gbuffer.cpp

#include "GBuffer.h" 
#include <core/state.h>
#include <core/numeric/flags.h>
#include <util/files.h>
#include <core/objects/light.h>
#include <core/message_tags.h>
#include <core/rendering/batch_render_list.h>

namespace glare::core
{
	GBuffer::GBuffer()
		: m_width(0), m_height(0), m_skybox(std::make_shared<core::Skybox>())
	{
	}

	GBuffer::GBuffer(unsigned int width, unsigned int height, unsigned samples)
		: GBuffer()
	{
		initialize(width, height, samples);
	}

	void GBuffer::initialize(unsigned width, unsigned height, unsigned samples)
	{
		m_width = width;
		m_height = height;

		m_texture_renderer = DefaultTextureRenderers::makeRenderer(files::shader("screenshader/gbuffer/gbuffer.frag"));

		const GLFWvidmode * mode = glfwGetVideoMode(glfwGetPrimaryMonitor());

		m_gbuffer_framebuffer = std::make_shared<Framebuffer>(static_cast<unsigned>(mode->width), static_cast<unsigned>(mode->height), samples);
		m_gbuffer_framebuffer->attach(gl::Attachment::eColor0);
		m_gbuffer_framebuffer->attach(gl::Attachment::eColor1);
		m_gbuffer_framebuffer->attach(gl::Attachment::eColor2);
		m_gbuffer_framebuffer->attach(gl::Attachment::eColor3);
		m_gbuffer_framebuffer->attach(gl::Attachment::eColor4);
		m_gbuffer_framebuffer->attach(gl::Attachment::eColor5);
		m_gbuffer_framebuffer->attach(gl::Attachment::eDepth);

		m_temporary_framebuffer_01 = std::make_shared<Framebuffer>(static_cast<unsigned>(mode->width), static_cast<unsigned>(mode->height));
		m_temporary_framebuffer_01->attach(gl::Attachment::eColor0);
		m_temporary_framebuffer_02 = std::make_shared<Framebuffer>(static_cast<unsigned>(mode->width), static_cast<unsigned>(mode->height));
		m_temporary_framebuffer_02->attach(gl::Attachment::eColor0);

		m_lights_buffer = std::make_unique<Buffer>();

		//Update all uniforms that won't change anymore...
		m_texture_renderer->shader().uniform("u_gbuffer.base_ior", m_gbuffer_framebuffer->attachment(gl::Attachment::eColor0).residentTextureAddress());
		m_texture_renderer->shader().uniform("u_gbuffer.rough_metallic_transmit_emit", m_gbuffer_framebuffer->attachment(gl::Attachment::eColor1).residentTextureAddress());
		m_texture_renderer->shader().uniform("u_gbuffer.normal", m_gbuffer_framebuffer->attachment(gl::Attachment::eColor2).residentTextureAddress());
		m_texture_renderer->shader().uniform("u_gbuffer.modelview_position", m_gbuffer_framebuffer->attachment(gl::Attachment::eColor3).residentTextureAddress());
		m_texture_renderer->shader().uniform("u_gbuffer.world_position", m_gbuffer_framebuffer->attachment(gl::Attachment::eColor4).residentTextureAddress());
		m_texture_renderer->shader().uniform("u_gbuffer.depth", m_gbuffer_framebuffer->attachment(gl::Attachment::eDepth).residentTextureAddress());

		// Those will only be later updated at will when resizing.
		m_texture_renderer->shader().uniform("screen.width", m_width);
		m_texture_renderer->shader().uniform("screen.height", m_height);
		m_texture_renderer->shader().uniform("u_samples", m_gbuffer_framebuffer->samples());

		m_texture_renderer->shader().bindSubroutine(gl::ShaderType::eFragment, "u_light_sample[0]", "samplePoint");
		m_texture_renderer->shader().bindSubroutine(gl::ShaderType::eFragment, "u_light_sample[1]", "sampleSpot");
		m_texture_renderer->shader().bindSubroutine(gl::ShaderType::eFragment, "u_light_sample[2]", "sampleDirectional");
		m_texture_renderer->shader().bindSubroutine(gl::ShaderType::eFragment, "u_light_sample[3]", "sampleAmbient");

	}

