Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1.  
  2. #include "context.h"
  3. #include "colormac.h"
  4. #include "macros.h"
  5. #include "texfetch.h"
  6. #include "texrender.h"
  7. #include "renderbuffer.h"
  8.  
  9.  
  10. /*
  11.  * Render-to-texture code for GL_EXT_framebuffer_object
  12.  */
  13.  
  14.  
  15. /**
  16.  * Derived from gl_renderbuffer class
  17.  */
  18. struct texture_renderbuffer
  19. {
  20.    struct gl_renderbuffer Base;   /**< Base class object */
  21.    struct gl_texture_image *TexImage;
  22.    StoreTexelFunc Store;
  23.    GLint Yoffset;                 /**< Layer for 1D array textures. */
  24.    GLint Zoffset;                 /**< Layer for 2D array textures, or slice
  25.                                    * for 3D textures
  26.                                    */
  27. };
  28.  
  29.  
  30. /**
  31.  * Get row of values from the renderbuffer that wraps a texture image.
  32.  */
  33. static void
  34. texture_get_row(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
  35.                 GLint x, GLint y, void *values)
  36. {
  37.    const struct texture_renderbuffer *trb
  38.       = (const struct texture_renderbuffer *) rb;
  39.    const GLint z = trb->Zoffset;
  40.    GLuint i;
  41.  
  42.    ASSERT(trb->TexImage->Width == rb->Width);
  43.    ASSERT(trb->TexImage->Height == rb->Height);
  44.  
  45.    y += trb->Yoffset;
  46.  
  47.    if (rb->DataType == CHAN_TYPE) {
  48.       GLchan *rgbaOut = (GLchan *) values;
  49.       for (i = 0; i < count; i++) {
  50.          GLfloat rgba[4];
  51.          trb->TexImage->FetchTexelf(trb->TexImage, x + i, y, z, rgba);
  52.          UNCLAMPED_FLOAT_TO_RGBA_CHAN(rgbaOut + 4 * i, rgba);
  53.       }
  54.    }
  55.    else if (rb->DataType == GL_UNSIGNED_SHORT) {
  56.       GLushort *zValues = (GLushort *) values;
  57.       for (i = 0; i < count; i++) {
  58.          GLfloat flt;
  59.          trb->TexImage->FetchTexelf(trb->TexImage, x + i, y, z, &flt);
  60.          zValues[i] = (GLushort) (flt * 0xffff);
  61.       }
  62.    }
  63.    else if (rb->DataType == GL_UNSIGNED_INT) {
  64.       GLuint *zValues = (GLuint *) values;
  65.       /*
  66.       const GLdouble scale = (GLdouble) 0xffffffff;
  67.       */
  68.       for (i = 0; i < count; i++) {
  69.          GLfloat flt;
  70.          trb->TexImage->FetchTexelf(trb->TexImage, x + i, y, z, &flt);
  71. #if 0
  72.          /* this should work, but doesn't (overflow due to low precision) */
  73.          zValues[i] = (GLuint) (flt * scale);
  74. #else
  75.          /* temporary hack */
  76.          zValues[i] = ((GLuint) (flt * 0xffffff)) << 8;
  77. #endif
  78.       }
  79.    }
  80.    else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {
  81.       GLuint *zValues = (GLuint *) values;
  82.       for (i = 0; i < count; i++) {
  83.          GLfloat flt;
  84.          trb->TexImage->FetchTexelf(trb->TexImage, x + i, y, z, &flt);
  85.          zValues[i] = ((GLuint) (flt * 0xffffff)) << 8;
  86.       }
  87.    }
  88.    else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {
  89.       GLuint *zValues = (GLuint *) values;
  90.       for (i = 0; i < count; i++) {
  91.          GLfloat flt;
  92.          trb->TexImage->FetchTexelf(trb->TexImage, x + i, y, z, &flt);
  93.          zValues[i] = (GLuint) (flt * 0xffffff);
  94.       }
  95.    }
  96.    else {
  97.       _mesa_problem(ctx, "invalid rb->DataType in texture_get_row");
  98.    }
  99. }
  100.  
  101.  
  102. static void
  103. texture_get_values(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
  104.                    const GLint x[], const GLint y[], void *values)
  105. {
  106.    const struct texture_renderbuffer *trb
  107.       = (const struct texture_renderbuffer *) rb;
  108.    const GLint z = trb->Zoffset;
  109.    GLuint i;
  110.  
  111.    if (rb->DataType == CHAN_TYPE) {
  112.       GLchan *rgbaOut = (GLchan *) values;
  113.       for (i = 0; i < count; i++) {
  114.          GLfloat rgba[4];
  115.          trb->TexImage->FetchTexelf(trb->TexImage, x[i], y[i] + trb->Yoffset,
  116.                                     z, rgba);
  117.          UNCLAMPED_FLOAT_TO_RGBA_CHAN(rgbaOut + 4 * i, rgba);
  118.       }
  119.    }
  120.    else if (rb->DataType == GL_UNSIGNED_SHORT) {
  121.       GLushort *zValues = (GLushort *) values;
  122.       for (i = 0; i < count; i++) {
  123.          GLfloat flt;
  124.          trb->TexImage->FetchTexelf(trb->TexImage, x[i], y[i] + trb->Yoffset,
  125.                                     z, &flt);
  126.          zValues[i] = (GLushort) (flt * 0xffff);
  127.       }
  128.    }
  129.    else if (rb->DataType == GL_UNSIGNED_INT) {
  130.       GLuint *zValues = (GLuint *) values;
  131.       for (i = 0; i < count; i++) {
  132.          GLfloat flt;
  133.          trb->TexImage->FetchTexelf(trb->TexImage, x[i], y[i] + trb->Yoffset,
  134.                                     z, &flt);
  135. #if 0
  136.          zValues[i] = (GLuint) (flt * 0xffffffff);
  137. #else
  138.          zValues[i] = ((GLuint) (flt * 0xffffff)) << 8;
  139. #endif
  140.       }
  141.    }
  142.    else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {
  143.       GLuint *zValues = (GLuint *) values;
  144.       for (i = 0; i < count; i++) {
  145.          GLfloat flt;
  146.          trb->TexImage->FetchTexelf(trb->TexImage, x[i], y[i] + trb->Yoffset,
  147.                                     z, &flt);
  148.          zValues[i] = ((GLuint) (flt * 0xffffff)) << 8;
  149.       }
  150.    }
  151.    else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {
  152.       GLuint *zValues = (GLuint *) values;
  153.       for (i = 0; i < count; i++) {
  154.          GLfloat flt;
  155.          trb->TexImage->FetchTexelf(trb->TexImage, x[i], y[i] + trb->Yoffset,
  156.                                     z, &flt);
  157.          zValues[i] = (GLuint) (flt * 0xffffff);
  158.       }
  159.    }
  160.    else {
  161.       _mesa_problem(ctx, "invalid rb->DataType in texture_get_values");
  162.    }
  163. }
  164.  
  165.  
  166. /**
  167.  * Put row of values into a renderbuffer that wraps a texture image.
  168.  */
  169. static void
  170. texture_put_row(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
  171.                 GLint x, GLint y, const void *values, const GLubyte *mask)
  172. {
  173.    const struct texture_renderbuffer *trb
  174.       = (const struct texture_renderbuffer *) rb;
  175.    const GLint z = trb->Zoffset;
  176.    GLuint i;
  177.  
  178.    y += trb->Yoffset;
  179.  
  180.    if (rb->DataType == CHAN_TYPE) {
  181.       const GLchan *rgba = (const GLchan *) values;
  182.       for (i = 0; i < count; i++) {
  183.          if (!mask || mask[i]) {
  184.             trb->Store(trb->TexImage, x + i, y, z, rgba);
  185.          }
  186.          rgba += 4;
  187.       }
  188.    }
  189.    else if (rb->DataType == GL_UNSIGNED_SHORT) {
  190.       const GLushort *zValues = (const GLushort *) values;
  191.       for (i = 0; i < count; i++) {
  192.          if (!mask || mask[i]) {
  193.             trb->Store(trb->TexImage, x + i, y, z, zValues + i);
  194.          }
  195.       }
  196.    }
  197.    else if (rb->DataType == GL_UNSIGNED_INT) {
  198.       const GLuint *zValues = (const GLuint *) values;
  199.       for (i = 0; i < count; i++) {
  200.          if (!mask || mask[i]) {
  201.             trb->Store(trb->TexImage, x + i, y, z, zValues + i);
  202.          }
  203.       }
  204.    }
  205.    else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {
  206.       const GLuint *zValues = (const GLuint *) values;
  207.       for (i = 0; i < count; i++) {
  208.          if (!mask || mask[i]) {
  209.             GLfloat flt = (GLfloat) ((zValues[i] >> 8) * (1.0 / 0xffffff));
  210.             trb->Store(trb->TexImage, x + i, y, z, &flt);
  211.          }
  212.       }
  213.    }
  214.    else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {
  215.       const GLuint *zValues = (const GLuint *) values;
  216.       for (i = 0; i < count; i++) {
  217.          if (!mask || mask[i]) {
  218.             GLfloat flt = (GLfloat) ((zValues[i] & 0xffffff) * (1.0 / 0xffffff));
  219.             trb->Store(trb->TexImage, x + i, y, z, &flt);
  220.          }
  221.       }
  222.    }
  223.    else {
  224.       _mesa_problem(ctx, "invalid rb->DataType in texture_put_row");
  225.    }
  226. }
  227.  
  228. /**
  229.  * Put row of RGB values into a renderbuffer that wraps a texture image.
  230.  */
  231. static void
  232. texture_put_row_rgb(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
  233.                 GLint x, GLint y, const void *values, const GLubyte *mask)
  234. {
  235.    const struct texture_renderbuffer *trb
  236.       = (const struct texture_renderbuffer *) rb;
  237.    const GLint z = trb->Zoffset;
  238.    GLuint i;
  239.  
  240.    y += trb->Yoffset;
  241.  
  242.    if (rb->DataType == CHAN_TYPE) {
  243.       const GLchan *rgb = (const GLchan *) values;
  244.       for (i = 0; i < count; i++) {
  245.          if (!mask || mask[i]) {
  246.             trb->Store(trb->TexImage, x + i, y, z, rgb);
  247.          }
  248.          rgb += 3;
  249.       }
  250.    }
  251.    else if (rb->DataType == GL_UNSIGNED_SHORT) {
  252.       const GLushort *zValues = (const GLushort *) values;
  253.       for (i = 0; i < count; i++) {
  254.          if (!mask || mask[i]) {
  255.             trb->Store(trb->TexImage, x + i, y, z, zValues + i);
  256.          }
  257.       }
  258.    }
  259.    else if (rb->DataType == GL_UNSIGNED_INT) {
  260.       const GLuint *zValues = (const GLuint *) values;
  261.       for (i = 0; i < count; i++) {
  262.          if (!mask || mask[i]) {
  263.             trb->Store(trb->TexImage, x + i, y, z, zValues + i);
  264.          }
  265.       }
  266.    }
  267.    else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {
  268.       const GLuint *zValues = (const GLuint *) values;
  269.       for (i = 0; i < count; i++) {
  270.          if (!mask || mask[i]) {
  271.             GLfloat flt = (GLfloat) ((zValues[i] >> 8) * (1.0 / 0xffffff));
  272.             trb->Store(trb->TexImage, x + i, y, z, &flt);
  273.          }
  274.       }
  275.    }
  276.    else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {
  277.       const GLuint *zValues = (const GLuint *) values;
  278.       for (i = 0; i < count; i++) {
  279.          if (!mask || mask[i]) {
  280.             GLfloat flt = (GLfloat) ((zValues[i] & 0xffffff) * (1.0 / 0xffffff));
  281.             trb->Store(trb->TexImage, x + i, y, z, &flt);
  282.          }
  283.       }
  284.    }
  285.    else {
  286.       _mesa_problem(ctx, "invalid rb->DataType in texture_put_row");
  287.    }
  288. }
  289.  
  290.  
  291. static void
  292. texture_put_mono_row(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
  293.                      GLint x, GLint y, const void *value, const GLubyte *mask)
  294. {
  295.    const struct texture_renderbuffer *trb
  296.       = (const struct texture_renderbuffer *) rb;
  297.    const GLint z = trb->Zoffset;
  298.    GLuint i;
  299.  
  300.    y += trb->Yoffset;
  301.  
  302.    if (rb->DataType == CHAN_TYPE) {
  303.       const GLchan *rgba = (const GLchan *) value;
  304.       for (i = 0; i < count; i++) {
  305.          if (!mask || mask[i]) {
  306.             trb->Store(trb->TexImage, x + i, y, z, rgba);
  307.          }
  308.       }
  309.    }
  310.    else if (rb->DataType == GL_UNSIGNED_SHORT) {
  311.       const GLushort zValue = *((const GLushort *) value);
  312.       for (i = 0; i < count; i++) {
  313.          if (!mask || mask[i]) {
  314.             trb->Store(trb->TexImage, x + i, y, z, &zValue);
  315.          }
  316.       }
  317.    }
  318.    else if (rb->DataType == GL_UNSIGNED_INT) {
  319.       const GLuint zValue = *((const GLuint *) value);
  320.       for (i = 0; i < count; i++) {
  321.          if (!mask || mask[i]) {
  322.             trb->Store(trb->TexImage, x + i, y, z, &zValue);
  323.          }
  324.       }
  325.    }
  326.    else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {
  327.       const GLuint zValue = *((const GLuint *) value);
  328.       const GLfloat flt = (GLfloat) ((zValue >> 8) * (1.0 / 0xffffff));
  329.       for (i = 0; i < count; i++) {
  330.          if (!mask || mask[i]) {
  331.             trb->Store(trb->TexImage, x + i, y, z, &flt);
  332.          }
  333.       }
  334.    }
  335.    else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {
  336.       const GLuint zValue = *((const GLuint *) value);
  337.       const GLfloat flt = (GLfloat) ((zValue & 0xffffff) * (1.0 / 0xffffff));
  338.       for (i = 0; i < count; i++) {
  339.          if (!mask || mask[i]) {
  340.             trb->Store(trb->TexImage, x + i, y, z, &flt);
  341.          }
  342.       }
  343.    }
  344.    else {
  345.       _mesa_problem(ctx, "invalid rb->DataType in texture_put_mono_row");
  346.    }
  347. }
  348.  
  349.  
  350. static void
  351. texture_put_values(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint count,
  352.                    const GLint x[], const GLint y[], const void *values,
  353.                    const GLubyte *mask)
  354. {
  355.    const struct texture_renderbuffer *trb
  356.       = (const struct texture_renderbuffer *) rb;
  357.    const GLint z = trb->Zoffset;
  358.    GLuint i;
  359.  
  360.    if (rb->DataType == CHAN_TYPE) {
  361.       const GLchan *rgba = (const GLchan *) values;
  362.       for (i = 0; i < count; i++) {
  363.          if (!mask || mask[i]) {
  364.             trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, rgba);
  365.          }
  366.          rgba += 4;
  367.       }
  368.    }
  369.    else if (rb->DataType == GL_UNSIGNED_SHORT) {
  370.       const GLushort *zValues = (const GLushort *) values;
  371.       for (i = 0; i < count; i++) {
  372.          if (!mask || mask[i]) {
  373.             trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, zValues + i);
  374.          }
  375.       }
  376.    }
  377.    else if (rb->DataType == GL_UNSIGNED_INT) {
  378.       const GLuint *zValues = (const GLuint *) values;
  379.       for (i = 0; i < count; i++) {
  380.          if (!mask || mask[i]) {
  381.             trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, zValues + i);
  382.          }
  383.       }
  384.    }
  385.    else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {
  386.       const GLuint *zValues = (const GLuint *) values;
  387.       for (i = 0; i < count; i++) {
  388.          if (!mask || mask[i]) {
  389.             GLfloat flt = (GLfloat) ((zValues[i] >> 8) * (1.0 / 0xffffff));
  390.             trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, &flt);
  391.          }
  392.       }
  393.    }
  394.    else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {
  395.       const GLuint *zValues = (const GLuint *) values;
  396.       for (i = 0; i < count; i++) {
  397.          if (!mask || mask[i]) {
  398.             GLfloat flt = (GLfloat) ((zValues[i] & 0xffffff) * (1.0 / 0xffffff));
  399.             trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, &flt);
  400.          }
  401.       }
  402.    }
  403.    else {
  404.       _mesa_problem(ctx, "invalid rb->DataType in texture_put_values");
  405.    }
  406. }
  407.  
  408.  
  409. static void
  410. texture_put_mono_values(struct gl_context *ctx, struct gl_renderbuffer *rb,
  411.                         GLuint count, const GLint x[], const GLint y[],
  412.                         const void *value, const GLubyte *mask)
  413. {
  414.    const struct texture_renderbuffer *trb
  415.       = (const struct texture_renderbuffer *) rb;
  416.    const GLint z = trb->Zoffset;
  417.    GLuint i;
  418.  
  419.    if (rb->DataType == CHAN_TYPE) {
  420.       const GLchan *rgba = (const GLchan *) value;
  421.       for (i = 0; i < count; i++) {
  422.          if (!mask || mask[i]) {
  423.             trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, rgba);
  424.          }
  425.       }
  426.    }
  427.    else if (rb->DataType == GL_UNSIGNED_INT) {
  428.       const GLuint zValue = *((const GLuint *) value);
  429.       for (i = 0; i < count; i++) {
  430.          if (!mask || mask[i]) {
  431.             trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, &zValue);
  432.          }
  433.       }
  434.    }
  435.    else if (rb->DataType == GL_UNSIGNED_SHORT) {
  436.       const GLushort zValue = *((const GLushort *) value);
  437.       for (i = 0; i < count; i++) {
  438.          if (!mask || mask[i]) {
  439.             trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, &zValue);
  440.          }
  441.       }
  442.    }
  443.    else if (rb->DataType == GL_UNSIGNED_INT_24_8_EXT) {
  444.       const GLuint zValue = *((const GLuint *) value);
  445.       const GLfloat flt = (GLfloat) ((zValue >> 8) * (1.0 / 0xffffff));
  446.       for (i = 0; i < count; i++) {
  447.          if (!mask || mask[i]) {
  448.             trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, &flt);
  449.          }
  450.       }
  451.    }
  452.    else if (rb->DataType == GL_UNSIGNED_INT_8_24_REV_MESA) {
  453.       const GLuint zValue = *((const GLuint *) value);
  454.       const GLfloat flt = (GLfloat) ((zValue & 0xffffff) * (1.0 / 0xffffff));
  455.       for (i = 0; i < count; i++) {
  456.          if (!mask || mask[i]) {
  457.             trb->Store(trb->TexImage, x[i], y[i] + trb->Yoffset, z, &flt);
  458.          }
  459.       }
  460.    }
  461.    else {
  462.       _mesa_problem(ctx, "invalid rb->DataType in texture_put_mono_values");
  463.    }
  464. }
  465.  
  466.  
  467. static void
  468. store_nop(struct gl_texture_image *texImage,
  469.           GLint col, GLint row, GLint img,
  470.           const void *texel)
  471. {
  472. }
  473.  
  474.  
  475. static void
  476. delete_texture_wrapper(struct gl_renderbuffer *rb)
  477. {
  478.    ASSERT(rb->RefCount == 0);
  479.    free(rb);
  480. }
  481.  
  482.  
  483. /**
  484.  * This function creates a renderbuffer object which wraps a texture image.
  485.  * The new renderbuffer is plugged into the given attachment point.
  486.  * This allows rendering into the texture as if it were a renderbuffer.
  487.  */
  488. static void
  489. wrap_texture(struct gl_context *ctx, struct gl_renderbuffer_attachment *att)
  490. {
  491.    struct texture_renderbuffer *trb;
  492.    const GLuint name = 0;
  493.  
  494.    ASSERT(att->Type == GL_TEXTURE);
  495.    ASSERT(att->Renderbuffer == NULL);
  496.  
  497.    trb = CALLOC_STRUCT(texture_renderbuffer);
  498.    if (!trb) {
  499.       _mesa_error(ctx, GL_OUT_OF_MEMORY, "wrap_texture");
  500.       return;
  501.    }
  502.  
  503.    /* init base gl_renderbuffer fields */
  504.    _mesa_init_renderbuffer(&trb->Base, name);
  505.    /* plug in our texture_renderbuffer-specific functions */
  506.    trb->Base.Delete = delete_texture_wrapper;
  507.    trb->Base.AllocStorage = NULL; /* illegal! */
  508.    trb->Base.GetRow = texture_get_row;
  509.    trb->Base.GetValues = texture_get_values;
  510.    trb->Base.PutRow = texture_put_row;
  511.    trb->Base.PutRowRGB = texture_put_row_rgb;
  512.    trb->Base.PutMonoRow = texture_put_mono_row;
  513.    trb->Base.PutValues = texture_put_values;
  514.    trb->Base.PutMonoValues = texture_put_mono_values;
  515.  
  516.    /* update attachment point */
  517.    _mesa_reference_renderbuffer(&att->Renderbuffer, &(trb->Base));
  518. }
  519.  
  520.  
  521.  
  522. /**
  523.  * Update the renderbuffer wrapper for rendering to a texture.
  524.  * For example, update the width, height of the RB based on the texture size,
  525.  * update the internal format info, etc.
  526.  */
  527. static void
  528. update_wrapper(struct gl_context *ctx, const struct gl_renderbuffer_attachment *att)
  529. {
  530.    struct texture_renderbuffer *trb
  531.       = (struct texture_renderbuffer *) att->Renderbuffer;
  532.  
  533.    (void) ctx;
  534.    ASSERT(trb);
  535.  
  536.    trb->TexImage = att->Texture->Image[att->CubeMapFace][att->TextureLevel];
  537.    ASSERT(trb->TexImage);
  538.  
  539.    trb->Store = _mesa_get_texel_store_func(trb->TexImage->TexFormat);
  540.    if (!trb->Store) {
  541.       /* we'll never draw into some textures (compressed formats) */
  542.       trb->Store = store_nop;
  543.    }
  544.  
  545.    if (att->Texture->Target == GL_TEXTURE_1D_ARRAY_EXT) {
  546.       trb->Yoffset = att->Zoffset;
  547.       trb->Zoffset = 0;
  548.    }
  549.    else {
  550.       trb->Yoffset = 0;
  551.       trb->Zoffset = att->Zoffset;
  552.    }
  553.  
  554.    trb->Base.Width = trb->TexImage->Width;
  555.    trb->Base.Height = trb->TexImage->Height;
  556.    trb->Base.InternalFormat = trb->TexImage->InternalFormat;
  557.    trb->Base.Format = trb->TexImage->TexFormat;
  558.  
  559.    /* XXX may need more special cases here */
  560.    switch (trb->TexImage->TexFormat) {
  561.    case MESA_FORMAT_Z24_S8:
  562.       trb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT;
  563.       trb->Base._BaseFormat = GL_DEPTH_STENCIL;
  564.       break;
  565.    case MESA_FORMAT_S8_Z24:
  566.       trb->Base.DataType = GL_UNSIGNED_INT_8_24_REV_MESA;
  567.       trb->Base._BaseFormat = GL_DEPTH_STENCIL;
  568.       break;
  569.    case MESA_FORMAT_Z24_X8:
  570.       trb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT;
  571.       trb->Base._BaseFormat = GL_DEPTH_COMPONENT;
  572.       break;
  573.    case MESA_FORMAT_X8_Z24:
  574.       trb->Base.DataType = GL_UNSIGNED_INT_8_24_REV_MESA;
  575.       trb->Base._BaseFormat = GL_DEPTH_COMPONENT;
  576.       break;
  577.    case MESA_FORMAT_Z16:
  578.       trb->Base.DataType = GL_UNSIGNED_SHORT;
  579.       trb->Base._BaseFormat = GL_DEPTH_COMPONENT;
  580.       break;
  581.    case MESA_FORMAT_Z32:
  582.       trb->Base.DataType = GL_UNSIGNED_INT;
  583.       trb->Base._BaseFormat = GL_DEPTH_COMPONENT;
  584.       break;
  585.    default:
  586.       trb->Base.DataType = CHAN_TYPE;
  587.       trb->Base._BaseFormat = GL_RGBA;
  588.    }
  589.    trb->Base.Data = trb->TexImage->Data;
  590. }
  591.  
  592.  
  593.  
  594. /**
  595.  * Called when rendering to a texture image begins, or when changing
  596.  * the dest mipmap level, cube face, etc.
  597.  * This is a fallback routine for software render-to-texture.
  598.  *
  599.  * Called via the glRenderbufferTexture1D/2D/3D() functions
  600.  * and elsewhere (such as glTexImage2D).
  601.  *
  602.  * The image we're rendering into is
  603.  * att->Texture->Image[att->CubeMapFace][att->TextureLevel];
  604.  * It'll never be NULL.
  605.  *
  606.  * \param fb  the framebuffer object the texture is being bound to
  607.  * \param att  the fb attachment point of the texture
  608.  *
  609.  * \sa _mesa_framebuffer_renderbuffer
  610.  */
  611. void
  612. _mesa_render_texture(struct gl_context *ctx,
  613.                      struct gl_framebuffer *fb,
  614.                      struct gl_renderbuffer_attachment *att)
  615. {
  616.    (void) fb;
  617.  
  618.    if (!att->Renderbuffer) {
  619.       wrap_texture(ctx, att);
  620.    }
  621.    update_wrapper(ctx, att);
  622. }
  623.  
  624.  
  625. void
  626. _mesa_finish_render_texture(struct gl_context *ctx,
  627.                             struct gl_renderbuffer_attachment *att)
  628. {
  629.    /* do nothing */
  630.    /* The renderbuffer texture wrapper will get deleted by the
  631.     * normal mechanism for deleting renderbuffers.
  632.     */
  633.    (void) ctx;
  634.    (void) att;
  635. }
  636.