mesa: Replace ctx->Shader.Current{Vertex,Fragment,Geometry}Program with an array.
authorPaul Berry <stereotype441@gmail.com>
Thu, 9 Jan 2014 19:16:27 +0000 (11:16 -0800)
committerPaul Berry <stereotype441@gmail.com>
Wed, 22 Jan 2014 04:25:02 +0000 (20:25 -0800)
These are replaced with
ctx->Shader.CurrentProgram[MESA_SHADER_{VERTEX,FRAGMENT,GEOMETRY}].
In patches to follow, this will allow us to replace a lot of ad-hoc
logic with a variable index into the array.

With the exception of the changes to mtypes.h, this patch was
generated entirely by the command:

    find src -type f '(' -iname '*.c' -o -iname '*.cpp' ')' \
    -print0 | xargs -0 sed -i \
    -e 's/\.CurrentVertexProgram/.CurrentProgram[MESA_SHADER_VERTEX]/g' \
    -e 's/\.CurrentGeometryProgram/.CurrentProgram[MESA_SHADER_GEOMETRY]/g' \
    -e 's/\.CurrentFragmentProgram/.CurrentProgram[MESA_SHADER_FRAGMENT]/g'

Reviewed-by: Chris Forbes <chrisf@ijw.co.nz>
Reviewed-by: Brian Paul <brianp@vmware.com>
28 files changed:
src/mesa/drivers/common/meta.c
src/mesa/drivers/dri/i965/brw_gs.c
src/mesa/drivers/dri/i965/brw_gs_surface_state.c
src/mesa/drivers/dri/i965/brw_vec4_gs.c
src/mesa/drivers/dri/i965/brw_vs.c
src/mesa/drivers/dri/i965/brw_vs_state.c
src/mesa/drivers/dri/i965/brw_vs_surface_state.c
src/mesa/drivers/dri/i965/brw_wm_state.c
src/mesa/drivers/dri/i965/gen6_sol.c
src/mesa/drivers/dri/i965/gen6_vs_state.c
src/mesa/drivers/dri/i965/gen6_wm_state.c
src/mesa/drivers/dri/i965/gen7_sol_state.c
src/mesa/drivers/dri/i965/gen7_vs_state.c
src/mesa/drivers/dri/i965/gen7_wm_state.c
src/mesa/main/api_validate.c
src/mesa/main/context.c
src/mesa/main/ff_fragment_shader.cpp
src/mesa/main/mtypes.h
src/mesa/main/shaderapi.c
src/mesa/main/state.c
src/mesa/main/texstate.c
src/mesa/main/transformfeedback.c
src/mesa/state_tracker/st_atom_clip.c
src/mesa/state_tracker/st_atom_constbuf.c
src/mesa/state_tracker/st_cb_drawpixels.c
src/mesa/state_tracker/st_draw.c
src/mesa/state_tracker/st_program.c
src/mesa/swrast/s_fragprog.c

index 3855536ad37eccbc5e262a6721c06eac412d6f92..98ac6f86c42840108e95b0b1f293cb9dab4bdfe7 100644 (file)
@@ -618,11 +618,11 @@ _mesa_meta_begin(struct gl_context *ctx, GLbitfield state)
       }
 
       _mesa_reference_shader_program(ctx, &save->VertexShader,
-                                     ctx->Shader.CurrentVertexProgram);
+                                     ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX]);
       _mesa_reference_shader_program(ctx, &save->GeometryShader,
-                                     ctx->Shader.CurrentGeometryProgram);
+                                     ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY]);
       _mesa_reference_shader_program(ctx, &save->FragmentShader,
-                                     ctx->Shader.CurrentFragmentProgram);
+                                     ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT]);
       _mesa_reference_shader_program(ctx, &save->ActiveShader,
                                      ctx->Shader.ActiveProgram);
 
