GeometryPtr OpenSGLatticeGeometry::createGeometry(const bool all)
{
showAll = all;
latticeGeo = Geometry::create();
#if OSG_MAJOR_VERSION < 2
// 2013-08-27 ZaJ: is this portable to OpenSG2? I've got no idea where setName is coming from...
setName(latticeGeo, "LatticeGeometry");
#endif
#if OSG_MAJOR_VERSION >= 2
latticeTypes = GeoUInt8Property::create();
latticePoints = GeoPnt3fProperty::create();
latticeIndices = GeoUInt32Property::create();
latticeColors = GeoColor3fProperty::create();
numOfPointsPerType = GeoUInt32Property::create();
#else // OpenSG1.8:
latticeTypes = GeoPTypesUI8::create();
latticePoints = GeoPositions3f::create();
latticeIndices = GeoIndicesUI32::create();
latticeColors = GeoColors3f::create();
numOfPointsPerType = GeoPLengthsUI32::create();
#endif
SimpleMaterialPtr mat = SimpleMaterial::create();
beginEditCP(mat, SimpleMaterial::LitFieldMask);
mat->setLit(false);
endEditCP(mat, SimpleMaterial::LitFieldMask);
latticeGeo->setMaterial(mat);
// define OPEN_GL types for lattice
beginEditCP(latticeTypes, GeoPTypesUI8::GeoPropDataFieldMask);
latticeTypes->addValue(GL_POINTS);
latticeTypes->addValue(GL_LINES);
endEditCP(latticeTypes, GeoPTypesUI8::GeoPropDataFieldMask);
calcNumOfPoints(all);
// define number of points for each OPEN_GL type for lattice
beginEditCP(numOfPointsPerType, GeoPLengthsUI32::GeoPropDataFieldMask);
numOfPointsPerType->addValue(numOfLatticePoints);
numOfPointsPerType->addValue(numOfLatticeLinePoints);
endEditCP(numOfPointsPerType, GeoPLengthsUI32::GeoPropDataFieldMask);
updateGeometry(all);
return latticeGeo;
}
//! Copy Constructor
DVRVolume::DVRVolume(const DVRVolume &source) :
Inherited (source),
drawStyleListValid(false ),
textureManager (this ),
shadingInitialized(false )
{
SINFO << "DVRVolume::DVRVolume(const DVRVolume &source) this: "
<< this << std::endl;
//!! FIXME:
//!! This is only performed during instantiation of real objects
//!! Which is only done with the copy constructor
//!!
//!! Otherwise my code cores - (maybe the copy constructor of FCPtr is
//!! broken?!)
DVRVolumePtr ptr(*this);
// Fake material for render action
SimpleMaterialPtr m = SimpleMaterial::create();
beginEditCP(m);
{
m->setTransparency(0.001f );
m->setLit (false );
m->setDiffuse (Color3f(1.0, 1.0, 1.0));
m->setAmbient (Color3f(1.0, 1.0, 1.0));
}
endEditCP(m);
// Chunk material as storage fieldcontainer for textures
ChunkMaterialPtr cm = SimpleMaterial::create();
// Add all
beginEditCP(ptr, RenderMaterialFieldMask | TextureStorageFieldMask);
{
setRenderMaterial(m );
setTextureStorage(cm);
}
endEditCP (ptr, RenderMaterialFieldMask | TextureStorageFieldMask);
commonConstructor();
}
NodePtr createScenegraph(){
// the scene must be created here
for (int x = 0; x < N; x++)
for (int z = 0; z < N; z++)
wMesh[x][z] = 0;
// GeoPTypes will define the types of primitives to be used
GeoPTypesPtr type = GeoPTypesUI8::create();
beginEditCP(type, GeoPTypesUI8::GeoPropDataFieldMask);
// we want to use quads ONLY
type->addValue(GL_QUADS);
endEditCP(type, GeoPTypesUI8::GeoPropDataFieldMask);
// GeoPLength will define the number of vertices of
// the used primitives
GeoPLengthsPtr length = GeoPLengthsUI32::create();
beginEditCP(length, GeoPLengthsUI32::GeoPropDataFieldMask);
// the length of our quads is four ;-)
length->addValue((N-1)*(N-1)*4);
endEditCP(length, GeoPLengthsUI32::GeoPropDataFieldMask);
// GeoPositions3f stores the positions of all vertices used in
// this specific geometry core
GeoPositions3fPtr pos = GeoPositions3f::create();
beginEditCP(pos, GeoPositions3f::GeoPropDataFieldMask);
// here they all come
for (int x = 0; x < N; x++)
for (int z = 0; z < N; z++)
pos->addValue(Pnt3f(x, wMesh[x][z], z));
endEditCP(pos, GeoPositions3f::GeoPropDataFieldMask);
//GeoColors3f stores all color values that will be used
GeoColors3fPtr colors = GeoColors3f::create();
beginEditCP(colors, GeoColors3f::GeoPropDataFieldMask);
for (int x = 0; x < N; x++)
for (int z = 0; z < N; z++)
colors->addValue(Color3f(0,0,1));
endEditCP(colors, GeoColors3f::GeoPropDataFieldMask);
GeoNormals3fPtr norms = GeoNormals3f::create();
beginEditCP(norms, GeoNormals3f::GeoPropDataFieldMask);
for (int x = 0; x < N; x++)
for (int z = 0; z < N; z++)
// As initially all heights are set to zero thus yielding a plane,
// we set all normals to (0,1,0) parallel to the y-axis
norms->addValue(Vec3f(0,1,0));
endEditCP(norms, GeoNormals3f::GeoPropDataFieldMask);
SimpleMaterialPtr mat = SimpleMaterial::create();
beginEditCP(mat);
mat->setDiffuse(Color3f(0,0,1));
endEditCP(mat);
// GeoIndicesUI32 points to all relevant data used by the
// provided primitives
GeoIndicesUI32Ptr indices = GeoIndicesUI32::create();
beginEditCP(indices, GeoIndicesUI32::GeoPropDataFieldMask);
for (int x = 0; x < N-1; x++)
for (int z = 0; z < N-1; z++){
// points to four vertices that will
// define a single quad
indices->addValue(z*N+x);
indices->addValue((z+1)*N+x);
indices->addValue((z+1)*N+x+1);
indices->addValue(z*N+x+1);
}
endEditCP(indices, GeoIndicesUI32::GeoPropDataFieldMask);
GeometryPtr geo = Geometry::create();
beginEditCP(geo,
Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::IndicesFieldMask |
Geometry::PositionsFieldMask |
Geometry::NormalsFieldMask |
Geometry::MaterialFieldMask |
Geometry::ColorsFieldMask |
Geometry::DlistCacheFieldMask
);
geo->setTypes(type);
geo->setLengths(length);
geo->setIndices(indices);
geo->setPositions(pos);
geo->setNormals(norms);
geo->setMaterial(mat);
//geo->setColors(colors);
geo->setDlistCache(false);
endEditCP(geo,
Geometry::TypesFieldMask |
Geometry::LengthsFieldMask |
Geometry::IndicesFieldMask |
Geometry::PositionsFieldMask |
Geometry::NormalsFieldMask |
Geometry::MaterialFieldMask |
Geometry::ColorsFieldMask |
Geometry::DlistCacheFieldMask
);
PointLightPtr pLight = PointLight::create();
NodePtr root = Node::create();
NodePtr water = Node::create();
NodePtr pLightTransformNode = Node::create();
TransformPtr pLightTransform = Transform::create();
NodePtr pLightNode = Node::create();
beginEditCP(pLightNode);
pLightNode->setCore(Group::create());
endEditCP(pLightNode);
Matrix m;
m.setIdentity();
m.setTranslate(50,25,50);
beginEditCP(pLightTransform);
pLightTransform->setMatrix(m);
endEditCP(pLightTransform);
//we add a little spehere that will represent the light source
GeometryPtr sphere = makeSphereGeo(2,2);
SimpleMaterialPtr sm = SimpleMaterial::create();
beginEditCP(sm, SimpleMaterial::DiffuseFieldMask |
SimpleMaterial::LitFieldMask);
{
sm->setLit(false);
sm->setDiffuse(Color3f(1,1,1));
}
endEditCP (sm, SimpleMaterial::DiffuseFieldMask |
SimpleMaterial::LitFieldMask);
beginEditCP(sphere, Geometry::MaterialFieldMask);
{
sphere->setMaterial(sm);
}
endEditCP (sphere, Geometry::MaterialFieldMask);
NodePtr sphereNode = Node::create();
beginEditCP(sphereNode);
sphereNode->setCore(sphere);
endEditCP(sphereNode);
beginEditCP(pLightTransformNode);
pLightTransformNode->setCore(pLightTransform);
pLightTransformNode->addChild(pLightNode);
pLightTransformNode->addChild(sphereNode);
endEditCP(pLightTransformNode);
beginEditCP(pLight);
pLight->setPosition(Pnt3f(0,0,0));
//Attenuation parameters
pLight->setConstantAttenuation(1);
pLight->setLinearAttenuation(0);
pLight->setQuadraticAttenuation(0);
//color information
pLight->setDiffuse(Color4f(1,1,1,1));
pLight->setAmbient(Color4f(0.2,0.2,0.2,1));
pLight->setSpecular(Color4f(1,1,1,1));
//set the beacon
pLight->setBeacon(pLightNode);
endEditCP (pLight);
beginEditCP(water);
water->setCore(geo);
endEditCP(water);
beginEditCP(root);
root->setCore(pLight);
root->addChild(water);
root->addChild(pLightTransformNode);
endEditCP(root);
return root;
}
void CharacterModel::convertMaterials(std::string configfile)
{
getMaterials().clear();
UInt32 mcnt = 0;
PathHandler ph;
ph.setBaseFile(configfile.c_str());
for(int mid = 0; mid < _coreModel->getCoreMaterialCount(); mid++)
{
CalCoreMaterial *coremat = _coreModel->getCoreMaterial(mid);
SimpleMaterialPtr mat = SimpleMaterial::create();
beginEditCP(mat);
CalCoreMaterial::Color &calamb = coremat->getAmbientColor();
CalCoreMaterial::Color &caldif = coremat->getDiffuseColor();
CalCoreMaterial::Color &calspec = coremat->getSpecularColor();
mat->setAmbient(Color3f(calamb.red / 255.0f, calamb.green / 255.0f, calamb.blue / 255.0f));
mat->setDiffuse(Color3f(caldif.red / 255.0f, caldif.green / 255.0f, caldif.blue / 255.0f));
mat->setSpecular(Color3f(calspec.red / 255.0f, calspec.green / 255.0f, calspec.blue / 255.0f));
mat->setShininess(coremat->getShininess() * 100.f);
mat->setLit(true);
mat->setColorMaterial(GL_NONE);
for(int mapId = 0; mapId < coremat->getMapCount(); mapId++)
{
std::string file = coremat->getMapFilename(mapId);
std::string pfile = ph.findFile(file.c_str());
SINFO << "Loading texture '" << pfile << "'..." << endLog;
ImagePtr img = Image::create();
if(!img->read(pfile.c_str()))
{
SWARNING << "CharacterModel::convertMaterials: error "
<< "loading image " << file << endLog;
}
else
{
// amz with my test scene paladin.cfg all textures were
// upside down so I disabled the vertical flipping perhaps
// they fixed the bug in Cal3D?
#if 0
beginEditCP(img);
{
// For some reason Cal3D expects textures upside down ???
UInt32 bpl = img->getBpp() * img->getWidth();
UChar8 *t = img->getData(),
*b = t + (img->getHeight() - 1) * bpl,
dum;
for(UInt32 y = img->getHeight() / 2; y > 0; --y)
{
for(UInt32 x = bpl; x > 0; --x, ++t, ++b)
{
dum = *t;
*t = *b;
*b = dum;
}
b -= bpl * 2;
}
}
endEditCP(img);
#endif
TextureChunkPtr tex = TextureChunk::create();
beginEditCP(tex);
tex->setImage(img);
tex->setEnvMode(GL_MODULATE);
endEditCP(tex);
mat->addChunk(tex);
}
}
endEditCP(mat);
coremat->setUserData((Cal::UserData)mcnt);
getMaterials().push_back(mat);
mcnt ++;
}
}
int main(int argc, char **argv)
{
osgInit(argc,argv);
// GLUT init
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow("OpenSG");
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutIdleFunc(idle);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(keyboard);
PassiveWindowPtr pwin=PassiveWindow::create();
pwin->init();
// create the texture
tx1 = TextureChunk::create();
const UInt16 width = 16, height = 1;
ImagePtr pImg1 = Image::create();
pImg1->set(Image::OSG_RGB_PF, width, height );
beginEditCP(pImg1);
UInt8 *d = pImg1->editData();
for(UInt16 y = 0; y < height; ++y)
{
for(UInt16 x = 0; x < width; ++x)
{
*d++ = static_cast<UInt8>(x * 255.f / width);
*d++ = static_cast<UInt8>(y * 255.f / height);
*d++ = static_cast<UInt8>(128);
}
}
endEditCP(pImg1);
beginEditCP(tx1);
tx1->setImage(pImg1);
tx1->setMinFilter(GL_NEAREST);
tx1->setMagFilter(GL_NEAREST);
tx1->setWrapS(GL_REPEAT);
tx1->setWrapT(GL_REPEAT);
endEditCP(tx1);
tg = TexGenChunk::create();
beginEditCP(tg);
tg->setGenFuncS(GL_EYE_LINEAR);
tg->setGenFuncSPlane(Vec4f(0,.15,0,0));
endEditCP(tg);
// create the material
SimpleMaterialPtr mat = SimpleMaterial::create();
beginEditCP(mat);
mat->setDiffuse(Color3f(1,1,1));
mat->setLit(false);
mat->addChunk(tx1);
mat->addChunk(tg);
endEditCP(mat);
// create the scene
NodePtr torus = makeTorus( .5, 2, 16, 32 );
GeometryPtr geo = GeometryPtr::dcast(torus->getCore());
beginEditCP(geo, Geometry::MaterialFieldMask);
geo->setMaterial(mat);
endEditCP(geo, Geometry::MaterialFieldMask);
transn1 = makeCoredNode<Transform>(&trans1);
beginEditCP(transn1, Node::CoreFieldMask | Node::ChildrenFieldMask);
{
transn1->addChild(torus);
}
endEditCP (transn1, Node::CoreFieldMask | Node::ChildrenFieldMask);
transn2 = makeCoredNode<Transform>(&trans2);
NodePtr scene = makeCoredNode<Group>();
beginEditCP(scene);
scene->addChild(transn1);
scene->addChild(transn2);
endEditCP(scene);
beginEditCP(tg);
tg->setSBeacon(torus);
endEditCP(tg);
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// create the window and initial camera/viewport
mgr->setWindow(pwin );
// tell the manager what to manage
mgr->setRoot (scene);
// show the whole scene
mgr->showAll();
mgr->redraw();
webInterface = new WebInterface();
webInterface->setRoot(scene);
// GLUT main loop
glutMainLoop();
return 0;
}
int main(int argc, char **argv)
{
osgInit(argc,argv);
// GLUT init
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutCreateWindow("OpenSG");
glutReshapeFunc(reshape);
glutDisplayFunc(display);
glutIdleFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(keyboard);
PassiveWindowPtr pwin=PassiveWindow::create();
pwin->init();
// create the scene
NodePtr scene;
scene = Node::create();
// create the material
// Pass 1: Simple red, shiny, depth-tested
DepthChunkPtr cl1 = DepthChunk::create();
beginEditCP(cl1);
cl1->setEnable(true);
cl1->setFunc(GL_LEQUAL);
endEditCP(cl1);
SimpleMaterialPtr mat = SimpleMaterial::create();
beginEditCP(mat);
mat->setDiffuse(Color3f(1,0,0));
mat->setSpecular(Color3f(.9,.9,.9));
mat->setShininess(30);
mat->setLit(true);
mat->addChunk(cl1);
endEditCP(mat);
// Pass 2: Green unlit, without depth testing
DepthChunkPtr cl2 = DepthChunk::create();
beginEditCP(cl2);
cl2->setEnable(false);
endEditCP(cl2);
SimpleMaterialPtr mat2 = SimpleMaterial::create();
beginEditCP(mat2);
mat2->setDiffuse(Color3f(0,1,0));
mat2->setLit(false);
mat2->setTransparency(.8);
mat2->addChunk(cl2);
endEditCP(mat2);
// Bring them together
MultiPassMaterialPtr mpm = MultiPassMaterial::create();
beginEditCP(mpm);
mpm->editMFMaterials()->push_back(mat);
mpm->editMFMaterials()->push_back(mat2);
endEditCP(mpm);
GeometryPtr g1 = makeTorusGeo(0.2, 2, 8, 16);
beginEditCP(scene);
scene->setCore(g1);
endEditCP(scene);
beginEditCP(g1);
g1->setMaterial(mpm);
endEditCP(g1);
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// create the window and initial camera/viewport
mgr->setWindow(pwin );
// tell the manager what to manage
mgr->setRoot (scene);
// show the whole scene
mgr->showAll();
mgr->redraw();
// GLUT main loop
glutMainLoop();
return 0;
}
int main(int argc, char *argv[])
{
osgLogP->setLogLevel(LOG_NOTICE);
osgInit(argc, argv);
int winid = setupGLUT(&argc, argv);
// create a GLUT window
GLUTWindowPtr gwin = GLUTWindow::create();
gwin->setId(winid);
gwin->init();
osgLogP->setLogLevel(LOG_DEBUG);
// build the test scene
NodePtr pRoot = Node ::create();
GroupPtr pRootCore = Group::create();
NodePtr pRayGeo = Node ::create();
NodePtr pScene = buildGraph();
GroupPtr pSceneCore = Group::create();
Time tStart;
Time tStop;
Time tDFTotal = 0.0;
Time tDFSTotal = 0.0;
Time tPTotal = 0.0;
Time tOTotal = 0.0;
StatCollector statP;
StatCollector statDF;
StatCollector statDFS;
beginEditCP(pRoot, Node::CoreFieldId | Node::ChildrenFieldId);
pRoot->setCore (pRootCore );
pRoot->addChild(pScene );
pRoot->addChild(pRayGeo );
endEditCP (pRoot, Node::CoreFieldId | Node::ChildrenFieldId);
createRays(uiNumRays, testRays);
// build the geometry to visualize the rays
pPoints = GeoPositions3f::create();
beginEditCP(pPoints);
pPoints->addValue(Pnt3f(0.0, 0.0, 0.0));
pPoints->addValue(Pnt3f(0.0, 0.0, 0.0));
pPoints->addValue(Pnt3f(0.0, 0.0, 0.0));
pPoints->addValue(Pnt3f(0.0, 0.0, 0.0));
pPoints->addValue(Pnt3f(0.0, 0.0, 0.0));
endEditCP (pPoints);
GeoIndicesUI32Ptr pIndices = GeoIndicesUI32::create();
beginEditCP(pIndices);
pIndices->addValue(0);
pIndices->addValue(1);
pIndices->addValue(2);
pIndices->addValue(3);
pIndices->addValue(4);
endEditCP (pIndices);
GeoPLengthsPtr pLengths = GeoPLengthsUI32::create();
beginEditCP(pLengths);
pLengths->addValue(2);
pLengths->addValue(3);
endEditCP (pLengths);
GeoPTypesPtr pTypes = GeoPTypesUI8::create();
beginEditCP(pTypes);
pTypes->addValue(GL_LINES );
pTypes->addValue(GL_TRIANGLES);
endEditCP (pTypes);
GeoColors3fPtr pColors = GeoColors3f::create();
beginEditCP(pColors);
pColors->addValue(Color3f(1.0, 1.0, 1.0));
pColors->addValue(Color3f(1.0, 0.0, 0.0));
pColors->addValue(Color3f(1.0, 0.0, 0.0));
pColors->addValue(Color3f(1.0, 0.0, 0.0));
pColors->addValue(Color3f(1.0, 0.0, 0.0));
endEditCP (pColors);
SimpleMaterialPtr pMaterial = SimpleMaterial::create();
beginEditCP(pMaterial);
pMaterial->setLit(false);
endEditCP (pMaterial);
GeometryPtr pRayGeoCore = Geometry::create();
beginEditCP(pRayGeoCore);
pRayGeoCore->setPositions(pPoints );
pRayGeoCore->setIndices (pIndices );
pRayGeoCore->setLengths (pLengths );
pRayGeoCore->setTypes (pTypes );
pRayGeoCore->setColors (pColors );
pRayGeoCore->setMaterial (pMaterial);
endEditCP (pRayGeoCore);
beginEditCP(pRayGeo, Node::CoreFieldId);
pRayGeo->setCore(pRayGeoCore);
endEditCP (pRayGeo, Node::CoreFieldId);
IntersectActor::regDefaultClassEnter(
osgTypedFunctionFunctor2CPtr<
NewActionTypes::ResultE, NodeCorePtr,
ActorBase::FunctorArgumentType & >(enterDefault));
NewActionBase *pDFAction = DepthFirstAction ::create();
NewActionBase *pDFSAction = DepthFirstStateAction::create();
NewActionBase *pPAction = PriorityAction ::create();
IntersectActor *pIActorDF = IntersectActor ::create();
IntersectActor *pIActorDFS = IntersectActor ::create();
IntersectActor *pIActorP = IntersectActor ::create();
pDFAction ->setStatistics(&statDF );
pDFSAction->setStatistics(&statDFS);
pPAction ->setStatistics(&statP );
// IntersectActor with DFS-Action does not need leave calls
pIActorDFS->setLeaveNodeFlag(false);
pDFAction ->addActor(pIActorDF );
pDFSAction->addActor(pIActorDFS);
pPAction ->addActor(pIActorP );
// create old action
IntersectAction *pIntAction = IntersectAction ::create();
// make sure bv are up to date
pScene->updateVolume();
SINFO << "-=< Intersect >=-" << endLog;
std::vector<Line>::iterator itRays = testRays.begin();
std::vector<Line>::iterator endRays = testRays.end ();
for(; itRays != endRays; ++itRays)
{
// DepthFirst
tStart = getSystemTime();
pIActorDF->setRay (*itRays);
pIActorDF->setMaxDistance(10000.0);
pIActorDF->reset ( );
pDFAction->apply(pScene);
tStop = getSystemTime();
tDFTotal += (tStop - tStart);
if(pIActorDF->getHit() == true)
{
IntersectResult result;
result._hit = true;
result._pObj = pIActorDF->getHitObject ();
result._tri = pIActorDF->getHitTriangleIndex();
result._dist = pIActorDF->getHitDistance ();
result._time = (tStop - tStart);
resultsDF.push_back(result);
}
else
{
IntersectResult result;
result._hit = false;
result._pObj = NullFC;
result._tri = -1;
result._dist = 0.0;
result._time = (tStop - tStart);
resultsDF.push_back(result);
}
std::string strStatDF;
statDF.putToString(strStatDF);
//SINFO << "stat DF: " << strStatDF << endLog;
// Depth First State
tStart = getSystemTime();
pIActorDFS->setRay (*itRays);
pIActorDFS->setMaxDistance(10000.0);
pIActorDFS->reset ( );
pDFSAction->apply(pScene);
tStop = getSystemTime();
tDFSTotal += (tStop - tStart);
if(pIActorDFS->getHit() == true)
{
IntersectResult result;
result._hit = true;
result._pObj = pIActorDFS->getHitObject ();
result._tri = pIActorDFS->getHitTriangleIndex();
result._dist = pIActorDFS->getHitDistance ();
result._time = (tStop - tStart);
resultsDFS.push_back(result);
}
else
{
IntersectResult result;
result._hit = false;
result._pObj = NullFC;
result._tri = -1;
result._dist = 0.0;
result._time = (tStop - tStart);
resultsDFS.push_back(result);
}
std::string strStatDFS;
statDFS.putToString(strStatDFS);
//SINFO << "stat DFS: " << strStatDFS << endLog;
// Priority
tStart = getSystemTime();
pIActorP->setRay (*itRays);
pIActorP->setMaxDistance(10000.0);
pIActorP->reset ( );
pPAction->apply(pScene);
tStop = getSystemTime();
tPTotal += (tStop - tStart);
if(pIActorP->getHit() == true)
{
IntersectResult result;
result._hit = true;
result._pObj = pIActorP->getHitObject ();
result._tri = pIActorP->getHitTriangleIndex();
result._dist = pIActorP->getHitDistance ();
result._time = (tStop - tStart);
resultsP.push_back(result);
}
else
{
IntersectResult result;
result._hit = false;
result._pObj = NullFC;
result._tri = -1;
result._dist = 0.0;
result._time = (tStop - tStart);
resultsP.push_back(result);
}
std::string strStatP;
statP.putToString(strStatP);
//SINFO << "stat P: " << strStatP << endLog;
// Old
tStart = getSystemTime();
pIntAction->setLine(*itRays, 100000);
pIntAction->apply (pScene );
tStop = getSystemTime();
tOTotal += (tStop - tStart);
if(pIntAction->didHit() == true)
{
IntersectResult result;
result._hit = true;
result._pObj = pIntAction->getHitObject ();
result._tri = pIntAction->getHitTriangle();
result._dist = pIntAction->getHitT ();
result._time = (tStop - tStart);
resultsO.push_back(result);
}
else
{
IntersectResult result;
result._hit = false;
result._pObj = NullFC;
result._tri = -1;
result._dist = 0.0;
result._time = (tStop - tStart);
resultsO.push_back(result);
}
}
UInt32 DFwins = 0;
UInt32 DFwinsHit = 0;
UInt32 DFwinsMiss = 0;
UInt32 DFSwins = 0;
UInt32 DFSwinsHit = 0;
UInt32 DFSwinsMiss = 0;
UInt32 Pwins = 0;
UInt32 PwinsHit = 0;
UInt32 PwinsMiss = 0;
UInt32 Owins = 0;
UInt32 OwinsHit = 0;
UInt32 OwinsMiss = 0;
UInt32 failCount = 0;
UInt32 passCount = 0;
UInt32 hitCount = 0;
UInt32 missCount = 0;
for(UInt32 i = 0; i < uiNumRays; ++i)
{
bool DFfastest = ((resultsDF [i]._time <= resultsDFS[i]._time) &&
(resultsDF [i]._time <= resultsP [i]._time) &&
(resultsDF [i]._time <= resultsO [i]._time) );
bool DFSfastest = ((resultsDFS[i]._time <= resultsDF [i]._time) &&
(resultsDFS[i]._time <= resultsP [i]._time) &&
(resultsDFS[i]._time <= resultsO [i]._time) );
bool Pfastest = ((resultsP [i]._time <= resultsDF [i]._time) &&
(resultsP [i]._time <= resultsDFS[i]._time) &&
(resultsP [i]._time <= resultsO [i]._time) );
bool Ofastest = ((resultsO [i]._time <= resultsDF [i]._time) &&
(resultsO [i]._time <= resultsDFS[i]._time) &&
(resultsO [i]._time <= resultsP [i]._time) );
if((resultsDF [i]._hit == resultsDFS[i]._hit) &&
(resultsDFS[i]._hit == resultsP [i]._hit) &&
(resultsP [i]._hit == resultsO [i]._hit) )
{
if((osgabs(resultsDF [i]._dist - resultsDFS[i]._dist) >= 0.001) ||
(osgabs(resultsDFS[i]._dist - resultsP [i]._dist) >= 0.001) ||
(osgabs(resultsP [i]._dist - resultsO [i]._dist) >= 0.001) ||
(osgabs(resultsO [i]._dist - resultsDF [i]._dist) >= 0.001) )
{
++failCount;
SINFO << "FAIL: df: " << resultsDF [i]._dist
<< " dfs: " << resultsDFS[i]._dist
<< " p: " << resultsP [i]._dist
<< " o: " << resultsO [i]._dist
<< endLog;
SINFO << "FAIL: df: " << resultsDF [i]._tri
<< " dfs: " << resultsDFS[i]._tri
<< " p: " << resultsP [i]._tri
<< " o: " << resultsO [i]._tri
<< endLog;
}
else
{
++passCount;
}
if(resultsDF[i]._hit == true)
{
++hitCount;
DFwinsHit = DFfastest ? DFwinsHit + 1 : DFwinsHit;
DFSwinsHit = DFSfastest ? DFSwinsHit + 1 : DFSwinsHit;
PwinsHit = Pfastest ? PwinsHit + 1 : PwinsHit;
OwinsHit = Ofastest ? OwinsHit + 1 : OwinsHit;
}
else
{
++missCount;
DFwinsMiss = DFfastest ? DFwinsMiss + 1 : DFwinsMiss;
DFSwinsMiss = DFSfastest ? DFSwinsMiss + 1 : DFSwinsMiss;
PwinsMiss = Pfastest ? PwinsMiss + 1 : PwinsMiss;
OwinsMiss = Ofastest ? OwinsMiss + 1 : OwinsMiss;
}
DFwins = DFfastest ? DFwins + 1 : DFwins;
DFSwins = DFSfastest ? DFSwins + 1 : DFSwins;
Pwins = Pfastest ? Pwins + 1 : Pwins;
Owins = Ofastest ? Owins + 1 : Owins;
}
else
{
++failCount;
}
//SINFO << i << " \t" << (DFfastest ? "D ->" : " ") << " hit: " << resultsDF [i]._hit << " time: " << resultsDF [i]._time << endLog;
//SINFO << " \t" << (DFSfastest ? "S ->" : " ") << " hit: " << resultsDFS[i]._hit << " time: " << resultsDFS[i]._time << endLog;
//SINFO << " \t" << (Pfastest ? "P ->" : " ") << " hit: " << resultsP [i]._hit << " time: " << resultsP [i]._time << endLog;
//SINFO << " \t" << (Ofastest ? "O ->" : " ") << " hit: " << resultsO [i]._hit << " time: " << resultsO [i]._time << endLog;
}
SINFO << " df total: " << tDFTotal << (tDFTotal < tDFSTotal && tDFTotal < tPTotal && tDFTotal < tOTotal ? " *" : " ")
<< " wins: " << DFwins << " (" << (static_cast<Real32>(DFwins) / static_cast<Real32>(passCount)) * 100.0 << "%)\t"
<< " wins on hit: " << DFwinsHit << " (" << (static_cast<Real32>(DFwinsHit) / static_cast<Real32>(hitCount )) * 100.0 << "%)\t"
<< " wins on miss: " << DFwinsMiss << " (" << (static_cast<Real32>(DFwinsMiss) / static_cast<Real32>(missCount)) * 100.0 << "%)"
<< endLog;
SINFO << " dfs total: " << tDFSTotal << (tDFSTotal < tDFTotal && tDFSTotal < tPTotal && tDFSTotal < tOTotal ? " *" : " ")
<< " wins: " << DFSwins << " (" << (static_cast<Real32>(DFSwins) / static_cast<Real32>(passCount)) * 100.0 << "%)\t"
<< " wins on hit: " << DFSwinsHit << " (" << (static_cast<Real32>(DFSwinsHit) / static_cast<Real32>(hitCount )) * 100.0 << "%)\t"
<< " wins on miss: " << DFSwinsMiss << " (" << (static_cast<Real32>(DFSwinsMiss) / static_cast<Real32>(missCount)) * 100.0 << "%)"
<< endLog;
SINFO << " p total: " << tPTotal << (tPTotal < tDFTotal && tPTotal < tDFSTotal && tPTotal < tOTotal ? " *" : " ")
<< " wins: " << Pwins << " (" << (static_cast<Real32>(Pwins) / static_cast<Real32>(passCount)) * 100.0 << "%)\t"
<< " wins on hit: " << PwinsHit << " (" << (static_cast<Real32>(PwinsHit) / static_cast<Real32>(hitCount )) * 100.0 << "%)\t"
<< " wins on miss: " << PwinsMiss << " (" << (static_cast<Real32>(PwinsMiss) / static_cast<Real32>(missCount)) * 100.0 << "%)"
<< endLog;
SINFO << " o total: " << tOTotal << (tOTotal < tDFTotal && tOTotal < tDFSTotal && tOTotal < tPTotal ? " *" : " ")
<< " wins: " << Owins << " (" << (static_cast<Real32>(Owins) / static_cast<Real32>(passCount)) * 100.0 << "%)\t"
<< " wins on hit: " << OwinsHit << " (" << (static_cast<Real32>(OwinsHit) / static_cast<Real32>(hitCount )) * 100.0 << "%)\t"
<< " wins on miss: " << OwinsMiss << " (" << (static_cast<Real32>(OwinsMiss) / static_cast<Real32>(missCount)) * 100.0 << "%)"
<< endLog;
SINFO << "pass: "******" fail: " << failCount
<< " hit: " << hitCount << " miss: " << missCount << endLog;
osgLogP->setLogLevel(LOG_NOTICE);
#if 0
// create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// tell the manager what to manage
mgr->setWindow(gwin );
mgr->setRoot (pRoot);
// show the whole scene
mgr->showAll();
// GLUT main loop
glutMainLoop();
#endif
return 0;
}
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;
}
// 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();
// Create the Scene
NodePtr scene = Node::create();
GroupPtr grcore = Group::create();
beginEditCP(scene);
scene->setCore(grcore);
// Add a Torus for background
scene->addChild(makeTorus(.2, 2, 16, 16));
// The actual creation of the functors is a little complicated.
// Mainly because the braindead M$ compiler has problems with, you have to
// explicitly create the functor for the right combination of return value
// type, number of arguments and argument types (values, pointers,
// references, etc.) and whether it is a function, a static method or an
// instance method.
// Given that the signatures of the draw and volumeUpdate functions are
// fixed, the three variants shown here should cover all the bases
// Add the DrawFunctor node for standard functions
NodePtr df = Node::create();
DrawFunctorCorePtr func = DrawFunctorCore::create();
beginEditCP(func);
func->setMaterial(getDefaultUnlitMaterial());
func->setDraw(
osgTypedFunctionFunctor1Ptr< Action::ResultE, DrawActionBase >(draw));
func->setVolumeUpdate(
osgTypedFunctionVoidFunctor1Ptr< Volume >(volUpdate));
endEditCP(func);
beginEditCP(df);
df->setCore(func);
endEditCP(df);
scene->addChild(df);
// Some transparent material
// Even though the DrawFunctorCore can do any kind of OpenGL functions, the
// Material of the Core is used to decide whether the node should be sorted
// and rendered last
SimpleMaterialPtr transmat = SimpleMaterial::create();
beginEditCP(transmat);
transmat->setTransparency(0.1); // The actual value is overriden by the draw
// anyway, but it has to be != 0 to be
// considered transparent
transmat->setLit(false);
endEditCP(transmat);
// Add the DrawFunctor node for static methods of a class
// Static methods are pretty much the same as functions
NodePtr dfsm = Node::create();
DrawFunctorCorePtr funcsm = DrawFunctorCore::create();
beginEditCP(funcsm);
funcsm->setMaterial(transmat);
funcsm->setDraw(
osgTypedFunctionFunctor1Ptr< Action::ResultE, DrawActionBase >(
&SWrapper::draw));
funcsm->setVolumeUpdate(
osgTypedFunctionVoidFunctor1Ptr< Volume >(&SWrapper::volUpdate));
endEditCP(funcsm);
beginEditCP(dfsm);
dfsm->setCore(funcsm);
endEditCP(dfsm);
scene->addChild(dfsm);
// Add the DrawFunctor node for methods
// The functor creation functions need the type of the object for which
// methods should be called.
Wrapper wrap(Color4f(0,1,0,.3));
NodePtr dfm = Node::create();
DrawFunctorCorePtr funcm = DrawFunctorCore::create();
beginEditCP(funcm);
funcm->setMaterial(transmat);
funcm->setDraw(
osgTypedMethodFunctor1ObjPtr< Action::ResultE, Wrapper, DrawActionBase >(
&wrap, &Wrapper::draw));
funcm->setVolumeUpdate(
osgTypedMethodVoidFunctor1ObjPtr< Wrapper, Volume >(
&wrap, &Wrapper::volUpdate));
endEditCP(funcm);
beginEditCP(dfm);
dfm->setCore(funcm);
endEditCP(dfm);
scene->addChild(dfm);
// Add a Sphere, just for fun
scene->addChild(makeLatLongSphere(16,16,.4));
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();
// GLUT main loop
glutMainLoop();
return 0;
}
// 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;
}