nitf::HashTable nitf::HashTable::clone(NITF_DATA_ITEM_CLONE cloner) throw(nitf::NITFException)
{
nitf::HashTable dolly(nitf_HashTable_clone(getNativeOrThrow(),
cloner, &error));
dolly.setManaged(false);
return dolly;
}
bool TrackballTransformManipulator::updateFrame( float dt )
{
bool result = false;
if( m_transformPath && getViewState() && getRenderTarget() )
{
switch( m_mode )
{
case Mode::ROTATE:
result = rotate();
break;
case Mode::PAN:
result = pan();
break;
case Mode::DOLLY:
result = dolly();
break;
default:
break;
}
}
return result;
}
void ofxFPSCam::update() {
float v;
v = key_state[key_assign[RIGHT]] ? move_speed : 0;
v -= key_state[key_assign[LEFT]] ? move_speed : 0;
velocity_side += (v - velocity_side) * 0.2;
truck(velocity_side);
v = key_state[key_assign[BACK]] ? move_speed : 0;
v -= key_state[key_assign[FORWARD]] ? move_speed : 0;
velocity_forward += (v - velocity_forward) * 0.2;
dolly(velocity_forward);
v = key_state[key_assign[UP]] ? move_speed : 0;
v -= key_state[key_assign[DOWN]] ? move_speed : 0;
velocity_upward += (v - velocity_upward) * 0.2;
boom(velocity_upward);
v = key_state[key_assign[PAN_LEFT]] ? rotate_speed : 0;
v -= key_state[key_assign[PAN_RIGHT]] ? rotate_speed : 0;
velocity_pan += (v - velocity_pan) * 0.2;
rotate(velocity_pan, ofVec3f(0, 1, 0));
v = key_state[key_assign[TILT_UP]] ? rotate_speed : 0;
v -= key_state[key_assign[TILT_DOWN]] ? rotate_speed : 0;
velocity_tilt += (v - velocity_tilt) * 0.2;
rotate(velocity_tilt, getSideDir());
}
//----------------------------------------
void ofxViewportCam::frameBoundingBox(const ofVec3f &minCorner,
const ofVec3f &maxCorner)
{
ofVec3f center((minCorner + maxCorner) * 0.5f);
setTargetPosition(center);
this->distance = minCorner.distance(maxCorner);
setPosition(target.getGlobalPosition());
dolly(this->distance);
}
//----------------------------------------
void ofxViewportCam::tumble(float yaw, float pitch)
{
const float tumbleAmount = 0.25f;
this->tiltAmount += pitch * tumbleAmount;
this->panAmount += yaw * tumbleAmount;
if(this->isTargetSet)
{
// Move to tumble point.
const ofVec3f targetPos(target.getGlobalPosition());
setPosition(targetPos);
// Reset orientation to identity.
setOrientation(ofQuaternion(0, 0, 0, 1));
// Apply tumble.
pan(this->panAmount);
tilt(this->tiltAmount);
// Re-apply pre-existing track and zoom.
dolly(this->distance);
truck(this->truckAmount);
boom(this->boomAmount);
}
else
{
// Move to tumble point.
dolly(-this->distance);
// Reset orientation to identity.
setOrientation(ofQuaternion(0, 0, 0, 1));
// Apply tumble.
pan(this->panAmount);
tilt(this->tiltAmount);
// Move back.
dolly(this->distance);
}
}
//static void MouseMoveHandler(GLFWwindow* window, double posx, double posy);
//static void MouseScrollHandler(GLFWwindow* window, double xoffset, double yoffset);
void onMouseMove(double posx, double posy) {
vec2 mouse = vec2(posx, posy);
vec2 delta = mouse - _lastMouse;
if (keys.at(Key::MRIGHT)) {
dolly(delta.y * 0.01f);
} else if (keys.at(Key::MLEFT)) {
rotate(delta.x * -0.01f);
} else if (keys.at(Key::MMIDDLE)) {
delta.y *= -1.0f;
translate(delta * -0.01f);
}
_lastMouse = mouse;
}
void ofxGamepadCamera::update(ofEventArgs& e) {
if(pad == NULL)
return;
float curTime = ofGetElapsedTimef();
float mult = curTime - lastTime;
pan(-pad->getAxisValue(PS3_STICK_R_X)*speedRotation*mult);
tilt(-pad->getAxisValue(PS3_STICK_R_Y)*speedRotation*mult);
truck(pad->getAxisValue(PS3_STICK_L_X)*speedMove*mult);
boom(-pad->getAxisValue(PS3_STICK_L_Y)*speedMove*mult);
if(useAnalogueDolly) {
dolly(-(pad->getAxisValueU(PS3_THRUST_L2)-.5)*speedMove*mult);
dolly((pad->getAxisValueU(PS3_THRUST_R2)-.5)*speedMove*mult);
} else {
if(pad->getButtonValue(PS3_BTN_L2)) {
dolly(-speedMove*2*mult);
}
if(pad->getButtonValue(PS3_BTN_R2)) {
dolly(speedMove*2*mult);
}
}
if(pad->getButtonValue(PS3_BTN_L1)) {
roll(-speedRotation*.7*mult);
}
if(pad->getButtonValue(PS3_BTN_R1)) {
roll(speedRotation*.7*mult);
}
if(pad->getButtonValue(PS3_BTN_SELECT))
reset();
lastTime = curTime;
}
void onMouseMove(QMouseEvent* event) {
vec2 mouse = toGlm(event->localPos());
vec2 delta = mouse - _lastMouse;
auto buttons = event->buttons();
if (buttons & Qt::RightButton) {
dolly(delta.y * 0.01f);
} else if (buttons & Qt::LeftButton) {
rotate(delta.x * -0.01f);
} else if (buttons & Qt::MiddleButton) {
delta.y *= -1.0f;
translate(delta * -0.01f);
}
_lastMouse = mouse;
}
//----------------------------------------
void ofxViewportCam::setTargetPosition(const ofVec3f &pos)
{
this->target.setPosition(pos);
this->isTargetSet = true;
// Move to tumble point.
const ofVec3f targetPos(target.getGlobalPosition());
setPosition(targetPos);
// Reset orientation to identity.
setOrientation(ofQuaternion(0, 0, 0, 1));
// Apply tumble.
pan(this->panAmount);
tilt(this->tiltAmount);
// Re-apply pre-existing track and zoom.
dolly(this->distance);
truck(this->truckAmount);
boom(this->boomAmount);
}
void Camera::mouseDragged(ofMouseEventArgs& event)
{
if(event.button == 0)
{
tumble(prevMouseX, prevMouseY, event.x, event.y);
}
else if(event.button == 1)
{
track(prevMouseX, prevMouseY, event.x, event.y);
}
else if(event.button == 2)
{
dolly(prevMouseX, prevMouseY, event.x, event.y);
setClippingPlane();
}
prevMouseX = event.x;
prevMouseY = event.y;
mouseClicked = false;;
}
//----------------------------------------
void ofxViewportCam::zoom(float delta)
{
this->distance -= delta;
dolly(-delta);
}
nitf::ImageSubheader ImageSubheader::clone() throw(nitf::NITFException)
{
nitf::ImageSubheader dolly(nitf_ImageSubheader_clone(getNativeOrThrow(), &error));
dolly.setManaged(false);
return dolly;
}
void ofxGameCamera::update(ofEventArgs& args){
rotationChanged = false;
positionChanged = false;
if(applyTranslation){
int multiplier = invertControls ? -1 : 1;
if(ofGetKeyPressed('w') || (useArrowKeys && ofGetKeyPressed(OF_KEY_UP)) ){
if(dampen){
targetNode.dolly(-speed);
}else{
dolly(-speed);
}
positionChanged = true;
}
if(ofGetKeyPressed('s') || (useArrowKeys && ofGetKeyPressed(OF_KEY_DOWN)) ){
if(dampen){
targetNode.dolly(speed);
}else{
dolly(speed);
}
positionChanged = true;
}
if(ofGetKeyPressed('a') || (useArrowKeys && ofGetKeyPressed(OF_KEY_LEFT)) ){
if(dampen){
targetNode.truck(-speed);
}else{
truck(-speed);
}
positionChanged = true;
}
if(ofGetKeyPressed('d') || (useArrowKeys && ofGetKeyPressed(OF_KEY_RIGHT)) ){
if(dampen){
targetNode.truck(speed);
}
else{
truck(speed);
}
positionChanged = true;
}
if(ofGetKeyPressed('c') || (useArrowKeys && ofGetKeyPressed(OF_KEY_PAGE_DOWN)) ){
if(dampen){
targetNode.boom(-speed*multiplier);
}
else{
boom(-speed*multiplier);
}
positionChanged = true;
}
if(ofGetKeyPressed('e') || (useArrowKeys && ofGetKeyPressed(OF_KEY_PAGE_UP)) ){
if(dampen){
targetNode.boom(speed*multiplier);
}
else{
boom(speed*multiplier);
}
positionChanged = true;
}
}
if(applyRotation){
if(ofGetKeyPressed('r')){
targetZRot += rollSpeed;
rotationChanged = true;
}
if(ofGetKeyPressed('q')){
targetZRot -= rollSpeed;
rotationChanged = true;
}
}
if(dampen){
setPosition(getPosition() + (targetNode.getPosition() - getPosition()) *.2);
}
ofVec2f mouse( ofGetMouseX(), ofGetMouseY() );
if(usemouse && applyRotation && ofGetMousePressed(0)){
if(!justResetAngles){
float dx = (mouse.x - lastMouse.x) * sensitivityX;
float dy = (mouse.y - lastMouse.y) * sensitivityY;
// cout << "b4 DX DY! " << dx << " " << dy << " " << targetXRot << " " << targetYRot << endl;
targetXRot += dx * (invertControls ? -1 : 1);
targetYRot += dy * (invertControls ? -1 : 1);
// targetYRot = ClampAngle(targetYRot, minimumY, maximumY);
// targetXRot = ClampAngle(targetXRot, minimumX, maximumX);
// cout << "after DX DY! " << dx << " " << dy << " " << targetXRot << " " << targetYRot << endl;
rotationChanged = true;
}
justResetAngles = false;
}
if(rotationChanged){
updateRotation();
}
lastMouse = mouse;
if(!ofGetMousePressed(0) && autosavePosition && (rotationChanged || positionChanged)){
saveCameraPosition();
}
}
