Esempio n. 1
0
 public Block(BlockType _type, MeshOrder _meshOrder, bool _solid, bool _opaque)
 {
     Type   = _type;
     Order  = _meshOrder;
     Solid  = _solid;
     Opaque = _opaque;
 }
Esempio n. 2
0
        private void OnCombineMesh()
        {
            RichText[]  texts     = GetComponentsInChildren <RichText>(false);
            RichImage[] images    = GetComponentsInChildren <RichImage>(false);
            var         meshCount = texts.Length + images.Length;

            if (meshCount == 0)
            {
                if (m_meshRender)
                {
                    m_meshRender.enabled = false;
                }
                return;
            }

            if (m_meshRender == null)
            {
                m_meshRender           = gameObject.GetOrAddComponent <MeshRenderer>();
                m_meshRender.hideFlags = MeshHideflags;

                m_meshFilter           = gameObject.GetOrAddComponent <MeshFilter>();
                m_meshFilter.hideFlags = MeshHideflags;

                m_mesh = new Mesh();
                m_mesh.MarkDynamic();
                m_mesh.hideFlags = MeshHideflags;
            }

            Material material = null;

            var meshes = ListPool <MeshOrder> .Get();

            var worldToLocalMatrix = this.transform.worldToLocalMatrix;

            for (int i = 0; i < images.Length; ++i)
            {
                var image = images[i];

                if (!image.IsActive())
                {
                    continue;
                }

                var mesh = image.Mesh();
                if (mesh == null)
                {
                    continue;
                }

                var meshOrder = new MeshOrder();
                meshOrder.mesh   = mesh;
                meshOrder.matrix = worldToLocalMatrix * image.transform.localToWorldMatrix;
                meshOrder.z      = image.transform.localPosition.z;

                meshes.Add(meshOrder);

                if (material == null)
                {
                    material = image.material;
                }
            }
            for (int j = 0; j < texts.Length; ++j)
            {
                var text = texts[j];

                if (!text.IsActive())
                {
                    continue;
                }

                var mesh = text.Mesh();
                if (mesh == null)
                {
                    continue;
                }

                var meshOrder = new MeshOrder();
                meshOrder.mesh   = mesh;
                meshOrder.matrix = worldToLocalMatrix * text.transform.localToWorldMatrix;
                meshOrder.z      = text.transform.localPosition.z;

                meshes.Add(meshOrder);

                if (material == null)
                {
                    material = text.material;
                }
            }

            if (meshes.Count == 0)
            {
                if (m_meshRender)
                {
                    m_meshRender.enabled = false;
                }
                return;
            }
            m_meshRender.enabled = true;

            meshes.Sort((lhs, rhs) => rhs.z.CompareTo(lhs.z));

            CombineInstance[] combine = new CombineInstance[meshes.Count];
            for (int i = 0; i < meshes.Count; ++i)
            {
                combine[i].mesh      = meshes[i].mesh;
                combine[i].transform = meshes[i].matrix;
            }

            ListPool <MeshOrder> .Release(meshes);

            m_mesh.CombineMeshes(combine, true);
            m_meshFilter.sharedMesh     = m_mesh;
            m_meshRender.sharedMaterial = material;
        }
 public CodeMeshedBlock(BlockType _type, MeshOrder _meshOrder, int AtlasIndexUp, int AtlasIndexDown, int AtlasIndexSides, bool _solid, bool _opaque)
     : base(_type, _meshOrder, _solid, _opaque)
 {
     UVs = TextureAtlas.GenerateUVs(AtlasIndexUp, AtlasIndexDown, AtlasIndexSides);
 }
 public CodeMeshedBlock(BlockType _type, MeshOrder _meshOrder, int AtlasIndex, bool _solid, bool _opaque) :
     this(_type, _meshOrder, AtlasIndex, AtlasIndex, AtlasIndex, _solid, _opaque)
 {
 }
 public LoadedMeshBlock(BlockType _type, MeshOrder _meshOrder, bool _solid, bool _opaque)
     : base(_type, _meshOrder, _solid, _opaque)
 {
     mesh = BlockMeshingManager.Get.typeToMesh.FirstOrDefault(nM => nM.type == _type).mesh;
     Debug.Assert(mesh != null, "Mesh type not found in dictionary, add it to BlockMeshingManager");
 }