@tty-pt/lamina 0.0.0-stage → 1.1.0

package/include/ttypt/lam.h

@@ -0,0 +1,372 @@
+/**
+ * @file lam.h
+ * @brief Public header for the liblamina rendering and input system.
+ *
+ * liblamina is a lightweight, cross-platform 2D/3D graphics layer providing
+ * a unified API across OpenGL, framebuffer, WebGL2/WASM, and software backends.
+ *
+ * It manages window/framebuffer creation, texture and sprite
+ * drawing, color and tint management, 3D terrain/billboard streaming,
+ * and basic input event handling.
+ */
+
+#ifndef LAM_H
+#define LAM_H
+#ifndef TTYPT_LAM_H
+#define TTYPT_LAM_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "./lam-key.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*───────────────────────────────────────────────*
+ *              CONSTANTS & TYPES                *
+ *───────────────────────────────────────────────*/
+
+/**
+ * @defgroup lam_types liblamina types and constants
+ * @brief Fundamental types and constants used by liblamina.
+ * @{
+ */
+
+/** Pack 8-bit RGBA channels into 32-bit integer compatible with liblamina shaders. */
+#define LAM_RGBA(r, g, b, a) \
+	((((uint32_t)(a) & 0xFF) << 24) | \
+	 (((uint32_t)(r) & 0xFF) << 16) | \
+	 (((uint32_t)(g) & 0xFF) << 8)  | \
+	  ((uint32_t)(b) & 0xFF))
+
+/** Pack 8-bit RGB channels with full opacity (alpha = 255). */
+#define LAM_RGB(r, g, b) LAM_RGBA(r, g, b, 255)
+
+/** Extract 8-bit Alpha channel from 32-bit color. */
+#define LAM_COLOR_A(c) (((uint32_t)(c) >> 24) & 0xFF)
+/** Extract 8-bit Red channel from 32-bit color. */
+#define LAM_COLOR_R(c) (((uint32_t)(c) >> 16) & 0xFF)
+/** Extract 8-bit Green channel from 32-bit color. */
+#define LAM_COLOR_G(c) (((uint32_t)(c) >> 8) & 0xFF)
+/** Extract 8-bit Blue channel from 32-bit color. */
+#define LAM_COLOR_B(c) ((uint32_t)(c) & 0xFF)
+
+/** Standard color palette constants */
+#define LAM_COLOR_WHITE        0xFFFFFFFF
+#define LAM_COLOR_BLACK        0xFF000000
+#define LAM_COLOR_TRANSPARENT  0x00000000
+#define LAM_COLOR_RED          0xFFFF0000
+#define LAM_COLOR_GREEN        0xFF00FF00
+#define LAM_COLOR_BLUE         0xFF0000FF
+#define LAM_COLOR_YELLOW       0xFFFFFF00
+#define LAM_COLOR_CYAN         0xFF00FFFF
+#define LAM_COLOR_MAGENTA      0xFFFF00FF
+
+/** @brief Input field flags used by keyboard handlers. */
+enum lam_key_flags {
+	LAM_INPUT_MULTILINE = 1, /**< Allows multi-line input (ENTER adds newlines). */
+	LAM_INPUT_NUMERIC   = 2, /**< Restricts input to numeric characters. */
+};
+
+/**
+ * @brief Software rendering callback.
+ *
+ * Called once per pixel for procedural or CPU-based rendering.
+ *
+ * @param[out] color Pointer to the pixel in BGRA format.
+ * @param[in]  x     X coordinate of the pixel.
+ * @param[in]  y     Y coordinate of the pixel.
+ * @param[in]  ctx   Optional user data pointer.
+ */
+typedef void lam_lambda_t(uint8_t *color,
+                          uint32_t x,
+                          uint32_t y,
+                          void *ctx);
+
+/** Default white RGBA tint (no color modulation). */
+static const uint32_t lam_default_tint = 0xFFFFFFFF;
+
+/**
+ * @brief Keyboard event callback prototype.
+ *
+ * @param[in] code  Platform key code.
+ * @param[in] type  Event type (press, release, repeat).
+ * @param[in] value Event state (1 = pressed, 0 = released).
+ * @return Non-zero to consume the event, zero to propagate.
+ */
+typedef int lam_key_cb_t(unsigned short code,
+                         unsigned short type,
+                         int value);
+
+/** @} */
+
+#ifdef __wasm__
+
+__attribute__((import_module("lamina"), import_name("lam_fill")))
+void lam_fill(uint32_t x, uint32_t y, uint32_t w, uint32_t h, uint32_t color);
+
+__attribute__((import_module("lamina"), import_name("lam_tile_draw")))
+void lam_tile_draw(uint32_t ref, uint32_t idx, uint32_t x, uint32_t y, uint32_t w, uint32_t h, uint32_t rx, uint32_t ry);
+
+__attribute__((import_module("lamina"), import_name("lam_flush")))
+void lam_flush(void);
+
+__attribute__((import_module("lamina"), import_name("lam_canvas_flush")))
+void lam_canvas_flush(const void *buf, uint32_t w, uint32_t h);
+
+__attribute__((import_module("lamina"), import_name("lam_shader_register")))
+uint32_t lam_shader_register(const char *name, const char *frag_glsl);
+
+__attribute__((import_module("lamina"), import_name("lam_shader_bind")))
+void lam_shader_bind(uint32_t shader_id);
+
+__attribute__((import_module("lamina"), import_name("lam_shader_uniforms")))
+void lam_shader_uniforms(uint32_t shader_id, const float *values, uint32_t count);
+
+__attribute__((import_module("lamina"), import_name("lam_cam_set_3d")))
+void lam_cam_set_3d(float target_x, float target_y, float target_z,
+                    float distance, float pitch_deg, float yaw_deg, float fov_deg);
+
+__attribute__((import_module("lamina"), import_name("lam_cam_set_2d")))
+void lam_cam_set_2d(void);
+
+__attribute__((import_module("lamina"), import_name("lam_terrain_mesh_flush")))
+void lam_terrain_mesh_flush(const void *color_rgba, const int16_t *height_i16,
+                            uint32_t chunk_w, uint32_t chunk_h,
+                            uint32_t stage_w, uint32_t stage_h,
+                            float sea_level, const float *cam_params,
+                            const void *water_rgba);
+
+__attribute__((import_module("lamina"), import_name("lam_billboard_batch_flush")))
+void lam_billboard_batch_flush(const void *billboard_data, uint32_t count, const void *atlas_ptr);
+
+__attribute__((import_module("lamina"), import_name("lam_image_request")))
+uint32_t lam_image_request(const char *url);
+
+__attribute__((import_module("lamina"), import_name("lam_image_read")))
+uint32_t lam_image_read(uint32_t img_id, void *dst_rgba, uint32_t max_bytes,
+                        uint32_t *out_w, uint32_t *out_h);
+
+#else /* !__wasm__ */
+
+/**
+ * @brief Obtain the current framebuffer dimensions.
+ *
+ * @param[out] width  Framebuffer width in pixels.
+ * @param[out] height Framebuffer height in pixels.
+ */
+void lam_size(uint32_t *width, uint32_t *height);
+
+/**
+ * @brief Initialise the OpenGL context, window, and input system.
+ */
+void lam_init(void);
+void lam_deinit(void);
+
+/*───────────────────────────────────────────────*
+ *                 RENDERING API                 *
+ *───────────────────────────────────────────────*/
+
+/**
+ * @defgroup lam_render liblamina rendering
+ * @brief Immediate-mode drawing and frame presentation.
+ * @{
+ */
+
+void lam_render(lam_lambda_t *lambda,
+                int32_t x, int32_t y,
+                uint32_t w, uint32_t h,
+                void *ctx);
+
+void lam_fill(int32_t x, int32_t y,
+              uint32_t w, uint32_t h,
+              uint32_t color);
+
+void lam_clear(uint32_t color);
+
+void lam_rect(int32_t x, int32_t y,
+              uint32_t w, uint32_t h,
+              uint32_t border_color,
+              uint32_t border_width);
+
+void lam_line(int32_t x0, int32_t y0,
+              int32_t x1, int32_t y1,
+              uint32_t color,
+              uint32_t thickness);
+
+void lam_flush(void);
+
+/** @} */
+
+/*───────────────────────────────────────────────*
+ *              TEXTURE / SPRITE API             *
+ *───────────────────────────────────────────────*/
+
+/**
+ * @defgroup lam_texture liblamina textures and sprites
+ * @brief Texture management and sprite drawing.
+ * @{
+ */
+
+void lam_tex_draw_x(uint32_t ref,
+                    int32_t x, int32_t y,
+                    uint32_t cx, uint32_t cy,
+                    uint32_t sw, uint32_t sh,
+                    uint32_t dw, uint32_t dh,
+                    uint32_t tint);
+
+void lam_tex_draw(uint32_t ref,
+                  int32_t x, int32_t y,
+                  uint32_t dw, uint32_t dh);
+
+unsigned lam_tex_load(const char *filename);
+void lam_tex_save(unsigned ref);
+void lam_tex_size(uint32_t *w, uint32_t *h, unsigned ref);
+uint32_t lam_tex_pick(unsigned ref, uint32_t x, uint32_t y);
+void lam_tex_paint(unsigned ref,
+                   uint32_t x, uint32_t y,
+                   uint32_t color);
+void lam_tint(uint32_t tint);
+
+/** @} */
+
+/*───────────────────────────────────────────────*
+ *                 INPUT API                     *
+ *───────────────────────────────────────────────*/
+
+/**
+ * @defgroup lam_input liblamina input handling
+ * @brief Keyboard polling and event dispatch.
+ * @{
+ */
+
+void lam_poll(void);
+void lam_key_reg(unsigned short key, lam_key_cb_t *cb);
+void lam_key_default_reg(lam_key_cb_t *cb);
+unsigned short lam_key_val(unsigned short code);
+int lam_key_parse(char *target, size_t len,
+                  unsigned short code, int flags);
+
+/** @} */
+
+/*───────────────────────────────────────────────*
+ *         WEBGL / HYBRID SSR FALLBACKS          *
+ *───────────────────────────────────────────────*/
+
+static inline void lam_canvas_flush(const void *buf, uint32_t w, uint32_t h)
+{ (void)buf; (void)w; (void)h; }
+
+static inline uint32_t lam_shader_register(const char *name, const char *frag_glsl)
+{ (void)name; (void)frag_glsl; return 0; }
+
+static inline void lam_shader_bind(uint32_t shader_id)
+{ (void)shader_id; }
+
+static inline void lam_shader_uniforms(uint32_t shader_id, const float *values, uint32_t count)
+{ (void)shader_id; (void)values; (void)count; }
+
+static inline void lam_terrain_mesh_flush(const void *c, const int16_t *h,
+                                          uint32_t cw, uint32_t ch,
+                                          uint32_t sw, uint32_t sh,
+                                          float sl, const float *cp,
+                                          const void *water_rgba)
+{ (void)c; (void)h; (void)cw; (void)ch; (void)sw; (void)sh; (void)sl; (void)cp; (void)water_rgba; }
+
+static inline void lam_billboard_batch_flush(const void *b, uint32_t count, const void *atlas)
+{ (void)b; (void)count; (void)atlas; }
+
+static inline uint32_t lam_image_request(const char *url)
+{ (void)url; return 0; }
+
+static inline uint32_t lam_image_read(uint32_t img_id, void *dst_rgba, uint32_t max_bytes,
+                                      uint32_t *out_w, uint32_t *out_h)
+{ (void)img_id; (void)dst_rgba; (void)max_bytes; (void)out_w; (void)out_h; return 0; }
+
+static inline void lam_cam_set_3d_7_(float tx, float ty, float tz, float d, float p, float y, float f)
+{ (void)tx; (void)ty; (void)tz; (void)d; (void)p; (void)y; (void)f; }
+
+static inline void lam_cam_set_2d_noop_(void) {}
+
+#define _LAM_CAM_SET_3D_PICK(_1, _2, _3, _4, _5, _6, _7, NAME, ...) NAME
+#define lam_cam_set_3d(...) _LAM_CAM_SET_3D_PICK(__VA_ARGS__, lam_cam_set_3d_7_, (lam_cam_set_3d))(__VA_ARGS__)
+
+#ifndef LAM_CAM_H
+#define lam_cam_set_2d() lam_cam_set_2d_noop_()
+#endif
+
+#endif /* !__wasm__ */
+
+/*───────────────────────────────────────────────*
+ *      3D BALLISTIC & ADVECTED PARTICLE API     *
+ *───────────────────────────────────────────────*/
+
+/**
+ * @brief Optional surface/floor elevation callback: returns surface Z at (wx, wy).
+ */
+typedef float (*lam_particle_surface_fn)(void *user_ctx, float wx, float wy);
+
+typedef struct {
+	float    x, y, z;          /* 3D world position */
+	float    vx, vy, vz;       /* 3D velocity (units/sec) */
+	float    size0, size1;     /* Start and end particle quad size */
+	float    age, max_age;     /* Current age and lifetime (seconds) */
+	float    drag;             /* Linear fluid/air drag coefficient (1/sec) */
+	float    gravity_scale;    /* Multiplier on system gravity (positive = falls, negative = rises) */
+	float    restitution;      /* Surface bounce restitution (< 0 = kill on surface contact, 0 = slide/settle, > 0 = bounce) */
+	uint32_t rgba0, rgba1;     /* Start and end RGBA tint (0xRRGGBBAA) */
+	uint8_t  kind;             /* Caller-defined material/behavior tag */
+	uint8_t  flags;            /* Bit 0: active */
+	uint16_t seed;             /* Per-particle deterministic phase seed */
+} lam_particle_t;
+
+typedef struct {
+	float    x, y, z;          /* Emission origin */
+	float    spread_x, spread_y, spread_z; /* Position jitter box half-extents */
+	float    dir_x, dir_y, dir_z;          /* Mean emission direction vector */
+	float    speed_min, speed_max;         /* Initial speed range */
+	float    cone_spread;      /* Angular velocity cone spread (0 = laser, 1 = hemisphere) */
+	float    size0_min, size0_max;         /* Start size range */
+	float    size1_min, size1_max;         /* End size range */
+	float    life_min, life_max;           /* Lifetime range in seconds */
+	float    drag;             /* Air/fluid drag coefficient */
+	float    gravity_scale;    /* Gravity multiplier */
+	float    restitution;      /* Surface contact behavior */
+	uint32_t rgba0, rgba1;     /* Start and end RGBA colors (0xRRGGBBAA) */
+	uint32_t count;            /* Number of particles to emit in this burst */
+	uint8_t  kind;             /* Material tag */
+} lam_particle_emitter_t;
+
+typedef struct {
+	float    x, y, z;          /* Interpolated 3D world position */
+	float    size;             /* Current interpolated world size */
+	float    norm_age;         /* Normalized age t in [0..1] */
+	uint32_t rgba;             /* Current interpolated & envelope-faded RGBA (0xRRGGBBAA) */
+	uint8_t  kind;             /* Material tag */
+	uint8_t  pad[3];
+} lam_particle_draw_t;
+
+typedef struct lam_particle_sys lam_particle_sys_t;
+
+lam_particle_sys_t *lam_particle_sys_create(size_t capacity, float default_gravity_z);
+void lam_particle_sys_destroy(lam_particle_sys_t *ps);
+void lam_particle_sys_clear(lam_particle_sys_t *ps);
+
+size_t lam_particle_emit(lam_particle_sys_t *ps, const lam_particle_emitter_t *em);
+
+void lam_particle_step(lam_particle_sys_t *ps, float dt,
+                       float wind_vx, float wind_vy, float wind_vz,
+                       lam_particle_surface_fn surface_fn, void *user_ctx);
+
+size_t lam_particle_gather(const lam_particle_sys_t *ps,
+                           lam_particle_draw_t *out_draw, size_t max_out);
+
+size_t lam_particle_active_count(const lam_particle_sys_t *ps);
+size_t lam_particle_capacity(const lam_particle_sys_t *ps);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TTYPT_LAM_H */
+#endif /* LAM_H */

