OSG::NodePtr makePolygon(double pntData[][3], int numPoints) {
OSG::GeometryPtr geoPtr = OSG::Geometry::create();
OSG::NodePtr nodePtr = OSG::Node::create();
GeoPositions3fPtr pnts = GeoPositions3f::create();
GeoNormals3fPtr norms = GeoNormals3f::create();
GeoTexCoords2fPtr tex = GeoTexCoords2f::create();
GeoIndicesUI32Ptr indices = GeoIndicesUI32::create();
GeoPLengthsUI32Ptr lens = GeoPLengthsUI32::create();
GeoPTypesUI8Ptr types = GeoPTypesUI8::create();
//Set up the properties according to the geometry defined above
beginEditCP(pnts);
beginEditCP(norms);
for(int i = 0; i < numPoints; i++)
{
pnts->push_back(Pnt3f(pntData[i][0],
pntData[i][1],
pntData[i][2]));
indices->push_back(2*i);
norms->push_back(Vec3f(0.0, 0.0, pntData[i][2]));
indices->push_back(2*i + 1);
}
endEditCP(pnts);
endEditCP(norms);
beginEditCP(types);
beginEditCP(lens);
types->push_back(GL_POLYGON);
lens->push_back(numPoints);
endEditCP(types);
endEditCP(lens);
beginEditCP(geoPtr);
geoPtr->setMaterial(getDefaultMaterial());
geoPtr->setPositions(pnts);
geoPtr->setNormals(norms);
geoPtr->setIndices(indices);
geoPtr->editMFIndexMapping()->push_back(Geometry::MapPosition |
Geometry::MapNormal);
geoPtr->setTypes(types);
geoPtr->setLengths(lens);
endEditCP(geoPtr);
nodePtr->setCore(geoPtr);
return nodePtr;
}
GeometryPtr createGeo(UInt32 mat)
{
GeoIndicesPtr ind = _ind[mat];
FDEBUG(("CreateGeoRec::createGeo: Mat %d: %d inds (%d tris)\n",
mat, ind->getSize(), ind->getSize()/3));
endEditCP(ind);
GeometryPtr geo = Geometry::create();
GeoPLengthsUI32Ptr len = GeoPLengthsUI32::create();
beginEditCP(len);
len->push_back(ind->getSize());
endEditCP(len);
GeoPTypesUI8Ptr typ = GeoPTypesUI8::create();
beginEditCP(typ);
typ->push_back(GL_TRIANGLES);
endEditCP(typ);
beginEditCP(geo);
if(random_color)
{
SimpleMaterialPtr mat = SimpleMaterial::create();
beginEditCP(mat);
Color3f c( drand48() * .7f + .3f,
drand48() * .7f + .3f,
drand48() * .7f + .3f);
mat->setDiffuse(c);
mat->setSpecular(Color3f(1.f,1.f,1.f));
mat->setShininess(10.f);
endEditCP(mat);
geo->setMaterial(mat);
}
else
{
geo->setMaterial(MaterialPool::getMaterial(mat));
}
geo->setPositions(_pos);
geo->setIndices(ind);
geo->setLengths(len);
geo->setTypes(typ);
geo->getIndexMapping().push_back(Geometry::MapPosition);
endEditCP(geo);
calcVertexNormals(geo);
//calcFaceNormals(geo);
createSingleIndex(geo);
return geo;
}
// Create the coordinate cross
NodePtr createCoordinateCross()
{
GeometryPtr geoPtr = Geometry::create();
beginEditCP(geoPtr);
{
GeoPTypesUI8Ptr typesPtr = GeoPTypesUI8::create();
typesPtr->push_back(GL_LINES);
geoPtr->setTypes(typesPtr);
GeoPLengthsUI32Ptr lensPtr = GeoPLengthsUI32::create();
lensPtr->push_back(6);
geoPtr->setLengths(lensPtr);
GeoPositions3fPtr posPtr = GeoPositions3f::create();
posPtr->push_back(Vec3f(-0.1f, 0.f, 0.f));
posPtr->push_back(Vec3f(1.f, 0.f, 0.f));
posPtr->push_back(Vec3f(0.f, -0.1f, 0.f));
posPtr->push_back(Vec3f(0.f, 1.f, 0.f));
posPtr->push_back(Vec3f(0.f, 0.f, -0.1f));
posPtr->push_back(Vec3f(0.f, 0.f, 1.f));
geoPtr->setPositions(posPtr);
GeoColors3fPtr colorsPtr = GeoColors3f::create();
colorsPtr->push_back(Color3f(1.f, 0.f, 0.f));
colorsPtr->push_back(Color3f(0.f, 1.f, 0.f));
colorsPtr->push_back(Color3f(0.f, 0.f, 1.f));
geoPtr->setColors(colorsPtr);
GeoIndicesUI32Ptr indicesPtr = GeoIndicesUI32::create();
// X Axis
indicesPtr->push_back(0);
indicesPtr->push_back(0);
indicesPtr->push_back(1);
indicesPtr->push_back(0);
// Y Axis
indicesPtr->push_back(2);
indicesPtr->push_back(1);
indicesPtr->push_back(3);
indicesPtr->push_back(1);
// Z Axis
indicesPtr->push_back(4);
indicesPtr->push_back(2);
indicesPtr->push_back(5);
indicesPtr->push_back(2);
geoPtr->setIndices(indicesPtr);
geoPtr->editMFIndexMapping()->clear();
geoPtr->editMFIndexMapping()->push_back(Geometry::MapPosition);
geoPtr->editMFIndexMapping()->push_back(Geometry::MapColor);
SimpleMaterialPtr matPtr = SimpleMaterial::create();
geoPtr->setMaterial(matPtr);
}
endEditCP(geoPtr);
NodePtr nodePtr = Node::create();
beginEditCP(nodePtr, Node::CoreFieldMask);
{
nodePtr->setCore(geoPtr);
}
endEditCP(nodePtr, Node::CoreFieldMask);
return nodePtr;
}
// Create the metrics
NodePtr createMetrics(TextFace *face, Real32 scale, const TextLayoutParam &layoutParam,
const TextLayoutResult &layoutResult)
{
GeometryPtr geoPtr = Geometry::create();
beginEditCP(geoPtr);
{
GeoPTypesUI8Ptr typesPtr = GeoPTypesUI8::create();
geoPtr->setTypes(typesPtr);
GeoPLengthsUI32Ptr lensPtr = GeoPLengthsUI32::create();
geoPtr->setLengths(lensPtr);
GeoPositions3fPtr posPtr = GeoPositions3f::create();
geoPtr->setPositions(posPtr);
GeoColors3fPtr colorsPtr = GeoColors3f::create();
colorsPtr->push_back(Color3f(0.f, 0.f, 1.f));
colorsPtr->push_back(Color3f(1.f, 0.f, 0.f));
colorsPtr->push_back(Color3f(0.f, 1.f, 0.f));
colorsPtr->push_back(Color3f(1.f, 1.f, 0.f));
geoPtr->setColors(colorsPtr);
GeoIndicesUI32Ptr indicesPtr = GeoIndicesUI32::create();
geoPtr->setIndices(indicesPtr);
UInt32 i, numGlyphs = layoutResult.getNumGlyphs();
for (i = 0; i < numGlyphs; ++i)
{
const TextGlyph &glyph = face->getGlyph(layoutResult.indices[i]);
typesPtr->push_back(GL_LINE_LOOP);
lensPtr->push_back(4);
const Vec2f &pos = layoutResult.positions[i];
Real32 left = pos.x() * scale;
Real32 right = (pos.x() + glyph.getWidth()) * scale;
Real32 top = pos.y() * scale;
Real32 bottom = (pos.y() - glyph.getHeight()) * scale;
UInt32 posOffset = posPtr->size();
posPtr->push_back(Vec3f(left, bottom, 0.f));
posPtr->push_back(Vec3f(right, bottom, 0.f));
posPtr->push_back(Vec3f(right, top, 0.f));
posPtr->push_back(Vec3f(left, top, 0.f));
indicesPtr->push_back(posOffset);
indicesPtr->push_back(0);
indicesPtr->push_back(posOffset + 1);
indicesPtr->push_back(0);
indicesPtr->push_back(posOffset + 2);
indicesPtr->push_back(0);
indicesPtr->push_back(posOffset + 3);
indicesPtr->push_back(0);
}
// Bounding box
Vec2f lowerLeft, upperRight;
face->calculateBoundingBox(layoutResult, lowerLeft, upperRight);
typesPtr->push_back(GL_LINE_LOOP);
lensPtr->push_back(4);
Real32 left = lowerLeft.x() * scale;
Real32 right = upperRight.x() * scale;
Real32 top = upperRight.y() * scale;
Real32 bottom = lowerLeft.y() * scale;
UInt32 posOffset = posPtr->size();
posPtr->push_back(Vec3f(left, bottom, 0.f));
posPtr->push_back(Vec3f(right, bottom, 0.f));
posPtr->push_back(Vec3f(right, top, 0.f));
posPtr->push_back(Vec3f(left, top, 0.f));
indicesPtr->push_back(posOffset);
indicesPtr->push_back(1);
indicesPtr->push_back(posOffset + 1);
indicesPtr->push_back(1);
indicesPtr->push_back(posOffset + 2);
indicesPtr->push_back(1);
indicesPtr->push_back(posOffset + 3);
indicesPtr->push_back(1);
// Text bounds & Line bounds
Vec2f pos, textPos, offset;
if (layoutParam.horizontal == true)
{
Real32 lineHeight = face->getHoriAscent() - face->getHoriDescent();
Real32 spacing = layoutParam.spacing * lineHeight;
if (layoutParam.topToBottom == true)
{
switch (layoutParam.minorAlignment)
{
case TextLayoutParam::ALIGN_BEGIN:
break;
case TextLayoutParam::ALIGN_FIRST:
pos[1] = textPos[1] = face->getHoriAscent();
break;
case TextLayoutParam::ALIGN_MIDDLE:
pos[1] = textPos[1] = (spacing * (layoutResult.lineBounds.size() - 1) + lineHeight) / 2.f;
break;
case TextLayoutParam::ALIGN_END:
pos[1] = textPos[1] = spacing * (layoutResult.lineBounds.size() - 1) + lineHeight;
break;
}
offset.setValues(0.f, -spacing);
}
else
{
switch (layoutParam.minorAlignment)
{
case TextLayoutParam::ALIGN_BEGIN:
pos[1] = lineHeight;
textPos[1] = spacing * (layoutResult.lineBounds.size() - 1) + lineHeight;
break;
case TextLayoutParam::ALIGN_FIRST:
pos[1] = face->getHoriAscent();
textPos[1] = spacing * (layoutResult.lineBounds.size() - 1) + face->getHoriAscent();
break;
case TextLayoutParam::ALIGN_MIDDLE:
pos[1] = -(spacing * (layoutResult.lineBounds.size() - 1) + lineHeight) / 2.f + lineHeight;
textPos[1] = (spacing * (layoutResult.lineBounds.size() - 1) + lineHeight) / 2.f;
break;
case TextLayoutParam::ALIGN_END:
pos[1] = -spacing * (layoutResult.lineBounds.size() - 1);
break;
}
offset.setValues(0.f, spacing);
}
}
else
{
Real32 lineHeight = face->getVertDescent() - face->getVertAscent();
Real32 spacing = layoutParam.spacing * lineHeight;
if (layoutParam.leftToRight == true)
{
switch (layoutParam.minorAlignment)
{
case TextLayoutParam::ALIGN_BEGIN:
break;
case TextLayoutParam::ALIGN_FIRST:
pos[0] = textPos[0] = face->getVertAscent();
break;
case TextLayoutParam::ALIGN_MIDDLE:
pos[0] = textPos[0] = -(spacing * (layoutResult.lineBounds.size() - 1) + lineHeight) / 2.f;
break;
case TextLayoutParam::ALIGN_END:
pos[0] = textPos[0] = -spacing * (layoutResult.lineBounds.size() - 1) - lineHeight;
break;
}
offset.setValues(spacing, 0.f);
}
else
{
switch (layoutParam.minorAlignment)
{
case TextLayoutParam::ALIGN_BEGIN:
pos[0] = -lineHeight;
textPos[0] = -spacing * (layoutResult.lineBounds.size() - 1) - lineHeight;
break;
case TextLayoutParam::ALIGN_FIRST:
pos[0] = -face->getVertDescent();
textPos[0] = -spacing * (layoutResult.lineBounds.size() - 1) -face->getVertDescent();
break;
case TextLayoutParam::ALIGN_MIDDLE:
pos[0] = (spacing * (layoutResult.lineBounds.size() - 1) + lineHeight) / 2.f - lineHeight;
textPos[0] = -(spacing * (layoutResult.lineBounds.size() - 1) + lineHeight) / 2.f;
break;
case TextLayoutParam::ALIGN_END:
pos[0] = spacing * (layoutResult.lineBounds.size() - 1);
break;
}
offset.setValues(-spacing, 0.f);
}
}
typesPtr->push_back(GL_LINE_LOOP);
lensPtr->push_back(4);
left = textPos.x();
top = textPos.y();
if (layoutParam.horizontal == true)
if (layoutParam.leftToRight == true)
switch (layoutParam.majorAlignment)
{
case TextLayoutParam::ALIGN_BEGIN:
case TextLayoutParam::ALIGN_FIRST:
break;
case TextLayoutParam::ALIGN_MIDDLE:
left -= layoutResult.textBounds.x() / 2.f;
break;
case TextLayoutParam::ALIGN_END:
left -= layoutResult.textBounds.x();
break;
}
else
switch (layoutParam.majorAlignment)
{
case TextLayoutParam::ALIGN_BEGIN:
case TextLayoutParam::ALIGN_FIRST:
left -= layoutResult.textBounds.x();
break;
case TextLayoutParam::ALIGN_MIDDLE:
left -= layoutResult.textBounds.x() / 2.f;
break;
case TextLayoutParam::ALIGN_END:
break;
}
else
if (layoutParam.topToBottom == true)
switch (layoutParam.majorAlignment)
{
case TextLayoutParam::ALIGN_BEGIN:
case TextLayoutParam::ALIGN_FIRST:
break;
case TextLayoutParam::ALIGN_MIDDLE:
top += layoutResult.textBounds.y() / 2.f;
break;
case TextLayoutParam::ALIGN_END:
top += layoutResult.textBounds.y();
break;
}
else
switch (layoutParam.majorAlignment)
{
case TextLayoutParam::ALIGN_BEGIN:
case TextLayoutParam::ALIGN_FIRST:
top += layoutResult.textBounds.y();
break;
case TextLayoutParam::ALIGN_MIDDLE:
top += layoutResult.textBounds.y() / 2.f;
break;
case TextLayoutParam::ALIGN_END:
break;
}
left *= scale;
right = left + layoutResult.textBounds.x() * scale;
top *= scale;
bottom = top - layoutResult.textBounds.y() * scale;
posOffset = posPtr->size();
posPtr->push_back(Vec3f(left, bottom, 0.f));
posPtr->push_back(Vec3f(right, bottom, 0.f));
posPtr->push_back(Vec3f(right, top, 0.f));
posPtr->push_back(Vec3f(left, top, 0.f));
indicesPtr->push_back(posOffset);
indicesPtr->push_back(3);
indicesPtr->push_back(posOffset + 1);
indicesPtr->push_back(3);
indicesPtr->push_back(posOffset + 2);
indicesPtr->push_back(3);
indicesPtr->push_back(posOffset + 3);
indicesPtr->push_back(3);
vector<Vec2f>::const_iterator lbIt;
for (lbIt = layoutResult.lineBounds.begin(); lbIt != layoutResult.lineBounds.end(); ++lbIt)
{
typesPtr->push_back(GL_LINE_LOOP);
lensPtr->push_back(4);
Real32 left = pos.x();
Real32 top = pos.y();
if (layoutParam.horizontal == true)
if (layoutParam.leftToRight == true)
switch (layoutParam.majorAlignment)
{
case TextLayoutParam::ALIGN_BEGIN:
case TextLayoutParam::ALIGN_FIRST:
break;
case TextLayoutParam::ALIGN_MIDDLE:
left -= lbIt->x() / 2.f;
break;
case TextLayoutParam::ALIGN_END:
left -= lbIt->x();
break;
}
else
switch (layoutParam.majorAlignment)
{
case TextLayoutParam::ALIGN_BEGIN:
case TextLayoutParam::ALIGN_FIRST:
left -= lbIt->x();
break;
case TextLayoutParam::ALIGN_MIDDLE:
left -= lbIt->x() / 2.f;
break;
case TextLayoutParam::ALIGN_END:
break;
}
else
if (layoutParam.topToBottom == true)
switch (layoutParam.majorAlignment)
{
case TextLayoutParam::ALIGN_BEGIN:
case TextLayoutParam::ALIGN_FIRST:
break;
case TextLayoutParam::ALIGN_MIDDLE:
top += lbIt->y() / 2.f;
break;
case TextLayoutParam::ALIGN_END:
top += lbIt->y();
break;
}
else
switch (layoutParam.majorAlignment)
{
case TextLayoutParam::ALIGN_BEGIN:
case TextLayoutParam::ALIGN_FIRST:
top += lbIt->y();
break;
case TextLayoutParam::ALIGN_MIDDLE:
top += lbIt->y() / 2.f;
break;
case TextLayoutParam::ALIGN_END:
break;
}
left *= scale;
Real32 right = left + lbIt->x() * scale;
top *= scale;
Real32 bottom = top - lbIt->y() * scale;
UInt32 posOffset = posPtr->size();
posPtr->push_back(Vec3f(left, bottom, 0.f));
posPtr->push_back(Vec3f(right, bottom, 0.f));
posPtr->push_back(Vec3f(right, top, 0.f));
posPtr->push_back(Vec3f(left, top, 0.f));
indicesPtr->push_back(posOffset);
indicesPtr->push_back(2);
indicesPtr->push_back(posOffset + 1);
indicesPtr->push_back(2);
indicesPtr->push_back(posOffset + 2);
indicesPtr->push_back(2);
indicesPtr->push_back(posOffset + 3);
indicesPtr->push_back(2);
typesPtr->push_back(GL_LINE_STRIP);
lensPtr->push_back(2);
posOffset = posPtr->size();
if (layoutParam.horizontal == true)
{
Real32 base = top - face->getHoriAscent() * scale;
posPtr->push_back(Vec3f(left, base, 0.f));
posPtr->push_back(Vec3f(right, base, 0.f));
}
else
{
Real32 base = left - face->getVertAscent() * scale;
posPtr->push_back(Vec3f(base, top, 0.f));
posPtr->push_back(Vec3f(base, bottom, 0.f));
}
indicesPtr->push_back(posOffset);
indicesPtr->push_back(2);
indicesPtr->push_back(posOffset + 1);
indicesPtr->push_back(2);
pos += offset;
}
geoPtr->editMFIndexMapping()->clear();
geoPtr->editMFIndexMapping()->push_back(Geometry::MapPosition);
geoPtr->editMFIndexMapping()->push_back(Geometry::MapColor);
SimpleMaterialPtr matPtr = SimpleMaterial::create();
geoPtr->setMaterial(matPtr);
}
endEditCP(geoPtr);
NodePtr nodePtr = Node::create();
beginEditCP(nodePtr, Node::CoreFieldMask);
{
nodePtr->setCore(geoPtr);
}
endEditCP(nodePtr, Node::CoreFieldMask);
return nodePtr;
}
NodePtr Puck::init()
{
// CREATE THE PUCK
NodePtr puck_trans_node = makeCoredNode<Transform>(&transPtr);
beginEditCP(transPtr);
{
transPtr->getMatrix().setTranslate(position[0],position[1],position[2]);
}
endEditCP(transPtr);
NodePtr puck = OSG::makeCylinder(PUCK_HALF_HEIGHT*2.0,radius, 32, true, true ,true);
beginEditCP(puck_trans_node);
{
puck_trans_node->addChild(puck);
}
endEditCP(puck_trans_node);
SimpleMaterialPtr puck_mat = SimpleMaterial::create();
beginEditCP(puck_mat);
{
puck_mat->setAmbient(Color3f(0.0,0.0,0.0));
puck_mat->setDiffuse(Color3f(1.0,0.0,0.0));
}
endEditCP(puck_mat);
GeometryPtr puck_geo = GeometryPtr::dcast(puck->getCore());
beginEditCP(puck_geo);
puck_geo->setMaterial(puck_mat);
beginEditCP(puck_geo);
/////////////////////////////
// SETUP THE INTERSECTION TEST COMPONENTS
// Create a small geometry to show the ray and what was hit
// Contains a line and a single triangle.
// The line shows the ray, the triangle whatever was hit.
isectPoints = GeoPositions3f::create();
beginEditCP(isectPoints);
{
isectPoints->addValue(Pnt3f(0,0,0));
isectPoints->addValue(Pnt3f(0,0,0));
isectPoints->addValue(Pnt3f(0,0,0));
isectPoints->addValue(Pnt3f(0,0,0));
isectPoints->addValue(Pnt3f(0,0,0));
}
endEditCP(isectPoints);
GeoIndicesUI32Ptr index = GeoIndicesUI32::create();
beginEditCP(index);
{
index->addValue(0);
index->addValue(1);
index->addValue(2);
index->addValue(3);
index->addValue(4);
}
endEditCP(index);
GeoPLengthsUI32Ptr lens = GeoPLengthsUI32::create();
beginEditCP(lens);
{
lens->addValue(2);
lens->addValue(3);
}
endEditCP(lens);
GeoPTypesUI8Ptr type = GeoPTypesUI8::create();
beginEditCP(type);
{
type->addValue(GL_LINES);
type->addValue(GL_TRIANGLES);
}
endEditCP(type);
SimpleMaterialPtr red = SimpleMaterial::create();
beginEditCP(red);
{
red->setDiffuse (Color3f( 1,0,0 ));
red->setTransparency(0.5);
red->setLit (false);
}
endEditCP (red);
testgeocore = Geometry::create();
beginEditCP(testgeocore);
{
testgeocore->setPositions(isectPoints);
testgeocore->setIndices(index);
testgeocore->setLengths(lens);
testgeocore->setTypes(type);
testgeocore->setMaterial(red);
}
endEditCP(testgeocore);
NodePtr testgeo = Node::create();
beginEditCP(testgeo);
{
testgeo->setCore(testgeocore);
}
endEditCP(testgeo);
beginEditCP(puck_trans_node);
{
puck_trans_node->addChild(testgeo);
}
return puck_trans_node;
}
GeometryPtr PerformerLoader::traverseGSet(NodePtr node, pfGeoSet *gset)
{
FINFO(("PerformerLoader::traverseGSet: traversing %p: ", gset));
if(gset->getType()->isDerivedFrom(pfGeoArray::getClassType()))
{
return traverseGArray(node, dynamic_cast<pfGeoArray*>(gset));
}
pfGeoState *gstate = gset->getGState();
int primtype, primcount, vertcount;
primtype = gset->getPrimType();
primcount = gset->getNumPrims();
FINFO(("pt %d, pc %d ", primtype, primcount));
int lencount, *lenlist;
if (lenlist = gset->getPrimLengths())
{
int i;
for (i = 0, lencount = 0; i < primcount; i++)
lencount += PF_ABS(lenlist[i]);
}
// Map Performer to OpenGL primtype
UInt32 oprimtype = GL_POINTS;
static int pprimtypes[] = { PFGS_POINTS, PFGS_LINES, PFGS_TRIS,
PFGS_QUADS, PFGS_LINESTRIPS, PFGS_TRISTRIPS,
PFGS_TRIFANS, PFGS_POLYS,
PFGS_FLAT_LINESTRIPS, PFGS_FLAT_TRISTRIPS,
PFGS_FLAT_TRIFANS, -1};
static int oprimtypes[] = { GL_POINTS, GL_LINES, GL_TRIANGLES,
GL_QUADS, GL_LINE_STRIP, GL_TRIANGLE_STRIP,
GL_TRIANGLE_FAN, GL_POLYGON,
GL_LINE_STRIP, GL_TRIANGLE_STRIP,
GL_TRIANGLE_FAN };
for (UInt16 i = 0; pprimtypes[i] != -1; ++i)
if(pprimtypes[i] == primtype)
oprimtype = oprimtypes[i];
int cn_buffer = 0;
switch (primtype)
{
case PFGS_POINTS: vertcount = primcount;
primcount = 1;
break;
case PFGS_LINES: vertcount = primcount * 2;
primcount = 1;
break;
case PFGS_TRIS: vertcount = primcount * 3;
primcount = 1;
break;
case PFGS_QUADS: vertcount = primcount * 4;
primcount = 1;
break;
case PFGS_LINESTRIPS:
case PFGS_TRISTRIPS:
case PFGS_TRIFANS:
case PFGS_POLYS: vertcount = lencount;
break;
case PFGS_FLAT_LINESTRIPS:
FDEBUG(("PerformerLoader::traverseGSet: found "
"primitive PFGS_FLAT_LINESTRIPS, will split into"
"individual lines!\n"));
cn_buffer = 1;
vertcount = lencount;
break;
case PFGS_FLAT_TRISTRIPS:
FDEBUG(("PerformerLoader::traverseGSet: found "
"primitive PFGS_FLAT_TRISTRIPS!\n"));
cn_buffer = 2;
vertcount = lencount;
break;
case PFGS_FLAT_TRIFANS:
FDEBUG(("PerformerLoader::traverseGSet: found "
"primitive PFGS_FLAT_TRIFANS!\n"));
cn_buffer = 2;
vertcount = lencount;
break;
}
FINFO(("vc %d ", vertcount));
// Fill the Geometry
GeometryPtr ogeo = Geometry::create();
beginEditCP(ogeo);
if(gstate)
{
ogeo->setMaterial(traverseGState(node, gstate));
}
else
{
ogeo->setMaterial(NullFC);
}
GeoPTypesPtr otypes = GeoPTypesUI8::create();
beginEditCP(otypes);
if (lenlist = gset->getPrimLengths())
{
GeoPLengthsUI32Ptr olens = GeoPLengthsUI32::create();
beginEditCP(olens);
for (int i = 0; i < primcount; i++)
{
otypes->push_back(oprimtype);
olens->push_back(lenlist[i]);
}
endEditCP(olens);
ogeo->setLengths(olens);
}
else
{
otypes->push_back(oprimtype);
lenlist = &vertcount;
lencount = vertcount;
if(primcount != 1)
FWARNING(("PerformerLoader::traverseGSet: No lens, but "
"primcount=%d.\n", primcount));
}
endEditCP(otypes);
ogeo->setTypes(otypes);
// Convert the geo attributes
int pmin, pmax;
pfVec3 *pverts;
ushort *pinds;
GeoPositions3fPtr opos = GeoPositions3f::create();
GeoIndicesUI16Ptr oind = GeoIndicesUI16::create();
beginEditCP(opos);
beginEditCP(oind);
gset->getAttrLists(PFGS_COORD3, (void**)&pverts, &pinds);
if(pverts)
{
if(pinds)
{
FINFO(("Vi %d-%d ", pmin, pmax));
gset->getAttrRange(PFGS_COORD3, &pmin, &pmax);
for(UInt32 i = 0; i < pmax+1; ++i)
opos->push_back(Vec3f(pverts[i].vec));
for(UInt32 i = 0; i < vertcount; ++i)
oind->push_back(pinds[i]);
}
else
{
FINFO(("V "));
for(UInt32 i = 0; i < vertcount; ++i)
opos->push_back(Vec3f(pverts[i].vec));
}
}
endEditCP(opos);
endEditCP(oind);
ogeo->setPositions(opos);
if(oind->size())
{
ogeo->setIndices(oind);
}
else
{
subRefCP(oind);
}
int bind;
// Normals
if((bind = gset->getAttrBind(PFGS_NORMAL3)) != PFGS_OFF)
{
if(bind == PFGS_PER_PRIM)
{
FNOTICE(("PerformerLoader::traverseGSet: found PER_PRIM binding "
"for normals, ignoring them.\n"));
}
else if(bind == PFGS_OVERALL)
{
FINFO(("NO "));
GeoNormals3fPtr onorm = GeoNormals3f::create();
beginEditCP(onorm);
pfVec3 *pnorms;
gset->getAttrLists(PFGS_NORMAL3, (void**)&pnorms, &pinds);
if(pnorms)
{
Vec3f c;
c.setValues(pnorms[0].vec[0], pnorms[0].vec[1],
pnorms[0].vec[2]);
#if 0 // This assumes a single normal is used as overall. Not true for 1.x
onorm->getField().push_back(c);
#else
for(int i = 0; i < vertcount; ++i)
onorm->getField().push_back(c);
#endif
}
endEditCP(onorm);
ogeo->setNormals(onorm);
}
else
{
GeoNormals3fPtr onorm = GeoNormals3f::create();
beginEditCP(onorm);
pfVec3 *pnorms;
ushort *pninds;
gset->getAttrLists(PFGS_NORMAL3, (void**)&pnorms, &pninds);
if(pnorms)
{
if(pninds)
{
int pcmin, pcmax;
gset->getAttrRange(PFGS_NORMAL3, &pcmin, &pcmax);
FINFO(("NI %d-%d ", pcmin, pcmax));
// Check indices
if(pcmax != pmax)
FWARNING(("Normal pmax %d != pmax %d!\n",
pcmax, pmax));
for(int i = 0; i < pcmax; ++i)
{
if(pinds[i] != pninds[i])
FWARNING(("Normal Index %d (%d) != vind (%d)!\n",
i, pninds[i], pinds[i]));
}
int ind = 0;
for(int j = 0; j < primcount; ++j)
{
Vec3f c;
c.setValues(pnorms[0].vec[0], pnorms[0].vec[1],
pnorms[0].vec[2]);
for(UInt32 i = 0; i < cn_buffer; ++i)
{
onorm->getField().push_back(c);
}
for(UInt32 i = 0; i < lenlist[j] - cn_buffer;
++i, ++ind)
{
Vec3f c;
c.setValues(pnorms[ind].vec[0],
pnorms[ind].vec[1],
pnorms[ind].vec[2]);
onorm->getField().push_back(c);
}
}
}
else
{
FINFO(("N "));
int ind = 0;
for(int j = 0; j < primcount; ++j)
{
Vec3f c;
c.setValues(pnorms[0].vec[0], pnorms[0].vec[1],
pnorms[0].vec[2]);
for(UInt32 i = 0; i < cn_buffer; ++i)
{
onorm->getField().push_back(c);
}
for(UInt32 i = 0; i < lenlist[j] - cn_buffer;
++i, ++ind)
{
Vec3f c;
c.setValues(pnorms[ind].vec[0],
pnorms[ind].vec[1],
pnorms[ind].vec[2]);
onorm->getField().push_back(c);
}
}
}
}
endEditCP(onorm);
ogeo->setNormals(onorm);
}
}
// Colors
if((bind = gset->getAttrBind(PFGS_COLOR4)) != PFGS_OFF)
{
if(bind == PFGS_PER_PRIM)
{
FNOTICE(("PerformerLoader::traverseGSet: found PER_PRIM binding "
"for colors, ignoring them.\n"));
}
else if(bind == PFGS_OVERALL)
{
FINFO(("CO "));
GeoColors4fPtr ocols = GeoColors4f::create();
beginEditCP(ocols);
pfVec4 *pcols;
gset->getAttrLists(PFGS_COLOR4, (void**)&pcols, &pinds);
if(pcols)
{
Color4f c;
c.setValuesRGBA(pcols[0].vec[0], pcols[0].vec[1],
pcols[0].vec[2], pcols[0].vec[3]);
#if 0 // This assumes a single colors is used as overall. Not true for 1.x
ocols->getField().push_back(c);
#else
for(int i = 0; i < vertcount; ++i)
ocols->getField().push_back(c);
#endif
}
endEditCP(ocols);
ogeo->setColors(ocols);
}
else
{
GeoColors4fPtr ocols = GeoColors4f::create();
beginEditCP(ocols);
pfVec4 *pcols;
ushort *pcinds;
gset->getAttrLists(PFGS_COLOR4, (void**)&pcols, &pcinds);
if(pcols)
{
if(pcinds)
{
int pcmin, pcmax;
gset->getAttrRange(PFGS_COLOR4, &pcmin, &pcmax);
FINFO(("CI %d-%d ", pcmin, pcmax));
if(pcmax != pmax)
FWARNING(("Color pmax %d != pmax %d!\n",
pcmax, pmax));
for(int i = 0; i < pcmax; ++i)
{
if(pinds[i] != pcinds[i])
FWARNING(("Color Index %d (%d) != vind (%d)!\n",
i, pcinds[i], pinds[i]));
}
// !!! Indices ignored for now, assumed to be the same
// as for positions
int ind = 0;
for(int j = 0; j < primcount; ++j)
{
Color4f c;
c.setValuesRGBA(pcols[0].vec[0], pcols[0].vec[1],
pcols[0].vec[2], pcols[0].vec[3]);
for(UInt32 i = 0; i < cn_buffer; ++i)
{
ocols->getField().push_back(c);
}
for(UInt32 i = 0; i < lenlist[j] - cn_buffer;
++i, ++ind)
{
Color4f c;
c.setValuesRGBA(pcols[ind].vec[0],
pcols[ind].vec[1],
pcols[ind].vec[2],
pcols[ind].vec[3]);
ocols->getField().push_back(c);
}
}
}
else
{
FINFO(("C "));
int ind = 0;
for(int j = 0; j < primcount; ++j)
{
Color4f c;
c.setValuesRGBA(pcols[0].vec[0], pcols[0].vec[1],
pcols[0].vec[2], pcols[0].vec[3]);
for(UInt32 i = 0; i < cn_buffer; ++i)
{
ocols->getField().push_back(c);
}
for(UInt32 i = 0; i < lenlist[j] - cn_buffer;
++i, ++ind)
{
Color4f c;
c.setValuesRGBA(pcols[ind].vec[0],
pcols[ind].vec[1],
pcols[ind].vec[2],
pcols[ind].vec[3]);
ocols->getField().push_back(c);
}
}
}
}
endEditCP(ocols);
ogeo->setColors(ocols);
}
}
// Texture coordinates
if((bind = gset->getAttrBind(PFGS_TEXCOORD2)) != PFGS_OFF)
{
if(bind == PFGS_PER_PRIM)
{
FNOTICE(("PerformerLoader::traverseGSet: found PER_PRIM binding "
"for texcoords, ignoring them.\n"));
}
else if(bind == PFGS_OVERALL)
{
FINFO(("TO "));
GeoTexCoords2fPtr otexc = GeoTexCoords2f::create();
beginEditCP(otexc);
pfVec2 *ptexcs;
gset->getAttrLists(PFGS_TEXCOORD2, (void**)&ptexcs, &pinds);
if(ptexcs)
{
Vec2f tc;
tc.setValues(ptexcs[0].vec[0], ptexcs[0].vec[1]);
#if 0 // This assumes a single texcal is used as overall. Not true for 1.x
otexc->getField().push_back(tc);
#else
for(int i = 0; i < vertcount; ++i)
otexc->getField().push_back(tc);
#endif
}
endEditCP(otexc);
ogeo->setTexCoords(otexc);
}
else
{
GeoTexCoords2fPtr otexc = GeoTexCoords2f::create();
beginEditCP(otexc);
pfVec2 *ptexcs;
ushort *ptexinds;
gset->getAttrLists(PFGS_TEXCOORD2, (void**)&ptexcs, &ptexinds);
if(ptexcs)
{
if(ptexinds)
{
int pcmin, pcmax;
gset->getAttrRange(PFGS_TEXCOORD2, &pcmin, &pcmax);
FINFO(("TI %d-%d ", pcmin, pcmax));
// Check indices
if(pcmax != pmax)
FWARNING(("TexCoord pmax %d != pmax %d!\n",
pcmax, pmax));
for(int i = 0; i < pcmax; ++i)
{
if(pinds[i] != ptexinds[i])
FWARNING(("TexCoord Index %d (%d) != vind (%d)!\n",
i, ptexinds[i], pinds[i]));
}
int ind = 0;
for(int j = 0; j < primcount; ++j)
{
Vec2f tc;
tc.setValues(ptexcs[0].vec[0], ptexcs[0].vec[1]);
for(UInt32 i = 0; i < cn_buffer; ++i)
{
otexc->getField().push_back(tc);
}
for(UInt32 i = 0; i < lenlist[j] - cn_buffer;
++i, ++ind)
{
Vec2f tc;
tc.setValues(ptexcs[ind].vec[0],
ptexcs[ind].vec[1]);
otexc->getField().push_back(tc);
}
}
}
else
{
FINFO(("T "));
int ind = 0;
for(int j = 0; j < primcount; ++j)
{
Vec2f tc;
tc.setValues(ptexcs[0].vec[0], ptexcs[0].vec[1]);
for(UInt32 i = 0; i < cn_buffer; ++i)
{
otexc->getField().push_back(tc);
}
for(UInt32 i = 0; i < lenlist[j] - cn_buffer;
++i, ++ind)
{
Vec2f tc;
tc.setValues(ptexcs[ind].vec[0],
ptexcs[ind].vec[1]);
otexc->getField().push_back(tc);
}
}
}
}
endEditCP(otexc);
ogeo->setTexCoords(otexc);
}
}
FINFO(("\n"));
endEditCP(ogeo);
//FINFO(("PerformerLoader::Geo dump %p\n", gset));
//ogeo->dump();
return ogeo;
}
/*
Aufruf dieser Funktion erfolgt bei Traversierung des Szenengraphen
mittels OpenSG-Funktion traverse().
Enthaelt ein Knoten verwertbare Geometrieinformation so tragen wir
Zeiger auf seine Geometrie (OpenSG-Strukturen) im array gla_meshInfo_
ein.
Nebenbei bestimmen wir für die Geometrie auch noch die World-Space-
Transformation (evtl. existiert eine OpenSG-Funktion um diese
Information zu erhalten, der Autor hat keine in der OpenSG-API
entdeckt).
*/
Action::ResultE enter(NodePtr &node)
{
int i, j, h;
Pnt3f v;
int numFaces, numFaceVertices, vId, size;
MeshInfo meshInfo;
TinyMatrix transf;
FaceIterator fit;
int numQuads;
NamePtr namePtr;
char name[255];
namePtr = NamePtr::dcast(node->findAttachment(Name::getClassType().getGroupId()));
if(namePtr == osg::NullFC)
strcpy(name, "");
else
{
strcpy(name, namePtr->getFieldPtr()->getValue().c_str());
}
SINFO << "Node name = '" << name << "'" << endl << endLog;
GeometryPtr geo = GeometryPtr::dcast(node->getCore());
if(geo != NullFC)
{
GeoPLengthsUI32Ptr pLength = GeoPLengthsUI32Ptr::dcast(geo->getLengths());
GeoPTypesUI8Ptr pTypes = GeoPTypesUI8Ptr::dcast(geo->getTypes());
/* pLength and pTypes should not be NullFC, however VRML Importer/Exporter
code is instable by now, so this can happen */
if((pLength != NullFC) && (pTypes != NullFC))
{
GeoPLengthsUI32::StoredFieldType * pLengthField = pLength->getFieldPtr();
GeoPTypesUI8::StoredFieldType * pTypeField = pTypes->getFieldPtr();
size = pLengthField->size();
for(h = 0; h < size; h++)
{
if(((*pTypeField)[h] == GL_TRIANGLES) ||
((*pTypeField)[h] == GL_QUADS))
{
/* may quads appear in GL_TRIANGLES ? */
/* check if all triangles have three vertices */
numQuads = 0;
fit = geo->beginFaces();
while(fit != geo->endFaces())
{
numFaceVertices = fit.getLength();
if(numFaceVertices == 4)
numQuads++;
if(numFaceVertices > 4)
{
SWARNING <<
"More than 4 vertices in face!" <<
endl <<
endLog;
return Action::Continue;
// exit(1);
}
++fit;
}
if(numQuads > 0)
{
SWARNING << "Quad encountered" << endl << endLog;
}
if(gl_sga->nodeDepth_ > 0)
{
for(i = 0; i < gl_sga->nodeDepth_; i++)
{
meshInfo.transf = meshInfo.transf * gl_sga->transf_[i];
}
}
else
meshInfo.transf.identity();
/* access to vertices */
GeoPositions3fPtr pPos = GeoPositions3fPtr::dcast(geo->getPositions());
GeoPositions3f::StoredFieldType * pPosField = pPos->getFieldPtr();
/* access to faces */
numFaces = 0;
fit = geo->beginFaces();
for(fit = geo->beginFaces(); fit != geo->endFaces(); ++fit)
{
numFaceVertices = fit.getLength();
for(j = 0; j < numFaceVertices; j++)
{
vId = fit.getPositionIndex(j);
}
numFaces++;
} /* for fit */
/* set other mesh attributes */
meshInfo.numQuads = numQuads;
meshInfo.geoPtr = geo;
meshInfo.vPtr = pPosField;
meshInfo.triangularFaces = (numQuads == 0);
meshInfo.numVertices = pPosField->size();
meshInfo.numFaces = numFaces;
gl_sga->meshInfo_.push_back(meshInfo);
gl_sga->numGeometryNodes_++;
}
else
{
// SWARNING << "Neither triangle nor quad. Field type = " <<
// (*pTypeField)[h] << endl << endLog;
}
} /* for h */
} /* if pLength!=NullFC */
}
else if(node->getCore()->getType().isDerivedFrom(Transform::getClassType()))
{
TransformPtr t = TransformPtr::dcast(node->getCore());
Matrix ma;
ma = t->getMatrix();
SINFO <<
"Node type derived from transform, skipping children" <<
endl <<
endLog;
for(i = 0; i < 4; i++)
{
for(j = 0; j < 4; j++)
{
transf[i][j] = ma[j][i]; /* the matrix is stored as columns/rows ? */
}
}
if(gl_sga->nodeDepth_ > gl_sga->maxNodeDepth_)
{
gl_sga->maxNodeDepth_ = gl_sga->nodeDepth_;
gl_sga->transf_.push_back(transf);
}
else
{
gl_sga->transf_[gl_sga->nodeDepth_] = transf;
}
gl_sga->nodeDepth_++;
}
return Action::Continue;
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// GLUT init
int winid = setupGLUT(&argc, argv);
// the connection between GLUT and OpenSG
GLUTWindowPtr gwin= GLUTWindow::create();
gwin->setId(winid);
gwin->init();
// The scene group
NodePtr scene = Node::create();
GroupPtr g = Group::create();
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
scene->setCore(g);
if(argc < 2)
{
FWARNING(("No file given!\n"));
FWARNING(("Supported file formats:\n"));
std::list<const char*> suffixes;
SceneFileHandler::the().getSuffixList(suffixes);
for(std::list<const char*>::iterator it = suffixes.begin();
it != suffixes.end();
++it)
{
FWARNING(("%s\n", *it));
}
fileroot = makeTorus(.5, 2, 16, 16);
}
else
{
/*
All scene file loading is handled via the SceneFileHandler.
*/
fileroot = SceneFileHandler::the().read(argv[1]);
}
scene->addChild(fileroot);
// Create a small geometry to show the ray and what was hit
// Contains a line and a single triangle.
// The line shows the ray, the triangle whatever was hit.
SimpleMaterialPtr red = SimpleMaterial::create();
beginEditCP(red);
{
red->setDiffuse (Color3f( 1,0,0 ));
red->setTransparency(0.5);
red->setLit (false);
}
endEditCP (red);
isectPoints = GeoPositions3f::create();
beginEditCP(isectPoints);
{
isectPoints->addValue(Pnt3f(0,0,0));
isectPoints->addValue(Pnt3f(0,0,0));
isectPoints->addValue(Pnt3f(0,0,0));
isectPoints->addValue(Pnt3f(0,0,0));
isectPoints->addValue(Pnt3f(0,0,0));
isectPoints->addValue(Pnt3f(0,0,0));
isectPoints->addValue(Pnt3f(0,0,0));
}
endEditCP(isectPoints);
GeoIndicesUI32Ptr index = GeoIndicesUI32::create();
beginEditCP(index);
{
index->addValue(0);
index->addValue(1);
index->addValue(2);
index->addValue(3);
index->addValue(4);
index->addValue(5);
index->addValue(6);
}
endEditCP(index);
GeoPLengthsUI32Ptr lens = GeoPLengthsUI32::create();
beginEditCP(lens);
{
lens->addValue(4);
lens->addValue(3);
}
endEditCP(lens);
GeoPTypesUI8Ptr type = GeoPTypesUI8::create();
beginEditCP(type);
{
type->addValue(GL_LINES);
type->addValue(GL_TRIANGLES);
}
endEditCP(type);
testgeocore = Geometry::create();
beginEditCP(testgeocore);
{
testgeocore->setPositions(isectPoints);
testgeocore->setIndices(index);
testgeocore->setLengths(lens);
testgeocore->setTypes(type);
testgeocore->setMaterial(red);
}
endEditCP(testgeocore);
NodePtr testgeo = Node::create();
beginEditCP(testgeo);
{
testgeo->setCore(testgeocore);
}
endEditCP(testgeo);
scene->addChild(testgeo);
endEditCP(scene);
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// tell the manager what to manage
mgr->setWindow(gwin );
mgr->setRoot (scene);
// show the whole scene
mgr->showAll();
mgr->getCamera()->setNear(mgr->getCamera()->getNear() / 10);
// Show the bounding volumes? Not for now
mgr->getAction()->setVolumeDrawing(false);
// GLUT main loop
glutMainLoop();
return 0;
// GLUT main loop
glutMainLoop();
return 0;
}
NodePtr createRose()
{
GeometryPtr geoPtr = Geometry::create();
beginEditCP(geoPtr);
{
GeoPTypesUI8Ptr typesPtr = GeoPTypesUI8::create();
typesPtr->push_back(GL_QUADS);
geoPtr->setTypes(typesPtr);
GeoPLengthsUI32Ptr lensPtr = GeoPLengthsUI32::create();
lensPtr->push_back(96);
geoPtr->setLengths(lensPtr);
GeoPositions3fPtr posPtr = GeoPositions3f::create();
// top
posPtr->push_back(Vec3f( 0.00f, 1.00f, 0.00f));
posPtr->push_back(Vec3f( 0.00f, 0.10f, 0.10f));
posPtr->push_back(Vec3f( 0.05f, 0.05f, 0.05f));
posPtr->push_back(Vec3f( 0.10f, 0.10f, 0.00f));
posPtr->push_back(Vec3f( 0.00f, 1.00f, 0.00f));
posPtr->push_back(Vec3f( 0.10f, 0.10f, 0.00f));
posPtr->push_back(Vec3f( 0.05f, 0.05f, -0.05f));
posPtr->push_back(Vec3f( 0.00f, 0.10f, -0.10f));
posPtr->push_back(Vec3f( 0.00f, 1.00f, 0.00f));
posPtr->push_back(Vec3f( 0.00f, 0.10f, -0.10f));
posPtr->push_back(Vec3f(-0.05f, 0.05f, -0.05f));
posPtr->push_back(Vec3f(-0.10f, 0.10f, 0.00f));
posPtr->push_back(Vec3f( 0.00f, 1.00f, 0.00f));
posPtr->push_back(Vec3f(-0.10f, 0.10f, 0.00f));
posPtr->push_back(Vec3f(-0.05f, 0.05f, 0.05f));
posPtr->push_back(Vec3f( 0.00f, 0.10f, 0.10f));
// bottom
posPtr->push_back(Vec3f( 0.00f, -1.00f, 0.00f));
posPtr->push_back(Vec3f( 0.10f, -0.10f, 0.00f));
posPtr->push_back(Vec3f( 0.05f, -0.05f, 0.05f));
posPtr->push_back(Vec3f( 0.00f, -0.10f, 0.10f));
posPtr->push_back(Vec3f( 0.00f, -1.00f, 0.00f));
posPtr->push_back(Vec3f( 0.00f, -0.10f, 0.10f));
posPtr->push_back(Vec3f(-0.05f, -0.05f, 0.05f));
posPtr->push_back(Vec3f(-0.10f, -0.10f, 0.00f));
posPtr->push_back(Vec3f( 0.00f, -1.00f, 0.00f));
posPtr->push_back(Vec3f(-0.10f, -0.10f, 0.00f));
posPtr->push_back(Vec3f(-0.05f, -0.05f, -0.05f));
posPtr->push_back(Vec3f( 0.00f, -0.10f, -0.10f));
posPtr->push_back(Vec3f( 0.00f, -1.00f, 0.00f));
posPtr->push_back(Vec3f( 0.00f, -0.10f, -0.10f));
posPtr->push_back(Vec3f( 0.05f, -0.05f, -0.05f));
posPtr->push_back(Vec3f( 0.10f, -0.10f, 0.00f));
// left
posPtr->push_back(Vec3f(-1.00f, 0.00f, 0.00f));
posPtr->push_back(Vec3f(-0.10f, -0.10f, 0.00f));
posPtr->push_back(Vec3f(-0.05f, -0.05f, 0.05f));
posPtr->push_back(Vec3f(-0.10f, 0.00f, 0.10f));
posPtr->push_back(Vec3f(-1.00f, 0.00f, 0.00f));
posPtr->push_back(Vec3f(-0.10f, 0.00f, 0.10f));
posPtr->push_back(Vec3f(-0.05f, 0.05f, 0.05f));
posPtr->push_back(Vec3f(-0.10f, 0.10f, 0.00f));
posPtr->push_back(Vec3f(-1.00f, 0.00f, 0.00f));
posPtr->push_back(Vec3f(-0.10f, 0.10f, 0.00f));
posPtr->push_back(Vec3f(-0.05f, 0.05f, -0.05f));
posPtr->push_back(Vec3f(-0.10f, 0.00f, -0.10f));
posPtr->push_back(Vec3f(-1.00f, 0.00f, 0.00f));
posPtr->push_back(Vec3f(-0.10f, 0.00f, -0.10f));
posPtr->push_back(Vec3f(-0.05f, -0.05f, -0.05f));
posPtr->push_back(Vec3f(-0.10f, -0.10f, 0.00f));
// right
posPtr->push_back(Vec3f( 1.00f, 0.00f, 0.00f));
posPtr->push_back(Vec3f( 0.10f, 0.00f, 0.10f));
posPtr->push_back(Vec3f( 0.05f, -0.05f, 0.05f));
posPtr->push_back(Vec3f( 0.10f, -0.10f, 0.00f));
posPtr->push_back(Vec3f( 1.00f, 0.00f, 0.00f));
posPtr->push_back(Vec3f( 0.10f, -0.10f, 0.00f));
posPtr->push_back(Vec3f( 0.05f, -0.05f, -0.05f));
posPtr->push_back(Vec3f( 0.10f, 0.00f, -0.10f));
posPtr->push_back(Vec3f( 1.00f, 0.00f, 0.00f));
posPtr->push_back(Vec3f( 0.10f, 0.00f, -0.10f));
posPtr->push_back(Vec3f( 0.05f, 0.05f, -0.05f));
posPtr->push_back(Vec3f( 0.10f, 0.10f, 0.00f));
posPtr->push_back(Vec3f( 1.00f, 0.00f, 0.00f));
posPtr->push_back(Vec3f( 0.10f, 0.10f, 0.00f));
posPtr->push_back(Vec3f( 0.05f, 0.05f, 0.05f));
posPtr->push_back(Vec3f( 0.10f, 0.00f, 0.10f));
// front
posPtr->push_back(Vec3f( 0.00f, 0.00f, 1.00f));
posPtr->push_back(Vec3f( 0.10f, 0.00f, 0.10f));
posPtr->push_back(Vec3f( 0.05f, 0.05f, 0.05f));
posPtr->push_back(Vec3f( 0.00f, 0.10f, 0.10f));
posPtr->push_back(Vec3f( 0.00f, 0.00f, 1.00f));
posPtr->push_back(Vec3f( 0.00f, 0.10f, 0.10f));
posPtr->push_back(Vec3f(-0.05f, 0.05f, 0.05f));
posPtr->push_back(Vec3f(-0.10f, 0.00f, 0.10f));
posPtr->push_back(Vec3f( 0.00f, 0.00f, 1.00f));
posPtr->push_back(Vec3f(-0.10f, 0.00f, 0.10f));
posPtr->push_back(Vec3f(-0.05f, -0.05f, 0.05f));
posPtr->push_back(Vec3f( 0.00f, -0.10f, 0.10f));
posPtr->push_back(Vec3f( 0.00f, 0.00f, 1.00f));
posPtr->push_back(Vec3f( 0.00f, -0.10f, 0.10f));
posPtr->push_back(Vec3f( 0.05f, -0.05f, 0.05f));
posPtr->push_back(Vec3f( 0.10f, 0.00f, 0.10f));
// back
posPtr->push_back(Vec3f( 0.00f, 0.00f, -1.00f));
posPtr->push_back(Vec3f(-0.10f, 0.00f, -0.10f));
posPtr->push_back(Vec3f(-0.05f, 0.05f, -0.05f));
posPtr->push_back(Vec3f( 0.00f, 0.10f, -0.10f));
posPtr->push_back(Vec3f( 0.00f, 0.00f, -1.00f));
posPtr->push_back(Vec3f( 0.00f, 0.10f, -0.10f));
posPtr->push_back(Vec3f( 0.05f, 0.05f, -0.05f));
posPtr->push_back(Vec3f( 0.10f, 0.00f, -0.10f));
posPtr->push_back(Vec3f( 0.00f, 0.00f, -1.00f));
posPtr->push_back(Vec3f( 0.10f, 0.00f, -0.10f));
posPtr->push_back(Vec3f( 0.05f, -0.05f, -0.05f));
posPtr->push_back(Vec3f( 0.00f, -0.10f, -0.10f));
posPtr->push_back(Vec3f( 0.00f, 0.00f, -1.00f));
posPtr->push_back(Vec3f( 0.00f, -0.10f, -0.10f));
posPtr->push_back(Vec3f(-0.05f, -0.05f, -0.05f));
posPtr->push_back(Vec3f(-0.10f, 0.00f, -0.10f));
geoPtr->setPositions(posPtr);
SimpleMaterialPtr matPtr = SimpleMaterial::create();
beginEditCP(matPtr);
{
matPtr->setDiffuse(Color3f(1, 0, 0));
}
endEditCP(matPtr);
geoPtr->setMaterial(matPtr);
}
endEditCP(geoPtr);
calcFaceNormals(geoPtr);
NodePtr nodePtr = Node::create();
beginEditCP(nodePtr, Node::CoreFieldMask);
{
nodePtr->setCore(geoPtr);
}
endEditCP(nodePtr, Node::CoreFieldMask);
return nodePtr;
}
