~ubuntu-branches/ubuntu/precise/openarena/precise

void ( APIENTRY * qglCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);

126

void ( APIENTRY * qglCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);

127

void ( APIENTRY * qglCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);

128

void ( APIENTRY * qglCullFace )(GLenum mode);

129

void ( APIENTRY * qglDeleteLists )(GLuint list, GLsizei range);

130

void ( APIENTRY * qglDeleteTextures )(GLsizei n, const GLuint *textures);

131

void ( APIENTRY * qglDepthFunc )(GLenum func);

132

void ( APIENTRY * qglDepthMask )(GLboolean flag);

133

void ( APIENTRY * qglDepthRange )(GLclampd zNear, GLclampd zFar);

134

void ( APIENTRY * qglDisable )(GLenum cap);

135

void ( APIENTRY * qglDisableClientState )(GLenum array);

136

void ( APIENTRY * qglDrawArrays )(GLenum mode, GLint first, GLsizei count);

137

void ( APIENTRY * qglDrawBuffer )(GLenum mode);

138

void ( APIENTRY * qglDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);

139

void ( APIENTRY * qglDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);

140

void ( APIENTRY * qglEdgeFlag )(GLboolean flag);

141

void ( APIENTRY * qglEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);

142

void ( APIENTRY * qglEdgeFlagv )(const GLboolean *flag);

143

void ( APIENTRY * qglEnable )(GLenum cap);

144

void ( APIENTRY * qglEnableClientState )(GLenum array);

145

void ( APIENTRY * qglEnd )(void);

146

void ( APIENTRY * qglEndList )(void);

147

void ( APIENTRY * qglEvalCoord1d )(GLdouble u);

148

void ( APIENTRY * qglEvalCoord1dv )(const GLdouble *u);

149

void ( APIENTRY * qglEvalCoord1f )(GLfloat u);

150

void ( APIENTRY * qglEvalCoord1fv )(const GLfloat *u);

151

void ( APIENTRY * qglEvalCoord2d )(GLdouble u, GLdouble v);

152

void ( APIENTRY * qglEvalCoord2dv )(const GLdouble *u);

153

void ( APIENTRY * qglEvalCoord2f )(GLfloat u, GLfloat v);

154

void ( APIENTRY * qglEvalCoord2fv )(const GLfloat *u);

155

void ( APIENTRY * qglEvalMesh1 )(GLenum mode, GLint i1, GLint i2);

156

void ( APIENTRY * qglEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);

157

void ( APIENTRY * qglEvalPoint1 )(GLint i);

158

void ( APIENTRY * qglEvalPoint2 )(GLint i, GLint j);

159

void ( APIENTRY * qglFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);

160

void ( APIENTRY * qglFinish )(void);

161

void ( APIENTRY * qglFlush )(void);

162

void ( APIENTRY * qglFogf )(GLenum pname, GLfloat param);

163

void ( APIENTRY * qglFogfv )(GLenum pname, const GLfloat *params);

164

void ( APIENTRY * qglFogi )(GLenum pname, GLint param);

165

void ( APIENTRY * qglFogiv )(GLenum pname, const GLint *params);

166

void ( APIENTRY * qglFrontFace )(GLenum mode);

167

void ( APIENTRY * qglFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);

168

GLuint ( APIENTRY * qglGenLists )(GLsizei range);

169

void ( APIENTRY * qglGenTextures )(GLsizei n, GLuint *textures);

170

void ( APIENTRY * qglGetBooleanv )(GLenum pname, GLboolean *params);

171

void ( APIENTRY * qglGetClipPlane )(GLenum plane, GLdouble *equation);

172

void ( APIENTRY * qglGetDoublev )(GLenum pname, GLdouble *params);

173

GLenum ( APIENTRY * qglGetError )(void);

174

void ( APIENTRY * qglGetFloatv )(GLenum pname, GLfloat *params);

175

void ( APIENTRY * qglGetIntegerv )(GLenum pname, GLint *params);

176

void ( APIENTRY * qglGetLightfv )(GLenum light, GLenum pname, GLfloat *params);

177

void ( APIENTRY * qglGetLightiv )(GLenum light, GLenum pname, GLint *params);

178

void ( APIENTRY * qglGetMapdv )(GLenum target, GLenum query, GLdouble *v);

179

void ( APIENTRY * qglGetMapfv )(GLenum target, GLenum query, GLfloat *v);

180

void ( APIENTRY * qglGetMapiv )(GLenum target, GLenum query, GLint *v);

181

void ( APIENTRY * qglGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);

182

void ( APIENTRY * qglGetMaterialiv )(GLenum face, GLenum pname, GLint *params);

183

void ( APIENTRY * qglGetPixelMapfv )(GLenum map, GLfloat *values);

184

void ( APIENTRY * qglGetPixelMapuiv )(GLenum map, GLuint *values);

185

void ( APIENTRY * qglGetPixelMapusv )(GLenum map, GLushort *values);

186

void ( APIENTRY * qglGetPointerv )(GLenum pname, GLvoid* *params);

187

void ( APIENTRY * qglGetPolygonStipple )(GLubyte *mask);

188

const GLubyte * ( APIENTRY * qglGetString )(GLenum name);

189

void ( APIENTRY * qglGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);

190

void ( APIENTRY * qglGetTexEnviv )(GLenum target, GLenum pname, GLint *params);

191

void ( APIENTRY * qglGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);

192

void ( APIENTRY * qglGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);

193

void ( APIENTRY * qglGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);

194

void ( APIENTRY * qglGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);

195

void ( APIENTRY * qglGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);

196

void ( APIENTRY * qglGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);

197

void ( APIENTRY * qglGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);

198

void ( APIENTRY * qglGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);

199

void ( APIENTRY * qglHint )(GLenum target, GLenum mode);

200

void ( APIENTRY * qglIndexMask )(GLuint mask);

201

void ( APIENTRY * qglIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);

202

void ( APIENTRY * qglIndexd )(GLdouble c);

203

void ( APIENTRY * qglIndexdv )(const GLdouble *c);

204

void ( APIENTRY * qglIndexf )(GLfloat c);

205

void ( APIENTRY * qglIndexfv )(const GLfloat *c);

206

void ( APIENTRY * qglIndexi )(GLint c);

207

void ( APIENTRY * qglIndexiv )(const GLint *c);

208

void ( APIENTRY * qglIndexs )(GLshort c);

209

void ( APIENTRY * qglIndexsv )(const GLshort *c);

210

void ( APIENTRY * qglIndexub )(GLubyte c);

211

void ( APIENTRY * qglIndexubv )(const GLubyte *c);

212

void ( APIENTRY * qglInitNames )(void);

213

void ( APIENTRY * qglInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);

214

GLboolean ( APIENTRY * qglIsEnabled )(GLenum cap);

215

GLboolean ( APIENTRY * qglIsList )(GLuint list);

216

GLboolean ( APIENTRY * qglIsTexture )(GLuint texture);

217

void ( APIENTRY * qglLightModelf )(GLenum pname, GLfloat param);

218

void ( APIENTRY * qglLightModelfv )(GLenum pname, const GLfloat *params);

219

void ( APIENTRY * qglLightModeli )(GLenum pname, GLint param);

220

void ( APIENTRY * qglLightModeliv )(GLenum pname, const GLint *params);

221

void ( APIENTRY * qglLightf )(GLenum light, GLenum pname, GLfloat param);

222

void ( APIENTRY * qglLightfv )(GLenum light, GLenum pname, const GLfloat *params);

223

void ( APIENTRY * qglLighti )(GLenum light, GLenum pname, GLint param);

224

void ( APIENTRY * qglLightiv )(GLenum light, GLenum pname, const GLint *params);

225

void ( APIENTRY * qglLineStipple )(GLint factor, GLushort pattern);

226

void ( APIENTRY * qglLineWidth )(GLfloat width);

227

void ( APIENTRY * qglListBase )(GLuint base);

228

void ( APIENTRY * qglLoadIdentity )(void);

229

void ( APIENTRY * qglLoadMatrixd )(const GLdouble *m);

230

void ( APIENTRY * qglLoadMatrixf )(const GLfloat *m);

231

void ( APIENTRY * qglLoadName )(GLuint name);

232

void ( APIENTRY * qglLogicOp )(GLenum opcode);

233

void ( APIENTRY * qglMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);

234

void ( APIENTRY * qglMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);

235

void ( APIENTRY * qglMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);

236

void ( APIENTRY * qglMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);

237

void ( APIENTRY * qglMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);

238

void ( APIENTRY * qglMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);

239

void ( APIENTRY * qglMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);

240

void ( APIENTRY * qglMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);

241

void ( APIENTRY * qglMaterialf )(GLenum face, GLenum pname, GLfloat param);

242

void ( APIENTRY * qglMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);

243

void ( APIENTRY * qglMateriali )(GLenum face, GLenum pname, GLint param);

244

void ( APIENTRY * qglMaterialiv )(GLenum face, GLenum pname, const GLint *params);

245

void ( APIENTRY * qglMatrixMode )(GLenum mode);

246

void ( APIENTRY * qglMultMatrixd )(const GLdouble *m);

247

void ( APIENTRY * qglMultMatrixf )(const GLfloat *m);

248

void ( APIENTRY * qglNewList )(GLuint list, GLenum mode);

249

void ( APIENTRY * qglNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);

250

void ( APIENTRY * qglNormal3bv )(const GLbyte *v);

251

void ( APIENTRY * qglNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);

252

void ( APIENTRY * qglNormal3dv )(const GLdouble *v);

253

void ( APIENTRY * qglNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);

254

void ( APIENTRY * qglNormal3fv )(const GLfloat *v);

255

void ( APIENTRY * qglNormal3i )(GLint nx, GLint ny, GLint nz);

256

void ( APIENTRY * qglNormal3iv )(const GLint *v);

257

void ( APIENTRY * qglNormal3s )(GLshort nx, GLshort ny, GLshort nz);

258

void ( APIENTRY * qglNormal3sv )(const GLshort *v);

259

void ( APIENTRY * qglNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);

260

void ( APIENTRY * qglOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);

261

void ( APIENTRY * qglPassThrough )(GLfloat token);

262

void ( APIENTRY * qglPixelMapfv )(GLenum map, GLsizei mapsize, const GLfloat *values);

263

void ( APIENTRY * qglPixelMapuiv )(GLenum map, GLsizei mapsize, const GLuint *values);

264

void ( APIENTRY * qglPixelMapusv )(GLenum map, GLsizei mapsize, const GLushort *values);

265

void ( APIENTRY * qglPixelStoref )(GLenum pname, GLfloat param);

266

void ( APIENTRY * qglPixelStorei )(GLenum pname, GLint param);

267

void ( APIENTRY * qglPixelTransferf )(GLenum pname, GLfloat param);

268

void ( APIENTRY * qglPixelTransferi )(GLenum pname, GLint param);

269

void ( APIENTRY * qglPixelZoom )(GLfloat xfactor, GLfloat yfactor);

270

void ( APIENTRY * qglPointSize )(GLfloat size);

271

void ( APIENTRY * qglPolygonMode )(GLenum face, GLenum mode);

272

void ( APIENTRY * qglPolygonOffset )(GLfloat factor, GLfloat units);

273

void ( APIENTRY * qglPolygonStipple )(const GLubyte *mask);

274

void ( APIENTRY * qglPopAttrib )(void);

275

void ( APIENTRY * qglPopClientAttrib )(void);

276

void ( APIENTRY * qglPopMatrix )(void);

277

void ( APIENTRY * qglPopName )(void);

278

void ( APIENTRY * qglPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);

279

void ( APIENTRY * qglPushAttrib )(GLbitfield mask);

280

void ( APIENTRY * qglPushClientAttrib )(GLbitfield mask);

281

void ( APIENTRY * qglPushMatrix )(void);

282

void ( APIENTRY * qglPushName )(GLuint name);

283

void ( APIENTRY * qglRasterPos2d )(GLdouble x, GLdouble y);

284

void ( APIENTRY * qglRasterPos2dv )(const GLdouble *v);

285

void ( APIENTRY * qglRasterPos2f )(GLfloat x, GLfloat y);

286

void ( APIENTRY * qglRasterPos2fv )(const GLfloat *v);

287

void ( APIENTRY * qglRasterPos2i )(GLint x, GLint y);

288

void ( APIENTRY * qglRasterPos2iv )(const GLint *v);

289

void ( APIENTRY * qglRasterPos2s )(GLshort x, GLshort y);

290

void ( APIENTRY * qglRasterPos2sv )(const GLshort *v);

291

void ( APIENTRY * qglRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);

292

void ( APIENTRY * qglRasterPos3dv )(const GLdouble *v);

293

void ( APIENTRY * qglRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);

294

void ( APIENTRY * qglRasterPos3fv )(const GLfloat *v);

295

void ( APIENTRY * qglRasterPos3i )(GLint x, GLint y, GLint z);

296

void ( APIENTRY * qglRasterPos3iv )(const GLint *v);

297

void ( APIENTRY * qglRasterPos3s )(GLshort x, GLshort y, GLshort z);

298

void ( APIENTRY * qglRasterPos3sv )(const GLshort *v);

299

void ( APIENTRY * qglRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);

300

void ( APIENTRY * qglRasterPos4dv )(const GLdouble *v);

301

void ( APIENTRY * qglRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);

302

void ( APIENTRY * qglRasterPos4fv )(const GLfloat *v);

303

void ( APIENTRY * qglRasterPos4i )(GLint x, GLint y, GLint z, GLint w);

304

void ( APIENTRY * qglRasterPos4iv )(const GLint *v);

305

void ( APIENTRY * qglRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);

306

void ( APIENTRY * qglRasterPos4sv )(const GLshort *v);

307

void ( APIENTRY * qglReadBuffer )(GLenum mode);

308

void ( APIENTRY * qglReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);

309

void ( APIENTRY * qglRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);

310

void ( APIENTRY * qglRectdv )(const GLdouble *v1, const GLdouble *v2);

311

void ( APIENTRY * qglRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);

312

void ( APIENTRY * qglRectfv )(const GLfloat *v1, const GLfloat *v2);

313

void ( APIENTRY * qglRecti )(GLint x1, GLint y1, GLint x2, GLint y2);

314

void ( APIENTRY * qglRectiv )(const GLint *v1, const GLint *v2);

315

void ( APIENTRY * qglRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);

316

void ( APIENTRY * qglRectsv )(const GLshort *v1, const GLshort *v2);

317

GLint ( APIENTRY * qglRenderMode )(GLenum mode);

318

void ( APIENTRY * qglRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);

319

void ( APIENTRY * qglRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);

320

void ( APIENTRY * qglScaled )(GLdouble x, GLdouble y, GLdouble z);

321

void ( APIENTRY * qglScalef )(GLfloat x, GLfloat y, GLfloat z);

322

void ( APIENTRY * qglScissor )(GLint x, GLint y, GLsizei width, GLsizei height);

323

void ( APIENTRY * qglSelectBuffer )(GLsizei size, GLuint *buffer);

324

void ( APIENTRY * qglShadeModel )(GLenum mode);

325

void ( APIENTRY * qglStencilFunc )(GLenum func, GLint ref, GLuint mask);

326

void ( APIENTRY * qglStencilMask )(GLuint mask);

327

void ( APIENTRY * qglStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);

328

void ( APIENTRY * qglTexCoord1d )(GLdouble s);

329

void ( APIENTRY * qglTexCoord1dv )(const GLdouble *v);

330

void ( APIENTRY * qglTexCoord1f )(GLfloat s);

331

void ( APIENTRY * qglTexCoord1fv )(const GLfloat *v);

332

void ( APIENTRY * qglTexCoord1i )(GLint s);

333

void ( APIENTRY * qglTexCoord1iv )(const GLint *v);

334

void ( APIENTRY * qglTexCoord1s )(GLshort s);

335

void ( APIENTRY * qglTexCoord1sv )(const GLshort *v);

336

void ( APIENTRY * qglTexCoord2d )(GLdouble s, GLdouble t);

337

void ( APIENTRY * qglTexCoord2dv )(const GLdouble *v);

338

void ( APIENTRY * qglTexCoord2f )(GLfloat s, GLfloat t);

339

void ( APIENTRY * qglTexCoord2fv )(const GLfloat *v);

340

void ( APIENTRY * qglTexCoord2i )(GLint s, GLint t);

341

void ( APIENTRY * qglTexCoord2iv )(const GLint *v);

342

void ( APIENTRY * qglTexCoord2s )(GLshort s, GLshort t);

343

void ( APIENTRY * qglTexCoord2sv )(const GLshort *v);

344

void ( APIENTRY * qglTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);

345

void ( APIENTRY * qglTexCoord3dv )(const GLdouble *v);

346

void ( APIENTRY * qglTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);

347

void ( APIENTRY * qglTexCoord3fv )(const GLfloat *v);

348

void ( APIENTRY * qglTexCoord3i )(GLint s, GLint t, GLint r);

349

void ( APIENTRY * qglTexCoord3iv )(const GLint *v);

350

void ( APIENTRY * qglTexCoord3s )(GLshort s, GLshort t, GLshort r);

351

void ( APIENTRY * qglTexCoord3sv )(const GLshort *v);

352

void ( APIENTRY * qglTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);

353

void ( APIENTRY * qglTexCoord4dv )(const GLdouble *v);

354

void ( APIENTRY * qglTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);

355

void ( APIENTRY * qglTexCoord4fv )(const GLfloat *v);

356

void ( APIENTRY * qglTexCoord4i )(GLint s, GLint t, GLint r, GLint q);

357

void ( APIENTRY * qglTexCoord4iv )(const GLint *v);

358

void ( APIENTRY * qglTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);

359

void ( APIENTRY * qglTexCoord4sv )(const GLshort *v);

360

void ( APIENTRY * qglTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);

361

void ( APIENTRY * qglTexEnvf )(GLenum target, GLenum pname, GLfloat param);

362

void ( APIENTRY * qglTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);

363

void ( APIENTRY * qglTexEnvi )(GLenum target, GLenum pname, GLint param);

364

void ( APIENTRY * qglTexEnviv )(GLenum target, GLenum pname, const GLint *params);

365

void ( APIENTRY * qglTexGend )(GLenum coord, GLenum pname, GLdouble param);

366

void ( APIENTRY * qglTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);

367

void ( APIENTRY * qglTexGenf )(GLenum coord, GLenum pname, GLfloat param);

368

void ( APIENTRY * qglTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);

369

void ( APIENTRY * qglTexGeni )(GLenum coord, GLenum pname, GLint param);

370

void ( APIENTRY * qglTexGeniv )(GLenum coord, GLenum pname, const GLint *params);

371

void ( APIENTRY * qglTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);

372

void ( APIENTRY * qglTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);

373

void ( APIENTRY * qglTexParameterf )(GLenum target, GLenum pname, GLfloat param);

374

void ( APIENTRY * qglTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);

375

void ( APIENTRY * qglTexParameteri )(GLenum target, GLenum pname, GLint param);

376

void ( APIENTRY * qglTexParameteriv )(GLenum target, GLenum pname, const GLint *params);

377

void ( APIENTRY * qglTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);

378

void ( APIENTRY * qglTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);

379

void ( APIENTRY * qglTranslated )(GLdouble x, GLdouble y, GLdouble z);

380

void ( APIENTRY * qglTranslatef )(GLfloat x, GLfloat y, GLfloat z);

381

void ( APIENTRY * qglVertex2d )(GLdouble x, GLdouble y);

382

void ( APIENTRY * qglVertex2dv )(const GLdouble *v);

383

void ( APIENTRY * qglVertex2f )(GLfloat x, GLfloat y);

384

void ( APIENTRY * qglVertex2fv )(const GLfloat *v);

385

void ( APIENTRY * qglVertex2i )(GLint x, GLint y);

386

void ( APIENTRY * qglVertex2iv )(const GLint *v);

387

void ( APIENTRY * qglVertex2s )(GLshort x, GLshort y);

388

void ( APIENTRY * qglVertex2sv )(const GLshort *v);

389

void ( APIENTRY * qglVertex3d )(GLdouble x, GLdouble y, GLdouble z);

390

void ( APIENTRY * qglVertex3dv )(const GLdouble *v);

391

void ( APIENTRY * qglVertex3f )(GLfloat x, GLfloat y, GLfloat z);

392

void ( APIENTRY * qglVertex3fv )(const GLfloat *v);

393

void ( APIENTRY * qglVertex3i )(GLint x, GLint y, GLint z);

394

void ( APIENTRY * qglVertex3iv )(const GLint *v);

395

void ( APIENTRY * qglVertex3s )(GLshort x, GLshort y, GLshort z);

396

void ( APIENTRY * qglVertex3sv )(const GLshort *v);

397

void ( APIENTRY * qglVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);

398

void ( APIENTRY * qglVertex4dv )(const GLdouble *v);

399

void ( APIENTRY * qglVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);

400

void ( APIENTRY * qglVertex4fv )(const GLfloat *v);

401

void ( APIENTRY * qglVertex4i )(GLint x, GLint y, GLint z, GLint w);

402

void ( APIENTRY * qglVertex4iv )(const GLint *v);

403

void ( APIENTRY * qglVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);

404

void ( APIENTRY * qglVertex4sv )(const GLshort *v);

405

void ( APIENTRY * qglVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);

406

void ( APIENTRY * qglViewport )(GLint x, GLint y, GLsizei width, GLsizei height);

407

408

void ( APIENTRY * qglMultiTexCoord2fARB )( GLenum texture, GLfloat s, GLfloat t );

409

void ( APIENTRY * qglActiveTextureARB )( GLenum texture );

410

void ( APIENTRY * qglClientActiveTextureARB )( GLenum texture );

411

412

void ( APIENTRY * qglLockArraysEXT)( GLint, GLint);

413

void ( APIENTRY * qglUnlockArraysEXT) ( void );

414

415

416

static void ( APIENTRY * dllAccum )(GLenum op, GLfloat value);

417

static void ( APIENTRY * dllAlphaFunc )(GLenum func, GLclampf ref);

418

GLboolean ( APIENTRY * dllAreTexturesResident )(GLsizei n, const GLuint *textures, GLboolean *residences);

419

static void ( APIENTRY * dllArrayElement )(GLint i);

420

static void ( APIENTRY * dllBegin )(GLenum mode);

421

static void ( APIENTRY * dllBindTexture )(GLenum target, GLuint texture);

422

static void ( APIENTRY * dllBitmap )(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);

423

static void ( APIENTRY * dllBlendFunc )(GLenum sfactor, GLenum dfactor);

424

static void ( APIENTRY * dllCallList )(GLuint list);

425

static void ( APIENTRY * dllCallLists )(GLsizei n, GLenum type, const GLvoid *lists);

426

static void ( APIENTRY * dllClear )(GLbitfield mask);

427

static void ( APIENTRY * dllClearAccum )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);

428

static void ( APIENTRY * dllClearColor )(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);

429

static void ( APIENTRY * dllClearDepth )(GLclampd depth);

430

static void ( APIENTRY * dllClearIndex )(GLfloat c);

431

static void ( APIENTRY * dllClearStencil )(GLint s);

432

static void ( APIENTRY * dllClipPlane )(GLenum plane, const GLdouble *equation);

433

static void ( APIENTRY * dllColor3b )(GLbyte red, GLbyte green, GLbyte blue);

434

static void ( APIENTRY * dllColor3bv )(const GLbyte *v);

435

static void ( APIENTRY * dllColor3d )(GLdouble red, GLdouble green, GLdouble blue);

436

static void ( APIENTRY * dllColor3dv )(const GLdouble *v);

437

static void ( APIENTRY * dllColor3f )(GLfloat red, GLfloat green, GLfloat blue);

438

static void ( APIENTRY * dllColor3fv )(const GLfloat *v);

439

static void ( APIENTRY * dllColor3i )(GLint red, GLint green, GLint blue);

440

static void ( APIENTRY * dllColor3iv )(const GLint *v);

441

static void ( APIENTRY * dllColor3s )(GLshort red, GLshort green, GLshort blue);

442

static void ( APIENTRY * dllColor3sv )(const GLshort *v);

443

static void ( APIENTRY * dllColor3ub )(GLubyte red, GLubyte green, GLubyte blue);

444

static void ( APIENTRY * dllColor3ubv )(const GLubyte *v);

445

static void ( APIENTRY * dllColor3ui )(GLuint red, GLuint green, GLuint blue);

446

static void ( APIENTRY * dllColor3uiv )(const GLuint *v);

447

static void ( APIENTRY * dllColor3us )(GLushort red, GLushort green, GLushort blue);

448

static void ( APIENTRY * dllColor3usv )(const GLushort *v);

449

static void ( APIENTRY * dllColor4b )(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);

450

static void ( APIENTRY * dllColor4bv )(const GLbyte *v);

451

static void ( APIENTRY * dllColor4d )(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);

452

static void ( APIENTRY * dllColor4dv )(const GLdouble *v);

453

static void ( APIENTRY * dllColor4f )(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);

454

static void ( APIENTRY * dllColor4fv )(const GLfloat *v);

455

static void ( APIENTRY * dllColor4i )(GLint red, GLint green, GLint blue, GLint alpha);

456

static void ( APIENTRY * dllColor4iv )(const GLint *v);

457

static void ( APIENTRY * dllColor4s )(GLshort red, GLshort green, GLshort blue, GLshort alpha);

458

static void ( APIENTRY * dllColor4sv )(const GLshort *v);

459

static void ( APIENTRY * dllColor4ub )(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);

460

static void ( APIENTRY * dllColor4ubv )(const GLubyte *v);

461

static void ( APIENTRY * dllColor4ui )(GLuint red, GLuint green, GLuint blue, GLuint alpha);

462

static void ( APIENTRY * dllColor4uiv )(const GLuint *v);

463

static void ( APIENTRY * dllColor4us )(GLushort red, GLushort green, GLushort blue, GLushort alpha);

464

static void ( APIENTRY * dllColor4usv )(const GLushort *v);

465

static void ( APIENTRY * dllColorMask )(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);

466

static void ( APIENTRY * dllColorMaterial )(GLenum face, GLenum mode);

467

static void ( APIENTRY * dllColorPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);

468

static void ( APIENTRY * dllCopyPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);

469

static void ( APIENTRY * dllCopyTexImage1D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border);

470

static void ( APIENTRY * dllCopyTexImage2D )(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);

471

static void ( APIENTRY * dllCopyTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);

472

static void ( APIENTRY * dllCopyTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);

473

