X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Fnvprogram.c;h=dd198b8141ab76108039181758f777d31388f8cc;hb=dde3270c19143b42a55a93e1e85bb24194462671;hp=db95638e263478055e5e2b69809324d341f189b3;hpb=aa00d122b81a118eca3b43c66f17d988b1aa62d3;p=mesa.git diff --git a/src/mesa/main/nvprogram.c b/src/mesa/main/nvprogram.c index db95638e263..dd198b8141a 100644 --- a/src/mesa/main/nvprogram.c +++ b/src/mesa/main/nvprogram.c @@ -1,8 +1,8 @@ /* * Mesa 3-D graphics library - * Version: 5.1 + * Version: 6.5.2 * - * Copyright (C) 1999-2003 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2006 Brian Paul All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), @@ -28,20 +28,28 @@ * \author Brian Paul */ +/* + * Regarding GL_NV_fragment/vertex_program, GL_NV_vertex_program1_1, etc: + * + * Portions of this software may use or implement intellectual + * property owned and licensed by NVIDIA Corporation. NVIDIA disclaims + * any and all warranties with respect to such intellectual property, + * including any use thereof or modifications thereto. + */ -#include "glheader.h" -#include "context.h" -#include "hash.h" -#include "imports.h" -#include "macros.h" -#include "mtypes.h" -#include "nvfragparse.h" -#include "nvfragprog.h" -#include "nvvertexec.h" -#include "nvvertparse.h" -#include "nvvertprog.h" -#include "nvprogram.h" -#include "program.h" +#include "main/glheader.h" +#include "main/context.h" +#include "main/hash.h" +#include "main/imports.h" +#include "main/macros.h" +#include "main/mtypes.h" +#include "main/nvprogram.h" +#include "program/arbprogparse.h" +#include "program/nvfragparse.h" +#include "program/nvvertparse.h" +#include "program/program.h" +#include "program/prog_instruction.h" +#include "program/prog_parameter.h" @@ -49,10 +57,10 @@ * Execute a vertex state program. * \note Called from the GL API dispatcher. */ -void +void GLAPIENTRY _mesa_ExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params) { - struct vertex_program *vprog; + struct gl_vertex_program *vprog; GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); @@ -61,18 +69,16 @@ _mesa_ExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params) return; } - vprog = (struct vertex_program *) - _mesa_HashLookup(ctx->Shared->Programs, id); + FLUSH_VERTICES(ctx, _NEW_PROGRAM); + + vprog = (struct gl_vertex_program *) _mesa_lookup_program(ctx, id); if (!vprog || vprog->Base.Target != GL_VERTEX_STATE_PROGRAM_NV) { _mesa_error(ctx, GL_INVALID_OPERATION, "glExecuteProgramNV"); return; } - _mesa_init_vp_registers(ctx); - _mesa_init_tracked_matrices(ctx); - COPY_4V(ctx->VertexProgram.Inputs[VERT_ATTRIB_POS], params); - _mesa_exec_vertex_program(ctx, vprog); + _mesa_problem(ctx, "glExecuteProgramNV() not supported"); } @@ -81,8 +87,9 @@ _mesa_ExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params) * \note Not compiled into display lists. * \note Called from the GL API dispatcher. */ -GLboolean _mesa_AreProgramsResidentNV(GLsizei n, const GLuint *ids, - GLboolean *residences) +GLboolean GLAPIENTRY +_mesa_AreProgramsResidentNV(GLsizei n, const GLuint *ids, + GLboolean *residences) { GLint i, j; GLboolean allResident = GL_TRUE; @@ -95,13 +102,12 @@ GLboolean _mesa_AreProgramsResidentNV(GLsizei n, const GLuint *ids, } for (i = 0; i < n; i++) { - const struct program *prog; + const struct gl_program *prog; if (ids[i] == 0) { _mesa_error(ctx, GL_INVALID_VALUE, "glAreProgramsResidentNV"); return GL_FALSE; } - prog = (const struct program *) - _mesa_HashLookup(ctx->Shared->Programs, ids[i]); + prog = _mesa_lookup_program(ctx, ids[i]); if (!prog) { _mesa_error(ctx, GL_INVALID_VALUE, "glAreProgramsResidentNV"); return GL_FALSE; @@ -128,7 +134,7 @@ GLboolean _mesa_AreProgramsResidentNV(GLsizei n, const GLuint *ids, * Request that a set of programs be resident in hardware. * \note Called from the GL API dispatcher. */ -void +void GLAPIENTRY _mesa_RequestResidentProgramsNV(GLsizei n, const GLuint *ids) { GLint i; @@ -142,20 +148,20 @@ _mesa_RequestResidentProgramsNV(GLsizei n, const GLuint *ids) /* just error checking for now */ for (i = 0; i < n; i++) { - struct program *prog; + struct gl_program *prog; if (ids[i] == 0) { _mesa_error(ctx, GL_INVALID_VALUE, "glRequestResidentProgramsNV(id)"); return; } - prog = (struct program *) _mesa_HashLookup(ctx->Shared->Programs, ids[i]); - + prog = _mesa_lookup_program(ctx, ids[i]); if (!prog) { _mesa_error(ctx, GL_INVALID_VALUE, "glRequestResidentProgramsNV(id)"); return; } + /* XXX this is really a hardware thing we should hook out */ prog->Resident = GL_TRUE; } } @@ -166,7 +172,7 @@ _mesa_RequestResidentProgramsNV(GLsizei n, const GLuint *ids) * \note Not compiled into display lists. * \note Called from the GL API dispatcher. */ -void +void GLAPIENTRY _mesa_GetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat *params) { @@ -201,7 +207,7 @@ _mesa_GetProgramParameterfvNV(GLenum target, GLuint index, * \note Not compiled into display lists. * \note Called from the GL API dispatcher. */ -void +void GLAPIENTRY _mesa_GetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble *params) { @@ -236,16 +242,15 @@ _mesa_GetProgramParameterdvNV(GLenum target, GLuint index, * \note Not compiled into display lists. * \note Called from the GL API dispatcher. */ -void +void GLAPIENTRY _mesa_GetProgramivNV(GLuint id, GLenum pname, GLint *params) { - struct program *prog; + struct gl_program *prog; GET_CURRENT_CONTEXT(ctx); - if (!ctx->_CurrentProgram) - ASSERT_OUTSIDE_BEGIN_END(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); - prog = (struct program *) _mesa_HashLookup(ctx->Shared->Programs, id); + prog = _mesa_lookup_program(ctx, id); if (!prog) { _mesa_error(ctx, GL_INVALID_OPERATION, "glGetProgramivNV"); return; @@ -256,7 +261,7 @@ _mesa_GetProgramivNV(GLuint id, GLenum pname, GLint *params) *params = prog->Target; return; case GL_PROGRAM_LENGTH_NV: - *params = prog->String ? _mesa_strlen((char *) prog->String) : 0; + *params = prog->String ?(GLint) strlen((char *) prog->String) : 0; return; case GL_PROGRAM_RESIDENT_NV: *params = prog->Resident; @@ -273,28 +278,27 @@ _mesa_GetProgramivNV(GLuint id, GLenum pname, GLint *params) * \note Not compiled into display lists. * \note Called from the GL API dispatcher. */ -void +void GLAPIENTRY _mesa_GetProgramStringNV(GLuint id, GLenum pname, GLubyte *program) { - struct program *prog; + struct gl_program *prog; GET_CURRENT_CONTEXT(ctx); - if (!ctx->_CurrentProgram) - ASSERT_OUTSIDE_BEGIN_END(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); if (pname != GL_PROGRAM_STRING_NV) { _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramStringNV(pname)"); return; } - prog = (struct program *) _mesa_HashLookup(ctx->Shared->Programs, id); + prog = _mesa_lookup_program(ctx, id); if (!prog) { _mesa_error(ctx, GL_INVALID_OPERATION, "glGetProgramStringNV"); return; } if (prog->String) { - MEMCPY(program, prog->String, _mesa_strlen((char *) prog->String)); + memcpy(program, prog->String, strlen((char *) prog->String)); } else { program[0] = 0; @@ -307,7 +311,7 @@ _mesa_GetProgramStringNV(GLuint id, GLenum pname, GLubyte *program) * \note Not compiled into display lists. * \note Called from the GL API dispatcher. */ -void +void GLAPIENTRY _mesa_GetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint *params) { @@ -349,28 +353,36 @@ _mesa_GetTrackMatrixivNV(GLenum target, GLuint address, * \note Not compiled into display lists. * \note Called from the GL API dispatcher. */ -void +void GLAPIENTRY _mesa_GetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble *params) { + const struct gl_client_array *array; GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); - if (index == 0 || index >= MAX_NV_VERTEX_PROGRAM_INPUTS) { + if (index >= MAX_NV_VERTEX_PROGRAM_INPUTS) { _mesa_error(ctx, GL_INVALID_VALUE, "glGetVertexAttribdvNV(index)"); return; } + array = &ctx->Array.ArrayObj->VertexAttrib[index]; + switch (pname) { case GL_ATTRIB_ARRAY_SIZE_NV: - params[0] = ctx->Array.VertexAttrib[index].Size; + params[0] = array->Size; break; case GL_ATTRIB_ARRAY_STRIDE_NV: - params[0] = ctx->Array.VertexAttrib[index].Stride; + params[0] = array->Stride; break; case GL_ATTRIB_ARRAY_TYPE_NV: - params[0] = ctx->Array.VertexAttrib[index].Type; + params[0] = array->Type; break; case GL_CURRENT_ATTRIB_NV: + if (index == 0) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glGetVertexAttribdvNV(index == 0)"); + return; + } FLUSH_CURRENT(ctx, 0); COPY_4V(params, ctx->Current.Attrib[index]); break; @@ -385,28 +397,36 @@ _mesa_GetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble *params) * \note Not compiled into display lists. * \note Called from the GL API dispatcher. */ -void +void GLAPIENTRY _mesa_GetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat *params) { + const struct gl_client_array *array; GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); - if (index == 0 || index >= MAX_NV_VERTEX_PROGRAM_INPUTS) { + if (index >= MAX_NV_VERTEX_PROGRAM_INPUTS) { _mesa_error(ctx, GL_INVALID_VALUE, "glGetVertexAttribdvNV(index)"); return; } + array = &ctx->Array.ArrayObj->VertexAttrib[index]; + switch (pname) { case GL_ATTRIB_ARRAY_SIZE_NV: - params[0] = (GLfloat) ctx->Array.VertexAttrib[index].Size; + params[0] = (GLfloat) array->Size; break; case GL_ATTRIB_ARRAY_STRIDE_NV: - params[0] = (GLfloat) ctx->Array.VertexAttrib[index].Stride; + params[0] = (GLfloat) array->Stride; break; case GL_ATTRIB_ARRAY_TYPE_NV: - params[0] = (GLfloat) ctx->Array.VertexAttrib[index].Type; + params[0] = (GLfloat) array->Type; break; case GL_CURRENT_ATTRIB_NV: + if (index == 0) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glGetVertexAttribfvNV(index == 0)"); + return; + } FLUSH_CURRENT(ctx, 0); COPY_4V(params, ctx->Current.Attrib[index]); break; @@ -421,28 +441,36 @@ _mesa_GetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat *params) * \note Not compiled into display lists. * \note Called from the GL API dispatcher. */ -void +void GLAPIENTRY _mesa_GetVertexAttribivNV(GLuint index, GLenum pname, GLint *params) { + const struct gl_client_array *array; GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); - if (index == 0 || index >= MAX_NV_VERTEX_PROGRAM_INPUTS) { + if (index >= MAX_NV_VERTEX_PROGRAM_INPUTS) { _mesa_error(ctx, GL_INVALID_VALUE, "glGetVertexAttribdvNV(index)"); return; } + array = &ctx->Array.ArrayObj->VertexAttrib[index]; + switch (pname) { case GL_ATTRIB_ARRAY_SIZE_NV: - params[0] = ctx->Array.VertexAttrib[index].Size; + params[0] = array->Size; break; case GL_ATTRIB_ARRAY_STRIDE_NV: - params[0] = ctx->Array.VertexAttrib[index].Stride; + params[0] = array->Stride; break; case GL_ATTRIB_ARRAY_TYPE_NV: - params[0] = ctx->Array.VertexAttrib[index].Type; + params[0] = array->Type; break; case GL_CURRENT_ATTRIB_NV: + if (index == 0) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "glGetVertexAttribivNV(index == 0)"); + return; + } FLUSH_CURRENT(ctx, 0); params[0] = (GLint) ctx->Current.Attrib[index][0]; params[1] = (GLint) ctx->Current.Attrib[index][1]; @@ -450,11 +478,7 @@ _mesa_GetVertexAttribivNV(GLuint index, GLenum pname, GLint *params) params[3] = (GLint) ctx->Current.Attrib[index][3]; break; case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB: - if (!ctx->Extensions.ARB_vertex_buffer_object) { - _mesa_error(ctx, GL_INVALID_ENUM, "glGetVertexAttribdvNV"); - return; - } - params[0] = ctx->Array.VertexAttrib[index].BufferBinding; + params[0] = array->BufferObj->Name; break; default: _mesa_error(ctx, GL_INVALID_ENUM, "glGetVertexAttribdvNV"); @@ -468,7 +492,7 @@ _mesa_GetVertexAttribivNV(GLuint index, GLenum pname, GLint *params) * \note Not compiled into display lists. * \note Called from the GL API dispatcher. */ -void +void GLAPIENTRY _mesa_GetVertexAttribPointervNV(GLuint index, GLenum pname, GLvoid **pointer) { GET_CURRENT_CONTEXT(ctx); @@ -484,29 +508,116 @@ _mesa_GetVertexAttribPointervNV(GLuint index, GLenum pname, GLvoid **pointer) return; } - *pointer = ctx->Array.VertexAttrib[index].Ptr;; + *pointer = (GLvoid *) ctx->Array.ArrayObj->VertexAttrib[index].Ptr; +} + +void +_mesa_emit_nv_temp_initialization(struct gl_context *ctx, + struct gl_program *program) +{ + struct prog_instruction *inst; + GLuint i; + struct gl_shader_compiler_options* options = + &ctx->ShaderCompilerOptions[_mesa_program_target_to_index(program->Target)]; + + if (!options->EmitNVTempInitialization) + return; + + /* We'll swizzle up a zero temporary so we can use it for the + * ARL. + */ + if (program->NumTemporaries == 0) + program->NumTemporaries = 1; + + _mesa_insert_instructions(program, 0, program->NumTemporaries + 1); + + for (i = 0; i < program->NumTemporaries; i++) { + struct prog_instruction *inst = &program->Instructions[i]; + + inst->Opcode = OPCODE_SWZ; + inst->DstReg.File = PROGRAM_TEMPORARY; + inst->DstReg.Index = i; + inst->DstReg.WriteMask = WRITEMASK_XYZW; + inst->SrcReg[0].File = PROGRAM_TEMPORARY; + inst->SrcReg[0].Index = 0; + inst->SrcReg[0].Swizzle = MAKE_SWIZZLE4(SWIZZLE_ZERO, + SWIZZLE_ZERO, + SWIZZLE_ZERO, + SWIZZLE_ZERO); + } + + inst = &program->Instructions[i]; + inst->Opcode = OPCODE_ARL; + inst->DstReg.File = PROGRAM_ADDRESS; + inst->DstReg.Index = 0; + inst->DstReg.WriteMask = WRITEMASK_XYZW; + inst->SrcReg[0].File = PROGRAM_TEMPORARY; + inst->SrcReg[0].Index = 0; + inst->SrcReg[0].Swizzle = SWIZZLE_XXXX; + + if (program->NumAddressRegs == 0) + program->NumAddressRegs = 1; } +void +_mesa_setup_nv_temporary_count(struct gl_context *ctx, struct gl_program *program) +{ + GLuint i; + program->NumTemporaries = 0; + for (i = 0; i < program->NumInstructions; i++) { + struct prog_instruction *inst = &program->Instructions[i]; + + if (inst->DstReg.File == PROGRAM_TEMPORARY) { + program->NumTemporaries = MAX2(program->NumTemporaries, + inst->DstReg.Index + 1); + } + if (inst->SrcReg[0].File == PROGRAM_TEMPORARY) { + program->NumTemporaries = MAX2((GLint)program->NumTemporaries, + inst->SrcReg[0].Index + 1); + } + if (inst->SrcReg[1].File == PROGRAM_TEMPORARY) { + program->NumTemporaries = MAX2((GLint)program->NumTemporaries, + inst->SrcReg[1].Index + 1); + } + if (inst->SrcReg[2].File == PROGRAM_TEMPORARY) { + program->NumTemporaries = MAX2((GLint)program->NumTemporaries, + inst->SrcReg[2].Index + 1); + } + } +} /** * Load/parse/compile a program. * \note Called from the GL API dispatcher. */ -void +void GLAPIENTRY _mesa_LoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte *program) { - struct program *prog; + struct gl_program *prog; GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); + if (!ctx->Extensions.NV_vertex_program + && !ctx->Extensions.NV_fragment_program) { + _mesa_error(ctx, GL_INVALID_OPERATION, "glLoadProgramNV()"); + return; + } + if (id == 0) { _mesa_error(ctx, GL_INVALID_VALUE, "glLoadProgramNV(id)"); return; } - prog = (struct program *) _mesa_HashLookup(ctx->Shared->Programs, id); + if (len < 0) { + _mesa_error(ctx, GL_INVALID_VALUE, "glLoadProgramNV(len)"); + return; + } + + FLUSH_VERTICES(ctx, _NEW_PROGRAM); + + prog = _mesa_lookup_program(ctx, id); if (prog && prog->Target != 0 && prog->Target != target) { _mesa_error(ctx, GL_INVALID_OPERATION, "glLoadProgramNV(target)"); @@ -516,122 +627,72 @@ _mesa_LoadProgramNV(GLenum target, GLuint id, GLsizei len, if ((target == GL_VERTEX_PROGRAM_NV || target == GL_VERTEX_STATE_PROGRAM_NV) && ctx->Extensions.NV_vertex_program) { - struct vertex_program *vprog = (struct vertex_program *) prog; - if (!vprog) { - vprog = CALLOC_STRUCT(vertex_program); + struct gl_vertex_program *vprog = (struct gl_vertex_program *) prog; + if (!vprog || prog == &_mesa_DummyProgram) { + vprog = (struct gl_vertex_program *) + ctx->Driver.NewProgram(ctx, target, id); if (!vprog) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV"); return; } - vprog->Base.RefCount = 1; - vprog->Base.Resident = GL_TRUE; _mesa_HashInsert(ctx->Shared->Programs, id, vprog); } - _mesa_parse_nv_vertex_program(ctx, target, program, len, vprog); + + if (ctx->Extensions.ARB_vertex_program + && (strncmp((char *) program, "!!ARB", 5) == 0)) { + _mesa_parse_arb_vertex_program(ctx, target, program, len, vprog); + } else { + _mesa_parse_nv_vertex_program(ctx, target, program, len, vprog); + } } else if (target == GL_FRAGMENT_PROGRAM_NV && ctx->Extensions.NV_fragment_program) { - struct fragment_program *fprog = (struct fragment_program *) prog; - if (!fprog) { - fprog = CALLOC_STRUCT(fragment_program); + struct gl_fragment_program *fprog = (struct gl_fragment_program *) prog; + if (!fprog || prog == &_mesa_DummyProgram) { + fprog = (struct gl_fragment_program *) + ctx->Driver.NewProgram(ctx, target, id); if (!fprog) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV"); return; } - fprog->Base.RefCount = 1; - fprog->Base.Resident = GL_TRUE; _mesa_HashInsert(ctx->Shared->Programs, id, fprog); } _mesa_parse_nv_fragment_program(ctx, target, program, len, fprog); } - else { - _mesa_error(ctx, GL_INVALID_ENUM, "glLoadProgramNV(target)"); - } -} - - - -/** - * Set a program parameter register. - * \note Called from the GL API dispatcher. - */ -void -_mesa_ProgramParameter4dNV(GLenum target, GLuint index, - GLdouble x, GLdouble y, GLdouble z, GLdouble w) -{ - _mesa_ProgramParameter4fNV(target, index, - (GLfloat)x, (GLfloat)y, (GLfloat)z, (GLfloat)w); -} - - -/** - * Set a program parameter register. - * \note Called from the GL API dispatcher. - */ -void -_mesa_ProgramParameter4dvNV(GLenum target, GLuint index, - const GLdouble *params) -{ - _mesa_ProgramParameter4fNV(target, index, - (GLfloat)params[0], (GLfloat)params[1], - (GLfloat)params[2], (GLfloat)params[3]); -} - - -/** - * Set a program parameter register. - * \note Called from the GL API dispatcher. - */ -void -_mesa_ProgramParameter4fNV(GLenum target, GLuint index, - GLfloat x, GLfloat y, GLfloat z, GLfloat w) -{ - GET_CURRENT_CONTEXT(ctx); - ASSERT_OUTSIDE_BEGIN_END(ctx); - - if (target == GL_VERTEX_PROGRAM_NV && ctx->Extensions.NV_vertex_program) { - if (index < MAX_NV_VERTEX_PROGRAM_PARAMS) { - ASSIGN_4V(ctx->VertexProgram.Parameters[index], x, y, z, w); - } - else { - _mesa_error(ctx, GL_INVALID_VALUE, "glProgramParameterNV(index)"); - return; + else if (target == GL_FRAGMENT_PROGRAM_ARB + && ctx->Extensions.ARB_fragment_program) { + struct gl_fragment_program *fprog = (struct gl_fragment_program *) prog; + if (!fprog || prog == &_mesa_DummyProgram) { + fprog = (struct gl_fragment_program *) + ctx->Driver.NewProgram(ctx, target, id); + if (!fprog) { + _mesa_error(ctx, GL_OUT_OF_MEMORY, "glLoadProgramNV"); + return; + } + _mesa_HashInsert(ctx->Shared->Programs, id, fprog); } + _mesa_parse_arb_fragment_program(ctx, target, program, len, fprog); } else { - _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameterNV"); - return; + _mesa_error(ctx, GL_INVALID_ENUM, "glLoadProgramNV(target)"); } } -/** - * Set a program parameter register. - * \note Called from the GL API dispatcher. - */ -void -_mesa_ProgramParameter4fvNV(GLenum target, GLuint index, - const GLfloat *params) -{ - _mesa_ProgramParameter4fNV(target, index, - params[0], params[1], params[2], params[3]); -} - - /** * Set a sequence of program parameter registers. * \note Called from the GL API dispatcher. */ -void +void GLAPIENTRY _mesa_ProgramParameters4dvNV(GLenum target, GLuint index, - GLuint num, const GLdouble *params) + GLsizei num, const GLdouble *params) { GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); if (target == GL_VERTEX_PROGRAM_NV && ctx->Extensions.NV_vertex_program) { - GLuint i; + GLint i; if (index + num > MAX_NV_VERTEX_PROGRAM_PARAMS) { _mesa_error(ctx, GL_INVALID_VALUE, "glProgramParameters4dvNV"); return; @@ -655,15 +716,15 @@ _mesa_ProgramParameters4dvNV(GLenum target, GLuint index, * Set a sequence of program parameter registers. * \note Called from the GL API dispatcher. */ -void +void GLAPIENTRY _mesa_ProgramParameters4fvNV(GLenum target, GLuint index, - GLuint num, const GLfloat *params) + GLsizei num, const GLfloat *params) { GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); if (target == GL_VERTEX_PROGRAM_NV && ctx->Extensions.NV_vertex_program) { - GLuint i; + GLint i; if (index + num > MAX_NV_VERTEX_PROGRAM_PARAMS) { _mesa_error(ctx, GL_INVALID_VALUE, "glProgramParameters4fvNV"); return; @@ -671,7 +732,7 @@ _mesa_ProgramParameters4fvNV(GLenum target, GLuint index, for (i = 0; i < num; i++) { COPY_4V(ctx->VertexProgram.Parameters[index + i], params); params += 4; - }; + } } else { _mesa_error(ctx, GL_INVALID_ENUM, "glProgramParameters4fvNV"); @@ -685,13 +746,15 @@ _mesa_ProgramParameters4fvNV(GLenum target, GLuint index, * Setup tracking of matrices into program parameter registers. * \note Called from the GL API dispatcher. */ -void +void GLAPIENTRY _mesa_TrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform) { GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); + FLUSH_VERTICES(ctx, _NEW_PROGRAM); + if (target == GL_VERTEX_PROGRAM_NV && ctx->Extensions.NV_vertex_program) { if (address & 0x3) { /* addr must be multiple of four */ @@ -743,30 +806,33 @@ _mesa_TrackMatrixNV(GLenum target, GLuint address, } -void +void GLAPIENTRY _mesa_ProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { - struct program *prog; - struct fragment_program *fragProg; + struct gl_program *prog; + struct gl_fragment_program *fragProg; GLfloat *v; GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END(ctx); - prog = (struct program *) _mesa_HashLookup(ctx->Shared->Programs, id); + FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS); + + prog = _mesa_lookup_program(ctx, id); if (!prog || prog->Target != GL_FRAGMENT_PROGRAM_NV) { _mesa_error(ctx, GL_INVALID_OPERATION, "glProgramNamedParameterNV"); return; } if (len <= 0) { - _mesa_error(ctx, GL_INVALID_VALUE, "glProgramNamedParameterNV"); + _mesa_error(ctx, GL_INVALID_VALUE, "glProgramNamedParameterNV(len)"); return; } - fragProg = (struct fragment_program *) prog; - v = _mesa_lookup_parameter_value(fragProg->Parameters, len, (char *) name); + fragProg = (struct gl_fragment_program *) prog; + v = _mesa_lookup_parameter_value(fragProg->Base.Parameters, len, + (char *) name); if (v) { v[0] = x; v[1] = y; @@ -775,11 +841,11 @@ _mesa_ProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte *name, return; } - _mesa_error(ctx, GL_INVALID_VALUE, "glProgramNamedParameterNV"); + _mesa_error(ctx, GL_INVALID_VALUE, "glProgramNamedParameterNV(name)"); } -void +void GLAPIENTRY _mesa_ProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte *name, const float v[]) { @@ -787,7 +853,7 @@ _mesa_ProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte *name, } -void +void GLAPIENTRY _mesa_ProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { @@ -796,7 +862,7 @@ _mesa_ProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte *name, } -void +void GLAPIENTRY _mesa_ProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte *name, const double v[]) { @@ -806,20 +872,19 @@ _mesa_ProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte *name, } -void +void GLAPIENTRY _mesa_GetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte *name, GLfloat *params) { - struct program *prog; - struct fragment_program *fragProg; + struct gl_program *prog; + struct gl_fragment_program *fragProg; const GLfloat *v; GET_CURRENT_CONTEXT(ctx); - if (!ctx->_CurrentProgram) - ASSERT_OUTSIDE_BEGIN_END(ctx); + ASSERT_OUTSIDE_BEGIN_END(ctx); - prog = (struct program *) _mesa_HashLookup(ctx->Shared->Programs, id); + prog = _mesa_lookup_program(ctx, id); if (!prog || prog->Target != GL_FRAGMENT_PROGRAM_NV) { _mesa_error(ctx, GL_INVALID_OPERATION, "glGetProgramNamedParameterNV"); return; @@ -830,8 +895,9 @@ _mesa_GetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte *name, return; } - fragProg = (struct fragment_program *) prog; - v = _mesa_lookup_parameter_value(fragProg->Parameters, len, (char *) name); + fragProg = (struct gl_fragment_program *) prog; + v = _mesa_lookup_parameter_value(fragProg->Base.Parameters, + len, (char *) name); if (v) { params[0] = v[0]; params[1] = v[1]; @@ -844,7 +910,7 @@ _mesa_GetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte *name, } -void +void GLAPIENTRY _mesa_GetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte *name, GLdouble *params) {