Remove Collada support
This commit is contained in:
Vincent Lejeune
parent
a012a3a14f
commit
9bbe8c61dc
@ -86,7 +86,6 @@ source/Irrlicht/CTriangleBBSelector.cpp
|
||||
source/Irrlicht/CAnimatedMeshMD3.cpp
|
||||
source/Irrlicht/CGUIComboBox.cpp
|
||||
source/Irrlicht/CSceneNodeAnimatorTexture.cpp
|
||||
source/Irrlicht/CColladaMeshWriter.cpp
|
||||
source/Irrlicht/COpenGLTexture.cpp
|
||||
source/Irrlicht/COctreeSceneNode.cpp
|
||||
source/Irrlicht/CWaterSurfaceSceneNode.cpp
|
||||
@ -182,7 +181,6 @@ source/Irrlicht/CNullDriver.cpp
|
||||
source/Irrlicht/CCameraSceneNode.cpp
|
||||
source/Irrlicht/CGUISpinBox.cpp
|
||||
source/Irrlicht/CReadFile.cpp
|
||||
source/Irrlicht/CColladaFileLoader.cpp
|
||||
source/Irrlicht/CParticleRingEmitter.cpp
|
||||
source/Irrlicht/CMetaTriangleSelector.cpp
|
||||
source/Irrlicht/CShadowVolumeSceneNode.cpp
|
||||
@ -256,7 +254,6 @@ source/Irrlicht/wglext.h
|
||||
source/Irrlicht/CTimer.h
|
||||
source/Irrlicht/CCSMLoader.h
|
||||
source/Irrlicht/CWADReader.h
|
||||
source/Irrlicht/CColladaMeshWriter.h
|
||||
source/Irrlicht/CSceneNodeAnimatorCameraFPS.h
|
||||
source/Irrlicht/CParticleFadeOutAffector.h
|
||||
source/Irrlicht/COpenGLSLMaterialRenderer.h
|
||||
@ -322,7 +319,6 @@ source/Irrlicht/CWaterSurfaceSceneNode.h
|
||||
source/Irrlicht/SoftwareDriver2_compile_config.h
|
||||
source/Irrlicht/CSceneNodeAnimatorTexture.h
|
||||
source/Irrlicht/CXMLReader.h
|
||||
source/Irrlicht/CColladaFileLoader.h
|
||||
source/Irrlicht/CEmptySceneNode.h
|
||||
source/Irrlicht/CCgMaterialRenderer.h
|
||||
source/Irrlicht/CParticleSystemSceneNode.h
|
||||
@ -434,7 +430,6 @@ include/ITimer.h
|
||||
include/IImage.h
|
||||
include/position2d.h
|
||||
include/IGUIToolbar.h
|
||||
include/IColladaMeshWriter.h
|
||||
include/IGUISpinBox.h
|
||||
include/IGUITabControl.h
|
||||
include/IBillboardTextSceneNode.h
|
||||
|
||||
@ -1,404 +0,0 @@
|
||||
// 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 \<index_of_refraction\> 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)
|
||||
{
|
||||
}
|
||||
|
||||
//! 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
|
||||
@ -317,11 +317,6 @@ B3D, MS3D or X meshes */
|
||||
#ifdef NO_IRR_COMPILE_WITH_MD3_LOADER_
|
||||
#undef _IRR_COMPILE_WITH_MD3_LOADER_
|
||||
#endif
|
||||
//! Define _IRR_COMPILE_WITH_COLLADA_LOADER_ if you want to load Collada files
|
||||
#define _IRR_COMPILE_WITH_COLLADA_LOADER_
|
||||
#ifdef NO_IRR_COMPILE_WITH_COLLADA_LOADER_
|
||||
#undef _IRR_COMPILE_WITH_COLLADA_LOADER_
|
||||
#endif
|
||||
//! Define _IRR_COMPILE_WITH_CSM_LOADER_ if you want to load Cartography Shop files
|
||||
#define _IRR_COMPILE_WITH_CSM_LOADER_
|
||||
#ifdef NO_IRR_COMPILE_WITH_CSM_LOADER_
|
||||
|
||||
@ -112,7 +112,6 @@
|
||||
#include "IMeshManipulator.h"
|
||||
#include "IMeshSceneNode.h"
|
||||
#include "IMeshWriter.h"
|
||||
#include "IColladaMeshWriter.h"
|
||||
#include "IMetaTriangleSelector.h"
|
||||
#include "IOSOperator.h"
|
||||
#include "IParticleSystemSceneNode.h" // also includes all emitters and attractors
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,389 +0,0 @@
|
||||
// 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 __C_COLLADA_MESH_FILE_LOADER_H_INCLUDED__
|
||||
#define __C_COLLADA_MESH_FILE_LOADER_H_INCLUDED__
|
||||
|
||||
#include "IMeshLoader.h"
|
||||
#include "IFileSystem.h"
|
||||
#include "IVideoDriver.h"
|
||||
#include "irrString.h"
|
||||
#include "SMesh.h"
|
||||
#include "SMeshBuffer.h"
|
||||
#include "ISceneManager.h"
|
||||
#include "irrMap.h"
|
||||
#include "CAttributes.h"
|
||||
|
||||
namespace irr
|
||||
{
|
||||
namespace scene
|
||||
{
|
||||
|
||||
#ifdef _DEBUG
|
||||
//#define COLLADA_READER_DEBUG
|
||||
#endif
|
||||
|
||||
class IColladaPrefab;
|
||||
|
||||
enum ECOLLADA_PARAM_NAME
|
||||
{
|
||||
ECPN_COLOR = 0,
|
||||
ECPN_AMBIENT,
|
||||
ECPN_DIFFUSE,
|
||||
ECPN_SPECULAR,
|
||||
ECPN_SHININESS,
|
||||
ECPN_TRANSPARENCY,
|
||||
ECPN_YFOV,
|
||||
ECPN_ZNEAR,
|
||||
ECPN_ZFAR,
|
||||
|
||||
ECPN_COUNT
|
||||
};
|
||||
|
||||
enum ECOLLADA_PARAM_TYPE
|
||||
{
|
||||
ECPT_FLOAT = 0,
|
||||
ECPT_FLOAT2,
|
||||
ECPT_FLOAT3,
|
||||
ECPT_FLOAT4,
|
||||
|
||||
ECPT_COUNT
|
||||
};
|
||||
|
||||
//! Collada Parameter
|
||||
struct SColladaParam
|
||||
{
|
||||
SColladaParam()
|
||||
: Name(ECPN_COUNT), Type(ECPT_COUNT)
|
||||
{
|
||||
for (int i=0; i<4; ++i) Floats[i] = 0;
|
||||
}
|
||||
|
||||
ECOLLADA_PARAM_NAME Name;
|
||||
ECOLLADA_PARAM_TYPE Type;
|
||||
|
||||
f32 Floats[4];
|
||||
};
|
||||
|
||||
enum ECOLLADA_INPUT_SEMANTIC
|
||||
{
|
||||
ECIS_POSITION = 0,
|
||||
ECIS_VERTEX,
|
||||
ECIS_NORMAL,
|
||||
ECIS_TEXCOORD,
|
||||
ECIS_UV,
|
||||
ECIS_TANGENT,
|
||||
ECIS_IMAGE,
|
||||
ECIS_TEXTURE,
|
||||
|
||||
ECIS_COUNT
|
||||
};
|
||||
|
||||
//! Collada Input
|
||||
struct SColladaInput
|
||||
{
|
||||
SColladaInput()
|
||||
: Semantic(ECIS_COUNT), Data(0), Offset(0), Set(0), Stride(1)
|
||||
{
|
||||
}
|
||||
|
||||
ECOLLADA_INPUT_SEMANTIC Semantic;
|
||||
core::stringc Source;
|
||||
f32* Data;
|
||||
u32 Offset;
|
||||
u32 Set;
|
||||
u32 Stride;
|
||||
};
|
||||
|
||||
//! Collada images
|
||||
struct SColladaImage
|
||||
{
|
||||
core::stringc Id;
|
||||
core::stringc Source;
|
||||
core::dimension2du Dimension;
|
||||
bool SourceIsFilename;
|
||||
};
|
||||
|
||||
|
||||
//! Collada texture
|
||||
struct SColladaTexture
|
||||
{
|
||||
video::ITexture* Texture;
|
||||
core::stringc Id;
|
||||
};
|
||||
|
||||
|
||||
//! Collada material
|
||||
struct SColladaMaterial
|
||||
{
|
||||
video::SMaterial Mat;
|
||||
core::stringc Id;
|
||||
core::stringc InstanceEffectId;
|
||||
f32 Transparency;
|
||||
|
||||
inline bool operator< (const SColladaMaterial & other) const
|
||||
{
|
||||
return Id < other.Id;
|
||||
}
|
||||
};
|
||||
|
||||
//! Collada effect (materials, shaders, and programs)
|
||||
struct SColladaEffect
|
||||
{
|
||||
core::stringc Id;
|
||||
f32 Transparency;
|
||||
core::array<core::stringc> Textures;
|
||||
video::SMaterial Mat;
|
||||
// TODO: Parameters looks somewhat lazy workaround, I think we should really read all parameters correct.
|
||||
io::IAttributes * Parameters;
|
||||
|
||||
inline bool operator< (const SColladaEffect & other) const
|
||||
{
|
||||
return Id < other.Id;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
struct SNumberArray // for storing float and int arrays
|
||||
{
|
||||
core::stringc Name;
|
||||
core::array<f32> Data;
|
||||
};
|
||||
|
||||
struct SAccessor
|
||||
{
|
||||
SAccessor()
|
||||
: Count(0), Offset(0), Stride(1) {}
|
||||
// I don't store the source of the accessor here because I assume
|
||||
// it to use the array of the source this accessor is located in.
|
||||
|
||||
int Count;
|
||||
int Offset;
|
||||
int Stride;
|
||||
|
||||
core::array<SColladaParam> Parameters; // parameters defining the accessor
|
||||
};
|
||||
|
||||
struct SSource
|
||||
{
|
||||
core::stringc Id;
|
||||
SNumberArray Array;
|
||||
core::array<SAccessor> Accessors;
|
||||
};
|
||||
|
||||
class CScenePrefab;
|
||||
|
||||
//! Meshloader capable of loading COLLADA meshes and scene descriptions into Irrlicht.
|
||||
class CColladaFileLoader : public IMeshLoader
|
||||
{
|
||||
public:
|
||||
|
||||
//! Constructor
|
||||
CColladaFileLoader(scene::ISceneManager* smgr, io::IFileSystem* fs);
|
||||
|
||||
//! destructor
|
||||
virtual ~CColladaFileLoader();
|
||||
|
||||
//! returns true if the file maybe is able to be loaded by this class
|
||||
//! based on the file extension (e.g. ".cob")
|
||||
virtual bool isALoadableFileExtension(const io::path& filename) const;
|
||||
|
||||
//! creates/loads an animated mesh from the file.
|
||||
//! \return Pointer to the created mesh. Returns 0 if loading failed.
|
||||
//! If you no longer need the mesh, you should call IAnimatedMesh::drop().
|
||||
//! See IReferenceCounted::drop() for more information.
|
||||
virtual IAnimatedMesh* createMesh(io::IReadFile* file);
|
||||
|
||||
private:
|
||||
|
||||
//! skips an (unknown) section in the collada document
|
||||
void skipSection(io::IXMLReaderUTF8* reader, bool reportSkipping);
|
||||
|
||||
//! reads the <COLLADA> section and its content
|
||||
void readColladaSection(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! reads a <library> section and its content
|
||||
void readLibrarySection(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! reads a <visual_scene> element and stores it as a prefab
|
||||
void readVisualScene(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! reads a <scene> section and its content
|
||||
void readSceneSection(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! reads a <asset> section and its content
|
||||
void readAssetSection(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! reads a <node> section and its content
|
||||
//! if a prefab pointer is passed the nodes are created as scene prefabs children of that prefab
|
||||
void readNodeSection(io::IXMLReaderUTF8* reader, scene::ISceneNode* parent, CScenePrefab* p=0);
|
||||
|
||||
//! reads a <lookat> element and its content and creates a matrix from it
|
||||
core::matrix4 readLookAtNode(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! reads a <matrix> element and its content and creates a matrix from it
|
||||
core::matrix4 readMatrixNode(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! reads a <perspective> element and its content and creates a matrix from it
|
||||
core::matrix4 readPerspectiveNode(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! reads a <rotate> element and its content and creates a matrix from it
|
||||
core::matrix4 readRotateNode(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! reads a <skew> element and its content and creates a matrix from it
|
||||
core::matrix4 readSkewNode(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! reads a <boundingbox> element and its content and stores it in bbox
|
||||
void readBboxNode(io::IXMLReaderUTF8* reader, core::aabbox3df& bbox);
|
||||
|
||||
//! reads a <scale> element and its content and creates a matrix from it
|
||||
core::matrix4 readScaleNode(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! reads a <translate> element and its content and creates a matrix from it
|
||||
core::matrix4 readTranslateNode(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! reads a <color> element
|
||||
video::SColorf readColorNode(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! reads a <float> element
|
||||
f32 readFloatNode(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! reads a <instance> node
|
||||
void readInstanceNode(io::IXMLReaderUTF8* reader,
|
||||
scene::ISceneNode* parent, scene::ISceneNode** outNode,
|
||||
CScenePrefab* p=0, const core::stringc& type=core::stringc());
|
||||
|
||||
//! creates a scene node from Prefabs (with name given in 'url')
|
||||
void instantiateNode(scene::ISceneNode* parent, scene::ISceneNode** outNode=0,
|
||||
CScenePrefab* p=0, const core::stringc& url="",
|
||||
const core::stringc& type=core::stringc());
|
||||
|
||||
//! reads a <light> element and stores it as prefab
|
||||
void readLightPrefab(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! reads a <camera> element and stores it as prefab
|
||||
void readCameraPrefab(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! reads a <image> element and stores it in the image section
|
||||
void readImage(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! reads a <texture> element and stores it in the texture section
|
||||
void readTexture(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! reads a <material> element and stores it in the material section
|
||||
void readMaterial(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! reads a <effect> element and stores it in the effects section
|
||||
void readEffect(io::IXMLReaderUTF8* reader, SColladaEffect * effect = 0);
|
||||
|
||||
//! reads a <geometry> element and stores it as mesh if possible
|
||||
void readGeometry(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! parses a float from a char pointer and moves the pointer to
|
||||
//! the end of the parsed float
|
||||
inline f32 readFloat(const c8** p);
|
||||
|
||||
//! parses an int from a char pointer and moves the pointer to
|
||||
//! the end of the parsed float
|
||||
inline s32 readInt(const c8** p);
|
||||
|
||||
//! places pointer to next begin of a token
|
||||
void findNextNoneWhiteSpace(const c8** p);
|
||||
|
||||
//! reads floats from inside of xml element until end of xml element
|
||||
void readFloatsInsideElement(io::IXMLReaderUTF8* reader, f32* floats, u32 count);
|
||||
|
||||
//! reads ints from inside of xml element until end of xml element
|
||||
void readIntsInsideElement(io::IXMLReaderUTF8* reader, s32* ints, u32 count);
|
||||
|
||||
//! clears all loaded data
|
||||
void clearData();
|
||||
|
||||
//! parses all collada parameters inside an element and stores them in ColladaParameters
|
||||
void readColladaParameters(io::IXMLReaderUTF8* reader, const core::stringc& parentName);
|
||||
|
||||
//! returns a collada parameter or none if not found
|
||||
SColladaParam* getColladaParameter(ECOLLADA_PARAM_NAME name);
|
||||
|
||||
//! parses all collada inputs inside an element and stores them in Inputs. Reads
|
||||
//! until first tag which is not an input tag or the end of the parent is reached
|
||||
void readColladaInputs(io::IXMLReaderUTF8* reader, const core::stringc& parentName);
|
||||
|
||||
//! reads a collada input tag and adds it to the input parameter
|
||||
void readColladaInput(io::IXMLReaderUTF8* reader, core::array<SColladaInput>& inputs);
|
||||
|
||||
//! returns a collada input or none if not found
|
||||
SColladaInput* getColladaInput(ECOLLADA_INPUT_SEMANTIC input);
|
||||
|
||||
//! read Collada Id, uses id or name if id is missing
|
||||
core::stringc readId(io::IXMLReaderUTF8* reader);
|
||||
|
||||
//! changes the XML URI into an internal id
|
||||
void uriToId(core::stringc& str);
|
||||
|
||||
//! reads a polygons section and creates a mesh from it
|
||||
void readPolygonSection(io::IXMLReaderUTF8* reader,
|
||||
core::array<SSource>& sources, scene::SMesh* mesh,
|
||||
const core::stringc& geometryId);
|
||||
|
||||
//! finds a material, possible instancing it
|
||||
const SColladaMaterial * findMaterial(const core::stringc & materialName);
|
||||
|
||||
//! reads and bind materials as given by the symbol->target bind mapping
|
||||
void readBindMaterialSection(io::IXMLReaderUTF8* reader, const core::stringc & id);
|
||||
|
||||
//! create an Irrlicht texture from the SColladaImage
|
||||
video::ITexture* getTextureFromImage(core::stringc uri, SColladaEffect * effect);
|
||||
|
||||
//! read a parameter and value
|
||||
void readParameter(io::IXMLReaderUTF8* reader, io::IAttributes* parameters);
|
||||
|
||||
scene::ISceneManager* SceneManager;
|
||||
io::IFileSystem* FileSystem;
|
||||
|
||||
scene::IAnimatedMesh* DummyMesh;
|
||||
core::stringc CurrentlyLoadingMesh;
|
||||
|
||||
scene::IAnimatedMesh* FirstLoadedMesh;
|
||||
io::path FirstLoadedMeshName;
|
||||
s32 LoadedMeshCount;
|
||||
u32 Version;
|
||||
bool FlipAxis;
|
||||
|
||||
core::array<IColladaPrefab*> Prefabs;
|
||||
core::array<SColladaParam> ColladaParameters;
|
||||
core::array<SColladaImage> Images;
|
||||
core::array<SColladaTexture> Textures;
|
||||
core::array<SColladaMaterial> Materials;
|
||||
core::array<SColladaInput> Inputs;
|
||||
core::array<SColladaEffect> Effects;
|
||||
//! meshbuffer reference ("geomid/matname") -> index into MeshesToBind
|
||||
core::map<core::stringc,u32> MaterialsToBind;
|
||||
//! Array of buffers for each material binding
|
||||
core::array< core::array<irr::scene::IMeshBuffer*> > MeshesToBind;
|
||||
|
||||
bool CreateInstances;
|
||||
};
|
||||
|
||||
|
||||
|
||||
//! following class is for holding and createing instances of library objects,
|
||||
//! named prefabs in this loader.
|
||||
class IColladaPrefab : public virtual IReferenceCounted
|
||||
{
|
||||
public:
|
||||
//! creates an instance of this prefab
|
||||
virtual scene::ISceneNode* addInstance(scene::ISceneNode* parent,
|
||||
scene::ISceneManager* mgr) = 0;
|
||||
|
||||
//! returns id of this prefab
|
||||
virtual const core::stringc& getId() = 0;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace scene
|
||||
} // end namespace irr
|
||||
|
||||
#endif
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,271 +0,0 @@
|
||||
// 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_C_COLLADA_MESH_WRITER_H_INCLUDED__
|
||||
#define __IRR_C_COLLADA_MESH_WRITER_H_INCLUDED__
|
||||
|
||||
#include "IColladaMeshWriter.h"
|
||||
#include "S3DVertex.h"
|
||||
#include "irrMap.h"
|
||||
#include "IVideoDriver.h"
|
||||
|
||||
namespace irr
|
||||
{
|
||||
namespace io
|
||||
{
|
||||
class IXMLWriter;
|
||||
class IFileSystem;
|
||||
}
|
||||
|
||||
namespace scene
|
||||
{
|
||||
//! Callback interface for properties which can be used to influence collada writing
|
||||
// (Implementer note: keep namespace labels here to make it easier for users copying this one)
|
||||
class CColladaMeshWriterProperties : public virtual IColladaMeshWriterProperties
|
||||
{
|
||||
public:
|
||||
//! Which lighting model should be used in the technique (FX) section when exporting effects (materials)
|
||||
virtual irr::scene::E_COLLADA_TECHNIQUE_FX getTechniqueFx(const irr::video::SMaterial& material) const;
|
||||
|
||||
//! Which texture index should be used when writing the texture of the given sampler color.
|
||||
virtual irr::s32 getTextureIdx(const irr::video::SMaterial & material, irr::scene::E_COLLADA_COLOR_SAMPLER cs) const;
|
||||
|
||||
//! Return which color from Irrlicht should be used for the color requested by collada
|
||||
virtual irr::scene::E_COLLADA_IRR_COLOR getColorMapping(const irr::video::SMaterial & material, irr::scene::E_COLLADA_COLOR_SAMPLER cs) const;
|
||||
|
||||
//! Return custom colors for certain color types requested by collada.
|
||||
virtual irr::video::SColor getCustomColor(const irr::video::SMaterial & material, irr::scene::E_COLLADA_COLOR_SAMPLER cs) const;
|
||||
|
||||
//! Return the settings for transparence
|
||||
virtual irr::scene::E_COLLADA_TRANSPARENT_FX getTransparentFx(const irr::video::SMaterial& material) const;
|
||||
|
||||
//! Transparency value for that material.
|
||||
virtual irr::f32 getTransparency(const irr::video::SMaterial& material) const;
|
||||
|
||||
//! Reflectivity value for that material
|
||||
virtual irr::f32 getReflectivity(const irr::video::SMaterial& material) const;
|
||||
|
||||
//! Return index of refraction for that material
|
||||
virtual irr::f32 getIndexOfRefraction(const irr::video::SMaterial& material) const;
|
||||
|
||||
//! Should node be used in scene export? By default all visible nodes are exported.
|
||||
virtual bool isExportable(const irr::scene::ISceneNode * node) const;
|
||||
|
||||
//! Return the mesh for the given nod. If it has no mesh or shouldn't export it's mesh return 0.
|
||||
virtual irr::scene::IMesh* getMesh(irr::scene::ISceneNode * node);
|
||||
|
||||
//! Return if the node has it's own material overwriting the mesh-materials
|
||||
virtual bool useNodeMaterial(const scene::ISceneNode* node) const;
|
||||
};
|
||||
|
||||
class CColladaMeshWriterNames : public virtual IColladaMeshWriterNames
|
||||
{
|
||||
public:
|
||||
CColladaMeshWriterNames(IColladaMeshWriter * writer);
|
||||
virtual irr::core::stringw nameForMesh(const scene::IMesh* mesh, int instance);
|
||||
virtual irr::core::stringw nameForNode(const scene::ISceneNode* node);
|
||||
virtual irr::core::stringw nameForMaterial(const video::SMaterial & material, int materialId, const scene::IMesh* mesh, const scene::ISceneNode* node);
|
||||
protected:
|
||||
irr::core::stringw nameForPtr(const void* ptr) const;
|
||||
private:
|
||||
IColladaMeshWriter * ColladaMeshWriter;
|
||||
};
|
||||
|
||||
|
||||
|
||||
//! class to write meshes, implementing a COLLADA (.dae, .xml) writer
|
||||
/** This writer implementation has been originally developed for irrEdit and then
|
||||
merged out to the Irrlicht Engine */
|
||||
class CColladaMeshWriter : public IColladaMeshWriter
|
||||
{
|
||||
public:
|
||||
|
||||
CColladaMeshWriter(ISceneManager * smgr, video::IVideoDriver* driver, io::IFileSystem* fs);
|
||||
virtual ~CColladaMeshWriter();
|
||||
|
||||
//! Returns the type of the mesh writer
|
||||
virtual EMESH_WRITER_TYPE getType() const;
|
||||
|
||||
//! writes a scene starting with the given node
|
||||
virtual bool writeScene(io::IWriteFile* file, scene::ISceneNode* root);
|
||||
|
||||
//! writes a mesh
|
||||
virtual bool writeMesh(io::IWriteFile* file, scene::IMesh* mesh, s32 flags=EMWF_NONE);
|
||||
|
||||
// Restrict the characters of oldString a set of allowed characters in xs::NCName and add the prefix.
|
||||
virtual irr::core::stringw toNCName(const irr::core::stringw& oldString, const irr::core::stringw& prefix=irr::core::stringw(L"_NC_")) const;
|
||||
|
||||
protected:
|
||||
|
||||
void reset();
|
||||
bool hasSecondTextureCoordinates(video::E_VERTEX_TYPE type) const;
|
||||
void writeUv(const irr::core::vector2df& vec);
|
||||
void writeVector(const irr::core::vector2df& vec);
|
||||
void writeVector(const irr::core::vector3df& vec);
|
||||
void writeColor(const irr::video::SColorf& colorf, bool writeAlpha=true);
|
||||
inline irr::core::stringw toString(const irr::video::ECOLOR_FORMAT format) const;
|
||||
inline irr::core::stringw toString(const irr::video::E_TEXTURE_CLAMP clamp) const;
|
||||
inline irr::core::stringw toString(const irr::scene::E_COLLADA_TRANSPARENT_FX opaque) const;
|
||||
inline irr::core::stringw toRef(const irr::core::stringw& source) const;
|
||||
bool isCamera(const scene::ISceneNode* node) const;
|
||||
irr::core::stringw nameForMesh(const scene::IMesh* mesh, int instance) const;
|
||||
irr::core::stringw nameForNode(const scene::ISceneNode* node) const;
|
||||
irr::core::stringw nameForMaterial(const video::SMaterial & material, int materialId, const scene::IMesh* mesh, const scene::ISceneNode* node);
|
||||
irr::core::stringw nameForMaterialSymbol(const scene::IMesh* mesh, int materialId) const;
|
||||
irr::core::stringw findCachedMaterialName(const irr::video::SMaterial& material) const;
|
||||
irr::core::stringw minTexfilterToString(bool bilinear, bool trilinear) const;
|
||||
irr::core::stringw magTexfilterToString(bool bilinear, bool trilinear) const;
|
||||
irr::core::stringw pathToURI(const irr::io::path& path) const;
|
||||
inline bool isXmlNameStartChar(wchar_t c) const;
|
||||
inline bool isXmlNameChar(wchar_t c) const;
|
||||
s32 getCheckedTextureIdx(const video::SMaterial & material, E_COLLADA_COLOR_SAMPLER cs);
|
||||
video::SColor getColorMapping(const video::SMaterial & material, E_COLLADA_COLOR_SAMPLER cs, E_COLLADA_IRR_COLOR colType);
|
||||
void writeAsset();
|
||||
void makeMeshNames(irr::scene::ISceneNode * node);
|
||||
void writeNodeMaterials(irr::scene::ISceneNode * node);
|
||||
void writeNodeEffects(irr::scene::ISceneNode * node);
|
||||
void writeNodeLights(irr::scene::ISceneNode * node);
|
||||
void writeNodeCameras(irr::scene::ISceneNode * node);
|
||||
void writeAllMeshGeometries();
|
||||
void writeSceneNode(irr::scene::ISceneNode * node);
|
||||
void writeMeshMaterials(scene::IMesh* mesh, irr::core::array<irr::core::stringw> * materialNamesOut=0);
|
||||
void writeMeshEffects(scene::IMesh* mesh);
|
||||
void writeMaterialEffect(const irr::core::stringw& materialname, const video::SMaterial & material);
|
||||
void writeMeshGeometry(const irr::core::stringw& meshname, scene::IMesh* mesh);
|
||||
void writeMeshInstanceGeometry(const irr::core::stringw& meshname, scene::IMesh* mesh, scene::ISceneNode* node=0);
|
||||
void writeMaterial(const irr::core::stringw& materialname);
|
||||
void writeLightInstance(const irr::core::stringw& lightName);
|
||||
void writeCameraInstance(const irr::core::stringw& cameraName);
|
||||
void writeLibraryImages();
|
||||
void writeColorFx(const video::SMaterial & material, const wchar_t * colorname, E_COLLADA_COLOR_SAMPLER cs, const wchar_t* attr1Name=0, const wchar_t* attr1Value=0);
|
||||
void writeAmbientLightElement(const video::SColorf & col);
|
||||
void writeColorElement(const video::SColor & col, bool writeAlpha=true);
|
||||
void writeColorElement(const video::SColorf & col, bool writeAlpha=true);
|
||||
void writeTextureSampler(s32 textureIdx);
|
||||
void writeFxElement(const video::SMaterial & material, E_COLLADA_TECHNIQUE_FX techFx);
|
||||
void writeNode(const wchar_t * nodeName, const wchar_t * content);
|
||||
void writeFloatElement(irr::f32 value);
|
||||
void writeRotateElement(const irr::core::vector3df& axis, irr::f32 angle);
|
||||
void writeScaleElement(const irr::core::vector3df& scale);
|
||||
void writeTranslateElement(const irr::core::vector3df& translate);
|
||||
void writeMatrixElement(const irr::core::matrix4& matrix);
|
||||
|
||||
struct SComponentGlobalStartPos
|
||||
{
|
||||
SComponentGlobalStartPos() : PosStartIndex(-1), PosLastIndex(-1),
|
||||
NormalStartIndex(-1), NormalLastIndex(-1),
|
||||
TCoord0StartIndex(-1), TCoord0LastIndex(-1),
|
||||
TCoord1StartIndex(-1), TCoord1LastIndex(-1)
|
||||
{ }
|
||||
|
||||
s32 PosStartIndex;
|
||||
s32 PosLastIndex;
|
||||
|
||||
s32 NormalStartIndex;
|
||||
s32 NormalLastIndex;
|
||||
|
||||
s32 TCoord0StartIndex;
|
||||
s32 TCoord0LastIndex;
|
||||
|
||||
s32 TCoord1StartIndex;
|
||||
s32 TCoord1LastIndex;
|
||||
};
|
||||
|
||||
io::IFileSystem* FileSystem;
|
||||
video::IVideoDriver* VideoDriver;
|
||||
io::IXMLWriter* Writer;
|
||||
core::array<video::ITexture*> LibraryImages;
|
||||
io::path Directory;
|
||||
|
||||
// Helper struct for creating geometry copies for the ECGI_PER_MESH_AND_MATERIAL settings.
|
||||
struct SGeometryMeshMaterials
|
||||
{
|
||||
bool equals(const core::array<irr::core::stringw>& names) const
|
||||
{
|
||||
if ( names.size() != MaterialNames.size() )
|
||||
return false;
|
||||
for ( irr::u32 i=0; i<MaterialNames.size(); ++i )
|
||||
if ( names[i] != MaterialNames[i] )
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
irr::core::stringw GeometryName; // replacing the usual ColladaMesh::Name
|
||||
core::array<irr::core::stringw> MaterialNames; // Material names exported for this instance
|
||||
core::array<const ISceneNode*> MaterialOwners; // Nodes using this specific mesh-material combination
|
||||
};
|
||||
|
||||
// Check per mesh-ptr if stuff has been written for this mesh already
|
||||
struct SColladaMesh
|
||||
{
|
||||
SColladaMesh() : MaterialsWritten(false), EffectsWritten(false)
|
||||
{
|
||||
}
|
||||
|
||||
SGeometryMeshMaterials * findGeometryMeshMaterials(const irr::core::array<irr::core::stringw> materialNames)
|
||||
{
|
||||
for ( irr::u32 i=0; i<GeometryMeshMaterials.size(); ++i )
|
||||
{
|
||||
if ( GeometryMeshMaterials[i].equals(materialNames) )
|
||||
return &(GeometryMeshMaterials[i]);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const irr::core::stringw& findGeometryNameForNode(const ISceneNode* node) const
|
||||
{
|
||||
if ( GeometryMeshMaterials.size() < 2 )
|
||||
return Name;
|
||||
for ( irr::u32 i=0; i<GeometryMeshMaterials.size(); ++i )
|
||||
{
|
||||
if ( GeometryMeshMaterials[i].MaterialOwners.linear_search(node) >= 0 )
|
||||
return GeometryMeshMaterials[i].GeometryName;
|
||||
}
|
||||
return Name; // (shouldn't get here usually)
|
||||
}
|
||||
|
||||
irr::core::stringw Name;
|
||||
bool MaterialsWritten; // just an optimization doing that here in addition to the MaterialsWritten map
|
||||
bool EffectsWritten; // just an optimization doing that here in addition to the EffectsWritten map
|
||||
|
||||
core::array<SGeometryMeshMaterials> GeometryMeshMaterials;
|
||||
};
|
||||
typedef core::map<IMesh*, SColladaMesh>::Node MeshNode;
|
||||
core::map<IMesh*, SColladaMesh> Meshes;
|
||||
|
||||
// structure for the lights library
|
||||
struct SColladaLight
|
||||
{
|
||||
SColladaLight() {}
|
||||
irr::core::stringw Name;
|
||||
};
|
||||
typedef core::map<ISceneNode*, SColladaLight>::Node LightNode;
|
||||
core::map<ISceneNode*, SColladaLight> LightNodes;
|
||||
|
||||
// structure for the camera library
|
||||
typedef core::map<ISceneNode*, irr::core::stringw>::Node CameraNode;
|
||||
core::map<ISceneNode*, irr::core::stringw> CameraNodes;
|
||||
|
||||
// Check per name if stuff has been written already
|
||||
// TODO: second parameter not needed, we just don't have a core::set class yet in Irrlicht
|
||||
core::map<irr::core::stringw, bool> MaterialsWritten;
|
||||
core::map<irr::core::stringw, bool> EffectsWritten;
|
||||
|
||||
// Cache material names
|
||||
struct MaterialName
|
||||
{
|
||||
MaterialName(const irr::video::SMaterial & material, const irr::core::stringw& name)
|
||||
: Material(material), Name(name)
|
||||
{}
|
||||
irr::video::SMaterial Material;
|
||||
irr::core::stringw Name;
|
||||
};
|
||||
irr::core::array< MaterialName > MaterialNameCache;
|
||||
};
|
||||
|
||||
|
||||
} // end namespace
|
||||
} // end namespace
|
||||
|
||||
#endif
|
||||
@ -68,10 +68,6 @@
|
||||
#include "CMY3DMeshFileLoader.h"
|
||||
#endif
|
||||
|
||||
#ifdef _IRR_COMPILE_WITH_COLLADA_LOADER_
|
||||
#include "CColladaFileLoader.h"
|
||||
#endif
|
||||
|
||||
#ifdef _IRR_COMPILE_WITH_DMF_LOADER_
|
||||
#include "CDMFLoader.h"
|
||||
#endif
|
||||
@ -278,9 +274,6 @@ CSceneManager::CSceneManager(video::IVideoDriver* driver, io::IFileSystem* fs,
|
||||
#ifdef _IRR_COMPILE_WITH_BSP_LOADER_
|
||||
MeshLoaderList.push_back(new CBSPMeshFileLoader(this, FileSystem));
|
||||
#endif
|
||||
#ifdef _IRR_COMPILE_WITH_COLLADA_LOADER_
|
||||
MeshLoaderList.push_back(new CColladaFileLoader(this, FileSystem));
|
||||
#endif
|
||||
#ifdef _IRR_COMPILE_WITH_3DS_LOADER_
|
||||
MeshLoaderList.push_back(new C3DSMeshFileLoader(this, FileSystem));
|
||||
#endif
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user