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]);
}
}
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();
}
/// <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()));
}
