@thi.ng/wasm-api-webgl 0.1.0

package/gl.js

@@ -0,0 +1,222 @@
+import { GLType } from "@thi.ng/api/typedarray";
+import { illegalArgs } from "@thi.ng/errors/illegal-arguments";
+import { unsupported } from "@thi.ng/errors/unsupported";
+import { WasmDomModule } from "@thi.ng/wasm-api-dom";
+import { ObjectIndex } from "@thi.ng/wasm-api/object-index";
+import { compileModel } from "@thi.ng/webgl/buffer";
+import { draw } from "@thi.ng/webgl/draw";
+import { defShader } from "@thi.ng/webgl/shader";
+import { defTexture } from "@thi.ng/webgl/texture";
+import {
+  $AttribUpdateSpec,
+  $ModelSpec,
+  $ShaderSpec,
+  $TextureSpec,
+  $UniformValue,
+  $WebGLContextOpts,
+  ImageType,
+  ShaderAttribType,
+  UniformType,
+  WebGLPowerPreference
+} from "./generated/api.js";
+const WasmWebGLModule = {
+  id: "webgl",
+  deps: [WasmDomModule],
+  factory: () => new WasmWebGL()
+};
+class WasmWebGL {
+  parent;
+  dom;
+  contexts;
+  models;
+  shaders;
+  textures;
+  $ShaderSpec;
+  $ModelSpec;
+  $TextureSpec;
+  $UniformValue;
+  $AttribUpdateSpec;
+  $WebGLContextOpts;
+  async init(parent) {
+    this.parent = parent;
+    this.dom = this.parent.modules[WasmDomModule.id];
+    const defIndex = (name) => new ObjectIndex({ name, logger: parent.logger });
+    this.contexts = defIndex("ctx");
+    this.shaders = defIndex("sha");
+    this.models = defIndex("mod");
+    this.textures = defIndex("tex");
+    this.$AttribUpdateSpec = $AttribUpdateSpec(this.parent);
+    this.$ModelSpec = $ModelSpec(this.parent);
+    this.$ShaderSpec = $ShaderSpec(this.parent);
+    this.$TextureSpec = $TextureSpec(this.parent);
+    this.$UniformValue = $UniformValue(this.parent);
+    this.$WebGLContextOpts = $WebGLContextOpts(this.parent);
+    return true;
+  }
+  getImports() {
+    return {
+      canvasGLContext: (canvasID, optsAddr) => {
+        const opts = this.$WebGLContextOpts.instance(optsAddr);
+        const ctx = this.dom.elements.get(canvasID).getContext("webgl2", {
+          alpha: !!opts.alpha,
+          antialias: !!opts.antialias,
+          depth: !!opts.depth,
+          desynchronized: !!opts.desynchronized,
+          failIfMajorPerformanceCaveat: !!opts.failIfMajorPerformanceCaveat,
+          powerPreference: WebGLPowerPreference[opts.powerPreference].replace("_", "-"),
+          premultipliedAlpha: !!opts.premultipliedAlpha,
+          preserveDrawingBuffer: !!opts.preserveDrawingBuffer,
+          stencil: !!opts.stencil
+        });
+        if (!ctx) unsupported("WebGL2 not supported");
+        return this.contexts.addUnique(ctx);
+      },
+      createShader: (ctxID, addr) => {
+        const buildAttribs = (spec2) => {
+          const attribs = {};
+          for (let att of spec2.attribs) {
+            attribs[att.name.deref()] = ShaderAttribType[att.type];
+          }
+          return attribs;
+        };
+        const buildVarying = (spec2) => {
+          const varyings = {};
+          for (let v of spec2.varying) {
+            varyings[v.name.deref()] = ShaderAttribType[v.type];
+          }
+          return varyings;
+        };
+        const buildUniforms = (spec2) => {
+          const uniforms = {};
+          for (let uni of spec2.uniforms) {
+            uniforms[uni.name.deref()] = [
+              UniformType[uni.type],
+              uni.default[UniformType[uni.type]]
+            ];
+          }
+          return uniforms;
+        };
+        const gl = this.contexts.get(ctxID);
+        const spec = this.$ShaderSpec.instance(addr);
+        const $spec = {
+          vs: spec.vs.deref(),
+          fs: spec.fs.deref(),
+          attribs: buildAttribs(spec),
+          varying: buildVarying(spec),
+          uniforms: buildUniforms(spec)
+        };
+        const shader = defShader(gl, $spec, {
+          logger: this.parent.logger
+        });
+        return this.shaders.add(shader);
+      },
+      createModel: (ctxID, addr) => {
+        const buildAttribs = (specs) => {
+          const attribs = {};
+          for (let att of specs) {
+            attribs[att.name.deref()] = {
+              type: att.type,
+              size: att.size,
+              stride: att.stride,
+              offset: att.offset,
+              data: att.data[GLType[att.type].toLowerCase()]
+            };
+          }
+          return attribs;
+        };
+        const buildUniforms = (specs) => {
+          const uniforms = {};
+          for (let uni of specs) {
+            uniforms[uni.name.deref()] = uni.value[UniformType[uni.type]];
+          }
+          return uniforms;
+        };
+        const gl = this.contexts.get(ctxID);
+        const spec = this.$ModelSpec.instance(addr);
+        const modelSpec = {
+          shader: this.shaders.get(spec.shader),
+          attribs: buildAttribs(spec.attribs),
+          uniforms: buildUniforms(spec.uniforms),
+          mode: spec.mode,
+          num: spec.num
+        };
+        if (spec.numInstances) {
+          modelSpec.instances = {
+            attribs: buildAttribs(spec.instances),
+            num: spec.numInstances
+          };
+        }
+        if (spec.textures.length) {
+          modelSpec.textures = [...spec.textures].map(
+            (id) => this.textures.get(id)
+          );
+        }
+        return this.models.add(compileModel(gl, modelSpec));
+      },
+      createTexture: (ctxID, addr) => {
+        const gl = this.contexts.get(ctxID);
+        const spec = this.$TextureSpec.instance(addr);
+        const img = spec.imgType !== ImageType.none ? spec.img[ImageType[spec.imgType]] : null;
+        const tex = defTexture(gl, {
+          width: spec.width,
+          height: spec.height,
+          depth: spec.depth,
+          image: img,
+          filter: spec.filter,
+          format: spec.format,
+          wrap: spec.wrap,
+          target: spec.target,
+          type: spec.type
+        });
+        return this.textures.add(tex);
+      },
+      uniformInt: this.uniformScalar.bind(this),
+      uniformUInt: this.uniformScalar.bind(this),
+      uniformFloat: this.uniformScalar.bind(this),
+      uniformVec: (modelID, name, value, size) => this.uniformVec(modelID, name, "f32", value >> 2, size),
+      uniformIVec: (modelID, name, value, size) => this.uniformVec(modelID, name, "i32", value >> 2, size),
+      uniformUVec: (modelID, name, value, size) => this.uniformVec(modelID, name, "u32", value >> 2, size),
+      updateAttrib: (modelID, name, addr) => {
+        const model = this.models.get(modelID);
+        const id = this.parent.getString(name);
+        const attrib = model.attribs[id];
+        if (!attrib) illegalArgs(`unknown attrib: ${id}`);
+        const spec = this.$AttribUpdateSpec.instance(addr);
+        attrib.buffer.setChunk(
+          spec.data[GLType[spec.type].toLowerCase()],
+          spec.offset
+        );
+      },
+      draw: (modelID) => {
+        draw(this.models.get(modelID));
+      },
+      clear: (ctxID, r, g, b, a) => {
+        const gl = this.contexts.get(ctxID);
+        gl.clearColor(r, g, b, a);
+        gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+      }
+    };
+  }
+  /**
+   * Shared handler for setting a scalar uniform in a ModelSpec
+   *
+   * @param modelID
+   * @param name
+   * @param value
+   */
+  uniformScalar(modelID, name, value) {
+    const spec = this.models.get(modelID);
+    const id = this.parent.getString(name);
+    spec.uniforms[id] = value;
+  }
+  uniformVec(modelID, name, type, addr, size) {
+    const spec = this.models.get(modelID);
+    const id = this.parent.getString(name);
+    const val = this.parent[type].subarray(addr, addr + size).slice();
+    spec.uniforms[id] = val;
+  }
+}
+export {
+  WasmWebGL,
+  WasmWebGLModule
+};

