コード例 #1
0
        public override void GetRenderElementsForShadowmap(MyLodTypeEnum lodTypeEnum, List <MyRender.MyRenderElement> renderElements, List <MyRender.MyRenderElement> transparentRenderElements)
        {
            if (MyRender.Settings.SkipVoxels)
            {
                return;
            }


            //  Get non-empty render cells visible to the frustum and sort them by distance to camera
            MyRender.GetRenderProfiler().StartProfilingBlock("GetElements from MyVoxelMap");

            foreach (MyRenderVoxelBatch batch in m_batches)
            {
                if (batch.IndexCount == 0)
                {
                    continue;
                }

                MyRender.MyRenderElement renderElement;
                MyRender.AllocateRenderElement(out renderElement);

                if (!MyRender.IsRenderOverloaded)
                {
                    SetupRenderElement(batch, renderElement);
                    renderElement.Dithering = 0;

                    renderElements.Add(renderElement);
                }
            }

            MyRender.GetRenderProfiler().EndProfilingBlock();
        }
コード例 #2
0
        public override void GetRenderElements(MyLodTypeEnum lodTypeEnum, List <MyRender.MyRenderElement> elements, List <MyRender.MyRenderElement> transparentElements)
        {
            if (MyRender.Settings.SkipVoxels)
            {
                return;
            }

            Debug.Assert(lodTypeEnum == MyLodTypeEnum.LOD0);

            foreach (MyRenderVoxelBatch batch in m_batches)
            {
                if (batch.IndexBuffer == null)
                {
                    continue;
                }

                MyRender.MyRenderElement renderElement;
                MyRender.AllocateRenderElement(out renderElement);

                if (!MyRender.IsRenderOverloaded)
                {
                    //renderElement.DebugName = this.Name;
                    SetupRenderElement(batch, renderElement);

                    renderElement.DrawTechnique = MyMeshDrawTechnique.VOXEL_MAP;
                    renderElement.Material      = m_fakeVoxelMaterial;

                    elements.Add(renderElement);
                }
                else if (renderElement == null)
                {
                    break;
                }
            }
        }
コード例 #3
0
        public override void GetRenderElements(MyLodTypeEnum lodTypeEnum, List <MyRender.MyRenderElement> elements, List <MyRender.MyRenderElement> transparentElements)
        {
            foreach (var mesh in m_meshes)
            {
                mesh.Material.PreloadTexture(LoadingMode.Background);

                MyRender.MyRenderElement renderElement;
                MyRender.AllocateRenderElement(out renderElement);

                if (!MyRender.IsRenderOverloaded)
                {
                    //renderElement.DebugName = entity.Name;
                    renderElement.RenderObject = this;

                    renderElement.VertexBuffer      = m_vertexBuffer;
                    renderElement.IndexBuffer       = m_indexBuffer;
                    renderElement.VertexCount       = m_vertexCount;
                    renderElement.VertexDeclaration = m_vertexDeclaration;
                    renderElement.VertexStride      = m_vertexStride;
                    renderElement.InstanceBuffer    = null;

                    renderElement.IndexStart = mesh.IndexStart;
                    renderElement.TriCount   = mesh.TriangleCount;

                    renderElement.WorldMatrixForDraw = GetWorldMatrixForDraw();
                    renderElement.WorldMatrix        = WorldMatrix;

                    renderElement.Material      = mesh.Material;
                    renderElement.DrawTechnique = mesh.Material.DrawTechnique;
                    renderElement.Color         = new Vector3(1, 1, 1);
                    renderElement.Dithering     = 0;

                    Debug.Assert(renderElement.VertexBuffer != null, "Vertex buffer cannot be null!");
                    Debug.Assert(renderElement.IndexBuffer != null, "Index buffer cannot be null!");

                    elements.Add(renderElement);
                }
            }
        }
