Ejemplo n.º 1
0
        public static VoxelChunk Create(Transform parent, string name, GeneratorSettings settings, int maxWidth, int maxHeight)
        {
            GameObject go = new GameObject(name);

            go.transform.SetParent(parent, false);

            VoxelChunk chunk = go.AddComponent <VoxelChunk>();

            chunk.Initialize(settings, maxWidth, maxHeight);

            return(chunk);
        }
Ejemplo n.º 2
0
        public void Initialize(GeneratorSettings settings, int maxWidth, int maxHeight)
        {
            nextPosition = transform.position;

            m_maxWidth  = maxWidth;
            m_maxHeight = maxHeight;
            m_settings  = settings;

            // Initialize mesh
            m_mesh      = new Mesh();
            m_mesh.name = name + "_Mesh";
            m_mesh.MarkDynamic();

            MeshFilter filter = gameObject.AddComponent <MeshFilter>();

            m_renderer = gameObject.AddComponent <MeshRenderer>();

            filter.sharedMesh         = m_mesh;
            m_renderer.sharedMaterial = m_settings.fillMaterial;

            if (m_settings.generateCollision)
            {
                m_meshCollision      = new Mesh();
                m_meshCollision.name = name + "_CollisionMesh";
                m_meshCollision.MarkDynamic();

                m_meshCollision.bounds = m_mesh.bounds;

                m_collider                = gameObject.AddComponent <MeshCollider>();
                m_collider.sharedMesh     = m_meshCollision;
                m_collider.convex         = false;
                m_collider.cookingOptions = m_settings.colliderCookingOptions;
            }

            if (m_settings.meshContour)
            {
                GameObject contour = new GameObject("Contour");
                contour.transform.parent        = transform;
                contour.transform.localPosition = Vector3.zero;
                contour.transform.localScale    = Vector3.one;
                contour.transform.localRotation = Quaternion.identity;

                m_meshContour      = new Mesh();
                m_meshContour.name = name + "_MeshContour";
                m_meshContour.MarkDynamic();

                m_meshContour.bounds = m_mesh.bounds;

                MeshFilter contourFilter = contour.AddComponent <MeshFilter>();
                contourFilter.sharedMesh = m_meshContour;

                m_rendererContour = contour.AddComponent <MeshRenderer>();
                m_rendererContour.sharedMaterial = settings.outlineMaterial;
            }

            // Initialize chunk data
            m_meshOut       = new MeshOutput();
            m_meshOut.verts = new List <Vector3>();
            m_meshOut.tris  = new List <int>();
            m_meshOut.uvs   = new List <Vector2>();

            if (m_settings.generateNormals)
            {
                m_meshOut.normals = new List <Vector3>();
            }

            // Initialize temp buffers
            m_meshOut.batched  = new bool[m_maxWidth * m_maxHeight];
            m_meshOut.contours = new List <List <Vector2> >();

            // Contour buffers
            if (m_settings.meshContour)
            {
                m_meshOut.contourVerts = new List <Vector3>();
                m_meshOut.contourTris  = new List <int>();
                m_meshOut.contourUVs   = new List <Vector2>();

                if (m_settings.generateNormals)
                {
                    m_meshOut.contourNormals = new List <Vector3>();
                }
            }

            // Collision buffers
            if (m_settings.generateCollision)
            {
                m_meshOut.collisionVerts = new List <Vector3>();
                m_meshOut.collisionTris  = new List <int>();
            }
        }