#ifndef __GL_THIN_CPP_H__
#define __GL_THIN_CPP_H__
#include "alias/cpp.h"
#include <stdint.h>
#include "gl_thin.h"
// --------------------------------------------------------------------------------------------------------------------
#define THIN_GL_SNIPPET_REQUIRE_require(NAME) &GL_##NAME##_snippet,
#define THIN_GL_SNIPPET_REQUIRE_code(CODE)
#define THIN_GL_SNIPPET_REQUIRE_string(CODE)
#define THIN_GL_SNIPPET_REQUIRE_(ITEM) ALIAS_CPP_CAT(THIN_GL_SNIPPET_REQUIRE_, ITEM)
#define THIN_GL_SNIPPET_CODE_require(NAME)
#define THIN_GL_SNIPPET_CODE_code(CODE) #CODE
#define THIN_GL_SNIPPET_CODE_string(CODE) CODE
#define THIN_GL_SNIPPET_CODE_(ITEM) ALIAS_CPP_CAT(THIN_GL_SNIPPET_CODE_, ITEM)
#define THIN_GL_DECLARE_SNIPPET(NAME, ...) extern struct GL_ShaderSnippet GL_##NAME##_snippet;
#define THIN_GL_IMPL_SNIPPET(NAME, ...)                                                                                \
  struct GL_ShaderSnippet GL_##NAME##_snippet = {                                                                      \
      .requires = {ALIAS_CPP_EVAL(ALIAS_CPP_MAP(THIN_GL_SNIPPET_REQUIRE_, __VA_ARGS__))},                              \
      .code = ALIAS_CPP_EVAL(ALIAS_CPP_MAP(THIN_GL_SNIPPET_CODE_, __VA_ARGS__))};
#define THIN_GL_SNIPPET(NAME, ...) THIN_GL_IMPL_SNIPPET(NAME, __VA_ARGS__)
// --------------------------------------------------------------------------------------------------------------------
#define THIN_GL_SHADER_REQUIRE_require(NAME) &GL_##NAME##_snippet,
#define THIN_GL_SHADER_REQUIRE_code(CODE)
#define THIN_GL_SHADER_REQUIRE_string(CODE)
#define THIN_GL_SHADER_REQUIRE_main(CODE)
#define THIN_GL_SHADER_REQUIRE_(ITEM) ALIAS_CPP_CAT(THIN_GL_SHADER_REQUIRE_, ITEM)
#define THIN_GL_SHADER_CODE_require(NAME)
#define THIN_GL_SHADER_CODE_code(CODE) #CODE
#define THIN_GL_SHADER_CODE_string(CODE) CODE
#define THIN_GL_SHADER_CODE_main(CODE) "void main() {" #CODE "}"
#define THIN_GL_SHADER_CODE_(ITEM) ALIAS_CPP_CAT(THIN_GL_SHADER_CODE_, ITEM)
#define THIN_GL_SHADER(NAME, ...)                                                                                      \
  static struct GL_Shader NAME##_shader = {                                                                            \
      .requires = {ALIAS_CPP_EVAL(ALIAS_CPP_MAP(THIN_GL_SHADER_REQUIRE_, __VA_ARGS__))},                               \
      .code = ALIAS_CPP_EVAL(ALIAS_CPP_MAP(THIN_GL_SHADER_CODE_, __VA_ARGS__))};
// --------------------------------------------------------------------------------------------------------------------
#define THIN_GL_ALIGNED(X) __attribute__((aligned(X)))
#define THIN_GL_STRUCT_TO_C_require(NAME)
#define THIN_GL_STRUCT_TO_C_unorm8(NAME) uint8_t NAME[4] THIN_GL_ALIGNED(4);     // uint (4, 4) -> float
#define THIN_GL_STRUCT_TO_C_unorm8x2(NAME) uint8_t NAME[4] THIN_GL_ALIGNED(4);   // uint (4, 4) -> vec2
#define THIN_GL_STRUCT_TO_C_unorm8x3(NAME) uint8_t NAME[4] THIN_GL_ALIGNED(4);   // uint (4, 4) -> vec3
#define THIN_GL_STRUCT_TO_C_unorm8x4(NAME) uint8_t NAME[4] THIN_GL_ALIGNED(4);   // uint (4, 4) -> vec4
#define THIN_GL_STRUCT_TO_C_unorm16(NAME) uint16_t NAME[2] THIN_GL_ALIGNED(4);   // uint (4, 4) -> float
#define THIN_GL_STRUCT_TO_C_unorm16x2(NAME) uint16_t NAME[2] THIN_GL_ALIGNED(4); // uint (4, 4) -> vec2
#define THIN_GL_STRUCT_TO_C_unorm16x3(NAME) uint16_t NAME[4] THIN_GL_ALIGNED(8); // uvec2 (8, 8) -> vec3
#define THIN_GL_STRUCT_TO_C_unorm16x4(NAME) uint16_t NAME[4] THIN_GL_ALIGNED(8); // uvec2 (8, 8) -> vec4
#define THIN_GL_STRUCT_TO_C_snorm16(NAME) int16_t NAME[2] THIN_GL_ALIGNED(4);    // uint (4, 4) -> float
#define THIN_GL_STRUCT_TO_C_snorm16x2(NAME) int16_t NAME[2] THIN_GL_ALIGNED(4);  // uint (4, 4) -> vec2
#define THIN_GL_STRUCT_TO_C_snorm16x3(NAME) int16_t NAME[4] THIN_GL_ALIGNED(8);  // uvec2 (8, 8) -> vec3
#define THIN_GL_STRUCT_TO_C_snorm16x4(NAME) int16_t NAME[4] THIN_GL_ALIGNED(8);  // uvec2 (8, 8) -> vec4
#define THIN_GL_STRUCT_TO_C_uint32(NAME) uint32_t NAME THIN_GL_ALIGNED(4);       // uint (4, 4) -> uint
#define THIN_GL_STRUCT_TO_C_int32(NAME) int32_t NAME THIN_GL_ALIGNED(4);         // int (4, 4) -> int
#define THIN_GL_STRUCT_TO_C_float32(NAME) float NAME THIN_GL_ALIGNED(4);         // float (4, 4) -> float
#define THIN_GL_STRUCT_TO_C_float32x2(NAME) float NAME[2] THIN_GL_ALIGNED(8);    // vec2 (8, 8) -> vec2
#define THIN_GL_STRUCT_TO_C_float32x3(NAME) float NAME[3] THIN_GL_ALIGNED(16);   // vec3 (16, 16) -> vec3
#define THIN_GL_STRUCT_TO_C_float32x4(NAME) float NAME[4] THIN_GL_ALIGNED(16);   // vec4 (16, 16) -> vec4
#define THIN_GL_STRUCT_TO_C_struct(TYPE, NAME) struct GL_##TYPE NAME;
#define THIN_GL_STRUCT_TO_C_unsized_array(TYPE)
#define THIN_GL_STRUCT_TO_C_(ITEM) ALIAS_CPP_CAT(THIN_GL_STRUCT_TO_C_, ITEM)
#define THIN_GL_STRUCT_TO_C(NAME, ...)                                                                                 \
  struct GL_##NAME {                                                                                                   \
    ALIAS_CPP_EVAL(ALIAS_CPP_MAP(THIN_GL_STRUCT_TO_C_, __VA_ARGS__))                                                   \
  };
#define THIN_GL_STRUCT_TO_GLSL_PACKED_require(NAME) "//"
#define THIN_GL_STRUCT_TO_GLSL_PACKED_unorm8(NAME) "uint " #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACKED_unorm8x2(NAME) "uint " #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACKED_unorm8x3(NAME) "uint " #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACKED_unorm8x4(NAME) "uint " #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACKED_unorm16(NAME) "uint " #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACKED_unorm16x2(NAME) "uint " #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACKED_unorm16x3(NAME) "uvec2 " #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACKED_unorm16x4(NAME) "uvec2 " #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACKED_snorm16(NAME) "uint " #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACKED_snorm16x2(NAME) "uint " #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACKED_snorm16x3(NAME) "uvec2 " #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACKED_snorm16x4(NAME) "uvec2 " #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACKED_uint32(NAME) "uint " #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACKED_int32(NAME) "int " #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACKED_float32(NAME) "float " #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACKED_float32x2(NAME) "vec2 " #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACKED_float32x3(NAME) "vec3 " #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACKED_float32x4(NAME) "vec4 " #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACKED_struct(TYPE, NAME) #TYPE "Packed " #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACKED_(ITEM) "  " ALIAS_CPP_CAT(THIN_GL_STRUCT_TO_GLSL_PACKED_, ITEM) ";\n"
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_require(NAME) "//"
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_unorm8(NAME) "float " #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_unorm8x2(NAME) "vec2 " #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_unorm8x3(NAME) "vec3 " #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_unorm8x4(NAME) "vec4 " #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_unorm16(NAME) "float " #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_unorm16x2(NAME) "vec2 " #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_unorm16x3(NAME) "vec3 " #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_unorm16x4(NAME) "vec4 " #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_snorm16(NAME) "float " #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_snorm16x2(NAME) "vec2 " #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_snorm16x3(NAME) "vec3 " #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_snorm16x4(NAME) "vec4 " #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_uint32(NAME) "uint " #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_int32(NAME) "int " #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_float32(NAME) "float " #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_float32x2(NAME) "vec2 " #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_float32x3(NAME) "vec3 " #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_float32x4(NAME) "vec4 " #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_struct(TYPE, NAME) #TYPE " " #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACKED_(ITEM) "  " ALIAS_CPP_CAT(THIN_GL_STRUCT_TO_GLSL_UNPACKED_, ITEM) ";\n"
#define THIN_GL_STRUCT_TO_GLSL_PACK_require(NAME) "//"
#define THIN_GL_STRUCT_TO_GLSL_PACK_unorm8(NAME) "packUnorm4x8(vec4(unpack." #NAME ", 0, 0, 0))"
#define THIN_GL_STRUCT_TO_GLSL_PACK_unorm8x2(NAME) "packUnorm4x8(vec4(unpack." #NAME ", 0, 0))"
#define THIN_GL_STRUCT_TO_GLSL_PACK_unorm8x3(NAME) "packUnorm4x8(vec4(unpack." #NAME ", 0))"
#define THIN_GL_STRUCT_TO_GLSL_PACK_unorm8x4(NAME) "packUnorm4x8(unpack." #NAME ")"
#define THIN_GL_STRUCT_TO_GLSL_PACK_unorm16(NAME) "packUnorm2x16(vec2(unpack." #NAME ", 0))"
#define THIN_GL_STRUCT_TO_GLSL_PACK_unorm16x2(NAME) "packUnorm2x16(unpack." #NAME ")"
#define THIN_GL_STRUCT_TO_GLSL_PACK_unorm16x3(NAME)                                                                    \
  "uvec2(packUnorm2x16(unpack." #NAME ".xy), packUnorm2x16(vec2(unpack." #NAME ".z, 0)))"
#define THIN_GL_STRUCT_TO_GLSL_PACK_unorm16x4(NAME)                                                                    \
  "uvec2(packUnorm2x16(unpack." #NAME ".xy), packUnorm2x16(unpack." #NAME ".zw))"
#define THIN_GL_STRUCT_TO_GLSL_PACK_snorm16(NAME) "packSnorm2x16(vec2(unpack." #NAME ", 0))"
#define THIN_GL_STRUCT_TO_GLSL_PACK_snorm16x2(NAME) "packSnorm2x16(unpack." #NAME ")"
#define THIN_GL_STRUCT_TO_GLSL_PACK_snorm16x3(NAME)                                                                    \
  "uvec2(packSnorm2x16(unpack." #NAME ".xy), packSnorm2x16(vec2(unpack." #NAME ".z, 0)))"
#define THIN_GL_STRUCT_TO_GLSL_PACK_snorm16x4(NAME)                                                                    \
  "uvec2(packSnorm2x16(unpack." #NAME ".xy), packSnorm2x16(unpack." #NAME ".zw))"
#define THIN_GL_STRUCT_TO_GLSL_PACK_uint32(NAME) "unpack." #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACK_int32(NAME) "unpack." #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACK_float32(NAME) "unpack." #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACK_float32x2(NAME) "unpack." #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACK_float32x3(NAME) "unpack." #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACK_float32x4(NAME) "unpack." #NAME
#define THIN_GL_STRUCT_TO_GLSL_PACK_struct(TYPE, NAME) #TYPE "_pack(unpack." #NAME ")"
#define THIN_GL_STRUCT_TO_GLSL_PACK_(ITEM) ",\n  " ALIAS_CPP_CAT(THIN_GL_STRUCT_TO_GLSL_PACK_, ITEM)
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_require(NAME) "//"
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_unorm8(NAME) "unpackUnorm4x8(pack." #NAME ").x"
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_unorm8x2(NAME) "unpackUnorm4x8(pack." #NAME ").xy"
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_unorm8x3(NAME) "unpackUnorm4x8(pack." #NAME ").xyz"
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_unorm8x4(NAME) "unpackUnorm4x8(pack." #NAME ")"
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_unorm16(NAME) "unpackUnorm2x16(pack." #NAME ").x"
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_unorm16x2(NAME) "unpackUnorm2x16(pack." #NAME ")"
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_unorm16x3(NAME)                                                                  \
  "vec3(unpackUnorm2x16(pack." #NAME ".x), unpackUnorm2x16(pack." #NAME ".y).x)"
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_unorm16x4(NAME)                                                                  \
  "vec4(unpackUnorm2x16(pack." #NAME ".x), unpackUnorm2x16(pack." #NAME ".y))"
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_snorm16(NAME) "unpackSnorm2x16(pack." #NAME ")"
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_snorm16x2(NAME) "unpackSnorm2x16(pack." #NAME ")"
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_snorm16x3(NAME)                                                                  \
  "vec3(unpackSnorm2x16(pack." #NAME ".x), unpackSnorm2x16(pack." #NAME ".y).x)"
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_snorm16x4(NAME)                                                                  \
  "vec4(unpackSnorm2x16(pack." #NAME ".x), unpackSnorm2x16(pack." #NAME ".y))"
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_uint32(NAME) "pack." #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_int32(NAME) "pack." #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_float32(NAME) "pack." #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_float32x2(NAME) "pack." #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_float32x3(NAME) "pack." #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_float32x4(NAME) "pack." #NAME
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_struct(TYPE, NAME) #TYPE "_unpack(pack." #NAME ")"
#define THIN_GL_STRUCT_TO_GLSL_UNPACK_(ITEM) ",\n  " ALIAS_CPP_CAT(THIN_GL_STRUCT_TO_GLSL_UNPACK_, ITEM)
// clang-format off
#define THIN_GL_STRUCT_TO_GLSL(NAME, ...)                                                                              \
  static const char GL_##NAME##_glsl[] =                                                                               \
    "struct " #NAME " {\n" ALIAS_CPP_EVAL(ALIAS_CPP_MAP(THIN_GL_STRUCT_TO_GLSL_UNPACKED_, __VA_ARGS__)) "};\n"         \
    "struct " #NAME "Packed {\n" ALIAS_CPP_EVAL(ALIAS_CPP_MAP(THIN_GL_STRUCT_TO_GLSL_PACKED_, __VA_ARGS__)) "};\n"     \
    #NAME "Packed " #NAME "_pack(in " #NAME " unpack) {\n"                                                             \
    "  return " #NAME "Packed(//"                                                                                      \
    ALIAS_CPP_EVAL(ALIAS_CPP_MAP(THIN_GL_STRUCT_TO_GLSL_PACK_, __VA_ARGS__))                                           \
    "  );\n"                                                                                                           \
    "}\n"                                                                                                              \
    #NAME " " #NAME "_unpack(in " #NAME "Packed pack) {\n"                                                             \
    "  return " #NAME "(//"                                                                                            \
    ALIAS_CPP_EVAL(ALIAS_CPP_MAP(THIN_GL_STRUCT_TO_GLSL_UNPACK_, __VA_ARGS__))                                         \
    "  );\n"                                                                                                           \
    "}\n";
