2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 * NVIDIA vertex/fragment program state management functions.
32 * Regarding GL_NV_fragment/vertex_program, GL_NV_vertex_program1_1, etc:
34 * Portions of this software may use or implement intellectual
35 * property owned and licensed by NVIDIA Corporation. NVIDIA disclaims
36 * any and all warranties with respect to such intellectual property,
37 * including any use thereof or modifications thereto.
46 #include "nvfragparse.h"
47 #include "program_instruction.h"
48 #include "nvvertexec.h"
49 #include "nvvertparse.h"
50 #include "nvprogram.h"
56 * Execute a vertex state program.
57 * \note Called from the GL API dispatcher.
60 _mesa_ExecuteProgramNV(GLenum target
, GLuint id
, const GLfloat
*params
)
62 struct gl_vertex_program
*vprog
;
63 GET_CURRENT_CONTEXT(ctx
);
64 ASSERT_OUTSIDE_BEGIN_END(ctx
);
66 if (target
!= GL_VERTEX_STATE_PROGRAM_NV
) {
67 _mesa_error(ctx
, GL_INVALID_ENUM
, "glExecuteProgramNV");
71 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
73 vprog
= (struct gl_vertex_program
*) _mesa_lookup_program(ctx
, id
);
75 if (!vprog
|| vprog
->Base
.Target
!= GL_VERTEX_STATE_PROGRAM_NV
) {
76 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glExecuteProgramNV");
80 _mesa_exec_vertex_state_program(ctx
, vprog
, params
);
85 * Determine if a set of programs is resident in hardware.
86 * \note Not compiled into display lists.
87 * \note Called from the GL API dispatcher.
90 _mesa_AreProgramsResidentNV(GLsizei n
, const GLuint
*ids
,
91 GLboolean
*residences
)
94 GLboolean allResident
= GL_TRUE
;
95 GET_CURRENT_CONTEXT(ctx
);
96 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx
, GL_FALSE
);
99 _mesa_error(ctx
, GL_INVALID_VALUE
, "glAreProgramsResidentNV(n)");
103 for (i
= 0; i
< n
; i
++) {
104 const struct gl_program
*prog
;
106 _mesa_error(ctx
, GL_INVALID_VALUE
, "glAreProgramsResidentNV");
109 prog
= _mesa_lookup_program(ctx
, ids
[i
]);
111 _mesa_error(ctx
, GL_INVALID_VALUE
, "glAreProgramsResidentNV");
114 if (prog
->Resident
) {
116 residences
[i
] = GL_TRUE
;
120 allResident
= GL_FALSE
;
121 for (j
= 0; j
< i
; j
++)
122 residences
[j
] = GL_TRUE
;
124 residences
[i
] = GL_FALSE
;
133 * Request that a set of programs be resident in hardware.
134 * \note Called from the GL API dispatcher.
137 _mesa_RequestResidentProgramsNV(GLsizei n
, const GLuint
*ids
)
140 GET_CURRENT_CONTEXT(ctx
);
141 ASSERT_OUTSIDE_BEGIN_END(ctx
);
144 _mesa_error(ctx
, GL_INVALID_VALUE
, "glRequestResidentProgramsNV(n)");
148 /* just error checking for now */
149 for (i
= 0; i
< n
; i
++) {
150 struct gl_program
*prog
;
153 _mesa_error(ctx
, GL_INVALID_VALUE
, "glRequestResidentProgramsNV(id)");
157 prog
= _mesa_lookup_program(ctx
, ids
[i
]);
159 _mesa_error(ctx
, GL_INVALID_VALUE
, "glRequestResidentProgramsNV(id)");
163 /* XXX this is really a hardware thing we should hook out */
164 prog
->Resident
= GL_TRUE
;
170 * Get a program parameter register.
171 * \note Not compiled into display lists.
172 * \note Called from the GL API dispatcher.
175 _mesa_GetProgramParameterfvNV(GLenum target
, GLuint index
,
176 GLenum pname
, GLfloat
*params
)
178 GET_CURRENT_CONTEXT(ctx
);
179 ASSERT_OUTSIDE_BEGIN_END(ctx
);
181 if (target
== GL_VERTEX_PROGRAM_NV
) {
182 if (pname
== GL_PROGRAM_PARAMETER_NV
) {
183 if (index
< MAX_NV_VERTEX_PROGRAM_PARAMS
) {
184 COPY_4V(params
, ctx
->VertexProgram
.Parameters
[index
]);
187 _mesa_error(ctx
, GL_INVALID_VALUE
,
188 "glGetProgramParameterfvNV(index)");
193 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramParameterfvNV(pname)");
198 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramParameterfvNV(target)");
205 * Get a program parameter register.
206 * \note Not compiled into display lists.
207 * \note Called from the GL API dispatcher.
210 _mesa_GetProgramParameterdvNV(GLenum target
, GLuint index
,
211 GLenum pname
, GLdouble
*params
)
213 GET_CURRENT_CONTEXT(ctx
);
214 ASSERT_OUTSIDE_BEGIN_END(ctx
);
216 if (target
== GL_VERTEX_PROGRAM_NV
) {
217 if (pname
== GL_PROGRAM_PARAMETER_NV
) {
218 if (index
< MAX_NV_VERTEX_PROGRAM_PARAMS
) {
219 COPY_4V(params
, ctx
->VertexProgram
.Parameters
[index
]);
222 _mesa_error(ctx
, GL_INVALID_VALUE
,
223 "glGetProgramParameterdvNV(index)");
228 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramParameterdvNV(pname)");
233 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramParameterdvNV(target)");
240 * Get a program attribute.
241 * \note Not compiled into display lists.
242 * \note Called from the GL API dispatcher.
245 _mesa_GetProgramivNV(GLuint id
, GLenum pname
, GLint
*params
)
247 struct gl_program
*prog
;
248 GET_CURRENT_CONTEXT(ctx
);
250 if (!ctx
->_CurrentProgram
)
251 ASSERT_OUTSIDE_BEGIN_END(ctx
);
253 prog
= _mesa_lookup_program(ctx
, id
);
255 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramivNV");
260 case GL_PROGRAM_TARGET_NV
:
261 *params
= prog
->Target
;
263 case GL_PROGRAM_LENGTH_NV
:
264 *params
= prog
->String
?(GLint
)_mesa_strlen((char *) prog
->String
) : 0;
266 case GL_PROGRAM_RESIDENT_NV
:
267 *params
= prog
->Resident
;
270 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramivNV(pname)");
277 * Get the program source code.
278 * \note Not compiled into display lists.
279 * \note Called from the GL API dispatcher.
282 _mesa_GetProgramStringNV(GLuint id
, GLenum pname
, GLubyte
*program
)
284 struct gl_program
*prog
;
285 GET_CURRENT_CONTEXT(ctx
);
287 if (!ctx
->_CurrentProgram
)
288 ASSERT_OUTSIDE_BEGIN_END(ctx
);
290 if (pname
!= GL_PROGRAM_STRING_NV
) {
291 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramStringNV(pname)");
295 prog
= _mesa_lookup_program(ctx
, id
);
297 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramStringNV");
302 MEMCPY(program
, prog
->String
, _mesa_strlen((char *) prog
->String
));
311 * Get matrix tracking information.
312 * \note Not compiled into display lists.
313 * \note Called from the GL API dispatcher.
316 _mesa_GetTrackMatrixivNV(GLenum target
, GLuint address
,
317 GLenum pname
, GLint
*params
)
319 GET_CURRENT_CONTEXT(ctx
);
320 ASSERT_OUTSIDE_BEGIN_END(ctx
);
322 if (target
== GL_VERTEX_PROGRAM_NV
323 && ctx
->Extensions
.NV_vertex_program
) {
326 if ((address
& 0x3) || address
>= MAX_NV_VERTEX_PROGRAM_PARAMS
) {
327 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetTrackMatrixivNV(address)");
334 case GL_TRACK_MATRIX_NV
:
335 params
[0] = (GLint
) ctx
->VertexProgram
.TrackMatrix
[i
];
337 case GL_TRACK_MATRIX_TRANSFORM_NV
:
338 params
[0] = (GLint
) ctx
->VertexProgram
.TrackMatrixTransform
[i
];
341 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetTrackMatrixivNV");
346 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetTrackMatrixivNV");
353 * Get a vertex (or vertex array) attribute.
354 * \note Not compiled into display lists.
355 * \note Called from the GL API dispatcher.
358 _mesa_GetVertexAttribdvNV(GLuint index
, GLenum pname
, GLdouble
*params
)
360 GET_CURRENT_CONTEXT(ctx
);
361 ASSERT_OUTSIDE_BEGIN_END(ctx
);
363 if (index
>= MAX_NV_VERTEX_PROGRAM_INPUTS
) {
364 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetVertexAttribdvNV(index)");
369 case GL_ATTRIB_ARRAY_SIZE_NV
:
370 params
[0] = ctx
->Array
.ArrayObj
->VertexAttrib
[index
].Size
;
372 case GL_ATTRIB_ARRAY_STRIDE_NV
:
373 params
[0] = ctx
->Array
.ArrayObj
->VertexAttrib
[index
].Stride
;
375 case GL_ATTRIB_ARRAY_TYPE_NV
:
376 params
[0] = ctx
->Array
.ArrayObj
->VertexAttrib
[index
].Type
;
378 case GL_CURRENT_ATTRIB_NV
:
380 _mesa_error(ctx
, GL_INVALID_OPERATION
,
381 "glGetVertexAttribdvNV(index == 0)");
384 FLUSH_CURRENT(ctx
, 0);
385 COPY_4V(params
, ctx
->Current
.Attrib
[index
]);
388 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetVertexAttribdvNV");
394 * Get a vertex (or vertex array) attribute.
395 * \note Not compiled into display lists.
396 * \note Called from the GL API dispatcher.
399 _mesa_GetVertexAttribfvNV(GLuint index
, GLenum pname
, GLfloat
*params
)
401 GET_CURRENT_CONTEXT(ctx
);
402 ASSERT_OUTSIDE_BEGIN_END(ctx
);
404 if (index
>= MAX_NV_VERTEX_PROGRAM_INPUTS
) {
405 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetVertexAttribdvNV(index)");
410 case GL_ATTRIB_ARRAY_SIZE_NV
:
411 params
[0] = (GLfloat
) ctx
->Array
.ArrayObj
->VertexAttrib
[index
].Size
;
413 case GL_ATTRIB_ARRAY_STRIDE_NV
:
414 params
[0] = (GLfloat
) ctx
->Array
.ArrayObj
->VertexAttrib
[index
].Stride
;
416 case GL_ATTRIB_ARRAY_TYPE_NV
:
417 params
[0] = (GLfloat
) ctx
->Array
.ArrayObj
->VertexAttrib
[index
].Type
;
419 case GL_CURRENT_ATTRIB_NV
:
421 _mesa_error(ctx
, GL_INVALID_OPERATION
,
422 "glGetVertexAttribfvNV(index == 0)");
425 FLUSH_CURRENT(ctx
, 0);
426 COPY_4V(params
, ctx
->Current
.Attrib
[index
]);
429 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetVertexAttribdvNV");
435 * Get a vertex (or vertex array) attribute.
436 * \note Not compiled into display lists.
437 * \note Called from the GL API dispatcher.
440 _mesa_GetVertexAttribivNV(GLuint index
, GLenum pname
, GLint
*params
)
442 GET_CURRENT_CONTEXT(ctx
);
443 ASSERT_OUTSIDE_BEGIN_END(ctx
);
445 if (index
>= MAX_NV_VERTEX_PROGRAM_INPUTS
) {
446 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetVertexAttribdvNV(index)");
451 case GL_ATTRIB_ARRAY_SIZE_NV
:
452 params
[0] = ctx
->Array
.ArrayObj
->VertexAttrib
[index
].Size
;
454 case GL_ATTRIB_ARRAY_STRIDE_NV
:
455 params
[0] = ctx
->Array
.ArrayObj
->VertexAttrib
[index
].Stride
;
457 case GL_ATTRIB_ARRAY_TYPE_NV
:
458 params
[0] = ctx
->Array
.ArrayObj
->VertexAttrib
[index
].Type
;
460 case GL_CURRENT_ATTRIB_NV
:
462 _mesa_error(ctx
, GL_INVALID_OPERATION
,
463 "glGetVertexAttribivNV(index == 0)");
466 FLUSH_CURRENT(ctx
, 0);
467 params
[0] = (GLint
) ctx
->Current
.Attrib
[index
][0];
468 params
[1] = (GLint
) ctx
->Current
.Attrib
[index
][1];
469 params
[2] = (GLint
) ctx
->Current
.Attrib
[index
][2];
470 params
[3] = (GLint
) ctx
->Current
.Attrib
[index
][3];
472 case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB
:
473 if (!ctx
->Extensions
.ARB_vertex_buffer_object
) {
474 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetVertexAttribdvNV");
477 params
[0] = ctx
->Array
.ArrayObj
->VertexAttrib
[index
].BufferObj
->Name
;
480 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetVertexAttribdvNV");
487 * Get a vertex array attribute pointer.
488 * \note Not compiled into display lists.
489 * \note Called from the GL API dispatcher.
492 _mesa_GetVertexAttribPointervNV(GLuint index
, GLenum pname
, GLvoid
**pointer
)
494 GET_CURRENT_CONTEXT(ctx
);
495 ASSERT_OUTSIDE_BEGIN_END(ctx
);
497 if (index
>= MAX_NV_VERTEX_PROGRAM_INPUTS
) {
498 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetVertexAttribPointerNV(index)");
502 if (pname
!= GL_ATTRIB_ARRAY_POINTER_NV
) {
503 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetVertexAttribPointerNV(pname)");
507 *pointer
= (GLvoid
*) ctx
->Array
.ArrayObj
->VertexAttrib
[index
].Ptr
;
513 * Load/parse/compile a program.
514 * \note Called from the GL API dispatcher.
517 _mesa_LoadProgramNV(GLenum target
, GLuint id
, GLsizei len
,
518 const GLubyte
*program
)
520 struct gl_program
*prog
;
521 GET_CURRENT_CONTEXT(ctx
);
522 ASSERT_OUTSIDE_BEGIN_END(ctx
);
525 _mesa_error(ctx
, GL_INVALID_VALUE
, "glLoadProgramNV(id)");
530 _mesa_error(ctx
, GL_INVALID_VALUE
, "glLoadProgramNV(len)");
534 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
536 prog
= _mesa_lookup_program(ctx
, id
);
538 if (prog
&& prog
->Target
!= 0 && prog
->Target
!= target
) {
539 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glLoadProgramNV(target)");
543 if ((target
== GL_VERTEX_PROGRAM_NV
||
544 target
== GL_VERTEX_STATE_PROGRAM_NV
)
545 && ctx
->Extensions
.NV_vertex_program
) {
546 struct gl_vertex_program
*vprog
= (struct gl_vertex_program
*) prog
;
547 if (!vprog
|| prog
== &_mesa_DummyProgram
) {
548 vprog
= (struct gl_vertex_program
*)
549 ctx
->Driver
.NewProgram(ctx
, target
, id
);
551 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glLoadProgramNV");
554 _mesa_HashInsert(ctx
->Shared
->Programs
, id
, vprog
);
556 _mesa_parse_nv_vertex_program(ctx
, target
, program
, len
, vprog
);
558 else if (target
== GL_FRAGMENT_PROGRAM_NV
559 && ctx
->Extensions
.NV_fragment_program
) {
560 struct gl_fragment_program
*fprog
= (struct gl_fragment_program
*) prog
;
561 if (!fprog
|| prog
== &_mesa_DummyProgram
) {
562 fprog
= (struct gl_fragment_program
*)
563 ctx
->Driver
.NewProgram(ctx
, target
, id
);
565 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glLoadProgramNV");
568 _mesa_HashInsert(ctx
->Shared
->Programs
, id
, fprog
);
570 _mesa_parse_nv_fragment_program(ctx
, target
, program
, len
, fprog
);
573 _mesa_error(ctx
, GL_INVALID_ENUM
, "glLoadProgramNV(target)");
580 * Set a program parameter register.
581 * \note Called from the GL API dispatcher.
584 _mesa_ProgramParameter4dNV(GLenum target
, GLuint index
,
585 GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
587 _mesa_ProgramParameter4fNV(target
, index
,
588 (GLfloat
)x
, (GLfloat
)y
, (GLfloat
)z
, (GLfloat
)w
);
593 * Set a program parameter register.
594 * \note Called from the GL API dispatcher.
597 _mesa_ProgramParameter4dvNV(GLenum target
, GLuint index
,
598 const GLdouble
*params
)
600 _mesa_ProgramParameter4fNV(target
, index
,
601 (GLfloat
)params
[0], (GLfloat
)params
[1],
602 (GLfloat
)params
[2], (GLfloat
)params
[3]);
607 * Set a program parameter register.
608 * \note Called from the GL API dispatcher.
611 _mesa_ProgramParameter4fNV(GLenum target
, GLuint index
,
612 GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
614 GET_CURRENT_CONTEXT(ctx
);
615 ASSERT_OUTSIDE_BEGIN_END(ctx
);
617 if (target
== GL_VERTEX_PROGRAM_NV
&& ctx
->Extensions
.NV_vertex_program
) {
618 if (index
< MAX_NV_VERTEX_PROGRAM_PARAMS
) {
619 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
620 ASSIGN_4V(ctx
->VertexProgram
.Parameters
[index
], x
, y
, z
, w
);
623 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramParameterNV(index)");
628 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameterNV");
635 * Set a program parameter register.
636 * \note Called from the GL API dispatcher.
639 _mesa_ProgramParameter4fvNV(GLenum target
, GLuint index
,
640 const GLfloat
*params
)
642 _mesa_ProgramParameter4fNV(target
, index
,
643 params
[0], params
[1], params
[2], params
[3]);
649 * Set a sequence of program parameter registers.
650 * \note Called from the GL API dispatcher.
653 _mesa_ProgramParameters4dvNV(GLenum target
, GLuint index
,
654 GLuint num
, const GLdouble
*params
)
656 GET_CURRENT_CONTEXT(ctx
);
657 ASSERT_OUTSIDE_BEGIN_END(ctx
);
659 if (target
== GL_VERTEX_PROGRAM_NV
&& ctx
->Extensions
.NV_vertex_program
) {
661 if (index
+ num
> MAX_NV_VERTEX_PROGRAM_PARAMS
) {
662 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramParameters4dvNV");
665 for (i
= 0; i
< num
; i
++) {
666 ctx
->VertexProgram
.Parameters
[index
+ i
][0] = (GLfloat
) params
[0];
667 ctx
->VertexProgram
.Parameters
[index
+ i
][1] = (GLfloat
) params
[1];
668 ctx
->VertexProgram
.Parameters
[index
+ i
][2] = (GLfloat
) params
[2];
669 ctx
->VertexProgram
.Parameters
[index
+ i
][3] = (GLfloat
) params
[3];
674 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameters4dvNV");
681 * Set a sequence of program parameter registers.
682 * \note Called from the GL API dispatcher.
685 _mesa_ProgramParameters4fvNV(GLenum target
, GLuint index
,
686 GLuint num
, const GLfloat
*params
)
688 GET_CURRENT_CONTEXT(ctx
);
689 ASSERT_OUTSIDE_BEGIN_END(ctx
);
691 if (target
== GL_VERTEX_PROGRAM_NV
&& ctx
->Extensions
.NV_vertex_program
) {
693 if (index
+ num
> MAX_NV_VERTEX_PROGRAM_PARAMS
) {
694 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramParameters4fvNV");
697 for (i
= 0; i
< num
; i
++) {
698 COPY_4V(ctx
->VertexProgram
.Parameters
[index
+ i
], params
);
703 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameters4fvNV");
711 * Setup tracking of matrices into program parameter registers.
712 * \note Called from the GL API dispatcher.
715 _mesa_TrackMatrixNV(GLenum target
, GLuint address
,
716 GLenum matrix
, GLenum transform
)
718 GET_CURRENT_CONTEXT(ctx
);
719 ASSERT_OUTSIDE_BEGIN_END(ctx
);
721 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
723 if (target
== GL_VERTEX_PROGRAM_NV
&& ctx
->Extensions
.NV_vertex_program
) {
725 /* addr must be multiple of four */
726 _mesa_error(ctx
, GL_INVALID_VALUE
, "glTrackMatrixNV(address)");
736 case GL_MODELVIEW_PROJECTION_NV
:
745 /* OK, fallthrough */
748 _mesa_error(ctx
, GL_INVALID_ENUM
, "glTrackMatrixNV(matrix)");
755 case GL_TRANSPOSE_NV
:
756 case GL_INVERSE_TRANSPOSE_NV
:
757 /* OK, fallthrough */
760 _mesa_error(ctx
, GL_INVALID_ENUM
, "glTrackMatrixNV(transform)");
764 ctx
->VertexProgram
.TrackMatrix
[address
/ 4] = matrix
;
765 ctx
->VertexProgram
.TrackMatrixTransform
[address
/ 4] = transform
;
768 _mesa_error(ctx
, GL_INVALID_ENUM
, "glTrackMatrixNV(target)");
775 _mesa_ProgramNamedParameter4fNV(GLuint id
, GLsizei len
, const GLubyte
*name
,
776 GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
778 struct gl_program
*prog
;
779 struct gl_fragment_program
*fragProg
;
782 GET_CURRENT_CONTEXT(ctx
);
783 ASSERT_OUTSIDE_BEGIN_END(ctx
);
785 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
787 prog
= _mesa_lookup_program(ctx
, id
);
788 if (!prog
|| prog
->Target
!= GL_FRAGMENT_PROGRAM_NV
) {
789 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glProgramNamedParameterNV");
794 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramNamedParameterNV(len)");
798 fragProg
= (struct gl_fragment_program
*) prog
;
799 v
= _mesa_lookup_parameter_value(fragProg
->Base
.Parameters
, len
,
809 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramNamedParameterNV(name)");
814 _mesa_ProgramNamedParameter4fvNV(GLuint id
, GLsizei len
, const GLubyte
*name
,
817 _mesa_ProgramNamedParameter4fNV(id
, len
, name
, v
[0], v
[1], v
[2], v
[3]);
822 _mesa_ProgramNamedParameter4dNV(GLuint id
, GLsizei len
, const GLubyte
*name
,
823 GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
825 _mesa_ProgramNamedParameter4fNV(id
, len
, name
, (GLfloat
)x
, (GLfloat
)y
,
826 (GLfloat
)z
, (GLfloat
)w
);
831 _mesa_ProgramNamedParameter4dvNV(GLuint id
, GLsizei len
, const GLubyte
*name
,
834 _mesa_ProgramNamedParameter4fNV(id
, len
, name
,
835 (GLfloat
)v
[0], (GLfloat
)v
[1],
836 (GLfloat
)v
[2], (GLfloat
)v
[3]);
841 _mesa_GetProgramNamedParameterfvNV(GLuint id
, GLsizei len
, const GLubyte
*name
,
844 struct gl_program
*prog
;
845 struct gl_fragment_program
*fragProg
;
848 GET_CURRENT_CONTEXT(ctx
);
850 if (!ctx
->_CurrentProgram
)
851 ASSERT_OUTSIDE_BEGIN_END(ctx
);
853 prog
= _mesa_lookup_program(ctx
, id
);
854 if (!prog
|| prog
->Target
!= GL_FRAGMENT_PROGRAM_NV
) {
855 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramNamedParameterNV");
860 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramNamedParameterNV");
864 fragProg
= (struct gl_fragment_program
*) prog
;
865 v
= _mesa_lookup_parameter_value(fragProg
->Base
.Parameters
,
875 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramNamedParameterNV");
880 _mesa_GetProgramNamedParameterdvNV(GLuint id
, GLsizei len
, const GLubyte
*name
,
883 GLfloat floatParams
[4];
884 _mesa_GetProgramNamedParameterfvNV(id
, len
, name
, floatParams
);
885 COPY_4V(params
, floatParams
);