IColladaMeshWriter.h

Go to the documentation of this file.

// Copyright (C) 2002-2011 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
        };

        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;

                virtual IMesh* getMesh(irr::scene::ISceneNode * node) = 0;
        };


        class IColladaMeshWriter : public IMeshWriter
        {
        public:

                IColladaMeshWriter() : Properties(0), DefaultProperties(0), WriteTextures(true), WriteDefaultScene(false), AmbientLight(0.f, 0.f, 0.f, 1.f)
                {
                }

                virtual ~IColladaMeshWriter() 
                {
                        if ( Properties )
                                Properties->drop();
                        if ( DefaultProperties )
                                DefaultProperties->drop();
                }

                virtual bool writeScene(io::IWriteFile* file, scene::ISceneNode* root) = 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 setProperties(IColladaMeshWriterProperties * p)
                {
                        if ( p == Properties )
                                return;
                        if ( p ) 
                                p->grab();
                        if ( Properties )
                                Properties->drop();
                        Properties = p;
                }

                virtual IColladaMeshWriterProperties * getProperties()
                {
                        return Properties;
                }


                IColladaMeshWriterProperties * getDefaultProperties() const 
                { 
                        return DefaultProperties; 
                }

        protected:
                // NOTE: you should also call setProperties
                virtual void setDefaultProperties(IColladaMeshWriterProperties * p)
                {
                        if ( p == DefaultProperties )
                                return;
                        if ( p ) 
                                p->grab();
                        if ( DefaultProperties )
                                DefaultProperties->drop();
                        DefaultProperties = p;
                }

        private:
                IColladaMeshWriterProperties * Properties;
                IColladaMeshWriterProperties * DefaultProperties;
                bool WriteTextures;
                bool WriteDefaultScene;
                video::SColorf AmbientLight;
        };


} // end namespace
} // end namespace

#endif