internal void CollectRenderElements(List <VRageRender.MyRender.MyRenderElement> renderElements, List <VRageRender.MyRender.MyRenderElement> transparentRenderElements, MyRenderModel model, List <MyRenderMeshMaterial> materials, int lodIndex)
        {
            if (model.LoadState == LoadState.Unloaded)
            {
                //model.LoadInDraw(LoadingMode.Background);
                model.LoadInDraw(LoadingMode.Immediate);
                return;
            }
            if (model.LoadState == LoadState.Loading)
            {
                return;
            }

            if (m_instanceBuffer != null && m_instanceCount == 0)
            {
                return;
            }

            var drawMatrix = GetWorldMatrixForDraw();

            int meshCount = model.GetMeshList().Count;

            for (int i = 0; i < meshCount; i++)
            {
                MyRenderMesh mesh = model.GetMeshList()[i];

                MyRenderMeshMaterial material = model.HasSharedMaterials ? mesh.Material : materials[i];

                if (!material.Enabled)
                {
                    continue;
                }

                if (material.DrawTechnique == MyMeshDrawTechnique.GLASS && EntityDithering == 0)
                {
                    m_drawTechnique = MyMeshDrawTechnique.GLASS;
                    continue;
                }

                //Preload needs to be here because of reloadcontent
                material.PreloadTexture(LoadingMode.Background);

                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     = mesh.GlassDithering == 0 ? EntityDithering : mesh.GlassDithering;
                    renderElement.ColorMaskHSV  = EntityColorMaskHSV;

                    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;

                        if (m_instanceBuffer.Type == MyRenderInstanceBufferType.Generic)
                        {
                            renderElement.DrawTechnique = renderElement.DrawTechnique == MyMeshDrawTechnique.ALPHA_MASKED ? MyMeshDrawTechnique.MESH_INSTANCED_GENERIC_MASKED : MyMeshDrawTechnique.MESH_INSTANCED_GENERIC;
                        }
                        else
                        {
                            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);
                    }
                }
            }
        }