36#include <libFreeWRL.h>
38#include "../vrml_parser/Structs.h"
39#include "../vrml_parser/CRoutes.h"
40#include "../main/headers.h"
42#include "../opengl/OpenGL_Utils.h"
43#include "../opengl/Textures.h"
44#include "../opengl/Frustum.h"
45#include "../opengl/Material.h"
46#include "RenderFuncs.h"
47#include "Component_Shape.h"
48#include "LinearAlgebra.h"
57#define RETURN_IF_RENDER_STATE_NOT_US \
58 if (renderstate()->render_light== VF_globalLight) { \
59 if (!node->global) return;\
61 if (node->global) return; \
62 if(renderstate()->render_geom != VF_Geom) return; \
70const GLDOUBLE bias[16] = { 0.5, 0.0, 0.0, 0.0,
77 struct Vector *projector_stack;
81 int currentlyWorkingOn;
83}* ppComponent_TextureProjector;
85void *Component_TextureProjector_constructor(){
90void Component_TextureProjector_init(
struct tComponent_TextureProjector *t){
95 t->prv = Component_TextureProjector_constructor();
97 ppComponent_TextureProjector p = (ppComponent_TextureProjector)t->prv;
99 p->projector_stack = newStack(
usehit);
102 p->currentlyWorkingOn = -1;
104 p->textureInProcess = -1;
108void Component_TextureProjector_clear(
struct tComponent_TextureProjector *t){
112 ppComponent_TextureProjector p = (ppComponent_TextureProjector)t->prv;
119 Stack* depth_buffer_stack;
128void* set_ProjectorRep(
void* _projectorrep)
131 if (!_projectorrep) {
135 projectorrep->itype = 6;
136 projectorrep->size = 1024;
148void projectorTable_clear(){
151 ppComponent_TextureProjector p;
152 ttglobal tg = gglobal();
153 p = (ppComponent_TextureProjector)tg->Component_TextureProjector.prv;
154 clearStack(p->projector_stack);
156void projectorTable_push(
usehit ptuple ){
159 ppComponent_TextureProjector p;
160 ttglobal tg = gglobal();
161 p = (ppComponent_TextureProjector)tg->Component_TextureProjector.prv;
164 stack_push(
usehit,p->projector_stack,ptuple);
167void projectorTable_pop(){
169 ppComponent_TextureProjector p;
170 ttglobal tg = gglobal();
171 p = (ppComponent_TextureProjector)tg->Component_TextureProjector.prv;
172 if(p->projector_stack->n < 1)
173 printf(
"ouch from projectorTable_opo()\n");
174 stack_pop(
usehit,p->projector_stack);
177int projectorTable_count() {
178 ppComponent_TextureProjector p;
179 ttglobal tg = gglobal();
180 p = (ppComponent_TextureProjector)tg->Component_TextureProjector.prv;
181 return p->projector_stack->n;
183usehit* projectorTable_item(
int i) {
184 ppComponent_TextureProjector p;
185 ttglobal tg = gglobal();
186 p = (ppComponent_TextureProjector)tg->Component_TextureProjector.prv;
187 return vector_get_ptr(
usehit, p->projector_stack, i);
189int projectorTable_node_use_count(
struct X3D_Node* node) {
191 for (
int i = 0; i < projectorTable_count(); i++) {
192 if (projectorTable_item(i)->node == node) count++;
197void clear_bound_textures(){
198 for(
int i=0;i<16;i++){
199 glActiveTexture(GL_TEXTURE0 + i);
200 glBindTexture(GL_TEXTURE_2D,0);
204void print_bound_textures(
char *str){
206 printf(
"ActiveTexture boundUnit %s\n",str);
207 for(
int i=0;i<16;i++){
208 glActiveTexture(GL_TEXTURE0 + i);
209 glGetIntegerv(GL_TEXTURE_BINDING_2D, &whichID);
210 printf(
"%12d %12d\n",i,whichID);
216int get_bound_image(
struct X3D_Node *node);
217int getGlTextureNumberFromTextureNode(
struct X3D_Node *textureNode);
218int getTextureSizeFromTextureNode(
struct X3D_Node *textureNode,
int *ixyz);
219int getTextureDescriptors(
struct X3D_Node *textureNode,
int *textures,
int *modes,
int *sources,
int *funcs,
int *width,
int *height,
int *samplr);
220void PRINT_GL_ERROR(GLenum _global_gl_err);
221void sendProjectorInfo()
225 s_shader_capabilities_t *me;
226 ppComponent_TextureProjector p;
227 ttglobal tg = gglobal();
228 p = (ppComponent_TextureProjector)tg->Component_TextureProjector.prv;
230 int projcount = min(projectorTable_count(), MAX_PROJ);
231 if (!projcount)
return;
233 me = getAppearanceProperties()->currentShaderProperties;
234 GLuint myProg = me->myShaderProgram;
253 GLint saveTextureStackTop = tg->RenderFuncs.textureStackTop;
254 PRINT_GL_ERROR_IF_ANY(
"BEGIN resend_textureprojector_matrix");
257 for (
int i = 0; i < 8; i++) {
260 sprintf(line,
"ptms[%d].GenMatCam", i);
261 me->ptmGenMatCam[i] = GET_UNIFORM(myProg, line);
262 sprintf(line,
"ptms[%d].backCull", i);
263 me->ptmbackCull[i] = GET_UNIFORM(myProg, line);
264 sprintf(line,
"ptms[%d].color", i);
265 me->ptmcolor[i] = GET_UNIFORM(myProg, line);
266 sprintf(line,
"ptms[%d].intensity", i);
267 me->ptmintensity[i] = GET_UNIFORM(myProg, line);
268 sprintf(line,
"ptms[%d].shadows", i);
269 me->ptmshadows[i] = GET_UNIFORM(myProg, line);
270 sprintf(line,
"ptms[%d].shadowIntensity", i);
271 me->ptmshadowIntensity[i] = GET_UNIFORM(myProg, line);
272 sprintf(line,
"ptms[%d].depthmap", i);
273 me->ptmdepthmap[i] = GET_UNIFORM(myProg, line);
274 sprintf(line,
"ptms[%d].tcount", i);
275 me->ptmtcount[i] = GET_UNIFORM(myProg, line);
276 sprintf(line,
"ptms[%d].tstart", i);
277 me->ptmtstart[i] = GET_UNIFORM(myProg, line);
278 sprintf(line,
"ptms[%d].type", i);
279 me->ptmtype[i] = GET_UNIFORM(myProg, line);
280 sprintf(line,
"ptms[%d].farDistance", i);
281 me->ptmfarDistance[i] = GET_UNIFORM(myProg, line);
283 for (
int i = 0; i < 16; i++) {
286 sprintf(line,
"tdescs[%d].tindex", i);
287 me->tdtindex[i] = GET_UNIFORM(myProg, line);
288 sprintf(line,
"tdescs[%d].mode", i);
289 me->tdmode[i] = GET_UNIFORM(myProg, line);
290 sprintf(line,
"tdescs[%d].source", i);
291 me->tdsource[i] = GET_UNIFORM(myProg, line);
292 sprintf(line,
"tdescs[%d].func", i);
293 me->tdfunc[i] = GET_UNIFORM(myProg, line);
294 sprintf(line,
"tdescs[%d].samplr", i);
295 me->tdsamplr[i] = GET_UNIFORM(myProg, line);
297 me->ptmCount = GET_UNIFORM(myProg,
"ptmCount");
298 PRINT_GL_ERROR_IF_ANY(
"EARLY resend_textureprojector_matrix");
306 for(
int j=0;j<projcount;j++)
308 float TenLinearGexMatCam0f[16];
311 usehit* uhit = projectorTable_item(j);
321 switch (node->_nodeType) {
322 case NODE_TextureProjector: projType = 0;
break;
323 case NODE_TextureProjectorParallel: projType = 1;
break;
324 case NODE_TextureProjectorPoint: projType = 2;
break;
331 matmultiplyFULL(matfull, uhit->mvm, projrep->matproj);
332 double2float(TenLinearGexMatCam0f, matfull, 16);
333 GLUNIFORMMATRIX4FV(me->ptmGenMatCam[j], 1, GL_FALSE, TenLinearGexMatCam0f);
339 double modelviewinv[16], eye2projector[16], matfull[16], mvm[16];
340 matcopy(mvm, uhit->mvm);
342 matinverse(modelviewinv, mvm);
343 matmultiplyAFFINE(eye2projector, modelviewinv, projrep->matview);
344 matmultiplyFULL(matfull, eye2projector, projrep->matproj);
345 double2float(w2l, matfull, 16);
352 GLUNIFORMMATRIX4FV(me->ptmGenMatCam[j], 1, GL_FALSE, w2l);
360 GLUNIFORM1I(me->ptmbackCull[j],ptm->backCull);
361 GLUNIFORM3FV(me->ptmcolor[j], 1, ptm->color.c);
362 GLUNIFORM1F(me->ptmintensity[j], ptm->intensity);
363 GLUNIFORM1I(me->ptmshadows[j], ptm->shadows);
364 GLUNIFORM1F(me->ptmshadowIntensity[j], ptm->shadowIntensity);
365 GLUNIFORM1I(me->ptmtype[j], projType);
366 GLUNIFORM1F(me->ptmfarDistance[j], ptm->farDistance);
369 struct X3D_NODE * tlist[4];
374 int width[4], height[4], samplr[4];
376 render_node(projrep->texture);
377 PRINT_GL_ERROR_IF_ANY(
"MIDDLE resend_textureprojector_matrix");
379 ntdesc = getTextureDescriptors(projrep->texture,textures, modes,sources, funcs, width, height, samplr);
380 GLUNIFORM1I(me->ptmtcount[j],ntdesc);
381 PRINT_GL_ERROR_IF_ANY(
"M1 resend_textureprojector_matrix");
382 GLUNIFORM1I(me->ptmtstart[j], kdesc);
383 GLenum _global_gl_err = glGetError();
384 while (_global_gl_err != GL_NONE) {
385 PRINT_GL_ERROR(_global_gl_err);
386 printf(
" here: %s (%s:%d)\n",
"resend_textureprojector_matrix", __FILE__, __LINE__);
387 _global_gl_err = glGetError();
390 PRINT_GL_ERROR_IF_ANY(
"M2 resend_textureprojector_matrix");
392 for(
int i=0;i<ntdesc;i++,kdesc++){
395 if (samplr[i] == 1) {
398 printf(
"%s ", stringNodeType(node->_nodeType));
399 glGetTextureParameteriv(textures[i], GL_TEXTURE_TARGET, (GLint*)&target);
401 case GL_TEXTURE_CUBE_MAP: printf(
"CUBE MAP \n");
break;
402 case GL_TEXTURE_2D: printf(
"texture2D\n");
break;
403 case GL_TEXTURE_3D: printf(
"texture3D\n");
break;
404 case GL_TEXTURE_2D_ARRAY: printf(
"GL_TEXTURE_2D_ARRAY\n");
405 default: printf(
"unknown %d \n", target);
break;
408 PRINT_GL_ERROR_IF_ANY(
"TT_start_ bfor bind cube");
410 kunit = share_or_next_material_sampler_index_Cube(textures[i]);
412 PRINT_GL_ERROR_IF_ANY(
"TT_start_ aftr bind cube");
413 glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
414 PRINT_GL_ERROR_IF_ANY(
"TT_start_ aftr seamless");
415 iunit = tunitCube(kunit);
416 glUniform1i(me->textureUnitCube[kunit], iunit);
419 kunit = share_or_next_material_sampler_index_2D(textures[i]);
420 iunit = tunit2D(kunit);
421 glUniform1i(me->textureUnit[kunit], iunit);
424 GLUNIFORM1I(me->tdtindex[kdesc],kunit);
425 PRINT_GL_ERROR_IF_ANY(
"M4 resend_textureprojector_matrix");
427 GLUNIFORM1I(me->tdmode[kdesc],modes[i]);
428 GLUNIFORM1I(me->tdsource[kdesc],sources[i]);
429 GLUNIFORM1I(me->tdfunc[kdesc],funcs[i]);
430 GLUNIFORM1I(me->tdsamplr[kdesc], samplr[i]);
431 PRINT_GL_ERROR_IF_ANY(
"M6 resend_textureprojector_matrix");
434 PRINT_GL_ERROR_IF_ANY(
"LATE resend_textureprojector_matrix");
437 struct X3D_Node* texnode = (
struct X3D_Node*)vector_get(
struct X3D_Node*, projrep->depth_buffer_stack, uhit->ivalue);
439 textureTableIndexStruct_s* tti;
440 if (texnode->_nodeType == NODE_GeneratedCubeMapTexture) {
442 tti = getTableIndex(tex->__textureTableIndex);
443 PRINT_GL_ERROR_IF_ANY(
"sendLightInfo before bind_or_share");
447 glGetTextureParameteriv(tti->OpenGLTexture, GL_TEXTURE_TARGET, (GLint*)&target);
449 case GL_TEXTURE_CUBE_MAP: printf(
"CUBE MAP \n");
break;
450 case GL_TEXTURE_2D: printf(
"texture2D\n");
break;
451 case GL_TEXTURE_3D: printf(
"texture3D\n");
break;
452 case GL_TEXTURE_2D_ARRAY: printf(
"GL_TEXTURE_2D_ARRAY\n");
453 default: printf(
"unknown %d \n", target);
break;
457 itexunit = share_or_next_material_sampler_index_Cube(tti->OpenGLTexture);
458 iunit = tunitCube(itexunit);
459 PRINT_GL_ERROR_IF_ANY(
"sendProjectorInfo after bind_or_share");
460 glUniform1i(me->textureUnitCube[iunit], itexunit);
464 tti = getTableIndex(tex->__textureTableIndex);
465 PRINT_GL_ERROR_IF_ANY(
"sendProjectorInfo before bind_or_share");
466 itexunit = share_or_next_material_sampler_index_2D(tti->OpenGLTexture);
467 iunit = tunit2D(itexunit);
468 PRINT_GL_ERROR_IF_ANY(
"sendProjectorInfo after bind_or_share");
469 glUniform1i(me->textureUnit[iunit], itexunit);
471 glUniform1i(me->ptmdepthmap[j], iunit);
497 tg->RenderFuncs.textureStackTop = saveTextureStackTop;
500 GLUNIFORM1I(me->ptmCount,pcount);
501 PRINT_GL_ERROR_IF_ANY(
"END resend_textureprojector_matrix");
504void generate_shadowmap_cube(
usehit uhit,
int index);
505void generate_shadowmap_2D(
usehit uhit,
int index);
508struct X3D_Node* make_depth_buffer_cube(
int width,
int height);
509struct X3D_Node* make_depth_buffer(
int width,
int height);
511int make_or_get_depth_buffer_projector(
int index,
struct X3D_Node* node) {
512 node->_intern = set_ProjectorRep(node->_intern);
514 if (!projrep->depth_buffer_stack) {
515 projrep->depth_buffer_stack = newStack(
struct X3D_Node*);
517 if (index > -1 && index < vectorSize(projrep->depth_buffer_stack))
return index;
518 struct X3D_Node* depth_buffer_texture = NULL;
519 if (node->_nodeType == NODE_TextureProjectorPoint)
520 depth_buffer_texture = make_depth_buffer_cube(projrep->size, projrep->size);
522 depth_buffer_texture = make_depth_buffer(projrep->size, projrep->size);
523 stack_push(
struct X3D_Node*, projrep->depth_buffer_stack, X3D_NODE(depth_buffer_texture));
524 return vectorSize(projrep->depth_buffer_stack) - 1;
528void projLookAt(GLDOUBLE eyex, GLDOUBLE eyey, GLDOUBLE eyez,
529 GLDOUBLE centerx, GLDOUBLE centery, GLDOUBLE centerz,
530 GLDOUBLE upx, GLDOUBLE upy, GLDOUBLE upz, GLDOUBLE *matrix);
531void projPerspective(GLDOUBLE fovy, GLDOUBLE aspect, GLDOUBLE zNear, GLDOUBLE zFar, GLDOUBLE *matrix);
532void printmatrix2(GLDOUBLE* mat,
char* description );
534void set_debug_quad_near_farplane(
float nearplane,
float farplane);
538 node->_intern = set_ProjectorRep(node->_intern);
540 float dir[3], up[3], cross1[3], cross2[3];
541 veccopy3f(node->_loc.c, node->location.c);
542 veccopy3f(dir, node->direction.c);
543 veccopy3f(up, node->upVector.c);
544 vecnormalize3f(dir, dir);
545 vecnormalize3f(up, up);
546 veccross3f(cross1, dir, up);
547 vecnormalize3f(cross1, cross1);
548 veccross3f(cross2, cross1, dir);
549 vecnormalize3f(cross2, cross2);
550 veccopy3f(node->_dir.c, dir);
551 node->_dir.c[3] = 0.0f;
552 veccopy3f(node->_upVec.c, up);
553 node->_upVec.c[3] = 0.0f;
557 set_debug_quad_near_farplane(node->nearDistance, node->farDistance);
565 float degree = node->fieldOfView* 180.0/3.141596;
566 GLDOUBLE cViewMat[16];
567 GLDOUBLE invcViewMat[16];
568 GLDOUBLE ViewMat[16];
569 GLDOUBLE ProjMat[16];
571 ppComponent_TextureProjector p;
572 ttglobal tg = gglobal();
573 p = (ppComponent_TextureProjector)tg->Component_TextureProjector.prv;
575 RETURN_IF_RENDER_STATE_NOT_US
581 GLDOUBLE modelview[16], modelviewnode[16], eye2projector[16], modelviewinv[16];
585 if(node->global) tg->Component_TextureProjector.globalProjector = TRUE;
589 FW_GL_MATRIX_MODE(GL_MODELVIEW);
590 FW_GL_GETDOUBLEV(GL_MODELVIEW_MATRIX, modelview);
593 double loc[3],dir[3],up[3],eye[3];
594 float2double(loc,node->_loc.c,3);
595 float2double(dir,node->_dir.c,3);
596 float2double(up,node->_upVec.c,3);
597 vecdifd(eye,loc,dir);
598 projLookAt(eye[0],eye[1],eye[2], loc[0],loc[1],loc[2], up[0],up[1],up[2],ViewMat);
600 matcopy(projrep->matview, ViewMat);
602 matinverse(modelviewinv,modelview);
604 matmultiplyAFFINE(eye2projector,modelviewinv,ViewMat);
607 projPerspective((GLDOUBLE)degree,
608 (GLDOUBLE)node->aspectRatio,
609 (GLDOUBLE)node->nearDistance,(GLDOUBLE)node->farDistance,
611 matcopy(projrep->matproj, ProjMat);
624 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node *, node->texture,tmpN);
628 if(getTextureSizeFromTextureNode(tmpN, ixyz)){
629 if(ixyz[0] > 0 && ixyz[1] > 0){
630 aspectRatio = (float)ixyz[0]/(
float)ixyz[1];
631 if(!APPROX(node->aspectRatio,aspectRatio)){
632 node->aspectRatio = aspectRatio;
646 ptuple.node = X3D_NODE(node);
647 ptuple.userdata = parent;
649 matcopy(ptuple.mvm, eye2projector);
651 matcopy(ptuple.mvm, modelview);
654 texture = tg->RenderFuncs.boundTextureStack[tg->RenderFuncs.textureStackTop];
655 projrep->itexture = texture;
656 projrep->texture = tmpN;
659 int nuse = projectorTable_node_use_count(X3D_NODE(node));
660 ptuple.ivalue = make_or_get_depth_buffer_projector(nuse, X3D_NODE(node));
661 generate_shadowmap_2D(ptuple, 0);
663 projectorTable_push(ptuple);
671 render_TextureProjector0(NULL, node);
676 RETURN_IF_RENDER_STATE_NOT_US
679 projectorTable_pop();
685 if (!renderstate()->render_light)
return;
687 render_TextureProjector(node);
702 RETURN_IF_RENDER_STATE_NOT_US
705 projectorTable_pop();
710 node->_intern = set_ProjectorRep(node->_intern);
713 float dir[3], up[3], cross1[3],cross2[3];
714 veccopy3f(node->_loc.c,node->location.c);
715 veccopy3f(dir,node->direction.c);
716 veccopy3f(up,node->upVector.c);
717 vecnormalize3f(dir,dir);
718 vecnormalize3f(up,up);
719 veccross3f(cross1,dir,up);
720 vecnormalize3f(cross1,cross1);
721 veccross3f(cross2,cross1,dir);
722 vecnormalize3f(cross2,cross2);
723 veccopy3f(node->_dir.c,dir);
724 node->_dir.c[3] = 0.0f;
725 veccopy3f(node->_upVec.c,up);
726 node->_upVec.c[3] = 0.0f;
732void projOrtho (GLDOUBLE l, GLDOUBLE r, GLDOUBLE b, GLDOUBLE t,
733 GLDOUBLE n, GLDOUBLE f,GLDOUBLE *matrix);
734void mesa_Ortho(GLDOUBLE left, GLDOUBLE right, GLDOUBLE bottom, GLDOUBLE top, GLDOUBLE nearZ, GLDOUBLE farZ, GLDOUBLE *m);
739 GLDOUBLE cViewMat[16];
740 GLDOUBLE invcViewMat[16];
741 GLDOUBLE ViewMat[16];
742 GLDOUBLE orthoMat[16];
744 ppComponent_TextureProjector p;
745 ttglobal tg = gglobal();
746 p = (ppComponent_TextureProjector)tg->Component_TextureProjector.prv;
748 RETURN_IF_RENDER_STATE_NOT_US
753 GLDOUBLE TenLinearGexMatCam0[16];
754 GLDOUBLE modelview[16], modelviewnode[16], eye2projector[16], modelviewinv[16];
758 if(node->global) tg->Component_TextureProjector.globalProjector = TRUE;
762 FW_GL_MATRIX_MODE(GL_MODELVIEW);
763 FW_GL_GETDOUBLEV(GL_MODELVIEW_MATRIX, modelview);
765 double loc[3],dir[3],up[3],eye[3];
766 float2double(loc,node->_loc.c,3);
767 float2double(dir,node->_dir.c,3);
768 float2double(up,node->_upVec.c,3);
769 vecdifd(eye,loc,dir);
770 projLookAt(eye[0],eye[1],eye[2], loc[0],loc[1],loc[2], up[0],up[1],up[2],ViewMat);
772 matcopy(projrep->matview, ViewMat);
774 matinverse(modelviewinv,modelview);
776 matmultiplyAFFINE(eye2projector,modelviewinv,ViewMat);
782 fov = node->fieldOfView.c;
786 mesa_Ortho((GLDOUBLE)fov[0], (GLDOUBLE)fov[2], (GLDOUBLE)fov[1], (GLDOUBLE)fov[3],
787 (GLDOUBLE)node->nearDistance, (GLDOUBLE)node->farDistance, orthoMat);
788 matcopy(projrep->matproj, orthoMat);
789 printmatrix2(orthoMat,
"orthoMat");
793 float size[3], center[3], * ll, * ur, zz[2];
794 double mate[16], dcenter[3], dsize[3], matproj[16], matinv[16];
797 zz[0] = node->nearDistance; zz[1] = node->farDistance;
799 vecadd2f(center, ll, ur);
800 center[2] = zz[0] + zz[1];
801 vecscale3f(center, center, .5f);
802 vecdif2f(size, ur, ll);
803 size[2] = zz[1] - zz[0];
804 mattranslate4d(mate, float2double(dcenter, center, 3));
805 matscale4d(mate, float2double(dsize, size, 3));
806 matinverse(matinv, mate);
807 mesa_Ortho(-.5, .5, -.5, .5, -.5, .5, matproj);
808 matmultiplyFULL(projrep->matproj, matproj, matinv);
816 float aspectRatio, denom;
817 denom = fov[3]-fov[1];
819 aspectRatio = (fov[2]-fov[0])/denom;
820 if(!APPROX(node->aspectRatio,aspectRatio)){
821 node->aspectRatio = aspectRatio;
831 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node *, node->texture,tmpN);
836 ptuple.node = X3D_NODE(node);
837 ptuple.userdata = parent;
839 matcopy(ptuple.mvm, eye2projector);
841 matcopy(ptuple.mvm, modelview);
844 texture = tg->RenderFuncs.boundTextureStack[tg->RenderFuncs.textureStackTop];
845 projrep->itexture = texture;
846 projrep->texture = tmpN;
849 int nuse = projectorTable_node_use_count(X3D_NODE(node));
850 ptuple.ivalue = make_or_get_depth_buffer_projector(nuse, X3D_NODE(node));
851 generate_shadowmap_2D(ptuple, 0);
853 projectorTable_push(ptuple);
860 render_TextureProjectorParallel0(NULL, node);
865 if (!renderstate()->render_light)
return;
867 render_TextureProjectorParallel(node);
873 node->_intern = set_ProjectorRep(node->_intern);
875 float dir[3], up[3], cross1[3], cross2[3];
876 veccopy3f(node->_loc.c, node->location.c);
877 veccopy3f(dir, node->direction.c);
878 veccopy3f(up, node->upVector.c);
879 vecnormalize3f(dir, dir);
880 vecnormalize3f(up, up);
881 veccross3f(cross1, dir, up);
882 vecnormalize3f(cross1, cross1);
883 veccross3f(cross2, cross1, dir);
884 vecnormalize3f(cross2, cross2);
885 veccopy3f(node->_dir.c, dir);
886 node->_dir.c[3] = 0.0f;
887 veccopy3f(node->_upVec.c, up);
888 node->_upVec.c[3] = 0.0f;
893double* matrix_lookAtfd(
float* eye3,
float* center3,
float* up3,
double* matrix);
899 GLDOUBLE cViewMat[16];
900 GLDOUBLE invcViewMat[16];
901 GLDOUBLE ViewMat[16];
902 GLDOUBLE ProjMat[16];
904 ppComponent_TextureProjector p;
905 ttglobal tg = gglobal();
906 p = (ppComponent_TextureProjector)tg->Component_TextureProjector.prv;
908 RETURN_IF_RENDER_STATE_NOT_US
914 GLDOUBLE modelview[16], modelviewnode[16], eye2projector[16], modelviewinv[16];
918 if (node->global) tg->Component_TextureProjector.globalProjector = TRUE;
922 FW_GL_MATRIX_MODE(GL_MODELVIEW);
923 FW_GL_GETDOUBLEV(GL_MODELVIEW_MATRIX, modelview);
926 double loc[3], dir[3], up[3], eye[3];
927 float2double(loc, node->_loc.c, 3);
928 float2double(dir, node->_dir.c, 3);
929 float2double(up, node->_upVec.c, 3);
930 vecdifd(eye, loc, dir);
931 projLookAt(eye[0], eye[1], eye[2], loc[0], loc[1], loc[2], up[0], up[1], up[2], ViewMat);
932 matcopy(projrep->matview, ViewMat);
936 vecadd3f(center, node->location.c, node->direction.c);
937 matrix_lookAtfd(node->location.c, center, node->upVector.c, projrep->matview);
940 matinverse(modelviewinv, modelview);
942 matmultiplyAFFINE(eye2projector, modelviewinv, ViewMat);
949 matidentity4d(ProjMat);
950 matcopy(projrep->matproj, ProjMat);
983 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node*, node->texture, tmpN);
990 ptuple.node = X3D_NODE(node);
991 ptuple.userdata = parent;
993 matcopy(ptuple.mvm, eye2projector);
995 matcopy(ptuple.mvm, modelview);
998 texture = tg->RenderFuncs.boundTextureStack[tg->RenderFuncs.textureStackTop];
999 projrep->itexture = texture;
1000 projrep->texture = tmpN;
1002 if (node->shadows) {
1003 int nuse = projectorTable_node_use_count(X3D_NODE(node));
1004 ptuple.ivalue = make_or_get_depth_buffer_projector(nuse, X3D_NODE(node));
1005 generate_shadowmap_cube(ptuple, 0);
1007 projectorTable_push(ptuple);
1013 render_TextureProjectorPoint0(NULL, node);
1018 RETURN_IF_RENDER_STATE_NOT_US
1021 projectorTable_pop();
1027 if (!renderstate()->render_light)
return;
1029 render_TextureProjectorPoint(node);
1081void sib_prep_TextureProjector(
struct X3D_Node* parent,
struct X3D_Node* sibAffector) {
1083 if (renderstate()->render_light != VF_globalLight && !renderstate()->render_depth && renderstate()->render_geom) {
1084 if (projector->global == FALSE && projector->on == TRUE) {
1086 shaderflags = getShaderFlags();
1087 shaderflags.base |= HAVE_PROJECTIVETEXTURE;
1088 pushShaderFlags(shaderflags);
1090 switch (projector->_nodeType) {
1091 case NODE_TextureProjector:
1094 case NODE_TextureProjectorParallel:
1097 case NODE_TextureProjectorPoint:
1106void sib_fin_TextureProjector(
struct X3D_Node* parent,
struct X3D_Node* sibAffector) {
1107 if (renderstate()->render_light != VF_globalLight && !renderstate()->render_depth && renderstate()->render_geom) {
1109 if (projector->global == FALSE && projector->on == TRUE) {
1110 projectorTable_pop();