Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: code/branches/ode/ode-0.9/OPCODE/OPC_MeshInterface.h @ 216

Last change on this file since 216 was 216, checked in by mathiask, 17 years ago
[Physik] add ode-0.9
File size: 10.0 KB

Line
1	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2	/*
3	* OPCODE - Optimized Collision Detection
4	* Copyright (C) 2001 Pierre Terdiman
5	* Homepage: http://www.codercorner.com/Opcode.htm
6	*/
7	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
8
9	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
10	/**
11	* Contains a mesh interface.
12	* \file OPC_MeshInterface.h
13	* \author Pierre Terdiman
14	* \date November, 27, 2002
15	*/
16	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
17
18	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
19	// Include Guard
20	#ifndef __OPC_MESHINTERFACE_H__
21	#define __OPC_MESHINTERFACE_H__
22
23	struct VertexPointers
24	{
25	const Point* Vertex[3];
26
27	bool BackfaceCulling(const Point& source)
28	{
29	const Point& p0 = *Vertex[0];
30	const Point& p1 = *Vertex[1];
31	const Point& p2 = *Vertex[2];
32
33	// Compute normal direction
34	Point Normal = (p2 - p1)^(p0 - p1);
35
36	// Backface culling
37	return (Normal \| (source - p0)) >= 0.0f;
38	}
39	};
40
41	#ifdef OPC_USE_CALLBACKS
42	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
43	/**
44	* User-callback, called by OPCODE to request vertices from the app.
45	* \param triangle_index [in] face index for which the system is requesting the vertices
46	* \param triangle [out] triangle's vertices (must be provided by the user)
47	* \param user_data [in] user-defined data from SetCallback()
48	*/
49	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
50	typedef void (RequestCallback) (udword triangle_index, VertexPointers& triangle, void user_data);
51	#endif
52
53	class OPCODE_API MeshInterface
54	{
55	public:
56	// Constructor / Destructor
57	MeshInterface();
58	~MeshInterface();
59	// Common settings
60	inline_ udword GetNbTriangles() const { return mNbTris; }
61	inline_ udword GetNbVertices() const { return mNbVerts; }
62	inline_ void SetNbTriangles(udword nb) { mNbTris = nb; }
63	inline_ void SetNbVertices(udword nb) { mNbVerts = nb; }
64
65	#ifdef OPC_USE_CALLBACKS
66	// Callback settings
67
68	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
69	/**
70	* Callback control: setups object callback. Must provide triangle-vertices for a given triangle index.
71	* \param callback [in] user-defined callback
72	* \param user_data [in] user-defined data
73	* \return true if success
74	*/
75	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
76	bool SetCallback(RequestCallback callback, void* user_data);
77	inline_ void* GetUserData() const { return mUserData; }
78	inline_ RequestCallback GetCallback() const { return mObjCallback; }
79	#else
80	// Pointers settings
81
82	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
83	/**
84	* Pointers control: setups object pointers. Must provide access to faces and vertices for a given object.
85	* \param tris [in] pointer to triangles
86	* \param verts [in] pointer to vertices
87	* \return true if success
88	*/
89	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
90	bool SetPointers(const IndexedTriangle* tris, const Point* verts);
91	inline_ const IndexedTriangle* GetTris() const { return mTris; }
92	inline_ const Point* GetVerts() const { return mVerts; }
93
94	#ifdef OPC_USE_STRIDE
95	// Strides settings
96
97	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
98	/**
99	* Strides control
100	* \param tri_stride [in] size of a triangle in bytes. The first sizeof(IndexedTriangle) bytes are used to get vertex indices.
101	* \param vertex_stride [in] size of a vertex in bytes. The first sizeof(Point) bytes are used to get vertex position.
102	* \return true if success
103	*/
104	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
105	bool SetStrides(udword tri_stride=sizeof(IndexedTriangle), udword vertex_stride=sizeof(Point));
106	inline_ udword GetTriStride() const { return mTriStride; }
107	inline_ udword GetVertexStride() const { return mVertexStride; }
108	#endif
109	#endif
110
111	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
112	/**
113	* Fetches a triangle given a triangle index.
114	* \param vp [out] required triangle's vertex pointers
115	* \param index [in] triangle index
116	*/
117	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
118	inline_ void GetTriangle(VertexPointers& vp, udword index) const
119	{
120	#ifdef OPC_USE_CALLBACKS
121	(mObjCallback)(index, vp, mUserData);
122	#else
123	#ifdef OPC_USE_STRIDE
124	const IndexedTriangle* T = (const IndexedTriangle)(((ubyte)mTris) + index * mTriStride);
125
126	if (Single){
127	vp.Vertex[0] = (const Point)(((ubyte)mVerts) + T->mVRef[0] * mVertexStride);
128	vp.Vertex[1] = (const Point)(((ubyte)mVerts) + T->mVRef[1] * mVertexStride);
129	vp.Vertex[2] = (const Point)(((ubyte)mVerts) + T->mVRef[2] * mVertexStride);
130	}
131	else{
132	for (int i = 0; i < 3; i++){
133	const double* v = (const double)(((ubyte)mVerts) + T->mVRef[i] * mVertexStride);
134
135	VertexCache[i].x = (float)v[0];
136	VertexCache[i].y = (float)v[1];
137	VertexCache[i].z = (float)v[2];
138	vp.Vertex[i] = &VertexCache[i];
139	}
140	}
141	#else
142	const IndexedTriangle* T = &mTris[index];
143	vp.Vertex[0] = &mVerts[T->mVRef[0]];
144	vp.Vertex[1] = &mVerts[T->mVRef[1]];
145	vp.Vertex[2] = &mVerts[T->mVRef[2]];
146	#endif
147	#endif
148	}
149
150	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
151	/**
152	* Remaps client's mesh according to a permutation.
153	* \param nb_indices [in] number of indices in the permutation (will be checked against number of triangles)
154	* \param permutation [in] list of triangle indices
155	* \return true if success
156	*/
157	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
158	bool RemapClient(udword nb_indices, const udword* permutation) const;
159
160	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
161	/**
162	* Checks the mesh interface is valid, i.e. things have been setup correctly.
163	* \return true if valid
164	*/
165	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
166	bool IsValid() const;
167
168	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
169	/**
170	* Checks the mesh itself is valid.
171	* Currently we only look for degenerate faces.
172	* \return number of degenerate faces
173	*/
174	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
175	udword CheckTopology() const;
176	private:
177
178	udword mNbTris; //!< Number of triangles in the input model
179	udword mNbVerts; //!< Number of vertices in the input model
180	#ifdef OPC_USE_CALLBACKS
181	// User callback
182	void* mUserData; //!< User-defined data sent to callback
183	RequestCallback mObjCallback; //!< Object callback
184	#else
185	// User pointers
186	const IndexedTriangle* mTris; //!< Array of indexed triangles
187	const Point* mVerts; //!< Array of vertices
188	#ifdef OPC_USE_STRIDE
189	udword mTriStride; //!< Possible triangle stride in bytes [Opcode 1.3]
190	udword mVertexStride; //!< Possible vertex stride in bytes [Opcode 1.3]
191	#endif
192	public:
193	bool Single; //!< Use single or double precision vertices
194	private:
195	static Point VertexCache[3];
196	#endif
197	};
198
199	#endif //__OPC_MESHINTERFACE_H__

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

Download in other formats: