source: branches/swt/src/opengl/mesa/texgen_tmp.h

Last change on this file was 2938, checked in by sandervl, 26 years ago

created
File size: 12.9 KB
Line 
1/* $Id: texgen_tmp.h,v 1.1 2000-02-29 00:48:39 sandervl Exp $ */
2
3/*
4 * Mesa 3-D graphics library
5 * Version: 3.1
6 *
7 * Copyright (C) 1999 Brian Paul All Rights Reserved.
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 */
26
27/*
28 * New (3.1) transformation code written by Keith Whitwell.
29 */
30
31
32/* Need to transform the eye plane equations into object space, and
33 * use ctx->EyeZDir in spheregen.
34 */
35
36#define CULL IDX&1
37
38/*
39 */
40static void TAG(build_m3)(GLfloat f[][3],
41 GLfloat m[],
42 const GLvector3f *normals,
43 const GLvector4f *coord_vec,
44 const GLuint flags[],
45 const GLubyte cullmask[] )
46{
47 GLuint stride = coord_vec->stride;
48 GLfloat *coord = (GLfloat *)coord_vec->start;
49 GLuint count = coord_vec->count;
50
51 const GLfloat *normal = FIRST_NORMAL;
52 GLuint i;
53
54 LOCAL_VARS;
55
56 (void) flags;
57 (void) cullmask;
58
59 /* KW: Had to rearrange this loop to avoid a compiler bug with gcc
60 * 2.7.3.1 at -O3 optimization. Using -fno-strength-reduce
61 * also fixed the bug - is this generally necessary?
62 */
63 for (i=0;i<count;i++,STRIDE_F(coord,stride)) {
64 CHECK {
65 const GLfloat *norm = normal;
66 GLfloat u[3], two_nu, fx, fy, fz;
67 COPY_3V( u, coord );
68 NORMALIZE_3FV( u );
69 two_nu = 2.0F * DOT3(norm,u);
70 fx = f[i][0] = u[0] - norm[0] * two_nu;
71 fy = f[i][1] = u[1] - norm[1] * two_nu;
72 fz = f[i][2] = u[2] - norm[2] * two_nu;
73 m[i] = fx*fx + fy*fy + (fz + 1.0F) * (fz + 1.0F);
74 if (m[i] != 0.0F) {
75 m[i] = 0.5F / (GLfloat) GL_SQRT(m[i]);
76 }
77 }
78 NEXT_NORMAL;
79 }
80}
81
82
83
84static void TAG(build_m2)(GLfloat f[][3],
85 GLfloat m[],
86 const GLvector3f *normals,
87 const GLvector4f *coord_vec,
88 const GLuint flags[],
89 const GLubyte cullmask[] )
90{
91 GLuint stride = coord_vec->stride;
92 GLfloat *coord = coord_vec->start;
93 GLuint count = coord_vec->count;
94
95 GLfloat *normal = FIRST_NORMAL;
96 GLuint i;
97
98 LOCAL_VARS;
99
100 (void) flags;
101 (void) cullmask;
102
103 for (i=0;i<count;i++,STRIDE_F(coord,stride)) {
104 CHECK {
105 GLfloat *norm = normal;
106 GLfloat u[3], two_nu, fx, fy, fz;
107 COPY_2V( u, coord );
108 u[2] = 0;
109 NORMALIZE_3FV( u );
110 two_nu = 2.0F * DOT3(norm,u);
111 fx = f[i][0] = u[0] - norm[0] * two_nu;
112 fy = f[i][1] = u[1] - norm[1] * two_nu;
113 fz = f[i][2] = u[2] - norm[2] * two_nu;
114 m[i] = fx*fx + fy*fy + (fz + 1.0F) * (fz + 1.0F);
115 if (m[i] != 0.0F) {
116 m[i] = 0.5F / (GLfloat) GL_SQRT(m[i]);
117 }
118 }
119 NEXT_NORMAL;
120 }
121}
122
123
124
125static build_m_func TAG(build_m_tab)[5] = {
126 0,
127 0,
128 TAG(build_m2),
129 TAG(build_m3),
130 TAG(build_m3)
131};
132
133
134/* This is unusual in that we respect the stride of the output vector
135 * (f). This allows us to pass in either a texcoord vector4f, or a
136 * temporary vector3f.
137 */
138static void TAG(build_f3)( GLfloat *f,
139 GLuint fstride,
140 const GLvector3f *normals,
141 const GLvector4f *coord_vec,
142 const GLuint flags[],
143 const GLubyte cullmask[] )
144{
145 GLuint stride = coord_vec->stride;
146 GLfloat *coord = coord_vec->start;
147 GLuint count = coord_vec->count;
148
149 GLfloat *normal = FIRST_NORMAL;
150 GLuint i;
151
152 LOCAL_VARS;
153
154 (void) flags;
155 (void) cullmask;
156
157 for (i=0;i<count;i++, STRIDE_F(coord,stride), STRIDE_F(f,fstride), NEXT_NORMAL) {
158 CHECK {
159 GLfloat u[3], two_nu;
160 COPY_3V( u, coord );
161 NORMALIZE_3FV( u );
162 two_nu = 2.0F * DOT3(normal,u);
163 f[0] = u[0] - normal[0] * two_nu;
164 f[1] = u[1] - normal[1] * two_nu;
165 f[2] = u[2] - normal[2] * two_nu;
166 }
167 }
168}
169
170
171static void TAG(build_f2)( GLfloat *f,
172 GLuint fstride,
173 const GLvector3f *normals,
174 const GLvector4f *coord_vec,
175 const GLuint flags[],
176 const GLubyte cullmask[] )
177{
178 GLuint stride = coord_vec->stride;
179 GLfloat *coord = coord_vec->start;
180 GLuint count = coord_vec->count;
181
182 GLfloat *normal = FIRST_NORMAL;
183 GLuint i;
184
185 LOCAL_VARS;
186
187 (void) flags;
188 (void) cullmask;
189
190 for (i=0;i<count;i++,STRIDE_F(coord,stride), STRIDE_F(f,fstride), NEXT_NORMAL) {
191 CHECK {
192 GLfloat u[3], two_nu;
193 COPY_2V( u, coord );
194 u[2] = 0;
195 NORMALIZE_3FV( u );
196 two_nu = 2.0F * DOT3(normal,u);
197 f[0] = u[0] - normal[0] * two_nu;
198 f[1] = u[1] - normal[1] * two_nu;
199 f[2] = u[2] - normal[2] * two_nu;
200 }
201 }
202}
203
204/* Just treat 4-vectors as 3-vectors.
205 */
206static build_f_func TAG(build_f_tab)[5] = {
207 0,
208 0,
209 TAG(build_f2),
210 TAG(build_f3),
211 TAG(build_f3)
212};
213
214
215/* Special case texgen functions.
216 */
217static void TAG(texgen_reflection_map_nv)( struct vertex_buffer *VB,
218 GLuint textureUnit )
219{
220 GLvector4f *in = VB->TexCoordPtr[textureUnit];
221 GLvector4f *out = VB->store.TexCoord[textureUnit];
222 GLubyte *cullmask = VB->CullMask + VB->Start;
223
224 TAG(build_f_tab)[VB->Unprojected->size]( out->start,
225 out->stride,
226 VB->NormalPtr,
227 VB->Unprojected,
228 VB->Flag + VB->Start,
229 cullmask );
230
231 if (!in) in = out;
232
233 if (in != out && in->size == 4) {
234 gl_copy_tab[CULL][0x8](out, in, cullmask);
235 }
236
237 VB->TexCoordPtr[textureUnit] = out;
238 out->size = MAX2(in->size, 3);
239 out->flags |= in->flags | VEC_SIZE_3;
240}
241
242
243
244static void TAG(texgen_normal_map_nv)( struct vertex_buffer *VB,
245 GLuint textureUnit )
246{
247 GLvector4f *in = VB->TexCoordPtr[textureUnit];
248 GLvector4f *out = VB->store.TexCoord[textureUnit];
249 GLvector3f *normals = VB->NormalPtr;
250 GLfloat (*texcoord)[4] = (GLfloat (*)[4])out->start;
251 GLubyte *cullmask = VB->CullMask + VB->Start;
252 GLuint *flags = VB->Flag + VB->Start;
253 GLuint count = VB->Count;
254 GLuint i;
255 const GLfloat *normal = FIRST_NORMAL;
256
257 LOCAL_VARS;
258
259 (void) flags;
260
261
262 for (i=0;i<count;i++, NEXT_NORMAL) {
263 CHECK {
264 texcoord[i][0] = normal[0];
265 texcoord[i][1] = normal[1];
266 texcoord[i][2] = normal[2];
267 }
268 }
269
270 if (!in) in = out;
271
272 if (in != out && in->size == 4) {
273 gl_copy_tab[CULL][0x8](out, in, cullmask);
274 }
275
276 VB->TexCoordPtr[textureUnit] = out;
277 out->size = MAX2(in->size, 3);
278 out->flags |= in->flags | VEC_SIZE_3;
279}
280
281
282static void TAG(texgen_sphere_map)( struct vertex_buffer *VB,
283 GLuint textureUnit )
284{
285 GLvector4f *in = VB->TexCoordPtr[textureUnit];
286 GLvector4f *out = VB->store.TexCoord[textureUnit];
287 GLfloat (*texcoord)[4] = (GLfloat (*)[4]) out->start;
288 GLubyte *cullmask = VB->CullMask + VB->Start;
289 GLuint count = VB->Count;
290 GLuint i;
291 GLfloat (*f)[3], *m;
292
293 if (!VB->tmp_f)
294 VB->tmp_f = (GLfloat (*)[3])malloc(VB->Size * sizeof(GLfloat) * 3);
295
296 if (!VB->tmp_m)
297 VB->tmp_m = (GLfloat *)malloc(VB->Size * sizeof(GLfloat));
298
299 f = VB->tmp_f;
300 m = VB->tmp_m;
301
302 (TAG(build_m_tab)[VB->Unprojected->size])( f, m,
303 VB->NormalPtr,
304 VB->Unprojected,
305 VB->Flag + VB->Start,
306 cullmask );
307
308 for (i=0;i<count;i++) {
309 CHECK {
310 texcoord[i][0] = f[i][0] * m[i] + 0.5F;
311 texcoord[i][1] = f[i][1] * m[i] + 0.5F;
312 }
313 }
314
315
316 if (!in) in = out;
317
318 if (in != out) {
319 struct gl_texture_unit *texUnit = &VB->ctx->Texture.Unit[textureUnit];
320 GLuint copy = (all_bits[in->size] & ~texUnit->TexGenEnabled);
321 if (copy)
322 gl_copy_tab[CULL][copy](out, in, cullmask);
323 }
324
325 VB->TexCoordPtr[textureUnit] = out;
326 out->size = MAX2(in->size,2);
327 out->flags |= in->flags | VEC_SIZE_2;
328}
329
330
331
332static void TAG(texgen)( struct vertex_buffer *VB, GLuint textureUnit )
333{
334 GLcontext *ctx = VB->ctx;
335 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[textureUnit];
336 const GLvector4f *obj = VB->ObjPtr;
337 const GLvector4f *eye = VB->EyePtr;
338 const GLvector3f *normals = VB->NormalPtr;
339 const GLubyte *cullmask = VB->CullMask + VB->Start;
340 const GLuint *flags = VB->Flag + VB->Start;
341
342 GLvector4f *in = VB->TexCoordPtr[textureUnit];
343 GLvector4f *out = VB->store.TexCoord[textureUnit];
344 GLfloat (*texcoord)[4] = (GLfloat (*)[4])out->start;
345 GLfloat *indata;
346 GLuint instride;
347 GLuint count = VB->Count;
348 GLfloat (*f)[3], *m;
349
350 LOCAL_VARS;
351
352 if (!VB->tmp_f)
353 VB->tmp_f = (GLfloat (*)[3])malloc(VB->Size * sizeof(GLfloat) * 3);
354
355 if (!VB->tmp_m)
356 VB->tmp_m = (GLfloat *)malloc(VB->Size * sizeof(GLfloat));
357
358 f = VB->tmp_f;
359 m = VB->tmp_m;
360
361 if (!in) in = out;
362 instride = in->stride;
363
364
365
366 if (texUnit->GenFlags & TEXGEN_NEED_M) {
367 TAG(build_m_tab)[in->size]( f, m, normals, eye, flags, cullmask );
368 } else if (texUnit->GenFlags & TEXGEN_NEED_F) {
369 TAG(build_f_tab)[in->size]( (GLfloat *)f, 3, normals, eye,
370 flags, cullmask );
371 }
372
373 if (in != out) {
374 GLuint copy = (all_bits[in->size] & ~texUnit->TexGenEnabled);
375 if (copy)
376 gl_copy_tab[CULL][copy](out, in, cullmask);
377 }
378
379 if (texUnit->Holes)
380 {
381 GLubyte holes = (GLubyte) (texUnit->Holes & ~all_bits[in->size]);
382 if (holes) {
383 if (holes & VEC_DIRTY_2) gl_vector4f_clean_elem(out, count, 2);
384 if (holes & VEC_DIRTY_1) gl_vector4f_clean_elem(out, count, 1);
385 if (holes & VEC_DIRTY_0) gl_vector4f_clean_elem(out, count, 0);
386 }
387 }
388
389 VB->TexCoordPtr[textureUnit] = out;
390 out->size = MAX2(in->size, texUnit->TexgenSize);
391 out->flags |= in->flags | texUnit->TexGenEnabled;
392
393 if (texUnit->TexGenEnabled & S_BIT) {
394 GLuint i;
395 switch (texUnit->GenModeS) {
396 case GL_OBJECT_LINEAR:
397 (gl_dotprod_tab[CULL][obj->size])(out, 0, obj,
398 texUnit->ObjectPlaneS, cullmask);
399 break;
400 case GL_EYE_LINEAR:
401 (gl_dotprod_tab[CULL][eye->size])(out, 0, eye,
402 texUnit->EyePlaneS, cullmask);
403 break;
404 case GL_SPHERE_MAP:
405 for (indata=in->start,i=0 ; i<count ; i++, STRIDE_F(indata,instride) )
406 CHECK texcoord[i][0] = indata[0] * m[i] + 0.5F;
407 break;
408 case GL_REFLECTION_MAP_NV:
409 for (i=0;i<count;i++)
410 CHECK texcoord[i][0] = f[i][0];
411 break;
412 case GL_NORMAL_MAP_NV: {
413
414 const GLfloat *normal = FIRST_NORMAL;
415 for (i=0;i<count;i++, NEXT_NORMAL) {
416 CHECK texcoord[i][0] = normal[0];
417 }
418 break;
419 }
420 default:
421 gl_problem(ctx, "Bad S texgen");
422 }
423 }
424
425 if (texUnit->TexGenEnabled & T_BIT) {
426 GLuint i;
427 switch (texUnit->GenModeT) {
428 case GL_OBJECT_LINEAR:
429 (gl_dotprod_tab[CULL][obj->size])(out, 1, obj,
430 texUnit->ObjectPlaneT, cullmask);
431 break;
432 case GL_EYE_LINEAR:
433 (gl_dotprod_tab[CULL][eye->size])(out, 1, eye,
434 texUnit->EyePlaneT, cullmask);
435 break;
436 case GL_SPHERE_MAP:
437 for (indata=in->start,i=0; i<count ;i++,STRIDE_F(indata,instride))
438 CHECK texcoord[i][1] = indata[1] * m[i] + 0.5F;
439 break;
440 case GL_REFLECTION_MAP_NV:
441 for (i=0;i<count;i++)
442 CHECK texcoord[i][0] = f[i][0];
443 break;
444 case GL_NORMAL_MAP_NV: {
445 const GLfloat *normal = FIRST_NORMAL;
446 for (i=0;i<count;i++, NEXT_NORMAL) {
447 CHECK texcoord[i][1] = normal[1];
448 }
449 break;
450 }
451 default:
452 gl_problem(ctx, "Bad T texgen");
453 }
454 }
455
456 if (texUnit->TexGenEnabled & R_BIT) {
457 GLuint i;
458 switch (texUnit->GenModeR) {
459 case GL_OBJECT_LINEAR:
460 (gl_dotprod_tab[CULL][obj->size])(out, 2, obj,
461 texUnit->ObjectPlaneR, cullmask);
462 break;
463 case GL_EYE_LINEAR:
464 (gl_dotprod_tab[CULL][eye->size])(out, 2, eye,
465 texUnit->EyePlaneR, cullmask);
466 break;
467 case GL_REFLECTION_MAP_NV:
468 for (i=0;i<count;i++)
469 CHECK texcoord[i][2] = f[i][2];
470 break;
471 case GL_NORMAL_MAP_NV: {
472 const GLfloat *normal = FIRST_NORMAL;
473 for (i=0;i<count;i++,NEXT_NORMAL) {
474 CHECK texcoord[i][2] = normal[2];
475 }
476 break;
477 }
478 default:
479 gl_problem(ctx, "Bad R texgen");
480 }
481 }
482
483 if (texUnit->TexGenEnabled & Q_BIT) {
484 switch (texUnit->GenModeQ) {
485 case GL_OBJECT_LINEAR:
486 (gl_dotprod_tab[CULL][obj->size])(out, 3, obj,
487 texUnit->ObjectPlaneQ, cullmask);
488 break;
489 case GL_EYE_LINEAR:
490 (gl_dotprod_tab[CULL][eye->size])(out, 3, eye,
491 texUnit->EyePlaneQ, cullmask);
492 break;
493 default:
494 gl_problem(ctx, "Bad Q texgen");
495 }
496 }
497}
498
499static void TAG(init_texgen)( void )
500{
501 texgen_generic_tab[IDX] = TAG(texgen);
502 texgen_reflection_map_nv_tab[IDX] = TAG(texgen_reflection_map_nv);
503 texgen_normal_map_nv_tab[IDX] = TAG(texgen_normal_map_nv);
504 texgen_sphere_map_tab[IDX] = TAG(texgen_sphere_map);
505}
506
507#undef TAG
508#undef IDX
509#undef CULL
510#undef FIRST_NORMAL
511#undef NEXT_NORMAL
512#undef LOCAL_VARS
513#undef CHECK
514
515
Note: See TracBrowser for help on using the repository browser.