Changeset 23571 in vbox for trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/arb_program_shader.c

Timestamp:

Oct 6, 2009 6:07:06 AM (15 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

53228

Message:

crOpenGL: update to wine 1.1.30

File:

• trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/arb_program_shader.c (modified) (41 diffs)

trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/arb_program_shader.c

@@ -101 +101 @@
 /* ARB_program_shader private data */
 
-struct loop_control
-{
-    unsigned int count;
-    unsigned int start;
-    int step;
-};
-
 struct control_frame
 {
@@ -125 +118 @@
         unsigned int                ifc_no;
     };
-    struct loop_control             loop_control;
+    struct wined3d_shader_loop_control loop_control;
     BOOL                            had_else;
 };
@@ -142 +135 @@
 {
     struct ps_compile_args          super;
-    DWORD                           bools; /* WORD is enough, use DWORD for alignment */
+    WORD                            bools;
+    WORD                            clip;  /* only a boolean, use a WORD for alignment */
     unsigned char                   loop_ctrl[MAX_CONST_I][3];
 };
@@ -282 +276 @@
  ********************************************************/
 
-/** 
- * Loads floating point constants into the currently set ARB_vertex/fragment_program.
+/* Loads floating point constants into the currently set ARB_vertex/fragment_program.
  * When constant_list == NULL, it will load all the constants.
- *  
+ *
  * @target_type should be either GL_VERTEX_PROGRAM_ARB (for vertex shaders)
  *  or GL_FRAGMENT_PROGRAM_ARB (for pixel shaders)
@@ -294 +287 @@
 {
     local_constant* lconst;
-    DWORD i = 0, j;
+    DWORD i, j;
     unsigned int ret;
 
-    if (TRACE_ON(d3d_shader)) {
+    if (TRACE_ON(d3d_constants))
+    {
         for(i = 0; i < max_constants; i++) {
             if(!dirty_consts[i]) continue;
@@ -305 +299 @@
         }
     }
+
+    i = 0;
+
     /* In 1.X pixel shaders constants are implicitly clamped in the range [-1;1] */
     if (target_type == GL_FRAGMENT_PROGRAM_ARB && This->baseShader.reg_maps.shader_version.major == 1)
@@ -546 +543 @@
 /**
  * Loads the app-supplied constants into the currently set ARB_[vertex/fragment]_programs.
- * 
- * We only support float constants in ARB at the moment, so don't 
+ *
+ * We only support float constants in ARB at the moment, so don't
  * worry about the Integers or Booleans
  */
@@ -632 +629 @@
     unsigned max_constantsF;
     const local_constant *lconst;
