/*
* Mesa 3-D graphics library
- * Version: 7.6
*
* Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
* Copyright (C) 2009 VMware, Inc. All Rights Reserved.
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
*/
#include "main/glheader.h"
-#include "main/colormac.h"
#include "main/macros.h"
#include "main/imports.h"
#include "main/samplerobj.h"
+#include "main/state.h"
#include "math/m_xform.h"
#include "program/prog_instruction.h"
#include "program/prog_statevars.h"
#include "program/prog_execute.h"
#include "swrast/s_context.h"
+#include "util/bitscan.h"
#include "tnl/tnl.h"
#include "tnl/t_context.h"
*/
struct vp_stage_data {
/** The results of running the vertex program go into these arrays. */
- GLvector4f results[VERT_RESULT_MAX];
+ GLvector4f results[VARYING_SLOT_MAX];
GLvector4f ndcCoords; /**< normalized device coords */
GLubyte *clipmask; /**< clip flags */
GLubyte *clipormask,
GLubyte *clipandmask )
{
- GLuint p;
-
- for (p = 0; p < ctx->Const.MaxClipPlanes; p++) {
- if (ctx->Transform.ClipPlanesEnabled & (1 << p)) {
- GLuint nr, i;
- const GLfloat a = ctx->Transform._ClipUserPlane[p][0];
- const GLfloat b = ctx->Transform._ClipUserPlane[p][1];
- const GLfloat c = ctx->Transform._ClipUserPlane[p][2];
- const GLfloat d = ctx->Transform._ClipUserPlane[p][3];
- GLfloat *coord = (GLfloat *)clip->data;
- GLuint stride = clip->stride;
- GLuint count = clip->count;
-
- for (nr = 0, i = 0 ; i < count ; i++) {
- GLfloat dp = (coord[0] * a +
- coord[1] * b +
- coord[2] * c +
- coord[3] * d);
-
- if (dp < 0) {
- nr++;
- clipmask[i] |= CLIP_USER_BIT;
- }
-
- STRIDE_F(coord, stride);
- }
+ GLbitfield mask = ctx->Transform.ClipPlanesEnabled;
+ while (mask) {
+ const int p = u_bit_scan(&mask);
+ GLuint nr, i;
+ const GLfloat a = ctx->Transform._ClipUserPlane[p][0];
+ const GLfloat b = ctx->Transform._ClipUserPlane[p][1];
+ const GLfloat c = ctx->Transform._ClipUserPlane[p][2];
+ const GLfloat d = ctx->Transform._ClipUserPlane[p][3];
+ GLfloat *coord = (GLfloat *)clip->data;
+ GLuint stride = clip->stride;
+ GLuint count = clip->count;
+
+ for (nr = 0, i = 0 ; i < count ; i++) {
+ GLfloat dp = (coord[0] * a +
+ coord[1] * b +
+ coord[2] * c +
+ coord[3] * d);
+
+ if (dp < 0) {
+ nr++;
+ clipmask[i] |= CLIP_USER_BIT;
+ }
+
+ STRIDE_F(coord, stride);
+ }
- if (nr > 0) {
- *clipormask |= CLIP_USER_BIT;
- if (nr == count) {
- *clipandmask |= CLIP_USER_BIT;
- return;
- }
- }
+ if (nr > 0) {
+ *clipormask |= CLIP_USER_BIT;
+ if (nr == count) {
+ *clipandmask |= CLIP_USER_BIT;
+ return;
+ }
}
}
}
store->clipmask,
&store->ormask,
&store->andmask,
- !ctx->Transform.DepthClamp );
+ !(ctx->Transform.DepthClampNear &&
+ ctx->Transform.DepthClampFar) );
}
else {
VB->NdcPtr = NULL;
store->clipmask,
&store->ormask,
&store->andmask,
- !ctx->Transform.DepthClamp );
+ !(ctx->Transform.DepthClampNear &&
+ ctx->Transform.DepthClampFar) );
}
if (store->andmask) {
/* Test userclip planes. This contributes to VB->ClipMask.
*/
/** XXX NEW_SLANG _Enabled ??? */
- if (ctx->Transform.ClipPlanesEnabled && (!ctx->VertexProgram._Enabled ||
- ctx->VertexProgram.Current->IsPositionInvariant)) {
+ if (ctx->Transform.ClipPlanesEnabled &&
+ (!_mesa_arb_vertex_program_enabled(ctx) ||
+ ctx->VertexProgram.Current->arb.IsPositionInvariant)) {
userclip( ctx,
VB->ClipPtr,
store->clipmask,
machine->NumDeriv = 0;
- /* init condition codes */
- machine->CondCodes[0] = COND_EQ;
- machine->CondCodes[1] = COND_EQ;
- machine->CondCodes[2] = COND_EQ;
- machine->CondCodes[3] = COND_EQ;
-
/* init call stack */
machine->StackDepth = 0;
machine->FetchTexelLod = vp_fetch_texel;
machine->FetchTexelDeriv = NULL; /* not used by vertex programs */
- machine->Samplers = ctx->VertexProgram._Current->Base.SamplerUnits;
+ machine->Samplers = ctx->VertexProgram._Current->SamplerUnits;
machine->SystemValues[SYSTEM_VALUE_INSTANCE_ID][0] = (GLfloat) instID;
}
* Map the texture images which the vertex program will access (if any).
*/
static void
-map_textures(struct gl_context *ctx, const struct gl_vertex_program *vp)
+map_textures(struct gl_context *ctx, const struct gl_program *vp)
{
GLuint u;
- for (u = 0; u < ctx->Const.MaxVertexTextureImageUnits; u++) {
- if (vp->Base.TexturesUsed[u]) {
+ for (u = 0; u < ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits; u++) {
+ if (vp->TexturesUsed[u]) {
/* Note: _Current *should* correspond to the target indicated
* in TexturesUsed[u].
*/
* Unmap the texture images which were used by the vertex program (if any).
*/
static void
-unmap_textures(struct gl_context *ctx, const struct gl_vertex_program *vp)
+unmap_textures(struct gl_context *ctx, const struct gl_program *vp)
{
GLuint u;
- for (u = 0; u < ctx->Const.MaxVertexTextureImageUnits; u++) {
- if (vp->Base.TexturesUsed[u]) {
+ for (u = 0; u < ctx->Const.Program[MESA_SHADER_VERTEX].MaxTextureImageUnits; u++) {
+ if (vp->TexturesUsed[u]) {
/* Note: _Current *should* correspond to the target indicated
* in TexturesUsed[u].
*/
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vp_stage_data *store = VP_STAGE_DATA(stage);
struct vertex_buffer *VB = &tnl->vb;
- struct gl_vertex_program *program = ctx->VertexProgram._Current;
+ struct gl_program *program = ctx->VertexProgram._Current;
struct gl_program_machine *machine = &store->machine;
- GLuint outputs[VERT_RESULT_MAX], numOutputs;
+ GLuint outputs[VARYING_SLOT_MAX], numOutputs;
GLuint i, j;
if (!program)
return GL_TRUE;
/* ARB program or vertex shader */
- _mesa_load_state_parameters(ctx, program->Base.Parameters);
+ _mesa_load_state_parameters(ctx, program->Parameters);
/* make list of outputs to save some time below */
numOutputs = 0;
- for (i = 0; i < VERT_RESULT_MAX; i++) {
- if (program->Base.OutputsWritten & BITFIELD64_BIT(i)) {
+ for (i = 0; i < VARYING_SLOT_MAX; i++) {
+ if (program->info.outputs_written & BITFIELD64_BIT(i)) {
outputs[numOutputs++] = i;
}
}
* memory that would never be used if we don't run the software tnl pipeline.
*/
if (!store->results[0].storage) {
- for (i = 0; i < VERT_RESULT_MAX; i++) {
+ for (i = 0; i < VARYING_SLOT_MAX; i++) {
assert(!store->results[i].storage);
_mesa_vector4f_alloc( &store->results[i], 0, VB->Size, 32 );
store->results[i].size = 4;
/* the vertex array case */
for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
- if (program->Base.InputsRead & BITFIELD64_BIT(attr)) {
+ if (program->info.inputs_read & BITFIELD64_BIT(attr)) {
const GLubyte *ptr = (const GLubyte*) VB->AttribPtr[attr]->data;
const GLuint size = VB->AttribPtr[attr]->size;
const GLuint stride = VB->AttribPtr[attr]->stride;
}
/* execute the program */
- _mesa_execute_program(ctx, &program->Base, machine);
+ _mesa_execute_program(ctx, program, machine);
/* copy the output registers into the VB->attribs arrays */
for (j = 0; j < numOutputs; j++) {
}
/* FOGC is a special case. Fragment shader expects (f,0,0,1) */
- if (program->Base.OutputsWritten & BITFIELD64_BIT(VERT_RESULT_FOGC)) {
- store->results[VERT_RESULT_FOGC].data[i][1] = 0.0;
- store->results[VERT_RESULT_FOGC].data[i][2] = 0.0;
- store->results[VERT_RESULT_FOGC].data[i][3] = 1.0;
+ if (program->info.outputs_written & BITFIELD64_BIT(VARYING_SLOT_FOGC)) {
+ store->results[VARYING_SLOT_FOGC].data[i][1] = 0.0;
+ store->results[VARYING_SLOT_FOGC].data[i][2] = 0.0;
+ store->results[VARYING_SLOT_FOGC].data[i][3] = 1.0;
}
#ifdef NAN_CHECK
- ASSERT(machine->Outputs[0][3] != 0.0F);
+ assert(machine->Outputs[0][3] != 0.0F);
#endif
#if 0
printf("HPOS: %f %f %f %f\n",
unmap_textures(ctx, program);
- if (program->IsPositionInvariant) {
+ if (program->arb.IsPositionInvariant) {
/* We need the exact same transform as in the fixed function path here
* to guarantee invariance, depending on compiler optimization flags
* results could be different otherwise.
/* Setup the VB pointers so that the next pipeline stages get
* their data from the right place (the program output arrays).
*/
- VB->ClipPtr = &store->results[VERT_RESULT_HPOS];
+ VB->ClipPtr = &store->results[VARYING_SLOT_POS];
VB->ClipPtr->size = 4;
VB->ClipPtr->count = VB->Count;
}
- VB->AttribPtr[VERT_ATTRIB_COLOR0] = &store->results[VERT_RESULT_COL0];
- VB->AttribPtr[VERT_ATTRIB_COLOR1] = &store->results[VERT_RESULT_COL1];
- VB->AttribPtr[VERT_ATTRIB_FOG] = &store->results[VERT_RESULT_FOGC];
- VB->AttribPtr[_TNL_ATTRIB_POINTSIZE] = &store->results[VERT_RESULT_PSIZ];
- VB->BackfaceColorPtr = &store->results[VERT_RESULT_BFC0];
- VB->BackfaceSecondaryColorPtr = &store->results[VERT_RESULT_BFC1];
+ VB->AttribPtr[VERT_ATTRIB_COLOR0] = &store->results[VARYING_SLOT_COL0];
+ VB->AttribPtr[VERT_ATTRIB_COLOR1] = &store->results[VARYING_SLOT_COL1];
+ VB->AttribPtr[VERT_ATTRIB_FOG] = &store->results[VARYING_SLOT_FOGC];
+ VB->AttribPtr[_TNL_ATTRIB_POINTSIZE] = &store->results[VARYING_SLOT_PSIZ];
+ VB->BackfaceColorPtr = &store->results[VARYING_SLOT_BFC0];
+ VB->BackfaceSecondaryColorPtr = &store->results[VARYING_SLOT_BFC1];
for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
VB->AttribPtr[_TNL_ATTRIB_TEX0 + i]
- = &store->results[VERT_RESULT_TEX0 + i];
+ = &store->results[VARYING_SLOT_TEX0 + i];
}
for (i = 0; i < ctx->Const.MaxVarying; i++) {
- if (program->Base.OutputsWritten & BITFIELD64_BIT(VERT_RESULT_VAR0 + i)) {
+ if (program->info.outputs_written &
+ BITFIELD64_BIT(VARYING_SLOT_VAR0 + i)) {
/* Note: varying results get put into the generic attributes */
VB->AttribPtr[VERT_ATTRIB_GENERIC0+i]
- = &store->results[VERT_RESULT_VAR0 + i];
+ = &store->results[VARYING_SLOT_VAR0 + i];
}
}
GLuint i;
/* free the vertex program result arrays */
- for (i = 0; i < VERT_RESULT_MAX; i++)
+ for (i = 0; i < VARYING_SLOT_MAX; i++)
_mesa_vector4f_free( &store->results[i] );
/* free misc arrays */