index 20e2ecb54f38555cb8fac4cccb9fe8d238647647..3e1ed730b60598695f8e3b9b8b31d8943eee83b5 100644 (file)
@@ -187,7 +187,7 @@ static void populate_key(struct brw_context *brw,
       /* BRW_NEW_TRANSFORM_FEEDBACK */
       if (_mesa_is_xfb_active_and_unpaused(ctx)) {
          const struct gl_shader_program *shaderprog =
-            ctx->Shader.CurrentVertexProgram;
+            ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX];
          const struct gl_transform_feedback_info *linked_xfb_info =
             &shaderprog->LinkedTransformFeedback;
          int i;
index 5661941fabd853070695ef324200e042b544a1e2..1ccf2e28ea2528e49a9d397733ce3d88900cb0c6 100644 (file)
@@ -69,7 +69,7 @@ brw_upload_gs_ubo_surfaces(struct brw_context *brw)
    struct gl_context *ctx = &brw->ctx;
 
    /* _NEW_PROGRAM */
-   struct gl_shader_program *prog = ctx->Shader.CurrentGeometryProgram;
+   struct gl_shader_program *prog = ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY];
 
    if (!prog)
       return;
@@ -93,7 +93,7 @@ brw_upload_gs_abo_surfaces(struct brw_context *brw)
 {
    struct gl_context *ctx = &brw->ctx;
    /* _NEW_PROGRAM */
-   struct gl_shader_program *prog = ctx->Shader.CurrentGeometryProgram;
+   struct gl_shader_program *prog = ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY];
 
    if (prog) {
       /* CACHE_NEW_GS_PROG */
index c40112b0f1f9f568fd867d0b226d015a69249ee4..80e6f97144a9f37277e8fafe61e17d635e5715ff 100644 (file)
@@ -296,7 +296,7 @@ brw_upload_gs_prog(struct brw_context *brw)
    if (!brw_search_cache(&brw->cache, BRW_GS_PROG,
                          &key, sizeof(key),
                          &stage_state->prog_offset, &brw->gs.prog_data)) {
-      bool success = do_gs_prog(brw, ctx->Shader.CurrentGeometryProgram,
+      bool success = do_gs_prog(brw, ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY],
                                 gp, &key);
       assert(success);
    }
index 0e9470fe0a36001266491948d0f9849b62536922..be260ae1a79881e281ddd49414a636ff7ddfdbe1 100644 (file)
@@ -156,7 +156,7 @@ brw_compute_vue_map(struct brw_context *brw, struct brw_vue_map *vue_map,
  */
 gl_clip_plane *brw_select_clip_planes(struct gl_context *ctx)
 {
-   if (ctx->Shader.CurrentVertexProgram) {
+   if (ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX]) {
       /* There is currently a GLSL vertex shader, so clip according to GLSL
        * rules, which means compare gl_ClipVertex (or gl_Position, if
        * gl_ClipVertex wasn't assigned) against the eye-coordinate clip planes
@@ -482,7 +482,7 @@ static void brw_upload_vs_prog(struct brw_context *brw)
    if (!brw_search_cache(&brw->cache, BRW_VS_PROG,
                         &key, sizeof(key),
                         &brw->vs.base.prog_offset, &brw->vs.prog_data)) {
-      bool success = do_vs_prog(brw, ctx->Shader.CurrentVertexProgram,
+      bool success = do_vs_prog(brw, ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX],
                                vp, &key);
       (void) success;
       assert(success);
index a712aee0a20081d5e98b8edcc69a8c8a7c5a2875..e493c3e325eaac198465055f70fc397f2a6bb16f 100644 (file)
@@ -60,7 +60,7 @@ brw_upload_vs_unit(struct brw_context *brw)
    /* Use ALT floating point mode for ARB vertex programs, because they
     * require 0^0 == 1.
     */
-   if (brw->ctx.Shader.CurrentVertexProgram == NULL)
+   if (brw->ctx.Shader.CurrentProgram[MESA_SHADER_VERTEX] == NULL)
       vs->thread1.floating_point_mode = BRW_FLOATING_POINT_NON_IEEE_754;
    else
       vs->thread1.floating_point_mode = BRW_FLOATING_POINT_IEEE_754;
index e3fa6386941c41b82d98b2ae74615464db9a4f69..06e246a0abe8670bcd8af7a2d5ac8bb1107b6cc0 100644 (file)
@@ -130,7 +130,7 @@ brw_upload_vs_ubo_surfaces(struct brw_context *brw)
 {
    struct gl_context *ctx = &brw->ctx;
    /* _NEW_PROGRAM */
-   struct gl_shader_program *prog = ctx->Shader.CurrentVertexProgram;
+   struct gl_shader_program *prog = ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX];
 
    if (!prog)
       return;
@@ -154,7 +154,7 @@ brw_upload_vs_abo_surfaces(struct brw_context *brw)
 {
    struct gl_context *ctx = &brw->ctx;
    /* _NEW_PROGRAM */
-   struct gl_shader_program *prog = ctx->Shader.CurrentVertexProgram;
+   struct gl_shader_program *prog = ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX];
 
    if (prog) {
       /* CACHE_NEW_VS_PROG */
index d9e049336683a9131e79dc145aaaa349e484e9f5..ddd260a72e6b6194c38d40f7cfffa7e9fdfc66d4 100644 (file)
@@ -115,7 +115,7 @@ brw_upload_wm_unit(struct brw_context *brw)
     * rendering, CurrentFragmentProgram is used for this check to
     * differentiate between the GLSL and non-GLSL cases.
     */
-   if (ctx->Shader.CurrentFragmentProgram == NULL)
+   if (ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT] == NULL)
       wm->thread1.floating_point_mode = BRW_FLOATING_POINT_NON_IEEE_754;
    else
       wm->thread1.floating_point_mode = BRW_FLOATING_POINT_IEEE_754;
index eede109a28516b358d3f322af1a1a1ad6b73182b..0047c8aa76e672530d01a9f678682be1ffacc884 100644 (file)
@@ -43,7 +43,7 @@ gen6_update_sol_surfaces(struct brw_context *brw)
       ctx->TransformFeedback.CurrentObject;
    /* BRW_NEW_VERTEX_PROGRAM */
    const struct gl_shader_program *shaderprog =
-      ctx->Shader.CurrentVertexProgram;
+      ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX];
    const struct gl_transform_feedback_info *linked_xfb_info =
       &shaderprog->LinkedTransformFeedback;
    int i;
@@ -89,7 +89,7 @@ brw_gs_upload_binding_table(struct brw_context *brw)
    struct gl_context *ctx = &brw->ctx;
    /* BRW_NEW_VERTEX_PROGRAM */
    const struct gl_shader_program *shaderprog =
-      ctx->Shader.CurrentVertexProgram;
+      ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX];
    bool has_surfaces = false;
    uint32_t *bind;
 
@@ -175,7 +175,7 @@ brw_begin_transform_feedback(struct gl_context *ctx, GLenum mode,
 {
    struct brw_context *brw = brw_context(ctx);
    const struct gl_shader_program *vs_prog =
-      ctx->Shader.CurrentVertexProgram;
+      ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX];
    const struct gl_transform_feedback_info *linked_xfb_info =
       &vs_prog->LinkedTransformFeedback;
    struct gl_transform_feedback_object *xfb_obj =
index ac58e9759c2ce0a46c3c599dd124211d473e53fd..6c6f73979cbc706b43f6c0dab3784f379dddfe2c 100644 (file)
@@ -158,7 +158,7 @@ upload_vs_state(struct brw_context *brw)
    /* Use ALT floating point mode for ARB vertex programs, because they
     * require 0^0 == 1.
     */
-   if (ctx->Shader.CurrentVertexProgram == NULL)
+   if (ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX] == NULL)
       floating_point_mode = GEN6_VS_FLOATING_POINT_MODE_ALT;
 
    BEGIN_BATCH(6);
index 0bb5ef3e75193d0cac2483ce4919b3e36c605e3d..c29a45c16ef61bc41af15602198e314337e29068 100644 (file)
@@ -140,7 +140,7 @@ upload_wm_state(struct brw_context *brw)
     * rendering, CurrentFragmentProgram is used for this check to
     * differentiate between the GLSL and non-GLSL cases.
     */
-   if (ctx->Shader.CurrentFragmentProgram == NULL)
+   if (ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT] == NULL)
       dw2 |= GEN6_WM_FLOATING_POINT_MODE_ALT;
 
    /* CACHE_NEW_SAMPLER */
index 8ef899306a0982fd0fcab7400ebf86f1a12f2682..1ca2b743ccf91df72099a83767acf7cae551f84b 100644 (file)
@@ -41,7 +41,7 @@ upload_3dstate_so_buffers(struct brw_context *brw)
    struct gl_context *ctx = &brw->ctx;
    /* BRW_NEW_VERTEX_PROGRAM */
    const struct gl_shader_program *vs_prog =
-      ctx->Shader.CurrentVertexProgram;
+      ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX];
    const struct gl_transform_feedback_info *linked_xfb_info =
       &vs_prog->LinkedTransformFeedback;
    /* BRW_NEW_TRANSFORM_FEEDBACK */
