X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fpipe%2Fdraw%2Fdraw_vertex_shader.c;h=5ca659dbf590341bddc599eff289ad532d3b1732;hb=1e0d30a515e4cac891b6c590f12a33e0e8a8e295;hp=e3bcd35334100bd62438c383c65026c481950725;hpb=0d13ade0cdd38759936a74824efbd6ac8b563aed;p=mesa.git diff --git a/src/mesa/pipe/draw/draw_vertex_shader.c b/src/mesa/pipe/draw/draw_vertex_shader.c index e3bcd353341..5ca659dbf59 100644 --- a/src/mesa/pipe/draw/draw_vertex_shader.c +++ b/src/mesa/pipe/draw/draw_vertex_shader.c @@ -32,40 +32,46 @@ */ #include "pipe/p_util.h" +#include "pipe/p_shader_tokens.h" +#if defined(__i386__) || defined(__386__) +#include "pipe/tgsi/exec/tgsi_sse2.h" +#endif #include "draw_private.h" #include "draw_context.h" -#include "draw_vertex.h" #include "x86/rtasm/x86sse.h" +#include "pipe/llvm/gallivm.h" + + +#define DBG_VS 0 -#include "pipe/tgsi/exec/tgsi_core.h" static INLINE unsigned -compute_clipmask(float cx, float cy, float cz, float cw) +compute_clipmask(const float *clip, /*const*/ float plane[][4], unsigned nr) { unsigned mask = 0; - - if (-cx + cw < 0) mask |= CLIP_RIGHT_BIT; - if ( cx + cw < 0) mask |= CLIP_LEFT_BIT; - if (-cy + cw < 0) mask |= CLIP_TOP_BIT; - if ( cy + cw < 0) mask |= CLIP_BOTTOM_BIT; - if (-cz + cw < 0) mask |= CLIP_FAR_BIT; - if ( cz + cw < 0) mask |= CLIP_NEAR_BIT; + unsigned i; + + /* Do the hardwired planes first: + */ + if (-clip[0] + clip[3] < 0) mask |= CLIP_RIGHT_BIT; + if ( clip[0] + clip[3] < 0) mask |= CLIP_LEFT_BIT; + if (-clip[1] + clip[3] < 0) mask |= CLIP_TOP_BIT; + if ( clip[1] + clip[3] < 0) mask |= CLIP_BOTTOM_BIT; + if (-clip[2] + clip[3] < 0) mask |= CLIP_FAR_BIT; + if ( clip[2] + clip[3] < 0) mask |= CLIP_NEAR_BIT; + + /* Followed by any remaining ones: + */ + for (i = 6; i < nr; i++) { + if (dot4(clip, plane[i]) < 0) + mask |= (1<vertex_shader->state->output_semantic_name[0] == TGSI_SEMANTIC_POSITION); -#ifdef DEBUG_foo - memset( machine, 0, sizeof( *machine ) ); -#endif - -#if 0 - /* init machine state */ - tgsi_exec_machine_init(machine, - draw->vertex_shader->state->tokens, - PIPE_MAX_SAMPLERS, - NULL /*samplers*/ ); -#endif - /* Consts does not require 16 byte alignment. */ - machine->Consts = (float (*)[4]) draw->mapped_constants; + machine->Consts = (float (*)[4]) draw->user.constants; machine->Inputs = ALIGN16_ASSIGN(inputs); machine->Outputs = ALIGN16_ASSIGN(outputs); @@ -119,33 +113,44 @@ run_vertex_program(struct draw_context *draw, draw_vertex_fetch( draw, machine, elts, count ); /* run shader */ - if( draw->vertex_shader->state->executable != NULL ) { +#if defined(__i386__) || defined(__386__) + if (draw->use_sse) { /* SSE */ - codegen_function func = (codegen_function) draw->vertex_shader->state->executable; + /* cast away const */ + struct draw_vertex_shader *shader + = (struct draw_vertex_shader *)draw->vertex_shader; + codegen_function func + = (codegen_function) x86_get_func( &shader->sse2_program ); func( machine->Inputs, machine->Outputs, machine->Consts, machine->Temps ); } - else { + else +#endif + { /* interpreter */ tgsi_exec_machine_run( machine ); } - /* store machine results */ for (j = 0; j < count; j++) { unsigned slot; float x, y, z, w; - /* Handle attr[0] (position) specially: */ + /* Handle attr[0] (position) specially: + * + * XXX: Computing the clipmask should be done in the vertex + * program as a set of DP4 instructions appended to the + * user-provided code. + */ x = vOut[j]->clip[0] = machine->Outputs[0].xyzw[0].f[j]; y = vOut[j]->clip[1] = machine->Outputs[0].xyzw[1].f[j]; z = vOut[j]->clip[2] = machine->Outputs[0].xyzw[2].f[j]; w = vOut[j]->clip[3] = machine->Outputs[0].xyzw[3].f[j]; - vOut[j]->clipmask = compute_clipmask(x, y, z, w) | draw->user_clipmask; + vOut[j]->clipmask = compute_clipmask(vOut[j]->clip, draw->plane, draw->nr_planes); vOut[j]->edgeflag = 1; /* divide by w */ @@ -160,37 +165,49 @@ run_vertex_program(struct draw_context *draw, vOut[j]->data[0][2] = z * scale[2] + trans[2]; vOut[j]->data[0][3] = w; +#if DBG_VS + printf("output[%d]win: %f %f %f %f\n", j, + vOut[j]->data[0][0], + vOut[j]->data[0][1], + vOut[j]->data[0][2], + vOut[j]->data[0][3]); +#endif /* Remaining attributes are packed into sequential post-transform * vertex attrib slots. - * Skip 0 since we just did it above. - * Subtract two because of the VERTEX_HEADER, CLIP_POS attribs. */ - for (slot = 1; slot < draw->vertex_info.num_attribs - 2; slot++) { + for (slot = 1; slot < draw->num_vs_outputs; slot++) { vOut[j]->data[slot][0] = machine->Outputs[slot].xyzw[0].f[j]; vOut[j]->data[slot][1] = machine->Outputs[slot].xyzw[1].f[j]; vOut[j]->data[slot][2] = machine->Outputs[slot].xyzw[2].f[j]; vOut[j]->data[slot][3] = machine->Outputs[slot].xyzw[3].f[j]; - /* - printf("output %d: %f %f %f %f\n", slot, +#if DBG_VS + printf("output[%d][%d]: %f %f %f %f\n", j, slot, vOut[j]->data[slot][0], vOut[j]->data[slot][1], vOut[j]->data[slot][2], vOut[j]->data[slot][3]); - */ +#endif } } /* loop over vertices */ } /** + * Run the vertex shader on all vertices in the vertex queue. * Called by the draw module when the vertx cache needs to be flushed. - * This involves running the vertex shader. */ -void draw_vertex_shader_queue_flush( struct draw_context *draw ) +void +draw_vertex_shader_queue_flush(struct draw_context *draw) { unsigned i, j; // fprintf(stderr, " q(%d) ", draw->vs.queue_nr ); +#ifdef MESA_LLVM + if (draw->vertex_shader->llvm_prog) { + draw_vertex_shader_queue_flush_llvm(draw); + return; + } +#endif /* run vertex shader on vertex cache entries, four per invokation */ for (i = 0; i < draw->vs.queue_nr; i += 4) { @@ -214,48 +231,66 @@ void draw_vertex_shader_queue_flush( struct draw_context *draw ) } -void * +struct draw_vertex_shader * draw_create_vertex_shader(struct draw_context *draw, const struct pipe_shader_state *shader) { - struct draw_vertex_shader *vs = calloc(1, sizeof(struct draw_vertex_shader)); + struct draw_vertex_shader *vs; + + vs = CALLOC_STRUCT( draw_vertex_shader ); + if (vs == NULL) { + return NULL; + } vs->state = shader; -#if defined(__i386__) || defined(__386__) - x86_init_func(&vs->sse2_program); +#ifdef MESA_LLVM + vs->llvm_prog = gallivm_from_tgsi(shader->tokens, GALLIVM_VS); + draw->engine = gallivm_global_cpu_engine(); + if (!draw->engine) { + draw->engine = gallivm_cpu_engine_create(vs->llvm_prog); + } + else { + gallivm_cpu_jit_compile(draw->engine, vs->llvm_prog); + } +#elif defined(__i386__) || defined(__386__) if (draw->use_sse) { - tgsi_emit_sse2(shader->tokens, &vs->sse2_program); - ((struct pipe_shader_state*)(vs->state))->executable = - x86_get_func(&vs->sse2_program); + /* cast-away const */ + struct pipe_shader_state *sh = (struct pipe_shader_state *) shader; + + x86_init_func( &vs->sse2_program ); + tgsi_emit_sse2( (struct tgsi_token *) sh->tokens, &vs->sse2_program ); } #endif return vs; } -void draw_bind_vertex_shader(struct draw_context *draw, - void *vcso) + +void +draw_bind_vertex_shader(struct draw_context *draw, + struct draw_vertex_shader *dvs) { draw_flush(draw); - draw->vertex_shader = (struct draw_vertex_shader*)(vcso); + draw->vertex_shader = dvs; + + draw->num_vs_outputs = dvs->state->num_outputs; - /* init machine state */ + /* specify the fragment program to interpret/execute */ tgsi_exec_machine_init(&draw->machine, draw->vertex_shader->state->tokens, PIPE_MAX_SAMPLERS, NULL /*samplers*/ ); } -void draw_delete_vertex_shader(struct draw_context *draw, - void *vcso) + +void +draw_delete_vertex_shader(struct draw_context *draw, + struct draw_vertex_shader *dvs) { - struct draw_vertex_shader *vs = (struct draw_vertex_shader*)(vcso); #if defined(__i386__) || defined(__386__) - x86_release_func(&vs->sse2_program); + x86_release_func( (struct x86_function *) &dvs->sse2_program ); #endif - free(vcso); -} - - + FREE( dvs ); +}