void init_brush(int i)
{
struct brush *b = get_brush(i);
if (b->state == 0)
{
int p;
/* Initialize and vertex and fragment shaders and uniforms. */
if (GL_has_shader_objects)
{
if (b->vert_text)
b->vert_shad = opengl_shader_object(GL_VERTEX_SHADER_ARB,
b->vert_text);
if (b->frag_text)
b->frag_shad = opengl_shader_object(GL_FRAGMENT_SHADER_ARB,
b->frag_text);
if (b->vert_shad || b->frag_shad)
b->shad_prog = opengl_program_object(b->vert_shad,
b->frag_shad);
if (b->shad_prog && b->uniform)
for (p = 0; p < vecnum(b->uniform); ++p)
use_uniform(b, (struct uniform *) vecget(b->uniform, p));
}
/* Initialize any vertex program and parameters. */
if (b->vert && GL_has_vertex_program)
{
b->vert_prog = opengl_vert_prog(b->vert);
for (p = 0; p < MAX_PARAM; ++p)
glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB,
p, b->vert_param[p]);
}
/* Initialize any fragment program and parameters. */
if (b->frag && GL_has_fragment_program)
{
b->frag_prog = opengl_frag_prog(b->frag);
for (p = 0; p < MAX_PARAM; ++p)
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB,
p, b->frag_param[p]);
}
b->state = 1;
}
}
static void
arbfvp_draw_from_brick(trixel_state t, trixel_brick * brick)
{
struct arbfvp_shaders * shaders = ARBFVP(t);
glEnable(GL_VERTEX_PROGRAM_ARB);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, shaders->vertex_program);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, shaders->fragment_program);
glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, ARBFVP_VERTEX_VOXMAP_SIZE_INV, (GLfloat*)&brick->dimensions_inv);
glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, ARBFVP_VERTEX_NORMAL_SCALE, (GLfloat*)&brick->normal_scale);
glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, ARBFVP_VERTEX_NORMAL_TRANSLATE, (GLfloat*)&brick->normal_translate);
}
void APIENTRY _my_glProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, const GLfloat* params)
{
for ( int i=0; i<count; i++ )
{
glProgramLocalParameter4fvARB(target, index+i, params + 4*i);
}
}
static void
arbfvp_set_light_param(trixel_state t, GLuint light, int param, GLfloat * value)
{
// XXX multiple lights?
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, ARBFVP(t)->fragment_program);
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, param, value);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, 0);
}
/*
====================
BindForViewOrigin
====================
*/
void idMegaTexture::BindForViewOrigin( const idVec3 viewOrigin ) {
SetViewOrigin( viewOrigin );
// borderClamp image goes in texture 0
//GL_SelectTexture( 0 );
globalImages->borderClampImage->Bind(0);
// level images in higher textures, blurriest first
for ( int i = 0 ; i < 7 ; i++ ) {
//GL_SelectTexture( 1+i );
if ( i >= numLevels ) {
globalImages->whiteImage->Bind( 1+i );
static float parms[4] = { -2, -2, 0, 1 }; // no contribution
glProgramLocalParameter4fvARB( GL_VERTEX_PROGRAM_ARB, i, parms );
} else {
idTextureLevel *level = &levels[ numLevels-1-i ];
if ( r_showMegaTexture.GetBool() ) {
if ( i & 1 ) {
globalImages->blackImage->Bind( 1+i );
} else {
globalImages->whiteImage->Bind( 1+i );
}
} else {
level->image->Bind( 1+i );
}
glProgramLocalParameter4fvARB( GL_VERTEX_PROGRAM_ARB, i, level->parms );
}
}
float parms[4];
parms[0] = 0;
parms[1] = 0;
parms[2] = 0;
parms[3] = 1;
glProgramLocalParameter4fvARB( GL_VERTEX_PROGRAM_ARB, 7, parms );
parms[0] = 1;
parms[1] = 1;
parms[2] = r_terrainScale.GetFloat();
parms[3] = 1;
glProgramLocalParameter4fvARB( GL_VERTEX_PROGRAM_ARB, 8, parms );
}
void GPUProgram::BindingTable::arbBind(GLenum target) const {
for (int b = 0; b < bindingArray.size(); ++b) {
const Binding& binding = bindingArray[b];
if ((binding.source == CONSTANT) && (binding.type == FLOAT4)) {
glProgramLocalParameter4fvARB(target, binding.slot, binding.vector);
}
}
}
void GPUProgram::loadConstant(int slot, const Vector4& value) const {
switch (extension) {
case NVIDIA:
glProgramParameter4fvNV(unit, slot, value);
break;
case ARB:
glProgramLocalParameter4fvARB(unit, slot, value);
break;
}
}
void GLArbGpuProgram::bindProgramPassIterationParameters(GpuProgramParametersSharedPtr params)
{
if (params->hasPassIterationNumber())
{
GLenum type = getGLShaderType(mType);
size_t physicalIndex = params->getPassIterationNumberIndex();
size_t logicalIndex = params->getFloatLogicalIndexForPhysicalIndex(physicalIndex);
const float* pFloat = params->getFloatPointer(physicalIndex);
glProgramLocalParameter4fvARB(type, (GLuint)logicalIndex, pFloat);
}
}
void recv_set_brush_vert_param(void)
{
struct brush *b = get_brush(recv_index());
int p = recv_index();
recv_array(b->vert_param[p], 4, sizeof (float));
if (b->vert_prog && GL_has_vertex_program)
{
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, b->vert_prog);
glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB,
p, b->vert_param[p]);
}
}
void recv_set_brush_frag_param(void)
{
struct brush *b = get_brush(recv_index());
int p = recv_index();
recv_array(b->frag_param[p], 4, sizeof (float));
if (b->frag_prog && GL_has_fragment_program)
{
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, b->frag_prog);
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB,
p, b->frag_param[p]);
}
}
void send_set_brush_vert_param(int i, int p, const float v[4])
{
struct brush *b = get_brush(i);
b->vert_param[p][0] = v[0];
b->vert_param[p][1] = v[1];
b->vert_param[p][2] = v[2];
b->vert_param[p][3] = v[3];
send_event(EVENT_SET_BRUSH_VERT_PARAM);
send_index(i);
send_index(p);
send_array(b->vert_param[p], 4, sizeof (float));
if (b->vert_prog && GL_has_vertex_program)
{
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, b->vert_prog);
glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB,
p, b->vert_param[p]);
}
}
void GLArbGpuProgram::bindProgramParameters(GpuProgramParametersSharedPtr params, uint16 mask)
{
GLenum type = getGLShaderType(mType);
// only supports float constants
GpuLogicalBufferStructPtr floatStruct = params->getFloatLogicalBufferStruct();
for (GpuLogicalIndexUseMap::const_iterator i = floatStruct->map.begin();
i != floatStruct->map.end(); ++i)
{
if (i->second.variability & mask)
{
size_t logicalIndex = i->first;
const float* pFloat = params->getFloatPointer(i->second.physicalIndex);
// Iterate over the params, set in 4-float chunks (low-level)
for (size_t j = 0; j < i->second.currentSize; j+=4)
{
glProgramLocalParameter4fvARB(type, logicalIndex, pFloat);
pFloat += 4;
++logicalIndex;
}
}
}
}
void
VertexProgramTest::setup(void)
{
// setup Infinity, Nan values
int nan;
float *nanPtr;
nan = (0xff << 23) | (1 << 0);
nanPtr = (float *) &nan;
InfNan[0] = HUGE_VAL;
InfNan[1] = -HUGE_VAL;
InfNan[2] = (float) (*nanPtr);
InfNan[3] = 1.0 / HUGE_VAL;
/*
printf("InfNan = %f %f %f %f\n",
InfNan[0], InfNan[1], InfNan[2], InfNan[3]);
*/
glGenProgramsARB(1, &progID);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, progID);
glEnable(GL_VERTEX_PROGRAM_ARB);
// load program inputs
glColor4fv(VertColor);
glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 0, Param0);
glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 1, Param1);
glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 2, Param2);
glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, 9, InfNan);
// other GL state
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, Ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, Diffuse);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, VertColor);
glFogf(GL_FOG_DENSITY, FogDensity);
glFogf(GL_FOG_START, FogStart);
glFogf(GL_FOG_END, FogEnd);
GLenum err = glGetError();
assert(!err); // should be OK
// setup vertex transform (we'll draw a quad in middle of window)
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-4.0, 4.0, -4.0, 4.0, 0.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glDrawBuffer(GL_FRONT);
glReadBuffer(GL_FRONT);
// compute error tolerances (may need fine-tuning)
int bufferBits[5];
glGetIntegerv(GL_RED_BITS, &bufferBits[0]);
glGetIntegerv(GL_GREEN_BITS, &bufferBits[1]);
glGetIntegerv(GL_BLUE_BITS, &bufferBits[2]);
glGetIntegerv(GL_ALPHA_BITS, &bufferBits[3]);
glGetIntegerv(GL_DEPTH_BITS, &bufferBits[4]);
tolerance[0] = 2.0 / (1 << bufferBits[0]);
tolerance[1] = 2.0 / (1 << bufferBits[1]);
tolerance[2] = 2.0 / (1 << bufferBits[2]);
if (bufferBits[3])
tolerance[3] = 2.0 / (1 << bufferBits[3]);
else
tolerance[3] = 1.0;
if (bufferBits[4])
tolerance[4] = 16.0 / (1 << bufferBits[4]);
else
tolerance[4] = 1.0;
// Some tests request a looser tolerance:
// XXX a factor of 4 may be too much...
for (int i = 0; i < 5; i++)
looseTolerance[i] = 4.0 * tolerance[i];
}
void Viewer::renderModel()
{
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, m_vertexProgramId );
glEnableVertexAttribArrayARB(0);
glEnableVertexAttribArrayARB(1);
glEnableVertexAttribArrayARB(2);
glEnableVertexAttribArrayARB(3);
glEnableVertexAttribArrayARB(8);
glEnable(GL_TEXTURE_2D);
// set global OpenGL states
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_VERTEX_PROGRAM_ARB);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_bufferObject[0]);
glVertexAttribPointerARB(0, 3 , GL_FLOAT, false, 0, NULL);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_bufferObject[1]);
glVertexAttribPointerARB(1, 4 , GL_FLOAT, false, 0, NULL);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_bufferObject[2]);
glVertexAttribPointerARB(2, 3 , GL_FLOAT, false, 0, NULL);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_bufferObject[3]);
glVertexAttribPointerARB(3, 4 , GL_FLOAT, false, 0, NULL);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_bufferObject[4]);
glVertexAttribPointerARB(8, 2 , GL_FLOAT, false, 0, NULL);
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, m_bufferObject[5]);
int hardwareMeshId;
for(hardwareMeshId=0;hardwareMeshId<m_calHardwareModel->getHardwareMeshCount() ; hardwareMeshId++)
{
m_calHardwareModel->selectHardwareMesh(hardwareMeshId);
unsigned char meshColor[4];
float materialColor[4];
// set the material ambient color
m_calHardwareModel->getAmbientColor(&meshColor[0]);
materialColor[0] = meshColor[0] / 255.0f; materialColor[1] = meshColor[1] / 255.0f; materialColor[2] = meshColor[2] / 255.0f; materialColor[3] = meshColor[3] / 255.0f;
glMaterialfv(GL_FRONT, GL_AMBIENT, materialColor);
// set the material diffuse color
m_calHardwareModel->getDiffuseColor(&meshColor[0]);
materialColor[0] = meshColor[0] / 255.0f; materialColor[1] = meshColor[1] / 255.0f; materialColor[2] = meshColor[2] / 255.0f; materialColor[3] = meshColor[3] / 255.0f;
glMaterialfv(GL_FRONT, GL_DIFFUSE, materialColor);
// set the material specular color
m_calHardwareModel->getSpecularColor(&meshColor[0]);
materialColor[0] = meshColor[0] / 255.0f; materialColor[1] = meshColor[1] / 255.0f; materialColor[2] = meshColor[2] / 255.0f; materialColor[3] = meshColor[3] / 255.0f;
glMaterialfv(GL_FRONT, GL_SPECULAR, materialColor);
// set the material shininess factor
float shininess;
shininess = 50.0f; //m_calHardwareModel->getShininess();
glMaterialfv(GL_FRONT, GL_SHININESS, &shininess);
int boneId;
for(boneId = 0; boneId < m_calHardwareModel->getBoneCount(); boneId++)
{
CalQuaternion rotationBoneSpace = m_calHardwareModel->getRotationBoneSpace(boneId, m_calModel->getSkeleton());
CalVector translationBoneSpace = m_calHardwareModel->getTranslationBoneSpace(boneId, m_calModel->getSkeleton());
CalMatrix rotationMatrix = rotationBoneSpace;
float transformation[12];
transformation[0]=rotationMatrix.dxdx;transformation[1]=rotationMatrix.dxdy;transformation[2]=rotationMatrix.dxdz;transformation[3]=translationBoneSpace.x;
transformation[4]=rotationMatrix.dydx;transformation[5]=rotationMatrix.dydy;transformation[6]=rotationMatrix.dydz;transformation[7]=translationBoneSpace.y;
transformation[8]=rotationMatrix.dzdx;transformation[9]=rotationMatrix.dzdy;transformation[10]=rotationMatrix.dzdz;transformation[11]=translationBoneSpace.z;
glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB,boneId*3,&transformation[0]);
glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB,boneId*3+1,&transformation[4]);
glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB,boneId*3+2,&transformation[8]);
// set the texture id we stored in the map user data
glBindTexture(GL_TEXTURE_2D, (GLuint)(size_t)m_calHardwareModel->getMapUserData(0));
}
if(sizeof(CalIndex)==2)
glDrawElements(GL_TRIANGLES, m_calHardwareModel->getFaceCount() * 3, GL_UNSIGNED_SHORT, (((CalIndex *)NULL)+ m_calHardwareModel->getStartIndex()));
else
glDrawElements(GL_TRIANGLES, m_calHardwareModel->getFaceCount() * 3, GL_UNSIGNED_INT, (((CalIndex *)NULL)+ m_calHardwareModel->getStartIndex()));
}
// clear vertex array state
glDisableVertexAttribArrayARB(0);
glDisableVertexAttribArrayARB(1);
glDisableVertexAttribArrayARB(2);
glDisableVertexAttribArrayARB(3);
glDisableVertexAttribArrayARB(8);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
// clear light
glDisable(GL_LIGHTING);
glDisable(GL_LIGHT0);
glDisable(GL_DEPTH_TEST);
glDisable(GL_VERTEX_PROGRAM_ARB);
glBindProgramARB( GL_VERTEX_PROGRAM_ARB, 0 );
}
inline void FragmentProgram::localParameter(GLuint index, const math::Matrix<4, 1, float> &vec)
{
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, index, &vec[0]);
}
inline void VertexProgram::localParameter(GLuint index, const math::Matrix<4, 1, float> &vec)
{
glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, index, &vec[0]);
}
/////////////////////////////////////////////////////////
// Render
//
void GEMglProgramLocalParameter4fvARB :: render(GemState *state) {
glProgramLocalParameter4fvARB (target, index, params);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglProgramLocalParameter4fvARB(JNIEnv *env, jclass clazz, jint target, jint index, jlong params, jlong function_pointer) {
const GLfloat *params_address = (const GLfloat *)(intptr_t)params;
glProgramLocalParameter4fvARBPROC glProgramLocalParameter4fvARB = (glProgramLocalParameter4fvARBPROC)((intptr_t)function_pointer);
glProgramLocalParameter4fvARB(target, index, params_address);
}
PIGLIT_GL_TEST_CONFIG_END
void
piglit_init(int argc, char **argv)
{
const char *source =
"!!ARBvp1.0\n"
"OPTION ARB_position_invariant;\n"
"MOV result.color, program.local[3];\n"
"END\n";
GLuint prog;
GLint max_local;
GLint i;
piglit_require_extension("GL_ARB_vertex_program");
prog = piglit_compile_program(GL_VERTEX_PROGRAM_ARB, source);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog);
glGetProgramivARB(GL_VERTEX_PROGRAM_ARB,
GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, &max_local);
/* Limit the test to blowing through 256MB of memory. */
max_local = MIN2(max_local, 1024 * 1024 * 16);
for (i = 0; i < max_local; i++) {
float values[4];
values[0] = i * 4;
values[1] = i * 4 + 1;
values[2] = i * 4 + 2;
values[3] = i * 4 + 3;
glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, i, values);
}
for (i = 0; i < max_local; i++) {
float values[4], get_values[4];
glGetProgramLocalParameterfvARB(GL_VERTEX_PROGRAM_ARB, i,
get_values);
values[0] = i * 4;
values[1] = i * 4 + 1;
values[2] = i * 4 + 2;
values[3] = i * 4 + 3;
if (memcmp(values, get_values, sizeof(values)) != 0) {
fprintf(stderr, "Difference on "
"glGetProgramLocalParameterfvARB(%d):\n", i);
fprintf(stderr, "expected: %f %f %f %f\n",
values[0],
values[1],
values[2],
values[3]);
fprintf(stderr, "found: %f %f %f %f\n",
get_values[0],
get_values[1],
get_values[2],
get_values[3]);
piglit_report_result(PIGLIT_FAIL);
}
}
piglit_report_result(PIGLIT_PASS);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBProgram_nglProgramLocalParameter4fvARB(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) {
const GLfloat *params_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position;
glProgramLocalParameter4fvARBPROC glProgramLocalParameter4fvARB = (glProgramLocalParameter4fvARBPROC)((intptr_t)function_pointer);
glProgramLocalParameter4fvARB(target, index, params_address);
}
static void DoFrame(void)
{
static float Local[3][4] = {
{ 1.0, 0.8, 1.0, 1.0 },
{ 0.5, 0.5, 0.5, 1.0 },
{ 1.0, 0.0, 0.0, 1.0 }
};
static float Local2[3][4] = {
{ 0.8, 1.0, 1.0, 1.0 },
{ 0.5, 0.5, 0.5, 1.0 },
{ 1.0, 0.0, 1.0, 1.0 }
};
int i;
glClearColor(0.8, 0.8, 0.8, 0.8);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TexDiffuse);
glEnable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, TexNormal);
glEnable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, TexSpecular);
glEnable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, TexLookup);
glEnable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE4);
glBindTexture(GL_TEXTURE_2D, TexLookup);
glEnable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE5);
glBindTexture(GL_TEXTURE_2D, TexLookup);
glEnable(GL_TEXTURE_2D);
glMultiTexCoord2f(GL_TEXTURE0, 0.0, 0.0);
glMultiTexCoord2f(GL_TEXTURE1, 0.0, 0.0);
glMultiTexCoord2f(GL_TEXTURE2, 0.0, 0.0);
glMultiTexCoord3f(GL_TEXTURE3, 0.0, 0.05, 0.25);
glMultiTexCoord3f(GL_TEXTURE4, 4, -3, 0);
glMultiTexCoord3f(GL_TEXTURE5, 0, 3, 4);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
for(i = 0; i < 3; ++i)
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, i, Local[i]);
glBegin(GL_QUADS);
glVertex2f(0.75, 0.75);
glVertex2f(0.25, 0.75);
glVertex2f(0.25, 0.25);
glVertex2f(0.75, 0.25);
glEnd();
glEnable(GL_FRAGMENT_PROGRAM_ARB);
for(i = 0; i < 3; ++i)
glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, i, Local2[i]);
glBegin(GL_QUADS);
glVertex2f(1.75, 0.75);
glVertex2f(1.25, 0.75);
glVertex2f(1.25, 0.25);
glVertex2f(1.75, 0.25);
glEnd();
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexProgram_nglProgramLocalParameter4fvARB__IIJ(JNIEnv *__env, jclass clazz, jint target, jint index, jlong paramsAddress) {
glProgramLocalParameter4fvARBPROC glProgramLocalParameter4fvARB = (glProgramLocalParameter4fvARBPROC)tlsGetFunction(1387);
intptr_t params = (intptr_t)paramsAddress;
UNUSED_PARAM(clazz)
glProgramLocalParameter4fvARB(target, index, params);
}
void Shader::bind() {
if(old_shader != this) {
if(vertex_target == GL_VERTEX_PROGRAM_ARB) glBindProgramARB(vertex_target,vertex_id);
if(fragment_target == GL_FRAGMENT_PROGRAM_ARB) glBindProgramARB(fragment_target,fragment_id);
else if(fragment_target == GL_FRAGMENT_PROGRAM_NV) glBindProgramNV(fragment_target,fragment_id);
else if(fragment_target == GL_COMBINE) glCallList(fragment_id);
old_shader = this;
}
for(int i = 0; i < num_matrixes; i++) {
glMatrixMode(GL_MATRIX0_ARB + matrixes[i].num);
if(matrixes[i].type == PROJECTION) glLoadMatrixf(Engine::projection);
else if(matrixes[i].type == MODELVIEW) glLoadMatrixf(Engine::modelview);
else if(matrixes[i].type == IMODELVIEW) glLoadMatrixf(Engine::imodelview);
else if(matrixes[i].type == TRANSFORM) glLoadMatrixf(Engine::transform);
else if(matrixes[i].type == ITRANSFORM) glLoadMatrixf(Engine::itransform);
else if(matrixes[i].type == LIGHT_TRANSFORM && Engine::current_light) glLoadMatrixf(Engine::current_light->transform);
}
if(num_matrixes) glMatrixMode(GL_MODELVIEW);
for(int i = 0; i < num_vertex_parameters; i++) {
if(vertex_parameters[i].type == TIME) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,vec4(Engine::time,Engine::time / 2.0f,Engine::time / 3.0f,Engine::time / 5.0f));
else if(vertex_parameters[i].type == SIN) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,vec4(sin(Engine::time),sin(Engine::time / 2.0f),sin(Engine::time / 3.0f),sin(Engine::time / 5.0f)));
else if(vertex_parameters[i].type == COS) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,vec4(cos(Engine::time),cos(Engine::time / 2.0f),cos(Engine::time / 3.0f),cos(Engine::time / 5.0f)));
else if(vertex_parameters[i].type == CAMERA) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,vec4(Engine::camera,1));
else if(vertex_parameters[i].type == ICAMERA) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,vec4(Engine::itransform * Engine::camera,1));
else if(vertex_parameters[i].type == LIGHT) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,Engine::light);
else if(vertex_parameters[i].type == ILIGHT) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,vec4(Engine::itransform * vec3(Engine::light),Engine::light.w));
else if(vertex_parameters[i].type == LIGHT_COLOR) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,Engine::light_color);
else if(vertex_parameters[i].type == FOG_COLOR) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,Engine::fog_color);
else if(vertex_parameters[i].type == VIEWPORT) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,vec4(Engine::viewport[0],Engine::viewport[1],Engine::viewport[2],Engine::viewport[3]));
else if(vertex_parameters[i].type == PARAMETER) glProgramLocalParameter4fvARB(vertex_target,vertex_parameters[i].num,parameters[vertex_parameters[i].parameter]);
}
for(int i = 0; i < num_fragment_parameters; i++) {
if(vertex_parameters[i].type == TIME) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,vec4(Engine::time,Engine::time / 2.0f,Engine::time / 3.0f,Engine::time / 5.0f));
else if(vertex_parameters[i].type == SIN) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,vec4(sin(Engine::time),sin(Engine::time / 2.0f),sin(Engine::time / 3.0f),sin(Engine::time / 5.0f)));
else if(vertex_parameters[i].type == COS) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,vec4(cos(Engine::time),cos(Engine::time / 2.0f),cos(Engine::time / 3.0f),cos(Engine::time / 5.0f)));
else if(fragment_parameters[i].type == CAMERA) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,vec4(Engine::camera,1));
else if(fragment_parameters[i].type == ICAMERA) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,vec4(Engine::itransform * Engine::camera,1));
else if(fragment_parameters[i].type == LIGHT) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,Engine::light);
else if(fragment_parameters[i].type == ILIGHT) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,vec4(Engine::itransform * vec3(Engine::light),Engine::light.w));
else if(fragment_parameters[i].type == LIGHT_COLOR) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,Engine::light_color);
else if(fragment_parameters[i].type == FOG_COLOR) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,Engine::fog_color);
else if(fragment_parameters[i].type == VIEWPORT) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,vec4(Engine::viewport[0],Engine::viewport[1],Engine::viewport[2],Engine::viewport[3]));
else if(fragment_parameters[i].type == PARAMETER) glProgramLocalParameter4fvARB(fragment_target,fragment_parameters[i].num,parameters[fragment_parameters[i].parameter]);
}
}
