private VertexUnit[] dVertices; // face public VertexPlaneVertical(VertexUnit dVertex1, VertexUnit[] dVertices) { isFixed = true; this.dVertex1 = dVertex1; if (dVertices.Length <= 2) { dVertices = new VertexUnit[3]; } this.dVertices = dVertices; RefreshPosition(); }
public void SetUnit(string unit) { if (string.IsNullOrEmpty(unit)) { return; } unit = unit.ToLower().FirstCharToUpperCase(); foreach (VertexUnit unitEnum in System.Enum.GetValues(typeof(VertexUnit))) { if (unitEnum.ToString() == unit) { Unit = unitEnum; return; } } }
public override void InitWithGeometry(Geometry geometry) { VertexUnit v1 = geometry.VertexUnit(corner.id1); VertexUnit v2 = geometry.VertexUnit(corner.id2); VertexUnit v3 = geometry.VertexUnit(corner.id3); dependencies = new List <VertexUnit>(); dependencies.Add(v1); dependencies.Add(v2); dependencies.Add(v3); GizmoCorner gizmoCorner = new GizmoCorner(corner); GizmoAngle gizmoAngle = new GizmoAngle(corner); gizmos = new Gizmo[] { gizmoCorner, gizmoAngle }; }
public override void InitWithGeometry(Geometry geometry) { int count = face.ids.Length; VertexUnit[] vertexUnits = new VertexUnit[count]; for (int i = 0; i < count; i++) { vertexUnits[i] = geometry.VertexUnit(face.ids[i]); } dependencies = new List <VertexUnit>(vertexUnits); GizmoVolume gizmoVolume = new GizmoVolume(face); gizmos = new Gizmo[] { gizmoVolume }; }
private void RemoveObserver(VertexUnit unit, Auxiliary auxiliary) { List <Auxiliary> observers; vertexObservers.TryGetValue(unit, out observers); if (observers != null) { observers.Remove(auxiliary); if (observers.Count == 0) { vertexObservers.Remove(unit); } } }
public override void InitWithGeometry(Geometry geometry) { try { VertexUnit unit1 = geometry.VertexUnit(edge.id1); VertexUnit unit2 = geometry.VertexUnit(edge.id2); units = new VertexUnit[] { }; GeoEdge geoEdge = new GeoEdge(unit1, unit2); elements = new GeoElement[] { geoEdge }; dependencies.Add(unit1); dependencies.Add(unit2); } catch (Exception e) { Debug.Log(e.Message); } }
public MoveVertexOperation(StateController stateController, GeoCamera geoCamera, Geometry geometry, GeometryBehaviour geometryBehaviour, GeoUI geoUI, VertexUnit vertex, VertexBehaviour vertexBehaviour, bool snap) { CanRotateCamera = false; CanActiveElement = false; this.stateController = stateController; this.geoCamera = geoCamera; this.geometry = geometry; this.geometryBehaviour = geometryBehaviour; this.inputPanel = geoUI.inputPanel; this.vertex = vertex; this.vertexBehaviour = vertexBehaviour; this.snap = snap; }
//--------------------------------------------------------------- #endregion //--------------------------------------------------------------- //--------------------------------------------------------------- #region Initialisation //--------------------------------------------------------------- /// <summary> /// Creates a new instance of a particle system. /// </summary> /// <param name="size">The max number of particles.</param> public ParticleSystem2d(int size) : base( ) { textures = new Textures(); particles = new Purple.Collections.FixedBag(size); // Create a new format VertexFormat format = new VertexFormat( new Type[] { typeof(PositionStream2), typeof(ColorStream), typeof(TextureStream) }); // create VertexUnit and IndexStream vertexUnit = new VertexUnit(format, size * 4); indexStream = IndexStream.FromQuads(size); // load shaders from the resource files using (System.IO.Stream fxStream = Purple.IO.ResourceFileSystem.Instance.Open("Purple/Graphics/Particles/Particle2d.fx")) { Effect = EffectCompiler.Instance.Compile(fxStream); } }
//--------------------------------------------------------------- #endregion //--------------------------------------------------------------- //--------------------------------------------------------------- #region Initialisation //--------------------------------------------------------------- /// <summary> /// Creates a new instance of a particle system. /// </summary> /// <param name="size">The max number of particles.</param> public LineParticleSystem(int size) : base( ) { textures = new Textures(); particles = new FixedRoundBuffer(size); // Create a new format VertexFormat format = new VertexFormat( new Type[] { typeof(PositionStream), typeof(ColorStream), typeof(TextureStream) }); // create VertexUnit and IndexStream vertexUnit = new VertexUnit(format, 2 + size * 2); indexStream = IndexStream.FromChain(size - 1); // load shaders from the resource files using (System.IO.Stream fxStream = Purple.IO.ResourceFileSystem.Instance.Open("Purple/Graphics/Particles/LineParticle.fx")) { Effect = EffectCompiler.Instance.Compile(fxStream); } }
void SoftSkin(Matrix4[] preBound) { // Apply skinning on all subSets for (int iSubSet = 0; iSubSet < data.Length; iSubSet++) { SubSetData ssData = data[iSubSet]; if (ssData != null) { VertexUnit vu = mesh.SubSets[iSubSet].VertexUnit; PositionStream ps = (PositionStream)vu[typeof(PositionStream)]; IBoneIndicesStream bis = (IBoneIndicesStream)vu[typeof(IBoneIndicesStream)]; IBoneWeightsStream bws = (IBoneWeightsStream)vu[typeof(IBoneWeightsStream)]; // currently just the position stream is skinned! Skinning.SoftSkin(ps, ssData.Position, bis, bws, preBound, Shadowed); ps.Upload(); } } }
public void GenerateResolvedBody(Geometry geometry) { SpinAuxiliary auxiliary = new SpinAuxiliary(); auxiliary.InitWithGeometry(geometry); geometryBehaviour = GameObject.Find("/3D/Geometry").GetComponent <GeometryBehaviour>(); VertexUnit[] vertexUnits = auxiliary.vertices; // Cylinder if (vertexUnits.Length == 4) { VertexUnit vertex1 = vertexUnits[0]; VertexUnit vertex2 = vertexUnits[1]; VertexUnit vertex3 = vertexUnits[2]; VertexUnit vertex4 = vertexUnits[3]; float radius1 = vertexUnits[3].Position().z; float radius2 = vertexUnits[2].Position().z; GeoCircular circular = new GeoCircular(new VertexUnit[] { vertex1, vertex2, vertex3, vertex4 }, radius1, radius2, CircularType.Cylinder); geometry.AddGeoCircular(circular); VertexSpace circle1 = new VertexSpace(0, vertex4.Position().y, 0); VertexSpace circle2 = new VertexSpace(0, vertex3.Position().y, 0); geometry.AddGeoCircle(new GeoCircle(circle1, radius1, CircleDirection.Y, false, FaceType.SpreadCylinderCircle)); geometry.AddGeoCircle(new GeoCircle(circle2, radius2, CircleDirection.Y, false, FaceType.SpreadCylinderCircle)); } // Cone else if (vertexUnits.Length == 3) { VertexUnit vertex1 = vertexUnits[0]; VertexUnit vertex2 = vertexUnits[1]; VertexUnit vertex3 = vertexUnits[2]; float radius = vertexUnits[2].Position().z; GeoCircular circular = new GeoCircular(new VertexUnit[] { vertex1, vertex2, vertex3 }, radius, radius, CircularType.Cone); geometry.AddGeoCircular(circular); VertexSpace circle1 = new VertexSpace(0, vertex3.Position().y, 0); geometry.AddGeoCircle(new GeoCircle(circle1, radius, CircleDirection.Y, false, FaceType.SpreadConeCircle)); } geometryBehaviour.InitGeometry(geometry); StatusButton lockButton = GameObject.Find("LockButton").GetComponent <StatusButton>(); lockButton.SetStatus(0); }
public HashSet <VertexUnit> VertexTotalObserveVertices(VertexUnit unit) { Auxiliary auxiliary = vertexAuxiliaryMap[unit]; return(AuxiliaryTotalObserveVertices(auxiliary)); // HashSet<VertexUnit> vertices = new HashSet<VertexUnit>(); // List<Auxiliary> observers = VertexObservers(unit); // foreach (Auxiliary a in observers) // { // vertices.UnionWith(a.units); // foreach (VertexUnit item in a.units) // vertices.UnionWith(VertexTotalObserveVertices(item)); // } // return vertices; }
public void RemoveVertexUnit(int id) { VertexUnit unit = vertices[id]; if (unit.isBase) { return; } vertices.Remove(id); string sign = vertexSignMap[id]; signVertexMap.Remove(sign); vertexSignMap.Remove(id); unit.RemoveDependencies(); // foreach (VertexUnit dependency in unit.dependencies)// TODO // RemoveVertexUnit(dependency.id); }
//--------------------------------------------------------------- #endregion //--------------------------------------------------------------- //--------------------------------------------------------------- #region Properties //--------------------------------------------------------------- //--------------------------------------------------------------- #endregion //--------------------------------------------------------------- //--------------------------------------------------------------- #region Initialisation //--------------------------------------------------------------- /// <summary> /// Creates a sky box entity. /// </summary> /// <param name="size">Size of sky box.</param> /// <param name="format"><see cref="VertexFormat"/> to use for skybox.</param> public SkyBoxEntity(Vector3 size, VertexFormat format) { // create streams VertexUnit vertexUnit = new VertexUnit(format, 8); PositionStream position = (PositionStream)vertexUnit[typeof(PositionStream)]; //TextureStream texture = (TextureStream)vertexUnit[ typeof(TextureStream) ]; IndexStream index = new IndexStream16(24); // fill position data position[0] = new Vector3(-size.X, -size.Y, size.Z); position[1] = new Vector3(size.X, -size.Y, size.Z); position[2] = new Vector3(size.X, -size.Y, -size.Z); position[3] = new Vector3(-size.X, -size.Y, -size.Z); position[4] = new Vector3(-size.X, size.Y, size.Z); position[5] = new Vector3(size.X, size.Y, size.Z); position[6] = new Vector3(size.X, size.Y, -size.Z); position[7] = new Vector3(-size.X, size.Y, -size.Z); subSet = new SubSet(vertexUnit, index); }
/// <summary> /// Loads the model. /// </summary> /// <param name="stream">Stream to load model from.</param> /// <returns>The loaded model.</returns> public Model LoadModel(Stream stream) { BlendMesh mesh; // get header and check if it is ok MD2_Header header = (MD2_Header)RawSerializer.Deserialize(stream, typeof(MD2_Header)); if (header.Ident != 844121161 || header.Version != 8) { return(null); } // Load skins MD2_Skin[] skinNames = (MD2_Skin[])RawSerializer.DeserializeArray(stream, typeof(MD2_Skin), header.NumSkins); // Load texture coordinates MD2_TextureCoordinate[] textureCoordinates = (MD2_TextureCoordinate[])RawSerializer.DeserializeArray(stream, typeof(MD2_TextureCoordinate), header.NumTextureCoordinates); // Load triangless MD2_Triangle[] triangles = (MD2_Triangle[])RawSerializer.DeserializeArray(stream, typeof(MD2_Triangle), header.NumTris); IndexStream indexStream = new IndexStream16(triangles.Length); for (int i = 0; i < triangles.Length; i++) { // indexStream[i] = triangles[i].VertexIndex[j; } mesh = new BlendMesh(header.NumFrames); // Load frames for (int i = 0; i < header.NumFrames; i++) { MD2_Frame frame = (MD2_Frame)RawSerializer.Deserialize(stream, typeof(MD2_Frame)); MD2_Vertex[] vertices = (MD2_Vertex[])RawSerializer.DeserializeArray(stream, typeof(MD2_Vertex), header.NumVertices); VertexUnit vu = new VertexUnit(VertexFormat.Position, vertices.Length); PositionStream ps = (PositionStream)vu[typeof(Purple.Graphics.VertexStreams.PositionStream)]; mesh.Meshes[i] = new Mesh(new SubSet(vu, indexStream)); } return(new Model(mesh, null)); }
public override void InitWithGeometry(Geometry geometry) { if (geometry is ResolvedBody) { resolvedBody = (ResolvedBody)geometry; } units = new VertexUnit[] { }; GeoVertex[] geoVertices = geometry.GeoVertices(); vertices = new VertexUnit[geoVertices.Length]; int[] ids = new int[geoVertices.Length]; for (int i = 0; i < geoVertices.Length; i++) { vertices[i] = geoVertices[i].VertexUnit(); ids[i] = vertices[i].id; } face = new FaceRefer(ids); elements = new GeoElement[] { }; dependencies.AddRange(units); }
public override void InitWithGeometry(Geometry geometry) { int count = face.ids.Length; VertexUnit[] vertexUnits = new VertexUnit[count]; for (int i = 0; i < count; i++) { vertexUnits[i] = geometry.VertexUnit(face.ids[i]); } VertexPlaneCenter unit = new VertexPlaneCenter(vertexUnits); unit.preferredSign = sign; geometry.VertexUnitSetId(unit, 0); units = new VertexUnit[] { unit }; GeoVertex geoVertex = new GeoVertex(unit); elements = new GeoElement[] { geoVertex }; dependencies.AddRange(vertexUnits); }
private SubSetData CreateSubSetData(SubSet subSet) { VertexUnit vu = subSet.VertexUnit; if (!vu.Format.Contains(Semantic.BoneIndices) || !vu.Format.Contains(Semantic.BoneIndices) || !vu.Format.Contains(Semantic.Position)) { return(null); } SubSetData ssData = new SubSetData(); PositionStream posStream = (PositionStream)vu[typeof(PositionStream)]; ssData.Position = (Vector3[])posStream.Data.Clone(); if (vu.Format.Contains(typeof(NormalStream))) { NormalStream normalStream = (NormalStream)vu[typeof(NormalStream)]; ssData.Normal = (Vector3[])normalStream.Data.Clone(); } return(ssData); }
/// <summary> /// Prepares a mesh for being used as a shadow Volume. /// </summary> /// <remarks>In fact the geometry is doubled and an FloatStream is added that contains 1.0f for /// vertices that are used for the near cap and 0.0f for the far cap.</remarks> /// <param name="mesh">The mesh to prepare.</param> public static void PrepareMesh(Mesh mesh) { SubSets subSets = mesh.SubSets; for (int iSubSet = 0; iSubSet < subSets.Count; iSubSet++) { VertexUnit vu = subSets[iSubSet].VertexUnit; IGraphicsStream[] streams = new IGraphicsStream[vu.StreamCount + 1]; for (int iStream = 0; iStream < vu.StreamCount; iStream++) { IGraphicsStream fromStream = vu[iStream]; IGraphicsStream toStream = null; using (Purple.Profiling.Profiler.Instance.Sample("Clone")) { toStream = fromStream.Clone(); } using (Purple.Profiling.Profiler.Instance.Sample("Resize")) { toStream.Resize(fromStream.Size * 2); } using (Purple.Profiling.Profiler.Instance.Sample("CopyTo")) { fromStream.Data.CopyTo(toStream.Data, fromStream.Size); } streams[iStream] = toStream; } using (Purple.Profiling.Profiler.Instance.Sample("FloatStream")) { FloatStream floatStream = new FloatStream(vu.Size * 2); for (int i = 0; i < vu.Size; i++) { floatStream[i] = 1.0f; floatStream[i + vu.Size] = 0.0f; } streams[vu.StreamCount] = floatStream; } vu = new VertexUnit(streams); subSets[iSubSet].VertexUnit = vu; } }
/// <summary> /// Merges two subsets. /// </summary> /// <param name="subSet">Subset to merge with.</param> public void Merge(SubSet subSet) { if (!CanMerge(subSet)) { throw new GraphicsException("Subsets can't be merged!"); } // Merge vertex unit VertexUnit unit = new VertexUnit(VertexUnit.Format, VertexUnit.Size + subSet.VertexUnit.Size); VertexUnit.Copy(VertexUnit, 0, unit, 0, VertexUnit.Size); VertexUnit.Copy(subSet.VertexUnit, 0, unit, VertexUnit.Size, subSet.VertexUnit.Size); VertexUnit.Dispose(); VertexUnit = unit; // Merge index streams IndexStream index = IndexStream.Create(IndexStream.Size + subSet.IndexStream.Size, IndexStream.GetType()); VertexStreams.IndexStream.Copy(IndexStream, 0, index, 0, IndexStream.Size, 0); VertexStreams.IndexStream.Copy(subSet.IndexStream, 0, index, IndexStream.Size, subSet.IndexStream.Size, VertexUnit.Size); IndexStream.Dispose(); IndexStream = index; }
/// <summary> /// retrieve n'th PositionStream2 from vertex Unit /// </summary> /// <param name="unit">vertexUnit to retrieve stream from</param> /// <param name="index">number of stream of type(PositionStream2)</param> /// <returns>the n'th PositionStream2 of the vertex unit</returns> public static PositionStream2 From(VertexUnit unit, int index) { return((PositionStream2)unit[typeof(PositionStream2), index]); }
/// <summary> /// Changes the format to fit the given semantics. /// </summary> /// <param name="semantics">Semantics to fit.</param> internal void ChangeFormat(Semantic[] semantics) { VertexUnit.ChangeFormat(semantics); }
/// <summary> /// constructor /// </summary> /// <param name="vertexUnit"></param> public BinormalStream(VertexUnit vertexUnit) : base(vertexUnit) { Usage = DeclarationUsage.Binormal; }
/// <summary> /// Clones the current <see cref="SubSet"/>, whereby the format of the <see cref="VertexUnit"/> /// is changed to the given <see cref="VertexFormat"/>. /// </summary> /// <remarks> /// Uses deep copy (just <see cref="VertexUnit"/> is cloned but not <see cref="IndexStream"/>). /// </remarks> /// <param name="format"></param> /// <returns></returns> public SubSet Clone(VertexFormat format) { SubSet ret = new SubSet(VertexUnit.Clone(format), IndexStream, IndexBufferStart, PrimitiveCount); return(ret); }
/// <summary> /// Import a mesh from a stream. /// </summary> /// <param name="stream">Stream containing mesh data.</param> public void Import(Stream stream) { Profiler.Instance.Begin("Import binary mesh"); // Header BinaryReader reader = new BinaryReader(stream); if (ReadString(reader) != "mesh" || ReadString(reader) != "v0.3") { throw new NotSupportedException("Can't load mesh, file not supported!"); } // Joints int jointNum = ReadInt(reader); Joint[] joints = new Joint[jointNum]; Matrix4[] jointArray = new Matrix4[jointNum]; Hashtable jointTable = new Hashtable(joints.Length); for (int i = 0; i < joints.Length; i++) { string name = ReadString(reader); string parent = ReadString(reader); reader.Read(matrixBytes, 0, matrixBytes.Length); Matrix4 m = Matrix4.From(matrixBytes); Joint parentJoint = null; if (parent != null && jointTable.Contains(parent)) { parentJoint = (Joint)jointTable[parent]; } joints[i] = new Joint(name, i, parentJoint); jointArray[i] = m; jointTable[name] = joints[i]; } skeleton = new Skeleton(jointArray, joints); // SubSet int subSetNum = ReadInt(reader); for (int i = 0; i < subSetNum; i++) { ArrayList streams = new ArrayList(10); // Header if (ReadString(reader) != "subset") { throw new NotSupportedException("Error on loading subSet!"); } string name = ReadString(reader); string parentJoint = ReadString(reader); int attributeCount = ReadInt(reader); StringDictionary attributes = new StringDictionary(); for (int t = 0; t < attributeCount; t++) { attributes.Add(ReadString(reader), ReadString(reader)); } // IndexStream // Todo Replace ushort.MaxValue with size of vertex unit IndexStream indexStream = IndexStream.Create(ReadInt(reader), ushort.MaxValue); byte[] indexBuffer = new byte[indexStream.Size * 4]; reader.Read(indexBuffer, 0, indexStream.Size * 4); for (int t = 0; t < indexStream.Size; t++) { indexStream[t] = BitConverter.ToInt32(indexBuffer, t * 4); } int vertexSize = ReadInt(reader); PositionStream posStream = new PositionStream(vertexSize); streams.Add(posStream); byte[] vertexBuffer = new byte[vertexSize * 12]; reader.Read(vertexBuffer, 0, vertexSize * 12); for (int t = 0; t < vertexSize; t++) { posStream[t] = Vector3.From(vertexBuffer, 12 * t); } NormalStream normalStream = new NormalStream(vertexSize); streams.Add(normalStream); reader.Read(vertexBuffer, 0, vertexSize * 12); for (int t = 0; t < vertexSize; t++) { normalStream[t] = Vector3.From(vertexBuffer, t * 12); } ColorStream colorStream = new ColorStream(vertexSize); streams.Add(colorStream); reader.Read(vertexBuffer, 0, vertexSize * 12); for (int t = 0; t < vertexSize; t++) { int r = Math.Basic.Clamp((int)(System.BitConverter.ToSingle(vertexBuffer, t * 12) * 255 + 0.5f), 0, 255); int g = Math.Basic.Clamp((int)(System.BitConverter.ToSingle(vertexBuffer, 4 + t * 12) * 255 + 0.5f), 0, 255); int b = Math.Basic.Clamp((int)(System.BitConverter.ToSingle(vertexBuffer, 8 + t * 12) * 255 + 0.5f), 0, 255); colorStream[t] = System.Drawing.Color.FromArgb(r, g, b).ToArgb(); } TextureStream[] textureStreams = new TextureStream[ReadInt(reader)]; for (int t = 0; t < textureStreams.Length; t++) { TextureStream texStream = new TextureStream(vertexSize); streams.Add(texStream); reader.Read(vertexBuffer, 0, vertexSize * 8); for (int j = 0; j < vertexSize; j++) { texStream[j] = Vector2.From(vertexBuffer, j * 8); } textureStreams[t] = texStream; } IBoneIndicesStream boneStream = null; IBoneWeightsStream weightsStream = null; int weightNum = ReadInt(reader); if (weightNum != 0) { if (HardwareSkinning) { boneStream = new BoneIndicesStream(vertexSize); weightsStream = new BoneWeightsStream(vertexSize); } else { boneStream = new SoftwareBoneIndicesStream(vertexSize); weightsStream = new SoftwareBoneWeightsStream(vertexSize); } streams.Add(boneStream); streams.Add(weightsStream); ArrayList[] indicesList = new ArrayList[vertexSize]; ArrayList[] weightsList = new ArrayList[vertexSize]; for (int t = 0; t < vertexSize; t++) { indicesList[t] = new ArrayList(8); weightsList[t] = new ArrayList(8); } byte[] weightBuffer = new byte[weightNum * 12]; reader.Read(weightBuffer, 0, weightNum * 12); for (int t = 0; t < weightNum; t++) { int vertexIndex = BitConverter.ToInt32(weightBuffer, t * 12); int jointIndex = BitConverter.ToInt32(weightBuffer, 4 + t * 12); float weight = BitConverter.ToSingle(weightBuffer, 8 + t * 12); indicesList[vertexIndex].Add((byte)jointIndex); weightsList[vertexIndex].Add(weight); } for (int t = 0; t < vertexSize; t++) { boneStream.SetIndices(t, (byte[])indicesList[t].ToArray(typeof(byte))); weightsStream.SetWeights(t, (float[])weightsList[t].ToArray(typeof(float))); } } VertexUnit vertexUnit = new VertexUnit(streams); Mesh mesh = new Mesh(new SubSet(vertexUnit, indexStream)); if (model == null) { if (skeleton.Joints.Length != 0) { model = new Model(new SkinnedMesh(mesh, skeleton), skeleton); } else { model = new Model(mesh, skeleton); } } else { Joint attachTo = skeleton.RootJoint; if (parentJoint != "") { attachTo = (jointTable[parentJoint] as Joint); } model.AttachModel(new Model(mesh, skeleton), attachTo); } } reader.Close(); Profiler.Instance.End("Import binary mesh"); }
public void RemoveDependency(VertexUnit vertex) { dependencies.Remove(vertex); }
/// <summary> /// constructor /// </summary> /// <param name="vertexUnit"></param> public FloatStream(VertexUnit vertexUnit) : base(vertexUnit.Size) { this.vertexUnit = vertexUnit; }
/// <summary> /// retrieves the first PositionStream2 of a certain vertex unit /// </summary> /// <param name="unit">vertex unit to retrive stream from</param> /// <returns>the first position stream of the vertex unit</returns> public static PositionStream2 From(VertexUnit unit) { return(From(unit, 0)); }
/// <summary> /// Clones the current <see cref="SubSet"/>, whereby the format is changed to the fit the semantics given. /// </summary> /// <remarks> /// Uses deep copy (just <see cref="VertexUnit"/> is cloned but not <see cref="IndexStream"/>). /// </remarks> /// <param name="semantics"></param> /// <returns></returns> public SubSet Clone(Semantic[] semantics) { SubSet ret = new SubSet(VertexUnit.Clone(semantics), IndexStream, IndexBufferStart, PrimitiveCount); return(ret); }
/// <summary> /// constructor /// </summary> /// <param name="vertexUnit"></param> public PositionStream2(VertexUnit vertexUnit) : base(vertexUnit.Size) { this.vertexUnit = vertexUnit; }