Управление камерой в OpenGL: базовые принципы и продвинутые техники

// Направление взгляда (вперед)
forward = normalize(center – eye)

// Вектор "вправо" (нормализованное векторное произведение)
right = normalize(cross(forward, up))

// Скорректированный вектор "вверх"
up = cross(right, forward)

view_matrix = [
right.x, right.y, right.z, -dot(right, eye),
up.x, up.y, up.z, -dot(up, eye),
-forward.x, -forward.y, -forward.z, dot(forward, eye),
0, 0, 0, 1
]

f = 1 / tan(fov / 2)

projection_matrix = [
f/aspect, 0, 0, 0,
0, f, 0, 0,
0, 0, (far+near)/(near-far), (2*far*near)/(near-far),
0, 0, -1, 0
]

ortho_matrix = [
2/(right-left), 0, 0, -(right+left)/(right-left),
0, 2/(top-bottom), 0, -(top+bottom)/(top-bottom),
0, 0, -2/(far-near), -(far+near)/(far-near),
0, 0, 0, 1
]

gl_Position = projection_matrix * view_matrix * model_matrix * vec4(position, 1.0);

class Camera {
private:
glm::vec3 position; // Позиция камеры
glm::vec3 front; // Направление "вперед"
glm::vec3 up; // Вектор "вверх"
glm::vec3 right; // Вектор "вправо"
glm::vec3 worldUp; // Мировой вектор "вверх"

// Углы Эйлера
float yaw;
float pitch;

// Параметры камеры
float movementSpeed;
float mouseSensitivity;
float zoom;

public:
// Конструктор
Camera(glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f));

// Получение матрицы вида
glm::mat4 GetViewMatrix();

// Методы управления камерой
void ProcessKeyboard(Camera_Movement direction, float deltaTime);
void ProcessMouseMovement(float xoffset, float yoffset);
void ProcessMouseScroll(float yoffset);

private:
// Обновление векторов камеры
void updateCameraVectors();
};

void Camera::ProcessMouseMovement(float xOffset, float yOffset) {
yaw += xOffset * mouseSensitivity;
pitch += yOffset * mouseSensitivity;

// Ограничение углов
if (pitch > 89.0f) pitch = 89.0f;
if (pitch < -89.0f) pitch = -89.0f;

// Пересчитываем векторы
updateCameraVectors();
}

void Camera::ProcessMouseMovement(float xOffset, float yOffset) {
// Создаем кватернионы для вращения
glm::quat quatYaw = glm::angleAxis(glm::radians(xOffset * mouseSensitivity), worldUp);
glm::quat quatPitch = glm::angleAxis(glm::radians(yOffset * mouseSensitivity), right);

// Комбинируем вращения и обновляем ориентацию камеры
orientation = quatYaw * orientation * quatPitch;
orientation = glm::normalize(orientation);

// Извлекаем новые векторы из кватерниона
front = glm::rotate(orientation, glm::vec3(0.0f, 0.0f, -1.0f));
right = glm::rotate(orientation, glm::vec3(1.0f, 0.0f, 0.0f));
up = glm::rotate(orientation, glm::vec3(0.0f, 1.0f, 0.0f));
}

void Camera::ProcessKeyboard(Camera_Movement direction, float deltaTime) {
float velocity = movementSpeed * deltaTime;

if (direction == FORWARD)
position += front * velocity;
if (direction == BACKWARD)
position -= front * velocity;
if (direction == LEFT)
position -= right * velocity;
if (direction == RIGHT)
position += right * velocity;
if (direction == UP)
position += worldUp * velocity;
if (direction == DOWN)
position -= worldUp * velocity;
}

void Camera::ProcessMouseMovement(float xOffset, float yOffset, bool constrainPitch = true) {
xOffset *= mouseSensitivity;
yOffset *= mouseSensitivity;

yaw += xOffset;
pitch += yOffset;

// Ограничение углов поворота по вертикали для избежания переворота камеры
if (constrainPitch) {
if (pitch > 89.0f) pitch = 89.0f;
if (pitch < -89.0f) pitch = -89.0f;
}

// Обновление векторов направления на основе обновленных углов Эйлера
updateCameraVectors();
}