@@ -104,7 +104,7 @@ gen7_upload_3dstate_so_decl_list(struct brw_context *brw,
    struct gl_context *ctx = &brw->ctx;
    /* BRW_NEW_VERTEX_PROGRAM */
    const struct gl_shader_program *vs_prog =
-      ctx->Shader.CurrentVertexProgram;
+      ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX];
    /* BRW_NEW_TRANSFORM_FEEDBACK */
    const struct gl_transform_feedback_info *linked_xfb_info =
       &vs_prog->LinkedTransformFeedback;
index 1e76eb1ee2eb268582f9807a5df6bb8b685a7580..8381e1fa3892cd44aeab3bd9f70c6b4172e94784 100644 (file)
@@ -92,7 +92,7 @@ upload_vs_state(struct brw_context *brw)
    /* Use ALT floating point mode for ARB vertex programs, because they
     * require 0^0 == 1.
     */
-   if (ctx->Shader.CurrentVertexProgram == NULL)
+   if (ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX] == NULL)
       floating_point_mode = GEN6_VS_FLOATING_POINT_MODE_ALT;
 
    BEGIN_BATCH(6);
index 8dcefc2e04cab79689fe58e269578d0bb7a4a9cf..70b63353215e18d99a65c120b58e71d9b2a8c5b6 100644 (file)
@@ -174,7 +174,7 @@ upload_ps_state(struct brw_context *brw)
     * differentiate between the GLSL and non-GLSL cases.
     */
    /* BRW_NEW_FRAGMENT_PROGRAM */