コード例 #4
0
        public override void GetRenderElementsForShadowmap(MyLodTypeEnum lodTypeEnum, List <MyRender.MyRenderElement> renderElements, List <MyRender.MyRenderElement> transparentRenderElements)
        {
            MyRenderModel model;

            int lodIndex = m_lods.Count > (int)lodTypeEnum ? (int)lodTypeEnum : 0;

            if (ShadowBoxLod && lodTypeEnum == MyLodTypeEnum.LOD1)
            {
                model = MyDebugDraw.ModelBoxLowRes;
            }
            else
            {
                model = m_lods[lodIndex].ShadowModel == null ? m_lods[lodIndex].Model : m_lods[lodIndex].ShadowModel;
            }

            if (model == null || model.LoadState != LoadState.Loaded)
            {
                return;
            }

            var drawMatrix = GetWorldMatrixForDraw();

            if (m_drawTechnique == MyMeshDrawTechnique.GLASS)
            {
                int meshCount = model.GetMeshList().Count;
                for (int i = 0; i < meshCount; i++)
                {
                    MyRenderMesh mesh = model.GetMeshList()[i];

                    MyRenderMeshMaterial material = mesh.Material;

                    if (!material.Enabled)
                    {
                        continue;
                    }

                    VRageRender.MyRender.MyRenderElement renderElement;
                    VRageRender.MyRender.AllocateRenderElement(out renderElement);

                    if (!MyRender.IsRenderOverloaded)
                    {
                        //renderElement.DebugName = entity.Name;
                        renderElement.RenderObject = this;

                        renderElement.VertexBuffer      = model.VertexBuffer;
                        renderElement.IndexBuffer       = model.IndexBuffer;
                        renderElement.VertexCount       = model.GetVerticesCount();
                        renderElement.VertexDeclaration = model.GetVertexDeclaration();
                        renderElement.VertexStride      = model.GetVertexStride();
                        renderElement.InstanceBuffer    = null;
                        renderElement.BonesUsed         = mesh.BonesUsed;

                        renderElement.IndexStart = mesh.IndexStart;
                        renderElement.TriCount   = mesh.TriCount;

                        renderElement.WorldMatrixForDraw = drawMatrix;
                        renderElement.WorldMatrix        = WorldMatrix;

                        renderElement.Material      = material;
                        renderElement.DrawTechnique = m_drawTechnique == MyMeshDrawTechnique.MESH || m_drawTechnique == MyMeshDrawTechnique.GLASS ? material.DrawTechnique : m_drawTechnique;
                        renderElement.Color         = EntityColor * material.DiffuseColor;
                        renderElement.Dithering     = EntityDithering;
                        renderElement.ColorMaskHSV  = EntityColorMaskHSV;


                        if (material.DrawTechnique == MyMeshDrawTechnique.GLASS)
                        {
                            renderElement.Dithering = mesh.GlassDithering;
                        }
                        else
                        {
                            renderElement.Dithering = 0;
                        }


                        if (m_instanceBuffer != null)
                        {
                            renderElement.VertexStride      = m_lods[lodIndex].VertexStride;
                            renderElement.VertexDeclaration = m_lods[lodIndex].VertexDeclaration;
                            renderElement.InstanceBuffer    = m_instanceBuffer.InstanceBuffer;
                            renderElement.InstanceStart     = m_instanceStart;
                            renderElement.InstanceCount     = m_instanceCount;
                            renderElement.InstanceStride    = m_instanceBuffer.Stride;
                            renderElement.DrawTechnique     = model.BoneIndices.Length > 0 ? MyMeshDrawTechnique.MESH_INSTANCED_SKINNED : MyMeshDrawTechnique.MESH_INSTANCED;
                        }

                        Debug.Assert(renderElement.VertexBuffer != null, "Vertex buffer cannot be null!");
                        Debug.Assert(renderElement.IndexBuffer != null, "Index buffer cannot be null!");

                        if (material.DrawTechnique == MyMeshDrawTechnique.HOLO)
                        {
                            if (transparentRenderElements != null)
                            {
                                transparentRenderElements.Add(renderElement);
                            }
                        }
                        else
                        {
                            renderElements.Add(renderElement);
                        }
                    }
                }
            }
            else
            {
                if (!MyRender.IsRenderOverloaded)
                {
                    int  meshCount      = model.GetMeshList().Count;
                    bool separateMeshes = false;
                    for (int i = 0; i < meshCount; i++)
                    {
                        MyRenderMesh mesh = model.GetMeshList()[i];
                        if (mesh.BonesUsed != null)
                        {
                            separateMeshes = true;
                            break;
                        }
                    }

                    if (!separateMeshes)
                    {
                        MyRender.MyRenderElement renderElement;
                        MyRender.AllocateRenderElement(out renderElement);

                        renderElement.RenderObject = this;

                        renderElement.VertexBuffer      = model.VertexBuffer;
                        renderElement.IndexBuffer       = model.IndexBuffer;
                        renderElement.VertexCount       = model.GetVerticesCount();
                        renderElement.VertexDeclaration = model.GetVertexDeclaration();
                        renderElement.VertexStride      = model.GetVertexStride();
                        renderElement.InstanceBuffer    = null;
                        renderElement.Dithering         = 0;
                        renderElement.BonesUsed         = null;

                        if (m_instanceBuffer != null)
                        {
                            renderElement.VertexStride      = m_lods[lodIndex].VertexStride;
                            renderElement.VertexDeclaration = m_lods[lodIndex].VertexDeclaration;
                            renderElement.InstanceBuffer    = m_instanceBuffer.InstanceBuffer;
                            renderElement.InstanceStart     = m_instanceStart;
                            renderElement.InstanceCount     = m_instanceCount;
                            renderElement.InstanceStride    = m_instanceBuffer.Stride;
                        }

                        renderElement.IndexStart = 0;
                        if (renderElement.IndexBuffer != null)
                        {
                            renderElement.TriCount = model.GetTrianglesCount();
                        }

                        //renderElement.DebugName = entity.Name;
                        renderElement.WorldMatrix        = WorldMatrix;
                        renderElement.WorldMatrixForDraw = drawMatrix;

                        renderElements.Add(renderElement);
                    }
                    else
                    {
                        for (int i = 0; i < meshCount; i++)
                        {
                            MyRenderMesh mesh = model.GetMeshList()[i];

                            VRageRender.MyRender.MyRenderElement renderElement;
                            VRageRender.MyRender.AllocateRenderElement(out renderElement);

                            renderElement.RenderObject = this;

                            renderElement.VertexBuffer      = model.VertexBuffer;
                            renderElement.IndexBuffer       = model.IndexBuffer;
                            renderElement.VertexCount       = model.GetVerticesCount();
                            renderElement.VertexDeclaration = model.GetVertexDeclaration();
                            renderElement.VertexStride      = model.GetVertexStride();
                            renderElement.InstanceBuffer    = null;
                            renderElement.Dithering         = 0;

                            renderElement.BonesUsed = mesh.BonesUsed;

                            renderElement.IndexStart = mesh.IndexStart;
                            renderElement.TriCount   = mesh.TriCount;

                            if (m_instanceBuffer != null)
                            {
                                renderElement.VertexStride      = m_lods[lodIndex].VertexStride;
                                renderElement.VertexDeclaration = m_lods[lodIndex].VertexDeclaration;
                                renderElement.InstanceBuffer    = m_instanceBuffer.InstanceBuffer;
                                renderElement.InstanceStart     = m_instanceStart;
                                renderElement.InstanceCount     = m_instanceCount;
                                renderElement.InstanceStride    = m_instanceBuffer.Stride;
                                renderElement.DrawTechnique     = model.BoneIndices.Length > 0 ? MyMeshDrawTechnique.MESH_INSTANCED_SKINNED : MyMeshDrawTechnique.MESH_INSTANCED;
                            }

                            renderElement.WorldMatrix        = WorldMatrix;
                            renderElement.WorldMatrixForDraw = drawMatrix;

                            renderElements.Add(renderElement);
                        }
                    }
                }
            }
        }