public void ReadFrom(Stream stream) { Seed = stream.ReadInt32(); Radius = stream.ReadFloat(); DeviationScale = stream.ReadFloat(); Diameter = Radius * 2.0f; AveragePlanetRadius = stream.ReadFloat(); }
public void ReadFrom(Stream stream) { int numMaterials = stream.ReadInt32(); Layers = new MyMaterialLayer[numMaterials]; for (int i = 0; i < numMaterials; ++i) { Layers[i] = new MyMaterialLayer(); Layers[i].StartHeight = stream.ReadFloat(); Layers[i].EndHeight = stream.ReadFloat(); Layers[i].StartAngle = stream.ReadFloat(); Layers[i].EndAngle = stream.ReadFloat(); Layers[i].HeightStartDeviation = stream.ReadFloat(); Layers[i].AngleStartDeviation = stream.ReadFloat(); Layers[i].HeightEndDeviation = stream.ReadFloat(); Layers[i].AngleEndDeviation = stream.ReadFloat(); Layers[i].MaterialDefinition = MyDefinitionManager.Static.GetVoxelMaterialDefinition(stream.ReadString()); } int numOreProbabilities = stream.ReadInt32(); OreProbabilities = new MyOreProbability[numOreProbabilities]; for (int i = 0; i < numOreProbabilities; ++i) { OreProbabilities[i] = new MyOreProbability(); OreProbabilities[i].CummulativeProbability = stream.ReadFloat(); OreProbabilities[i].OreName = stream.ReadString(); } OreStartDepth = stream.ReadFloat(); OreEndDepth = stream.ReadFloat(); }
public void ReadFrom(Stream stream) { int numOreProbabilities = stream.ReadInt32(); OreProbabilities = new MyOreProbability[numOreProbabilities]; for (int i = 0; i < numOreProbabilities; ++i) { OreProbabilities[i] = new MyOreProbability(); OreProbabilities[i].CummulativeProbability = stream.ReadFloat(); OreProbabilities[i].OreName = stream.ReadString(); } OreStartDepth = stream.ReadFloat(); OreEndDepth = stream.ReadFloat(); }
public HvaReader(Stream s) { // Index swaps for transposing a matrix var ids = new byte[]{0,4,8,12,1,5,9,13,2,6,10,14}; s.Seek(16, SeekOrigin.Begin); FrameCount = s.ReadUInt32(); LimbCount = s.ReadUInt32(); // Skip limb names s.Seek(16*LimbCount, SeekOrigin.Current); Transforms = new float[16*FrameCount*LimbCount]; for (var j = 0; j < FrameCount; j++) for (var i = 0; i < LimbCount; i++) { // Convert to column-major matrices and add the final matrix row var c = 16*(LimbCount*j + i); Transforms[c + 3] = 0; Transforms[c + 7] = 0; Transforms[c + 11] = 0; Transforms[c + 15] = 1; for (var k = 0; k < 12; k++) Transforms[c + ids[k]] = s.ReadFloat(); } }
public HvaReader(Stream s, string fileName) { // Index swaps for transposing a matrix var ids = new byte[] { 0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14 }; s.Seek(16, SeekOrigin.Begin); FrameCount = s.ReadUInt32(); LimbCount = s.ReadUInt32(); // Skip limb names s.Seek(16 * LimbCount, SeekOrigin.Current); Transforms = new float[16 * FrameCount * LimbCount]; var testMatrix = new float[16]; for (var j = 0; j < FrameCount; j++) for (var i = 0; i < LimbCount; i++) { // Convert to column-major matrices and add the final matrix row var c = 16 * (LimbCount * j + i); Transforms[c + 3] = 0; Transforms[c + 7] = 0; Transforms[c + 11] = 0; Transforms[c + 15] = 1; for (var k = 0; k < 12; k++) Transforms[c + ids[k]] = s.ReadFloat(); Array.Copy(Transforms, 16 * (LimbCount * j + i), testMatrix, 0, 16); if (Util.MatrixInverse(testMatrix) == null) throw new InvalidDataException( "The transformation matrix for HVA file `{0}` section {1} frame {2} is invalid because it is not invertible!" .F(fileName, i, j)); } }
void IMyStorageDataProvider.ReadFrom(ref MyOctreeStorage.ChunkHeader header, Stream stream, ref bool isOldFormat) { m_state.Version = stream.ReadUInt32(); if (m_state.Version != CURRENT_VERSION) { // Making sure this gets saved in new format and serialized cache holding old format is discarded. isOldFormat = true; } m_state.Generator = stream.ReadInt32(); m_state.Seed = stream.ReadInt32(); m_state.Size = stream.ReadFloat(); if (m_state.Version == VERSION_WITHOUT_PLANETS) { m_state.IsPlanet = 0; } else { m_state.IsPlanet = stream.ReadUInt32(); } if (m_state.IsPlanet != 0) { int numMaterials = stream.ReadInt32(); m_materialLayers = new MyMaterialLayer[numMaterials]; for (int i = 0; i < numMaterials; ++i) { m_materialLayers[i] = new MyMaterialLayer(); m_materialLayers[i].StartHeight = stream.ReadFloat(); m_materialLayers[i].EndHeight = stream.ReadFloat(); m_materialLayers[i].MaterialName = stream.ReadString(); m_materialLayers[i].StartAngle = stream.ReadFloat(); m_materialLayers[i].EndAngle = stream.ReadFloat(); m_materialLayers[i].HeightStartDeviation = stream.ReadFloat(); m_materialLayers[i].AngleStartDeviation = stream.ReadFloat(); m_materialLayers[i].HeightEndDeviation = stream.ReadFloat(); m_materialLayers[i].AngleEndDeviation = stream.ReadFloat(); } m_shapeAttributes.Seed = stream.ReadInt32(); m_shapeAttributes.Radius = stream.ReadFloat(); m_shapeAttributes.NoiseFrequency = stream.ReadFloat(); m_shapeAttributes.DeviationScale = stream.ReadFloat(); m_shapeAttributes.NormalNoiseFrequency = stream.ReadFloat(); m_shapeAttributes.LayerDeviationNoiseFreqeuncy = stream.ReadFloat(); m_shapeAttributes.LayerDeviationSeed = stream.ReadInt32(); m_hillAttributes.BlendTreshold = stream.ReadFloat(); m_hillAttributes.Treshold = stream.ReadFloat(); m_hillAttributes.SizeRatio = stream.ReadFloat(); m_hillAttributes.NumNoises = stream.ReadInt32(); m_hillAttributes.Frequency = stream.ReadFloat(); m_canyonAttributes.BlendTreshold = stream.ReadFloat(); m_canyonAttributes.Treshold = stream.ReadFloat(); m_canyonAttributes.SizeRatio = stream.ReadFloat(); m_canyonAttributes.NumNoises = stream.ReadInt32(); m_canyonAttributes.Frequency = stream.ReadFloat(); MyCompositeShapes.PlanetGenerators[m_state.Generator](ref m_shapeAttributes,ref m_hillAttributes, ref m_canyonAttributes, m_materialLayers, out m_data); } else { MyCompositeShapes.AsteroidGenerators[m_state.Generator](m_state.Seed, m_state.Size, out m_data); } m_state.Version = CURRENT_VERSION; }
public override void ReadFromStream(Stream aStream) { Yaw = aStream.ReadFloat(); Pitch = aStream.ReadFloat(); OnGround = aStream.ReadBoolean(); }
public void ReadFrom(Stream stream) { Seed = stream.ReadInt32(); Radius = stream.ReadFloat(); NoiseFrequency = stream.ReadFloat(); DeviationScale = stream.ReadFloat(); NormalNoiseFrequency = stream.ReadFloat(); LayerDeviationNoiseFrequency = stream.ReadFloat(); LayerDeviationSeed = stream.ReadInt32(); Diameter = Radius * 2.0f; }
public override void ReadFromStream(Stream aStream) { X = aStream.ReadDouble (); Stance = aStream.ReadDouble (); Y = aStream.ReadDouble (); Z = aStream.ReadDouble (); Yaw = aStream.ReadFloat (); Pitch = aStream.ReadFloat (); OnGround = aStream.ReadBoolean (); }
void IMyStorageDataProvider.ReadFrom(ref MyOctreeStorage.ChunkHeader header, Stream stream, ref bool isOldFormat) { m_state.Version = stream.ReadUInt32(); if (m_state.Version != CURRENT_VERSION) { // Making sure this gets saved in new format and serialized cache holding old format is discarded. isOldFormat = true; } m_state.Generator = stream.ReadInt32(); m_state.Seed = stream.ReadInt32(); m_state.Size = stream.ReadFloat(); if (m_state.Version == VERSION_WITHOUT_PLANETS) { m_state.UnusedCompat = 0; } else { m_state.UnusedCompat = stream.ReadUInt32(); if (m_state.UnusedCompat == 1) { Debug.Fail("This storage is from a prototype version of planets and is no longer supported."); throw new InvalidBranchException(); } } var gen = MyCompositeShapes.AsteroidGenerators[m_state.Generator]; gen(m_state.Seed, m_state.Size, out m_data); m_state.Version = CURRENT_VERSION; }
public static void ReadMeshData(Stream stream, Pmo pmo, int MeshNumber = 0) { // Go to mesh position. if (MeshNumber == 0) { stream.Seek(pmo.header.MeshOffset0, SeekOrigin.Begin); } else { stream.Seek(pmo.header.MeshOffset1, SeekOrigin.Begin); } UInt16 VertCnt = 0xFFFF; while (VertCnt > 0) { MeshChunks meshChunk = new MeshChunks(); meshChunk.MeshNumber = MeshNumber; meshChunk.SectionInfo = BinaryMapping.ReadObject <MeshSection>(stream); // Exit if Vertex Count is zero. if (meshChunk.SectionInfo.VertexCount <= 0) { break; } meshChunk.TextureID = meshChunk.SectionInfo.TextureID; VertexFlags flags = GetFlags(meshChunk.SectionInfo); bool isColorFlagRisen = flags.UniformDiffuseFlag; if (pmo.header.SkeletonOffset != 0) { meshChunk.SectionInfo_opt1 = BinaryMapping.ReadObject <MeshSectionOptional1>(stream); } if (isColorFlagRisen) { meshChunk.SectionInfo_opt2 = BinaryMapping.ReadObject <MeshSectionOptional2>(stream); } if (meshChunk.SectionInfo.TriangleStripCount > 0) { meshChunk.TriangleStripValues = new UInt16[meshChunk.SectionInfo.TriangleStripCount]; for (int i = 0; i < meshChunk.SectionInfo.TriangleStripCount; i++) { meshChunk.TriangleStripValues[i] = stream.ReadUInt16(); } } // Get Formats. CoordinateFormat TexCoordFormat = flags.TextureCoordinateFormat; CoordinateFormat VertexPositionFormat = flags.PositionFormat; CoordinateFormat WeightFormat = flags.WeightFormat; ColorFormat ColorFormat = flags.ColorFormat; UInt32 SkinningWeightsCount = flags.SkinningWeightsCount; BinaryReader r = new BinaryReader(stream); long positionAfterHeader = stream.Position; if (meshChunk.SectionInfo.TriangleStripCount > 0) { int vertInd = 0; for (int p = 0; p < meshChunk.SectionInfo.TriangleStripCount; p++) { for (int s = 0; s < (meshChunk.TriangleStripValues[p] - 2); s++) { if (s % 2 == 0) { meshChunk.Indices.Add(vertInd + s + 0); meshChunk.Indices.Add(vertInd + s + 1); meshChunk.Indices.Add(vertInd + s + 2); } else { meshChunk.Indices.Add(vertInd + s + 0); meshChunk.Indices.Add(vertInd + s + 2); meshChunk.Indices.Add(vertInd + s + 1); } } vertInd += meshChunk.TriangleStripValues[p]; } } else { if (flags.Primitive == PrimitiveType.PRIMITIVE_TRIANGLE_STRIP) { for (int s = 0; s < (meshChunk.SectionInfo.VertexCount - 2); s++) { if (s % 2 == 0) { meshChunk.Indices.Add(s + 0); meshChunk.Indices.Add(s + 1); meshChunk.Indices.Add(s + 2); } else { meshChunk.Indices.Add(s + 1); meshChunk.Indices.Add(s + 0); meshChunk.Indices.Add(s + 2); } } } } for (int v = 0; v < meshChunk.SectionInfo.VertexCount; v++) { long vertexStartPos = stream.Position; int vertexIncreaseAmount = 0; if (pmo.header.SkeletonOffset != 0 && WeightFormat != CoordinateFormat.NO_VERTEX) { for (int i = 0; i < (SkinningWeightsCount + 1); i++) { switch (WeightFormat) { case CoordinateFormat.NORMALIZED_8_BITS: meshChunk.jointWeights.Add(stream.ReadByte() / 127.0f); break; case CoordinateFormat.NORMALIZED_16_BITS: meshChunk.jointWeights.Add(stream.ReadUInt16() / 32767.0f); break; case CoordinateFormat.FLOAT_32_BITS: meshChunk.jointWeights.Add(stream.ReadFloat()); break; case CoordinateFormat.NO_VERTEX: break; } } } Vector2 currentTexCoord; switch (TexCoordFormat) { case CoordinateFormat.NORMALIZED_8_BITS: currentTexCoord.X = stream.ReadByte() / 127.0f; currentTexCoord.Y = stream.ReadByte() / 127.0f; meshChunk.textureCoordinates.Add(currentTexCoord); break; case CoordinateFormat.NORMALIZED_16_BITS: vertexIncreaseAmount = ((0x2 - (Convert.ToInt32(stream.Position - vertexStartPos) & 0x1)) & 0x1); stream.Seek(vertexIncreaseAmount, SeekOrigin.Current); currentTexCoord.X = stream.ReadUInt16() / 32767.0f; currentTexCoord.Y = stream.ReadUInt16() / 32767.0f; meshChunk.textureCoordinates.Add(currentTexCoord); break; case CoordinateFormat.FLOAT_32_BITS: vertexIncreaseAmount = ((0x4 - (Convert.ToInt32(stream.Position - vertexStartPos) & 0x3)) & 0x3); stream.Seek(vertexIncreaseAmount, SeekOrigin.Current); currentTexCoord.X = stream.ReadFloat(); currentTexCoord.Y = stream.ReadFloat(); meshChunk.textureCoordinates.Add(currentTexCoord); break; } switch (ColorFormat) { case Pmo.ColorFormat.NO_COLOR: meshChunk.colors.Add(new Vector4(0xFF, 0xFF, 0xFF, 0xFF)); break; case Pmo.ColorFormat.BGR_5650_16BITS: stream.ReadUInt16(); break; case Pmo.ColorFormat.ABGR_5551_16BITS: stream.ReadUInt16(); break; case Pmo.ColorFormat.ABGR_4444_16BITS: stream.ReadUInt16(); break; case Pmo.ColorFormat.ABGR_8888_32BITS: vertexIncreaseAmount = ((0x4 - (Convert.ToInt32(stream.Position - vertexStartPos) & 0x3)) & 0x3); stream.Seek(vertexIncreaseAmount, SeekOrigin.Current); Vector4 col; col.X = stream.ReadByte(); col.Y = stream.ReadByte(); col.Z = stream.ReadByte(); col.W = stream.ReadByte(); meshChunk.colors.Add(col); break; } Vector3 currentVertex; // Handle triangles and triangle strips. switch (VertexPositionFormat) { case CoordinateFormat.NORMALIZED_8_BITS: currentVertex.X = r.ReadSByte() / 127.0f; currentVertex.Y = r.ReadSByte() / 127.0f; currentVertex.Z = r.ReadSByte() / 127.0f; meshChunk.vertices.Add(currentVertex); break; case CoordinateFormat.NORMALIZED_16_BITS: vertexIncreaseAmount = ((0x2 - (Convert.ToInt32(stream.Position - vertexStartPos) & 0x1)) & 0x1); stream.Seek(vertexIncreaseAmount, SeekOrigin.Current); currentVertex.X = (float)stream.ReadInt16() / 32767.0f; currentVertex.Y = (float)stream.ReadInt16() / 32767.0f; currentVertex.Z = (float)stream.ReadInt16() / 32767.0f; meshChunk.vertices.Add(currentVertex); break; case CoordinateFormat.FLOAT_32_BITS: vertexIncreaseAmount = ((0x4 - (Convert.ToInt32(stream.Position - vertexStartPos) & 0x3)) & 0x3); stream.Seek(vertexIncreaseAmount, SeekOrigin.Current); currentVertex.X = stream.ReadFloat(); currentVertex.Y = stream.ReadFloat(); currentVertex.Z = stream.ReadFloat(); meshChunk.vertices.Add(currentVertex); break; } stream.Seek(vertexStartPos + meshChunk.SectionInfo.VertexSize, SeekOrigin.Begin); if (flags.Primitive == PrimitiveType.PRIMITIVE_TRIANGLE) { meshChunk.Indices.Add(v); } } VertCnt = meshChunk.SectionInfo.VertexCount; pmo.Meshes.Add(meshChunk); // Find position of next data chunk. stream.Seek(positionAfterHeader + (meshChunk.SectionInfo.VertexCount * meshChunk.SectionInfo.VertexSize), SeekOrigin.Begin); stream.Seek(stream.Position % 4, SeekOrigin.Current); } }
public VxlReader(Stream s) { if (!s.ReadASCII(16).StartsWith("Voxel Animation")) throw new InvalidDataException("Invalid vxl header"); s.ReadUInt32(); LimbCount = s.ReadUInt32(); s.ReadUInt32(); BodySize = s.ReadUInt32(); s.Seek(770, SeekOrigin.Current); // Read Limb headers Limbs = new VxlLimb[LimbCount]; for (var i = 0; i < LimbCount; i++) { Limbs[i] = new VxlLimb(); Limbs[i].Name = s.ReadASCII(16); s.Seek(12, SeekOrigin.Current); } // Skip to the Limb footers s.Seek(802 + 28*LimbCount + BodySize, SeekOrigin.Begin); var LimbDataOffset = new uint[LimbCount]; for (var i = 0; i < LimbCount; i++) { LimbDataOffset[i] = s.ReadUInt32(); s.Seek(8, SeekOrigin.Current); Limbs[i].Scale = s.ReadFloat(); s.Seek(48, SeekOrigin.Current); Limbs[i].Bounds = new float[6]; for (var j = 0; j < 6; j++) Limbs[i].Bounds[j] = s.ReadFloat(); Limbs[i].Size = s.ReadBytes(3); Limbs[i].Type = (NormalType)s.ReadByte(); } for (var i = 0; i < LimbCount; i++) { s.Seek(802 + 28*LimbCount + LimbDataOffset[i], SeekOrigin.Begin); ReadVoxelData(s, Limbs[i]); } }
/// <summary> /// Populate this instance from the given <see cref="Stream"/> as a binary <see cref="KeyValue"/>. /// </summary> /// <param name="input">The input <see cref="Stream"/> to read from.</param> /// <returns><c>true</c> if the read was successful; otherwise, <c>false</c>.</returns> public bool ReadAsBinary(Stream input) { this.Children = new List <KeyValue>(); while (true) { var type = ( Type )input.ReadByte(); if (type == Type.End) { break; } var current = new KeyValue(); current.Name = input.ReadNullTermString(Encoding.UTF8); try { switch (type) { case Type.None: { current.ReadAsBinary(input); break; } case Type.String: { current.Value = input.ReadNullTermString(Encoding.UTF8); break; } case Type.WideString: { throw new InvalidDataException("wstring is unsupported"); } case Type.Int32: case Type.Color: case Type.Pointer: { current.Value = Convert.ToString(input.ReadInt32()); break; } case Type.UInt64: { current.Value = Convert.ToString(input.ReadUInt64()); break; } case Type.Float32: { current.Value = Convert.ToString(input.ReadFloat()); break; } default: { throw new InvalidDataException("Unknown KV type encountered."); } } } catch (InvalidDataException ex) { throw new InvalidDataException(string.Format("An exception ocurred while reading KV '{0}'", current.Name), ex); } this.Children.Add(current); } return(input.Position == input.Length); }
public static object Read(Stream stream, FormatItem format, DbEnvironment env) { switch (format.DataType) { case TdsDataType.TDS_BIT: return(stream.ReadBool()); case TdsDataType.TDS_INT1: return((byte)stream.ReadByte()); case TdsDataType.TDS_SINT1: return((sbyte)stream.ReadByte()); case TdsDataType.TDS_INT2: return(stream.ReadShort()); case TdsDataType.TDS_UINT2: return(stream.ReadUShort()); case TdsDataType.TDS_INT4: return(stream.ReadInt()); case TdsDataType.TDS_UINT4: return(stream.ReadUInt()); case TdsDataType.TDS_INT8: return(stream.ReadLong()); case TdsDataType.TDS_UINT8: return(stream.ReadULong()); case TdsDataType.TDS_INTN: switch (stream.ReadByte()) { case 0: return(DBNull.Value); case 1: return((byte)stream.ReadByte()); //both INTN(1) and UINTN(1) are an INT1. Never an SINT1. case 2: return(stream.ReadShort()); case 4: return(stream.ReadInt()); case 8: return(stream.ReadLong()); } break; case TdsDataType.TDS_UINTN: switch (stream.ReadByte()) { case 0: return(DBNull.Value); case 1: return((byte)stream.ReadByte()); case 2: return(stream.ReadUShort()); case 4: return(stream.ReadUInt()); case 8: return(stream.ReadULong()); } break; case TdsDataType.TDS_FLT4: return(stream.ReadFloat()); case TdsDataType.TDS_FLT8: return(stream.ReadDouble()); case TdsDataType.TDS_FLTN: switch (stream.ReadByte()) { case 0: return(DBNull.Value); case 4: return(stream.ReadFloat()); case 8: return(stream.ReadDouble()); } break; case TdsDataType.TDS_CHAR: case TdsDataType.TDS_VARCHAR: case TdsDataType.TDS_BOUNDARY: case TdsDataType.TDS_SENSITIVITY: return(stream.ReadNullableByteLengthPrefixedString(env.Encoding)); case TdsDataType.TDS_BINARY: case TdsDataType.TDS_VARBINARY: return(stream.ReadNullableByteLengthPrefixedByteArray()); case TdsDataType.TDS_LONGCHAR: return(stream.ReadNullableIntLengthPrefixedString(env.Encoding)); /* * TDS_LONGBINARY serialization 55 serialized java object or instance (i.e. java object) * TDS_LONGBINARY serialized java class 56 serialized java class (i.e. byte code) * TDS_LONGBINARY smallbinary 59 64K max length binary data (ASA) * TDS_LONGBINARY unichar 34 fixed length UTF-16 encoded data * TDS_LONGBINARY univarchar 35 variable length UTF-16 encoded data */ case TdsDataType.TDS_LONGBINARY: { //the UserType can affect how we need to interpret the result data switch (format.UserType) { case 34: case 35: return(stream.ReadNullableIntLengthPrefixedString(Encoding.Unicode)); default: return(stream.ReadNullableIntLengthPrefixedByteArray()); } } case TdsDataType.TDS_DECN: case TdsDataType.TDS_NUMN: { var precision = format.Precision ?? 1; var scale = format.Scale ?? 0; if (env.UseAseDecimal) { var aseDecimal = stream.ReadAseDecimal(precision, scale); return(aseDecimal.HasValue ? env.UseAseDecimal ? (object)aseDecimal.Value : aseDecimal.Value.ToDecimal() : DBNull.Value); } return((object)stream.ReadDecimal(precision, scale) ?? DBNull.Value); } case TdsDataType.TDS_MONEY: return(stream.ReadMoney()); case TdsDataType.TDS_SHORTMONEY: return(stream.ReadSmallMoney()); case TdsDataType.TDS_MONEYN: switch (stream.ReadByte()) { case 0: return(DBNull.Value); case 4: return(stream.ReadSmallMoney()); case 8: return(stream.ReadMoney()); } break; case TdsDataType.TDS_DATETIME: return(stream.ReadIntPartDateTime()); case TdsDataType.TDS_SHORTDATE: return(stream.ReadShortPartDateTime()); case TdsDataType.TDS_DATETIMEN: switch (stream.ReadByte()) { case 0: return(DBNull.Value); case 4: return(stream.ReadShortPartDateTime()); case 8: return(stream.ReadIntPartDateTime()); } break; case TdsDataType.TDS_DATE: return(stream.ReadDate()); case TdsDataType.TDS_DATEN: switch (stream.ReadByte()) { case 0: return(DBNull.Value); case 4: return(stream.ReadDate()); } break; case TdsDataType.TDS_TIME: return(stream.ReadTime()); case TdsDataType.TDS_TIMEN: switch (stream.ReadByte()) { case 0: return(DBNull.Value); case 4: return(stream.ReadTime()); } break; case TdsDataType.TDS_TEXT: case TdsDataType.TDS_XML: { var textPtrLen = (byte)stream.ReadByte(); if (textPtrLen == 0) { return(DBNull.Value); } var textPtr = new byte[textPtrLen]; stream.Read(textPtr, 0, textPtrLen); stream.ReadULong(); //timestamp return(stream.ReadNullableIntLengthPrefixedString(env.Encoding)); } case TdsDataType.TDS_IMAGE: { var textPtrLen = (byte)stream.ReadByte(); if (textPtrLen == 0) { return(DBNull.Value); } var textPtr = new byte[textPtrLen]; stream.Read(textPtr, 0, textPtrLen); stream.ReadULong(); //timestamp var dataLen = stream.ReadInt(); var data = new byte[dataLen]; stream.Read(data, 0, dataLen); return(data); } case TdsDataType.TDS_UNITEXT: { var textPtrLen = (byte)stream.ReadByte(); if (textPtrLen == 0) { return(DBNull.Value); } var textPtr = new byte[textPtrLen]; stream.Read(textPtr, 0, textPtrLen); stream.ReadULong(); //timestamp return(stream.ReadNullableIntLengthPrefixedString(Encoding.Unicode)); } default: Debug.Assert(false, $"Unsupported data type {format.DataType}"); break; } return(DBNull.Value); // Catch-all. }
void IMyStorageDataProvider.ReadFrom(ref MyOctreeStorage.ChunkHeader header, Stream stream, ref bool isOldFormat) { m_state.Version = stream.ReadUInt32(); if (m_state.Version != CURRENT_VERSION) { // Making sure this gets saved in new format and serialized cache holding old format is discarded. isOldFormat = true; } m_state.Generator = stream.ReadInt32(); m_state.Seed = stream.ReadInt32(); m_state.Size = stream.ReadFloat(); if (m_state.Version == VERSION_WITHOUT_PLANETS) { m_state.IsPlanet = 0; } else { m_state.IsPlanet = stream.ReadUInt32(); } if (m_state.IsPlanet != 0) { int numMaterials = stream.ReadInt32(); m_materialLayers = new MyMaterialLayer[numMaterials]; for (int i = 0; i < numMaterials; ++i) { m_materialLayers[i] = new MyMaterialLayer(); m_materialLayers[i].StartHeight = stream.ReadFloat(); m_materialLayers[i].EndHeight = stream.ReadFloat(); m_materialLayers[i].MaterialName = stream.ReadString(); m_materialLayers[i].StartAngle = stream.ReadFloat(); m_materialLayers[i].EndAngle = stream.ReadFloat(); m_materialLayers[i].HeightStartDeviation = stream.ReadFloat(); m_materialLayers[i].AngleStartDeviation = stream.ReadFloat(); m_materialLayers[i].HeightEndDeviation = stream.ReadFloat(); m_materialLayers[i].AngleEndDeviation = stream.ReadFloat(); } m_shapeAttributes.Seed = stream.ReadInt32(); m_shapeAttributes.Radius = stream.ReadFloat(); m_shapeAttributes.NoiseFrequency = stream.ReadFloat(); m_shapeAttributes.DeviationScale = stream.ReadFloat(); m_shapeAttributes.NormalNoiseFrequency = stream.ReadFloat(); m_shapeAttributes.LayerDeviationNoiseFreqeuncy = stream.ReadFloat(); m_shapeAttributes.LayerDeviationSeed = stream.ReadInt32(); m_hillAttributes.BlendTreshold = stream.ReadFloat(); m_hillAttributes.Treshold = stream.ReadFloat(); m_hillAttributes.SizeRatio = stream.ReadFloat(); m_hillAttributes.NumNoises = stream.ReadInt32(); m_hillAttributes.Frequency = stream.ReadFloat(); m_canyonAttributes.BlendTreshold = stream.ReadFloat(); m_canyonAttributes.Treshold = stream.ReadFloat(); m_canyonAttributes.SizeRatio = stream.ReadFloat(); m_canyonAttributes.NumNoises = stream.ReadInt32(); m_canyonAttributes.Frequency = stream.ReadFloat(); MyCompositeShapes.PlanetGenerators[m_state.Generator](ref m_shapeAttributes, ref m_hillAttributes, ref m_canyonAttributes, m_materialLayers, out m_data); } else { MyCompositeShapes.AsteroidGenerators[m_state.Generator](m_state.Seed, m_state.Size, out m_data); } m_state.Version = CURRENT_VERSION; }
private static object ReadTDS_FLT4(Stream stream, FormatItem format, DbEnvironment env) { return(stream.ReadFloat()); }
public static void ReadAndMapProperty(this Stream stream, object obj, List <string> nameTable) { var baseProperty = stream.ReadBaseProperty(); var pi = obj.GetType().GetField(nameTable[baseProperty.NameIdx], BindingFlags.Public | BindingFlags.Instance); if (pi == null) { return; } var fieldType = pi.FieldType.IsGenericType && pi.FieldType.GetGenericTypeDefinition() == typeof(Nullable <>) ? Nullable.GetUnderlyingType(pi.FieldType) : pi.FieldType; object value = null; switch (nameTable[baseProperty.TypeIdx]) { case "IntProperty": value = stream.ReadInt32(); break; case "BoolProperty": value = stream.ReadBool(); break; case "ByteProperty": stream.ReadInt32(); // EnumNameIdx var enumValueNameIdx = stream.ReadInt32(); value = Enum.Parse(fieldType, nameTable[enumValueNameIdx]); break; case "FloatProperty": value = stream.ReadFloat(); break; case "NameProperty": value = stream.ReadNameProperty(nameTable); break; case "StrProperty": value = stream.ReadString(); break; case "ArrayProperty": // У массивов NumElements входит в PropertySize var numElements = stream.ReadInt32(); // Если элементов нет, то следом идет сразу следующее свойство, массив не заканчивается ничем, нет даже None if (numElements == 0) { return; } value = Activator.CreateInstance(fieldType); var elementType = fieldType.GetGenericArguments()[0]; for (var i = 0; i < numElements; i++) { if (elementType == typeof(int)) // array<int> { (value as IList).Add(stream.ReadInt32()); } else if (elementType == typeof(string)) // array<string> { (value as IList).Add(stream.ReadString()); } else if (elementType == typeof(NameProperty)) // array<name> { (value as IList).Add(stream.ReadNameProperty(nameTable)); } else { var element = Activator.CreateInstance(elementType); var nameIdx = stream.ReadInt32(); while (nameTable[nameIdx] != "None") { stream.Seek(-4, SeekOrigin.Current); stream.ReadAndMapProperty(element, nameTable); nameIdx = stream.ReadInt32(); } (value as IList).Add(element); } } break; case "StructProperty": // У структур StructNameIdx не входит в PropertySize var structNameIdx = stream.ReadInt32(); switch (nameTable[structNameIdx]) { case "Vector": value = new Vector { X = stream.ReadFloat(), Y = stream.ReadFloat(), Z = stream.ReadFloat() }; break; case "Rotator": value = new Rotator { Pitch = stream.ReadInt32(), Yaw = stream.ReadInt32(), Roll = stream.ReadInt32() }; break; case "Transform": stream.Seek(baseProperty.PropertySize, SeekOrigin.Current); break; default: // На случай SEpisodeBoundaryStats[] value = Activator.CreateInstance(fieldType.IsArray ? fieldType.GetElementType() : fieldType); var nameIdx = stream.ReadInt32(); // None в конце всех структур, кроме стандартных Vector, Rotator, Transform while (nameTable[nameIdx] != "None") { stream.Seek(-4, SeekOrigin.Current); stream.ReadAndMapProperty(value, nameTable); nameIdx = stream.ReadInt32(); } break; } break; } if (fieldType.IsArray) { var array = (Array)pi.GetValue(obj); array.SetValue(value, baseProperty.ArrayIdx); pi.SetValue(obj, array); } else { pi.SetValue(obj, value); } }
public static Vector3 ReadVector3(this Stream fs) { return(new Vector3(fs.ReadFloat(), fs.ReadFloat(), fs.ReadFloat())); }
public static Rect ReadRect(this Stream fs) { return(new Rect(fs.ReadFloat(), fs.ReadFloat(), fs.ReadFloat(), fs.ReadFloat())); }
static bool TryReadAsBinaryCore(Stream input, KeyValue current, KeyValue parent) { current.Children = new List <KeyValue>(); while (true) { var type = ( Type )input.ReadByte(); if (type == Type.End) { break; } current.Name = input.ReadNullTermString(Encoding.UTF8); switch (type) { case Type.None: { var child = new KeyValue(); var didReadChild = TryReadAsBinaryCore(input, child, current); if (!didReadChild) { return(false); } break; } case Type.String: { current.Value = input.ReadNullTermString(Encoding.UTF8); break; } case Type.WideString: { DebugLog.WriteLine("KeyValue", "Encountered WideString type when parsing binary KeyValue, which is unsupported. Returning false."); return(false); } case Type.Int32: case Type.Color: case Type.Pointer: { current.Value = Convert.ToString(input.ReadInt32()); break; } case Type.UInt64: { current.Value = Convert.ToString(input.ReadUInt64()); break; } case Type.Float32: { current.Value = Convert.ToString(input.ReadFloat()); break; } default: { return(false); } } if (parent != null) { parent.Children.Add(current); } current = new KeyValue(); } return(true); }
/// <summary> /// Load StatValue data from stream /// </summary> /// <param name="stream"></param> public void Load(Stream stream, float version) { if (version != 1.4f) { return; } name = stream.ReadStringPacket(); curBaseValue = stream.ReadFloat(); curBaseMin = stream.ReadFloat(); curBaseMax = stream.ReadFloat(); curBaseRegenAmount = stream.ReadFloat(); curBaseRegenDelay = stream.ReadFloat(); curValue = stream.ReadFloat(); curMin = stream.ReadFloat(); curMax = stream.ReadFloat(); curRegenAmount = stream.ReadFloat(); curRegenDelay = stream.ReadFloat(); nextRegen = stream.ReadFloat(); ActiveModifiers.Clear(); int count = stream.ReadInt(); for (int i = 0; i < count; i++) { StatModifier sm = new StatModifier(); sm.Load(stream); ActiveModifiers.Add(sm); } // Raise events if (onInit != null) { onInit.Invoke(); } }
/** <inheritdoc /> */ public float ReadFloat() { return(Stream.ReadFloat()); }
private static Entity ReadEntity(Stream stream, IDictionary <int, Group> groups, IDictionary <int, VisGroup> visGroups) { var className = stream.ReadLengthPrefixedString(); var origin = ReadVector3D(stream); var flags = (Flags)stream.ReadInt(); // NOTE: Editor state (hidden, selected), not entity spawnflags. var groupID = stream.ReadInt(); var rootGroupID = stream.ReadInt(); var color = ReadColor(stream); // NOTE: Each entity contains a list of 'special' attribute names, but they're not relevant for MESS: for (int i = 0; i < 13; i++) { stream.ReadLengthPrefixedString(); } // Many 'special' attributes are stored here, but they're only included in a MAP file export if they // also occur in the properties dictionary, so MESS can ignore these: var spawnflags = stream.ReadInt(); var angles = ReadAngles(stream); var rendering = (Rendering)stream.ReadInt(); var rawFxColor = stream.ReadBytes(4); var fxColor = new Color(rawFxColor[3], rawFxColor[2], rawFxColor[1], rawFxColor[0]); var renderMode = stream.ReadInt(); var renderFX = stream.ReadInt(); var body = stream.ReadShort(); var skin = stream.ReadShort(); var sequence = stream.ReadInt(); var framerate = stream.ReadFloat(); var scale = stream.ReadFloat(); var radius = stream.ReadFloat(); var unknown1 = stream.ReadBytes(28); var propertyCount = stream.ReadInt(); var properties = Enumerable.Range(0, propertyCount) .Select(i => Tuple.Create(stream.ReadLengthPrefixedString(), stream.ReadLengthPrefixedString())) .ToArray(); var visGroupCount = stream.ReadInt(); var visGroupIDs = Enumerable.Range(0, visGroupCount) .Select(i => stream.ReadInt()) .ToArray(); var brushCount = stream.ReadInt(); var brushes = Enumerable.Range(0, brushCount) .Select(i => ReadBrush(stream, groups, visGroups)) .ToArray(); var entity = new Entity(brushes); entity.ClassName = className; entity.Origin = origin; entity.Color = color; entity.Group = (groupID != 0 && groups.TryGetValue(groupID, out var group)) ? group : null; //entity.VisGroup; // TODO: MESS does not support objects being part of multiple VIS groups! foreach (var property in properties) { entity.Properties[property.Item1] = property.Item2; } return(entity); }
void IMyStorageDataProvider.ReadFrom(ref MyOctreeStorage.ChunkHeader header, Stream stream, ref bool isOldFormat) { m_state.Version = stream.ReadUInt32(); if (m_state.Version != CURRENT_VERSION) { // Making sure this gets saved in new format and serialized cache holding old format is discarded. isOldFormat = true; m_state.Version = CURRENT_VERSION; } m_state.Generator = stream.ReadInt32(); m_state.Seed = stream.ReadInt32(); m_state.Size = stream.ReadFloat(); MyCompositeShapes.AsteroidGenerators[m_state.Generator](m_state.Seed, m_state.Size, out m_data); }
private static Face ReadFace(Stream stream) { var face = new Face(); var renderFlags = stream.ReadInt(); var vertexCount = stream.ReadInt(); face.TextureRightAxis = ReadVector3D(stream); var textureShiftX = stream.ReadFloat(); face.TextureDownAxis = ReadVector3D(stream); var textureShiftY = stream.ReadFloat(); face.TextureShift = new Vector2D(textureShiftX, textureShiftY); face.TextureScale = new Vector2D(stream.ReadFloat(), stream.ReadFloat()); face.TextureAngle = stream.ReadFloat(); var unknown1 = stream.ReadInt(); var unknown2 = stream.ReadBytes(16); face.TextureName = stream.ReadString(64); var unknown3 = stream.ReadFloat(); var unknown4 = stream.ReadFloat(); var unknown5 = stream.ReadFloat(); var unknown6 = stream.ReadFloat(); var unknown7 = stream.ReadInt(); for (int i = 0; i < vertexCount; i++) { var position = ReadVector3D(stream); // TODO: Normal? var vertexUnknown1 = stream.ReadFloat(); var vertexUnknown2 = stream.ReadFloat(); var vertexUnknown3 = stream.ReadFloat(); face.Vertices.Add(position); } face.PlanePoints = face.Vertices.Take(3).Reverse().ToArray(); return(face); }
public override void ReadFromStream(Stream aStream) { Yaw = aStream.ReadFloat (); Pitch = aStream.ReadFloat (); OnGround = aStream.ReadBoolean (); }
private static Vector3D ReadVector3D(Stream stream) { return(new Vector3D(stream.ReadFloat(), stream.ReadFloat(), stream.ReadFloat())); }
public override void ReadFromStream(Stream aStream) { A = aStream.ReadFloat (); B = aStream.ReadFloat (); C = aStream.ReadBoolean (); D = aStream.ReadBoolean (); E = aStream.ReadFloat (); F = aStream.ReadFloat (); }
public GBXVec3(Stream s) { X = s.ReadFloat(); Y = s.ReadFloat(); Z = s.ReadFloat(); }
public void ReadFrom(Stream stream) { BlendTreshold = stream.ReadFloat(); Treshold = stream.ReadFloat(); SizeRatio = stream.ReadFloat(); NumNoises = stream.ReadInt32(); Frequency = stream.ReadFloat(); }
public static Color ReadColor(this Stream fs) { return(new Color(fs.ReadFloat(), fs.ReadFloat(), fs.ReadFloat(), fs.ReadFloat())); }
public static ShaderInfo DisassembleShader(Stream inStream, TextWriter writer = null) { uint vers = inStream.ReadUInt32(); var minor = vers.bits(7, 0); var major = vers.bits(15, 8); var shaderType = (Frequency)vers.bits(31, 16); if (shaderType != Frequency.Pixel && shaderType != Frequency.Vertex) { Console.WriteLine("Not a valid Shader!"); return(null); } int instructionCount = 0; int texInstructionCount = 0; int indent = 2; var shaderInfo = new ShaderInfo { Frequency = shaderType }; while (inStream.Position + 4 <= inStream.Length) { uint token = inStream.ReadUInt32(); var opcode = (OpcodeType)token.bits(15, 0); if (opcode == OpcodeType.D3DSIO_END) { writer?.WriteLine(); writer?.WriteLine(shaderType == Frequency.Pixel ? $"// approximately {instructionCount + texInstructionCount} instruction slots used ({texInstructionCount} texture, {instructionCount} arithmetic)" : $"// approximately {instructionCount} instruction slots used"); return(shaderInfo); } else if (opcode == OpcodeType.D3DSIO_COMMENT) { //writer?.WriteLine("Begin COMMENT"); uint length = token.bits(30, 16); long commentEnd = length * 4 + inStream.Position; if (inStream.ReadUInt32() == CTAB) { long ctabPos = inStream.Position; var header = new D3DConstantTable(inStream); inStream.Seek(ctabPos + header.ConstantInfo, SeekOrigin.Begin); var constantInfos = new ConstRegisterInfo[header.Constants]; for (int i = 0; i < header.Constants; i++) { constantInfos[i] = new ConstRegisterInfo(inStream); } inStream.Seek(ctabPos + header.Creator, SeekOrigin.Begin); string creator = inStream.ReadString(); writer?.WriteLine("//"); writer?.WriteLine($"// Generated by {creator}"); writer?.WriteLine("//"); shaderInfo.Constants = new ConstantInfo[header.Constants]; //writer?.WriteLine("BEGIN Constant Table"); for (int i = 0; i < constantInfos.Length; i++) { ConstRegisterInfo info = constantInfos[i]; inStream.Seek(ctabPos + info.TypeInfo, SeekOrigin.Begin); var type = new TypeInfo(inStream); inStream.Seek(ctabPos + info.Name, SeekOrigin.Begin); string name = inStream.ReadString(); shaderInfo.Constants[i] = new ConstantInfo(name, (D3DXREGISTER_SET)info.RegisterSet, info.RegisterIndex, info.RegisterCount, info.DefaultValue, (D3DXPARAMETER_CLASS)type.Class, (D3DXPARAMETER_TYPE)type.Type, type.Rows, type.Columns, type.Elements); #if DEBUGGING writer?.WriteLine(); writer?.WriteLine(name); writer?.WriteLine($"RegisterSet: {(D3DXREGISTER_SET)info.RegisterSet}, RegisterIndex: {info.RegisterIndex}, RegisterCount: {info.RegisterCount}," + $" DefaultValue: {info.DefaultValue}"); writer?.WriteLine($"Class: {(D3DXPARAMETER_CLASS)type.Class}, Type: {(D3DXPARAMETER_TYPE)type.Type}, Rows: {type.Rows}, Columns: {type.Columns}," + $" Elements: {type.Elements}, StructMembers {type.StructMembers}, StructMemberInfo: {type.StructMemberInfo}"); #endif } writer?.WriteLine("// Parameters:"); writer?.WriteLine("//"); foreach (ConstantInfo info in shaderInfo.Constants) { string line = $"// {d3d9types.paramTypes[info.ParameterType]}"; switch (info.ParameterClass) { case D3DXPARAMETER_CLASS.SCALAR: case D3DXPARAMETER_CLASS.OBJECT: break; case D3DXPARAMETER_CLASS.VECTOR: line += info.Columns; break; case D3DXPARAMETER_CLASS.MATRIX_COLUMNS: line += $"{info.Rows}x{info.Columns}"; break; case D3DXPARAMETER_CLASS.MATRIX_ROWS: line += "ROWS?????????"; break; case D3DXPARAMETER_CLASS.STRUCT: line += "STRUCT?????????"; break; } line += " "; line += info.Name; if (info.Elements > 1) { line += $"[{info.Elements}]"; } line += ";"; writer?.WriteLine(line); } writer?.WriteLine("//"); writer?.WriteLine("//"); int maxNameLength = Math.Max(12, shaderInfo.Constants.Max(c => c.Name.Length)); int regTextLength = Math.Max(5, shaderInfo.Constants.Max(c => c.RegisterIndex.NumDigits()) + 1); int sizeTextLength = Math.Max(4, shaderInfo.Constants.Max(c => c.RegisterCount.NumDigits())); writer?.WriteLine("// Registers:"); writer?.WriteLine("//"); writer?.WriteLine($"// {"Name".PadRight(maxNameLength)} {"Reg".PadRight(regTextLength)} {"Size".PadRight(sizeTextLength)}"); writer?.WriteLine($"// {new string('-', maxNameLength)} {new string('-', regTextLength)} {new string('-', sizeTextLength)}"); foreach (ConstantInfo info in shaderInfo.Constants.OrderBy(c => c.RegisterSet).ThenBy(c => c.RegisterIndex)) { writer?.WriteLine($"// {info.Name.PadRight(maxNameLength)} {d3d9types.registerSets[info.RegisterSet]}{info.RegisterIndex.ToString().PadRight(regTextLength - 1)}" + $" {info.RegisterCount.ToString().PadLeft(sizeTextLength)}"); } writer?.WriteLine("//"); //writer?.WriteLine("END Constant Table"); } inStream.Seek(commentEnd, SeekOrigin.Begin); //writer?.WriteLine("End COMMENT"); writer?.WriteLine(); writer?.WriteLine($" {(shaderType == Frequency.Pixel ? "ps" : "vs")}_{major}_{minor}"); } else if (opcode == OpcodeType.D3DSIO_DCL) { uint declToken = inStream.ReadUInt32(); var declarationType = (D3DDECLUSAGE)declToken.bits(4, 0); var samplerTexType = (D3DSAMPLER_TEXTURE_TYPE)declToken.bits(30, 27); string suffix = ""; if (samplerTexType != D3DSAMPLER_TEXTURE_TYPE.D3DSTT_UNKNOWN) { suffix = d3d9types.samplerTexTypes[samplerTexType]; } else { suffix = d3d9types.declarationTypes[declarationType]; uint usageIndex = declToken.bits(19, 16); if (usageIndex != 0) { suffix += usageIndex; } uint destToken = inStream.ReadUInt32(); inStream.Seek(-4, SeekOrigin.Current); var declaration = new ParameterDeclaration(declarationType, (int)usageIndex, (D3DSHADER_PARAM_REGISTER_TYPE)(destToken.bits(30, 28) | (destToken.bits(12, 11) << 3)), (int)destToken.bits(10, 0), new WriteMask(destToken.bit(16), destToken.bit(17), destToken.bit(18), destToken.bit(19)), ((ResultModifiers)token.bits(23, 20)).HasFlag(ResultModifiers.Partial_Precision)); if (declaration.RegisterType == D3DSHADER_PARAM_REGISTER_TYPE.INPUT) { shaderInfo.InputDeclarations.Add(declaration); } else { shaderInfo.OutputDeclarations.Add(declaration); } } string destinationParameterTokenString = ReadDestinationParameterToken(inStream, shaderType); writer?.WriteLine($" dcl{suffix}{destinationParameterTokenString}"); } else { instructionCount++; uint instructionSize = token.bits(27, 24); bool isPredicated = token.bit(28); //todo: implement //writer?.WriteLine($"{d3d9types.opcodeNames[opcode]} (instruction size: {instructionSize})"); var parameters = new List <string>(); string line; void setLineStart() => line = $"{new string(' ', indent * 2)}{d3d9types.opcodeNames[opcode]}"; string appendComparison() { //todo: not sure about this, test switch (token.bits(23, 16)) { case 0: line += "_gt"; break; case 1: line += "_lt"; break; case 2: line += "_ge"; break; case 3: line += "_le"; break; case 4: line += "_eq"; break; case 5: line += "_ne"; break; } return(line); } setLineStart(); switch (opcode) { case OpcodeType.D3DSIO_NOP: case OpcodeType.D3DSIO_RET: case OpcodeType.D3DSIO_BREAK: break; case OpcodeType.D3DSIO_MOV: case OpcodeType.D3DSIO_RCP: case OpcodeType.D3DSIO_RSQ: case OpcodeType.D3DSIO_EXP: case OpcodeType.D3DSIO_LOG: case OpcodeType.D3DSIO_LIT: case OpcodeType.D3DSIO_FRC: case OpcodeType.D3DSIO_ABS: case OpcodeType.D3DSIO_NRM: case OpcodeType.D3DSIO_MOVA: case OpcodeType.D3DSIO_EXPP: case OpcodeType.D3DSIO_DSX: case OpcodeType.D3DSIO_DSY: parameters.Add(ReadDestinationParameterToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); break; case OpcodeType.D3DSIO_ADD: case OpcodeType.D3DSIO_SUB: case OpcodeType.D3DSIO_MUL: case OpcodeType.D3DSIO_DP3: case OpcodeType.D3DSIO_DP4: case OpcodeType.D3DSIO_MIN: case OpcodeType.D3DSIO_MAX: case OpcodeType.D3DSIO_SLT: case OpcodeType.D3DSIO_SGE: case OpcodeType.D3DSIO_DST: case OpcodeType.D3DSIO_M4x4: case OpcodeType.D3DSIO_M4x3: case OpcodeType.D3DSIO_M3x4: case OpcodeType.D3DSIO_M3x3: case OpcodeType.D3DSIO_M3x2: case OpcodeType.D3DSIO_POW: case OpcodeType.D3DSIO_CRS: case OpcodeType.D3DSIO_LOGP: case OpcodeType.D3DSIO_BEM: parameters.Add(ReadDestinationParameterToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); break; case OpcodeType.D3DSIO_MAD: case OpcodeType.D3DSIO_LRP: case OpcodeType.D3DSIO_SGN: case OpcodeType.D3DSIO_CND: case OpcodeType.D3DSIO_CMP: case OpcodeType.D3DSIO_DP2ADD: parameters.Add(ReadDestinationParameterToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); break; case OpcodeType.D3DSIO_CALL: parameters.Add(ReadLabelToken(inStream, shaderType)); break; case OpcodeType.D3DSIO_CALLNZ: parameters.Add(ReadLabelToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); break; case OpcodeType.D3DSIO_LOOP: parameters.Add("aL"); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); indent++; break; case OpcodeType.D3DSIO_REP: case OpcodeType.D3DSIO_IF: line += " "; parameters.Add(ReadSourceParameterToken(inStream, shaderType)); indent++; break; case OpcodeType.D3DSIO_IFC: line = appendComparison(); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); indent++; break; case OpcodeType.D3DSIO_ELSE: indent--; setLineStart(); indent++; break; case OpcodeType.D3DSIO_ENDREP: case OpcodeType.D3DSIO_ENDLOOP: case OpcodeType.D3DSIO_ENDIF: indent--; //these shouldn't be indented, so rewrite the opcode setLineStart(); break; case OpcodeType.D3DSIO_LABEL: case OpcodeType.D3DSIO_BREAKP: parameters.Add(ReadSourceParameterToken(inStream, shaderType)); break; case OpcodeType.D3DSIO_SINCOS: parameters.Add(ReadDestinationParameterToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); //unclear to me whether this has 2 or 4 parameters if (instructionSize == 4) { parameters.Add(ReadSourceParameterToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); } break; case OpcodeType.D3DSIO_BREAKC: line = appendComparison(); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); break; case OpcodeType.D3DSIO_SETP: line = appendComparison(); parameters.Add(ReadDestinationParameterToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); break; case OpcodeType.D3DSIO_DEF: parameters.Add(ReadDestinationParameterToken(inStream, shaderType)); parameters.Add($"{inStream.ReadFloat()}"); parameters.Add($"{inStream.ReadFloat()}"); parameters.Add($"{inStream.ReadFloat()}"); parameters.Add($"{inStream.ReadFloat()}"); instructionCount--; break; case OpcodeType.D3DSIO_DEFB: parameters.Add(ReadDestinationParameterToken(inStream, shaderType)); parameters.Add($"{inStream.ReadUInt32() > 0}"); instructionCount--; break; case OpcodeType.D3DSIO_DEFI: parameters.Add(ReadDestinationParameterToken(inStream, shaderType)); parameters.Add($"{inStream.ReadInt32()}"); parameters.Add($"{inStream.ReadInt32()}"); parameters.Add($"{inStream.ReadInt32()}"); parameters.Add($"{inStream.ReadInt32()}"); instructionCount--; break; case OpcodeType.D3DSIO_TEXKILL: parameters.Add(ReadDestinationParameterToken(inStream, shaderType)); break; case OpcodeType.D3DSIO_TEXLDD: parameters.Add(ReadDestinationParameterToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); texInstructionCount++; break; case OpcodeType.D3DSIO_TEX: case OpcodeType.D3DSIO_TEXM3x3SPEC: case OpcodeType.D3DSIO_TEXLDL: parameters.Add(ReadDestinationParameterToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); texInstructionCount++; break; case OpcodeType.D3DSIO_TEXBEM: case OpcodeType.D3DSIO_TEXBEML: case OpcodeType.D3DSIO_TEXREG2AR: case OpcodeType.D3DSIO_TEXREG2GB: case OpcodeType.D3DSIO_TEXM3x2PAD: case OpcodeType.D3DSIO_TEXM3x2TEX: case OpcodeType.D3DSIO_TEXM3x3PAD: case OpcodeType.D3DSIO_TEXM3x3TEX: case OpcodeType.D3DSIO_TEXM3x3VSPEC: case OpcodeType.D3DSIO_TEXREG2RGB: case OpcodeType.D3DSIO_TEXDP3TEX: case OpcodeType.D3DSIO_TEXM3x2DEPTH: case OpcodeType.D3DSIO_TEXDP3: case OpcodeType.D3DSIO_TEXM3x3: parameters.Add(ReadDestinationParameterToken(inStream, shaderType)); parameters.Add(ReadSourceParameterToken(inStream, shaderType)); texInstructionCount++; break; case OpcodeType.D3DSIO_TEXDEPTH: parameters.Add(ReadDestinationParameterToken(inStream, shaderType)); texInstructionCount++; break; default: for (; instructionSize > 0; instructionSize--) { inStream.ReadUInt32(); } break; } writer?.WriteLine($"{line}{string.Join(", ", parameters)}"); } } Console.WriteLine("No End Token found!"); return(null); }
/// <summary> /// Populate this instance from the given <see cref="Stream"/> as a binary <see cref="KeyValue"/>. /// </summary> /// <param name="input">The input <see cref="Stream"/> to read from.</param> /// <returns><c>true</c> if the read was successful; otherwise, <c>false</c>.</returns> public bool ReadAsBinary( Stream input ) { this.Children = new List<KeyValue>(); while ( true ) { var type = ( Type )input.ReadByte(); if ( type == Type.End ) { break; } var current = new KeyValue(); current.Name = input.ReadNullTermString( Encoding.UTF8 ); try { switch ( type ) { case Type.None: { current.ReadAsBinary( input ); break; } case Type.String: { current.Value = input.ReadNullTermString( Encoding.UTF8 ); break; } case Type.WideString: { throw new InvalidDataException( "wstring is unsupported" ); } case Type.Int32: case Type.Color: case Type.Pointer: { current.Value = Convert.ToString( input.ReadInt32() ); break; } case Type.UInt64: { current.Value = Convert.ToString( input.ReadUInt64() ); break; } case Type.Float32: { current.Value = Convert.ToString( input.ReadFloat() ); break; } default: { throw new InvalidDataException( "Unknown KV type encountered." ); } } } catch ( InvalidDataException ex ) { throw new InvalidDataException( string.Format( "An exception ocurred while reading KV '{0}'", current.Name ), ex ); } this.Children.Add( current ); } return input.Position == input.Length; }
void IMyStorageDataProvider.ReadFrom(ref MyOctreeStorage.ChunkHeader header, Stream stream, ref bool isOldFormat) { m_state.Version = stream.ReadUInt32(); if (m_state.Version != CURRENT_VERSION) { // Making sure this gets saved in new format and serialized cache holding old format is discarded. isOldFormat = true; } m_state.Generator = stream.ReadInt32(); m_state.Seed = stream.ReadInt32(); m_state.Size = stream.ReadFloat(); if (m_state.Version == VERSION_WITHOUT_PLANETS) { m_state.IsPlanet = 0; } else { m_state.IsPlanet = stream.ReadUInt32(); } if (m_state.IsPlanet != 0) { m_materialAttributes.ReadFrom(stream); m_shapeAttributes.ReadFrom(stream); m_hillAttributes.ReadFrom(stream); m_canyonAttributes.ReadFrom(stream); MyCompositeShapes.PlanetGenerators[m_state.Generator](ref m_shapeAttributes, ref m_hillAttributes, ref m_canyonAttributes, ref m_materialAttributes, out m_data); } else { MyCompositeShapes.AsteroidGenerators[m_state.Generator](m_state.Seed, m_state.Size, out m_data); } m_state.Version = CURRENT_VERSION; }
public static Quaternion ReadQuaternion(this Stream fs) { return(new Quaternion(fs.ReadFloat(), fs.ReadFloat(), fs.ReadFloat(), fs.ReadFloat())); }