projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
mesa: add support for ATI_envmap_bumpmap
[mesa.git] / src / mesa / swrast / s_texcombine.c
1 /*
2 * Mesa 3-D graphics library
3 * Version: 7.5
4 *
5 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved.
6 * Copyright (C) 2009 VMware, Inc. All Rights Reserved.
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included
16 * in all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
22 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 */
25
26
27 #include "main/glheader.h"
28 #include "main/context.h"
29 #include "main/colormac.h"
30 #include "main/image.h"
31 #include "main/imports.h"
32 #include "main/macros.h"
33 #include "main/pixel.h"
34 #include "shader/prog_instruction.h"
35
36 #include "s_context.h"
37 #include "s_texcombine.h"
38
39
40 #define PROD(A,B) ( (GLuint)(A) * ((GLuint)(B)+1) )
41 #define S_PROD(A,B) ( (GLint)(A) * ((GLint)(B)+1) )
42 #if CHAN_BITS == 32
43 typedef GLfloat ChanTemp;
44 #else
45 typedef GLuint ChanTemp;
46 #endif
47
48
49 /**
50 * Do texture application for GL_ARB/EXT_texture_env_combine.
51 * This function also supports GL_{EXT,ARB}_texture_env_dot3 and
52 * GL_ATI_texture_env_combine3. Since "classic" texture environments are
53 * implemented using GL_ARB_texture_env_combine-like state, this same function
54 * is used for classic texture environment application as well.
55 *
56 * \param ctx rendering context
57 * \param textureUnit the texture unit to apply
58 * \param n number of fragments to process (span width)
59 * \param primary_rgba incoming fragment color array
60 * \param texelBuffer pointer to texel colors for all texture units
61 *
62 * \param rgba incoming colors, which get modified here
63 */
64 static void
65 texture_combine( const GLcontext *ctx, GLuint unit, GLuint n,
66 CONST GLchan (*primary_rgba)[4],
67 CONST GLchan *texelBuffer,
68 GLchan (*rgba)[4] )
69 {
70 const struct gl_texture_unit *textureUnit = &(ctx->Texture.Unit[unit]);
71 const GLchan (*argRGB [4])[4];
72 const GLchan (*argA [4])[4];
73 const GLint RGBshift = textureUnit->_CurrentCombine->ScaleShiftRGB;
74 const GLuint Ashift = textureUnit->_CurrentCombine->ScaleShiftA;
75 #if CHAN_TYPE == GL_FLOAT
76 const GLchan RGBmult = (GLfloat) (1 << RGBshift);
77 const GLchan Amult = (GLfloat) (1 << Ashift);
78 #else
79 const GLint half = (CHAN_MAX + 1) / 2;
80 #endif
81 static const GLchan one[4] = { CHAN_MAX, CHAN_MAX, CHAN_MAX, CHAN_MAX };
82 static const GLchan zero[4] = { 0, 0, 0, 0 };
83 const GLuint numColorArgs = textureUnit->_CurrentCombine->_NumArgsRGB;
84 const GLuint numAlphaArgs = textureUnit->_CurrentCombine->_NumArgsA;
85 GLchan ccolor[4][MAX_WIDTH][4];
86 GLuint i, j;
87
88 ASSERT(ctx->Extensions.EXT_texture_env_combine ||
89 ctx->Extensions.ARB_texture_env_combine);
90 ASSERT(CONST_SWRAST_CONTEXT(ctx)->_AnyTextureCombine);
91
92 /*
93 printf("modeRGB 0x%x modeA 0x%x srcRGB1 0x%x srcA1 0x%x srcRGB2 0x%x srcA2 0x%x\n",
94 textureUnit->_CurrentCombine->ModeRGB,
95 textureUnit->_CurrentCombine->ModeA,
96 textureUnit->_CurrentCombine->SourceRGB[0],
97 textureUnit->_CurrentCombine->SourceA[0],
98 textureUnit->_CurrentCombine->SourceRGB[1],
99 textureUnit->_CurrentCombine->SourceA[1]);
100 */
101
102 /*
103 * Do operand setup for up to 4 operands. Loop over the terms.
104 */
105 for (j = 0; j < numColorArgs; j++) {
106 const GLenum srcRGB = textureUnit->_CurrentCombine->SourceRGB[j];
107
108 switch (srcRGB) {
109 case GL_TEXTURE:
110 argRGB[j] = (const GLchan (*)[4])
111 (texelBuffer + unit * (n * 4 * sizeof(GLchan)));
112 break;
113 case GL_PRIMARY_COLOR:
114 argRGB[j] = primary_rgba;
115 break;
116 case GL_PREVIOUS:
117 argRGB[j] = (const GLchan (*)[4]) rgba;
118 break;
119 case GL_CONSTANT:
120 {
121 GLchan (*c)[4] = ccolor[j];
122 GLchan red, green, blue, alpha;
123 UNCLAMPED_FLOAT_TO_CHAN(red, textureUnit->EnvColor[0]);
124 UNCLAMPED_FLOAT_TO_CHAN(green, textureUnit->EnvColor[1]);
125 UNCLAMPED_FLOAT_TO_CHAN(blue, textureUnit->EnvColor[2]);
126 UNCLAMPED_FLOAT_TO_CHAN(alpha, textureUnit->EnvColor[3]);
127 for (i = 0; i < n; i++) {
128 c[i][RCOMP] = red;
129 c[i][GCOMP] = green;
130 c[i][BCOMP] = blue;
131 c[i][ACOMP] = alpha;
132 }
133 argRGB[j] = (const GLchan (*)[4]) ccolor[j];
134 }
135 break;
136 /* GL_ATI_texture_env_combine3 allows GL_ZERO & GL_ONE as sources.
137 */
138 case GL_ZERO:
139 argRGB[j] = & zero;
140 break;
141 case GL_ONE:
142 argRGB[j] = & one;
143 break;
144 default:
145 /* ARB_texture_env_crossbar source */
146 {
147 const GLuint srcUnit = srcRGB - GL_TEXTURE0;
148 ASSERT(srcUnit < ctx->Const.MaxTextureUnits);
149 if (!ctx->Texture.Unit[srcUnit]._ReallyEnabled)
150 return;
151 argRGB[j] = (const GLchan (*)[4])
152 (texelBuffer + srcUnit * (n * 4 * sizeof(GLchan)));
153 }
154 }
155
156 if (textureUnit->_CurrentCombine->OperandRGB[j] != GL_SRC_COLOR) {
157 const GLchan (*src)[4] = argRGB[j];
158 GLchan (*dst)[4] = ccolor[j];
159
160 /* point to new arg[j] storage */
161 argRGB[j] = (const GLchan (*)[4]) ccolor[j];
162
163 if (textureUnit->_CurrentCombine->OperandRGB[j] == GL_ONE_MINUS_SRC_COLOR) {
164 for (i = 0; i < n; i++) {
165 dst[i][RCOMP] = CHAN_MAX - src[i][RCOMP];
166 dst[i][GCOMP] = CHAN_MAX - src[i][GCOMP];
167 dst[i][BCOMP] = CHAN_MAX - src[i][BCOMP];
168 }
169 }
170 else if (textureUnit->_CurrentCombine->OperandRGB[j] == GL_SRC_ALPHA) {
171 for (i = 0; i < n; i++) {
172 dst[i][RCOMP] = src[i][ACOMP];
173 dst[i][GCOMP] = src[i][ACOMP];
174 dst[i][BCOMP] = src[i][ACOMP];
175 }
176 }
177 else {
178 ASSERT(textureUnit->_CurrentCombine->OperandRGB[j] ==GL_ONE_MINUS_SRC_ALPHA);
179 for (i = 0; i < n; i++) {
180 dst[i][RCOMP] = CHAN_MAX - src[i][ACOMP];
181 dst[i][GCOMP] = CHAN_MAX - src[i][ACOMP];
182 dst[i][BCOMP] = CHAN_MAX - src[i][ACOMP];
183 }
184 }
185 }
186 }
187
188 /*
189 * Set up the argA[i] pointers
190 */
191 for (j = 0; j < numAlphaArgs; j++) {
192 const GLenum srcA = textureUnit->_CurrentCombine->SourceA[j];
193
194 switch (srcA) {
195 case GL_TEXTURE:
196 argA[j] = (const GLchan (*)[4])
197 (texelBuffer + unit * (n * 4 * sizeof(GLchan)));
198 break;
199 case GL_PRIMARY_COLOR:
200 argA[j] = primary_rgba;
201 break;
202 case GL_PREVIOUS:
203 argA[j] = (const GLchan (*)[4]) rgba;
204 break;
205 case GL_CONSTANT:
206 {
207 GLchan alpha, (*c)[4] = ccolor[j];
208 UNCLAMPED_FLOAT_TO_CHAN(alpha, textureUnit->EnvColor[3]);
209 for (i = 0; i < n; i++)
210 c[i][ACOMP] = alpha;
211 argA[j] = (const GLchan (*)[4]) ccolor[j];
212 }
213 break;
214 /* GL_ATI_texture_env_combine3 allows GL_ZERO & GL_ONE as sources.
215 */
216 case GL_ZERO:
217 argA[j] = & zero;
218 break;
219 case GL_ONE:
220 argA[j] = & one;
221 break;
222 default:
223 /* ARB_texture_env_crossbar source */
224 {
225 const GLuint srcUnit = srcA - GL_TEXTURE0;
226 ASSERT(srcUnit < ctx->Const.MaxTextureUnits);
227 if (!ctx->Texture.Unit[srcUnit]._ReallyEnabled)
228 return;
229 argA[j] = (const GLchan (*)[4])
230 (texelBuffer + srcUnit * (n * 4 * sizeof(GLchan)));
231 }
232 }
233
234 if (textureUnit->_CurrentCombine->OperandA[j] == GL_ONE_MINUS_SRC_ALPHA) {
235 const GLchan (*src)[4] = argA[j];
236 GLchan (*dst)[4] = ccolor[j];
237 argA[j] = (const GLchan (*)[4]) ccolor[j];
238 for (i = 0; i < n; i++) {
239 dst[i][ACOMP] = CHAN_MAX - src[i][ACOMP];
240 }
241 }
242 }
243
244 /*
245 * Do the texture combine.
246 */
247 switch (textureUnit->_CurrentCombine->ModeRGB) {
248 case GL_REPLACE:
249 {
250 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
251 if (RGBshift) {
252 for (i = 0; i < n; i++) {
253 #if CHAN_TYPE == GL_FLOAT
254 rgba[i][RCOMP] = arg0[i][RCOMP] * RGBmult;
255 rgba[i][GCOMP] = arg0[i][GCOMP] * RGBmult;
256 rgba[i][BCOMP] = arg0[i][BCOMP] * RGBmult;
257 #else
258 GLuint r = (GLuint) arg0[i][RCOMP] << RGBshift;
259 GLuint g = (GLuint) arg0[i][GCOMP] << RGBshift;
260 GLuint b = (GLuint) arg0[i][BCOMP] << RGBshift;
261 rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
262 rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
263 rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
264 #endif
265 }
266 }
267 else {
268 for (i = 0; i < n; i++) {
269 rgba[i][RCOMP] = arg0[i][RCOMP];
270 rgba[i][GCOMP] = arg0[i][GCOMP];
271 rgba[i][BCOMP] = arg0[i][BCOMP];
272 }
273 }
274 }
275 break;
276 case GL_MODULATE:
277 {
278 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
279 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
280 #if CHAN_TYPE != GL_FLOAT
281 const GLint shift = CHAN_BITS - RGBshift;
282 #endif
283 for (i = 0; i < n; i++) {
284 #if CHAN_TYPE == GL_FLOAT
285 rgba[i][RCOMP] = arg0[i][RCOMP] * arg1[i][RCOMP] * RGBmult;
286 rgba[i][GCOMP] = arg0[i][GCOMP] * arg1[i][GCOMP] * RGBmult;
287 rgba[i][BCOMP] = arg0[i][BCOMP] * arg1[i][BCOMP] * RGBmult;
288 #else
289 GLuint r = PROD(arg0[i][RCOMP], arg1[i][RCOMP]) >> shift;
290 GLuint g = PROD(arg0[i][GCOMP], arg1[i][GCOMP]) >> shift;
291 GLuint b = PROD(arg0[i][BCOMP], arg1[i][BCOMP]) >> shift;
292 rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
293 rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
294 rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
295 #endif
296 }
297 }
298 break;
299 case GL_ADD:
300 if (textureUnit->EnvMode == GL_COMBINE4_NV) {
301 /* (a * b) + (c * d) */
302 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
303 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
304 const GLchan (*arg2)[4] = (const GLchan (*)[4]) argRGB[2];
305 const GLchan (*arg3)[4] = (const GLchan (*)[4]) argRGB[3];
306 for (i = 0; i < n; i++) {
307 #if CHAN_TYPE == GL_FLOAT
308 rgba[i][RCOMP] = (arg0[i][RCOMP] * arg1[i][RCOMP] +
309 arg2[i][RCOMP] * arg3[i][RCOMP]) * RGBmult;
310 rgba[i][GCOMP] = (arg0[i][GCOMP] * arg1[i][GCOMP] +
311 arg2[i][GCOMP] * arg3[i][GCOMP]) * RGBmult;
312 rgba[i][BCOMP] = (arg0[i][BCOMP] * arg1[i][BCOMP] +
313 arg2[i][BCOMP] * arg3[i][BCOMP]) * RGBmult;
314 #else
315 const GLint shift = CHAN_BITS - RGBshift;
316 GLint r = (PROD(arg0[i][RCOMP], arg1[i][RCOMP]) >> shift) +
317 (PROD(arg2[i][RCOMP], arg3[i][RCOMP]) >> shift);
318 GLint g = (PROD(arg0[i][GCOMP], arg1[i][GCOMP]) >> shift) +
319 (PROD(arg2[i][GCOMP], arg3[i][GCOMP]) >> shift);
320 GLint b = (PROD(arg0[i][BCOMP], arg1[i][BCOMP]) >> shift) +
321 (PROD(arg2[i][BCOMP], arg3[i][BCOMP]) >> shift);
322 rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
323 rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
324 rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
325 #endif
326 }
327 }
328 else {
329 /* 2-term addition */
330 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
331 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
332 for (i = 0; i < n; i++) {
333 #if CHAN_TYPE == GL_FLOAT
334 rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP]) * RGBmult;
335 rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP]) * RGBmult;
336 rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP]) * RGBmult;
337 #else
338 GLint r = ((GLint) arg0[i][RCOMP] + (GLint) arg1[i][RCOMP]) << RGBshift;
339 GLint g = ((GLint) arg0[i][GCOMP] + (GLint) arg1[i][GCOMP]) << RGBshift;
340 GLint b = ((GLint) arg0[i][BCOMP] + (GLint) arg1[i][BCOMP]) << RGBshift;
341 rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
342 rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
343 rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
344 #endif
345 }
346 }
347 break;
348 case GL_ADD_SIGNED:
349 if (textureUnit->EnvMode == GL_COMBINE4_NV) {
350 /* (a * b) + (c * d) - 0.5 */
351 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
352 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
353 const GLchan (*arg2)[4] = (const GLchan (*)[4]) argRGB[2];
354 const GLchan (*arg3)[4] = (const GLchan (*)[4]) argRGB[3];
355 for (i = 0; i < n; i++) {
356 #if CHAN_TYPE == GL_FLOAT
357 rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP] *
358 arg2[i][RCOMP] + arg3[i][RCOMP] - 0.5) * RGBmult;
359 rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP] *
360 arg2[i][GCOMP] + arg3[i][GCOMP] - 0.5) * RGBmult;
361 rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP] *
362 arg2[i][BCOMP] + arg3[i][BCOMP] - 0.5) * RGBmult;
363 #else
364 GLint r = (((PROD(arg0[i][RCOMP], arg1[i][RCOMP]) +
365 PROD(arg2[i][RCOMP], arg3[i][RCOMP])) >> CHAN_BITS) - half)
366 << RGBshift;
367 GLint g = (((PROD(arg0[i][GCOMP], arg1[i][GCOMP]) +
368 PROD(arg2[i][GCOMP], arg3[i][GCOMP])) >> CHAN_BITS) - half)
369 << RGBshift;
370 GLint b = (((PROD(arg0[i][BCOMP], arg1[i][BCOMP]) +
371 PROD(arg2[i][BCOMP], arg3[i][BCOMP])) >> CHAN_BITS) - half)
372 << RGBshift;
373 rgba[i][RCOMP] = (GLchan) CLAMP(r, 0, CHAN_MAX);
374 rgba[i][GCOMP] = (GLchan) CLAMP(g, 0, CHAN_MAX);
375 rgba[i][BCOMP] = (GLchan) CLAMP(b, 0, CHAN_MAX);
376 #endif
377 }
378 }
379 else {
380 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
381 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
382 for (i = 0; i < n; i++) {
383 #if CHAN_TYPE == GL_FLOAT
384 rgba[i][RCOMP] = (arg0[i][RCOMP] + arg1[i][RCOMP] - 0.5) * RGBmult;
385 rgba[i][GCOMP] = (arg0[i][GCOMP] + arg1[i][GCOMP] - 0.5) * RGBmult;
386 rgba[i][BCOMP] = (arg0[i][BCOMP] + arg1[i][BCOMP] - 0.5) * RGBmult;
387 #else
388 GLint r = (GLint) arg0[i][RCOMP] + (GLint) arg1[i][RCOMP] - half;
389 GLint g = (GLint) arg0[i][GCOMP] + (GLint) arg1[i][GCOMP] - half;
390 GLint b = (GLint) arg0[i][BCOMP] + (GLint) arg1[i][BCOMP] - half;
391 r = (r < 0) ? 0 : r << RGBshift;
392 g = (g < 0) ? 0 : g << RGBshift;
393 b = (b < 0) ? 0 : b << RGBshift;
394 rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
395 rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
396 rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
397 #endif
398 }
399 }
400 break;
401 case GL_INTERPOLATE:
402 {
403 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
404 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
405 const GLchan (*arg2)[4] = (const GLchan (*)[4]) argRGB[2];
406 #if CHAN_TYPE != GL_FLOAT
407 const GLint shift = CHAN_BITS - RGBshift;
408 #endif
409 for (i = 0; i < n; i++) {
410 #if CHAN_TYPE == GL_FLOAT
411 rgba[i][RCOMP] = (arg0[i][RCOMP] * arg2[i][RCOMP] +
412 arg1[i][RCOMP] * (CHAN_MAXF - arg2[i][RCOMP])) * RGBmult;
413 rgba[i][GCOMP] = (arg0[i][GCOMP] * arg2[i][GCOMP] +
414 arg1[i][GCOMP] * (CHAN_MAXF - arg2[i][GCOMP])) * RGBmult;
415 rgba[i][BCOMP] = (arg0[i][BCOMP] * arg2[i][BCOMP] +
416 arg1[i][BCOMP] * (CHAN_MAXF - arg2[i][BCOMP])) * RGBmult;
417 #else
418 GLuint r = (PROD(arg0[i][RCOMP], arg2[i][RCOMP])
419 + PROD(arg1[i][RCOMP], CHAN_MAX - arg2[i][RCOMP]))
420 >> shift;
421 GLuint g = (PROD(arg0[i][GCOMP], arg2[i][GCOMP])
422 + PROD(arg1[i][GCOMP], CHAN_MAX - arg2[i][GCOMP]))
423 >> shift;
424 GLuint b = (PROD(arg0[i][BCOMP], arg2[i][BCOMP])
425 + PROD(arg1[i][BCOMP], CHAN_MAX - arg2[i][BCOMP]))
426 >> shift;
427 rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
428 rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
429 rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
430 #endif
431 }
432 }
433 break;
434 case GL_SUBTRACT:
435 {
436 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
437 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
438 for (i = 0; i < n; i++) {
439 #if CHAN_TYPE == GL_FLOAT
440 rgba[i][RCOMP] = (arg0[i][RCOMP] - arg1[i][RCOMP]) * RGBmult;
441 rgba[i][GCOMP] = (arg0[i][GCOMP] - arg1[i][GCOMP]) * RGBmult;
442 rgba[i][BCOMP] = (arg0[i][BCOMP] - arg1[i][BCOMP]) * RGBmult;
443 #else
444 GLint r = ((GLint) arg0[i][RCOMP] - (GLint) arg1[i][RCOMP]) << RGBshift;
445 GLint g = ((GLint) arg0[i][GCOMP] - (GLint) arg1[i][GCOMP]) << RGBshift;
446 GLint b = ((GLint) arg0[i][BCOMP] - (GLint) arg1[i][BCOMP]) << RGBshift;
447 rgba[i][RCOMP] = (GLchan) CLAMP(r, 0, CHAN_MAX);
448 rgba[i][GCOMP] = (GLchan) CLAMP(g, 0, CHAN_MAX);
449 rgba[i][BCOMP] = (GLchan) CLAMP(b, 0, CHAN_MAX);
450 #endif
451 }
452 }
453 break;
454 case GL_DOT3_RGB_EXT:
455 case GL_DOT3_RGBA_EXT:
456 {
457 /* Do not scale the result by 1 2 or 4 */
458 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
459 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
460 for (i = 0; i < n; i++) {
461 #if CHAN_TYPE == GL_FLOAT
462 GLchan dot = ((arg0[i][RCOMP]-0.5F) * (arg1[i][RCOMP]-0.5F) +
463 (arg0[i][GCOMP]-0.5F) * (arg1[i][GCOMP]-0.5F) +
464 (arg0[i][BCOMP]-0.5F) * (arg1[i][BCOMP]-0.5F))
465 * 4.0F;
466 dot = CLAMP(dot, 0.0F, CHAN_MAXF);
467 #else
468 GLint dot = (S_PROD((GLint)arg0[i][RCOMP] - half,
469 (GLint)arg1[i][RCOMP] - half) +
470 S_PROD((GLint)arg0[i][GCOMP] - half,
471 (GLint)arg1[i][GCOMP] - half) +
472 S_PROD((GLint)arg0[i][BCOMP] - half,
473 (GLint)arg1[i][BCOMP] - half)) >> 6;
474 dot = CLAMP(dot, 0, CHAN_MAX);
475 #endif
476 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = (GLchan) dot;
477 }
478 }
479 break;
480 case GL_DOT3_RGB:
481 case GL_DOT3_RGBA:
482 {
483 /* DO scale the result by 1 2 or 4 */
484 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
485 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
486 for (i = 0; i < n; i++) {
487 #if CHAN_TYPE == GL_FLOAT
488 GLchan dot = ((arg0[i][RCOMP]-0.5F) * (arg1[i][RCOMP]-0.5F) +
489 (arg0[i][GCOMP]-0.5F) * (arg1[i][GCOMP]-0.5F) +
490 (arg0[i][BCOMP]-0.5F) * (arg1[i][BCOMP]-0.5F))
491 * 4.0F * RGBmult;
492 dot = CLAMP(dot, 0.0, CHAN_MAXF);
493 #else
494 GLint dot = (S_PROD((GLint)arg0[i][RCOMP] - half,
495 (GLint)arg1[i][RCOMP] - half) +
496 S_PROD((GLint)arg0[i][GCOMP] - half,
497 (GLint)arg1[i][GCOMP] - half) +
498 S_PROD((GLint)arg0[i][BCOMP] - half,
499 (GLint)arg1[i][BCOMP] - half)) >> 6;
500 dot <<= RGBshift;
501 dot = CLAMP(dot, 0, CHAN_MAX);
502 #endif
503 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = (GLchan) dot;
504 }
505 }
506 break;
507 case GL_MODULATE_ADD_ATI:
508 {
509 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
510 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
511 const GLchan (*arg2)[4] = (const GLchan (*)[4]) argRGB[2];
512 #if CHAN_TYPE != GL_FLOAT
513 const GLint shift = CHAN_BITS - RGBshift;
514 #endif
515 for (i = 0; i < n; i++) {
516 #if CHAN_TYPE == GL_FLOAT
517 rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) + arg1[i][RCOMP]) * RGBmult;
518 rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) + arg1[i][GCOMP]) * RGBmult;
519 rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) + arg1[i][BCOMP]) * RGBmult;
520 #else
521 GLuint r = (PROD(arg0[i][RCOMP], arg2[i][RCOMP])
522 + ((GLuint) arg1[i][RCOMP] << CHAN_BITS)) >> shift;
523 GLuint g = (PROD(arg0[i][GCOMP], arg2[i][GCOMP])
524 + ((GLuint) arg1[i][GCOMP] << CHAN_BITS)) >> shift;
525 GLuint b = (PROD(arg0[i][BCOMP], arg2[i][BCOMP])
526 + ((GLuint) arg1[i][BCOMP] << CHAN_BITS)) >> shift;
527 rgba[i][RCOMP] = (GLchan) MIN2(r, CHAN_MAX);
528 rgba[i][GCOMP] = (GLchan) MIN2(g, CHAN_MAX);
529 rgba[i][BCOMP] = (GLchan) MIN2(b, CHAN_MAX);
530 #endif
531 }
532 }
533 break;
534 case GL_MODULATE_SIGNED_ADD_ATI:
535 {
536 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
537 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
538 const GLchan (*arg2)[4] = (const GLchan (*)[4]) argRGB[2];
539 #if CHAN_TYPE != GL_FLOAT
540 const GLint shift = CHAN_BITS - RGBshift;
541 #endif
542 for (i = 0; i < n; i++) {
543 #if CHAN_TYPE == GL_FLOAT
544 rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) + arg1[i][RCOMP] - 0.5) * RGBmult;
545 rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) + arg1[i][GCOMP] - 0.5) * RGBmult;
546 rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) + arg1[i][BCOMP] - 0.5) * RGBmult;
547 #else
548 GLint r = (S_PROD(arg0[i][RCOMP], arg2[i][RCOMP])
549 + (((GLint) arg1[i][RCOMP] - half) << CHAN_BITS))
550 >> shift;
551 GLint g = (S_PROD(arg0[i][GCOMP], arg2[i][GCOMP])
552 + (((GLint) arg1[i][GCOMP] - half) << CHAN_BITS))
553 >> shift;
554 GLint b = (S_PROD(arg0[i][BCOMP], arg2[i][BCOMP])
555 + (((GLint) arg1[i][BCOMP] - half) << CHAN_BITS))
556 >> shift;
557 rgba[i][RCOMP] = (GLchan) CLAMP(r, 0, CHAN_MAX);
558 rgba[i][GCOMP] = (GLchan) CLAMP(g, 0, CHAN_MAX);
559 rgba[i][BCOMP] = (GLchan) CLAMP(b, 0, CHAN_MAX);
560 #endif
561 }
562 }
563 break;
564 case GL_MODULATE_SUBTRACT_ATI:
565 {
566 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argRGB[0];
567 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argRGB[1];
568 const GLchan (*arg2)[4] = (const GLchan (*)[4]) argRGB[2];
569 #if CHAN_TYPE != GL_FLOAT
570 const GLint shift = CHAN_BITS - RGBshift;
571 #endif
572 for (i = 0; i < n; i++) {
573 #if CHAN_TYPE == GL_FLOAT
574 rgba[i][RCOMP] = ((arg0[i][RCOMP] * arg2[i][RCOMP]) - arg1[i][RCOMP]) * RGBmult;
575 rgba[i][GCOMP] = ((arg0[i][GCOMP] * arg2[i][GCOMP]) - arg1[i][GCOMP]) * RGBmult;
576 rgba[i][BCOMP] = ((arg0[i][BCOMP] * arg2[i][BCOMP]) - arg1[i][BCOMP]) * RGBmult;
577 #else
578 GLint r = (S_PROD(arg0[i][RCOMP], arg2[i][RCOMP])
579 - ((GLint) arg1[i][RCOMP] << CHAN_BITS))
580 >> shift;
581 GLint g = (S_PROD(arg0[i][GCOMP], arg2[i][GCOMP])
582 - ((GLint) arg1[i][GCOMP] << CHAN_BITS))
583 >> shift;
584 GLint b = (S_PROD(arg0[i][BCOMP], arg2[i][BCOMP])
585 - ((GLint) arg1[i][BCOMP] << CHAN_BITS))
586 >> shift;
587 rgba[i][RCOMP] = (GLchan) CLAMP(r, 0, CHAN_MAX);
588 rgba[i][GCOMP] = (GLchan) CLAMP(g, 0, CHAN_MAX);
589 rgba[i][BCOMP] = (GLchan) CLAMP(b, 0, CHAN_MAX);
590 #endif
591 }
592 }
593 break;
594 case GL_BUMP_ENVMAP_ATI:
595 {
596 /* this produces a fixed rgba color, and the coord calc is done elsewhere */
597 for (i = 0; i < n; i++) {
598 /* rgba result is 0,0,0,1 */
599 #if CHAN_TYPE == GL_FLOAT
600 rgba[i][RCOMP] = 0.0;
601 rgba[i][GCOMP] = 0.0;
602 rgba[i][BCOMP] = 0.0;
603 rgba[i][ACOMP] = 1.0;
604 #else
605 rgba[i][RCOMP] = 0;
606 rgba[i][GCOMP] = 0;
607 rgba[i][BCOMP] = 0;
608 rgba[i][ACOMP] = CHAN_MAX;
609 #endif
610 }
611 }
612 return; /* no alpha processing */
613 default:
614 _mesa_problem(ctx, "invalid combine mode");
615 }
616
617 switch (textureUnit->_CurrentCombine->ModeA) {
618 case GL_REPLACE:
619 {
620 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
621 if (Ashift) {
622 for (i = 0; i < n; i++) {
623 #if CHAN_TYPE == GL_FLOAT
624 GLchan a = arg0[i][ACOMP] * Amult;
625 #else
626 GLuint a = (GLuint) arg0[i][ACOMP] << Ashift;
627 #endif
628 rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
629 }
630 }
631 else {
632 for (i = 0; i < n; i++) {
633 rgba[i][ACOMP] = arg0[i][ACOMP];
634 }
635 }
636 }
637 break;
638 case GL_MODULATE:
639 {
640 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
641 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
642 #if CHAN_TYPE != GL_FLOAT
643 const GLint shift = CHAN_BITS - Ashift;
644 #endif
645 for (i = 0; i < n; i++) {
646 #if CHAN_TYPE == GL_FLOAT
647 rgba[i][ACOMP] = arg0[i][ACOMP] * arg1[i][ACOMP] * Amult;
648 #else
649 GLuint a = (PROD(arg0[i][ACOMP], arg1[i][ACOMP]) >> shift);
650 rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
651 #endif
652 }
653 }
654 break;
655 case GL_ADD:
656 if (textureUnit->EnvMode == GL_COMBINE4_NV) {
657 /* (a * b) + (c * d) */
658 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
659 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
660 const GLchan (*arg2)[4] = (const GLchan (*)[4]) argA[2];
661 const GLchan (*arg3)[4] = (const GLchan (*)[4]) argA[3];
662 for (i = 0; i < n; i++) {
663 #if CHAN_TYPE == GL_FLOAT
664 rgba[i][ACOMP] = (arg0[i][ACOMP] * arg1[i][ACOMP] +
665 arg2[i][ACOMP] * arg3[i][ACOMP]) * Amult;
666 #else
667 const GLint shift = CHAN_BITS - Ashift;
668 GLint a = (PROD(arg0[i][ACOMP], arg1[i][ACOMP]) >> shift) +
669 (PROD(arg2[i][ACOMP], arg3[i][ACOMP]) >> shift);
670 rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
671 #endif
672 }
673 }
674 else {
675 /* two-term add */
676 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
677 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
678 for (i = 0; i < n; i++) {
679 #if CHAN_TYPE == GL_FLOAT
680 rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP]) * Amult;
681 #else
682 GLint a = ((GLint) arg0[i][ACOMP] + arg1[i][ACOMP]) << Ashift;
683 rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
684 #endif
685 }
686 }
687 break;
688 case GL_ADD_SIGNED:
689 if (textureUnit->EnvMode == GL_COMBINE4_NV) {
690 /* (a * b) + (c * d) - 0.5 */
691 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
692 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
693 const GLchan (*arg2)[4] = (const GLchan (*)[4]) argA[2];
694 const GLchan (*arg3)[4] = (const GLchan (*)[4]) argA[3];
695 for (i = 0; i < n; i++) {
696 #if CHAN_TYPE == GL_FLOAT
697 rgba[i][ACOMP] = (arg0[i][ACOMP] * arg1[i][ACOMP] +
698 arg2[i][ACOMP] * arg3[i][ACOMP] -
699 0.5) * Amult;
700 #else
701 GLint a = (((PROD(arg0[i][ACOMP], arg1[i][ACOMP]) +
702 PROD(arg2[i][ACOMP], arg3[i][ACOMP])) >> CHAN_BITS) - half)
703 << Ashift;
704 rgba[i][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
705 #endif
706 }
707 }
708 else {
709 /* a + b - 0.5 */
710 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
711 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
712 for (i = 0; i < n; i++) {
713 #if CHAN_TYPE == GL_FLOAT
714 rgba[i][ACOMP] = (arg0[i][ACOMP] + arg1[i][ACOMP] - 0.5F) * Amult;
715 #else
716 GLint a = (GLint) arg0[i][ACOMP] + (GLint) arg1[i][ACOMP] -half;
717 a = (a < 0) ? 0 : a << Ashift;
718 rgba[i][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
719 #endif
720 }
721 }
722 break;
723 case GL_INTERPOLATE:
724 {
725 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
726 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
727 const GLchan (*arg2)[4] = (const GLchan (*)[4]) argA[2];
728 #if CHAN_TYPE != GL_FLOAT
729 const GLint shift = CHAN_BITS - Ashift;
730 #endif
731 for (i=0; i<n; i++) {
732 #if CHAN_TYPE == GL_FLOAT
733 rgba[i][ACOMP] = (arg0[i][ACOMP] * arg2[i][ACOMP] +
734 arg1[i][ACOMP] * (CHAN_MAXF - arg2[i][ACOMP]))
735 * Amult;
736 #else
737 GLuint a = (PROD(arg0[i][ACOMP], arg2[i][ACOMP])
738 + PROD(arg1[i][ACOMP], CHAN_MAX - arg2[i][ACOMP]))
739 >> shift;
740 rgba[i][ACOMP] = (GLchan) MIN2(a, CHAN_MAX);
741 #endif
742 }
743 }
744 break;
745 case GL_SUBTRACT:
746 {
747 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
748 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
749 for (i = 0; i < n; i++) {
750 #if CHAN_TYPE == GL_FLOAT
751 rgba[i][ACOMP] = (arg0[i][ACOMP] - arg1[i][ACOMP]) * Amult;
752 #else
753 GLint a = ((GLint) arg0[i][ACOMP] - (GLint) arg1[i][ACOMP]) << Ashift;
754 rgba[i][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
755 #endif
756 }
757 }
758 break;
759 case GL_MODULATE_ADD_ATI:
760 {
761 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
762 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
763 const GLchan (*arg2)[4] = (const GLchan (*)[4]) argA[2];
764 #if CHAN_TYPE != GL_FLOAT
765 const GLint shift = CHAN_BITS - Ashift;
766 #endif
767 for (i = 0; i < n; i++) {
768 #if CHAN_TYPE == GL_FLOAT
769 rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP]) + arg1[i][ACOMP]) * Amult;
770 #else
771 GLint a = (PROD(arg0[i][ACOMP], arg2[i][ACOMP])
772 + ((GLuint) arg1[i][ACOMP] << CHAN_BITS))
773 >> shift;
774 rgba[i][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
775 #endif
776 }
777 }
778 break;
779 case GL_MODULATE_SIGNED_ADD_ATI:
780 {
781 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
782 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
783 const GLchan (*arg2)[4] = (const GLchan (*)[4]) argA[2];
784 #if CHAN_TYPE != GL_FLOAT
785 const GLint shift = CHAN_BITS - Ashift;
786 #endif
787 for (i = 0; i < n; i++) {
788 #if CHAN_TYPE == GL_FLOAT
789 rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP]) + arg1[i][ACOMP] - 0.5F) * Amult;
790 #else
791 GLint a = (S_PROD(arg0[i][ACOMP], arg2[i][ACOMP])
792 + (((GLint) arg1[i][ACOMP] - half) << CHAN_BITS))
793 >> shift;
794 rgba[i][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
795 #endif
796 }
797 }
798 break;
799 case GL_MODULATE_SUBTRACT_ATI:
800 {
801 const GLchan (*arg0)[4] = (const GLchan (*)[4]) argA[0];
802 const GLchan (*arg1)[4] = (const GLchan (*)[4]) argA[1];
803 const GLchan (*arg2)[4] = (const GLchan (*)[4]) argA[2];
804 #if CHAN_TYPE != GL_FLOAT
805 const GLint shift = CHAN_BITS - Ashift;
806 #endif
807 for (i = 0; i < n; i++) {
808 #if CHAN_TYPE == GL_FLOAT
809 rgba[i][ACOMP] = ((arg0[i][ACOMP] * arg2[i][ACOMP]) - arg1[i][ACOMP]) * Amult;
810 #else
811 GLint a = (S_PROD(arg0[i][ACOMP], arg2[i][ACOMP])
812 - ((GLint) arg1[i][ACOMP] << CHAN_BITS))
813 >> shift;
814 rgba[i][ACOMP] = (GLchan) CLAMP(a, 0, CHAN_MAX);
815 #endif
816 }
817 }
818 break;
819 default:
820 _mesa_problem(ctx, "invalid combine mode");
821 }
822
823 /* Fix the alpha component for GL_DOT3_RGBA_EXT/ARB combining.
824 * This is kind of a kludge. It would have been better if the spec
825 * were written such that the GL_COMBINE_ALPHA value could be set to
826 * GL_DOT3.
827 */
828 if (textureUnit->_CurrentCombine->ModeRGB == GL_DOT3_RGBA_EXT ||
829 textureUnit->_CurrentCombine->ModeRGB == GL_DOT3_RGBA) {
830 for (i = 0; i < n; i++) {
831 rgba[i][ACOMP] = rgba[i][RCOMP];
832 }
833 }
834 }
835 #undef PROD
836
837
838 /**
839 * Apply X/Y/Z/W/0/1 swizzle to an array of colors/texels.
840 * See GL_EXT_texture_swizzle.
841 */
842 static void
843 swizzle_texels(GLuint swizzle, GLuint count, GLchan (*texels)[4])
844 {
845 const GLuint swzR = GET_SWZ(swizzle, 0);
846 const GLuint swzG = GET_SWZ(swizzle, 1);
847 const GLuint swzB = GET_SWZ(swizzle, 2);
848 const GLuint swzA = GET_SWZ(swizzle, 3);
849 GLchan vector[6];
850 GLuint i;
851
852 vector[SWIZZLE_ZERO] = 0;
853 vector[SWIZZLE_ONE] = CHAN_MAX;
854
855 for (i = 0; i < count; i++) {
856 vector[SWIZZLE_X] = texels[i][0];
857 vector[SWIZZLE_Y] = texels[i][1];
858 vector[SWIZZLE_Z] = texels[i][2];
859 vector[SWIZZLE_W] = texels[i][3];
860 texels[i][RCOMP] = vector[swzR];
861 texels[i][GCOMP] = vector[swzG];
862 texels[i][BCOMP] = vector[swzB];
863 texels[i][ACOMP] = vector[swzA];
864 }
865 }
866
867
868 /**
869 * Apply a conventional OpenGL texture env mode (REPLACE, ADD, BLEND,
870 * MODULATE, or DECAL) to an array of fragments.
871 * Input: textureUnit - pointer to texture unit to apply
872 * format - base internal texture format
873 * n - number of fragments
874 * primary_rgba - primary colors (may alias rgba for single texture)
875 * texels - array of texel colors
876 * InOut: rgba - incoming fragment colors modified by texel colors
877 * according to the texture environment mode.
878 */
879 static void
880 texture_apply( const GLcontext *ctx,
881 const struct gl_texture_unit *texUnit,
882 GLuint n,
883 CONST GLchan primary_rgba[][4], CONST GLchan texel[][4],
884 GLchan rgba[][4] )
885 {
886 GLint baseLevel;
887 GLuint i;
888 GLchan Rc, Gc, Bc, Ac;
889 GLenum format;
890 (void) primary_rgba;
891
892 ASSERT(texUnit);
893 ASSERT(texUnit->_Current);
894
895 baseLevel = texUnit->_Current->BaseLevel;
896 ASSERT(texUnit->_Current->Image[0][baseLevel]);
897
898 format = texUnit->_Current->Image[0][baseLevel]->_BaseFormat;
899
900 if (format == GL_COLOR_INDEX || format == GL_YCBCR_MESA) {
901 format = GL_RGBA; /* a bit of a hack */
902 }
903 else if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL_EXT) {
904 format = texUnit->_Current->DepthMode;
905 }
906
907 switch (texUnit->EnvMode) {
908 case GL_REPLACE:
909 switch (format) {
910 case GL_ALPHA:
911 for (i=0;i<n;i++) {
912 /* Cv = Cf */
913 /* Av = At */
914 rgba[i][ACOMP] = texel[i][ACOMP];
915 }
916 break;
917 case GL_LUMINANCE:
918 for (i=0;i<n;i++) {
919 /* Cv = Lt */
920 GLchan Lt = texel[i][RCOMP];
921 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = Lt;
922 /* Av = Af */
923 }
924 break;
925 case GL_LUMINANCE_ALPHA:
926 for (i=0;i<n;i++) {
927 GLchan Lt = texel[i][RCOMP];
928 /* Cv = Lt */
929 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = Lt;
930 /* Av = At */
931 rgba[i][ACOMP] = texel[i][ACOMP];
932 }
933 break;
934 case GL_INTENSITY:
935 for (i=0;i<n;i++) {
936 /* Cv = It */
937 GLchan It = texel[i][RCOMP];
938 rgba[i][RCOMP] = rgba[i][GCOMP] = rgba[i][BCOMP] = It;
939 /* Av = It */
940 rgba[i][ACOMP] = It;
941 }
942 break;
943 case GL_RGB:
944 for (i=0;i<n;i++) {
945 /* Cv = Ct */
946 rgba[i][RCOMP] = texel[i][RCOMP];
947 rgba[i][GCOMP] = texel[i][GCOMP];
948 rgba[i][BCOMP] = texel[i][BCOMP];
949 /* Av = Af */
950 }
951 break;
952 case GL_RGBA:
953 for (i=0;i<n;i++) {
954 /* Cv = Ct */
955 rgba[i][RCOMP] = texel[i][RCOMP];
956 rgba[i][GCOMP] = texel[i][GCOMP];
957 rgba[i][BCOMP] = texel[i][BCOMP];
958 /* Av = At */
959 rgba[i][ACOMP] = texel[i][ACOMP];
960 }
961 break;
962 default:
963 _mesa_problem(ctx, "Bad format (GL_REPLACE) in texture_apply");
964 return;
965 }
966 break;
967
968 case GL_MODULATE:
969 switch (format) {
970 case GL_ALPHA:
971 for (i=0;i<n;i++) {
972 /* Cv = Cf */
973 /* Av = AfAt */
974 rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], texel[i][ACOMP] );
975 }
976 break;
977 case GL_LUMINANCE:
978 for (i=0;i<n;i++) {
979 /* Cv = LtCf */
980 GLchan Lt = texel[i][RCOMP];
981 rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], Lt );
982 rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], Lt );
983 rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], Lt );
984 /* Av = Af */
985 }
986 break;
987 case GL_LUMINANCE_ALPHA:
988 for (i=0;i<n;i++) {
989 /* Cv = CfLt */
990 GLchan Lt = texel[i][RCOMP];
991 rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], Lt );
992 rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], Lt );
993 rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], Lt );
994 /* Av = AfAt */
995 rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], texel[i][ACOMP] );
996 }
997 break;
998 case GL_INTENSITY:
999 for (i=0;i<n;i++) {
1000 /* Cv = CfIt */
1001 GLchan It = texel[i][RCOMP];
1002 rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], It );
1003 rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], It );
1004 rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], It );
1005 /* Av = AfIt */
1006 rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], It );
1007 }
1008 break;
1009 case GL_RGB:
1010 for (i=0;i<n;i++) {
1011 /* Cv = CfCt */
1012 rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], texel[i][RCOMP] );
1013 rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], texel[i][GCOMP] );
1014 rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], texel[i][BCOMP] );
1015 /* Av = Af */
1016 }
1017 break;
1018 case GL_RGBA:
1019 for (i=0;i<n;i++) {
1020 /* Cv = CfCt */
1021 rgba[i][RCOMP] = CHAN_PRODUCT( rgba[i][RCOMP], texel[i][RCOMP] );
1022 rgba[i][GCOMP] = CHAN_PRODUCT( rgba[i][GCOMP], texel[i][GCOMP] );
1023 rgba[i][BCOMP] = CHAN_PRODUCT( rgba[i][BCOMP], texel[i][BCOMP] );
1024 /* Av = AfAt */
1025 rgba[i][ACOMP] = CHAN_PRODUCT( rgba[i][ACOMP], texel[i][ACOMP] );
1026 }
1027 break;
1028 default:
1029 _mesa_problem(ctx, "Bad format (GL_MODULATE) in texture_apply");
1030 return;
1031 }
1032 break;
1033
1034 case GL_DECAL:
1035 switch (format) {
1036 case GL_ALPHA:
1037 case GL_LUMINANCE:
1038 case GL_LUMINANCE_ALPHA:
1039 case GL_INTENSITY:
1040 /* undefined */
1041 break;
1042 case GL_RGB:
1043 for (i=0;i<n;i++) {
1044 /* Cv = Ct */
1045 rgba[i][RCOMP] = texel[i][RCOMP];
1046 rgba[i][GCOMP] = texel[i][GCOMP];
1047 rgba[i][BCOMP] = texel[i][BCOMP];
1048 /* Av = Af */
1049 }
1050 break;
1051 case GL_RGBA:
1052 for (i=0;i<n;i++) {
1053 /* Cv = Cf(1-At) + CtAt */
1054 GLchan t = texel[i][ACOMP], s = CHAN_MAX - t;
1055 rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(texel[i][RCOMP],t);
1056 rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(texel[i][GCOMP],t);
1057 rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(texel[i][BCOMP],t);
1058 /* Av = Af */
1059 }
1060 break;
1061 default:
1062 _mesa_problem(ctx, "Bad format (GL_DECAL) in texture_apply");
1063 return;
1064 }
1065 break;
1066
1067 case GL_BLEND:
1068 UNCLAMPED_FLOAT_TO_CHAN(Rc, texUnit->EnvColor[0]);
1069 UNCLAMPED_FLOAT_TO_CHAN(Gc, texUnit->EnvColor[1]);
1070 UNCLAMPED_FLOAT_TO_CHAN(Bc, texUnit->EnvColor[2]);
1071 UNCLAMPED_FLOAT_TO_CHAN(Ac, texUnit->EnvColor[3]);
1072 switch (format) {
1073 case GL_ALPHA:
1074 for (i=0;i<n;i++) {
1075 /* Cv = Cf */
1076 /* Av = AfAt */
1077 rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
1078 }
1079 break;
1080 case GL_LUMINANCE:
1081 for (i=0;i<n;i++) {
1082 /* Cv = Cf(1-Lt) + CcLt */
1083 GLchan Lt = texel[i][RCOMP], s = CHAN_MAX - Lt;
1084 rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(Rc, Lt);
1085 rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(Gc, Lt);
1086 rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(Bc, Lt);
1087 /* Av = Af */
1088 }
1089 break;
1090 case GL_LUMINANCE_ALPHA:
1091 for (i=0;i<n;i++) {
1092 /* Cv = Cf(1-Lt) + CcLt */
1093 GLchan Lt = texel[i][RCOMP], s = CHAN_MAX - Lt;
1094 rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(Rc, Lt);
1095 rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(Gc, Lt);
1096 rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(Bc, Lt);
1097 /* Av = AfAt */
1098 rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP],texel[i][ACOMP]);
1099 }
1100 break;
1101 case GL_INTENSITY:
1102 for (i=0;i<n;i++) {
1103 /* Cv = Cf(1-It) + CcIt */
1104 GLchan It = texel[i][RCOMP], s = CHAN_MAX - It;
1105 rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], s) + CHAN_PRODUCT(Rc, It);
1106 rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], s) + CHAN_PRODUCT(Gc, It);
1107 rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], s) + CHAN_PRODUCT(Bc, It);
1108 /* Av = Af(1-It) + Ac*It */
1109 rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], s) + CHAN_PRODUCT(Ac, It);
1110 }
1111 break;
1112 case GL_RGB:
1113 for (i=0;i<n;i++) {
1114 /* Cv = Cf(1-Ct) + CcCt */
1115 rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], (CHAN_MAX-texel[i][RCOMP])) + CHAN_PRODUCT(Rc,texel[i][RCOMP]);
1116 rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], (CHAN_MAX-texel[i][GCOMP])) + CHAN_PRODUCT(Gc,texel[i][GCOMP]);
1117 rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], (CHAN_MAX-texel[i][BCOMP])) + CHAN_PRODUCT(Bc,texel[i][BCOMP]);
1118 /* Av = Af */
1119 }
1120 break;
1121 case GL_RGBA:
1122 for (i=0;i<n;i++) {
1123 /* Cv = Cf(1-Ct) + CcCt */
1124 rgba[i][RCOMP] = CHAN_PRODUCT(rgba[i][RCOMP], (CHAN_MAX-texel[i][RCOMP])) + CHAN_PRODUCT(Rc,texel[i][RCOMP]);
1125 rgba[i][GCOMP] = CHAN_PRODUCT(rgba[i][GCOMP], (CHAN_MAX-texel[i][GCOMP])) + CHAN_PRODUCT(Gc,texel[i][GCOMP]);
1126 rgba[i][BCOMP] = CHAN_PRODUCT(rgba[i][BCOMP], (CHAN_MAX-texel[i][BCOMP])) + CHAN_PRODUCT(Bc,texel[i][BCOMP]);
1127 /* Av = AfAt */
1128 rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP],texel[i][ACOMP]);
1129 }
1130 break;
1131 default:
1132 _mesa_problem(ctx, "Bad format (GL_BLEND) in texture_apply");
1133 return;
1134 }
1135 break;
1136
1137 /* XXX don't clamp results if GLchan is float??? */
1138
1139 case GL_ADD: /* GL_EXT_texture_add_env */
1140 switch (format) {
1141 case GL_ALPHA:
1142 for (i=0;i<n;i++) {
1143 /* Rv = Rf */
1144 /* Gv = Gf */
1145 /* Bv = Bf */
1146 rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
1147 }
1148 break;
1149 case GL_LUMINANCE:
1150 for (i=0;i<n;i++) {
1151 ChanTemp Lt = texel[i][RCOMP];
1152 ChanTemp r = rgba[i][RCOMP] + Lt;
1153 ChanTemp g = rgba[i][GCOMP] + Lt;
1154 ChanTemp b = rgba[i][BCOMP] + Lt;
1155 rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
1156 rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
1157 rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
1158 /* Av = Af */
1159 }
1160 break;
1161 case GL_LUMINANCE_ALPHA:
1162 for (i=0;i<n;i++) {
1163 ChanTemp Lt = texel[i][RCOMP];
1164 ChanTemp r = rgba[i][RCOMP] + Lt;
1165 ChanTemp g = rgba[i][GCOMP] + Lt;
1166 ChanTemp b = rgba[i][BCOMP] + Lt;
1167 rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
1168 rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
1169 rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
1170 rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
1171 }
1172 break;
1173 case GL_INTENSITY:
1174 for (i=0;i<n;i++) {
1175 GLchan It = texel[i][RCOMP];
1176 ChanTemp r = rgba[i][RCOMP] + It;
1177 ChanTemp g = rgba[i][GCOMP] + It;
1178 ChanTemp b = rgba[i][BCOMP] + It;
1179 ChanTemp a = rgba[i][ACOMP] + It;
1180 rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
1181 rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
1182 rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
1183 rgba[i][ACOMP] = MIN2(a, CHAN_MAX);
1184 }
1185 break;
1186 case GL_RGB:
1187 for (i=0;i<n;i++) {
1188 ChanTemp r = rgba[i][RCOMP] + texel[i][RCOMP];
1189 ChanTemp g = rgba[i][GCOMP] + texel[i][GCOMP];
1190 ChanTemp b = rgba[i][BCOMP] + texel[i][BCOMP];
1191 rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
1192 rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
1193 rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
1194 /* Av = Af */
1195 }
1196 break;
1197 case GL_RGBA:
1198 for (i=0;i<n;i++) {
1199 ChanTemp r = rgba[i][RCOMP] + texel[i][RCOMP];
1200 ChanTemp g = rgba[i][GCOMP] + texel[i][GCOMP];
1201 ChanTemp b = rgba[i][BCOMP] + texel[i][BCOMP];
1202 rgba[i][RCOMP] = MIN2(r, CHAN_MAX);
1203 rgba[i][GCOMP] = MIN2(g, CHAN_MAX);
1204 rgba[i][BCOMP] = MIN2(b, CHAN_MAX);
1205 rgba[i][ACOMP] = CHAN_PRODUCT(rgba[i][ACOMP], texel[i][ACOMP]);
1206 }
1207 break;
1208 default:
1209 _mesa_problem(ctx, "Bad format (GL_ADD) in texture_apply");
1210 return;
1211 }
1212 break;
1213
1214 default:
1215 _mesa_problem(ctx, "Bad env mode in texture_apply");
1216 return;
1217 }
1218 }
1219
1220
1221
1222 /**
1223 * Apply texture mapping to a span of fragments.
1224 */
1225 void
1226 _swrast_texture_span( GLcontext *ctx, SWspan *span )
1227 {
1228 SWcontext *swrast = SWRAST_CONTEXT(ctx);
1229 GLchan primary_rgba[MAX_WIDTH][4];
1230 GLuint unit;
1231
1232 ASSERT(span->end < MAX_WIDTH);
1233
1234 /*
1235 * Save copy of the incoming fragment colors (the GL_PRIMARY_COLOR)
1236 */
1237 if (swrast->_AnyTextureCombine)
1238 MEMCPY(primary_rgba, span->array->rgba, 4 * span->end * sizeof(GLchan));
1239
1240 /* First must sample all bump maps */
1241 for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
1242 if (ctx->Texture.Unit[unit]._ReallyEnabled &&
1243 ctx->Texture.Unit[unit]._CurrentCombine->ModeRGB == GL_BUMP_ENVMAP_ATI) {
1244 const GLfloat (*texcoords)[4]
1245 = (const GLfloat (*)[4])
1246 span->array->attribs[FRAG_ATTRIB_TEX0 + unit];
1247 GLfloat (*targetcoords)[4]
1248 = (GLfloat (*)[4])
1249 span->array->attribs[FRAG_ATTRIB_TEX0 +
1250 ctx->Texture.Unit[unit].BumpTarget - GL_TEXTURE0];
1251
1252 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
1253 const struct gl_texture_object *curObj = texUnit->_Current;
1254 GLfloat *lambda = span->array->lambda[unit];
1255 GLchan (*texels)[4] = (GLchan (*)[4])
1256 (swrast->TexelBuffer + unit * (span->end * 4 * sizeof(GLchan)));
1257 GLuint i;
1258 GLfloat rotMatrix00 = ctx->Texture.Unit[unit].RotMatrix[0];
1259 GLfloat rotMatrix01 = ctx->Texture.Unit[unit].RotMatrix[1];
1260 GLfloat rotMatrix10 = ctx->Texture.Unit[unit].RotMatrix[2];
1261 GLfloat rotMatrix11 = ctx->Texture.Unit[unit].RotMatrix[3];
1262
1263 /* adjust texture lod (lambda) */
1264 if (span->arrayMask & SPAN_LAMBDA) {
1265 if (texUnit->LodBias + curObj->LodBias != 0.0F) {
1266 /* apply LOD bias, but don't clamp yet */
1267 const GLfloat bias = CLAMP(texUnit->LodBias + curObj->LodBias,
1268 -ctx->Const.MaxTextureLodBias,
1269 ctx->Const.MaxTextureLodBias);
1270 GLuint i;
1271 for (i = 0; i < span->end; i++) {
1272 lambda[i] += bias;
1273 }
1274 }
1275
1276 if (curObj->MinLod != -1000.0 || curObj->MaxLod != 1000.0) {
1277 /* apply LOD clamping to lambda */
1278 const GLfloat min = curObj->MinLod;
1279 const GLfloat max = curObj->MaxLod;
1280 GLuint i;
1281 for (i = 0; i < span->end; i++) {
1282 GLfloat l = lambda[i];
1283 lambda[i] = CLAMP(l, min, max);
1284 }
1285 }
1286 }
1287
1288 /* Sample the texture (span->end = number of fragments) */
1289 swrast->TextureSample[unit]( ctx, texUnit->_Current, span->end,
1290 texcoords, lambda, texels );
1291
1292 /* manipulate the span values of the bump target
1293 not sure this can work correctly even ignoring
1294 the problem that channel is unsigned */
1295 for (i = 0; i < span->end; i++) {
1296 #if CHAN_TYPE == GL_FLOAT
1297 targetcoords[i][0] += (texels[i][0] * rotMatrix00 + texels[i][1] *
1298 rotMatrix01) / targetcoords[i][3];
1299 targetcoords[i][1] += (texels[i][0] * rotMatrix10 + texels[i][1] *
1300 rotMatrix11) / targetcoords[i][3];
1301 #else
1302 targetcoords[i][0] += (CHAN_TO_FLOAT(texels[i][1]) * rotMatrix00 +
1303 CHAN_TO_FLOAT(texels[i][1]) * rotMatrix01) /
1304 targetcoords[i][3];
1305 targetcoords[i][1] += (CHAN_TO_FLOAT(texels[i][0]) * rotMatrix10 +
1306 CHAN_TO_FLOAT(texels[i][1]) * rotMatrix11) /
1307 targetcoords[i][3];
1308 #endif
1309 }
1310 }
1311 }
1312
1313 /*
1314 * Must do all texture sampling before combining in order to
1315 * accomodate GL_ARB_texture_env_crossbar.
1316 */
1317 for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
1318 if (ctx->Texture.Unit[unit]._ReallyEnabled &&
1319 ctx->Texture.Unit[unit]._CurrentCombine->ModeRGB != GL_BUMP_ENVMAP_ATI) {
1320 const GLfloat (*texcoords)[4]
1321 = (const GLfloat (*)[4])
1322 span->array->attribs[FRAG_ATTRIB_TEX0 + unit];
1323 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
1324 const struct gl_texture_object *curObj = texUnit->_Current;
1325 GLfloat *lambda = span->array->lambda[unit];
1326 GLchan (*texels)[4] = (GLchan (*)[4])
1327 (swrast->TexelBuffer + unit * (span->end * 4 * sizeof(GLchan)));
1328
1329 /* adjust texture lod (lambda) */
1330 if (span->arrayMask & SPAN_LAMBDA) {
1331 if (texUnit->LodBias + curObj->LodBias != 0.0F) {
1332 /* apply LOD bias, but don't clamp yet */
1333 const GLfloat bias = CLAMP(texUnit->LodBias + curObj->LodBias,
1334 -ctx->Const.MaxTextureLodBias,
1335 ctx->Const.MaxTextureLodBias);
1336 GLuint i;
1337 for (i = 0; i < span->end; i++) {
1338 lambda[i] += bias;
1339 }
1340 }
1341
1342 if (curObj->MinLod != -1000.0 || curObj->MaxLod != 1000.0) {
1343 /* apply LOD clamping to lambda */
1344 const GLfloat min = curObj->MinLod;
1345 const GLfloat max = curObj->MaxLod;
1346 GLuint i;
1347 for (i = 0; i < span->end; i++) {
1348 GLfloat l = lambda[i];
1349 lambda[i] = CLAMP(l, min, max);
1350 }
1351 }
1352 }
1353
1354 /* Sample the texture (span->end = number of fragments) */
1355 swrast->TextureSample[unit]( ctx, texUnit->_Current, span->end,
1356 texcoords, lambda, texels );
1357
1358 /* GL_SGI_texture_color_table */
1359 if (texUnit->ColorTableEnabled) {
1360 #if CHAN_TYPE == GL_UNSIGNED_BYTE
1361 _mesa_lookup_rgba_ubyte(&texUnit->ColorTable, span->end, texels);
1362 #elif CHAN_TYPE == GL_UNSIGNED_SHORT
1363 _mesa_lookup_rgba_ubyte(&texUnit->ColorTable, span->end, texels);
1364 #else
1365 _mesa_lookup_rgba_float(&texUnit->ColorTable, span->end, texels);
1366 #endif
1367 }
1368
1369 /* GL_EXT_texture_swizzle */
1370 if (curObj->_Swizzle != SWIZZLE_NOOP) {
1371 swizzle_texels(curObj->_Swizzle, span->end, texels);
1372 }
1373 }
1374 }
1375
1376
1377 /*
1378 * OK, now apply the texture (aka texture combine/blend).
1379 * We modify the span->color.rgba values.
1380 */
1381 for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
1382 if (ctx->Texture.Unit[unit]._ReallyEnabled) {
1383 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
1384 if (texUnit->_CurrentCombine != &texUnit->_EnvMode ) {
1385 texture_combine( ctx, unit, span->end,
1386 (CONST GLchan (*)[4]) primary_rgba,
1387 swrast->TexelBuffer,
1388 span->array->rgba );
1389 }
1390 else {
1391 /* conventional texture blend */
1392 const GLchan (*texels)[4] = (const GLchan (*)[4])
1393 (swrast->TexelBuffer + unit *
1394 (span->end * 4 * sizeof(GLchan)));
1395
1396
1397 texture_apply( ctx, texUnit, span->end,
1398 (CONST GLchan (*)[4]) primary_rgba, texels,
1399 span->array->rgba );
1400 }
1401 }
1402 }
1403 }