return false;\r
#endif\r
\r
- Size = 0;\r
file->write("BB3D", 4);\r
- file->write(&Size, sizeof(u32)); // Updated later once known.\r
+ file->write("size", 4); // BB3D chunk size, updated later\r
\r
- int version = 1;\r
- write(file, &version, sizeof(int));\r
+ const u32 version = 1;\r
+ file->write(&version, 4);\r
\r
//\r
\r
- const u32 numBeshBuffers = mesh->getMeshBufferCount();\r
+ const u32 numMeshBuffers = mesh->getMeshBufferCount();\r
array<SB3dTexture> texs;\r
map<ITexture *, u32> tex2id; // TODO: texture pointer as key not sufficient as same texture can have several id's\r
u32 texsizes = 0;\r
- for (u32 i = 0; i < numBeshBuffers; i++)\r
+ for (u32 i = 0; i < numMeshBuffers; i++)\r
{\r
const IMeshBuffer * const mb = mesh->getMeshBuffer(i);\r
const SMaterial &mat = mb->getMaterial();\r
}\r
}\r
\r
- write(file, "TEXS", 4);\r
- write(file, &texsizes, 4);\r
+ file->write("TEXS", 4);\r
+ file->write(&texsizes, 4);\r
\r
u32 numTexture = texs.size();\r
for (u32 i = 0; i < numTexture; i++)\r
{\r
- write(file, texs[i].TextureName.c_str(), texs[i].TextureName.size() + 1);\r
- write(file, &texs[i].Flags, 7*4);\r
+ file->write(texs[i].TextureName.c_str(), texs[i].TextureName.size() + 1);\r
+ file->write(&texs[i].Flags, 7*4);\r
}\r
\r
//\r
\r
- const u32 brushsize = (7 * 4 + 1) * numBeshBuffers + numBeshBuffers * 4 * MATERIAL_MAX_TEXTURES + 4;\r
- write(file, "BRUS", 4);\r
- write(file, &brushsize, 4);\r
- u32 brushcheck = Size;\r
+ file->write("BRUS", 4);\r
+ const u32 brushSizeAdress = file->getPos();\r
+ file->write(&brushSizeAdress, 4); // BRUSH chunk size, updated later\r
+\r
const u32 usedtex = MATERIAL_MAX_TEXTURES;\r
- write(file, &usedtex, 4);\r
+ file->write(&usedtex, 4);\r
\r
- for (u32 i = 0; i < numBeshBuffers; i++)\r
+ for (u32 i = 0; i < numMeshBuffers; i++)\r
{\r
const IMeshBuffer * const mb = mesh->getMeshBuffer(i);\r
const SMaterial &mat = mb->getMaterial();\r
\r
- write(file, "", 1);\r
+ file->write("", 1);\r
\r
float f = 1;\r
- write(file, &f, 4);\r
- write(file, &f, 4);\r
- write(file, &f, 4);\r
- write(file, &f, 4);\r
+ file->write(&f, 4);\r
+ file->write(&f, 4);\r
+ file->write(&f, 4);\r
+ file->write(&f, 4);\r
\r
f = 0;\r
- write(file, &f, 4);\r
+ file->write(&f, 4);\r
\r
u32 tmp = 1;\r
- write(file, &tmp, 4);\r
+ file->write(&tmp, 4);\r
tmp = 0;\r
- write(file, &tmp, 4);\r
+ file->write(&tmp, 4);\r
\r
for (u32 j = 0; j < MATERIAL_MAX_TEXTURES; j++)\r
{\r
+ s32 id = -1;\r
if (mat.getTexture(j))\r
{\r
- const u32 id = tex2id[mat.getTexture(j)];\r
- write(file, &id, 4);\r
- }\r
- else\r
- {\r
- const int id = -1;\r
- write(file, &id, 4);\r
+ id = tex2id[mat.getTexture(j)];\r
}\r
+ file->write(&id, 4);\r
}\r
}\r
+ writeSizeFrom(file, brushSizeAdress+4, brushSizeAdress); // BRUSH chunk size\r
\r
- // Check brushsize\r
- brushcheck = Size - brushcheck;\r
- if (brushcheck != brushsize)\r
- {\r
- printf("Failed in brush size calculation, size %u advanced %u\n",\r
- brushsize, brushcheck);\r
- }\r
-\r
- write(file, "NODE", 4);\r
-\r
- // Calculate node size\r
- u32 nodesize = 41 + 8 + 4 + 8;\r
- u32 bonesSize = 0;\r
-\r
- if(ISkinnedMesh *skinnedMesh = getSkinned(mesh))\r
- {\r
- if (!skinnedMesh->isStatic())\r
- {\r
- bonesSize += 20;\r
- }\r
-\r
- const core::array<ISkinnedMesh::SJoint*> rootJoints = getRootJoints(skinnedMesh);\r
- for (u32 i = 0; i < rootJoints.size(); i++)\r
- {\r
- bonesSize += getJointChunkSize(skinnedMesh, rootJoints[i]);\r
- }\r
- nodesize += bonesSize;\r
-\r
- // -------------------\r
-\r
- }\r
-\r
- // VERT data\r
- nodesize += 12;\r
+ file->write("NODE", 4);\r
+ u32 nodeSizeAdress = file->getPos();\r
+ file->write(&nodeSizeAdress, 4); // NODE chunk size, updated later\r
\r
- const u32 texcoords = getUVlayerCount(mesh);\r
- for (u32 i = 0; i < numBeshBuffers; i++)\r
- {\r
- nodesize += 8 + 4;\r
- const IMeshBuffer * const mb = mesh->getMeshBuffer(i);\r
+ // Node\r
+ file->write("", 1);\r
\r
- nodesize += mb->getVertexCount() * 10 * 4;\r
+ // position\r
+ writeVector3(file, core::vector3df(0.f, 0.f, 0.f));\r
\r
- nodesize += mb->getVertexCount() * texcoords * 2 * 4;\r
- nodesize += mb->getIndexCount() * 4;\r
- }\r
- write(file, &nodesize, 4);\r
- u32 nodecheck = Size;\r
+ // scale\r
+ writeVector3(file, core::vector3df(1.f, 1.f, 1.f));\r
\r
- // Node\r
- write(file, "", 1);\r
- float f = 0;\r
- write(file, &f, 4);\r
- write(file, &f, 4);\r
- write(file, &f, 4);\r
-\r
- f = 1;\r
- write(file, &f, 4);\r
- write(file, &f, 4);\r
- write(file, &f, 4);\r
-\r
- write(file, &f, 4);\r
- f = 0;\r
- write(file, &f, 4);\r
- write(file, &f, 4);\r
- write(file, &f, 4);\r
+ // rotation\r
+ writeQuaternion(file, core::quaternion(0.f, 0.f, 0.f, 1.f));\r
\r
// Mesh\r
- write(file, "MESH", 4);\r
- const u32 meshsize = nodesize - 41 - 8 - bonesSize;\r
- write(file, &meshsize, 4);\r
+ file->write("MESH", 4);\r
+ const u32 meshSizeAdress = file->getPos();\r
+ file->write(&meshSizeAdress, 4); // MESH chunk size, updated later\r
+\r
s32 brushID = -1;\r
- write(file, &brushID, 4);\r
+ file->write(&brushID, 4);\r
\r
\r
\r
// Verts\r
- write(file, "VRTS", 4);\r
- u32 vertsize = 12;\r
-\r
- for (u32 i = 0; i < numBeshBuffers; i++)\r
- {\r
- const IMeshBuffer * const mb = mesh->getMeshBuffer(i);\r
+ file->write("VRTS", 4);\r
+ const u32 verticesSizeAdress = file->getPos();\r
+ file->write(&verticesSizeAdress, 4);\r
\r
- vertsize += mb->getVertexCount() * 10 * 4 +\r
- mb->getVertexCount() * texcoords * 2 * 4;\r
- }\r
- write(file, &vertsize, 4);\r
- u32 vertcheck = Size;\r
+ u32 flagsB3D = 3; // 1=normal values present, 2=rgba values present\r
+ file->write(&flagsB3D, 4);\r
\r
- int flagsB3D = 3;\r
- write(file, &flagsB3D, 4);\r
-\r
- write(file, &texcoords, 4);\r
+ const u32 texcoordsCount = getUVlayerCount(mesh);\r
+ file->write(&texcoordsCount, 4);\r
flagsB3D = 2;\r
- write(file, &flagsB3D, 4);\r
+ file->write(&flagsB3D, 4);\r
\r
- for (u32 i = 0; i < numBeshBuffers; i++)\r
+ for (u32 i = 0; i < numMeshBuffers; i++)\r
{\r
const IMeshBuffer * const mb = mesh->getMeshBuffer(i);\r
- irr::u32 numVertices = mb->getVertexCount();\r
+ const u32 numVertices = mb->getVertexCount();\r
for (u32 j = 0; j < numVertices; j++)\r
{\r
const vector3df &pos = mb->getPosition(j);\r
- write(file, &pos.X, 4);\r
- write(file, &pos.Y, 4);\r
- write(file, &pos.Z, 4);\r
+ writeVector3(file, pos);\r
\r
const vector3df &n = mb->getNormal(j);\r
- write(file, &n.X, 4);\r
- write(file, &n.Y, 4);\r
- write(file, &n.Z, 4);\r
+ writeVector3(file, n);\r
\r
- const u32 zero = 0;\r
switch (mb->getVertexType())\r
{\r
case EVT_STANDARD:\r
{\r
S3DVertex *v = (S3DVertex *) mb->getVertices();\r
const SColorf col(v[j].Color);\r
- write(file, &col.r, 4);\r
- write(file, &col.g, 4);\r
- write(file, &col.b, 4);\r
- write(file, &col.a, 4);\r
-\r
- write(file, &v[j].TCoords.X, 4);\r
- write(file, &v[j].TCoords.Y, 4);\r
- if (texcoords == 2)\r
+ writeColor(file, col);\r
+\r
+ const core::vector2df uv1 = v[j].TCoords;\r
+ writeVector2(file, uv1);\r
+ if (texcoordsCount == 2)\r
{\r
- write(file, &zero, 4);\r
- write(file, &zero, 4);\r
+ writeVector2(file, core::vector2df(0.f, 0.f));\r
}\r
}\r
break;\r
{\r
S3DVertex2TCoords *v = (S3DVertex2TCoords *) mb->getVertices();\r
const SColorf col(v[j].Color);\r
- write(file, &col.r, 4);\r
- write(file, &col.g, 4);\r
- write(file, &col.b, 4);\r
- write(file, &col.a, 4);\r
-\r
- write(file, &v[j].TCoords.X, 4);\r
- write(file, &v[j].TCoords.Y, 4);\r
- write(file, &v[j].TCoords2.X, 4);\r
- write(file, &v[j].TCoords2.Y, 4);\r
+ writeColor(file, col);\r
+\r
+ const core::vector2df uv1 = v[j].TCoords;\r
+ writeVector2(file, uv1);\r
+ const core::vector2df uv2 = v[j].TCoords;\r
+ writeVector2(file, uv2);\r
}\r
break;\r
case EVT_TANGENTS:\r
{\r
S3DVertexTangents *v = (S3DVertexTangents *) mb->getVertices();\r
const SColorf col(v[j].Color);\r
- write(file, &col.r, 4);\r
- write(file, &col.g, 4);\r
- write(file, &col.b, 4);\r
- write(file, &col.a, 4);\r
-\r
- write(file, &v[j].TCoords.X, 4);\r
- write(file, &v[j].TCoords.Y, 4);\r
- if (texcoords == 2)\r
+ writeColor(file, col);\r
+\r
+ const core::vector2df uv1 = v[j].TCoords;\r
+ writeVector2(file, uv1);\r
+ if (texcoordsCount == 2)\r
{\r
- write(file, &zero, 4);\r
- write(file, &zero, 4);\r
+ writeVector2(file, core::vector2df(0.f, 0.f));\r
}\r
}\r
break;\r
}\r
}\r
}\r
- // Check vertsize\r
- vertcheck = Size - vertcheck;\r
- if (vertcheck != vertsize)\r
- {\r
- printf("Failed in vertex size calculation, size %u advanced %u\n",\r
- vertsize, vertcheck);\r
- }\r
+ writeSizeFrom(file, verticesSizeAdress+4, verticesSizeAdress); // VERT chunk size\r
+\r
\r
u32 currentMeshBufferIndex = 0;\r
// Tris\r
- for (u32 i = 0; i < numBeshBuffers; i++)\r
+ for (u32 i = 0; i < numMeshBuffers; i++)\r
{\r
const IMeshBuffer * const mb = mesh->getMeshBuffer(i);\r
- write(file, "TRIS", 4);\r
- const u32 trisize = 4 + mb->getIndexCount() * 4;\r
- write(file, &trisize, 4);\r
-\r
- u32 tricheck = Size;\r
+ file->write("TRIS", 4);\r
+ const u32 trisSizeAdress = file->getPos();\r
+ file->write(&trisSizeAdress, 4); // TRIS chunk size, updated later\r
\r
- write(file, &i, 4);\r
+ file->write(&i, 4);\r
\r
u32 numIndices = mb->getIndexCount();\r
const u16 * const idx = (u16 *) mb->getIndices();\r
for (u32 j = 0; j < numIndices; j += 3)\r
{\r
u32 tmp = idx[j] + currentMeshBufferIndex;\r
- write(file, &tmp, sizeof(u32));\r
+ file->write(&tmp, sizeof(u32));\r
\r
tmp = idx[j + 1] + currentMeshBufferIndex;\r
- write(file, &tmp, sizeof(u32));\r
+ file->write(&tmp, sizeof(u32));\r
\r
tmp = idx[j + 2] + currentMeshBufferIndex;\r
- write(file, &tmp, sizeof(u32));\r
+ file->write(&tmp, sizeof(u32));\r
}\r
-\r
- // Check that tris calculation was ok\r
- tricheck = Size - tricheck;\r
- if (tricheck != trisize)\r
- {\r
- printf("Failed in tris size calculation, size %u advanced %u\n",\r
- trisize, tricheck);\r
- }\r
+ writeSizeFrom(file, trisSizeAdress+4, trisSizeAdress); // TRIS chunk size\r
\r
currentMeshBufferIndex += mb->getVertexCount();\r
}\r
+ writeSizeFrom(file, meshSizeAdress+4, meshSizeAdress); // MESH chunk size\r
+\r
\r
if(ISkinnedMesh *skinnedMesh = getSkinned(mesh))\r
{\r
// Write animation data\r
+ f32 animationSpeedMultiplier = 1.f;\r
if (!skinnedMesh->isStatic())\r
{\r
- write(file, "ANIM", 4);\r
+ file->write("ANIM", 4);\r
\r
const u32 animsize = 12;\r
- write(file, &animsize, 4);\r
+ file->write(&animsize, 4);\r
\r
const u32 flags = 0;\r
- const u32 frames = skinnedMesh->getFrameCount();\r
- const f32 fps = skinnedMesh->getAnimationSpeed();\r
+ f32 fps = skinnedMesh->getAnimationSpeed();\r
+\r
+ /* B3D file format use integer as keyframe, so there is some potential issues if the model use float as keyframe (Irrlicht use float) with a low animation FPS value\r
+ So we define a minimum animation FPS value to multiply the frame and FPS value if the FPS of the animation is too low to store the keyframe with integers */\r
+ const int minimumAnimationFPS = 60;\r
+\r
+ if (fps < minimumAnimationFPS)\r
+ {\r
+ animationSpeedMultiplier = minimumAnimationFPS / fps;\r
+ fps = minimumAnimationFPS;\r
+ }\r
+ const u32 frames = static_cast<u32>(skinnedMesh->getFrameCount() * animationSpeedMultiplier);\r
\r
- write(file, &flags, 4);\r
- write(file, &frames, 4);\r
- write(file, &fps, 4);\r
+ file->write(&flags, 4);\r
+ file->write(&frames, 4);\r
+ file->write(&fps, 4);\r
}\r
\r
// Write joints\r
\r
for (u32 i = 0; i < rootJoints.size(); i++)\r
{\r
- writeJointChunk(file, skinnedMesh, rootJoints[i]);\r
+ writeJointChunk(file, skinnedMesh, rootJoints[i], animationSpeedMultiplier);\r
}\r
}\r
\r
- // Check that node calculation was ok\r
- nodecheck = Size - nodecheck;\r
- if (nodecheck != nodesize)\r
- {\r
- printf("Failed in node size calculation, size %u advanced %u\n",\r
- nodesize, nodecheck);\r
- }\r
- file->seek(4);\r
- file->write(&Size, 4);\r
+ writeSizeFrom(file, nodeSizeAdress+4, nodeSizeAdress); // Node chunk size\r
+ writeSizeFrom(file, 8, 4); // BB3D chunk size\r
\r
return true;\r
}\r
\r
\r
\r
-void CB3DMeshWriter::writeJointChunk(io::IWriteFile* file, ISkinnedMesh* mesh , ISkinnedMesh::SJoint* joint)\r
+void CB3DMeshWriter::writeJointChunk(io::IWriteFile* file, ISkinnedMesh* mesh, ISkinnedMesh::SJoint* joint, f32 animationSpeedMultiplier)\r
{\r
// Node\r
- write(file, "NODE", 4);\r
-\r
- // Calculate node size\r
- u32 nodesize = getJointChunkSize(mesh, joint);\r
- nodesize -= 8; // The declaration + size of THIS chunk shouldn't be added to the size\r
-\r
- write(file, &nodesize, 4);\r
+ file->write("NODE", 4);\r
+ const u32 nodeSizeAdress = file->getPos();\r
+ file->write(&nodeSizeAdress, 4);\r
\r
\r
core::stringc name = joint->Name;\r
- write(file, name.c_str(), name.size());\r
- write(file, "", 1);\r
+ file->write(name.c_str(), name.size());\r
+ file->write("", 1);\r
\r
- core::vector3df pos = joint->Animatedposition;\r
// Position\r
- write(file, &pos.X, 4);\r
- write(file, &pos.Y, 4);\r
- write(file, &pos.Z, 4);\r
+ const core::vector3df pos = joint->Animatedposition;\r
+ writeVector3(file, pos);\r
\r
// Scale\r
core::vector3df scale = joint->Animatedscale;\r
if (scale == core::vector3df(0, 0, 0))\r
scale = core::vector3df(1, 1, 1);\r
\r
- write(file, &scale.X, 4);\r
- write(file, &scale.Y, 4);\r
- write(file, &scale.Z, 4);\r
+ writeVector3(file, scale);\r
\r
// Rotation\r
- core::quaternion quat = joint->Animatedrotation;\r
- write(file, &quat.W, 4);\r
- write(file, &quat.X, 4);\r
- write(file, &quat.Y, 4);\r
- write(file, &quat.Z, 4);\r
+ const core::quaternion quat = joint->Animatedrotation;\r
+ writeQuaternion(file, quat);\r
\r
// Bone\r
- write(file, "BONE", 4);\r
+ file->write("BONE", 4);\r
u32 bonesize = 8 * joint->Weights.size();\r
- write(file, &bonesize, 4);\r
+ file->write(&bonesize, 4);\r
\r
// Skinning ------------------\r
for (u32 i = 0; i < joint->Weights.size(); i++)\r
b3dVertexID += mesh->getMeshBuffer(j)->getVertexCount();\r
}\r
\r
- write(file, &b3dVertexID, 4);\r
- write(file, &weight, 4);\r
+ file->write(&b3dVertexID, 4);\r
+ file->write(&weight, 4);\r
}\r
// ---------------------------\r
\r
+ f32 floatBuffer[5];\r
// Animation keys\r
if (joint->PositionKeys.size())\r
{\r
- write(file, "KEYS", 4);\r
+ file->write("KEYS", 4);\r
u32 keysSize = 4 * joint->PositionKeys.size() * 4; // X, Y and Z pos + frame\r
keysSize += 4; // Flag to define the type of the key\r
- write(file, &keysSize, 4);\r
+ file->write(&keysSize, 4);\r
\r
u32 flag = 1; // 1 = flag for position keys\r
- write(file, &flag, 4);\r
+ file->write(&flag, 4);\r
\r
for (u32 i = 0; i < joint->PositionKeys.size(); i++)\r
{\r
- const s32 frame = static_cast<s32>(joint->PositionKeys[i].frame);\r
- const core::vector3df pos = joint->PositionKeys[i].position;\r
-\r
- write (file, &frame, 4);\r
-\r
- write (file, &pos.X, 4);\r
- write (file, &pos.Y, 4);\r
- write (file, &pos.Z, 4);\r
+ const s32 frame = static_cast<s32>(joint->PositionKeys[i].frame * animationSpeedMultiplier);\r
+ file->write(&frame, 4);\r
\r
+ const core::vector3df pos = joint->PositionKeys[i].position;\r
+ pos.getAs3Values(floatBuffer);\r
+ file->write(floatBuffer, 12);\r
}\r
}\r
if (joint->RotationKeys.size())\r
{\r
- write(file, "KEYS", 4);\r
+ file->write("KEYS", 4);\r
u32 keysSize = 4 * joint->RotationKeys.size() * 5; // W, X, Y and Z rot + frame\r
keysSize += 4; // Flag\r
- write(file, &keysSize, 4);\r
+ file->write(&keysSize, 4);\r
\r
u32 flag = 4;\r
- write(file, &flag, 4);\r
+ file->write(&flag, 4);\r
\r
for (u32 i = 0; i < joint->RotationKeys.size(); i++)\r
{\r
- const s32 frame = static_cast<s32>(joint->RotationKeys[i].frame);\r
+ const s32 frame = static_cast<s32>(joint->RotationKeys[i].frame * animationSpeedMultiplier);\r
const core::quaternion rot = joint->RotationKeys[i].rotation;\r
\r
- write (file, &frame, 4);\r
-\r
- write (file, &rot.W, 4);\r
- write (file, &rot.X, 4);\r
- write (file, &rot.Y, 4);\r
- write (file, &rot.Z, 4);\r
+ memcpy(floatBuffer, &frame, 4);\r
+ floatBuffer[1] = rot.W;\r
+ floatBuffer[2] = rot.X;\r
+ floatBuffer[3] = rot.Y;\r
+ floatBuffer[4] = rot.Z;\r
+ file->write(floatBuffer, 20);\r
}\r
}\r
if (joint->ScaleKeys.size())\r
{\r
- write(file, "KEYS", 4);\r
+ file->write("KEYS", 4);\r
u32 keysSize = 4 * joint->ScaleKeys.size() * 4; // X, Y and Z scale + frame\r
keysSize += 4; // Flag\r
- write(file, &keysSize, 4);\r
+ file->write(&keysSize, 4);\r
\r
u32 flag = 2;\r
- write(file, &flag, 4);\r
+ file->write(&flag, 4);\r
\r
for (u32 i = 0; i < joint->ScaleKeys.size(); i++)\r
{\r
- const s32 frame = static_cast<s32>(joint->ScaleKeys[i].frame);\r
- const core::vector3df scale = joint->ScaleKeys[i].scale;\r
-\r
- write (file, &frame, 4);\r
+ const s32 frame = static_cast<s32>(joint->ScaleKeys[i].frame * animationSpeedMultiplier);\r
+ file->write(&frame, 4);\r
\r
- write (file, &scale.X, 4);\r
- write (file, &scale.Y, 4);\r
- write (file, &scale.Z, 4);\r
+ const core::vector3df scale = joint->ScaleKeys[i].scale;\r
+ scale.getAs3Values(floatBuffer);\r
+ file->write(floatBuffer, 12);\r
}\r
}\r
\r
for (u32 i = 0; i < joint->Children.size(); i++)\r
{\r
- writeJointChunk(file, mesh, joint->Children[i]);\r
+ writeJointChunk(file, mesh, joint->Children[i], animationSpeedMultiplier);\r
}\r
+\r
+ writeSizeFrom(file, nodeSizeAdress+4, nodeSizeAdress); // NODE chunk size\r
}\r
\r
\r
return 0;\r
}\r
\r
-u32 CB3DMeshWriter::getJointChunkSize(const ISkinnedMesh* mesh, ISkinnedMesh::SJoint* joint)\r
-{\r
- u32 chunkSize = 8 + 40; // Chunk declaration + chunk data\r
- chunkSize += joint->Name.size() + 1; // the NULL character at the end of the string\r
-\r
- u32 boneSize = joint->Weights.size() * 8; // vertex_id + weight = 8 bits per weight block\r
- boneSize += 8; // declaration + size of he BONE chunk\r
-\r
- u32 keysSize = 0;\r
- if (joint->PositionKeys.size() != 0)\r
- {\r
- keysSize += 8; // KEYS + chunk size\r
- keysSize += 4; // flags\r
-\r
- keysSize += (joint->PositionKeys.size() * 16);\r
- }\r
- if (joint->RotationKeys.size() != 0)\r
- {\r
- keysSize += 8; // KEYS + chunk size\r
- keysSize += 4; // flags\r
-\r
- keysSize += (joint->RotationKeys.size() * 20);\r
- }\r
- if (joint->ScaleKeys.size() != 0)\r
- {\r
- keysSize += 8; // KEYS + chunk size\r
- keysSize += 4; // flags\r
-\r
- keysSize += (joint->ScaleKeys.size() * 16);\r
- }\r
-\r
- chunkSize += boneSize;\r
- chunkSize += keysSize;\r
-\r
- for (u32 i = 0; i < joint->Children.size(); ++i)\r
- {\r
- chunkSize += (getJointChunkSize(mesh, joint->Children[i]));\r
- }\r
- return chunkSize;\r
-}\r
-\r
core::array<ISkinnedMesh::SJoint*> CB3DMeshWriter::getRootJoints(const ISkinnedMesh* mesh)\r
{\r
core::array<ISkinnedMesh::SJoint*> roots;\r
return 1;\r
}\r
\r
-void CB3DMeshWriter::write(io::IWriteFile* file, const void *ptr, const u32 bytes)\r
+void CB3DMeshWriter::writeVector2(io::IWriteFile* file, const core::vector2df& vec2)\r
+{\r
+ f32 buffer[2] = {vec2.X, vec2.Y};\r
+ file->write(buffer, 8);\r
+}\r
+\r
+void CB3DMeshWriter::writeVector3(io::IWriteFile* file, const core::vector3df& vec3)\r
+{\r
+ f32 buffer[3];\r
+ vec3.getAs3Values(buffer);\r
+ file->write(buffer, 12);\r
+}\r
+\r
+void CB3DMeshWriter::writeQuaternion(io::IWriteFile* file, const core::quaternion& quat)\r
+{\r
+ f32 buffer[4] = {quat.W, quat.X, quat.Y, quat.Z};\r
+ file->write(buffer, 16);\r
+}\r
+\r
+void CB3DMeshWriter::writeColor(io::IWriteFile* file, const video::SColorf& color)\r
+{\r
+ f32 buffer[4] = {color.r, color.g, color.b, color.a};\r
+ file->write(buffer, 16);\r
+}\r
+\r
+// Write the size from a given position to current position at a specific position in the file\r
+void CB3DMeshWriter::writeSizeFrom(io::IWriteFile* file, const u32 from, const u32 adressToWrite)\r
{\r
- file->write(ptr, bytes);\r
- Size += bytes;\r
+ const long back = file->getPos();\r
+ file->seek(adressToWrite);\r
+ const u32 sizeToWrite = back - from;\r
+ file->write(&sizeToWrite, 4);\r
+ file->seek(back);\r
}\r
\r
} // end namespace\r
projects / irrlicht.git / commitdiff