30#include <system_threads.h>
35#include <libFreeWRL.h>
40#include "../vrml_parser/Structs.h"
41#include "../main/headers.h"
42#include "../main/ProdCon.h"
43#include "../vrml_parser/CParseGeneral.h"
44#include "../scenegraph/Vector.h"
45#include "../vrml_parser/CFieldDecls.h"
46#include "../vrml_parser/CParseParser.h"
47#include "../vrml_parser/CParseLexer.h"
48#include "../vrml_parser/CParse.h"
49#include "../vrml_parser/CRoutes.h"
50#include "../scenegraph/quaternion.h"
51#include "../scenegraph/Viewer.h"
52#include "../scenegraph/LinearAlgebra.h"
53#include "../scenegraph/Component_KeyDevice.h"
54#include "../input/EAIHeaders.h"
55#include "../input/InputFunctions.h"
57#include "../opengl/Material.h"
58#include "../scenegraph/Component_Core.h"
59#include "../scenegraph/Component_Networking.h"
60#include "LoadTextures.h"
61#include "OpenGL_Utils.h"
63#include "../scenegraph/RenderFuncs.h"
64#include "../scenegraph/Component_Shape.h"
67#include "../x3d_parser/Bindable.h"
69#include "../ui/common.h"
71void kill_rendering(
void);
75static void mesa_Frustum(GLDOUBLE left, GLDOUBLE right, GLDOUBLE bottom, GLDOUBLE top, GLDOUBLE nearZ, GLDOUBLE farZ, GLDOUBLE *m);
78#undef DEBUG_FW_LOADMAT
79#ifdef DEBUG_FW_LOADMAT
80static void fw_glLoadMatrixd(GLDOUBLE *val,
char *,
int);
81#define FW_GL_LOADMATRIX(aaa) fw_glLoadMatrixd(aaa,__FILE__,__LINE__);
83static void fw_glLoadMatrixd(GLDOUBLE *val);
84#define FW_GL_LOADMATRIX(aaa) fw_glLoadMatrixd(aaa);
91 s_shader_capabilities_t *myCapabilities;
97void mesa_Ortho(GLDOUBLE left, GLDOUBLE right, GLDOUBLE bottom, GLDOUBLE top, GLDOUBLE nearZ, GLDOUBLE farZ, GLDOUBLE *m);
98static void getShaderCommonInterfaces (s_shader_capabilities_t *me);
108#define LOCK_MEMORYTABLE pthread_mutex_lock(&p->memtablelock);
109#define UNLOCK_MEMORYTABLE pthread_mutex_unlock(&p->memtablelock);
116#define MAX_LARGE_MATRIX_STACK 256
117#define MAX_SMALL_MATRIX_STACK 9
118#define MATRIX_SIZE 16
119typedef GLDOUBLE MATRIX4[MATRIX_SIZE];
126 struct Vector *linearNodeTable;
128 int potentialHoleCount;
130 float cc_red, cc_green, cc_blue, cc_alpha;
131 pthread_mutex_t memtablelock;
132 MATRIX4 FW_ModelView[MAX_LARGE_MATRIX_STACK];
133 MATRIX4 FW_ProjectionView[MAX_SMALL_MATRIX_STACK];
134 MATRIX4 FW_TextureView[MAX_SMALL_MATRIX_STACK];
137 int projectionviewTOS;
142 GLDOUBLE *currentMatrix;
147 struct Vector *myShaderTable;
148 int userDefinedShaderCount;
149 char *userDefinedFragmentShader[MAX_USER_DEFINED_SHADERS];
150 char *userDefinedVertexShader[MAX_USER_DEFINED_SHADERS];
156void *OpenGL_Utils_constructor(){
161void OpenGL_Utils_init(
struct tOpenGL_Utils *t)
165 t->displayDepth = 24;
168 t->cc_changed = FALSE;
171 t->prv = OpenGL_Utils_constructor();
173 ppOpenGL_Utils p = (ppOpenGL_Utils)t->prv;
174 p->linearNodeTable = NULL;
175 p->potentialHoleCount = 0;
181 pthread_mutex_init(&(p->memtablelock), NULL);
185 p->projectionviewTOS = 0;
186 p->textureviewTOS = 0;
189 p->whichMode = GL_MODELVIEW;
190 p->currentMatrix = p->FW_ModelView[0];
193 loadIdentityMatrix(p->FW_ModelView[0]);
194 loadIdentityMatrix(p->FW_ProjectionView[0]);
195 loadIdentityMatrix(p->FW_TextureView[0]);
203 p->userDefinedShaderCount = 0;
210void OpenGL_Utils_clear(
struct tOpenGL_Utils *t)
215 ppOpenGL_Utils p = (ppOpenGL_Utils)t->prv;
216 deleteVector(
struct X3D_Node*,p->linearNodeTable);
217 if(p->myShaderTable){
219 for(i=0;i<vectorSize(p->myShaderTable);i++){
221 FREE_IF_NZ(entry->myCapabilities);
229GLEWContext * glewGetContext()
231 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
236GLDOUBLE *getPickrayMatrix(
int index)
240 ttglobal tg = gglobal();
241 bstack = getActiveBindableStacks(tg);
242 return bstack->pickraymatrix[index];
244void setPickrayMatrix(
int index, GLDOUBLE *mat)
248 ttglobal tg = gglobal();
249 bstack = getActiveBindableStacks(tg);
250 memcpy(bstack->pickraymatrix[index],mat,16*
sizeof(GLDOUBLE));
254void kill_userDefinedShaders() {
257 ttglobal tg = gglobal();
258 p = (ppOpenGL_Utils)tg->OpenGL_Utils.prv;
261 p->userDefinedShaderCount = 0;
265 for (i=0; i<MAX_USER_DEFINED_SHADERS; i++) {
268 FREE_IF_NZ (p->userDefinedFragmentShader[i]);
269 FREE_IF_NZ (p->userDefinedVertexShader[i]);
272 for (i=0; i <vectorSize(p->myShaderTable); i++) {
274 FREE_IF_NZ(me->myCapabilities);
282 p->myShaderTable->n = 0;
287int getNextFreeUserDefinedShaderSlot() {
290 ttglobal tg = gglobal();
291 p = (ppOpenGL_Utils)tg->OpenGL_Utils.prv;
293 p->userDefinedShaderCount++;
294 if (p->userDefinedShaderCount == MAX_USER_DEFINED_SHADERS)
return -1;
296 rv = p->userDefinedShaderCount;
302void sendShaderTextToEngine(
int ste,
int parts,
char ** vertSource,
char ** fragSource) {
308 ttglobal tg = gglobal();
309 p = (ppOpenGL_Utils)tg->OpenGL_Utils.prv;
312 for (i=0; i<parts; i++) {
314 if (vertSource[i] != NULL) vs=vertSource[i];
315 if (fragSource[i] != NULL) fs=fragSource[i];
319 p->userDefinedFragmentShader[ste] = fs;
320 p->userDefinedVertexShader[ste] = vs;
324#if defined (_ANDROID)
338void fwl_decomposeShape(
struct X3D_Shape * node,
347 struct X3D_Node * geom = node->geometry;
350 *fpptr = NULL; *lpptr = NULL; *matptr = NULL; *texptr = NULL;
351 *texttptr = NULL; *geomptr = NULL;
353 POSSIBLE_PROTO_EXPANSION(
struct X3D_Appearance *,X3D_NODE(app),app);
354 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node*,geom,geom);
365 POSSIBLE_PROTO_EXPANSION(
struct X3D_Material *,X3D_NODE(mat),*matptr);
371 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node *,geom,*geomptr);
380int fwl_android_get_valid_shapeNodes(
struct Vector **shapeNodes) {
384 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
389 if (*shapeNodes == NULL) {
390 *shapeNodes = newVector (
struct X3D_Shape *, 16);
394 if (p==NULL)
return 0;
395 if (p->linearNodeTable==NULL)
return 0;
402 for (tc=0; tc<vectorSize(p->linearNodeTable); tc++){
403 struct X3D_Node *node = vector_get(
struct X3D_Node *,p->linearNodeTable, tc);
408 POSSIBLE_PROTO_EXPANSION (
struct X3D_Node *,node,node);
411 if ((node->_nodeType == NODE_Shape) && (node->referenceCount>0)) {
412 struct X3D_Node *geom = X3D_SHAPE(node)->geometry;
416 POSSIBLE_PROTO_EXPANSION (
struct X3D_Node *, geom, geom);
418 if ((geom->_nodeType != NODE_IndexedLineSet) &&
419 (geom->_nodeType != NODE_LineSet) &&
420 (geom->_nodeType != NODE_PointSet)) {
423 vector_pushBack(
struct X3D_Node *,me, node);
456 return vectorSize(me);
463void fwl_android_zero_shapeNodeTable(
struct Vector **shapeNodes) {
464 if (*shapeNodes == NULL) {
465 *shapeNodes = newVector (
struct X3D_Shape *, 16);
468 vectorSize(*shapeNodes) = 0;
478int fwl_get_FillPropStatus(
struct Vector **shapeNodes,
int whichEntry) {
491 if (vectorSize(*shapeNodes) == 0 ) {
492 if (fwl_android_get_valid_shapeNodes(shapeNodes) == 0)
return FALSE;
497 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
499 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
503 return (fp->_enabled);
508void fwl_set_FillPropStatus (
struct Vector **shapeNodes,
int whichEntry,
int yesNo,
float fillScale) {
519 if (vectorSize(*shapeNodes) == 0 ) {
520 if (fwl_android_get_valid_shapeNodes(shapeNodes) == 0)
return;
525 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
528 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
534 if (X3D_SHAPE(node)->appearance == NULL) {
536 ap = createNewX3DNode(NODE_Appearance);
537 AddRemoveSFNodeFieldChild(node,
538 offsetPointer_deref(
struct X3D_Node **,node,offsetof (
struct X3D_Shape, appearance)),
539 X3D_NODE(ap),0,__FILE__,__LINE__);
541 mat = createNewX3DNode(NODE_Material);
542 AddRemoveSFNodeFieldChild(X3D_NODE(ap),
544 X3D_NODE(mat),0,__FILE__,__LINE__);
548 ap = X3D_APPEARANCE(X3D_SHAPE(node)->appearance);
553 if (ap->fillProperties == NULL) {
555 fp = X3D_FILLPROPERTIES(createNewX3DNode(NODE_FillProperties));
556 AddRemoveSFNodeFieldChild(X3D_NODE(ap),
558 X3D_NODE(fp),0,__FILE__,__LINE__);
561 fp = X3D_FILLPROPERTIES(ap->fillProperties);
563 if (fp->_nodeType == NODE_FillProperties) fp->_enabled = TRUE;
567 fp->_hatchScale.c[0] = fillScale;
568 fp->_hatchScale.c[1] = fillScale;
576 ap = X3D_APPEARANCE(X3D_SHAPE(node)->appearance);
578 if (ap->fillProperties != NULL) {
581 if (fp->_nodeType == NODE_FillProperties) fp->_enabled = FALSE;
590int fwl_get_FillPropHatched(
struct Vector **shapeNodes,
int whichEntry) {
599 if (vectorSize(*shapeNodes) == 0 ) {
604 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
605 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
607 return (fp->hatched);
611void fwl_set_FillPropHatched (
struct Vector **shapeNodes,
int whichEntry,
int yesNo) {
621 if (vectorSize(*shapeNodes) == 0 ) {
626 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
627 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
629 if (fp!=NULL) fp->hatched = yesNo;
633int fwl_get_FillPropFilled(
struct Vector **shapeNodes,
int whichEntry) {
642 if (vectorSize(*shapeNodes) == 0 ) {
647 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
648 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
654void fwl_set_FillPropFilled (
struct Vector **shapeNodes,
int whichEntry,
int yesNo) {
664 if (vectorSize(*shapeNodes) == 0 ) {
669 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
670 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
672 if (fp!=NULL) fp->filled = yesNo;
677int fwl_get_FillPropStyle(
struct Vector **shapeNodes,
int whichEntry) {
686 if (vectorSize(*shapeNodes) == 0 ) {
691 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
692 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
694 if (fp==NULL)
return 0;
695 return (fp->hatchStyle);
699void fwl_set_FillPropStyle (
struct Vector **shapeNodes,
int whichEntry,
int which) {
709 if (vectorSize(*shapeNodes) == 0 ) {
714 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
715 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
717 if (fp!=NULL) fp->hatchStyle = which;
722int fwl_get_FillPropColour(
struct Vector **shapeNodes,
int whichEntry) {
732 if (vectorSize(*shapeNodes) == 0 ) {
737 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
738 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
740 #define CLAMP(value, min, max) (((value) >(max)) ? (max) : (((value) <(min)) ? (min) : (value)))
741 if (fp==NULL)
return 0;
743 integer_colour = 0xFF000000 + (
744 ((uint8_t)(255.0f *CLAMP(fp->hatchColor.c[0], 0.0, 1.0)) <<16) |
745 ((uint8_t)(255.0f *CLAMP(fp->hatchColor.c[1], 0.0, 1.0)) <<8) |
746 ((uint8_t)(255.0f *CLAMP(fp->hatchColor.c[2], 0.0, 1.0))));
749 return (integer_colour);
753void fwl_set_FillPropColour (
struct Vector **shapeNodes,
int whichEntry,
int argbColour) {
763 if (vectorSize(*shapeNodes) == 0 ) {
768 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
769 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
772 fp->hatchColor.c[0] =CLAMP(((
float)((argbColour &0xff0000) >>16)) /255.0, 0.0, 1.0);
773 fp->hatchColor.c[1] =CLAMP(((
float)((argbColour &0x00ff00) >>8)) /255.0, 0.0, 1.0);
774 fp->hatchColor.c[2] =CLAMP(((
float)((argbColour &0x0000ff))) /255.0, 0.0, 1.0);
787int fwl_set_MaterialExisting(
struct Vector **shapeNodes,
int whichEntry) {
797 int twoSided = FALSE;
801 if (vectorSize(*shapeNodes) == 0 ) {
802 if (fwl_android_get_valid_shapeNodes(shapeNodes) == 0)
return FALSE;
807 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
810 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
814 if (X3D_SHAPE(node)->appearance == NULL) {
816 ap = createNewX3DNode(NODE_Appearance);
817 AddRemoveSFNodeFieldChild(node,
818 offsetPointer_deref(
struct X3D_Node **,node,offsetof (
struct X3D_Shape, appearance)),
819 X3D_NODE(ap),0,__FILE__,__LINE__);
821 mat = createNewX3DNode(NODE_TwoSidedMaterial);
822 AddRemoveSFNodeFieldChild(X3D_NODE(ap),
824 X3D_NODE(mat),0,__FILE__,__LINE__);
827 ap = X3D_APPEARANCE(X3D_SHAPE(node)->appearance);
833 if (ap->material == NULL) {
835 tsm = X3D_TWOSIDEDMATERIAL(createNewX3DNode(NODE_TwoSidedMaterial));
836 AddRemoveSFNodeFieldChild(X3D_NODE(ap),
838 X3D_NODE(tsm),0,__FILE__,__LINE__);
841 tsm = X3D_TWOSIDEDMATERIAL(ap->material);
845 if (tsm->_nodeType != NODE_TwoSidedMaterial) {
848 if (mat->_nodeType == NODE_Material) {
850 ntsm->ambientIntensity = mat->ambientIntensity;
851 ntsm->backAmbientIntensity = mat->ambientIntensity;
852 ntsm->shininess = mat->shininess;
853 ntsm->backShininess = mat->shininess;
854 ntsm->transparency = mat->transparency;
855 ntsm->backTransparency = mat->transparency;
856 memcpy((
void *)&ntsm->diffuseColor, (
void *)&mat->diffuseColor,
sizeof(
struct SFColor));
857 memcpy((
void *)&ntsm->backDiffuseColor, (
void *)&mat->diffuseColor,
sizeof(
struct SFColor));
858 memcpy((
void *)&ntsm->emissiveColor, (
void *)&mat->emissiveColor,
sizeof(
struct SFColor));
859 memcpy((
void *)&ntsm->backEmissiveColor, (
void *)&mat->emissiveColor,
sizeof(
struct SFColor));
860 memcpy((
void *)&ntsm->specularColor, (
void *)&mat->specularColor,
sizeof(
struct SFColor));
861 memcpy((
void *)&ntsm->backSpecularColor, (
void *)&mat->specularColor,
sizeof(
struct SFColor));
862 ntsm->separateBackColor=FALSE;
864 ConsoleMessage (
"somehow the Material is not a node of Material type for this node");
868 AddRemoveSFNodeFieldChild(X3D_NODE(ap),
870 X3D_NODE(ntsm),0,__FILE__,__LINE__);
873 twoSided = X3D_TWOSIDEDMATERIAL(tsm)->separateBackColor;
899int fwl_get_MaterialColourValue(
struct Vector **shapeNodes,
int whichEntry,
int whichValue) {
911 if (vectorSize(*shapeNodes) == 0 ) {
912 if (fwl_android_get_valid_shapeNodes(shapeNodes) == 0)
return 0;
917 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
920 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
922 if (mat == NULL)
return 0;
924 if (mat->_nodeType == NODE_TwoSidedMaterial) {
927 switch (whichValue) {
928 case 0: col = &tmat->diffuseColor;
break;
929 case 1: col = &tmat->emissiveColor;
break;
930 case 2: col = &tmat->specularColor;
break;
931 case 3: col = &tmat->backDiffuseColor;
break;
932 case 4: col = &tmat->backEmissiveColor;
break;
933 case 5: col = &tmat->backSpecularColor;
break;
938 integer_colour = 0xFF000000 + (
939 ((uint8_t)(255.0f *CLAMP(col->c[0], 0.0, 1.0)) <<16) |
940 ((uint8_t)(255.0f *CLAMP(col->c[1], 0.0, 1.0)) <<8) |
941 ((uint8_t)(255.0f *CLAMP(col->c[2], 0.0, 1.0))));
943 return integer_colour;
946 ConsoleMessage (
"getMaterialValue, expected a TwoSidedMaterial, not a %s\n",stringNodeType(mat->_nodeType));
952void fwl_set_TwoSidedMaterialStatus(
struct Vector **shapeNodes,
int whichEntry,
int oneTwo) {
962 if (vectorSize(*shapeNodes) == 0 ) {
967 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
968 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
970 if (mat == NULL)
return;
971 if (mat->_nodeType == NODE_TwoSidedMaterial) {
973 X3D_TWOSIDEDMATERIAL(mat)->separateBackColor = oneTwo;
979void fwl_set_MaterialColourValue (
struct Vector **shapeNodes,
int whichEntry,
int whichValue,
int argbColour) {
989 if (vectorSize(*shapeNodes) == 0 ) {
994 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
995 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
997 if (mat == NULL)
return;
998 if (mat->_nodeType == NODE_TwoSidedMaterial) {
1001 switch (whichValue) {
1002 case 0: col = &tmat->diffuseColor;
break;
1003 case 1: col = &tmat->emissiveColor;
break;
1004 case 2: col = &tmat->specularColor;
break;
1005 case 3: col = &tmat->backDiffuseColor;
break;
1006 case 4: col = &tmat->backEmissiveColor;
break;
1007 case 5: col = &tmat->backSpecularColor;
break;
1011 col->c[0] =CLAMP(((
float)((argbColour &0xff0000) >>16)) /255.0, 0.0, 1.0);
1012 col->c[1] =CLAMP(((
float)((argbColour &0x00ff00) >>8)) /255.0, 0.0, 1.0);
1013 col->c[2] =CLAMP(((
float)((argbColour &0x0000ff))) /255.0, 0.0, 1.0);
1026int fwl_get_MaterialFloatValue(
struct Vector **shapeNodes,
int whichEntry,
int whichSide,
int whichField) {
1040 if (vectorSize(*shapeNodes) == 0 ) {
1041 if (fwl_android_get_valid_shapeNodes(shapeNodes) == 0)
return 0;
1046 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
1049 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
1051 if (mat == NULL)
return 0;
1053 if (mat->_nodeType == NODE_TwoSidedMaterial) {
1057 switch (whichField) {
1058 case 1: fcol = tmat->shininess;
break;
1059 case 2: fcol = tmat->transparency;
break;
1060 case 3: fcol = tmat->ambientIntensity;
break;
1062 ConsoleMessage (
"hmmm - expect 1-3, got %d",whichField);
1067 switch (whichField) {
1068 case 1: fcol = tmat->backShininess;
break;
1069 case 2: fcol = tmat->backTransparency;
break;
1070 case 3: fcol = tmat->backAmbientIntensity;
break;
1072 ConsoleMessage (
"hmmm - expect 1-3, got %d",whichField);
1078 return (
int)(fcol*100.0);
1080 ConsoleMessage (
"getMaterialValue, expected a TwoSidedMaterial, not a %s\n",stringNodeType(mat->_nodeType));
1086void fwl_set_MaterialFloatValue(
struct Vector **shapeNodes,
int whichEntry,
int whichSide,
int whichField,
int nv) {
1100 if (vectorSize(*shapeNodes) == 0 ) {
1101 if (fwl_android_get_valid_shapeNodes(shapeNodes) == 0)
return;
1106 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
1109 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
1111 if (mat == NULL)
return;
1113 if (mat->_nodeType == NODE_TwoSidedMaterial) {
1115 float nnv = CLAMP(((
float)nv)/100.0,0.0,1.0);
1118 switch (whichField) {
1119 case 1: tmat->shininess=nnv;
break;
1120 case 2: tmat->transparency=nnv;
break;
1121 case 3: tmat->ambientIntensity=nnv;
break;
1123 ConsoleMessage (
"hmmm - expect 1-3, got %d",whichField);
1127 switch (whichField) {
1128 case 1: tmat->backShininess=nnv;
break;
1129 case 2: tmat->backTransparency=nnv;
break;
1130 case 3: tmat->backAmbientIntensity=nnv;
break;
1132 ConsoleMessage (
"hmmm - expect 1-3, got %d",whichField);
1138 ConsoleMessage (
"getMaterialValue, expected a TwoSidedMaterial, not a %s\n",stringNodeType(mat->_nodeType));
1148#define TURN_OFF_SHOULDSORTCHILDREN node->_renderFlags = node->_renderFlags & (0xFFFF^ VF_shouldSortChildren);
1150void fwl_setShadingStyle(
int val) {
1153 ttglobal tg = gglobal();
1154 p = (ppOpenGL_Utils)tg->OpenGL_Utils.prv;
1155 p->shadingStyle = val;
1157int fwl_getShadingStyle() {
1159 ttglobal tg = gglobal();
1160 p = (ppOpenGL_Utils)tg->OpenGL_Utils.prv;
1161 return p->shadingStyle;
1193static void shaderErrorLog(GLuint myShader,
char *which) {
1194 #if defined (GL_VERSION_2_0) || defined (GL_ES_VERSION_2_0)
1195 #define MAX_INFO_LOG_SIZE 2048
1196 GLchar infoLog[MAX_INFO_LOG_SIZE];
1197 char outline[MAX_INFO_LOG_SIZE*2];
1198 glGetShaderInfoLog(myShader, MAX_INFO_LOG_SIZE, NULL, infoLog);
1199 sprintf(outline,
"problem with %s shader: %s",which, infoLog);
1200 ConsoleMessage (outline);
1202 ConsoleMessage (
"Problem compiling shader");
1214 #ifdef GL_SHADER_COMPILER
1216 static bool haveDoneThis =
false;
1223 ppOpenGL_Utils p = gglobal()->OpenGL_Utils.prv;
1224 struct Vector *myShaderTable = p->myShaderTable;
1230 for (i=0; i<vectorSize(myShaderTable); i++) {
1233 if(me->whichOne.volume == rq_cap0.volume && me->whichOne.effects == rq_cap0.effects){
1234 return me->myCapabilities;
1236 }
else if (rq_cap0.depth) {
1237 if (me->whichOne.depth == rq_cap0.depth)
1238 return me->myCapabilities;
1239 }
else if (rq_cap0.debug) {
1240 if (me->whichOne.debug == rq_cap0.debug)
return me->myCapabilities;
1242 if (me->whichOne.base == rq_cap0.base && me->whichOne.effects == rq_cap0.effects && me->whichOne.usershaders == rq_cap0.usershaders) {
1244 return me->myCapabilities;
1264#ifdef GL_SHADER_COMPILER
1265 glGetBooleanv(GL_SHADER_COMPILER,bbb);
1266 if (!haveDoneThis) {
1267 haveDoneThis =
true;
1271 ConsoleMessage(
"no shader compiler\n");
1280#if defined (GL_SHADER_COMPILER) && defined (GL_HIGH_FLOAT)
1283 GLint range[2]; GLint precision;
1286 ConsoleMessage(
"starting getMyShader");
1288 glGetBooleanv(GL_SHADER_COMPILER,&b);
1289 if (b) ConsoleMessage(
"have shader compiler");
else ConsoleMessage(
"NO SHADER COMPILER");
1292 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_LOW_FLOAT, range, &precision);
1293 ConsoleMessage (
"GL_VERTEX_SHADER, GL_LOW_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
1294 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_MEDIUM_FLOAT, range, &precision);
1295 ConsoleMessage (
"GL_VERTEX_SHADER, GL_MEDIUM_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
1296 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_HIGH_FLOAT, range, &precision);
1297 ConsoleMessage (
"GL_VERTEX_SHADER, GL_HIGH_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
1299 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_LOW_INT, range, &precision);
1300 ConsoleMessage (
"GL_VERTEX_SHADER, GL_LOW_INT range [%d,%d],precision %d",range[0],range[1],precision);
1301 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_MEDIUM_INT, range, &precision);
1302 ConsoleMessage (
"GL_VERTEX_SHADER, GL_MEDIUM_INT range [%d,%d],precision %d",range[0],range[1],precision);
1303 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_HIGH_INT, range, &precision);
1304 ConsoleMessage (
"GL_VERTEX_SHADER, GL_HIGH_INT range [%d,%d],precision %d",range[0],range[1],precision);
1306 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_LOW_FLOAT, range, &precision);
1307 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_LOW_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
1308 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_MEDIUM_FLOAT, range, &precision);
1309 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_MEDIUM_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
1310 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_HIGH_FLOAT, range, &precision);
1311 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_HIGH_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
1313 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_LOW_INT, range, &precision);
1314 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_LOW_INT range [%d,%d],precision %d",range[0],range[1],precision);
1315 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_MEDIUM_INT, range, &precision);
1316 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_MEDIUM_INT range [%d,%d],precision %d",range[0],range[1],precision);
1317 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_HIGH_INT, range, &precision);
1318 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_HIGH_INT range [%d,%d],precision %d",range[0],range[1],precision);
1325 ste->whichOne = rq_cap;
1326 ste->myCapabilities = MALLOC(s_shader_capabilities_t*,
sizeof (s_shader_capabilities_t));
1329 makeAndCompileShader(ste);
1335 return ste->myCapabilities;
1338s_shader_capabilities_t *getMyShader(
unsigned int rq_cap0) {
1341 rq_cap0s.base = rq_cap0;
1342 return getMyShaders(rq_cap0s);
1344#define DESIRE(whichOne,zzz) ((whichOne & zzz)==zzz)
1356static const GLchar *vertProjValDec =
"\
1357 uniform mat4 projTexGenMatCam0; \n \
1358 varying vec4 projTexCoord; \n";
1360static const GLchar *vertProjCalTexCoord =
"\
1361 void vertProjCalTexCoord(void) { \
1362 projTexCoord = projTexGenMatCam0 * fw_Vertex; \
1365static const GLchar *vertProjTexCalculation =
"\
1366 vertProjCalTexCoord();\n";
1376static const GLchar *fragProjValDec =
"\
1377 varying vec4 projTexCoord; \n \
1378 vec4 ProjMapColor_forCam1; \n";
1380static const GLchar *fragProjCalTexCoord =
"\
1381 void fragProjCalTexCoord(void) { \
1382 if( projTexCoord.q > 0.0 ){ \n \
1383 ProjMapColor_forCam1 = texture2DProj(fw_Texture_unit0, projTexCoord);\n \
1387static const GLchar *fragProjTexCalculation =
"\
1388 fragProjCalTexCoord();\n \
1389 finalFrag += ProjMapColor_forCam1;\n \
1400static const GLchar *vertMultiProjValDec =
"\
1401 uniform mat4 MultiprojTexGenMatCam1; \n \
1402 uniform mat4 MultiprojTexGenMatCam2; \n \
1403 uniform mat4 MultiprojTexGenMatCam3; \n \
1404 uniform mat4 MultiprojTexGenMatCam4; \n \
1405 varying vec4 MultiprojTexCoord1; \n \
1406 varying vec4 MultiprojTexCoord2; \n \
1407 varying vec4 MultiprojTexCoord3; \n \
1408 varying vec4 MultiprojTexCoord4; \n";
1410static const GLchar *vertMultiProjCalTexCoord =
"\
1411 void vertMultiProjCalTexCoord(void) { \
1412 MultiprojTexCoord1 = MultiprojTexGenMatCam1 * fw_Vertex; \
1413 MultiprojTexCoord2 = MultiprojTexGenMatCam2 * fw_Vertex; \
1414 MultiprojTexCoord3 = MultiprojTexGenMatCam3 * fw_Vertex; \
1415 MultiprojTexCoord4 = MultiprojTexGenMatCam4 * fw_Vertex; \
1418static const GLchar *vertMultiProjTexCalculation =
"\
1419 vertMultiProjCalTexCoord();\n";
1429static const GLchar *fragMultiProjValDec =
"\
1430 varying vec4 MultiprojTexCoord1; \n \
1431 varying vec4 MultiprojTexCoord2; \n \
1432 varying vec4 MultiprojTexCoord3; \n \
1433 varying vec4 MultiprojTexCoord4; \n \
1434 vec4 final_color = vec4(1.0, 1.0, 1.0, 0.0); \n";
1436static const GLchar *fragMultiProjCalTexCoord =
"\
1437 void fragMultiProjCalTexCoord(void) { \
1438 if( MultiprojTexCoord1.q > 0.0 ){ \n \
1439 vec4 ProjMapColor_forCam1 = texture2DProj(fw_Texture_unit0, MultiprojTexCoord1);\n \
1440 final_color = ProjMapColor_forCam1;\n \
1442 if( MultiprojTexCoord2.q > 0.0 ){ \n \
1443 vec4 ProjMapColor_forCam2 = texture2DProj(fw_Texture_unit1, MultiprojTexCoord2);\n \
1444 final_color = final_color+ ProjMapColor_forCam2;\n \
1446 if( MultiprojTexCoord3.q > 0.0 ){ \n \
1447 vec4 ProjMapColor_forCam3 = texture2DProj(fw_Texture_unit2, MultiprojTexCoord3);\n \
1448 final_color = final_color+ ProjMapColor_forCam3;\n \
1452static const GLchar *fragMultiProjTexCalculation =
"\
1453 fragMultiProjCalTexCoord();\n \
1454 finalFrag += final_color;\n \
1465static const GLchar *vertPosDec =
"\
1466 attribute vec4 fw_Vertex; \n \
1467 uniform mat4 fw_ModelViewMatrix; \n \
1468 uniform mat4 fw_ProjectionMatrix; \n ";
1470static const GLchar *vertNormDec =
" \
1471 uniform mat4 fw_NormalMatrix;\n \
1472 attribute vec3 fw_Normal; \n";
1474static const GLchar *vertSimColDec =
"\
1475 attribute vec4 fw_Color;\n ";
1477static const GLchar *vertTexMatrixDec =
"\
1478 uniform mat4 fw_TextureMatrix0;\n";
1480static const GLchar *vertTexCoordGenDec =
"\
1481 uniform int fw_textureCoordGenType;\n";
1483static const GLchar *vertTexCoordDec =
"\
1484attribute vec4 fw_MultiTexCoord0; \n\
1485attribute vec4 fw_MultiTexCoord1; \n\
1486attribute vec4 fw_MultiTexCoord2; \n\
1487attribute vec4 fw_MultiTexCoord3; \n\
1490static const GLchar *vertOneMatDec =
"\
1491 uniform fw_MaterialParameters\n\
1492 fw_FrontMaterial; \n";
1493static const GLchar *vertBackMatDec =
"\
1494 uniform fw_MaterialParameters fw_BackMaterial; \n";
1500static const GLchar *vecNormPos =
" \
1502 vec4 vertexPos; \n";
1504static const GLchar *varyingNormPos =
" \
1505 varying vec3 vertexNorm; \
1506 varying vec4 vertexPos; \n";
1508static const GLchar *varyingTexCoord =
"\
1509 varying vec3 fw_TexCoord[4];\n";
1511static const GLchar *varyingFrontColour =
"\
1512 varying vec4 v_front_colour; \n";
1514static const GLchar *varyingHatchPosition =
"\
1515 varying vec2 hatchPosition; \n";
1519static const GLchar *vertMainStart =
"void main(void) { \n";
1521static const GLchar *vertEnd =
"}";
1523static const GLchar *vertPos =
"gl_Position = fw_ProjectionMatrix * fw_ModelViewMatrix * fw_Vertex;\n ";
1525static const GLchar *vertNormPosCalc =
"\
1526 vertexNorm = normalize(fw_NormalMatrix * vec4(fw_Normal,1));\n \
1527 vertexPos = fw_ModelViewMatrix * fw_Vertex;\n ";
1529static const GLchar *vertSimColUse =
"v_front_colour = fw_Color; \n";
1531static const GLchar *vertEmissionOnlyColourAss =
"v_front_colour = fw_FrontMaterial.emission;\n";
1532static const GLchar *vertSingTexCalc =
"fw_TexCoord[0] = vec3(vec4(fw_TextureMatrix0 *w_MultiTexCoord0)).stp;\n";
1534static const GLchar *vertSingTexCubeCalc =
"\
1535 vec3 u=normalize(vec3(fw_ProjectionMatrix * fw_Vertex)); /* myEyeVertex */ \
1536 /* vec3 n=normalize(vec3(fw_NormalMatrix*vec4(fw_Normal,1))); \
1537 fw_TexCoord[0] = reflect(u,n); myEyeNormal */ \n \
1538 /* v_texC = reflect(normalize(vec3(vertexPos)),vertexNorm);\n */ \
1539 fw_TexCoord[0] = reflect(u,vertexNorm);\n";
1543const static GLchar *fragTCGTDefs = TEXTURECOORDINATEGENERATORDefs;
1548static const GLchar *sphEnvMapCalc =
" \n \
1549/* sphereEnvironMapping Calculation */ \
1550/* vec3 u=normalize(vec3(fw_ModelViewMatrix * fw_Vertex)); (myEyeVertex) \
1551vec3 n=normalize(vec3(fw_NormalMatrix*vec4(fw_Normal,1))); \
1552vec3 r = reflect(u,n); (myEyeNormal) */ \n\
1553vec3 u=normalize(vec3(vertexPos)); /* u is normalized position, used below more than once */ \n \
1554vec3 r= reflect(u,vertexNorm); \n\
1555if (fw_textureCoordGenType==TCGT_SPHERE) { /* TCGT_SPHERE GL_SPHERE_MAP OpenGL Equiv */ \n\
1556 float m=2.0 * sqrt(r.x*r.x + r.y*r.y + (r.z*1.0)*(r.z*1.0)); \n\
1557 fw_TexCoord[0] = vec3(r.x/m+0.5,r.y/m+0.5,0.0); \n \
1558}else if (fw_textureCoordGenType==TCGT_CAMERASPACENORMAL) /* GL_REFLECTION_MAP used for sampling cubemaps */ {\n \
1559 float dotResult = 2.0 * dot(u,r); \n\
1560 fw_TexCoord[0] = vec3(u-r)*dotResult;\n\
1561} else { /* default usage - like default CubeMaps */ \n\
1562 vec3 u=normalize(vec3(fw_ProjectionMatrix * fw_Vertex)); /* myEyeVertex */ \
1563 fw_TexCoord[0] = reflect(u,vertexNorm);\n \
1567static const GLchar *vertHatchPosCalc =
"hatchPosition = fw_Vertex.xy;\n";
1569static const GLchar *fillPropDefines =
"\
1570uniform vec4 HatchColour; \n\
1571uniform bool hatched; uniform bool filled;\n\
1572uniform vec2 HatchScale; uniform vec2 HatchPct; uniform int algorithm; ";
1576static const GLchar *lightDefines =
"\
1577struct fw_MaterialParameters { \n\
1582 float shininess; \n\
1583 float occlusion; \n\
1584 float normalScale; \n\
1585 float transparency; \n\
1588 float roughness; \n\
1590 // multitextures are disaggregated \n\
1595 int samplr[10]; //0 texture2D 1 cubeMap \n\
1597 int nt; //total single textures \n\
1598 //iunit [0] normal [1] emissive [2] occlusion [3] diffuse OR base [4] shininess OR metallicRoughness [5] specular [6] ambient \n\
1599 int tcount[7]; //num single textures 1= one texture 0=no texture 2+ = multitexture \n\
1600 int tstart[7]; // where in packed tindex list to start looping \n\
1601 //int cindex[7]; // which geometry multitexcoord channel 0=default \n\
1603uniform fw_MaterialParameters fw_FrontMaterial; \n\
1604#define MAX_LIGHTS 8 \n\
1605uniform int lightcount; \n\
1606uniform int lightType[MAX_LIGHTS];//ANGLE like this \n\
1607struct fw_LightSourceParameters { \n\
1610 float intensity; \n\
1612 vec3 halfVector; \n\
1614 float spotBeamWidth; \n\
1615 float spotCutoff; \n\
1616 vec3 Attenuations; \n\
1617 float lightRadius; \n\
1619 float shadowIntensity; \n\
1623uniform fw_LightSourceParameters fw_LightSource[MAX_LIGHTS] /* gl_MaxLights */ ;\n\
1643static const GLchar *ADSLLightModel =
"\n\
1644/* use ADSLightModel here the ADS colour is returned from the function. */\n\
1645vec4 ADSLightModel(in vec3 myNormal, in vec4 myPosition, in bool useMatDiffuse) {\n\
1647 vec4 diffuse = vec4(0., 0., 0., 0.);\n\
1648 vec4 ambient = vec4(0., 0., 0., 0.);\n\
1649 vec4 specular = vec4(0., 0., 0., 1.);\n\
1650 vec3 normal = normalize (myNormal);\n\
1652 vec3 viewv = -normalize(myPosition.xyz); \n \
1653 bool backFacing = (dot(normal,viewv) < 0.0); \n \
1655 vec4 matdiffuse = vec4(1.0,1.0,1.0,1.0);\n\
1656 float myAlph = 0.0;\n\
1658 fw_MaterialParameters myMat = fw_FrontMaterial;\n\
1660/* back Facing materials - flip the normal and grab back materials */ \n \
1661if (backFacing) { \n \
1662 normal = -normal; \n \
1663 myMat = fw_BackMaterial; \n \
1666 emissive = myMat.emission;\n\
1667 myAlph = myMat.diffuse.a;\n\
1668 if(useMatDiffuse)\n\
1669 matdiffuse = myMat.diffuse;\n\
1671 /* apply the lights to this material */\n\
1672 for (i=0; i<MAX_LIGHTS; i++) {\n\
1673 if(i<lightcount) { /*weird but ANGLE needs constant loop*/ \n\
1674 vec4 myLightDiffuse = fw_LightSource[i].diffuse;\n\
1675 vec4 myLightAmbient = fw_LightSource[i].ambient;\n\
1676 vec4 myLightSpecular = fw_LightSource[i].specular;\n\
1677 vec4 myLightPosition = fw_LightSource[i].position; \n\
1678 int myLightType = lightType[i]; //fw_LightSource[i].lightType;\n\
1679 vec3 myLightDir = fw_LightSource[i].spotDirection.xyz; \n\
1680 vec3 eyeVector = normalize(myPosition.xyz);\n\
1681 vec3 VP; /* vector of light direction and distance */\n\
1682 VP = myLightPosition.xyz - myPosition.xyz;\n\
1683 vec3 L = myLightDir; /*directional light*/ \n\
1684 if(myLightType < 2) /*point and spot*/ \n\
1685 L = normalize(VP); \n\
1686 float nDotL = max(dot(normal, L), 0.0);\n\
1687 vec3 halfVector = normalize(L - eyeVector);\n\
1688 /* normal dot light half vector */\n\
1689 float nDotHV = max(dot(normal,halfVector),0.0);\n\
1691 if (myLightType==1) {\n\
1694 float spotAttenuation = 0.0; \n\
1695 float powerFactor = 0.0; /* for light dropoff */ \n\
1696 float attenuation; /* computed attenuation factor */\n\
1697 float d; /* distance to vertex */ \n\
1699 if (nDotL > 0.0) {\n\
1700 powerFactor = pow(nDotL,myMat.shininess); \n\
1701 /* tone down the power factor if myMat.shininess borders 0 */\n\
1702 if (myMat.shininess < 1.0) {\n\
1703 powerFactor *= myMat.shininess; \n\
1706 attenuation = 1.0/(fw_LightSource[i].Attenuations.x + (fw_LightSource[i].Attenuations.y * d) + (fw_LightSource[i].Attenuations.z *d *d));\n\
1707 spotDot = dot (-L,myLightDir);\n\
1708 /* check against spotCosCutoff */\n\
1709 if (spotDot > fw_LightSource[i].spotCutoff) {\n\
1710 spotAttenuation = pow(spotDot,fw_LightSource[i].spotCutoff);\n\
1712 attenuation *= spotAttenuation;\n\
1713 /* diffuse light computation */\n\
1714 diffuse += nDotL* matdiffuse*myLightDiffuse * attenuation;\n\
1715 /* ambient light computation */\n\
1716 ambient += myMat.ambient*myLightAmbient;\n\
1717 /* specular light computation */\n\
1718 specular += myLightSpecular * powerFactor * attenuation;\n\
1720 } else if (myLightType == 2) { \n\
1721 /* DirectionalLight */ \n\
1722 float powerFactor = 0.0; /* for light dropoff */\n\
1723 if (nDotL > 0.0) {\n\
1724 powerFactor = pow(nDotHV, myMat.shininess);\n\
1725 /* tone down the power factor if myMat.shininess borders 0 */\n\
1726 if (myMat.shininess < 1.0) {\n\
1727 powerFactor *= myMat.shininess;\n\
1730 /* Specular light computation */\n\
1731 specular += myMat.specular *myLightSpecular*powerFactor;\n\
1732 /* diffuse light computation */\n\
1733 diffuse += nDotL*matdiffuse*myLightDiffuse;\n\
1734 /* ambient light computation */\n\
1735 ambient += myMat.ambient*myLightAmbient; \n\
1738 float powerFactor=0.0; /* for light dropoff */\n\
1739 float attenuation = 0.0; /* computed attenuation factor */\n\
1740 float d = length(VP); /* distance to vertex */ \n\
1741 /* are we within range? */\n\
1742 if (d <= fw_LightSource[i].lightRadius) {\n\
1743 if (nDotL > 0.0) {\n\
1744 powerFactor = pow(nDotL, myMat.shininess);\n\
1745 //attenuation = (myMat.shininess-128.0);\n\
1747 /* this is actually the SFVec3f attenuation field */\n\
1748 attenuation = 1.0/(fw_LightSource[i].Attenuations.x + (fw_LightSource[i].Attenuations.y * d) + (fw_LightSource[i].Attenuations.z *d *d));\n\
1749 /* diffuse light computation */\n\
1750 diffuse += nDotL* matdiffuse*myLightDiffuse * attenuation;\n\
1751 /* ambient light computation */\n\
1752 ambient += myMat.ambient*myLightAmbient;\n\
1753 /* specular light computation */\n\
1754 attenuation *= (myMat.shininess/128.0);\n\
1755 specular += myLightSpecular * powerFactor * attenuation;\n\
1760 return clamp(vec4(vec3(ambient+diffuse+specular+emissive),myAlph), 0.0, 1.0);\n\
1763#ifdef USING_SHADER_LIGHT_ARRAY_METHOD
1768static const GLchar *lightDefinesArrayMethod =
"\
1769struct fw_MaterialParameters {\n\
1776uniform int lightcount;\n\
1777uniform int lightType[MAX_LIGHTS];\n\
1778uniform vec4 lightambient[MAX_LIGHTS]; \n\
1779uniform vec4 lightdiffuse[MAX_LIGHTS]; \n\
1780uniform vec4 lightspecular[MAX_LIGHTS]; \n\
1781uniform vec4 lightposition[MAX_LIGHTS]; \n\
1782uniform vec4 lighthalfVector[MAX_LIGHTS]; \n\
1783uniform vec4 lightspotDirection[MAX_LIGHTS]; \n\
1784uniform float lightspotBeamWidth[MAX_LIGHTS]; \n\
1785uniform float lightspotCutoff[MAX_LIGHTS]; \n\
1786uniform float lightRadius[MAX_LIGHTS]; \n\
1787uniform vec3 lightAttenuations[MAX_LIGHTS]; \n\
1790static const GLchar *ADSLLightModelArrayMethod =
"\n\
1791/* use ADSLightModel here the ADS colour is returned from the function. */\n\
1792vec4 ADSLightModel(in vec3 myNormal, in vec4 myPosition, in bool useMatDiffuse) {\n\
1794 vec4 diffuse = vec4(0., 0., 0., 0.);\n\
1795 vec4 ambient = vec4(0., 0., 0., 0.);\n\
1796 vec4 specular = vec4(0., 0., 0., 1.);\n\
1797 vec3 normal = normalize (myNormal);\n\
1799 vec3 viewv = -normalize(myPosition.xyz); \n \
1800 bool backFacing = (dot(normal,viewv) < 0.0); \n \
1802 vec4 matdiffuse = vec4(1.0,1.0,1.0,1.0);\n\
1803 float myAlph = 0.0;\n\
1805 fw_MaterialParameters myMat = fw_FrontMaterial;\n\
1807/* back Facing materials - flip the normal and grab back materials */ \n \
1808if (backFacing) { \n \
1809 normal = -normal; \n \
1810 myMat = fw_BackMaterial; \n \
1813 emissive = myMat.emission;\n\
1814 myAlph = myMat.diffuse.a;\n\
1815 if(useMatDiffuse)\n\
1816 matdiffuse = myMat.diffuse;\n\
1818 /* apply the lights to this material */\n\
1819 for (i=0; i<MAX_LIGHTS; i++) {\n\
1820 if(i<lightcount){ /* weird but ANGLE for d3d9 needs constant loop (d3d11/winrt OK with variable loop)*/ \n\
1821 vec4 myLightDiffuse = lightdiffuse[i];\n\
1822 vec4 myLightAmbient = lightambient[i];\n\
1823 vec4 myLightSpecular = lightspecular[i];\n\
1824 vec4 myLightPosition = lightposition[i]; \n\
1825 vec4 myspotDirection = lightspotDirection[i]; \n\
1826 int myLightType = lightType[i]; \n\
1827 vec3 myLightDir = myspotDirection.xyz; \n\
1828 vec3 eyeVector = normalize(myPosition.xyz);\n\
1829 vec3 VP; /* vector of light direction and distance */\n\
1830 VP = myLightPosition.xyz - myPosition.xyz;\n\
1831 vec3 L = myLightDir; /*directional light*/ \n\
1832 if(myLightType < 2) /*point and spot*/ \n\
1833 L = normalize(VP); \n\
1834 float nDotL = max(dot(normal, L), 0.0);\n\
1835 vec3 halfVector = normalize(L - eyeVector);\n\
1836 /* normal dot light half vector */\n\
1837 float nDotHV = max(dot(normal,halfVector),0.0);\n\
1839 if (myLightType==1) {\n\
1842 float spotAttenuation = 0.0; \n\
1843 float powerFactor = 0.0; /* for light dropoff */ \n\
1844 float attenuation; /* computed attenuation factor */\n\
1845 float d; /* distance to vertex */ \n\
1847 if (nDotL > 0.0) {\n\
1848 powerFactor = pow(nDotL,myMat.shininess); \n\
1849 /* tone down the power factor if myMat.shininess borders 0 */\n\
1850 if (myMat.shininess < 1.0) {\n\
1851 powerFactor *= myMat.shininess; \n\
1854 attenuation = 1.0/(lightAttenuations[i].x + (lightAttenuations[i].y * d) + (lightAttenuations[i].z *d *d));\n\
1855 spotDot = dot (-L,myLightDir);\n\
1856 /* check against spotCosCutoff */\n\
1857 if (spotDot > lightspotCutoff[i]) {\n\
1858 spotAttenuation = pow(spotDot,lightspotBeamWidth[i]);\n\
1860 attenuation *= spotAttenuation;\n\
1861 /* diffuse light computation */\n\
1862 diffuse += nDotL* matdiffuse*myLightDiffuse * attenuation;\n\
1863 /* ambient light computation */\n\
1864 ambient += myMat.ambient*myLightAmbient;\n\
1865 /* specular light computation */\n\
1866 specular += myLightSpecular * powerFactor * attenuation;\n\
1868 } else if (myLightType == 2) { \n\
1869 /* DirectionalLight */ \n\
1870 float powerFactor = 0.0; /* for light dropoff */\n\
1871 if (nDotL > 0.0) {\n\
1872 powerFactor = pow(nDotHV, myMat.shininess);\n\
1873 /* tone down the power factor if myMat.shininess borders 0 */\n\
1874 if (myMat.shininess < 1.0) {\n\
1875 powerFactor *= myMat.shininess;\n\
1878 /* Specular light computation */\n\
1879 specular += myMat.specular *myLightSpecular*powerFactor;\n\
1880 /* diffuse light computation */\n\
1881 diffuse += nDotL*matdiffuse*myLightDiffuse;\n\
1882 /* ambient light computation */\n\
1883 ambient += myMat.ambient*myLightAmbient; \n\
1886 float powerFactor=0.0; /* for light dropoff */\n\
1887 float attenuation = 0.0; /* computed attenuation factor */\n\
1888 float d = length(VP); /* distance to vertex */ \n\
1889 /* are we within range? */\n\
1890 if (d <= lightRadius[i]) {\n\
1891 if (nDotL > 0.0) {\n\
1892 powerFactor = pow(nDotL, myMat.shininess);\n\
1894 /* this is actually the SFVec3f attenuation field */\n\
1895 attenuation = 1.0/(lightAttenuations[i].x + (lightAttenuations[i].y * d) + (lightAttenuations[i].z *d *d));\n\
1896 /* diffuse light computation */\n\
1897 diffuse += nDotL* matdiffuse*myLightDiffuse * attenuation;\n\
1898 /* ambient light computation */\n\
1899 ambient += myMat.ambient*myLightAmbient;\n\
1900 /* specular light computation */\n\
1901 attenuation *= (myMat.shininess/128.0);\n\
1902 specular += myLightSpecular * powerFactor * attenuation;\n\
1907 return clamp(vec4(vec3(ambient+diffuse+specular+emissive),myAlph), 0.0, 1.0);\n\
1918#if defined (GL_ES_VERSION_2_0)
1919 static const GLchar *fragHighPrecision =
"precision highp float;\n ";
1920 static const GLchar *fragMediumPrecision =
"precision mediump float;\n ";
1921 static const GLchar *maxLights = STR_MAX_LIGHTS;
1923 static const GLchar *maxLights = STR_MAX_LIGHTS;
1943static const GLchar *fragMainStart =
"void main() { vec4 finalFrag = vec4(1.,1.,1.,1.);\n";
1944static const GLchar *anaglyphGrayFragEnd =
"float gray = dot(finalFrag.rgb, vec3(0.299, 0.587, 0.114)); \n \
1945 gl_FragColor = vec4(gray, gray, gray, finalFrag.a);}";
1951static const GLchar *discardInFragEnd =
"if (finalFrag.a==0.0) {discard; } else {gl_FragColor = finalFrag;}}";
1952static const GLchar *fragEnd =
"gl_FragColor = finalFrag;}";
1955static const GLchar *fragTex0Dec =
"uniform sampler2D fw_Texture_unit0; \n";
1956static const GLchar *fragTex0CubeDec =
"uniform samplerCube fw_Texture_unit0; \n";
1960static const GLchar *fragSimColAss =
"finalFrag = v_front_colour * finalFrag;\n ";
1961static const GLchar *fragNoAppAss =
"finalFrag = vec4(1.0, 1.0, 1.0, 1.0);\n";
1962static const GLchar *fragFrontColAss=
" finalFrag = v_front_colour * finalFrag;";
1963const static GLchar *fragADSLAss =
"finalFrag = ADSLightModel(vertexNorm,vertexPos,true) * finalFrag;";
1964const static GLchar *vertADSLCalc =
"v_front_colour = ADSLightModel(vertexNorm,vertexPos,true);";
1965const static GLchar *vertADSLCalc0 =
"v_front_colour = ADSLightModel(vertexNorm,vertexPos,false);";
1967const static GLchar *fragSingTexAss =
"finalFrag = texture2D(fw_Texture_unit0, fw_TexCoord[0].st) * finalFrag;\n";
1968const static GLchar *fragSingTexCubeAss =
"finalFrag = textureCube(fw_Texture_unit0, fw_TexCoord[0]) * finalFrag;\n";
1982const static GLchar *fragMultiTexDef = MULTITEXTUREDefs;
1984static const GLchar *fragMultiTexUniforms =
" \
1985/* defined for single textures... uniform sampler2D fw_Texture_unit0; */\
1986uniform sampler2D fw_Texture_unit1; \
1987uniform sampler2D fw_Texture_unit2; \
1988/* REMOVE these as shader compile takes long \
1989uniform sampler2D fw_Texture_unit3; \
1990uniform sampler2D fw_Texture_unit4; \
1991uniform sampler2D fw_Texture_unit5; \
1992uniform sampler2D fw_Texture_unit6; \
1993uniform sampler2D fw_Texture_unit7; \
1995uniform int fw_Texture_mode0; \
1996uniform int fw_Texture_mode1; \
1997uniform int fw_Texture_mode2; \
1998/* REMOVE these as shader compile takes long \
1999uniform int fw_Texture_mode3; \
2000uniform int fw_Texture_mode4; \
2001uniform int fw_Texture_mode5; \
2002uniform int fw_Texture_mode6; \
2003uniform int fw_Texture_mode7; \
2006uniform int textureCount;\n";
2008static const GLchar *fragFillPropFunc =
"\
2009vec4 fillPropCalc(in vec4 prevColour, vec2 MCposition, int algorithm) {\
2011vec2 position, useBrick; \
2013position = MCposition / HatchScale; \
2015if (algorithm == 0) {/* bricking */ \
2016 if (fract(position.y * 0.5) > 0.5) \
2017 position.x += 0.5; \
2020/* algorithm 1, 2 = no futzing required here */ \
2021if (algorithm == 3) {/* positive diagonals */ \
2022 vec2 curpos = position; \
2023 position.x -= curpos.y; \
2026if (algorithm == 4) {/* negative diagonals */ \
2027 vec2 curpos = position; \
2028 position.x += curpos.y; \
2031if (algorithm == 6) {/* diagonal crosshatch */ \
2032 vec2 curpos = position; \
2033 if (fract(position.y) > 0.5) { \
2034 if (fract(position.x) < 0.5) position.x += curpos.y; \
2035 else position.x -= curpos.y; \
2037 if (fract(position.x) > 0.5) position.x += curpos.y; \
2038 else position.x -= curpos.y; \
2042position = fract(position); \
2044useBrick = step(position, HatchPct); \
2046 if (filled) {colour = prevColour;} else { colour=vec4(0.,0.,0.,0); }\
2048 colour = mix(HatchColour, colour, useBrick.x * useBrick.y); \
2052static const GLchar *fragFillPropCalc =
"\
2053finalFrag= fillPropCalc(finalFrag, hatchPosition, algorithm);\n";
2055static const GLchar *fragMulTexFunc =
"\
2056vec4 finalColCalc(in vec4 prevColour, in int mode, in sampler2D tex, in vec2 texcoord) { \
2057vec4 texel = texture2D(tex,texcoord); \
2058vec4 rv = vec4(1.,0.,1.,1.); \
2060if (mode==MTMODE_OFF) { rv = vec4(prevColour);} \
2061else if (mode==MTMODE_REPLACE) {rv = vec4(texture2D(tex, texcoord));}\
2062else if (mode==MTMODE_MODULATE) { \
2067cf = prevColour.rgb; \
2074rv = vec4(ct*cf, at*af); \
2077else if (mode==MTMODE_MODULATE2X) { \
2081cf = prevColour.rgb; \
2086rv = vec4(vec4(ct*cf, at*af)*vec4(2.,2.,2.,2.)); \
2088else if (mode==MTMODE_MODULATE4X) { \
2092cf = prevColour.rgb; \
2097rv = vec4(vec4(ct*cf, at*af)*vec4(4.,4.,4.,4.)); \
2099else if (mode== MTMODE_ADDSIGNED) {\
2100rv = vec4 (prevColour + texel - vec4 (0.5, 0.5, 0.5, -.5)); \
2102else if (mode== MTMODE_ADDSIGNED2X) {\
2103rv = vec4 ((prevColour + texel - vec4 (0.5, 0.5, 0.5, -.5))*vec4(2.,2.,2.,2.)); \
2105else if (mode== MTMODE_ADD) {\
2106rv= vec4 (prevColour + texel); \
2108else if (mode== MTMODE_SUBTRACT) {\
2109rv = vec4 (prevColour - texel); \
2111else if (mode==MTMODE_ADDSMOOTH) { \
2112rv = vec4 (prevColour + (prevColour - vec4 (1.,1.,1.,1.)) * texel); \
2118const static GLchar *fragMulTexCalc =
"\
2119if(textureCount>=1) {finalFrag=finalColCalc(finalFrag,fw_Texture_mode0,fw_Texture_unit0,fw_TexCoord[0].st);} \n\
2120if(textureCount>=2) {finalFrag=finalColCalc(finalFrag,fw_Texture_mode1,fw_Texture_unit1,fw_TexCoord[0].st);} \n\
2121if(textureCount>=3) {finalFrag=finalColCalc(finalFrag,fw_Texture_mode2,fw_Texture_unit2,fw_TexCoord[0].st);} \n\
2122/* REMOVE these as shader compile takes long \
2123if(textureCount>=4) {finalFrag=finalColCalc(finalFrag,fw_Texture_mode3,fw_Texture_unit3,fw_TexCoord[0].st);} \n\
2124if(textureCount>=5) {finalFrag=finalColCalc(finalFrag,fw_Texture_mode4,fw_Texture_unit4,fw_TexCoord[0].st);} \n\
2125if(textureCount>=6) {finalFrag=finalColCalc(finalFrag,fw_Texture_mode5,fw_Texture_unit5,fw_TexCoord[0].st);} \n\
2126if(textureCount>=7) {finalFrag=finalColCalc(finalFrag,fw_Texture_mode6,fw_Texture_unit6,fw_TexCoord[0].st);} \n\
2127if(textureCount>=8) {finalFrag=finalColCalc(finalFrag,fw_Texture_mode7,fw_Texture_unit7,fw_TexCoord[0].st);} \n\
2133const static GLchar *pointSizeDeclare=
"uniform float pointSize;\n";
2134const static GLchar *pointSizeAss=
"gl_PointSize = pointSize; \n";
2137static int getSpecificShaderSourceOriginal (
const GLchar *vertexSource[vertexEndMarker],
2141 bool didADSLmaterial;
2142#ifdef USING_SHADER_LIGHT_ARRAY_METHOD
2144 const GLchar *lightDefines0 = lightDefinesArrayMethod;
2145 const GLchar *ADSLLightModel0 = ADSLLightModelArrayMethod;
2147 const GLchar *lightDefines0 = lightDefines;
2148 const GLchar *ADSLLightModel0 = ADSLLightModel;
2155#if defined (GL_ES_VERSION_2_0)
2156 bool haveHighPrecisionFragmentShaders =
false;
2158#ifdef VARY_VERTEX_PRECISION
2159 bool haveHighPrecisionVertexShaders =
false;
2162 GLint range[2]; GLint precision;
2165 if (DESIRE(whichOne.base,SHADINGSTYLE_PHONG)) {
2166 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_HIGH_FLOAT, range, &precision);
2168 haveHighPrecisionFragmentShaders=
true;
2170 haveHighPrecisionFragmentShaders=
false;
2171 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_MEDIUM_FLOAT, range, &precision);
2172 if (precision == 0) {
2173 ConsoleMessage(
"low precision Fragment shaders only available - view may not work so well");
2176#ifdef VARY_VERTEX_PRECISION
2179 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_HIGH_FLOAT, range, &precision);
2181 haveHighPrecisionVertexShaders=
true;
2183 haveHighPrecisionVertexShaders=
false;
2184 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_MEDIUM_FLOAT, range, &precision);
2185 if (precision == 0) {
2186 ConsoleMessage(
"low precision Vertex shaders only available - view may not work so well");
2196 #if defined (VERBOSE) && defined (GL_ES_VERSION_2_0)
2200 glGetBooleanv(GL_SHADER_COMPILER,&b);
2201 if (b) ConsoleMessage(
"have shader compiler");
else ConsoleMessage(
"NO SHADER COMPILER");
2204 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_LOW_FLOAT, range, &precision);
2205 ConsoleMessage (
"GL_VERTEX_SHADER, GL_LOW_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
2206 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_MEDIUM_FLOAT, range, &precision);
2207 ConsoleMessage (
"GL_VERTEX_SHADER, GL_MEDIUM_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
2208 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_HIGH_FLOAT, range, &precision);
2209 ConsoleMessage (
"GL_VERTEX_SHADER, GL_HIGH_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
2211 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_LOW_INT, range, &precision);
2212 ConsoleMessage (
"GL_VERTEX_SHADER, GL_LOW_INT range [%d,%d],precision %d",range[0],range[1],precision);
2213 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_MEDIUM_INT, range, &precision);
2214 ConsoleMessage (
"GL_VERTEX_SHADER, GL_MEDIUM_INT range [%d,%d],precision %d",range[0],range[1],precision);
2215 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_HIGH_INT, range, &precision);
2216 ConsoleMessage (
"GL_VERTEX_SHADER, GL_HIGH_INT range [%d,%d],precision %d",range[0],range[1],precision);
2218 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_LOW_FLOAT, range, &precision);
2219 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_LOW_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
2220 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_MEDIUM_FLOAT, range, &precision);
2221 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_MEDIUM_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
2222 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_HIGH_FLOAT, range, &precision);
2223 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_HIGH_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
2225 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_LOW_INT, range, &precision);
2226 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_LOW_INT range [%d,%d],precision %d",range[0],range[1],precision);
2227 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_MEDIUM_INT, range, &precision);
2228 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_MEDIUM_INT range [%d,%d],precision %d",range[0],range[1],precision);
2229 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_HIGH_INT, range, &precision);
2230 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_HIGH_INT range [%d,%d],precision %d",range[0],range[1],precision);
2235 if DESIRE(whichOne.base,NO_APPEARANCE_SHADER) ConsoleMessage (
"want NO_APPEARANCE_SHADER");
2236 if DESIRE(whichOne.base,MATERIAL_APPEARANCE_SHADER) ConsoleMessage (
"want MATERIAL_APPEARANCE_SHADER");
2237 if DESIRE(whichOne.base,TWO_MATERIAL_APPEARANCE_SHADER) ConsoleMessage (
"want TWO_MATERIAL_APPEARANCE_SHADER");
2238 if DESIRE(whichOne.base,ONE_TEX_APPEARANCE_SHADER)ConsoleMessage(
"want ONE_TEX_APPEARANCE_SHADER");
2239 if DESIRE(whichOne.base,MULTI_TEX_APPEARANCE_SHADER)ConsoleMessage(
"want MULTI_TEX_APPEARANCE_SHADER");
2240 if DESIRE(whichOne.base,COLOUR_MATERIAL_SHADER)ConsoleMessage(
"want COLOUR_MATERIAL_SHADER");
2241 if DESIRE(whichOne.base,FILL_PROPERTIES_SHADER)ConsoleMessage(
"want FILL_PROPERTIES_SHADER");
2242 if DESIRE(whichOne.base,HAVE_LINEPOINTS_COLOR)ConsoleMessage (
"want LINE_POINTS_COLOR");
2243 if DESIRE(whichOne.base,HAVE_LINEPOINTS_APPEARANCE)ConsoleMessage (
"want LINE_POINTS_APPEARANCE");
2244 if DESIRE(whichOne.base,HAVE_TEXTURECOORDINATEGENERATOR) ConsoleMessage (
"want HAVE_TEXTURECOORDINATEGENERATOR");
2245 if DESIRE(whichOne.base,HAVE_CUBEMAP_TEXTURE) ConsoleMessage (
"want HAVE_CUBEMAP_TEXTURE");
2251#if defined(GL_ES_VERSION_2_0)
2252 fragmentSource[fragmentGLSLVersion] =
"#version 100\n";
2253 vertexSource[vertexGLSLVersion] =
"#version 100\n";
2254 if (haveHighPrecisionFragmentShaders) {
2255 fragmentSource[fragmentPrecisionDeclare] = fragHighPrecision;
2258 fragmentSource[fragmentPrecisionDeclare] = fragMediumPrecision;
2262#ifdef VARY_VERTEX_PRECISION
2264 if (haveHighPrecisionVertexShaders) {
2265 vertexSource[vertexPrecisionDeclare] = fragHighPrecision;
2266 ConsoleMessage(
"have high precision vertex shaders");
2268 vertexSource[vertexPrecisionDeclare] = fragMediumPrecision;
2269 ConsoleMessage(
"have medium precision vertex shaders");
2275 fragmentSource[fragmentGLSLVersion] =
"#version 120\n";
2276 vertexSource[vertexGLSLVersion] =
"#version 120\n";
2279 fragmentSource[fragMaxLightsDeclare] = maxLights;
2280 vertexSource[vertMaxLightsDeclare] = maxLights;
2281 vertexSource[vertexPositionDeclare] = vertPosDec;
2287 if (!whichOne.usershaders) {
2294 vertexSource[vertexMainStart] = vertMainStart;
2295 vertexSource[vertexPositionCalculation] = vertPos;
2296 vertexSource[vertexMainEnd] = vertEnd;
2299 fragmentSource[fragmentMainStart] = fragMainStart;
2300 if(Viewer()->anaglyph || Viewer()->anaglyphB)
2301 fragmentSource[fragmentMainEnd] = anaglyphGrayFragEnd;
2303 if (DESIRE(whichOne.base,SHADINGSTYLE_PHONG)) fragmentSource[fragmentMainEnd] = discardInFragEnd;
2304 else fragmentSource[fragmentMainEnd] = fragEnd;
2313 if DESIRE(whichOne.base,COLOUR_MATERIAL_SHADER) {
2314 vertexSource[vertexSimpleColourDeclare] = vertSimColDec;
2315 vertexSource[vertFrontColourDeclare] = varyingFrontColour;
2316 vertexSource[vertexSimpleColourCalculation] = vertSimColUse;
2317 vertexSource[vertexPointSizeDeclare] = pointSizeDeclare;
2318 vertexSource[vertexPointSizeAssign] = pointSizeAss;
2319 fragmentSource[fragmentSimpleColourDeclare] = varyingFrontColour;
2320 fragmentSource[fragmentSimpleColourAssign] = fragSimColAss;
2323 if DESIRE(whichOne.base,NO_APPEARANCE_SHADER) {
2324 fragmentSource[fragmentSimpleColourAssign] = fragNoAppAss;
2325 vertexSource[vertexPointSizeDeclare] = pointSizeDeclare;
2326 vertexSource[vertexPointSizeAssign] = pointSizeAss;
2334 if (DESIRE(whichOne.base,SHADINGSTYLE_PHONG)) {
2335 doThis = (DESIRE(whichOne.base,MATERIAL_APPEARANCE_SHADER)) ||
2336 (DESIRE(whichOne.base,TWO_MATERIAL_APPEARANCE_SHADER));
2338 doThis = DESIRE(whichOne.base,TWO_MATERIAL_APPEARANCE_SHADER);
2342 vertexSource[vertexNormPosOutput] = varyingNormPos;
2343 vertexSource[vertexNormalDeclare] = vertNormDec;
2344 vertexSource[vertexNormPosCalculation] = vertNormPosCalc;
2346 fragmentSource[fragmentLightDefines] = lightDefines0;
2347 fragmentSource[fragmentOneColourDeclare] = vertOneMatDec;
2348 fragmentSource[fragmentBackColourDeclare] = vertBackMatDec;
2349 fragmentSource[fragmentNormPosDeclare] = varyingNormPos;
2350 fragmentSource[fragmentADSLLightModel] = ADSLLightModel0;
2351 fragmentSource[fragmentADSLAssign] = fragADSLAss;
2358 didADSLmaterial =
false;
2359 if((DESIRE(whichOne.base,MATERIAL_APPEARANCE_SHADER)) && (!DESIRE(whichOne.base,SHADINGSTYLE_PHONG))) {
2360 vertexSource[vertexNormalDeclare] = vertNormDec;
2361 vertexSource[vertexLightDefines] = lightDefines0;
2362 vertexSource[vertexOneMaterialDeclare] = vertOneMatDec;
2363 vertexSource[vertFrontColourDeclare] = varyingFrontColour;
2364 vertexSource[vertexNormPosCalculation] = vertNormPosCalc;
2365 vertexSource[vertexNormPosOutput] = vecNormPos;
2366 vertexSource[vertexLightingEquation] = ADSLLightModel0;
2367 vertexSource[vertexBackMaterialDeclare] = vertBackMatDec;
2368 vertexSource[vertexADSLCalculation] = vertADSLCalc;
2369 didADSLmaterial =
true;
2370 fragmentSource[fragmentOneColourDeclare] = varyingFrontColour;
2371 fragmentSource[fragmentOneColourAssign] = fragFrontColAss;
2373 vertexSource[vertexProjValDec] = vertProjValDec;
2374 vertexSource[vertexProjCalTexCoord] = vertProjCalTexCoord;
2375 vertexSource[vertexProjTexCalculation] = vertProjTexCalculation;
2377 fragmentSource[fragmentTex0Declare] = fragTex0Dec;
2378 fragmentSource[fragmentProjValDec] = fragProjValDec;
2379 fragmentSource[fragmentProjCalTexCoord] = fragProjCalTexCoord;
2380 fragmentSource[fragmentProjTexAssign] = fragProjTexCalculation;
2385 if DESIRE(whichOne.base,HAVE_LINEPOINTS_APPEARANCE) {
2386 vertexSource[vertexLightDefines] = lightDefines0;
2387 vertexSource[vertFrontColourDeclare] = varyingFrontColour;
2388 vertexSource[vertexOneMaterialDeclare] = vertOneMatDec;
2390 #if defined (GL_ES_VERSION_2_0)
2391 vertexSource[vertexPointSizeDeclare] = pointSizeDeclare;
2392 vertexSource[vertexPointSizeAssign] = pointSizeAss;
2395 vertexSource[vertexOneMaterialCalculation] = vertEmissionOnlyColourAss;
2396 fragmentSource[fragmentSimpleColourDeclare] = varyingFrontColour;
2397 fragmentSource[fragmentSimpleColourAssign] = fragSimColAss;
2402 if (DESIRE(whichOne.base,ONE_TEX_APPEARANCE_SHADER) ||
2403 DESIRE(whichOne.base,HAVE_TEXTURECOORDINATEGENERATOR) ||
2404 DESIRE(whichOne.base,HAVE_CUBEMAP_TEXTURE) ||
2405 DESIRE(whichOne.base,MULTI_TEX_APPEARANCE_SHADER)) {
2407 ttglobal tg = gglobal();
2410 vertexSource[vertexTexCoordInputDeclare] = vertTexCoordDec;
2411 vertexSource[vertexTexCoordOutputDeclare] = varyingTexCoord;
2412 vertexSource[vertexTextureMatrixDeclare] = vertTexMatrixDec;
2413 vertexSource[vertexSingleTextureCalculation] = vertSingTexCalc;
2415 vertexSource[vertexADSLCalculation] = vertADSLCalc0;
2417 fragmentSource[fragmentTexCoordDeclare] = varyingTexCoord;
2418 fragmentSource[fragmentTex0Declare] = fragTex0Dec;
2439 fragmentSource[fragmentTextureAssign] = fragSingTexAss;
2444 if (DESIRE(whichOne.base,HAVE_CUBEMAP_TEXTURE)) {
2445 vertexSource[vertexSingleTextureCalculation] = vertSingTexCubeCalc;
2447 fragmentSource[fragmentTex0Declare] = fragTex0CubeDec;
2448 fragmentSource[fragmentTextureAssign] = fragSingTexCubeAss;
2452 if DESIRE(whichOne.base,MULTI_TEX_APPEARANCE_SHADER) {
2456 vertexSource[vertexOneMaterialDeclare] = vertOneMatDec;
2457 vertexSource[vertexLightDefines] = lightDefines0;
2458 vertexSource[vertexNormPosCalculation] = vertNormPosCalc;
2459 vertexSource[vertexNormPosOutput] = vecNormPos;
2460 vertexSource[vertexLightingEquation] = ADSLLightModel0;
2461 vertexSource[vertexBackMaterialDeclare] = vertBackMatDec;
2463 fragmentSource[fragmentMultiTexDefines]= fragMultiTexUniforms;
2464 fragmentSource[fragmentMultiTexDeclare] = fragMultiTexDef;
2465 fragmentSource[fragmentTex0Declare] = fragTex0Dec;
2466 fragmentSource[fragmentMultiTexModel] = fragMulTexFunc;
2467 fragmentSource[fragmentTextureAssign] = fragMulTexCalc;
2471 vertexSource[vertexMultiProjValDec] = vertMultiProjValDec;
2472 vertexSource[vertexMultiProjCalTexCoord] = vertMultiProjCalTexCoord;
2473 vertexSource[vertexMultiProjTexCalculation] = vertMultiProjTexCalculation;
2474 fragmentSource[fragmentMultiProjValDec] = fragMultiProjValDec;
2475 fragmentSource[fragmentMultiProjCalTexCoord] = fragMultiProjCalTexCoord;
2479 fragmentSource[fragmentTextureAssign] = fragMultiProjTexCalculation;
2484 if DESIRE(whichOne.base,HAVE_TEXTURECOORDINATEGENERATOR) {
2487 vertexSource[vertexTextureMatrixDeclare] = vertTexCoordGenDec;
2488 vertexSource[vertexSingleTextureCalculation] = sphEnvMapCalc;
2490 vertexSource[vertexTCGTDefines] = fragTCGTDefs;
2494 if DESIRE(whichOne.base,FILL_PROPERTIES_SHADER) {
2497 vertexSource[vertexHatchPositionDeclare] = varyingHatchPosition;
2498 vertexSource[vertexHatchPositionCalculation] = vertHatchPosCalc;
2500 fragmentSource[fragmentFillPropDefines] = fillPropDefines;
2501 fragmentSource[fragmentHatchPositionDeclare] = varyingHatchPosition;
2502 fragmentSource[fragmentFillPropModel] = fragFillPropFunc;
2503 fragmentSource[fragmentFillPropAssign] = fragFillPropCalc;
2508 if (whichOne.usershaders) {
2511 ttglobal tg = gglobal();
2512 p = (ppOpenGL_Utils)tg->OpenGL_Utils.prv;
2515 me = whichOne.usershaders;
2522 vertexSource[vertexMainStart] =
" \n \
2523uniform mat4 fw_ModelViewInverseMatrix; \n\
2524uniform mat4 fw_TextureMatrix[4]; \n\
2525uniform int nTexMatrix; \n\
2526uniform int nTexCoordChannels; \n\
2527#define HEADLIGHT_LIGHT 0\n \
2528#define gl_ModelViewInverseMatrix fw_ModelViewInverseMatrix \n\
2529#define ftransform() (fw_ProjectionMatrix*fw_ModelViewMatrix*fw_Vertex)\n \
2530#define gl_ModelViewProjectionMatrix (fw_ProjectionMatrix*fw_ModelViewMatrix)\n \
2531#define gl_NormalMatrix mat3(fw_NormalMatrix)\n \
2532#define gl_ProjectionMatrix fw_ProjectionMatrix \n\
2533#define gl_ModelViewMatrix fw_ModelViewMatrix \n\
2534#define gl_TextureMatrix fw_TextureMatrix \n\
2535#define gl_Vertex fw_Vertex \n \
2536#define gl_Normal fw_Normal\n \
2537#define gl_Texture_unit0 fw_Texture_unit0\n \
2538#define gl_MultiTexCoord0 vec2(fw_MultiTexCoord0)\n \
2539#define gl_Texture_unit1 fw_Texture_unit1\n \
2540#define gl_MultiTexCoord1 vec2(fw_MultiTexCoord1)\n \
2541#define gl_Texture_unit2 fw_Texture_unit2\n \
2542#define gl_MultiTexCoord2 vec2(fw_MultiTexCoord2)\n \
2543#define gl_LightSource fw_LightSource\n ";
2544 vertexSource[vertexTexCoordInputDeclare] = vertTexCoordDec;
2552 fragmentSource[fragmentMainStart] =
"\
2553#define HEADLIGHT_LIGHT 0\n \
2554#define gl_NormalMatrix mat3(fw_NormalMatrix)\n \
2555#define gl_Normal fw_Normal\n \
2556#define gl_LightSource fw_LightSource\n \
2557uniform sampler2D textureUnit[8];\n\
2558#define gl_Texture_unit0 textureUnit[0];\n\
2559uniform samplerCube textureUnitCube[8]; \n\
2565 vertexSource[vertexLightDefines] = lightDefines0;
2566 vertexSource[vertexSimpleColourDeclare] = vertSimColDec;
2567 vertexSource[vertFrontColourDeclare] = varyingFrontColour;
2571 vertexSource[vertexNormalDeclare] = vertNormDec;
2572 fragmentSource[fragmentLightDefines] = lightDefines0;
2575 if ((p->userDefinedVertexShader[me] == NULL) || (p->userDefinedFragmentShader[me]==NULL)) {
2576 ConsoleMessage (
"no Shader Source found for user defined shaders...");
2580 fragmentSource[fragmentUserDefinedInput] = p->userDefinedFragmentShader[me];
2581 vertexSource[vertexUserDefinedInput] = p->userDefinedVertexShader[me];
2590 vertexShaderResources_t x1;
2591 fragmentShaderResources_t x2;
2593 FILE* fp = fopen(
"C:/tmp/vertex_vc13.src",
"w+");
2594 ConsoleMessage (
"Vertex source:\n");
2595 fprintf(fp,
"Vertex source:\n");
2596 for (x1=vertexGLSLVersion; x1<vertexEndMarker; x1++) {
2597 if (strlen(vertexSource[x1])>0){
2598 ConsoleMessage(
"%s",vertexSource[x1]);
2599 fprintf(fp,
"%s",vertexSource[x1]);
2602 ConsoleMessage(
"Fragment Source:\n");
2603 fprintf(fp,
"Fragment Source:\n");
2605 for (x2=fragmentGLSLVersion; x2<fragmentEndMarker; x2++) {
2606 if (strlen(fragmentSource[x2])>0){
2607 ConsoleMessage(
"%s",fragmentSource[x2]);
2608 fprintf(fp,
"%s",fragmentSource[x2]);
2620int getSpecificShaderSourceCastlePlugs (
const GLchar **vertexSource,
const GLchar **fragmentSource,
shaderflagsstruct whichOne);
2621int getSpecificShaderSourceVolume (
const GLchar **vertexSource,
const GLchar **fragmentSource,
shaderflagsstruct whichOne);
2622int getSpecificShaderSourceDepth(
const GLchar** vertexSource,
const GLchar** fragmentSource,
shaderflagsstruct whichOne);
2623int getSpecificShaderSourceDebug(
const GLchar** vertexSource,
const GLchar** fragmentSource,
shaderflagsstruct whichOne);
2624static int getSpecificShaderSource (
const GLchar *vertexSource[vertexEndMarker],
const GLchar *fragmentSource[fragmentEndMarker],
2626 int iret, userDefined, usingCastlePlugs = 1;
2627 userDefined = whichOne.usershaders ? TRUE : FALSE;
2629 if(usingCastlePlugs && !userDefined) {
2632 iret = getSpecificShaderSourceDebug(vertexSource, fragmentSource, whichOne);
2633 else if (whichOne.depth)
2634 iret = getSpecificShaderSourceDepth(vertexSource, fragmentSource, whichOne);
2635 else if (whichOne.volume)
2636 iret = getSpecificShaderSourceVolume(vertexSource, fragmentSource, whichOne);
2638 iret = getSpecificShaderSourceCastlePlugs(vertexSource, fragmentSource, whichOne);
2640 iret = getSpecificShaderSourceOriginal(vertexSource, fragmentSource, whichOne);
2649 GLuint myVertexShader = 0;
2650 GLuint myFragmentShader= 0;
2653 s_shader_capabilities_t *myShader = me->myCapabilities;
2654 const GLchar *vertexSource[vertexEndMarker];
2655 const GLchar *fragmentSource[fragmentEndMarker];
2656 vertexShaderResources_t x1;
2657 fragmentShaderResources_t x2;
2660 ConsoleMessage (
"makeAndCompileShader called");
2665 for (x1=vertexGLSLVersion; x1<vertexEndMarker; x1++)
2666 vertexSource[x1] =
"";
2667 for (x2=fragmentGLSLVersion; x2<fragmentEndMarker; x2++)
2668 fragmentSource[x2] =
"";
2672 myProg = glCreateProgram();
2673 (*myShader).myShaderProgram = myProg;
2676 (*myShader).compiledOK = FALSE;
2679 if (!getSpecificShaderSource(vertexSource, fragmentSource, me->whichOne)) {
2683 myVertexShader = CREATE_SHADER (VERTEX_SHADER);
2684 SHADER_SOURCE(myVertexShader, vertexEndMarker, ((
const GLchar **)vertexSource), NULL);
2685 COMPILE_SHADER(myVertexShader);
2686 GET_SHADER_INFO(myVertexShader, COMPILE_STATUS, &success);
2688 shaderErrorLog(myVertexShader,
"VERTEX");
2691 ATTACH_SHADER(myProg, myVertexShader);
2695 myFragmentShader = CREATE_SHADER (FRAGMENT_SHADER);
2696 SHADER_SOURCE(myFragmentShader, fragmentEndMarker, (
const GLchar **) fragmentSource, NULL);
2697 COMPILE_SHADER(myFragmentShader);
2698 GET_SHADER_INFO(myFragmentShader, COMPILE_STATUS, &success);
2700 shaderErrorLog(myFragmentShader,
"FRAGMENT");
2702 ATTACH_SHADER(myProg, myFragmentShader);
2705 LINK_SHADER(myProg);
2707 glGetProgramiv(myProg,GL_LINK_STATUS, &success);
2710 memset(buffer, 0, 2048);
2712 glGetProgramInfoLog(myProg, 2047,&len,buffer);
2713 printf(
"SHADER PROGRAM ERROR: %s\n", buffer);
2714 if (strstr(buffer,
"error C5041")) {
2716 glGetIntegerv(GL_MAX_VERTEX_OUTPUT_COMPONENTS, &mvoc);
2717 printf(
"gl max vertex output components %d\n", mvoc);
2720 (*myShader).compiledOK = (success == GL_TRUE);
2721 getShaderCommonInterfaces(myShader);
2723static void getShaderCommonInterfaces (s_shader_capabilities_t *me) {
2724 ttglobal tg = gglobal();
2726 GLuint myProg = me->myShaderProgram;
2730 #ifdef SHADERVERBOSE
2739 printf (
"getShaderCommonInterfaces, I am program %d\n",myProg);
2741 if (glIsProgram(myProg))
2742 printf (
"getShaderCommonInterfaces, %d is a program\n",myProg);
2744 printf (
"hmmm - it is not a program!\n");
2745 glGetAttachedShaders(myProg,10,&count,shaders);
2746 printf (
"got %d attached shaders, they are: \n",count);
2747 for (i=0; i<count; i++) {
2750 printf (
"%d\n",shaders[i]);
2751 glGetShaderSource(shaders[i],3000,&len,sl);
2752 printf (
"len %d\n",len);
2753 printf (
"sl: %s\n",sl);
2755 glGetProgramiv(myProg,GL_INFO_LOG_LENGTH, xxx); printf (
"GL_INFO_LOG_LENGTH_STATUS %d\n",xxx[0]);
2756 glGetProgramiv(myProg,GL_LINK_STATUS, xxx); printf (
"GL_LINK_STATUS %d\n",xxx[0]);
2757 glGetProgramiv(myProg,GL_VALIDATE_STATUS, xxx); printf (
"GL_VALIDATE_STATUS %d\n",xxx[0]);
2758 glGetProgramiv(myProg,GL_ACTIVE_ATTRIBUTES, xxx); printf (
"GL_ACTIVE_ATTRIBUTES %d\n",xxx[0]);
2759 glGetProgramiv(myProg,GL_ACTIVE_UNIFORMS, xxx); printf (
"GL_ACTIVE_UNIFORMS %d\n",xxx[0]);
2761 glGetProgramiv(myProg,GL_INFO_LOG_LENGTH, xxx);
2763 #define MAX_INFO_LOG_SIZE 512
2764 GLchar infoLog[MAX_INFO_LOG_SIZE];
2765 glGetProgramInfoLog(myProg, MAX_INFO_LOG_SIZE, NULL, infoLog);
2766 printf (
"log: %s\n",infoLog);
2778 for(
int i=0;i<16;i++){
2781 sprintf(line,
"textureUnit[%d]",i);
2782 me->textureUnit[i] = GET_UNIFORM(myProg,line);
2784 for (
int i = 0; i < 8; i++) {
2787 sprintf(line,
"textureUnitCube[%d]", i);
2788 me->textureUnitCube[i] = GET_UNIFORM(myProg, line);
2790 me->myMaterialDiffuse = GET_UNIFORM(myProg,
"fw_FrontMaterial.diffuse");
2791 me->myMaterialEmissive = GET_UNIFORM(myProg,
"fw_FrontMaterial.emissive");
2792 me->myMaterialSpecular = GET_UNIFORM(myProg,
"fw_FrontMaterial.specular");
2793 me->myMaterialAmbient = GET_UNIFORM(myProg,
"fw_FrontMaterial.ambient");
2794 me->myMaterialShininess = GET_UNIFORM(myProg,
"fw_FrontMaterial.shininess");
2795 me->myMaterialOcclusion = GET_UNIFORM(myProg,
"fw_FrontMaterial.occlusion");
2796 me->myMaterialNormalScale = GET_UNIFORM(myProg,
"fw_FrontMaterial.normalScale");
2797 me->myMaterialTransparency = GET_UNIFORM(myProg,
"fw_FrontMaterial.transparency");
2798 me->myMaterialBaseColor = GET_UNIFORM(myProg,
"fw_FrontMaterial.baseColor");
2799 me->myMaterialMetallic = GET_UNIFORM(myProg,
"fw_FrontMaterial.metallic");
2800 me->myMaterialRoughness = GET_UNIFORM(myProg,
"fw_FrontMaterial.roughness");
2801 me->myMaterialType = GET_UNIFORM(myProg,
"fw_FrontMaterial.type");
2802 me->myMaterialTransdex = GET_UNIFORM(myProg,
"fw_FrontMaterial.transdex");
2803 me->myMaterialNt = GET_UNIFORM(myProg,
"fw_FrontMaterial.nt");
2804 for(
int i=0;i<10;i++){
2806 sprintf(line,
"fw_FrontMaterial.tindex[%d]",i);
2807 me->myMaterialTindex[i] = GET_UNIFORM(myProg,line);
2808 sprintf(line,
"fw_FrontMaterial.mode[%d]",i);
2809 me->myMaterialMode[i] = GET_UNIFORM(myProg,line);
2810 sprintf(line,
"fw_FrontMaterial.source[%d]",i);
2811 me->myMaterialSource[i] = GET_UNIFORM(myProg,line);
2812 sprintf(line,
"fw_FrontMaterial.func[%d]",i);
2813 me->myMaterialFunc[i] = GET_UNIFORM(myProg,line);
2814 sprintf(line,
"fw_FrontMaterial.cmap[%d]", i);
2815 me->myMaterialCmap[i] = GET_UNIFORM(myProg, line);
2819 for(
int i=0;i<7;i++){
2821 sprintf(line,
"fw_FrontMaterial.samplr[%d]", i);
2822 me->myMaterialSampler[i] = GET_UNIFORM(myProg, line);
2825 sprintf(line,
"fw_FrontMaterial.tstart[%d]",i);
2826 me->myMaterialTstart[i] = GET_UNIFORM(myProg,line);
2827 sprintf(line,
"fw_FrontMaterial.tcount[%d]",i);
2828 me->myMaterialTcount[i] = GET_UNIFORM(myProg,line);
2832 me->myMaterialBackDiffuse = GET_UNIFORM(myProg,
"fw_BackMaterial.diffuse");
2833 me->myMaterialBackEmissive = GET_UNIFORM(myProg,
"fw_BackMaterial.emissive");
2834 me->myMaterialBackSpecular = GET_UNIFORM(myProg,
"fw_BackMaterial.specular");
2835 me->myMaterialBackAmbient = GET_UNIFORM(myProg,
"fw_BackMaterial.ambient");
2836 me->myMaterialBackShininess = GET_UNIFORM(myProg,
"fw_BackMaterial.shininess");
2837 me->myMaterialBackOcclusion = GET_UNIFORM(myProg,
"fw_BackMaterial.occlusion");
2838 me->myMaterialBackNormalScale = GET_UNIFORM(myProg,
"fw_BackMaterial.normalScale");
2839 me->myMaterialBackTransparency = GET_UNIFORM(myProg,
"fw_BackMaterial.transparency");
2840 me->myMaterialBackBaseColor = GET_UNIFORM(myProg,
"fw_BackMaterial.baseColor");
2841 me->myMaterialBackMetallic = GET_UNIFORM(myProg,
"fw_BackMaterial.metallic");
2842 me->myMaterialBackRoughness = GET_UNIFORM(myProg,
"fw_BackMaterial.roughness");
2843 me->myMaterialBackType = GET_UNIFORM(myProg,
"fw_BackMaterial.type");
2844 me->myMaterialBackTransdex = GET_UNIFORM(myProg,
"fw_BackMaterial.transdex");
2845 me->myMaterialBackNt = GET_UNIFORM(myProg,
"fw_BackMaterial.nt");
2846 for(
int i=0;i<10;i++){
2848 sprintf(line,
"fw_BackMaterial.tindex[%d]",i);
2849 me->myMaterialBackTindex[i] = GET_UNIFORM(myProg,line);
2850 sprintf(line,
"fw_BackMaterial.mode[%d]",i);
2851 me->myMaterialBackMode[i] = GET_UNIFORM(myProg,line);
2852 sprintf(line,
"fw_BackMaterial.source[%d]",i);
2853 me->myMaterialBackSource[i] = GET_UNIFORM(myProg,line);
2854 sprintf(line,
"fw_BackMaterial.func[%d]",i);
2855 me->myMaterialBackFunc[i] = GET_UNIFORM(myProg,line);
2856 sprintf(line,
"fw_BackMaterial.cmap[%d]", i);
2857 me->myMaterialBackCmap[i] = GET_UNIFORM(myProg, line);
2859 for(
int i=0;i<7;i++){
2861 sprintf(line,
"fw_BackMaterial.samplr[%d]", i);
2862 me->myMaterialBackSampler[i] = GET_UNIFORM(myProg, line);
2865 sprintf(line,
"fw_BackMaterial.tstart[%d]",i);
2866 me->myMaterialBackTstart[i] = GET_UNIFORM(myProg,line);
2867 sprintf(line,
"fw_BackMaterial.tcount[%d]",i);
2868 me->myMaterialBackTcount[i] = GET_UNIFORM(myProg,line);
2874 me->lightcount = GET_UNIFORM(myProg,
"lightcount");
2906 char uniformName[100];
2907 me->haveLightInShader =
false;
2908#ifdef USING_SHADER_LIGHT_ARRAY_METHOD
2910 for (i = 0; i<MAX_LIGHTS; i++) {
2913 strcpy(uniformName,
"lightambient[0]");
2914 sndx = strstr(uniformName,
"[");
2916 me->lightAmbient[i] = GET_UNIFORM(myProg, uniformName);
2920 strcpy(uniformName,
"lightdiffuse[0]");
2921 sndx = strstr(uniformName,
"[");
2923 me->lightDiffuse[i] = GET_UNIFORM(myProg, uniformName);
2927 strcpy(uniformName,
"lightspecular[0]");
2928 sndx = strstr(uniformName,
"[");
2930 me->lightSpecular[i] = GET_UNIFORM(myProg, uniformName);
2934 strcpy(uniformName,
"lightposition[0]");
2935 sndx = strstr(uniformName,
"[");
2937 me->lightPosition[i] = GET_UNIFORM(myProg, uniformName);
2942 if (me->lightPosition[i] != -1) me->haveLightInShader =
true;
2944 strcpy(uniformName,
"lightspotDirection[0]");
2945 sndx = strstr(uniformName,
"[");
2947 me->lightSpotDir[i] = GET_UNIFORM(myProg, uniformName);
2951 strcpy(uniformName,
"lightspotExponent[0]");
2952 sndx = strstr(uniformName,
"[");
2954 me->lightSpotBeamWidth[i] = GET_UNIFORM(myProg, uniformName);
2958 strcpy(uniformName,
"lightspotCutoff[0]");
2959 sndx = strstr(uniformName,
"[");
2961 me->lightSpotCutoffAngle[i] = GET_UNIFORM(myProg, uniformName);
2965 strcpy(uniformName,
"lightAttenuations[0]");
2966 sndx = strstr(uniformName,
"[");
2968 me->lightAtten[i] = GET_UNIFORM(myProg, uniformName);
2970 strcpy(uniformName,
"lightRadius[0]");
2971 sndx = strstr(uniformName,
"[");
2973 me->lightRadius[i] = GET_UNIFORM(myProg, uniformName);
2979 strcpy(uniformName,
"fw_LightSource[0].");
2980 for (i=0; i<MAX_LIGHTS; i++) {
2982 uniformName[15] =
'0' + i;
2984 strcpy(&uniformName[18],
"ambient");
2987 me->lightAmbientIntensity[i] = GET_UNIFORM(myProg,uniformName);
2991 strcpy(&uniformName[18],
"color");
2992 me->lightColor[i] = GET_UNIFORM(myProg,uniformName);
2996 strcpy(&uniformName[18],
"intensity");
2997 me->lightIntensity[i] = GET_UNIFORM(myProg,uniformName);
3001 strcpy(&uniformName[18],
"location");
3002 me->lightLocation[i] = GET_UNIFORM(myProg,uniformName);
3007 if (me->lightLocation[i] != -1) me->haveLightInShader =
true;
3009 strcpy(&uniformName[18],
"direction");
3010 me->lightDirection[i] = GET_UNIFORM(myProg,uniformName);
3015 strcpy(&uniformName[18],
"spotBeamWidth");
3016 me->lightSpotBeamWidth[i] = GET_UNIFORM(myProg,uniformName);
3020 strcpy(&uniformName[18],
"spotCutoff");
3021 me->lightSpotCutoffAngle[i] = GET_UNIFORM(myProg,uniformName);
3025 strcpy(&uniformName[18],
"Attenuations");
3026 me->lightAtten[i] = GET_UNIFORM(myProg,uniformName);
3042 strcpy(&uniformName[18],
"lightRadius");
3043 me->lightRadius[i] = GET_UNIFORM(myProg,uniformName);
3046 strcpy(&uniformName[18],
"shadows");
3047 me->lightshadows[i] = GET_UNIFORM(myProg, uniformName);
3048 strcpy(&uniformName[18],
"shadowIntensity");
3049 me->lightshadowIntensity[i] = GET_UNIFORM(myProg, uniformName);
3050 strcpy(&uniformName[18],
"depthmap");
3051 me->lightdepthmap[i] = GET_UNIFORM(myProg, uniformName);
3062 strcpy(uniformName,
"lightType[0]");
3063 for (i = 0; i < MAX_LIGHTS; i++) {
3065 uniformName[10] =
'0' + i;
3066 me->lightType[i] = GET_UNIFORM(myProg, uniformName);
3068 strcpy(uniformName,
"lightMat[0]");
3069 for (i = 0; i < MAX_LIGHTS; i++) {
3071 uniformName[9] =
'0' + i;
3072 me->lightMat[i] = GET_UNIFORM(myProg, uniformName);
3079 me->ModelViewMatrix = GET_UNIFORM(myProg,
"fw_ModelViewMatrix");
3080 me->ProjectionMatrix = GET_UNIFORM(myProg,
"fw_ProjectionMatrix");
3081 me->NormalMatrix = GET_UNIFORM(myProg,
"fw_NormalMatrix");
3082 me->ModelViewInverseMatrix = GET_UNIFORM(myProg,
"fw_ModelViewInverseMatrix");
3084 me->TextureMatrix[0] = GET_UNIFORM(myProg,
"fw_TextureMatrix[0]");
3085 me->TextureMatrix[1] = GET_UNIFORM(myProg,
"fw_TextureMatrix[1]");
3086 me->TextureMatrix[2] = GET_UNIFORM(myProg,
"fw_TextureMatrix[2]");
3087 me->TextureMatrix[3] = GET_UNIFORM(myProg,
"fw_TextureMatrix[3]");
3088 me->tmap[0] = GET_UNIFORM(myProg,
"fw_tmap[0]");
3089 me->tmap[1] = GET_UNIFORM(myProg,
"fw_tmap[1]");
3090 me->tmap[2] = GET_UNIFORM(myProg,
"fw_tmap[2]");
3091 me->tmap[3] = GET_UNIFORM(myProg,
"fw_tmap[3]");
3092 me->tmap[4] = GET_UNIFORM(myProg,
"fw_tmap[4]");
3093 me->tmap[5] = GET_UNIFORM(myProg,
"fw_tmap[5]");
3095 me->tgen[0] = GET_UNIFORM(myProg,
"fw_tgen[0]");
3096 me->tgen[1] = GET_UNIFORM(myProg,
"fw_tgen[1]");
3097 me->tgen[2] = GET_UNIFORM(myProg,
"fw_tgen[2]");
3098 me->tgen[3] = GET_UNIFORM(myProg,
"fw_tgen[3]");
3099 me->tgen[4] = GET_UNIFORM(myProg,
"fw_tgen[4]");
3100 me->tgen[5] = GET_UNIFORM(myProg,
"fw_tgen[5]");
3102 me->parameter_n = GET_UNIFORM(myProg,
"fw_parameter_n");
3103 me->parameter[0] = GET_UNIFORM(myProg,
"fw_parameter[0]");
3104 me->parameter[1] = GET_UNIFORM(myProg,
"fw_parameter[1]");
3105 me->parameter[2] = GET_UNIFORM(myProg,
"fw_parameter[2]");
3106 me->parameter[3] = GET_UNIFORM(myProg,
"fw_parameter[3]");
3107 me->parameter[4] = GET_UNIFORM(myProg,
"fw_parameter[4]");
3108 me->parameter[5] = GET_UNIFORM(myProg,
"fw_parameter[5]");
3109 me->parameter[6] = GET_UNIFORM(myProg,
"fw_parameter[6]");
3111 me->cmap[0] = GET_UNIFORM(myProg,
"fw_cmap[0]");
3112 me->cmap[1] = GET_UNIFORM(myProg,
"fw_cmap[1]");
3113 me->cmap[2] = GET_UNIFORM(myProg,
"fw_cmap[2]");
3114 me->cmap[3] = GET_UNIFORM(myProg,
"fw_cmap[3]");
3115 me->cmap[4] = GET_UNIFORM(myProg,
"fw_cmap[4]");
3116 me->cmap[5] = GET_UNIFORM(myProg,
"fw_cmap[5]");
3117 me->ntexcombo = GET_UNIFORM(myProg,
"fw_ntexcombo");
3118 me->nTexMatrix = GET_UNIFORM(myProg,
"nTexMatrix");
3119 me->Vertices = GET_ATTRIB(myProg,
"fw_Vertex");
3120 me->nextVertex = GET_ATTRIB(myProg,
"a_nextVertex");
3121 me->prevVertex = GET_ATTRIB(myProg,
"a_prevVertex");
3122 me->Normals = GET_ATTRIB(myProg,
"fw_Normal");
3123 me->Colours = GET_ATTRIB(myProg,
"fw_Color");
3124 me->FogCoords = GET_ATTRIB(myProg,
"fw_FogCoords");
3125 me->Cindex = GET_ATTRIB(myProg,
"fw_Cindex");
3128 me->TexCoords[0] = GET_ATTRIB(myProg,
"fw_MultiTexCoord0");
3129 me->TexCoords[1] = GET_ATTRIB(myProg,
"fw_MultiTexCoord1");
3130 me->TexCoords[2] = GET_ATTRIB(myProg,
"fw_MultiTexCoord2");
3131 me->TexCoords[3] = GET_ATTRIB(myProg,
"fw_MultiTexCoord3");
3132 me->nTexCoordChannels = GET_UNIFORM(myProg,
"nTexCoordChannels");
3133 me->flipuv = GET_UNIFORM(myProg,
"flipuv");
3135 for (i=0; i<MAX_MULTITEXTURE; i++) {
3137 sprintf (line,
"fw_Texture_unit%d",i);
3138 me->TextureUnit[i]= GET_UNIFORM(myProg,line);
3139 sprintf (line,
"fw_Texture_mode%d",i);
3140 me->TextureMode[i] = GET_UNIFORM(myProg,line);
3141 sprintf (line,
"fw_Texture_source%d",i);
3142 me->TextureSource[i] = GET_UNIFORM(myProg,line);
3143 sprintf (line,
"fw_Texture_function%d",i);
3144 me->TextureFunction[i] = GET_UNIFORM(myProg,line);
3149 me->textureCount = GET_UNIFORM(myProg,
"textureCount");
3150 me->multitextureColor = GET_UNIFORM(myProg,
"mt_Color");
3154 me->tex3dTiles = GET_UNIFORM(myProg,
"tex3dTiles");
3155 me->tex3dUseVertex = GET_UNIFORM(myProg,
"tex3dUseVertex");
3156 me->magFilter = GET_UNIFORM(myProg,
"magFilter");
3157 me->repeatSTR = GET_UNIFORM(myProg,
"repeatSTR");
3161 me->pointSize = GET_UNIFORM(myProg,
"u_pointSize");
3162 me->pointAttenuation = GET_UNIFORM(myProg,
"u_pointAttenuation");
3163 me->pointRange = GET_UNIFORM(myProg,
"u_pointSizeRange");
3164 me->pointColorMode = GET_UNIFORM(myProg,
"u_pointColorMode");
3165 me->pointPosition = GET_UNIFORM(myProg,
"u_pointPosition");
3166 me->pointCPV = GET_UNIFORM(myProg,
"u_pointCPV");
3167 me->pointFogCoord = GET_UNIFORM(myProg,
"u_pointFogCoord");
3168 me->pointMethod = GET_UNIFORM(myProg,
"u_pointMethod");
3170 me->linetype = GET_UNIFORM(myProg,
"u_linetype");
3171 me->linewidth = GET_UNIFORM(myProg,
"u_linewidth");
3172 me->linestrip_start_style = GET_UNIFORM(myProg,
"u_linestrip_start_style");
3173 me->linestrip_end_style = GET_UNIFORM(myProg,
"u_linestrip_end_style");
3174 me->lineperiod = GET_UNIFORM(myProg,
"u_lineperiod");
3175 me->screenresolution = GET_UNIFORM(myProg,
"u_screenresolution");
3176 me->linetype_uv = GET_UNIFORM(myProg,
"u_linetype_uv");
3177 me->linetype_tse = GET_UNIFORM(myProg,
"u_linetype_tse");
3178 me->hatchColour = GET_UNIFORM(myProg,
"fillprops.HatchColour");
3181 me->filledBool = GET_UNIFORM(myProg,
"fillprops.filled");
3182 me->hatchedBool = GET_UNIFORM(myProg,
"fillprops.hatched");
3183 me->hatchAlgo = GET_UNIFORM(myProg,
"fillprops.HatchAlgo");
3185 me->fogColor = GET_UNIFORM(myProg,
"fw_fogparams.fogColor");
3186 me->fogvisibilityRange = GET_UNIFORM(myProg,
"fw_fogparams.visibilityRange");
3187 me->fogScale = GET_UNIFORM(myProg,
"fw_fogparams.fogScale");
3188 me->fogType = GET_UNIFORM(myProg,
"fw_fogparams.fogType");
3191 me->clipplanes = GET_UNIFORM(myProg,
"fw_clipplanes");
3192 me->nclipplanes = GET_UNIFORM(myProg,
"fw_nclipplanes");
3195 me->texCoordGenType = GET_UNIFORM(myProg,
"fw_textureCoordGenType");
3199 printf (
"shader uniforms: vertex %d normal %d modelview %d projection %d\n",
3200 me->Vertices, me->Normals, me->ModelViewMatrix, me->ProjectionMatrix);
3201 printf (
"hatchColour %d, hatchPercent %d",me->hatchColour, me->hatchPercent);
3207void calculateViewingSpeed(X3D_Viewer *);
3208static void handle_GeoLODRange(
struct X3D_GeoLOD *node) {
3214 getCurrentPosInModelB();
3216 cx =
viewer->currentPosInModel.x - node->__movedCoords.c[0];
3217 cy =
viewer->currentPosInModel.y - node->__movedCoords.c[1];
3218 cz =
viewer->currentPosInModel.z - node->__movedCoords.c[2];
3223 oldInRange = node->__inRange;
3226 if((cx*cx+cy*cy+cz*cz) > (node->range * node->range)) {
3227 node->__inRange = FALSE;
3229 node->__inRange = TRUE;
3233 if (oldInRange != node->__inRange) {
3236 if (node->__inRange) printf (
"TRUE: ");
else printf (
"FALSE: ");
3237 printf (
"range changed; level %d, comparing %lf:%lf:%lf and range %lf node %u\n",
3238 node->__level, cx,cy,cz, node->range, node);
3242 if (node->children.p == NULL) node->children.p=MALLOC(
struct X3D_Node **,
sizeof(
struct X3D_Node *) * 4);
3244 if (node->__inRange == TRUE) {
3246 printf (
"GeoLOD %u level %d, inRange set to FALSE, range %lf\n",node, node->__level, node->range);
3248 node->level_changed = 1;
3249 node->children.p[0] = node->__child1Node;
3250 node->children.p[1] = node->__child2Node;
3251 node->children.p[2] = node->__child3Node;
3252 node->children.p[3] = node->__child4Node;
3253 node->children.n = 4;
3256 printf (
"GeoLOD %u level %d, inRange set to TRUE range %lf\n",node, node->__level, node->range);
3258 node->level_changed = 0;
3259 node->children.n = 0;
3260 if( node->__rootUrl )
3262 node->children.p[0] = node->__rootUrl;
3263 node->children.n = 1;
3265 else if( node->rootNode.p && node->rootNode.p[0] )
3267 node->children.p[0] = node->rootNode.p[0];
3268 node->children.n = 1;
3271 MARK_EVENT(X3D_NODE(node), offsetof (
struct X3D_GeoLOD, level_changed));
3272 MARK_EVENT(X3D_NODE(node), offsetof (
struct X3D_GeoLOD, children));
3273 oldInRange = X3D_GEOLOD(node)->__inRange;
3279 update_node(X3D_NODE(node));
3286static struct depth_slice depth_slices_three [] = {
3298static int n_depth_slices = 1;
3299static int want_depth_slices = 0;
3300int iclamp(
int ival,
int istart,
int iend);
3301void fwl_set_depth_slices(
int nslices){
3302 want_depth_slices = iclamp(nslices,0,3);
3305int fwl_get_depth_slices(){
3306 return want_depth_slices;
3308static void calculateNearFarplanes(
struct X3D_Node *vpnode,
int layerid ){
3324 int previous_n, iwant;
3326 static int once = 0;
3327 X3D_Viewer *
viewer = ViewerByLayerId(layerid);
3328 viewer->nearPlane = DEFAULT_NEARPLANE;
3329 viewer->farPlane = DEFAULT_FARPLANE;
3331 iwant = fwl_get_depth_slices();
3332 previous_n = n_depth_slices;
3342 float scene_diameter;
3345 FW_GL_GETDOUBLEV(GL_MODELVIEW_MATRIX, MM);
3354 extent6f_copy(extent6,rn->_extent);
3355 extent6f_mattransform4d(extent6,extent6,MM);
3357 vecset3f(vpf,0.0f,0.0f,0.0f);
3358 extent6f_union_vec3f(extent6,vpf);
3359 scene_diameter = extent6f_get_maxradius(extent6) * 2.0;
3361 if(scene_diameter > 21000.0f ) n_depth_slices = 2;
3362 if(scene_diameter > 1.e9 ) n_depth_slices = 3;
3365 n_depth_slices = want_depth_slices;
3367 if(0)
if(!once || previous_n != n_depth_slices)
3368 ConsoleMessage(
"depth slices: %d \n",n_depth_slices);
3371void calculateViewingDistIfJustBound(
struct X3D_Node *vpnode,
int layerid ){
3372 if(Viewer()->doExamineModeDistanceCalculations){
3378 float scene_diameter, vpradius;
3380 float vpf[3], center[3], vpoffset[3];
3381 FW_GL_GETDOUBLEV(GL_MODELVIEW_MATRIX, MM);
3390 extent6f_copy(extent6,rn->_extent);
3391 extent6f_mattransform4d(extent6,extent6,MM);
3393 vecset3f(vpf,0.0f,0.0f,0.0f);
3394 extent6f_get_center3f(extent6,center);
3396 vecdif3f(vpoffset,center,vpf);
3397 scene_diameter = extent6f_get_maxradius(extent6) * 2.0;
3398 vpradius = veclength3f(vpoffset);
3400 Viewer()->Dist = vpradius;
3402 Viewer()->doExamineModeDistanceCalculations = FALSE;
3408int get_n_depth_slices(){
3409 return n_depth_slices;
3411void get_depth_slice(
int islice,
double *znear,
double *zfar){
3413 switch(n_depth_slices){
3416 *znear = depth_slices_one[islice].znear;
3417 *zfar = depth_slices_one[islice].zfar;
3420 *znear = depth_slices_two[1-islice].znear;
3421 *zfar = depth_slices_two[1-islice].zfar;
3424 *znear = depth_slices_three[2-islice].znear;
3425 *zfar = depth_slices_three[2-islice].zfar;
3430static void calculateNearFarplanes_OLD(
struct X3D_Node *vpnode,
int layerid ) {
3449 GLDOUBLE cfp = -DBL_MAX;
3450 GLDOUBLE cnp = DBL_MAX;
3452 bool doingGeoSpatial =
false;
3453 double bboxMovedCentreZ = 0.0;
3454 double bboxSphereRadius = 0.0;
3462 ttglobal tg = gglobal();
3463 X3D_Viewer *
viewer = ViewerByLayerId(layerid);
3469 printf (
"have a bound viewpoint... lets calculate our near/far planes from it \n");
3470 printf (
"we are currently at %4.2f %4.2f %4.2f\n",Viewer()->currentPosInModel.x, Viewer()->currentPosInModel.y, Viewer()->currentPosInModel.z);
3476 if ((vpnode->_nodeType != NODE_Viewpoint) &&
3477 (vpnode->_nodeType != NODE_OrthoViewpoint) &&
3478 (vpnode->_nodeType != NODE_GeoViewpoint)) {
3479 printf (
"can not do this node type yet %s, for cpf\n",stringNodeType(vpnode->_nodeType));
3480 viewer->nearPlane = DEFAULT_NEARPLANE;
3481 viewer->farPlane = DEFAULT_FARPLANE;
3482 viewer->backgroundPlane = DEFAULT_BACKGROUNDPLANE;
3486 if (vpnode->_nodeType == NODE_GeoViewpoint) {
3487 doingGeoSpatial =
true;
3491 viewer->nearPlane = DEFAULT_NEARPLANE;
3492 viewer->farPlane = DEFAULT_FARPLANE;
3493 viewer->backgroundPlane = DEFAULT_BACKGROUNDPLANE;
3494 if(doingGeoSpatial){
3495 viewer->nearPlane = 10000.0;
3496 viewer->farPlane = 2100000000.0;
3497 viewer->backgroundPlane = 2000000000.0;
3507 if (doingGeoSpatial) {
3508 if ((rn->EXTENT_MAX_X - rn->EXTENT_MIN_X) > bboxSphereRadius) {
3509 bboxSphereRadius = rn->EXTENT_MAX_X - rn->EXTENT_MIN_X;
3511 if ((rn->EXTENT_MAX_Y - rn->EXTENT_MIN_Y) > bboxSphereRadius) {
3512 bboxSphereRadius = rn->EXTENT_MAX_Y - rn->EXTENT_MIN_Y;
3514 if ((rn->EXTENT_MAX_Z - rn->EXTENT_MIN_Z) > bboxSphereRadius) {
3515 bboxSphereRadius = rn->EXTENT_MAX_Z - rn->EXTENT_MIN_Z;
3517 bboxSphereRadius /=2.0;
3521 ConsoleMessage (
"bboxSphereRadius %lf",bboxSphereRadius);
3527 FW_GL_GETDOUBLEV(GL_MODELVIEW_MATRIX, MM);
3530 printf (
"rootNode extents x: %4.2f %4.2f y:%4.2f %4.2f z: %4.2f %4.2f\n",rootNode()->EXTENT_MAX_X, rootNode()->EXTENT_MIN_X,rootNode()->EXTENT_MAX_Y, rootNode()->EXTENT_MIN_Y,rootNode()->EXTENT_MAX_Z, rootNode()->EXTENT_MIN_Z);
3534 moveAndRotateThisPoint(&bboxPoints[0], rn->EXTENT_MIN_X, rn->EXTENT_MIN_Y, rn->EXTENT_MIN_Z,MM);
3535 moveAndRotateThisPoint(&bboxPoints[1], rn->EXTENT_MIN_X, rn->EXTENT_MIN_Y, rn->EXTENT_MAX_Z,MM);
3536 moveAndRotateThisPoint(&bboxPoints[2], rn->EXTENT_MIN_X, rn->EXTENT_MAX_Y, rn->EXTENT_MIN_Z,MM);
3537 moveAndRotateThisPoint(&bboxPoints[3], rn->EXTENT_MIN_X, rn->EXTENT_MAX_Y, rn->EXTENT_MAX_Z,MM);
3538 moveAndRotateThisPoint(&bboxPoints[4], rn->EXTENT_MAX_X, rn->EXTENT_MIN_Y, rn->EXTENT_MIN_Z,MM);
3539 moveAndRotateThisPoint(&bboxPoints[5], rn->EXTENT_MAX_X, rn->EXTENT_MIN_Y, rn->EXTENT_MAX_Z,MM);
3540 moveAndRotateThisPoint(&bboxPoints[6], rn->EXTENT_MAX_X, rn->EXTENT_MAX_Y, rn->EXTENT_MIN_Z,MM);
3541 moveAndRotateThisPoint(&bboxPoints[7], rn->EXTENT_MAX_X, rn->EXTENT_MAX_Y, rn->EXTENT_MAX_Z,MM);
3545 static int done_once = 0;
3546 if(done_once)
return;
3548 bmin = bmax = bboxPoints[0].z;
3549 for (ci=0; ci<8; ci++) {
3550 bmin = min(bmin,bboxPoints[ci].z);
3551 bmax = max(bmax,bboxPoints[ci].z);
3553 viewer->nearPlane = max(.1,bmin);
3557 printf(
"\rnear %lf far %lf",
viewer->nearPlane,
viewer->farPlane);
3562 for (ci=0; ci<8; ci++) {
3563 bboxMovedCentreZ += bboxPoints[ci].z;
3567 printf (
"moved bbox node %d is %4.2f %4.2f %4.2f\n",ci,bboxPoints[ci].x, bboxPoints[ci].y, bboxPoints[ci].z);
3570 if (!doingGeoSpatial) {
3571 if (-(bboxPoints[ci].z) > cfp) cfp = -(bboxPoints[ci].z);
3572 if (-(bboxPoints[ci].z) < cnp) cnp = -(bboxPoints[ci].z);
3576 bboxMovedCentreZ /= 8.0;
3578 if (doingGeoSpatial) {
3579 cnp = -bboxMovedCentreZ - bboxSphereRadius;
3580 cfp = -bboxMovedCentreZ;
3585 ConsoleMessage (
"centre of bbox is %lf Z away",bboxMovedCentreZ);
3586 ConsoleMessage (
"bboxMovedCentreZ minus bboxRadius %lf",-bboxMovedCentreZ - bboxSphereRadius);
3594 if (cnp<DEFAULT_NEARPLANE) cnp = DEFAULT_NEARPLANE;
3596 if (cfp<1.0) cfp = 1.0;
3606 printf (
"cnp %lf cfp before leaving room for Background %lf\n",cnp,cfp);
3616 if ((cnp<1.0) && (vpnode->_nodeType == NODE_GeoViewpoint)) {
3618 cnp = Viewer()->currentPosInModel.z/16.0;
3620 ConsoleMessage (
"vp height %lf moved height %lf posinModel %f",X3D_GEOVIEWPOINT(vpnode)->position.c[2],
3621 X3D_GEOVIEWPOINT(vpnode)->__movedPosition.c[2],Viewer()->currentPosInModel.z);
3622 smooger ++;
if (smooger == 100) smooger = 0;
3635 if (vectorSize(getActiveBindableStacks(tg)->background)!= 0) {
3636 viewer->farPlane = max(cfp * 10.0,DEFAULT_FARPLANE);
3637 viewer->backgroundPlane = max(cfp*5.0,DEFAULT_BACKGROUNDPLANE);
3639 viewer->farPlane = max(cfp,DEFAULT_FARPLANE);
3640 viewer->backgroundPlane = max(cfp,DEFAULT_BACKGROUNDPLANE);
3646 viewer->farPlane = max(cfp,DEFAULT_FARPLANE);
3648 printf(
"\rnear %lf far %lf",
viewer->nearPlane,
viewer->farPlane);
3653 viewer->farPlane = DEFAULT_FARPLANE;
3655 printf(
"\rnear %lf far %lf",
viewer->nearPlane,
viewer->farPlane);
3662 if (vectorSize(getActiveBindableStacks(tg)->background)!= 0) {
3663 viewer->farPlane = cfp * 10.0;
3664 viewer->backgroundPlane = cfp*5.0;
3667 viewer->backgroundPlane = cfp;
3673void doglClearColor() {
3675 ttglobal tg = gglobal();
3676 p = (ppOpenGL_Utils)tg->OpenGL_Utils.prv;
3677 FW_GL_CLEAR_COLOR(p->cc_red, p->cc_green, p->cc_blue, p->cc_alpha);
3678 tg->OpenGL_Utils.cc_changed = FALSE;
3686void clear_shader_table()
3693 ttglobal tg = gglobal();
3694 p = (ppOpenGL_Utils)tg->OpenGL_Utils.prv;
3696 if (p->myShaderTable != NULL) {
3699 for (i=0; i<vectorSize(p->myShaderTable); i++) {
3711 void GLAPIENTRY MessageCallback( GLenum source,
3716 const GLchar* message,
3717 const void* userParam )
3720 if(severity == GL_DEBUG_SEVERITY_HIGH){
3721 fprintf( stderr,
"GL CALLBACK: %s type = 0x%x, severity = 0x%x, message = %s\n",
3722 ( type == GL_DEBUG_TYPE_ERROR ?
"** GL ERROR **" :
"" ),
3723 type, severity, message );
3724 printf(
"press enter:");
3729bool fwl_initialize_GL()
3731 char blankTexture[] = {0x40, 0x40, 0x40, 0xFF};
3734 ttglobal tg = gglobal();
3735 p = (ppOpenGL_Utils)tg->OpenGL_Utils.prv;
3737 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start 1");
3738 initialize_rdr_caps();
3740 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start 3");
3745#if defined(TARGET_X11) || defined(TARGET_MOTIF)
3755 glEnable ( GL_DEBUG_OUTPUT );
3756 glDebugMessageCallback( MessageCallback, 0 );
3759 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start 4");
3761 FW_GL_MATRIX_MODE(GL_PROJECTION);
3762 FW_GL_LOAD_IDENTITY();
3763 FW_GL_MATRIX_MODE(GL_MODELVIEW);
3765 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start 6");
3767 FW_GL_CLEAR_COLOR(p->cc_red, p->cc_green, p->cc_blue, p->cc_alpha);
3769 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start 7");
3771 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start 8");
3774 FW_GL_DEPTHFUNC(GL_LEQUAL);
3775 glEnable(GL_DEPTH_TEST);
3777 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start 9");
3779 gl_linewidth = gglobal()->Mainloop.gl_linewidth;
3785 #if defined (GL_ES_VERSION_2_0)
3786 #if defined (GL_PROGRAM_POINT_SIZE)
3787 glEnable(GL_PROGRAM_POINT_SIZE);
3789 #if defined (GL_PROGRAM_POINT_SIZE_EXT)
3790 glEnable(GL_PROGRAM_POINT_SIZE_EXT);
3793 glPointSize (gl_linewidth);
3796 glLineWidth(gl_linewidth);
3798 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start a");
3809 FW_GL_BLENDFUNC(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
3810 FW_GL_CLEAR(GL_COLOR_BUFFER_BIT);
3812 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start b");
3822 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start c1");
3826 CULL_FACE_INITIALIZE;
3828 FW_GL_PIXELSTOREI(GL_UNPACK_ALIGNMENT,1);
3829 FW_GL_PIXELSTOREI(GL_PACK_ALIGNMENT,1);
3831 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start c");
3835 FW_GL_GENTEXTURES (1,&tg->Textures.defaultBlankTexture);
3836 glBindTexture (GL_TEXTURE_2D, tg->Textures.defaultBlankTexture);
3837 FW_GL_TEXPARAMETERI( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
3838 FW_GL_TEXPARAMETERI( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
3839 FW_GL_TEXIMAGE2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, blankTexture);
3841 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start d");
3846 clear_shader_table();
3862ivec4 get_current_viewport();
3863void BackEndClearBuffer(
int which) {
3864 ivec4 vport = get_current_viewport();
3865 FW_GL_SCISSOR(vport.X,vport.Y,vport.W,vport.H);
3866 glEnable(GL_SCISSOR_TEST);
3868 FW_GL_CLEAR(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
3871 FW_GL_CLEAR(GL_DEPTH_BUFFER_BIT);
3874 glDisable(GL_SCISSOR_TEST);
3877void fw_glMatrixMode(GLint mode) {
3878 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
3880 p->whichMode = mode;
3882 printf (
"fw_glMatrixMode, projTOS %d, modTOS %d texvTOS %d\n",p->projectionviewTOS,p->modelviewTOS, p->textureviewTOS);
3884 switch (p->whichMode) {
3885 case GL_PROJECTION: printf (
"glMatrixMode(GL_PROJECTION)\n");
break;
3886 case GL_MODELVIEW: printf (
"glMatrixMode(GL_MODELVIEW)\n");
break;
3887 case GL_TEXTURE: printf (
"glMatrixMode(GL_TEXTURE)\n");
break;
3891 switch (p->whichMode) {
3892 case GL_PROJECTION: p->currentMatrix = (GLDOUBLE *) &p->FW_ProjectionView[p->projectionviewTOS];
break;
3893 case GL_MODELVIEW: p->currentMatrix = (GLDOUBLE *) &p->FW_ModelView[p->modelviewTOS];
break;
3894 case GL_TEXTURE: p->currentMatrix = (GLDOUBLE *) &p->FW_TextureView[p->textureviewTOS];
break;
3895 default: printf (
"invalid mode sent in it is %d, expected one of %d %d %d\n",p->whichMode, GL_PROJECTION,GL_MODELVIEW,GL_TEXTURE);
3900void fw_glLoadIdentity(
void) {
3901 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
3903 loadIdentityMatrix(p->currentMatrix);
3904 FW_GL_LOADMATRIX(p->currentMatrix);
3907MATRIX4* PushMat(
int a,
int *b,
int c, MATRIX4 *d){
3910 printf(
"stack overflow, depth %d whichmode %d\n", *b, a);
3913 memcpy((
void *)d[*b], (
void *)d[*b - 1],
sizeof(GLDOUBLE)* 16);
3918void printMaxStackUsed(){
3919 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
3920 ConsoleMessage(
"%25s %d\n",
"max modelview stack used", p->maxStackUsed);
3922void fw_glPushMatrix(
void) {
3923 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
3925 switch (p->whichMode) {
3926 case GL_PROJECTION: p->currentMatrix = *PushMat(GL_PROJECTION, &p->projectionviewTOS, MAX_SMALL_MATRIX_STACK, p->FW_ProjectionView);
break;
3927 case GL_MODELVIEW: p->currentMatrix = *PushMat(GL_MODELVIEW, &p->modelviewTOS, MAX_LARGE_MATRIX_STACK, p->FW_ModelView);
break;
3928 case GL_TEXTURE: p->currentMatrix = *PushMat(GL_TEXTURE, &p->textureviewTOS, MAX_SMALL_MATRIX_STACK, p->FW_TextureView);
break;
3929 default:printf(
"wrong mode in popMatrix\n");
3931 p->maxStackUsed = max(p->maxStackUsed, p->modelviewTOS);
3932 FW_GL_LOADMATRIX(p->currentMatrix);
3949MATRIX4 *PopMat(
int a,
int *b, MATRIX4 *c){
3953 printf(
"popMatrix, stack underflow, whichMode %d\n", a);
3957void fw_glPopMatrix(
void) {
3958 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
3960 switch (p->whichMode) {
3961 case GL_PROJECTION: p->currentMatrix = *PopMat(GL_PROJECTION, &p->projectionviewTOS, p->FW_ProjectionView);
break;
3962 case GL_MODELVIEW: p->currentMatrix = *PopMat(GL_MODELVIEW, &p->modelviewTOS, p->FW_ModelView);
break;
3963 case GL_TEXTURE: p->currentMatrix = *PopMat(GL_TEXTURE, &p->textureviewTOS, p->FW_TextureView);
break;
3965 default: printf (
"wrong mode in popMatrix\n");
3968 FW_GL_LOADMATRIX(p->currentMatrix);
3984void fw_glTransformd(GLDOUBLE *mat) {
3985 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
3989 matmultiplyAFFINE(p->currentMatrix,mat,p->currentMatrix);
3990 FW_GL_LOADMATRIX(p->currentMatrix);
3993void fw_glTranslated(GLDOUBLE x, GLDOUBLE y, GLDOUBLE z) {
3994 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
3999 p->currentMatrix[12] = p->currentMatrix[0] * x + p->currentMatrix[4] * y + p->currentMatrix[8] * z + p->currentMatrix[12];
4000 p->currentMatrix[13] = p->currentMatrix[1] * x + p->currentMatrix[5] * y + p->currentMatrix[9] * z + p->currentMatrix[13];
4001 p->currentMatrix[14] = p->currentMatrix[2] * x + p->currentMatrix[6] * y + p->currentMatrix[10] * z + p->currentMatrix[14];
4002 p->currentMatrix[15] = p->currentMatrix[3] * x + p->currentMatrix[7] * y + p->currentMatrix[11] * z + p->currentMatrix[15];
4004 FW_GL_LOADMATRIX(p->currentMatrix);
4007void fw_glTranslatef(
float x,
float y,
float z) {
4008 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
4011 p->currentMatrix[12] = p->currentMatrix[0] * x + p->currentMatrix[4] * y + p->currentMatrix[8] * z + p->currentMatrix[12];
4012 p->currentMatrix[13] = p->currentMatrix[1] * x + p->currentMatrix[5] * y + p->currentMatrix[9] * z + p->currentMatrix[13];
4013 p->currentMatrix[14] = p->currentMatrix[2] * x + p->currentMatrix[6] * y + p->currentMatrix[10] * z + p->currentMatrix[14];
4014 p->currentMatrix[15] = p->currentMatrix[3] * x + p->currentMatrix[7] * y + p->currentMatrix[11] * z + p->currentMatrix[15];
4016 FW_GL_LOADMATRIX(p->currentMatrix);
4020void fw_glMultMatrixd (GLDOUBLE *mat) {
4021 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
4023 matmultiplyFULL(p->currentMatrix,mat,p->currentMatrix);
4028void fw_glRotateRad (GLDOUBLE angle, GLDOUBLE x, GLDOUBLE y, GLDOUBLE z) {
4031 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
4035 loadIdentityMatrix (myMat);
4038 mag = x*x + y*y + z*z;
4041 if (APPROX(mag,0.00)) {
4046 if (APPROX(angle,0.0)) {
4050 if (!APPROX(mag,1.0)) {
4052 in.x = x; in.y = y, in.z = z;
4053 vecnormal(&out,&in);
4054 x = out.x; y = out.y; z = out.z;
4059 matrotate(myMat,angle,x,y,z);
4063 matmultiplyAFFINE(p->currentMatrix,myMat,p->currentMatrix);
4067 FW_GL_LOADMATRIX(p->currentMatrix);
4071void fw_glRotated (GLDOUBLE angle, GLDOUBLE x, GLDOUBLE y, GLDOUBLE z) {
4075 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
4079 radAng = angle * 3.1415926536/ 180.0;
4081 loadIdentityMatrix (myMat);
4084 mag = x*x + y*y + z*z;
4087 if (APPROX(mag,0.00)) {
4092 if (APPROX(angle,0.0)) {
4096 if (!APPROX(mag,1.0)) {
4098 in.x = x; in.y = y, in.z = z;
4099 vecnormal(&out,&in);
4100 x = out.x; y = out.y; z = out.z;
4108 matrotate(myMat,radAng,x,y,z);
4109 matmultiplyAFFINE(p->currentMatrix,p->currentMatrix,myMat);
4111 FW_GL_LOADMATRIX(p->currentMatrix);
4114void fw_glRotatef (
float a,
float x,
float y,
float z) {
4115 fw_glRotated((GLDOUBLE)a, (GLDOUBLE)x, (GLDOUBLE)y, (GLDOUBLE)z);
4118void fw_glScaled (GLDOUBLE x, GLDOUBLE y, GLDOUBLE z) {
4119 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
4123 p->currentMatrix[0] *= x; p->currentMatrix[4] *= y; p->currentMatrix[8] *= z;
4124 p->currentMatrix[1] *= x; p->currentMatrix[5] *= y; p->currentMatrix[9] *= z;
4125 p->currentMatrix[2] *= x; p->currentMatrix[6] *= y; p->currentMatrix[10] *= z;
4126 p->currentMatrix[3] *= x; p->currentMatrix[7] *= y; p->currentMatrix[11] *= z;
4128 FW_GL_LOADMATRIX(p->currentMatrix);
4131void fw_glScalef (
float x,
float y,
float z) {
4132 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
4136 p->currentMatrix[0] *= x; p->currentMatrix[4] *= y; p->currentMatrix[8] *= z;
4137 p->currentMatrix[1] *= x; p->currentMatrix[5] *= y; p->currentMatrix[9] *= z;
4138 p->currentMatrix[2] *= x; p->currentMatrix[6] *= y; p->currentMatrix[10] *= z;
4139 p->currentMatrix[3] *= x; p->currentMatrix[7] *= y; p->currentMatrix[11] *= z;
4141 FW_GL_LOADMATRIX(p->currentMatrix);
4145void fw_glGetDoublev (
int ty, GLDOUBLE *mat) {
4147 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
4158 case GL_PROJECTION_MATRIX: dp = p->FW_ProjectionView[p->projectionviewTOS];
break;
4159 case GL_MODELVIEW_MATRIX: dp = p->FW_ModelView[p->modelviewTOS];
break;
4160 case GL_TEXTURE_MATRIX: dp = p->FW_TextureView[p->textureviewTOS];
break;
4162 loadIdentityMatrix(mat);
4163 printf (
"invalid mode sent in it is %d, expected one of %d %d %d\n",ty,GL_PROJECTION_MATRIX,GL_MODELVIEW_MATRIX,GL_TEXTURE_MATRIX);
4166 memcpy((
void *)mat, (
void *) dp,
sizeof (GLDOUBLE) * MATRIX_SIZE);
4168void fw_glGetInteger(
int ty,
int *params){
4169 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
4171 case GL_TEXTURE_STACK_DEPTH:
4172 params[0] = p->textureviewTOS;
4178void fw_glSetDoublev (
int ty, GLDOUBLE *mat) {
4180 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
4191 case GL_PROJECTION_MATRIX: dp = p->FW_ProjectionView[p->projectionviewTOS];
break;
4192 case GL_MODELVIEW_MATRIX: dp = p->FW_ModelView[p->modelviewTOS];
break;
4193 case GL_TEXTURE_MATRIX: dp = p->FW_TextureView[p->textureviewTOS];
break;
4195 printf (
"invalid mode sent in it is %d, expected one of %d %d %d\n",ty,GL_PROJECTION_MATRIX,GL_MODELVIEW_MATRIX,GL_TEXTURE_MATRIX);
4198 memcpy((
void *) dp, (
void *)mat,
sizeof (GLDOUBLE) * MATRIX_SIZE);
4203void kill_rendering() {
4217void kill_oldWorld(
int kill_EAI,
int kill_JavaScript,
char *file,
int line) {
4227 printf (
"kill 1 myThread %u displayThread %u\n",pthread_self(), gglobal()->threads.DispThrd);
4229 if (pthread_self().p != gglobal()->threads.DispThrd.p ) {
4231 if (pthread_self() != gglobal()->threads.DispThrd) {
4233 ConsoleMessage (
"kill_oldWorld must run in the displayThread called at %s:%d\n",file,line);
4239 resetSensorEvents();
4249 resource_tree_destroy();
4252 gglobal()->resources.root_res = NULL;
4259 rootnode = rootNode();
4260 if (rootnode != NULL) {
4261 if(rootnode->_nodeType == NODE_Proto){
4262 unload_broto(X3D_PROTO(rootnode));
4264 struct Multi_Node *children, *sortedChildren;
4266 children = &X3D_PROTO(rootNode())->__children;
4267 sortedChildren = &X3D_PROTO(rootNode())->_sortedChildren;
4269 if (children->n != 0) {
4270 for (i=0; i<children->n; i++) {
4271 markForDispose(children->p[i], TRUE);
4282 sortedChildren->n = 0;
4288 closeConsoleMessage();
4298 EAI_killBindables();
4300 killKeySensorNodeList();
4304 setMenuStatusVP(NULL);
4309 kill_userDefinedShaders();
4321#if !defined(EXCLUDE_EAI)
4325 fwlio_RxTx_control(CHANNEL_EAI, RxTx_STOP) ;
4330 if (globalParser != NULL) {
4331 parser_destroyData(globalParser);
4340 setMenuStatusVP(
"NONE");
4342void unload_globalParser() {
4346 parser_destroyData(globalParser);
4347 FREE_IF_NZ(globalParser->lexer);
4349 FREE_IF_NZ(globalParser);
4350 gglobal()->CParse.globalParser = NULL;
4352void unload_libraryscenes();
4353void reset_Browser(){
4358 struct X3D_Node *rootnode = rootNode();
4359 if (rootnode != NULL) {
4360 if( rootnode->_nodeType == NODE_Proto){
4361 unload_broto(X3D_PROTO(rootnode));
4362 unload_globalParser();
4363 resource_tree_destroy();
4364 unload_libraryscenes();
4367 kill_oldWorld(TRUE,TRUE,__FILE__,__LINE__);
4373#if defined (_ANDROID)
4376void fwl_Android_reloadAssets(
void) {
4381 p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
4384 resetGlobalShader();
4389 fwl_initialize_GL();
4393 if (p->linearNodeTable != NULL) {
4395 for (tc=0; tc<vectorSize(p->linearNodeTable); tc++){
4396 node = vector_get(
struct X3D_Node *,p->linearNodeTable,tc);
4404 switch (node->_nodeType) {
4409 me->__SphereIndxVBO = 0;
4410 FREE_IF_NZ(me->__points.p);
4411 me->__points.p = NULL;
4423 case NODE_Cylinder: {
4425 me->__cylinderVBO = 0;
4429 case NODE_Background: {
4444 for (i=0; i<VBO_COUNT; i++) pr->VBO_buffers[i] = 0;
4460int checkNode(
struct X3D_Node *node,
char *fn,
int line) {
4462 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
4465 printf (
"checkNode, node is NULL at %s %d\n",fn,line);
4469 if (node == X3D_NODE(rootNode()))
return FALSE;
4473 for (tc=0; tc<vectorSize(p->linearNodeTable); tc++){
4474 if (vector_get(
struct X3D_Node *,p->linearNodeTable,tc) == node) {
4475 if (node->referenceCount > 0) {
4493static void createMemoryTable(){
4494 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
4496 p->linearNodeTable = newVector(
struct X3D_Node*, 128);
4502void registerX3DNode(
struct X3D_Node * tmp){
4503 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
4505 bool filledHole = FALSE;
4509 if (p->linearNodeTable == NULL) {
4510 createMemoryTable();
4514 if (p->potentialHoleCount > 0) {
4515 for (tc=0; tc<vectorSize(p->linearNodeTable); tc++){
4517 if (vector_get(
struct X3D_Node *,p->linearNodeTable,tc) == NULL) {
4518 vector_set(
struct X3D_Node *, p->linearNodeTable, tc, tmp);
4519 p->potentialHoleCount--;
4533 if (!filledHole) vector_pushBack(
struct X3D_Node *, p->linearNodeTable, tmp);
4537int removeNodeFromVector(
int iaction,
struct Vector *v,
struct X3D_Node *node);
4538void unRegisterX3DNode(
struct X3D_Node * tmp){
4539 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
4541 if (p->linearNodeTable ) {
4542 removeNodeFromVector(1, p->linearNodeTable, tmp);
4558void doNotRegisterThisNodeForDestroy(
struct X3D_Node * nodePtr){
4561 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
4566 for (i=0; i<vectorSize(p->linearNodeTable); i++) {
4567 if (vector_get(
struct X3D_Node *,p->linearNodeTable,i) == nodePtr) {
4568 vector_set(
struct X3D_Node *,p->linearNodeTable,i,NULL);
4569 p->potentialHoleCount++;
4588static void sortChildren (
struct Multi_Node *ch,
struct Multi_Node *sortedCh,
int sortForDistance) {
4603 printf (
"start sortChildren line %d nc %d ",line,nc);
4604 if (sortForDistance) printf (
"sortForDistance ");
4610 if (nc != sortedCh->n) {
4612 FREE_IF_NZ(sortedCh->p);
4613 sortedCh->p = MALLOC(
void *,
sizeof (
struct X3DNode *) * nc);
4614 memcpy(sortedCh->p, ch->p,
sizeof(
struct X3DNode *) * nc);
4620 if (!sortForDistance) {
4633 for(i=0; i<nc; i++) {
4634 a = X3D_NODE(sortedCh->p[i]);
4635 printf (
"sortChildren, child %d of %d, is a %p %s dist %f rf %x ",i,nc,
4636 a, stringNodeType (a->_nodeType),a->_dist,a->_renderFlags);
4653 for(i=0; i<nc; i++) {
4655 for (j=(nc-1); j>i; j--) {
4657 a = X3D_NODE(sortedCh->p[j-1]);
4658 b = X3D_NODE(sortedCh->p[j]);
4662 if (a->_dist > b->_dist) {
4664 printf (
"sortChildren at %lf, have to switch %d %d dists %lf %lf ",TickTime(),i,j,a->_dist, b->_dist);
4665 printf (
"a %p %s, b %p %s\n",a,stringNodeType(a->_nodeType),b,stringNodeType(b->_nodeType));
4669 sortedCh->p[j-1] = b;
4683 printf (
"sortChildren returning:");
4684 for(i=0; i<nc; i++) {
4687 printf (
"sortChildren child %d %p %f %s",i,b,b->_dist,stringNodeType(b->_nodeType));
4689 printf (
"no child %d", i);
4691 printf (
" unsorted %p\n",b);
4697void zeroVisibilityFlag(
void) {
4700 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
4703 if (fwl_isinputThreadParsing())
return;
4707 if ((gglobal()->Frustum.OccFailed) || fwl_isTextureParsing()) {
4712 for (i=0; i<vectorSize(p->linearNodeTable); i++){
4713 node = vector_get(
struct X3D_Node *,p->linearNodeTable,i);
4715 node->_renderFlags = node->_renderFlags | VF_hasVisibleChildren;
4719 else if (p->linearNodeTable)
4722 for (i=0; i<vectorSize(p->linearNodeTable); i++){
4723 node = vector_get(
struct X3D_Node *,p->linearNodeTable,i);
4727 #ifdef OCCLUSIONVERBOSE
4728 if (((node->_renderFlags) & VF_hasVisibleChildren) != 0) {
4729 printf (
"%lf, zeroVisibility - %d is a %s, flags %x\n",TickTime(), i,stringNodeType(node->_nodeType), (node->_renderFlags) & VF_hasVisibleChildren);
4733 node->_renderFlags = node->_renderFlags & (0xFFFF^VF_hasVisibleChildren);
4745#define CMD(TTT,YYY) \
4747 if (NODE_NEEDS_COMPILING) compile_Metadata##TTT((struct X3D_Metadata##TTT *) YYY)
4749#define BEGIN_NODE(thistype) case NODE_##thistype:
4750#define END_NODE break;
4752#define SIBLING_SENSITIVE(thistype) \
4754 if (((struct X3D_##thistype *)node)->enabled) { \
4755 nParents = vectorSize((struct X3D_##thistype *)pnode->_parentVector); \
4756 parentVector = (((struct X3D_##thistype *)pnode)->_parentVector); \
4759#define ANCHOR_SENSITIVE(thistype) \
4761 anchorPtr = (struct X3D_Anchor *)node;
4766#define BINDABLE(thistype) \
4767 setBindPtr = (int *)(((char*)(node))+offsetof (struct X3D_##thistype, set_bind)); \
4768 if ((*setBindPtr) == 100) {setBindPtr = NULL; }
4770#define CHILDREN_NODE(thistype) \
4771 addChildren = NULL; removeChildren = NULL; \
4772 offsetOfChildrenPtr = offsetof (struct X3D_##thistype, children); \
4773 if (((struct X3D_##thistype *)node)->addChildren.n > 0) { \
4774 addChildren = &((struct X3D_##thistype *)node)->addChildren; \
4775 childrenPtr = &((struct X3D_##thistype *)node)->children; \
4777 if (((struct X3D_##thistype *)node)->removeChildren.n > 0) { \
4778 removeChildren = &((struct X3D_##thistype *)node)->removeChildren; \
4779 childrenPtr = &((struct X3D_##thistype *)node)->children; \
4782#define CHILDREN_SWITCH_NODE(thistype) \
4783 addChildren = NULL; removeChildren = NULL; \
4784 spec = X3D_PROTO(node->_executionContext)->__specversion; \
4785 if (spec < 300 || ((struct X3D_##thistype*)node)->choice.n) { \
4786 offsetOfChildrenPtr = offsetof(struct X3D_##thistype, choice); \
4787 childrenPtr = &((struct X3D_##thistype*)node)->choice; \
4789 offsetOfChildrenPtr = offsetof(struct X3D_##thistype, children); \
4790 childrenPtr = &((struct X3D_##thistype*)node)->children; \
4792 if (((struct X3D_##thistype*)node)->addChildren.n > 0) \
4793 addChildren = &((struct X3D_##thistype*)node)->addChildren; \
4794 if (((struct X3D_##thistype*)node)->removeChildren.n > 0) \
4795 removeChildren = &((struct X3D_##thistype*)node)->removeChildren;
4825#define CHILDREN_LOD_NODE(thistype) \
4826 addChildren = NULL; removeChildren = NULL; \
4827 spec = X3D_PROTO(node->_executionContext)->__specversion; \
4828 if (spec < 300 || ((struct X3D_##thistype*)node)->level.n) { \
4829 offsetOfChildrenPtr = offsetof(struct X3D_##thistype, level); \
4830 childrenPtr = &((struct X3D_##thistype*)node)->level; \
4832 offsetOfChildrenPtr = offsetof(struct X3D_##thistype, children); \
4833 childrenPtr = &((struct X3D_##thistype*)node)->children; \
4835 if (X3D_LODNODE(node)->addChildren.n > 0) { \
4836 addChildren = &X3D_LODNODE(node)->addChildren; \
4838 if (X3D_LODNODE(node)->removeChildren.n > 0) { \
4839 removeChildren = &X3D_LODNODE(node)->removeChildren; \
4843#define CHILDREN_ANY_NODE(thistype,thischildren) \
4844 addChildren = NULL; removeChildren = NULL; \
4845 offsetOfChildrenPtr = offsetof (struct X3D_##thistype, thischildren); \
4846 if (((struct X3D_##thistype *)node)->addChildren.n > 0) { \
4847 addChildren = &((struct X3D_##thistype *)node)->addChildren; \
4848 childrenPtr = &((struct X3D_##thistype *)node)->thischildren; \
4850 if (((struct X3D_##thistype *)node)->removeChildren.n > 0) { \
4851 removeChildren = &((struct X3D_##thistype *)node)->removeChildren; \
4852 childrenPtr = &((struct X3D_##thistype *)node)->thischildren; \
4856#define EVIN_AND_FIELD_SAME(thisfield, thistype) \
4857 if ((((struct X3D_##thistype *)node)->set_##thisfield.n) > 0) { \
4858 ((struct X3D_##thistype *)node)->thisfield.n = 0; \
4859 FREE_IF_NZ (((struct X3D_##thistype *)node)->thisfield.p); \
4860 ((struct X3D_##thistype *)node)->thisfield.p = ((struct X3D_##thistype *)node)->set_##thisfield.p; \
4861 ((struct X3D_##thistype *)node)->thisfield.n = ((struct X3D_##thistype *)node)->set_##thisfield.n; \
4862 ((struct X3D_##thistype *)node)->set_##thisfield.n = 0; \
4863 ((struct X3D_##thistype *)node)->set_##thisfield.p = NULL; \
4871OLDCODE#define LOCAL_LIGHT_PARENT_FLAG \
4873OLDCODE
for (i = 0; i < vectorSize(pnode->_parentVector); i++) { \
4874OLDCODE
struct X3D_Node *n = vector_get(
struct X3D_Node*, pnode->_parentVector, i); \
4875OLDCODE
if( n != 0 ) n->_renderFlags = n->_renderFlags | VF_localLight; \
4880#define ADD_TO_PARENT_SIBAFFECTORS \
4882 for (i = 0; i < vectorSize(pnode->_parentVector); i++) { \
4883 struct X3D_Node *n = vector_get(struct X3D_Node*, pnode->_parentVector, i); \
4884 if( n != 0 ) AddToSibAffectors(n,pnode); \
4888#define CHECK_MATERIAL_TRANSPARENCY \
4889if (((struct X3D_Material *)node)->transparency > 0.0001) { \
4891update_renderFlag(X3D_NODE(pnode),VF_Blend | VF_shouldSortChildren);\
4892gglobal()->RenderFuncs.have_transparency = TRUE; \
4895#define CHECK_FILL_PROPERTY_FILLED \
4896 if ((((struct X3D_FillProperties *)node)->_enabled == TRUE) && (((struct X3D_FillProperties *)node)->filled == FALSE)) { \
4898 update_renderFlag(X3D_NODE(pnode),VF_Blend | VF_shouldSortChildren);\
4899 gglobal()->RenderFuncs.have_transparency = TRUE; \
4902#define CHECK_TWOSIDED_MATERIAL_TRANSPARENCY \
4903 if ((((struct X3D_TwoSidedMaterial *)node)->transparency > 0.0001) || (((struct X3D_TwoSidedMaterial *)node)->backTransparency > 0.0001)){ \
4905 update_renderFlag(X3D_NODE(pnode),VF_Blend | VF_shouldSortChildren);\
4906 gglobal()->RenderFuncs.have_transparency = TRUE; \
4909#define CHECK_IMAGETEXTURE_TRANSPARENCY \
4910 if (isTextureAlpha(((struct X3D_ImageTexture *)node)->__textureTableIndex)) { \
4912 update_renderFlag(X3D_NODE(pnode),VF_Blend | VF_shouldSortChildren);\
4913 gglobal()->RenderFuncs.have_transparency = TRUE; \
4916#define CHECK_PIXELTEXTURE_TRANSPARENCY \
4917 if (isTextureAlpha(((struct X3D_PixelTexture *)node)->__textureTableIndex)) { \
4919 update_renderFlag(X3D_NODE(pnode),VF_Blend | VF_shouldSortChildren);\
4920 gglobal()->RenderFuncs.have_transparency = TRUE; \
4923#define CHECK_MOVIETEXTURE_TRANSPARENCY \
4924 if (isTextureAlpha(((struct X3D_MovieTexture *)node)->__textureTableIndex)) { \
4926 update_renderFlag(X3D_NODE(pnode),VF_Blend | VF_shouldSortChildren);\
4927 gglobal()->RenderFuncs.have_transparency = TRUE; \
4943 if(node->_nodeType == NODE_Proto)
4949 if(pn->__children.n > 0)
4950 dnode = getTypeNode(pn->__children.p[0]);
4959void printStatsNodes(){
4961 ttglobal tg = gglobal();
4962 p = (ppOpenGL_Utils)tg->OpenGL_Utils.prv;
4964 ConsoleMessage(
"%25s %d\n",
"Nodes count", p->linearNodeTable->n);
4967int unRegisterX3DAnyNode(
struct X3D_Node *node);
4974 ttglobal tg = gglobal();
4975 p = (ppOpenGL_Utils)tg->OpenGL_Utils.prv;
4977 for (i = 0; i < vectorSize(p->linearNodeTable); i++){
4978 node = vector_get(
struct X3D_Node *, p->linearNodeTable, i);
4980 if (node->referenceCount <= 0) {
4983 unRegisterX3DAnyNode(node);
4985 vector_set(
struct X3D_Node *,p->linearNodeTable,i,NULL);
4994int isSiblingAffector(
struct X3D_Node *node){
4996 switch(node->_nodeType){
4997 case NODE_DirectionalLight:
4998 case NODE_SpotLight:
4999 case NODE_PointLight:
5001 case NODE_ClipPlane:
5003 case NODE_TextureProjector:
5004 case NODE_TextureProjectorParallel:
5005 case NODE_TextureProjectorPoint:
5021int hasSiblingAffectorField(
struct X3D_Node *node,
int whereFrom){
5027 printf (
"hasSiblingAffectorField, node %p from line %d\n",node,whereFrom);
5030 switch(node->_nodeType){
5034 case NODE_Transform:
5036 case NODE_Billboard:
5037 case NODE_Collision:
5038 case NODE_GeoLocation:
5039 case NODE_GeoTransform:
5040 case NODE_HAnimSite:
5041 case NODE_HAnimHumanoid:
5044 case NODE_EspduTransform:
5045 case NODE_CADAssembly:
5050 case NODE_LayoutLayer:
5051 case NODE_LayoutGroup:
5052 case NODE_ScreenGroup:
5053 case NODE_PickableGroup:
5054 case NODE_StaticGroup:
5061void *sibAffectorPtr(
struct X3D_Node *node){
5065 int *fieldOffsetsPtr;
5066 fieldOffsetsPtr = (
int*) NODE_OFFSETS[node->_nodeType];
5068 while(fieldOffsetsPtr[0] > -1){
5070 if(fieldOffsetsPtr[0] == FIELDNAMES___sibAffectors){
5071 fieldPtr = offsetPointer_deref(
char *, node,fieldOffsetsPtr[1]);
5074 fieldOffsetsPtr += FIELDOFFSET_LENGTH;
5087 printf (
"in AddToSibAffectors, we have node parent NULL, node is a %s\n",stringNodeType(affector->_nodeType));
5091 if(hasSiblingAffectorField(parent,__LINE__) && isSiblingAffector(affector)){
5092 struct Multi_Node *safs = sibAffectorPtr(parent);
5094 safs->p = REALLOC(safs->p,(safs->n+1)*
sizeof(
struct X3D_Node*));
5095 safs->p[safs->n] = affector;
5100void zeroSibAffectors(
struct X3D_Node *node){
5103 struct Multi_Node* saf = sibAffectorPtr(node);
5113int needs_updating_Inline(
struct X3D_Node *node);
5116void startOfLoopNodeUpdates(
void) {
5120 struct Vector *parentVector;
5122 int i, j, k, foundbound, spec;
5128 size_t offsetOfChildrenPtr;
5133 ttglobal tg = gglobal();
5134 p = (ppOpenGL_Utils)tg->OpenGL_Utils.prv;
5136 if (rootNode() == NULL)
return;
5140 removeChildren = NULL;
5142 parentVector = NULL;
5144 offsetOfChildrenPtr = 0;
5147 tg->Mainloop.HaveSensitive = FALSE;
5148 tg->RenderFuncs.have_transparency = FALSE;
5152 if (fwl_isinputThreadParsing())
return;
5153 profile_start(
"loopnodeupdt");
5160 for (i=0; i<vectorSize(p->linearNodeTable); i++){
5161 node = vector_get(
struct X3D_Node *,p->linearNodeTable,i);
5163 if (node->referenceCount <= 0) {
5172 vector_set(
struct X3D_Node *,p->linearNodeTable,i,NULL);
5177 node->_renderFlags = node->_renderFlags & (0xFFFF^VF_Sensitive);
5178 node->_renderFlags = node->_renderFlags & (0xFFFF^VF_Viewpoint);
5179 node->_renderFlags = node->_renderFlags & (0xFFFF^VF_localLight);
5180 node->_renderFlags = node->_renderFlags & (0xFFFF^VF_globalLight);
5181 node->_renderFlags = node->_renderFlags & (0xFFFF^VF_Blend);
5184 if(hasSiblingAffectorField(node,__LINE__)){
5185 zeroSibAffectors(node);
5195 rn->_renderFlags = rn->_renderFlags & (0xFFFF^VF_Sensitive);
5196 rn->_renderFlags = rn->_renderFlags & (0xFFFF^VF_Viewpoint);
5197 rn->_renderFlags = rn->_renderFlags & (0xFFFF^VF_localLight);
5198 rn->_renderFlags = rn->_renderFlags & (0xFFFF^VF_globalLight);
5199 rn->_renderFlags = rn->_renderFlags & (0xFFFF^VF_Blend);
5206 if (rootNode() != NULL) {
5207 struct Multi_Node *children, *_sortedChildren;
5208 node = (
struct X3D_Node*)rootNode();
5210 _sortedChildren = NULL;
5211 if(node->_nodeType == NODE_Proto){
5212 children = &X3D_PROTO(node)->__children;
5213 _sortedChildren = &X3D_PROTO(node)->_sortedChildren;
5215 if(node->_nodeType == NODE_Group) {
5216 children = &X3D_GROUP(node)->children;
5217 _sortedChildren = &X3D_GROUP(node)->_sortedChildren;
5221 sortChildren (children, _sortedChildren,rootNode()->_renderFlags & VF_shouldSortChildren);
5222 rootNode()->_renderFlags=rootNode()->_renderFlags & (0xFFFF^VF_shouldSortChildren);
5223 if(node->_nodeType == NODE_Proto){
5228 addChildren = NULL; removeChildren = NULL;
5229 offsetOfChildrenPtr = offsetof (
struct X3D_Proto, __children);
5230 if (((
struct X3D_Proto *)node)->addChildren.n > 0) {
5231 addChildren = &((
struct X3D_Proto *)node)->addChildren;
5232 childrenPtr = &((
struct X3D_Proto *)node)->__children;
5234 if (((
struct X3D_Proto *)node)->removeChildren.n > 0) {
5235 removeChildren = &((
struct X3D_Proto *)node)->removeChildren;
5236 childrenPtr = &((
struct X3D_Proto *)node)->__children;
5240 CHILDREN_NODE(Group)
5243 if (childrenPtr != NULL) {
5244 if (addChildren != NULL) {
5245 AddRemoveChildren(node,childrenPtr,(
struct X3D_Node * *) addChildren->p,addChildren->n,1,__FILE__,__LINE__);
5248 if (removeChildren != NULL) {
5249 AddRemoveChildren(node,childrenPtr,(
struct X3D_Node * *) removeChildren->p,removeChildren->n,2,__FILE__,__LINE__);
5250 removeChildren->n=0;
5253 MARK_EVENT(node,offsetOfChildrenPtr);
5264 for (i=0; i<vectorSize(p->linearNodeTable); i++){
5265 node = vector_get(
struct X3D_Node *,p->linearNodeTable,i);
5267 if (node->referenceCount > 0) {
5269 node = getTypeNode(node);
5270 if(node == NULL && pnode != NULL)
5271 if(pnode->_nodeType == NODE_Proto){
5285 load_externProtoInstance(X3D_PROTO(pnode));
5287 node = getTypeNode(pnode);
5291 switch (node->_nodeType) {
5294 if ((X3D_SHAPE(node)->__occludeCheckCount <=0) ||
5295 (X3D_SHAPE(node)->__visible)) {
5296 update_renderFlag (X3D_NODE(pnode),VF_hasVisibleChildren);
5300 X3D_SHAPE(node)->__occludeCheckCount--;
5307 BEGIN_NODE(DirectionalLight)
5308 if (X3D_DIRECTIONALLIGHT(node)->on) {
5309 if (X3D_DIRECTIONALLIGHT(node)->global)
5310 update_renderFlag(pnode,VF_globalLight);
5314 ADD_TO_PARENT_SIBAFFECTORS
5318 BEGIN_NODE(SpotLight)
5319 if (X3D_SPOTLIGHT(node)->on) {
5320 if (X3D_SPOTLIGHT(node)->global)
5321 update_renderFlag(pnode,VF_globalLight);
5325 ADD_TO_PARENT_SIBAFFECTORS
5329 BEGIN_NODE(PointLight)
5330 if (X3D_POINTLIGHT(node)->on) {
5331 if (X3D_POINTLIGHT(node)->global)
5332 update_renderFlag(pnode,VF_globalLight);
5336 ADD_TO_PARENT_SIBAFFECTORS
5340 BEGIN_NODE(LocalFog)
5341 ADD_TO_PARENT_SIBAFFECTORS
5343 BEGIN_NODE(ClipPlane)
5344 ADD_TO_PARENT_SIBAFFECTORS
5347 ADD_TO_PARENT_SIBAFFECTORS
5349 BEGIN_NODE(TextureProjector)
5350 if (X3D_TEXTUREPROJECTOR(node)->on) {
5351 if (X3D_TEXTUREPROJECTOR(node)->global)
5352 update_renderFlag(pnode,VF_globalLight);
5355 ADD_TO_PARENT_SIBAFFECTORS
5359 BEGIN_NODE(TextureProjectorParallel)
5360 if (X3D_TEXTUREPROJECTORPARALLEL(node)->on) {
5361 if (X3D_TEXTUREPROJECTORPARALLEL(node)->global)
5362 update_renderFlag(pnode,VF_globalLight);
5365 ADD_TO_PARENT_SIBAFFECTORS
5369 BEGIN_NODE(TextureProjectorPoint)
5370 if (X3D_TEXTUREPROJECTORPOINT(node)->on) {
5371 if (X3D_TEXTUREPROJECTORPOINT(node)->global)
5372 update_renderFlag(pnode, VF_globalLight);
5375 ADD_TO_PARENT_SIBAFFECTORS
5384 BEGIN_NODE(IndexedLineSet)
5385 EVIN_AND_FIELD_SAME(colorIndex,IndexedLineSet)
5386 EVIN_AND_FIELD_SAME(coordIndex,IndexedLineSet)
5389 BEGIN_NODE(IndexedTriangleFanSet)
5390 EVIN_AND_FIELD_SAME(index,IndexedTriangleFanSet)
5392 BEGIN_NODE(IndexedTriangleSet)
5393 EVIN_AND_FIELD_SAME(index,IndexedTriangleSet)
5395 BEGIN_NODE(IndexedTriangleStripSet)
5396 EVIN_AND_FIELD_SAME(index,IndexedTriangleStripSet)
5398 BEGIN_NODE(GeoElevationGrid)
5399 EVIN_AND_FIELD_SAME(height,GeoElevationGrid)
5401 BEGIN_NODE(ElevationGrid)
5402 EVIN_AND_FIELD_SAME(height,ElevationGrid)
5404 BEGIN_NODE(Extrusion)
5405 EVIN_AND_FIELD_SAME(crossSection,Extrusion)
5406 EVIN_AND_FIELD_SAME(orientation,Extrusion)
5407 EVIN_AND_FIELD_SAME(scale,Extrusion)
5408 EVIN_AND_FIELD_SAME(spine,Extrusion)
5410 BEGIN_NODE(IndexedFaceSet)
5411 EVIN_AND_FIELD_SAME(colorIndex,IndexedFaceSet)
5412 EVIN_AND_FIELD_SAME(coordIndex,IndexedFaceSet)
5413 EVIN_AND_FIELD_SAME(normalIndex,IndexedFaceSet)
5414 EVIN_AND_FIELD_SAME(texCoordIndex,IndexedFaceSet)
5424 BEGIN_NODE(LineSensor) SIBLING_SENSITIVE(LineSensor) END_NODE
5425 BEGIN_NODE(PointSensor) SIBLING_SENSITIVE(PointSensor) END_NODE
5426 BEGIN_NODE(PlaneSensor) SIBLING_SENSITIVE(PlaneSensor) END_NODE
5427 BEGIN_NODE(MultiTouchSensor) SIBLING_SENSITIVE(MultiTouchSensor) END_NODE
5428 BEGIN_NODE(SphereSensor) SIBLING_SENSITIVE(SphereSensor) END_NODE
5429 BEGIN_NODE(CylinderSensor) SIBLING_SENSITIVE(CylinderSensor) END_NODE
5430 BEGIN_NODE(TouchSensor) SIBLING_SENSITIVE(TouchSensor) END_NODE
5431 BEGIN_NODE(GeoTouchSensor) SIBLING_SENSITIVE(GeoTouchSensor) END_NODE
5435 ANCHOR_SENSITIVE(Anchor)
5436 CHILDREN_NODE(Anchor)
5441 update_renderFlag (X3D_NODE(pnode),VF_hasVisibleChildren);
5444 BEGIN_NODE(CADLayer)
5445 CHILDREN_NODE(Switch)
5450 sortChildren (&X3D_CADPART(node)->children,&X3D_CADPART(node)->_sortedChildren,pnode->_renderFlags & VF_shouldSortChildren);
5452 CHILDREN_NODE(CADPart)
5456 BEGIN_NODE(CADAssembly)
5457 sortChildren (&X3D_CADASSEMBLY(node)->children,&X3D_CADASSEMBLY(node)->_sortedChildren,pnode->_renderFlags & VF_shouldSortChildren);
5459 CHILDREN_NODE(CADAssembly)
5463 BEGIN_NODE(Viewpoint) BINDABLE(Viewpoint) END_NODE
5464 BEGIN_NODE(OrthoViewpoint) BINDABLE(OrthoViewpoint) END_NODE
5465 BEGIN_NODE(GeoViewpoint) BINDABLE(GeoViewpoint) END_NODE
5467 BEGIN_NODE(NavigationInfo)
5469 BINDABLE(NavigationInfo)
5472 BEGIN_NODE(StaticGroup)
5474 sortChildren (&X3D_STATICGROUP(node)->children,&X3D_STATICGROUP(node)->_sortedChildren,pnode->_renderFlags & VF_shouldSortChildren);
5481 sortChildren (&X3D_GROUP(node)->children,&X3D_GROUP(node)->_sortedChildren,pnode->_renderFlags & VF_shouldSortChildren);
5483 CHILDREN_NODE(Group)
5486 BEGIN_NODE(PickableGroup)
5489 CHILDREN_NODE(PickableGroup)
5493 sortChildren (&X3D_INLINE(node)->__children,&X3D_INLINE(node)->_sortedChildren,node->_renderFlags & VF_shouldSortChildren);
5495 CHILDREN_ANY_NODE(Inline,__children)
5498 BEGIN_NODE(Transform)
5500 sortChildren (&X3D_TRANSFORM(node)->children,&X3D_TRANSFORM(node)->_sortedChildren,pnode->_renderFlags & VF_shouldSortChildren);
5502 CHILDREN_NODE(Transform)
5511 BEGIN_NODE(Contour2D)
5512 CHILDREN_NODE(Contour2D)
5515 BEGIN_NODE(HAnimSite)
5516 CHILDREN_NODE(HAnimSite)
5519 BEGIN_NODE(HAnimSegment)
5520 CHILDREN_NODE(HAnimSegment)
5523 BEGIN_NODE(HAnimJoint)
5524 CHILDREN_NODE(HAnimJoint)
5527 BEGIN_NODE(Billboard)
5528 CHILDREN_NODE(Billboard)
5529 update_renderFlag(pnode,VF_Proximity);
5532 BEGIN_NODE(Collision)
5533 CHILDREN_NODE(Collision)
5537 CHILDREN_SWITCH_NODE(Switch)
5554 CHILDREN_LOD_NODE(LOD)
5555 update_renderFlag(pnode,VF_Proximity);
5559 BEGIN_NODE(Material) CHECK_MATERIAL_TRANSPARENCY END_NODE
5560 BEGIN_NODE(TwoSidedMaterial) CHECK_TWOSIDED_MATERIAL_TRANSPARENCY END_NODE
5561 BEGIN_NODE(FillProperties) CHECK_FILL_PROPERTY_FILLED END_NODE
5564 BEGIN_NODE(ImageTexture) CHECK_IMAGETEXTURE_TRANSPARENCY END_NODE
5565 BEGIN_NODE(PixelTexture) CHECK_PIXELTEXTURE_TRANSPARENCY END_NODE
5566 BEGIN_NODE(MovieTexture) CHECK_MOVIETEXTURE_TRANSPARENCY END_NODE
5568 BEGIN_NODE(VolumeData)
5569 tg->RenderFuncs.have_transparency = TRUE;
5570 update_renderFlag(X3D_NODE(pnode),VF_Blend | VF_shouldSortChildren);\
5572 BEGIN_NODE(SegmentedVolumeData)
5573 tg->RenderFuncs.have_transparency = TRUE;
5574 update_renderFlag(X3D_NODE(pnode),VF_Blend | VF_shouldSortChildren);\
5576 BEGIN_NODE(IsoSurfaceVolumeData)
5577 tg->RenderFuncs.have_transparency = TRUE;
5578 update_renderFlag(X3D_NODE(pnode),VF_Blend | VF_shouldSortChildren);\
5583 BEGIN_NODE(Background)
5584 BINDABLE(Background)
5588 BEGIN_NODE(TextureBackground)
5589 BINDABLE(TextureBackground)
5600 BEGIN_NODE (VisibilitySensor)
5601 #ifdef OCCLUSION_STUFF
5603 if ((X3D_VISIBILITYSENSOR(node)->__occludeCheckCount <=0) ||
5604 (X3D_VISIBILITYSENSOR(node)->__visible)) {
5605 update_renderFlag (X3D_NODE(pnode),VF_hasVisibleChildren);
5609 X3D_VISIBILITYSENSOR(node)->__occludeCheckCount--;
5612 update_renderFlag(pnode,VF_Blend & VF_shouldSortChildren);
5616 update_renderFlag(pnode,VF_Other);
5621 BEGIN_NODE (ProximitySensor)
5622 if (X3D_PROXIMITYSENSOR(node)->enabled) update_renderFlag(pnode,VF_Proximity);
5626 BEGIN_NODE (GeoProximitySensor)
5627 if (X3D_GEOPROXIMITYSENSOR(node)->enabled) update_renderFlag(pnode,VF_Proximity);
5632 if (!(NODE_NEEDS_COMPILING)) {
5633 handle_GeoLODRange(X3D_GEOLOD(node));
5638 BEGIN_NODE (GeoTransform)
5639 sortChildren (&X3D_GEOTRANSFORM(node)->children,&X3D_GEOTRANSFORM(node)->_sortedChildren,pnode->_renderFlags & VF_shouldSortChildren);
5641 CHILDREN_NODE(GeoTransform)
5644 BEGIN_NODE (GeoLocation)
5645 sortChildren (&X3D_GEOLOCATION(node)->children,&X3D_GEOLOCATION(node)->_sortedChildren,pnode->_renderFlags & VF_shouldSortChildren);
5647 CHILDREN_NODE(GeoLocation)
5650 BEGIN_NODE (EspduTransform)
5651 CHILDREN_NODE(EspduTransform)
5655 BEGIN_NODE(MetadataSFBool) CMD(SFBool,node); END_NODE
5656 BEGIN_NODE(MetadataSFFloat) CMD(SFFloat,node); END_NODE
5657 BEGIN_NODE(MetadataMFFloat) CMD(MFFloat,node); END_NODE
5658 BEGIN_NODE(MetadataSFRotation) CMD(
SFRotation,node); END_NODE
5659 BEGIN_NODE(MetadataMFRotation) CMD(MFRotation,node); END_NODE
5660 BEGIN_NODE(MetadataSFVec3f) CMD(
SFVec3f,node); END_NODE
5661 BEGIN_NODE(MetadataMFVec3f) CMD(MFVec3f,node); END_NODE
5662 BEGIN_NODE(MetadataMFBool) CMD(MFBool,node); END_NODE
5663 BEGIN_NODE(MetadataSFInt32) CMD(SFInt32,node); END_NODE
5664 BEGIN_NODE(MetadataMFInt32) CMD(MFInt32,node); END_NODE
5665 BEGIN_NODE(MetadataSFNode) CMD(SFNode,node); END_NODE
5666 BEGIN_NODE(MetadataMFNode) CMD(MFNode,node); END_NODE
5667 BEGIN_NODE(MetadataSFColor) CMD(
SFColor,node); END_NODE
5668 BEGIN_NODE(MetadataMFColor) CMD(MFColor,node); END_NODE
5669 BEGIN_NODE(MetadataSFColorRGBA) CMD(
SFColorRGBA,node); END_NODE
5670 BEGIN_NODE(MetadataMFColorRGBA) CMD(MFColorRGBA,node); END_NODE
5671 BEGIN_NODE(MetadataSFTime) CMD(SFTime,node); END_NODE
5672 BEGIN_NODE(MetadataMFTime) CMD(MFTime,node); END_NODE
5673 BEGIN_NODE(MetadataSFString) CMD(SFString,node); END_NODE
5674 BEGIN_NODE(MetadataMFString) CMD(MFString,node); END_NODE
5675 BEGIN_NODE(MetadataSFVec2f) CMD(
SFVec2f,node); END_NODE
5676 BEGIN_NODE(MetadataMFVec2f) CMD(MFVec2f,node); END_NODE
5677 BEGIN_NODE(MetadataSFImage) CMD(
SFImage,node); END_NODE
5678 BEGIN_NODE(MetadataSFVec3d) CMD(
SFVec3d,node); END_NODE
5679 BEGIN_NODE(MetadataMFVec3d) CMD(MFVec3d,node); END_NODE
5680 BEGIN_NODE(MetadataSFDouble) CMD(SFDouble,node); END_NODE
5681 BEGIN_NODE(MetadataMFDouble) CMD(MFDouble,node); END_NODE
5682 BEGIN_NODE(MetadataSFMatrix3f) CMD(
SFMatrix3f,node); END_NODE
5683 BEGIN_NODE(MetadataMFMatrix3f) CMD(MFMatrix3f,node); END_NODE
5684 BEGIN_NODE(MetadataSFMatrix3d) CMD(
SFMatrix3d,node); END_NODE
5685 BEGIN_NODE(MetadataMFMatrix3d) CMD(MFMatrix3d,node); END_NODE
5686 BEGIN_NODE(MetadataSFMatrix4f) CMD(
SFMatrix4f,node); END_NODE
5687 BEGIN_NODE(MetadataMFMatrix4f) CMD(MFMatrix4f,node); END_NODE
5688 BEGIN_NODE(MetadataSFMatrix4d) CMD(
SFMatrix4d,node); END_NODE
5689 BEGIN_NODE(MetadataMFMatrix4d) CMD(MFMatrix4d,node); END_NODE
5690 BEGIN_NODE(MetadataSFVec2d) CMD(
SFVec2d,node); END_NODE
5691 BEGIN_NODE(MetadataMFVec2d) CMD(MFVec2d,node); END_NODE
5692 BEGIN_NODE(MetadataSFVec4f) CMD(
SFVec4f,node); END_NODE
5693 BEGIN_NODE(MetadataMFVec4f) CMD(MFVec4f,node); END_NODE
5694 BEGIN_NODE(MetadataSFVec4d) CMD(
SFVec4d,node); END_NODE
5695 BEGIN_NODE(MetadataMFVec4d) CMD(MFVec4d,node); END_NODE
5702 if (nParents != 0) {
5703 for (j=0; j<nParents; j++) {
5705 n->_renderFlags = n->_renderFlags | VF_Sensitive;
5708 tg->Mainloop.HaveSensitive = TRUE;
5713 if (anchorPtr != NULL) {
5714 anchorPtr->_renderFlags = anchorPtr->_renderFlags | VF_Sensitive;
5717 tg->Mainloop.HaveSensitive = TRUE;
5722 if (setBindPtr != NULL) {
5724 if (*setBindPtr < 100) {
5727 send_bind_to(node,*setBindPtr);
5753 if (childrenPtr != NULL) {
5755 if (addChildren != NULL) {
5762 AddRemoveChildren(node,childrenPtr,(
struct X3D_Node * *) addChildren->p,addChildren->n,1,__FILE__,__LINE__);
5765 for (i=0; i<addChildren->n; i++) {
5766 struct X3D_Node *ch = X3D_NODE(addChildren->p[i]);
5767 add_parent(ch,node,__FILE__,__LINE__);
5773 if (removeChildren != NULL) {
5774 AddRemoveChildren(node,childrenPtr,(
struct X3D_Node * *) removeChildren->p,removeChildren->n,2,__FILE__,__LINE__);
5777 for (i=0; i<removeChildren->n; i++) {
5778 struct X3D_Node *ch = X3D_NODE(removeChildren->p[i]);
5779 remove_parent(ch,node);
5781 removeChildren->n=0;
5786 MARK_EVENT(node,offsetOfChildrenPtr);
5798 for(k=0;k<vectorSize(tg->Bindable.bstacks);k++){
5802 if( vectorSize(bstack->viewpoint) > 0){
5806 struct X3D_Node *boundvp = vector_back(
struct X3D_Node*,bstack->viewpoint);
5807 update_renderFlag(boundvp, VF_Viewpoint);
5808 calculateNearFarplanes(boundvp, bstack->layerId);
5809 calculateViewingDistIfJustBound(boundvp,bstack->layerId);
5818 X3D_Viewer *
viewer = Viewer();
5819 viewer->nearPlane = DEFAULT_NEARPLANE;
5820 viewer->farPlane = DEFAULT_FARPLANE;
5821 viewer->backgroundPlane = DEFAULT_BACKGROUNDPLANE;
5823 profile_end(
"loopnodeupdt");
5830void markForDispose(
struct X3D_Node *node,
int recursive){
5832 int *fieldOffsetsPtr;
5835 if (node==NULL)
return;
5836 if (node==X3D_NODE(rootNode()) && node->_nodeType != NODE_Proto) {
5837 ConsoleMessage (
"not disposing rootNode");
5843 ConsoleMessage (
"\nmarkingForDispose %p (%s) currently at %d",node,
5844 stringNodeType(node->_nodeType),node->referenceCount);
5848 if (node->referenceCount > 0)
5849 node->referenceCount--;
5856 fieldOffsetsPtr = (
int*) NODE_OFFSETS[node->_nodeType];
5858 while (*fieldOffsetsPtr != -1) {
5859 fieldPtr = offsetPointer_deref(
char *, node,*(fieldOffsetsPtr+1));
5861 ConsoleMessage (
"looking at field %s type %s",FIELDNAMES[*fieldOffsetsPtr],FIELDTYPES[*(fieldOffsetsPtr+2)]);
5865 if (*fieldOffsetsPtr == FIELDNAMES_setValue)
5868 if (*fieldOffsetsPtr == FIELDNAMES_valueChanged)
5871 if (*fieldOffsetsPtr == FIELDNAMES__selected)
5874 if (*fieldOffsetsPtr == FIELDNAMES___oldChildren)
5877 if (*fieldOffsetsPtr == FIELDNAMES___oldKeyPtr)
5880 if (*fieldOffsetsPtr == FIELDNAMES___oldKeyValuePtr)
5884 if (node->_nodeType == NODE_GeoLOD) {
5885 if (*fieldOffsetsPtr == FIELDNAMES_children)
break;
5888 if (*fieldOffsetsPtr == FIELDNAMES__shaderUserDefinedFields)
5892 switch(*(fieldOffsetsPtr+2)){
5893 case FIELDTYPE_MFNode: {
5901 for (i=0; i<MNode->n; i++) {
5906 ConsoleMessage (
"calling markForDispose on node %p as it is an element of an MFNode",tp);
5908 markForDispose(tp,TRUE);
5914 case FIELDTYPE_SFNode: {
5917 memcpy(&SNode,fieldPtr,
sizeof(
struct X3D_Node *));
5920 ConsoleMessage (
"SFNode, field is %p...",SNode);
5921 if (SNode != NULL) {
5922 ConsoleMessage (
"SFNode, .... and it is of type %s",stringNodeType(SNode->_nodeType));
5923 ConsoleMessage (
" ... field SFNode, %s type %s\n",FIELDNAMES[*fieldOffsetsPtr],FIELDTYPES[*(fieldOffsetsPtr+2)]);
5927 if(SNode && SNode->referenceCount > 0) {
5929 ConsoleMessage (
"calling markForDispose on node %p as it is contents of SFNode field",SNode);
5931 markForDispose(SNode, TRUE);
5939 fieldOffsetsPtr += FIELDOFFSET_LENGTH;
5948OLDCODE #define DELETE_IF_IN_PRODCON(aaa) \
5949OLDCODE
if (tg->ProdCon.aaa) { \
5950OLDCODE
bool foundIt = FALSE; \
5952OLDCODE
for (i=0; i<vectorSize(tg->ProdCon.aaa); i++) { \
5953OLDCODE
if (vector_get(
struct X3D_Node*,tg->ProdCon.aaa, i) == structptr) { \
5954OLDCODE foundIt = TRUE; \
5958OLDCODE
if (foundIt) { \
5959OLDCODE
struct Vector *newStack = newVector(
struct X3D_Node*, 2); \
5960OLDCODE
for (i=0; i<vectorSize(tg->ProdCon.aaa); i++) { \
5961OLDCODE
if (vector_get(
struct X3D_Node*,tg->ProdCon.aaa, i) != structptr) { \
5962OLDCODE vector_pushBack(
struct X3D_Node*, newStack, \
5963OLDCODE vector_get(
struct X3D_Node*,tg->ProdCon.aaa,i)); \
5966OLDCODE deleteVector(
struct X3D_Node*, tg->ProdCon.aaa); \
5967OLDCODE tg->ProdCon.aaa = newStack; \
5971OLDCODE #define DELETE_IF_IN_STACK(aaa) \
5972OLDCODE
if (tg->Bindable.aaa) { \
5973OLDCODE
bool foundIt = FALSE; \
5975OLDCODE
for (i=0; i<vectorSize(tg->Bindable.aaa); i++) { \
5976OLDCODE
if (vector_get(
struct X3D_Node*,tg->Bindable.aaa, i) == structptr) { \
5977OLDCODE foundIt = TRUE; \
5981OLDCODE
if (foundIt) { \
5982OLDCODE
struct Vector *newStack = newVector(
struct X3D_Node*, 2); \
5983OLDCODE
for (i=0; i<vectorSize(tg->Bindable.aaa); i++) { \
5984OLDCODE
if (vector_get(
struct X3D_Node*,tg->Bindable.aaa, i) != structptr) { \
5985OLDCODE vector_pushBack(
struct X3D_Node*, newStack, \
5986OLDCODE vector_get(
struct X3D_Node*,tg->Bindable.aaa,i)); \
5989OLDCODE deleteVector(
struct X3D_Node*, tg->Bindable.aaa); \
5990OLDCODE tg->Bindable.aaa = newStack; \
5999BOOL walk_fields(
struct X3D_Node* node, BOOL (*callbackFunc)(),
void* callbackData)
6006 int type,mode,source;
6008 int *fieldOffsetsPtr;
6020 fieldOffsetsPtr = (
int *)NODE_OFFSETS[node->_nodeType];
6022 while (*fieldOffsetsPtr != -1) {
6023 fname = FIELDNAMES[fieldOffsetsPtr[0]];
6025 publicfield = fname && (fname[0] !=
'_') ? TRUE : FALSE;
6026 mode = PKW_from_KW(fieldOffsetsPtr[3]);
6027 type = fieldOffsetsPtr[2];
6029 fieldPtr = (
union anyVrml*)offsetPointer_deref(
char *, node,*(fieldOffsetsPtr+1));
6032 foundField = callbackFunc(callbackData,node,jfield,fieldPtr,fname,mode,type,source,publicfield);
6033 if( foundField )
break;
6034 fieldOffsetsPtr += FIELDOFFSET_LENGTH;
6040 user = nodeTypeSupportsUserFields(node);
6055 switch(node->_nodeType)
6058 case NODE_ComposedShader:
6059 case NODE_ShaderProgram :
6061 case NODE_PackagedShader:
6067 switch(node->_nodeType)
6069 case NODE_Script: shader =(
struct Shader_Script *)(X3D_SCRIPT(node)->__scriptObj);
break;
6070 case NODE_ComposedShader: shader =(
struct Shader_Script *)(X3D_COMPOSEDSHADER(node)->_shaderUserDefinedFields);
break;
6071 case NODE_ShaderProgram: shader =(
struct Shader_Script *)(X3D_SHADERPROGRAM(node)->_shaderUserDefinedFields);
break;
6072 case NODE_PackagedShader: shader =(
struct Shader_Script *)(X3D_PACKAGEDSHADER(node)->_shaderUserDefinedFields);
break;
6073 case NODE_Effect: shader =(
struct Shader_Script *)(X3D_EFFECT(node)->_shaderUserDefinedFields);
break;
6076 for(j=0; j!=vectorSize(shader->fields); ++j)
6079 mode = sfield->fieldDecl->PKWmode;
6080 fname = ScriptFieldDecl_getName(sfield);
6081 type = sfield->fieldDecl->fieldType;
6082 fieldPtr = &sfield->value;
6083 source = node->_nodeType == NODE_Script ? 1 : 2;
6085 foundField = callbackFunc(callbackData,node,jfield,fieldPtr,fname,mode,type,source,publicfield);
6100 for(j=0; j!=vectorSize(pstruct->iface); ++j)
6103 mode = pfield->mode;
6104 fname = pfield->cname;
6105 type = pfield->type;
6106 fieldPtr = &pfield->defaultVal;
6109 foundField = callbackFunc(callbackData,node,jfield,fieldPtr,fname,mode,type,source,publicfield);
6182BOOL isManagedField(
int mode,
int type, BOOL isPublic)
6184 BOOL isManaged = (type == FIELDTYPE_SFNode || type == FIELDTYPE_MFNode);
6185 isManaged = isManaged && (mode == PKW_initializeOnly || mode == PKW_inputOutput);
6186 isManaged = isManaged && isPublic;
6196void indentf(
int indent){
6198 for(m=0;m<indent;m++) printf(
" ");
6201void print_node_links0(
struct X3D_Node* sfn,
int *level);
6202BOOL cbPrintLinks(
void *callbackData,
struct X3D_Node* node,
int jfield,
6203 union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
6205 int *level = (
int*)callbackData;
6210 if(isManagedField(type,mode,publicfield))
6212 int n,k,haveSomething;
6214 haveSomething = (type==FIELDTYPE_SFNode && fieldPtr->sfnode) || (type==FIELDTYPE_MFNode && fieldPtr->mfnode.n);
6217 printf(
"%s ",fieldName);
6218 if(type==FIELDTYPE_SFNode){
6219 plist = &fieldPtr->sfnode;
6222 plist = fieldPtr->mfnode.p;
6223 n = fieldPtr->mfnode.n;
6233 if(n>1) indentf((*level));
6234 print_node_links0(sfn,level);
6236 if(type==FIELDTYPE_MFNode && n > 1){
6247void print_node_links0(
struct X3D_Node* sfn,
int *level)
6252 printf(
"node %p ",sfn);
6253 if(sfn->_parentVector && vectorSize(sfn->_parentVector)){
6255 printf(
" parents={");
6256 for(j=0;j<vectorSize(sfn->_parentVector);j++){
6257 struct X3D_Node *parent = vector_get(
struct X3D_Node *,sfn->_parentVector, j);
6258 printf(
"%p, ",parent);
6263 walk_fields(sfn,cbPrintLinks,level);
6266void print_node_links(
struct X3D_Node* sfn)
6269 print_node_links0(sfn,&level);
6271 printf(
"ouch level =%d\n",level);
6275BOOL cbUnlinkChild(
void *callbackData,
struct X3D_Node* node,
int jfield,
6276 union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
6278 if(isManagedField(mode,type,publicfield)){
6279 if(type == FIELDTYPE_SFNode){
6280 struct X3D_Node **sfn = &fieldPtr->sfnode;
6281 AddRemoveSFNodeFieldChild(node,sfn,*sfn,2,__FILE__,__LINE__);
6282 if(fieldPtr->sfnode)
6283 printf(
"didn't delete sfnode child\n");
6284 }
else if(type == FIELDTYPE_MFNode){
6286 AddRemoveChildren(node,mfn,mfn->p,mfn->n,2,__FILE__,__LINE__);
6291BOOL cbUnlinkParent(
void *callbackData,
struct X3D_Node* parent,
int jfield,
6292 union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
6294 struct X3D_Node* node = X3D_NODE(callbackData);
6295 if(isManagedField(mode,type,publicfield)){
6296 if(type == FIELDTYPE_SFNode){
6297 struct X3D_Node **sfn = &fieldPtr->sfnode;
6298 AddRemoveSFNodeFieldChild(parent,sfn,node,2,__FILE__,__LINE__);
6299 }
else if(type == FIELDTYPE_MFNode){
6301 AddRemoveChildren(parent,mfn,&node,1,2,__FILE__,__LINE__);
6306void unlink_node(
struct X3D_Node* node)
6311 walk_fields(node,cbUnlinkChild,NULL);
6313 if(node->_parentVector && vectorSize(node->_parentVector)){
6315 struct Vector* pp = newVector(
struct X3D_Node*,vectorSize(node->_parentVector));
6316 for(j=0;j<vectorSize(node->_parentVector);j++){
6317 struct X3D_Node *parent = vector_get(
struct X3D_Node *,node->_parentVector, j);
6318 vector_pushBack(
struct X3D_Node*,pp,parent);
6320 for(j=0;j<vectorSize(pp);j++){
6322 walk_fields(parent,cbUnlinkParent,node);
6324 node->_parentVector->n = 0;
6325 deleteVector(
struct X3D_Node*, pp);
6330void deleteMallocedFieldValue(
int type,
union anyVrml *fieldPtr);
6331BOOL cbFreeMallocedBuiltinField(
void *callbackData,
struct X3D_Node* node,
int jfield,
6332 union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
6348 if( strncmp(fieldName,
"__",2) && strcmp(fieldName,
"__oldurl") && strcmp(fieldName,
"_parentVector")) {
6351 deleteMallocedFieldValue(type,fieldPtr);
6352 if(type == FIELDTYPE_FreeWRLPTR){
6353 if(!strncmp(fieldName,
"__x",3) || !strncmp(fieldName,
"__v",3)) {
6354 FREE_IF_NZ(fieldPtr->sfnode);
6362BOOL cbFreePublicMallocedBuiltinField(
void *callbackData,
struct X3D_Node* node,
int jfield,
6363 union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
6374 if(strncmp(fieldName,
"_",1)) {
6377 deleteMallocedFieldValue(type,fieldPtr);
6383BOOL cbFreeMallocedUserField(
void *callbackData,
struct X3D_Node* node,
int jfield,
6384 union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
6397 if(strncmp(fieldName,
"__",2)) {
6400 deleteMallocedFieldValue(type,fieldPtr);
6408 switch(node->_nodeType)
6410 case NODE_Script: shader =(
struct Shader_Script *)(X3D_SCRIPT(node)->__scriptObj);
break;
6411 case NODE_ComposedShader: shader =(
struct Shader_Script *)(X3D_COMPOSEDSHADER(node)->_shaderUserDefinedFields);
break;
6412 case NODE_Effect: shader =(
struct Shader_Script *)(X3D_EFFECT(node)->_shaderUserDefinedFields);
break;
6413 case NODE_ShaderProgram: shader =(
struct Shader_Script *)(X3D_SHADERPROGRAM(node)->_shaderUserDefinedFields);
break;
6414 case NODE_PackagedShader: shader =(
struct Shader_Script *)(X3D_PACKAGEDSHADER(node)->_shaderUserDefinedFields);
break;
6419 switch(node->_nodeType)
6421 case NODE_Script: X3D_SCRIPT(node)->__scriptObj = (
void *)shader;
break;
6422 case NODE_ComposedShader: X3D_COMPOSEDSHADER(node)->_shaderUserDefinedFields = (
void *)shader;;
break;
6423 case NODE_Effect: X3D_EFFECT(node)->_shaderUserDefinedFields = (
void *)shader;;
break;
6424 case NODE_ShaderProgram: X3D_SHADERPROGRAM(node)->_shaderUserDefinedFields = (
void *)shader;;
break;
6425 case NODE_PackagedShader: X3D_PACKAGEDSHADER(node)->_shaderUserDefinedFields = (
void *)shader;;
break;
6433 for(i=0;i<vectorSize(shader->fields);i++){
6435 deleteScriptFieldDecl(field);
6439 FREE_IF_NZ(shader->fields);
6446void freeMallocedNodeFields0(
struct X3D_Node* node){
6456 int isScriptType, isBrotoType, hasUserFields;
6457 isScriptType = node->_nodeType == NODE_Script || node->_nodeType == NODE_ComposedShader || node->_nodeType == NODE_ShaderProgram || node->_nodeType == NODE_PackagedShader;
6458 isBrotoType = node->_nodeType == NODE_Proto;
6459 hasUserFields = isScriptType || isBrotoType;
6464 walk_fields(node,cbFreeMallocedUserField,NULL);
6468 deleteShaderDefinition(shader);
6469 setShader(node,NULL);
6471 }
else if(isBrotoType){
6473 deleteProtoDefinition(pnode->__protoDef);
6474 FREE_IF_NZ(pnode->__protoDef);
6475 FREE_IF_NZ(pnode->__typename);
6485 walk_fields(node,cbFreeMallocedBuiltinField,NULL);
6492void freeMallocedNodeFields(
struct X3D_Node* node){
6494 deleteVector(
void*,node->_parentVector);
6495 if(node->_gc) free_registered_node_gc(node);
6496 freeMallocedNodeFields0(node);
6736#ifdef DEBUG_FW_LOADMAT
6737 static void fw_glLoadMatrixd(GLDOUBLE *val,
char *where,
int line) {
6739 for (i=0; i<16; i++) {
6740 if (val[i] > 2000.0) printf (
"FW_GL_LOADMATRIX, val %d %lf at %s:%d\n",i,val[i],where,line);
6741 if (val[i] < -2000.0) printf (
"FW_GL_LOADMATRIX, val %d %lf at %s:%d\n",i,val[i],where,line);
6745static void fw_glLoadMatrixd(GLDOUBLE *val) {
6749 #ifndef GL_ES_VERSION_2_0
6753BOOL matrix3x3_inverse_float(
float *inn,
float *outt);
6755void sendExplicitMatriciesToShader (GLint ModelViewMatrix, GLint ProjectionMatrix, GLint NormalMatrix, GLint *TextureMatrix, GLint ModelViewInverseMatrix)
6763 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
6767 dp = p->FW_ModelView[p->modelviewTOS];
6771 for (i=0; i<16; i++) {
6775 profile_start(
"sendmtx");
6776 GLUNIFORMMATRIX4FV(ModelViewMatrix,1,GL_FALSE,spval);
6777 profile_end(
"sendmtx");
6780 dp = p->FW_ProjectionView[p->projectionviewTOS];
6783 matdouble2float4(sp,dp);
6789 profile_start(
"sendmtx");
6790 GLUNIFORMMATRIX4FV(ProjectionMatrix,1,GL_FALSE,spval);
6793 profile_end(
"sendmtx");
6796 for(j=0;j<MAX_MULTITEXTURE;j++) {
6797 int itexturestackposition = j+1;
6798 if (TextureMatrix[j] != -1 && itexturestackposition <= p->textureviewTOS) {
6800 dp = p->FW_TextureView[itexturestackposition];
6805 for (i=0; i<16; i++) {
6809 profile_start(
"sendmtx");
6810 GLUNIFORMMATRIX4FV(TextureMatrix[j],1,GL_FALSE,spval);
6813 profile_end(
"sendmtx");
6817 if (ModelViewInverseMatrix != -1 || NormalMatrix != -1) {
6819 GLDOUBLE inverseMV[16];
6823 dpp = p->FW_ModelView[p->modelviewTOS];
6824 memcpy(MV, dpp,
sizeof(GLDOUBLE) * 16);
6825 matinverse(inverseMV, MV);
6826 double2float(spvali, inverseMV, 16);
6828 if( ModelViewInverseMatrix != -1){
6829 GLUNIFORMMATRIX4FV(ModelViewInverseMatrix,1,GL_FALSE,spvali);
6834 if (NormalMatrix != -1) {
6836 GLUNIFORMMATRIX4FV(NormalMatrix, 1, GL_TRUE, spvali);
6847void sendMatriciesToShader(s_shader_capabilities_t *me) {
6848 sendExplicitMatriciesToShader (me->ModelViewMatrix, me->ProjectionMatrix, me->NormalMatrix,me->TextureMatrix,me->ModelViewInverseMatrix);
6851#define SEND_VEC2(myMat,myVal) \
6852if (me->myMat != -1) { GLUNIFORM2FV(me->myMat,1,myVal);}
6854#define SEND_VEC4(myMat,myVal) \
6855if (me->myMat != -1) { GLUNIFORM4FV(me->myMat,1,myVal);}
6857#define SEND_VEC3(myMat,myVal) \
6858if (me->myMat != -1) { GLUNIFORM3FV(me->myMat,1,myVal);}
6860#define SEND_FLOAT(myMat,myVal) \
6861if (me->myMat != -1) { GLUNIFORM1F(me->myMat,myVal);}
6863#define SEND_INT(myMat,myVal) \
6864if (me->myMat != -1) { GLUNIFORM1I(me->myMat,myVal);}
6868void sendFogToShader(s_shader_capabilities_t *me) {
6873 profile_start(
"sendvec");
6874 memcpy(color4,fog->color.c,
sizeof(
float)*3);
6876 SEND_VEC4(fogColor,color4);
6877 SEND_FLOAT(fogvisibilityRange,fog->visibilityRange*fog->__fogScale);
6878 SEND_FLOAT(fogScale,1.0f);
6879 SEND_INT(fogType,fog->__fogType);
6881 profile_end(
"sendvec");
6884float *getTransformedClipPlanes();
6885int getClipPlaneCount();
6886void sendClipplanesToShader(s_shader_capabilities_t *me){
6889 float *clipplanes = getTransformedClipPlanes();
6890 nsend = getClipPlaneCount();
6891 GLUNIFORM4FV(me->clipplanes,nsend,clipplanes);
6892 GLUNIFORM1I(me->nclipplanes,nsend);
6903static int nunit2D = 0;
6904static int nunitCube = 0;
6905static int unit2D[32];
6906static int unitCube[8];
6907void clear_material_samplers();
6908int share_or_next_material_sampler_index_2D(GLint texture);
6909GLint tunit2D(
int index);
6913void clear_material_samplers(){
6917 for (
int i = 0; i < 8; i++) {
6922int share_or_next_material_sampler_index_2D(GLint texture){
6925 kunit = bind_or_share_next_textureUnit(GL_TEXTURE_2D, texture);
6927 for(
int i=0;i<nunit2D;i++){
6928 if(unit2D[i] == kunit){
6933 unit2D[nunit2D] = kunit;
6940GLint tunit2D(
int index){
6942 return unit2D[index];
6944int share_or_next_material_sampler_index_Cube(GLint texture) {
6947 kunit = bind_or_share_next_textureUnit(GL_TEXTURE_CUBE_MAP, texture);
6949 for (
int i = 0; i < nunitCube; i++) {
6950 if (unitCube[i] == kunit) {
6955 unitCube[nunitCube] = kunit;
6962GLint tunitCube(
int index) {
6963 return unitCube[index];
6966void sendLightInfo2(s_shader_capabilities_t* me);
6967int getTextureDescriptors(
struct X3D_Node* textureNode,
int* textures,
int* modes,
int* sources,
int* funcs,
int* width,
int* height,
int* samplr);
6968void sendMaterialsToShader(s_shader_capabilities_t *me) {
6973 ttglobal tg = gglobal();
6975 fw_FrontMaterial = &myap->fw_FrontMaterial;
6976 fw_BackMaterial = &myap->fw_BackMaterial;
6996PRINT_GL_ERROR_IF_ANY(
"BEGIN sendMaterialsToShader");
6999 profile_start(
"sendvec");
7000 GLUNIFORM3FV(me->myMaterialDiffuse,1,fw_FrontMaterial->diffuse);
7001 GLUNIFORM3FV(me->myMaterialEmissive,1,fw_FrontMaterial->emissive);
7002 GLUNIFORM3FV(me->myMaterialSpecular,1,fw_FrontMaterial->specular);
7003 GLUNIFORM3FV(me->myMaterialBaseColor,1,fw_FrontMaterial->baseColor);
7004 GLUNIFORM1F(me->myMaterialAmbient,fw_FrontMaterial->ambient);
7005 GLUNIFORM1F(me->myMaterialShininess,fw_FrontMaterial->shininess);
7006 GLUNIFORM1F(me->myMaterialOcclusion, fw_FrontMaterial->occlusion);
7007 GLUNIFORM1F(me->myMaterialNormalScale, fw_FrontMaterial->normalScale);
7008 GLUNIFORM1F(me->myMaterialTransparency,fw_FrontMaterial->transparency);
7009 GLUNIFORM1F(me->myMaterialRoughness,fw_FrontMaterial->roughness);
7010 GLUNIFORM1F(me->myMaterialMetallic,fw_FrontMaterial->metallic);
7011 GLUNIFORM1I(me->myMaterialType,fw_FrontMaterial->type);
7012 GLUNIFORM1I(me->myMaterialTransdex,fw_FrontMaterial->transdex);
7013 PRINT_GL_ERROR_IF_ANY(
"#2 sendMaterialsToShader");
7015 mp = fw_FrontMaterial;
7018 GLint saveTextureStackTop = tg->RenderFuncs.textureStackTop;
7021 for (
int iuse = 0; iuse < 7; iuse++) {
7024 if (mp->textures[iuse]) {
7028 mp->tcount[iuse] = 0;
7029 mp->tstart[iuse] = nt;
7030 int textures[4], modes[4], sources[4], funcs[4], width[4], height[4], samplr[4];
7031 render_node(mp->textures[iuse]);
7032 int ntdesc = getTextureDescriptors(mp->textures[iuse], textures, modes, sources, funcs, width, height, samplr);
7033 mp->tcount[iuse] = ntdesc;
7034 for (
int j = 0; j < ntdesc; j++) {
7036 mp->samplr[nt] = samplr[j];
7037 if (mp->samplr[nt] == 1)
7038 kunit = share_or_next_material_sampler_index_Cube(textures[j]);
7040 kunit = share_or_next_material_sampler_index_2D(textures[j]);
7041 mp->tindex[nt] = kunit;
7042 mp->source[nt] = sources[j];
7043 mp->mode[nt] = modes[j];
7044 mp->func[nt] = funcs[j];
7045 if (mp->samplr[nt] == 1) {
7046 iunit = tunitCube(kunit);
7047 glUniform1i(me->textureUnitCube[kunit], iunit);
7050 iunit = tunit2D(kunit);
7051 glUniform1i(me->textureUnit[kunit], iunit);
7053 glUniform1i(me->myMaterialTindex[nt], mp->tindex[nt]);
7054 glUniform1i(me->myMaterialMode[nt], mp->mode[nt]);
7055 glUniform1i(me->myMaterialSource[nt], mp->source[nt]);
7056 glUniform1i(me->myMaterialFunc[nt], mp->func[nt]);
7057 glUniform1i(me->myMaterialSampler[nt], mp->samplr[nt]);
7058 glUniform1i(me->myMaterialCmap[nt], mp->cmap[iuse]);
7062 tg->RenderFuncs.textureStackTop = saveTextureStackTop;
7065 GLUNIFORM1I(me->myMaterialTcount[iuse], mp->tcount[iuse]);
7066 GLUNIFORM1I(me->myMaterialTstart[iuse], mp->tstart[iuse]);
7071 PRINT_GL_ERROR_IF_ANY(
"#3 sendMaterialsToShader");
7073 GLUNIFORM3FV(me->myMaterialBackDiffuse,1,fw_BackMaterial->diffuse);
7074 GLUNIFORM3FV(me->myMaterialBackEmissive,1,fw_BackMaterial->emissive);
7075 GLUNIFORM3FV(me->myMaterialBackSpecular,1,fw_BackMaterial->specular);
7076 GLUNIFORM3FV(me->myMaterialBackBaseColor,1,fw_BackMaterial->baseColor);
7077 GLUNIFORM1F(me->myMaterialBackAmbient,fw_BackMaterial->ambient);
7078 GLUNIFORM1F(me->myMaterialBackShininess,fw_BackMaterial->shininess);
7079 GLUNIFORM1F(me->myMaterialBackOcclusion, fw_BackMaterial->occlusion);
7080 GLUNIFORM1F(me->myMaterialBackNormalScale, fw_BackMaterial->normalScale);
7081 GLUNIFORM1F(me->myMaterialBackTransparency,fw_BackMaterial->transparency);
7082 GLUNIFORM1F(me->myMaterialBackRoughness,fw_BackMaterial->roughness);
7083 GLUNIFORM1F(me->myMaterialBackMetallic,fw_BackMaterial->metallic);
7084 GLUNIFORM1I(me->myMaterialBackType,fw_BackMaterial->type);
7085 GLUNIFORM1I(me->myMaterialBackTransdex,fw_BackMaterial->transdex);
7086 PRINT_GL_ERROR_IF_ANY(
"#4 sendMaterialsToShader");
7088 mp = fw_BackMaterial;
7090 GLint saveTextureStackTop = tg->RenderFuncs.textureStackTop;
7092 for (
int iuse = 0; iuse < 7; iuse++) {
7093 if (mp->textures[iuse]) {
7097 mp->tcount[iuse] = 0;
7098 mp->tstart[iuse] = nt;
7099 int textures[4], modes[4], sources[4], funcs[4], width[4], height[4], samplr[4];
7100 render_node(mp->textures[iuse]);
7101 int ntdesc = getTextureDescriptors(mp->textures[iuse], textures, modes, sources, funcs, width, height,samplr);
7102 mp->tcount[iuse] = ntdesc;
7103 for (
int j = 0; j < ntdesc; j++) {
7105 mp->samplr[nt] = samplr[j];
7106 if (mp->samplr[nt] == 1)
7107 kunit = share_or_next_material_sampler_index_Cube(textures[j]);
7109 kunit = share_or_next_material_sampler_index_2D(textures[j]);
7111 mp->tindex[nt] = kunit;
7112 mp->source[nt] = sources[j];
7113 mp->mode[nt] = modes[j];
7114 mp->func[nt] = funcs[j];
7115 if (mp->samplr[nt] == 1) {
7116 iunit = tunitCube(kunit);
7117 glUniform1i(me->textureUnitCube[kunit], iunit);
7120 iunit = tunit2D(kunit);
7121 glUniform1i(me->textureUnit[kunit], iunit);
7123 glUniform1i(me->myMaterialBackTindex[nt], mp->tindex[nt]);
7124 glUniform1i(me->myMaterialBackMode[nt], mp->mode[nt]);
7125 glUniform1i(me->myMaterialBackSource[nt], mp->source[nt]);
7126 glUniform1i(me->myMaterialBackFunc[nt], mp->func[nt]);
7127 glUniform1i(me->myMaterialBackSampler[nt], mp->samplr[nt]);
7128 glUniform1i(me->myMaterialBackCmap[nt], mp->cmap[iuse]);
7131 tg->RenderFuncs.textureStackTop = saveTextureStackTop;
7134 GLUNIFORM1I(me->myMaterialBackTcount[iuse], mp->tcount[iuse]);
7135 GLUNIFORM1I(me->myMaterialBackTstart[iuse], mp->tstart[iuse]);
7137 PRINT_GL_ERROR_IF_ANY(
"#5 sendMaterialsToShader");
7147 profile_end(
"sendvec");
7149 if (me->haveLightInShader) sendLightInfo2(me);
7152 #if defined (GL_ES_VERSION_2_0)
7153 SEND_FLOAT(myPointSize,myap->pointSize);
7155 glPointSize(myap->pointSize > 0 ? myap->pointSize : 1);
7158 profile_start(
"sendmat");
7160 GLUNIFORM1I(me->filledBool,myap->filledBool);
7161 GLUNIFORM1I(me->hatchedBool,myap->hatchedBool);
7162 GLUNIFORM1I(me->hatchAlgo,myap->hatchAlgo);
7163 SEND_VEC4(hatchColour,myap->hatchColour);
7164 PRINT_GL_ERROR_IF_ANY(
"#6 sendMaterialsToShader");
7167 ivec4 vp = get_current_viewport();
7170 GLUNIFORM4F(me->screenresolution,(
float)vp.W,(
float)vp.H,(
float)vp.X,(
float)vp.Y);
7171 if(myap->linetype_uv){
7172 GLUNIFORM2FV(me->linetype_uv,128,myap->linetype_uv);
7173 GLUNIFORM1I(me->linetype,myap->linetype);
7175 GLUNIFORM1I(me->linetype,1);
7177 if(myap->linetype_tse)
7178 GLUNIFORM3FV(me->linetype_tse,128,myap->linetype_tse);
7179 GLUNIFORM1F(me->lineperiod,myap->lineperiod);
7180 GLUNIFORM1F(me->linewidth,myap->linewidth);
7181 GLUNIFORM1I(me->linestrip_start_style,myap->linestrip_start_style);
7182 GLUNIFORM1I(me->linestrip_end_style,myap->linestrip_end_style);
7184 PRINT_GL_ERROR_IF_ANY(
"#7 sendMaterialsToShader");
7188 GLUNIFORM1F(me->pointSize,myap->pointSize);
7189 GLUNIFORM3FV(me->pointAttenuation,1,myap->pointsizeAttenuation);
7190 GLUNIFORM2FV(me->pointRange,1,myap->pointsizeRange);
7191 GLUNIFORM1I(me->pointColorMode,myap->pointColorMode);
7192 GLUNIFORM1I(me->pointMethod,myap->pointMethod);
7194 PRINT_GL_ERROR_IF_ANY(
"#8 sendMaterialsToShader");
7196 SEND_INT(texCoordGenType,myap->texCoordGeneratorType);
7197 profile_end(
"sendmat");
7198 PRINT_GL_ERROR_IF_ANY(
"END sendMaterialsToShader");
7201void __gluMultMatrixVecd(
const GLDOUBLE matrix[16],
const GLDOUBLE in[4],
7206 for (i=0; i<4; i++) {
7208 in[0] * matrix[0*4+i] +
7209 in[1] * matrix[1*4+i] +
7210 in[2] * matrix[2*4+i] +
7211 in[3] * matrix[3*4+i];
7217(GLDOUBLE objx, GLDOUBLE objy, GLDOUBLE objz,
7218 const GLDOUBLE modelMatrix[16],
7219 const GLDOUBLE projMatrix[16],
7220 const GLint viewport[4],
7221 GLDOUBLE *winx, GLDOUBLE *winy, GLDOUBLE *winz)
7230 __gluMultMatrixVecd(modelMatrix, in, out);
7231 __gluMultMatrixVecd(projMatrix, out, in);
7232 if (in[3] == 0.0)
return;
7237 in[0] = in[0] * 0.5 + 0.5;
7238 in[1] = in[1] * 0.5 + 0.5;
7239 in[2] = in[2] * 0.5 + 0.5;
7242 in[0] = in[0] * viewport[2] + viewport[0];
7243 in[1] = in[1] * viewport[3] + viewport[1];
7250void __gluMultMatricesd(
const GLDOUBLE a[16],
const GLDOUBLE b[16],
7255 for (i = 0; i < 4; i++) {
7256 for (j = 0; j < 4; j++) {
7271int __gluInvertMatrixd(
const GLDOUBLE m[16], GLDOUBLE invOut[16])
7273 GLDOUBLE inv[16], det;
7276 inv[0] = m[5]*m[10]*m[15] - m[5]*m[11]*m[14] - m[9]*m[6]*m[15]
7277 + m[9]*m[7]*m[14] + m[13]*m[6]*m[11] - m[13]*m[7]*m[10];
7278 inv[4] = -m[4]*m[10]*m[15] + m[4]*m[11]*m[14] + m[8]*m[6]*m[15]
7279 - m[8]*m[7]*m[14] - m[12]*m[6]*m[11] + m[12]*m[7]*m[10];
7280 inv[8] = m[4]*m[9]*m[15] - m[4]*m[11]*m[13] - m[8]*m[5]*m[15]
7281 + m[8]*m[7]*m[13] + m[12]*m[5]*m[11] - m[12]*m[7]*m[9];
7282 inv[12] = -m[4]*m[9]*m[14] + m[4]*m[10]*m[13] + m[8]*m[5]*m[14]
7283 - m[8]*m[6]*m[13] - m[12]*m[5]*m[10] + m[12]*m[6]*m[9];
7284 inv[1] = -m[1]*m[10]*m[15] + m[1]*m[11]*m[14] + m[9]*m[2]*m[15]
7285 - m[9]*m[3]*m[14] - m[13]*m[2]*m[11] + m[13]*m[3]*m[10];
7286 inv[5] = m[0]*m[10]*m[15] - m[0]*m[11]*m[14] - m[8]*m[2]*m[15]
7287 + m[8]*m[3]*m[14] + m[12]*m[2]*m[11] - m[12]*m[3]*m[10];
7288 inv[9] = -m[0]*m[9]*m[15] + m[0]*m[11]*m[13] + m[8]*m[1]*m[15]
7289 - m[8]*m[3]*m[13] - m[12]*m[1]*m[11] + m[12]*m[3]*m[9];
7290 inv[13] = m[0]*m[9]*m[14] - m[0]*m[10]*m[13] - m[8]*m[1]*m[14]
7291 + m[8]*m[2]*m[13] + m[12]*m[1]*m[10] - m[12]*m[2]*m[9];
7292 inv[2] = m[1]*m[6]*m[15] - m[1]*m[7]*m[14] - m[5]*m[2]*m[15]
7293 + m[5]*m[3]*m[14] + m[13]*m[2]*m[7] - m[13]*m[3]*m[6];
7294 inv[6] = -m[0]*m[6]*m[15] + m[0]*m[7]*m[14] + m[4]*m[2]*m[15]
7295 - m[4]*m[3]*m[14] - m[12]*m[2]*m[7] + m[12]*m[3]*m[6];
7296 inv[10] = m[0]*m[5]*m[15] - m[0]*m[7]*m[13] - m[4]*m[1]*m[15]
7297 + m[4]*m[3]*m[13] + m[12]*m[1]*m[7] - m[12]*m[3]*m[5];
7298 inv[14] = -m[0]*m[5]*m[14] + m[0]*m[6]*m[13] + m[4]*m[1]*m[14]
7299 - m[4]*m[2]*m[13] - m[12]*m[1]*m[6] + m[12]*m[2]*m[5];
7300 inv[3] = -m[1]*m[6]*m[11] + m[1]*m[7]*m[10] + m[5]*m[2]*m[11]
7301 - m[5]*m[3]*m[10] - m[9]*m[2]*m[7] + m[9]*m[3]*m[6];
7302 inv[7] = m[0]*m[6]*m[11] - m[0]*m[7]*m[10] - m[4]*m[2]*m[11]
7303 + m[4]*m[3]*m[10] + m[8]*m[2]*m[7] - m[8]*m[3]*m[6];
7304 inv[11] = -m[0]*m[5]*m[11] + m[0]*m[7]*m[9] + m[4]*m[1]*m[11]
7305 - m[4]*m[3]*m[9] - m[8]*m[1]*m[7] + m[8]*m[3]*m[5];
7306 inv[15] = m[0]*m[5]*m[10] - m[0]*m[6]*m[9] - m[4]*m[1]*m[10]
7307 + m[4]*m[2]*m[9] + m[8]*m[1]*m[6] - m[8]*m[2]*m[5];
7309 det = m[0]*inv[0] + m[1]*inv[4] + m[2]*inv[8] + m[3]*inv[12];
7315 for (i = 0; i < 16; i++)
7316 invOut[i] = inv[i] * det;
7323void fw_gluUnProject(GLDOUBLE winx, GLDOUBLE winy, GLDOUBLE winz,
7324 const GLDOUBLE modelMatrix[16],
7325 const GLDOUBLE projMatrix[16],
7326 const GLint viewport[4],
7327 GLDOUBLE *objx, GLDOUBLE *objy, GLDOUBLE *objz)
7332 GLDOUBLE finalMatrix[16];
7336 __gluMultMatricesd(modelMatrix, projMatrix, finalMatrix);
7337 if (!__gluInvertMatrixd(finalMatrix, finalMatrix))
return;
7345 in[0] = (in[0] - viewport[0]) / viewport[2];
7346 in[1] = (in[1] - viewport[1]) / viewport[3];
7349 in[0] = in[0] * 2 - 1;
7350 in[1] = in[1] * 2 - 1;
7351 in[2] = in[2] * 2 - 1;
7353 __gluMultMatrixVecd(finalMatrix, in, out);
7354 if (out[3] == 0.0)
return;
7364void fw_Ortho (GLDOUBLE left, GLDOUBLE right, GLDOUBLE bottom, GLDOUBLE top, GLDOUBLE nearZ, GLDOUBLE farZ) {
7366 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
7369 dp = p->FW_ProjectionView[p->projectionviewTOS];
7372 if (right <= left) right = left+1.0;
7373 if (top <= bottom) top= bottom+1.0;
7374 if (farZ <= nearZ) farZ= nearZ + 2.0;
7377 mesa_Ortho(left,right,bottom,top,nearZ,farZ,dp);
7381 FW_GL_LOADMATRIX(dp);
7386void fw_gluPerspective(GLDOUBLE fovy, GLDOUBLE aspect, GLDOUBLE zNear, GLDOUBLE zFar) {
7387 GLDOUBLE xmin, xmax, ymin, ymax;
7392 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
7396 ymax = zNear * tan(fovy * M_PI / 360.0);
7398 xmin = ymin * aspect;
7399 xmax = ymax * aspect;
7402 FW_GL_MATRIX_MODE(GL_PROJECTION);
7404 dp = p->FW_ProjectionView[p->projectionviewTOS];
7406 mesa_Frustum(xmin, xmax, ymin, ymax, zNear, zFar, ndp);
7407 mattranspose(ndp2,ndp);
7413 matmultiplyFULL(ndp,ndp2,dp);
7418 #define TRY_PERSPECTIVE_METHOD_1
7419 #ifdef TRY_PERSPECTIVE_METHOD_1
7420 FW_GL_LOADMATRIX(ndp);
7422 memcpy (p->FW_ProjectionView[p->projectionviewTOS],ndp,16*sizeof (GLDOUBLE));
7426 #ifdef TRY_PERSPECTIVE_METHOD_2
7430 GLDOUBLE sine, cotangent, deltaZ;
7431 GLDOUBLE radians = fovy / 2.0 * M_PI / 180.0;
7433 deltaZ = zFar - zNear;
7434 sine = sin(radians);
7435 if ((deltaZ == 0) || (sine == 0) || (aspect == 0)) {
7438 cotangent = cos(radians) / sine;
7440 loadIdentityMatrix(m);
7442 m[0*4+0] = cotangent / aspect;
7443 m[1*4+1] = cotangent;
7444 m[2*4+2] = -(zFar + zNear) / deltaZ;
7446 m[3*4+2] = -2 * zNear * zFar / deltaZ;
7448 matmultiplyFULL(m,m,dp);
7450 FW_GL_LOADMATRIX(m);
7457 #ifdef TRY_PERSPECTIVE_METHOD_3
7463 gluPerspective(fovy,aspect,zNear,zFar);
7464 FW_GL_GETDOUBLEV(GL_PROJECTION_MATRIX,yyy);
7477void fw_gluPerspective_2(GLDOUBLE xcenter, GLDOUBLE fovy, GLDOUBLE aspect, GLDOUBLE zNear, GLDOUBLE zFar) {
7481 GLDOUBLE xmin, xmax, ymin, ymax;
7486 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
7490 ymax = zNear * tan(fovy * M_PI / 360.0);
7492 xmin = ymin * aspect;
7493 xmax = ymax * aspect;
7494 xmin += xcenter * xmin;
7495 xmax += xcenter * xmin;
7497 FW_GL_MATRIX_MODE(GL_PROJECTION);
7499 dp = p->FW_ProjectionView[p->projectionviewTOS];
7501 mesa_Frustum(xmin, xmax, ymin, ymax, zNear, zFar, ndp);
7502 mattranspose(ndp2,ndp);
7508 matmultiplyFULL(ndp,ndp2,dp);
7515 memcpy (p->FW_ProjectionView[p->projectionviewTOS],ndp,16*sizeof (GLDOUBLE));
7518void fw_gluPerspectiveTexture(GLDOUBLE fovy, GLDOUBLE aspect, GLDOUBLE zNear, GLDOUBLE zFar) {
7519 GLDOUBLE xmin, xmax, ymin, ymax;
7524 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
7526 ymax = zNear * tan(fovy * M_PI / 360.0);
7528 xmin = ymin * aspect;
7529 xmax = ymax * aspect;
7532 FW_GL_MATRIX_MODE(GL_TEXTURE);
7533 FW_GL_LOAD_IDENTITY();
7535 dp = p->FW_TextureView[p->textureviewTOS];
7537 mesa_Frustum(xmin, xmax, ymin, ymax, zNear, zFar, ndp);
7538 mattranspose(ndp2,ndp);
7544 matmultiply(ndp,ndp2,dp);
7547 FW_GL_LOADMATRIX(ndp);
7550 memcpy (p->FW_TextureView[p->textureviewTOS],ndp,16*sizeof (GLDOUBLE));
7553void fw_gluPerspectiveTextureLookAt(GLDOUBLE ex, GLDOUBLE ey, GLDOUBLE ez,
7554 GLDOUBLE cx, GLDOUBLE cy, GLDOUBLE cz,
7555 GLDOUBLE ux,GLDOUBLE uy,GLDOUBLE uz)
7557 GLDOUBLE sx, sy, sz;
7558 GLDOUBLE fx, fy, fz;
7564 ppOpenGL_Utils p = (ppOpenGL_Utils)gglobal()->OpenGL_Utils.prv;
7565 FW_GL_MATRIX_MODE(GL_TEXTURE);
7568 dp = p->FW_TextureView[p->textureviewTOS];
7570 sx=cx-ex; sy=cy-ey; sz=cz-ez;
7571 fx=sy*ux-uy*sz; fy=sz*ux-sx*uz; fz=sx*uy-sy*ux;
7573 ndp1[0]=sx;ndp1[4]=sy;ndp1[8]=sz;ndp1[12]=0;
7574 ndp1[1]=ux;ndp1[5]=uy;ndp1[9]=uz;ndp1[13]=0;
7575 ndp1[2]=-fx;ndp1[6]=-fy;ndp1[10]=-fz;ndp1[14]=0;
7576 ndp1[3]=0;ndp1[7]=0;ndp1[11]=0;ndp1[15]=1;
7578 ndp2[0]=1;ndp2[4]=0;ndp2[8]=0;ndp2[12]=-ex;
7579 ndp2[1]=0;ndp2[5]=1;ndp2[9]=0;ndp2[13]=-ey;
7580 ndp2[2]=0;ndp2[6]=0;ndp2[10]=1;ndp2[14]=-ez;
7581 ndp2[3]=0;ndp2[7]=0;ndp2[11]=0;ndp2[15]=1;
7583 matmultiply(ndp3,ndp1,ndp2);
7584 matmultiply(ndp,ndp3,dp);
7586 FW_GL_LOADMATRIX(ndp);
7589 memcpy (p->FW_TextureView[p->textureviewTOS],ndp,16*sizeof (GLDOUBLE));
7595void fw_gluPickMatrix(GLDOUBLE xx, GLDOUBLE yy, GLDOUBLE width, GLDOUBLE height, GLint *vp) {
7597 printf (
"PickMat %lf %lf %lf %lf %d %d %d %d\n",xx,yy,width,height,vp[0], vp[1],vp[2],vp[3]);
7600 if ((width < 0.0) || (height < 0.0))
return;
7602 FW_GL_TRANSLATE_D((vp[2] - 2.0 * (xx - vp[0])) / width, (vp[3] - 2.0 * (yy - vp[1])) / height, 0.0);
7603 FW_GL_SCALE_D(vp[2] / width, vp[3] / height, 1.0);
7622void mesa_Frustum(GLDOUBLE left, GLDOUBLE right, GLDOUBLE bottom, GLDOUBLE top, GLDOUBLE nearZ, GLDOUBLE farZ, GLDOUBLE *m)
7625 GLDOUBLE x = (2.0*nearZ) / (right-left);
7626 GLDOUBLE y = (2.0*nearZ) / (top-bottom);
7627 GLDOUBLE a = (right+left) / (right-left);
7628 GLDOUBLE b = (top+bottom) / (top-bottom);
7629 GLDOUBLE c = -(farZ+nearZ) / ( farZ-nearZ);
7630 GLDOUBLE d = -(2.0F*farZ*nearZ) / (farZ-nearZ);
7666void mesa_Ortho(GLDOUBLE left, GLDOUBLE right, GLDOUBLE bottom, GLDOUBLE top, GLDOUBLE nearZ, GLDOUBLE farZ, GLDOUBLE *m)
7668#define M(row,col) m[col*4+row]
7669 M(0,0) = 2.0F / (right-left);
7672 M(0,3) = -(right+left) / (right-left);
7675 M(1,1) = 2.0F / (top-bottom);
7677 M(1,3) = -(top+bottom) / (top-bottom);
7681 M(2,2) = -2.0F / (farZ-nearZ);
7682 M(2,3) = -(farZ+nearZ) / (farZ-nearZ);
7693void projPerspective(GLDOUBLE fovy, GLDOUBLE aspect, GLDOUBLE zNear, GLDOUBLE zFar, GLDOUBLE *matrix) {
7694 GLDOUBLE xmin, xmax, ymin, ymax;
7699 ymax = zNear * tan(fovy * M_PI / 360.0);
7701 xmin = ymin * aspect;
7702 xmax = ymax * aspect;
7704 mesa_Frustum(xmin, xmax, ymin, ymax, zNear, zFar, ndp);
7705 mattranspose(ndp2,ndp);
7707 memcpy (matrix,ndp2,16*
sizeof (GLDOUBLE));
7711void projLookAt(GLDOUBLE eyex, GLDOUBLE eyey, GLDOUBLE eyez,
7712 GLDOUBLE centerx, GLDOUBLE centery, GLDOUBLE centerz,
7713 GLDOUBLE upx, GLDOUBLE upy, GLDOUBLE upz, GLDOUBLE *matrix)
7716 GLDOUBLE x[3], y[3], z[3];
7719 z[0] = eyex - centerx;
7720 z[1] = eyey - centery;
7721 z[2] = eyez - centerz;
7722 mag = sqrt(z[0] * z[0] + z[1] * z[1] + z[2] * z[2]);
7733 x[0] = y[1] * z[2] - y[2] * z[1];
7734 x[1] = -y[0] * z[2] + y[2] * z[0];
7735 x[2] = y[0] * z[1] - y[1] * z[0];
7737 y[0] = z[1] * x[2] - z[2] * x[1];
7738 y[1] = -z[0] * x[2] + z[2] * x[0];
7739 y[2] = z[0] * x[1] - z[1] * x[0];
7741 mag = sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
7748 mag = sqrt(y[0] * y[0] + y[1] * y[1] + y[2] * y[2]);
7755#define M(row,col) m[col*4+row]
7775 FW_GL_TRANSFORM_D(m);
7777 FW_GL_TRANSLATE_D(-eyex, -eyey, -eyez);
7780 vecsetd(eye,-eyex,-eyey,-eyez);
7781 mattranslate4d(m,eye);
7782 memcpy (matrix,m,16*
sizeof (GLDOUBLE));
7786void projOrtho (GLDOUBLE l, GLDOUBLE r, GLDOUBLE b, GLDOUBLE t,
7787 GLDOUBLE n, GLDOUBLE f,GLDOUBLE *matrix)
7792#define M(row,col) m[col*4+row]
7793 M(0, 0) = 2.0/(r-l);
7796 M(0, 3) = -((r+l) / r-l);
7798 M(1, 1) = 2.0/(t-b);
7800 M(1, 3) = -((t+b)/(r-b));
7803 M(2, 2) = -2.0/(f-n);
7804 M(2, 3) = -((f+n)/(f-n));
7828 memcpy (matrix,m,16*
sizeof (GLDOUBLE));