static void ( APIENTRY * dllCullFace )(GLenum mode);

474

static void ( APIENTRY * dllDeleteLists )(GLuint list, GLsizei range);

475

static void ( APIENTRY * dllDeleteTextures )(GLsizei n, const GLuint *textures);

476

static void ( APIENTRY * dllDepthFunc )(GLenum func);

477

static void ( APIENTRY * dllDepthMask )(GLboolean flag);

478

static void ( APIENTRY * dllDepthRange )(GLclampd zNear, GLclampd zFar);

479

static void ( APIENTRY * dllDisable )(GLenum cap);

480

static void ( APIENTRY * dllDisableClientState )(GLenum array);

481

static void ( APIENTRY * dllDrawArrays )(GLenum mode, GLint first, GLsizei count);

482

static void ( APIENTRY * dllDrawBuffer )(GLenum mode);

483

static void ( APIENTRY * dllDrawElements )(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);

484

static void ( APIENTRY * dllDrawPixels )(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);

485

static void ( APIENTRY * dllEdgeFlag )(GLboolean flag);

486

static void ( APIENTRY * dllEdgeFlagPointer )(GLsizei stride, const GLvoid *pointer);

487

static void ( APIENTRY * dllEdgeFlagv )(const GLboolean *flag);

488

static void ( APIENTRY * dllEnable )(GLenum cap);

489

static void ( APIENTRY * dllEnableClientState )(GLenum array);

490

static void ( APIENTRY * dllEnd )(void);

491

static void ( APIENTRY * dllEndList )(void);

492

static void ( APIENTRY * dllEvalCoord1d )(GLdouble u);

493

static void ( APIENTRY * dllEvalCoord1dv )(const GLdouble *u);

494

static void ( APIENTRY * dllEvalCoord1f )(GLfloat u);

495

static void ( APIENTRY * dllEvalCoord1fv )(const GLfloat *u);

496

static void ( APIENTRY * dllEvalCoord2d )(GLdouble u, GLdouble v);

497

static void ( APIENTRY * dllEvalCoord2dv )(const GLdouble *u);

498

static void ( APIENTRY * dllEvalCoord2f )(GLfloat u, GLfloat v);

499

static void ( APIENTRY * dllEvalCoord2fv )(const GLfloat *u);

500

static void ( APIENTRY * dllEvalMesh1 )(GLenum mode, GLint i1, GLint i2);

501

static void ( APIENTRY * dllEvalMesh2 )(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);

502

static void ( APIENTRY * dllEvalPoint1 )(GLint i);

503

static void ( APIENTRY * dllEvalPoint2 )(GLint i, GLint j);

504

static void ( APIENTRY * dllFeedbackBuffer )(GLsizei size, GLenum type, GLfloat *buffer);

505

static void ( APIENTRY * dllFinish )(void);

506

static void ( APIENTRY * dllFlush )(void);

507

static void ( APIENTRY * dllFogf )(GLenum pname, GLfloat param);

508

static void ( APIENTRY * dllFogfv )(GLenum pname, const GLfloat *params);

509

static void ( APIENTRY * dllFogi )(GLenum pname, GLint param);

510

static void ( APIENTRY * dllFogiv )(GLenum pname, const GLint *params);

511

static void ( APIENTRY * dllFrontFace )(GLenum mode);

512

static void ( APIENTRY * dllFrustum )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);

513

GLuint ( APIENTRY * dllGenLists )(GLsizei range);

514

static void ( APIENTRY * dllGenTextures )(GLsizei n, GLuint *textures);

515

static void ( APIENTRY * dllGetBooleanv )(GLenum pname, GLboolean *params);

516

static void ( APIENTRY * dllGetClipPlane )(GLenum plane, GLdouble *equation);

517

static void ( APIENTRY * dllGetDoublev )(GLenum pname, GLdouble *params);

518

GLenum ( APIENTRY * dllGetError )(void);

519

static void ( APIENTRY * dllGetFloatv )(GLenum pname, GLfloat *params);

520

static void ( APIENTRY * dllGetIntegerv )(GLenum pname, GLint *params);

521

static void ( APIENTRY * dllGetLightfv )(GLenum light, GLenum pname, GLfloat *params);

522

static void ( APIENTRY * dllGetLightiv )(GLenum light, GLenum pname, GLint *params);

523

static void ( APIENTRY * dllGetMapdv )(GLenum target, GLenum query, GLdouble *v);

524

static void ( APIENTRY * dllGetMapfv )(GLenum target, GLenum query, GLfloat *v);

525

static void ( APIENTRY * dllGetMapiv )(GLenum target, GLenum query, GLint *v);

526

static void ( APIENTRY * dllGetMaterialfv )(GLenum face, GLenum pname, GLfloat *params);

527

static void ( APIENTRY * dllGetMaterialiv )(GLenum face, GLenum pname, GLint *params);

528

static void ( APIENTRY * dllGetPixelMapfv )(GLenum map, GLfloat *values);

529

static void ( APIENTRY * dllGetPixelMapuiv )(GLenum map, GLuint *values);

530

static void ( APIENTRY * dllGetPixelMapusv )(GLenum map, GLushort *values);

531

static void ( APIENTRY * dllGetPointerv )(GLenum pname, GLvoid* *params);

532

static void ( APIENTRY * dllGetPolygonStipple )(GLubyte *mask);

533

const GLubyte * ( APIENTRY * dllGetString )(GLenum name);

534

static void ( APIENTRY * dllGetTexEnvfv )(GLenum target, GLenum pname, GLfloat *params);

535

static void ( APIENTRY * dllGetTexEnviv )(GLenum target, GLenum pname, GLint *params);

536

static void ( APIENTRY * dllGetTexGendv )(GLenum coord, GLenum pname, GLdouble *params);

537

static void ( APIENTRY * dllGetTexGenfv )(GLenum coord, GLenum pname, GLfloat *params);

538

static void ( APIENTRY * dllGetTexGeniv )(GLenum coord, GLenum pname, GLint *params);

539

static void ( APIENTRY * dllGetTexImage )(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);

540

static void ( APIENTRY * dllGetTexLevelParameterfv )(GLenum target, GLint level, GLenum pname, GLfloat *params);

541

static void ( APIENTRY * dllGetTexLevelParameteriv )(GLenum target, GLint level, GLenum pname, GLint *params);

542

static void ( APIENTRY * dllGetTexParameterfv )(GLenum target, GLenum pname, GLfloat *params);

543

static void ( APIENTRY * dllGetTexParameteriv )(GLenum target, GLenum pname, GLint *params);

544

static void ( APIENTRY * dllHint )(GLenum target, GLenum mode);

545

static void ( APIENTRY * dllIndexMask )(GLuint mask);

546

static void ( APIENTRY * dllIndexPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);

547

static void ( APIENTRY * dllIndexd )(GLdouble c);

548

static void ( APIENTRY * dllIndexdv )(const GLdouble *c);

549

static void ( APIENTRY * dllIndexf )(GLfloat c);

550

static void ( APIENTRY * dllIndexfv )(const GLfloat *c);

551

static void ( APIENTRY * dllIndexi )(GLint c);

552

static void ( APIENTRY * dllIndexiv )(const GLint *c);

553

static void ( APIENTRY * dllIndexs )(GLshort c);

554

static void ( APIENTRY * dllIndexsv )(const GLshort *c);

555

static void ( APIENTRY * dllIndexub )(GLubyte c);

556

static void ( APIENTRY * dllIndexubv )(const GLubyte *c);

557

static void ( APIENTRY * dllInitNames )(void);

558

static void ( APIENTRY * dllInterleavedArrays )(GLenum format, GLsizei stride, const GLvoid *pointer);

559

GLboolean ( APIENTRY * dllIsEnabled )(GLenum cap);

560

GLboolean ( APIENTRY * dllIsList )(GLuint list);

561

GLboolean ( APIENTRY * dllIsTexture )(GLuint texture);

562

static void ( APIENTRY * dllLightModelf )(GLenum pname, GLfloat param);

563

static void ( APIENTRY * dllLightModelfv )(GLenum pname, const GLfloat *params);

564

static void ( APIENTRY * dllLightModeli )(GLenum pname, GLint param);

565

static void ( APIENTRY * dllLightModeliv )(GLenum pname, const GLint *params);

566

static void ( APIENTRY * dllLightf )(GLenum light, GLenum pname, GLfloat param);

567

static void ( APIENTRY * dllLightfv )(GLenum light, GLenum pname, const GLfloat *params);

568

static void ( APIENTRY * dllLighti )(GLenum light, GLenum pname, GLint param);

569

static void ( APIENTRY * dllLightiv )(GLenum light, GLenum pname, const GLint *params);

570

static void ( APIENTRY * dllLineStipple )(GLint factor, GLushort pattern);

571

static void ( APIENTRY * dllLineWidth )(GLfloat width);

572

static void ( APIENTRY * dllListBase )(GLuint base);

573

static void ( APIENTRY * dllLoadIdentity )(void);

574

static void ( APIENTRY * dllLoadMatrixd )(const GLdouble *m);

575

static void ( APIENTRY * dllLoadMatrixf )(const GLfloat *m);

576

static void ( APIENTRY * dllLoadName )(GLuint name);

577

static void ( APIENTRY * dllLogicOp )(GLenum opcode);

578

static void ( APIENTRY * dllMap1d )(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);

579

static void ( APIENTRY * dllMap1f )(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);

580

static void ( APIENTRY * dllMap2d )(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);

581

static void ( APIENTRY * dllMap2f )(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);

582

static void ( APIENTRY * dllMapGrid1d )(GLint un, GLdouble u1, GLdouble u2);

583

static void ( APIENTRY * dllMapGrid1f )(GLint un, GLfloat u1, GLfloat u2);

584

static void ( APIENTRY * dllMapGrid2d )(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);

585

static void ( APIENTRY * dllMapGrid2f )(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);

586

static void ( APIENTRY * dllMaterialf )(GLenum face, GLenum pname, GLfloat param);

587

static void ( APIENTRY * dllMaterialfv )(GLenum face, GLenum pname, const GLfloat *params);

588

static void ( APIENTRY * dllMateriali )(GLenum face, GLenum pname, GLint param);

589

static void ( APIENTRY * dllMaterialiv )(GLenum face, GLenum pname, const GLint *params);

590

static void ( APIENTRY * dllMatrixMode )(GLenum mode);

591

static void ( APIENTRY * dllMultMatrixd )(const GLdouble *m);

592

static void ( APIENTRY * dllMultMatrixf )(const GLfloat *m);

593

static void ( APIENTRY * dllNewList )(GLuint list, GLenum mode);

594

static void ( APIENTRY * dllNormal3b )(GLbyte nx, GLbyte ny, GLbyte nz);

595

static void ( APIENTRY * dllNormal3bv )(const GLbyte *v);

596

static void ( APIENTRY * dllNormal3d )(GLdouble nx, GLdouble ny, GLdouble nz);

597

static void ( APIENTRY * dllNormal3dv )(const GLdouble *v);

598

static void ( APIENTRY * dllNormal3f )(GLfloat nx, GLfloat ny, GLfloat nz);

599

static void ( APIENTRY * dllNormal3fv )(const GLfloat *v);

600

static void ( APIENTRY * dllNormal3i )(GLint nx, GLint ny, GLint nz);

601

static void ( APIENTRY * dllNormal3iv )(const GLint *v);

602

static void ( APIENTRY * dllNormal3s )(GLshort nx, GLshort ny, GLshort nz);

603

static void ( APIENTRY * dllNormal3sv )(const GLshort *v);

604

static void ( APIENTRY * dllNormalPointer )(GLenum type, GLsizei stride, const GLvoid *pointer);

605

static void ( APIENTRY * dllOrtho )(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);

606

static void ( APIENTRY * dllPassThrough )(GLfloat token);

607

static void ( APIENTRY * dllPixelMapfv )(GLenum map, GLsizei mapsize, const GLfloat *values);

608

static void ( APIENTRY * dllPixelMapuiv )(GLenum map, GLsizei mapsize, const GLuint *values);

609

static void ( APIENTRY * dllPixelMapusv )(GLenum map, GLsizei mapsize, const GLushort *values);

610

static void ( APIENTRY * dllPixelStoref )(GLenum pname, GLfloat param);

611

static void ( APIENTRY * dllPixelStorei )(GLenum pname, GLint param);

612

static void ( APIENTRY * dllPixelTransferf )(GLenum pname, GLfloat param);

613

static void ( APIENTRY * dllPixelTransferi )(GLenum pname, GLint param);

614

static void ( APIENTRY * dllPixelZoom )(GLfloat xfactor, GLfloat yfactor);

615

static void ( APIENTRY * dllPointSize )(GLfloat size);

616

static void ( APIENTRY * dllPolygonMode )(GLenum face, GLenum mode);

617

static void ( APIENTRY * dllPolygonOffset )(GLfloat factor, GLfloat units);

618

static void ( APIENTRY * dllPolygonStipple )(const GLubyte *mask);

619

static void ( APIENTRY * dllPopAttrib )(void);

620

static void ( APIENTRY * dllPopClientAttrib )(void);

621

static void ( APIENTRY * dllPopMatrix )(void);

622

static void ( APIENTRY * dllPopName )(void);

623

static void ( APIENTRY * dllPrioritizeTextures )(GLsizei n, const GLuint *textures, const GLclampf *priorities);

624

static void ( APIENTRY * dllPushAttrib )(GLbitfield mask);

625

static void ( APIENTRY * dllPushClientAttrib )(GLbitfield mask);

626

static void ( APIENTRY * dllPushMatrix )(void);

627

static void ( APIENTRY * dllPushName )(GLuint name);

628

static void ( APIENTRY * dllRasterPos2d )(GLdouble x, GLdouble y);

629

static void ( APIENTRY * dllRasterPos2dv )(const GLdouble *v);

630

static void ( APIENTRY * dllRasterPos2f )(GLfloat x, GLfloat y);

631

static void ( APIENTRY * dllRasterPos2fv )(const GLfloat *v);

632

static void ( APIENTRY * dllRasterPos2i )(GLint x, GLint y);

633

static void ( APIENTRY * dllRasterPos2iv )(const GLint *v);

634

static void ( APIENTRY * dllRasterPos2s )(GLshort x, GLshort y);

635

static void ( APIENTRY * dllRasterPos2sv )(const GLshort *v);

636

static void ( APIENTRY * dllRasterPos3d )(GLdouble x, GLdouble y, GLdouble z);

637

static void ( APIENTRY * dllRasterPos3dv )(const GLdouble *v);

638

static void ( APIENTRY * dllRasterPos3f )(GLfloat x, GLfloat y, GLfloat z);

639

static void ( APIENTRY * dllRasterPos3fv )(const GLfloat *v);

640

static void ( APIENTRY * dllRasterPos3i )(GLint x, GLint y, GLint z);

641

static void ( APIENTRY * dllRasterPos3iv )(const GLint *v);

642

static void ( APIENTRY * dllRasterPos3s )(GLshort x, GLshort y, GLshort z);

643

static void ( APIENTRY * dllRasterPos3sv )(const GLshort *v);

644

static void ( APIENTRY * dllRasterPos4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);

645

static void ( APIENTRY * dllRasterPos4dv )(const GLdouble *v);

646

static void ( APIENTRY * dllRasterPos4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);

647

static void ( APIENTRY * dllRasterPos4fv )(const GLfloat *v);

648

static void ( APIENTRY * dllRasterPos4i )(GLint x, GLint y, GLint z, GLint w);

649

static void ( APIENTRY * dllRasterPos4iv )(const GLint *v);

650

static void ( APIENTRY * dllRasterPos4s )(GLshort x, GLshort y, GLshort z, GLshort w);

651

static void ( APIENTRY * dllRasterPos4sv )(const GLshort *v);

652

static void ( APIENTRY * dllReadBuffer )(GLenum mode);

653

static void ( APIENTRY * dllReadPixels )(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);

654

static void ( APIENTRY * dllRectd )(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);

655

static void ( APIENTRY * dllRectdv )(const GLdouble *v1, const GLdouble *v2);

656

static void ( APIENTRY * dllRectf )(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);

657

static void ( APIENTRY * dllRectfv )(const GLfloat *v1, const GLfloat *v2);

658

static void ( APIENTRY * dllRecti )(GLint x1, GLint y1, GLint x2, GLint y2);

659

static void ( APIENTRY * dllRectiv )(const GLint *v1, const GLint *v2);

660

static void ( APIENTRY * dllRects )(GLshort x1, GLshort y1, GLshort x2, GLshort y2);

661

static void ( APIENTRY * dllRectsv )(const GLshort *v1, const GLshort *v2);

662

GLint ( APIENTRY * dllRenderMode )(GLenum mode);

663

static void ( APIENTRY * dllRotated )(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);

664

static void ( APIENTRY * dllRotatef )(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);

665

static void ( APIENTRY * dllScaled )(GLdouble x, GLdouble y, GLdouble z);

666

static void ( APIENTRY * dllScalef )(GLfloat x, GLfloat y, GLfloat z);

667

static void ( APIENTRY * dllScissor )(GLint x, GLint y, GLsizei width, GLsizei height);

668

static void ( APIENTRY * dllSelectBuffer )(GLsizei size, GLuint *buffer);

669

static void ( APIENTRY * dllShadeModel )(GLenum mode);

670

static void ( APIENTRY * dllStencilFunc )(GLenum func, GLint ref, GLuint mask);

671

static void ( APIENTRY * dllStencilMask )(GLuint mask);

672

static void ( APIENTRY * dllStencilOp )(GLenum fail, GLenum zfail, GLenum zpass);

673

static void ( APIENTRY * dllTexCoord1d )(GLdouble s);

674

static void ( APIENTRY * dllTexCoord1dv )(const GLdouble *v);

675

static void ( APIENTRY * dllTexCoord1f )(GLfloat s);

676

static void ( APIENTRY * dllTexCoord1fv )(const GLfloat *v);

677

static void ( APIENTRY * dllTexCoord1i )(GLint s);

678

static void ( APIENTRY * dllTexCoord1iv )(const GLint *v);

679

static void ( APIENTRY * dllTexCoord1s )(GLshort s);

680

static void ( APIENTRY * dllTexCoord1sv )(const GLshort *v);

681

static void ( APIENTRY * dllTexCoord2d )(GLdouble s, GLdouble t);

682

static void ( APIENTRY * dllTexCoord2dv )(const GLdouble *v);

683

static void ( APIENTRY * dllTexCoord2f )(GLfloat s, GLfloat t);

684

static void ( APIENTRY * dllTexCoord2fv )(const GLfloat *v);

685

static void ( APIENTRY * dllTexCoord2i )(GLint s, GLint t);

686

static void ( APIENTRY * dllTexCoord2iv )(const GLint *v);

687

static void ( APIENTRY * dllTexCoord2s )(GLshort s, GLshort t);

688

static void ( APIENTRY * dllTexCoord2sv )(const GLshort *v);

689

static void ( APIENTRY * dllTexCoord3d )(GLdouble s, GLdouble t, GLdouble r);

690

static void ( APIENTRY * dllTexCoord3dv )(const GLdouble *v);

691

static void ( APIENTRY * dllTexCoord3f )(GLfloat s, GLfloat t, GLfloat r);

692

static void ( APIENTRY * dllTexCoord3fv )(const GLfloat *v);

693

static void ( APIENTRY * dllTexCoord3i )(GLint s, GLint t, GLint r);

694

static void ( APIENTRY * dllTexCoord3iv )(const GLint *v);

695

static void ( APIENTRY * dllTexCoord3s )(GLshort s, GLshort t, GLshort r);

696

static void ( APIENTRY * dllTexCoord3sv )(const GLshort *v);

697

static void ( APIENTRY * dllTexCoord4d )(GLdouble s, GLdouble t, GLdouble r, GLdouble q);

698

static void ( APIENTRY * dllTexCoord4dv )(const GLdouble *v);

699

static void ( APIENTRY * dllTexCoord4f )(GLfloat s, GLfloat t, GLfloat r, GLfloat q);

700

static void ( APIENTRY * dllTexCoord4fv )(const GLfloat *v);

701

static void ( APIENTRY * dllTexCoord4i )(GLint s, GLint t, GLint r, GLint q);

702

static void ( APIENTRY * dllTexCoord4iv )(const GLint *v);

703

static void ( APIENTRY * dllTexCoord4s )(GLshort s, GLshort t, GLshort r, GLshort q);

704

static void ( APIENTRY * dllTexCoord4sv )(const GLshort *v);

705

static void ( APIENTRY * dllTexCoordPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);

706

static void ( APIENTRY * dllTexEnvf )(GLenum target, GLenum pname, GLfloat param);

707

static void ( APIENTRY * dllTexEnvfv )(GLenum target, GLenum pname, const GLfloat *params);

708

static void ( APIENTRY * dllTexEnvi )(GLenum target, GLenum pname, GLint param);

709

static void ( APIENTRY * dllTexEnviv )(GLenum target, GLenum pname, const GLint *params);

710

static void ( APIENTRY * dllTexGend )(GLenum coord, GLenum pname, GLdouble param);

711

static void ( APIENTRY * dllTexGendv )(GLenum coord, GLenum pname, const GLdouble *params);

712

static void ( APIENTRY * dllTexGenf )(GLenum coord, GLenum pname, GLfloat param);

713

static void ( APIENTRY * dllTexGenfv )(GLenum coord, GLenum pname, const GLfloat *params);

714

static void ( APIENTRY * dllTexGeni )(GLenum coord, GLenum pname, GLint param);

715

static void ( APIENTRY * dllTexGeniv )(GLenum coord, GLenum pname, const GLint *params);

716

static void ( APIENTRY * dllTexImage1D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);

717

static void ( APIENTRY * dllTexImage2D )(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);

718

static void ( APIENTRY * dllTexParameterf )(GLenum target, GLenum pname, GLfloat param);

719

static void ( APIENTRY * dllTexParameterfv )(GLenum target, GLenum pname, const GLfloat *params);

720

static void ( APIENTRY * dllTexParameteri )(GLenum target, GLenum pname, GLint param);

721

static void ( APIENTRY * dllTexParameteriv )(GLenum target, GLenum pname, const GLint *params);

722

static void ( APIENTRY * dllTexSubImage1D )(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);

723

static void ( APIENTRY * dllTexSubImage2D )(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);

724

static void ( APIENTRY * dllTranslated )(GLdouble x, GLdouble y, GLdouble z);

725

static void ( APIENTRY * dllTranslatef )(GLfloat x, GLfloat y, GLfloat z);

726

static void ( APIENTRY * dllVertex2d )(GLdouble x, GLdouble y);

727

static void ( APIENTRY * dllVertex2dv )(const GLdouble *v);

728

static void ( APIENTRY * dllVertex2f )(GLfloat x, GLfloat y);

729

static void ( APIENTRY * dllVertex2fv )(const GLfloat *v);

730

static void ( APIENTRY * dllVertex2i )(GLint x, GLint y);

731

static void ( APIENTRY * dllVertex2iv )(const GLint *v);

732

static void ( APIENTRY * dllVertex2s )(GLshort x, GLshort y);

733

static void ( APIENTRY * dllVertex2sv )(const GLshort *v);

734

static void ( APIENTRY * dllVertex3d )(GLdouble x, GLdouble y, GLdouble z);

735

static void ( APIENTRY * dllVertex3dv )(const GLdouble *v);

736

static void ( APIENTRY * dllVertex3f )(GLfloat x, GLfloat y, GLfloat z);

737

static void ( APIENTRY * dllVertex3fv )(const GLfloat *v);

738

static void ( APIENTRY * dllVertex3i )(GLint x, GLint y, GLint z);

739

static void ( APIENTRY * dllVertex3iv )(const GLint *v);

740

static void ( APIENTRY * dllVertex3s )(GLshort x, GLshort y, GLshort z);

741

static void ( APIENTRY * dllVertex3sv )(const GLshort *v);

742

static void ( APIENTRY * dllVertex4d )(GLdouble x, GLdouble y, GLdouble z, GLdouble w);

743

static void ( APIENTRY * dllVertex4dv )(const GLdouble *v);

744

static void ( APIENTRY * dllVertex4f )(GLfloat x, GLfloat y, GLfloat z, GLfloat w);

745

static void ( APIENTRY * dllVertex4fv )(const GLfloat *v);

746

static void ( APIENTRY * dllVertex4i )(GLint x, GLint y, GLint z, GLint w);

747

static void ( APIENTRY * dllVertex4iv )(const GLint *v);

748

static void ( APIENTRY * dllVertex4s )(GLshort x, GLshort y, GLshort z, GLshort w);

749

static void ( APIENTRY * dllVertex4sv )(const GLshort *v);

750

static void ( APIENTRY * dllVertexPointer )(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);

751

static void ( APIENTRY * dllViewport )(GLint x, GLint y, GLsizei width, GLsizei height);

752

753

static const char * BooleanToString( GLboolean b )

754

{

755

if ( b == GL_FALSE )

756

return "GL_FALSE";

757

else if ( b == GL_TRUE )

758

return "GL_TRUE";

759

else

760

return "OUT OF RANGE FOR BOOLEAN";

761

}

762

763

static const char * FuncToString( GLenum f )

764

{

765

switch ( f )

766

{

767

case GL_ALWAYS:

768

return "GL_ALWAYS";

769

case GL_NEVER:

770

return "GL_NEVER";

771

case GL_LEQUAL:

772

return "GL_LEQUAL";

773

case GL_LESS:

774

return "GL_LESS";

775

case GL_EQUAL:

776

return "GL_EQUAL";

777

case GL_GREATER:

778

return "GL_GREATER";

779

case GL_GEQUAL:

780

return "GL_GEQUAL";

781

case GL_NOTEQUAL:

782

return "GL_NOTEQUAL";

783

default:

784

return "!!! UNKNOWN !!!";

785

}

786

}

787

788

static const char * PrimToString( GLenum mode )

789

{

790

static char prim[1024];

791

792

if ( mode == GL_TRIANGLES )

793

strcpy( prim, "GL_TRIANGLES" );

794

else if ( mode == GL_TRIANGLE_STRIP )

795

strcpy( prim, "GL_TRIANGLE_STRIP" );

796

else if ( mode == GL_TRIANGLE_FAN )

797

strcpy( prim, "GL_TRIANGLE_FAN" );

798

else if ( mode == GL_QUADS )

799

strcpy( prim, "GL_QUADS" );

800

else if ( mode == GL_QUAD_STRIP )

801

strcpy( prim, "GL_QUAD_STRIP" );

802

else if ( mode == GL_POLYGON )

803

strcpy( prim, "GL_POLYGON" );

804

else if ( mode == GL_POINTS )

805

strcpy( prim, "GL_POINTS" );

806

else if ( mode == GL_LINES )

807

strcpy( prim, "GL_LINES" );

808

else if ( mode == GL_LINE_STRIP )

809

strcpy( prim, "GL_LINE_STRIP" );

810

else if ( mode == GL_LINE_LOOP )

811

strcpy( prim, "GL_LINE_LOOP" );

812

else

813

sprintf( prim, "0x%x", mode );

814

815

return prim;

816

}

