int TCamera::setAttribute (const string& rktNAME, NAttribute nVALUE, EAttribType eTYPE)
{
if ( rktNAME == "up" )
{
if ( eTYPE == FX_VECTOR )
{
setUp (*((TVector*) nVALUE.pvValue));
}
else
{
return FX_ATTRIB_WRONG_TYPE;
}
}
else if ( rktNAME == "look_at" )
{
if ( eTYPE == FX_VECTOR )
{
setLookAt (*((TVector*) nVALUE.pvValue));
}
else
{
return FX_ATTRIB_WRONG_TYPE;
}
}
else
{
return TEntity::setAttribute (rktNAME, nVALUE, eTYPE);
}
return FX_ATTRIB_OK;
} /* setAttribute() */
void Camera::updateCameraRotation() {
double xPos, yPos;
glfwGetCursorPos(m_window, &xPos, &yPos); // get current mouse position
// if mouse still in window center, no need to recalculate view matrix
if (xPos == m_windowWidth / 2 && yPos == m_windowHeight / 2) {
return;
}
centerMouse();
m_horizontalAngle += float(m_windowWidth / 2 - xPos) * m_mouseSpeed;
m_verticalAngle += float(m_windowHeight / 2 - yPos) * m_mouseSpeed;
glm::vec3 oldLookIn = getLookAt() - getCenter();
glm::vec3 lookInHorizontal = glm::vec3(sin(m_horizontalAngle), oldLookIn.y, cos(m_horizontalAngle));
glm::vec3 lookInVertical = glm::vec3(oldLookIn.x * cos(m_verticalAngle), sin(m_verticalAngle), oldLookIn.z * cos(m_verticalAngle));
glm::vec3 newLookIn = glm::normalize(lookInHorizontal + lookInVertical);
setLookAt(getCenter() + newLookIn);
float rightHorizontalAngle = m_horizontalAngle - PI / 2.0f;
setRight(glm::vec3(sin(rightHorizontalAngle), getRight().y, cos(rightHorizontalAngle)));
setUp(glm::normalize(glm::cross(getRight(), newLookIn)));
}
void Camera::updateCameraMovement(double prevTime) {
double currTime = glfwGetTime();
float deltaTime = float(currTime - prevTime);
glm::vec3 position = getCenter();
glm::vec3 lookIn = getLookAt() - getCenter();
glm::vec3 forward = glm::vec3(lookIn.x, 0, lookIn.z);
bool moved = false;
// Move forward
if (glfwGetKey(m_window, GLFW_KEY_W) == GLFW_PRESS){
position += forward * deltaTime * m_moveSpeed;
moved = true;
}
// Move backward
if (glfwGetKey(m_window, GLFW_KEY_S) == GLFW_PRESS){
position -= forward * deltaTime * m_moveSpeed;
moved = true;
}
// Strafe right
if (glfwGetKey(m_window, GLFW_KEY_D) == GLFW_PRESS){
position += getRight() * deltaTime * m_moveSpeed;
moved = true;
}
// Strafe left
if (glfwGetKey(m_window, GLFW_KEY_A) == GLFW_PRESS){
position -= getRight() * deltaTime * m_moveSpeed;
moved = true;
}
setCenter(position);
setLookAt(getCenter() + lookIn);
}
void Camera::tic(uint64_t time) {
vec3 temp1, temp2;
vec3 tempVec;
mat4 tempMatrix;
float pathAccOffset = 0.0;
// Find the angle between the two paths
// float rotAngle = m_pathAngle * (m_head->getPosition() - m_pathPos).Length()
// / ((m_head->getPosition() - m_tail->getPosition()).Length()
// - CAMERA_LOOK_AHEAD_DISTANCE);
// If we are turning our forward, but the angle between ourselves and
// the intended is close enough, stop turning to allow for rotation
/*if (m_turning && .5 >
angleBetween(m_head->getPosition() - m_tail->getPosition(),
m_pathRef - m_pathPos)) {
m_turning = false;
m_pathPos = m_pathRef - ((m_head->getPosition()
- m_tail->getPosition()).Normalized()
* CAMERA_LOOK_AHEAD_DISTANCE);
// m_pathUp = m_tail->getUp();
//}
// If we aren't turning, its safe to rotate
//if (!m_turning) {*/
temp1 = m_tail->getUp() * (m_head->getPosition() - m_pathRef).Length() /
(m_head->getPosition() - m_tail->getPosition()).Length();
temp2 = m_head->getUp() * (m_pathRef - m_tail->getPosition()).Length() /
(m_head->getPosition() - m_tail->getPosition()).Length();
m_pathUp = (temp1 + temp2).Normalized();
// }
// Move our reference point down the path
if (m_boosting) {
m_boostTime += time;
if (m_boostTime > 2000) {
m_boostTime = 2000;
}
pathAccOffset = (CAMERA_BOOST_ACC * m_boostTime);
}
else {
m_boostTime -= time * 3;
if(m_boostTime < 0) {
m_boostTime = 0;
}
}
m_pathRef += (((m_head->getPosition() - m_pathRef).Normalized()) *
((time * CAMERA_DEF_VELOCITY) + pathAccOffset));
calculateSide();
tempVec = (m_pathRef - m_pathPos).Normalized();
m_pathPos = m_pathRef - (tempVec * CAMERA_LOOK_AHEAD_DISTANCE);
setLookAt();
}
void DisplayItem::touchEvent(QTouchEvent* event) {
if (event->touchPointStates() & Qt::TouchPointPressed) {
if (event->touchPoints().size() == 2) {
QPointF p1 = mapFromScreen(event->touchPoints()[0].pos());
QPointF p2 = mapFromScreen(event->touchPoints()[1].pos());
m_distance = QVector2D(p1 - p2).length();
}
}
if (event->touchPoints().size() == 1) {
if (flickable()) {
QPointF p1 = mapFromScreen(event->touchPoints().front().lastPos());
QPointF p2 = mapFromScreen(event->touchPoints().front().pos());
setLookAt(effectiveLookAt() - p2 + p1);
} else
event->ignore();
} else if (event->touchPoints().size() == 2) {
QPointF p1 = mapFromScreen(event->touchPoints()[0].pos());
QPointF p2 = mapFromScreen(event->touchPoints()[1].pos());
qreal distance = QVector2D(p1 - p2).length();
setFactor(factor() * distance / m_distance);
} else
event->ignore();
}
FreeCamera::FreeCamera(glm::vec3 pos, glm::vec3 center, float acc, float max_speed) :
BaseCamera(pos, center, 4), acc(acc), max_speed(max_speed) {
keys[FORWARD] = 'w';
keys[BACK] = 's';
keys[LEFT] = 'a';
keys[RIGHT] = 'd';
setLookAt(center);
min_limit = 0;
max_limit = 100000000000;
}
void Camera::turn (float const x, float const y, float const speed){
glm::vec3 newVec3;
glm::vec3 right;
//Translate to the origin
translateOrigin();
//calculate right vector
//Rotate about x
setLookAt(glm::mat3(glm::rotate(speed * y, getRight()))*lookAt);
//Rotate about y
glm::vec3 currentUp = getCurrentUp();
setLookAt(glm::mat3(glm::rotate(speed * x, currentUp))*lookAt);
//Translate back to previous position
translatePosition();
}
void
Camera::calcLookAt()
{
// this is true when a "lookat" is not used in the config file
if (m_lookAt.x != FLT_MAX)
{
setLookAt(m_lookAt);
m_lookAt.set(FLT_MAX, FLT_MAX, FLT_MAX);
}
}
void Camera::dragMouse( int x, int y )
{
Vec3f mouseDelta = Vec3f(x,y,0.0f) - mLastMousePosition;
mLastMousePosition = Vec3f(x,y,0.0f);
switch(mCurrentMouseAction)
{
case kActionTranslate:
{
calculateViewingTransformParameters();
double xTrack = -mouseDelta[0] * kMouseTranslationXSensitivity;
double yTrack = mouseDelta[1] * kMouseTranslationYSensitivity;
Vec3f transXAxis = mUpVector ^ (mPosition - mLookAt);
transXAxis /= sqrt((transXAxis*transXAxis));
Vec3f transYAxis = (mPosition - mLookAt) ^ transXAxis;
transYAxis /= sqrt((transYAxis*transYAxis));
setLookAt(getLookAt() + transXAxis*xTrack + transYAxis*yTrack);
break;
}
case kActionRotate:
{
float dAzimuth = -mouseDelta[0] * kMouseRotationSensitivity;
float dElevation = mouseDelta[1] * kMouseRotationSensitivity;
setAzimuth(getAzimuth() + dAzimuth);
setElevation(getElevation() + dElevation);
if (getAzimuth() > M_PI)
mAzimuth -= 2.0*M_PI;
if (getElevation() > M_PI)
mElevation -= 2.0*M_PI;
fprintf(stderr, "az %f, elev %f\n", mAzimuth, mElevation);
break;
}
case kActionZoom:
{
float dDolly = -mouseDelta[1] * kMouseZoomSensitivity;
setDolly(getDolly() + dDolly);
break;
}
case kActionTwist:
// Not implemented
default:
break;
}
}
Camera::Camera(void)
{
_lookAt = std::vector<GLfloat>(3,0.0f);
_distance = std::vector<GLfloat>(3,0.0f);
_extraRot = std::vector<GLfloat>(3,0.0f);
setLookAt(0.0f,0.0f,0.0f);
_distance[0] = 4.0f;
_distance[1] = 1.0f;
_distance[2] = 4.0f;
}
void Camera::moveForward(float units){
glm::vec3 newPosition = position - lookAt;
newPosition = glm::normalize(newPosition);
//move both position and lookAt
setPosition(position.x - (units*newPosition.x),
position.y - (units*newPosition.y),
position.z - (units*newPosition.z));
setLookAt(lookAt.x - (units*newPosition.x),
lookAt.y - (units*newPosition.y),
lookAt.z - (units*newPosition.z));
}
Camera::Camera(GLFWwindow *window) {
m_window = window;
getWindowDimensions();
centerMouse();
initVars();
setCenter(glm::vec3(0, 0, 5));
setLookAt(glm::vec3(0, 0, 4));
setUp(glm::vec3(0, 1, 0));
setRight(glm::vec3(1, 0, 0));
updateViewMatrix();
}
SpotLight::SpotLight( const Vector3f& position, const Vector3f& center, const Vector3f& up,
float fovYRadians, float zNear, float zFar, float aspect,
const Vector3f& color, const Vector3f& distanceFalloff ) :
m_fovYRadians( fovYRadians ),
m_zNear( zNear ),
m_zFar( zFar ),
m_aspect( aspect ),
m_color( color ),
m_distanceFalloff( distanceFalloff )
{
setLookAt( position, center, up );
}
void bsCamera::animate(void)
{
#if 0
if(mNumFrames>0 && mAnimation)
{
double pos[3],dir[3],up[3];
int gotpos, gotdir;
GetCamera(mAnimation,mCurrentTime,&gotpos,pos,&gotdir,dir,up);
if(gotpos) setPosition(Vec3f(pos[0],pos[1],pos[2]));
if(gotdir)
{
setLookAt(Vec3f(pos[0]+dir[0],pos[1]+dir[1],pos[2]+dir[2]));
setUpVector(Vec3f(up[0],up[1],up[2]));
}
}
#endif
}
void Camera::moveRight(float units){
//Translate to origin
translateOrigin();
//Calculate right vector
glm::vec3 right = getRight();
//Normalize right vector
right = glm::normalize(right);
glm::mat4 transMat = glm::translate(right*units);
//Translate back
translatePosition();
//move both position and lookAt
setLookAt(glm::vec3(transMat*glm::vec4(lookAt, 1)));
setPosition(glm::vec3(transMat*glm::vec4(position, 1)));
}
//----------------------------------------
ofx2DCam::ofx2DCam(){
setLookAt(OFX2DCAM_FRONT);
lastTap = 0;
bApplyInertia =false;
bDoTranslate = false;
bDistanceSet = false;
bDoScale = false;
reset();
parameters.setName("ofx2Dcam");
parameters.add(bEnableMouse.set("Enable Mouse Input", false));
parameters.add(dragSensitivity.set("Drag Sensitivity", 1, 0, 3));
parameters.add(scrollSensitivity.set("Scroll Sensitivity", 10, 0, 30));
parameters.add(drag.set("Drag", 0.9, 0, 1));
parameters.add(farClip.set("Far Clip", 2000, 5000, 10000));
parameters.add(nearClip.set("Near Clip", -1000, -5000, 10000));
bEnableMouse.addListener(this, &ofx2DCam::enableMouseInputCB);
enableMouseInput();
}
Camera::Camera()
{
setPerspective(glm::radians(60.0f), 1280.0f / 720.0f, 0.1f, 1000.f);
setLookAt(vec3(-5, 10, 4), vec3(4, 0, 4), vec3(0, 1, 0));
}
void Camera::dragMouse( int x, int y )
{
Vec3f mouseDelta = Vec3f(x,y,0.0f) - mLastMousePosition;
switch(mCurrentMouseAction)
{
case kActionTranslate:
{
// Determine mouse movement
double xTrack = -mouseDelta[0] * kMouseTranslationXSensitivity;
double yTrack = mouseDelta[1] * kMouseTranslationYSensitivity;
// Recalculate stuff if needed
if (m_bDirtyTransform)
{
updateTransform();
}
// Determine directions of motion in scene space
Vec3f direction = m_vPosition - m_vLookAt;
Vec3f transXAxis = m_vUpVector ^ direction;
transXAxis /= sqrt((transXAxis*transXAxis));
Vec3f transYAxis = direction ^ transXAxis;
transYAxis /= sqrt((transYAxis*transYAxis));
// Move the camera's look-at point
setLookAt(getLookAt() + transXAxis*xTrack + transYAxis*yTrack);
break;
}
case kActionRotate:
{
// Store the rotation in this quarternion
float quat[4];
// Get the mouse coordinates in a range between -1.0 and 1.0
float viewHalfWidth = (m_iViewportWidth / 2.f), viewHalfHeight = (m_iViewportHeight / 2.f);
float oldX = mLastMousePosition[0] * 2.f / (m_iViewportWidth - 1) - 1.f,
oldY = mLastMousePosition[1] * 2.f / (m_iViewportHeight - 1) - 1.f,
newX = x * 2.f / (m_iViewportWidth - 1) - 1.f,
newY = y * 2.f / (m_iViewportHeight - 1) - 1.f;
// Get the quaternion to rotate around, from the trackball code.
trackball( quat, oldX, -oldY, newX, -newY );
// Add the new quaternion to the current one.
float oldQuat[4];
memcpy(oldQuat, m_fQuat, sizeof(float) * 4);
//add_quats(oldQuat, quat, m_fQuat);
add_quats(quat, oldQuat, m_fQuat);
// Update the transform parameters.
updateTransform();
break;
}
case kActionZoom:
{
// Determine dolly movement.
float fDollyDelta = -mouseDelta[1] * kMouseZoomSensitivity;
// Add to dolly
setDolly(getDolly() + fDollyDelta);
updateTransform();
break;
}
case kActionTwist:
{
break;
}
default:
break;
}
mLastMousePosition = Vec3f(x,y,0.0f);
}
void nRenderer::bindCam(nCamera *c) {
activeCam = c;
if(c) {
setLookAt(c->getPosition(), c->getLookAt());
}
}
void DisplayItem::mouseMoveEvent(QMouseEvent* event) {
if (!m_buttonDown) return event->ignore();
QPointF p = mapFromScreen(event->pos());
setLookAt(effectiveLookAt() - p + m_startPoint);
}
void CCCameraBase::setLookAtY(const float y)
{
setLookAt( CCVector3( lookAt.x, y, lookAt.z ) );
}
void DisplayItem::focusedObjectPositionChanged() {
setLookAt(-focusedObject()->matrix() * QPointF(0, 0));
}
