void OrbitCameraManipulator::rotateCamera( float dx, float dy )
{
if( dx != 0.0 || dy != 0.0 )
{
// yaw
osg::CoordinateFrame coordinate_frame = getCoordinateFrame( m_lookat );
osg::Vec3d yaw_axis = getUpVector( coordinate_frame );
yaw_axis.normalize();
// lookat is the center of the screen. rotation center can be different (intersection point)
osg::Vec3d center_eye = m_eye - m_rotate_center;
osg::Vec3d center_lookat = m_lookat - m_rotate_center;
osg::Vec3d eye_lookat = m_lookat - m_eye;
// pitch
osg::Vec3d pitch_axis(0,0,1);
pitch_axis = pitch_axis ^ center_eye;
pitch_axis.normalize();
// apply yaw and pitch around the rotation center
osg::Quat quatpitch( dy*2.2, pitch_axis );
osg::Vec3d center_eye_pitch = quatpitch * center_eye;
osg::Vec3d center_lookat_pitch = quatpitch * center_lookat;
osg::Quat quatyaw( -dx*5.2, yaw_axis );
osg::Vec3d center_eye_new = quatyaw*center_eye_pitch;
osg::Vec3d center_lookat_new = quatyaw*center_lookat_pitch;
m_eye.set( m_rotate_center + center_eye_new );
m_lookat.set( m_rotate_center + center_lookat_new );
}
};
/// one-time class and physics initialization
void Terrain::initialize(void)
{
// std::cerr << "initializing...\n";
/* This code is inside cPhysics class */
// set up basic state
/* m_upAxis = 1; // start with Y-axis as "up"
m_type = PHY_FLOAT;
m_model = eRadial;//eFractal;
m_isDynamic = true;
// set up the physics world
m_collisionConfiguration = new btDefaultCollisionConfiguration();
m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration);
btVector3 worldMin(-1000,-1000,-1000);
btVector3 worldMax(1000,1000,1000);
m_overlappingPairCache = new btAxisSweep3(worldMin,worldMax);
m_constraintSolver = new btSequentialImpulseConstraintSolver();
m_dynamicsWorld = new btDiscreteDynamicsWorld(m_dispatcher,m_overlappingPairCache,m_constraintSolver,m_collisionConfiguration);
// initialize axis- or type-dependent physics from here
this->resetPhysics(); */
clearWorld();
// get new heightfield of appropriate type
m_rawHeightfieldData = getRawHeightfieldData(eRadial, PHY_FLOAT, m_minHeight, m_maxHeight);
bool flipQuadEdges = false; // width, height, *heightmapData, scale, minHeight, maxHeight, upAxis, heightMapDatatype, flipQuadEdges
btHeightfieldTerrainShape * heightfieldShape = new btHeightfieldTerrainShape(s_gridSize, s_gridSize, m_rawHeightfieldData, s_gridHeightScale, m_minHeight, m_maxHeight, m_upAxis, PHY_FLOAT, flipQuadEdges);
assert(heightfieldShape);
// scale the shape
btVector3 localScaling = getUpVector(m_upAxis, s_gridSpacing, 1.0);
heightfieldShape->setLocalScaling(localScaling);
// stash this shape away
cPhysics::Get().getCollisionShapes().push_back(heightfieldShape);
//m_collisionShapes.push_back(heightfieldShape);
// set origin to middle of heightfield
btTransform tr;
tr.setIdentity();
tr.setOrigin(btVector3(0,-20,0));
// create ground object
float mass = 0.0;
//localCreateRigidBody(mass, tr, heightfieldShape);
//We can also use DemoApplication::localCreateRigidBody, but for clarity it is provided here:
btRigidBody* body = cPhysics::Get().GetNewBody(heightfieldShape, mass, cVec3(0, -20, 0));
}
/// called whenever key terrain attribute is changed
void TerrainDemo::resetPhysics(void)
{
// remove old heightfield
clearWorld();
// reset gravity to point in appropriate direction
m_dynamicsWorld->setGravity(getUpVector(m_upAxis, 0.0, -s_gravity));
// get new heightfield of appropriate type
m_rawHeightfieldData =
getRawHeightfieldData(m_model, m_type, m_minHeight, m_maxHeight);
btAssert(m_rawHeightfieldData && "failed to create raw heightfield");
bool flipQuadEdges = false;
btHeightfieldTerrainShape * heightfieldShape =
new btHeightfieldTerrainShape(s_gridSize, s_gridSize,
m_rawHeightfieldData,
s_gridHeightScale,
m_minHeight, m_maxHeight,
m_upAxis, m_type, flipQuadEdges);
btAssert(heightfieldShape && "null heightfield");
// scale the shape
btVector3 localScaling = getUpVector(m_upAxis, s_gridSpacing, 1.0);
heightfieldShape->setLocalScaling(localScaling);
// stash this shape away
m_collisionShapes.push_back(heightfieldShape);
// set origin to middle of heightfield
btTransform tr;
tr.setIdentity();
tr.setOrigin(btVector3(0,-20,0));
// create ground object
float mass = 0.0;
localCreateRigidBody(mass, tr, heightfieldShape);
}
void Camera::rotate(float a, float x, float y, float z)
{
//rotate around the camera's axes (axises?) by a
Vector3 vy=getUpVector()*y;
Vector3 vx=getRightVector()*x;
Vector3 vz=getCameraNorm()*z;
Vector3 total=vx+vy+vz;
if (total.length()>0.001)
{
total.normalise();
modelview.rotate(a,total.x,total.y,total.z);
updateModelview();
}
}
void gep::FreeCamera::lookAt(const gep::vec3& target)
{
mat4 lookAtMat = mat4::lookAtMatrix(getPosition(), target, getUpVector());
m_rotation = Quaternion::fromMat4(lookAtMat);
}
void Camera::setTarget(const Vec3f& target)
{
std::cout << this->pivotPoint() << std::endl;
std::cout << this->position() << std::endl;
setupCameraOrientation(target - m_frame->position(), getUpVector());
}
void Camera::setViewDirection(const Vec3f& direction)
{
setupCameraOrientation(direction, getUpVector());
}
Vector3 Transform::getUpVector() const
{
Vector3 v;
getUpVector(&v);
return v;
}
void Object3D::yaw(float angle)
{
Vector3D axis;
getUpVector(axis);
rotate(axis, angle);
}
void Object3D::getDownVector(Vector3D& result)
{
getUpVector(result);
result.negate();
}
void RTSCamera::animate(u32 elapsed)
{
bool movebymouse = false;
f32 nRotX = rotX;
f32 nRotY = rotY;
f32 nZoom = currentZoom;
vector3df translate(oldTarget);
vector3df tvectX = Pos - Target;
tvectX = tvectX.crossProduct(UpVector);
tvectX.normalize();
// if(oldTarget.X != 0)
// {
// }
//Zoom
if (isMouseButtonDown(MOUSE_BUTTON_RIGHT) && isMouseButtonDown(MOUSE_BUTTON_LEFT))
{
if (!zooming)
{
zoomStartX = MousePos.X;
zoomStartY = MousePos.Y;
zooming = true;
nZoom = currentZoom;
}
else
{
f32 old = nZoom;
nZoom += (zoomStartX - MousePos.X) * zoomSpeed * 100;
// f32 targetMinDistance = 0.1f;
// if (nZoom < targetMinDistance)
// nZoom = targetMinDistance;
if (nZoom < targetMinDistance)
nZoom = targetMinDistance;
else if (nZoom > targetMaxDistance)
nZoom = targetMaxDistance;
if (nZoom < 0)
nZoom = old;
}
}
else
{
if (zooming)
{
f32 old = currentZoom;
currentZoom = currentZoom + (zoomStartX - MousePos.X ) * zoomSpeed;
nZoom = currentZoom;
if (nZoom < 0)
nZoom = currentZoom = old;
}
zooming = false;
}
//We rotate in Editor with right mouse button
if(isMouseButtonDown(MOUSE_BUTTON_RIGHT) && !isKeyDown(KEY_SHIFT) && !isKeyDown(KEY_LSHIFT) && !isKeyDown(KEY_RSHIFT))
{
movebymouse = true;
if (!rotating)
{
rotateStartX = MousePos.X;
rotateStartY = MousePos.Y;
rotating = true;
//nRotX = rotX;
//nRotY = rotY;
}
else
{
nRotX -= (rotateStartX - MousePos.X) * rotateSpeed * (f32)elapsed/500;
nRotY -= (rotateStartY - MousePos.Y) * rotateSpeed * (f32)elapsed/500;
rotX = nRotX;//rotX - (rotateStartX - MousePos.X) * rotateSpeed * (f32)elapsed/500;
rotY = nRotY;//rotY - (rotateStartY - MousePos.Y) * rotateSpeed * (f32)elapsed/500;
if(rotY < -350)
{
rotY = -350;
nRotY = -350;
}
if(rotY > -280)
{
rotY = -280;
nRotY = -280;
}
printf("PERA CAMERA:%f\n", rotY);
}
}
else
{
if (rotating)
{
rotX = rotX - (rotateStartX - MousePos.X) * rotateSpeed * (f32)elapsed/500;
rotY = rotY - (rotateStartY - MousePos.Y) * rotateSpeed * (f32)elapsed/500;
nRotX = rotX;
nRotY = rotY;
}
rotating = false;
}
//Translate
if(isMouseButtonDown(MOUSE_BUTTON_RIGHT) && (isKeyDown(KEY_SHIFT) || isKeyDown(KEY_LSHIFT) || isKeyDown(KEY_RSHIFT)))
{
movebymouse = true;
if (!translating)
{
translateStartX = MousePos.X;
translateStartY = MousePos.Y;
translating = true;
}
else
{
translate += tvectX * (translateStartX - MousePos.X) * translateSpeed * (f32)elapsed/100;
translate.X += tvectX.Z * (translateStartY - MousePos.Y) * translateSpeed * (f32)elapsed/100;
translate.Z -= tvectX.X * (translateStartY - MousePos.Y) * translateSpeed * (f32)elapsed/100;
oldTarget = translate;
}
}
else if (isKeyDown(KEY_KEY_W) || isKeyDown(KEY_UP) && !zooming && !isKeyDown(KEY_SHIFT) && !isKeyDown(KEY_LSHIFT) && !isKeyDown(KEY_RSHIFT))
{
if (!translating)
translating = true;
else
{
vector3df movevector = getPosition() - getTarget();
movevector.Y = 0;
movevector.normalize();
translate =getTarget() - movevector * translateSpeed * (f32)elapsed/100;
oldTarget = translate;
//setPosition(getPosition() - movevector * translateSpeed * (f32)elapsed/100);
//setTarget(getTarget() - movevector * translateSpeed * (f32)elapsed/100);
//updateAbsolutePosition();
}
}
else if (isKeyDown(KEY_KEY_S) || isKeyDown(KEY_DOWN) && !zooming && !isKeyDown(KEY_SHIFT) && !isKeyDown(KEY_LSHIFT) && !isKeyDown(KEY_RSHIFT))
{
if (!translating)
translating = true;
else
{
vector3df movevector = getPosition() - getTarget();
movevector.Y = 0;
movevector.normalize();
translate =getTarget() + movevector * translateSpeed * (f32)elapsed/100;
oldTarget = translate;
// setPosition(getPosition() + movevector * translateSpeed * (f32)elapsed/100);
// setTarget(getTarget() + movevector * translateSpeed * (f32)elapsed/100);
// updateAbsolutePosition();
}
}
else if (isKeyDown(KEY_KEY_A) || isKeyDown(KEY_LEFT) && !zooming && !isKeyDown(KEY_SHIFT) && !isKeyDown(KEY_LSHIFT) && !isKeyDown(KEY_RSHIFT))
{
if (!translating)
translating = true;
else
{
/*translate += tvectX * (translateStartX - MousePos.X) * translateSpeed * (f32)elapsed/100;
translate.X += tvectX.Z * (translateStartY - MousePos.Y) * translateSpeed * (f32)elapsed/100;
translate.Z -= tvectX.X * (translateStartY - MousePos.Y) * translateSpeed * (f32)elapsed/100;
*/
//= translate;
vector3df totargetvector = getPosition() - getTarget();
totargetvector.normalize();
vector3df crossvector = totargetvector.crossProduct(getUpVector());
vector3df strafevector = crossvector.normalize();
translate =getTarget() - strafevector * translateSpeed * (f32)elapsed/100;
oldTarget = translate;
//setPosition(getPosition() - strafevector * translateSpeed * (f32)elapsed/100);
//setTarget(getTarget() - strafevector * translateSpeed * (f32)elapsed/100);
//oldTarget = getTarget();
//updateAbsolutePosition();
}
}
else if (isKeyDown(KEY_KEY_D) || isKeyDown(KEY_RIGHT) && !zooming && !isKeyDown(KEY_SHIFT) && !isKeyDown(KEY_LSHIFT) && !isKeyDown(KEY_RSHIFT))
{
if (!translating)
translating = true;
else
{
vector3df totargetvector = getPosition() - getTarget();
totargetvector.normalize();
vector3df crossvector = totargetvector.crossProduct(getUpVector());
vector3df strafevector = crossvector.normalize();
translate =getTarget() + strafevector * translateSpeed * (f32)elapsed/100;
oldTarget = translate;
//setPosition(getPosition() + strafevector * translateSpeed * (f32)elapsed/100);
//setTarget(getTarget() + strafevector * translateSpeed * (f32)elapsed/100);
//updateAbsolutePosition();
}
}
else
{
translating = false;
/*moving camera when mouse on screen edges*/
/*if (!translating && !zooming && !rotating)
{
//Mouse Coordinates go from 0 to 1 on both axes
if (MousePos.X < 0.05) //Up
{
vector3df totargetvector = getPosition() - getTarget();
totargetvector.normalize();
vector3df crossvector = totargetvector.crossProduct(getUpVector());
vector3df strafevector = crossvector.normalize();
setPosition(getPosition() - strafevector * translateSpeed);
setTarget(getTarget() - strafevector * translateSpeed);
updateAbsolutePosition();
}
else if (MousePos.X > 0.95) //Down
{
vector3df totargetvector = getPosition() - getTarget();
totargetvector.normalize();
vector3df crossvector = totargetvector.crossProduct(getUpVector());
vector3df strafevector = crossvector.normalize();
setPosition(getPosition() + strafevector * translateSpeed);
setTarget(getTarget() + strafevector * translateSpeed);
updateAbsolutePosition();
}
else if (MousePos.Y < 0.05) //Up
{
vector3df movevector = getPosition() - getTarget();
movevector.Y = 0;
movevector.normalize();
setPosition(getPosition() - movevector * translateSpeed);
setTarget(getTarget() - movevector * translateSpeed);
updateAbsolutePosition();
}
else if (MousePos.Y > 0.95) //Down
{
vector3df movevector = getPosition() - getTarget();
movevector.Y = 0;
movevector.normalize();
setPosition(getPosition() + movevector * translateSpeed);
setTarget(getTarget() + movevector * translateSpeed);
updateAbsolutePosition();
}
}*/
}
//Set Position
//if(movebymouse)
//{
Target = translate;
Pos.X = nZoom + Target.X;
Pos.Y = Target.Y;
Pos.Z = Target.Z;
Pos.rotateXYBy(nRotY, Target);
Pos.rotateXZBy(-nRotX, Target);
//Correct Rotation Error
UpVector.set(0,1,0);
UpVector.rotateXYBy(-nRotY, core::vector3df(0,0,0));
UpVector.rotateXZBy(-nRotX+180.f, core::vector3df(0,0,0));
//}
}
glm::mat4 Camera::calculateViewMatrix() const
{
return glm::lookAt(getPosition(), getLookingAt(), getUpVector());
}