package/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./api.js";
+export * from "./gl.js";
+//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -0,0 +1,2 @@
+export * from "./api.js";
+export * from "./gl.js";

package/package.json

@@ -0,0 +1,100 @@
+{
+  "name": "@thi.ng/wasm-api-webgl",
+  "version": "0.1.0",
+  "description": "WebGL bridge API for hybrid TypeScript & WASM (Zig) applications",
+  "type": "module",
+  "module": "./index.js",
+  "typings": "./index.d.ts",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thi-ng/umbrella.git"
+  },
+  "homepage": "https://thi.ng/wasm-api-webgl",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/postspectacular"
+    },
+    {
+      "type": "patreon",
+      "url": "https://patreon.com/thing_umbrella"
+    }
+  ],
+  "author": "Karsten Schmidt (https://thi.ng)",
+  "license": "Apache-2.0",
+  "scripts": {
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
+    "build:types": "npx wasm-api-bindgen  -a analytics.json --config src/typedefs-config.json --lang ts -o src/generated/api.ts --lang zig -o zig/api.zig src/typedefs.json",
+    "clean": "bun ../../tools/src/clean-package.ts",
+    "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
+    "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
+    "doc:readme": "bun ../../tools/src/module-stats.ts && bun ../../tools/src/readme.ts",
+    "pub": "yarn npm publish --access public",
+    "test": "bun test",
+    "tool:tangle": "../../node_modules/.bin/tangle src/**/*.ts"
+  },
+  "dependencies": {
+    "@thi.ng/api": "^8.11.9",
+    "@thi.ng/errors": "^2.5.15",
+    "@thi.ng/wasm-api": "^2.0.0",
+    "@thi.ng/wasm-api-dom": "^1.0.0",
+    "@thi.ng/webgl": "^6.9.12"
+  },
+  "devDependencies": {
+    "@microsoft/api-extractor": "^7.47.5",
+    "@thi.ng/wasm-api-bindgen": "^0.6.0",
+    "esbuild": "^0.23.0",
+    "typedoc": "^0.26.5",
+    "typescript": "^5.5.4"
+  },
+  "keywords": [
+    "browser",
+    "codegen",
+    "interop",
+    "shader",
+    "typescript",
+    "webassembly",
+    "webgl",
+    "zig"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "browser": {
+    "process": false,
+    "setTimeout": false
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "./*.js",
+    "./*.d.ts",
+    "zig",
+    "generated"
+  ],
+  "exports": {
+    ".": {
+      "default": "./index.js"
+    },
+    "./api": {
+      "default": "./api.js"
+    },
+    "./gl": {
+      "default": "./gl.js"
+    }
+  },
+  "thi.ng": {
+    "parent": "@thi.ng/wasm-api",
+    "related": [
+      "wasm-api-canvas",
+      "webgl"
+    ],
+    "status": "alpha",
+    "year": 2024
+  },
+  "gitHead": "f6e26ea1142525171de5d36b9c3119f2782bb437\n"
+}

