294 lines
8.7 KiB
C++
294 lines
8.7 KiB
C++
#ifndef _APPLICATIONCLASS_H_
|
|
#define _APPLICATIONCLASS_H_
|
|
|
|
|
|
///////////////////////
|
|
// MY CLASS INCLUDES //
|
|
///////////////////////
|
|
#include "d3dclass.h"
|
|
#include "cameraclass.h"
|
|
#include "object.h"
|
|
#include "lightclass.h"
|
|
#include <vector>
|
|
#include <filesystem>
|
|
|
|
#include "bitmapclass.h"
|
|
#include "spriteclass.h"
|
|
#include "timerclass.h"
|
|
#include "fontshaderclass.h"
|
|
#include "fontclass.h"
|
|
#include "textclass.h"
|
|
#include "fpsclass.h"
|
|
#include "inputclass.h"
|
|
#include "shadermanagerclass.h"
|
|
#include "modellistclass.h"
|
|
#include "positionclass.h"
|
|
#include "frustumclass.h"
|
|
#include "rendertextureclass.h"
|
|
#include "displayplaneclass.h"
|
|
#include "translateshaderclass.h"
|
|
#include "reflectionshaderclass.h"
|
|
#include "physics.h"
|
|
#include "frustum.h"
|
|
#include "skybox.h"
|
|
|
|
|
|
#include <fstream>
|
|
#include <WICTextureLoader.h>
|
|
#include <comdef.h> // Pour _com_error
|
|
#include <chrono>
|
|
#include <thread>
|
|
#include <map>
|
|
#include <algorithm>
|
|
#include <DirectXMath.h>
|
|
|
|
|
|
/////////////
|
|
// GLOBALS //
|
|
/////////////
|
|
const bool FULL_SCREEN = false;
|
|
const float SCREEN_DEPTH = 1000.0f;
|
|
const float SCREEN_NEAR = 0.3f;
|
|
|
|
struct Input
|
|
{
|
|
bool m_KeyLeft = false;
|
|
bool m_KeyRight = false;
|
|
bool m_KeyUp = false;
|
|
bool m_KeyDown = false;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Class name: ApplicationClass
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
class ApplicationClass
|
|
{
|
|
public:
|
|
ApplicationClass();
|
|
~ApplicationClass();
|
|
D3DClass* GetDirect3D();
|
|
RenderTextureClass* GetSceneTexture() const { return m_SceneTexture; };
|
|
RenderTextureClass* GetRenderTexture() const { return m_RenderTexture; };
|
|
RenderTextureClass* GetRefractionTexture() const { return m_RefractionTexture; };
|
|
RenderTextureClass* GetReflectionTexture() const { return m_ReflectionTexture; };
|
|
|
|
|
|
bool Initialize(int, int, HWND, bool IsVulkan);
|
|
void Shutdown();
|
|
bool Frame(InputClass*);
|
|
void PhysicsThreadFunction();
|
|
int GetPhysicsTickRate() const { return m_PhysicsTickRate; };
|
|
void SetPhysicsTickRate(int physicsTickRate) { m_PhysicsTickRate = physicsTickRate; };
|
|
|
|
int GetScreenWidth() const;
|
|
void SetScreenWidth(int screenWidth);
|
|
int GetScreenHeight() const;
|
|
void SetScreenHeight(int screenHeight);
|
|
|
|
float GetSpeed() const { return m_speed; };
|
|
void SetSpeed(float speed) { this->m_speed = speed; };
|
|
|
|
void AddCube();
|
|
void DeleteKobject(int index);
|
|
size_t GetCubeCount() const { return m_cubes.size(); };
|
|
size_t GetTerrainCubeCount() const { return m_terrainChunk.size(); };
|
|
std::vector<Object*> GetCubes() const { return m_cubes; };
|
|
std::vector<Object*> GetTerrainCubes() const { return m_terrainChunk; };
|
|
std::vector<Object*> GetKobjects() const { return m_object; };
|
|
void AddKobject(std::wstring& filepath);
|
|
void SetPath(WCHAR* path) { m_path = path; };
|
|
void SetWFolder(std::filesystem::path WFolder) { m_WFolder = WFolder; };
|
|
|
|
void GenerateTerrain();
|
|
void DeleteTerrain();
|
|
|
|
XMVECTOR GetLightPosition(int index);
|
|
XMVECTOR GetLightColor(int index);
|
|
void SetLightPosition(int index, XMVECTOR color);
|
|
void SetLightColor(int index, XMVECTOR color);
|
|
void DeleteLight(int index);
|
|
void AddLight();
|
|
std::vector<LightClass*> GetLights() const { return m_Lights; };
|
|
LightClass* GetSunLight() const { return m_SunLight; };
|
|
|
|
bool GetShouldQuit() const { return m_ShouldQuit; };
|
|
void SetShouldQuit(bool shouldQuit) { m_ShouldQuit = shouldQuit; };
|
|
|
|
void SetCelShading(bool enable) { m_enableCelShading = enable; };
|
|
|
|
void SetVsync(bool vsync);
|
|
bool GetVsync() const { return VSYNC_ENABLED; };
|
|
|
|
HWND GetHwnd() const;
|
|
void SetHwnd(HWND hwnd);
|
|
|
|
bool IsWindowed() const;
|
|
void SetWindowed(bool windowed);
|
|
|
|
void SetWindowSize(ImVec2 size) { windowSize = size; };
|
|
ImVec2 GetWindowSize() const { return windowSize; };
|
|
float GetAspectRatio() const { return (float)m_screenWidth / (float)m_screenHeight; };
|
|
|
|
Physics* GetPhysics() const { return m_Physics; };
|
|
|
|
// ----------------------------------- //
|
|
// ------------- Culling ------------- //
|
|
// ----------------------------------- //
|
|
|
|
Frustum GetFrustum() const { return m_FrustumCulling; };
|
|
void SetFrustum(Frustum frustum) { m_FrustumCulling = frustum; };
|
|
|
|
void ConstructFrustum();
|
|
int GetRenderCount() const { return m_renderCount; };
|
|
void SetRenderCount(int renderCount) { m_renderCount = renderCount; };
|
|
float GetFrustumTolerance() const { return m_FrustumCullingTolerance; };
|
|
void SetFrustumTolerance(float frustumTolerance) { m_FrustumCullingTolerance = frustumTolerance; };
|
|
|
|
bool GetCanFixedUpdate() const { return CanFixedUpdate; };
|
|
void SetCanFixedUpdate(bool canFixedUpdate) { CanFixedUpdate = canFixedUpdate; };
|
|
|
|
ID3D11ShaderResourceView* GetBackBufferSRV() const {return m_BackBufferSRV;};
|
|
|
|
// Save and load scene
|
|
void SaveScene();
|
|
bool LoadScene();
|
|
|
|
void SetScenePath(std::string path) { m_scenePath = path; };
|
|
std::wstring GetScenePath();
|
|
|
|
std::string ConvertWStringToString(const std::wstring& wstr);
|
|
|
|
private:
|
|
bool Render(float, float, float, float, float);
|
|
bool RenderPhysics(bool keyLeft, bool keyRight, bool keyUp, bool keyDown, float deltaTime);
|
|
bool UpdateMouseStrings(int, int, bool);
|
|
bool UpdateFps();
|
|
bool UpdateRenderCountString(int);
|
|
bool RenderSceneToTexture(float);
|
|
bool RenderRefractionToTexture();
|
|
bool RenderReflectionToTexture();
|
|
bool RenderPass(const std::vector<std::reference_wrapper<std::vector<Object*>>>& RenderQueues, XMFLOAT4* diffuse, XMFLOAT4* position, XMFLOAT4* ambient, XMMATRIX view, XMMATRIX projection);
|
|
|
|
void UpdateSkyboxPosition();
|
|
|
|
public :
|
|
std::vector<ID3D11ShaderResourceView*> textures;
|
|
|
|
private :
|
|
|
|
// ------------------------------------- //
|
|
// ------------- DIRECT3D -------------- //
|
|
// ------------------------------------- //
|
|
|
|
D3DClass* m_Direct3D;
|
|
IDXGISwapChain* m_swapChain;
|
|
ModelClass* m_Model,* m_GroundModel, * m_WallModel, * m_BathModel, * m_WaterModel;
|
|
ModelListClass* m_ModelList;
|
|
bool VSYNC_ENABLED = true;
|
|
|
|
HWND m_hwnd;
|
|
bool m_windowed;
|
|
|
|
std::string m_scenePath;
|
|
|
|
// ------------------------------------- //
|
|
// ------------- RENDERING ------------- //
|
|
// ------------------------------------- //
|
|
|
|
XMMATRIX m_baseViewMatrix;
|
|
RenderTextureClass* m_RenderTexture, * m_RefractionTexture, * m_ReflectionTexture;
|
|
RenderTextureClass* m_SceneTexture;
|
|
DisplayPlaneClass* m_DisplayPlane;
|
|
int m_screenWidth, m_screenHeight;
|
|
CameraClass* m_Camera;
|
|
PositionClass* m_Position;
|
|
|
|
// ------------------------------------ //
|
|
// ------------- OBJECTS -------------- //
|
|
// ------------------------------------ //
|
|
|
|
Object* m_SelectedObject;
|
|
std::vector<Object*> m_cubes;
|
|
std::vector<Object*> m_terrainChunk;
|
|
float m_speed = 0.1f; // speed for the demo spinning object
|
|
std::vector<Object*> m_object;
|
|
std::vector<Object*> m_ImportedObject;
|
|
int m_ObjectId = 0;
|
|
std::vector<std::reference_wrapper<std::vector<Object*>>> m_RenderQueues;
|
|
std::vector<Object*> m_Skybox;
|
|
|
|
// ----------------------------------- //
|
|
// ------------- LIGHTS -------------- //
|
|
// ----------------------------------- //
|
|
|
|
LightClass* m_Light;
|
|
std::vector<LightClass*> m_Lights;
|
|
int m_numLights;
|
|
LightClass* m_SunLight;
|
|
|
|
XMFLOAT3 TrueLightPosition;
|
|
ModelClass* m_LightModel;
|
|
|
|
// ----------------------------------- //
|
|
// ------------- SHADERS ------------- //
|
|
// ----------------------------------- //
|
|
|
|
ShaderManagerClass* m_ShaderManager;
|
|
FontShaderClass* m_FontShader;
|
|
BitmapClass* m_Bitmap;
|
|
SpriteClass* m_Sprite;
|
|
|
|
bool m_enableCelShading;
|
|
|
|
// ----------------------------------- //
|
|
// ------------ VARIABLES ------------ //
|
|
// ----------------------------------- //
|
|
|
|
float m_waterHeight, m_waterTranslation;
|
|
wchar_t* m_path;
|
|
std::filesystem::path m_WFolder;
|
|
|
|
// ------------------------------------------------- //
|
|
// ------------- FPS AND INFO ON SCREEN ------------ //
|
|
// ------------------------------------------------- //
|
|
|
|
TimerClass* m_Timer;
|
|
TextClass* m_MouseStrings;
|
|
TextClass* m_RenderCountString;
|
|
FontClass* m_Font;
|
|
FpsClass* m_Fps;
|
|
TextClass* m_FpsString;
|
|
int m_previousFps;
|
|
|
|
// ------------------------------------------------- //
|
|
// ------------------- OTHER ----------------------- //
|
|
// ------------------------------------------------- //
|
|
|
|
bool m_ShouldQuit;
|
|
Physics* m_Physics;
|
|
float m_gravity;
|
|
XMVECTOR m_previousPosition;
|
|
ImVec2 windowSize;
|
|
int m_PhysicsTickRate = 50;
|
|
bool CanFixedUpdate = false;
|
|
std::thread m_PhysicsThread;
|
|
|
|
ID3D11Texture2D* m_BackBufferTexture;
|
|
ID3D11ShaderResourceView* m_BackBufferSRV;
|
|
|
|
// ------------------------------------------------- //
|
|
// ------------------- Culling --------------------- //
|
|
// ------------------------------------------------- //
|
|
|
|
Frustum m_FrustumCulling;
|
|
int m_renderCount;
|
|
float m_FrustumCullingTolerance = 5.f;
|
|
|
|
// ------------------------------------------------- //
|
|
// -------------------- Input ---------------------- //
|
|
// ------------------------------------------------- //
|
|
|
|
Input m_Inputs;
|
|
};
|
|
|
|
#endif |