src/mesa/drivers/dri/r300/r300_texstate.c

   1 /*
   2 Copyright (C) The Weather Channel, Inc.  2002.  All Rights Reserved.
   3
   4 The Weather Channel (TM) funded Tungsten Graphics to develop the
   5 initial release of the Radeon 8500 driver under the XFree86 license.
   6 This notice must be preserved.
   7
   8 Permission is hereby granted, free of charge, to any person obtaining
   9 a copy of this software and associated documentation files (the
  10 "Software"), to deal in the Software without restriction, including
  11 without limitation the rights to use, copy, modify, merge, publish,
  12 distribute, sublicense, and/or sell copies of the Software, and to
  13 permit persons to whom the Software is furnished to do so, subject to
  14 the following conditions:
  15
  16 The above copyright notice and this permission notice (including the
  17 next paragraph) shall be included in all copies or substantial
  18 portions of the Software.
  19
  20 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  23 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  24 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27
  28 **************************************************************************/
  29
  30 /**
  31  * \file
  32  *
  33  * \author Keith Whitwell <keith@tungstengraphics.com>
  34  *
  35  * \todo Enable R300 texture tiling code?
  36  */
  37
  38 #include "main/glheader.h"
  39 #include "main/imports.h"
  40 #include "main/context.h"
  41 #include "main/macros.h"
  42 #include "main/texformat.h"
  43 #include "main/teximage.h"
  44 #include "main/texobj.h"
  45 #include "main/enums.h"
  46
  47 #include "r300_context.h"
  48 #include "r300_state.h"
  49 #include "r300_ioctl.h"
  50 #include "radeon_mipmap_tree.h"
  51 #include "r300_tex.h"
  52 #include "r300_reg.h"
  53
  54 #define VALID_FORMAT(f) ( ((f) <= MESA_FORMAT_RGBA_DXT5                 \
  55                            || ((f) >= MESA_FORMAT_RGBA_FLOAT32 &&       \
  56                                (f) <= MESA_FORMAT_INTENSITY_FLOAT16))   \
  57                           && tx_table[f].flag )
  58
  59 #define _ASSIGN(entry, format)                          \
  60         [ MESA_FORMAT_ ## entry ] = { format, 0, 1}
  61
  62 /*
  63  * Note that the _REV formats are the same as the non-REV formats.  This is
  64  * because the REV and non-REV formats are identical as a byte string, but
  65  * differ when accessed as 16-bit or 32-bit words depending on the endianness of
  66  * the host.  Since the textures are transferred to the R300 as a byte string
  67  * (i.e. without any byte-swapping), the R300 sees the REV and non-REV formats
  68  * identically.  -- paulus
  69  */
  70
  71 static const struct tx_table {
  72         GLuint format, filter, flag;
  73 } tx_table[] = {
  74         /* *INDENT-OFF* */
  75 #ifdef MESA_LITTLE_ENDIAN
  76         _ASSIGN(RGBA8888, R300_EASY_TX_FORMAT(Y, Z, W, X, W8Z8Y8X8)),
  77         _ASSIGN(RGBA8888_REV, R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8)),
  78         _ASSIGN(ARGB8888, R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8)),
  79         _ASSIGN(ARGB8888_REV, R300_EASY_TX_FORMAT(W, Z, Y, X, W8Z8Y8X8)),
  80 #else
  81         _ASSIGN(RGBA8888, R300_EASY_TX_FORMAT(Z, Y, X, W, W8Z8Y8X8)),
  82         _ASSIGN(RGBA8888_REV, R300_EASY_TX_FORMAT(Y, Z, W, X, W8Z8Y8X8)),
  83         _ASSIGN(ARGB8888, R300_EASY_TX_FORMAT(W, Z, Y, X, W8Z8Y8X8)),
  84         _ASSIGN(ARGB8888_REV, R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8)),
  85 #endif
  86         _ASSIGN(RGB888, R300_EASY_TX_FORMAT(X, Y, Z, ONE, W8Z8Y8X8)),
  87         _ASSIGN(RGB565, R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5)),
  88         _ASSIGN(RGB565_REV, R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5)),
  89         _ASSIGN(ARGB4444, R300_EASY_TX_FORMAT(X, Y, Z, W, W4Z4Y4X4)),
  90         _ASSIGN(ARGB4444_REV, R300_EASY_TX_FORMAT(X, Y, Z, W, W4Z4Y4X4)),
  91         _ASSIGN(ARGB1555, R300_EASY_TX_FORMAT(X, Y, Z, W, W1Z5Y5X5)),
  92         _ASSIGN(ARGB1555_REV, R300_EASY_TX_FORMAT(X, Y, Z, W, W1Z5Y5X5)),
  93         _ASSIGN(AL88, R300_EASY_TX_FORMAT(X, X, X, Y, Y8X8)),
  94         _ASSIGN(AL88_REV, R300_EASY_TX_FORMAT(X, X, X, Y, Y8X8)),
  95         _ASSIGN(RGB332, R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z3Y3X2)),
  96         _ASSIGN(A8, R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, X8)),
  97         _ASSIGN(L8, R300_EASY_TX_FORMAT(X, X, X, ONE, X8)),
  98         _ASSIGN(I8, R300_EASY_TX_FORMAT(X, X, X, X, X8)),
  99         _ASSIGN(CI8, R300_EASY_TX_FORMAT(X, X, X, X, X8)),
 100         _ASSIGN(YCBCR, R300_EASY_TX_FORMAT(X, Y, Z, ONE, G8R8_G8B8) | R300_TX_FORMAT_YUV_MODE),
 101         _ASSIGN(YCBCR_REV, R300_EASY_TX_FORMAT(X, Y, Z, ONE, G8R8_G8B8) | R300_TX_FORMAT_YUV_MODE),
 102         _ASSIGN(RGB_DXT1, R300_EASY_TX_FORMAT(X, Y, Z, ONE, DXT1)),
 103         _ASSIGN(RGBA_DXT1, R300_EASY_TX_FORMAT(X, Y, Z, W, DXT1)),
 104         _ASSIGN(RGBA_DXT3, R300_EASY_TX_FORMAT(X, Y, Z, W, DXT3)),
 105         _ASSIGN(RGBA_DXT5, R300_EASY_TX_FORMAT(Y, Z, W, X, DXT5)),
 106         _ASSIGN(RGBA_FLOAT32, R300_EASY_TX_FORMAT(Z, Y, X, W, FL_R32G32B32A32)),
 107         _ASSIGN(RGBA_FLOAT16, R300_EASY_TX_FORMAT(Z, Y, X, W, FL_R16G16B16A16)),
 108         _ASSIGN(RGB_FLOAT32, 0xffffffff),
 109         _ASSIGN(RGB_FLOAT16, 0xffffffff),
 110         _ASSIGN(ALPHA_FLOAT32, R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, FL_I32)),
 111         _ASSIGN(ALPHA_FLOAT16, R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, FL_I16)),
 112         _ASSIGN(LUMINANCE_FLOAT32, R300_EASY_TX_FORMAT(X, X, X, ONE, FL_I32)),
 113         _ASSIGN(LUMINANCE_FLOAT16, R300_EASY_TX_FORMAT(X, X, X, ONE, FL_I16)),
 114         _ASSIGN(LUMINANCE_ALPHA_FLOAT32, R300_EASY_TX_FORMAT(X, X, X, Y, FL_I32A32)),
 115         _ASSIGN(LUMINANCE_ALPHA_FLOAT16, R300_EASY_TX_FORMAT(X, X, X, Y, FL_I16A16)),
 116         _ASSIGN(INTENSITY_FLOAT32, R300_EASY_TX_FORMAT(X, X, X, X, FL_I32)),
 117         _ASSIGN(INTENSITY_FLOAT16, R300_EASY_TX_FORMAT(X, X, X, X, FL_I16)),
 118         _ASSIGN(Z16, R300_EASY_TX_FORMAT(X, X, X, X, X16)),
 119         _ASSIGN(Z24_S8, R300_EASY_TX_FORMAT(X, X, X, X, X24_Y8)),
 120         _ASSIGN(Z32, R300_EASY_TX_FORMAT(X, X, X, X, X32)),
 121         /* *INDENT-ON* */
 122 };
 123
 124 #undef _ASSIGN
 125
 126 void r300SetDepthTexMode(struct gl_texture_object *tObj)
 127 {
 128         static const GLuint formats[3][3] = {
 129                 {
 130                         R300_EASY_TX_FORMAT(X, X, X, ONE, X16),
 131                         R300_EASY_TX_FORMAT(X, X, X, X, X16),
 132                         R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, X16),
 133                 },
 134                 {
 135                         R300_EASY_TX_FORMAT(X, X, X, ONE, X24_Y8),
 136                         R300_EASY_TX_FORMAT(X, X, X, X, X24_Y8),
 137                         R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, X24_Y8),
 138                 },
 139                 {
 140                         R300_EASY_TX_FORMAT(X, X, X, ONE, X32),
 141                         R300_EASY_TX_FORMAT(X, X, X, X, X32),
 142                         R300_EASY_TX_FORMAT(ZERO, ZERO, ZERO, X, X32),
 143                 },
 144         };
 145         const GLuint *format;
 146         radeonTexObjPtr t;
 147
 148         if (!tObj)
 149                 return;
 150
 151         t = radeon_tex_obj(tObj);
 152
 153         switch (tObj->Image[0][tObj->BaseLevel]->TexFormat->MesaFormat) {
 154         case MESA_FORMAT_Z16:
 155                 format = formats[0];
 156                 break;
 157         case MESA_FORMAT_Z24_S8:
 158                 format = formats[1];
 159                 break;
 160         case MESA_FORMAT_Z32:
 161                 format = formats[2];
 162                 break;
 163         default:
 164                 /* Error...which should have already been caught by higher
 165                  * levels of Mesa.
 166                  */
 167                 ASSERT(0);
 168                 return;
 169         }
 170
 171         switch (tObj->DepthMode) {
 172         case GL_LUMINANCE:
 173                 t->pp_txformat = format[0];
 174                 break;
 175         case GL_INTENSITY:
 176                 t->pp_txformat = format[1];
 177                 break;
 178         case GL_ALPHA:
 179                 t->pp_txformat = format[2];
 180                 break;
 181         default:
 182                 /* Error...which should have already been caught by higher
 183                  * levels of Mesa.
 184                  */
 185                 ASSERT(0);
 186                 return;
 187         }
 188 }
 189
 190
 191 /**
 192  * Compute the cached hardware register values for the given texture object.
 193  *
 194  * \param rmesa Context pointer
 195  * \param t the r300 texture object
 196  */
 197 static void setup_hardware_state(r300ContextPtr rmesa, radeonTexObj *t)
 198 {
 199         const struct gl_texture_image *firstImage;
 200         int firstlevel = t->mt ? t->mt->firstLevel : 0;
 201
 202         firstImage = t->base.Image[0][firstlevel];
 203
 204         if (!t->image_override
 205             && VALID_FORMAT(firstImage->TexFormat->MesaFormat)) {
 206                 if (firstImage->TexFormat->BaseFormat == GL_DEPTH_COMPONENT) {
 207                         r300SetDepthTexMode(&t->base);
 208                 } else {
 209                         t->pp_txformat = tx_table[firstImage->TexFormat->MesaFormat].format;
 210                 }
 211
 212                 t->pp_txfilter |= tx_table[firstImage->TexFormat->MesaFormat].filter;
 213         } else if (!t->image_override) {
 214                 _mesa_problem(NULL, "unexpected texture format in %s",
 215                               __FUNCTION__);
 216                 return;
 217         }
 218
 219         if (t->image_override && t->bo)
 220                 return;
 221
 222         t->pp_txsize = (((firstImage->Width - 1) << R300_TX_WIDTHMASK_SHIFT)
 223                         | ((firstImage->Height - 1) << R300_TX_HEIGHTMASK_SHIFT)
 224                         | ((firstImage->DepthLog2) << R300_TX_DEPTHMASK_SHIFT)
 225                         | ((t->mt->lastLevel - t->mt->firstLevel) << R300_TX_MAX_MIP_LEVEL_SHIFT));
 226
 227         t->tile_bits = 0;
 228
 229         if (t->base.Target == GL_TEXTURE_CUBE_MAP)
 230                 t->pp_txformat |= R300_TX_FORMAT_CUBIC_MAP;
 231         if (t->base.Target == GL_TEXTURE_3D)
 232                 t->pp_txformat |= R300_TX_FORMAT_3D;
 233
 234
 235         if (t->base.Target == GL_TEXTURE_RECTANGLE_NV) {
 236                 unsigned int align = (64 / t->mt->bpp) - 1;
 237                 t->pp_txsize |= R300_TX_SIZE_TXPITCH_EN;
 238                 if (!t->image_override)
 239                         t->pp_txpitch = ((firstImage->Width + align) & ~align) - 1;
 240         }
 241
 242         if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515) {
 243             if (firstImage->Width > 2048)
 244                 t->pp_txpitch |= R500_TXWIDTH_BIT11;
 245             if (firstImage->Height > 2048)
 246                 t->pp_txpitch |= R500_TXHEIGHT_BIT11;
 247         }
 248 }
 249
 250 /**
 251  * Ensure the given texture is ready for rendering.
 252  *
 253  * Mostly this means populating the texture object's mipmap tree.
 254  */
 255 static GLboolean r300_validate_texture(GLcontext * ctx, struct gl_texture_object *texObj)
 256 {
 257         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 258         radeonTexObj *t = radeon_tex_obj(texObj);
 259
 260         if (!radeon_validate_texture_miptree(ctx, texObj))
 261                 return GL_FALSE;
 262
 263         /* Configure the hardware registers (more precisely, the cached version
 264          * of the hardware registers). */
 265         setup_hardware_state(rmesa, t);
 266
 267         t->validated = GL_TRUE;
 268         return GL_TRUE;
 269 }
 270
 271 /**
 272  * Ensure all enabled and complete textures are uploaded along with any buffers being used.
 273  */
 274 GLboolean r300ValidateBuffers(GLcontext * ctx)
 275 {
 276         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 277         struct radeon_renderbuffer *rrb;
 278         int i;
 279
 280         radeon_validate_reset_bos(&rmesa->radeon);
 281
 282         rrb = radeon_get_colorbuffer(&rmesa->radeon);
 283         /* color buffer */
 284         if (rrb && rrb->bo) {
 285                 radeon_validate_bo(&rmesa->radeon, rrb->bo,
 286                                    0, RADEON_GEM_DOMAIN_VRAM);
 287         }
 288
 289         /* depth buffer */
 290         rrb = radeon_get_depthbuffer(&rmesa->radeon);
 291         if (rrb && rrb->bo) {
 292                 radeon_validate_bo(&rmesa->radeon, rrb->bo,
 293                                    0, RADEON_GEM_DOMAIN_VRAM);
 294         }
 295
 296         for (i = 0; i < ctx->Const.MaxTextureImageUnits; ++i) {
 297                 radeonTexObj *t;
 298
 299                 if (!ctx->Texture.Unit[i]._ReallyEnabled)
 300                         continue;
 301
 302                 if (!r300_validate_texture(ctx, ctx->Texture.Unit[i]._Current)) {
 303                         _mesa_warning(ctx,
 304                                       "failed to validate texture for unit %d.\n",
 305                                       i);
 306                 }
 307                 t = radeon_tex_obj(ctx->Texture.Unit[i]._Current);
 308                 if (t->image_override && t->bo)
 309                         radeon_validate_bo(&rmesa->radeon, t->bo,
 310                                            RADEON_GEM_DOMAIN_GTT | RADEON_GEM_DOMAIN_VRAM, 0);
 311
 312                 else if (t->mt->bo)
 313                         radeon_validate_bo(&rmesa->radeon, t->mt->bo,
 314                                            RADEON_GEM_DOMAIN_GTT | RADEON_GEM_DOMAIN_VRAM, 0);
 315         }
 316
 317         return radeon_revalidate_bos(ctx);
 318 }
 319
 320 void r300SetTexOffset(__DRIcontext * pDRICtx, GLint texname,
 321                       unsigned long long offset, GLint depth, GLuint pitch)
 322 {
 323         r300ContextPtr rmesa = pDRICtx->driverPrivate;
 324         struct gl_texture_object *tObj =
 325             _mesa_lookup_texture(rmesa->radeon.glCtx, texname);
 326         radeonTexObjPtr t = radeon_tex_obj(tObj);
 327         uint32_t pitch_val;
 328
 329         if (!tObj)
 330                 return;
 331
 332         t->image_override = GL_TRUE;
 333
 334         if (!offset)
 335                 return;
 336
 337         t->bo = NULL;
 338         t->override_offset = offset;
 339         t->pp_txpitch &= (1 << 13) -1;
 340         pitch_val = pitch;
 341
 342         switch (depth) {
 343         case 32:
 344                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8);
 345                 t->pp_txfilter |= tx_table[2].filter;
 346                 pitch_val /= 4;
 347                 break;
 348         case 24:
 349         default:
 350                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, W8Z8Y8X8);
 351                 t->pp_txfilter |= tx_table[4].filter;
 352                 pitch_val /= 4;
 353                 break;
 354         case 16:
 355                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5);
 356                 t->pp_txfilter |= tx_table[5].filter;
 357                 pitch_val /= 2;
 358                 break;
 359         }
 360         pitch_val--;
 361
 362         t->pp_txpitch |= pitch_val;
 363 }
 364
 365 void r300SetTexBuffer2(__DRIcontext *pDRICtx, GLint target, GLint glx_texture_format, __DRIdrawable *dPriv)
 366 {
 367         struct gl_texture_unit *texUnit;
 368         struct gl_texture_object *texObj;
 369         struct gl_texture_image *texImage;
 370         struct radeon_renderbuffer *rb;
 371         radeon_texture_image *rImage;
 372         radeonContextPtr radeon;
 373         r300ContextPtr rmesa;
 374         struct radeon_framebuffer *rfb;
 375         radeonTexObjPtr t;
 376         uint32_t pitch_val;
 377         uint32_t internalFormat, type, format;
 378
 379         type = GL_BGRA;
 380         format = GL_UNSIGNED_BYTE;
 381         internalFormat = (glx_texture_format == GLX_TEXTURE_FORMAT_RGB_EXT ? 3 : 4);
 382
 383         radeon = pDRICtx->driverPrivate;
 384         rmesa = pDRICtx->driverPrivate;
 385
 386         rfb = dPriv->driverPrivate;
 387         texUnit = &radeon->glCtx->Texture.Unit[radeon->glCtx->Texture.CurrentUnit];
 388         texObj = _mesa_select_tex_object(radeon->glCtx, texUnit, target);
 389         texImage = _mesa_get_tex_image(radeon->glCtx, texObj, target, 0);
 390
 391         rImage = get_radeon_texture_image(texImage);
 392         t = radeon_tex_obj(texObj);
 393         if (t == NULL) {
 394             return;
 395         }
 396
 397         radeon_update_renderbuffers(pDRICtx, dPriv);
 398         /* back & depth buffer are useless free them right away */
 399         rb = (void*)rfb->base.Attachment[BUFFER_DEPTH].Renderbuffer;
 400         if (rb && rb->bo) {
 401                 radeon_bo_unref(rb->bo);
 402         rb->bo = NULL;
 403         }
 404         rb = (void*)rfb->base.Attachment[BUFFER_BACK_LEFT].Renderbuffer;
 405         if (rb && rb->bo) {
 406                 radeon_bo_unref(rb->bo);
 407                 rb->bo = NULL;
 408         }
 409         rb = rfb->color_rb[0];
 410         if (rb->bo == NULL) {
 411                 /* Failed to BO for the buffer */
 412                 return;
 413         }
 414
 415         _mesa_lock_texture(radeon->glCtx, texObj);
 416         if (t->bo) {
 417                 radeon_bo_unref(t->bo);
 418                 t->bo = NULL;
 419         }
 420         if (rImage->bo) {
 421                 radeon_bo_unref(rImage->bo);
 422                 rImage->bo = NULL;
 423         }
 424         if (t->mt) {
 425                 radeon_miptree_unreference(t->mt);
 426                 t->mt = NULL;
 427         }
 428         if (rImage->mt) {
 429                 radeon_miptree_unreference(rImage->mt);
 430                 rImage->mt = NULL;
 431         }
 432         fprintf(stderr,"settexbuf %dx%d@%d %d targ %x format %x\n", rb->width, rb->height, rb->cpp, rb->pitch, target, format);
 433         _mesa_init_teximage_fields(radeon->glCtx, target, texImage,
 434                                    rb->width, rb->height, 1, 0, rb->cpp);
 435         texImage->RowStride = rb->pitch / rb->cpp;
 436         texImage->TexFormat = radeonChooseTextureFormat(radeon->glCtx,
 437                                                         internalFormat,
 438                                                         type, format, 0);
 439         rImage->bo = rb->bo;
 440         radeon_bo_ref(rImage->bo);
 441         t->bo = rb->bo;
 442         radeon_bo_ref(t->bo);
 443         t->tile_bits = 0;
 444         t->image_override = GL_TRUE;
 445         t->override_offset = 0;
 446         t->pp_txpitch &= (1 << 13) -1;
 447         pitch_val = rb->pitch;
 448         switch (rb->cpp) {
 449         case 4:
 450                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, W, W8Z8Y8X8);
 451                 t->pp_txfilter |= tx_table[2].filter;
 452                 pitch_val /= 4;
 453                 break;
 454         case 3:
 455         default:
 456                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, W8Z8Y8X8);
 457                 t->pp_txfilter |= tx_table[4].filter;
 458                 pitch_val /= 4;
 459                 break;
 460         case 2:
 461                 t->pp_txformat = R300_EASY_TX_FORMAT(X, Y, Z, ONE, Z5Y6X5);
 462                 t->pp_txfilter |= tx_table[5].filter;
 463                 pitch_val /= 2;
 464                 break;
 465         }
 466         pitch_val--;
 467         t->pp_txsize = ((rb->width - 1) << R300_TX_WIDTHMASK_SHIFT) |
 468               ((rb->height - 1) << R300_TX_HEIGHTMASK_SHIFT);
 469         t->pp_txsize |= R300_TX_SIZE_TXPITCH_EN;
 470         t->pp_txpitch |= pitch_val;
 471
 472         if (rmesa->radeon.radeonScreen->chip_family >= CHIP_FAMILY_RV515) {
 473             if (rb->width > 2048)
 474                 t->pp_txpitch |= R500_TXWIDTH_BIT11;
 475             if (rb->height > 2048)
 476                 t->pp_txpitch |= R500_TXHEIGHT_BIT11;
 477         }
 478         t->validated = GL_TRUE;
 479         _mesa_unlock_texture(radeon->glCtx, texObj);
 480         return;
 481 }
 482
 483 void r300SetTexBuffer(__DRIcontext *pDRICtx, GLint target, __DRIdrawable *dPriv)
 484 {
 485         r300SetTexBuffer2(pDRICtx, target, GLX_TEXTURE_FORMAT_RGBA_EXT, dPriv);
 486 }