Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Mesa 3-D graphics library
  3.  *
  4.  * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
  5.  *
  6.  * Permission is hereby granted, free of charge, to any person obtaining a
  7.  * copy of this software and associated documentation files (the "Software"),
  8.  * to deal in the Software without restriction, including without limitation
  9.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10.  * and/or sell copies of the Software, and to permit persons to whom the
  11.  * Software is furnished to do so, subject to the following conditions:
  12.  *
  13.  * The above copyright notice and this permission notice shall be included
  14.  * in all copies or substantial portions of the Software.
  15.  *
  16.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19.  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20.  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21.  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22.  * OTHER DEALINGS IN THE SOFTWARE.
  23.  */
  24.  
  25. /**
  26.  * Meta operations.  Some GL operations can be expressed in terms of
  27.  * other GL operations.  For example, glBlitFramebuffer() can be done
  28.  * with texture mapping and glClear() can be done with polygon rendering.
  29.  *
  30.  * \author Brian Paul
  31.  */
  32.  
  33.  
  34. #include "main/glheader.h"
  35. #include "main/mtypes.h"
  36. #include "main/imports.h"
  37. #include "main/arbprogram.h"
  38. #include "main/arrayobj.h"
  39. #include "main/blend.h"
  40. #include "main/blit.h"
  41. #include "main/bufferobj.h"
  42. #include "main/buffers.h"
  43. #include "main/clear.h"
  44. #include "main/condrender.h"
  45. #include "main/depth.h"
  46. #include "main/enable.h"
  47. #include "main/fbobject.h"
  48. #include "main/feedback.h"
  49. #include "main/formats.h"
  50. #include "main/format_unpack.h"
  51. #include "main/glformats.h"
  52. #include "main/image.h"
  53. #include "main/macros.h"
  54. #include "main/matrix.h"
  55. #include "main/mipmap.h"
  56. #include "main/multisample.h"
  57. #include "main/objectlabel.h"
  58. #include "main/pipelineobj.h"
  59. #include "main/pixel.h"
  60. #include "main/pbo.h"
  61. #include "main/polygon.h"
  62. #include "main/queryobj.h"
  63. #include "main/readpix.h"
  64. #include "main/scissor.h"
  65. #include "main/shaderapi.h"
  66. #include "main/shaderobj.h"
  67. #include "main/state.h"
  68. #include "main/stencil.h"
  69. #include "main/texobj.h"
  70. #include "main/texenv.h"
  71. #include "main/texgetimage.h"
  72. #include "main/teximage.h"
  73. #include "main/texparam.h"
  74. #include "main/texstate.h"
  75. #include "main/texstore.h"
  76. #include "main/transformfeedback.h"
  77. #include "main/uniforms.h"
  78. #include "main/varray.h"
  79. #include "main/viewport.h"
  80. #include "main/samplerobj.h"
  81. #include "program/program.h"
  82. #include "swrast/swrast.h"
  83. #include "drivers/common/meta.h"
  84. #include "main/enums.h"
  85. #include "main/glformats.h"
  86. #include "util/ralloc.h"
  87.  
  88. /** Return offset in bytes of the field within a vertex struct */
  89. #define OFFSET(FIELD) ((void *) offsetof(struct vertex, FIELD))
  90.  
  91. static void
  92. meta_clear(struct gl_context *ctx, GLbitfield buffers, bool glsl);
  93.  
  94. static struct blit_shader *
  95. choose_blit_shader(GLenum target, struct blit_shader_table *table);
  96.  
  97. static void cleanup_temp_texture(struct temp_texture *tex);
  98. static void meta_glsl_clear_cleanup(struct clear_state *clear);
  99. static void meta_decompress_cleanup(struct decompress_state *decompress);
  100. static void meta_drawpix_cleanup(struct drawpix_state *drawpix);
  101.  
  102. void
  103. _mesa_meta_bind_fbo_image(GLenum fboTarget, GLenum attachment,
  104.                           struct gl_texture_image *texImage, GLuint layer)
  105. {
  106.    struct gl_texture_object *texObj = texImage->TexObject;
  107.    int level = texImage->Level;
  108.    GLenum texTarget = texObj->Target;
  109.  
  110.    switch (texTarget) {
  111.    case GL_TEXTURE_1D:
  112.       _mesa_FramebufferTexture1D(fboTarget,
  113.                                  attachment,
  114.                                  texTarget,
  115.                                  texObj->Name,
  116.                                  level);
  117.       break;
  118.    case GL_TEXTURE_1D_ARRAY:
  119.    case GL_TEXTURE_2D_ARRAY:
  120.    case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
  121.    case GL_TEXTURE_CUBE_MAP_ARRAY:
  122.    case GL_TEXTURE_3D:
  123.       _mesa_FramebufferTextureLayer(fboTarget,
  124.                                     attachment,
  125.                                     texObj->Name,
  126.                                     level,
  127.                                     layer);
  128.       break;
  129.    default: /* 2D / cube */
  130.       if (texTarget == GL_TEXTURE_CUBE_MAP)
  131.          texTarget = GL_TEXTURE_CUBE_MAP_POSITIVE_X + texImage->Face;
  132.  
  133.       _mesa_FramebufferTexture2D(fboTarget,
  134.                                  attachment,
  135.                                  texTarget,
  136.                                  texObj->Name,
  137.                                  level);
  138.    }
  139. }
  140.  
  141. GLuint
  142. _mesa_meta_compile_shader_with_debug(struct gl_context *ctx, GLenum target,
  143.                                      const GLcharARB *source)
  144. {
  145.    GLuint shader;
  146.    GLint ok, size;
  147.    GLchar *info;
  148.  
  149.    shader = _mesa_CreateShader(target);
  150.    _mesa_ShaderSource(shader, 1, &source, NULL);
  151.    _mesa_CompileShader(shader);
  152.  
  153.    _mesa_GetShaderiv(shader, GL_COMPILE_STATUS, &ok);
  154.    if (ok)
  155.       return shader;
  156.  
  157.    _mesa_GetShaderiv(shader, GL_INFO_LOG_LENGTH, &size);
  158.    if (size == 0) {
  159.       _mesa_DeleteShader(shader);
  160.       return 0;
  161.    }
  162.  
  163.    info = malloc(size);
  164.    if (!info) {
  165.       _mesa_DeleteShader(shader);
  166.       return 0;
  167.    }
  168.  
  169.    _mesa_GetShaderInfoLog(shader, size, NULL, info);
  170.    _mesa_problem(ctx,
  171.                  "meta program compile failed:\n%s\n"
  172.                  "source:\n%s\n",
  173.                  info, source);
  174.  
  175.    free(info);
  176.    _mesa_DeleteShader(shader);
  177.  
  178.    return 0;
  179. }
  180.  
  181. GLuint
  182. _mesa_meta_link_program_with_debug(struct gl_context *ctx, GLuint program)
  183. {
  184.    GLint ok, size;
  185.    GLchar *info;
  186.  
  187.    _mesa_LinkProgram(program);
  188.  
  189.    _mesa_GetProgramiv(program, GL_LINK_STATUS, &ok);
  190.    if (ok)
  191.       return program;
  192.  
  193.    _mesa_GetProgramiv(program, GL_INFO_LOG_LENGTH, &size);
  194.    if (size == 0)
  195.       return 0;
  196.  
  197.    info = malloc(size);
  198.    if (!info)
  199.       return 0;
  200.  
  201.    _mesa_GetProgramInfoLog(program, size, NULL, info);
  202.    _mesa_problem(ctx, "meta program link failed:\n%s", info);
  203.  
  204.    free(info);
  205.  
  206.    return 0;
  207. }
  208.  
  209. void
  210. _mesa_meta_compile_and_link_program(struct gl_context *ctx,
  211.                                     const char *vs_source,
  212.                                     const char *fs_source,
  213.                                     const char *name,
  214.                                     GLuint *program)
  215. {
  216.    GLuint vs = _mesa_meta_compile_shader_with_debug(ctx, GL_VERTEX_SHADER,
  217.                                                     vs_source);
  218.    GLuint fs = _mesa_meta_compile_shader_with_debug(ctx, GL_FRAGMENT_SHADER,
  219.                                                     fs_source);
  220.  
  221.    *program = _mesa_CreateProgram();
  222.    _mesa_ObjectLabel(GL_PROGRAM, *program, -1, name);
  223.    _mesa_AttachShader(*program, fs);
  224.    _mesa_DeleteShader(fs);
  225.    _mesa_AttachShader(*program, vs);
  226.    _mesa_DeleteShader(vs);
  227.    _mesa_BindAttribLocation(*program, 0, "position");
  228.    _mesa_BindAttribLocation(*program, 1, "texcoords");
  229.    _mesa_meta_link_program_with_debug(ctx, *program);
  230.  
  231.    _mesa_UseProgram(*program);
  232. }
  233.  
  234. /**
  235.  * Generate a generic shader to blit from a texture to a framebuffer
  236.  *
  237.  * \param ctx       Current GL context
  238.  * \param texTarget Texture target that will be the source of the blit
  239.  *
  240.  * \returns a handle to a shader program on success or zero on failure.
  241.  */
  242. void
  243. _mesa_meta_setup_blit_shader(struct gl_context *ctx,
  244.                              GLenum target,
  245.                              bool do_depth,
  246.                              struct blit_shader_table *table)
  247. {
  248.    char *vs_source, *fs_source;
  249.    struct blit_shader *shader = choose_blit_shader(target, table);
  250.    const char *vs_input, *vs_output, *fs_input, *vs_preprocess, *fs_preprocess;
  251.    void *mem_ctx;
  252.  
  253.    if (ctx->Const.GLSLVersion < 130) {
  254.       vs_preprocess = "";
  255.       vs_input = "attribute";
  256.       vs_output = "varying";
  257.       fs_preprocess = "#extension GL_EXT_texture_array : enable";
  258.       fs_input = "varying";
  259.    } else {
  260.       vs_preprocess = "#version 130";
  261.       vs_input = "in";
  262.       vs_output = "out";
  263.       fs_preprocess = "#version 130";
  264.       fs_input = "in";
  265.       shader->func = "texture";
  266.    }
  267.  
  268.    assert(shader != NULL);
  269.  
  270.    if (shader->shader_prog != 0) {
  271.       _mesa_UseProgram(shader->shader_prog);
  272.       return;
  273.    }
  274.  
  275.    mem_ctx = ralloc_context(NULL);
  276.  
  277.    vs_source = ralloc_asprintf(mem_ctx,
  278.                 "%s\n"
  279.                 "%s vec2 position;\n"
  280.                 "%s vec4 textureCoords;\n"
  281.                 "%s vec4 texCoords;\n"
  282.                 "void main()\n"
  283.                 "{\n"
  284.                 "   texCoords = textureCoords;\n"
  285.                 "   gl_Position = vec4(position, 0.0, 1.0);\n"
  286.                 "}\n",
  287.                 vs_preprocess, vs_input, vs_input, vs_output);
  288.  
  289.    fs_source = ralloc_asprintf(mem_ctx,
  290.                 "%s\n"
  291.                 "#extension GL_ARB_texture_cube_map_array: enable\n"
  292.                 "uniform %s texSampler;\n"
  293.                 "%s vec4 texCoords;\n"
  294.                 "void main()\n"
  295.                 "{\n"
  296.                 "   gl_FragColor = %s(texSampler, %s);\n"
  297.                 "%s"
  298.                 "}\n",
  299.                 fs_preprocess, shader->type, fs_input,
  300.                 shader->func, shader->texcoords,
  301.                 do_depth ?  "   gl_FragDepth = gl_FragColor.x;\n" : "");
  302.  
  303.    _mesa_meta_compile_and_link_program(ctx, vs_source, fs_source,
  304.                                        ralloc_asprintf(mem_ctx, "%s blit",
  305.                                                        shader->type),
  306.                                        &shader->shader_prog);
  307.    ralloc_free(mem_ctx);
  308. }
  309.  
  310. /**
  311.  * Configure vertex buffer and vertex array objects for tests
  312.  *
  313.  * Regardless of whether a new VAO and new VBO are created, the objects
  314.  * referenced by \c VAO and \c VBO will be bound into the GL state vector
  315.  * when this function terminates.
  316.  *
  317.  * \param VAO       Storage for vertex array object handle.  If 0, a new VAO
  318.  *                  will be created.
  319.  * \param VBO       Storage for vertex buffer object handle.  If 0, a new VBO
  320.  *                  will be created.  The new VBO will have storage for 4
  321.  *                  \c vertex structures.
  322.  * \param use_generic_attributes  Should generic attributes 0 and 1 be used,
  323.  *                  or should traditional, fixed-function color and texture
  324.  *                  coordinate be used?
  325.  * \param vertex_size  Number of components for attribute 0 / vertex.
  326.  * \param texcoord_size  Number of components for attribute 1 / texture
  327.  *                  coordinate.  If this is 0, attribute 1 will not be set or
  328.  *                  enabled.
  329.  * \param color_size  Number of components for attribute 1 / primary color.
  330.  *                  If this is 0, attribute 1 will not be set or enabled.
  331.  *
  332.  * \note If \c use_generic_attributes is \c true, \c color_size must be zero.
  333.  * Use \c texcoord_size instead.
  334.  */
  335. void
  336. _mesa_meta_setup_vertex_objects(GLuint *VAO, GLuint *VBO,
  337.                                 bool use_generic_attributes,
  338.                                 unsigned vertex_size, unsigned texcoord_size,
  339.                                 unsigned color_size)
  340. {
  341.    if (*VAO == 0) {
  342.       assert(*VBO == 0);
  343.  
  344.       /* create vertex array object */
  345.       _mesa_GenVertexArrays(1, VAO);
  346.       _mesa_BindVertexArray(*VAO);
  347.  
  348.       /* create vertex array buffer */
  349.       _mesa_GenBuffers(1, VBO);
  350.       _mesa_BindBuffer(GL_ARRAY_BUFFER, *VBO);
  351.       _mesa_BufferData(GL_ARRAY_BUFFER, 4 * sizeof(struct vertex), NULL,
  352.                        GL_DYNAMIC_DRAW);
  353.  
  354.       /* setup vertex arrays */
  355.       if (use_generic_attributes) {
  356.          assert(color_size == 0);
  357.  
  358.          _mesa_VertexAttribPointer(0, vertex_size, GL_FLOAT, GL_FALSE,
  359.                                    sizeof(struct vertex), OFFSET(x));
  360.          _mesa_EnableVertexAttribArray(0);
  361.  
  362.          if (texcoord_size > 0) {
  363.             _mesa_VertexAttribPointer(1, texcoord_size, GL_FLOAT, GL_FALSE,
  364.                                       sizeof(struct vertex), OFFSET(tex));
  365.             _mesa_EnableVertexAttribArray(1);
  366.          }
  367.       } else {
  368.          _mesa_VertexPointer(vertex_size, GL_FLOAT, sizeof(struct vertex),
  369.                              OFFSET(x));
  370.          _mesa_EnableClientState(GL_VERTEX_ARRAY);
  371.  
  372.          if (texcoord_size > 0) {
  373.             _mesa_TexCoordPointer(texcoord_size, GL_FLOAT,
  374.                                   sizeof(struct vertex), OFFSET(tex));
  375.             _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
  376.          }
  377.  
  378.          if (color_size > 0) {
  379.             _mesa_ColorPointer(color_size, GL_FLOAT,
  380.                                sizeof(struct vertex), OFFSET(r));
  381.             _mesa_EnableClientState(GL_COLOR_ARRAY);
  382.          }
  383.       }
  384.    } else {
  385.       _mesa_BindVertexArray(*VAO);
  386.       _mesa_BindBuffer(GL_ARRAY_BUFFER, *VBO);
  387.    }
  388. }
  389.  
  390. /**
  391.  * Initialize meta-ops for a context.
  392.  * To be called once during context creation.
  393.  */
  394. void
  395. _mesa_meta_init(struct gl_context *ctx)
  396. {
  397.    assert(!ctx->Meta);
  398.  
  399.    ctx->Meta = CALLOC_STRUCT(gl_meta_state);
  400. }
  401.  
  402. /**
  403.  * Free context meta-op state.
  404.  * To be called once during context destruction.
  405.  */
  406. void
  407. _mesa_meta_free(struct gl_context *ctx)
  408. {
  409.    GET_CURRENT_CONTEXT(old_context);
  410.    _mesa_make_current(ctx, NULL, NULL);
  411.    _mesa_meta_glsl_blit_cleanup(&ctx->Meta->Blit);
  412.    meta_glsl_clear_cleanup(&ctx->Meta->Clear);
  413.    _mesa_meta_glsl_generate_mipmap_cleanup(&ctx->Meta->Mipmap);
  414.    cleanup_temp_texture(&ctx->Meta->TempTex);
  415.    meta_decompress_cleanup(&ctx->Meta->Decompress);
  416.    meta_drawpix_cleanup(&ctx->Meta->DrawPix);
  417.    if (old_context)
  418.       _mesa_make_current(old_context, old_context->WinSysDrawBuffer, old_context->WinSysReadBuffer);
  419.    else
  420.       _mesa_make_current(NULL, NULL, NULL);
  421.    free(ctx->Meta);
  422.    ctx->Meta = NULL;
  423. }
  424.  
  425.  
  426. /**
  427.  * Enter meta state.  This is like a light-weight version of glPushAttrib
  428.  * but it also resets most GL state back to default values.
  429.  *
  430.  * \param state  bitmask of MESA_META_* flags indicating which attribute groups
  431.  *               to save and reset to their defaults
  432.  */
  433. void
  434. _mesa_meta_begin(struct gl_context *ctx, GLbitfield state)
  435. {
  436.    struct save_state *save;
  437.  
  438.    /* hope MAX_META_OPS_DEPTH is large enough */
  439.    assert(ctx->Meta->SaveStackDepth < MAX_META_OPS_DEPTH);
  440.  
  441.    save = &ctx->Meta->Save[ctx->Meta->SaveStackDepth++];
  442.    memset(save, 0, sizeof(*save));
  443.    save->SavedState = state;
  444.  
  445.    /* We always push into desktop GL mode and pop out at the end.  No sense in
  446.     * writing our shaders varying based on the user's context choice, when
  447.     * Mesa can handle either.
  448.     */
  449.    save->API = ctx->API;
  450.    ctx->API = API_OPENGL_COMPAT;
  451.  
  452.    /* Pausing transform feedback needs to be done early, or else we won't be
  453.     * able to change other state.
  454.     */
  455.    save->TransformFeedbackNeedsResume =
  456.       _mesa_is_xfb_active_and_unpaused(ctx);
  457.    if (save->TransformFeedbackNeedsResume)
  458.       _mesa_PauseTransformFeedback();
  459.  
  460.    /* After saving the current occlusion object, call EndQuery so that no
  461.     * occlusion querying will be active during the meta-operation.
  462.     */
  463.    if (state & MESA_META_OCCLUSION_QUERY) {
  464.       save->CurrentOcclusionObject = ctx->Query.CurrentOcclusionObject;
  465.       if (save->CurrentOcclusionObject)
  466.          _mesa_EndQuery(save->CurrentOcclusionObject->Target);
  467.    }
  468.  
  469.    if (state & MESA_META_ALPHA_TEST) {
  470.       save->AlphaEnabled = ctx->Color.AlphaEnabled;
  471.       save->AlphaFunc = ctx->Color.AlphaFunc;
  472.       save->AlphaRef = ctx->Color.AlphaRef;
  473.       if (ctx->Color.AlphaEnabled)
  474.          _mesa_set_enable(ctx, GL_ALPHA_TEST, GL_FALSE);
  475.    }
  476.  
  477.    if (state & MESA_META_BLEND) {
  478.       save->BlendEnabled = ctx->Color.BlendEnabled;
  479.       if (ctx->Color.BlendEnabled) {
  480.          if (ctx->Extensions.EXT_draw_buffers2) {
  481.             GLuint i;
  482.             for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
  483.                _mesa_set_enablei(ctx, GL_BLEND, i, GL_FALSE);
  484.             }
  485.          }
  486.          else {
  487.             _mesa_set_enable(ctx, GL_BLEND, GL_FALSE);
  488.          }
  489.       }
  490.       save->ColorLogicOpEnabled = ctx->Color.ColorLogicOpEnabled;
  491.       if (ctx->Color.ColorLogicOpEnabled)
  492.          _mesa_set_enable(ctx, GL_COLOR_LOGIC_OP, GL_FALSE);
  493.    }
  494.  
  495.    if (state & MESA_META_DITHER) {
  496.       save->DitherFlag = ctx->Color.DitherFlag;
  497.       _mesa_set_enable(ctx, GL_DITHER, GL_TRUE);
  498.    }
  499.  
  500.    if (state & MESA_META_COLOR_MASK) {
  501.       memcpy(save->ColorMask, ctx->Color.ColorMask,
  502.              sizeof(ctx->Color.ColorMask));
  503.       if (!ctx->Color.ColorMask[0][0] ||
  504.           !ctx->Color.ColorMask[0][1] ||
  505.           !ctx->Color.ColorMask[0][2] ||
  506.           !ctx->Color.ColorMask[0][3])
  507.          _mesa_ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
  508.    }
  509.  
  510.    if (state & MESA_META_DEPTH_TEST) {
  511.       save->Depth = ctx->Depth; /* struct copy */
  512.       if (ctx->Depth.Test)
  513.          _mesa_set_enable(ctx, GL_DEPTH_TEST, GL_FALSE);
  514.    }
  515.  
  516.    if (state & MESA_META_FOG) {
  517.       save->Fog = ctx->Fog.Enabled;
  518.       if (ctx->Fog.Enabled)
  519.          _mesa_set_enable(ctx, GL_FOG, GL_FALSE);
  520.    }
  521.  
  522.    if (state & MESA_META_PIXEL_STORE) {
  523.       save->Pack = ctx->Pack;
  524.       save->Unpack = ctx->Unpack;
  525.       ctx->Pack = ctx->DefaultPacking;
  526.       ctx->Unpack = ctx->DefaultPacking;
  527.    }
  528.  
  529.    if (state & MESA_META_PIXEL_TRANSFER) {
  530.       save->RedScale = ctx->Pixel.RedScale;
  531.       save->RedBias = ctx->Pixel.RedBias;
  532.       save->GreenScale = ctx->Pixel.GreenScale;
  533.       save->GreenBias = ctx->Pixel.GreenBias;
  534.       save->BlueScale = ctx->Pixel.BlueScale;
  535.       save->BlueBias = ctx->Pixel.BlueBias;
  536.       save->AlphaScale = ctx->Pixel.AlphaScale;
  537.       save->AlphaBias = ctx->Pixel.AlphaBias;
  538.       save->MapColorFlag = ctx->Pixel.MapColorFlag;
  539.       ctx->Pixel.RedScale = 1.0F;
  540.       ctx->Pixel.RedBias = 0.0F;
  541.       ctx->Pixel.GreenScale = 1.0F;
  542.       ctx->Pixel.GreenBias = 0.0F;
  543.       ctx->Pixel.BlueScale = 1.0F;
  544.       ctx->Pixel.BlueBias = 0.0F;
  545.       ctx->Pixel.AlphaScale = 1.0F;
  546.       ctx->Pixel.AlphaBias = 0.0F;
  547.       ctx->Pixel.MapColorFlag = GL_FALSE;
  548.       /* XXX more state */
  549.       ctx->NewState |=_NEW_PIXEL;
  550.    }
  551.  
  552.    if (state & MESA_META_RASTERIZATION) {
  553.       save->FrontPolygonMode = ctx->Polygon.FrontMode;
  554.       save->BackPolygonMode = ctx->Polygon.BackMode;
  555.       save->PolygonOffset = ctx->Polygon.OffsetFill;
  556.       save->PolygonSmooth = ctx->Polygon.SmoothFlag;
  557.       save->PolygonStipple = ctx->Polygon.StippleFlag;
  558.       save->PolygonCull = ctx->Polygon.CullFlag;
  559.       _mesa_PolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  560.       _mesa_set_enable(ctx, GL_POLYGON_OFFSET_FILL, GL_FALSE);
  561.       _mesa_set_enable(ctx, GL_POLYGON_SMOOTH, GL_FALSE);
  562.       _mesa_set_enable(ctx, GL_POLYGON_STIPPLE, GL_FALSE);
  563.       _mesa_set_enable(ctx, GL_CULL_FACE, GL_FALSE);
  564.    }
  565.  
  566.    if (state & MESA_META_SCISSOR) {
  567.       save->Scissor = ctx->Scissor; /* struct copy */
  568.       _mesa_set_enable(ctx, GL_SCISSOR_TEST, GL_FALSE);
  569.    }
  570.  
  571.    if (state & MESA_META_SHADER) {
  572.       int i;
  573.  
  574.       if (ctx->Extensions.ARB_vertex_program) {
  575.          save->VertexProgramEnabled = ctx->VertexProgram.Enabled;
  576.          _mesa_reference_vertprog(ctx, &save->VertexProgram,
  577.                                   ctx->VertexProgram.Current);
  578.          _mesa_set_enable(ctx, GL_VERTEX_PROGRAM_ARB, GL_FALSE);
  579.       }
  580.  
  581.       if (ctx->Extensions.ARB_fragment_program) {
  582.          save->FragmentProgramEnabled = ctx->FragmentProgram.Enabled;
  583.          _mesa_reference_fragprog(ctx, &save->FragmentProgram,
  584.                                   ctx->FragmentProgram.Current);
  585.          _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_FALSE);
  586.       }
  587.  
  588.       if (ctx->Extensions.ATI_fragment_shader) {
  589.          save->ATIFragmentShaderEnabled = ctx->ATIFragmentShader.Enabled;
  590.          _mesa_set_enable(ctx, GL_FRAGMENT_SHADER_ATI, GL_FALSE);
  591.       }
  592.  
  593.       if (ctx->Pipeline.Current) {
  594.          _mesa_reference_pipeline_object(ctx, &save->Pipeline,
  595.                                          ctx->Pipeline.Current);
  596.          _mesa_BindProgramPipeline(0);
  597.       }
  598.  
  599.       /* Save the shader state from ctx->Shader (instead of ctx->_Shader) so
  600.        * that we don't have to worry about the current pipeline state.
  601.        */
  602.       for (i = 0; i <= MESA_SHADER_FRAGMENT; i++) {
  603.          _mesa_reference_shader_program(ctx, &save->Shader[i],
  604.                                         ctx->Shader.CurrentProgram[i]);
  605.       }
  606.       _mesa_reference_shader_program(ctx, &save->ActiveShader,
  607.                                      ctx->Shader.ActiveProgram);
  608.  
  609.       _mesa_UseProgram(0);
  610.    }
  611.  
  612.    if (state & MESA_META_STENCIL_TEST) {
  613.       save->Stencil = ctx->Stencil; /* struct copy */
  614.       if (ctx->Stencil.Enabled)
  615.          _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_FALSE);
  616.       /* NOTE: other stencil state not reset */
  617.    }
  618.  
  619.    if (state & MESA_META_TEXTURE) {
  620.       GLuint u, tgt;
  621.  
  622.       save->ActiveUnit = ctx->Texture.CurrentUnit;
  623.       save->ClientActiveUnit = ctx->Array.ActiveTexture;
  624.       save->EnvMode = ctx->Texture.Unit[0].EnvMode;
  625.  
  626.       /* Disable all texture units */
  627.       for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
  628.          save->TexEnabled[u] = ctx->Texture.Unit[u].Enabled;
  629.          save->TexGenEnabled[u] = ctx->Texture.Unit[u].TexGenEnabled;
  630.          if (ctx->Texture.Unit[u].Enabled ||
  631.              ctx->Texture.Unit[u].TexGenEnabled) {
  632.             _mesa_ActiveTexture(GL_TEXTURE0 + u);
  633.             _mesa_set_enable(ctx, GL_TEXTURE_2D, GL_FALSE);
  634.             if (ctx->Extensions.ARB_texture_cube_map)
  635.                _mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP, GL_FALSE);
  636.  
  637.             _mesa_set_enable(ctx, GL_TEXTURE_1D, GL_FALSE);
  638.             _mesa_set_enable(ctx, GL_TEXTURE_3D, GL_FALSE);
  639.             if (ctx->Extensions.NV_texture_rectangle)
  640.                _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE, GL_FALSE);
  641.             _mesa_set_enable(ctx, GL_TEXTURE_GEN_S, GL_FALSE);
  642.             _mesa_set_enable(ctx, GL_TEXTURE_GEN_T, GL_FALSE);
  643.             _mesa_set_enable(ctx, GL_TEXTURE_GEN_R, GL_FALSE);
  644.             _mesa_set_enable(ctx, GL_TEXTURE_GEN_Q, GL_FALSE);
  645.          }
  646.       }
  647.  
  648.       /* save current texture objects for unit[0] only */
  649.       for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
  650.          _mesa_reference_texobj(&save->CurrentTexture[tgt],
  651.                                 ctx->Texture.Unit[0].CurrentTex[tgt]);
  652.       }
  653.  
  654.       /* set defaults for unit[0] */
  655.       _mesa_ActiveTexture(GL_TEXTURE0);
  656.       _mesa_ClientActiveTexture(GL_TEXTURE0);
  657.       _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  658.    }
  659.  
  660.    if (state & MESA_META_TRANSFORM) {
  661.       GLuint activeTexture = ctx->Texture.CurrentUnit;
  662.       memcpy(save->ModelviewMatrix, ctx->ModelviewMatrixStack.Top->m,
  663.              16 * sizeof(GLfloat));
  664.       memcpy(save->ProjectionMatrix, ctx->ProjectionMatrixStack.Top->m,
  665.              16 * sizeof(GLfloat));
  666.       memcpy(save->TextureMatrix, ctx->TextureMatrixStack[0].Top->m,
  667.              16 * sizeof(GLfloat));
  668.       save->MatrixMode = ctx->Transform.MatrixMode;
  669.       /* set 1:1 vertex:pixel coordinate transform */
  670.       _mesa_ActiveTexture(GL_TEXTURE0);
  671.       _mesa_MatrixMode(GL_TEXTURE);
  672.       _mesa_LoadIdentity();
  673.       _mesa_ActiveTexture(GL_TEXTURE0 + activeTexture);
  674.       _mesa_MatrixMode(GL_MODELVIEW);
  675.       _mesa_LoadIdentity();
  676.       _mesa_MatrixMode(GL_PROJECTION);
  677.       _mesa_LoadIdentity();
  678.  
  679.       /* glOrtho with width = 0 or height = 0 generates GL_INVALID_VALUE.
  680.        * This can occur when there is no draw buffer.
  681.        */
  682.       if (ctx->DrawBuffer->Width != 0 && ctx->DrawBuffer->Height != 0)
  683.          _mesa_Ortho(0.0, ctx->DrawBuffer->Width,
  684.                      0.0, ctx->DrawBuffer->Height,
  685.                      -1.0, 1.0);
  686.  
  687.       if (ctx->Extensions.ARB_clip_control) {
  688.          save->ClipOrigin = ctx->Transform.ClipOrigin;
  689.          save->ClipDepthMode = ctx->Transform.ClipDepthMode;
  690.          _mesa_ClipControl(GL_LOWER_LEFT, GL_NEGATIVE_ONE_TO_ONE);
  691.       }
  692.    }
  693.  
  694.    if (state & MESA_META_CLIP) {
  695.       save->ClipPlanesEnabled = ctx->Transform.ClipPlanesEnabled;
  696.       if (ctx->Transform.ClipPlanesEnabled) {
  697.          GLuint i;
  698.          for (i = 0; i < ctx->Const.MaxClipPlanes; i++) {
  699.             _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_FALSE);
  700.          }
  701.       }
  702.    }
  703.  
  704.    if (state & MESA_META_VERTEX) {
  705.       /* save vertex array object state */
  706.       _mesa_reference_vao(ctx, &save->VAO,
  707.                                    ctx->Array.VAO);
  708.       _mesa_reference_buffer_object(ctx, &save->ArrayBufferObj,
  709.                                     ctx->Array.ArrayBufferObj);
  710.       /* set some default state? */
  711.    }
  712.  
  713.    if (state & MESA_META_VIEWPORT) {
  714.       /* save viewport state */
  715.       save->ViewportX = ctx->ViewportArray[0].X;
  716.       save->ViewportY = ctx->ViewportArray[0].Y;
  717.       save->ViewportW = ctx->ViewportArray[0].Width;
  718.       save->ViewportH = ctx->ViewportArray[0].Height;
  719.       /* set viewport to match window size */
  720.       if (ctx->ViewportArray[0].X != 0 ||
  721.           ctx->ViewportArray[0].Y != 0 ||
  722.           ctx->ViewportArray[0].Width != (float) ctx->DrawBuffer->Width ||
  723.           ctx->ViewportArray[0].Height != (float) ctx->DrawBuffer->Height) {
  724.          _mesa_set_viewport(ctx, 0, 0, 0,
  725.                             ctx->DrawBuffer->Width, ctx->DrawBuffer->Height);
  726.       }
  727.       /* save depth range state */
  728.       save->DepthNear = ctx->ViewportArray[0].Near;
  729.       save->DepthFar = ctx->ViewportArray[0].Far;
  730.       /* set depth range to default */
  731.       _mesa_DepthRange(0.0, 1.0);
  732.    }
  733.  
  734.    if (state & MESA_META_CLAMP_FRAGMENT_COLOR) {
  735.       save->ClampFragmentColor = ctx->Color.ClampFragmentColor;
  736.  
  737.       /* Generally in here we want to do clamping according to whether
  738.        * it's for the pixel path (ClampFragmentColor is GL_TRUE),
  739.        * regardless of the internal implementation of the metaops.
  740.        */
  741.       if (ctx->Color.ClampFragmentColor != GL_TRUE &&
  742.           ctx->Extensions.ARB_color_buffer_float)
  743.          _mesa_ClampColor(GL_CLAMP_FRAGMENT_COLOR, GL_FALSE);
  744.    }
  745.  
  746.    if (state & MESA_META_CLAMP_VERTEX_COLOR) {
  747.       save->ClampVertexColor = ctx->Light.ClampVertexColor;
  748.  
  749.       /* Generally in here we never want vertex color clamping --
  750.        * result clamping is only dependent on fragment clamping.
  751.        */
  752.       if (ctx->Extensions.ARB_color_buffer_float)
  753.          _mesa_ClampColor(GL_CLAMP_VERTEX_COLOR, GL_FALSE);
  754.    }
  755.  
  756.    if (state & MESA_META_CONDITIONAL_RENDER) {
  757.       save->CondRenderQuery = ctx->Query.CondRenderQuery;
  758.       save->CondRenderMode = ctx->Query.CondRenderMode;
  759.  
  760.       if (ctx->Query.CondRenderQuery)
  761.          _mesa_EndConditionalRender();
  762.    }
  763.  
  764.    if (state & MESA_META_SELECT_FEEDBACK) {
  765.       save->RenderMode = ctx->RenderMode;
  766.       if (ctx->RenderMode == GL_SELECT) {
  767.          save->Select = ctx->Select; /* struct copy */
  768.          _mesa_RenderMode(GL_RENDER);
  769.       } else if (ctx->RenderMode == GL_FEEDBACK) {
  770.          save->Feedback = ctx->Feedback; /* struct copy */
  771.          _mesa_RenderMode(GL_RENDER);
  772.       }
  773.    }
  774.  
  775.    if (state & MESA_META_MULTISAMPLE) {
  776.       save->Multisample = ctx->Multisample; /* struct copy */
  777.  
  778.       if (ctx->Multisample.Enabled)
  779.          _mesa_set_multisample(ctx, GL_FALSE);
  780.       if (ctx->Multisample.SampleCoverage)
  781.          _mesa_set_enable(ctx, GL_SAMPLE_COVERAGE, GL_FALSE);
  782.       if (ctx->Multisample.SampleAlphaToCoverage)
  783.          _mesa_set_enable(ctx, GL_SAMPLE_ALPHA_TO_COVERAGE, GL_FALSE);
  784.       if (ctx->Multisample.SampleAlphaToOne)
  785.          _mesa_set_enable(ctx, GL_SAMPLE_ALPHA_TO_ONE, GL_FALSE);
  786.       if (ctx->Multisample.SampleShading)
  787.          _mesa_set_enable(ctx, GL_SAMPLE_SHADING, GL_FALSE);
  788.       if (ctx->Multisample.SampleMask)
  789.          _mesa_set_enable(ctx, GL_SAMPLE_MASK, GL_FALSE);
  790.    }
  791.  
  792.    if (state & MESA_META_FRAMEBUFFER_SRGB) {
  793.       save->sRGBEnabled = ctx->Color.sRGBEnabled;
  794.       if (ctx->Color.sRGBEnabled)
  795.          _mesa_set_framebuffer_srgb(ctx, GL_FALSE);
  796.    }
  797.  
  798.    if (state & MESA_META_DRAW_BUFFERS) {
  799.       struct gl_framebuffer *fb = ctx->DrawBuffer;
  800.       memcpy(save->ColorDrawBuffers, fb->ColorDrawBuffer,
  801.              sizeof(save->ColorDrawBuffers));
  802.    }
  803.  
  804.    /* misc */
  805.    {
  806.       save->Lighting = ctx->Light.Enabled;
  807.       if (ctx->Light.Enabled)
  808.          _mesa_set_enable(ctx, GL_LIGHTING, GL_FALSE);
  809.       save->RasterDiscard = ctx->RasterDiscard;
  810.       if (ctx->RasterDiscard)
  811.          _mesa_set_enable(ctx, GL_RASTERIZER_DISCARD, GL_FALSE);
  812.  
  813.       save->DrawBufferName = ctx->DrawBuffer->Name;
  814.       save->ReadBufferName = ctx->ReadBuffer->Name;
  815.       save->RenderbufferName = (ctx->CurrentRenderbuffer ?
  816.                                 ctx->CurrentRenderbuffer->Name : 0);
  817.    }
  818. }
  819.  
  820.  
  821. /**
  822.  * Leave meta state.  This is like a light-weight version of glPopAttrib().
  823.  */
  824. void
  825. _mesa_meta_end(struct gl_context *ctx)
  826. {
  827.    assert(ctx->Meta->SaveStackDepth > 0);
  828.  
  829.    struct save_state *save = &ctx->Meta->Save[ctx->Meta->SaveStackDepth - 1];
  830.    const GLbitfield state = save->SavedState;
  831.    int i;
  832.  
  833.    /* Grab the result of the old occlusion query before starting it again. The
  834.     * old result is added to the result of the new query so the driver will
  835.     * continue adding where it left off. */
  836.    if (state & MESA_META_OCCLUSION_QUERY) {
  837.       if (save->CurrentOcclusionObject) {
  838.          struct gl_query_object *q = save->CurrentOcclusionObject;
  839.          GLuint64EXT result;
  840.          if (!q->Ready)
  841.             ctx->Driver.WaitQuery(ctx, q);
  842.          result = q->Result;
  843.          _mesa_BeginQuery(q->Target, q->Id);
  844.          ctx->Query.CurrentOcclusionObject->Result += result;
  845.       }
  846.    }
  847.  
  848.    if (state & MESA_META_ALPHA_TEST) {
  849.       if (ctx->Color.AlphaEnabled != save->AlphaEnabled)
  850.          _mesa_set_enable(ctx, GL_ALPHA_TEST, save->AlphaEnabled);
  851.       _mesa_AlphaFunc(save->AlphaFunc, save->AlphaRef);
  852.    }
  853.  
  854.    if (state & MESA_META_BLEND) {
  855.       if (ctx->Color.BlendEnabled != save->BlendEnabled) {
  856.          if (ctx->Extensions.EXT_draw_buffers2) {
  857.             GLuint i;
  858.             for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
  859.                _mesa_set_enablei(ctx, GL_BLEND, i, (save->BlendEnabled >> i) & 1);
  860.             }
  861.          }
  862.          else {
  863.             _mesa_set_enable(ctx, GL_BLEND, (save->BlendEnabled & 1));
  864.          }
  865.       }
  866.       if (ctx->Color.ColorLogicOpEnabled != save->ColorLogicOpEnabled)
  867.          _mesa_set_enable(ctx, GL_COLOR_LOGIC_OP, save->ColorLogicOpEnabled);
  868.    }
  869.  
  870.    if (state & MESA_META_DITHER)
  871.       _mesa_set_enable(ctx, GL_DITHER, save->DitherFlag);
  872.  
  873.    if (state & MESA_META_COLOR_MASK) {
  874.       GLuint i;
  875.       for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
  876.          if (!TEST_EQ_4V(ctx->Color.ColorMask[i], save->ColorMask[i])) {
  877.             if (i == 0) {
  878.                _mesa_ColorMask(save->ColorMask[i][0], save->ColorMask[i][1],
  879.                                save->ColorMask[i][2], save->ColorMask[i][3]);
  880.             }
  881.             else {
  882.                _mesa_ColorMaski(i,
  883.                                       save->ColorMask[i][0],
  884.                                       save->ColorMask[i][1],
  885.                                       save->ColorMask[i][2],
  886.                                       save->ColorMask[i][3]);
  887.             }
  888.          }
  889.       }
  890.    }
  891.  
  892.    if (state & MESA_META_DEPTH_TEST) {
  893.       if (ctx->Depth.Test != save->Depth.Test)
  894.          _mesa_set_enable(ctx, GL_DEPTH_TEST, save->Depth.Test);
  895.       _mesa_DepthFunc(save->Depth.Func);
  896.       _mesa_DepthMask(save->Depth.Mask);
  897.    }
  898.  
  899.    if (state & MESA_META_FOG) {
  900.       _mesa_set_enable(ctx, GL_FOG, save->Fog);
  901.    }
  902.  
  903.    if (state & MESA_META_PIXEL_STORE) {
  904.       ctx->Pack = save->Pack;
  905.       ctx->Unpack = save->Unpack;
  906.    }
  907.  
  908.    if (state & MESA_META_PIXEL_TRANSFER) {
  909.       ctx->Pixel.RedScale = save->RedScale;
  910.       ctx->Pixel.RedBias = save->RedBias;
  911.       ctx->Pixel.GreenScale = save->GreenScale;
  912.       ctx->Pixel.GreenBias = save->GreenBias;
  913.       ctx->Pixel.BlueScale = save->BlueScale;
  914.       ctx->Pixel.BlueBias = save->BlueBias;
  915.       ctx->Pixel.AlphaScale = save->AlphaScale;
  916.       ctx->Pixel.AlphaBias = save->AlphaBias;
  917.       ctx->Pixel.MapColorFlag = save->MapColorFlag;
  918.       /* XXX more state */
  919.       ctx->NewState |=_NEW_PIXEL;
  920.    }
  921.  
  922.    if (state & MESA_META_RASTERIZATION) {
  923.       _mesa_PolygonMode(GL_FRONT, save->FrontPolygonMode);
  924.       _mesa_PolygonMode(GL_BACK, save->BackPolygonMode);
  925.       _mesa_set_enable(ctx, GL_POLYGON_STIPPLE, save->PolygonStipple);
  926.       _mesa_set_enable(ctx, GL_POLYGON_SMOOTH, save->PolygonSmooth);
  927.       _mesa_set_enable(ctx, GL_POLYGON_OFFSET_FILL, save->PolygonOffset);
  928.       _mesa_set_enable(ctx, GL_CULL_FACE, save->PolygonCull);
  929.    }
  930.  
  931.    if (state & MESA_META_SCISSOR) {
  932.       unsigned i;
  933.  
  934.       for (i = 0; i < ctx->Const.MaxViewports; i++) {
  935.          _mesa_set_scissor(ctx, i,
  936.                            save->Scissor.ScissorArray[i].X,
  937.                            save->Scissor.ScissorArray[i].Y,
  938.                            save->Scissor.ScissorArray[i].Width,
  939.                            save->Scissor.ScissorArray[i].Height);
  940.          _mesa_set_enablei(ctx, GL_SCISSOR_TEST, i,
  941.                            (save->Scissor.EnableFlags >> i) & 1);
  942.       }
  943.    }
  944.  
  945.    if (state & MESA_META_SHADER) {
  946.       static const GLenum targets[] = {
  947.          GL_VERTEX_SHADER,
  948.          GL_GEOMETRY_SHADER,
  949.          GL_FRAGMENT_SHADER,
  950.       };
  951.  
  952.       bool any_shader;
  953.  
  954.       if (ctx->Extensions.ARB_vertex_program) {
  955.          _mesa_set_enable(ctx, GL_VERTEX_PROGRAM_ARB,
  956.                           save->VertexProgramEnabled);
  957.          _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current,
  958.                                   save->VertexProgram);
  959.          _mesa_reference_vertprog(ctx, &save->VertexProgram, NULL);
  960.       }
  961.  
  962.       if (ctx->Extensions.ARB_fragment_program) {
  963.          _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB,
  964.                           save->FragmentProgramEnabled);
  965.          _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current,
  966.                                   save->FragmentProgram);
  967.          _mesa_reference_fragprog(ctx, &save->FragmentProgram, NULL);
  968.       }
  969.  
  970.       if (ctx->Extensions.ATI_fragment_shader) {
  971.          _mesa_set_enable(ctx, GL_FRAGMENT_SHADER_ATI,
  972.                           save->ATIFragmentShaderEnabled);
  973.       }
  974.  
  975.       any_shader = false;
  976.       for (i = 0; i <= MESA_SHADER_FRAGMENT; i++) {
  977.          /* It is safe to call _mesa_use_shader_program even if the extension
  978.           * necessary for that program state is not supported.  In that case,
  979.           * the saved program object must be NULL and the currently bound
  980.           * program object must be NULL.  _mesa_use_shader_program is a no-op
  981.           * in that case.
  982.           */
  983.          _mesa_use_shader_program(ctx, targets[i],
  984.                                   save->Shader[i],
  985.                                   &ctx->Shader);
  986.  
  987.          /* Do this *before* killing the reference. :)
  988.           */
  989.          if (save->Shader[i] != NULL)
  990.             any_shader = true;
  991.  
  992.          _mesa_reference_shader_program(ctx, &save->Shader[i], NULL);
  993.       }
  994.  
  995.       _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram,
  996.                                      save->ActiveShader);
  997.       _mesa_reference_shader_program(ctx, &save->ActiveShader, NULL);
  998.  
  999.       /* If there were any stages set with programs, use ctx->Shader as the
  1000.        * current shader state.  Otherwise, use Pipeline.Default.  The pipeline
  1001.        * hasn't been restored yet, and that may modify ctx->_Shader further.
  1002.        */
  1003.       if (any_shader)
  1004.          _mesa_reference_pipeline_object(ctx, &ctx->_Shader,
  1005.                                          &ctx->Shader);
  1006.       else
  1007.          _mesa_reference_pipeline_object(ctx, &ctx->_Shader,
  1008.                                          ctx->Pipeline.Default);
  1009.  
  1010.       if (save->Pipeline) {
  1011.          _mesa_bind_pipeline(ctx, save->Pipeline);
  1012.  
  1013.          _mesa_reference_pipeline_object(ctx, &save->Pipeline, NULL);
  1014.       }
  1015.    }
  1016.  
  1017.    if (state & MESA_META_STENCIL_TEST) {
  1018.       const struct gl_stencil_attrib *stencil = &save->Stencil;
  1019.  
  1020.       _mesa_set_enable(ctx, GL_STENCIL_TEST, stencil->Enabled);
  1021.       _mesa_ClearStencil(stencil->Clear);
  1022.       if (ctx->Extensions.EXT_stencil_two_side) {
  1023.          _mesa_set_enable(ctx, GL_STENCIL_TEST_TWO_SIDE_EXT,
  1024.                           stencil->TestTwoSide);
  1025.          _mesa_ActiveStencilFaceEXT(stencil->ActiveFace
  1026.                                     ? GL_BACK : GL_FRONT);
  1027.       }
  1028.       /* front state */
  1029.       _mesa_StencilFuncSeparate(GL_FRONT,
  1030.                                 stencil->Function[0],
  1031.                                 stencil->Ref[0],
  1032.                                 stencil->ValueMask[0]);
  1033.       _mesa_StencilMaskSeparate(GL_FRONT, stencil->WriteMask[0]);
  1034.       _mesa_StencilOpSeparate(GL_FRONT, stencil->FailFunc[0],
  1035.                               stencil->ZFailFunc[0],
  1036.                               stencil->ZPassFunc[0]);
  1037.       /* back state */
  1038.       _mesa_StencilFuncSeparate(GL_BACK,
  1039.                                 stencil->Function[1],
  1040.                                 stencil->Ref[1],
  1041.                                 stencil->ValueMask[1]);
  1042.       _mesa_StencilMaskSeparate(GL_BACK, stencil->WriteMask[1]);
  1043.       _mesa_StencilOpSeparate(GL_BACK, stencil->FailFunc[1],
  1044.                               stencil->ZFailFunc[1],
  1045.                               stencil->ZPassFunc[1]);
  1046.    }
  1047.  
  1048.    if (state & MESA_META_TEXTURE) {
  1049.       GLuint u, tgt;
  1050.  
  1051.       assert(ctx->Texture.CurrentUnit == 0);
  1052.  
  1053.       /* restore texenv for unit[0] */
  1054.       _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, save->EnvMode);
  1055.  
  1056.       /* restore texture objects for unit[0] only */
  1057.       for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
  1058.          if (ctx->Texture.Unit[0].CurrentTex[tgt] != save->CurrentTexture[tgt]) {
  1059.             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
  1060.             _mesa_reference_texobj(&ctx->Texture.Unit[0].CurrentTex[tgt],
  1061.                                    save->CurrentTexture[tgt]);
  1062.          }
  1063.          _mesa_reference_texobj(&save->CurrentTexture[tgt], NULL);
  1064.       }
  1065.  
  1066.       /* Restore fixed function texture enables, texgen */
  1067.       for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
  1068.          if (ctx->Texture.Unit[u].Enabled != save->TexEnabled[u]) {
  1069.             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
  1070.             ctx->Texture.Unit[u].Enabled = save->TexEnabled[u];
  1071.          }
  1072.  
  1073.          if (ctx->Texture.Unit[u].TexGenEnabled != save->TexGenEnabled[u]) {
  1074.             FLUSH_VERTICES(ctx, _NEW_TEXTURE);
  1075.             ctx->Texture.Unit[u].TexGenEnabled = save->TexGenEnabled[u];
  1076.          }
  1077.       }
  1078.  
  1079.       /* restore current unit state */
  1080.       _mesa_ActiveTexture(GL_TEXTURE0 + save->ActiveUnit);
  1081.       _mesa_ClientActiveTexture(GL_TEXTURE0 + save->ClientActiveUnit);
  1082.    }
  1083.  
  1084.    if (state & MESA_META_TRANSFORM) {
  1085.       GLuint activeTexture = ctx->Texture.CurrentUnit;
  1086.       _mesa_ActiveTexture(GL_TEXTURE0);
  1087.       _mesa_MatrixMode(GL_TEXTURE);
  1088.       _mesa_LoadMatrixf(save->TextureMatrix);
  1089.       _mesa_ActiveTexture(GL_TEXTURE0 + activeTexture);
  1090.  
  1091.       _mesa_MatrixMode(GL_MODELVIEW);
  1092.       _mesa_LoadMatrixf(save->ModelviewMatrix);
  1093.  
  1094.       _mesa_MatrixMode(GL_PROJECTION);
  1095.       _mesa_LoadMatrixf(save->ProjectionMatrix);
  1096.  
  1097.       _mesa_MatrixMode(save->MatrixMode);
  1098.  
  1099.       if (ctx->Extensions.ARB_clip_control)
  1100.          _mesa_ClipControl(save->ClipOrigin, save->ClipDepthMode);
  1101.    }
  1102.  
  1103.    if (state & MESA_META_CLIP) {
  1104.       if (save->ClipPlanesEnabled) {
  1105.          GLuint i;
  1106.          for (i = 0; i < ctx->Const.MaxClipPlanes; i++) {
  1107.             if (save->ClipPlanesEnabled & (1 << i)) {
  1108.                _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_TRUE);
  1109.             }
  1110.          }
  1111.       }
  1112.    }
  1113.  
  1114.    if (state & MESA_META_VERTEX) {
  1115.       /* restore vertex buffer object */
  1116.       _mesa_BindBuffer(GL_ARRAY_BUFFER_ARB, save->ArrayBufferObj->Name);
  1117.       _mesa_reference_buffer_object(ctx, &save->ArrayBufferObj, NULL);
  1118.  
  1119.       /* restore vertex array object */
  1120.       _mesa_BindVertexArray(save->VAO->Name);
  1121.       _mesa_reference_vao(ctx, &save->VAO, NULL);
  1122.    }
  1123.  
  1124.    if (state & MESA_META_VIEWPORT) {
  1125.       if (save->ViewportX != ctx->ViewportArray[0].X ||
  1126.           save->ViewportY != ctx->ViewportArray[0].Y ||
  1127.           save->ViewportW != ctx->ViewportArray[0].Width ||
  1128.           save->ViewportH != ctx->ViewportArray[0].Height) {
  1129.          _mesa_set_viewport(ctx, 0, save->ViewportX, save->ViewportY,
  1130.                             save->ViewportW, save->ViewportH);
  1131.       }
  1132.       _mesa_DepthRange(save->DepthNear, save->DepthFar);
  1133.    }
  1134.  
  1135.    if (state & MESA_META_CLAMP_FRAGMENT_COLOR &&
  1136.        ctx->Extensions.ARB_color_buffer_float) {
  1137.       _mesa_ClampColor(GL_CLAMP_FRAGMENT_COLOR, save->ClampFragmentColor);
  1138.    }
  1139.  
  1140.    if (state & MESA_META_CLAMP_VERTEX_COLOR &&
  1141.        ctx->Extensions.ARB_color_buffer_float) {
  1142.       _mesa_ClampColor(GL_CLAMP_VERTEX_COLOR, save->ClampVertexColor);
  1143.    }
  1144.  
  1145.    if (state & MESA_META_CONDITIONAL_RENDER) {
  1146.       if (save->CondRenderQuery)
  1147.          _mesa_BeginConditionalRender(save->CondRenderQuery->Id,
  1148.                                       save->CondRenderMode);
  1149.    }
  1150.  
  1151.    if (state & MESA_META_SELECT_FEEDBACK) {
  1152.       if (save->RenderMode == GL_SELECT) {
  1153.          _mesa_RenderMode(GL_SELECT);
  1154.          ctx->Select = save->Select;
  1155.       } else if (save->RenderMode == GL_FEEDBACK) {
  1156.          _mesa_RenderMode(GL_FEEDBACK);
  1157.          ctx->Feedback = save->Feedback;
  1158.       }
  1159.    }
  1160.  
  1161.    if (state & MESA_META_MULTISAMPLE) {
  1162.       struct gl_multisample_attrib *ctx_ms = &ctx->Multisample;
  1163.       struct gl_multisample_attrib *save_ms = &save->Multisample;
  1164.  
  1165.       if (ctx_ms->Enabled != save_ms->Enabled)
  1166.          _mesa_set_multisample(ctx, save_ms->Enabled);
  1167.       if (ctx_ms->SampleCoverage != save_ms->SampleCoverage)
  1168.          _mesa_set_enable(ctx, GL_SAMPLE_COVERAGE, save_ms->SampleCoverage);
  1169.       if (ctx_ms->SampleAlphaToCoverage != save_ms->SampleAlphaToCoverage)
  1170.          _mesa_set_enable(ctx, GL_SAMPLE_ALPHA_TO_COVERAGE, save_ms->SampleAlphaToCoverage);
  1171.       if (ctx_ms->SampleAlphaToOne != save_ms->SampleAlphaToOne)
  1172.          _mesa_set_enable(ctx, GL_SAMPLE_ALPHA_TO_ONE, save_ms->SampleAlphaToOne);
  1173.       if (ctx_ms->SampleCoverageValue != save_ms->SampleCoverageValue ||
  1174.           ctx_ms->SampleCoverageInvert != save_ms->SampleCoverageInvert) {
  1175.          _mesa_SampleCoverage(save_ms->SampleCoverageValue,
  1176.                               save_ms->SampleCoverageInvert);
  1177.       }
  1178.       if (ctx_ms->SampleShading != save_ms->SampleShading)
  1179.          _mesa_set_enable(ctx, GL_SAMPLE_SHADING, save_ms->SampleShading);
  1180.       if (ctx_ms->SampleMask != save_ms->SampleMask)
  1181.          _mesa_set_enable(ctx, GL_SAMPLE_MASK, save_ms->SampleMask);
  1182.       if (ctx_ms->SampleMaskValue != save_ms->SampleMaskValue)
  1183.          _mesa_SampleMaski(0, save_ms->SampleMaskValue);
  1184.       if (ctx_ms->MinSampleShadingValue != save_ms->MinSampleShadingValue)
  1185.          _mesa_MinSampleShading(save_ms->MinSampleShadingValue);
  1186.    }
  1187.  
  1188.    if (state & MESA_META_FRAMEBUFFER_SRGB) {
  1189.       if (ctx->Color.sRGBEnabled != save->sRGBEnabled)
  1190.          _mesa_set_framebuffer_srgb(ctx, save->sRGBEnabled);
  1191.    }
  1192.  
  1193.    /* misc */
  1194.    if (save->Lighting) {
  1195.       _mesa_set_enable(ctx, GL_LIGHTING, GL_TRUE);
  1196.    }
  1197.    if (save->RasterDiscard) {
  1198.       _mesa_set_enable(ctx, GL_RASTERIZER_DISCARD, GL_TRUE);
  1199.    }
  1200.    if (save->TransformFeedbackNeedsResume)
  1201.       _mesa_ResumeTransformFeedback();
  1202.  
  1203.    if (ctx->DrawBuffer->Name != save->DrawBufferName)
  1204.       _mesa_BindFramebuffer(GL_DRAW_FRAMEBUFFER, save->DrawBufferName);
  1205.  
  1206.    if (ctx->ReadBuffer->Name != save->ReadBufferName)
  1207.       _mesa_BindFramebuffer(GL_READ_FRAMEBUFFER, save->ReadBufferName);
  1208.  
  1209.    if (!ctx->CurrentRenderbuffer ||
  1210.        ctx->CurrentRenderbuffer->Name != save->RenderbufferName)
  1211.       _mesa_BindRenderbuffer(GL_RENDERBUFFER, save->RenderbufferName);
  1212.  
  1213.    if (state & MESA_META_DRAW_BUFFERS) {
  1214.       _mesa_drawbuffers(ctx, ctx->DrawBuffer, ctx->Const.MaxDrawBuffers,
  1215.                         save->ColorDrawBuffers, NULL);
  1216.    }
  1217.  
  1218.    ctx->Meta->SaveStackDepth--;
  1219.  
  1220.    ctx->API = save->API;
  1221. }
  1222.  
  1223.  
  1224. /**
  1225.  * Convert Z from a normalized value in the range [0, 1] to an object-space
  1226.  * Z coordinate in [-1, +1] so that drawing at the new Z position with the
  1227.  * default/identity ortho projection results in the original Z value.
  1228.  * Used by the meta-Clear, Draw/CopyPixels and Bitmap functions where the Z
  1229.  * value comes from the clear value or raster position.
  1230.  */
  1231. static inline GLfloat
  1232. invert_z(GLfloat normZ)
  1233. {
  1234.    GLfloat objZ = 1.0f - 2.0f * normZ;
  1235.    return objZ;
  1236. }
  1237.  
  1238.  
  1239. /**
  1240.  * One-time init for a temp_texture object.
  1241.  * Choose tex target, compute max tex size, etc.
  1242.  */
  1243. static void
  1244. init_temp_texture(struct gl_context *ctx, struct temp_texture *tex)
  1245. {
  1246.    /* prefer texture rectangle */
  1247.    if (_mesa_is_desktop_gl(ctx) && ctx->Extensions.NV_texture_rectangle) {
  1248.       tex->Target = GL_TEXTURE_RECTANGLE;
  1249.       tex->MaxSize = ctx->Const.MaxTextureRectSize;
  1250.       tex->NPOT = GL_TRUE;
  1251.    }
  1252.    else {
  1253.       /* use 2D texture, NPOT if possible */
  1254.       tex->Target = GL_TEXTURE_2D;
  1255.       tex->MaxSize = 1 << (ctx->Const.MaxTextureLevels - 1);
  1256.       tex->NPOT = ctx->Extensions.ARB_texture_non_power_of_two;
  1257.    }
  1258.    tex->MinSize = 16;  /* 16 x 16 at least */
  1259.    assert(tex->MaxSize > 0);
  1260.  
  1261.    _mesa_GenTextures(1, &tex->TexObj);
  1262. }
  1263.  
  1264. static void
  1265. cleanup_temp_texture(struct temp_texture *tex)
  1266. {
  1267.    if (!tex->TexObj)
  1268.      return;
  1269.    _mesa_DeleteTextures(1, &tex->TexObj);
  1270.    tex->TexObj = 0;
  1271. }
  1272.  
  1273.  
  1274. /**
  1275.  * Return pointer to temp_texture info for non-bitmap ops.
  1276.  * This does some one-time init if needed.
  1277.  */
  1278. struct temp_texture *
  1279. _mesa_meta_get_temp_texture(struct gl_context *ctx)
  1280. {
  1281.    struct temp_texture *tex = &ctx->Meta->TempTex;
  1282.  
  1283.    if (!tex->TexObj) {
  1284.       init_temp_texture(ctx, tex);
  1285.    }
  1286.  
  1287.    return tex;
  1288. }
  1289.  
  1290.  
  1291. /**
  1292.  * Return pointer to temp_texture info for _mesa_meta_bitmap().
  1293.  * We use a separate texture for bitmaps to reduce texture
  1294.  * allocation/deallocation.
  1295.  */
  1296. static struct temp_texture *
  1297. get_bitmap_temp_texture(struct gl_context *ctx)
  1298. {
  1299.    struct temp_texture *tex = &ctx->Meta->Bitmap.Tex;
  1300.  
  1301.    if (!tex->TexObj) {
  1302.       init_temp_texture(ctx, tex);
  1303.    }
  1304.  
  1305.    return tex;
  1306. }
  1307.  
  1308. /**
  1309.  * Return pointer to depth temp_texture.
  1310.  * This does some one-time init if needed.
  1311.  */
  1312. struct temp_texture *
  1313. _mesa_meta_get_temp_depth_texture(struct gl_context *ctx)
  1314. {
  1315.    struct temp_texture *tex = &ctx->Meta->Blit.depthTex;
  1316.  
  1317.    if (!tex->TexObj) {
  1318.       init_temp_texture(ctx, tex);
  1319.    }
  1320.  
  1321.    return tex;
  1322. }
  1323.  
  1324. /**
  1325.  * Compute the width/height of texture needed to draw an image of the
  1326.  * given size.  Return a flag indicating whether the current texture
  1327.  * can be re-used (glTexSubImage2D) or if a new texture needs to be
  1328.  * allocated (glTexImage2D).
  1329.  * Also, compute s/t texcoords for drawing.
  1330.  *
  1331.  * \return GL_TRUE if new texture is needed, GL_FALSE otherwise
  1332.  */
  1333. GLboolean
  1334. _mesa_meta_alloc_texture(struct temp_texture *tex,
  1335.                          GLsizei width, GLsizei height, GLenum intFormat)
  1336. {
  1337.    GLboolean newTex = GL_FALSE;
  1338.  
  1339.    assert(width <= tex->MaxSize);
  1340.    assert(height <= tex->MaxSize);
  1341.  
  1342.    if (width > tex->Width ||
  1343.        height > tex->Height ||
  1344.        intFormat != tex->IntFormat) {
  1345.       /* alloc new texture (larger or different format) */
  1346.  
  1347.       if (tex->NPOT) {
  1348.          /* use non-power of two size */
  1349.          tex->Width = MAX2(tex->MinSize, width);
  1350.          tex->Height = MAX2(tex->MinSize, height);
  1351.       }
  1352.       else {
  1353.          /* find power of two size */
  1354.          GLsizei w, h;
  1355.          w = h = tex->MinSize;
  1356.          while (w < width)
  1357.             w *= 2;
  1358.          while (h < height)
  1359.             h *= 2;
  1360.          tex->Width = w;
  1361.          tex->Height = h;
  1362.       }
  1363.  
  1364.       tex->IntFormat = intFormat;
  1365.  
  1366.       newTex = GL_TRUE;
  1367.    }
  1368.  
  1369.    /* compute texcoords */
  1370.    if (tex->Target == GL_TEXTURE_RECTANGLE) {
  1371.       tex->Sright = (GLfloat) width;
  1372.       tex->Ttop = (GLfloat) height;
  1373.    }
  1374.    else {
  1375.       tex->Sright = (GLfloat) width / tex->Width;
  1376.       tex->Ttop = (GLfloat) height / tex->Height;
  1377.    }
  1378.  
  1379.    return newTex;
  1380. }
  1381.  
  1382.  
  1383. /**
  1384.  * Setup/load texture for glCopyPixels or glBlitFramebuffer.
  1385.  */
  1386. void
  1387. _mesa_meta_setup_copypix_texture(struct gl_context *ctx,
  1388.                                  struct temp_texture *tex,
  1389.                                  GLint srcX, GLint srcY,
  1390.                                  GLsizei width, GLsizei height,
  1391.                                  GLenum intFormat,
  1392.                                  GLenum filter)
  1393. {
  1394.    bool newTex;
  1395.  
  1396.    _mesa_BindTexture(tex->Target, tex->TexObj);
  1397.    _mesa_TexParameteri(tex->Target, GL_TEXTURE_MIN_FILTER, filter);
  1398.    _mesa_TexParameteri(tex->Target, GL_TEXTURE_MAG_FILTER, filter);
  1399.    _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  1400.  
  1401.    newTex = _mesa_meta_alloc_texture(tex, width, height, intFormat);
  1402.  
  1403.    /* copy framebuffer image to texture */
  1404.    if (newTex) {
  1405.       /* create new tex image */
  1406.       if (tex->Width == width && tex->Height == height) {
  1407.          /* create new tex with framebuffer data */
  1408.          _mesa_CopyTexImage2D(tex->Target, 0, tex->IntFormat,
  1409.                               srcX, srcY, width, height, 0);
  1410.       }
  1411.       else {
  1412.          /* create empty texture */
  1413.          _mesa_TexImage2D(tex->Target, 0, tex->IntFormat,
  1414.                           tex->Width, tex->Height, 0,
  1415.                           intFormat, GL_UNSIGNED_BYTE, NULL);
  1416.          /* load image */
  1417.          _mesa_CopyTexSubImage2D(tex->Target, 0,
  1418.                                  0, 0, srcX, srcY, width, height);
  1419.       }
  1420.    }
  1421.    else {
  1422.       /* replace existing tex image */
  1423.       _mesa_CopyTexSubImage2D(tex->Target, 0,
  1424.                               0, 0, srcX, srcY, width, height);
  1425.    }
  1426. }
  1427.  
  1428.  
  1429. /**
  1430.  * Setup/load texture for glDrawPixels.
  1431.  */
  1432. void
  1433. _mesa_meta_setup_drawpix_texture(struct gl_context *ctx,
  1434.                                  struct temp_texture *tex,
  1435.                                  GLboolean newTex,
  1436.                                  GLsizei width, GLsizei height,
  1437.                                  GLenum format, GLenum type,
  1438.                                  const GLvoid *pixels)
  1439. {
  1440.    _mesa_BindTexture(tex->Target, tex->TexObj);
  1441.    _mesa_TexParameteri(tex->Target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  1442.    _mesa_TexParameteri(tex->Target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  1443.    _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  1444.  
  1445.    /* copy pixel data to texture */
  1446.    if (newTex) {
  1447.       /* create new tex image */
  1448.       if (tex->Width == width && tex->Height == height) {
  1449.          /* create new tex and load image data */
  1450.          _mesa_TexImage2D(tex->Target, 0, tex->IntFormat,
  1451.                           tex->Width, tex->Height, 0, format, type, pixels);
  1452.       }
  1453.       else {
  1454.          struct gl_buffer_object *save_unpack_obj = NULL;
  1455.  
  1456.          _mesa_reference_buffer_object(ctx, &save_unpack_obj,
  1457.                                        ctx->Unpack.BufferObj);
  1458.          _mesa_BindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
  1459.          /* create empty texture */
  1460.          _mesa_TexImage2D(tex->Target, 0, tex->IntFormat,
  1461.                           tex->Width, tex->Height, 0, format, type, NULL);
  1462.          if (save_unpack_obj != NULL)
  1463.             _mesa_BindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB,
  1464.                                 save_unpack_obj->Name);
  1465.          /* load image */
  1466.          _mesa_TexSubImage2D(tex->Target, 0,
  1467.                              0, 0, width, height, format, type, pixels);
  1468.       }
  1469.    }
  1470.    else {
  1471.       /* replace existing tex image */
  1472.       _mesa_TexSubImage2D(tex->Target, 0,
  1473.                           0, 0, width, height, format, type, pixels);
  1474.    }
  1475. }
  1476.  
  1477. void
  1478. _mesa_meta_setup_ff_tnl_for_blit(GLuint *VAO, GLuint *VBO,
  1479.                                  unsigned texcoord_size)
  1480. {
  1481.    _mesa_meta_setup_vertex_objects(VAO, VBO, false, 2, texcoord_size, 0);
  1482.  
  1483.    /* setup projection matrix */
  1484.    _mesa_MatrixMode(GL_PROJECTION);
  1485.    _mesa_LoadIdentity();
  1486. }
  1487.  
  1488. /**
  1489.  * Meta implementation of ctx->Driver.Clear() in terms of polygon rendering.
  1490.  */
  1491. void
  1492. _mesa_meta_Clear(struct gl_context *ctx, GLbitfield buffers)
  1493. {
  1494.    meta_clear(ctx, buffers, false);
  1495. }
  1496.  
  1497. void
  1498. _mesa_meta_glsl_Clear(struct gl_context *ctx, GLbitfield buffers)
  1499. {
  1500.    meta_clear(ctx, buffers, true);
  1501. }
  1502.  
  1503. static void
  1504. meta_glsl_clear_init(struct gl_context *ctx, struct clear_state *clear)
  1505. {
  1506.    const char *vs_source =
  1507.       "#extension GL_AMD_vertex_shader_layer : enable\n"
  1508.       "#extension GL_ARB_draw_instanced : enable\n"
  1509.       "attribute vec4 position;\n"
  1510.       "void main()\n"
  1511.       "{\n"
  1512.       "#ifdef GL_AMD_vertex_shader_layer\n"
  1513.       "   gl_Layer = gl_InstanceID;\n"
  1514.       "#endif\n"
  1515.       "   gl_Position = position;\n"
  1516.       "}\n";
  1517.    const char *fs_source =
  1518.       "uniform vec4 color;\n"
  1519.       "void main()\n"
  1520.       "{\n"
  1521.       "   gl_FragColor = color;\n"
  1522.       "}\n";
  1523.    GLuint vs, fs;
  1524.    bool has_integer_textures;
  1525.  
  1526.    _mesa_meta_setup_vertex_objects(&clear->VAO, &clear->VBO, true, 3, 0, 0);
  1527.  
  1528.    if (clear->ShaderProg != 0)
  1529.       return;
  1530.  
  1531.    vs = _mesa_CreateShader(GL_VERTEX_SHADER);
  1532.    _mesa_ShaderSource(vs, 1, &vs_source, NULL);
  1533.    _mesa_CompileShader(vs);
  1534.  
  1535.    fs = _mesa_CreateShader(GL_FRAGMENT_SHADER);
  1536.    _mesa_ShaderSource(fs, 1, &fs_source, NULL);
  1537.    _mesa_CompileShader(fs);
  1538.  
  1539.    clear->ShaderProg = _mesa_CreateProgram();
  1540.    _mesa_AttachShader(clear->ShaderProg, fs);
  1541.    _mesa_DeleteShader(fs);
  1542.    _mesa_AttachShader(clear->ShaderProg, vs);
  1543.    _mesa_DeleteShader(vs);
  1544.    _mesa_BindAttribLocation(clear->ShaderProg, 0, "position");
  1545.    _mesa_ObjectLabel(GL_PROGRAM, clear->ShaderProg, -1, "meta clear");
  1546.    _mesa_LinkProgram(clear->ShaderProg);
  1547.  
  1548.    clear->ColorLocation = _mesa_GetUniformLocation(clear->ShaderProg, "color");
  1549.  
  1550.    has_integer_textures = _mesa_is_gles3(ctx) ||
  1551.       (_mesa_is_desktop_gl(ctx) && ctx->Const.GLSLVersion >= 130);
  1552.  
  1553.    if (has_integer_textures) {
  1554.       void *shader_source_mem_ctx = ralloc_context(NULL);
  1555.       const char *vs_int_source =
  1556.          ralloc_asprintf(shader_source_mem_ctx,
  1557.                          "#version 130\n"
  1558.                          "#extension GL_AMD_vertex_shader_layer : enable\n"
  1559.                          "#extension GL_ARB_draw_instanced : enable\n"
  1560.                          "in vec4 position;\n"
  1561.                          "void main()\n"
  1562.                          "{\n"
  1563.                          "#ifdef GL_AMD_vertex_shader_layer\n"
  1564.                          "   gl_Layer = gl_InstanceID;\n"
  1565.                          "#endif\n"
  1566.                          "   gl_Position = position;\n"
  1567.                          "}\n");
  1568.       const char *fs_int_source =
  1569.          ralloc_asprintf(shader_source_mem_ctx,
  1570.                          "#version 130\n"
  1571.                          "uniform ivec4 color;\n"
  1572.                          "out ivec4 out_color;\n"
  1573.                          "\n"
  1574.                          "void main()\n"
  1575.                          "{\n"
  1576.                          "   out_color = color;\n"
  1577.                          "}\n");
  1578.  
  1579.       vs = _mesa_meta_compile_shader_with_debug(ctx, GL_VERTEX_SHADER,
  1580.                                                 vs_int_source);
  1581.       fs = _mesa_meta_compile_shader_with_debug(ctx, GL_FRAGMENT_SHADER,
  1582.                                                 fs_int_source);
  1583.       ralloc_free(shader_source_mem_ctx);
  1584.  
  1585.       clear->IntegerShaderProg = _mesa_CreateProgram();
  1586.       _mesa_AttachShader(clear->IntegerShaderProg, fs);
  1587.       _mesa_DeleteShader(fs);
  1588.       _mesa_AttachShader(clear->IntegerShaderProg, vs);
  1589.       _mesa_DeleteShader(vs);
  1590.       _mesa_BindAttribLocation(clear->IntegerShaderProg, 0, "position");
  1591.  
  1592.       /* Note that user-defined out attributes get automatically assigned
  1593.        * locations starting from 0, so we don't need to explicitly
  1594.        * BindFragDataLocation to 0.
  1595.        */
  1596.  
  1597.       _mesa_ObjectLabel(GL_PROGRAM, clear->IntegerShaderProg, -1,
  1598.                         "integer clear");
  1599.       _mesa_meta_link_program_with_debug(ctx, clear->IntegerShaderProg);
  1600.  
  1601.       clear->IntegerColorLocation =
  1602.          _mesa_GetUniformLocation(clear->IntegerShaderProg, "color");
  1603.    }
  1604. }
  1605.  
  1606. static void
  1607. meta_glsl_clear_cleanup(struct clear_state *clear)
  1608. {
  1609.    if (clear->VAO == 0)
  1610.       return;
  1611.    _mesa_DeleteVertexArrays(1, &clear->VAO);
  1612.    clear->VAO = 0;
  1613.    _mesa_DeleteBuffers(1, &clear->VBO);
  1614.    clear->VBO = 0;
  1615.    _mesa_DeleteProgram(clear->ShaderProg);
  1616.    clear->ShaderProg = 0;
  1617.  
  1618.    if (clear->IntegerShaderProg) {
  1619.       _mesa_DeleteProgram(clear->IntegerShaderProg);
  1620.       clear->IntegerShaderProg = 0;
  1621.    }
  1622. }
  1623.  
  1624. /**
  1625.  * Given a bitfield of BUFFER_BIT_x draw buffers, call glDrawBuffers to
  1626.  * set GL to only draw to those buffers.
  1627.  *
  1628.  * Since the bitfield has no associated order, the assignment of draw buffer
  1629.  * indices to color attachment indices is rather arbitrary.
  1630.  */
  1631. void
  1632. _mesa_meta_drawbuffers_from_bitfield(GLbitfield bits)
  1633. {
  1634.    GLenum enums[MAX_DRAW_BUFFERS];
  1635.    int i = 0;
  1636.    int n;
  1637.  
  1638.    /* This function is only legal for color buffer bitfields. */
  1639.    assert((bits & ~BUFFER_BITS_COLOR) == 0);
  1640.  
  1641.    /* Make sure we don't overflow any arrays. */
  1642.    assert(_mesa_bitcount(bits) <= MAX_DRAW_BUFFERS);
  1643.  
  1644.    enums[0] = GL_NONE;
  1645.  
  1646.    if (bits & BUFFER_BIT_FRONT_LEFT)
  1647.       enums[i++] = GL_FRONT_LEFT;
  1648.  
  1649.    if (bits & BUFFER_BIT_FRONT_RIGHT)
  1650.       enums[i++] = GL_FRONT_RIGHT;
  1651.  
  1652.    if (bits & BUFFER_BIT_BACK_LEFT)
  1653.       enums[i++] = GL_BACK_LEFT;
  1654.  
  1655.    if (bits & BUFFER_BIT_BACK_RIGHT)
  1656.       enums[i++] = GL_BACK_RIGHT;
  1657.  
  1658.    for (n = 0; n < MAX_COLOR_ATTACHMENTS; n++) {
  1659.       if (bits & (1 << (BUFFER_COLOR0 + n)))
  1660.          enums[i++] = GL_COLOR_ATTACHMENT0 + n;
  1661.    }
  1662.  
  1663.    _mesa_DrawBuffers(i, enums);
  1664. }
  1665.  
  1666. /**
  1667.  * Meta implementation of ctx->Driver.Clear() in terms of polygon rendering.
  1668.  */
  1669. static void
  1670. meta_clear(struct gl_context *ctx, GLbitfield buffers, bool glsl)
  1671. {
  1672.    struct clear_state *clear = &ctx->Meta->Clear;
  1673.    GLbitfield metaSave;
  1674.    const GLuint stencilMax = (1 << ctx->DrawBuffer->Visual.stencilBits) - 1;
  1675.    struct gl_framebuffer *fb = ctx->DrawBuffer;
  1676.    float x0, y0, x1, y1, z;
  1677.    struct vertex verts[4];
  1678.    int i;
  1679.  
  1680.    metaSave = (MESA_META_ALPHA_TEST |
  1681.                MESA_META_BLEND |
  1682.                MESA_META_DEPTH_TEST |
  1683.                MESA_META_RASTERIZATION |
  1684.                MESA_META_SHADER |
  1685.                MESA_META_STENCIL_TEST |
  1686.                MESA_META_VERTEX |
  1687.                MESA_META_VIEWPORT |
  1688.                MESA_META_CLIP |
  1689.                MESA_META_CLAMP_FRAGMENT_COLOR |
  1690.                MESA_META_MULTISAMPLE |
  1691.                MESA_META_OCCLUSION_QUERY);
  1692.  
  1693.    if (!glsl) {
  1694.       metaSave |= MESA_META_FOG |
  1695.                   MESA_META_PIXEL_TRANSFER |
  1696.                   MESA_META_TRANSFORM |
  1697.                   MESA_META_TEXTURE |
  1698.                   MESA_META_CLAMP_VERTEX_COLOR |
  1699.                   MESA_META_SELECT_FEEDBACK;
  1700.    }
  1701.  
  1702.    if (buffers & BUFFER_BITS_COLOR) {
  1703.       metaSave |= MESA_META_DRAW_BUFFERS;
  1704.    } else {
  1705.       /* We'll use colormask to disable color writes.  Otherwise,
  1706.        * respect color mask
  1707.        */
  1708.       metaSave |= MESA_META_COLOR_MASK;
  1709.    }
  1710.  
  1711.    _mesa_meta_begin(ctx, metaSave);
  1712.  
  1713.    if (glsl) {
  1714.       meta_glsl_clear_init(ctx, clear);
  1715.  
  1716.       x0 = ((float) fb->_Xmin / fb->Width)  * 2.0f - 1.0f;
  1717.       y0 = ((float) fb->_Ymin / fb->Height) * 2.0f - 1.0f;
  1718.       x1 = ((float) fb->_Xmax / fb->Width)  * 2.0f - 1.0f;
  1719.       y1 = ((float) fb->_Ymax / fb->Height) * 2.0f - 1.0f;
  1720.       z = -invert_z(ctx->Depth.Clear);
  1721.    } else {
  1722.       _mesa_meta_setup_vertex_objects(&clear->VAO, &clear->VBO, false, 3, 0, 4);
  1723.  
  1724.       x0 = (float) fb->_Xmin;
  1725.       y0 = (float) fb->_Ymin;
  1726.       x1 = (float) fb->_Xmax;
  1727.       y1 = (float) fb->_Ymax;
  1728.       z = invert_z(ctx->Depth.Clear);
  1729.    }
  1730.  
  1731.    if (fb->_IntegerColor) {
  1732.       assert(glsl);
  1733.       _mesa_UseProgram(clear->IntegerShaderProg);
  1734.       _mesa_Uniform4iv(clear->IntegerColorLocation, 1,
  1735.                           ctx->Color.ClearColor.i);
  1736.    } else if (glsl) {
  1737.       _mesa_UseProgram(clear->ShaderProg);
  1738.       _mesa_Uniform4fv(clear->ColorLocation, 1,
  1739.                           ctx->Color.ClearColor.f);
  1740.    }
  1741.  
  1742.    /* GL_COLOR_BUFFER_BIT */
  1743.    if (buffers & BUFFER_BITS_COLOR) {
  1744.       /* Only draw to the buffers we were asked to clear. */
  1745.       _mesa_meta_drawbuffers_from_bitfield(buffers & BUFFER_BITS_COLOR);
  1746.  
  1747.       /* leave colormask state as-is */
  1748.  
  1749.       /* Clears never have the color clamped. */
  1750.       if (ctx->Extensions.ARB_color_buffer_float)
  1751.          _mesa_ClampColor(GL_CLAMP_FRAGMENT_COLOR, GL_FALSE);
  1752.    }
  1753.    else {
  1754.       assert(metaSave & MESA_META_COLOR_MASK);
  1755.       _mesa_ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
  1756.    }
  1757.  
  1758.    /* GL_DEPTH_BUFFER_BIT */
  1759.    if (buffers & BUFFER_BIT_DEPTH) {
  1760.       _mesa_set_enable(ctx, GL_DEPTH_TEST, GL_TRUE);
  1761.       _mesa_DepthFunc(GL_ALWAYS);
  1762.       _mesa_DepthMask(GL_TRUE);
  1763.    }
  1764.    else {
  1765.       assert(!ctx->Depth.Test);
  1766.    }
  1767.  
  1768.    /* GL_STENCIL_BUFFER_BIT */
  1769.    if (buffers & BUFFER_BIT_STENCIL) {
  1770.       _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_TRUE);
  1771.       _mesa_StencilOpSeparate(GL_FRONT_AND_BACK,
  1772.                               GL_REPLACE, GL_REPLACE, GL_REPLACE);
  1773.       _mesa_StencilFuncSeparate(GL_FRONT_AND_BACK, GL_ALWAYS,
  1774.                                 ctx->Stencil.Clear & stencilMax,
  1775.                                 ctx->Stencil.WriteMask[0]);
  1776.    }
  1777.    else {
  1778.       assert(!ctx->Stencil.Enabled);
  1779.    }
  1780.  
  1781.    /* vertex positions */
  1782.    verts[0].x = x0;
  1783.    verts[0].y = y0;
  1784.    verts[0].z = z;
  1785.    verts[1].x = x1;
  1786.    verts[1].y = y0;
  1787.    verts[1].z = z;
  1788.    verts[2].x = x1;
  1789.    verts[2].y = y1;
  1790.    verts[2].z = z;
  1791.    verts[3].x = x0;
  1792.    verts[3].y = y1;
  1793.    verts[3].z = z;
  1794.  
  1795.    if (!glsl) {
  1796.       for (i = 0; i < 4; i++) {
  1797.          verts[i].r = ctx->Color.ClearColor.f[0];
  1798.          verts[i].g = ctx->Color.ClearColor.f[1];
  1799.          verts[i].b = ctx->Color.ClearColor.f[2];
  1800.          verts[i].a = ctx->Color.ClearColor.f[3];
  1801.       }
  1802.    }
  1803.  
  1804.    /* upload new vertex data */
  1805.    _mesa_BufferData(GL_ARRAY_BUFFER_ARB, sizeof(verts), verts,
  1806.                        GL_DYNAMIC_DRAW_ARB);
  1807.  
  1808.    /* draw quad(s) */
  1809.    if (fb->MaxNumLayers > 0) {
  1810.       _mesa_DrawArraysInstanced(GL_TRIANGLE_FAN, 0, 4, fb->MaxNumLayers);
  1811.    } else {
  1812.       _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
  1813.    }
  1814.  
  1815.    _mesa_meta_end(ctx);
  1816. }
  1817.  
  1818. /**
  1819.  * Meta implementation of ctx->Driver.CopyPixels() in terms
  1820.  * of texture mapping and polygon rendering and GLSL shaders.
  1821.  */
  1822. void
  1823. _mesa_meta_CopyPixels(struct gl_context *ctx, GLint srcX, GLint srcY,
  1824.                       GLsizei width, GLsizei height,
  1825.                       GLint dstX, GLint dstY, GLenum type)
  1826. {
  1827.    struct copypix_state *copypix = &ctx->Meta->CopyPix;
  1828.    struct temp_texture *tex = _mesa_meta_get_temp_texture(ctx);
  1829.    struct vertex verts[4];
  1830.  
  1831.    if (type != GL_COLOR ||
  1832.        ctx->_ImageTransferState ||
  1833.        ctx->Fog.Enabled ||
  1834.        width > tex->MaxSize ||
  1835.        height > tex->MaxSize) {
  1836.       /* XXX avoid this fallback */
  1837.       _swrast_CopyPixels(ctx, srcX, srcY, width, height, dstX, dstY, type);
  1838.       return;
  1839.    }
  1840.  
  1841.    /* Most GL state applies to glCopyPixels, but a there's a few things
  1842.     * we need to override:
  1843.     */
  1844.    _mesa_meta_begin(ctx, (MESA_META_RASTERIZATION |
  1845.                           MESA_META_SHADER |
  1846.                           MESA_META_TEXTURE |
  1847.                           MESA_META_TRANSFORM |
  1848.                           MESA_META_CLIP |
  1849.                           MESA_META_VERTEX |
  1850.                           MESA_META_VIEWPORT));
  1851.  
  1852.    _mesa_meta_setup_vertex_objects(&copypix->VAO, &copypix->VBO, false,
  1853.                                    3, 2, 0);
  1854.  
  1855.    /* Silence valgrind warnings about reading uninitialized stack. */
  1856.    memset(verts, 0, sizeof(verts));
  1857.  
  1858.    /* Alloc/setup texture */
  1859.    _mesa_meta_setup_copypix_texture(ctx, tex, srcX, srcY, width, height,
  1860.                                     GL_RGBA, GL_NEAREST);
  1861.  
  1862.    /* vertex positions, texcoords (after texture allocation!) */
  1863.    {
  1864.       const GLfloat dstX0 = (GLfloat) dstX;
  1865.       const GLfloat dstY0 = (GLfloat) dstY;
  1866.       const GLfloat dstX1 = dstX + width * ctx->Pixel.ZoomX;
  1867.       const GLfloat dstY1 = dstY + height * ctx->Pixel.ZoomY;
  1868.       const GLfloat z = invert_z(ctx->Current.RasterPos[2]);
  1869.  
  1870.       verts[0].x = dstX0;
  1871.       verts[0].y = dstY0;
  1872.       verts[0].z = z;
  1873.       verts[0].tex[0] = 0.0F;
  1874.       verts[0].tex[1] = 0.0F;
  1875.       verts[1].x = dstX1;
  1876.       verts[1].y = dstY0;
  1877.       verts[1].z = z;
  1878.       verts[1].tex[0] = tex->Sright;
  1879.       verts[1].tex[1] = 0.0F;
  1880.       verts[2].x = dstX1;
  1881.       verts[2].y = dstY1;
  1882.       verts[2].z = z;
  1883.       verts[2].tex[0] = tex->Sright;
  1884.       verts[2].tex[1] = tex->Ttop;
  1885.       verts[3].x = dstX0;
  1886.       verts[3].y = dstY1;
  1887.       verts[3].z = z;
  1888.       verts[3].tex[0] = 0.0F;
  1889.       verts[3].tex[1] = tex->Ttop;
  1890.  
  1891.       /* upload new vertex data */
  1892.       _mesa_BufferSubData(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
  1893.    }
  1894.  
  1895.    _mesa_set_enable(ctx, tex->Target, GL_TRUE);
  1896.  
  1897.    /* draw textured quad */
  1898.    _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
  1899.  
  1900.    _mesa_set_enable(ctx, tex->Target, GL_FALSE);
  1901.  
  1902.    _mesa_meta_end(ctx);
  1903. }
  1904.  
  1905. static void
  1906. meta_drawpix_cleanup(struct drawpix_state *drawpix)
  1907. {
  1908.    if (drawpix->VAO != 0) {
  1909.       _mesa_DeleteVertexArrays(1, &drawpix->VAO);
  1910.       drawpix->VAO = 0;
  1911.  
  1912.       _mesa_DeleteBuffers(1, &drawpix->VBO);
  1913.       drawpix->VBO = 0;
  1914.    }
  1915.  
  1916.    if (drawpix->StencilFP != 0) {
  1917.       _mesa_DeleteProgramsARB(1, &drawpix->StencilFP);
  1918.       drawpix->StencilFP = 0;
  1919.    }
  1920.  
  1921.    if (drawpix->DepthFP != 0) {
  1922.       _mesa_DeleteProgramsARB(1, &drawpix->DepthFP);
  1923.       drawpix->DepthFP = 0;
  1924.    }
  1925. }
  1926.  
  1927. /**
  1928.  * When the glDrawPixels() image size is greater than the max rectangle
  1929.  * texture size we use this function to break the glDrawPixels() image
  1930.  * into tiles which fit into the max texture size.
  1931.  */
  1932. static void
  1933. tiled_draw_pixels(struct gl_context *ctx,
  1934.                   GLint tileSize,
  1935.                   GLint x, GLint y, GLsizei width, GLsizei height,
  1936.                   GLenum format, GLenum type,
  1937.                   const struct gl_pixelstore_attrib *unpack,
  1938.                   const GLvoid *pixels)
  1939. {
  1940.    struct gl_pixelstore_attrib tileUnpack = *unpack;
  1941.    GLint i, j;
  1942.  
  1943.    if (tileUnpack.RowLength == 0)
  1944.       tileUnpack.RowLength = width;
  1945.  
  1946.    for (i = 0; i < width; i += tileSize) {
  1947.       const GLint tileWidth = MIN2(tileSize, width - i);
  1948.       const GLint tileX = (GLint) (x + i * ctx->Pixel.ZoomX);
  1949.  
  1950.       tileUnpack.SkipPixels = unpack->SkipPixels + i;
  1951.  
  1952.       for (j = 0; j < height; j += tileSize) {
  1953.          const GLint tileHeight = MIN2(tileSize, height - j);
  1954.          const GLint tileY = (GLint) (y + j * ctx->Pixel.ZoomY);
  1955.  
  1956.          tileUnpack.SkipRows = unpack->SkipRows + j;
  1957.  
  1958.          _mesa_meta_DrawPixels(ctx, tileX, tileY, tileWidth, tileHeight,
  1959.                                format, type, &tileUnpack, pixels);
  1960.       }
  1961.    }
  1962. }
  1963.  
  1964.  
  1965. /**
  1966.  * One-time init for drawing stencil pixels.
  1967.  */
  1968. static void
  1969. init_draw_stencil_pixels(struct gl_context *ctx)
  1970. {
  1971.    /* This program is run eight times, once for each stencil bit.
  1972.     * The stencil values to draw are found in an 8-bit alpha texture.
  1973.     * We read the texture/stencil value and test if bit 'b' is set.
  1974.     * If the bit is not set, use KIL to kill the fragment.
  1975.     * Finally, we use the stencil test to update the stencil buffer.
  1976.     *
  1977.     * The basic algorithm for checking if a bit is set is:
  1978.     *   if (is_odd(value / (1 << bit)))
  1979.     *      result is one (or non-zero).
  1980.     *   else
  1981.     *      result is zero.
  1982.     * The program parameter contains three values:
  1983.     *   parm.x = 255 / (1 << bit)
  1984.     *   parm.y = 0.5
  1985.     *   parm.z = 0.0
  1986.     */
  1987.    static const char *program =
  1988.       "!!ARBfp1.0\n"
  1989.       "PARAM parm = program.local[0]; \n"
  1990.       "TEMP t; \n"
  1991.       "TEX t, fragment.texcoord[0], texture[0], %s; \n"   /* NOTE %s here! */
  1992.       "# t = t * 255 / bit \n"
  1993.       "MUL t.x, t.a, parm.x; \n"
  1994.       "# t = (int) t \n"
  1995.       "FRC t.y, t.x; \n"
  1996.       "SUB t.x, t.x, t.y; \n"
  1997.       "# t = t * 0.5 \n"
  1998.       "MUL t.x, t.x, parm.y; \n"
  1999.       "# t = fract(t.x) \n"
  2000.       "FRC t.x, t.x; # if t.x != 0, then the bit is set \n"
  2001.       "# t.x = (t.x == 0 ? 1 : 0) \n"
  2002.       "SGE t.x, -t.x, parm.z; \n"
  2003.       "KIL -t.x; \n"
  2004.       "# for debug only \n"
  2005.       "#MOV result.color, t.x; \n"
  2006.       "END \n";
  2007.    char program2[1000];
  2008.    struct drawpix_state *drawpix = &ctx->Meta->DrawPix;
  2009.    struct temp_texture *tex = _mesa_meta_get_temp_texture(ctx);
  2010.    const char *texTarget;
  2011.  
  2012.    assert(drawpix->StencilFP == 0);
  2013.  
  2014.    /* replace %s with "RECT" or "2D" */
  2015.    assert(strlen(program) + 4 < sizeof(program2));
  2016.    if (tex->Target == GL_TEXTURE_RECTANGLE)
  2017.       texTarget = "RECT";
  2018.    else
  2019.       texTarget = "2D";
  2020.    _mesa_snprintf(program2, sizeof(program2), program, texTarget);
  2021.  
  2022.    _mesa_GenProgramsARB(1, &drawpix->StencilFP);
  2023.    _mesa_BindProgramARB(GL_FRAGMENT_PROGRAM_ARB, drawpix->StencilFP);
  2024.    _mesa_ProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
  2025.                           strlen(program2), (const GLubyte *) program2);
  2026. }
  2027.  
  2028.  
  2029. /**
  2030.  * One-time init for drawing depth pixels.
  2031.  */
  2032. static void
  2033. init_draw_depth_pixels(struct gl_context *ctx)
  2034. {
  2035.    static const char *program =
  2036.       "!!ARBfp1.0\n"
  2037.       "PARAM color = program.local[0]; \n"
  2038.       "TEX result.depth, fragment.texcoord[0], texture[0], %s; \n"
  2039.       "MOV result.color, color; \n"
  2040.       "END \n";
  2041.    char program2[200];
  2042.    struct drawpix_state *drawpix = &ctx->Meta->DrawPix;
  2043.    struct temp_texture *tex = _mesa_meta_get_temp_texture(ctx);
  2044.    const char *texTarget;
  2045.  
  2046.    assert(drawpix->DepthFP == 0);
  2047.  
  2048.    /* replace %s with "RECT" or "2D" */
  2049.    assert(strlen(program) + 4 < sizeof(program2));
  2050.    if (tex->Target == GL_TEXTURE_RECTANGLE)
  2051.       texTarget = "RECT";
  2052.    else
  2053.       texTarget = "2D";
  2054.    _mesa_snprintf(program2, sizeof(program2), program, texTarget);
  2055.  
  2056.    _mesa_GenProgramsARB(1, &drawpix->DepthFP);
  2057.    _mesa_BindProgramARB(GL_FRAGMENT_PROGRAM_ARB, drawpix->DepthFP);
  2058.    _mesa_ProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
  2059.                           strlen(program2), (const GLubyte *) program2);
  2060. }
  2061.  
  2062.  
  2063. /**
  2064.  * Meta implementation of ctx->Driver.DrawPixels() in terms
  2065.  * of texture mapping and polygon rendering.
  2066.  */
  2067. void
  2068. _mesa_meta_DrawPixels(struct gl_context *ctx,
  2069.                       GLint x, GLint y, GLsizei width, GLsizei height,
  2070.                       GLenum format, GLenum type,
  2071.                       const struct gl_pixelstore_attrib *unpack,
  2072.                       const GLvoid *pixels)
  2073. {
  2074.    struct drawpix_state *drawpix = &ctx->Meta->DrawPix;
  2075.    struct temp_texture *tex = _mesa_meta_get_temp_texture(ctx);
  2076.    const struct gl_pixelstore_attrib unpackSave = ctx->Unpack;
  2077.    const GLuint origStencilMask = ctx->Stencil.WriteMask[0];
  2078.    struct vertex verts[4];
  2079.    GLenum texIntFormat;
  2080.    GLboolean fallback, newTex;
  2081.    GLbitfield metaExtraSave = 0x0;
  2082.  
  2083.    /*
  2084.     * Determine if we can do the glDrawPixels with texture mapping.
  2085.     */
  2086.    fallback = GL_FALSE;
  2087.    if (ctx->Fog.Enabled) {
  2088.       fallback = GL_TRUE;
  2089.    }
  2090.  
  2091.    if (_mesa_is_color_format(format)) {
  2092.       /* use more compact format when possible */
  2093.       /* XXX disable special case for GL_LUMINANCE for now to work around
  2094.        * apparent i965 driver bug (see bug #23670).
  2095.        */
  2096.       if (/*format == GL_LUMINANCE ||*/ format == GL_LUMINANCE_ALPHA)
  2097.          texIntFormat = format;
  2098.       else
  2099.          texIntFormat = GL_RGBA;
  2100.  
  2101.       /* If we're not supposed to clamp the resulting color, then just
  2102.        * promote our texture to fully float.  We could do better by
  2103.        * just going for the matching set of channels, in floating
  2104.        * point.
  2105.        */
  2106.       if (ctx->Color.ClampFragmentColor != GL_TRUE &&
  2107.           ctx->Extensions.ARB_texture_float)
  2108.          texIntFormat = GL_RGBA32F;
  2109.    }
  2110.    else if (_mesa_is_stencil_format(format)) {
  2111.       if (ctx->Extensions.ARB_fragment_program &&
  2112.           ctx->Pixel.IndexShift == 0 &&
  2113.           ctx->Pixel.IndexOffset == 0 &&
  2114.           type == GL_UNSIGNED_BYTE) {
  2115.          /* We'll store stencil as alpha.  This only works for GLubyte
  2116.           * image data because of how incoming values are mapped to alpha
  2117.           * in [0,1].
  2118.           */
  2119.          texIntFormat = GL_ALPHA;
  2120.          metaExtraSave = (MESA_META_COLOR_MASK |
  2121.                           MESA_META_DEPTH_TEST |
  2122.                           MESA_META_PIXEL_TRANSFER |
  2123.                           MESA_META_SHADER |
  2124.                           MESA_META_STENCIL_TEST);
  2125.       }
  2126.       else {
  2127.          fallback = GL_TRUE;
  2128.       }
  2129.    }
  2130.    else if (_mesa_is_depth_format(format)) {
  2131.       if (ctx->Extensions.ARB_depth_texture &&
  2132.           ctx->Extensions.ARB_fragment_program) {
  2133.          texIntFormat = GL_DEPTH_COMPONENT;
  2134.          metaExtraSave = (MESA_META_SHADER);
  2135.       }
  2136.       else {
  2137.          fallback = GL_TRUE;
  2138.       }
  2139.    }
  2140.    else {
  2141.       fallback = GL_TRUE;
  2142.    }
  2143.  
  2144.    if (fallback) {
  2145.       _swrast_DrawPixels(ctx, x, y, width, height,
  2146.                          format, type, unpack, pixels);
  2147.       return;
  2148.    }
  2149.  
  2150.    /*
  2151.     * Check image size against max texture size, draw as tiles if needed.
  2152.     */
  2153.    if (width > tex->MaxSize || height > tex->MaxSize) {
  2154.       tiled_draw_pixels(ctx, tex->MaxSize, x, y, width, height,
  2155.                         format, type, unpack, pixels);
  2156.       return;
  2157.    }
  2158.  
  2159.    /* Most GL state applies to glDrawPixels (like blending, stencil, etc),
  2160.     * but a there's a few things we need to override:
  2161.     */
  2162.    _mesa_meta_begin(ctx, (MESA_META_RASTERIZATION |
  2163.                           MESA_META_SHADER |
  2164.                           MESA_META_TEXTURE |
  2165.                           MESA_META_TRANSFORM |
  2166.                           MESA_META_CLIP |
  2167.                           MESA_META_VERTEX |
  2168.                           MESA_META_VIEWPORT |
  2169.                           metaExtraSave));
  2170.  
  2171.    newTex = _mesa_meta_alloc_texture(tex, width, height, texIntFormat);
  2172.  
  2173.    _mesa_meta_setup_vertex_objects(&drawpix->VAO, &drawpix->VBO, false,
  2174.                                    3, 2, 0);
  2175.  
  2176.    /* Silence valgrind warnings about reading uninitialized stack. */
  2177.    memset(verts, 0, sizeof(verts));
  2178.  
  2179.    /* vertex positions, texcoords (after texture allocation!) */
  2180.    {
  2181.       const GLfloat x0 = (GLfloat) x;
  2182.       const GLfloat y0 = (GLfloat) y;
  2183.       const GLfloat x1 = x + width * ctx->Pixel.ZoomX;
  2184.       const GLfloat y1 = y + height * ctx->Pixel.ZoomY;
  2185.       const GLfloat z = invert_z(ctx->Current.RasterPos[2]);
  2186.  
  2187.       verts[0].x = x0;
  2188.       verts[0].y = y0;
  2189.       verts[0].z = z;
  2190.       verts[0].tex[0] = 0.0F;
  2191.       verts[0].tex[1] = 0.0F;
  2192.       verts[1].x = x1;
  2193.       verts[1].y = y0;
  2194.       verts[1].z = z;
  2195.       verts[1].tex[0] = tex->Sright;
  2196.       verts[1].tex[1] = 0.0F;
  2197.       verts[2].x = x1;
  2198.       verts[2].y = y1;
  2199.       verts[2].z = z;
  2200.       verts[2].tex[0] = tex->Sright;
  2201.       verts[2].tex[1] = tex->Ttop;
  2202.       verts[3].x = x0;
  2203.       verts[3].y = y1;
  2204.       verts[3].z = z;
  2205.       verts[3].tex[0] = 0.0F;
  2206.       verts[3].tex[1] = tex->Ttop;
  2207.    }
  2208.  
  2209.    /* upload new vertex data */
  2210.    _mesa_BufferData(GL_ARRAY_BUFFER_ARB, sizeof(verts),
  2211.                        verts, GL_DYNAMIC_DRAW_ARB);
  2212.  
  2213.    /* set given unpack params */
  2214.    ctx->Unpack = *unpack;
  2215.  
  2216.    _mesa_set_enable(ctx, tex->Target, GL_TRUE);
  2217.  
  2218.    if (_mesa_is_stencil_format(format)) {
  2219.       /* Drawing stencil */
  2220.       GLint bit;
  2221.  
  2222.       if (!drawpix->StencilFP)
  2223.          init_draw_stencil_pixels(ctx);
  2224.  
  2225.       _mesa_meta_setup_drawpix_texture(ctx, tex, newTex, width, height,
  2226.                                        GL_ALPHA, type, pixels);
  2227.  
  2228.       _mesa_ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
  2229.  
  2230.       _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_TRUE);
  2231.  
  2232.       /* set all stencil bits to 0 */
  2233.       _mesa_StencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
  2234.       _mesa_StencilFunc(GL_ALWAYS, 0, 255);
  2235.       _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
  2236.  
  2237.       /* set stencil bits to 1 where needed */
  2238.       _mesa_StencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
  2239.  
  2240.       _mesa_BindProgramARB(GL_FRAGMENT_PROGRAM_ARB, drawpix->StencilFP);
  2241.       _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_TRUE);
  2242.  
  2243.       for (bit = 0; bit < ctx->DrawBuffer->Visual.stencilBits; bit++) {
  2244.          const GLuint mask = 1 << bit;
  2245.          if (mask & origStencilMask) {
  2246.             _mesa_StencilFunc(GL_ALWAYS, mask, mask);
  2247.             _mesa_StencilMask(mask);
  2248.  
  2249.             _mesa_ProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 0,
  2250.                                              255.0f / mask, 0.5f, 0.0f, 0.0f);
  2251.  
  2252.             _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
  2253.          }
  2254.       }
  2255.    }
  2256.    else if (_mesa_is_depth_format(format)) {
  2257.       /* Drawing depth */
  2258.       if (!drawpix->DepthFP)
  2259.          init_draw_depth_pixels(ctx);
  2260.  
  2261.       _mesa_BindProgramARB(GL_FRAGMENT_PROGRAM_ARB, drawpix->DepthFP);
  2262.       _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_TRUE);
  2263.  
  2264.       /* polygon color = current raster color */
  2265.       _mesa_ProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 0,
  2266.                                         ctx->Current.RasterColor);
  2267.  
  2268.       _mesa_meta_setup_drawpix_texture(ctx, tex, newTex, width, height,
  2269.                                        format, type, pixels);
  2270.  
  2271.       _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
  2272.    }
  2273.    else {
  2274.       /* Drawing RGBA */
  2275.       _mesa_meta_setup_drawpix_texture(ctx, tex, newTex, width, height,
  2276.                                        format, type, pixels);
  2277.       _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
  2278.    }
  2279.  
  2280.    _mesa_set_enable(ctx, tex->Target, GL_FALSE);
  2281.  
  2282.    /* restore unpack params */
  2283.    ctx->Unpack = unpackSave;
  2284.  
  2285.    _mesa_meta_end(ctx);
  2286. }
  2287.  
  2288. static GLboolean
  2289. alpha_test_raster_color(struct gl_context *ctx)
  2290. {
  2291.    GLfloat alpha = ctx->Current.RasterColor[ACOMP];
  2292.    GLfloat ref = ctx->Color.AlphaRef;
  2293.  
  2294.    switch (ctx->Color.AlphaFunc) {
  2295.       case GL_NEVER:
  2296.          return GL_FALSE;
  2297.       case GL_LESS:
  2298.          return alpha < ref;
  2299.       case GL_EQUAL:
  2300.          return alpha == ref;
  2301.       case GL_LEQUAL:
  2302.          return alpha <= ref;
  2303.       case GL_GREATER:
  2304.          return alpha > ref;
  2305.       case GL_NOTEQUAL:
  2306.          return alpha != ref;
  2307.       case GL_GEQUAL:
  2308.          return alpha >= ref;
  2309.       case GL_ALWAYS:
  2310.          return GL_TRUE;
  2311.       default:
  2312.          assert(0);
  2313.          return GL_FALSE;
  2314.    }
  2315. }
  2316.  
  2317. /**
  2318.  * Do glBitmap with a alpha texture quad.  Use the alpha test to cull
  2319.  * the 'off' bits.  A bitmap cache as in the gallium/mesa state
  2320.  * tracker would improve performance a lot.
  2321.  */
  2322. void
  2323. _mesa_meta_Bitmap(struct gl_context *ctx,
  2324.                   GLint x, GLint y, GLsizei width, GLsizei height,
  2325.                   const struct gl_pixelstore_attrib *unpack,
  2326.                   const GLubyte *bitmap1)
  2327. {
  2328.    struct bitmap_state *bitmap = &ctx->Meta->Bitmap;
  2329.    struct temp_texture *tex = get_bitmap_temp_texture(ctx);
  2330.    const GLenum texIntFormat = GL_ALPHA;
  2331.    const struct gl_pixelstore_attrib unpackSave = *unpack;
  2332.    GLubyte fg, bg;
  2333.    struct vertex verts[4];
  2334.    GLboolean newTex;
  2335.    GLubyte *bitmap8;
  2336.  
  2337.    /*
  2338.     * Check if swrast fallback is needed.
  2339.     */
  2340.    if (ctx->_ImageTransferState ||
  2341.        ctx->FragmentProgram._Enabled ||
  2342.        ctx->Fog.Enabled ||
  2343.        ctx->Texture._MaxEnabledTexImageUnit != -1 ||
  2344.        width > tex->MaxSize ||
  2345.        height > tex->MaxSize) {
  2346.       _swrast_Bitmap(ctx, x, y, width, height, unpack, bitmap1);
  2347.       return;
  2348.    }
  2349.  
  2350.    if (ctx->Color.AlphaEnabled && !alpha_test_raster_color(ctx))
  2351.       return;
  2352.  
  2353.    /* Most GL state applies to glBitmap (like blending, stencil, etc),
  2354.     * but a there's a few things we need to override:
  2355.     */
  2356.    _mesa_meta_begin(ctx, (MESA_META_ALPHA_TEST |
  2357.                           MESA_META_PIXEL_STORE |
  2358.                           MESA_META_RASTERIZATION |
  2359.                           MESA_META_SHADER |
  2360.                           MESA_META_TEXTURE |
  2361.                           MESA_META_TRANSFORM |
  2362.                           MESA_META_CLIP |
  2363.                           MESA_META_VERTEX |
  2364.                           MESA_META_VIEWPORT));
  2365.  
  2366.    _mesa_meta_setup_vertex_objects(&bitmap->VAO, &bitmap->VBO, false, 3, 2, 4);
  2367.  
  2368.    newTex = _mesa_meta_alloc_texture(tex, width, height, texIntFormat);
  2369.  
  2370.    /* Silence valgrind warnings about reading uninitialized stack. */
  2371.    memset(verts, 0, sizeof(verts));
  2372.  
  2373.    /* vertex positions, texcoords, colors (after texture allocation!) */
  2374.    {
  2375.       const GLfloat x0 = (GLfloat) x;
  2376.       const GLfloat y0 = (GLfloat) y;
  2377.       const GLfloat x1 = (GLfloat) (x + width);
  2378.       const GLfloat y1 = (GLfloat) (y + height);
  2379.       const GLfloat z = invert_z(ctx->Current.RasterPos[2]);
  2380.       GLuint i;
  2381.  
  2382.       verts[0].x = x0;
  2383.       verts[0].y = y0;
  2384.       verts[0].z = z;
  2385.       verts[0].tex[0] = 0.0F;
  2386.       verts[0].tex[1] = 0.0F;
  2387.       verts[1].x = x1;
  2388.       verts[1].y = y0;
  2389.       verts[1].z = z;
  2390.       verts[1].tex[0] = tex->Sright;
  2391.       verts[1].tex[1] = 0.0F;
  2392.       verts[2].x = x1;
  2393.       verts[2].y = y1;
  2394.       verts[2].z = z;
  2395.       verts[2].tex[0] = tex->Sright;
  2396.       verts[2].tex[1] = tex->Ttop;
  2397.       verts[3].x = x0;
  2398.       verts[3].y = y1;
  2399.       verts[3].z = z;
  2400.       verts[3].tex[0] = 0.0F;
  2401.       verts[3].tex[1] = tex->Ttop;
  2402.  
  2403.       for (i = 0; i < 4; i++) {
  2404.          verts[i].r = ctx->Current.RasterColor[0];
  2405.          verts[i].g = ctx->Current.RasterColor[1];
  2406.          verts[i].b = ctx->Current.RasterColor[2];
  2407.          verts[i].a = ctx->Current.RasterColor[3];
  2408.       }
  2409.  
  2410.       /* upload new vertex data */
  2411.       _mesa_BufferSubData(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
  2412.    }
  2413.  
  2414.    /* choose different foreground/background alpha values */
  2415.    CLAMPED_FLOAT_TO_UBYTE(fg, ctx->Current.RasterColor[ACOMP]);
  2416.    bg = (fg > 127 ? 0 : 255);
  2417.  
  2418.    bitmap1 = _mesa_map_pbo_source(ctx, &unpackSave, bitmap1);
  2419.    if (!bitmap1) {
  2420.       _mesa_meta_end(ctx);
  2421.       return;
  2422.    }
  2423.  
  2424.    bitmap8 = malloc(width * height);
  2425.    if (bitmap8) {
  2426.       memset(bitmap8, bg, width * height);
  2427.       _mesa_expand_bitmap(width, height, &unpackSave, bitmap1,
  2428.                           bitmap8, width, fg);
  2429.  
  2430.       _mesa_set_enable(ctx, tex->Target, GL_TRUE);
  2431.  
  2432.       _mesa_set_enable(ctx, GL_ALPHA_TEST, GL_TRUE);
  2433.       _mesa_AlphaFunc(GL_NOTEQUAL, UBYTE_TO_FLOAT(bg));
  2434.  
  2435.       _mesa_meta_setup_drawpix_texture(ctx, tex, newTex, width, height,
  2436.                                        GL_ALPHA, GL_UNSIGNED_BYTE, bitmap8);
  2437.  
  2438.       _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
  2439.  
  2440.       _mesa_set_enable(ctx, tex->Target, GL_FALSE);
  2441.  
  2442.       free(bitmap8);
  2443.    }
  2444.  
  2445.    _mesa_unmap_pbo_source(ctx, &unpackSave);
  2446.  
  2447.    _mesa_meta_end(ctx);
  2448. }
  2449.  
  2450. /**
  2451.  * Compute the texture coordinates for the four vertices of a quad for
  2452.  * drawing a 2D texture image or slice of a cube/3D texture.
  2453.  * \param faceTarget  GL_TEXTURE_1D/2D/3D or cube face name
  2454.  * \param slice  slice of a 1D/2D array texture or 3D texture
  2455.  * \param width  width of the texture image
  2456.  * \param height  height of the texture image
  2457.  * \param coords0/1/2/3  returns the computed texcoords
  2458.  */
  2459. void
  2460. _mesa_meta_setup_texture_coords(GLenum faceTarget,
  2461.                                 GLint slice,
  2462.                                 GLint width,
  2463.                                 GLint height,
  2464.                                 GLint depth,
  2465.                                 GLfloat coords0[4],
  2466.                                 GLfloat coords1[4],
  2467.                                 GLfloat coords2[4],
  2468.                                 GLfloat coords3[4])
  2469. {
  2470.    static const GLfloat st[4][2] = {
  2471.       {0.0f, 0.0f}, {1.0f, 0.0f}, {1.0f, 1.0f}, {0.0f, 1.0f}
  2472.    };
  2473.    GLuint i;
  2474.    GLfloat r;
  2475.  
  2476.    if (faceTarget == GL_TEXTURE_CUBE_MAP_ARRAY)
  2477.       faceTarget = GL_TEXTURE_CUBE_MAP_POSITIVE_X + slice % 6;
  2478.  
  2479.    /* Currently all texture targets want the W component to be 1.0.
  2480.     */
  2481.    coords0[3] = 1.0F;
  2482.    coords1[3] = 1.0F;
  2483.    coords2[3] = 1.0F;
  2484.    coords3[3] = 1.0F;
  2485.  
  2486.    switch (faceTarget) {
  2487.    case GL_TEXTURE_1D:
  2488.    case GL_TEXTURE_2D:
  2489.    case GL_TEXTURE_3D:
  2490.    case GL_TEXTURE_2D_ARRAY:
  2491.       if (faceTarget == GL_TEXTURE_3D) {
  2492.          assert(slice < depth);
  2493.          assert(depth >= 1);
  2494.          r = (slice + 0.5f) / depth;
  2495.       }
  2496.       else if (faceTarget == GL_TEXTURE_2D_ARRAY)
  2497.          r = (float) slice;
  2498.       else
  2499.          r = 0.0F;
  2500.       coords0[0] = 0.0F; /* s */
  2501.       coords0[1] = 0.0F; /* t */
  2502.       coords0[2] = r; /* r */
  2503.       coords1[0] = 1.0F;
  2504.       coords1[1] = 0.0F;
  2505.       coords1[2] = r;
  2506.       coords2[0] = 1.0F;
  2507.       coords2[1] = 1.0F;
  2508.       coords2[2] = r;
  2509.       coords3[0] = 0.0F;
  2510.       coords3[1] = 1.0F;
  2511.       coords3[2] = r;
  2512.       break;
  2513.    case GL_TEXTURE_RECTANGLE_ARB:
  2514.       coords0[0] = 0.0F; /* s */
  2515.       coords0[1] = 0.0F; /* t */
  2516.       coords0[2] = 0.0F; /* r */
  2517.       coords1[0] = (float) width;
  2518.       coords1[1] = 0.0F;
  2519.       coords1[2] = 0.0F;
  2520.       coords2[0] = (float) width;
  2521.       coords2[1] = (float) height;
  2522.       coords2[2] = 0.0F;
  2523.       coords3[0] = 0.0F;
  2524.       coords3[1] = (float) height;
  2525.       coords3[2] = 0.0F;
  2526.       break;
  2527.    case GL_TEXTURE_1D_ARRAY:
  2528.       coords0[0] = 0.0F; /* s */
  2529.       coords0[1] = (float) slice; /* t */
  2530.       coords0[2] = 0.0F; /* r */
  2531.       coords1[0] = 1.0f;
  2532.       coords1[1] = (float) slice;
  2533.       coords1[2] = 0.0F;
  2534.       coords2[0] = 1.0F;
  2535.       coords2[1] = (float) slice;
  2536.       coords2[2] = 0.0F;
  2537.       coords3[0] = 0.0F;
  2538.       coords3[1] = (float) slice;
  2539.       coords3[2] = 0.0F;
  2540.       break;
  2541.  
  2542.    case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
  2543.    case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
  2544.    case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
  2545.    case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
  2546.    case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
  2547.    case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
  2548.       /* loop over quad verts */
  2549.       for (i = 0; i < 4; i++) {
  2550.          /* Compute sc = +/-scale and tc = +/-scale.
  2551.           * Not +/-1 to avoid cube face selection ambiguity near the edges,
  2552.           * though that can still sometimes happen with this scale factor...
  2553.           */
  2554.          const GLfloat scale = 0.9999f;
  2555.          const GLfloat sc = (2.0f * st[i][0] - 1.0f) * scale;
  2556.          const GLfloat tc = (2.0f * st[i][1] - 1.0f) * scale;
  2557.          GLfloat *coord;
  2558.  
  2559.          switch (i) {
  2560.          case 0:
  2561.             coord = coords0;
  2562.             break;
  2563.          case 1:
  2564.             coord = coords1;
  2565.             break;
  2566.          case 2:
  2567.             coord = coords2;
  2568.             break;
  2569.          case 3:
  2570.             coord = coords3;
  2571.             break;
  2572.          default:
  2573.             unreachable("not reached");
  2574.          }
  2575.  
  2576.          coord[3] = (float) (slice / 6);
  2577.  
  2578.          switch (faceTarget) {
  2579.          case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
  2580.             coord[0] = 1.0f;
  2581.             coord[1] = -tc;
  2582.             coord[2] = -sc;
  2583.             break;
  2584.          case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
  2585.             coord[0] = -1.0f;
  2586.             coord[1] = -tc;
  2587.             coord[2] = sc;
  2588.             break;
  2589.          case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
  2590.             coord[0] = sc;
  2591.             coord[1] = 1.0f;
  2592.             coord[2] = tc;
  2593.             break;
  2594.          case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
  2595.             coord[0] = sc;
  2596.             coord[1] = -1.0f;
  2597.             coord[2] = -tc;
  2598.             break;
  2599.          case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
  2600.             coord[0] = sc;
  2601.             coord[1] = -tc;
  2602.             coord[2] = 1.0f;
  2603.             break;
  2604.          case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
  2605.             coord[0] = -sc;
  2606.             coord[1] = -tc;
  2607.             coord[2] = -1.0f;
  2608.             break;
  2609.          default:
  2610.             assert(0);
  2611.          }
  2612.       }
  2613.       break;
  2614.    default:
  2615.       assert(!"unexpected target in _mesa_meta_setup_texture_coords()");
  2616.    }
  2617. }
  2618.  
  2619. static struct blit_shader *
  2620. choose_blit_shader(GLenum target, struct blit_shader_table *table)
  2621. {
  2622.    switch(target) {
  2623.    case GL_TEXTURE_1D:
  2624.       table->sampler_1d.type = "sampler1D";
  2625.       table->sampler_1d.func = "texture1D";
  2626.       table->sampler_1d.texcoords = "texCoords.x";
  2627.       return &table->sampler_1d;
  2628.    case GL_TEXTURE_2D:
  2629.       table->sampler_2d.type = "sampler2D";
  2630.       table->sampler_2d.func = "texture2D";
  2631.       table->sampler_2d.texcoords = "texCoords.xy";
  2632.       return &table->sampler_2d;
  2633.    case GL_TEXTURE_RECTANGLE:
  2634.       table->sampler_rect.type = "sampler2DRect";
  2635.       table->sampler_rect.func = "texture2DRect";
  2636.       table->sampler_rect.texcoords = "texCoords.xy";
  2637.       return &table->sampler_rect;
  2638.    case GL_TEXTURE_3D:
  2639.       /* Code for mipmap generation with 3D textures is not used yet.
  2640.        * It's a sw fallback.
  2641.        */
  2642.       table->sampler_3d.type = "sampler3D";
  2643.       table->sampler_3d.func = "texture3D";
  2644.       table->sampler_3d.texcoords = "texCoords.xyz";
  2645.       return &table->sampler_3d;
  2646.    case GL_TEXTURE_CUBE_MAP:
  2647.       table->sampler_cubemap.type = "samplerCube";
  2648.       table->sampler_cubemap.func = "textureCube";
  2649.       table->sampler_cubemap.texcoords = "texCoords.xyz";
  2650.       return &table->sampler_cubemap;
  2651.    case GL_TEXTURE_1D_ARRAY:
  2652.       table->sampler_1d_array.type = "sampler1DArray";
  2653.       table->sampler_1d_array.func = "texture1DArray";
  2654.       table->sampler_1d_array.texcoords = "texCoords.xy";
  2655.       return &table->sampler_1d_array;
  2656.    case GL_TEXTURE_2D_ARRAY:
  2657.       table->sampler_2d_array.type = "sampler2DArray";
  2658.       table->sampler_2d_array.func = "texture2DArray";
  2659.       table->sampler_2d_array.texcoords = "texCoords.xyz";
  2660.       return &table->sampler_2d_array;
  2661.    case GL_TEXTURE_CUBE_MAP_ARRAY:
  2662.       table->sampler_cubemap_array.type = "samplerCubeArray";
  2663.       table->sampler_cubemap_array.func = "textureCubeArray";
  2664.       table->sampler_cubemap_array.texcoords = "texCoords.xyzw";
  2665.       return &table->sampler_cubemap_array;
  2666.    default:
  2667.       _mesa_problem(NULL, "Unexpected texture target 0x%x in"
  2668.                     " setup_texture_sampler()\n", target);
  2669.       return NULL;
  2670.    }
  2671. }
  2672.  
  2673. void
  2674. _mesa_meta_blit_shader_table_cleanup(struct blit_shader_table *table)
  2675. {
  2676.    _mesa_DeleteProgram(table->sampler_1d.shader_prog);
  2677.    _mesa_DeleteProgram(table->sampler_2d.shader_prog);
  2678.    _mesa_DeleteProgram(table->sampler_3d.shader_prog);
  2679.    _mesa_DeleteProgram(table->sampler_rect.shader_prog);
  2680.    _mesa_DeleteProgram(table->sampler_cubemap.shader_prog);
  2681.    _mesa_DeleteProgram(table->sampler_1d_array.shader_prog);
  2682.    _mesa_DeleteProgram(table->sampler_2d_array.shader_prog);
  2683.    _mesa_DeleteProgram(table->sampler_cubemap_array.shader_prog);
  2684.  
  2685.    table->sampler_1d.shader_prog = 0;
  2686.    table->sampler_2d.shader_prog = 0;
  2687.    table->sampler_3d.shader_prog = 0;
  2688.    table->sampler_rect.shader_prog = 0;
  2689.    table->sampler_cubemap.shader_prog = 0;
  2690.    table->sampler_1d_array.shader_prog = 0;
  2691.    table->sampler_2d_array.shader_prog = 0;
  2692.    table->sampler_cubemap_array.shader_prog = 0;
  2693. }
  2694.  
  2695. /**
  2696.  * Determine the GL data type to use for the temporary image read with
  2697.  * ReadPixels() and passed to Tex[Sub]Image().
  2698.  */
  2699. static GLenum
  2700. get_temp_image_type(struct gl_context *ctx, mesa_format format)
  2701. {
  2702.    const GLenum baseFormat = _mesa_get_format_base_format(format);
  2703.    const GLenum datatype = _mesa_get_format_datatype(format);
  2704.    const GLint format_red_bits = _mesa_get_format_bits(format, GL_RED_BITS);
  2705.  
  2706.    switch (baseFormat) {
  2707.    case GL_RGBA:
  2708.    case GL_RGB:
  2709.    case GL_RG:
  2710.    case GL_RED:
  2711.    case GL_ALPHA:
  2712.    case GL_LUMINANCE:
  2713.    case GL_LUMINANCE_ALPHA:
  2714.    case GL_INTENSITY:
  2715.       if (datatype == GL_INT || datatype == GL_UNSIGNED_INT) {
  2716.          return datatype;
  2717.       } else if (format_red_bits <= 8) {
  2718.          return GL_UNSIGNED_BYTE;
  2719.       } else if (format_red_bits <= 16) {
  2720.          return GL_UNSIGNED_SHORT;
  2721.       }
  2722.       return GL_FLOAT;
  2723.    case GL_DEPTH_COMPONENT:
  2724.       if (datatype == GL_FLOAT)
  2725.          return GL_FLOAT;
  2726.       else
  2727.          return GL_UNSIGNED_INT;
  2728.    case GL_DEPTH_STENCIL:
  2729.       if (datatype == GL_FLOAT)
  2730.          return GL_FLOAT_32_UNSIGNED_INT_24_8_REV;
  2731.       else
  2732.          return GL_UNSIGNED_INT_24_8;
  2733.    default:
  2734.       _mesa_problem(ctx, "Unexpected format %d in get_temp_image_type()",
  2735.                     baseFormat);
  2736.       return 0;
  2737.    }
  2738. }
  2739.  
  2740. /**
  2741.  * Attempts to wrap the destination texture in an FBO and use
  2742.  * glBlitFramebuffer() to implement glCopyTexSubImage().
  2743.  */
  2744. static bool
  2745. copytexsubimage_using_blit_framebuffer(struct gl_context *ctx, GLuint dims,
  2746.                                        struct gl_texture_image *texImage,
  2747.                                        GLint xoffset,
  2748.                                        GLint yoffset,
  2749.                                        GLint zoffset,
  2750.                                        struct gl_renderbuffer *rb,
  2751.                                        GLint x, GLint y,
  2752.                                        GLsizei width, GLsizei height)
  2753. {
  2754.    GLuint fbo;
  2755.    bool success = false;
  2756.    GLbitfield mask;
  2757.    GLenum status;
  2758.  
  2759.    if (!ctx->Extensions.ARB_framebuffer_object)
  2760.       return false;
  2761.  
  2762.    _mesa_meta_begin(ctx, MESA_META_ALL & ~MESA_META_DRAW_BUFFERS);
  2763.  
  2764.    _mesa_GenFramebuffers(1, &fbo);
  2765.    _mesa_BindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
  2766.  
  2767.    if (rb->_BaseFormat == GL_DEPTH_STENCIL ||
  2768.        rb->_BaseFormat == GL_DEPTH_COMPONENT) {
  2769.       _mesa_meta_bind_fbo_image(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
  2770.                                 texImage, zoffset);
  2771.       mask = GL_DEPTH_BUFFER_BIT;
  2772.  
  2773.       if (rb->_BaseFormat == GL_DEPTH_STENCIL &&
  2774.           texImage->_BaseFormat == GL_DEPTH_STENCIL) {
  2775.          _mesa_meta_bind_fbo_image(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
  2776.                                    texImage, zoffset);
  2777.          mask |= GL_STENCIL_BUFFER_BIT;
  2778.       }
  2779.       _mesa_DrawBuffer(GL_NONE);
  2780.    } else {
  2781.       _mesa_meta_bind_fbo_image(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
  2782.                                 texImage, zoffset);
  2783.       mask = GL_COLOR_BUFFER_BIT;
  2784.       _mesa_DrawBuffer(GL_COLOR_ATTACHMENT0);
  2785.    }
  2786.  
  2787.    status = _mesa_CheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
  2788.    if (status != GL_FRAMEBUFFER_COMPLETE)
  2789.       goto out;
  2790.  
  2791.    ctx->Meta->Blit.no_ctsi_fallback = true;
  2792.  
  2793.    /* Since we've bound a new draw framebuffer, we need to update
  2794.     * its derived state -- _Xmin, etc -- for BlitFramebuffer's clipping to
  2795.     * be correct.
  2796.     */
  2797.    _mesa_update_state(ctx);
  2798.  
  2799.    /* We skip the core BlitFramebuffer checks for format consistency, which
  2800.     * are too strict for CopyTexImage.  We know meta will be fine with format
  2801.     * changes.
  2802.     */
  2803.    mask = _mesa_meta_BlitFramebuffer(ctx, ctx->ReadBuffer, ctx->DrawBuffer,
  2804.                                      x, y,
  2805.                                      x + width, y + height,
  2806.                                      xoffset, yoffset,
  2807.                                      xoffset + width, yoffset + height,
  2808.                                      mask, GL_NEAREST);
  2809.    ctx->Meta->Blit.no_ctsi_fallback = false;
  2810.    success = mask == 0x0;
  2811.  
  2812.  out:
  2813.    _mesa_DeleteFramebuffers(1, &fbo);
  2814.    _mesa_meta_end(ctx);
  2815.    return success;
  2816. }
  2817.  
  2818. /**
  2819.  * Helper for _mesa_meta_CopyTexSubImage1/2/3D() functions.
  2820.  * Have to be careful with locking and meta state for pixel transfer.
  2821.  */
  2822. void
  2823. _mesa_meta_CopyTexSubImage(struct gl_context *ctx, GLuint dims,
  2824.                            struct gl_texture_image *texImage,
  2825.                            GLint xoffset, GLint yoffset, GLint zoffset,
  2826.                            struct gl_renderbuffer *rb,
  2827.                            GLint x, GLint y,
  2828.                            GLsizei width, GLsizei height)
  2829. {
  2830.    GLenum format, type;
  2831.    GLint bpp;
  2832.    void *buf;
  2833.  
  2834.    if (copytexsubimage_using_blit_framebuffer(ctx, dims,
  2835.                                               texImage,
  2836.                                               xoffset, yoffset, zoffset,
  2837.                                               rb,
  2838.                                               x, y,
  2839.                                               width, height)) {
  2840.       return;
  2841.    }
  2842.  
  2843.    /* Choose format/type for temporary image buffer */
  2844.    format = _mesa_get_format_base_format(texImage->TexFormat);
  2845.    if (format == GL_LUMINANCE ||
  2846.        format == GL_LUMINANCE_ALPHA ||
  2847.        format == GL_INTENSITY) {
  2848.       /* We don't want to use GL_LUMINANCE, GL_INTENSITY, etc. for the
  2849.        * temp image buffer because glReadPixels will do L=R+G+B which is
  2850.        * not what we want (should be L=R).
  2851.        */
  2852.       format = GL_RGBA;
  2853.    }
  2854.  
  2855.    type = get_temp_image_type(ctx, texImage->TexFormat);
  2856.    if (_mesa_is_format_integer_color(texImage->TexFormat)) {
  2857.       format = _mesa_base_format_to_integer_format(format);
  2858.    }
  2859.    bpp = _mesa_bytes_per_pixel(format, type);
  2860.    if (bpp <= 0) {
  2861.       _mesa_problem(ctx, "Bad bpp in _mesa_meta_CopyTexSubImage()");
  2862.       return;
  2863.    }
  2864.  
  2865.    /*
  2866.     * Alloc image buffer (XXX could use a PBO)
  2867.     */
  2868.    buf = malloc(width * height * bpp);
  2869.    if (!buf) {
  2870.       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage%uD", dims);
  2871.       return;
  2872.    }
  2873.  
  2874.    /*
  2875.     * Read image from framebuffer (disable pixel transfer ops)
  2876.     */
  2877.    _mesa_meta_begin(ctx, MESA_META_PIXEL_STORE | MESA_META_PIXEL_TRANSFER);
  2878.    ctx->Driver.ReadPixels(ctx, x, y, width, height,
  2879.                           format, type, &ctx->Pack, buf);
  2880.    _mesa_meta_end(ctx);
  2881.  
  2882.    _mesa_update_state(ctx); /* to update pixel transfer state */
  2883.  
  2884.    /*
  2885.     * Store texture data (with pixel transfer ops)
  2886.     */
  2887.    _mesa_meta_begin(ctx, MESA_META_PIXEL_STORE);
  2888.  
  2889.    if (texImage->TexObject->Target == GL_TEXTURE_1D_ARRAY) {
  2890.       assert(yoffset == 0);
  2891.       ctx->Driver.TexSubImage(ctx, dims, texImage,
  2892.                               xoffset, zoffset, 0, width, 1, 1,
  2893.                               format, type, buf, &ctx->Unpack);
  2894.    } else {
  2895.       ctx->Driver.TexSubImage(ctx, dims, texImage,
  2896.                               xoffset, yoffset, zoffset, width, height, 1,
  2897.                               format, type, buf, &ctx->Unpack);
  2898.    }
  2899.  
  2900.    _mesa_meta_end(ctx);
  2901.  
  2902.    free(buf);
  2903. }
  2904.  
  2905. static void
  2906. meta_decompress_fbo_cleanup(struct decompress_fbo_state *decompress_fbo)
  2907. {
  2908.    if (decompress_fbo->FBO != 0) {
  2909.       _mesa_DeleteFramebuffers(1, &decompress_fbo->FBO);
  2910.       _mesa_DeleteRenderbuffers(1, &decompress_fbo->RBO);
  2911.    }
  2912.  
  2913.    memset(decompress_fbo, 0, sizeof(*decompress_fbo));
  2914. }
  2915.  
  2916. static void
  2917. meta_decompress_cleanup(struct decompress_state *decompress)
  2918. {
  2919.    meta_decompress_fbo_cleanup(&decompress->byteFBO);
  2920.    meta_decompress_fbo_cleanup(&decompress->floatFBO);
  2921.  
  2922.    if (decompress->VAO != 0) {
  2923.       _mesa_DeleteVertexArrays(1, &decompress->VAO);
  2924.       _mesa_DeleteBuffers(1, &decompress->VBO);
  2925.    }
  2926.  
  2927.    if (decompress->Sampler != 0)
  2928.       _mesa_DeleteSamplers(1, &decompress->Sampler);
  2929.  
  2930.    memset(decompress, 0, sizeof(*decompress));
  2931. }
  2932.  
  2933. /**
  2934.  * Decompress a texture image by drawing a quad with the compressed
  2935.  * texture and reading the pixels out of the color buffer.
  2936.  * \param slice  which slice of a 3D texture or layer of a 1D/2D texture
  2937.  * \param destFormat  format, ala glReadPixels
  2938.  * \param destType  type, ala glReadPixels
  2939.  * \param dest  destination buffer
  2940.  * \param destRowLength  dest image rowLength (ala GL_PACK_ROW_LENGTH)
  2941.  */
  2942. static bool
  2943. decompress_texture_image(struct gl_context *ctx,
  2944.                          struct gl_texture_image *texImage,
  2945.                          GLuint slice,
  2946.                          GLenum destFormat, GLenum destType,
  2947.                          GLvoid *dest)
  2948. {
  2949.    struct decompress_state *decompress = &ctx->Meta->Decompress;
  2950.    struct decompress_fbo_state *decompress_fbo;
  2951.    struct gl_texture_object *texObj = texImage->TexObject;
  2952.    const GLint width = texImage->Width;
  2953.    const GLint height = texImage->Height;
  2954.    const GLint depth = texImage->Height;
  2955.    const GLenum target = texObj->Target;
  2956.    GLenum rbFormat;
  2957.    GLenum faceTarget;
  2958.    struct vertex verts[4];
  2959.    GLuint samplerSave;
  2960.    GLenum status;
  2961.    const bool use_glsl_version = ctx->Extensions.ARB_vertex_shader &&
  2962.                                       ctx->Extensions.ARB_fragment_shader;
  2963.  
  2964.    switch (_mesa_get_format_datatype(texImage->TexFormat)) {
  2965.    case GL_FLOAT:
  2966.       decompress_fbo = &decompress->floatFBO;
  2967.       rbFormat = GL_RGBA32F;
  2968.       break;
  2969.    case GL_UNSIGNED_NORMALIZED:
  2970.       decompress_fbo = &decompress->byteFBO;
  2971.       rbFormat = GL_RGBA;
  2972.       break;
  2973.    default:
  2974.       return false;
  2975.    }
  2976.  
  2977.    if (slice > 0) {
  2978.       assert(target == GL_TEXTURE_3D ||
  2979.              target == GL_TEXTURE_2D_ARRAY ||
  2980.              target == GL_TEXTURE_CUBE_MAP_ARRAY);
  2981.    }
  2982.  
  2983.    switch (target) {
  2984.    case GL_TEXTURE_1D:
  2985.    case GL_TEXTURE_1D_ARRAY:
  2986.       assert(!"No compressed 1D textures.");
  2987.       return false;
  2988.  
  2989.    case GL_TEXTURE_3D:
  2990.       assert(!"No compressed 3D textures.");
  2991.       return false;
  2992.  
  2993.    case GL_TEXTURE_CUBE_MAP_ARRAY:
  2994.       faceTarget = GL_TEXTURE_CUBE_MAP_POSITIVE_X + (slice % 6);
  2995.       break;
  2996.  
  2997.    case GL_TEXTURE_CUBE_MAP:
  2998.       faceTarget = GL_TEXTURE_CUBE_MAP_POSITIVE_X + texImage->Face;
  2999.       break;
  3000.  
  3001.    default:
  3002.       faceTarget = target;
  3003.       break;
  3004.    }
  3005.  
  3006.    _mesa_meta_begin(ctx, MESA_META_ALL & ~(MESA_META_PIXEL_STORE |
  3007.                                            MESA_META_DRAW_BUFFERS));
  3008.  
  3009.    samplerSave = ctx->Texture.Unit[ctx->Texture.CurrentUnit].Sampler ?
  3010.          ctx->Texture.Unit[ctx->Texture.CurrentUnit].Sampler->Name : 0;
  3011.  
  3012.    /* Create/bind FBO/renderbuffer */
  3013.    if (decompress_fbo->FBO == 0) {
  3014.       _mesa_GenFramebuffers(1, &decompress_fbo->FBO);
  3015.       _mesa_GenRenderbuffers(1, &decompress_fbo->RBO);
  3016.       _mesa_BindFramebuffer(GL_FRAMEBUFFER_EXT, decompress_fbo->FBO);
  3017.       _mesa_BindRenderbuffer(GL_RENDERBUFFER_EXT, decompress_fbo->RBO);
  3018.       _mesa_FramebufferRenderbuffer(GL_FRAMEBUFFER_EXT,
  3019.                                        GL_COLOR_ATTACHMENT0_EXT,
  3020.                                        GL_RENDERBUFFER_EXT,
  3021.                                        decompress_fbo->RBO);
  3022.    }
  3023.    else {
  3024.       _mesa_BindFramebuffer(GL_FRAMEBUFFER_EXT, decompress_fbo->FBO);
  3025.    }
  3026.  
  3027.    /* alloc dest surface */
  3028.    if (width > decompress_fbo->Width || height > decompress_fbo->Height) {
  3029.       _mesa_BindRenderbuffer(GL_RENDERBUFFER_EXT, decompress_fbo->RBO);
  3030.       _mesa_RenderbufferStorage(GL_RENDERBUFFER_EXT, rbFormat,
  3031.                                 width, height);
  3032.       status = _mesa_CheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
  3033.       if (status != GL_FRAMEBUFFER_COMPLETE) {
  3034.          /* If the framebuffer isn't complete then we'll leave
  3035.           * decompress_fbo->Width as zero so that it will fail again next time
  3036.           * too */
  3037.          _mesa_meta_end(ctx);
  3038.          return false;
  3039.       }
  3040.       decompress_fbo->Width = width;
  3041.       decompress_fbo->Height = height;
  3042.    }
  3043.  
  3044.    if (use_glsl_version) {
  3045.       _mesa_meta_setup_vertex_objects(&decompress->VAO, &decompress->VBO, true,
  3046.                                       2, 4, 0);
  3047.  
  3048.       _mesa_meta_setup_blit_shader(ctx, target, false, &decompress->shaders);
  3049.    } else {
  3050.       _mesa_meta_setup_ff_tnl_for_blit(&decompress->VAO, &decompress->VBO, 3);
  3051.    }
  3052.  
  3053.    if (!decompress->Sampler) {
  3054.       _mesa_GenSamplers(1, &decompress->Sampler);
  3055.       _mesa_BindSampler(ctx->Texture.CurrentUnit, decompress->Sampler);
  3056.       /* nearest filtering */
  3057.       _mesa_SamplerParameteri(decompress->Sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  3058.       _mesa_SamplerParameteri(decompress->Sampler, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  3059.       /* No sRGB decode or encode.*/
  3060.       if (ctx->Extensions.EXT_texture_sRGB_decode) {
  3061.          _mesa_SamplerParameteri(decompress->Sampler, GL_TEXTURE_SRGB_DECODE_EXT,
  3062.                              GL_SKIP_DECODE_EXT);
  3063.       }
  3064.  
  3065.    } else {
  3066.       _mesa_BindSampler(ctx->Texture.CurrentUnit, decompress->Sampler);
  3067.    }
  3068.  
  3069.    /* Silence valgrind warnings about reading uninitialized stack. */
  3070.    memset(verts, 0, sizeof(verts));
  3071.  
  3072.    _mesa_meta_setup_texture_coords(faceTarget, slice, width, height, depth,
  3073.                                    verts[0].tex,
  3074.                                    verts[1].tex,
  3075.                                    verts[2].tex,
  3076.                                    verts[3].tex);
  3077.  
  3078.    /* setup vertex positions */
  3079.    verts[0].x = -1.0F;
  3080.    verts[0].y = -1.0F;
  3081.    verts[1].x =  1.0F;
  3082.    verts[1].y = -1.0F;
  3083.    verts[2].x =  1.0F;
  3084.    verts[2].y =  1.0F;
  3085.    verts[3].x = -1.0F;
  3086.    verts[3].y =  1.0F;
  3087.  
  3088.    _mesa_set_viewport(ctx, 0, 0, 0, width, height);
  3089.  
  3090.    /* upload new vertex data */
  3091.    _mesa_BufferSubData(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
  3092.  
  3093.    /* setup texture state */
  3094.    _mesa_BindTexture(target, texObj->Name);
  3095.  
  3096.    if (!use_glsl_version)
  3097.       _mesa_set_enable(ctx, target, GL_TRUE);
  3098.  
  3099.    {
  3100.       /* save texture object state */
  3101.       const GLint baseLevelSave = texObj->BaseLevel;
  3102.       const GLint maxLevelSave = texObj->MaxLevel;
  3103.  
  3104.       /* restrict sampling to the texture level of interest */
  3105.       if (target != GL_TEXTURE_RECTANGLE_ARB) {
  3106.          _mesa_TexParameteri(target, GL_TEXTURE_BASE_LEVEL, texImage->Level);
  3107.          _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, texImage->Level);
  3108.       }
  3109.  
  3110.       /* render quad w/ texture into renderbuffer */
  3111.       _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
  3112.      
  3113.       /* Restore texture object state, the texture binding will
  3114.        * be restored by _mesa_meta_end().
  3115.        */
  3116.       if (target != GL_TEXTURE_RECTANGLE_ARB) {
  3117.          _mesa_TexParameteri(target, GL_TEXTURE_BASE_LEVEL, baseLevelSave);
  3118.          _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, maxLevelSave);
  3119.       }
  3120.  
  3121.    }
  3122.  
  3123.    /* read pixels from renderbuffer */
  3124.    {
  3125.       GLenum baseTexFormat = texImage->_BaseFormat;
  3126.       GLenum destBaseFormat = _mesa_base_tex_format(ctx, destFormat);
  3127.  
  3128.       /* The pixel transfer state will be set to default values at this point
  3129.        * (see MESA_META_PIXEL_TRANSFER) so pixel transfer ops are effectively
  3130.        * turned off (as required by glGetTexImage) but we need to handle some
  3131.        * special cases.  In particular, single-channel texture values are
  3132.        * returned as red and two-channel texture values are returned as
  3133.        * red/alpha.
  3134.        */
  3135.       if ((baseTexFormat == GL_LUMINANCE ||
  3136.            baseTexFormat == GL_LUMINANCE_ALPHA ||
  3137.            baseTexFormat == GL_INTENSITY) ||
  3138.           /* If we're reading back an RGB(A) texture (using glGetTexImage) as
  3139.            * luminance then we need to return L=tex(R).
  3140.            */
  3141.           ((baseTexFormat == GL_RGBA ||
  3142.             baseTexFormat == GL_RGB  ||
  3143.             baseTexFormat == GL_RG) &&
  3144.           (destBaseFormat == GL_LUMINANCE ||
  3145.            destBaseFormat == GL_LUMINANCE_ALPHA ||
  3146.            destBaseFormat == GL_LUMINANCE_INTEGER_EXT ||
  3147.            destBaseFormat == GL_LUMINANCE_ALPHA_INTEGER_EXT))) {
  3148.          /* Green and blue must be zero */
  3149.          _mesa_PixelTransferf(GL_GREEN_SCALE, 0.0f);
  3150.          _mesa_PixelTransferf(GL_BLUE_SCALE, 0.0f);
  3151.       }
  3152.  
  3153.       _mesa_ReadPixels(0, 0, width, height, destFormat, destType, dest);
  3154.    }
  3155.  
  3156.    /* disable texture unit */
  3157.    if (!use_glsl_version)
  3158.       _mesa_set_enable(ctx, target, GL_FALSE);
  3159.  
  3160.    _mesa_BindSampler(ctx->Texture.CurrentUnit, samplerSave);
  3161.  
  3162.    _mesa_meta_end(ctx);
  3163.  
  3164.    return true;
  3165. }
  3166.  
  3167.  
  3168. /**
  3169.  * This is just a wrapper around _mesa_get_tex_image() and
  3170.  * decompress_texture_image().  Meta functions should not be directly called
  3171.  * from core Mesa.
  3172.  */
  3173. void
  3174. _mesa_meta_GetTexImage(struct gl_context *ctx,
  3175.                        GLenum format, GLenum type, GLvoid *pixels,
  3176.                        struct gl_texture_image *texImage)
  3177. {
  3178.    if (_mesa_is_format_compressed(texImage->TexFormat)) {
  3179.       GLuint slice;
  3180.       bool result = true;
  3181.  
  3182.       for (slice = 0; slice < texImage->Depth; slice++) {
  3183.          void *dst;
  3184.          if (texImage->TexObject->Target == GL_TEXTURE_2D_ARRAY
  3185.              || texImage->TexObject->Target == GL_TEXTURE_CUBE_MAP_ARRAY) {
  3186.             /* Setup pixel packing.  SkipPixels and SkipRows will be applied
  3187.              * in the decompress_texture_image() function's call to
  3188.              * glReadPixels but we need to compute the dest slice's address
  3189.              * here (according to SkipImages and ImageHeight).
  3190.              */
  3191.             struct gl_pixelstore_attrib packing = ctx->Pack;
  3192.             packing.SkipPixels = 0;
  3193.             packing.SkipRows = 0;
  3194.             dst = _mesa_image_address3d(&packing, pixels, texImage->Width,
  3195.                                         texImage->Height, format, type,
  3196.                                         slice, 0, 0);
  3197.          }
  3198.          else {
  3199.             dst = pixels;
  3200.          }
  3201.          result = decompress_texture_image(ctx, texImage, slice,
  3202.                                            format, type, dst);
  3203.          if (!result)
  3204.             break;
  3205.       }
  3206.  
  3207.       if (result)
  3208.          return;
  3209.    }
  3210.  
  3211.    _mesa_GetTexImage_sw(ctx, format, type, pixels, texImage);
  3212. }
  3213.  
  3214.  
  3215. /**
  3216.  * Meta implementation of ctx->Driver.DrawTex() in terms
  3217.  * of polygon rendering.
  3218.  */
  3219. void
  3220. _mesa_meta_DrawTex(struct gl_context *ctx, GLfloat x, GLfloat y, GLfloat z,
  3221.                    GLfloat width, GLfloat height)
  3222. {
  3223.    struct drawtex_state *drawtex = &ctx->Meta->DrawTex;
  3224.    struct vertex {
  3225.       GLfloat x, y, z, st[MAX_TEXTURE_UNITS][2];
  3226.    };
  3227.    struct vertex verts[4];
  3228.    GLuint i;
  3229.  
  3230.    _mesa_meta_begin(ctx, (MESA_META_RASTERIZATION |
  3231.                           MESA_META_SHADER |
  3232.                           MESA_META_TRANSFORM |
  3233.                           MESA_META_VERTEX |
  3234.                           MESA_META_VIEWPORT));
  3235.  
  3236.    if (drawtex->VAO == 0) {
  3237.       /* one-time setup */
  3238.       GLint active_texture;
  3239.  
  3240.       /* create vertex array object */
  3241.       _mesa_GenVertexArrays(1, &drawtex->VAO);
  3242.       _mesa_BindVertexArray(drawtex->VAO);
  3243.  
  3244.       /* create vertex array buffer */
  3245.       _mesa_GenBuffers(1, &drawtex->VBO);
  3246.       _mesa_BindBuffer(GL_ARRAY_BUFFER_ARB, drawtex->VBO);
  3247.       _mesa_BufferData(GL_ARRAY_BUFFER_ARB, sizeof(verts),
  3248.                           NULL, GL_DYNAMIC_DRAW_ARB);
  3249.  
  3250.       /* client active texture is not part of the array object */
  3251.       active_texture = ctx->Array.ActiveTexture;
  3252.  
  3253.       /* setup vertex arrays */
  3254.       _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
  3255.       _mesa_EnableClientState(GL_VERTEX_ARRAY);
  3256.       for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
  3257.          _mesa_ClientActiveTexture(GL_TEXTURE0 + i);
  3258.          _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(st[i]));
  3259.          _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
  3260.       }
  3261.  
  3262.       /* restore client active texture */
  3263.       _mesa_ClientActiveTexture(GL_TEXTURE0 + active_texture);
  3264.    }
  3265.    else {
  3266.       _mesa_BindVertexArray(drawtex->VAO);
  3267.       _mesa_BindBuffer(GL_ARRAY_BUFFER_ARB, drawtex->VBO);
  3268.    }
  3269.  
  3270.    /* vertex positions, texcoords */
  3271.    {
  3272.       const GLfloat x1 = x + width;
  3273.       const GLfloat y1 = y + height;
  3274.  
  3275.       z = CLAMP(z, 0.0f, 1.0f);
  3276.       z = invert_z(z);
  3277.  
  3278.       verts[0].x = x;
  3279.       verts[0].y = y;
  3280.       verts[0].z = z;
  3281.  
  3282.       verts[1].x = x1;
  3283.       verts[1].y = y;
  3284.       verts[1].z = z;
  3285.  
  3286.       verts[2].x = x1;
  3287.       verts[2].y = y1;
  3288.       verts[2].z = z;
  3289.  
  3290.       verts[3].x = x;
  3291.       verts[3].y = y1;
  3292.       verts[3].z = z;
  3293.  
  3294.       for (i = 0; i < ctx->Const.MaxTextureUnits; i++) {
  3295.          const struct gl_texture_object *texObj;
  3296.          const struct gl_texture_image *texImage;
  3297.          GLfloat s, t, s1, t1;
  3298.          GLuint tw, th;
  3299.  
  3300.          if (!ctx->Texture.Unit[i]._Current) {
  3301.             GLuint j;
  3302.             for (j = 0; j < 4; j++) {
  3303.                verts[j].st[i][0] = 0.0f;
  3304.                verts[j].st[i][1] = 0.0f;
  3305.             }
  3306.             continue;
  3307.          }
  3308.  
  3309.          texObj = ctx->Texture.Unit[i]._Current;
  3310.          texImage = texObj->Image[0][texObj->BaseLevel];
  3311.          tw = texImage->Width2;
  3312.          th = texImage->Height2;
  3313.  
  3314.          s = (GLfloat) texObj->CropRect[0] / tw;
  3315.          t = (GLfloat) texObj->CropRect[1] / th;
  3316.          s1 = (GLfloat) (texObj->CropRect[0] + texObj->CropRect[2]) / tw;
  3317.          t1 = (GLfloat) (texObj->CropRect[1] + texObj->CropRect[3]) / th;
  3318.  
  3319.          verts[0].st[i][0] = s;
  3320.          verts[0].st[i][1] = t;
  3321.  
  3322.          verts[1].st[i][0] = s1;
  3323.          verts[1].st[i][1] = t;
  3324.  
  3325.          verts[2].st[i][0] = s1;
  3326.          verts[2].st[i][1] = t1;
  3327.  
  3328.          verts[3].st[i][0] = s;
  3329.          verts[3].st[i][1] = t1;
  3330.       }
  3331.  
  3332.       _mesa_BufferSubData(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
  3333.    }
  3334.  
  3335.    _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
  3336.  
  3337.    _mesa_meta_end(ctx);
  3338. }
  3339.  
  3340. static bool
  3341. cleartexsubimage_color(struct gl_context *ctx,
  3342.                        struct gl_texture_image *texImage,
  3343.                        const GLvoid *clearValue,
  3344.                        GLint zoffset)
  3345. {
  3346.    mesa_format format;
  3347.    union gl_color_union colorValue;
  3348.    GLenum datatype;
  3349.    GLenum status;
  3350.  
  3351.    _mesa_meta_bind_fbo_image(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
  3352.                              texImage, zoffset);
  3353.  
  3354.    status = _mesa_CheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
  3355.    if (status != GL_FRAMEBUFFER_COMPLETE)
  3356.       return false;
  3357.  
  3358.    /* We don't want to apply an sRGB conversion so override the format */
  3359.    format = _mesa_get_srgb_format_linear(texImage->TexFormat);
  3360.    datatype = _mesa_get_format_datatype(format);
  3361.  
  3362.    switch (datatype) {
  3363.    case GL_UNSIGNED_INT:
  3364.    case GL_INT:
  3365.       if (clearValue)
  3366.          _mesa_unpack_uint_rgba_row(format, 1, clearValue,
  3367.                                     (GLuint (*)[4]) colorValue.ui);
  3368.       else
  3369.          memset(&colorValue, 0, sizeof colorValue);
  3370.       if (datatype == GL_INT)
  3371.          _mesa_ClearBufferiv(GL_COLOR, 0, colorValue.i);
  3372.       else
  3373.          _mesa_ClearBufferuiv(GL_COLOR, 0, colorValue.ui);
  3374.       break;
  3375.    default:
  3376.       if (clearValue)
  3377.          _mesa_unpack_rgba_row(format, 1, clearValue,
  3378.                                (GLfloat (*)[4]) colorValue.f);
  3379.       else
  3380.          memset(&colorValue, 0, sizeof colorValue);
  3381.       _mesa_ClearBufferfv(GL_COLOR, 0, colorValue.f);
  3382.       break;
  3383.    }
  3384.  
  3385.    return true;
  3386. }
  3387.  
  3388. static bool
  3389. cleartexsubimage_depth_stencil(struct gl_context *ctx,
  3390.                                struct gl_texture_image *texImage,
  3391.                                const GLvoid *clearValue,
  3392.                                GLint zoffset)
  3393. {
  3394.    GLint stencilValue;
  3395.    GLfloat depthValue;
  3396.    GLenum status;
  3397.  
  3398.    _mesa_meta_bind_fbo_image(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
  3399.                              texImage, zoffset);
  3400.  
  3401.    if (texImage->_BaseFormat == GL_DEPTH_STENCIL)
  3402.       _mesa_meta_bind_fbo_image(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT,
  3403.                                 texImage, zoffset);
  3404.  
  3405.    status = _mesa_CheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
  3406.    if (status != GL_FRAMEBUFFER_COMPLETE)
  3407.       return false;
  3408.  
  3409.    if (clearValue) {
  3410.       GLuint depthStencilValue[2];
  3411.  
  3412.       /* Convert the clearValue from whatever format it's in to a floating
  3413.        * point value for the depth and an integer value for the stencil index
  3414.        */
  3415.       _mesa_unpack_float_32_uint_24_8_depth_stencil_row(texImage->TexFormat,
  3416.                                                         1, /* n */
  3417.                                                         clearValue,
  3418.                                                         depthStencilValue);
  3419.       /* We need a memcpy here instead of a cast because we need to
  3420.        * reinterpret the bytes as a float rather than converting it
  3421.        */
  3422.       memcpy(&depthValue, depthStencilValue, sizeof depthValue);
  3423.       stencilValue = depthStencilValue[1] & 0xff;
  3424.    } else {
  3425.       depthValue = 0.0f;
  3426.       stencilValue = 0;
  3427.    }
  3428.  
  3429.    if (texImage->_BaseFormat == GL_DEPTH_STENCIL)
  3430.       _mesa_ClearBufferfi(GL_DEPTH_STENCIL, 0, depthValue, stencilValue);
  3431.    else
  3432.       _mesa_ClearBufferfv(GL_DEPTH, 0, &depthValue);
  3433.  
  3434.    return true;
  3435. }
  3436.  
  3437. static bool
  3438. cleartexsubimage_for_zoffset(struct gl_context *ctx,
  3439.                              struct gl_texture_image *texImage,
  3440.                              GLint zoffset,
  3441.                              const GLvoid *clearValue)
  3442. {
  3443.    GLuint fbo;
  3444.    bool success;
  3445.  
  3446.    _mesa_GenFramebuffers(1, &fbo);
  3447.    _mesa_BindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
  3448.  
  3449.    switch(texImage->_BaseFormat) {
  3450.    case GL_DEPTH_STENCIL:
  3451.    case GL_DEPTH_COMPONENT:
  3452.       success = cleartexsubimage_depth_stencil(ctx, texImage,
  3453.                                                clearValue, zoffset);
  3454.       break;
  3455.    default:
  3456.       success = cleartexsubimage_color(ctx, texImage, clearValue, zoffset);
  3457.       break;
  3458.    }
  3459.  
  3460.    _mesa_DeleteFramebuffers(1, &fbo);
  3461.  
  3462.    return success;
  3463. }
  3464.  
  3465. static bool
  3466. cleartexsubimage_using_fbo(struct gl_context *ctx,
  3467.                            struct gl_texture_image *texImage,
  3468.                            GLint xoffset, GLint yoffset, GLint zoffset,
  3469.                            GLsizei width, GLsizei height, GLsizei depth,
  3470.                            const GLvoid *clearValue)
  3471. {
  3472.    bool success = true;
  3473.    GLint z;
  3474.  
  3475.    _mesa_meta_begin(ctx,
  3476.                     MESA_META_SCISSOR |
  3477.                     MESA_META_COLOR_MASK |
  3478.                     MESA_META_DITHER |
  3479.                     MESA_META_FRAMEBUFFER_SRGB);
  3480.  
  3481.    _mesa_set_enable(ctx, GL_DITHER, GL_FALSE);
  3482.  
  3483.    _mesa_set_enable(ctx, GL_SCISSOR_TEST, GL_TRUE);
  3484.    _mesa_Scissor(xoffset, yoffset, width, height);
  3485.  
  3486.    for (z = zoffset; z < zoffset + depth; z++) {
  3487.       if (!cleartexsubimage_for_zoffset(ctx, texImage, z, clearValue)) {
  3488.          success = false;
  3489.          break;
  3490.       }
  3491.    }
  3492.  
  3493.    _mesa_meta_end(ctx);
  3494.  
  3495.    return success;
  3496. }
  3497.  
  3498. extern void
  3499. _mesa_meta_ClearTexSubImage(struct gl_context *ctx,
  3500.                             struct gl_texture_image *texImage,
  3501.                             GLint xoffset, GLint yoffset, GLint zoffset,
  3502.                             GLsizei width, GLsizei height, GLsizei depth,
  3503.                             const GLvoid *clearValue)
  3504. {
  3505.    bool res;
  3506.  
  3507.    res = cleartexsubimage_using_fbo(ctx, texImage,
  3508.                                     xoffset, yoffset, zoffset,
  3509.                                     width, height, depth,
  3510.                                     clearValue);
  3511.  
  3512.    if (res)
  3513.       return;
  3514.  
  3515.    _mesa_warning(ctx,
  3516.                  "Falling back to mapping the texture in "
  3517.                  "glClearTexSubImage\n");
  3518.  
  3519.    _mesa_store_cleartexsubimage(ctx, texImage,
  3520.                                 xoffset, yoffset, zoffset,
  3521.                                 width, height, depth,
  3522.                                 clearValue);
  3523. }
  3524.