3719 lines
129 KiB
C++
3719 lines
129 KiB
C++
/*=============================================================================
|
|
GLLog.cpp : implementation of the Logging OpenGL functions.
|
|
Copyright (c) 2001 Crytek Studios. All Rights Reserved.
|
|
|
|
Revision history:
|
|
* Created by Honitch Andrey
|
|
|
|
=============================================================================*/
|
|
|
|
|
|
#include "RenderPCH.h"
|
|
#include "GL_Renderer.h"
|
|
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
|
|
//======================================================================
|
|
|
|
// GL functions implement.
|
|
#define GL_EXT(name)
|
|
#define GL_PROC(ext,ret,func,parms) ret (__stdcall *t##func)parms;
|
|
#include "GLFuncs.h"
|
|
#undef GL_EXT
|
|
#undef GL_PROC
|
|
|
|
/*#define GL_EXT(name)
|
|
#define GL_PROC(ext,ret,func,parms) ret l##func parms;
|
|
{\
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", #func);\
|
|
return t##func parms; \
|
|
}\
|
|
|
|
#include "GLFuncs.h"
|
|
#undef GL_EXT
|
|
#undef GL_PROC*/
|
|
|
|
#define ecase(e) case e: return #e
|
|
|
|
static char sStr[1024];
|
|
#define edefault(e) default: sprintf(sStr, "0x%x", e); return sStr;
|
|
|
|
static char *senFace(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_FRONT);
|
|
ecase (GL_BACK);
|
|
ecase (GL_FRONT_AND_BACK);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senProgramARB(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_VERTEX_PROGRAM_ARB);
|
|
ecase (GL_FRAGMENT_PROGRAM_ARB);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senArrayBufferARB(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_ELEMENT_ARRAY_BUFFER_ARB);
|
|
ecase (GL_ARRAY_BUFFER_ARB);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senMaterial(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_SHININESS);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senFog(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_FOG_COLOR);
|
|
ecase (GL_FOG_END);
|
|
ecase (GL_FOG_START);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senMaterialv(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_AMBIENT);
|
|
ecase (GL_DIFFUSE);
|
|
ecase (GL_SPECULAR);
|
|
ecase (GL_EMISSION);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senLightv(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_POSITION);
|
|
ecase (GL_AMBIENT);
|
|
ecase (GL_DIFFUSE);
|
|
ecase (GL_SPECULAR);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senLight(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_CONSTANT_ATTENUATION);
|
|
ecase (GL_LINEAR_ATTENUATION);
|
|
ecase (GL_QUADRATIC_ATTENUATION);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senStencilFunc(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_NEVER);
|
|
ecase (GL_LESS);
|
|
ecase (GL_EQUAL);
|
|
ecase (GL_LEQUAL);
|
|
ecase (GL_GREATER);
|
|
ecase (GL_NOTEQUAL);
|
|
ecase (GL_GEQUAL);
|
|
ecase (GL_ALWAYS);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senStencilOp(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_ZERO);
|
|
ecase (GL_KEEP);
|
|
ecase (GL_REPLACE);
|
|
ecase (GL_INCR);
|
|
ecase (GL_DECR);
|
|
ecase (GL_INCR_WRAP_EXT);
|
|
ecase (GL_DECR_WRAP_EXT);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senNewList(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_COMPILE);
|
|
ecase (GL_COMPILE_AND_EXECUTE);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senMatrixMode(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_MODELVIEW);
|
|
ecase (GL_PROJECTION);
|
|
ecase (GL_TEXTURE);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senPolyType(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_POINTS);
|
|
ecase (GL_LINES);
|
|
ecase (GL_LINE_LOOP);
|
|
ecase (GL_LINE_STRIP);
|
|
ecase (GL_TRIANGLES);
|
|
ecase (GL_TRIANGLE_STRIP);
|
|
ecase (GL_TRIANGLE_FAN);
|
|
ecase (GL_QUADS);
|
|
ecase (GL_QUAD_STRIP);
|
|
ecase (GL_POLYGON);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senDataType(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_BYTE);
|
|
ecase (GL_UNSIGNED_BYTE);
|
|
ecase (GL_SHORT);
|
|
ecase (GL_UNSIGNED_SHORT);
|
|
ecase (GL_INT);
|
|
ecase (GL_UNSIGNED_INT);
|
|
ecase (GL_FLOAT);
|
|
ecase (GL_DOUBLE);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senAlphaFunction(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_NEVER);
|
|
ecase (GL_LESS);
|
|
ecase (GL_EQUAL);
|
|
ecase (GL_LEQUAL);
|
|
ecase (GL_GREATER);
|
|
ecase (GL_NOTEQUAL);
|
|
ecase (GL_GEQUAL);
|
|
ecase (GL_ALWAYS);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senBlendingFactor(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_ZERO);
|
|
ecase (GL_ONE);
|
|
ecase (GL_SRC_COLOR);
|
|
ecase (GL_ONE_MINUS_SRC_COLOR);
|
|
ecase (GL_SRC_ALPHA);
|
|
ecase (GL_ONE_MINUS_SRC_ALPHA);
|
|
ecase (GL_DST_ALPHA);
|
|
ecase (GL_ONE_MINUS_DST_ALPHA);
|
|
ecase (GL_DST_COLOR);
|
|
ecase (GL_ONE_MINUS_DST_COLOR);
|
|
ecase (GL_SRC_ALPHA_SATURATE);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senAccumOp(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_ACCUM);
|
|
ecase (GL_LOAD);
|
|
ecase (GL_RETURN);
|
|
ecase (GL_MULT);
|
|
ecase (GL_ADD);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senClientState(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_VERTEX_ARRAY);
|
|
ecase (GL_NORMAL_ARRAY);
|
|
ecase (GL_COLOR_ARRAY);
|
|
ecase (GL_TEXTURE_COORD_ARRAY);
|
|
ecase (GL_VERTEX_ARRAY_RANGE_NV);
|
|
ecase (GL_VERTEX_ATTRIB_ARRAY0_NV);
|
|
ecase (GL_VERTEX_ATTRIB_ARRAY1_NV);
|
|
ecase (GL_VERTEX_ATTRIB_ARRAY2_NV);
|
|
ecase (GL_VERTEX_ATTRIB_ARRAY3_NV);
|
|
ecase (GL_VERTEX_ATTRIB_ARRAY4_NV);
|
|
ecase (GL_VERTEX_ATTRIB_ARRAY5_NV);
|
|
ecase (GL_VERTEX_ATTRIB_ARRAY6_NV);
|
|
ecase (GL_VERTEX_ATTRIB_ARRAY7_NV);
|
|
ecase (GL_VERTEX_ATTRIB_ARRAY8_NV);
|
|
ecase (GL_VERTEX_ATTRIB_ARRAY9_NV);
|
|
ecase (GL_VERTEX_ATTRIB_ARRAY10_NV);
|
|
ecase (GL_VERTEX_ATTRIB_ARRAY11_NV);
|
|
ecase (GL_VERTEX_ATTRIB_ARRAY12_NV);
|
|
ecase (GL_VERTEX_ATTRIB_ARRAY13_NV);
|
|
ecase (GL_VERTEX_ATTRIB_ARRAY14_NV);
|
|
ecase (GL_VERTEX_ATTRIB_ARRAY15_NV);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senCullFace(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_FRONT);
|
|
ecase (GL_BACK);
|
|
ecase (GL_FRONT_AND_BACK);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senTextureEnvTarget(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_TEXTURE_ENV);
|
|
ecase (GL_TEXTURE_SHADER_NV);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senTextureEnvPName(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_TEXTURE_ENV_MODE);
|
|
ecase (GL_COMBINE_RGB_EXT);
|
|
ecase (GL_COMBINE_ALPHA_EXT);
|
|
ecase (GL_SOURCE0_RGB_EXT);
|
|
ecase (GL_SOURCE1_RGB_EXT);
|
|
ecase (GL_SOURCE2_RGB_EXT);
|
|
ecase (GL_SOURCE3_RGB_NV);
|
|
ecase (GL_SOURCE0_ALPHA_EXT);
|
|
ecase (GL_SOURCE1_ALPHA_EXT);
|
|
ecase (GL_SOURCE2_ALPHA_EXT);
|
|
ecase (GL_SOURCE3_ALPHA_NV);
|
|
ecase (GL_OPERAND0_RGB_EXT);
|
|
ecase (GL_OPERAND1_RGB_EXT);
|
|
ecase (GL_OPERAND2_RGB_EXT);
|
|
ecase (GL_OPERAND3_RGB_NV);
|
|
ecase (GL_OPERAND0_ALPHA_EXT);
|
|
ecase (GL_OPERAND1_ALPHA_EXT);
|
|
ecase (GL_OPERAND2_ALPHA_EXT);
|
|
ecase (GL_OPERAND3_ALPHA_NV);
|
|
ecase (GL_RGB_SCALE_EXT);
|
|
ecase (GL_ALPHA_SCALE);
|
|
ecase (GL_SHADER_OPERATION_NV);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senTextureEnvfPName(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_TEXTURE_ENV_COLOR);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senTextureEnvParam(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_MODULATE);
|
|
ecase (GL_NONE);
|
|
ecase (GL_COMBINE_ALPHA_EXT);
|
|
ecase (GL_REPLACE);
|
|
ecase (GL_DECAL);
|
|
ecase (GL_ADD);
|
|
ecase (GL_COMBINE_EXT);
|
|
ecase (GL_ADD_SIGNED_EXT);
|
|
ecase (GL_COMBINE4_NV);
|
|
ecase (GL_TEXTURE);
|
|
ecase (GL_SRC_COLOR);
|
|
ecase (GL_PRIMARY_COLOR_EXT);
|
|
ecase (GL_SRC_ALPHA);
|
|
ecase (GL_ONE_MINUS_SRC_ALPHA);
|
|
ecase (GL_TEXTURE0_ARB);
|
|
ecase (GL_TEXTURE1_ARB);
|
|
ecase (GL_TEXTURE2_ARB);
|
|
ecase (GL_TEXTURE3_ARB);
|
|
ecase (GL_TEXTURE4_ARB);
|
|
ecase (GL_TEXTURE5_ARB);
|
|
ecase (GL_TEXTURE6_ARB);
|
|
ecase (GL_TEXTURE7_ARB);
|
|
ecase (GL_ONE_MINUS_SRC_COLOR);
|
|
ecase (GL_PREVIOUS_EXT);
|
|
ecase (GL_CONSTANT_EXT);
|
|
ecase (GL_ONE);
|
|
ecase (GL_CULL_FRAGMENT_NV);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senFenceContition(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_ALL_COMPLETED_NV);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
|
|
static char *senTexFormat(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_BGRA_EXT);
|
|
ecase (GL_BGR_EXT);
|
|
ecase (GL_RGBA);
|
|
ecase (GL_RGB);
|
|
ecase (GL_RGB8);
|
|
ecase (GL_ALPHA);
|
|
ecase (GL_RGBA4);
|
|
ecase (GL_COMPRESSED_RGB_S3TC_DXT1_EXT);
|
|
ecase (GL_COMPRESSED_RGBA_S3TC_DXT3_EXT);
|
|
ecase (GL_COMPRESSED_RGBA_S3TC_DXT5_EXT);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senTexDataType(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_UNSIGNED_BYTE);
|
|
ecase (GL_BYTE);
|
|
ecase (GL_SHORT);
|
|
ecase (GL_UNSIGNED_SHORT);
|
|
ecase (GL_INT);
|
|
ecase (GL_UNSIGNED_INT);
|
|
ecase (GL_FLOAT);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senTexTarg(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_TEXTURE_1D);
|
|
ecase (GL_TEXTURE_2D);
|
|
ecase (GL_TEXTURE_3D);
|
|
ecase (GL_TEXTURE_CUBE_MAP_EXT);
|
|
ecase (GL_TEXTURE_RECTANGLE_NV);
|
|
ecase (GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT);
|
|
ecase (GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT);
|
|
ecase (GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT);
|
|
ecase (GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT);
|
|
ecase (GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT);
|
|
ecase (GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senTexParmName(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_TEXTURE_MIN_FILTER);
|
|
ecase (GL_TEXTURE_MAG_FILTER);
|
|
ecase (GL_TEXTURE_MAX_ANISOTROPY_EXT);
|
|
ecase (GL_TEXTURE_WRAP_S);
|
|
ecase (GL_TEXTURE_WRAP_T);
|
|
ecase (GL_TEXTURE_WRAP_R);
|
|
ecase (GL_GENERATE_MIPMAP_SGIS);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senTexParm(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_CLAMP_TO_EDGE);
|
|
ecase (GL_REPEAT);
|
|
ecase (GL_LINEAR);
|
|
ecase (GL_LINEAR_MIPMAP_NEAREST);
|
|
ecase (GL_LINEAR_MIPMAP_LINEAR);
|
|
ecase (GL_NEAREST_MIPMAP_NEAREST);
|
|
ecase (GL_NEAREST);
|
|
ecase (GL_TEXTURE_MAX_ANISOTROPY_EXT);
|
|
ecase (GL_TEXTURE_WRAP_S);
|
|
ecase (GL_TEXTURE_WRAP_T);
|
|
ecase (GL_TEXTURE_WRAP_R);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senDisEn(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_FRAGMENT_PROGRAM_ARB);
|
|
ecase (GL_FOG);
|
|
ecase (GL_TEXTURE_GEN_S);
|
|
ecase (GL_TEXTURE_GEN_T);
|
|
ecase (GL_TEXTURE_GEN_R);
|
|
ecase (GL_TEXTURE_GEN_Q);
|
|
ecase (GL_LIGHTING);
|
|
ecase (GL_TEXTURE_1D);
|
|
ecase (GL_TEXTURE_2D);
|
|
ecase (GL_LINE_STIPPLE);
|
|
ecase (GL_POLYGON_STIPPLE);
|
|
ecase (GL_CULL_FACE);
|
|
ecase (GL_ALPHA_TEST);
|
|
ecase (GL_BLEND);
|
|
ecase (GL_INDEX_LOGIC_OP);
|
|
ecase (GL_COLOR_LOGIC_OP);
|
|
ecase (GL_DITHER);
|
|
ecase (GL_STENCIL_TEST);
|
|
ecase (GL_DEPTH_TEST);
|
|
ecase (GL_CLIP_PLANE0);
|
|
ecase (GL_CLIP_PLANE1);
|
|
ecase (GL_CLIP_PLANE2);
|
|
ecase (GL_CLIP_PLANE3);
|
|
ecase (GL_CLIP_PLANE4);
|
|
ecase (GL_CLIP_PLANE5);
|
|
ecase (GL_LIGHT0);
|
|
ecase (GL_LIGHT1);
|
|
ecase (GL_LIGHT2);
|
|
ecase (GL_LIGHT3);
|
|
ecase (GL_LIGHT4);
|
|
ecase (GL_LIGHT5);
|
|
ecase (GL_LIGHT6);
|
|
ecase (GL_LIGHT7);
|
|
ecase (GL_POINT_SMOOTH);
|
|
ecase (GL_LINE_SMOOTH);
|
|
ecase (GL_SCISSOR_TEST);
|
|
ecase (GL_COLOR_MATERIAL);
|
|
ecase (GL_VERTEX_ARRAY);
|
|
ecase (GL_NORMAL_ARRAY);
|
|
ecase (GL_NORMALIZE);
|
|
ecase (GL_COLOR_ARRAY);
|
|
ecase (GL_TEXTURE_COORD_ARRAY);
|
|
ecase (GL_POLYGON_OFFSET_FILL);
|
|
ecase (GL_POLYGON_OFFSET_LINE);
|
|
ecase (GL_REGISTER_COMBINERS_NV);
|
|
ecase (GL_VERTEX_PROGRAM_NV);
|
|
ecase (GL_VERTEX_STATE_PROGRAM_NV);
|
|
ecase (GL_PER_STAGE_CONSTANTS_NV);
|
|
ecase (GL_TEXTURE_SHADER_NV);
|
|
ecase (GL_TEXTURE_CUBE_MAP_EXT);
|
|
ecase (GL_FRAGMENT_SHADER_ATI);
|
|
ecase (GL_STENCIL_TEST_TWO_SIDE_EXT);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
static char *senActiveTextureARB(GLenum e)
|
|
{
|
|
switch (e)
|
|
{
|
|
ecase (GL_TEXTURE0_ARB);
|
|
ecase (GL_TEXTURE1_ARB);
|
|
ecase (GL_TEXTURE2_ARB);
|
|
ecase (GL_TEXTURE3_ARB);
|
|
ecase (GL_TEXTURE4_ARB);
|
|
ecase (GL_TEXTURE5_ARB);
|
|
ecase (GL_TEXTURE6_ARB);
|
|
ecase (GL_TEXTURE7_ARB);
|
|
edefault (e);
|
|
}
|
|
}
|
|
|
|
void __stdcall lglAccum (GLenum Parm0, GLfloat Parm1)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %f)\n", "glAccum", senAccumOp(Parm0), Parm1);
|
|
tglAccum(Parm0, Parm1);
|
|
}
|
|
void __stdcall lglAlphaFunc (GLenum Parm0, GLclampf Parm1)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %.3f)\n", "glAlphaFunc", senAlphaFunction(Parm0), (float)Parm1);
|
|
tglAlphaFunc(Parm0, Parm1);
|
|
}
|
|
GLboolean __stdcall lglAreTexturesResident (GLsizei Parm0, const GLuint* Parm1, GLboolean* Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glAreTexturesResident");
|
|
return tglAreTexturesResident(Parm0, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglArrayElement (GLint Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (0x%x)\n", "glArrayElement", Parm0);
|
|
tglArrayElement(Parm0);
|
|
}
|
|
void __stdcall lglBegin (GLenum Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s)\n", "glBegin", senPolyType(Parm0));
|
|
tglBegin(Parm0);
|
|
}
|
|
void __stdcall lglBindTexture (GLenum Parm0, GLuint Parm1)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, 0x%x)\n", "glBindTexture", senTexTarg(Parm0), Parm1);
|
|
tglBindTexture(Parm0, Parm1);
|
|
}
|
|
void __stdcall lglBitmap (GLsizei Parm0, GLsizei Parm1, GLfloat Parm2, GLfloat Parm3, GLfloat Parm4, GLfloat Parm5, const GLubyte* Parm6)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glBitmap");
|
|
tglBitmap(Parm0, Parm1, Parm2, Parm3, Parm4, Parm5, Parm6);
|
|
}
|
|
void __stdcall lglBlendFunc (GLenum Parm0, GLenum Parm1)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %s)\n", "glBlendFunc", senBlendingFactor(Parm0), senBlendingFactor(Parm1));
|
|
tglBlendFunc(Parm0, Parm1);
|
|
}
|
|
void __stdcall lglCallList (GLuint Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (0x%x)\n", "glCallList", Parm0);
|
|
tglCallList(Parm0);
|
|
}
|
|
void __stdcall lglCallLists (GLsizei Parm0, GLenum Parm1, const GLvoid* Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glCallLists");
|
|
tglCallLists(Parm0, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglClear (GLbitfield Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (0x%x)\n", "glClear", Parm0);
|
|
tglClear(Parm0);
|
|
}
|
|
void __stdcall lglClearAccum (GLfloat Parm0, GLfloat Parm1, GLfloat Parm2, GLfloat Parm3)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%f, %f, %f, %f)\n", "glClearAccum", Parm0, Parm1, Parm2, Parm3);
|
|
tglClearAccum(Parm0, Parm1, Parm2, Parm3);
|
|
}
|
|
void __stdcall lglClearColor (GLclampf Parm0, GLclampf Parm1, GLclampf Parm2, GLclampf Parm3)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%f, %f, %f, %f)\n", "glClearColor", Parm0, Parm1, Parm2, Parm3);
|
|
tglClearColor(Parm0, Parm1, Parm2, Parm3);
|
|
}
|
|
void __stdcall lglClearDepth (GLclampd Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%.3f)\n", "glClearDepth", Parm0);
|
|
tglClearDepth(Parm0);
|
|
}
|
|
void __stdcall lglClearIndex (GLfloat Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glClearIndex");
|
|
tglClearIndex(Parm0);
|
|
}
|
|
void __stdcall lglClearStencil (GLint Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glClearStencil");
|
|
tglClearStencil(Parm0);
|
|
}
|
|
void __stdcall lglClipPlane (GLenum Parm0, const GLdouble* Parm1)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glClipPlane");
|
|
tglClipPlane(Parm0, Parm1);
|
|
}
|
|
void __stdcall lglColor3b (GLbyte Parm0, GLbyte Parm1, GLbyte Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor3b");
|
|
tglColor3b(Parm0, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglColor3bv (const GLbyte* Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor3bv");
|
|
tglColor3bv(Parm0);
|
|
}
|
|
void __stdcall lglColor3d (GLdouble Parm0, GLdouble Parm1, GLdouble Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor3d");
|
|
tglColor3d(Parm0, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglColor3dv (const GLdouble* Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor3dv");
|
|
tglColor3dv(Parm0);
|
|
}
|
|
void __stdcall lglColor3f (GLfloat Parm0, GLfloat Parm1, GLfloat Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%f, %f, %f)\n", "glColor3f", Parm0, Parm1, Parm2);
|
|
tglColor3f(Parm0, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglColor3fv (const GLfloat* Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor3fv");
|
|
tglColor3fv(Parm0);
|
|
}
|
|
void __stdcall lglColor3i (GLint Parm0, GLint Parm1, GLint Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor3i");
|
|
tglColor3i(Parm0, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglColor3iv (const GLint* Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor3iv");
|
|
tglColor3iv(Parm0);
|
|
}
|
|
void __stdcall lglColor3s (GLshort Parm0, GLshort Parm1, GLshort Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor3s");
|
|
tglColor3s(Parm0, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglColor3sv (const GLshort* Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor3sv");
|
|
tglColor3sv(Parm0);
|
|
}
|
|
void __stdcall lglColor3ub (GLubyte Parm0, GLubyte Parm1, GLubyte Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor3ub");
|
|
tglColor3ub(Parm0, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglColor3ubv (const GLubyte* Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor3ubv");
|
|
tglColor3ubv(Parm0);
|
|
}
|
|
void __stdcall lglColor3ui (GLuint Parm0, GLuint Parm1, GLuint Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor3ui");
|
|
tglColor3ui(Parm0, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglColor3uiv (const GLuint* Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor3uiv");
|
|
tglColor3uiv(Parm0);
|
|
}
|
|
void __stdcall lglColor3us (GLushort Parm0, GLushort Parm1, GLushort Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor3us");
|
|
tglColor3us(Parm0, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglColor3usv (const GLushort* Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor3usv");
|
|
tglColor3usv(Parm0);
|
|
}
|
|
void __stdcall lglColor4b (GLbyte Parm0, GLbyte Parm1, GLbyte Parm2, GLbyte Parm3)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor4b");
|
|
tglColor4b(Parm0, Parm1, Parm2, Parm3);
|
|
}
|
|
void __stdcall lglColor4bv (const GLbyte* Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor4bv");
|
|
tglColor4bv(Parm0);
|
|
}
|
|
void __stdcall lglColor4d (GLdouble Parm0, GLdouble Parm1, GLdouble Parm2, GLdouble Parm3)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor4d");
|
|
tglColor4d(Parm0, Parm1, Parm2, Parm3);
|
|
}
|
|
void __stdcall lglColor4dv (const GLdouble* Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor4dv");
|
|
tglColor4dv(Parm0);
|
|
}
|
|
void __stdcall lglColor4f (GLfloat Parm0, GLfloat Parm1, GLfloat Parm2, GLfloat Parm3)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%f, %f, %f, %f)\n", "glColor4f", Parm0, Parm1, Parm2, Parm3);
|
|
tglColor4f(Parm0, Parm1, Parm2, Parm3);
|
|
}
|
|
void __stdcall lglColor4fv (const GLfloat* Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor4fv");
|
|
tglColor4fv(Parm0);
|
|
}
|
|
void __stdcall lglColor4i (GLint Parm0, GLint Parm1, GLint Parm2, GLint Parm3)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor4i");
|
|
tglColor4i(Parm0, Parm1, Parm2, Parm3);
|
|
}
|
|
void __stdcall lglColor4iv (const GLint* Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor4iv");
|
|
tglColor4iv(Parm0);
|
|
}
|
|
void __stdcall lglColor4s (GLshort Parm0, GLshort Parm1, GLshort Parm2, GLshort Parm3)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor4s");
|
|
tglColor4s(Parm0, Parm1, Parm2, Parm3);
|
|
}
|
|
void __stdcall lglColor4sv (const GLshort* Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor4sv");
|
|
tglColor4sv(Parm0);
|
|
}
|
|
void __stdcall lglColor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor4ub");
|
|
tglColor4ub(red, green, blue, alpha);
|
|
}
|
|
void __stdcall lglColor4ubv (const GLubyte *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor4ubv");
|
|
tglColor4ubv(v);
|
|
}
|
|
void __stdcall lglColor4ui (GLuint red, GLuint green, GLuint blue, GLuint alpha)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor4ui");
|
|
tglColor4ui(red, green, blue, alpha);
|
|
}
|
|
void __stdcall lglColor4uiv (const GLuint *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor4uiv");
|
|
tglColor4uiv(v);
|
|
}
|
|
void __stdcall lglColor4us (GLushort red, GLushort green, GLushort blue, GLushort alpha)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor4us");
|
|
tglColor4us(red, green, blue, alpha);
|
|
}
|
|
void __stdcall lglColor4usv (const GLushort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColor4usv");
|
|
tglColor4usv(v);
|
|
}
|
|
void __stdcall lglColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d, %d, %d, %d)\n", "glColorMask", red, green, blue, alpha);
|
|
tglColorMask(red, green, blue, alpha);
|
|
}
|
|
void __stdcall lglColorMaterial (GLenum face, GLenum mode)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColorMaterial");
|
|
tglColorMaterial(face, mode);
|
|
}
|
|
void __stdcall lglColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d, %s, %d, 0x%x)\n", "glColorPointer", size, senDataType(type), stride, pointer);
|
|
tglColorPointer(size, type, stride, pointer);
|
|
}
|
|
void __stdcall lglCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glCopyPixels");
|
|
tglCopyPixels(x, y, width, height, type);
|
|
}
|
|
void __stdcall lglCopyTexImage1D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glCopyTexImage1D");
|
|
tglCopyTexImage1D(target, level, internalFormat, x, y, width, border);
|
|
}
|
|
void __stdcall lglCopyTexImage2D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glCopyTexImage2D");
|
|
tglCopyTexImage2D(target, level, internalFormat, x, y, width, height, border);
|
|
}
|
|
void __stdcall lglCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glCopyTexSubImage1D");
|
|
tglCopyTexSubImage1D(target, level, xoffset, x, y, width);
|
|
}
|
|
void __stdcall lglCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glCopyTexSubImage2D");
|
|
tglCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
|
|
}
|
|
void __stdcall lglCullFace (GLenum mode)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s)\n", "glCullFace", senCullFace(mode));
|
|
tglCullFace(mode);
|
|
}
|
|
void __stdcall lglDeleteLists (GLuint list, GLsizei range)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glDeleteLists");
|
|
tglDeleteLists(list, range);
|
|
}
|
|
void __stdcall lglDeleteTextures (GLsizei n, const GLuint *textures)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d, MEM)\n", "glDeleteTextures", n);
|
|
tglDeleteTextures(n, textures);
|
|
}
|
|
void __stdcall lglDepthFunc (GLenum func)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s)\n", "glDepthFunc", senAlphaFunction(func));
|
|
tglDepthFunc(func);
|
|
}
|
|
void __stdcall lglDepthMask (GLboolean flag)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d)\n", "glDepthMask", flag);
|
|
tglDepthMask(flag);
|
|
}
|
|
void __stdcall lglDepthRange (GLclampd zNear, GLclampd zFar)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%f, %f)\n", "glDepthRange", zNear, zFar);
|
|
tglDepthRange(zNear, zFar);
|
|
}
|
|
void __stdcall lglDisable (GLenum cap)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s)\n", "glDisable", senDisEn(cap));
|
|
tglDisable(cap);
|
|
}
|
|
void __stdcall lglDisableClientState (GLenum array)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s)\n", "glDisableClientState", senClientState(array));
|
|
tglDisableClientState(array);
|
|
}
|
|
void __stdcall lglDrawArrays (GLenum mode, GLint first, GLsizei count)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glDrawArrays");
|
|
tglDrawArrays(mode, first, count);
|
|
}
|
|
void __stdcall lglDrawBuffer (GLenum mode)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glDrawBuffer");
|
|
tglDrawBuffer(mode);
|
|
}
|
|
void __stdcall lglDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %d, %s, 0x%x)\n", "glDrawElements", senPolyType(mode), count, senDataType(type), indices);
|
|
tglDrawElements(mode, count, type, indices);
|
|
}
|
|
void __stdcall lglDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glDrawPixels");
|
|
tglDrawPixels(width, height, format, type, pixels);
|
|
}
|
|
void __stdcall lglEdgeFlag (GLboolean flag)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEdgeFlag");
|
|
tglEdgeFlag(flag);
|
|
}
|
|
void __stdcall lglEdgeFlagPointer (GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEdgeFlagPointer");
|
|
tglEdgeFlagPointer(stride, pointer);
|
|
}
|
|
void __stdcall lglEdgeFlagv (const GLboolean *flag)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEdgeFlagv");
|
|
tglEdgeFlagv(flag);
|
|
}
|
|
void __stdcall lglEnable (GLenum cap)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s)\n", "glEnable", senDisEn(cap));
|
|
tglEnable(cap);
|
|
}
|
|
void __stdcall lglEnableClientState (GLenum array)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s)\n", "glEnableClientState", senClientState(array));
|
|
tglEnableClientState(array);
|
|
}
|
|
void __stdcall lglEnd (void)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEnd");
|
|
tglEnd();
|
|
}
|
|
void __stdcall lglEndList (void)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEndList");
|
|
tglEndList();
|
|
}
|
|
void __stdcall lglEvalCoord1d (GLdouble u)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEvalCoord1d");
|
|
tglEvalCoord1d(u);
|
|
}
|
|
void __stdcall lglEvalCoord1dv (const GLdouble *u)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEvalCoord1dv");
|
|
tglEvalCoord1dv(u);
|
|
}
|
|
void __stdcall lglEvalCoord1f (GLfloat u)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEvalCoord1f");
|
|
tglEvalCoord1f(u);
|
|
}
|
|
void __stdcall lglEvalCoord1fv (const GLfloat *u)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEvalCoord1fv");
|
|
tglEvalCoord1fv(u);
|
|
}
|
|
void __stdcall lglEvalCoord2d (GLdouble u, GLdouble v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEvalCoord2d");
|
|
tglEvalCoord2d(u, v);
|
|
}
|
|
void __stdcall lglEvalCoord2dv (const GLdouble *u)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEvalCoord2dv");
|
|
tglEvalCoord2dv(u);
|
|
}
|
|
void __stdcall lglEvalCoord2f (GLfloat u, GLfloat v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEvalCoord2f");
|
|
tglEvalCoord2f(u, v);
|
|
}
|
|
void __stdcall lglEvalCoord2fv (const GLfloat *u)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEvalCoord2fv");
|
|
tglEvalCoord2fv(u);
|
|
}
|
|
void __stdcall lglEvalMesh1 (GLenum mode, GLint i1, GLint i2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEvalMesh1");
|
|
tglEvalMesh1(mode, i1, i2);
|
|
}
|
|
void __stdcall lglEvalMesh2 (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEvalMesh2");
|
|
tglEvalMesh2(mode, i1, i2, j1, j2);
|
|
}
|
|
void __stdcall lglEvalPoint1 (GLint i)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEvalPoint1");
|
|
tglEvalPoint1(i);
|
|
}
|
|
void __stdcall lglEvalPoint2 (GLint i, GLint j)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEvalPoint2");
|
|
tglEvalPoint2(i, j);
|
|
}
|
|
void __stdcall lglFeedbackBuffer (GLsizei size, GLenum type, GLfloat *buffer)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glFeedbackBuffer");
|
|
tglFeedbackBuffer(size, type, buffer);
|
|
}
|
|
void __stdcall lglFinish (void)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glFinish");
|
|
tglFinish();
|
|
}
|
|
void __stdcall lglFlush (void)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glFlush");
|
|
tglFlush();
|
|
}
|
|
void __stdcall lglFogf (GLenum pname, GLfloat param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %.3f)\n", "glFogf", senFog(pname), param);
|
|
tglFogf(pname, param);
|
|
}
|
|
void __stdcall lglFogfv (GLenum pname, const GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, [%.3f, %.3f, %.3f, %.3f])\n", "glFogfv", senFog(pname), params[0], params[1], params[2], params[3]);
|
|
tglFogfv(pname, params);
|
|
}
|
|
void __stdcall lglFogi (GLenum pname, GLint param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %d)\n", "glFogi", senFog(pname), param);
|
|
tglFogi(pname, param);
|
|
}
|
|
void __stdcall lglFogiv (GLenum pname, const GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glFogiv");
|
|
tglFogiv(pname, params);
|
|
}
|
|
void __stdcall lglFrontFace (GLenum mode)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glFrontFace");
|
|
tglFrontFace(mode);
|
|
}
|
|
void __stdcall lglFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glFrustum");
|
|
tglFrustum(left, right, bottom, top, zNear, zFar);
|
|
}
|
|
GLuint __stdcall lglGenLists (GLsizei range)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGenLists");
|
|
return tglGenLists(range);
|
|
}
|
|
void __stdcall lglGenTextures (GLsizei n, GLuint *textures)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGenTextures");
|
|
tglGenTextures(n, textures);
|
|
assert(textures[n-1]<14000);
|
|
}
|
|
void __stdcall lglGetBooleanv (GLenum pname, GLboolean *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetBooleanv");
|
|
tglGetBooleanv(pname, params);
|
|
}
|
|
void __stdcall lglGetClipPlane (GLenum plane, GLdouble *equation)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetClipPlane");
|
|
tglGetClipPlane(plane, equation);
|
|
}
|
|
void __stdcall lglGetDoublev (GLenum pname, GLdouble *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetDoublev");
|
|
tglGetDoublev(pname, params);
|
|
}
|
|
GLenum __stdcall lglGetError (void)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetError");
|
|
return tglGetError();
|
|
}
|
|
void __stdcall lglGetFloatv (GLenum pname, GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetFloatv");
|
|
tglGetFloatv(pname, params);
|
|
}
|
|
void __stdcall lglGetIntegerv (GLenum pname, GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetIntegerv");
|
|
tglGetIntegerv(pname, params);
|
|
}
|
|
void __stdcall lglGetLightfv (GLenum light, GLenum pname, GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetLightfv");
|
|
tglGetLightfv(light, pname, params);
|
|
}
|
|
void __stdcall lglGetLightiv (GLenum light, GLenum pname, GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetLightiv");
|
|
tglGetLightiv(light, pname, params);
|
|
}
|
|
void __stdcall lglGetMapdv (GLenum target, GLenum query, GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetMapdv");
|
|
tglGetMapdv(target, query, v);
|
|
}
|
|
void __stdcall lglGetMapfv (GLenum target, GLenum query, GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetMapfv");
|
|
tglGetMapfv(target, query, v);
|
|
}
|
|
void __stdcall lglGetMapiv (GLenum target, GLenum query, GLint *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetMapiv");
|
|
tglGetMapiv(target, query, v);
|
|
}
|
|
void __stdcall lglGetMaterialfv (GLenum face, GLenum pname, GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetMaterialfv");
|
|
tglGetMaterialfv(face, pname, params);
|
|
}
|
|
void __stdcall lglGetMaterialiv (GLenum face, GLenum pname, GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetMaterialiv");
|
|
tglGetMaterialiv(face, pname, params);
|
|
}
|
|
void __stdcall lglGetPixelMapfv (GLenum map, GLfloat *values)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetPixelMapfv");
|
|
tglGetPixelMapfv(map, values);
|
|
}
|
|
void __stdcall lglGetPixelMapuiv (GLenum map, GLuint *values)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetPixelMapuiv");
|
|
tglGetPixelMapuiv(map, values);
|
|
}
|
|
void __stdcall lglGetPixelMapusv (GLenum map, GLushort *values)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetPixelMapusv");
|
|
tglGetPixelMapusv(map, values);
|
|
}
|
|
void __stdcall lglGetPointerv (GLenum pname, GLvoid* *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetPointerv");
|
|
tglGetPointerv(pname, params);
|
|
}
|
|
void __stdcall lglGetPolygonStipple (GLubyte *mask)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetPolygonStipple");
|
|
tglGetPolygonStipple(mask);
|
|
}
|
|
const GLubyte * __stdcall lglGetString (GLenum name)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetString");
|
|
return tglGetString(name);
|
|
}
|
|
void __stdcall lglGetTexEnvfv (GLenum target, GLenum pname, GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetTexEnvfv");
|
|
tglGetTexEnvfv(target, pname, params);
|
|
}
|
|
void __stdcall lglGetTexEnviv (GLenum target, GLenum pname, GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetTexEnviv");
|
|
tglGetTexEnviv(target, pname, params);
|
|
}
|
|
void __stdcall lglGetTexGendv (GLenum coord, GLenum pname, GLdouble *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetTexGendv");
|
|
tglGetTexGendv(coord, pname, params);
|
|
}
|
|
void __stdcall lglGetTexGenfv (GLenum coord, GLenum pname, GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetTexGenfv");
|
|
tglGetTexGenfv(coord, pname, params);
|
|
}
|
|
void __stdcall lglGetTexGeniv (GLenum coord, GLenum pname, GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetTexGeniv");
|
|
tglGetTexGeniv(coord, pname, params);
|
|
}
|
|
void __stdcall lglGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetTexImage");
|
|
tglGetTexImage(target, level, format, type, pixels);
|
|
}
|
|
void __stdcall lglGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetTexLevelParameterfv");
|
|
tglGetTexLevelParameterfv(target, level, pname, params);
|
|
}
|
|
void __stdcall lglGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetTexLevelParameteriv");
|
|
tglGetTexLevelParameteriv(target, level, pname, params);
|
|
}
|
|
void __stdcall lglGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetTexParameterfv");
|
|
tglGetTexParameterfv(target, pname, params);
|
|
}
|
|
void __stdcall lglGetTexParameteriv (GLenum target, GLenum pname, GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetTexParameteriv");
|
|
tglGetTexParameteriv(target, pname, params);
|
|
}
|
|
void __stdcall lglHint (GLenum target, GLenum mode)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glHint");
|
|
tglHint(target, mode);
|
|
}
|
|
void __stdcall lglIndexMask (GLuint mask)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glIndexMask");
|
|
tglIndexMask(mask);
|
|
}
|
|
void __stdcall lglIndexPointer (GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glIndexPointer");
|
|
tglIndexPointer(type, stride, pointer);
|
|
}
|
|
void __stdcall lglIndexd (GLdouble c)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glIndexd");
|
|
tglIndexd(c);
|
|
}
|
|
void __stdcall lglIndexdv (const GLdouble *c)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glIndexdv");
|
|
tglIndexdv(c);
|
|
}
|
|
void __stdcall lglIndexf (GLfloat c)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glIndexf");
|
|
tglIndexf(c);
|
|
}
|
|
void __stdcall lglIndexfv (const GLfloat *c)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glIndexfv");
|
|
tglIndexfv(c);
|
|
}
|
|
void __stdcall lglIndexi (GLint c)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glIndexi");
|
|
tglIndexi(c);
|
|
}
|
|
void __stdcall lglIndexiv (const GLint *c)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glIndexiv");
|
|
tglIndexiv(c);
|
|
}
|
|
void __stdcall lglIndexs (GLshort c)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glIndexs");
|
|
tglIndexs(c);
|
|
}
|
|
void __stdcall lglIndexsv (const GLshort *c)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glIndexsv");
|
|
tglIndexsv(c);
|
|
}
|
|
void __stdcall lglIndexub (GLubyte c)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glIndexub");
|
|
tglIndexub(c);
|
|
}
|
|
void __stdcall lglIndexubv (const GLubyte *c)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glIndexubv");
|
|
tglIndexubv(c);
|
|
}
|
|
void __stdcall lglInitNames (void)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glInitNames");
|
|
tglInitNames();
|
|
}
|
|
void __stdcall lglInterleavedArrays (GLenum format, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glInterleavedArrays");
|
|
tglInterleavedArrays(format, stride, pointer);
|
|
}
|
|
GLboolean __stdcall lglIsEnabled (GLenum cap)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glIsEnabled");
|
|
return tglIsEnabled(cap);
|
|
}
|
|
GLboolean __stdcall lglIsList (GLuint list)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glIsList");
|
|
return tglIsList(list);
|
|
}
|
|
GLboolean __stdcall lglIsTexture (GLuint texture)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glIsTexture");
|
|
return tglIsTexture(texture);
|
|
}
|
|
void __stdcall lglLightModelf (GLenum pname, GLfloat param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glLightModelf");
|
|
tglLightModelf(pname, param);
|
|
}
|
|
void __stdcall lglLightModelfv (GLenum pname, const GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glLightModelfv");
|
|
tglLightModelfv(pname, params);
|
|
}
|
|
void __stdcall lglLightModeli (GLenum pname, GLint param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glLightModeli");
|
|
tglLightModeli(pname, param);
|
|
}
|
|
void __stdcall lglLightModeliv (GLenum pname, const GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glLightModeliv");
|
|
tglLightModeliv(pname, params);
|
|
}
|
|
void __stdcall lglLightf (GLenum light, GLenum pname, GLfloat param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d, %s, %.3f)\n", "glLightf", light-GL_LIGHT0, senLight(pname), param);
|
|
tglLightf(light, pname, param);
|
|
}
|
|
void __stdcall lglLightfv (GLenum light, GLenum pname, const GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d, %s, [%.3f %.3f %.3f %.3f])\n", "glLightfv", light-GL_LIGHT0, senLightv(pname), params[0], params[1], params[2], params[3]);
|
|
tglLightfv(light, pname, params);
|
|
}
|
|
void __stdcall lglLighti (GLenum light, GLenum pname, GLint param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glLighti");
|
|
tglLighti(light, pname, param);
|
|
}
|
|
void __stdcall lglLightiv (GLenum light, GLenum pname, const GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glLightiv");
|
|
tglLightiv(light, pname, params);
|
|
}
|
|
void __stdcall lglLineStipple (GLint factor, GLushort pattern)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glLineStipple");
|
|
tglLineStipple(factor, pattern);
|
|
}
|
|
void __stdcall lglLineWidth (GLfloat width)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glLineWidth");
|
|
tglLineWidth(width);
|
|
}
|
|
void __stdcall lglListBase (GLuint base)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glListBase");
|
|
tglListBase(base);
|
|
}
|
|
void __stdcall lglLoadIdentity (void)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glLoadIdentity");
|
|
tglLoadIdentity();
|
|
}
|
|
void __stdcall lglLoadMatrixd (const GLdouble *m)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glLoadMatrixd");
|
|
tglLoadMatrixd(m);
|
|
}
|
|
void __stdcall lglLoadMatrixf (const GLfloat *m)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glLoadMatrixf");
|
|
tglLoadMatrixf(m);
|
|
}
|
|
void __stdcall lglLoadName (GLuint name)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glLoadName");
|
|
tglLoadName(name);
|
|
}
|
|
void __stdcall lglLogicOp (GLenum opcode)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glLogicOp");
|
|
tglLogicOp(opcode);
|
|
}
|
|
void __stdcall lglMap1d (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMap1d");
|
|
tglMap1d(target, u1, u2, stride, order, points);
|
|
}
|
|
void __stdcall lglMap1f (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMap1f");
|
|
tglMap1f(target, u1, u2, stride, order, points);
|
|
}
|
|
void __stdcall lglMap2d (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMap2d");
|
|
tglMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
|
|
}
|
|
void __stdcall lglMap2f (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMap2f");
|
|
tglMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
|
|
}
|
|
void __stdcall lglMapGrid1d (GLint un, GLdouble u1, GLdouble u2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMapGrid1d");
|
|
tglMapGrid1d(un, u1, u2);
|
|
}
|
|
void __stdcall lglMapGrid1f (GLint un, GLfloat u1, GLfloat u2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMapGrid1f");
|
|
tglMapGrid1f(un, u1, u2);
|
|
}
|
|
void __stdcall lglMapGrid2d (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMapGrid2d");
|
|
tglMapGrid2d(un, u1, u2, vn, v1, v2);
|
|
}
|
|
void __stdcall lglMapGrid2f (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMapGrid2f");
|
|
tglMapGrid2f(un, u1, u2, vn, v1, v2);
|
|
}
|
|
void __stdcall lglMaterialf (GLenum face, GLenum pname, GLfloat param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %s, %.3f)\n", "glMaterialf", senFace(face), senMaterial(pname), param);
|
|
tglMaterialf(face, pname, param);
|
|
}
|
|
void __stdcall lglMaterialfv (GLenum face, GLenum pname, const GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %s, [%.3f %.3f %.3f %.3f])\n", "glMaterialfv", senFace(face), senMaterialv(pname), params[0], params[1], params[2], params[3]);
|
|
tglMaterialfv(face, pname, params);
|
|
}
|
|
void __stdcall lglMateriali (GLenum face, GLenum pname, GLint param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMateriali");
|
|
tglMateriali(face, pname, param);
|
|
}
|
|
void __stdcall lglMaterialiv (GLenum face, GLenum pname, const GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMaterialiv");
|
|
tglMaterialiv(face, pname, params);
|
|
}
|
|
void __stdcall lglMatrixMode (GLenum mode)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s)\n", "glMatrixMode", senMatrixMode(mode));
|
|
tglMatrixMode(mode);
|
|
}
|
|
void __stdcall lglMultMatrixd (const GLdouble *m)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMultMatrixd");
|
|
tglMultMatrixd(m);
|
|
}
|
|
void __stdcall lglMultMatrixf (const GLfloat *m)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMultMatrixf");
|
|
tglMultMatrixf(m);
|
|
}
|
|
void __stdcall lglNewList (GLuint list, GLenum mode)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d, %s)\n", "glNewList", list, senNewList(mode));
|
|
tglNewList(list, mode);
|
|
}
|
|
void __stdcall lglNormal3b (GLbyte nx, GLbyte ny, GLbyte nz)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glNormal3b");
|
|
tglNormal3b(nx, ny, nz);
|
|
}
|
|
void __stdcall lglNormal3bv (const GLbyte *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glNormal3bv");
|
|
tglNormal3bv(v);
|
|
}
|
|
void __stdcall lglNormal3d (GLdouble nx, GLdouble ny, GLdouble nz)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%f, %f, %f)\n", "glNormal3d", nx, ny, nz);
|
|
tglNormal3d(nx, ny, nz);
|
|
}
|
|
void __stdcall lglNormal3dv (const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glNormal3dv");
|
|
tglNormal3dv(v);
|
|
}
|
|
void __stdcall lglNormal3f (GLfloat nx, GLfloat ny, GLfloat nz)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%f, %f, %f)\n", "glNormal3f", nx, ny, nz);
|
|
tglNormal3f(nx, ny, nz);
|
|
}
|
|
void __stdcall lglNormal3fv (const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glNormal3fv");
|
|
tglNormal3fv(v);
|
|
}
|
|
void __stdcall lglNormal3i (GLint nx, GLint ny, GLint nz)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glNormal3i");
|
|
tglNormal3i(nx, ny, nz);
|
|
}
|
|
void __stdcall lglNormal3iv (const GLint *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glNormal3iv");
|
|
tglNormal3iv(v);
|
|
}
|
|
void __stdcall lglNormal3s (GLshort nx, GLshort ny, GLshort nz)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glNormal3s");
|
|
tglNormal3s(nx, ny, nz);
|
|
}
|
|
void __stdcall lglNormal3sv (const GLshort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glNormal3sv");
|
|
tglNormal3sv(v);
|
|
}
|
|
void __stdcall lglNormalPointer (GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %d, 0x%x)\n", "glNormalPointer", senDataType(type), stride, pointer);
|
|
tglNormalPointer(type, stride, pointer);
|
|
}
|
|
void __stdcall lglOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glOrtho");
|
|
tglOrtho(left, right, bottom, top, zNear, zFar);
|
|
}
|
|
void __stdcall lglPassThrough (GLfloat token)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPassThrough");
|
|
tglPassThrough(token);
|
|
}
|
|
void __stdcall lglPixelMapfv (GLenum map, GLsizei mapsize, const GLfloat *values)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPixelMapfv");
|
|
tglPixelMapfv(map, mapsize, values);
|
|
}
|
|
void __stdcall lglPixelMapuiv (GLenum map, GLsizei mapsize, const GLuint *values)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPixelMapuiv");
|
|
tglPixelMapuiv(map, mapsize, values);
|
|
}
|
|
void __stdcall lglPixelMapusv (GLenum map, GLsizei mapsize, const GLushort *values)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPixelMapusv");
|
|
tglPixelMapusv(map, mapsize, values);
|
|
}
|
|
void __stdcall lglPixelStoref (GLenum pname, GLfloat param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPixelStoref");
|
|
tglPixelStoref(pname, param);
|
|
}
|
|
void __stdcall lglPixelStorei (GLenum pname, GLint param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPixelStorei");
|
|
tglPixelStorei(pname, param);
|
|
}
|
|
void __stdcall lglPixelTransferf (GLenum pname, GLfloat param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPixelTransferf");
|
|
tglPixelTransferf(pname, param);
|
|
}
|
|
void __stdcall lglPixelTransferi (GLenum pname, GLint param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPixelTransferi");
|
|
tglPixelTransferi(pname, param);
|
|
}
|
|
void __stdcall lglPixelZoom (GLfloat xfactor, GLfloat yfactor)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPixelZoom");
|
|
tglPixelZoom(xfactor, yfactor);
|
|
}
|
|
void __stdcall lglPointSize (GLfloat size)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPointSize");
|
|
tglPointSize(size);
|
|
}
|
|
void __stdcall lglPolygonMode (GLenum face, GLenum mode)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPolygonMode");
|
|
tglPolygonMode(face, mode);
|
|
}
|
|
void __stdcall lglPolygonOffset (GLfloat factor, GLfloat units)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%f, %f)\n", "glPolygonOffset", factor, units);
|
|
tglPolygonOffset(factor, units);
|
|
}
|
|
void __stdcall lglPolygonStipple (const GLubyte *mask)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPolygonStipple");
|
|
tglPolygonStipple(mask);
|
|
}
|
|
void __stdcall lglPopAttrib (void)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPopAttrib");
|
|
tglPopAttrib();
|
|
}
|
|
void __stdcall lglPopClientAttrib (void)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPopClientAttrib");
|
|
tglPopClientAttrib();
|
|
}
|
|
void __stdcall lglPopMatrix (void)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPopMatrix");
|
|
tglPopMatrix();
|
|
}
|
|
void __stdcall lglPopName (void)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPopName");
|
|
tglPopName();
|
|
}
|
|
void __stdcall lglPrioritizeTextures (GLsizei n, const GLuint *textures, const GLclampf *priorities)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPrioritizeTextures");
|
|
tglPrioritizeTextures(n, textures, priorities);
|
|
}
|
|
void __stdcall lglPushAttrib (GLbitfield mask)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPushAttrib");
|
|
tglPushAttrib(mask);
|
|
}
|
|
void __stdcall lglPushClientAttrib (GLbitfield mask)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPushClientAttrib");
|
|
tglPushClientAttrib(mask);
|
|
}
|
|
void __stdcall lglPushMatrix (void)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPushMatrix");
|
|
tglPushMatrix();
|
|
}
|
|
void __stdcall lglPushName (GLuint name)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPushName");
|
|
tglPushName(name);
|
|
}
|
|
void __stdcall lglRasterPos2d (GLdouble x, GLdouble y)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos2d");
|
|
tglRasterPos2d(x, y);
|
|
}
|
|
void __stdcall lglRasterPos2dv (const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos2dv");
|
|
tglRasterPos2dv(v);
|
|
}
|
|
void __stdcall lglRasterPos2f (GLfloat x, GLfloat y)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos2f");
|
|
tglRasterPos2f(x, y);
|
|
}
|
|
void __stdcall lglRasterPos2fv (const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos2fv");
|
|
tglRasterPos2fv(v);
|
|
}
|
|
void __stdcall lglRasterPos2i (GLint x, GLint y)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos2i");
|
|
tglRasterPos2i(x, y);
|
|
}
|
|
void __stdcall lglRasterPos2iv (const GLint *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos2iv");
|
|
tglRasterPos2iv(v);
|
|
}
|
|
void __stdcall lglRasterPos2s (GLshort x, GLshort y)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos2s");
|
|
tglRasterPos2s(x, y);
|
|
}
|
|
void __stdcall lglRasterPos2sv (const GLshort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos2sv");
|
|
tglRasterPos2sv(v);
|
|
}
|
|
void __stdcall lglRasterPos3d (GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos3d");
|
|
tglRasterPos3d(x, y, z);
|
|
}
|
|
void __stdcall lglRasterPos3dv (const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos3dv");
|
|
tglRasterPos3dv(v);
|
|
}
|
|
void __stdcall lglRasterPos3f (GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos3f");
|
|
tglRasterPos3f(x, y, z);
|
|
}
|
|
void __stdcall lglRasterPos3fv (const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos3fv");
|
|
tglRasterPos3fv(v);
|
|
}
|
|
void __stdcall lglRasterPos3i (GLint x, GLint y, GLint z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos3i");
|
|
tglRasterPos3i(x, y, z);
|
|
}
|
|
void __stdcall lglRasterPos3iv (const GLint *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos3iv");
|
|
tglRasterPos3iv(v);
|
|
}
|
|
void __stdcall lglRasterPos3s (GLshort x, GLshort y, GLshort z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos3s");
|
|
tglRasterPos3s(x, y, z);
|
|
}
|
|
void __stdcall lglRasterPos3sv (const GLshort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos3sv");
|
|
tglRasterPos3sv(v);
|
|
}
|
|
void __stdcall lglRasterPos4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos4d");
|
|
tglRasterPos4d(x, y, z, w);
|
|
}
|
|
void __stdcall lglRasterPos4dv (const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos4dv");
|
|
tglRasterPos4dv(v);
|
|
}
|
|
void __stdcall lglRasterPos4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos4f");
|
|
tglRasterPos4f(x, y, z, w);
|
|
}
|
|
void __stdcall lglRasterPos4fv (const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos4fv");
|
|
tglRasterPos4fv(v);
|
|
}
|
|
void __stdcall lglRasterPos4i (GLint x, GLint y, GLint z, GLint w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos4i");
|
|
tglRasterPos4i(x, y, z, w);
|
|
}
|
|
void __stdcall lglRasterPos4iv (const GLint *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos4iv");
|
|
tglRasterPos4iv(v);
|
|
}
|
|
void __stdcall lglRasterPos4s (GLshort x, GLshort y, GLshort z, GLshort w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos4s");
|
|
tglRasterPos4s(x, y, z, w);
|
|
}
|
|
void __stdcall lglRasterPos4sv (const GLshort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRasterPos4sv");
|
|
tglRasterPos4sv(v);
|
|
}
|
|
void __stdcall lglReadBuffer (GLenum mode)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glReadBuffer");
|
|
tglReadBuffer(mode);
|
|
}
|
|
void __stdcall lglReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glReadPixels");
|
|
tglReadPixels(x, y, width, height, format, type, pixels);
|
|
}
|
|
void __stdcall lglRectd (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRectd");
|
|
tglRectd(x1, y1, x2, y2);
|
|
}
|
|
void __stdcall lglRectdv (const GLdouble *v1, const GLdouble *v2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRectdv");
|
|
tglRectdv(v1, v2);
|
|
}
|
|
void __stdcall lglRectf (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRectf");
|
|
tglRectf(x1, y1, x2, y2);
|
|
}
|
|
void __stdcall lglRectfv (const GLfloat *v1, const GLfloat *v2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRectfv");
|
|
tglRectfv(v1, v2);
|
|
}
|
|
void __stdcall lglRecti (GLint x1, GLint y1, GLint x2, GLint y2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRecti");
|
|
tglRecti(x1, y1, x2, y2);
|
|
}
|
|
void __stdcall lglRectiv (const GLint *v1, const GLint *v2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRectiv");
|
|
tglRectiv(v1, v2);
|
|
}
|
|
void __stdcall lglRects (GLshort x1, GLshort y1, GLshort x2, GLshort y2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRects");
|
|
tglRects(x1, y1, x2, y2);
|
|
}
|
|
void __stdcall lglRectsv (const GLshort *v1, const GLshort *v2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRectsv");
|
|
tglRectsv(v1, v2);
|
|
}
|
|
GLint __stdcall lglRenderMode (GLenum mode)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRenderMode");
|
|
return tglRenderMode(mode);
|
|
}
|
|
void __stdcall lglRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRotated");
|
|
tglRotated(angle, x, y, z);
|
|
}
|
|
void __stdcall lglRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRotatef");
|
|
tglRotatef(angle, x, y, z);
|
|
}
|
|
void __stdcall lglScaled (GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%f, %f, %f)\n", "glScaled", x, y, z);
|
|
tglScaled(x, y, z);
|
|
}
|
|
void __stdcall lglScalef (GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%f, %f, %f)\n", "glScalef", x, y, z);
|
|
tglScalef(x, y, z);
|
|
}
|
|
void __stdcall lglScissor (GLint x, GLint y, GLsizei width, GLsizei height)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d, %d, %d, %d)\n", "glScissor", x, y, width, height);
|
|
tglScissor(x, y, width, height);
|
|
}
|
|
void __stdcall lglSelectBuffer (GLsizei size, GLuint *buffer)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSelectBuffer");
|
|
tglSelectBuffer(size, buffer);
|
|
}
|
|
void __stdcall lglShadeModel (GLenum mode)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glShadeModel");
|
|
tglShadeModel(mode);
|
|
}
|
|
void __stdcall lglStencilFunc (GLenum func, GLint ref, GLuint mask)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %d, 0x%x)\n", "glStencilFunc", senStencilFunc(func), ref, mask);
|
|
tglStencilFunc(func, ref, mask);
|
|
}
|
|
void __stdcall lglStencilMask (GLuint mask)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (0x%x)\n", "glStencilMask", mask);
|
|
tglStencilMask(mask);
|
|
}
|
|
void __stdcall lglStencilOp (GLenum fail, GLenum zfail, GLenum zpass)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %s, %s)\n", "glStencilOp", senStencilOp(fail), senStencilOp(zfail), senStencilOp(zpass));
|
|
tglStencilOp(fail, zfail, zpass);
|
|
}
|
|
void __stdcall lglTexCoord1d (GLdouble s)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord1d");
|
|
tglTexCoord1d(s);
|
|
}
|
|
void __stdcall lglTexCoord1dv (const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord1dv");
|
|
tglTexCoord1dv(v);
|
|
}
|
|
void __stdcall lglTexCoord1f (GLfloat s)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord1f");
|
|
tglTexCoord1f(s);
|
|
}
|
|
void __stdcall lglTexCoord1fv (const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord1fv");
|
|
tglTexCoord1fv(v);
|
|
}
|
|
void __stdcall lglTexCoord1i (GLint s)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord1i");
|
|
tglTexCoord1i(s);
|
|
}
|
|
void __stdcall lglTexCoord1iv (const GLint *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord1iv");
|
|
tglTexCoord1iv(v);
|
|
}
|
|
void __stdcall lglTexCoord1s (GLshort s)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord1s");
|
|
tglTexCoord1s(s);
|
|
}
|
|
void __stdcall lglTexCoord1sv (const GLshort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord1sv");
|
|
tglTexCoord1sv(v);
|
|
}
|
|
void __stdcall lglTexCoord2d (GLdouble s, GLdouble t)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord2d");
|
|
tglTexCoord2d(s, t);
|
|
}
|
|
void __stdcall lglTexCoord2dv (const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord2dv");
|
|
tglTexCoord2dv(v);
|
|
}
|
|
void __stdcall lglTexCoord2f (GLfloat s, GLfloat t)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%f, %f)\n", "glTexCoord2f", s, t);
|
|
tglTexCoord2f(s, t);
|
|
}
|
|
void __stdcall lglTexCoord2fv (const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord2fv");
|
|
tglTexCoord2fv(v);
|
|
}
|
|
void __stdcall lglTexCoord2i (GLint s, GLint t)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord2i");
|
|
tglTexCoord2i(s, t);
|
|
}
|
|
void __stdcall lglTexCoord2iv (const GLint *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord2iv");
|
|
tglTexCoord2iv(v);
|
|
}
|
|
void __stdcall lglTexCoord2s (GLshort s, GLshort t)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord2s");
|
|
tglTexCoord2s(s, t);
|
|
}
|
|
void __stdcall lglTexCoord2sv (const GLshort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord2sv");
|
|
tglTexCoord2sv(v);
|
|
}
|
|
void __stdcall lglTexCoord3d (GLdouble s, GLdouble t, GLdouble r)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord3d");
|
|
tglTexCoord3d(s, t, r);
|
|
}
|
|
void __stdcall lglTexCoord3dv (const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord3dv");
|
|
tglTexCoord3dv(v);
|
|
}
|
|
void __stdcall lglTexCoord3f (GLfloat s, GLfloat t, GLfloat r)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord3f");
|
|
tglTexCoord3f(s, t, r);
|
|
}
|
|
void __stdcall lglTexCoord3fv (const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord3fv");
|
|
tglTexCoord3fv(v);
|
|
}
|
|
void __stdcall lglTexCoord3i (GLint s, GLint t, GLint r)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord3i");
|
|
tglTexCoord3i(s, t, r);
|
|
}
|
|
void __stdcall lglTexCoord3iv (const GLint *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord3iv");
|
|
tglTexCoord3iv(v);
|
|
}
|
|
void __stdcall lglTexCoord3s (GLshort s, GLshort t, GLshort r)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord3s");
|
|
tglTexCoord3s(s, t, r);
|
|
}
|
|
void __stdcall lglTexCoord3sv (const GLshort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord3sv");
|
|
tglTexCoord3sv(v);
|
|
}
|
|
void __stdcall lglTexCoord4d (GLdouble s, GLdouble t, GLdouble r, GLdouble q)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord4d");
|
|
tglTexCoord4d(s, t, r, q);
|
|
}
|
|
void __stdcall lglTexCoord4dv (const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord4dv");
|
|
tglTexCoord4dv(v);
|
|
}
|
|
void __stdcall lglTexCoord4f (GLfloat s, GLfloat t, GLfloat r, GLfloat q)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord4f");
|
|
tglTexCoord4f(s, t, r, q);
|
|
}
|
|
void __stdcall lglTexCoord4fv (const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord4fv");
|
|
tglTexCoord4fv(v);
|
|
}
|
|
void __stdcall lglTexCoord4i (GLint s, GLint t, GLint r, GLint q)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord4i");
|
|
tglTexCoord4i(s, t, r, q);
|
|
}
|
|
void __stdcall lglTexCoord4iv (const GLint *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord4iv");
|
|
tglTexCoord4iv(v);
|
|
}
|
|
void __stdcall lglTexCoord4s (GLshort s, GLshort t, GLshort r, GLshort q)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord4s");
|
|
tglTexCoord4s(s, t, r, q);
|
|
}
|
|
void __stdcall lglTexCoord4sv (const GLshort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexCoord4sv");
|
|
tglTexCoord4sv(v);
|
|
}
|
|
void __stdcall lglTexCoordPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d, %s, %d, 0x%x)\n", "glTexCoordPointer", size, senDataType(type), stride, pointer);
|
|
tglTexCoordPointer(size, type, stride, pointer);
|
|
}
|
|
void __stdcall lglTexEnvf (GLenum target, GLenum pname, GLfloat param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %s, %s)\n", "glTexEnvf", senTextureEnvTarget(target), senTextureEnvPName(pname), senTextureEnvParam((int)param));
|
|
tglTexEnvf(target, pname, param);
|
|
}
|
|
void __stdcall lglTexEnvfv (GLenum target, GLenum pname, const GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %s, (%.3f, %.3f, %.3f, %.3f))\n", "glTexEnvfv", senTextureEnvTarget(target), senTextureEnvfPName(pname), params[0], params[1], params[2], params[3]);
|
|
tglTexEnvfv(target, pname, params);
|
|
}
|
|
void __stdcall lglTexEnvi (GLenum target, GLenum pname, GLint param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %s, %s)\n", "glTexEnvi", senTextureEnvTarget(target), senTextureEnvPName(pname), senTextureEnvParam(param));
|
|
tglTexEnvi(target, pname, param);
|
|
}
|
|
void __stdcall lglTexEnviv (GLenum target, GLenum pname, const GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %s, (%i, %i, %i, %i))\n", "glTexEnviv", senTextureEnvTarget(target), senTextureEnvfPName(pname), params[0], params[1], params[2], params[3]);
|
|
tglTexEnviv(target, pname, params);
|
|
}
|
|
void __stdcall lglTexGend (GLenum coord, GLenum pname, GLdouble param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexGend");
|
|
tglTexGend(coord, pname, param);
|
|
}
|
|
void __stdcall lglTexGendv (GLenum coord, GLenum pname, const GLdouble *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexGendv");
|
|
tglTexGendv(coord, pname, params);
|
|
}
|
|
void __stdcall lglTexGenf (GLenum coord, GLenum pname, GLfloat param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexGenf");
|
|
tglTexGenf(coord, pname, param);
|
|
}
|
|
void __stdcall lglTexGenfv (GLenum coord, GLenum pname, const GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexGenfv");
|
|
tglTexGenfv(coord, pname, params);
|
|
}
|
|
void __stdcall lglTexGeni (GLenum coord, GLenum pname, GLint param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexGeni");
|
|
tglTexGeni(coord, pname, param);
|
|
}
|
|
void __stdcall lglTexGeniv (GLenum coord, GLenum pname, const GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexGeniv");
|
|
tglTexGeniv(coord, pname, params);
|
|
}
|
|
void __stdcall lglTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexImage1D");
|
|
tglTexImage1D(target, level, internalformat, width, border, format, type, pixels);
|
|
}
|
|
void __stdcall lglTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %d, %s, %d, %d, %d, %s, %s, 0x%x)\n", "glTexImage2D", senTexTarg(target), level, senTexFormat(internalformat), width, height, border, senTexFormat(format), senTexDataType(type), pixels);
|
|
tglTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
|
|
}
|
|
void __stdcall lglTexParameterf (GLenum target, GLenum pname, GLfloat param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %s, %.3f)\n", "glTexParameterf", senTexTarg(target), senTexParmName(pname), param);
|
|
tglTexParameterf(target, pname, param);
|
|
}
|
|
void __stdcall lglTexParameterfv (GLenum target, GLenum pname, const GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexParameterfv");
|
|
tglTexParameterfv(target, pname, params);
|
|
}
|
|
void __stdcall lglTexParameteri (GLenum target, GLenum pname, GLint param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %s, %s)\n", "glTexParameteri", senTexTarg(target), senTexParmName(pname), senTexParm(param));
|
|
tglTexParameteri(target, pname, param);
|
|
}
|
|
void __stdcall lglTexParameteriv (GLenum target, GLenum pname, const GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexParameteriv");
|
|
tglTexParameteriv(target, pname, params);
|
|
}
|
|
void __stdcall lglTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexSubImage1D");
|
|
tglTexSubImage1D(target, level, xoffset, width, format, type, pixels);
|
|
}
|
|
void __stdcall lglTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexSubImage2D");
|
|
tglTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
|
|
}
|
|
void __stdcall lglTranslated (GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTranslated");
|
|
tglTranslated(x, y, z);
|
|
}
|
|
void __stdcall lglTranslatef (GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTranslatef");
|
|
tglTranslatef(x, y, z);
|
|
}
|
|
void __stdcall lglVertex2d (GLdouble x, GLdouble y)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex2d");
|
|
tglVertex2d(x, y);
|
|
}
|
|
void __stdcall lglVertex2dv (const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex2dv");
|
|
tglVertex2dv(v);
|
|
}
|
|
void __stdcall lglVertex2f (GLfloat x, GLfloat y)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex2f");
|
|
tglVertex2f(x, y);
|
|
}
|
|
void __stdcall lglVertex2fv (const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex2fv");
|
|
tglVertex2fv(v);
|
|
}
|
|
void __stdcall lglVertex2i (GLint x, GLint y)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex2i");
|
|
tglVertex2i(x, y);
|
|
}
|
|
void __stdcall lglVertex2iv (const GLint *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex2iv");
|
|
tglVertex2iv(v);
|
|
}
|
|
void __stdcall lglVertex2s (GLshort x, GLshort y)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex2s");
|
|
tglVertex2s(x, y);
|
|
}
|
|
void __stdcall lglVertex2sv (const GLshort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex2sv");
|
|
tglVertex2sv(v);
|
|
}
|
|
void __stdcall lglVertex3d (GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex3d");
|
|
tglVertex3d(x, y, z);
|
|
}
|
|
void __stdcall lglVertex3dv (const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex3dv");
|
|
tglVertex3dv(v);
|
|
}
|
|
void __stdcall lglVertex3f (GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex3f");
|
|
tglVertex3f(x, y, z);
|
|
}
|
|
void __stdcall lglVertex3fv (const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex3fv");
|
|
tglVertex3fv(v);
|
|
}
|
|
void __stdcall lglVertex3i (GLint x, GLint y, GLint z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex3i");
|
|
tglVertex3i(x, y, z);
|
|
}
|
|
void __stdcall lglVertex3iv (const GLint *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex3iv");
|
|
tglVertex3iv(v);
|
|
}
|
|
void __stdcall lglVertex3s (GLshort x, GLshort y, GLshort z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex3s");
|
|
tglVertex3s(x, y, z);
|
|
}
|
|
void __stdcall lglVertex3sv (const GLshort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex3sv");
|
|
tglVertex3sv(v);
|
|
}
|
|
void __stdcall lglVertex4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex4d");
|
|
tglVertex4d(x, y, z, w);
|
|
}
|
|
void __stdcall lglVertex4dv (const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex4dv");
|
|
tglVertex4dv(v);
|
|
}
|
|
void __stdcall lglVertex4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex4f");
|
|
tglVertex4f(x, y, z, w);
|
|
}
|
|
void __stdcall lglVertex4fv (const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex4fv");
|
|
tglVertex4fv(v);
|
|
}
|
|
void __stdcall lglVertex4i (GLint x, GLint y, GLint z, GLint w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex4i");
|
|
tglVertex4i(x, y, z, w);
|
|
}
|
|
void __stdcall lglVertex4iv (const GLint *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex4iv");
|
|
tglVertex4iv(v);
|
|
}
|
|
void __stdcall lglVertex4s (GLshort x, GLshort y, GLshort z, GLshort w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex4s");
|
|
tglVertex4s(x, y, z, w);
|
|
}
|
|
void __stdcall lglVertex4sv (const GLshort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertex4sv");
|
|
tglVertex4sv(v);
|
|
}
|
|
void __stdcall lglVertexPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d, %s, %d, 0x%x)\n", "glVertexPointer", size, senDataType(type), stride, pointer);
|
|
tglVertexPointer(size, type, stride, pointer);
|
|
}
|
|
void __stdcall lglViewport (GLint x, GLint y, GLsizei width, GLsizei height)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d, %d, %d, %d)\n", "glViewport", x, y, width, height);
|
|
tglViewport(x, y, width, height);
|
|
}
|
|
BOOL __stdcall lpwglCopyContext (HGLRC Parm0, HGLRC Parm1, UINT Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglCopyContext");
|
|
return tpwglCopyContext(Parm0, Parm1, Parm2);
|
|
}
|
|
HGLRC __stdcall lpwglCreateContext (HDC Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglCreateContext");
|
|
return tpwglCreateContext(Parm0);
|
|
}
|
|
HGLRC __stdcall lpwglCreateLayerContext (HGLRC Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglCreateLayerContext");
|
|
return tpwglCreateLayerContext(Parm0);
|
|
}
|
|
BOOL __stdcall lpwglDeleteContext (HGLRC Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglDeleteContext");
|
|
return tpwglDeleteContext(Parm0);
|
|
}
|
|
HGLRC __stdcall lpwglGetCurrentContext (VOID)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglGetCurrentContext");
|
|
return tpwglGetCurrentContext();
|
|
}
|
|
HDC __stdcall lpwglGetCurrentDC (VOID)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglGetCurrentDC");
|
|
return tpwglGetCurrentDC();
|
|
}
|
|
PROC __stdcall lpwglGetProcAddress (LPCSTR Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglGetProcAddress");
|
|
return tpwglGetProcAddress(Parm0);
|
|
}
|
|
BOOL __stdcall lpwglMakeCurrent (HDC Parm0, HGLRC Parm1)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglMakeCurrent");
|
|
return tpwglMakeCurrent(Parm0, Parm1);
|
|
}
|
|
BOOL __stdcall lpwglShareLists (HGLRC Parm0, HGLRC Parm1)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglShareLists");
|
|
return tpwglShareLists(Parm0, Parm1);
|
|
}
|
|
INT __stdcall lpwglChoosePixelFormat (HDC hDC, CONST PIXELFORMATDESCRIPTOR* pfd)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglChoosePixelFormat");
|
|
return tpwglChoosePixelFormat(hDC, pfd);
|
|
}
|
|
INT __stdcall lpwglDescribePixelFormat (HDC Parm0, INT Parm1, UINT Parm2, PIXELFORMATDESCRIPTOR* Parm3)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglDescribePixelFormat");
|
|
return tpwglDescribePixelFormat(Parm0, Parm1, Parm2, Parm3);
|
|
}
|
|
BOOL __stdcall lpwglSetPixelFormat (HDC Parm0, INT Parm1, CONST PIXELFORMATDESCRIPTOR* Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglSetPixelFormat");
|
|
return tpwglSetPixelFormat(Parm0, Parm1, Parm2);
|
|
}
|
|
BOOL __stdcall lpwglSwapBuffers (HDC hDC)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglSwapBuffers");
|
|
return tpwglSwapBuffers(hDC);
|
|
}
|
|
BOOL __stdcall lwglBindTexImageARB (HPBUFFERARB hPbuffer, int iBuffer)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglBindTexImageARB");
|
|
return twglBindTexImageARB(hPbuffer, iBuffer);
|
|
}
|
|
BOOL __stdcall lwglReleaseTexImageARB (HPBUFFERARB hPbuffer, int iBuffer)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglReleaseTexImageARB");
|
|
return twglReleaseTexImageARB(hPbuffer, iBuffer);
|
|
}
|
|
void __stdcall lglSampleCoverageARB(GLclampf p0, GLboolean p1)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSampleCoverageARB");
|
|
tglSampleCoverageARB(p0, p1);
|
|
}
|
|
/*void __stdcall lglSamplePassARB(GLenum p0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSamplePassARB");
|
|
tglSamplePassARB(p0);
|
|
}*/
|
|
HANDLE __stdcall lwglCreateBufferRegionARB (HDC hDC, int a, UINT b)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglCreateBufferRegionARB");
|
|
return twglCreateBufferRegionARB(hDC, a, b);
|
|
}
|
|
void __stdcall lwglDeleteBufferRegionARB (HANDLE a)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglDeleteBufferRegionARB");
|
|
twglDeleteBufferRegionARB(a);
|
|
}
|
|
BOOL __stdcall lwglSaveBufferRegionARB (HANDLE a, int b, int c, int d, int e)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglSaveBufferRegionARB");
|
|
return twglSaveBufferRegionARB(a,b,c,d,e);
|
|
}
|
|
BOOL __stdcall lwglRestoreBufferRegionARB (HANDLE a, int b, int c, int d, int e, int f, int g)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglRestoreBufferRegionARB");
|
|
return twglRestoreBufferRegionARB(a,b,c,d,e,f,g);
|
|
}
|
|
void __stdcall lglTexImage3DEXT (GLenum a, GLint b, GLenum c, GLsizei d, GLsizei e, GLsizei f, GLint g, GLenum h, GLenum i, const GLvoid *j)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexImage3DEXT");
|
|
tglTexImage3DEXT(a,b,c,d,e,f,g,h,i,j);
|
|
}
|
|
void __stdcall lglTexSubImage3DEXT (GLenum a, GLint b, GLint c, GLint d, GLint e, GLsizei f, GLsizei g, GLsizei h, GLenum i, GLenum j, const GLvoid *k)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTexSubImage3DEXT");
|
|
tglTexSubImage3DEXT(a,b,c,d,e,f,g,h,i,j,k);
|
|
}
|
|
void __stdcall lglFogCoordPointerEXT (GLenum a, GLsizei b, const GLvoid *c)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glFogCoordPointerEXT");
|
|
tglFogCoordPointerEXT(a,b,c);
|
|
}
|
|
void __stdcall lglFogCoordfEXT (GLfloat a)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glFogCoordfEXT");
|
|
tglFogCoordfEXT(a);
|
|
}
|
|
void __stdcall lglDrawRangeElementsEXT (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glDrawRangeElementsEXT");
|
|
tglDrawRangeElementsEXT(mode,start,end,count,type,indices);
|
|
}
|
|
INT __stdcall lpChoosePixelFormat (HDC hDC, CONST PIXELFORMATDESCRIPTOR* pfd)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "ChoosePixelFormat");
|
|
return tpChoosePixelFormat(hDC, pfd);
|
|
}
|
|
INT __stdcall lpDescribePixelFormat (HDC Parm0, INT Parm1, UINT Parm2, PIXELFORMATDESCRIPTOR* Parm3)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "DescribePixelFormat");
|
|
return tpDescribePixelFormat(Parm0, Parm1, Parm2, Parm3);
|
|
}
|
|
BOOL __stdcall lpGetPixelFormat (HDC Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "GetPixelFormat");
|
|
return tpGetPixelFormat(Parm0);
|
|
}
|
|
BOOL __stdcall lpSetPixelFormat (HDC Parm0, INT Parm1, CONST PIXELFORMATDESCRIPTOR* pfd)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "SetPixelFormat");
|
|
return tpSetPixelFormat(Parm0, Parm1, pfd);
|
|
}
|
|
BOOL __stdcall lpSwapBuffers (HDC hDC)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "SwapBuffers");
|
|
return tpSwapBuffers(hDC);
|
|
}
|
|
void __stdcall lglColorTableEXT (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const void *data)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColorTableEXT");
|
|
tglColorTableEXT(target, internalFormat, width, format, type, data);
|
|
}
|
|
void __stdcall lglColorSubTableEXT (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColorSubTableEXT");
|
|
tglColorSubTableEXT(target, start, count, format, type, data);
|
|
}
|
|
void __stdcall lglGetColorTableEXT (GLenum target, GLenum format, GLenum type, void *data)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetColorTableEXT");
|
|
tglGetColorTableEXT(target, format, type, data);
|
|
}
|
|
void __stdcall lglGetColorTableParameterivEXT (GLenum target, GLenum pname, int *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetColorTableParameterivEXT");
|
|
tglGetColorTableParameterivEXT(target, pname, params);
|
|
}
|
|
void __stdcall lglGetColorTableParameterfvEXT (GLenum target, GLenum pname, float *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetColorTableParameterfvEXT");
|
|
tglGetColorTableParameterfvEXT(target, pname, params);
|
|
}
|
|
void __stdcall lglCompressedTexImage3DARB (GLenum Parm0, GLint Parm1, GLenum Parm2, GLsizei Parm3, GLsizei Parm4, GLsizei Parm5, GLint Parm6, GLsizei Parm7, const GLvoid * Parm8)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glCompressedTexImage3DARB");
|
|
tglCompressedTexImage3DARB(Parm0, Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, Parm7, Parm8);
|
|
}
|
|
void __stdcall lglCompressedTexImage2DARB (GLenum Parm0, GLint Parm1, GLenum Parm2, GLsizei Parm3, GLsizei Parm4, GLint Parm5, GLsizei Parm6, const GLvoid *Parm7)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %d, %s, %d, %d, %d, %d, 0x%x)\n", "glCompressedTexImage2DARB", senTexTarg(Parm0), Parm1, senTexFormat(Parm2), Parm3, Parm4, Parm5, Parm6, Parm7);
|
|
tglCompressedTexImage2DARB(Parm0, Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, Parm7);
|
|
}
|
|
void __stdcall lglCompressedTexImage1DARB (GLenum Parm0, GLint Parm1, GLenum Parm2, GLsizei Parm3, GLint Parm4, GLsizei Parm5, const GLvoid *Parm6)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glCompressedTexImage1DARB");
|
|
tglCompressedTexImage1DARB(Parm0, Parm1, Parm2, Parm3, Parm4, Parm5, Parm6);
|
|
}
|
|
void __stdcall lglCompressedTexSubImage3DARB (GLenum Parm0, GLint Parm1, GLint Parm2, GLint Parm3, GLint Parm4, GLsizei Parm5, GLsizei Parm6, GLsizei Parm7, GLenum Parm8, GLsizei Parm9, const GLvoid *Parm10)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glCompressedTexSubImage3DARB");
|
|
tglCompressedTexSubImage3DARB(Parm0, Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, Parm7, Parm8, Parm9, Parm10);
|
|
}
|
|
void __stdcall lglCompressedTexSubImage2DARB (GLenum Parm0, GLint Parm1, GLint Parm2, GLint Parm3, GLsizei Parm4, GLsizei Parm5, GLenum Parm6, GLsizei Parm7, const GLvoid *Parm8)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glCompressedTexSubImage2DARB");
|
|
tglCompressedTexSubImage2DARB(Parm0, Parm1, Parm2, Parm3, Parm4, Parm5, Parm6, Parm7, Parm8);
|
|
}
|
|
void __stdcall lglCompressedTexSubImage1DARB (GLenum Parm0, GLint Parm1, GLint Parm2, GLsizei Parm3, GLenum Parm4, GLsizei Parm5, const GLvoid *Parm6)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glCompressedTexSubImage1DARB");
|
|
tglCompressedTexSubImage1DARB(Parm0, Parm1, Parm2, Parm3, Parm4, Parm5, Parm6);
|
|
}
|
|
void __stdcall lglGetCompressedTexImageARB (GLenum Parm0, GLint Parm1, void *Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetCompressedTexImageARB");
|
|
tglGetCompressedTexImageARB(Parm0, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglLockArraysEXT (GLint first, GLsizei count)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d, %d)\n", "glLockArraysEXT", first, count);
|
|
tglLockArraysEXT(first, count);
|
|
}
|
|
void __stdcall lglUnlockArraysEXT (void)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glUnlockArraysEXT");
|
|
tglUnlockArraysEXT();
|
|
}
|
|
BOOL __stdcall lwglSwapIntervalEXT (int Parm0)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d)\n", "wglSwapIntervalEXT", Parm0);
|
|
return twglSwapIntervalEXT(Parm0);
|
|
}
|
|
void __stdcall lglMultiTexCoord1fARB (GLenum target, GLfloat Parm1)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMultiTexCoord1fARB");
|
|
tglMultiTexCoord1fARB(target, Parm1);
|
|
}
|
|
void __stdcall lglMultiTexCoord2fARB (GLenum target, GLfloat Parm1, GLfloat Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMultiTexCoord2fARB");
|
|
tglMultiTexCoord2fARB(target, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglMultiTexCoord3fARB (GLenum target, GLfloat Parm1, GLfloat Parm2, GLfloat Parm3)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMultiTexCoord3fARB");
|
|
tglMultiTexCoord3fARB(target, Parm1, Parm2, Parm3);
|
|
}
|
|
void __stdcall lglMultiTexCoord4fARB (GLenum target, GLfloat Parm1, GLfloat Parm2, GLfloat Parm3, GLfloat Parm4)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMultiTexCoord4fARB");
|
|
tglMultiTexCoord4fARB(target, Parm1, Parm2, Parm3, Parm4);
|
|
}
|
|
void __stdcall lglMultiTexCoord1fvARB (GLenum target, GLfloat Parm1)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMultiTexCoord1fvARB");
|
|
tglMultiTexCoord1fvARB(target, Parm1);
|
|
}
|
|
void __stdcall lglMultiTexCoord2fvARB (GLenum target, const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMultiTexCoord2fvARB");
|
|
tglMultiTexCoord2fvARB(target, v);
|
|
}
|
|
void __stdcall lglMultiTexCoord3fvARB (GLenum target, const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMultiTexCoord3fvARB");
|
|
tglMultiTexCoord3fvARB(target, v);
|
|
}
|
|
void __stdcall lglMultiTexCoord4fvARB (GLenum target, const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMultiTexCoord4fvARB");
|
|
tglMultiTexCoord4fvARB(target, v);
|
|
}
|
|
void __stdcall lglActiveTextureARB (GLenum target)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s)\n", "glActiveTextureARB", senActiveTextureARB(target));
|
|
tglActiveTextureARB(target);
|
|
}
|
|
void __stdcall lglClientActiveTextureARB (GLenum target)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s)\n", "glClientActiveTextureARB", senActiveTextureARB(target));
|
|
tglClientActiveTextureARB(target);
|
|
}
|
|
void __stdcall lglPointParameterfEXT (GLenum pname, GLfloat param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPointParameterfEXT");
|
|
tglPointParameterfEXT(pname, param);
|
|
}
|
|
void __stdcall lglPointParameterfvEXT (GLenum pname, GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPointParameterfvEXT");
|
|
tglPointParameterfvEXT(pname, params);
|
|
}
|
|
BOOL __stdcall lwglGetDeviceGammaRamp3DFX(HDC hDC, LPVOID lpRamp)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglGetDeviceGammaRamp3DFX");
|
|
return twglGetDeviceGammaRamp3DFX(hDC, lpRamp);
|
|
}
|
|
BOOL __stdcall lwglSetDeviceGammaRamp3DFX(HDC hDC, LPVOID lpRamp)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglSetDeviceGammaRamp3DFX");
|
|
return twglSetDeviceGammaRamp3DFX(hDC, lpRamp);
|
|
}
|
|
void __stdcall lglCullParameterdvSGI (GLenum pname, GLdouble* params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glCullParameterdvSGI");
|
|
tglCullParameterdvSGI(pname, params);
|
|
}
|
|
void __stdcall lglCullParameterfvSGI (GLenum pname, GLfloat* params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glCullParameterfvSGI");
|
|
tglCullParameterfvSGI(pname, params);
|
|
}
|
|
void __stdcall lglVertexArrayRangeNV (int length, void *pointer)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexArrayRangeNV");
|
|
tglVertexArrayRangeNV(length, pointer);
|
|
}
|
|
void __stdcall lglFlushVertexArrayRangeNV (void)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glFlushVertexArrayRangeNV");
|
|
tglFlushVertexArrayRangeNV();
|
|
}
|
|
void* __stdcall lwglAllocateMemoryNV (int size, float readFrequency, float writeFrequency, float priority)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglAllocateMemoryNV");
|
|
return twglAllocateMemoryNV(size, readFrequency, writeFrequency, priority);
|
|
}
|
|
void __stdcall lwglFreeMemoryNV (void *pointer)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglFreeMemoryNV");
|
|
twglFreeMemoryNV(pointer);
|
|
}
|
|
void __stdcall lglDeleteFencesNV (GLsizei n, const GLuint *fences)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glDeleteFencesNV");
|
|
tglDeleteFencesNV(n, fences);
|
|
}
|
|
void __stdcall lglGenFencesNV (GLsizei n, GLuint *fences)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGenFencesNV");
|
|
tglGenFencesNV(n, fences);
|
|
}
|
|
GLboolean __stdcall lglIsFenceNV (GLuint fence)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glIsFenceNV");
|
|
return tglIsFenceNV(fence);
|
|
}
|
|
GLboolean __stdcall lglTestFenceNV (GLuint fence)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTestFenceNV");
|
|
return tglTestFenceNV(fence);
|
|
}
|
|
void __stdcall lglGetFenceivNV (GLuint fence, GLenum pname, GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetFenceivNV");
|
|
tglGetFenceivNV(fence, pname, params);
|
|
}
|
|
void __stdcall lglFinishFenceNV (GLuint fence)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d)\n", "glFinishFenceNV", fence);
|
|
tglFinishFenceNV(fence);
|
|
}
|
|
void __stdcall lglSetFenceNV (GLuint fence, GLenum condition)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d, %s)\n", "glSetFenceNV", fence, senFenceContition(condition));
|
|
tglSetFenceNV(fence, condition);
|
|
}
|
|
void __stdcall lglSecondaryColor3bEXT (GLbyte Parm0, GLbyte Parm1, GLbyte Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSecondaryColor3bEXT");
|
|
tglSecondaryColor3bEXT(Parm0, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglSecondaryColor3bvEXT (const GLbyte *p)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSecondaryColor3bvEXT");
|
|
tglSecondaryColor3bvEXT(p);
|
|
}
|
|
void __stdcall lglSecondaryColor3dEXT (GLdouble Parm0, GLdouble Parm1, GLdouble Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSecondaryColor3dEXT");
|
|
tglSecondaryColor3dEXT(Parm0, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglSecondaryColor3dvEXT (const GLdouble *p)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSecondaryColor3dvEXT");
|
|
tglSecondaryColor3dvEXT(p);
|
|
}
|
|
void __stdcall lglSecondaryColor3fEXT (GLfloat Parm0, GLfloat Parm1, GLfloat Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSecondaryColor3fEXT");
|
|
tglSecondaryColor3fEXT(Parm0, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglSecondaryColor3fvEXT (const GLfloat *p)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSecondaryColor3fvEXT");
|
|
tglSecondaryColor3fvEXT(p);
|
|
}
|
|
void __stdcall lglSecondaryColor3iEXT (GLint Parm0, GLint Parm1, GLint Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSecondaryColor3iEXT");
|
|
tglSecondaryColor3iEXT(Parm0, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglSecondaryColor3ivEXT (const GLint *p)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSecondaryColor3ivEXT");
|
|
tglSecondaryColor3ivEXT(p);
|
|
}
|
|
void __stdcall lglSecondaryColor3sEXT (GLshort Parm0, GLshort Parm1, GLshort Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSecondaryColor3sEXT");
|
|
tglSecondaryColor3sEXT(Parm0, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglSecondaryColor3svEXT (const GLshort *p)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSecondaryColor3svEXT");
|
|
tglSecondaryColor3svEXT(p);
|
|
}
|
|
void __stdcall lglSecondaryColor3ubEXT (GLubyte Parm0, GLubyte Parm1, GLubyte Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSecondaryColor3ubEXT");
|
|
tglSecondaryColor3ubEXT(Parm0, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglSecondaryColor3ubvEXT (const GLubyte *p)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSecondaryColor3ubvEXT");
|
|
tglSecondaryColor3ubvEXT(p);
|
|
}
|
|
void __stdcall lglSecondaryColor3uiEXT (GLuint Parm0, GLuint Parm1, GLuint Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSecondaryColor3uiEXT");
|
|
tglSecondaryColor3uiEXT(Parm0, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglSecondaryColor3uivEXT (const GLuint *p)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSecondaryColor3uivEXT");
|
|
tglSecondaryColor3uivEXT(p);
|
|
}
|
|
void __stdcall lglSecondaryColor3usEXT (GLushort Parm0, GLushort Parm1, GLushort Parm2)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSecondaryColor3usEXT");
|
|
tglSecondaryColor3usEXT(Parm0, Parm1, Parm2);
|
|
}
|
|
void __stdcall lglSecondaryColor3usvEXT (const GLushort *p)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSecondaryColor3usvEXT");
|
|
tglSecondaryColor3usvEXT(p);
|
|
}
|
|
void __stdcall lglSecondaryColorPointerEXT (GLint Parm0, GLenum Parm1, GLsizei Parm2, GLvoid *Parm3)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSecondaryColorPointerEXT");
|
|
tglSecondaryColorPointerEXT(Parm0, Parm1, Parm2, Parm3);
|
|
}
|
|
void __stdcall lglCombinerParameterfvNV (GLenum pname, const GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d, (%.3f, %.3f, %.3f, %.3f))\n", "glCombinerParameterfvNV", pname-GL_CONSTANT_COLOR0_NV, params[0], params[1], params[2], params[3]);
|
|
tglCombinerParameterfvNV(pname, params);
|
|
}
|
|
void __stdcall lglCombinerStageParameterfvNV (GLenum stage, GLenum pname, const GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d, %d, (%.3f, %.3f, %.3f, %.3f))\n", "glCombinerStageParameterfvNV", stage-GL_COMBINER0_NV, pname-GL_CONSTANT_COLOR0_NV, params[0], params[1], params[2], params[3]);
|
|
tglCombinerStageParameterfvNV(stage, pname, params);
|
|
}
|
|
void __stdcall lglCombinerParameterfNV (GLenum pname, GLfloat param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glCombinerParameterfNV");
|
|
tglCombinerParameterfNV(pname, param);
|
|
}
|
|
void __stdcall lglCombinerParameterivNV (GLenum pname, const GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glCombinerParameterivNV");
|
|
tglCombinerParameterivNV(pname, params);
|
|
}
|
|
void __stdcall lglCombinerParameteriNV (GLenum pname, GLint param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glCombinerParameteriNV");
|
|
tglCombinerParameteriNV(pname, param);
|
|
}
|
|
void __stdcall lglCombinerInputNV (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glCombinerInputNV");
|
|
tglCombinerInputNV(stage, portion, variable, input, mapping, componentUsage);
|
|
}
|
|
void __stdcall lglCombinerOutputNV (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glCombinerOutputNV");
|
|
tglCombinerOutputNV(stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum);
|
|
}
|
|
void __stdcall lglFinalCombinerInputNV (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glFinalCombinerInputNV");
|
|
tglFinalCombinerInputNV(variable, input, mapping, componentUsage);
|
|
}
|
|
void __stdcall lglGetCombinerInputParameterfvNV (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetCombinerInputParameterfvNV");
|
|
tglGetCombinerInputParameterfvNV(stage, portion, variable, pname, params);
|
|
}
|
|
void __stdcall lglGetCombinerStageParameterfvNV (GLenum stage, GLenum pname, GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetCombinerStageParameterfvNV");
|
|
tglGetCombinerStageParameterfvNV(stage, pname, params);
|
|
}
|
|
void __stdcall lglGetCombinerInputParameterivNV (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetCombinerInputParameterivNV");
|
|
tglGetCombinerInputParameterivNV(stage, portion, variable, pname, params);
|
|
}
|
|
void __stdcall lglGetCombinerOutputParameterfvNV (GLenum stage, GLenum portion, GLenum pname, GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetCombinerOutputParameterfvNV");
|
|
tglGetCombinerOutputParameterfvNV(stage, portion, pname, params);
|
|
}
|
|
void __stdcall lglGetCombinerOutputParameterivNV (GLenum stage, GLenum portion, GLenum pname, GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetCombinerOutputParameterivNV");
|
|
tglGetCombinerOutputParameterivNV(stage, portion, pname, params);
|
|
}
|
|
void __stdcall lglGetFinalCombinerInputParameterfvNV (GLenum variable, GLenum pname, GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetFinalCombinerInputParameterfvNV");
|
|
tglGetFinalCombinerInputParameterfvNV(variable, pname, params);
|
|
}
|
|
void __stdcall lglGetFinalCombinerInputParameterivNV (GLenum variable, GLenum pname, GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetFinalCombinerInputParameterivNV");
|
|
tglGetFinalCombinerInputParameterivNV(variable, pname, params);
|
|
}
|
|
|
|
GLboolean _stdcall lglAreProgramsResidentNV (GLsizei n, const GLuint *programs, GLboolean *residences)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glAreProgramsResidentNV");
|
|
return tglAreProgramsResidentNV (n, programs, residences);
|
|
}
|
|
void _stdcall lglBindProgramNV (GLenum target, GLuint id)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d)\n", "glBindProgramNV", id);
|
|
tglBindProgramNV (target, id);
|
|
}
|
|
void _stdcall lglDeleteProgramsNV (GLsizei n, const GLuint *programs)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glDeleteProgramsNV");
|
|
tglDeleteProgramsNV (n, programs);
|
|
}
|
|
void _stdcall lglExecuteProgramNV (GLenum target, GLuint id, const GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glExecuteProgramNV");
|
|
tglExecuteProgramNV (target, id, params);
|
|
}
|
|
void _stdcall lglGenProgramsNV (GLsizei n, GLuint *programs)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGenProgramsNV");
|
|
tglGenProgramsNV (n, programs);
|
|
}
|
|
void _stdcall lglGetProgramParameterdvNV (GLenum target, GLuint index, GLenum pname, GLdouble *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetProgramParameterdvNV");
|
|
tglGetProgramParameterdvNV (target, index, pname, params);
|
|
}
|
|
void _stdcall lglGetProgramParameterfvNV (GLenum target, GLuint index, GLenum pname, GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetProgramParameterfvNV");
|
|
tglGetProgramParameterfvNV (target, index, pname, params);
|
|
}
|
|
void _stdcall lglGetProgramivNV (GLuint id, GLenum pname, GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetProgramivNV");
|
|
tglGetProgramivNV (id, pname, params);
|
|
}
|
|
void _stdcall lglGetProgramStringNV (GLuint id, GLenum pname, GLubyte *program)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetProgramStringNV");
|
|
tglGetProgramStringNV (id, pname, program);
|
|
}
|
|
void _stdcall lglGetTrackMatrixivNV (GLenum target, GLuint address, GLenum pname, GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetTrackMatrixivNV");
|
|
tglGetTrackMatrixivNV (target, address, pname, params);
|
|
}
|
|
void _stdcall lglGetVertexAttribdvNV (GLuint index, GLenum pname, GLdouble *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetVertexAttribdvNV");
|
|
tglGetVertexAttribdvNV (index, pname, params);
|
|
}
|
|
void _stdcall lglGetVertexAttribfvNV (GLuint index, GLenum pname, GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetVertexAttribfvNV");
|
|
tglGetVertexAttribfvNV (index, pname, params);
|
|
}
|
|
void _stdcall lglGetVertexAttribivNV (GLuint index, GLenum pname, GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetVertexAttribivNV");
|
|
tglGetVertexAttribivNV (index, pname, params);
|
|
}
|
|
/*void _stdcall lglGetVertexAttribPointervNV (GLuint index, GLenum pname, GLvoid* *pointer)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetVertexAttribPointervNV");
|
|
tglGetVertexAttribPointervNV (index, pname, pointer);
|
|
}*/
|
|
GLboolean _stdcall lglIsProgramNV (GLuint id)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glIsProgramNV");
|
|
return tglIsProgramNV (id);
|
|
}
|
|
void _stdcall lglLoadProgramNV (GLenum target, GLuint id, GLsizei len, const GLubyte *program)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glLoadProgramNV");
|
|
tglLoadProgramNV (target, id, len, program);
|
|
}
|
|
void _stdcall lglProgramParameter4dNV (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glProgramParameter4dNV");
|
|
tglProgramParameter4dNV (target, index, x, y, z, w);
|
|
}
|
|
void _stdcall lglProgramParameter4dvNV (GLenum target, GLuint index, const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glProgramParameter4dvNV");
|
|
tglProgramParameter4dvNV (target, index, v);
|
|
}
|
|
void _stdcall lglProgramParameter4fNV (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d, %f, %f, %f, %f)\n", "glProgramParameter4fNV", index, x, y, z, w);
|
|
tglProgramParameter4fNV (target, index, x, y, z, w);
|
|
}
|
|
void _stdcall lglProgramParameter4fvNV (GLenum target, GLuint index, const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d, %f, %f, %f, %f)\n", "glProgramParameter4fvNV", index, v[0], v[1], v[2], v[3]);
|
|
tglProgramParameter4fvNV (target, index, v);
|
|
}
|
|
void _stdcall lglProgramParameters4dvNV (GLenum target, GLuint index, GLsizei count, const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glProgramParameters4dvNV");
|
|
tglProgramParameters4dvNV (target, index, count, v);
|
|
}
|
|
void _stdcall lglProgramParameters4fvNV (GLenum target, GLuint index, GLsizei count, const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d", "glProgramParameters4fvNV", index);
|
|
const float *vv = v;
|
|
for (int i=0; i<(int)count; i++)
|
|
{
|
|
gRenDev->Logv(0, ", [%.3f, %.3f, %.3f, %.3f]", vv[0], vv[1], vv[2], vv[3]);
|
|
vv += 4;
|
|
}
|
|
gRenDev->Logv(0, ", %d)\n", count);
|
|
tglProgramParameters4fvNV (target, index, count, v);
|
|
}
|
|
void _stdcall lglRequestResidentProgramsNV (GLsizei n, const GLuint *programs)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glRequestResidentProgramsNV");
|
|
tglRequestResidentProgramsNV (n, programs);
|
|
}
|
|
void _stdcall lglTrackMatrixNV (GLenum target, GLuint address, GLenum matrix, GLenum transform)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glTrackMatrixNV");
|
|
tglTrackMatrixNV (target, address, matrix, transform);
|
|
}
|
|
void _stdcall lglVertexAttribPointerNV (GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d, %d, %s, %d, 0x%x)\n", "glVertexAttribPointerNV", index, fsize, senDataType(type), stride, pointer);
|
|
tglVertexAttribPointerNV (index, fsize, type, stride, pointer);
|
|
}
|
|
void _stdcall lglVertexAttrib1dNV (GLuint index, GLdouble x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib1dNV");
|
|
tglVertexAttrib1dNV (index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib1dvNV (GLuint index, const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib1dvNV");
|
|
tglVertexAttrib1dvNV (index, v);
|
|
}
|
|
void _stdcall lglVertexAttrib1fNV (GLuint index, GLfloat x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib1fNV");
|
|
tglVertexAttrib1fNV (index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib1fvNV (GLuint index, const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib1fvNV");
|
|
tglVertexAttrib1fvNV (index, v);
|
|
}
|
|
void _stdcall lglVertexAttrib1sNV (GLuint index, GLshort x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib1sNV");
|
|
tglVertexAttrib1sNV (index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib1svNV (GLuint index, const GLshort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib1svNV");
|
|
tglVertexAttrib1svNV (index, v);
|
|
}
|
|
void _stdcall lglVertexAttrib2dNV (GLuint index, GLdouble x, GLdouble y)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib2dNV");
|
|
tglVertexAttrib2dNV (index, x, y);
|
|
}
|
|
void _stdcall lglVertexAttrib2dvNV (GLuint index, const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib2dvNV");
|
|
tglVertexAttrib2dvNV (index, v);
|
|
}
|
|
void _stdcall lglVertexAttrib2fNV (GLuint index, GLfloat x, GLfloat y)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib2fNV");
|
|
tglVertexAttrib2fNV (index, x, y);
|
|
}
|
|
void _stdcall lglVertexAttrib2fvNV (GLuint index, const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib2fvNV");
|
|
tglVertexAttrib2fvNV (index, v);
|
|
}
|
|
void _stdcall lglVertexAttrib2sNV (GLuint index, GLshort x, GLshort y)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib2sNV");
|
|
tglVertexAttrib2sNV (index, x, y);
|
|
}
|
|
void _stdcall lglVertexAttrib2svNV (GLuint index, const GLshort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib2svNV");
|
|
tglVertexAttrib2svNV (index, v);
|
|
}
|
|
void _stdcall lglVertexAttrib3dNV (GLuint index, GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib3dNV");
|
|
tglVertexAttrib3dNV (index, x, y, z);
|
|
}
|
|
void _stdcall lglVertexAttrib3dvNV (GLuint index, const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib3dvNV");
|
|
tglVertexAttrib3dvNV (index, v);
|
|
}
|
|
void _stdcall lglVertexAttrib3fNV (GLuint index, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib3fNV");
|
|
tglVertexAttrib3fNV (index, x, y, z);
|
|
}
|
|
void _stdcall lglVertexAttrib3fvNV (GLuint index, const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib3fvNV");
|
|
tglVertexAttrib3fvNV (index, v);
|
|
}
|
|
void _stdcall lglVertexAttrib3sNV (GLuint index, GLshort x, GLshort y, GLshort z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib3sNV");
|
|
tglVertexAttrib3sNV (index, x, y, z);
|
|
}
|
|
void _stdcall lglVertexAttrib3svNV (GLuint index, const GLshort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib3svNV");
|
|
tglVertexAttrib3svNV (index, v);
|
|
}
|
|
void _stdcall lglVertexAttrib4dNV (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4dNV");
|
|
tglVertexAttrib4dNV (index, x, y, z, w);
|
|
}
|
|
void _stdcall lglVertexAttrib4dvNV (GLuint index, const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4dvNV");
|
|
tglVertexAttrib4dvNV (index, v);
|
|
}
|
|
void _stdcall lglVertexAttrib4fNV (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4fNV");
|
|
tglVertexAttrib4fNV (index, x, y, z, w);
|
|
}
|
|
void _stdcall lglVertexAttrib4fvNV (GLuint index, const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4fvNV");
|
|
tglVertexAttrib4fvNV (index, v);
|
|
}
|
|
void _stdcall lglVertexAttrib4sNV (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4sNV");
|
|
tglVertexAttrib4sNV (index, x, y, z, w);
|
|
}
|
|
void _stdcall lglVertexAttrib4svNV (GLuint index, const GLshort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4svNV");
|
|
tglVertexAttrib4svNV (index, v);
|
|
}
|
|
void _stdcall lglVertexAttrib4ubvNV (GLuint index, const GLubyte *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4ubvNV");
|
|
tglVertexAttrib4ubvNV (index, v);
|
|
}
|
|
void _stdcall lglVertexAttribs1dvNV (GLuint index, GLsizei count, const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttribs1dvNV");
|
|
tglVertexAttribs1dvNV (index, count, v);
|
|
}
|
|
void _stdcall lglVertexAttribs1fvNV (GLuint index, GLsizei count, const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttribs1fvNV");
|
|
tglVertexAttribs1fvNV (index, count, v);
|
|
}
|
|
void _stdcall lglVertexAttribs1svNV (GLuint index, GLsizei count, const GLshort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttribs1svNV");
|
|
tglVertexAttribs1svNV (index, count, v);
|
|
}
|
|
void _stdcall lglVertexAttribs2dvNV (GLuint index, GLsizei count, const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttribs2dvNV");
|
|
tglVertexAttribs2dvNV (index, count, v);
|
|
}
|
|
void _stdcall lglVertexAttribs2fvNV (GLuint index, GLsizei count, const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttribs2fvNV");
|
|
tglVertexAttribs2fvNV (index, count, v);
|
|
}
|
|
void _stdcall lglVertexAttribs2svNV (GLuint index, GLsizei count, const GLshort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttribs2svNV");
|
|
tglVertexAttribs2svNV (index, count, v);
|
|
}
|
|
void _stdcall lglVertexAttribs3dvNV (GLuint index, GLsizei count, const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttribs3dvNV");
|
|
tglVertexAttribs3dvNV (index, count, v);
|
|
}
|
|
void _stdcall lglVertexAttribs3fvNV (GLuint index, GLsizei count, const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttribs3fvNV");
|
|
tglVertexAttribs3fvNV (index, count, v);
|
|
}
|
|
void _stdcall lglVertexAttribs3svNV (GLuint index, GLsizei count, const GLshort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttribs3svNV");
|
|
tglVertexAttribs3svNV (index, count, v);
|
|
}
|
|
void _stdcall lglVertexAttribs4dvNV (GLuint index, GLsizei count, const GLdouble *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttribs4dvNV");
|
|
tglVertexAttribs4dvNV (index, count, v);
|
|
}
|
|
void _stdcall lglVertexAttribs4fvNV (GLuint index, GLsizei count, const GLfloat *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttribs4fvNV");
|
|
tglVertexAttribs4fvNV (index, count, v);
|
|
}
|
|
void _stdcall lglVertexAttribs4svNV (GLuint index, GLsizei count, const GLshort *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttribs4svNV");
|
|
tglVertexAttribs4svNV (index, count, v);
|
|
}
|
|
void _stdcall lglVertexAttribs4ubvNV (GLuint index, GLsizei count, const GLubyte *v)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttribs4ubvNV");
|
|
tglVertexAttribs4ubvNV (index, count, v);
|
|
}
|
|
|
|
void __stdcall lglMultiDrawArraysEXT(GLenum p0, GLint *p1, GLsizei *p2, GLsizei p3)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMultiDrawArraysEXT");
|
|
tglMultiDrawArraysEXT(p0, p1, p2, p3);
|
|
}
|
|
void __stdcall lglMultiDrawElementsEXT(GLenum p0, const GLsizei *p1, GLenum p2, const GLvoid* *p3, GLsizei p4)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMultiDrawElementsEXT");
|
|
tglMultiDrawElementsEXT(p0, p1, p2, p3, p4);
|
|
}
|
|
|
|
void __stdcall lglPointParameteriNV (GLenum pname, int param)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPointParameteriNV");
|
|
tglPointParameteriNV(pname, param);
|
|
}
|
|
void __stdcall lglPointParameterivNV(GLenum pname, const int *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPointParameterivNV");
|
|
tglPointParameterivNV(pname, params);
|
|
}
|
|
|
|
BOOL _stdcall lwglGetPixelFormatAttribivARB (HDC hdc, int a, int b, UINT c, const int *d, int *e)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglGetPixelFormatAttribivARB");
|
|
return twglGetPixelFormatAttribivARB (hdc, a,b,c,d,e);
|
|
}
|
|
BOOL _stdcall lwglGetPixelFormatAttribfvARB (HDC hdc, int a, int b, UINT c, const int *d, FLOAT *e)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglGetPixelFormatAttribfvARB");
|
|
return twglGetPixelFormatAttribfvARB (hdc, a,b,c,d,e);
|
|
}
|
|
BOOL _stdcall lwglChoosePixelFormatARB (HDC hdc, const int *a, const FLOAT *b, UINT c, int *d, UINT *e)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglChoosePixelFormatARB");
|
|
return twglChoosePixelFormatARB (hdc, a,b,c,d,e);
|
|
}
|
|
|
|
BOOL _stdcall lwglMakeContextCurrentARB (HDC a, HDC b, HGLRC c)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglMakeContextCurrentARB");
|
|
return twglMakeContextCurrentARB (a,b,c);
|
|
}
|
|
HDC _stdcall lwglGetCurrentReadDCARB (void)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglGetCurrentReadDCARB");
|
|
return twglGetCurrentReadDCARB ();
|
|
}
|
|
|
|
HPBUFFERARB _stdcall lwglCreatePbufferARB (HDC a, int b, int c, int d, const int * e)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglCreatePbufferARB");
|
|
return twglCreatePbufferARB (a,b,c,d,e);
|
|
}
|
|
HDC _stdcall lwglGetPbufferDCARB (HPBUFFERARB a)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglGetPbufferDCARB");
|
|
return twglGetPbufferDCARB (a);
|
|
}
|
|
int _stdcall lwglReleasePbufferDCARB (HPBUFFERARB a, HDC b)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglReleasePbufferDCARB");
|
|
return twglReleasePbufferDCARB (a,b);
|
|
}
|
|
BOOL _stdcall lwglDestroyPbufferARB (HPBUFFERARB a)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglDestroyPbufferARB");
|
|
return twglDestroyPbufferARB (a);
|
|
}
|
|
BOOL _stdcall lwglQueryPbufferARB (HPBUFFERARB a, int b, int *c)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "wglQueryPbufferARB");
|
|
return twglQueryPbufferARB (a,b,c);
|
|
}
|
|
|
|
void _stdcall lglGenOcclusionQueriesNV(GLsizei n, GLuint *ids)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGenOcclusionQueriesNV");
|
|
return tglGenOcclusionQueriesNV(n, ids);
|
|
}
|
|
void _stdcall lglDeleteOcclusionQueriesNV(GLsizei n, GLuint *ids)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glDeleteOcclusionQueriesNV");
|
|
return tglDeleteOcclusionQueriesNV(n, ids);
|
|
}
|
|
void _stdcall lglIsOcclusionQueryNV(GLuint id)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glIsOcclusionQueryNV");
|
|
return tglIsOcclusionQueryNV(id);
|
|
}
|
|
void _stdcall lglBeginOcclusionQueryNV(GLuint id)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glBeginOcclusionQueryNV");
|
|
return tglBeginOcclusionQueryNV(id);
|
|
}
|
|
void _stdcall lglEndOcclusionQueryNV(void)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEndOcclusionQueryNV");
|
|
return tglEndOcclusionQueryNV();
|
|
}
|
|
void _stdcall lglGetOcclusionQueryivNV(GLuint id, GLenum pname, GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetOcclusionQueryivNV");
|
|
return tglGetOcclusionQueryivNV(id, pname, params);
|
|
}
|
|
void _stdcall lglGetOcclusionQueryuivNV(GLuint id, GLenum pname, GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetOcclusionQueryuivNV");
|
|
return tglGetOcclusionQueryuivNV(id, pname, params);
|
|
}
|
|
|
|
GLuint _stdcall lglGenFragmentShadersATI(GLuint range)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d)\n", "glGenFragmentShadersATI", range);
|
|
return tglGenFragmentShadersATI(range);
|
|
}
|
|
void _stdcall lglBindFragmentShaderATI(GLuint id)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d)\n", "glBindFragmentShaderATI", id);
|
|
tglBindFragmentShaderATI(id);
|
|
}
|
|
void _stdcall lglDeleteFragmentShaderATI(GLuint id)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d)\n", "glDeleteFragmentShaderATI", id);
|
|
tglDeleteFragmentShaderATI(id);
|
|
}
|
|
void _stdcall lglBeginFragmentShaderATI(GLvoid)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glBeginFragmentShaderATI");
|
|
tglBeginFragmentShaderATI();
|
|
}
|
|
void _stdcall lglEndFragmentShaderATI(GLvoid)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEndFragmentShaderATI");
|
|
tglEndFragmentShaderATI();
|
|
}
|
|
void _stdcall lglPassTexCoordATI(GLuint dst, GLuint coord, GLenum swizzle)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glPassTexCoordATI");
|
|
tglPassTexCoordATI(dst, coord, swizzle);
|
|
}
|
|
void _stdcall lglSampleMapATI(GLuint dst, GLuint interp, GLenum swizzle)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glSampleMapATI");
|
|
tglSampleMapATI(dst, interp, swizzle);
|
|
}
|
|
void _stdcall lglColorFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColorFragmentOp1ATI");
|
|
tglColorFragmentOp1ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod);
|
|
}
|
|
void _stdcall lglColorFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColorFragmentOp2ATI");
|
|
tglColorFragmentOp2ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
|
|
}
|
|
void _stdcall lglColorFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glColorFragmentOp3ATI");
|
|
tglColorFragmentOp3ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
|
|
}
|
|
void _stdcall lglAlphaFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glAlphaFragmentOp1ATI");
|
|
tglAlphaFragmentOp1ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod);
|
|
}
|
|
void _stdcall lglAlphaFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glAlphaFragmentOp2ATI");
|
|
tglAlphaFragmentOp2ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
|
|
}
|
|
void _stdcall lglAlphaFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glAlphaFragmentOp3ATI");
|
|
tglAlphaFragmentOp3ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
|
|
}
|
|
void _stdcall lglSetFragmentShaderConstantATI(GLuint dst, const GLfloat *value)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (0x%x, (%.3f, %.3f, %.3f, %.3f))\n", "glSetFragmentShaderConstantATI", dst, value[0], value[1], value[2], value[3]);
|
|
tglSetFragmentShaderConstantATI(dst, value);
|
|
}
|
|
|
|
void _stdcall lglVertexAttrib1sARB(GLuint index, GLshort x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib1sARB");
|
|
tglVertexAttrib1sARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib1fARB(GLuint index, GLfloat x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib1fARB");
|
|
tglVertexAttrib1fARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib1dARB(GLuint index, GLdouble x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib1dARB");
|
|
tglVertexAttrib1dARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib2sARB(GLuint index, GLshort x, GLshort y)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib2sARB");
|
|
tglVertexAttrib2sARB(index, x, y);
|
|
}
|
|
void _stdcall lglVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib2fARB");
|
|
tglVertexAttrib2fARB(index, x, y);
|
|
}
|
|
void _stdcall lglVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib2dARB");
|
|
tglVertexAttrib2dARB(index, x, y);
|
|
}
|
|
void _stdcall lglVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib3sARB");
|
|
tglVertexAttrib3sARB(index, x, y, z);
|
|
}
|
|
void _stdcall lglVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib3fARB");
|
|
tglVertexAttrib3fARB(index, x, y, z);
|
|
}
|
|
void _stdcall lglVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib3dARB");
|
|
tglVertexAttrib3dARB(index, x, y, z);
|
|
}
|
|
void _stdcall lglVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4sARB");
|
|
tglVertexAttrib4sARB(index, x, y, z, w);
|
|
}
|
|
void _stdcall lglVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4fARB");
|
|
tglVertexAttrib4fARB(index, x, y, z, w);
|
|
}
|
|
void _stdcall lglVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4dARB");
|
|
tglVertexAttrib4dARB(index, x, y, z, w);
|
|
}
|
|
void _stdcall lglVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4NubARB");
|
|
tglVertexAttrib4NubARB(index, x, y, z, w);
|
|
}
|
|
void _stdcall lglVertexAttrib1svARB(GLuint index, const GLshort *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib1svARB");
|
|
tglVertexAttrib1svARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib1fvARB(GLuint index, const GLfloat *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib1fvARB");
|
|
tglVertexAttrib1fvARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib1dvARB(GLuint index, const GLdouble *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib1dvARB");
|
|
tglVertexAttrib1dvARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib2svARB(GLuint index, const GLshort *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib2svARB");
|
|
tglVertexAttrib2svARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib2fvARB(GLuint index, const GLfloat *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib2fvARB");
|
|
tglVertexAttrib2fvARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib2dvARB(GLuint index, const GLdouble *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib2dvARB");
|
|
tglVertexAttrib2dvARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib3svARB(GLuint index, const GLshort *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib3svARB");
|
|
tglVertexAttrib3svARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib3fvARB(GLuint index, const GLfloat *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib3fvARB");
|
|
tglVertexAttrib3fvARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib3dvARB(GLuint index, const GLdouble *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib3dvARB");
|
|
tglVertexAttrib3dvARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib4bvARB(GLuint index, const GLbyte *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4bvARB");
|
|
tglVertexAttrib4bvARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib4ubvARB(GLuint index, const GLubyte *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4ubvARB");
|
|
tglVertexAttrib4ubvARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib4svARB(GLuint index, const GLshort *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4svARB");
|
|
tglVertexAttrib4svARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib4usvARB(GLuint index, const GLushort *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4usvARB");
|
|
tglVertexAttrib4usvARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib4ivARB(GLuint index, const GLint *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4ivARB");
|
|
tglVertexAttrib4ivARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib4uivARB(GLuint index, const GLuint *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4uivARB");
|
|
tglVertexAttrib4uivARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib4fvARB(GLuint index, const GLfloat *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4fvARB");
|
|
tglVertexAttrib4fvARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib4dvARB(GLuint index, const GLdouble *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4dvARB");
|
|
tglVertexAttrib4dvARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib4NbvARB(GLuint index, const GLbyte *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4NbvARB");
|
|
tglVertexAttrib4NbvARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib4NsvARB(GLuint index, const GLshort *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4NsvARB");
|
|
tglVertexAttrib4NsvARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib4NivARB(GLuint index, const GLint *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4NivARB");
|
|
tglVertexAttrib4NivARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib4NubvARB(GLuint index, const GLubyte *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4NubARB");
|
|
tglVertexAttrib4NubvARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib4NusvARB(GLuint index, const GLushort *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4NusARB");
|
|
tglVertexAttrib4NusvARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttrib4NuivARB(GLuint index, const GLuint *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttrib4NuiARB");
|
|
tglVertexAttrib4NuivARB(index, x);
|
|
}
|
|
void _stdcall lglVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glVertexAttribPointerARB");
|
|
tglVertexAttribPointerARB(index, size, type, normalized, stride, pointer);
|
|
}
|
|
void _stdcall lglEnableVertexAttribArrayARB(GLuint index)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glEnableVertexAttribArrayARB");
|
|
tglEnableVertexAttribArrayARB(index);
|
|
}
|
|
void _stdcall lglDisableVertexAttribArrayARB(GLuint index)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glDisableVertexAttribArrayARB");
|
|
tglDisableVertexAttribArrayARB(index);
|
|
}
|
|
void _stdcall lglProgramStringARB(GLenum target, GLenum format, GLsizei len, const void *string)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glProgramStringARB");
|
|
tglProgramStringARB(target, format, len, string);
|
|
}
|
|
void _stdcall lglBindProgramARB(GLenum target, GLuint program)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, 0x%x)\n", "glBindProgramARB", senProgramARB(target), program);
|
|
tglBindProgramARB(target, program);
|
|
}
|
|
void _stdcall lglDeleteProgramsARB(GLsizei n, const GLuint *programs)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glDeleteProgramsARB");
|
|
tglDeleteProgramsARB(n, programs);
|
|
}
|
|
void _stdcall lglGenProgramsARB(GLsizei n, GLuint *programs)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGenProgramsARB");
|
|
tglGenProgramsARB(n, programs);
|
|
}
|
|
void _stdcall lglProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glProgramEnvParameter4dARB");
|
|
tglProgramEnvParameter4dARB(target, index, x, y, z, w);
|
|
}
|
|
void _stdcall lglProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glProgramEnvParameter4dvARB");
|
|
tglProgramEnvParameter4dvARB(target, index, x);
|
|
}
|
|
void _stdcall lglProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %d, [%.3f, %.3f, %.3f, %.3f])\n", "glProgramEnvParameter4fARB", senProgramARB(target), index, x, y, z, w);
|
|
tglProgramEnvParameter4fARB(target, index, x, y, z, w);
|
|
}
|
|
void _stdcall lglProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %d, [%.3f, %.3f, %.3f, %.3f])\n", "glProgramEnvParameter4fvARB", senProgramARB(target), index, x[0], x[1], x[2], x[3]);
|
|
tglProgramEnvParameter4fvARB(target, index, x);
|
|
}
|
|
void _stdcall lglProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glProgramLocalParameter4dARB");
|
|
tglProgramLocalParameter4dARB(target, index, x, y, z, w);
|
|
}
|
|
void _stdcall lglProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glProgramLocalParameter4dvARB");
|
|
tglProgramLocalParameter4dvARB(target, index, x);
|
|
}
|
|
void _stdcall lglProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glProgramLocalParameter4fARB");
|
|
tglProgramLocalParameter4fARB(target, index, x, y, z, w);
|
|
}
|
|
void _stdcall lglProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s(0x%x, %d, (%.3f, %.3f, %.3f, %.3f))\n", "glProgramLocalParameter4fvARB", target, index, x[0], x[1], x[2], x[3]);
|
|
tglProgramLocalParameter4fvARB(target, index, x);
|
|
}
|
|
void _stdcall lglGetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetProgramEnvParameterfvARB");
|
|
tglGetProgramEnvParameterfvARB(target, index, x);
|
|
}
|
|
void _stdcall lglGetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetProgramEnvParameterdvARB");
|
|
tglGetProgramEnvParameterdvARB(target, index, x);
|
|
}
|
|
void _stdcall lglGetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetProgramLocalParameterfvARB");
|
|
tglGetProgramLocalParameterfvARB(target, index, x);
|
|
}
|
|
void _stdcall lglGetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble *x)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetProgramLocalParameterdvARB");
|
|
tglGetProgramLocalParameterdvARB(target, index, x);
|
|
}
|
|
void _stdcall lglGetProgramivARB(GLenum target, GLenum pname, GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetProgramivARB");
|
|
tglGetProgramivARB(target, pname, params);
|
|
}
|
|
void _stdcall lglGetProgramStringARB(GLenum target, GLenum pname, void *string)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetProgramStringARB");
|
|
tglGetProgramStringARB(target, pname, string);
|
|
}
|
|
void _stdcall lglGetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetVertexAttribdvARB");
|
|
tglGetVertexAttribdvARB(index, pname, params);
|
|
}
|
|
void _stdcall lglGetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetVertexAttribfvARB");
|
|
tglGetVertexAttribfvARB(index, pname, params);
|
|
}
|
|
void _stdcall lglGetVertexAttribivARB(GLuint index, GLenum pname, GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetVertexAttribivARB");
|
|
tglGetVertexAttribivARB(index, pname, params);
|
|
}
|
|
void _stdcall lglGetVertexAttribPointervARB(GLuint index, GLenum pname, void **pointer)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetVertexAttribPointervARB");
|
|
tglGetVertexAttribPointervARB(index, pname, pointer);
|
|
}
|
|
GLboolean _stdcall lglIsProgramARB(GLuint program)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glIsProgramARB");
|
|
return tglIsProgramARB(program);
|
|
}
|
|
|
|
void _stdcall lglBindBufferARB(GLenum target, GLuint buffer)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%s, %d)\n", "glBindBufferARB", senArrayBufferARB(target), buffer);
|
|
tglBindBufferARB(target, buffer);
|
|
}
|
|
void _stdcall lglDeleteBuffersARB(GLsizei n, const GLuint *buffers)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glDeleteBuffersARB");
|
|
tglDeleteBuffersARB(n, buffers);
|
|
}
|
|
void _stdcall lglGenBuffersARB(GLsizei n, GLuint *buffers)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGenBuffersARB");
|
|
tglGenBuffersARB(n, buffers);
|
|
}
|
|
GLboolean _stdcall lglIsBufferARB(GLuint buffer)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s (%d)\n", "glIsBuffersARB", buffer);
|
|
return tglIsBufferARB(buffer);
|
|
}
|
|
void _stdcall lglBufferDataARB(GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glBufferDataARB");
|
|
tglBufferDataARB(target, size, data, usage);
|
|
}
|
|
void _stdcall lglBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glBufferSubDataARB");
|
|
tglBufferSubDataARB(target, offset, size, data);
|
|
}
|
|
void _stdcall lglGetBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid *data)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetBufferSubDataARB");
|
|
tglGetBufferSubDataARB(target, offset, size, data);
|
|
}
|
|
void * _stdcall lglMapBufferARB(GLenum target, GLenum access)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glMapBufferARB");
|
|
return tglMapBufferARB(target, access);
|
|
}
|
|
GLboolean _stdcall lglUnmapBufferARB(GLenum target)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glUnmapBufferARB");
|
|
return tglUnmapBufferARB(target);
|
|
}
|
|
void _stdcall lglGetBufferParameterivARB(GLenum target, GLenum pname, GLint *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetBufferParameterivARB");
|
|
tglGetBufferParameterivARB(target, pname, params);
|
|
}
|
|
void _stdcall lglGetBufferPointervARB(GLenum target, GLenum pname, GLvoid **params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetBufferPointervARB");
|
|
tglGetBufferPointervARB(target, pname, params);
|
|
}
|
|
|
|
void _stdcall lglDepthBoundsEXT(GLclampd minx, GLclampd maxx)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glDepthBoundsEXT");
|
|
tglDepthBoundsEXT(minx, maxx);
|
|
}
|
|
|
|
void _stdcall lglStencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glStencilFuncSeparateATI (%s, %s, 0x%x, 0x%x)", senStencilFunc(frontfunc), senStencilFunc(backfunc), ref, mask);
|
|
tglStencilFuncSeparateATI(frontfunc, backfunc, ref, mask);
|
|
}
|
|
void _stdcall lglStencilOpSeparateATI(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glStencilOpSeparateATI (%s, %s, %s)", senFace(face), senStencilOp(sfail), senStencilOp(dpfail), senStencilOp(dppass));
|
|
tglStencilOpSeparateATI(face, sfail, dpfail, dppass);
|
|
}
|
|
|
|
void _stdcall lglActiveStencilFaceEXT(GLenum face)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glActiveStencilFaceEXT (%s)", senFace(face));
|
|
tglActiveStencilFaceEXT(face);
|
|
}
|
|
|
|
void _stdcall lglProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glProgramNamedParameter4fNV (%d, %d, %s, [%.3f, %.3f, %.3f, %.3f])", id, len, name, x,y,z,w);
|
|
tglProgramNamedParameter4fNV(id, len, name, x, y, z, w);
|
|
}
|
|
void _stdcall lglProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glProgramNamedParameter4dNV (%d, %d, %s, [%.3f, %.3f, %.3f, %.3f])", id, len, name, x,y,z,w);
|
|
tglProgramNamedParameter4dNV(id, len, name, x, y, z, w);
|
|
}
|
|
void _stdcall lglProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte *name, const GLfloat v[])
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glProgramNamedParameter4fvNV (%d, %d, %s, [%.3f, %.3f, %.3f, %.3f])", id, len, name, v[0],v[1],v[2],v[3]);
|
|
tglProgramNamedParameter4fvNV(id, len, name, v);
|
|
}
|
|
void _stdcall lglProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte *name, const GLdouble v[])
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glProgramNamedParameter4dvNV (%d, %d, %s, [%.3f, %.3f, %.3f, %.3f])", id, len, name, v[0],v[1],v[2],v[3]);
|
|
tglProgramNamedParameter4dvNV(id, len, name, v);
|
|
}
|
|
void _stdcall lglGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte *name, GLfloat *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetProgramNamedParameterfvNV");
|
|
tglGetProgramNamedParameterfvNV(id, len, name, params);
|
|
}
|
|
void _stdcall lglGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte *name, GLdouble *params)
|
|
{
|
|
gRenDev->Logv(SRendItem::m_RecurseLevel, "%s\n", "glGetProgramNamedParameterdvNV");
|
|
tglGetProgramNamedParameterdvNV(id, len, name, params);
|
|
}
|
|
|
|
//==============================================================================================
|
|
|
|
void CGLRenderer::SetLogFuncs(bool set)
|
|
{
|
|
static bool sSet = 0;
|
|
|
|
if (set == sSet)
|
|
return;
|
|
|
|
sSet = set;
|
|
|
|
if (set)
|
|
{
|
|
#define GL_EXT(name)
|
|
#define GL_PROC(ext,ret,func,parms) if (func) t##func = func; func = l##func;
|
|
#include "GLFuncs.h"
|
|
#undef GL_EXT
|
|
#undef GL_PROC
|
|
}
|
|
else
|
|
{
|
|
#define GL_EXT(name)
|
|
#define GL_PROC(ext,ret,func,parms) if (t##func) func = t##func;
|
|
#include "GLFuncs.h"
|
|
#undef GL_EXT
|
|
#undef GL_PROC
|
|
}
|
|
}
|