void Camera::input()
{
float sensitivity = 0.5f;
float movAmt = (float)(10 * Time::getDelta());
float rotAmt = (float)(100 * Time::getDelta());
if (Input::getKey(KEY::KEY_ESCAPE))
{
Input::setCursor(true);
mouseLocked = false;
}
if (mouseLocked)
{
Vector2f centerPosition = Vector2f((float)Window::getWidth() / 2.0f, (float)Window::getHeight() / 2.0f);
Vector2f deltaPos = Input::getMousePosition() - centerPosition;
bool rotY = deltaPos.x != 0;
bool rotX = deltaPos.y != 0;
if (rotY)
rotateY(deltaPos.x * sensitivity);
if (rotX)
rotateX(deltaPos.y * sensitivity);
if (rotY || rotX)
Input::setMousePosition(centerPosition);
}
if (Input::getMouseDown(MOUSE::LEFT_MOUSE))
{
Vector2f centerPosition = Vector2f((float)Window::getWidth() / 2.0f, (float)Window::getHeight() / 2.0f);
Input::setMousePosition(centerPosition);
Input::setCursor(false);
mouseLocked = true;
}
if (Input::getKey(KEY::KEY_W))
move(getForward(), movAmt);
if (Input::getKey(KEY::KEY_S))
move(getForward(), -movAmt);
if (Input::getKey(KEY::KEY_A))
move(getLeft(), movAmt);
if (Input::getKey(KEY::KEY_D))
move(getRight(), movAmt);
//if(Input::getKey(KEY::KEY_UP))
// rotateX(-rotAmt);
//if(Input::getKey(KEY::KEY_DOWN))
// rotateX(rotAmt);
//if(Input::getKey(KEY::KEY_LEFT))
// rotateY(-rotAmt);
//if(Input::getKey(KEY::KEY_RIGHT))
// rotateY(rotAmt);
}
vector<double> ForwardRateSource::getForwardFworwardMultiplicative(Date fromDate, vector<Date> toDates) const
{
vector<double> rates = getForward(toDates);
double fromRate = getForward(fromDate);
for (size_t i = 0; i < toDates.size(); ++i)
{
rates[i] /= fromRate;
}
return rates;
}
boost::shared_ptr<ForwardRateSource> ForwardCurveCMADeterministic::rollForward(Date toDate)
{
vector<Date> originalDates = curve->getObservationDates();
vector<Date> rolledObservationDates;
vector<double> rolledFwds;
if (!isInRange(toDate))
{
rolledObservationDates.push_back(toDate);
rolledFwds.push_back(1.0);
}
else
{
for (size_t i = 0; i < originalDates.size(); ++i)
{
if (originalDates[i] >= toDate)
{
rolledObservationDates.push_back(originalDates[i]);
rolledFwds.push_back(getForward(originalDates[i]));
}
}
}
return boost::shared_ptr<ForwardCurveCMADeterministic>(
new ForwardCurveCMADeterministic(toDate,
rolledObservationDates,
rolledFwds,
LINEAR,
true));
}
void CameraUtility::moveForward(float distance) {
Vector3f position = getPosition();
Vector3f forward = getForward();
Vector3f change = forward * distance;
position += change;
setPosition(position);
}
Vehicle* Balaenidae::spawn(dWorldID world,dSpaceID space,int type, int number)
{
Vehicle *v;
if (type == MANTA)
{
SimplifiedDynamicManta *_manta1 = new SimplifiedDynamicManta(getFaction());
_manta1->init();
_manta1->setNumber(number);
_manta1->embody(world, space);
_manta1->setPos(pos[0],pos[1]+28, pos[2]);
_manta1->setStatus(Manta::ON_DECK);
_manta1->inert = true;
alignToMe(_manta1->getBodyID());
v = (Vehicle*)_manta1;
} else if (type == WALRUS)
{
Walrus *_walrus = new Walrus(getFaction());
_walrus->init();
_walrus->setNumber(number);
_walrus->embody(world,space);
Vec3f p;
p = p.normalize();
p = getForward()*450;
_walrus->setPos(pos[0]-p[0],pos[1]-p[1],pos[2]-p[2]);
_walrus->setStatus(Walrus::SAILING);
_walrus->stop();
alignToMe(_walrus->getBodyID());
v = (Vehicle*)_walrus;
}
return v;
}
void kore::Camera::moveForward(float fSpeed) {
if (!_sceneNode) {
return;
}
_sceneNode->translate(-getForward() * fSpeed, SPACE_WORLD);
}
boost::shared_ptr<ForwardRateSource> ForwardCurveStochasticFX::rollForward(Date toDate, double normalRV)
{
double rolledSpot = getForward(toDate);
double sd = vrs->getStandardDeviation(toDate);
rolledSpot *= exp(-sd * sd / 2 + sd * normalRV);
vector<Date> rolledDRSDates = getRolledDatesAheadOf(toDate);;
vector<double> domesticDF = vector<double>(rolledDRSDates.size());
vector<double> foreignDF = vector<double>(rolledDRSDates.size());
double domesticScalingFactor = domesticDRS->getDiscountFactor(toDate);
double foreignScalingFactor = foreignDRS->getDiscountFactor(toDate);
for (size_t i = 0; i < rolledDRSDates.size(); ++i)
{
domesticDF[i] = domesticDRS->getDiscountFactor(rolledDRSDates[i]) / domesticScalingFactor;
foreignDF[i] = foreignDRS->getDiscountFactor(rolledDRSDates[i]) / foreignScalingFactor;
}
boost::shared_ptr<DiscountRateSource> rolledDomesticDRS = boost::shared_ptr<DiscountRateSource>(
new DiscountCurve(toDate, rolledDRSDates, domesticDF, LINEAR, allowExtrapolation));
boost::shared_ptr<DiscountRateSource> rolledForeighDRS = boost::shared_ptr<DiscountRateSource>(
new DiscountCurve(toDate, rolledDRSDates, foreignDF, LINEAR, allowExtrapolation));
return boost::shared_ptr<ForwardRateSource>(new ForwardCurveFX(toDate,
rolledSpot,
rolledDomesticDRS,
rolledForeighDRS));
}
void Ship :: update (WorldInterface& r_world)
{
if (isUnitAiSet())
{
if (!desired_velocity.isZero())
{
double theta = max_rotation_rate * TimeSystem::getFrameDuration();
if(theta > 0.0)
{
rotateTowards(desired_velocity.getNormalized(), theta);
}
double delta = max_acceleration * TimeSystem::getFrameDuration();
if(delta > 0.0)
{
double currentSpeed = getSpeed();
double desiredSpeed = desired_velocity.getNorm();
if (currentSpeed < desiredSpeed)
{
currentSpeed += delta;
if (currentSpeed > desiredSpeed) currentSpeed = desiredSpeed;
setSpeed(currentSpeed);
}
else if (currentSpeed > desiredSpeed)
{
currentSpeed -= delta;
if (currentSpeed < desiredSpeed) currentSpeed = desiredSpeed;
setSpeed(currentSpeed);
}
}
}
if (wantsToFire && isReloaded())
{
r_world.addBullet(getPosition(), getForward(), getId());
wantsToFire = false;
markReloading();
}
}
if(isAlive() && isDying())
{
r_world.addExplosion(getPositionPrevious(), getRadius() * EXPLOSION_SIZE_FACTOR, 0);
m_is_dead = true;
// no further updates
assert(invariant());
return;
}
if(isAlive())
{
updateBasic(); // moves the Ship
m_reload_timer += TimeSystem::getFrameDuration();
}
assert(invariant());
}
void
OpenSteer::SimpleVehicle::measurePathCurvature (const float elapsedTime)
{
if (elapsedTime > 0)
{
const Vector3 dP = _lastPosition - getPosition();
const Vector3 dF = (_lastForward - getForward()) / dP.length();
const Vector3 lateral = Vec3Utils::perpendicularComponent(dF, getForward());
const float sign = (lateral.dotProduct(getSide()) < 0) ? 1.0f : -1.0f;
_curvature = lateral.length() * sign;
blendIntoAccumulator (elapsedTime * 4.0f,
_curvature,
_smoothedCurvature);
_lastForward = getForward();
_lastPosition = getPosition();
}
}
vector<boost::shared_ptr<ForwardRateSource> > ForwardRateSourceStochastic::rollForward(vector<Date> rateSetDates,
vector<double> &rateSetsFromAnchorToFinalRollDate)
{
vector<boost::shared_ptr<ForwardRateSource> > frss = rollForward();
rateSetsFromAnchorToFinalRollDate = vector<double>(rateSetDates.size(), 0);
Date startDate = anchorDate;
Date endDate = forwardSimulationDates[0];
vector<Date>::iterator startIt, endIt;
endIt = upper_bound(rateSetDates.begin(), rateSetDates.end(), endDate);
vector<Date> rateSetSubset = vector<Date>(rateSetDates.begin(), endIt);
double expectedFwd = getForward(endDate);
double simulatedFwd = frss[0]->getForward(endDate);
double ratio = (simulatedFwd - expectedFwd) / expectedFwd;
double denominator = (double) (endDate - startDate);
size_t index = 0;
for (size_t j = 0; j < rateSetSubset.size(); ++j)
{
double adjustedFwd = getForward(rateSetSubset[j]) * (1 + ratio * ((double) (rateSetSubset[j] - startDate)) / denominator);
rateSetsFromAnchorToFinalRollDate[index] = (adjustedFwd);
++index;
}
for (size_t i = 1; i < forwardSimulationDates.size(); ++i)
{
startDate = endDate;
endDate = forwardSimulationDates[i];
startIt = endIt;
endIt = upper_bound(rateSetDates.begin(), rateSetDates.end(), endDate);
rateSetSubset = vector<Date>(startIt, endIt);
expectedFwd = frss[i-1]->getForward(endDate);
simulatedFwd = frss[i]->getForward(endDate);
ratio = (simulatedFwd - expectedFwd) / expectedFwd;
denominator = (double) (endDate - startDate);
for (size_t j = 0; j < rateSetSubset.size(); ++j)
{
double adjustedFwd = frss[i-1]->getForward(rateSetSubset[j]);
adjustedFwd *= (1 + ratio * ((double) (rateSetSubset[j] - startDate)) / denominator);
rateSetsFromAnchorToFinalRollDate[index] = (adjustedFwd);
++index;
}
}
return frss;
}
//!Set the Forward score for the given cell
//!\param seqPos Sequence position
//!\param currState State index
//!\param value Forward score
void simpleTrellis::setForward(size_t seqPos, size_t currState,double& value) {
if (getForward()==-INFINITY) {
trell[seqPos][currState].forw=value;
}
else {
trell[seqPos][currState].forw=addLog(trell[seqPos][currState].forw, value);
}
return;
}
vector<double> ForwardRateSource::getForward(vector<Date> toDates) const
{
vector<double> rates;
for (size_t i = 0; i < toDates.size(); ++i)
{
rates.push_back(getForward(toDates[i]));
}
return rates;
}
void CameraUtility::rotateWorldYInPlace(Single angleDegrees) {
Matrix3x3f rotation;
rotation.setToRotationY(angleDegrees);
Vector3f up = rotation * getUp();
Vector3f forward = rotation * getForward();
ms_gameControllerInstance->m_vmdApp->display->set_eye_dir(&forward[0]);
ms_gameControllerInstance->m_vmdApp->display->set_eye_up(&up[0]);
}
boost::shared_ptr<ForwardRateSource> ForwardRateSourceStochastic::rollForward(Date toDate,
double normalRV,
vector<Date> rateSetDates,
vector<double> &rateSetsFromAnchorToDate)
{
boost::shared_ptr<ForwardRateSource> rolledRate = rollForward(toDate, normalRV);
double expectedFwd = getForward(toDate);
double simulatedFwd = rolledRate->getForward(toDate);
double ratio = (simulatedFwd - expectedFwd) / expectedFwd;
rateSetsFromAnchorToDate.clear();
double denominator = (double) (toDate - anchorDate);
for (size_t i = 0; i < rateSetDates.size(); ++i)
{
double adjustedFwd = getForward(rateSetDates[i]) * (1 + ratio * ((double) (rateSetDates[i] - anchorDate)) / denominator);
rateSetsFromAnchorToDate.push_back(adjustedFwd);
}
return rolledRate;
}
void CameraUtility::yaw(float angleDegrees) {
Vector3f up = getUp();
Vector3f forward = getForward();
Matrix4 currentTransform;
currentTransform.rotate_axis(&up[0], angleDegrees);
currentTransform.multpoint3d(&forward[0], &forward[0]);
ms_displayDevice->set_eye_dir(&forward[0]);
}
//!Set the Forward score for the given cell
//!\param val Forward score
void simpleTrellis::setForward(double& value) {
if (getForward()==-INFINITY) {
trell[sequencePosition][currentState].forw=value;
}
else {
trell[sequencePosition][currentState].forw=addLog(trell[sequencePosition][currentState].forw, value);
}
return;
}
CoordinateSystem Ship :: getCameraCoordinateSystem () const
{
const Vector3& forward = getForward();
const Vector3& up = getUp();
Vector3 camera_at = getPosition() +
forward * CAMERA_FORWARD_DISTANCE +
up * CAMERA_UP_DISTANCE;
return CoordinateSystem(camera_at, forward, up);
}
void CameraUtility::rotateWorld(Single angleDegrees, const Vector3f& axis) {
Matrix3x3f rotation;
rotation.setFromAngleAxis(angleDegrees, axis);
Vector3f up = rotation * getUp();
Vector3f forward = rotation * getForward();
Vector3f position = rotation * getPosition();
ms_gameControllerInstance->m_vmdApp->display->set_eye_dir(&forward[0]);
ms_gameControllerInstance->m_vmdApp->display->set_eye_up(&up[0]);
ms_gameControllerInstance->m_vmdApp->display->set_eye_pos(&position[0]);
}
vector<boost::shared_ptr<ForwardRateSource> > ForwardCurveStochasticFX::rollForward()
{
vector<boost::shared_ptr<ForwardRateSource> > returnFrss = vector<boost::shared_ptr<ForwardRateSource> >(frss.size());
for (size_t i = 0; i < forwardSimulationDates.size(); ++i)
{
double bumpedSpot = getForward(forwardSimulationDates[i]);
bumpedSpot *= exp(-standardDeviations[i] * standardDeviations[i] / 2 + standardDeviations[i] * normalRVs[i]);
frss[i]->setSpotAtT0(bumpedSpot);
returnFrss[i] = frss[i];
}
return returnFrss;
}
void SteeringVehicle::resetLocalSpace()
{
setForward(mForwardVector);
setSide(localRotateForwardToSide(getForward()));
setUp(Vector3::UNIT_Y);
Vector3 pos = mCreature->getPosition();
setPosition(pos);
Vector3 src = mCreature->getOrientation()*Vector3::NEGATIVE_UNIT_Z;
// regenerate local space(by default: align vehicle's forward axis with
// new velocity, but this behavior may be overridden by derived classes.)
regenerateOrthonormalBasisUF(src);
}
void FirstPersonCamera::update(double elapsedTime)
{
glm::vec2 movementAmount = glm::vec2(0.0f);
bool changedPosition = false;
if (mInput.isKeyDown(GLFW_KEY_W)) {
movementAmount.y = 1.0f;
changedPosition = true;
}
if (mInput.isKeyDown(GLFW_KEY_S)) {
movementAmount.y = -1.0f;
changedPosition = true;
}
if (mInput.isKeyDown(GLFW_KEY_A)) {
movementAmount.x = 1.0f;
changedPosition = true;
}
if (mInput.isKeyDown(GLFW_KEY_D)) {
movementAmount.x = -1.0f;
changedPosition = true;
}
const float fElapsedTime = static_cast<float>(elapsedTime);
bool changedOrientation = false;
glm::vec2 mouseDelta(0.0f);
//if (mInput.isMouseButtonDown(GLFW_MOUSE_BUTTON_LEFT)) {
const glm::vec2 mousePos = mInput.getMousePosition();
mouseDelta = mousePos - mPrevMousePos;
mPrevMousePos = mousePos;
changedOrientation = (mouseDelta != glm::vec2(0.0f));
//}
if (changedOrientation) {
const float pitch = mouseDelta.y * mMouseSensitivity * mRotationRate * fElapsedTime;
const float yaw = -mouseDelta.x * mMouseSensitivity * mRotationRate * fElapsedTime;
offsetOrientation(pitch, yaw);
}
if (changedPosition) {
glm::vec2 movement = movementAmount * mMovementRate * fElapsedTime;
glm::vec3 strafe = getRight() * movement.x;
glm::vec3 forward = getForward() * movement.y;
setPosition(getPosition() + strafe + forward);
}
Camera::update(elapsedTime);
}
void Camera::update(float delta)
{
//acceleration = glm::vec3(0.f, 0.f, 0.f);
if (inputManager->forwardKeyPressed && !inputManager->backKeyPressed)
position += getForward() * MOVEMENT_SPEED * delta * (inputManager->crouchKeyPressed ? CROUCH_SPEED_FACTOR : 1.f);
else if (inputManager->backKeyPressed && !inputManager->forwardKeyPressed)
position -= getForward() * MOVEMENT_SPEED * delta * (inputManager->crouchKeyPressed ? CROUCH_SPEED_FACTOR : 1.f);
if (inputManager->leftKeyPressed && !inputManager->rightKeyPressed)
position += getRight() * MOVEMENT_SPEED * delta * (inputManager->crouchKeyPressed ? CROUCH_SPEED_FACTOR : 1.f);
else if (inputManager->rightKeyPressed && !inputManager->leftKeyPressed)
position -= getRight() * MOVEMENT_SPEED * delta * (inputManager->crouchKeyPressed ? CROUCH_SPEED_FACTOR : 1.f);
if (inputManager->upKeyPressed && !inputManager->downKeyPressed)
position += getUp() * MOVEMENT_SPEED * delta * (inputManager->crouchKeyPressed ? CROUCH_SPEED_FACTOR : 1.f);
else if (inputManager->downKeyPressed && !inputManager->upKeyPressed)
position -= getUp() * MOVEMENT_SPEED * delta * (inputManager->crouchKeyPressed ? CROUCH_SPEED_FACTOR : 1.f);
updateTransform(delta);
viewMatrix = glm::lookAt(position, position + getForward(), getUp());
}
void MainCamera::lookToTarget() {
Vec3f z = getForward() / getForward().length();
Vec3f b = up_.cross(z);
Vec3f x = b / b.length();
Vec3f y = z.cross(x);
Eigen::Matrix4f R;
R << x.x, x.y, x.z, 0.0f,
y.x, y.y, y.z, 0.0f,
z.x, z.y, z.z, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f;
Eigen::Matrix4f T;
T << 1.0f, 0.0f, 0.0f, -pos_.x,
0.0f, 1.0f, 0.0f, -pos_.y,
0.0f, 0.0f, 1.0f, -pos_.z,
0.0f, 0.0f, 0.0f, 1.0f;
Eigen::Matrix4f m = R * T;
glMultMatrixf(m.data());
}
void Camera::setLookAt() {
if (cameraType == _PATH_CAMERA) {
m_eye = m_pathPos;
m_ref = m_pathRef;
m_up = m_pathUp;
m_player->setVisible(true);
}
if (cameraType == _MOTION_CAMERA) {
//DOESNT'T WORK PERFECTLY NOW BECAUSE OF CHANGES TO CAMERA/PLAYER
m_eye = (m_player->getPosition() -
(getForward() * CAMERA_DIST_FROM_PLAYER) + m_pathPos) / 2;
//Pulls camera back for acceleration purposes
//May want to make it be exponentially pulled back with time
m_eye = m_eye - (getForward() * (.025 * m_boostTime));
m_ref = m_pathRef;
m_up = m_pathUp;
m_player->setVisible(true);
}
if (cameraType == _SHIP_CAMERA) {
m_eye = (m_player->getPosition()
- (m_player->getAimForward() * CAMERA_DIST_FROM_PLAYER)
+ (m_player->getAimUp() * SHIP_CAMERA_ABOVE_SCALAR));
m_ref = m_player->getAimForward() + m_player->getPosition();
m_up = m_player->getAimUp();
m_player->setVisible(true);
}
if (cameraType == _FPS_CAMERA) {
m_eye = m_player->getPosition();
m_ref = m_player->getAimForward() + m_player->getPosition();
m_up = m_player->getAimUp();
m_player->setVisible(false);
}
}
void kore::Camera::rotateViewQuat(const float angle, const glm::vec3 v3Axis) {
glm::vec3 v3View = getForward();
glm::vec3 v3Up(0.0f, 1.0f, 0.0f);
glm::quat quatView(0, v3View);
glm::quat quatViewResult = glm::rotate(quatView, angle, v3Axis);
v3View.x = quatViewResult.x;
v3View.y = quatViewResult.y;
v3View.z = quatViewResult.z;
v3View = glm::normalize(v3View);
glm::vec3 v3Side = glm::cross(v3Up, v3View);
v3Side = glm::normalize(v3Side);
v3Up = glm::cross(v3View, v3Side);
v3Up = glm::normalize(v3Up);
setOrientation(v3Side, v3Up, v3View);
}
void Balaenidae::getViewPort(Vec3f &Up, Vec3f &position, Vec3f &forward)
{
position = getPos();
forward = getForward();
Up = toVectorInFixedSystem(0.0f, 1.0f, 0.0f,0,0);
Vec3f orig;
forward = forward.normalize();
orig = position;
Up[0]=Up[2]=0;Up[1]=100;// poner en 4 si queres que este un toque arriba desde atras.
position = position - 400*forward + Up;
forward = orig-position;
}
boost::shared_ptr<ForwardRateSource> ForwardCurveCMADeterministic::parallelBump(double spread)
{
vector<Date> originalDates = getObservationDates();
vector<double> rolledFwds;
for (size_t i = 0; i < originalDates.size(); ++i)
{
rolledFwds.push_back(getForward(originalDates[i]) + spread);
}
return boost::shared_ptr<ForwardCurveCMADeterministic>(
new ForwardCurveCMADeterministic(anchorDate,
originalDates,
rolledFwds,
LINEAR,
true));
}
bool GLWorld::stepForward()
{
//Play bump animation if stepForward() fails
if(!World::stepForward())
{
SignedCoords wall = getForward();
bump_dir_x = wall.first;
bump_dir_z = wall.second;
setAnimation(ANIM_BUMP);
return false;
}
setAnimation(ANIM_STEP);
updateAnimationTarget();
emit changed();
return true;
}
vector<double> ForwardRateSourceStochastic::getImpliedRandomNumbers(vector<double> spot)
{
vector<double> expectedForwards = vector<double>(forwardSimulationDates.size());
vector<double> sds = vector<double>(forwardSimulationDates.size());
vector<double> rns = vector<double>(forwardSimulationDates.size());
size_t startIndex = 0;
if (forwardSimulationDates.front() == anchorDate)
{
rns[0] = 0;
++startIndex;
}
for (size_t i = startIndex; i < forwardSimulationDates.size(); ++i)
{
expectedForwards[i] = getForward(forwardSimulationDates[i]);
sds[i] = vrs->getStandardDeviation(forwardSimulationDates[i]);
rns[i] = log(spot[i] / expectedForwards[i]) / sds[i] + sds[i] / 2.0;
}
return rns;
}
void kore::Camera::setPosition(const glm::vec3& v3Pos) {
// Directly set the position to the inverse view-matirx
m_matViewInverse[ 3 ] = glm::vec4(v3Pos, 1.0f);
// Now calculate the inverse translation for the
// view-matrix as a linear combination of the rotational basis-vectors
glm::vec3 v3Side = getSide();
glm::vec3 v3Up = getUp();
glm::vec3 v3Forward = getForward();
glm::vec3 v3ViewSide = glm::vec3(v3Side.x, v3Up.x, v3Forward.x);
glm::vec3 v3ViewUp = glm::vec3(v3Side.y, v3Up.y, v3Forward.y);
glm::vec3 v3ViewForward = glm::vec3(v3Side.z, v3Up.z, v3Forward.z);
m_matView[ 3 ] = glm::vec4(v3ViewSide * -v3Pos.x +
v3ViewUp * -v3Pos.y +
v3ViewForward * -v3Pos.z, 1.0f);
paramsChanged();
}
