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 varyings[MAX_VARYING_VECTORS];
  41         GLvector4f ndc_coords;
  42         GLubyte *clipmask;
  43         GLubyte ormask;
  44         GLubyte andmask;
  45 } arbvs_stage_data;
  46
  47 #define ARBVS_STAGE_DATA(stage) ((arbvs_stage_data *) stage->privatePtr)
  48
  49 static GLboolean construct_arb_vertex_shader (GLcontext *ctx, struct tnl_pipeline_stage *stage)
  50 {
  51         TNLcontext *tnl = TNL_CONTEXT(ctx);
  52         struct vertex_buffer *vb = &tnl->vb;
  53         arbvs_stage_data *store;
  54         GLuint size = vb->Size;
  55         GLuint i;
  56
  57         stage->privatePtr = _mesa_malloc (sizeof (arbvs_stage_data));
  58         store = ARBVS_STAGE_DATA(stage);
  59         if (store == NULL)
  60                 return GL_FALSE;
  61
  62         for (i = 0; i < VERT_RESULT_MAX; i++)
  63         {
  64                 _mesa_vector4f_alloc (&store->outputs[i], 0, size, 32);
  65                 store->outputs[i].size = 4;
  66         }
  67         for (i = 0; i < MAX_VARYING_VECTORS; i++)
  68         {
  69                 _mesa_vector4f_alloc (&store->varyings[i], 0, size, 32);
  70                 store->varyings[i].size = 4;
  71         }
  72         _mesa_vector4f_alloc (&store->ndc_coords, 0, size, 32);
  73         store->clipmask = (GLubyte *) ALIGN_MALLOC (size, 32);
  74
  75         return GL_TRUE;
  76 }
  77
  78 static void destruct_arb_vertex_shader (struct tnl_pipeline_stage *stage)
  79 {
  80         arbvs_stage_data *store = ARBVS_STAGE_DATA(stage);
  81
  82         if (store != NULL)
  83         {
  84                 GLuint i;
  85
  86                 for (i = 0; i < VERT_RESULT_MAX; i++)
  87                         _mesa_vector4f_free (&store->outputs[i]);
  88                 for (i = 0; i < MAX_VARYING_VECTORS; i++)
  89                         _mesa_vector4f_free (&store->varyings[i]);
  90                 _mesa_vector4f_free (&store->ndc_coords);
  91                 ALIGN_FREE (store->clipmask);
  92
  93                 _mesa_free (store);
  94                 stage->privatePtr = NULL;
  95         }
  96 }
  97
  98 static void validate_arb_vertex_shader (GLcontext *ctx, struct tnl_pipeline_stage *stage)
  99 {
 100 }
 101
 102 static GLvoid fetch_input_float (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
 103         struct vertex_buffer *vb)
 104 {
 105         const GLubyte *ptr = (const GLubyte *) vb->AttribPtr[attr]->data;
 106         const GLuint stride = vb->AttribPtr[attr]->stride;
 107         const GLfloat *data = (const GLfloat *) (ptr + stride * i);
 108         GLfloat vec[1];
 109
 110         vec[0] = data[0];
 111         (**pro).UpdateFixedAttribute (pro, index, vec, 0, sizeof (GLfloat), GL_TRUE);
 112 }
 113
 114 static GLvoid fetch_input_vec3 (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
 115         struct vertex_buffer *vb)
 116 {
 117         const GLubyte *ptr = (const GLubyte *) vb->AttribPtr[attr]->data;
 118         const GLuint stride = vb->AttribPtr[attr]->stride;
 119         const GLfloat *data = (const GLfloat *) (ptr + stride * i);
 120         GLfloat vec[3];
 121
 122         vec[0] = data[0];
 123         vec[1] = data[1];
 124         vec[2] = data[2];
 125         (**pro).UpdateFixedAttribute (pro, index, vec, 0, 3 * sizeof (GLfloat), GL_TRUE);
 126 }
 127
 128 static void fetch_input_vec4 (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
 129         struct vertex_buffer *vb)
 130 {
 131         const GLubyte *ptr = (const GLubyte *) vb->AttribPtr[attr]->data;
 132         const GLuint size = vb->AttribPtr[attr]->size;
 133         const GLuint stride = vb->AttribPtr[attr]->stride;
 134         const GLfloat *data = (const GLfloat *) (ptr + stride * i);
 135         GLfloat vec[4];
 136
 137         switch (size)
 138         {
 139         case 2:
 140                 vec[0] = data[0];
 141                 vec[1] = data[1];
 142                 vec[2] = 0.0f;
 143                 vec[3] = 1.0f;
 144                 break;
 145         case 3:
 146                 vec[0] = data[0];
 147                 vec[1] = data[1];
 148                 vec[2] = data[2];
 149                 vec[3] = 1.0f;
 150                 break;
 151         case 4:
 152                 vec[0] = data[0];
 153                 vec[1] = data[1];
 154                 vec[2] = data[2];
 155                 vec[3] = data[3];
 156                 break;
 157         }
 158         (**pro).UpdateFixedAttribute (pro, index, vec, 0, 4 * sizeof (GLfloat), GL_TRUE);
 159 }
 160
 161 static GLvoid fetch_output_float (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
 162         arbvs_stage_data *store)
 163 {
 164         (**pro).UpdateFixedAttribute (pro, index, &store->outputs[attr].data[i], 0, sizeof (GLfloat),
 165                 GL_FALSE);
 166 }
 167
 168 static void fetch_output_vec4 (struct gl2_program_intf **pro, GLuint index, GLuint attr, GLuint i,
 169         GLuint offset, arbvs_stage_data *store)
 170 {
 171         (**pro).UpdateFixedAttribute (pro, index, &store->outputs[attr].data[i], offset,
 172                 4 * sizeof (GLfloat), GL_FALSE);
 173 }
 174
 175 static GLboolean run_arb_vertex_shader (GLcontext *ctx, struct tnl_pipeline_stage *stage)
 176 {
 177         TNLcontext *tnl = TNL_CONTEXT(ctx);
 178         struct vertex_buffer *vb = &tnl->vb;
 179         arbvs_stage_data *store = ARBVS_STAGE_DATA(stage);
 180         struct gl2_program_intf **pro;
 181         GLsizei i, j;
 182
 183         if (!ctx->ShaderObjects._VertexShaderPresent)
 184                 return GL_TRUE;
 185
 186         pro = ctx->ShaderObjects.CurrentProgram;
 187         (**pro).UpdateFixedUniforms (pro);
 188
 189         for (i = 0; i < vb->Count; i++)
 190         {
 191                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_VERTEX, _TNL_ATTRIB_POS, i, vb);
 192                 fetch_input_vec3 (pro, SLANG_VERTEX_FIXED_NORMAL, _TNL_ATTRIB_NORMAL, i, vb);
 193                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_COLOR, _TNL_ATTRIB_COLOR0, i, vb);
 194                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_SECONDARYCOLOR, _TNL_ATTRIB_COLOR1, i, vb);
 195                 fetch_input_float (pro, SLANG_VERTEX_FIXED_FOGCOORD, _TNL_ATTRIB_FOG, i, vb);
 196                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD0, _TNL_ATTRIB_TEX0, i, vb);
 197                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD1, _TNL_ATTRIB_TEX1, i, vb);
 198                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD2, _TNL_ATTRIB_TEX2, i, vb);
 199                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD3, _TNL_ATTRIB_TEX3, i, vb);
 200                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD4, _TNL_ATTRIB_TEX4, i, vb);
 201                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD5, _TNL_ATTRIB_TEX5, i, vb);
 202                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD6, _TNL_ATTRIB_TEX6, i, vb);
 203                 fetch_input_vec4 (pro, SLANG_VERTEX_FIXED_MULTITEXCOORD7, _TNL_ATTRIB_TEX7, i, vb);
 204
 205                 _slang_exec_vertex_shader (pro);
 206
 207                 fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_POSITION, VERT_RESULT_HPOS, i, 0, store);
 208                 fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_FRONTCOLOR, VERT_RESULT_COL0, i, 0, store);
 209                 fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_FRONTSECONDARYCOLOR, VERT_RESULT_COL1, i, 0, store);
 210                 fetch_output_float (pro, SLANG_VERTEX_FIXED_FOGFRAGCOORD, VERT_RESULT_FOGC, i, store);
 211                 for (j = 0; j < 8; j++)
 212                         fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_TEXCOORD, VERT_RESULT_TEX0 + j, i, j, store);
 213                 fetch_output_float (pro, SLANG_VERTEX_FIXED_POINTSIZE, VERT_RESULT_PSIZ, i, store);
 214                 fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_BACKCOLOR, VERT_RESULT_BFC0, i, 0, store);
 215                 fetch_output_vec4 (pro, SLANG_VERTEX_FIXED_BACKSECONDARYCOLOR, VERT_RESULT_BFC1, i, 0, store);
 216                 /* XXX: fetch output SLANG_VERTEX_FIXED_CLIPVERTEX */
 217
 218                 for (j = 0; j < MAX_VARYING_VECTORS; j++)
 219                 {
 220                         GLuint k;
 221
 222                         for (k = 0; k < VARYINGS_PER_VECTOR; k++)
 223                         {
 224                                 (**pro).UpdateVarying (pro, j * VARYINGS_PER_VECTOR + k,
 225                                         &store->varyings[j].data[i][k], GL_TRUE);
 226                         }
 227                 }
 228         }
 229
 230         vb->ClipPtr = &store->outputs[VERT_RESULT_HPOS];
 231         vb->ClipPtr->count = vb->Count;
 232         vb->ColorPtr[0] = &store->outputs[VERT_RESULT_COL0];
 233         vb->SecondaryColorPtr[0] = &store->outputs[VERT_RESULT_COL1];
 234         for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++)
 235                 vb->TexCoordPtr[i] = &store->outputs[VERT_RESULT_TEX0 + i];
 236         vb->ColorPtr[1] = &store->outputs[VERT_RESULT_BFC0];
 237         vb->SecondaryColorPtr[1] = &store->outputs[VERT_RESULT_BFC1];
 238         vb->FogCoordPtr = &store->outputs[VERT_RESULT_FOGC];
 239         vb->PointSizePtr = &store->outputs[VERT_RESULT_PSIZ];
 240         for (i = 0; i < MAX_VARYING_VECTORS; i++)
 241                 vb->VaryingPtr[i] = &store->varyings[i];
 242
 243         vb->AttribPtr[VERT_ATTRIB_COLOR0] = vb->ColorPtr[0];
 244         vb->AttribPtr[VERT_ATTRIB_COLOR1] = vb->SecondaryColorPtr[0];
 245         vb->AttribPtr[VERT_ATTRIB_FOG] = vb->FogCoordPtr;
 246         for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++)
 247                 vb->AttribPtr[VERT_ATTRIB_TEX0 + i] = vb->TexCoordPtr[i];
 248         vb->AttribPtr[_TNL_ATTRIB_POINTSIZE] = &store->outputs[VERT_RESULT_PSIZ];
 249         for (i = 0; i < MAX_VARYING_VECTORS; i++)
 250                 vb->AttribPtr[_TNL_ATTRIB_ATTRIBUTE0 + i] = vb->VaryingPtr[i];
 251
 252         store->ormask = 0;
 253         store->andmask = CLIP_FRUSTUM_BITS;
 254
 255         if (tnl->NeedNdcCoords)
 256         {
 257                 vb->NdcPtr = _mesa_clip_tab[vb->ClipPtr->size] (vb->ClipPtr, &store->ndc_coords,
 258                         store->clipmask, &store->ormask, &store->andmask);
 259         }
 260         else
 261         {
 262                 vb->NdcPtr = NULL;
 263                 _mesa_clip_np_tab[vb->ClipPtr->size] (vb->ClipPtr, NULL, store->clipmask, &store->ormask,
 264                         &store->andmask);
 265         }
 266
 267         if (store->andmask)
 268                 return GL_FALSE;
 269
 270         vb->ClipAndMask = store->andmask;
 271         vb->ClipOrMask = store->ormask;
 272         vb->ClipMask = store->clipmask;
 273
 274         return GL_TRUE;
 275 }
 276
 277 const struct tnl_pipeline_stage _tnl_arb_vertex_shader_stage = {
 278         "ARB_vertex_shader",
 279         NULL,
 280         construct_arb_vertex_shader,
 281         destruct_arb_vertex_shader,
 282         validate_arb_vertex_shader,
 283         run_arb_vertex_shader
 284 };
 285