-   if (ctx->Shader.CurrentFragmentProgram == NULL)
+   if (ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT] == NULL)
       dw2 |= GEN7_PS_FLOATING_POINT_MODE_ALT;
 
    /* Haswell requires the sample mask to be set in this packet as well as
index 96b178905cc28835f00c00b8c1157d4c90eb1593..6945584433e91dbdca0ed9961bb2291d67144691 100644 (file)
@@ -128,7 +128,7 @@ check_valid_to_render(struct gl_context *ctx, const char *function)
    case API_OPENGL_CORE:
       {
          const struct gl_shader_program *vsProg =
-            ctx->Shader.CurrentVertexProgram;
+            ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX];
          GLboolean haveVertexShader = (vsProg && vsProg->LinkStatus);
          GLboolean haveVertexProgram = ctx->VertexProgram._Enabled;
          if (haveVertexShader || haveVertexProgram) {
@@ -269,9 +269,9 @@ _mesa_valid_prim_mode(struct gl_context *ctx, GLenum mode, const char *name)
     *   TRIANGLES_ADJACENCY_ARB or TRIANGLE_STRIP_ADJACENCY_ARB.
     *
    */
-   if (ctx->Shader.CurrentGeometryProgram) {
+   if (ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY]) {
       const GLenum geom_mode =
-         ctx->Shader.CurrentGeometryProgram->Geom.InputType;
+         ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY]->Geom.InputType;
       switch (mode) {
       case GL_POINTS:
          valid_enum = (geom_mode == GL_POINTS);
@@ -330,8 +330,8 @@ _mesa_valid_prim_mode(struct gl_context *ctx, GLenum mode, const char *name)
    if (_mesa_is_xfb_active_and_unpaused(ctx)) {
       GLboolean pass = GL_TRUE;
 
-      if(ctx->Shader.CurrentGeometryProgram) {
-         switch (ctx->Shader.CurrentGeometryProgram->Geom.OutputType) {
+      if(ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY]) {
+         switch (ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY]->Geom.OutputType) {
          case GL_POINTS:
             pass = ctx->TransformFeedback.Mode == GL_POINTS;
             break;
index 807812955d184c1ea47e03e55abe8b477d0ebd28..28ce6a1bc5cd67e257ab867dc54cc2c522d1cc81 100644 (file)
@@ -1765,10 +1765,10 @@ _mesa_valid_to_render(struct gl_context *ctx, const char *where)
    if (ctx->NewState)
       _mesa_update_state(ctx);
 
-   if (ctx->Shader.CurrentVertexProgram) {
+   if (ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX]) {
       vert_from_glsl_shader = true;
 
-      if (!ctx->Shader.CurrentVertexProgram->LinkStatus) {
+      if (!ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX]->LinkStatus) {
          _mesa_error(ctx, GL_INVALID_OPERATION,
                      "%s(shader not linked)", where);
          return GL_FALSE;
@@ -1777,19 +1777,19 @@ _mesa_valid_to_render(struct gl_context *ctx, const char *where)
       {
          char errMsg[100];
          if (!_mesa_validate_shader_program(ctx,
-                                           ctx->Shader.CurrentVertexProgram,
+                                           ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX],
                                             errMsg)) {
             _mesa_warning(ctx, "Shader program %u is invalid: %s",
-                          ctx->Shader.CurrentVertexProgram->Name, errMsg);
+                          ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX]->Name, errMsg);
          }
       }
 #endif
    }
 
-   if (ctx->Shader.CurrentGeometryProgram) {
+   if (ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY]) {
       geom_from_glsl_shader = true;
 
-      if (!ctx->Shader.CurrentGeometryProgram->LinkStatus) {
+      if (!ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY]->LinkStatus) {
          _mesa_error(ctx, GL_INVALID_OPERATION,
                      "%s(shader not linked)", where);
          return GL_FALSE;
@@ -1798,19 +1798,19 @@ _mesa_valid_to_render(struct gl_context *ctx, const char *where)
       {
          char errMsg[100];
          if (!_mesa_validate_shader_program(ctx,
-                                           ctx->Shader.CurrentGeometryProgram,
+                                           ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY],
                                             errMsg)) {
             _mesa_warning(ctx, "Shader program %u is invalid: %s",
-                          ctx->Shader.CurrentGeometryProgram->Name, errMsg);
+                          ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY]->Name, errMsg);
          }
       }
 #endif
    }
 
