void kore::Camera::transformChanged(const TransformPtr& newTransform) {
SceneNodeComponent::transformChanged(newTransform);
_matView = glm::inverse(newTransform->getGlobal());
_matViewInverse = newTransform->getGlobal();
paramsChanged();
}
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 CameraController::setCamera( CameraPtr camera )
{
m_data->camera = camera;
m_data->camera->addStandardParameters(); // subsequent casts are safe because of this
m_data->resolution = staticPointerCast<V2iData>( m_data->camera->parameters()["resolution"] );
m_data->screenWindow = staticPointerCast<Box2fData>( m_data->camera->parameters()["screenWindow"] );
m_data->clippingPlanes = staticPointerCast<V2fData>( m_data->camera->parameters()["clippingPlanes"] );
m_data->projection = staticPointerCast<StringData>( m_data->camera->parameters()["projection"] );
if( m_data->projection->readable()=="perspective" )
{
m_data->fov = staticPointerCast<FloatData>( m_data->camera->parameters()["projection:fov"] );
}
else
{
m_data->fov = 0;
}
TransformPtr transform = m_data->camera->getTransform();
m_data->transform = runTimeCast<MatrixTransform>( transform );
if( !m_data->transform )
{
m_data->transform = new MatrixTransform( transform ? transform->transform() : M44f() );
m_data->camera->setTransform( m_data->transform );
}
m_data->centreOfInterest = 1;
}
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();
}
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 );
}
void MoveManipulator::doMovement(TransformPtr t,
Int32 coord,
Real32 value,
const Vec3f &translation,
const Quaternion &rotation,
const Vec3f &scaleFactor,
const Quaternion &scaleOrientation )
{
Vec3f trans(0.0f, 0.0f, 0.0f);
trans[coord] = value;
Matrix ma, mb, mc, md, me;
ma.setTranslate( -translation );
mb.setRotate ( rotation.inverse() );
mc.setTransform( trans );
md.setRotate ( rotation );
me.setTranslate( translation );
beginEditCP(t, Transform::MatrixFieldMask);
{
t->editMatrix().multLeft(ma);
t->editMatrix().multLeft(mb);
t->editMatrix().multLeft(mc);
t->editMatrix().multLeft(md);
t->editMatrix().multLeft(me);
}
endEditCP(t, Transform::MatrixFieldMask);
}
// redraw the window
void display(void)
{
Profiler::the().StartProfile("Frame");
unsigned i;
for (i=0; i<numFirst; ++i) {
TransformPtr trf = TransformPtr::dcast(first->getChild(i)->getCore());
beginEditCP(trf);
trf->getMatrix()[3] += Vec4f((rand()/Real32(RAND_MAX)-0.5f),
(rand()/Real32(RAND_MAX)-0.5f),
(rand()/Real32(RAND_MAX)-0.5f), 0.0f);
endEditCP(trf);
}
for (i=0; i<numSecond; ++i) {
TransformPtr trf = TransformPtr::dcast(second->getChild(i)->getCore());
beginEditCP(trf);
trf->getMatrix()[3] += Vec4f((rand()/Real32(RAND_MAX)-0.5f),
(rand()/Real32(RAND_MAX)-0.5f),
(rand()/Real32(RAND_MAX)-0.5f), 0.0f);
endEditCP(trf);
}
bool result = all->apply(first, second);
OSGRAPIDCollision& col = (OSGRAPIDCollision&)all->getData();
SLOG << col.getNumContacts() << " contacts with "
<< col.getNumBVolTests() << " BVolTests/"
<< col.getNumMixedTests() << " MixedTests/"
<< col.getNumPrimTests() << " TriTests "
<< std::endl;
Profiler::the().EndProfile("Frame");
mgr->redraw();
}
CameraNode::CameraNode( TransformPtr pTransform, Frustum const &frustum )
: SceneNode( INVALID_ACTOR_ID, NULL, RenderPass_0, pTransform ),
m_Frustum( frustum ),
m_IsActive( true ),
m_IsDebugCamera( false ),
m_pTarget( shared_ptr<SceneNode>() ),
m_CamOffsetVector( 0.0f, 1.0f, -10.0f, 0.0f ),
m_View( Mat4x4::LookAt( pTransform->GetToWorldPosition(), pTransform->GetToWorldPosition() + pTransform->GetForward(), g_Up ) )
{
}
//////////////////////////////////////////////////////////////////////////
//! 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 GuiMeshRender::ProcessEntities(const EntityMap &entities) {
if (entities.empty()) {
//printf("Warning: GuiMeshRender: Entity list is empty\n");
return;
}
EntityMap::const_iterator it, ite;
GuiMeshPtr mesh;
TransformPtr transform;
mat4 model, view, projection, model_view, mvp;
mat3 normal;
// warning: make sure the values here are all floats
projection = glm::ortho(0.0f, 800.0f, 600.0f, 0.0f, -1.0f, 1.0f);
for (it = entities.begin(), ite = entities.end(); it != ite; ++it) {
mesh = gui_mesh_mapper_(it->second);
transform = transform_mapper_(it->second);
model = transform->world();
model_view = model; // camera does not need to effect this
mvp = projection * model_view;
normal = inverse(transpose(mat3(model_view)));
shared_ptr<BasicMaterial> material = boost::dynamic_pointer_cast<BasicMaterial>(mesh->material);
vec4 light_pos = material->light_position_;
// hack to have light move with world
// todo: implement light as entity
material->light_position_ = model_view * light_pos;
// do things like setup colors and lights
// and attach shader program
mesh->material->PreRender();
material->light_position_ = light_pos;
// push matrices up
mesh->material->PushMatrices(model_view, projection, mvp, normal);
// call draw
mesh->geometry->Draw();
// let go of shader program
mesh->material->PostRender();
}
}
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);
}
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
display(void)
{
Matrix m1, m2, m3;
Quaternion q1;
tball.getRotation().getValue(m3);
q1.setValue(m3);
m1.setRotate(q1);
// std::cout << "TBROT" << std::endl << tball.getRotation() << std::endl;
// std::cout << "M3" << std::endl << m3 << std::endl;
// std::cout << "Q1" << std::endl << q1 << std::endl;
// std::cout << "M1" << std::endl << m1 << std::endl;
// m1.setRotate( tball.getRotation() );
m2.setTranslate( tball.getPosition() );
//std::cout << "Pos: " << tball.getPosition() << ", Rot: " << tball.getRotation() << std::endl;
// std::cout << tball.getRotation() << std::endl;
m1.mult( m2 );
cam_trans->editSFMatrix()->setValue( m1 );
win->draw( ract );
}
void PhysicsSystem::CheckCup(const TransformPtr &ball_transform){
using glm::vec2;
float radius = 0.05f;
BallComponentPtr ball_comp = ball_comp_mapper_(ball_);
TileComponentPtr curr_tile = tile_comp_mapper_(ball_comp->current_tile);
VolumePtr cup_vol = volume_mapper_(curr_tile->cup);
TransformPtr cup_transform = transform_mapper_(curr_tile->cup);
// create ball projection
vec3 proj = Project(ball_transform->position(), cup_vol->normal, cup_vol->vertices[0]);
// project cup vertices to xz plane
vector<vec2> projected_vertices;
for (int j = 0, sizej = cup_vol->vertices.size(); j < sizej; ++j) {
vec3 v = cup_vol->vertices[j];
vec2 p(v.x, v.z);
projected_vertices.push_back(p);
}
// project ball to xz plane
vec2 point(proj.x, proj.z);
// check to see if ball overlaps hole
bool inter = PointInPolygon(point, projected_vertices);
// does ball overlap?
if (inter) {
float dist_from_cup = glm::length(ball_transform->position() - cup_transform->position());
//if ball is close enough to go in hole and moving slow enough, ball went in cup (stop ball)
if(dist_from_cup < MADE_CUP_RADIUS && glm::length(ball_comp->velocity) < MAX_CUP_ENTRY_SPEED ) {
ball_comp->velocity = vec3();
ball_comp->acceleration = vec3();
ball_comp->in_cup = true;
}
//if ball is on lip, alter accel to go towards center
else if(dist_from_cup > MADE_CUP_RADIUS && dist_from_cup < CUP_LIP_RADIUS) {
ball_comp->acceleration += glm::normalize(cup_transform->position() - ball_transform->position()) * LIP_ACCEL;
}
else{}
}
}
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
// 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();
}
void
display(void)
{
Matrix m1, m2, m3;
Quaternion q1;
#ifdef PAR_SCHEDULER
if(pVSCThread == NULL)
{
pVSCThread = ExternalThread::find("VSCScheduler");
}
VSC::VSCScheduler::the()->enterSyncBarrier(2);
pVSCThread->getChangeList()->applyToCurrent();
pVSCThread->getChangeList()->clearAll();
// VSC::vsc_sleep(100);
VSC::VSCScheduler::the()->enterSyncBarrier(2);
#endif
// tball.getRotation().getValue(m3);
// q1.setValue(m3);
// m1.setRotate(q1);
// cout << "TBROT" << endl << tball.getRotation() << endl;
// cout << "M3" << endl << m3 << endl;
// cout << "Q1" << endl << q1 << endl;
// cout << "M1" << endl << m1 << endl;
// m1.setRotate( tball.getRotation() );
// m2.setTranslate( tball.getPosition() );
//cout << "Pos: " << tball.getPosition() << ", Rot: " << tball.getRotation() << endl;
// cout << tball.getRotation() << endl;
// m1.mult( m2 );
cam_trans->getSFMatrix()->setValue(tball.getFullTrackballMatrix());
/*
fprintf(stderr, "%d %d %d %d | %d | %d\r",
glutGet(GLUT_WINDOW_RED_SIZE),
glutGet(GLUT_WINDOW_GREEN_SIZE),
glutGet(GLUT_WINDOW_BLUE_SIZE),
glutGet(GLUT_WINDOW_ALPHA_SIZE),
glutGet(GLUT_WINDOW_DEPTH_SIZE),
glutGet(GLUT_WINDOW_STENCIL_SIZE));
*/
win->draw( ract );
}
void PhysicsSystem::ResolveCollision(const TransformPtr &ball_transform, const vec3 &normal, const vec3 &intersection) {
BallComponentPtr ball_comp = ball_comp_mapper_(ball_);
ball_transform->set_position(intersection);
vec3 direction = ball_comp->velocity;
vec3 w = glm::dot(normal, -direction) * normal;
vec3 result = w + (w + direction);
ball_comp->velocity = result;
}
//do Animation-Calculations here
void Animate()
{
static Real64 t0 = OSG::getSystemTime();
Real64 t = OSG::getSystemTime() - t0;
Real32 rotb = t * 10.0;
if(rotb > 360.0)
rotb -= 360.0;
Real32 rotc1 = t * 20.0;
if(rotc1 > 360.0)
rotc1 -= 360.0;
Real32 rotc2 = t * 40.0;
if(rotc2 > 360.0)
rotc2 -= 360.0;
Quaternion q;
beginEditCP(_box_trans);
q.setValueAsAxisDeg(0.2,0,1, rotb);
_box_trans->editMatrix().setRotate(q);
endEditCP(_box_trans);
beginEditCP(_cylinder1_trans);
q.setValueAsAxisDeg(0,0,1, rotc1);
_cylinder1_trans->editMatrix().setRotate(q);
endEditCP(_cylinder1_trans);
beginEditCP(_cylinder2_trans);
q.setValueAsAxisDeg(0,0,1, rotc2);
_cylinder2_trans->editMatrix().setRotate(q);
endEditCP(_cylinder2_trans);
beginEditCP(box_trans_node);
endEditCP(box_trans_node);
beginEditCP(cam);
endEditCP(cam);
mgr->redraw();
glutPostRedisplay();
}
void doCamTrans ( void )
{
Matrix m1, m2, m3;
Quaternion q1;
tball.getRotation().getValue(m3);
q1.setValue(m3);
m1.setRotate(q1);
m2.setTranslate( tball.getPosition() );
m1.mult( m2 );
cam_trans->getSFMatrix()->setValue( m1 );
}
void display(void)
{
Matrix m1, m2, m3;
Quaternion q1;
tball.getRotation().getValue(m3);
q1.setValue(m3);
m1.setRotate(q1);
m2.setTranslate( tball.getPosition() );
m1.mult( m2 );
cam_trans->editSFMatrix()->setValue( m1 );
window->draw( drAct );
}
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);
}
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
void PhysicsSystem::UpdateCollision(const TransformPtr &ball_transform) {
BallComponentPtr ball_comp = ball_comp_mapper_(ball_);
vec3 start = ball_transform->position();
vec3 end = start + ball_comp->velocity * Time::GetDeltaTime();
vec3 normal, penetration;
unordered_map<VolumePtr, EntityPtr>::iterator it;
for (it = wall_map_.begin(); it != wall_map_.end(); ++it) {
if (Intersect(start, end, it->first, normal, penetration)) {
ResolveCollision(ball_transform, normal, penetration);
}
}
}
void display(void)
{
Matrix m1, m2;
m1.setRotate(tball.getRotation());
m2.setTranslate(tball.getPosition());
m1.mult(m2);
cam_trans->editSFMatrix()->setValue(m1);
if(doRender)
win->render(ract);
else
win->draw(dact);
}
void
display(void)
{
Matrix m1, m2, m3;
m1=trackball.getMatrix();
// m1.transpose();
// m2.setTranslate(0,0,8);
// m1.mult(m2);
cam_trans->editSFMatrix()->setValue( m1 );
win->draw( ract );
}
// 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();
}
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;
}
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;
}
