#pragma once
#include "../NCLGL/OGLRenderer.h"
class Camera;
class HeightMap;
class SceneNode;
class Mesh;
class MeshAnimation;
class MeshMaterial;
class CubeRobot;
#include "../nclgl/Light.h"
#include "../nclgl/Frustum.h"	

#include <algorithm>

class Renderer : public OGLRenderer {
public:
	Renderer(Window& parent);
	~Renderer(void);
	void RenderScene() override;
	void UpdateScene(float dt) override;

	void toggleCameraAutomatic() {
		cameraAutomatic = !cameraAutomatic;
	}

	void toggleRedPostProcess() {
		applyRedPostProcess = !applyRedPostProcess;
	}

	void toggleDrawSplitScreen() {
		drawSplitScreen = !drawSplitScreen;
	}

protected:
	void DrawHeightmap();
	void DrawWater();
	void DrawSkybox();
	void DrawCharacter();
	void DrawMainNodeScene();

	void DrawShadowScene();
	void DrawMainShadowScene();

	void SetupSceneOne();

	void BuildNodeLists(SceneNode* from);
	void SortNodeLists();
	void ClearNodeLists();
	void DrawNodes();
	void DrawNode(SceneNode* n);
	//void DrawNode(SceneNode* n);

	//void GenerateCharacter(Mesh* meshValue, MeshAnimation* animValue, MeshMaterial* materialValue);


	void generateGBuffer();
	void generateLightBuffer();
	void generateShadowBuffer();
	void generateShadowCubeMapBuffer();
	void generateCombinedBuffer();

	void GenerateScreenTexture(GLuint& into, bool depth = false);
	void GenerateShadowTexture(GLuint& into);
	void GenerateShadowCubeMapTexture(GLuint& into);

	void DrawRedPostProcess();

	void CombineBuffers();

	void DrawPostProcess();


	bool applyRedPostProcess = false;	
	bool drawSplitScreen = false;
	int currentScreenNum = 0;
	float redIntensity = 0;
	bool moveCamOne = true;

	bool cameraAutomatic = true;

	float waitCameraTime = 0;

	GLuint bufferFBO;
	GLuint bufferColourTex;
	GLuint bufferNormalTex;
	GLuint bufferPosTex;
	GLuint bufferDepthTex;

	GLenum gBuffer[3];
	GLenum lightBuffer[2];
	GLenum combinedBuffer[1];

	GLuint pointLightFBO;
	GLuint lightEmissiveTex;
	GLuint lightSpecularTex;

	GLuint shadowFBO;
	GLuint shadowTex;

	GLuint shadowCubeMapFBO;
	GLuint shadowCubeMapTex;

	GLuint combinedFBO;
	GLuint combinedTex;

	GLuint processFBO;
	GLuint bufferColourTexPost[2];


	Shader* sceneShader;
	Shader* lightShader;
	Shader* reflectShader;
	Shader* skyboxShader;
	Shader* skinningShader;
	Shader* shadowShader;
	Shader* shadowSceneShader;
	//Shader* reflectSphereShader;
	Shader* redShader;
	Shader* combineShader;
	//Shader* sceneBlurShader;
	//Shader* processBlurShader;
//
	//HeightMap* heightMap;
	Mesh* fullScreenQuad;

	HeightMap* terrain;

	Light* light;
	Light* light2;

	//Camera* camera;

	GLuint skybox;
	GLuint waterTex;
	GLuint earthTex;
	GLuint earthBump;

	float waterRotate;
	float waterCycle;


	Camera* currentCamera;
	Camera* camOne;
	Camera* camTwo;

	Matrix4 cameraPerspectiveMatrix;
	Matrix4 cameraSplitScreenPerspectiveMatrix;
	Matrix4 shadowPerspectiveMatrix;

	SceneNode* root;

	SceneNode* sceneZero;
	SceneNode* sceneOne;



	Frustum frameFrustum;

	vector<SceneNode*> transparentNodeList;
	vector<SceneNode*> nodeList;


	Mesh* cubeRobot;

	GLuint sphere1Tex;



	//Shader* shader;
	//GLuint texture;

	Mesh* mesh;
	MeshAnimation* anim;
	MeshMaterial* material;
	vector<GLuint> matTextures;
	int currentFrame;
	float frameTime;

	GLuint sceneDiffuse;
	GLuint sceneBump;
	float sceneTime;

	vector<Mesh*> sceneMeshes;
	vector<Matrix4> sceneTransforms;
};