35#include <libFreeWRL.h>
37#include "../vrml_parser/Structs.h"
38#include "../main/headers.h"
39#include "../opengl/Frustum.h"
40#include "../opengl/Material.h"
41#include "../opengl/OpenGL_Utils.h"
42#include "../opengl/Textures.h"
43#include "Component_ProgrammableShaders.h"
44#include "Component_Shape.h"
45#include "RenderFuncs.h"
54 struct X3D_Node * this_textureTransform;
66static void *Component_Shape_constructor(){
71void Component_Shape_init(
struct tComponent_Shape *t){
74 t->prv = Component_Shape_constructor();
81void fwl_set_modulation(
int modulation){
83 p->modulation = modulation;
85int fwl_get_modulation(){
93 return &p->appearanceProperties;
97static int hasUserDefinedShader(
struct X3D_Node *node) {
98#define NO_SHADER 99999
99 unsigned int rv = NO_SHADER;
101 if (node==NULL)
return 0;
105 if (node->_nodeType == NODE_Appearance) {
110 if (ap && ap->shaders.n != 0) {
114 if (ap->shaders.n > 1) {
115 ConsoleMessage (
"warning, Appearance->shaders has more than 1 node, using only first one");
122 if (cps->_nodeType == NODE_ComposedShader) {
127 if (cps->_retrievedURLData) {
128 if (cps->_shaderUserNumber == -1) cps->_shaderUserNumber = getNextFreeUserDefinedShaderSlot();
129 rv = cps->_shaderUserNumber;
131 }
else if (cps->_nodeType == NODE_PackagedShader) {
133 if (X3D_PACKAGEDSHADER(cps)->_retrievedURLData) {
134 if (X3D_PACKAGEDSHADER(cps)->_shaderUserNumber == -1)
135 X3D_PACKAGEDSHADER(cps)->_shaderUserNumber = getNextFreeUserDefinedShaderSlot();
136 rv = X3D_PACKAGEDSHADER(cps)->_shaderUserNumber;
138 }
else if (cps->_nodeType == NODE_ProgramShader) {
140 if (X3D_PROGRAMSHADER(cps)->_retrievedURLData) {
141 if (X3D_PROGRAMSHADER(cps)->_shaderUserNumber == -1)
142 X3D_PROGRAMSHADER(cps)->_shaderUserNumber = getNextFreeUserDefinedShaderSlot();
144 rv = X3D_PROGRAMSHADER(cps)->_shaderUserNumber;
147 ConsoleMessage (
"shader field of Appearance is a %s, ignoring",stringNodeType(cps->_nodeType));
157 if (rv == NO_SHADER) rv = 0;
168 POSSIBLE_PROTO_EXPANSION(
struct X3D_Appearance *, X3D_NODE(appearance),tmpN)
169 if(tmpN && tmpN->texture)
170 if(tmpN->texture->_nodeType == NODE_GeneratedCubeMapTexture) ret = TRUE;
174void setUserShaderNode(
struct X3D_Node *me) {
176 p->userShaderNode = me;
179struct X3D_Node *getThis_textureTransform(){
181 return p->this_textureTransform;
183void clear_bound_textures();
193 RENDER_MATERIAL_SUBNODES(node->material);
195 if (node->fillProperties) {
196 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node *, node->fillProperties,tmpN);
201 if (node->lineProperties) {
202 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node *, node->lineProperties,tmpN);
214 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node *, node->textureTransform,p->this_textureTransform);
217 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node *, node->texture,tmpN);
218 tg->RenderFuncs.texturenode = (
void*)tmpN;
224 if (node->shaders.n !=0) {
226 int foundGoodShader = FALSE;
228 for (count=0; count<node->shaders.n; count++) {
229 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node *, node->shaders.p[count], tmpN);
233 if (foundGoodShader) {
236 SET_SHADER_SELECTED_FALSE(tmpN);
239 SET_FOUND_GOOD_SHADER(tmpN);
240 DEBUG_SHADER(
"running shader (%s) %d of %d\n",
241 stringNodeType(X3D_NODE(tmpN)->_nodeType),count, node->shaders.n);
249 if (node->effects.n !=0) {
252 prep_sibAffectors(X3D_NODE(node),&node->effects);
284 p->material_oneSided = node;
289 return p->material_oneSided;
293 return p->material_twoSided;
302 if (node->ambientIntensity < 0.0f) node->ambientIntensity=0.0f;
303 if (node->ambientIntensity > 1.0f) node->ambientIntensity=1.0f;
304 if (node->shininess < 0.0f) node->shininess=0.0f;
305 if (node->shininess > 1.0f) node->shininess=1.0f;
306 if (node->transparency < 0.0f) node->transparency=MIN_NODE_TRANSPARENCY;
307 if (node->transparency >= 1.0f) node->transparency=MAX_NODE_TRANSPARENCY;
309 for (i=0; i<3; i++) {
310 if (node->diffuseColor.c[i] < 0.0f) node->diffuseColor.c[i]=0.0f;
311 if (node->diffuseColor.c[i] > 1.0f) node->diffuseColor.c[i]=1.0f;
312 if (node->emissiveColor.c[i] < 0.0f) node->emissiveColor.c[i]=0.0f;
313 if (node->emissiveColor.c[i] > 1.0f) node->emissiveColor.c[i]=1.0f;
314 if (node->specularColor.c[i] < 0.0f) node->specularColor.c[i]=0.0f;
315 if (node->specularColor.c[i] > 1.0f) node->specularColor.c[i]=1.0f;
320 trans = 1.0f - node->transparency;
338 node->_verifiedColor.p[3] = trans;
339 node->_verifiedColor.p[7] = trans;
340 node->_verifiedColor.p[11] = trans;
341 node->_verifiedColor.p[15] = trans;
344 memcpy((
void *)(&node->_verifiedColor.p[8]), node->diffuseColor.c, sizeof (
float) * 3);
347 for(i=0; i<3; i++) { node->_verifiedColor.p[i+4] = node->_verifiedColor.p[i+8] * node->ambientIntensity; }
350 memcpy((
void *)(&node->_verifiedColor.p[12]), node->specularColor.c, sizeof (
float) * 3);
353 memcpy((
void *)(&node->_verifiedColor.p[0]), node->emissiveColor.c, sizeof (
float) * 3);
356 node->_verifiedColor.p[16] = node->shininess * 128.0f;
358#define MAX_SHIN 128.0f
359#define MIN_SHIN 0.01f
360 if ((node->_verifiedColor.p[16] > MAX_SHIN) || (node->_verifiedColor.p[16] < MIN_SHIN)) {
361 if (node->_verifiedColor.p[16]>MAX_SHIN){node->_verifiedColor.p[16] = MAX_SHIN;}
else{node->_verifiedColor.p[16]=MIN_SHIN;}
369#define CHECK_COLOUR_FIELD(aaa) \
371 struct X3D_##aaa *me = (struct X3D_##aaa *)realNode; \
372 if (me->color == NULL) return NOTHING; \
373 else return COLOUR_MATERIAL_SHADER; \
376#define CHECK_FOGCOORD_FIELD(aaa) \
378 struct X3D_##aaa *me = (struct X3D_##aaa *)realNode; \
379 if (me->fogCoord == NULL) return NOTHING; \
380 else return HAVE_FOG_COORDS; \
388static bool getIfLinePoints(
struct X3D_Node *realNode) {
389 if (realNode == NULL)
return false;
390 switch (realNode->_nodeType) {
391 case NODE_IndexedLineSet:
394 case NODE_Polyline2D:
395 case NODE_Polypoint2D:
406 int *fieldOffsetsPtr = NULL;
409 if (realGeomNode == NULL)
return tc;
411 fieldOffsetsPtr = (
int *)NODE_OFFSETS[realGeomNode->_nodeType];
413 while (*fieldOffsetsPtr != -1) {
414 if (*fieldOffsetsPtr == FIELDNAMES_texCoord) {
416 memcpy(&tc,offsetPointer_deref(
void*, realGeomNode,*(fieldOffsetsPtr+1)),
sizeof(
struct X3D_Node *));
419 fieldOffsetsPtr += FIELDOFFSET_LENGTH;
424static int getShapeTextureCoordGen(
struct X3D_Node *realNode) {
426 tc = getGeomTexCoordField(realNode);
428 if (tc->_nodeType == NODE_TextureCoordinateGenerator)
return HAVE_TEXTURECOORDINATEGENERATOR;
435static int getShapeColourShader (
struct X3D_Node *myGeom) {
438 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node *,myGeom,realNode);
440 if (realNode == NULL)
return NOTHING;
445 switch (realNode->_nodeType) {
446 CHECK_COLOUR_FIELD(IndexedFaceSet);
447 CHECK_COLOUR_FIELD(IndexedLineSet);
448 CHECK_COLOUR_FIELD(IndexedTriangleFanSet);
449 CHECK_COLOUR_FIELD(IndexedTriangleSet);
450 CHECK_COLOUR_FIELD(IndexedTriangleStripSet);
451 CHECK_COLOUR_FIELD(LineSet);
452 CHECK_COLOUR_FIELD(PointSet);
453 CHECK_COLOUR_FIELD(TriangleFanSet);
454 CHECK_COLOUR_FIELD(TriangleStripSet);
455 CHECK_COLOUR_FIELD(TriangleSet);
456 CHECK_COLOUR_FIELD(ElevationGrid);
457 CHECK_COLOUR_FIELD(GeoElevationGrid);
458 CHECK_COLOUR_FIELD(QuadSet);
459 CHECK_COLOUR_FIELD(IndexedQuadSet);
466static int getShapeFogShader (
struct X3D_Node *myGeom) {
469 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node *,myGeom,realNode);
471 if (realNode == NULL)
return NOTHING;
476 switch (realNode->_nodeType) {
477 CHECK_FOGCOORD_FIELD(IndexedFaceSet);
478 CHECK_FOGCOORD_FIELD(IndexedLineSet);
479 CHECK_FOGCOORD_FIELD(IndexedTriangleFanSet);
480 CHECK_FOGCOORD_FIELD(IndexedTriangleSet);
481 CHECK_FOGCOORD_FIELD(IndexedTriangleStripSet);
482 CHECK_FOGCOORD_FIELD(LineSet);
483 CHECK_FOGCOORD_FIELD(PointSet);
484 CHECK_FOGCOORD_FIELD(TriangleFanSet);
485 CHECK_FOGCOORD_FIELD(TriangleStripSet);
486 CHECK_FOGCOORD_FIELD(TriangleSet);
487 CHECK_FOGCOORD_FIELD(ElevationGrid);
489 CHECK_FOGCOORD_FIELD(QuadSet);
490 CHECK_FOGCOORD_FIELD(IndexedQuadSet);
497static int getAppearanceShader (
struct X3D_Node *myApp) {
502 int retval = NOTHING;
505 if (myApp == NULL)
return retval;
507 POSSIBLE_PROTO_EXPANSION(
struct X3D_Appearance *, myApp,realAppearanceNode);
508 if (!realAppearanceNode || realAppearanceNode->_nodeType != NODE_Appearance)
return retval;
510 if (realAppearanceNode->material != NULL) {
511 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node *, realAppearanceNode->material,realMaterialNode);
512 if(realMaterialNode) {
513 if (realMaterialNode->_nodeType == NODE_Material) {
514 retval |= MATERIAL_APPEARANCE_SHADER;
516 if (realMaterialNode->_nodeType == NODE_TwoSidedMaterial) {
517 retval |= TWO_MATERIAL_APPEARANCE_SHADER;
523 if (realAppearanceNode->fillProperties != NULL) {
525 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node *, realAppearanceNode->fillProperties,fp);
527 if (fp->_nodeType != NODE_FillProperties) {
528 ConsoleMessage(
"getAppearanceShader, fillProperties has a node type of %s",stringNodeType(fp->_nodeType));
531 if (X3D_FILLPROPERTIES(fp)->_enabled)
532 retval |= FILL_PROPERTIES_SHADER;
538 if (realAppearanceNode->texture != NULL) {
542 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node *, realAppearanceNode->texture,tex);
544 if ((tex->_nodeType == NODE_ImageTexture) ||
545 (tex->_nodeType == NODE_MovieTexture) ||
546 (tex->_nodeType == NODE_PixelTexture) ){
547 retval |= ONE_TEX_APPEARANCE_SHADER;
548 }
else if( (tex->_nodeType == NODE_PixelTexture3D) ||
549 (tex->_nodeType == NODE_ComposedTexture3D) ||
550 (tex->_nodeType == NODE_ImageTexture3D) ) {
551 retval |= ONE_TEX_APPEARANCE_SHADER;
552 retval |= TEX3D_SHADER;
553 if(tex->_nodeType == NODE_ComposedTexture3D)
554 retval |= TEX3D_LAYER_SHADER;
555 }
else if (tex->_nodeType == NODE_MultiTexture) {
556 retval |= MULTI_TEX_APPEARANCE_SHADER;
557 }
else if ((tex->_nodeType == NODE_ComposedCubeMapTexture) ||
558 (tex->_nodeType == NODE_ImageCubeMapTexture) ||
559 (tex->_nodeType == NODE_GeneratedCubeMapTexture)) {
560 retval |= HAVE_CUBEMAP_TEXTURE;
562 ConsoleMessage (
"getAppearanceShader, texture field %s not supported yet\n",
563 stringNodeType(tex->_nodeType));
569 printf (
"getAppearanceShader, returning %x\n",retval);
606 hatchX = 0.80f; hatchY = 0.80f;
607 algor = node->hatchStyle; filled = node->filled; hatched = node->hatched;
608 switch (node->hatchStyle) {
610 case 1: hatchX = 1.0f;
break;
611 case 2: hatchY = 1.0f;
break;
612 case 3: hatchY=1.0f;
break;
613 case 4: hatchY=1.0f;
break;
615 case 6: hatchY = 1.0f;
break;
618 node->hatched = FALSE;
622 me->filledBool = filled;
623 me->hatchedBool = hatched;
624 me->hatchPercent[0] = hatchX;
625 me->hatchPercent[1] = hatchY;
626 me->hatchScale[0] = node->_hatchScale.c[0];
627 me->hatchScale[1] = node->_hatchScale.c[1];
628 me->algorithm = algor;
629 me->hatchColour[0]=node->hatchColor.c[0]; me->hatchColour[1]=node->hatchColor.c[1]; me->hatchColour[2] = node->hatchColor.c[2];
630 me->hatchColour[3] = 1.0;
635 #ifdef NEED_TO_ADD_TO_SHADER
636 much of
this was working in older versions of FreeWRL,
637 before we went to 100% shader based code. Check FreeWRL
638 from (say) 2011 to see what the shader code looked like
646 if (node->linewidthScaleFactor > 1.0) {
648 glLineWidth(node->linewidthScaleFactor);
649 me= getAppearanceProperties();
650 me->pointSize = node->linewidthScaleFactor;
654 #ifdef NEED_TO_ADD_TO_SHADER
655 if (node->linetype > 1) {
657 switch (node->linetype) {
658 case 2: pat = 0xff00;
break;
659 case 3: pat = 0x4040;
break;
660 case 4: pat = 0x04ff;
break;
661 case 5: pat = 0x44fe;
break;
662 case 6: pat = 0x0100;
break;
663 case 7: pat = 0x0100;
break;
664 case 10: pat = 0xaaaa;
break;
665 case 11: pat = 0x0170;
break;
666 case 12: pat = 0x0000;
break;
667 case 13: pat = 0x0000;
break;
677int getImageChannelCountFromTTI(
struct X3D_Node *appearanceNode ){
679 int channels, imgalpha, haveTexture;
684 POSSIBLE_PROTO_EXPANSION(
struct X3D_Appearance*,appearanceNode,appearance);
688 if(appearance->texture){
693 if(appearance->texture->_nodeType == NODE_MultiTexture ||
694 appearance->texture->_nodeType == NODE_ComposedTexture3D ){
697 switch(appearance->texture->_nodeType){
698 case NODE_MultiTexture: mtex = &((
struct X3D_MultiTexture*)appearance->texture)->texture;
break;
699 case NODE_ComposedTexture3D: mtex = &((
struct X3D_ComposedTexture3D*)appearance->texture)->texture;
break;
704 for(k=0;k<mtex->n;k++){
711 channels = max(channels,tti->channels);
712 imgalpha = max(tti->hasAlpha,imgalpha);
717 }
else if(appearance->texture->_nodeType == NODE_ComposedCubeMapTexture){
736 channels = max(channels,tti->channels);
737 imgalpha = max(tti->hasAlpha,imgalpha);
749 channels = tti->channels;
750 imgalpha = tti->hasAlpha;
757 channels = haveTexture ? channels : 0;
765void update_effect_uniforms();
767void textureTransform_start();
769void resend_textureprojector_matrix();
771void child_Shape (
struct X3D_Shape *node) {
779 {0.0f, 0.0f, 0.0f, 1.0f},
780 {0.0f, 0.0f, 0.0f, 1.0f},
781 {0.8f, 0.8f, 0.8f, 1.0f},
782 {0.0f, 0.0f, 0.0f, 1.0f},
791 if(!(node->geometry)) {
return; }
795 if((renderstate()->render_collision) || (renderstate()->render_sensitive)) {
797 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node *,node->geometry,tmpNG);
805 tg->RenderFuncs.last_texture_type = NOTEXTURE;
806 tg->RenderFuncs.shapenode = node;
809 memcpy (&p->appearanceProperties.fw_FrontMaterial, &defaultMaterials, sizeof (
struct fw_MaterialParameters));
810 memcpy (&p->appearanceProperties.fw_BackMaterial, &defaultMaterials, sizeof (
struct fw_MaterialParameters));
812 if((renderstate()->render_cube) && hasGeneratedCubeMapTexture((
struct X3D_Appearance*)node->appearance))
816 if (renderstate()->render_blend == (node->_renderFlags & VF_Blend)) {
824 RENDER_MATERIAL_SUBNODES(node->appearance);
828 if (p->material_oneSided != NULL) {
829 memcpy (&p->appearanceProperties.fw_FrontMaterial, p->material_oneSided->_verifiedColor.p, sizeof (
struct fw_MaterialParameters));
830 memcpy (&p->appearanceProperties.fw_BackMaterial, p->material_oneSided->_verifiedColor.p, sizeof (
struct fw_MaterialParameters));
832 memcpy(p->appearanceProperties.emissionColour,p->material_oneSided->_verifiedColor.p, 3*
sizeof(
float));
834 }
else if (p->material_twoSided != NULL) {
835 memcpy (&p->appearanceProperties.fw_FrontMaterial, p->material_twoSided->_verifiedFrontColor.p, sizeof (
struct fw_MaterialParameters));
836 memcpy (&p->appearanceProperties.fw_BackMaterial, p->material_twoSided->_verifiedBackColor.p, sizeof (
struct fw_MaterialParameters));
838 memcpy(p->appearanceProperties.emissionColour,p->material_twoSided->_verifiedFrontColor.p, 3*
sizeof(
float));
846 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node *, node->geometry,tmpNG);
848 shader_requirements.base = node->_shaderflags_base;
849 shader_requirements.effects = node->_shaderflags_effects;
850 shader_requirements.usershaders = node->_shaderflags_usershaders;
851 isUserShader = shader_requirements.usershaders ? TRUE : FALSE;
882 int modulation = p->modulation;
883 channels = getImageChannelCountFromTTI(node->appearance);
886 shader_requirements.base |= MAT_FIRST;
888 if(shader_requirements.base & COLOUR_MATERIAL_SHADER){
893 shader_requirements.base |= CPV_REPLACE_PRIOR;
896 if(channels && (channels == 3 || channels == 4) && modulation < 2)
897 shader_requirements.base |= TEXTURE_REPLACE_PRIOR;
900 if(channels && (channels == 2 || channels == 4) && modulation == 0)
901 shader_requirements.base |= TEXALPHA_REPLACE_PRIOR;
907 shader_requirements.base |= getShaderFlags().base;
908 shader_requirements.effects |= getShaderFlags().effects;
913 scap = getMyShaders(shader_requirements);
914 enableGlobalShader(scap);
918 if (tmpNG && tmpNG->_intern) {
919 if (tmpNG->_intern->tcoordtype == NODE_TextureCoordinateGenerator) {
920 getAppearanceProperties()->texCoordGeneratorType = tmpNG->_intern->texgentype;
926 if(isUserShader && p->userShaderNode){
930 switch (p->userShaderNode->_nodeType) {
931 case NODE_ComposedShader:
932 if (X3D_COMPOSEDSHADER(p->userShaderNode)->isValid) {
933 if (!X3D_COMPOSEDSHADER(p->userShaderNode)->_initialized) {
934 sendInitialFieldsToShader(p->userShaderNode);
938 case NODE_ProgramShader:
939 if (X3D_PROGRAMSHADER(p->userShaderNode)->isValid) {
940 if (!X3D_PROGRAMSHADER(p->userShaderNode)->_initialized) {
941 sendInitialFieldsToShader(p->userShaderNode);
946 case NODE_PackagedShader:
947 if (X3D_PACKAGEDSHADER(p->userShaderNode)->isValid) {
948 if (!X3D_PACKAGEDSHADER(p->userShaderNode)->_initialized) {
949 sendInitialFieldsToShader(p->userShaderNode);
957 if(shader_requirements.effects){
958 update_effect_uniforms();
962 #ifdef SHAPEOCCLUSION
978 resend_textureprojector_matrix();
979 textureTransform_start();
985 FW_GL_BINDBUFFER(GL_ARRAY_BUFFER, 0);
986 FW_GL_BINDBUFFER(GL_ELEMENT_ARRAY_BUFFER, 0);
987 textureTransform_end();
989 #ifdef SHAPEOCCLUSION
994 if(node->appearance){
996 POSSIBLE_PROTO_EXPANSION(
struct X3D_Appearance *,node->appearance,tmpA);
998 fin_sibAffectors(X3D_NODE(tmpA),&tmpA->effects);
1006 finishedWithGlobalShader();
1007 p->material_twoSided = NULL;
1008 p->material_oneSided = NULL;
1009 p->userShaderNode = NULL;
1010 tg->RenderFuncs.shapenode = NULL;
1015 if (p->this_textureTransform) {
1016 p->this_textureTransform = NULL;
1017 FW_GL_MATRIX_MODE(GL_TEXTURE);
1018 FW_GL_LOAD_IDENTITY();
1019 FW_GL_MATRIX_MODE(GL_MODELVIEW);
1024 float gl_linewidth = tg->Mainloop.gl_linewidth;
1025 glLineWidth(gl_linewidth);
1026 p->appearanceProperties.pointSize = gl_linewidth;
1036void compile_Shape (
struct X3D_Shape *node) {
1037 int whichAppearanceShader = 0;
1038 int whichShapeColorShader = 0;
1039 int whichShapeFogShader = 0;
1040 bool isUnlitGeometry =
false;
1041 int hasTextureCoordinateGenerator = 0;
1042 int whichUnlitGeometry = 0;
1046 int userDefinedShader = 0;
1053 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node *, node->geometry,tmpG);
1054 whichShapeColorShader = getShapeColourShader(tmpG);
1055 whichShapeFogShader = getShapeFogShader(tmpG);
1057 isUnlitGeometry = getIfLinePoints(tmpG);
1058 hasTextureCoordinateGenerator = getShapeTextureCoordGen(tmpG);
1060 POSSIBLE_PROTO_EXPANSION(
struct X3D_Node *, node->appearance,tmpN);
1064 userDefinedShader = hasUserDefinedShader(tmpN);
1069 whichUnlitGeometry = HAVE_LINEPOINTS_COLOR;
1070 whichAppearanceShader = getAppearanceShader(tmpN);
1074 node->_shaderflags_base = (whichShapeColorShader | whichShapeFogShader | whichAppearanceShader |
1075 hasTextureCoordinateGenerator | whichUnlitGeometry );
1076 node->_shaderflags_usershaders = userDefinedShader;
1077 node->_shaderflags_effects = 0;
1083 if (node->_shaderflags_base == NOTHING)
1084 node->_shaderflags_base = NO_APPEARANCE_SHADER;
1098 if (node->ambientIntensity < 0.0) node->ambientIntensity=0.0f;
1099 if (node->ambientIntensity > 1.0) node->ambientIntensity=1.0f;
1100 if (node->shininess < 0.0) node->shininess=0.0f;
1101 if (node->shininess > 1.0) node->shininess=1.0f;
1102 if (node->transparency < 0.0) node->transparency=MIN_NODE_TRANSPARENCY;
1103 if (node->transparency >= 1.0) node->transparency=MAX_NODE_TRANSPARENCY;
1105 if (node->backAmbientIntensity < 0.0) node->backAmbientIntensity=0.0f;
1106 if (node->backAmbientIntensity > 1.0) node->backAmbientIntensity=1.0f;
1107 if (node->backShininess < 0.0) node->backShininess=0.0f;
1108 if (node->backShininess > 1.0) node->backShininess=1.0f;
1109 if (node->backTransparency < 0.0) node->backTransparency=0.0f;
1110 if (node->backTransparency > 1.0) node->backTransparency=1.0f;
1112 for (i=0; i<3; i++) {
1113 if (node->diffuseColor.c[i] < 0.0) node->diffuseColor.c[i]=0.0f;
1114 if (node->diffuseColor.c[i] > 1.0) node->diffuseColor.c[i]=1.0f;
1115 if (node->emissiveColor.c[i] < 0.0) node->emissiveColor.c[i]=0.0f;
1116 if (node->emissiveColor.c[i] > 1.0) node->emissiveColor.c[i]=1.0f;
1117 if (node->specularColor.c[i] < 0.0) node->specularColor.c[i]=0.0f;
1118 if (node->specularColor.c[i] > 1.0) node->specularColor.c[i]=1.0f;
1120 if (node->backDiffuseColor.c[i] < 0.0) node->backDiffuseColor.c[i]=0.0f;
1121 if (node->backDiffuseColor.c[i] > 1.0) node->backDiffuseColor.c[i]=1.0f;
1122 if (node->backEmissiveColor.c[i] < 0.0) node->backEmissiveColor.c[i]=0.0f;
1123 if (node->backEmissiveColor.c[i] > 1.0) node->backEmissiveColor.c[i]=1.0f;
1124 if (node->backSpecularColor.c[i] < 0.0) node->backSpecularColor.c[i]=0.0f;
1125 if (node->backSpecularColor.c[i] > 1.0) node->backSpecularColor.c[i]=1.0f;
1129 trans = 1.0f - node->transparency;
1130 node->_verifiedFrontColor.p[3] = trans;
1131 node->_verifiedFrontColor.p[7] = trans;
1132 node->_verifiedFrontColor.p[11] = trans;
1133 node->_verifiedFrontColor.p[15] = trans;
1134 trans = 1.0f - node->backTransparency;
1135 node->_verifiedBackColor.p[3] = trans;
1136 node->_verifiedBackColor.p[7] = trans;
1137 node->_verifiedBackColor.p[11] = trans;
1138 node->_verifiedBackColor.p[15] = trans;
1142 memcpy((
void *)(&node->_verifiedFrontColor.p[8]), node->diffuseColor.c, sizeof (
float) * 3);
1145 for(i=0; i<4; i++) { node->_verifiedFrontColor.p[i+4] = node->_verifiedFrontColor.p[i+8] * node->ambientIntensity; }
1148 memcpy((
void *)(&node->_verifiedFrontColor.p[12]), node->specularColor.c, sizeof (
float) * 3);
1151 memcpy((
void *)(&node->_verifiedFrontColor.p[0]), node->emissiveColor.c, sizeof (
float) * 3);
1154 node->_verifiedFrontColor.p[16] = node->shininess * 128.0f;
1156#define MAX_SHIN 128.0f
1157#define MIN_SHIN 0.01f
1158 if ((node->_verifiedFrontColor.p[16] > MAX_SHIN) || (node->_verifiedFrontColor.p[16] < MIN_SHIN)) {
1159 if (node->_verifiedFrontColor.p[16]>MAX_SHIN){node->_verifiedFrontColor.p[16] = MAX_SHIN;}
else{node->_verifiedFrontColor.p[16]=MIN_SHIN;}
1164 if (node->separateBackColor) {
1167 memcpy((
void *)(&node->_verifiedBackColor.p[8]), node->backDiffuseColor.c, sizeof (
float) * 3);
1170 for(i=0; i<3; i++) { node->_verifiedBackColor.p[i+4] = node->_verifiedBackColor.p[i+8] * node->ambientIntensity; }
1173 memcpy((
void *)(&node->_verifiedBackColor.p[12]), node->backSpecularColor.c, sizeof (
float) * 3);
1176 memcpy((
void *)(&node->_verifiedBackColor.p[0]), node->backEmissiveColor.c, sizeof (
float) * 3);
1179 node->_verifiedBackColor.p[16] = node->shininess * 128.0f;
1181#define MAX_SHIN 128.0f
1182#define MIN_SHIN 0.01f
1183 if ((node->_verifiedBackColor.p[16] > MAX_SHIN) || (node->_verifiedBackColor.p[16] < MIN_SHIN)) {
1184 if (node->_verifiedBackColor.p[16]>MAX_SHIN){node->_verifiedBackColor.p[16] = MAX_SHIN;}
else{node->_verifiedBackColor.p[16]=MIN_SHIN;}
1191 memcpy(node->_verifiedBackColor.p, node->_verifiedFrontColor.p, sizeof (
float) * 17);
1205 p->material_twoSided = node;