Working node network ;)

Daxode · Daxode · commit bcbd0e38db62 · 2020-11-01T14:29:32.000+01:00
diff --git a/Blobtory/Scripts/planet_former/CubeFormer.py b/Blobtory/Scripts/planet_former/CubeFormer.py
@@ -13,7 +13,8 @@ class CubeFormer:
     radius = PTAFloat([0])
     isWater = False
 
-    def __init__(self, winCreator: WindowCreator, width: int, length: int, height: int, spacing: float):
+    def __init__(self, winCreator: WindowCreator, name: str, width: int, length: int, height: int, spacing: float):
+        self.name = name
         self.winCreator = winCreator
         self.size = LVecBase3i(width, length, height)
         self.spacing = spacing
@@ -23,7 +24,7 @@ def __init__(self, winCreator: WindowCreator, width: int, length: int, height: i
 
     def GenerateCube(self) -> Texture:
         if self.vertexBuffer is None:
-            self.vertexBuffer = deepcopy(Texture("vertex buffer"))
+            self.vertexBuffer = deepcopy(Texture("vertex buffer"+self.name))
             self.vertexBuffer.setup_3d_texture(self.size[0], self.size[1], self.size[2], Texture.T_float, Texture.F_rgba32)
 
         if self.__cubeBufferCreatorComputeNode is None:
diff --git a/Blobtory/Scripts/planet_former/MarchingCubes.py b/Blobtory/Scripts/planet_former/MarchingCubes.py
@@ -25,7 +25,6 @@ def __init__(self, cubeformer: CubeFormer):
         self.cubeformer = cubeformer
         self.winCreator = cubeformer.winCreator
         self.size = cubeformer.size
-        self.cubeVertexBuffer = cubeformer.vertexBuffer
         self.edgeVertexCount = self.cubeformer.vertexCount*3
 
     def EdgeGenerator(self) -> Texture:
@@ -42,7 +41,7 @@ def EdgeGenerator(self) -> Texture:
             self.edgeBufferGeneratorNode.set_shader(shader)
             self.edgeBufferGeneratorNode.set_shader_input("isoLevel", 0.5)
             self.edgeBufferGeneratorNode.set_shader_input("size", self.size)
-            self.edgeBufferGeneratorNode.set_shader_input("vertexBufferWAlphaCube", self.cubeVertexBuffer)
+            self.edgeBufferGeneratorNode.set_shader_input("vertexBufferWAlphaCube", self.cubeformer.vertexBuffer)
             self.edgeBufferGeneratorNode.set_shader_input("vertexBufferEdge", self.edgeVertexBuffer)
 
         yass = LVecBase3i(math.ceil(self.size[0]*3 / 16), math.ceil(self.size[1] / 8), math.ceil(self.size[2] / 8))
@@ -54,7 +53,7 @@ def EdgeGenerator(self) -> Texture:
 
     def MarchCube(self):
         if self.atomic is None:
-            self.atomic = copy(Texture("atomic int"))
+            self.atomic = deepcopy(Texture("atomic int"))
             self.atomic.setupBufferTexture(1, Texture.T_int, Texture.F_r32i, GeomEnums.UH_dynamic)
 
         if self.triangleBuffer is None:
@@ -83,7 +82,7 @@ def MarchCube(self):
             self.cubeMarchBufferGeneratorNode.set_shader_input("size", self.size)
             self.cubeMarchBufferGeneratorNode.set_shader_input("triagIndexBuffer", self.atomic)
 
-            self.cubeMarchBufferGeneratorNode.set_shader_input("vertexBufferWAlphaCube", self.cubeVertexBuffer)
+            self.cubeMarchBufferGeneratorNode.set_shader_input("vertexBufferWAlphaCube", self.cubeformer.vertexBuffer)
             self.cubeMarchBufferGeneratorNode.set_shader_input("vertexBufferEdge", self.edgeVertexBuffer)
             self.cubeMarchBufferGeneratorNode.set_shader_input("triangleBuffer", self.triangleBuffer)
             self.cubeMarchBufferGeneratorNode.set_shader_input("triangulationBuffer", self.triangulationBuffer)
@@ -122,18 +121,18 @@ def GenerateMesh(self):
             self.winCreator.base.render.find("**/node").removeNode()
 
         self.geomPath = self.winCreator.base.render.attach_new_node(node)
-        self.geomPath.setPos(
-            -self.size.getX()*0.5*self.cubeformer.spacing,
-            -self.size.getY()*0.5*self.cubeformer.spacing,
-            -self.size.getZ()*0.5*self.cubeformer.spacing)
+        # self.geomPath.setPos(
+        #     -self.size.getX()*0.5*self.cubeformer.spacing,
+        #     -self.size.getY()*0.5*self.cubeformer.spacing,
+        #     -self.size.getZ()*0.5*self.cubeformer.spacing)
 
         self.winCreator.pipelineSwitcher.AddModelWithShaderGeneralName(self.geomPath, "assets/shaders/planets/planet")
         self.geomPath.set_shader_input('vertexBufferEdge', self.edgeVertexBuffer)
         self.geomPath.set_shader_input('triangleBuffer', self.triangleBuffer)
         self.geomPath.set_shader_input('normalBuffer', self.normalBuffer)
 
         myMaterial = Material()
-        myMaterial.setShininess(0.8)  # Make this material shiny
+        myMaterial.setShininess(0.4)  # Make this material shiny
         self.geomPath.setMaterial(myMaterial)
 
         myMarchCubeMatsTex = self.winCreator.base.loader.loadTexture(
diff --git a/Blobtory/Scripts/planet_former/PlanetGenerator.py b/Blobtory/Scripts/planet_former/PlanetGenerator.py
@@ -1,38 +1,41 @@
-from panda3d.core import PTAFloat
+import array
+
+from direct.task import Task
+from panda3d.core import PTAFloat, LVecBase3f
+import numpy as np
+from typing import Dict
+import cv2
+import copy
 
 from Blobtory.Scripts.Pipeline.WindowCreator import WindowCreator
 from Blobtory.Scripts.planet_former.CubeFormer import CubeFormer
 from Blobtory.Scripts.planet_former.MarchingCubes import MarchingCubes
 from Blobtory.Scripts.Pipeline.PipelineInstancing import PipelineInstancing
 
+
 class PlanetGenerator:
+    shouldUpdatePhysicsMeshes = False
+    nodeDict: Dict = {}
+    listOfItems = None
+
     def __init__(self, winCreator: WindowCreator, gridSize: int, radius: float):
         self.radius = radius
         self.winCreator = winCreator
 
         # Setup Mesh
-        self.cubeformer: CubeFormer = CubeFormer(self.winCreator, gridSize, gridSize, gridSize, winCreator.cubeSpacing)
+        self.cubeformer: CubeFormer = CubeFormer(self.winCreator, "Normal", gridSize, gridSize, gridSize, winCreator.cubeSpacing)
         self.cubeformer.GenerateCube()
-        self.cubeformer.GenerateNoiseSphere(self.radius)
-
         self.marchingCubes: MarchingCubes = MarchingCubes(self.cubeformer)
-        self.marchingCubes.EdgeGenerator()
-        self.marchingCubes.MarchCube()
-        self.marchingCubes.GenerateMesh()
 
         # Setup Navigation Mesh
-        self.cubeformerNav: CubeFormer = CubeFormer(self.winCreator, gridSize//4, gridSize//4, gridSize//4, winCreator.cubeSpacing*4)
+        self.cubeformerNav: CubeFormer = CubeFormer(self.winCreator, "Navigation", gridSize//8, gridSize//8, gridSize//8, winCreator.cubeSpacing*8)
         self.cubeformerNav.GenerateCube()
-        self.cubeformerNav.GenerateNoiseSphere(self.radius)
-
         self.marchingCubesNav: MarchingCubes = MarchingCubes(self.cubeformerNav)
-        self.marchingCubesNav.EdgeGenerator()
-        self.marchingCubesNav.MarchCube()
 
         # Setup Water Mesh
-        self.cubeformerWater: CubeFormer = CubeFormer(self.winCreator, gridSize//4, gridSize//4, gridSize//4, winCreator.cubeSpacing*4)
+        self.cubeformerWater: CubeFormer = CubeFormer(self.winCreator, "Water", gridSize//4, gridSize//4, gridSize//4, winCreator.cubeSpacing*4)
         self.cubeformerWater.GenerateCube()
-        self.cubeformerWater.mouseTime.setData(PTAFloat([10, 0, 0, 10.1]))
+        self.cubeformerWater.mouseTime.setData(PTAFloat([10, 0, 0, 6.1]))
         self.cubeformerWater.GenerateNoiseSphere(self.radius * 0.98)
         self.cubeformerWater.isWater = True
 
@@ -41,6 +44,9 @@ def __init__(self, winCreator: WindowCreator, gridSize: int, radius: float):
         self.marchingCubesWater.MarchCube()
         self.marchingCubesWater.GenerateMesh()
 
+        self.sphere = self.winCreator.base.loader.loadModel("assets/models/icosphere")
+        self.sphere2 = self.winCreator.base.loader.loadModel("assets/models/icosphere")
+
         # sphere = self.winCreator.base.loader.loadModel("assets/models/icosphere")
         # PipelineInstancing.RenderThisModelAtVertexesFrom3DBuffer(sphere, self.cubeformer.vertexBuffer,
         #                                                        self.cubeformer.size, self.winCreator)
@@ -49,15 +55,87 @@ def __init__(self, winCreator: WindowCreator, gridSize: int, radius: float):
         # PipelineInstancing.RenderThisModelAtVertexesFrom3DBuffer(box, self.cubeformerNav.vertexBuffer,
         #                                                          self.cubeformerNav.size, self.winCreator)
 
+        self.RegenPlanet()
+        # self.winCreator.base.taskMgr.setupTaskChain('physics', numThreads=1)
+        self.winCreator.base.taskMgr.doMethodLater(1, self.UpdatePhysicsMesh, "Planet Physics Updater"''', taskChain="physics"''')
+        self.winCreator.base.accept("r", self.TryNavmesh)
+        self.winCreator.base.accept("r-repeat", self.TryNavmesh)
+
+    def TryNavmesh(self):
+        examplePoint = next(self.listOfItems)
+        neighbourPoints = self.nodeDict[examplePoint]
+
+        self.sphere2.reparentTo(self.winCreator.base.render)
+        self.sphere2.setScale(10)
+        self.sphere2.setPos(examplePoint[0], examplePoint[1], examplePoint[2])
+        print(examplePoint, neighbourPoints)
+
+        # PipelineInstancing.RenderThisModelAtVertexesFrom3DBuffer(sphere, self.marchingCubesNav.edgeVertexBuffer, self.marchingCubesNav.size, self.winCreator)
+        PipelineInstancing.RenderThisModelAtVertexes(self.sphere, list(neighbourPoints), self.winCreator)
+
     def RegenPlanet(self):
         self.winCreator.baseData.debuggerPlanetFormer.Inform("Regenerating planet")
-
         self.cubeformerNav.GenerateNoiseSphere(self.radius)
-        self.marchingCubesNav.EdgeGenerator()
-        self.marchingCubesNav.MarchCube()
-        self.marchingCubesNav.GenerateMesh()
-
         self.cubeformer.GenerateNoiseSphere(self.radius)
+        self.UpdatePlanet()
+
+    def UpdatePlanet(self):
         self.marchingCubes.EdgeGenerator()
         self.marchingCubes.MarchCube()
-        self.marchingCubes.GenerateMesh()
+        #self.marchingCubes.GenerateMesh()
+        self.shouldUpdatePhysicsMeshes = True
+
+    def UpdatePhysicsMesh(self, task):
+        if self.shouldUpdatePhysicsMeshes:
+            # Generate marching
+            self.marchingCubesNav.EdgeGenerator()
+            self.marchingCubesNav.MarchCube()
+            self.marchingCubesNav.GenerateMesh()
+
+            # Extract Mesh Data (Tri Indexes and Vertexes)
+            self.winCreator.base.graphicsEngine.extractTextureData(self.marchingCubesNav.edgeVertexBuffer,
+                                                                   self.winCreator.base.win.gsg)
+            ramImageVertex = self.marchingCubesNav.edgeVertexBuffer.getRamImage()
+            output = np.frombuffer(ramImageVertex, dtype=np.float32)
+            output: np.ndarray = output.reshape((self.marchingCubesNav.size[2],
+                                     self.marchingCubesNav.size[1],
+                                     self.marchingCubesNav.size[0]*3, 4))
+
+            self.winCreator.base.graphicsEngine.extractTextureData(self.marchingCubesNav.triangleBuffer,
+                                                                   self.winCreator.base.win.gsg)
+            ramImage = self.marchingCubesNav.triangleBuffer.getRamImage()
+            outputTriangle = memoryview(ramImage).cast("i")
+
+            # Restructure that data to be a node network instead using a dictionary
+            outputR = map(tuple, output.reshape((self.marchingCubesNav.size[0]*3 *
+                                     self.marchingCubesNav.size[1] *
+                                     self.marchingCubesNav.size[2], 4)))
+            self.nodeDict = dict((el, set([])) for el in outputR)
+            del outputR
+
+            buffer = np.empty(12, dtype=int)
+
+            triagIndexCount = self.marchingCubesNav.vertexCount * 4
+            for count, x in enumerate(outputTriangle):
+                buffer[count % 12] = x
+                if count % 12 == 11:
+                    print(output.shape, buffer)
+                    v1 = tuple(output[buffer[2], buffer[1], buffer[0]])
+                    v2 = tuple(output[buffer[6], buffer[5], buffer[4]])
+                    v3 = tuple(output[buffer[10], buffer[9], buffer[8]])
+
+                    self.nodeDict[v1].add(v2)
+                    self.nodeDict[v1].add(v3)
+
+                    self.nodeDict[v2].add(v1)
+                    self.nodeDict[v2].add(v3)
+
+                    self.nodeDict[v3].add(v2)
+                    self.nodeDict[v3].add(v1)
+
+                if count > triagIndexCount:
+                    break
+            self.listOfItems = (item[0] for item in self.nodeDict.items() if len(item[1]) > 0)
+
+            self.shouldUpdatePhysicsMeshes = False
+        return Task.again
diff --git a/assets/shaders/compute/cubemarcher.glsl b/assets/shaders/compute/cubemarcher.glsl
@@ -65,14 +65,14 @@ void main() {
         vec3 v1 = imageLoad(vertexBufferEdge, vertexID.xyz).xyz;
 
         ivec4 globalIndexForC = globalEdgeFromLocal[imageLoad(triangulationBuffer, ivec2(i+2, cubeIndex)).x];
-        vertexID = ivec4(id+globalIndexForC.xyz+(ivec3(size.x, 0, 0)*globalIndexForC.w), cubeIndex);
+        vertexID = ivec4(id+globalIndexForC.xyz+(ivec3(size.x, 0, 0)*globalIndexForC.w), 0);
         imageStore(triangleBuffer, triangleIDIndex+2, vertexID);
         vec3 v2 = imageLoad(vertexBufferEdge, vertexID.xyz).xyz;
 
         vec3 normal = normalize(cross(v2-v0, v1-v0));
         //vec3 normal = normalize(v2+v0+v1);
         int type = int(distance(vec3(512), v1)/51);
-        if (isWater) type = 13;
+        if (isWater) type = 13; //int(sin(dot(normal,vec3(1)))*1+13);
         // if(type > 7) if(dot(normalize(vec3(512)-v1), normal)<0.5) type = 6;
         imageStore(normalBuffer, int(triangleIDIndex/3), vec4(normal, type));
 