+    DWORD map;
 
     /* In pixel shaders, all private constants are program local, we don't need anything
@@ -675 +673 @@
     }
 
-    for(i = 0; i < This->baseShader.limits.temporary; i++) {
-        if (reg_maps->temporary[i])
-            shader_addline(buffer, "TEMP R%u;\n", i);
-    }
-
-    for (i = 0; i < This->baseShader.limits.address; i++) {
-        if (reg_maps->address[i])
-            shader_addline(buffer, "ADDRESS A%d;\n", i);
-    }
-
-    if(pshader && reg_maps->shader_version.major == 1 && reg_maps->shader_version.minor <= 3) {
-        for(i = 0; i < This->baseShader.limits.texcoord; i++) {
-            if (reg_maps->texcoord[i] && pshader)
-                shader_addline(buffer,"TEMP T%u;\n", i);
+    for (i = 0, map = reg_maps->temporary; map; map >>= 1, ++i)
+    {
+        if (map & 1) shader_addline(buffer, "TEMP R%u;\n", i);
+    }
+
+    for (i = 0, map = reg_maps->address; map; map >>= 1, ++i)
+    {
+        if (map & 1) shader_addline(buffer, "ADDRESS A%u;\n", i);
+    }
+
+    if (pshader && reg_maps->shader_version.major == 1 && reg_maps->shader_version.minor <= 3)
+    {
+        for (i = 0, map = reg_maps->texcoord; map; map >>= 1, ++i)
+        {
+            if (map & 1) shader_addline(buffer, "TEMP T%u;\n", i);
         }
     }
@@ -1262 +1261 @@
     if (flags & TEX_DERIV)
     {
-        if(flags & TEX_PROJ) FIXME("Projected texture sampling with custom derivates\n");
-        if(flags & TEX_BIAS) FIXME("Biased texture sampling with custom derivates\n");
+        if(flags & TEX_PROJ) FIXME("Projected texture sampling with custom derivatives\n");
+        if(flags & TEX_BIAS) FIXME("Biased texture sampling with custom derivatives\n");
         shader_addline(buffer, "TXD%s %s, %s, %s, %s, texture[%u], %s;\n", mod, dst_str, coord_reg,
                        dsx, dsy,sampler_idx, tex_type);
@@ -2038 +2037 @@
     char dst_str[50];
     char src0_name[50];
-    char dst_reg[8];
+    char dst_reg[50];
     BOOL is_color;
 
@@ -2081 +2080 @@
     char src0_name[50];
     char src1_name[50];
-    char dst_reg[8];
+    char dst_reg[50];
     BOOL is_color;
 
@@ -3010 +3009 @@
 {
     GLuint program_id = 0;
+    GLint pos;
+
     const char *blt_vprogram =
         "!!ARBvp1.0\n"
@@ -3020 +3021 @@
     GL_EXTCALL(glGenProgramsARB(1, &program_id));
     GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, program_id));
-    GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(blt_vprogram), blt_vprogram));
-
-    if (glGetError() == GL_INVALID_OPERATION) {
-        GLint pos;
-        glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
+    GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
+            strlen(blt_vprogram), blt_vprogram));
+    checkGLcall("glProgramStringARB()");
+
+    glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
+    if (pos != -1)
+    {
         FIXME("Vertex program error at position %d: %s\n", pos,
             debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
     }
+    else
+    {
+        GLint native;
+
+        GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB, &native));
+        checkGLcall("glGetProgramivARB()");
+        if (!native) WARN("Program exceeds native resource limits.\n");
+    }
 
     return program_id;
@@ -3036 +3047 @@
 {
     GLuint program_id = 0;
+    GLint pos;
+
     static const char * const blt_fprograms[tex_type_count] =
     {
@@ -3070 +3083 @@
     GL_EXTCALL(glGenProgramsARB(1, &program_id));
     GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, program_id));
-    GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(blt_fprograms[tex_type]), blt_fprograms[tex_type]));
-
-    if (glGetError() == GL_INVALID_OPERATION) {
-        GLint pos;
-        glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
+    GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
+            strlen(blt_fprograms[tex_type]), blt_fprograms[tex_type]));
+    checkGLcall("glProgramStringARB()");
+
+    glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
+    if (pos != -1)
+    {
         FIXME("Fragment program error at position %d: %s\n", pos,
             debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
+    }
+    else
+    {
+        GLint native;
+
+        GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB, &native));
+        checkGLcall("glGetProgramivARB()");
+        if (!native) WARN("Program exceeds native resource limits.\n");
     }
 
@@ -3229 +3252 @@
     BOOL dcl_tmp = args->super.srgb_correction, dcl_td = FALSE;
     BOOL want_nv_prog = FALSE;
-    struct arb_pshader_private *shader_priv = This->backend_priv;
+    struct arb_pshader_private *shader_priv = This->baseShader.backend_data;
+    GLint errPos;
+    DWORD map;
 
     char srgbtmp[4][4];
     unsigned int i, found = 0;
 
-    for(i = 0; i < This->baseShader.limits.temporary; i++) {
-
-        /* Don't overwrite the color source */
-        if(This->color0_mov && i == This->color0_reg) continue;
-        else if(reg_maps->shader_version.major < 2 && i == 0) continue;
-
-        if(reg_maps->temporary[i]) {
-            sprintf(srgbtmp[found], "R%u", i);
-            found++;
-            if(found == 4) break;
-        }
+    for (i = 0, map = reg_maps->temporary; map; map >>= 1, ++i)
+    {
+        if (!(map & 1)
+                || (This->color0_mov && i == This->color0_reg)
+                || (reg_maps->shader_version.major < 2 && i == 0))
+            continue;
+
+        sprintf(srgbtmp[found], "R%u", i);
+        ++found;
+        if (found == 4) break;
     }
 
