IColladaMeshWriter.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h

#ifndef __IRR_I_COLLADA_MESH_WRITER_H_INCLUDED__
#define __IRR_I_COLLADA_MESH_WRITER_H_INCLUDED__

#include "IMeshWriter.h"
#include "ISceneNode.h"
#include "IAnimatedMesh.h"
#include "SMaterial.h"

namespace irr
{
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_IRR_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_IRR_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 irr::scene::ISceneNode * node) const = 0;

                // TODO: Function is not const because there is no const getMesh() function for several Irrlicht nodes.
                virtual IMesh* getMesh(irr::scene::ISceneNode * node) = 0;


                virtual bool useNodeMaterial(const scene::ISceneNode* node) const = 0;

        };


        class IColladaMeshWriterNames  : public virtual IReferenceCounted
        {
        public:

                virtual ~IColladaMeshWriterNames () {}


                virtual irr::core::stringc nameForMesh(const scene::IMesh* mesh, int instance) = 0;


                virtual irr::core::stringc nameForNode(const scene::ISceneNode* node) = 0;


                virtual irr::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(irr::f32 meter, const irr::core::stringc& name)
                {
                        UnitMeter = meter;
                        UnitName = name;
                }

                virtual irr::f32 getUnitMeter() const
                {
                        return UnitMeter;
                }

                virtual irr::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 irr::core::stringc toNCName(const irr::core::stringc& oldString, const irr::core::stringc& prefix=irr::core::stringc("_NC_")) const = 0;


                // TODO: Function is not const because there is no const getMesh() function for several Irrlicht nodes.
                virtual const irr::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:
                irr::core::stringc ParamNamesUV[2];

        private:
                IColladaMeshWriterProperties * Properties;
                IColladaMeshWriterProperties * DefaultProperties;
                IColladaMeshWriterNames * NameGenerator;
                IColladaMeshWriterNames * DefaultNameGenerator;
                bool WriteTextures;
                bool WriteDefaultScene;
                bool ExportSMaterialOnce;
                video::SColorf AmbientLight;
                irr::f32 UnitMeter;
                irr::core::stringc UnitName;
                E_COLLADA_GEOMETRY_WRITING GeometryWriting;
        };


} // end namespace
} // end namespace

#endif