// clang-format on
#define THIN_GL_STRUCT_TO_DESC_require(NAME) &GL_##NAME##_snippet,
#define THIN_GL_STRUCT_TO_DESC_unorm8(NAME)
#define THIN_GL_STRUCT_TO_DESC_unorm8x2(NAME)
#define THIN_GL_STRUCT_TO_DESC_unorm8x3(NAME)
#define THIN_GL_STRUCT_TO_DESC_unorm8x4(NAME)
#define THIN_GL_STRUCT_TO_DESC_unorm16(NAME)
#define THIN_GL_STRUCT_TO_DESC_unorm16x2(NAME)
#define THIN_GL_STRUCT_TO_DESC_unorm16x3(NAME)
#define THIN_GL_STRUCT_TO_DESC_unorm16x4(NAME)
#define THIN_GL_STRUCT_TO_DESC_snorm16(NAME)
#define THIN_GL_STRUCT_TO_DESC_snorm16x2(NAME)
#define THIN_GL_STRUCT_TO_DESC_snorm16x3(NAME)
#define THIN_GL_STRUCT_TO_DESC_snorm16x4(NAME)
#define THIN_GL_STRUCT_TO_DESC_uint32(NAME)
#define THIN_GL_STRUCT_TO_DESC_int32(NAME)
#define THIN_GL_STRUCT_TO_DESC_float32(NAME)
#define THIN_GL_STRUCT_TO_DESC_float32x2(NAME)
#define THIN_GL_STRUCT_TO_DESC_float32x3(NAME)
#define THIN_GL_STRUCT_TO_DESC_float32x4(NAME)
#define THIN_GL_STRUCT_TO_DESC_struct(TYPE, NAME)
#define THIN_GL_STRUCT_TO_DESC_unsized_array(TYPE)
#define THIN_GL_STRUCT_TO_DESC_(ITEM) ALIAS_CPP_CAT(THIN_GL_STRUCT_TO_DESC_, ITEM)
#define THIN_GL_STRUCT_TO_DESC(NAME, ...)                                                                              \
  struct GL_ShaderSnippet GL_##NAME##_snippet = {                                                                      \
      .requires = {ALIAS_CPP_EVAL(ALIAS_CPP_MAP(THIN_GL_STRUCT_TO_DESC_, __VA_ARGS__)) NULL},                          \
      .code = GL_##NAME##_glsl,                                                                                        \
      .structure_size = sizeof(struct GL_##NAME)};
#define THIN_GL_DECLARE_STRUCT(NAME, ...)                                                                              \
  THIN_GL_STRUCT_TO_C(NAME, __VA_ARGS__)                                                                               \
  extern struct GL_ShaderSnippet GL_##NAME##_snippet;
#define THIN_GL_IMPL_STRUCT(NAME, ...)                                                                                 \
  THIN_GL_STRUCT_TO_GLSL(NAME, __VA_ARGS__)                                                                            \
  THIN_GL_STRUCT_TO_DESC(NAME, __VA_ARGS__)
#define THIN_GL_STRUCT(NAME, ...)                                                                                      \
  THIN_GL_STRUCT_TO_C(NAME, __VA_ARGS__)                                                                               \
  THIN_GL_STRUCT_TO_GLSL(NAME, __VA_ARGS__)                                                                            \
  THIN_GL_STRUCT_TO_DESC(NAME, __VA_ARGS__)
THIN_GL_DECLARE_STRUCT(DrawArraysIndirectCommand, uint32(count), uint32(instance_count), uint32(first),
                       uint32(base_instance))
THIN_GL_DECLARE_STRUCT(DrawElementsIndirectCommand, uint32(count), uint32(instance_count), uint32(first_index),
                       uint32(base_vertex), uint32(base_instance))
THIN_GL_DECLARE_STRUCT(DispatchIndirectCommand, uint32(num_groups_x), uint32(num_groups_y), uint32(num_groups_z))
#define THIN_GL_BLOCK_TO_C(NAME, ...) THIN_GL_STRUCT_TO_C(NAME, __VA_ARGS__)
#define THIN_GL_BLOCK_TO_DESC(NAME, ...) THIN_GL_STRUCT_TO_DESC(NAME, __VA_ARGS__)
#define THIN_GL_CAT(A, ...) THIN_GL_CAT_(A, ##__VA_ARGS__)
#define THIN_GL_CAT_(A, ...) A##__VA_ARGS__
#define THIN_GL_BLOCK_TO_GLSL_require(NAME) "  //"
#define THIN_GL_BLOCK_TO_GLSL_uint32(NAME) "  uint " #NAME
#define THIN_GL_BLOCK_TO_GLSL_int32(NAME) "  int " #NAME
#define THIN_GL_BLOCK_TO_GLSL_float32(NAME) "  float " #NAME
#define THIN_GL_BLOCK_TO_GLSL_float32x2(NAME) "  vec2 " #NAME
#define THIN_GL_BLOCK_TO_GLSL_float32x3(NAME) "  vec3 " #NAME
#define THIN_GL_BLOCK_TO_GLSL_float32x4(NAME) "  vec4 " #NAME
#define THIN_GL_BLOCK_TO_GLSL_struct(TYPE, NAME) "  " #TYPE " " #NAME
#define THIN_GL_BLOCK_TO_GLSL_unsized_array(TYPE) THIN_GL_CAT(THIN_GL_BLOCK_TO_GLSL_, TYPE) "[]"
#define THIN_GL_BLOCK_TO_GLSL_(ITEM) ALIAS_CPP_CAT(THIN_GL_BLOCK_TO_GLSL_, ITEM) ";\n"
#define THIN_GL_BLOCK_TO_GLSL(NAME, ...)                                                                               \
  static const char GL_##NAME##_glsl[] =                                                                               \
      "buffer " #NAME " {\n" ALIAS_CPP_EVAL(ALIAS_CPP_MAP(THIN_GL_BLOCK_TO_GLSL_, __VA_ARGS__)) "} ";
#define THIN_GL_DECLARE_BLOCK(NAME, ...)                                                                               \
  THIN_GL_BLOCK_TO_C(NAME, __VA_ARGS__)                                                                                \
  extern struct GL_ShaderSnippet GL_##NAME##_snippet;
#define THIN_GL_IMPL_BLOCK(NAME, ...)                                                                                  \
  THIN_GL_BLOCK_TO_GLSL(NAME, __VA_ARGS__)                                                                             \
  THIN_GL_BLOCK_TO_DESC(NAME, __VA_ARGS__)
#define THIN_GL_BLOCK(NAME, ...)                                                                                       \
  THIN_GL_BLOCK_TO_C(NAME, __VA_ARGS__)                                                                                \
  THIN_GL_BLOCK_TO_GLSL(NAME, __VA_ARGS__)                                                                             \
  THIN_GL_BLOCK_TO_DESC(NAME, __VA_ARGS__)
#endif
      .flags = 0 ALIAS_CPP_EVAL(ALIAS_CPP_MAP(THIN_GL_SHADER_FLAGS_, __VA_ARGS__)),                                    \
#define THIN_GL_SHADER_CODE_flag(NAME)
#define THIN_GL_SHADER_REQUIRE_flag(NAME) 
#define THIN_GL_SHADER_FLAGS_require(NAME)
#define THIN_GL_SHADER_FLAGS_flag(NAME) | THIN_GL_SHADER_FLAG_ ## NAME
#define THIN_GL_SHADER_FLAGS_code(CODE)
#define THIN_GL_SHADER_FLAGS_string(CODE)
#define THIN_GL_SHADER_FLAGS_main(CODE)
#define THIN_GL_SHADER_FLAGS_(ITEM) ALIAS_CPP_CAT(THIN_GL_SHADER_FLAGS_, ITEM)
      .flags = 0 ALIAS_CPP_EVAL(ALIAS_CPP_MAP(THIN_GL_SNIPPET_FLAGS_, __VA_ARGS__)),                                   \
#define THIN_GL_SNIPPET_CODE_flag(NAME)
#define THIN_GL_SNIPPET_REQUIRE_flag(NAME)
#define THIN_GL_SNIPPET_FLAGS_require(NAME)
#define THIN_GL_SNIPPET_FLAGS_flag(NAME) | THIN_GL_SHADER_FLAG_ ## NAME
#define THIN_GL_SNIPPET_FLAGS_code(CODE)
#define THIN_GL_SNIPPET_FLAGS_string(CODE)
#define THIN_GL_SNIPPET_FLAGS_(ITEM) ALIAS_CPP_CAT(THIN_GL_SNIPPET_FLAGS_, ITEM)

#ifndef __GL_THIN_H__
#define __GL_THIN_H__
#include "glad.h"
#include <alias/memory.h>
#include <alias/math.h>
#include <stdbool.h>
#define THIN_GL_MAX_ATTRIBUTES 16
#define THIN_GL_MAX_BINDINGS 2
#define THIN_GL_MAX_UNIFORMS 16
#define THIN_GL_MAX_IMAGES 16
#define THIN_GL_MAX_BUFFERS 16
#define THIN_GL_VERTEX_BIT 0x01
#define THIN_GL_GEOMETRY_BIT 0x02
#define THIN_GL_TESSC_BIT 0x04
#define THIN_GL_TESSE_BIT 0x08
#define THIN_GL_FRAGMENT_BIT 0x10
#define THIN_GL_LOCAL_GROUP_SIZE_SUBGROUP_SIZE 0xFFFFFFFF
typedef void (*GL_VoidFn)(void);
// --------------------------------------------------------------------------------------------------------------------
// C to OpenGL data format
enum GL_Type {
  GL_Type_Unused,
  GL_Type_Float,
  GL_Type_Float2,
  GL_Type_Float3,
  GL_Type_Float4,
  GL_Type_Double,
  GL_Type_Double2,
  GL_Type_Double3,
  GL_Type_Double4,
  GL_Type_Int,
  GL_Type_Int2,
  GL_Type_Int3,
  GL_Type_Int4,
  GL_Type_Uint,
  GL_Type_Uint2,
  GL_Type_Uint3,
  GL_Type_Uint4,
  GL_Type_Bool,
  GL_Type_Bool2,
  GL_Type_Bool3,
  GL_Type_Bool4,
  GL_Type_Float2x2,
  GL_Type_Float3x3,
  GL_Type_Float4x4,
  GL_Type_Float2x3,
  GL_Type_Float2x4,
  GL_Type_Float3x2,
  GL_Type_Float3x4,
  GL_Type_Float4x2,
  GL_Type_Float4x3,
  GL_Type_Double2x2,
  GL_Type_Double3x3,
  GL_Type_Double4x4,
  GL_Type_Double2x3,
  GL_Type_Double2x4,
  GL_Type_Double3x2,
  GL_Type_Double3x4,
  GL_Type_Double4x2,
  GL_Type_Double4x3,
  GL_Type_Sampler1D,
  GL_Type_Sampler2D,
  GL_Type_Sampler3D,
  GL_Type_SamplerCube,
  GL_Type_Sampler1DShadow,
  GL_Type_Sampler2DShadow,
  GL_Type_Sampler1DArray,
  GL_Type_Sampler2DArray,
  GL_Type_SamplerCubeArray,
  GL_Type_Sampler1DArrayShadow,
  GL_Type_Sampler2DArrayShadow,
  GL_Type_Sampler2DMultisample,
  GL_Type_Sampler2DMultisampleArray,
  GL_Type_SamplerCubeShadow,
  GL_Type_SamplerCubeArrayShadow,
  GL_Type_SamplerBuffer,
  GL_Type_Sampler2DRect,
  GL_Type_Sampler2DRectShadow,
  GL_Type_IntSampler1D,
  GL_Type_IntSampler2D,
  GL_Type_IntSampler3D,
  GL_Type_IntSamplerCube,
  GL_Type_IntSampler1DArray,
  GL_Type_IntSampler2DArray,
  GL_Type_IntSamplerCubeMapArray,
  GL_Type_IntSampler2DMultisample,
  GL_Type_IntSampler2DMultisampleArray,
  GL_Type_IntSamplerBuffer,
  GL_Type_IntSampler2DRect,
  GL_Type_UintSampler1D,
  GL_Type_UintSampler2D,
  GL_Type_UintSampler3D,
  GL_Type_UintSamplerCube,
  GL_Type_UintSampler1DArray,
  GL_Type_UintSampler2DArray,
  GL_Type_UintSamplerCubeMapArray,
  GL_Type_UintSampler2DMultisample,
  GL_Type_UintSampler2DMultisampleArray,
  GL_Type_UintSamplerBuffer,
  GL_Type_UintSampler2DRect,
  GL_Type_Image1D,
  GL_Type_Image2D,
  GL_Type_Image3D,
  GL_Type_Image2DRect,
  GL_Type_ImageCube,
  GL_Type_ImageBuffer,
  GL_Type_Image1DArray,
  GL_Type_Image2DArray,
  GL_Type_ImageCubeArray,
  GL_Type_Image2DMultisample,
  GL_Type_Image2DMultisampleArray,
  GL_Type_IntImage1D,
  GL_Type_IntImage2D,
  GL_Type_IntImage3D,
  GL_Type_IntImage2DRect,
  GL_Type_IntImageCube,
  GL_Type_IntImageBuffer,
  GL_Type_IntImage1DArray,
  GL_Type_IntImage2DArray,
  GL_Type_IntImageCubeArray,
  GL_Type_IntImage2DMultisample,
  GL_Type_IntImage2DMultisampleArray,
  GL_Type_UintImage1D,
  GL_Type_UintImage2D,
  GL_Type_UintImage3D,
  GL_Type_UintImage2DRect,
  GL_Type_UintImageCube,
  GL_Type_UintImageBuffer,
  GL_Type_UintImage1DArray,
  GL_Type_UintImage2DArray,
  GL_Type_UintImageCubeArray,
  GL_Type_UintImage2DMultisample,
  GL_Type_UintImage2DMultisampleArray,
  GL_Type_AtomicUint,
  GL_Type_InlineStructure, // valid in THIN_GL_STRUCT and THIN_GL_BLOCK
  GL_Type_ShaderStorageBuffer
};
struct GL_UniformData {
  const void *pointer;
  GLboolean transpose;
  const struct GL_Buffer *buffer;
  union {
    float _float;
    float vec[4];
    float mat[16];
    GLint _int;
    GLint ivec[4];
    GLint imat[16];
    GLuint uint;
    GLuint uvec[4];
    GLuint umat[16];
  };
};
struct GL_ShaderSnippet {
  const struct GL_ShaderSnippet *requires[8];
  const char *code;
  /* internal */
  uint32_t structure_size;
  GLuint emit_index;
};
struct GL_Shader {
  const struct GL_ShaderSnippet *requires[8];
  const char *code;
  /* internal */
  GLuint object;
};
struct GL_ShaderResource {
  enum GL_Type type;
  const char *name;
  GLsizei count;
  union {
    struct {
      GL_VoidFn prepare;
      uint32_t prepare_draw_index;
      struct GL_UniformData data;
    } uniform;
    struct {
      struct GL_ShaderSnippet *snippet;
      union {
        struct GL_Buffer *buffer;
        struct GL_Buffer *buffers[THIN_GL_MAX_BUFFERS];
      };
    } block;
  };
};
// --------------------------------------------------------------------------------------------------------------------
// state setup for draw/compute
// - interface defined in C ensures GLSL and C expect the same thing
#define THIN_GL_PIPILINE_STATE_FIELDS                                                                                  \
  struct {                                                                                                             \
    GLbitfield stage_bits;                                                                                             \
    enum GL_Type type;                                                                                                 \
    const char *name;                                                                                                  \
    GLsizei count;                                                                                                     \
    const struct GL_ShaderSnippet *struture;                                                                           \
  } uniform[THIN_GL_MAX_UNIFORMS];                                                                                     \
  struct {                                                                                                             \
    GLbitfield stage_bits;                                                                                             \
    struct GL_ShaderResource *resource;                                                                                \
  } global[THIN_GL_MAX_UNIFORMS];                                                                                      \
  struct {                                                                                                             \
    GLbitfield stage_bits;                                                                                             \
    enum GL_Type type;                                                                                                 \
    const char *name;                                                                                                  \
  } image[THIN_GL_MAX_IMAGES];                                                                                         \
  /* internal */                                                                                                       \
  GLuint program_object;
struct GL_PipelineState {
  THIN_GL_PIPILINE_STATE_FIELDS
};
#define THIN_GL_STAGE_FIELDS                                                                                           \
  const char *source;                                                                                                  \
  /* internal */                                                                                                       \
  GLuint shader_object;
struct GL_VertexStage {
  THIN_GL_STAGE_FIELDS
  GLenum primitive;
  struct {
    GLuint binding;
    alias_memory_Format format;
    GLint size;
    const GLchar *name;
    GLuint offset;
  } attribute[THIN_GL_MAX_ATTRIBUTES];
  struct {
    GLsizei stride;
    GLuint divisor;
  } binding[THIN_GL_MAX_BINDINGS];
  // internal
  GLuint vertex_array_object;
};
struct GL_DrawState {
  THIN_GL_PIPILINE_STATE_FIELDS
  GLenum primitive;
  struct {
    GLuint binding;
    alias_memory_Format format;
    GLint size;
    const GLchar *name;
    GLuint offset;
  } attribute[THIN_GL_MAX_ATTRIBUTES];
  struct {
    GLsizei stride;
    GLuint divisor;
  } binding[THIN_GL_MAX_BINDINGS];
  const struct GL_Shader *vertex_shader;
  bool depth_test_enable;
  bool depth_mask;
  float depth_range_min;
  float depth_range_max;
  const struct GL_Shader *fragment_shader;
  bool blend_enable;
  GLenum blend_src_factor;
  GLenum blend_dst_factor;
  /* internal */
  GLuint vertex_shader_object;
  GLuint fragment_shader_object;
  GLuint vertex_array_object;
};
struct GL_ComputeState {
  THIN_GL_PIPILINE_STATE_FIELDS
  const struct GL_Shader *shader;
  GLuint local_group_x;
  GLuint local_group_y;
  GLuint local_group_z;
  /* internal */
  GLuint shader_object;
};
// --------------------------------------------------------------------------------------------------------------------
// asset
struct GL_Buffer {
  enum {
    GL_Buffer_Static,    // never changes, lives on the GPU
    GL_Buffer_Temporary, // The buffer used to send information from the CPU to GPU once
    GL_Buffer_GPU,       // only lives on the GPU
    GL_Buffer_CPU,       // A buffer persantly mapped and bound, updated by the CPU many times
  } kind;
  GLuint buffer;
  GLsizei size;
  void *mapping;
  GLintptr offset;
  bool dirty;
};
// --------------------------------------------------------------------------------------------------------------------
// asset reference collection needed for a draw/compute
#define THIN_GL_PIPILINE_ASSETS_FIELDS                                                                                 \
  GLuint image[THIN_GL_MAX_IMAGES];                                                                                    \
  struct GL_UniformData uniforms[THIN_GL_MAX_UNIFORMS];
struct GL_PipelineAssets {
  THIN_GL_PIPILINE_ASSETS_FIELDS
};
struct GL_DrawAssets {
  THIN_GL_PIPILINE_ASSETS_FIELDS
  const struct GL_Buffer *element_buffer;
  uint32_t element_buffer_offset;
  const struct GL_Buffer *vertex_buffers[THIN_GL_MAX_BINDINGS];
};
struct GL_ComputeAssets {
  THIN_GL_PIPILINE_ASSETS_FIELDS
};
// --------------------------------------------------------------------------------------------------------------------
// draw
void GL_initialize_draw_state(const struct GL_DrawState *state);
GLbitfield GL_apply_draw_state(const struct GL_DrawState *state);
GLbitfield GL_apply_draw_assets(const struct GL_DrawState *state, const struct GL_DrawAssets *assets);
void GL_draw_arrays(const struct GL_DrawState *state, const struct GL_DrawAssets *assets, GLint first, GLsizei count,
                    GLsizei instancecount, GLuint baseinstance);
void GL_draw_elements(const struct GL_DrawState *state, const struct GL_DrawAssets *assets, GLsizei count,
                      GLsizei instancecount, GLint basevertex, GLuint baseinstance);
void GL_draw_elements_indirect(const struct GL_DrawState *state, const struct GL_DrawAssets *assets,
                               const struct GL_Buffer *indirect, GLsizei indirect_offset);
// --------------------------------------------------------------------------------------------------------------------
// compute
void GL_initialize_compute_state(const struct GL_ComputeState *state);
GLbitfield GL_apply_compute_state(const struct GL_ComputeState *state);
GLbitfield GL_apply_compute_assets(const struct GL_ComputeState *state, const struct GL_ComputeAssets *assets);
void GL_compute(const struct GL_ComputeState *state, const struct GL_ComputeAssets *assets, GLuint num_groups_x,
                GLuint num_groups_y, GLuint num_groups_z);
void GL_compute_indirect(const struct GL_ComputeState *state, const struct GL_ComputeAssets *assets,
                         const struct GL_Buffer *indirect, GLsizei indirect_offset);
// --------------------------------------------------------------------------------------------------------------------
// resource data
struct GL_Buffer GL_allocate_static_buffer(GLenum type, GLsizei size, const void *data);
struct GL_Buffer GL_allocate_temporary_buffer(GLenum type, GLsizei size);
struct GL_Buffer GL_allocate_temporary_buffer_from(GLenum type, GLsizei size, const void *data);
void *GL_update_buffer_begin(const struct GL_Buffer *buffer, GLintptr offset, GLsizei size);
void GL_update_buffer_end(const struct GL_Buffer *buffer, GLintptr offset, GLsizei size);
GLbitfield GL_flush_buffer(const struct GL_Buffer *buffer, GLbitfield read_barrier_bits);
void GL_free_buffer(const struct GL_Buffer *buffer);
void GL_reset_temporary_buffers(void);
void GL_temporary_buffer_stats(GLenum type, uint32_t *total_allocated, uint32_t *used);
void GL_destroy_buffer(const struct GL_Buffer *buffer);
// --------------------------------------------------------------------------------------------------------------------
// resource
void GL_ShaderResource_prepare(const struct GL_ShaderResource *resource);
// mimic OpenGL's matrix
static inline void GL_matrix_construct(float xx, float yx, float zx, float wx, float xy, float yy, float zy, float wy,
                                       float xz, float yz, float zz, float wz, float xw, float yw, float zw, float ww,
                                       float result[16]) {
  result[0] = xx;
  result[1] = xy;
  result[2] = xz;
  result[3] = xw;
  result[4] = yx;
  result[5] = yy;
  result[6] = yz;
  result[7] = yw;
  result[8] = zx;
  result[9] = zy;
  result[10] = zz;
  result[11] = zw;
  result[12] = wx;
  result[13] = wy;
  result[14] = wz;
  result[15] = ww;
}
static inline void GL_matrix_identity(float result[16]) {
  // clang-format off
  GL_matrix_construct(
    1, 0, 0, 0,
    0, 1, 0, 0,
    0, 0, 1, 0,
    0, 0, 0, 1,
    result
  );
  // clang-format on
}
static inline void GL_matrix_translation(float x, float y, float z, float result[16]) {
  // clang-format off
  GL_matrix_construct(
    1, 0, 0, x,
    0, 1, 0, y,
    0, 0, 1, z,
    0, 0, 0, 1,
    result
  );
  // clang-format on
}
static inline void GL_matrix_rotation(float angle, float x, float y, float z, float result[16]) {
  double magnitude = sqrt(x * x + y * y + z * z);
  if(magnitude < alias_R_MIN) {
    GL_matrix_identity(result);
    return;
  }
  double one_over_magnitude = 1.0 / magnitude;
  double a = angle * 0.01745329251;
  x *= one_over_magnitude;
  y *= one_over_magnitude;
  z *= one_over_magnitude;
  double s = sin(a);
  double c = cos(a);
  double one_minus_c = 1.0 - c;
  double xs = x * s;
  double ys = y * s;
  double zs = z * s;
  double xc = x * one_minus_c;
  double yc = y * one_minus_c;
  double zc = z * one_minus_c;
  double m_xx = (xc * x) + c;
  double m_xy = (xc * y) + zs;
  double m_xz = (xc * z) - ys;
  double m_yx = (yc * x) - zs;
  double m_yy = (yc * y) + c;
  double m_yz = (yc * z) + xs;
  double m_zx = (zc * x) + ys;
  double m_zy = (zc * y) - xs;
  double m_zz = (zc * z) + c;
  // clang-format off
  GL_matrix_construct(
    m_xx, m_yx, m_zx, 0,
    m_xy, m_yy, m_zy, 0,
    m_xz, m_yz, m_zz, 0,
       0,   0,     0, 1,
    result
  );
  // clang-format on
}
static inline void GL_matrix_rotation_x(float angle, float result[16]) {
  float a = angle * 0.01745329251;
  float s = sin(a);
  float c = cos(a);
  // clang-format off
  GL_matrix_construct(
    1, 0,  0, 0,
    0, c, -s, 0,
    0, s,  c, 0,
    0, 0,  0, 1,
    result
  );
  // clang-format on
}
static inline void GL_matrix_rotation_y(float angle, float result[16]) {
  float a = angle * 0.01745329251;
  float s = sin(a);
  float c = cos(a);
  // clang-format off
  GL_matrix_construct(
     c, 0, s, 0,
     0, 1, 0, 0,
    -s, 0, c, 0,
     0, 0, 0, 1,
    result
  );
  // clang-format on
}
static inline void GL_matrix_rotation_z(float angle, float result[16]) {
  float a = angle * 0.01745329251;
  float s = sin(a);
  float c = cos(a);
  // clang-format off
  GL_matrix_construct(
    c, -s, 0, 0,
    s,  c, 0, 0,
    0,  0, 1, 0,
    0,  0, 0, 1,
    result
  );
  // clang-format on
}
static inline void GL_matrix_frustum(float left, float right, float bottom, float top, float near, float far,
                                     float result[16]) {
  float x = (2 * near) / (right - left);
  float y = (2 * near) / (top - bottom);
  float a = (right + left) / (right - left);
  float b = (top + bottom) / (top - bottom);
  float c = -(far + near) / (far - near);
  float d = -(2 * far * near) / (far - near);
  // clang-format off
  GL_matrix_construct(
      x, 0,  a,  0,
      0, y,  b,  0,
      0, 0,  c,  d,
      0, 0, -1,  0,
    result
  );
  // clang-format on
}
static inline void GL_matrix_ortho(float left, float right, float bottom, float top, float near, float far,
                                   float result[16]) {
  float x = 2 / (right - left);
  float y = 2 / (top - bottom);
  float z = -2 / (far - near);
  float a = -(right + left) / (right - left);
  float b = -(top + bottom) / (top - bottom);
  float c = -(far + near) / (far - near);
  // clang-format off
  GL_matrix_construct(
      x, 0, 0, a,
      0, y, 0, b,
      0, 0, z, c,
      0, 0, 0, 1,
    result
  );
  // clang-format on
}
static inline void GL_matrix_multiply(const float a[16], const float b[16], float result[16]) {
  float m[16];
  for(uint32_t i = 0; i < 4; i++) {
    float row[4] = {a[0 + i], a[4 + i], a[8 + i], a[12 + i]};
    // clang-format off
    m[ 0 + i] = row[0] * b[ 0 + 0] + row[1] * b[ 0 + 1] + row[2] * b[ 0 + 2] + row[3] * b[ 0 + 3];
    m[ 4 + i] = row[0] * b[ 4 + 0] + row[1] * b[ 4 + 1] + row[2] * b[ 4 + 2] + row[3] * b[ 4 + 3];
    m[ 8 + i] = row[0] * b[ 8 + 0] + row[1] * b[ 8 + 1] + row[2] * b[ 8 + 2] + row[3] * b[ 8 + 3];
    m[12 + i] = row[0] * b[12 + 0] + row[1] * b[12 + 1] + row[2] * b[12 + 2] + row[3] * b[12 + 3];
    // clang-format on
  }
  alias_memory_copy(result, sizeof(float) * 16, m, sizeof(float) * 16);
}
static inline void GL_translate(float matrix[16], float x, float y, float z) {
  float temp[16];
  GL_matrix_translation(x, y, z, temp);
  GL_matrix_multiply(matrix, temp, matrix);
}
static inline void GL_rotate(float matrix[16], float angle, float x, float y, float z) {
  float temp[16];
  GL_matrix_rotation(angle, x, y, z, temp);
  GL_matrix_multiply(matrix, temp, matrix);
}
static inline void GL_rotate_x(float matrix[16], float angle) {
  float temp[16];
  GL_matrix_rotation_x(angle, temp);
  GL_matrix_multiply(matrix, temp, matrix);
}
static inline void GL_rotate_y(float matrix[16], float angle) {
  float temp[16];
  GL_matrix_rotation_y(angle, temp);
  GL_matrix_multiply(matrix, temp, matrix);
}
static inline void GL_rotate_z(float matrix[16], float angle) {
  float temp[16];
  GL_matrix_rotation_z(angle, temp);
  GL_matrix_multiply(matrix, temp, matrix);
}
#endif
  uint32_t flags;
  uint32_t flags;
#define THIN_GL_SHADER_FLAG_SUBGROUP_ARITHMETIC 0x00000001
#define THIN_GL_SHADER_FLAG_ARITHMETIC_INT64    0x00000002

#include "gl_thin_cpp.h"
#include "gl_local.h"
THIN_GL_IMPL_STRUCT(DrawArraysIndirectCommand, uint32(count), uint32(instance_count), uint32(first),
                    uint32(base_instance))
THIN_GL_IMPL_STRUCT(DrawElementsIndirectCommand, uint32(count), uint32(instance_count), uint32(first_index),
                    uint32(base_vertex), uint32(base_instance))
THIN_GL_IMPL_STRUCT(DispatchIndirectCommand, uint32(num_groups_x), uint32(num_groups_y), uint32(num_groups_z))
struct GL_TypeInfo {
  const char *name;
  GLenum target;
};
static struct GL_TypeInfo type_info[] = {
    [GL_Type_Float] = {"float"},
    [GL_Type_Float2] = {"vec2"},
    [GL_Type_Float3] = {"vec3"},
    [GL_Type_Float4] = {"vec4"},
    [GL_Type_Int] = {"int"},
    [GL_Type_Int2] = {"ivec2"},
    [GL_Type_Int3] = {"ivec3"},
    [GL_Type_Int4] = {"ivec4"},
    [GL_Type_Uint] = {"uint"},
    [GL_Type_Uint2] = {"uvec2"},
    [GL_Type_Uint3] = {"uvec3"},
    [GL_Type_Uint4] = {"uvec4"},
    [GL_Type_Float2x2] = {"mat2"},
    [GL_Type_Float3x3] = {"mat3"},
    [GL_Type_Float4x4] = {"mat4"},
    [GL_Type_Float2x3] = {"mat2x3"},
    [GL_Type_Float3x2] = {"mat3x2"},
    [GL_Type_Float2x4] = {"mat2x4"},
    [GL_Type_Float4x2] = {"mat4x2"},
    [GL_Type_Float3x4] = {"mat3x4"},
    [GL_Type_Float4x3] = {"mat4x3"},
    [GL_Type_Sampler1D] =
        {
            .name = "sampler1D",
            .target = GL_TEXTURE_1D,
        },
    [GL_Type_Image1D] =
        {
            .name = "image1D",
            .target = GL_TEXTURE_1D,
        },
    [GL_Type_Sampler1DShadow] =
        {
            .name = "sampler1DShadow",
            .target = GL_TEXTURE_1D_ARRAY,
        },
    [GL_Type_Sampler1DArray] =
        {
            .name = "sampler1DArray",
            .target = GL_TEXTURE_1D_ARRAY,
        },
    [GL_Type_Sampler1DArrayShadow] =
        {
            .name = "sampler1DArrayShadow",
            .target = GL_TEXTURE_1D_ARRAY,
        },
    [GL_Type_Sampler2D] =
        {
            .name = "sampler2D",
            .target = GL_TEXTURE_2D,
        },
};
struct TemporaryBuffer {
  GLuint buffer;
  GLenum type;
  GLsizei size;
  GLsizei offset;
  void *mapped_memory;
};
static struct {
  uint32_t num_temporary_buffers;
  struct TemporaryBuffer *temporary_buffers;
  char *script_builder_ptr;
  uint32_t script_builder_cap;
  GLint script_builder_len;
  uint32_t draw_index;
  uint32_t emit_index;
} _ = {0, 0, 0, 0};
static void script_builder_init(void) {
  _.script_builder_len = 0;
  _.emit_index++;
}
static void script_builder_add(const char *format, ...) {
  va_list ap;
  va_start(ap, format);
  uint32_t len = vsprintf(NULL, 0, format, ap);
  va_end(ap);
  if(_.script_builder_len + len + 1 > _.script_builder_cap) {
    _.script_builder_cap = _.script_builder_len + len + 2;
    _.script_builder_cap += _.script_builder_cap >> 1;
    _.script_builder_ptr = realloc(_.script_builder_ptr, sizeof(*_.script_builder_ptr) * _.script_builder_cap);
  }
  va_start(ap, format);
  vsprintf(_.script_builder_ptr + _.script_builder_len, _.script_builder_cap - _.script_builder_len, format, ap);
  _.script_builder_len += len;
  _.script_builder_ptr[_.script_builder_len] = 0;
  va_end(ap);
}
static void script_builder_add_shader(const struct GL_ShaderSnippet *shader);
static void script_builder_add_shader_requisites(const struct GL_ShaderSnippet *shader) {
  for(uint32_t i = 0; i < 8; i++) {
    if(shader->requires[i] == NULL)
      break;
    script_builder_add_shader(shader->requires[i]);
  }
}
static void script_builder_add_shader(const struct GL_ShaderSnippet *shader) {
  if(shader->emit_index == _.emit_index)
    return;
  script_builder_add_shader_requisites(shader);
  script_builder_add("%s\n", shader->code);
  *(uint32_t *)(&shader->emit_index) = _.emit_index;
}
static void script_builder_add_vertex_format(const struct GL_DrawState *draw_state) {
  for(int i = 0; i < THIN_GL_MAX_ATTRIBUTES; i++) {
    if(draw_state->attribute[i].format == 0)
      break;
    script_builder_add("layout(location=%i) in ", i);
    const char *type_name, *vec_name;
    switch(draw_state->attribute[i].format) {
    case alias_memory_Format_Uint8:
    case alias_memory_Format_Uint16:
    case alias_memory_Format_Uint32:
    case alias_memory_Format_Uint64:
      type_name = "uint";
      vec_name = "uvec";
      break;
    case alias_memory_Format_Sint8:
    case alias_memory_Format_Sint16:
    case alias_memory_Format_Sint32:
    case alias_memory_Format_Sint64:
      type_name = "int";
      vec_name = "ivec";
      break;
    case alias_memory_Format_Unorm8:
    case alias_memory_Format_Unorm16:
    case alias_memory_Format_Snorm8:
    case alias_memory_Format_Snorm16:
    case alias_memory_Format_Uscaled8:
    case alias_memory_Format_Uscaled16:
    case alias_memory_Format_Sscaled8:
    case alias_memory_Format_Sscaled16:
    case alias_memory_Format_Urgb8:
    case alias_memory_Format_Float32:
      type_name = "float";
      vec_name = "vec";
      break;
    case alias_memory_Format_Float16:
      type_name = "half_float";
      vec_name = "hvec";
      break;
    case alias_memory_Format_Float64:
      type_name = "double";
      vec_name = "dvec";
      break;
    default:
      // TODO error
      break;
    }
    if(draw_state->attribute[i].size > 1) {
      script_builder_add("%s%i in_%s;\n", vec_name, draw_state->attribute[i].size, draw_state->attribute[i].name);
    } else {
      script_builder_add("%s in_%s;\n", type_name, draw_state->attribute[i].name);
    }
  }
}
static void script_builder_add_uniform_format(const struct GL_PipelineState *pipeline_state, GLbitfield stage_bit) {
  GLuint uniform_location = 0;
  GLuint shader_storage_buffer_binding = 0;
  GLuint location, binding;
  for(uint32_t i = 0; i < THIN_GL_MAX_UNIFORMS; i++) {
    if((stage_bit && !pipeline_state->uniform[i].stage_bits) || pipeline_state->uniform[i].type == GL_Type_Unused)
      continue;
    GLuint location = uniform_location++;
    if((pipeline_state->uniform[i].stage_bits & stage_bit) != stage_bit)
      continue;
    script_builder_add("layout(location=%i) uniform %s u_%s;\n", location,
                       type_info[pipeline_state->uniform[i].type].name, pipeline_state->uniform[i].name);
  }
  for(uint32_t i = 0; i < THIN_GL_MAX_UNIFORMS; i++) {
    if((stage_bit && !pipeline_state->global[i].stage_bits) || pipeline_state->global[i].resource == NULL)
      continue;
    uint32_t count = alias_max(pipeline_state->global[i].resource->count, 1);
    if(pipeline_state->global[i].resource->type == GL_Type_ShaderStorageBuffer) {
      binding = shader_storage_buffer_binding;
      shader_storage_buffer_binding += count;
    } else {
      location = uniform_location++;
    }
    if((pipeline_state->global[i].stage_bits & stage_bit) != stage_bit)
      continue;
    if(pipeline_state->global[i].resource->type == GL_Type_ShaderStorageBuffer) {
      script_builder_add_shader_requisites(pipeline_state->global[i].resource->block.snippet);
      script_builder_add("layout(std430, binding=%i) %s u_%s", binding,
                         pipeline_state->global[i].resource->block.snippet->code,
                         pipeline_state->global[i].resource->name);
    } else {
      script_builder_add("layout(location=%i) uniform %s u_%s", location,
                         type_info[pipeline_state->global[i].resource->type].name,
                         pipeline_state->global[i].resource->name);
    }
    if(count > 1) {
      script_builder_add("[%i];\n", count);
    } else {
      script_builder_add(";\n");
    }
  }
}
static void script_builder_add_images_format(const struct GL_PipelineState *pipeline_state, GLbitfield stage_bit) {
  for(uint32_t i = 0; i < THIN_GL_MAX_IMAGES; i++) {
    if(!(pipeline_state->image[i].stage_bits & stage_bit))
      continue;
    script_builder_add("layout(binding=%i) uniform %s u_%s;\n", i, type_info[pipeline_state->image[i].type].name,
                       pipeline_state->image[i].name);
  }
}
void gl_compileShader(GLuint shader) {
  glCompileShader(shader);
  GLint status;
  glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
  if(status != GL_TRUE) {
    GLint length;
    glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length);
    GLchar *info_log = malloc(length + 1);
    glGetShaderInfoLog(shader, length + 1, NULL, info_log);
    Com_Error(ERR_FATAL, "shader compile error: %s", info_log);
    free(info_log);
  }
}
void gl_linkProgram(GLuint program) {
  glLinkProgram(program);
  GLint status;
  glGetProgramiv(program, GL_LINK_STATUS, &status);
  if(status != GL_TRUE) {
    GLint length = 0;
    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length);
    GLchar *info_log = malloc(length + 1);
    glGetProgramInfoLog(program, length + 1, NULL, info_log);
    Com_Error(ERR_FATAL, "program link error: %s", info_log);
    free(info_log);
  }
}
void glProgram_init(struct glProgram *prog, const char *vsource, const char *fsource) {
  GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);
  GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
  glShaderSource(vertex_shader, 1, &vsource, NULL);
  glShaderSource(fragment_shader, 1, &fsource, NULL);
  gl_compileShader(vertex_shader);
  gl_compileShader(fragment_shader);
  GLuint program = glCreateProgram();
  glAttachShader(program, vertex_shader);
  glAttachShader(program, fragment_shader);
  gl_linkProgram(program);
  prog->vertex_shader = vertex_shader;
  prog->fragment_shader = fragment_shader;
  prog->program = program;
}
void GL_initialize_draw_state(const struct GL_DrawState *state) {
  if(state->vertex_shader != NULL && state->vertex_shader_object == 0) {
    script_builder_init();
    script_builder_add_prelude((const struct GL_ShaderSnippet *)state->vertex_shader);
    script_builder_add_vertex_format(state);
    script_builder_add_uniform_format((const struct GL_PipelineState *)state, THIN_GL_VERTEX_BIT);
    script_builder_add_images_format((const struct GL_PipelineState *)state, THIN_GL_VERTEX_BIT);
    script_builder_add_shader_requisites((const struct GL_ShaderSnippet *)state->vertex_shader);
    script_builder_add("%s", state->vertex_shader->code);
    GLuint shader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(shader, 1, (const char *const *)&_.script_builder_ptr, &_.script_builder_len);
    gl_compileShader(shader);
    *(GLuint *)(&state->vertex_shader_object) = shader;
  }
  if(state->fragment_shader != NULL && state->fragment_shader_object == 0) {
    script_builder_init();
    script_builder_add_prelude((const struct GL_ShaderSnippet *)state->fragment_shader);
    script_builder_add_uniform_format((const struct GL_PipelineState *)state, THIN_GL_FRAGMENT_BIT);
    script_builder_add_images_format((const struct GL_PipelineState *)state, THIN_GL_FRAGMENT_BIT);
    script_builder_add_shader_requisites((const struct GL_ShaderSnippet *)state->fragment_shader);
    script_builder_add("%s", state->fragment_shader->code);
    GLuint shader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(shader, 1, (const char *const *)&_.script_builder_ptr, &_.script_builder_len);
    gl_compileShader(shader);
    *(GLuint *)(&state->fragment_shader_object) = shader;
  }
  if(state->vertex_shader_object != 0 && state->fragment_shader_object != 0 && state->program_object == 0) {
    GLuint program = glCreateProgram();
    glAttachShader(program, state->vertex_shader_object);
    glAttachShader(program, state->fragment_shader_object);
    gl_linkProgram(program);
    *(GLuint *)(&state->program_object) = program;
  }
  if(state->attribute[0].format != 0 && state->vertex_array_object == 0) {
    GLuint vao;
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);
    for(int i = 0; i < THIN_GL_MAX_ATTRIBUTES; i++) {
      if(state->attribute[i].format == 0)
        break;
      glEnableVertexArrayAttrib(vao, i);
      switch(state->attribute[i].format) {
      case alias_memory_Format_Uint8:
        glVertexArrayAttribIFormat(vao, i, state->attribute[i].size, GL_UNSIGNED_BYTE, state->attribute[i].offset);
        break;
      case alias_memory_Format_Uint16:
        glVertexArrayAttribIFormat(vao, i, state->attribute[i].size, GL_UNSIGNED_SHORT, state->attribute[i].offset);
        break;
      case alias_memory_Format_Uint32:
        glVertexArrayAttribIFormat(vao, i, state->attribute[i].size, GL_UNSIGNED_INT, state->attribute[i].offset);
        break;
      case alias_memory_Format_Uint64:
        //
        break;
      case alias_memory_Format_Sint8:
        glVertexArrayAttribIFormat(vao, i, state->attribute[i].size, GL_BYTE, state->attribute[i].offset);
        break;
      case alias_memory_Format_Sint16:
        glVertexArrayAttribIFormat(vao, i, state->attribute[i].size, GL_SHORT, state->attribute[i].offset);
        break;
      case alias_memory_Format_Sint32:
        glVertexArrayAttribIFormat(vao, i, state->attribute[i].size, GL_INT, state->attribute[i].offset);
        break;
      case alias_memory_Format_Sint64:
        //
        break;
      case alias_memory_Format_Unorm8:
        glVertexArrayAttribFormat(vao, i, state->attribute[i].size, GL_UNSIGNED_BYTE, GL_TRUE,
                                  state->attribute[i].offset);
        break;
      case alias_memory_Format_Unorm16:
        glVertexArrayAttribFormat(vao, i, state->attribute[i].size, GL_UNSIGNED_SHORT, GL_TRUE,
                                  state->attribute[i].offset);
        break;
      case alias_memory_Format_Snorm8:
        glVertexArrayAttribFormat(vao, i, state->attribute[i].size, GL_BYTE, GL_TRUE, state->attribute[i].offset);
        break;
      case alias_memory_Format_Snorm16:
        glVertexArrayAttribFormat(vao, i, state->attribute[i].size, GL_SHORT, GL_TRUE, state->attribute[i].offset);
        break;
      case alias_memory_Format_Uscaled8:
        glVertexArrayAttribFormat(vao, i, state->attribute[i].size, GL_UNSIGNED_BYTE, GL_FALSE,
                                  state->attribute[i].offset);
        break;
      case alias_memory_Format_Uscaled16:
        glVertexArrayAttribFormat(vao, i, state->attribute[i].size, GL_UNSIGNED_SHORT, GL_FALSE,
                                  state->attribute[i].offset);
        break;
      case alias_memory_Format_Sscaled8:
        glVertexArrayAttribFormat(vao, i, state->attribute[i].size, GL_BYTE, GL_FALSE, state->attribute[i].offset);
        break;
      case alias_memory_Format_Sscaled16:
        glVertexArrayAttribFormat(vao, i, state->attribute[i].size, GL_SHORT, GL_FALSE, state->attribute[i].offset);
        break;
      case alias_memory_Format_Urgb8:
        //
        break;
      case alias_memory_Format_Float16:
        glVertexArrayAttribFormat(vao, i, state->attribute[i].size, GL_HALF_FLOAT, GL_FALSE,
                                  state->attribute[i].offset);
        break;
      case alias_memory_Format_Float32:
        glVertexArrayAttribFormat(vao, i, state->attribute[i].size, GL_FLOAT, GL_FALSE, state->attribute[i].offset);
        break;
      case alias_memory_Format_Float64:
        glVertexArrayAttribLFormat(vao, i, state->attribute[i].size, GL_DOUBLE, state->attribute[i].offset);
        break;
      default:
        // TODO error
        break;
      }
      glVertexArrayAttribBinding(vao, i, state->attribute[i].binding);
    }
    *(GLuint *)(&state->vertex_array_object) = vao;
  }
}
static GLbitfield apply_pipeline_state(const struct GL_PipelineState *state) {
  static struct GL_PipelineState current_pipeline_state;
  if(current_pipeline_state.program_object != state->program_object) {
    glUseProgram(state->program_object);
    current_pipeline_state.program_object = state->program_object;
  }
  return 0;
}
GLbitfield GL_apply_draw_state(const struct GL_DrawState *state) {
  static struct GL_DrawState current_draw_state;
  GLbitfield barriers = apply_pipeline_state((const struct GL_PipelineState *)state);
  if(current_draw_state.vertex_array_object != state->vertex_array_object) {
    glBindVertexArray(state->vertex_array_object);
    current_draw_state.vertex_array_object = state->vertex_array_object;
  }
  if(current_draw_state.depth_test_enable != state->depth_test_enable) {
    if(state->depth_test_enable) {
      glEnable(GL_DEPTH_TEST);
      current_draw_state.depth_test_enable = true;
    } else {
      glDisable(GL_DEPTH_TEST);
      current_draw_state.depth_test_enable = false;
    }
  }
  if(current_draw_state.depth_mask != state->depth_mask) {
    if(state->depth_mask) {
      glDepthMask(GL_TRUE);
      current_draw_state.depth_mask = true;
    } else {
      glDepthMask(GL_FALSE);
      current_draw_state.depth_mask = false;
    }
  }
  if(current_draw_state.depth_range_min != state->depth_range_min ||
     current_draw_state.depth_range_max != state->depth_range_max) {
    glDepthRange(state->depth_range_min, state->depth_range_max);
    current_draw_state.depth_range_min = state->depth_range_min;
    current_draw_state.depth_range_max = state->depth_range_max;
  }
  if(state->blend_enable) {
    if(!current_draw_state.blend_enable || current_draw_state.blend_src_factor != state->blend_src_factor ||
       current_draw_state.blend_dst_factor != state->blend_dst_factor) {
      glEnable(GL_BLEND);
      glBlendFunc(state->blend_src_factor, state->blend_dst_factor);
      current_draw_state.blend_enable = true;
      current_draw_state.blend_src_factor = state->blend_src_factor;
      current_draw_state.blend_dst_factor = state->blend_dst_factor;
    }
  } else if(current_draw_state.blend_enable) {
    glDisable(GL_BLEND);
    current_draw_state.blend_enable = false;
  }
  return barriers;
}
static inline void GL_apply_uniform(GLuint location, enum GL_Type type, GLsizei count,
                                    const struct GL_UniformData *data) {
  count = count || 1;
  if(data->pointer) {
    switch(type) {
    case GL_Type_Unused:
      break;
    case GL_Type_Float:
      glUniform1fv(location, count, data->pointer);
      break;
    case GL_Type_Float2:
      glUniform2fv(location, count, data->pointer);
      break;
    case GL_Type_Float3:
      glUniform3fv(location, count, data->pointer);
      break;
    case GL_Type_Float4:
      glUniform4fv(location, count, data->pointer);
      break;
    case GL_Type_Int:
      glUniform1iv(location, count, data->pointer);
      break;
    case GL_Type_Int2:
      glUniform2iv(location, count, data->pointer);
      break;
    case GL_Type_Int3:
      glUniform3iv(location, count, data->pointer);
      break;
    case GL_Type_Int4:
      glUniform4iv(location, count, data->pointer);
      break;
    case GL_Type_Uint:
      glUniform1uiv(location, count, data->pointer);
      break;
    case GL_Type_Uint2:
      glUniform2uiv(location, count, data->pointer);
      break;
    case GL_Type_Uint3:
      glUniform3uiv(location, count, data->pointer);
      break;
    case GL_Type_Uint4:
      glUniform4uiv(location, count, data->pointer);
      break;
    case GL_Type_Float2x2:
      glUniformMatrix2fv(location, count, data->transpose, data->pointer);
      break;
    case GL_Type_Float3x3:
      glUniformMatrix3fv(location, count, data->transpose, data->pointer);
      break;
    case GL_Type_Float4x4:
      glUniformMatrix4fv(location, count, data->transpose, data->pointer);
      break;
    case GL_Type_Float2x3:
      glUniformMatrix2x3fv(location, count, data->transpose, data->pointer);
      break;
    case GL_Type_Float3x2:
      glUniformMatrix3x2fv(location, count, data->transpose, data->pointer);
      break;
    case GL_Type_Float2x4:
      glUniformMatrix2x4fv(location, count, data->transpose, data->pointer);
      break;
    case GL_Type_Float4x2:
      glUniformMatrix4x2fv(location, count, data->transpose, data->pointer);
      break;
    case GL_Type_Float3x4:
      glUniformMatrix3x4fv(location, count, data->transpose, data->pointer);
      break;
    case GL_Type_Float4x3:
      glUniformMatrix4x3fv(location, count, data->transpose, data->pointer);
      break;
    default:
      // TODO error
      break;
    }
  } else {
    switch(type) {
    case GL_Type_Unused:
      break;
    case GL_Type_Float:
      glUniform1f(location, data->_float);
      break;
    case GL_Type_Float2:
      glUniform2f(location, data->vec[0], data->vec[1]);
      break;
    case GL_Type_Float3:
      glUniform3f(location, data->vec[0], data->vec[1], data->vec[2]);
      break;
    case GL_Type_Float4:
      glUniform4f(location, data->vec[0], data->vec[1], data->vec[2], data->vec[3]);
      break;
    case GL_Type_Int:
      glUniform1i(location, data->_int);
      break;
    case GL_Type_Int2:
      glUniform2i(location, data->ivec[0], data->ivec[1]);
      break;
    case GL_Type_Int3:
      glUniform3i(location, data->ivec[0], data->ivec[1], data->ivec[2]);
      break;
    case GL_Type_Int4:
      glUniform4i(location, data->ivec[0], data->ivec[1], data->ivec[2], data->ivec[3]);
      break;
    case GL_Type_Uint:
      glUniform1ui(location, data->uint);
      break;
    case GL_Type_Uint2:
      glUniform2ui(location, data->uvec[0], data->uvec[1]);
      break;
    case GL_Type_Uint3:
      glUniform3ui(location, data->uvec[0], data->uvec[1], data->uvec[2]);
      break;
    case GL_Type_Uint4:
      glUniform4ui(location, data->uvec[0], data->uvec[1], data->uvec[2], data->uvec[3]);
      break;
    case GL_Type_Float2x2:
      glUniformMatrix2fv(location, count, data->transpose, data->mat);
      break;
    case GL_Type_Float3x3:
      glUniformMatrix3fv(location, count, data->transpose, data->mat);
      break;
    case GL_Type_Float4x4:
      glUniformMatrix4fv(location, count, data->transpose, data->mat);
      break;
    case GL_Type_Float2x3:
      glUniformMatrix2x3fv(location, count, data->transpose, data->mat);
      break;
    case GL_Type_Float3x2:
      glUniformMatrix3x2fv(location, count, data->transpose, data->mat);
      break;
    case GL_Type_Float2x4:
      glUniformMatrix2x4fv(location, count, data->transpose, data->mat);
      break;
    case GL_Type_Float4x2:
      glUniformMatrix4x2fv(location, count, data->transpose, data->mat);
      break;
    case GL_Type_Float3x4:
      glUniformMatrix3x4fv(location, count, data->transpose, data->mat);
      break;
    case GL_Type_Float4x3:
      glUniformMatrix4x3fv(location, count, data->transpose, data->mat);
      break;
    default:
      // TODO error
      break;
    }
  }
}
static inline GLbitfield apply_pipeline_assets(const struct GL_PipelineState *state,
                                               const struct GL_PipelineAssets *assets, bool compute) {
  static struct GL_PipelineAssets current_assets;
  GLuint uniform_location = 0;
  GLuint shader_storage_buffer_binding = 0;
  GLuint location, binding;
  GLbitfield barriers = 0;
  for(uint32_t i = 0; i < THIN_GL_MAX_IMAGES; i++) {
    if(assets != NULL && assets->image[i]) {
      if(current_assets.image[i] != assets->image[i]) {
        if(type_info[state->image[i].type].target == GL_SAMPLER) {
          glBindSampler(i, assets->image[i]);
        } else {
          glActiveTexture(GL_TEXTURE0 + i);
          glBindTexture(type_info[state->image[i].type].target, assets->image[i]);
        }
      } else {
        glActiveTexture(GL_TEXTURE0 + i);
        glBindTexture(GL_TEXTURE_2D, assets->image[i]);
      }
      current_assets.image[i] = assets->image[i];
    }
  }
  for(uint32_t i = 0; i < THIN_GL_MAX_UNIFORMS; i++) {
    if((!compute && !state->uniform[i].stage_bits) || state->uniform[i].type == GL_Type_Unused)
      continue;
    GLuint location = uniform_location++;
    if(assets != NULL)
      GL_apply_uniform(location, state->uniform[i].type, state->uniform[i].count, &assets->uniforms[i]);
  }
  for(uint32_t i = 0; i < THIN_GL_MAX_UNIFORMS; i++) {
    if((!compute && !state->global[i].stage_bits) || state->global[i].resource == NULL)
      continue;
    uint32_t count = alias_max(state->global[i].resource->count, 1);
    if(state->global[i].resource->type == GL_Type_ShaderStorageBuffer) {
      binding = shader_storage_buffer_binding;
      shader_storage_buffer_binding += count;
    } else {
      location = uniform_location++;
    }
    if(state->global[i].resource->type == GL_Type_ShaderStorageBuffer) {
      if(count > 1) {
        for(uint32_t j = 0; j < count; j++) {
          barriers |= GL_flush_buffer(state->global[i].resource->block.buffers[j], GL_SHADER_STORAGE_BARRIER_BIT);
          glBindBufferBase(GL_SHADER_STORAGE_BUFFER, binding + j, state->global[i].resource->block.buffers[j]->buffer);
        }
      } else {
        barriers |= GL_flush_buffer(state->global[i].resource->block.buffer, GL_SHADER_STORAGE_BARRIER_BIT);
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, binding, state->global[i].resource->block.buffer->buffer);
      }
    } else {
      GL_ShaderResource_prepare(state->global[i].resource);
      GL_apply_uniform(location, state->global[i].resource->type, state->global[i].resource->count,
                       &state->global[i].resource->uniform.data);
    }
  }
  return barriers;
}
GLbitfield GL_apply_draw_assets(const struct GL_DrawState *state, const struct GL_DrawAssets *assets) {
  // static struct GL_DrawAssets current_draw_assets;
  GLbitfield barriers =
      apply_pipeline_assets((const struct GL_PipelineState *)state, (const struct GL_PipelineAssets *)assets, false);
  if(assets != NULL) {
    if(assets->element_buffer != NULL) {
      barriers |= GL_flush_buffer(assets->element_buffer, GL_ELEMENT_ARRAY_BARRIER_BIT);
      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, assets->element_buffer->buffer);
    }
    for(int i = 0; i < THIN_GL_MAX_BINDINGS; i++) {
      if(assets->vertex_buffers[i] == NULL)
        break;
      barriers |= GL_flush_buffer(assets->vertex_buffers[i], GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT);
      if(assets->vertex_buffers[i]->kind == GL_Buffer_Temporary) {
        glBindVertexBuffer(i, assets->vertex_buffers[i]->buffer, assets->vertex_buffers[i]->offset,
                           state->binding[i].stride);
      } else {
        glBindVertexBuffer(i, assets->vertex_buffers[i]->buffer, 0, state->binding[i].stride);
      }
    }
  }
  return barriers;
}
static void apply_barriers(GLbitfield barriers) {
  if(barriers)
    glMemoryBarrier(barriers);
}
void GL_draw_arrays(const struct GL_DrawState *state, const struct GL_DrawAssets *assets, GLint first, GLsizei count,
                    GLsizei instancecount, GLuint baseinstance) {
  GL_initialize_draw_state(state);
  GLbitfield barriers = GL_apply_draw_state(state);
  barriers |= GL_apply_draw_assets(state, assets);
  apply_barriers(barriers);
  glDrawArraysInstancedBaseInstance(state->primitive, first, count, instancecount, baseinstance);
  _.draw_index++;
}
void GL_draw_elements(const struct GL_DrawState *state, const struct GL_DrawAssets *assets, GLsizei count,
                      GLsizei instancecount, GLint basevertex, GLuint baseinstance) {
  GL_initialize_draw_state(state);
  GLbitfield barriers = GL_apply_draw_state(state);
  barriers |= GL_apply_draw_assets(state, assets);
  apply_barriers(barriers);
  glDrawElementsInstancedBaseVertexBaseInstance(
      state->primitive, count, GL_UNSIGNED_INT,
      (void *)(assets->element_buffer->kind == GL_Buffer_Temporary ? assets->element_buffer->offset : 0) +
          sizeof(uint32_t) * assets->element_buffer_offset,
      instancecount, basevertex, baseinstance);
  _.draw_index++;
}
void GL_draw_elements_indirect(const struct GL_DrawState *state, const struct GL_DrawAssets *assets,
                               const struct GL_Buffer *indirect, GLsizei indirect_offset) {
  GL_initialize_draw_state(state);
  GLbitfield barriers = GL_apply_draw_state(state);
  barriers |= GL_apply_draw_assets(state, assets);
  barriers |= GL_flush_buffer(indirect, GL_COMMAND_BARRIER_BIT);
  apply_barriers(barriers);
  glBindBuffer(GL_DRAW_INDIRECT_BUFFER, indirect->buffer);
  glDrawElementsIndirect(state->primitive, GL_UNSIGNED_INT, (const void *)(uintptr_t)indirect_offset);
  _.draw_index++;
}
struct GL_Buffer GL_allocate_static_buffer(GLenum type, GLsizei size, const void *data) {
  struct GL_Buffer result;
  result.kind = GL_Buffer_Static;
  glCreateBuffers(1, &result.buffer);
  glNamedBufferStorage(result.buffer, size, data, 0);
  result.size = size;
  return result;
}
struct GL_Buffer GL_allocate_temporary_buffer(GLenum type, GLsizei size) {
again:
  for(uint32_t i = 0; i < _.num_temporary_buffers; i++) {
    if(_.temporary_buffers[i].type == type && _.temporary_buffers[i].size - _.temporary_buffers[i].offset > size) {
      struct GL_Buffer result;
      result.kind = GL_Buffer_Temporary;
      result.buffer = _.temporary_buffers[i].buffer;
      result.size = size;
      result.mapping = (void *)((GLbyte *)_.temporary_buffers[i].mapped_memory + _.temporary_buffers[i].offset);
      result.offset = _.temporary_buffers[i].offset;
      result.dirty = true;
      _.temporary_buffers[i].offset += size;
      return result;
    }
  }
  // 16 << 20); // 16mb TODO make a cvar
  GLsizei block_size = 4 << 20;
  GLsizei allocation_size = ((size + block_size) / block_size) * block_size;
  _.temporary_buffers = realloc(_.temporary_buffers, sizeof(*_.temporary_buffers) * (_.num_temporary_buffers + 1));
  glCreateBuffers(1, &_.temporary_buffers[_.num_temporary_buffers].buffer);
  glNamedBufferStorage(_.temporary_buffers[_.num_temporary_buffers].buffer, allocation_size, NULL,
                       GL_MAP_PERSISTENT_BIT | GL_MAP_WRITE_BIT);
  _.temporary_buffers[_.num_temporary_buffers].type = type;
  _.temporary_buffers[_.num_temporary_buffers].size = allocation_size;
  _.temporary_buffers[_.num_temporary_buffers].offset = 0;
  _.temporary_buffers[_.num_temporary_buffers].mapped_memory =
      glMapNamedBufferRange(_.temporary_buffers[_.num_temporary_buffers].buffer, 0, allocation_size,
                            GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
  _.num_temporary_buffers++;
  goto again;
}
struct GL_Buffer GL_allocate_temporary_buffer_from(GLenum type, GLsizei size, const void *ptr) {
  struct GL_Buffer result = GL_allocate_temporary_buffer(type, size);
  memcpy(result.mapping, ptr, size);
  return result;
}
static void activate_buffer(const struct GL_Buffer *buffer) {
  if(buffer->buffer != 0)
    return;
  switch(buffer->kind) {
  case GL_Buffer_Static:
    break;
  case GL_Buffer_Temporary:
    break;
  case GL_Buffer_CPU:
    glCreateBuffers(1, (GLuint *)&buffer->buffer);
    glNamedBufferStorage(buffer->buffer, buffer->size, NULL, GL_MAP_PERSISTENT_BIT | GL_MAP_WRITE_BIT);
    *(void **)&buffer->mapping = glMapNamedBufferRange(
        buffer->buffer, 0, buffer->size, GL_MAP_PERSISTENT_BIT | GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
    break;
  case GL_Buffer_GPU:
    glCreateBuffers(1, (GLuint *)&buffer->buffer);
    glNamedBufferStorage(buffer->buffer, buffer->size, NULL, 0);
    break;
  }
}
void *GL_update_buffer_begin(const struct GL_Buffer *buffer, GLintptr offset, GLsizei size) {
  (void)offset;
  (void)size;
  if(buffer->kind == GL_Buffer_CPU) {
    activate_buffer(buffer);
    return buffer->mapping;
  }
  return NULL;
}
void GL_update_buffer_end(const struct GL_Buffer *buffer, GLintptr offset, GLsizei size) {
  if(buffer->kind == GL_Buffer_CPU) {
    glFlushMappedNamedBufferRange(buffer->buffer, offset, size);
    *(bool *)&buffer->dirty = true;
  }
}
GLbitfield GL_flush_buffer(const struct GL_Buffer *buffer, GLbitfield read_barrier_bits) {
  switch(buffer->kind) {
  case GL_Buffer_Static:
    break;
  case GL_Buffer_Temporary:
    if(buffer->dirty) {
      glFlushMappedNamedBufferRange(buffer->buffer, buffer->offset, buffer->size);
      *(bool *)&buffer->dirty = false;
      return GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT;
    }
    break;
  case GL_Buffer_CPU:
    activate_buffer(buffer);
    if(buffer->dirty) {
      *(bool *)&buffer->dirty = false;
      return GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT;
    }
    break;
  case GL_Buffer_GPU:
    activate_buffer(buffer);
    if(buffer->dirty) {
      *(bool *)&buffer->dirty = false;
      return read_barrier_bits;
    }
    break;
  }
  return 0;
}
void GL_free_buffer(const struct GL_Buffer *buffer) {
  switch(buffer->kind) {
  case GL_Buffer_Static:
    glDeleteBuffers(1, &buffer->buffer);
    break;
  case GL_Buffer_GPU:
  case GL_Buffer_CPU:
    break;
  case GL_Buffer_Temporary:
    break;
  }
}
void GL_reset_temporary_buffers(void) {
  for(uint32_t i = 0; i < _.num_temporary_buffers; i++) {
    _.temporary_buffers[i].offset = 0;
  }
}
void GL_temporary_buffer_stats(GLenum type, uint32_t *total_allocated, uint32_t *used) {
  *total_allocated = 0;
  *used = 0;
  for(uint32_t i = 0; i < _.num_temporary_buffers; i++) {
    if(_.temporary_buffers[i].type == type) {
      *total_allocated += _.temporary_buffers[i].size;
      *used += _.temporary_buffers[i].offset;
    }
  }
}
void GL_ShaderResource_prepare(const struct GL_ShaderResource *resource) {
  if(resource->uniform.prepare_draw_index != _.draw_index) {
    *(uint32_t *)&resource->uniform.prepare_draw_index = _.draw_index;
    if(resource->uniform.prepare != NULL) {
      resource->uniform.prepare();
    }
  }
}
#ifndef GL_SUBGROUP_SIZE
#define GL_SUBGROUP_SIZE 0x9532
#endif
void GL_initialize_compute_state(const struct GL_ComputeState *state) {
  if(state->shader != NULL && state->shader_object == 0) {
    script_builder_init();
    script_builder_add_prelude((const struct GL_ShaderSnippet *)state->shader);
    if(state->local_group_x == THIN_GL_LOCAL_GROUP_SIZE_SUBGROUP_SIZE) {
      glGetIntegerv(GL_SUBGROUP_SIZE, (GLint *)&state->local_group_x);
    }
    if(state->local_group_y == THIN_GL_LOCAL_GROUP_SIZE_SUBGROUP_SIZE) {
      glGetIntegerv(GL_SUBGROUP_SIZE, (GLint *)&state->local_group_y);
    }
    if(state->local_group_z == THIN_GL_LOCAL_GROUP_SIZE_SUBGROUP_SIZE) {
      glGetIntegerv(GL_SUBGROUP_SIZE, (GLint *)&state->local_group_z);
    }
    script_builder_add("layout(local_size_x=%i, local_size_y=%i, local_size_z=%i) in;\n",
                       alias_max(state->local_group_x, 1), alias_max(state->local_group_y, 1),
                       alias_max(state->local_group_z, 1));
    script_builder_add_uniform_format((const struct GL_PipelineState *)state, 0);
    script_builder_add_images_format((const struct GL_PipelineState *)state, 0);
    script_builder_add_shader_requisites((const struct GL_ShaderSnippet *)state->shader);
    script_builder_add("%s", state->shader->code);
    GLuint shader = glCreateShader(GL_COMPUTE_SHADER);
    glShaderSource(shader, 1, (const char *const *)&_.script_builder_ptr, &_.script_builder_len);
    gl_compileShader(shader);
    *(GLuint *)(&state->shader_object) = shader;
  }
  if(state->shader_object != 0 && state->program_object == 0) {
    GLuint program = glCreateProgram();
    glAttachShader(program, state->shader_object);
    gl_linkProgram(program);
    *(GLuint *)(&state->program_object) = program;
  }
}
GLbitfield GL_apply_compute_state(const struct GL_ComputeState *state) {
  return apply_pipeline_state((const struct GL_PipelineState *)state);
}
GLbitfield GL_apply_compute_assets(const struct GL_ComputeState *state, const struct GL_ComputeAssets *assets) {
  //static struct GL_ComputeAssets current_compute_assets;
  GLbitfield barriers =
      apply_pipeline_assets((const struct GL_PipelineState *)state, (const struct GL_PipelineAssets *)assets, true);
  if(assets != NULL) {
  }
  return barriers;
}
void GL_compute(const struct GL_ComputeState *state, const struct GL_ComputeAssets *assets, GLuint num_groups_x,
                GLuint num_groups_y, GLuint num_groups_z) {
  GL_initialize_compute_state(state);
  GLbitfield barriers = GL_apply_compute_state(state);
  barriers |= GL_apply_compute_assets(state, assets);
  apply_barriers(barriers);
  glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
}
void GL_compute_indirect(const struct GL_ComputeState *state, const struct GL_ComputeAssets *assets,
                         const struct GL_Buffer *indirect, GLsizei indirect_offset) {
  GL_initialize_compute_state(state);
  GLbitfield barriers = GL_apply_compute_state(state);
  barriers |= GL_apply_compute_assets(state, assets);
  barriers |= GL_flush_buffer(indirect, GL_COMMAND_BARRIER_BIT);
  apply_barriers(barriers);
  glBindBuffer(GL_DISPATCH_INDIRECT_BUFFER, indirect->buffer);
  glDispatchComputeIndirect(indirect_offset);
}
    printf("%.*s\n", _.script_builder_len, _.script_builder_ptr);
  script_builder_add("#define _Bool bool\n");
  }
}
static uint32_t script_builder_collect_flags(const struct GL_ShaderSnippet *shader) {
  uint32_t flags = shader->flags;
  for(uint32_t i = 0; i < 8; i++) {
    if(shader->requires[i] == NULL)
      break;
    flags |= script_builder_collect_flags(shader->requires[i]);
  }
  return flags;
}
static void script_builder_add_prelude(const struct GL_ShaderSnippet *shader) {
  uint32_t flags = script_builder_collect_flags(shader);
  script_builder_add("#version 460 core\n");
  if(flags & THIN_GL_SHADER_FLAG_SUBGROUP_ARITHMETIC) {
    script_builder_add("#extension GL_KHR_shader_subgroup_arithmetic : enable\n");
  }
  if(flags & THIN_GL_SHADER_FLAG_ARITHMETIC_INT64) {
    script_builder_add("#extension GL_EXT_shader_explicit_arithmetic_types_int64 : enable\n");

#include "gl_thin.h"

THIN_GL_SHADER(vertex,

ALIAS_GL_SHADER(vertex,

THIN_GL_SHADER(fragment,

ALIAS_GL_SHADER(fragment,

static struct GL_DrawState draw_state = {.primitive = GL_TRIANGLES,

static struct alias_gl_DrawState draw_state = {.primitive = GL_TRIANGLES,

                                         .uniform[0] = {THIN_GL_FRAGMENT_BIT, GL_Type_Float, "alpha"},
                                         .global[0] = {THIN_GL_VERTEX_BIT, &u_view_projection_matrix},
                                         .image[0] = {THIN_GL_FRAGMENT_BIT, GL_Type_Sampler2D, "img"},

                                         .uniform[0] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_float, "alpha"},
                                         .global[0] = {ALIAS_GL_VERTEX_BIT, &u_view_projection_matrix},
                                         .image[0] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_sampler2D, "img"},

  struct GL_Buffer element_buffer =
      GL_allocate_temporary_buffer_from(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32_t) * 6, indexes);
  struct GL_Buffer vertex_buffer =
      GL_allocate_temporary_buffer_from(GL_ARRAY_BUFFER, sizeof(struct DrawVertex) * 4, vertexes);

  struct alias_gl_Buffer element_buffer =
      alias_gl_allocateTemporaryBufferFrom(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32_t) * 6, indexes);
  struct alias_gl_Buffer vertex_buffer =
      alias_gl_allocateTemporaryBufferFrom(GL_ARRAY_BUFFER, sizeof(struct DrawVertex) * 4, vertexes);

  GL_draw_elements(&draw_state,
                   &(struct GL_DrawAssets){.image[0] = model->skins[e->frame]->texnum,

  alias_gl_drawElements(&draw_state,
                   &(struct alias_gl_DrawAssets){.image[0] = model->skins[e->frame]->texnum,

#include "gl_thin.h"

THIN_GL_SHADER(vertex,

ALIAS_GL_SHADER(vertex,

THIN_GL_SHADER(fragment,

ALIAS_GL_SHADER(fragment,

static struct GL_DrawState draw_state = {.primitive = GL_TRIANGLES,

static struct alias_gl_DrawState draw_state = {.primitive = GL_TRIANGLES,

                                         .image[0] = {THIN_GL_FRAGMENT_BIT, GL_Type_Sampler2D, "sky_map"},
                                         .global[0] = {THIN_GL_VERTEX_BIT, &u_model_view_projection_matrix},

                                         .image[0] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_sampler2D, "sky_map"},
                                         .global[0] = {ALIAS_GL_VERTEX_BIT, &u_model_view_projection_matrix},

static struct GL_Buffer vertex_buffer;
static struct GL_Buffer index_buffer;

static struct alias_gl_Buffer vertex_buffer;
static struct alias_gl_Buffer index_buffer;

  GL_matrix_translation(r_origin[0], r_origin[1], r_origin[2], u_model_matrix.uniform.data.mat);
  GL_rotate(u_model_matrix.uniform.data.mat, r_newrefdef.time * sky[cmodel_index].rotate, sky[cmodel_index].axis[0],

  alias_matrix_translation(r_origin[0], r_origin[1], r_origin[2], u_model_matrix.uniform.data.mat);
  alias_rotate(u_model_matrix.uniform.data.mat, r_newrefdef.time * sky[cmodel_index].rotate, sky[cmodel_index].axis[0],

    GL_draw_elements(&draw_state,
                     &(struct GL_DrawAssets){.element_buffer = &index_buffer,

    alias_gl_drawElements(&draw_state,
                     &(struct alias_gl_DrawAssets){.element_buffer = &index_buffer,

    index_buffer = GL_allocate_static_buffer(GL_ELEMENT_ARRAY_BUFFER, sizeof(index_data), index_data);
    vertex_buffer = GL_allocate_static_buffer(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data);

    index_buffer = alias_gl_allocateStaticBuffer(GL_ELEMENT_ARRAY_BUFFER, sizeof(index_data), index_data);
    vertex_buffer = alias_gl_allocateStaticBuffer(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data);

#include "gl_thin.h"

THIN_GL_SHADER(bsp_vertex,

ALIAS_GL_SHADER(bsp_vertex,

THIN_GL_SHADER(bsp_fragment,

ALIAS_GL_SHADER(bsp_fragment,

THIN_GL_SHADER(bsp_turbulent_fragment,

ALIAS_GL_SHADER(bsp_turbulent_fragment,

  .uniform[0] = {THIN_GL_FRAGMENT_BIT, GL_Type_Float3, "tangent"},                                                     \
  .uniform[1] = {THIN_GL_FRAGMENT_BIT, GL_Type_Float3, "bitangent"},                                                   \
  .uniform[2] = {THIN_GL_FRAGMENT_BIT, GL_Type_Float3, "normal"},                                                      \
  .uniform[3] = {THIN_GL_FRAGMENT_BIT, GL_Type_Float2, "alpha_time"},                                                  \
  .global[0] = {THIN_GL_VERTEX_BIT, &u_model_view_projection_matrix}

  .uniform[0] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_float3, "tangent"},                                                     \
  .uniform[1] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_float3, "bitangent"},                                                   \
  .uniform[2] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_float3, "normal"},                                                      \
  .uniform[3] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_float2, "alpha_time"},                                                  \
  .global[0] = {ALIAS_GL_VERTEX_BIT, &u_model_view_projection_matrix}

  .image[0] = {THIN_GL_FRAGMENT_BIT, GL_Type_Sampler2D, "albedo_map"},                                                 \
  .image[1] = {THIN_GL_FRAGMENT_BIT, GL_Type_Sampler2D, "normal_map"},                                                 \
  .image[3] = {THIN_GL_FRAGMENT_BIT, GL_Type_Sampler2D, "lightmap_rgb0"},                                              \
  .image[4] = {THIN_GL_FRAGMENT_BIT, GL_Type_Sampler2D, "lightmap_r1"},                                                \
  .image[5] = {THIN_GL_FRAGMENT_BIT, GL_Type_Sampler2D, "lightmap_g1"},                                                \
  .image[6] = {THIN_GL_FRAGMENT_BIT, GL_Type_Sampler2D, "lightmap_b1"}

  .image[0] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_sampler2D, "albedo_map"},                                                 \
  .image[1] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_sampler2D, "normal_map"},                                                 \
  .image[3] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_sampler2D, "lightmap_rgb0"},                                              \
  .image[4] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_sampler2D, "lightmap_r1"},                                                \
  .image[5] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_sampler2D, "lightmap_g1"},                                                \
  .image[6] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_sampler2D, "lightmap_b1"}

static struct GL_DrawState draw_state_opaque = {.primitive = GL_TRIANGLES,

static struct alias_gl_DrawState draw_state_opaque = {.primitive = GL_TRIANGLES,

static struct GL_DrawState draw_state_transparent = {.primitive = GL_TRIANGLES,

static struct alias_gl_DrawState draw_state_transparent = {.primitive = GL_TRIANGLES,

static struct GL_DrawState draw_state_turbulent_opaque = {.primitive = GL_TRIANGLES,

static struct alias_gl_DrawState draw_state_turbulent_opaque = {.primitive = GL_TRIANGLES,

static struct GL_DrawState draw_state_turbulent_transparent = {.primitive = GL_TRIANGLES,

static struct alias_gl_DrawState draw_state_turbulent_transparent = {.primitive = GL_TRIANGLES,

  struct GL_DrawState *draw_state;

  struct alias_gl_DrawState *draw_state;

  struct GL_DrawAssets assets = {.image[0] = image_set.albedo->texnum,

  struct alias_gl_DrawAssets assets = {.image[0] = image_set.albedo->texnum,

  GL_draw_elements(draw_state, &assets, surf->elements_count, 1, 0, 0);

  alias_gl_drawElements(draw_state, &assets, surf->elements_count, 1, 0, 0);

  GL_matrix_identity(u_model_matrix.uniform.data.mat);

  alias_matrix_identity(u_model_matrix.uniform.data.mat);

  GL_matrix_identity(u_model_matrix.uniform.data.mat);

  alias_matrix_identity(u_model_matrix.uniform.data.mat);

#include "gl_thin_cpp.h"

// THIN_GL_IMPL_BLOCK(FrameMetrics, uint32(num_live_particles), uint32(num_dead_particles))

// ALIAS_GL_IMPL_BLOCK(FrameMetrics, uint32(num_live_particles), uint32(num_dead_particles))

THIN_GL_IMPL_BLOCK(Frame, float32(time), float32x3(viewOrigin))

ALIAS_GL_IMPL_BLOCK(Frame, float32(time), float32x3(viewOrigin))

THIN_GL_IMPL_BLOCK(View, float32x3(origin))

ALIAS_GL_IMPL_BLOCK(View, float32x3(origin))

//THIN_GL_IMPL_SNIPPET(Frame_random, require(random_squares32), code(uint random_uint() { return random_xy(); }))

//ALIAS_GL_IMPL_SNIPPET(Frame_random, require(random_squares32), code(uint random_uint() { return random_xy(); }))

  GL_matrix_multiply(u_view_matrix.uniform.data.mat, u_model_matrix.uniform.data.mat,

  alias_matrix_multiply(u_view_matrix.uniform.data.mat, u_model_matrix.uniform.data.mat,

  GL_matrix_multiply(u_projection_matrix.uniform.data.mat, u_view_matrix.uniform.data.mat,

  alias_matrix_multiply(u_projection_matrix.uniform.data.mat, u_view_matrix.uniform.data.mat,

  GL_ShaderResource_prepare(&u_view_projection_matrix);
  GL_matrix_multiply(u_view_projection_matrix.uniform.data.mat, u_model_matrix.uniform.data.mat,

  alias_gl_ShaderResource_prepare(&u_view_projection_matrix);
  alias_matrix_multiply(u_view_projection_matrix.uniform.data.mat, u_model_matrix.uniform.data.mat,

struct GL_ShaderResource u_time = {.type = GL_Type_Float, .name = "time"};
struct GL_ShaderResource u_model_matrix = {.type = GL_Type_Float4x4, .name = "model_matrix"};
struct GL_ShaderResource u_view_matrix = {.type = GL_Type_Float4x4, .name = "view_matrix"};
struct GL_ShaderResource u_model_view_matrix = {
    .type = GL_Type_Float4x4, .name = "model_view_matrix", .uniform.prepare = prepare_model_view};
struct GL_ShaderResource u_projection_matrix = {.type = GL_Type_Float4x4, .name = "projection_matrix"};
struct GL_ShaderResource u_view_projection_matrix = {
    .type = GL_Type_Float4x4, .name = "view_projection_matrix", .uniform.prepare = prepare_view_projection};
struct GL_ShaderResource u_model_view_projection_matrix = {
    .type = GL_Type_Float4x4, .name = "model_view_projection_matrix", .uniform.prepare = prepare_model_view_projection};

struct alias_gl_ShaderResource u_time = {.type = alias_gl_Type_float, .name = "time"};
struct alias_gl_ShaderResource u_model_matrix = {.type = alias_gl_Type_float4x4, .name = "model_matrix"};
struct alias_gl_ShaderResource u_view_matrix = {.type = alias_gl_Type_float4x4, .name = "view_matrix"};
struct alias_gl_ShaderResource u_model_view_matrix = {
    .type = alias_gl_Type_float4x4, .name = "model_view_matrix", .uniform.prepare = prepare_model_view};
struct alias_gl_ShaderResource u_projection_matrix = {.type = alias_gl_Type_float4x4, .name = "projection_matrix"};
struct alias_gl_ShaderResource u_view_projection_matrix = {
    .type = alias_gl_Type_float4x4, .name = "view_projection_matrix", .uniform.prepare = prepare_view_projection};
struct alias_gl_ShaderResource u_model_view_projection_matrix = {
    .type = alias_gl_Type_float4x4, .name = "model_view_projection_matrix", .uniform.prepare = prepare_model_view_projection};

struct GL_Buffer u_frame_buffer = {.kind = GL_Buffer_CPU, .size = sizeof(struct GL_Frame)};
struct GL_ShaderResource u_frame = {.type = GL_Type_ShaderStorageBuffer,

struct alias_gl_Buffer u_frame_buffer = {.kind = alias_gl_Buffer_cpu, .size = sizeof(struct alias_gl_Frame)};
struct alias_gl_ShaderResource u_frame = {.type = alias_gl_Type_shaderStorageBuffer,

                                    .block.snippet = &GL_Frame_snippet};

                                    .block.snippet = &alias_gl_Frame_snippet};

struct GL_ShaderResource u_view;
struct GL_ShaderResource u_draw;

struct alias_gl_ShaderResource u_view;
struct alias_gl_ShaderResource u_draw;

  GL_translate(u_model_matrix.uniform.data.mat, e->origin[0], e->origin[1], e->origin[2]);
  GL_rotate_z(u_model_matrix.uniform.data.mat, e->angles[1]);
  GL_rotate_y(u_model_matrix.uniform.data.mat, -e->angles[0]);
  GL_rotate_x(u_model_matrix.uniform.data.mat, -e->angles[2]);

  alias_translate(u_model_matrix.uniform.data.mat, e->origin[0], e->origin[1], e->origin[2]);
  alias_rotate_z(u_model_matrix.uniform.data.mat, e->angles[1]);
  alias_rotate_y(u_model_matrix.uniform.data.mat, -e->angles[0]);
  alias_rotate_x(u_model_matrix.uniform.data.mat, -e->angles[2]);

  GL_matrix_frustum(xmin, xmax, ymin, ymax, zNear, zFar, u_projection_matrix.uniform.data.mat);

  alias_matrix_frustum(xmin, xmax, ymin, ymax, zNear, zFar, u_projection_matrix.uniform.data.mat);

  GL_matrix_identity(u_view_matrix.uniform.data.mat);
  GL_rotate_x(u_view_matrix.uniform.data.mat, -90);
  GL_rotate_z(u_view_matrix.uniform.data.mat, 90);
  GL_rotate_x(u_view_matrix.uniform.data.mat, -r_newrefdef.viewangles[2]);
  GL_rotate_y(u_view_matrix.uniform.data.mat, -r_newrefdef.viewangles[0]);
  GL_rotate_z(u_view_matrix.uniform.data.mat, -r_newrefdef.viewangles[1]);
  GL_translate(u_view_matrix.uniform.data.mat, -r_newrefdef.vieworg[0], -r_newrefdef.vieworg[1],

  alias_matrix_identity(u_view_matrix.uniform.data.mat);
  alias_rotate_x(u_view_matrix.uniform.data.mat, -90);
  alias_rotate_z(u_view_matrix.uniform.data.mat, 90);
  alias_rotate_x(u_view_matrix.uniform.data.mat, -r_newrefdef.viewangles[2]);
  alias_rotate_y(u_view_matrix.uniform.data.mat, -r_newrefdef.viewangles[0]);
  alias_rotate_z(u_view_matrix.uniform.data.mat, -r_newrefdef.viewangles[1]);
  alias_translate(u_view_matrix.uniform.data.mat, -r_newrefdef.vieworg[0], -r_newrefdef.vieworg[1],

  GL_matrix_ortho(0, vid.width, vid.height, 0, -99999, 99999, u_projection_matrix.uniform.data.mat);
  GL_matrix_identity(u_view_matrix.uniform.data.mat);

  alias_matrix_ortho(0, vid.width, vid.height, 0, -99999, 99999, u_projection_matrix.uniform.data.mat);
  alias_matrix_identity(u_view_matrix.uniform.data.mat);

  struct GL_Frame *frame = (struct GL_Frame *)GL_update_buffer_begin(&u_frame_buffer, 0, sizeof(*frame));

  struct alias_gl_Frame *frame = (struct alias_gl_Frame *)alias_gl_updateBufferBegin(&u_frame_buffer, 0, sizeof(*frame));

  GL_update_buffer_end(&u_frame_buffer, 0, sizeof(*frame));

  alias_gl_updateBufferEnd(&u_frame_buffer, 0, sizeof(*frame));

  GL_matrix_ortho(0, vid.width, vid.height, 0, -99999, 99999, u_projection_matrix.uniform.data.mat);
  GL_matrix_identity(u_view_matrix.uniform.data.mat);

  alias_matrix_ortho(0, vid.width, vid.height, 0, -99999, 99999, u_projection_matrix.uniform.data.mat);
  alias_matrix_identity(u_view_matrix.uniform.data.mat);

  GL_reset_temporary_buffers();

  alias_gl_resetTemporaryBuffers();

#include "gl_thin_cpp.h"

THIN_GL_STRUCT(particle_Data, float32x4(origin_time), snorm16x4(velocity_alpha), snorm16x4(acceleration_alphaVelocity),

ALIAS_GL_STRUCT(particle_Data, float32x4(origin_time), snorm16x4(velocity_alpha), snorm16x4(acceleration_alphaVelocity),

THIN_GL_BLOCK(particle_data, require(particle_Data), unsized_array(struct(particle_DataPacked, item)))
static struct GL_Buffer data_buffer = {.kind = GL_Buffer_GPU, .size = sizeof(struct GL_particle_Data) * NUM_PARTICLES};
static struct GL_ShaderResource data_resource = {.type = GL_Type_ShaderStorageBuffer,

ALIAS_GL_BLOCK(particle_data, require(particle_Data), unsized_array(struct(particle_DataPacked, item)))
static struct alias_gl_Buffer data_buffer = {.kind = alias_gl_Buffer_gpu, .size = sizeof(struct alias_gl_particle_Data) * NUM_PARTICLES};
static struct alias_gl_ShaderResource data_resource = {.type = alias_gl_Type_shaderStorageBuffer,

                                                 .block.snippet = &GL_particle_data_snippet};

                                                 .block.snippet = &alias_gl_particle_data_snippet};

THIN_GL_BLOCK(particle_distance, unsized_array(uint32(item)))
static struct GL_Buffer distance_buffer = {.kind = GL_Buffer_GPU, .size = sizeof(uint32_t) * NUM_PARTICLES};
static struct GL_ShaderResource distance_resource = {.type = GL_Type_ShaderStorageBuffer,

ALIAS_GL_BLOCK(particle_distance, unsized_array(uint32(item)))
static struct alias_gl_Buffer distance_buffer = {.kind = alias_gl_Buffer_gpu, .size = sizeof(uint32_t) * NUM_PARTICLES};
static struct alias_gl_ShaderResource distance_resource = {.type = alias_gl_Type_shaderStorageBuffer,

                                                     .block.snippet = &GL_particle_distance_snippet};
static struct GL_Buffer distance2_buffer = {.kind = GL_Buffer_GPU, .size = sizeof(uint32_t) * NUM_PARTICLES};

                                                     .block.snippet = &alias_gl_particle_distance_snippet};
static struct alias_gl_Buffer distance2_buffer = {.kind = alias_gl_Buffer_gpu, .size = sizeof(uint32_t) * NUM_PARTICLES};

THIN_GL_BLOCK(particle_dead, unsized_array(uint32(item)))
static struct GL_Buffer dead_buffer = {.kind = GL_Buffer_GPU, .size = sizeof(uint32_t) * NUM_PARTICLES};
static struct GL_ShaderResource dead_resource = {.type = GL_Type_ShaderStorageBuffer,

ALIAS_GL_BLOCK(particle_dead, unsized_array(uint32(item)))
static struct alias_gl_Buffer dead_buffer = {.kind = alias_gl_Buffer_gpu, .size = sizeof(uint32_t) * NUM_PARTICLES};
static struct alias_gl_ShaderResource dead_resource = {.type = alias_gl_Type_shaderStorageBuffer,

                                                 .block.snippet = &GL_particle_dead_snippet};

                                                 .block.snippet = &alias_gl_particle_dead_snippet};

THIN_GL_BLOCK(particle_alive, unsized_array(uint32(item)))
static struct GL_Buffer alive_buffer = {.kind = GL_Buffer_GPU, .size = sizeof(uint32_t) * NUM_PARTICLES};
static struct GL_ShaderResource alive_resource = {.type = GL_Type_ShaderStorageBuffer,

ALIAS_GL_BLOCK(particle_alive, unsized_array(uint32(item)))
static struct alias_gl_Buffer alive_buffer = {.kind = alias_gl_Buffer_gpu, .size = sizeof(uint32_t) * NUM_PARTICLES};
static struct alias_gl_ShaderResource alive_resource = {.type = alias_gl_Type_shaderStorageBuffer,

                                                  .block.snippet = &GL_particle_alive_snippet};

                                                  .block.snippet = &alias_gl_particle_alive_snippet};

THIN_GL_BLOCK(particle_emitted, unsized_array(uint32(item)))
static struct GL_Buffer emitted_buffer = {.kind = GL_Buffer_GPU, .size = sizeof(uint32_t) * NUM_PARTICLES};
static struct GL_ShaderResource emitted_resource = {.type = GL_Type_ShaderStorageBuffer,

ALIAS_GL_BLOCK(particle_emitted, unsized_array(uint32(item)))
static struct alias_gl_Buffer emitted_buffer = {.kind = alias_gl_Buffer_gpu, .size = sizeof(uint32_t) * NUM_PARTICLES};
static struct alias_gl_ShaderResource emitted_resource = {.type = alias_gl_Type_shaderStorageBuffer,

                                                    .block.snippet = &GL_particle_emitted_snippet};

                                                    .block.snippet = &alias_gl_particle_emitted_snippet};

THIN_GL_BLOCK(particle_counter, uint32(alive), int32(dead), uint32(simulate))
static struct GL_Buffer counter_buffer = {.kind = GL_Buffer_GPU, .size = sizeof(struct GL_particle_counter)};
static struct GL_ShaderResource counter_resource = {.type = GL_Type_ShaderStorageBuffer,

ALIAS_GL_BLOCK(particle_counter, uint32(alive), int32(dead), uint32(simulate))
static struct alias_gl_Buffer counter_buffer = {.kind = alias_gl_Buffer_gpu, .size = sizeof(struct alias_gl_particle_counter)};
static struct alias_gl_ShaderResource counter_resource = {.type = alias_gl_Type_shaderStorageBuffer,

                                                    .block.snippet = &GL_particle_counter_snippet};

                                                    .block.snippet = &alias_gl_particle_counter_snippet};

THIN_GL_BLOCK(particle_indirect, require(DispatchIndirectCommand), require(DrawElementsIndirectCommand),

ALIAS_GL_BLOCK(particle_indirect, require(DispatchIndirectCommand), require(DrawElementsIndirectCommand),

static struct GL_Buffer indirect_buffer = {.kind = GL_Buffer_GPU, .size = sizeof(struct GL_particle_indirect)};
static struct GL_ShaderResource indirect_resource = {.type = GL_Type_ShaderStorageBuffer,

static struct alias_gl_Buffer indirect_buffer = {.kind = alias_gl_Buffer_gpu, .size = sizeof(struct alias_gl_particle_indirect)};
static struct alias_gl_ShaderResource indirect_resource = {.type = alias_gl_Type_shaderStorageBuffer,

                                                     .block.snippet = &GL_particle_indirect_snippet};

                                                     .block.snippet = &alias_gl_particle_indirect_snippet};

// THIN_GL_STRUCT(particle_EmitParameters, float32x4(velocity_x), float32x4(velocity_y), float32x4(velocity_z),

// ALIAS_GL_STRUCT(particle_EmitParameters, float32x4(velocity_x), float32x4(velocity_y), float32x4(velocity_z),

THIN_GL_BLOCK(sort_parameters, require(DispatchIndirectCommand), uint32(num_particles), uint32(width), uint32(height),

ALIAS_GL_BLOCK(sort_parameters, require(DispatchIndirectCommand), uint32(num_particles), uint32(width), uint32(height),

static struct GL_Buffer sort_parameters_buffer = {.kind = GL_Buffer_GPU, .size = sizeof(struct GL_sort_parameters)};
static struct GL_ShaderResource sort_parameters_resource = {.type = GL_Type_ShaderStorageBuffer,

static struct alias_gl_Buffer sort_parameters_buffer = {.kind = alias_gl_Buffer_gpu, .size = sizeof(struct alias_gl_sort_parameters)};
static struct alias_gl_ShaderResource sort_parameters_resource = {.type = alias_gl_Type_shaderStorageBuffer,

                                                            .block.snippet = &GL_sort_parameters_snippet};

                                                            .block.snippet = &alias_gl_sort_parameters_snippet};

THIN_GL_BLOCK(particle_key, unsized_array(uint32(item)))
static struct GL_ShaderResource sort_key_resource = {.type = GL_Type_ShaderStorageBuffer,

ALIAS_GL_BLOCK(particle_key, unsized_array(uint32(item)))
static struct alias_gl_ShaderResource sort_key_resource = {.type = alias_gl_Type_shaderStorageBuffer,

                                                     .block.snippet = &GL_particle_key_snippet};

                                                     .block.snippet = &alias_gl_particle_key_snippet};

THIN_GL_BLOCK(particle_value, unsized_array(uint32(item)))
static struct GL_ShaderResource sort_value_resource = {.type = GL_Type_ShaderStorageBuffer,

ALIAS_GL_BLOCK(particle_value, unsized_array(uint32(item)))
static struct alias_gl_ShaderResource sort_value_resource = {.type = alias_gl_Type_shaderStorageBuffer,

                                                       .block.snippet = &GL_particle_value_snippet};

                                                       .block.snippet = &alias_gl_particle_value_snippet};

THIN_GL_SHADER(initialize, main(

ALIAS_GL_SHADER(initialize, main(

static struct GL_ComputeState initialize_compute_state = {.shader = &initialize_shader,
                                                          .uniform[0] = {0, GL_Type_Uint, "count"},

static struct alias_gl_ComputeState initialize_compute_state = {.shader = &initialize_shader,
                                                          .uniform[0] = {0, alias_gl_Type_uint, "count"},

  GL_compute(&initialize_compute_state, &(struct GL_ComputeAssets){.uniforms[0].uint = NUM_PARTICLES}, 1, 1, 1);

  alias_gl_compute(&initialize_compute_state, &(struct alias_gl_ComputeAssets){.uniforms[0].uint = NUM_PARTICLES}, 1, 1, 1);

THIN_GL_SNIPPET(emit_particle, require(particle_Data), code(

ALIAS_GL_SNIPPET(emit_particle, require(particle_Data), code(

THIN_GL_SHADER(emit_on_mesh,

ALIAS_GL_SHADER(emit_on_mesh,

THIN_GL_SHADER(emit_single, require(emit_particle), main(

ALIAS_GL_SHADER(emit_single, require(emit_particle), main(

struct GL_ComputeState emit_single_compute_state = {.shader = &emit_single_shader,
                                                    .uniform[0] = {0, GL_Type_Float3, "origin"},
                                                    .uniform[1] = {0, GL_Type_Float3, "velocity"},
                                                    .uniform[2] = {0, GL_Type_Float3, "acceleration"},
                                                    .uniform[3] = {0, GL_Type_Float, "alpha"},
                                                    .uniform[4] = {0, GL_Type_Float, "alphaVelocity"},
                                                    .uniform[5] = {0, GL_Type_Float4, "albedo"},
                                                    .uniform[6] = {0, GL_Type_Float4, "emit"},
                                                    .uniform[7] = {0, GL_Type_Float, "incandescence"},
                                                    .uniform[8] = {0, GL_Type_Float, "incandescenceVelocity"},

struct alias_gl_ComputeState emit_single_compute_state = {.shader = &emit_single_shader,
                                                    .uniform[0] = {0, alias_gl_Type_float3, "origin"},
                                                    .uniform[1] = {0, alias_gl_Type_float3, "velocity"},
                                                    .uniform[2] = {0, alias_gl_Type_float3, "acceleration"},
                                                    .uniform[3] = {0, alias_gl_Type_float, "alpha"},
                                                    .uniform[4] = {0, alias_gl_Type_float, "alphaVelocity"},
                                                    .uniform[5] = {0, alias_gl_Type_float4, "albedo"},
                                                    .uniform[6] = {0, alias_gl_Type_float4, "emit"},
                                                    .uniform[7] = {0, alias_gl_Type_float, "incandescence"},
                                                    .uniform[8] = {0, alias_gl_Type_float, "incandescenceVelocity"},

THIN_GL_SHADER(pre_simulate, main(

ALIAS_GL_SHADER(pre_simulate, main(

struct GL_ComputeState presimulate_compute_state = {

struct alias_gl_ComputeState presimulate_compute_state = {

THIN_GL_SHADER(simulate, main(

ALIAS_GL_SHADER(simulate, main(

struct GL_ComputeState simulate_compute_state = {.shader = &simulate_shader,

struct alias_gl_ComputeState simulate_compute_state = {.shader = &simulate_shader,

THIN_GL_SHADER(postsimulate,

ALIAS_GL_SHADER(postsimulate,

struct GL_ComputeState postsimulate_compute_state = {.shader = &postsimulate_shader,

struct alias_gl_ComputeState postsimulate_compute_state = {.shader = &postsimulate_shader,

THIN_GL_SHADER(postsimulate_sort,

ALIAS_GL_SHADER(postsimulate_sort,

struct GL_ComputeState postsimulate_sort_compute_state = {.shader = &postsimulate_sort_shader,

struct alias_gl_ComputeState postsimulate_sort_compute_state = {.shader = &postsimulate_sort_shader,

THIN_GL_SHADER(sort_particles_fill_pass,

ALIAS_GL_SHADER(sort_particles_fill_pass,

static struct GL_ComputeState sort_particles_fill_pass_state = {.shader = &sort_particles_fill_pass_shader,

static struct alias_gl_ComputeState sort_particles_fill_pass_state = {.shader = &sort_particles_fill_pass_shader,

THIN_GL_SHADER(sort_particles_radix_pass_1,

ALIAS_GL_SHADER(sort_particles_radix_pass_1,

static struct GL_ComputeState sort_particles_radix_pass_1_state = {.shader = &sort_particles_radix_pass_1_shader,

static struct alias_gl_ComputeState sort_particles_radix_pass_1_state = {.shader = &sort_particles_radix_pass_1_shader,

THIN_GL_SHADER(sort_particles_rotate_pass,

ALIAS_GL_SHADER(sort_particles_rotate_pass,

static struct GL_ComputeState sort_particles_rotate_pass_state = {.shader = &sort_particles_rotate_pass_shader,

static struct alias_gl_ComputeState sort_particles_rotate_pass_state = {.shader = &sort_particles_rotate_pass_shader,

THIN_GL_SHADER(sort_particles_radix_pass_2,

ALIAS_GL_SHADER(sort_particles_radix_pass_2,

static struct GL_ComputeState sort_particles_radix_pass_2_state = {.shader = &sort_particles_radix_pass_2_shader,

static struct alias_gl_ComputeState sort_particles_radix_pass_2_state = {.shader = &sort_particles_radix_pass_2_shader,

THIN_GL_SHADER(sort_particles_sortedmatrix_pass,

ALIAS_GL_SHADER(sort_particles_sortedmatrix_pass,

static struct GL_ComputeState sort_particles_sortedmatrix_pass_state = {.shader =

static struct alias_gl_ComputeState sort_particles_sortedmatrix_pass_state = {.shader =

THIN_GL_SHADER(vertex,

ALIAS_GL_SHADER(vertex,

THIN_GL_SHADER(fragment,

ALIAS_GL_SHADER(fragment,

  struct GL_ComputeAssets assets;

  struct alias_gl_ComputeAssets assets;

  GL_compute(&emit_single_compute_state, &assets, 1, 1, 1);

  alias_gl_compute(&emit_single_compute_state, &assets, 1, 1, 1);

static struct GL_DrawState particle_draw_state = {

static struct alias_gl_DrawState particle_draw_state = {

    .attribute[0] = {0, alias_memory_Format_Float32, 3, "origin", offsetof(struct GL_particle_Data, origin_time)},
    .attribute[1] = {0, alias_memory_Format_Float32, 1, "time", offsetof(struct GL_particle_Data, origin_time) + 12},
    .attribute[2] = {0, alias_memory_Format_Snorm16, 3, "velocity", offsetof(struct GL_particle_Data, velocity_alpha)},
    .attribute[3] = {0, alias_memory_Format_Snorm16, 1, "alpha", offsetof(struct GL_particle_Data, velocity_alpha) + 6},

    .attribute[0] = {0, alias_memory_Format_Float32, 3, "origin", offsetof(struct alias_gl_particle_Data, origin_time)},
    .attribute[1] = {0, alias_memory_Format_Float32, 1, "time", offsetof(struct alias_gl_particle_Data, origin_time) + 12},
    .attribute[2] = {0, alias_memory_Format_Snorm16, 3, "velocity", offsetof(struct alias_gl_particle_Data, velocity_alpha)},
    .attribute[3] = {0, alias_memory_Format_Snorm16, 1, "alpha", offsetof(struct alias_gl_particle_Data, velocity_alpha) + 6},

                     offsetof(struct GL_particle_Data, acceleration_alphaVelocity)},

                     offsetof(struct alias_gl_particle_Data, acceleration_alphaVelocity)},

                     offsetof(struct GL_particle_Data, acceleration_alphaVelocity) + 6},
    .attribute[6] = {0, alias_memory_Format_Unorm8, 3, "albedo", offsetof(struct GL_particle_Data, albedo)},
    .attribute[7] = {0, alias_memory_Format_Unorm8, 3, "emit", offsetof(struct GL_particle_Data, emit)},

                     offsetof(struct alias_gl_particle_Data, acceleration_alphaVelocity) + 6},
    .attribute[6] = {0, alias_memory_Format_Unorm8, 3, "albedo", offsetof(struct alias_gl_particle_Data, albedo)},
    .attribute[7] = {0, alias_memory_Format_Unorm8, 3, "emit", offsetof(struct alias_gl_particle_Data, emit)},

                     offsetof(struct GL_particle_Data, incandescence_incandescenceVelocity)},

                     offsetof(struct alias_gl_particle_Data, incandescence_incandescenceVelocity)},

                     offsetof(struct GL_particle_Data, incandescence_incandescenceVelocity) + 2},
    .binding[0] = {sizeof(struct GL_particle_Data), 0},
    .uniform[0] = {THIN_GL_VERTEX_BIT, GL_Type_Float3, "point_size_sizemin_sizemax"},
    .uniform[1] = {THIN_GL_VERTEX_BIT, GL_Type_Float3, "point_a_b_c"},
    .global[0] = {THIN_GL_VERTEX_BIT, &u_view_projection_matrix},
    .global[1] = {THIN_GL_VERTEX_BIT, &u_view_matrix},
    .global[2] = {THIN_GL_VERTEX_BIT, &u_time},

                     offsetof(struct alias_gl_particle_Data, incandescence_incandescenceVelocity) + 2},
    .binding[0] = {sizeof(struct alias_gl_particle_Data), 0},
    .uniform[0] = {ALIAS_GL_VERTEX_BIT, alias_gl_Type_float3, "point_size_sizemin_sizemax"},
    .uniform[1] = {ALIAS_GL_VERTEX_BIT, alias_gl_Type_float3, "point_a_b_c"},
    .global[0] = {ALIAS_GL_VERTEX_BIT, &u_view_projection_matrix},
    .global[1] = {ALIAS_GL_VERTEX_BIT, &u_view_matrix},
    .global[2] = {ALIAS_GL_VERTEX_BIT, &u_time},

  GL_compute(&presimulate_compute_state, NULL, 1, 1, 1);

  alias_gl_compute(&presimulate_compute_state, NULL, 1, 1, 1);

  GL_compute_indirect(&simulate_compute_state, NULL, &indirect_buffer, offsetof(struct GL_particle_indirect, simulate));

  alias_gl_computeIndirect(&simulate_compute_state, NULL, &indirect_buffer, offsetof(struct alias_gl_particle_indirect, simulate));

    GL_compute(&postsimulate_sort_compute_state, NULL, 1, 1, 1);

    alias_gl_compute(&postsimulate_sort_compute_state, NULL, 1, 1, 1);

    GL_compute_indirect(&sort_particles_fill_pass_state, NULL, &sort_parameters_buffer,
                        offsetof(struct GL_sort_parameters, fill));

    alias_gl_computeIndirect(&sort_particles_fill_pass_state, NULL, &sort_parameters_buffer,
                        offsetof(struct alias_gl_sort_parameters, fill));

    GL_compute_indirect(&sort_particles_radix_pass_1_state, NULL, &sort_parameters_buffer,
                        offsetof(struct GL_sort_parameters, radix_1));

    alias_gl_computeIndirect(&sort_particles_radix_pass_1_state, NULL, &sort_parameters_buffer,
                        offsetof(struct alias_gl_sort_parameters, radix_1));

    GL_compute_indirect(&sort_particles_rotate_pass_state, NULL, &sort_parameters_buffer,
                        offsetof(struct GL_sort_parameters, rotate));

    alias_gl_computeIndirect(&sort_particles_rotate_pass_state, NULL, &sort_parameters_buffer,
                        offsetof(struct alias_gl_sort_parameters, rotate));

    GL_compute_indirect(&sort_particles_radix_pass_2_state, NULL, &sort_parameters_buffer,
                        offsetof(struct GL_sort_parameters, radix_2));

    alias_gl_computeIndirect(&sort_particles_radix_pass_2_state, NULL, &sort_parameters_buffer,
                        offsetof(struct alias_gl_sort_parameters, radix_2));

    GL_compute_indirect(&sort_particles_sortedmatrix_pass_state, NULL, &sort_parameters_buffer,
                        offsetof(struct GL_sort_parameters, sortedmatrix));

    alias_gl_computeIndirect(&sort_particles_sortedmatrix_pass_state, NULL, &sort_parameters_buffer,
                        offsetof(struct alias_gl_sort_parameters, sortedmatrix));

    GL_compute(&postsimulate_compute_state, NULL, 1, 1, 1);

    alias_gl_compute(&postsimulate_compute_state, NULL, 1, 1, 1);

  struct GL_DrawAssets assets = {.uniforms[0] = {.vec[0] = gl_particle_size->value,

  struct alias_gl_DrawAssets assets = {.uniforms[0] = {.vec[0] = gl_particle_size->value,

  GL_draw_elements_indirect(&particle_draw_state, &assets, &indirect_buffer,
                            offsetof(struct GL_particle_indirect, draw));

  alias_gl_drawElementsIndirect(&particle_draw_state, &assets, &indirect_buffer,
                            offsetof(struct alias_gl_particle_indirect, draw));

#include "gl_thin.h"

THIN_GL_SHADER(vertex,

ALIAS_GL_SHADER(vertex,

THIN_GL_SHADER(fragment,

ALIAS_GL_SHADER(fragment,

  .uniform[0] = {THIN_GL_FRAGMENT_BIT, GL_Type_Float3, "light_rgb0"},                                                  \
  .uniform[1] = {THIN_GL_FRAGMENT_BIT, GL_Type_Float3, "light_r1"},                                                    \
  .uniform[2] = {THIN_GL_FRAGMENT_BIT, GL_Type_Float3, "light_g1"},                                                    \
  .uniform[3] = {THIN_GL_FRAGMENT_BIT, GL_Type_Float3, "light_b1"},                                                    \
  .global[0] = {THIN_GL_VERTEX_BIT, &u_model_view_projection_matrix}

  .uniform[0] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_float3, "light_rgb0"},                                                  \
  .uniform[1] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_float3, "light_r1"},                                                    \
  .uniform[2] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_float3, "light_g1"},                                                    \
  .uniform[3] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_float3, "light_b1"},                                                    \
  .global[0] = {ALIAS_GL_VERTEX_BIT, &u_model_view_projection_matrix}

static struct GL_DrawState draw_state_opaque = {.primitive = GL_TRIANGLES,

static struct alias_gl_DrawState draw_state_opaque = {.primitive = GL_TRIANGLES,

static struct GL_DrawState draw_state_transparent = {.primitive = GL_TRIANGLES,

static struct alias_gl_DrawState draw_state_transparent = {.primitive = GL_TRIANGLES,

static struct GL_Buffer element_buffer;
static struct GL_Buffer vertex_buffer;

static struct alias_gl_Buffer element_buffer;
static struct alias_gl_Buffer vertex_buffer;

    element_buffer = GL_allocate_static_buffer(GL_ELEMENT_ARRAY_BUFFER, sizeof(element_data), element_data);
    vertex_buffer = GL_allocate_static_buffer(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data);

    element_buffer = alias_gl_allocateStaticBuffer(GL_ELEMENT_ARRAY_BUFFER, sizeof(element_data), element_data);
    vertex_buffer = alias_gl_allocateStaticBuffer(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data);

  GL_matrix_identity(u_model_matrix.uniform.data.mat);

  alias_matrix_identity(u_model_matrix.uniform.data.mat);

  GL_draw_elements(

  alias_gl_drawElements(

      &(struct GL_DrawAssets){

      &(struct alias_gl_DrawAssets){

              (struct GL_UniformData){.vec[0] = shadelight.f[0], .vec[1] = shadelight.f[4], .vec[2] = shadelight.f[8]},

              (struct alias_gl_UniformData){.vec[0] = shadelight.f[0], .vec[1] = shadelight.f[4], .vec[2] = shadelight.f[8]},

              (struct GL_UniformData){.vec[0] = shadelight.f[1], .vec[1] = shadelight.f[2], .vec[2] = shadelight.f[3]},

              (struct alias_gl_UniformData){.vec[0] = shadelight.f[1], .vec[1] = shadelight.f[2], .vec[2] = shadelight.f[3]},

              (struct GL_UniformData){.vec[0] = shadelight.f[5], .vec[1] = shadelight.f[6], .vec[2] = shadelight.f[7]},
          .uniforms[3] = (struct GL_UniformData){.vec[0] = shadelight.f[9],

              (struct alias_gl_UniformData){.vec[0] = shadelight.f[5], .vec[1] = shadelight.f[6], .vec[2] = shadelight.f[7]},
          .uniforms[3] = (struct alias_gl_UniformData){.vec[0] = shadelight.f[9],

#include "gl_thin.h"

#include <alias/gl.h>

  struct GL_Buffer element_buffer;   // triangles
  struct GL_Buffer position_buffer;  // position float[3]
  struct GL_Buffer attribute_buffer; // st unorm16[2] / 2, lightmap_st unorm16[2], quat snorm16[4]

  struct alias_gl_Buffer element_buffer;   // triangles
  struct alias_gl_Buffer position_buffer;  // position float[3]
  struct alias_gl_Buffer attribute_buffer; // st unorm16[2] / 2, lightmap_st unorm16[2], quat snorm16[4]

      GL_allocate_static_buffer(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32_t) * num_elements, element_buffer_data);

      alias_gl_allocateStaticBuffer(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32_t) * num_elements, element_buffer_data);

      GL_allocate_static_buffer(GL_ARRAY_BUFFER, sizeof(float) * 3 * num_vertexes, position_buffer_data);

      alias_gl_allocateStaticBuffer(GL_ARRAY_BUFFER, sizeof(float) * 3 * num_vertexes, position_buffer_data);

      GL_allocate_static_buffer(GL_ARRAY_BUFFER, sizeof(float) * 4 * num_vertexes, attribute_buffer_data);

      alias_gl_allocateStaticBuffer(GL_ARRAY_BUFFER, sizeof(float) * 4 * num_vertexes, attribute_buffer_data);

#include "gl_thin.h"

THIN_GL_SHADER(vertex,

ALIAS_GL_SHADER(vertex,

THIN_GL_SHADER(fragment,

ALIAS_GL_SHADER(fragment,

  .uniform[0] = {THIN_GL_FRAGMENT_BIT, GL_Type_Float3, "light_rgb0"},                                                  \
  .uniform[1] = {THIN_GL_FRAGMENT_BIT, GL_Type_Float3, "light_r1"},                                                    \
  .uniform[2] = {THIN_GL_FRAGMENT_BIT, GL_Type_Float3, "light_g1"},                                                    \
  .uniform[3] = {THIN_GL_FRAGMENT_BIT, GL_Type_Float3, "light_b1"},                                                    \
  .global[0] = {THIN_GL_VERTEX_BIT, &u_model_matrix}, .global[1] = {THIN_GL_VERTEX_BIT, &u_view_matrix},               \
  .global[2] = {THIN_GL_VERTEX_BIT, &u_projection_matrix}

  .uniform[0] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_float3, "light_rgb0"},                                                  \
  .uniform[1] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_float3, "light_r1"},                                                    \
  .uniform[2] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_float3, "light_g1"},                                                    \
  .uniform[3] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_float3, "light_b1"},                                                    \
  .global[0] = {ALIAS_GL_VERTEX_BIT, &u_model_matrix}, .global[1] = {ALIAS_GL_VERTEX_BIT, &u_view_matrix},               \
  .global[2] = {ALIAS_GL_VERTEX_BIT, &u_projection_matrix}

#define IMAGES_FORMAT .image[0] = {THIN_GL_FRAGMENT_BIT, GL_Type_Sampler2D, "albedo_map"}

#define IMAGES_FORMAT .image[0] = {ALIAS_GL_FRAGMENT_BIT, alias_gl_Type_sampler2D, "albedo_map"}

static struct GL_DrawState draw_state_opaque = {DRAW_STATE, NO_SHELL, OPAQUE, NO_DEPTH_HACK};
static struct GL_DrawState draw_state_opaque_depthhack = {DRAW_STATE, NO_SHELL, OPAQUE, DEPTH_HACK};
static struct GL_DrawState draw_state_transparent = {DRAW_STATE, NO_SHELL, TRANSPARENT, NO_DEPTH_HACK};
static struct GL_DrawState draw_state_transparent_depthhack = {DRAW_STATE, NO_SHELL, TRANSPARENT, DEPTH_HACK};

static struct alias_gl_DrawState draw_state_opaque = {DRAW_STATE, NO_SHELL, OPAQUE, NO_DEPTH_HACK};
static struct alias_gl_DrawState draw_state_opaque_depthhack = {DRAW_STATE, NO_SHELL, OPAQUE, DEPTH_HACK};
static struct alias_gl_DrawState draw_state_transparent = {DRAW_STATE, NO_SHELL, TRANSPARENT, NO_DEPTH_HACK};
static struct alias_gl_DrawState draw_state_transparent_depthhack = {DRAW_STATE, NO_SHELL, TRANSPARENT, DEPTH_HACK};

  GL_matrix_translation((currententity->oldorigin[0] - currententity->origin[0]) * currententity->backlerp,

  alias_matrix_translation((currententity->oldorigin[0] - currententity->origin[0]) * currententity->backlerp,

  struct GL_DrawState *draw_state =

  struct alias_gl_DrawState *draw_state =

    struct GL_Buffer element_vbo =
        GL_allocate_temporary_buffer(GL_ELEMENT_ARRAY_BUFFER, render_mesh->num_indexes * sizeof(uint32_t));
    struct GL_Buffer position_vbo =
        GL_allocate_temporary_buffer(GL_ARRAY_BUFFER, render_mesh->num_vertexes * sizeof(struct VertexPosition));
    struct GL_Buffer attribute_vbo =
        GL_allocate_temporary_buffer(GL_ARRAY_BUFFER, render_mesh->num_vertexes * sizeof(struct VertexAttribute));

    struct alias_gl_Buffer element_vbo =
        alias_gl_allocateTemporaryBuffer(GL_ELEMENT_ARRAY_BUFFER, render_mesh->num_indexes * sizeof(uint32_t));
    struct alias_gl_Buffer position_vbo =
        alias_gl_allocateTemporaryBuffer(GL_ARRAY_BUFFER, render_mesh->num_vertexes * sizeof(struct VertexPosition));
    struct alias_gl_Buffer attribute_vbo =
        alias_gl_allocateTemporaryBuffer(GL_ARRAY_BUFFER, render_mesh->num_vertexes * sizeof(struct VertexAttribute));

    struct GL_DrawAssets assets;

    struct alias_gl_DrawAssets assets;

        (struct GL_UniformData){.vec[0] = shadelight.f[0], .vec[1] = shadelight.f[4], .vec[2] = shadelight.f[8]};

        (struct alias_gl_UniformData){.vec[0] = shadelight.f[0], .vec[1] = shadelight.f[4], .vec[2] = shadelight.f[8]};

        (struct GL_UniformData){.vec[0] = shadelight.f[1], .vec[1] = shadelight.f[2], .vec[2] = shadelight.f[3]};

        (struct alias_gl_UniformData){.vec[0] = shadelight.f[1], .vec[1] = shadelight.f[2], .vec[2] = shadelight.f[3]};

        (struct GL_UniformData){.vec[0] = shadelight.f[5], .vec[1] = shadelight.f[6], .vec[2] = shadelight.f[7]};

        (struct alias_gl_UniformData){.vec[0] = shadelight.f[5], .vec[1] = shadelight.f[6], .vec[2] = shadelight.f[7]};

        (struct GL_UniformData){.vec[0] = shadelight.f[9], .vec[1] = shadelight.f[10], .vec[2] = shadelight.f[11]};

        (struct alias_gl_UniformData){.vec[0] = shadelight.f[9], .vec[1] = shadelight.f[10], .vec[2] = shadelight.f[11]};

    GL_draw_elements(draw_state, &assets, render_mesh->num_indexes, 1, 0, 0);

    alias_gl_drawElements(draw_state, &assets, render_mesh->num_indexes, 1, 0, 0);

#include "gl_thin_cpp.h"

#include <alias/gl.h>
#include <alias/matrix.h>

extern struct GL_ShaderResource u_time;
extern struct GL_ShaderResource u_model_matrix;
extern struct GL_ShaderResource u_view_matrix;
extern struct GL_ShaderResource u_model_view_matrix;
extern struct GL_ShaderResource u_projection_matrix;
extern struct GL_ShaderResource u_view_projection_matrix;
extern struct GL_ShaderResource u_model_view_projection_matrix;

extern struct alias_gl_ShaderResource u_time;
extern struct alias_gl_ShaderResource u_model_matrix;
extern struct alias_gl_ShaderResource u_view_matrix;
extern struct alias_gl_ShaderResource u_model_view_matrix;
extern struct alias_gl_ShaderResource u_projection_matrix;
extern struct alias_gl_ShaderResource u_view_projection_matrix;
extern struct alias_gl_ShaderResource u_model_view_projection_matrix;

extern struct GL_ShaderResource u_frame;
extern struct GL_ShaderResource u_frame_metrics;
extern struct GL_ShaderResource u_view;
extern struct GL_ShaderResource u_draw;

extern struct alias_gl_ShaderResource u_frame;
extern struct alias_gl_ShaderResource u_frame_metrics;
extern struct alias_gl_ShaderResource u_view;
extern struct alias_gl_ShaderResource u_draw;

// THIN_GL_DELCARE_BLOCK(FrameMetrics, uint32(num_live_particles), uint32(num_dead_particles))

// ALIAS_GL_DELCARE_BLOCK(FrameMetrics, uint32(num_live_particles), uint32(num_dead_particles))

THIN_GL_DECLARE_BLOCK(Frame, uint32(index), float32(time), float32x3(viewOrigin))

ALIAS_GL_DECLARE_BLOCK(Frame, uint32(index), float32(time), float32x3(viewOrigin))

THIN_GL_DECLARE_SNIPPET(Frame_utils)

ALIAS_GL_DECLARE_SNIPPET(Frame_utils)

THIN_GL_DECLARE_BLOCK(View, float32x3(origin))