-   if (ctx->Shader.CurrentFragmentProgram) {
+   if (ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT]) {
       frag_from_glsl_shader = true;
 
-      if (!ctx->Shader.CurrentFragmentProgram->LinkStatus) {
+      if (!ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT]->LinkStatus) {
          _mesa_error(ctx, GL_INVALID_OPERATION,
                      "%s(shader not linked)", where);
          return GL_FALSE;
@@ -1819,10 +1819,10 @@ _mesa_valid_to_render(struct gl_context *ctx, const char *where)
       {
          char errMsg[100];
          if (!_mesa_validate_shader_program(ctx,
-                                           ctx->Shader.CurrentFragmentProgram,
+                                           ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT],
                                             errMsg)) {
             _mesa_warning(ctx, "Shader program %u is invalid: %s",
-                          ctx->Shader.CurrentFragmentProgram->Name, errMsg);
+                          ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT]->Name, errMsg);
          }
       }
 #endif
@@ -1875,9 +1875,9 @@ _mesa_valid_to_render(struct gl_context *ctx, const char *where)
       struct gl_shader_program *shProg[MESA_SHADER_STAGES];
       gl_shader_stage i;
 
-      shProg[MESA_SHADER_VERTEX] = ctx->Shader.CurrentVertexProgram;
-      shProg[MESA_SHADER_GEOMETRY] = ctx->Shader.CurrentGeometryProgram;
-      shProg[MESA_SHADER_FRAGMENT] = ctx->Shader.CurrentFragmentProgram;
+      shProg[MESA_SHADER_VERTEX] = ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX];
+      shProg[MESA_SHADER_GEOMETRY] = ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY];
+      shProg[MESA_SHADER_FRAGMENT] = ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT];
 
       for (i = 0; i < MESA_SHADER_STAGES; i++) {
         if (shProg[i] == NULL || shProg[i]->_Used
index 8523edf41b65bc5a939e359b093d39084ead9055..cad67aa8513ff016b174a118118137da1a5e48be 100644 (file)
@@ -317,9 +317,9 @@ static GLbitfield get_fp_input_mask( struct gl_context *ctx )
 {
    /* _NEW_PROGRAM */
    const GLboolean vertexShader =
-      (ctx->Shader.CurrentVertexProgram &&
-       ctx->Shader.CurrentVertexProgram->LinkStatus &&
-       ctx->Shader.CurrentVertexProgram->_LinkedShaders[MESA_SHADER_VERTEX]);
+      (ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX] &&
+       ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX]->LinkStatus &&
+       ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX]->_LinkedShaders[MESA_SHADER_VERTEX]);
    const GLboolean vertexProgram = ctx->VertexProgram._Enabled;
    GLbitfield fp_inputs = 0x0;
 