@@ -3375 +3399 @@
             lconst_map, NULL, &priv_ctx);
 
-    for(i = 0; i < (sizeof(reg_maps->bumpmat) / sizeof(reg_maps->bumpmat[0])); i++) {
-        if(!reg_maps->bumpmat[i]) continue;
+    for (i = 0, map = reg_maps->bumpmat; map; map >>= 1, ++i)
+    {
+        if (!(map & 1)) continue;
 
         cur = compiled->numbumpenvmatconsts;
@@ -3398 +3423 @@
         compiled->numbumpenvmatconsts = cur + 1;
 
-        if(!reg_maps->luminanceparams[i]) continue;
+        if (!(reg_maps->luminanceparams & (1 << i))) continue;
 
         compiled->luminanceconst[cur].const_num = next_local++;
@@ -3486 +3511 @@
     }
 
-    if(shader_priv->clipplane_emulation)
-    {
-        shader_addline(buffer, "KIL fragment.texcoord[%u];\n", shader_priv->clipplane_emulation - 1);
+    if (shader_priv->clipplane_emulation != ~0U && args->clip)
+    {
+        shader_addline(buffer, "KIL fragment.texcoord[%u];\n", shader_priv->clipplane_emulation);
     }
 
@@ -3512 +3537 @@
     GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
                buffer->bsize, buffer->buffer));
-
-    if (glGetError() == GL_INVALID_OPERATION) {
-        GLint errPos;
-        glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errPos);
+    checkGLcall("glProgramStringARB()");
+
+    glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errPos);
+    if (errPos != -1)
+    {
         FIXME("HW PixelShader Error at position %d: %s\n",
               errPos, debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
         retval = 0;
+    }
+    else
+    {
+        GLint native;
+
+        GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB, &native));
+        checkGLcall("glGetProgramivARB()");
+        if (!native) WARN("Program exceeds native resource limits.\n");
     }
 
@@ -3796 +3830 @@
     struct shader_arb_ctx_priv priv_ctx;
     unsigned int i;
+    GLint errPos;
 
     memset(&priv_ctx, 0, sizeof(priv_ctx));
@@ -3905 +3940 @@
     GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
                buffer->bsize, buffer->buffer));
-
-    if (glGetError() == GL_INVALID_OPERATION) {
-        GLint errPos;
-        glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errPos);
+    checkGLcall("glProgramStringARB()");
+
+    glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errPos);
+    if (errPos != -1)
+    {
         FIXME("HW VertexShader Error at position %d: %s\n",
               errPos, debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
         ret = -1;
-    } else {
+    }
+    else
+    {
+        GLint native;
+
+        GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB, &native));
+        checkGLcall("glGetProgramivARB()");
+        if (!native) WARN("Program exceeds native resource limits.\n");
+
         /* Load immediate constants */
         if(lconst_map) {
@@ -3924 +3968 @@
 
     return ret;
-}
-
-static void find_clip_texcoord(IWineD3DPixelShaderImpl *ps)
-{
-    struct arb_pshader_private *shader_priv = ps->backend_priv;
-    int i;
-    const struct wined3d_gl_info *gl_info = &((IWineD3DDeviceImpl *)ps->baseShader.device)->adapter->gl_info;
-
-    /* See if we can use fragment.texcoord[7] for clipplane emulation
-     *
-     * Don't do this if it is not supported, or fragment.texcoord[7] is used
-     */
-    if(ps->baseShader.reg_maps.shader_version.major < 3)
-    {
-        for(i = GL_LIMITS(texture_stages); i > 0; i--)
-        {
-            if(!ps->baseShader.reg_maps.texcoord[i - 1])
-            {
-                shader_priv->clipplane_emulation = i;
-                return;
-            }
-        }
-        WARN("Did not find a free clip reg(2.0)\n");
-    }
-    else
-    {
-        for(i = GL_LIMITS(texture_stages); i > 0; i--)
-        {
-            if(!(ps->baseShader.reg_maps.input_registers & (1 << (i - 1))))
-            {
-                shader_priv->clipplane_emulation = i;
-                return;
-            }
-        }
-        WARN("Did not find a free clip reg(3.0)\n");
-    }
 }
 
