Cleaning

koptilnya/mesh_loader/cl_builder.txt

@@ -6,20 +6,29 @@ require("obj_parser.txt")
 
 MeshBuilder = class("MeshBuilder")
 
-function MeshBuilder:initialize(link, maxQuota)
+function MeshBuilder:initialize(link)
     self.link = link
     self.meshData = {}
 
     self._objects = {}
-    self._parser = ObjParser:new(link, maxQuota)
-    self._parser.onLoaded = function(parser, objData, meshData, usedTriangles)
+    self._parser = ObjParser:new(link)
+    self._parser.onLoaded = function(parser, objData)
+        self:onObjLoaded(objData)
+    end
+    self._parser.onParsed = function(parser, meshData, usedTriangles)
+        net.start("obj_parsed")
+        net.send()
+
+        self:onObjParsed(meshData, usedTriangles)
+
         self.meshData = meshData
 
-        net.start("ready")
-        net.send()
+        self:_applyMeshes()
     end
 
-    net.receive("holograms", function()
+    net.receive("objects", function()
+        self._objects = {}
+
         local hasNext = net.readBit()
 
         while hasNext == 1 do
@@ -27,17 +36,17 @@ function MeshBuilder:initialize(link, maxQuota)
 
             net.readEntity(function(ent)
                 local holo = ent:toHologram()
+                local object = {name = name, holo = holo}
 
-                table.insert(self._objects, {name = name, holo = holo})
+                table.insert(self._objects, object)
             end)
 
             hasNext = net.readBit()
         end
-        
-        self:_applyMeshes()
-        
-        timer.simple(0, function()
+
+        timer.simple(0.5, function()
             self:onHologramsReceived(self._objects)
+            self:_applyMeshes()
         end)
     end)
 end
@@ -47,9 +56,25 @@ function MeshBuilder:_applyMeshes()
         if self.meshData[v.name] ~= nil then
             v.holo:setMesh(self.meshData[v.name])
             v.holo:setRenderBounds(Vector(-200), Vector(200))
+            v.meshApplied = true
         end
     end
+
+    if #self._objects > 0 then
+        self:onMeshesApplied()
+    end
+end
+
+-- STUB
+
+function MeshBuilder:onObjLoaded(objData)
+end
+
+function MeshBuilder:onObjParsed(meshData, usedTriangles)
 end
 
 function MeshBuilder:onHologramsReceived(objects)
 end
+
+function MeshBuilder:onMeshesApplied()
+end

koptilnya/mesh_loader/obj_parser.txt

@@ -1,4 +1,7 @@
 -- @client
+-- @include /koptilnya/libs/workers.txt
+require("/koptilnya/libs/workers.txt")
+
 ObjParser = class("ObjParser")
 
 local initialChipName = chip():getChipName()
@@ -6,35 +9,44 @@ local function setStatus(status)
     setName(string.format("%s (%s)", initialChipName, status))
 end
 
-function ObjParser:initialize(link, maxQuota)
-    self.maxQuota = maxQuota or 0.6
+function ObjParser:initialize(link)
+    addWorker(coroutine.wrap(function()
+        setStatus("Getting file...")
 
-    local triangles = mesh.trianglesLeft()
+        while not http.canRequest() do
+            coroutine.yield(1)
+        end
 
-    setStatus("Getting file...")
-    http.get(link, function(objData)
-        objData = string.gsub(objData, "\nl%s%d+%s%d+", "")
-
-        local loadMesh = coroutine.wrap(function()
-            self.meshData = mesh.createFromObj(objData, true, true)
-
-            return true
+        local objData
+        http.get(link, function(response)
+            objData = response
+            objData = string.gsub(response, "\nl%s%d+%s%d+", "")
         end)
 
+        while not objData do
+            coroutine.yield(1)
+        end
+
+        self:onLoaded(objData)
+
+        local triangles = mesh.trianglesLeft()
+
         setStatus("File received, start parsing...")
-        hook.add("think", "loadingMesh", function()
-            while math.max(quotaAverage(), quotaUsed()) < quotaMax() * self.maxQuota do
-                if loadMesh() then
-                    setName(initialChipName)
-                    self:onLoaded(objData, self.meshData, triangles - mesh.trianglesLeft())
-                    hook.remove("think", "loadingMesh")
 
-                    return
-                end
-            end
-        end)
-    end)
+        self.meshData = mesh.createFromObj(objData, true)
+
+        self:onParsed(self.meshData, triangles - mesh.trianglesLeft())
+
+        setName(initialChipName)
+
+        return 2
+    end))
 end
 
-function ObjParser:onLoaded(objData, meshData, usedTriangles)
+-- STUB
+
+function ObjParser:onLoaded(objData)
+end
+
+function ObjParser:onParsed(meshData, usedTriangles)
 end

koptilnya/mesh_loader/sv_builder.txt

@@ -1,54 +1,99 @@
 -- @server
+-- @include /koptilnya/libs/workers.txt
+require("/koptilnya/libs/workers.txt")
+
 MeshBuilder = class("MeshBuilder")
 
 function MeshBuilder:initialize(link, modelPlaceholder)
     self.link = link
     self.modelPlaceholder = modelPlaceholder or "models/holograms/cube.mdl"
-    self.isReady = false
 
     self._objectsNames = {}
     self._objects = {}
-    self._readyPlayers = {}
+    self._objectsToSend = {}
+    self._firstTimePlayers = find.allPlayers()
+    self._firstTimeSended = false
 
-    http.get(link, function(response)
-        for object in string.gmatch(response, "^?\n?o%s([%w_%.%-]+)") do
+    net.receive("obj_parsed", function(len, ply)
+        self:onPlayerParsedObj(ply)
+    end)
+
+    hook.add("ClientInitialized", "MeshBuilder_ClientInitialized", function(ply)
+        if #self._firstTimePlayers > 0 then
+            table.removeByValue(self._firstTimePlayers, ply)
+
+            if #self._firstTimePlayers == 0 then
+                self:_sendObjects(find.allPlayers())
+
+                self._firstTimeSended = true
+            end
+        else
+            self:_sendObjects(ply)
+        end        
+    end)
+
+    hook.add("PlayerConnected", "MeshBuilder_PlayerConnected", function(ply)
+        if not self._firstTimeSended then
+            table.insert(self._firstTimePlayers, ply)
+        end
+    end)
+
+    hook.add("PlayerDisconnected", "MeshBuilder_PlayerDisconnected", function(ply)
+        table.removeByValue(self._firstTimePlayers, ply)
+    end)
+
+    addWorker(coroutine.wrap(function()
+        while not http.canRequest() do
+            coroutine.yield(1)
+        end
+
+        local objData
+        http.get(link, function(response)
+            objData = response
+        end)
+
+        while not objData do
+            coroutine.yield(1)
+        end
+
+        self:onObjectLoaded(objData)
+
+        for object in string.gmatch(objData, "^?\n?o%s([%w_%.%-]+)") do
             table.insert(self._objectsNames, object)
         end
 
-        
-        timer.simple(0, function()
-            self.isReady = true
-            self:onReady(self._objectsNames)
-        end)
+        self:onObjectParsed(self._objectsNames)
 
-        for _, v in pairs(self._readyPlayers) do
-            self:_sendHolograms(v)
-        end
-    end)
-
-    net.receive("ready", function(len, ply)
-        table.insert(self._readyPlayers, ply)
-
-        self:_sendHolograms(ply)
-    end)
+        return 2
+    end))
 end
 
-function MeshBuilder:_sendHolograms(ply)
-    if #self._objects == 0 then
+function MeshBuilder:_sendObjects(target)
+    if #self._objectsToSend == 0 then
         return
     end
 
-    net.start("holograms")
-    for _, v in pairs(self._objects) do
+    if type(target) == "table" and #target == 0 or type(target) == "Player" then
+        return
+    end
+
+    net.start("objects")
+    for _, v in pairs(self._objectsToSend) do
         net.writeBit(1)
         net.writeString(v.name)
         net.writeEntity(v.holo)
     end
     net.writeBit(0)
-    net.send(ply)
+    net.send(target)
 end
 
-function MeshBuilder:onReady(objectsNames)
+function MeshBuilder:reset()
+    for _, v in pairs(self._objects) do
+        v.holo:remove()
+    end
+
+    self._objects = {}
+    self._objectsToSend = {}
 end
 
 function MeshBuilder:build(name, pos, ang, scale, color, mat, parent, relativeTo)
@@ -66,12 +111,27 @@ function MeshBuilder:build(name, pos, ang, scale, color, mat, parent, relativeTo
     end
 
     table.insert(self._objects, {name = name, holo = holo})
-    
-    return name, holo
+
+    return holo
 end
 
-function MeshBuilder:buildAll(pos, ang, scale, color, mat, parent, relativeTo)
-    for _, v in pairs(self._objectsNames) do
-        self:build(v, pos, ang, scale, color, mat, parent, relativeTo)
+function MeshBuilder:getResult()
+    table.copyFromTo(self._objects, self._objectsToSend)
+
+    if self._firstTimeSended then
+        self:_sendObjects()
     end
+
+    return self._objectsToSend
+end
+
+-- STUB
+
+function MeshBuilder:onObjectLoaded(objData)
+end
+
+function MeshBuilder:onObjectParsed(objectsNames)
+end
+
+function MeshBuilder:onPlayerParsedObj(ply)
 end