* 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
+ * THE AUTHORS 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/colormac.h"
#include "main/macros.h"
#include "main/imports.h"
+#include "main/samplerobj.h"
#include "math/m_xform.h"
#include "program/prog_instruction.h"
#include "program/prog_statevars.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 ormask, andmask; /**< for clipping */
+ GLboolean vertex_textures;
+
struct gl_program_machine machine;
};
SWcontext *swrast = SWRAST_CONTEXT(ctx);
/* XXX use a float-valued TextureSample routine here!!! */
- swrast->TextureSample[unit](ctx, ctx->Texture.Unit[unit]._Current,
+ swrast->TextureSample[unit](ctx, _mesa_get_samplerobj(ctx, unit),
+ ctx->Texture.Unit[unit]._Current,
1, (const GLfloat (*)[4]) texcoord,
&lambda, (GLfloat (*)[4]) color);
}
memcpy(machine->VertAttribs, ctx->Current.Attrib,
MAX_VERTEX_GENERIC_ATTRIBS * 4 * sizeof(GLfloat));
- if (ctx->VertexProgram._Current->IsNVProgram) {
- GLuint i;
- /* Output/result regs are initialized to [0,0,0,1] */
- for (i = 0; i < MAX_NV_VERTEX_PROGRAM_OUTPUTS; i++) {
- ASSIGN_4V(machine->Outputs[i], 0.0F, 0.0F, 0.0F, 1.0F);
- }
- /* Temp regs are initialized to [0,0,0,0] */
- for (i = 0; i < MAX_NV_VERTEX_PROGRAM_TEMPS; i++) {
- ASSIGN_4V(machine->Temporaries[i], 0.0F, 0.0F, 0.0F, 0.0F);
- }
- for (i = 0; i < MAX_VERTEX_PROGRAM_ADDRESS_REGS; i++) {
- ASSIGN_4V(machine->AddressReg[i], 0, 0, 0, 0);
- }
- }
-
machine->NumDeriv = 0;
/* init condition codes */
{
GLuint u;
- if (!ctx->Driver.MapTexture)
- return;
-
for (u = 0; u < ctx->Const.MaxVertexTextureImageUnits; u++) {
if (vp->Base.TexturesUsed[u]) {
/* Note: _Current *should* correspond to the target indicated
* in TexturesUsed[u].
*/
- ctx->Driver.MapTexture(ctx, ctx->Texture.Unit[u]._Current);
+ _swrast_map_texture(ctx, ctx->Texture.Unit[u]._Current);
}
}
}
{
GLuint u;
- if (!ctx->Driver.MapTexture)
- return;
-
for (u = 0; u < ctx->Const.MaxVertexTextureImageUnits; u++) {
if (vp->Base.TexturesUsed[u]) {
/* Note: _Current *should* correspond to the target indicated
* in TexturesUsed[u].
*/
- ctx->Driver.UnmapTexture(ctx, ctx->Texture.Unit[u]._Current);
+ _swrast_unmap_texture(ctx, ctx->Texture.Unit[u]._Current);
}
}
}
struct vertex_buffer *VB = &tnl->vb;
struct gl_vertex_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;
- if (program->IsNVProgram) {
- _mesa_load_tracked_matrices(ctx);
- }
- else {
- /* ARB program or vertex shader */
- _mesa_load_state_parameters(ctx, program->Base.Parameters);
- }
+ /* ARB program or vertex shader */
+ _mesa_load_state_parameters(ctx, program->Base.Parameters);
/* make list of outputs to save some time below */
numOutputs = 0;
- for (i = 0; i < VERT_RESULT_MAX; i++) {
+ for (i = 0; i < VARYING_SLOT_MAX; i++) {
if (program->Base.OutputsWritten & BITFIELD64_BIT(i)) {
outputs[numOutputs++] = i;
+ }
+ }
- if (!store->results[i].data) {
- _mesa_vector4f_alloc( &store->results[i], 0, VB->Size, 32 );
- store->results[i].size = 4;
- }
+ /* Allocate result vectors. We delay this until now to avoid allocating
+ * memory that would never be used if we don't run the software tnl pipeline.
+ */
+ if (!store->results[0].storage) {
+ 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 & (1 << attr)) {
+ if (program->Base.InputsRead & 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;
}
/* 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->Base.OutputsWritten & 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);
unmap_textures(ctx, program);
- /* Fixup fog and point size results if needed */
- if (program->IsNVProgram) {
- if (ctx->Fog.Enabled &&
- (program->Base.OutputsWritten & BITFIELD64_BIT(VERT_RESULT_FOGC)) == 0) {
- for (i = 0; i < VB->Count; i++) {
- store->results[VERT_RESULT_FOGC].data[i][0] = 1.0;
- }
- }
-
- if (ctx->VertexProgram.PointSizeEnabled &&
- (program->Base.OutputsWritten & BITFIELD64_BIT(VERT_RESULT_PSIZ)) == 0) {
- for (i = 0; i < VB->Count; i++) {
- store->results[VERT_RESULT_PSIZ].data[i][0] = ctx->Point.Size;
- }
- }
- }
-
if (program->IsPositionInvariant) {
/* We need the exact same transform as in the fixed function path here
* to guarantee invariance, depending on compiler optimization flags
/* 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->Base.OutputsWritten & 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];
}
}
struct vp_stage_data *store;
const GLuint size = VB->Size;
- stage->privatePtr = CALLOC(sizeof(*store));
+ stage->privatePtr = calloc(1, sizeof(*store));
store = VP_STAGE_DATA(stage);
if (!store)
return GL_FALSE;
/* a few other misc allocations */
_mesa_vector4f_alloc( &store->ndcCoords, 0, size, 32 );
- store->clipmask = (GLubyte *) _mesa_align_malloc(sizeof(GLubyte)*size, 32 );
+ store->clipmask = _mesa_align_malloc(sizeof(GLubyte)*size, 32 );
return GL_TRUE;
}
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 */
_mesa_vector4f_free( &store->ndcCoords );
_mesa_align_free( store->clipmask );
- FREE( store );
+ free( store );
stage->privatePtr = NULL;
}
}
projects / mesa.git / blobdiff