void Camera::ProcessMouseScroll(float yOffset) {
zoom -= yOffset;
if (zoom < 1.0f) zoom = 1.0f;
if (zoom > 45.0f) zoom = 45.0f; 
}

glm::mat4 Camera::GetViewMatrix() {
return glm::lookAt(position, position + front, up);
}

void Camera::updateCameraVectors() {
// Рассчитываем новый вектор направления
glm::vec3 newFront;
newFront.x = cos(glm::radians(yaw)) * cos(glm::radians(pitch));
newFront.y = sin(glm::radians(pitch));
newFront.z = sin(glm::radians(yaw)) * cos(glm::radians(pitch));
front = glm::normalize(newFront);

// Пересчитываем вектора right и up
right = glm::normalize(glm::cross(front, worldUp));
up = glm::normalize(glm::cross(right, front));
}

// Инициализация
Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));

// В цикле рендеринга
glm::mat4 view = camera.GetViewMatrix();
glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), 
(float)screenWidth / (float)screenHeight, 
0.1f, 100.0f);

// Передаем матрицы в шейдер
shader.setMat4("view", view);
shader.setMat4("projection", projection);

void processInput(GLFWwindow *window) {
if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
camera.ProcessKeyboard(FORWARD, deltaTime);
if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
camera.ProcessKeyboard(BACKWARD, deltaTime);
if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
camera.ProcessKeyboard(LEFT, deltaTime);
if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
camera.ProcessKeyboard(RIGHT, deltaTime);
}

void mouse_callback(GLFWwindow* window, double xpos, double ypos) {
// Расчет смещения мыши с предыдущей позиции
static float lastX = screenWidth / 2.0f;
static float lastY = screenHeight / 2.0f;
static bool firstMouse = true;

if (firstMouse) {
lastX = xpos;
lastY = ypos;
firstMouse = false;
}

float xOffset = xpos – lastX;
float yOffset = lastY – ypos; // Инвертировано, т.к. y-координаты идут снизу вверх

lastX = xpos;
lastY = ypos;

camera.ProcessMouseMovement(xOffset, yOffset);
}

void scroll_callback(GLFWwindow* window, double xoffset, double yoffset) {
camera.ProcessMouseScroll(yoffset);
}

class QuaternionCamera {
private:
glm::vec3 position;
glm::quat orientation;
glm::vec3 front, up, right;
float movementSpeed;

public:
// Инициализация с использованием кватерниона ориентации
QuaternionCamera() : position(0.0f, 0.0f, 0.0f), 
orientation(1.0f, 0.0f, 0.0f, 0.0f), 
movementSpeed(2.5f) {
updateVectors();
}

// Вращение камеры с помощью кватерниона
void rotate(float angleInRadians, const glm::vec3& axis) {
glm::quat q = glm::angleAxis(angleInRadians, glm::normalize(axis));
orientation = q * orientation;
orientation = glm::normalize(orientation); // Нормализуем для предотвращения ошибок
updateVectors();
}

// Обновление векторов камеры на основе кватерниона
void updateVectors() {
// Применяем кватернион к базовым векторам
front = glm::rotate(orientation, glm::vec3(0.0f, 0.0f, -1.0f));
right = glm::rotate(orientation, glm::vec3(1.0f, 0.0f, 0.0f));
up = glm::rotate(orientation, glm::vec3(0.0f, 1.0f, 0.0f));
}

glm::mat4 GetViewMatrix() {
return glm::lookAt(position, position + front, up);
}
};

