Load default shader resources at renderer startup

src/Device.cpp

@@ -129,6 +129,8 @@ bool Device::init(int argc, char** argv)
 
 	create_renderer();
 
+	m_renderer->init();
+
 	Log::d("Renderer created.");
 
 	create_debug_renderer();
@@ -198,6 +200,8 @@ void Device::shutdown()
 
 	if (m_renderer)
 	{
+		m_renderer->shutdown();
+
 		delete m_renderer;
 	}
 

src/renderers/Renderer.h

@@ -57,6 +57,29 @@ enum LightType
 	LT_SPOT			= 2
 };
 
+enum ShaderAttrib
+{
+	SA_VERTEX			= 0,
+	SA_COORDS			= 1,
+	SA_NORMAL			= 2,
+	SA_DIFFUSE_MAP		= 3,
+	SA_DETAIL_MAP		= 4,
+	SA_NORMAL_MAP		= 5,
+
+	SA_COUNT
+};
+
+// Keep in sync with ShaderAttrib
+const char* const SHADER_ATTRIB_NAMES[] =
+{
+	"vertex",			// 0
+	"coords",			// 1
+	"normal",			// 2
+	"diffuse_map",		// 3
+	"detail_map",		// 4
+	"normal_map"		// 5
+};
+
 typedef Id VertexBufferId;
 typedef Id IndexBufferId;
 typedef Id RenderBufferId;
@@ -79,6 +102,9 @@ public:
 							Renderer() {}
 	virtual					~Renderer() {}
 
+	virtual void			init() = 0;
+	virtual void			shutdown() = 0;
+
 	/// Creates a new vertex buffer optimized for rendering static vertex data.
 	/// @vertices is the array containig @count vertex data elements of the given @format.
 	virtual VertexBufferId	create_vertex_buffer(size_t count, VertexFormat format, const void* vertices) = 0;

src/renderers/gl/GLRenderer.cpp

@@ -39,6 +39,10 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "Vec4.h"
 #include "Mat3.h"
 #include "Mat4.h"
+#include "Device.h"
+#include "ResourceManager.h"
+#include "VertexShaderResource.h"
+#include "PixelShaderResource.h"
 
 #if defined(WINDOWS)
 	//Define the missing constants in vs' gl.h
@@ -149,7 +153,7 @@ GLRenderer::GLRenderer() :
 
 	glEnable(GL_LIGHTING);
 
-	glEnable(GL_BLEND);
+	glDisable(GL_BLEND);
 	//TODO: Use Premultiplied alpha
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 	glBlendEquation(GL_FUNC_ADD);
@@ -193,6 +197,18 @@ GLRenderer::~GLRenderer()
 {
 }
 