817

818

static const char * CapToString( GLenum cap )

819

{

820

static char buffer[1024];

821

822

switch ( cap )

823

{

824

case GL_TEXTURE_2D:

825

return "GL_TEXTURE_2D";

826

case GL_BLEND:

827

return "GL_BLEND";

828

case GL_DEPTH_TEST:

829

return "GL_DEPTH_TEST";

830

case GL_CULL_FACE:

831

return "GL_CULL_FACE";

832

case GL_CLIP_PLANE0:

833

return "GL_CLIP_PLANE0";

834

case GL_COLOR_ARRAY:

835

return "GL_COLOR_ARRAY";

836

case GL_TEXTURE_COORD_ARRAY:

837

return "GL_TEXTURE_COORD_ARRAY";

838

case GL_VERTEX_ARRAY:

839

return "GL_VERTEX_ARRAY";

840

case GL_ALPHA_TEST:

841

return "GL_ALPHA_TEST";

842

case GL_STENCIL_TEST:

843

return "GL_STENCIL_TEST";

844

default:

845

sprintf( buffer, "0x%x", cap );

846

}

847

848

return buffer;

849

}

850

851

static const char * TypeToString( GLenum t )

852

{

853

switch ( t )

854

{

855

case GL_BYTE:

856

return "GL_BYTE";

857

case GL_UNSIGNED_BYTE:

858

return "GL_UNSIGNED_BYTE";

859

case GL_SHORT:

860

return "GL_SHORT";

861

case GL_UNSIGNED_SHORT:

862

return "GL_UNSIGNED_SHORT";

863

case GL_INT:

864

return "GL_INT";

865

case GL_UNSIGNED_INT:

866

return "GL_UNSIGNED_INT";

867

case GL_FLOAT:

868

return "GL_FLOAT";

869

case GL_DOUBLE:

870

return "GL_DOUBLE";

871

default:

872

return "!!! UNKNOWN !!!";

873

}

874

}

875

876

static void APIENTRY logAccum(GLenum op, GLfloat value)

877

{

878

fprintf( glw_state.log_fp, "glAccum\n" );

879

dllAccum( op, value );

880

}

881

882

static void APIENTRY logAlphaFunc(GLenum func, GLclampf ref)

883

{

884

fprintf( glw_state.log_fp, "glAlphaFunc( 0x%x, %f )\n", func, ref );

885

dllAlphaFunc( func, ref );

886

}

887

888

static GLboolean APIENTRY logAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)

889

{

890

fprintf( glw_state.log_fp, "glAreTexturesResident\n" );

891

return dllAreTexturesResident( n, textures, residences );

892

}

893

894

static void APIENTRY logArrayElement(GLint i)

895

{

896

fprintf( glw_state.log_fp, "glArrayElement\n" );

897

dllArrayElement( i );

898

}

899

900

static void APIENTRY logBegin(GLenum mode)

901

{

902

fprintf( glw_state.log_fp, "glBegin( %s )\n", PrimToString( mode ));

903

dllBegin( mode );

904

}

905

906

static void APIENTRY logBindTexture(GLenum target, GLuint texture)

907

{

908

fprintf( glw_state.log_fp, "glBindTexture( 0x%x, %u )\n", target, texture );

909

dllBindTexture( target, texture );

910

}

911

912

static void APIENTRY logBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)

913

{

914

fprintf( glw_state.log_fp, "glBitmap\n" );

915

dllBitmap( width, height, xorig, yorig, xmove, ymove, bitmap );

916

}

917

918

static void BlendToName( char *n, GLenum f )

919

{

920

switch ( f )

921

{

922

case GL_ONE:

923

strcpy( n, "GL_ONE" );

924

break;

925

case GL_ZERO:

926

strcpy( n, "GL_ZERO" );

927

break;

928

case GL_SRC_ALPHA:

929

strcpy( n, "GL_SRC_ALPHA" );

930

break;

931

case GL_ONE_MINUS_SRC_ALPHA:

932

strcpy( n, "GL_ONE_MINUS_SRC_ALPHA" );

933

break;

934

case GL_DST_COLOR:

935

strcpy( n, "GL_DST_COLOR" );

936

break;

937

case GL_ONE_MINUS_DST_COLOR:

938

strcpy( n, "GL_ONE_MINUS_DST_COLOR" );

939

break;

940

case GL_DST_ALPHA:

941

strcpy( n, "GL_DST_ALPHA" );

942

break;

943

default:

944

sprintf( n, "0x%x", f );

945

}

946

}

947

static void APIENTRY logBlendFunc(GLenum sfactor, GLenum dfactor)

948

{

949

char sf[128], df[128];

950

951

BlendToName( sf, sfactor );

952

BlendToName( df, dfactor );

953

954

fprintf( glw_state.log_fp, "glBlendFunc( %s, %s )\n", sf, df );

955

dllBlendFunc( sfactor, dfactor );

956

}

957

958

static void APIENTRY logCallList(GLuint list)

959

{

960

fprintf( glw_state.log_fp, "glCallList( %u )\n", list );

961

dllCallList( list );

962

}

963

964

static void APIENTRY logCallLists(GLsizei n, GLenum type, const void *lists)

965

{

966

fprintf( glw_state.log_fp, "glCallLists\n" );

967

dllCallLists( n, type, lists );

968

}

969

970

static void APIENTRY logClear(GLbitfield mask)

971

{

972

fprintf( glw_state.log_fp, "glClear( 0x%x = ", mask );

973

974

if ( mask & GL_COLOR_BUFFER_BIT )

975

fprintf( glw_state.log_fp, "GL_COLOR_BUFFER_BIT " );

976

if ( mask & GL_DEPTH_BUFFER_BIT )

977

fprintf( glw_state.log_fp, "GL_DEPTH_BUFFER_BIT " );

978

if ( mask & GL_STENCIL_BUFFER_BIT )

979

fprintf( glw_state.log_fp, "GL_STENCIL_BUFFER_BIT " );

980

if ( mask & GL_ACCUM_BUFFER_BIT )

981

fprintf( glw_state.log_fp, "GL_ACCUM_BUFFER_BIT " );

982

983

fprintf( glw_state.log_fp, ")\n" );

984

dllClear( mask );

985

}

986

987

static void APIENTRY logClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)

988

{

989

fprintf( glw_state.log_fp, "glClearAccum\n" );

990

dllClearAccum( red, green, blue, alpha );

991

}

992

993

static void APIENTRY logClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)

994

{

995

fprintf( glw_state.log_fp, "glClearColor\n" );

996

dllClearColor( red, green, blue, alpha );

997

}

998

999

static void APIENTRY logClearDepth(GLclampd depth)

1000

{

1001

fprintf( glw_state.log_fp, "glClearDepth( %f )\n", ( float ) depth );

1002

dllClearDepth( depth );

1003

}

1004

1005

static void APIENTRY logClearIndex(GLfloat c)

1006

{

1007

fprintf( glw_state.log_fp, "glClearIndex\n" );

1008

dllClearIndex( c );

1009

}

1010

1011

static void APIENTRY logClearStencil(GLint s)

1012

{

1013

fprintf( glw_state.log_fp, "glClearStencil( %d )\n", s );

1014

dllClearStencil( s );

1015

}

1016

1017

static void APIENTRY logClipPlane(GLenum plane, const GLdouble *equation)

1018

{

1019

fprintf( glw_state.log_fp, "glClipPlane\n" );

1020

dllClipPlane( plane, equation );

1021

}

1022

1023

static void APIENTRY logColor3b(GLbyte red, GLbyte green, GLbyte blue)

1024

{

1025

fprintf( glw_state.log_fp, "glColor3b\n" );

1026

dllColor3b( red, green, blue );

1027

}

1028

1029

static void APIENTRY logColor3bv(const GLbyte *v)

1030

{

1031

fprintf( glw_state.log_fp, "glColor3bv\n" );

1032

dllColor3bv( v );

1033

}

1034

1035

static void APIENTRY logColor3d(GLdouble red, GLdouble green, GLdouble blue)

1036

{

1037

fprintf( glw_state.log_fp, "glColor3d\n" );

1038

dllColor3d( red, green, blue );

1039

}

1040

1041

static void APIENTRY logColor3dv(const GLdouble *v)

1042

{

1043

fprintf( glw_state.log_fp, "glColor3dv\n" );

1044

dllColor3dv( v );

1045

}

1046

1047

static void APIENTRY logColor3f(GLfloat red, GLfloat green, GLfloat blue)

1048

{

1049

fprintf( glw_state.log_fp, "glColor3f\n" );

1050

dllColor3f( red, green, blue );

1051

}

1052

1053

static void APIENTRY logColor3fv(const GLfloat *v)

1054

{

1055

fprintf( glw_state.log_fp, "glColor3fv\n" );

1056

dllColor3fv( v );

1057

}

1058

1059

static void APIENTRY logColor3i(GLint red, GLint green, GLint blue)

1060

{

1061

fprintf( glw_state.log_fp, "glColor3i\n" );

1062

dllColor3i( red, green, blue );

1063

}

1064

1065

static void APIENTRY logColor3iv(const GLint *v)

1066

{

1067

fprintf( glw_state.log_fp, "glColor3iv\n" );

1068

dllColor3iv( v );

1069

}

1070

1071

static void APIENTRY logColor3s(GLshort red, GLshort green, GLshort blue)

1072

{

1073

fprintf( glw_state.log_fp, "glColor3s\n" );

1074

dllColor3s( red, green, blue );

1075

}

1076

1077

static void APIENTRY logColor3sv(const GLshort *v)

1078

{

1079

fprintf( glw_state.log_fp, "glColor3sv\n" );

1080

dllColor3sv( v );

1081

}

1082

1083

static void APIENTRY logColor3ub(GLubyte red, GLubyte green, GLubyte blue)

1084

{

1085

fprintf( glw_state.log_fp, "glColor3ub\n" );

1086

dllColor3ub( red, green, blue );

1087

}

1088

1089

static void APIENTRY logColor3ubv(const GLubyte *v)

1090

{

1091

fprintf( glw_state.log_fp, "glColor3ubv\n" );

1092

dllColor3ubv( v );

1093

}

1094

1095

#define SIG( x ) fprintf( glw_state.log_fp, x "\n" )

1096

1097

static void APIENTRY logColor3ui(GLuint red, GLuint green, GLuint blue)

1098

{

1099

SIG( "glColor3ui" );

1100

dllColor3ui( red, green, blue );

1101

}

1102

1103

static void APIENTRY logColor3uiv(const GLuint *v)

1104

{

1105

SIG( "glColor3uiv" );

1106

dllColor3uiv( v );

1107

}

1108

1109

static void APIENTRY logColor3us(GLushort red, GLushort green, GLushort blue)

1110

{

1111

SIG( "glColor3us" );

1112

dllColor3us( red, green, blue );

1113

}

1114

1115

static void APIENTRY logColor3usv(const GLushort *v)

1116

{

1117

SIG( "glColor3usv" );

1118

dllColor3usv( v );

1119

}

1120

1121

static void APIENTRY logColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)

1122

{

1123

SIG( "glColor4b" );

1124

dllColor4b( red, green, blue, alpha );

1125

}

1126

1127

static void APIENTRY logColor4bv(const GLbyte *v)

1128

{

1129

SIG( "glColor4bv" );

1130

dllColor4bv( v );

1131

}

1132

1133

static void APIENTRY logColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)

1134

{

1135

SIG( "glColor4d" );

1136

dllColor4d( red, green, blue, alpha );

1137

}

1138

static void APIENTRY logColor4dv(const GLdouble *v)

1139

{

1140

SIG( "glColor4dv" );

1141

dllColor4dv( v );

1142

}

1143

static void APIENTRY logColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)

1144

{

1145

fprintf( glw_state.log_fp, "glColor4f( %f,%f,%f,%f )\n", red, green, blue, alpha );

1146

dllColor4f( red, green, blue, alpha );

1147

}

1148

static void APIENTRY logColor4fv(const GLfloat *v)

1149

{

1150

fprintf( glw_state.log_fp, "glColor4fv( %f,%f,%f,%f )\n", v[0], v[1], v[2], v[3] );

1151

dllColor4fv( v );

1152

}

1153

static void APIENTRY logColor4i(GLint red, GLint green, GLint blue, GLint alpha)

1154

{

1155

SIG( "glColor4i" );

1156

dllColor4i( red, green, blue, alpha );

1157

}

1158

static void APIENTRY logColor4iv(const GLint *v)

1159

{

1160

SIG( "glColor4iv" );

1161

dllColor4iv( v );

1162

}

1163

static void APIENTRY logColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)

1164

{

1165

SIG( "glColor4s" );

1166

dllColor4s( red, green, blue, alpha );

1167

}

1168

static void APIENTRY logColor4sv(const GLshort *v)

1169

{

1170

SIG( "glColor4sv" );

1171

dllColor4sv( v );

1172

}

1173

static void APIENTRY logColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)

1174

{

1175

SIG( "glColor4b" );

1176

dllColor4b( red, green, blue, alpha );

1177

}

1178

static void APIENTRY logColor4ubv(const GLubyte *v)

1179

{

1180

SIG( "glColor4ubv" );

1181

dllColor4ubv( v );

1182

}

1183

static void APIENTRY logColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)

1184

{

1185

SIG( "glColor4ui" );

1186

dllColor4ui( red, green, blue, alpha );

1187

}

1188

static void APIENTRY logColor4uiv(const GLuint *v)

1189

{

1190

SIG( "glColor4uiv" );

1191

dllColor4uiv( v );

1192

}

1193

static void APIENTRY logColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)

1194

{

1195

SIG( "glColor4us" );

1196

dllColor4us( red, green, blue, alpha );

1197

}

1198

static void APIENTRY logColor4usv(const GLushort *v)

1199

{

1200

SIG( "glColor4usv" );

1201

dllColor4usv( v );

1202

}

1203

static void APIENTRY logColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)

1204

{

1205

SIG( "glColorMask" );

1206

dllColorMask( red, green, blue, alpha );

1207

}

1208

static void APIENTRY logColorMaterial(GLenum face, GLenum mode)

1209

{

1210

SIG( "glColorMaterial" );

1211

dllColorMaterial( face, mode );

1212

}

1213

1214

static void APIENTRY logColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)

1215

{

1216

fprintf( glw_state.log_fp, "glColorPointer( %d, %s, %d, MEM )\n", size, TypeToString( type ), stride );

1217

dllColorPointer( size, type, stride, pointer );

1218

}

1219

1220

static void APIENTRY logCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)

1221

{

1222

SIG( "glCopyPixels" );

1223

dllCopyPixels( x, y, width, height, type );

1224

}

1225

1226

static void APIENTRY logCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)

1227

{

1228

SIG( "glCopyTexImage1D" );

1229

dllCopyTexImage1D( target, level, internalFormat, x, y, width, border );

1230

}

1231

1232

static void APIENTRY logCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)

1233

{

1234

SIG( "glCopyTexImage2D" );

1235

dllCopyTexImage2D( target, level, internalFormat, x, y, width, height, border );

1236

}

1237

1238

static void APIENTRY logCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)

1239

{

1240

SIG( "glCopyTexSubImage1D" );

1241

dllCopyTexSubImage1D( target, level, xoffset, x, y, width );

1242

}

1243

1244

static void APIENTRY logCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)

1245

{

1246

SIG( "glCopyTexSubImage2D" );

1247

dllCopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height );

1248

}

1249

1250

static void APIENTRY logCullFace(GLenum mode)

1251

{

1252

fprintf( glw_state.log_fp, "glCullFace( %s )\n", ( mode == GL_FRONT ) ? "GL_FRONT" : "GL_BACK" );

1253

dllCullFace( mode );

1254

}

1255

1256

static void APIENTRY logDeleteLists(GLuint list, GLsizei range)

1257

{

1258

SIG( "glDeleteLists" );

1259

dllDeleteLists( list, range );

1260

}

1261

1262

static void APIENTRY logDeleteTextures(GLsizei n, const GLuint *textures)

1263

{

1264

SIG( "glDeleteTextures" );

1265

dllDeleteTextures( n, textures );

1266

}

1267

1268

static void APIENTRY logDepthFunc(GLenum func)

1269

{

1270

fprintf( glw_state.log_fp, "glDepthFunc( %s )\n", FuncToString( func ) );

1271

dllDepthFunc( func );

1272

}

1273

1274

static void APIENTRY logDepthMask(GLboolean flag)

1275

{

1276

fprintf( glw_state.log_fp, "glDepthMask( %s )\n", BooleanToString( flag ) );

1277

dllDepthMask( flag );

1278

}

1279

1280

static void APIENTRY logDepthRange(GLclampd zNear, GLclampd zFar)

1281

{

1282

fprintf( glw_state.log_fp, "glDepthRange( %f, %f )\n", ( float ) zNear, ( float ) zFar );

1283

dllDepthRange( zNear, zFar );

1284

}

1285

1286

static void APIENTRY logDisable(GLenum cap)

1287

{

1288

fprintf( glw_state.log_fp, "glDisable( %s )\n", CapToString( cap ) );

1289

dllDisable( cap );

1290

}

1291

1292

static void APIENTRY logDisableClientState(GLenum array)

1293

{

1294

fprintf( glw_state.log_fp, "glDisableClientState( %s )\n", CapToString( array ) );

1295

dllDisableClientState( array );

1296

}

1297

1298

static void APIENTRY logDrawArrays(GLenum mode, GLint first, GLsizei count)

1299

{

1300

SIG( "glDrawArrays" );

1301

dllDrawArrays( mode, first, count );

1302

}

1303

1304

static void APIENTRY logDrawBuffer(GLenum mode)

1305

{

1306

SIG( "glDrawBuffer" );

1307

dllDrawBuffer( mode );

1308

}

1309

1310

static void APIENTRY logDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)

1311

{

1312

fprintf( glw_state.log_fp, "glDrawElements( %s, %d, %s, MEM )\n", PrimToString( mode ), count, TypeToString( type ) );

1313

dllDrawElements( mode, count, type, indices );

1314

}

1315

1316

static void APIENTRY logDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)

1317

{

1318

SIG( "glDrawPixels" );

1319

dllDrawPixels( width, height, format, type, pixels );

1320

}

1321

1322

static void APIENTRY logEdgeFlag(GLboolean flag)

1323

{

1324

SIG( "glEdgeFlag" );

1325

dllEdgeFlag( flag );

1326

}

1327

1328

static void APIENTRY logEdgeFlagPointer(GLsizei stride, const void *pointer)

1329

{

1330

SIG( "glEdgeFlagPointer" );

1331

dllEdgeFlagPointer( stride, pointer );

1332

}

1333

1334

static void APIENTRY logEdgeFlagv(const GLboolean *flag)

1335

{

1336

SIG( "glEdgeFlagv" );

1337

dllEdgeFlagv( flag );

1338

}

1339

1340

static void APIENTRY logEnable(GLenum cap)

1341

{

1342

fprintf( glw_state.log_fp, "glEnable( %s )\n", CapToString( cap ) );

1343

dllEnable( cap );

1344

}

1345

1346

static void APIENTRY logEnableClientState(GLenum array)

1347

{

1348

fprintf( glw_state.log_fp, "glEnableClientState( %s )\n", CapToString( array ) );

1349

dllEnableClientState( array );

1350

}

1351

1352

static void APIENTRY logEnd(void)

1353

{

1354

SIG( "glEnd" );

1355

dllEnd();

1356

}

1357

1358

static void APIENTRY logEndList(void)

1359

{

1360

SIG( "glEndList" );

1361

dllEndList();

1362

}

1363

1364

static void APIENTRY logEvalCoord1d(GLdouble u)

1365

{

1366

SIG( "glEvalCoord1d" );

1367

dllEvalCoord1d( u );

1368

}

1369

1370

static void APIENTRY logEvalCoord1dv(const GLdouble *u)

1371

{

1372

SIG( "glEvalCoord1dv" );

1373

dllEvalCoord1dv( u );

1374

}

1375

1376

static void APIENTRY logEvalCoord1f(GLfloat u)

1377

{

1378

SIG( "glEvalCoord1f" );

1379

dllEvalCoord1f( u );

1380

}

1381

1382

static void APIENTRY logEvalCoord1fv(const GLfloat *u)

1383

{

1384

SIG( "glEvalCoord1fv" );

1385

dllEvalCoord1fv( u );

1386

}

1387

static void APIENTRY logEvalCoord2d(GLdouble u, GLdouble v)

1388

{

1389

SIG( "glEvalCoord2d" );

1390

dllEvalCoord2d( u, v );

1391

}

1392

static void APIENTRY logEvalCoord2dv(const GLdouble *u)

1393

{

1394

SIG( "glEvalCoord2dv" );

1395

dllEvalCoord2dv( u );

1396

}

1397

static void APIENTRY logEvalCoord2f(GLfloat u, GLfloat v)

1398

{

1399

SIG( "glEvalCoord2f" );

1400

dllEvalCoord2f( u, v );

1401

}

1402

static void APIENTRY logEvalCoord2fv(const GLfloat *u)

1403

{

1404

SIG( "glEvalCoord2fv" );

1405

dllEvalCoord2fv( u );

1406

}

1407

1408

static void APIENTRY logEvalMesh1(GLenum mode, GLint i1, GLint i2)

1409

{

1410

SIG( "glEvalMesh1" );

1411

dllEvalMesh1( mode, i1, i2 );

1412

}

1413

static void APIENTRY logEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)

1414

{

1415

SIG( "glEvalMesh2" );

1416

dllEvalMesh2( mode, i1, i2, j1, j2 );

1417

}

1418

static void APIENTRY logEvalPoint1(GLint i)

1419

{

1420

SIG( "glEvalPoint1" );

1421

dllEvalPoint1( i );

1422

}

1423

static void APIENTRY logEvalPoint2(GLint i, GLint j)

1424

{

1425

SIG( "glEvalPoint2" );

1426

dllEvalPoint2( i, j );

1427

}

1428

1429

static void APIENTRY logFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)

1430

{

1431

SIG( "glFeedbackBuffer" );

1432

dllFeedbackBuffer( size, type, buffer );

1433

}

1434

1435

static void APIENTRY logFinish(void)

1436

{

1437

SIG( "glFinish" );

1438

dllFinish();

1439

}

1440

1441

static void APIENTRY logFlush(void)

1442

{

1443

SIG( "glFlush" );

1444

dllFlush();

1445

}

1446

1447

static void APIENTRY logFogf(GLenum pname, GLfloat param)

1448

{

1449

SIG( "glFogf" );

1450

dllFogf( pname, param );

1451

}

1452

1453

static void APIENTRY logFogfv(GLenum pname, const GLfloat *params)

1454

{

1455

SIG( "glFogfv" );

1456

dllFogfv( pname, params );

1457

}

1458

1459

static void APIENTRY logFogi(GLenum pname, GLint param)

1460

{

1461

SIG( "glFogi" );

1462

dllFogi( pname, param );

1463

}

1464

1465

static void APIENTRY logFogiv(GLenum pname, const GLint *params)

1466

{

1467

SIG( "glFogiv" );

1468

dllFogiv( pname, params );

1469

}

1470

1471

static void APIENTRY logFrontFace(GLenum mode)

1472

{

1473

SIG( "glFrontFace" );

1474

dllFrontFace( mode );

1475

}

1476

1477

static void APIENTRY logFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)

1478

{

1479

SIG( "glFrustum" );

1480

dllFrustum( left, right, bottom, top, zNear, zFar );

1481

}

1482

1483

static GLuint APIENTRY logGenLists(GLsizei range)

1484

{

1485

SIG( "glGenLists" );

1486

return dllGenLists( range );

1487

}

1488

1489

static void APIENTRY logGenTextures(GLsizei n, GLuint *textures)

1490

{

1491

SIG( "glGenTextures" );

1492

dllGenTextures( n, textures );

1493

}

1494

1495

static void APIENTRY logGetBooleanv(GLenum pname, GLboolean *params)

1496

{

1497

SIG( "glGetBooleanv" );

1498

dllGetBooleanv( pname, params );

1499

}

1500

1501

static void APIENTRY logGetClipPlane(GLenum plane, GLdouble *equation)

1502

{

1503

SIG( "glGetClipPlane" );

1504

dllGetClipPlane( plane, equation );

1505

}

1506

1507

static void APIENTRY logGetDoublev(GLenum pname, GLdouble *params)

1508

{

1509

SIG( "glGetDoublev" );

1510

dllGetDoublev( pname, params );

1511

}

1512

1513

static GLenum APIENTRY logGetError(void)

1514

{

1515

SIG( "glGetError" );

1516

return dllGetError();

1517

}

1518

1519

static void APIENTRY logGetFloatv(GLenum pname, GLfloat *params)

1520

{

1521

SIG( "glGetFloatv" );

1522

dllGetFloatv( pname, params );

1523

}

1524

1525

static void APIENTRY logGetIntegerv(GLenum pname, GLint *params)

1526

{

1527

SIG( "glGetIntegerv" );

1528

dllGetIntegerv( pname, params );

1529

}

1530

1531

static void APIENTRY logGetLightfv(GLenum light, GLenum pname, GLfloat *params)

1532

{

1533

SIG( "glGetLightfv" );

1534

dllGetLightfv( light, pname, params );

1535

}

1536

1537

static void APIENTRY logGetLightiv(GLenum light, GLenum pname, GLint *params)

1538

{

1539

SIG( "glGetLightiv" );

1540

dllGetLightiv( light, pname, params );

1541

}

1542

1543

static void APIENTRY logGetMapdv(GLenum target, GLenum query, GLdouble *v)

1544

{

1545

SIG( "glGetMapdv" );

1546

dllGetMapdv( target, query, v );

1547

}

1548

1549

static void APIENTRY logGetMapfv(GLenum target, GLenum query, GLfloat *v)

1550

{

1551

SIG( "glGetMapfv" );

1552

dllGetMapfv( target, query, v );

1553

}

