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 * \file tnl/t_vb_program.c
28 * \brief Pipeline stage for executing NVIDIA vertex programs.
29 * \author Brian Paul, Keith Whitwell
42 #include "simple_list.h"
44 #include "nvvertprog.h"
45 #include "nvvertexec.h"
46 #include "nvprogram.h"
48 #include "math/m_translate.h"
50 #include "t_context.h"
51 #include "t_pipeline.h"
55 * \warning These values _MUST_ match the values in the OutputRegisters[]
56 * array in vpparse.c!!!
58 #define VERT_RESULT_HPOS 0
59 #define VERT_RESULT_COL0 1
60 #define VERT_RESULT_COL1 2
61 #define VERT_RESULT_BFC0 3
62 #define VERT_RESULT_BFC1 4
63 #define VERT_RESULT_FOGC 5
64 #define VERT_RESULT_PSIZ 6
65 #define VERT_RESULT_TEX0 7
66 #define VERT_RESULT_TEX1 8
67 #define VERT_RESULT_TEX2 9
68 #define VERT_RESULT_TEX3 10
69 #define VERT_RESULT_TEX4 11
70 #define VERT_RESULT_TEX5 12
71 #define VERT_RESULT_TEX6 13
72 #define VERT_RESULT_TEX7 14
76 * Private storage for the vertex program pipeline stage.
78 struct vp_stage_data
{
79 /** The results of running the vertex program go into these arrays. */
80 GLvector4f attribs
[15];
82 GLvector4f ndcCoords
; /**< normalized device coords */
83 GLubyte
*clipmask
; /**< clip flags */
84 GLubyte ormask
, andmask
; /**< for clipping */
88 #define VP_STAGE_DATA(stage) ((struct vp_stage_data *)(stage->privatePtr))
92 * This function executes vertex programs
94 static GLboolean
run_vp( GLcontext
*ctx
, struct tnl_pipeline_stage
*stage
)
96 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
97 struct vp_stage_data
*store
= VP_STAGE_DATA(stage
);
98 struct vertex_buffer
*VB
= &tnl
->vb
;
99 struct vertex_program
*program
= ctx
->VertexProgram
.Current
;
102 _mesa_init_tracked_matrices(ctx
); /* load registers with matrices */
103 _mesa_init_vp_registers(ctx
); /* init temp and result regs */
105 for (i
= 0; i
< VB
->Count
; i
++) {
109 printf("Input %d: %f, %f, %f, %f\n", i
,
110 VB
->AttribPtr
[0]->data
[i
][0],
111 VB
->AttribPtr
[0]->data
[i
][1],
112 VB
->AttribPtr
[0]->data
[i
][2],
113 VB
->AttribPtr
[0]->data
[i
][3]);
114 printf(" color: %f, %f, %f, %f\n",
115 VB
->AttribPtr
[3]->data
[i
][0],
116 VB
->AttribPtr
[3]->data
[i
][1],
117 VB
->AttribPtr
[3]->data
[i
][2],
118 VB
->AttribPtr
[3]->data
[i
][3]);
119 printf(" normal: %f, %f, %f, %f\n",
120 VB
->AttribPtr
[2]->data
[i
][0],
121 VB
->AttribPtr
[2]->data
[i
][1],
122 VB
->AttribPtr
[2]->data
[i
][2],
123 VB
->AttribPtr
[2]->data
[i
][3]);
126 /* the vertex array case */
127 for (attr
= 0; attr
< VERT_ATTRIB_MAX
; attr
++) {
128 if (program
->InputsRead
& (1 << attr
)) {
129 const GLubyte
*ptr
= (const GLubyte
*) VB
->AttribPtr
[attr
]->data
;
130 const GLuint size
= VB
->AttribPtr
[attr
]->size
;
131 const GLuint stride
= VB
->AttribPtr
[attr
]->stride
;
132 const GLfloat
*data
= (GLfloat
*) (ptr
+ stride
* i
);
133 ASSIGN_4V(ctx
->VertexProgram
.Inputs
[attr
], 0, 0, 0, 1);
134 COPY_SZ_4V(ctx
->VertexProgram
.Inputs
[attr
], size
, data
);
138 /* execute the program */
140 _mesa_exec_vertex_program(ctx
, program
);
142 /* Fixup fog an point size results if needed */
143 if (ctx
->Fog
.Enabled
&&
144 (program
->OutputsWritten
& (1 << VERT_RESULT_FOGC
)) == 0) {
145 ctx
->VertexProgram
.Outputs
[VERT_RESULT_FOGC
][0] = 1.0;
148 if (ctx
->VertexProgram
.PointSizeEnabled
&&
149 (program
->OutputsWritten
& (1 << VERT_RESULT_PSIZ
)) == 0) {
150 ctx
->VertexProgram
.Outputs
[VERT_RESULT_PSIZ
][0] = ctx
->Point
.Size
;
153 /* copy the output registers into the VB->attribs arrays */
154 /* XXX (optimize) could use a conditional and smaller loop limit here */
155 for (attr
= 0; attr
< 15; attr
++) {
156 COPY_4V(store
->attribs
[attr
].data
[i
],
157 ctx
->VertexProgram
.Outputs
[attr
]);
161 /* Setup the VB pointers so that the next pipeline stages get
162 * their data from the right place (the program output arrays).
164 VB
->ClipPtr
= &store
->attribs
[VERT_RESULT_HPOS
];
165 VB
->ClipPtr
->size
= 4;
166 VB
->ClipPtr
->count
= VB
->Count
;
167 VB
->ColorPtr
[0] = &store
->attribs
[VERT_RESULT_COL0
];
168 VB
->ColorPtr
[1] = &store
->attribs
[VERT_RESULT_BFC0
];
169 VB
->SecondaryColorPtr
[0] = &store
->attribs
[VERT_RESULT_COL1
];
170 VB
->SecondaryColorPtr
[1] = &store
->attribs
[VERT_RESULT_BFC1
];
171 VB
->FogCoordPtr
= &store
->attribs
[VERT_RESULT_FOGC
];
172 VB
->PointSizePtr
= &store
->attribs
[VERT_RESULT_PSIZ
];
174 VB
->AttribPtr
[VERT_ATTRIB_COLOR0
] = VB
->ColorPtr
[0];
175 VB
->AttribPtr
[VERT_ATTRIB_COLOR1
] = VB
->SecondaryColorPtr
[0];
176 VB
->AttribPtr
[VERT_ATTRIB_FOG
] = VB
->FogCoordPtr
;
177 VB
->AttribPtr
[_TNL_ATTRIB_POINTSIZE
] = &store
->attribs
[VERT_RESULT_PSIZ
];
179 for (i
= 0; i
< ctx
->Const
.MaxTextureUnits
; i
++) {
180 VB
->AttribPtr
[VERT_ATTRIB_TEX0
+i
] = VB
->TexCoordPtr
[i
] =
181 &store
->attribs
[VERT_RESULT_TEX0
+ i
];
186 /* Cliptest and perspective divide. Clip functions must clear
190 store
->andmask
= CLIP_ALL_BITS
;
192 if (tnl
->NeedNdcCoords
) {
194 _mesa_clip_tab
[VB
->ClipPtr
->size
]( VB
->ClipPtr
,
202 _mesa_clip_np_tab
[VB
->ClipPtr
->size
]( VB
->ClipPtr
,
209 if (store
->andmask
) /* All vertices are outside the frustum */
213 /* This is where we'd do clip testing against the user-defined
214 * clipping planes, but they're not supported by vertex programs.
217 VB
->ClipOrMask
= store
->ormask
;
218 VB
->ClipMask
= store
->clipmask
;
225 * This function validates stuff.
227 static GLboolean
run_validate_program( GLcontext
*ctx
,
228 struct tnl_pipeline_stage
*stage
)
231 /* XXX do we need any validation for vertex programs? */
235 if (ctx
->Visual
.rgbMode
) {
236 if (ctx
->Light
._NeedVertices
) {
237 if (ctx
->Light
.Model
.ColorControl
== GL_SEPARATE_SPECULAR_COLOR
)
238 tab
= _tnl_light_spec_tab
;
240 tab
= _tnl_light_tab
;
243 if (ctx
->Light
.EnabledList
.next
== ctx
->Light
.EnabledList
.prev
)
244 tab
= _tnl_light_fast_single_tab
;
246 tab
= _tnl_light_fast_tab
;
250 tab
= _tnl_light_ci_tab
;
252 if (ctx
->Light
.ColorMaterialEnabled
)
253 ind
|= LIGHT_COLORMATERIAL
;
255 if (ctx
->Light
.Model
.TwoSide
)
256 ind
|= LIGHT_TWOSIDE
;
258 VP_STAGE_DATA(stage
)->light_func_tab
= &tab
[ind
];
260 /* This and the above should only be done on _NEW_LIGHT:
262 _mesa_validate_all_lighting_tables( ctx
);
265 /* Now run the stage...
268 return stage
->run( ctx
, stage
);
274 * Called the first time stage->run is called. In effect, don't
275 * allocate data until the first time the stage is run.
277 static GLboolean
run_init_vp( GLcontext
*ctx
,
278 struct tnl_pipeline_stage
*stage
)
280 TNLcontext
*tnl
= TNL_CONTEXT(ctx
);
281 struct vertex_buffer
*VB
= &(tnl
->vb
);
282 struct vp_stage_data
*store
;
283 const GLuint size
= VB
->Size
;
286 stage
->privatePtr
= MALLOC(sizeof(*store
));
287 store
= VP_STAGE_DATA(stage
);
291 /* Allocate arrays of vertex output values */
292 for (i
= 0; i
< 15; i
++) {
293 _mesa_vector4f_alloc( &store
->attribs
[i
], 0, size
, 32 );
294 store
->attribs
[i
].size
= 4;
297 /* a few other misc allocations */
298 _mesa_vector4f_alloc( &store
->ndcCoords
, 0, size
, 32 );
299 store
->clipmask
= (GLubyte
*) ALIGN_MALLOC(sizeof(GLubyte
)*size
, 32 );
301 /* Now validate the stage derived data...
303 stage
->run
= run_validate_program
;
304 return stage
->run( ctx
, stage
);
310 * Check if vertex program mode is enabled.
311 * If so, configure the pipeline stage's type, inputs, and outputs.
313 static void check_vp( GLcontext
*ctx
, struct tnl_pipeline_stage
*stage
)
315 stage
->active
= ctx
->VertexProgram
.Enabled
;
318 /* Set stage->inputs equal to the bitmask of vertex attributes
319 * which the program needs for inputs.
321 stage
->inputs
= ctx
->VertexProgram
.Current
->InputsRead
;
327 * Destructor for this pipeline stage.
329 static void dtr( struct tnl_pipeline_stage
*stage
)
331 struct vp_stage_data
*store
= VP_STAGE_DATA(stage
);
336 /* free the vertex program result arrays */
337 for (i
= 0; i
< 15; i
++)
338 _mesa_vector4f_free( &store
->attribs
[i
] );
340 /* free misc arrays */
341 _mesa_vector4f_free( &store
->ndcCoords
);
342 ALIGN_FREE( store
->clipmask
);
345 stage
->privatePtr
= 0;
350 * Public description of this pipeline stage.
352 const struct tnl_pipeline_stage _tnl_vertex_program_stage
=
355 _NEW_ALL
, /*XXX FIX */ /* recheck */
356 _NEW_ALL
, /*XXX FIX */ /* recalc */
357 GL_FALSE
, /* active */
358 0, /* inputs - calculated on the fly */
359 _TNL_BITS_PROG_ANY
, /* outputs -- could calculate */
360 0, /* changed_inputs */
361 NULL
, /* private_data */
363 check_vp
, /* check */
364 run_init_vp
/* run -- initially set to ctr */