public wnd1(EndianBinaryReader er)
: base(er)
{
long basepos = er.BaseStream.Position - 0x4C;
InflationLeft = er.ReadUInt16() / 16f;
InflationRight = er.ReadUInt16() / 16f;
InflationTop = er.ReadUInt16() / 16f;
InflationBottom = er.ReadUInt16() / 16f;
FrameSizeLeft = er.ReadUInt16();
FrameSizeRight = er.ReadUInt16();
FrameSizeTop = er.ReadUInt16();
FrameSizeBottom = er.ReadUInt16();
NrFrames = er.ReadByte();
byte tmp = er.ReadByte();
UseLTMaterial = (tmp & 1) == 1;
UseVtxColorForAllWindow = (tmp & 2) == 2;
Kind = (WindowKind)((tmp >> 2) & 3);
DontDrawContent = (tmp & 8) == 16;
Padding = er.ReadUInt16();
ContentOffset = er.ReadUInt32();
FrameOffsetTableOffset = er.ReadUInt32();
er.BaseStream.Position = basepos + ContentOffset;
Content = new WindowContent(er);
er.BaseStream.Position = basepos + FrameOffsetTableOffset;
WindowFrameOffsets = er.ReadUInt32s(NrFrames);
WindowFrames = new WindowFrame[NrFrames];
for (int i = 0; i < NrFrames; i++)
{
er.BaseStream.Position = basepos + WindowFrameOffsets[i];
WindowFrames[i] = new WindowFrame(er);
}
er.BaseStream.Position = basepos + SectionSize;
}
public pic1(EndianBinaryReader er)
: base(er)
{
VertexColorLT = er.ReadColor8();
VertexColorRT = er.ReadColor8();
VertexColorLB = er.ReadColor8();
VertexColorRB = er.ReadColor8();
MaterialId = er.ReadUInt16();
NrTexCoordEntries = er.ReadUInt16();
TexCoordEntries = new TexCoord[NrTexCoordEntries];
for (int i = 0; i < NrTexCoordEntries; i++)
{
TexCoordEntries[i] = new TexCoord(er);
}
}
override public void decode(EndianBinaryReader binReader)
{
actorId = binReader.ReadInt16();
m_byte = binReader.ReadSByte();
m_date = binReader.ReadDate();
m_float = binReader.ReadFloat();
testStruct = new sendLogin_testStructVO();
testStruct.decode(binReader);
var len_playerList = binReader.ReadUInt16();
playerList = new sendLogin_playerListVO[len_playerList];
for (int i = 0; i < len_playerList; i++)
{
playerList[i] = new sendLogin_playerListVO();
playerList[i].decode(binReader);
}
}
public txt1(EndianBinaryReader er)
: base(er)
{
long baseoffset = er.BaseStream.Position - 0x4C;
NrCharacters = er.ReadUInt16();
NrCharacters2 = er.ReadUInt16();
MaterialId = er.ReadUInt16();
FontId = er.ReadUInt16();
PositionType = er.ReadByte();
TextAlignment = er.ReadByte();
TextFlags = er.ReadByte();
Padding = er.ReadByte();
StringOffset = er.ReadUInt32();
TopColor = er.ReadColor8();
BottomColor = er.ReadColor8();
FontSize = er.ReadVector2();
CharSize = er.ReadSingle();
LineSize = er.ReadSingle();
er.BaseStream.Position = baseoffset + StringOffset;
Text = er.ReadStringNT(Encoding.Unicode);
er.BaseStream.Position = baseoffset + SectionSize;
}
public void decode(EndianBinaryReader binReader)
{
m_ushort = binReader.ReadUInt16();
m_int = binReader.ReadInt32();
m_uint = binReader.ReadUInt32();
m_Boolean = binReader.ReadBoolean();
m_Binary = binReader.ReadBytes(binReader.ReadInt32());
m_string = binReader.ReadUTF();
}
override public void decode(EndianBinaryReader binReader)
{
battleId = binReader.ReadInt16();
var len_damageList = binReader.ReadUInt16();
damageList = new CommonStructVO[len_damageList];
for (int i = 0; i < len_damageList; i++)
{
damageList[i] = new CommonStructVO();
damageList[i].decode(binReader);
}
}
/// <summary>
/// Load materials in stream.
/// </summary>
/// <param name="stream">Stream to use.</param>
/// <returns>Material definitions.</returns>
public static IEnumerable<NsbmdMaterial> ReadTex0(Stream stream, int blockoffset, out int ptexnum, out int ppalnum, out List<NSBMDTexture> texs, out List<NSBMDPalette> pals)
{
EndianBinaryReader reader = new EndianBinaryReader(stream, Endianness.LittleEndian);
UInt32 blocksize, blockptr, blocklimit;
int texnum;
UInt32 texdataoffset;
int texdatasize;
UInt32 sptexoffset; // for 4x4 compressed texels only
int sptexsize; // for 4x4 compressed texels only
UInt32 spdataoffset; // for 4x4 compressed texels only
int palnum;
UInt32 paldefoffset;
UInt32 paldataoffset;
int paldatasize;
NsbmdMaterial[] material = null;
int i, j;
texs = new List<NSBMDTexture>();
pals = new List<NSBMDPalette>();
blockptr = (uint)(blockoffset + 4); // already read the block ID, so skip 4 bytes
blocksize = reader.ReadUInt32(); // block size
blocklimit = (uint)(blocksize + blockoffset);
Console.WriteLine("DEBUG: blockoffset = {0}, blocksize = {1}", blockoffset, blocksize);
stream.Skip(4); // skip 4 padding 0s
texdatasize = reader.ReadUInt16() << 3; // total texture data size div8
stream.Skip(6); // skip 6 bytes
texdataoffset = (uint)(reader.ReadUInt32() + blockoffset);
stream.Skip(4); // skip 4 padding 0s
sptexsize = reader.ReadUInt16() << 3; // for format 5 4x4-texel, data size div8
stream.Skip(6); // skip 6 bytesmhm
sptexoffset = (uint)(reader.ReadUInt32() + blockoffset); // for format 5 4x4-texel, data offset
spdataoffset = (uint)(reader.ReadUInt32() + blockoffset); // for format 5 4x4-texel, palette info
stream.Skip(4); // skip 4 bytes
paldatasize = reader.ReadUInt16() << 3; // total palette data size div8
stream.Skip(2); // skip 2 bytes
paldefoffset = (uint)(reader.ReadUInt32() + blockoffset);
paldataoffset = (uint)(reader.ReadUInt32() + blockoffset);
// printf( "texdataoffset = %08x texdatasize = %08x\n", texdataoffset, texdatasize );
// printf( "sptexoffset = %08x sptexsize = %08x spdataoffset = %08x\n", sptexoffset, sptexsize, spdataoffset );
// printf( "paldataoffset = %08x paldatasize = %08x\n", paldataoffset, paldatasize );
////////////////////////////////////////////////
// texture definition
stream.Skip(1); // skip dummy '0'
texnum = reader.ReadByte(); // no of texture
blockptr = (uint)stream.Position;
stream.Seek(paldefoffset, SeekOrigin.Begin);
stream.Skip(1); // skip dummy '0'
palnum = reader.ReadByte(); // no of palette
stream.Seek(blockptr, SeekOrigin.Begin);
Console.WriteLine("texnum = {0}, palnum = {1}", texnum, palnum);
// allocate memory for material, great enough to hold all texture and palette
material = new NsbmdMaterial[(texnum > palnum ? texnum : palnum)];
for (i = 0; i < material.Length; i++)
material[i] = new NsbmdMaterial();
stream.Skip(14 + (texnum * 4)); // go straight to texture info
for (i = 0; i < texnum; i++)
{
UInt32 offset;
int param;
int format;
int width;
int height;
var mat = material[i];
offset = (uint)(reader.ReadUInt16() << 3);
param = reader.ReadUInt16(); // texture parameter
stream.Skip(4); // skip 4 bytes
format = (param >> 10) & 7; // format 0..7, see DSTek
width = 8 << ((param >> 4) & 7);
height = 8 << ((param >> 7) & 7);
mat.color0 = (param >> 13) & 1;
if (format == 5)
mat.texoffset = offset + sptexoffset; // 4x4-Texel Compressed Texture
else
mat.texoffset = offset + texdataoffset;
mat.format = format;
mat.width = width;
mat.height = height;
NSBMDTexture t = new NSBMDTexture();
t.format = format;
t.width = width;
t.height = height;
t.color0 = (param >> 13) & 1;
texs.Add(t);
}
////////////////////////////////////////////
// copy texture names
for (i = 0; i < texnum; i++)
{
material[i].texname = Utils.ReadNSBMDString(reader);
reader.BaseStream.Position -= 16;
texs[i].texname = Utils.ReadNSBMDString(reader);
}
////////////////////////////////////////////////
// calculate each texture's size
for (i = 0; i < texnum; i++)
{
int[] bpp = { 0, 8, 2, 4, 8, 2, 8, 16 };
var mat = material[i];
mat.texsize = (uint)(mat.width * mat.height * bpp[mat.format] / 8);
Console.WriteLine("tex {0} '{1}': offset = {2} size = {3} [W,H] = [{4}, {5}]",
i, mat.texname, mat.texoffset, mat.texsize, mat.width, mat.height);
texs[i].texsize = (uint)(mat.width * mat.height * bpp[mat.format] / 8);
}
////////////////////////////////////////////////
// palette definition
stream.Seek(paldefoffset + 2, SeekOrigin.Begin); // skip palnum, already read
stream.Seek(14 + (palnum * 4), SeekOrigin.Current); // go straight to palette info
for (i = 0; i < palnum; i++)
{
uint curOffset = (uint)((reader.ReadUInt16() << 3) + paldataoffset);
stream.Seek(2, SeekOrigin.Current); // skip 2 bytes
material[i].paloffset = curOffset;
NSBMDPalette t = new NSBMDPalette();
t.paloffset = curOffset;
pals.Add(t);
}
////////////////////////////////////////////////
// copy palette names
for (i = 0; i < palnum; i++)
{
var mat = material[i];
mat.palname = Utils.ReadNSBMDString(reader);
reader.BaseStream.Position -= 16;
pals[i].palname = Utils.ReadNSBMDString(reader);
}
////////////////////////////////////////////////
// calculate each palette's size
// assume the palettes are stored sequentially
/*for (i = 0; i < palnum - 1; i++)
{
int r;
var mat = material[i];
r = i;
try { while (material[r].paloffset == mat.paloffset) r++; }
catch { }
// below is RotA stupid way to calculate the size of palette: next's offset - current's offset
// it works most of the time
if (r != palnum)
{
mat.palsize = material[r].paloffset - mat.paloffset;
pals[i].palsize = material[r].paloffset - mat.paloffset;
}
else
{
mat.palsize = blocklimit - mat.paloffset;
pals[i].palsize = blocklimit - mat.paloffset;
}
//printf("pal '%s' size = %d\n", mat->palname, mat->palsize);
}
material[i].palsize = blocklimit - material[i].paloffset;
pals[i].palsize = blocklimit - material[i].paloffset;*/
List<int> offsets = new List<int>();
for (int k = 0; k < pals.Count; k++)
{
if (!offsets.Contains((int)pals[k].paloffset))
{
offsets.Add((int)pals[k].paloffset);
}
}
offsets.Add((int)blocklimit);
offsets.Sort();
for (int k = 0; k < pals.Count; k++)
{
int pallength;
int l = -1;
do
{
l++;
}
while (offsets[l] - pals[k].paloffset <= 0);//nsbtx.PalInfo.infoBlock.PalInfo[i + j].Palette_Offset - nsbtx.PalInfo.infoBlock.PalInfo[i].Palette_Offset == 0)
pallength = offsets[l] - (int)pals[k].paloffset;
//RGBA[] c_ = pals[k].paldata;
//List<RGBA> c = new List<RGBA>();
//c.AddRange(pals[k].paldata.Take(pallength / 2));
//pals[k].paldata = c.ToArray();
pals[k].palsize = (uint)pallength;
material[k].palsize = (uint)pallength;
}
////////////////////////////////////////////////
// traverse each texture
for (i = 0; i < texnum; i++)
{
var mat = material[i];
stream.Seek(mat.texoffset, SeekOrigin.Begin);
////////////////////////////////////////////////
// read texture into memory
byte[] by = reader.ReadBytes((int)mat.texsize);
mat.texdata = by;
texs[i].texdata = by;
Console.WriteLine("DEBUG: texoffset = {0}, texsize = {1}", mat.texoffset, mat.texsize);
////////////////////////////////////////////////
// additional data for format 5 4x4 compressed texels
if (mat.format == 5)
{
UInt32 r = mat.texsize / 2;//>> 1;
stream.Seek(spdataoffset + (mat.texoffset - sptexoffset) / 2, SeekOrigin.Begin);
by = reader.ReadBytes((int)r);
mat.spdata = by;
texs[i].spdata = by;
Console.WriteLine("DEBUG: 4x4-texel spdataoffset = {0}, spdatasize = {1}", spdataoffset, r);
//spdataoffset += r;
}
}
////////////////////////////////////////////////
// traverse each palette
for (i = 0; i < palnum; i++)
{
try
{
NsbmdMaterial mat = material[i];
var palentry = mat.palsize >> 1;
RGBA[] rgbq = new RGBA[palentry];
Console.WriteLine("DEBUG: converting pal '{0}', palentry = {1}", mat.palname, palentry);
stream.Seek(mat.paloffset, SeekOrigin.Begin);
for (j = 0; j < palentry; j++)
{
UInt16 p = reader.ReadUInt16();
rgbq[j].R = (byte)(((p >> 0) & 0x1f) << 3); // red
rgbq[j].G = (byte)(((p >> 5) & 0x1f) << 3); // green
rgbq[j].B = (byte)(((p >> 10) & 0x1f) << 3); // blue
//rgbq[j].RotA = (p&0x8000) ? 0xff : 0;
rgbq[j].A = (p & 0x8000) == 0 ? (byte)0xff : (byte)0;//0xff; // alpha
}
mat.paldata = rgbq;
pals[i].paldata = rgbq;
}
catch
{
}
}
ptexnum = texnum;
ppalnum = palnum;
return material;
}
public TexMap(EndianBinaryReader er)
{
TexIndex = er.ReadUInt16();
byte tmp = er.ReadByte();
WrapS = (WrapMode)(tmp & 3);
MinFilter = (FilterMode)((tmp >> 2) & 3);
tmp = er.ReadByte();
WrapT = (WrapMode)(tmp & 3);
MagFilter = (FilterMode)((tmp >> 2) & 3);
}
public TexCoordGen(EndianBinaryReader er)
{
Unknown1 = er.ReadByte();
Source = (TexCoordSource)er.ReadByte();
Unknown2 = er.ReadUInt16();
}
public Material(EndianBinaryReader er)
{
itemTag = er.ReadUInt16();
size = er.ReadUInt16();
diffAmb = er.ReadUInt32();
specEmi = er.ReadUInt32();
polyAttr = er.ReadUInt32();
polyAttrMask = er.ReadUInt32();
texImageParam = er.ReadUInt32();
texImageParamMask = er.ReadUInt32();
texPlttBase = er.ReadUInt16();
flag = (NNS_G3D_MATFLAG)er.ReadUInt16();
origWidth = er.ReadUInt16();
origHeight = er.ReadUInt16();
magW = er.ReadFx32();
magH = er.ReadFx32();
if ((flag & NNS_G3D_MATFLAG.NNS_G3D_MATFLAG_TEXMTX_SCALEONE) == 0)
{
scaleS = er.ReadFx32();
scaleT = er.ReadFx32();
}
if ((flag & NNS_G3D_MATFLAG.NNS_G3D_MATFLAG_TEXMTX_ROTZERO) == 0)
{
rotSin = er.ReadFx16();
rotCos = er.ReadFx16();
}
if ((flag & NNS_G3D_MATFLAG.NNS_G3D_MATFLAG_TEXMTX_TRANSZERO) == 0)
{
transS = er.ReadFx32();
transT = er.ReadFx32();
}
if ((flag & NNS_G3D_MATFLAG.NNS_G3D_MATFLAG_EFFECTMTX) == NNS_G3D_MATFLAG.NNS_G3D_MATFLAG_EFFECTMTX)
{
effectMtx = er.ReadFx32s(16);
}
}
public ModelInfo(EndianBinaryReader er)
{
sbcType = er.ReadByte();
scalingRule = er.ReadByte();
texMtxMode = er.ReadByte();
numNode = er.ReadByte();
numMat = er.ReadByte();
numShp = er.ReadByte();
firstUnusedMtxStackID = er.ReadByte();
er.ReadByte();//PADDING(1 byte);
posScale = er.ReadFx32();
invPosScale = er.ReadFx32();
numVertex = er.ReadUInt16();
numPolygon = er.ReadUInt16();
numTriangle = er.ReadUInt16();
numQuad = er.ReadUInt16();
boxX = er.ReadFx16();
boxY = er.ReadFx16();
boxZ = er.ReadFx16();
boxW = er.ReadFx16();
boxH = er.ReadFx16();
boxD = er.ReadFx16();
boxPosScale = er.ReadFx32();
boxInvPosScale = er.ReadFx32();
}
public DirectoryTableEntry(EndianBinaryReader er)
{
dirEntryStart = er.ReadUInt32();
dirEntryFileID = er.ReadUInt16();
dirParentID = er.ReadUInt16();
}
public MaterialSet(EndianBinaryReader er)
{
//er.SetMarkerOnCurrentOffset("MaterialSet");
long basepos = er.BaseStream.Position;
ofsDictTexToMatList = er.ReadUInt16();
ofsDictPlttToMatList = er.ReadUInt16();
dict = new Dictionary<MaterialSetData>(er);
long curpos = er.BaseStream.Position;
materials = new Material[dict.numEntry];
for (int i = 0; i < dict.numEntry; i++)
{
er.BaseStream.Position = dict[i].Value.Offset + basepos;//er.GetMarker("MaterialSet");
materials[i] = new Material(er);
}
er.BaseStream.Position = curpos;
dictTexToMatList = new Dictionary<TexToMatData>(er);
for (int i = 0; i < dictTexToMatList.numEntry; i++)
{
curpos = er.BaseStream.Position;
er.BaseStream.Position = dictTexToMatList[i].Value.Offset + basepos;
dictTexToMatList[i].Value.Materials = er.ReadBytes((int)dictTexToMatList[i].Value.NrMat);
er.BaseStream.Position = curpos;
}
dictPlttToMatList = new Dictionary<PlttToMatData>(er);
for (int i = 0; i < dictPlttToMatList.numEntry; i++)
{
curpos = er.BaseStream.Position;
er.BaseStream.Position = dictPlttToMatList[i].Value.Offset + basepos;
dictPlttToMatList[i].Value.Materials = er.ReadBytes((int)dictPlttToMatList[i].Value.NrMat);
er.BaseStream.Position = curpos;
}
while ((er.BaseStream.Position % 4) != 0) er.ReadByte();
//er.ReadBytes(4);//PADDING(4 bytes alignment);
}
public override void Read(EndianBinaryReader er)
{
offset = (uint)(er.ReadUInt16() << 3);
flag = er.ReadUInt16();
}
public texInfo(EndianBinaryReader er)
{
vramKey = er.ReadUInt32();
sizeTex = (UInt32)(er.ReadUInt16() << 3);
ofsDict = er.ReadUInt16();
flag = er.ReadUInt16();
er.ReadBytes(2);//PADDING(2 bytes);
ofsTex = er.ReadUInt32();
}
public Node(EndianBinaryReader er)
{
RefBit = er.ReadUInt32();
LeftIndex = er.ReadUInt16();
RightIndex = er.ReadUInt16();
NameOffset = er.ReadUInt32();
if (NameOffset != 0) NameOffset += (UInt32)er.BaseStream.Position - 4;
DataOffset = er.ReadUInt32();
if (DataOffset != 0) DataOffset += (UInt32)er.BaseStream.Position - 4;
if (NameOffset != 0)
{
long curpos = er.BaseStream.Position;
er.BaseStream.Position = NameOffset;
Name = er.ReadStringNT(Encoding.ASCII);
er.BaseStream.Position = curpos;
}
}
public EntryNameTableDirectoryEntry(EndianBinaryReader er)
: base(er)
{
entryName = er.ReadString(Encoding.ASCII, entryNameLength & 0x7F);
directoryID = er.ReadUInt16();
}
public WindowFrame(EndianBinaryReader er)
{
MaterialId = er.ReadUInt16();
TextureFlip = (TexFlip)er.ReadByte();
Padding = er.ReadByte();
}
/// <summary>
/// Parse single NSBMD object.
/// </summary>
private static void ParseNsbmdObject(EndianBinaryReader reader, NsbmdObject nsbmdObject, float modelscale)
{
UInt16 v = reader.ReadUInt16();
Int16 divide = reader.ReadInt16();
divide = (short)NsbmdGlRenderer.sign(divide, 16);
int unknown = v >> 12 & 0xf;
nsbmdObject.StackID = unknown;
//nsbmdObject.isBillboard = ((v >> 12 & 0xf) == 1?true:false);
float[] s = NsbmdGlRenderer.loadIdentity();
float[] r = NsbmdGlRenderer.loadIdentity();
float[] t = NsbmdGlRenderer.loadIdentity();
if ((v & 1) == 0)
{
nsbmdObject.Trans = true;
nsbmdObject.X = (float)reader.ReadInt32() / 4096f / modelscale;//(float)getdword(reader.ReadBytes(4)) / 4096f; //(float)(reader.ReadDouble() / 4096d);//.ReadUInt32() / 4096;
nsbmdObject.Y = (float)reader.ReadInt32() / 4096f / modelscale;//(float)getdword(reader.ReadBytes(4)) / 4096f;//(float)(reader.ReadDouble() / 4096d);
nsbmdObject.Z = (float)reader.ReadInt32() / 4096f / modelscale;//(float)getdword(reader.ReadBytes(4)) / 4096f;//(float)(reader.ReadDouble() / 4096d);
t = NsbmdGlRenderer.translate(t, nsbmdObject.X, nsbmdObject.Y, nsbmdObject.Z);
}
if ((v >> 3 & 0x1) == 0x1)
{
nsbmdObject.IsRotated = true;
float a = reader.ReadInt16();
a = NsbmdGlRenderer.sign((int)a, 16) / 4096f;
float b = reader.ReadInt16();
b = NsbmdGlRenderer.sign((int)b, 16) / 4096f;
nsbmdObject.Pivot = (int)(v >> 4) & 0x0f;
nsbmdObject.Neg = (int)(v >> 8) & 0x0f;
nsbmdObject.RotA = a;
nsbmdObject.RotB = b;
nsbmdObject.rotate_mtx = mtxPivot(new float[] { nsbmdObject.RotA, nsbmdObject.RotB }, nsbmdObject.Pivot, nsbmdObject.Neg);
r = NsbmdGlRenderer.multMatrix(r, nsbmdObject.rotate_mtx);
}
if ((v >> 1 & 1) == 0 && (v >> 3 & 1) == 0)
{
float[] a = new float[16];
a[0] = 1.0F;
a[5] = 1.0F;
a[10] = 1.0F;
a[15] = 1.0F;
float[] rotate = new float[8];
//msg = (new StringBuilder()).append(msg).append(" | R: ").toString();
for (int j = 0; j < rotate.Length; j++)
{
//dataParser _tmp4 = pa;
int value = NsbmdGlRenderer.sign(reader.ReadInt16(),16); //dataParser.getSign(data, offset + 4 + j * 2 + jump, 2);
rotate[j] = (float)value / 4096f;
//msg = (new StringBuilder()).append(msg).append(pad(Integer.valueOf(value), 4)).toString();
//if(j + 1 < rotate.length)
// msg = (new StringBuilder()).append(msg).append(", ").toString();
}
a[0] = (float)divide / 4096f;
a[1] = rotate[0];
a[2] = rotate[1];
a[4] = rotate[2];
a[5] = rotate[3];
a[6] = rotate[4];
a[8] = rotate[5];
a[9] = rotate[6];
a[10] = rotate[7];
nsbmdObject.rotate_mtx = a;
nsbmdObject.IsRotated = true;
r = NsbmdGlRenderer.multMatrix(r, nsbmdObject.rotate_mtx);
}
if ((v >> 2 & 1) == 0)
{
float[] scale = new float[3];
for (int j = 0; j < scale.Length; j++)
{
int value = reader.ReadInt32();
scale[j] = (float)value / 4096f;
}
nsbmdObject.scale = scale;
nsbmdObject.IsScaled = true;
s = NsbmdGlRenderer.scale(s, scale[0], scale[1], scale[2]);
}
nsbmdObject.materix = NsbmdGlRenderer.loadIdentity();
nsbmdObject.materix = NsbmdGlRenderer.multMatrix(nsbmdObject.materix, t);
nsbmdObject.materix = NsbmdGlRenderer.multMatrix(nsbmdObject.materix, r);
nsbmdObject.materix = NsbmdGlRenderer.multMatrix(nsbmdObject.materix, s);
}
/// <summary>
/// ReadMld0.
/// </summary>
private static NsbmdModel[] ReadMdl0(Stream stream, int blockoffset)
{
var reader = new EndianBinaryReader(stream, Endianness.LittleEndian);
int blocksize;
int blockptr;
int blocklimit;
byte num;
uint r;
List<NsbmdModel> model = new List<NsbmdModel>();
////////////////////////////////////////////////
// model
blockptr = blockoffset + 4; // already read the ID, skip 4 bytes
blocksize = reader.ReadInt32(); // block size
blocklimit = blocksize + blockoffset;
stream.Skip(1); // skip dummy '0'
num = reader.ReadByte(); // no of model
if (num <= 0)
throw new Exception();
for (var i = 0; i < num; ++i)
model.Add(new NsbmdModel());
var modelOffset = new UInt32[num];
stream.Skip(10 + 4 + (num * 4)); // skip [char xyz], useless, go straight to model data offset
blockptr += 10 + 4;
////////////////////////////////////////////////
// copy model dataoffset
for (var i = 0; i < num; i++)
modelOffset[i] = (uint)(reader.ReadUInt32() + blockoffset);
////////////////////////////////////////////////
// copy model names
for (var i = 0; i < num; i++)
model[i].Name = Utils.ReadNSBMDString(reader);
////////////////////////////////////////////////
// parse model data
uint totalsize_base = reader.ReadUInt32();
uint codeoffset_base = reader.ReadUInt32();
uint texpaloffset_base = reader.ReadUInt32();
uint polyoffset_base = reader.ReadUInt32();
uint polyend_base = reader.ReadUInt32();
stream.Skip(4);
uint matnum = reader.ReadByte(); // no. of material
uint polynum = reader.ReadByte(); // no. of polygon
byte laststack = reader.ReadByte();
byte unknown1m = reader.ReadByte();
float modelscale = (float)reader.ReadInt32() / 4096f;
float boundscale = (float)reader.ReadInt32();// / 4096f;
int vertexcount = reader.ReadInt16();
int surfacecount = reader.ReadInt16();
int trianglecount = reader.ReadInt16();
int quadcount = reader.ReadInt16();
model[0].laststackid = laststack;
model[0].modelScale = modelscale;
model[0].boundScale = boundscale;
model[0].boundXmin = (float)NsbmdGlRenderer.sign(reader.ReadInt16(), 16) / 4096f;
model[0].boundYmin = (float)NsbmdGlRenderer.sign(reader.ReadInt16(), 16) / 4096f;
model[0].boundZmin = (float)NsbmdGlRenderer.sign(reader.ReadInt16(), 16) / 4096f;
model[0].boundXmax = (float)NsbmdGlRenderer.sign(reader.ReadInt16(), 16) / 4096f;
model[0].boundYmax = (float)NsbmdGlRenderer.sign(reader.ReadInt16(), 16) / 4096f;
model[0].boundZmax = (float)NsbmdGlRenderer.sign(reader.ReadInt16(), 16) / 4096f;
var polyOffsets = new UInt32[polynum];
var polyDataSize = new UInt32[polynum];
for (var i = 0; i < 1; i++)
{
var mod = model[i];
stream.Seek(modelOffset[i], SeekOrigin.Begin);
// the following variables are all offset values
long totalsize;
uint codeoffset;
UInt32 texpaloffset;
UInt32 polyoffset;
long polyend;
long texoffset;
long paloffset;
uint modoffset = modelOffset[i];
totalsize = totalsize_base + modoffset;
codeoffset = codeoffset_base + modoffset;
// additional model data, bone definition etc., just follow NsbmdObject section
texpaloffset = texpaloffset_base + modoffset;
polyoffset = polyoffset_base + modoffset;
polyend = polyend_base + modoffset;
stream.Skip(5 * 4 + 4 + 2 + 38); // go straight to NsbmdObject
////////////////////////////////////////////////
// NsbmdObject section
UInt32 objnum;
int objdatabase;
UInt32[] objdataoffset;
UInt32[] objdatasize;
objdatabase = (int)stream.Position;
stream.Skip(1); // skip dummy '0'
objnum = reader.ReadByte(); // no of NsbmdObject
stream.Skip(14 + (objnum * 4)); // skip bytes, go striaght to NsbmdObject data offset
for (i = 0; i < objnum; ++i)
mod.Objects.Add(new NsbmdObject());
objdataoffset = new UInt32[objnum];
objdatasize = new UInt32[objnum];
for (var j = 0; j < objnum; j++)
objdataoffset[j] = (UInt32)(reader.ReadUInt32() + objdatabase);
for (var j = 0; j < objnum - 1; j++)
objdatasize[j] = objdataoffset[j + 1] - objdataoffset[j];
objdatasize[objnum - 1] = (UInt32)(codeoffset - objdataoffset[objnum - 1]);
////////////////////////////////////////////////
// copy NsbmdObject names
for (var j = 0; j < objnum; j++)
{
mod.Objects[j].Name = Utils.ReadNSBMDString(reader);
// TO DEBUG
Console.WriteLine(mod.Objects[j].Name);
}
////////////////////////////////////////////////
// parse NsbmdObject information
for (var j = 0; j < objnum; j++)
{
if (objdatasize[j] <= 4)
continue;
stream.Seek(objdataoffset[j], SeekOrigin.Begin);
ParseNsbmdObject(reader, mod.Objects[j], modelscale);
}
////////////////////////////////////////////////
// material section
stream.Seek(texpaloffset, SeekOrigin.Begin); // now get the texture and palette offset
texoffset = reader.ReadUInt16() + texpaloffset;
paloffset = reader.ReadUInt16() + texpaloffset;
// allocate memory for material
for (var j = 0; j <= matnum; j++)//i <= matnum; ++i)
mod.Materials.Add(new NsbmdMaterial());
////////////////////////////////////////////////
// parse material definition
// defines RotA material by pairing texture and palette
stream.Seek(16 + (matnum * 4), SeekOrigin.Current); // go straight to material data offset
for (var j = 0; j < matnum; j++) // TODO: BAD!
{
mod.Materials[j] = new NsbmdMaterial();
blockptr = (int)stream.Position;
r = reader.ReadUInt32() + texpaloffset/* + 4 + 12*/;// skip 18 bytes (+ 2 bytes for texoffset, 2 bytes for paloffset)
stream.Seek(r, SeekOrigin.Begin);
//mod.Materials[j].repeat = reader.ReadByte();
//reader.BaseStream.Position -= 1;
int dummy = reader.ReadInt16();
int sectionSize = reader.ReadInt16();
int unknown1 = reader.ReadInt32();//DifAmbColors
int unknown2 = reader.ReadInt32();//SpeEmiColors
int unknown3 = reader.ReadInt32();//PolyAttrib
int constant2 = reader.ReadInt32();//PolyAttrib Mask
int texVramOffset = reader.ReadInt16();
int texImageParam = reader.ReadInt16();
int constant3 = reader.ReadInt32();//texImageParam Mask
int constant4 = reader.ReadInt32();
int matWidth = reader.ReadInt16();
int matHeight = reader.ReadInt16();
int unknown4 = reader.ReadInt16();
int unknown5 = reader.ReadInt16();
int unknown6 = reader.ReadInt32();
//int unknown7 = reader.ReadInt32();//if srt S Scale
//int unknown8 = reader.ReadInt32();//if srt T Scale
//int unknown9 = reader.ReadInt16();//if srt & 60 Rot
//int unknownA = reader.ReadInt16();//if srt & 60 S Trans
//int unknownB = reader.ReadInt16();//if srt & 60 T Trans
//uint polyParam = reader.ReadUInt32();
//reader.ReadInt16();
//ushort texImageParam = reader.ReadUInt16();
mod.Materials[j].repeatS = texImageParam & 1;
mod.Materials[j].repeatT = texImageParam >> 1 & 1;
mod.Materials[j].flipS = texImageParam >> 2 & 1;
mod.Materials[j].flipT = texImageParam >> 3 & 1;
/*if ((texImageParam >> 14 & 0x03) == 1)
{
mod.Materials[j].scaleS = /*1 << /(texImageParam >> 12 & 2) + 1;
mod.Materials[j].scaleT = /*1 << /(texImageParam >> 14 & 2) + 1;
}
else
{
mod.Materials[j].scaleS = 1;
mod.Materials[j].scaleT = 1;
}*/
switch (texImageParam >> 14 & 0x03)
{
case 0:
mod.Materials[j].scaleS = 1;
mod.Materials[j].scaleT = 1;
mod.Materials[j].transS = 0;
mod.Materials[j].transT = 0;
break;
case 1:
{
int sscale = (int)reader.ReadInt32();// >> 0 & 0xFFFFFFFF;
sscale = NsbmdGlRenderer.sign(sscale, 32);
int tscale = (int)reader.ReadInt32();// >> 0 & 0xFFFFFFFF;
tscale = NsbmdGlRenderer.sign(tscale, 32);
//int strans = (int)unknown2 >> 0 & 0xFFFF;
//int ttrans = (int)unknown2 >> 16 & 0xFFFF;
mod.Materials[j].scaleS = (float)sscale / 4096f;
mod.Materials[j].scaleT = (float)tscale / 4096f;
if (sectionSize >= 60)
{
mod.Materials[j].rot = (float)reader.ReadInt16() / 4096f;
mod.Materials[j].transS = (float)reader.ReadInt16() / 4096f;
mod.Materials[j].transT = (float)reader.ReadInt16() / 4096f;
}
else
{
}
break;
}
case 2:
case 3:
mod.Materials[j].mtx = new float[16];
for (int k = 0; k < 16; k++)
{
mod.Materials[j].mtx[k] = reader.ReadInt32();
}
break;
default:
break;
// throw new Exception(String.Format("BMD: unsupported texture coord transform mode {0}", matgroup.m_TexParams >> 30));
}
mod.Materials[j].width = matWidth;
mod.Materials[j].height = matHeight;
int width = 8 << (texImageParam >> 4 & 7);
int height = 8 << (texImageParam >> 7 & 7);
//int m_DifAmbColors = reader.ReadInt32();
//int m_SpeEmiColors = reader.ReadInt32();
mod.Materials[j].DiffuseColor = SM64DSe.Helper.BGR15ToColor((ushort)(unknown1 & 0x7FFF));
mod.Materials[j].AmbientColor = SM64DSe.Helper.BGR15ToColor((ushort)(unknown1 >> 16 & 0x7FFF));
mod.Materials[j].SpecularColor = SM64DSe.Helper.BGR15ToColor((ushort)(unknown2 & 0x7FFF));
mod.Materials[j].EmissionColor = SM64DSe.Helper.BGR15ToColor((ushort)(unknown2 >> 16 & 0x7FFF));
int a = (int)((unknown3 >> 16) & 31);
mod.Materials[j].Alpha = a;//a * 2 + 1;//a * 2 + (a + 31) / 32;
mod.Materials[j].PolyAttrib = (uint)unknown3;
mod.Materials[j].diffuseColor = (unknown1 >> 15 & 1) == 1;
mod.Materials[j].shine = (unknown2 >> 15 & 1) == 1;
stream.Seek(blockptr + 4, SeekOrigin.Begin);
}
for (var j = 0; j < matnum; j++)
{
mod.Materials[j].MaterialName = Utils.ReadNSBMDString(reader);
}
////////////////////////////////////////////////
// now go to read the texture definition
stream.Seek(texoffset, SeekOrigin.Begin);
stream.Skip(1); // skip dummy '0'
int texnum = reader.ReadByte();
Debug.Assert(texnum <= matnum);
Console.WriteLine(String.Format("texnum: {0}", texnum));
if (texnum > 0)
{
stream.Seek(14 + (texnum * 4), SeekOrigin.Current); // go straight to data offsets
for (var j = 0; j < texnum; j++)
{
Int32 flags = reader.ReadInt32();
int numPairs = flags >> 16 & 0xf;
int dummy = flags >> 24 & 0xf;
blockptr = (int)stream.Position;
stream.Seek((flags & 0xffff) + texpaloffset, SeekOrigin.Begin);
NSBMDTexture t = new NSBMDTexture();
for (int k = 0; k < numPairs; k++)
{
uint texmatid = reader.ReadByte();
mod.tex_mat.Add((int)texmatid);
mod.Materials[j].texmatid.Add(texmatid);
t.texmatid.Add(texmatid);
}
mod.Textures.Add(t);
stream.Seek(blockptr, SeekOrigin.Begin);
}
for (var j = 0; j < texnum; j++) // copy texture names
{
NsbmdMaterial mat = mod.Materials[j];
mat.texname = Utils.ReadNSBMDString(reader);
reader.BaseStream.Position -= 16;
mod.Textures[j].texname = Utils.ReadNSBMDString(reader);
Console.WriteLine("tex (matid={0}): {1}", mat.texmatid, mat.texname);
}
}
////////////////////////////////////////////////
// now go to read the palette definition
stream.Seek(paloffset, SeekOrigin.Begin);
stream.Skip(1); // skip dummy '0'
int palnum = reader.ReadByte(); // no of palette definition
Debug.Assert(palnum <= matnum); // may not always hold?
Console.WriteLine("DEBUG: palnum = {0}", palnum);
if (palnum > 0)
{
stream.Seek(14 + (palnum * 4), SeekOrigin.Current); // go straight to data offsets
for (var j = 0; j < palnum; j++) // matching palette with material
{
Int32 flags = reader.ReadInt32();
int numPairs = flags >> 16 & 0xf;
int dummy = flags >> 24 & 0xf;
blockptr = (int)stream.Position;
stream.Seek((flags & 0xffff) + texpaloffset, SeekOrigin.Begin);
NSBMDPalette t = new NSBMDPalette();
for (int k = 0; k < numPairs; k++)
{
uint texmatid = reader.ReadByte();
mod.tex_mat.Add((int)texmatid);
mod.Materials[j].texmatid.Add(texmatid);
t.palmatid.Add(texmatid);
}
mod.Palettes.Add(t);
stream.Seek(blockptr, SeekOrigin.Begin);
}
for (var j = 0; j < palnum; j++) // copy palette names
{
int palmatid = (int)mod.Materials[j].palmatid;
mod.Materials[palmatid].palname = Utils.ReadNSBMDString(reader);
reader.BaseStream.Position -= 16;
mod.Palettes[j].palname = Utils.ReadNSBMDString(reader);
// TO DEBUG
Console.WriteLine("pal (matid={0}): {1}", palmatid, mod.Materials[palmatid].palname);
}
}
////////////////////////////////////////////////
// Polygon
stream.Seek(polyoffset, SeekOrigin.Begin);
stream.Skip(1); // skip dummy '0'
r = reader.ReadByte(); // no of polygon
Console.WriteLine("DEBUG: polynum = {0}", polynum);
for (var j = 0; j <= polynum; j++)
{
mod.Polygons.Add(new NsbmdPolygon());
}
stream.Skip(14 + (polynum * 4)); // skip bytes, go straight to data offset
for (var j = 0; j < polynum; j++)
polyOffsets[j] = reader.ReadUInt32() + polyoffset;
try
{
for (var j = 0; j < polynum; j++) // copy polygon names
{
mod.Polygons[j].Name = Utils.ReadNSBMDString(reader);
Console.WriteLine(mod.Polygons[j].Name);
}
}
catch { }
////////////////////////////////////////////////
// now go to the polygon data, there is RotA 16-byte-header before geometry commands
for (var j = 0; j < polynum; j++)
{
var poly = mod.Polygons[j];
//////////////////////////////////////////////////////////
poly.MatId = -1; // DEFAULT: indicate no associated material
//////////////////////////////////////////////////////////
//stream.Seek(polyOffsets[j] + 8, SeekOrigin.Begin); // skip 8 unknown bytes
short dummy = reader.ReadInt16();
short headerSize = reader.ReadInt16();
int unknown2 = reader.ReadInt32();
polyOffsets[j] += reader.ReadUInt32();
polyDataSize[j] = reader.ReadUInt32();
//printf( "poly %2d '%-16s': dataoffset: %08x datasize %08x\n", j, poly->polyname, poly->dataoffset, poly->datasize );
}
//}
////////////////////////////////////////////////
// read the polygon data into memory
for (var j = 0; j < polynum; j++)
{
var poly = mod.Polygons[j];
stream.Seek(polyOffsets[j], SeekOrigin.Begin);
poly.PolyData = reader.ReadBytes((int)polyDataSize[j]);
}
//}
////////////////////////////////////////////////
// decode the additional model data
DecodeCode(stream, codeoffset, texpaloffset, mod, laststack);
}
//modelnum = num;
return model.ToArray();
}
public plttInfo(EndianBinaryReader er)
{
vramKey = er.ReadUInt32();
sizePltt = (UInt32)(er.ReadUInt16() << 3);
flag = er.ReadUInt16();
ofsDict = er.ReadUInt16();
er.ReadBytes(2);//PADDING(2 bytes);
ofsPlttData = er.ReadUInt32();
}
public NodeData(EndianBinaryReader er)
{
flag = er.ReadUInt16();
_00 = er.ReadInt16();
if ((flag & NNS_G3D_SRTFLAG_TRANS_ZERO) == 0)
{
Tx = er.ReadFx32();
Ty = er.ReadFx32();
Tz = er.ReadFx32();
}
if ((flag & NNS_G3D_SRTFLAG_ROT_ZERO) == 0 &&
(flag & NNS_G3D_SRTFLAG_PIVOT_EXIST) == 0)
{
_01 = er.ReadFx16();
_02 = er.ReadFx16();
_10 = er.ReadFx16();
_11 = er.ReadFx16();
_12 = er.ReadFx16();
_20 = er.ReadFx16();
_21 = er.ReadFx16();
_22 = er.ReadFx16();
}
if ((flag & NNS_G3D_SRTFLAG_ROT_ZERO) == 0 &&
(flag & NNS_G3D_SRTFLAG_PIVOT_EXIST) != 0)
{
A = er.ReadFx16();
B = er.ReadFx16();
}
if ((flag & NNS_G3D_SRTFLAG_SCALE_ONE) == 0)
{
Sx = er.ReadFx32();
Sy = er.ReadFx32();
Sz = er.ReadFx32();
InvSx = er.ReadFx32();
InvSy = er.ReadFx32();
InvSz = er.ReadFx32();
}
}
public Shape(EndianBinaryReader er)
{
long pos = er.BaseStream.Position;
itemTag = er.ReadUInt16();
size = er.ReadUInt16();
flag = (NNS_G3D_SHPFLAG)er.ReadUInt32();
ofsDL = er.ReadUInt32();
sizeDL = er.ReadUInt32();
long curpos = er.BaseStream.Position;
er.BaseStream.Position = pos + ofsDL;
DL = er.ReadBytes((int)sizeDL);
er.BaseStream.Position = curpos;
}
public KCLOctreeNode(EndianBinaryReader er, long BaseOffset)
{
DataOffset = er.ReadUInt32();
IsLeaf = (DataOffset >> 31) == 1;
DataOffset &= 0x7FFFFFFF;
long curpos = er.BaseStream.Position;
er.BaseStream.Position = BaseOffset + DataOffset;
if (IsLeaf)
{
er.BaseStream.Position += 2;//Skip starting zero
List<ushort> tris = new List<ushort>();
while (true)
{
ushort v = er.ReadUInt16();
if (v == 0) break;
tris.Add((ushort)(v - 1));
}
Triangles = tris.ToArray();
}
else
{
SubNodes = new KCLOctreeNode[8];
for (int i = 0; i < 8; i++)
{
SubNodes[i] = new KCLOctreeNode(er, BaseOffset + DataOffset);
}
}
er.BaseStream.Position = curpos;
}
