IColladaMeshWriter.hpp

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in nirtcpp/nirtcpp.hpp
 
#ifndef NIRT_I_COLLADA_MESH_WRITER_HPP_INCLUDED
#define NIRT_I_COLLADA_MESH_WRITER_HPP_INCLUDED
 
#include <nirtcpp/core/engine/IMeshWriter.hpp>
#include <nirtcpp/core/engine/ISceneNode.hpp>
#include <nirtcpp/core/engine/IAnimatedMesh.hpp>
#include <nirtcpp/core/engine/SMaterial.hpp>
 
namespace nirt
{
namespace io
{
    class IWriteFile;
} // end namespace io
 
namespace scene
{
    enum E_COLLADA_TECHNIQUE_FX
    {
        ECTF_BLINN,
        ECTF_PHONG,
        ECTF_LAMBERT,
        // constantly shaded surface that is independent of lighting.
        ECTF_CONSTANT
    };
 
    enum E_COLLADA_TRANSPARENT_FX
    {
        ECOF_A_ONE = 0,
 
        ECOF_RGB_ZERO = 1
    };
 
    enum E_COLLADA_COLOR_SAMPLER
    {
        ECCS_DIFFUSE,
        ECCS_AMBIENT,
        ECCS_EMISSIVE,
        ECCS_SPECULAR,
        ECCS_TRANSPARENT,
        ECCS_REFLECTIVE
    };
 
    enum E_COLLADA_NIRT_COLOR
    {
        ECIC_NONE,
 
        ECIC_CUSTOM,
 
        ECIC_DIFFUSE,
 
        ECIC_AMBIENT,
 
        ECIC_EMISSIVE,
 
        ECIC_SPECULAR
    };
 
    enum E_COLLADA_GEOMETRY_WRITING
    {
        ECGI_PER_MESH,
 
        ECGI_PER_MESH_AND_MATERIAL
    };
 
    class IColladaMeshWriterProperties  : public virtual IReferenceCounted
    {
    public:
        virtual ~IColladaMeshWriterProperties () {}
 
        virtual E_COLLADA_TECHNIQUE_FX getTechniqueFx(const video::SMaterial& material) const = 0;
 
 
        virtual s32 getTextureIdx(const video::SMaterial & material, E_COLLADA_COLOR_SAMPLER cs) const = 0;
 
 
        virtual E_COLLADA_NIRT_COLOR getColorMapping(const video::SMaterial & material, E_COLLADA_COLOR_SAMPLER cs) const = 0;
 
 
        virtual video::SColor getCustomColor(const video::SMaterial & material, E_COLLADA_COLOR_SAMPLER cs) const = 0;
 
 
        virtual E_COLLADA_TRANSPARENT_FX getTransparentFx(const video::SMaterial& material) const = 0;
 
 
        virtual f32 getTransparency(const video::SMaterial& material) const = 0;
 
 
        virtual f32 getReflectivity(const video::SMaterial& material) const = 0;
 
 
        virtual f32 getIndexOfRefraction(const video::SMaterial& material) const = 0;
 
        virtual bool isExportable(const nirt::scene::ISceneNode * node) const = 0;
 
        // TODO: Function is not const because there is no const getMesh() function for several Nirtcpp nodes.
        virtual IMesh* getMesh(nirt::scene::ISceneNode * node) = 0;
 
 
        virtual bool useNodeMaterial(const scene::ISceneNode* node) const = 0;
 
    };
 
 
    class IColladaMeshWriterNames  : public virtual IReferenceCounted
    {
    public:
 
        virtual ~IColladaMeshWriterNames () {}
 
 
        virtual nirt::core::stringc nameForMesh(const scene::IMesh* mesh, int instance) = 0;
 
 
        virtual nirt::core::stringc nameForNode(const scene::ISceneNode* node) = 0;
 
 
        virtual nirt::core::stringc nameForMaterial(const video::SMaterial & material, int materialId, const scene::IMesh* mesh, const scene::ISceneNode* node) = 0;
    };
 
 
    class IColladaMeshWriter : public IMeshWriter
    {
    public:
 
        IColladaMeshWriter()
            : Properties(0), DefaultProperties(0), NameGenerator(0), DefaultNameGenerator(0)
            , WriteTextures(true), WriteDefaultScene(true), ExportSMaterialOnce(true)
            , AmbientLight(0.f, 0.f, 0.f, 1.f)
            , UnitMeter(1.f), UnitName("meter")
            , GeometryWriting(ECGI_PER_MESH)
        {
            ParamNamesUV[0] = "U";
            ParamNamesUV[1] = "V";
        }
 
        virtual ~IColladaMeshWriter()
        {
            if ( Properties )
                Properties->drop();
            if ( DefaultProperties )
                DefaultProperties->drop();
            if ( NameGenerator )
                NameGenerator->drop();
            if ( DefaultNameGenerator )
                DefaultNameGenerator->drop();
        }
 