class FollowCamera {
private:
glm::vec3 targetPosition;
glm::vec3 offset;
float followSpeed;
float rotationSpeed;

public:
FollowCamera() : followSpeed(2.0f), rotationSpeed(1.0f),
offset(0.0f, 5.0f, 10.0f) {}

void update(float deltaTime, const glm::vec3& newTargetPosition) {
// Плавное обновление позиции цели
targetPosition = glm::mix(targetPosition, newTargetPosition, followSpeed * deltaTime);

// Рассчитываем позицию камеры относительно цели
position = targetPosition + offset;

// Направляем камеру на цель
front = glm::normalize(targetPosition – position);
right = glm::normalize(glm::cross(front, glm::vec3(0.0f, 1.0f, 0.0f)));
up = glm::normalize(glm::cross(right, front));
}

// Настройка орбитального вращения вокруг цели
void orbit(float horizontalAngle, float verticalAngle) {
// Ограничиваем вертикальный угол для предотвращения переворота
verticalAngle = glm::clamp(verticalAngle, -85.0f, 85.0f);

// Преобразуем сферические координаты в декартовы для обновления смещения
float distance = glm::length(offset);
float theta = glm::radians(horizontalAngle);
float phi = glm::radians(verticalAngle);

offset.x = distance * cos(phi) * sin(theta);
offset.y = distance * sin(phi);
offset.z = distance * cos(phi) * cos(theta);
}
};

class SplineCamera {
private:
std::vector<glm::vec3> controlPoints;
float t; // параметр сплайна [0,1]
float speed;

public:
SplineCamera() : t(0.0f), speed(0.1f) {}

void addControlPoint(const glm::vec3& point) {
controlPoints.push_back(point);
}

void update(float deltaTime) {
if (controlPoints.size() < 4)
return;

t += speed * deltaTime;
if (t > 1.0f) {
t = 0.0f;
// Сдвигаем контрольные точки для непрерывного движения
controlPoints.erase(controlPoints.begin());
controlPoints.push_back(controlPoints.back() + 
(controlPoints.back() – *(controlPoints.end() – 2)));
}

// Вычисляем позицию камеры по кубической кривой Безье
position = cubicBezier(controlPoints[0], controlPoints[1], 
controlPoints[2], controlPoints[3], t);

// Направление камеры также можно интерполировать по сплайну
glm::vec3 nextPos = cubicBezier(controlPoints[0], controlPoints[1], 
controlPoints[2], controlPoints[3], t + 0.01f);
front = glm::normalize(nextPos – position);
right = glm::normalize(glm::cross(front, glm::vec3(0.0f, 1.0f, 0.0f)));
up = glm::normalize(glm::cross(right, front));
}

private:
glm::vec3 cubicBezier(const glm::vec3& p0, const glm::vec3& p1, 
const glm::vec3& p2, const glm::vec3& p3, float t) {
float u = 1.0f – t;
float tt = t * t;
float uu = u * u;
float uuu = uu * u;
float ttt = tt * t;

glm::vec3 p = uuu * p0;
p += 3.0f * uu * t * p1;
p += 3.0f * u * tt * p2;
p += ttt * p3;

return p;
}
};

class PhysicalCamera {
private:
glm::vec3 position;
glm::vec3 velocity;
glm::quat orientation;
glm::quat targetOrientation;

float mass;
float maxSpeed;
float acceleration;
float friction;
float rotationDamping;

public:
PhysicalCamera() : mass(5.0f), maxSpeed(10.0f), acceleration(20.0f),
friction(0.2f), rotationDamping(0.1f),
velocity(0.0f) {}

void applyForce(const glm::vec3& force, float deltaTime) {
glm::vec3 acceleration = force / mass;
velocity += acceleration * deltaTime;

// Ограничение максимальной скорости
if (glm::length(velocity) > maxSpeed) {
velocity = glm::normalize(velocity) * maxSpeed;
}
}

void update(float deltaTime) {
// Применяем трение
velocity *= (1.0f – friction * deltaTime);

// Обновляем позицию
position += velocity * deltaTime;

// Интерполируем ориентацию для плавного поворота
orientation = glm::slerp(orientation, targetOrientation, rotationDamping);

// Обновляем векторы направления
updateVectors();
}

// Установка целевой ориентации при вращении мышью
void setTargetOrientation(const glm::quat& newOrientation) {
targetOrientation = newOrientation;
}
};