package/include/ttypt/webgl.h

@@ -0,0 +1,286 @@
+#ifndef TTYPT_WEBGL_H
+#define TTYPT_WEBGL_H
+
+/*
+ * webgl.h — Canonical WebGL 1/2 graphics interface for WebAssembly and native C.
+ * Implements two-level WASM import namespace "webgl" with native fallback.
+ */
+
+#include <stdint.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef unsigned int GLenum;
+typedef unsigned int GLuint;
+typedef int GLint;
+typedef int GLsizei;
+typedef float GLfloat;
+typedef float GLclampf;
+typedef unsigned char GLboolean;
+
+#define GL_FALSE                  0
+#define GL_TRUE                   1
+
+#define GL_COLOR_BUFFER_BIT       0x00004000
+#define GL_DEPTH_BUFFER_BIT       0x00000100
+
+#define GL_POINTS                 0x0000
+#define GL_LINES                  0x0001
+#define GL_TRIANGLES              0x0004
+#define GL_TRIANGLE_STRIP         0x0005
+#define GL_TRIANGLE_FAN           0x0006
+
+#define GL_BYTE                   0x1400
+#define GL_UNSIGNED_BYTE          0x1401
+#define GL_SHORT                  0x1402
+#define GL_UNSIGNED_SHORT         0x1403
+#define GL_INT                    0x1404
+#define GL_UNSIGNED_INT           0x1405
+#define GL_FLOAT                  0x1406
+
+#define GL_FRAGMENT_SHADER        0x8B30
+#define GL_VERTEX_SHADER          0x8B31
+
+#define GL_ARRAY_BUFFER           0x8892
+#define GL_ELEMENT_ARRAY_BUFFER   0x8893
+
+#define GL_STREAM_DRAW            0x88E0
+#define GL_STATIC_DRAW            0x88E4
+#define GL_DYNAMIC_DRAW           0x88E8
+
+#define GL_COMPILE_STATUS         0x8B81
+#define GL_LINK_STATUS            0x8B82
+
+#define GL_DEPTH_TEST             0x0B71
+#define GL_BLEND                  0x0BE2
+#define GL_CULL_FACE              0x0B44
+#define GL_LESS                   0x0201
+#define GL_LEQUAL                 0x0203
+#define GL_SRC_ALPHA              0x0302
+#define GL_ONE_MINUS_SRC_ALPHA    0x0303
+#define GL_TEXTURE_2D             0x0DE1
+#define GL_TEXTURE0               0x84C0
+#define GL_TEXTURE1               0x84C1
+#define GL_TEXTURE2               0x84C2
+#define GL_TEXTURE_MAG_FILTER     0x2800
+#define GL_TEXTURE_MIN_FILTER     0x2801
+#define GL_TEXTURE_WRAP_S         0x2802
+#define GL_TEXTURE_WRAP_T         0x2803
+#define GL_NEAREST                0x2600
+#define GL_LINEAR                 0x2601
+#define GL_CLAMP_TO_EDGE          0x812F
+#define GL_RGBA                   0x1908
+#define GL_R16I                   0x8233
+#define GL_RED_INTEGER            0x8D94
+#define GL_UNPACK_ALIGNMENT       0x0CF5
+#define GL_POLYGON_OFFSET_FILL    0x8037
+
+#ifdef __wasm__
+__attribute__((import_module("webgl"), import_name("glViewport")))
+void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
+
+__attribute__((import_module("webgl"), import_name("glClearColor")))
+void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+
+__attribute__((import_module("webgl"), import_name("glClear")))
+void glClear(GLenum mask);
+
+__attribute__((import_module("webgl"), import_name("glEnable")))
+void glEnable(GLenum cap);
+
+__attribute__((import_module("webgl"), import_name("glDisable")))
+void glDisable(GLenum cap);
+
+__attribute__((import_module("webgl"), import_name("glDepthFunc")))
+void glDepthFunc(GLenum func);
+
+__attribute__((import_module("webgl"), import_name("glDepthMask")))
+void glDepthMask(GLboolean flag);
+
+__attribute__((import_module("webgl"), import_name("glBlendFunc")))
+void glBlendFunc(GLenum sfactor, GLenum dfactor);
+
+__attribute__((import_module("webgl"), import_name("glColorMask")))
+void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+
+__attribute__((import_module("webgl"), import_name("glPolygonOffset")))
+void glPolygonOffset(GLfloat factor, GLfloat units);
+
+__attribute__((import_module("webgl"), import_name("glCreateShader")))
+GLuint glCreateShader(GLenum type);
+
+__attribute__((import_module("webgl"), import_name("glShaderSource")))
+void glShaderSource(GLuint shader, const char *src, size_t len);
+
+__attribute__((import_module("webgl"), import_name("glCompileShader")))
+void glCompileShader(GLuint shader);
+
+__attribute__((import_module("webgl"), import_name("glGetShaderParameter")))
+GLint glGetShaderParameter(GLuint shader, GLenum pname);
+
+__attribute__((import_module("webgl"), import_name("glCreateProgram")))
+GLuint glCreateProgram(void);
+
+__attribute__((import_module("webgl"), import_name("glAttachShader")))
+void glAttachShader(GLuint program, GLuint shader);
+
+__attribute__((import_module("webgl"), import_name("glLinkProgram")))
+void glLinkProgram(GLuint program);
+
+__attribute__((import_module("webgl"), import_name("glGetProgramParameter")))
+GLint glGetProgramParameter(GLuint program, GLenum pname);
+
+__attribute__((import_module("webgl"), import_name("glUseProgram")))
+void glUseProgram(GLuint program);
+
+__attribute__((import_module("webgl"), import_name("glCreateBuffer")))
+GLuint glCreateBuffer(void);
+
+__attribute__((import_module("webgl"), import_name("glBindBuffer")))
+void glBindBuffer(GLenum target, GLuint buffer);
+
+__attribute__((import_module("webgl"), import_name("glBufferData")))
+void glBufferData(GLenum target, const void *data, size_t size, GLenum usage);
+
+__attribute__((import_module("webgl"), import_name("glCreateTexture")))
+GLuint glCreateTexture(void);
+
+__attribute__((import_module("webgl"), import_name("glDeleteTexture")))
+void glDeleteTexture(GLuint texture);
+
+__attribute__((import_module("webgl"), import_name("glBindTexture")))
+void glBindTexture(GLenum target, GLuint texture);
+
+__attribute__((import_module("webgl"), import_name("glActiveTexture")))
+void glActiveTexture(GLenum texture);
+
+__attribute__((import_module("webgl"), import_name("glTexParameteri")))
+void glTexParameteri(GLenum target, GLenum pname, GLint param);
+
+__attribute__((import_module("webgl"), import_name("glPixelStorei")))
+void glPixelStorei(GLenum pname, GLint param);
+
+__attribute__((import_module("webgl"), import_name("glTexImage2D")))
+void glTexImage2D(GLenum target, GLint level, GLint internalformat,
+                  GLsizei width, GLsizei height, GLint border,
+                  GLenum format, GLenum type, const void *pixels);
+
+__attribute__((import_module("webgl"), import_name("glEnableVertexAttribArray")))
+void glEnableVertexAttribArray(GLuint index);
+
+__attribute__((import_module("webgl"), import_name("glDisableVertexAttribArray")))
+void glDisableVertexAttribArray(GLuint index);
+
+__attribute__((import_module("webgl"), import_name("glVertexAttribPointer")))
+void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, size_t offset);
+
+__attribute__((import_module("webgl"), import_name("glDrawArrays")))
+void glDrawArrays(GLenum mode, GLint first, GLsizei count);
+
+__attribute__((import_module("webgl"), import_name("glDrawElements")))
+void glDrawElements(GLenum mode, GLsizei count, GLenum type, size_t offset);
+
+__attribute__((import_module("webgl"), import_name("glGetAttribLocation")))
+GLint glGetAttribLocation(GLuint program, const char *name, size_t len);
+
+__attribute__((import_module("webgl"), import_name("glBindAttribLocation")))
+void glBindAttribLocation(GLuint program, GLuint index, const char *name, size_t len);
+
+__attribute__((import_module("webgl"), import_name("glGetUniformLocation")))
+GLint glGetUniformLocation(GLuint program, const char *name, size_t len);
+
+__attribute__((import_module("webgl"), import_name("glUniform1i")))
+void glUniform1i(GLint location, GLint v0);
+
+__attribute__((import_module("webgl"), import_name("glUniform1f")))
+void glUniform1f(GLint location, GLfloat v0);
+
+__attribute__((import_module("webgl"), import_name("glUniform2f")))
+void glUniform2f(GLint location, GLfloat v0, GLfloat v1);
+
+__attribute__((import_module("webgl"), import_name("glUniform3f")))
+void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+
+__attribute__((import_module("webgl"), import_name("glUniform4f")))
+void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+
+__attribute__((import_module("webgl"), import_name("glUniform2fv")))
+void glUniform2fv(GLint location, GLsizei count, const GLfloat *value);
+
+__attribute__((import_module("webgl"), import_name("glUniform3fv")))
+void glUniform3fv(GLint location, GLsizei count, const GLfloat *value);
+
+__attribute__((import_module("webgl"), import_name("glUniformMatrix4fv")))
+void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+
+__attribute__((import_module("webgl"), import_name("glDeleteShader")))
+void glDeleteShader(GLuint shader);
+
+__attribute__((import_module("webgl"), import_name("glDeleteProgram")))
+void glDeleteProgram(GLuint program);
+
+__attribute__((import_module("webgl"), import_name("glDeleteBuffer")))
+void glDeleteBuffer(GLuint buffer);
+
+#else
+
+static inline void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) { (void)x; (void)y; (void)width; (void)height; }
+static inline void glClearColor(GLclampf r, GLclampf g, GLclampf b, GLclampf a) { (void)r; (void)g; (void)b; (void)a; }
+static inline void glClear(GLenum mask) { (void)mask; }
+static inline void glEnable(GLenum cap) { (void)cap; }
+static inline void glDisable(GLenum cap) { (void)cap; }
+static inline void glDepthFunc(GLenum func) { (void)func; }
+static inline void glDepthMask(GLboolean flag) { (void)flag; }
+static inline void glBlendFunc(GLenum sfactor, GLenum dfactor) { (void)sfactor; (void)dfactor; }
+static inline void glColorMask(GLboolean r, GLboolean g, GLboolean b, GLboolean a) { (void)r; (void)g; (void)b; (void)a; }
+static inline void glPolygonOffset(GLfloat factor, GLfloat units) { (void)factor; (void)units; }
+static inline GLuint glCreateShader(GLenum type) { (void)type; return 1; }
+static inline void glShaderSource(GLuint s, const char *src, size_t len) { (void)s; (void)src; (void)len; }
+static inline void glCompileShader(GLuint s) { (void)s; }
+static inline GLint glGetShaderParameter(GLuint s, GLenum p) { (void)s; (void)p; return 1; }
+static inline GLuint glCreateProgram(void) { return 1; }
+static inline void glAttachShader(GLuint p, GLuint s) { (void)p; (void)s; }
+static inline void glLinkProgram(GLuint p) { (void)p; }
+static inline GLint glGetProgramParameter(GLuint p, GLenum param) { (void)p; (void)param; return 1; }
+static inline void glUseProgram(GLuint p) { (void)p; }
+static inline GLuint glCreateBuffer(void) { return 1; }
+static inline void glBindBuffer(GLenum t, GLuint b) { (void)t; (void)b; }
+static inline void glBufferData(GLenum t, const void *d, size_t s, GLenum u) { (void)t; (void)d; (void)s; (void)u; }
+static inline GLuint glCreateTexture(void) { return 1; }
+static inline void glDeleteTexture(GLuint t) { (void)t; }
+static inline void glBindTexture(GLenum t, GLuint tex) { (void)t; (void)tex; }
+static inline void glActiveTexture(GLenum t) { (void)t; }
+static inline void glTexParameteri(GLenum t, GLenum p, GLint v) { (void)t; (void)p; (void)v; }
+static inline void glPixelStorei(GLenum p, GLint v) { (void)p; (void)v; }
+static inline void glTexImage2D(GLenum t, GLint l, GLint inf, GLsizei w, GLsizei h, GLint b, GLenum f, GLenum ty, const void *px)
+{ (void)t; (void)l; (void)inf; (void)w; (void)h; (void)b; (void)f; (void)ty; (void)px; }
+static inline void glEnableVertexAttribArray(GLuint i) { (void)i; }
+static inline void glDisableVertexAttribArray(GLuint i) { (void)i; }
+static inline void glVertexAttribPointer(GLuint i, GLint s, GLenum t, GLboolean n, GLsizei st, size_t o) { (void)i; (void)s; (void)t; (void)n; (void)st; (void)o; }
+static inline void glDrawArrays(GLenum m, GLint f, GLsizei c) { (void)m; (void)f; (void)c; }
+static inline void glDrawElements(GLenum m, GLsizei c, GLenum t, size_t o) { (void)m; (void)c; (void)t; (void)o; }
+static inline GLint glGetAttribLocation(GLuint p, const char *n, size_t l) { (void)p; (void)n; (void)l; return 0; }
+static inline void glBindAttribLocation(GLuint p, GLuint i, const char *n, size_t l) { (void)p; (void)i; (void)n; (void)l; }
+static inline GLint glGetUniformLocation(GLuint p, const char *n, size_t l) { (void)p; (void)n; (void)l; return 1; }
+static inline void glUniform1i(GLint l, GLint v0) { (void)l; (void)v0; }
+static inline void glUniform1f(GLint l, GLfloat v0) { (void)l; (void)v0; }
+static inline void glUniform2f(GLint l, GLfloat v0, GLfloat v1) { (void)l; (void)v0; (void)v1; }
+static inline void glUniform3f(GLint l, GLfloat v0, GLfloat v1, GLfloat v2) { (void)l; (void)v0; (void)v1; (void)v2; }
+static inline void glUniform4f(GLint l, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) { (void)l; (void)v0; (void)v1; (void)v2; (void)v3; }
+static inline void glUniform2fv(GLint l, GLsizei c, const GLfloat *v) { (void)l; (void)c; (void)v; }
+static inline void glUniform3fv(GLint l, GLsizei c, const GLfloat *v) { (void)l; (void)c; (void)v; }
+static inline void glUniformMatrix4fv(GLint l, GLsizei c, GLboolean t, const GLfloat *v) { (void)l; (void)c; (void)t; (void)v; }
+static inline void glDeleteShader(GLuint s) { (void)s; }
+static inline void glDeleteProgram(GLuint p) { (void)p; }
+static inline void glDeleteBuffer(GLuint b) { (void)b; }
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* TTYPT_WEBGL_H */