From 7028cbe09c688437910a25623098762bf0fa592d Mon Sep 17 00:00:00 2001 From: David Walter Seikel Date: Mon, 28 Mar 2016 22:28:34 +1000 Subject: Move Irrlicht to src/others. --- .../irrlicht-1.8.1/include/IColladaMeshWriter.h | 405 +++++++++++++++++++++ 1 file changed, 405 insertions(+) create mode 100644 src/others/irrlicht-1.8.1/include/IColladaMeshWriter.h (limited to 'src/others/irrlicht-1.8.1/include/IColladaMeshWriter.h') diff --git a/src/others/irrlicht-1.8.1/include/IColladaMeshWriter.h b/src/others/irrlicht-1.8.1/include/IColladaMeshWriter.h new file mode 100644 index 0000000..e3f48a7 --- /dev/null +++ b/src/others/irrlicht-1.8.1/include/IColladaMeshWriter.h @@ -0,0 +1,405 @@ +// 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 +{ + //! Lighting models - more or less the way Collada categorizes materials + enum E_COLLADA_TECHNIQUE_FX + { + //! Blinn-phong which is default for opengl and dx fixed function pipelines. + //! But several well-known renderers don't support it and prefer phong. + ECTF_BLINN, + //! Phong shading, default in many external renderers. + ECTF_PHONG, + //! diffuse shaded surface that is independent of lighting. + ECTF_LAMBERT, + // constantly shaded surface that is independent of lighting. + ECTF_CONSTANT + }; + + //! How to interpret the opacity in collada + enum E_COLLADA_TRANSPARENT_FX + { + //! default - only alpha channel of color or texture is used. + ECOF_A_ONE = 0, + + //! Alpha values for each RGB channel of color or texture are used. + ECOF_RGB_ZERO = 1 + }; + + //! Color names collada uses in it's color samplers + enum E_COLLADA_COLOR_SAMPLER + { + ECCS_DIFFUSE, + ECCS_AMBIENT, + ECCS_EMISSIVE, + ECCS_SPECULAR, + ECCS_TRANSPARENT, + ECCS_REFLECTIVE + }; + + //! Irrlicht colors which can be mapped to E_COLLADA_COLOR_SAMPLER values + enum E_COLLADA_IRR_COLOR + { + //! Don't write this element at all + ECIC_NONE, + + //! Check IColladaMeshWriterProperties for custom color + ECIC_CUSTOM, + + //! Use SMaterial::DiffuseColor + ECIC_DIFFUSE, + + //! Use SMaterial::AmbientColor + ECIC_AMBIENT, + + //! Use SMaterial::EmissiveColor + ECIC_EMISSIVE, + + //! Use SMaterial::SpecularColor + ECIC_SPECULAR + }; + + //! Control when geometry elements are created + enum E_COLLADA_GEOMETRY_WRITING + { + //! Default - write each mesh exactly once to collada. Optimal but will not work with many tools. + ECGI_PER_MESH, + + //! Write each mesh as often as it's used with different materials-names in the scene. + //! Material names which are used here are created on export, so using the IColladaMeshWriterNames + //! interface you have some control over how many geometries are written. + ECGI_PER_MESH_AND_MATERIAL + }; + + //! Callback interface for properties which can be used to influence collada writing + class IColladaMeshWriterProperties : public virtual IReferenceCounted + { + public: + virtual ~IColladaMeshWriterProperties () {} + + //! Which lighting model should be used in the technique (FX) section when exporting effects (materials) + virtual E_COLLADA_TECHNIQUE_FX getTechniqueFx(const video::SMaterial& material) const = 0; + + //! Which texture index should be used when writing the texture of the given sampler color. + /** \return the index to the texture-layer or -1 if that texture should never be exported + Note: for ECCS_TRANSPARENT by default the alpha channel is used, if you want to use RGB you have to set + also the ECOF_RGB_ZERO flag in getTransparentFx. */ + virtual s32 getTextureIdx(const video::SMaterial & material, E_COLLADA_COLOR_SAMPLER cs) const = 0; + + //! Return which color from Irrlicht should be used for the color requested by collada + /** Note that collada allows exporting either texture or color, not both. + So color mapping is only checked if we have no valid texture already. + By default we try to return best fits when possible. For example ECCS_DIFFUSE is mapped to ECIC_DIFFUSE. + When ECIC_CUSTOM is returned then the result of getCustomColor will be used. */ + virtual E_COLLADA_IRR_COLOR getColorMapping(const video::SMaterial & material, E_COLLADA_COLOR_SAMPLER cs) const = 0; + + //! Return custom colors for certain color types requested by collada. + /** Only used when getColorMapping returns ECIC_CUSTOM for the same paramters. */ + virtual video::SColor getCustomColor(const video::SMaterial & material, E_COLLADA_COLOR_SAMPLER cs) const = 0; + + //! Return the transparence color interpretation. + /** Not this is only about ECCS_TRANSPARENT and does not affect getTransparency. */ + virtual E_COLLADA_TRANSPARENT_FX getTransparentFx(const video::SMaterial& material) const = 0; + + //! Transparency value for that material. + /** This value is additional to transparent settings, if both are set they will be multiplicated. + \return 1.0 for fully transparent, 0.0 for not transparent and not written at all when < 0.f */ + virtual f32 getTransparency(const video::SMaterial& material) const = 0; + + //! Reflectivity value for that material + /** The amount of perfect mirror reflection to be added to the reflected light + \return 0.0 - 1.0 for reflectivity and element is not written at all when < 0.f */ + virtual f32 getReflectivity(const video::SMaterial& material) const = 0; + + //! Return index of refraction for that material + /** By default we don't write that. + \return a value greater equal 0.f to write \ when it is lesser than 0 nothing will be written */ + virtual f32 getIndexOfRefraction(const video::SMaterial& material) const = 0; + + //! Should node be used in scene export? (only needed for scene-writing, ignored in mesh-writing) + //! By default all visible nodes are exported. + virtual bool isExportable(const irr::scene::ISceneNode * node) const = 0; + + //! Return the mesh for the given node. If it has no mesh or shouldn't export it's mesh + //! you can return 0 in which case only the transformation matrix of the node will be used. + // Note: Function is not const because there is no const getMesh() function. + virtual IMesh* getMesh(irr::scene::ISceneNode * node) = 0; + + //! Return if the node has it's own material overwriting the mesh-materials + /** Usually true except for mesh-nodes which have isReadOnlyMaterials set. + This is mostly important for naming (as ISceneNode::getMaterial() already returns the correct material). + You have to override it when exporting custom scenenodes with own materials. + \return true => The node's own material is used, false => ignore node material and use the one from the mesh */ + virtual bool useNodeMaterial(const scene::ISceneNode* node) const = 0; + + }; + + //! Callback interface to use custom names on collada writing. + /** You can either modify names and id's written to collada or you can use + this interface to just find out which names are used on writing. + */ + class IColladaMeshWriterNames : public virtual IReferenceCounted + { + public: + + virtual ~IColladaMeshWriterNames () {} + + //! Return a unique name for the given mesh + /** Note that names really must be unique here per mesh-pointer, so + mostly it's a good idea to return the nameForMesh from + IColladaMeshWriter::getDefaultNameGenerator(). Also names must follow + the xs::NCName standard to be valid, you can run them through + IColladaMeshWriter::toNCName to ensure that. + \param mesh Pointer to the mesh which needs a name + \param instance When E_COLLADA_GEOMETRY_WRITING is not ECGI_PER_MESH then + several instances of the same mesh can be written and this counts them. + */ + virtual irr::core::stringw nameForMesh(const scene::IMesh* mesh, int instance) = 0; + + //! Return a unique name for the given node + /** Note that names really must be unique here per node-pointer, so + mostly it's a good idea to return the nameForNode from + IColladaMeshWriter::getDefaultNameGenerator(). Also names must follow + the xs::NCName standard to be valid, you can run them through + IColladaMeshWriter::toNCName to ensure that. + */ + virtual irr::core::stringw nameForNode(const scene::ISceneNode* node) = 0; + + //! Return a name for the material + /** There is one material created in the writer for each unique name. + So you can use this to control the number of materials which get written. + For example Irrlicht does by default write one material for each material + instanced by a node. So if you know that in your application material + instances per node are identical between different nodes you can reduce + the number of exported materials using that knowledge by using identical + names for such shared materials. + Names must follow the xs::NCName standard to be valid, you can run them + through IColladaMeshWriter::toNCName to ensure that. + */ + virtual irr::core::stringw nameForMaterial(const video::SMaterial & material, int materialId, const scene::IMesh* mesh, const scene::ISceneNode* node) = 0; + }; + + + //! Interface for writing meshes + 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) + { + } + + //! Destructor + virtual ~IColladaMeshWriter() + { + if ( Properties ) + Properties->drop(); + if ( DefaultProperties ) + DefaultProperties->drop(); + if ( NameGenerator ) + NameGenerator->drop(); + if ( DefaultNameGenerator ) + DefaultNameGenerator->drop(); + } + + //! writes a scene starting with the given node + virtual bool writeScene(io::IWriteFile* file, scene::ISceneNode* root) = 0; + + + //! Set if texture information should be written + virtual void setWriteTextures(bool write) + { + WriteTextures = write; + } + + //! Get if texture information should be written + virtual bool getWriteTextures() const + { + return WriteTextures; + } + + //! Set if a default scene should be written when writing meshes. + /** Many collada readers fail to read a mesh if the collada files doesn't contain a scene as well. + The scene is doing an instantiation of the mesh. + When using writeScene this flag is ignored (as we have scene there already) + */ + virtual void setWriteDefaultScene(bool write) + { + WriteDefaultScene = write; + } + + //! Get if a default scene should be written + virtual bool getWriteDefaultScene() const + { + return WriteDefaultScene; + } + + //! Sets ambient color of the scene to write + virtual void setAmbientLight(const video::SColorf &ambientColor) + { + AmbientLight = ambientColor; + } + + //! Return ambient light of the scene which is written + virtual video::SColorf getAmbientLight() const + { + return AmbientLight; + } + + //! Control when and how often a mesh is written + /** Optimally ECGI_PER_MESH would be always sufficent - writing geometry once per mesh. + Unfortunately many tools (at the time of writing this nearly all of them) have trouble + on import when different materials are used per node. So when you override materials + per node and importing the resuling collada has materials problems in other tools try + using other values here. + \param writeStyle One of the E_COLLADA_GEOMETRY_WRITING settings. + */ + virtual void setGeometryWriting(E_COLLADA_GEOMETRY_WRITING writeStyle) + { + GeometryWriting = writeStyle; + } + + //! Get the current style of geometry writing. + virtual E_COLLADA_GEOMETRY_WRITING getGeometryWriting() const + { + return GeometryWriting; + } + + //! Make certain there is only one collada material generated per Irrlicht material + /** Checks before creating a collada material-name if an identical + irr:::video::SMaterial has been exported already. If so don't export it with + another name. This is set by default and leads to way smaller .dae files. + Note that if you need to disable this flag for some reason you can still + get a similar effect using the IColladaMeshWriterNames::nameForMaterial + by returning identical names for identical materials there. + */ + virtual void setExportSMaterialsOnlyOnce(bool exportOnce) + { + ExportSMaterialOnce = exportOnce; + } + + virtual bool getExportSMaterialsOnlyOnce() const + { + return ExportSMaterialOnce; + } + + //! Set properties to use by the meshwriter instead of it's default properties. + /** Overloading properties with an own class allows modifying the writing process in certain ways. + By default properties are set to the DefaultProperties. */ + virtual void setProperties(IColladaMeshWriterProperties * p) + { + if ( p == Properties ) + return; + if ( p ) + p->grab(); + if ( Properties ) + Properties->drop(); + Properties = p; + } + + //! Get properties which are currently used. + virtual IColladaMeshWriterProperties * getProperties() const + { + return Properties; + } + + //! Return the original default properties of the writer. + /** You can use this pointer in your own properties to access and return default values. */ + IColladaMeshWriterProperties * getDefaultProperties() const + { + return DefaultProperties; + } + + //! Install a generator to create custom names on export. + virtual void setNameGenerator(IColladaMeshWriterNames * nameGenerator) + { + if ( nameGenerator == NameGenerator ) + return; + if ( nameGenerator ) + nameGenerator->grab(); + if ( NameGenerator ) + NameGenerator->drop(); + NameGenerator = nameGenerator; + } + + //! Get currently used name generator + virtual IColladaMeshWriterNames * getNameGenerator() const + { + return NameGenerator; + } + + //! Return the original default name generator of the writer. + /** You can use this pointer in your own generator to access and return default values. */ + IColladaMeshWriterNames * getDefaultNameGenerator() const + { + return DefaultNameGenerator; + } + + //! Restrict the characters of oldString a set of allowed characters in xs::NCName and add the prefix. + /** A tool function to help when using a custom name generator to generative valid names for collada names and id's. */ + 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 -- cgit v1.1