void Camera::preventCollisions(const std::vector<Collider*>& colliders) {
// Сохраняем предыдущую позицию
glm::vec3 oldPosition = position;

// Минимальное расстояние от камеры до объекта
float minDistance = 0.5f;

for (const auto& collider : colliders) {
// Проверяем пересечение с коллайдером
if (collider->intersectsSphere(position, minDistance)) {
// Вычисляем направление от объекта к камере
glm::vec3 toCamera = glm::normalize(position – collider->getCenter());

// Отодвигаем камеру от объекта
position = collider->getCenter() + toCamera * (collider->getRadius() + minDistance);
}
}

// Проверяем, не прошла ли камера сквозь стену
Ray ray(oldPosition, glm::normalize(position – oldPosition));
float rayDistance = glm::length(position – oldPosition);

for (const auto& collider : colliders) {
float hitDistance;
if (collider->intersectsRay(ray, hitDistance) && hitDistance < rayDistance) {
// Останавливаемся перед объектом
position = ray.origin + ray.direction * (hitDistance – 0.1f);
break;
}
}
}

class OptimizedCamera {
private:
glm::vec3 position;
glm::vec3 front, up, right;
bool viewMatrixDirty;
glm::mat4 cachedViewMatrix;

public:
OptimizedCamera() : viewMatrixDirty(true) {}

void setPosition(const glm::vec3& newPosition) {
if (position != newPosition) {
position = newPosition;
viewMatrixDirty = true;
}
}

void setOrientation(const glm::vec3& newFront, const glm::vec3& newUp) {
if (front != newFront || up != newUp) {
front = newFront;
up = newUp;
right = glm::normalize(glm::cross(front, up));
viewMatrixDirty = true;
}
}

const glm::mat4& getViewMatrix() {
if (viewMatrixDirty) {
cachedViewMatrix = glm::lookAt(position, position + front, up);
viewMatrixDirty = false;
}
return cachedViewMatrix;
}
};

class CameraSystem {
private:
std::map<std::string, std::shared_ptr<Camera>> cameras;
std::string activeCamera;

public:
void addCamera(const std::string& name, std::shared_ptr<Camera> camera) {
cameras[name] = camera;
if (cameras.size() == 1) activeCamera = name;
}

void setActiveCamera(const std::string& name) {
if (cameras.find(name) != cameras.end()) {
activeCamera = name;
}
}

Camera* getActiveCamera() {
return cameras[activeCamera].get();
}

void update(float deltaTime) {
for (auto& [name, camera] : cameras) {
camera->update(deltaTime);
}
}
};

struct Frustum {
enum Planes { LEFT, RIGHT, BOTTOM, TOP, NEAR, FAR };
glm::vec4 planes[6];

void updateFromCamera(const Camera& camera, float aspect, float fov, float near, float far) {
glm::mat4 proj = glm::perspective(fov, aspect, near, far);
glm::mat4 view = camera.GetViewMatrix();
glm::mat4 vp = proj * view;

// Извлечение плоскостей отсечения из матрицы VP
planes[LEFT] = glm::row(vp, 3) + glm::row(vp, 0);
planes[RIGHT] = glm::row(vp, 3) – glm::row(vp, 0);
planes[BOTTOM] = glm::row(vp, 3) + glm::row(vp, 1);
planes[TOP] = glm::row(vp, 3) – glm::row(vp, 1);
planes[NEAR] = glm::row(vp, 3) + glm::row(vp, 2);
planes[FAR] = glm::row(vp, 3) – glm::row(vp, 2);

// Нормализация плоскостей
for (int i = 0; i < 6; i++) {
planes[i] /= glm::length(glm::vec3(planes[i]));
}
}

bool isSphereVisible(const glm::vec3& center, float radius) const {
for (int i = 0; i < 6; i++) {
if (glm::dot(glm::vec3(planes[i]), center) + planes[i].w <= -radius)
return false; // Сфера полностью за плоскостью
}
return true; // Сфера видима или частично видима
}
};