1554

1555

static void APIENTRY logGetMapiv(GLenum target, GLenum query, GLint *v)

1556

{

1557

SIG( "glGetMapiv" );

1558

dllGetMapiv( target, query, v );

1559

}

1560

1561

static void APIENTRY logGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)

1562

{

1563

SIG( "glGetMaterialfv" );

1564

dllGetMaterialfv( face, pname, params );

1565

}

1566

1567

static void APIENTRY logGetMaterialiv(GLenum face, GLenum pname, GLint *params)

1568

{

1569

SIG( "glGetMaterialiv" );

1570

dllGetMaterialiv( face, pname, params );

1571

}

1572

1573

static void APIENTRY logGetPixelMapfv(GLenum map, GLfloat *values)

1574

{

1575

SIG( "glGetPixelMapfv" );

1576

dllGetPixelMapfv( map, values );

1577

}

1578

1579

static void APIENTRY logGetPixelMapuiv(GLenum map, GLuint *values)

1580

{

1581

SIG( "glGetPixelMapuiv" );

1582

dllGetPixelMapuiv( map, values );

1583

}

1584

1585

static void APIENTRY logGetPixelMapusv(GLenum map, GLushort *values)

1586

{

1587

SIG( "glGetPixelMapusv" );

1588

dllGetPixelMapusv( map, values );

1589

}

1590

1591

static void APIENTRY logGetPointerv(GLenum pname, GLvoid* *params)

1592

{

1593

SIG( "glGetPointerv" );

1594

dllGetPointerv( pname, params );

1595

}

1596

1597

static void APIENTRY logGetPolygonStipple(GLubyte *mask)

1598

{

1599

SIG( "glGetPolygonStipple" );

1600

dllGetPolygonStipple( mask );

1601

}

1602

1603

static const GLubyte * APIENTRY logGetString(GLenum name)

1604

{

1605

SIG( "glGetString" );

1606

return dllGetString( name );

1607

}

1608

1609

static void APIENTRY logGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)

1610

{

1611

SIG( "glGetTexEnvfv" );

1612

dllGetTexEnvfv( target, pname, params );

1613

}

1614

1615

static void APIENTRY logGetTexEnviv(GLenum target, GLenum pname, GLint *params)

1616

{

1617

SIG( "glGetTexEnviv" );

1618

dllGetTexEnviv( target, pname, params );

1619

}

1620

1621

static void APIENTRY logGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)

1622

{

1623

SIG( "glGetTexGendv" );

1624

dllGetTexGendv( coord, pname, params );

1625

}

1626

1627

static void APIENTRY logGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)

1628

{

1629

SIG( "glGetTexGenfv" );

1630

dllGetTexGenfv( coord, pname, params );

1631

}

1632

1633

static void APIENTRY logGetTexGeniv(GLenum coord, GLenum pname, GLint *params)

1634

{

1635

SIG( "glGetTexGeniv" );

1636

dllGetTexGeniv( coord, pname, params );

1637

}

1638

1639

static void APIENTRY logGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)

1640

{

1641

SIG( "glGetTexImage" );

1642

dllGetTexImage( target, level, format, type, pixels );

1643

}

1644

static void APIENTRY logGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params )

1645

{

1646

SIG( "glGetTexLevelParameterfv" );

1647

dllGetTexLevelParameterfv( target, level, pname, params );

1648

}

1649

1650

static void APIENTRY logGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)

1651

{

1652

SIG( "glGetTexLevelParameteriv" );

1653

dllGetTexLevelParameteriv( target, level, pname, params );

1654

}

1655

1656

static void APIENTRY logGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)

1657

{

1658

SIG( "glGetTexParameterfv" );

1659

dllGetTexParameterfv( target, pname, params );

1660

}

1661

1662

static void APIENTRY logGetTexParameteriv(GLenum target, GLenum pname, GLint *params)

1663

{

1664

SIG( "glGetTexParameteriv" );

1665

dllGetTexParameteriv( target, pname, params );

1666

}

1667

1668

static void APIENTRY logHint(GLenum target, GLenum mode)

1669

{

1670

fprintf( glw_state.log_fp, "glHint( 0x%x, 0x%x )\n", target, mode );

1671

dllHint( target, mode );

1672

}

1673

1674

static void APIENTRY logIndexMask(GLuint mask)

1675

{

1676

SIG( "glIndexMask" );

1677

dllIndexMask( mask );

1678

}

1679

1680

static void APIENTRY logIndexPointer(GLenum type, GLsizei stride, const void *pointer)

1681

{

1682

SIG( "glIndexPointer" );

1683

dllIndexPointer( type, stride, pointer );

1684

}

1685

1686

static void APIENTRY logIndexd(GLdouble c)

1687

{

1688

SIG( "glIndexd" );

1689

dllIndexd( c );

1690

}

1691

1692

static void APIENTRY logIndexdv(const GLdouble *c)

1693

{

1694

SIG( "glIndexdv" );

1695

dllIndexdv( c );

1696

}

1697

1698

static void APIENTRY logIndexf(GLfloat c)

1699

{

1700

SIG( "glIndexf" );

1701

dllIndexf( c );

1702

}

1703

1704

static void APIENTRY logIndexfv(const GLfloat *c)

1705

{

1706

SIG( "glIndexfv" );

1707

dllIndexfv( c );

1708

}

1709

1710

static void APIENTRY logIndexi(GLint c)

1711

{

1712

SIG( "glIndexi" );

1713

dllIndexi( c );

1714

}

1715

1716

static void APIENTRY logIndexiv(const GLint *c)

1717

{

1718

SIG( "glIndexiv" );

1719

dllIndexiv( c );

1720

}

1721

1722

static void APIENTRY logIndexs(GLshort c)

1723

{

1724

SIG( "glIndexs" );

1725

dllIndexs( c );

1726

}

1727

1728

static void APIENTRY logIndexsv(const GLshort *c)

1729

{

1730

SIG( "glIndexsv" );

1731

dllIndexsv( c );

1732

}

1733

1734

static void APIENTRY logIndexub(GLubyte c)

1735

{

1736

SIG( "glIndexub" );

1737

dllIndexub( c );

1738

}

1739

1740

static void APIENTRY logIndexubv(const GLubyte *c)

1741

{

1742

SIG( "glIndexubv" );

1743

dllIndexubv( c );

1744

}

1745

1746

static void APIENTRY logInitNames(void)

1747

{

1748

SIG( "glInitNames" );

1749

dllInitNames();

1750

}

1751

1752

static void APIENTRY logInterleavedArrays(GLenum format, GLsizei stride, const void *pointer)

1753

{

1754

SIG( "glInterleavedArrays" );

1755

dllInterleavedArrays( format, stride, pointer );

1756

}

1757

1758

static GLboolean APIENTRY logIsEnabled(GLenum cap)

1759

{

1760

SIG( "glIsEnabled" );

1761

return dllIsEnabled( cap );

1762

}

1763

static GLboolean APIENTRY logIsList(GLuint list)

1764

{

1765

SIG( "glIsList" );

1766

return dllIsList( list );

1767

}

1768

static GLboolean APIENTRY logIsTexture(GLuint texture)

1769

{

1770

SIG( "glIsTexture" );

1771

return dllIsTexture( texture );

1772

}

1773

1774

static void APIENTRY logLightModelf(GLenum pname, GLfloat param)

1775

{

1776

SIG( "glLightModelf" );

1777

dllLightModelf( pname, param );

1778

}

1779

1780

static void APIENTRY logLightModelfv(GLenum pname, const GLfloat *params)

1781

{

1782

SIG( "glLightModelfv" );

1783

dllLightModelfv( pname, params );

1784

}

1785

1786

static void APIENTRY logLightModeli(GLenum pname, GLint param)

1787

{

1788

SIG( "glLightModeli" );

1789

dllLightModeli( pname, param );

1790

1791

}

1792

1793

static void APIENTRY logLightModeliv(GLenum pname, const GLint *params)

1794

{

1795

SIG( "glLightModeliv" );

1796

dllLightModeliv( pname, params );

1797

}

1798

1799

static void APIENTRY logLightf(GLenum light, GLenum pname, GLfloat param)

1800

{

1801

SIG( "glLightf" );

1802

dllLightf( light, pname, param );

1803

}

1804

1805

static void APIENTRY logLightfv(GLenum light, GLenum pname, const GLfloat *params)

1806

{

1807

SIG( "glLightfv" );

1808

dllLightfv( light, pname, params );

1809

}

1810

1811

static void APIENTRY logLighti(GLenum light, GLenum pname, GLint param)

1812

{

1813

SIG( "glLighti" );

1814

dllLighti( light, pname, param );

1815

}

1816

1817

static void APIENTRY logLightiv(GLenum light, GLenum pname, const GLint *params)

1818

{

1819

SIG( "glLightiv" );

1820

dllLightiv( light, pname, params );

1821

}

1822

1823

static void APIENTRY logLineStipple(GLint factor, GLushort pattern)

1824

{

1825

SIG( "glLineStipple" );

1826

dllLineStipple( factor, pattern );

1827

}

1828

1829

static void APIENTRY logLineWidth(GLfloat width)

1830

{

1831

SIG( "glLineWidth" );

1832

dllLineWidth( width );

1833

}

1834

1835

static void APIENTRY logListBase(GLuint base)

1836

{

1837

SIG( "glListBase" );

1838

dllListBase( base );

1839

}

1840

1841

static void APIENTRY logLoadIdentity(void)

1842

{

1843

SIG( "glLoadIdentity" );

1844

dllLoadIdentity();

1845

}

1846

1847

static void APIENTRY logLoadMatrixd(const GLdouble *m)

1848

{

1849

SIG( "glLoadMatrixd" );

1850

dllLoadMatrixd( m );

1851

}

1852

1853

static void APIENTRY logLoadMatrixf(const GLfloat *m)

1854

{

1855

SIG( "glLoadMatrixf" );

1856

dllLoadMatrixf( m );

1857

}

1858

1859

static void APIENTRY logLoadName(GLuint name)

1860

{

1861

SIG( "glLoadName" );

1862

dllLoadName( name );

1863

}

1864

1865

static void APIENTRY logLogicOp(GLenum opcode)

1866

{

1867

SIG( "glLogicOp" );

1868

dllLogicOp( opcode );

1869

}

1870

1871

static void APIENTRY logMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)

1872

{

1873

SIG( "glMap1d" );

1874

dllMap1d( target, u1, u2, stride, order, points );

1875

}

1876

1877

static void APIENTRY logMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)

1878

{

1879

SIG( "glMap1f" );

1880

dllMap1f( target, u1, u2, stride, order, points );

1881

}

1882

1883

static void APIENTRY logMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)

1884

{

1885

SIG( "glMap2d" );

1886

dllMap2d( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );

1887

}

1888

1889

static void APIENTRY logMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)

1890

{

1891

SIG( "glMap2f" );

1892

dllMap2f( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );

1893

}

1894

1895

static void APIENTRY logMapGrid1d(GLint un, GLdouble u1, GLdouble u2)

1896

{

1897

SIG( "glMapGrid1d" );

1898

dllMapGrid1d( un, u1, u2 );

1899

}

1900

1901

static void APIENTRY logMapGrid1f(GLint un, GLfloat u1, GLfloat u2)

1902

{

1903

SIG( "glMapGrid1f" );

1904

dllMapGrid1f( un, u1, u2 );

1905

}

1906

1907

static void APIENTRY logMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)

1908

{

1909

SIG( "glMapGrid2d" );

1910

dllMapGrid2d( un, u1, u2, vn, v1, v2 );

1911

}

1912

static void APIENTRY logMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)

1913

{

1914

SIG( "glMapGrid2f" );

1915

dllMapGrid2f( un, u1, u2, vn, v1, v2 );

1916

}

1917

static void APIENTRY logMaterialf(GLenum face, GLenum pname, GLfloat param)

1918

{

1919

SIG( "glMaterialf" );

1920

dllMaterialf( face, pname, param );

1921

}

1922

static void APIENTRY logMaterialfv(GLenum face, GLenum pname, const GLfloat *params)

1923

{

1924

SIG( "glMaterialfv" );

1925

dllMaterialfv( face, pname, params );

1926

}

1927

1928

static void APIENTRY logMateriali(GLenum face, GLenum pname, GLint param)

1929

{

1930

SIG( "glMateriali" );

1931

dllMateriali( face, pname, param );

1932

}

1933

1934

static void APIENTRY logMaterialiv(GLenum face, GLenum pname, const GLint *params)

1935

{

1936

SIG( "glMaterialiv" );

1937

dllMaterialiv( face, pname, params );

1938

}

1939

1940

static void APIENTRY logMatrixMode(GLenum mode)

1941

{

1942

SIG( "glMatrixMode" );

1943

dllMatrixMode( mode );

1944

}

1945

1946

static void APIENTRY logMultMatrixd(const GLdouble *m)

1947

{

1948

SIG( "glMultMatrixd" );

1949

dllMultMatrixd( m );

1950

}

1951

1952

static void APIENTRY logMultMatrixf(const GLfloat *m)

1953

{

1954

SIG( "glMultMatrixf" );

1955

dllMultMatrixf( m );

1956

}

1957

1958

static void APIENTRY logNewList(GLuint list, GLenum mode)

1959

{

1960

SIG( "glNewList" );

1961

dllNewList( list, mode );

1962

}

1963

1964

static void APIENTRY logNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)

1965

{

1966

SIG ("glNormal3b" );

1967

dllNormal3b( nx, ny, nz );

1968

}

1969

1970

static void APIENTRY logNormal3bv(const GLbyte *v)

1971

{

1972

SIG( "glNormal3bv" );

1973

dllNormal3bv( v );

1974

}

1975

1976

static void APIENTRY logNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)

1977

{

1978

SIG( "glNormal3d" );

1979

dllNormal3d( nx, ny, nz );

1980

}

1981

1982

static void APIENTRY logNormal3dv(const GLdouble *v)

1983

{

1984

SIG( "glNormal3dv" );

1985

dllNormal3dv( v );

1986

}

1987

1988

static void APIENTRY logNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)

1989

{

1990

SIG( "glNormal3f" );

1991

dllNormal3f( nx, ny, nz );

1992

}

1993

1994

static void APIENTRY logNormal3fv(const GLfloat *v)

1995

{

1996

SIG( "glNormal3fv" );

1997

dllNormal3fv( v );

1998

}

1999

static void APIENTRY logNormal3i(GLint nx, GLint ny, GLint nz)

2000

{

2001

SIG( "glNormal3i" );

2002

dllNormal3i( nx, ny, nz );

2003

}

2004

static void APIENTRY logNormal3iv(const GLint *v)

2005

{

2006

SIG( "glNormal3iv" );

2007

dllNormal3iv( v );

2008

}

2009

static void APIENTRY logNormal3s(GLshort nx, GLshort ny, GLshort nz)

2010

{

2011

SIG( "glNormal3s" );

2012

dllNormal3s( nx, ny, nz );

2013

}

2014

static void APIENTRY logNormal3sv(const GLshort *v)

2015

{

2016

SIG( "glNormal3sv" );

2017

dllNormal3sv( v );

2018

}

2019

static void APIENTRY logNormalPointer(GLenum type, GLsizei stride, const void *pointer)

2020

{

2021

SIG( "glNormalPointer" );

2022

dllNormalPointer( type, stride, pointer );

2023

}

2024

static void APIENTRY logOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)

2025

{

2026

SIG( "glOrtho" );

2027

dllOrtho( left, right, bottom, top, zNear, zFar );

2028

}

2029

2030

static void APIENTRY logPassThrough(GLfloat token)

2031

{

2032

SIG( "glPassThrough" );

2033

dllPassThrough( token );

2034

}

2035

2036

static void APIENTRY logPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)

2037

{

2038

SIG( "glPixelMapfv" );

2039

dllPixelMapfv( map, mapsize, values );

2040

}

2041

2042

static void APIENTRY logPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)

2043

{

2044

SIG( "glPixelMapuiv" );

2045

dllPixelMapuiv( map, mapsize, values );

2046

}

2047

2048

static void APIENTRY logPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)

2049

{

2050

SIG( "glPixelMapusv" );

2051

dllPixelMapusv( map, mapsize, values );

2052

}

2053

static void APIENTRY logPixelStoref(GLenum pname, GLfloat param)

2054

{

2055

SIG( "glPixelStoref" );

2056

dllPixelStoref( pname, param );

2057

}

2058

static void APIENTRY logPixelStorei(GLenum pname, GLint param)

2059

{

2060

SIG( "glPixelStorei" );

2061

dllPixelStorei( pname, param );

2062

}

2063

static void APIENTRY logPixelTransferf(GLenum pname, GLfloat param)

2064

{

2065

SIG( "glPixelTransferf" );

2066

dllPixelTransferf( pname, param );

2067

}

2068

2069

static void APIENTRY logPixelTransferi(GLenum pname, GLint param)

2070

{

2071

SIG( "glPixelTransferi" );

2072

dllPixelTransferi( pname, param );

2073

}

2074

2075

static void APIENTRY logPixelZoom(GLfloat xfactor, GLfloat yfactor)

2076

{

2077

SIG( "glPixelZoom" );

2078

dllPixelZoom( xfactor, yfactor );

2079

}

2080

2081

static void APIENTRY logPointSize(GLfloat size)

2082

{

2083

SIG( "glPointSize" );

2084

dllPointSize( size );

2085

}

2086

2087

static void APIENTRY logPolygonMode(GLenum face, GLenum mode)

2088

{

2089

fprintf( glw_state.log_fp, "glPolygonMode( 0x%x, 0x%x )\n", face, mode );

2090

dllPolygonMode( face, mode );

2091

}

2092

2093

static void APIENTRY logPolygonOffset(GLfloat factor, GLfloat units)

2094

{

2095

SIG( "glPolygonOffset" );

2096

dllPolygonOffset( factor, units );

2097

}

2098

static void APIENTRY logPolygonStipple(const GLubyte *mask )

2099

{

2100

SIG( "glPolygonStipple" );

2101

dllPolygonStipple( mask );

2102

}

2103

static void APIENTRY logPopAttrib(void)

2104

{

2105

SIG( "glPopAttrib" );

2106

dllPopAttrib();

2107

}

2108

2109

static void APIENTRY logPopClientAttrib(void)

2110

{

2111

SIG( "glPopClientAttrib" );

2112

dllPopClientAttrib();

2113

}

2114

2115

static void APIENTRY logPopMatrix(void)

2116

{

2117

SIG( "glPopMatrix" );

2118

dllPopMatrix();

2119

}

2120

2121

static void APIENTRY logPopName(void)

2122

{

2123

SIG( "glPopName" );

2124

dllPopName();

2125

}

2126

2127

static void APIENTRY logPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)

2128

{

2129

SIG( "glPrioritizeTextures" );

2130

dllPrioritizeTextures( n, textures, priorities );

2131

}

2132

2133

static void APIENTRY logPushAttrib(GLbitfield mask)

2134

{

2135

SIG( "glPushAttrib" );

2136

dllPushAttrib( mask );

2137

}

2138

2139

static void APIENTRY logPushClientAttrib(GLbitfield mask)

2140

{

2141

SIG( "glPushClientAttrib" );

2142

dllPushClientAttrib( mask );

2143

}

2144

2145

static void APIENTRY logPushMatrix(void)

2146

{

2147

SIG( "glPushMatrix" );

2148

dllPushMatrix();

2149

}

2150

2151

static void APIENTRY logPushName(GLuint name)

2152

{

2153

SIG( "glPushName" );

2154

dllPushName( name );

2155

}

2156

2157

static void APIENTRY logRasterPos2d(GLdouble x, GLdouble y)

2158

{

2159

SIG ("glRasterPot2d" );

2160

dllRasterPos2d( x, y );

2161

}

2162

2163

static void APIENTRY logRasterPos2dv(const GLdouble *v)

2164

{

2165

SIG( "glRasterPos2dv" );

2166

dllRasterPos2dv( v );

2167

}

2168

2169

static void APIENTRY logRasterPos2f(GLfloat x, GLfloat y)

2170

{

2171

SIG( "glRasterPos2f" );

2172

dllRasterPos2f( x, y );

2173

}

2174

static void APIENTRY logRasterPos2fv(const GLfloat *v)

2175

{

2176

SIG( "glRasterPos2dv" );

2177

dllRasterPos2fv( v );

2178

}

2179

static void APIENTRY logRasterPos2i(GLint x, GLint y)

2180

{

2181

SIG( "glRasterPos2if" );

2182

dllRasterPos2i( x, y );

2183

}

2184

static void APIENTRY logRasterPos2iv(const GLint *v)

2185

{

2186

SIG( "glRasterPos2iv" );

2187

dllRasterPos2iv( v );

2188

}

2189

static void APIENTRY logRasterPos2s(GLshort x, GLshort y)

2190

{

2191

SIG( "glRasterPos2s" );

2192

dllRasterPos2s( x, y );

2193

}

2194

static void APIENTRY logRasterPos2sv(const GLshort *v)

2195

{

2196

SIG( "glRasterPos2sv" );

2197

dllRasterPos2sv( v );

2198

}

2199

static void APIENTRY logRasterPos3d(GLdouble x, GLdouble y, GLdouble z)

2200

{

2201

SIG( "glRasterPos3d" );

2202

dllRasterPos3d( x, y, z );

2203

}

2204

static void APIENTRY logRasterPos3dv(const GLdouble *v)

2205

{

2206

SIG( "glRasterPos3dv" );

2207

dllRasterPos3dv( v );

2208

}

2209

static void APIENTRY logRasterPos3f(GLfloat x, GLfloat y, GLfloat z)

2210

{

2211

SIG( "glRasterPos3f" );

2212

dllRasterPos3f( x, y, z );

2213

}

2214

static void APIENTRY logRasterPos3fv(const GLfloat *v)

2215

{

2216

SIG( "glRasterPos3fv" );

2217

dllRasterPos3fv( v );

2218

}

2219

static void APIENTRY logRasterPos3i(GLint x, GLint y, GLint z)

2220

{

2221

SIG( "glRasterPos3i" );

2222

dllRasterPos3i( x, y, z );

2223

}

2224

static void APIENTRY logRasterPos3iv(const GLint *v)

2225

{

2226

SIG( "glRasterPos3iv" );

2227

dllRasterPos3iv( v );

2228

}

2229

static void APIENTRY logRasterPos3s(GLshort x, GLshort y, GLshort z)

2230

{

2231

SIG( "glRasterPos3s" );

2232

dllRasterPos3s( x, y, z );

2233

}

2234

static void APIENTRY logRasterPos3sv(const GLshort *v)

2235

{

2236

SIG( "glRasterPos3sv" );

2237

dllRasterPos3sv( v );

2238

}

2239

static void APIENTRY logRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)

2240

{

2241

SIG( "glRasterPos4d" );

2242

dllRasterPos4d( x, y, z, w );

2243

}

2244

static void APIENTRY logRasterPos4dv(const GLdouble *v)

2245

{

2246

SIG( "glRasterPos4dv" );

2247

dllRasterPos4dv( v );

2248

}

2249

static void APIENTRY logRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)

2250

{

2251

SIG( "glRasterPos4f" );

2252

dllRasterPos4f( x, y, z, w );

2253

}

2254

static void APIENTRY logRasterPos4fv(const GLfloat *v)

2255

{

2256

SIG( "glRasterPos4fv" );

2257

dllRasterPos4fv( v );

2258

}

2259

static void APIENTRY logRasterPos4i(GLint x, GLint y, GLint z, GLint w)

2260

{

2261

SIG( "glRasterPos4i" );

2262

dllRasterPos4i( x, y, z, w );

2263

}

2264

static void APIENTRY logRasterPos4iv(const GLint *v)

2265

{

2266

SIG( "glRasterPos4iv" );

2267

dllRasterPos4iv( v );

2268

}

2269

static void APIENTRY logRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)

2270

{

2271

SIG( "glRasterPos4s" );

2272

dllRasterPos4s( x, y, z, w );

2273

}

2274

static void APIENTRY logRasterPos4sv(const GLshort *v)

2275

{

2276

SIG( "glRasterPos4sv" );

2277

dllRasterPos4sv( v );

2278

}

2279

static void APIENTRY logReadBuffer(GLenum mode)

2280

{

2281

SIG( "glReadBuffer" );

2282

dllReadBuffer( mode );

2283

}

2284

static void APIENTRY logReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)

2285

{

2286

SIG( "glReadPixels" );

2287

dllReadPixels( x, y, width, height, format, type, pixels );

2288

}

2289

2290

static void APIENTRY logRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)

2291

{

2292

SIG( "glRectd" );

2293

dllRectd( x1, y1, x2, y2 );

2294

}

2295

2296

static void APIENTRY logRectdv(const GLdouble *v1, const GLdouble *v2)

2297

{

2298

SIG( "glRectdv" );

2299

dllRectdv( v1, v2 );

2300

}

2301

2302

static void APIENTRY logRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)

2303

{

2304

SIG( "glRectf" );

2305

dllRectf( x1, y1, x2, y2 );

2306

}

2307

2308

static void APIENTRY logRectfv(const GLfloat *v1, const GLfloat *v2)

2309

{

2310

SIG( "glRectfv" );

2311

dllRectfv( v1, v2 );

2312

}

2313

static void APIENTRY logRecti(GLint x1, GLint y1, GLint x2, GLint y2)

2314

{

2315

SIG( "glRecti" );

2316

dllRecti( x1, y1, x2, y2 );

2317

}

2318

static void APIENTRY logRectiv(const GLint *v1, const GLint *v2)

2319

{

2320

SIG( "glRectiv" );

2321

dllRectiv( v1, v2 );

2322

}

2323

static void APIENTRY logRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)

2324

{

2325

SIG( "glRects" );

2326

dllRects( x1, y1, x2, y2 );

2327

}

2328

static void APIENTRY logRectsv(const GLshort *v1, const GLshort *v2)

2329

{

2330

SIG( "glRectsv" );

2331

dllRectsv( v1, v2 );

2332

}

2333

static GLint APIENTRY logRenderMode(GLenum mode)

2334

{

2335

SIG( "glRenderMode" );

2336

return dllRenderMode( mode );

2337

}

2338

static void APIENTRY logRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)

2339

{

2340

SIG( "glRotated" );

2341

dllRotated( angle, x, y, z );

2342

}

2343

2344

static void APIENTRY logRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)

2345

{

2346

SIG( "glRotatef" );

2347

dllRotatef( angle, x, y, z );

2348

}

