#include "main/glheader.h"
#include "main/colormac.h"
-#include "main/context.h"
#include "main/macros.h"
#include "main/imports.h"
-#include "shader/prog_instruction.h"
-#include "shader/prog_statevars.h"
-#include "shader/prog_execute.h"
+#include "main/samplerobj.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 "swrast/s_texfilter.h"
#include "tnl/tnl.h"
#include "tnl/t_context.h"
#ifdef NAN_CHECK
/** Check for NaNs and very large values */
-static INLINE void
+static inline void
check_float(float x)
{
assert(!IS_INF_OR_NAN(x));
GLvector4f ndcCoords; /**< normalized device coords */
GLubyte *clipmask; /**< clip flags */
GLubyte ormask, andmask; /**< for clipping */
+
+ GLboolean vertex_textures;
+
+ struct gl_program_machine machine;
};
static void
-userclip( GLcontext *ctx,
+userclip( struct gl_context *ctx,
GLvector4f *clip,
GLubyte *clipmask,
GLubyte *clipormask,
static GLboolean
-do_ndc_cliptest(GLcontext *ctx, struct vp_stage_data *store)
+do_ndc_cliptest(struct gl_context *ctx, struct vp_stage_data *store)
{
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *VB = &tnl->vb;
* moved into main/ someday.
*/
static void
-vp_fetch_texel(GLcontext *ctx, const GLfloat texcoord[4], GLfloat lambda,
+vp_fetch_texel(struct gl_context *ctx, const GLfloat texcoord[4], GLfloat lambda,
GLuint unit, GLfloat color[4])
{
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);
}
* Called via ctx->Driver.ProgramStringNotify() after a new vertex program
* string has been parsed.
*/
-void
-_tnl_program_string(GLcontext *ctx, GLenum target, struct gl_program *program)
+GLboolean
+_tnl_program_string(struct gl_context *ctx, GLenum target, struct gl_program *program)
{
/* No-op.
* If we had derived anything from the program that was private to this
* stage we'd recompute/validate it here.
*/
+ return GL_TRUE;
}
* Initialize virtual machine state prior to executing vertex program.
*/
static void
-init_machine(GLcontext *ctx, struct gl_program_machine *machine)
+init_machine(struct gl_context *ctx, struct gl_program_machine *machine,
+ GLuint instID)
{
/* Input registers get initialized from the current vertex attribs */
- MEMCPY(machine->VertAttribs, ctx->Current.Attrib,
+ 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 */
machine->FetchTexelDeriv = NULL; /* not used by vertex programs */
machine->Samplers = ctx->VertexProgram._Current->Base.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(GLcontext *ctx, const struct gl_vertex_program *vp)
+map_textures(struct gl_context *ctx, const struct gl_vertex_program *vp)
{
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);
}
}
}
* Unmap the texture images which were used by the vertex program (if any).
*/
static void
-unmap_textures(GLcontext *ctx, const struct gl_vertex_program *vp)
+unmap_textures(struct gl_context *ctx, const struct gl_vertex_program *vp)
{
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);
}
}
}
* This function executes vertex programs
*/
static GLboolean
-run_vp( GLcontext *ctx, struct tnl_pipeline_stage *stage )
+run_vp( struct gl_context *ctx, struct tnl_pipeline_stage *stage )
{
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_machine machine;
+ struct gl_program_machine *machine = &store->machine;
GLuint outputs[VERT_RESULT_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;
}
}
+ /* 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 < VERT_RESULT_MAX; i++) {
+ assert(!store->results[i].storage);
+ _mesa_vector4f_alloc( &store->results[i], 0, VB->Size, 32 );
+ store->results[i].size = 4;
+ }
+ }
+
map_textures(ctx, program);
for (i = 0; i < VB->Count; i++) {
GLuint attr;
- init_machine(ctx, &machine);
+ init_machine(ctx, machine, tnl->CurInstance);
#if 0
printf("Input %d: %f, %f, %f, %f\n", i,
/* 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;
check_float(data[2]);
check_float(data[3]);
#endif
- COPY_CLEAN_4V(machine.VertAttribs[attr], size, data);
+ COPY_CLEAN_4V(machine->VertAttribs[attr], size, data);
}
}
/* execute the program */
- _mesa_execute_program(ctx, &program->Base, &machine);
+ _mesa_execute_program(ctx, &program->Base, machine);
/* copy the output registers into the VB->attribs arrays */
for (j = 0; j < numOutputs; j++) {
const GLuint attr = outputs[j];
#ifdef NAN_CHECK
- check_float(machine.Outputs[attr][0]);
- check_float(machine.Outputs[attr][1]);
- check_float(machine.Outputs[attr][2]);
- check_float(machine.Outputs[attr][3]);
+ check_float(machine->Outputs[attr][0]);
+ check_float(machine->Outputs[attr][1]);
+ check_float(machine->Outputs[attr][2]);
+ check_float(machine->Outputs[attr][3]);
#endif
- COPY_4V(store->results[attr].data[i], machine.Outputs[attr]);
+ COPY_4V(store->results[attr].data[i], machine->Outputs[attr]);
}
/* FOGC is a special case. Fragment shader expects (f,0,0,1) */
store->results[VERT_RESULT_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",
- machine.Outputs[0][0],
- machine.Outputs[0][1],
- machine.Outputs[0][2],
- machine.Outputs[0][3]);
+ machine->Outputs[0][0],
+ machine->Outputs[0][1],
+ machine->Outputs[0][2],
+ machine->Outputs[0][3]);
#endif
}
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
* allocate data until the first time the stage is run.
*/
static GLboolean
-init_vp(GLcontext *ctx, struct tnl_pipeline_stage *stage)
+init_vp(struct gl_context *ctx, struct tnl_pipeline_stage *stage)
{
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *VB = &(tnl->vb);
struct vp_stage_data *store;
const GLuint size = VB->Size;
- GLuint i;
- stage->privatePtr = MALLOC(sizeof(*store));
+ stage->privatePtr = calloc(1, sizeof(*store));
store = VP_STAGE_DATA(stage);
if (!store)
return GL_FALSE;
- /* Allocate arrays of vertex output values */
- for (i = 0; i < VERT_RESULT_MAX; i++) {
- _mesa_vector4f_alloc( &store->results[i], 0, size, 32 );
- store->results[i].size = 4;
- }
-
/* a few other misc allocations */
_mesa_vector4f_alloc( &store->ndcCoords, 0, size, 32 );
- store->clipmask = (GLubyte *) ALIGN_MALLOC(sizeof(GLubyte)*size, 32 );
+ store->clipmask = _mesa_align_malloc(sizeof(GLubyte)*size, 32 );
return GL_TRUE;
}
/* free misc arrays */
_mesa_vector4f_free( &store->ndcCoords );
- ALIGN_FREE( store->clipmask );
+ _mesa_align_free( store->clipmask );
- FREE( store );
+ free( store );
stage->privatePtr = NULL;
}
}
static void
-validate_vp_stage(GLcontext *ctx, struct tnl_pipeline_stage *stage)
+validate_vp_stage(struct gl_context *ctx, struct tnl_pipeline_stage *stage)
{
if (ctx->VertexProgram._Current) {
_swrast_update_texture_samplers(ctx);
projects / mesa.git / blobdiff