Esempio n. 1
0
        /// <summary>
        /// Sets the material of the voxel at the given world position.
        /// </summary>
        /// <param name="worldPos"></param>
        /// <param name="val"></param>
        public void setMaterialFromWorldPos(Vector3 worldPos, byte val)
        {
            worldPos = worldPos - position;
            Vector3I arrayPos = new Vector3I((int)Math.Round(worldPos.x) / NodeManager.LODSize[LOD],
                                             (int)Math.Round(worldPos.y) / NodeManager.LODSize[LOD],
                                             (int)Math.Round(worldPos.z) / NodeManager.LODSize[LOD]);

            if (arrayPos.x < -1 || arrayPos.x > 17 ||
                arrayPos.y < -1 || arrayPos.y > 17 ||
                arrayPos.z < -1 || arrayPos.z > 17)
            {
                Debug.Log("Wrong node. " + arrayPos);
                return;
            }

            bool change = (densityChangeData.getMaterial(arrayPos.x, arrayPos.y, arrayPos.z) != val);

            densityChangeData.setMaterial(arrayPos.x, arrayPos.y, arrayPos.z, val);

            if (change)
            {
                setPermanence(true);
                hasDensityChangeData = true;
                MeshFactory.requestSave(this);
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Initializes the Quixel Engine
        /// </summary>
        /// <param name="mats">Array of materials.</param>
        /// <param name="terrainObj">Parent terrain object. (empty)</param>
        /// <param name="worldName">Name of the world. Used for paging. (empty)</param>
        public static void init(Material[] mats, GameObject terrainObj, string worldName)
        {
            MeshFactory.terrainObj = terrainObj;

            materials = mats;
            Debug.Log("Materials: " + mats.Length);
            DensityPool.init();
            MeshFactory.start();
            NodeManager.init(worldName);
        }
Esempio n. 3
0
 /// <summary>
 /// Regenerates the chunk without threading.
 /// </summary>
 public void regenerateChunk()
 {
     if (regenReq)
     {
         regenFlag = true;
     }
     else
     {
         MeshFactory.requestMesh(this);
         regenReq = true;
     }
 }
Esempio n. 4
0
        /// <summary>
        /// Updates the Quixel system. Should be called every step.
        /// </summary>
        public static void update()
        {
            DensityPool.update();
            MeshFactory.update();

            if (cameraObj != null)
            {
                NodeManager.setViewPosition(cameraObj.transform.position);
            }

            if (!Application.isPlaying)
            {
                active = false;
            }
        }
Esempio n. 5
0
        /// <summary>
        /// Sets the density of a point, given a world pos.
        /// </summary>
        /// <param name="worldPos"></param>
        public void setDensityFromWorldPos(Vector3 worldPos, float val)
        {
            worldPos = worldPos - position;
            Vector3I arrayPos = new Vector3I((int)(worldPos.x), (int)(worldPos.y), (int)(worldPos.z));

            if (arrayPos.x < -1 || arrayPos.x > 17 ||
                arrayPos.y < -1 || arrayPos.y > 17 ||
                arrayPos.z < -1 || arrayPos.z > 17)
            {
                Debug.Log("Wrong node. " + arrayPos);
                return;
            }

            densityChangeData.set(arrayPos.x, arrayPos.y, arrayPos.z, val);
            setPermanence(true);

            hasDensityChangeData = true;
            MeshFactory.requestSave(this);
        }
Esempio n. 6
0
        /// <summary>
        /// Continuously check if we have chunks to generate.
        /// </summary>
        private void generateLoop()
        {
            bool sleep = true;

            while (QuixelEngine.isActive())
            {
                sleep = false;

                MeshFactory.MeshRequest req = MeshFactory.getNextRequest();
                if (req == null)
                {
                    sleep = true;
                }
                else
                {
                    if (req.densities == null)
                    {
                        if (!req.hasDensities)
                        {
                            req.densities = DensityPool.getDensityData();
                        }
                        else
                        {
                            req.densities = req.node.densityData;
                        }
                    }

                    MeshFactory.GenerateMeshData(req);

                    lock (finishedQueue)
                        finishedQueue.Enqueue(req);
                }

                if (sleep)
                {
                    Thread.Sleep(30);
                }
                else
                {
                    Thread.Sleep(4);
                }
            }
        }
Esempio n. 7
0
        public Node(Node parent, Vector3 position, int subNodeID, int LOD, RenderType renderType)
        {
            densityChangeData = new DensityData();
            this.parent       = parent;
            this.position     = position;
            this.subNodeID    = subNodeID;
            this.LOD          = LOD;

            float chunkWidth = (NodeManager.LODSize[LOD] * NodeManager.nodeSize) / 2f;

            center = new Vector3(position.x + chunkWidth,
                                 position.y + chunkWidth,
                                 position.z + chunkWidth);

            setRenderType(renderType);

            if (parent != null && parent.permanent)
            {
                permanent = true;
            }

            NodeManager.nodeCount[LOD]++;

            float nWidth = NodeManager.LODSize[LOD] * NodeManager.nodeSize;

            chunkPos.x = (int)(center.x / nWidth);
            chunkPos.y = (int)(center.y / nWidth);
            chunkPos.z = (int)(center.z / nWidth);

            if (LOD == 0)
            {
                string dir = getDirectory();
                if (Directory.Exists(dir) && File.Exists(dir + "\\densities.txt"))
                {
                    MeshFactory.requestLoad(this);
                }
            }

            regenReq = true;
            MeshFactory.requestMesh(this);
        }
Esempio n. 8
0
        /// <summary>
        /// Sets the density of a point, given a world pos.
        /// </summary>
        /// <param name="worldPos"></param>
        public void setDensityFromWorldPos(Vector3 worldPos, float val)
        {
            worldPos = worldPos - position;
            Vector3I arrayPos = new Vector3I((int)Math.Round(worldPos.x) / NodeManager.LODSize[LOD],
                                             (int)Math.Round(worldPos.y) / NodeManager.LODSize[LOD],
                                             (int)Math.Round(worldPos.z) / NodeManager.LODSize[LOD]);

            if (arrayPos.x < -1 || arrayPos.x > 17 ||
                arrayPos.y < -1 || arrayPos.y > 17 ||
                arrayPos.z < -1 || arrayPos.z > 17)
            {
                Debug.Log("Wrong node. " + arrayPos + ":" + worldPos + ":" + containsDensityPoint(worldPos).ToString());
                return;
            }

            densityChangeData.set(arrayPos.x, arrayPos.y, arrayPos.z, val);
            setPermanence(true);

            hasDensityChangeData = true;
            MeshFactory.requestSave(this);
        }
Esempio n. 9
0
        /// <summary>
        /// Called when a mesh has been generated
        /// </summary>
        /// <param name="mesh">Mesh data</param>
        public void setMesh(MeshData meshData)
        {
            densityData.setChangeData(densityChangeData);

            regenReq = false;
            if (regenFlag)
            {
                regenFlag = false;
                regenReq  = true;
                MeshFactory.requestMesh(this);
            }

            hasMesh = true;
            if (meshData.indexArray.Length == 0)
            {
                return;
            }

            if (chunk == null)
            {
                chunk = ChunkPool.getChunk();
                if (LOD > 2)
                {
                    chunk.transform.position = position - new Vector3(0f, (NodeManager.LODSize[LOD] / 2f), 0f);
                }
                else
                {
                    chunk.transform.position = position;
                }

                //chunk.GetComponent<MeshFilter>().mesh.subMeshCount = QuixelEngine.materials.Length;
                chunk.GetComponent <MeshRenderer>().materials = QuixelEngine.materials;
            }

            empty = false;
            Mesh mesh = new Mesh();

            mesh.subMeshCount = QuixelEngine.materials.Length;
            mesh.vertices     = meshData.triangleArray;

            for (int i = 0; i < QuixelEngine.materials.Length; i++)
            {
                if (meshData.indexArray[i].Length > 0)
                {
                    mesh.SetTriangles(meshData.indexArray[i], i);
                }
            }
            //mesh.triangles = meshData.indexArray;
            mesh.uv = meshData.uvArray;

            mesh.normals = meshData.normalArray;
            //mesh.RecalculateBounds();
            mesh.Optimize();

            chunk.GetComponent <MeshFilter>().mesh = mesh;

            if (LOD == 0 && collides)
            {
                chunk.GetComponent <MeshCollider>().sharedMesh = mesh;
            }
            meshData.dispose();

            renderCheck();
            switch (renderType)
            {
            case RenderType.BACK:
                if (chunk != null)
                {
                    chunk.layer = 9;
                }
                break;

            case RenderType.FRONT:
                if (chunk != null)
                {
                    chunk.layer = 8;
                }
                break;
            }
            if (parent != null)
            {
                parent.renderCheck();
            }
        }
Esempio n. 10
0
 /// <summary>
 /// Queue a mesh for generation.
 /// </summary>
 /// <param name="req"></param>
 public void queueGenerateMesh(MeshFactory.MeshRequest req)
 {
     lock (genQueue)
         genQueue.Enqueue(req);
 }