You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
341 lines
8.5 KiB
341 lines
8.5 KiB
/**
|
|
* \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;
|
|
}
|