        //\param writeRoot: 0 = no, 1=yes unless root is scenemanager, 2=yes
        virtual bool writeScene(io::IWriteFile* file, scene::ISceneNode* root, int writeRoot=1) = 0;
 
 
        virtual void setWriteTextures(bool write)
        {
            WriteTextures = write;
        }
 
        virtual bool getWriteTextures() const
        {
            return WriteTextures;
        }
 
 
        virtual void setWriteDefaultScene(bool write)
        {
            WriteDefaultScene = write;
        }
 
        virtual bool getWriteDefaultScene() const
        {
            return WriteDefaultScene;
        }
 
        virtual void setAmbientLight(const video::SColorf &ambientColor)
        {
            AmbientLight = ambientColor;
        }
 
        virtual video::SColorf getAmbientLight() const
        {
            return AmbientLight;
        }
 
 
        virtual void setUnit(nirt::f32 meter, const nirt::core::stringc& name)
        {
            UnitMeter = meter;
            UnitName = name;
        }
 
        virtual nirt::f32 getUnitMeter() const
        {
            return UnitMeter;
        }
 
        virtual nirt::core::stringc getUnitName() const 
        {
            return UnitName;
        }
 
 
        virtual void setGeometryWriting(E_COLLADA_GEOMETRY_WRITING writeStyle)
        {
            GeometryWriting = writeStyle;
        }
 
        virtual E_COLLADA_GEOMETRY_WRITING getGeometryWriting() const
        {
            return GeometryWriting;
        }
 
 
        virtual void setExportSMaterialsOnlyOnce(bool exportOnce)
        {
            ExportSMaterialOnce = exportOnce;
        }
 
        virtual bool getExportSMaterialsOnlyOnce() const
        {
            return ExportSMaterialOnce;
        }
 
 
        virtual void setProperties(IColladaMeshWriterProperties * p)
        {
            if ( p == Properties )
                return;
            if ( p )
                p->grab();
            if ( Properties )
                Properties->drop();
            Properties = p;
        }
 
        virtual IColladaMeshWriterProperties * getProperties() const
        {
            return Properties;
        }
 
 
        IColladaMeshWriterProperties * getDefaultProperties() const
        {
            return DefaultProperties;
        }
 
        virtual void setNameGenerator(IColladaMeshWriterNames * nameGenerator)
        {
            if ( nameGenerator == NameGenerator )
                return;
            if ( nameGenerator )
                nameGenerator->grab();
            if ( NameGenerator )
                NameGenerator->drop();
            NameGenerator = nameGenerator;
        }
 
        virtual IColladaMeshWriterNames * getNameGenerator() const
        {
            return NameGenerator;
        }
 
 
        IColladaMeshWriterNames * getDefaultNameGenerator() const
        {
            return DefaultNameGenerator;
        }
 
 
        virtual nirt::core::stringc toNCName(const nirt::core::stringc& oldString, const nirt::core::stringc& prefix=nirt::core::stringc("_NC_")) const = 0;
 
 
        // TODO: Function is not const because there is no const getMesh() function for several Nirtcpp nodes.
        virtual const nirt::core::stringc* findGeometryNameForNode(ISceneNode* node) = 0;
 
 
        void SetParamNamesUV(const core::stringc& u, const core::stringc& v)
        {
            ParamNamesUV[0] = u;
            ParamNamesUV[1] = v;
        }
 
 
    protected:
        // NOTE: You usually should also call setProperties with the same parameter when using setDefaultProperties
        virtual void setDefaultProperties(IColladaMeshWriterProperties * p)
        {
            if ( p == DefaultProperties )
                return;
            if ( p )
                p->grab();
            if ( DefaultProperties )
                DefaultProperties->drop();
            DefaultProperties = p;
        }
 
        // NOTE: You usually should also call setNameGenerator with the same parameter when using setDefaultProperties
        virtual void setDefaultNameGenerator(IColladaMeshWriterNames * p)
        {
            if ( p == DefaultNameGenerator )
                return;
            if ( p )
                p->grab();
            if ( DefaultNameGenerator )
                DefaultNameGenerator->drop();
            DefaultNameGenerator = p;
        }
 
    protected:
        nirt::core::stringc ParamNamesUV[2];
 
    private:
        IColladaMeshWriterProperties * Properties;
        IColladaMeshWriterProperties * DefaultProperties;
        IColladaMeshWriterNames * NameGenerator;
        IColladaMeshWriterNames * DefaultNameGenerator;
        bool WriteTextures;
        bool WriteDefaultScene;
        bool ExportSMaterialOnce;
        video::SColorf AmbientLight;
        nirt::f32 UnitMeter;
        nirt::core::stringc UnitName;
        E_COLLADA_GEOMETRY_WRITING GeometryWriting;
    };
 
 
} // end namespace
} // end namespace
 
#endif