2349

2350

static void APIENTRY logScaled(GLdouble x, GLdouble y, GLdouble z)

2351

{

2352

SIG( "glScaled" );

2353

dllScaled( x, y, z );

2354

}

2355

2356

static void APIENTRY logScalef(GLfloat x, GLfloat y, GLfloat z)

2357

{

2358

SIG( "glScalef" );

2359

dllScalef( x, y, z );

2360

}

2361

2362

static void APIENTRY logScissor(GLint x, GLint y, GLsizei width, GLsizei height)

2363

{

2364

fprintf( glw_state.log_fp, "glScissor( %d, %d, %d, %d )\n", x, y, width, height );

2365

dllScissor( x, y, width, height );

2366

}

2367

2368

static void APIENTRY logSelectBuffer(GLsizei size, GLuint *buffer)

2369

{

2370

SIG( "glSelectBuffer" );

2371

dllSelectBuffer( size, buffer );

2372

}

2373

2374

static void APIENTRY logShadeModel(GLenum mode)

2375

{

2376

SIG( "glShadeModel" );

2377

dllShadeModel( mode );

2378

}

2379

2380

static void APIENTRY logStencilFunc(GLenum func, GLint ref, GLuint mask)

2381

{

2382

SIG( "glStencilFunc" );

2383

dllStencilFunc( func, ref, mask );

2384

}

2385

2386

static void APIENTRY logStencilMask(GLuint mask)

2387

{

2388

SIG( "glStencilMask" );

2389

dllStencilMask( mask );

2390

}

2391

2392

static void APIENTRY logStencilOp(GLenum fail, GLenum zfail, GLenum zpass)

2393

{

2394

SIG( "glStencilOp" );

2395

dllStencilOp( fail, zfail, zpass );

2396

}

2397

2398

static void APIENTRY logTexCoord1d(GLdouble s)

2399

{

2400

SIG( "glTexCoord1d" );

2401

dllTexCoord1d( s );

2402

}

2403

2404

static void APIENTRY logTexCoord1dv(const GLdouble *v)

2405

{

2406

SIG( "glTexCoord1dv" );

2407

dllTexCoord1dv( v );

2408

}

2409

2410

static void APIENTRY logTexCoord1f(GLfloat s)

2411

{

2412

SIG( "glTexCoord1f" );

2413

dllTexCoord1f( s );

2414

}

2415

static void APIENTRY logTexCoord1fv(const GLfloat *v)

2416

{

2417

SIG( "glTexCoord1fv" );

2418

dllTexCoord1fv( v );

2419

}

2420

static void APIENTRY logTexCoord1i(GLint s)

2421

{

2422

SIG( "glTexCoord1i" );

2423

dllTexCoord1i( s );

2424

}

2425

static void APIENTRY logTexCoord1iv(const GLint *v)

2426

{

2427

SIG( "glTexCoord1iv" );

2428

dllTexCoord1iv( v );

2429

}

2430

static void APIENTRY logTexCoord1s(GLshort s)

2431

{

2432

SIG( "glTexCoord1s" );

2433

dllTexCoord1s( s );

2434

}

2435

static void APIENTRY logTexCoord1sv(const GLshort *v)

2436

{

2437

SIG( "glTexCoord1sv" );

2438

dllTexCoord1sv( v );

2439

}

2440

static void APIENTRY logTexCoord2d(GLdouble s, GLdouble t)

2441

{

2442

SIG( "glTexCoord2d" );

2443

dllTexCoord2d( s, t );

2444

}

2445

2446

static void APIENTRY logTexCoord2dv(const GLdouble *v)

2447

{

2448

SIG( "glTexCoord2dv" );

2449

dllTexCoord2dv( v );

2450

}

2451

static void APIENTRY logTexCoord2f(GLfloat s, GLfloat t)

2452

{

2453

SIG( "glTexCoord2f" );

2454

dllTexCoord2f( s, t );

2455

}

2456

static void APIENTRY logTexCoord2fv(const GLfloat *v)

2457

{

2458

SIG( "glTexCoord2fv" );

2459

dllTexCoord2fv( v );

2460

}

2461

static void APIENTRY logTexCoord2i(GLint s, GLint t)

2462

{

2463

SIG( "glTexCoord2i" );

2464

dllTexCoord2i( s, t );

2465

}

2466

static void APIENTRY logTexCoord2iv(const GLint *v)

2467

{

2468

SIG( "glTexCoord2iv" );

2469

dllTexCoord2iv( v );

2470

}

2471

static void APIENTRY logTexCoord2s(GLshort s, GLshort t)

2472

{

2473

SIG( "glTexCoord2s" );

2474

dllTexCoord2s( s, t );

2475

}

2476

static void APIENTRY logTexCoord2sv(const GLshort *v)

2477

{

2478

SIG( "glTexCoord2sv" );

2479

dllTexCoord2sv( v );

2480

}

2481

static void APIENTRY logTexCoord3d(GLdouble s, GLdouble t, GLdouble r)

2482

{

2483

SIG( "glTexCoord3d" );

2484

dllTexCoord3d( s, t, r );

2485

}

2486

static void APIENTRY logTexCoord3dv(const GLdouble *v)

2487

{

2488

SIG( "glTexCoord3dv" );

2489

dllTexCoord3dv( v );

2490

}

2491

static void APIENTRY logTexCoord3f(GLfloat s, GLfloat t, GLfloat r)

2492

{

2493

SIG( "glTexCoord3f" );

2494

dllTexCoord3f( s, t, r );

2495

}

2496

static void APIENTRY logTexCoord3fv(const GLfloat *v)

2497

{

2498

SIG( "glTexCoord3fv" );

2499

dllTexCoord3fv( v );

2500

}

2501

static void APIENTRY logTexCoord3i(GLint s, GLint t, GLint r)

2502

{

2503

SIG( "glTexCoord3i" );

2504

dllTexCoord3i( s, t, r );

2505

}

2506

static void APIENTRY logTexCoord3iv(const GLint *v)

2507

{

2508

SIG( "glTexCoord3iv" );

2509

dllTexCoord3iv( v );

2510

}

2511

static void APIENTRY logTexCoord3s(GLshort s, GLshort t, GLshort r)

2512

{

2513

SIG( "glTexCoord3s" );

2514

dllTexCoord3s( s, t, r );

2515

}

2516

static void APIENTRY logTexCoord3sv(const GLshort *v)

2517

{

2518

SIG( "glTexCoord3sv" );

2519

dllTexCoord3sv( v );

2520

}

2521

static void APIENTRY logTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)

2522

{

2523

SIG( "glTexCoord4d" );

2524

dllTexCoord4d( s, t, r, q );

2525

}

2526

static void APIENTRY logTexCoord4dv(const GLdouble *v)

2527

{

2528

SIG( "glTexCoord4dv" );

2529

dllTexCoord4dv( v );

2530

}

2531

static void APIENTRY logTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)

2532

{

2533

SIG( "glTexCoord4f" );

2534

dllTexCoord4f( s, t, r, q );

2535

}

2536

static void APIENTRY logTexCoord4fv(const GLfloat *v)

2537

{

2538

SIG( "glTexCoord4fv" );

2539

dllTexCoord4fv( v );

2540

}

2541

static void APIENTRY logTexCoord4i(GLint s, GLint t, GLint r, GLint q)

2542

{

2543

SIG( "glTexCoord4i" );

2544

dllTexCoord4i( s, t, r, q );

2545

}

2546

static void APIENTRY logTexCoord4iv(const GLint *v)

2547

{

2548

SIG( "glTexCoord4iv" );

2549

dllTexCoord4iv( v );

2550

}

2551

static void APIENTRY logTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)

2552

{

2553

SIG( "glTexCoord4s" );

2554

dllTexCoord4s( s, t, r, q );

2555

}

2556

static void APIENTRY logTexCoord4sv(const GLshort *v)

2557

{

2558

SIG( "glTexCoord4sv" );

2559

dllTexCoord4sv( v );

2560

}

2561

static void APIENTRY logTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)

2562

{

2563

fprintf( glw_state.log_fp, "glTexCoordPointer( %d, %s, %d, MEM )\n", size, TypeToString( type ), stride );

2564

dllTexCoordPointer( size, type, stride, pointer );

2565

}

2566

2567

static void APIENTRY logTexEnvf(GLenum target, GLenum pname, GLfloat param)

2568

{

2569

fprintf( glw_state.log_fp, "glTexEnvf( 0x%x, 0x%x, %f )\n", target, pname, param );

2570

dllTexEnvf( target, pname, param );

2571

}

2572

2573

static void APIENTRY logTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)

2574

{

2575

SIG( "glTexEnvfv" );

2576

dllTexEnvfv( target, pname, params );

2577

}

2578

2579

static void APIENTRY logTexEnvi(GLenum target, GLenum pname, GLint param)

2580

{

2581

fprintf( glw_state.log_fp, "glTexEnvi( 0x%x, 0x%x, 0x%x )\n", target, pname, param );

2582

dllTexEnvi( target, pname, param );

2583

}

2584

static void APIENTRY logTexEnviv(GLenum target, GLenum pname, const GLint *params)

2585

{

2586

SIG( "glTexEnviv" );

2587

dllTexEnviv( target, pname, params );

2588

}

2589

2590

static void APIENTRY logTexGend(GLenum coord, GLenum pname, GLdouble param)

2591

{

2592

SIG( "glTexGend" );

2593

dllTexGend( coord, pname, param );

2594

}

2595

2596

static void APIENTRY logTexGendv(GLenum coord, GLenum pname, const GLdouble *params)

2597

{

2598

SIG( "glTexGendv" );

2599

dllTexGendv( coord, pname, params );

2600

}

2601

2602

static void APIENTRY logTexGenf(GLenum coord, GLenum pname, GLfloat param)

2603

{

2604

SIG( "glTexGenf" );

2605

dllTexGenf( coord, pname, param );

2606

}

2607

static void APIENTRY logTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)

2608

{

2609

SIG( "glTexGenfv" );

2610

dllTexGenfv( coord, pname, params );

2611

}

2612

static void APIENTRY logTexGeni(GLenum coord, GLenum pname, GLint param)

2613

{

2614

SIG( "glTexGeni" );

2615

dllTexGeni( coord, pname, param );

2616

}

2617

static void APIENTRY logTexGeniv(GLenum coord, GLenum pname, const GLint *params)

2618

{

2619

SIG( "glTexGeniv" );

2620

dllTexGeniv( coord, pname, params );

2621

}

2622

static void APIENTRY logTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)

2623

{

2624

SIG( "glTexImage1D" );

2625

dllTexImage1D( target, level, internalformat, width, border, format, type, pixels );

2626

}

2627

static void APIENTRY logTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)

2628

{

2629

SIG( "glTexImage2D" );

2630

dllTexImage2D( target, level, internalformat, width, height, border, format, type, pixels );

2631

}

2632

2633

static void APIENTRY logTexParameterf(GLenum target, GLenum pname, GLfloat param)

2634

{

2635

fprintf( glw_state.log_fp, "glTexParameterf( 0x%x, 0x%x, %f )\n", target, pname, param );

2636

dllTexParameterf( target, pname, param );

2637

}

2638

2639

static void APIENTRY logTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)

2640

{

2641

SIG( "glTexParameterfv" );

2642

dllTexParameterfv( target, pname, params );

2643

}

2644

static void APIENTRY logTexParameteri(GLenum target, GLenum pname, GLint param)

2645

{

2646

fprintf( glw_state.log_fp, "glTexParameteri( 0x%x, 0x%x, 0x%x )\n", target, pname, param );

2647

dllTexParameteri( target, pname, param );

2648

}

2649

static void APIENTRY logTexParameteriv(GLenum target, GLenum pname, const GLint *params)

2650

{

2651

SIG( "glTexParameteriv" );

2652

dllTexParameteriv( target, pname, params );

2653

}

2654

static void APIENTRY logTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)

2655

{

2656

SIG( "glTexSubImage1D" );

2657

dllTexSubImage1D( target, level, xoffset, width, format, type, pixels );

2658

}

2659

static void APIENTRY logTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)

2660

{

2661

SIG( "glTexSubImage2D" );

2662

dllTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );

2663

}

2664

static void APIENTRY logTranslated(GLdouble x, GLdouble y, GLdouble z)

2665

{

2666

SIG( "glTranslated" );

2667

dllTranslated( x, y, z );

2668

}

2669

2670

static void APIENTRY logTranslatef(GLfloat x, GLfloat y, GLfloat z)

2671

{

2672

SIG( "glTranslatef" );

2673

dllTranslatef( x, y, z );

2674

}

2675

2676

static void APIENTRY logVertex2d(GLdouble x, GLdouble y)

2677

{

2678

SIG( "glVertex2d" );

2679

dllVertex2d( x, y );

2680

}

2681

2682

static void APIENTRY logVertex2dv(const GLdouble *v)

2683

{

2684

SIG( "glVertex2dv" );

2685

dllVertex2dv( v );

2686

}

2687

static void APIENTRY logVertex2f(GLfloat x, GLfloat y)

2688

{

2689

SIG( "glVertex2f" );

2690

dllVertex2f( x, y );

2691

}

2692

static void APIENTRY logVertex2fv(const GLfloat *v)

2693

{

2694

SIG( "glVertex2fv" );

2695

dllVertex2fv( v );

2696

}

2697

static void APIENTRY logVertex2i(GLint x, GLint y)

2698

{

2699

SIG( "glVertex2i" );

2700

dllVertex2i( x, y );

2701

}

2702

static void APIENTRY logVertex2iv(const GLint *v)

2703

{

2704

SIG( "glVertex2iv" );

2705

dllVertex2iv( v );

2706

}

2707

static void APIENTRY logVertex2s(GLshort x, GLshort y)

2708

{

2709

SIG( "glVertex2s" );

2710

dllVertex2s( x, y );

2711

}

2712

static void APIENTRY logVertex2sv(const GLshort *v)

2713

{

2714

SIG( "glVertex2sv" );

2715

dllVertex2sv( v );

2716

}

2717

static void APIENTRY logVertex3d(GLdouble x, GLdouble y, GLdouble z)

2718

{

2719

SIG( "glVertex3d" );

2720

dllVertex3d( x, y, z );

2721

}

2722

static void APIENTRY logVertex3dv(const GLdouble *v)

2723

{

2724

SIG( "glVertex3dv" );

2725

dllVertex3dv( v );

2726

}

2727

static void APIENTRY logVertex3f(GLfloat x, GLfloat y, GLfloat z)

2728

{

2729

SIG( "glVertex3f" );

2730

dllVertex3f( x, y, z );

2731

}

2732

static void APIENTRY logVertex3fv(const GLfloat *v)

2733

{

2734

SIG( "glVertex3fv" );

2735

dllVertex3fv( v );

2736

}

2737

static void APIENTRY logVertex3i(GLint x, GLint y, GLint z)

2738

{

2739

SIG( "glVertex3i" );

2740

dllVertex3i( x, y, z );

2741

}

2742

static void APIENTRY logVertex3iv(const GLint *v)

2743

{

2744

SIG( "glVertex3iv" );

2745

dllVertex3iv( v );

2746

}

2747

static void APIENTRY logVertex3s(GLshort x, GLshort y, GLshort z)

2748

{

2749

SIG( "glVertex3s" );

2750

dllVertex3s( x, y, z );

2751

}

2752

static void APIENTRY logVertex3sv(const GLshort *v)

2753

{

2754

SIG( "glVertex3sv" );

2755

dllVertex3sv( v );

2756

}

2757

static void APIENTRY logVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)

2758

{

2759

SIG( "glVertex4d" );

2760

dllVertex4d( x, y, z, w );

2761

}

2762

static void APIENTRY logVertex4dv(const GLdouble *v)

2763

{

2764

SIG( "glVertex4dv" );

2765

dllVertex4dv( v );

2766

}

2767

static void APIENTRY logVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)

2768

{

2769

SIG( "glVertex4f" );

2770

dllVertex4f( x, y, z, w );

2771

}

2772

static void APIENTRY logVertex4fv(const GLfloat *v)

2773

{

2774

SIG( "glVertex4fv" );

2775

dllVertex4fv( v );

2776

}

2777

static void APIENTRY logVertex4i(GLint x, GLint y, GLint z, GLint w)

2778

{

2779

SIG( "glVertex4i" );

2780

dllVertex4i( x, y, z, w );

2781

}

2782

static void APIENTRY logVertex4iv(const GLint *v)

2783

{

2784

SIG( "glVertex4iv" );

2785

dllVertex4iv( v );

2786

}

2787

static void APIENTRY logVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)

2788

{

2789

SIG( "glVertex4s" );

2790

dllVertex4s( x, y, z, w );

2791

}

2792

static void APIENTRY logVertex4sv(const GLshort *v)

2793

{

2794

SIG( "glVertex4sv" );

2795

dllVertex4sv( v );

2796

}

2797

static void APIENTRY logVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)

2798

{

2799

fprintf( glw_state.log_fp, "glVertexPointer( %d, %s, %d, MEM )\n", size, TypeToString( type ), stride );

2800

dllVertexPointer( size, type, stride, pointer );

2801

}

2802

static void APIENTRY logViewport(GLint x, GLint y, GLsizei width, GLsizei height)

2803

{

2804

fprintf( glw_state.log_fp, "glViewport( %d, %d, %d, %d )\n", x, y, width, height );

2805

dllViewport( x, y, width, height );

2806

}

2807

2808

2809

** QGL_Shutdown

2810

2811

** Unloads the specified DLL then nulls out all the proc pointers. This

2812

** is only called during a hard shutdown of the OGL subsystem (e.g. vid_restart).

2813

2814

void QGL_Shutdown( void )

2815

{

2816

ri.Printf( PRINT_ALL, "...shutting down QGL\n" );

2817

2818

if ( glw_state.hinstOpenGL )

2819

{

2820

ri.Printf( PRINT_ALL, "...unloading OpenGL DLL\n" );

2821

FreeLibrary( glw_state.hinstOpenGL );

2822

}

2823

2824

glw_state.hinstOpenGL = NULL;

2825

2826

qglAccum = NULL;

2827

qglAlphaFunc = NULL;

2828

qglAreTexturesResident = NULL;

2829

qglArrayElement = NULL;

2830

qglBegin = NULL;

2831

qglBindTexture = NULL;

2832

qglBitmap = NULL;

2833

qglBlendFunc = NULL;

2834

qglCallList = NULL;

2835

qglCallLists = NULL;

2836

qglClear = NULL;

2837

qglClearAccum = NULL;

2838

qglClearColor = NULL;

2839

qglClearDepth = NULL;

2840

qglClearIndex = NULL;

2841

qglClearStencil = NULL;

2842

qglClipPlane = NULL;

2843

qglColor3b = NULL;

2844

qglColor3bv = NULL;

2845

qglColor3d = NULL;

2846

qglColor3dv = NULL;

2847

qglColor3f = NULL;

2848

qglColor3fv = NULL;

2849

qglColor3i = NULL;

2850

qglColor3iv = NULL;

2851

qglColor3s = NULL;

2852

qglColor3sv = NULL;

2853

qglColor3ub = NULL;

2854

qglColor3ubv = NULL;

2855

qglColor3ui = NULL;

2856

qglColor3uiv = NULL;

2857

qglColor3us = NULL;

2858

qglColor3usv = NULL;

2859

qglColor4b = NULL;

2860

qglColor4bv = NULL;

2861

qglColor4d = NULL;

2862

qglColor4dv = NULL;

2863

qglColor4f = NULL;

2864

qglColor4fv = NULL;

2865

qglColor4i = NULL;

2866

qglColor4iv = NULL;

2867

qglColor4s = NULL;

2868

qglColor4sv = NULL;

2869

qglColor4ub = NULL;

2870

qglColor4ubv = NULL;

2871

qglColor4ui = NULL;

2872

qglColor4uiv = NULL;

2873

qglColor4us = NULL;

2874

qglColor4usv = NULL;

2875

qglColorMask = NULL;

2876

qglColorMaterial = NULL;

2877

qglColorPointer = NULL;

2878

qglCopyPixels = NULL;

2879

qglCopyTexImage1D = NULL;

2880

qglCopyTexImage2D = NULL;

2881

qglCopyTexSubImage1D = NULL;

2882

qglCopyTexSubImage2D = NULL;

2883

qglCullFace = NULL;

2884

qglDeleteLists = NULL;

2885

qglDeleteTextures = NULL;

2886

qglDepthFunc = NULL;

2887

qglDepthMask = NULL;

2888

qglDepthRange = NULL;

2889

qglDisable = NULL;

2890

qglDisableClientState = NULL;

2891

qglDrawArrays = NULL;

2892

qglDrawBuffer = NULL;

2893

qglDrawElements = NULL;

2894

qglDrawPixels = NULL;

2895

qglEdgeFlag = NULL;

2896

qglEdgeFlagPointer = NULL;

2897

qglEdgeFlagv = NULL;

2898

qglEnable = NULL;

2899

qglEnableClientState = NULL;

2900

qglEnd = NULL;

2901

qglEndList = NULL;

2902

qglEvalCoord1d = NULL;

2903

qglEvalCoord1dv = NULL;

2904

qglEvalCoord1f = NULL;

2905

qglEvalCoord1fv = NULL;

2906

qglEvalCoord2d = NULL;

2907

qglEvalCoord2dv = NULL;

2908

qglEvalCoord2f = NULL;

2909

qglEvalCoord2fv = NULL;

2910

qglEvalMesh1 = NULL;

2911

qglEvalMesh2 = NULL;

2912

qglEvalPoint1 = NULL;

2913

qglEvalPoint2 = NULL;

2914

qglFeedbackBuffer = NULL;

2915

qglFinish = NULL;

2916

qglFlush = NULL;

2917

qglFogf = NULL;

2918

qglFogfv = NULL;

2919

qglFogi = NULL;

2920

qglFogiv = NULL;

2921

qglFrontFace = NULL;

2922

qglFrustum = NULL;

2923

qglGenLists = NULL;

2924

qglGenTextures = NULL;

2925

qglGetBooleanv = NULL;

2926

qglGetClipPlane = NULL;

2927

qglGetDoublev = NULL;

2928

qglGetError = NULL;

2929

qglGetFloatv = NULL;

2930

qglGetIntegerv = NULL;

2931

qglGetLightfv = NULL;

2932

qglGetLightiv = NULL;

2933

qglGetMapdv = NULL;

2934

qglGetMapfv = NULL;

2935

qglGetMapiv = NULL;

2936

qglGetMaterialfv = NULL;

2937

qglGetMaterialiv = NULL;

2938

qglGetPixelMapfv = NULL;

2939

qglGetPixelMapuiv = NULL;

2940

qglGetPixelMapusv = NULL;

2941

qglGetPointerv = NULL;

2942

qglGetPolygonStipple = NULL;

2943

qglGetString = NULL;

2944

qglGetTexEnvfv = NULL;

2945

qglGetTexEnviv = NULL;

2946

qglGetTexGendv = NULL;

2947

qglGetTexGenfv = NULL;

2948

qglGetTexGeniv = NULL;

2949

qglGetTexImage = NULL;

2950

qglGetTexLevelParameterfv = NULL;

2951

qglGetTexLevelParameteriv = NULL;

2952

qglGetTexParameterfv = NULL;

2953

qglGetTexParameteriv = NULL;

2954

qglHint = NULL;

2955

qglIndexMask = NULL;

2956

qglIndexPointer = NULL;

2957

qglIndexd = NULL;

2958

qglIndexdv = NULL;

2959

qglIndexf = NULL;

2960

qglIndexfv = NULL;

2961

qglIndexi = NULL;

2962

qglIndexiv = NULL;

2963

qglIndexs = NULL;

2964

qglIndexsv = NULL;

2965

qglIndexub = NULL;

2966

qglIndexubv = NULL;

2967

qglInitNames = NULL;

2968

qglInterleavedArrays = NULL;

2969

qglIsEnabled = NULL;

2970

qglIsList = NULL;

2971

qglIsTexture = NULL;

2972

qglLightModelf = NULL;

2973

qglLightModelfv = NULL;

2974

qglLightModeli = NULL;

2975

qglLightModeliv = NULL;

2976

qglLightf = NULL;

2977

qglLightfv = NULL;

2978

qglLighti = NULL;

2979

qglLightiv = NULL;

2980

qglLineStipple = NULL;

2981

qglLineWidth = NULL;

2982

qglListBase = NULL;

2983

qglLoadIdentity = NULL;

2984

qglLoadMatrixd = NULL;

2985

qglLoadMatrixf = NULL;

2986

qglLoadName = NULL;

2987

qglLogicOp = NULL;

2988

qglMap1d = NULL;

2989

qglMap1f = NULL;

2990

qglMap2d = NULL;

2991

qglMap2f = NULL;

2992

qglMapGrid1d = NULL;

2993

qglMapGrid1f = NULL;

2994

qglMapGrid2d = NULL;

2995

qglMapGrid2f = NULL;

2996

qglMaterialf = NULL;

2997

qglMaterialfv = NULL;

2998

qglMateriali = NULL;

2999

qglMaterialiv = NULL;

3000

qglMatrixMode = NULL;

3001

qglMultMatrixd = NULL;

3002

qglMultMatrixf = NULL;

3003

qglNewList = NULL;

3004

qglNormal3b = NULL;

3005

qglNormal3bv = NULL;

3006

qglNormal3d = NULL;

3007

qglNormal3dv = NULL;

3008

qglNormal3f = NULL;

3009

qglNormal3fv = NULL;

3010

qglNormal3i = NULL;

3011

qglNormal3iv = NULL;

3012

qglNormal3s = NULL;

3013

qglNormal3sv = NULL;

3014

qglNormalPointer = NULL;

3015

qglOrtho = NULL;

3016

qglPassThrough = NULL;

3017

qglPixelMapfv = NULL;

3018

qglPixelMapuiv = NULL;

3019

qglPixelMapusv = NULL;

3020

qglPixelStoref = NULL;

3021

qglPixelStorei = NULL;

3022

qglPixelTransferf = NULL;

3023

qglPixelTransferi = NULL;

3024

qglPixelZoom = NULL;

3025

qglPointSize = NULL;

3026

qglPolygonMode = NULL;

3027

qglPolygonOffset = NULL;

3028

qglPolygonStipple = NULL;

3029

qglPopAttrib = NULL;

3030

qglPopClientAttrib = NULL;

3031

qglPopMatrix = NULL;

3032

qglPopName = NULL;

3033

qglPrioritizeTextures = NULL;

3034

qglPushAttrib = NULL;

3035

qglPushClientAttrib = NULL;

3036

qglPushMatrix = NULL;

3037

qglPushName = NULL;

3038

qglRasterPos2d = NULL;

3039

qglRasterPos2dv = NULL;

3040

qglRasterPos2f = NULL;

3041

qglRasterPos2fv = NULL;

3042

qglRasterPos2i = NULL;

3043

qglRasterPos2iv = NULL;

3044

qglRasterPos2s = NULL;

3045

qglRasterPos2sv = NULL;

3046

qglRasterPos3d = NULL;

3047

qglRasterPos3dv = NULL;

3048

qglRasterPos3f = NULL;

3049

qglRasterPos3fv = NULL;

3050

qglRasterPos3i = NULL;

3051

qglRasterPos3iv = NULL;

3052

qglRasterPos3s = NULL;

3053

qglRasterPos3sv = NULL;

3054

qglRasterPos4d = NULL;

3055

qglRasterPos4dv = NULL;

3056

qglRasterPos4f = NULL;

3057

qglRasterPos4fv = NULL;

3058

qglRasterPos4i = NULL;

3059

qglRasterPos4iv = NULL;

3060

qglRasterPos4s = NULL;

3061

qglRasterPos4sv = NULL;

3062

qglReadBuffer = NULL;

3063

qglReadPixels = NULL;

3064

qglRectd = NULL;

3065

qglRectdv = NULL;

3066

qglRectf = NULL;

3067

qglRectfv = NULL;

3068

qglRecti = NULL;

3069

qglRectiv = NULL;

3070

qglRects = NULL;

3071

qglRectsv = NULL;

3072

qglRenderMode = NULL;

3073

qglRotated = NULL;

3074

qglRotatef = NULL;

3075

qglScaled = NULL;

3076

qglScalef = NULL;

3077

qglScissor = NULL;

3078

qglSelectBuffer = NULL;

3079

qglShadeModel = NULL;

3080

qglStencilFunc = NULL;

3081

qglStencilMask = NULL;

3082

qglStencilOp = NULL;

3083

qglTexCoord1d = NULL;

3084

qglTexCoord1dv = NULL;

3085

qglTexCoord1f = NULL;

3086

qglTexCoord1fv = NULL;

3087

qglTexCoord1i = NULL;

3088

qglTexCoord1iv = NULL;

3089

qglTexCoord1s = NULL;

3090

qglTexCoord1sv = NULL;

3091

qglTexCoord2d = NULL;

3092

qglTexCoord2dv = NULL;

3093

qglTexCoord2f = NULL;

3094

qglTexCoord2fv = NULL;

3095

qglTexCoord2i = NULL;

3096

qglTexCoord2iv = NULL;

3097

qglTexCoord2s = NULL;

3098

qglTexCoord2sv = NULL;

3099

qglTexCoord3d = NULL;

3100

qglTexCoord3dv = NULL;

3101

qglTexCoord3f = NULL;

3102

qglTexCoord3fv = NULL;

3103

qglTexCoord3i = NULL;

3104

qglTexCoord3iv = NULL;

3105

qglTexCoord3s = NULL;

3106

qglTexCoord3sv = NULL;

3107

qglTexCoord4d = NULL;

3108

qglTexCoord4dv = NULL;

3109

qglTexCoord4f = NULL;

3110

qglTexCoord4fv = NULL;

3111

qglTexCoord4i = NULL;

3112

qglTexCoord4iv = NULL;

3113

qglTexCoord4s = NULL;

3114

qglTexCoord4sv = NULL;

3115

qglTexCoordPointer = NULL;

3116

qglTexEnvf = NULL;

3117

qglTexEnvfv = NULL;

3118

qglTexEnvi = NULL;

3119

qglTexEnviv = NULL;

3120

qglTexGend = NULL;

3121

qglTexGendv = NULL;

3122

qglTexGenf = NULL;

3123

qglTexGenfv = NULL;

3124

qglTexGeni = NULL;

3125

qglTexGeniv = NULL;

3126

qglTexImage1D = NULL;

3127

qglTexImage2D = NULL;

3128

qglTexParameterf = NULL;

3129

qglTexParameterfv = NULL;

3130

qglTexParameteri = NULL;

3131

qglTexParameteriv = NULL;

3132

qglTexSubImage1D = NULL;

3133

qglTexSubImage2D = NULL;

3134

qglTranslated = NULL;

3135

qglTranslatef = NULL;

3136

qglVertex2d = NULL;

3137

qglVertex2dv = NULL;

3138

qglVertex2f = NULL;

3139

qglVertex2fv = NULL;

3140

qglVertex2i = NULL;

3141

qglVertex2iv = NULL;

3142

qglVertex2s = NULL;

3143

qglVertex2sv = NULL;

3144

qglVertex3d = NULL;

3145

qglVertex3dv = NULL;

3146

qglVertex3f = NULL;

3147

qglVertex3fv = NULL;

3148

qglVertex3i = NULL;

3149

qglVertex3iv = NULL;

3150

qglVertex3s = NULL;

3151

qglVertex3sv = NULL;

3152

qglVertex4d = NULL;

3153

qglVertex4dv = NULL;

3154

qglVertex4f = NULL;

3155

qglVertex4fv = NULL;

3156

qglVertex4i = NULL;

3157

qglVertex4iv = NULL;

3158

qglVertex4s = NULL;

3159

qglVertex4sv = NULL;

3160

qglVertexPointer = NULL;

3161

qglViewport = NULL;

3162

3163

qwglCopyContext = NULL;

3164

qwglCreateContext = NULL;

3165

qwglCreateLayerContext = NULL;

3166

qwglDeleteContext = NULL;

3167

qwglDescribeLayerPlane = NULL;

3168

qwglGetCurrentContext = NULL;

3169

qwglGetCurrentDC = NULL;

3170

qwglGetLayerPaletteEntries = NULL;

3171

qwglGetProcAddress = NULL;

3172

qwglMakeCurrent = NULL;

3173

qwglRealizeLayerPalette = NULL;

3174

qwglSetLayerPaletteEntries = NULL;

3175

qwglShareLists = NULL;

3176

qwglSwapLayerBuffers = NULL;

3177

qwglUseFontBitmaps = NULL;

3178

qwglUseFontOutlines = NULL;

3179

3180

qwglChoosePixelFormat = NULL;

3181

qwglDescribePixelFormat = NULL;

3182

qwglGetPixelFormat = NULL;

3183

qwglSetPixelFormat = NULL;

3184

qwglSwapBuffers = NULL;

3185

}

