public static int VertexFormatStride(VertexFormats format) { const int floatSz = 4; const int float4 = floatSz * 4; const int float3 = floatSz * 3; const int float2 = floatSz * 2; switch (format) { case VertexFormats.Diffuse: return floatSz; case VertexFormats.Normal: return float3; case VertexFormats.Position: return float3; case VertexFormats.Texture0: case VertexFormats.Texture1: case VertexFormats.Texture2: case VertexFormats.Texture3: case VertexFormats.Texture4: return float2; case VertexFormats.PointSize: return floatSz; case VertexFormats.Transformed: return float4; default: return 0; } }
//Class Constructor 3 public GeometryIndexedSplatted(Device device, Type vertexType, VertexFormats vertexFormat, PrimitiveType primitivesType, int numDivision, uint[] divisionDistribution) : base(device, vertexType, vertexFormat, primitivesType) { this.UseDivisionVB = true; //implicitly this.NumDivisions = numDivision; this.DivisionDistribution = divisionDistribution; this.VBModified += new VBModifiedHandler(this.OnVBModified); this.IBModified += new IBModifiedHandler(this.OnIBModified); }
public Shape(string id, VertexBuffer[] vertexBuffers, IndexBuffer[] indexBuffers, int[] numVertices, int[] numIndices, int[] indexVRefs, PrimitiveType[] pTypes, VertexFormats[] vFormats, int[] primCounts, BoundingBox bBox) : base(id, null, null) { vBuffers = vertexBuffers; iBuffers = indexBuffers; vertexCount = numVertices; indexCount = numIndices; this.indexVRefs = indexVRefs; this.pTypes = pTypes; this.vFormats = vFormats; this.primCounts = primCounts; this.bBox = bBox; }
/// <summary>Updates the mesh to a new vertex format</summary> public void SetVertexFormat(Device device, VertexFormats format) { Mesh tempSystemMesh = null; Mesh tempLocalMesh = null; VertexFormats oldFormat = VertexFormats.None; using (systemMemoryMesh) { using (localMemoryMesh) { // Clone the meshes if (systemMemoryMesh != null) { oldFormat = systemMemoryMesh.VertexFormat; tempSystemMesh = systemMemoryMesh.Clone(systemMemoryMesh.Options.Value, format, device); } if (localMemoryMesh != null) { tempLocalMesh = localMemoryMesh.Clone(localMemoryMesh.Options.Value, format, device); } } } // Store the new meshes systemMemoryMesh = tempSystemMesh; localMemoryMesh = tempLocalMesh; // Compute normals if they are being requested and the old mesh didn't have them if (((oldFormat & VertexFormats.Normal) == 0) && ((format & VertexFormats.None) != 0)) { if (systemMemoryMesh != null) { systemMemoryMesh.ComputeNormals(); } if (localMemoryMesh != null) { localMemoryMesh.ComputeNormals(); } } }
//Class Constructor 3 public GeometryIndexed(Device device, Type vertexType, VertexFormats vertexFormat, PrimitiveType primitivesType) : base() { this.Device = device; this._PrimitivesType = primitivesType; this._VertexType = vertexType; this._VertexFormat = vertexFormat; this._VB = null; this._IB = null; //can only use TriangleList or LineList for now if (this._PrimitivesType == PrimitiveType.LineList) { step = 2; } if (this._PrimitivesType == PrimitiveType.TriangleList) { step = 3; } }
public static void CreateBufferStream(ICollection <DataFields[]> streams, out GeomDataBufferStream bufferStream) { bufferStream = new GeomDataBufferStream(); // create format order Dictionary <VertexFormats, int> fields = new Dictionary <VertexFormats, int>(); List <DataFields> dataFields = new List <DataFields>(); int index = 0; foreach (DataFields[] stream in streams) { foreach (DataFields field in stream) { if (!fields.ContainsKey(field.Format)) { dataFields.Add(field); fields.Add(field.Format, index++); } } } bufferStream.Fields = new VertexFormats[dataFields.Count]; bufferStream.FieldPositions = new int[dataFields.Count]; VertexFormats format = VertexFormats.None; int pos = 0; for (int i = 0; i < dataFields.Count; i++) { bufferStream.Fields[i] = dataFields[i].Format; format |= dataFields[i].Format; bufferStream.FieldPositions[i] = pos; pos += VertexFormatStride(dataFields[i].Format); } bufferStream.Stride = pos; bufferStream.Format = format; }
public static void FlipNormalsVB(VertexBuffer vb, VertexFormats vFormat, int size) { if (vFormat == CustomVertex.PositionNormal.Format) { CustomVertex.PositionNormal[] verts = (CustomVertex.PositionNormal[]) vb.Lock(0, LockFlags.None); for (int v = 0; v < verts.Length; v++) { verts[v].Normal = new Vector3(-verts[v].Normal.X, -verts[v].Normal.Y, -verts[v].Normal.Z); } vb.Unlock(); } else if (vFormat == CustomVertex.PositionNormalColored.Format) { CustomVertex.PositionNormalColored[] verts = (CustomVertex.PositionNormalColored[]) vb.Lock(0, LockFlags.None); for (int v = 0; v < verts.Length; v++) { verts[v].Normal = new Vector3(-verts[v].Normal.X, -verts[v].Normal.Y, -verts[v].Normal.Z); } vb.Unlock(); } else if (vFormat == CustomVertex.PositionNormalTextured.Format) { CustomVertex.PositionNormalTextured[] verts = (CustomVertex.PositionNormalTextured[]) vb.Lock(0, LockFlags.None); for (int v = 0; v < verts.Length; v++) { verts[v].Normal = new Vector3(-verts[v].Normal.X, -verts[v].Normal.Y, -verts[v].Normal.Z); } vb.Unlock(); } else { throw new Exception("Unsupported format to flip normals with"); } }
public static int VertexFormatStride(VertexFormats format) { const int floatSz = 4; const int float4 = floatSz * 4; const int float3 = floatSz * 3; const int float2 = floatSz * 2; switch (format) { case VertexFormats.Diffuse: return(floatSz); case VertexFormats.Normal: return(float3); case VertexFormats.Position: return(float3); case VertexFormats.Texture0: case VertexFormats.Texture1: case VertexFormats.Texture2: case VertexFormats.Texture3: case VertexFormats.Texture4: return(float2); case VertexFormats.PointSize: return(floatSz); case VertexFormats.Transformed: return(float4); default: return(0); } }
//Class Constructor 1 public GeometryIndexed(Device device, VertexBuffer vB, IndexBuffer iB, Type vertexType, VertexFormats vertexFormat, PrimitiveType primitivesType) : base() { this.Device = device; this._PrimitivesType = primitivesType; this._VertexType = vertexType; this._VertexFormat = vertexFormat; this._VB = vB; this._IB = iB; //can only use TriangleList or LineList for now if (this._PrimitivesType == PrimitiveType.LineList) { step = 2; } if (this._PrimitivesType == PrimitiveType.TriangleList) { step = 3; } this.UpdateNoOfVertices(); this.UpdateNoOfIndices(); this.UpdateNeighbourList(); }
//Class Constructor 2 public GeometryIndexed(Device device, int numVertices, int numIndices, Type vertexType, VertexFormats vertexFormat, PrimitiveType primitivesType) : base() { this.Device = device; this._PrimitivesType = primitivesType; this._VertexType = vertexType; this._VertexFormat = vertexFormat; this._VB = new VertexBuffer(this._VertexType, numVertices, this.Device, Usage.SoftwareProcessing, this._VertexFormat, Pool.Default); this._IB = new IndexBuffer(typeof(short), numIndices * 3, this.Device, Usage.SoftwareProcessing, Pool.Default); //can only use TriangleList or LineList for now if (this._PrimitivesType == PrimitiveType.LineList) { step = 2; } if (this._PrimitivesType == PrimitiveType.TriangleList) { step = 3; } this.UpdateNoOfVertices(); this.UpdateNoOfIndices(); this.UpdateNeighbourList(); }
/// <summary>Updates the mesh to a new vertex format</summary> public void SetVertexFormat(Device device, VertexFormats format) { Mesh tempSystemMesh = null; Mesh tempLocalMesh = null; VertexFormats oldFormat = VertexFormats.None; using(systemMemoryMesh) { using (localMemoryMesh) { // Clone the meshes if (systemMemoryMesh != null) { oldFormat = systemMemoryMesh.VertexFormat; tempSystemMesh = systemMemoryMesh.Clone(systemMemoryMesh.Options.Value, format, device); } if (localMemoryMesh != null) { tempLocalMesh = localMemoryMesh.Clone(localMemoryMesh.Options.Value, format, device); } } } // Store the new meshes systemMemoryMesh = tempSystemMesh; localMemoryMesh = tempLocalMesh; // Compute normals if they are being requested and the old mesh didn't have them if ( ((oldFormat & VertexFormats.Normal) == 0) && ((format & VertexFormats.None) != 0) ) { if (systemMemoryMesh != null) systemMemoryMesh.ComputeNormals(); if (localMemoryMesh != null) localMemoryMesh.ComputeNormals(); } }
protected void SetupColored() { m_ColoredVertices = new CustomVertex.PositionColored[m_NumVertices]; m_VertexFormat = CustomVertex.PositionColored.Format; m_VertexBuffer = new VertexBuffer(typeof(CustomVertex.PositionColored), m_NumVertices, D3DDevice, Usage.Dynamic | Usage.WriteOnly, m_VertexFormat, Pool.Default); for(int i = 0; i < m_NumVertices; i++) { float angle = ((float)i / (float)m_NumVertices) * 2 * 3.14159f; double tempx = Radius * Math.Cos(angle); double tempy = Radius * Math.Sin(angle); m_ColoredVertices[i].Position = new Vector3( (float)tempx + (XPos + Radius), (float)tempy + (YPos + Radius), 0f); m_ColoredVertices[i].Color = m_Color.ToArgb(); } m_VertexBuffer.SetData(m_ColoredVertices, 0, LockFlags.None); }
public VertexBuffer(Type typeVertexType, int numVerts, Device device, Usage usage, VertexFormats vertexFormat, Pool pool) : base((IntPtr)null) { throw new NotImplementedException(); }
/// <summary> /// Save the mesh when the DirectX device is lost /// </summary> void d3d_DxLost(Direct3d d3d, Device dx) { if (mMesh == null) return; // Save all data needed to restore the mesh mNumFaces = mMesh.NumberFaces; mNumVertices = mMesh.NumberVertices; mNumBytesPerVertex = mMesh.NumberBytesPerVertex; mFlags = mMesh.Options.Value; mVertexFormat = mMesh.VertexFormat; // Copy pathIndex buffer mIndexBufferCopy = (byte[])mMesh.LockIndexBuffer(typeof(byte), LockFlags.ReadOnly, mMesh.IndexBuffer.Description.Size); mMesh.UnlockIndexBuffer(); // Copy vertex buffer mVertexBufferCopy = (byte[])mMesh.LockVertexBuffer(typeof(byte), LockFlags.ReadOnly, mMesh.NumberBytesPerVertex * mMesh.NumberVertices); mMesh.UnlockVertexBuffer(); // Copy attribute buffer mAttributeBufferCopy = mMesh.LockAttributeBufferArray(LockFlags.ReadOnly); mMesh.UnlockAttributeBuffer(mAttributeBufferCopy); mMesh.Dispose(); mMesh = null; mVertexCache = null; }
public unsafe VertexBuffer(IDirect3DVertexBuffer9 *lp, Device device, Usage usage, VertexFormats vertexFormat, Pool pool) : base((IntPtr)lp) { throw new NotImplementedException(); }
public static int GetFormatSize(VertexFormats vertexFormat) { throw new NotImplementedException(); }
public DataFields(VertexFormats format, string usage) { this.Format = format; this.Usage = usage; }
public void Render() { if (_player == null) { return; } lock (_subtitleLock) { if (_clearOnNextRender) { //Log.Debug("SubtitleRenderer: clearOnNextRender"); _clearOnNextRender = false; if (_subTexture != null) { _subTexture.SafeDispose(); } _subTexture = null; _currentSubtitle = null; } if (_renderSubtitles == false) { return; } // ugly temp! bool timeForNext = false; if (_subtitles.Count > 0) { Subtitle next = _subtitles.First.Value; if (next.presentTime <= _player.StreamPosition) { timeForNext = true; } } _posOnLastRender = _player.StreamPosition; // Check for subtitle if we dont have one currently or if the current one is beyond its timeout if (_currentSubtitle == null || _currentSubtitle.presentTime + _currentSubtitle.timeOut <= _player.StreamPosition || timeForNext) { //Log.Debug("-Current position: "); if (_currentSubtitle != null && !timeForNext) { //Log.Debug("-Current subtitle : " + currentSubtitle.ToString() + " time out expired"); _currentSubtitle = null; } if (timeForNext) { //if (currentSubtitle != null) Log.Debug("-Current subtitle : " + currentSubtitle.ToString() + " TIME FOR NEXT!"); } Subtitle next = null; while (_subtitles.Count > 0) { next = _subtitles.First.Value; //Log.Debug("-next from queue: " + next.ToString()); // if the next should be displayed now or previously if (next.presentTime <= _player.StreamPosition) { // remove from queue _subtitles.RemoveFirst(); // if it is not too late for this sub to be displayed, break // otherwise continue if (next.presentTime + next.timeOut >= _player.StreamPosition) { _currentSubtitle = next; break; } } // next wants to be displayed in the future so break else { //Log.Debug("-next is in the future"); break; } } // if currentSubtitle is non-null we have a new subtitle if (_currentSubtitle != null) { SetSubtitle(_currentSubtitle); } else { return; } } VertexFormats vertexFormat = GUIGraphicsContext.DX9Device.VertexFormat; try { int wx = 0, wy = 0, wwidth = 0, wheight = 0; float rationW = 1, rationH = 1; Rectangle src, dst; VMR9Util.g_vmr9.GetVideoWindows(out src, out dst); rationH = dst.Height / (float)_currentSubtitle.screenHeight; rationW = dst.Width / (float)_currentSubtitle.screenWidth; wx = dst.X + (int)(rationW * (float)_currentSubtitle.horizontalPosition); wy = dst.Y + (int)(rationH * (float)_currentSubtitle.firstScanLine); wwidth = (int)((float)_currentSubtitle.width * rationW); wheight = (int)((float)_currentSubtitle.height * rationH); // make sure the vertex buffer is ready and correct for the coordinates CreateVertexBuffer(wx, wy, wwidth, wheight); // Log.Debug("Subtitle render target: wx = {0} wy = {1} ww = {2} wh = {3}", wx, wy, wwidth, wheight); // enable alpha blending so that the subtitle is rendered with transparent background DXNative.FontEngineSetRenderState((int)D3DRENDERSTATETYPE.D3DRS_ALPHABLENDENABLE, 1); // Make sure D3D objects haven't been disposed for some reason. This would cause // an access violation on native side, causing Skin Engine to halt rendering if (!_subTexture.Disposed && !_vertexBuffer.Disposed) { GUIGraphicsContext.DX9Device.SetStreamSource(0, _vertexBuffer, 0); GUIGraphicsContext.DX9Device.SetTexture(0, _subTexture); GUIGraphicsContext.DX9Device.VertexFormat = CustomVertex.TransformedTextured.Format; GUIGraphicsContext.DX9Device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2); } else { Log.Debug("Subtitle renderer: D3D resource was disposed! Not trying to render the texture"); } } catch (Exception e) { Log.Error(e); } try { // Restore device settings GUIGraphicsContext.DX9Device.SetTexture(0, null); GUIGraphicsContext.DX9Device.VertexFormat = vertexFormat; } catch (Exception e) { Log.Error(e); } } // end of lock (subtitle) }
public void BuildBuffers(Device device) { if (Geometry.Normals != null) { if (Geometry.VertexClrs != null) { vFormat = CustomVertex.PositionNormalColored.Format; vBuffer = new VertexBuffer(typeof(CustomVertex.PositionNormalColored), Geometry.Vertices.Length, device, Usage.None, CustomVertex.PositionNormalColored.Format, Pool.Managed); CustomVertex.PositionNormalColored[] verts = (CustomVertex.PositionNormalColored[])vBuffer.Lock(0, LockFlags.None); for (int i = 0; i < Geometry.Vertices.Length; i++) { verts[i].Position = Geometry.Vertices[i]; verts[i].Normal = Geometry.Normals[i]; verts[i].Color = Geometry.VertexClrs[i]; } vBuffer.Unlock(); } else { if (Geometry.TexCoords != null) { vFormat = CustomVertex.PositionNormalTextured.Format; vBuffer = new VertexBuffer(typeof(CustomVertex.PositionNormalTextured), Geometry.Vertices.Length, device, Usage.None, CustomVertex.PositionNormalTextured.Format, Pool.Managed); CustomVertex.PositionNormalTextured[] verts = (CustomVertex.PositionNormalTextured[])vBuffer.Lock(0, LockFlags.None); for (int i = 0; i < Geometry.Vertices.Length; i++) { verts[i].Position = Geometry.Vertices[i]; verts[i].Normal = Geometry.Normals[i]; verts[i].Tu = Geometry.TexCoords[i].X; verts[i].Tv = Geometry.TexCoords[i].Y; } vBuffer.Unlock(); } else { vFormat = CustomVertex.PositionNormal.Format; vBuffer = new VertexBuffer(typeof(CustomVertex.PositionNormal), Geometry.Vertices.Length, device, Usage.None, CustomVertex.PositionNormal.Format, Pool.Managed); CustomVertex.PositionNormal[] verts = (CustomVertex.PositionNormal[])vBuffer.Lock(0, LockFlags.None); for (int i = 0; i < Geometry.Vertices.Length; i++) { verts[i].Position = Geometry.Vertices[i]; verts[i].Normal = Geometry.Normals[i]; } vBuffer.Unlock(); } } } else { if (Geometry.VertexClrs != null) { vFormat = CustomVertex.PositionColored.Format; vBuffer = new VertexBuffer(typeof(CustomVertex.PositionColored), Geometry.Vertices.Length, device, Usage.None, CustomVertex.PositionColored.Format, Pool.Managed); CustomVertex.PositionColored[] verts = (CustomVertex.PositionColored[])vBuffer.Lock(0, LockFlags.None); for (int i = 0; i < Geometry.Vertices.Length; i++) { verts[i].Position = Geometry.Vertices[i]; verts[i].Color = Geometry.VertexClrs[i]; } vBuffer.Unlock(); } else { if (Geometry.TexCoords != null) { vFormat = CustomVertex.PositionTextured.Format; vBuffer = new VertexBuffer(typeof(CustomVertex.PositionTextured), Geometry.Vertices.Length, device, Usage.None, CustomVertex.PositionTextured.Format, Pool.Managed); CustomVertex.PositionTextured[] verts = (CustomVertex.PositionTextured[])vBuffer.Lock(0, LockFlags.None); for (int i = 0; i < Geometry.Vertices.Length; i++) { verts[i].Position = Geometry.Vertices[i]; verts[i].Tu = Geometry.TexCoords[i].X; verts[i].Tv = Geometry.TexCoords[i].Y; } vBuffer.Unlock(); } else { vFormat = CustomVertex.PositionOnly.Format; vBuffer = new VertexBuffer(typeof(CustomVertex.PositionOnly), Geometry.Vertices.Length, device, Usage.None, CustomVertex.PositionOnly.Format, Pool.Managed); CustomVertex.PositionOnly[] verts = (CustomVertex.PositionOnly[])vBuffer.Lock(0, LockFlags.None); for (int i = 0; i < Geometry.Vertices.Length; i++) { verts[i].Position = Geometry.Vertices[i]; } vBuffer.Unlock(); } } } if (Geometry.PrimIndices != null) { if (MaterialIndices != null) { matIBuffers = new IndexBuffer[MaterialIndices.Length]; int mibIdx = 0; foreach (ABMaterialIndex matIndex in MaterialIndices) { if (matIndex.Material.Texture == null && matIndex.Material.TextureName != null) { if (File.Exists(matIndex.Material.TextureName)) matIndex.Material.Texture = TextureLoader.FromFile(device, matIndex.Material.TextureName); } int numIndices = matIndex.Indices.Length * 3; IndexBuffer buffer = matIBuffers[mibIdx++] = new IndexBuffer(typeof(int), numIndices, device, Usage.None, Pool.Managed); int[] indices = (int[])buffer.Lock(0, LockFlags.None); int iIdx = 0; for (int i = 0; i < matIndex.Indices.Length; i++) { int index = matIndex.Indices[i] * 3; indices[iIdx++] = Geometry.PrimIndices[index]; indices[iIdx++] = Geometry.PrimIndices[index + 1]; indices[iIdx++] = Geometry.PrimIndices[index + 2]; } buffer.Unlock(); switch (Geometry.PrimType) { case PrimitiveType.LineList: matIndex.PrimCount = numIndices / 2; break; case PrimitiveType.LineStrip: matIndex.PrimCount = numIndices - 1; break; case PrimitiveType.PointList: matIndex.PrimCount = numIndices; break; case PrimitiveType.TriangleList: matIndex.PrimCount = numIndices / 3; break; } } } else { iBuffer = new IndexBuffer(typeof(int), Geometry.PrimIndices.Length, device, Usage.None, Pool.Managed); //iBuffer.SetData(Geometry.PrimIndices, 0, LockFlags.None); int[] indices = (int[])iBuffer.Lock(0, LockFlags.None); for (int i = 0; i < Geometry.PrimIndices.Length; i++) { indices[i] = Geometry.PrimIndices[i]; } iBuffer.Unlock(); switch (Geometry.PrimType) { case PrimitiveType.LineList: numPrimitives = Geometry.PrimIndices.Length / 2; break; case PrimitiveType.LineStrip: numPrimitives = Geometry.PrimIndices.Length - 1; break; case PrimitiveType.PointList: numPrimitives = Geometry.PrimIndices.Length; break; case PrimitiveType.TriangleList: numPrimitives = Geometry.PrimIndices.Length / 3; break; } } } else { switch (Geometry.PrimType) { case PrimitiveType.LineList: numPrimitives = Geometry.Vertices.Length / 2; break; case PrimitiveType.LineStrip: numPrimitives = Geometry.Vertices.Length - 1; break; case PrimitiveType.PointList: numPrimitives = Geometry.Vertices.Length; break; case PrimitiveType.TriangleList: numPrimitives = Geometry.Vertices.Length / 3; break; } } }
protected void RebuildStructure(Device device, NuSceneBuffer3D sceneBuffer, GeneralStructuresShadingDesc shading) { boundingBox = GenerateBoundingBoxFromPoints(sceneBuffer.triangleStrips); bool useClrAxis = shading.RibbonsShadingDesc.PropertiesInUse.ContainsKey("UseClrAxis"); Vector4 xClrStep = new Vector4(), yClrStep = new Vector4(), zClrStep = new Vector4(); Vector4 xClrStart = new Vector4(), yClrStart = new Vector4(), zClrStart = new Vector4(); if (useClrAxis) { // pre-calculate colour ranges scale from bounding box Color xClrA, xClrB; if (shading.RibbonsShadingDesc.Clrs.XEnabled) { xClrA = shading.RibbonsShadingDesc.Clrs.Xa; xClrB = shading.RibbonsShadingDesc.Clrs.Xb; } else xClrA = xClrB = shading.RibbonsShadingDesc.DefaultClr; Color yClrA, yClrB; if (shading.RibbonsShadingDesc.Clrs.YEnabled) { yClrA = shading.RibbonsShadingDesc.Clrs.Ya; yClrB = shading.RibbonsShadingDesc.Clrs.Yb; } else yClrA = yClrB = shading.RibbonsShadingDesc.DefaultClr; Color zClrA, zClrB; if (shading.RibbonsShadingDesc.Clrs.ZEnabled) { zClrA = shading.RibbonsShadingDesc.Clrs.Za; zClrB = shading.RibbonsShadingDesc.Clrs.Zb; } else zClrA = zClrB = shading.RibbonsShadingDesc.DefaultClr; float difA = xClrB.A - xClrA.A; float difR = xClrB.R - xClrA.R; float difG = xClrB.G - xClrA.G; float difB = xClrB.B - xClrA.B; // calc steps xClrStep = new Vector4(difA / boundingBox.Dimensions.X, difR / boundingBox.Dimensions.X, difG / boundingBox.Dimensions.X, difB / boundingBox.Dimensions.X); difA = yClrB.A - yClrA.A; difR = yClrB.R - yClrA.R; difG = yClrB.G - yClrA.G; difB = yClrB.B - yClrA.B; yClrStep = new Vector4(difA / boundingBox.Dimensions.Y, difR / boundingBox.Dimensions.Y, difG / boundingBox.Dimensions.Y, difB / boundingBox.Dimensions.Y); difA = zClrB.A - zClrA.A; difR = zClrB.R - zClrA.R; difG = zClrB.G - zClrA.G; difB = zClrB.B - zClrA.B; zClrStep = new Vector4(difA / boundingBox.Dimensions.Z, difR / boundingBox.Dimensions.Z, difG / boundingBox.Dimensions.Z, difB / boundingBox.Dimensions.Z); } if (shading.RibbonsShadingDesc.ShadingType == RibbonsShadingDesc.Shading.Solid) { // make triangle strips List<Vector3[]> triStripsList = sceneBuffer.triangleStrips; triStrips = new VertexBuffer[triStripsList.Count]; triStripsMirrored = new VertexBuffer[triStripsList.Count]; triStripSizes = new int[triStripsList.Count]; for (int strip = 0; strip < triStripsList.Count; strip++) { Vector3[] points = triStripsList[strip]; if (useClrAxis) { vFormat = CustomVertex.PositionNormalColored.Format; triStrips[strip] = new VertexBuffer(typeof(CustomVertex.PositionNormalColored), points.Length, device, Usage.None, CustomVertex.PositionNormalColored.Format, Pool.Managed); triStripSizes[strip] = points.Length - 2; CustomVertex.PositionNormalColored[] verts = (CustomVertex.PositionNormalColored[]) triStrips[strip].Lock(0, LockFlags.None); float xStart = boundingBox.Centre.X - (boundingBox.Dimensions.X / 2.0f); float yStart = boundingBox.Centre.Y - (boundingBox.Dimensions.Y / 2.0f); float zStart = boundingBox.Centre.Z - (boundingBox.Dimensions.Z / 2.0f); for (int v = 1; v < points.Length - 1; v++) { // V1 float xSteps = points[v - 1].X - xStart; float ySteps = points[v - 1].Y - yStart; float zSteps = points[v - 1].Z - zStart; // blend XYZ colours int A = (int)((xClrStep.X * xSteps) + (yClrStep.X * ySteps) + (zClrStep.X * zSteps)); int R = (int)((xClrStep.Y * xSteps) + (yClrStep.Y * ySteps) + (zClrStep.Y * zSteps)); int G = (int)((xClrStep.Z * xSteps) + (yClrStep.Z * ySteps) + (zClrStep.Z * zSteps)); int B = (int)((xClrStep.W * xSteps) + (yClrStep.W * ySteps) + (zClrStep.W * zSteps)); verts[v - 1].Color = Color.FromArgb(A, R, G, B).ToArgb(); verts[v - 1].Position = points[v - 1]; // V2 xSteps = points[v].X - xStart; ySteps = points[v].Y - yStart; zSteps = points[v].Z - zStart; // blend XYZ colours A = (int)((xClrStep.X * xSteps) + (yClrStep.X * ySteps) + (zClrStep.X * zSteps)); R = (int)((xClrStep.Y * xSteps) + (yClrStep.Y * ySteps) + (zClrStep.Y * zSteps)); G = (int)((xClrStep.Z * xSteps) + (yClrStep.Z * ySteps) + (zClrStep.Z * zSteps)); B = (int)((xClrStep.W * xSteps) + (yClrStep.W * ySteps) + (zClrStep.W * zSteps)); verts[v].Color = Color.FromArgb(A, R, G, B).ToArgb(); verts[v].Position = points[v]; // V3 xSteps = points[v + 1].X - xStart; ySteps = points[v + 1].Y - yStart; zSteps = points[v + 1].Z - zStart; // blend XYZ colours A = (int)((xClrStep.X * xSteps) + (yClrStep.X * ySteps) + (zClrStep.X * zSteps)); R = (int)((xClrStep.Y * xSteps) + (yClrStep.Y * ySteps) + (zClrStep.Y * zSteps)); G = (int)((xClrStep.Z * xSteps) + (yClrStep.Z * ySteps) + (zClrStep.Z * zSteps)); B = (int)((xClrStep.W * xSteps) + (yClrStep.W * ySteps) + (zClrStep.W * zSteps)); verts[v + 1].Color = Color.FromArgb(A, R, G, B).ToArgb(); verts[v + 1].Position = points[v + 1]; // normals Vector3 v0 = verts[v + 1].Position; Vector3 v1 = verts[v].Position; Vector3 v2 = verts[v - 1].Position; Vector3 e1 = v1 - v0, e2 = v2 - v0; Vector3 vNormal = Vector3.Normalize(Vector3.Cross(e1, e2)); verts[v - 1].Normal += vNormal; verts[v].Normal += vNormal; verts[v + 1].Normal += vNormal; if (v != 1) verts[v - 1].Normal *= 0.5f; if (v == points.Length - 1) verts[v].Normal *= 0.5f; } // mirror for double-sided triStripsMirrored[strip] = new VertexBuffer(typeof(CustomVertex.PositionNormalColored), points.Length, device, Usage.None, CustomVertex.PositionNormalColored.Format, Pool.Managed); // clone triStripsMirrored[strip].SetData(verts, 0, LockFlags.None); triStrips[strip].Unlock(); // flip FlipNormalsVB(triStripsMirrored[strip], CustomVertex.PositionNormalColored.Format, triStripSizes[strip]); } else { vFormat = CustomVertex.PositionNormal.Format; triStrips[strip] = new VertexBuffer(typeof(CustomVertex.PositionNormal), points.Length, device, Usage.None, CustomVertex.PositionNormal.Format, Pool.Managed); triStripSizes[strip] = points.Length - 2; CustomVertex.PositionNormal[] verts = (CustomVertex.PositionNormal[]) triStrips[strip].Lock(0, LockFlags.None); for (int v = 1; v < points.Length - 1; v++) { // positions verts[v - 1].Position = points[v + 1]; verts[v].Position = points[v]; verts[v + 1].Position = points[v - 1]; // normals Vector3 v0 = verts[v - 1].Position; Vector3 v1 = verts[v].Position; Vector3 v2 = verts[v + 1].Position; Vector3 e1 = v1 - v0, e2 = v2 - v0; Vector3 vNormal = Vector3.Normalize(Vector3.Cross(e1, e2)); verts[v - 1].Normal += vNormal; verts[v].Normal += vNormal; verts[v + 1].Normal += vNormal; if (v != 1) verts[v - 1].Normal *= 0.5f; if (v == points.Length - 1) verts[v].Normal *= 0.5f; } // mirror for double-sided triStripsMirrored[strip] = new VertexBuffer(typeof(CustomVertex.PositionNormal), points.Length, device, Usage.None, CustomVertex.PositionNormal.Format, Pool.Managed); // clone triStripsMirrored[strip].SetData(verts, 0, LockFlags.None); triStrips[strip].Unlock(); // flip FlipNormalsVB(triStripsMirrored[strip], CustomVertex.PositionNormal.Format, triStripSizes[strip]); } } } else if (shading.RibbonsShadingDesc.ShadingType == RibbonsShadingDesc.Shading.Edges) { } }
public void DrawUserPrimitives(PrimitiveType primative_type, int primative_count, VertexFormats format, object vertex_data) { _Device_.VertexFormat = format; _Device_.DrawUserPrimitives(primative_type, primative_count, vertex_data); }
public void SetFontRenderState() { mLastTexture = null; mVertexFormat = VertexFormats.PointSize; }
public static VertexElement[] DeclaratorFromFormat(VertexFormats vertexFormat) { throw new NotImplementedException(); }
/// <summary> /// This used to be done in the World class but moved here so folks could override a ROL's behavior. /// /// NOTE: Everything under an Icons is rendered using RenderPriority.Icons. If you put any other kind of /// ROL in here it (and it's children) probably wont render. /// </summary> /// <param name="drawArgs"></param> /// <param name="priority"></param> public override void RenderChildren(DrawArgs drawArgs, RenderPriority priority) { //Respect icon set temporal extents if (TimeKeeper.CurrentTimeUtc < EarliestTime || TimeKeeper.CurrentTimeUtc > LatestTime) { return; } if (!isOn) { return; } if (!isInitialized) { return; } if (priority != RenderPriority.Icons) { return; } // render ourselves this.Render(drawArgs); if (m_canUsePointSprites) { pointSprites.Clear(); } // First render everything except icons - we need to do this twice since the other loop is INSIDE the // sprite.begin which can mess up the rendering of other ROs. This is why prerender is in this loop. m_childrenRWLock.AcquireReaderLock(Timeout.Infinite); try { foreach (RenderableObject ro in m_children) { if (!ro.IsOn) { continue; } if (ro is Icon) // && (priority == RenderPriority.Icons)) { Icon icon = ro as Icon; if (icon == null) { continue; } // do this once for both passes icon.DistanceToIcon = Vector3.Length(icon.Position - drawArgs.WorldCamera.Position); // do PreRender regardless of everything else // note that mouseover actions happen one render cycle after mouse is over icon icon.PreRender(drawArgs, (mouseOverIcon != null) && (icon == mouseOverIcon)); } else if (ro is RenderableObjectList) { (ro as RenderableObjectList).RenderChildren(drawArgs, priority); } //// hack to render both surface images and terrain mapped images. //else if (priority == RenderPriority.TerrainMappedImages) //{ // if (ro.RenderPriority == RenderPriority.SurfaceImages || ro.RenderPriority == RenderPriority.TerrainMappedImages) // { // ro.Render(drawArgs); // } //} else // if (ro.RenderPriority == priority) { ro.Render(drawArgs); } } } catch (Exception ex) { Log.Write(ex); } finally { m_childrenRWLock.ReleaseReaderLock(); } m_labelRectangles.Clear(); int closestIconDistanceSquared = int.MaxValue; Icon closestIcon = null; if (priority == RenderPriority.Icons) { try { m_sprite.Begin(SpriteFlags.AlphaBlend); // Now render just the icons m_childrenRWLock.AcquireReaderLock(Timeout.Infinite); try { foreach (RenderableObject ro in m_children) { if (!ro.IsOn) { continue; } Icon icon = ro as Icon; if (icon == null) { continue; } // don't try to render if we aren't in view or too far away if ((drawArgs.WorldCamera.ViewFrustum.ContainsPoint(icon.Position)) && (icon.DistanceToIcon <= icon.MaximumDisplayDistance) && (icon.DistanceToIcon >= icon.MinimumDisplayDistance)) { Vector3 translationVector = new Vector3( (float)(icon.PositionD.X - drawArgs.WorldCamera.ReferenceCenter.X), (float)(icon.PositionD.Y - drawArgs.WorldCamera.ReferenceCenter.Y), (float)(icon.PositionD.Z - drawArgs.WorldCamera.ReferenceCenter.Z)); Vector3 projectedPoint = drawArgs.WorldCamera.Project(translationVector); // check if inside bounding box of icon int dx = DrawArgs.LastMousePosition.X - (int)projectedPoint.X; int dy = DrawArgs.LastMousePosition.Y - (int)projectedPoint.Y; if (icon.SelectionRectangle.Contains(dx, dy)) { // Mouse is over, check whether this icon is closest int distanceSquared = dx * dx + dy * dy; if (distanceSquared < closestIconDistanceSquared) { closestIconDistanceSquared = distanceSquared; closestIcon = icon; } } // mouseover is always one render cycle behind...we mark that an icon is the mouseover // icon and render it normally. On the NEXT pass it renders as a mouseover icon if (icon != mouseOverIcon) { // Note: Always render hooked icons as a real icon rather than a sprite. if (icon.UsePointSprite && (icon.DistanceToIcon > icon.PointSpriteDistance) && m_canUsePointSprites && !icon.IsHooked) { PointSpriteVertex pv = new PointSpriteVertex(translationVector.X, translationVector.Y, translationVector.Z, icon.PointSpriteSize, icon.PointSpriteColor.ToArgb()); pointSprites.Add(pv); } else { // add pointsprite anyway if (icon.UsePointSprite && icon.AlwaysRenderPointSprite) { PointSpriteVertex pv = new PointSpriteVertex(translationVector.X, translationVector.Y, translationVector.Z, icon.PointSpriteSize, icon.PointSpriteColor.ToArgb()); pointSprites.Add(pv); } icon.FastRender(drawArgs, m_sprite, projectedPoint, false, m_labelRectangles); } } } else { // do whatever we're supposed to do if we're not in view or too far away icon.NoRender(drawArgs); } // do post rendering even if we don't render // note that mouseover actions happen one render cycle after mouse is over icon icon.PostRender(drawArgs, icon == mouseOverIcon); } } catch (Exception ex) { System.Console.WriteLine(ex.Message.ToString()); } finally { m_childrenRWLock.ReleaseReaderLock(); } // Clear the rectangles so that mouseover label always appears m_labelRectangles.Clear(); // Render the mouse over icon last (on top) if (mouseOverIcon != null) { Vector3 translationVector = new Vector3( (float)(mouseOverIcon.PositionD.X - drawArgs.WorldCamera.ReferenceCenter.X), (float)(mouseOverIcon.PositionD.Y - drawArgs.WorldCamera.ReferenceCenter.Y), (float)(mouseOverIcon.PositionD.Z - drawArgs.WorldCamera.ReferenceCenter.Z)); Vector3 projectedPoint = drawArgs.WorldCamera.Project(translationVector); if (mouseOverIcon.UsePointSprite && mouseOverIcon.AlwaysRenderPointSprite && m_canUsePointSprites) { // add pointsprite anyway PointSpriteVertex pv = new PointSpriteVertex(translationVector.X, translationVector.Y, translationVector.Z, mouseOverIcon.PointSpriteSize, mouseOverIcon.PointSpriteColor.ToArgb()); pointSprites.Add(pv); } mouseOverIcon.FastRender(drawArgs, m_sprite, projectedPoint, true, m_labelRectangles); } // set new mouseover icon mouseOverIcon = closestIcon; } catch (Exception ex) { System.Console.WriteLine(ex.Message.ToString()); } finally { m_sprite.End(); } // render point sprites if any in the list try { if (pointSprites.Count > 0) { // save device state Texture origTexture = drawArgs.device.GetTexture(0); VertexFormats origVertexFormat = drawArgs.device.VertexFormat; float origPointScaleA = drawArgs.device.RenderState.PointScaleA; float origPointScaleB = drawArgs.device.RenderState.PointScaleB; float origPointScaleC = drawArgs.device.RenderState.PointScaleC; bool origPointSpriteEnable = drawArgs.device.RenderState.PointSpriteEnable; bool origPointScaleEnable = drawArgs.device.RenderState.PointScaleEnable; Blend origSourceBlend = drawArgs.device.RenderState.SourceBlend; Blend origDestBlend = drawArgs.device.RenderState.DestinationBlend; // set device to do point sprites drawArgs.device.SetTexture(0, m_pointTexture.Texture); drawArgs.device.VertexFormat = VertexFormats.Position | VertexFormats.PointSize | VertexFormats.Diffuse; drawArgs.device.RenderState.PointScaleA = 1f; drawArgs.device.RenderState.PointScaleB = 0f; drawArgs.device.RenderState.PointScaleC = 0f; //drawArgs.device.RenderState.PointScaleA = 0f; //drawArgs.device.RenderState.PointScaleB = 0f; //drawArgs.device.RenderState.PointScaleC = .0000000000001f; drawArgs.device.RenderState.PointSpriteEnable = true; drawArgs.device.RenderState.PointScaleEnable = true; drawArgs.device.RenderState.SourceBlend = Blend.One; drawArgs.device.RenderState.DestinationBlend = Blend.InvSourceAlpha; drawArgs.device.SetTextureStageState(0, TextureStageStates.ColorOperation, (int)TextureOperation.Modulate); drawArgs.device.SetTextureStageState(0, TextureStageStates.ColorArgument1, (int)TextureArgument.TextureColor); drawArgs.device.SetTextureStageState(0, TextureStageStates.ColorArgument2, (int)TextureArgument.Diffuse); drawArgs.device.DrawUserPrimitives(PrimitiveType.PointList, pointSprites.Count, pointSprites.ToArray()); // restore device state drawArgs.device.SetTexture(0, origTexture); drawArgs.device.VertexFormat = origVertexFormat; drawArgs.device.RenderState.PointScaleA = origPointScaleA; drawArgs.device.RenderState.PointScaleB = origPointScaleB; drawArgs.device.RenderState.PointScaleC = origPointScaleC; drawArgs.device.RenderState.PointSpriteEnable = origPointSpriteEnable; drawArgs.device.RenderState.PointScaleEnable = origPointScaleEnable; drawArgs.device.RenderState.SourceBlend = origSourceBlend; drawArgs.device.RenderState.DestinationBlend = origDestBlend; } } catch (Exception ex) { System.Console.WriteLine(ex.Message.ToString()); } } }
public Mesh(int numFaces, int numVertices, MeshFlags options, VertexFormats vertexFormat, Device device) : base((IntPtr)null) { throw new NotImplementedException(); }
/// <summary> /// Create an AutoVertexBuffer /// </summary> public AutoVertexBuffer(Direct3d d3d, Type vertexType, int numVerts, Usage usage, VertexFormats format, Pool pool) { mVertexBuffer = new VertexBuffer(vertexType, numVerts == 0 ? 1 : numVerts, d3d.Dx, usage, format, pool); mD3d = d3d; mVertexType = vertexType; mVertexNumVertices = numVerts; mVertexUsage = usage; mVertexFormat = format; mVertexPool = pool; d3d.DxLost += new Direct3d.DxDirect3dDelegate(d3d_DxLost); d3d.DxRestore += new Direct3d.DxDirect3dDelegate(d3d_DxRestore); }
/// <summary> /// Sets the desired vertex format for the mesh /// </summary> public void SetVertexFormat(VertexFormats format) { vf = format; vfSet = true; }
protected void RebuildStructure(Device device, NuSceneBuffer3D sceneBuffer, GeneralStructuresShadingDesc shading) { boundingBox = GenerateBoundingBoxFromPoints(sceneBuffer.triangleStrips); bool useClrAxis = shading.RibbonsShadingDesc.PropertiesInUse.ContainsKey("UseClrAxis"); Vector4 xClrStep = new Vector4(), yClrStep = new Vector4(), zClrStep = new Vector4(); Vector4 xClrStart = new Vector4(), yClrStart = new Vector4(), zClrStart = new Vector4(); if (useClrAxis) { // pre-calculate colour ranges scale from bounding box Color xClrA, xClrB; if (shading.RibbonsShadingDesc.Clrs.XEnabled) { xClrA = shading.RibbonsShadingDesc.Clrs.Xa; xClrB = shading.RibbonsShadingDesc.Clrs.Xb; } else { xClrA = xClrB = shading.RibbonsShadingDesc.DefaultClr; } Color yClrA, yClrB; if (shading.RibbonsShadingDesc.Clrs.YEnabled) { yClrA = shading.RibbonsShadingDesc.Clrs.Ya; yClrB = shading.RibbonsShadingDesc.Clrs.Yb; } else { yClrA = yClrB = shading.RibbonsShadingDesc.DefaultClr; } Color zClrA, zClrB; if (shading.RibbonsShadingDesc.Clrs.ZEnabled) { zClrA = shading.RibbonsShadingDesc.Clrs.Za; zClrB = shading.RibbonsShadingDesc.Clrs.Zb; } else { zClrA = zClrB = shading.RibbonsShadingDesc.DefaultClr; } float difA = xClrB.A - xClrA.A; float difR = xClrB.R - xClrA.R; float difG = xClrB.G - xClrA.G; float difB = xClrB.B - xClrA.B; // calc steps xClrStep = new Vector4(difA / boundingBox.Dimensions.X, difR / boundingBox.Dimensions.X, difG / boundingBox.Dimensions.X, difB / boundingBox.Dimensions.X); difA = yClrB.A - yClrA.A; difR = yClrB.R - yClrA.R; difG = yClrB.G - yClrA.G; difB = yClrB.B - yClrA.B; yClrStep = new Vector4(difA / boundingBox.Dimensions.Y, difR / boundingBox.Dimensions.Y, difG / boundingBox.Dimensions.Y, difB / boundingBox.Dimensions.Y); difA = zClrB.A - zClrA.A; difR = zClrB.R - zClrA.R; difG = zClrB.G - zClrA.G; difB = zClrB.B - zClrA.B; zClrStep = new Vector4(difA / boundingBox.Dimensions.Z, difR / boundingBox.Dimensions.Z, difG / boundingBox.Dimensions.Z, difB / boundingBox.Dimensions.Z); } if (shading.RibbonsShadingDesc.ShadingType == RibbonsShadingDesc.Shading.Solid) { // make triangle strips List <Vector3[]> triStripsList = sceneBuffer.triangleStrips; triStrips = new VertexBuffer[triStripsList.Count]; triStripsMirrored = new VertexBuffer[triStripsList.Count]; triStripSizes = new int[triStripsList.Count]; for (int strip = 0; strip < triStripsList.Count; strip++) { Vector3[] points = triStripsList[strip]; if (useClrAxis) { vFormat = CustomVertex.PositionNormalColored.Format; triStrips[strip] = new VertexBuffer(typeof(CustomVertex.PositionNormalColored), points.Length, device, Usage.None, CustomVertex.PositionNormalColored.Format, Pool.Managed); triStripSizes[strip] = points.Length - 2; CustomVertex.PositionNormalColored[] verts = (CustomVertex.PositionNormalColored[]) triStrips[strip].Lock(0, LockFlags.None); float xStart = boundingBox.Centre.X - (boundingBox.Dimensions.X / 2.0f); float yStart = boundingBox.Centre.Y - (boundingBox.Dimensions.Y / 2.0f); float zStart = boundingBox.Centre.Z - (boundingBox.Dimensions.Z / 2.0f); for (int v = 1; v < points.Length - 1; v++) { // V1 float xSteps = points[v - 1].X - xStart; float ySteps = points[v - 1].Y - yStart; float zSteps = points[v - 1].Z - zStart; // blend XYZ colours int A = (int)((xClrStep.X * xSteps) + (yClrStep.X * ySteps) + (zClrStep.X * zSteps)); int R = (int)((xClrStep.Y * xSteps) + (yClrStep.Y * ySteps) + (zClrStep.Y * zSteps)); int G = (int)((xClrStep.Z * xSteps) + (yClrStep.Z * ySteps) + (zClrStep.Z * zSteps)); int B = (int)((xClrStep.W * xSteps) + (yClrStep.W * ySteps) + (zClrStep.W * zSteps)); verts[v - 1].Color = Color.FromArgb(A, R, G, B).ToArgb(); verts[v - 1].Position = points[v - 1]; // V2 xSteps = points[v].X - xStart; ySteps = points[v].Y - yStart; zSteps = points[v].Z - zStart; // blend XYZ colours A = (int)((xClrStep.X * xSteps) + (yClrStep.X * ySteps) + (zClrStep.X * zSteps)); R = (int)((xClrStep.Y * xSteps) + (yClrStep.Y * ySteps) + (zClrStep.Y * zSteps)); G = (int)((xClrStep.Z * xSteps) + (yClrStep.Z * ySteps) + (zClrStep.Z * zSteps)); B = (int)((xClrStep.W * xSteps) + (yClrStep.W * ySteps) + (zClrStep.W * zSteps)); verts[v].Color = Color.FromArgb(A, R, G, B).ToArgb(); verts[v].Position = points[v]; // V3 xSteps = points[v + 1].X - xStart; ySteps = points[v + 1].Y - yStart; zSteps = points[v + 1].Z - zStart; // blend XYZ colours A = (int)((xClrStep.X * xSteps) + (yClrStep.X * ySteps) + (zClrStep.X * zSteps)); R = (int)((xClrStep.Y * xSteps) + (yClrStep.Y * ySteps) + (zClrStep.Y * zSteps)); G = (int)((xClrStep.Z * xSteps) + (yClrStep.Z * ySteps) + (zClrStep.Z * zSteps)); B = (int)((xClrStep.W * xSteps) + (yClrStep.W * ySteps) + (zClrStep.W * zSteps)); verts[v + 1].Color = Color.FromArgb(A, R, G, B).ToArgb(); verts[v + 1].Position = points[v + 1]; // normals Vector3 v0 = verts[v + 1].Position; Vector3 v1 = verts[v].Position; Vector3 v2 = verts[v - 1].Position; Vector3 e1 = v1 - v0, e2 = v2 - v0; Vector3 vNormal = Vector3.Normalize(Vector3.Cross(e1, e2)); verts[v - 1].Normal += vNormal; verts[v].Normal += vNormal; verts[v + 1].Normal += vNormal; if (v != 1) { verts[v - 1].Normal *= 0.5f; } if (v == points.Length - 1) { verts[v].Normal *= 0.5f; } } // mirror for double-sided triStripsMirrored[strip] = new VertexBuffer(typeof(CustomVertex.PositionNormalColored), points.Length, device, Usage.None, CustomVertex.PositionNormalColored.Format, Pool.Managed); // clone triStripsMirrored[strip].SetData(verts, 0, LockFlags.None); triStrips[strip].Unlock(); // flip FlipNormalsVB(triStripsMirrored[strip], CustomVertex.PositionNormalColored.Format, triStripSizes[strip]); } else { vFormat = CustomVertex.PositionNormal.Format; triStrips[strip] = new VertexBuffer(typeof(CustomVertex.PositionNormal), points.Length, device, Usage.None, CustomVertex.PositionNormal.Format, Pool.Managed); triStripSizes[strip] = points.Length - 2; CustomVertex.PositionNormal[] verts = (CustomVertex.PositionNormal[]) triStrips[strip].Lock(0, LockFlags.None); for (int v = 1; v < points.Length - 1; v++) { // positions verts[v - 1].Position = points[v + 1]; verts[v].Position = points[v]; verts[v + 1].Position = points[v - 1]; // normals Vector3 v0 = verts[v - 1].Position; Vector3 v1 = verts[v].Position; Vector3 v2 = verts[v + 1].Position; Vector3 e1 = v1 - v0, e2 = v2 - v0; Vector3 vNormal = Vector3.Normalize(Vector3.Cross(e1, e2)); verts[v - 1].Normal += vNormal; verts[v].Normal += vNormal; verts[v + 1].Normal += vNormal; if (v != 1) { verts[v - 1].Normal *= 0.5f; } if (v == points.Length - 1) { verts[v].Normal *= 0.5f; } } // mirror for double-sided triStripsMirrored[strip] = new VertexBuffer(typeof(CustomVertex.PositionNormal), points.Length, device, Usage.None, CustomVertex.PositionNormal.Format, Pool.Managed); // clone triStripsMirrored[strip].SetData(verts, 0, LockFlags.None); triStrips[strip].Unlock(); // flip FlipNormalsVB(triStripsMirrored[strip], CustomVertex.PositionNormal.Format, triStripSizes[strip]); } } } else if (shading.RibbonsShadingDesc.ShadingType == RibbonsShadingDesc.Shading.Edges) { } }
/// <summary> /// Set the flexible vertex format /// </summary> public void SetVertexFormat(Device device, VertexFormats format) { Mesh pTempSysMemMesh = null; Mesh pTempLocalMesh = null; if (systemMemoryMesh != null) { pTempSysMemMesh = systemMemoryMesh.Clone(MeshFlags.SystemMemory, format, device); } if (localMemoryMesh != null) { try { pTempLocalMesh = localMemoryMesh.Clone(0, format, device); } catch (Exception e) { pTempSysMemMesh.Dispose(); pTempSysMemMesh = null; throw e; } } if (systemMemoryMesh != null) systemMemoryMesh.Dispose(); systemMemoryMesh = null; if (localMemoryMesh != null) localMemoryMesh.Dispose(); localMemoryMesh = null; // Clean up any vertex/index buffers DisposeLocalBuffers(true, true); if (pTempSysMemMesh != null) systemMemoryMesh = pTempSysMemMesh; if (pTempLocalMesh != null) localMemoryMesh = pTempLocalMesh; // Compute normals in case the meshes have them if (systemMemoryMesh != null) systemMemoryMesh.ComputeNormals(); if (localMemoryMesh != null) localMemoryMesh.ComputeNormals(); }
public SkyBox(Device device3D, string xFileName, Vector3 scal, VertexFormats vertexFormat) : base(device3D, xFileName, scal, vertexFormat) { }
protected void SetupTextured() { m_TexturedVertices = new CustomVertex.PositionTextured[4]; m_VertexFormat = CustomVertex.PositionTextured.Format; m_VertexBuffer = new VertexBuffer(typeof(CustomVertex.PositionTextured), 4, D3DDevice, Usage.Dynamic | Usage.WriteOnly, m_VertexFormat, Pool.Default); m_TexturedVertices[0].Position = new Vector3(m_x1, m_y1, m_z1); m_TexturedVertices[0].Tu = 0f; m_TexturedVertices[0].Tv = 0f; m_TexturedVertices[1].Position = new Vector3(m_x2, m_y2, m_z2); m_TexturedVertices[1].Tu = 0f; m_TexturedVertices[1].Tv = 1f; m_TexturedVertices[2].Position = new Vector3(m_x3, m_y3, m_z3); m_TexturedVertices[2].Tu = 1f; m_TexturedVertices[2].Tv = 1f; m_TexturedVertices[3].Position = new Vector3(m_x4, m_y4, m_z4); m_TexturedVertices[3].Tu = 1f; m_TexturedVertices[3].Tv = 0f; m_VertexBuffer.SetData(m_TexturedVertices, 0, LockFlags.None); }
public void Render() { lock (_OSDLock) { // Store current settings so they can be restored when we are done VertexFormats vertexFormat = GUIGraphicsContext.DX9Device.VertexFormat; try { if (_OSDTexture == null || _OSDTexture.Disposed) { return; } int wx = 0, wy = 0, wwidth = 0, wheight = 0; if (GUIGraphicsContext.IsFullScreenVideo) { wheight = PlaneScene.DestRect.Height; wwidth = PlaneScene.DestRect.Width; wx = GUIGraphicsContext.OverScanLeft; wy = GUIGraphicsContext.OverScanTop; if (PlaneScene.DestRect.X == 0 || PlaneScene.DestRect.Y == 0) { wx += PlaneScene.DestRect.X; wy += PlaneScene.DestRect.Y; } } else // Video overlay { wheight = GUIGraphicsContext.VideoWindow.Height; wwidth = GUIGraphicsContext.VideoWindow.Width; wx = GUIGraphicsContext.VideoWindow.Right - (GUIGraphicsContext.VideoWindow.Width); wy = GUIGraphicsContext.VideoWindow.Top; } DXNative.FontEngineSetRenderState((int)D3DRENDERSTATETYPE.D3DRS_ALPHABLENDENABLE, 1); CreateVertexBuffer(wx, wy, wwidth, wheight); // Make sure D3D objects haven't been disposed for some reason. This would cause // an access violation on native side, causing Skin Engine to halt rendering if (!_OSDTexture.Disposed && !_vertexBuffer.Disposed) { GUIGraphicsContext.DX9Device.SetStreamSource(0, _vertexBuffer, 0); GUIGraphicsContext.DX9Device.SetTexture(0, _OSDTexture); GUIGraphicsContext.DX9Device.VertexFormat = CustomVertex.TransformedTextured.Format; GUIGraphicsContext.DX9Device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2); } else { Log.Debug("OSD renderer: D3D resource was disposed! Not trying to render the texture"); } } catch (Exception e) { Log.Error(e); } try { // Restore device settings GUIGraphicsContext.DX9Device.SetTexture(0, null); GUIGraphicsContext.DX9Device.VertexFormat = vertexFormat; } catch (Exception e) { Log.Error(e); } } }
/// <summary> /// Cone the mesh (and textures that it contains), /// optionally converting the vertex and texture format. /// </summary> public AutoMesh Clone(Direct3d d3d, MeshFlags flags, VertexFormats vertexFormat, Format textureFormat, Usage usage, Pool pool) { // Clone the mesh vertex info Mesh mesh = mMesh.Clone(flags, vertexFormat, d3d.Dx); AutoMesh autoMesh = new AutoMesh(d3d, mesh); // Clone AutoMesh variables autoMesh.Tag = Tag; // Clone textures and materials if (mTextures.Length != 0) { // Clone materials autoMesh.mMaterials = new Material[mMaterials.Length]; for (int i = 0; i < mMaterials.Length; i++) autoMesh.mMaterials[i] = mMaterials[i]; // Clone textures autoMesh.mTextures = new AutoTexture[mTextures.Length]; for (int i = 0; i < mTextures.Length; i++) if (mTextures[i] != null) { // Already cloned this texture? bool alreadyConvertedTexture = false; for (int j = 0; j < i; j++) if (mTextures[i] == mTextures[j]) { alreadyConvertedTexture = true; autoMesh.mTextures[i] = autoMesh.mTextures[j]; break; } // Clone new texture if (!alreadyConvertedTexture) autoMesh.mTextures[i] = mTextures[i].Clone(d3d, textureFormat, usage, pool); } } return autoMesh; }
public void BuildBuffers(Device device) { if (Geometry.Normals != null) { if (Geometry.VertexClrs != null) { vFormat = CustomVertex.PositionNormalColored.Format; vBuffer = new VertexBuffer(typeof(CustomVertex.PositionNormalColored), Geometry.Vertices.Length, device, Usage.None, CustomVertex.PositionNormalColored.Format, Pool.Managed); CustomVertex.PositionNormalColored[] verts = (CustomVertex.PositionNormalColored[])vBuffer.Lock(0, LockFlags.None); for (int i = 0; i < Geometry.Vertices.Length; i++) { verts[i].Position = Geometry.Vertices[i]; verts[i].Normal = Geometry.Normals[i]; verts[i].Color = Geometry.VertexClrs[i]; } vBuffer.Unlock(); } else { if (Geometry.TexCoords != null) { vFormat = CustomVertex.PositionNormalTextured.Format; vBuffer = new VertexBuffer(typeof(CustomVertex.PositionNormalTextured), Geometry.Vertices.Length, device, Usage.None, CustomVertex.PositionNormalTextured.Format, Pool.Managed); CustomVertex.PositionNormalTextured[] verts = (CustomVertex.PositionNormalTextured[])vBuffer.Lock(0, LockFlags.None); for (int i = 0; i < Geometry.Vertices.Length; i++) { verts[i].Position = Geometry.Vertices[i]; verts[i].Normal = Geometry.Normals[i]; verts[i].Tu = Geometry.TexCoords[i].X; verts[i].Tv = Geometry.TexCoords[i].Y; } vBuffer.Unlock(); } else { vFormat = CustomVertex.PositionNormal.Format; vBuffer = new VertexBuffer(typeof(CustomVertex.PositionNormal), Geometry.Vertices.Length, device, Usage.None, CustomVertex.PositionNormal.Format, Pool.Managed); CustomVertex.PositionNormal[] verts = (CustomVertex.PositionNormal[])vBuffer.Lock(0, LockFlags.None); for (int i = 0; i < Geometry.Vertices.Length; i++) { verts[i].Position = Geometry.Vertices[i]; verts[i].Normal = Geometry.Normals[i]; } vBuffer.Unlock(); } } } else { if (Geometry.VertexClrs != null) { vFormat = CustomVertex.PositionColored.Format; vBuffer = new VertexBuffer(typeof(CustomVertex.PositionColored), Geometry.Vertices.Length, device, Usage.None, CustomVertex.PositionColored.Format, Pool.Managed); CustomVertex.PositionColored[] verts = (CustomVertex.PositionColored[])vBuffer.Lock(0, LockFlags.None); for (int i = 0; i < Geometry.Vertices.Length; i++) { verts[i].Position = Geometry.Vertices[i]; verts[i].Color = Geometry.VertexClrs[i]; } vBuffer.Unlock(); } else { if (Geometry.TexCoords != null) { vFormat = CustomVertex.PositionTextured.Format; vBuffer = new VertexBuffer(typeof(CustomVertex.PositionTextured), Geometry.Vertices.Length, device, Usage.None, CustomVertex.PositionTextured.Format, Pool.Managed); CustomVertex.PositionTextured[] verts = (CustomVertex.PositionTextured[])vBuffer.Lock(0, LockFlags.None); for (int i = 0; i < Geometry.Vertices.Length; i++) { verts[i].Position = Geometry.Vertices[i]; verts[i].Tu = Geometry.TexCoords[i].X; verts[i].Tv = Geometry.TexCoords[i].Y; } vBuffer.Unlock(); } else { vFormat = CustomVertex.PositionOnly.Format; vBuffer = new VertexBuffer(typeof(CustomVertex.PositionOnly), Geometry.Vertices.Length, device, Usage.None, CustomVertex.PositionOnly.Format, Pool.Managed); CustomVertex.PositionOnly[] verts = (CustomVertex.PositionOnly[])vBuffer.Lock(0, LockFlags.None); for (int i = 0; i < Geometry.Vertices.Length; i++) { verts[i].Position = Geometry.Vertices[i]; } vBuffer.Unlock(); } } } if (Geometry.PrimIndices != null) { if (MaterialIndices != null) { matIBuffers = new IndexBuffer[MaterialIndices.Length]; int mibIdx = 0; foreach (ABMaterialIndex matIndex in MaterialIndices) { if (matIndex.Material.Texture == null && matIndex.Material.TextureName != null) { if (File.Exists(matIndex.Material.TextureName)) { matIndex.Material.Texture = TextureLoader.FromFile(device, matIndex.Material.TextureName); } } int numIndices = matIndex.Indices.Length * 3; IndexBuffer buffer = matIBuffers[mibIdx++] = new IndexBuffer(typeof(int), numIndices, device, Usage.None, Pool.Managed); int[] indices = (int[])buffer.Lock(0, LockFlags.None); int iIdx = 0; for (int i = 0; i < matIndex.Indices.Length; i++) { int index = matIndex.Indices[i] * 3; indices[iIdx++] = Geometry.PrimIndices[index]; indices[iIdx++] = Geometry.PrimIndices[index + 1]; indices[iIdx++] = Geometry.PrimIndices[index + 2]; } buffer.Unlock(); switch (Geometry.PrimType) { case PrimitiveType.LineList: matIndex.PrimCount = numIndices / 2; break; case PrimitiveType.LineStrip: matIndex.PrimCount = numIndices - 1; break; case PrimitiveType.PointList: matIndex.PrimCount = numIndices; break; case PrimitiveType.TriangleList: matIndex.PrimCount = numIndices / 3; break; } } } else { iBuffer = new IndexBuffer(typeof(int), Geometry.PrimIndices.Length, device, Usage.None, Pool.Managed); //iBuffer.SetData(Geometry.PrimIndices, 0, LockFlags.None); int[] indices = (int[])iBuffer.Lock(0, LockFlags.None); for (int i = 0; i < Geometry.PrimIndices.Length; i++) { indices[i] = Geometry.PrimIndices[i]; } iBuffer.Unlock(); switch (Geometry.PrimType) { case PrimitiveType.LineList: numPrimitives = Geometry.PrimIndices.Length / 2; break; case PrimitiveType.LineStrip: numPrimitives = Geometry.PrimIndices.Length - 1; break; case PrimitiveType.PointList: numPrimitives = Geometry.PrimIndices.Length; break; case PrimitiveType.TriangleList: numPrimitives = Geometry.PrimIndices.Length / 3; break; } } } else { switch (Geometry.PrimType) { case PrimitiveType.LineList: numPrimitives = Geometry.Vertices.Length / 2; break; case PrimitiveType.LineStrip: numPrimitives = Geometry.Vertices.Length - 1; break; case PrimitiveType.PointList: numPrimitives = Geometry.Vertices.Length; break; case PrimitiveType.TriangleList: numPrimitives = Geometry.Vertices.Length / 3; break; } } }
public static float ComputeBoundingSphere(GraphicsStream pointsFvf, int numVertices, VertexFormats vertexFormat, out Vector3 center) { throw new NotImplementedException(); }
public static void ComputeBoundingBox(GraphicsStream pointsFvf, int numVertices, VertexFormats vertexFormat, out Vector3 min, out Vector3 max) { throw new NotImplementedException(); }
public Mesh3D(Device device3D, string xFileName, Vector3 scal, VertexFormats vertexFormat) { _device3d = device3D; Scal = scal; _vertexFormat = vertexFormat; string currentDirectory = Application.StartupPath; try { ExtendedMaterial[] materialArray; // // Check DirectX |*.x file name // if (!xFileName.EndsWith(".x", true, new System.Globalization.CultureInfo("en-US"))) { throw new Exception(@"Your File is not a DirectX file |*.x" + "\n\rPlease Enter correct FileName."); } if (!System.IO.File.Exists(System.Windows.Forms.Application.StartupPath + @"\myMeshs\" + xFileName)) { throw new NotFoundException("Given path was not found."); } Directory.SetCurrentDirectory(Application.StartupPath + @"\myMeshs\"); mesh = Mesh.FromFile(xFileName, MeshFlags.Managed, device3D, out materialArray); // // Compute Normals // if (vertexFormat == CustomVertex.PositionNormalTextured.Format) { mesh = mesh.Clone(mesh.Options.Value, CustomVertex.PositionNormalTextured.Format, device3D); mesh.ComputeNormals(); } else if (vertexFormat == CustomVertex.PositionNormalColored.Format) { mesh = mesh.Clone(mesh.Options.Value, CustomVertex.PositionNormalColored.Format, device3D); mesh.ComputeNormals(); } // // set data // if (materialArray != null && materialArray.Length > 0) { MeshMaterials = new Material[materialArray.Length]; MeshTexturs = new Texture[materialArray.Length]; for (int i = 0; i < materialArray.Length; i++) { MeshMaterials[i] = materialArray[i].Material3D; MeshMaterials[i].Ambient = MeshMaterials[i].Diffuse; if (!string.IsNullOrEmpty(materialArray[i].TextureFilename)) { MeshTexturs[i] = TextureLoader.FromFile(device3D, materialArray[i].TextureFilename); } } } ComputeRadius(); optimaize(Math.Max(Math.Max(scal.X, scal.Y), scal.Z)); } catch (Exception ex) { System.Windows.Forms.MessageBox.Show(ex.Message, ex.Source, System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error); hasError = true; } finally { Directory.SetCurrentDirectory(currentDirectory); } }
public VertexBuffer(Device device, int sizeOfBufferInBytes, Usage usage, VertexFormats vertexFormat, Pool pool) : base((IntPtr)null) { throw new NotImplementedException(); }
public override void Render(DrawArgs drawArgs) { if (!isOn) { return; } if (!isInitialized) { Initialize(drawArgs); } m_pointSprites.Clear(); int closestIconDistanceSquared = int.MaxValue; PointIcon closestIcon = null; // build list of all points in view foreach (PointIcon point in m_points.Values) { try { // don't bother to do anything else if we aren't even in view if (drawArgs.WorldCamera.ViewFrustum.ContainsPoint(point.Position)) { Vector3 translationVector = new Vector3( (float)(point.PositionD.X - drawArgs.WorldCamera.ReferenceCenter.X), (float)(point.PositionD.Y - drawArgs.WorldCamera.ReferenceCenter.Y), (float)(point.PositionD.Z - drawArgs.WorldCamera.ReferenceCenter.Z)); Vector3 projectedPoint = drawArgs.WorldCamera.Project(translationVector); // check if inside bounding box of icon int dx = DrawArgs.LastMousePosition.X - (int)projectedPoint.X; int dy = DrawArgs.LastMousePosition.Y - (int)projectedPoint.Y; if (SelectionRectangle.Contains(dx, dy)) { // Mouse is over, check whether this icon is closest int distanceSquared = dx * dx + dy * dy; if (distanceSquared < closestIconDistanceSquared) { closestIconDistanceSquared = distanceSquared; closestIcon = point; } } PointSpriteVertex pv = new PointSpriteVertex(translationVector.X, translationVector.Y, translationVector.Z, point.Size, point.Color.ToArgb()); m_pointSprites.Add(pv); } } catch { } finally { } } // render point sprites if any in the list try { if (m_pointSprites.Count > 0) { // save device state Texture origTexture = drawArgs.device.GetTexture(0); VertexFormats origVertexFormat = drawArgs.device.VertexFormat; float origPointScaleA = drawArgs.device.RenderState.PointScaleA; float origPointScaleB = drawArgs.device.RenderState.PointScaleB; float origPointScaleC = drawArgs.device.RenderState.PointScaleC; bool origPointSpriteEnable = drawArgs.device.RenderState.PointSpriteEnable; bool origPointScaleEnable = drawArgs.device.RenderState.PointScaleEnable; Blend origSourceBlend = drawArgs.device.RenderState.SourceBlend; Blend origDestBlend = drawArgs.device.RenderState.DestinationBlend; // set device to do point sprites drawArgs.device.SetTexture(0, m_pointTexture.Texture); drawArgs.device.VertexFormat = VertexFormats.Position | VertexFormats.PointSize | VertexFormats.Diffuse; drawArgs.device.RenderState.PointScaleA = 1f; drawArgs.device.RenderState.PointScaleB = 0f; drawArgs.device.RenderState.PointScaleC = 0f; drawArgs.device.RenderState.PointSpriteEnable = true; drawArgs.device.RenderState.PointScaleEnable = true; //drawArgs.device.RenderState.SourceBlend = Blend.One; //drawArgs.device.RenderState.DestinationBlend = Blend.BlendFactor; drawArgs.device.SetTextureStageState(0, TextureStageStates.ColorOperation, (int)TextureOperation.Modulate); drawArgs.device.SetTextureStageState(0, TextureStageStates.ColorArgument1, (int)TextureArgument.TextureColor); drawArgs.device.SetTextureStageState(0, TextureStageStates.ColorArgument2, (int)TextureArgument.Diffuse); // Draw all visible points drawArgs.device.DrawUserPrimitives(PrimitiveType.PointList, m_pointSprites.Count, m_pointSprites.ToArray()); // Draw label and description of mouseover point if (closestIcon != null) { } // restore device state drawArgs.device.SetTexture(0, origTexture); drawArgs.device.VertexFormat = origVertexFormat; drawArgs.device.RenderState.PointScaleA = origPointScaleA; drawArgs.device.RenderState.PointScaleB = origPointScaleB; drawArgs.device.RenderState.PointScaleC = origPointScaleC; drawArgs.device.RenderState.PointSpriteEnable = origPointSpriteEnable; drawArgs.device.RenderState.PointScaleEnable = origPointScaleEnable; drawArgs.device.RenderState.SourceBlend = origSourceBlend; drawArgs.device.RenderState.DestinationBlend = origDestBlend; } } catch { } }
protected void SetupColored() { m_ColoredVertices = new CustomVertex.PositionColored[4]; m_VertexFormat = CustomVertex.PositionColored.Format; m_VertexBuffer = new VertexBuffer(typeof(CustomVertex.PositionColored), 4, device, Usage.Dynamic | Usage.WriteOnly, m_VertexFormat, Pool.Default); m_ColoredVertices[0].Position = new Vector3(m_x1, m_y1, m_z1); m_ColoredVertices[0].Color = m_Color1.ToArgb(); m_ColoredVertices[1].Position = new Vector3(m_x2, m_y2, m_z2); m_ColoredVertices[1].Color = m_Color2.ToArgb(); m_ColoredVertices[2].Position = new Vector3(m_x3, m_y3, m_z3); m_ColoredVertices[2].Color = m_Color3.ToArgb(); m_ColoredVertices[3].Position = new Vector3(m_x4, m_y4, m_z4); m_ColoredVertices[3].Color = m_Color4.ToArgb(); m_VertexBuffer.SetData(m_ColoredVertices, 0, LockFlags.None); }
public Mesh Clone(MeshFlags options, VertexFormats vertexFormat, Device device) { throw new NotImplementedException(); }
public static float ComputeBoundingSphere(Array pointsFvf, VertexFormats vertexFormat, out Vector3 center) { throw new NotImplementedException(); }
public static void FlipNormalsVB(VertexBuffer vb, VertexFormats vFormat, int size) { if (vFormat == CustomVertex.PositionNormal.Format) { CustomVertex.PositionNormal[] verts = (CustomVertex.PositionNormal[]) vb.Lock(0, LockFlags.None); for (int v = 0; v < verts.Length; v++) { verts[v].Normal = new Vector3(-verts[v].Normal.X, -verts[v].Normal.Y, -verts[v].Normal.Z); } vb.Unlock(); } else if (vFormat == CustomVertex.PositionNormalColored.Format) { CustomVertex.PositionNormalColored[] verts = (CustomVertex.PositionNormalColored[]) vb.Lock(0, LockFlags.None); for (int v = 0; v < verts.Length; v++) { verts[v].Normal = new Vector3(-verts[v].Normal.X, -verts[v].Normal.Y, -verts[v].Normal.Z); } vb.Unlock(); } else if (vFormat == CustomVertex.PositionNormalTextured.Format) { CustomVertex.PositionNormalTextured[] verts = (CustomVertex.PositionNormalTextured[]) vb.Lock(0, LockFlags.None); for (int v = 0; v < verts.Length; v++) { verts[v].Normal = new Vector3(-verts[v].Normal.X, -verts[v].Normal.Y, -verts[v].Normal.Z); } vb.Unlock(); } else throw new Exception("Unsupported format to flip normals with"); }
public static void ComputeBoundingBox(Array pointsFvf, VertexFormats vertexFormat, out Vector3 min, out Vector3 max) { throw new NotImplementedException(); }
/// <summary> /// Setup the form by loading the mesh /// </summary> private void FormViewMesh_Shown(object sender, EventArgs e) { // ToDo: Show a message form while loading AutoMesh autoMesh = null; // Load the mesh (or fail and exit) try { autoMesh = AutoMesh.LoadFromXFile(mFileName, MeshFlags.SystemMemory, d3dModel); } catch { // Dispose whatever we have try { autoMesh.Dispose(); } catch { } autoMesh = null; MessageBox.Show(this, "Error loading mesh"); Hide(); return; } // Detect unsupported texture formats VertexFormats format = autoMesh.M.VertexFormat; if ( (format & VertexFormats.TextureCountMask) != VertexFormats.Texture0 && (format & VertexFormats.Texture1) != VertexFormats.Texture1 ) { MessageBox.Show(this, "Multiple textures not supported"); autoMesh.Dispose(); Hide(); return; } // Unsupported vertex formats VertexFormats unsupported = VertexFormats.Specular | VertexFormats.LastBetaD3DColor | VertexFormats.LastBetaUByte4 | VertexFormats.PointSize | VertexFormats.Transformed; if ( (int)(format & unsupported) != 0) { MessageBox.Show(this, "Unsupported vertex format"); autoMesh.Dispose(); Hide(); return; } // No position (sometimes this happens) if ( (format & VertexFormats.Position) != VertexFormats.Position ) { MessageBox.Show(this, "Unsupported vertex format (no position detected!)"); autoMesh.Dispose(); Hide(); return; } // Clone to new format, using 32 bit pixel format. try { mMesh = autoMesh.Clone(d3dModel, MeshFlags.Managed, autoMesh.M.VertexFormat, Format.A8R8G8B8, Usage.AutoGenerateMipMap, Pool.Managed); } catch { MessageBox.Show(this, "Error cloning mesh"); try { autoMesh.Dispose(); } catch { } try { mMesh.Dispose(); } catch { } Hide(); return; } autoMesh.Dispose(); autoMesh = null; // Display mesh info DisplayMeshInfo(); }