~jtaylor/ubuntu/oneiric/soya/fix-780305

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

* OPCODE - Optimized Collision Detection

* Homepage: http://www.codercorner.com/Opcode.htm

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

* Contains a mesh interface.

* \file OPC_MeshInterface.h

* \author Pierre Terdiman

* \date November, 27, 2002

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Include Guard

#ifndef __OPC_MESHINTERFACE_H__

#define __OPC_MESHINTERFACE_H__

struct VertexPointers

{

const Point* Vertex[3];

bool BackfaceCulling(const Point& source)

{

const Point& p0 = *Vertex[0];

const Point& p1 = *Vertex[1];

const Point& p2 = *Vertex[2];

// Compute normal direction

Point Normal = (p2 - p1)^(p0 - p1);

// Backface culling

return (Normal | (source - p0)) >= 0.0f;

}

};

#ifdef OPC_USE_CALLBACKS

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

* User-callback, called by OPCODE to request vertices from the app.

* \param triangle_index [in] face index for which the system is requesting the vertices

* \param triangle [out] triangle's vertices (must be provided by the user)

* \param user_data [in] user-defined data from SetCallback()

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

typedef void (*RequestCallback) (udword triangle_index, VertexPointers& triangle, void* user_data);

#endif

class OPCODE_API MeshInterface

{

public:

// Constructor / Destructor

MeshInterface();

~MeshInterface();

// Common settings

inline_ udword GetNbTriangles() const { return mNbTris; }

inline_ udword GetNbVertices() const { return mNbVerts; }

inline_ void SetNbTriangles(udword nb) { mNbTris = nb; }

inline_ void SetNbVertices(udword nb) { mNbVerts = nb; }

#ifdef OPC_USE_CALLBACKS

// Callback settings

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

* Callback control: setups object callback. Must provide triangle-vertices for a given triangle index.

* \param callback [in] user-defined callback

* \param user_data [in] user-defined data

* \return true if success

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

bool SetCallback(RequestCallback callback, void* user_data);

inline_ void* GetUserData() const { return mUserData; }

inline_ RequestCallback GetCallback() const { return mObjCallback; }

#else

// Pointers settings

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

* Pointers control: setups object pointers. Must provide access to faces and vertices for a given object.

* \param tris [in] pointer to triangles

* \param verts [in] pointer to vertices

* \return true if success

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

bool SetPointers(const IndexedTriangle* tris, const Point* verts);

inline_ const IndexedTriangle* GetTris() const { return mTris; }

inline_ const Point* GetVerts() const { return mVerts; }

#ifdef OPC_USE_STRIDE

// Strides settings

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/**

* 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__

Older »