@@ -383,7 +383,7 @@ static GLbitfield get_fp_input_mask( struct gl_context *ctx )
        * validation (see additional comments in state.c).
        */
       if (vertexShader)
-         vprog = ctx->Shader.CurrentVertexProgram->_LinkedShaders[MESA_SHADER_VERTEX]->Program;
+         vprog = ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX]->_LinkedShaders[MESA_SHADER_VERTEX]->Program;
       else
          vprog = &ctx->VertexProgram.Current->Base;
 
index c396609203dd2af3bea16b4e0c31a33343ebbc75..3dd967884c4edda16ff5f3656c5bdb0133cf2b45 100644 (file)
@@ -1815,7 +1815,8 @@ struct gl_transform_feedback_object
 
    /**
     * The shader program active when BeginTransformFeedback() was called.
-    * When active and unpaused, this equals ctx->Shader.CurrentVertexProgram.
+    * When active and unpaused, this equals
+    * ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX].
     */
    struct gl_shader_program *shader_program;
 
@@ -2714,9 +2715,7 @@ struct gl_shader_state
     * GL_EXT_separate_shader_objects is not supported, each of these must point
     * to \c NULL or to the same program.
     */
-   struct gl_shader_program *CurrentVertexProgram;
-   struct gl_shader_program *CurrentGeometryProgram;
-   struct gl_shader_program *CurrentFragmentProgram;
+   struct gl_shader_program *CurrentProgram[MESA_SHADER_STAGES];
 
    struct gl_shader_program *_CurrentFragmentProgram;
 
index 2ab0a0cfde2633cc8a4f6e193b2b655771144767..d57748c93adfcfc930936a1cbf6529166f7566b6 100644 (file)
@@ -130,10 +130,10 @@ _mesa_init_shader_state(struct gl_context *ctx)
 void
 _mesa_free_shader_state(struct gl_context *ctx)
 {
-   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentVertexProgram, NULL);
-   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentGeometryProgram,
+   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX], NULL);
+   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY],
                                  NULL);
-   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentFragmentProgram,
+   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT],
                                  NULL);
    _mesa_reference_shader_program(ctx, &ctx->Shader._CurrentFragmentProgram,
                                  NULL);
@@ -949,21 +949,21 @@ use_shader_program(struct gl_context *ctx, GLenum type,
 
    switch (type) {
    case GL_VERTEX_SHADER:
-      target = &ctx->Shader.CurrentVertexProgram;
+      target = &ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX];
       if ((shProg == NULL)
          || (shProg->_LinkedShaders[MESA_SHADER_VERTEX] == NULL)) {
         shProg = NULL;
       }
       break;
    case GL_GEOMETRY_SHADER_ARB:
-      target = &ctx->Shader.CurrentGeometryProgram;
+      target = &ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY];
       if ((shProg == NULL)
          || (shProg->_LinkedShaders[MESA_SHADER_GEOMETRY] == NULL)) {
         shProg = NULL;
       }
       break;
    case GL_FRAGMENT_SHADER:
-      target = &ctx->Shader.CurrentFragmentProgram;
+      target = &ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT];
       if ((shProg == NULL)
          || (shProg->_LinkedShaders[MESA_SHADER_FRAGMENT] == NULL)) {
         shProg = NULL;
index 87f6553a5f9c6a60b7123440de69b78283dd3d2d..bde548f68d8957133582b6bc81d6e2360c140047 100644 (file)
@@ -94,9 +94,9 @@ update_program_enables(struct gl_context *ctx)
 static GLbitfield
 update_program(struct gl_context *ctx)
 {
-   const struct gl_shader_program *vsProg = ctx->Shader.CurrentVertexProgram;
-   const struct gl_shader_program *gsProg = ctx->Shader.CurrentGeometryProgram;
-   struct gl_shader_program *fsProg = ctx->Shader.CurrentFragmentProgram;
+   const struct gl_shader_program *vsProg = ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX];
+   const struct gl_shader_program *gsProg = ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY];
+   struct gl_shader_program *fsProg = ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT];
    const struct gl_vertex_program *prevVP = ctx->VertexProgram._Current;
    const struct gl_fragment_program *prevFP = ctx->FragmentProgram._Current;
    const struct gl_geometry_program *prevGP = ctx->GeometryProgram._Current;
