#include <SDL2\SDL.h>
#include "Graphix\Graphix.h"
+#include "Game.h"
#include "GLM.h"
void Events::processEvents()
{
SDL_Event sdl_event;
+ bool focus_gained = false;
while (SDL_PollEvent(&sdl_event)){
//cout << sdl_event.type << endl;
switch (sdl_event.type){
case SDL_WINDOWEVENT_FOCUS_GAINED:
window_focus = true;
Graphix::hideMouse(true);
+ focus_gained = true;
break;
case SDL_WINDOWEVENT_FOCUS_LOST:
window_focus = false;
break;
case SDL_WINDOWEVENT_RESIZED:
Graphix::setWindowSize(sdl_event.window.data1, sdl_event.window.data2);
+ Game::updateActiveView();
break;
default:
break;
break;
}
}
+
+ if (focus_gained)
+ {
+ view_x = 0;
+ view_y = 0;
+ }
+
keymotion();
}
using glm::rotate;
//using glm::scale;
using glm::determinant;
-using glm::perspective;
+//using glm::perspective;
+//using glm::lookAt;
using glm::normalize;
-using glm::inverse;
+//using glm::inverse;
using glm::transpose;
using glm::dot;
using glm::cross;
#define M_2_PI 0.636619772367581343075535053490057448 /* 2/pi */
#define M_D_R 57.2957795131 /* 180/pi */
-__declspec(deprecated)
+__declspec(deprecated("Use glm::lenght(vec3)"))
float VektorAbs(const vec3& vek);
mat4 removeScale(const mat4& matrix);
\r
void Game::play()\r
{\r
+ active = this;\r
+\r
Fps fps(0.3f);\r
int sleep_time=0;\r
float message_time=0;\r
int framecount = 0;\r
\r
-\r
current_world->bindShader();\r
\r
while (!Events::halt){\r
}\r
}\r
\r
+void Game::updateActiveView()\r
+{\r
+ active->current_world->setView(Graphix::getWindowWidth(), Graphix::getWindowHeight());\r
+}\r
+\r
void Game::update(float deltaT)\r
{\r
/* ADJUST WINDOWS SIZE*/\r
- if (Graphix::getWindowHeight() != current_world->getViewport().getHeight() || Graphix::getWindowWidth() != current_world->getViewport().getWidth())\r
- {\r
- current_world->setView(0, 0, Graphix::getWindowWidth(), Graphix::getWindowHeight());\r
+ //if (Graphix::getWindowHeight() != current_world->getViewport().getHeight() || Graphix::getWindowWidth() != current_world->getViewport().getWidth())\r
+ //{\r
+ // current_world->setView(0, 0, Graphix::getWindowWidth(), Graphix::getWindowHeight());\r
\r
- }\r
+ //}\r
\r
if (playing){\r
current_world->update(deltaT);\r
//else\r
// l_menu->draw();\r
\r
-}
\ No newline at end of file
+}\r
+\r
+Game* Game::active = nullptr;
\ No newline at end of file
//void loadLVL();
+ static void updateActiveView();
private:
void update(float);
void draw() const;
+ static Game* active;
+
};
{\r
width = _width;\r
height = _height;\r
+\r
+ glViewport(0, 0, width, height);\r
}\r
\r
void Graphix::setWindowPos(unsigned int _xpos, unsigned int _ypos)\r
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);\r
glClearAccum(0.f, 0.f, 0.f, 0.f);\r
glClear(GL_ACCUM_BUFFER_BIT);\r
+\r
+ glViewport(0, 0, width, height);\r
}\r
\r
void Graphix::FullScreen(bool _enable, bool _keepDesktopResolution)\r
\r
//bindModel();\r
bt_init();\r
+ box_init();\r
\r
name = "BBox";\r
\r
tmpIMesh = new IMesh(scene->mMeshes[i], _scale* getScale(tmpModelMat));\r
models.push_back(std::pair<IMesh*, mat4>(tmpIMesh, tmpModelMatClean));\r
\r
+ tmpIMesh->box_init(tmpModelMatClean);\r
+\r
+ if (i == 0)\r
+ box = tmpIMesh->getBox();\r
+ else\r
+ box.update(tmpIMesh->getBox());\r
}\r
\r
}\r
//}\r
\r
\r
+\r
+\r
string IMetaMesh::type2str() const\r
{\r
return "IMetaMesh";\r
}\r
+\r
//\r
//void IMetaMesh::setMargin(btScalar _margin)\r
//{\r
\r
using namespace std;\r
\r
+typedef Model::Box Box;\r
+\r
Model::Model()\r
{\r
}\r
return true;\r
}\r
\r
+void Model::box_init(const mat4& _model)\r
+{\r
+ if (vertex == nullptr)\r
+ return;\r
+\r
+ vec3 tmp = vec3(_model * vec4(vertex[0], vertex[1], vertex[2],1.f));\r
+\r
+ vec3 min = tmp, max = tmp;\r
+\r
+ for (uint i = 1; i < numvertices; i++)\r
+ {\r
+ tmp = vec3(_model * vec4(vertex[3 * i], vertex[3 * i + 1], vertex[3 * i + 2], 1.f));\r
+ for (uint k = 0; k < 3; k++)\r
+ {\r
+ if (tmp[k] > max[k])\r
+ max[k] = tmp[k];\r
+ if (tmp[k] < min[k])\r
+ min[k] = tmp[k];\r
+ }\r
+ }\r
+\r
+ box = Box((max + min) * .5f, (max - min) * .5f);\r
+}\r
+\r
+Box Model::getBox()\r
+{\r
+ if (box.size() == vec3(0.f))\r
+ box_init();\r
+ return box;\r
+}\r
+\r
+\r
Model::operator btCollisionShape*() const\r
{\r
return bt_collision_shape;\r
Model* Model::SkyBoxModel = nullptr;\r
std::unordered_map<string, Model*> Model::IMetaModel;\r
std::unordered_map<string, uint> Model::IMetaModel_count;\r
+\r
+\r
+//CLASS BOX\r
+\r
+Box::Box() : cen(0.f), siz(0.f), rad(0.f)\r
+{}\r
+\r
+Model::Box::Box(const unsigned int num, const float * verts)\r
+{\r
+}\r
+\r
+Box::Box(const vec3& _center, const vec3& _size) : cen(_center), siz(_size), rad(length(_size))\r
+{\r
+}\r
+\r
+Box::~Box()\r
+{\r
+}\r
+\r
+void Box::update(const Box& _box)\r
+{\r
+ vec3 diff = _box.cen - cen;\r
+ float size;\r
+\r
+ for (int i = 0; i<3; ++i)\r
+ {\r
+ if (abs(siz[i] - _box.siz[i]) - abs(diff[i]) >= 0)\r
+ {\r
+ if (siz[i] < _box.siz[i])\r
+ {\r
+ siz[i] = _box.siz[i];\r
+ cen[i] = _box.cen[i];\r
+ }\r
+ }\r
+ else\r
+ {\r
+ size = (siz[i] + _box.siz[i] + abs(diff[i])) * .5f;\r
+ cen[i] = cen[i] - sign(diff[i]) * (siz[i] - size);\r
+ siz[i] = size;\r
+ }\r
+\r
+ }\r
+ rad = length(siz);\r
+}\r
+\r
+\r
+void Box::getBBcs(vec3& _center, vec3& _size) const\r
+{\r
+ _center = cen;\r
+ _size = siz;\r
+}\r
+\r
+vec3 Box::center() const\r
+{\r
+ return cen;\r
+}\r
+\r
+vec3 Box::size() const\r
+{\r
+ return siz;\r
+}\r
+\r
+float Box::radius() const\r
+{\r
+ return rad;\r
+}\r
+\r
+void Box::rotate(const mat4& _modelMat)\r
+{\r
+ //Rotate Center\r
+ cen = (vec3)(_modelMat*vec4(cen, 1.f));\r
+\r
+ //Rotate Size\r
+ vec3 newSize(0.f);\r
+ mat3 tmpModelMat(_modelMat);\r
+ for (auto i = 0; i < 3; ++i)\r
+ newSize += abs(tmpModelMat[i]) * siz[i];\r
+ siz = newSize;\r
+ rad = length(siz);\r
+}\r
+\r
+void Box::scale(const vec3& _scale)\r
+{\r
+ for (uint i = 0; i < 3; ++i)\r
+ {\r
+ cen[i] *= _scale[i];\r
+ siz[i] *= _scale[i];\r
+ }\r
+\r
+ rad = length(siz);\r
+}\r
+\r
+float Box::getDist(const vec3& _pos) const\r
+{\r
+ vec3 diff = _pos - cen;\r
+ vec3 direc = normalize(diff);\r
+\r
+ float size(0.f);\r
+ for (auto i = 0; i < 3; ++i)\r
+ size += abs(siz[i] * direc[i]);\r
+ return diff.length() - size;\r
+}\r
+\r
+float Box::getDist(const vec3& _pos, const vec3& _direc) const\r
+{\r
+ vec3 diff = _pos - cen;\r
+\r
+ float size(0.f);\r
+ for (auto i = 0; i < 3; ++i)\r
+ size += abs(siz[i] * _direc[i]);\r
+ return dot(diff, _direc) - size;\r
+}\r
+\r
+\r
+Box Box::merge(const Box& _boxA, const Box& _boxB)\r
+{\r
+ vec3 diff = _boxB.cen - _boxA.cen;\r
+ vec3 size;\r
+ vec3 center;\r
+\r
+ for (int i = 0; i<3; ++i)\r
+ {\r
+ if (abs(_boxA.siz[i] - _boxB.siz[i]) - abs(diff[i]) >= 0)\r
+ {\r
+ if (_boxA.siz[i] > _boxB.siz[i])\r
+ {\r
+ size[i] = _boxA.siz[i];\r
+ center[i] = _boxA.cen[i];\r
+ }\r
+ else\r
+ {\r
+ size[i] = _boxB.siz[i];\r
+ center[i] = _boxB.cen[i];\r
+ }\r
+ }\r
+ else\r
+ {\r
+ size[i] = (_boxA.siz[i] + _boxB.siz[i] + abs(diff[i])) * .5f;\r
+ center[i] = _boxA.cen[i] - sign(diff[i]) * (_boxA.siz[i] - size[i]);\r
+ }\r
+\r
+ }\r
+ return Box(center, size);\r
+}\r
+\r
{\r
public:\r
\r
+ class Box;\r
+\r
/* Binds Model to GL*/\r
virtual void bindModel();\r
virtual void unbindModel();\r
virtual void bt_init(bool _convex = true);\r
virtual void bt_setMargin(btScalar margin);\r
\r
+ virtual void box_init(const mat4& modelMat = mat4(1.f));\r
+ virtual Box getBox();\r
+\r
// Mesh Speichern?\r
bool loadMesh(const std::string& modelpath, uint mindex = 0);\r
bool loadMesh(const aiMesh* mesh, const vec3& scale = vec3(1.f));\r
\r
+ class Box\r
+ {\r
+ public:\r
+ Box();\r
+ Box(const unsigned int num, const float* verts);\r
+ Box(const vec3& center, const vec3& size);\r
+ ~Box();\r
+\r
+ void update(const Box& box);\r
+\r
+ void getBBcs(vec3& center, vec3& size) const;\r
+\r
+ vec3 center() const;\r
+ vec3 size() const;\r
+ float radius() const;\r
+\r
+ void rotate(const mat4& modelMat);\r
+ void scale(const vec3& scale);\r
+\r
+ float getDist(const vec3& pos) const;\r
+ float getDist(const vec3& pos, const vec3& direc) const;\r
+\r
+ static Box merge(const Box& boxA, const Box& boxB);\r
+\r
+ protected:\r
+ vec3 cen;\r
+ vec3 siz;\r
+ float rad;\r
+ };\r
+\r
protected:\r
Model();\r
virtual ~Model();\r
float *vertex = nullptr, *normals = nullptr, *uvs = nullptr;\r
uint *index = nullptr;\r
\r
- vec3 center;\r
- float radius;\r
+ //vec3 center = vec3(0.f), size = vec3(0.f);\r
+ //float radius = 0.f;\r
+\r
+ Box box;\r
\r
std::unordered_map<uint, uint> shader_map;\r
\r
+++ /dev/null
-#include "ViewPort.h"
-
-#include <GL\glew.h>
-#include "../GLM.h"
-
-#include "Shader.h"
-
-#define VIEW_TOP_LIM 0.9f
-#define VIEW_BOT_LIM -0.3f
-
-
-ViewPort::ViewPort(unsigned int _x, unsigned int _y, unsigned int _width, unsigned int _height, float _fovy, float _zNear, float _zFar) :
- xpos(_x),
- ypos(_y),
- width(_width),
- height(_height),
- fovy(_fovy),
- zNear(_zNear),
- zFar(_zFar),
- projection(perspective(fovy, (float)width / height, zNear, zFar)),
- view_angle_x(0),
- view_angle_y(0),
- view_dist(2),
- view(0.f),
- shadow_dist(2)
-{
- rotateView(0.f, -.5f);
-}
-
-
-ViewPort::~ViewPort()
-{
-}
-
-void ViewPort::useViewPort() const
-{
- glViewport(xpos, ypos, width, height);
-}
-
-void ViewPort::bindView(const Shader* shader) const{
- shader->useShader();
-
- shader->setUniformLocation("uProjection", projection);
- shader->setUniformLocation("uInvProjection", glm::inverse(projection));
- shader->setUniformLocation("uView", view);
-
-}
-
-void ViewPort::bindView(const Shader* shader, vec3 pos) const{
- shader->useShader();
-
- shader->setUniformLocation("uProjection", projection);
- shader->setUniformLocation("uInvProjection", glm::inverse(projection));
- shader->setUniformLocation("uView", translate(view, -pos));
-}
-
-void ViewPort::bindViewShadowDir(const Shader* shader) const {
- shader->useShader();
-
- shader->setUniformLocation("uProjection", glm::mat4(1 / shadow_dist));
- shader->setUniformLocation("uInvProjection", glm::mat4(shadow_dist));
- //TODO the real thing
- shader->setUniformLocation("uView", view);
-}
-
-void ViewPort::rotateView(float angle_x, float angle_y){
-
- if (angle_y || angle_x){
-
- view_angle_x -= angle_x;
- view_angle_y -= angle_y;
-
- //Y-Limits
- if (view_angle_y > VIEW_TOP_LIM)
- view_angle_y = VIEW_TOP_LIM;
-
- if (view_angle_y < VIEW_BOT_LIM)
- view_angle_y = VIEW_BOT_LIM;
-
- view = translate(vec3(0.f, 0.f, -view_dist))*rotate(view_angle_y *(float)M_PI_2, vec3(1.f, 0.f, 0.f))*rotate(view_angle_x * (float)M_PI_2, vec3(0.f, 1.f, 0.f));
- }
-
-}
-
-vec3 ViewPort::rotateDirection(const vec3 & direction) const{
- return glm::rotateY(direction, -view_angle_x * (float)M_PI_2);
-}
-
-unsigned int ViewPort::getXPos() const
-{
- return xpos;
-}
-
-unsigned int ViewPort::getYPos() const
-{
- return ypos;
-}
-
-unsigned int ViewPort::getWidth() const
-{
- return width;
-}
-
-unsigned int ViewPort::getHeight() const
-{
- return height;
-}
-
-void ViewPort::setView(uint _x, uint _y, uint _width, uint _height, bool _updateProjection)
-{
- xpos = _x;
- ypos = _y;
- width = _width;
- height = _height;
- if (_updateProjection)
- projection = perspective(fovy, (float)width / height, zNear, zFar);
-}
+++ /dev/null
-#pragma once
-
-//#include "Drawable.h"
-#include "../GLM.h"
-
-class Shader;
-
-class ViewPort
-{
-public:
- ViewPort(unsigned int x, unsigned int y, unsigned int width, unsigned int height, float fovy, float zNear, float zFar);
- ~ViewPort();
-
- void useViewPort() const;
-
- void setView(unsigned int x, unsigned int y, unsigned int width, unsigned int height, bool updateProjection = true);
-
- void bindView(const Shader* shader) const;
- void bindView(const Shader* shader, vec3 lookat) const;
- void bindViewShadowDir(const Shader* shader) const;
-
- void rotateView(float angle_x, float angle_y);
- vec3 rotateDirection(const vec3 & direction) const;
-
- unsigned int getXPos() const;
- unsigned int getYPos() const;
- unsigned int getWidth() const;
- unsigned int getHeight() const;
-
-// Drawable* content;
-
-
-protected:
- unsigned int width;
- unsigned int height;
-
- unsigned int xpos;
- unsigned int ypos;
-
- float fovy, zNear, zFar;
-
- mat4 projection;
- mat4 view;
-
- float view_dist;
- float view_angle_x;
- float view_angle_y;
-
- float shadow_dist;
-};
-
--- /dev/null
+#include "Camera.h"
+
+#include "../Graphix/Shader.h"
+
+using glm::lookAt;
+using glm::perspective;
+using glm::inverse;
+
+#define VIEW_PITCH_MAX 0.3f
+#define VIEW_PITCH_MIN -0.9f
+
+#define WORLD_UP vec3(0.f, 1.f, 0.f)
+
+Camera::Camera(float _yFov, float _xyRatio, float _zNear, float _zFar) :
+ yFov(_yFov),
+ xyRatio(_xyRatio),
+ zNear(_zNear),
+ zFar(_zFar),
+ projection(perspective(yFov, xyRatio, zNear, zFar)),
+ pitch(0.f),
+ yaw(0.f),
+ dist(2.f), //DIST
+ cPosition(0.f)
+{
+ updateVectors();
+}
+
+
+Camera::~Camera()
+{
+}
+
+void Camera::useCamera() const
+{
+ useProjection();
+ useView();
+}
+
+void Camera::useView() const
+{
+ Shader::getShader(SH_ACTIVE)->setUniformLocation("uView", lookAt(cPosition - dist* cFront,cPosition, cUpVector));
+}
+
+void Camera::useProjection() const
+{
+ Shader::getShader(SH_ACTIVE)->setUniformLocation("uProjection", projection);
+ Shader::getShader(SH_ACTIVE)->setUniformLocation("uInvProjection", glm::inverse(projection));
+}
+
+void Camera::updateView(const vec3& _target)
+{
+
+ if (_target == cPosition)
+ return;
+
+ cPosition = _target;
+}
+
+void Camera::updateView_pitch(float _pitch)
+{
+ if (_pitch == 0)
+ return;
+
+ float piTmp = pitch + _pitch;
+
+ if (piTmp > VIEW_PITCH_MAX)
+ piTmp = VIEW_PITCH_MAX;
+ else if(piTmp < VIEW_PITCH_MIN)
+ piTmp = VIEW_PITCH_MIN;
+
+ if (pitch == piTmp)
+ return;
+
+ pitch = piTmp;
+
+ updateVectors();
+}
+
+void Camera::updateView_yaw(float _yaw)
+{
+ if (_yaw == 0)
+ return;
+
+ yaw += _yaw;
+
+ updateVectors();
+}
+
+
+void Camera::updateProjection(float _xyRatio)
+{
+ if (xyRatio == _xyRatio)
+ return;
+
+ xyRatio = _xyRatio;
+
+ projection = perspective(yFov, xyRatio, zNear, zFar);
+}
+
+void Camera::updateProjection(float _yFov, float _xyRatio, float _zNear, float _zFar)
+{
+ if (yFov == _yFov && xyRatio == _xyRatio&&zNear == _zNear&&zFar == _zFar)
+ return;
+
+ yFov = _yFov;
+ xyRatio = _xyRatio;
+ zNear = _zNear;
+ zFar = _zFar;
+
+ projection = perspective(yFov, xyRatio, zNear, zFar);
+}
+
+bool Camera::frustum_sphere(vec3 center, float radius)
+{
+ return false;
+}
+
+void Camera::updateVectors()
+{
+ cFront.x = cos(yaw*(float)M_PI_2) * cos(pitch*(float)M_2_PI);
+ cFront.y = sin(pitch*(float)M_2_PI);
+ cFront.z = sin(yaw*(float)M_PI_2) * cos(pitch*(float)M_2_PI);
+ cFront = normalize(cFront);
+
+
+ cRight = normalize(cross(cFront, WORLD_UP));
+ cUpVector = normalize(cross(cRight, cFront));
+}
\ No newline at end of file
--- /dev/null
+#pragma once
+
+#include "../GLM.h"
+
+
+//TURN AROUND TARGET!
+class Camera
+{
+public:
+ Camera(float yFov, float xyRatio, float zNear, float zFar);
+ ~Camera();
+
+
+
+ /*use Camera (bind View&Projection at current Shader) if unchanged*/
+ void useCamera() const;
+
+ void useView() const;
+ void useProjection() const;
+
+ void updateView(const vec3& target);
+ void updateView_pitch(float);
+ void updateView_yaw(float);
+
+ void updateProjection(float xyRatio);
+ void updateProjection(float yFov, float xyRatio, float zNear, float zFar);
+
+ vec3 getDirection() { return cFront;}
+ vec3 getRight() { return cRight; }
+
+ vec3 getWorldDirection() { return normalize(vec3(cFront.x, 0.f, cFront.z)); }
+ vec3 getWorldRight() { return normalize(vec3(cRight.x, 0.f, cRight.z)); }
+
+ bool frustum_sphere(vec3 center, float radius = 0.f);
+
+
+protected:
+
+ void updateVectors();
+
+ /*Projection*/
+ float yFov, xyRatio, zNear, zFar;
+ mat4 projection = mat4(1.f);
+
+ /*View*/
+ vec3 cPosition, cFront, cUpVector, cRight;
+ float pitch, yaw;
+ float dist;
+
+};
+
#include "../Graphix/Shader.h"
#include "../GLM.h"
#include "../Events.h"
-#include "../Graphix/ViewPort.h"
+#include "Camera.h"
#include "Scene.h"
#define TIME_TILL_MAX_MOVE 2
void Marvin::update(float deltaT)
{
- ViewPort& viewPort(mainScene->getViewport());
+ //ViewPort& viewPort(mainScene->getViewport());
+ Camera& cam(mainScene->getCam());
int move_y = Events::getMoveY();
// MOVE Player
if (move_x)
- move(SPEED_MOVE_NORMAL *move_x * deltaT * viewPort.rotateDirection(vec3(-1.f, 0.f, 0.f)));
+ move(-SPEED_MOVE_NORMAL *move_x * deltaT * cam.getWorldRight());
if (move_y){
if (move_y > 0){
move_delta += deltaT;
if (move_delta > TIME_TILL_MAX_MOVE)
move_delta = TIME_TILL_MAX_MOVE;
- move(SPEED_MOVE_NORMAL * (MOVE_FASTER * move_delta / TIME_TILL_MAX_MOVE + 1) *move_y * deltaT * viewPort.rotateDirection(vec3(0.f, 0.f, -1.f)));
+ move(SPEED_MOVE_NORMAL * (MOVE_FASTER * move_delta / TIME_TILL_MAX_MOVE + 1) *move_y * deltaT * cam.getWorldDirection());
}
else
- move(SPEED_MOVE_NORMAL *move_y * deltaT * viewPort.rotateDirection(vec3(0.f, 0.f, -1.f)));
+ move(SPEED_MOVE_NORMAL *move_y * deltaT * cam.getWorldDirection());
}
else
{
//Rotate Play in move direction
if (move_x || move_y)
- turnTo(viewPort.rotateDirection(vec3(0.f, 0.f, -1.f)), 3 * deltaT / TIME_TILL_DIRECTION_ROTATE);
+ turnTo(cam.getWorldDirection(), 3 * deltaT / TIME_TILL_DIRECTION_ROTATE);
SceneObject::update(deltaT);
}
#include "Scene.h"
#include "SceneObject.h"
-#include "Sky.h"
+//#include "Sky.h"
+//#include "Camera.h"
#include <GL\glew.h>
-#include "../GLM.h"
+//#include "../GLM.h"
#include "../Graphix/Graphix.h"
#include "../Graphix/Shader.h"
-#include "../Graphix/ViewPort.h"
+//#include "../Graphix/ViewPort.h"
#include "../Graphix/Textures.h"
#include "../Graphix/Model.h"
#define NELEMS(x) (sizeof(x) / sizeof((x)[0]))
+ShaderTarget shader[] = { SH_BASIC,SH_BASICTEXTURE,SH_LIGHTING, SH_SHADOWDIR };
+
using std::list;
using std::set;
#define YFALL_SPEED 9.8f
Scene::Scene(unsigned int x, unsigned int y, unsigned int width, unsigned int height, float fovy, float zNear, float zFar, vec3 pos, SceneObject* _lookat) :
-viewPort(x, y, width, height, fovy, zNear, zFar),
+//viewPort(x, y, width, height, fovy, zNear, zFar),
+camera(fovy, (float)width/height, zNear, zFar),
lookat(_lookat)
{
currenttime = 0.0f;
if (lookat != nullptr)
- timestamps.push(Timestamp(0.0f, _lookat->getModelMat(), x, lookat->ySpeed));
+ timestamps.push(Timestamp(0.0f, _lookat->getModelMat(), lookat->ySpeed));
bt_collision_configuration = new btDefaultCollisionConfiguration();
bt_dispatcher = new btCollisionDispatcher(bt_collision_configuration);
fBufferObject::clearBuffer();
Graphix::disableEffects(EF_BLOOM);
+
+ for (int s = 0; s < NELEMS(shader); s++)
+ {
+ Shader::getShader(shader[s])->useShader();
+ camera.useCamera();
+ }
}
void Scene::update(float deltaT)
{
// XYAchse um den Player
- float rotatex = 0.002f*Events::getViewX();
- float rotatey = 0.001f*Events::getViewY();
- viewPort.rotateView(rotatex, rotatey);
+ //float rotatex = 0.002f*Events::getViewX();
+ //float rotatey = 0.001f*Events::getViewY();
+ camera.updateView_pitch(0.001f*Events::getViewY());
+ camera.updateView_yaw(-0.002f*Events::getViewX());
+ //viewPort.rotateView(rotatex, rotatey);
if (!Events::getTimeShift())
{
if (ceil((currenttime + deltaT) / timestep) > ceil(currenttime / timestep))
{
- timestamps.push(Timestamp(currenttime, lookat->getModelMat(), viewPort.getXPos(), lookat->ySpeed));
+ timestamps.push(Timestamp(currenttime, lookat->getModelMat(), lookat->ySpeed));
}
currenttime += deltaT;
{
float prev_time = timestamps.top().time;
mat4 prev_mat = timestamps.top().Playermodel;
- unsigned int prev_camera = timestamps.top().CameraX;
+ //unsigned int prev_camera = timestamps.top().CameraX;
int prev_ySpeed = timestamps.top().ySpeed;
while (max(0.0f, currenttime - deltaT) < prev_time)
{
prev_time = timestamps.top().time;
prev_mat = timestamps.top().Playermodel;
- prev_camera = timestamps.top().CameraX;
+ //prev_camera = timestamps.top().CameraX;
prev_ySpeed = timestamps.top().ySpeed;
}
currenttime = max(0.0f, currenttime - deltaT);
}
+ camera.updateView(lookat->getPosition()+vec3(0.f,1.f,0.f));
+
}
void Scene::draw() const
{
- //Skybox
- viewPort.bindView(Shader::getShader(SH_BASICTEXTURE), lookat->getPosition() + vec3(0.0f, 1.0f, 0.0f));
- //BBox
- viewPort.bindView(Shader::getShader(SH_BASIC), lookat->getPosition() + vec3(0.0f, 1.0f, 0.0f));
- //SceneObjects
- viewPort.bindView(Shader::getShader(SH_LIGHTING), lookat->getPosition() + vec3(0.0f, 1.0f, 0.0f));
- //ShadowDir
- viewPort.bindViewShadowDir(Shader::getShader(SH_SHADOWDIR));
- viewPort.useViewPort();
+ for (int s = 0; s < NELEMS(shader); s++)
+ {
+ Shader::getShader(shader[s])->useShader();
+ camera.useView();
+ }
/*Draw WireFrame ONLY*/
if (Events::isKToggleActive(SDLK_F3))
/*DRAW SCENE*/
Shader::getShader(SH_BASICTEXTURE)->useShader();
SkyBox.draw();
+ //Shader::getShader(SH_BASICTEXTURE)->useShader();
+ //Shader::getShader(SH_BASICTEXTURE)->setUniformLocation("uFar", false);
Shader::getShader(SH_LIGHTING)->useShader();
drawSceneObjects();
lookat = _lookat;
}
-ViewPort& Scene::getViewport()
-{
- return viewPort;
-}
+//ViewPort& Scene::getViewport()
+//{
+// return viewPort;
+//}
-void Scene::setView(unsigned int x, unsigned int y, unsigned int width, unsigned int height, bool updateProjection)
+void Scene::setView(unsigned int width, unsigned int height, bool updateProjection)
{
- viewPort.setView(x, y, width, height, updateProjection);
+ if(updateProjection)
+ camera.updateProjection((float)width / height);
+
+ for (int s = 0; s < NELEMS(shader); s++)
+ {
+ Shader::getShader(shader[s])->useShader();
+ camera.useProjection();
+ }
+
render->updateSize(width, height);
postRender->updateSize(width, height);
for (int i = 0; i < 2; i++)
void Scene::bindShader()
{
/*SceneObject*/
- ShaderTarget shader[] = {SH_BASIC,SH_BASICTEXTURE,SH_LIGHTING, SH_SHADOWDIR};
for (int s = 0; s < NELEMS(shader); s++)
{
for (auto i = SceneObjects.cbegin(); i != SceneObjects.cend(); ++i)
(*i)->bindShader(Shader::getShader(shader[s]));
}
+
/*Skybox*/
SkyBox.bindShader(Shader::getShader(SH_BASICTEXTURE));
#include "../GLM.h"
-#include "../Graphix/ViewPort.h"
#include "Sky.h"
+#include "Camera.h"
#include "Timestamp.h"
#include <list>
#include <stack>
class SceneObject;
-class ViewPort;
-class Sky;
+//class ViewPort;
+//class Sky;
class Shader;
class fBufferObject;
+//class Camera;
class Scene
{
std::list<SceneObject*>* getSceneObjects();
void setLookAt(SceneObject* _lookat);
- ViewPort& getViewport();
+ //ViewPort& getViewport();
+ Camera& getCam() { return camera; }
- void setView(unsigned int x, unsigned int y, unsigned int width, unsigned int height, bool updateProjection = true);
+ void setView(unsigned int width, unsigned int height, bool updateProjection = true);
protected:
- ViewPort viewPort;
+ //ViewPort viewPort;
+ Camera camera;
Sky SkyBox;
SceneObject* lookat;
virtual void draw(drawTarget target=DRAW_Model) const;
virtual void bindShader(const Shader* shader);
-
virtual void bindShaderCollision(const Shader* shader);
virtual void collides(SceneObject* other, btPersistentManifold* contactManifold, float deltaT=1.f);
#include "Timestamp.h"
-Timestamp::Timestamp(float _time, mat4& _Playermodel, unsigned int x, float _ySpeed) :
+Timestamp::Timestamp(float _time, mat4& _Playermodel, float _ySpeed) :
time(_time),
Playermodel(_Playermodel),
-CameraX(x),
+//CameraX(x),
ySpeed(_ySpeed)
{
class Timestamp
{
public:
- Timestamp(float _time, mat4& _Playermodel, unsigned int _Camera, float ySpeed);
+ Timestamp(float _time, mat4& _Playermodel, float ySpeed);
virtual ~Timestamp();
float time;
mat4 Playermodel;
- unsigned int CameraX;
+ //unsigned int CameraX;
float ySpeed;
};
\ No newline at end of file
<ClCompile Include="Graphix\Textures\fBufferObject.cpp" />\r
<ClCompile Include="Graphix\Textures\rBufferObject.cpp" />\r
<ClCompile Include="Graphix\Textures\Texture.cpp" />\r
+ <ClCompile Include="Scene\Camera.cpp" />\r
<ClCompile Include="Scene\EventBox.cpp" />\r
<ClCompile Include="Scene\Level.cpp" />\r
<ClCompile Include="Scene\Marvin.cpp" />\r
<ClCompile Include="Scene\Scene.cpp" />\r
<ClCompile Include="Scene\SceneObject.cpp" />\r
<ClCompile Include="Graphix\Shader.cpp" />\r
- <ClCompile Include="Graphix\ViewPort.cpp" />\r
<ClCompile Include="main.cpp" />\r
<ClCompile Include="Message.cpp" />\r
<ClCompile Include="Scene\Sky.cpp" />\r
<ClInclude Include="Graphix\Textures\rBufferObject.h" />\r
<ClInclude Include="Graphix\Textures\Texture.h" />\r
<ClInclude Include="Scene.h" />\r
+ <ClInclude Include="Scene\Camera.h" />\r
<ClInclude Include="Scene\EventBox.h" />\r
<ClInclude Include="Scene\Level.h" />\r
<ClInclude Include="Scene\Marvin.h" />\r
<ClInclude Include="Scene\Scene.h" />\r
<ClInclude Include="Scene\SceneObject.h" />\r
<ClInclude Include="Graphix\Shader.h" />\r
- <ClInclude Include="Graphix\ViewPort.h" />\r
<ClInclude Include="Message.h" />\r
<ClInclude Include="Scene\Sky.h" />\r
<ClInclude Include="Scene\Timestamp.h" />\r
<ClCompile Include="Graphix\Shader.cpp">\r
<Filter>Source Files</Filter>\r
</ClCompile>\r
- <ClCompile Include="Graphix\ViewPort.cpp">\r
- <Filter>Source Files</Filter>\r
- </ClCompile>\r
<ClCompile Include="Game.cpp">\r
<Filter>Source Files</Filter>\r
</ClCompile>\r
<ClCompile Include="Graphix\Textures\dBufferObject.cpp">\r
<Filter>Source Files</Filter>\r
</ClCompile>\r
+ <ClCompile Include="Scene\Camera.cpp">\r
+ <Filter>Source Files</Filter>\r
+ </ClCompile>\r
</ItemGroup>\r
<ItemGroup>\r
<ClInclude Include="Fps.h">\r
<ClInclude Include="Graphix\Shader.h">\r
<Filter>Header Files</Filter>\r
</ClInclude>\r
- <ClInclude Include="Graphix\ViewPort.h">\r
- <Filter>Header Files</Filter>\r
- </ClInclude>\r
<ClInclude Include="Game.h">\r
<Filter>Header Files</Filter>\r
</ClInclude>\r
<ClInclude Include="Graphix\Textures\dBufferObject.h">\r
<Filter>Header Files</Filter>\r
</ClInclude>\r
+ <ClInclude Include="Scene\Camera.h">\r
+ <Filter>Header Files</Filter>\r
+ </ClInclude>\r
</ItemGroup>\r
</Project>
\ No newline at end of file
projects / cgue_weave.git / commitdiff