class PhysicsAwareCamera : public Camera {
private:
PhysicsSystem* physicsSystem;
float cameraRadius;

public:
PhysicsAwareCamera(PhysicsSystem* physics) : 
physicsSystem(physics), cameraRadius(0.5f) {}

void updatePosition(const glm::vec3& newPosition) {
// Проверяем, доступна ли новая позиция
if (physicsSystem->isSpherePositionValid(newPosition, cameraRadius)) {
position = newPosition;
} else {
// Находим ближайшую допустимую позицию
position = physicsSystem->findClosestValidPosition(position, 
newPosition, 
cameraRadius);
}
}

// Проверка прямой видимости цели
bool hasLineOfSightTo(const glm::vec3& target) {
return !physicsSystem->rayCast(position, target, glm::length(target – position));
}
};

class CameraUIController {
private:
Camera* camera;
UISystem* uiSystem;

public:
CameraUIController(Camera* cam, UISystem* ui) : camera(cam), uiSystem(ui) {}

void handleInput(const InputEvent& event) {
// Если курсор над UI элементом, игнорируем ввод для камеры
if (uiSystem->isPointerOverUI()) {
return;
}

// Иначе обрабатываем ввод для камеры
if (event.type == InputEvent::MOUSE_MOVE) {
camera->ProcessMouseMovement(event.mouseDeltaX, event.mouseDeltaY);
} else if (event.type == InputEvent::KEY_PRESSED) {
// Обработка клавиатурных команд
switch (event.keyCode) {
case KEY_W: camera->ProcessKeyboard(FORWARD, event.deltaTime); break;
case KEY_S: camera->ProcessKeyboard(BACKWARD, event.deltaTime); break;
// ...другие клавиши
}
}
}
};

struct CameraState {
glm::vec3 position;
float yaw, pitch;
float zoom;

// Сериализация в JSON
json toJSON() const {
json j;
j["position"] = {position.x, position.y, position.z};
j["yaw"] = yaw;
j["pitch"] = pitch;
j["zoom"] = zoom;
return j;
}

// Десериализация из JSON
static CameraState fromJSON(const json& j) {
CameraState state;
auto posArray = j["position"];
state.position = glm::vec3(posArray[0], posArray[1], posArray[2]);
state.yaw = j["yaw"];
state.pitch = j["pitch"];
state.zoom = j["zoom"];
return state;
}
};

// Методы для работы с состоянием в классе Camera
class Camera {
public:
CameraState getState() const {
CameraState state;
state.position = position;
state.yaw = yaw;
state.pitch = pitch;
state.zoom = zoom;
return state;
}

void setState(const CameraState& state) {
position = state.position;
yaw = state.yaw;
pitch = state.pitch;
zoom = state.zoom;
updateCameraVectors();
}

void saveToFile(const std::string& filename) {
json j = getState().toJSON();
std::ofstream file(filename);
file << j.dump(4);
}

void loadFromFile(const std::string& filename) {
std::ifstream file(filename);
json j;
file >> j;
setState(CameraState::fromJSON(j));
}
};

class ProfilingCamera : public Camera {
private:
Timer timer;
MovingAverage<float, 60> updateTimes; // Скользящее среднее за 60 кадров

public:
void update(float deltaTime) {
timer.start();

// Основная логика обновления камеры
// ...

float elapsed = timer.getElapsedMilliseconds();
updateTimes.add(elapsed);

// Логирование, если время обновления слишком велико
if (updateTimes.getAverage() > 1.0f) { // Больше 1 мс считаем проблемой
Logger::warning("Camera update taking too long: %.2f ms", 
updateTimes.getAverage());
}
}

void printPerformanceStats() {
Logger::info("Camera update times – Avg: %.2f ms, Min: %.2f ms, Max: %.2f ms",
updateTimes.getAverage(),
updateTimes.getMin(),
updateTimes.getMax());
}
};