+//-----------------------------------------------------------------------------
+void GLRenderer::init()
+{
+	load_default_shaders();
+}
+
+//-----------------------------------------------------------------------------
+void GLRenderer::shutdown()
+{
+	unload_default_shaders();
+}
+
 //-----------------------------------------------------------------------------
 VertexBufferId GLRenderer::create_vertex_buffer(size_t count, VertexFormat format, const void* vertices)
 {
@@ -426,6 +442,10 @@ GPUProgramId GLRenderer::create_gpu_program(VertexShaderId vs, PixelShaderId ps)
 	glAttachShader(gl_program.gl_object, m_vertex_shaders[id.index].gl_object);
 	glAttachShader(gl_program.gl_object, m_pixel_shaders[id.index].gl_object);
 
+	glBindAttribLocation(gl_program.gl_object, SA_VERTEX, "vertex");
+	glBindAttribLocation(gl_program.gl_object, SA_COORDS, "coords");
+	glBindAttribLocation(gl_program.gl_object, SA_NORMAL, "normal");
+
 	glLinkProgram(gl_program.gl_object);
 
 	GLint success;
@@ -964,6 +984,9 @@ void GLRenderer::begin_frame()
 {
 	// Clear frame/depth buffer
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+	// Bind the default gpu program
+	bind_gpu_program(m_default_gpu_program);
 }
 
 //-----------------------------------------------------------------------------
@@ -1023,42 +1046,36 @@ void GLRenderer::bind_vertex_buffer(VertexBufferId vb) const
 	{
 		case VF_XY_FLOAT_32:
 		{
-			glEnableClientState(GL_VERTEX_ARRAY);
-			glVertexPointer(2, GL_FLOAT, 0, 0);
+			glEnableVertexAttribArray(SA_VERTEX);
+			glVertexAttribPointer(SA_VERTEX, 2, GL_FLOAT, GL_FALSE, 0, 0);
 			break;
 		}
 		case VF_XYZ_FLOAT_32:
 		{
-			glEnableClientState(GL_VERTEX_ARRAY);
-			glVertexPointer(3, GL_FLOAT, 0, 0);
+			glEnableVertexAttribArray(SA_VERTEX);
+			glVertexAttribPointer(SA_VERTEX, 3, GL_FLOAT, GL_FALSE, 0, 0);
 			break;
 		}
 		case VF_UV_FLOAT_32:
 		{
-			glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-			glTexCoordPointer(2, GL_FLOAT, 0, 0);
+			glEnableVertexAttribArray(SA_COORDS);
+			glVertexAttribPointer(SA_COORDS, 2, GL_FLOAT, GL_FALSE, 0, 0);
 			break;
 		}
 		case VF_UVT_FLOAT_32:
 		{
-			glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-			glTexCoordPointer(3, GL_FLOAT, 0, 0);
+			glEnableVertexAttribArray(SA_COORDS);
+			glVertexAttribPointer(SA_COORDS, 3, GL_FLOAT, GL_FALSE, 0, 0);
 			break;
 		}
 		case VF_XYZ_NORMAL_FLOAT_32:
 		{
-			glEnableClientState(GL_NORMAL_ARRAY);
-			glNormalPointer(GL_FLOAT, 0, 0);
+			glEnableVertexAttribArray(SA_NORMAL);
+			glVertexAttribPointer(SA_NORMAL, 3, GL_FLOAT, GL_FALSE, 0, 0);
 			break;
 		}
 		case VF_XYZ_UV_XYZ_NORMAL_FLOAT_32:
 		{
-			glEnableClientState(GL_VERTEX_ARRAY);
-			glEnableClientState(GL_NORMAL_ARRAY);
-			glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-			glVertexPointer(3, GL_FLOAT, 0, 0);
-			glTexCoordPointer(2, GL_FLOAT, 0, 0);
-			glNormalPointer(GL_FLOAT, 0, 0);
 			break;
 		}
 		default:
@@ -1160,6 +1177,56 @@ void GLRenderer::draw_lines(const float* vertices, const float* colors, uint32_t
 	glDisableClientState(GL_VERTEX_ARRAY);
 }
 
+//-----------------------------------------------------------------------------
+void GLRenderer::load_default_shaders()
+{
+	ResourceManager* resman = device()->resource_manager();
+
+	// Load default vertex/pixel shaders
+	m_default_vertex_shader = resman->load("default/default.vs");
+	m_default_pixel_shader = resman->load("default/default.ps");
+
+	// Wait for loading
+	resman->flush();
+
+	// Obtain resource data
+	VertexShaderResource* vs = (VertexShaderResource*)resman->data(m_default_vertex_shader);
+	PixelShaderResource* ps = (PixelShaderResource*)resman->data(m_default_pixel_shader);
+
+	// Create and bind the default program
+	m_default_gpu_program = create_gpu_program(vs->vertex_shader(), ps->pixel_shader());
+}
+
+//-----------------------------------------------------------------------------
+void GLRenderer::unload_default_shaders()
+{
+	ResourceManager* resman = device()->resource_manager();
+
+	destroy_gpu_program(m_default_gpu_program);
+
+	resman->unload(m_default_pixel_shader);
+	resman->unload(m_default_vertex_shader);
+}
+
+//-----------------------------------------------------------------------------
+void GLRenderer::reload_default_shaders()
+{
+	ResourceManager* resman = device()->resource_manager();
+
+	resman->reload(m_default_vertex_shader);
+	resman->reload(m_default_pixel_shader);
+
+	// Destroy old gpu program
+	destroy_gpu_program(m_default_gpu_program);
+
+	// Obtain resource data
+	VertexShaderResource* vs = (VertexShaderResource*)resman->data(m_default_vertex_shader);
+	PixelShaderResource* ps = (PixelShaderResource*)resman->data(m_default_pixel_shader);
+
+	// Create and bind the new default program
+	m_default_gpu_program = create_gpu_program(vs->vertex_shader(), ps->pixel_shader());
+}
+
 //-----------------------------------------------------------------------------
 bool GLRenderer::activate_texture_unit(uint32_t unit)
 {

src/renderers/gl/GLRenderer.h

@@ -36,6 +36,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "PixelShader.h"
 #include "IdTable.h"
 #include "MallocAllocator.h"
+#include "Resource.h"
 
 namespace crown
 {
@@ -98,6 +99,9 @@ public:
 						GLRenderer();
 						~GLRenderer();
 
+	void				init();
+	void				shutdown();
+
 	// Vertex buffers
 	VertexBufferId		create_vertex_buffer(size_t count, VertexFormat format, const void* vertices);
 	VertexBufferId		create_dynamic_vertex_buffer(size_t count, VertexFormat format, const void* vertices);
@@ -210,6 +214,11 @@ public:
 
 private:
 
+	// Loads the default shaders
+	void				load_default_shaders();
+	void				unload_default_shaders();
+	void				reload_default_shaders();
+
 	// Activates a texture unit and returns true if succes
 	bool				activate_texture_unit(uint32_t unit);
 	bool				activate_light(uint32_t light);
@@ -257,18 +266,26 @@ private:
 	IdTable				m_index_buffers_id_table;
 	GLIndexBuffer		m_index_buffers[MAX_INDEX_BUFFERS];
 
+	// Vertex shader management
 	IdTable 			m_vertex_shaders_id_table;
 	GLVertexShader		m_vertex_shaders[MAX_VERTEX_SHADERS];
 
+	// Pixel shader management
 	IdTable 			m_pixel_shaders_id_table;
 	GLPixelShader		m_pixel_shaders[MAX_PIXEL_SHADERS];
 
+	// GPU program management
 	IdTable 			m_gpu_programs_id_table;
 	GLGPUProgram		m_gpu_programs[128];
 
 	// Render buffer management
-	//IdTable				m_render_buffers_id_table;
-	//GLRenderBuffer		m_render_buffers[MAX_RENDER_BUFFERS];
+	//IdTable			m_render_buffers_id_table;
+	//GLRenderBuffer	m_render_buffers[MAX_RENDER_BUFFERS];
+
+	// Default shaders
+	ResourceId			m_default_vertex_shader;
+	ResourceId			m_default_pixel_shader;
+	GPUProgramId		m_default_gpu_program;
 
 	friend class		TextureResource;
 };