/// <summary> /// Adds vertices to manager /// </summary> /// <param name="id">Id</param> /// <param name="data">Vertex list</param> /// <param name="dynamic">Add to dynamic buffers</param> /// <param name="instances">Add instancing space</param> public BufferDescriptor Add(string id, IEnumerable <IVertexData> data, bool dynamic, int instances) { if (data?.Any() != true) { return(null); } VertexTypes vType = data.First().VertexType; var keyIndex = this.vertexData.FindIndex(k => k.Type == vType && k.Dynamic == dynamic && (k.Instances > 0 == instances > 0)); if (keyIndex < 0) { keyIndex = this.vertexData.Count; this.vertexData.Add(new VertexBufferDescription(vType, dynamic) { Name = id }); } var key = this.vertexData[keyIndex]; var descriptor = key.AddDescriptor(keyIndex, data, instances); if (key.ReallocationNeeded) { vertexBufferAllocationNeeded = true; } return(descriptor); }
/// <summary> /// Create the combined mesh entity. /// </summary> public CombinedMeshesEntity() { if (typeof(VertexType) == typeof(VertexPosition)) { _vtype = VertexTypes.VertexPosition; } else if (typeof(VertexType) == typeof(VertexPositionColor)) { _vtype = VertexTypes.VertexPositionColor; } else if (typeof(VertexType) == typeof(VertexPositionTexture)) { _vtype = VertexTypes.VertexPositionTexture; } else if (typeof(VertexType) == typeof(VertexPositionNormalTexture)) { _vtype = VertexTypes.VertexPositionNormalTexture; } else if (typeof(VertexType) == typeof(VertexPositionNormalTangentTexture)) { _vtype = VertexTypes.VertexPositionNormalTangentTexture; } else { throw new Exceptions.InvalidValueException("Unsupported vertex type in combined mesh!"); } }
public SugiVertex(TVertex originalVertex, SKSize size) { Size = size; OriginalVertex = originalVertex; Type = VertexTypes.Original; Segment = null; }
/// <summary> /// Initializes a new instance of the <see cref="SugiVertex"/> class. /// </summary> /// <param name="originalVertex">Wrapped vertex.</param> /// <param name="type">Vertex type.</param> /// <param name="size">Vertex size.</param> public SugiVertex(TVertex originalVertex, VertexTypes type, Size size) { OriginalVertex = originalVertex; Type = type; Size = size; Segment = null; }
private static Queue <VertexGroup> GetContainerLikeItems( [NotNull, ItemNotNull] AlternatingLayer alternatingLayer, VertexTypes containerLikeVertexType) { var queue = new Queue <VertexGroup>(); foreach (IData item in alternatingLayer) { var vertex = item as SugiVertex; if (vertex != null && vertex.Type == containerLikeVertexType) { queue.Enqueue(new VertexGroup(vertex.Position) { Size = 1 }); } else if (vertex is null) { var container = (ISegmentContainer)item; if (container.Count > 0) { queue.Enqueue(new VertexGroup(container.Position) { Size = container.Count }); } } } return(queue); }
/// <summary> /// Gets skinned equivalent for specified non skinning type /// </summary> /// <param name="vertexType">Vertex type</param> /// <returns>Returns skinned equivalent for specified non skinning type</returns> public static VertexTypes GetSkinnedEquivalent(VertexTypes vertexType) { if (vertexType == VertexTypes.Position) { return(VertexTypes.PositionSkinned); } if (vertexType == VertexTypes.PositionColor) { return(VertexTypes.PositionColorSkinned); } if (vertexType == VertexTypes.PositionNormalColor) { return(VertexTypes.PositionNormalColorSkinned); } if (vertexType == VertexTypes.PositionTexture) { return(VertexTypes.PositionTextureSkinned); } if (vertexType == VertexTypes.PositionNormalTexture) { return(VertexTypes.PositionNormalTextureSkinned); } if (vertexType == VertexTypes.PositionNormalTextureTangent) { return(VertexTypes.PositionNormalTextureTangentSkinned); } return(VertexTypes.Unknown); }
public SugiVertex(TVertex originalVertex) { Contract.Requires(originalVertex != null); OriginalVertex = originalVertex; Type = VertexTypes.Original; Segment = null; }
/// <summary> /// Gets whether specified vertex type is skinned or not /// </summary> /// <param name="vertexTypes">Vertex type</param> /// <returns>Returns true if the vertex type contains skinning info</returns> public static bool IsSkinned(VertexTypes vertexTypes) { return (vertexTypes == VertexTypes.PositionSkinned || vertexTypes == VertexTypes.PositionColorSkinned || vertexTypes == VertexTypes.PositionNormalColorSkinned || vertexTypes == VertexTypes.PositionTextureSkinned || vertexTypes == VertexTypes.PositionNormalTextureSkinned || vertexTypes == VertexTypes.PositionNormalTextureTangentSkinned); }
/// <summary> /// Submesh grouping optimization /// </summary> /// <param name="meshArray">Mesh array</param> /// <param name="optimizedMesh">Optimized mesh result</param> /// <returns>Returns true if the mesh array was optimized</returns> public static bool OptimizeMeshes(IEnumerable <SubMeshContent> meshArray, out SubMeshContent optimizedMesh) { optimizedMesh = null; int?count = meshArray?.Count(); if (count == 1) { optimizedMesh = meshArray.First(); } else if (count > 1) { var firstMesh = meshArray.First(); string material = firstMesh.Material; Topology topology = firstMesh.Topology; VertexTypes vertexType = firstMesh.VertexType; bool isTextured = firstMesh.Textured; List <VertexData> verts = new List <VertexData>(); List <uint> idx = new List <uint>(); uint indexOffset = 0; foreach (var mesh in meshArray) { if (mesh.VertexType != vertexType || mesh.Topology != topology) { optimizedMesh = null; return(false); } if (mesh.Vertices.Length > 0) { verts.AddRange(mesh.Vertices); } if (mesh.Indices.Length > 0) { idx.AddRange(mesh.Indices.Select(i => i + indexOffset)); } indexOffset = (uint)verts.Count; } optimizedMesh = new SubMeshContent(topology, material, isTextured, false); optimizedMesh.SetVertices(verts); optimizedMesh.SetIndices(idx); } return(true); }
private SugiVertex AddDummyVertex(VertexTypes type, int layerIndex) { var vertex = new SugiVertex(type) { LayerIndex = layerIndex }; _layers[layerIndex].Add(vertex); _graph.AddVertex(vertex); return(vertex); }
public override void ReadHeader(Stream stream, long length) { BinaryReader reader = new BinaryReader(stream); Version = reader.ReadUInt32(); ShaderName = Util.ReadString(reader); PrimitiveType = (PrimitiveTypes)reader.ReadUInt32(); VertexType = (VertexTypes)reader.ReadUInt32(); NumVertices = reader.ReadUInt32(); NumIndices = reader.ReadUInt32(); NumMatrices = reader.ReadUInt32(); }
private void PlaceQVertices( [NotNull, ItemNotNull] AlternatingLayer alternatingLayer, [NotNull, ItemNotNull] IEnumerable <SugiVertex> nextLayer, bool straightSweep) { Debug.Assert(alternatingLayer != null); Debug.Assert(nextLayer != null); VertexTypes type = straightSweep ? VertexTypes.QVertex : VertexTypes.PVertex; var qVertices = new HashSet <SugiVertex>(); foreach (SugiVertex vertex in nextLayer) { if (vertex.Type != type) { continue; } qVertices.Add(vertex); } for (int i = 0; i < alternatingLayer.Count; ++i) { var segmentContainer = alternatingLayer[i] as SegmentContainer; if (segmentContainer is null) { continue; } for (int j = 0; j < segmentContainer.Count; ++j) { ThrowIfCancellationRequested(); Segment segment = segmentContainer[j]; SugiVertex vertex = straightSweep ? segment.QVertex : segment.PVertex; if (!qVertices.Contains(vertex)) { continue; } alternatingLayer.RemoveAt(i); segmentContainer.Split(segment, out ISegmentContainer container1, out ISegmentContainer container2); container1.Position = segmentContainer.Position; container2.Position = segmentContainer.Position + container1.Count + 1; alternatingLayer.Insert(i, container1); alternatingLayer.Insert(i + 1, vertex); alternatingLayer.Insert(i + 2, container2); ++i; break; } } }
/// <summary> /// Gets whether specified vertex type is textured or not /// </summary> /// <param name="vertexTypes">Vertex type</param> /// <returns>Returns true if the vertex type contains texture map info</returns> public static bool IsTextured(VertexTypes vertexTypes) { return (vertexTypes == VertexTypes.Billboard || vertexTypes == VertexTypes.PositionTexture || vertexTypes == VertexTypes.PositionNormalTexture || vertexTypes == VertexTypes.PositionNormalTextureTangent || vertexTypes == VertexTypes.PositionTextureSkinned || vertexTypes == VertexTypes.PositionNormalTextureSkinned || vertexTypes == VertexTypes.PositionNormalTextureTangentSkinned); }
/// <summary> /// Get technique by vertex type /// </summary> /// <param name="vertexType">VertexType</param> /// <param name="instanced">Use instancing data</param> /// <param name="transparent">Use transparent textures</param> /// <returns>Returns the technique to process the specified vertex type</returns> public EngineEffectTechnique GetTechnique( VertexTypes vertexType, bool instanced, bool transparent) { if (transparent) { return(GetTechniqueTransparent(vertexType, instanced)); } else { return(GetTechniqueOpaque(vertexType, instanced)); } }
private List <SugiVertex> FindVerticesWithSameMeasure( [NotNull, ItemNotNull] AlternatingLayer nextAlternatingLayer, bool straightSweep, [NotNull] out IList <int> ranges, out int maxRangeLength) { Debug.Assert(nextAlternatingLayer != null); VertexTypes ignorableVertexType = straightSweep ? VertexTypes.QVertex : VertexTypes.PVertex; var verticesWithSameMeasure = new List <SugiVertex>(); SugiVertex[] vertices = nextAlternatingLayer.OfType <SugiVertex>().ToArray(); int startIndex; int endIndex; maxRangeLength = 0; ranges = new List <int>(); for (startIndex = 0; startIndex < vertices.Length; startIndex = endIndex + 1) { ThrowIfCancellationRequested(); endIndex = FindNearVertexEndIndex(startIndex, vertices); if (endIndex > startIndex) { int rangeLength = 0; for (int i = startIndex; i <= endIndex; ++i) { ThrowIfCancellationRequested(); if (vertices[i].Type == ignorableVertexType || vertices[i].DoNotOptimize) { continue; } ++rangeLength; verticesWithSameMeasure.Add(vertices[i]); } if (rangeLength > 0) { maxRangeLength = Math.Max(rangeLength, maxRangeLength); ranges.Add(rangeLength); } } } return(verticesWithSameMeasure); }
/// <summary> /// Adds a dummy vertex to the sparse compaction graph. /// </summary> /// <param name="type">The type of the dummy vertex (p,q,r).</param> /// <param name="layerIndex">The index of the layer of the vertex.</param> /// <returns>The new vertex which has been added to the graph and the /// layers.</returns> private SugiVertex AddDummyVertex(VertexTypes type, int layerIndex) { Contract.Requires(layerIndex < _layers.Count); Contract.Ensures(Contract.Result <SugiVertex>() != null); var vertex = new SugiVertex() { Type = type, LayerIndex = layerIndex }; _layers[layerIndex].Add(vertex); _graph.AddVertex(vertex); return(vertex); }
public override void ReadHeader(Stream stream, long length) { BinaryReader reader = new BinaryReader(stream); Version = reader.ReadUInt32(); ShaderName = Util.ReadString(reader, ref ShaderName_padding); PrimitiveType = (PrimitiveTypes)reader.ReadUInt32(); VertexType = (VertexTypes)reader.ReadUInt32(); NumVertices = reader.ReadUInt32(); NumIndices = reader.ReadUInt32(); NumMatrices = reader.ReadUInt32(); MemoryImaged = reader.ReadUInt32(); Optimised = reader.ReadUInt32(); VertexAnimated = reader.ReadUInt32(); VertexAnimatedMask = reader.ReadUInt32(); }
/// <summary> /// Get technique by vertex type /// </summary> /// <param name="vertexType">VertexType</param> /// <param name="channel">Color channel</param> /// <returns>Returns the technique to process the specified vertex type</returns> public EngineEffectTechnique GetTechnique(VertexTypes vertexType, SpriteTextureChannels channel) { if (vertexType == VertexTypes.PositionColor) { return(this.PositionColor); } else if (vertexType == VertexTypes.PositionTexture) { if (channel == SpriteTextureChannels.All) { return(this.PositionTexture); } else if (channel == SpriteTextureChannels.Red) { return(this.PositionTextureRED); } else if (channel == SpriteTextureChannels.Green) { return(this.PositionTextureGREEN); } else if (channel == SpriteTextureChannels.Blue) { return(this.PositionTextureBLUE); } else if (channel == SpriteTextureChannels.Alpha) { return(this.PositionTextureALPHA); } else if (channel == SpriteTextureChannels.NoAlpha) { return(this.PositionTextureNOALPHA); } else { return(this.PositionTexture); } } else { throw new EngineException(string.Format("Bad vertex type for effect: {0}", vertexType)); } }
/// <summary> /// Replaces the P or Q vertices of the <paramref name="alternatingLayer"/> with their segment on the next layer. /// </summary> /// <param name="alternatingLayer">The actual alternating layer. It will be modified.</param> /// <param name="straightSweep">If true, we are sweeping down else we're sweeping up.</param> private static void AppendSegmentsToAlternatingLayer( [NotNull, ItemNotNull] AlternatingLayer alternatingLayer, bool straightSweep) { Debug.Assert(alternatingLayer != null); VertexTypes type = straightSweep ? VertexTypes.PVertex : VertexTypes.QVertex; for (int i = 1; i < alternatingLayer.Count; i += 2) { var vertex = (SugiVertex)alternatingLayer[i]; if (vertex.Type == type) { var precedingContainer = (SegmentContainer)alternatingLayer[i - 1]; var succeedingContainer = (SegmentContainer)alternatingLayer[i + 1]; precedingContainer.Append(vertex.Segment); precedingContainer.Join(succeedingContainer); // Remove the vertex and the succeeding container from the alternating layer alternatingLayer.RemoveRange(i, 2); i -= 2; } } }
public SugiVertex(TIVertex originalVertex) { OriginalVertex = originalVertex; Type = VertexTypes.Original; Segment = null; }
/// <summary> /// Initializes a new instance of the <see cref="SugiVertex"/> class. /// </summary> /// <param name="type">Vertex type.</param> public SugiVertex(VertexTypes type) : this(null, type, default(Size)) { }
private static Queue <VertexGroup> GetContainerLikeItems(AlternatingLayer alternatingLayer, VertexTypes containerLikeVertexType) { Queue <VertexGroup> queue = new Queue <VertexGroup>(); foreach (var item in alternatingLayer) { var vertex = item as SugiVertex; if (vertex != null && vertex.Type == containerLikeVertexType) { queue.Enqueue(new VertexGroup() { Position = vertex.Position, Size = 1 }); } else if (vertex == null) { var container = item as ISegmentContainer; if (container.Count > 0) { queue.Enqueue(new VertexGroup() { Position = container.Position, Size = container.Count }); } } } return(queue); }
/// <summary> /// Process the vertex data /// </summary> /// <param name="description">Decription</param> /// <param name="geometry">Geometry</param> /// <param name="vertexType">Vertext type</param> /// <param name="vertices">Resulting vertices</param> /// <param name="indices">Resulting indices</param> private static void ProcessVertexData(DrawingDataDescription description, SubMeshContent geometry, VertexTypes vertexType, out VertexData[] vertices, out uint[] indices) { if (VertexData.IsTangent(vertexType)) { geometry.ComputeTangents(); } if (!description.Constraint.HasValue) { vertices = geometry.Vertices; indices = geometry.Indices; return; } if (geometry.Indices?.Length > 0) { ComputeConstraintIndices( description.Constraint.Value, geometry.Vertices, geometry.Indices, out vertices, out indices); } else { ComputeConstraintVertices( description.Constraint.Value, geometry.Vertices, out vertices); indices = new uint[] { }; } }
/// <summary> /// Get vertex type from geometry /// </summary> /// <param name="description">Description</param> /// <param name="materials">Material dictionary</param> /// <param name="vertexType">Vertex type</param> /// <param name="isSkinned">Sets wether the current geometry has skinning data or not</param> /// <param name="material">Material name</param> /// <returns>Returns the vertex type</returns> private static VertexTypes GetVertexType(DrawingDataDescription description, MaterialDictionary materials, VertexTypes vertexType, bool isSkinned, string material) { var res = vertexType; if (isSkinned) { //Get skinned equivalent res = VertexData.GetSkinnedEquivalent(res); } if (!description.LoadNormalMaps) { return(res); } if (VertexData.IsTextured(res) && !VertexData.IsTangent(res)) { var meshMaterial = materials[material]; if (meshMaterial?.NormalMap != null) { //Get tangent equivalent res = VertexData.GetTangentEquivalent(res); } } return(res); }
static public unsafe bool getVertexTypeFromGranny(granny_data_type_definition *grannyVertType, ref int vertMemSize, ref granny_data_type_definition[] grnDTD, ref VertexDeclaration grnVD, ref VertexDeclaration d3dVD) { List <VertexTypes.eVertexDeclElement> decls = new List <VertexTypes.eVertexDeclElement>(); List <granny_data_type_definition> grndcls = new List <granny_data_type_definition>(); granny_data_type_definition *def = grannyVertType; while (def->memberType != granny_member_type.GrannyEndMember) { byte *str = (byte *)def->Name; IntPtr strPtr = new IntPtr((byte *)str); string name = Marshal.PtrToStringAnsi(strPtr); if (name.Equals("FD")) //COMPRESSED VERTEX FORMAT { // CoreGlobals.getErrorManager().OnSimpleWarning(String.Format("Granny file {0} is Compressed. The current build of the editor does not support this. \n To view this model in the editor, please re-export uncompressed.", filename)); return(false); } if (def->memberType == granny_member_type.GrannyReal32Member) { granny_data_type_definition pdef; pdef.ArrayWidth = def->ArrayWidth; pdef.Extra0 = def->Extra0; pdef.Extra1 = def->Extra1; pdef.Extra2 = def->Extra2; pdef.memberType = def->memberType; pdef.Name = def->Name; pdef.ReferenceType = def->ReferenceType; pdef.TraversalID = def->TraversalID; //grndcls.Add(pdef); if (def->ArrayWidth == 4) { // if (name.Equals("DiffuseColor0")) decls.Add(VertexTypes.eVertexDeclElement.cVDE_ColorDWORD); } else if (def->ArrayWidth == 3) { if (name.Equals("Position")) { decls.Add(VertexTypes.eVertexDeclElement.cVDE_Position); grndcls.Add(pdef); } else if (name.Equals("Normal")) { decls.Add(VertexTypes.eVertexDeclElement.cVDE_Normal); grndcls.Add(pdef); } else if (name.Equals("Tangent")) { decls.Add(VertexTypes.eVertexDeclElement.cVDE_Tangent); grndcls.Add(pdef); } else if (name.Equals("Binormal")) { decls.Add(VertexTypes.eVertexDeclElement.cVDE_BiNormal); grndcls.Add(pdef); } } else if (def->ArrayWidth == 2) { if (name.Equals("TextureCoordinates0")) { decls.Add(VertexTypes.eVertexDeclElement.cVDE_TexCoord2); grndcls.Add(pdef); } else if (name.Equals("TextureCoordinates1")) { decls.Add(VertexTypes.eVertexDeclElement.cVDE_TexCoord2); grndcls.Add(pdef); } else if (name.Equals("TextureCoordinates2")) { decls.Add(VertexTypes.eVertexDeclElement.cVDE_TexCoord2); grndcls.Add(pdef); } else if (name.Equals("TextureCoordinates3")) { decls.Add(VertexTypes.eVertexDeclElement.cVDE_TexCoord2); grndcls.Add(pdef); } } } /* else if (def->memberType == granny_member_type.GrannyNormalUInt8Member) * { * * // CoreGlobals.getErrorManager().OnSimpleWarning(String.Format("Granny file {0} has an unsupported vertex structure", filename)); * // return false; * * if (name.Equals("BoneWeights")) * { * if (def->ArrayWidth == 4) * decls.Add(VertexTypes.eVertexDeclElement.cVDE_BlendWeight4); * } * else if (name.Equals("BoneIndices")) * decls.Add(VertexTypes.eVertexDeclElement.cVDE_BlendIndicies); * }*/ def++; } //create our granny vertex grnDTD = new granny_data_type_definition[grndcls.Count + 1]; for (int k = 0; k < grndcls.Count; k++) { grnDTD[k] = grndcls[k]; } grnDTD[decls.Count] = new granny_data_type_definition(); grnDTD[decls.Count].memberType = granny_member_type.GrannyEndMember; //get our D3D Version of things short val = 0; grnVD = VertexTypes.genVertexDecl(decls, false, ref val); vertMemSize = (int)val; d3dVD = VertexTypes.genVertexDecl(decls, true, ref val); return(true); }
/// <summary> /// Get technique by vertex type /// </summary> /// <param name="vertexType">VertexType</param> /// <param name="instanced">Use instancing data</param> /// <returns>Returns the technique to process the specified vertex type</returns> public EngineEffectTechnique GetTechnique( VertexTypes vertexType, bool instanced) { if (!instanced) { switch (vertexType) { case VertexTypes.PositionColor: return(this.PositionColor); case VertexTypes.PositionTexture: return(this.PositionTexture); case VertexTypes.PositionNormalColor: return(this.PositionNormalColor); case VertexTypes.PositionNormalTexture: return(this.PositionNormalTexture); case VertexTypes.PositionNormalTextureTangent: return(this.PositionNormalTextureTangent); case VertexTypes.PositionColorSkinned: return(this.PositionColorSkinned); case VertexTypes.PositionTextureSkinned: return(this.PositionTextureSkinned); case VertexTypes.PositionNormalColorSkinned: return(this.PositionNormalColorSkinned); case VertexTypes.PositionNormalTextureSkinned: return(this.PositionNormalTextureSkinned); case VertexTypes.PositionNormalTextureTangentSkinned: return(this.PositionNormalTextureTangentSkinned); default: throw new EngineException(string.Format("Bad vertex type for effect: {0}", vertexType)); } } else { switch (vertexType) { case VertexTypes.PositionColor: return(this.InstancingPositionColor); case VertexTypes.PositionTexture: return(this.InstancingPositionTexture); case VertexTypes.PositionNormalColor: return(this.InstancingPositionNormalColor); case VertexTypes.PositionNormalTexture: return(this.InstancingPositionNormalTexture); case VertexTypes.PositionNormalTextureTangent: return(this.InstancingPositionNormalTextureTangent); case VertexTypes.PositionColorSkinned: return(this.InstancingPositionColorSkinned); case VertexTypes.PositionTextureSkinned: return(this.InstancingPositionTextureSkinned); case VertexTypes.PositionNormalColorSkinned: return(this.InstancingPositionNormalColorSkinned); case VertexTypes.PositionNormalTextureSkinned: return(this.InstancingPositionNormalTextureSkinned); case VertexTypes.PositionNormalTextureTangentSkinned: return(this.InstancingPositionNormalTextureTangentSkinned); default: throw new EngineException(string.Format("Bad instanced vertex type for effect: {0}", vertexType)); } } }
internal void BuildDrawInfo(PathGraph graph) { FreeVBs(); List <Vector3> verts = new List <Vector3>(); List <Vector3> norms = new List <Vector3>(); List <UInt32> indexes = new List <UInt32>(); List <int> vertCounts = new List <int>(); graph.GetNodePolys(verts, indexes, norms, vertCounts); if (verts.Count == 0) { return; } VPosNormCol0 [] nodeVerts = new VPosNormCol0[verts.Count]; for (int i = 0; i < nodeVerts.Length; i++) { nodeVerts[i].Position = verts[i] + Vector3.UnitY; //boost up 1 nodeVerts[i].Normal.X = norms[i].X; nodeVerts[i].Normal.Y = norms[i].Y; nodeVerts[i].Normal.Z = norms[i].Z; nodeVerts[i].Normal.W = 1f; } int idx = 0; for (int i = 0; i < vertCounts.Count; i++) { Color col = Mathery.RandomColor(mRand); for (int j = 0; j < vertCounts[i]; j++) { nodeVerts[idx + j].Color0 = col; } idx += vertCounts[i]; } mVBNodes = VertexTypes.BuildABuffer(mGD.GD, nodeVerts, VertexTypes.GetIndex(nodeVerts[0].GetType())); mIBNodes = VertexTypes.BuildAnIndexBuffer(mGD.GD, indexes.ToArray()); mVBBNodes = VertexTypes.BuildAVBB(VertexTypes.GetIndex(nodeVerts[0].GetType()), mVBNodes); mNodeIndexCount = indexes.Count; //connexions List <PathGraph.LineSeg> segz = graph.GetNodeConnections(); if (segz.Count <= 0) { return; } VPosNormCol0 [] segVerts = new VPosNormCol0[segz.Count * 3]; UInt32 index = 0; indexes.Clear(); foreach (PathGraph.LineSeg seg in segz) { Color col = Mathery.RandomColor(mRand); //endpoint segVerts[index].Position = seg.mB; Vector3 lineVec = seg.mB - seg.mA; //get a perpindicular axis to the a to b axis //so the back side of the connection can flare out a bit Vector3 crossVec = Vector3.Cross(lineVec, Vector3.UnitY); crossVec.Normalize(); Vector3 normVec = Vector3.Cross(crossVec, lineVec); normVec.Normalize(); crossVec *= 2f; segVerts[index + 1].Position = seg.mA - crossVec + Mathery.RandomDirectionXZ(mRand); segVerts[index + 2].Position = seg.mA + crossVec + Mathery.RandomDirectionXZ(mRand); segVerts[index].Color0 = col; segVerts[index + 1].Color0 = col; segVerts[index + 2].Color0 = col; //adjust up segVerts[index].Position += Vector3.UnitY * 2f; segVerts[index + 1].Position += Vector3.UnitY * 1.7f; segVerts[index + 2].Position += Vector3.UnitY * 1.7f; Half4 norm; norm.X = normVec.X; norm.Y = normVec.Y; norm.Z = normVec.Z; norm.W = 1f; segVerts[index].Normal = norm; segVerts[index + 1].Normal = norm; segVerts[index + 2].Normal = norm; indexes.Add(index); indexes.Add(index + 1); indexes.Add(index + 2); index += 3; } mVBCons = VertexTypes.BuildABuffer(mGD.GD, segVerts, VertexTypes.GetIndex(segVerts[0].GetType())); mIBCons = VertexTypes.BuildAnIndexBuffer(mGD.GD, indexes.ToArray()); mVBBCons = VertexTypes.BuildAVBB(VertexTypes.GetIndex(segVerts[0].GetType()), mVBCons); mConIndexCount = indexes.Count; }
internal void BuildPathDrawInfo(List <Vector3> path, Vector3 boxMiddleOffset) { if (mVBPath != null) { mVBPath.Dispose(); } if (mIBPath != null) { mIBPath.Dispose(); } if (path.Count < 2) { return; } VPosNormCol0 [] segVerts = new VPosNormCol0[(path.Count - 1) * 3]; UInt32 index = 0; List <UInt32> indexes = new List <UInt32>(); for (int i = 0; i < (path.Count - 1); i++) { Color col = Mathery.RandomColor(mRand); col = Color.Red; //endpoint segVerts[index].Position = path[i + 1]; Vector3 lineVec = path[i + 1] - path[i]; //get a perpindicular axis to the a to b axis //so the back side of the connection can flare out a bit Vector3 crossVec = Vector3.Cross(lineVec, Vector3.UnitY); crossVec.Normalize(); Vector3 normVec = Vector3.Cross(crossVec, lineVec); normVec.Normalize(); crossVec *= 2f; segVerts[index + 1].Position = path[i] - crossVec + Mathery.RandomDirectionXZ(mRand); segVerts[index + 2].Position = path[i] + crossVec + Mathery.RandomDirectionXZ(mRand); segVerts[index].Color0 = col; segVerts[index + 1].Color0 = col; segVerts[index + 2].Color0 = col; //adjust up segVerts[index].Position += boxMiddleOffset; segVerts[index + 1].Position += boxMiddleOffset; segVerts[index + 2].Position += boxMiddleOffset; Half4 norm; norm.X = normVec.X; norm.Y = normVec.Y; norm.Z = normVec.Z; norm.W = 1f; segVerts[index].Normal = norm; segVerts[index + 1].Normal = norm; segVerts[index + 2].Normal = norm; indexes.Add(index); indexes.Add(index + 1); indexes.Add(index + 2); index += 3; } mVBPath = VertexTypes.BuildABuffer(mGD.GD, segVerts, VertexTypes.GetIndex(segVerts[0].GetType())); mIBPath = VertexTypes.BuildAnIndexBuffer(mGD.GD, indexes.ToArray()); mVBBPath = VertexTypes.BuildAVBB(VertexTypes.GetIndex(segVerts[0].GetType()), mVBPath); mPathIndexCount = indexes.Count; }
/// <summary> /// Get technique by vertex type for transparent objects /// </summary> /// <param name="vertexType">VertexType</param> /// <param name="instanced">Use instancing data</param> /// <returns>Returns the technique to process the specified vertex type</returns> private EngineEffectTechnique GetTechniqueTransparent( VertexTypes vertexType, bool instanced) { if (!instanced) { switch (vertexType) { case VertexTypes.PositionColor: return(this.ShadowMapPositionColor); case VertexTypes.PositionColorSkinned: return(this.ShadowMapPositionColorSkinned); case VertexTypes.PositionTexture: return(this.ShadowMapPositionTextureTransparent); case VertexTypes.PositionTextureSkinned: return(this.ShadowMapPositionTextureTransparentSkinned); case VertexTypes.PositionNormalColor: return(this.ShadowMapPositionNormalColor); case VertexTypes.PositionNormalColorSkinned: return(this.ShadowMapPositionNormalColorSkinned); case VertexTypes.PositionNormalTexture: return(this.ShadowMapPositionNormalTextureTransparent); case VertexTypes.PositionNormalTextureSkinned: return(this.ShadowMapPositionNormalTextureTransparentSkinned); case VertexTypes.PositionNormalTextureTangent: return(this.ShadowMapPositionNormalTextureTangentTransparent); case VertexTypes.PositionNormalTextureTangentSkinned: return(this.ShadowMapPositionNormalTextureTangentTransparentSkinned); default: throw new EngineException(string.Format("Bad vertex type for effect. {0}; Instaced: {1}; Transparent", vertexType, instanced)); } } else { switch (vertexType) { case VertexTypes.PositionColor: return(this.ShadowMapPositionColorInstanced); case VertexTypes.PositionColorSkinned: return(this.ShadowMapPositionColorSkinnedInstanced); case VertexTypes.PositionTexture: return(this.ShadowMapPositionTextureTransparentInstanced); case VertexTypes.PositionTextureSkinned: return(this.ShadowMapPositionTextureTransparentSkinnedInstanced); case VertexTypes.PositionNormalColor: return(this.ShadowMapPositionNormalColorInstanced); case VertexTypes.PositionNormalColorSkinned: return(this.ShadowMapPositionNormalColorSkinnedInstanced); case VertexTypes.PositionNormalTexture: return(this.ShadowMapPositionNormalTextureTransparentInstanced); case VertexTypes.PositionNormalTextureSkinned: return(this.ShadowMapPositionNormalTextureTransparentSkinnedInstanced); case VertexTypes.PositionNormalTextureTangent: return(this.ShadowMapPositionNormalTextureTangentTransparentInstanced); case VertexTypes.PositionNormalTextureTangentSkinned: return(this.ShadowMapPositionNormalTextureTangentTransparentSkinnedInstanced); default: throw new EngineException(string.Format("Bad vertex type for effect. {0}; Instaced: {1}; Transparent", vertexType, instanced)); } } }
public VertexModel(VertexTypes type, string vertexId, string fullName, string addressImage, string standardPhone) : this(type, vertexId) { FullName = fullName; AddressImage = addressImage; StandardPhone = standardPhone; }