/*
 * Copyright (C) 2017-2019  Christopher J. Howard
 *
 * This file is part of Antkeeper Source Code.
 *
 * Antkeeper Source Code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Antkeeper Source Code 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Antkeeper Source Code.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "sky-render-pass.hpp"
#include "resources/resource-manager.hpp"

SkyRenderPass::SkyRenderPass(ResourceManager* resourceManager):
	resourceManager(resourceManager),
	shader(nullptr)
{}

bool SkyRenderPass::load(const RenderContext* renderContext)
{
	const float quadVertexData[] =
	{
		-1.0f,  1.0f, 0.0f,
		-1.0f, -1.0f, 0.0f,
		 1.0f, -1.0f, 0.0f,
		 1.0f,  1.0f, 0.0f
	};

	const std::uint32_t quadIndexData[] =
	{
		0, 1, 3,
		3, 1, 2
	};

	quadVertexCount = 4;
	quadIndexCount = 6;
	
	// Create quad geometry
	glGenVertexArrays(1, &quadVAO);
	glBindVertexArray(quadVAO);
	glGenBuffers(1, &quadVBO);
	glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 3 * quadVertexCount, quadVertexData, GL_STATIC_DRAW);
	glEnableVertexAttribArray(EMERGENT_VERTEX_POSITION);
	glVertexAttribPointer(EMERGENT_VERTEX_POSITION, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (char*)0 + 0*sizeof(float));
	glGenBuffers(1, &quadIBO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, quadIBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(std::uint32_t) * quadIndexCount, quadIndexData, GL_STATIC_DRAW);

	// Load sky shader
	shader = resourceManager->load<Shader>("sky.glsl");
	
	// Generate shader permutation
	if (!shader->generatePermutation(0))
	{
		std::cerr << std::string("SkyRenderPass: failed to generate shader permutation.") << std::endl;
		return false;
	}
	
	// Connect shader variables
	matrixParam.connect(shader->getInput("matrix"));
	sunDirectionParam.connect(shader->getInput("sunDirection"));
	sunAngularRadiusParam.connect(shader->getInput("sunAngularRadius"));
	skyGradientParam.connect(shader->getInput("skyGradient"));

	// Load sky gradient texture
	skyGradientTexture = resourceManager->load<Texture2D>("sky-gradient-noon.png");

	// Set sun angular radius
	sunAngularRadius = glm::radians(2.0f);
	
	return true;
}

void SkyRenderPass::unload()
{
	// Free quad geometry
	glDeleteBuffers(1, &quadIBO);
	glDeleteBuffers(1, &quadVBO);
	glDeleteVertexArrays(1, &quadVAO);

	matrixParam.disconnect();
	sunDirectionParam.disconnect();
	sunAngularRadiusParam.disconnect();
	skyGradientParam.disconnect();
	shader->deleteAllPermutations();
}

void SkyRenderPass::render(RenderContext* renderContext)
{
	const Camera& camera = *(renderContext->camera);

	// Get sun light
	const std::list<SceneObject*>* lights = renderContext->scene->getObjects(SceneObjectType::LIGHT);
	DirectionalLight* sun = nullptr;
	for (SceneObject* object: *lights)
	{
		Light* light = reinterpret_cast<Light*>(object);
		if (light->getLightType() == LightType::DIRECTIONAL)
		{
			sun = reinterpret_cast<DirectionalLight*>(light);
			break;
		}
	}
	
	// Bind framebuffer and setup viewport
	glBindFramebuffer(GL_FRAMEBUFFER, renderTarget->framebuffer);
	glViewport(0, 0, renderTarget->width, renderTarget->height);

	// Disable depth testing and writing
	glDisable(GL_DEPTH_TEST);
	glDepthMask(GL_FALSE);
	
	// Enable backface culling
	glEnable(GL_CULL_FACE);
	glCullFace(GL_BACK);
	
	// Disable alpha blending
	glDisable(GL_BLEND);

	// Calculate matrix
	Matrix4 modelView = Matrix4(Matrix3(camera.getViewTween()->getSubstate()));
	const Matrix4& inverseProjection = camera.getInverseProjectionTween()->getSubstate();
	Matrix4 matrix = glm::inverse(modelView) * inverseProjection;

	// Get sun direction
	Vector3 sunDirection = Vector3(0, 0, 1);
	if (sun)
	{
		sunDirection = glm::normalize(sun->getDirectionTween()->getSubstate());
	}

	// Bind shader
	shader->activate(0);

	// Set shader param values
	matrixParam.setValue(matrix);
	sunDirectionParam.setValue(sunDirection);
	sunAngularRadiusParam.setValue(sunAngularRadius);
	skyGradientParam.setValue(skyGradientTexture);

	// Upload shader params
	matrixParam.upload();
	sunDirectionParam.upload();
	sunAngularRadiusParam.upload();
	skyGradientParam.upload();
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		
	// Draw quad
	glBindVertexArray(quadVAO);
	glDrawElementsBaseVertex(GL_TRIANGLES, quadIndexCount, GL_UNSIGNED_INT,	(void*)0, 0);
}