package/zig/api.zig

@@ -0,0 +1,360 @@
+//! Generated by @thi.ng/wasm-api-bindgen at 2024-08-17T16:17:33.290Z
+//! DO NOT EDIT!
+
+const std = @import("std");
+const bindgen = @import("wasm-api-bindgen");
+
+pub const ShaderAttribSpecSlice = bindgen.Slice([]ShaderAttribSpec, [*]ShaderAttribSpec);
+pub const ConstShaderAttribSpecSlice = bindgen.Slice([]const ShaderAttribSpec, [*]const ShaderAttribSpec);
+
+pub const ShaderVaryingSpecSlice = bindgen.Slice([]ShaderVaryingSpec, [*]ShaderVaryingSpec);
+pub const ConstShaderVaryingSpecSlice = bindgen.Slice([]const ShaderVaryingSpec, [*]const ShaderVaryingSpec);
+
+pub const ShaderUniformSpecSlice = bindgen.Slice([]ShaderUniformSpec, [*]ShaderUniformSpec);
+pub const ConstShaderUniformSpecSlice = bindgen.Slice([]const ShaderUniformSpec, [*]const ShaderUniformSpec);
+
+pub const ModelAttribSpecSlice = bindgen.Slice([]ModelAttribSpec, [*]ModelAttribSpec);
+pub const ConstModelAttribSpecSlice = bindgen.Slice([]const ModelAttribSpec, [*]const ModelAttribSpec);
+
+pub const ModelUniformSlice = bindgen.Slice([]ModelUniform, [*]ModelUniform);
+pub const ConstModelUniformSlice = bindgen.Slice([]const ModelUniform, [*]const ModelUniform);
+
+pub const I32Slice = bindgen.Slice([]i32, [*]i32);
+pub const ConstI32Slice = bindgen.Slice([]const i32, [*]const i32);
+
+pub const I8Slice = bindgen.Slice([]i8, [*]i8);
+pub const ConstI8Slice = bindgen.Slice([]const i8, [*]const i8);
+
+pub const U8Slice = bindgen.Slice([]u8, [*]u8);
+pub const ConstU8Slice = bindgen.Slice([]const u8, [*]const u8);
+
+pub const I16Slice = bindgen.Slice([]i16, [*]i16);
+pub const ConstI16Slice = bindgen.Slice([]const i16, [*]const i16);
+
+pub const U16Slice = bindgen.Slice([]u16, [*]u16);
+pub const ConstU16Slice = bindgen.Slice([]const u16, [*]const u16);
+
+pub const U32Slice = bindgen.Slice([]u32, [*]u32);
+pub const ConstU32Slice = bindgen.Slice([]const u32, [*]const u32);
+
+pub const F32Slice = bindgen.Slice([]f32, [*]f32);
+pub const ConstF32Slice = bindgen.Slice([]const f32, [*]const f32);
+
+/// Syntax sugar for: `ConstModelAttribSpecSlice.wrap()`
+pub inline fn modelAttribs(items: []const ModelAttribSpec) ConstModelAttribSpecSlice {
+    return ConstModelAttribSpecSlice.wrap(items);
+}
+/// Syntax sugar for: `ConstModelUniformSlice.wrap()`
+pub inline fn modelUniforms(items: []const ModelUniform) ConstModelUniformSlice {
+    return ConstModelUniformSlice.wrap(items);
+}
+/// Syntax sugar for: `ConstShaderAttribSpecSlice.wrap()`
+pub inline fn shaderAttribs(items: []const ShaderAttribSpec) ConstShaderAttribSpecSlice {
+    return ConstShaderAttribSpecSlice.wrap(items);
+}
+
+/// Syntax sugar for: `ShaderVaryingSpecSlice.wrap()`
+pub inline fn shaderVaryings(items: []const ShaderVaryingSpec) ConstShaderVaryingSpecSlice {
+    return ConstShaderVaryingSpecSlice.wrap(items);
+}
+
+/// Syntax sugar for: `ConstShaderUniformSpecSlice.wrap()`
+pub inline fn shaderUniforms(items: []const ShaderUniformSpec) ConstShaderUniformSpecSlice {
+    return ConstShaderUniformSpecSlice.wrap(items);
+}
+
+/// WebGL rendering context options, used by `createCanvasContext()`
+pub const WebGLContextOpts = extern struct {
+    alpha: u8 = 0,
+    antialias: u8 = 0,
+    depth: u8 = 1,
+    desynchronized: u8 = 0,
+    failIfMajorPerformanceCaveat: u8 = 0,
+    powerPreference: WebGLPowerPreference = .default,
+    premultipliedAlpha: u8 = 0,
+    preserveDrawingBuffer: u8 = 0,
+    stencil: u8 = 0,
+};
+
+pub const WebGLPowerPreference = enum(u8) {
+    default,
+    high_performance,
+    low_power,
+};
+
+pub const ShaderSpec = extern struct {
+    vs: bindgen.ConstStringPtr,
+    fs: bindgen.ConstStringPtr,
+    /// Slice of shader attribute specs
+    attribs: ConstShaderAttribSpecSlice = shaderAttribs(&[_]ShaderAttribSpec{}),
+    /// Slice of shader varying specs
+    varying: ConstShaderVaryingSpecSlice = shaderVaryings(&[_]ShaderVaryingSpec{}),
+    /// Slice of shader uniform specs
+    uniforms: ConstShaderUniformSpecSlice = shaderUniforms(&[_]ShaderUniformSpec{}),
+};
+
+pub const ShaderAttribSpec = extern struct {
+    name: bindgen.ConstStringPtr,
+    type: ShaderAttribType,
+};
+
+pub const ShaderVaryingSpec = extern struct {
+    name: bindgen.ConstStringPtr,
+    type: ShaderAttribType,
+};
+
+pub const ShaderUniformSpec = extern struct {
+    name: bindgen.ConstStringPtr,
+    type: UniformType,
+    default: UniformValue = .{ .float = 0 },
+};
+
+pub const ModelSpec = extern struct {
+    /// Slice of model attribute specs
+    attribs: ConstModelAttribSpecSlice = modelAttribs(&[_]ModelAttribSpec{}),
+    /// Slice of instance attribute specs
+    instances: ConstModelAttribSpecSlice = modelAttribs(&[_]ModelAttribSpec{}),
+    /// Slice of model uniforms
+    uniforms: ConstModelUniformSlice = modelUniforms(&[_]ModelUniform{}),
+    textures: ConstI32Slice = ConstI32Slice.wrap(&[_]i32{}),
+    shader: i32,
+    num: u32,
+    numInstances: u32 = 0,
+    mode: DrawMode = .triangles,
+};
+
+pub const ModelAttribSpec = extern struct {
+    name: bindgen.ConstStringPtr,
+    data: ModelAttribData,
+    type: ModelAttribType = .f32,
+    offset: u32 = 0,
+    stride: u32 = 0,
+    size: u32,
+};
+
+pub const ModelAttribData = extern union {
+    u8: ConstI8Slice,
+    i8: ConstU8Slice,
+    i16: ConstI16Slice,
+    u16: ConstU16Slice,
+    u32: ConstI32Slice,
+    i32: ConstU32Slice,
+    f32: ConstF32Slice,
+};
+
+pub const AttribUpdateSpec = extern struct {
+    data: ModelAttribData,
+    type: ModelAttribType = .f32,
+    /// Start byte offset in WebGL buffer
+    offset: u32 = 0,
+};
+
+pub const ModelUniform = extern struct {
+    name: bindgen.ConstStringPtr,
+    type: UniformType,
+    value: UniformValue,
+};
+
+pub const UniformValue = extern union {
+    float: f32,
+    vec2: @Vector(2, f32),
+    vec3: @Vector(3, f32),
+    vec4: @Vector(4, f32),
+};
+
+pub const TextureSpec = extern struct {
+    img: ImageData = .{ .none = 0 },
+    width: u16,
+    height: u16,
+    depth: u16 = 0,
+    format: TextureFormat = .rgba,
+    target: TextureTarget = .texture_2d,
+    type: TextureType = .auto,
+    filter: TextureFilter = .nearest,
+    wrap: TextureRepeat = .clamp,
+    imgType: ImageType = .none,
+};
+
+pub const ImageData = extern union {
+    none: u32,
+    u8: ConstU8Slice,
+    u16: ConstU16Slice,
+    u32: ConstU32Slice,
+    f32: ConstF32Slice,
+};
+
+pub const ImageType = enum(u8) {
+    none,
+    u8,
+    u16,
+    u32,
+    f32,
+};
+
+/// Same as https://docs.thi.ng/umbrella/api/enums/GLType.html
+pub const ModelAttribType = enum(u16) {
+    i8 = 5120,
+    u8 = 5121,
+    i16 = 5122,
+    u16 = 5123,
+    i32 = 5124,
+    u32 = 5125,
+    f32 = 5126,
+};
+
+pub const ShaderAttribType = enum(u8) {
+    float,
+    int,
+    uint,
+    vec2,
+    vec3,
+    vec4,
+    mat22,
+    mat33,
+    mat44,
+};
+
+pub const UniformType = enum(u8) {
+    float,
+    int,
+    uint,
+    vec2,
+    vec3,
+    vec4,
+    mat22,
+    mat33,
+    mat44,
+    sampler2D,
+    sampler3D,
+    samplerCube,
+};
+
+/// Visualization mode for how geometry will be interpreted
+/// Same as: https://docs.thi.ng/umbrella/webgl/enums/DrawMode.html
+pub const DrawMode = enum(u8) {
+    points,
+    lines,
+    line_loop,
+    line_strip,
+    triangles,
+    triangle_strip,
+    triangle_fan,
+};
+
+/// Same as: https://docs.thi.ng/umbrella/webgl/enums/TextureFilter.html
+pub const TextureFilter = enum(u16) {
+    linear = 9729,
+    nearest = 9728,
+    nearest_mipmap_nearest = 9984,
+    linear_mipmap_nearest,
+    nearest_mipmap_linear,
+    linear_mipmap_linear,
+};
+
+/// Same as: https://docs.thi.ng/umbrella/webgl/enums/TextureFormat.html
+pub const TextureFormat = enum(u16) {
+    alpha = 6406,
+    depth_component = 6402,
+    depth_component16 = 33189,
+    depth_component24 = 33190,
+    depth_component32f = 36012,
+    depth_stencil = 34041,
+    depth24_stencil8 = 35056,
+    depth32f_stencil8 = 36013,
+    luminance = 6409,
+    luminance_alpha = 6410,
+    r11f_g11f_b10f = 35898,
+    r16f = 33325,
+    r16i = 33331,
+    r16ui = 33332,
+    r32f = 33326,
+    r32i = 33333,
+    r32ui = 33334,
+    r8 = 33321,
+    r8_snorm = 36756,
+    r8i = 33329,
+    r8ui = 33330,
+    red = 6403,
+    red_integer = 36244,
+    rg = 33319,
+    rg_integer = 33320,
+    rg16f = 33327,
+    rg16i = 33337,
+    rg16ui = 33338,
+    rg32f = 33328,
+    rg32i = 33339,
+    rg32ui = 33340,
+    rg8 = 33323,
+    rg8_snorm = 36757,
+    rg8i = 33335,
+    rg8ui = 33336,
+    rgb = 6407,
+    rgb_integer = 36248,
+    rgb10_a2 = 32857,
+    rgb10_a2ui = 36975,
+    rgb16f = 34843,
+    rgb16i = 36233,
+    rgb16ui = 36215,
+    rgb32f = 34837,
+    rgb32i = 36227,
+    rgb32ui = 36209,
+    rgb5_a1 = 32855,
+    rgb565 = 36194,
+    rgb8 = 32849,
+    rgb8_snorm = 36758,
+    rgb8i = 36239,
+    rgb8ui = 36221,
+    rgb9_e5 = 35901,
+    rgba = 6408,
+    rgba_integer = 36249,
+    rgba16f = 34842,
+    rgba16i = 36232,
+    rgba16ui = 36214,
+    rgba32f = 34836,
+    rgba32i = 36226,
+    rgba32ui = 36208,
+    rgba4 = 32854,
+    rgba8 = 32856,
+    rgba8_snorm = 36759,
+    rgba8i = 36238,
+    rgba8ui = 36220,
+    srgb8 = 35905,
+    srgb8_alpha8 = 35907,
+};
+
+/// Same as: https://docs.thi.ng/umbrella/webgl/enums/TextureRepeat.html
+pub const TextureRepeat = enum(u16) {
+    repeat = 10497,
+    clamp = 33071,
+    repeat_mirror = 33648,
+};
+
+/// Same as: https://docs.thi.ng/umbrella/webgl/enums/TextureTarget.html
+pub const TextureTarget = enum(u16) {
+    texture_2d = 3553,
+    texture_3d = 32879,
+    texture_cube_map = 34067,
+    texture_2d_array = 35866,
+};
+
+/// Same as: https://docs.thi.ng/umbrella/webgl/enums/TextureType.html
+pub const TextureType = enum(u16) {
+    auto = 0,
+    byte = 5120,
+    unsigned_byte = 5121,
+    short = 5122,
+    unsigned_short = 5123,
+    int = 5124,
+    unsigned_int = 5125,
+    float = 5126,
+    half_float = 5131,
+    unsigned_short_4_4_4_4 = 32819,
+    unsigned_short_5_5_5_1 = 32820,
+    unsigned_short_5_6_5 = 33635,
+    unsigned_int_2_10_10_10_rev = 33640,
+    unsigned_int_24_8 = 34042,
+    unsigned_int_10f_11f_11f_rev = 35899,
+    unsigned_int_5_9_9_9_rev = 35902,
+    half_float_oes = 36193,
+    float_32_unsigned_int_24_8_rev = 36269,
+};