[pcsx_rearmed.git] / deps / libchdr / deps / zstd-1.5.5 / build / single_file_libs / examples / emscripten.c

/**
 * \file emscripten.c
 * Emscripten example of using the single-file \c zstddeclib. Draws a rotating
 * textured quad with data from the in-line Zstd compressed DXT1 texture (DXT1
 * being hardware compression, further compressed with Zstd).
 * \n
 * Compile using:
 * \code
 *	export CC_FLAGS="-Wall -Wextra -Werror -Os -g0 -flto --llvm-lto 3 -lGL -DNDEBUG=1"
 *	export EM_FLAGS="-s WASM=1 -s ENVIRONMENT=web --shell-file shell.html --closure 1"
 *	emcc $CC_FLAGS $EM_FLAGS -o out.html emscripten.c
 * \endcode
 * 
 * \author Carl Woffenden, Numfum GmbH (released under a CC0 license)
 */

#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <emscripten/emscripten.h>
#include <emscripten/html5.h>

#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>

#include "../zstddeclib.c"

//************************* Test Data (DXT texture) **************************/

/**
 * Zstd compressed DXT1 256x256 texture source.
 * \n
 * See \c testcard.png for the original.
 */
static uint8_t const srcZstd[] = {
#include "testcard-zstd.inl"
};

/**
 * Uncompressed size of \c #srcZstd.
 */
#define DXT1_256x256 32768

/**
 * Destination for decoding \c #srcZstd.
 */
static uint8_t dstDxt1[DXT1_256x256] = {};

#ifndef ZSTD_VERSION_MAJOR
/**
 * For the case where the decompression library hasn't been included we add a
 * dummy function to fake the process and stop the buffers being optimised out.
 */
size_t ZSTD_decompress(void* dst, size_t dstLen, const void* src, size_t srcLen) {
	return (memcmp(dst, src, (srcLen < dstLen) ? srcLen : dstLen)) ? dstLen : 0;
}
#endif

//*************************** Program and Shaders ***************************/

/**
 * Program object ID.
 */
static GLuint progId = 0;

/**
 * Vertex shader ID.
 */
static GLuint vertId = 0;

/**
 * Fragment shader ID.
 */
static GLuint fragId = 0;

//********************************* Uniforms *********************************/

/**
 * Quad rotation angle ID.
 */
static GLint uRotId = -1;

/**
 * Draw colour ID.
 */
static GLint uTx0Id = -1;

//******************************* Shader Source ******************************/

/**
 * Vertex shader to draw texture mapped polys with an applied rotation.
 */
static GLchar const vertShader2D[] =
#if GL_ES_VERSION_2_0
	"#version 100\n"
	"precision mediump float;\n"
#else
	"#version 120\n"
#endif
	"uniform   float uRot;"	// rotation
	"attribute vec2  aPos;"	// vertex position coords
	"attribute vec2  aUV0;"	// vertex texture UV0
	"varying   vec2  vUV0;"	// (passed to fragment shader)
	"void main() {"
	"	float cosA = cos(radians(uRot));"
	"	float sinA = sin(radians(uRot));"
	"	mat3 rot = mat3(cosA, -sinA, 0.0,"
	"					sinA,  cosA, 0.0,"
	"					0.0,   0.0,  1.0);"
	"	gl_Position = vec4(rot * vec3(aPos, 1.0), 1.0);"
	"	vUV0 = aUV0;"
	"}";

/**
 * Fragment shader for the above polys.
 */
static GLchar const fragShader2D[] =
#if GL_ES_VERSION_2_0
	"#version 100\n"
	"precision mediump float;\n"
#else
	"#version 120\n"
#endif
	"uniform sampler2D uTx0;"
	"varying vec2      vUV0;" // (passed from fragment shader)
	"void main() {"
	"	gl_FragColor = texture2D(uTx0, vUV0);"
	"}";

