2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2004 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 "nvfragprog.h"
48 #include "nvvertexec.h"
49 #include "nvvertparse.h"
50 #include "nvvertprog.h"
51 #include "nvprogram.h"
57 * Execute a vertex state program.
58 * \note Called from the GL API dispatcher.
61 _mesa_ExecuteProgramNV(GLenum target
, GLuint id
, const GLfloat
*params
)
63 struct vertex_program
*vprog
;
64 GET_CURRENT_CONTEXT(ctx
);
65 ASSERT_OUTSIDE_BEGIN_END(ctx
);
67 if (target
!= GL_VERTEX_STATE_PROGRAM_NV
) {
68 _mesa_error(ctx
, GL_INVALID_ENUM
, "glExecuteProgramNV");
72 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
74 vprog
= (struct vertex_program
*)
75 _mesa_HashLookup(ctx
->Shared
->Programs
, id
);
77 if (!vprog
|| vprog
->Base
.Target
!= GL_VERTEX_STATE_PROGRAM_NV
) {
78 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glExecuteProgramNV");
82 _mesa_init_vp_per_vertex_registers(ctx
);
83 _mesa_init_vp_per_primitive_registers(ctx
);
84 COPY_4V(ctx
->VertexProgram
.Inputs
[VERT_ATTRIB_POS
], params
);
85 _mesa_exec_vertex_program(ctx
, vprog
);
90 * Determine if a set of programs is resident in hardware.
91 * \note Not compiled into display lists.
92 * \note Called from the GL API dispatcher.
94 GLboolean GLAPIENTRY
_mesa_AreProgramsResidentNV(GLsizei n
, const GLuint
*ids
,
95 GLboolean
*residences
)
98 GLboolean allResident
= GL_TRUE
;
99 GET_CURRENT_CONTEXT(ctx
);
100 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx
, GL_FALSE
);
103 _mesa_error(ctx
, GL_INVALID_VALUE
, "glAreProgramsResidentNV(n)");
107 for (i
= 0; i
< n
; i
++) {
108 const struct program
*prog
;
110 _mesa_error(ctx
, GL_INVALID_VALUE
, "glAreProgramsResidentNV");
113 prog
= (const struct program
*)
114 _mesa_HashLookup(ctx
->Shared
->Programs
, ids
[i
]);
116 _mesa_error(ctx
, GL_INVALID_VALUE
, "glAreProgramsResidentNV");
119 if (prog
->Resident
) {
121 residences
[i
] = GL_TRUE
;
125 allResident
= GL_FALSE
;
126 for (j
= 0; j
< i
; j
++)
127 residences
[j
] = GL_TRUE
;
129 residences
[i
] = GL_FALSE
;
138 * Request that a set of programs be resident in hardware.
139 * \note Called from the GL API dispatcher.
142 _mesa_RequestResidentProgramsNV(GLsizei n
, const GLuint
*ids
)
145 GET_CURRENT_CONTEXT(ctx
);
146 ASSERT_OUTSIDE_BEGIN_END(ctx
);
149 _mesa_error(ctx
, GL_INVALID_VALUE
, "glRequestResidentProgramsNV(n)");
153 /* just error checking for now */
154 for (i
= 0; i
< n
; i
++) {
155 struct program
*prog
;
158 _mesa_error(ctx
, GL_INVALID_VALUE
, "glRequestResidentProgramsNV(id)");
162 prog
= (struct program
*) _mesa_HashLookup(ctx
->Shared
->Programs
, ids
[i
]);
164 _mesa_error(ctx
, GL_INVALID_VALUE
, "glRequestResidentProgramsNV(id)");
168 /* XXX this is really a hardware thing we should hook out */
169 prog
->Resident
= GL_TRUE
;
175 * Get a program parameter register.
176 * \note Not compiled into display lists.
177 * \note Called from the GL API dispatcher.
180 _mesa_GetProgramParameterfvNV(GLenum target
, GLuint index
,
181 GLenum pname
, GLfloat
*params
)
183 GET_CURRENT_CONTEXT(ctx
);
184 ASSERT_OUTSIDE_BEGIN_END(ctx
);
186 if (target
== GL_VERTEX_PROGRAM_NV
) {
187 if (pname
== GL_PROGRAM_PARAMETER_NV
) {
188 if (index
< MAX_NV_VERTEX_PROGRAM_PARAMS
) {
189 COPY_4V(params
, ctx
->VertexProgram
.Parameters
[index
]);
192 _mesa_error(ctx
, GL_INVALID_VALUE
,
193 "glGetProgramParameterfvNV(index)");
198 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramParameterfvNV(pname)");
203 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramParameterfvNV(target)");
210 * Get a program parameter register.
211 * \note Not compiled into display lists.
212 * \note Called from the GL API dispatcher.
215 _mesa_GetProgramParameterdvNV(GLenum target
, GLuint index
,
216 GLenum pname
, GLdouble
*params
)
218 GET_CURRENT_CONTEXT(ctx
);
219 ASSERT_OUTSIDE_BEGIN_END(ctx
);
221 if (target
== GL_VERTEX_PROGRAM_NV
) {
222 if (pname
== GL_PROGRAM_PARAMETER_NV
) {
223 if (index
< MAX_NV_VERTEX_PROGRAM_PARAMS
) {
224 COPY_4V(params
, ctx
->VertexProgram
.Parameters
[index
]);
227 _mesa_error(ctx
, GL_INVALID_VALUE
,
228 "glGetProgramParameterdvNV(index)");
233 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramParameterdvNV(pname)");
238 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramParameterdvNV(target)");
245 * Get a program attribute.
246 * \note Not compiled into display lists.
247 * \note Called from the GL API dispatcher.
250 _mesa_GetProgramivNV(GLuint id
, GLenum pname
, GLint
*params
)
252 struct program
*prog
;
253 GET_CURRENT_CONTEXT(ctx
);
255 if (!ctx
->_CurrentProgram
)
256 ASSERT_OUTSIDE_BEGIN_END(ctx
);
258 prog
= (struct program
*) _mesa_HashLookup(ctx
->Shared
->Programs
, id
);
260 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramivNV");
265 case GL_PROGRAM_TARGET_NV
:
266 *params
= prog
->Target
;
268 case GL_PROGRAM_LENGTH_NV
:
269 *params
= prog
->String
?(GLint
)_mesa_strlen((char *) prog
->String
) : 0;
271 case GL_PROGRAM_RESIDENT_NV
:
272 *params
= prog
->Resident
;
275 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramivNV(pname)");
282 * Get the program source code.
283 * \note Not compiled into display lists.
284 * \note Called from the GL API dispatcher.
287 _mesa_GetProgramStringNV(GLuint id
, GLenum pname
, GLubyte
*program
)
289 struct program
*prog
;
290 GET_CURRENT_CONTEXT(ctx
);
292 if (!ctx
->_CurrentProgram
)
293 ASSERT_OUTSIDE_BEGIN_END(ctx
);
295 if (pname
!= GL_PROGRAM_STRING_NV
) {
296 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramStringNV(pname)");
300 prog
= (struct program
*) _mesa_HashLookup(ctx
->Shared
->Programs
, id
);
302 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramStringNV");
307 MEMCPY(program
, prog
->String
, _mesa_strlen((char *) prog
->String
));
316 * Get matrix tracking information.
317 * \note Not compiled into display lists.
318 * \note Called from the GL API dispatcher.
321 _mesa_GetTrackMatrixivNV(GLenum target
, GLuint address
,
322 GLenum pname
, GLint
*params
)
324 GET_CURRENT_CONTEXT(ctx
);
325 ASSERT_OUTSIDE_BEGIN_END(ctx
);
327 if (target
== GL_VERTEX_PROGRAM_NV
328 && ctx
->Extensions
.NV_vertex_program
) {
331 if ((address
& 0x3) || address
>= MAX_NV_VERTEX_PROGRAM_PARAMS
) {
332 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetTrackMatrixivNV(address)");
339 case GL_TRACK_MATRIX_NV
:
340 params
[0] = (GLint
) ctx
->VertexProgram
.TrackMatrix
[i
];
342 case GL_TRACK_MATRIX_TRANSFORM_NV
:
343 params
[0] = (GLint
) ctx
->VertexProgram
.TrackMatrixTransform
[i
];
346 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetTrackMatrixivNV");
351 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetTrackMatrixivNV");
358 * Get a vertex (or vertex array) attribute.
359 * \note Not compiled into display lists.
360 * \note Called from the GL API dispatcher.
363 _mesa_GetVertexAttribdvNV(GLuint index
, GLenum pname
, GLdouble
*params
)
365 GET_CURRENT_CONTEXT(ctx
);
366 ASSERT_OUTSIDE_BEGIN_END(ctx
);
368 if (index
== 0 || index
>= MAX_NV_VERTEX_PROGRAM_INPUTS
) {
369 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetVertexAttribdvNV(index)");
374 case GL_ATTRIB_ARRAY_SIZE_NV
:
375 params
[0] = ctx
->Array
.VertexAttrib
[index
].Size
;
377 case GL_ATTRIB_ARRAY_STRIDE_NV
:
378 params
[0] = ctx
->Array
.VertexAttrib
[index
].Stride
;
380 case GL_ATTRIB_ARRAY_TYPE_NV
:
381 params
[0] = ctx
->Array
.VertexAttrib
[index
].Type
;
383 case GL_CURRENT_ATTRIB_NV
:
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
== 0 || 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
.VertexAttrib
[index
].Size
;
413 case GL_ATTRIB_ARRAY_STRIDE_NV
:
414 params
[0] = (GLfloat
) ctx
->Array
.VertexAttrib
[index
].Stride
;
416 case GL_ATTRIB_ARRAY_TYPE_NV
:
417 params
[0] = (GLfloat
) ctx
->Array
.VertexAttrib
[index
].Type
;
419 case GL_CURRENT_ATTRIB_NV
:
420 FLUSH_CURRENT(ctx
, 0);
421 COPY_4V(params
, ctx
->Current
.Attrib
[index
]);
424 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetVertexAttribdvNV");
430 * Get a vertex (or vertex array) attribute.
431 * \note Not compiled into display lists.
432 * \note Called from the GL API dispatcher.
435 _mesa_GetVertexAttribivNV(GLuint index
, GLenum pname
, GLint
*params
)
437 GET_CURRENT_CONTEXT(ctx
);
438 ASSERT_OUTSIDE_BEGIN_END(ctx
);
440 if (index
== 0 || index
>= MAX_NV_VERTEX_PROGRAM_INPUTS
) {
441 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetVertexAttribdvNV(index)");
446 case GL_ATTRIB_ARRAY_SIZE_NV
:
447 params
[0] = ctx
->Array
.VertexAttrib
[index
].Size
;
449 case GL_ATTRIB_ARRAY_STRIDE_NV
:
450 params
[0] = ctx
->Array
.VertexAttrib
[index
].Stride
;
452 case GL_ATTRIB_ARRAY_TYPE_NV
:
453 params
[0] = ctx
->Array
.VertexAttrib
[index
].Type
;
455 case GL_CURRENT_ATTRIB_NV
:
456 FLUSH_CURRENT(ctx
, 0);
457 params
[0] = (GLint
) ctx
->Current
.Attrib
[index
][0];
458 params
[1] = (GLint
) ctx
->Current
.Attrib
[index
][1];
459 params
[2] = (GLint
) ctx
->Current
.Attrib
[index
][2];
460 params
[3] = (GLint
) ctx
->Current
.Attrib
[index
][3];
462 case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB
:
463 if (!ctx
->Extensions
.ARB_vertex_buffer_object
) {
464 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetVertexAttribdvNV");
467 params
[0] = ctx
->Array
.VertexAttrib
[index
].BufferObj
->Name
;
470 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetVertexAttribdvNV");
477 * Get a vertex array attribute pointer.
478 * \note Not compiled into display lists.
479 * \note Called from the GL API dispatcher.
482 _mesa_GetVertexAttribPointervNV(GLuint index
, GLenum pname
, GLvoid
**pointer
)
484 GET_CURRENT_CONTEXT(ctx
);
485 ASSERT_OUTSIDE_BEGIN_END(ctx
);
487 if (index
>= MAX_NV_VERTEX_PROGRAM_INPUTS
) {
488 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetVertexAttribPointerNV(index)");
492 if (pname
!= GL_ATTRIB_ARRAY_POINTER_NV
) {
493 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetVertexAttribPointerNV(pname)");
497 *pointer
= (GLvoid
*) ctx
->Array
.VertexAttrib
[index
].Ptr
;;
503 * Load/parse/compile a program.
504 * \note Called from the GL API dispatcher.
507 _mesa_LoadProgramNV(GLenum target
, GLuint id
, GLsizei len
,
508 const GLubyte
*program
)
510 struct program
*prog
;
511 GET_CURRENT_CONTEXT(ctx
);
512 ASSERT_OUTSIDE_BEGIN_END(ctx
);
515 _mesa_error(ctx
, GL_INVALID_VALUE
, "glLoadProgramNV(id)");
519 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
521 prog
= (struct program
*) _mesa_HashLookup(ctx
->Shared
->Programs
, id
);
523 if (prog
&& prog
->Target
!= 0 && prog
->Target
!= target
) {
524 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glLoadProgramNV(target)");
528 if ((target
== GL_VERTEX_PROGRAM_NV
||
529 target
== GL_VERTEX_STATE_PROGRAM_NV
)
530 && ctx
->Extensions
.NV_vertex_program
) {
531 struct vertex_program
*vprog
= (struct vertex_program
*) prog
;
532 if (!vprog
|| prog
== &_mesa_DummyProgram
) {
533 vprog
= (struct vertex_program
*)
534 ctx
->Driver
.NewProgram(ctx
, target
, id
);
536 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glLoadProgramNV");
539 _mesa_HashInsert(ctx
->Shared
->Programs
, id
, vprog
);
541 _mesa_parse_nv_vertex_program(ctx
, target
, program
, len
, vprog
);
543 else if (target
== GL_FRAGMENT_PROGRAM_NV
544 && ctx
->Extensions
.NV_fragment_program
) {
545 struct fragment_program
*fprog
= (struct fragment_program
*) prog
;
546 if (!fprog
|| prog
== &_mesa_DummyProgram
) {
547 fprog
= (struct fragment_program
*)
548 ctx
->Driver
.NewProgram(ctx
, target
, id
);
550 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glLoadProgramNV");
553 _mesa_HashInsert(ctx
->Shared
->Programs
, id
, fprog
);
555 _mesa_parse_nv_fragment_program(ctx
, target
, program
, len
, fprog
);
558 _mesa_error(ctx
, GL_INVALID_ENUM
, "glLoadProgramNV(target)");
565 * Set a program parameter register.
566 * \note Called from the GL API dispatcher.
569 _mesa_ProgramParameter4dNV(GLenum target
, GLuint index
,
570 GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
572 _mesa_ProgramParameter4fNV(target
, index
,
573 (GLfloat
)x
, (GLfloat
)y
, (GLfloat
)z
, (GLfloat
)w
);
578 * Set a program parameter register.
579 * \note Called from the GL API dispatcher.
582 _mesa_ProgramParameter4dvNV(GLenum target
, GLuint index
,
583 const GLdouble
*params
)
585 _mesa_ProgramParameter4fNV(target
, index
,
586 (GLfloat
)params
[0], (GLfloat
)params
[1],
587 (GLfloat
)params
[2], (GLfloat
)params
[3]);
592 * Set a program parameter register.
593 * \note Called from the GL API dispatcher.
596 _mesa_ProgramParameter4fNV(GLenum target
, GLuint index
,
597 GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
599 GET_CURRENT_CONTEXT(ctx
);
600 ASSERT_OUTSIDE_BEGIN_END(ctx
);
602 if (target
== GL_VERTEX_PROGRAM_NV
&& ctx
->Extensions
.NV_vertex_program
) {
603 if (index
< MAX_NV_VERTEX_PROGRAM_PARAMS
) {
604 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
605 ASSIGN_4V(ctx
->VertexProgram
.Parameters
[index
], x
, y
, z
, w
);
608 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramParameterNV(index)");
613 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameterNV");
620 * Set a program parameter register.
621 * \note Called from the GL API dispatcher.
624 _mesa_ProgramParameter4fvNV(GLenum target
, GLuint index
,
625 const GLfloat
*params
)
627 _mesa_ProgramParameter4fNV(target
, index
,
628 params
[0], params
[1], params
[2], params
[3]);
634 * Set a sequence of program parameter registers.
635 * \note Called from the GL API dispatcher.
638 _mesa_ProgramParameters4dvNV(GLenum target
, GLuint index
,
639 GLuint num
, const GLdouble
*params
)
641 GET_CURRENT_CONTEXT(ctx
);
642 ASSERT_OUTSIDE_BEGIN_END(ctx
);
644 if (target
== GL_VERTEX_PROGRAM_NV
&& ctx
->Extensions
.NV_vertex_program
) {
646 if (index
+ num
> MAX_NV_VERTEX_PROGRAM_PARAMS
) {
647 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramParameters4dvNV");
650 for (i
= 0; i
< num
; i
++) {
651 ctx
->VertexProgram
.Parameters
[index
+ i
][0] = (GLfloat
) params
[0];
652 ctx
->VertexProgram
.Parameters
[index
+ i
][1] = (GLfloat
) params
[1];
653 ctx
->VertexProgram
.Parameters
[index
+ i
][2] = (GLfloat
) params
[2];
654 ctx
->VertexProgram
.Parameters
[index
+ i
][3] = (GLfloat
) params
[3];
659 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameters4dvNV");
666 * Set a sequence of program parameter registers.
667 * \note Called from the GL API dispatcher.
670 _mesa_ProgramParameters4fvNV(GLenum target
, GLuint index
,
671 GLuint num
, const GLfloat
*params
)
673 GET_CURRENT_CONTEXT(ctx
);
674 ASSERT_OUTSIDE_BEGIN_END(ctx
);
676 if (target
== GL_VERTEX_PROGRAM_NV
&& ctx
->Extensions
.NV_vertex_program
) {
678 if (index
+ num
> MAX_NV_VERTEX_PROGRAM_PARAMS
) {
679 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramParameters4fvNV");
682 for (i
= 0; i
< num
; i
++) {
683 COPY_4V(ctx
->VertexProgram
.Parameters
[index
+ i
], params
);
688 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameters4fvNV");
696 * Setup tracking of matrices into program parameter registers.
697 * \note Called from the GL API dispatcher.
700 _mesa_TrackMatrixNV(GLenum target
, GLuint address
,
701 GLenum matrix
, GLenum transform
)
703 GET_CURRENT_CONTEXT(ctx
);
704 ASSERT_OUTSIDE_BEGIN_END(ctx
);
706 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
708 if (target
== GL_VERTEX_PROGRAM_NV
&& ctx
->Extensions
.NV_vertex_program
) {
710 /* addr must be multiple of four */
711 _mesa_error(ctx
, GL_INVALID_VALUE
, "glTrackMatrixNV(address)");
721 case GL_MODELVIEW_PROJECTION_NV
:
730 /* OK, fallthrough */
733 _mesa_error(ctx
, GL_INVALID_ENUM
, "glTrackMatrixNV(matrix)");
740 case GL_TRANSPOSE_NV
:
741 case GL_INVERSE_TRANSPOSE_NV
:
742 /* OK, fallthrough */
745 _mesa_error(ctx
, GL_INVALID_ENUM
, "glTrackMatrixNV(transform)");
749 ctx
->VertexProgram
.TrackMatrix
[address
/ 4] = matrix
;
750 ctx
->VertexProgram
.TrackMatrixTransform
[address
/ 4] = transform
;
753 _mesa_error(ctx
, GL_INVALID_ENUM
, "glTrackMatrixNV(target)");
760 _mesa_ProgramNamedParameter4fNV(GLuint id
, GLsizei len
, const GLubyte
*name
,
761 GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
763 struct program
*prog
;
764 struct fragment_program
*fragProg
;
767 GET_CURRENT_CONTEXT(ctx
);
768 ASSERT_OUTSIDE_BEGIN_END(ctx
);
770 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
772 prog
= (struct program
*) _mesa_HashLookup(ctx
->Shared
->Programs
, id
);
773 if (!prog
|| prog
->Target
!= GL_FRAGMENT_PROGRAM_NV
) {
774 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glProgramNamedParameterNV");
779 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramNamedParameterNV(len)");
783 fragProg
= (struct fragment_program
*) prog
;
784 v
= _mesa_lookup_parameter_value(fragProg
->Parameters
, len
, (char *) name
);
793 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramNamedParameterNV(name)");
798 _mesa_ProgramNamedParameter4fvNV(GLuint id
, GLsizei len
, const GLubyte
*name
,
801 _mesa_ProgramNamedParameter4fNV(id
, len
, name
, v
[0], v
[1], v
[2], v
[3]);
806 _mesa_ProgramNamedParameter4dNV(GLuint id
, GLsizei len
, const GLubyte
*name
,
807 GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
809 _mesa_ProgramNamedParameter4fNV(id
, len
, name
, (GLfloat
)x
, (GLfloat
)y
,
810 (GLfloat
)z
, (GLfloat
)w
);
815 _mesa_ProgramNamedParameter4dvNV(GLuint id
, GLsizei len
, const GLubyte
*name
,
818 _mesa_ProgramNamedParameter4fNV(id
, len
, name
,
819 (GLfloat
)v
[0], (GLfloat
)v
[1],
820 (GLfloat
)v
[2], (GLfloat
)v
[3]);
825 _mesa_GetProgramNamedParameterfvNV(GLuint id
, GLsizei len
, const GLubyte
*name
,
828 struct program
*prog
;
829 struct fragment_program
*fragProg
;
832 GET_CURRENT_CONTEXT(ctx
);
834 if (!ctx
->_CurrentProgram
)
835 ASSERT_OUTSIDE_BEGIN_END(ctx
);
837 prog
= (struct program
*) _mesa_HashLookup(ctx
->Shared
->Programs
, id
);
838 if (!prog
|| prog
->Target
!= GL_FRAGMENT_PROGRAM_NV
) {
839 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramNamedParameterNV");
844 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramNamedParameterNV");
848 fragProg
= (struct fragment_program
*) prog
;
849 v
= _mesa_lookup_parameter_value(fragProg
->Parameters
, len
, (char *) name
);
858 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramNamedParameterNV");
863 _mesa_GetProgramNamedParameterdvNV(GLuint id
, GLsizei len
, const GLubyte
*name
,
866 GLfloat floatParams
[4];
867 _mesa_GetProgramNamedParameterfvNV(id
, len
, name
, floatParams
);
868 COPY_4V(params
, floatParams
);