@@ -307,7 +307,7 @@ update_multisample(struct gl_context *ctx)
 static void
 update_twoside(struct gl_context *ctx)
 {
-   if (ctx->Shader.CurrentVertexProgram ||
+   if (ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX] ||
        ctx->VertexProgram._Enabled) {
       ctx->VertexProgram._TwoSideEnabled = ctx->VertexProgram.TwoSideEnabled;
    } else {
index 7720965a8c85d921d4a74b726245f7e96b660925..b6da76d4213ac5f95daea56ac9c6a51421c36dab 100644 (file)
@@ -532,19 +532,19 @@ update_texture_state( struct gl_context *ctx )
    struct gl_program *gprog = NULL;
    GLbitfield enabledFragUnits = 0x0;
 
-   if (ctx->Shader.CurrentVertexProgram &&
-       ctx->Shader.CurrentVertexProgram->LinkStatus) {
-      vprog = ctx->Shader.CurrentVertexProgram->_LinkedShaders[MESA_SHADER_VERTEX]->Program;
+   if (ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX] &&
+       ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX]->LinkStatus) {
+      vprog = ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX]->_LinkedShaders[MESA_SHADER_VERTEX]->Program;
    }
 
-   if (ctx->Shader.CurrentGeometryProgram &&
-       ctx->Shader.CurrentGeometryProgram->LinkStatus) {
-      gprog = ctx->Shader.CurrentGeometryProgram->_LinkedShaders[MESA_SHADER_GEOMETRY]->Program;
+   if (ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY] &&
+       ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY]->LinkStatus) {
+      gprog = ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY]->_LinkedShaders[MESA_SHADER_GEOMETRY]->Program;
    }
 
-   if (ctx->Shader.CurrentFragmentProgram &&
-       ctx->Shader.CurrentFragmentProgram->LinkStatus) {
-      fprog = ctx->Shader.CurrentFragmentProgram->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program;
+   if (ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT] &&
+       ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT]->LinkStatus) {
+      fprog = ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT]->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program;
    }
    else if (ctx->FragmentProgram._Enabled) {
       fprog = &ctx->FragmentProgram.Current->Base;
index 76d213b16aaf4f2984a932154bd057d805c8b99f..9eaa698ab954a1252955e80060c40c650d40e208 100644 (file)
@@ -387,13 +387,13 @@ _mesa_BeginTransformFeedback(GLenum mode)
 
    obj = ctx->TransformFeedback.CurrentObject;
 
-   if (ctx->Shader.CurrentVertexProgram == NULL) {
+   if (ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX] == NULL) {
       _mesa_error(ctx, GL_INVALID_OPERATION,
                   "glBeginTransformFeedback(no program active)");
       return;
    }
 
-   info = &ctx->Shader.CurrentVertexProgram->LinkedTransformFeedback;
+   info = &ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX]->LinkedTransformFeedback;
 
    if (info->NumOutputs == 0) {
       _mesa_error(ctx, GL_INVALID_OPERATION,
@@ -451,7 +451,7 @@ _mesa_BeginTransformFeedback(GLenum mode)
       obj->GlesRemainingPrims = max_vertices / vertices_per_prim;
    }
 
-   obj->shader_program = ctx->Shader.CurrentVertexProgram;
+   obj->shader_program = ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX];
 
    assert(ctx->Driver.BeginTransformFeedback);
    ctx->Driver.BeginTransformFeedback(ctx, mode, obj);
@@ -993,7 +993,7 @@ _mesa_ResumeTransformFeedback(void)
     *  the program object being used by the current transform feedback object
     *  is not active."
     */
-   if (obj->shader_program != ctx->Shader.CurrentVertexProgram) {
+   if (obj->shader_program != ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX]) {
       _mesa_error(ctx, GL_INVALID_OPERATION,
                   "glResumeTransformFeedback(wrong vertex program bound)");
       return;
index 700899934d8826176d2ca852762a848331cbecbb..274b36a624e18674c47cacbdaa990655d32f75dd 100644 (file)
@@ -52,7 +52,7 @@ static void update_clip( struct st_context *st )
    /* if we have a vertex shader that writes clip vertex we need to pass
       the pre-projection transformed coordinates into the driver. */
    if (st->vp) {
-      if (ctx->Shader.CurrentVertexProgram)
+      if (ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX])
          use_eye = TRUE;
    }
 
