Context Navigation

source: OGRE/trunk/ogrenew/OgreMain/include/OgreMeshManager.h @ 657

Revision 657, 20.5 KB checked in by mattausch, 19 years ago (diff)
added ogre dependencies and patched ogre sources

Rev	Line
[657]	1	/*
	2	-----------------------------------------------------------------------------
	3	This source file is part of OGRE
	4	(Object-oriented Graphics Rendering Engine)
	5	For the latest info, see http://www.ogre3d.org/
	6
	7	Copyright (c) 2000-2005 The OGRE Team
	8	Also see acknowledgements in Readme.html
	9
	10	This program is free software; you can redistribute it and/or modify it under
	11	the terms of the GNU Lesser General Public License as published by the Free Software
	12	Foundation; either version 2 of the License, or (at your option) any later
	13	version.
	14
	15	This program is distributed in the hope that it will be useful, but WITHOUT
	16	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
	17	FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
	18
	19	You should have received a copy of the GNU Lesser General Public License along with
	20	this program; if not, write to the Free Software Foundation, Inc., 59 Temple
	21	Place - Suite 330, Boston, MA 02111-1307, USA, or go to
	22	http://www.gnu.org/copyleft/lesser.txt.
	23	-----------------------------------------------------------------------------
	24	*/
	25	#ifndef __MeshManager_H__
	26	#define __MeshManager_H__
	27
	28	#include "OgrePrerequisites.h"
	29
	30	#include "OgreResourceManager.h"
	31	#include "OgreSingleton.h"
	32	#include "OgreVector3.h"
	33	#include "OgreHardwareBuffer.h"
	34	#include "OgreMesh.h"
	35	#include "OgrePatchMesh.h"
	36
	37	namespace Ogre {
	38
	39	/** Handles the management of mesh resources.
	40	@remarks
	41	This class deals with the runtime management of
	42	mesh data; like other resource managers it handles
	43	the creation of resources (in this case mesh data),
	44	working within a fixed memory budget.
	45	*/
	46	class _OgreExport MeshManager: public ResourceManager, public Singleton<MeshManager>,
	47	public ManualResourceLoader
	48	{
	49	public:
	50	MeshManager();
	51	~MeshManager();
	52
	53	/** Initialises the manager, only to be called by OGRE internally. */
	54	void _initialise(void);
	55
	56	/** Loads a mesh from a file, making it immediately available for use.
	57	@note
	58	If the model has already been loaded, the existing instance
	59	will be returned.
	60	@remarks
	61	Ogre loads model files from it's own proprietary
	62	format called .mesh. This is because having a single file
	63	format is better for runtime performance, and we also have
	64	control over pre-processed data (such as
	65	collision boxes, LOD reductions etc).
	66	@param filename The name of the .mesh file
	67	@param groupName The name of the resource group to assign the mesh to
	68	@param vertexBufferUsage The usage flags with which the vertex buffer(s)
	69	will be created
	70	@param indexBufferUsage The usage flags with which the index buffer(s) created for
	71	this mesh will be created with.
	72	@param vertexBufferShadowed If true, the vertex buffers will be shadowed by system memory
	73	copies for faster read access
	74	@param indexBufferShadowed If true, the index buffers will be shadowed by system memory
	75	copies for faster read access
	76	@param priority The priority of this mesh in the resource system
	77	*/
	78	MeshPtr load( const String& filename, const String& groupName,
	79	HardwareBuffer::Usage vertexBufferUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY,
	80	HardwareBuffer::Usage indexBufferUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY,
	81	bool vertexBufferShadowed = true, bool indexBufferShadowed = true);
	82
	83
	84	/** Creates a new Mesh specifically for manual definition rather
	85	than loading from an object file.
	86	@remarks
	87	Note that once you've defined your mesh, you must call Mesh::_setBounds and
	88	Mesh::_setBoundingRadius in order to define the bounds of your mesh. In previous
	89	versions of OGRE you could call Mesh::_updateBounds, but OGRE's support of
	90	write-only vertex buffers makes this no longer appropriate.
	91	@param name The name to give the new mesh
	92	@param groupName The name of the resource group to assign the mesh to
	93	@param loader ManualResourceLoader which will be called to load this mesh
	94	when the time comes. It is recommended that you populate this field
	95	in order that the mesh can be rebuilt should the need arise
	96	*/
	97	MeshPtr createManual( const String& name, const String& groupName,
	98	ManualResourceLoader* loader = 0);
	99
	100	/** Creates a basic plane, by default majoring on the x/y axes facing positive Z.
	101	@param
	102	name The name to give the resulting mesh
	103	@param
	104	groupName The name of the resource group to assign the mesh to
	105	@param
	106	plane The orientation of the plane and distance from the origin
	107	@param
	108	width The width of the plane in world coordinates
	109	@param
	110	height The height of the plane in world coordinates
	111	@param
	112	xsegments The number of segements to the plane in the x direction
	113	@param
	114	ysegments The number of segements to the plane in the y direction
	115	@param
	116	normals If true, normals are created perpendicular to the plane
	117	@param
	118	numTexCoordSets The number of 2D texture coordinate sets created - by default the corners
	119	are created to be the corner of the texture.
	120	@param
	121	uTile The number of times the texture should be repeated in the u direction
	122	@param
	123	vTile The number of times the texture should be repeated in the v direction
	124	@param
	125	upVector The 'Up' direction of the plane.
	126	@param
	127	vertexBufferUsage The usage flag with which the vertex buffer for this plane will be created
	128	@param
	129	indexBufferUsage The usage flag with which the index buffer for this plane will be created
	130	@param
	131	vertexShadowBuffer If this flag is set to true, the vertex buffer will be created
	132	with a system memory shadow buffer,
	133	allowing you to read it back more efficiently than if it is in hardware
	134	@param
	135	indexShadowBuffer If this flag is set to true, the index buffer will be
	136	created with a system memory shadow buffer,
	137	allowing you to read it back more efficiently than if it is in hardware
	138	*/
	139	MeshPtr createPlane(
	140	const String& name, const String& groupName, const Plane& plane,
	141	Real width, Real height,
	142	int xsegments = 1, int ysegments = 1,
	143	bool normals = true, int numTexCoordSets = 1,
	144	Real uTile = 1.0f, Real vTile = 1.0f, const Vector3& upVector = Vector3::UNIT_Y,
	145	HardwareBuffer::Usage vertexBufferUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY,
	146	HardwareBuffer::Usage indexBufferUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY,
	147	bool vertexShadowBuffer = true, bool indexShadowBuffer = true);
	148
	149
	150	/** Creates a plane, which because of it's texture coordinates looks like a curved
	151	surface, useful for skies in a skybox.
	152	@param
	153	name The name to give the resulting mesh
	154	@param
	155	groupName The name of the resource group to assign the mesh to
	156	@param
	157	plane The orientation of the plane and distance from the origin
	158	@param
	159	width The width of the plane in world coordinates
	160	@param
	161	height The height of the plane in world coordinates
	162	@param
	163	curvature The curvature of the plane. Good values are
	164	between 2 and 65. Higher values are more curved leading to
	165	a smoother effect, lower values are less curved meaning
	166	more distortion at the horizons but a better distance effect.
	167	@param
	168	xsegments The number of segements to the plane in the x direction
	169	@param
	170	ysegments The number of segements to the plane in the y direction
	171	@param
	172	normals If true, normals are created perpendicular to the plane
	173	@param
	174	numTexCoordSets The number of 2D texture coordinate sets created - by default the corners
	175	are created to be the corner of the texture.
	176	@param
	177	uTile The number of times the texture should be repeated in the u direction
	178	@param
	179	vTile The number of times the texture should be repeated in the v direction
	180	@param
	181	upVector The 'Up' direction of the plane.
	182	@param
	183	orientation The orientation of the overall sphere that's used to create the illusion
	184	@param
	185	vertexBufferUsage The usage flag with which the vertex buffer for this plane will be created
	186	@param
	187	indexBufferUsage The usage flag with which the index buffer for this plane will be created
	188	@param
	189	vertexShadowBuffer If this flag is set to true, the vertex buffer will be created
	190	with a system memory shadow buffer,
	191	allowing you to read it back more efficiently than if it is in hardware
	192	@param
	193	indexShadowBuffer If this flag is set to true, the index buffer will be
	194	created with a system memory shadow buffer,
	195	allowing you to read it back more efficiently than if it is in hardware
	196	@param ySegmentsToKeep The number of segments from the top of the dome
	197	downwards to keep. -1 keeps all of them. This can save fillrate if
	198	you cannot see much of the sky lower down.
	199	*/
	200	MeshPtr createCurvedIllusionPlane(
	201	const String& name, const String& groupName, const Plane& plane,
	202	Real width, Real height, Real curvature,
	203	int xsegments = 1, int ysegments = 1,
	204	bool normals = true, int numTexCoordSets = 1,
	205	Real uTile = 1.0f, Real vTile = 1.0f, const Vector3& upVector = Vector3::UNIT_Y,
	206	const Quaternion& orientation = Quaternion::IDENTITY,
	207	HardwareBuffer::Usage vertexBufferUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY,
	208	HardwareBuffer::Usage indexBufferUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY,
	209	bool vertexShadowBuffer = true, bool indexShadowBuffer = true,
	210	int ySegmentsToKeep = -1);
	211
	212	/** Creates a genuinely curved plane, by default majoring on the x/y axes facing positive Z.
	213	@param
	214	name The name to give the resulting mesh
	215	@param
	216	groupName The name of the resource group to assign the mesh to
	217	@param
	218	plane The orientation of the plane and distance from the origin
	219	@param
	220	width The width of the plane in world coordinates
	221	@param
	222	height The height of the plane in world coordinates
	223	@param
	224	bow The amount of 'bow' in the curved plane. (Could also be concidered the depth.)
	225	@param
	226	xsegments The number of segements to the plane in the x direction
	227	@param
	228	ysegments The number of segements to the plane in the y direction
	229	@param
	230	normals If true, normals are created perpendicular to the plane
	231	@param
	232	numTexCoordSets The number of 2D texture coordinate sets created - by default the corners
	233	are created to be the corner of the texture.
	234	@param
	235	uTile The number of times the texture should be repeated in the u direction
	236	@param
	237	vTile The number of times the texture should be repeated in the v direction
	238	@param
	239	upVector The 'Up' direction of the plane.
	240	@param
	241	vertexBufferUsage The usage flag with which the vertex buffer for this plane will be created
	242	@param
	243	indexBufferUsage The usage flag with which the index buffer for this plane will be created
	244	@param
	245	vertexShadowBuffer If this flag is set to true, the vertex buffer will be created
	246	with a system memory shadow buffer,
	247	allowing you to read it back more efficiently than if it is in hardware
	248	@param
	249	indexShadowBuffer If this flag is set to true, the index buffer will be
	250	created with a system memory shadow buffer,
	251	allowing you to read it back more efficiently than if it is in hardware
	252	*/
	253	MeshPtr createCurvedPlane(
	254	const String& name, const String& groupName, const Plane& plane,
	255	Real width, Real height, Real bow = 0.5f,
	256	int xsegments = 1, int ysegments = 1,
	257	bool normals = false, int numTexCoordSets = 1,
	258	Real xTile = 1.0f, Real yTile = 1.0f, const Vector3& upVector = Vector3::UNIT_Y,
	259	HardwareBuffer::Usage vertexBufferUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY,
	260	HardwareBuffer::Usage indexBufferUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY,
	261	bool vertexShadowBuffer = true, bool indexShadowBuffer = true);
	262
	263	/** Creates a Bezier patch based on an array of control vertices.
	264	@param
	265	name The name to give the newly created mesh.
	266	@param
	267	groupName The name of the resource group to assign the mesh to
	268	@param
	269	controlPointBuffer A pointer to a buffer containing the vertex data which defines control points
	270	of the curves rather than actual vertices. Note that you are expected to provide not
	271	just position information, but potentially normals and texture coordinates too. The
	272	format of the buffer is defined in the VertexDeclaration parameter
	273	@param
	274	decaration VertexDeclaration describing the contents of the buffer.
	275	Note this declaration must _only_ draw on buffer source 0!
	276	@param
	277	width Specifies the width of the patch in control points.
	278	Note this parameter must greater than or equal to 3.
	279	@param
	280	height Specifies the height of the patch in control points.
	281	Note this parameter must greater than or equal to 3.
	282	@param
	283	uMaxSubdivisionLevel,vMaxSubdivisionLevel If you want to manually set the top level of subdivision,
	284	do it here, otherwise let the system decide.
	285	@param
	286	visibleSide Determines which side of the patch (or both) triangles are generated for.
	287	@param
	288	vbUsage Vertex buffer usage flags. Recommend the default since vertex buffer should be static.
	289	@param
	290	ibUsage Index buffer usage flags. Recommend the default since index buffer should
	291	be dynamic to change levels but not readable.
	292	@param
	293	vbUseShadow Flag to determine if a shadow buffer is generated for the vertex buffer. See
	294	HardwareBuffer for full details.
	295	@param
	296	ibUseShadow Flag to determine if a shadow buffer is generated for the index buffer. See
	297	HardwareBuffer for full details.
	298	*/
	299	PatchMeshPtr createBezierPatch(
	300	const String& name, const String& groupName, void* controlPointBuffer,
	301	VertexDeclaration *declaration, size_t width, size_t height,
	302	size_t uMaxSubdivisionLevel = PatchSurface::AUTO_LEVEL,
	303	size_t vMaxSubdivisionLevel = PatchSurface::AUTO_LEVEL,
	304	PatchSurface::VisibleSide visibleSide = PatchSurface::VS_FRONT,
	305	HardwareBuffer::Usage vbUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY,
	306	HardwareBuffer::Usage ibUsage = HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY,
	307	bool vbUseShadow = true, bool ibUseShadow = true);
	308
	309	/** Tells the mesh manager that all future meshes should prepare themselves for
	310	shadow volumes on loading.
	311	*/
	312	void setPrepareAllMeshesForShadowVolumes(bool enable);
	313	/** Retrieves whether all Meshes should prepare themselves for shadow volumes. */
	314	bool getPrepareAllMeshesForShadowVolumes(void);
	315
	316	/** Override standard Singleton retrieval.
	317	@remarks
	318	Why do we do this? Well, it's because the Singleton
	319	implementation is in a .h file, which means it gets compiled
	320	into anybody who includes it. This is needed for the
	321	Singleton template to work, but we actually only want it
	322	compiled into the implementation of the class based on the
	323	Singleton, not all of them. If we don't change this, we get
	324	link errors when trying to use the Singleton-based class from
	325	an outside dll.
	326	@par
	327	This method just delegates to the template version anyway,
	328	but the implementation stays in this single compilation unit,
	329	preventing link errors.
	330	*/
	331	static MeshManager& getSingleton(void);
	332	/** Override standard Singleton retrieval.
	333	@remarks
	334	Why do we do this? Well, it's because the Singleton
	335	implementation is in a .h file, which means it gets compiled
	336	into anybody who includes it. This is needed for the
	337	Singleton template to work, but we actually only want it
	338	compiled into the implementation of the class based on the
	339	Singleton, not all of them. If we don't change this, we get
	340	link errors when trying to use the Singleton-based class from
	341	an outside dll.
	342	@par
	343	This method just delegates to the template version anyway,
	344	but the implementation stays in this single compilation unit,
	345	preventing link errors.
	346	*/
	347	static MeshManager* getSingletonPtr(void);
	348
	349	/** Gets the factor by which the bounding box of an entity is padded.
	350	Default is 0.01
	351	*/
	352	Real getBoundsPaddingFactor(void);
	353
	354	/** Sets the factor by which the bounding box of an entity is padded
	355	*/
	356	void setBoundsPaddingFactor(Real paddingFactor);
	357
	358	/** @see ManualResourceLoader::loadResource */
	359	void loadResource(Resource* res);
	360
	361	protected:
	362	/// @copydoc ResourceManager::createImpl
	363	Resource* createImpl(const String& name, ResourceHandle handle,
	364	const String& group, bool isManual, ManualResourceLoader* loader,
	365	const NameValuePairList* createParams);
	366
	367	/** Utility method for tesselating 2D meshes.
	368	*/
	369	void tesselate2DMesh(SubMesh* pSub, int meshWidth, int meshHeight,
	370	bool doubleSided = false,
	371	HardwareBuffer::Usage indexBufferUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY,
	372	bool indexSysMem = false);
	373
	374	void createPrefabPlane(void);
	375
	376	/** Enum identifying the types of manual mesh built by this manager */
	377	enum MeshBuildType
	378	{
	379	MBT_PLANE,
	380	MBT_CURVED_ILLUSION_PLANE,
	381	MBT_CURVED_PLANE
	382	};
	383	/** Saved parameters used to (re)build a manual mesh built by this class */
	384	struct MeshBuildParams
	385	{
	386	MeshBuildType type;
	387	Plane plane;
	388	Real width;
	389	Real height;
	390	Real curvature;
	391	int xsegments;
	392	int ysegments;
	393	bool normals;
	394	int numTexCoordSets;
	395	Real xTile;
	396	Real yTile;
	397	Vector3 upVector;
	398	Quaternion orientation;
	399	HardwareBuffer::Usage vertexBufferUsage;
	400	HardwareBuffer::Usage indexBufferUsage;
	401	bool vertexShadowBuffer;
	402	bool indexShadowBuffer;
	403	int ySegmentsToKeep;
	404	};
	405	/** Map from resource pointer to parameter set */
	406	typedef std::map<Resource*, MeshBuildParams> MeshBuildParamsMap;
	407	MeshBuildParamsMap mMeshBuildParams;
	408
	409	/** Utility method for manual loading a plane */
	410	void loadManualPlane(Mesh* pMesh, MeshBuildParams& params);
	411	/** Utility method for manual loading a curved plane */
	412	void loadManualCurvedPlane(Mesh* pMesh, MeshBuildParams& params);
	413	/** Utility method for manual loading a curved illusion plane */
	414	void loadManualCurvedIllusionPlane(Mesh* pMesh, MeshBuildParams& params);
	415
	416	bool mPrepAllMeshesForShadowVolumes;
	417
	418	//the factor by which the bounding box of an entity is padded
	419	Real mBoundsPaddingFactor;
	420	};
	421
	422
	423	} //namespace
	424
	425	#endif

Note: See TracBrowser for help on using the repository browser.

Download in other formats: