/*
	QGL Renderer
	Ivan Pelipenko peri4ko@yandex.ru

	This program is free software: you can redistribute it and/or modify
	it under the terms of the GNU Lesser General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public License
	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef RENDERER_H
#define RENDERER_H

#include "renderer_base.h"
#include "renderer_material.h"
#include "renderer_service.h"
#include "renderer_selection.h"
#include "tonemapping_proc.h"
#include "glcubemap.h"
#include <QQueue>


class Renderer: public RendererBase {
	friend class QGLView;
	friend class MouseController;
	friend class RendererMaterial;
	friend class RendererService;
	friend class RendererSelection;
	friend class TonemappingProc;
	enum ShaderRole {
		// Selection
		srSelectionFill,
		srSelectionHalo,
		srSelectionApply,
		srSelectionFrame,

		// Service
		srServiceFill,
		srServiceFrame,
		srServiceLine,

		// Deferred shading
		srGeometryPass,
		srLightOmniPass,
		srLightSpotPass,
		srFinalPass,
		srTonemapPass,
	};
	enum DeferredBufferRole {
		dbrDiffuse,
		dbrNormalZ,
		dbrSpecularReflect,
		dbrEmissionRough,
		dbrSpeedBitangXY,

		dbrBuffersCount,
	};
	enum OutBufferRole {
		obrTonemap,
		obrSum,
		obrSolidOmni,
		obrSolidSpot,
		obrTransparentOmni,
		obrTransparentSpot,

		obrBuffersCount,
	};

public:
	Renderer(QGLView * view_);
	virtual ~Renderer();

	void init(int width, int height);
	void resize(int width, int height);
	void reloadShaders();
	void renderScene();
	void setCameraLightMode(int m);
	int cameraLightMode() const {return camera_light_mode;}
	void setGrabImage(bool on);
	bool isGrabImage() const {return is_grabbing;}
	QImage getImage() const {return last_img;}

	QImage materialThumbnail(Material * m) {return rend_mat.materialThumbnail(m);}
	void recreateMaterialThumbnails(bool force_all = false) {rend_mat.recreateMaterialThumbnails(force_all);}

protected:
	void fillObjectsBuffer(const ObjectBaseList & ol, RenderPass pass);
	void reloadObjects();
	void renderObjects(Scene & scene, RenderPass pass);
	void renderLight(int first_wr_buff, bool clear_only);

	bool bindShader(ShaderRole role, QOpenGLShaderProgram ** ret = 0);
	bool bindShader(QOpenGLShaderProgram * sp);
	void initShaders();
	void releaseShader();

private:
	float gamma_ = 1.f;
	int camera_light_mode;
	bool edit_mode, need_init_shaders, need_render_sum;
	Framebuffer fbo_ds, fbo_out;
	QMap<ShaderRole, QString> shader_files;
	QMap<ShaderRole, QStringList> shader_defines;
	QMap<ShaderRole, QOpenGLShaderProgram*> shaders;
	QOpenGLShaderProgram * shader_fxaa = nullptr;

	RendererMaterial rend_mat;
	RendererService rend_service;
	RendererSelection rend_selection;
	TonemappingProc tone_proc;

	Mesh * quad;
	Light * cam_light;
	CubeTexture tex_env;

	QPoint mouse_pos;
	QRect mouse_rect;
	QMatrix4x4 prev_view, prev_proj;
	QMatrix3x3 nm;
	QVector4D corner_dirs[4];
	QVector<QVector3D> hcontent;
	QMap<int, QList<Light*>> cur_lights;
	QImage last_img;
	bool is_grabbing = false;
};

#endif // RENDERER_H