2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2003 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 * ARB_vertex/fragment_program state management functions.
33 #include "arbprogram.h"
34 #include "arbfragparse.h"
35 #include "arbvertparse.h"
40 #include "nvprogram.h"
41 #include "nvfragparse.h"
42 #include "nvfragprog.h"
43 #include "nvvertparse.h"
44 #include "nvvertprog.h"
48 _mesa_EnableVertexAttribArrayARB(GLuint index
)
50 GET_CURRENT_CONTEXT(ctx
);
51 ASSERT_OUTSIDE_BEGIN_END(ctx
);
53 if (index
>= ctx
->Const
.MaxVertexProgramAttribs
) {
54 _mesa_error(ctx
, GL_INVALID_VALUE
,
55 "glEnableVertexAttribArrayARB(index)");
59 FLUSH_VERTICES(ctx
, _NEW_ARRAY
);
60 ctx
->Array
.VertexAttrib
[index
].Enabled
= GL_TRUE
;
61 ctx
->Array
._Enabled
|= _NEW_ARRAY_ATTRIB(index
);
62 ctx
->Array
.NewState
|= _NEW_ARRAY_ATTRIB(index
);
67 _mesa_DisableVertexAttribArrayARB(GLuint index
)
69 GET_CURRENT_CONTEXT(ctx
);
70 ASSERT_OUTSIDE_BEGIN_END(ctx
);
72 if (index
>= ctx
->Const
.MaxVertexProgramAttribs
) {
73 _mesa_error(ctx
, GL_INVALID_VALUE
,
74 "glEnableVertexAttribArrayARB(index)");
78 FLUSH_VERTICES(ctx
, _NEW_ARRAY
);
79 ctx
->Array
.VertexAttrib
[index
].Enabled
= GL_FALSE
;
80 ctx
->Array
._Enabled
&= ~_NEW_ARRAY_ATTRIB(index
);
81 ctx
->Array
.NewState
|= _NEW_ARRAY_ATTRIB(index
);
86 _mesa_GetVertexAttribdvARB(GLuint index
, GLenum pname
, GLdouble
*params
)
89 GET_CURRENT_CONTEXT(ctx
);
90 ASSERT_OUTSIDE_BEGIN_END(ctx
);
92 _mesa_GetVertexAttribfvARB(index
, pname
, fparams
);
93 if (ctx
->ErrorValue
== GL_NO_ERROR
) {
94 if (pname
== GL_CURRENT_VERTEX_ATTRIB_ARB
) {
95 COPY_4V(params
, fparams
);
98 params
[0] = fparams
[0];
105 _mesa_GetVertexAttribfvARB(GLuint index
, GLenum pname
, GLfloat
*params
)
107 GET_CURRENT_CONTEXT(ctx
);
108 ASSERT_OUTSIDE_BEGIN_END(ctx
);
110 if (index
== 0 || index
>= VERT_ATTRIB_MAX
) {
111 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetVertexAttribfvARB(index)");
116 case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB
:
117 params
[0] = (GLfloat
) ctx
->Array
.VertexAttrib
[index
].Enabled
;
119 case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB
:
120 params
[0] = (GLfloat
) ctx
->Array
.VertexAttrib
[index
].Size
;
122 case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB
:
123 params
[0] = (GLfloat
) ctx
->Array
.VertexAttrib
[index
].Stride
;
125 case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB
:
126 params
[0] = (GLfloat
) ctx
->Array
.VertexAttrib
[index
].Type
;
128 case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB
:
129 params
[0] = ctx
->Array
.VertexAttrib
[index
].Normalized
;
131 case GL_CURRENT_VERTEX_ATTRIB_ARB
:
132 FLUSH_CURRENT(ctx
, 0);
133 COPY_4V(params
, ctx
->Current
.Attrib
[index
]);
135 case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB
:
136 if (!ctx
->Extensions
.ARB_vertex_buffer_object
) {
137 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetVertexAttribfvARB(pname)");
140 params
[0] = (GLfloat
) ctx
->Array
.VertexAttrib
[index
].BufferObj
->Name
;
142 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetVertexAttribfvARB(pname)");
149 _mesa_GetVertexAttribivARB(GLuint index
, GLenum pname
, GLint
*params
)
152 GET_CURRENT_CONTEXT(ctx
);
153 ASSERT_OUTSIDE_BEGIN_END(ctx
);
155 _mesa_GetVertexAttribfvARB(index
, pname
, fparams
);
156 if (ctx
->ErrorValue
== GL_NO_ERROR
) {
157 if (pname
== GL_CURRENT_VERTEX_ATTRIB_ARB
) {
158 COPY_4V_CAST(params
, fparams
, GLint
); /* float to int */
161 params
[0] = (GLint
) fparams
[0];
168 _mesa_GetVertexAttribPointervARB(GLuint index
, GLenum pname
, GLvoid
**pointer
)
170 GET_CURRENT_CONTEXT(ctx
);
171 ASSERT_OUTSIDE_BEGIN_END(ctx
);
173 if (index
>= ctx
->Const
.MaxVertexProgramAttribs
) {
174 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetVertexAttribPointerARB(index)");
178 if (pname
!= GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB
) {
179 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetVertexAttribPointerARB(pname)");
183 *pointer
= (GLvoid
*) ctx
->Array
.VertexAttrib
[index
].Ptr
;;
188 _mesa_ProgramStringARB(GLenum target
, GLenum format
, GLsizei len
,
189 const GLvoid
*string
)
191 GET_CURRENT_CONTEXT(ctx
);
192 ASSERT_OUTSIDE_BEGIN_END(ctx
);
194 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
196 if (target
== GL_VERTEX_PROGRAM_ARB
197 && ctx
->Extensions
.ARB_vertex_program
) {
198 struct vertex_program
*prog
= ctx
->VertexProgram
.Current
;
199 if (format
!= GL_PROGRAM_FORMAT_ASCII_ARB
) {
200 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramStringARB(format)");
203 _mesa_parse_arb_vertex_program(ctx
, target
, (const GLubyte
*) string
,
206 else if (target
== GL_FRAGMENT_PROGRAM_ARB
207 && ctx
->Extensions
.ARB_fragment_program
) {
208 struct fragment_program
*prog
= ctx
->FragmentProgram
.Current
;
209 if (format
!= GL_PROGRAM_FORMAT_ASCII_ARB
) {
210 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramStringARB(format)");
213 _mesa_parse_arb_fragment_program(ctx
, target
, (const GLubyte
*) string
,
217 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramStringARB(target)");
223 _mesa_ProgramEnvParameter4dARB(GLenum target
, GLuint index
,
224 GLdouble x
, GLdouble y
, GLdouble z
, GLdouble w
)
226 _mesa_ProgramEnvParameter4fARB(target
, index
, (GLfloat
) x
, (GLfloat
) y
,
227 (GLfloat
) z
, (GLfloat
) w
);
232 _mesa_ProgramEnvParameter4dvARB(GLenum target
, GLuint index
,
233 const GLdouble
*params
)
235 _mesa_ProgramEnvParameter4fARB(target
, index
, (GLfloat
) params
[0],
236 (GLfloat
) params
[1], (GLfloat
) params
[2],
237 (GLfloat
) params
[3]);
242 _mesa_ProgramEnvParameter4fARB(GLenum target
, GLuint index
,
243 GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
245 GET_CURRENT_CONTEXT(ctx
);
246 ASSERT_OUTSIDE_BEGIN_END(ctx
);
248 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
250 if (target
== GL_FRAGMENT_PROGRAM_ARB
251 && ctx
->Extensions
.ARB_fragment_program
) {
252 if (index
>= ctx
->Const
.MaxFragmentProgramEnvParams
) {
253 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramEnvParameter(index)");
256 ASSIGN_4V(ctx
->FragmentProgram
.Parameters
[index
], x
, y
, z
, w
);
258 if (target
== GL_VERTEX_PROGRAM_ARB
259 && ctx
->Extensions
.ARB_vertex_program
) {
260 if (index
>= ctx
->Const
.MaxVertexProgramEnvParams
) {
261 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramEnvParameter(index)");
264 ASSIGN_4V(ctx
->VertexProgram
.Parameters
[index
], x
, y
, z
, w
);
267 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramEnvParameter(target)");
274 _mesa_ProgramEnvParameter4fvARB(GLenum target
, GLuint index
,
275 const GLfloat
*params
)
277 _mesa_ProgramEnvParameter4fARB(target
, index
, params
[0], params
[1],
278 params
[2], params
[3]);
283 _mesa_GetProgramEnvParameterdvARB(GLenum target
, GLuint index
,
286 GET_CURRENT_CONTEXT(ctx
);
289 _mesa_GetProgramEnvParameterfvARB(target
, index
, fparams
);
290 if (ctx
->ErrorValue
== GL_NO_ERROR
) {
291 params
[0] = fparams
[0];
292 params
[1] = fparams
[1];
293 params
[2] = fparams
[2];
294 params
[3] = fparams
[3];
300 _mesa_GetProgramEnvParameterfvARB(GLenum target
, GLuint index
,
303 GET_CURRENT_CONTEXT(ctx
);
305 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
307 if (!ctx
->_CurrentProgram
)
308 ASSERT_OUTSIDE_BEGIN_END(ctx
);
310 if (target
== GL_FRAGMENT_PROGRAM_ARB
311 && ctx
->Extensions
.ARB_fragment_program
) {
312 if (index
>= ctx
->Const
.MaxFragmentProgramEnvParams
) {
313 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramEnvParameter(index)");
316 COPY_4V(params
, ctx
->FragmentProgram
.Parameters
[index
]);
318 if (target
== GL_VERTEX_PROGRAM_ARB
319 && ctx
->Extensions
.ARB_vertex_program
) {
320 if (index
>= ctx
->Const
.MaxVertexProgramEnvParams
) {
321 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramEnvParameter(index)");
324 COPY_4V(params
, ctx
->VertexProgram
.Parameters
[index
]);
327 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramEnvParameter(target)");
334 * Note, this function is also used by the GL_NV_fragment_program extension.
337 _mesa_ProgramLocalParameter4fARB(GLenum target
, GLuint index
,
338 GLfloat x
, GLfloat y
, GLfloat z
, GLfloat w
)
340 GET_CURRENT_CONTEXT(ctx
);
341 struct program
*prog
;
342 ASSERT_OUTSIDE_BEGIN_END(ctx
);
344 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
346 if ((target
== GL_FRAGMENT_PROGRAM_NV
347 && ctx
->Extensions
.NV_fragment_program
) ||
348 (target
== GL_FRAGMENT_PROGRAM_ARB
349 && ctx
->Extensions
.ARB_fragment_program
)) {
350 if (index
>= ctx
->Const
.MaxFragmentProgramLocalParams
) {
351 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramLocalParameterARB");
354 prog
= &(ctx
->FragmentProgram
.Current
->Base
);
356 else if (target
== GL_VERTEX_PROGRAM_ARB
357 && ctx
->Extensions
.ARB_vertex_program
) {
358 if (index
>= ctx
->Const
.MaxVertexProgramLocalParams
) {
359 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramLocalParameterARB");
362 prog
= &(ctx
->VertexProgram
.Current
->Base
);
365 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramLocalParameterARB");
369 ASSERT(index
< MAX_PROGRAM_LOCAL_PARAMS
);
370 prog
->LocalParams
[index
][0] = x
;
371 prog
->LocalParams
[index
][1] = y
;
372 prog
->LocalParams
[index
][2] = z
;
373 prog
->LocalParams
[index
][3] = w
;
378 * Note, this function is also used by the GL_NV_fragment_program extension.
381 _mesa_ProgramLocalParameter4fvARB(GLenum target
, GLuint index
,
382 const GLfloat
*params
)
384 _mesa_ProgramLocalParameter4fARB(target
, index
, params
[0], params
[1],
385 params
[2], params
[3]);
390 * Note, this function is also used by the GL_NV_fragment_program extension.
393 _mesa_ProgramLocalParameter4dARB(GLenum target
, GLuint index
,
394 GLdouble x
, GLdouble y
,
395 GLdouble z
, GLdouble w
)
397 _mesa_ProgramLocalParameter4fARB(target
, index
, (GLfloat
) x
, (GLfloat
) y
,
398 (GLfloat
) z
, (GLfloat
) w
);
403 * Note, this function is also used by the GL_NV_fragment_program extension.
406 _mesa_ProgramLocalParameter4dvARB(GLenum target
, GLuint index
,
407 const GLdouble
*params
)
409 _mesa_ProgramLocalParameter4fARB(target
, index
,
410 (GLfloat
) params
[0], (GLfloat
) params
[1],
411 (GLfloat
) params
[2], (GLfloat
) params
[3]);
416 * Note, this function is also used by the GL_NV_fragment_program extension.
419 _mesa_GetProgramLocalParameterfvARB(GLenum target
, GLuint index
,
422 const struct program
*prog
;
424 GET_CURRENT_CONTEXT(ctx
);
425 ASSERT_OUTSIDE_BEGIN_END(ctx
);
427 if (target
== GL_VERTEX_PROGRAM_ARB
428 && ctx
->Extensions
.ARB_vertex_program
) {
429 prog
= &(ctx
->VertexProgram
.Current
->Base
);
430 maxParams
= ctx
->Const
.MaxVertexProgramLocalParams
;
432 else if (target
== GL_FRAGMENT_PROGRAM_ARB
433 && ctx
->Extensions
.ARB_fragment_program
) {
434 prog
= &(ctx
->FragmentProgram
.Current
->Base
);
435 maxParams
= ctx
->Const
.MaxFragmentProgramLocalParams
;
437 else if (target
== GL_FRAGMENT_PROGRAM_NV
438 && ctx
->Extensions
.NV_fragment_program
) {
439 prog
= &(ctx
->FragmentProgram
.Current
->Base
);
440 maxParams
= MAX_NV_FRAGMENT_PROGRAM_PARAMS
;
443 _mesa_error(ctx
, GL_INVALID_ENUM
,
444 "glGetProgramLocalParameterARB(target)");
448 if (index
>= maxParams
) {
449 _mesa_error(ctx
, GL_INVALID_VALUE
,
450 "glGetProgramLocalParameterARB(index)");
455 ASSERT(index
< MAX_PROGRAM_LOCAL_PARAMS
);
456 COPY_4V(params
, prog
->LocalParams
[index
]);
461 * Note, this function is also used by the GL_NV_fragment_program extension.
464 _mesa_GetProgramLocalParameterdvARB(GLenum target
, GLuint index
,
467 GET_CURRENT_CONTEXT(ctx
);
468 GLfloat floatParams
[4];
469 _mesa_GetProgramLocalParameterfvARB(target
, index
, floatParams
);
470 if (ctx
->ErrorValue
== GL_NO_ERROR
) {
471 COPY_4V(params
, floatParams
);
477 _mesa_GetProgramivARB(GLenum target
, GLenum pname
, GLint
*params
)
479 struct program
*prog
;
480 GET_CURRENT_CONTEXT(ctx
);
482 if (!ctx
->_CurrentProgram
)
483 ASSERT_OUTSIDE_BEGIN_END(ctx
);
485 if (target
== GL_VERTEX_PROGRAM_ARB
486 && ctx
->Extensions
.ARB_vertex_program
) {
487 prog
= &(ctx
->VertexProgram
.Current
->Base
);
489 else if (target
== GL_FRAGMENT_PROGRAM_ARB
490 && ctx
->Extensions
.ARB_fragment_program
) {
491 prog
= &(ctx
->FragmentProgram
.Current
->Base
);
494 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramivARB(target)");
501 case GL_PROGRAM_LENGTH_ARB
:
502 *params
= prog
->String
? _mesa_strlen((char *) prog
->String
) : 0;
504 case GL_PROGRAM_FORMAT_ARB
:
505 *params
= prog
->Format
;
507 case GL_PROGRAM_BINDING_ARB
:
510 case GL_PROGRAM_INSTRUCTIONS_ARB
:
511 *params
= prog
->NumInstructions
;
513 case GL_MAX_PROGRAM_INSTRUCTIONS_ARB
:
514 if (target
== GL_VERTEX_PROGRAM_ARB
)
515 *params
= ctx
->Const
.MaxVertexProgramInstructions
;
517 *params
= ctx
->Const
.MaxFragmentProgramInstructions
;
519 case GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB
:
520 *params
= prog
->NumInstructions
;
522 case GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB
:
523 if (target
== GL_VERTEX_PROGRAM_ARB
)
524 *params
= ctx
->Const
.MaxVertexProgramInstructions
;
526 *params
= ctx
->Const
.MaxFragmentProgramInstructions
;
528 case GL_PROGRAM_TEMPORARIES_ARB
:
529 *params
= prog
->NumTemporaries
;
531 case GL_MAX_PROGRAM_TEMPORARIES_ARB
:
532 if (target
== GL_VERTEX_PROGRAM_ARB
)
533 *params
= ctx
->Const
.MaxVertexProgramTemps
;
535 *params
= ctx
->Const
.MaxFragmentProgramTemps
;
537 case GL_PROGRAM_NATIVE_TEMPORARIES_ARB
:
538 /* XXX same as GL_PROGRAM_TEMPORARIES_ARB? */
539 *params
= prog
->NumTemporaries
;
541 case GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB
:
542 /* XXX same as GL_MAX_PROGRAM_TEMPORARIES_ARB? */
543 if (target
== GL_VERTEX_PROGRAM_ARB
)
544 *params
= ctx
->Const
.MaxVertexProgramTemps
;
546 *params
= ctx
->Const
.MaxFragmentProgramTemps
;
548 case GL_PROGRAM_PARAMETERS_ARB
:
549 *params
= prog
->NumParameters
;
551 case GL_MAX_PROGRAM_PARAMETERS_ARB
:
552 if (target
== GL_VERTEX_PROGRAM_ARB
)
553 *params
= ctx
->Const
.MaxVertexProgramLocalParams
;
555 *params
= ctx
->Const
.MaxFragmentProgramLocalParams
;
557 case GL_PROGRAM_NATIVE_PARAMETERS_ARB
:
558 /* XXX same as GL_MAX_PROGRAM_PARAMETERS_ARB? */
559 *params
= prog
->NumParameters
;
561 case GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB
:
562 /* XXX same as GL_MAX_PROGRAM_PARAMETERS_ARB? */
563 if (target
== GL_VERTEX_PROGRAM_ARB
)
564 *params
= ctx
->Const
.MaxVertexProgramLocalParams
;
566 *params
= ctx
->Const
.MaxFragmentProgramLocalParams
;
568 case GL_PROGRAM_ATTRIBS_ARB
:
569 *params
= prog
->NumAttributes
;
571 case GL_MAX_PROGRAM_ATTRIBS_ARB
:
572 if (target
== GL_VERTEX_PROGRAM_ARB
)
573 *params
= ctx
->Const
.MaxVertexProgramAttribs
;
575 *params
= ctx
->Const
.MaxFragmentProgramAttribs
;
577 case GL_PROGRAM_NATIVE_ATTRIBS_ARB
:
578 /* XXX same as GL_PROGRAM_ATTRIBS_ARB? */
579 *params
= prog
->NumAttributes
;
581 case GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB
:
582 /* XXX same as GL_MAX_PROGRAM_ATTRIBS_ARB? */
583 if (target
== GL_VERTEX_PROGRAM_ARB
)
584 *params
= ctx
->Const
.MaxVertexProgramAttribs
;
586 *params
= ctx
->Const
.MaxFragmentProgramAttribs
;
588 case GL_PROGRAM_ADDRESS_REGISTERS_ARB
:
589 *params
= prog
->NumAddressRegs
;
591 case GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB
:
592 if (target
== GL_VERTEX_PROGRAM_ARB
)
593 *params
= ctx
->Const
.MaxVertexProgramAddressRegs
;
595 *params
= ctx
->Const
.MaxFragmentProgramAddressRegs
;
597 case GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB
:
598 /* XXX same as GL_PROGRAM_ADDRESS_REGISTERS_ARB? */
599 *params
= prog
->NumAddressRegs
;
601 case GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB
:
602 /* XXX same as GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB? */
603 if (target
== GL_VERTEX_PROGRAM_ARB
)
604 *params
= ctx
->Const
.MaxVertexProgramAddressRegs
;
606 *params
= ctx
->Const
.MaxFragmentProgramAddressRegs
;
608 case GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB
:
609 if (target
== GL_VERTEX_PROGRAM_ARB
)
610 *params
= ctx
->Const
.MaxVertexProgramLocalParams
;
612 *params
= ctx
->Const
.MaxFragmentProgramLocalParams
;
614 case GL_MAX_PROGRAM_ENV_PARAMETERS_ARB
:
615 if (target
== GL_VERTEX_PROGRAM_ARB
)
616 *params
= ctx
->Const
.MaxVertexProgramEnvParams
;
618 *params
= ctx
->Const
.MaxFragmentProgramEnvParams
;
620 case GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB
:
626 * The following apply to fragment programs only.
628 case GL_PROGRAM_ALU_INSTRUCTIONS_ARB
:
629 case GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB
:
630 if (target
!= GL_FRAGMENT_PROGRAM_ARB
) {
631 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramivARB(target)");
634 *params
= ctx
->FragmentProgram
.Current
->NumAluInstructions
;
636 case GL_PROGRAM_TEX_INSTRUCTIONS_ARB
:
637 case GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB
:
638 if (target
!= GL_FRAGMENT_PROGRAM_ARB
) {
639 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramivARB(target)");
642 *params
= ctx
->FragmentProgram
.Current
->NumTexInstructions
;
644 case GL_PROGRAM_TEX_INDIRECTIONS_ARB
:
645 case GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB
:
646 if (target
!= GL_FRAGMENT_PROGRAM_ARB
) {
647 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramivARB(target)");
650 *params
= ctx
->FragmentProgram
.Current
->NumTexIndirections
;
652 case GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB
:
653 case GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB
:
654 if (target
!= GL_FRAGMENT_PROGRAM_ARB
) {
655 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramivARB(target)");
658 *params
= ctx
->Const
.MaxFragmentProgramAluInstructions
;
660 case GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB
:
661 case GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB
:
662 if (target
!= GL_FRAGMENT_PROGRAM_ARB
) {
663 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramivARB(target)");
666 *params
= ctx
->Const
.MaxFragmentProgramTexInstructions
;
668 case GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB
:
669 case GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB
:
670 if (target
!= GL_FRAGMENT_PROGRAM_ARB
) {
671 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramivARB(target)");
674 *params
= ctx
->Const
.MaxFragmentProgramTexIndirections
;
677 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramivARB(pname)");
684 _mesa_GetProgramStringARB(GLenum target
, GLenum pname
, GLvoid
*string
)
686 struct program
*prog
;
687 GET_CURRENT_CONTEXT(ctx
);
689 if (!ctx
->_CurrentProgram
)
690 ASSERT_OUTSIDE_BEGIN_END(ctx
);
692 if (target
== GL_VERTEX_PROGRAM_ARB
) {
693 prog
= &(ctx
->VertexProgram
.Current
->Base
);
695 else if (target
== GL_FRAGMENT_PROGRAM_ARB
) {
696 prog
= &(ctx
->FragmentProgram
.Current
->Base
);
699 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramStringARB(target)");
705 if (pname
!= GL_PROGRAM_STRING_ARB
) {
706 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramStringARB(pname)");
710 MEMCPY(string
, prog
->String
, _mesa_strlen((char *) prog
->String
));