VRS - The Virtual Rendering System

version 3.3

threedsreader.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2008 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * This  library  is  free  software; you can redistribute it and/or  modify it
 * under the terms of the GNU Lesser General Public  License  as  published  by
 * the  Free  Software  Foundation;  either  version 2.1 of the License, or (at
 * your option) any later version. This library  is  distributed  in  the  hope
 * that  it will be useful, but  WITHOUT ANY WARRANTY; without even the implied
 * warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE.  See  the
 * GNU Lesser General Public License for more details. You should have received
 * a copy of the GNU Lesser+ General Public License along with this library; if
 * not, write to the FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/

// $Id: threedsreader.h 6429 2008-07-04 15:03:07Z Stefan_Maass $

#ifndef VRS_IO_THREEDSREADER_H
#define VRS_IO_THREEDSREADER_H

#include <vrs/sharedobj.h>
#include <vrs/so.h>
#include <vrs/sg/scenething.h>
#include <vrs/io/objectreader.h>

namespace VRS {

template<typename T, typename V> class NonPersistentDictionary;

class VRS_CORE_API ThreeDSReader:public ObjectReader {
public:
        // standard ObjectReader methods
        ThreeDSReader();
        virtual SO<SharedObj> read(DataResource* data, const ID& targetType) const;

        const char* objectFormatName() const {return "3D Studio Max";}
    const char* objectFileSuffix() const {return "3ds";}        

    virtual bool canProduce(const ID& targetType) const;

    // extentions (only directly callable)
        enum TextureMode {
                NO_TEXTURES,                            // ignore all textures in file
                FORCE_TEXTURES,                         // abort reading, if a texture image is unavailable
                                                                        // textures are searched in the directory of the 3ds file
                TRY_TEXTURES                            // skip texture, if image is unavailable (standard)
        };
    VRS_SERIALIZABLE_CLASS_ENUM(TextureMode);

        enum TextureModulationMode {
                MODULATE_TEXTURES_BY_MATERIAL, // use 3ds-material to modulate texture 
                MODULATE_TEXTURES_BY_WHITE,     // use white material to modulate texture (standard);
        };
    VRS_SERIALIZABLE_CLASS_ENUM(TextureModulationMode);

        enum ReadMode {
                READ_SCENE,                                     // read complete scene with lights, cameras and all meshes 
                READ_OBJECT                                     // read only one specified object or first mesh of file (standard)
        };
    VRS_SERIALIZABLE_CLASS_ENUM(ReadMode);

        enum MaterialMode {
                NO_MATERIAL,                            // use no materials
                COLORS_ONLY,                            // set only object color
        ALL_BUT_CULLING_MATERIAL,   // include face style as well, but discards culling (standard)
                COMPLETE_MATERIAL                       // include face style as well 
        };
    VRS_SERIALIZABLE_CLASS_ENUM(MaterialMode);

        enum OptimizationMode {
                NO_OPTIMIZATIONS = 0,           // disable all optimizations: load all data of file, 
                                                                        // make rendering system independent scene graph
                DISCARD_UNUSED_DATA = 1,        // discard unused texture coordinates (standard)
                EXCLUSIVE_OPENGL = 2            // create scene graph renderable only with opengl
                                                                        // advantages: higher framerate, fewer memory usage
        };
    VRS_SERIALIZABLE_CLASS_ENUM(OptimizationMode);

        static std::string noCamera();
        static std::string firstCamera();
        static std::string firstCameraIfPossible();

        // global settings (affect read() as well as readScene() and readObject()
        static void setTextureMode(TextureMode textureMode);

    static void setTextureModulationMode(TextureModulationMode textureModulationMode);

        static void setCreateNormals(bool normals);

        static void setCollapse(bool collapse);

        static void setMetaInfo(bool metaInfo);





    static void setContextDataInsertion(bool yesNo);

        static void setMaterialMode(MaterialMode materialMode);

        static void setReadMode(ReadMode readMode);

        static void setOptimizations(unsigned int optimizationMode);

    static void setMaxTextureSize(unsigned int maxSize);

    static void setCopyTexturesToPow2(bool pow2);

        // query current settings
        static TextureMode textureMode();
    static TextureModulationMode textureModulationMode();
        static bool collapse();
        static bool metainfo();
    static bool contextDataInsertion();
        static MaterialMode materialMode();
        static ReadMode readMode();
        static unsigned int optimizationMode();
    static unsigned int maxTextureSize();
        static bool copyTexturesToPow2();

        // extended read methods
        static SO<SceneThing> readScene(const std::string& fileName, const std::string& cameraName, bool lights, bool environment);
        static SO<SceneThing> readScene(SO<DataResource> data, const std::string& cameraName, bool lights, bool environment);

        static SO<SceneThing> readObject(const std::string& fileName, const std::string& objectName = "");
        static SO<SceneThing> readObject(SO<DataResource> data, const std::string& objectName = "");

        static NonPersistentDictionary< std::string, SO< NonPersistentDictionary< std::string, std::string > > >* readNames(const std::string& fileName);

        VRS_TYPEINFO(ThreeDSReader, ObjectReader);

private:
    static bool createNormals_;
        static bool collapse_;
        static bool metainfo_;
    static bool s_contextDataInsertion;
        static TextureMode texture_;
        static TextureModulationMode textureModulation_;
        static MaterialMode material_;
        static ReadMode readMode_;
        static unsigned int opts_;
        static unsigned int maxTextureSize_;
        static bool copyTexturesToPow2_;


    static SO<SceneThing> readImpl(SO<DataResource> d, const std::string& objName, const std::string& camName, bool lights, bool env, ReadMode r);
};

} // namespace VRS

#endif // VRS_IO_THREEDSREADER_H

---

Generated on Thu May 24 06:00:16 2012 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact