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;

        // Note: Function is not const because there is no const getMesh() function.
        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::stringw nameForMesh(const scene::IMesh* mesh, int instance) = 0;


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


        virtual irr::core::stringw 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)
            , GeometryWriting(ECGI_PER_MESH)
        {
        }

        virtual ~IColladaMeshWriter() 
        {
            if ( Properties )
                Properties->drop();
            if ( DefaultProperties )
                DefaultProperties->drop();
            if ( NameGenerator )
                NameGenerator->drop();
            if ( DefaultNameGenerator )
                DefaultNameGenerator->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 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::stringw toNCName(const irr::core::stringw& oldString, const irr::core::stringw& prefix=irr::core::stringw(L"_NC_")) const = 0;


    protected:
        // NOTE: You usually should also call setProperties with the same paraemter 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 paraemter when using setDefaultProperties
        virtual void setDefaultNameGenerator(IColladaMeshWriterNames * p)
        {
            if ( p == DefaultNameGenerator )
                return;
            if ( p ) 
                p->grab();
            if ( DefaultNameGenerator )
                DefaultNameGenerator->drop();
            DefaultNameGenerator = p;
        }

    private:
        IColladaMeshWriterProperties * Properties;
        IColladaMeshWriterProperties * DefaultProperties;
        IColladaMeshWriterNames * NameGenerator;
        IColladaMeshWriterNames * DefaultNameGenerator;
        bool WriteTextures;
        bool WriteDefaultScene;
        bool ExportSMaterialOnce;
        video::SColorf AmbientLight;
        E_COLLADA_GEOMETRY_WRITING GeometryWriting;
    };


} // end namespace
} // end namespace

#endif