@@ -3972 +3980 @@
     GLuint ret;
 
-    if(!shader->backend_priv) {
+    if (!shader->baseShader.backend_data)
+    {
         IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) shader->baseShader.device;
+        const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
         struct shader_arb_priv *priv = device->shader_priv;
 
-        shader->backend_priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
-        shader_data = shader->backend_priv;
+        shader->baseShader.backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
+        shader_data = shader->baseShader.backend_data;
         shader_data->clamp_consts = shader->baseShader.reg_maps.shader_version.major == 1;
 
@@ -3986 +3996 @@
         TRACE("Shader got assigned input signature index %u\n", shader_data->input_signature_idx);
 
-        if(!device->vs_clipping) find_clip_texcoord(shader);
-    }
-    shader_data = shader->backend_priv;
+        if (!device->vs_clipping)
+            shader_data->clipplane_emulation = shader_find_free_input_register(&shader->baseShader.reg_maps,
+                    GL_LIMITS(texture_stages) - 1);
+        else
+            shader_data->clipplane_emulation = ~0U;
+    }
+    shader_data = shader->baseShader.backend_data;
 
     /* Usually we have very few GL shaders for each d3d shader(just 1 or maybe 2),
@@ -4062 +4076 @@
     const struct wined3d_gl_info *gl_info = &((IWineD3DDeviceImpl *)shader->baseShader.device)->adapter->gl_info;
 
-    if(!shader->backend_priv) {
-        shader->backend_priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
-    }
-    shader_data = shader->backend_priv;
+    if (!shader->baseShader.backend_data)
+    {
+        shader->baseShader.backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
+    }
+    shader_data = shader->baseShader.backend_data;
 
     /* Usually we have very few GL shaders for each d3d shader(just 1 or maybe 2),
@@ -4130 +4145 @@
     }
 
+    /* Only enable the clip plane emulation KIL if at least one clipplane is enabled. The KIL instruction
+     * is quite expensive because it forces the driver to disable early Z discards. It is cheaper to
+     * duplicate the shader than have a no-op KIL instruction in every shader
+     */
+    if((!((IWineD3DDeviceImpl *) shader->baseShader.device)->vs_clipping) && use_vs(stateblock) &&
+       stateblock->renderState[WINED3DRS_CLIPPING] && stateblock->renderState[WINED3DRS_CLIPPLANEENABLE])
+    {
+        args->clip = 1;
+    }
+    else
+    {
+        args->clip = 0;
+    }
+
     /* Skip if unused or local, or supported natively */
     int_skip = ~shader->baseShader.reg_maps.integer_constants | shader->baseShader.reg_maps.local_int_consts;
@@ -4168 +4197 @@
     {
         IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *) stateblock->pixelShader;
-        struct arb_pshader_private *shader_priv = ps->backend_priv;
+        struct arb_pshader_private *shader_priv = ps->baseShader.backend_data;
         args->ps_signature = shader_priv->input_signature_idx;
 
-        args->boolclip.clip_control[0] = shader_priv->clipplane_emulation;
+        args->boolclip.clip_control[0] = shader_priv->clipplane_emulation + 1;
     }
     else
@@ -4264 +4293 @@
          * a 1.x and newer shader, reload the first 8 constants
          */
-        if(priv->last_ps_const_clamped != ((struct arb_pshader_private *) ps->backend_priv)->clamp_consts)
-        {
-            priv->last_ps_const_clamped = ((struct arb_pshader_private *) ps->backend_priv)->clamp_consts;
+        if(priv->last_ps_const_clamped != ((struct arb_pshader_private *)ps->baseShader.backend_data)->clamp_consts)
+        {
+            priv->last_ps_const_clamped = ((struct arb_pshader_private *)ps->baseShader.backend_data)->clamp_consts;
             This->highest_dirty_ps_const = max(This->highest_dirty_ps_const, 8);
             for(i = 0; i < 8; i++)
@@ -4382 +4411 @@
     {
         IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *) iface;
-        struct arb_pshader_private *shader_data = This->backend_priv;
+        struct arb_pshader_private *shader_data = This->baseShader.backend_data;
         UINT i;
 
@@ -4397 +4426 @@
         HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders);
         HeapFree(GetProcessHeap(), 0, shader_data);
-        This->backend_priv = NULL;
+        This->baseShader.backend_data = NULL;
     } else {
         IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *) iface;
