public override void Initialize(int index, int id, int size, byte[] data,
Dictionary <int, WldFragment> fragments,
Dictionary <int, string> stringHash, ILogger logger)
{
base.Initialize(index, id, size, data, fragments, stringHash, logger);
var reader = new BinaryReader(new MemoryStream(data));
Name = stringHash[-reader.ReadInt32()];
SkeletonReferences = new List <SkeletonTrackReference>();
int flags = reader.ReadInt32();
int fragment1 = reader.ReadInt32();
int size1 = reader.ReadInt32();
int size2 = reader.ReadInt32();
int fragment2 = reader.ReadInt32();
var bitAnalyzer = new BitAnalyzer(flags);
if (bitAnalyzer.IsBitSet(0))
{
int params1 = reader.ReadInt32();
}
if (bitAnalyzer.IsBitSet(1))
{
reader.BaseStream.Position += 7 * sizeof(int);
}
// size 1 entries
for (int i = 0; i < size1; ++i)
{
int numOfDatapair = reader.ReadInt32();
for (int j = 0; j < numOfDatapair; ++j)
{
reader.ReadInt32();
reader.ReadSingle();
}
}
// references
for (int i = 0; i < size2; ++i)
{
if (size2 != 1)
{
}
int fragmentIndex = reader.ReadInt32();
var skeletonTrackReference = fragments[fragmentIndex - 1] as SkeletonTrackReference;
if (skeletonTrackReference != null)
{
SkeletonReferences.Add(skeletonTrackReference);
}
}
}
public override void Initialize(int index, int id, int size, byte[] data,
Dictionary <int, WldFragment> fragments,
Dictionary <int, string> stringHash, ILogger logger)
{
base.Initialize(index, id, size, data, fragments, stringHash, logger);
var reader = new BinaryReader(new MemoryStream(data));
Name = stringHash[-reader.ReadInt32()];
int flags = reader.ReadInt32();
bool params1 = false;
bool params2 = false;
bool size2frag3data3 = false;
var ba = new BitAnalyzer(flags);
if (ba.IsBitSet(0))
{
params1 = true;
}
if (ba.IsBitSet(1))
{
params2 = true;
}
//if (CheckBit(flags, 9))
//size2frag3data3 = true;
// number of track entries
int size1 = reader.ReadInt32();
//Log::get().write("Track entries: %i", size1);
// optional 0x18 polygon animation - gives bogus references
int fragment = reader.ReadInt32();
// params - [0, 1, 2] - no idea what they are for
if (params1)
{
reader.BaseStream.Position += (3 * sizeof(int));
}
if (params2)
{
reader.BaseStream.Position += (sizeof(float));
}
Skeleton = new List <SkeletonPieceData>();
SkeletonPieceDictionary = new Dictionary <string, SkeletonPieceData>();
// entries - bones
for (int i = 0; i < size1; ++i)
{
var piece = new SkeletonPieceData();
// Create the skeleton structure
// refers to this or another 0x10 fragment - confusing
int entryNameRef = reader.ReadInt32();
piece.Name = stringHash[-entryNameRef];
// usually 0
int entryFlags = reader.ReadInt32();
// reference to an 0x13
int entryFrag = reader.ReadInt32();
piece.AnimationTracks = new Dictionary <string, SkeletonPieceTrackReference>();
piece.AnimationTracks["default"] = fragments[entryFrag - 1] as SkeletonPieceTrackReference;
piece.AnimationTracks["default"].Assigned = true;
int entryFrag2 = reader.ReadInt32();
// Reference to a 0x2D
if (entryFrag2 != 0)
{
}
int entrySize = reader.ReadInt32();
List <int> moose = new List <int>();
for (int j = 0; j < entrySize; ++j)
{
int pieceIndex = reader.ReadInt32();
moose.Add(pieceIndex);
}
piece.ConnectedPieces = moose;
Skeleton.Add(piece);
if (piece.Name != "")
{
if (!SkeletonPieceDictionary.ContainsKey(piece.Name))
{
SkeletonPieceDictionary.Add(piece.Name, piece);
}
}
}
}
public override void Initialize(int index, int id, int size, byte[] data,
Dictionary <int, WldFragment> fragments,
Dictionary <int, string> stringHash, ILogger logger)
{
base.Initialize(index, id, size, data, fragments, stringHash, logger);
var reader = new BinaryReader(new MemoryStream(data));
// String reference
Name = stringHash[-reader.ReadInt32()];
// Flags?
int flags = reader.ReadInt32();
// Params
int parameters = reader.ReadInt32();
int params2 = reader.ReadInt32();
float params3a = reader.ReadSingle();
float params3b = reader.ReadSingle();
int reference6 = reader.ReadInt32();
if (reference6 != 0)
{
TextureInfoReference = fragments[reference6 - 1] as TextureInfoReference;
}
else
{
// Some materials are missing texture references
// This may correspond with the 'palette.bmp' texture that is often unused
// We consider them invisible
IsInvisible = true;
}
// The bits here determine what kind of shader this uses to render the material
var bitAnalyzer = new BitAnalyzer((int)parameters);
bool bit0 = bitAnalyzer.IsBitSet(0);
bool bit1 = bitAnalyzer.IsBitSet(1);
bool bit2 = bitAnalyzer.IsBitSet(2);
bool bit3 = bitAnalyzer.IsBitSet(3);
bool bit4 = bitAnalyzer.IsBitSet(4);
bool bit5 = bitAnalyzer.IsBitSet(5);
bool bit6 = bitAnalyzer.IsBitSet(6);
bool bit7 = bitAnalyzer.IsBitSet(7);
if (parameters == 0)
{
// Invisible texture (used for things like boundaries that are not rendered)
// All bits are 0
ShaderType = ShaderType.Invisible;
IsInvisible = true;
}
else if (parameters == TextureConstants.Diffuse)
{
// Diffuse - Fully opaque, used by most materials
ShaderType = ShaderType.Diffuse;
}
else if (parameters == TextureConstants.Transparent)
{
// Transparent - Materials that are partly transparent (e.g. water)
ShaderType = ShaderType.Transparent;
}
else if (parameters == TextureConstants.MaskedDiffuse)
{
// Masked - Opaque materials that have a color (top left) when rendering (e.g. tree leaves, rope)
ShaderType = ShaderType.MaskedDiffuse;
}
else if (parameters == TextureConstants.DiffusePassable)
{
ShaderType = ShaderType.Diffuse;
}
else if (parameters == TextureConstants.MaskedTransparentUnlit)
{
ShaderType = ShaderType.AlphaFromBrightness;
}
else if (parameters == TextureConstants.MaskedTransparentLit)
{
ShaderType = ShaderType.AlphaFromBrightness;
}
else if (parameters == TextureConstants.UnknownDiffuse)
{
ShaderType = ShaderType.Diffuse;
logger.LogError("Dump: " + parameters.ToString("X"));
}
else if (parameters == TextureConstants.UnknownDiffuse2)
{
ShaderType = ShaderType.Diffuse;
logger.LogError("Dump: " + parameters.ToString("X"));
}
else
{
// Unhandled - default to Diffuse
ShaderType = ShaderType.Diffuse;
logger.LogError("Unable to identify shader type for material: " + Name);
logger.LogError("Flag bit dump: " + bit0 + " " + bit1 + " " + bit2 + " " + bit3 + " " + bit4 + " " +
bit5 + " " + bit6 + " " + bit7);
logger.LogError("Param dump: " + parameters);
}
}