3186

3187

#define GR_NUM_BOARDS 0x0f

3188

3189

static qboolean GlideIsValid( void )

3190

{

3191

HMODULE hGlide;

3192

// int numBoards;

3193

// void (__stdcall *grGet)(unsigned int, unsigned int, int*);

3194

3195

if ( ( hGlide = LoadLibrary("Glide3X") ) != 0 )

3196

{

3197

// FIXME: 3Dfx needs to fix this shit

3198

return qtrue;

3199

3200

#if 0

3201

grGet = (void *)GetProcAddress( hGlide, "_grGet@12");

3202

3203

if ( grGet )

3204

{

3205

grGet( GR_NUM_BOARDS, sizeof(int), &numBoards);

3206

}

3207

else

3208

{

3209

// if we've reached this point, something is seriously wrong

3210

ri.Printf( PRINT_WARNING, "WARNING: could not find grGet in GLIDE3X.DLL\n" );

3211

numBoards = 0;

3212

}

3213

3214

FreeLibrary( hGlide );

3215

hGlide = NULL;

3216

3217

if ( numBoards > 0 )

3218

{

3219

return qtrue;

3220

}

3221

3222

ri.Printf( PRINT_WARNING, "WARNING: invalid Glide installation!\n" );

3223

#endif

3224

}

3225

3226

return qfalse;

3227

}

3228

3229

#ifdef _MSC_VER

3230

# pragma warning (disable : 4113 4133 4047 )

3231

# define GPA( a ) GetProcAddress( glw_state.hinstOpenGL, a )

3232

#else

3233

# define GPA( a ) (void *)GetProcAddress( glw_state.hinstOpenGL, a )

3234

#endif

3235

3236

3237

** QGL_Init

3238

3239

** This is responsible for binding our qgl function pointers to

3240

** the appropriate GL stuff. In Windows this means doing a

3241

** LoadLibrary and a bunch of calls to GetProcAddress. On other

3242

** operating systems we need to do the right thing, whatever that

3243

** might be.

3244

3245

qboolean QGL_Init( const char *dllname )

3246

{

3247

char systemDir[1024];

3248

char libName[1024];

3249

3250

GetSystemDirectory( systemDir, sizeof( systemDir ) );

3251

3252

assert( glw_state.hinstOpenGL == 0 );

3253

3254

ri.Printf( PRINT_ALL, "...initializing QGL\n" );

3255

3256

// NOTE: this assumes that 'dllname' is lower case (and it should be)!

3257

if ( strstr( dllname, _3DFX_DRIVER_NAME ) )

3258

{

3259

if ( !GlideIsValid() )

3260

{

3261

ri.Printf( PRINT_ALL, "...WARNING: missing Glide installation, assuming no 3Dfx available\n" );

3262

return qfalse;

3263

}

3264

}

3265

3266

if ( dllname[0] != '!' )

3267

{

3268

Com_sprintf( libName, sizeof( libName ), "%s\\%s", systemDir, dllname );

3269

}

3270

else

3271

{

3272

Q_strncpyz( libName, dllname, sizeof( libName ) );

3273

}

3274

3275

ri.Printf( PRINT_ALL, "...calling LoadLibrary( '%s.dll' ): ", libName );

3276

3277

if ( ( glw_state.hinstOpenGL = LoadLibrary( dllname ) ) == 0 )

3278

{

3279

ri.Printf( PRINT_ALL, "failed\n" );

3280

return qfalse;

3281

}

3282

ri.Printf( PRINT_ALL, "succeeded\n" );

3283

3284

qglAccum = dllAccum = GPA( "glAccum" );

3285

qglAlphaFunc = dllAlphaFunc = GPA( "glAlphaFunc" );

3286

qglAreTexturesResident = dllAreTexturesResident = GPA( "glAreTexturesResident" );

3287

qglArrayElement = dllArrayElement = GPA( "glArrayElement" );

3288

qglBegin = dllBegin = GPA( "glBegin" );

3289

qglBindTexture = dllBindTexture = GPA( "glBindTexture" );

3290

qglBitmap = dllBitmap = GPA( "glBitmap" );

3291

qglBlendFunc = dllBlendFunc = GPA( "glBlendFunc" );

3292

qglCallList = dllCallList = GPA( "glCallList" );

3293

qglCallLists = dllCallLists = GPA( "glCallLists" );

3294

qglClear = dllClear = GPA( "glClear" );

3295

qglClearAccum = dllClearAccum = GPA( "glClearAccum" );

3296

qglClearColor = dllClearColor = GPA( "glClearColor" );

3297

qglClearDepth = dllClearDepth = GPA( "glClearDepth" );

3298

qglClearIndex = dllClearIndex = GPA( "glClearIndex" );

3299

qglClearStencil = dllClearStencil = GPA( "glClearStencil" );

3300

qglClipPlane = dllClipPlane = GPA( "glClipPlane" );

3301

qglColor3b = dllColor3b = GPA( "glColor3b" );

3302

qglColor3bv = dllColor3bv = GPA( "glColor3bv" );

3303

qglColor3d = dllColor3d = GPA( "glColor3d" );

3304

qglColor3dv = dllColor3dv = GPA( "glColor3dv" );

3305

qglColor3f = dllColor3f = GPA( "glColor3f" );

3306

qglColor3fv = dllColor3fv = GPA( "glColor3fv" );

3307

qglColor3i = dllColor3i = GPA( "glColor3i" );

3308

qglColor3iv = dllColor3iv = GPA( "glColor3iv" );

3309

qglColor3s = dllColor3s = GPA( "glColor3s" );

3310

qglColor3sv = dllColor3sv = GPA( "glColor3sv" );

3311

qglColor3ub = dllColor3ub = GPA( "glColor3ub" );

3312

qglColor3ubv = dllColor3ubv = GPA( "glColor3ubv" );

3313

qglColor3ui = dllColor3ui = GPA( "glColor3ui" );

3314

qglColor3uiv = dllColor3uiv = GPA( "glColor3uiv" );

3315

qglColor3us = dllColor3us = GPA( "glColor3us" );

3316

qglColor3usv = dllColor3usv = GPA( "glColor3usv" );

3317

qglColor4b = dllColor4b = GPA( "glColor4b" );

3318

qglColor4bv = dllColor4bv = GPA( "glColor4bv" );

3319

qglColor4d = dllColor4d = GPA( "glColor4d" );

3320

qglColor4dv = dllColor4dv = GPA( "glColor4dv" );

3321

qglColor4f = dllColor4f = GPA( "glColor4f" );

3322

qglColor4fv = dllColor4fv = GPA( "glColor4fv" );

3323

qglColor4i = dllColor4i = GPA( "glColor4i" );

3324

qglColor4iv = dllColor4iv = GPA( "glColor4iv" );

3325

qglColor4s = dllColor4s = GPA( "glColor4s" );

3326

qglColor4sv = dllColor4sv = GPA( "glColor4sv" );

3327

qglColor4ub = dllColor4ub = GPA( "glColor4ub" );

3328

qglColor4ubv = dllColor4ubv = GPA( "glColor4ubv" );

3329

qglColor4ui = dllColor4ui = GPA( "glColor4ui" );

3330

qglColor4uiv = dllColor4uiv = GPA( "glColor4uiv" );

3331

qglColor4us = dllColor4us = GPA( "glColor4us" );

3332

qglColor4usv = dllColor4usv = GPA( "glColor4usv" );

3333

qglColorMask = dllColorMask = GPA( "glColorMask" );

3334

qglColorMaterial = dllColorMaterial = GPA( "glColorMaterial" );

3335

qglColorPointer = dllColorPointer = GPA( "glColorPointer" );

3336

qglCopyPixels = dllCopyPixels = GPA( "glCopyPixels" );

3337

qglCopyTexImage1D = dllCopyTexImage1D = GPA( "glCopyTexImage1D" );

3338

qglCopyTexImage2D = dllCopyTexImage2D = GPA( "glCopyTexImage2D" );

3339

qglCopyTexSubImage1D = dllCopyTexSubImage1D = GPA( "glCopyTexSubImage1D" );

3340

qglCopyTexSubImage2D = dllCopyTexSubImage2D = GPA( "glCopyTexSubImage2D" );

3341

qglCullFace = dllCullFace = GPA( "glCullFace" );

3342

qglDeleteLists = dllDeleteLists = GPA( "glDeleteLists" );

3343

qglDeleteTextures = dllDeleteTextures = GPA( "glDeleteTextures" );

3344

qglDepthFunc = dllDepthFunc = GPA( "glDepthFunc" );

3345

qglDepthMask = dllDepthMask = GPA( "glDepthMask" );

3346

qglDepthRange = dllDepthRange = GPA( "glDepthRange" );

3347

qglDisable = dllDisable = GPA( "glDisable" );

3348

qglDisableClientState = dllDisableClientState = GPA( "glDisableClientState" );

3349

qglDrawArrays = dllDrawArrays = GPA( "glDrawArrays" );

3350

qglDrawBuffer = dllDrawBuffer = GPA( "glDrawBuffer" );

3351

qglDrawElements = dllDrawElements = GPA( "glDrawElements" );

3352

qglDrawPixels = dllDrawPixels = GPA( "glDrawPixels" );

3353

qglEdgeFlag = dllEdgeFlag = GPA( "glEdgeFlag" );

3354

qglEdgeFlagPointer = dllEdgeFlagPointer = GPA( "glEdgeFlagPointer" );

3355

qglEdgeFlagv = dllEdgeFlagv = GPA( "glEdgeFlagv" );

3356

qglEnable = dllEnable = GPA( "glEnable" );

3357

qglEnableClientState = dllEnableClientState = GPA( "glEnableClientState" );

3358

qglEnd = dllEnd = GPA( "glEnd" );

3359

qglEndList = dllEndList = GPA( "glEndList" );

3360

qglEvalCoord1d = dllEvalCoord1d = GPA( "glEvalCoord1d" );

3361

qglEvalCoord1dv = dllEvalCoord1dv = GPA( "glEvalCoord1dv" );

3362

qglEvalCoord1f = dllEvalCoord1f = GPA( "glEvalCoord1f" );

3363

qglEvalCoord1fv = dllEvalCoord1fv = GPA( "glEvalCoord1fv" );

3364

qglEvalCoord2d = dllEvalCoord2d = GPA( "glEvalCoord2d" );

3365

qglEvalCoord2dv = dllEvalCoord2dv = GPA( "glEvalCoord2dv" );

3366

qglEvalCoord2f = dllEvalCoord2f = GPA( "glEvalCoord2f" );

3367

qglEvalCoord2fv = dllEvalCoord2fv = GPA( "glEvalCoord2fv" );

3368

qglEvalMesh1 = dllEvalMesh1 = GPA( "glEvalMesh1" );

3369

qglEvalMesh2 = dllEvalMesh2 = GPA( "glEvalMesh2" );

3370

qglEvalPoint1 = dllEvalPoint1 = GPA( "glEvalPoint1" );

3371

qglEvalPoint2 = dllEvalPoint2 = GPA( "glEvalPoint2" );

3372

qglFeedbackBuffer = dllFeedbackBuffer = GPA( "glFeedbackBuffer" );

3373

qglFinish = dllFinish = GPA( "glFinish" );

3374

qglFlush = dllFlush = GPA( "glFlush" );

3375

qglFogf = dllFogf = GPA( "glFogf" );

3376

qglFogfv = dllFogfv = GPA( "glFogfv" );

3377

qglFogi = dllFogi = GPA( "glFogi" );

3378

qglFogiv = dllFogiv = GPA( "glFogiv" );

3379

qglFrontFace = dllFrontFace = GPA( "glFrontFace" );

3380

qglFrustum = dllFrustum = GPA( "glFrustum" );

3381

qglGenLists = dllGenLists = ( GLuint (__stdcall * )(int) ) GPA( "glGenLists" );

3382

qglGenTextures = dllGenTextures = GPA( "glGenTextures" );

3383

qglGetBooleanv = dllGetBooleanv = GPA( "glGetBooleanv" );

3384

qglGetClipPlane = dllGetClipPlane = GPA( "glGetClipPlane" );

3385

qglGetDoublev = dllGetDoublev = GPA( "glGetDoublev" );

3386

qglGetError = dllGetError = ( GLenum (__stdcall * )(void) ) GPA( "glGetError" );

3387

qglGetFloatv = dllGetFloatv = GPA( "glGetFloatv" );

3388

qglGetIntegerv = dllGetIntegerv = GPA( "glGetIntegerv" );

3389

qglGetLightfv = dllGetLightfv = GPA( "glGetLightfv" );

3390

qglGetLightiv = dllGetLightiv = GPA( "glGetLightiv" );

3391

qglGetMapdv = dllGetMapdv = GPA( "glGetMapdv" );

3392

qglGetMapfv = dllGetMapfv = GPA( "glGetMapfv" );

3393

qglGetMapiv = dllGetMapiv = GPA( "glGetMapiv" );

3394

qglGetMaterialfv = dllGetMaterialfv = GPA( "glGetMaterialfv" );

3395

qglGetMaterialiv = dllGetMaterialiv = GPA( "glGetMaterialiv" );

3396

qglGetPixelMapfv = dllGetPixelMapfv = GPA( "glGetPixelMapfv" );

3397

qglGetPixelMapuiv = dllGetPixelMapuiv = GPA( "glGetPixelMapuiv" );

3398

qglGetPixelMapusv = dllGetPixelMapusv = GPA( "glGetPixelMapusv" );

3399

qglGetPointerv = dllGetPointerv = GPA( "glGetPointerv" );

3400

qglGetPolygonStipple = dllGetPolygonStipple = GPA( "glGetPolygonStipple" );

3401

qglGetString = dllGetString = GPA( "glGetString" );

3402

qglGetTexEnvfv = dllGetTexEnvfv = GPA( "glGetTexEnvfv" );

3403

qglGetTexEnviv = dllGetTexEnviv = GPA( "glGetTexEnviv" );

3404

qglGetTexGendv = dllGetTexGendv = GPA( "glGetTexGendv" );

3405

qglGetTexGenfv = dllGetTexGenfv = GPA( "glGetTexGenfv" );

3406

qglGetTexGeniv = dllGetTexGeniv = GPA( "glGetTexGeniv" );

3407

qglGetTexImage = dllGetTexImage = GPA( "glGetTexImage" );

3408

qglGetTexParameterfv = dllGetTexParameterfv = GPA( "glGetTexParameterfv" );

3409

qglGetTexParameteriv = dllGetTexParameteriv = GPA( "glGetTexParameteriv" );

3410

qglHint = dllHint = GPA( "glHint" );

3411

qglIndexMask = dllIndexMask = GPA( "glIndexMask" );

3412

qglIndexPointer = dllIndexPointer = GPA( "glIndexPointer" );

3413

qglIndexd = dllIndexd = GPA( "glIndexd" );

3414

qglIndexdv = dllIndexdv = GPA( "glIndexdv" );

3415

qglIndexf = dllIndexf = GPA( "glIndexf" );

3416

qglIndexfv = dllIndexfv = GPA( "glIndexfv" );

3417

qglIndexi = dllIndexi = GPA( "glIndexi" );

3418

qglIndexiv = dllIndexiv = GPA( "glIndexiv" );

3419

qglIndexs = dllIndexs = GPA( "glIndexs" );

3420

qglIndexsv = dllIndexsv = GPA( "glIndexsv" );

3421

qglIndexub = dllIndexub = GPA( "glIndexub" );

3422

qglIndexubv = dllIndexubv = GPA( "glIndexubv" );

3423

qglInitNames = dllInitNames = GPA( "glInitNames" );

3424

qglInterleavedArrays = dllInterleavedArrays = GPA( "glInterleavedArrays" );

3425

qglIsEnabled = dllIsEnabled = GPA( "glIsEnabled" );

3426

qglIsList = dllIsList = GPA( "glIsList" );

3427

qglIsTexture = dllIsTexture = GPA( "glIsTexture" );

3428

qglLightModelf = dllLightModelf = GPA( "glLightModelf" );

3429

qglLightModelfv = dllLightModelfv = GPA( "glLightModelfv" );

3430

qglLightModeli = dllLightModeli = GPA( "glLightModeli" );

3431

qglLightModeliv = dllLightModeliv = GPA( "glLightModeliv" );

3432

qglLightf = dllLightf = GPA( "glLightf" );

3433

qglLightfv = dllLightfv = GPA( "glLightfv" );

3434

qglLighti = dllLighti = GPA( "glLighti" );

3435

qglLightiv = dllLightiv = GPA( "glLightiv" );

3436

qglLineStipple = dllLineStipple = GPA( "glLineStipple" );

3437

qglLineWidth = dllLineWidth = GPA( "glLineWidth" );

3438

qglListBase = dllListBase = GPA( "glListBase" );

3439

qglLoadIdentity = dllLoadIdentity = GPA( "glLoadIdentity" );

3440

qglLoadMatrixd = dllLoadMatrixd = GPA( "glLoadMatrixd" );

3441

qglLoadMatrixf = dllLoadMatrixf = GPA( "glLoadMatrixf" );

3442

qglLoadName = dllLoadName = GPA( "glLoadName" );

3443

qglLogicOp = dllLogicOp = GPA( "glLogicOp" );

3444

qglMap1d = dllMap1d = GPA( "glMap1d" );

3445

qglMap1f = dllMap1f = GPA( "glMap1f" );

3446

qglMap2d = dllMap2d = GPA( "glMap2d" );

3447

qglMap2f = dllMap2f = GPA( "glMap2f" );

3448

qglMapGrid1d = dllMapGrid1d = GPA( "glMapGrid1d" );

3449

qglMapGrid1f = dllMapGrid1f = GPA( "glMapGrid1f" );

3450

qglMapGrid2d = dllMapGrid2d = GPA( "glMapGrid2d" );

3451

qglMapGrid2f = dllMapGrid2f = GPA( "glMapGrid2f" );

3452

qglMaterialf = dllMaterialf = GPA( "glMaterialf" );

3453

qglMaterialfv = dllMaterialfv = GPA( "glMaterialfv" );

3454

qglMateriali = dllMateriali = GPA( "glMateriali" );

3455

qglMaterialiv = dllMaterialiv = GPA( "glMaterialiv" );

3456

qglMatrixMode = dllMatrixMode = GPA( "glMatrixMode" );

3457

qglMultMatrixd = dllMultMatrixd = GPA( "glMultMatrixd" );

3458

qglMultMatrixf = dllMultMatrixf = GPA( "glMultMatrixf" );

3459

qglNewList = dllNewList = GPA( "glNewList" );

3460

qglNormal3b = dllNormal3b = GPA( "glNormal3b" );

3461

qglNormal3bv = dllNormal3bv = GPA( "glNormal3bv" );

3462

qglNormal3d = dllNormal3d = GPA( "glNormal3d" );

3463

qglNormal3dv = dllNormal3dv = GPA( "glNormal3dv" );

3464

qglNormal3f = dllNormal3f = GPA( "glNormal3f" );

3465

qglNormal3fv = dllNormal3fv = GPA( "glNormal3fv" );

3466

qglNormal3i = dllNormal3i = GPA( "glNormal3i" );

3467

qglNormal3iv = dllNormal3iv = GPA( "glNormal3iv" );

3468

qglNormal3s = dllNormal3s = GPA( "glNormal3s" );

3469

qglNormal3sv = dllNormal3sv = GPA( "glNormal3sv" );

3470

qglNormalPointer = dllNormalPointer = GPA( "glNormalPointer" );

3471

qglOrtho = dllOrtho = GPA( "glOrtho" );

3472

qglPassThrough = dllPassThrough = GPA( "glPassThrough" );

3473

qglPixelMapfv = dllPixelMapfv = GPA( "glPixelMapfv" );

3474

qglPixelMapuiv = dllPixelMapuiv = GPA( "glPixelMapuiv" );

3475

qglPixelMapusv = dllPixelMapusv = GPA( "glPixelMapusv" );

3476

qglPixelStoref = dllPixelStoref = GPA( "glPixelStoref" );

3477

qglPixelStorei = dllPixelStorei = GPA( "glPixelStorei" );

3478

qglPixelTransferf = dllPixelTransferf = GPA( "glPixelTransferf" );

3479

qglPixelTransferi = dllPixelTransferi = GPA( "glPixelTransferi" );

3480

qglPixelZoom = dllPixelZoom = GPA( "glPixelZoom" );

3481

qglPointSize = dllPointSize = GPA( "glPointSize" );

3482

qglPolygonMode = dllPolygonMode = GPA( "glPolygonMode" );

3483

qglPolygonOffset = dllPolygonOffset = GPA( "glPolygonOffset" );

3484

qglPolygonStipple = dllPolygonStipple = GPA( "glPolygonStipple" );

3485

qglPopAttrib = dllPopAttrib = GPA( "glPopAttrib" );

3486

qglPopClientAttrib = dllPopClientAttrib = GPA( "glPopClientAttrib" );

3487

qglPopMatrix = dllPopMatrix = GPA( "glPopMatrix" );

3488

qglPopName = dllPopName = GPA( "glPopName" );

3489

qglPrioritizeTextures = dllPrioritizeTextures = GPA( "glPrioritizeTextures" );

3490

qglPushAttrib = dllPushAttrib = GPA( "glPushAttrib" );

3491

qglPushClientAttrib = dllPushClientAttrib = GPA( "glPushClientAttrib" );

3492

qglPushMatrix = dllPushMatrix = GPA( "glPushMatrix" );

3493

qglPushName = dllPushName = GPA( "glPushName" );

3494

qglRasterPos2d = dllRasterPos2d = GPA( "glRasterPos2d" );

3495

qglRasterPos2dv = dllRasterPos2dv = GPA( "glRasterPos2dv" );

3496

qglRasterPos2f = dllRasterPos2f = GPA( "glRasterPos2f" );

3497

qglRasterPos2fv = dllRasterPos2fv = GPA( "glRasterPos2fv" );

3498

qglRasterPos2i = dllRasterPos2i = GPA( "glRasterPos2i" );

3499

qglRasterPos2iv = dllRasterPos2iv = GPA( "glRasterPos2iv" );

3500

qglRasterPos2s = dllRasterPos2s = GPA( "glRasterPos2s" );

3501

qglRasterPos2sv = dllRasterPos2sv = GPA( "glRasterPos2sv" );

3502

qglRasterPos3d = dllRasterPos3d = GPA( "glRasterPos3d" );

3503

qglRasterPos3dv = dllRasterPos3dv = GPA( "glRasterPos3dv" );

3504

qglRasterPos3f = dllRasterPos3f = GPA( "glRasterPos3f" );

3505

qglRasterPos3fv = dllRasterPos3fv = GPA( "glRasterPos3fv" );

3506

qglRasterPos3i = dllRasterPos3i = GPA( "glRasterPos3i" );

3507

qglRasterPos3iv = dllRasterPos3iv = GPA( "glRasterPos3iv" );

3508

qglRasterPos3s = dllRasterPos3s = GPA( "glRasterPos3s" );

3509

qglRasterPos3sv = dllRasterPos3sv = GPA( "glRasterPos3sv" );

3510

qglRasterPos4d = dllRasterPos4d = GPA( "glRasterPos4d" );

3511

qglRasterPos4dv = dllRasterPos4dv = GPA( "glRasterPos4dv" );

3512

qglRasterPos4f = dllRasterPos4f = GPA( "glRasterPos4f" );

3513

qglRasterPos4fv = dllRasterPos4fv = GPA( "glRasterPos4fv" );

3514

qglRasterPos4i = dllRasterPos4i = GPA( "glRasterPos4i" );

3515

qglRasterPos4iv = dllRasterPos4iv = GPA( "glRasterPos4iv" );

3516

qglRasterPos4s = dllRasterPos4s = GPA( "glRasterPos4s" );

3517

qglRasterPos4sv = dllRasterPos4sv = GPA( "glRasterPos4sv" );

3518

qglReadBuffer = dllReadBuffer = GPA( "glReadBuffer" );

3519

qglReadPixels = dllReadPixels = GPA( "glReadPixels" );

3520

qglRectd = dllRectd = GPA( "glRectd" );

3521

qglRectdv = dllRectdv = GPA( "glRectdv" );

3522

qglRectf = dllRectf = GPA( "glRectf" );

3523

qglRectfv = dllRectfv = GPA( "glRectfv" );

3524

qglRecti = dllRecti = GPA( "glRecti" );

3525

qglRectiv = dllRectiv = GPA( "glRectiv" );

3526

qglRects = dllRects = GPA( "glRects" );

3527

qglRectsv = dllRectsv = GPA( "glRectsv" );

3528

qglRenderMode = dllRenderMode = GPA( "glRenderMode" );

3529

qglRotated = dllRotated = GPA( "glRotated" );

3530

qglRotatef = dllRotatef = GPA( "glRotatef" );

3531

qglScaled = dllScaled = GPA( "glScaled" );

3532

qglScalef = dllScalef = GPA( "glScalef" );

3533

qglScissor = dllScissor = GPA( "glScissor" );

3534

qglSelectBuffer = dllSelectBuffer = GPA( "glSelectBuffer" );

3535

qglShadeModel = dllShadeModel = GPA( "glShadeModel" );

3536

qglStencilFunc = dllStencilFunc = GPA( "glStencilFunc" );

3537

qglStencilMask = dllStencilMask = GPA( "glStencilMask" );

3538

qglStencilOp = dllStencilOp = GPA( "glStencilOp" );

3539

qglTexCoord1d = dllTexCoord1d = GPA( "glTexCoord1d" );

3540

qglTexCoord1dv = dllTexCoord1dv = GPA( "glTexCoord1dv" );

3541

qglTexCoord1f = dllTexCoord1f = GPA( "glTexCoord1f" );

3542

qglTexCoord1fv = dllTexCoord1fv = GPA( "glTexCoord1fv" );

3543

qglTexCoord1i = dllTexCoord1i = GPA( "glTexCoord1i" );

3544

qglTexCoord1iv = dllTexCoord1iv = GPA( "glTexCoord1iv" );

3545

qglTexCoord1s = dllTexCoord1s = GPA( "glTexCoord1s" );

3546

qglTexCoord1sv = dllTexCoord1sv = GPA( "glTexCoord1sv" );

3547

qglTexCoord2d = dllTexCoord2d = GPA( "glTexCoord2d" );

3548

qglTexCoord2dv = dllTexCoord2dv = GPA( "glTexCoord2dv" );

3549

qglTexCoord2f = dllTexCoord2f = GPA( "glTexCoord2f" );

3550

qglTexCoord2fv = dllTexCoord2fv = GPA( "glTexCoord2fv" );

3551

qglTexCoord2i = dllTexCoord2i = GPA( "glTexCoord2i" );

3552

qglTexCoord2iv = dllTexCoord2iv = GPA( "glTexCoord2iv" );

3553

qglTexCoord2s = dllTexCoord2s = GPA( "glTexCoord2s" );

3554

qglTexCoord2sv = dllTexCoord2sv = GPA( "glTexCoord2sv" );

3555

qglTexCoord3d = dllTexCoord3d = GPA( "glTexCoord3d" );

3556

qglTexCoord3dv = dllTexCoord3dv = GPA( "glTexCoord3dv" );

3557

qglTexCoord3f = dllTexCoord3f = GPA( "glTexCoord3f" );

3558

qglTexCoord3fv = dllTexCoord3fv = GPA( "glTexCoord3fv" );

3559

qglTexCoord3i = dllTexCoord3i = GPA( "glTexCoord3i" );

3560

qglTexCoord3iv = dllTexCoord3iv = GPA( "glTexCoord3iv" );

3561

qglTexCoord3s = dllTexCoord3s = GPA( "glTexCoord3s" );

3562

qglTexCoord3sv = dllTexCoord3sv = GPA( "glTexCoord3sv" );

3563

qglTexCoord4d = dllTexCoord4d = GPA( "glTexCoord4d" );

3564

qglTexCoord4dv = dllTexCoord4dv = GPA( "glTexCoord4dv" );

3565

qglTexCoord4f = dllTexCoord4f = GPA( "glTexCoord4f" );

3566

qglTexCoord4fv = dllTexCoord4fv = GPA( "glTexCoord4fv" );

3567

qglTexCoord4i = dllTexCoord4i = GPA( "glTexCoord4i" );

3568

qglTexCoord4iv = dllTexCoord4iv = GPA( "glTexCoord4iv" );

3569

qglTexCoord4s = dllTexCoord4s = GPA( "glTexCoord4s" );

3570

qglTexCoord4sv = dllTexCoord4sv = GPA( "glTexCoord4sv" );

3571

qglTexCoordPointer = dllTexCoordPointer = GPA( "glTexCoordPointer" );

3572

qglTexEnvf = dllTexEnvf = GPA( "glTexEnvf" );

3573

qglTexEnvfv = dllTexEnvfv = GPA( "glTexEnvfv" );

3574

qglTexEnvi = dllTexEnvi = GPA( "glTexEnvi" );

3575

qglTexEnviv = dllTexEnviv = GPA( "glTexEnviv" );

3576

qglTexGend = dllTexGend = GPA( "glTexGend" );

3577

qglTexGendv = dllTexGendv = GPA( "glTexGendv" );

3578

qglTexGenf = dllTexGenf = GPA( "glTexGenf" );

3579

qglTexGenfv = dllTexGenfv = GPA( "glTexGenfv" );

3580

qglTexGeni = dllTexGeni = GPA( "glTexGeni" );

3581

qglTexGeniv = dllTexGeniv = GPA( "glTexGeniv" );

3582

qglTexImage1D = dllTexImage1D = GPA( "glTexImage1D" );

3583

qglTexImage2D = dllTexImage2D = GPA( "glTexImage2D" );

3584

qglTexParameterf = dllTexParameterf = GPA( "glTexParameterf" );

3585

qglTexParameterfv = dllTexParameterfv = GPA( "glTexParameterfv" );

3586

qglTexParameteri = dllTexParameteri = GPA( "glTexParameteri" );

3587

qglTexParameteriv = dllTexParameteriv = GPA( "glTexParameteriv" );

3588

qglTexSubImage1D = dllTexSubImage1D = GPA( "glTexSubImage1D" );

3589

qglTexSubImage2D = dllTexSubImage2D = GPA( "glTexSubImage2D" );

3590

qglTranslated = dllTranslated = GPA( "glTranslated" );

3591

qglTranslatef = dllTranslatef = GPA( "glTranslatef" );

3592

qglVertex2d = dllVertex2d = GPA( "glVertex2d" );

3593

qglVertex2dv = dllVertex2dv = GPA( "glVertex2dv" );

3594

qglVertex2f = dllVertex2f = GPA( "glVertex2f" );

3595

qglVertex2fv = dllVertex2fv = GPA( "glVertex2fv" );

3596

qglVertex2i = dllVertex2i = GPA( "glVertex2i" );

3597

qglVertex2iv = dllVertex2iv = GPA( "glVertex2iv" );

3598

qglVertex2s = dllVertex2s = GPA( "glVertex2s" );

3599

qglVertex2sv = dllVertex2sv = GPA( "glVertex2sv" );

3600

qglVertex3d = dllVertex3d = GPA( "glVertex3d" );

3601

qglVertex3dv = dllVertex3dv = GPA( "glVertex3dv" );

3602

qglVertex3f = dllVertex3f = GPA( "glVertex3f" );

3603

qglVertex3fv = dllVertex3fv = GPA( "glVertex3fv" );

3604

qglVertex3i = dllVertex3i = GPA( "glVertex3i" );

3605

qglVertex3iv = dllVertex3iv = GPA( "glVertex3iv" );

3606

qglVertex3s = dllVertex3s = GPA( "glVertex3s" );

3607

qglVertex3sv = dllVertex3sv = GPA( "glVertex3sv" );

3608

qglVertex4d = dllVertex4d = GPA( "glVertex4d" );

3609

qglVertex4dv = dllVertex4dv = GPA( "glVertex4dv" );

3610

qglVertex4f = dllVertex4f = GPA( "glVertex4f" );

3611

qglVertex4fv = dllVertex4fv = GPA( "glVertex4fv" );

3612

qglVertex4i = dllVertex4i = GPA( "glVertex4i" );

3613

qglVertex4iv = dllVertex4iv = GPA( "glVertex4iv" );

3614

qglVertex4s = dllVertex4s = GPA( "glVertex4s" );

3615

qglVertex4sv = dllVertex4sv = GPA( "glVertex4sv" );

3616

qglVertexPointer = dllVertexPointer = GPA( "glVertexPointer" );

3617

qglViewport = dllViewport = GPA( "glViewport" );

3618

3619

qwglCopyContext = GPA( "wglCopyContext" );

3620

qwglCreateContext = GPA( "wglCreateContext" );

3621

qwglCreateLayerContext = GPA( "wglCreateLayerContext" );

3622

qwglDeleteContext = GPA( "wglDeleteContext" );

3623

qwglDescribeLayerPlane = GPA( "wglDescribeLayerPlane" );

3624

qwglGetCurrentContext = GPA( "wglGetCurrentContext" );

3625

qwglGetCurrentDC = GPA( "wglGetCurrentDC" );

3626

qwglGetLayerPaletteEntries = GPA( "wglGetLayerPaletteEntries" );

3627

qwglGetProcAddress = GPA( "wglGetProcAddress" );

3628

qwglMakeCurrent = GPA( "wglMakeCurrent" );

3629

qwglRealizeLayerPalette = GPA( "wglRealizeLayerPalette" );

3630

qwglSetLayerPaletteEntries = GPA( "wglSetLayerPaletteEntries" );

3631

qwglShareLists = GPA( "wglShareLists" );

3632

qwglSwapLayerBuffers = GPA( "wglSwapLayerBuffers" );

3633

qwglUseFontBitmaps = GPA( "wglUseFontBitmapsA" );

3634

qwglUseFontOutlines = GPA( "wglUseFontOutlinesA" );

3635

3636

qwglChoosePixelFormat = GPA( "wglChoosePixelFormat" );

3637

qwglDescribePixelFormat = GPA( "wglDescribePixelFormat" );

3638

qwglGetPixelFormat = GPA( "wglGetPixelFormat" );

3639

qwglSetPixelFormat = GPA( "wglSetPixelFormat" );

3640

qwglSwapBuffers = GPA( "wglSwapBuffers" );

3641

3642

qwglSwapIntervalEXT = 0;

3643

qglActiveTextureARB = 0;

3644

qglClientActiveTextureARB = 0;

3645

qglMultiTexCoord2fARB = 0;

3646

qglLockArraysEXT = 0;

3647

qglUnlockArraysEXT = 0;

3648

qwglGetDeviceGammaRamp3DFX = NULL;

3649

qwglSetDeviceGammaRamp3DFX = NULL;

3650

3651

// check logging

3652

QGL_EnableLogging( r_logFile->integer );

3653

3654

return qtrue;

3655

}

