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=2d424632e734357f45849acd18df36d48a9ebd63;hpb=37cf13ed9a429c755f121daa1776b1b30a985ab3;p=mesa.git

diff --git a/src/mesa/pipe/draw/draw_vertex_shader.c b/src/mesa/pipe/draw/draw_vertex_shader.c
index 2d424632e73..5ca659dbf59 100644
--- a/src/mesa/pipe/draw/draw_vertex_shader.c
+++ b/src/mesa/pipe/draw/draw_vertex_shader.c
@@ -32,45 +32,52 @@
   */
 
 #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 "pipe/tgsi/exec/tgsi_core.h"
+#include "x86/rtasm/x86sse.h"
+#include "pipe/llvm/gallivm.h"
+
+
+#define DBG_VS 0
+
 
 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<<i);
+   }
 
    return mask;
 }
 
 
-
-
-#if !defined(XSTDCALL) 
-#if defined(WIN32)
-#define XSTDCALL __stdcall
-#else
-#define XSTDCALL
-#endif
-#endif
-
-#if defined(USE_X86_ASM) || defined(SLANG_X86)
-typedef void (XSTDCALL *sse2_function)(
+typedef void (XSTDCALL *codegen_function) (
    const struct tgsi_exec_vector *input,
    struct tgsi_exec_vector *output,
    float (*constant)[4],
    struct tgsi_exec_vector *temporary );
-#endif
+
 
 /**
  * Transform vertices with the current vertex program/shader
@@ -85,7 +92,7 @@ run_vertex_program(struct draw_context *draw,
                    unsigned elts[4], unsigned count,
                    struct vertex_header *vOut[])
 {
-   struct tgsi_exec_machine machine;
+   struct tgsi_exec_machine *machine = &draw->machine;
    unsigned int j;
 
    ALIGN16_DECL(struct tgsi_exec_vector, inputs, PIPE_ATTRIB_MAX);
@@ -94,60 +101,56 @@ run_vertex_program(struct draw_context *draw,
    const float *trans = draw->viewport.translate;
 
    assert(count <= 4);
-#if 0
-   assert(draw->vertex_shader.outputs_written & (1 << TGSI_ATTRIB_POS));
-#else
-   assert(draw->vertex_shader.output_semantics[0] == TGSI_SEMANTIC_POSITION);
-#endif
-
-#ifdef DEBUG
-   memset( &machine, 0, sizeof( machine ) );
-#endif
-
-   /* init machine state */
-   tgsi_exec_machine_init(&machine,
-                          draw->vertex_shader.tokens,
-                          PIPE_MAX_SAMPLERS,
-                          NULL /*samplers*/ );
+   assert(draw->vertex_shader->state->output_semantic_name[0]
+          == TGSI_SEMANTIC_POSITION);
 
    /* 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);
+   machine->Inputs = ALIGN16_ASSIGN(inputs);
+   machine->Outputs = ALIGN16_ASSIGN(outputs);
 
-   draw_vertex_fetch( draw, &machine, elts, count );
+   draw_vertex_fetch( draw, machine, elts, count );
 
    /* run shader */
-   if( draw->vertex_shader.executable != NULL ) {
-#if defined(USE_X86_ASM) || defined(SLANG_X86)
-      sse2_function func = (sse2_function) draw->vertex_shader.executable;
+#if defined(__i386__) || defined(__386__)
+   if (draw->use_sse) {
+      /* SSE */
+      /* 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
-      assert( 0 );
-#endif
+         machine->Inputs,
+         machine->Outputs,
+         machine->Consts,
+         machine->Temps );
    }
-   else {
-      tgsi_exec_machine_run( &machine );
+   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: */
-      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];
+      /* 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 */
@@ -162,36 +165,50 @@ 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++) {
-         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,
+      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];
+#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) {
       struct vertex_header *dests[4];
@@ -213,3 +230,67 @@ void draw_vertex_shader_queue_flush( struct draw_context *draw )
    draw->vs.queue_nr = 0;
 }
 
+
+struct draw_vertex_shader *
+draw_create_vertex_shader(struct draw_context *draw,
+                          const struct pipe_shader_state *shader)
+{
+   struct draw_vertex_shader *vs;
+
+   vs = CALLOC_STRUCT( draw_vertex_shader );
+   if (vs == NULL) {
+      return NULL;
+   }
+
+   vs->state = shader;
+
+#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) {
+      /* 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,
+                        struct draw_vertex_shader *dvs)
+{
+   draw_flush(draw);
+   draw->vertex_shader = dvs;
+
+   draw->num_vs_outputs = dvs->state->num_outputs;
+
+   /* 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,
+                          struct draw_vertex_shader *dvs)
+{
+#if defined(__i386__) || defined(__386__)
+   x86_release_func( (struct x86_function *) &dvs->sse2_program );
+#endif
+
+   FREE( dvs );
+}