index 14cdfc6f95ddee6b4728af05432a41a055571799..c710b7465503e5ea2ab2da4d51fad753a40a6ee8 100644 (file)
@@ -218,7 +218,7 @@ static void st_bind_ubos(struct st_context *st,
 
 static void bind_vs_ubos(struct st_context *st)
 {
-   struct gl_shader_program *prog = st->ctx->Shader.CurrentVertexProgram;
+   struct gl_shader_program *prog = st->ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX];
 
    if (!prog)
       return;
@@ -237,7 +237,7 @@ const struct st_tracked_state st_bind_vs_ubos = {
 
 static void bind_fs_ubos(struct st_context *st)
 {
-   struct gl_shader_program *prog = st->ctx->Shader.CurrentFragmentProgram;
+   struct gl_shader_program *prog = st->ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT];
 
    if (!prog)
       return;
@@ -256,7 +256,7 @@ const struct st_tracked_state st_bind_fs_ubos = {
 
 static void bind_gs_ubos(struct st_context *st)
 {
-   struct gl_shader_program *prog = st->ctx->Shader.CurrentGeometryProgram;
+   struct gl_shader_program *prog = st->ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY];
 
    if (!prog)
       return;
index 4e79511d606da34c6b51dc641cd4e96c392c97cc..97f2130773dcd8df52a47c2c66cea86d3fb9306d 100644 (file)
@@ -1364,7 +1364,7 @@ blit_copy_pixels(struct gl_context *ctx, GLint srcx, GLint srcy,
        !ctx->Stencil.Enabled &&
        !ctx->FragmentProgram.Enabled &&
        !ctx->VertexProgram.Enabled &&
-       !ctx->Shader.CurrentFragmentProgram &&
+       !ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT] &&
        ctx->DrawBuffer->_NumColorDrawBuffers == 1 &&
        !ctx->Query.CondRenderQuery &&
        !ctx->Query.CurrentOcclusionObject) {
index 46257e0f5f67c7ae7903760987d099a90032c69c..6a7a4efd6e1784a7cdb3120de6c141ec97a89dd0 100644 (file)
@@ -132,9 +132,9 @@ static void
 check_uniforms(struct gl_context *ctx)
 {
    struct gl_shader_program *shProg[3] = {
-      ctx->Shader.CurrentVertexProgram,
-      ctx->Shader.CurrentGeometryProgram,
-      ctx->Shader.CurrentFragmentProgram,
+      ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX],
+      ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY],
+      ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT],
    };
    unsigned j;
 
index 2d6d430990a073896ade3d21bba80e731738d2c9..1a00c314dda11fdba2b5f07a47ef48934f4e16af 100644 (file)
@@ -1196,9 +1196,9 @@ void
 st_print_shaders(struct gl_context *ctx)
 {
    struct gl_shader_program *shProg[3] = {
-      ctx->Shader.CurrentVertexProgram,
-      ctx->Shader.CurrentGeometryProgram,
-      ctx->Shader.CurrentFragmentProgram,
+      ctx->Shader.CurrentProgram[MESA_SHADER_VERTEX],
+      ctx->Shader.CurrentProgram[MESA_SHADER_GEOMETRY],
+      ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT],
    };
    unsigned j;
 
index 4e9ac394e2c04cd185031214d800a6426486d4c7..fa45fa97ade74b47b3ff5a635d7a8fada081bc47 100644 (file)
@@ -182,7 +182,7 @@ init_machine(struct gl_context *ctx, struct gl_program_machine *machine,
    machine->Samplers = program->Base.SamplerUnits;
 
    /* if running a GLSL program (not ARB_fragment_program) */
-   if (ctx->Shader.CurrentFragmentProgram) {
+   if (ctx->Shader.CurrentProgram[MESA_SHADER_FRAGMENT]) {
       /* Store front/back facing value */
       machine->Attribs[VARYING_SLOT_FACE][col][0] = 1.0F - span->facing;
    }