state_program.c revision 7bcc9300d10d0bd2c659be811f360748ecbc8274
/* Copyright (c) 2001, Stanford University
* All rights reserved
*
* See the file LICENSE.txt for information on redistributing this software.
*/
#include "state.h"
#include "state_internals.h"
#include "cr_mem.h"
#include "cr_string.h"
/*
* General notes:
*
* Vertex programs can change vertices so bounding boxes may not be
* practical for tilesort. Tilesort may have to broadcast geometry
* when vertex programs are in effect. We could semi-parse vertex
* programs to determine if they write to the o[HPOS] register.
*/
/*
* Lookup the named program and return a pointer to it.
* If the program doesn't exist, create it and reserve its Id and put
* it into the hash table.
*/
static CRProgram *
{
if (!prog) {
if (!prog)
return NULL;
if (id > 0)
}
return prog;
}
/*
* Delete a CRProgram object and all attached data.
*/
static void
{
}
}
/*
* Set the named symbol to the value (x, y, z, w).
* NOTE: Symbols should only really be added during parsing of the program.
* However, the state tracker does not parse the programs (yet). So, when
* someone calls glProgramNamedParameter4fNV() we always enter the symbol
* since we don't know if it's really valid or not.
*/
static void
{
/* NOTE: <name> may not be null-terminated! */
/* found it */
return;
}
}
/* add new symbol table entry */
if (symbol) {
}
}
/*
* Return a pointer to the values for the given symbol. Return NULL if
* the name doesn't exist in the symbol table.
*/
static const GLfloat *
{
/* NOTE: <name> may not be null-terminated! */
}
}
return NULL;
}
/*
* Used by both glBindProgramNV and glBindProgramARB
*/
static CRProgram *
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (g->current.inBeginEnd) {
return NULL;
}
if (id == 0) {
if (target == vertexTarget) {
prog = p->defaultVertexProgram;
}
else if (target == fragmentTarget) {
prog = p->defaultFragmentProgram;
}
else {
"glBindProgram(bad target)");
return NULL;
}
}
else {
}
if (!prog) {
return NULL;
}
"glBindProgram target mismatch");
return NULL;
}
if (target == vertexTarget) {
p->currentVertexProgram = prog;
p->vpProgramBinding = id;
}
else if (target == fragmentTarget) {
p->currentFragmentProgram = prog;
p->fpProgramBinding = id;
}
return prog;
}
{
if (prog) {
}
}
{
if (prog) {
}
}
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
GLint i;
if (g->current.inBeginEnd) {
return;
}
if (n < 0)
{
return;
}
for (i = 0; i < n; i++) {
if (ids[i] > 0) {
if (prog == p->currentVertexProgram) {
p->currentVertexProgram = p->defaultVertexProgram;
}
else if (prog == p->currentFragmentProgram) {
}
if (prog) {
}
}
}
}
{
/* Hmmm, this is really hard to do if we don't actually execute
* the program in a software simulation.
*/
(void)params;
(void)target;
(void)id;
}
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
}
{
crStateGenProgramsNV(n, ids);
}
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (g->current.inBeginEnd) {
return GL_FALSE;
}
if (id == 0) {
"glIsProgram(id==0)");
return GL_FALSE;
}
if (prog)
return GL_TRUE;
else
return GL_FALSE;
}
GLboolean STATE_APIENTRY crStateAreProgramsResidentNV(GLsizei n, const GLuint *ids, GLboolean *residences)
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
int i;
if (n < 0) {
"glAreProgramsResidentNV(n)");
return GL_FALSE;
}
for (i = 0; i < n; i++) {
if (ids[i] == 0) {
"glAreProgramsResidentNV(id)");
return GL_FALSE;
}
if (!prog) {
"glAreProgramsResidentNV(id)");
return GL_FALSE;
}
break;
}
}
for (i = 0; i < n; i++) {
}
}
return retVal;
}
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
GLint i;
if (g->current.inBeginEnd) {
return;
}
if (n < 0) {
"glRequestResidentProgramsNV(n<0)");
return;
}
for (i = 0; i < n ; i++) {
if (prog)
}
}
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (g->current.inBeginEnd) {
return;
}
if (id == 0) {
"glLoadProgramNV(id==0)");
return;
}
if (!prog) {
return;
}
"glLoadProgramNV(target)");
return;
}
if (!progCopy) {
return;
}
return;
}
}
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (g->current.inBeginEnd) {
return;
}
if (format != GL_PROGRAM_FORMAT_ASCII_ARB) {
"glProgramStringARB(format)");
return;
}
if (target == GL_FRAGMENT_PROGRAM_ARB
&& g->extensions.ARB_fragment_program) {
prog = p->currentFragmentProgram;
}
else if (target == GL_VERTEX_PROGRAM_ARB
&& g->extensions.ARB_vertex_program) {
prog = p->currentVertexProgram;
}
else {
"glProgramStringARB(target)");
return;
}
if (!progCopy) {
return;
}
return;
}
}
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (g->current.inBeginEnd) {
return;
}
if (id == 0) {
"glGetProgramivNV(bad id)");
return;
}
if (!prog) {
"glGetProgramivNV(bad id)");
return;
}
switch (pname) {
case GL_PROGRAM_TARGET_NV:
return;
case GL_PROGRAM_LENGTH_NV:
return;
case GL_PROGRAM_RESIDENT_NV:
return;
default:
"glGetProgramivNV(pname)");
return;
}
}
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (pname != GL_PROGRAM_STRING_NV) {
"glGetProgramStringNV(pname)");
return;
}
if (g->current.inBeginEnd) {
return;
}
if (id == 0) {
"glGetProgramStringNV(bad id)");
return;
}
if (!prog) {
"glGetProgramStringNV(bad id)");
return;
}
}
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (target == GL_VERTEX_PROGRAM_ARB) {
prog = p->currentVertexProgram;
}
else if (target == GL_FRAGMENT_PROGRAM_ARB) {
prog = p->currentFragmentProgram;
}
else {
"glGetProgramStringNV(target)");
return;
}
if (pname != GL_PROGRAM_STRING_NV) {
"glGetProgramStringNV(pname)");
return;
}
if (g->current.inBeginEnd) {
return;
}
}
{
}
{
}
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (g->current.inBeginEnd) {
return;
}
if (target == GL_VERTEX_PROGRAM_NV) {
p->vertexParameters[index][0] = x;
}
else {
"glProgramParameterNV(index=%d)", index);
return;
}
}
else {
"glProgramParameterNV(target)");
return;
}
}
{
}
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (g->current.inBeginEnd) {
return;
}
if (target == GL_VERTEX_PROGRAM_NV) {
GLuint i;
for (i = 0; i < num; i++) {
}
}
else {
"glProgramParameters4dvNV(index+num)");
return;
}
}
else {
"glProgramParameterNV(target)");
return;
}
}
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (g->current.inBeginEnd) {
return;
}
if (target == GL_VERTEX_PROGRAM_NV) {
GLuint i;
for (i = 0; i < num; i++) {
}
}
else {
"glProgramParameters4dvNV(index+num)");
return;
}
}
else {
"glProgramParameterNV(target)");
return;
}
}
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (g->current.inBeginEnd) {
return;
}
if (target == GL_VERTEX_PROGRAM_NV) {
if (pname == GL_PROGRAM_PARAMETER_NV) {
}
else {
"glGetProgramParameterfvNV(index)");
return;
}
}
else {
"glGetProgramParameterfvNV(pname)");
return;
}
}
else {
"glGetProgramParameterfvNV(target)");
return;
}
}
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (g->current.inBeginEnd) {
return;
}
if (target == GL_VERTEX_PROGRAM_NV) {
if (pname == GL_PROGRAM_PARAMETER_NV) {
}
else {
"glGetProgramParameterdvNV(index)");
return;
}
}
else {
"glGetProgramParameterdvNV(pname)");
return;
}
}
else {
"glGetProgramParameterdvNV(target)");
return;
}
}
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (g->current.inBeginEnd) {
return;
}
if (target == GL_VERTEX_PROGRAM_NV) {
if (address & 0x3) {
/* addr must be multiple of four */
"glTrackMatrixNV(address)");
return;
}
switch (matrix) {
case GL_NONE:
case GL_MODELVIEW:
case GL_PROJECTION:
case GL_TEXTURE:
case GL_COLOR:
case GL_MATRIX0_NV:
case GL_MATRIX1_NV:
case GL_MATRIX2_NV:
case GL_MATRIX3_NV:
case GL_MATRIX4_NV:
case GL_MATRIX5_NV:
case GL_MATRIX6_NV:
case GL_MATRIX7_NV:
case GL_TEXTURE0_ARB:
case GL_TEXTURE1_ARB:
case GL_TEXTURE2_ARB:
case GL_TEXTURE3_ARB:
case GL_TEXTURE4_ARB:
case GL_TEXTURE5_ARB:
case GL_TEXTURE6_ARB:
case GL_TEXTURE7_ARB:
/* OK, fallthrough */
break;
default:
"glTrackMatrixNV(matrix = %x)",matrix);
return;
}
switch (transform) {
case GL_IDENTITY_NV:
case GL_INVERSE_NV:
case GL_TRANSPOSE_NV:
case GL_INVERSE_TRANSPOSE_NV:
/* OK, fallthrough */
break;
default:
"glTrackMatrixNV(transform = %x)",transform);
return;
}
}
else {
"glTrackMatrixNV(target = %x)",target);
}
}
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (g->current.inBeginEnd) {
return;
}
if (target == GL_VERTEX_PROGRAM_NV) {
"glGetTrackMatrixivNV(address)");
return;
}
if (pname == GL_TRACK_MATRIX_NV) {
}
else if (pname == GL_TRACK_MATRIX_TRANSFORM_NV) {
}
else {
"glGetTrackMatrixivNV(pname)");
return;
}
}
else {
"glGetTrackMatrixivNV(target)");
return;
}
}
{
params[0] = floatParams[0];
if (pname == GL_CURRENT_ATTRIB_NV) {
}
}
{
CRContext *g = GetCurrentContext();
if (g->current.inBeginEnd) {
return;
}
if (index >= CR_MAX_VERTEX_ATTRIBS) {
"glGetVertexAttribfvNV(index)");
return;
}
switch (pname) {
case GL_ATTRIB_ARRAY_SIZE_NV:
break;
break;
case GL_ATTRIB_ARRAY_TYPE_NV:
break;
case GL_CURRENT_ATTRIB_NV:
break;
default:
return;
}
}
{
if (pname == GL_CURRENT_ATTRIB_NV) {
}
}
{
CRContext *g = GetCurrentContext();
if (g->current.inBeginEnd) {
return;
}
if (index >= CR_MAX_VERTEX_ATTRIBS) {
"glGetVertexAttribfvARB(index)");
return;
}
switch (pname) {
break;
break;
break;
break;
break;
break;
default:
return;
}
}
{
if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) {
}
}
{
params[0] = floatParams[0];
if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) {
}
}
/**********************************************************************/
/*
* Added by GL_NV_fragment_program
*/
void STATE_APIENTRY crStateProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (g->current.inBeginEnd) {
return;
}
if (!prog) {
"glProgramNamedParameterNV(bad id %d)", id);
return;
}
"glProgramNamedParameterNV(target)");
return;
}
}
void STATE_APIENTRY crStateProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
crStateProgramNamedParameter4fNV(id, len, name, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
}
void STATE_APIENTRY crStateProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte *name, const GLfloat v[])
{
}
void STATE_APIENTRY crStateProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte *name, const GLdouble v[])
{
crStateProgramNamedParameter4fNV(id, len, name, (GLfloat) v[0], (GLfloat) v[1], (GLfloat) v[2], (GLfloat) v[3]);
}
void STATE_APIENTRY crStateGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte *name, GLfloat *params)
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (g->current.inBeginEnd) {
return;
}
if (!prog) {
"glGetProgramNamedParameterNV(bad id)");
return;
}
"glGetProgramNamedParameterNV(target)");
return;
}
if (!value) {
"glGetProgramNamedParameterNV(name)");
return;
}
}
void STATE_APIENTRY crStateGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte *name, GLdouble *params)
{
params[0] = floatParams[0];
}
void STATE_APIENTRY crStateProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
crStateProgramLocalParameter4fARB(target, index, (GLfloat) x, (GLfloat) y, (GLfloat) z, (GLfloat) w);
}
void STATE_APIENTRY crStateProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble *params)
{
}
void STATE_APIENTRY crStateProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (g->current.inBeginEnd) {
return;
}
if (index >= CR_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMS) {
"glProgramLocalParameterARB(index)");
return;
}
prog = p->currentFragmentProgram;
}
else if (target == GL_VERTEX_PROGRAM_ARB) {
if (index >= CR_MAX_VERTEX_PROGRAM_LOCAL_PARAMS) {
"glProgramLocalParameterARB(index)");
return;
}
prog = p->currentVertexProgram;
}
else {
"glProgramLocalParameterARB(target)");
return;
}
}
void STATE_APIENTRY crStateProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat *params)
{
}
void STATE_APIENTRY crStateGetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat *params)
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (g->current.inBeginEnd) {
return;
}
prog = p->currentFragmentProgram;
"glGetProgramLocalParameterARB(index)");
return;
}
}
prog = p->currentVertexProgram;
"glGetProgramLocalParameterARB(index)");
return;
}
}
else {
"glGetProgramLocalParameterARB(target)");
return;
}
if (!prog) {
"glGetProgramLocalParameterARB(no program)");
return;
}
if (!prog) {
"glGetProgramLocalParameterARB(no program)");
return;
}
}
void STATE_APIENTRY crStateGetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble *params)
{
params[0] = floatParams[0];
}
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (g->current.inBeginEnd) {
return;
}
if (target == GL_VERTEX_PROGRAM_ARB) {
prog = p->currentVertexProgram;
}
else if (target == GL_FRAGMENT_PROGRAM_ARB) {
prog = p->currentFragmentProgram;
}
else {
"glGetProgramivARB(target)");
return;
}
switch (pname) {
case GL_PROGRAM_LENGTH_ARB:
break;
case GL_PROGRAM_FORMAT_ARB:
break;
case GL_PROGRAM_BINDING_ARB:
break;
break;
if (target == GL_VERTEX_PROGRAM_ARB)
else
break;
break;
if (target == GL_VERTEX_PROGRAM_ARB)
else
break;
break;
if (target == GL_VERTEX_PROGRAM_ARB)
else
break;
/* XXX same as GL_PROGRAM_TEMPORARIES_ARB? */
break;
/* XXX same as GL_MAX_PROGRAM_TEMPORARIES_ARB? */
if (target == GL_VERTEX_PROGRAM_ARB)
else
break;
break;
if (target == GL_VERTEX_PROGRAM_ARB)
else
break;
/* XXX same as GL_MAX_PROGRAM_PARAMETERS_ARB? */
break;
/* XXX same as GL_MAX_PROGRAM_PARAMETERS_ARB? */
if (target == GL_VERTEX_PROGRAM_ARB)
else
break;
case GL_PROGRAM_ATTRIBS_ARB:
break;
if (target == GL_VERTEX_PROGRAM_ARB)
else
break;
/* XXX same as GL_PROGRAM_ATTRIBS_ARB? */
break;
/* XXX same as GL_MAX_PROGRAM_ATTRIBS_ARB? */
if (target == GL_VERTEX_PROGRAM_ARB)
else
break;
break;
if (target == GL_VERTEX_PROGRAM_ARB)
else
break;
/* XXX same as GL_PROGRAM_ADDRESS_REGISTERS_ARB? */
break;
/* XXX same as GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB? */
if (target == GL_VERTEX_PROGRAM_ARB)
else
break;
if (target == GL_VERTEX_PROGRAM_ARB)
else
break;
if (target == GL_VERTEX_PROGRAM_ARB)
else
break;
/* XXX ok? */
break;
/*
* These are for fragment programs only
*/
"crStateGetProgramivARB(target or pname)");
return;
}
break;
"crStateGetProgramivARB(target or pname)");
return;
}
break;
"crStateGetProgramivARB(target or pname)");
return;
}
break;
/* XXX same as GL_PROGRAM_ALU_INSTRUCTIONS_ARB? */
"crStateGetProgramivARB(target or pname)");
return;
}
break;
/* XXX same as GL_PROGRAM_ALU_INSTRUCTIONS_ARB? */
"crStateGetProgramivARB(target or pname)");
return;
}
break;
"crStateGetProgramivARB(target or pname)");
return;
}
break;
"crStateGetProgramivARB(target or pname)");
return;
}
break;
"crStateGetProgramivARB(target or pname)");
return;
}
break;
"crStateGetProgramivARB(target or pname)");
return;
}
break;
default:
"crStateGetProgramivARB(pname)");
return;
}
}
/* XXX maybe move these two functions into state_client.c? */
{
CRContext *g = GetCurrentContext();
CRClientState *c = &(g->client);
"glDisableVertexAttribArrayARB(index)");
return;
}
}
{
CRContext *g = GetCurrentContext();
CRClientState *c = &(g->client);
"glEnableVertexAttribArrayARB(index)");
return;
}
}
void STATE_APIENTRY crStateGetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble *params)
{
}
void STATE_APIENTRY crStateGetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat *params)
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (g->current.inBeginEnd) {
return;
}
"glGetProgramEnvParameterARB(index)");
return;
}
}
"glGetProgramEnvParameterARB(index)");
return;
}
}
else {
"glGetProgramEnvParameterARB(target)");
return;
}
}
void STATE_APIENTRY crStateProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
}
void STATE_APIENTRY crStateProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble *params)
{
crStateProgramEnvParameter4fARB(target, index, (GLfloat) params[0], (GLfloat) params[1], (GLfloat) params[2], (GLfloat) params[3]);
}
void STATE_APIENTRY crStateProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
CRContext *g = GetCurrentContext();
CRProgramState *p = &(g->program);
if (g->current.inBeginEnd) {
return;
}
"glProgramEnvParameterARB(index)");
return;
}
p->fragmentParameters[index][0] = x;
}
"glProgramEnvParameterARB(index)");
return;
}
p->vertexParameters[index][0] = x;
}
else {
"glProgramEnvParameterARB(target)");
return;
}
}
void STATE_APIENTRY crStateProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat *params)
{
}
/**********************************************************************/
{
GLuint i;
p->programHash = crAllocHashtable();
/* ARB_vertex/fragment_program define default program objects */
p->currentVertexProgram = p->defaultVertexProgram;
p->errorPos = -1;
p->errorString = NULL;
p->TrackMatrix[i] = GL_NONE;
p->TrackMatrixTransform[i] = GL_IDENTITY_NV;
}
p->vertexParameters[i][0] = 0.0;
}
for (i = 0; i < CR_MAX_FRAGMENT_PROGRAM_ENV_PARAMS; i++) {
p->fragmentParameters[i][0] = 0.0;
}
p->fpEnabledARB = GL_FALSE;
p->vpPointSize = GL_FALSE;
}
static void DeleteProgramCallback( void *data )
{
}
{
}
/* XXX it would be nice to autogenerate this, but we can't for now.
*/
void
{
unsigned int i, j;
for (j=0;j<CR_MAX_BITARRAY;j++)
/* vertex program enable */
if (toProg->isARBprogram)
else
}
}
}
}
/* fragment program enable */
}
}
}
to->TrackMatrix[i],
to->TrackMatrixTransform[i]);
}
}
}
}
/* vertex program binding */
if (toProg->isARBprogram)
else
}
}
if (toProg) {
/* vertex program text */
if (toProg->isARBprogram) {
}
else {
}
}
if (toProg->isARBprogram)
to->vertexParameters[i]);
else
to->vertexParameters[i]);
if (fromProg) {
to->vertexParameters[i]);
}
}
}
}
/* vertex program local parameters */
if (toProg->isARBprogram)
else
}
}
}
}
}
/*
* Separate paths for NV vs ARB fragment program
*/
/* NV fragment program binding */
}
}
if (toProg) {
/* fragment program text */
}
to->fragmentParameters[i]);
if (fromProg) {
to->fragmentParameters[i]);
}
}
}
}
/* named local parameters */
if (fromProg) {
}
}
}
}
/* numbered local parameters */
for (i = 0; i < CR_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMS; i++) {
toProg->parameters[i]);
if (fromProg) {
}
}
}
}
}
}
else if (to->fpEnabledARB) {
/* ARB fragment program binding */
}
}
if (toProg) {
/* fragment program text */
}
to->fragmentParameters[i]);
if (fromProg) {
to->fragmentParameters[i]);
}
}
}
}
/* numbered local parameters */
for (i = 0; i < CR_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMS; i++) {
toProg->parameters[i]);
if (fromProg) {
}
}
}
}
}
}
}
void
{
unsigned int i, j;
GLenum whichVert = fromCtx->extensions.ARB_vertex_program && toCtx->extensions.ARB_vertex_program ? GL_VERTEX_PROGRAM_ARB : GL_VERTEX_PROGRAM_NV;
for (j=0;j<CR_MAX_BITARRAY;j++)
/* vertex program enable */
}
}
}
}
/* fragment program enable */
}
}
}
to->TrackMatrix[i],
to->TrackMatrixTransform[i]);
}
}
}
}
/* vertex program binding */
if (toProg->isARBprogram)
else
}
}
if (toProg) {
/* vertex program text */
if (toProg->isARBprogram)
else
}
if (toProg->isARBprogram)
else
}
}
}
/* vertex program local parameters */
if (toProg->isARBprogram)
else
}
}
}
}
}
/*
* Separate paths for NV vs ARB fragment program
*/
/* NV fragment program binding */
}
}
if (toProg) {
/* fragment program text */
}
to->fragmentParameters[i]);
}
}
}
/* named local parameters */
}
}
}
/* numbered local parameters */
for (i = 0; i < CR_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMS; i++) {
if (toProg->isARBprogram)
else
}
}
}
}
}
else if (to->fpEnabledARB) {
/* ARB fragment program binding */
}
}
if (toProg) {
/* fragment program text */
}
}
}
}
/* numbered local parameters */
for (i = 0; i < CR_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMS; i++) {
}
}
}
}
}
/* Resend program data */
{
}
}
/*@todo support NVprograms and add some data validity checks*/
static void
{
uint32_t i;
if (pProgram->isARBprogram)
{
{
{
diff_api.ProgramEnvParameter4fvARB(GL_VERTEX_PROGRAM_ARB, i, pContext->program.vertexParameters[i]);
}
/* vertex program local parameters */
{
}
}
{
{
diff_api.ProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, i, pContext->program.fragmentParameters[i]);
}
/* vertex program local parameters */
for (i = 0; i < CR_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMS; i++)
{
}
}
else
{
crError("Unexpected program target");
}
}
else
{
}
}
{
(void) bForceUpdate;
/* save original bindings */
/* restore original bindings */
if (pOrigVP->isARBprogram)
else
if (pOrigFP->isARBprogram)
else
}