583 lines
18 KiB
C++
583 lines
18 KiB
C++
// ==============================================================
|
|
// This file is part of Glest (www.glest.org)
|
|
//
|
|
// Copyright (C) 2001-2008 Martiño Figueroa
|
|
//
|
|
// You can redistribute this code and/or modify it under
|
|
// the terms of the GNU General Public License as published
|
|
// by the Free Software Foundation; either version 2 of the
|
|
// License, or (at your option) any later version
|
|
// ==============================================================
|
|
|
|
#include "game_camera.h"
|
|
|
|
#include <cstdlib>
|
|
|
|
#include "config.h"
|
|
#include "game_constants.h"
|
|
#include "xml_parser.h"
|
|
#include "conversion.h"
|
|
#include "platform_common.h"
|
|
#include "leak_dumper.h"
|
|
#include "randomgen.h"
|
|
|
|
|
|
using namespace Shared::Graphics;
|
|
using Shared::Xml::XmlNode;
|
|
using namespace Shared::Util;
|
|
|
|
namespace Glest { namespace Game {
|
|
|
|
// =====================================================
|
|
// class GameCamera
|
|
// =====================================================
|
|
|
|
//static std::map<float, std::map<float, std::map<Vec3f, Quad2i> > > cacheVisibleQuad;
|
|
|
|
// ================== PUBLIC =====================
|
|
|
|
const float GameCamera::startingVAng= -60.f;
|
|
const float GameCamera::startingHAng= 0.f;
|
|
const float GameCamera::vTransitionMult= 0.125f;
|
|
const float GameCamera::hTransitionMult= 0.125f;
|
|
const float GameCamera::defaultHeight= 20.f;
|
|
const float GameCamera::centerOffsetZ= 8.0f;
|
|
const float GameCamera::shakeDist= 50.f;
|
|
|
|
// ================= Constructor =================
|
|
|
|
GameCamera::GameCamera() : pos(0.f, defaultHeight, 0.f),
|
|
destPos(0.f, defaultHeight, 0.f), destAng(startingVAng, startingHAng) {
|
|
//Config &config = Config::getInstance();
|
|
calculatedDefault=defaultHeight;
|
|
state= sGame;
|
|
|
|
cacheVisibleQuad.clear();
|
|
//MaxVisibleQuadItemCache = config.getInt("MaxVisibleQuadItemCache",intToStr(-1).c_str());
|
|
MaxVisibleQuadItemCache = -1;
|
|
//if(Config::getInstance().getBool("DisableCaching","false") == true) {
|
|
// MaxVisibleQuadItemCache = 0;
|
|
//}
|
|
|
|
//config
|
|
speed= Config::getInstance().getFloat("CameraMoveSpeed","15") / GameConstants::cameraFps;
|
|
clampBounds= !Config::getInstance().getBool("PhotoMode");
|
|
clampDisable = false;
|
|
|
|
vAng= startingVAng;
|
|
hAng= startingHAng;
|
|
|
|
rotate=0;
|
|
|
|
move= Vec3f(0.f);
|
|
|
|
shakeDecrement=0.f;
|
|
currentShakeIntensity=0;
|
|
shakeOffset= Vec2f(0.f);
|
|
|
|
//maxRenderDistance = Config::getInstance().getFloat("RenderDistanceMax","64");
|
|
maxHeight = Config::getInstance().getFloat("CameraMaxDistance","20");
|
|
minHeight = Config::getInstance().getFloat("CameraMinDistance","7");
|
|
//maxCameraDist = maxHeight;
|
|
//minCameraDist = minHeight;
|
|
minVAng = -Config::getInstance().getFloat("CameraMaxYaw","77.5");
|
|
maxVAng = -Config::getInstance().getFloat("CameraMinYaw","20");
|
|
fov = Config::getInstance().getFloat("CameraFov","45");
|
|
|
|
lastHAng=0;
|
|
lastVAng=0;
|
|
limitX=0;
|
|
limitY=0;
|
|
}
|
|
|
|
GameCamera::~GameCamera() {
|
|
cacheVisibleQuad.clear();
|
|
}
|
|
|
|
std::string GameCamera::getCameraMovementKey() const {
|
|
char szBuf[8096]="";
|
|
snprintf(szBuf,8096,"%s_%f_%f_%f_%s,%f",pos.getString().c_str(),hAng,vAng,rotate,move.getString().c_str(),fov);
|
|
return szBuf;
|
|
}
|
|
|
|
void GameCamera::setMaxHeight(float value) {
|
|
if(value < 0) {
|
|
maxHeight = Config::getInstance().getFloat("CameraMaxDistance","20");
|
|
}
|
|
else {
|
|
maxHeight = value;
|
|
}
|
|
}
|
|
|
|
void GameCamera::setCalculatedDefault(float calculatedDefault){
|
|
this->calculatedDefault= calculatedDefault;
|
|
if(maxHeight>0 && maxHeight<calculatedDefault){
|
|
setMaxHeight(calculatedDefault);
|
|
}
|
|
resetPosition();
|
|
}
|
|
|
|
void GameCamera::init(int limitX, int limitY){
|
|
this->limitX= limitX;
|
|
this->limitY= limitY;
|
|
}
|
|
|
|
// ==================== Misc =====================
|
|
|
|
void GameCamera::setPos(Vec2f pos){
|
|
this->pos= Vec3f(pos.x, this->pos.y, pos.y);
|
|
clampPosXZ(0.0f, (float)limitX, 0.0f, (float)limitY);
|
|
destPos.x = pos.x;
|
|
destPos.z = pos.y;
|
|
}
|
|
|
|
void GameCamera::setPos(Vec3f pos){
|
|
this->pos= pos;
|
|
//clampPosXZ(0.0f, (float)limitX, 0.0f, (float)limitY);
|
|
destPos.x = pos.x;
|
|
destPos.y = pos.y;
|
|
destPos.z = pos.z;
|
|
}
|
|
|
|
void GameCamera::shake(int shakeDuration, int shakeStartIntensity , bool cameraDistanceAffected, Vec3f unitVector) {
|
|
float currentDurationLeft=0;
|
|
float incomingShakeIntensity=((float) shakeStartIntensity)/1000;
|
|
|
|
// calculate the shake duration which is left
|
|
if(this->currentShakeIntensity > 0.f && this->shakeDecrement != 0.f){
|
|
currentDurationLeft=this->currentShakeIntensity / this->shakeDecrement;
|
|
}
|
|
|
|
// reduce new shake effect camera distance related
|
|
if (cameraDistanceAffected) {
|
|
incomingShakeIntensity=incomingShakeIntensity*(1.f-unitVector.dist(getPos())/GameCamera::shakeDist);
|
|
}
|
|
|
|
// add camera shake effect to current one ( if exsists ).
|
|
if(this->currentShakeIntensity>0){
|
|
this->currentShakeIntensity = this->currentShakeIntensity+incomingShakeIntensity ;
|
|
}
|
|
else {
|
|
this->currentShakeIntensity = incomingShakeIntensity ;
|
|
}
|
|
|
|
// use bigger shakeDuration to calculate new shakeDecrement
|
|
if(currentDurationLeft < shakeDuration){
|
|
this->shakeDecrement = currentShakeIntensity / ((float) shakeDuration);
|
|
}
|
|
else if(currentDurationLeft!=0.0f)
|
|
{
|
|
this->shakeDecrement = currentShakeIntensity / ((float) currentDurationLeft);
|
|
}
|
|
}
|
|
|
|
void GameCamera::shakeCamera(){
|
|
//RandomGen random;
|
|
if(currentShakeIntensity > 0.f) {
|
|
// pos.x += (((float) (rand() % 50)) / 50.f - 0.5f) * currentShakeIntensity;
|
|
// pos.z += (((float) (rand() % 50)) / 50.f - 0.5f) * currentShakeIntensity;
|
|
|
|
shakeOffset.x = (((float) (rand() % 50)) / 50.f - 0.5f) * currentShakeIntensity;
|
|
shakeOffset.y = (((float) (rand() % 50)) / 50.f - 0.5f) * currentShakeIntensity;
|
|
currentShakeIntensity -= shakeDecrement;
|
|
}
|
|
}
|
|
|
|
void GameCamera::update(){
|
|
//move XZ
|
|
if(move.z){
|
|
moveForwardH(speed * move.z, 0.9f);
|
|
}
|
|
if(move.x){
|
|
moveSideH(speed * move.x, 0.9f);
|
|
}
|
|
|
|
//free state
|
|
if(state==sFree ){
|
|
if(std::fabs(rotate) == 1){
|
|
rotateHV(speed*5*rotate, 0);
|
|
}
|
|
if(move.y>0){
|
|
moveUp(speed * move.y);
|
|
if(clampDisable == false && clampBounds && pos.y<maxHeight){
|
|
rotateHV(0.f, -speed * 1.7f * move.y);
|
|
}
|
|
}
|
|
if(move.y<0){
|
|
moveUp(speed * move.y);
|
|
if(clampDisable == false && clampBounds && pos.y>minHeight){
|
|
rotateHV(0.f, -speed * 1.7f * move.y);
|
|
}
|
|
}
|
|
}
|
|
|
|
//game state
|
|
if(abs(destAng.x - vAng) > 0.01f) {
|
|
vAng+= (destAng.x - vAng) * hTransitionMult;
|
|
}
|
|
if(abs(destAng.y - hAng) > 0.01f) {
|
|
if(abs(destAng.y - hAng) > 180) {
|
|
if(destAng.y > hAng) {
|
|
hAng+= (destAng.y - hAng - 360) * vTransitionMult;
|
|
} else {
|
|
hAng+= (destAng.y - hAng + 360) * vTransitionMult;
|
|
}
|
|
} else {
|
|
hAng+= (destAng.y - hAng) * vTransitionMult;
|
|
}
|
|
}
|
|
if(abs(destPos.x - pos.x) > 0.01f) {
|
|
pos.x += (destPos.x - pos.x) / 32.0f;
|
|
}
|
|
if(abs(destPos.y - pos.y) > 0.01f) {
|
|
pos.y += (destPos.y - pos.y) / 32.0f;
|
|
}
|
|
if(abs(destPos.z - pos.z) > 0.01f) {
|
|
pos.z += (destPos.z - pos.z) / 32.0f;
|
|
}
|
|
clampAng();
|
|
shakeCamera();
|
|
|
|
if(clampDisable == false && clampBounds){
|
|
clampPosXYZ(0.0f, (float)limitX, minHeight, maxHeight, 0.0f, (float)limitY);
|
|
}
|
|
}
|
|
|
|
Quad2i GameCamera::computeVisibleQuad() {
|
|
//printf("\n@@@ hAng [%f] vAng [%f] fov [%f]\n",hAng,vAng,fov);
|
|
|
|
if(MaxVisibleQuadItemCache != 0) {
|
|
std::map<float, std::map<float, std::map<Vec3f, Quad2i> > >::const_iterator iterFind = cacheVisibleQuad.find(fov);
|
|
if(iterFind != cacheVisibleQuad.end()) {
|
|
std::map<float, std::map<Vec3f, Quad2i> >::const_iterator iterFind2 = iterFind->second.find(hAng);
|
|
if(iterFind2 != iterFind->second.end()) {
|
|
std::map<Vec3f, Quad2i>::const_iterator iterFind3 = iterFind2->second.find(pos);
|
|
if(iterFind3 != iterFind2->second.end()) {
|
|
return iterFind3->second;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
float nearDist = 15.f;
|
|
float dist = pos.y > nearDist ? pos.y * 1.2f : nearDist;
|
|
float farDist = 90.f * (pos.y > nearDist ? pos.y / 15.f : 1.f);
|
|
const float viewDegree = 180.f;
|
|
|
|
Vec2f v(std::sin(degToRad(viewDegree - hAng)), std::cos(degToRad(viewDegree - hAng)));
|
|
Vec2f v1(std::sin(degToRad(viewDegree - hAng - fov)), std::cos(degToRad(viewDegree - hAng - fov)));
|
|
Vec2f v2(std::sin(degToRad(viewDegree - hAng + fov)), std::cos(degToRad(viewDegree - hAng + fov)));
|
|
|
|
v.normalize();
|
|
v1.normalize();
|
|
v2.normalize();
|
|
|
|
Vec2f p = Vec2f(pos.x, pos.z) - v * dist;
|
|
Vec2i p1(static_cast<int>(p.x + v1.x * nearDist), static_cast<int>(p.y + v1.y * nearDist));
|
|
Vec2i p2(static_cast<int>(p.x + v1.x * farDist), static_cast<int>(p.y + v1.y * farDist));
|
|
Vec2i p3(static_cast<int>(p.x + v2.x * nearDist), static_cast<int>(p.y + v2.y * nearDist));
|
|
Vec2i p4(static_cast<int>(p.x + v2.x * farDist), static_cast<int>(p.y + v2.y * farDist));
|
|
|
|
const bool debug = false;
|
|
|
|
Quad2i result;
|
|
if (hAng >= 135 && hAng <= 225) {
|
|
if(debug) printf("Line %d hAng [%f] fov [%f]\n",__LINE__,hAng,fov);
|
|
|
|
result = Quad2i(p1, p2, p3, p4);
|
|
if(MaxVisibleQuadItemCache != 0 &&
|
|
(MaxVisibleQuadItemCache < 0 || (int)cacheVisibleQuad[fov][hAng].size() <= MaxVisibleQuadItemCache)) {
|
|
cacheVisibleQuad[fov][hAng][pos] = result;
|
|
}
|
|
}
|
|
else if (hAng >= 45 && hAng <= 135) {
|
|
if(debug) printf("Line %d hAng [%f] fov [%f]\n",__LINE__,hAng,fov);
|
|
|
|
result = Quad2i(p3, p1, p4, p2);
|
|
if(MaxVisibleQuadItemCache != 0 &&
|
|
(MaxVisibleQuadItemCache < 0 || (int)cacheVisibleQuad[fov][hAng].size() <= MaxVisibleQuadItemCache)) {
|
|
cacheVisibleQuad[fov][hAng][pos] = result;
|
|
}
|
|
}
|
|
else if (hAng >= 225 && hAng <= 315) {
|
|
if(debug) printf("Line %d hAng [%f] fov [%f]\n",__LINE__,hAng,fov);
|
|
|
|
result = Quad2i(p2, p4, p1, p3);
|
|
if(MaxVisibleQuadItemCache != 0 &&
|
|
(MaxVisibleQuadItemCache < 0 || (int)cacheVisibleQuad[fov][hAng].size() <= MaxVisibleQuadItemCache)) {
|
|
cacheVisibleQuad[fov][hAng][pos] = result;
|
|
}
|
|
}
|
|
else {
|
|
if(debug) printf("Line %d hAng [%f] fov [%f]\n",__LINE__,hAng,fov);
|
|
|
|
result = Quad2i(p4, p3, p2, p1);
|
|
if(MaxVisibleQuadItemCache != 0 &&
|
|
(MaxVisibleQuadItemCache < 0 || (int)cacheVisibleQuad[fov][hAng].size() <= MaxVisibleQuadItemCache)) {
|
|
cacheVisibleQuad[fov][hAng][pos] = Quad2i(p4, p3, p2, p1);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void GameCamera::setState(State s){
|
|
if(s==sGame){
|
|
state = sGame;
|
|
setClampDisabled(false);
|
|
resetPosition();
|
|
}
|
|
else if(s==sUnit){
|
|
state = sUnit;
|
|
setClampDisabled(true);
|
|
}
|
|
else if(s==sFree){
|
|
state = sFree;
|
|
setClampDisabled(false);
|
|
resetPosition();
|
|
}
|
|
else {
|
|
abort();//"unknown camera state"
|
|
}
|
|
}
|
|
|
|
void GameCamera::resetPosition(){
|
|
destAng.x = startingVAng;
|
|
destAng.y = startingHAng;
|
|
destPos.y = calculatedDefault;
|
|
}
|
|
|
|
void GameCamera::centerXZ(float x, float z){
|
|
destPos.x = pos.x= x;
|
|
destPos.z = pos.z= z+centerOffsetZ;
|
|
}
|
|
|
|
//void GameCamera::transitionXYZ(float x, float y, float z) {
|
|
// destPos.x += x;
|
|
// destPos.y += y;
|
|
// destPos.z += z;
|
|
// clampPosXYZ(0.0f, (float)limitX, minHeight, maxHeight, 0.0f, (float)limitY);
|
|
//}
|
|
|
|
void GameCamera::transitionVH(float v, float h) {
|
|
destAng.x -= v;
|
|
//destPos.y -= v * destPos.y / 100.f;
|
|
destAng.y -= h;
|
|
clampAng();
|
|
}
|
|
|
|
void GameCamera::rotateToVH(float v, float h) {
|
|
destAng.x = v;
|
|
destAng.y = h;
|
|
clampAng();
|
|
}
|
|
|
|
void GameCamera::zoom(float dist) {
|
|
float flatDist = dist * std::cos(degToRad(vAng));
|
|
Vec3f offset(flatDist * std::sin(degToRad(hAng)), dist * std::sin(degToRad(vAng)), flatDist * -std::cos(degToRad(hAng)));
|
|
|
|
destPos += offset;
|
|
}
|
|
|
|
void GameCamera::load(const XmlNode *node) {
|
|
//destPos = node->getChildVec3fValue("pos");
|
|
//destAng = node->getChildVec2fValue("angle");
|
|
}
|
|
|
|
void GameCamera::save(XmlNode *node) const {
|
|
//node->addChild("pos", pos);
|
|
//node->addChild("angle", Vec2f(vAng, hAng));
|
|
}
|
|
|
|
// ==================== PRIVATE ====================
|
|
|
|
void GameCamera::clampPosXZ(float x1, float x2, float z1, float z2){
|
|
if(clampDisable == true) {
|
|
return;
|
|
}
|
|
|
|
if(pos.x < x1) pos.x = x1;
|
|
if(destPos.x < x1) destPos.x = x1;
|
|
if(pos.z < z1) pos.z = z1;
|
|
if(destPos.z < z1) destPos.z = z1;
|
|
if(pos.x > x2) pos.x = x2;
|
|
if(destPos.x > x2) destPos.x = x2;
|
|
if(pos.z > z2) pos.z = z2;
|
|
if(destPos.z > z2) destPos.z = z2;
|
|
}
|
|
|
|
void GameCamera::clampPosXYZ(float x1, float x2, float y1, float y2, float z1, float z2){
|
|
if(clampDisable == true) {
|
|
return;
|
|
}
|
|
|
|
if(pos.x < x1) pos.x = x1;
|
|
if(destPos.x < x1) destPos.x = x1;
|
|
if(pos.y < y1) pos.y = y1;
|
|
if(destPos.y < y1) destPos.y = y1;
|
|
if(pos.z < z1) pos.z = z1;
|
|
if(destPos.z < z1) destPos.z = z1;
|
|
if(pos.x > x2) pos.x = x2;
|
|
if(destPos.x > x2) destPos.x = x2;
|
|
if(pos.y > y2) pos.y = y2;
|
|
if(destPos.y > y2) destPos.y = y2;
|
|
if(pos.z > z2) pos.z = z2;
|
|
if(destPos.z > z2) destPos.z = z2;
|
|
}
|
|
|
|
void GameCamera::rotateHV(float h, float v){
|
|
destAng.x = vAng += v;
|
|
destAng.y = hAng += h;
|
|
clampAng();
|
|
}
|
|
|
|
void GameCamera::clampAng() {
|
|
if(clampDisable == true && state != sUnit ) {
|
|
return;
|
|
}
|
|
|
|
if(vAng > maxVAng) vAng = maxVAng;
|
|
if(destAng.x > maxVAng) destAng.x = maxVAng;
|
|
if(vAng < minVAng) vAng = minVAng;
|
|
if(destAng.x < minVAng) destAng.x = minVAng;
|
|
if(hAng > 360.f) hAng -= 360.f;
|
|
if(destAng.y > 360.f) destAng.y -= 360.f;
|
|
if(hAng < 0.f) hAng += 360.f;
|
|
if(destAng.y < 0.f) destAng.y = 360.f;
|
|
}
|
|
|
|
//move camera forwad but never change heightFactor
|
|
void GameCamera::moveForwardH(float d, float response) {
|
|
Vec3f offset(std::sin(degToRad(hAng)) * d, 0.f, -std::cos(degToRad(hAng)) * d);
|
|
destPos += offset;
|
|
pos.x += offset.x * response;
|
|
pos.z += offset.z * response;
|
|
}
|
|
|
|
//move camera to a side but never change heightFactor
|
|
void GameCamera::moveSideH(float d, float response){
|
|
Vec3f offset(std::sin(degToRad(hAng+90)) * d, 0.f, -std::cos(degToRad(hAng+90)) * d);
|
|
destPos += offset;
|
|
pos.x += (destPos.x - pos.x) * response;
|
|
pos.z += (destPos.z - pos.z) * response;
|
|
}
|
|
|
|
void GameCamera::moveUp(float d){
|
|
// pos.y+= d;
|
|
destPos.y += d;
|
|
}
|
|
|
|
void GameCamera::saveGame(XmlNode *rootNode) {
|
|
std::map<string,string> mapTagReplacements;
|
|
XmlNode *gamecameraNode = rootNode->addChild("GameCamera");
|
|
|
|
// Vec3f pos;
|
|
gamecameraNode->addAttribute("pos",pos.getString(), mapTagReplacements);
|
|
// Vec3f destPos;
|
|
gamecameraNode->addAttribute("destPos",destPos.getString(), mapTagReplacements);
|
|
//
|
|
// float hAng; //YZ plane positive -Z axis
|
|
gamecameraNode->addAttribute("hAng",floatToStr(hAng,6), mapTagReplacements);
|
|
// float vAng; //XZ plane positive +Z axis
|
|
gamecameraNode->addAttribute("vAng",floatToStr(vAng,6), mapTagReplacements);
|
|
// float lastHAng;
|
|
gamecameraNode->addAttribute("lastHAng",floatToStr(lastHAng,6), mapTagReplacements);
|
|
|
|
// float lastVAng;
|
|
gamecameraNode->addAttribute("lastVAng",floatToStr(lastVAng,6), mapTagReplacements);
|
|
// Vec2f destAng;
|
|
gamecameraNode->addAttribute("destAng",destAng.getString(), mapTagReplacements);
|
|
// float rotate;
|
|
gamecameraNode->addAttribute("rotate",floatToStr(rotate,6), mapTagReplacements);
|
|
// Vec3f move;
|
|
gamecameraNode->addAttribute("move",move.getString(), mapTagReplacements);
|
|
// State state;
|
|
gamecameraNode->addAttribute("state",intToStr(state), mapTagReplacements);
|
|
// int limitX;
|
|
gamecameraNode->addAttribute("limitX",intToStr(limitX), mapTagReplacements);
|
|
// int limitY;
|
|
gamecameraNode->addAttribute("limitY",intToStr(limitY), mapTagReplacements);
|
|
// //config
|
|
// float speed;
|
|
gamecameraNode->addAttribute("speed",floatToStr(speed,6), mapTagReplacements);
|
|
// bool clampBounds;
|
|
gamecameraNode->addAttribute("clampBounds",intToStr(clampBounds), mapTagReplacements);
|
|
// //float maxRenderDistance;
|
|
// float maxHeight;
|
|
gamecameraNode->addAttribute("maxHeight",floatToStr(maxHeight,6), mapTagReplacements);
|
|
// float minHeight;
|
|
gamecameraNode->addAttribute("minHeight",floatToStr(minHeight,6), mapTagReplacements);
|
|
// //float maxCameraDist;
|
|
// //float minCameraDist;
|
|
// float minVAng;
|
|
gamecameraNode->addAttribute("minVAng",floatToStr(minVAng,6), mapTagReplacements);
|
|
// float maxVAng;
|
|
gamecameraNode->addAttribute("maxVAng",floatToStr(maxVAng,6), mapTagReplacements);
|
|
// float fov;
|
|
gamecameraNode->addAttribute("fov",floatToStr(fov,6), mapTagReplacements);
|
|
// float calculatedDefault;
|
|
gamecameraNode->addAttribute("calculatedDefault",floatToStr(calculatedDefault,6), mapTagReplacements);
|
|
// std::map<float, std::map<float, std::map<Vec3f, Quad2i> > > cacheVisibleQuad;
|
|
// int MaxVisibleQuadItemCache;
|
|
gamecameraNode->addAttribute("MaxVisibleQuadItemCache",intToStr(MaxVisibleQuadItemCache), mapTagReplacements);
|
|
}
|
|
|
|
void GameCamera::loadGame(const XmlNode *rootNode) {
|
|
const XmlNode *gamecameraNode = rootNode->getChild("GameCamera");
|
|
|
|
//firstTime = timeflowNode->getAttribute("firstTime")->getFloatValue();
|
|
|
|
// Vec3f pos;
|
|
pos = Vec3f::strToVec3(gamecameraNode->getAttribute("pos")->getValue());
|
|
// Vec3f destPos;
|
|
destPos = Vec3f::strToVec3(gamecameraNode->getAttribute("destPos")->getValue());
|
|
//
|
|
// float hAng; //YZ plane positive -Z axis
|
|
hAng = gamecameraNode->getAttribute("hAng")->getFloatValue();
|
|
// float vAng; //XZ plane positive +Z axis
|
|
vAng = gamecameraNode->getAttribute("vAng")->getFloatValue();
|
|
// float lastHAng;
|
|
lastHAng = gamecameraNode->getAttribute("lastHAng")->getFloatValue();
|
|
|
|
// float lastVAng;
|
|
lastVAng = gamecameraNode->getAttribute("lastVAng")->getFloatValue();
|
|
// Vec2f destAng;
|
|
destAng = Vec2f::strToVec2(gamecameraNode->getAttribute("destAng")->getValue());
|
|
// float rotate;
|
|
rotate = gamecameraNode->getAttribute("rotate")->getFloatValue();
|
|
// Vec3f move;
|
|
move = Vec3f::strToVec3(gamecameraNode->getAttribute("move")->getValue());
|
|
// State state;
|
|
state = static_cast<State>(gamecameraNode->getAttribute("state")->getIntValue());
|
|
// int limitX;
|
|
limitX = gamecameraNode->getAttribute("limitX")->getIntValue();
|
|
// int limitY;
|
|
limitY = gamecameraNode->getAttribute("limitY")->getIntValue();
|
|
// //config
|
|
// float speed;
|
|
speed = gamecameraNode->getAttribute("speed")->getFloatValue();
|
|
// bool clampBounds;
|
|
clampBounds = gamecameraNode->getAttribute("clampBounds")->getIntValue() != 0;
|
|
// //float maxRenderDistance;
|
|
// float maxHeight;
|
|
maxHeight = gamecameraNode->getAttribute("maxHeight")->getFloatValue();
|
|
// float minHeight;
|
|
minHeight = gamecameraNode->getAttribute("minHeight")->getFloatValue();
|
|
// //float maxCameraDist;
|
|
// //float minCameraDist;
|
|
// float minVAng;
|
|
minVAng = gamecameraNode->getAttribute("minVAng")->getFloatValue();
|
|
// float maxVAng;
|
|
maxVAng = gamecameraNode->getAttribute("maxVAng")->getFloatValue();
|
|
// float fov;
|
|
fov = gamecameraNode->getAttribute("fov")->getFloatValue();
|
|
// float calculatedDefault;
|
|
calculatedDefault = gamecameraNode->getAttribute("calculatedDefault")->getFloatValue();
|
|
// std::map<float, std::map<float, std::map<Vec3f, Quad2i> > > cacheVisibleQuad;
|
|
// int MaxVisibleQuadItemCache;
|
|
MaxVisibleQuadItemCache = gamecameraNode->getAttribute("MaxVisibleQuadItemCache")->getIntValue();
|
|
|
|
}
|
|
|
|
}}//end namespace
|