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/sounds.h"
53#include "../scenegraph/LinearAlgebra.h"
54#include "../scenegraph/Component_KeyDevice.h"
55#include "../input/EAIHeaders.h"
56#include "../input/InputFunctions.h"
58#include "../opengl/Material.h"
59#include "../scenegraph/Component_Core.h"
60#include "../scenegraph/Component_Networking.h"
61#include "LoadTextures.h"
62#include "OpenGL_Utils.h"
64#include "../scenegraph/RenderFuncs.h"
65#include "../scenegraph/Component_Shape.h"
68#include "../x3d_parser/Bindable.h"
70#include "../ui/common.h"
72void kill_rendering(
void);
76static void mesa_Frustum(GLDOUBLE left, GLDOUBLE right, GLDOUBLE bottom, GLDOUBLE top, GLDOUBLE nearZ, GLDOUBLE farZ, GLDOUBLE *m);
79#undef DEBUG_FW_LOADMAT
80#ifdef DEBUG_FW_LOADMAT
81static void fw_glLoadMatrixd(GLDOUBLE *val,
char *,
int);
82#define FW_GL_LOADMATRIX(aaa) fw_glLoadMatrixd(aaa,__FILE__,__LINE__);
84static void fw_glLoadMatrixd(GLDOUBLE *val);
85#define FW_GL_LOADMATRIX(aaa) fw_glLoadMatrixd(aaa);
98void mesa_Ortho(GLDOUBLE left, GLDOUBLE right, GLDOUBLE bottom, GLDOUBLE top, GLDOUBLE nearZ, GLDOUBLE farZ, GLDOUBLE *m);
109#define LOCK_MEMORYTABLE pthread_mutex_lock(&p->memtablelock);
110#define UNLOCK_MEMORYTABLE pthread_mutex_unlock(&p->memtablelock);
117#define MAX_LARGE_MATRIX_STACK 256
118#define MAX_SMALL_MATRIX_STACK 9
119#define MATRIX_SIZE 16
120typedef GLDOUBLE MATRIX4[MATRIX_SIZE];
127 struct Vector *linearNodeTable;
129 int potentialHoleCount;
131 float cc_red, cc_green, cc_blue, cc_alpha;
132 pthread_mutex_t memtablelock;
133 MATRIX4 FW_ModelView[MAX_LARGE_MATRIX_STACK];
134 MATRIX4 FW_ProjectionView[MAX_SMALL_MATRIX_STACK];
135 MATRIX4 FW_TextureView[MAX_SMALL_MATRIX_STACK];
138 int projectionviewTOS;
143 GLDOUBLE *currentMatrix;
148 struct Vector *myShaderTable;
149 int userDefinedShaderCount;
150 char *userDefinedFragmentShader[MAX_USER_DEFINED_SHADERS];
151 char *userDefinedVertexShader[MAX_USER_DEFINED_SHADERS];
157void *OpenGL_Utils_constructor(){
162void OpenGL_Utils_init(
struct tOpenGL_Utils *t)
166 t->displayDepth = 24;
169 t->cc_changed = FALSE;
172 t->prv = OpenGL_Utils_constructor();
175 p->linearNodeTable = NULL;
176 p->potentialHoleCount = 0;
182 pthread_mutex_init(&(p->memtablelock), NULL);
186 p->projectionviewTOS = 0;
187 p->textureviewTOS = 0;
190 p->whichMode = GL_MODELVIEW;
191 p->currentMatrix = p->FW_ModelView[0];
194 loadIdentityMatrix(p->FW_ModelView[0]);
195 loadIdentityMatrix(p->FW_ProjectionView[0]);
196 loadIdentityMatrix(p->FW_TextureView[0]);
204 p->userDefinedShaderCount = 0;
211void OpenGL_Utils_clear(
struct tOpenGL_Utils *t)
217 deleteVector(
struct X3D_Node*,p->linearNodeTable);
218 if(p->myShaderTable){
220 for(i=0;i<vectorSize(p->myShaderTable);i++){
222 FREE_IF_NZ(entry->myCapabilities);
230GLEWContext * glewGetContext()
237GLDOUBLE *getPickrayMatrix(
int index)
242 bstack = getActiveBindableStacks(tg);
243 return bstack->pickraymatrix[index];
245void setPickrayMatrix(
int index, GLDOUBLE *mat)
250 bstack = getActiveBindableStacks(tg);
251 memcpy(bstack->pickraymatrix[index],mat,16*
sizeof(GLDOUBLE));
255void kill_userDefinedShaders() {
262 p->userDefinedShaderCount = 0;
266 for (i=0; i<MAX_USER_DEFINED_SHADERS; i++) {
269 FREE_IF_NZ (p->userDefinedFragmentShader[i]);
270 FREE_IF_NZ (p->userDefinedVertexShader[i]);
273 for (i=0; i <vectorSize(p->myShaderTable); i++) {
275 FREE_IF_NZ(me->myCapabilities);
283 p->myShaderTable->n = 0;
288int getNextFreeUserDefinedShaderSlot() {
294 p->userDefinedShaderCount++;
295 if (p->userDefinedShaderCount == MAX_USER_DEFINED_SHADERS)
return -1;
297 rv = p->userDefinedShaderCount;
303void sendShaderTextToEngine(
int ste,
int parts,
char ** vertSource,
char ** fragSource) {
313 for (i=0; i<parts; i++) {
315 if (vertSource[i] != NULL) vs=vertSource[i];
316 if (fragSource[i] != NULL) fs=fragSource[i];
320 p->userDefinedFragmentShader[ste] = fs;
321 p->userDefinedVertexShader[ste] = vs;
325#if defined (_ANDROID)
339void fwl_decomposeShape(
struct X3D_Shape * node,
348 struct X3D_Node * geom = node->geometry;
351 *fpptr = NULL; *lpptr = NULL; *matptr = NULL; *texptr = NULL;
352 *texttptr = NULL; *geomptr = NULL;
354 POSSIBLE_PROTO_EXPANSION(
struct X3D_Appearance *,X3D_NODE(app),app);
355 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node*,geom,geom);
366 POSSIBLE_PROTO_EXPANSION(
struct X3D_Material *,X3D_NODE(mat),*matptr);
372 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node *,geom,*geomptr);
381int fwl_android_get_valid_shapeNodes(
struct Vector **shapeNodes) {
390 if (*shapeNodes == NULL) {
391 *shapeNodes = newVector (
struct X3D_Shape *, 16);
395 if (p==NULL)
return 0;
396 if (p->linearNodeTable==NULL)
return 0;
403 for (tc=0; tc<vectorSize(p->linearNodeTable); tc++){
404 struct X3D_Node *node = vector_get(
struct X3D_Node *,p->linearNodeTable, tc);
409 POSSIBLE_PROTO_EXPANSION (
struct X3D_Node *,node,node);
412 if ((node->_nodeType == NODE_Shape) && (node->referenceCount>0)) {
413 struct X3D_Node *geom = X3D_SHAPE(node)->geometry;
417 POSSIBLE_PROTO_EXPANSION (
struct X3D_Node *, geom, geom);
419 if ((geom->_nodeType != NODE_IndexedLineSet) &&
420 (geom->_nodeType != NODE_LineSet) &&
421 (geom->_nodeType != NODE_PointSet)) {
424 vector_pushBack(
struct X3D_Node *,me, node);
457 return vectorSize(me);
464void fwl_android_zero_shapeNodeTable(
struct Vector **shapeNodes) {
465 if (*shapeNodes == NULL) {
466 *shapeNodes = newVector (
struct X3D_Shape *, 16);
469 vectorSize(*shapeNodes) = 0;
479int fwl_get_FillPropStatus(
struct Vector **shapeNodes,
int whichEntry) {
492 if (vectorSize(*shapeNodes) == 0 ) {
493 if (fwl_android_get_valid_shapeNodes(shapeNodes) == 0)
return FALSE;
498 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
500 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
504 return (fp->_enabled);
509void fwl_set_FillPropStatus (
struct Vector **shapeNodes,
int whichEntry,
int yesNo,
float fillScale) {
520 if (vectorSize(*shapeNodes) == 0 ) {
521 if (fwl_android_get_valid_shapeNodes(shapeNodes) == 0)
return;
526 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
529 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
535 if (X3D_SHAPE(node)->appearance == NULL) {
537 ap = createNewX3DNode(NODE_Appearance);
538 AddRemoveSFNodeFieldChild(node,
539 offsetPointer_deref(
struct X3D_Node **,node,offsetof (
struct X3D_Shape, appearance)),
540 X3D_NODE(ap),0,__FILE__,__LINE__);
542 mat = createNewX3DNode(NODE_Material);
543 AddRemoveSFNodeFieldChild(X3D_NODE(ap),
545 X3D_NODE(mat),0,__FILE__,__LINE__);
549 ap = X3D_APPEARANCE(X3D_SHAPE(node)->appearance);
554 if (ap->fillProperties == NULL) {
556 fp = X3D_FILLPROPERTIES(createNewX3DNode(NODE_FillProperties));
557 AddRemoveSFNodeFieldChild(X3D_NODE(ap),
559 X3D_NODE(fp),0,__FILE__,__LINE__);
562 fp = X3D_FILLPROPERTIES(ap->fillProperties);
564 if (fp->_nodeType == NODE_FillProperties) fp->_enabled = TRUE;
568 fp->_hatchScale.c[0] = fillScale;
569 fp->_hatchScale.c[1] = fillScale;
577 ap = X3D_APPEARANCE(X3D_SHAPE(node)->appearance);
579 if (ap->fillProperties != NULL) {
582 if (fp->_nodeType == NODE_FillProperties) fp->_enabled = FALSE;
591int fwl_get_FillPropHatched(
struct Vector **shapeNodes,
int whichEntry) {
600 if (vectorSize(*shapeNodes) == 0 ) {
605 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
606 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
608 return (fp->hatched);
612void fwl_set_FillPropHatched (
struct Vector **shapeNodes,
int whichEntry,
int yesNo) {
622 if (vectorSize(*shapeNodes) == 0 ) {
627 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
628 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
630 if (fp!=NULL) fp->hatched = yesNo;
634int fwl_get_FillPropFilled(
struct Vector **shapeNodes,
int whichEntry) {
643 if (vectorSize(*shapeNodes) == 0 ) {
648 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
649 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
655void fwl_set_FillPropFilled (
struct Vector **shapeNodes,
int whichEntry,
int yesNo) {
665 if (vectorSize(*shapeNodes) == 0 ) {
670 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
671 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
673 if (fp!=NULL) fp->filled = yesNo;
678int fwl_get_FillPropStyle(
struct Vector **shapeNodes,
int whichEntry) {
687 if (vectorSize(*shapeNodes) == 0 ) {
692 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
693 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
695 if (fp==NULL)
return 0;
696 return (fp->hatchStyle);
700void fwl_set_FillPropStyle (
struct Vector **shapeNodes,
int whichEntry,
int which) {
710 if (vectorSize(*shapeNodes) == 0 ) {
715 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
716 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
718 if (fp!=NULL) fp->hatchStyle = which;
723int fwl_get_FillPropColour(
struct Vector **shapeNodes,
int whichEntry) {
733 if (vectorSize(*shapeNodes) == 0 ) {
738 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
739 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
741 #define CLAMP(value, min, max) (((value) >(max)) ? (max) : (((value) <(min)) ? (min) : (value)))
742 if (fp==NULL)
return 0;
744 integer_colour = 0xFF000000 + (
745 ((uint8_t)(255.0f *CLAMP(fp->hatchColor.c[0], 0.0, 1.0)) <<16) |
746 ((uint8_t)(255.0f *CLAMP(fp->hatchColor.c[1], 0.0, 1.0)) <<8) |
747 ((uint8_t)(255.0f *CLAMP(fp->hatchColor.c[2], 0.0, 1.0))));
750 return (integer_colour);
754void fwl_set_FillPropColour (
struct Vector **shapeNodes,
int whichEntry,
int argbColour) {
764 if (vectorSize(*shapeNodes) == 0 ) {
769 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
770 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
773 fp->hatchColor.c[0] =CLAMP(((
float)((argbColour &0xff0000) >>16)) /255.0, 0.0, 1.0);
774 fp->hatchColor.c[1] =CLAMP(((
float)((argbColour &0x00ff00) >>8)) /255.0, 0.0, 1.0);
775 fp->hatchColor.c[2] =CLAMP(((
float)((argbColour &0x0000ff))) /255.0, 0.0, 1.0);
788int fwl_set_MaterialExisting(
struct Vector **shapeNodes,
int whichEntry) {
798 int twoSided = FALSE;
802 if (vectorSize(*shapeNodes) == 0 ) {
803 if (fwl_android_get_valid_shapeNodes(shapeNodes) == 0)
return FALSE;
808 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
811 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
815 if (X3D_SHAPE(node)->appearance == NULL) {
817 ap = createNewX3DNode(NODE_Appearance);
818 AddRemoveSFNodeFieldChild(node,
819 offsetPointer_deref(
struct X3D_Node **,node,offsetof (
struct X3D_Shape, appearance)),
820 X3D_NODE(ap),0,__FILE__,__LINE__);
822 mat = createNewX3DNode(NODE_TwoSidedMaterial);
823 AddRemoveSFNodeFieldChild(X3D_NODE(ap),
825 X3D_NODE(mat),0,__FILE__,__LINE__);
828 ap = X3D_APPEARANCE(X3D_SHAPE(node)->appearance);
834 if (ap->material == NULL) {
836 tsm = X3D_TWOSIDEDMATERIAL(createNewX3DNode(NODE_TwoSidedMaterial));
837 AddRemoveSFNodeFieldChild(X3D_NODE(ap),
839 X3D_NODE(tsm),0,__FILE__,__LINE__);
842 tsm = X3D_TWOSIDEDMATERIAL(ap->material);
846 if (tsm->_nodeType != NODE_TwoSidedMaterial) {
849 if (mat->_nodeType == NODE_Material) {
851 ntsm->ambientIntensity = mat->ambientIntensity;
852 ntsm->backAmbientIntensity = mat->ambientIntensity;
853 ntsm->shininess = mat->shininess;
854 ntsm->backShininess = mat->shininess;
855 ntsm->transparency = mat->transparency;
856 ntsm->backTransparency = mat->transparency;
857 memcpy((
void *)&ntsm->diffuseColor, (
void *)&mat->diffuseColor,
sizeof(
struct SFColor));
858 memcpy((
void *)&ntsm->backDiffuseColor, (
void *)&mat->diffuseColor,
sizeof(
struct SFColor));
859 memcpy((
void *)&ntsm->emissiveColor, (
void *)&mat->emissiveColor,
sizeof(
struct SFColor));
860 memcpy((
void *)&ntsm->backEmissiveColor, (
void *)&mat->emissiveColor,
sizeof(
struct SFColor));
861 memcpy((
void *)&ntsm->specularColor, (
void *)&mat->specularColor,
sizeof(
struct SFColor));
862 memcpy((
void *)&ntsm->backSpecularColor, (
void *)&mat->specularColor,
sizeof(
struct SFColor));
863 ntsm->separateBackColor=FALSE;
865 ConsoleMessage (
"somehow the Material is not a node of Material type for this node");
869 AddRemoveSFNodeFieldChild(X3D_NODE(ap),
871 X3D_NODE(ntsm),0,__FILE__,__LINE__);
874 twoSided = X3D_TWOSIDEDMATERIAL(tsm)->separateBackColor;
900int fwl_get_MaterialColourValue(
struct Vector **shapeNodes,
int whichEntry,
int whichValue) {
912 if (vectorSize(*shapeNodes) == 0 ) {
913 if (fwl_android_get_valid_shapeNodes(shapeNodes) == 0)
return 0;
918 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
921 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
923 if (mat == NULL)
return 0;
925 if (mat->_nodeType == NODE_TwoSidedMaterial) {
928 switch (whichValue) {
929 case 0: col = &tmat->diffuseColor;
break;
930 case 1: col = &tmat->emissiveColor;
break;
931 case 2: col = &tmat->specularColor;
break;
932 case 3: col = &tmat->backDiffuseColor;
break;
933 case 4: col = &tmat->backEmissiveColor;
break;
934 case 5: col = &tmat->backSpecularColor;
break;
939 integer_colour = 0xFF000000 + (
940 ((uint8_t)(255.0f *CLAMP(col->c[0], 0.0, 1.0)) <<16) |
941 ((uint8_t)(255.0f *CLAMP(col->c[1], 0.0, 1.0)) <<8) |
942 ((uint8_t)(255.0f *CLAMP(col->c[2], 0.0, 1.0))));
944 return integer_colour;
947 ConsoleMessage (
"getMaterialValue, expected a TwoSidedMaterial, not a %s\n",stringNodeType(mat->_nodeType));
953void fwl_set_TwoSidedMaterialStatus(
struct Vector **shapeNodes,
int whichEntry,
int oneTwo) {
963 if (vectorSize(*shapeNodes) == 0 ) {
968 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
969 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
971 if (mat == NULL)
return;
972 if (mat->_nodeType == NODE_TwoSidedMaterial) {
974 X3D_TWOSIDEDMATERIAL(mat)->separateBackColor = oneTwo;
980void fwl_set_MaterialColourValue (
struct Vector **shapeNodes,
int whichEntry,
int whichValue,
int argbColour) {
990 if (vectorSize(*shapeNodes) == 0 ) {
995 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
996 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
998 if (mat == NULL)
return;
999 if (mat->_nodeType == NODE_TwoSidedMaterial) {
1002 switch (whichValue) {
1003 case 0: col = &tmat->diffuseColor;
break;
1004 case 1: col = &tmat->emissiveColor;
break;
1005 case 2: col = &tmat->specularColor;
break;
1006 case 3: col = &tmat->backDiffuseColor;
break;
1007 case 4: col = &tmat->backEmissiveColor;
break;
1008 case 5: col = &tmat->backSpecularColor;
break;
1012 col->c[0] =CLAMP(((
float)((argbColour &0xff0000) >>16)) /255.0, 0.0, 1.0);
1013 col->c[1] =CLAMP(((
float)((argbColour &0x00ff00) >>8)) /255.0, 0.0, 1.0);
1014 col->c[2] =CLAMP(((
float)((argbColour &0x0000ff))) /255.0, 0.0, 1.0);
1027int fwl_get_MaterialFloatValue(
struct Vector **shapeNodes,
int whichEntry,
int whichSide,
int whichField) {
1041 if (vectorSize(*shapeNodes) == 0 ) {
1042 if (fwl_android_get_valid_shapeNodes(shapeNodes) == 0)
return 0;
1047 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
1050 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
1052 if (mat == NULL)
return 0;
1054 if (mat->_nodeType == NODE_TwoSidedMaterial) {
1058 switch (whichField) {
1059 case 1: fcol = tmat->shininess;
break;
1060 case 2: fcol = tmat->transparency;
break;
1061 case 3: fcol = tmat->ambientIntensity;
break;
1063 ConsoleMessage (
"hmmm - expect 1-3, got %d",whichField);
1068 switch (whichField) {
1069 case 1: fcol = tmat->backShininess;
break;
1070 case 2: fcol = tmat->backTransparency;
break;
1071 case 3: fcol = tmat->backAmbientIntensity;
break;
1073 ConsoleMessage (
"hmmm - expect 1-3, got %d",whichField);
1079 return (
int)(fcol*100.0);
1081 ConsoleMessage (
"getMaterialValue, expected a TwoSidedMaterial, not a %s\n",stringNodeType(mat->_nodeType));
1087void fwl_set_MaterialFloatValue(
struct Vector **shapeNodes,
int whichEntry,
int whichSide,
int whichField,
int nv) {
1101 if (vectorSize(*shapeNodes) == 0 ) {
1102 if (fwl_android_get_valid_shapeNodes(shapeNodes) == 0)
return;
1107 struct X3D_Node *node = vector_get(
struct X3D_Node *,*shapeNodes, whichEntry);
1110 fwl_decomposeShape(X3D_SHAPE(node),&fp,&lp,&mat,&tex,&tt,&geom);
1112 if (mat == NULL)
return;
1114 if (mat->_nodeType == NODE_TwoSidedMaterial) {
1116 float nnv = CLAMP(((
float)nv)/100.0,0.0,1.0);
1119 switch (whichField) {
1120 case 1: tmat->shininess=nnv;
break;
1121 case 2: tmat->transparency=nnv;
break;
1122 case 3: tmat->ambientIntensity=nnv;
break;
1124 ConsoleMessage (
"hmmm - expect 1-3, got %d",whichField);
1128 switch (whichField) {
1129 case 1: tmat->backShininess=nnv;
break;
1130 case 2: tmat->backTransparency=nnv;
break;
1131 case 3: tmat->backAmbientIntensity=nnv;
break;
1133 ConsoleMessage (
"hmmm - expect 1-3, got %d",whichField);
1139 ConsoleMessage (
"getMaterialValue, expected a TwoSidedMaterial, not a %s\n",stringNodeType(mat->_nodeType));
1146#define TURN_OFF_SHOULDSORTCHILDREN node->_renderFlags = node->_renderFlags & (0xFFFF^ VF_shouldSortChildren);
1156OLDCODEvoid fwl_set_glClearColor (
float red ,
float green ,
float blue ,
float alpha) {
1160OLDCODE p->cc_red = red; p->cc_green = green ; p->cc_blue = blue ; p->cc_alpha = alpha ;
1161OLDCODE tg->OpenGL_Utils.cc_changed = TRUE;
1164OLDCODEvoid setglClearColor (
float *val) {
1168OLDCODE p->cc_red = *val; val++;
1169OLDCODE p->cc_green = *val; val++;
1170OLDCODE p->cc_blue = *val;
1177OLDCODE tg->OpenGL_Utils.cc_changed = TRUE;
1182void fwl_setShadingStyle(
int val) {
1187 p->shadingStyle = val;
1189int fwl_getShadingStyle() {
1193 return p->shadingStyle;
1199OLDCODEvoid fwl_set_phongShading (
int val) {
1203OLDCODE
if(val) fwl_setShadingStyle(2);
1204OLDCODE
else fwl_setShadingStyle(1);
1207OLDCODEint fwl_get_phongShading () {
1211OLDCODE
return fwl_getShadingStyle() == 2 ? TRUE : FALSE;
1245static void shaderErrorLog(GLuint myShader,
char *which) {
1246 #if defined (GL_VERSION_2_0) || defined (GL_ES_VERSION_2_0)
1247 #define MAX_INFO_LOG_SIZE 512
1248 GLchar infoLog[MAX_INFO_LOG_SIZE];
1249 char outline[MAX_INFO_LOG_SIZE*2];
1250 glGetShaderInfoLog(myShader, MAX_INFO_LOG_SIZE, NULL, infoLog);
1251 sprintf(outline,
"problem with %s shader: %s",which, infoLog);
1252 ConsoleMessage (outline);
1254 ConsoleMessage (
"Problem compiling shader");
1267 #ifdef GL_SHADER_COMPILER
1269 static bool haveDoneThis =
false;
1277 struct Vector *myShaderTable = p->myShaderTable;
1283 for (i=0; i<vectorSize(myShaderTable); i++) {
1286 if(me->whichOne.volume == rq_cap0.volume && me->whichOne.effects == rq_cap0.effects){
1287 return me->myCapabilities;
1290 if (me->whichOne.base == rq_cap0.base && me->whichOne.effects == rq_cap0.effects && me->whichOne.usershaders == rq_cap0.usershaders) {
1292 return me->myCapabilities;
1312#ifdef GL_SHADER_COMPILER
1313 glGetBooleanv(GL_SHADER_COMPILER,&b);
1314 if (!haveDoneThis) {
1315 haveDoneThis =
true;
1319 ConsoleMessage(
"no shader compiler\n");
1328#if defined (GL_SHADER_COMPILER) && defined (GL_HIGH_FLOAT)
1331 GLint range[2]; GLint precision;
1334 ConsoleMessage(
"starting getMyShader");
1336 glGetBooleanv(GL_SHADER_COMPILER,&b);
1337 if (b) ConsoleMessage(
"have shader compiler");
else ConsoleMessage(
"NO SHADER COMPILER");
1340 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_LOW_FLOAT, range, &precision);
1341 ConsoleMessage (
"GL_VERTEX_SHADER, GL_LOW_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
1342 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_MEDIUM_FLOAT, range, &precision);
1343 ConsoleMessage (
"GL_VERTEX_SHADER, GL_MEDIUM_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
1344 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_HIGH_FLOAT, range, &precision);
1345 ConsoleMessage (
"GL_VERTEX_SHADER, GL_HIGH_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
1347 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_LOW_INT, range, &precision);
1348 ConsoleMessage (
"GL_VERTEX_SHADER, GL_LOW_INT range [%d,%d],precision %d",range[0],range[1],precision);
1349 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_MEDIUM_INT, range, &precision);
1350 ConsoleMessage (
"GL_VERTEX_SHADER, GL_MEDIUM_INT range [%d,%d],precision %d",range[0],range[1],precision);
1351 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_HIGH_INT, range, &precision);
1352 ConsoleMessage (
"GL_VERTEX_SHADER, GL_HIGH_INT range [%d,%d],precision %d",range[0],range[1],precision);
1354 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_LOW_FLOAT, range, &precision);
1355 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_LOW_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
1356 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_MEDIUM_FLOAT, range, &precision);
1357 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_MEDIUM_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
1358 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_HIGH_FLOAT, range, &precision);
1359 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_HIGH_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
1361 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_LOW_INT, range, &precision);
1362 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_LOW_INT range [%d,%d],precision %d",range[0],range[1],precision);
1363 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_MEDIUM_INT, range, &precision);
1364 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_MEDIUM_INT range [%d,%d],precision %d",range[0],range[1],precision);
1365 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_HIGH_INT, range, &precision);
1366 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_HIGH_INT range [%d,%d],precision %d",range[0],range[1],precision);
1373 new ->whichOne = rq_cap;
1377 makeAndCompileShader(
new);
1383 return new->myCapabilities;
1389 rq_cap0s.base = rq_cap0;
1390 return getMyShaders(rq_cap0s);
1392#define DESIRE(whichOne,zzz) ((whichOne & zzz)==zzz)
1404static const GLchar *vertProjValDec =
"\
1405 uniform mat4 projTexGenMatCam0; \n \
1406 varying vec4 projTexCoord; \n";
1408static const GLchar *vertProjCalTexCoord =
"\
1409 void vertProjCalTexCoord(void) { \
1410 projTexCoord = projTexGenMatCam0 * fw_Vertex; \
1413static const GLchar *vertProjTexCalculation =
"\
1414 vertProjCalTexCoord();\n";
1424static const GLchar *fragProjValDec =
"\
1425 varying vec4 projTexCoord; \n \
1426 vec4 ProjMapColor_forCam1; \n";
1428static const GLchar *fragProjCalTexCoord =
"\
1429 void fragProjCalTexCoord(void) { \
1430 if( projTexCoord.q > 0.0 ){ \n \
1431 ProjMapColor_forCam1 = texture2DProj(fw_Texture_unit0, projTexCoord);\n \
1435static const GLchar *fragProjTexCalculation =
"\
1436 fragProjCalTexCoord();\n \
1437 finalFrag += ProjMapColor_forCam1;\n \
1448static const GLchar *vertMultiProjValDec =
"\
1449 uniform mat4 MultiprojTexGenMatCam1; \n \
1450 uniform mat4 MultiprojTexGenMatCam2; \n \
1451 uniform mat4 MultiprojTexGenMatCam3; \n \
1452 uniform mat4 MultiprojTexGenMatCam4; \n \
1453 varying vec4 MultiprojTexCoord1; \n \
1454 varying vec4 MultiprojTexCoord2; \n \
1455 varying vec4 MultiprojTexCoord3; \n \
1456 varying vec4 MultiprojTexCoord4; \n";
1458static const GLchar *vertMultiProjCalTexCoord =
"\
1459 void vertMultiProjCalTexCoord(void) { \
1460 MultiprojTexCoord1 = MultiprojTexGenMatCam1 * fw_Vertex; \
1461 MultiprojTexCoord2 = MultiprojTexGenMatCam2 * fw_Vertex; \
1462 MultiprojTexCoord3 = MultiprojTexGenMatCam3 * fw_Vertex; \
1463 MultiprojTexCoord4 = MultiprojTexGenMatCam4 * fw_Vertex; \
1466static const GLchar *vertMultiProjTexCalculation =
"\
1467 vertMultiProjCalTexCoord();\n";
1477static const GLchar *fragMultiProjValDec =
"\
1478 varying vec4 MultiprojTexCoord1; \n \
1479 varying vec4 MultiprojTexCoord2; \n \
1480 varying vec4 MultiprojTexCoord3; \n \
1481 varying vec4 MultiprojTexCoord4; \n \
1482 vec4 final_color = vec4(1.0, 1.0, 1.0, 0.0); \n";
1484static const GLchar *fragMultiProjCalTexCoord =
"\
1485 void fragMultiProjCalTexCoord(void) { \
1486 if( MultiprojTexCoord1.q > 0.0 ){ \n \
1487 vec4 ProjMapColor_forCam1 = texture2DProj(fw_Texture_unit0, MultiprojTexCoord1);\n \
1488 final_color = ProjMapColor_forCam1;\n \
1490 if( MultiprojTexCoord2.q > 0.0 ){ \n \
1491 vec4 ProjMapColor_forCam2 = texture2DProj(fw_Texture_unit1, MultiprojTexCoord2);\n \
1492 final_color = final_color+ ProjMapColor_forCam2;\n \
1494 if( MultiprojTexCoord3.q > 0.0 ){ \n \
1495 vec4 ProjMapColor_forCam3 = texture2DProj(fw_Texture_unit2, MultiprojTexCoord3);\n \
1496 final_color = final_color+ ProjMapColor_forCam3;\n \
1500static const GLchar *fragMultiProjTexCalculation =
"\
1501 fragMultiProjCalTexCoord();\n \
1502 finalFrag += final_color;\n \
1513static const GLchar *vertPosDec =
"\
1514 attribute vec4 fw_Vertex; \n \
1515 uniform mat4 fw_ModelViewMatrix; \n \
1516 uniform mat4 fw_ProjectionMatrix; \n ";
1518static const GLchar *vertNormDec =
" \
1519 uniform mat3 fw_NormalMatrix;\n \
1520 attribute vec3 fw_Normal; \n";
1522static const GLchar *vertSimColDec =
"\
1523 attribute vec4 fw_Color;\n ";
1525static const GLchar *vertTexMatrixDec =
"\
1526 uniform mat4 fw_TextureMatrix0;\n";
1528static const GLchar *vertTexCoordGenDec =
"\
1529 uniform int fw_textureCoordGenType;\n";
1531static const GLchar *vertTexCoordDec =
"\
1532 attribute vec2 fw_MultiTexCoord0;\n";
1534static const GLchar *vertOneMatDec =
"\
1535 uniform fw_MaterialParameters\n\
1536 fw_FrontMaterial; \n";
1537static const GLchar *vertBackMatDec =
"\
1538 uniform fw_MaterialParameters fw_BackMaterial; \n";
1544static const GLchar *vecNormPos =
" \
1546 vec4 vertexPos; \n";
1548static const GLchar *varyingNormPos =
" \
1549 varying vec3 vertexNorm; \
1550 varying vec4 vertexPos; \n";
1552static const GLchar *varyingTexCoord =
"\
1553 varying vec3 fw_TexCoord[4];\n";
1555static const GLchar *varyingFrontColour =
"\
1556 varying vec4 v_front_colour; \n";
1558static const GLchar *varyingHatchPosition =
"\
1559 varying vec2 hatchPosition; \n";
1563static const GLchar *vertMainStart =
"void main(void) { \n";
1565static const GLchar *vertEnd =
"}";
1567static const GLchar *vertPos =
"gl_Position = fw_ProjectionMatrix * fw_ModelViewMatrix * fw_Vertex;\n ";
1569static const GLchar *vertNormPosCalc =
"\
1570 vertexNorm = normalize(fw_NormalMatrix * fw_Normal);\n \
1571 vertexPos = fw_ModelViewMatrix * fw_Vertex;\n ";
1573static const GLchar *vertSimColUse =
"v_front_colour = fw_Color; \n";
1575static const GLchar *vertEmissionOnlyColourAss =
"v_front_colour = fw_FrontMaterial.emission;\n";
1576static const GLchar *vertSingTexCalc =
"fw_TexCoord[0] = vec3(vec4(fw_TextureMatrix0 *vec4(fw_MultiTexCoord0,0,0))).stp;\n";
1578static const GLchar *vertSingTexCubeCalc =
"\
1579 vec3 u=normalize(vec3(fw_ProjectionMatrix * fw_Vertex)); /* myEyeVertex */ \
1580 /* vec3 n=normalize(vec3(fw_NormalMatrix*fw_Normal)); \
1581 fw_TexCoord[0] = reflect(u,n); myEyeNormal */ \n \
1582 /* v_texC = reflect(normalize(vec3(vertexPos)),vertexNorm);\n */ \
1583 fw_TexCoord[0] = reflect(u,vertexNorm);\n";
1587const static GLchar *fragTCGTDefs = TEXTURECOORDINATEGENERATORDefs;
1592static const GLchar *sphEnvMapCalc =
" \n \
1593/* sphereEnvironMapping Calculation */ \
1594/* vec3 u=normalize(vec3(fw_ModelViewMatrix * fw_Vertex)); (myEyeVertex) \
1595vec3 n=normalize(vec3(fw_NormalMatrix*fw_Normal)); \
1596vec3 r = reflect(u,n); (myEyeNormal) */ \n\
1597vec3 u=normalize(vec3(vertexPos)); /* u is normalized position, used below more than once */ \n \
1598vec3 r= reflect(u,vertexNorm); \n\
1599if (fw_textureCoordGenType==TCGT_SPHERE) { /* TCGT_SPHERE GL_SPHERE_MAP OpenGL Equiv */ \n\
1600 float m=2.0 * sqrt(r.x*r.x + r.y*r.y + (r.z*1.0)*(r.z*1.0)); \n\
1601 fw_TexCoord[0] = vec3(r.x/m+0.5,r.y/m+0.5,0.0); \n \
1602}else if (fw_textureCoordGenType==TCGT_CAMERASPACENORMAL) /* GL_REFLECTION_MAP used for sampling cubemaps */ {\n \
1603 float dotResult = 2.0 * dot(u,r); \n\
1604 fw_TexCoord[0] = vec3(u-r)*dotResult;\n\
1605} else { /* default usage - like default CubeMaps */ \n\
1606 vec3 u=normalize(vec3(fw_ProjectionMatrix * fw_Vertex)); /* myEyeVertex */ \
1607 fw_TexCoord[0] = reflect(u,vertexNorm);\n \
1611static const GLchar *vertHatchPosCalc =
"hatchPosition = fw_Vertex.xy;\n";
1613static const GLchar *fillPropDefines =
"\
1614uniform vec4 HatchColour; \n\
1615uniform bool hatched; uniform bool filled;\n\
1616uniform vec2 HatchScale; uniform vec2 HatchPct; uniform int algorithm; ";
1620static const GLchar *lightDefines =
"\
1621struct fw_MaterialParameters {\n\
1628uniform int lightcount;\n\
1629//uniform float lightRadius[MAX_LIGHTS];\n\
1630uniform int lightType[MAX_LIGHTS];//ANGLE like this\n\
1631struct fw_LightSourceParameters { \n\
1636 vec4 halfVector; \n\
1637 vec4 spotDirection; \n\
1638 float spotBeamWidth; \n\
1639 float spotCutoff; \n\
1640 vec3 Attenuations; \n\
1641 //float constantAttenuation; \n\
1642 //float linearAttenuation; \n\
1643 //float quadraticAttenuation; \n\
1644 float lightRadius; \n\
1645 //int lightType; ANGLE doesnt like int in struct array \n\
1648uniform fw_LightSourceParameters fw_LightSource[MAX_LIGHTS] /* gl_MaxLights */ ;\n\
1667static const GLchar *ADSLLightModel =
"\n\
1668/* use ADSLightModel here the ADS colour is returned from the function. */\n\
1669vec4 ADSLightModel(in vec3 myNormal, in vec4 myPosition, in bool useMatDiffuse) {\n\
1671 vec4 diffuse = vec4(0., 0., 0., 0.);\n\
1672 vec4 ambient = vec4(0., 0., 0., 0.);\n\
1673 vec4 specular = vec4(0., 0., 0., 1.);\n\
1674 vec3 normal = normalize (myNormal);\n\
1676 vec3 viewv = -normalize(myPosition.xyz); \n \
1677 bool backFacing = (dot(normal,viewv) < 0.0); \n \
1679 vec4 matdiffuse = vec4(1.0,1.0,1.0,1.0);\n\
1680 float myAlph = 0.0;\n\
1682 fw_MaterialParameters myMat = fw_FrontMaterial;\n\
1684/* back Facing materials - flip the normal and grab back materials */ \n \
1685if (backFacing) { \n \
1686 normal = -normal; \n \
1687 myMat = fw_BackMaterial; \n \
1690 emissive = myMat.emission;\n\
1691 myAlph = myMat.diffuse.a;\n\
1692 if(useMatDiffuse)\n\
1693 matdiffuse = myMat.diffuse;\n\
1695 /* apply the lights to this material */\n\
1696 for (i=0; i<MAX_LIGHTS; i++) {\n\
1697 if(i<lightcount) { /*weird but ANGLE needs constant loop*/ \n\
1698 vec4 myLightDiffuse = fw_LightSource[i].diffuse;\n\
1699 vec4 myLightAmbient = fw_LightSource[i].ambient;\n\
1700 vec4 myLightSpecular = fw_LightSource[i].specular;\n\
1701 vec4 myLightPosition = fw_LightSource[i].position; \n\
1702 int myLightType = lightType[i]; //fw_LightSource[i].lightType;\n\
1703 vec3 myLightDir = fw_LightSource[i].spotDirection.xyz; \n\
1704 vec3 eyeVector = normalize(myPosition.xyz);\n\
1705 vec3 VP; /* vector of light direction and distance */\n\
1706 VP = myLightPosition.xyz - myPosition.xyz;\n\
1707 vec3 L = myLightDir; /*directional light*/ \n\
1708 if(myLightType < 2) /*point and spot*/ \n\
1709 L = normalize(VP); \n\
1710 float nDotL = max(dot(normal, L), 0.0);\n\
1711 vec3 halfVector = normalize(L - eyeVector);\n\
1712 /* normal dot light half vector */\n\
1713 float nDotHV = max(dot(normal,halfVector),0.0);\n\
1715 if (myLightType==1) {\n\
1718 float spotAttenuation = 0.0; \n\
1719 float powerFactor = 0.0; /* for light dropoff */ \n\
1720 float attenuation; /* computed attenuation factor */\n\
1721 float d; /* distance to vertex */ \n\
1723 if (nDotL > 0.0) {\n\
1724 powerFactor = pow(nDotL,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 attenuation = 1.0/(fw_LightSource[i].Attenuations.x + (fw_LightSource[i].Attenuations.y * d) + (fw_LightSource[i].Attenuations.z *d *d));\n\
1731 spotDot = dot (-L,myLightDir);\n\
1732 /* check against spotCosCutoff */\n\
1733 if (spotDot > fw_LightSource[i].spotCutoff) {\n\
1734 spotAttenuation = pow(spotDot,fw_LightSource[i].spotCutoff);\n\
1736 attenuation *= spotAttenuation;\n\
1737 /* diffuse light computation */\n\
1738 diffuse += nDotL* matdiffuse*myLightDiffuse * attenuation;\n\
1739 /* ambient light computation */\n\
1740 ambient += myMat.ambient*myLightAmbient;\n\
1741 /* specular light computation */\n\
1742 specular += myLightSpecular * powerFactor * attenuation;\n\
1744 } else if (myLightType == 2) { \n\
1745 /* DirectionalLight */ \n\
1746 float powerFactor = 0.0; /* for light dropoff */\n\
1747 if (nDotL > 0.0) {\n\
1748 powerFactor = pow(nDotHV, myMat.shininess);\n\
1749 /* tone down the power factor if myMat.shininess borders 0 */\n\
1750 if (myMat.shininess < 1.0) {\n\
1751 powerFactor *= myMat.shininess;\n\
1754 /* Specular light computation */\n\
1755 specular += myMat.specular *myLightSpecular*powerFactor;\n\
1756 /* diffuse light computation */\n\
1757 diffuse += nDotL*matdiffuse*myLightDiffuse;\n\
1758 /* ambient light computation */\n\
1759 ambient += myMat.ambient*myLightAmbient; \n\
1762 float powerFactor=0.0; /* for light dropoff */\n\
1763 float attenuation = 0.0; /* computed attenuation factor */\n\
1764 float d = length(VP); /* distance to vertex */ \n\
1765 /* are we within range? */\n\
1766 if (d <= fw_LightSource[i].lightRadius) {\n\
1767 if (nDotL > 0.0) {\n\
1768 powerFactor = pow(nDotL, myMat.shininess);\n\
1769 //attenuation = (myMat.shininess-128.0);\n\
1771 /* this is actually the SFVec3f attenuation field */\n\
1772 attenuation = 1.0/(fw_LightSource[i].Attenuations.x + (fw_LightSource[i].Attenuations.y * d) + (fw_LightSource[i].Attenuations.z *d *d));\n\
1773 /* diffuse light computation */\n\
1774 diffuse += nDotL* matdiffuse*myLightDiffuse * attenuation;\n\
1775 /* ambient light computation */\n\
1776 ambient += myMat.ambient*myLightAmbient;\n\
1777 /* specular light computation */\n\
1778 attenuation *= (myMat.shininess/128.0);\n\
1779 specular += myLightSpecular * powerFactor * attenuation;\n\
1784 return clamp(vec4(vec3(ambient+diffuse+specular+emissive),myAlph), 0.0, 1.0);\n\
1787#ifdef USING_SHADER_LIGHT_ARRAY_METHOD
1792static const GLchar *lightDefinesArrayMethod =
"\
1793struct fw_MaterialParameters {\n\
1800uniform int lightcount;\n\
1801uniform int lightType[MAX_LIGHTS];\n\
1802uniform vec4 lightambient[MAX_LIGHTS]; \n\
1803uniform vec4 lightdiffuse[MAX_LIGHTS]; \n\
1804uniform vec4 lightspecular[MAX_LIGHTS]; \n\
1805uniform vec4 lightposition[MAX_LIGHTS]; \n\
1806uniform vec4 lighthalfVector[MAX_LIGHTS]; \n\
1807uniform vec4 lightspotDirection[MAX_LIGHTS]; \n\
1808uniform float lightspotBeamWidth[MAX_LIGHTS]; \n\
1809uniform float lightspotCutoff[MAX_LIGHTS]; \n\
1810uniform float lightRadius[MAX_LIGHTS]; \n\
1811uniform vec3 lightAttenuations[MAX_LIGHTS]; \n\
1814static const GLchar *ADSLLightModelArrayMethod =
"\n\
1815/* use ADSLightModel here the ADS colour is returned from the function. */\n\
1816vec4 ADSLightModel(in vec3 myNormal, in vec4 myPosition, in bool useMatDiffuse) {\n\
1818 vec4 diffuse = vec4(0., 0., 0., 0.);\n\
1819 vec4 ambient = vec4(0., 0., 0., 0.);\n\
1820 vec4 specular = vec4(0., 0., 0., 1.);\n\
1821 vec3 normal = normalize (myNormal);\n\
1823 vec3 viewv = -normalize(myPosition.xyz); \n \
1824 bool backFacing = (dot(normal,viewv) < 0.0); \n \
1826 vec4 matdiffuse = vec4(1.0,1.0,1.0,1.0);\n\
1827 float myAlph = 0.0;\n\
1829 fw_MaterialParameters myMat = fw_FrontMaterial;\n\
1831/* back Facing materials - flip the normal and grab back materials */ \n \
1832if (backFacing) { \n \
1833 normal = -normal; \n \
1834 myMat = fw_BackMaterial; \n \
1837 emissive = myMat.emission;\n\
1838 myAlph = myMat.diffuse.a;\n\
1839 if(useMatDiffuse)\n\
1840 matdiffuse = myMat.diffuse;\n\
1842 /* apply the lights to this material */\n\
1843 for (i=0; i<MAX_LIGHTS; i++) {\n\
1844 if(i<lightcount){ /* weird but ANGLE for d3d9 needs constant loop (d3d11/winrt OK with variable loop)*/ \n\
1845 vec4 myLightDiffuse = lightdiffuse[i];\n\
1846 vec4 myLightAmbient = lightambient[i];\n\
1847 vec4 myLightSpecular = lightspecular[i];\n\
1848 vec4 myLightPosition = lightposition[i]; \n\
1849 vec4 myspotDirection = lightspotDirection[i]; \n\
1850 int myLightType = lightType[i]; \n\
1851 vec3 myLightDir = myspotDirection.xyz; \n\
1852 vec3 eyeVector = normalize(myPosition.xyz);\n\
1853 vec3 VP; /* vector of light direction and distance */\n\
1854 VP = myLightPosition.xyz - myPosition.xyz;\n\
1855 vec3 L = myLightDir; /*directional light*/ \n\
1856 if(myLightType < 2) /*point and spot*/ \n\
1857 L = normalize(VP); \n\
1858 float nDotL = max(dot(normal, L), 0.0);\n\
1859 vec3 halfVector = normalize(L - eyeVector);\n\
1860 /* normal dot light half vector */\n\
1861 float nDotHV = max(dot(normal,halfVector),0.0);\n\
1863 if (myLightType==1) {\n\
1866 float spotAttenuation = 0.0; \n\
1867 float powerFactor = 0.0; /* for light dropoff */ \n\
1868 float attenuation; /* computed attenuation factor */\n\
1869 float d; /* distance to vertex */ \n\
1871 if (nDotL > 0.0) {\n\
1872 powerFactor = pow(nDotL,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 attenuation = 1.0/(lightAttenuations[i].x + (lightAttenuations[i].y * d) + (lightAttenuations[i].z *d *d));\n\
1879 spotDot = dot (-L,myLightDir);\n\
1880 /* check against spotCosCutoff */\n\
1881 if (spotDot > lightspotCutoff[i]) {\n\
1882 spotAttenuation = pow(spotDot,lightspotBeamWidth[i]);\n\
1884 attenuation *= spotAttenuation;\n\
1885 /* diffuse light computation */\n\
1886 diffuse += nDotL* matdiffuse*myLightDiffuse * attenuation;\n\
1887 /* ambient light computation */\n\
1888 ambient += myMat.ambient*myLightAmbient;\n\
1889 /* specular light computation */\n\
1890 specular += myLightSpecular * powerFactor * attenuation;\n\
1892 } else if (myLightType == 2) { \n\
1893 /* DirectionalLight */ \n\
1894 float powerFactor = 0.0; /* for light dropoff */\n\
1895 if (nDotL > 0.0) {\n\
1896 powerFactor = pow(nDotHV, myMat.shininess);\n\
1897 /* tone down the power factor if myMat.shininess borders 0 */\n\
1898 if (myMat.shininess < 1.0) {\n\
1899 powerFactor *= myMat.shininess;\n\
1902 /* Specular light computation */\n\
1903 specular += myMat.specular *myLightSpecular*powerFactor;\n\
1904 /* diffuse light computation */\n\
1905 diffuse += nDotL*matdiffuse*myLightDiffuse;\n\
1906 /* ambient light computation */\n\
1907 ambient += myMat.ambient*myLightAmbient; \n\
1910 float powerFactor=0.0; /* for light dropoff */\n\
1911 float attenuation = 0.0; /* computed attenuation factor */\n\
1912 float d = length(VP); /* distance to vertex */ \n\
1913 /* are we within range? */\n\
1914 if (d <= lightRadius[i]) {\n\
1915 if (nDotL > 0.0) {\n\
1916 powerFactor = pow(nDotL, myMat.shininess);\n\
1918 /* this is actually the SFVec3f attenuation field */\n\
1919 attenuation = 1.0/(lightAttenuations[i].x + (lightAttenuations[i].y * d) + (lightAttenuations[i].z *d *d));\n\
1920 /* diffuse light computation */\n\
1921 diffuse += nDotL* matdiffuse*myLightDiffuse * attenuation;\n\
1922 /* ambient light computation */\n\
1923 ambient += myMat.ambient*myLightAmbient;\n\
1924 /* specular light computation */\n\
1925 attenuation *= (myMat.shininess/128.0);\n\
1926 specular += myLightSpecular * powerFactor * attenuation;\n\
1931 return clamp(vec4(vec3(ambient+diffuse+specular+emissive),myAlph), 0.0, 1.0);\n\
1942#if defined (GL_ES_VERSION_2_0)
1943 static const GLchar *fragHighPrecision =
"precision highp float;\n ";
1944 static const GLchar *fragMediumPrecision =
"precision mediump float;\n ";
1945 static const GLchar *maxLights = STR_MAX_LIGHTS;
1947 static const GLchar *maxLights = STR_MAX_LIGHTS;
1967static const GLchar *fragMainStart =
"void main() { vec4 finalFrag = vec4(1.,1.,1.,1.);\n";
1968static const GLchar *anaglyphGrayFragEnd =
"float gray = dot(finalFrag.rgb, vec3(0.299, 0.587, 0.114)); \n \
1969 gl_FragColor = vec4(gray, gray, gray, finalFrag.a);}";
1975static const GLchar *discardInFragEnd =
"if (finalFrag.a==0.0) {discard; } else {gl_FragColor = finalFrag;}}";
1976static const GLchar *fragEnd =
"gl_FragColor = finalFrag;}";
1979static const GLchar *fragTex0Dec =
"uniform sampler2D fw_Texture_unit0; \n";
1980static const GLchar *fragTex0CubeDec =
"uniform samplerCube fw_Texture_unit0; \n";
1984static const GLchar *fragSimColAss =
"finalFrag = v_front_colour * finalFrag;\n ";
1985static const GLchar *fragNoAppAss =
"finalFrag = vec4(1.0, 1.0, 1.0, 1.0);\n";
1986static const GLchar *fragFrontColAss=
" finalFrag = v_front_colour * finalFrag;";
1987const static GLchar *fragADSLAss =
"finalFrag = ADSLightModel(vertexNorm,vertexPos,true) * finalFrag;";
1988const static GLchar *vertADSLCalc =
"v_front_colour = ADSLightModel(vertexNorm,vertexPos,true);";
1989const static GLchar *vertADSLCalc0 =
"v_front_colour = ADSLightModel(vertexNorm,vertexPos,false);";
1991const static GLchar *fragSingTexAss =
"finalFrag = texture2D(fw_Texture_unit0, fw_TexCoord[0].st) * finalFrag;\n";
1992const static GLchar *fragSingTexCubeAss =
"finalFrag = textureCube(fw_Texture_unit0, fw_TexCoord[0]) * finalFrag;\n";
2006const static GLchar *fragMultiTexDef = MULTITEXTUREDefs;
2008static const GLchar *fragMultiTexUniforms =
" \
2009/* defined for single textures... uniform sampler2D fw_Texture_unit0; */\
2010uniform sampler2D fw_Texture_unit1; \
2011uniform sampler2D fw_Texture_unit2; \
2012/* REMOVE these as shader compile takes long \
2013uniform sampler2D fw_Texture_unit3; \
2014uniform sampler2D fw_Texture_unit4; \
2015uniform sampler2D fw_Texture_unit5; \
2016uniform sampler2D fw_Texture_unit6; \
2017uniform sampler2D fw_Texture_unit7; \
2019uniform int fw_Texture_mode0; \
2020uniform int fw_Texture_mode1; \
2021uniform int fw_Texture_mode2; \
2022/* REMOVE these as shader compile takes long \
2023uniform int fw_Texture_mode3; \
2024uniform int fw_Texture_mode4; \
2025uniform int fw_Texture_mode5; \
2026uniform int fw_Texture_mode6; \
2027uniform int fw_Texture_mode7; \
2030uniform int textureCount;\n";
2032static const GLchar *fragFillPropFunc =
"\
2033vec4 fillPropCalc(in vec4 prevColour, vec2 MCposition, int algorithm) {\
2035vec2 position, useBrick; \
2037position = MCposition / HatchScale; \
2039if (algorithm == 0) {/* bricking */ \
2040 if (fract(position.y * 0.5) > 0.5) \
2041 position.x += 0.5; \
2044/* algorithm 1, 2 = no futzing required here */ \
2045if (algorithm == 3) {/* positive diagonals */ \
2046 vec2 curpos = position; \
2047 position.x -= curpos.y; \
2050if (algorithm == 4) {/* negative diagonals */ \
2051 vec2 curpos = position; \
2052 position.x += curpos.y; \
2055if (algorithm == 6) {/* diagonal crosshatch */ \
2056 vec2 curpos = position; \
2057 if (fract(position.y) > 0.5) { \
2058 if (fract(position.x) < 0.5) position.x += curpos.y; \
2059 else position.x -= curpos.y; \
2061 if (fract(position.x) > 0.5) position.x += curpos.y; \
2062 else position.x -= curpos.y; \
2066position = fract(position); \
2068useBrick = step(position, HatchPct); \
2070 if (filled) {colour = prevColour;} else { colour=vec4(0.,0.,0.,0); }\
2072 colour = mix(HatchColour, colour, useBrick.x * useBrick.y); \
2076static const GLchar *fragFillPropCalc =
"\
2077finalFrag= fillPropCalc(finalFrag, hatchPosition, algorithm);\n";
2079static const GLchar *fragMulTexFunc =
"\
2080vec4 finalColCalc(in vec4 prevColour, in int mode, in sampler2D tex, in vec2 texcoord) { \
2081vec4 texel = texture2D(tex,texcoord); \
2082vec4 rv = vec4(1.,0.,1.,1.); \
2084if (mode==MTMODE_OFF) { rv = vec4(prevColour);} \
2085else if (mode==MTMODE_REPLACE) {rv = vec4(texture2D(tex, texcoord));}\
2086else if (mode==MTMODE_MODULATE) { \
2091cf = prevColour.rgb; \
2098rv = vec4(ct*cf, at*af); \
2101else if (mode==MTMODE_MODULATE2X) { \
2105cf = prevColour.rgb; \
2110rv = vec4(vec4(ct*cf, at*af)*vec4(2.,2.,2.,2.)); \
2112else if (mode==MTMODE_MODULATE4X) { \
2116cf = prevColour.rgb; \
2121rv = vec4(vec4(ct*cf, at*af)*vec4(4.,4.,4.,4.)); \
2123else if (mode== MTMODE_ADDSIGNED) {\
2124rv = vec4 (prevColour + texel - vec4 (0.5, 0.5, 0.5, -.5)); \
2126else if (mode== MTMODE_ADDSIGNED2X) {\
2127rv = vec4 ((prevColour + texel - vec4 (0.5, 0.5, 0.5, -.5))*vec4(2.,2.,2.,2.)); \
2129else if (mode== MTMODE_ADD) {\
2130rv= vec4 (prevColour + texel); \
2132else if (mode== MTMODE_SUBTRACT) {\
2133rv = vec4 (prevColour - texel); \
2135else if (mode==MTMODE_ADDSMOOTH) { \
2136rv = vec4 (prevColour + (prevColour - vec4 (1.,1.,1.,1.)) * texel); \
2142const static GLchar *fragMulTexCalc =
"\
2143if(textureCount>=1) {finalFrag=finalColCalc(finalFrag,fw_Texture_mode0,fw_Texture_unit0,fw_TexCoord[0].st);} \n\
2144if(textureCount>=2) {finalFrag=finalColCalc(finalFrag,fw_Texture_mode1,fw_Texture_unit1,fw_TexCoord[0].st);} \n\
2145if(textureCount>=3) {finalFrag=finalColCalc(finalFrag,fw_Texture_mode2,fw_Texture_unit2,fw_TexCoord[0].st);} \n\
2146/* REMOVE these as shader compile takes long \
2147if(textureCount>=4) {finalFrag=finalColCalc(finalFrag,fw_Texture_mode3,fw_Texture_unit3,fw_TexCoord[0].st);} \n\
2148if(textureCount>=5) {finalFrag=finalColCalc(finalFrag,fw_Texture_mode4,fw_Texture_unit4,fw_TexCoord[0].st);} \n\
2149if(textureCount>=6) {finalFrag=finalColCalc(finalFrag,fw_Texture_mode5,fw_Texture_unit5,fw_TexCoord[0].st);} \n\
2150if(textureCount>=7) {finalFrag=finalColCalc(finalFrag,fw_Texture_mode6,fw_Texture_unit6,fw_TexCoord[0].st);} \n\
2151if(textureCount>=8) {finalFrag=finalColCalc(finalFrag,fw_Texture_mode7,fw_Texture_unit7,fw_TexCoord[0].st);} \n\
2157const static GLchar *pointSizeDeclare=
"uniform float pointSize;\n";
2158const static GLchar *pointSizeAss=
"gl_PointSize = pointSize; \n";
2161static int getSpecificShaderSourceOriginal (
const GLchar *vertexSource[vertexEndMarker],
2165 bool didADSLmaterial;
2166#ifdef USING_SHADER_LIGHT_ARRAY_METHOD
2168 const GLchar *lightDefines0 = lightDefinesArrayMethod;
2169 const GLchar *ADSLLightModel0 = ADSLLightModelArrayMethod;
2171 const GLchar *lightDefines0 = lightDefines;
2172 const GLchar *ADSLLightModel0 = ADSLLightModel;
2179#if defined (GL_ES_VERSION_2_0)
2180 bool haveHighPrecisionFragmentShaders =
false;
2182#ifdef VARY_VERTEX_PRECISION
2183 bool haveHighPrecisionVertexShaders =
false;
2186 GLint range[2]; GLint precision;
2189 if (DESIRE(whichOne.base,SHADINGSTYLE_PHONG)) {
2190 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_HIGH_FLOAT, range, &precision);
2192 haveHighPrecisionFragmentShaders=
true;
2194 haveHighPrecisionFragmentShaders=
false;
2195 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_MEDIUM_FLOAT, range, &precision);
2196 if (precision == 0) {
2197 ConsoleMessage(
"low precision Fragment shaders only available - view may not work so well");
2200#ifdef VARY_VERTEX_PRECISION
2203 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_HIGH_FLOAT, range, &precision);
2205 haveHighPrecisionVertexShaders=
true;
2207 haveHighPrecisionVertexShaders=
false;
2208 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_MEDIUM_FLOAT, range, &precision);
2209 if (precision == 0) {
2210 ConsoleMessage(
"low precision Vertex shaders only available - view may not work so well");
2220 #if defined (VERBOSE) && defined (GL_ES_VERSION_2_0)
2224 glGetBooleanv(GL_SHADER_COMPILER,&b);
2225 if (b) ConsoleMessage(
"have shader compiler");
else ConsoleMessage(
"NO SHADER COMPILER");
2228 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_LOW_FLOAT, range, &precision);
2229 ConsoleMessage (
"GL_VERTEX_SHADER, GL_LOW_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
2230 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_MEDIUM_FLOAT, range, &precision);
2231 ConsoleMessage (
"GL_VERTEX_SHADER, GL_MEDIUM_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
2232 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_HIGH_FLOAT, range, &precision);
2233 ConsoleMessage (
"GL_VERTEX_SHADER, GL_HIGH_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
2235 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_LOW_INT, range, &precision);
2236 ConsoleMessage (
"GL_VERTEX_SHADER, GL_LOW_INT range [%d,%d],precision %d",range[0],range[1],precision);
2237 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_MEDIUM_INT, range, &precision);
2238 ConsoleMessage (
"GL_VERTEX_SHADER, GL_MEDIUM_INT range [%d,%d],precision %d",range[0],range[1],precision);
2239 glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_HIGH_INT, range, &precision);
2240 ConsoleMessage (
"GL_VERTEX_SHADER, GL_HIGH_INT range [%d,%d],precision %d",range[0],range[1],precision);
2242 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_LOW_FLOAT, range, &precision);
2243 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_LOW_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
2244 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_MEDIUM_FLOAT, range, &precision);
2245 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_MEDIUM_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
2246 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_HIGH_FLOAT, range, &precision);
2247 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_HIGH_FLOAT range [%d,%d],precision %d",range[0],range[1],precision);
2249 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_LOW_INT, range, &precision);
2250 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_LOW_INT range [%d,%d],precision %d",range[0],range[1],precision);
2251 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_MEDIUM_INT, range, &precision);
2252 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_MEDIUM_INT range [%d,%d],precision %d",range[0],range[1],precision);
2253 glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_HIGH_INT, range, &precision);
2254 ConsoleMessage (
"GL_FRAGMENT_SHADER, GL_HIGH_INT range [%d,%d],precision %d",range[0],range[1],precision);
2259 if DESIRE(whichOne.base,NO_APPEARANCE_SHADER) ConsoleMessage (
"want NO_APPEARANCE_SHADER");
2260 if DESIRE(whichOne.base,MATERIAL_APPEARANCE_SHADER) ConsoleMessage (
"want MATERIAL_APPEARANCE_SHADER");
2261 if DESIRE(whichOne.base,TWO_MATERIAL_APPEARANCE_SHADER) ConsoleMessage (
"want TWO_MATERIAL_APPEARANCE_SHADER");
2262 if DESIRE(whichOne.base,ONE_TEX_APPEARANCE_SHADER)ConsoleMessage(
"want ONE_TEX_APPEARANCE_SHADER");
2263 if DESIRE(whichOne.base,MULTI_TEX_APPEARANCE_SHADER)ConsoleMessage(
"want MULTI_TEX_APPEARANCE_SHADER");
2264 if DESIRE(whichOne.base,COLOUR_MATERIAL_SHADER)ConsoleMessage(
"want COLOUR_MATERIAL_SHADER");
2265 if DESIRE(whichOne.base,FILL_PROPERTIES_SHADER)ConsoleMessage(
"want FILL_PROPERTIES_SHADER");
2266 if DESIRE(whichOne.base,HAVE_LINEPOINTS_COLOR)ConsoleMessage (
"want LINE_POINTS_COLOR");
2267 if DESIRE(whichOne.base,HAVE_LINEPOINTS_APPEARANCE)ConsoleMessage (
"want LINE_POINTS_APPEARANCE");
2268 if DESIRE(whichOne.base,HAVE_TEXTURECOORDINATEGENERATOR) ConsoleMessage (
"want HAVE_TEXTURECOORDINATEGENERATOR");
2269 if DESIRE(whichOne.base,HAVE_CUBEMAP_TEXTURE) ConsoleMessage (
"want HAVE_CUBEMAP_TEXTURE");
2275#if defined(GL_ES_VERSION_2_0)
2276 fragmentSource[fragmentGLSLVersion] =
"#version 100\n";
2277 vertexSource[vertexGLSLVersion] =
"#version 100\n";
2278 if (haveHighPrecisionFragmentShaders) {
2279 fragmentSource[fragmentPrecisionDeclare] = fragHighPrecision;
2282 fragmentSource[fragmentPrecisionDeclare] = fragMediumPrecision;
2286#ifdef VARY_VERTEX_PRECISION
2288 if (haveHighPrecisionVertexShaders) {
2289 vertexSource[vertexPrecisionDeclare] = fragHighPrecision;
2290 ConsoleMessage(
"have high precision vertex shaders");
2292 vertexSource[vertexPrecisionDeclare] = fragMediumPrecision;
2293 ConsoleMessage(
"have medium precision vertex shaders");
2299 fragmentSource[fragmentGLSLVersion] =
"#version 110\n";
2300 vertexSource[vertexGLSLVersion] =
"#version 110\n";
2303 fragmentSource[fragMaxLightsDeclare] = maxLights;
2304 vertexSource[vertMaxLightsDeclare] = maxLights;
2305 vertexSource[vertexPositionDeclare] = vertPosDec;
2311 if (!whichOne.usershaders) {
2318 vertexSource[vertexMainStart] = vertMainStart;
2319 vertexSource[vertexPositionCalculation] = vertPos;
2320 vertexSource[vertexMainEnd] = vertEnd;
2323 fragmentSource[fragmentMainStart] = fragMainStart;
2324 if(Viewer()->anaglyph || Viewer()->anaglyphB)
2325 fragmentSource[fragmentMainEnd] = anaglyphGrayFragEnd;
2327 if (DESIRE(whichOne.base,SHADINGSTYLE_PHONG)) fragmentSource[fragmentMainEnd] = discardInFragEnd;
2328 else fragmentSource[fragmentMainEnd] = fragEnd;
2337 if DESIRE(whichOne.base,COLOUR_MATERIAL_SHADER) {
2338 vertexSource[vertexSimpleColourDeclare] = vertSimColDec;
2339 vertexSource[vertFrontColourDeclare] = varyingFrontColour;
2340 vertexSource[vertexSimpleColourCalculation] = vertSimColUse;
2341 vertexSource[vertexPointSizeDeclare] = pointSizeDeclare;
2342 vertexSource[vertexPointSizeAssign] = pointSizeAss;
2343 fragmentSource[fragmentSimpleColourDeclare] = varyingFrontColour;
2344 fragmentSource[fragmentSimpleColourAssign] = fragSimColAss;
2347 if DESIRE(whichOne.base,NO_APPEARANCE_SHADER) {
2348 fragmentSource[fragmentSimpleColourAssign] = fragNoAppAss;
2349 vertexSource[vertexPointSizeDeclare] = pointSizeDeclare;
2350 vertexSource[vertexPointSizeAssign] = pointSizeAss;
2358 if (DESIRE(whichOne.base,SHADINGSTYLE_PHONG)) {
2359 doThis = (DESIRE(whichOne.base,MATERIAL_APPEARANCE_SHADER)) ||
2360 (DESIRE(whichOne.base,TWO_MATERIAL_APPEARANCE_SHADER));
2362 doThis = DESIRE(whichOne.base,TWO_MATERIAL_APPEARANCE_SHADER);
2366 vertexSource[vertexNormPosOutput] = varyingNormPos;
2367 vertexSource[vertexNormalDeclare] = vertNormDec;
2368 vertexSource[vertexNormPosCalculation] = vertNormPosCalc;
2370 fragmentSource[fragmentLightDefines] = lightDefines0;
2371 fragmentSource[fragmentOneColourDeclare] = vertOneMatDec;
2372 fragmentSource[fragmentBackColourDeclare] = vertBackMatDec;
2373 fragmentSource[fragmentNormPosDeclare] = varyingNormPos;
2374 fragmentSource[fragmentADSLLightModel] = ADSLLightModel0;
2375 fragmentSource[fragmentADSLAssign] = fragADSLAss;
2382 didADSLmaterial =
false;
2383 if((DESIRE(whichOne.base,MATERIAL_APPEARANCE_SHADER)) && (!DESIRE(whichOne.base,SHADINGSTYLE_PHONG))) {
2384 vertexSource[vertexNormalDeclare] = vertNormDec;
2385 vertexSource[vertexLightDefines] = lightDefines0;
2386 vertexSource[vertexOneMaterialDeclare] = vertOneMatDec;
2387 vertexSource[vertFrontColourDeclare] = varyingFrontColour;
2388 vertexSource[vertexNormPosCalculation] = vertNormPosCalc;
2389 vertexSource[vertexNormPosOutput] = vecNormPos;
2390 vertexSource[vertexLightingEquation] = ADSLLightModel0;
2391 vertexSource[vertexBackMaterialDeclare] = vertBackMatDec;
2392 vertexSource[vertexADSLCalculation] = vertADSLCalc;
2393 didADSLmaterial =
true;
2394 fragmentSource[fragmentOneColourDeclare] = varyingFrontColour;
2395 fragmentSource[fragmentOneColourAssign] = fragFrontColAss;
2397 vertexSource[vertexProjValDec] = vertProjValDec;
2398 vertexSource[vertexProjCalTexCoord] = vertProjCalTexCoord;
2399 vertexSource[vertexProjTexCalculation] = vertProjTexCalculation;
2401 fragmentSource[fragmentTex0Declare] = fragTex0Dec;
2402 fragmentSource[fragmentProjValDec] = fragProjValDec;
2403 fragmentSource[fragmentProjCalTexCoord] = fragProjCalTexCoord;
2404 fragmentSource[fragmentProjTexAssign] = fragProjTexCalculation;
2409 if DESIRE(whichOne.base,HAVE_LINEPOINTS_APPEARANCE) {
2410 vertexSource[vertexLightDefines] = lightDefines0;
2411 vertexSource[vertFrontColourDeclare] = varyingFrontColour;
2412 vertexSource[vertexOneMaterialDeclare] = vertOneMatDec;
2414 #if defined (GL_ES_VERSION_2_0)
2415 vertexSource[vertexPointSizeDeclare] = pointSizeDeclare;
2416 vertexSource[vertexPointSizeAssign] = pointSizeAss;
2419 vertexSource[vertexOneMaterialCalculation] = vertEmissionOnlyColourAss;
2420 fragmentSource[fragmentSimpleColourDeclare] = varyingFrontColour;
2421 fragmentSource[fragmentSimpleColourAssign] = fragSimColAss;
2426 if (DESIRE(whichOne.base,ONE_TEX_APPEARANCE_SHADER) ||
2427 DESIRE(whichOne.base,HAVE_TEXTURECOORDINATEGENERATOR) ||
2428 DESIRE(whichOne.base,HAVE_CUBEMAP_TEXTURE) ||
2429 DESIRE(whichOne.base,MULTI_TEX_APPEARANCE_SHADER)) {
2434 vertexSource[vertexTexCoordInputDeclare] = vertTexCoordDec;
2435 vertexSource[vertexTexCoordOutputDeclare] = varyingTexCoord;
2436 vertexSource[vertexTextureMatrixDeclare] = vertTexMatrixDec;
2437 vertexSource[vertexSingleTextureCalculation] = vertSingTexCalc;
2439 vertexSource[vertexADSLCalculation] = vertADSLCalc0;
2441 fragmentSource[fragmentTexCoordDeclare] = varyingTexCoord;
2442 fragmentSource[fragmentTex0Declare] = fragTex0Dec;
2463 fragmentSource[fragmentTextureAssign] = fragSingTexAss;
2468 if (DESIRE(whichOne.base,HAVE_CUBEMAP_TEXTURE)) {
2469 vertexSource[vertexSingleTextureCalculation] = vertSingTexCubeCalc;
2471 fragmentSource[fragmentTex0Declare] = fragTex0CubeDec;
2472 fragmentSource[fragmentTextureAssign] = fragSingTexCubeAss;
2476 if DESIRE(whichOne.base,MULTI_TEX_APPEARANCE_SHADER) {
2480 vertexSource[vertexOneMaterialDeclare] = vertOneMatDec;
2481 vertexSource[vertexLightDefines] = lightDefines0;
2482 vertexSource[vertexNormPosCalculation] = vertNormPosCalc;
2483 vertexSource[vertexNormPosOutput] = vecNormPos;
2484 vertexSource[vertexLightingEquation] = ADSLLightModel0;
2485 vertexSource[vertexBackMaterialDeclare] = vertBackMatDec;
2487 fragmentSource[fragmentMultiTexDefines]= fragMultiTexUniforms;
2488 fragmentSource[fragmentMultiTexDeclare] = fragMultiTexDef;
2489 fragmentSource[fragmentTex0Declare] = fragTex0Dec;
2490 fragmentSource[fragmentMultiTexModel] = fragMulTexFunc;
2491 fragmentSource[fragmentTextureAssign] = fragMulTexCalc;
2495 vertexSource[vertexMultiProjValDec] = vertMultiProjValDec;
2496 vertexSource[vertexMultiProjCalTexCoord] = vertMultiProjCalTexCoord;
2497 vertexSource[vertexMultiProjTexCalculation] = vertMultiProjTexCalculation;
2498 fragmentSource[fragmentMultiProjValDec] = fragMultiProjValDec;
2499 fragmentSource[fragmentMultiProjCalTexCoord] = fragMultiProjCalTexCoord;
2503 fragmentSource[fragmentTextureAssign] = fragMultiProjTexCalculation;
2508 if DESIRE(whichOne.base,HAVE_TEXTURECOORDINATEGENERATOR) {
2511 vertexSource[vertexTextureMatrixDeclare] = vertTexCoordGenDec;
2512 vertexSource[vertexSingleTextureCalculation] = sphEnvMapCalc;
2514 vertexSource[vertexTCGTDefines] = fragTCGTDefs;
2518 if DESIRE(whichOne.base,FILL_PROPERTIES_SHADER) {
2521 vertexSource[vertexHatchPositionDeclare] = varyingHatchPosition;
2522 vertexSource[vertexHatchPositionCalculation] = vertHatchPosCalc;
2524 fragmentSource[fragmentFillPropDefines] = fillPropDefines;
2525 fragmentSource[fragmentHatchPositionDeclare] = varyingHatchPosition;
2526 fragmentSource[fragmentFillPropModel] = fragFillPropFunc;
2527 fragmentSource[fragmentFillPropAssign] = fragFillPropCalc;
2532 if (whichOne.usershaders) {
2539 me = whichOne.usershaders;
2545 vertexSource[vertexMainStart] =
" \n \
2546 #define HEADLIGHT_LIGHT 0\n \
2547 #define ftransform() (fw_ProjectionMatrix*fw_ModelViewMatrix*fw_Vertex)\n \
2548 #define gl_ModelViewProjectionMatrix (fw_ProjectionMatrix*fw_ModelViewMatrix)\n \
2549 #define gl_NormalMatrix fw_NormalMatrix\n \
2550 #define gl_ProjectionMatrix fw_ProjectionMatrix \n\
2551 #define gl_ModelViewMatrix fw_ModelViewMatrix \n\
2552 #define fw_TextureMatrix fw_TextureMatrix0 \n\
2553 #define gl_TextureMatrix fw_TextureMatrix0 \n\
2554 #define gl_Vertex fw_Vertex \n \
2555 #define gl_Normal fw_Normal\n \
2556 #define gl_Texture_unit0 fw_Texture_unit0\n \
2557 #define gl_MultiTexCoord0 fw_MultiTexCoord0\n \
2558 #define gl_Texture_unit1 fw_Texture_unit1\n \
2559 #define gl_MultiTexCoord1 fw_MultiTexCoord1\n \
2560 #define gl_Texture_unit2 fw_Texture_unit2\n \
2561 #define gl_MultiTexCoord2 fw_MultiTexCoord2\n \
2562 #define gl_LightSource fw_LightSource\n ";
2570 fragmentSource[fragmentMainStart] =
" \
2571 #define HEADLIGHT_LIGHT 0\n \
2572 #define gl_NormalMatrix fw_NormalMatrix\n \
2573 #define gl_Normal fw_Normal\n \
2574 #define gl_LightSource fw_LightSource\n ";
2579 vertexSource[vertexLightDefines] = lightDefines0;
2580 vertexSource[vertexSimpleColourDeclare] = vertSimColDec;
2581 vertexSource[vertFrontColourDeclare] = varyingFrontColour;
2585 vertexSource[vertexNormalDeclare] = vertNormDec;
2586 fragmentSource[fragmentLightDefines] = lightDefines0;
2589 if ((p->userDefinedVertexShader[me] == NULL) || (p->userDefinedFragmentShader[me]==NULL)) {
2590 ConsoleMessage (
"no Shader Source found for user defined shaders...");
2594 fragmentSource[fragmentUserDefinedInput] = p->userDefinedFragmentShader[me];
2595 vertexSource[vertexUserDefinedInput] = p->userDefinedVertexShader[me];
2604 vertexShaderResources_t x1;
2605 fragmentShaderResources_t x2;
2607 FILE* fp = fopen(
"C:/tmp/vertex_vc13.src",
"w+");
2608 ConsoleMessage (
"Vertex source:\n");
2609 fprintf(fp,
"Vertex source:\n");
2610 for (x1=vertexGLSLVersion; x1<vertexEndMarker; x1++) {
2611 if (strlen(vertexSource[x1])>0){
2612 ConsoleMessage(
"%s",vertexSource[x1]);
2613 fprintf(fp,
"%s",vertexSource[x1]);
2616 ConsoleMessage(
"Fragment Source:\n");
2617 fprintf(fp,
"Fragment Source:\n");
2619 for (x2=fragmentGLSLVersion; x2<fragmentEndMarker; x2++) {
2620 if (strlen(fragmentSource[x2])>0){
2621 ConsoleMessage(
"%s",fragmentSource[x2]);
2622 fprintf(fp,
"%s",fragmentSource[x2]);
2634int getSpecificShaderSourceCastlePlugs (
const GLchar **vertexSource,
const GLchar **fragmentSource,
shaderflagsstruct whichOne);
2635int getSpecificShaderSourceVolume (
const GLchar **vertexSource,
const GLchar **fragmentSource,
shaderflagsstruct whichOne);
2636static int getSpecificShaderSource (
const GLchar *vertexSource[vertexEndMarker],
const GLchar *fragmentSource[fragmentEndMarker],
2638 int iret, userDefined, usingCastlePlugs = 1;
2639 userDefined = whichOne.usershaders ? TRUE : FALSE;
2641 if(usingCastlePlugs && !userDefined) {
2644 iret = getSpecificShaderSourceVolume(vertexSource, fragmentSource, whichOne);
2646 iret = getSpecificShaderSourceCastlePlugs(vertexSource, fragmentSource, whichOne);
2648 iret = getSpecificShaderSourceOriginal(vertexSource, fragmentSource, whichOne);
2657 GLuint myVertexShader = 0;
2658 GLuint myFragmentShader= 0;
2662 const GLchar *vertexSource[vertexEndMarker];
2663 const GLchar *fragmentSource[fragmentEndMarker];
2664 vertexShaderResources_t x1;
2665 fragmentShaderResources_t x2;
2668 ConsoleMessage (
"makeAndCompileShader called");
2673 for (x1=vertexGLSLVersion; x1<vertexEndMarker; x1++)
2674 vertexSource[x1] =
"";
2675 for (x2=fragmentGLSLVersion; x2<fragmentEndMarker; x2++)
2676 fragmentSource[x2] =
"";
2680 myProg = glCreateProgram();
2681 (*myShader).myShaderProgram = myProg;
2684 (*myShader).compiledOK = FALSE;
2687 if (!getSpecificShaderSource(vertexSource, fragmentSource, me->whichOne)) {
2691 myVertexShader = CREATE_SHADER (VERTEX_SHADER);
2692 SHADER_SOURCE(myVertexShader, vertexEndMarker, ((
const GLchar **)vertexSource), NULL);
2693 COMPILE_SHADER(myVertexShader);
2694 GET_SHADER_INFO(myVertexShader, COMPILE_STATUS, &success);
2696 shaderErrorLog(myVertexShader,
"VERTEX");
2699 ATTACH_SHADER(myProg, myVertexShader);
2703 myFragmentShader = CREATE_SHADER (FRAGMENT_SHADER);
2704 SHADER_SOURCE(myFragmentShader, fragmentEndMarker, (
const GLchar **) fragmentSource, NULL);
2705 COMPILE_SHADER(myFragmentShader);
2706 GET_SHADER_INFO(myFragmentShader, COMPILE_STATUS, &success);
2708 shaderErrorLog(myFragmentShader,
"FRAGMENT");
2710 ATTACH_SHADER(myProg, myFragmentShader);
2713 LINK_SHADER(myProg);
2715 glGetProgramiv(myProg,GL_LINK_STATUS, &success);
2716 (*myShader).compiledOK = (success == GL_TRUE);
2717 getShaderCommonInterfaces(myShader);
2722 GLuint myProg = me->myShaderProgram;
2726 #ifdef SHADERVERBOSE
2735 printf (
"getShaderCommonInterfaces, I am program %d\n",myProg);
2737 if (glIsProgram(myProg))
2738 printf (
"getShaderCommonInterfaces, %d is a program\n",myProg);
2740 printf (
"hmmm - it is not a program!\n");
2741 glGetAttachedShaders(myProg,10,&count,shaders);
2742 printf (
"got %d attached shaders, they are: \n",count);
2743 for (i=0; i<count; i++) {
2746 printf (
"%d\n",shaders[i]);
2747 glGetShaderSource(shaders[i],3000,&len,sl);
2748 printf (
"len %d\n",len);
2749 printf (
"sl: %s\n",sl);
2751 glGetProgramiv(myProg,GL_INFO_LOG_LENGTH, xxx); printf (
"GL_INFO_LOG_LENGTH_STATUS %d\n",xxx[0]);
2752 glGetProgramiv(myProg,GL_LINK_STATUS, xxx); printf (
"GL_LINK_STATUS %d\n",xxx[0]);
2753 glGetProgramiv(myProg,GL_VALIDATE_STATUS, xxx); printf (
"GL_VALIDATE_STATUS %d\n",xxx[0]);
2754 glGetProgramiv(myProg,GL_ACTIVE_ATTRIBUTES, xxx); printf (
"GL_ACTIVE_ATTRIBUTES %d\n",xxx[0]);
2755 glGetProgramiv(myProg,GL_ACTIVE_UNIFORMS, xxx); printf (
"GL_ACTIVE_UNIFORMS %d\n",xxx[0]);
2757 glGetProgramiv(myProg,GL_INFO_LOG_LENGTH, xxx);
2759 #define MAX_INFO_LOG_SIZE 512
2760 GLchar infoLog[MAX_INFO_LOG_SIZE];
2761 glGetProgramInfoLog(myProg, MAX_INFO_LOG_SIZE, NULL, infoLog);
2762 printf (
"log: %s\n",infoLog);
2774 for(
int i=0;i<4;i++){
2777 sprintf(line,
"textureUnit[%d]",i);
2778 me->textureUnit[i] = GET_UNIFORM(myProg,line);
2780 for(
int i=0;i<8;i++){
2783 sprintf(line,
"projTexGenMatCam[%d]",i);
2784 me->projTexGenMatCam[i] = GET_UNIFORM(myProg,line);
2785 sprintf(line,
"pbackCull[%d]",i);
2786 me->pbackCull[i] = GET_UNIFORM(myProg,line);
2787 sprintf(line,
"ntdesc[%d]",i);
2788 me->ntdesc[i] = GET_UNIFORM(myProg,line);
2790 for(
int i=0;i<16;i++){
2793 sprintf(line,
"tunits[%d]",i);
2794 me->tunits[i] = GET_UNIFORM(myProg,line);
2795 sprintf(line,
"modes[%d]",i);
2796 me->modes[i] = GET_UNIFORM(myProg,line);
2797 sprintf(line,
"sources[%d]",i);
2798 me->sources[i] = GET_UNIFORM(myProg,line);
2799 sprintf(line,
"funcs[%d]",i);
2800 me->funcs[i] = GET_UNIFORM(myProg,line);
2802 me->pCount = GET_UNIFORM(myProg,
"pCount");
2814 me->myMaterialEmission = GET_UNIFORM(myProg,
"fw_FrontMaterial.emission");
2815 me->myMaterialDiffuse = GET_UNIFORM(myProg,
"fw_FrontMaterial.diffuse");
2816 me->myMaterialShininess = GET_UNIFORM(myProg,
"fw_FrontMaterial.shininess");
2817 me->myMaterialAmbient = GET_UNIFORM(myProg,
"fw_FrontMaterial.ambient");
2818 me->myMaterialSpecular = GET_UNIFORM(myProg,
"fw_FrontMaterial.specular");
2820 me->myMaterialBackEmission = GET_UNIFORM(myProg,
"fw_BackMaterial.emission");
2821 me->myMaterialBackDiffuse = GET_UNIFORM(myProg,
"fw_BackMaterial.diffuse");
2822 me->myMaterialBackShininess = GET_UNIFORM(myProg,
"fw_BackMaterial.shininess");
2823 me->myMaterialBackAmbient = GET_UNIFORM(myProg,
"fw_BackMaterial.ambient");
2824 me->myMaterialBackSpecular = GET_UNIFORM(myProg,
"fw_BackMaterial.specular");
2829 me->lightcount = GET_UNIFORM(myProg,
"lightcount");
2858 char uniformName[100];
2859 me->haveLightInShader =
false;
2860#ifdef USING_SHADER_LIGHT_ARRAY_METHOD
2862 for (i = 0; i<MAX_LIGHTS; i++) {
2865 strcpy(uniformName,
"lightambient[0]");
2866 sndx = strstr(uniformName,
"[");
2868 me->lightAmbient[i] = GET_UNIFORM(myProg, uniformName);
2872 strcpy(uniformName,
"lightdiffuse[0]");
2873 sndx = strstr(uniformName,
"[");
2875 me->lightDiffuse[i] = GET_UNIFORM(myProg, uniformName);
2879 strcpy(uniformName,
"lightspecular[0]");
2880 sndx = strstr(uniformName,
"[");
2882 me->lightSpecular[i] = GET_UNIFORM(myProg, uniformName);
2886 strcpy(uniformName,
"lightposition[0]");
2887 sndx = strstr(uniformName,
"[");
2889 me->lightPosition[i] = GET_UNIFORM(myProg, uniformName);
2894 if (me->lightPosition[i] != -1) me->haveLightInShader =
true;
2896 strcpy(uniformName,
"lightspotDirection[0]");
2897 sndx = strstr(uniformName,
"[");
2899 me->lightSpotDir[i] = GET_UNIFORM(myProg, uniformName);
2903 strcpy(uniformName,
"lightspotExponent[0]");
2904 sndx = strstr(uniformName,
"[");
2906 me->lightSpotBeamWidth[i] = GET_UNIFORM(myProg, uniformName);
2910 strcpy(uniformName,
"lightspotCutoff[0]");
2911 sndx = strstr(uniformName,
"[");
2913 me->lightSpotCutoffAngle[i] = GET_UNIFORM(myProg, uniformName);
2917 strcpy(uniformName,
"lightAttenuations[0]");
2918 sndx = strstr(uniformName,
"[");
2920 me->lightAtten[i] = GET_UNIFORM(myProg, uniformName);
2922 strcpy(uniformName,
"lightRadius[0]");
2923 sndx = strstr(uniformName,
"[");
2925 me->lightRadius[i] = GET_UNIFORM(myProg, uniformName);
2931 strcpy(uniformName,
"fw_LightSource[0].");
2932 for (i=0; i<MAX_LIGHTS; i++) {
2934 uniformName[15] =
'0' + i;
2936 strcpy(&uniformName[18],
"ambient");
2939 me->lightAmbient[i] = GET_UNIFORM(myProg,uniformName);
2943 strcpy(&uniformName[18],
"diffuse");
2944 me->lightDiffuse[i] = GET_UNIFORM(myProg,uniformName);
2948 strcpy(&uniformName[18],
"specular");
2949 me->lightSpecular[i] = GET_UNIFORM(myProg,uniformName);
2953 strcpy(&uniformName[18],
"position");
2954 me->lightPosition[i] = GET_UNIFORM(myProg,uniformName);
2959 if (me->lightPosition[i] != -1) me->haveLightInShader =
true;
2961 strcpy(&uniformName[18],
"spotDirection");
2962 me->lightSpotDir[i] = GET_UNIFORM(myProg,uniformName);
2967 strcpy(&uniformName[18],
"spotBeamWidth");
2968 me->lightSpotBeamWidth[i] = GET_UNIFORM(myProg,uniformName);
2972 strcpy(&uniformName[18],
"spotCutoff");
2973 me->lightSpotCutoffAngle[i] = GET_UNIFORM(myProg,uniformName);
2977 strcpy(&uniformName[18],
"Attenuations");
2978 me->lightAtten[i] = GET_UNIFORM(myProg,uniformName);
2994 strcpy(&uniformName[18],
"lightRadius");
2995 me->lightRadius[i] = GET_UNIFORM(myProg,uniformName);
3004 strcpy(uniformName,
"lightType[0]");
3005 for (i = 0; i < MAX_LIGHTS; i++) {
3007 uniformName[10] =
'0' + i;
3008 me->lightType[i] = GET_UNIFORM(myProg, uniformName);
3014 me->ModelViewMatrix = GET_UNIFORM(myProg,
"fw_ModelViewMatrix");
3015 me->ProjectionMatrix = GET_UNIFORM(myProg,
"fw_ProjectionMatrix");
3016 me->NormalMatrix = GET_UNIFORM(myProg,
"fw_NormalMatrix");
3017 me->ModelViewInverseMatrix = GET_UNIFORM(myProg,
"fw_ModelViewInverseMatrix");
3019 me->TextureMatrix[0] = GET_UNIFORM(myProg,
"fw_TextureMatrix0");
3020 me->TextureMatrix[1] = GET_UNIFORM(myProg,
"fw_TextureMatrix1");
3021 me->TextureMatrix[2] = GET_UNIFORM(myProg,
"fw_TextureMatrix2");
3022 me->TextureMatrix[3] = GET_UNIFORM(myProg,
"fw_TextureMatrix3");
3024 me->Vertices = GET_ATTRIB(myProg,
"fw_Vertex");
3026 me->Normals = GET_ATTRIB(myProg,
"fw_Normal");
3027 me->Colours = GET_ATTRIB(myProg,
"fw_Color");
3028 me->FogCoords = GET_ATTRIB(myProg,
"fw_FogCoords");
3032 me->TexCoords[0] = GET_ATTRIB(myProg,
"fw_MultiTexCoord0");
3033 me->TexCoords[1] = GET_ATTRIB(myProg,
"fw_MultiTexCoord1");
3034 me->TexCoords[2] = GET_ATTRIB(myProg,
"fw_MultiTexCoord2");
3035 me->TexCoords[3] = GET_ATTRIB(myProg,
"fw_MultiTexCoord3");
3038 for (i=0; i<MAX_MULTITEXTURE; i++) {
3040 sprintf (line,
"fw_Texture_unit%d",i);
3041 me->TextureUnit[i]= GET_UNIFORM(myProg,line);
3042 sprintf (line,
"fw_Texture_mode%d",i);
3043 me->TextureMode[i] = GET_UNIFORM(myProg,line);
3044 sprintf (line,
"fw_Texture_source%d",i);
3045 me->TextureSource[i] = GET_UNIFORM(myProg,line);
3046 sprintf (line,
"fw_Texture_function%d",i);
3047 me->TextureFunction[i] = GET_UNIFORM(myProg,line);
3052 me->textureCount = GET_UNIFORM(myProg,
"textureCount");
3053 me->multitextureColor = GET_UNIFORM(myProg,
"mt_Color");
3057 me->tex3dTiles = GET_UNIFORM(myProg,
"tex3dTiles");
3058 me->tex3dUseVertex = GET_UNIFORM(myProg,
"tex3dUseVertex");
3059 me->magFilter = GET_UNIFORM(myProg,
"magFilter");
3060 me->repeatSTR = GET_UNIFORM(myProg,
"repeatSTR");
3064 me->myPointSize = GET_UNIFORM(myProg,
"pointSize");
3065 me->hatchColour = GET_UNIFORM(myProg,
"HatchColour");
3066 me->hatchPercent = GET_UNIFORM(myProg,
"HatchPct");
3067 me->hatchScale = GET_UNIFORM(myProg,
"HatchScale");
3068 me->filledBool = GET_UNIFORM(myProg,
"filled");
3069 me->hatchedBool = GET_UNIFORM(myProg,
"hatched");
3070 me->algorithm = GET_UNIFORM(myProg,
"algorithm");
3072 me->fogColor = GET_UNIFORM(myProg,
"fw_fogparams.fogColor");
3073 me->fogvisibilityRange = GET_UNIFORM(myProg,
"fw_fogparams.visibilityRange");
3074 me->fogScale = GET_UNIFORM(myProg,
"fw_fogparams.fogScale");
3075 me->fogType = GET_UNIFORM(myProg,
"fw_fogparams.fogType");
3078 me->clipplanes = GET_UNIFORM(myProg,
"fw_clipplanes");
3079 me->nclipplanes = GET_UNIFORM(myProg,
"fw_nclipplanes");
3082 me->texCoordGenType = GET_UNIFORM(myProg,
"fw_textureCoordGenType");
3086 printf (
"shader uniforms: vertex %d normal %d modelview %d projection %d\n",
3087 me->Vertices, me->Normals, me->ModelViewMatrix, me->ProjectionMatrix);
3088 printf (
"hatchColour %d, hatchPercent %d",me->hatchColour, me->hatchPercent);
3095static void handle_GeoLODRange(
struct X3D_GeoLOD *node) {
3101 getCurrentPosInModelB();
3103 cx =
viewer->currentPosInModel.x - node->__movedCoords.c[0];
3104 cy =
viewer->currentPosInModel.y - node->__movedCoords.c[1];
3105 cz =
viewer->currentPosInModel.z - node->__movedCoords.c[2];
3110 oldInRange = node->__inRange;
3113 if((cx*cx+cy*cy+cz*cz) > (node->range * node->range)) {
3114 node->__inRange = FALSE;
3116 node->__inRange = TRUE;
3120 if (oldInRange != node->__inRange) {
3123 if (node->__inRange) printf (
"TRUE: ");
else printf (
"FALSE: ");
3124 printf (
"range changed; level %d, comparing %lf:%lf:%lf and range %lf node %u\n",
3125 node->__level, cx,cy,cz, node->range, node);
3129 if (node->children.p == NULL) node->children.p=MALLOC(
struct X3D_Node **,
sizeof(
struct X3D_Node *) * 4);
3131 if (node->__inRange == TRUE) {
3133 printf (
"GeoLOD %u level %d, inRange set to FALSE, range %lf\n",node, node->__level, node->range);
3135 node->level_changed = 1;
3136 node->children.p[0] = node->__child1Node;
3137 node->children.p[1] = node->__child2Node;
3138 node->children.p[2] = node->__child3Node;
3139 node->children.p[3] = node->__child4Node;
3140 node->children.n = 4;
3143 printf (
"GeoLOD %u level %d, inRange set to TRUE range %lf\n",node, node->__level, node->range);
3145 node->level_changed = 0;
3146 node->children.n = 0;
3147 if( node->__rootUrl )
3149 node->children.p[0] = node->__rootUrl;
3150 node->children.n = 1;
3152 else if( node->rootNode.p && node->rootNode.p[0] )
3154 node->children.p[0] = node->rootNode.p[0];
3155 node->children.n = 1;
3158 MARK_EVENT(X3D_NODE(node), offsetof (
struct X3D_GeoLOD, level_changed));
3159 MARK_EVENT(X3D_NODE(node), offsetof (
struct X3D_GeoLOD, children));
3160 oldInRange = X3D_GEOLOD(node)->__inRange;
3166 update_node(X3D_NODE(node));
3170#ifdef DEBUGGING_CODE
3172void drawBBOX(
struct X3D_Node *node) {
3174 FW_GL_COLOR3F((
float)1.0,(
float)0.6,(
float)0.6);
3178 glVertex3d(node->EXTENT_MIN_X, node->EXTENT_MIN_Y, node->EXTENT_MIN_Z);
3179 glVertex3d(node->EXTENT_MIN_X, node->EXTENT_MIN_Y, node->EXTENT_MAX_Z);
3183 glVertex3d(node->EXTENT_MIN_X, node->EXTENT_MIN_Y, node->EXTENT_MIN_Z);
3184 glVertex3d(node->EXTENT_MIN_X, node->EXTENT_MAX_Y, node->EXTENT_MIN_Z);
3188 glVertex3d(node->EXTENT_MIN_X, node->EXTENT_MAX_Y, node->EXTENT_MIN_Z);
3189 glVertex3d(node->EXTENT_MIN_X, node->EXTENT_MAX_Y, node->EXTENT_MAX_Z);
3193 glVertex3d(node->EXTENT_MIN_X, node->EXTENT_MIN_Y, node->EXTENT_MAX_Z);
3194 glVertex3d(node->EXTENT_MIN_X, node->EXTENT_MAX_Y, node->EXTENT_MAX_Z);
3199 glVertex3d(node->EXTENT_MAX_X, node->EXTENT_MIN_Y, node->EXTENT_MIN_Z);
3200 glVertex3d(node->EXTENT_MAX_X, node->EXTENT_MIN_Y, node->EXTENT_MAX_Z);
3204 glVertex3d(node->EXTENT_MAX_X, node->EXTENT_MIN_Y, node->EXTENT_MIN_Z);
3205 glVertex3d(node->EXTENT_MAX_X, node->EXTENT_MAX_Y, node->EXTENT_MIN_Z);
3209 glVertex3d(node->EXTENT_MAX_X, node->EXTENT_MAX_Y, node->EXTENT_MIN_Z);
3210 glVertex3d(node->EXTENT_MAX_X, node->EXTENT_MAX_Y, node->EXTENT_MAX_Z);
3214 glVertex3d(node->EXTENT_MAX_X, node->EXTENT_MIN_Y, node->EXTENT_MAX_Z);
3215 glVertex3d(node->EXTENT_MAX_X, node->EXTENT_MAX_Y, node->EXTENT_MAX_Z);
3220 glVertex3d(node->EXTENT_MIN_X, node->EXTENT_MIN_Y, node->EXTENT_MIN_Z);
3221 glVertex3d(node->EXTENT_MAX_X, node->EXTENT_MIN_Y, node->EXTENT_MIN_Z);
3225 glVertex3d(node->EXTENT_MIN_X, node->EXTENT_MIN_Y, node->EXTENT_MAX_Z);
3226 glVertex3d(node->EXTENT_MAX_X, node->EXTENT_MIN_Y, node->EXTENT_MAX_Z);
3230 glVertex3d(node->EXTENT_MIN_X, node->EXTENT_MAX_Y, node->EXTENT_MIN_Z);
3231 glVertex3d(node->EXTENT_MAX_X, node->EXTENT_MAX_Y, node->EXTENT_MIN_Z);
3235 glVertex3d(node->EXTENT_MIN_X, node->EXTENT_MAX_Y, node->EXTENT_MAX_Z);
3236 glVertex3d(node->EXTENT_MAX_X, node->EXTENT_MAX_Y, node->EXTENT_MAX_Z);
3244static struct depth_slice depth_slices_three [] = {
3249static struct depth_slice depth_slices_two [] = {
3253static struct depth_slice depth_slices_one [] = {
3256static int n_depth_slices = 1;
3257static int want_depth_slices = 0;
3258int iclamp(
int ival,
int istart,
int iend);
3259void fwl_set_depth_slices(
int nslices){
3260 want_depth_slices = iclamp(nslices,0,3);
3263int fwl_get_depth_slices(){
3264 return want_depth_slices;
3266static void calculateNearFarplanes(
struct X3D_Node *vpnode,
int layerid ){
3282 int previous_n, iwant;
3284 static int once = 0;
3286 viewer->nearPlane = DEFAULT_NEARPLANE;
3287 viewer->farPlane = DEFAULT_FARPLANE;
3289 iwant = fwl_get_depth_slices();
3290 previous_n = n_depth_slices;
3300 float scene_diameter;
3303 FW_GL_GETDOUBLEV(GL_MODELVIEW_MATRIX, MM);
3312 extent6f_copy(extent6,rn->_extent);
3313 extent6f_mattransform4d(extent6,extent6,MM);
3315 vecset3f(vpf,0.0f,0.0f,0.0f);
3316 extent6f_union_vec3f(extent6,vpf);
3317 scene_diameter = extent6f_get_maxradius(extent6) * 2.0;
3319 if(scene_diameter > 21000.0f ) n_depth_slices = 2;
3320 if(scene_diameter > 1.e9 ) n_depth_slices = 3;
3323 n_depth_slices = want_depth_slices;
3325 if(0)
if(!once || previous_n != n_depth_slices)
3326 ConsoleMessage(
"depth slices: %d \n",n_depth_slices);
3329void calculateViewingDistIfJustBound(
struct X3D_Node *vpnode,
int layerid ){
3330 if(Viewer()->doExamineModeDistanceCalculations){
3336 float scene_diameter, vpradius;
3338 float vpf[3], center[3], vpoffset[3];
3339 FW_GL_GETDOUBLEV(GL_MODELVIEW_MATRIX, MM);
3348 extent6f_copy(extent6,rn->_extent);
3349 extent6f_mattransform4d(extent6,extent6,MM);
3351 vecset3f(vpf,0.0f,0.0f,0.0f);
3352 extent6f_get_center3f(extent6,center);
3354 vecdif3f(vpoffset,center,vpf);
3355 scene_diameter = extent6f_get_maxradius(extent6) * 2.0;
3356 vpradius = veclength3f(vpoffset);
3358 Viewer()->Dist = vpradius;
3360 Viewer()->doExamineModeDistanceCalculations = FALSE;
3366int get_n_depth_slices(){
3367 return n_depth_slices;
3369void get_depth_slice(
int islice,
double *znear,
double *zfar){
3371 switch(n_depth_slices){
3374 *znear = depth_slices_one[islice].znear;
3375 *zfar = depth_slices_one[islice].zfar;
3378 *znear = depth_slices_two[1-islice].znear;
3379 *zfar = depth_slices_two[1-islice].zfar;
3382 *znear = depth_slices_three[2-islice].znear;
3383 *zfar = depth_slices_three[2-islice].zfar;
3388static void calculateNearFarplanes_OLD(
struct X3D_Node *vpnode,
int layerid ) {
3407 GLDOUBLE cfp = -DBL_MAX;
3408 GLDOUBLE cnp = DBL_MAX;
3410 bool doingGeoSpatial =
false;
3411 double bboxMovedCentreZ = 0.0;
3412 double bboxSphereRadius = 0.0;
3427 printf (
"have a bound viewpoint... lets calculate our near/far planes from it \n");
3428 printf (
"we are currently at %4.2f %4.2f %4.2f\n",Viewer()->currentPosInModel.x, Viewer()->currentPosInModel.y, Viewer()->currentPosInModel.z);
3434 if ((vpnode->_nodeType != NODE_Viewpoint) &&
3435 (vpnode->_nodeType != NODE_OrthoViewpoint) &&
3436 (vpnode->_nodeType != NODE_GeoViewpoint)) {
3437 printf (
"can not do this node type yet %s, for cpf\n",stringNodeType(vpnode->_nodeType));
3438 viewer->nearPlane = DEFAULT_NEARPLANE;
3439 viewer->farPlane = DEFAULT_FARPLANE;
3440 viewer->backgroundPlane = DEFAULT_BACKGROUNDPLANE;
3444 if (vpnode->_nodeType == NODE_GeoViewpoint) {
3445 doingGeoSpatial =
true;
3449 viewer->nearPlane = DEFAULT_NEARPLANE;
3450 viewer->farPlane = DEFAULT_FARPLANE;
3451 viewer->backgroundPlane = DEFAULT_BACKGROUNDPLANE;
3452 if(doingGeoSpatial){
3453 viewer->nearPlane = 10000.0;
3454 viewer->farPlane = 2100000000.0;
3455 viewer->backgroundPlane = 2000000000.0;
3465 if (doingGeoSpatial) {
3466 if ((rn->EXTENT_MAX_X - rn->EXTENT_MIN_X) > bboxSphereRadius) {
3467 bboxSphereRadius = rn->EXTENT_MAX_X - rn->EXTENT_MIN_X;
3469 if ((rn->EXTENT_MAX_Y - rn->EXTENT_MIN_Y) > bboxSphereRadius) {
3470 bboxSphereRadius = rn->EXTENT_MAX_Y - rn->EXTENT_MIN_Y;
3472 if ((rn->EXTENT_MAX_Z - rn->EXTENT_MIN_Z) > bboxSphereRadius) {
3473 bboxSphereRadius = rn->EXTENT_MAX_Z - rn->EXTENT_MIN_Z;
3475 bboxSphereRadius /=2.0;
3479 ConsoleMessage (
"bboxSphereRadius %lf",bboxSphereRadius);
3485 FW_GL_GETDOUBLEV(GL_MODELVIEW_MATRIX, MM);
3488 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);
3492 moveAndRotateThisPoint(&bboxPoints[0], rn->EXTENT_MIN_X, rn->EXTENT_MIN_Y, rn->EXTENT_MIN_Z,MM);
3493 moveAndRotateThisPoint(&bboxPoints[1], rn->EXTENT_MIN_X, rn->EXTENT_MIN_Y, rn->EXTENT_MAX_Z,MM);
3494 moveAndRotateThisPoint(&bboxPoints[2], rn->EXTENT_MIN_X, rn->EXTENT_MAX_Y, rn->EXTENT_MIN_Z,MM);
3495 moveAndRotateThisPoint(&bboxPoints[3], rn->EXTENT_MIN_X, rn->EXTENT_MAX_Y, rn->EXTENT_MAX_Z,MM);
3496 moveAndRotateThisPoint(&bboxPoints[4], rn->EXTENT_MAX_X, rn->EXTENT_MIN_Y, rn->EXTENT_MIN_Z,MM);
3497 moveAndRotateThisPoint(&bboxPoints[5], rn->EXTENT_MAX_X, rn->EXTENT_MIN_Y, rn->EXTENT_MAX_Z,MM);
3498 moveAndRotateThisPoint(&bboxPoints[6], rn->EXTENT_MAX_X, rn->EXTENT_MAX_Y, rn->EXTENT_MIN_Z,MM);
3499 moveAndRotateThisPoint(&bboxPoints[7], rn->EXTENT_MAX_X, rn->EXTENT_MAX_Y, rn->EXTENT_MAX_Z,MM);
3503 static int done_once = 0;
3504 if(done_once)
return;
3506 bmin = bmax = bboxPoints[0].z;
3507 for (ci=0; ci<8; ci++) {
3508 bmin = min(bmin,bboxPoints[ci].z);
3509 bmax = max(bmax,bboxPoints[ci].z);
3511 viewer->nearPlane = max(.1,bmin);
3515 printf(
"\rnear %lf far %lf",
viewer->nearPlane,
viewer->farPlane);
3520 for (ci=0; ci<8; ci++) {
3521 bboxMovedCentreZ += bboxPoints[ci].z;
3525 printf (
"moved bbox node %d is %4.2f %4.2f %4.2f\n",ci,bboxPoints[ci].x, bboxPoints[ci].y, bboxPoints[ci].z);
3528 if (!doingGeoSpatial) {
3529 if (-(bboxPoints[ci].z) > cfp) cfp = -(bboxPoints[ci].z);
3530 if (-(bboxPoints[ci].z) < cnp) cnp = -(bboxPoints[ci].z);
3534 bboxMovedCentreZ /= 8.0;
3536 if (doingGeoSpatial) {
3537 cnp = -bboxMovedCentreZ - bboxSphereRadius;
3538 cfp = -bboxMovedCentreZ;
3543 ConsoleMessage (
"centre of bbox is %lf Z away",bboxMovedCentreZ);
3544 ConsoleMessage (
"bboxMovedCentreZ minus bboxRadius %lf",-bboxMovedCentreZ - bboxSphereRadius);
3552 if (cnp<DEFAULT_NEARPLANE) cnp = DEFAULT_NEARPLANE;
3554 if (cfp<1.0) cfp = 1.0;
3564 printf (
"cnp %lf cfp before leaving room for Background %lf\n",cnp,cfp);
3574 if ((cnp<1.0) && (vpnode->_nodeType == NODE_GeoViewpoint)) {
3576 cnp = Viewer()->currentPosInModel.z/16.0;
3578 ConsoleMessage (
"vp height %lf moved height %lf posinModel %f",X3D_GEOVIEWPOINT(vpnode)->position.c[2],
3579 X3D_GEOVIEWPOINT(vpnode)->__movedPosition.c[2],Viewer()->currentPosInModel.z);
3580 smooger ++;
if (smooger == 100) smooger = 0;
3593 if (vectorSize(getActiveBindableStacks(tg)->background)!= 0) {
3594 viewer->farPlane = max(cfp * 10.0,DEFAULT_FARPLANE);
3595 viewer->backgroundPlane = max(cfp*5.0,DEFAULT_BACKGROUNDPLANE);
3597 viewer->farPlane = max(cfp,DEFAULT_FARPLANE);
3598 viewer->backgroundPlane = max(cfp,DEFAULT_BACKGROUNDPLANE);
3604 viewer->farPlane = max(cfp,DEFAULT_FARPLANE);
3606 printf(
"\rnear %lf far %lf",
viewer->nearPlane,
viewer->farPlane);
3611 viewer->farPlane = DEFAULT_FARPLANE;
3613 printf(
"\rnear %lf far %lf",
viewer->nearPlane,
viewer->farPlane);
3620 if (vectorSize(getActiveBindableStacks(tg)->background)!= 0) {
3621 viewer->farPlane = cfp * 10.0;
3622 viewer->backgroundPlane = cfp*5.0;
3625 viewer->backgroundPlane = cfp;
3631void doglClearColor() {
3635 FW_GL_CLEAR_COLOR(p->cc_red, p->cc_green, p->cc_blue, p->cc_alpha);
3636 tg->OpenGL_Utils.cc_changed = FALSE;
3644void clear_shader_table()
3654 if (p->myShaderTable != NULL) {
3657 for (i=0; i<vectorSize(p->myShaderTable); i++) {
3669 void GLAPIENTRY MessageCallback( GLenum source,
3674 const GLchar* message,
3675 const void* userParam )
3678 if(severity == GL_DEBUG_SEVERITY_HIGH){
3679 fprintf( stderr,
"GL CALLBACK: %s type = 0x%x, severity = 0x%x, message = %s\n",
3680 ( type == GL_DEBUG_TYPE_ERROR ?
"** GL ERROR **" :
"" ),
3681 type, severity, message );
3682 printf(
"press enter:");
3687bool fwl_initialize_GL()
3689 char blankTexture[] = {0x40, 0x40, 0x40, 0xFF};
3695 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start 1");
3696 initialize_rdr_caps();
3698 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start 3");
3703#if defined(TARGET_X11) || defined(TARGET_MOTIF)
3713 glEnable ( GL_DEBUG_OUTPUT );
3714 glDebugMessageCallback( MessageCallback, 0 );
3717 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start 4");
3719 FW_GL_MATRIX_MODE(GL_PROJECTION);
3720 FW_GL_LOAD_IDENTITY();
3721 FW_GL_MATRIX_MODE(GL_MODELVIEW);
3723 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start 6");
3725 FW_GL_CLEAR_COLOR(p->cc_red, p->cc_green, p->cc_blue, p->cc_alpha);
3727 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start 7");
3729 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start 8");
3732 FW_GL_DEPTHFUNC(GL_LEQUAL);
3733 glEnable(GL_DEPTH_TEST);
3735 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start 9");
3737 gl_linewidth = gglobal()->Mainloop.gl_linewidth;
3743 #if defined (GL_ES_VERSION_2_0)
3744 #if defined (GL_PROGRAM_POINT_SIZE)
3745 glEnable(GL_PROGRAM_POINT_SIZE);
3747 #if defined (GL_PROGRAM_POINT_SIZE_EXT)
3748 glEnable(GL_PROGRAM_POINT_SIZE_EXT);
3751 glPointSize (gl_linewidth);
3754 glLineWidth(gl_linewidth);
3756 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start a");
3767 FW_GL_BLENDFUNC(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
3768 FW_GL_CLEAR(GL_COLOR_BUFFER_BIT);
3770 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start b");
3779 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start c0");
3782 initializeLightTables();
3784 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start c1");
3788 CULL_FACE_INITIALIZE;
3790 FW_GL_PIXELSTOREI(GL_UNPACK_ALIGNMENT,1);
3791 FW_GL_PIXELSTOREI(GL_PACK_ALIGNMENT,1);
3793 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start c");
3797 FW_GL_GENTEXTURES (1,&tg->Textures.defaultBlankTexture);
3798 glBindTexture (GL_TEXTURE_2D, tg->Textures.defaultBlankTexture);
3799 FW_GL_TEXPARAMETERI( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
3800 FW_GL_TEXPARAMETERI( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
3801 FW_GL_TEXIMAGE2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, blankTexture);
3803 PRINT_GL_ERROR_IF_ANY(
"fwl_initialize_GL start d");
3808 clear_shader_table();
3824ivec4 get_current_viewport();
3825void BackEndClearBuffer(
int which) {
3826 ivec4 vport = get_current_viewport();
3827 FW_GL_SCISSOR(vport.X,vport.Y,vport.W,vport.H);
3828 glEnable(GL_SCISSOR_TEST);
3830 FW_GL_CLEAR(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
3833 FW_GL_CLEAR(GL_DEPTH_BUFFER_BIT);
3836 glDisable(GL_SCISSOR_TEST);
3840void BackEndLightsOff() {
3842 for (i=0; i<HEADLIGHT_LIGHT; i++) {
3843 setLightState(i, FALSE);
3848void fw_glMatrixMode(GLint mode) {
3851 p->whichMode = mode;
3853 printf (
"fw_glMatrixMode, projTOS %d, modTOS %d texvTOS %d\n",p->projectionviewTOS,p->modelviewTOS, p->textureviewTOS);
3855 switch (p->whichMode) {
3856 case GL_PROJECTION: printf (
"glMatrixMode(GL_PROJECTION)\n");
break;
3857 case GL_MODELVIEW: printf (
"glMatrixMode(GL_MODELVIEW)\n");
break;
3858 case GL_TEXTURE: printf (
"glMatrixMode(GL_TEXTURE)\n");
break;
3862 switch (p->whichMode) {
3863 case GL_PROJECTION: p->currentMatrix = (GLDOUBLE *) &p->FW_ProjectionView[p->projectionviewTOS];
break;
3864 case GL_MODELVIEW: p->currentMatrix = (GLDOUBLE *) &p->FW_ModelView[p->modelviewTOS];
break;
3865 case GL_TEXTURE: p->currentMatrix = (GLDOUBLE *) &p->FW_TextureView[p->textureviewTOS];
break;
3866 default: printf (
"invalid mode sent in it is %d, expected one of %d %d %d\n",p->whichMode, GL_PROJECTION,GL_MODELVIEW,GL_TEXTURE);
3871void fw_glLoadIdentity(
void) {
3874 loadIdentityMatrix(p->currentMatrix);
3875 FW_GL_LOADMATRIX(p->currentMatrix);
3878MATRIX4* PushMat(
int a,
int *b,
int c, MATRIX4 *d){
3881 printf(
"stack overflow, depth %d whichmode %d\n", *b, a);
3884 memcpy((
void *)d[*b], (
void *)d[*b - 1],
sizeof(GLDOUBLE)* 16);
3889void printMaxStackUsed(){
3891 ConsoleMessage(
"%25s %d\n",
"max modelview stack used", p->maxStackUsed);
3893void fw_glPushMatrix(
void) {
3896 switch (p->whichMode) {
3897 case GL_PROJECTION: p->currentMatrix = *PushMat(GL_PROJECTION, &p->projectionviewTOS, MAX_SMALL_MATRIX_STACK, p->FW_ProjectionView);
break;
3898 case GL_MODELVIEW: p->currentMatrix = *PushMat(GL_MODELVIEW, &p->modelviewTOS, MAX_LARGE_MATRIX_STACK, p->FW_ModelView);
break;
3899 case GL_TEXTURE: p->currentMatrix = *PushMat(GL_TEXTURE, &p->textureviewTOS, MAX_SMALL_MATRIX_STACK, p->FW_TextureView);
break;
3900 default:printf(
"wrong mode in popMatrix\n");
3902 p->maxStackUsed = max(p->maxStackUsed, p->modelviewTOS);
3903 FW_GL_LOADMATRIX(p->currentMatrix);
3920MATRIX4 *PopMat(
int a,
int *b, MATRIX4 *c){
3924 printf(
"popMatrix, stack underflow, whichMode %d\n", a);
3928void fw_glPopMatrix(
void) {
3931 switch (p->whichMode) {
3932 case GL_PROJECTION: p->currentMatrix = *PopMat(GL_PROJECTION, &p->projectionviewTOS, p->FW_ProjectionView);
break;
3933 case GL_MODELVIEW: p->currentMatrix = *PopMat(GL_MODELVIEW, &p->modelviewTOS, p->FW_ModelView);
break;
3934 case GL_TEXTURE: p->currentMatrix = *PopMat(GL_TEXTURE, &p->textureviewTOS, p->FW_TextureView);
break;
3936 default: printf (
"wrong mode in popMatrix\n");
3939 FW_GL_LOADMATRIX(p->currentMatrix);
3955void fw_glTransformd(GLDOUBLE *mat) {
3960 matmultiplyAFFINE(p->currentMatrix,mat,p->currentMatrix);
3961 FW_GL_LOADMATRIX(p->currentMatrix);
3964void fw_glTranslated(GLDOUBLE x, GLDOUBLE y, GLDOUBLE z) {
3970 p->currentMatrix[12] = p->currentMatrix[0] * x + p->currentMatrix[4] * y + p->currentMatrix[8] * z + p->currentMatrix[12];
3971 p->currentMatrix[13] = p->currentMatrix[1] * x + p->currentMatrix[5] * y + p->currentMatrix[9] * z + p->currentMatrix[13];
3972 p->currentMatrix[14] = p->currentMatrix[2] * x + p->currentMatrix[6] * y + p->currentMatrix[10] * z + p->currentMatrix[14];
3973 p->currentMatrix[15] = p->currentMatrix[3] * x + p->currentMatrix[7] * y + p->currentMatrix[11] * z + p->currentMatrix[15];
3975 FW_GL_LOADMATRIX(p->currentMatrix);
3978void fw_glTranslatef(
float x,
float y,
float z) {
3982 p->currentMatrix[12] = p->currentMatrix[0] * x + p->currentMatrix[4] * y + p->currentMatrix[8] * z + p->currentMatrix[12];
3983 p->currentMatrix[13] = p->currentMatrix[1] * x + p->currentMatrix[5] * y + p->currentMatrix[9] * z + p->currentMatrix[13];
3984 p->currentMatrix[14] = p->currentMatrix[2] * x + p->currentMatrix[6] * y + p->currentMatrix[10] * z + p->currentMatrix[14];
3985 p->currentMatrix[15] = p->currentMatrix[3] * x + p->currentMatrix[7] * y + p->currentMatrix[11] * z + p->currentMatrix[15];
3987 FW_GL_LOADMATRIX(p->currentMatrix);
3991void fw_glMultMatrixd (GLDOUBLE *mat) {
3994 matmultiplyFULL(p->currentMatrix,mat,p->currentMatrix);
3999void fw_glRotateRad (GLDOUBLE angle, GLDOUBLE x, GLDOUBLE y, GLDOUBLE z) {
4006 loadIdentityMatrix (myMat);
4009 mag = x*x + y*y + z*z;
4012 if (APPROX(mag,0.00)) {
4017 if (APPROX(angle,0.0)) {
4021 if (!APPROX(mag,1.0)) {
4023 in.x = x; in.y = y, in.z = z;
4024 vecnormal(&out,&in);
4025 x = out.x; y = out.y; z = out.z;
4030 matrotate(myMat,angle,x,y,z);
4034 matmultiplyAFFINE(p->currentMatrix,myMat,p->currentMatrix);
4038 FW_GL_LOADMATRIX(p->currentMatrix);
4042void fw_glRotated (GLDOUBLE angle, GLDOUBLE x, GLDOUBLE y, GLDOUBLE z) {
4050 radAng = angle * 3.1415926536/ 180.0;
4052 loadIdentityMatrix (myMat);
4055 mag = x*x + y*y + z*z;
4058 if (APPROX(mag,0.00)) {
4063 if (APPROX(angle,0.0)) {
4067 if (!APPROX(mag,1.0)) {
4069 in.x = x; in.y = y, in.z = z;
4070 vecnormal(&out,&in);
4071 x = out.x; y = out.y; z = out.z;
4079 matrotate(myMat,radAng,x,y,z);
4080 matmultiplyAFFINE(p->currentMatrix,p->currentMatrix,myMat);
4082 FW_GL_LOADMATRIX(p->currentMatrix);
4085void fw_glRotatef (
float a,
float x,
float y,
float z) {
4086 fw_glRotated((GLDOUBLE)a, (GLDOUBLE)x, (GLDOUBLE)y, (GLDOUBLE)z);
4089void fw_glScaled (GLDOUBLE x, GLDOUBLE y, GLDOUBLE z) {
4094 p->currentMatrix[0] *= x; p->currentMatrix[4] *= y; p->currentMatrix[8] *= z;
4095 p->currentMatrix[1] *= x; p->currentMatrix[5] *= y; p->currentMatrix[9] *= z;
4096 p->currentMatrix[2] *= x; p->currentMatrix[6] *= y; p->currentMatrix[10] *= z;
4097 p->currentMatrix[3] *= x; p->currentMatrix[7] *= y; p->currentMatrix[11] *= z;
4099 FW_GL_LOADMATRIX(p->currentMatrix);
4102void fw_glScalef (
float x,
float y,
float z) {
4107 p->currentMatrix[0] *= x; p->currentMatrix[4] *= y; p->currentMatrix[8] *= z;
4108 p->currentMatrix[1] *= x; p->currentMatrix[5] *= y; p->currentMatrix[9] *= z;
4109 p->currentMatrix[2] *= x; p->currentMatrix[6] *= y; p->currentMatrix[10] *= z;
4110 p->currentMatrix[3] *= x; p->currentMatrix[7] *= y; p->currentMatrix[11] *= z;
4112 FW_GL_LOADMATRIX(p->currentMatrix);
4116void fw_glGetDoublev (
int ty, GLDOUBLE *mat) {
4129 case GL_PROJECTION_MATRIX: dp = p->FW_ProjectionView[p->projectionviewTOS];
break;
4130 case GL_MODELVIEW_MATRIX: dp = p->FW_ModelView[p->modelviewTOS];
break;
4131 case GL_TEXTURE_MATRIX: dp = p->FW_TextureView[p->textureviewTOS];
break;
4133 loadIdentityMatrix(mat);
4134 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);
4137 memcpy((
void *)mat, (
void *) dp,
sizeof (GLDOUBLE) * MATRIX_SIZE);
4140void fw_glSetDoublev (
int ty, GLDOUBLE *mat) {
4153 case GL_PROJECTION_MATRIX: dp = p->FW_ProjectionView[p->projectionviewTOS];
break;
4154 case GL_MODELVIEW_MATRIX: dp = p->FW_ModelView[p->modelviewTOS];
break;
4155 case GL_TEXTURE_MATRIX: dp = p->FW_TextureView[p->textureviewTOS];
break;
4157 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);
4160 memcpy((
void *) dp, (
void *)mat,
sizeof (GLDOUBLE) * MATRIX_SIZE);
4165void kill_rendering() {
4179void kill_oldWorld(
int kill_EAI,
int kill_JavaScript,
char *file,
int line) {
4189 printf (
"kill 1 myThread %u displayThread %u\n",pthread_self(), gglobal()->threads.DispThrd);
4191 if (pthread_self().p != gglobal()->threads.DispThrd.p ) {
4193 if (pthread_self() != gglobal()->threads.DispThrd) {
4195 ConsoleMessage (
"kill_oldWorld must run in the displayThread called at %s:%d\n",file,line);
4201 resetSensorEvents();
4211 resource_tree_destroy();
4214 gglobal()->resources.root_res = NULL;
4221 rootnode = rootNode();
4222 if (rootnode != NULL) {
4223 if(rootnode->_nodeType == NODE_Proto){
4224 unload_broto(X3D_PROTO(rootnode));
4226 struct Multi_Node *children, *sortedChildren;
4228 children = &X3D_PROTO(rootNode())->__children;
4229 sortedChildren = &X3D_PROTO(rootNode())->_sortedChildren;
4231 if (children->n != 0) {
4232 for (i=0; i<children->n; i++) {
4233 markForDispose(children->p[i], TRUE);
4244 sortedChildren->n = 0;
4250 closeConsoleMessage();
4260 EAI_killBindables();
4262 killKeySensorNodeList();
4269 setMenuStatus(NULL);
4272 kill_userDefinedShaders();
4284#if !defined(EXCLUDE_EAI)
4288 fwlio_RxTx_control(CHANNEL_EAI, RxTx_STOP) ;
4293 sprintf (mystring,
"QUIT");
4294 Sound_toserver(mystring);
4299 if (globalParser != NULL) {
4300 parser_destroyData(globalParser);
4309 setMenuStatus(
"NONE");
4311void unload_globalParser() {
4315 parser_destroyData(globalParser);
4316 FREE_IF_NZ(globalParser->lexer);
4318 FREE_IF_NZ(globalParser);
4319 gglobal()->CParse.globalParser = NULL;
4321void unload_libraryscenes();
4322void reset_Browser(){
4327 struct X3D_Node *rootnode = rootNode();
4328 if (rootnode != NULL) {
4329 if( rootnode->_nodeType == NODE_Proto){
4330 unload_broto(X3D_PROTO(rootnode));
4331 unload_globalParser();
4332 resource_tree_destroy();
4333 unload_libraryscenes();
4336 kill_oldWorld(TRUE,TRUE,__FILE__,__LINE__);
4342#if defined (_ANDROID)
4345void fwl_Android_reloadAssets(
void) {
4353 resetGlobalShader();
4358 fwl_initialize_GL();
4362 if (p->linearNodeTable != NULL) {
4364 for (tc=0; tc<vectorSize(p->linearNodeTable); tc++){
4365 node = vector_get(
struct X3D_Node *,p->linearNodeTable,tc);
4373 switch (node->_nodeType) {
4378 me->__SphereIndxVBO = 0;
4379 FREE_IF_NZ(me->__points.p);
4380 me->__points.p = NULL;
4392 case NODE_Cylinder: {
4394 me->__cylinderVBO = 0;
4398 case NODE_Background: {
4413 for (i=0; i<VBO_COUNT; i++) pr->VBO_buffers[i] = 0;
4429int checkNode(
struct X3D_Node *node,
char *fn,
int line) {
4434 printf (
"checkNode, node is NULL at %s %d\n",fn,line);
4438 if (node == X3D_NODE(rootNode()))
return FALSE;
4442 for (tc=0; tc<vectorSize(p->linearNodeTable); tc++){
4443 if (vector_get(
struct X3D_Node *,p->linearNodeTable,tc) == node) {
4444 if (node->referenceCount > 0) {
4462static void createMemoryTable(){
4465 p->linearNodeTable = newVector(
struct X3D_Node*, 128);
4471void registerX3DNode(
struct X3D_Node * tmp){
4474 bool filledHole = FALSE;
4478 if (p->linearNodeTable == NULL) {
4479 createMemoryTable();
4483 if (p->potentialHoleCount > 0) {
4484 for (tc=0; tc<vectorSize(p->linearNodeTable); tc++){
4486 if (vector_get(
struct X3D_Node *,p->linearNodeTable,tc) == NULL) {
4487 vector_set(
struct X3D_Node *, p->linearNodeTable, tc, tmp);
4488 p->potentialHoleCount--;
4502 if (!filledHole) vector_pushBack(
struct X3D_Node *, p->linearNodeTable, tmp);
4506int removeNodeFromVector(
int iaction,
struct Vector *v,
struct X3D_Node *node);
4507void unRegisterX3DNode(
struct X3D_Node * tmp){
4510 if (p->linearNodeTable ) {
4511 removeNodeFromVector(1, p->linearNodeTable, tmp);
4527void doNotRegisterThisNodeForDestroy(
struct X3D_Node * nodePtr){
4535 for (i=0; i<vectorSize(p->linearNodeTable); i++) {
4536 if (vector_get(
struct X3D_Node *,p->linearNodeTable,i) == nodePtr) {
4537 vector_set(
struct X3D_Node *,p->linearNodeTable,i,NULL);
4538 p->potentialHoleCount++;
4556static void sortChildren (
int line,
struct Multi_Node *ch,
struct Multi_Node *sortedCh,
int sortForDistance) {
4571 printf (
"sortChildren line %d nc %d ",line,nc);
4572 if (sortForDistance) printf (
"sortForDistance ");
4578 if (nc != sortedCh->n) {
4579 FREE_IF_NZ(sortedCh->p);
4580 sortedCh->p = MALLOC(
void *,
sizeof (
struct X3DNode *) * nc);
4581 memcpy(sortedCh->p, ch->p,
sizeof(
struct X3DNode *) * nc);
4586 printf (
"sortChildren start, %d, chptr %u\n",nc,ch);
4591 if (!sortForDistance)
return;
4599 for(i=0; i<nc; i++) {
4601 for (j=(nc-1); j>i; j--) {
4603 a = X3D_NODE(sortedCh->p[j-1]);
4604 b = X3D_NODE(sortedCh->p[j]);
4608 if (a->_dist > b->_dist) {
4611 sortedCh->p[j-1] = b;
4625 printf (
"sortChildren returning.\n");
4626 for(i=0; i<nc; i++) {
4629 printf (
"child %d %u %f %s",i,b,b->_dist,stringNodeType(b->_nodeType));
4631 printf (
"no child %d", i);
4633 printf (
" unsorted %u\n",b);
4639void zeroVisibilityFlag(
void) {
4645 if (fwl_isinputThreadParsing())
return;
4649 if ((gglobal()->Frustum.OccFailed) || fwl_isTextureParsing()) {
4654 for (i=0; i<vectorSize(p->linearNodeTable); i++){
4655 node = vector_get(
struct X3D_Node *,p->linearNodeTable,i);
4657 node->_renderFlags = node->_renderFlags | VF_hasVisibleChildren;
4661 else if (p->linearNodeTable)
4664 for (i=0; i<vectorSize(p->linearNodeTable); i++){
4665 node = vector_get(
struct X3D_Node *,p->linearNodeTable,i);
4669 #ifdef OCCLUSIONVERBOSE
4670 if (((node->_renderFlags) & VF_hasVisibleChildren) != 0) {
4671 printf (
"%lf, zeroVisibility - %d is a %s, flags %x\n",TickTime(), i,stringNodeType(node->_nodeType), (node->_renderFlags) & VF_hasVisibleChildren);
4675 node->_renderFlags = node->_renderFlags & (0xFFFF^VF_hasVisibleChildren);
4687#define CMD(TTT,YYY) \
4689 if (NODE_NEEDS_COMPILING) compile_Metadata##TTT((struct X3D_Metadata##TTT *) YYY)
4691#define BEGIN_NODE(thistype) case NODE_##thistype:
4692#define END_NODE break;
4694#define SIBLING_SENSITIVE(thistype) \
4696 if (((struct X3D_##thistype *)node)->enabled) { \
4697 nParents = vectorSize((struct X3D_##thistype *)pnode->_parentVector); \
4698 parentVector = (((struct X3D_##thistype *)pnode)->_parentVector); \
4701#define ANCHOR_SENSITIVE(thistype) \
4703 anchorPtr = (struct X3D_Anchor *)node;
4708#define BINDABLE(thistype) \
4709 setBindPtr = (int *)(((char*)(node))+offsetof (struct X3D_##thistype, set_bind)); \
4710 if ((*setBindPtr) == 100) {setBindPtr = NULL; }
4712#define CHILDREN_NODE(thistype) \
4713 addChildren = NULL; removeChildren = NULL; \
4714 offsetOfChildrenPtr = offsetof (struct X3D_##thistype, children); \
4715 if (((struct X3D_##thistype *)node)->addChildren.n > 0) { \
4716 addChildren = &((struct X3D_##thistype *)node)->addChildren; \
4717 childrenPtr = &((struct X3D_##thistype *)node)->children; \
4719 if (((struct X3D_##thistype *)node)->removeChildren.n > 0) { \
4720 removeChildren = &((struct X3D_##thistype *)node)->removeChildren; \
4721 childrenPtr = &((struct X3D_##thistype *)node)->children; \
4724#define CHILDREN_SWITCH_NODE(thistype) \
4725 addChildren = NULL; removeChildren = NULL; \
4726 offsetOfChildrenPtr = offsetof (struct X3D_##thistype, choice); \
4727 if (((struct X3D_##thistype *)node)->addChildren.n > 0) { \
4728 addChildren = &((struct X3D_##thistype *)node)->addChildren; \
4729 childrenPtr = &((struct X3D_##thistype *)node)->choice; \
4731 if (((struct X3D_##thistype *)node)->removeChildren.n > 0) { \
4732 removeChildren = &((struct X3D_##thistype *)node)->removeChildren; \
4733 childrenPtr = &((struct X3D_##thistype *)node)->choice; \
4736#define CHILDREN_LOD_NODE \
4737 addChildren = NULL; removeChildren = NULL; \
4738 offsetOfChildrenPtr = offsetof (struct X3D_LOD, children); \
4739 if (X3D_LODNODE(node)->addChildren.n > 0) { \
4740 addChildren = &X3D_LODNODE(node)->addChildren; \
4741 if (X3D_LODNODE(node)->__isX3D == 0) childrenPtr = &X3D_LODNODE(node)->level; \
4742 else childrenPtr = &X3D_LODNODE(node)->children; \
4744 if (X3D_LODNODE(node)->removeChildren.n > 0) { \
4745 removeChildren = &X3D_LODNODE(node)->removeChildren; \
4746 if (X3D_LODNODE(node)->__isX3D == 0) childrenPtr = &X3D_LODNODE(node)->level; \
4747 else childrenPtr = &X3D_LODNODE(node)->children; \
4750#define CHILDREN_ANY_NODE(thistype,thischildren) \
4751 addChildren = NULL; removeChildren = NULL; \
4752 offsetOfChildrenPtr = offsetof (struct X3D_##thistype, thischildren); \
4753 if (((struct X3D_##thistype *)node)->addChildren.n > 0) { \
4754 addChildren = &((struct X3D_##thistype *)node)->addChildren; \
4755 childrenPtr = &((struct X3D_##thistype *)node)->thischildren; \
4757 if (((struct X3D_##thistype *)node)->removeChildren.n > 0) { \
4758 removeChildren = &((struct X3D_##thistype *)node)->removeChildren; \
4759 childrenPtr = &((struct X3D_##thistype *)node)->thischildren; \
4763#define EVIN_AND_FIELD_SAME(thisfield, thistype) \
4764 if ((((struct X3D_##thistype *)node)->set_##thisfield.n) > 0) { \
4765 ((struct X3D_##thistype *)node)->thisfield.n = 0; \
4766 FREE_IF_NZ (((struct X3D_##thistype *)node)->thisfield.p); \
4767 ((struct X3D_##thistype *)node)->thisfield.p = ((struct X3D_##thistype *)node)->set_##thisfield.p; \
4768 ((struct X3D_##thistype *)node)->thisfield.n = ((struct X3D_##thistype *)node)->set_##thisfield.n; \
4769 ((struct X3D_##thistype *)node)->set_##thisfield.n = 0; \
4770 ((struct X3D_##thistype *)node)->set_##thisfield.p = NULL; \
4778OLDCODE#define LOCAL_LIGHT_PARENT_FLAG \
4780OLDCODE
for (i = 0; i < vectorSize(pnode->_parentVector); i++) { \
4781OLDCODE
struct X3D_Node *n = vector_get(
struct X3D_Node*, pnode->_parentVector, i); \
4782OLDCODE
if( n != 0 ) n->_renderFlags = n->_renderFlags | VF_localLight; \
4787#define ADD_TO_PARENT_SIBAFFECTORS \
4789 for (i = 0; i < vectorSize(pnode->_parentVector); i++) { \
4790 struct X3D_Node *n = vector_get(struct X3D_Node*, pnode->_parentVector, i); \
4791 if( n != 0 ) AddToSibAffectors(n,pnode); \
4795#define CHECK_MATERIAL_TRANSPARENCY \
4796if (((struct X3D_Material *)node)->transparency > 0.0001) { \
4798update_renderFlag(X3D_NODE(pnode),VF_Blend | VF_shouldSortChildren);\
4799gglobal()->RenderFuncs.have_transparency = TRUE; \
4802#define CHECK_FILL_PROPERTY_FILLED \
4803 if ((((struct X3D_FillProperties *)node)->_enabled == TRUE) && (((struct X3D_FillProperties *)node)->filled == FALSE)) { \
4805 update_renderFlag(X3D_NODE(pnode),VF_Blend | VF_shouldSortChildren);\
4806 gglobal()->RenderFuncs.have_transparency = TRUE; \
4809#define CHECK_TWOSIDED_MATERIAL_TRANSPARENCY \
4810 if ((((struct X3D_TwoSidedMaterial *)node)->transparency > 0.0001) || (((struct X3D_TwoSidedMaterial *)node)->backTransparency > 0.0001)){ \
4812 update_renderFlag(X3D_NODE(pnode),VF_Blend | VF_shouldSortChildren);\
4813 gglobal()->RenderFuncs.have_transparency = TRUE; \
4816#define CHECK_IMAGETEXTURE_TRANSPARENCY \
4817 if (isTextureAlpha(((struct X3D_ImageTexture *)node)->__textureTableIndex)) { \
4819 update_renderFlag(X3D_NODE(pnode),VF_Blend | VF_shouldSortChildren);\
4820 gglobal()->RenderFuncs.have_transparency = TRUE; \
4823#define CHECK_PIXELTEXTURE_TRANSPARENCY \
4824 if (isTextureAlpha(((struct X3D_PixelTexture *)node)->__textureTableIndex)) { \
4826 update_renderFlag(X3D_NODE(pnode),VF_Blend | VF_shouldSortChildren);\
4827 gglobal()->RenderFuncs.have_transparency = TRUE; \
4830#define CHECK_MOVIETEXTURE_TRANSPARENCY \
4831 if (isTextureAlpha(((struct X3D_MovieTexture *)node)->__textureTableIndex)) { \
4833 update_renderFlag(X3D_NODE(pnode),VF_Blend | VF_shouldSortChildren);\
4834 gglobal()->RenderFuncs.have_transparency = TRUE; \
4850 if(node->_nodeType == NODE_Proto)
4856 if(pn->__children.n > 0)
4857 dnode = getTypeNode(pn->__children.p[0]);
4866void printStatsNodes(){
4871 ConsoleMessage(
"%25s %d\n",
"Nodes count", p->linearNodeTable->n);
4874int unRegisterX3DAnyNode(
struct X3D_Node *node);
4884 for (i = 0; i < vectorSize(p->linearNodeTable); i++){
4885 node = vector_get(
struct X3D_Node *, p->linearNodeTable, i);
4887 if (node->referenceCount <= 0) {
4890 unRegisterX3DAnyNode(node);
4892 vector_set(
struct X3D_Node *,p->linearNodeTable,i,NULL);
4901int isSiblingAffector(
struct X3D_Node *node){
4903 switch(node->_nodeType){
4904 case NODE_DirectionalLight:
4905 case NODE_SpotLight:
4906 case NODE_PointLight:
4908 case NODE_ClipPlane:
4910 case NODE_TextureProjectorPerspective:
4911 case NODE_TextureProjectorParallel:
4927int hasSiblingAffectorField(
struct X3D_Node *node,
int whereFrom){
4933 printf (
"hasSiblingAffectorField, node %p from line %d\n",node,whereFrom);
4936 switch(node->_nodeType){
4940 case NODE_Transform:
4942 case NODE_Billboard:
4943 case NODE_Collision:
4944 case NODE_GeoLocation:
4945 case NODE_GeoTransform:
4946 case NODE_HAnimSite:
4947 case NODE_HAnimHumanoid:
4950 case NODE_EspduTransform:
4951 case NODE_CADAssembly:
4956 case NODE_LayoutLayer:
4957 case NODE_LayoutGroup:
4958 case NODE_ScreenGroup:
4959 case NODE_PickableGroup:
4960 case NODE_StaticGroup:
4967void *sibAffectorPtr(
struct X3D_Node *node){
4971 int *fieldOffsetsPtr;
4972 fieldOffsetsPtr = (
int*) NODE_OFFSETS[node->_nodeType];
4974 while(fieldOffsetsPtr[0] > -1){
4976 if(fieldOffsetsPtr[0] == FIELDNAMES___sibAffectors){
4977 fieldPtr = offsetPointer_deref(
char *, node,fieldOffsetsPtr[1]);
4980 fieldOffsetsPtr += FIELDOFFSET_LENGTH;
4993 printf (
"in AddToSibAffectors, we have node parent NULL, node is a %s\n",stringNodeType(affector->_nodeType));
4997 if(hasSiblingAffectorField(parent,__LINE__) && isSiblingAffector(affector)){
4998 struct Multi_Node *safs = sibAffectorPtr(parent);
5000 safs->p = REALLOC(safs->p,(safs->n+1)*
sizeof(
struct X3D_Node*));
5001 safs->p[safs->n] = affector;
5006void zeroSibAffectors(
struct X3D_Node *node){
5009 struct Multi_Node* saf = sibAffectorPtr(node);
5019int needs_updating_Inline(
struct X3D_Node *node);
5022void startOfLoopNodeUpdates(
void) {
5026 struct Vector *parentVector;
5028 int i,j,k,foundbound;
5034 size_t offsetOfChildrenPtr;
5042 if (rootNode() == NULL)
return;
5046 removeChildren = NULL;
5048 parentVector = NULL;
5050 offsetOfChildrenPtr = 0;
5053 tg->Mainloop.HaveSensitive = FALSE;
5054 tg->RenderFuncs.have_transparency = FALSE;
5058 if (fwl_isinputThreadParsing())
return;
5059 profile_start(
"loopnodeupdt");
5066 for (i=0; i<vectorSize(p->linearNodeTable); i++){
5067 node = vector_get(
struct X3D_Node *,p->linearNodeTable,i);
5069 if (node->referenceCount <= 0) {
5078 vector_set(
struct X3D_Node *,p->linearNodeTable,i,NULL);
5081 node->_renderFlags = node->_renderFlags & (0xFFFF^VF_Sensitive);
5082 node->_renderFlags = node->_renderFlags & (0xFFFF^VF_Viewpoint);
5083 node->_renderFlags = node->_renderFlags & (0xFFFF^VF_localLight);
5084 node->_renderFlags = node->_renderFlags & (0xFFFF^VF_globalLight);
5085 node->_renderFlags = node->_renderFlags & (0xFFFF^VF_Blend);
5087 if(hasSiblingAffectorField(node,__LINE__)){
5088 zeroSibAffectors(node);
5096 rn->_renderFlags = rn->_renderFlags & (0xFFFF^VF_Sensitive);
5097 rn->_renderFlags = rn->_renderFlags & (0xFFFF^VF_Viewpoint);
5098 rn->_renderFlags = rn->_renderFlags & (0xFFFF^VF_localLight);
5099 rn->_renderFlags = rn->_renderFlags & (0xFFFF^VF_globalLight);
5100 rn->_renderFlags = rn->_renderFlags & (0xFFFF^VF_Blend);
5106 if (rootNode() != NULL) {
5107 struct Multi_Node *children, *_sortedChildren;
5108 node = (
struct X3D_Node*)rootNode();
5110 _sortedChildren = NULL;
5111 if(node->_nodeType == NODE_Proto){
5112 children = &X3D_PROTO(node)->__children;
5113 _sortedChildren = &X3D_PROTO(node)->_sortedChildren;
5115 if(node->_nodeType == NODE_Group) {
5116 children = &X3D_GROUP(node)->children;
5117 _sortedChildren = &X3D_GROUP(node)->_sortedChildren;
5119 sortChildren (__LINE__,children, _sortedChildren,rootNode()->_renderFlags & VF_shouldSortChildren);
5120 rootNode()->_renderFlags=rootNode()->_renderFlags & (0xFFFF^VF_shouldSortChildren);
5121 if(node->_nodeType == NODE_Proto){
5126 addChildren = NULL; removeChildren = NULL;
5127 offsetOfChildrenPtr = offsetof (
struct X3D_Proto, __children);
5128 if (((
struct X3D_Proto *)node)->addChildren.n > 0) {
5129 addChildren = &((
struct X3D_Proto *)node)->addChildren;
5130 childrenPtr = &((
struct X3D_Proto *)node)->__children;
5132 if (((
struct X3D_Proto *)node)->removeChildren.n > 0) {
5133 removeChildren = &((
struct X3D_Proto *)node)->removeChildren;
5134 childrenPtr = &((
struct X3D_Proto *)node)->__children;
5138 CHILDREN_NODE(Group)
5141 if (childrenPtr != NULL) {
5142 if (addChildren != NULL) {
5143 AddRemoveChildren(node,childrenPtr,(
struct X3D_Node * *) addChildren->p,addChildren->n,1,__FILE__,__LINE__);
5146 if (removeChildren != NULL) {
5147 AddRemoveChildren(node,childrenPtr,(
struct X3D_Node * *) removeChildren->p,removeChildren->n,2,__FILE__,__LINE__);
5148 removeChildren->n=0;
5151 MARK_EVENT(node,offsetOfChildrenPtr);
5162 for (i=0; i<vectorSize(p->linearNodeTable); i++){
5163 node = vector_get(
struct X3D_Node *,p->linearNodeTable,i);
5165 if (node->referenceCount > 0) {
5167 node = getTypeNode(node);
5168 if(node == NULL && pnode != NULL)
5169 if(pnode->_nodeType == NODE_Proto){
5183 load_externProtoInstance(X3D_PROTO(pnode));
5185 node = getTypeNode(pnode);
5189 switch (node->_nodeType) {
5192 if ((X3D_SHAPE(node)->__occludeCheckCount <=0) ||
5193 (X3D_SHAPE(node)->__visible)) {
5194 update_renderFlag (X3D_NODE(pnode),VF_hasVisibleChildren);
5198 X3D_SHAPE(node)->__occludeCheckCount--;
5205 BEGIN_NODE(DirectionalLight)
5206 if (X3D_DIRECTIONALLIGHT(node)->on) {
5207 if (X3D_DIRECTIONALLIGHT(node)->global)
5208 update_renderFlag(pnode,VF_globalLight);
5211 ADD_TO_PARENT_SIBAFFECTORS
5215 BEGIN_NODE(SpotLight)
5216 if (X3D_SPOTLIGHT(node)->on) {
5217 if (X3D_SPOTLIGHT(node)->global)
5218 update_renderFlag(pnode,VF_globalLight);
5221 ADD_TO_PARENT_SIBAFFECTORS
5225 BEGIN_NODE(PointLight)
5226 if (X3D_POINTLIGHT(node)->on) {
5227 if (X3D_POINTLIGHT(node)->global)
5228 update_renderFlag(pnode,VF_globalLight);
5231 ADD_TO_PARENT_SIBAFFECTORS
5235 BEGIN_NODE(LocalFog)
5236 ADD_TO_PARENT_SIBAFFECTORS
5238 BEGIN_NODE(ClipPlane)
5239 ADD_TO_PARENT_SIBAFFECTORS
5242 ADD_TO_PARENT_SIBAFFECTORS
5244 BEGIN_NODE(TextureProjectorPerspective)
5245 if (X3D_TEXTUREPROJECTORPERSPECTIVE(node)->on) {
5246 if (X3D_TEXTUREPROJECTORPERSPECTIVE(node)->global)
5247 update_renderFlag(pnode,VF_globalLight);
5250 ADD_TO_PARENT_SIBAFFECTORS
5254 BEGIN_NODE(TextureProjectorParallel)
5255 if (X3D_TEXTUREPROJECTORPARALLEL(node)->on) {
5256 if (X3D_TEXTUREPROJECTORPARALLEL(node)->global)
5257 update_renderFlag(pnode,VF_globalLight);
5260 ADD_TO_PARENT_SIBAFFECTORS
5269 BEGIN_NODE(IndexedLineSet)
5270 EVIN_AND_FIELD_SAME(colorIndex,IndexedLineSet)
5271 EVIN_AND_FIELD_SAME(coordIndex,IndexedLineSet)
5274 BEGIN_NODE(IndexedTriangleFanSet)
5275 EVIN_AND_FIELD_SAME(index,IndexedTriangleFanSet)
5277 BEGIN_NODE(IndexedTriangleSet)
5278 EVIN_AND_FIELD_SAME(index,IndexedTriangleSet)
5280 BEGIN_NODE(IndexedTriangleStripSet)
5281 EVIN_AND_FIELD_SAME(index,IndexedTriangleStripSet)
5283 BEGIN_NODE(GeoElevationGrid)
5284 EVIN_AND_FIELD_SAME(height,GeoElevationGrid)
5286 BEGIN_NODE(ElevationGrid)
5287 EVIN_AND_FIELD_SAME(height,ElevationGrid)
5289 BEGIN_NODE(Extrusion)
5290 EVIN_AND_FIELD_SAME(crossSection,Extrusion)
5291 EVIN_AND_FIELD_SAME(orientation,Extrusion)
5292 EVIN_AND_FIELD_SAME(scale,Extrusion)
5293 EVIN_AND_FIELD_SAME(spine,Extrusion)
5295 BEGIN_NODE(IndexedFaceSet)
5296 EVIN_AND_FIELD_SAME(colorIndex,IndexedFaceSet)
5297 EVIN_AND_FIELD_SAME(coordIndex,IndexedFaceSet)
5298 EVIN_AND_FIELD_SAME(normalIndex,IndexedFaceSet)
5299 EVIN_AND_FIELD_SAME(texCoordIndex,IndexedFaceSet)
5309 BEGIN_NODE(LineSensor) SIBLING_SENSITIVE(LineSensor) END_NODE
5310 BEGIN_NODE(PointSensor) SIBLING_SENSITIVE(PointSensor) END_NODE
5311 BEGIN_NODE(PlaneSensor) SIBLING_SENSITIVE(PlaneSensor) END_NODE
5312 BEGIN_NODE(SphereSensor) SIBLING_SENSITIVE(SphereSensor) END_NODE
5313 BEGIN_NODE(CylinderSensor) SIBLING_SENSITIVE(CylinderSensor) END_NODE
5314 BEGIN_NODE(TouchSensor) SIBLING_SENSITIVE(TouchSensor) END_NODE
5315 BEGIN_NODE(GeoTouchSensor) SIBLING_SENSITIVE(GeoTouchSensor) END_NODE
5319 propagateExtent(X3D_NODE(node));
5320 ANCHOR_SENSITIVE(Anchor)
5321 CHILDREN_NODE(Anchor)
5326 update_renderFlag (X3D_NODE(pnode),VF_hasVisibleChildren);
5329 BEGIN_NODE(CADLayer)
5330 propagateExtent(X3D_NODE(node));
5331 CHILDREN_NODE(Switch)
5336 sortChildren (__LINE__,&X3D_CADPART(node)->children,&X3D_CADPART(node)->_sortedChildren,pnode->_renderFlags & VF_shouldSortChildren);
5337 TURN_OFF_SHOULDSORTCHILDREN
5338 propagateExtent(X3D_NODE(node));
5339 CHILDREN_NODE(CADPart)
5343 BEGIN_NODE(CADAssembly)
5344 sortChildren (__LINE__,&X3D_CADASSEMBLY(node)->children,&X3D_CADASSEMBLY(node)->_sortedChildren,pnode->_renderFlags & VF_shouldSortChildren);
5345 TURN_OFF_SHOULDSORTCHILDREN
5346 propagateExtent(X3D_NODE(node));
5347 CHILDREN_NODE(CADAssembly)
5351 BEGIN_NODE(Viewpoint) BINDABLE(Viewpoint) END_NODE
5352 BEGIN_NODE(OrthoViewpoint) BINDABLE(OrthoViewpoint) END_NODE
5353 BEGIN_NODE(GeoViewpoint) BINDABLE(GeoViewpoint) END_NODE
5355 BEGIN_NODE(NavigationInfo)
5357 BINDABLE(NavigationInfo)
5360 BEGIN_NODE(StaticGroup)
5362 sortChildren (__LINE__,&X3D_STATICGROUP(node)->children,&X3D_STATICGROUP(node)->_sortedChildren,pnode->_renderFlags & VF_shouldSortChildren);
5363 TURN_OFF_SHOULDSORTCHILDREN
5364 propagateExtent(X3D_NODE(node));
5370 sortChildren (__LINE__,&X3D_GROUP(node)->children,&X3D_GROUP(node)->_sortedChildren,pnode->_renderFlags & VF_shouldSortChildren);
5371 TURN_OFF_SHOULDSORTCHILDREN
5372 propagateExtent(X3D_NODE(node));
5373 CHILDREN_NODE(Group)
5376 BEGIN_NODE(PickableGroup)
5379 propagateExtent(X3D_NODE(node));
5380 CHILDREN_NODE(PickableGroup)
5384 sortChildren (__LINE__,&X3D_INLINE(node)->__children,&X3D_INLINE(node)->_sortedChildren,node->_renderFlags & VF_shouldSortChildren);
5385 TURN_OFF_SHOULDSORTCHILDREN
5386 propagateExtent(X3D_NODE(node));
5387 CHILDREN_ANY_NODE(Inline,__children)
5390 BEGIN_NODE(Transform)
5391 sortChildren (__LINE__,&X3D_TRANSFORM(node)->children,&X3D_TRANSFORM(node)->_sortedChildren,pnode->_renderFlags & VF_shouldSortChildren);
5392 TURN_OFF_SHOULDSORTCHILDREN
5393 propagateExtent(X3D_NODE(node));
5394 CHILDREN_NODE(Transform)
5403 BEGIN_NODE(Contour2D)
5404 CHILDREN_NODE(Contour2D)
5407 BEGIN_NODE(HAnimSite)
5408 CHILDREN_NODE(HAnimSite)
5411 BEGIN_NODE(HAnimSegment)
5412 CHILDREN_NODE(HAnimSegment)
5415 BEGIN_NODE(HAnimJoint)
5416 CHILDREN_NODE(HAnimJoint)
5419 BEGIN_NODE(Billboard)
5420 propagateExtent(X3D_NODE(node));
5421 CHILDREN_NODE(Billboard)
5422 update_renderFlag(pnode,VF_Proximity);
5425 BEGIN_NODE(Collision)
5426 propagateExtent(X3D_NODE(node));
5427 CHILDREN_NODE(Collision)
5431 propagateExtent(X3D_NODE(node));
5432 CHILDREN_SWITCH_NODE(Switch)
5436 propagateExtent(X3D_NODE(node));
5438 update_renderFlag(pnode,VF_Proximity);
5442 BEGIN_NODE(Material) CHECK_MATERIAL_TRANSPARENCY END_NODE
5443 BEGIN_NODE(TwoSidedMaterial) CHECK_TWOSIDED_MATERIAL_TRANSPARENCY END_NODE
5444 BEGIN_NODE(FillProperties) CHECK_FILL_PROPERTY_FILLED END_NODE
5447 BEGIN_NODE(ImageTexture) CHECK_IMAGETEXTURE_TRANSPARENCY END_NODE
5448 BEGIN_NODE(PixelTexture) CHECK_PIXELTEXTURE_TRANSPARENCY END_NODE
5449 BEGIN_NODE(MovieTexture) CHECK_MOVIETEXTURE_TRANSPARENCY END_NODE
5451 BEGIN_NODE(VolumeData)
5452 tg->RenderFuncs.have_transparency = TRUE;
5453 update_renderFlag(X3D_NODE(pnode),VF_Blend | VF_shouldSortChildren);\
5455 BEGIN_NODE(SegmentedVolumeData)
5456 tg->RenderFuncs.have_transparency = TRUE;
5457 update_renderFlag(X3D_NODE(pnode),VF_Blend | VF_shouldSortChildren);\
5459 BEGIN_NODE(IsoSurfaceVolumeData)
5460 tg->RenderFuncs.have_transparency = TRUE;
5461 update_renderFlag(X3D_NODE(pnode),VF_Blend | VF_shouldSortChildren);\
5466 BEGIN_NODE(Background)
5467 BINDABLE(Background)
5471 BEGIN_NODE(TextureBackground)
5472 BINDABLE(TextureBackground)
5483 BEGIN_NODE (VisibilitySensor)
5484 #ifdef OCCLUSION_STUFF
5486 if ((X3D_VISIBILITYSENSOR(node)->__occludeCheckCount <=0) ||
5487 (X3D_VISIBILITYSENSOR(node)->__visible)) {
5488 update_renderFlag (X3D_NODE(pnode),VF_hasVisibleChildren);
5492 X3D_VISIBILITYSENSOR(node)->__occludeCheckCount--;
5495 update_renderFlag(pnode,VF_Blend & VF_shouldSortChildren);
5499 update_renderFlag(pnode,VF_Other);
5504 BEGIN_NODE (ProximitySensor)
5505 if (X3D_PROXIMITYSENSOR(node)->enabled) update_renderFlag(pnode,VF_Proximity);
5509 BEGIN_NODE (GeoProximitySensor)
5510 if (X3D_GEOPROXIMITYSENSOR(node)->enabled) update_renderFlag(pnode,VF_Proximity);
5515 if (!(NODE_NEEDS_COMPILING)) {
5516 handle_GeoLODRange(X3D_GEOLOD(node));
5519 propagateExtent(X3D_NODE(node));
5522 BEGIN_NODE (GeoTransform)
5523 sortChildren (__LINE__,&X3D_GEOTRANSFORM(node)->children,&X3D_GEOTRANSFORM(node)->_sortedChildren,pnode->_renderFlags & VF_shouldSortChildren);
5524 TURN_OFF_SHOULDSORTCHILDREN
5525 propagateExtent(X3D_NODE(node));
5526 CHILDREN_NODE(GeoTransform)
5529 BEGIN_NODE (GeoLocation)
5530 sortChildren (__LINE__,&X3D_GEOLOCATION(node)->children,&X3D_GEOLOCATION(node)->_sortedChildren,pnode->_renderFlags & VF_shouldSortChildren);
5531 TURN_OFF_SHOULDSORTCHILDREN
5532 propagateExtent(X3D_NODE(node));
5533 CHILDREN_NODE(GeoLocation)
5536 BEGIN_NODE (EspduTransform)
5537 propagateExtent(X3D_NODE(node));
5538 CHILDREN_NODE(EspduTransform)
5542 BEGIN_NODE(MetadataSFBool) CMD(SFBool,node); END_NODE
5543 BEGIN_NODE(MetadataSFFloat) CMD(SFFloat,node); END_NODE
5544 BEGIN_NODE(MetadataMFFloat) CMD(MFFloat,node); END_NODE
5545 BEGIN_NODE(MetadataSFRotation) CMD(
SFRotation,node); END_NODE
5546 BEGIN_NODE(MetadataMFRotation) CMD(MFRotation,node); END_NODE
5547 BEGIN_NODE(MetadataSFVec3f) CMD(
SFVec3f,node); END_NODE
5548 BEGIN_NODE(MetadataMFVec3f) CMD(MFVec3f,node); END_NODE
5549 BEGIN_NODE(MetadataMFBool) CMD(MFBool,node); END_NODE
5550 BEGIN_NODE(MetadataSFInt32) CMD(SFInt32,node); END_NODE
5551 BEGIN_NODE(MetadataMFInt32) CMD(MFInt32,node); END_NODE
5552 BEGIN_NODE(MetadataSFNode) CMD(SFNode,node); END_NODE
5553 BEGIN_NODE(MetadataMFNode) CMD(MFNode,node); END_NODE
5554 BEGIN_NODE(MetadataSFColor) CMD(
SFColor,node); END_NODE
5555 BEGIN_NODE(MetadataMFColor) CMD(MFColor,node); END_NODE
5556 BEGIN_NODE(MetadataSFColorRGBA) CMD(
SFColorRGBA,node); END_NODE
5557 BEGIN_NODE(MetadataMFColorRGBA) CMD(MFColorRGBA,node); END_NODE
5558 BEGIN_NODE(MetadataSFTime) CMD(SFTime,node); END_NODE
5559 BEGIN_NODE(MetadataMFTime) CMD(MFTime,node); END_NODE
5560 BEGIN_NODE(MetadataSFString) CMD(SFString,node); END_NODE
5561 BEGIN_NODE(MetadataMFString) CMD(MFString,node); END_NODE
5562 BEGIN_NODE(MetadataSFVec2f) CMD(
SFVec2f,node); END_NODE
5563 BEGIN_NODE(MetadataMFVec2f) CMD(MFVec2f,node); END_NODE
5564 BEGIN_NODE(MetadataSFImage) CMD(SFImage,node); END_NODE
5565 BEGIN_NODE(MetadataSFVec3d) CMD(
SFVec3d,node); END_NODE
5566 BEGIN_NODE(MetadataMFVec3d) CMD(MFVec3d,node); END_NODE
5567 BEGIN_NODE(MetadataSFDouble) CMD(SFDouble,node); END_NODE
5568 BEGIN_NODE(MetadataMFDouble) CMD(MFDouble,node); END_NODE
5569 BEGIN_NODE(MetadataSFMatrix3f) CMD(
SFMatrix3f,node); END_NODE
5570 BEGIN_NODE(MetadataMFMatrix3f) CMD(MFMatrix3f,node); END_NODE
5571 BEGIN_NODE(MetadataSFMatrix3d) CMD(
SFMatrix3d,node); END_NODE
5572 BEGIN_NODE(MetadataMFMatrix3d) CMD(MFMatrix3d,node); END_NODE
5573 BEGIN_NODE(MetadataSFMatrix4f) CMD(
SFMatrix4f,node); END_NODE
5574 BEGIN_NODE(MetadataMFMatrix4f) CMD(MFMatrix4f,node); END_NODE
5575 BEGIN_NODE(MetadataSFMatrix4d) CMD(
SFMatrix4d,node); END_NODE
5576 BEGIN_NODE(MetadataMFMatrix4d) CMD(MFMatrix4d,node); END_NODE
5577 BEGIN_NODE(MetadataSFVec2d) CMD(
SFVec2d,node); END_NODE
5578 BEGIN_NODE(MetadataMFVec2d) CMD(MFVec2d,node); END_NODE
5579 BEGIN_NODE(MetadataSFVec4f) CMD(
SFVec4f,node); END_NODE
5580 BEGIN_NODE(MetadataMFVec4f) CMD(MFVec4f,node); END_NODE
5581 BEGIN_NODE(MetadataSFVec4d) CMD(
SFVec4d,node); END_NODE
5582 BEGIN_NODE(MetadataMFVec4d) CMD(MFVec4d,node); END_NODE
5589 if (nParents != 0) {
5590 for (j=0; j<nParents; j++) {
5592 n->_renderFlags = n->_renderFlags | VF_Sensitive;
5595 tg->Mainloop.HaveSensitive = TRUE;
5600 if (anchorPtr != NULL) {
5601 anchorPtr->_renderFlags = anchorPtr->_renderFlags | VF_Sensitive;
5604 tg->Mainloop.HaveSensitive = TRUE;
5609 if (setBindPtr != NULL) {
5611 if (*setBindPtr < 100) {
5614 send_bind_to(node,*setBindPtr);
5640 if (childrenPtr != NULL) {
5642 if (addChildren != NULL) {
5649 AddRemoveChildren(node,childrenPtr,(
struct X3D_Node * *) addChildren->p,addChildren->n,1,__FILE__,__LINE__);
5652 for (i=0; i<addChildren->n; i++) {
5653 struct X3D_Node *ch = X3D_NODE(addChildren->p[i]);
5654 add_parent(ch,node,__FILE__,__LINE__);
5660 if (removeChildren != NULL) {
5661 AddRemoveChildren(node,childrenPtr,(
struct X3D_Node * *) removeChildren->p,removeChildren->n,2,__FILE__,__LINE__);
5664 for (i=0; i<removeChildren->n; i++) {
5665 struct X3D_Node *ch = X3D_NODE(removeChildren->p[i]);
5666 remove_parent(ch,node);
5668 removeChildren->n=0;
5673 MARK_EVENT(node,offsetOfChildrenPtr);
5684 for(k=0;k<vectorSize(tg->Bindable.bstacks);k++){
5687 if( vectorSize(bstack->viewpoint) > 0){
5691 struct X3D_Node *boundvp = vector_back(
struct X3D_Node*,bstack->viewpoint);
5692 update_renderFlag(boundvp, VF_Viewpoint);
5693 calculateNearFarplanes(boundvp, bstack->layerId);
5694 calculateViewingDistIfJustBound(boundvp,bstack->layerId);
5704 viewer->nearPlane = DEFAULT_NEARPLANE;
5705 viewer->farPlane = DEFAULT_FARPLANE;
5706 viewer->backgroundPlane = DEFAULT_BACKGROUNDPLANE;
5708 profile_end(
"loopnodeupdt");
5715void markForDispose(
struct X3D_Node *node,
int recursive){
5717 int *fieldOffsetsPtr;
5720 if (node==NULL)
return;
5721 if (node==X3D_NODE(rootNode()) && node->_nodeType != NODE_Proto) {
5722 ConsoleMessage (
"not disposing rootNode");
5728 ConsoleMessage (
"\nmarkingForDispose %p (%s) currently at %d",node,
5729 stringNodeType(node->_nodeType),node->referenceCount);
5733 if (node->referenceCount > 0)
5734 node->referenceCount--;
5741 fieldOffsetsPtr = (
int*) NODE_OFFSETS[node->_nodeType];
5743 while (*fieldOffsetsPtr != -1) {
5744 fieldPtr = offsetPointer_deref(
char *, node,*(fieldOffsetsPtr+1));
5746 ConsoleMessage (
"looking at field %s type %s",FIELDNAMES[*fieldOffsetsPtr],FIELDTYPES[*(fieldOffsetsPtr+2)]);
5750 if (*fieldOffsetsPtr == FIELDNAMES_setValue)
5753 if (*fieldOffsetsPtr == FIELDNAMES_valueChanged)
5756 if (*fieldOffsetsPtr == FIELDNAMES__selected)
5759 if (*fieldOffsetsPtr == FIELDNAMES___oldChildren)
5762 if (*fieldOffsetsPtr == FIELDNAMES___oldKeyPtr)
5765 if (*fieldOffsetsPtr == FIELDNAMES___oldKeyValuePtr)
5769 if (node->_nodeType == NODE_GeoLOD) {
5770 if (*fieldOffsetsPtr == FIELDNAMES_children)
break;
5773 if (*fieldOffsetsPtr == FIELDNAMES__shaderUserDefinedFields)
5777 switch(*(fieldOffsetsPtr+2)){
5778 case FIELDTYPE_MFNode: {
5786 for (i=0; i<MNode->n; i++) {
5791 ConsoleMessage (
"calling markForDispose on node %p as it is an element of an MFNode",tp);
5793 markForDispose(tp,TRUE);
5799 case FIELDTYPE_SFNode: {
5802 memcpy(&SNode,fieldPtr,
sizeof(
struct X3D_Node *));
5805 ConsoleMessage (
"SFNode, field is %p...",SNode);
5806 if (SNode != NULL) {
5807 ConsoleMessage (
"SFNode, .... and it is of type %s",stringNodeType(SNode->_nodeType));
5808 ConsoleMessage (
" ... field SFNode, %s type %s\n",FIELDNAMES[*fieldOffsetsPtr],FIELDTYPES[*(fieldOffsetsPtr+2)]);
5812 if(SNode && SNode->referenceCount > 0) {
5814 ConsoleMessage (
"calling markForDispose on node %p as it is contents of SFNode field",SNode);
5816 markForDispose(SNode, TRUE);
5824 fieldOffsetsPtr += FIELDOFFSET_LENGTH;
5833OLDCODE #define DELETE_IF_IN_PRODCON(aaa) \
5834OLDCODE
if (tg->ProdCon.aaa) { \
5835OLDCODE
bool foundIt = FALSE; \
5837OLDCODE
for (i=0; i<vectorSize(tg->ProdCon.aaa); i++) { \
5838OLDCODE
if (vector_get(
struct X3D_Node*,tg->ProdCon.aaa, i) == structptr) { \
5839OLDCODE foundIt = TRUE; \
5843OLDCODE
if (foundIt) { \
5844OLDCODE
struct Vector *newStack = newVector(
struct X3D_Node*, 2); \
5845OLDCODE
for (i=0; i<vectorSize(tg->ProdCon.aaa); i++) { \
5846OLDCODE
if (vector_get(
struct X3D_Node*,tg->ProdCon.aaa, i) != structptr) { \
5847OLDCODE vector_pushBack(
struct X3D_Node*, newStack, \
5848OLDCODE vector_get(
struct X3D_Node*,tg->ProdCon.aaa,i)); \
5851OLDCODE deleteVector(
struct X3D_Node*, tg->ProdCon.aaa); \
5852OLDCODE tg->ProdCon.aaa = newStack; \
5856OLDCODE #define DELETE_IF_IN_STACK(aaa) \
5857OLDCODE
if (tg->Bindable.aaa) { \
5858OLDCODE
bool foundIt = FALSE; \
5860OLDCODE
for (i=0; i<vectorSize(tg->Bindable.aaa); i++) { \
5861OLDCODE
if (vector_get(
struct X3D_Node*,tg->Bindable.aaa, i) == structptr) { \
5862OLDCODE foundIt = TRUE; \
5866OLDCODE
if (foundIt) { \
5867OLDCODE
struct Vector *newStack = newVector(
struct X3D_Node*, 2); \
5868OLDCODE
for (i=0; i<vectorSize(tg->Bindable.aaa); i++) { \
5869OLDCODE
if (vector_get(
struct X3D_Node*,tg->Bindable.aaa, i) != structptr) { \
5870OLDCODE vector_pushBack(
struct X3D_Node*, newStack, \
5871OLDCODE vector_get(
struct X3D_Node*,tg->Bindable.aaa,i)); \
5874OLDCODE deleteVector(
struct X3D_Node*, tg->Bindable.aaa); \
5875OLDCODE tg->Bindable.aaa = newStack; \
5884BOOL walk_fields(
struct X3D_Node* node, BOOL (*callbackFunc)(),
void* callbackData)
5891 int type,mode,source;
5893 int *fieldOffsetsPtr;
5905 fieldOffsetsPtr = (
int *)NODE_OFFSETS[node->_nodeType];
5907 while (*fieldOffsetsPtr != -1) {
5908 fname = FIELDNAMES[fieldOffsetsPtr[0]];
5910 publicfield = fname && (fname[0] !=
'_') ? TRUE : FALSE;
5911 mode = PKW_from_KW(fieldOffsetsPtr[3]);
5912 type = fieldOffsetsPtr[2];
5914 fieldPtr = (
union anyVrml*)offsetPointer_deref(
char *, node,*(fieldOffsetsPtr+1));
5917 foundField = callbackFunc(callbackData,node,jfield,fieldPtr,fname,mode,type,source,publicfield);
5918 if( foundField )
break;
5919 fieldOffsetsPtr += FIELDOFFSET_LENGTH;
5925 user = nodeTypeSupportsUserFields(node);
5940 switch(node->_nodeType)
5943 case NODE_ComposedShader:
5944 case NODE_ShaderProgram :
5946 case NODE_PackagedShader:
5952 switch(node->_nodeType)
5954 case NODE_Script: shader =(
struct Shader_Script *)(X3D_SCRIPT(node)->__scriptObj);
break;
5955 case NODE_ComposedShader: shader =(
struct Shader_Script *)(X3D_COMPOSEDSHADER(node)->_shaderUserDefinedFields);
break;
5956 case NODE_ShaderProgram: shader =(
struct Shader_Script *)(X3D_SHADERPROGRAM(node)->_shaderUserDefinedFields);
break;
5957 case NODE_PackagedShader: shader =(
struct Shader_Script *)(X3D_PACKAGEDSHADER(node)->_shaderUserDefinedFields);
break;
5958 case NODE_Effect: shader =(
struct Shader_Script *)(X3D_EFFECT(node)->_shaderUserDefinedFields);
break;
5961 for(j=0; j!=vectorSize(shader->fields); ++j)
5964 mode = sfield->fieldDecl->PKWmode;
5965 fname = ScriptFieldDecl_getName(sfield);
5966 type = sfield->fieldDecl->fieldType;
5967 fieldPtr = &sfield->value;
5968 source = node->_nodeType == NODE_Script ? 1 : 2;
5970 foundField = callbackFunc(callbackData,node,jfield,fieldPtr,fname,mode,type,source,publicfield);
5985 for(j=0; j!=vectorSize(pstruct->iface); ++j)
5988 mode = pfield->mode;
5989 fname = pfield->cname;
5990 type = pfield->type;
5991 fieldPtr = &pfield->defaultVal;
5994 foundField = callbackFunc(callbackData,node,jfield,fieldPtr,fname,mode,type,source,publicfield);
6067BOOL isManagedField(
int mode,
int type, BOOL isPublic)
6069 BOOL isManaged = (type == FIELDTYPE_SFNode || type == FIELDTYPE_MFNode);
6070 isManaged = isManaged && (mode == PKW_initializeOnly || mode == PKW_inputOutput);
6071 isManaged = isManaged && isPublic;
6081void indentf(
int indent){
6083 for(m=0;m<indent;m++) printf(
" ");
6086void print_node_links0(
struct X3D_Node* sfn,
int *level);
6087BOOL cbPrintLinks(
void *callbackData,
struct X3D_Node* node,
int jfield,
6088 union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
6090 int *level = (
int*)callbackData;
6095 if(isManagedField(type,mode,publicfield))
6097 int n,k,haveSomething;
6099 haveSomething = (type==FIELDTYPE_SFNode && fieldPtr->sfnode) || (type==FIELDTYPE_MFNode && fieldPtr->mfnode.n);
6102 printf(
"%s ",fieldName);
6103 if(type==FIELDTYPE_SFNode){
6104 plist = &fieldPtr->sfnode;
6107 plist = fieldPtr->mfnode.p;
6108 n = fieldPtr->mfnode.n;
6118 if(n>1) indentf((*level));
6119 print_node_links0(sfn,level);
6121 if(type==FIELDTYPE_MFNode && n > 1){
6132void print_node_links0(
struct X3D_Node* sfn,
int *level)
6137 printf(
"node %p ",sfn);
6138 if(sfn->_parentVector && vectorSize(sfn->_parentVector)){
6140 printf(
" parents={");
6141 for(j=0;j<vectorSize(sfn->_parentVector);j++){
6142 struct X3D_Node *parent = vector_get(
struct X3D_Node *,sfn->_parentVector, j);
6143 printf(
"%p, ",parent);
6148 walk_fields(sfn,cbPrintLinks,level);
6151void print_node_links(
struct X3D_Node* sfn)
6154 print_node_links0(sfn,&level);
6156 printf(
"ouch level =%d\n",level);
6160BOOL cbUnlinkChild(
void *callbackData,
struct X3D_Node* node,
int jfield,
6161 union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
6163 if(isManagedField(mode,type,publicfield)){
6164 if(type == FIELDTYPE_SFNode){
6165 struct X3D_Node **sfn = &fieldPtr->sfnode;
6166 AddRemoveSFNodeFieldChild(node,sfn,*sfn,2,__FILE__,__LINE__);
6167 if(fieldPtr->sfnode)
6168 printf(
"didn't delete sfnode child\n");
6169 }
else if(type == FIELDTYPE_MFNode){
6171 AddRemoveChildren(node,mfn,mfn->p,mfn->n,2,__FILE__,__LINE__);
6176BOOL cbUnlinkParent(
void *callbackData,
struct X3D_Node* parent,
int jfield,
6177 union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
6179 struct X3D_Node* node = X3D_NODE(callbackData);
6180 if(isManagedField(mode,type,publicfield)){
6181 if(type == FIELDTYPE_SFNode){
6182 struct X3D_Node **sfn = &fieldPtr->sfnode;
6183 AddRemoveSFNodeFieldChild(parent,sfn,node,2,__FILE__,__LINE__);
6184 }
else if(type == FIELDTYPE_MFNode){
6186 AddRemoveChildren(parent,mfn,&node,1,2,__FILE__,__LINE__);
6191void unlink_node(
struct X3D_Node* node)
6196 walk_fields(node,cbUnlinkChild,NULL);
6198 if(node->_parentVector && vectorSize(node->_parentVector)){
6200 struct Vector* pp = newVector(
struct X3D_Node*,vectorSize(node->_parentVector));
6201 for(j=0;j<vectorSize(node->_parentVector);j++){
6202 struct X3D_Node *parent = vector_get(
struct X3D_Node *,node->_parentVector, j);
6203 vector_pushBack(
struct X3D_Node*,pp,parent);
6205 for(j=0;j<vectorSize(pp);j++){
6207 walk_fields(parent,cbUnlinkParent,node);
6209 node->_parentVector->n = 0;
6210 deleteVector(
struct X3D_Node*, pp);
6215void deleteMallocedFieldValue(
int type,
union anyVrml *fieldPtr);
6216BOOL cbFreeMallocedBuiltinField(
void *callbackData,
struct X3D_Node* node,
int jfield,
6217 union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
6233 if( strncmp(fieldName,
"__",2) && strcmp(fieldName,
"__oldurl") && strcmp(fieldName,
"_parentVector")) {
6236 deleteMallocedFieldValue(type,fieldPtr);
6237 if(type == FIELDTYPE_FreeWRLPTR){
6238 if(!strncmp(fieldName,
"__x",3) || !strncmp(fieldName,
"__v",3)) {
6239 FREE_IF_NZ(fieldPtr->sfnode);
6247BOOL cbFreePublicMallocedBuiltinField(
void *callbackData,
struct X3D_Node* node,
int jfield,
6248 union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
6259 if(strncmp(fieldName,
"_",1)) {
6262 deleteMallocedFieldValue(type,fieldPtr);
6268BOOL cbFreeMallocedUserField(
void *callbackData,
struct X3D_Node* node,
int jfield,
6269 union anyVrml *fieldPtr,
char *fieldName,
int mode,
int type,
int source,BOOL publicfield)
6282 if(strncmp(fieldName,
"__",2)) {
6285 deleteMallocedFieldValue(type,fieldPtr);
6293 switch(node->_nodeType)
6295 case NODE_Script: shader =(
struct Shader_Script *)(X3D_SCRIPT(node)->__scriptObj);
break;
6296 case NODE_ComposedShader: shader =(
struct Shader_Script *)(X3D_COMPOSEDSHADER(node)->_shaderUserDefinedFields);
break;
6297 case NODE_Effect: shader =(
struct Shader_Script *)(X3D_EFFECT(node)->_shaderUserDefinedFields);
break;
6298 case NODE_ShaderProgram: shader =(
struct Shader_Script *)(X3D_SHADERPROGRAM(node)->_shaderUserDefinedFields);
break;
6299 case NODE_PackagedShader: shader =(
struct Shader_Script *)(X3D_PACKAGEDSHADER(node)->_shaderUserDefinedFields);
break;
6304 switch(node->_nodeType)
6306 case NODE_Script: X3D_SCRIPT(node)->__scriptObj = (
void *)shader;
break;
6307 case NODE_ComposedShader: X3D_COMPOSEDSHADER(node)->_shaderUserDefinedFields = (
void *)shader;;
break;
6308 case NODE_Effect: X3D_EFFECT(node)->_shaderUserDefinedFields = (
void *)shader;;
break;
6309 case NODE_ShaderProgram: X3D_SHADERPROGRAM(node)->_shaderUserDefinedFields = (
void *)shader;;
break;
6310 case NODE_PackagedShader: X3D_PACKAGEDSHADER(node)->_shaderUserDefinedFields = (
void *)shader;;
break;
6318 for(i=0;i<vectorSize(shader->fields);i++){
6320 deleteScriptFieldDecl(field);
6324 FREE_IF_NZ(shader->fields);
6331void freeMallocedNodeFields0(
struct X3D_Node* node){
6341 int isScriptType, isBrotoType, hasUserFields;
6342 isScriptType = node->_nodeType == NODE_Script || node->_nodeType == NODE_ComposedShader || node->_nodeType == NODE_ShaderProgram || node->_nodeType == NODE_PackagedShader;
6343 isBrotoType = node->_nodeType == NODE_Proto;
6344 hasUserFields = isScriptType || isBrotoType;
6349 walk_fields(node,cbFreeMallocedUserField,NULL);
6353 deleteShaderDefinition(shader);
6354 setShader(node,NULL);
6356 }
else if(isBrotoType){
6358 deleteProtoDefinition(pnode->__protoDef);
6359 FREE_IF_NZ(pnode->__protoDef);
6360 FREE_IF_NZ(pnode->__typename);
6370 walk_fields(node,cbFreeMallocedBuiltinField,NULL);
6377void freeMallocedNodeFields(
struct X3D_Node* node){
6379 deleteVector(
void*,node->_parentVector);
6380 if(node->_gc) free_registered_node_gc(node);
6381 freeMallocedNodeFields0(node);
6621#ifdef DEBUG_FW_LOADMAT
6622 static void fw_glLoadMatrixd(GLDOUBLE *val,
char *where,
int line) {
6624 for (i=0; i<16; i++) {
6625 if (val[i] > 2000.0) printf (
"FW_GL_LOADMATRIX, val %d %lf at %s:%d\n",i,val[i],where,line);
6626 if (val[i] < -2000.0) printf (
"FW_GL_LOADMATRIX, val %d %lf at %s:%d\n",i,val[i],where,line);
6630static void fw_glLoadMatrixd(GLDOUBLE *val) {
6634 #ifndef GL_ES_VERSION_2_0
6638BOOL matrix3x3_inverse_float(
float *inn,
float *outt);
6640void sendExplicitMatriciesToShader (GLint ModelViewMatrix, GLint ProjectionMatrix, GLint NormalMatrix, GLint *TextureMatrix, GLint ModelViewInverseMatrix)
6652 dp = p->FW_ModelView[p->modelviewTOS];
6656 for (i=0; i<16; i++) {
6660 profile_start(
"sendmtx");
6661 GLUNIFORMMATRIX4FV(ModelViewMatrix,1,GL_FALSE,spval);
6662 profile_end(
"sendmtx");
6665 dp = p->FW_ProjectionView[p->projectionviewTOS];
6667 matdouble2float4(sp,dp);
6673 profile_start(
"sendmtx");
6674 GLUNIFORMMATRIX4FV(ProjectionMatrix,1,GL_FALSE,spval);
6675 profile_end(
"sendmtx");
6678 for(j=0;j<MAX_MULTITEXTURE;j++) {
6679 int itexturestackposition = j+1;
6680 if (TextureMatrix[j] != -1 && itexturestackposition <= p->textureviewTOS) {
6682 dp = p->FW_TextureView[itexturestackposition];
6687 for (i=0; i<16; i++) {
6691 profile_start(
"sendmtx");
6692 GLUNIFORMMATRIX4FV(TextureMatrix[j],1,GL_FALSE,spval);
6693 profile_end(
"sendmtx");
6697 if( ModelViewInverseMatrix != -1){
6704 GLDOUBLE inverseMV[16];
6708 dpp = p->FW_ModelView[p->modelviewTOS];
6709 memcpy(MV,dpp,
sizeof(GLDOUBLE)*16);
6710 matinverse (inverseMV,MV);
6713 for (ii=0; ii<16; ii++) {
6714 *spi = (float) *dpi;
6717 GLUNIFORMMATRIX4FV(ModelViewInverseMatrix,1,GL_FALSE,spvali);
6722 if (NormalMatrix != -1) {
6724 dp = p->FW_ModelView[p->modelviewTOS];
6733 spval[i*3 +j] = (
float) dp[i*4 + j];
6735 matrix3x3_inverse_float(spval, ftemp);
6737 for (i = 0; i < 3; i++)
6738 for (j = 0; j < 3; j++)
6739 normMat[i*3 +j] = ftemp[j*3 + i];
6743 GLDOUBLE inverseMV[16];
6744 GLDOUBLE transInverseMV[16];
6746 memcpy(MV,dp,
sizeof(GLDOUBLE)*16);
6748 matinverse (inverseMV,MV);
6749 mattranspose(transInverseMV,inverseMV);
6751 normMat[0] = (float) transInverseMV[0];
6752 normMat[1] = (float) transInverseMV[1];
6753 normMat[2] = (float) transInverseMV[2];
6755 normMat[3] = (float) transInverseMV[4];
6756 normMat[4] = (float) transInverseMV[5];
6757 normMat[5] = (float) transInverseMV[6];
6759 normMat[6] = (float) transInverseMV[8];
6760 normMat[7] = (float) transInverseMV[9];
6761 normMat[8] = (float) transInverseMV[10];
6769 profile_start(
"sendmtx");
6770 GLUNIFORMMATRIX3FV(NormalMatrix,1,GL_FALSE,normMat);
6771 profile_end(
"sendmtx");
6780 sendExplicitMatriciesToShader (me->ModelViewMatrix, me->ProjectionMatrix, me->NormalMatrix,me->TextureMatrix,me->ModelViewInverseMatrix);
6783#define SEND_VEC2(myMat,myVal) \
6784if (me->myMat != -1) { GLUNIFORM2FV(me->myMat,1,myVal);}
6786#define SEND_VEC4(myMat,myVal) \
6787if (me->myMat != -1) { GLUNIFORM4FV(me->myMat,1,myVal);}
6789#define SEND_FLOAT(myMat,myVal) \
6790if (me->myMat != -1) { GLUNIFORM1F(me->myMat,myVal);}
6792#define SEND_INT(myMat,myVal) \
6793if (me->myMat != -1) { GLUNIFORM1I(me->myMat,myVal);}
6802 profile_start(
"sendvec");
6803 memcpy(color4,fog->color.c,
sizeof(
float)*3);
6805 SEND_VEC4(fogColor,color4);
6806 SEND_FLOAT(fogvisibilityRange,fog->visibilityRange*fog->__fogScale);
6807 SEND_FLOAT(fogScale,1.0f);
6808 SEND_INT(fogType,fog->__fogType);
6810 profile_end(
"sendvec");
6813float *getTransformedClipPlanes();
6814int getClipPlaneCount();
6818 float *clipplanes = getTransformedClipPlanes();
6819 nsend = getClipPlaneCount();
6820 GLUNIFORM4FV(me->clipplanes,nsend,clipplanes);
6821 GLUNIFORM1I(me->nclipplanes,nsend);
6830 fw_FrontMaterial = &myap->fw_FrontMaterial;
6831 fw_BackMaterial = &myap->fw_BackMaterial;
6851PRINT_GL_ERROR_IF_ANY(
"BEGIN sendMaterialsToShader");
6854 profile_start(
"sendvec");
6855 SEND_VEC4(myMaterialAmbient,fw_FrontMaterial->ambient);
6856 SEND_VEC4(myMaterialDiffuse,fw_FrontMaterial->diffuse);
6857 SEND_VEC4(myMaterialSpecular,fw_FrontMaterial->specular);
6858 SEND_VEC4(myMaterialEmission,fw_FrontMaterial->emission);
6859 SEND_FLOAT(myMaterialShininess,fw_FrontMaterial->shininess);
6861 SEND_VEC4(myMaterialBackAmbient,fw_BackMaterial->ambient);
6862 SEND_VEC4(myMaterialBackDiffuse,fw_BackMaterial->diffuse);
6863 SEND_VEC4(myMaterialBackSpecular,fw_BackMaterial->specular);
6864 SEND_VEC4(myMaterialBackEmission,fw_BackMaterial->emission);
6865 SEND_FLOAT(myMaterialBackShininess,fw_BackMaterial->shininess);
6866 profile_end(
"sendvec");
6868 if (me->haveLightInShader) sendLightInfo(me);
6871 #if defined (GL_ES_VERSION_2_0)
6872 SEND_FLOAT(myPointSize,myap->pointSize);
6874 glPointSize(myap->pointSize > 0 ? myap->pointSize : 1);
6877 profile_start(
"sendmat");
6879 SEND_INT(filledBool,myap->filledBool);
6880 SEND_INT(hatchedBool,myap->hatchedBool);
6881 SEND_INT(algorithm,myap->algorithm);
6882 SEND_VEC4(hatchColour,myap->hatchColour);
6883 SEND_VEC2(hatchScale,myap->hatchScale);
6884 SEND_VEC2(hatchPercent,myap->hatchPercent);
6887 SEND_INT(texCoordGenType,myap->texCoordGeneratorType);
6888 profile_end(
"sendmat");
6889 PRINT_GL_ERROR_IF_ANY(
"END sendMaterialsToShader");
6892void __gluMultMatrixVecd(
const GLDOUBLE matrix[16],
const GLDOUBLE in[4],
6897 for (i=0; i<4; i++) {
6899 in[0] * matrix[0*4+i] +
6900 in[1] * matrix[1*4+i] +
6901 in[2] * matrix[2*4+i] +
6902 in[3] * matrix[3*4+i];
6908(GLDOUBLE objx, GLDOUBLE objy, GLDOUBLE objz,
6909 const GLDOUBLE modelMatrix[16],
6910 const GLDOUBLE projMatrix[16],
6911 const GLint viewport[4],
6912 GLDOUBLE *winx, GLDOUBLE *winy, GLDOUBLE *winz)
6921 __gluMultMatrixVecd(modelMatrix, in, out);
6922 __gluMultMatrixVecd(projMatrix, out, in);
6923 if (in[3] == 0.0)
return;
6928 in[0] = in[0] * 0.5 + 0.5;
6929 in[1] = in[1] * 0.5 + 0.5;
6930 in[2] = in[2] * 0.5 + 0.5;
6933 in[0] = in[0] * viewport[2] + viewport[0];
6934 in[1] = in[1] * viewport[3] + viewport[1];
6941void __gluMultMatricesd(
const GLDOUBLE a[16],
const GLDOUBLE b[16],
6946 for (i = 0; i < 4; i++) {
6947 for (j = 0; j < 4; j++) {
6962int __gluInvertMatrixd(
const GLDOUBLE m[16], GLDOUBLE invOut[16])
6964 GLDOUBLE inv[16], det;
6967 inv[0] = m[5]*m[10]*m[15] - m[5]*m[11]*m[14] - m[9]*m[6]*m[15]
6968 + m[9]*m[7]*m[14] + m[13]*m[6]*m[11] - m[13]*m[7]*m[10];
6969 inv[4] = -m[4]*m[10]*m[15] + m[4]*m[11]*m[14] + m[8]*m[6]*m[15]
6970 - m[8]*m[7]*m[14] - m[12]*m[6]*m[11] + m[12]*m[7]*m[10];
6971 inv[8] = m[4]*m[9]*m[15] - m[4]*m[11]*m[13] - m[8]*m[5]*m[15]
6972 + m[8]*m[7]*m[13] + m[12]*m[5]*m[11] - m[12]*m[7]*m[9];
6973 inv[12] = -m[4]*m[9]*m[14] + m[4]*m[10]*m[13] + m[8]*m[5]*m[14]
6974 - m[8]*m[6]*m[13] - m[12]*m[5]*m[10] + m[12]*m[6]*m[9];
6975 inv[1] = -m[1]*m[10]*m[15] + m[1]*m[11]*m[14] + m[9]*m[2]*m[15]
6976 - m[9]*m[3]*m[14] - m[13]*m[2]*m[11] + m[13]*m[3]*m[10];
6977 inv[5] = m[0]*m[10]*m[15] - m[0]*m[11]*m[14] - m[8]*m[2]*m[15]
6978 + m[8]*m[3]*m[14] + m[12]*m[2]*m[11] - m[12]*m[3]*m[10];
6979 inv[9] = -m[0]*m[9]*m[15] + m[0]*m[11]*m[13] + m[8]*m[1]*m[15]
6980 - m[8]*m[3]*m[13] - m[12]*m[1]*m[11] + m[12]*m[3]*m[9];
6981 inv[13] = m[0]*m[9]*m[14] - m[0]*m[10]*m[13] - m[8]*m[1]*m[14]
6982 + m[8]*m[2]*m[13] + m[12]*m[1]*m[10] - m[12]*m[2]*m[9];
6983 inv[2] = m[1]*m[6]*m[15] - m[1]*m[7]*m[14] - m[5]*m[2]*m[15]
6984 + m[5]*m[3]*m[14] + m[13]*m[2]*m[7] - m[13]*m[3]*m[6];
6985 inv[6] = -m[0]*m[6]*m[15] + m[0]*m[7]*m[14] + m[4]*m[2]*m[15]
6986 - m[4]*m[3]*m[14] - m[12]*m[2]*m[7] + m[12]*m[3]*m[6];
6987 inv[10] = m[0]*m[5]*m[15] - m[0]*m[7]*m[13] - m[4]*m[1]*m[15]
6988 + m[4]*m[3]*m[13] + m[12]*m[1]*m[7] - m[12]*m[3]*m[5];
6989 inv[14] = -m[0]*m[5]*m[14] + m[0]*m[6]*m[13] + m[4]*m[1]*m[14]
6990 - m[4]*m[2]*m[13] - m[12]*m[1]*m[6] + m[12]*m[2]*m[5];
6991 inv[3] = -m[1]*m[6]*m[11] + m[1]*m[7]*m[10] + m[5]*m[2]*m[11]
6992 - m[5]*m[3]*m[10] - m[9]*m[2]*m[7] + m[9]*m[3]*m[6];
6993 inv[7] = m[0]*m[6]*m[11] - m[0]*m[7]*m[10] - m[4]*m[2]*m[11]
6994 + m[4]*m[3]*m[10] + m[8]*m[2]*m[7] - m[8]*m[3]*m[6];
6995 inv[11] = -m[0]*m[5]*m[11] + m[0]*m[7]*m[9] + m[4]*m[1]*m[11]
6996 - m[4]*m[3]*m[9] - m[8]*m[1]*m[7] + m[8]*m[3]*m[5];
6997 inv[15] = m[0]*m[5]*m[10] - m[0]*m[6]*m[9] - m[4]*m[1]*m[10]
6998 + m[4]*m[2]*m[9] + m[8]*m[1]*m[6] - m[8]*m[2]*m[5];
7000 det = m[0]*inv[0] + m[1]*inv[4] + m[2]*inv[8] + m[3]*inv[12];
7006 for (i = 0; i < 16; i++)
7007 invOut[i] = inv[i] * det;
7014void fw_gluUnProject(GLDOUBLE winx, GLDOUBLE winy, GLDOUBLE winz,
7015 const GLDOUBLE modelMatrix[16],
7016 const GLDOUBLE projMatrix[16],
7017 const GLint viewport[4],
7018 GLDOUBLE *objx, GLDOUBLE *objy, GLDOUBLE *objz)
7023 GLDOUBLE finalMatrix[16];
7027 __gluMultMatricesd(modelMatrix, projMatrix, finalMatrix);
7028 if (!__gluInvertMatrixd(finalMatrix, finalMatrix))
return;
7036 in[0] = (in[0] - viewport[0]) / viewport[2];
7037 in[1] = (in[1] - viewport[1]) / viewport[3];
7040 in[0] = in[0] * 2 - 1;
7041 in[1] = in[1] * 2 - 1;
7042 in[2] = in[2] * 2 - 1;
7044 __gluMultMatrixVecd(finalMatrix, in, out);
7045 if (out[3] == 0.0)
return;
7055void fw_Ortho (GLDOUBLE left, GLDOUBLE right, GLDOUBLE bottom, GLDOUBLE top, GLDOUBLE nearZ, GLDOUBLE farZ) {
7060 dp = p->FW_ProjectionView[p->projectionviewTOS];
7063 if (right <= left) right = left+1.0;
7064 if (top <= bottom) top= bottom+1.0;
7065 if (farZ <= nearZ) farZ= nearZ + 2.0;
7068 mesa_Ortho(left,right,bottom,top,nearZ,farZ,dp);
7072 FW_GL_LOADMATRIX(dp);
7077void fw_gluPerspective(GLDOUBLE fovy, GLDOUBLE aspect, GLDOUBLE zNear, GLDOUBLE zFar) {
7078 GLDOUBLE xmin, xmax, ymin, ymax;
7087 ymax = zNear * tan(fovy * M_PI / 360.0);
7089 xmin = ymin * aspect;
7090 xmax = ymax * aspect;
7093 FW_GL_MATRIX_MODE(GL_PROJECTION);
7095 dp = p->FW_ProjectionView[p->projectionviewTOS];
7097 mesa_Frustum(xmin, xmax, ymin, ymax, zNear, zFar, ndp);
7098 mattranspose(ndp2,ndp);
7104 matmultiplyFULL(ndp,ndp2,dp);
7109 #define TRY_PERSPECTIVE_METHOD_1
7110 #ifdef TRY_PERSPECTIVE_METHOD_1
7111 FW_GL_LOADMATRIX(ndp);
7113 memcpy (p->FW_ProjectionView[p->projectionviewTOS],ndp,16*sizeof (GLDOUBLE));
7117 #ifdef TRY_PERSPECTIVE_METHOD_2
7121 GLDOUBLE sine, cotangent, deltaZ;
7122 GLDOUBLE radians = fovy / 2.0 * M_PI / 180.0;
7124 deltaZ = zFar - zNear;
7125 sine = sin(radians);
7126 if ((deltaZ == 0) || (sine == 0) || (aspect == 0)) {
7129 cotangent = cos(radians) / sine;
7131 loadIdentityMatrix(m);
7133 m[0*4+0] = cotangent / aspect;
7134 m[1*4+1] = cotangent;
7135 m[2*4+2] = -(zFar + zNear) / deltaZ;
7137 m[3*4+2] = -2 * zNear * zFar / deltaZ;
7139 matmultiplyFULL(m,m,dp);
7141 FW_GL_LOADMATRIX(m);
7148 #ifdef TRY_PERSPECTIVE_METHOD_3
7154 gluPerspective(fovy,aspect,zNear,zFar);
7155 FW_GL_GETDOUBLEV(GL_PROJECTION_MATRIX,yyy);
7168void fw_gluPerspective_2(GLDOUBLE xcenter, GLDOUBLE fovy, GLDOUBLE aspect, GLDOUBLE zNear, GLDOUBLE zFar) {
7172 GLDOUBLE xmin, xmax, ymin, ymax;
7181 ymax = zNear * tan(fovy * M_PI / 360.0);
7183 xmin = ymin * aspect;
7184 xmax = ymax * aspect;
7185 xmin += xcenter * xmin;
7186 xmax += xcenter * xmin;
7188 FW_GL_MATRIX_MODE(GL_PROJECTION);
7190 dp = p->FW_ProjectionView[p->projectionviewTOS];
7192 mesa_Frustum(xmin, xmax, ymin, ymax, zNear, zFar, ndp);
7193 mattranspose(ndp2,ndp);
7199 matmultiplyFULL(ndp,ndp2,dp);
7206 memcpy (p->FW_ProjectionView[p->projectionviewTOS],ndp,16*sizeof (GLDOUBLE));
7209void fw_gluPerspectiveTexture(GLDOUBLE fovy, GLDOUBLE aspect, GLDOUBLE zNear, GLDOUBLE zFar) {
7210 GLDOUBLE xmin, xmax, ymin, ymax;
7217 ymax = zNear * tan(fovy * M_PI / 360.0);
7219 xmin = ymin * aspect;
7220 xmax = ymax * aspect;
7223 FW_GL_MATRIX_MODE(GL_TEXTURE);
7224 FW_GL_LOAD_IDENTITY();
7226 dp = p->FW_TextureView[p->textureviewTOS];
7228 mesa_Frustum(xmin, xmax, ymin, ymax, zNear, zFar, ndp);
7229 mattranspose(ndp2,ndp);
7235 matmultiply(ndp,ndp2,dp);
7238 FW_GL_LOADMATRIX(ndp);
7241 memcpy (p->FW_TextureView[p->textureviewTOS],ndp,16*sizeof (GLDOUBLE));
7244void fw_gluPerspectiveTextureLookAt(GLDOUBLE ex, GLDOUBLE ey, GLDOUBLE ez,
7245 GLDOUBLE cx, GLDOUBLE cy, GLDOUBLE cz,
7246 GLDOUBLE ux,GLDOUBLE uy,GLDOUBLE uz)
7248 GLDOUBLE sx, sy, sz;
7249 GLDOUBLE fx, fy, fz;
7256 FW_GL_MATRIX_MODE(GL_TEXTURE);
7259 dp = p->FW_TextureView[p->textureviewTOS];
7261 sx=cx-ex; sy=cy-ey; sz=cz-ez;
7262 fx=sy*ux-uy*sz; fy=sz*ux-sx*uz; fz=sx*uy-sy*ux;
7264 ndp1[0]=sx;ndp1[4]=sy;ndp1[8]=sz;ndp1[12]=0;
7265 ndp1[1]=ux;ndp1[5]=uy;ndp1[9]=uz;ndp1[13]=0;
7266 ndp1[2]=-fx;ndp1[6]=-fy;ndp1[10]=-fz;ndp1[14]=0;
7267 ndp1[3]=0;ndp1[7]=0;ndp1[11]=0;ndp1[15]=1;
7269 ndp2[0]=1;ndp2[4]=0;ndp2[8]=0;ndp2[12]=-ex;
7270 ndp2[1]=0;ndp2[5]=1;ndp2[9]=0;ndp2[13]=-ey;
7271 ndp2[2]=0;ndp2[6]=0;ndp2[10]=1;ndp2[14]=-ez;
7272 ndp2[3]=0;ndp2[7]=0;ndp2[11]=0;ndp2[15]=1;
7274 matmultiply(ndp3,ndp1,ndp2);
7275 matmultiply(ndp,ndp3,dp);
7277 FW_GL_LOADMATRIX(ndp);
7280 memcpy (p->FW_TextureView[p->textureviewTOS],ndp,16*sizeof (GLDOUBLE));
7286void fw_gluPickMatrix(GLDOUBLE xx, GLDOUBLE yy, GLDOUBLE width, GLDOUBLE height, GLint *vp) {
7288 printf (
"PickMat %lf %lf %lf %lf %d %d %d %d\n",xx,yy,width,height,vp[0], vp[1],vp[2],vp[3]);
7291 if ((width < 0.0) || (height < 0.0))
return;
7293 FW_GL_TRANSLATE_D((vp[2] - 2.0 * (xx - vp[0])) / width, (vp[3] - 2.0 * (yy - vp[1])) / height, 0.0);
7294 FW_GL_SCALE_D(vp[2] / width, vp[3] / height, 1.0);
7314mesa_Frustum(GLDOUBLE left, GLDOUBLE right, GLDOUBLE bottom, GLDOUBLE top, GLDOUBLE nearZ, GLDOUBLE farZ, GLDOUBLE *m)
7317 GLDOUBLE x = (2.0*nearZ) / (right-left);
7318 GLDOUBLE y = (2.0*nearZ) / (top-bottom);
7319 GLDOUBLE a = (right+left) / (right-left);
7320 GLDOUBLE b = (top+bottom) / (top-bottom);
7321 GLDOUBLE c = -(farZ+nearZ) / ( farZ-nearZ);
7322 GLDOUBLE d = -(2.0F*farZ*nearZ) / (farZ-nearZ);
7358void mesa_Ortho(GLDOUBLE left, GLDOUBLE right, GLDOUBLE bottom, GLDOUBLE top, GLDOUBLE nearZ, GLDOUBLE farZ, GLDOUBLE *m)
7360#define M(row,col) m[col*4+row]
7361 M(0,0) = 2.0F / (right-left);
7364 M(0,3) = -(right+left) / (right-left);
7367 M(1,1) = 2.0F / (top-bottom);
7369 M(1,3) = -(top+bottom) / (top-bottom);
7373 M(2,2) = -2.0F / (farZ-nearZ);
7374 M(2,3) = -(farZ+nearZ) / (farZ-nearZ);
7385void projPerspective(GLDOUBLE fovy, GLDOUBLE aspect, GLDOUBLE zNear, GLDOUBLE zFar, GLDOUBLE *matrix) {
7386 GLDOUBLE xmin, xmax, ymin, ymax;
7391 ymax = zNear * tan(fovy * M_PI / 360.0);
7393 xmin = ymin * aspect;
7394 xmax = ymax * aspect;
7396 mesa_Frustum(xmin, xmax, ymin, ymax, zNear, zFar, ndp);
7397 mattranspose(ndp2,ndp);
7399 memcpy (matrix,ndp2,16*
sizeof (GLDOUBLE));
7403void projLookAt(GLDOUBLE eyex, GLDOUBLE eyey, GLDOUBLE eyez,
7404 GLDOUBLE centerx, GLDOUBLE centery, GLDOUBLE centerz,
7405 GLDOUBLE upx, GLDOUBLE upy, GLDOUBLE upz, GLDOUBLE *matrix)
7408 GLDOUBLE x[3], y[3], z[3];
7411 z[0] = eyex - centerx;
7412 z[1] = eyey - centery;
7413 z[2] = eyez - centerz;
7414 mag = sqrt(z[0] * z[0] + z[1] * z[1] + z[2] * z[2]);
7425 x[0] = y[1] * z[2] - y[2] * z[1];
7426 x[1] = -y[0] * z[2] + y[2] * z[0];
7427 x[2] = y[0] * z[1] - y[1] * z[0];
7429 y[0] = z[1] * x[2] - z[2] * x[1];
7430 y[1] = -z[0] * x[2] + z[2] * x[0];
7431 y[2] = z[0] * x[1] - z[1] * x[0];
7433 mag = sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
7440 mag = sqrt(y[0] * y[0] + y[1] * y[1] + y[2] * y[2]);
7447#define M(row,col) m[col*4+row]
7467 FW_GL_TRANSFORM_D(m);
7469 FW_GL_TRANSLATE_D(-eyex, -eyey, -eyez);
7472 vecsetd(eye,-eyex,-eyey,-eyez);
7473 mattranslate4d(m,eye);
7474 memcpy (matrix,m,16*
sizeof (GLDOUBLE));
7478void projOrtho (GLDOUBLE l, GLDOUBLE r, GLDOUBLE b, GLDOUBLE t,
7479 GLDOUBLE n, GLDOUBLE f,GLDOUBLE *matrix)
7484#define M(row,col) m[col*4+row]
7485 M(0, 0) = 2.0/(r-l);
7488 M(0, 3) = -((r+l) / r-l);
7490 M(1, 1) = 2.0/(t-b);
7492 M(1, 3) = -((t+b)/(r-b));
7495 M(2, 2) = -2.0/(f-n);
7496 M(2, 3) = -((f+n)/(f-n));
7520 memcpy (matrix,m,16*
sizeof (GLDOUBLE));