00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include "LampBasic.h"
00026 #include <direct.h>
00027 #include "Graphics/InputOutput/BinarySceneSaver.h"
00028 #include "Core/InputOutput/BinaryFileWriter.h"
00029 #include "Core/InputOutput/FilePath.h"
00030 #include "Core/Codec/Tga/TargaSaver.h"
00031 #include "Graphics/Scene/Scene.h"
00032 #include "Graphics/Fog/Fog.h"
00033 #include "Graphics/Light/LightManager.h"
00034 #include "Graphics/SceneNode/SceneNodeManager.h"
00035 #include "Graphics/Model/ModelManager.h"
00036 #include "Graphics/Mesh/MeshManager.h"
00037 #include "Graphics/MeshData/MeshDataManager.h"
00038 #include "Graphics/Material/MaterialManager.h"
00039 #include "Graphics/Texture/TextureManager.h"
00040 #include "Graphics/Picture/PictureManager.h"
00041
00042 namespace Lamp{
00043
00044
00045
00046 BinarySceneSaver::BinarySceneSaver(){
00047 }
00048
00049
00050 BinarySceneSaver::~BinarySceneSaver(){
00051 }
00052
00053
00054 void BinarySceneSaver::save(const String& filePath, Scene* scene){
00055 FilePath path(filePath);
00056 BinaryFileWriter* binaryFileWriter = new BinaryFileWriter(filePath);
00057 save(binaryFileWriter, scene, path.getFolderPath());
00058 delete binaryFileWriter;
00059 }
00060
00061
00062 void BinarySceneSaver::save(BinaryWriter* binaryWriter, Scene* scene,
00063 const String& basePath){
00064
00065 writer_ = binaryWriter;
00066 basePath_ = basePath;
00067 scene_ = scene;
00068 sceneNodeManager_ = scene->getSceneNodeManager();
00069 lightManager_ = scene->getLightManager();
00070 modelManager_ = scene->getModelManager();
00071 meshManager_ = scene->getMeshManager();
00072 meshDataManager_ = scene->getMeshDataManager();
00073 materialManager_ = scene->getMaterialManager();
00074 textureManager_ = scene->getTextureManager();
00075 pictureManager_ = scene->getPictureManager();
00076
00077
00078 writeHeader();
00079
00080
00081 int linkCount = writeObjectList();
00082
00083
00084 writeLink(linkCount);
00085 }
00086
00087
00088 void BinarySceneSaver::writeHeader(){
00089
00090 writeID("LBScene");
00091
00092 u_int binaryVersion = 0x00000900;
00093 writer_->writeUInt(binaryVersion);
00094 align();
00095 }
00096
00097
00098 int BinarySceneSaver::writeObjectList(){
00099 int linkCount = 0;
00100
00101 writeFog(scene_->getFog());
00102
00103
00104
00105 int sceneNodeCount = sceneNodeManager_->getCount();
00106
00107 if(sceneNodeCount > 1){ writeSceneNodeList(); }
00108 linkCount += sceneNodeCount;
00109
00110
00111 int lightCount = lightManager_->getCount();
00112 if(lightCount > 0){ writeLightList(); }
00113
00114
00115
00116 int modelCount = modelManager_->getCount();
00117 if(modelCount > 0){ writeModelList(); }
00118 linkCount += modelCount;
00119
00120
00121 int meshCount = meshManager_->getCount();
00122 if(meshCount > 0){ writeMeshList(); }
00123 linkCount += meshCount;
00124
00125
00126 int meshDataCount = meshDataManager_->getCount();
00127 if(meshDataCount > 0){ writeMeshDataList(); }
00128 linkCount += meshDataCount;
00129
00130
00131 int materialCount = materialManager_->getCount();
00132 if(materialCount > 0){ writeMaterialList(); }
00133 linkCount += materialCount;
00134
00135
00136 int textureCount = textureManager_->getCount();
00137 if(textureCount > 0){ writeTextureList(); }
00138 linkCount += textureCount;
00139
00140
00141 int pictureCount = pictureManager_->getCount();
00142 if(pictureCount > 0){
00143 int startAddress = startBlock("Picture");
00144 for(int i = 0; i < pictureCount; i++){
00145 writePicture(pictureManager_->get(i));
00146 }
00147 endBlock(startAddress);
00148 }
00149 linkCount += pictureCount;
00150
00151 return linkCount;
00152 }
00153
00154
00155 void BinarySceneSaver::writeLink(int linkCount){
00156
00157 if(linkCount <= 1){ return; }
00158
00159 {
00160 int startAddress = startBlock("SceneNodeLin");
00161 int sceneNodeCount = sceneNodeManager_->getCount();
00162 for(int i = 0; i < sceneNodeCount; i++){
00163 writeSceneNodeLink(sceneNodeManager_->get(i));
00164 }
00165 endBlock(startAddress);
00166 }
00167
00168
00169 int modelCount = modelManager_->getCount();
00170 if(modelCount > 0){
00171 int startAddress = startBlock("ModelLink");
00172 for(int i = 0; i < modelCount; i++){
00173 writeModelLink(modelManager_->get(i));
00174 }
00175 endBlock(startAddress);
00176 }
00177
00178
00179 int meshCount = meshManager_->getCount();
00180 if(meshCount > 0){
00181 int startAddress = startBlock("MeshLink");
00182 for(int i = 0; i < meshCount; i++){
00183 writeMeshLink(meshManager_->get(i));
00184 }
00185 endBlock(startAddress);
00186 }
00187
00188
00189
00190 int textureCount = textureManager_->getCount();
00191 if(textureCount > 0){ writeMaterialLinkList(); }
00192
00193
00194 if(textureCount > 0){
00195 int startAddress = startBlock("TextureLink");
00196 for(int i = 0; i < textureCount; i++){
00197 writeTextureLink(textureManager_->get(i));
00198 }
00199 endBlock(startAddress);
00200 }
00201 }
00202
00203
00204
00205
00206 void BinarySceneSaver::writeFog(Fog* fog){
00207 int startAddress = startBlock("Fog");
00208
00209 writeColor4c(fog->getColor());
00210
00211 writer_->writeInt(fog->getMode());
00212
00213 writer_->writeFloat(fog->getDensity());
00214
00215 writer_->writeFloat(fog->getNear());
00216
00217 writer_->writeFloat(fog->getFar());
00218
00219 writer_->writeBool(fog->isEnabled());
00220 endBlock(startAddress);
00221 }
00222
00223
00224
00225
00226 void BinarySceneSaver::writeSceneNodeList(){
00227 int startAddress = startBlock("SceneNode");
00228 int sceneNodeCount = sceneNodeManager_->getCount();
00229
00230 for(int i = 1; i < sceneNodeCount; i++){
00231 SceneNode* sceneNode = sceneNodeManager_->get(i);
00232 if(sceneNode->isLODSceneNode()){
00233 writeLODSceneNode(sceneNode->castLODSceneNode());
00234 }else{
00235 writeSceneNode(sceneNode);
00236 }
00237 }
00238 endBlock(startAddress);
00239 }
00240
00241
00242 void BinarySceneSaver::writeSceneNode(SceneNode* sceneNode){
00243 int startAddress = startBlock("Standard");
00244
00245 writeString(sceneNode->getName());
00246
00247 writeVector3(sceneNode->getScale());
00248
00249 writeVector3(sceneNode->getRotationXYZ());
00250
00251 writeVector3(sceneNode->getTranslation());
00252
00253 writer_->writeBool(sceneNode->isEnabled());
00254 endBlock(startAddress);
00255 }
00256
00257
00258 void BinarySceneSaver::writeLODSceneNode(LODSceneNode* sceneNode){
00259 int startAddress = startBlock("LOD");
00260
00261 writeString(sceneNode->getName());
00262
00263 writeVector3(sceneNode->getScale());
00264
00265 writeVector3(sceneNode->getRotationXYZ());
00266
00267 writeVector3(sceneNode->getTranslation());
00268
00269 int lodThresholdCount = sceneNode->getLODThresholdCount();
00270 writer_->writeInt(lodThresholdCount);
00271 for(int i = 0; i < lodThresholdCount; i++){
00272 writer_->writeFloat(sceneNode->getLODThreshold(i));
00273 }
00274
00275 writer_->writeBool(sceneNode->isEnabled());
00276 endBlock(startAddress);
00277 }
00278
00279
00280
00281
00282 void BinarySceneSaver::writeLightList(){
00283 int startAddress = startBlock("Light");
00284 int lightCount = lightManager_->getCount();
00285 for(int i = 0; i < lightCount; i++){
00286 Light* light = lightManager_->get(i);
00287 if(light->isAmbientLight()){
00288 writeAmbientLight(light->castAmbientLight());
00289 }else if(light->isDirectionalLight()){
00290 writeDirectionalLight(light->castDirectionalLight());
00291 }else if(light->isPointLight()){
00292 writePointLight(light->castPointLight());
00293 }else{
00294 ErrorOut("BinarySceneSaver::writeLightList() unsupported light %s",
00295 light->getName().getBytes());
00296 }
00297 }
00298 endBlock(startAddress);
00299 }
00300
00301
00302 void BinarySceneSaver::writeLight(Light* light){
00303
00304 writer_->writeUInt(light->getLightMask());
00305
00306 writer_->writeBool(light->isEnabled());
00307 }
00308
00309
00310 void BinarySceneSaver::writeAmbientLight(AmbientLight* light){
00311 int startAddress = startBlock("Ambient");
00312
00313 writeString(light->getName());
00314
00315 writeColor3f(light->getColor());
00316
00317 writeLight(light);
00318 endBlock(startAddress);
00319 }
00320
00321
00322 void BinarySceneSaver::writeDirectionalLight(DirectionalLight* light){
00323 int startAddress = startBlock("Directional");
00324
00325 writeString(light->getName());
00326
00327 writeColor3f(light->getDiffuseColor());
00328
00329 writeColor3f(light->getSpecularColor());
00330
00331 writeVector3(light->getDirection());
00332
00333 writeLight(light);
00334 endBlock(startAddress);
00335 }
00336
00337
00338 void BinarySceneSaver::writePointLight(PointLight* light){
00339 int startAddress = startBlock("Point");
00340
00341 writeString(light->getName());
00342
00343 writeColor3f(light->getDiffuseColor());
00344
00345 writeColor3f(light->getSpecularColor());
00346
00347 writeVector3(light->getPosition());
00348
00349 writer_->writeFloat(light->getRange());
00350
00351 writer_->writeFloat(light->getAttenuation0());
00352 writer_->writeFloat(light->getAttenuation1());
00353 writer_->writeFloat(light->getAttenuation2());
00354
00355 writeLight(light);
00356 endBlock(startAddress);
00357 }
00358
00359
00360
00361
00362 void BinarySceneSaver::writeModelList(){
00363 int startAddress = startBlock("Model");
00364 int modelCount = modelManager_->getCount();
00365 for(int i = 0; i < modelCount; i++){
00366 Model* model = modelManager_->get(i);
00367 if(model->isStandardModel()){
00368 writeStandardModel(model->castStandardModel());
00369 }else if(model->isCharacterModel()){
00370 writeCharacterModel(model->castCharacterModel());
00371 }else{
00372 ErrorOut("BinarySceneSaver::writeModelList() "
00373 "unsupported model %s", model->getName().getBytes());
00374 }
00375 }
00376 endBlock(startAddress);
00377 }
00378
00379
00380 void BinarySceneSaver::writeStandardModel(StandardModel* model){
00381 int startAddress = startBlock("Standard");
00382
00383 writeString(model->getName());
00384
00385 writer_->writeBool(model->isEnabled());
00386 endBlock(startAddress);
00387 }
00388
00389
00390 void BinarySceneSaver::writeCharacterModel(CharacterModel* model){
00391 int startAddress = startBlock("Character");
00392
00393 writeString(model->getName());
00394
00395 writer_->writeBool(model->isEnabled());
00396
00397 align();
00398
00399 int boneCount = model->getBoneCount();
00400 writer_->writeInt(boneCount);
00401 for(int i = 0; i < boneCount; i++){ writeBone(model->getBone(i)); }
00402
00403 for(int i = 0; i < boneCount; i++){
00404 writeBoneLink(model, model->getBone(i));
00405 }
00406 endBlock(startAddress);
00407 }
00408
00409
00410 void BinarySceneSaver::writeBone(Bone* bone){
00411
00412 writeString(bone->getName());
00413
00414 writeMatrix34(bone->getInversePoseMatrix());
00415
00416 writeVector3(bone->getScale());
00417
00418 writeVector3(bone->getRotationXYZ());
00419
00420 writeVector3(bone->getTranslation());
00421 }
00422
00423
00424 void BinarySceneSaver::writeBoneLink(CharacterModel* model, Bone* bone){
00425 int boneCount = bone->getBoneCount();
00426 writer_->writeInt(boneCount);
00427 for(int i = 0; i < boneCount; i++){
00428 writer_->writeInt(model->getBoneIndex(bone->getBone(i)));
00429 }
00430 }
00431
00432
00433
00434
00435 void BinarySceneSaver::writeMeshList(){
00436 int startAddress = startBlock("Mesh");
00437 int meshCount = meshManager_->getCount();
00438 for(int i = 0; i < meshCount; i++){
00439 Mesh* mesh = meshManager_->get(i);
00440 if(mesh->isRigidMesh()){
00441 writeRigidMesh(mesh->castRigidMesh());
00442 }else if(mesh->isCharacterMesh()){
00443 writeCharacterMesh(mesh->castCharacterMesh());
00444 }else{
00445 ErrorOut("BinarySceneSaver::writeMeshList() unsupported mesh %s",
00446 mesh->getName().getBytes());
00447 }
00448 }
00449 endBlock(startAddress);
00450 }
00451
00452
00453 void BinarySceneSaver::writeRigidMesh(RigidMesh* mesh){
00454 int startAddress = startBlock("Rigid");
00455
00456 writeString(mesh->getName());
00457
00458 writer_->writeBool(mesh->isEnabled());
00459 endBlock(startAddress);
00460 }
00461
00462
00463 void BinarySceneSaver::writeCharacterMesh(CharacterMesh* mesh){
00464 int startAddress = startBlock("Character");
00465
00466 writeString(mesh->getName());
00467
00468 writer_->writeBool(mesh->isEnabled());
00469 endBlock(startAddress);
00470 }
00471
00472
00473
00474
00475 void BinarySceneSaver::writeMeshDataList(){
00476 int startAddress = startBlock("MeshData");
00477 int meshDataCount = meshDataManager_->getCount();
00478 for(int i = 0; i < meshDataCount; i++){
00479 writeMeshData(meshDataManager_->get(i));
00480 }
00481 endBlock(startAddress);
00482 }
00483
00484
00485 void BinarySceneSaver::writeMeshData(MeshData* meshData){
00486
00487 writeString(meshData->getName());
00488
00489 writeAxisAlignedBox(meshData->getBoundingBox());
00490
00491 writeSphere(meshData->getBoundingSphere());
00492
00493 writer_->writeInt(meshData->getPrimitiveType());
00494
00495 int vertexIndexCount = meshData->getVertexIndexCount();
00496 writer_->writeInt(vertexIndexCount);
00497 if(vertexIndexCount > 0){
00498 writer_->writeBytes(meshData->getVertexIndexArray(),
00499 sizeof(u_short) * vertexIndexCount);
00500 }
00501
00502 bool hasNormal = meshData->hasNormal();
00503 writer_->writeBool(hasNormal);
00504
00505 bool hasColor = meshData->hasColor();
00506 writer_->writeBool(hasColor);
00507
00508 align();
00509
00510 int vertexCount = meshData->getVertexCount();
00511 writer_->writeInt(vertexCount);
00512
00513 int texCoordSetCount = meshData->getTexCoordSetCount();
00514 writer_->writeInt(texCoordSetCount);
00515
00516 for(int i = 0; i < texCoordSetCount; i++){
00517 int texCoordType = meshData->getTexCoordType(i);
00518 writer_->writeInt(texCoordType);
00519 }
00520
00521 writer_->writeBytes(meshData->getPositionArray(),
00522 sizeof(Vector3) * vertexCount);
00523
00524 if(hasNormal){
00525 writer_->writeBytes(meshData->getNormalArray(),
00526 sizeof(Vector3) * vertexCount);
00527 }
00528
00529 if(hasColor){
00530 writer_->writeBytes(meshData->getColorArray(),
00531 sizeof(Color4c) * vertexCount);
00532 }
00533
00534 for(int i = 0; i < texCoordSetCount; i++){
00535 writer_->writeBytes(meshData->getTexCoordArray(i),
00536 meshData->getTexCoordArraySize(i));
00537 }
00538
00539 int bonesPerVertex = meshData->getBonesPerVertex();
00540 writer_->writeInt(bonesPerVertex);
00541 if(bonesPerVertex != 0){
00542
00543 writer_->writeBytes(meshData->getBoneIndexArray(),
00544 sizeof(u_char) * vertexCount * bonesPerVertex);
00545 }
00546
00547 int weightsPerVertex = meshData->getWeightsPerVertex();
00548 if(weightsPerVertex != 0){
00549
00550 writer_->writeBytes(meshData->getWeightArray(),
00551 sizeof(float) * vertexCount * weightsPerVertex);
00552 }
00553
00554 align();
00555 }
00556
00557
00558
00559
00560 void BinarySceneSaver::writeMaterialList(){
00561 int startAddress = startBlock("Material");
00562 int materialCount = materialManager_->getCount();
00563 for(int i = 0; i < materialCount; i++){
00564 Material* material = materialManager_->get(i);
00565 if(material->isBasicMaterial()){
00566 writeBasicMaterial(material->castBasicMaterial());
00567 }else{
00568 ErrorOut("BinarySceneSaver::writeMaterialList() "
00569 "unsupported material %s", material->getName().getBytes());
00570 }
00571 }
00572 endBlock(startAddress);
00573 }
00574
00575
00576 void BinarySceneSaver::writeMaterial(const Material* material){
00577
00578 writeString(material->getName());
00579
00580 writer_->writeInt(material->getPriority());
00581
00582 writer_->writeInt(material->getBlendMode());
00583
00584 writer_->writeFloat(material->getAlpha());
00585
00586 writer_->writeInt(material->getBlendSource());
00587
00588 writer_->writeInt(material->getBlendDestination());
00589
00590 writer_->writeInt(material->getFogOption());
00591
00592 writer_->writeUInt(material->getLightMask());
00593
00594 writer_->writeBool(material->useZWrite());
00595
00596 writer_->writeBool(material->useZTest());
00597
00598 align();
00599 }
00600
00601
00602 void BinarySceneSaver::writeBasicMaterial(const BasicMaterial* material){
00603 int startAddress = startBlock("Basic");
00604
00605 writeMaterial(material);
00606
00607 writer_->writeInt(material->getBaseUVIndex());
00608
00609 writer_->writeInt(material->getGlossUVIndex());
00610
00611 writer_->writeInt(material->getLightUVIndex());
00612
00613 writer_->writeInt(material->getStainUVIndex());
00614
00615 writeColor3f(material->getDiffuseColor());
00616
00617 writeColor3f(material->getSpecularColor());
00618
00619 writer_->writeFloat(material->getSpecularPower());
00620
00621 writeColor3f(material->getAmbientColor());
00622
00623 writeColor3f(material->getEmissiveColor());
00624
00625 align();
00626 endBlock(startAddress);
00627 }
00628
00629
00630
00631
00632 void BinarySceneSaver::writeTextureList(){
00633 int startAddress = startBlock("Texture");
00634 int textureCount = textureManager_->getCount();
00635 for(int i = 0; i < textureCount; i++){
00636 Texture* texture = textureManager_->get(i);
00637 if(texture->isSurfaceTexture()){
00638 writeSurfaceTexture(texture->castSurfaceTexture());
00639 }else{
00640 ErrorOut("BinarySceneSaver::writeTextureList() "
00641 "unsupported texture %s", texture->getName().getBytes());
00642 }
00643 }
00644 endBlock(startAddress);
00645 }
00646
00647
00648 void BinarySceneSaver::writeSurfaceTexture(const SurfaceTexture* texture){
00649 int startAddress = startBlock("Surface");
00650
00651 writeString(texture->getName());
00652
00653 writer_->writeInt(texture->getAddressModeU());
00654
00655 writer_->writeInt(texture->getAddressModeV());
00656
00657 writeTexCoord2(texture->getRepeatUV());
00658
00659 writeTexCoord2(texture->getOffsetUV());
00660 endBlock(startAddress);
00661 }
00662
00663
00664
00665
00666 void BinarySceneSaver::writePicture(const Picture* picture){
00667
00668 writeString(picture->getName());
00669
00670 String path = picture->getPath();
00671 writeString(path);
00672
00673 FilePath filePath(path);
00674 path = filePath.getFolderPath();
00675 if(path != ""){
00676 path = basePath_ + path;
00677 mkdir(path.getBytes());
00678 }
00679
00680 TargaSaver saver;
00681 if(picture->isPictureRGB8()){
00682
00683 PictureRGB8* rgb8 = picture->castPictureRGB8();
00684 saver.save(basePath_ + rgb8->getPath(),
00685 rgb8->getSize(), rgb8->getImage());
00686 }else if(picture->isPictureRGBA8()){
00687
00688 PictureRGBA8* rgba8 = picture->castPictureRGBA8();
00689 saver.save(basePath_ + rgba8->getPath(),
00690 rgba8->getSize(), rgba8->getImage());
00691 }else{
00692 ErrorOut("BinarySceneSaver::writePictureList() "
00693 "unsupported picture %s", picture->getName().getBytes());
00694 }
00695 }
00696
00697
00698
00699
00700 void BinarySceneSaver::writeSceneNodeLink(SceneNode* sceneNode){
00701
00702 int sceneNodeCount = sceneNode->getSceneNodeCount();
00703 int sceneLeafCount = sceneNode->getSceneLeafCount();
00704 if(sceneNodeCount + sceneLeafCount == 0){ return; }
00705
00706 writeString(sceneNode->getName());
00707
00708 writer_->writeInt(sceneNodeCount);
00709
00710 for(int i = 0; i < sceneNodeCount; i++){
00711 writeString(sceneNode->getSceneNode(i)->getName());
00712 }
00713
00714 writer_->writeInt(sceneLeafCount);
00715
00716 for(int i = 0; i < sceneLeafCount; i++){
00717 SceneLeaf* sceneLeaf = sceneNode->getSceneLeaf(i);
00718 if(sceneLeaf->isModel()){
00719 writer_->writeInt(0);
00720 }else if(sceneLeaf->isLight()){
00721 writer_->writeInt(1);
00722 }else{
00723 Assert(false);
00724 }
00725 writeString(sceneLeaf->getName());
00726 }
00727 }
00728
00729
00730 void BinarySceneSaver::writeModelLink(const Model* model){
00731 int meshCount = model->getMeshCount();
00732 if(meshCount == 0){ return; }
00733
00734 writeString(model->getName());
00735
00736 writer_->writeInt(meshCount);
00737
00738 for(int i = 0; i < meshCount; i++){
00739 writeString(model->getMesh(i)->getName());
00740 }
00741 }
00742
00743
00744 void BinarySceneSaver::writeMeshLink(const Mesh* mesh){
00745 bool hasMeshData = (mesh->getMeshData() != NULL);
00746 bool hasMaterial = (mesh->getMaterial() != NULL);
00747 if((!hasMeshData) && (!hasMaterial)){ return; }
00748
00749 writeString(mesh->getName());
00750
00751 writer_->writeBool(hasMeshData);
00752
00753 writer_->writeBool(hasMaterial);
00754
00755 align();
00756
00757 if(hasMeshData){ writeString(mesh->getMeshData()->getName()); }
00758
00759 if(hasMaterial){ writeString(mesh->getMaterial()->getName()); }
00760 }
00761
00762
00763 void BinarySceneSaver::writeMaterialLinkList(){
00764 int startAddress = startBlock("MaterialLink");
00765 int materialCount = materialManager_->getCount();
00766 for(int i = 0; i < materialCount; i++){
00767 Material* material = materialManager_->get(i);
00768 if(material->isBasicMaterial()){
00769 writeBasicMaterialLink(material->castBasicMaterial());
00770 }else{
00771 ErrorOut("BinarySceneSaver::writeMaterialLinkList() "
00772 "unsupported material %s", material->getName().getBytes());
00773 }
00774 }
00775 endBlock(startAddress);
00776 }
00777
00778
00779 void BinarySceneSaver::writeBasicMaterialLink(const BasicMaterial* material){
00780 Texture* baseTexture = material->getBaseTexture();
00781 Texture* glossTexture = material->getGlossTexture();
00782 Texture* lightTexture = material->getLightTexture();
00783 Texture* stainTexture = material->getStainTexture();
00784 bool hasBaseTexture = (baseTexture != NULL);
00785 bool hasGlossTexture = (glossTexture != NULL);
00786 bool hasLightTexture = (lightTexture != NULL);
00787 bool hasStainTexture = (stainTexture != NULL);
00788
00789 if((!hasBaseTexture) && (!hasGlossTexture) &&
00790 (!hasLightTexture) && (!hasStainTexture)){ return; }
00791 int startAddress = startBlock("Basic");
00792
00793 writeString(material->getName());
00794
00795 writer_->writeBool(hasBaseTexture);
00796 writer_->writeBool(hasGlossTexture);
00797 writer_->writeBool(hasLightTexture);
00798 writer_->writeBool(hasStainTexture);
00799
00800 align();
00801
00802 if(hasBaseTexture){ writeString(baseTexture->getName()); }
00803 if(hasGlossTexture){ writeString(glossTexture->getName()); }
00804 if(hasLightTexture){ writeString(lightTexture->getName()); }
00805 if(hasStainTexture){ writeString(stainTexture->getName()); }
00806 endBlock(startAddress);
00807 }
00808
00809
00810 void BinarySceneSaver::writeTextureLink(const Texture* texture){
00811 int pictureCount = texture->getPictureCount();
00812 if(pictureCount == 0){ return; }
00813
00814 writeString(texture->getName());
00815
00816 writer_->writeInt(pictureCount);
00817
00818 for(int i = 0; i < pictureCount; i++){
00819 writeString(texture->getPicture(i)->getName());
00820 }
00821 }
00822
00823
00824
00825
00826 void BinarySceneSaver::writeString(const String& string){
00827 int writeSize = string.getSize() + 1;
00828 writer_->writeInt(writeSize);
00829 writer_->writeBytes(string.getBytes(), writeSize);
00830 align();
00831 }
00832
00833
00834 void BinarySceneSaver::writeVector3(const Vector3& vector){
00835 writer_->writeBytes(vector.array, sizeof(Vector3));
00836 }
00837
00838
00839 void BinarySceneSaver::writeMatrix34(const Matrix34& matrix){
00840 writer_->writeBytes(matrix.array, sizeof(Matrix34));
00841 }
00842
00843
00844 void BinarySceneSaver::writeColor4c(const Color4c& color){
00845 writer_->writeBytes(color.array, sizeof(Color4c));
00846 }
00847
00848
00849 void BinarySceneSaver::writeColor3f(const Color3f& color){
00850 writer_->writeBytes(color.array, sizeof(Color3f));
00851 }
00852
00853
00854 void BinarySceneSaver::writeColor4f(const Color4f& color){
00855 writer_->writeBytes(color.array, sizeof(Color4f));
00856 }
00857
00858
00859 void BinarySceneSaver::writeTexCoord2(const TexCoord2& uv){
00860 writer_->writeBytes(uv.array, sizeof(TexCoord2));
00861 }
00862
00863
00864 void BinarySceneSaver::writeAxisAlignedBox(const AxisAlignedBox& box){
00865 writer_->writeBytes(&box, sizeof(AxisAlignedBox));
00866 }
00867
00868
00869 void BinarySceneSaver::writeSphere(const Sphere& sphere){
00870 writer_->writeBytes(&sphere, sizeof(Sphere));
00871 }
00872
00873
00874
00875
00876 void BinarySceneSaver::align(){
00877 writer_->align(16);
00878 }
00879
00880
00881 void BinarySceneSaver::writeID(const String& id){
00882 u_char buffer[12];
00883 int size = id.getSize();
00884 Assert(size <= 12);
00885 for(int i = 0; i < size; i++){ buffer[i] = id.charAt(i); }
00886 for(int i = size; i < 12; i++){ buffer[i] = 0; }
00887 writer_->writeBytes(buffer, 12);
00888 }
00889
00890
00891 int BinarySceneSaver::startBlock(const String& blockName){
00892 writeID(blockName);
00893 u_int blockAddress = writer_->getPosition();
00894
00895 writer_->writeInt(0);
00896 align();
00897 return blockAddress;
00898 }
00899
00900
00901 void BinarySceneSaver::endBlock(int blockStartAddress){
00902 align();
00903 int nowPosition = writer_->getPosition();
00904
00905 int blockSize = nowPosition - blockStartAddress - 4;
00906 writer_->setPosition(blockStartAddress);
00907 writer_->writeInt(blockSize);
00908 writer_->setPosition(nowPosition);
00909 }
00910
00911 }
00912