#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 "swrast/s_context.h"
#include "swrast/s_texfilter.h"
#include "tnl/tnl.h"
#include "tnl/t_context.h"
#include "tnl/t_pipeline.h"
#include "swrast/s_context.h"
#include "swrast/s_texfilter.h"
struct vp_stage_data {
GLvector4f results[VERT_RESULT_MAX];
GLvector4f ndcCoords;
GLubyte *clipmask;
GLubyte ormask, andmask;
};
#define VP_STAGE_DATA(stage) ((struct vp_stage_data *)(stage->privatePtr))
static void
userclip( GLcontext *ctx,
GLvector4f *clip,
GLubyte *clipmask,
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);
}
if (nr > 0) {
*clipormask |= CLIP_USER_BIT;
if (nr == count) {
*clipandmask |= CLIP_USER_BIT;
return;
}
}
}
}
}
static GLboolean
do_ndc_cliptest(GLcontext *ctx, struct vp_stage_data *store)
{
TNLcontext *tnl = TNL_CONTEXT(ctx);
struct vertex_buffer *VB = &tnl->vb;
store->ormask = 0;
store->andmask = CLIP_FRUSTUM_BITS;
if (tnl->NeedNdcCoords) {
VB->NdcPtr =
_mesa_clip_tab[VB->ClipPtr->size]( VB->ClipPtr,
&store->ndcCoords,
store->clipmask,
&store->ormask,
&store->andmask );
}
else {
VB->NdcPtr = NULL;
_mesa_clip_np_tab[VB->ClipPtr->size]( VB->ClipPtr,
NULL,
store->clipmask,
&store->ormask,
&store->andmask );
}
if (store->andmask) {
return GL_FALSE;
}
if (ctx->Transform.ClipPlanesEnabled && (!ctx->VertexProgram._Enabled ||
ctx->VertexProgram.Current->IsPositionInvariant)) {
userclip( ctx,
VB->ClipPtr,
store->clipmask,
&store->ormask,
&store->andmask );
if (store->andmask) {
return GL_FALSE;
}
}
VB->ClipAndMask = store->andmask;
VB->ClipOrMask = store->ormask;
VB->ClipMask = store->clipmask;
return GL_TRUE;
}
static void
vp_fetch_texel(GLcontext *ctx, const GLfloat texcoord[4], GLfloat lambda,
GLuint unit, GLfloat color[4])
{
GLchan rgba[4];
SWcontext *swrast = SWRAST_CONTEXT(ctx);
swrast->TextureSample[unit](ctx, ctx->Texture.Unit[unit]._Current,
1, (const GLfloat (*)[4]) texcoord,
&lambda, &rgba);
color[0] = CHAN_TO_FLOAT(rgba[0]);
color[1] = CHAN_TO_FLOAT(rgba[1]);
color[2] = CHAN_TO_FLOAT(rgba[2]);
color[3] = CHAN_TO_FLOAT(rgba[3]);
}
void
_tnl_program_string(GLcontext *ctx, GLenum target, struct gl_program *program)
{
}
static void
init_machine(GLcontext *ctx, struct gl_program_machine *machine)
{
MEMCPY(machine->VertAttribs, ctx->Current.Attrib,
MAX_VERTEX_PROGRAM_ATTRIBS * 4 * sizeof(GLfloat));
if (ctx->VertexProgram._Current->IsNVProgram) {
GLuint i;
for (i = 0; i < MAX_NV_VERTEX_PROGRAM_OUTPUTS; i++) {
ASSIGN_4V(machine->Outputs[i], 0.0F, 0.0F, 0.0F, 1.0F);
}
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;
machine->CondCodes[0] = COND_EQ;
machine->CondCodes[1] = COND_EQ;
machine->CondCodes[2] = COND_EQ;
machine->CondCodes[3] = COND_EQ;
machine->StackDepth = 0;
machine->FetchTexelLod = vp_fetch_texel;
machine->FetchTexelDeriv = NULL;
}
static void
map_textures(GLcontext *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]) {
ctx->Driver.MapTexture(ctx, ctx->Texture.Unit[u]._Current);
}
}
}
static void
unmap_textures(GLcontext *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]) {
ctx->Driver.UnmapTexture(ctx, ctx->Texture.Unit[u]._Current);
}
}
}
static GLboolean
run_vp( GLcontext *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;
GLuint outputs[VERT_RESULT_MAX], numOutputs;
GLuint i, j;
if (!program)
return GL_TRUE;
if (program->IsNVProgram) {
_mesa_load_tracked_matrices(ctx);
}
else {
_mesa_load_state_parameters(ctx, program->Base.Parameters);
}
numOutputs = 0;
for (i = 0; i < VERT_RESULT_MAX; i++) {
if (program->Base.OutputsWritten & (1 << i)) {
outputs[numOutputs++] = i;
}
}
map_textures(ctx, program);
for (i = 0; i < VB->Count; i++) {
GLuint attr;
init_machine(ctx, &machine);
#if 0
printf("Input %d: %f, %f, %f, %f\n", i,
VB->AttribPtr[0]->data[i][0],
VB->AttribPtr[0]->data[i][1],
VB->AttribPtr[0]->data[i][2],
VB->AttribPtr[0]->data[i][3]);
printf(" color: %f, %f, %f, %f\n",
VB->AttribPtr[3]->data[i][0],
VB->AttribPtr[3]->data[i][1],
VB->AttribPtr[3]->data[i][2],
VB->AttribPtr[3]->data[i][3]);
printf(" normal: %f, %f, %f, %f\n",
VB->AttribPtr[2]->data[i][0],
VB->AttribPtr[2]->data[i][1],
VB->AttribPtr[2]->data[i][2],
VB->AttribPtr[2]->data[i][3]);
#endif
for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) {
if (program->Base.InputsRead & (1 << attr)) {
const GLubyte *ptr = (const GLubyte*) VB->AttribPtr[attr]->data;
const GLuint size = VB->AttribPtr[attr]->size;
const GLuint stride = VB->AttribPtr[attr]->stride;
const GLfloat *data = (GLfloat *) (ptr + stride * i);
COPY_CLEAN_4V(machine.VertAttribs[attr], size, data);
}
}
_mesa_execute_program(ctx, &program->Base, &machine);
for (j = 0; j < numOutputs; j++) {
const GLuint attr = outputs[j];
COPY_4V(store->results[attr].data[i], machine.Outputs[attr]);
}
#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]);
#endif
}
unmap_textures(ctx, program);
if (program->IsNVProgram) {
if (ctx->Fog.Enabled &&
(program->Base.OutputsWritten & (1 << 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 & (1 << 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) {
VB->ClipPtr = TransformRaw( &store->results[0],
&ctx->_ModelProjectMatrix,
VB->AttribPtr[0] );
switch (VB->ClipPtr->size) {
case 1:
case 2:
_mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 2 );
case 3:
_mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 3 );
case 4:
break;
}
}
else {
VB->ClipPtr = &store->results[VERT_RESULT_HPOS];
VB->ClipPtr->size = 4;
VB->ClipPtr->count = VB->Count;
}
VB->ColorPtr[0] = &store->results[VERT_RESULT_COL0];
VB->ColorPtr[1] = &store->results[VERT_RESULT_BFC0];
VB->SecondaryColorPtr[0] = &store->results[VERT_RESULT_COL1];
VB->SecondaryColorPtr[1] = &store->results[VERT_RESULT_BFC1];
VB->FogCoordPtr = &store->results[VERT_RESULT_FOGC];
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];
for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) {
VB->TexCoordPtr[i] =
VB->AttribPtr[_TNL_ATTRIB_TEX0 + i]
= &store->results[VERT_RESULT_TEX0 + i];
}
for (i = 0; i < ctx->Const.MaxVarying; i++) {
if (program->Base.OutputsWritten & (1 << (VERT_RESULT_VAR0 + i))) {
VB->AttribPtr[VERT_ATTRIB_GENERIC0+i]
= &store->results[VERT_RESULT_VAR0 + i];
}
}
return do_ndc_cliptest(ctx, store);
}
static GLboolean
init_vp(GLcontext *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));
store = VP_STAGE_DATA(stage);
if (!store)
return GL_FALSE;
for (i = 0; i < VERT_RESULT_MAX; i++) {
_mesa_vector4f_alloc( &store->results[i], 0, size, 32 );
store->results[i].size = 4;
}
_mesa_vector4f_alloc( &store->ndcCoords, 0, size, 32 );
store->clipmask = (GLubyte *) ALIGN_MALLOC(sizeof(GLubyte)*size, 32 );
return GL_TRUE;
}
static void
dtr(struct tnl_pipeline_stage *stage)
{
struct vp_stage_data *store = VP_STAGE_DATA(stage);
if (store) {
GLuint i;
for (i = 0; i < VERT_RESULT_MAX; i++)
_mesa_vector4f_free( &store->results[i] );
_mesa_vector4f_free( &store->ndcCoords );
ALIGN_FREE( store->clipmask );
FREE( store );
stage->privatePtr = NULL;
}
}
static void
validate_vp_stage(GLcontext *ctx, struct tnl_pipeline_stage *stage)
{
if (ctx->VertexProgram._Current) {
_swrast_update_texture_samplers(ctx);
}
}
const struct tnl_pipeline_stage _tnl_vertex_program_stage =
{
"vertex-program",
NULL,
init_vp,
dtr,
validate_vp_stage,
run_vp
};