-        struct arb_vshader_private *shader_data = This->backend_priv;
+        struct arb_vshader_private *shader_data = This->baseShader.backend_data;
         UINT i;
 
@@ -4415 +4444 @@
         HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders);
         HeapFree(GetProcessHeap(), 0, shader_data);
-        This->backend_priv = NULL;
+        This->baseShader.backend_data = NULL;
     }
 }
@@ -4425 +4454 @@
 }
 
-struct wine_rb_functions sig_tree_functions =
+static const struct wine_rb_functions sig_tree_functions =
 {
     wined3d_rb_alloc,
@@ -4696 +4725 @@
 
 static void get_loop_control_const(const struct wined3d_shader_instruction *ins,
-        IWineD3DBaseShaderImpl *This, UINT idx, struct loop_control *loop_control)
+        IWineD3DBaseShaderImpl *This, UINT idx, struct wined3d_shader_loop_control *loop_control)
 {
     struct shader_arb_ctx_priv *priv = ins->ctx->backend_data;
@@ -5239 +5268 @@
     if (use_ps(stateblock))
     {
-        if(stage != 0 &&
-           ((IWineD3DPixelShaderImpl *) stateblock->pixelShader)->baseShader.reg_maps.bumpmat[stage]) {
+        if (stage != 0
+                && (((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.reg_maps.bumpmat & (1 << stage)))
+        {
             /* The pixel shader has to know the bump env matrix. Do a constants update if it isn't scheduled
              * anyway
@@ -5275 +5305 @@
     if (use_ps(stateblock))
     {
-        if(stage != 0 &&
-           ((IWineD3DPixelShaderImpl *) stateblock->pixelShader)->baseShader.reg_maps.luminanceparams[stage]) {
+        if (stage != 0
+                && (((IWineD3DPixelShaderImpl *)stateblock->pixelShader)->baseShader.reg_maps.luminanceparams & (1 << stage)))
+        {
             /* The pixel shader has to know the luminance offset. Do a constants update if it
              * isn't scheduled anyway
@@ -5530 +5561 @@
     BOOL op_equal;
     const char *final_combiner_src = "ret";
+    GLint pos;
 
     /* Find out which textures are read */
@@ -5763 +5795 @@
     GL_EXTCALL(glGenProgramsARB(1, &ret));
     GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, ret));
-    GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(buffer.buffer), buffer.buffer));
-
-    if (glGetError() == GL_INVALID_OPERATION) {
-        GLint pos;
-        glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
+    GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
+            strlen(buffer.buffer), buffer.buffer));
+    checkGLcall("glProgramStringARB()");
+
+    glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
+    if (pos != -1)
+    {
         FIXME("Fragment program error at position %d: %s\n", pos,
               debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
     }
+    else
+    {
+        GLint native;
+
+        GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB, &native));
+        checkGLcall("glGetProgramivARB()");
+        if (!native) WARN("Program exceeds native resource limits.\n");
+    }
+
     shader_buffer_free(&buffer);
     return ret;
@@ -6349 +6392 @@
     char luminance_component;
     struct arbfp_blit_priv *priv = device->blit_priv;
+    GLint pos;
 
     /* Shader header */
@@ -6451 +6495 @@
 
     ENTER_GL();
-    GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(buffer.buffer), buffer.buffer));
-
-    if (glGetError() == GL_INVALID_OPERATION) {
-        GLint pos;
-        glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
+    GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
+            strlen(buffer.buffer), buffer.buffer));
+    checkGLcall("glProgramStringARB()");
+
+    glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
+    if (pos != -1)
+    {
         FIXME("Fragment program error at position %d: %s\n", pos,
               debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
     }
+    else
+    {
+        GLint native;
+
+        GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB, &native));
+        checkGLcall("glGetProgramivARB()");
+        if (!native) WARN("Program exceeds native resource limits.\n");
+    }
+
     shader_buffer_free(&buffer);
     LEAVE_GL();