all repos — mgba @ 1768721e7e2669373f5472ab56690cc9b0904097

mGBA Game Boy Advance Emulator

src/platform/opengl/gles2.c (view raw)

  1/* Copyright (c) 2013-2015 Jeffrey Pfau
  2 *
  3 * This Source Code Form is subject to the terms of the Mozilla Public
  4 * License, v. 2.0. If a copy of the MPL was not distributed with this
  5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
  6#include "gles2.h"
  7
  8#include "gba/video.h"
  9#include "util/configuration.h"
 10#include "util/formatting.h"
 11#include "util/vector.h"
 12#include "util/vfs.h"
 13
 14#define MAX_PASSES 8
 15
 16static const GLchar* const _gles2Header =
 17	"#version 100\n"
 18	"precision mediump float;\n";
 19
 20static const GLchar* const _gl3Header =
 21	"#version 120\n";
 22
 23static const char* const _vertexShader =
 24	"attribute vec4 position;\n"
 25	"varying vec2 texCoord;\n"
 26
 27	"void main() {\n"
 28	"	gl_Position = position;\n"
 29	"	texCoord = (position.st + vec2(1.0, -1.0)) * vec2(0.5, -0.5);\n"
 30	"}";
 31
 32static const char* const _nullVertexShader =
 33	"attribute vec4 position;\n"
 34	"varying vec2 texCoord;\n"
 35
 36	"void main() {\n"
 37	"	gl_Position = position;\n"
 38	"	texCoord = (position.st + vec2(1.0, 1.0)) * vec2(0.5, 0.5);\n"
 39	"}";
 40
 41static const char* const _fragmentShader =
 42	"varying vec2 texCoord;\n"
 43	"uniform sampler2D tex;\n"
 44	"uniform float gamma;\n"
 45	"uniform vec3 desaturation;\n"
 46	"uniform vec3 scale;\n"
 47	"uniform vec3 bias;\n"
 48
 49	"void main() {\n"
 50	"	vec4 color = texture2D(tex, texCoord);\n"
 51	"	color.a = 1.;\n"
 52	"	float average = dot(color.rgb, vec3(1.)) / 3.;\n"
 53	"	color.rgb = mix(color.rgb, vec3(average), desaturation);\n"
 54	"	color.rgb = scale * pow(color.rgb, vec3(gamma, gamma, gamma)) + bias;\n"
 55	"	gl_FragColor = color;\n"
 56	"}";
 57
 58static const char* const _nullFragmentShader =
 59	"varying vec2 texCoord;\n"
 60	"uniform sampler2D tex;\n"
 61
 62	"void main() {\n"
 63	"	vec4 color = texture2D(tex, texCoord);\n"
 64	"	color.a = 1.;\n"
 65	"	gl_FragColor = color;\n"
 66	"}";
 67
 68static const GLfloat _vertices[] = {
 69	-1.f, -1.f,
 70	-1.f, 1.f,
 71	1.f, 1.f,
 72	1.f, -1.f,
 73};
 74
 75static void GBAGLES2ContextInit(struct VideoBackend* v, WHandle handle) {
 76	UNUSED(handle);
 77	struct GBAGLES2Context* context = (struct GBAGLES2Context*) v;
 78	glGenTextures(1, &context->tex);
 79	glBindTexture(GL_TEXTURE_2D, context->tex);
 80	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 81	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 82
 83#ifdef COLOR_16_BIT
 84#ifdef COLOR_5_6_5
 85	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, VIDEO_HORIZONTAL_PIXELS, VIDEO_VERTICAL_PIXELS, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 0);
 86#else
 87	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, VIDEO_HORIZONTAL_PIXELS, VIDEO_VERTICAL_PIXELS, 0, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, 0);
 88#endif
 89#else
 90	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, VIDEO_HORIZONTAL_PIXELS, VIDEO_VERTICAL_PIXELS, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
 91#endif
 92
 93	glClearColor(0.f, 0.f, 0.f, 1.f);
 94
 95	struct GBAGLES2Uniform* uniforms = malloc(sizeof(struct GBAGLES2Uniform) * 4);
 96	uniforms[0].name = "gamma";
 97	uniforms[0].readableName = "Gamma";
 98	uniforms[0].type = GL_FLOAT;
 99	uniforms[0].value.f = 1.0f;
100	uniforms[0].min.f = 0.1f;
101	uniforms[0].max.f = 3.0f;
102	uniforms[1].name = "scale";
103	uniforms[1].readableName = "Scale";
104	uniforms[1].type = GL_FLOAT_VEC3;
105	uniforms[1].value.fvec3[0] = 1.0f;
106	uniforms[1].value.fvec3[1] = 1.0f;
107	uniforms[1].value.fvec3[2] = 1.0f;
108	uniforms[1].min.fvec3[0] = -1.0f;
109	uniforms[1].min.fvec3[1] = -1.0f;
110	uniforms[1].min.fvec3[2] = -1.0f;
111	uniforms[1].max.fvec3[0] = 2.0f;
112	uniforms[1].max.fvec3[1] = 2.0f;
113	uniforms[1].max.fvec3[2] = 2.0f;
114	uniforms[2].name = "bias";
115	uniforms[2].readableName = "Bias";
116	uniforms[2].type = GL_FLOAT_VEC3;
117	uniforms[2].value.fvec3[0] = 0.0f;
118	uniforms[2].value.fvec3[1] = 0.0f;
119	uniforms[2].value.fvec3[2] = 0.0f;
120	uniforms[2].min.fvec3[0] = -1.0f;
121	uniforms[2].min.fvec3[1] = -1.0f;
122	uniforms[2].min.fvec3[2] = -1.0f;
123	uniforms[2].max.fvec3[0] = 1.0f;
124	uniforms[2].max.fvec3[1] = 1.0f;
125	uniforms[2].max.fvec3[2] = 1.0f;
126	uniforms[3].name = "desaturation";
127	uniforms[3].readableName = "Desaturation";
128	uniforms[3].type = GL_FLOAT_VEC3;
129	uniforms[3].value.fvec3[0] = 0.0f;
130	uniforms[3].value.fvec3[1] = 0.0f;
131	uniforms[3].value.fvec3[2] = 0.0f;
132	uniforms[3].min.fvec3[0] = 0.0f;
133	uniforms[3].min.fvec3[1] = 0.0f;
134	uniforms[3].min.fvec3[2] = 0.0f;
135	uniforms[3].max.fvec3[0] = 1.0f;
136	uniforms[3].max.fvec3[1] = 1.0f;
137	uniforms[3].max.fvec3[2] = 1.0f;
138	GBAGLES2ShaderInit(&context->initialShader, _vertexShader, _fragmentShader, -1, -1, false, uniforms, 4);
139	GBAGLES2ShaderInit(&context->finalShader, 0, 0, 0, 0, false, 0, 0);
140	glDeleteFramebuffers(1, &context->finalShader.fbo);
141	context->finalShader.fbo = 0;
142}
143
144static void GBAGLES2ContextDeinit(struct VideoBackend* v) {
145	struct GBAGLES2Context* context = (struct GBAGLES2Context*) v;
146	glDeleteTextures(1, &context->tex);
147	GBAGLES2ShaderDeinit(&context->initialShader);
148	GBAGLES2ShaderDeinit(&context->finalShader);
149	free(context->initialShader.uniforms);
150}
151
152static void GBAGLES2ContextResized(struct VideoBackend* v, int w, int h) {
153	int drawW = w;
154	int drawH = h;
155	if (v->lockAspectRatio) {
156		if (w * 2 > h * 3) {
157			drawW = h * 3 / 2;
158		} else if (w * 2 < h * 3) {
159			drawH = w * 2 / 3;
160		}
161	}
162	glViewport(0, 0, VIDEO_HORIZONTAL_PIXELS, VIDEO_VERTICAL_PIXELS);
163	glClearColor(0.f, 0.f, 0.f, 1.f);
164	glClear(GL_COLOR_BUFFER_BIT);
165	glViewport((w - drawW) / 2, (h - drawH) / 2, drawW, drawH);
166}
167
168static void GBAGLES2ContextClear(struct VideoBackend* v) {
169	UNUSED(v);
170	glClearColor(0.f, 0.f, 0.f, 1.f);
171	glClear(GL_COLOR_BUFFER_BIT);
172}
173
174void _drawShader(struct GBAGLES2Shader* shader) {
175	GLint viewport[4];
176	glBindFramebuffer(GL_FRAMEBUFFER, shader->fbo);
177	if (shader->blend) {
178		glEnable(GL_BLEND);
179		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
180	} else {
181		glDisable(GL_BLEND);
182		glClear(GL_COLOR_BUFFER_BIT);
183	}
184
185	glGetIntegerv(GL_VIEWPORT, viewport);
186	int drawW = shader->width;
187	int drawH = shader->height;
188	int padW = 0;
189	int padH = 0;
190	if (!shader->width) {
191		drawW = viewport[2];
192		padW = viewport[0];
193	}
194	if (!shader->height) {
195		drawH = viewport[3];
196		padH = viewport[1];
197	}
198	if (shader->integerScaling) {
199		padW = 0;
200		padH = 0;
201		drawW -= drawW % VIDEO_HORIZONTAL_PIXELS;
202		drawH -= drawH % VIDEO_VERTICAL_PIXELS;
203	}
204	glViewport(padW, padH, drawW, drawH);
205	if (!shader->width || !shader->height) {
206		GLint oldTex;
207		glGetIntegerv(GL_TEXTURE_BINDING_2D, &oldTex);
208		glBindTexture(GL_TEXTURE_2D, shader->tex);
209		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, drawW, drawH, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
210		glBindTexture(GL_TEXTURE_2D, oldTex);
211	}
212
213	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
214	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, shader->filter ? GL_LINEAR : GL_NEAREST);
215	glUseProgram(shader->program);
216	glUniform1i(shader->texLocation, 0);
217	glVertexAttribPointer(shader->positionLocation, 2, GL_FLOAT, GL_FALSE, 0, _vertices);
218	glEnableVertexAttribArray(shader->positionLocation);
219	size_t u;
220	for (u = 0; u < shader->nUniforms; ++u) {
221		struct GBAGLES2Uniform* uniform = &shader->uniforms[u];
222		switch (uniform->type) {
223		case GL_FLOAT:
224			glUniform1f(uniform->location, uniform->value.f);
225			break;
226		case GL_INT:
227			glUniform1i(uniform->location, uniform->value.i);
228			break;
229		case GL_BOOL:
230			glUniform1i(uniform->location, uniform->value.b);
231			break;
232		case GL_FLOAT_VEC2:
233			glUniform2fv(uniform->location, 1, uniform->value.fvec2);
234			break;
235		case GL_FLOAT_VEC3:
236			glUniform3fv(uniform->location, 1, uniform->value.fvec3);
237			break;
238		case GL_FLOAT_VEC4:
239			glUniform4fv(uniform->location, 1, uniform->value.fvec4);
240			break;
241		case GL_INT_VEC2:
242			glUniform2iv(uniform->location, 1, uniform->value.ivec2);
243			break;
244		case GL_INT_VEC3:
245			glUniform3iv(uniform->location, 1, uniform->value.ivec3);
246			break;
247		case GL_INT_VEC4:
248			glUniform4iv(uniform->location, 1, uniform->value.ivec4);
249			break;
250		case GL_BOOL_VEC2:
251			glUniform2i(uniform->location, uniform->value.bvec2[0], uniform->value.bvec2[1]);
252			break;
253		case GL_BOOL_VEC3:
254			glUniform3i(uniform->location, uniform->value.bvec3[0], uniform->value.bvec3[1], uniform->value.bvec3[2]);
255			break;
256		case GL_BOOL_VEC4:
257			glUniform4i(uniform->location, uniform->value.bvec4[0], uniform->value.bvec4[1], uniform->value.bvec4[2], uniform->value.bvec4[3]);
258			break;
259		case GL_FLOAT_MAT2:
260			glUniformMatrix2fv(uniform->location, 1, GL_FALSE, uniform->value.fmat2x2);
261			break;
262		case GL_FLOAT_MAT3:
263			glUniformMatrix3fv(uniform->location, 1, GL_FALSE, uniform->value.fmat3x3);
264			break;
265		case GL_FLOAT_MAT4:
266			glUniformMatrix4fv(uniform->location, 1, GL_FALSE, uniform->value.fmat4x4);
267			break;
268		}
269	}
270	glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
271	glBindTexture(GL_TEXTURE_2D, shader->tex);
272	glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
273}
274
275void GBAGLES2ContextDrawFrame(struct VideoBackend* v) {
276	struct GBAGLES2Context* context = (struct GBAGLES2Context*) v;
277	glActiveTexture(GL_TEXTURE0);
278	glBindTexture(GL_TEXTURE_2D, context->tex);
279
280	context->finalShader.filter = v->filter;
281	_drawShader(&context->initialShader);
282	size_t n;
283	for (n = 0; n < context->nShaders; ++n) {
284		_drawShader(&context->shaders[n]);
285	}
286	_drawShader(&context->finalShader);
287	glBindFramebuffer(GL_FRAMEBUFFER, 0);
288	glUseProgram(0);
289}
290
291void GBAGLES2ContextPostFrame(struct VideoBackend* v, const void* frame) {
292	struct GBAGLES2Context* context = (struct GBAGLES2Context*) v;
293	glBindTexture(GL_TEXTURE_2D, context->tex);
294#ifdef COLOR_16_BIT
295#ifdef COLOR_5_6_5
296	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, VIDEO_HORIZONTAL_PIXELS, VIDEO_VERTICAL_PIXELS, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, frame);
297#else
298	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, VIDEO_HORIZONTAL_PIXELS, VIDEO_VERTICAL_PIXELS, 0, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, frame);
299#endif
300#else
301	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, VIDEO_HORIZONTAL_PIXELS, VIDEO_VERTICAL_PIXELS, 0, GL_RGBA, GL_UNSIGNED_BYTE, frame);
302#endif
303}
304
305void GBAGLES2ContextCreate(struct GBAGLES2Context* context) {
306	context->d.init = GBAGLES2ContextInit;
307	context->d.deinit = GBAGLES2ContextDeinit;
308	context->d.resized = GBAGLES2ContextResized;
309	context->d.swap = 0;
310	context->d.clear = GBAGLES2ContextClear;
311	context->d.postFrame = GBAGLES2ContextPostFrame;
312	context->d.drawFrame = GBAGLES2ContextDrawFrame;
313	context->d.setMessage = 0;
314	context->d.clearMessage = 0;
315	context->shaders = 0;
316	context->nShaders = 0;
317}
318
319void GBAGLES2ShaderInit(struct GBAGLES2Shader* shader, const char* vs, const char* fs, int width, int height, bool integerScaling, struct GBAGLES2Uniform* uniforms, size_t nUniforms) {
320	shader->width = width >= 0 ? width : VIDEO_HORIZONTAL_PIXELS;
321	shader->height = height >= 0 ? height : VIDEO_VERTICAL_PIXELS;
322	shader->integerScaling = integerScaling;
323	shader->filter = false;
324	shader->blend = false;
325	shader->uniforms = uniforms;
326	shader->nUniforms = nUniforms;
327	glGenFramebuffers(1, &shader->fbo);
328	glBindFramebuffer(GL_FRAMEBUFFER, shader->fbo);
329
330	glGenTextures(1, &shader->tex);
331	glBindTexture(GL_TEXTURE_2D, shader->tex);
332	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
333	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
334	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
335	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
336	if (shader->width && shader->height) {
337		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, shader->width, shader->height, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
338	}
339
340	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, shader->tex, 0);
341	shader->program = glCreateProgram();
342	shader->vertexShader = glCreateShader(GL_VERTEX_SHADER);
343	shader->fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
344	const GLchar* shaderBuffer[2];
345	const GLubyte* version = glGetString(GL_VERSION);
346	if (strncmp((const char*) version, "OpenGL ES ", strlen("OpenGL ES "))) {
347		shaderBuffer[0] = _gl3Header;
348	} else {
349		shaderBuffer[0] = _gles2Header;
350	}
351	if (vs) {
352		shaderBuffer[1] = vs;
353	} else {
354		shaderBuffer[1] = _nullVertexShader;
355	}
356	glShaderSource(shader->vertexShader, 2, shaderBuffer, 0);
357
358	if (fs) {
359		shaderBuffer[1] = fs;
360	} else {
361		shaderBuffer[1] = _nullFragmentShader;
362	}
363	glShaderSource(shader->fragmentShader, 2, shaderBuffer, 0);
364
365	glAttachShader(shader->program, shader->vertexShader);
366	glAttachShader(shader->program, shader->fragmentShader);
367	char log[1024];
368	glCompileShader(shader->fragmentShader);
369	glGetShaderInfoLog(shader->fragmentShader, 1024, 0, log);
370	if (log[0]) {
371		printf("%s\n", log);
372	}
373	glCompileShader(shader->vertexShader);
374	glGetShaderInfoLog(shader->vertexShader, 1024, 0, log);
375	if (log[0]) {
376		printf("%s\n", log);
377	}
378	glLinkProgram(shader->program);
379	glGetProgramInfoLog(shader->program, 1024, 0, log);
380	if (log[0]) {
381		printf("%s\n", log);
382	}
383
384	shader->texLocation = glGetUniformLocation(shader->program, "tex");
385	shader->positionLocation = glGetAttribLocation(shader->program, "position");
386	size_t i;
387	for (i = 0; i < shader->nUniforms; ++i) {
388		shader->uniforms[i].location = glGetUniformLocation(shader->program, shader->uniforms[i].name);
389	}
390	glBindFramebuffer(GL_FRAMEBUFFER, 0);
391}
392
393void GBAGLES2ShaderDeinit(struct GBAGLES2Shader* shader) {
394	glDeleteTextures(1, &shader->tex);
395	glDeleteShader(shader->fragmentShader);
396	glDeleteProgram(shader->program);
397	glDeleteFramebuffers(1, &shader->fbo);
398}
399
400void GBAGLES2ShaderAttach(struct GBAGLES2Context* context, struct GBAGLES2Shader* shaders, size_t nShaders) {
401	if (context->shaders) {
402		if (context->shaders == shaders && context->nShaders == nShaders) {
403			return;
404		}
405		GBAGLES2ShaderDetach(context);
406	}
407	context->shaders = shaders;
408	context->nShaders = nShaders;
409	size_t i;
410	for (i = 0; i < nShaders; ++i) {
411		glBindFramebuffer(GL_FRAMEBUFFER, context->shaders[i].fbo);
412		glClear(GL_COLOR_BUFFER_BIT);
413	}
414	glBindFramebuffer(GL_FRAMEBUFFER, 0);
415}
416
417void GBAGLES2ShaderDetach(struct GBAGLES2Context* context) {
418	if (!context->shaders) {
419		return;
420	}
421	context->shaders = 0;
422	context->nShaders = 0;
423}
424
425static bool _lookupIntValue(const struct Configuration* config, const char* section, const char* key, int* out) {
426	const char* charValue = ConfigurationGetValue(config, section, key);
427	if (!charValue) {
428		return false;
429	}
430	char* end;
431	unsigned long value = strtol(charValue, &end, 10);
432	if (*end) {
433		return false;
434	}
435	*out = value;
436	return true;
437}
438
439static bool _lookupFloatValue(const struct Configuration* config, const char* section, const char* key, float* out) {
440	const char* charValue = ConfigurationGetValue(config, section, key);
441	if (!charValue) {
442		return false;
443	}
444	char* end;
445	float value = strtof_u(charValue, &end);
446	if (*end) {
447		return false;
448	}
449	*out = value;
450	return true;
451}
452
453static bool _lookupBoolValue(const struct Configuration* config, const char* section, const char* key, GLboolean* out) {
454	const char* charValue = ConfigurationGetValue(config, section, key);
455	if (!charValue) {
456		return false;
457	}
458	if (!strcmp(charValue, "true")) {
459		*out = GL_TRUE;
460		return true;
461	}
462	if (!strcmp(charValue, "false")) {
463		*out = GL_FALSE;
464		return true;
465	}
466	char* end;
467	unsigned long value = strtol(charValue, &end, 10);
468	if (*end) {
469		return false;
470	}
471	*out = value;
472	return true;
473}
474
475DECLARE_VECTOR(GBAGLES2UniformList, struct GBAGLES2Uniform);
476DEFINE_VECTOR(GBAGLES2UniformList, struct GBAGLES2Uniform);
477
478static void _uniformHandler(const char* sectionName, void* user) {
479	struct GBAGLES2UniformList* uniforms = user;
480	unsigned passId;
481	int sentinel;
482	if (sscanf(sectionName, "pass.%u.uniform.%n", &passId, &sentinel) < 1) {
483		return;
484	}
485	struct GBAGLES2Uniform* u = GBAGLES2UniformListAppend(uniforms);
486	u->name = sectionName;
487}
488
489
490static void _loadValue(struct Configuration* description, const char* name, GLenum type, const char* field, union GBAGLES2UniformValue* value) {
491	char fieldName[16];
492	switch (type) {
493	case GL_FLOAT:
494		value->f = 0;
495		_lookupFloatValue(description, name, field, &value->f);
496		break;
497	case GL_FLOAT_VEC2:
498		value->fvec2[0] = 0;
499		value->fvec2[1] = 0;
500		snprintf(fieldName, sizeof(fieldName), "%s[0]", field);
501		_lookupFloatValue(description, name, fieldName, &value->fvec2[0]);
502		snprintf(fieldName, sizeof(fieldName), "%s[1]", field);
503		_lookupFloatValue(description, name, fieldName, &value->fvec2[1]);
504		break;
505	case GL_FLOAT_VEC3:
506		value->fvec3[0] = 0;
507		value->fvec3[1] = 0;
508		value->fvec3[2] = 0;
509		snprintf(fieldName, sizeof(fieldName), "%s[0]", field);
510		_lookupFloatValue(description, name, fieldName, &value->fvec3[0]);
511		snprintf(fieldName, sizeof(fieldName), "%s[1]", field);
512		_lookupFloatValue(description, name, fieldName, &value->fvec3[1]);
513		snprintf(fieldName, sizeof(fieldName), "%s[2]", field);
514		_lookupFloatValue(description, name, fieldName, &value->fvec3[2]);
515		break;
516	case GL_FLOAT_VEC4:
517		value->fvec4[0] = 0;
518		value->fvec4[1] = 0;
519		value->fvec4[2] = 0;
520		value->fvec4[3] = 0;
521		snprintf(fieldName, sizeof(fieldName), "%s[0]", field);
522		_lookupFloatValue(description, name, fieldName, &value->fvec4[0]);
523		snprintf(fieldName, sizeof(fieldName), "%s[1]", field);
524		_lookupFloatValue(description, name, fieldName, &value->fvec4[1]);
525		snprintf(fieldName, sizeof(fieldName), "%s[2]", field);
526		_lookupFloatValue(description, name, fieldName, &value->fvec4[2]);
527		snprintf(fieldName, sizeof(fieldName), "%s[3]", field);
528		_lookupFloatValue(description, name, fieldName, &value->fvec4[3]);
529		break;
530	case GL_FLOAT_MAT2:
531		value->fmat2x2[0] = 0;
532		value->fmat2x2[1] = 0;
533		value->fmat2x2[2] = 0;
534		value->fmat2x2[3] = 0;
535		snprintf(fieldName, sizeof(fieldName), "%s[0,0]", field);
536		_lookupFloatValue(description, name, fieldName, &value->fmat2x2[0]);
537		snprintf(fieldName, sizeof(fieldName), "%s[0,1]", field);
538		_lookupFloatValue(description, name, fieldName, &value->fmat2x2[1]);
539		snprintf(fieldName, sizeof(fieldName), "%s[1,0]", field);
540		_lookupFloatValue(description, name, fieldName, &value->fmat2x2[2]);
541		snprintf(fieldName, sizeof(fieldName), "%s[1,1]", field);
542		_lookupFloatValue(description, name, fieldName, &value->fmat2x2[3]);
543		break;
544	case GL_FLOAT_MAT3:
545		value->fmat3x3[0] = 0;
546		value->fmat3x3[1] = 0;
547		value->fmat3x3[2] = 0;
548		value->fmat3x3[3] = 0;
549		value->fmat3x3[4] = 0;
550		value->fmat3x3[5] = 0;
551		value->fmat3x3[6] = 0;
552		value->fmat3x3[7] = 0;
553		value->fmat3x3[8] = 0;
554		snprintf(fieldName, sizeof(fieldName), "%s[0,0]", field);
555		_lookupFloatValue(description, name, fieldName, &value->fmat3x3[0]);
556		snprintf(fieldName, sizeof(fieldName), "%s[0,1]", field);
557		_lookupFloatValue(description, name, fieldName, &value->fmat3x3[1]);
558		snprintf(fieldName, sizeof(fieldName), "%s[0,2]", field);
559		_lookupFloatValue(description, name, fieldName, &value->fmat3x3[2]);
560		snprintf(fieldName, sizeof(fieldName), "%s[1,0]", field);
561		_lookupFloatValue(description, name, fieldName, &value->fmat3x3[3]);
562		snprintf(fieldName, sizeof(fieldName), "%s[1,1]", field);
563		_lookupFloatValue(description, name, fieldName, &value->fmat3x3[4]);
564		snprintf(fieldName, sizeof(fieldName), "%s[1,2]", field);
565		_lookupFloatValue(description, name, fieldName, &value->fmat3x3[5]);
566		snprintf(fieldName, sizeof(fieldName), "%s[2,0]", field);
567		_lookupFloatValue(description, name, fieldName, &value->fmat3x3[6]);
568		snprintf(fieldName, sizeof(fieldName), "%s[2,1]", field);
569		_lookupFloatValue(description, name, fieldName, &value->fmat3x3[7]);
570		snprintf(fieldName, sizeof(fieldName), "%s[2,2]", field);
571		_lookupFloatValue(description, name, fieldName, &value->fmat3x3[8]);
572		break;
573	case GL_FLOAT_MAT4:
574		value->fmat4x4[0] = 0;
575		value->fmat4x4[1] = 0;
576		value->fmat4x4[2] = 0;
577		value->fmat4x4[3] = 0;
578		value->fmat4x4[4] = 0;
579		value->fmat4x4[5] = 0;
580		value->fmat4x4[6] = 0;
581		value->fmat4x4[7] = 0;
582		value->fmat4x4[8] = 0;
583		value->fmat4x4[9] = 0;
584		value->fmat4x4[10] = 0;
585		value->fmat4x4[11] = 0;
586		value->fmat4x4[12] = 0;
587		value->fmat4x4[13] = 0;
588		value->fmat4x4[14] = 0;
589		value->fmat4x4[15] = 0;
590		snprintf(fieldName, sizeof(fieldName), "%s[0,0]", field);
591		_lookupFloatValue(description, name, fieldName, &value->fmat4x4[0]);
592		snprintf(fieldName, sizeof(fieldName), "%s[0,1]", field);
593		_lookupFloatValue(description, name, fieldName, &value->fmat4x4[1]);
594		snprintf(fieldName, sizeof(fieldName), "%s[0,2]", field);
595		_lookupFloatValue(description, name, fieldName, &value->fmat4x4[2]);
596		snprintf(fieldName, sizeof(fieldName), "%s[0,3]", field);
597		_lookupFloatValue(description, name, fieldName, &value->fmat4x4[3]);
598		snprintf(fieldName, sizeof(fieldName), "%s[1,0]", field);
599		_lookupFloatValue(description, name, fieldName, &value->fmat4x4[4]);
600		snprintf(fieldName, sizeof(fieldName), "%s[1,1]", field);
601		_lookupFloatValue(description, name, fieldName, &value->fmat4x4[5]);
602		snprintf(fieldName, sizeof(fieldName), "%s[1,2]", field);
603		_lookupFloatValue(description, name, fieldName, &value->fmat4x4[6]);
604		snprintf(fieldName, sizeof(fieldName), "%s[1,3]", field);
605		_lookupFloatValue(description, name, fieldName, &value->fmat4x4[7]);
606		snprintf(fieldName, sizeof(fieldName), "%s[2,0]", field);
607		_lookupFloatValue(description, name, fieldName, &value->fmat4x4[8]);
608		snprintf(fieldName, sizeof(fieldName), "%s[2,1]", field);
609		_lookupFloatValue(description, name, fieldName, &value->fmat4x4[9]);
610		snprintf(fieldName, sizeof(fieldName), "%s[2,2]", field);
611		_lookupFloatValue(description, name, fieldName, &value->fmat4x4[10]);
612		snprintf(fieldName, sizeof(fieldName), "%s[2,3]", field);
613		_lookupFloatValue(description, name, fieldName, &value->fmat4x4[11]);
614		snprintf(fieldName, sizeof(fieldName), "%s[3,0]", field);
615		_lookupFloatValue(description, name, fieldName, &value->fmat4x4[12]);
616		snprintf(fieldName, sizeof(fieldName), "%s[3,1]", field);
617		_lookupFloatValue(description, name, fieldName, &value->fmat4x4[13]);
618		snprintf(fieldName, sizeof(fieldName), "%s[3,2]", field);
619		_lookupFloatValue(description, name, fieldName, &value->fmat4x4[14]);
620		snprintf(fieldName, sizeof(fieldName), "%s[3,3]", field);
621		_lookupFloatValue(description, name, fieldName, &value->fmat4x4[15]);
622		break;
623	case GL_INT:
624		value->i = 0;
625		_lookupIntValue(description, name, field, &value->i);
626		break;
627	case GL_INT_VEC2:
628		value->ivec2[0] = 0;
629		value->ivec2[1] = 0;
630		snprintf(fieldName, sizeof(fieldName), "%s[0]", field);
631		_lookupIntValue(description, name, fieldName, &value->ivec2[0]);
632		snprintf(fieldName, sizeof(fieldName), "%s[1]", field);
633		_lookupIntValue(description, name, fieldName, &value->ivec2[1]);
634		break;
635	case GL_INT_VEC3:
636		value->ivec3[0] = 0;
637		value->ivec3[1] = 0;
638		value->ivec3[2] = 0;
639		snprintf(fieldName, sizeof(fieldName), "%s[0]", field);
640		_lookupIntValue(description, name, fieldName, &value->ivec3[0]);
641		snprintf(fieldName, sizeof(fieldName), "%s[1]", field);
642		_lookupIntValue(description, name, fieldName, &value->ivec3[1]);
643		snprintf(fieldName, sizeof(fieldName), "%s[2]", field);
644		_lookupIntValue(description, name, fieldName, &value->ivec3[2]);
645		break;
646	case GL_INT_VEC4:
647		value->ivec4[0] = 0;
648		value->ivec4[1] = 0;
649		value->ivec4[2] = 0;
650		value->ivec4[3] = 0;
651		snprintf(fieldName, sizeof(fieldName), "%s[0]", field);
652		_lookupIntValue(description, name, fieldName, &value->ivec4[0]);
653		snprintf(fieldName, sizeof(fieldName), "%s[1]", field);
654		_lookupIntValue(description, name, fieldName, &value->ivec4[1]);
655		snprintf(fieldName, sizeof(fieldName), "%s[2]", field);
656		_lookupIntValue(description, name, fieldName, &value->ivec4[2]);
657		snprintf(fieldName, sizeof(fieldName), "%s[3]", field);
658		_lookupIntValue(description, name, fieldName, &value->ivec4[3]);
659		break;
660	case GL_BOOL:
661		value->b = 0;
662		_lookupBoolValue(description, name, field, &value->b);
663		break;
664	case GL_BOOL_VEC2:
665		value->bvec2[0] = 0;
666		value->bvec2[1] = 0;
667		snprintf(fieldName, sizeof(fieldName), "%s[0]", field);
668		_lookupBoolValue(description, name, fieldName, &value->bvec2[0]);
669		snprintf(fieldName, sizeof(fieldName), "%s[1]", field);
670		_lookupBoolValue(description, name, fieldName, &value->bvec2[1]);
671		break;
672	case GL_BOOL_VEC3:
673		value->bvec3[0] = 0;
674		value->bvec3[1] = 0;
675		value->bvec3[2] = 0;
676		snprintf(fieldName, sizeof(fieldName), "%s[0]", field);
677		_lookupBoolValue(description, name, fieldName, &value->bvec3[0]);
678		snprintf(fieldName, sizeof(fieldName), "%s[1]", field);
679		_lookupBoolValue(description, name, fieldName, &value->bvec3[1]);
680		snprintf(fieldName, sizeof(fieldName), "%s[2]", field);
681		_lookupBoolValue(description, name, fieldName, &value->bvec3[2]);
682		break;
683	case GL_BOOL_VEC4:
684		value->bvec4[0] = 0;
685		value->bvec4[1] = 0;
686		value->bvec4[2] = 0;
687		value->bvec4[3] = 0;
688		snprintf(fieldName, sizeof(fieldName), "%s[0]", field);
689		_lookupBoolValue(description, name, fieldName, &value->bvec4[0]);
690		snprintf(fieldName, sizeof(fieldName), "%s[1]", field);
691		_lookupBoolValue(description, name, fieldName, &value->bvec4[1]);
692		snprintf(fieldName, sizeof(fieldName), "%s[2]", field);
693		_lookupBoolValue(description, name, fieldName, &value->bvec4[2]);
694		snprintf(fieldName, sizeof(fieldName), "%s[3]", field);
695		_lookupBoolValue(description, name, fieldName, &value->bvec4[3]);
696		break;
697	}
698}
699
700static bool _loadUniform(struct Configuration* description, size_t pass, struct GBAGLES2Uniform* uniform) {
701	unsigned passId;
702	if (sscanf(uniform->name, "pass.%u.uniform.", &passId) < 1 || passId != pass) {
703		return false;
704	}
705	const char* type = ConfigurationGetValue(description, uniform->name, "type");
706	if (!type) {
707		return false;
708	}
709	if (!strcmp(type, "float")) {
710		uniform->type = GL_FLOAT;
711	} else if (!strcmp(type, "float2")) {
712		uniform->type = GL_FLOAT_VEC2;
713	} else if (!strcmp(type, "float3")) {
714		uniform->type = GL_FLOAT_VEC3;
715	} else if (!strcmp(type, "float4")) {
716		uniform->type = GL_FLOAT_VEC4;
717	} else if (!strcmp(type, "float2x2")) {
718		uniform->type = GL_FLOAT_MAT2;
719	} else if (!strcmp(type, "float3x3")) {
720		uniform->type = GL_FLOAT_MAT3;
721	} else if (!strcmp(type, "float4x4")) {
722		uniform->type = GL_FLOAT_MAT4;
723	} else if (!strcmp(type, "int")) {
724		uniform->type = GL_INT;
725	} else if (!strcmp(type, "int2")) {
726		uniform->type = GL_INT_VEC2;
727	} else if (!strcmp(type, "int3")) {
728		uniform->type = GL_INT_VEC3;
729	} else if (!strcmp(type, "int4")) {
730		uniform->type = GL_INT_VEC4;
731	} else if (!strcmp(type, "bool")) {
732		uniform->type = GL_BOOL;
733	} else if (!strcmp(type, "int2")) {
734		uniform->type = GL_BOOL_VEC2;
735	} else if (!strcmp(type, "int3")) {
736		uniform->type = GL_BOOL_VEC3;
737	} else if (!strcmp(type, "int4")) {
738		uniform->type = GL_BOOL_VEC4;
739	} else {
740		return false;
741	}
742	_loadValue(description, uniform->name, uniform->type, "default", &uniform->value);
743	_loadValue(description, uniform->name, uniform->type, "min", &uniform->min);
744	_loadValue(description, uniform->name, uniform->type, "max", &uniform->max);
745	const char* readable = ConfigurationGetValue(description, uniform->name, "readableName");
746	if (readable) {
747		uniform->readableName = strdup(readable);
748	} else {
749		uniform->readableName = 0;
750	}
751	uniform->name = strdup(strstr(uniform->name, "uniform.") + strlen("uniform."));
752	return true;
753}
754
755bool GBAGLES2ShaderLoad(struct VideoShader* shader, struct VDir* dir) {
756	struct VFile* manifest = dir->openFile(dir, "manifest.ini", O_RDONLY);
757	if (!manifest) {
758		return false;
759	}
760	bool success = false;
761	struct Configuration description;
762	ConfigurationInit(&description);
763	if (ConfigurationReadVFile(&description, manifest)) {
764		int inShaders;
765		success = _lookupIntValue(&description, "shader", "passes", &inShaders);
766		if (inShaders > MAX_PASSES || inShaders < 1) {
767			success = false;
768		}
769		if (success) {
770			struct GBAGLES2Shader* shaderBlock = malloc(sizeof(struct GBAGLES2Shader) * inShaders);
771			int n;
772			for (n = 0; n < inShaders; ++n) {
773				char passName[12];
774				snprintf(passName, sizeof(passName), "pass.%u", n);
775				const char* fs = ConfigurationGetValue(&description, passName, "fragmentShader");
776				const char* vs = ConfigurationGetValue(&description, passName, "vertexShader");
777				if (fs && (fs[0] == '.' || strstr(fs, PATH_SEP))) {
778					success = false;
779					break;
780				}
781				if (vs && (vs[0] == '.' || strstr(vs, PATH_SEP))) {
782					success = false;
783					break;
784				}
785				char* fssrc = 0;
786				char* vssrc = 0;
787				if (fs) {
788					struct VFile* fsf = dir->openFile(dir, fs, O_RDONLY);
789					if (!fsf) {
790						success = false;
791						break;
792					}
793					fssrc = malloc(fsf->size(fsf) + 1);
794					fssrc[fsf->size(fsf)] = '\0';
795					fsf->read(fsf, fssrc, fsf->size(fsf));
796					fsf->close(fsf);
797				}
798				if (vs) {
799					struct VFile* vsf = dir->openFile(dir, vs, O_RDONLY);
800					if (!vsf) {
801						success = false;
802						free(fssrc);
803						break;
804					}
805					vssrc = malloc(vsf->size(vsf) + 1);
806					vssrc[vsf->size(vsf)] = '\0';
807					vsf->read(vsf, vssrc, vsf->size(vsf));
808					vsf->close(vsf);
809				}
810				int width = 0;
811				int height = 0;
812				int scaling = 0;
813				_lookupIntValue(&description, passName, "width", &width);
814				_lookupIntValue(&description, passName, "height", &height);
815				_lookupIntValue(&description, passName, "integerScaling", &scaling);
816
817				struct GBAGLES2UniformList uniformVector;
818				GBAGLES2UniformListInit(&uniformVector, 0);
819				ConfigurationEnumerateSections(&description, _uniformHandler, &uniformVector);
820				size_t u;
821				for (u = 0; u < GBAGLES2UniformListSize(&uniformVector); ++u) {
822					struct GBAGLES2Uniform* uniform = GBAGLES2UniformListGetPointer(&uniformVector, u);
823					if (!_loadUniform(&description, n, uniform)) {
824						GBAGLES2UniformListShift(&uniformVector, u, 1);
825						--u;
826					}
827				}
828				u = GBAGLES2UniformListSize(&uniformVector);
829				struct GBAGLES2Uniform* uniformBlock = malloc(sizeof(*uniformBlock) * u);
830				memcpy(uniformBlock, GBAGLES2UniformListGetPointer(&uniformVector, 0), sizeof(*uniformBlock) * u);
831				GBAGLES2UniformListDeinit(&uniformVector);
832
833				GBAGLES2ShaderInit(&shaderBlock[n], vssrc, fssrc, width, height, scaling, uniformBlock, u);
834				int b = 0;
835				_lookupIntValue(&description, passName, "blend", &b);
836				if (b) {
837					shaderBlock[n].blend = b;
838				}
839				b = 0;
840				_lookupIntValue(&description, passName, "filter", &b);
841				if (b) {
842					shaderBlock[n].filter = b;
843				}
844				free(fssrc);
845				free(vssrc);
846			}
847			if (success) {
848				shader->nPasses = inShaders;
849				shader->passes = shaderBlock;
850				shader->name = ConfigurationGetValue(&description, "shader", "name");
851				if (shader->name) {
852					shader->name = strdup(shader->name);
853				}
854				shader->author = ConfigurationGetValue(&description, "shader", "author");
855				if (shader->author) {
856					shader->author = strdup(shader->author);
857				}
858				shader->description = ConfigurationGetValue(&description, "shader", "description");
859				if (shader->description) {
860					shader->description = strdup(shader->description);
861				}
862			} else {
863				inShaders = n;
864				for (n = 0; n < inShaders; ++n) {
865					GBAGLES2ShaderDeinit(&shaderBlock[n]);
866				}
867			}
868		}
869	}
870	ConfigurationDeinit(&description);
871	return success;
872}
873
874void GBAGLES2ShaderFree(struct VideoShader* shader) {
875	free((void*) shader->name);
876	free((void*) shader->author);
877	free((void*) shader->description);
878	shader->name = 0;
879	shader->author = 0;
880	shader->description = 0;
881	struct GBAGLES2Shader* shaders = shader->passes;
882	size_t n;
883	for (n = 0; n < shader->nPasses; ++n) {
884		GBAGLES2ShaderDeinit(&shaders[n]);
885		size_t u;
886		for (u = 0; u < shaders[n].nUniforms; ++u) {
887			free((void*) shaders[n].uniforms[u].name);
888			free((void*) shaders[n].uniforms[u].readableName);
889		}
890	}
891	free(shaders);
892	shader->passes = 0;
893	shader->nPasses = 0;
894}