gbuffer.cpp

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

namespace glare
{
	namespace core
	{
		GBuffer::GBuffer(unsigned int width, unsigned int 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<TextureMultisampled>>(unsigned(mode->width), 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::eColor6);
			m_gbuffer_framebuffer->attach(gl::Attachment::eDepth);

			m_lights_buffer = std::make_unique<Buffer<gl::BufferType::eShaderStorage>>();

			//Update all uniforms that won't change anymore...
			m_texture_renderer->shader().uniform("u_gbuffer.depth", m_gbuffer_framebuffer->depthAttachment().makeTextureResident());
			m_texture_renderer->shader().uniform("u_gbuffer.diffuse", m_gbuffer_framebuffer->colorAttachment(gl::Attachment::eColor0).makeTextureResident());
			m_texture_renderer->shader().uniform("u_gbuffer.normals", m_gbuffer_framebuffer->colorAttachment(gl::Attachment::eColor1).makeTextureResident());
			m_texture_renderer->shader().uniform("u_gbuffer.specular", m_gbuffer_framebuffer->colorAttachment(gl::Attachment::eColor2).makeTextureResident());
			m_texture_renderer->shader().uniform("u_gbuffer.id", m_gbuffer_framebuffer->colorAttachment(gl::Attachment::eColor3).makeTextureResident());
			m_texture_renderer->shader().uniform("u_gbuffer.position", m_gbuffer_framebuffer->colorAttachment(gl::Attachment::eColor4).makeTextureResident());
			m_texture_renderer->shader().uniform("u_gbuffer.position_raw", m_gbuffer_framebuffer->colorAttachment(gl::Attachment::eColor5).makeTextureResident());
			m_texture_renderer->shader().uniform("u_gbuffer.lighting", m_gbuffer_framebuffer->colorAttachment(gl::Attachment::eColor6).makeTextureResident());

			// 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");
		}

		GBuffer::~GBuffer()
		{
		}

		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
		{
			gl::setEnabled(gl::EnableParameter::eDepthTest, false);
			m_texture_renderer->shader().use();

			m_lights_buffer->upload(LightManager::getInstance().storage(), gl::BufferUsage::eDynamicCopy);
			m_texture_renderer->shader().storageBuffer("lightsBuffer", *m_lights_buffer);

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

			LightManager::getInstance().clear();
			m_texture_renderer->shader().uniform("u_view", state::camera->getView());
			m_texture_renderer->shader().uniform("u_projection", state::camera->getProjection());
			m_texture_renderer->shader().uniform("camera_position", glm::vec3(state::camera->getOwner()->absoluteTransform() * glm::vec4(0,0,0,1)));
			m_texture_renderer->draw();
			gl::setEnabled(gl::EnableParameter::eDepthTest, true);
		}

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

		const Framebuffer<TextureMultisampled>& 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 = 100;// width;
			m_height = 100;// 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);
		}
	}
}