/**
 * Helper to compile a shader.
 * 
 * \param type shader type
 * \param text shader source
 * \return the shader ID (or zero if compilation failed)
 */
static GLuint compileShader(GLenum const type, const GLchar* text) {
	GLuint shader = glCreateShader(type);
	if (shader) {
		glShaderSource (shader, 1, &text, NULL);
		glCompileShader(shader);
		GLint compiled;
		glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
		if (compiled) {
			return shader;
		} else {
			GLint logLen;
			glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLen);
			if (logLen > 1) {
				GLchar*  logStr = malloc(logLen);
				glGetShaderInfoLog(shader, logLen, NULL, logStr);
			#ifndef NDEBUG
				printf("Shader compilation error: %s\n", logStr);
			#endif
				free(logStr);
			}
			glDeleteShader(shader);
		}
	}
	return 0;
}

//********************************** Helpers *********************************/

/**
 * Vertex position index.
 */
#define GL_VERT_POSXY_ID 0

/**
 * Vertex UV0 index.
 */
#define GL_VERT_TXUV0_ID 1

 /**
  * \c GL vec2 storage type.
  */
struct vec2 {
	float x;
	float y;
};

/**
 * Combined 2D vertex and 2D texture coordinates.
 */
struct posTex2d {
	struct vec2 pos;
	struct vec2 uv0;
};

//****************************************************************************/

/**
 * Current quad rotation angle (in degrees, updated per frame).
 */
static float rotDeg = 0.0f;

/**
 * Emscripten (single) GL context.
 */
static EMSCRIPTEN_WEBGL_CONTEXT_HANDLE glCtx = 0;

/**
 * Emscripten resize handler.
 */
static EM_BOOL resize(int type, const EmscriptenUiEvent* e, void* data) {
	double surfaceW;
	double surfaceH;
	if (emscripten_get_element_css_size   ("#canvas", &surfaceW, &surfaceH) == EMSCRIPTEN_RESULT_SUCCESS) {
		emscripten_set_canvas_element_size("#canvas",  surfaceW,  surfaceH);
		if (glCtx) {
			glViewport(0, 0, (int) surfaceW, (int) surfaceH);
		}
	}
	(void) type;
	(void) data;
	(void) e;
	return EM_FALSE;
}

/**
 * Boilerplate to create a WebGL context.
 */
static EM_BOOL initContext() {
	// Default attributes
	EmscriptenWebGLContextAttributes attr;
	emscripten_webgl_init_context_attributes(&attr);
	if ((glCtx = emscripten_webgl_create_context("#canvas", &attr))) {
		// Bind the context and fire a resize to get the initial size
		emscripten_webgl_make_context_current(glCtx);
		emscripten_set_resize_callback(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, NULL, EM_FALSE, resize);
		resize(0, NULL, NULL);
		return EM_TRUE;
	}
	return EM_FALSE;
}

/**
 * Called once per frame (clears the screen and draws the rotating quad).
 */
static void tick() {
	glClearColor(1.0f, 0.0f, 1.0f, 1.0f);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	if (uRotId >= 0) {
		glUniform1f(uRotId, rotDeg);
		rotDeg += 0.1f;
		if (rotDeg >= 360.0f) {
			rotDeg -= 360.0f;
		}
	}

	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
	glFlush();
}

/**
 * Creates the GL context, shaders and quad data, decompresses the Zstd data
 * and 'uploads' the resulting texture.
 * 
 * As a (naive) comparison, removing Zstd and building with "-Os -g0 s WASM=1
 * -lGL emscripten.c" results in a 15kB WebAssembly file; re-adding Zstd
 * increases the Wasm by 26kB.
 */