	void GBuffer::record(std::function<void()> render_function) const
	{
		activate();
		render_function();
		deactivate();
	}

	void GBuffer::activate() const
	{
		m_gbuffer_framebuffer->activate();
		gl::clear(gl::ClearBufferBits::eColor | gl::ClearBufferBits::eDepth);
	}

	void GBuffer::deactivate() const
	{
		m_gbuffer_framebuffer->deactivate();
	}

	void GBuffer::draw() const
	{
		m_lights_buffer->upload<LightShadow>(core::Context::current().lights().get(), gl::BufferUsage::eDynamicDraw);

		m_temporary_framebuffer_01->activate();
		static auto ssao_renderer = DefaultTextureRenderers::makeRenderer(files::shader("screenshader/ssao/ssao.frag"));
		ssao_renderer->shader().uniform("projection_matrix", core::Context::current().camera()->projectionMatrix());
		ssao_renderer->shader().uniform("screen_space_positions", m_gbuffer_framebuffer->attachment(gl::Attachment::eColor3).residentTextureAddress());
		ssao_renderer->shader().uniform("screen_space_normals", m_gbuffer_framebuffer->attachment(gl::Attachment::eColor5).residentTextureAddress());
		ssao_renderer->shader().uniform("u_gbuffer.depth", m_gbuffer_framebuffer->attachment(gl::Attachment::eDepth).residentTextureAddress());
		ssao_renderer->shader().uniform("screen_size", glm::vec2(m_width, m_height));
		ssao_renderer->draw();
		m_temporary_framebuffer_01->deactivate();

		m_temporary_framebuffer_02->activate();
		static auto blur_1d = DefaultTextureRenderers::makeRenderer(files::shader("screenshader/blur/blur_1d.frag"));
		blur_1d->shader().uniform("rgb_color_texture", m_temporary_framebuffer_01->attachment(gl::Attachment::eColor0).residentTextureAddress());
		blur_1d->shader().uniform("axis", 0u);
		blur_1d->draw();
		m_temporary_framebuffer_02->deactivate();

		m_temporary_framebuffer_01->activate();
		blur_1d->shader().uniform("rgb_color_texture", m_temporary_framebuffer_02->attachment(gl::Attachment::eColor0).residentTextureAddress());
		blur_1d->shader().uniform("axis", 1u);
		blur_1d->draw();
		m_temporary_framebuffer_01->deactivate();

		deactivate();
		gl::setEnabled(gl::EnableParameter::eDepthTest, false);
		m_texture_renderer->shader().use();

		m_texture_renderer->shader().storageBuffer("lightsBuffer", *m_lights_buffer);

		if (m_skybox->isInitialized())
			m_texture_renderer->shader().uniform("environment", m_skybox->makeResident());

		m_texture_renderer->shader().uniform("u_ssao_texture", m_temporary_framebuffer_01->attachment(gl::Attachment::eColor0).residentTextureAddress());
		m_texture_renderer->shader().uniform("u_view", core::Context::current().camera()->viewMatrix());
		m_texture_renderer->shader().uniform("u_projection", core::Context::current().camera()->projectionMatrix());
		m_texture_renderer->shader().uniform("camera_position", glm::vec3(core::Context::current().camera()->owner()->worldTransform().position));
		m_texture_renderer->draw();
		gl::setEnabled(gl::EnableParameter::eDepthTest, true);
	}

	std::shared_ptr<Skybox> GBuffer::getSkybox() const
	{
		return m_skybox;
	}

	void GBuffer::setSkybox(std::shared_ptr<Skybox> skybox)
	{
		m_skybox = skybox;
	}

	const Framebuffer& GBuffer::framebuffer() const
	{
		return *m_gbuffer_framebuffer;
	}

	void GBuffer::updateSize(unsigned width, unsigned height)
	{
		updateSize(width, height, m_gbuffer_framebuffer->samples());
	}

	void GBuffer::updateSize(unsigned width, unsigned height, unsigned samples)
	{
		m_width = width;// width;
		m_height = height;// height;
		m_gbuffer_framebuffer->resize(width, height, samples);
		m_texture_renderer->shader().uniform("screen.width", m_width);
		m_texture_renderer->shader().uniform("screen.height", m_height);
		m_texture_renderer->shader().uniform("u_samples", samples);
	}
}