src/mesa/tnl/t_vb_arbshader.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5
   4  *
   5  * Copyright (C) 2006  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Michal Krol
  26  */
  27
  28 #include "glheader.h"
  29 #include "imports.h"
  30 #include "macros.h"
  31 #include "shaderobjects.h"
  32 #include "shaderobjects_3dlabs.h"
  33 #include "t_pipeline.h"
  34 #include "slang_utility.h"
  35 #include "slang_link.h"
  36
  37 typedef struct
  38 {
  39         GLvector4f outputs[VERT_RESULT_MAX];
  40         GLvector4f ndc_coords;
  41         GLubyte *clipmask;
  42         GLubyte ormask;
  43         GLubyte andmask;
  44 } arbvs_stage_data;
  45
  46 #define ARBVS_STAGE_DATA(stage) ((arbvs_stage_data *) stage->privatePtr)
  47
  48 static GLboolean construct_arb_vertex_shader (GLcontext *ctx, struct tnl_pipeline_stage *stage)
  49 {
  50         TNLcontext *tnl = TNL_CONTEXT(ctx);
  51         struct vertex_buffer *vb = &tnl->vb;
  52         arbvs_stage_data *store;
  53         GLuint size = vb->Size;
  54         GLuint i;
  55
  56         stage->privatePtr = _mesa_malloc (sizeof (arbvs_stage_data));
  57         store = ARBVS_STAGE_DATA(stage);
  58         if (store == NULL)
  59                 return GL_FALSE;
  60
  61         for (i = 0; i < VERT_RESULT_MAX; i++)
  62         {
  63                 _mesa_vector4f_alloc (&store->outputs[i], 0, size, 32);
  64                 store->outputs[i].size = 4;
  65         }
  66         _mesa_vector4f_alloc (&store->ndc_coords, 0, size, 32);
  67         store->clipmask = (GLubyte *) ALIGN_MALLOC (size, 32);
  68
  69         return GL_TRUE;
  70 }
  71
  72 static void destruct_arb_vertex_shader (struct tnl_pipeline_stage *stage)
  73 {
  74         arbvs_stage_data *store = ARBVS_STAGE_DATA(stage);
  75
  76         if (store != NULL)
  77         {
  78                 GLuint i;
  79
  80                 for (i = 0; i < VERT_RESULT_MAX; i++)
  81                         _mesa_vector4f_free (&store->outputs[i]);
  82                 _mesa_vector4f_free (&store->ndc_coords);
  83                 ALIGN_FREE (store->clipmask);
  84
  85                 _mesa_free (store);
  86                 stage->privatePtr = NULL;
  87         }
  88 }
  89
  90 static void validate_arb_vertex_shader (GLcontext *ctx, struct tnl_pipeline_stage *stage)
  91 {
  92 }
  93
  94 static GLvoid fetch_input_float (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
  95         struct vertex_buffer *vb)
  96 {
  97         const GLubyte *ptr = (const GLubyte *) vb->AttribPtr[attr]->data;
  98         const GLuint stride = vb->AttribPtr[attr]->stride;
  99         const GLfloat *data = (const GLfloat *) (ptr + stride * i);
 100         GLfloat vec[1];
 101
 102         vec[0] = data[0];
 103         (**pro).UpdateFixedAttribute (pro, index, vec, 0, sizeof (GLfloat), GL_TRUE);
 104 }
 105
 106 static GLvoid fetch_input_vec3 (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
 107         struct vertex_buffer *vb)
 108 {
 109         const GLubyte *ptr = (const GLubyte *) vb->AttribPtr[attr]->data;
 110         const GLuint stride = vb->AttribPtr[attr]->stride;
 111         const GLfloat *data = (const GLfloat *) (ptr + stride * i);
 112         GLfloat vec[3];
 113
 114         vec[0] = data[0];
 115         vec[1] = data[1];
 116         vec[2] = data[2];
 117         (**pro).UpdateFixedAttribute (pro, index, vec, 0, 3 * sizeof (GLfloat), GL_TRUE);
 118 }
 119
 120 static void fetch_input_vec4 (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
 121         struct vertex_buffer *vb)
 122 {
 123         const GLubyte *ptr = (const GLubyte *) vb->AttribPtr[attr]->data;
 124         const GLuint size = vb->AttribPtr[attr]->size;
 125         const GLuint stride = vb->AttribPtr[attr]->stride;
 126         const GLfloat *data = (const GLfloat *) (ptr + stride * i);
 127         GLfloat vec[4];
 128
 129         switch (size)
 130         {
 131         case 2:
 132                 vec[0] = data[0];
 133                 vec[1] = data[1];
 134                 vec[2] = 0.0f;
 135                 vec[3] = 1.0f;
 136                 break;
 137         case 3:
 138                 vec[0] = data[0];
 139                 vec[1] = data[1];
 140                 vec[2] = data[2];
 141                 vec[3] = 1.0f;
 142                 break;
 143         case 4:
 144                 vec[0] = data[0];
 145                 vec[1] = data[1];
 146                 vec[2] = data[2];
 147                 vec[3] = data[3];
 148                 break;
 149         }
 150         (**pro).UpdateFixedAttribute (pro, index, vec, 0, 4 * sizeof (GLfloat), GL_TRUE);
 151 }
 152
 153 static GLvoid fetch_output_float (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
 154         arbvs_stage_data *store)
 155 {
 156         (**pro).UpdateFixedAttribute (pro, index, &store->outputs[attr].data[i], 0, sizeof (GLfloat),
 157                 GL_FALSE);
 158 }
 159
 160 static void fetch_output_vec4 (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
 161         GLuint offset, arbvs_stage_data *store)
 162 {
 163         (**pro).UpdateFixedAttribute (pro, index, &store->outputs[attr].data[i], offset,
 164                 4 * sizeof (GLfloat), GL_FALSE);
 165 }
 166
 167 static GLboolean run_arb_vertex_shader (GLcontext *ctx, struct tnl_pipeline_stage *stage)
 168 {
 169         TNLcontext *tnl = TNL_CONTEXT(ctx);
 170         struct vertex_buffer *vb = &tnl->vb;
 171         arbvs_stage_data *store = ARBVS_STAGE_DATA(stage);
 172         struct gl2_program_intf **pro;
 173         GLsizei i, j;
 174
 175         if (!ctx->ShaderObjects._VertexShaderPresent)
 176                 return GL_TRUE;
 177
 178         pro = ctx->ShaderObjects.CurrentProgram;
 179         (**pro).UpdateFixedUniforms (pro);
 180
 181         for (i = 0; i < vb->Count; i++)
 182         {
 183                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_VERTEX, _TNL_ATTRIB_POS, i, vb);
 184                 fetch_input_vec3 (pro, SLANG_VERTEX_FIXED_NORMAL, _TNL_ATTRIB_NORMAL, i, vb);
 185                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_COLOR, _TNL_ATTRIB_COLOR0, i, vb);
 186                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_SECONDARYCOLOR, _TNL_ATTRIB_COLOR1, i, vb);
 187                 fetch_input_float (pro, SLANG_VERTEX_FIXED_FOGCOORD, _TNL_ATTRIB_FOG, i, vb);
 188                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD0, _TNL_ATTRIB_TEX0, i, vb);
 189                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD1, _TNL_ATTRIB_TEX1, i, vb);
 190                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD2, _TNL_ATTRIB_TEX2, i, vb);
 191                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD3, _TNL_ATTRIB_TEX3, i, vb);
 192                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD4, _TNL_ATTRIB_TEX4, i, vb);
 193                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD5, _TNL_ATTRIB_TEX5, i, vb);
 194                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD6, _TNL_ATTRIB_TEX6, i, vb);
 195                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD7, _TNL_ATTRIB_TEX7, i, vb);
 196
 197                 _slang_exec_vertex_shader (pro);
 198
 199                 fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_POSITION, VERT_RESULT_HPOS, i, 0, store);
 200                 fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_FRONTCOLOR, VERT_RESULT_COL0, i, 0, store);
 201                 fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_FRONTSECONDARYCOLOR, VERT_RESULT_COL1, i, 0, store);
 202                 fetch_output_float (pro, SLANG_VERTEX_FIXED_FOGFRAGCOORD, VERT_RESULT_FOGC, i, store);
 203                 for (j = 0; j < 8; j++)
 204                         fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_TEXCOORD, VERT_RESULT_TEX0 + j, i, j, store);
 205                 fetch_output_float (pro, SLANG_VERTEX_FIXED_POINTSIZE, VERT_RESULT_PSIZ, i, store);
 206                 fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_BACKCOLOR, VERT_RESULT_BFC0, i, 0, store);
 207                 fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_BACKSECONDARYCOLOR, VERT_RESULT_BFC1, i, 0, store);
 208                 /* XXX: fetch output SLANG_VERTEX_FIXED_CLIPVERTEX */
 209         }
 210
 211         vb->ClipPtr = &store->outputs[VERT_RESULT_HPOS];
 212         vb->ClipPtr->count = vb->Count;
 213         vb->ColorPtr[0] = &store->outputs[VERT_RESULT_COL0];
 214         vb->SecondaryColorPtr[0] = &store->outputs[VERT_RESULT_COL1];
 215         for (i = 0; i < ctx->Const.MaxTextureUnits; i++)
 216                 vb->TexCoordPtr[i] = &store->outputs[VERT_RESULT_TEX0 + i];
 217         vb->ColorPtr[1] = &store->outputs[VERT_RESULT_BFC0];
 218         vb->SecondaryColorPtr[1] = &store->outputs[VERT_RESULT_BFC1];
 219         vb->FogCoordPtr = &store->outputs[VERT_RESULT_FOGC];
 220         vb->PointSizePtr = &store->outputs[VERT_RESULT_PSIZ];
 221
 222         vb->AttribPtr[VERT_ATTRIB_COLOR0] = vb->ColorPtr[0];
 223         vb->AttribPtr[VERT_ATTRIB_COLOR1] = vb->SecondaryColorPtr[0];
 224         vb->AttribPtr[VERT_ATTRIB_FOG] = vb->FogCoordPtr;
 225         for (i = 0; i < ctx->Const.MaxTextureUnits; i++)
 226                 vb->AttribPtr[VERT_ATTRIB_TEX0 + i] = vb->TexCoordPtr[i];
 227         vb->AttribPtr[_TNL_ATTRIB_POINTSIZE] = &store->outputs[VERT_RESULT_PSIZ];
 228
 229         store->ormask = 0;
 230         store->andmask = CLIP_ALL_BITS;
 231
 232         if (tnl->NeedNdcCoords)
 233         {
 234                 vb->NdcPtr = _mesa_clip_tab[vb->ClipPtr->size] (vb->ClipPtr, &store->ndc_coords,
 235                         store->clipmask, &store->ormask, &store->andmask);
 236         }
 237         else
 238         {
 239                 vb->NdcPtr = NULL;
 240                 _mesa_clip_np_tab[vb->ClipPtr->size] (vb->ClipPtr, NULL, store->clipmask, &store->ormask,
 241                         &store->andmask);
 242         }
 243
 244         if (store->andmask)
 245                 return GL_FALSE;
 246
 247         vb->ClipAndMask = store->andmask;
 248         vb->ClipOrMask = store->ormask;
 249         vb->ClipMask = store->clipmask;
 250
 251         return GL_TRUE;
 252 }
 253
 254 const struct tnl_pipeline_stage _tnl_arb_vertex_shader_stage = {
 255         "ARB_vertex_shader",
 256         NULL,
 257         construct_arb_vertex_shader,
 258         destruct_arb_vertex_shader,
 259         validate_arb_vertex_shader,
 260         run_arb_vertex_shader
 261 };
 262