cleanup and refactoring
This commit is contained in:
parent
2302158928
commit
76f6bf62a4
GPG key ID:
223391B52FAD4463
1285 changed files with 757994 additions and 8 deletions
237
raytracer/nvpro_core/nvh/camerainertia.hpp
Normal file
237
raytracer/nvpro_core/nvh/camerainertia.hpp
Normal file
|
|
@ -0,0 +1,237 @@
|
|||
/*
|
||||
* Copyright (c) 2013-2021, NVIDIA CORPORATION. All rights reserved.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
* SPDX-FileCopyrightText: Copyright (c) 2013-2021 NVIDIA CORPORATION
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
//--------------------------------------------------------------------
|
||||
#pragma once
|
||||
|
||||
#include <nvh/nvprint.hpp>
|
||||
#include <glm/glm.hpp>
|
||||
|
||||
#include <cmath>
|
||||
#include "glm/gtc/matrix_transform.hpp"
|
||||
|
||||
/* @DOC_START
|
||||
# struct InertiaCamera
|
||||
> Struct that offers a camera moving with some inertia effect around a target point
|
||||
|
||||
InertiaCamera exposes a mix of pseudo polar rotation around a target point and
|
||||
some other movements to translate the target point, zoom in and out.
|
||||
|
||||
Either the keyboard or mouse can be used for all of the moves.
|
||||
@DOC_END */
|
||||
struct InertiaCamera
|
||||
{
|
||||
glm::vec3 curEyePos, curFocusPos, curObjectPos; ///< Current position of the motion
|
||||
glm::vec3 eyePos, focusPos, objectPos; ///< expected posiions to reach
|
||||
float tau; ///< acceleration factor in the motion function
|
||||
float epsilon;
|
||||
float eyeD;
|
||||
float focusD;
|
||||
float objectD;
|
||||
glm::mat4 m4_view; ///< transformation matrix resulting from the computation
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
InertiaCamera(const glm::vec3 eye = glm::vec3(0.0f, 1.0f, -3.0f),
|
||||
const glm::vec3 focus = glm::vec3(0, 0, 0),
|
||||
const glm::vec3 object = glm::vec3(0, 0, 0))
|
||||
{
|
||||
epsilon = 0.001f;
|
||||
tau = 0.2f;
|
||||
curEyePos = eye;
|
||||
eyePos = eye;
|
||||
curFocusPos = focus;
|
||||
focusPos = focus;
|
||||
curObjectPos = object;
|
||||
objectPos = object;
|
||||
eyeD = 0.0f;
|
||||
focusD = 0.0f;
|
||||
objectD = 0.0f;
|
||||
m4_view = glm::mat4(1);
|
||||
glm::mat4 Lookat = glm::lookAt(curEyePos, curFocusPos, glm::vec3(0, 1, 0));
|
||||
m4_view *= Lookat;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
void rotateH(float s, bool bPan = false)
|
||||
{
|
||||
glm::vec3 p = eyePos;
|
||||
glm::vec3 o = focusPos;
|
||||
glm::vec3 po = p - o;
|
||||
float l = glm::length(po);
|
||||
glm::vec3 dv = glm::cross(po, glm::vec3(0, 1, 0));
|
||||
dv *= s;
|
||||
p += dv;
|
||||
po = p - o;
|
||||
float l2 = glm::length(po);
|
||||
l = l2 - l;
|
||||
p -= (l / l2) * (po);
|
||||
eyePos = p;
|
||||
if(bPan)
|
||||
focusPos += dv;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
void rotateV(float s, bool bPan = false)
|
||||
{
|
||||
glm::vec3 p = eyePos;
|
||||
glm::vec3 o = focusPos;
|
||||
glm::vec3 po = p - o;
|
||||
float l = glm::length(po);
|
||||
glm::vec3 dv = glm::cross(po, glm::vec3(0, -1, 0));
|
||||
dv = glm::normalize(dv);
|
||||
glm::vec3 dv2 = glm::cross(po, dv);
|
||||
dv2 *= s;
|
||||
p += dv2;
|
||||
po = p - o;
|
||||
float l2 = glm::length(po);
|
||||
|
||||
if(bPan)
|
||||
focusPos += dv2;
|
||||
|
||||
// protect against gimbal lock
|
||||
if(std::fabs(dot(po / l2, glm::vec3(0, 1, 0))) > 0.99)
|
||||
return;
|
||||
|
||||
l = l2 - l;
|
||||
p -= (l / l2) * (po);
|
||||
eyePos = p;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
void move(float s, bool bPan)
|
||||
{
|
||||
glm::vec3 p = eyePos;
|
||||
glm::vec3 o = focusPos;
|
||||
glm::vec3 po = p - o;
|
||||
po *= s;
|
||||
p -= po;
|
||||
if(bPan)
|
||||
focusPos -= po;
|
||||
eyePos = p;
|
||||
}
|
||||
//------------------------------------------------------------------------------------
|
||||
/// > simulation step to call with a proper time interval to update the animation
|
||||
//------------------------------------------------------------------------------------
|
||||
bool update(float dt)
|
||||
{
|
||||
if(dt > (1.0f / 60.0f))
|
||||
dt = (1.0f / 60.0f);
|
||||
bool bContinue = false;
|
||||
static glm::vec3 eyeVel = glm::vec3(0, 0, 0);
|
||||
static glm::vec3 eyeAcc = glm::vec3(0, 0, 0);
|
||||
eyeD = glm::length(curEyePos - eyePos);
|
||||
if(eyeD > epsilon)
|
||||
{
|
||||
bContinue = true;
|
||||
glm::vec3 dV = curEyePos - eyePos;
|
||||
eyeAcc = (-2.0f / tau) * eyeVel - dV / (tau * tau);
|
||||
// integrate
|
||||
eyeVel += eyeAcc * glm::vec3(dt, dt, dt);
|
||||
curEyePos += eyeVel * glm::vec3(dt, dt, dt);
|
||||
}
|
||||
else
|
||||
{
|
||||
eyeVel = glm::vec3(0, 0, 0);
|
||||
eyeAcc = glm::vec3(0, 0, 0);
|
||||
}
|
||||
|
||||
static glm::vec3 focusVel = glm::vec3(0, 0, 0);
|
||||
static glm::vec3 focusAcc = glm::vec3(0, 0, 0);
|
||||
focusD = glm::length(curFocusPos - focusPos);
|
||||
if(focusD > epsilon)
|
||||
{
|
||||
bContinue = true;
|
||||
glm::vec3 dV = curFocusPos - focusPos;
|
||||
focusAcc = (-2.0f / tau) * focusVel - dV / (tau * tau);
|
||||
// integrate
|
||||
focusVel += focusAcc * glm::vec3(dt, dt, dt);
|
||||
curFocusPos += focusVel * glm::vec3(dt, dt, dt);
|
||||
}
|
||||
else
|
||||
{
|
||||
focusVel = glm::vec3(0, 0, 0);
|
||||
focusAcc = glm::vec3(0, 0, 0);
|
||||
}
|
||||
|
||||
static glm::vec3 objectVel = glm::vec3(0, 0, 0);
|
||||
static glm::vec3 objectAcc = glm::vec3(0, 0, 0);
|
||||
objectD = glm::length(curObjectPos - objectPos);
|
||||
if(objectD > epsilon)
|
||||
{
|
||||
bContinue = true;
|
||||
glm::vec3 dV = curObjectPos - objectPos;
|
||||
objectAcc = (-2.0f / tau) * objectVel - dV / (tau * tau);
|
||||
// integrate
|
||||
objectVel += objectAcc * glm::vec3(dt, dt, dt);
|
||||
curObjectPos += objectVel * glm::vec3(dt, dt, dt);
|
||||
}
|
||||
else
|
||||
{
|
||||
objectVel = glm::vec3(0, 0, 0);
|
||||
objectAcc = glm::vec3(0, 0, 0);
|
||||
}
|
||||
//
|
||||
// Camera View matrix
|
||||
//
|
||||
glm::vec3 up(0, 1, 0);
|
||||
m4_view = glm::mat4(1);
|
||||
glm::mat4 Lookat = glm::lookAt(curEyePos, curFocusPos, up);
|
||||
m4_view *= Lookat;
|
||||
return bContinue;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
/// > Call this function to update the camera position and targets position
|
||||
/// \arg *reset* set to true will directly update the actual positions without
|
||||
/// performing the animation for transitioning.
|
||||
//------------------------------------------------------------------------------
|
||||
void look_at(const glm::vec3& eye, const glm::vec3& center /*, const glm::vec3& up*/, bool reset = false)
|
||||
{
|
||||
eyePos = eye;
|
||||
focusPos = center;
|
||||
if(reset)
|
||||
{
|
||||
curEyePos = eye;
|
||||
curFocusPos = center;
|
||||
glm::vec3 up(0, 1, 0);
|
||||
m4_view = glm::mat4(1);
|
||||
glm::mat4 Lookat = glm::lookAt(curEyePos, curFocusPos, up);
|
||||
m4_view *= Lookat;
|
||||
}
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
/// > debug information of camera position and target position
|
||||
/// Particularily useful to record a bunch of positions that can later be
|
||||
/// reuses as "recorded" presets
|
||||
//------------------------------------------------------------------------------
|
||||
void print_look_at(bool cppLike = false)
|
||||
{
|
||||
if(cppLike)
|
||||
{
|
||||
LOGI("{glm::vec3(%.2f, %.2f, %.2f), glm::vec3(%.2f, %.2f, %.2f)},\n", eyePos.x, eyePos.y, eyePos.z, focusPos.x,
|
||||
focusPos.y, focusPos.z);
|
||||
}
|
||||
else
|
||||
{
|
||||
LOGI("%.2f %.2f %.2f %.2f %.2f %.2f 0.0\n", eyePos.x, eyePos.y, eyePos.z, focusPos.x, focusPos.y, focusPos.z);
|
||||
}
|
||||
}
|
||||
};
|
||||
Loading…
Add table
Add a link
Reference in a new issue