void display(void)
{
Real32 time = glutGet(GLUT_ELAPSED_TIME );
//create the Quaternion the describes the rotation of
//the planet around the sun
Quaternion planetRot = Quaternion(Vec3f(0,1,0), time/float(1000));
//now the rotation of the moon around the planet
//the division by 12 speeds up the rotation by 12 compared to the
//planet rotation
Quaternion moonRot = Quaternion(Vec3f(0,1,0), time/float(1000/12));
//generate the Matrices
Matrix p,m;
p.setIdentity();
m.setIdentity();
p.setRotate(planetRot);
m.setRotate(moonRot);
p.setTranslate(20,0,0);
m.setTranslate(8,0,0);
beginEditCP(planetTransform, Transform::MatrixFieldMask);
planetTransform->setMatrix(p);
endEditCP(planetTransform, Transform::MatrixFieldMask);
beginEditCP(moonTransform, Transform::MatrixFieldMask);
moonTransform->setMatrix(m);
endEditCP(moonTransform, Transform::MatrixFieldMask);
mgr->redraw();
}
virtual void keyPressed(const KeyEventPtr e)
{
if(e->getKey() == KeyEvent::KEY_Q && e->getModifiers() & KeyEvent::KEY_MODIFIER_CONTROL)
{
TutorialWindowEventProducer->closeWindow();
}
switch(e->getKey())
{
case KeyEvent::KEY_S:
statFlag = !statFlag;
mgr->setStatistics(statFlag);
break;
case KeyEvent::KEY_EQUALS:
{
Vec3f Translation;
Quaternion Rotation;
Vec3f Scale;
Quaternion ScaleOrient;
Matrix ThePointLightMat = ThePointLightBeaconTransform->getMatrix();
ThePointLightMat.getTransform(Translation,Rotation,Scale,ScaleOrient);
Translation = Translation + Vec3f(0.0,10.0,0.0);
ThePointLightMat.setTranslate(Translation);
beginEditCP(ThePointLightBeaconTransform);
ThePointLightBeaconTransform->setMatrix(ThePointLightMat);
endEditCP(ThePointLightBeaconTransform);
}
break;
case KeyEvent::KEY_MINUS:
{
Vec3f Translation;
Quaternion Rotation;
Vec3f Scale;
Quaternion ScaleOrient;
Matrix ThePointLightMat = ThePointLightBeaconTransform->getMatrix();
ThePointLightMat.getTransform(Translation,Rotation,Scale,ScaleOrient);
Translation = Translation + Vec3f(0.0,-10.0,0.0);
ThePointLightMat.setTranslate(Translation);
beginEditCP(ThePointLightBeaconTransform);
ThePointLightBeaconTransform->setMatrix(ThePointLightMat);
endEditCP(ThePointLightBeaconTransform);
}
break;
case KeyEvent::KEY_T:
beginEditCP(TheBlinnMat, BlinnMaterial::DiffuseTextureFieldMask);
endEditCP(TheBlinnMat, BlinnMaterial::DiffuseTextureFieldMask);
break;
}
}
void CFlystickTranslationResetTool::OnTrackingButtonReleased(Quaternion q, Vec3f position){
std::cout << "CFlystickTranslationResetTool::OnTrackingButtonReleased()" << std::endl;
if (! m_bToolActive){
std::cout << "tool is not active" << std::endl;
return;
}
if (m_posgPickedObjectNode == NullFC){
std::cout << "CFlystickTranslationResetTool: No object picked to reset translation" << std::endl;
return;
}
NodePtr parentingTransformNode = GetParentTransformNode(m_posgPickedObjectNode);
if (parentingTransformNode != NullFC){
std::cout << "CFlystickTranslationResetTool: Resetting translation!" << std::endl;
TransformPtr transform = TransformPtr::dcast(parentingTransformNode->getCore());
Matrix m = transform->getMatrix();
m.setTranslate(0.0, 0.0, 0.0);
beginEditCP(transform, Transform::MatrixFieldMask);{
transform->setMatrix(m);
};endEditCP(transform, Transform::MatrixFieldMask);
}else{
std::cout << "CFlystickTranslationResetTool: Found no parenting transform to reset!" << std::endl;
}
m_bToolActive = false;
}
void
display(void)
{
Matrix m1, m2;
m1.setRotate( tball.getRotation() );
m2.setTranslate( tball.getPosition() );
m1.mult( m2 );
cam_trans->editSFMatrix()->setValue( m1 );
// move the object
float t = glutGet(GLUT_ELAPSED_TIME);
Quaternion q;
q.setValueAsAxisDeg(0, 1, 0, t / 5000);
m1.setTransform(Vec3f(osgsin(t / 500.), 0, osgcos(t / 500)), q);
tr->setMatrix(m1);
if ( doRender )
win->render( ract );
else
win->draw( dact );
}
// redraw the window
void display(void)
{
Matrix m;
Real32 t = glutGet(GLUT_ELAPSED_TIME );
if(animate)
{
m.setTransform(Vec3f( osgsin(t / 1000.f),
osgcos(t / 1000.f),
osgsin(t / 1000.f)),
Quaternion( Vec3f(0,1,0),
t / 1000.f),
Vec3f( osgsin(t / 900.f)*.5+.7,
osgcos(t / 900.f)*.5+.7,
osgsin(t / 900.f)*.5+.7));
beginEditCP(trans1, Transform::MatrixFieldMask);
{
trans1->setMatrix(m);
}
endEditCP (trans1, Transform::MatrixFieldMask);
m.setTransform(Vec3f( osgsin(t / 500.f),
osgcos(t / 500.f),
osgsin(t / 500.f)),
Quaternion( Vec3f(0,1,0),
t / 1000.f),
Vec3f( osgsin(t / 400.f)*.5+.7,
osgcos(t / 400.f)*.5+.7,
osgsin(t / 400.f)*.5+.7));
beginEditCP(trans2, Transform::MatrixFieldMask);
{
trans2->setMatrix(m);
}
endEditCP (trans2, Transform::MatrixFieldMask);
}
// render
mgr->redraw();
// all done, swap
glutSwapBuffers();
}
//////////////////////////////////////////////////////////////////////////
//! build a box
//////////////////////////////////////////////////////////////////////////
void buildBox(void)
{
Vec3f Lengths(frand()*2.0+0.5, frand()*2.0+0.5, frand()*2.0+0.5);
Matrix m;
//create OpenSG mesh
GeometryPtr box;
NodePtr boxNode = makeBox(Lengths.x(), Lengths.y(), Lengths.z(), 1, 1, 1);
box = GeometryPtr::dcast(boxNode->getCore());
SimpleMaterialPtr box_mat = SimpleMaterial::create();
beginEditCP(box_mat);
box_mat->setAmbient(Color3f(0.0,0.0,0.0));
box_mat->setDiffuse(Color3f(0.0,1.0 ,0.0));
endEditCP(box_mat);
beginEditCP(box, Geometry::MaterialFieldMask);
box->setMaterial(box_mat);
endEditCP(box, Geometry::MaterialFieldMask);
TransformPtr boxTrans;
NodePtr boxTransNode = makeCoredNode<Transform>(&boxTrans);
m.setIdentity();
Real32 randX = frand()*10.0-5.0;
Real32 randY = frand()*10.0-5.0;
m.setTranslate(randX, randY, 10.0);
beginEditCP(boxTrans, Transform::MatrixFieldMask);
boxTrans->setMatrix(m);
endEditCP(boxTrans, Transform::MatrixFieldMask);
//create ODE data
PhysicsBodyPtr boxBody = PhysicsBody::create(physicsWorld);
beginEditCP(boxBody, PhysicsBody::PositionFieldMask);
boxBody->setPosition(Vec3f(randX, randY, 10.0));
endEditCP(boxBody, PhysicsBody::PositionFieldMask);
boxBody->setBoxMass(1.0, Lengths.x(), Lengths.y(), Lengths.z());
PhysicsBoxGeomPtr boxGeom = PhysicsBoxGeom::create();
beginEditCP(boxGeom, PhysicsBoxGeom::BodyFieldMask | PhysicsBoxGeom::SpaceFieldMask | PhysicsBoxGeom::LengthsFieldMask | PhysicsBoxGeom::CategoryBitsFieldMask);
boxGeom->setBody(boxBody);
boxGeom->setSpace(physicsSpace);
boxGeom->setLengths(Lengths);
boxGeom->setCategoryBits(BoxCategory);
endEditCP(boxGeom, PhysicsBoxGeom::BodyFieldMask | PhysicsBoxGeom::SpaceFieldMask | PhysicsBoxGeom::LengthsFieldMask | PhysicsBoxGeom::CategoryBitsFieldMask);
//add attachments
beginEditCP(boxNode, Node::AttachmentsFieldMask);
boxNode->addAttachment(boxGeom);
endEditCP(boxNode, Node::AttachmentsFieldMask);
beginEditCP(boxTransNode, Node::AttachmentsFieldMask | Node::ChildrenFieldMask);
boxTransNode->addAttachment(boxBody);
boxTransNode->addChild(boxNode);
endEditCP(boxTransNode, Node::AttachmentsFieldMask | Node::ChildrenFieldMask);
//add to SceneGraph
beginEditCP(spaceGroupNode, Node::ChildrenFieldMask);
spaceGroupNode->addChild(boxTransNode);
endEditCP(spaceGroupNode, Node::ChildrenFieldMask);
}
//////////////////////////////////////////////////////////////////////////
//! build a sphere
//////////////////////////////////////////////////////////////////////////
void buildSphere(void)
{
Real32 Radius(frand()*1.5+0.2);
Matrix m;
//create OpenSG mesh
GeometryPtr sphere;
NodePtr sphereNode = makeSphere(2, Radius);
sphere = GeometryPtr::dcast(sphereNode->getCore());
SimpleMaterialPtr sphere_mat = SimpleMaterial::create();
beginEditCP(sphere_mat);
sphere_mat->setAmbient(Color3f(0.0,0.0,0.0));
sphere_mat->setDiffuse(Color3f(0.0,0.0,1.0));
endEditCP(sphere_mat);
beginEditCP(sphere, Geometry::MaterialFieldMask);
sphere->setMaterial(sphere_mat);
endEditCP(sphere);
TransformPtr sphereTrans;
NodePtr sphereTransNode = makeCoredNode<Transform>(&sphereTrans);
m.setIdentity();
Real32 randX = frand()*10.0-5.0;
Real32 randY = frand()*10.0-5.0;
m.setTranslate(randX, randY, 10.0);
beginEditCP(sphereTrans, Transform::MatrixFieldMask);
sphereTrans->setMatrix(m);
endEditCP(sphereTrans);
//create ODE data
PhysicsBodyPtr sphereBody = PhysicsBody::create(physicsWorld);
beginEditCP(sphereBody, PhysicsBody::PositionFieldMask | PhysicsBody::AngularDampingFieldMask);
sphereBody->setPosition(Vec3f(randX, randY, 10.0));
sphereBody->setAngularDamping(0.0001);
endEditCP(sphereBody, PhysicsBody::PositionFieldMask | PhysicsBody::AngularDampingFieldMask);
sphereBody->setSphereMass(0.4,Radius);
PhysicsSphereGeomPtr sphereGeom = PhysicsSphereGeom::create();
beginEditCP(sphereGeom, PhysicsSphereGeom::BodyFieldMask | PhysicsSphereGeom::SpaceFieldMask | PhysicsSphereGeom::RadiusFieldMask | PhysicsSphereGeom::CategoryBitsFieldMask);
sphereGeom->setBody(sphereBody);
sphereGeom->setSpace(physicsSpace);
sphereGeom->setRadius(Radius);
sphereGeom->setCategoryBits(SphereCategory);
endEditCP(sphereGeom, PhysicsSphereGeom::BodyFieldMask | PhysicsSphereGeom::SpaceFieldMask | PhysicsSphereGeom::RadiusFieldMask | PhysicsSphereGeom::CategoryBitsFieldMask);
//add attachments
beginEditCP(sphereNode, Node::AttachmentsFieldMask);
sphereNode->addAttachment(sphereGeom);
endEditCP(sphereNode);
beginEditCP(sphereTransNode, Node::AttachmentsFieldMask | Node::ChildrenFieldMask);
sphereTransNode->addAttachment(sphereBody);
sphereTransNode->addChild(sphereNode);
endEditCP(sphereTransNode);
//add to SceneGraph
beginEditCP(spaceGroupNode, Node::ChildrenFieldMask);
spaceGroupNode->addChild(sphereTransNode);
endEditCP(spaceGroupNode);
}
void Particles::createSymmetricEmitterLine(Vec3f dir, Real32 dist, UInt16 num)
{
NodePtr localTransNode;
TransformPtr localTrans;
Matrix m;
dir.normalize();
for (int i = 1; i < num; i++)
{
localTransNode = Node::create();
localTrans = Transform::create();
m.setIdentity();
m.setTranslate(dir*(i*dist));
beginEditCP(localTrans, Transform::MatrixFieldMask);
localTrans->setMatrix(m);
endEditCP(localTrans, Transform::MatrixFieldMask);
beginEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
localTransNode->setCore(localTrans);
localTransNode->addChild(cloneTree(particleNode));
endEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
beginEditCP(particleTransNode, Node::ChildrenFieldMask);
particleTransNode->addChild(localTransNode);
endEditCP(particleTransNode, Node::ChildrenFieldMask);
localTransNode = Node::create();
localTrans = Transform::create();
m.setIdentity();
m.setTranslate(dir*(-i*dist));
beginEditCP(localTrans, Transform::MatrixFieldMask);
localTrans->setMatrix(m);
endEditCP(localTrans, Transform::MatrixFieldMask);
beginEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
localTransNode->setCore(localTrans);
localTransNode->addChild(cloneTree(particleNode));
endEditCP(localTransNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
beginEditCP(particleTransNode, Node::ChildrenFieldMask);
particleTransNode->addChild(localTransNode);
endEditCP(particleTransNode, Node::ChildrenFieldMask);
} // for
} // createSymmetricEmitterLine
virtual void update(const UpdateEventPtr e)
{
Real32 RotateRate(1.0f);
Matrix RotMat;
RotMat.setRotate(Quaternion(Vec3f(0.0,1.0,0.0),RotateRate*e->getElapsedTime()));
Matrix NewMat(RootTransformCore->getMatrix());
NewMat.multLeft(RotMat);
beginEditCP(RootTransformCore, Transform::MatrixFieldMask);
RootTransformCore->setMatrix(NewMat);
endEditCP(RootTransformCore, Transform::MatrixFieldMask);
}
// redraw the window
void display( void )
{
Matrix m;
Real32 t = glutGet(GLUT_ELAPSED_TIME );
m.setTransform(Vec3f(0, .9, 0),
Quaternion( Vec3f(1,1,0), osgsin(t / 1000.f) / 2.f));
// set the transform's matrix
beginEditCP(trans, Transform::MatrixFieldMask);
{
trans->setMatrix(m);
}
endEditCP (trans, Transform::MatrixFieldMask);
mgr->redraw();
}
void Particles::duplicate(Vec3f deltaPos, Quaternion deltaRot)
{
NodePtr copyTransNode = cloneTree(particleTransNode);
TransformPtr copyTrans = Transform::create();
Matrix m;
m.setIdentity();
m.setRotate(deltaRot);
m.setTranslate(deltaPos);
beginEditCP(copyTrans);
copyTrans->setMatrix(m);
endEditCP(copyTrans);
beginEditCP(copyTransNode);
copyTransNode->setCore(copyTrans);
endEditCP(copyTransNode);
beginEditCP(particleTransNode);
particleTransNode->addChild(copyTransNode);
endEditCP(particleTransNode);
} // duplicate
void SkyBackgroundPluginForm::setLightSettings( LightPtr light, LightSettingsHandler &handler )
{
beginEditCP(light);
light->setAmbient(handler.ambient);
light->setDiffuse(handler.diffuse);
light->setSpecular(handler.specular);
endEditCP(light);
NodePtr beacon = light->getBeacon();
if (beacon == NullFC)
{
TransformPtr beaconTransform = Transform::create();
beacon = Node::create();
beginEditCP(beacon);
beacon->setCore(beaconTransform);
endEditCP(beacon);
}
TransformPtr transform = TransformPtr::dcast(beacon->getCore());
if (transform == NullFC)
{
TransformPtr beaconTransform = Transform::create();
beginEditCP(beacon);
beacon->setCore(beaconTransform);
endEditCP(beacon);
transform = beaconTransform;
}
Matrix m;
float transFactor = LightDistanceExSlider->value();
Vec3f translate = Vec3f(handler.direction.x() * transFactor, handler.direction.y() * transFactor,
handler.direction.z() * transFactor);
if (zUpCheckBox->isChecked())
m.setTranslate(translate.x(), translate.y(), translate.z());
else
m.setTranslate(translate.x(), translate.z(), -translate.y());
beginEditCP(transform);
transform->setMatrix(m);
endEditCP(transform);
}
// Initialize GLUT & OpenSG and set up the scene
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindowEventProducer = createDefaultWindowEventProducer();
WindowPtr MainWindow = TutorialWindowEventProducer->initWindow();
TutorialWindowEventProducer->setDisplayCallback(display);
TutorialWindowEventProducer->setReshapeCallback(reshape);
//Add Window Listener
TutorialKeyListener TheKeyListener;
TutorialWindowEventProducer->addKeyListener(&TheKeyListener);
TutorialMouseListener TheTutorialMouseListener;
TutorialMouseMotionListener TheTutorialMouseMotionListener;
TutorialWindowEventProducer->addMouseListener(&TheTutorialMouseListener);
TutorialWindowEventProducer->addMouseMotionListener(&TheTutorialMouseMotionListener);
// Create the SimpleSceneManager helper
mgr = new SimpleSceneManager;
// Tell the Manager what to manage
mgr->setWindow(TutorialWindowEventProducer->getWindow());
//Make a SphereNode for the point light
LambertMaterialPtr TheLightMat = LambertMaterial::create();
beginEditCP(TheLightMat, LambertMaterial::IncandescenceFieldMask);
TheLightMat->setIncandescence(Color3f(1.0,1.0,1.0));
endEditCP(TheLightMat, LambertMaterial::IncandescenceFieldMask);
GeometryPtr LightSphereGeo = makeSphereGeo(2,2.0);
beginEditCP(LightSphereGeo, Geometry::MaterialFieldMask);
LightSphereGeo->setMaterial(TheLightMat);
endEditCP (LightSphereGeo, Geometry::MaterialFieldMask);
NodePtr LightSphereNode = Node::create();
beginEditCP(LightSphereNode, Node::CoreFieldMask);
LightSphereNode->setCore(LightSphereGeo);
endEditCP (LightSphereNode, Node::CoreFieldMask);
//Create the beacon for the Point Light
Matrix ThePointLightMat;
ThePointLightMat.setTranslate(Vec3f(0.0,100.0,0.0));
ThePointLightBeaconTransform = Transform::create();
beginEditCP(ThePointLightBeaconTransform);
ThePointLightBeaconTransform->setMatrix(ThePointLightMat);
endEditCP(ThePointLightBeaconTransform);
NodePtr ThePointLightBeaconNode = Node::create();
beginEditCP(ThePointLightBeaconNode);
ThePointLightBeaconNode->setCore(ThePointLightBeaconTransform);
ThePointLightBeaconNode->addChild(LightSphereNode);
endEditCP(ThePointLightBeaconNode);
//Set the light properties desired
PointLightPtr ThePointLight = PointLight::create();
beginEditCP(ThePointLight);
ThePointLight->setAmbient(0.3,0.3,0.3,0.3);
ThePointLight->setDiffuse(1.0,1.0,1.0,1.0);
ThePointLight->setSpecular(1.0,1.0,1.0,1.0);
ThePointLight->setBeacon(ThePointLightBeaconNode);
endEditCP(ThePointLight);
NodePtr ThePointLightNode = Node::create();
beginEditCP(ThePointLightNode);
ThePointLightNode->setCore(ThePointLight);
endEditCP(ThePointLightNode);
//Set the light properties desired
SpotLightPtr TheSpotLight = SpotLight::create();
beginEditCP(TheSpotLight);
TheSpotLight->setAmbient(0.3,0.3,0.3,0.3);
TheSpotLight->setDiffuse(1.0,1.0,1.0,1.0);
TheSpotLight->setSpecular(1.0,1.0,1.0,1.0);
TheSpotLight->setBeacon(ThePointLightBeaconNode);
TheSpotLight->setDirection(Vec3f(0.0,-1.0,0.0));
TheSpotLight->setSpotExponent(5.0);
TheSpotLight->setSpotCutOff(1.1);
endEditCP(TheSpotLight);
NodePtr TheSpotLightNode = Node::create();
beginEditCP(TheSpotLightNode);
TheSpotLightNode->setCore(TheSpotLight);
endEditCP(TheSpotLightNode);
//Load in the Heightmap Image
ImagePtr PerlinNoiseImage = createPerlinImage(Vec2s(256,256), Vec2f(10.0f,10.0f),0.5f,1.0f,Vec2f(0.0f,0.0f),0.25f,6,PERLIN_INTERPOLATE_COSINE,false,Image::OSG_L_PF, Image::OSG_UINT8_IMAGEDATA);
TextureChunkPtr TheTextureChunk = TextureChunk::create();
beginEditCP(TheTextureChunk);
TheTextureChunk->setImage(PerlinNoiseImage);
endEditCP(TheTextureChunk);
//Lambert Material
LambertMaterialPtr TheLambertMat = LambertMaterial::create();
beginEditCP(TheLambertMat, LambertMaterial::ColorFieldMask | LambertMaterial::AmbientColorFieldMask | LambertMaterial::DiffuseFieldMask
| LambertMaterial::NumLightsFieldMask | LambertMaterial::DiffuseTextureFieldMask);
TheLambertMat->setColor(Color3f(0.0,1.0,0.0));
TheLambertMat->setAmbientColor(Color3f(1.0,0.0,0.0));
TheLambertMat->setDiffuse(0.5);
TheLambertMat->setNumLights(1);
endEditCP(TheLambertMat, LambertMaterial::ColorFieldMask | LambertMaterial::AmbientColorFieldMask | LambertMaterial::DiffuseFieldMask
| LambertMaterial::NumLightsFieldMask | LambertMaterial::DiffuseTextureFieldMask);
//Blinn Material
TheBlinnMat = BlinnMaterial::create();
beginEditCP(TheBlinnMat, BlinnMaterial::ColorFieldMask | BlinnMaterial::AmbientColorFieldMask | BlinnMaterial::DiffuseFieldMask
| BlinnMaterial::SpecularColorFieldMask | BlinnMaterial::SpecularEccentricityFieldMask | BlinnMaterial::SpecularRolloffFieldMask | BlinnMaterial::DiffuseTextureFieldMask);
TheBlinnMat->setColor(Color3f(1.0,0.0,0.0));
TheBlinnMat->setAmbientColor(Color3f(0.0,0.0,0.0));
TheBlinnMat->setSpecularColor(Color3f(0.0,0.0,1.0));
TheBlinnMat->setSpecularEccentricity(0.35);
TheBlinnMat->setSpecularRolloff(0.85);
TheBlinnMat->setDiffuse(0.65);
TheBlinnMat->setDiffuseTexture(TheTextureChunk);
endEditCP(TheBlinnMat, BlinnMaterial::ColorFieldMask | BlinnMaterial::AmbientColorFieldMask | BlinnMaterial::DiffuseFieldMask
| BlinnMaterial::SpecularColorFieldMask | BlinnMaterial::SpecularEccentricityFieldMask | BlinnMaterial::SpecularRolloffFieldMask | BlinnMaterial::DiffuseTextureFieldMask);
//Phong Material
Phong2MaterialPtr ThePhongMat = Phong2Material::create();
beginEditCP(ThePhongMat, Phong2Material::ColorFieldMask | Phong2Material::AmbientColorFieldMask | Phong2Material::DiffuseFieldMask
| Phong2Material::SpecularColorFieldMask | Phong2Material::SpecularCosinePowerFieldMask);
ThePhongMat->setColor(Color3f(1.0,0.0,0.0));
ThePhongMat->setAmbientColor(Color3f(0.0,0.0,0.0));
ThePhongMat->setSpecularColor(Color3f(0.0,0.0,1.0));
ThePhongMat->setSpecularCosinePower(50.0);
ThePhongMat->setDiffuse(0.65);
endEditCP(ThePhongMat, Phong2Material::ColorFieldMask | Phong2Material::AmbientColorFieldMask | Phong2Material::DiffuseFieldMask
| Phong2Material::SpecularColorFieldMask | Phong2Material::SpecularCosinePowerFieldMask);
//Anisotropic Material
AnisotropicMaterialPtr TheAnisotropicMat = AnisotropicMaterial::create();
beginEditCP(TheAnisotropicMat, AnisotropicMaterial::ColorFieldMask | AnisotropicMaterial::AmbientColorFieldMask | AnisotropicMaterial::DiffuseFieldMask
| AnisotropicMaterial::SpecularColorFieldMask | AnisotropicMaterial::SpecularRoughnessFieldMask | AnisotropicMaterial::SpecularFresnelIndexFieldMask
| AnisotropicMaterial::SpecularSpreadXFieldMask | AnisotropicMaterial::SpecularSpreadYFieldMask);
TheAnisotropicMat->setColor(Color3f(1.0,0.0,0.0));
TheAnisotropicMat->setAmbientColor(Color3f(0.0,0.0,0.0));
TheAnisotropicMat->setDiffuse(0.65);
TheAnisotropicMat->setSpecularColor(Color3f(0.0,0.0,1.0));
TheAnisotropicMat->setSpecularRoughness(32.0);
TheAnisotropicMat->setSpecularFresnelIndex(0.85);
TheAnisotropicMat->setSpecularSpreadX(1.0);
TheAnisotropicMat->setSpecularSpreadY(1.0);
endEditCP(TheAnisotropicMat, AnisotropicMaterial::ColorFieldMask | AnisotropicMaterial::AmbientColorFieldMask | AnisotropicMaterial::DiffuseFieldMask
| AnisotropicMaterial::SpecularColorFieldMask | AnisotropicMaterial::SpecularRoughnessFieldMask | AnisotropicMaterial::SpecularFresnelIndexFieldMask
| AnisotropicMaterial::SpecularSpreadXFieldMask | AnisotropicMaterial::SpecularSpreadYFieldMask);
PointChunkPtr TempChunk = PointChunk::create();
//addRefCP(TempChunk);
//Anisotropic Material
TheRampMat = RampMaterial::create();
beginEditCP(TheRampMat);
//Color
TheRampMat->setRampSource(RampMaterial::RAMP_SOURCE_FACING_ANGLE);
TheRampMat->getColors().push_back(Color3f(1.0,0.0,0.0));
TheRampMat->getColorPositions().push_back(0.4);
TheRampMat->getColorInterpolations().push_back(RampMaterial::RAMP_INTERPOLATION_SMOOTH);
TheRampMat->getColors().push_back(Color3f(0.0,1.0,0.0));
TheRampMat->getColorPositions().push_back(1.0);
//Transparency
TheRampMat->getTransparencies().push_back(Color3f(0.0,0.0,0.0));
TheRampMat->getTransparencyPositions().push_back(0.83);
TheRampMat->getTransparencyInterpolations().push_back(RampMaterial::RAMP_INTERPOLATION_SMOOTH);
TheRampMat->getTransparencies().push_back(Color3f(1.0,1.0,1.0));
TheRampMat->getTransparencyPositions().push_back(1.0);
TheRampMat->setAmbientColor(Color3f(0.0,0.0,0.0));
TheRampMat->setSpecularity(1.0);
TheRampMat->setSpecularEccentricity(0.8);
TheRampMat->getSpecularColors().push_back(Color3f(1.0,1.0,1.0));
TheRampMat->getSpecularColorPositions().push_back(0.95);
TheRampMat->getSpecularColorInterpolations().push_back(RampMaterial::RAMP_INTERPOLATION_SMOOTH);
TheRampMat->getSpecularColors().push_back(Color3f(0.0,0.0,1.0));
TheRampMat->getSpecularColorPositions().push_back(1.0);
TheRampMat->getSpecularRolloffs().push_back(1.0);
TheRampMat->getExtraChunks().push_back(TempChunk);
endEditCP(TheRampMat);
//Make the Heightmap Geometry
HeightmapGeometryPtr TutorialHeightmapGeo = HeightmapGeometry::create();
beginEditCP(TutorialHeightmapGeo, HeightmapGeometry::HeightImageFieldMask | HeightmapGeometry::DimensionsFieldMask | HeightmapGeometry::SegmentsFieldMask | HeightmapGeometry::ScaleFieldMask | HeightmapGeometry::OffsetFieldMask | HeightmapGeometry::MaterialFieldMask);
TutorialHeightmapGeo->setHeightImage(PerlinNoiseImage);
TutorialHeightmapGeo->setDimensions(Vec2f(200.0,200.0));
TutorialHeightmapGeo->setSegments(Vec2f(150.0,150.0));
TutorialHeightmapGeo->setScale(30.0);
TutorialHeightmapGeo->setOffset(0.0);
TutorialHeightmapGeo->setMaterial( TheBlinnMat );
endEditCP(TutorialHeightmapGeo, HeightmapGeometry::HeightImageFieldMask | HeightmapGeometry::DimensionsFieldMask | HeightmapGeometry::SegmentsFieldMask | HeightmapGeometry::ScaleFieldMask | HeightmapGeometry::OffsetFieldMask | HeightmapGeometry::MaterialFieldMask);
calcVertexNormals(TutorialHeightmapGeo);
calcVertexTangents(TutorialHeightmapGeo,0,Geometry::TexCoords7FieldId, Geometry::TexCoords6FieldId);
//Make the Heightmap Node
NodePtr TutorialHeightmapNode = Node::create();
beginEditCP(TutorialHeightmapNode, Node::CoreFieldMask);
TutorialHeightmapNode->setCore(TutorialHeightmapGeo);
endEditCP (TutorialHeightmapNode, Node::CoreFieldMask);
//Make a SphereNode
GeometryPtr SphereGeo = makeSphereGeo(2,50.0);
//GeometryPtr SphereGeo = makeCylinderGeo(50,20.0, 16,true,true,true);
beginEditCP(SphereGeo, Geometry::MaterialFieldMask);
SphereGeo->setMaterial(TheLambertMat);
endEditCP (SphereGeo, Geometry::MaterialFieldMask);
calcVertexNormals(SphereGeo);
calcVertexTangents(SphereGeo,0,Geometry::TexCoords7FieldId, Geometry::TexCoords6FieldId);
NodePtr SphereNode = Node::create();
beginEditCP(SphereNode, Node::CoreFieldMask);
SphereNode->setCore(SphereGeo);
endEditCP (SphereNode, Node::CoreFieldMask);
//Make Main Scene Node
NodePtr scene = Node::create();
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
scene->setCore(Group::create());
// add the torus as a child
scene->addChild(TutorialHeightmapNode);
//scene->addChild(SphereNode);
scene->addChild(ThePointLightBeaconNode);
endEditCP (scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
//Add the scene to the Light Nodes
//beginEditCP(ThePointLightNode, Node::ChildrenFieldMask);
//ThePointLightNode->addChild(scene);
//endEditCP(ThePointLightNode, Node::ChildrenFieldMask);
//// tell the manager what to manage
//mgr->setRoot (ThePointLightNode);
beginEditCP(TheSpotLightNode, Node::ChildrenFieldMask);
TheSpotLightNode->addChild(scene);
endEditCP(TheSpotLightNode, Node::ChildrenFieldMask);
// tell the manager what to manage
mgr->setRoot (TheSpotLightNode);
mgr->turnHeadlightOff();
// show the whole scene
mgr->showAll();
//Open Window
Vec2f WinSize(TutorialWindowEventProducer->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindowEventProducer->getDesktopSize() - WinSize) *0.5);
TutorialWindowEventProducer->openWindow(WinPos,
WinSize,
"06Heightmap");
//Main Loop
TutorialWindowEventProducer->mainLoop();
osgExit();
return 0;
}
void updateScene()
{
statfg->editCollector().getElem(majorAlignDesc)->set(alignmentToString(layoutParam.majorAlignment));
statfg->editCollector().getElem(minorAlignDesc)->set(alignmentToString(layoutParam.minorAlignment));
statfg->editCollector().getElem(dirDesc)->set(layoutParam.horizontal ? "Horizontal" : "Vertical");
statfg->editCollector().getElem(horiDirDesc)->set(layoutParam.leftToRight ? "Left to right" : "Right to left");
statfg->editCollector().getElem(vertDirDesc)->set(layoutParam.topToBottom ? "Top to bottom" : "Bottom to top");
if(face == NULL)
return;
// Put it all together into a Geometry NodeCore.
TextLayoutResult layoutResult;
Real32 scale = 2.f;
face->layout(lines, layoutParam, layoutResult);
#if 0
GeometryPtr geo = Geometry::create();
face->fillGeo(geo, layoutResult, scale);
NodePtr textNode = Node::create();
beginEditCP(textNode, Node::CoreFieldMask);
{
textNode->setCore(geo);
}
endEditCP(textNode, Node::CoreFieldMask);
#else
NodePtr textNode = face->makeNode(layoutResult, scale);
GeometryPtr geo = GeometryPtr::dcast(textNode->getCore());
#endif
NodePtr transNodePtr = Node::create();
TransformPtr transPtr = Transform::create();
Matrix transMatrix;
transMatrix.setTranslate(0.f, 0.f, -0.03f);
beginEditCP(transPtr);
{
transPtr->setMatrix(transMatrix);
}
endEditCP(transPtr);
beginEditCP(transNodePtr, Node::CoreFieldMask | Node::ChildrenFieldMask);
{
transNodePtr->setCore(transPtr);
transNodePtr->addChild(textNode);
}
endEditCP(transNodePtr, Node::CoreFieldMask | Node::ChildrenFieldMask);
ImagePtr imagePtr = face->getTexture();
TextureChunkPtr texChunk = TextureChunk::create();
beginEditCP(texChunk);
{
texChunk->setImage(imagePtr);
texChunk->setWrapS(GL_CLAMP);
texChunk->setWrapT(GL_CLAMP);
texChunk->setMagFilter(GL_NEAREST);
texChunk->setMinFilter(GL_NEAREST);
texChunk->setEnvMode(GL_MODULATE);
}
endEditCP(texChunk);
MaterialChunkPtr matChunk = MaterialChunk::create();
beginEditCP(matChunk);
{
matChunk->setAmbient(Color4f(1.f, 1.f, 1.f, 1.f));
matChunk->setDiffuse(Color4f(1.f, 1.f, 1.f, 1.f));
matChunk->setEmission(Color4f(0.f, 0.f, 0.f, 1.f));
matChunk->setSpecular(Color4f(0.f, 0.f, 0.f, 1.f));
matChunk->setShininess(0);
}
endEditCP(matChunk);
BlendChunkPtr blendChunk = BlendChunk::create();
beginEditCP(blendChunk);
{
blendChunk->setSrcFactor(GL_SRC_ALPHA);
blendChunk->setDestFactor(GL_ONE_MINUS_SRC_ALPHA);
}
endEditCP(blendChunk);
ChunkMaterialPtr m = ChunkMaterial::create();
beginEditCP(m);
{
m->addChunk(texChunk);
m->addChunk(matChunk);
m->addChunk(blendChunk);
}
endEditCP(m);
beginEditCP(geo, Geometry::MaterialFieldMask);
{
geo->setMaterial(m);
}
endEditCP(geo, Geometry::MaterialFieldMask);
beginEditCP(scene, Node::ChildrenFieldMask);
{
scene->editMFChildren()->clear();
scene->addChild(createCoordinateCross());
scene->addChild(createMetrics(face, scale, layoutParam, layoutResult));
scene->addChild(transNodePtr);
}
endEditCP(scene, Node::ChildrenFieldMask);
mgr->showAll();
glutPostRedisplay();
}
int main(int argc, char **argv)
{
// OSG init
osgInit(argc,argv);
// Set up Window
TutorialWindowEventProducer = createDefaultWindowEventProducer();
WindowPtr MainWindow = TutorialWindowEventProducer->initWindow();
TutorialWindowEventProducer->setDisplayCallback(display);
TutorialWindowEventProducer->setReshapeCallback(reshape);
TutorialKeyListener TheKeyListener;
TutorialWindowEventProducer->addKeyListener(&TheKeyListener);
TutorialUpdateListener TheUpdateListener;
TutorialWindowEventProducer->addUpdateListener(&TheUpdateListener);
// Create the SceneManager
mgr = new SceneManager;
// Tell the Manager what to manage
mgr->setWindow(MainWindow);
// Make Torus Node (creates Torus in background of scene)
NodePtr TorusGeometryNode = makeTorus(.5, 2, 16, 16);
// Make Torus Node (creates Torus in background of scene)
NodePtr BoxGeometryNode = makeBox(0.5,0.5,0.5,50,2,2);
//Set the Camera Beacon Node
Matrix Offset;
//Offset.setTranslate(0.0f,2.5f,6.0f);
Offset.setTranslate(0.0f,0.0,6.0f);
CameraBeaconTransform = Transform::create();
beginEditCP(CameraBeaconTransform, Transform::MatrixFieldMask);
CameraBeaconTransform->setMatrix(Offset);
endEditCP(CameraBeaconTransform, Transform::MatrixFieldMask);
NodePtr CameraBeaconNode = Node::create();
beginEditCP(CameraBeaconNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
CameraBeaconNode->setCore(CameraBeaconTransform);
endEditCP(CameraBeaconNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
//Set the Box Transform Node
BoxTransform = Transform::create();
NodePtr BoxNode = Node::create();
beginEditCP(BoxNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
BoxNode->setCore(BoxTransform);
BoxNode->addChild(BoxGeometryNode);
BoxNode->addChild(CameraBeaconNode);
endEditCP(BoxNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
// Make Main Scene Node and add the Torus
NodePtr scene = osg::Node::create();
beginEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
scene->setCore(osg::Group::create());
scene->addChild(TorusGeometryNode);
scene->addChild(BoxNode);
endEditCP(scene, Node::CoreFieldMask | Node::ChildrenFieldMask);
//Set the Root node to the Scene Manager
mgr->setRoot(scene);
//The perspective decoratee camera
CameraPtr PCamera = PerspectiveCamera::create();
beginEditCP(PerspectiveCameraPtr::dcast(PCamera));
PerspectiveCameraPtr::dcast(PCamera)->setBeacon(CameraBeaconNode);
PerspectiveCameraPtr::dcast(PCamera)->setFov (deg2rad(60.f));
PerspectiveCameraPtr::dcast(PCamera)->setNear (0.1f);
PerspectiveCameraPtr::dcast(PCamera)->setFar (10000.f);
endEditCP(PerspectiveCameraPtr::dcast(PCamera));
//Create the Rubber band Camera
Vec3f PositionCoefficients(0.1,1.5,1.5);
Vec3f OrientationCoefficients(0.1,2.5,2.5);
RubberCamera = RubberBandCamera::create();
beginEditCP(RubberCamera, RubberBandCamera::DecorateeFieldMask | RubberBandCamera::BeaconFieldMask | RubberBandCamera::PositionCoefficientsFieldMask | RubberBandCamera::OrientationCoefficientsFieldMask);
RubberCamera->setDecoratee(PCamera);
RubberCamera->setBeacon(CameraBeaconNode);
RubberCamera->setPositionCoefficients(PositionCoefficients);
RubberCamera->setOrientationCoefficients(OrientationCoefficients);
endEditCP(RubberCamera, RubberBandCamera::DecorateeFieldMask | RubberBandCamera::BeaconFieldMask | RubberBandCamera::PositionCoefficientsFieldMask | RubberBandCamera::OrientationCoefficientsFieldMask);
RubberCamera->setToBeacon();
mgr->setCamera(RubberCamera);
// Show the whole Scene
//mgr->showAll();
//Open Window
Vec2f WinSize(TutorialWindowEventProducer->getDesktopSize() * 0.85f);
Pnt2f WinPos((TutorialWindowEventProducer->getDesktopSize() - WinSize) *0.5);
TutorialWindowEventProducer->openWindow(WinPos,
WinSize,
"01RubberBandCamera");
//Enter main Loop
TutorialWindowEventProducer->mainLoop();
osgExit();
return 0;
}
virtual void update(const UpdateEventPtr e)
{
RubberCamera->update(e->getElapsedTime());
float TranslateAmount(1.0f);
float RotateAmount(1.0f);
WindowEventProducerPtr TheEventProducer(WindowEventProducerPtr::dcast(e->getSource()));
if(TheEventProducer->getKeyState(KeyEvent::KEY_LEFT) == KeyEvent::KEY_STATE_DOWN)
{
Matrix TranslateTransform;
TranslateTransform.setTranslate(-TranslateAmount*e->getElapsedTime(),0.0f,0.0f);
Matrix NewTransform(BoxTransform->getMatrix());
NewTransform.mult(TranslateTransform);
beginEditCP(BoxTransform, Transform::MatrixFieldMask);
BoxTransform->setMatrix(NewTransform);
endEditCP(BoxTransform, Transform::MatrixFieldMask);
}
if(TheEventProducer->getKeyState(KeyEvent::KEY_RIGHT) == KeyEvent::KEY_STATE_DOWN)
{
Matrix TranslateTransform;
TranslateTransform.setTranslate(TranslateAmount*e->getElapsedTime(),0.0f,0.0f);
Matrix NewTransform(BoxTransform->getMatrix());
NewTransform.mult(TranslateTransform);
beginEditCP(BoxTransform, Transform::MatrixFieldMask);
BoxTransform->setMatrix(NewTransform);
endEditCP(BoxTransform, Transform::MatrixFieldMask);
}
if(TheEventProducer->getKeyState(KeyEvent::KEY_UP) == KeyEvent::KEY_STATE_DOWN)
{
Matrix TranslateTransform;
TranslateTransform.setTranslate(0.0f,0.0f,-TranslateAmount*e->getElapsedTime());
Matrix NewTransform(BoxTransform->getMatrix());
NewTransform.mult(TranslateTransform);
beginEditCP(BoxTransform, Transform::MatrixFieldMask);
BoxTransform->setMatrix(NewTransform);
endEditCP(BoxTransform, Transform::MatrixFieldMask);
}
if(TheEventProducer->getKeyState(KeyEvent::KEY_DOWN) == KeyEvent::KEY_STATE_DOWN)
{
Matrix TranslateTransform;
TranslateTransform.setTranslate(0.0f,0.0f,TranslateAmount*e->getElapsedTime());
Matrix NewTransform(BoxTransform->getMatrix());
NewTransform.mult(TranslateTransform);
beginEditCP(BoxTransform, Transform::MatrixFieldMask);
BoxTransform->setMatrix(NewTransform);
endEditCP(BoxTransform, Transform::MatrixFieldMask);
}
if(TheEventProducer->getKeyState(KeyEvent::KEY_A) == KeyEvent::KEY_STATE_DOWN)
{
Matrix TranslateTransform;
//TranslateTransform.setTranslate(-TranslateAmount,0.0f,0.0f);
TranslateTransform.setRotate(Quaternion(Vec3f(0.0f,1.0f,0.0f), -RotateAmount*e->getElapsedTime()));
Matrix NewTransform(BoxTransform->getMatrix());
NewTransform.mult(TranslateTransform);
beginEditCP(BoxTransform, Transform::MatrixFieldMask);
BoxTransform->setMatrix(NewTransform);
endEditCP(BoxTransform, Transform::MatrixFieldMask);
}
if(TheEventProducer->getKeyState(KeyEvent::KEY_D) == KeyEvent::KEY_STATE_DOWN)
{
Matrix TranslateTransform;
//TranslateTransform.setTranslate(TranslateAmount,0.0f,0.0f);
TranslateTransform.setRotate(Quaternion(Vec3f(0.0f,1.0f,0.0f), RotateAmount*e->getElapsedTime()));
Matrix NewTransform(BoxTransform->getMatrix());
NewTransform.mult(TranslateTransform);
beginEditCP(BoxTransform, Transform::MatrixFieldMask);
BoxTransform->setMatrix(NewTransform);
endEditCP(BoxTransform, Transform::MatrixFieldMask);
}
}
void ApplicationBuilder::attachApplication(void)
{
Inherited::attachApplication();
beginEditCP(ApplicationBuilderPtr(this) , ApplicationBuilder::EditingProjectFieldMask);
setEditingProject(MainApplication::the()->getProject());
endEditCP(ApplicationBuilderPtr(this) , ApplicationBuilder::EditingProjectFieldMask);
//Camera Beacon
Matrix TransformMatrix;
TransformPtr CameraBeaconTransform = Transform::create();
beginEditCP(CameraBeaconTransform, Transform::MatrixFieldMask);
CameraBeaconTransform->setMatrix(TransformMatrix);
endEditCP(CameraBeaconTransform, Transform::MatrixFieldMask);
NodePtr CameraBeaconNode = Node::create();
beginEditCP(CameraBeaconNode, Node::CoreFieldMask);
CameraBeaconNode->setCore(CameraBeaconTransform);
endEditCP(CameraBeaconNode, Node::CoreFieldMask);
// Make Main Scene Node empty
NodePtr DefaultRootNode = osg::Node::create();
beginEditCP(DefaultRootNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
DefaultRootNode->setCore(osg::Group::create());
DefaultRootNode->addChild(CameraBeaconNode);
endEditCP(DefaultRootNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
//Camera
PerspectiveCameraPtr DefaultCamera = PerspectiveCamera::create();
beginEditCP(DefaultCamera);
DefaultCamera->setBeacon(CameraBeaconNode);
DefaultCamera->setFov (deg2rad(60.f));
DefaultCamera->setNear (0.1f);
DefaultCamera->setFar (10000.f);
endEditCP(DefaultCamera);
//Background
SolidBackgroundPtr DefaultBackground = SolidBackground::create();
beginEditCP(DefaultBackground, SolidBackground::ColorFieldMask);
DefaultBackground->setColor(Color3f(0.0f,0.0f,0.0f));
endEditCP(DefaultBackground, SolidBackground::ColorFieldMask);
//Icon Manager
_IconManager = DefaultIconManager::create();
//User Interface
ForegroundPtr UserInterfaceForeground = createInterface();
beginEditCP(_TheBuilderInterface->getDrawingSurface(), UIDrawingSurface::EventProducerFieldMask);
_TheBuilderInterface->getDrawingSurface()->setEventProducer(MainApplication::the()->getMainWindowEventProducer());
endEditCP(_TheBuilderInterface->getDrawingSurface(), UIDrawingSurface::EventProducerFieldMask);
//Viewport
if(MainApplication::the()->getMainWindowEventProducer()->getWindow() != NullFC && MainApplication::the()->getMainWindowEventProducer()->getWindow()->getPort().size() == 0)
{
ViewportPtr DefaultViewport = Viewport::create();
beginEditCP(DefaultViewport);
DefaultViewport->setCamera (DefaultCamera);
DefaultViewport->setRoot (DefaultRootNode);
DefaultViewport->setSize (0.0f,0.0f, 1.0f,1.0f);
DefaultViewport->setBackground (DefaultBackground);
DefaultViewport->getForegrounds().push_back (UserInterfaceForeground);
endEditCP(DefaultViewport);
beginEditCP(MainApplication::the()->getMainWindowEventProducer()->getWindow(), Window::PortFieldMask);
MainApplication::the()->getMainWindowEventProducer()->getWindow()->addPort(DefaultViewport);
endEditCP(MainApplication::the()->getMainWindowEventProducer()->getWindow(), Window::PortFieldMask);
}
}
NodePtr createScenegraph(){
//At first we load all needed models from file
NodePtr w_high = SceneFileHandler::the().read("data/woman_high.wrl");
NodePtr w_medium = SceneFileHandler::the().read("data/woman_medium.wrl");
NodePtr w_low = SceneFileHandler::the().read("data/woman_low.wrl");
//we check the result
if ((w_high == NullFC)&&(w_medium == NullFC)&&(w_low == NullFC)){
std::cout << "It was not possible to load all needed models from file" << std::endl;
return NullFC;
}
//now the LOD core
DistanceLODPtr lod = DistanceLOD::create();
beginEditCP(lod, DistanceLOD::CenterFieldMask | DistanceLOD::RangeFieldMask);
lod->getSFCenter()->setValue(Pnt3f(0,0,0));
lod->getMFRange()->push_back(200);
lod->getMFRange()->push_back(500);
endEditCP(lod, DistanceLOD::CenterFieldMask | DistanceLOD::RangeFieldMask);
//the node containing the LOD core. The three models will be
//added as its children
NodePtr lodNode = Node::create();
beginEditCP(lodNode);
lodNode->setCore(lod);
lodNode->addChild(w_high);
lodNode->addChild(w_medium);
lodNode->addChild(w_low);
endEditCP(lodNode);
//create the node with switch core ********************
SwitchPtr sw = Switch::create();
beginEditCP(sw, Switch::ChoiceFieldMask);
//Notice: the first choice is 0
sw->setChoice(0);
endEditCP(sw, Switch::ChoiceFieldMask);
NodePtr switchNode = Node::create();
beginEditCP(switchNode);
switchNode->setCore(sw);
switchNode->addChild(lodNode);
endEditCP(switchNode);
//end witch creation **********************************
NodePtr root = Node::create();
beginEditCP(root);
root->setCore(Group::create());
root->addChild(switchNode);
endEditCP(root);
// we know want to extract the mesh geometry out of the graph
// it is sufficent to pass the model only as root for searching
NodePtr womanGeometry = checkName(w_high);
GeometryPtr geo;
if (womanGeometry != NullFC){
geo = GeometryPtr::dcast(womanGeometry->getCore());
if (geo == NullFC)
std::cout << "Casting failed!" << std::endl;
}else{
std::cout << "No correct geometry node found!" << std::endl;
//create a dummy object
geo = makeBoxGeo(0.5,0.5,0.5,1,1,1);
}
// generating a material *********************************
SimpleMaterialPtr mat = SimpleMaterial::create();
beginEditCP(mat);
mat->setAmbient(Color3f(0.2,0.2,0.2));
mat->setDiffuse(Color3f(0.6,0.3,0.1));
mat->setSpecular(Color3f(1,1,1));
mat->setShininess(0.8);
endEditCP(mat);
beginEditCP(geo, Geometry::MaterialFieldMask);
geo->setMaterial(mat);
endEditCP(geo, Geometry::MaterialFieldMask);
// end material generation *******************************
//new node with "old" geometry core referenced
NodePtr woman = Node::create();
beginEditCP(woman);
woman->setCore(geo);
endEditCP(woman);
//translate it a bit to see both women
NodePtr womanTrans = Node::create();
TransformPtr t = Transform::create();
beginEditCP(t);
Matrix m;
m.setIdentity();
m.setTranslate(Vec3f(0,0,200));
t->setMatrix(m);
endEditCP(t);
beginEditCP(womanTrans);
womanTrans->setCore(t);
womanTrans->addChild(woman);
endEditCP(womanTrans);
//add it to the root
beginEditCP(root);
root->addChild(womanTrans);
endEditCP(root);
return root;
}
ComponentPtr createGLPanel(void)
{
//Create the nessicary parts for a viewport
//Camera Beacon
Matrix TransformMatrix;
TransformMatrix.setTranslate(0.0f,0.0f, 0.0f);
TransformPtr CameraBeaconTransform = Transform::create();
beginEditCP(CameraBeaconTransform, Transform::MatrixFieldMask);
CameraBeaconTransform->setMatrix(TransformMatrix);
endEditCP(CameraBeaconTransform, Transform::MatrixFieldMask);
NodePtr CameraBeaconNode = Node::create();
beginEditCP(CameraBeaconNode, Node::CoreFieldMask);
CameraBeaconNode->setCore(CameraBeaconTransform);
endEditCP(CameraBeaconNode, Node::CoreFieldMask);
//Light Beacon
Matrix LightTransformMatrix;
LightTransformMatrix.setTranslate(0.0f,0.0f, 0.0f);
TransformPtr LightBeaconTransform = Transform::create();
beginEditCP(LightBeaconTransform, Transform::MatrixFieldMask);
LightBeaconTransform->setMatrix(TransformMatrix);
endEditCP(LightBeaconTransform, Transform::MatrixFieldMask);
NodePtr LightBeaconNode = Node::create();
beginEditCP(LightBeaconNode, Node::CoreFieldMask);
LightBeaconNode->setCore(CameraBeaconTransform);
endEditCP(LightBeaconNode, Node::CoreFieldMask);
//Light Node
DirectionalLightPtr TheDirectionLight = DirectionalLight::create();
beginEditCP(TheDirectionLight, DirectionalLight::DirectionFieldMask);
TheDirectionLight->setDirection(0.0f,1.0f,0.0f);
endEditCP(TheDirectionLight, DirectionalLight::DirectionFieldMask);
NodePtr LightNode = Node::create();
beginEditCP(LightNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
LightNode->setCore(TheDirectionLight);
LightNode->addChild(createScene());
endEditCP(LightNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
// Make Torus Node (creates Torus in background of scene)
NodePtr GeometryNode = makeTorus(.5, 2, 32, 32);
// Make Main Scene Node and add the Torus
NodePtr DefaultRootNode = osg::Node::create();
beginEditCP(DefaultRootNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
DefaultRootNode->setCore(osg::Group::create());
DefaultRootNode->addChild(CameraBeaconNode);
DefaultRootNode->addChild(LightBeaconNode);
DefaultRootNode->addChild(LightNode);
endEditCP(DefaultRootNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
//Camera
PerspectiveCameraPtr DefaultCamera = PerspectiveCamera::create();
beginEditCP(DefaultCamera);
DefaultCamera->setBeacon(CameraBeaconNode);
DefaultCamera->setFov (deg2rad(60.f));
DefaultCamera->setNear (0.1f);
DefaultCamera->setFar (100.f);
endEditCP(DefaultCamera);
//Background
GradientBackgroundPtr DefaultBackground = GradientBackground::create();
beginEditCP(DefaultBackground, GradientBackground::ColorFieldMask | GradientBackground::PositionFieldMask);
DefaultBackground->addLine(Color3f(0.0f,0.0f,0.0f), 0.0f);
DefaultBackground->addLine(Color3f(0.0f,0.0f,1.0f), 1.0f);
endEditCP(DefaultBackground, GradientBackground::ColorFieldMask | GradientBackground::PositionFieldMask);
//Viewport
ViewportPtr DefaultViewport = Viewport::create();
beginEditCP(DefaultViewport);
DefaultViewport->setCamera (DefaultCamera);
DefaultViewport->setRoot (DefaultRootNode);
DefaultViewport->setSize (0.0f,0.0f, 1.0f,1.0f);
DefaultViewport->setBackground (DefaultBackground);
endEditCP(DefaultViewport);
//GL Viewport Component
GLViewportPtr TheGLViewport = GLViewport::create();
beginEditCP(TheGLViewport, GLViewport::PortFieldMask | GLViewport::PreferredSizeFieldMask | GLViewport::BordersFieldMask);
TheGLViewport->setPort(DefaultViewport);
TheGLViewport->setPreferredSize(Vec2f(1024.0f,768.0f));
endEditCP(TheGLViewport, GLViewport::PortFieldMask | GLViewport::PreferredSizeFieldMask | GLViewport::BordersFieldMask);
TheGLViewport->showAll();
return TheGLViewport;
}
void SpaceNavigatorSSM::mouseButtonPress(UInt16 button, Int16 x, Int16 y)
{
switch (button)
{
case MouseLeft:
// test if an object is picked
if(_objectPicking)
{
Line ray = calcViewRay(x, y);
IntersectAction *iAct = IntersectAction::create();
iAct->setLine(ray);
iAct->apply(this->getRoot());
// we have a hit
if(iAct->didHit())
{
_pickedObjectNode = iAct->getHitObject();
#ifdef SPACENAVIGATOR_DEBUG_OUTPUT
std::cout << "SpaceNavigatorSSM: Object transformation mode active ( " << getName(_pickedObjectNode) << " )" << std::endl;
#endif // SPACENAVIGATOR_DEBUG_OUTPUT
// go up in the graph to the next transformation
while(!_pickedObjectNode->getCore()->getType().isDerivedFrom(Transform::getClassType()))
{
if(_pickedObjectNode->getParent() != this->getRoot())
_pickedObjectNode = _pickedObjectNode->getParent();
else
{
// insert a new transformation node
NodePtr pickedObject = iAct->getHitObject();
TransformPtr newTransform = Transform::create();
Matrix m;
m.setIdentity();
beginEditCP(newTransform, Transform::MatrixFieldMask);
newTransform->setMatrix(m);
endEditCP(newTransform, Transform::MatrixFieldMask);
NodePtr newTransformNode = Node::create();
beginEditCP(newTransformNode, Node::CoreFieldMask);
newTransformNode->setCore(newTransform);
endEditCP(newTransformNode, Node::CoreFieldMask);
NodePtr pickedObjectParent = pickedObject->getParent();
// add reference because reCount would be 0 and then it will
// be deleted
addRefCP(pickedObject);
beginEditCP(pickedObjectParent);
pickedObjectParent->replaceChildBy(pickedObject, newTransformNode);
endEditCP(pickedObjectParent);
beginEditCP(newTransformNode);
newTransformNode->addChild(pickedObject);
endEditCP(newTransformNode);
// sub the reference which was added before
subRefCP(pickedObject);
_pickedObjectNode = newTransformNode;
}
}
// a transformation was found and the objects bounding box is showed
this->setHighlight(_pickedObjectNode);
}
}
_navigator.buttonPress(Navigator::LEFT_MOUSE,x,y);
break;
case MouseMiddle:
_navigator.buttonPress(Navigator::MIDDLE_MOUSE,x,y);
break;
case MouseRight:
// release picked object and switch off bounding box rendering
if(_objectPicking)
{
_pickedObjectNode = NullFC;
this->setHighlight(NullFC);
#ifdef SPACENAVIGATOR_DEBUG_OUTPUT
std::cout << "SpaceNavigatorSSM: Camera transformation mode active" << std::endl;
#endif // SPACENAVIGATOR_DEBUG_OUTPUT
}
_navigator.buttonPress(Navigator::RIGHT_MOUSE,x,y);
break;
case MouseUp:
_navigator.buttonPress(Navigator::UP_MOUSE,x,y);
break;
case MouseDown:
_navigator.buttonPress(Navigator::DOWN_MOUSE,x,y);
break;
}
_mousebuttons |= 1 << button;
_lastx = x;
_lasty = y;
}
void keyboard(unsigned char k, int x, int y)
{
switch(k)
{
case 27:
{
OpenSGDeformActionManager::Destroy();
osgExit();
exit(0);
}
case '1':
{
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
break;
}
case '2':
{
glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
break;
}
case '3':
{
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
break;
}
case '5':
{
chairIndex = (chairIndex + 1) % 6;
model = chairNodes[chairIndex];
cout << "Selected model is: ";
if (getName(model))
cout << getName(model);
cout << " " << model << endl;
break;
}
case '6':
{
ax *= -1;
break;
}
case '7':
{
if (ax < 0)
ax = -1;
else
ax = 1;
break;
}
case '8':
{
if (ax < 0)
ax = -2;
else
ax = 2;
break;
}
case '9':
{
if (ax < 0)
ax = -3;
else
ax = 3;
break;
}
case 'p':
{
#if OSG_MAJOR_VERSION >= 2
traverse(scene, boost::bind(printSceneGraph,_1));
#else
traverse(scene, osgTypedFunctionFunctor1CPtrRef
<Action::ResultE, NodePtr>(printSceneGraph));
#endif
break;
}
case 'h':
{
printUsage();
break;
}
case 'i':
{
gmtl::AABoxf aabb;
osgdam = OpenSGDeformActionManager::GetInstance();
if (osgdam != 0)
{
osgdam->insertLattice(model, 2, 2, 2, 3);
}
break;
}
case 'j':
{
osgdam = OpenSGDeformActionManager::GetInstance();
if(osgdam != 0)
{
gmtl::AABoxf aabb;
Pnt3f aabbMin, aabbMax;
#if OSG_MAJOR_VERSION >= 2
model->editVolume(true).getBounds(aabbMin, aabbMax);
#else
model->getVolume(true).getBounds(aabbMin, aabbMax);
#endif
for (int i = 0; i < 3; i++)
{
aabbMin[i] = aabbMin[i] - 1.0f;
aabbMax[i] = aabbMax[i]/2 + 1.0f;
}
aabb = gmtl::AABoxf(gmtl::Vec3f(aabbMin[0], aabbMin[1], aabbMin[2]),
gmtl::Vec3f(aabbMax[0], aabbMax[1], aabbMax[2]));
osgdam->insertLattice(model, 2, 2, 2, 3, true, aabb);
}
break;
}
case 'q':
{
NodePtr tmp = model;
while (tmp != NullFC)
{
TransformPtr tcore = TransformPtr::dcast(tmp->getCore());
if (tcore != NullFC)
{
Matrix mm = tcore->getMatrix();
Matrix tm = Matrix::identity();
tm.setScale(1,2,1);
mm.mult(tm);
beginEditCP(tcore, Transform::MatrixFieldMask);
tcore->setMatrix(mm);
endEditCP(tcore, Transform::MatrixFieldMask);
mm = tcore->getMatrix();
break;
}
tmp = tmp->getParent();
}
break;
}
default:
break;
}
if (osgdam != 0)
{
switch(k)
{
case '4':
{
all = !all;
osgdam->setShowAll(model, all);
break;
}
case 'e':
{
doExecute = !doExecute;
osgdam->setInstantExecution(model, doExecute);
break;
}
case 'r':
{
osgdam->removeLattice(model);
break;
}
case 't':
{
osgdam->taper(model, 1.0f, ax);
break;
}
case 'g':
{
osgdam->twist(model, gmtl::Math::deg2Rad(5.0f), ax);
break;
}
case 'b':
{
osgdam->bend(model, gmtl::Math::deg2Rad(5.0f), 0.5f, ax);
break;
}
case 'v':
{
osgdam->bend(model, -gmtl::Math::deg2Rad(5.0f), 0.0f, ax);
break;
}
case 'c':
{
osgdam->bend(model, -gmtl::Math::deg2Rad(5.0f), 1.0f, ax);
break;
}
case 'f':
{
osgdam->bend(model, -gmtl::Math::deg2Rad(5.0f), 0.5f, ax);
break;
}
case 'd':
{
gmtl::Matrix44f dMatrix;
dMatrix[0][0] = 0.5f;
dMatrix[1][1] = 1.0f;
dMatrix[2][2] = -1.5f;
osgdam->deform(model, dMatrix, false);
break;
}
case 'l':
{
selectPoints.clear();
selectPositions.clear();
osgdam->unselectLatticeCellPoints(model);
break;
}
case 'm':
{
osgdam->selectLatticeCellPoint(mgr, model, x, y, true);
break;
}
case 'n':
{
osgdam->unselectLatticeCellPoint(mgr, model, x, y);
break;
}
case '-':
{
gmtl::Vec3f pos;
selectPositions.clear();
selectPoints = osgdam->getSelection(model);
for (size_t i = 0; i < selectPoints.size(); ++i)
{
osgdam->getPoint(model, selectPoints[i], pos);
if (ax == 1)
pos[0] -= 0.5f;
else if (ax == 2)
pos[1] -= 0.5f;
else
pos[2] -= 0.5f;
selectPositions.push_back(pos);
}
osgdam->setPoints(model, selectPoints, selectPositions);
break;
}
case '+':
{
gmtl::Vec3f pos;
selectPositions.clear();
selectPoints = osgdam->getSelection(model);
for (size_t i = 0; i < selectPoints.size(); ++i)
{
osgdam->getPoint(model, selectPoints[i], pos);
if (ax == 1)
pos[0] += 0.5f;
else if (ax == 2)
pos[1] += 0.5f;
else
pos[2] += 0.5f;
selectPositions.push_back(pos);
}
osgdam->setPoints(model, selectPoints, selectPositions);
break;
}
case 'u':
{
osgdam->undo(model);
break;
}
case 'x':
{
osgdam->executeFfd(model);
break;
}
case 'o':
{
osgdam->dump(model);
break;
}
default:
break;
}
}
}
// 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
/*
Transformation accumulate through the graph, i.e. all nodes below
a Transformation are influenced by it, even other Transformations.
This can be used to create models of objects that move together and
in relation to each other, the prime examples being a robot arm and
a planetary system. This example does something not quite unlike a
robot arm.
*/
// create the scene
/*
This time the graph is not wide, but deep, i.e. every Transformation
only has two children, a Geometry and another transformation.
The end resulting motion of the geometry is the accumulation of
all the Transformations above it.
*/
// use a cylinder this time
GeometryPtr cyl = makeCylinderGeo( 1, .3, 8, true, true, true );
// the single transformation Core used
trans = Transform::create();
// setup an intial transformation
Matrix m;
m.setTransform(Vec3f(0, .9, 0));
beginEditCP(trans, Transform::MatrixFieldMask);
{
trans->setMatrix(m);
}
endEditCP (trans, Transform::MatrixFieldMask);
/*
NullFC is the generic NULL value for FieldContainer pointer.
*/
NodePtr last = NullFC;
// create the copied transformations and their geometry nodes
for(UInt16 i = 1; i < ncopies; ++i)
{
// create the shared Geometry
NodePtr geonode = Node::create();
beginEditCP(geonode, Node::CoreFieldMask );
{
geonode->setCore(cyl);
}
endEditCP (geonode, Node::CoreFieldMask );
// add a transformation to the Geometry
NodePtr transnode = Node::create();
beginEditCP(transnode, Node::CoreFieldMask | Node::ChildrenFieldMask);
{
transnode->setCore (trans);
transnode->addChild(geonode );
if(last != NullFC)
transnode->addChild(last);
}
endEditCP (transnode, Node::CoreFieldMask | Node::ChildrenFieldMask);
last = transnode;
}
NodePtr scene = last;
// 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;
}
NodePtr PerformerLoader::traverse(pfNode *node)
{
FINFO(("PfL:traverse: traversing \"%s\": %p (%s)\n",
node->getName()?node->getName():"Unnamed",
node, pfGetTypeName(node)));
if(_nodes.find(node) != _nodes.end())
{
FINFO(("PfL:traverse: found in nodemap as %p.\n",
_nodes[node].getCPtr()));
return cloneTree(_nodes[node]);
}
NodePtr n = Node::create();
NodeCorePtr core = NullFC;
beginEditCP(n);
setName(n, node->getName());
if (node->getType()->isDerivedFrom(pfGroup::getClassType()))
{
pfGroup *group = dynamic_cast<pfGroup *>(node);
int ind = 0;
int num = group->getNumChildren();
if (node->getType()->isDerivedFrom(pfLOD::getClassType()))
{
if(_highestLODOnly)
{
num = osgMin(num, 1);
core = Group::create();
}
else
{
pfLOD *lod = dynamic_cast<pfLOD *>(node);
DistanceLODPtr l = DistanceLOD::create();
beginEditCP(l);
for(int i = 0; i < lod->getNumRanges(); ++i)
{
l->getRange().push_back(lod->getRange(i));
}
endEditCP(l);
core = l;
}
}
else if (node->getType()->isDerivedFrom(pfSCS::getClassType()))
{
pfSCS *scs = dynamic_cast<pfSCS *>(node);
if (node->getType()->isDerivedFrom(pfDCS::getClassType()))
{
}
pfMatrix pmat;
scs->getMat(pmat);
Matrix omat;
omat.setValue( pmat[0][0], pmat[0][1], pmat[0][2], pmat[0][3],
pmat[1][0], pmat[1][1], pmat[1][2], pmat[1][3],
pmat[2][0], pmat[2][1], pmat[2][2], pmat[2][3],
pmat[3][0], pmat[3][1], pmat[3][2], pmat[3][3]);
omat.transpose();
TransformPtr t = Transform::create();
beginEditCP(t);
t->setMatrix(omat);
endEditCP(t);
core = t;
}
else if (node->getType()->isDerivedFrom(pfScene::getClassType()))
{
FWARNING(("PerformerLoader::traverse: encountered scene "
"group!\n"));
}
else if (node->getType()->isDerivedFrom(pfLayer::getClassType()))
{
FWARNING(("PerformerLoader::traverse: encountered layer "
"group!\n"));
}
else if (node->getType() != pfGroup::getClassType())
{
FWARNING(("PerformerLoader::traverse: encountered unknown group"
" node of type %s\n", pfGetTypeName(node)));
core = Group::create();
}
else
{
core = Group::create();
}
for (;ind < num; ind++)
{
NodePtr cn = traverse(group->getChild(ind));
if(cn != NullFC)
n->addChild(cn);
}
}
else if (node->getType()->isDerivedFrom(pfGeode::getClassType()))
{
pfGeode *geode = dynamic_cast<pfGeode *>(node);
int num;
if (node->getType()->isDerivedFrom(pfBillboard::getClassType()))
{
num = geode->getNumGSets();
}
else if(node->getType()->isDerivedFrom(pfParaSurface::getClassType()))
{
FWARNING(("PerformerLoader::traverse: encountered parametric"
" surface %s\n", pfGetTypeName(node)));
}
else
num = geode->getNumGSets();
if(num == 1)
{
core = traverseGSet(n, geode->getGSet(0));
}
else
{
core = Group::create();
for (int i = 0; i < num; i++)
{
GeometryPtr geo = traverseGSet(n, geode->getGSet(i));
if(geo != NullFC)
{
n->addChild(makeNodeFor(geo));
}
}
}
}
else if (node->getType()->isDerivedFrom(pfLightSource::getClassType()))
{
FWARNING(("PerformerLoader::traverse: encountered light source!\n"));
}
else
{
FWARNING(("PerformerLoader::traverse: encountered unhandled node"
" of type %s\n", pfGetTypeName(node)));
return NullFC;
}
if(core != NullFC)
{
n->setCore(core);
}
else
{
n->setCore(Group::create());
FWARNING(("PerformerLoader::traverse: couldn't create core!\n"));
}
endEditCP(n);
_nodes[node] = n;
FINFO(("PfL:traverse: adding \"%s\": %p to nodelist using %p\n",
node->getName()?node->getName():"Unnamed",
node, n.getCPtr()));
return n;
}
NodePtr createTag(const std::string &label, const Vec3f &translation)
{
TextLayoutParam layoutParam;
layoutParam.majorAlignment = TextLayoutParam::ALIGN_MIDDLE;
layoutParam.minorAlignment = TextLayoutParam::ALIGN_MIDDLE;
TextLayoutResult layoutResult;
face->layout(label, layoutParam, layoutResult);
GeometryPtr geo = Geometry::create();
Real32 size = face->getParam().size;
face->fillGeo(geo, layoutResult, size);
NodePtr textNode = Node::create();
beginEditCP(textNode, Node::CoreFieldMask);
{
textNode->setCore(geo);
}
endEditCP(textNode, Node::CoreFieldMask);
beginEditCP(geo, Geometry::MaterialFieldMask);
{
geo->setMaterial(textMaterial);
}
endEditCP(geo, Geometry::MaterialFieldMask);
NodePtr screenGroupNodePtr = Node::create();
GroupPtr screenGroupPtr = ScreenGroup::create();
beginEditCP(screenGroupNodePtr, Node::CoreFieldMask | Node::ChildrenFieldMask);
{
screenGroupNodePtr->setCore(screenGroupPtr);
screenGroupNodePtr->addChild(textNode);
}
endEditCP(screenGroupNodePtr, Node::CoreFieldMask | Node::ChildrenFieldMask);
NodePtr billboardNodePtr = Node::create();
BillboardPtr billboardPtr = Billboard::create();
beginEditCP(billboardPtr);
{
billboardPtr->setAxisOfRotation(Vec3f(0, 0, 0));
billboardPtr->setFocusOnCamera(false);
billboardPtr->setAlignToScreen(true);
}
endEditCP(billboardPtr);
beginEditCP(billboardNodePtr, Node::CoreFieldMask | Node::ChildrenFieldMask);
{
billboardNodePtr->setCore(billboardPtr);
billboardNodePtr->addChild(screenGroupNodePtr);
}
endEditCP(billboardNodePtr, Node::CoreFieldMask | Node::ChildrenFieldMask);
NodePtr nodePtr = Node::create();
TransformPtr transPtr = Transform::create();
Matrix transMatrix;
transMatrix.setTranslate(translation);
beginEditCP(transPtr);
{
transPtr->setMatrix(transMatrix);
}
endEditCP(transPtr);
beginEditCP(nodePtr, Node::CoreFieldMask | Node::ChildrenFieldMask);
{
nodePtr->setCore(transPtr);
nodePtr->addChild(billboardNodePtr);
}
endEditCP(nodePtr, Node::CoreFieldMask | Node::ChildrenFieldMask);
return nodePtr;
}
//////////////////////////////////////////////////////////////////////////
//! trimesh defined by filenode will be loaded
//////////////////////////////////////////////////////////////////////////
void buildTriMesh(void)
{
//NodePtr tri = makeTorus(0.5, 1.0, 24, 12);
//NodePtr tri = makeBox(10.0, 10.0, 10.0, 1, 1, 1);
NodePtr tri = Node::Ptr::dcast(TriGeometryBase->shallowCopy());
if(tri!=NullFC)
{
GeometryPtr triGeo = GeometryPtr::dcast(tri->getCore());
Matrix m;
SimpleMaterialPtr tri_mat = SimpleMaterial::create();
beginEditCP(tri_mat);
tri_mat->setAmbient(Color3f(0.1,0.1,0.2));
tri_mat->setDiffuse(Color3f(1.0,0.1,0.7));
endEditCP(tri_mat);
triGeo->setMaterial(tri_mat);
TransformPtr triTrans;
NodePtr triTransNode = makeCoredNode<Transform>(&triTrans);
m.setIdentity();
Real32 randX = frand()*10.0-5.0;
Real32 randY = frand()*10.0-5.0;
m.setTranslate(randX, randY, 18.0);
triTrans->setMatrix(m);
//create ODE data
Vec3f GeometryBounds(calcMinGeometryBounds(triGeo));
PhysicsBodyPtr triBody = PhysicsBody::create(physicsWorld);
beginEditCP(triBody, PhysicsBody::PositionFieldMask | PhysicsBody::LinearDampingFieldMask | PhysicsBody::AngularDampingFieldMask);
triBody->setPosition(Vec3f(randX, randY, 18.0));
triBody->setLinearDamping(0.0001);
triBody->setAngularDamping(0.0001);
endEditCP(triBody, PhysicsBody::PositionFieldMask | PhysicsBody::LinearDampingFieldMask | PhysicsBody::AngularDampingFieldMask);
triBody->setBoxMass(1.0,GeometryBounds.x(), GeometryBounds.y(), GeometryBounds.z());
PhysicsGeomPtr triGeom;
if(true)
{
triGeom = PhysicsTriMeshGeom::create();
beginEditCP(triGeom, PhysicsTriMeshGeom::BodyFieldMask |
PhysicsTriMeshGeom::SpaceFieldMask |
PhysicsTriMeshGeom::GeometryNodeFieldMask);
triGeom->setBody(triBody);
//add geom to space for collision
triGeom->setSpace(physicsSpace);
//set the geometryNode to fill the ode-triMesh
PhysicsTriMeshGeom::Ptr::dcast(triGeom)->setGeometryNode(tri);
endEditCP(triGeom, PhysicsTriMeshGeom::BodyFieldMask |
PhysicsTriMeshGeom::SpaceFieldMask |
PhysicsTriMeshGeom::GeometryNodeFieldMask);
}
else
{
triGeom = PhysicsBoxGeom::create();
beginEditCP(triGeom, PhysicsBoxGeom::BodyFieldMask | PhysicsBoxGeom::SpaceFieldMask | PhysicsBoxGeom::LengthsFieldMask);
triGeom->setBody(triBody);
triGeom->setSpace(physicsSpace);
PhysicsBoxGeom::Ptr::dcast(triGeom)->setLengths(GeometryBounds);
endEditCP(triGeom, PhysicsBoxGeom::BodyFieldMask | PhysicsBoxGeom::SpaceFieldMask | PhysicsBoxGeom::LengthsFieldMask);
}
beginEditCP(triGeom, PhysicsGeom::CategoryBitsFieldMask);
triGeom->setCategoryBits(TriCategory);
endEditCP(triGeom, PhysicsGeom::CategoryBitsFieldMask);
//add attachments
tri->addAttachment(triGeom);
triTransNode->addAttachment(triBody);
//add to SceneGraph
triTransNode->addChild(tri);
spaceGroupNode->addChild(triTransNode);
}
else
{
SLOG << "Could not read MeshData!" << endLog;
}
}
NodePtr createScenegraph(){
//create sun, planet & moon geometry
GeometryPtr sun = makeSphereGeo(3, 6);
NodePtr planet = makeSphere(3, 3);
NodePtr moon = makeSphere(2,1);
//the root node will be the sun
NodePtr root = Node::create();
beginEditCP(root, Node::CoreFieldMask);
root->setCore(sun);
endEditCP(root, Node::CoreFieldMask);
NodePtr planetTransformNode = Node::create();
NodePtr moonTransformNode = Node::create();
// these were declared globally
planetTransform = Transform::create();
moonTransform = Transform::create();
// Now we need to fill it with live
// We want to have the planet some distance away from the sun,
// but initial with no rotation. The same aplies to the moon
Matrix m,n;
m.setIdentity();
n.setIdentity();
m.setTranslate(20,0,0);
n.setTranslate(8,0,0);
beginEditCP(planetTransform, Transform::MatrixFieldMask);
planetTransform->setMatrix(m);
endEditCP(planetTransform, Transform::MatrixFieldMask);
beginEditCP(moonTransform, Transform::MatrixFieldMask);
moonTransform->setMatrix(n);
endEditCP(moonTransform, Transform::MatrixFieldMask);
//Insert the cores into the apropiate nodes and add the geometry
beginEditCP(planetTransformNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
planetTransformNode->setCore(planetTransform);
planetTransformNode->addChild(planet);
endEditCP(planetTransformNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
beginEditCP(moonTransformNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
moonTransformNode->setCore(moonTransform);
moonTransformNode->addChild(moon);
endEditCP(moonTransformNode, Node::CoreFieldMask | Node::ChildrenFieldMask);
//add the planet to the sun
beginEditCP(root, Node::ChildrenFieldMask);
root->addChild(planetTransformNode);
endEditCP(root, Node::ChildrenFieldMask);
//add the moon to the planet
beginEditCP(planet, Node::ChildrenFieldMask);
planet->addChild(moonTransformNode);
endEditCP(planet, Node::ChildrenFieldMask);
//now we are done
return root;
}
//This function will create our scenegraph
NodePtr createScenegraph(){
// we will use the variable to set our trandform matrices
Matrix m;
// First we will create all needed geometry
// the body of the house
NodePtr houseMain = makeBox(20,20,20,1,1,1);
// now the roof
NodePtr roof = makeBox(14.14, 14.14, 20, 1, 1, 1);
// we translate the roof to the correct position
TransformPtr tRoof = Transform::create();
beginEditCP(tRoof, Transform::MatrixFieldMask);
m.setIdentity();
m.setTranslate(0,10,0);
m.setRotate(Quaternion(Vec3f(0,0,1), 3.14159/4));
tRoof->setMatrix(m);
endEditCP(tRoof, Transform::MatrixFieldMask);
NodePtr roofTrans = Node::create();
beginEditCP(roofTrans, Node::CoreFieldMask | Node::ChildrenFieldMask);
roofTrans->setCore(tRoof);
roofTrans->addChild(roof);
endEditCP(roofTrans, Node::CoreFieldMask | Node::ChildrenFieldMask);
// and the chimney - we have the top and sides generated
// but we have no need for the bottom (it is inside the house)
NodePtr chimney = makeCylinder(10,1,8,true,true,false);
//now we translate the chimney
//create the transform core
TransformPtr tChimney = Transform::create();
beginEditCP(tChimney, Transform::MatrixFieldMask);
m.setIdentity();
// -5 along the x-axis and 2.5 along the z axis
// translates the chimney away from the center
// 15 along the y-axis translates the chimney to fit on top
// of the big box (have a look at the figure above2,5
m.setTranslate(-5,15,2.5);
tChimney->setMatrix(m);
endEditCP(tChimney, Transform::MatrixFieldMask);
//insert the transform core into the node
NodePtr chimneyTrans = Node::create();
beginEditCP(chimneyTrans, Node::CoreFieldMask | Node::ChildrenFieldMask);
chimneyTrans->setCore(tChimney);
chimneyTrans->addChild(chimney);
endEditCP(chimneyTrans, Node::CoreFieldMask | Node::ChildrenFieldMask);
// Now we create the root node and attach the geometry nodes to it
NodePtr n = Node::create();
beginEditCP(n, Node::CoreFieldMask | Node::ChildrenFieldMask);
n->setCore(Group::create());
n->addChild(houseMain);
n->addChild(roofTrans);
n->addChild(chimneyTrans);
endEditCP(n, Node::CoreFieldMask | Node::ChildrenFieldMask);
return n;
}
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;
}
FBOViewportPtr createSceneFBO(void)
{
//Create Camera Beacon
Matrix CameraMat;
CameraMat.setTranslate(0.0f,0.0f,4.0f);
TransformPtr CameraBeconCore = Transform::create();
beginEditCP(CameraBeconCore, Transform::MatrixFieldMask);
CameraBeconCore->setMatrix(CameraMat);
endEditCP(CameraBeconCore, Transform::MatrixFieldMask);
NodePtr CameraBeconNode = Node::create();
beginEditCP(CameraBeconNode, Node::CoreFieldMask);
CameraBeconNode->setCore(CameraBeconCore);
endEditCP(CameraBeconNode, Node::CoreFieldMask);
//Create Camera
PerspectiveCameraPtr TheCamera = PerspectiveCamera::create();
beginEditCP(TheCamera);
TheCamera->setFov(deg2rad(60.0f));
TheCamera->setAspect(1.0f);
TheCamera->setNear(0.1f);
TheCamera->setFar(100.0f);
TheCamera->setBeacon(CameraBeconNode);
endEditCP(TheCamera);
//Make the Material
BlinnMaterialPtr TheMaterial = BlinnMaterial::create();
beginEditCP(TheMaterial);
TheMaterial->setDiffuse(0.8);
TheMaterial->setColor(Color3f(1.0,1.0,1.0));
TheMaterial->setAmbientColor(Color3f(1.0,1.0,1.0));
TheMaterial->setNumLights(1);
endEditCP(TheMaterial);
// Make Torus Node (creates Torus in background of scene)
NodePtr TorusGeometryNode = makeTorus(.5, 2, 24, 48);
beginEditCP(TorusGeometryNode->getCore());
GeometryPtr::dcast(TorusGeometryNode->getCore())->setMaterial(TheMaterial);
endEditCP(TorusGeometryNode->getCore());
calcVertexNormals(GeometryPtr::dcast(TorusGeometryNode->getCore()));
calcVertexTangents(GeometryPtr::dcast(TorusGeometryNode->getCore()),0,Geometry::TexCoords7FieldId, Geometry::TexCoords6FieldId);
RootTransformCore = Transform::create();
NodePtr TorusTransformNode = Node::create();
beginEditCP(TorusTransformNode, Node::CoreFieldMask);
TorusTransformNode->setCore(RootTransformCore);
TorusTransformNode->addChild(TorusGeometryNode);
endEditCP(TorusTransformNode, Node::CoreFieldMask);
//Create Light Beacon
Matrix LightMat;
LightMat.setTranslate(0.0f,10.0f,1.0f);
TransformPtr LightBeconCore = Transform::create();
beginEditCP(LightBeconCore, Transform::MatrixFieldMask);
LightBeconCore->setMatrix(LightMat);
endEditCP(LightBeconCore, Transform::MatrixFieldMask);
NodePtr LightBeconNode = Node::create();
beginEditCP(LightBeconNode, Node::CoreFieldMask);
LightBeconNode->setCore(LightBeconCore);
endEditCP(LightBeconNode, Node::CoreFieldMask);
//Create Light
TheLight = PointLight::create();
beginEditCP(TheLight);
TheLight->setBeacon(LightBeconNode);
endEditCP(TheLight);
NodePtr LightNode = Node::create();
beginEditCP(LightNode, Node::CoreFieldMask);
LightNode->setCore(TheLight);
LightNode->addChild(TorusTransformNode);
endEditCP(LightNode, Node::CoreFieldMask);
//Create Root
NodePtr TheRoot = Node::create();
beginEditCP(TheRoot);
TheRoot->setCore(Group::create());
TheRoot->addChild(CameraBeconNode);
TheRoot->addChild(LightNode);
TheRoot->addChild(LightBeconNode);
endEditCP(TheRoot);
//Create Background
SolidBackgroundPtr TheBackground = SolidBackground::create();
TheBackground->setColor(Color3f(1.0,0.0,0.0));
//DepthClearBackgroundPtr TheBackground = DepthClearBackground::create();
//Create the Image
ImagePtr TheColorImage = Image::create();
TheColorImage->set(Image::OSG_RGB_PF,2,2,1,1,1,0.0f,0,Image::OSG_FLOAT16_IMAGEDATA);
//Create the texture
TextureChunkPtr TheColorTextureChunk = TextureChunk::create();
beginEditCP(TheColorTextureChunk);
TheColorTextureChunk->setImage(TheColorImage);
TheColorTextureChunk->setMinFilter(GL_NEAREST);
TheColorTextureChunk->setMagFilter(GL_NEAREST);
TheColorTextureChunk->setWrapS(GL_CLAMP_TO_EDGE);
TheColorTextureChunk->setWrapR(GL_CLAMP_TO_EDGE);
TheColorTextureChunk->setScale(false);
TheColorTextureChunk->setNPOTMatrixScale(true);
TheColorTextureChunk->setEnvMode(GL_REPLACE);
TheColorTextureChunk->setInternalFormat(GL_RGB16F);
endEditCP(TheColorTextureChunk);
//Create FBO
FBOViewportPtr TheFBO = FBOViewport::create();
beginEditCP(TheFBO);
TheFBO->setBackground(TheBackground);
TheFBO->setRoot(TheRoot);
TheFBO->setCamera(TheCamera);
TheFBO->setEnabled(true);
TheFBO->getTextures().push_back(TheColorTextureChunk);
TheFBO->setStorageWidth(TheColorTextureChunk->getImage()->getWidth());
TheFBO->setStorageHeight(TheColorTextureChunk->getImage()->getHeight());
TheFBO->setSize(0,0,TheColorTextureChunk->getImage()->getWidth()-1, TheColorTextureChunk->getImage()->getHeight()-1);
endEditCP(TheFBO);
return TheFBO;
}
