int32_t read(bx::ReaderI* _reader, VertexDecl& _decl, bx::Error* _err)
{
BX_ERROR_SCOPE(_err);
int32_t total = 0;
uint8_t numAttrs;
total += bx::read(_reader, numAttrs, _err);
uint16_t stride;
total += bx::read(_reader, stride, _err);
if (!_err->isOk() )
{
return total;
}
_decl.begin();
for (uint32_t ii = 0; ii < numAttrs; ++ii)
{
uint16_t offset;
total += bx::read(_reader, offset, _err);
uint16_t attribId = 0;
total += bx::read(_reader, attribId, _err);
uint8_t num;
total += bx::read(_reader, num, _err);
uint16_t attribTypeId;
total += bx::read(_reader, attribTypeId, _err);
bool normalized;
total += bx::read(_reader, normalized, _err);
bool asInt;
total += bx::read(_reader, asInt, _err);
if (!_err->isOk() )
{
return total;
}
Attrib::Enum attr = idToAttrib(attribId);
AttribType::Enum type = idToAttribType(attribTypeId);
if (Attrib::Count != attr
&& AttribType::Count != type)
{
_decl.add(attr, num, type, normalized, asInt);
_decl.m_offset[attr] = offset;
}
}
_decl.end();
_decl.m_stride = stride;
return total;
}
void Model_Sonic::evaluatePrimitive(Primitive &primitive) {
/* Create the actual IBO and VBO structures. */
if (primitive.invalid || primitive.indices.empty() || primitive.vertices.empty())
return;
// Create the index buffer
primitive.indexBuffer.setSize(primitive.indices.size(), sizeof(uint16), GL_UNSIGNED_SHORT);
uint16 *indices = (uint16 *) primitive.indexBuffer.getData();
memcpy(indices, &primitive.indices[0], primitive.indices.size() * sizeof(uint16));
// Create vertex buffer
VertexDecl vertexDecl;
vertexDecl.push_back(VertexAttrib(VPOSITION, 3, GL_FLOAT));
vertexDecl.push_back(VertexAttrib(VNORMAL , 3, GL_FLOAT));
vertexDecl.push_back(VertexAttrib(VCOLOR , 4, GL_FLOAT));
vertexDecl.push_back(VertexAttrib(VTCOORD , 2, GL_FLOAT));
primitive.vertexBuffer.setVertexDeclInterleave(primitive.vertices.size(), vertexDecl);
float *vData = (float *) primitive.vertexBuffer.getData();
for (PrimitiveVertices::const_iterator v = primitive.vertices.begin(); v != primitive.vertices.end(); ++v) {
/* To get the absolute position of the vertex, transform it by the absolute
* position of its base node. Use an identity matrix as a fallback. */
// TODO: For some primitives, we need to calculate the weighted average of several matrices
Common::TransformationMatrix matrix;
if (!v->nodes.empty() && v->nodes[0].node)
matrix = v->nodes[0].node->getAsolutePosition();
const Common::Vector3 pos = matrix * v->vertex;
*vData++ = pos[0];
*vData++ = pos[1];
*vData++ = pos[2];
*vData++ = v->normal[0];
*vData++ = v->normal[1];
*vData++ = v->normal[2];
*vData++ = v->color[0];
*vData++ = v->color[1];
*vData++ = v->color[2];
*vData++ = v->color[3];
*vData++ = v->texCoord[0];
*vData++ = v->texCoord[1];
}
}
int32_t write(bx::WriterI* _writer, const VertexDecl& _decl, bx::Error* _err)
{
BX_ERROR_SCOPE(_err);
int32_t total = 0;
uint8_t numAttrs = 0;
for (uint32_t attr = 0; attr < Attrib::Count; ++attr)
{
numAttrs += UINT16_MAX == _decl.m_attributes[attr] ? 0 : 1;
}
total += bx::write(_writer, numAttrs, _err);
total += bx::write(_writer, _decl.m_stride, _err);
for (uint32_t attr = 0; attr < Attrib::Count; ++attr)
{
if (UINT16_MAX != _decl.m_attributes[attr])
{
uint8_t num;
AttribType::Enum type;
bool normalized;
bool asInt;
_decl.decode(Attrib::Enum(attr), num, type, normalized, asInt);
total += bx::write(_writer, _decl.m_offset[attr], _err);
total += bx::write(_writer, s_attribToId[attr].id, _err);
total += bx::write(_writer, num, _err);
total += bx::write(_writer, s_attribTypeToId[type].id, _err);
total += bx::write(_writer, normalized, _err);
total += bx::write(_writer, asInt, _err);
}
}
return total;
}
void dump(const VertexDecl& _decl)
{
if (BX_ENABLED(BGFX_CONFIG_DEBUG) )
{
dbgPrintf("vertexdecl %08x (%08x), stride %d\n"
, _decl.m_hash
, bx::hashMurmur2A(_decl.m_attributes)
, _decl.m_stride
);
for (uint32_t attr = 0; attr < Attrib::Count; ++attr)
{
if (UINT16_MAX != _decl.m_attributes[attr])
{
uint8_t num;
AttribType::Enum type;
bool normalized;
bool asInt;
_decl.decode(Attrib::Enum(attr), num, type, normalized, asInt);
dbgPrintf("\tattr %d - %s, num %d, type %d, norm %d, asint %d, offset %d\n"
, attr
, getAttribName(Attrib::Enum(attr) )
, num
, type
, normalized
, asInt
, _decl.m_offset[attr]
);
}
}
}
}
int32_t write(bx::WriterI* _writer, const VertexDecl& _decl)
{
int32_t total = 0;
uint8_t numAttrs = 0;
for (uint32_t attr = 0; attr < Attrib::Count; ++attr)
{
numAttrs += 0xff == _decl.m_attributes[attr] ? 0 : 1;
}
total += bx::write(_writer, numAttrs);
total += bx::write(_writer, _decl.m_stride);
for (uint32_t attr = 0; attr < Attrib::Count; ++attr)
{
if (0xff != _decl.m_attributes[attr])
{
uint8_t num;
AttribType::Enum type;
bool normalized;
bool asInt;
_decl.decode(Attrib::Enum(attr), num, type, normalized, asInt);
total += bx::write(_writer, _decl.m_offset[attr]);
total += bx::write(_writer, s_attribToId[attr].id);
total += bx::write(_writer, num);
total += bx::write(_writer, s_attribTypeToId[type].id);
total += bx::write(_writer, normalized);
total += bx::write(_writer, asInt);
}
}
return total;
}
int32_t read(bx::ReaderI* _reader, VertexDecl& _decl)
{
int32_t total = 0;
uint8_t numAttrs;
total += bx::read(_reader, numAttrs);
uint16_t stride;
total += bx::read(_reader, stride);
_decl.begin();
for (uint32_t ii = 0; ii < numAttrs; ++ii)
{
uint16_t offset;
total += bx::read(_reader, offset);
uint16_t attribId = 0;
total += bx::read(_reader, attribId);
uint8_t num;
total += bx::read(_reader, num);
uint16_t attribTypeId;
total += bx::read(_reader, attribTypeId);
bool normalized;
total += bx::read(_reader, normalized);
bool asInt;
total += bx::read(_reader, asInt);
Attrib::Enum attr = idToAttrib(attribId);
AttribType::Enum type = idToAttribType(attribTypeId);
if (Attrib::Count != attr
&& AttribType::Count != type)
{
_decl.add(attr, num, type, normalized, asInt);
_decl.m_offset[attr] = offset;
}
}
_decl.end();
_decl.m_stride = stride;
return total;
}
void ModelNode_Witcher::readTexturePaint(Model_Witcher::ParserContext &ctx) {
uint32 layersOffset, layersCount;
Model::readArrayDef(*ctx.mdb, layersOffset, layersCount);
ctx.mdb->skip(28); // Unknown
uint32 offMeshArrays = ctx.mdb->readUint32LE();
uint32 sectorID0 = ctx.mdb->readUint32LE();
uint32 sectorID1 = ctx.mdb->readUint32LE();
uint32 sectorID2 = ctx.mdb->readUint32LE();
uint32 sectorID3 = ctx.mdb->readUint32LE();
float boundingMin[3], boundingMax[3];
boundingMin[0] = ctx.mdb->readIEEEFloatLE();
boundingMin[1] = ctx.mdb->readIEEEFloatLE();
boundingMin[2] = ctx.mdb->readIEEEFloatLE();
boundingMax[0] = ctx.mdb->readIEEEFloatLE();
boundingMax[1] = ctx.mdb->readIEEEFloatLE();
boundingMax[2] = ctx.mdb->readIEEEFloatLE();
_diffuse[0] = ctx.mdb->readIEEEFloatLE();
_diffuse[1] = ctx.mdb->readIEEEFloatLE();
_diffuse[2] = ctx.mdb->readIEEEFloatLE();
_ambient[0] = ctx.mdb->readIEEEFloatLE();
_ambient[1] = ctx.mdb->readIEEEFloatLE();
_ambient[2] = ctx.mdb->readIEEEFloatLE();
float textureTransRot[3];
textureTransRot[0] = ctx.mdb->readIEEEFloatLE();
textureTransRot[1] = ctx.mdb->readIEEEFloatLE();
textureTransRot[2] = ctx.mdb->readIEEEFloatLE();
_shadow = ctx.mdb->readUint32LE() == 1;
_render = ctx.mdb->readUint32LE() == 1;
bool tileFade = ctx.mdb->readUint32LE() == 1;
bool controlFade = ctx.mdb->readByte() == 1;
bool lightMapped = ctx.mdb->readByte() == 1;
bool rotateTexture = ctx.mdb->readByte() == 1;
ctx.mdb->skip(1); // Unknown
float transparencyShift = ctx.mdb->readIEEEFloatLE();
uint32 defaultRenderList = ctx.mdb->readUint32LE();
uint32 fourCC = ctx.mdb->readUint32BE();
ctx.mdb->skip(4); // Unknown
float depthOffset = ctx.mdb->readIEEEFloatLE();
uint32 blendGroup = ctx.mdb->readUint32LE();
bool dayNightLightMaps = ctx.mdb->readByte() == 1;
Common::UString dayNightTransition = Common::readStringFixed(*ctx.mdb, Common::kEncodingASCII, 200);
bool ignoreHitCheck = ctx.mdb->readByte() == 1;
bool needsReflection = ctx.mdb->readByte() == 1;
ctx.mdb->skip(1); // Unknown
float reflectionPlaneNormal[3];
reflectionPlaneNormal[0] = ctx.mdb->readIEEEFloatLE();
reflectionPlaneNormal[1] = ctx.mdb->readIEEEFloatLE();
reflectionPlaneNormal[2] = ctx.mdb->readIEEEFloatLE();
float reflectionPlaneDistance = ctx.mdb->readIEEEFloatLE();
bool fadeOnCameraCollision = ctx.mdb->readByte() == 1;
bool noSelfShadow = ctx.mdb->readByte() == 1;
bool isReflected = ctx.mdb->readByte() == 1;
ctx.mdb->skip(1); // Unknown
float detailMapScape = ctx.mdb->readIEEEFloatLE();
bool onlyReflected = ctx.mdb->readByte() == 1;
Common::UString lightMapName = Common::readStringFixed(*ctx.mdb, Common::kEncodingASCII, 64);
bool canDecal = ctx.mdb->readByte() == 1;
bool ignoreLODReflection = ctx.mdb->readByte() == 1;
bool enableSpecular = ctx.mdb->readByte() == 1;
uint32 endPos = ctx.mdb->seek(ctx.offRawData + offMeshArrays);
ctx.mdb->skip(4);
uint32 vertexOffset, vertexCount;
Model::readArrayDef(*ctx.mdb, vertexOffset, vertexCount);
uint32 normalsOffset, normalsCount;
Model::readArrayDef(*ctx.mdb, normalsOffset, normalsCount);
uint32 tangentsOffset, tangentsCount;
Model::readArrayDef(*ctx.mdb, tangentsOffset, tangentsCount);
uint32 biNormalsOffset, biNormalsCount;
Model::readArrayDef(*ctx.mdb, biNormalsOffset, biNormalsCount);
uint32 tVertsOffset[4], tVertsCount[4];
for (uint t = 0; t < 4; t++)
Model::readArrayDef(*ctx.mdb, tVertsOffset[t], tVertsCount[t]);
uint32 unknownOffset, unknownCount;
Model::readArrayDef(*ctx.mdb, unknownOffset, unknownCount);
uint32 facesOffset, facesCount;
Model::readArrayDef(*ctx.mdb, facesOffset, facesCount);
if ((vertexCount == 0) || (facesCount == 0)) {
ctx.mdb->seek(endPos);
return;
}
std::vector<TexturePaintLayer> layers;
layers.resize(layersCount);
for (uint32 l = 0; l < layersCount; l++) {
ctx.mdb->seek(ctx.offRawData + layersOffset + l * 52);
layers[l].hasTexture = ctx.mdb->readByte() == 1;
if (!layers[l].hasTexture)
continue;
ctx.mdb->skip(3); // Unknown
ctx.mdb->skip(4); // Offset to material
layers[l].texture = Common::readStringFixed(*ctx.mdb, Common::kEncodingASCII, 32);
uint32 weightsOffset, weightsCount;
Model::readArrayDef(*ctx.mdb, weightsOffset, weightsCount);
ctx.mdb->seek(ctx.offRawData + weightsOffset);
layers[l].weights.resize(weightsCount);
for (std::vector<float>::iterator w = layers[l].weights.begin(); w != layers[l].weights.end(); ++w)
*w = ctx.mdb->readIEEEFloatLE();
}
std::vector<Common::UString> textures;
textures.push_back(lightMapName);
evaluateTextures(1, textures, 0, tVertsCount, dayNightLightMaps, lightMapName);
loadTextures(textures);
size_t texCount = textures.size();
// Read vertices
VertexDecl vertexDecl;
vertexDecl.push_back(VertexAttrib(VPOSITION, 3, GL_FLOAT));
vertexDecl.push_back(VertexAttrib(VNORMAL , 3, GL_FLOAT));
for (uint t = 0; t < texCount; t++)
vertexDecl.push_back(VertexAttrib(VTCOORD + t, 2, GL_FLOAT));
_vertexBuffer.setVertexDeclLinear(vertexCount, vertexDecl);
// Read vertex position
ctx.mdb->seek(ctx.offRawData + vertexOffset);
float *v = reinterpret_cast<float *>(_vertexBuffer.getData(0));
for (uint32 i = 0; i < vertexCount; i++) {
*v++ = ctx.mdb->readIEEEFloatLE();
*v++ = ctx.mdb->readIEEEFloatLE();
*v++ = ctx.mdb->readIEEEFloatLE();
}
// Read vertex normals
assert(normalsCount == vertexCount);
ctx.mdb->seek(ctx.offRawData + normalsOffset);
v = reinterpret_cast<float *>(_vertexBuffer.getData(1));
for (uint32 i = 0; i < normalsCount; i++) {
*v++ = ctx.mdb->readIEEEFloatLE();
*v++ = ctx.mdb->readIEEEFloatLE();
*v++ = ctx.mdb->readIEEEFloatLE();
}
// Read texture coordinates
for (uint t = 0; t < texCount; t++) {
ctx.mdb->seek(ctx.offRawData + tVertsOffset[t]);
v = reinterpret_cast<float *>(_vertexBuffer.getData(2 + t));
for (uint32 i = 0; i < tVertsCount[t]; i++) {
if (i < tVertsCount[t]) {
*v++ = ctx.mdb->readIEEEFloatLE();
*v++ = ctx.mdb->readIEEEFloatLE();
} else {
*v++ = 0.0f;
*v++ = 0.0f;
}
}
}
// Read faces
_indexBuffer.setSize(facesCount * 3, sizeof(uint32), GL_UNSIGNED_INT);
ctx.mdb->seek(ctx.offRawData + facesOffset);
uint32 *f = reinterpret_cast<uint32 *>(_indexBuffer.getData());
for (uint32 i = 0; i < facesCount; i++) {
// Vertex indices
*f++ = ctx.mdb->readUint32LE();
*f++ = ctx.mdb->readUint32LE();
*f++ = ctx.mdb->readUint32LE();
ctx.mdb->skip(68); // Unknown
}
createBound();
ctx.mdb->seek(endPos);
}
void ModelNode_Witcher::readMesh(Model_Witcher::ParserContext &ctx) {
ctx.mdb->skip(4); // Function pointer
ctx.mdb->skip(4); // Unknown
uint32 offMeshArrays = ctx.mdb->readUint32LE();
ctx.mdb->skip(4); // Unknown
float boundingMin[3], boundingMax[3];
boundingMin[0] = ctx.mdb->readIEEEFloatLE();
boundingMin[1] = ctx.mdb->readIEEEFloatLE();
boundingMin[2] = ctx.mdb->readIEEEFloatLE();
boundingMax[0] = ctx.mdb->readIEEEFloatLE();
boundingMax[1] = ctx.mdb->readIEEEFloatLE();
boundingMax[2] = ctx.mdb->readIEEEFloatLE();
ctx.mdb->skip(28); // Unknown
float volFogScale = ctx.mdb->readIEEEFloatLE();
ctx.mdb->skip(16); // Unknown
_diffuse[0] = ctx.mdb->readIEEEFloatLE();
_diffuse[1] = ctx.mdb->readIEEEFloatLE();
_diffuse[2] = ctx.mdb->readIEEEFloatLE();
_ambient[0] = ctx.mdb->readIEEEFloatLE();
_ambient[1] = ctx.mdb->readIEEEFloatLE();
_ambient[2] = ctx.mdb->readIEEEFloatLE();
float textureTransRot[3];
textureTransRot[0] = ctx.mdb->readIEEEFloatLE();
textureTransRot[1] = ctx.mdb->readIEEEFloatLE();
textureTransRot[2] = ctx.mdb->readIEEEFloatLE();
_shininess = ctx.mdb->readIEEEFloatLE();
_shadow = ctx.mdb->readUint32LE() == 1;
_beaming = ctx.mdb->readUint32LE() == 1;
_render = ctx.mdb->readUint32LE() == 1;
_hasTransparencyHint = true;
_transparencyHint = ctx.mdb->readUint32LE() == 1;
ctx.mdb->skip(4); // Unknown
Common::UString texture[4];
for (int t = 0; t < 4; t++) {
texture[t] = Common::readStringFixed(*ctx.mdb, Common::kEncodingASCII, 64);
if (texture[t] == "NULL")
texture[t].clear();
}
bool tileFade = ctx.mdb->readUint32LE() == 1;
bool controlFade = ctx.mdb->readByte() == 1;
bool lightMapped = ctx.mdb->readByte() == 1;
bool rotateTexture = ctx.mdb->readByte() == 1;
ctx.mdb->skip(1); // Unknown
float transparencyShift = ctx.mdb->readIEEEFloatLE();
uint32 defaultRenderList = ctx.mdb->readUint32LE();
uint32 preserveVColors = ctx.mdb->readUint32LE();
uint32 fourCC = ctx.mdb->readUint32BE();
ctx.mdb->skip(4); // Unknown
float depthOffset = ctx.mdb->readIEEEFloatLE();
float coronaCenterMult = ctx.mdb->readIEEEFloatLE();
float fadeStartDistance = ctx.mdb->readIEEEFloatLE();
bool distFromScreenCenterFace = ctx.mdb->readByte() == 1;
ctx.mdb->skip(3); // Unknown
float enlargeStartDistance = ctx.mdb->readIEEEFloatLE();
bool affectedByWind = ctx.mdb->readByte() == 1;
ctx.mdb->skip(3); // Unknown
float dampFactor = ctx.mdb->readIEEEFloatLE();
uint32 blendGroup = ctx.mdb->readUint32LE();
bool dayNightLightMaps = ctx.mdb->readByte() == 1;
Common::UString dayNightTransition = Common::readStringFixed(*ctx.mdb, Common::kEncodingASCII, 200);
bool ignoreHitCheck = ctx.mdb->readByte() == 1;
bool needsReflection = ctx.mdb->readByte() == 1;
ctx.mdb->skip(1); // Unknown
float reflectionPlaneNormal[3];
reflectionPlaneNormal[0] = ctx.mdb->readIEEEFloatLE();
reflectionPlaneNormal[1] = ctx.mdb->readIEEEFloatLE();
reflectionPlaneNormal[2] = ctx.mdb->readIEEEFloatLE();
float reflectionPlaneDistance = ctx.mdb->readIEEEFloatLE();
bool fadeOnCameraCollision = ctx.mdb->readByte() == 1;
bool noSelfShadow = ctx.mdb->readByte() == 1;
bool isReflected = ctx.mdb->readByte() == 1;
bool onlyReflected = ctx.mdb->readByte() == 1;
Common::UString lightMapName = Common::readStringFixed(*ctx.mdb, Common::kEncodingASCII, 64);
bool canDecal = ctx.mdb->readByte() == 1;
bool multiBillBoard = ctx.mdb->readByte() == 1;
bool ignoreLODReflection = ctx.mdb->readByte() == 1;
ctx.mdb->skip(1); // Unknown
float detailMapScape = ctx.mdb->readIEEEFloatLE();
ctx.offTextureInfo = ctx.mdb->readUint32LE();
uint32 endPos = ctx.mdb->seek(ctx.offRawData + offMeshArrays);
ctx.mdb->skip(4);
uint32 vertexOffset, vertexCount;
Model::readArrayDef(*ctx.mdb, vertexOffset, vertexCount);
uint32 normalsOffset, normalsCount;
Model::readArrayDef(*ctx.mdb, normalsOffset, normalsCount);
uint32 tangentsOffset, tangentsCount;
Model::readArrayDef(*ctx.mdb, tangentsOffset, tangentsCount);
uint32 biNormalsOffset, biNormalsCount;
Model::readArrayDef(*ctx.mdb, biNormalsOffset, biNormalsCount);
uint32 tVertsOffset[4], tVertsCount[4];
for (uint t = 0; t < 4; t++)
Model::readArrayDef(*ctx.mdb, tVertsOffset[t], tVertsCount[t]);
uint32 unknownOffset, unknownCount;
Model::readArrayDef(*ctx.mdb, unknownOffset, unknownCount);
uint32 facesOffset, facesCount;
Model::readArrayDef(*ctx.mdb, facesOffset, facesCount);
if (ctx.fileVersion == 133)
ctx.offTexData = ctx.mdb->readUint32LE();
if ((vertexCount == 0) || (facesCount == 0)) {
ctx.mdb->seek(endPos);
return;
}
std::vector<Common::UString> textures;
readTextures(ctx, textures);
evaluateTextures(4, textures, texture, tVertsCount, dayNightLightMaps, lightMapName);
loadTextures(textures);
size_t texCount = textures.size();
// Read vertices
VertexDecl vertexDecl;
vertexDecl.push_back(VertexAttrib(VPOSITION, 3, GL_FLOAT));
vertexDecl.push_back(VertexAttrib(VNORMAL , 3, GL_FLOAT));
for (uint t = 0; t < texCount; t++)
vertexDecl.push_back(VertexAttrib(VTCOORD + t, 2, GL_FLOAT));
_vertexBuffer.setVertexDeclLinear(vertexCount, vertexDecl);
// Read vertex position
ctx.mdb->seek(ctx.offRawData + vertexOffset);
float *v = reinterpret_cast<float *>(_vertexBuffer.getData(0));
for (uint32 i = 0; i < vertexCount; i++) {
*v++ = ctx.mdb->readIEEEFloatLE();
*v++ = ctx.mdb->readIEEEFloatLE();
*v++ = ctx.mdb->readIEEEFloatLE();
}
// Read vertex normals
assert(normalsCount == vertexCount);
ctx.mdb->seek(ctx.offRawData + normalsOffset);
v = reinterpret_cast<float *>(_vertexBuffer.getData(1));
for (uint32 i = 0; i < normalsCount; i++) {
*v++ = ctx.mdb->readIEEEFloatLE();
*v++ = ctx.mdb->readIEEEFloatLE();
*v++ = ctx.mdb->readIEEEFloatLE();
}
// Read texture coordinates
for (uint t = 0; t < texCount; t++) {
ctx.mdb->seek(ctx.offRawData + tVertsOffset[t]);
v = reinterpret_cast<float *>(_vertexBuffer.getData(2 + t));
for (uint32 i = 0; i < tVertsCount[t]; i++) {
if (i < tVertsCount[t]) {
*v++ = ctx.mdb->readIEEEFloatLE();
*v++ = ctx.mdb->readIEEEFloatLE();
} else {
*v++ = 0.0f;
*v++ = 0.0f;
}
}
}
// Read faces
_indexBuffer.setSize(facesCount * 3, sizeof(uint32), GL_UNSIGNED_INT);
ctx.mdb->seek(ctx.offRawData + facesOffset);
uint32 *f = reinterpret_cast<uint32 *>(_indexBuffer.getData());
for (uint32 i = 0; i < facesCount; i++) {
ctx.mdb->skip(4 * 4 + 4);
if (ctx.fileVersion == 133)
ctx.mdb->skip(3 * 4);
// Vertex indices
*f++ = ctx.mdb->readUint32LE();
*f++ = ctx.mdb->readUint32LE();
*f++ = ctx.mdb->readUint32LE();
if (ctx.fileVersion == 133)
ctx.mdb->skip(4);
}
createBound();
ctx.mdb->seek(endPos);
}
void vertexUnpack(float _output[4], Attrib::Enum _attr, const VertexDecl& _decl, const void* _data, uint32_t _index)
{
if (!_decl.has(_attr) )
{
bx::memSet(_output, 0, 4*sizeof(float) );
return;
}
uint32_t stride = _decl.getStride();
uint8_t* data = (uint8_t*)_data + _index*stride + _decl.getOffset(_attr);
uint8_t num;
AttribType::Enum type;
bool normalized;
bool asInt;
_decl.decode(_attr, num, type, normalized, asInt);
switch (type)
{
default:
case AttribType::Uint8:
{
uint8_t* packed = (uint8_t*)data;
if (asInt)
{
switch (num)
{
default: *_output++ = (float(*packed++) - 128.0f)*1.0f/127.0f; BX_FALLTHROUGH;
case 3: *_output++ = (float(*packed++) - 128.0f)*1.0f/127.0f; BX_FALLTHROUGH;
case 2: *_output++ = (float(*packed++) - 128.0f)*1.0f/127.0f; BX_FALLTHROUGH;
case 1: *_output++ = (float(*packed++) - 128.0f)*1.0f/127.0f;
}
}
else
{
switch (num)
{
default: *_output++ = float(*packed++)*1.0f/255.0f; BX_FALLTHROUGH;
case 3: *_output++ = float(*packed++)*1.0f/255.0f; BX_FALLTHROUGH;
case 2: *_output++ = float(*packed++)*1.0f/255.0f; BX_FALLTHROUGH;
case 1: *_output++ = float(*packed++)*1.0f/255.0f;
}
}
}
break;
case AttribType::Uint10:
{
uint32_t packed = *(uint32_t*)data;
if (asInt)
{
switch (num)
{
default: BX_FALLTHROUGH;
case 3: *_output++ = (float(packed & 0x3ff) - 512.0f)*1.0f/511.0f; packed >>= 10; BX_FALLTHROUGH;
case 2: *_output++ = (float(packed & 0x3ff) - 512.0f)*1.0f/511.0f; packed >>= 10; BX_FALLTHROUGH;
case 1: *_output++ = (float(packed & 0x3ff) - 512.0f)*1.0f/511.0f;
}
}
else
{
switch (num)
{
default: BX_FALLTHROUGH;
case 3: *_output++ = float(packed & 0x3ff)*1.0f/1023.0f; packed >>= 10; BX_FALLTHROUGH;
case 2: *_output++ = float(packed & 0x3ff)*1.0f/1023.0f; packed >>= 10; BX_FALLTHROUGH;
case 1: *_output++ = float(packed & 0x3ff)*1.0f/1023.0f;
}
}
}
break;
case AttribType::Int16:
{
int16_t* packed = (int16_t*)data;
if (asInt)
{
switch (num)
{
default: *_output++ = float(*packed++)*1.0f/32767.0f; BX_FALLTHROUGH;
case 3: *_output++ = float(*packed++)*1.0f/32767.0f; BX_FALLTHROUGH;
case 2: *_output++ = float(*packed++)*1.0f/32767.0f; BX_FALLTHROUGH;
case 1: *_output++ = float(*packed++)*1.0f/32767.0f;
}
}
else
{
switch (num)
{
default: *_output++ = (float(*packed++) + 32768.0f)*1.0f/65535.0f; BX_FALLTHROUGH;
case 3: *_output++ = (float(*packed++) + 32768.0f)*1.0f/65535.0f; BX_FALLTHROUGH;
case 2: *_output++ = (float(*packed++) + 32768.0f)*1.0f/65535.0f; BX_FALLTHROUGH;
case 1: *_output++ = (float(*packed++) + 32768.0f)*1.0f/65535.0f;
}
}
}
break;
case AttribType::Half:
{
uint16_t* packed = (uint16_t*)data;
switch (num)
{
default: *_output++ = bx::halfToFloat(*packed++); BX_FALLTHROUGH;
case 3: *_output++ = bx::halfToFloat(*packed++); BX_FALLTHROUGH;
case 2: *_output++ = bx::halfToFloat(*packed++); BX_FALLTHROUGH;
case 1: *_output++ = bx::halfToFloat(*packed++);
}
}
break;
case AttribType::Float:
bx::memCopy(_output, data, num*sizeof(float) );
_output += num;
break;
}
void vertexPack(const float _input[4], bool _inputNormalized, Attrib::Enum _attr, const VertexDecl& _decl, void* _data, uint32_t _index)
{
if (!_decl.has(_attr) )
{
return;
}
uint32_t stride = _decl.getStride();
uint8_t* data = (uint8_t*)_data + _index*stride + _decl.getOffset(_attr);
uint8_t num;
AttribType::Enum type;
bool normalized;
bool asInt;
_decl.decode(_attr, num, type, normalized, asInt);
switch (type)
{
default:
case AttribType::Uint8:
{
uint8_t* packed = (uint8_t*)data;
if (_inputNormalized)
{
if (asInt)
{
switch (num)
{
default: *packed++ = uint8_t(*_input++ * 127.0f + 128.0f); BX_FALLTHROUGH;
case 3: *packed++ = uint8_t(*_input++ * 127.0f + 128.0f); BX_FALLTHROUGH;
case 2: *packed++ = uint8_t(*_input++ * 127.0f + 128.0f); BX_FALLTHROUGH;
case 1: *packed++ = uint8_t(*_input++ * 127.0f + 128.0f);
}
}
else
{
switch (num)
{
default: *packed++ = uint8_t(*_input++ * 255.0f); BX_FALLTHROUGH;
case 3: *packed++ = uint8_t(*_input++ * 255.0f); BX_FALLTHROUGH;
case 2: *packed++ = uint8_t(*_input++ * 255.0f); BX_FALLTHROUGH;
case 1: *packed++ = uint8_t(*_input++ * 255.0f);
}
}
}
else
{
switch (num)
{
default: *packed++ = uint8_t(*_input++); BX_FALLTHROUGH;
case 3: *packed++ = uint8_t(*_input++); BX_FALLTHROUGH;
case 2: *packed++ = uint8_t(*_input++); BX_FALLTHROUGH;
case 1: *packed++ = uint8_t(*_input++);
}
}
}
break;
case AttribType::Uint10:
{
uint32_t packed = 0;
if (_inputNormalized)
{
if (asInt)
{
switch (num)
{
default: BX_FALLTHROUGH;
case 3: packed |= uint32_t(*_input++ * 511.0f + 512.0f); BX_FALLTHROUGH;
case 2: packed <<= 10; packed |= uint32_t(*_input++ * 511.0f + 512.0f); BX_FALLTHROUGH;
case 1: packed <<= 10; packed |= uint32_t(*_input++ * 511.0f + 512.0f);
}
}
else
{
switch (num)
{
default: BX_FALLTHROUGH;
case 3: packed |= uint32_t(*_input++ * 1023.0f); BX_FALLTHROUGH;
case 2: packed <<= 10; packed |= uint32_t(*_input++ * 1023.0f); BX_FALLTHROUGH;
case 1: packed <<= 10; packed |= uint32_t(*_input++ * 1023.0f);
}
}
}
else
{
switch (num)
{
default: BX_FALLTHROUGH;
case 3: packed |= uint32_t(*_input++); BX_FALLTHROUGH;
case 2: packed <<= 10; packed |= uint32_t(*_input++); BX_FALLTHROUGH;
case 1: packed <<= 10; packed |= uint32_t(*_input++);
}
}
*(uint32_t*)data = packed;
}
break;
case AttribType::Int16:
{
int16_t* packed = (int16_t*)data;
if (_inputNormalized)
{
if (asInt)
{
switch (num)
{
default: *packed++ = int16_t(*_input++ * 32767.0f); BX_FALLTHROUGH;
case 3: *packed++ = int16_t(*_input++ * 32767.0f); BX_FALLTHROUGH;
case 2: *packed++ = int16_t(*_input++ * 32767.0f); BX_FALLTHROUGH;
case 1: *packed++ = int16_t(*_input++ * 32767.0f);
}
}
else
{
switch (num)
{
default: *packed++ = int16_t(*_input++ * 65535.0f - 32768.0f); BX_FALLTHROUGH;
case 3: *packed++ = int16_t(*_input++ * 65535.0f - 32768.0f); BX_FALLTHROUGH;
case 2: *packed++ = int16_t(*_input++ * 65535.0f - 32768.0f); BX_FALLTHROUGH;
case 1: *packed++ = int16_t(*_input++ * 65535.0f - 32768.0f);
}
}
}
else
{
switch (num)
{
default: *packed++ = int16_t(*_input++); BX_FALLTHROUGH;
case 3: *packed++ = int16_t(*_input++); BX_FALLTHROUGH;
case 2: *packed++ = int16_t(*_input++); BX_FALLTHROUGH;
case 1: *packed++ = int16_t(*_input++);
}
}
}
break;
case AttribType::Half:
{
uint16_t* packed = (uint16_t*)data;
switch (num)
{
default: *packed++ = bx::halfFromFloat(*_input++); BX_FALLTHROUGH;
case 3: *packed++ = bx::halfFromFloat(*_input++); BX_FALLTHROUGH;
case 2: *packed++ = bx::halfFromFloat(*_input++); BX_FALLTHROUGH;
case 1: *packed++ = bx::halfFromFloat(*_input++);
}
}
break;
case AttribType::Float:
bx::memCopy(data, _input, num*sizeof(float) );
break;
}
}
void ModelNode_KotOR::readMesh(Model_KotOR::ParserContext &ctx) {
uint32 P = ctx.mdl->pos();
ctx.mdl->skip(8); // Function pointers
uint32 facesOffset, facesCount;
Model::readArrayDef(*ctx.mdl, facesOffset, facesCount);
float boundingMin[3], boundingMax[3];
boundingMin[0] = ctx.mdl->readIEEEFloatLE();
boundingMin[1] = ctx.mdl->readIEEEFloatLE();
boundingMin[2] = ctx.mdl->readIEEEFloatLE();
boundingMax[0] = ctx.mdl->readIEEEFloatLE();
boundingMax[1] = ctx.mdl->readIEEEFloatLE();
boundingMax[2] = ctx.mdl->readIEEEFloatLE();
float radius = ctx.mdl->readIEEEFloatLE();
float pointsAverage[3];
pointsAverage[0] = ctx.mdl->readIEEEFloatLE();
pointsAverage[1] = ctx.mdl->readIEEEFloatLE();
pointsAverage[2] = ctx.mdl->readIEEEFloatLE();
_diffuse[0] = ctx.mdl->readIEEEFloatLE();
_diffuse[1] = ctx.mdl->readIEEEFloatLE();
_diffuse[2] = ctx.mdl->readIEEEFloatLE();
_ambient[0] = ctx.mdl->readIEEEFloatLE();
_ambient[1] = ctx.mdl->readIEEEFloatLE();
_ambient[2] = ctx.mdl->readIEEEFloatLE();
_specular[0] = 0;
_specular[1] = 0;
_specular[2] = 0;
uint32 transparencyHint = ctx.mdl->readUint32LE();
_hasTransparencyHint = true;
_transparencyHint = (transparencyHint != 0);
std::vector<Common::UString> textures;
textures.push_back(Common::readStringFixed(*ctx.mdl, Common::kEncodingASCII, 32));
textures.push_back(Common::readStringFixed(*ctx.mdl, Common::kEncodingASCII, 32));
ctx.mdl->skip(24); // Unknown
ctx.mdl->skip(12); // Vertex indices counts
uint32 offOffVerts, offOffVertsCount;
Model::readArrayDef(*ctx.mdl, offOffVerts, offOffVertsCount);
if (offOffVertsCount > 1)
throw Common::Exception("Face offsets offsets count wrong (%d)", offOffVertsCount);
ctx.mdl->skip(12); // Unknown
ctx.mdl->skip(24 + 16); // Unknown
uint32 mdxStructSize = ctx.mdl->readUint32LE();
ctx.mdl->skip(8); // Unknown
uint32 offNormals = ctx.mdl->readUint32LE();
ctx.mdl->skip(4); // Unknown
uint32 offUV[2];
offUV[0] = ctx.mdl->readUint32LE();
offUV[1] = ctx.mdl->readUint32LE();
ctx.mdl->skip(24); // Unknown
uint16 vertexCount = ctx.mdl->readUint16LE();
uint16 textureCount = ctx.mdl->readUint16LE();
ctx.mdl->skip(2);
byte unknownFlag1 = ctx.mdl->readByte();
_shadow = ctx.mdl->readByte() == 1;
byte unknownFlag2 = ctx.mdl->readByte();
_render = ctx.mdl->readByte() == 1;
ctx.mdl->skip(10);
if (ctx.kotor2)
ctx.mdl->skip(8);
uint32 offNodeData = ctx.mdl->readUint32LE();
ctx.mdl->skip(4);
if ((offOffVertsCount < 1) || (vertexCount == 0) || (facesCount == 0))
return;
uint32 endPos = ctx.mdl->pos();
if (textureCount > 2) {
warning("Model_KotOR::readMesh(): textureCount > 2 (%d)", textureCount);
textureCount = 2;
}
if ((textureCount > 0) && !ctx.texture.empty())
textures[0] = ctx.texture;
textures.resize(textureCount);
loadTextures(textures);
// Read vertices (interleaved)
GLsizei vpsize = 3;
GLsizei vnsize = 3;
GLsizei vtsize = 2;
uint32 vertexSize = (vpsize + vnsize + vtsize * textureCount) * sizeof(float);
_vertexBuffer.setSize(vertexCount, vertexSize);
float *vertexData = (float *) _vertexBuffer.getData();
VertexDecl vertexDecl;
VertexAttrib vp;
vp.index = VPOSITION;
vp.size = vpsize;
vp.type = GL_FLOAT;
vp.stride = vertexSize;
vp.pointer = vertexData;
vertexDecl.push_back(vp);
VertexAttrib vn;
vn.index = VNORMAL;
vn.size = vnsize;
vn.type = GL_FLOAT;
vn.stride = vertexSize;
vn.pointer = vertexData + vpsize;
vertexDecl.push_back(vn);
for (uint16 t = 0; t < textureCount; t++) {
VertexAttrib vt;
vt.index = VTCOORD + t;
vt.size = vtsize;
vt.type = GL_FLOAT;
vt.stride = vertexSize;
vt.pointer = vertexData + vpsize + vnsize + vtsize * t;
vertexDecl.push_back(vt);
}
_vertexBuffer.setVertexDecl(vertexDecl);
float *v = vertexData;
for (uint32 i = 0; i < vertexCount; i++) {
// Position
ctx.mdx->seekTo(offNodeData + i * mdxStructSize);
*v++ = ctx.mdx->readIEEEFloatLE();
*v++ = ctx.mdx->readIEEEFloatLE();
*v++ = ctx.mdx->readIEEEFloatLE();
// Normal
//ctx.mdx->seekTo(offNodeData + i * mdxStructSize + offNormals);
*v++ = ctx.mdx->readIEEEFloatLE();
*v++ = ctx.mdx->readIEEEFloatLE();
*v++ = ctx.mdx->readIEEEFloatLE();
// TexCoords
for (uint16 t = 0; t < textureCount; t++) {
if (offUV[t] != 0xFFFFFFFF) {
ctx.mdx->seekTo(offNodeData + i * mdxStructSize + offUV[t]);
*v++ = ctx.mdx->readIEEEFloatLE();
*v++ = ctx.mdx->readIEEEFloatLE();
} else {
*v++ = 0.0;
*v++ = 0.0;
}
}
}
// Read faces
ctx.mdl->seekTo(ctx.offModelData + offOffVerts);
uint32 offVerts = ctx.mdl->readUint32LE();
ctx.mdl->seekTo(ctx.offModelData + offVerts);
_indexBuffer.setSize(facesCount * 3, sizeof(uint16), GL_UNSIGNED_SHORT);
uint16 *f = (uint16 *) _indexBuffer.getData();
for (uint32 i = 0; i < facesCount * 3; i++)
f[i] = ctx.mdl->readUint16LE();
createBound();
ctx.mdl->seekTo(endPos);
}
void vertexConvert(const VertexDecl& _destDecl, void* _destData, const VertexDecl& _srcDecl, const void* _srcData, uint32_t _num)
{
if (_destDecl.m_hash == _srcDecl.m_hash)
{
memcpy(_destData, _srcData, _srcDecl.getSize(_num) );
return;
}
struct ConvertOp
{
enum Enum
{
Set,
Copy,
Convert,
};
Attrib::Enum attr;
Enum op;
uint32_t src;
uint32_t dest;
uint32_t size;
};
ConvertOp convertOp[Attrib::Count];
uint32_t numOps = 0;
for (uint32_t ii = 0; ii < Attrib::Count; ++ii)
{
Attrib::Enum attr = (Attrib::Enum)ii;
if (_destDecl.has(attr) )
{
ConvertOp& cop = convertOp[numOps];
cop.attr = attr;
cop.dest = _destDecl.getOffset(attr);
uint8_t num;
AttribType::Enum type;
bool normalized;
bool asInt;
_destDecl.decode(attr, num, type, normalized, asInt);
cop.size = (*s_attribTypeSize[0])[type][num-1];
if (_srcDecl.has(attr) )
{
cop.src = _srcDecl.getOffset(attr);
cop.op = _destDecl.m_attributes[attr] == _srcDecl.m_attributes[attr] ? ConvertOp::Copy : ConvertOp::Convert;
}
else
{
cop.op = ConvertOp::Set;
}
++numOps;
}
}
if (0 < numOps)
{
const uint8_t* src = (const uint8_t*)_srcData;
uint32_t srcStride = _srcDecl.getStride();
uint8_t* dest = (uint8_t*)_destData;
uint32_t destStride = _destDecl.getStride();
float unpacked[4];
for (uint32_t ii = 0; ii < _num; ++ii)
{
for (uint32_t jj = 0; jj < numOps; ++jj)
{
const ConvertOp& cop = convertOp[jj];
switch (cop.op)
{
case ConvertOp::Set:
memset(dest + cop.dest, 0, cop.size);
break;
case ConvertOp::Copy:
memcpy(dest + cop.dest, src + cop.src, cop.size);
break;
case ConvertOp::Convert:
vertexUnpack(unpacked, cop.attr, _srcDecl, src);
vertexPack(unpacked, true, cop.attr, _destDecl, dest);
break;
}
}
src += srcStride;
dest += destStride;
}
}
}
void ModelNode_KotOR::readMesh(Model_KotOR::ParserContext &ctx) {
size_t P = ctx.mdl->pos();
ctx.mdl->skip(8); // Function pointers
uint32 facesOffset, facesCount;
Model::readArrayDef(*ctx.mdl, facesOffset, facesCount);
float boundingMin[3], boundingMax[3];
boundingMin[0] = ctx.mdl->readIEEEFloatLE();
boundingMin[1] = ctx.mdl->readIEEEFloatLE();
boundingMin[2] = ctx.mdl->readIEEEFloatLE();
boundingMax[0] = ctx.mdl->readIEEEFloatLE();
boundingMax[1] = ctx.mdl->readIEEEFloatLE();
boundingMax[2] = ctx.mdl->readIEEEFloatLE();
float radius = ctx.mdl->readIEEEFloatLE();
float pointsAverage[3];
pointsAverage[0] = ctx.mdl->readIEEEFloatLE();
pointsAverage[1] = ctx.mdl->readIEEEFloatLE();
pointsAverage[2] = ctx.mdl->readIEEEFloatLE();
_mesh = new Mesh();
_mesh->diffuse[0] = ctx.mdl->readIEEEFloatLE();
_mesh->diffuse[1] = ctx.mdl->readIEEEFloatLE();
_mesh->diffuse[2] = ctx.mdl->readIEEEFloatLE();
_mesh->ambient[0] = ctx.mdl->readIEEEFloatLE();
_mesh->ambient[1] = ctx.mdl->readIEEEFloatLE();
_mesh->ambient[2] = ctx.mdl->readIEEEFloatLE();
_mesh->specular[0] = 0;
_mesh->specular[1] = 0;
_mesh->specular[2] = 0;
uint32 transparencyHint = ctx.mdl->readUint32LE();
_mesh->hasTransparencyHint = true;
_mesh->transparencyHint = (transparencyHint != 0);
std::vector<Common::UString> textures;
textures.push_back(Common::readStringFixed(*ctx.mdl, Common::kEncodingASCII, 32));
textures.push_back(Common::readStringFixed(*ctx.mdl, Common::kEncodingASCII, 32));
ctx.mdl->skip(24); // Unknown
ctx.mdl->skip(12); // Vertex indices counts
uint32 offOffVerts, offOffVertsCount;
Model::readArrayDef(*ctx.mdl, offOffVerts, offOffVertsCount);
if (offOffVertsCount > 1)
throw Common::Exception("Face offsets offsets count wrong (%d)", offOffVertsCount);
ctx.mdl->skip(12); // Unknown
ctx.mdl->skip(24 + 16); // Unknown
uint32 mdxStructSize = ctx.mdl->readUint32LE();
ctx.mdl->skip(8); // Unknown
uint32 offNormals = ctx.mdl->readUint32LE();
ctx.mdl->skip(4); // Unknown
uint32 offUV[2];
offUV[0] = ctx.mdl->readUint32LE();
offUV[1] = ctx.mdl->readUint32LE();
ctx.mdl->skip(24); // Unknown
uint16 vertexCount = ctx.mdl->readUint16LE();
uint16 textureCount = ctx.mdl->readUint16LE();
ctx.mdl->skip(2);
byte unknownFlag1 = ctx.mdl->readByte();
_mesh->shadow = ctx.mdl->readByte() == 1;
byte unknownFlag2 = ctx.mdl->readByte();
_mesh->render = ctx.mdl->readByte() == 1;
ctx.mdl->skip(10);
if (ctx.kotor2)
ctx.mdl->skip(8);
uint32 offNodeData = ctx.mdl->readUint32LE();
ctx.mdl->skip(4);
if ((offOffVertsCount < 1) || (vertexCount == 0) || (facesCount == 0))
return;
_render = _mesh->render;
_mesh->data = new MeshData();
_mesh->data->envMapMode = kModeEnvironmentBlendedOver;
uint32 endPos = ctx.mdl->pos();
if (textureCount > 2) {
warning("Model_KotOR::readMesh(): textureCount > 2 (%d)", textureCount);
textureCount = 2;
}
if ((textureCount > 0) && !ctx.texture.empty())
textures[0] = ctx.texture;
textures.resize(textureCount);
loadTextures(textures);
// Read vertices (interleaved)
VertexDecl vertexDecl;
vertexDecl.push_back(VertexAttrib(VPOSITION, 3, GL_FLOAT));
vertexDecl.push_back(VertexAttrib(VNORMAL , 3, GL_FLOAT));
for (uint t = 0; t < textureCount; t++)
vertexDecl.push_back(VertexAttrib(VTCOORD + t , 2, GL_FLOAT));
_mesh->data->vertexBuffer.setVertexDeclInterleave(vertexCount, vertexDecl);
float *v = reinterpret_cast<float *>(_mesh->data->vertexBuffer.getData());
for (uint32 i = 0; i < vertexCount; i++) {
// Position
ctx.mdx->seek(offNodeData + i * mdxStructSize);
*v++ = ctx.mdx->readIEEEFloatLE();
*v++ = ctx.mdx->readIEEEFloatLE();
*v++ = ctx.mdx->readIEEEFloatLE();
// Normal
//ctx.mdx->seek(offNodeData + i * mdxStructSize + offNormals);
*v++ = ctx.mdx->readIEEEFloatLE();
*v++ = ctx.mdx->readIEEEFloatLE();
*v++ = ctx.mdx->readIEEEFloatLE();
// TexCoords
for (uint16 t = 0; t < textureCount; t++) {
if (offUV[t] != 0xFFFFFFFF) {
ctx.mdx->seek(offNodeData + i * mdxStructSize + offUV[t]);
*v++ = ctx.mdx->readIEEEFloatLE();
*v++ = ctx.mdx->readIEEEFloatLE();
} else {
*v++ = 0.0f;
*v++ = 0.0f;
}
}
}
// Read faces
ctx.mdl->seek(ctx.offModelData + offOffVerts);
uint32 offVerts = ctx.mdl->readUint32LE();
ctx.mdl->seek(ctx.offModelData + offVerts);
_mesh->data->indexBuffer.setSize(facesCount * 3, sizeof(uint16), GL_UNSIGNED_SHORT);
uint16 *f = reinterpret_cast<uint16 *>(_mesh->data->indexBuffer.getData());
for (uint32 i = 0; i < facesCount * 3; i++)
f[i] = ctx.mdl->readUint16LE();
createBound();
ctx.mdl->seek(endPos);
}
bool ModelNode_NWN2::loadSkin(Model_NWN2::ParserContext &ctx) {
uint32 tag = ctx.mdb->readUint32BE();
if (tag != kSkinID)
throw Common::Exception("Invalid skin packet signature (%s)", Common::debugTag(tag).c_str());
uint32 packetSize = ctx.mdb->readUint32LE();
_name = Common::readStringFixed(*ctx.mdb, Common::kEncodingASCII, 32);
// Skipping lower level of detail models
if (_name.endsWith("_L01") || _name.endsWith("_L02"))
return false;
Common::UString skeletonName = Common::readStringFixed(*ctx.mdb, Common::kEncodingASCII, 32);
Common::UString diffuseMap = Common::readStringFixed(*ctx.mdb, Common::kEncodingASCII, 32);
Common::UString normalMap = Common::readStringFixed(*ctx.mdb, Common::kEncodingASCII, 32);
_tintMap = Common::readStringFixed(*ctx.mdb, Common::kEncodingASCII, 32);
Common::UString glowMap = Common::readStringFixed(*ctx.mdb, Common::kEncodingASCII, 32);
_diffuse [0] = ctx.mdb->readIEEEFloatLE();
_diffuse [1] = ctx.mdb->readIEEEFloatLE();
_diffuse [2] = ctx.mdb->readIEEEFloatLE();
_specular[0] = ctx.mdb->readIEEEFloatLE();
_specular[1] = ctx.mdb->readIEEEFloatLE();
_specular[2] = ctx.mdb->readIEEEFloatLE();
float specularPower = ctx.mdb->readIEEEFloatLE();
float specularValue = ctx.mdb->readIEEEFloatLE();
uint32 textureFlags = ctx.mdb->readUint32LE();
uint32 vertexCount = ctx.mdb->readUint32LE();
uint32 facesCount = ctx.mdb->readUint32LE();
if ((vertexCount == 0) || (facesCount == 0))
return false;
std::vector<Common::UString> textures;
textures.push_back(diffuseMap);
loadTextures(textures);
// Read vertices (interleaved)
VertexDecl vertexDecl;
vertexDecl.push_back(VertexAttrib(VPOSITION, 3, GL_FLOAT));
vertexDecl.push_back(VertexAttrib(VNORMAL , 3, GL_FLOAT));
vertexDecl.push_back(VertexAttrib(VTCOORD , 3, GL_FLOAT));
if (!_tintMap.empty())
vertexDecl.push_back(VertexAttrib(VTCOORD + 1, 3, GL_FLOAT));
_vertexBuffer.setVertexDeclInterleave(vertexCount, vertexDecl);
float *v = (float *) _vertexBuffer.getData();
for (uint32 i = 0; i < vertexCount; i++) {
// Position
*v++ = ctx.mdb->readIEEEFloatLE();
*v++ = ctx.mdb->readIEEEFloatLE();
*v++ = ctx.mdb->readIEEEFloatLE();
// Normal
*v++ = ctx.mdb->readIEEEFloatLE();
*v++ = ctx.mdb->readIEEEFloatLE();
*v++ = ctx.mdb->readIEEEFloatLE();
ctx.mdb->skip(4 * 4); // Bone weights
ctx.mdb->skip(4 * 1); // Bone indices
ctx.mdb->skip(3 * 4); // Tangent
ctx.mdb->skip(3 * 4); // Binormal
// TexCoords
*v++ = ctx.mdb->readIEEEFloatLE();
*v++ = ctx.mdb->readIEEEFloatLE();
*v++ = ctx.mdb->readIEEEFloatLE();
// TintMap TexCoords
if (!_tintMap.empty()) {
v[0] = v[-3];
v[1] = v[-2];
v[2] = v[-1];
v += 3;
}
ctx.mdb->skip(4); // Bone count
}
// Read faces
_indexBuffer.setSize(facesCount * 3, sizeof(uint16), GL_UNSIGNED_SHORT);
uint16 *f = (uint16 *) _indexBuffer.getData();
for (uint32 i = 0; i < facesCount * 3; i++)
f[i] = ctx.mdb->readUint16LE();
createBound();
_render = true;
return true;
}