3656

3657

void QGL_EnableLogging( qboolean enable )

3658

{

3659

static qboolean isEnabled;

3660

3661

// return if we're already active

3662

if ( isEnabled && enable ) {

3663

// decrement log counter and stop if it has reached 0

3664

ri.Cvar_Set( "r_logFile", va("%d", r_logFile->integer - 1 ) );

3665

if ( r_logFile->integer ) {

3666

return;

3667

}

3668

enable = qfalse;

3669

}

3670

3671

// return if we're already disabled

3672

if ( !enable && !isEnabled )

3673

return;

3674

3675

isEnabled = enable;

3676

3677

if ( enable )

3678

{

3679

if ( !glw_state.log_fp )

3680

{

3681

struct tm *newtime;

3682

time_t aclock;

3683

char buffer[1024];

3684

cvar_t *basedir;

3685

3686

time( &aclock );

3687

newtime = localtime( &aclock );

3688

3689

asctime( newtime );

3690

3691

basedir = ri.Cvar_Get( "fs_basepath", "", 0 );

3692

Com_sprintf( buffer, sizeof(buffer), "%s/gl.log", basedir->string );

3693

glw_state.log_fp = fopen( buffer, "wt" );

3694

3695

fprintf( glw_state.log_fp, "%s\n", asctime( newtime ) );

3696

}

3697

3698

qglAccum = logAccum;

3699

qglAlphaFunc = logAlphaFunc;

3700

qglAreTexturesResident = logAreTexturesResident;

3701

qglArrayElement = logArrayElement;

3702

qglBegin = logBegin;

3703

qglBindTexture = logBindTexture;

3704

qglBitmap = logBitmap;

3705

qglBlendFunc = logBlendFunc;

3706

qglCallList = logCallList;

3707

qglCallLists = logCallLists;

3708

qglClear = logClear;

3709

qglClearAccum = logClearAccum;

3710

qglClearColor = logClearColor;

3711

qglClearDepth = logClearDepth;

3712

qglClearIndex = logClearIndex;

3713

qglClearStencil = logClearStencil;

3714

qglClipPlane = logClipPlane;

3715

qglColor3b = logColor3b;

3716

qglColor3bv = logColor3bv;

3717

qglColor3d = logColor3d;

3718

qglColor3dv = logColor3dv;

3719

qglColor3f = logColor3f;

3720

qglColor3fv = logColor3fv;

3721

qglColor3i = logColor3i;

3722

qglColor3iv = logColor3iv;

3723

qglColor3s = logColor3s;

3724

qglColor3sv = logColor3sv;

3725

qglColor3ub = logColor3ub;

3726

qglColor3ubv = logColor3ubv;

3727

qglColor3ui = logColor3ui;

3728

qglColor3uiv = logColor3uiv;

3729

qglColor3us = logColor3us;

3730

qglColor3usv = logColor3usv;

3731

qglColor4b = logColor4b;

3732

qglColor4bv = logColor4bv;

3733

qglColor4d = logColor4d;

3734

qglColor4dv = logColor4dv;

3735

qglColor4f = logColor4f;

3736

qglColor4fv = logColor4fv;

3737

qglColor4i = logColor4i;

3738

qglColor4iv = logColor4iv;

3739

qglColor4s = logColor4s;

3740

qglColor4sv = logColor4sv;

3741

qglColor4ub = logColor4ub;

3742

qglColor4ubv = logColor4ubv;

3743

qglColor4ui = logColor4ui;

3744

qglColor4uiv = logColor4uiv;

3745

qglColor4us = logColor4us;

3746

qglColor4usv = logColor4usv;

3747

qglColorMask = logColorMask;

3748

qglColorMaterial = logColorMaterial;

3749

qglColorPointer = logColorPointer;

3750

qglCopyPixels = logCopyPixels;

3751

qglCopyTexImage1D = logCopyTexImage1D;

3752

qglCopyTexImage2D = logCopyTexImage2D;

3753

qglCopyTexSubImage1D = logCopyTexSubImage1D;

3754

qglCopyTexSubImage2D = logCopyTexSubImage2D;

3755

qglCullFace = logCullFace;

3756

qglDeleteLists = logDeleteLists ;

3757

qglDeleteTextures = logDeleteTextures ;

3758

qglDepthFunc = logDepthFunc ;

3759

qglDepthMask = logDepthMask ;

3760

qglDepthRange = logDepthRange ;

3761

qglDisable = logDisable ;

3762

qglDisableClientState = logDisableClientState ;

3763

qglDrawArrays = logDrawArrays ;

3764

qglDrawBuffer = logDrawBuffer ;

3765

qglDrawElements = logDrawElements ;

3766

qglDrawPixels = logDrawPixels ;

3767

qglEdgeFlag = logEdgeFlag ;

3768

qglEdgeFlagPointer = logEdgeFlagPointer ;

3769

qglEdgeFlagv = logEdgeFlagv ;

3770

qglEnable = logEnable ;

3771

qglEnableClientState = logEnableClientState ;

3772

qglEnd = logEnd ;

3773

qglEndList = logEndList ;

3774

qglEvalCoord1d = logEvalCoord1d ;

3775

qglEvalCoord1dv = logEvalCoord1dv ;

3776

qglEvalCoord1f = logEvalCoord1f ;

3777

qglEvalCoord1fv = logEvalCoord1fv ;

3778

qglEvalCoord2d = logEvalCoord2d ;

3779

qglEvalCoord2dv = logEvalCoord2dv ;

3780

qglEvalCoord2f = logEvalCoord2f ;

3781

qglEvalCoord2fv = logEvalCoord2fv ;

3782

qglEvalMesh1 = logEvalMesh1 ;

3783

qglEvalMesh2 = logEvalMesh2 ;

3784

qglEvalPoint1 = logEvalPoint1 ;

3785

qglEvalPoint2 = logEvalPoint2 ;

3786

qglFeedbackBuffer = logFeedbackBuffer ;

3787

qglFinish = logFinish ;

3788

qglFlush = logFlush ;

3789

qglFogf = logFogf ;

3790

qglFogfv = logFogfv ;

3791

qglFogi = logFogi ;

3792

qglFogiv = logFogiv ;

3793

qglFrontFace = logFrontFace ;

3794

qglFrustum = logFrustum ;

3795

qglGenLists = logGenLists ;

3796

qglGenTextures = logGenTextures ;

3797

qglGetBooleanv = logGetBooleanv ;

3798

qglGetClipPlane = logGetClipPlane ;

3799

qglGetDoublev = logGetDoublev ;

3800

qglGetError = logGetError ;

3801

qglGetFloatv = logGetFloatv ;

3802

qglGetIntegerv = logGetIntegerv ;

3803

qglGetLightfv = logGetLightfv ;

3804

qglGetLightiv = logGetLightiv ;

3805

qglGetMapdv = logGetMapdv ;

3806

qglGetMapfv = logGetMapfv ;

3807

qglGetMapiv = logGetMapiv ;

3808

qglGetMaterialfv = logGetMaterialfv ;

3809

qglGetMaterialiv = logGetMaterialiv ;

3810

qglGetPixelMapfv = logGetPixelMapfv ;

3811

qglGetPixelMapuiv = logGetPixelMapuiv ;

3812

qglGetPixelMapusv = logGetPixelMapusv ;

3813

qglGetPointerv = logGetPointerv ;

3814

qglGetPolygonStipple = logGetPolygonStipple ;

3815

qglGetString = logGetString ;

3816

qglGetTexEnvfv = logGetTexEnvfv ;

3817

qglGetTexEnviv = logGetTexEnviv ;

3818

qglGetTexGendv = logGetTexGendv ;

3819

qglGetTexGenfv = logGetTexGenfv ;

3820

qglGetTexGeniv = logGetTexGeniv ;

3821

qglGetTexImage = logGetTexImage ;

3822

qglGetTexLevelParameterfv = logGetTexLevelParameterfv ;

3823

qglGetTexLevelParameteriv = logGetTexLevelParameteriv ;

3824

qglGetTexParameterfv = logGetTexParameterfv ;

3825

qglGetTexParameteriv = logGetTexParameteriv ;

3826

qglHint = logHint ;

3827

qglIndexMask = logIndexMask ;

3828

qglIndexPointer = logIndexPointer ;

3829

qglIndexd = logIndexd ;

3830

qglIndexdv = logIndexdv ;

3831

qglIndexf = logIndexf ;

3832

qglIndexfv = logIndexfv ;

3833

qglIndexi = logIndexi ;

3834

qglIndexiv = logIndexiv ;

3835

qglIndexs = logIndexs ;

3836

qglIndexsv = logIndexsv ;

3837

qglIndexub = logIndexub ;

3838

qglIndexubv = logIndexubv ;

3839

qglInitNames = logInitNames ;

3840

qglInterleavedArrays = logInterleavedArrays ;

3841

qglIsEnabled = logIsEnabled ;

3842

qglIsList = logIsList ;

3843

qglIsTexture = logIsTexture ;

3844

qglLightModelf = logLightModelf ;

3845

qglLightModelfv = logLightModelfv ;

3846

qglLightModeli = logLightModeli ;

3847

qglLightModeliv = logLightModeliv ;

3848

qglLightf = logLightf ;

3849

qglLightfv = logLightfv ;

3850

qglLighti = logLighti ;

3851

qglLightiv = logLightiv ;

3852

qglLineStipple = logLineStipple ;

3853

qglLineWidth = logLineWidth ;

3854

qglListBase = logListBase ;

3855

qglLoadIdentity = logLoadIdentity ;

3856

qglLoadMatrixd = logLoadMatrixd ;

3857

qglLoadMatrixf = logLoadMatrixf ;

3858

qglLoadName = logLoadName ;

3859

qglLogicOp = logLogicOp ;

3860

qglMap1d = logMap1d ;

3861

qglMap1f = logMap1f ;

3862

qglMap2d = logMap2d ;

3863

qglMap2f = logMap2f ;

3864

qglMapGrid1d = logMapGrid1d ;

3865

qglMapGrid1f = logMapGrid1f ;

3866

qglMapGrid2d = logMapGrid2d ;

3867

qglMapGrid2f = logMapGrid2f ;

3868

qglMaterialf = logMaterialf ;

3869

qglMaterialfv = logMaterialfv ;

3870

qglMateriali = logMateriali ;

3871

qglMaterialiv = logMaterialiv ;

3872

qglMatrixMode = logMatrixMode ;

3873

qglMultMatrixd = logMultMatrixd ;

3874

qglMultMatrixf = logMultMatrixf ;

3875

qglNewList = logNewList ;

3876

qglNormal3b = logNormal3b ;

3877

qglNormal3bv = logNormal3bv ;

3878

qglNormal3d = logNormal3d ;

3879

qglNormal3dv = logNormal3dv ;

3880

qglNormal3f = logNormal3f ;

3881

qglNormal3fv = logNormal3fv ;

3882

qglNormal3i = logNormal3i ;

3883

qglNormal3iv = logNormal3iv ;

3884

qglNormal3s = logNormal3s ;

3885

qglNormal3sv = logNormal3sv ;

3886

qglNormalPointer = logNormalPointer ;

3887

qglOrtho = logOrtho ;

3888

qglPassThrough = logPassThrough ;

3889

qglPixelMapfv = logPixelMapfv ;

3890

qglPixelMapuiv = logPixelMapuiv ;

3891

qglPixelMapusv = logPixelMapusv ;

3892

qglPixelStoref = logPixelStoref ;

3893

qglPixelStorei = logPixelStorei ;

3894

qglPixelTransferf = logPixelTransferf ;

3895

qglPixelTransferi = logPixelTransferi ;

3896

qglPixelZoom = logPixelZoom ;

3897

qglPointSize = logPointSize ;

3898

qglPolygonMode = logPolygonMode ;

3899

qglPolygonOffset = logPolygonOffset ;

3900

qglPolygonStipple = logPolygonStipple ;

3901

qglPopAttrib = logPopAttrib ;

3902

qglPopClientAttrib = logPopClientAttrib ;

3903

qglPopMatrix = logPopMatrix ;

3904

qglPopName = logPopName ;

3905

qglPrioritizeTextures = logPrioritizeTextures ;

3906

qglPushAttrib = logPushAttrib ;

3907

qglPushClientAttrib = logPushClientAttrib ;

3908

qglPushMatrix = logPushMatrix ;

3909

qglPushName = logPushName ;

3910

qglRasterPos2d = logRasterPos2d ;

3911

qglRasterPos2dv = logRasterPos2dv ;

3912

qglRasterPos2f = logRasterPos2f ;

3913

qglRasterPos2fv = logRasterPos2fv ;

3914

qglRasterPos2i = logRasterPos2i ;

3915

qglRasterPos2iv = logRasterPos2iv ;

3916

qglRasterPos2s = logRasterPos2s ;

3917

qglRasterPos2sv = logRasterPos2sv ;

3918

qglRasterPos3d = logRasterPos3d ;

3919

qglRasterPos3dv = logRasterPos3dv ;

3920

qglRasterPos3f = logRasterPos3f ;

3921

qglRasterPos3fv = logRasterPos3fv ;

3922

qglRasterPos3i = logRasterPos3i ;

3923

qglRasterPos3iv = logRasterPos3iv ;

3924

qglRasterPos3s = logRasterPos3s ;

3925

qglRasterPos3sv = logRasterPos3sv ;

3926

qglRasterPos4d = logRasterPos4d ;

3927

qglRasterPos4dv = logRasterPos4dv ;

3928

qglRasterPos4f = logRasterPos4f ;

3929

qglRasterPos4fv = logRasterPos4fv ;

3930

qglRasterPos4i = logRasterPos4i ;

3931

qglRasterPos4iv = logRasterPos4iv ;

3932

qglRasterPos4s = logRasterPos4s ;

3933

qglRasterPos4sv = logRasterPos4sv ;

3934

qglReadBuffer = logReadBuffer ;

3935

qglReadPixels = logReadPixels ;

3936

qglRectd = logRectd ;

3937

qglRectdv = logRectdv ;

3938

qglRectf = logRectf ;

3939

qglRectfv = logRectfv ;

3940

qglRecti = logRecti ;

3941

qglRectiv = logRectiv ;

3942

qglRects = logRects ;

3943

qglRectsv = logRectsv ;

3944

qglRenderMode = logRenderMode ;

3945

qglRotated = logRotated ;

3946

qglRotatef = logRotatef ;

3947

qglScaled = logScaled ;

3948

qglScalef = logScalef ;

3949

qglScissor = logScissor ;

3950

qglSelectBuffer = logSelectBuffer ;

3951

qglShadeModel = logShadeModel ;

3952

qglStencilFunc = logStencilFunc ;

3953

qglStencilMask = logStencilMask ;

3954

qglStencilOp = logStencilOp ;

3955

qglTexCoord1d = logTexCoord1d ;

3956

qglTexCoord1dv = logTexCoord1dv ;

3957

qglTexCoord1f = logTexCoord1f ;

3958

qglTexCoord1fv = logTexCoord1fv ;

3959

qglTexCoord1i = logTexCoord1i ;

3960

qglTexCoord1iv = logTexCoord1iv ;

3961

qglTexCoord1s = logTexCoord1s ;

3962

qglTexCoord1sv = logTexCoord1sv ;

3963

qglTexCoord2d = logTexCoord2d ;

3964

qglTexCoord2dv = logTexCoord2dv ;

3965

qglTexCoord2f = logTexCoord2f ;

3966

qglTexCoord2fv = logTexCoord2fv ;

3967

qglTexCoord2i = logTexCoord2i ;

3968

qglTexCoord2iv = logTexCoord2iv ;

3969

qglTexCoord2s = logTexCoord2s ;

3970

qglTexCoord2sv = logTexCoord2sv ;

3971

qglTexCoord3d = logTexCoord3d ;

3972

qglTexCoord3dv = logTexCoord3dv ;

3973

qglTexCoord3f = logTexCoord3f ;

3974

qglTexCoord3fv = logTexCoord3fv ;

3975

qglTexCoord3i = logTexCoord3i ;

3976

qglTexCoord3iv = logTexCoord3iv ;

3977

qglTexCoord3s = logTexCoord3s ;

3978

qglTexCoord3sv = logTexCoord3sv ;

3979

qglTexCoord4d = logTexCoord4d ;

3980

qglTexCoord4dv = logTexCoord4dv ;

3981

qglTexCoord4f = logTexCoord4f ;

3982

qglTexCoord4fv = logTexCoord4fv ;

3983

qglTexCoord4i = logTexCoord4i ;

3984

qglTexCoord4iv = logTexCoord4iv ;

3985

qglTexCoord4s = logTexCoord4s ;

3986

qglTexCoord4sv = logTexCoord4sv ;

3987

qglTexCoordPointer = logTexCoordPointer ;

3988

qglTexEnvf = logTexEnvf ;

3989

qglTexEnvfv = logTexEnvfv ;

3990

qglTexEnvi = logTexEnvi ;

3991

qglTexEnviv = logTexEnviv ;

3992

qglTexGend = logTexGend ;

3993

qglTexGendv = logTexGendv ;

3994

qglTexGenf = logTexGenf ;

3995

qglTexGenfv = logTexGenfv ;

3996

qglTexGeni = logTexGeni ;

3997

qglTexGeniv = logTexGeniv ;

3998

qglTexImage1D = logTexImage1D ;

3999

qglTexImage2D = logTexImage2D ;

4000

qglTexParameterf = logTexParameterf ;

4001

qglTexParameterfv = logTexParameterfv ;

4002

qglTexParameteri = logTexParameteri ;

4003

qglTexParameteriv = logTexParameteriv ;

4004

qglTexSubImage1D = logTexSubImage1D ;

4005

qglTexSubImage2D = logTexSubImage2D ;

4006

qglTranslated = logTranslated ;

4007

qglTranslatef = logTranslatef ;

4008

qglVertex2d = logVertex2d ;

4009

qglVertex2dv = logVertex2dv ;

4010

qglVertex2f = logVertex2f ;

4011

qglVertex2fv = logVertex2fv ;

4012

qglVertex2i = logVertex2i ;

4013

qglVertex2iv = logVertex2iv ;

4014

qglVertex2s = logVertex2s ;

4015

qglVertex2sv = logVertex2sv ;

4016

qglVertex3d = logVertex3d ;

4017

qglVertex3dv = logVertex3dv ;

4018

qglVertex3f = logVertex3f ;

4019

qglVertex3fv = logVertex3fv ;

4020

qglVertex3i = logVertex3i ;

4021

qglVertex3iv = logVertex3iv ;

4022

qglVertex3s = logVertex3s ;

4023

qglVertex3sv = logVertex3sv ;

4024

qglVertex4d = logVertex4d ;

4025

qglVertex4dv = logVertex4dv ;

4026

qglVertex4f = logVertex4f ;

4027

qglVertex4fv = logVertex4fv ;

4028

qglVertex4i = logVertex4i ;

4029

qglVertex4iv = logVertex4iv ;

4030

qglVertex4s = logVertex4s ;

4031

qglVertex4sv = logVertex4sv ;

4032

qglVertexPointer = logVertexPointer ;

4033

qglViewport = logViewport ;

4034

}

4035

else

4036

{

4037

if ( glw_state.log_fp ) {

4038

fprintf( glw_state.log_fp, "*** CLOSING LOG ***\n" );

4039

fclose( glw_state.log_fp );

4040

glw_state.log_fp = NULL;

4041

}

4042

qglAccum = dllAccum;

4043

qglAlphaFunc = dllAlphaFunc;

4044

qglAreTexturesResident = dllAreTexturesResident;

4045

qglArrayElement = dllArrayElement;

4046

qglBegin = dllBegin;

4047

qglBindTexture = dllBindTexture;

4048

qglBitmap = dllBitmap;

4049

qglBlendFunc = dllBlendFunc;

4050

qglCallList = dllCallList;

4051

qglCallLists = dllCallLists;

4052

qglClear = dllClear;

4053

qglClearAccum = dllClearAccum;

4054

qglClearColor = dllClearColor;

4055

qglClearDepth = dllClearDepth;

4056

qglClearIndex = dllClearIndex;

4057

qglClearStencil = dllClearStencil;

4058

qglClipPlane = dllClipPlane;

4059

qglColor3b = dllColor3b;

4060

qglColor3bv = dllColor3bv;

4061

qglColor3d = dllColor3d;

4062

qglColor3dv = dllColor3dv;

4063

qglColor3f = dllColor3f;

4064

qglColor3fv = dllColor3fv;

4065

qglColor3i = dllColor3i;

4066

qglColor3iv = dllColor3iv;

4067

qglColor3s = dllColor3s;

4068

qglColor3sv = dllColor3sv;

4069

qglColor3ub = dllColor3ub;

4070

qglColor3ubv = dllColor3ubv;

4071

qglColor3ui = dllColor3ui;

4072

qglColor3uiv = dllColor3uiv;

4073

qglColor3us = dllColor3us;

4074

qglColor3usv = dllColor3usv;

4075

qglColor4b = dllColor4b;

4076

qglColor4bv = dllColor4bv;

4077

qglColor4d = dllColor4d;

4078

qglColor4dv = dllColor4dv;

4079

qglColor4f = dllColor4f;

4080

qglColor4fv = dllColor4fv;

4081

qglColor4i = dllColor4i;

4082

qglColor4iv = dllColor4iv;

4083

qglColor4s = dllColor4s;

4084

qglColor4sv = dllColor4sv;

4085

qglColor4ub = dllColor4ub;

4086

qglColor4ubv = dllColor4ubv;

4087

qglColor4ui = dllColor4ui;

4088

qglColor4uiv = dllColor4uiv;

4089

qglColor4us = dllColor4us;

4090

qglColor4usv = dllColor4usv;

4091

qglColorMask = dllColorMask;

4092

qglColorMaterial = dllColorMaterial;

4093

qglColorPointer = dllColorPointer;

4094

qglCopyPixels = dllCopyPixels;

4095

qglCopyTexImage1D = dllCopyTexImage1D;

4096

qglCopyTexImage2D = dllCopyTexImage2D;

4097

qglCopyTexSubImage1D = dllCopyTexSubImage1D;

4098

qglCopyTexSubImage2D = dllCopyTexSubImage2D;

4099

qglCullFace = dllCullFace;

4100

qglDeleteLists = dllDeleteLists ;

4101

qglDeleteTextures = dllDeleteTextures ;

4102

qglDepthFunc = dllDepthFunc ;

4103

qglDepthMask = dllDepthMask ;

4104

qglDepthRange = dllDepthRange ;

4105

qglDisable = dllDisable ;

4106

qglDisableClientState = dllDisableClientState ;

4107

qglDrawArrays = dllDrawArrays ;

4108

qglDrawBuffer = dllDrawBuffer ;

4109

qglDrawElements = dllDrawElements ;

4110

qglDrawPixels = dllDrawPixels ;

4111

qglEdgeFlag = dllEdgeFlag ;

4112

qglEdgeFlagPointer = dllEdgeFlagPointer ;

4113

qglEdgeFlagv = dllEdgeFlagv ;

4114

qglEnable = dllEnable ;

4115

qglEnableClientState = dllEnableClientState ;

4116

qglEnd = dllEnd ;

4117

qglEndList = dllEndList ;

4118

qglEvalCoord1d = dllEvalCoord1d ;

4119

qglEvalCoord1dv = dllEvalCoord1dv ;

4120

qglEvalCoord1f = dllEvalCoord1f ;

4121

qglEvalCoord1fv = dllEvalCoord1fv ;

4122

qglEvalCoord2d = dllEvalCoord2d ;

4123

qglEvalCoord2dv = dllEvalCoord2dv ;

4124

qglEvalCoord2f = dllEvalCoord2f ;

4125

qglEvalCoord2fv = dllEvalCoord2fv ;

4126

qglEvalMesh1 = dllEvalMesh1 ;

4127

qglEvalMesh2 = dllEvalMesh2 ;

4128

qglEvalPoint1 = dllEvalPoint1 ;

4129

qglEvalPoint2 = dllEvalPoint2 ;

4130

qglFeedbackBuffer = dllFeedbackBuffer ;

4131

qglFinish = dllFinish ;

4132

qglFlush = dllFlush ;

4133

qglFogf = dllFogf ;

4134

qglFogfv = dllFogfv ;

4135

qglFogi = dllFogi ;

4136

qglFogiv = dllFogiv ;

4137

qglFrontFace = dllFrontFace ;

4138

qglFrustum = dllFrustum ;

4139

qglGenLists = dllGenLists ;

4140

qglGenTextures = dllGenTextures ;

4141

qglGetBooleanv = dllGetBooleanv ;

4142

qglGetClipPlane = dllGetClipPlane ;

4143

qglGetDoublev = dllGetDoublev ;

4144

qglGetError = dllGetError ;

4145

qglGetFloatv = dllGetFloatv ;

4146

qglGetIntegerv = dllGetIntegerv ;

4147

qglGetLightfv = dllGetLightfv ;

4148

qglGetLightiv = dllGetLightiv ;

4149

qglGetMapdv = dllGetMapdv ;

4150

qglGetMapfv = dllGetMapfv ;

4151

qglGetMapiv = dllGetMapiv ;

4152

qglGetMaterialfv = dllGetMaterialfv ;

4153

qglGetMaterialiv = dllGetMaterialiv ;

4154

qglGetPixelMapfv = dllGetPixelMapfv ;

4155

qglGetPixelMapuiv = dllGetPixelMapuiv ;

4156

qglGetPixelMapusv = dllGetPixelMapusv ;

4157

qglGetPointerv = dllGetPointerv ;

4158

qglGetPolygonStipple = dllGetPolygonStipple ;

4159

qglGetString = dllGetString ;

4160

qglGetTexEnvfv = dllGetTexEnvfv ;

4161

qglGetTexEnviv = dllGetTexEnviv ;

4162

qglGetTexGendv = dllGetTexGendv ;

4163

qglGetTexGenfv = dllGetTexGenfv ;

4164

qglGetTexGeniv = dllGetTexGeniv ;

4165

qglGetTexImage = dllGetTexImage ;

4166

qglGetTexLevelParameterfv = dllGetTexLevelParameterfv ;

4167

qglGetTexLevelParameteriv = dllGetTexLevelParameteriv ;

4168

qglGetTexParameterfv = dllGetTexParameterfv ;

4169

qglGetTexParameteriv = dllGetTexParameteriv ;

4170

qglHint = dllHint ;

4171

qglIndexMask = dllIndexMask ;

4172

qglIndexPointer = dllIndexPointer ;

4173

qglIndexd = dllIndexd ;

4174

qglIndexdv = dllIndexdv ;

4175

qglIndexf = dllIndexf ;

4176

qglIndexfv = dllIndexfv ;

4177

qglIndexi = dllIndexi ;

4178

qglIndexiv = dllIndexiv ;

4179

qglIndexs = dllIndexs ;

4180

qglIndexsv = dllIndexsv ;

4181

qglIndexub = dllIndexub ;

4182

qglIndexubv = dllIndexubv ;

4183

qglInitNames = dllInitNames ;

4184

qglInterleavedArrays = dllInterleavedArrays ;

4185

qglIsEnabled = dllIsEnabled ;

4186

qglIsList = dllIsList ;

4187

qglIsTexture = dllIsTexture ;

4188

qglLightModelf = dllLightModelf ;

4189

qglLightModelfv = dllLightModelfv ;

4190

qglLightModeli = dllLightModeli ;

4191

qglLightModeliv = dllLightModeliv ;

4192

qglLightf = dllLightf ;

4193

qglLightfv = dllLightfv ;

4194

qglLighti = dllLighti ;

4195

qglLightiv = dllLightiv ;

4196

qglLineStipple = dllLineStipple ;

4197

qglLineWidth = dllLineWidth ;

4198

qglListBase = dllListBase ;

4199

qglLoadIdentity = dllLoadIdentity ;

4200

qglLoadMatrixd = dllLoadMatrixd ;

4201

qglLoadMatrixf = dllLoadMatrixf ;

4202

qglLoadName = dllLoadName ;

4203

qglLogicOp = dllLogicOp ;

4204

qglMap1d = dllMap1d ;

4205

qglMap1f = dllMap1f ;

4206

qglMap2d = dllMap2d ;

4207

qglMap2f = dllMap2f ;

4208

qglMapGrid1d = dllMapGrid1d ;

4209

qglMapGrid1f = dllMapGrid1f ;

4210

qglMapGrid2d = dllMapGrid2d ;

4211

qglMapGrid2f = dllMapGrid2f ;

4212

qglMaterialf = dllMaterialf ;

4213

qglMaterialfv = dllMaterialfv ;

4214

qglMateriali = dllMateriali ;

4215

qglMaterialiv = dllMaterialiv ;

4216

qglMatrixMode = dllMatrixMode ;

4217

qglMultMatrixd = dllMultMatrixd ;

4218

qglMultMatrixf = dllMultMatrixf ;

4219

qglNewList = dllNewList ;

4220

qglNormal3b = dllNormal3b ;

4221

qglNormal3bv = dllNormal3bv ;

4222

qglNormal3d = dllNormal3d ;

4223

qglNormal3dv = dllNormal3dv ;

4224

qglNormal3f = dllNormal3f ;

4225

qglNormal3fv = dllNormal3fv ;

4226

qglNormal3i = dllNormal3i ;

4227

qglNormal3iv = dllNormal3iv ;

4228

qglNormal3s = dllNormal3s ;

4229

qglNormal3sv = dllNormal3sv ;

4230

qglNormalPointer = dllNormalPointer ;

4231

qglOrtho = dllOrtho ;

4232

qglPassThrough = dllPassThrough ;

4233

qglPixelMapfv = dllPixelMapfv ;

4234

qglPixelMapuiv = dllPixelMapuiv ;

4235

qglPixelMapusv = dllPixelMapusv ;

4236

qglPixelStoref = dllPixelStoref ;

4237

qglPixelStorei = dllPixelStorei ;

4238

qglPixelTransferf = dllPixelTransferf ;

4239

qglPixelTransferi = dllPixelTransferi ;

4240

qglPixelZoom = dllPixelZoom ;

4241

qglPointSize = dllPointSize ;

4242

qglPolygonMode = dllPolygonMode ;

4243

qglPolygonOffset = dllPolygonOffset ;

4244

qglPolygonStipple = dllPolygonStipple ;

4245

qglPopAttrib = dllPopAttrib ;

4246

qglPopClientAttrib = dllPopClientAttrib ;

4247

qglPopMatrix = dllPopMatrix ;

4248

qglPopName = dllPopName ;

4249

qglPrioritizeTextures = dllPrioritizeTextures ;

4250

qglPushAttrib = dllPushAttrib ;

4251

qglPushClientAttrib = dllPushClientAttrib ;

4252

qglPushMatrix = dllPushMatrix ;

4253

qglPushName = dllPushName ;

4254

qglRasterPos2d = dllRasterPos2d ;

4255

qglRasterPos2dv = dllRasterPos2dv ;

4256

qglRasterPos2f = dllRasterPos2f ;

4257

qglRasterPos2fv = dllRasterPos2fv ;

4258

qglRasterPos2i = dllRasterPos2i ;

4259

qglRasterPos2iv = dllRasterPos2iv ;

4260

qglRasterPos2s = dllRasterPos2s ;

4261

qglRasterPos2sv = dllRasterPos2sv ;

4262

qglRasterPos3d = dllRasterPos3d ;

4263

qglRasterPos3dv = dllRasterPos3dv ;

4264

qglRasterPos3f = dllRasterPos3f ;

4265

qglRasterPos3fv = dllRasterPos3fv ;

4266

qglRasterPos3i = dllRasterPos3i ;

4267

qglRasterPos3iv = dllRasterPos3iv ;

4268

qglRasterPos3s = dllRasterPos3s ;

4269

qglRasterPos3sv = dllRasterPos3sv ;

4270

qglRasterPos4d = dllRasterPos4d ;

4271

qglRasterPos4dv = dllRasterPos4dv ;

4272

qglRasterPos4f = dllRasterPos4f ;

4273

qglRasterPos4fv = dllRasterPos4fv ;

4274

qglRasterPos4i = dllRasterPos4i ;

4275

qglRasterPos4iv = dllRasterPos4iv ;

4276

qglRasterPos4s = dllRasterPos4s ;

4277

qglRasterPos4sv = dllRasterPos4sv ;

4278

qglReadBuffer = dllReadBuffer ;

4279

qglReadPixels = dllReadPixels ;

4280

qglRectd = dllRectd ;

4281

qglRectdv = dllRectdv ;

4282

qglRectf = dllRectf ;

4283

qglRectfv = dllRectfv ;

4284

qglRecti = dllRecti ;

4285

qglRectiv = dllRectiv ;

4286

qglRects = dllRects ;

4287

qglRectsv = dllRectsv ;

4288

qglRenderMode = dllRenderMode ;

4289

qglRotated = dllRotated ;

4290

qglRotatef = dllRotatef ;

4291

qglScaled = dllScaled ;

4292

qglScalef = dllScalef ;

4293

qglScissor = dllScissor ;

4294

qglSelectBuffer = dllSelectBuffer ;

4295

qglShadeModel = dllShadeModel ;

4296

qglStencilFunc = dllStencilFunc ;

4297

qglStencilMask = dllStencilMask ;

4298

qglStencilOp = dllStencilOp ;

4299

qglTexCoord1d = dllTexCoord1d ;

4300

qglTexCoord1dv = dllTexCoord1dv ;

4301

qglTexCoord1f = dllTexCoord1f ;

4302

qglTexCoord1fv = dllTexCoord1fv ;

4303

qglTexCoord1i = dllTexCoord1i ;

4304

qglTexCoord1iv = dllTexCoord1iv ;

4305

qglTexCoord1s = dllTexCoord1s ;

4306

qglTexCoord1sv = dllTexCoord1sv ;

4307

qglTexCoord2d = dllTexCoord2d ;

4308

qglTexCoord2dv = dllTexCoord2dv ;

4309

qglTexCoord2f = dllTexCoord2f ;

4310

qglTexCoord2fv = dllTexCoord2fv ;

4311

qglTexCoord2i = dllTexCoord2i ;

4312

qglTexCoord2iv = dllTexCoord2iv ;

4313

qglTexCoord2s = dllTexCoord2s ;

4314

qglTexCoord2sv = dllTexCoord2sv ;

4315

qglTexCoord3d = dllTexCoord3d ;

4316

qglTexCoord3dv = dllTexCoord3dv ;

4317

qglTexCoord3f = dllTexCoord3f ;

4318

qglTexCoord3fv = dllTexCoord3fv ;

4319

qglTexCoord3i = dllTexCoord3i ;

4320

qglTexCoord3iv = dllTexCoord3iv ;

4321

qglTexCoord3s = dllTexCoord3s ;

4322

qglTexCoord3sv = dllTexCoord3sv ;

4323

qglTexCoord4d = dllTexCoord4d ;

4324

qglTexCoord4dv = dllTexCoord4dv ;

4325

qglTexCoord4f = dllTexCoord4f ;

4326

qglTexCoord4fv = dllTexCoord4fv ;

4327

qglTexCoord4i = dllTexCoord4i ;

4328

qglTexCoord4iv = dllTexCoord4iv ;

4329

qglTexCoord4s = dllTexCoord4s ;

4330

qglTexCoord4sv = dllTexCoord4sv ;

4331

qglTexCoordPointer = dllTexCoordPointer ;

4332

qglTexEnvf = dllTexEnvf ;

4333

qglTexEnvfv = dllTexEnvfv ;

4334

qglTexEnvi = dllTexEnvi ;

4335

qglTexEnviv = dllTexEnviv ;

4336

qglTexGend = dllTexGend ;

4337

qglTexGendv = dllTexGendv ;

4338

qglTexGenf = dllTexGenf ;

4339

qglTexGenfv = dllTexGenfv ;

4340

qglTexGeni = dllTexGeni ;

4341

qglTexGeniv = dllTexGeniv ;

4342

qglTexImage1D = dllTexImage1D ;

4343

qglTexImage2D = dllTexImage2D ;

4344

qglTexParameterf = dllTexParameterf ;

4345

qglTexParameterfv = dllTexParameterfv ;

4346

qglTexParameteri = dllTexParameteri ;

4347

qglTexParameteriv = dllTexParameteriv ;

4348

qglTexSubImage1D = dllTexSubImage1D ;

4349

qglTexSubImage2D = dllTexSubImage2D ;

4350

qglTranslated = dllTranslated ;

4351

qglTranslatef = dllTranslatef ;

4352

qglVertex2d = dllVertex2d ;

4353

qglVertex2dv = dllVertex2dv ;

4354

qglVertex2f = dllVertex2f ;

4355

qglVertex2fv = dllVertex2fv ;

4356

qglVertex2i = dllVertex2i ;

4357

qglVertex2iv = dllVertex2iv ;

4358

qglVertex2s = dllVertex2s ;

4359

qglVertex2sv = dllVertex2sv ;

4360

qglVertex3d = dllVertex3d ;

4361

qglVertex3dv = dllVertex3dv ;

4362

qglVertex3f = dllVertex3f ;

4363

qglVertex3fv = dllVertex3fv ;

4364

qglVertex3i = dllVertex3i ;

4365

qglVertex3iv = dllVertex3iv ;

4366

qglVertex3s = dllVertex3s ;

4367

qglVertex3sv = dllVertex3sv ;

4368

qglVertex4d = dllVertex4d ;

4369

qglVertex4dv = dllVertex4dv ;

4370

qglVertex4f = dllVertex4f ;

4371

qglVertex4fv = dllVertex4fv ;

4372

qglVertex4i = dllVertex4i ;

4373

qglVertex4iv = dllVertex4iv ;

4374

qglVertex4s = dllVertex4s ;

4375

qglVertex4sv = dllVertex4sv ;

4376

qglVertexPointer = dllVertexPointer ;

4377

qglViewport = dllViewport ;

4378

}

4379

}

4380

4381

#ifdef _MSC_VER

4382

#pragma warning (default : 4113 4133 4047 )

4383

#endif

4384

4385

4386

Older »