public override void CreateIndexBuffer(List <Face> faces) { int[] indices = new int[24]; int i = 0; for (int n = 0; n < 4; n++) { indices[i++] = n; indices[i++] = (n + 1) % 4; indices[i++] = n + 4; indices[i++] = (n + 1) % 4 + 4; indices[i++] = n; indices[i++] = n + 4; } lock (DX.GlobalLock) { IndexBuffer = new D3D9.IndexBuffer(DX.Device, sizeof(int) * 24, D3D9.Usage.WriteOnly, D3D9.Pool.Managed, false); IndexBuffer.Lock(0, 0, D3D9.LockFlags.None).WriteRange(indices); IndexBuffer.Unlock(); } IndexCount = indices.Length; }
public static Model FromScene(Scene scene, Device device) { VertexDeclaration vertexDeclaration = new VertexDeclaration(device, VertexPositionNormalTexture.VertexElements); Model result = new Model(scene, device, vertexDeclaration); foreach (Mesh mesh in scene.Meshes.Where(x => x.Positions.Any())) { VertexBuffer vertexBuffer = new VertexBuffer(device, mesh.Positions.Count * VertexPositionNormalTexture.SizeInBytes, Usage.WriteOnly, VertexFormat.None, Pool.Default); DataStream vertexDataStream = vertexBuffer.Lock(0, mesh.Positions.Count * VertexPositionNormalTexture.SizeInBytes, LockFlags.None); VertexPositionNormalTexture[] vertices = new VertexPositionNormalTexture[mesh.Positions.Count]; for (int i = 0; i < vertices.Length; ++i) vertices[i] = new VertexPositionNormalTexture(mesh.Positions[i], (mesh.Normals.Count > i) ? mesh.Normals[i] : Vector3D.Zero, (mesh.TextureCoordinates.Count > i) ? mesh.TextureCoordinates[i].Xy : Point2D.Zero); vertexDataStream.WriteRange(vertices); vertexBuffer.Unlock(); IndexBuffer indexBuffer = new IndexBuffer(device, mesh.Indices.Count * sizeof(int), Usage.WriteOnly, Pool.Default, false); DataStream indexDataStream = indexBuffer.Lock(0, mesh.Indices.Count * sizeof(int), LockFlags.None); indexDataStream.WriteRange(mesh.Indices.ToArray()); indexBuffer.Unlock(); ModelMesh modelMesh = new ModelMesh(mesh, device, vertexBuffer, mesh.Positions.Count, indexBuffer, mesh.PrimitiveCount, Matrix3D.Identity, mesh.Material); result.Meshes.Add(modelMesh); } return result; }
internal ModelMesh(Mesh sourceMesh, Device device, VertexBuffer vertexBuffer, int numVertices, IndexBuffer indexBuffer, int primitiveCount, Matrix3D world, Material material) { SourceMesh = sourceMesh; _device = device; _vertexBuffer = vertexBuffer; _numVertices = numVertices; _indexBuffer = indexBuffer; _primitiveCount = primitiveCount; _effect = new SimpleEffect(device) { World = world, AmbientLightColor = new ColorRgbF(0.1f, 0.1f, 0.1f), DiffuseColor = material.DiffuseColor, SpecularColor = material.SpecularColor, SpecularPower = material.Shininess, Alpha = material.Transparency }; if (!string.IsNullOrEmpty(material.DiffuseTextureName)) _effect.DiffuseTexture = Texture.FromFile(device, material.DiffuseTextureName, Usage.None, Pool.Default); _effect.CurrentTechnique = "RenderScene"; Opaque = (material.Transparency == 1.0f); }
public virtual void CreateIndexBuffer(List <Face> faces) { lock (DX.GlobalLock) { IndexBuffer = new D3D9.IndexBuffer(DX.Device, faces.Count * Face.Size, D3D9.Usage.WriteOnly, D3D9.Pool.Managed, true); IndexBuffer.Lock(0, 0, D3D9.LockFlags.None).WriteRange(faces.ToArray()); IndexBuffer.Unlock(); } IndexCount = faces.Count * 3; }
public override void UnloadContent() { if (m_indexBuffer != null) { m_indexBuffer.Dispose(); m_indexBuffer = null; } if (m_vertexBuffer != null) { m_vertexBuffer.Dispose(); m_vertexBuffer = null; } }
internal Direct3D9IndexBuffer(SharpDX.Direct3D9.Device device, uint[] data) { _length = data.Length; _buffer = new SharpDX.Direct3D9.IndexBuffer(device, data.Length * sizeof(uint), Usage.WriteOnly, Pool.Managed, false); SharpDX.DataStream ds = _buffer.Lock(0, _length * sizeof(uint), LockFlags.None); for (int i = 0; i < data.Length; i++) { ds.Write(data[i]); } _buffer.Unlock(); }
public void Dispose() { if (VertexBuffer != null) { VertexBuffer.Dispose(); VertexBuffer = null; VertexCount = 0; } if (IndexBuffer != null) { IndexBuffer.Dispose(); IndexBuffer = null; IndexCount = 0; } }
public void CreateResources() { ushort[] indices = new ushort[6 * 20]; int count = indices.Length / 6; for (int i = 0; i < count; i++) { indices[(i * 6) + 0] = (ushort)((i * 4) + 0); indices[(i * 6) + 1] = (ushort)((i * 4) + 1); indices[(i * 6) + 2] = (ushort)((i * 4) + 2); indices[(i * 6) + 3] = (ushort)((i * 4) + 2); indices[(i * 6) + 4] = (ushort)((i * 4) + 1); indices[(i * 6) + 5] = (ushort)((i * 4) + 3); } _maxBatches = indices.Length / 6; _vertexDeclaration = new VertexDeclaration(_device, VertexPositionNormalTexture.VertexElements); _indexBuffer = new IndexBuffer(_device, sizeof(ushort) * indices.Length, Usage.WriteOnly, Pool.Managed, true); _indexBuffer.Lock(0, 0, LockFlags.None).WriteRange(indices, 0, indices.Length); }
public void UnloadContent() { if (m_vertexBuffer != null) { m_vertexBuffer.Dispose(); m_vertexBuffer = null; MyPerformanceCounter.PerAppLifetime.ModelVertexBuffersSize -= m_vertexBufferSize; m_vertexBufferSize = 0; } if (m_indexBuffer != null) { m_indexBuffer.Dispose(); m_indexBuffer = null; MyPerformanceCounter.PerAppLifetime.ModelIndexBuffersSize -= m_indexBufferSize; m_indexBufferSize = 0; } LoadState = Textures.LoadState.Unloaded; m_loadedContent = false; }
public RenderResources(Device device) { Vertex[] rectangle = new Vertex[]{ new Vertex(0,0,0), new Vertex(1,0,0), new Vertex(0,1,0), new Vertex(1,1,0), }; int[] rectanglei = new int[] { 0, 1, 1, 3, 3, 2, 2, 0 }; RectangleVBuffer = new VertexBuffer(device, rectangle.Length * Vertex.SizeInBytes, Usage.WriteOnly, VertexFormat.None, Pool.Default); var dsv = RectangleVBuffer.Lock(0, 0, LockFlags.Discard); dsv.WriteRange(rectangle); RectangleVBuffer.Unlock(); RecangleIBuffer = new IndexBuffer(device, sizeof(int) * rectanglei.Length, Usage.WriteOnly, Pool.Default, false); var dsi = RecangleIBuffer.Lock(0, 0, LockFlags.Discard); dsi.WriteRange(rectanglei); RecangleIBuffer.Unlock(); int[] fillrecti = new int[] { 0, 1, 2, 3, 2, 1 }; FillRectangleIBuffer = new IndexBuffer(device, sizeof(int) * fillrecti.Length, Usage.WriteOnly, Pool.Default, false); dsi = FillRectangleIBuffer.Lock(0, 0, LockFlags.Discard); dsi.WriteRange(fillrecti); FillRectangleIBuffer.Unlock(); Vertex[] circle = new Vertex[CircleQuality + 1]; for (int la = 0; la < circle.Length;la++) { var angle = O3DHelper.Scale(la,0,circle.Length,0,MathUtil.TwoPi); float x = (float)Math.Sin(angle) * 0.5f + 0.5f; float y = (float)Math.Cos(angle) * 0.5f + 0.5f; circle[la] = new Vertex(x, y, 0); } circle[CircleQuality] = new Vertex(0.5f, 0.5f, 0); CircleVBuffer = new VertexBuffer(device, circle.Length * Vertex.SizeInBytes, Usage.WriteOnly, VertexFormat.None, Pool.Default); dsv = CircleVBuffer.Lock(0, 0, LockFlags.Discard); dsv.WriteRange(circle); CircleVBuffer.Unlock(); int[] circlei = new int[CircleQuality * 2]; for (int la = 0; la < CircleQuality;la++) { circlei[la * 2 + 0] = la; circlei[la * 2 + 1] = (la + 1) % CircleQuality; } CircleIBuffer = new IndexBuffer(device, sizeof(int) * circlei.Length, Usage.WriteOnly, Pool.Default, false); dsi = CircleIBuffer.Lock(0, 0, LockFlags.Discard); dsi.WriteRange(circlei); CircleIBuffer.Unlock(); int[] fcircle = new int[CircleQuality * 3]; for (int la = 0; la < CircleQuality; la++) { fcircle[la * 3 + 0] = (la + 1) % CircleQuality; fcircle[la * 3 + 1] = la; fcircle[la * 3 + 2] = CircleQuality; } FillCircleIBuffer = new IndexBuffer(device, sizeof(int) * fcircle.Length, Usage.WriteOnly, Pool.Default, false); dsi = FillCircleIBuffer.Lock(0, 0, LockFlags.Discard); dsi.WriteRange(fcircle); FillCircleIBuffer.Unlock(); Shader = Effect.FromString(device, Resources.Shader, ShaderFlags.None); }
void CreateIndexBuffer() { MyDebug.AssertDebug(m_indexBuffer == null); if (m_Indices != null) { m_indexBuffer = new IndexBuffer(MyRender.GraphicsDevice, m_Indices.Length * sizeof(int), Usage.WriteOnly, Pool.Default, false); m_indexBuffer.SetData(m_Indices); m_indexBuffer.Tag = this; m_indexBufferSize = m_Indices.Length * sizeof(int); } else if (m_Indices_16bit != null) { m_indexBuffer = new IndexBuffer(MyRender.GraphicsDevice, m_Indices_16bit.Length * sizeof(short), Usage.WriteOnly, Pool.Default, true); m_indexBuffer.SetData(m_Indices_16bit); m_indexBuffer.Tag = this; m_indexBufferSize = m_Indices_16bit.Length * sizeof(short); } MyPerformanceCounter.PerAppLifetime.ModelIndexBuffersSize += m_indexBufferSize; SignResource(m_indexBuffer); }
private void SignResource(IndexBuffer indexBuffer) { indexBuffer.DebugName = m_assetName + "_ib"; }
/// <summary> /// Dispose /// </summary> public void Dispose() { m_meshContainer.Clear(); m_vertexBuffer.Dispose(); m_vertexBuffer = null; MyPerformanceCounter.PerAppLifetime.ModelVertexBuffersSize -= m_vertexBufferSize; m_vertexBufferSize = 0; m_indexBuffer.Dispose(); m_indexBuffer = null; MyPerformanceCounter.PerAppLifetime.ModelIndexBuffersSize -= m_indexBufferSize; m_indexBufferSize = 0; }
public void LoadBuffers(MyModelData modelData, string assetName = null) { System.Diagnostics.Debug.Assert(modelData.Sections.Count > 0, "Invalid object"); if (modelData.Sections.Count == 0) return; // create index buffer { m_trianglesCount = modelData.Indices.Count / 3; m_Indices_16bit = new ushort[modelData.Indices.Count]; for (int i = 0; i < modelData.Indices.Count; ++i) m_Indices_16bit[i] = (ushort)modelData.Indices[i]; m_indexBuffer = new IndexBuffer(MyRender.GraphicsDevice, m_Indices_16bit.Length * sizeof(short), Usage.WriteOnly, Pool.Default, true); m_indexBuffer.SetData(m_Indices_16bit); m_indexBuffer.Tag = this; m_indexBufferSize = m_Indices_16bit.Length * sizeof(short); SignResource(m_indexBuffer); } // create vertex buffer { m_verticesCount = modelData.Positions.Count; m_vertices = new MyCompressedVertexNormal[m_verticesCount]; var vertexArray = new MyVertexFormatPositionNormalTextureTangent[m_verticesCount]; for (int i = 0; i < modelData.Positions.Count; ++i) { vertexArray[i].Position = modelData.Positions[i]; vertexArray[i].Normal = modelData.Normals[i]; vertexArray[i].Tangent = modelData.Tangents[i]; vertexArray[i].TexCoord = modelData.TexCoords[i]; m_vertices[i] = new MyCompressedVertexNormal() { Position = vertexArray[i].PositionPacked, Normal = vertexArray[i].NormalPacked }; } m_vertexDeclaration = MyVertexFormatPositionNormalTextureTangent.VertexDeclaration; m_vertexStride = MyVertexFormatPositionNormalTextureTangent.Stride; m_vertexBufferSize = vertexArray.Length * m_vertexStride; m_vertexBuffer = new VertexBuffer(MyRender.GraphicsDevice, m_vertexBufferSize, Usage.WriteOnly, VertexFormat.None, Pool.Default); m_vertexBuffer.SetData(vertexArray); m_vertexBuffer.Tag = this; SignResource(m_vertexBuffer); } m_meshContainer.Clear(); // apply materials here for (int s = 0; s < modelData.Sections.Count; ++s) { var mpi = new MyMeshPartInfo(); mpi.Technique = m_drawTechnique; // Disabled, because it assert always when models are loaded before materials //System.Diagnostics.Debug.Assert(MyRenderModels.Materials.ContainsKey(modelData.Sections[s].MaterialName), "Mesh material not present!"); if (MyRenderModels.Materials.ContainsKey(modelData.Sections[s].MaterialName)) mpi.m_MaterialDesc = MyRenderModels.Materials[modelData.Sections[s].MaterialName]; var start = modelData.Sections[s].IndexStart; var end = start + modelData.Sections[s].TriCount*3; for (int i = start; i < end; ++i) mpi.m_indices.Add(modelData.Indices[i]); m_meshContainer.Add(new MyRenderMesh(mpi, null) { IndexStart = modelData.Sections[s].IndexStart, TriCount = modelData.Sections[s].TriCount }); } // store properties of this model { BoundingBox = modelData.AABB; BoundingSphere = new BoundingSphere(modelData.AABB.Center, modelData.AABB.HalfExtents.Length()); BoundingBoxSize = BoundingBox.Size; BoundingBoxSizeHalf = BoundingBox.HalfExtents; ModelInfo = new MyModelInfo(m_trianglesCount, m_verticesCount, BoundingBoxSize); PreloadTextures(LoadingMode.Immediate); LoadState = Textures.LoadState.Loaded; m_loadedContent = true; m_loadedData = true; } }
protected void RecreateBuffers() { Pool pool; if (viewportImage.GraphicsDeviceService.UseDeviceEx == true) pool = Pool.Default; else pool = Pool.Managed; if (!thickLines) { // Prepare for using single-pixel lines if ((vertices == null) || (vertices.Length != Points.Count) || (vertexBuffer == null)) { if (vertexBuffer != null) vertexBuffer.Dispose(); if ((vertices == null) || (vertices.Length != Points.Count)) vertices = new VertexPositionColor[Points.Count]; vertexBuffer = new VertexBuffer(graphicsDevice, vertices.Length * VertexPositionColor.SizeInBytes, Usage.WriteOnly, VertexFormat.Position | VertexFormat.Diffuse, pool); } if ((indices == null) || (indices.Length != Points.Count) || (indexBuffer == null)) { if (indexBuffer != null) indexBuffer.Dispose(); if ((indices == null) || (indices.Length != Points.Count)) indices = new short[Points.Count]; indexBuffer = new IndexBuffer(graphicsDevice, indices.Length * Marshal.SizeOf(typeof(short)), Usage.WriteOnly, pool, true); } } else { // Prepare for thick lines. 4 vertices and 6 indices per line. if ((thickVertices == null) || (thickVertices.Length != Points.Count * 4) || (vertexBuffer == null)) { if (vertexBuffer != null) vertexBuffer.Dispose(); if ((thickVertices == null) || (thickVertices.Length != Points.Count * 4)) thickVertices = new ThickLinesVertex[Points.Count * 4]; vertexBuffer = new VertexBuffer(graphicsDevice, thickVertices.Length * ThickLinesVertex.SizeInBytes, Usage.WriteOnly, VertexFormat.Position | VertexFormat.Texture0 | VertexFormat.Texture1 | VertexFormat.Diffuse, pool); } if ((indices == null) || (indices.Length != Points.Count * 6) || (indexBuffer == null)) { if (indexBuffer != null) indexBuffer.Dispose(); if ((indices == null) || (indices.Length != Points.Count * 6)) indices = new short[6 * Points.Count]; indexBuffer = new IndexBuffer(graphicsDevice, indices.Length * Marshal.SizeOf(typeof(short)), Usage.WriteOnly, pool, true); } } }
/// <summary> /// Loads the content. /// </summary> public override void LoadContent() { MyRender.Log.WriteLine("TransparentGeometry.LoadContent() - START"); MyRender.Log.IncreaseIndent(); MyRender.GetRenderProfiler().StartProfilingBlock("TransparentGeometry.LoadContent"); MyRender.Log.WriteLine(string.Format("MyTransparentGeometry.LoadData - START")); m_sortedTransparentGeometry.Clear(); m_preparedTransparentGeometry.Clear(); m_lowresTransparentGeometry.Clear(); // Max count of all particles should be less or equal than max count of billboards MyDebug.AssertRelease(MyTransparentGeometryConstants.MAX_PARTICLES_COUNT <= MyTransparentGeometryConstants.MAX_TRANSPARENT_GEOMETRY_COUNT); MyDebug.AssertRelease(MyTransparentGeometryConstants.MAX_COCKPIT_PARTICLES_COUNT <= MyTransparentGeometryConstants.MAX_TRANSPARENT_GEOMETRY_COUNT); PrepareAtlasMaterials(); m_vertexBuffer = new VertexBuffer(MyRender.GraphicsDevice, MyVertexFormatTransparentGeometry.Stride * MyTransparentGeometryConstants.MAX_TRANSPARENT_GEOMETRY_COUNT * MyTransparentGeometryConstants.VERTICES_PER_TRANSPARENT_GEOMETRY, Usage.WriteOnly | Usage.Dynamic, VertexFormat.None, Pool.Default); m_startOffsetInVertexBuffer = 0; m_endOffsetInVertexBuffer = 0; m_vertexBuffer.DebugName = "TransparentGeometry"; m_indexBuffer = new IndexBuffer(MyRender.GraphicsDevice, MyTransparentGeometryConstants.MAX_TRANSPARENT_GEOMETRY_INDICES * sizeof(int), Usage.WriteOnly, Pool.Default, false); m_indexBuffer.SetData(m_indices); MyRender.GetRenderProfiler().EndProfilingBlock(); MyRender.Log.DecreaseIndent(); MyRender.Log.WriteLine("TransparentGeometry.LoadContent() - END"); }
protected void RecreateBuffers() { if (viewportImage == null) return; lock (updateLocker) { Pool pool; if (viewportImage.GraphicsDeviceService.UseDeviceEx == true) pool = Pool.Default; else pool = Pool.Managed; if ((vertexBufferLength != vertices.Length) || (vertexBuffer == null)) { if (vertexBuffer != null) vertexBuffer.Dispose(); vertexBuffer = new VertexBuffer(graphicsDevice, vertices.Length * VertexPositionNormalColor.SizeInBytes, Usage.WriteOnly, VertexFormat.Position | VertexFormat.Normal | VertexFormat.Diffuse, pool); vertexBufferLength = vertices.Length; } using (DataStream stream = vertexBuffer.Lock(0, 0, LockFlags.None)) { stream.WriteRange(vertices); vertexBuffer.Unlock(); } graphicsDevice.VertexFormat = VertexFormat.Position | VertexFormat.Normal | VertexFormat.Diffuse; if ((indexBufferLength != indices.Length) || (indexBuffer == null)) { if (indexBuffer != null) indexBuffer.Dispose(); indexBuffer = new IndexBuffer(graphicsDevice, indices.Length * Marshal.SizeOf(typeof(int)), Usage.WriteOnly, pool, false); indexBufferLength = indices.Length; } using (DataStream streamIndex = indexBuffer.Lock(0, 0, LockFlags.None)) { streamIndex.WriteRange(indices); indexBuffer.Unlock(); } } }
private NormalBuffers GetNormalBuffers(ModelMesh mesh) { if (!_normals.ContainsKey(mesh)) { NormalBuffers normalBuffers = new NormalBuffers(); Line3D[] normalLines = NormalLinesGenerator.Generate(mesh.SourceMesh); normalBuffers.PrimitiveCount = normalLines.Length; normalBuffers.VertexCount = normalLines.Length * 2; VertexBuffer vertexBuffer = new VertexBuffer(_device, normalBuffers.VertexCount * VertexPositionColor.SizeInBytes, Usage.WriteOnly, VertexFormat.None, Pool.Default); DataStream vertexDataStream = vertexBuffer.Lock(0, normalBuffers.VertexCount * VertexPositionColor.SizeInBytes, LockFlags.None); VertexPositionColor[] vertices = new VertexPositionColor[normalBuffers.VertexCount]; int counter = 0; for (int i = 0; i < normalLines.Length; ++i) { Vector3D normalColor = Vector3D.Normalize(normalLines[i].Direction); normalColor += Vector3D.One; normalColor *= 0.5f; vertices[counter++] = new VertexPositionColor(normalLines[i].Start, normalColor); vertices[counter++] = new VertexPositionColor(normalLines[i].End, normalColor); } vertexDataStream.WriteRange(vertices); vertexBuffer.Unlock(); normalBuffers.Vertices = vertexBuffer; IndexBuffer indexBuffer = new IndexBuffer(_device, normalBuffers.VertexCount * sizeof(int), Usage.WriteOnly, Pool.Default, false); DataStream indexDataStream = indexBuffer.Lock(0, normalBuffers.VertexCount * sizeof(int), LockFlags.None); indexDataStream.WriteRange(Enumerable.Range(0, normalBuffers.VertexCount).ToArray()); indexBuffer.Unlock(); normalBuffers.Indices = indexBuffer; _normals.Add(mesh, normalBuffers); } return _normals[mesh]; }
private void CreateIndexBuffer(int triangleCount) { int indexSize = sizeof(int); if (m_indexBuffer == null || m_indexBuffer.Description.Size < triangleCount * 3 * indexSize) { if (m_indexBuffer != null) m_indexBuffer.Dispose(); m_indexBuffer = new IndexBuffer(MyRender.GraphicsDevice, triangleCount * 3 * indexSize, Usage.WriteOnly, Pool.Default, false); } int indexOffset = 0; m_meshes.Clear(); foreach (var pair in m_materialGroups) { var mesh = new MyRenderGroup() { IndexStart = indexOffset, Material = pair.Key }; foreach (var meshInfo in pair.Value) { // Copy indices var compoundIb = m_indexBuffer.Lock(indexOffset * indexSize, meshInfo.Mesh.TriCount * 3 * indexSize, LockFlags.None); var format = meshInfo.Model.IndexBuffer.Description.Format; Debug.Assert(format == Format.Index16 || format == Format.Index32); int modelIndexSize = format == Format.Index16 ? sizeof(short) : sizeof(int); var modelIb = meshInfo.Model.IndexBuffer.Lock(meshInfo.Mesh.IndexStart * modelIndexSize, meshInfo.Mesh.TriCount * 3 * modelIndexSize, LockFlags.ReadOnly); while (modelIb.RemainingLength > 0) { if (format == Format.Index16) { int index = modelIb.Read<short>() + meshInfo.VertexOffset; compoundIb.Write(index); } else { int index = modelIb.Read<int>() + meshInfo.VertexOffset; compoundIb.Write(index); } } m_indexBuffer.Unlock(); meshInfo.Model.IndexBuffer.Unlock(); mesh.TriangleCount += meshInfo.Mesh.TriCount; indexOffset += meshInfo.Mesh.TriCount * 3; } m_meshes.Add(mesh); } }
protected override void DisposeDisposables() { base.DisposeDisposables(); if (vertexBuffer != null) vertexBuffer.Dispose(); if (indexBuffer != null) indexBuffer.Dispose(); vertexBuffer = null; indexBuffer = null; }
public override void LoadContent() { int vbSize; unsafe { vbSize = sizeof(MyVertexFormatPositionNormalTextureTangent) * m_vertices.Length; } int ibSize = sizeof(ushort) * m_indices.Length; m_vertexBuffer = new VertexBuffer(MyRender.Device, vbSize, Usage.Dynamic | Usage.WriteOnly, VertexFormat.None, Pool.Default); m_vertexBuffer.Tag = this; m_vertexBuffer.SetData(m_vertices, LockFlags.Discard); m_indexBuffer = new IndexBuffer(MyRender.Device, ibSize, Usage.Dynamic | Usage.WriteOnly, Pool.Default, true); m_indexBuffer.Tag = this; m_indexBuffer.SetData(m_indices, LockFlags.Discard); m_ropeMaterial.PreloadTexture(); base.LoadContent(); }
/// <summary> /// Unloads the content. /// </summary> public override void UnloadContent() { MyRender.Log.WriteLine("TransparentGeometry.UnloadContent - START"); MyRender.Log.IncreaseIndent(); if (m_indexBuffer != null) { m_indexBuffer.Dispose(); m_indexBuffer = null; } if (m_vertexBuffer != null) { m_vertexBuffer.Dispose(); m_vertexBuffer = null; } MyRender.Log.DecreaseIndent(); MyRender.Log.WriteLine("TransparentGeometry.UnloadContent - END"); }
public override void UnloadContent() { m_vertexBuffer.Dispose(); m_indexBuffer.Dispose(); m_vertexBuffer = null; m_indexBuffer = null; base.UnloadContent(); }