TextureCoordinateNode *SceneGraph::findTextureCoordinateNode(char *name) {
if (!name || strlen(name) <= 0)
return NULL;
for (TextureCoordinateNode *node = findTextureCoordinateNode(); node; node = node->nextTraversal()) {
const char *nodeName = node->getName();
if (nodeName && strlen(nodeName)) {
if (!strcmp(name, nodeName))
return node;
}
}
return NULL;
}
bool IndexedFaceSetNode::generateTextureCoordinate()
{
TextureCoordinateNode *texCoord = getTextureCoordinateNodes();
if (texCoord)
return false;
CoordinateNode *coordinateNode = getCoordinateNodes();
if (!coordinateNode)
return false;
texCoord = new TextureCoordinateNode();
int nPolygon = getNPolygons();
if (nPolygon <= 0)
return false;
float (*normal)[3] = new float[nPolygon][3];
SFVec3f *center = new SFVec3f[nPolygon];
SFVec3f *maxExtents = new SFVec3f[nPolygon];
SFVec3f *minExtents = new SFVec3f[nPolygon];
bool bPolygonBegin;
int polyn;
float point[3][3];
float coord[3];
int vertexn = 0;
int n;
bPolygonBegin = true;
polyn = 0;
/*
int nColorIndexes = idxFaceSet->getNColorIndexes();
int nNormalIndexes = idxFaceSet->getNNormalIndexes();
int nTexCoordIndexes = idxFaceSet->getNTexCoordIndexes();
*/
int nCoordIndexes = getNCoordIndexes();
for (n=0; n<nCoordIndexes; n++) {
int coordIndex = getCoordIndex(n);
if (coordIndex != -1) {
if (vertexn < 3)
coordinateNode->getPoint(coordIndex, point[vertexn]);
float point[3];
coordinateNode->getPoint(coordIndex, point);
if (bPolygonBegin) {
maxExtents[polyn].setValue(point);
minExtents[polyn].setValue(point);
center[polyn].setValue(point);
bPolygonBegin = false;
}
else {
SetExtents(maxExtents[polyn], minExtents[polyn], point);
center[polyn].add(point);
}
vertexn++;
}
else {
GetNormalFromVertices(point, normal[polyn]);
center[polyn].scale(1.0f / (float)vertexn);
maxExtents[polyn].sub(center[polyn]);
minExtents[polyn].sub(center[polyn]);
vertexn = 0;
bPolygonBegin = true;
polyn++;
}
}
float minx, miny, maxx, maxy, xlength, ylength;
SFMatrix matrix;
bPolygonBegin = true;
polyn = 0;
for (n=0; n<nCoordIndexes; n++) {
int coordIndex = getCoordIndex(n);
if (coordIndex != -1) {
if (bPolygonBegin) {
GetRotateMatrixFromNormal(normal[polyn], matrix);
matrix.multi(&minExtents[polyn]);
matrix.multi(&maxExtents[polyn]);
minx = minExtents[polyn].getX();
miny = minExtents[polyn].getY();
maxx = maxExtents[polyn].getX();
maxy = maxExtents[polyn].getY();
xlength = (float)fabs(maxExtents[polyn].getX() - minExtents[polyn].getX());
ylength = (float)fabs(maxExtents[polyn].getY() - minExtents[polyn].getY());
if (xlength == 0.0f || ylength == 0.0f) {
delete texCoord;
delete []minExtents;
delete []maxExtents;
delete []center;
delete []normal;
return false;
}
bPolygonBegin = false;
}
coordinateNode->getPoint(coordIndex, coord);
coord[0] -= center[polyn].getX();
coord[1] -= center[polyn].getY();
coord[2] -= center[polyn].getZ();
matrix.multi(coord);
coord[0] = (float)fabs(coord[0] - minx) / xlength;
coord[1] = (float)fabs(coord[1] - miny) / ylength;
texCoord->addPoint(coord);
}
else {
// coord[0] = coord[1] = 0.0f;
// texCoord->addPoint(coord);
bPolygonBegin = true;
polyn++;
}
}
addChildNode(texCoord);
delete []minExtents;
delete []maxExtents;
delete []center;
delete []normal;
return true;
}
static void DrawIdxFaceSet(IndexedFaceSetNode *idxFaceSet)
{
CoordinateNode *coordinateNode = idxFaceSet->getCoordinateNodes();
if (!coordinateNode)
return;
TextureCoordinateNode *texCoordNode = idxFaceSet->getTextureCoordinateNodes();
NormalNode *normalNode = idxFaceSet->getNormalNodes();
ColorNode *colorNode = idxFaceSet->getColorNodes();
bool colorPerVertex =idxFaceSet->getColorPerVertex();
bool normalPerVertex =idxFaceSet->getNormalPerVertex();
bool ccw = idxFaceSet->getCCW();
if (ccw == true)
glFrontFace(GL_CCW);
else
glFrontFace(GL_CW);
bool solid = idxFaceSet->getSolid();
if (solid == false)
glDisable(GL_CULL_FACE);
else
glEnable(GL_CULL_FACE);
bool convex = idxFaceSet->getConvex();
GLUtriangulatorObj *tessObj = NULL;
if (convex == false) {
tessObj = gluNewTess();
gluTessCallback(tessObj, GLU_BEGIN, (GLUtessCallBackFunc)glBegin);
gluTessCallback(tessObj, GLU_VERTEX, (GLUtessCallBackFunc)glVertex3dv);
gluTessCallback(tessObj, GLU_END, (GLUtessCallBackFunc)glEnd);
}
bool bPolygonBegin = true;
bool bPolygonClose = true;
int nPolygon = 0;
int nVertex = 0;
float point[3];
float vector[3];
float color[4]; color[3] = 1.0f;
float coord[2];
double (*tessPoint)[3];
if ((idxFaceSet->getColorPerVertex() && idxFaceSet->getColorNodes()) || (idxFaceSet->getNormalPerVertex() && idxFaceSet->getNormalNodes()))
glShadeModel (GL_SMOOTH);
else
glShadeModel (GL_FLAT);
int nColorIndexes = idxFaceSet->getNColorIndexes();
int nNormalIndexes = idxFaceSet->getNNormalIndexes();
int nTexCoordIndexes = idxFaceSet->getNTexCoordIndexes();
int nCoordIndexes = idxFaceSet->getNCoordIndexes();
for (int nCoordIndex=0; nCoordIndex<nCoordIndexes; nCoordIndex++) {
int coordIndex = idxFaceSet->getCoordIndex(nCoordIndex);
if (bPolygonBegin) {
if (convex == false)
gluBeginPolygon(tessObj);
else
glBegin(GL_POLYGON);
bPolygonBegin = false;
bPolygonClose = false;
int nVertices = 0;
int index = coordIndex;
while (index != -1) {
nVertices++;
int nIndex = nCoordIndex + nVertices;
if (nIndex < nCoordIndexes)
index = idxFaceSet->getCoordIndex(nIndex);
else
break;
}
if (convex == false)
tessPoint = new double[nVertices][3];
// dafault color
//glColor3f(1.0f, 1.0f, 1.0f);
// default normal
if ((nCoordIndex + 2) < nCoordIndexes) {
float point[3][3];
float normal[3];
for (int n=0; n<3; n++) {
int index = idxFaceSet->getCoordIndex(nCoordIndex+n);
coordinateNode->getPoint(index, point[n]);
}
GetNormalFromVertices(point, normal);
glNormal3fv(normal);
}
else
glNormal3f(0.0f, 0.0f, 1.0f);
if (colorNode && !colorPerVertex) {
if (0 < nColorIndexes)
colorNode->getColor(idxFaceSet->getColorIndex(nPolygon), color);
else
colorNode->getColor(nPolygon, color);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
// glColor3fv(color);
}
if (normalNode && !normalPerVertex) {
if (0 < nNormalIndexes)
normalNode->getVector(idxFaceSet->getNormalIndex(nPolygon), vector);
else
normalNode->getVector(nPolygon, vector);
glNormal3fv(vector);
}
nPolygon++;
nVertex = 0;
}
if (coordIndex != -1) {
if (colorNode && colorPerVertex) {
if (0 < nColorIndexes)
colorNode->getColor(idxFaceSet->getColorIndex(nCoordIndex), color);
else
colorNode->getColor(coordIndex, color);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
// glColor3fv(color);
}
if (normalNode && normalPerVertex) {
if (0 < nNormalIndexes)
normalNode->getVector(idxFaceSet->getNormalIndex(nCoordIndex), vector);
else
normalNode->getVector(coordIndex, vector);
glNormal3fv(vector);
}
if (texCoordNode) {
if (0 < nTexCoordIndexes)
texCoordNode->getPoint(idxFaceSet->getTexCoordIndex(nCoordIndex), coord);
else
texCoordNode->getPoint(coordIndex, coord);
coord[1] = 1.0f - coord[1];
glTexCoord2fv(coord);
}
coordinateNode->getPoint(coordIndex, point);
if (convex == false) {
tessPoint[nVertex][0] = point[0];
tessPoint[nVertex][1] = point[1];
tessPoint[nVertex][2] = point[2];
gluTessVertex(tessObj, tessPoint[nVertex], tessPoint[nVertex]);
}
else
glVertex3fv(point);
nVertex++;
}
else {
if (convex == false) {
gluEndPolygon(tessObj);
delete[] tessPoint;
}
else
glEnd();
bPolygonBegin = true;
bPolygonClose = true;
}
}
if (bPolygonClose == false) {
if (convex == false) {
gluEndPolygon(tessObj);
delete[] tessPoint;
}
else
glEnd();
}
if (ccw == false)
glFrontFace(GL_CCW);
if (solid == false)
glEnable(GL_CULL_FACE);
if (convex == false)
gluDeleteTess(tessObj);
glShadeModel(GL_SMOOTH);
}
static void DrawElevationGrid(ElevationGridNode *eg)
{
int xDimension = eg->getXDimension();
int zDimension = eg->getZDimension();
int nPoints = xDimension * zDimension;
float xSpacing = eg->getXSpacing();
float zSpacing = eg->getZSpacing();
int x, z;
SFVec3f *point = new SFVec3f[nPoints];
for (x=0; x<xDimension; x++) {
for (z=0; z<zDimension; z++) {
float xpos = xSpacing * x;
float ypos = eg->getHeight(x + z*zDimension);
float zpos = zSpacing * z;
point[x + z*xDimension].setValue(xpos, ypos, zpos);
}
}
ColorNode *color = eg->getColorNodes();
NormalNode *normal = eg->getNormalNodes();
TextureCoordinateNode *texCoord = eg->getTextureCoordinateNodes();
bool bColorPerVertex = eg->getColorPerVertex();
bool bNormalPerVertex = eg->getNormalPerVertex();
bool ccw = eg->getCCW();
if (ccw == true)
glFrontFace(GL_CCW);
else
glFrontFace(GL_CW);
bool solid = eg->getSolid();
if (solid == false)
glDisable(GL_CULL_FACE);
else
glEnable(GL_CULL_FACE);
glNormal3f(0.0f, 1.0f, 0.0f);
for (x=0; x<xDimension-1; x++) {
for (z=0; z<zDimension-1; z++) {
int n;
if (bColorPerVertex == false && color) {
float egColor[4]; egColor[3] = 1.0f;
color->getColor(x + z*zDimension, egColor);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, egColor);
// glColor3fv(egColor);
}
if (bNormalPerVertex == false && normal) {
float egNormal[3];
normal->getVector(x + z*zDimension, egNormal);
glNormal3fv(egNormal);
}
float egPoint[4][3];
float egColor[4][4];
float egNormal[4][3];
float egTexCoord[4][2];
egColor[0][3] = egColor[1][3] = egColor[2][3] = egColor[3][3] = 1.0f;
for (n=0; n<4; n++) {
int xIndex = x + ((n < 2) ? 0 : 1);
int zIndex = z + (n%2);
int index = xIndex + zIndex*xDimension;
if (bColorPerVertex == true && color)
color->getColor(index, egColor[n]);
if (bNormalPerVertex == true && normal)
normal->getVector(index, egNormal[n]);
if (texCoord)
texCoord->getPoint(index, egTexCoord[n]);
else {
egTexCoord[n][0] = (float)xIndex / (float)(xDimension-1);
egTexCoord[n][1] = (float)zIndex / (float)(zDimension-1);
}
point[index].getValue(egPoint[n]);
}
glBegin(GL_POLYGON);
// Tanks for Joerg Scheurich aka MUFTI
if (!normal) {
float point[3][3];
float normal[3];
for (n=0; n<3; n++)
memcpy(point[n] , egPoint[n], sizeof(float)*3);
GetNormalFromVertices(point, normal);
glNormal3fv(normal);
}
for (n=0; n<3; n++) {
if (bColorPerVertex == true && color) {
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, egColor[n]);
// glColor3fv(egColor);
}
if (bNormalPerVertex == true && normal)
glNormal3fv(egNormal[n]);
glTexCoord2fv(egTexCoord[n]);
glVertex3fv(egPoint[n]);
}
glEnd();
glBegin(GL_POLYGON);
// Tanks for Joerg Scheurich aka MUFTI
if (!normal) {
float point[3][3];
float normal[3];
for (n=3; 0<n; n--)
memcpy(point[3-n] , egPoint[n], sizeof(float)*3);
GetNormalFromVertices(point, normal);
glNormal3fv(normal);
}
for (n=3; 0<n; n--) {
if (bColorPerVertex == true && color) {
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, egColor[n]);
// glColor3fv(egColor);
}
if (bNormalPerVertex == true && normal)
glNormal3fv(egNormal[n]);
glTexCoord2fv(egTexCoord[n]);
glVertex3fv(egPoint[n]);
}
glEnd();
}
}
if (ccw == false)
glFrontFace(GL_CCW);
if (solid == false)
glEnable(GL_CULL_FACE);
delete []point;
}
