projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
small fix to match new _mesa_rescale_teximage2d
[mesa.git] / src / mesa / drivers / dri / tdfx / tdfx_tex.c
1 /* -*- mode: c; c-basic-offset: 3 -*-
2 *
3 * Copyright 2000 VA Linux Systems Inc., Fremont, California.
4 *
5 * All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the next
15 * paragraph) shall be included in all copies or substantial portions of the
16 * Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * VA LINUX SYSTEMS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
22 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
23 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
24 * SOFTWARE.
25 */
26 /* $XFree86: xc/lib/GL/mesa/src/drv/tdfx/tdfx_tex.c,v 1.7 2002/11/05 17:46:10 tsi Exp $ */
27
28 /*
29 * New fixes:
30 * Daniel Borca <dborca@users.sourceforge.net>, 19 Jul 2004
31 *
32 * Original rewrite:
33 * Gareth Hughes <gareth@valinux.com>, 29 Sep - 1 Oct 2000
34 *
35 * Authors:
36 * Gareth Hughes <gareth@valinux.com>
37 * Brian Paul <brianp@valinux.com>
38 *
39 */
40
41 #include "image.h"
42 #include "texcompress.h"
43 #include "texformat.h"
44 #include "teximage.h"
45 #include "texstore.h"
46 #include "texobj.h"
47 #include "tdfx_context.h"
48 #include "tdfx_tex.h"
49 #include "tdfx_texman.h"
50
51
52 /* no borders! can't halve 1x1! (stride > width * comp) not allowed */
53 void
54 _mesa_halve2x2_teximage2d ( GLcontext *ctx,
55 struct gl_texture_image *texImage,
56 GLuint bytesPerPixel,
57 GLint srcWidth, GLint srcHeight,
58 const GLvoid *srcImage, GLvoid *dstImage )
59 {
60 GLint i, j, k;
61 GLint dstWidth = srcWidth / 2;
62 GLint dstHeight = srcHeight / 2;
63 GLint srcRowStride = srcWidth * bytesPerPixel;
64 GLubyte *src = (GLubyte *)srcImage;
65 GLubyte *dst = dstImage;
66
67 GLuint bpt = 0;
68 GLubyte *_s = NULL;
69 GLubyte *_d = NULL;
70 GLenum _t;
71
72 if (texImage->TexFormat->MesaFormat == MESA_FORMAT_RGB565) {
73 _t = GL_UNSIGNED_SHORT_5_6_5_REV;
74 bpt = bytesPerPixel;
75 } else if (texImage->TexFormat->MesaFormat == MESA_FORMAT_ARGB4444) {
76 _t = GL_UNSIGNED_SHORT_4_4_4_4_REV;
77 bpt = bytesPerPixel;
78 } else if (texImage->TexFormat->MesaFormat == MESA_FORMAT_ARGB1555) {
79 _t = GL_UNSIGNED_SHORT_1_5_5_5_REV;
80 bpt = bytesPerPixel;
81 }
82 if (bpt) {
83 bytesPerPixel = 4;
84 srcRowStride = srcWidth * bytesPerPixel;
85 if (dstWidth == 0) {
86 dstWidth = 1;
87 }
88 if (dstHeight == 0) {
89 dstHeight = 1;
90 }
91 _s = src = MALLOC(srcRowStride * srcHeight);
92 _d = dst = MALLOC(dstWidth * bytesPerPixel * dstHeight);
93 _mesa_texstore_rgba8888(ctx, 2, GL_RGBA,
94 &_mesa_texformat_rgba8888_rev, src,
95 0, 0, 0, /* dstX/Y/Zoffset */
96 srcRowStride, /* dstRowStride */
97 0, /* dstImageStride */
98 srcWidth, srcHeight, 1,
99 texImage->Format, _t, srcImage, &ctx->DefaultPacking);
100 }
101
102 if (srcHeight == 1) {
103 for (i = 0; i < dstWidth; i++) {
104 for (k = 0; k < bytesPerPixel; k++) {
105 dst[0] = (src[0] + src[bytesPerPixel] + 1) / 2;
106 src++;
107 dst++;
108 }
109 src += bytesPerPixel;
110 }
111 } else if (srcWidth == 1) {
112 for (j = 0; j < dstHeight; j++) {
113 for (k = 0; k < bytesPerPixel; k++) {
114 dst[0] = (src[0] + src[srcRowStride] + 1) / 2;
115 src++;
116 dst++;
117 }
118 src += srcRowStride;
119 }
120 } else {
121 for (j = 0; j < dstHeight; j++) {
122 for (i = 0; i < dstWidth; i++) {
123 for (k = 0; k < bytesPerPixel; k++) {
124 dst[0] = (src[0] +
125 src[bytesPerPixel] +
126 src[srcRowStride] +
127 src[srcRowStride + bytesPerPixel] + 2) / 4;
128 src++;
129 dst++;
130 }
131 src += bytesPerPixel;
132 }
133 src += srcRowStride;
134 }
135 }
136
137 if (bpt) {
138 src = _s;
139 dst = _d;
140 texImage->TexFormat->StoreImage(ctx, 2, texImage->Format,
141 texImage->TexFormat, dstImage,
142 0, 0, 0, /* dstX/Y/Zoffset */
143 dstWidth * bpt,
144 0, /* dstImageStride */
145 dstWidth, dstHeight, 1,
146 GL_BGRA, CHAN_TYPE, dst, &ctx->DefaultPacking);
147 FREE(dst);
148 FREE(src);
149 }
150 }
151
152
153 static int
154 logbase2(int n)
155 {
156 GLint i = 1;
157 GLint log2 = 0;
158
159 if (n < 0) {
160 return -1;
161 }
162
163 while (n > i) {
164 i *= 2;
165 log2++;
166 }
167 if (i != n) {
168 return -1;
169 }
170 else {
171 return log2;
172 }
173 }
174
175
176 /*
177 * Compute various texture image parameters.
178 * Input: w, h - source texture width and height
179 * Output: lodlevel - Glide lod level token for the larger texture dimension
180 * aspectratio - Glide aspect ratio token
181 * sscale - S scale factor used during triangle setup
182 * tscale - T scale factor used during triangle setup
183 * wscale - OpenGL -> Glide image width scale factor
184 * hscale - OpenGL -> Glide image height scale factor
185 *
186 * Sample results:
187 * w h lodlevel aspectRatio
188 * 128 128 GR_LOD_LOG2_128 (=7) GR_ASPECT_LOG2_1x1 (=0)
189 * 64 64 GR_LOD_LOG2_64 (=6) GR_ASPECT_LOG2_1x1 (=0)
190 * 64 32 GR_LOD_LOG2_64 (=6) GR_ASPECT_LOG2_2x1 (=1)
191 * 32 64 GR_LOD_LOG2_64 (=6) GR_ASPECT_LOG2_1x2 (=-1)
192 * 32 32 GR_LOD_LOG2_32 (=5) GR_ASPECT_LOG2_1x1 (=0)
193 */
194 static void
195 tdfxTexGetInfo(const GLcontext *ctx, int w, int h,
196 GrLOD_t *lodlevel, GrAspectRatio_t *aspectratio,
197 float *sscale, float *tscale,
198 int *wscale, int *hscale)
199 {
200 int logw, logh, ar, lod, ws, hs;
201 float s, t;
202
203 ASSERT(w >= 1);
204 ASSERT(h >= 1);
205
206 logw = logbase2(w);
207 logh = logbase2(h);
208 ar = logw - logh; /* aspect ratio = difference in log dimensions */
209 s = t = 256.0;
210 ws = hs = 1;
211
212 /* Hardware only allows a maximum aspect ratio of 8x1, so handle
213 |ar| > 3 by scaling the image and using an 8x1 aspect ratio */
214 if (ar >= 0) {
215 ASSERT(w >= h);
216 lod = logw;
217 if (ar <= GR_ASPECT_LOG2_8x1) {
218 t = 256 >> ar;
219 }
220 else {
221 /* have to stretch image height */
222 t = 32.0;
223 hs = 1 << (ar - 3);
224 ar = GR_ASPECT_LOG2_8x1;
225 }
226 }
227 else {
228 ASSERT(w < h);
229 lod = logh;
230 if (ar >= GR_ASPECT_LOG2_1x8) {
231 s = 256 >> -ar;
232 }
233 else {
234 /* have to stretch image width */
235 s = 32.0;
236 ws = 1 << (-ar - 3);
237 ar = GR_ASPECT_LOG2_1x8;
238 }
239 }
240
241 if (lodlevel)
242 *lodlevel = (GrLOD_t) lod;
243 if (aspectratio)
244 *aspectratio = (GrAspectRatio_t) ar;
245 if (sscale)
246 *sscale = s;
247 if (tscale)
248 *tscale = t;
249 if (wscale)
250 *wscale = ws;
251 if (hscale)
252 *hscale = hs;
253 }
254
255
256 /*
257 * We need to call this when a texture object's minification filter
258 * or texture image sizes change.
259 */
260 static void RevalidateTexture(GLcontext *ctx, struct gl_texture_object *tObj)
261 {
262 tdfxTexInfo *ti = TDFX_TEXTURE_DATA(tObj);
263 GLint minl, maxl;
264
265 if (!ti)
266 return;
267
268 minl = maxl = tObj->BaseLevel;
269
270 if (tObj->Image[0][minl]) {
271 maxl = MIN2(tObj->MaxLevel, tObj->Image[0][minl]->MaxLog2);
272
273 /* compute largeLodLog2, aspect ratio and texcoord scale factors */
274 tdfxTexGetInfo(ctx, tObj->Image[0][minl]->Width, tObj->Image[0][minl]->Height,
275 &ti->info.largeLodLog2,
276 &ti->info.aspectRatioLog2,
277 &(ti->sScale), &(ti->tScale), NULL, NULL);
278 }
279
280 if (tObj->Image[0][maxl] && (tObj->MinFilter != GL_NEAREST) && (tObj->MinFilter != GL_LINEAR)) {
281 /* mipmapping: need to compute smallLodLog2 */
282 tdfxTexGetInfo(ctx, tObj->Image[0][maxl]->Width,
283 tObj->Image[0][maxl]->Height,
284 &ti->info.smallLodLog2, NULL,
285 NULL, NULL, NULL, NULL);
286 }
287 else {
288 /* not mipmapping: smallLodLog2 = largeLodLog2 */
289 ti->info.smallLodLog2 = ti->info.largeLodLog2;
290 maxl = minl;
291 }
292
293 ti->minLevel = minl;
294 ti->maxLevel = maxl;
295 ti->info.data = NULL;
296
297 /* this is necessary because of fxDDCompressedTexImage2D */
298 if (ti->padded) {
299 struct gl_texture_image *texImage = tObj->Image[0][minl];
300 tdfxMipMapLevel *mml = TDFX_TEXIMAGE_DATA(texImage);
301 if (mml->wScale != 1 || mml->hScale != 1) {
302 ti->sScale /= mml->wScale;
303 ti->tScale /= mml->hScale;
304 }
305 }
306 }
307
308
309 static tdfxTexInfo *
310 fxAllocTexObjData(tdfxContextPtr fxMesa)
311 {
312 tdfxTexInfo *ti;
313
314 if (!(ti = CALLOC(sizeof(tdfxTexInfo)))) {
315 _mesa_problem(NULL, "tdfx driver: out of memory");
316 return NULL;
317 }
318
319 ti->isInTM = GL_FALSE;
320
321 ti->whichTMU = TDFX_TMU_NONE;
322
323 ti->tm[TDFX_TMU0] = NULL;
324 ti->tm[TDFX_TMU1] = NULL;
325
326 ti->minFilt = GR_TEXTUREFILTER_POINT_SAMPLED;
327 ti->magFilt = GR_TEXTUREFILTER_BILINEAR;
328
329 ti->sClamp = GR_TEXTURECLAMP_WRAP;
330 ti->tClamp = GR_TEXTURECLAMP_WRAP;
331
332 ti->mmMode = GR_MIPMAP_NEAREST;
333 ti->LODblend = FXFALSE;
334
335 return ti;
336 }
337
338
339 /*
340 * Called via glBindTexture.
341 */
342 static void
343 tdfxBindTexture(GLcontext * ctx, GLenum target,
344 struct gl_texture_object *tObj)
345 {
346 tdfxContextPtr fxMesa = TDFX_CONTEXT(ctx);
347 tdfxTexInfo *ti;
348
349 if (MESA_VERBOSE & VERBOSE_DRIVER) {
350 fprintf(stderr, "fxmesa: fxDDTexBind(%d,%p)\n", tObj->Name,
351 tObj->DriverData);
352 }
353
354 if ((target != GL_TEXTURE_1D) && (target != GL_TEXTURE_2D))
355 return;
356
357 if (!tObj->DriverData) {
358 tObj->DriverData = fxAllocTexObjData(fxMesa);
359 }
360
361 ti = TDFX_TEXTURE_DATA(tObj);
362 ti->lastTimeUsed = fxMesa->texBindNumber++;
363
364 fxMesa->new_state |= TDFX_NEW_TEXTURE;
365 }
366
367
368 /*
369 * Called via glTexEnv.
370 */
371 static void
372 tdfxTexEnv(GLcontext * ctx, GLenum target, GLenum pname,
373 const GLfloat * param)
374 {
375 tdfxContextPtr fxMesa = TDFX_CONTEXT(ctx);
376
377 if ( TDFX_DEBUG & DEBUG_VERBOSE_API ) {
378 if (param)
379 fprintf(stderr, "fxmesa: texenv(%x,%x)\n", pname,
380 (GLint) (*param));
381 else
382 fprintf(stderr, "fxmesa: texenv(%x)\n", pname);
383 }
384
385 /* XXX this is a bit of a hack to force the Glide texture
386 * state to be updated.
387 */
388 fxMesa->TexState.EnvMode[ctx->Texture.CurrentUnit] = 0;
389
390 fxMesa->new_state |= TDFX_NEW_TEXTURE;
391 }
392
393
394 /*
395 * Called via glTexParameter.
396 */
397 static void
398 tdfxTexParameter(GLcontext * ctx, GLenum target,
399 struct gl_texture_object *tObj,
400 GLenum pname, const GLfloat * params)
401 {
402 tdfxContextPtr fxMesa = TDFX_CONTEXT(ctx);
403 GLenum param = (GLenum) (GLint) params[0];
404 tdfxTexInfo *ti;
405
406 if (MESA_VERBOSE & VERBOSE_DRIVER) {
407 fprintf(stderr, "fxmesa: fxDDTexParam(%d,%p,%x,%x)\n", tObj->Name,
408 tObj->DriverData, pname, param);
409 }
410
411 if ((target != GL_TEXTURE_1D) && (target != GL_TEXTURE_2D))
412 return;
413
414 if (!tObj->DriverData)
415 tObj->DriverData = fxAllocTexObjData(fxMesa);
416
417 ti = TDFX_TEXTURE_DATA(tObj);
418
419 switch (pname) {
420 case GL_TEXTURE_MIN_FILTER:
421 switch (param) {
422 case GL_NEAREST:
423 ti->mmMode = GR_MIPMAP_DISABLE;
424 ti->minFilt = GR_TEXTUREFILTER_POINT_SAMPLED;
425 ti->LODblend = FXFALSE;
426 break;
427 case GL_LINEAR:
428 ti->mmMode = GR_MIPMAP_DISABLE;
429 ti->minFilt = GR_TEXTUREFILTER_BILINEAR;
430 ti->LODblend = FXFALSE;
431 break;
432 case GL_NEAREST_MIPMAP_LINEAR:
433 if (!fxMesa->Glide.HaveCombineExt) {
434 if (fxMesa->haveTwoTMUs) {
435 ti->mmMode = GR_MIPMAP_NEAREST;
436 ti->LODblend = FXTRUE;
437 }
438 else {
439 ti->mmMode = GR_MIPMAP_NEAREST_DITHER;
440 ti->LODblend = FXFALSE;
441 }
442 ti->minFilt = GR_TEXTUREFILTER_POINT_SAMPLED;
443 break;
444 }
445 /* XXX Voodoo3/Banshee mipmap blending seems to produce
446 * incorrectly filtered colors for the smallest mipmap levels.
447 * To work-around we fall-through here and use a different filter.
448 */
449 case GL_NEAREST_MIPMAP_NEAREST:
450 ti->mmMode = GR_MIPMAP_NEAREST;
451 ti->minFilt = GR_TEXTUREFILTER_POINT_SAMPLED;
452 ti->LODblend = FXFALSE;
453 break;
454 case GL_LINEAR_MIPMAP_LINEAR:
455 if (!fxMesa->Glide.HaveCombineExt) {
456 if (fxMesa->haveTwoTMUs) {
457 ti->mmMode = GR_MIPMAP_NEAREST;
458 ti->LODblend = FXTRUE;
459 }
460 else {
461 ti->mmMode = GR_MIPMAP_NEAREST_DITHER;
462 ti->LODblend = FXFALSE;
463 }
464 ti->minFilt = GR_TEXTUREFILTER_BILINEAR;
465 break;
466 }
467 /* XXX Voodoo3/Banshee mipmap blending seems to produce
468 * incorrectly filtered colors for the smallest mipmap levels.
469 * To work-around we fall-through here and use a different filter.
470 */
471 case GL_LINEAR_MIPMAP_NEAREST:
472 ti->mmMode = GR_MIPMAP_NEAREST;
473 ti->minFilt = GR_TEXTUREFILTER_BILINEAR;
474 ti->LODblend = FXFALSE;
475 break;
476 default:
477 break;
478 }
479 ti->reloadImages = GL_TRUE;
480 RevalidateTexture(ctx, tObj);
481 fxMesa->new_state |= TDFX_NEW_TEXTURE;
482 break;
483
484 case GL_TEXTURE_MAG_FILTER:
485 switch (param) {
486 case GL_NEAREST:
487 ti->magFilt = GR_TEXTUREFILTER_POINT_SAMPLED;
488 break;
489 case GL_LINEAR:
490 ti->magFilt = GR_TEXTUREFILTER_BILINEAR;
491 break;
492 default:
493 break;
494 }
495 fxMesa->new_state |= TDFX_NEW_TEXTURE;
496 break;
497
498 case GL_TEXTURE_WRAP_S:
499 switch (param) {
500 case GL_CLAMP_TO_BORDER:
501 case GL_CLAMP_TO_EDGE:
502 case GL_CLAMP:
503 ti->sClamp = GR_TEXTURECLAMP_CLAMP;
504 break;
505 case GL_REPEAT:
506 ti->sClamp = GR_TEXTURECLAMP_WRAP;
507 break;
508 case GL_MIRRORED_REPEAT:
509 ti->sClamp = GR_TEXTURECLAMP_MIRROR_EXT;
510 break;
511 default:
512 break;
513 }
514 fxMesa->new_state |= TDFX_NEW_TEXTURE;
515 break;
516
517 case GL_TEXTURE_WRAP_T:
518 switch (param) {
519 case GL_CLAMP_TO_BORDER:
520 case GL_CLAMP_TO_EDGE:
521 case GL_CLAMP:
522 ti->tClamp = GR_TEXTURECLAMP_CLAMP;
523 break;
524 case GL_REPEAT:
525 ti->tClamp = GR_TEXTURECLAMP_WRAP;
526 break;
527 case GL_MIRRORED_REPEAT:
528 ti->tClamp = GR_TEXTURECLAMP_MIRROR_EXT;
529 break;
530 default:
531 break;
532 }
533 fxMesa->new_state |= TDFX_NEW_TEXTURE;
534 break;
535
536 case GL_TEXTURE_BORDER_COLOR:
537 /* TO DO */
538 break;
539 case GL_TEXTURE_MIN_LOD:
540 /* TO DO */
541 break;
542 case GL_TEXTURE_MAX_LOD:
543 /* TO DO */
544 break;
545 case GL_TEXTURE_BASE_LEVEL:
546 RevalidateTexture(ctx, tObj);
547 break;
548 case GL_TEXTURE_MAX_LEVEL:
549 RevalidateTexture(ctx, tObj);
550 break;
551
552 default:
553 break;
554 }
555 }
556
557
558 /*
559 * Called via glDeleteTextures to delete a texture object.
560 * Here, we delete the Glide data associated with the texture.
561 */
562 static void
563 tdfxDeleteTexture(GLcontext * ctx, struct gl_texture_object *tObj)
564 {
565 if (ctx && ctx->DriverCtx) {
566 tdfxContextPtr fxMesa = TDFX_CONTEXT(ctx);
567 tdfxTMFreeTexture(fxMesa, tObj);
568 fxMesa->new_state |= TDFX_NEW_TEXTURE;
569 /* Free mipmap images and the texture object itself */
570 _mesa_delete_texture_object(ctx, tObj);
571 }
572 }
573
574
575 /*
576 * Return true if texture is resident, false otherwise.
577 */
578 static GLboolean
579 tdfxIsTextureResident(GLcontext *ctx, struct gl_texture_object *tObj)
580 {
581 tdfxTexInfo *ti = TDFX_TEXTURE_DATA(tObj);
582 return (GLboolean) (ti && ti->isInTM);
583 }
584
585
586
587 /*
588 * Convert a gl_color_table texture palette to Glide's format.
589 */
590 static GrTexTable_t
591 convertPalette(FxU32 data[256], const struct gl_color_table *table)
592 {
593 const GLubyte *tableUB = (const GLubyte *) table->Table;
594 GLint width = table->Size;
595 FxU32 r, g, b, a;
596 GLint i;
597
598 ASSERT(table->Type == GL_UNSIGNED_BYTE);
599
600 switch (table->Format) {
601 case GL_INTENSITY:
602 for (i = 0; i < width; i++) {
603 r = tableUB[i];
604 g = tableUB[i];
605 b = tableUB[i];
606 a = tableUB[i];
607 data[i] = (a << 24) | (r << 16) | (g << 8) | b;
608 }
609 return GR_TEXTABLE_PALETTE_6666_EXT;
610 case GL_LUMINANCE:
611 for (i = 0; i < width; i++) {
612 r = tableUB[i];
613 g = tableUB[i];
614 b = tableUB[i];
615 a = 255;
616 data[i] = (a << 24) | (r << 16) | (g << 8) | b;
617 }
618 return GR_TEXTABLE_PALETTE;
619 case GL_ALPHA:
620 for (i = 0; i < width; i++) {
621 r = g = b = 255;
622 a = tableUB[i];
623 data[i] = (a << 24) | (r << 16) | (g << 8) | b;
624 }
625 return GR_TEXTABLE_PALETTE_6666_EXT;
626 case GL_LUMINANCE_ALPHA:
627 for (i = 0; i < width; i++) {
628 r = g = b = tableUB[i * 2 + 0];
629 a = tableUB[i * 2 + 1];
630 data[i] = (a << 24) | (r << 16) | (g << 8) | b;
631 }
632 return GR_TEXTABLE_PALETTE_6666_EXT;
633 case GL_RGB:
634 for (i = 0; i < width; i++) {
635 r = tableUB[i * 3 + 0];
636 g = tableUB[i * 3 + 1];
637 b = tableUB[i * 3 + 2];
638 a = 255;
639 data[i] = (a << 24) | (r << 16) | (g << 8) | b;
640 }
641 return GR_TEXTABLE_PALETTE;
642 case GL_RGBA:
643 for (i = 0; i < width; i++) {
644 r = tableUB[i * 4 + 0];
645 g = tableUB[i * 4 + 1];
646 b = tableUB[i * 4 + 2];
647 a = tableUB[i * 4 + 3];
648 data[i] = (a << 24) | (r << 16) | (g << 8) | b;
649 }
650 return GR_TEXTABLE_PALETTE_6666_EXT;
651 }
652 abort();
653 }
654
655
656
657 static void
658 tdfxUpdateTexturePalette(GLcontext * ctx, struct gl_texture_object *tObj)
659 {
660 tdfxContextPtr fxMesa = TDFX_CONTEXT(ctx);
661
662 if (tObj) {
663 /* per-texture palette */
664 tdfxTexInfo *ti;
665
666 /* This might be a proxy texture. */
667 if (!tObj->Palette.Table)
668 return;
669
670 if (!tObj->DriverData)
671 tObj->DriverData = fxAllocTexObjData(fxMesa);
672 ti = TDFX_TEXTURE_DATA(tObj);
673 assert(ti);
674 ti->paltype = convertPalette(ti->palette.data, &tObj->Palette);
675 /*tdfxTexInvalidate(ctx, tObj);*/
676 }
677 else {
678 /* global texture palette */
679 fxMesa->TexPalette.Type = convertPalette(fxMesa->glbPalette.data, &ctx->Texture.Palette);
680 fxMesa->TexPalette.Data = &(fxMesa->glbPalette.data);
681 fxMesa->dirty |= TDFX_UPLOAD_TEXTURE_PALETTE;
682 }
683 fxMesa->new_state |= TDFX_NEW_TEXTURE; /* XXX too heavy-handed */
684 }
685
686
687 /**********************************************************************/
688 /**** NEW TEXTURE IMAGE FUNCTIONS ****/
689 /**********************************************************************/
690
691 #if 000
692 static FxBool TexusFatalError = FXFALSE;
693 static FxBool TexusError = FXFALSE;
694
695 #define TX_DITHER_NONE 0x00000000
696
697 static void
698 fxTexusError(const char *string, FxBool fatal)
699 {
700 _mesa_problem(NULL, string);
701 /*
702 * Just propagate the fatal value up.
703 */
704 TexusError = FXTRUE;
705 TexusFatalError = fatal;
706 }
707 #endif
708
709
710 static const struct gl_texture_format *
711 tdfxChooseTextureFormat( GLcontext *ctx, GLint internalFormat,
712 GLenum srcFormat, GLenum srcType )
713 {
714 tdfxContextPtr fxMesa = TDFX_CONTEXT(ctx);
715 const GLboolean allow32bpt = TDFX_IS_NAPALM(fxMesa);
716
717 switch (internalFormat) {
718 case GL_ALPHA:
719 case GL_ALPHA4:
720 case GL_ALPHA8:
721 case GL_ALPHA12:
722 case GL_ALPHA16:
723 case GL_COMPRESSED_ALPHA:
724 return &_mesa_texformat_a8;
725 case 1:
726 case GL_LUMINANCE:
727 case GL_LUMINANCE4:
728 case GL_LUMINANCE8:
729 case GL_LUMINANCE12:
730 case GL_LUMINANCE16:
731 case GL_COMPRESSED_LUMINANCE:
732 return &_mesa_texformat_l8;
733 case 2:
734 case GL_LUMINANCE_ALPHA:
735 case GL_LUMINANCE4_ALPHA4:
736 case GL_LUMINANCE6_ALPHA2:
737 case GL_LUMINANCE8_ALPHA8:
738 case GL_LUMINANCE12_ALPHA4:
739 case GL_LUMINANCE12_ALPHA12:
740 case GL_LUMINANCE16_ALPHA16:
741 case GL_COMPRESSED_LUMINANCE_ALPHA:
742 return &_mesa_texformat_al88;
743 case GL_INTENSITY:
744 case GL_INTENSITY4:
745 case GL_INTENSITY8:
746 case GL_INTENSITY12:
747 case GL_INTENSITY16:
748 case GL_COMPRESSED_INTENSITY:
749 return &_mesa_texformat_i8;
750 case GL_R3_G3_B2:
751 case GL_RGB4:
752 case GL_RGB5:
753 return &_mesa_texformat_rgb565;
754 case GL_COMPRESSED_RGB:
755 /* intentional fall-through */
756 case 3:
757 case GL_RGB:
758 if ( srcFormat == GL_RGB && srcType == GL_UNSIGNED_SHORT_5_6_5 ) {
759 return &_mesa_texformat_rgb565;
760 }
761 /* intentional fall through */
762 case GL_RGB8:
763 case GL_RGB10:
764 case GL_RGB12:
765 case GL_RGB16:
766 return (allow32bpt) ? &_mesa_texformat_argb8888
767 : &_mesa_texformat_rgb565;
768 case GL_RGBA2:
769 case GL_RGBA4:
770 return &_mesa_texformat_argb4444;
771 case GL_COMPRESSED_RGBA:
772 /* intentional fall-through */
773 case 4:
774 case GL_RGBA:
775 if ( srcFormat == GL_BGRA ) {
776 if ( srcType == GL_UNSIGNED_INT_8_8_8_8_REV ) {
777 return &_mesa_texformat_argb8888;
778 }
779 else if ( srcType == GL_UNSIGNED_SHORT_4_4_4_4_REV ) {
780 return &_mesa_texformat_argb4444;
781 }
782 else if ( srcType == GL_UNSIGNED_SHORT_1_5_5_5_REV ) {
783 return &_mesa_texformat_argb1555;
784 }
785 }
786 /* intentional fall through */
787 case GL_RGBA8:
788 case GL_RGB10_A2:
789 case GL_RGBA12:
790 case GL_RGBA16:
791 return allow32bpt ? &_mesa_texformat_argb8888
792 : &_mesa_texformat_argb4444;
793 case GL_RGB5_A1:
794 return &_mesa_texformat_argb1555;
795 case GL_COLOR_INDEX:
796 case GL_COLOR_INDEX1_EXT:
797 case GL_COLOR_INDEX2_EXT:
798 case GL_COLOR_INDEX4_EXT:
799 case GL_COLOR_INDEX8_EXT:
800 case GL_COLOR_INDEX12_EXT:
801 case GL_COLOR_INDEX16_EXT:
802 return &_mesa_texformat_ci8;
803 /* GL_EXT_texture_compression_s3tc */
804 /* GL_S3_s3tc */
805 case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
806 case GL_RGB_S3TC:
807 case GL_RGB4_S3TC:
808 return &_mesa_texformat_rgb_dxt1;
809 case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
810 return &_mesa_texformat_rgba_dxt1;
811 case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
812 case GL_RGBA_S3TC:
813 case GL_RGBA4_S3TC:
814 return &_mesa_texformat_rgba_dxt3;
815 case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
816 return &_mesa_texformat_rgba_dxt5;
817 /* GL_3DFX_texture_compression_FXT1 */
818 case GL_COMPRESSED_RGB_FXT1_3DFX:
819 return &_mesa_texformat_rgb_fxt1;
820 case GL_COMPRESSED_RGBA_FXT1_3DFX:
821 return &_mesa_texformat_rgba_fxt1;
822 default:
823 _mesa_problem(ctx, "unexpected format in tdfxChooseTextureFormat");
824 return NULL;
825 }
826 }
827
828
829 /*
830 * Return the Glide format for the given mesa texture format.
831 */
832 static GrTextureFormat_t
833 fxGlideFormat(GLint mesaFormat)
834 {
835 switch (mesaFormat) {
836 case MESA_FORMAT_I8:
837 return GR_TEXFMT_ALPHA_8;
838 case MESA_FORMAT_A8:
839 return GR_TEXFMT_ALPHA_8;
840 case MESA_FORMAT_L8:
841 return GR_TEXFMT_INTENSITY_8;
842 case MESA_FORMAT_CI8:
843 return GR_TEXFMT_P_8;
844 case MESA_FORMAT_AL88:
845 return GR_TEXFMT_ALPHA_INTENSITY_88;
846 case MESA_FORMAT_RGB565:
847 return GR_TEXFMT_RGB_565;
848 case MESA_FORMAT_ARGB4444:
849 return GR_TEXFMT_ARGB_4444;
850 case MESA_FORMAT_ARGB1555:
851 return GR_TEXFMT_ARGB_1555;
852 case MESA_FORMAT_ARGB8888:
853 return GR_TEXFMT_ARGB_8888;
854 case MESA_FORMAT_RGB_FXT1:
855 case MESA_FORMAT_RGBA_FXT1:
856 return GR_TEXFMT_ARGB_CMP_FXT1;
857 case MESA_FORMAT_RGB_DXT1:
858 case MESA_FORMAT_RGBA_DXT1:
859 return GR_TEXFMT_ARGB_CMP_DXT1;
860 case MESA_FORMAT_RGBA_DXT3:
861 return GR_TEXFMT_ARGB_CMP_DXT3;
862 case MESA_FORMAT_RGBA_DXT5:
863 return GR_TEXFMT_ARGB_CMP_DXT5;
864 default:
865 _mesa_problem(NULL, "Unexpected format in fxGlideFormat");
866 return 0;
867 }
868 }
869
870
871 /* Texel-fetch functions for software texturing and glGetTexImage().
872 * We should have been able to use some "standard" fetch functions (which
873 * may get defined in texutil.c) but we have to account for scaled texture
874 * images on tdfx hardware (the 8:1 aspect ratio limit).
875 * Hence, we need special functions here.
876 */
877 extern void
878 fxt1_decode_1 (const void *texture, int width,
879 int i, int j, unsigned char *rgba);
880
881 static void
882 fetch_intensity8(const struct gl_texture_image *texImage,
883 GLint i, GLint j, GLint k, GLchan * rgba)
884 {
885 const tdfxMipMapLevel *mml = TDFX_TEXIMAGE_DATA(texImage);
886 const GLubyte *texel;
887
888 i = i * mml->wScale;
889 j = j * mml->hScale;
890
891 texel = ((GLubyte *) texImage->Data) + j * mml->width + i;
892 rgba[RCOMP] = *texel;
893 rgba[GCOMP] = *texel;
894 rgba[BCOMP] = *texel;
895 rgba[ACOMP] = *texel;
896 }
897
898
899 static void
900 fetch_luminance8(const struct gl_texture_image *texImage,
901 GLint i, GLint j, GLint k, GLchan * rgba)
902 {
903 const tdfxMipMapLevel *mml = TDFX_TEXIMAGE_DATA(texImage);
904 const GLubyte *texel;
905
906 i = i * mml->wScale;
907 j = j * mml->hScale;
908
909 texel = ((GLubyte *) texImage->Data) + j * mml->width + i;
910 rgba[RCOMP] = *texel;
911 rgba[GCOMP] = *texel;
912 rgba[BCOMP] = *texel;
913 rgba[ACOMP] = 255;
914 }
915
916
917 static void
918 fetch_alpha8(const struct gl_texture_image *texImage,
919 GLint i, GLint j, GLint k, GLchan * rgba)
920 {
921 const tdfxMipMapLevel *mml = TDFX_TEXIMAGE_DATA(texImage);
922 const GLubyte *texel;
923
924 i = i * mml->wScale;
925 j = j * mml->hScale;
926
927 texel = ((GLubyte *) texImage->Data) + j * mml->width + i;
928 rgba[RCOMP] = 255;
929 rgba[GCOMP] = 255;
930 rgba[BCOMP] = 255;
931 rgba[ACOMP] = *texel;
932 }
933
934
935 static void
936 fetch_index8(const struct gl_texture_image *texImage,
937 GLint i, GLint j, GLint k, GLchan * indexOut)
938 {
939 const tdfxMipMapLevel *mml = TDFX_TEXIMAGE_DATA(texImage);
940 const GLubyte *texel;
941
942 i = i * mml->wScale;
943 j = j * mml->hScale;
944
945 texel = ((GLubyte *) texImage->Data) + j * mml->width + i;
946 *indexOut = *texel;
947 }
948
949
950 static void
951 fetch_luminance8_alpha8(const struct gl_texture_image *texImage,
952 GLint i, GLint j, GLint k, GLchan * rgba)
953 {
954 const tdfxMipMapLevel *mml = TDFX_TEXIMAGE_DATA(texImage);
955 const GLubyte *texel;
956
957 i = i * mml->wScale;
958 j = j * mml->hScale;
959
960 texel = ((GLubyte *) texImage->Data) + (j * mml->width + i) * 2;
961 rgba[RCOMP] = texel[0];
962 rgba[GCOMP] = texel[0];
963 rgba[BCOMP] = texel[0];
964 rgba[ACOMP] = texel[1];
965 }
966
967
968 static void
969 fetch_r5g6b5(const struct gl_texture_image *texImage,
970 GLint i, GLint j, GLint k, GLchan * rgba)
971 {
972 const tdfxMipMapLevel *mml = TDFX_TEXIMAGE_DATA(texImage);
973 const GLushort *texel;
974
975 i = i * mml->wScale;
976 j = j * mml->hScale;
977
978 texel = ((GLushort *) texImage->Data) + j * mml->width + i;
979 rgba[RCOMP] = (((*texel) >> 11) & 0x1f) * 255 / 31;
980 rgba[GCOMP] = (((*texel) >> 5) & 0x3f) * 255 / 63;
981 rgba[BCOMP] = (((*texel) >> 0) & 0x1f) * 255 / 31;
982 rgba[ACOMP] = 255;
983 }
984
985
986 static void
987 fetch_r4g4b4a4(const struct gl_texture_image *texImage,
988 GLint i, GLint j, GLint k, GLchan * rgba)
989 {
990 const tdfxMipMapLevel *mml = TDFX_TEXIMAGE_DATA(texImage);
991 const GLushort *texel;
992
993 i = i * mml->wScale;
994 j = j * mml->hScale;
995
996 texel = ((GLushort *) texImage->Data) + j * mml->width + i;
997 rgba[RCOMP] = (((*texel) >> 12) & 0xf) * 255 / 15;
998 rgba[GCOMP] = (((*texel) >> 8) & 0xf) * 255 / 15;
999 rgba[BCOMP] = (((*texel) >> 4) & 0xf) * 255 / 15;
1000 rgba[ACOMP] = (((*texel) >> 0) & 0xf) * 255 / 15;
1001 }
1002
1003
1004 static void
1005 fetch_r5g5b5a1(const struct gl_texture_image *texImage,
1006 GLint i, GLint j, GLint k, GLchan * rgba)
1007 {
1008 const tdfxMipMapLevel *mml = TDFX_TEXIMAGE_DATA(texImage);
1009 const GLushort *texel;
1010
1011 i = i * mml->wScale;
1012 j = j * mml->hScale;
1013
1014 texel = ((GLushort *) texImage->Data) + j * mml->width + i;
1015 rgba[RCOMP] = (((*texel) >> 11) & 0x1f) * 255 / 31;
1016 rgba[GCOMP] = (((*texel) >> 6) & 0x1f) * 255 / 31;
1017 rgba[BCOMP] = (((*texel) >> 1) & 0x1f) * 255 / 31;
1018 rgba[ACOMP] = (((*texel) >> 0) & 0x01) * 255;
1019 }
1020
1021
1022 static void
1023 fetch_a8r8g8b8(const struct gl_texture_image *texImage,
1024 GLint i, GLint j, GLint k, GLchan * rgba)
1025 {
1026 const tdfxMipMapLevel *mml = TDFX_TEXIMAGE_DATA(texImage);
1027 const GLuint *texel;
1028
1029 i = i * mml->wScale;
1030 j = j * mml->hScale;
1031
1032 texel = ((GLuint *) texImage->Data) + j * mml->width + i;
1033 rgba[RCOMP] = (((*texel) >> 16) & 0xff);
1034 rgba[GCOMP] = (((*texel) >> 8) & 0xff);
1035 rgba[BCOMP] = (((*texel) ) & 0xff);
1036 rgba[ACOMP] = (((*texel) >> 24) & 0xff);
1037 }
1038
1039
1040 static void
1041 fetch_rgb_fxt1(const struct gl_texture_image *texImage,
1042 GLint i, GLint j, GLint k, GLchan *rgba)
1043 {
1044 const tdfxMipMapLevel *mml = TDFX_TEXIMAGE_DATA(texImage);
1045
1046 i = i * mml->wScale;
1047 j = j * mml->hScale;
1048
1049 fxt1_decode_1(texImage->Data, mml->width, i, j, rgba);
1050 rgba[ACOMP] = 255;
1051 }
1052
1053
1054 static void
1055 fetch_rgba_fxt1(const struct gl_texture_image *texImage,
1056 GLint i, GLint j, GLint k, GLchan *rgba)
1057 {
1058 const tdfxMipMapLevel *mml = TDFX_TEXIMAGE_DATA(texImage);
1059
1060 i = i * mml->wScale;
1061 j = j * mml->hScale;
1062
1063 fxt1_decode_1(texImage->Data, mml->width, i, j, rgba);
1064 }
1065
1066
1067 static void
1068 fetch_rgb_dxt1(const struct gl_texture_image *texImage,
1069 GLint i, GLint j, GLint k, GLchan *rgba)
1070 {
1071 const tdfxMipMapLevel *mml = TDFX_TEXIMAGE_DATA(texImage);
1072
1073 i = i * mml->wScale;
1074 j = j * mml->hScale;
1075
1076 _mesa_texformat_rgb_dxt1.FetchTexel2D(texImage, i, j, k, rgba);
1077 }
1078
1079
1080 static void
1081 fetch_rgba_dxt1(const struct gl_texture_image *texImage,
1082 GLint i, GLint j, GLint k, GLchan *rgba)
1083 {
1084 const tdfxMipMapLevel *mml = TDFX_TEXIMAGE_DATA(texImage);
1085
1086 i = i * mml->wScale;
1087 j = j * mml->hScale;
1088
1089 _mesa_texformat_rgba_dxt1.FetchTexel2D(texImage, i, j, k, rgba);
1090 }
1091
1092
1093 static void
1094 fetch_rgba_dxt3(const struct gl_texture_image *texImage,
1095 GLint i, GLint j, GLint k, GLchan *rgba)
1096 {
1097 const tdfxMipMapLevel *mml = TDFX_TEXIMAGE_DATA(texImage);
1098
1099 i = i * mml->wScale;
1100 j = j * mml->hScale;
1101
1102 _mesa_texformat_rgba_dxt3.FetchTexel2D(texImage, i, j, k, rgba);
1103 }
1104
1105
1106 static void
1107 fetch_rgba_dxt5(const struct gl_texture_image *texImage,
1108 GLint i, GLint j, GLint k, GLchan *rgba)
1109 {
1110 const tdfxMipMapLevel *mml = TDFX_TEXIMAGE_DATA(texImage);
1111
1112 i = i * mml->wScale;
1113 j = j * mml->hScale;
1114
1115 _mesa_texformat_rgba_dxt5.FetchTexel2D(texImage, i, j, k, rgba);
1116 }
1117
1118
1119 static FetchTexelFuncC
1120 fxFetchFunction(GLint mesaFormat)
1121 {
1122 switch (mesaFormat) {
1123 case MESA_FORMAT_I8:
1124 return &fetch_intensity8;
1125 case MESA_FORMAT_A8:
1126 return &fetch_alpha8;
1127 case MESA_FORMAT_L8:
1128 return &fetch_luminance8;
1129 case MESA_FORMAT_CI8:
1130 return &fetch_index8;
1131 case MESA_FORMAT_AL88:
1132 return &fetch_luminance8_alpha8;
1133 case MESA_FORMAT_RGB565:
1134 return &fetch_r5g6b5;
1135 case MESA_FORMAT_ARGB4444:
1136 return &fetch_r4g4b4a4;
1137 case MESA_FORMAT_ARGB1555:
1138 return &fetch_r5g5b5a1;
1139 case MESA_FORMAT_ARGB8888:
1140 return &fetch_a8r8g8b8;
1141 case MESA_FORMAT_RGB_FXT1:
1142 return &fetch_rgb_fxt1;
1143 case MESA_FORMAT_RGBA_FXT1:
1144 return &fetch_rgba_fxt1;
1145 case MESA_FORMAT_RGB_DXT1:
1146 return &fetch_rgb_dxt1;
1147 case MESA_FORMAT_RGBA_DXT1:
1148 return &fetch_rgba_dxt1;
1149 case MESA_FORMAT_RGBA_DXT3:
1150 return &fetch_rgba_dxt3;
1151 case MESA_FORMAT_RGBA_DXT5:
1152 return &fetch_rgba_dxt5;
1153 default:
1154 _mesa_problem(NULL, "Unexpected format in fxFetchFunction");
1155 return NULL;
1156 }
1157 }
1158
1159
1160 static GLboolean
1161 adjust2DRatio (GLcontext *ctx,
1162 GLint xoffset, GLint yoffset,
1163 GLint width, GLint height,
1164 GLenum format, GLenum type, const GLvoid *pixels,
1165 const struct gl_pixelstore_attrib *packing,
1166 tdfxMipMapLevel *mml,
1167 struct gl_texture_image *texImage,
1168 GLint texelBytes,
1169 GLint dstRowStride)
1170 {
1171 const GLint newWidth = width * mml->wScale;
1172 const GLint newHeight = height * mml->hScale;
1173 GLvoid *tempImage;
1174
1175 if (!texImage->IsCompressed) {
1176 GLubyte *destAddr;
1177 tempImage = MALLOC(width * height * texelBytes);
1178 if (!tempImage) {
1179 return GL_FALSE;
1180 }
1181
1182 texImage->TexFormat->StoreImage(ctx, 2, texImage->Format,
1183 texImage->TexFormat, tempImage,
1184 0, 0, 0, /* dstX/Y/Zoffset */
1185 width * texelBytes, /* dstRowStride */
1186 0, /* dstImageStride */
1187 width, height, 1,
1188 format, type, pixels, packing);
1189
1190 /* now rescale */
1191 /* compute address of dest subimage within the overal tex image */
1192 destAddr = (GLubyte *) texImage->Data
1193 + (yoffset * mml->hScale * mml->width
1194 + xoffset * mml->wScale) * texelBytes;
1195
1196 _mesa_rescale_teximage2d(texelBytes,
1197 width,
1198 dstRowStride, /* dst stride */
1199 width, height,
1200 newWidth, newHeight,
1201 tempImage, destAddr);
1202 } else {
1203 const GLint rawBytes = 4;
1204 GLvoid *rawImage = MALLOC(width * height * rawBytes);
1205 if (!rawImage) {
1206 return GL_FALSE;
1207 }
1208 tempImage = MALLOC(newWidth * newHeight * rawBytes);
1209 if (!tempImage) {
1210 return GL_FALSE;
1211 }
1212 /* unpack image, apply transfer ops and store in rawImage */
1213 _mesa_texstore_rgba8888(ctx, 2, GL_RGBA,
1214 &_mesa_texformat_rgba8888_rev, rawImage,
1215 0, 0, 0, /* dstX/Y/Zoffset */
1216 width * rawBytes, /* dstRowStride */
1217 0, /* dstImageStride */
1218 width, height, 1,
1219 format, type, pixels, packing);
1220 _mesa_rescale_teximage2d(rawBytes,
1221 width,
1222 newWidth * rawBytes, /* dst stride */
1223 width, height, /* src */
1224 newWidth, newHeight, /* dst */
1225 rawImage /*src*/, tempImage /*dst*/ );
1226 texImage->TexFormat->StoreImage(ctx, 2, texImage->Format,
1227 texImage->TexFormat, texImage->Data,
1228 xoffset * mml->wScale, yoffset * mml->hScale, 0, /* dstX/Y/Zoffset */
1229 dstRowStride,
1230 0, /* dstImageStride */
1231 newWidth, newHeight, 1,
1232 GL_RGBA, CHAN_TYPE, tempImage, &ctx->DefaultPacking);
1233 FREE(rawImage);
1234 }
1235
1236 FREE(tempImage);
1237
1238 return GL_TRUE;
1239 }
1240
1241
1242 static void
1243 tdfxTexImage2D(GLcontext *ctx, GLenum target, GLint level,
1244 GLint internalFormat, GLint width, GLint height, GLint border,
1245 GLenum format, GLenum type, const GLvoid *pixels,
1246 const struct gl_pixelstore_attrib *packing,
1247 struct gl_texture_object *texObj,
1248 struct gl_texture_image *texImage)
1249 {
1250 tdfxContextPtr fxMesa = TDFX_CONTEXT(ctx);
1251 tdfxTexInfo *ti;
1252 tdfxMipMapLevel *mml;
1253 GLint texelBytes, dstRowStride;
1254
1255 /*
1256 printf("TexImage id=%d int 0x%x format 0x%x type 0x%x %dx%d\n",
1257 texObj->Name, texImage->IntFormat, format, type,
1258 texImage->Width, texImage->Height);
1259 */
1260
1261 ti = TDFX_TEXTURE_DATA(texObj);
1262 if (!ti) {
1263 texObj->DriverData = fxAllocTexObjData(fxMesa);
1264 if (!texObj->DriverData) {
1265 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
1266 return;
1267 }
1268 ti = TDFX_TEXTURE_DATA(texObj);
1269 }
1270 assert(ti);
1271
1272 mml = TDFX_TEXIMAGE_DATA(texImage);
1273 if (!mml) {
1274 texImage->DriverData = CALLOC(sizeof(tdfxMipMapLevel));
1275 if (!texImage->DriverData) {
1276 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
1277 return;
1278 }
1279 mml = TDFX_TEXIMAGE_DATA(texImage);
1280 }
1281
1282 /* Determine width and height scale factors for texture.
1283 * Remember, Glide is limited to 8:1 aspect ratios.
1284 */
1285 tdfxTexGetInfo(ctx,
1286 texImage->Width, texImage->Height,
1287 NULL, /* lod level */
1288 NULL, /* aspect ratio */
1289 NULL, NULL, /* sscale, tscale */
1290 &mml->wScale, &mml->hScale);
1291
1292 /* rescaled size: */
1293 mml->width = width * mml->wScale;
1294 mml->height = height * mml->hScale;
1295
1296 #if FX_COMPRESS_S3TC_AS_FXT1_HACK
1297 /* [koolsmoky] substitute FXT1 for DXTn and Legacy S3TC */
1298 /* [dBorca] we should update texture's attribute, then,
1299 * because if the application asks us to decompress, we
1300 * have to know the REAL format! Also, DXT3/5 might not
1301 * be correct, since it would mess with "compressedSize".
1302 * Ditto for GL_RGBA[4]_S3TC, which is always mapped to DXT3.
1303 */
1304 if (texImage->IsCompressed) {
1305 switch (internalFormat) {
1306 case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
1307 case GL_RGB_S3TC:
1308 case GL_RGB4_S3TC:
1309 internalFormat = GL_COMPRESSED_RGB_FXT1_3DFX;
1310 break;
1311 case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
1312 case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
1313 case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
1314 case GL_RGBA_S3TC:
1315 case GL_RGBA4_S3TC:
1316 internalFormat = GL_COMPRESSED_RGBA_FXT1_3DFX;
1317 }
1318 texImage->IntFormat = internalFormat;
1319 }
1320 #endif
1321 #if FX_TC_NAPALM
1322 if (fxMesa->type >= GR_SSTTYPE_Voodoo4) {
1323 GLenum texNapalm = 0;
1324 if (internalFormat == GL_COMPRESSED_RGB) {
1325 texNapalm = GL_COMPRESSED_RGB_FXT1_3DFX;
1326 } else if (internalFormat == GL_COMPRESSED_RGBA) {
1327 texNapalm = GL_COMPRESSED_RGBA_FXT1_3DFX;
1328 }
1329 if (texNapalm) {
1330 texImage->IntFormat = internalFormat = texNapalm;
1331 texImage->IsCompressed = GL_TRUE;
1332 }
1333 }
1334 #endif
1335
1336 /* choose the texture format */
1337 assert(ctx->Driver.ChooseTextureFormat);
1338 texImage->TexFormat = (*ctx->Driver.ChooseTextureFormat)(ctx,
1339 internalFormat, format, type);
1340 assert(texImage->TexFormat);
1341 mml->glideFormat = fxGlideFormat(texImage->TexFormat->MesaFormat);
1342 ti->info.format = mml->glideFormat;
1343 texImage->FetchTexelc = fxFetchFunction(texImage->TexFormat->MesaFormat);
1344 texelBytes = texImage->TexFormat->TexelBytes;
1345
1346 if (texImage->IsCompressed) {
1347 texImage->CompressedSize = _mesa_compressed_texture_size(ctx,
1348 mml->width,
1349 mml->height,
1350 1,
1351 internalFormat);
1352 dstRowStride = _mesa_compressed_row_stride(internalFormat, mml->width);
1353 texImage->Data = MESA_PBUFFER_ALLOC(texImage->CompressedSize);
1354 } else {
1355 dstRowStride = mml->width * texelBytes;
1356 texImage->Data = MESA_PBUFFER_ALLOC(mml->width * mml->height * texelBytes);
1357 }
1358 if (!texImage->Data) {
1359 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
1360 return;
1361 }
1362
1363 if (pixels != NULL) {
1364 if (mml->wScale != 1 || mml->hScale != 1) {
1365 /* rescale image to overcome 1:8 aspect limitation */
1366 if (!adjust2DRatio(ctx,
1367 0, 0,
1368 width, height,
1369 format, type, pixels,
1370 packing,
1371 mml,
1372 texImage,
1373 texelBytes,
1374 dstRowStride)
1375 ) {
1376 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage2D");
1377 return;
1378 }
1379 }
1380 else {
1381 /* no rescaling needed */
1382 /* unpack image, apply transfer ops and store in texImage->Data */
1383 texImage->TexFormat->StoreImage(ctx, 2, texImage->Format,
1384 texImage->TexFormat, texImage->Data,
1385 0, 0, 0, /* dstX/Y/Zoffset */
1386 dstRowStride,
1387 0, /* dstImageStride */
1388 width, height, 1,
1389 format, type, pixels, packing);
1390 }
1391
1392 /* GL_SGIS_generate_mipmap */
1393 if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
1394 GLint mipWidth, mipHeight;
1395 tdfxMipMapLevel *mip;
1396 struct gl_texture_image *mipImage;
1397 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1398 const GLint maxLevels = _mesa_max_texture_levels(ctx, texObj->Target);
1399
1400 assert(!texImage->IsCompressed);
1401
1402 while (level < texObj->MaxLevel && level < maxLevels - 1) {
1403 mipWidth = width / 2;
1404 if (!mipWidth) {
1405 mipWidth = 1;
1406 }
1407 mipHeight = height / 2;
1408 if (!mipHeight) {
1409 mipHeight = 1;
1410 }
1411 if ((mipWidth == width) && (mipHeight == height)) {
1412 break;
1413 }
1414 _mesa_TexImage2D(target, ++level, internalFormat,
1415 mipWidth, mipHeight, border,
1416 format, type,
1417 NULL);
1418 mipImage = _mesa_select_tex_image(ctx, texUnit, target, level);
1419 mip = TDFX_TEXIMAGE_DATA(mipImage);
1420 _mesa_halve2x2_teximage2d(ctx,
1421 texImage,
1422 texelBytes,
1423 mml->width, mml->height,
1424 texImage->Data, mipImage->Data);
1425 texImage = mipImage;
1426 mml = mip;
1427 width = mipWidth;
1428 height = mipHeight;
1429 }
1430 }
1431 }
1432
1433 RevalidateTexture(ctx, texObj);
1434
1435 ti->reloadImages = GL_TRUE;
1436 fxMesa->new_state |= TDFX_NEW_TEXTURE;
1437 }
1438
1439
1440 static void
1441 tdfxTexSubImage2D(GLcontext *ctx, GLenum target, GLint level,
1442 GLint xoffset, GLint yoffset,
1443 GLsizei width, GLsizei height,
1444 GLenum format, GLenum type,
1445 const GLvoid *pixels,
1446 const struct gl_pixelstore_attrib *packing,
1447 struct gl_texture_object *texObj,
1448 struct gl_texture_image *texImage )
1449 {
1450 tdfxContextPtr fxMesa = TDFX_CONTEXT(ctx);
1451 tdfxTexInfo *ti;
1452 tdfxMipMapLevel *mml;
1453 GLint texelBytes, dstRowStride;
1454
1455 if (!texObj->DriverData) {
1456 _mesa_problem(ctx, "problem in fxDDTexSubImage2D");
1457 return;
1458 }
1459
1460 ti = TDFX_TEXTURE_DATA(texObj);
1461 assert(ti);
1462 mml = TDFX_TEXIMAGE_DATA(texImage);
1463 assert(mml);
1464
1465 assert(texImage->Data); /* must have an existing texture image! */
1466 assert(texImage->Format);
1467
1468 texelBytes = texImage->TexFormat->TexelBytes;
1469 if (texImage->IsCompressed) {
1470 dstRowStride = _mesa_compressed_row_stride(texImage->IntFormat, mml->width);
1471 } else {
1472 dstRowStride = mml->width * texelBytes;
1473 }
1474
1475 if (mml->wScale != 1 || mml->hScale != 1) {
1476 /* need to rescale subimage to match mipmap level's rescale factors */
1477 if (!adjust2DRatio(ctx,
1478 xoffset, yoffset,
1479 width, height,
1480 format, type, pixels,
1481 packing,
1482 mml,
1483 texImage,
1484 texelBytes,
1485 dstRowStride)
1486 ) {
1487 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage2D");
1488 return;
1489 }
1490 }
1491 else {
1492 /* no rescaling needed */
1493 texImage->TexFormat->StoreImage(ctx, 2, texImage->Format,
1494 texImage->TexFormat, texImage->Data,
1495 xoffset, yoffset, 0,
1496 dstRowStride,
1497 0, /* dstImageStride */
1498 width, height, 1,
1499 format, type, pixels, packing);
1500 }
1501
1502 /* GL_SGIS_generate_mipmap */
1503 if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
1504 GLint mipWidth, mipHeight;
1505 tdfxMipMapLevel *mip;
1506 struct gl_texture_image *mipImage;
1507 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1508 const GLint maxLevels = _mesa_max_texture_levels(ctx, texObj->Target);
1509
1510 assert(!texImage->IsCompressed);
1511
1512 width = texImage->Width;
1513 height = texImage->Height;
1514 while (level < texObj->MaxLevel && level < maxLevels - 1) {
1515 mipWidth = width / 2;
1516 if (!mipWidth) {
1517 mipWidth = 1;
1518 }
1519 mipHeight = height / 2;
1520 if (!mipHeight) {
1521 mipHeight = 1;
1522 }
1523 if ((mipWidth == width) && (mipHeight == height)) {
1524 break;
1525 }
1526 ++level;
1527 mipImage = _mesa_select_tex_image(ctx, texUnit, target, level);
1528 mip = TDFX_TEXIMAGE_DATA(mipImage);
1529 _mesa_halve2x2_teximage2d(ctx,
1530 texImage,
1531 texelBytes,
1532 mml->width, mml->height,
1533 texImage->Data, mipImage->Data);
1534 texImage = mipImage;
1535 mml = mip;
1536 width = mipWidth;
1537 height = mipHeight;
1538 }
1539 }
1540
1541 ti->reloadImages = GL_TRUE; /* signal the image needs to be reloaded */
1542 fxMesa->new_state |= TDFX_NEW_TEXTURE; /* XXX this might be a bit much */
1543 }
1544
1545
1546 static void
1547 tdfxTexImage1D(GLcontext *ctx, GLenum target, GLint level,
1548 GLint internalFormat, GLint width, GLint border,
1549 GLenum format, GLenum type, const GLvoid *pixels,
1550 const struct gl_pixelstore_attrib *packing,
1551 struct gl_texture_object *texObj,
1552 struct gl_texture_image *texImage)
1553 {
1554 tdfxTexImage2D(ctx, target, level,
1555 internalFormat, width, 1, border,
1556 format, type, pixels,
1557 packing,
1558 texObj,
1559 texImage);
1560 }
1561
1562 static void
1563 tdfxTexSubImage1D(GLcontext *ctx, GLenum target, GLint level,
1564 GLint xoffset,
1565 GLsizei width,
1566 GLenum format, GLenum type,
1567 const GLvoid *pixels,
1568 const struct gl_pixelstore_attrib *packing,
1569 struct gl_texture_object *texObj,
1570 struct gl_texture_image *texImage )
1571 {
1572 tdfxTexSubImage2D(ctx, target, level,
1573 xoffset, 0,
1574 width, 1,
1575 format, type,
1576 pixels,
1577 packing,
1578 texObj,
1579 texImage);
1580 }
1581
1582 /**********************************************************************/
1583 /**** COMPRESSED TEXTURE IMAGE FUNCTIONS ****/
1584 /**********************************************************************/
1585
1586 static void
1587 tdfxCompressedTexImage2D (GLcontext *ctx, GLenum target,
1588 GLint level, GLint internalFormat,
1589 GLsizei width, GLsizei height, GLint border,
1590 GLsizei imageSize, const GLvoid *data,
1591 struct gl_texture_object *texObj,
1592 struct gl_texture_image *texImage)
1593 {
1594 tdfxContextPtr fxMesa = TDFX_CONTEXT(ctx);
1595 tdfxTexInfo *ti;
1596 tdfxMipMapLevel *mml;
1597
1598 if (TDFX_DEBUG & DEBUG_VERBOSE_DRI) {
1599 fprintf(stderr, "tdfxCompressedTexImage2D: id=%d int 0x%x %dx%d\n",
1600 texObj->Name, internalFormat,
1601 width, height);
1602 }
1603
1604 if ((target != GL_TEXTURE_1D && target != GL_TEXTURE_2D) || texImage->Border > 0) {
1605 _mesa_problem(NULL, "tdfx: unsupported texture in tdfxCompressedTexImg()\n");
1606 return;
1607 }
1608
1609 assert(texImage->IsCompressed);
1610
1611 ti = TDFX_TEXTURE_DATA(texObj);
1612 if (!ti) {
1613 texObj->DriverData = fxAllocTexObjData(fxMesa);
1614 if (!texObj->DriverData) {
1615 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2D");
1616 return;
1617 }
1618 ti = TDFX_TEXTURE_DATA(texObj);
1619 }
1620 assert(ti);
1621
1622 mml = TDFX_TEXIMAGE_DATA(texImage);
1623 if (!mml) {
1624 texImage->DriverData = CALLOC(sizeof(tdfxMipMapLevel));
1625 if (!texImage->DriverData) {
1626 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2D");
1627 return;
1628 }
1629 mml = TDFX_TEXIMAGE_DATA(texImage);
1630 }
1631
1632 tdfxTexGetInfo(ctx, width, height, NULL, NULL, NULL, NULL,
1633 &mml->wScale, &mml->hScale);
1634
1635 mml->width = width * mml->wScale;
1636 mml->height = height * mml->hScale;
1637
1638
1639 /* choose the texture format */
1640 assert(ctx->Driver.ChooseTextureFormat);
1641 texImage->TexFormat = (*ctx->Driver.ChooseTextureFormat)(ctx,
1642 internalFormat, -1/*format*/, -1/*type*/);
1643 assert(texImage->TexFormat);
1644
1645 /* Determine the appropriate Glide texel format,
1646 * given the user's internal texture format hint.
1647 */
1648 mml->glideFormat = fxGlideFormat(texImage->TexFormat->MesaFormat);
1649 ti->info.format = mml->glideFormat;
1650 texImage->FetchTexelc = fxFetchFunction(texImage->TexFormat->MesaFormat);
1651
1652 /* allocate new storage for texture image, if needed */
1653 if (!texImage->Data) {
1654 texImage->CompressedSize = _mesa_compressed_texture_size(ctx,
1655 mml->width,
1656 mml->height,
1657 1,
1658 internalFormat);
1659 texImage->Data = MESA_PBUFFER_ALLOC(texImage->CompressedSize);
1660 if (!texImage->Data) {
1661 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage2D");
1662 return;
1663 }
1664 }
1665
1666 /* save the texture data */
1667 if (mml->wScale != 1 || mml->hScale != 1) {
1668 /* [dBorca] Hack alert:
1669 * now we're screwed. We can't decompress,
1670 * unless we do it in HW (via textureBuffer).
1671 * We still have some chances:
1672 * 1) we got FXT1 textures - we CAN decompress, rescale for
1673 * aspectratio, then compress back.
1674 * 2) there is a chance that MIN("s", "t") won't be overflowed.
1675 * Thus, we don't care about textureclamp and we could lower
1676 * MIN("uscale", "vscale") below 32. We still have to have
1677 * our data aligned inside a 8:1 rectangle.
1678 * 3) just in case if MIN("s", "t") gets overflowed with GL_REPEAT,
1679 * we replicate the data over the padded area.
1680 * For now, we take 2) + 3) but texelfetchers will be wrong!
1681 */
1682 GLuint srcRowStride = _mesa_compressed_row_stride(internalFormat, width);
1683
1684 GLuint destRowStride = _mesa_compressed_row_stride(internalFormat,
1685 mml->width);
1686
1687 _mesa_upscale_teximage2d(srcRowStride, (height+3) / 4,
1688 destRowStride, (mml->height+3) / 4,
1689 1, data, srcRowStride,
1690 texImage->Data);
1691 ti->padded = GL_TRUE;
1692 } else {
1693 MEMCPY(texImage->Data, data, texImage->CompressedSize);
1694 }
1695
1696 /* GL_SGIS_generate_mipmap */
1697 if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
1698 assert(!texImage->IsCompressed);
1699 }
1700
1701 RevalidateTexture(ctx, texObj);
1702
1703 ti->reloadImages = GL_TRUE;
1704 fxMesa->new_state |= TDFX_NEW_TEXTURE;
1705 }
1706
1707
1708 static void
1709 tdfxCompressedTexSubImage2D( GLcontext *ctx, GLenum target,
1710 GLint level, GLint xoffset,
1711 GLint yoffset, GLsizei width,
1712 GLint height, GLenum format,
1713 GLsizei imageSize, const GLvoid *data,
1714 struct gl_texture_object *texObj,
1715 struct gl_texture_image *texImage )
1716 {
1717 tdfxContextPtr fxMesa = TDFX_CONTEXT(ctx);
1718 tdfxTexInfo *ti;
1719 tdfxMipMapLevel *mml;
1720 GLint destRowStride, srcRowStride;
1721 GLint i, rows;
1722 GLubyte *dest;
1723
1724 if (TDFX_DEBUG & DEBUG_VERBOSE_DRI) {
1725 fprintf(stderr, "tdfxCompressedTexSubImage2D: id=%d\n", texObj->Name);
1726 }
1727
1728 ti = TDFX_TEXTURE_DATA(texObj);
1729 assert(ti);
1730 mml = TDFX_TEXIMAGE_DATA(texImage);
1731 assert(mml);
1732
1733 srcRowStride = _mesa_compressed_row_stride(texImage->IntFormat, width);
1734
1735 destRowStride = _mesa_compressed_row_stride(texImage->IntFormat,
1736 mml->width);
1737 dest = _mesa_compressed_image_address(xoffset, yoffset, 0,
1738 texImage->IntFormat,
1739 mml->width,
1740 (GLubyte*) texImage->Data);
1741
1742 rows = height / 4; /* [dBorca] hardcoded 4, but works for FXT1/DXTC */
1743
1744 for (i = 0; i < rows; i++) {
1745 MEMCPY(dest, data, srcRowStride);
1746 dest += destRowStride;
1747 data = (GLvoid *)((GLuint)data + (GLuint)srcRowStride);
1748 }
1749
1750 /* [dBorca] Hack alert:
1751 * see fxDDCompressedTexImage2D for caveats
1752 */
1753 if (mml->wScale != 1 || mml->hScale != 1) {
1754 srcRowStride = _mesa_compressed_row_stride(texImage->IntFormat, texImage->Width);
1755
1756 destRowStride = _mesa_compressed_row_stride(texImage->IntFormat,
1757 mml->width);
1758 _mesa_upscale_teximage2d(srcRowStride, texImage->Height / 4,
1759 destRowStride, mml->height / 4,
1760 1, texImage->Data, destRowStride,
1761 texImage->Data);
1762 }
1763
1764 /* GL_SGIS_generate_mipmap */
1765 if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
1766 assert(!texImage->IsCompressed);
1767 }
1768
1769 RevalidateTexture(ctx, texObj);
1770
1771 ti->reloadImages = GL_TRUE;
1772 fxMesa->new_state |= TDFX_NEW_TEXTURE;
1773 }
1774
1775
1776 #if 0
1777 static void
1778 PrintTexture(int w, int h, int c, const GLubyte * data)
1779 {
1780 int i, j;
1781 for (i = 0; i < h; i++) {
1782 for (j = 0; j < w; j++) {
1783 if (c == 2)
1784 printf("%02x %02x ", data[0], data[1]);
1785 else if (c == 3)
1786 printf("%02x %02x %02x ", data[0], data[1], data[2]);
1787 data += c;
1788 }
1789 printf("\n");
1790 }
1791 }
1792 #endif
1793
1794
1795 GLboolean
1796 tdfxTestProxyTexImage(GLcontext *ctx, GLenum target,
1797 GLint level, GLint internalFormat,
1798 GLenum format, GLenum type,
1799 GLint width, GLint height,
1800 GLint depth, GLint border)
1801 {
1802 tdfxContextPtr fxMesa = TDFX_CONTEXT(ctx);
1803 struct gl_shared_state *mesaShared = fxMesa->glCtx->Shared;
1804 struct tdfxSharedState *shared = (struct tdfxSharedState *) mesaShared->DriverData;
1805
1806 switch (target) {
1807 case GL_PROXY_TEXTURE_1D:
1808 /*JJJ wrong*/
1809 case GL_PROXY_TEXTURE_2D:
1810 {
1811 struct gl_texture_object *tObj;
1812 tdfxTexInfo *ti;
1813 int memNeeded;
1814
1815 tObj = ctx->Texture.Proxy2D;
1816 if (!tObj->DriverData)
1817 tObj->DriverData = fxAllocTexObjData(fxMesa);
1818 ti = TDFX_TEXTURE_DATA(tObj);
1819 assert(ti);
1820
1821 /* assign the parameters to test against */
1822 tObj->Image[0][level]->Width = width;
1823 tObj->Image[0][level]->Height = height;
1824 tObj->Image[0][level]->Border = border;
1825 #if 0
1826 tObj->Image[0][level]->IntFormat = internalFormat;
1827 #endif
1828 if (level == 0) {
1829 /* don't use mipmap levels > 0 */
1830 tObj->MinFilter = tObj->MagFilter = GL_NEAREST;
1831 }
1832 else {
1833 /* test with all mipmap levels */
1834 tObj->MinFilter = GL_LINEAR_MIPMAP_LINEAR;
1835 tObj->MagFilter = GL_NEAREST;
1836 }
1837 RevalidateTexture(ctx, tObj);
1838
1839 /*
1840 printf("small lodlog2 0x%x\n", ti->info.smallLodLog2);
1841 printf("large lodlog2 0x%x\n", ti->info.largeLodLog2);
1842 printf("aspect ratio 0x%x\n", ti->info.aspectRatioLog2);
1843 printf("glide format 0x%x\n", ti->info.format);
1844 printf("data %p\n", ti->info.data);
1845 printf("lodblend %d\n", (int) ti->LODblend);
1846 */
1847
1848 /* determine where texture will reside */
1849 if (ti->LODblend && !shared->umaTexMemory) {
1850 /* XXX GR_MIPMAPLEVELMASK_BOTH might not be right, but works */
1851 memNeeded = fxMesa->Glide.grTexTextureMemRequired(
1852 GR_MIPMAPLEVELMASK_BOTH, &(ti->info));
1853 }
1854 else {
1855 /* XXX GR_MIPMAPLEVELMASK_BOTH might not be right, but works */
1856 memNeeded = fxMesa->Glide.grTexTextureMemRequired(
1857 GR_MIPMAPLEVELMASK_BOTH, &(ti->info));
1858 }
1859 /*
1860 printf("Proxy test %d > %d\n", memNeeded, shared->totalTexMem[0]);
1861 */
1862 if (memNeeded > shared->totalTexMem[0])
1863 return GL_FALSE;
1864 else
1865 return GL_TRUE;
1866 }
1867 case GL_PROXY_TEXTURE_3D:
1868 return GL_TRUE; /* software rendering */
1869 default:
1870 return GL_TRUE; /* never happens, silence compiler */
1871 }
1872 }
1873
1874
1875 /**
1876 * Allocate a new texture object.
1877 * Called via ctx->Driver.NewTextureObject.
1878 * Note: this function will be called during context creation to
1879 * allocate the default texture objects.
1880 * Note: we could use containment here to 'derive' the driver-specific
1881 * texture object from the core mesa gl_texture_object. Not done at this time.
1882 */
1883 static struct gl_texture_object *
1884 tdfxNewTextureObject( GLcontext *ctx, GLuint name, GLenum target )
1885 {
1886 struct gl_texture_object *obj;
1887 obj = _mesa_new_texture_object(ctx, name, target);
1888 return obj;
1889 }
1890
1891
1892 void tdfxInitTextureFuncs( struct dd_function_table *functions )
1893 {
1894 functions->BindTexture = tdfxBindTexture;
1895 functions->NewTextureObject = tdfxNewTextureObject;
1896 functions->DeleteTexture = tdfxDeleteTexture;
1897 functions->TexEnv = tdfxTexEnv;
1898 functions->TexParameter = tdfxTexParameter;
1899 functions->ChooseTextureFormat = tdfxChooseTextureFormat;
1900 functions->TexImage1D = tdfxTexImage1D;
1901 functions->TexSubImage1D = tdfxTexSubImage1D;
1902 functions->TexImage2D = tdfxTexImage2D;
1903 functions->TexSubImage2D = tdfxTexSubImage2D;
1904 functions->IsTextureResident = tdfxIsTextureResident;
1905 functions->CompressedTexImage2D = tdfxCompressedTexImage2D;
1906 functions->CompressedTexSubImage2D = tdfxCompressedTexSubImage2D;
1907 functions->UpdateTexturePalette = tdfxUpdateTexturePalette;
1908 }