int main() {
	if (initContext()) {
		// Compile shaders and set the initial GL state
		if ((progId = glCreateProgram())) {
			 vertId = compileShader(GL_VERTEX_SHADER,   vertShader2D);
			 fragId = compileShader(GL_FRAGMENT_SHADER, fragShader2D);
			 
			 glBindAttribLocation(progId, GL_VERT_POSXY_ID, "aPos");
			 glBindAttribLocation(progId, GL_VERT_TXUV0_ID, "aUV0");
			 
			 glAttachShader(progId, vertId);
			 glAttachShader(progId, fragId);
			 glLinkProgram (progId);
			 glUseProgram  (progId);
			 uRotId = glGetUniformLocation(progId, "uRot");
			 uTx0Id = glGetUniformLocation(progId, "uTx0");
			 if (uTx0Id >= 0) {
				 glUniform1i(uTx0Id, 0);
			 }
			
			 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
			 glEnable(GL_BLEND);
			 glDisable(GL_DITHER);

			 glCullFace(GL_BACK);
			 glEnable(GL_CULL_FACE);
		}
		
		GLuint vertsBuf = 0;
		GLuint indexBuf = 0;
		GLuint txName   = 0;
		// Create the textured quad (vert positions then UVs)
		struct posTex2d verts2d[] = {
			{{-0.85f, -0.85f}, {0.0f, 0.0f}}, // BL
			{{ 0.85f, -0.85f}, {1.0f, 0.0f}}, // BR
			{{-0.85f,  0.85f}, {0.0f, 1.0f}}, // TL
			{{ 0.85f,  0.85f}, {1.0f, 1.0f}}, // TR
		};
		uint16_t index2d[] = {
			0, 1, 2,
			2, 1, 3,
		};
		glGenBuffers(1, &vertsBuf);
		glBindBuffer(GL_ARRAY_BUFFER, vertsBuf);
		glBufferData(GL_ARRAY_BUFFER,
			sizeof(verts2d), verts2d, GL_STATIC_DRAW);
		glVertexAttribPointer(GL_VERT_POSXY_ID, 2,
			GL_FLOAT, GL_FALSE, sizeof(struct posTex2d), 0);
		glVertexAttribPointer(GL_VERT_TXUV0_ID, 2,
			GL_FLOAT, GL_FALSE, sizeof(struct posTex2d),
				(void*) offsetof(struct posTex2d, uv0));
		glGenBuffers(1, &indexBuf);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuf);
		glBufferData(GL_ELEMENT_ARRAY_BUFFER,
			sizeof(index2d), index2d, GL_STATIC_DRAW);
		glEnableVertexAttribArray(GL_VERT_POSXY_ID);
		glEnableVertexAttribArray(GL_VERT_TXUV0_ID);
		
		// Decode the Zstd data and create the texture
		if (ZSTD_decompress(dstDxt1, DXT1_256x256, srcZstd, sizeof srcZstd) == DXT1_256x256) {
			glGenTextures(1, &txName);
			glBindTexture(GL_TEXTURE_2D, txName);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
			glCompressedTexImage2D(GL_TEXTURE_2D, 0,
				GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
					256, 256, 0, DXT1_256x256, dstDxt1);
		} else {
			printf("Failed to decode Zstd data\n");
		}
		emscripten_set_main_loop(tick, 0, EM_FALSE);
		emscripten_exit_with_live_runtime();
	}
	return EXIT_FAILURE;
}
Commit	Line	Data
648db22b	1	/**
	2	* \file emscripten.c
	3	* Emscripten example of using the single-file \c zstddeclib. Draws a rotating
	4	* textured quad with data from the in-line Zstd compressed DXT1 texture (DXT1
	5	* being hardware compression, further compressed with Zstd).
	6	* \n
	7	* Compile using:
	8	* \code
	9	* export CC_FLAGS="-Wall -Wextra -Werror -Os -g0 -flto --llvm-lto 3 -lGL -DNDEBUG=1"
	10	* export EM_FLAGS="-s WASM=1 -s ENVIRONMENT=web --shell-file shell.html --closure 1"
	11	* emcc $CC_FLAGS $EM_FLAGS -o out.html emscripten.c
	12	* \endcode
	13	*
	14	* \author Carl Woffenden, Numfum GmbH (released under a CC0 license)
	15	*/
	16
	17	#include <stddef.h>
	18	#include <stdio.h>
	19	#include <stdlib.h>
	20	#include <string.h>
	21
	22	#include <emscripten/emscripten.h>
	23	#include <emscripten/html5.h>
	24
	25	#include <GLES2/gl2.h>
	26	#include <GLES2/gl2ext.h>
	27
	28	#include "../zstddeclib.c"
	29
	30	//*********************** Test Data (DXT texture) ************************/
	31
	32	/**
	33	* Zstd compressed DXT1 256x256 texture source.
	34	* \n
	35	* See \c testcard.png for the original.
	36	*/
	37	static uint8_t const srcZstd[] = {
	38	#include "testcard-zstd.inl"
	39	};
	40
	41	/**
	42	* Uncompressed size of \c #srcZstd.
	43	*/
	44	#define DXT1_256x256 32768
	45
	46	/**
	47	* Destination for decoding \c #srcZstd.
	48	*/
	49	static uint8_t dstDxt1[DXT1_256x256] = {};
	50
	51	#ifndef ZSTD_VERSION_MAJOR
	52	/**
	53	* For the case where the decompression library hasn't been included we add a
	54	* dummy function to fake the process and stop the buffers being optimised out.
	55	*/
	56	size_t ZSTD_decompress(void* dst, size_t dstLen, const void* src, size_t srcLen) {
	57	return (memcmp(dst, src, (srcLen < dstLen) ? srcLen : dstLen)) ? dstLen : 0;
	58	}
	59	#endif
	60
	61	//************************* Program and Shaders *************************/
	62
	63	/**
	64	* Program object ID.
65	*/
66	static GLuint progId = 0;
67
68	/**
69	* Vertex shader ID.
70	*/
71	static GLuint vertId = 0;
72
73	/**
74	* Fragment shader ID.
75	*/
76	static GLuint fragId = 0;
77
78	//******************************* Uniforms *******************************/
79
80	/**
81	* Quad rotation angle ID.
82	*/
83	static GLint uRotId = -1;
84
85	/**
86	* Draw colour ID.
87	*/
88	static GLint uTx0Id = -1;
89
90	//***************************** Shader Source ****************************/
91
92	/**
93	* Vertex shader to draw texture mapped polys with an applied rotation.
94	*/
95	static GLchar const vertShader2D[] =
96	#if GL_ES_VERSION_2_0
97	"#version 100\n"
98	"precision mediump float;\n"
99	#else
100	"#version 120\n"
101	#endif
102	"uniform float uRot;" // rotation
103	"attribute vec2 aPos;" // vertex position coords
104	"attribute vec2 aUV0;" // vertex texture UV0
105	"varying vec2 vUV0;" // (passed to fragment shader)
106	"void main() {"
107	" float cosA = cos(radians(uRot));"
108	" float sinA = sin(radians(uRot));"
109	" mat3 rot = mat3(cosA, -sinA, 0.0,"
110	" sinA, cosA, 0.0,"
111	" 0.0, 0.0, 1.0);"
112	" gl_Position = vec4(rot * vec3(aPos, 1.0), 1.0);"
113	" vUV0 = aUV0;"
114	"}";
115
116	/**
117	* Fragment shader for the above polys.
118	*/
119	static GLchar const fragShader2D[] =
120	#if GL_ES_VERSION_2_0
121	"#version 100\n"
122	"precision mediump float;\n"
123	#else
124	"#version 120\n"
125	#endif
126	"uniform sampler2D uTx0;"
127	"varying vec2 vUV0;" // (passed from fragment shader)
128	"void main() {"
129	" gl_FragColor = texture2D(uTx0, vUV0);"
130	"}";
131
132	/**
133	* Helper to compile a shader.
134	*
135	* \param type shader type
136	* \param text shader source
137	* \return the shader ID (or zero if compilation failed)
138	*/
139	static GLuint compileShader(GLenum const type, const GLchar* text) {
140	GLuint shader = glCreateShader(type);
141	if (shader) {
142	glShaderSource (shader, 1, &text, NULL);
143	glCompileShader(shader);
144	GLint compiled;
145	glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
146	if (compiled) {
147	return shader;
148	} else {
149	GLint logLen;
150	glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLen);
151	if (logLen > 1) {
152	GLchar* logStr = malloc(logLen);
153	glGetShaderInfoLog(shader, logLen, NULL, logStr);
154	#ifndef NDEBUG
155	printf("Shader compilation error: %s\n", logStr);
156	#endif
157	free(logStr);
158	}
159	glDeleteShader(shader);
160	}
161	}
162	return 0;
163	}
164
165	//******************************** Helpers *******************************/
166
167	/**
168	* Vertex position index.
169	*/
170	#define GL_VERT_POSXY_ID 0
171
172	/**
173	* Vertex UV0 index.
174	*/
175	#define GL_VERT_TXUV0_ID 1
176
177	/**
178	* \c GL vec2 storage type.
179	*/
180	struct vec2 {
181	float x;
182	float y;
183	};
184
185	/**
186	* Combined 2D vertex and 2D texture coordinates.
187	*/
188	struct posTex2d {
189	struct vec2 pos;
190	struct vec2 uv0;
191	};
192
193	//****************************************************************************/
194
195	/**
196	* Current quad rotation angle (in degrees, updated per frame).
197	*/
198	static float rotDeg = 0.0f;
199
200	/**
201	* Emscripten (single) GL context.
202	*/
203	static EMSCRIPTEN_WEBGL_CONTEXT_HANDLE glCtx = 0;
204
205	/**
206	* Emscripten resize handler.
207	*/
208	static EM_BOOL resize(int type, const EmscriptenUiEvent* e, void* data) {
209	double surfaceW;
210	double surfaceH;
211	if (emscripten_get_element_css_size ("#canvas", &surfaceW, &surfaceH) == EMSCRIPTEN_RESULT_SUCCESS) {
212	emscripten_set_canvas_element_size("#canvas", surfaceW, surfaceH);
213	if (glCtx) {
214	glViewport(0, 0, (int) surfaceW, (int) surfaceH);
215	}
216	}
217	(void) type;
218	(void) data;
219	(void) e;
220	return EM_FALSE;
221	}
222
223	/**
224	* Boilerplate to create a WebGL context.
225	*/
226	static EM_BOOL initContext() {
227	// Default attributes
228	EmscriptenWebGLContextAttributes attr;
229	emscripten_webgl_init_context_attributes(&attr);
230	if ((glCtx = emscripten_webgl_create_context("#canvas", &attr))) {
231	// Bind the context and fire a resize to get the initial size
232	emscripten_webgl_make_context_current(glCtx);
233	emscripten_set_resize_callback(EMSCRIPTEN_EVENT_TARGET_DOCUMENT, NULL, EM_FALSE, resize);
234	resize(0, NULL, NULL);
235	return EM_TRUE;
236	}
237	return EM_FALSE;
238	}
239
240	/**
241	* Called once per frame (clears the screen and draws the rotating quad).
242	*/
243	static void tick() {
244	glClearColor(1.0f, 0.0f, 1.0f, 1.0f);
245	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
246
247	if (uRotId >= 0) {
248	glUniform1f(uRotId, rotDeg);
249	rotDeg += 0.1f;
250	if (rotDeg >= 360.0f) {
251	rotDeg -= 360.0f;
252	}
253	}
254
255	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
256	glFlush();
257	}
258
259	/**
260	* Creates the GL context, shaders and quad data, decompresses the Zstd data
261	* and 'uploads' the resulting texture.
262	*
263	* As a (naive) comparison, removing Zstd and building with "-Os -g0 s WASM=1
264	* -lGL emscripten.c" results in a 15kB WebAssembly file; re-adding Zstd
265	* increases the Wasm by 26kB.
266	*/
267	int main() {
268	if (initContext()) {
269	// Compile shaders and set the initial GL state
270	if ((progId = glCreateProgram())) {
271	vertId = compileShader(GL_VERTEX_SHADER, vertShader2D);
272	fragId = compileShader(GL_FRAGMENT_SHADER, fragShader2D);
273
274	glBindAttribLocation(progId, GL_VERT_POSXY_ID, "aPos");
275	glBindAttribLocation(progId, GL_VERT_TXUV0_ID, "aUV0");
276
277	glAttachShader(progId, vertId);
278	glAttachShader(progId, fragId);
279	glLinkProgram (progId);
280	glUseProgram (progId);
281	uRotId = glGetUniformLocation(progId, "uRot");
282	uTx0Id = glGetUniformLocation(progId, "uTx0");
283	if (uTx0Id >= 0) {
284	glUniform1i(uTx0Id, 0);
285	}
286
287	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
288	glEnable(GL_BLEND);
289	glDisable(GL_DITHER);
290
291	glCullFace(GL_BACK);
292	glEnable(GL_CULL_FACE);
293	}
294
295	GLuint vertsBuf = 0;
296	GLuint indexBuf = 0;
297	GLuint txName = 0;
298	// Create the textured quad (vert positions then UVs)
299	struct posTex2d verts2d[] = {
300	{{-0.85f, -0.85f}, {0.0f, 0.0f}}, // BL
301	{{ 0.85f, -0.85f}, {1.0f, 0.0f}}, // BR
302	{{-0.85f, 0.85f}, {0.0f, 1.0f}}, // TL
303	{{ 0.85f, 0.85f}, {1.0f, 1.0f}}, // TR
304	};
305	uint16_t index2d[] = {
306	0, 1, 2,
307	2, 1, 3,
308	};
309	glGenBuffers(1, &vertsBuf);
310	glBindBuffer(GL_ARRAY_BUFFER, vertsBuf);
311	glBufferData(GL_ARRAY_BUFFER,
312	sizeof(verts2d), verts2d, GL_STATIC_DRAW);
313	glVertexAttribPointer(GL_VERT_POSXY_ID, 2,
314	GL_FLOAT, GL_FALSE, sizeof(struct posTex2d), 0);
315	glVertexAttribPointer(GL_VERT_TXUV0_ID, 2,
316	GL_FLOAT, GL_FALSE, sizeof(struct posTex2d),
317	(void*) offsetof(struct posTex2d, uv0));
318	glGenBuffers(1, &indexBuf);
319	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuf);
320	glBufferData(GL_ELEMENT_ARRAY_BUFFER,
321	sizeof(index2d), index2d, GL_STATIC_DRAW);
322	glEnableVertexAttribArray(GL_VERT_POSXY_ID);
323	glEnableVertexAttribArray(GL_VERT_TXUV0_ID);
324
325	// Decode the Zstd data and create the texture
326	if (ZSTD_decompress(dstDxt1, DXT1_256x256, srcZstd, sizeof srcZstd) == DXT1_256x256) {
327	glGenTextures(1, &txName);
328	glBindTexture(GL_TEXTURE_2D, txName);
329	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
330	glCompressedTexImage2D(GL_TEXTURE_2D, 0,
331	GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
332	256, 256, 0, DXT1_256x256, dstDxt1);
333	} else {
334	printf("Failed to decode Zstd data\n");
335	}
336	emscripten_set_main_loop(tick, 0, EM_FALSE);
337	emscripten_exit_with_live_runtime();
338	}
339	return EXIT_FAILURE;
340	}