diff --git a/dlib/dlibincludes.c b/dlib/dlibincludes.c index 08e0067..d333509 100644 --- a/dlib/dlibincludes.c +++ b/dlib/dlibincludes.c @@ -11,8 +11,6 @@ # include # include -# include -# include // # include // # include FT_FREETYPE_H // # include FT_GLYPH_H @@ -31,15 +29,17 @@ #endif #ifdef BUILD_VULKAN - # define VK_NO_PROTOTYPES - # include - # define VMA_STATIC_VULKAN_FUNCTIONS 0 # define VMA_DYNAMIC_VULKAN_FUNCTIONS 1 # define VMA_VULKAN_VERSION 1002000 - # include "../external/vma/vk_mem_alloc.h" - +#endif + +#ifdef BUILD_GL +# include +# include +# include +# include #endif diff --git a/dlib/platform.d b/dlib/platform.d index 984bf44..7282402 100644 --- a/dlib/platform.d +++ b/dlib/platform.d @@ -404,7 +404,6 @@ import core.sys.posix.pthread : PThread = pthread_t, import core.stdc.string : strlen; - const u32 X11_CB_TRANSFER_SIZE_DEFAULT = 1048576; const u32 X11_TIMEOUT_DEFAULT = 1500; @@ -635,8 +634,15 @@ WindowError() return WINDOW_ERR_MSG; } +enum i32 GL_CORE_PROFILE = 0x00000001; + bool -CreateWindow(PlatformWindow* window, string name, u32 width, u32 height, XVisualInfo* visual_info = null) +CreateWindow( + bool create_gl_context = false, + i32 gl_major_version = 4, + i32 gl_minor_version = 6, + i32 gl_profile = GL_CORE_PROFILE + )(PlatformWindow* window, string name, u32 width, u32 height) { PlatformWindow wnd = { w: width, @@ -671,18 +677,58 @@ CreateWindow(PlatformWindow* window, string name, u32 width, u32 height, XVisual window.screen_id = XDefaultScreen(window.display); - i64 value_mask = CWBackPixmap | CWBackPixel; + const i64 value_mask = CWBackPixmap | CWBackPixel; + const i64 event_mask = KeyPressMask | + KeyReleaseMask | + ExposureMask | + ButtonPressMask | + ButtonReleaseMask | + PointerMotionMask | + StructureNotifyMask | + PropertyChangeMask; - if(visual_info) + static if(create_gl_context) { - XSetWindowAttributes attrs = { - background_pixmap: None, - border_pixel: 0, - event_mask: StructureNotifyMask, - }; + import opengl; + const i32[] visual_attributes = [ + GLX_X_RENDERABLE, true, + GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT, + GLX_RENDER_TYPE, GLX_RGBA_BIT, + GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR, + GLX_RED_SIZE, 8, + GLX_GREEN_SIZE, 8, + GLX_BLUE_SIZE, 8, + GLX_ALPHA_SIZE, 8, + GLX_DEPTH_SIZE, 24, + GLX_STENCIL_SIZE, 8, + GLX_DOUBLEBUFFER, true, + None, + ]; - value_mask |= CWColormap; - auto copy = CopyFromParent; + i32 fb_count; + GLXFBConfig* fb_config = glXChooseFBConfig(window.display, window.screen_id, visual_attributes.ptr, &fb_count); + + if(fb_config == null || fb_count == 0) + { + Errf("Failed to retrieve GL framebuffer config"); + return false; + } + + GLXFBConfig chosen_fb_config = fb_config[0]; + XFree(fb_config); + + XVisualInfo* visual_info = glXGetVisualFromFBConfig(window.display, chosen_fb_config); + if(visual_info == null) + { + Errf("Failed to get GL visual"); + return false; + } + + XSetWindowAttributes set_window_attrs = { + colormap: XCreateColormap(window.display, RootWindow(window.display, visual_info.screen), visual_info.visual, AllocNone), + border_pixel: 0, + event_mask: event_mask, + }; window.window = XCreateWindow( window.display, @@ -695,8 +741,8 @@ CreateWindow(PlatformWindow* window, string name, u32 width, u32 height, XVisual visual_info.depth, InputOutput, visual_info.visual, - value_mask, - &attrs + value_mask | CWColormap, + &set_window_attrs ); XFree(visual_info); @@ -721,15 +767,6 @@ CreateWindow(PlatformWindow* window, string name, u32 width, u32 height, XVisual WINDOW_ERR_MSG = "Failed to create X11 window"; return false; } - - i64 event_mask = KeyPressMask | - KeyReleaseMask | - ExposureMask | - ButtonPressMask | - ButtonReleaseMask | - PointerMotionMask | - StructureNotifyMask | - PropertyChangeMask; XSelectInput(window.display, window.window, event_mask); @@ -774,8 +811,41 @@ CreateWindow(PlatformWindow* window, string name, u32 width, u32 height, XVisual XFlush(window.display); + static if(create_gl_context) + { + import opengl; + + glXCreateContextAttribsARB = cast(typeof(glXCreateContextAttribsARB))glXGetProcAddressARB(cast(u8*)r"glXCreateContexAttribsARB"); + if(!glXCreateContextAttribsARB) + { + Errf("glXCreateContextAttribsARB function not found"); + return false; + } + + enum GLX_CONTEXT_MAJOR_VERSION = 0x2091; + enum GLX_CONTEXT_MINOR_VERSION = 0x2092; + enum GLX_CONTEXT_PROFILE_MASK_ARB = 0x9126; + + const(i32[]) context_attributes = [ + GLX_CONTEXT_MAJOR_VERSION, gl_major_version, + GLX_CONTEXT_MINOR_VERSION, gl_minor_version, + GLX_CONTEXT_PROFILE_MASK_ARB, gl_profile, + None, + ]; + + GLXContext context = glXCreateContextAttribsARB(window.display, chosen_fb_config, null, True, context_attributes.ptr); + + if(!context) + { + Errf("Failed to create OpenGL context"); + return false; + } + + glXMakeCurrent(window.display, window.window, context); + } + return true; -}; +} void StartPlatformThread(PlatformWindow* window) @@ -1813,6 +1883,11 @@ version(DLIB_TEST) unittest assert(events[2].type == WET.FileDeleted); assert(events[2].names[0] == r"test_file.txt"); + + version(COMPILE_TEST) + { + CreateWindow!(true)(null, "GL", 1920, 1080); + } } } diff --git a/opengl/glenum.d b/opengl/glenum.d new file mode 100644 index 0000000..61aad0c --- /dev/null +++ b/opengl/glenum.d @@ -0,0 +1,1253 @@ +import dlib.aliases; + +enum GLEnum : u32 +{ + DEPTH_BUFFER_BIT = 0x00000100, + STENCIL_BUFFER_BIT = 0x00000400, + COLOR_BUFFER_BIT = 0x00004000, + FALSE = 0, + TRUE = 1, + POINTS = 0x0000, + LINES = 0x0001, + LINE_LOOP = 0x0002, + LINE_STRIP = 0x0003, + TRIANGLES = 0x0004, + TRIANGLE_STRIP = 0x0005, + TRIANGLE_FAN = 0x0006, + QUADS = 0x0007, + NEVER = 0x0200, + LESS = 0x0201, + EQUAL = 0x0202, + LEQUAL = 0x0203, + GREATER = 0x0204, + NOTEQUAL = 0x0205, + GEQUAL = 0x0206, + ALWAYS = 0x0207, + ZERO = 0, + ONE = 1, + SRC_COLOR = 0x0300, + ONE_MINUS_SRC_COLOR = 0x0301, + SRC_ALPHA = 0x0302, + ONE_MINUS_SRC_ALPHA = 0x0303, + DST_ALPHA = 0x0304, + ONE_MINUS_DST_ALPHA = 0x0305, + DST_COLOR = 0x0306, + ONE_MINUS_DST_COLOR = 0x0307, + SRC_ALPHA_SATURATE = 0x0308, + NONE = 0, + FRONT_LEFT = 0x0400, + FRONT_RIGHT = 0x0401, + BACK_LEFT = 0x0402, + BACK_RIGHT = 0x0403, + FRONT = 0x0404, + BACK = 0x0405, + LEFT = 0x0406, + RIGHT = 0x0407, + FRONT_AND_BACK = 0x0408, + NO_ERROR = 0, + INVALID_ENUM = 0x0500, + INVALID_VALUE = 0x0501, + INVALID_OPERATION = 0x0502, + OUT_OF_MEMORY = 0x0505, + CW = 0x0900, + CCW = 0x0901, + POINT_SIZE = 0x0B11, + POINT_SIZE_RANGE = 0x0B12, + POINT_SIZE_GRANULARITY = 0x0B13, + LINE_SMOOTH = 0x0B20, + LINE_WIDTH = 0x0B21, + LINE_WIDTH_RANGE = 0x0B22, + LINE_WIDTH_GRANULARITY = 0x0B23, + POLYGON_MODE = 0x0B40, + POLYGON_SMOOTH = 0x0B41, + CULL_FACE = 0x0B44, + CULL_FACE_MODE = 0x0B45, + FRONT_FACE = 0x0B46, + DEPTH_RANGE = 0x0B70, + DEPTH_TEST = 0x0B71, + DEPTH_WRITEMASK = 0x0B72, + DEPTH_CLEAR_VALUE = 0x0B73, + DEPTH_FUNC = 0x0B74, + STENCIL_TEST = 0x0B90, + STENCIL_CLEAR_VALUE = 0x0B91, + STENCIL_FUNC = 0x0B92, + STENCIL_VALUE_MASK = 0x0B93, + STENCIL_FAIL = 0x0B94, + STENCIL_PASS_DEPTH_FAIL = 0x0B95, + STENCIL_PASS_DEPTH_PASS = 0x0B96, + STENCIL_REF = 0x0B97, + STENCIL_WRITEMASK = 0x0B98, + VIEWPORT = 0x0BA2, + DITHER = 0x0BD0, + BLEND_DST = 0x0BE0, + BLEND_SRC = 0x0BE1, + BLEND = 0x0BE2, + LOGIC_OP_MODE = 0x0BF0, + COLOR_LOGIC_OP = 0x0BF2, + DRAW_BUFFER = 0x0C01, + READ_BUFFER = 0x0C02, + SCISSOR_BOX = 0x0C10, + SCISSOR_TEST = 0x0C11, + COLOR_CLEAR_VALUE = 0x0C22, + COLOR_WRITEMASK = 0x0C23, + DOUBLEBUFFER = 0x0C32, + STEREO = 0x0C33, + LINE_SMOOTH_HINT = 0x0C52, + POLYGON_SMOOTH_HINT = 0x0C53, + UNPACK_SWAP_BYTES = 0x0CF0, + UNPACK_LSB_FIRST = 0x0CF1, + UNPACK_ROW_LENGTH = 0x0CF2, + UNPACK_SKIP_ROWS = 0x0CF3, + UNPACK_SKIP_PIXELS = 0x0CF4, + UNPACK_ALIGNMENT = 0x0CF5, + PACK_SWAP_BYTES = 0x0D00, + PACK_LSB_FIRST = 0x0D01, + PACK_ROW_LENGTH = 0x0D02, + PACK_SKIP_ROWS = 0x0D03, + PACK_SKIP_PIXELS = 0x0D04, + PACK_ALIGNMENT = 0x0D05, + MAX_TEXTURE_SIZE = 0x0D33, + MAX_VIEWPORT_DIMS = 0x0D3A, + SUBPIXEL_BITS = 0x0D50, + TEXTURE_1D = 0x0DE0, + TEXTURE_2D = 0x0DE1, + POLYGON_OFFSET_UNITS = 0x2A00, + POLYGON_OFFSET_POINT = 0x2A01, + POLYGON_OFFSET_LINE = 0x2A02, + POLYGON_OFFSET_FILL = 0x8037, + POLYGON_OFFSET_FACTOR = 0x8038, + TEXTURE_BINDING_1D = 0x8068, + TEXTURE_BINDING_2D = 0x8069, + TEXTURE_WIDTH = 0x1000, + TEXTURE_HEIGHT = 0x1001, + TEXTURE_INTERNAL_FORMAT = 0x1003, + TEXTURE_BORDER_COLOR = 0x1004, + TEXTURE_RED_SIZE = 0x805C, + TEXTURE_GREEN_SIZE = 0x805D, + TEXTURE_BLUE_SIZE = 0x805E, + TEXTURE_ALPHA_SIZE = 0x805F, + DONT_CARE = 0x1100, + FASTEST = 0x1101, + NICEST = 0x1102, + BYTE = 0x1400, + UNSIGNED_BYTE = 0x1401, + SHORT = 0x1402, + UNSIGNED_SHORT = 0x1403, + INT = 0x1404, + UNSIGNED_INT = 0x1405, + FLOAT = 0x1406, + DOUBLE = 0x140A, + STACK_OVERFLOW = 0x0503, + STACK_UNDERFLOW = 0x0504, + CLEAR = 0x1500, + AND = 0x1501, + AND_REVERSE = 0x1502, + COPY = 0x1503, + AND_INVERTED = 0x1504, + NOOP = 0x1505, + XOR = 0x1506, + OR = 0x1507, + NOR = 0x1508, + EQUIV = 0x1509, + INVERT = 0x150A, + OR_REVERSE = 0x150B, + COPY_INVERTED = 0x150C, + OR_INVERTED = 0x150D, + NAND = 0x150E, + SET = 0x150F, + TEXTURE = 0x1702, + COLOR = 0x1800, + DEPTH = 0x1801, + STENCIL = 0x1802, + STENCIL_INDEX = 0x1901, + DEPTH_COMPONENT = 0x1902, + RED = 0x1903, + GREEN = 0x1904, + BLUE = 0x1905, + ALPHA = 0x1906, + RGB = 0x1907, + RGBA = 0x1908, + POINT = 0x1B00, + LINE = 0x1B01, + FILL = 0x1B02, + KEEP = 0x1E00, + REPLACE = 0x1E01, + INCR = 0x1E02, + DECR = 0x1E03, + VENDOR = 0x1F00, + RENDERER = 0x1F01, + VERSION = 0x1F02, + EXTENSIONS = 0x1F03, + NEAREST = 0x2600, + LINEAR = 0x2601, + NEAREST_MIPMAP_NEAREST = 0x2700, + LINEAR_MIPMAP_NEAREST = 0x2701, + NEAREST_MIPMAP_LINEAR = 0x2702, + LINEAR_MIPMAP_LINEAR = 0x2703, + TEXTURE_MAG_FILTER = 0x2800, + TEXTURE_MIN_FILTER = 0x2801, + TEXTURE_WRAP_S = 0x2802, + TEXTURE_WRAP_T = 0x2803, + PROXY_TEXTURE_1D = 0x8063, + PROXY_TEXTURE_2D = 0x8064, + REPEAT = 0x2901, + R3_G3_B2 = 0x2A10, + RGB4 = 0x804F, + RGB5 = 0x8050, + RGB8 = 0x8051, + RGB10 = 0x8052, + RGB12 = 0x8053, + RGB16 = 0x8054, + RGBA2 = 0x8055, + RGBA4 = 0x8056, + RGB5_A1 = 0x8057, + RGBA8 = 0x8058, + RGB10_A2 = 0x8059, + RGBA12 = 0x805A, + RGBA16 = 0x805B, + CURRENT_BIT = 0x00000001, + POINT_BIT = 0x00000002, + LINE_BIT = 0x00000004, + POLYGON_BIT = 0x00000008, + POLYGON_STIPPLE_BIT = 0x00000010, + PIXEL_MODE_BIT = 0x00000020, + LIGHTING_BIT = 0x00000040, + FOG_BIT = 0x00000080, + ACCUM_BUFFER_BIT = 0x00000200, + VIEWPORT_BIT = 0x00000800, + TRANSFORM_BIT = 0x00001000, + ENABLE_BIT = 0x00002000, + HINT_BIT = 0x00008000, + EVAL_BIT = 0x00010000, + LIST_BIT = 0x00020000, + TEXTURE_BIT = 0x00040000, + SCISSOR_BIT = 0x00080000, + ALL_ATTRIB_BITS = 0xFFFFFFFF, + CLIENT_PIXEL_STORE_BIT = 0x00000001, + CLIENT_VERTEX_ARRAY_BIT = 0x00000002, + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF, + QUAD_STRIP = 0x0008, + POLYGON = 0x0009, + ACCUM = 0x0100, + LOAD = 0x0101, + RETURN = 0x0102, + MULT = 0x0103, + ADD = 0x0104, + AUX0 = 0x0409, + AUX1 = 0x040A, + AUX2 = 0x040B, + AUX3 = 0x040C, + _2D = 0x0600, + _3D = 0x0601, + _3D_COLOR = 0x0602, + _3D_COLOR_TEXTURE = 0x0603, + _4D_COLOR_TEXTURE = 0x0604, + PASS_THROUGH_TOKEN = 0x0700, + POINT_TOKEN = 0x0701, + LINE_TOKEN = 0x0702, + POLYGON_TOKEN = 0x0703, + BITMAP_TOKEN = 0x0704, + DRAW_PIXEL_TOKEN = 0x0705, + COPY_PIXEL_TOKEN = 0x0706, + LINE_RESET_TOKEN = 0x0707, + EXP = 0x0800, + EXP2 = 0x0801, + COEFF = 0x0A00, + ORDER = 0x0A01, + DOMAIN = 0x0A02, + PIXEL_MAP_I_TO_I = 0x0C70, + PIXEL_MAP_S_TO_S = 0x0C71, + PIXEL_MAP_I_TO_R = 0x0C72, + PIXEL_MAP_I_TO_G = 0x0C73, + PIXEL_MAP_I_TO_B = 0x0C74, + PIXEL_MAP_I_TO_A = 0x0C75, + PIXEL_MAP_R_TO_R = 0x0C76, + PIXEL_MAP_G_TO_G = 0x0C77, + PIXEL_MAP_B_TO_B = 0x0C78, + PIXEL_MAP_A_TO_A = 0x0C79, + VERTEX_ARRAY_POINTER = 0x808E, + NORMAL_ARRAY_POINTER = 0x808F, + COLOR_ARRAY_POINTER = 0x8090, + INDEX_ARRAY_POINTER = 0x8091, + TEXTURE_COORD_ARRAY_POINTER = 0x8092, + EDGE_FLAG_ARRAY_POINTER = 0x8093, + FEEDBACK_BUFFER_POINTER = 0x0DF0, + SELECTION_BUFFER_POINTER = 0x0DF3, + CURRENT_COLOR = 0x0B00, + CURRENT_INDEX = 0x0B01, + CURRENT_NORMAL = 0x0B02, + CURRENT_TEXTURE_COORDS = 0x0B03, + CURRENT_RASTER_COLOR = 0x0B04, + CURRENT_RASTER_INDEX = 0x0B05, + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06, + CURRENT_RASTER_POSITION = 0x0B07, + CURRENT_RASTER_POSITION_VALID = 0x0B08, + CURRENT_RASTER_DISTANCE = 0x0B09, + POINT_SMOOTH = 0x0B10, + LINE_STIPPLE = 0x0B24, + LINE_STIPPLE_PATTERN = 0x0B25, + LINE_STIPPLE_REPEAT = 0x0B26, + LIST_MODE = 0x0B30, + MAX_LIST_NESTING = 0x0B31, + LIST_BASE = 0x0B32, + LIST_INDEX = 0x0B33, + POLYGON_STIPPLE = 0x0B42, + EDGE_FLAG = 0x0B43, + LIGHTING = 0x0B50, + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51, + LIGHT_MODEL_TWO_SIDE = 0x0B52, + LIGHT_MODEL_AMBIENT = 0x0B53, + SHADE_MODEL = 0x0B54, + COLOR_MATERIAL_FACE = 0x0B55, + COLOR_MATERIAL_PARAMETER = 0x0B56, + COLOR_MATERIAL = 0x0B57, + FOG = 0x0B60, + FOG_INDEX = 0x0B61, + FOG_DENSITY = 0x0B62, + FOG_START = 0x0B63, + FOG_END = 0x0B64, + FOG_MODE = 0x0B65, + FOG_COLOR = 0x0B66, + ACCUM_CLEAR_VALUE = 0x0B80, + MATRIX_MODE = 0x0BA0, + NORMALIZE = 0x0BA1, + MODELVIEW_STACK_DEPTH = 0x0BA3, + PROJECTION_STACK_DEPTH = 0x0BA4, + TEXTURE_STACK_DEPTH = 0x0BA5, + MODELVIEW_MATRIX = 0x0BA6, + PROJECTION_MATRIX = 0x0BA7, + TEXTURE_MATRIX = 0x0BA8, + ATTRIB_STACK_DEPTH = 0x0BB0, + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1, + ALPHA_TEST = 0x0BC0, + ALPHA_TEST_FUNC = 0x0BC1, + ALPHA_TEST_REF = 0x0BC2, + INDEX_LOGIC_OP = 0x0BF1, + LOGIC_OP = 0x0BF1, + AUX_BUFFERS = 0x0C00, + INDEX_CLEAR_VALUE = 0x0C20, + INDEX_WRITEMASK = 0x0C21, + INDEX_MODE = 0x0C30, + RGBA_MODE = 0x0C31, + RENDER_MODE = 0x0C40, + PERSPECTIVE_CORRECTION_HINT = 0x0C50, + POINT_SMOOTH_HINT = 0x0C51, + FOG_HINT = 0x0C54, + TEXTURE_GEN_S = 0x0C60, + TEXTURE_GEN_T = 0x0C61, + TEXTURE_GEN_R = 0x0C62, + TEXTURE_GEN_Q = 0x0C63, + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0, + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1, + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2, + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3, + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4, + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5, + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6, + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7, + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8, + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9, + MAP_COLOR = 0x0D10, + MAP_STENCIL = 0x0D11, + INDEX_SHIFT = 0x0D12, + INDEX_OFFSET = 0x0D13, + RED_SCALE = 0x0D14, + RED_BIAS = 0x0D15, + ZOOM_X = 0x0D16, + ZOOM_Y = 0x0D17, + GREEN_SCALE = 0x0D18, + GREEN_BIAS = 0x0D19, + BLUE_SCALE = 0x0D1A, + BLUE_BIAS = 0x0D1B, + ALPHA_SCALE = 0x0D1C, + ALPHA_BIAS = 0x0D1D, + DEPTH_SCALE = 0x0D1E, + DEPTH_BIAS = 0x0D1F, + MAX_EVAL_ORDER = 0x0D30, + MAX_LIGHTS = 0x0D31, + MAX_CLIP_PLANES = 0x0D32, + MAX_PIXEL_MAP_TABLE = 0x0D34, + MAX_ATTRIB_STACK_DEPTH = 0x0D35, + MAX_MODELVIEW_STACK_DEPTH = 0x0D36, + MAX_NAME_STACK_DEPTH = 0x0D37, + MAX_PROJECTION_STACK_DEPTH = 0x0D38, + MAX_TEXTURE_STACK_DEPTH = 0x0D39, + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B, + INDEX_BITS = 0x0D51, + RED_BITS = 0x0D52, + GREEN_BITS = 0x0D53, + BLUE_BITS = 0x0D54, + ALPHA_BITS = 0x0D55, + DEPTH_BITS = 0x0D56, + STENCIL_BITS = 0x0D57, + ACCUM_RED_BITS = 0x0D58, + ACCUM_GREEN_BITS = 0x0D59, + ACCUM_BLUE_BITS = 0x0D5A, + ACCUM_ALPHA_BITS = 0x0D5B, + NAME_STACK_DEPTH = 0x0D70, + AUTO_NORMAL = 0x0D80, + MAP1_COLOR_4 = 0x0D90, + MAP1_INDEX = 0x0D91, + MAP1_NORMAL = 0x0D92, + MAP1_TEXTURE_COORD_1 = 0x0D93, + MAP1_TEXTURE_COORD_2 = 0x0D94, + MAP1_TEXTURE_COORD_3 = 0x0D95, + MAP1_TEXTURE_COORD_4 = 0x0D96, + MAP1_VERTEX_3 = 0x0D97, + MAP1_VERTEX_4 = 0x0D98, + MAP2_COLOR_4 = 0x0DB0, + MAP2_INDEX = 0x0DB1, + MAP2_NORMAL = 0x0DB2, + MAP2_TEXTURE_COORD_1 = 0x0DB3, + MAP2_TEXTURE_COORD_2 = 0x0DB4, + MAP2_TEXTURE_COORD_3 = 0x0DB5, + MAP2_TEXTURE_COORD_4 = 0x0DB6, + MAP2_VERTEX_3 = 0x0DB7, + MAP2_VERTEX_4 = 0x0DB8, + MAP1_GRID_DOMAIN = 0x0DD0, + MAP1_GRID_SEGMENTS = 0x0DD1, + MAP2_GRID_DOMAIN = 0x0DD2, + MAP2_GRID_SEGMENTS = 0x0DD3, + FEEDBACK_BUFFER_SIZE = 0x0DF1, + FEEDBACK_BUFFER_TYPE = 0x0DF2, + SELECTION_BUFFER_SIZE = 0x0DF4, + VERTEX_ARRAY = 0x8074, + NORMAL_ARRAY = 0x8075, + COLOR_ARRAY = 0x8076, + INDEX_ARRAY = 0x8077, + TEXTURE_COORD_ARRAY = 0x8078, + EDGE_FLAG_ARRAY = 0x8079, + VERTEX_ARRAY_SIZE = 0x807A, + VERTEX_ARRAY_TYPE = 0x807B, + VERTEX_ARRAY_STRIDE = 0x807C, + NORMAL_ARRAY_TYPE = 0x807E, + NORMAL_ARRAY_STRIDE = 0x807F, + COLOR_ARRAY_SIZE = 0x8081, + COLOR_ARRAY_TYPE = 0x8082, + COLOR_ARRAY_STRIDE = 0x8083, + INDEX_ARRAY_TYPE = 0x8085, + INDEX_ARRAY_STRIDE = 0x8086, + TEXTURE_COORD_ARRAY_SIZE = 0x8088, + TEXTURE_COORD_ARRAY_TYPE = 0x8089, + TEXTURE_COORD_ARRAY_STRIDE = 0x808A, + EDGE_FLAG_ARRAY_STRIDE = 0x808C, + TEXTURE_COMPONENTS = 0x1003, + TEXTURE_BORDER = 0x1005, + TEXTURE_LUMINANCE_SIZE = 0x8060, + TEXTURE_INTENSITY_SIZE = 0x8061, + TEXTURE_PRIORITY = 0x8066, + TEXTURE_RESIDENT = 0x8067, + AMBIENT = 0x1200, + DIFFUSE = 0x1201, + SPECULAR = 0x1202, + POSITION = 0x1203, + SPOT_DIRECTION = 0x1204, + SPOT_EXPONENT = 0x1205, + SPOT_CUTOFF = 0x1206, + CONSTANT_ATTENUATION = 0x1207, + LINEAR_ATTENUATION = 0x1208, + QUADRATIC_ATTENUATION = 0x1209, + COMPILE = 0x1300, + COMPILE_AND_EXECUTE = 0x1301, + _2_BYTES = 0x1407, + _3_BYTES = 0x1408, + _4_BYTES = 0x1409, + EMISSION = 0x1600, + SHININESS = 0x1601, + AMBIENT_AND_DIFFUSE = 0x1602, + COLOR_INDEXES = 0x1603, + MODELVIEW = 0x1700, + PROJECTION = 0x1701, + COLOR_INDEX = 0x1900, + LUMINANCE = 0x1909, + LUMINANCE_ALPHA = 0x190A, + BITMAP = 0x1A00, + RENDER = 0x1C00, + FEEDBACK = 0x1C01, + SELECT = 0x1C02, + FLAT = 0x1D00, + SMOOTH = 0x1D01, + S = 0x2000, + T = 0x2001, + R = 0x2002, + Q = 0x2003, + MODULATE = 0x2100, + DECAL = 0x2101, + TEXTURE_ENV_MODE = 0x2200, + TEXTURE_ENV_COLOR = 0x2201, + TEXTURE_ENV = 0x2300, + EYE_LINEAR = 0x2400, + OBJECT_LINEAR = 0x2401, + SPHERE_MAP = 0x2402, + TEXTURE_GEN_MODE = 0x2500, + OBJECT_PLANE = 0x2501, + EYE_PLANE = 0x2502, + CLAMP = 0x2900, + ALPHA4 = 0x803B, + ALPHA8 = 0x803C, + ALPHA12 = 0x803D, + ALPHA16 = 0x803E, + LUMINANCE4 = 0x803F, + LUMINANCE8 = 0x8040, + LUMINANCE12 = 0x8041, + LUMINANCE16 = 0x8042, + LUMINANCE4_ALPHA4 = 0x8043, + LUMINANCE6_ALPHA2 = 0x8044, + LUMINANCE8_ALPHA8 = 0x8045, + LUMINANCE12_ALPHA4 = 0x8046, + LUMINANCE12_ALPHA12 = 0x8047, + LUMINANCE16_ALPHA16 = 0x8048, + INTENSITY = 0x8049, + INTENSITY4 = 0x804A, + INTENSITY8 = 0x804B, + INTENSITY12 = 0x804C, + INTENSITY16 = 0x804D, + V2F = 0x2A20, + V3F = 0x2A21, + C4UB_V2F = 0x2A22, + C4UB_V3F = 0x2A23, + C3F_V3F = 0x2A24, + N3F_V3F = 0x2A25, + C4F_N3F_V3F = 0x2A26, + T2F_V3F = 0x2A27, + T4F_V4F = 0x2A28, + T2F_C4UB_V3F = 0x2A29, + T2F_C3F_V3F = 0x2A2A, + T2F_N3F_V3F = 0x2A2B, + T2F_C4F_N3F_V3F = 0x2A2C, + T4F_C4F_N3F_V4F = 0x2A2D, + CLIP_PLANE0 = 0x3000, + CLIP_PLANE1 = 0x3001, + CLIP_PLANE2 = 0x3002, + CLIP_PLANE3 = 0x3003, + CLIP_PLANE4 = 0x3004, + CLIP_PLANE5 = 0x3005, + LIGHT0 = 0x4000, + LIGHT1 = 0x4001, + LIGHT2 = 0x4002, + LIGHT3 = 0x4003, + LIGHT4 = 0x4004, + LIGHT5 = 0x4005, + LIGHT6 = 0x4006, + LIGHT7 = 0x4007, + UNSIGNED_BYTE_3_3_2 = 0x8032, + UNSIGNED_SHORT_4_4_4_4 = 0x8033, + UNSIGNED_SHORT_5_5_5_1 = 0x8034, + UNSIGNED_INT_8_8_8_8 = 0x8035, + UNSIGNED_INT_10_10_10_2 = 0x8036, + TEXTURE_BINDING_3D = 0x806A, + PACK_SKIP_IMAGES = 0x806B, + PACK_IMAGE_HEIGHT = 0x806C, + UNPACK_SKIP_IMAGES = 0x806D, + UNPACK_IMAGE_HEIGHT = 0x806E, + TEXTURE_3D = 0x806F, + PROXY_TEXTURE_3D = 0x8070, + TEXTURE_DEPTH = 0x8071, + TEXTURE_WRAP_R = 0x8072, + MAX_3D_TEXTURE_SIZE = 0x8073, + UNSIGNED_BYTE_2_3_3_REV = 0x8362, + UNSIGNED_SHORT_5_6_5 = 0x8363, + UNSIGNED_SHORT_5_6_5_REV = 0x8364, + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365, + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366, + UNSIGNED_INT_8_8_8_8_REV = 0x8367, + UNSIGNED_INT_2_10_10_10_REV = 0x8368, + BGR = 0x80E0, + BGRA = 0x80E1, + MAX_ELEMENTS_VERTICES = 0x80E8, + MAX_ELEMENTS_INDICES = 0x80E9, + CLAMP_TO_EDGE = 0x812F, + TEXTURE_MIN_LOD = 0x813A, + TEXTURE_MAX_LOD = 0x813B, + TEXTURE_BASE_LEVEL = 0x813C, + TEXTURE_MAX_LEVEL = 0x813D, + SMOOTH_POINT_SIZE_RANGE = 0x0B12, + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13, + SMOOTH_LINE_WIDTH_RANGE = 0x0B22, + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23, + ALIASED_LINE_WIDTH_RANGE = 0x846E, + RESCALE_NORMAL = 0x803A, + LIGHT_MODEL_COLOR_CONTROL = 0x81F8, + SINGLE_COLOR = 0x81F9, + SEPARATE_SPECULAR_COLOR = 0x81FA, + ALIASED_POINT_SIZE_RANGE = 0x846D, + TEXTURE0 = 0x84C0, + TEXTURE1 = 0x84C1, + TEXTURE2 = 0x84C2, + TEXTURE3 = 0x84C3, + TEXTURE4 = 0x84C4, + TEXTURE5 = 0x84C5, + TEXTURE6 = 0x84C6, + TEXTURE7 = 0x84C7, + TEXTURE8 = 0x84C8, + TEXTURE9 = 0x84C9, + TEXTURE10 = 0x84CA, + TEXTURE11 = 0x84CB, + TEXTURE12 = 0x84CC, + TEXTURE13 = 0x84CD, + TEXTURE14 = 0x84CE, + TEXTURE15 = 0x84CF, + TEXTURE16 = 0x84D0, + TEXTURE17 = 0x84D1, + TEXTURE18 = 0x84D2, + TEXTURE19 = 0x84D3, + TEXTURE20 = 0x84D4, + TEXTURE21 = 0x84D5, + TEXTURE22 = 0x84D6, + TEXTURE23 = 0x84D7, + TEXTURE24 = 0x84D8, + TEXTURE25 = 0x84D9, + TEXTURE26 = 0x84DA, + TEXTURE27 = 0x84DB, + TEXTURE28 = 0x84DC, + TEXTURE29 = 0x84DD, + TEXTURE30 = 0x84DE, + TEXTURE31 = 0x84DF, + ACTIVE_TEXTURE = 0x84E0, + MULTISAMPLE = 0x809D, + SAMPLE_ALPHA_TO_COVERAGE = 0x809E, + SAMPLE_ALPHA_TO_ONE = 0x809F, + SAMPLE_COVERAGE = 0x80A0, + SAMPLE_BUFFERS = 0x80A8, + SAMPLES = 0x80A9, + SAMPLE_COVERAGE_VALUE = 0x80AA, + SAMPLE_COVERAGE_INVERT = 0x80AB, + TEXTURE_CUBE_MAP = 0x8513, + TEXTURE_BINDING_CUBE_MAP = 0x8514, + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515, + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516, + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517, + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518, + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519, + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A, + PROXY_TEXTURE_CUBE_MAP = 0x851B, + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C, + COMPRESSED_RGB = 0x84ED, + COMPRESSED_RGBA = 0x84EE, + TEXTURE_COMPRESSION_HINT = 0x84EF, + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0, + TEXTURE_COMPRESSED = 0x86A1, + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2, + COMPRESSED_TEXTURE_FORMATS = 0x86A3, + CLAMP_TO_BORDER = 0x812D, + CLIENT_ACTIVE_TEXTURE = 0x84E1, + MAX_TEXTURE_UNITS = 0x84E2, + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3, + TRANSPOSE_PROJECTION_MATRIX = 0x84E4, + TRANSPOSE_TEXTURE_MATRIX = 0x84E5, + TRANSPOSE_COLOR_MATRIX = 0x84E6, + MULTISAMPLE_BIT = 0x20000000, + NORMAL_MAP = 0x8511, + REFLECTION_MAP = 0x8512, + COMPRESSED_ALPHA = 0x84E9, + COMPRESSED_LUMINANCE = 0x84EA, + COMPRESSED_LUMINANCE_ALPHA = 0x84EB, + COMPRESSED_INTENSITY = 0x84EC, + COMBINE = 0x8570, + COMBINE_RGB = 0x8571, + COMBINE_ALPHA = 0x8572, + SOURCE0_RGB = 0x8580, + SOURCE1_RGB = 0x8581, + SOURCE2_RGB = 0x8582, + SOURCE0_ALPHA = 0x8588, + SOURCE1_ALPHA = 0x8589, + SOURCE2_ALPHA = 0x858A, + OPERAND0_RGB = 0x8590, + OPERAND1_RGB = 0x8591, + OPERAND2_RGB = 0x8592, + OPERAND0_ALPHA = 0x8598, + OPERAND1_ALPHA = 0x8599, + OPERAND2_ALPHA = 0x859A, + RGB_SCALE = 0x8573, + ADD_SIGNED = 0x8574, + INTERPOLATE = 0x8575, + SUBTRACT = 0x84E7, + CONSTANT = 0x8576, + PRIMARY_COLOR = 0x8577, + PREVIOUS = 0x8578, + DOT3_RGB = 0x86AE, + DOT3_RGBA = 0x86AF, + BLEND_DST_RGB = 0x80C8, + BLEND_SRC_RGB = 0x80C9, + BLEND_DST_ALPHA = 0x80CA, + BLEND_SRC_ALPHA = 0x80CB, + POINT_FADE_THRESHOLD_SIZE = 0x8128, + DEPTH_COMPONENT16 = 0x81A5, + DEPTH_COMPONENT24 = 0x81A6, + DEPTH_COMPONENT32 = 0x81A7, + MIRRORED_REPEAT = 0x8370, + MAX_TEXTURE_LOD_BIAS = 0x84FD, + TEXTURE_LOD_BIAS = 0x8501, + INCR_WRAP = 0x8507, + DECR_WRAP = 0x8508, + TEXTURE_DEPTH_SIZE = 0x884A, + TEXTURE_COMPARE_MODE = 0x884C, + TEXTURE_COMPARE_FUNC = 0x884D, + POINT_SIZE_MIN = 0x8126, + POINT_SIZE_MAX = 0x8127, + POINT_DISTANCE_ATTENUATION = 0x8129, + GENERATE_MIPMAP = 0x8191, + GENERATE_MIPMAP_HINT = 0x8192, + FOG_COORDINATE_SOURCE = 0x8450, + FOG_COORDINATE = 0x8451, + FRAGMENT_DEPTH = 0x8452, + CURRENT_FOG_COORDINATE = 0x8453, + FOG_COORDINATE_ARRAY_TYPE = 0x8454, + FOG_COORDINATE_ARRAY_STRIDE = 0x8455, + FOG_COORDINATE_ARRAY_POINTER = 0x8456, + FOG_COORDINATE_ARRAY = 0x8457, + COLOR_SUM = 0x8458, + CURRENT_SECONDARY_COLOR = 0x8459, + SECONDARY_COLOR_ARRAY_SIZE = 0x845A, + SECONDARY_COLOR_ARRAY_TYPE = 0x845B, + SECONDARY_COLOR_ARRAY_STRIDE = 0x845C, + SECONDARY_COLOR_ARRAY_POINTER = 0x845D, + SECONDARY_COLOR_ARRAY = 0x845E, + TEXTURE_FILTER_CONTROL = 0x8500, + DEPTH_TEXTURE_MODE = 0x884B, + COMPARE_R_TO_TEXTURE = 0x884E, + FUNC_ADD = 0x8006, + FUNC_SUBTRACT = 0x800A, + FUNC_REVERSE_SUBTRACT = 0x800B, + MIN = 0x8007, + MAX = 0x8008, + CONSTANT_COLOR = 0x8001, + ONE_MINUS_CONSTANT_COLOR = 0x8002, + CONSTANT_ALPHA = 0x8003, + ONE_MINUS_CONSTANT_ALPHA = 0x8004, + BUFFER_SIZE = 0x8764, + BUFFER_USAGE = 0x8765, + QUERY_COUNTER_BITS = 0x8864, + CURRENT_QUERY = 0x8865, + QUERY_RESULT = 0x8866, + QUERY_RESULT_AVAILABLE = 0x8867, + ARRAY_BUFFER = 0x8892, + ELEMENT_ARRAY_BUFFER = 0x8893, + ARRAY_BUFFER_BINDING = 0x8894, + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895, + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F, + READ_ONLY = 0x88B8, + WRITE_ONLY = 0x88B9, + READ_WRITE = 0x88BA, + BUFFER_ACCESS = 0x88BB, + BUFFER_MAPPED = 0x88BC, + BUFFER_MAP_POINTER = 0x88BD, + STREAM_DRAW = 0x88E0, + STREAM_READ = 0x88E1, + STREAM_COPY = 0x88E2, + STATIC_DRAW = 0x88E4, + STATIC_READ = 0x88E5, + STATIC_COPY = 0x88E6, + DYNAMIC_DRAW = 0x88E8, + DYNAMIC_READ = 0x88E9, + DYNAMIC_COPY = 0x88EA, + SAMPLES_PASSED = 0x8914, + SRC1_ALPHA = 0x8589, + VERTEX_ARRAY_BUFFER_BINDING = 0x8896, + NORMAL_ARRAY_BUFFER_BINDING = 0x8897, + COLOR_ARRAY_BUFFER_BINDING = 0x8898, + INDEX_ARRAY_BUFFER_BINDING = 0x8899, + TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A, + EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B, + SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C, + FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D, + WEIGHT_ARRAY_BUFFER_BINDING = 0x889E, + FOG_COORD_SRC = 0x8450, + FOG_COORD = 0x8451, + CURRENT_FOG_COORD = 0x8453, + FOG_COORD_ARRAY_TYPE = 0x8454, + FOG_COORD_ARRAY_STRIDE = 0x8455, + FOG_COORD_ARRAY_POINTER = 0x8456, + FOG_COORD_ARRAY = 0x8457, + FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D, + SRC0_RGB = 0x8580, + SRC1_RGB = 0x8581, + SRC2_RGB = 0x8582, + SRC0_ALPHA = 0x8588, + SRC2_ALPHA = 0x858A, + BLEND_EQUATION_RGB = 0x8009, + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622, + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623, + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624, + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625, + CURRENT_VERTEX_ATTRIB = 0x8626, + VERTEX_PROGRAM_POINT_SIZE = 0x8642, + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645, + STENCIL_BACK_FUNC = 0x8800, + STENCIL_BACK_FAIL = 0x8801, + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802, + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803, + MAX_DRAW_BUFFERS = 0x8824, + DRAW_BUFFER0 = 0x8825, + DRAW_BUFFER1 = 0x8826, + DRAW_BUFFER2 = 0x8827, + DRAW_BUFFER3 = 0x8828, + DRAW_BUFFER4 = 0x8829, + DRAW_BUFFER5 = 0x882A, + DRAW_BUFFER6 = 0x882B, + DRAW_BUFFER7 = 0x882C, + DRAW_BUFFER8 = 0x882D, + DRAW_BUFFER9 = 0x882E, + DRAW_BUFFER10 = 0x882F, + DRAW_BUFFER11 = 0x8830, + DRAW_BUFFER12 = 0x8831, + DRAW_BUFFER13 = 0x8832, + DRAW_BUFFER14 = 0x8833, + DRAW_BUFFER15 = 0x8834, + BLEND_EQUATION_ALPHA = 0x883D, + MAX_VERTEX_ATTRIBS = 0x8869, + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A, + MAX_TEXTURE_IMAGE_UNITS = 0x8872, + FRAGMENT_SHADER = 0x8B30, + VERTEX_SHADER = 0x8B31, + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49, + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A, + MAX_VARYING_FLOATS = 0x8B4B, + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C, + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D, + SHADER_TYPE = 0x8B4F, + FLOAT_VEC2 = 0x8B50, + FLOAT_VEC3 = 0x8B51, + FLOAT_VEC4 = 0x8B52, + INT_VEC2 = 0x8B53, + INT_VEC3 = 0x8B54, + INT_VEC4 = 0x8B55, + BOOL = 0x8B56, + BOOL_VEC2 = 0x8B57, + BOOL_VEC3 = 0x8B58, + BOOL_VEC4 = 0x8B59, + FLOAT_MAT2 = 0x8B5A, + FLOAT_MAT3 = 0x8B5B, + FLOAT_MAT4 = 0x8B5C, + SAMPLER_1D = 0x8B5D, + SAMPLER_2D = 0x8B5E, + SAMPLER_3D = 0x8B5F, + SAMPLER_CUBE = 0x8B60, + SAMPLER_1D_SHADOW = 0x8B61, + SAMPLER_2D_SHADOW = 0x8B62, + DELETE_STATUS = 0x8B80, + COMPILE_STATUS = 0x8B81, + LINK_STATUS = 0x8B82, + VALIDATE_STATUS = 0x8B83, + INFO_LOG_LENGTH = 0x8B84, + ATTACHED_SHADERS = 0x8B85, + ACTIVE_UNIFORMS = 0x8B86, + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87, + SHADER_SOURCE_LENGTH = 0x8B88, + ACTIVE_ATTRIBUTES = 0x8B89, + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A, + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B, + SHADING_LANGUAGE_VERSION = 0x8B8C, + CURRENT_PROGRAM = 0x8B8D, + POINT_SPRITE_COORD_ORIGIN = 0x8CA0, + LOWER_LEFT = 0x8CA1, + UPPER_LEFT = 0x8CA2, + STENCIL_BACK_REF = 0x8CA3, + STENCIL_BACK_VALUE_MASK = 0x8CA4, + STENCIL_BACK_WRITEMASK = 0x8CA5, + VERTEX_PROGRAM_TWO_SIDE = 0x8643, + POINT_SPRITE = 0x8861, + COORD_REPLACE = 0x8862, + MAX_TEXTURE_COORDS = 0x8871, + PIXEL_PACK_BUFFER = 0x88EB, + PIXEL_UNPACK_BUFFER = 0x88EC, + PIXEL_PACK_BUFFER_BINDING = 0x88ED, + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF, + FLOAT_MAT2x3 = 0x8B65, + FLOAT_MAT2x4 = 0x8B66, + FLOAT_MAT3x2 = 0x8B67, + FLOAT_MAT3x4 = 0x8B68, + FLOAT_MAT4x2 = 0x8B69, + FLOAT_MAT4x3 = 0x8B6A, + SRGB = 0x8C40, + SRGB8 = 0x8C41, + SRGB_ALPHA = 0x8C42, + SRGB8_ALPHA8 = 0x8C43, + COMPRESSED_SRGB = 0x8C48, + COMPRESSED_SRGB_ALPHA = 0x8C49, + CURRENT_RASTER_SECONDARY_COLOR = 0x845F, + SLUMINANCE_ALPHA = 0x8C44, + SLUMINANCE8_ALPHA8 = 0x8C45, + SLUMINANCE = 0x8C46, + SLUMINANCE8 = 0x8C47, + COMPRESSED_SLUMINANCE = 0x8C4A, + COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B, + COMPARE_REF_TO_TEXTURE = 0x884E, + CLIP_DISTANCE0 = 0x3000, + CLIP_DISTANCE1 = 0x3001, + CLIP_DISTANCE2 = 0x3002, + CLIP_DISTANCE3 = 0x3003, + CLIP_DISTANCE4 = 0x3004, + CLIP_DISTANCE5 = 0x3005, + CLIP_DISTANCE6 = 0x3006, + CLIP_DISTANCE7 = 0x3007, + MAX_CLIP_DISTANCES = 0x0D32, + MAJOR_VERSION = 0x821B, + MINOR_VERSION = 0x821C, + NUM_EXTENSIONS = 0x821D, + CONTEXT_FLAGS = 0x821E, + COMPRESSED_RED = 0x8225, + COMPRESSED_RG = 0x8226, + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001, + RGBA32F = 0x8814, + RGB32F = 0x8815, + RGBA16F = 0x881A, + RGB16F = 0x881B, + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD, + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF, + MIN_PROGRAM_TEXEL_OFFSET = 0x8904, + MAX_PROGRAM_TEXEL_OFFSET = 0x8905, + CLAMP_READ_COLOR = 0x891C, + FIXED_ONLY = 0x891D, + MAX_VARYING_COMPONENTS = 0x8B4B, + TEXTURE_1D_ARRAY = 0x8C18, + PROXY_TEXTURE_1D_ARRAY = 0x8C19, + TEXTURE_2D_ARRAY = 0x8C1A, + PROXY_TEXTURE_2D_ARRAY = 0x8C1B, + TEXTURE_BINDING_1D_ARRAY = 0x8C1C, + TEXTURE_BINDING_2D_ARRAY = 0x8C1D, + R11F_G11F_B10F = 0x8C3A, + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B, + RGB9_E5 = 0x8C3D, + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E, + TEXTURE_SHARED_SIZE = 0x8C3F, + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76, + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F, + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80, + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83, + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84, + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85, + PRIMITIVES_GENERATED = 0x8C87, + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88, + RASTERIZER_DISCARD = 0x8C89, + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A, + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B, + INTERLEAVED_ATTRIBS = 0x8C8C, + SEPARATE_ATTRIBS = 0x8C8D, + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E, + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F, + RGBA32UI = 0x8D70, + RGB32UI = 0x8D71, + RGBA16UI = 0x8D76, + RGB16UI = 0x8D77, + RGBA8UI = 0x8D7C, + RGB8UI = 0x8D7D, + RGBA32I = 0x8D82, + RGB32I = 0x8D83, + RGBA16I = 0x8D88, + RGB16I = 0x8D89, + RGBA8I = 0x8D8E, + RGB8I = 0x8D8F, + RED_INTEGER = 0x8D94, + GREEN_INTEGER = 0x8D95, + BLUE_INTEGER = 0x8D96, + RGB_INTEGER = 0x8D98, + RGBA_INTEGER = 0x8D99, + BGR_INTEGER = 0x8D9A, + BGRA_INTEGER = 0x8D9B, + SAMPLER_1D_ARRAY = 0x8DC0, + SAMPLER_2D_ARRAY = 0x8DC1, + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3, + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4, + SAMPLER_CUBE_SHADOW = 0x8DC5, + UNSIGNED_INT_VEC2 = 0x8DC6, + UNSIGNED_INT_VEC3 = 0x8DC7, + UNSIGNED_INT_VEC4 = 0x8DC8, + INT_SAMPLER_1D = 0x8DC9, + INT_SAMPLER_2D = 0x8DCA, + INT_SAMPLER_3D = 0x8DCB, + INT_SAMPLER_CUBE = 0x8DCC, + INT_SAMPLER_1D_ARRAY = 0x8DCE, + INT_SAMPLER_2D_ARRAY = 0x8DCF, + UNSIGNED_INT_SAMPLER_1D = 0x8DD1, + UNSIGNED_INT_SAMPLER_2D = 0x8DD2, + UNSIGNED_INT_SAMPLER_3D = 0x8DD3, + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4, + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6, + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7, + QUERY_WAIT = 0x8E13, + QUERY_NO_WAIT = 0x8E14, + QUERY_BY_REGION_WAIT = 0x8E15, + QUERY_BY_REGION_NO_WAIT = 0x8E16, + BUFFER_ACCESS_FLAGS = 0x911F, + BUFFER_MAP_LENGTH = 0x9120, + BUFFER_MAP_OFFSET = 0x9121, + DEPTH_COMPONENT32F = 0x8CAC, + DEPTH32F_STENCIL8 = 0x8CAD, + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD, + INVALID_FRAMEBUFFER_OPERATION = 0x0506, + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210, + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211, + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212, + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213, + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214, + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215, + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216, + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217, + FRAMEBUFFER_DEFAULT = 0x8218, + FRAMEBUFFER_UNDEFINED = 0x8219, + DEPTH_STENCIL_ATTACHMENT = 0x821A, + MAX_RENDERBUFFER_SIZE = 0x84E8, + DEPTH_STENCIL = 0x84F9, + UNSIGNED_INT_24_8 = 0x84FA, + DEPTH24_STENCIL8 = 0x88F0, + TEXTURE_STENCIL_SIZE = 0x88F1, + TEXTURE_RED_TYPE = 0x8C10, + TEXTURE_GREEN_TYPE = 0x8C11, + TEXTURE_BLUE_TYPE = 0x8C12, + TEXTURE_ALPHA_TYPE = 0x8C13, + TEXTURE_DEPTH_TYPE = 0x8C16, + UNSIGNED_NORMALIZED = 0x8C17, + FRAMEBUFFER_BINDING = 0x8CA6, + DRAW_FRAMEBUFFER_BINDING = 0x8CA6, + RENDERBUFFER_BINDING = 0x8CA7, + READ_FRAMEBUFFER = 0x8CA8, + DRAW_FRAMEBUFFER = 0x8CA9, + READ_FRAMEBUFFER_BINDING = 0x8CAA, + RENDERBUFFER_SAMPLES = 0x8CAB, + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0, + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1, + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2, + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3, + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4, + FRAMEBUFFER_COMPLETE = 0x8CD5, + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6, + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7, + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB, + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC, + FRAMEBUFFER_UNSUPPORTED = 0x8CDD, + MAX_COLOR_ATTACHMENTS = 0x8CDF, + COLOR_ATTACHMENT0 = 0x8CE0, + COLOR_ATTACHMENT1 = 0x8CE1, + COLOR_ATTACHMENT2 = 0x8CE2, + COLOR_ATTACHMENT3 = 0x8CE3, + COLOR_ATTACHMENT4 = 0x8CE4, + COLOR_ATTACHMENT5 = 0x8CE5, + COLOR_ATTACHMENT6 = 0x8CE6, + COLOR_ATTACHMENT7 = 0x8CE7, + COLOR_ATTACHMENT8 = 0x8CE8, + COLOR_ATTACHMENT9 = 0x8CE9, + COLOR_ATTACHMENT10 = 0x8CEA, + COLOR_ATTACHMENT11 = 0x8CEB, + COLOR_ATTACHMENT12 = 0x8CEC, + COLOR_ATTACHMENT13 = 0x8CED, + COLOR_ATTACHMENT14 = 0x8CEE, + COLOR_ATTACHMENT15 = 0x8CEF, + COLOR_ATTACHMENT16 = 0x8CF0, + COLOR_ATTACHMENT17 = 0x8CF1, + COLOR_ATTACHMENT18 = 0x8CF2, + COLOR_ATTACHMENT19 = 0x8CF3, + COLOR_ATTACHMENT20 = 0x8CF4, + COLOR_ATTACHMENT21 = 0x8CF5, + COLOR_ATTACHMENT22 = 0x8CF6, + COLOR_ATTACHMENT23 = 0x8CF7, + COLOR_ATTACHMENT24 = 0x8CF8, + COLOR_ATTACHMENT25 = 0x8CF9, + COLOR_ATTACHMENT26 = 0x8CFA, + COLOR_ATTACHMENT27 = 0x8CFB, + COLOR_ATTACHMENT28 = 0x8CFC, + COLOR_ATTACHMENT29 = 0x8CFD, + COLOR_ATTACHMENT30 = 0x8CFE, + COLOR_ATTACHMENT31 = 0x8CFF, + DEPTH_ATTACHMENT = 0x8D00, + STENCIL_ATTACHMENT = 0x8D20, + FRAMEBUFFER = 0x8D40, + RENDERBUFFER = 0x8D41, + RENDERBUFFER_WIDTH = 0x8D42, + RENDERBUFFER_HEIGHT = 0x8D43, + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44, + STENCIL_INDEX1 = 0x8D46, + STENCIL_INDEX4 = 0x8D47, + STENCIL_INDEX8 = 0x8D48, + STENCIL_INDEX16 = 0x8D49, + RENDERBUFFER_RED_SIZE = 0x8D50, + RENDERBUFFER_GREEN_SIZE = 0x8D51, + RENDERBUFFER_BLUE_SIZE = 0x8D52, + RENDERBUFFER_ALPHA_SIZE = 0x8D53, + RENDERBUFFER_DEPTH_SIZE = 0x8D54, + RENDERBUFFER_STENCIL_SIZE = 0x8D55, + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56, + MAX_SAMPLES = 0x8D57, + INDEX = 0x8222, + TEXTURE_LUMINANCE_TYPE = 0x8C14, + TEXTURE_INTENSITY_TYPE = 0x8C15, + FRAMEBUFFER_SRGB = 0x8DB9, + HALF_FLOAT = 0x140B, + MAP_READ_BIT = 0x0001, + MAP_WRITE_BIT = 0x0002, + MAP_INVALIDATE_RANGE_BIT = 0x0004, + MAP_INVALIDATE_BUFFER_BIT = 0x0008, + MAP_FLUSH_EXPLICIT_BIT = 0x0010, + MAP_UNSYNCHRONIZED_BIT = 0x0020, + COMPRESSED_RED_RGTC1 = 0x8DBB, + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC, + COMPRESSED_RG_RGTC2 = 0x8DBD, + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE, + RG = 0x8227, + RG_INTEGER = 0x8228, + R8 = 0x8229, + R16 = 0x822A, + RG8 = 0x822B, + RG16 = 0x822C, + R16F = 0x822D, + R32F = 0x822E, + RG16F = 0x822F, + RG32F = 0x8230, + R8I = 0x8231, + R8UI = 0x8232, + R16I = 0x8233, + R16UI = 0x8234, + R32I = 0x8235, + R32UI = 0x8236, + RG8I = 0x8237, + RG8UI = 0x8238, + RG16I = 0x8239, + RG16UI = 0x823A, + RG32I = 0x823B, + RG32UI = 0x823C, + VERTEX_ARRAY_BINDING = 0x85B5, + CLAMP_VERTEX_COLOR = 0x891A, + CLAMP_FRAGMENT_COLOR = 0x891B, + ALPHA_INTEGER = 0x8D97, + SAMPLER_2D_RECT = 0x8B63, + SAMPLER_2D_RECT_SHADOW = 0x8B64, + SAMPLER_BUFFER = 0x8DC2, + INT_SAMPLER_2D_RECT = 0x8DCD, + INT_SAMPLER_BUFFER = 0x8DD0, + UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5, + UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8, + TEXTURE_BUFFER = 0x8C2A, + MAX_TEXTURE_BUFFER_SIZE = 0x8C2B, + TEXTURE_BINDING_BUFFER = 0x8C2C, + TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D, + TEXTURE_RECTANGLE = 0x84F5, + TEXTURE_BINDING_RECTANGLE = 0x84F6, + PROXY_TEXTURE_RECTANGLE = 0x84F7, + MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8, + R8_SNORM = 0x8F94, + RG8_SNORM = 0x8F95, + RGB8_SNORM = 0x8F96, + RGBA8_SNORM = 0x8F97, + R16_SNORM = 0x8F98, + RG16_SNORM = 0x8F99, + RGB16_SNORM = 0x8F9A, + RGBA16_SNORM = 0x8F9B, + SIGNED_NORMALIZED = 0x8F9C, + PRIMITIVE_RESTART = 0x8F9D, + PRIMITIVE_RESTART_INDEX = 0x8F9E, + COPY_READ_BUFFER = 0x8F36, + COPY_WRITE_BUFFER = 0x8F37, + UNIFORM_BUFFER = 0x8A11, + UNIFORM_BUFFER_BINDING = 0x8A28, + UNIFORM_BUFFER_START = 0x8A29, + UNIFORM_BUFFER_SIZE = 0x8A2A, + MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B, + MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C, + MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D, + MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E, + MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F, + MAX_UNIFORM_BLOCK_SIZE = 0x8A30, + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31, + MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32, + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33, + UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34, + ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35, + ACTIVE_UNIFORM_BLOCKS = 0x8A36, + UNIFORM_TYPE = 0x8A37, + UNIFORM_SIZE = 0x8A38, + UNIFORM_NAME_LENGTH = 0x8A39, + UNIFORM_BLOCK_INDEX = 0x8A3A, + UNIFORM_OFFSET = 0x8A3B, + UNIFORM_ARRAY_STRIDE = 0x8A3C, + UNIFORM_MATRIX_STRIDE = 0x8A3D, + UNIFORM_IS_ROW_MAJOR = 0x8A3E, + UNIFORM_BLOCK_BINDING = 0x8A3F, + UNIFORM_BLOCK_DATA_SIZE = 0x8A40, + UNIFORM_BLOCK_NAME_LENGTH = 0x8A41, + UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42, + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43, + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44, + UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45, + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46, + INVALID_INDEX = 0xFFFFFFFF, + CONTEXT_CORE_PROFILE_BIT = 0x00000001, + CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002, + LINES_ADJACENCY = 0x000A, + LINE_STRIP_ADJACENCY = 0x000B, + TRIANGLES_ADJACENCY = 0x000C, + TRIANGLE_STRIP_ADJACENCY = 0x000D, + PROGRAM_POINT_SIZE = 0x8642, + MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29, + FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7, + FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8, + GEOMETRY_SHADER = 0x8DD9, + GEOMETRY_VERTICES_OUT = 0x8916, + GEOMETRY_INPUT_TYPE = 0x8917, + GEOMETRY_OUTPUT_TYPE = 0x8918, + MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF, + MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0, + MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1, + MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122, + MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123, + MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124, + MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125, + CONTEXT_PROFILE_MASK = 0x9126, + DEPTH_CLAMP = 0x864F, + QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C, + FIRST_VERTEX_CONVENTION = 0x8E4D, + LAST_VERTEX_CONVENTION = 0x8E4E, + PROVOKING_VERTEX = 0x8E4F, + TEXTURE_CUBE_MAP_SEAMLESS = 0x884F, + MAX_SERVER_WAIT_TIMEOUT = 0x9111, + OBJECT_TYPE = 0x9112, + SYNC_CONDITION = 0x9113, + SYNC_STATUS = 0x9114, + SYNC_FLAGS = 0x9115, + SYNC_FENCE = 0x9116, + SYNC_GPU_COMMANDS_COMPLETE = 0x9117, + UNSIGNALED = 0x9118, + SIGNALED = 0x9119, + ALREADY_SIGNALED = 0x911A, + TIMEOUT_EXPIRED = 0x911B, + CONDITION_SATISFIED = 0x911C, + WAIT_FAILED = 0x911D, + TIMEOUT_IGNORED = -1, + SYNC_FLUSH_COMMANDS_BIT = 0x00000001, + SAMPLE_POSITION = 0x8E50, + SAMPLE_MASK = 0x8E51, + SAMPLE_MASK_VALUE = 0x8E52, + MAX_SAMPLE_MASK_WORDS = 0x8E59, + TEXTURE_2D_MULTISAMPLE = 0x9100, + PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101, + TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102, + PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103, + TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104, + TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105, + TEXTURE_SAMPLES = 0x9106, + TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107, + SAMPLER_2D_MULTISAMPLE = 0x9108, + INT_SAMPLER_2D_MULTISAMPLE = 0x9109, + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A, + SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B, + INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C, + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D, + MAX_COLOR_TEXTURE_SAMPLES = 0x910E, + MAX_DEPTH_TEXTURE_SAMPLES = 0x910F, + MAX_INTEGER_SAMPLES = 0x9110, + VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE, + SRC1_COLOR = 0x88F9, + ONE_MINUS_SRC1_COLOR = 0x88FA, + ONE_MINUS_SRC1_ALPHA = 0x88FB, + MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC, + ANY_SAMPLES_PASSED = 0x8C2F, + SAMPLER_BINDING = 0x8919, + RGB10_A2UI = 0x906F, + TEXTURE_SWIZZLE_R = 0x8E42, + TEXTURE_SWIZZLE_G = 0x8E43, + TEXTURE_SWIZZLE_B = 0x8E44, + TEXTURE_SWIZZLE_A = 0x8E45, + TEXTURE_SWIZZLE_RGBA = 0x8E46, + TIME_ELAPSED = 0x88BF, + TIMESTAMP = 0x8E28, + INT_2_10_10_10_REV = 0x8D9F, +} alias GLE = GLEnum; diff --git a/opengl/opengl.d b/opengl/opengl.d new file mode 100644 index 0000000..3da2223 --- /dev/null +++ b/opengl/opengl.d @@ -0,0 +1,81 @@ +import dlib.aliases; +import dlib.util; +import dlib.alloc; + +static if(NativeTarget) +{ + import dlibincludes; + public import opengl_native; +} +else +{ + public import opengl_wasm; +} + +public import glenum; + +u32 +GLCreateShader(GLEnum shader_type, string[] shader_src) +{ + i32[32] src_lengths; + immutable(char)*[32] src_ptrs; + for(usize i = 0; i < shader_src.length; i += 1) + { + src_ptrs[i] = shader_src[i].ptr; + src_lengths[i] = cast(i32)shader_src[i].length; + } + + u32 shader = glCreateShader(shader_type); + glShaderSource(shader, cast(u32)shader_src.length, src_ptrs.ptr, src_lengths.ptr); + + i32 success; + glGetShaderiv(shader, GLE.COMPILE_STATUS, &success); + if(!success) + { + char[512] info_log; + i32 log_length; + glGetShaderInfoLog(shader, cast(u32)info_log.length, &log_length, info_log.ptr); + + Errf("Error compiling shader: %s", Str(info_log[0 .. log_length])); + shader = 0; + } + + return shader; +} + +u32 +GLCreateProgramFromSources(string[] vertex_src, string[] fragment_src) +{ + u32 program; + + u32 vertex_shader = GLCreateShader(GLE.VERTEX_SHADER, vertex_src); + u32 fragment_shader = GLCreateShader(GLE.FRAGMENT_SHADER, fragment_src); + if(vertex_shader && fragment_shader) + { + program = glCreateProgram(); + glAttachShader(program, vertex_shader); + glAttachShader(program, fragment_shader); + glLinkProgram(program); + + i32 success; + glGetProgramiv(program, GLE.LINK_STATUS, &success); + if(!success) + { + char[512] info_log; + i32 log_length; + glGetProgramInfoLog(program, cast(u32)info_log.length, &log_length, info_log.ptr); + + Errf("Error compiling program: %s", Str(info_log[0 .. log_length])); + + program = 0; + } + } + + if(!program) + { + Errf("Failed to create program!"); + } + + return program; +} + diff --git a/opengl/opengl_native.d b/opengl/opengl_native.d new file mode 100644 index 0000000..2ecd3be --- /dev/null +++ b/opengl/opengl_native.d @@ -0,0 +1,50 @@ +import dlibincludes; + +// TODO: fix on js side + +alias PFNGLXCREATECONTEXTATTRIBSARBPROC = extern(C) GLXContext function(Display*, GLXFBConfig, GLXContext, int, const int*); + +PFNGLXCREATECONTEXTATTRIBSARBPROC glXCreateContextAttribsARB; +PFNGLDELETERENDERBUFFERSPROC glDeleteRenderbuffers; +PFNGLGENRENDERBUFFERSPROC glGenRenderbuffers; +PFNGLGENVERTEXARRAYSPROC glGenVertexArrays; +PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays; +PFNGLGENBUFFERSPROC glGenBuffers; +PFNGLCOMPILESHADERPROC glCompileShader; +PFNGLUSEPROGRAMPROC glUseProgram; +PFNGLVALIDATEPROGRAMPROC glValidateProgram; +PFNGLBINDBUFFERBASEPROC glBindBufferBase; +PFNGLGETUNIFORMBLOCKINDEXPROC glGetUniformBlockIndex; +PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray; +PFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate; +PFNGLBINDVERTEXARRAYPROC glBindVertexArray; +PFNGLBINDBUFFERPROC glBindBuffer; +PFNGLBUFFERDATAPROC glBufferData; +PFNGLBUFFERSUBDATAPROC glBufferSubData; +PFNGLVERTEXATTRIBDIVISORPROC glVertexAttribDivisor; +PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer; +PFNGLDRAWARRAYSINSTANCEDPROC glDrawArraysInstanced; +PFNGLDRAWELEMENTSINSTANCEDPROC glDrawElementsInstanced; +PFNGLACTIVETEXTUREPROC glActiveTexture; +PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation; +PFNGLUNIFORM1FPROC glUniform1f; +PFNGLUNIFORM2FPROC glUniform2f; +PFNGLUNIFORM3FPROC glUniform3f; +PFNGLUNIFORM4FPROC glUniform4f; +PFNGLUNIFORM1IPROC glUniform1i; +PFNGLUNIFORM2IPROC glUniform2i; +PFNGLUNIFORM3IPROC glUniform3i; +PFNGLUNIFORM4IPROC glUniform4i; +PFNGLCREATEPROGRAMPROC glCreateProgram; +PFNGLCREATESHADERPROC glCreateShader; +PFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers; +PFNGLDELETEPROGRAMPROC glDeleteProgram; +PFNGLDELETESHADERPROC glDeleteShader; +PFNGLSHADERSOURCEPROC glShaderSource; +PFNGLGETPROGRAMIVPROC glGetProgramiv; +PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog; +PFNGLGETSHADERIVPROC glGetShaderiv; +PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog; +PFNGLATTACHSHADERPROC glAttachShader; +PFNGLLINKPROGRAMPROC glLinkProgram; diff --git a/opengl/opengl_wasm.d b/opengl/opengl_wasm.d new file mode 100644 index 0000000..2caad9f --- /dev/null +++ b/opengl/opengl_wasm.d @@ -0,0 +1,216 @@ +import ldc.attributes; + +import dlib.aliases; + +import glenum; + +version(WebAssembly): + +enum WebGLAttributes +{ + None = 0<<0, + NoAlpha = 1<<0, + NoAntiAliasing = 1<<1, + NoDepth = 1<<2, + FailIfMajorPerformanceCaveat = 1<<3, + NoPremultipliedAlpha = 1<<4, + PreserveDrawingBuffer = 1<<5, + Stencil = 1<<6, + Desynchronized = 1<<7, +} alias WGLA = WebGLAttributes; + +import wasm; + +extern(C) @llvmAttr("wasm-import-module", "gl"): + +@WasmName!("GenRenderbuffers") void +glGenRenderbuffers(usize n, u32* renderbuffers); + +@WasmName!("DeleteBuffers") void +glDeleteBuffers(usize n, const u32* buffers); + +@WasmName!("DeleteFramebuffers") void +glDeleteFramebuffers(usize n, const u32* framebuffers); + +@WasmName!("GenBuffers") u32 +glGenBuffers(usize n, u32* buffers); + +@WasmName!("DeleteRenderbuffers") void +glDeleteRenderbuffers(usize n, const u32* renderbuffers); + +@WasmName!("GenTextures") u32 +glCreateTextures(usize n, u32* textures); + +@WasmName!("GenVertexArrays") void +glGenVertexArrays(usize n, u32* vaos); + +@WasmName!("DeleteVertexArrays") void +glDeleteVertexArrays(usize n, const u32* vaos); + +@WasmName!("DeleteTextures") void +glDeleteTextures(usize n, const u32* textures); + +@WasmName!("SetCurrentContextById") b32 +glSetCurrentContextByID(string id); + +@WasmName!("CreateCurrentContextById") b32 +glCreateCurrentContextByID(string id, WebGLAttributes); + +@WasmName!("Clear") void +glClear(u32 bits); + +@WasmName!("ClearColor") void +glClearColor(f32 red, f32 green, f32 blue, f32 alpha); + +@WasmName!("ClearDepth") void +glClearDepth(f32 depth); + +@WasmName!("ClearStencil") void +glClearStencil(i32 s); + +@WasmName!("ColorMask") void +glColorMask(u32 red, u32 green, u32 blue, u32 alpha); + +@WasmName!("CompileShader") void +glCompileShader(u32 shader); + +@WasmName!("UseProgram") void +glUseProgram(u32 program); + +@WasmName!("ValidateProgram") void +glValidateProgram(u32 program); + +@WasmName!("BindBufferBase") void +glBindBufferBase(GLEnum target, u32 index, u32 buffer); + +@WasmName!("GetUniformBlockIndex") u32 +glGetUniformBlockIndex(u32 program, const char* uniform_block_name); + +@WasmName!("CullFace") void +glCullFace(GLEnum mode); + +@WasmName!("Enable") void +glEnable(GLEnum cap); + +@WasmName!("Disable") void +glDisable(GLEnum cap); + +@WasmName!("EnableVertexAttribArray") void +glEnableVertexAttribArray(u32 index); + +@WasmName!("DisableVertexAttribArray") void +glDisableVertexAttribArray(u32 index); + +@WasmName!("FrontFace") void +glFrontFace(GLEnum mode); + +@WasmName!("BlendFuncSeparate") void +glBlendFuncSeparate(GLEnum src_rgb, GLEnum dst_rgb, GLEnum src_alpha, GLEnum dst_alpha); + +@WasmName!("BindTexture") void +glBindTexture(GLEnum target, u32 texture); + +@WasmName!("TexParameterf") void +glTexParameterf(GLEnum target, GLEnum pname, f32 param); + +@WasmName!("TexParameteri") void +glTexParameteri(GLEnum target, GLEnum pname, i32 param); + +@WasmName!("TexImage2D") void +glTexImage2D(GLEnum target, i32 level, i32 internal_format, usize width, usize height, i32 border, GLEnum format, GLEnum type, const void* data); + +@WasmName!("BindVertexArray") void +glBindVertexArray(u32 vao); + +@WasmName!("BlendFunc") void +glBlendFunc(GLEnum sfactor, GLEnum dfactor); + +@WasmName!("BindBuffer") void +glBindBuffer(GLEnum target, u32 buffer); + +@WasmName!("BufferData") void +glBufferData(GLEnum target, usize size, const void* data, GLEnum usage); + +@WasmName!("BufferSubData") void +glBufferSubData(GLEnum target, usize offset, usize size, const void* data); + +@WasmName!("VertexAttribDivisor") void +glVertexAttribDivisor(u32 index, u32 divisor); + +@WasmName!("VertexAttribPointer") void +glVertexAttribPointer(u32 index, i32 size, GLEnum type, b32 normalized, usize stride, const void* pointer); + +@WasmName!("Viewport") void +glViewport(i32 x, i32 y, usize width, usize height); + +@WasmName!("DrawArraysInstanced") void +glDrawArraysInstanced(GLEnum mode, i32 first, usize count, usize instance_count); + +@WasmName!("DrawElementsInstanced") void +glDrawElementsInstanced(GLEnum mode, usize count, GLEnum type, const void* indices, usize instance_count); + +@WasmName!("ActiveTexture") void +glActiveTexture(GLEnum texture); + +@WasmName!("GetUniformLocation") i32 +glGetUniformLocation(u32 program, const char* name); + +@WasmName!("Uniform1f") void +glUniform1f(i32 location, f32 v0); + +@WasmName!("Uniform2f") void +glUniform2f(i32 location, f32 v0, f32 v1); + +@WasmName!("Uniform3f") void +glUniform3f(i32 location, f32 v0, f32 v1, f32 v2); + +@WasmName!("Uniform4f") void +glUniform4f(i32 location, f32 v0, f32 v1, f32 v2, f32 v3); + +@WasmName!("Uniform1i") void +glUniform1i(i32 location, i32 v0); + +@WasmName!("Uniform2i") void +glUniform2i(i32 location, i32 v0, i32 v1); + +@WasmName!("Uniform3i") void +glUniform3i(i32 location, i32 v0, i32 v1, i32 v2); + +@WasmName!("Uniform4i") void +glUniform4i(i32 location, i32 v0, i32 v1, i32 v2, i32 v3); + +@WasmName!("CreateProgram") u32 +glCreateProgram(); + +@WasmName!("CreateShader") u32 +glCreateShader(GLEnum shader_type); + +@WasmName!("DeleteProgram") void +glDeleteProgram(u32 program); + +@WasmName!("DeleteShader") void +glDeleteShader(u32 shader); + +@WasmName!("ShaderSource") void +glShaderSource(u32 shader, usize count, const char** string, const i32* length); + +@WasmName!("Scissor") void +glScissor(i32 x, i32 y, usize width, usize height); + +@WasmName!("GetProgramiv") void +glGetProgramiv(u32 program, GLEnum pname, i32* params); + +@WasmName!("GetProgramInfoLog") void +glGetProgramInfoLog(u32 program, i32 max_length, i32* length, char* info_log); + +@WasmName!("GetShaderiv") void +glGetShaderiv(u32 shader, GLEnum pname, i32* params); + +@WasmName!("GetShaderInfoLog") void +glGetShaderInfoLog(u32 shader, i32 max_length, i32* length, char* info_log); + +@WasmName!("AttachShader") void +glAttachShader(u32 program, u32 shader); + +@WasmName!("LinkProgram") void +glLinkProgram(u32 program); diff --git a/test.sh b/test.sh index 878e450..e2910b6 100755 --- a/test.sh +++ b/test.sh @@ -32,7 +32,12 @@ if [ "$1" == "wasm" ]; then -gcc=clang "--of=$out" ) - declare -a wasm_src=(wasm/runtime/object.d) + declare -a wasm_src=( + wasm/runtime/object.d + opengl/opengl_wasm.d + opengl/opengl.d + opengl/glenum.d + ) ldc2 "${flags[@]}" "${shared_src[@]}" "${wasm_src[@]}" @@ -66,16 +71,25 @@ else native_src+=( vulkan/vulkan.d vulkan/vulkan_funcs.d + opengl/opengl.d + opengl/opengl_native.d + opengl/glenum.d build/libvma.a ) flags+=( -L-lvulkan -L-lstdc++ + -L-lGL + -L-lX11 + -L-lXfixes -Jbuild -d-version=VULKAN_RENDERER_TEST -d-version=DLIB_ASSETS + -d-version=COMPILE_TEST + -d-version=BUILD_GL -Xcc=-DBUILD_VULKAN -Xcc=-DBUILD_ASSETS + -Xcc=-DBUILD_GL ) # Test for compilation diff --git a/wasm/runtime/wasm.d b/wasm/runtime/wasm.d index 00371bc..0ab8d9a 100644 --- a/wasm/runtime/wasm.d +++ b/wasm/runtime/wasm.d @@ -36,35 +36,43 @@ enum SprintfType : size_t Pointer, } +template WasmModule(string _module) +{ + enum WasmModule = llvmAttr("wasm-import-module", _module); +} +template WasmName(string name) +{ + enum WasmName = llvmAttr("wasm-import-name", name); +} -extern extern(C) @llvmAttr("wasm-import-module", "env"): +extern extern(C) @WasmModule!("env"): -@llvmAttr("wasm-import-name", "Console") void +@WasmName!("Console") void Console(string str, bool write_line); -@llvmAttr("wasm-import-name", "Console2") void +@WasmName!("Console2") void Console2(size_t length, const(void)* ptr, bool write_line); -@llvmAttr("wasm-import-name", "Abort") void +@WasmName!("Abort") void Abort(string message) @nogc; -@llvmAttr("wasm-import-name", "SprintfLoadValue") void +@WasmName!("SprintfLoadValue") void SprintfLoadValue(const(void)* ptr, SprintfType type) @nogc; -@llvmAttr("wasm-import-name", "SprintfLoadArray") void +@WasmName!("SprintfLoadArray") void SprintfLoadArray(size_t length, const(void)* ptr, SprintfType type) @nogc; -@llvmAttr("wasm-import-name", "SprintfEnd") size_t +@WasmName!("SprintfEnd") size_t SprintfEnd(char[] buffer, string format) @nogc; -@llvmAttr("wasm-import-name", "pow") double +@WasmName!("pow") double pow(double base, double exponent) @nogc; -@llvmAttr("wasm-import-name", "cos") double +@WasmName!("cos") double cos(double x) @nogc; -@llvmAttr("wasm-import-name", "acos") double +@WasmName!("acos") double acos(double x) @nogc; void diff --git a/wasm/wasm.js b/wasm/wasm.js index bb3ba6a..fd57d4e 100644 --- a/wasm/wasm.js +++ b/wasm/wasm.js @@ -27,7 +27,8 @@ const TYPES = { CharArray: 25, }; -let LoadSize = null; +let LoadSize = null; +let StoreSize = null; function assert(condition, message) { @@ -38,39 +39,139 @@ function assert(condition, message) } } -const wasm_manager = { - memory: null, - data_view: null, - stdout_string: "", - sprintf_values: [], - ptr_size: 4, -}; +let MEMORY = null; +let DATA_VIEW = null; +let GL = null; +let STDOUT_STRING = ""; +let SPRINF_VALUES = []; +let PTR_SIZE = 4; +let GL_ELEMENT = null; +let GL_VERSION = 1.0; + +let GL_LAST_ERROR = 0; +let GL_CURRENT_ID = 1; +let BUFFERS = new Map([0, null]); +let PROGRAMS = new Map([0, null]); +let FRAMEBUFFERS = new Map([0, null]); +let RENDERBUFFERS = new Map([0, null]); +let TEXTURES = new Map([0, null]); +let UNIFORMS = new Map([0, null]); +let SHADERS = new Map([0, null]); +let VAOS = new Map([0, null]); +let QUERIES = new Map([0, null]); +let SAMPLERS = new Map([0, null]); +let TRANSFORM_FEEDBACK = new Map([0, null]); +let SYNCS = new Map([0, null]); +let PROGRAM_INFO = new Map([0, null]); function InitWasmManager(memory, ptr_size = 4) { - wasm_manager.ptr_size = ptr_size; + PTR_SIZE = ptr_size; - wasm_manager.sprintf_values = []; + SPRINTF_VALUES = []; - wasm_manager.stdout_string = ""; + STDOUT_STRING = ""; - switch(wasm_manager.ptr_size) + switch(PTR_SIZE) { - case 8: LoadSize = LoadU64; break; + case 8: LoadSize = LoadU64; StoreSize = StoreU64; break; case 4: - default: LoadSize = LoadU32; break; + default: LoadSize = LoadU32; StoreSize = StoreU32; break; } } function SetMemory(memory) { - wasm_manager.memory = memory; - wasm_manager.data_view = new DataView(wasm_manager.memory.buffer); + MEMORY = memory; + DATA_VIEW = new DataView(MEMORY.buffer); } function Memory() { - return new DataView(wasm_manager.memory.buffer); + return new DataView(MEMORY.buffer); +} + +function GLRemoveItem(map, id) +{ + map.delete(id); +} + +function GLGetItem(map, id) +{ + return map.has(id) ? map.get(id) : null; +} + +function GLAddItem(map, item) +{ + map.set(GL_CURRENT_ID, item); + return GL_CURRENT_ID++; +} + +function SetGLError(error) +{ + if(!GL_LAST_ERROR) GL_LAST_ERROR = error; +} + +function SetGLContext(element, settings) +{ + if(!element) return false; + if(GL_ELEMENT == element) return true; + + settings ??= {}; + GL = element.getContext("webgl2", settings) || element.getContext("webgl", settings); + if(GL) + { + GL_ELEMENT = element; + GL_VERSION = GL.getParameter(0x1F02).indexOf("WebGL 2.0") !== -1 ? 2.0 : 1.0; + } + + return !!GL; +} + +function AssertWebGL2() +{ + if(GL_VERSION < 2.0) + { + throw new Error("WebGL2 function called without a WebGL2 enabled context"); + } +} + +function PopulateUniformTable(program) +{ + let p = GLGetItem(PROGRAMS, program); + PROGRAM_INFO[program] = { + uniforms: {}, + maxUniformLength: 0, + maxAttributeLength: -1, + maxUniformBlockNameLength: -1, + }; + + let ptable = PROGRAM_INFO[program]; + let utable = ptable.uniforms; + let numUniforms = GL.getProgramParameter(p, GL.ACTIVE_UNIFORMS); + + for(i = 0; i < numUniforms; ++i) + { + let u = GL.getActiveUniform(p, i); + let name = u.name; + if(ptable.maxUniformLength = Math.max(ptable.maxUniformLength, name.length + 1), name.indexOf("]", name.length - 1) !== -1) + { + name = name.slice(0, name.lastIndexOf("[")); + } + + let loc = GL.getUniformLocation(p, name); + if(loc !== null) + { + let id = GLAddItem(UNIFORMS, loc); + utable[name] = [u.size, id]; + for(let j = 1; j < u.size; ++j) + { + let n = name + "[" + j + "]"; + let loc = GL.getUniformLocation(p, n); + GLAddItem(UNIFORMS, loc); + } + } + } } function LoadBool(addr) { return Boolean(Memory().getUint8(addr, true)); } @@ -99,7 +200,7 @@ function LoadI64(addr) function LoadArray(array_class, length, addr) { - return new array_class(wasm_manager.memory.buffer, addr, length); + return new array_class(MEMORY.buffer, addr, length); } function LoadString(length, addr) @@ -120,13 +221,47 @@ function LoadCString(ptr) function StoreString(ptr, value) { const src = new TextEncoder().encode(value); - const dst = new Uint8Array(wasm_manager.memory.buffer, ptr, src.length); + const dst = new Uint8Array(MEMORY.buffer, ptr, src.length); dst.set(src); return src.length; } +function StoreU8(addr, value) { Memory().setUint8(addr, value, true); } +function StoreI8(addr, value) { Memory().setInt8 (addr, value, true); } +function StoreU16(addr, value) { Memory().setUint16(addr, value, true); } +function StoreI16(addr, value) { Memory().setInt16(addr, value, true); } +function StoreU32(addr, value) { Memory().setUint32(addr, value, true); } +function StoreI32(addr, value) { Memory().setInt32(addr, value, true); } + +function StoreU64(addr, value) +{ + let div = 4294967296; + if(typeof value === 'bigint') + { + div = BigInt(div); + } + + StoreU32(addr+0, Number(value), true); + StoreU32(addr+4, Math.floor(Number(value/div)), true); +} + +function StoreI64(addr, value) +{ + let div = 4294967296; + if(typeof value === 'bigint') + { + div = BigInt(div); + } + + StoreI32(addr+0, Number(value), true); + StoreI32(addr+4, Math.floor(Number(value/div)), true); +} + +function StoreF32(addr, value) { Memory().setFloat32(addr, value, true); } +function StoreF64(addr, value) { Memory().setFloat64(addr, value, true); } + const imports = { env: { Abort(string_length, string_ptr) @@ -158,11 +293,11 @@ const imports = { { if(type === TYPES.Bool) { - wasm_manager.sprintf_values.push(value ? 'true' : 'false'); + SPRINTF_VALUES.push(value ? 'true' : 'false'); } else { - wasm_manager.sprintf_values.push(''+value); + SPRINTF_VALUES.push(''+value); } } }, @@ -192,7 +327,7 @@ const imports = { value = `[${value.join(", ")}]`; } - wasm_manager.sprintf_values.push(value); + SPRINTF_VALUES.push(value); } }, SprintfEnd(buffer_length, buffer_ptr, string_length, string_ptr) @@ -212,7 +347,7 @@ const imports = { } let value_index = 0; - for(; value_index < wasm_manager.sprintf_values.length;) + for(; value_index < SPRINTF_VALUES.length;) { assert(format.length); @@ -240,7 +375,7 @@ const imports = { continue; } - result += wasm_manager.sprintf_values[value_index++]; + result += SPRINTF_VALUES[value_index++]; format = format.substring(digit_index); Next(); @@ -249,7 +384,7 @@ const imports = { } else if((char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z')) { - result += wasm_manager.sprintf_values[value_index++]; + result += SPRINTF_VALUES[value_index++]; format = format.substring(2); Next(); } @@ -261,37 +396,1371 @@ const imports = { const bytes_written = StoreString(buffer_ptr, result); assert(bytes_written <= buffer_length, "Format string is longer than buffer length"); - wasm_manager.sprintf_values = []; + SPRINTF_VALUES = []; return bytes_written; }, Console(string_length, string_ptr, write_line) { - wasm_manager.stdout_string += LoadString(string_length, string_ptr); + STDOUT_STRING += LoadString(string_length, string_ptr); const arr = LoadArray(Uint8Array, string_length, string_ptr); - if(write_line || wasm_manager.stdout_string.includes("\n")) + if(write_line || STDOUT_STRING.includes("\n")) { - console.log(wasm_manager.stdout_string); - wasm_manager.stdout_string = ""; + console.log(STDOUT_STRING); + STDOUT_STRING = ""; } }, Console2(string_length, string_ptr, write_line) { - wasm_manager.stdout_string += LoadString(string_length, string_ptr); + STDOUT_STRING += LoadString(string_length, string_ptr); const arr = LoadArray(Uint8Array, string_length, string_ptr); - if(write_line || wasm_manager.stdout_string.includes("\n")) + if(write_line || STDOUT_STRING.includes("\n")) { - console.log(wasm_manager.stdout_string); - wasm_manager.stdout_string = ""; + console.log(STDOUT_STRING); + STDOUT_STRING = ""; } }, pow: Math.pow, cos: Math.cos, acos: Math.acos, }, -} + gl: { + SetCurrentContextById: (name_length, name_ptr) => + { + let name = LoadString(name_length, name_ptr); + let element = getElement(name); + return SetGLContext(element, {alpha: true, antialias: true, depth: true, premultipliedAlpha: true}); + }, + CreateCurrentContextById: (name_length, name_ptr, attributes) => + { + let name = LoadString(name_length, name_ptr); + let element = getElement(name); + + let contextSettings = { + alpha: ! (attributes & (1<<0)), + antialias: ! (attributes & (1<<1)), + depth: ! (attributes & (1<<2)), + failIfMajorPerformanceCaveat: !!(attributes & (1<<3)), + premultipliedAlpha: ! (attributes & (1<<4)), + preserveDrawingBuffer: !!(attributes & (1<<5)), + stencil: !!(attributes & (1<<6)), + desynchronized: !!(attributes & (1<<7)), + }; + + return SetGLContext(element, contextSettings); + }, + Clear: (x) => { + GL.clear(x); + }, + ClearColor: (r, g, b, a) => { + GL.clearColor(r, g, b, a); + }, + ClearDepth: (x) => { + GL.clearDepth(x); + }, + ClearStencil: (x) => { + GL.clearStencil(x); + }, + ColorMask: (r, g, b, a) => { + GL.colorMask(!!r, !!g, !!b, !!a); + }, + CompileShader: (shader) => { + if(shader) + { + GL.compileShader(GLGetItem(SHADERS, shader)); + } + }, + UseProgram: (program) => { + if(program) + { + GL.useProgram(GLGetItem(PROGRAMS, program)); + } + }, + ValidateProgram: (program) => { + if(program) + { + GL.validateProgram(GLGetItem(PROGRAMS, program)); + } + }, + BindBufferBase: (target, index, buffer) => { + AssertWebGL2(); + GL.bindBufferBase(target, index, GLGetItem(BUFFERS, buffer)); + }, + GetUniformBlockIndex: (program, uniformBlockName_ptr) => { + AssertWebGL2(); + return GL.getUniformBlockIndex(GLGetItem(PROGRAMS, program), LoadCString(uniformBlockName_ptr)); + }, + GenTextures: (count, texture_ptr) => + { + for(let i = 0; i < count; i += 1) + { + const id = GLAddItem(TEXTURES, GL.createTexture()); + StoreU32(texture_ptr+4*i, id); + } + }, + CullFace: (mode) => + { + GL.cullFace(mode); + }, + GenBuffers: (count, buffer_ptr) => + { + for(let i = 0; i < count; i += 1) + { + const id = GLAddItem(BUFFERS, GL.createBuffer()); + StoreU32(buffer_ptr+4*i, id); + } + }, + Enable: (cap) => + { + GL.enable(cap); + }, + EnableVertexAttribArray: (index) => + { + GL.enableVertexAttribArray(index); + }, + Disable: (cap) => + { + GL.disable(cap); + }, + DisableVertexAttribArray: (index) => + { + GL.disableVertexAttribArray(index); + }, + FrontFace: (mode) => + { + GL.frontFace(mode); + }, + BlendFuncSeparate: (srcRGB, dstRGB, srcAlpha, dstAlpha) => + { + GL.blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); + }, + BindTexture: (target, texture) => + { + GL.bindTexture(target, GLGetItem(TEXTURES, texture)); + }, + TexParameterf: (target, pname, param) => + { + GL.texParameterf(target, pname, param); + }, + TexParameteri: (target, pname, param) => + { + GL.texParameteri(target, pname, param); + }, + TexImage2D: (target, level, internalformat, width, height, border, format, type, size, data) => + { + let buffer = null; + + if(data) + { + switch(internalformat) + { + case GL.RGBA32F: + case GL.RGB32F: + case GL.RG32F: + case GL.R32F: buffer = LoadArray(Float32Array, size, data); break; + case GL.RGBA32UI: + case GL.RGB32UI: + case GL.RG32UI: + case GL.R32UI: buffer = LoadArray(Uint32Array, size, data); break; + case GL.RGBA32I: + case GL.RGB32I: + case GL.RG32I: + case GL.R32I: buffer = LoadArray(Int32Array, size, data); break; + default: buffer = LoadArray(Uint8Array, size, data); break; + } + } + + GL.texImage2D(target, level, internalformat, width, height, border, format, type, buffer); + }, + GenVertexArrays: (count, vao_ptr) => + { + AssertWebGL2(); + for(let i = 0; i < count; i += 1) + { + const id = GLAddItem(VAOS, GL.createVertexArray()); + StoreU32(vao_ptr+4*i, id); + } + }, + DeleteVertexArrays: (count, vao_ptr) => + { + AssertWebGL2(); + + const vaos = LoadArray(Uint32Array, count, vao_ptr); + for(let i = 0; i < vaos.length; i += 1) + { + const id = vaos[i]; + let obj = GLGetItem(VAOS, id); + if(obj) + { + GL.deleteVertexArray(obj); + GLRemoveItem(VAOS, id); + } + } + }, + BindVertexArray: (vertexArray) => + { + AssertWebGL2(); + GL.bindVertexArray(GLGetItem(VAOS, vertexArray)); + }, + BlendFunc: (sfactor, dfactor) => + { + GL.blendFunc(sfactor, dfactor); + }, + BindBuffer: (target, buffer) => + { + let bufferObj = GLGetItem(BUFFERS, buffer); + if(target == 35051) + { + GL.currentPixelPackBufferBinding = buffer; + } + else + { + if(target == 35052) + { + GL.currentPixelUnpackBufferBinding = buffer; + } + GL.bindBuffer(target, bufferObj) + } + }, + BufferData: (target, size, data, usage) => + { + if(data) + { + GL.bufferData(target, LoadArray(Uint8Array, size, data), usage); + } + else + { + GL.bufferData(target, size, usage); + } + }, + BufferSubData: (target, offset, size, data) => + { + if(data) + { + GL.bufferSubData(target, offset, LoadArray(Uint8Array, size, data)); + } + else + { + GL.bufferSubData(target, offset, null); + } + }, + VertexAttribDivisor: (index, divisor) => + { + AssertWebGL2(); + GL.vertexAttribDivisor(index, divisor); + }, + VertexAttribPointer: (index, size, type, normalized, stride, ptr) => + { + GL.vertexAttribPointer(index, size, type, !!normalized, stride, ptr); + }, + Viewport: (x, y, w, h) => + { + if(GLELEMENT) + { + GLELEMENT.width = w; + GLELEMENT.height = h; + } + + GL.viewport(x, y, w, h); + }, + DrawArraysInstanced: (mode, first, count, instanceCount) => + { + AssertWebGL2(); + GL.drawArraysInstanced(mode, first, count, instanceCount); + }, + DrawElementsInstanced: (mode, count, type, offset, instanceCount) => + { + AssertWebGL2(); + GL.drawElementsInstanced(mode, count, type, offset, instanceCount); + }, + ActiveTexture: (x) => + { + GL.activeTexture(x); + }, + GetUniformLocation: (program, name_ptr) => + { + let name = LoadCString(name_ptr); + let arrayOffset = 0; + if(name.indexOf("]", name.length - 1) !== -1) + { + let ls = name.lastIndexOf("["); + let arrayIndex = name.slice(ls + 1, -1); + if(arrayIndex.length > 0 && (arrayOffset = parseInt(arrayIndex)) < 0) + { + return -1; + } + + name = name.slice(0, ls) + } + + let ptable = PROGRAM_INFO[program]; + if(!ptable) + { + return -1; + } + var uniformInfo = ptable.uniforms[name]; + return (uniformInfo && arrayOffset < uniformInfo[0]) ? uniformInfo[1] + arrayOffset : -1 + }, + Uniform1f: (location, v0) => { GL.uniform1f(GLGetItem(UNIFORMS, location), v0); }, + Uniform2f: (location, v0, v1) => { GL.uniform2f(GLGetItem(UNIFORMS, location), v0, v1); }, + Uniform3f: (location, v0, v1, v2) => { GL.uniform3f(GLGetItem(UNIFORMS, location), v0, v1, v2); }, + Uniform4f: (location, v0, v1, v2, v3) => { GL.uniform4f(GLGetItem(UNIFORMS, location), v0, v1, v2, v3); }, + Uniform1i: (location, v0) => { GL.uniform1i(GLGetItem(UNIFORMS, location), v0); }, + Uniform2i: (location, v0, v1) => { GL.uniform2i(GLGetItem(UNIFORMS, location), v0, v1); }, + Uniform3i: (location, v0, v1, v2) => { GL.uniform3i(GLGetItem(UNIFORMS, location), v0, v1, v2); }, + Uniform4i: (location, v0, v1, v2, v3) => { GL.uniform4i(GLGetItem(UNIFORMS, location), v0, v1, v2, v3); }, + UniformMatrix2fv: (location, addr) => + { + let array = LoadArray(Float32Array, 2*2, addr); + GL.uniformMatrix2fv(GLGetItem(UNIFORMS, location), false, array); + }, + UniformMatrix3fv: (location, addr) => + { + let array = LoadArray(Float32Array, 3*3, addr); + GL.uniformMatrix3fv(GLGetItem(UNIFORMS, location), false, array); + }, + UniformMatrix4fv: (location, addr) => + { + let array = LoadArray(Float32Array, 4*4, addr); + GL.uniformMatrix4fv(GLGetItem(UNIFORMS, location), false, array); + }, + CreateProgram: () => + { + return GLAddItem(PROGRAMS, GL.createProgram()); + }, + GenRenderbuffer: (count, renderbuffer_ptr) => + { + for(let i = 0; i < count; i += 1) + { + const id = GLAddItem(RENDERBUFFERS, GL.createRenderbuffer()); + StoreU32(renderbuffer_ptr+4*i, id); + } + }, + CreateShader: (shaderType) => + { + return GLAddItem(SHADERS, GL.createShader(shaderType)); + }, + DeleteBuffers: (count, buffer_ptr) => + { + const buffers = LoadArray(Uint32Array, count, buffer_ptr); + for(let i = 0; i < buffers.length; i += 1) + { + const id = buffers[i]; + let obj = GLGetItem(BUFFERS, id); + if(obj && id != 0) + { + GL.deleteBuffer(obj); + GLRemoveItem(BUFFERS, id); + } + } + }, + DeleteFramebuffers: (count, framebuffer_ptr) => + { + const framebuffers = LoadArray(Uint32Array, count, framebuffer_ptr); + for(let i = 0; i < framebuffers.length; i += 1) + { + const id = framebuffers[i]; + let obj = GLGetItem(FRAMEBUFFERS, id); + if(obj && id != 0) + { + GL.deleteFramebuffer(obj); + GLRemoveItem(FRAMEBUFFERS, id); + } + } + }, + DeleteProgram: (id) => + { + let obj = GLGetItem(PROGRAMS, id); + if(obj && id != 0) + { + GL.deleteProgram(obj); + GLRemoveItem(PROGRAMS, id); + } + }, + DeleteRenderbuffers: (count, renderbuffer_ptr) => + { + const renderbuffers = LoadArray(Uint32Array, count, renderbuffer_ptr); + for(let i = 0; i < renderbuffers.length; i += 1) + { + const id = renderbuffers[i]; + let obj = GLGetItem(RENDERBUFFERS, id); + if(obj && id != 0) + { + GL.deleteRenderbuffer(obj); + GLRemoveItem(RENDERBUFFERS, id); + } + } + }, + DeleteShader: (id) => + { + let obj = GLGetItem(SHADERS, id); + if(obj && id != 0) + { + GL.deleteShader(obj); + GLRemoveItem(SHADERS, id); + } + }, + DeleteTextures: (count, texture_ptr) => + { + const textures = LoadArray(Uint32Array, count, texture_ptr); + for(let i = 0; i < textures.length; i += 1) + { + const id = textures[i]; + let obj = GLGetItem(TEXTURES, id); + if(obj && id != 0) + { + GL.deleteTexture(obj); + GLRemoveItem(TEXTURES, id); + } + } + }, + Scissor: (x, y, width, height) => + { + GL.scissor(x, y, width, height); + }, + ShaderSource: (shader, count, strings_ptr, lengths_ptr) => + { + let lengths = null; + if(lengths_ptr) + { + lengths = LoadArray(Uint32Array, count, lengths_ptr); + } + + let source = ""; + for(let i = 0; i < count; i += 1) + { + const addr = LoadSize(strings_ptr + i*PTR_SIZE); + let source_part = lengths && (lengths?.[i] ?? 0) > 0 ? LoadString(lengths[i], addr) : LoadCString(addr); + + source += source_part; + } + + GL.shaderSource(GLGetItem(SHADERS, shader), source); + }, + GetError: () => + { + let err = GL_LAST_ERROR; + SetGLError(0); + if(err) + { + return err; + } + + return GL.getError(); + }, + GetProgramiv: (program, pname, ptr) => + { + const param = GL.getProgramParameter(GLGetItem(PROGRAMS, program), pname); + StoreI32(ptr, param); + }, + GetProgramInfoLog: (program, buf_length, buf_ptr, length_ptr) => + { + let log = GL.getProgramInfoLog(GLGetItem(PROGRAMS, program)); + if(log === null) + { + log = "(unknown error)"; + } + + if(buf_len > 0 && buf_ptr) + { + let n = Math.min(buf_len, log.length); + log = log.substring(0, n); + LoadArray(Uint8Array, buf_length, buf_ptr).set(new TextEncoder().encode(log)) + + StoreSize(length_ptr, n); + } + }, + GetShaderInfoLog: (shader, buf_ptr, buf_len, length_ptr) => + { + let log = GL.getShaderInfoLog(GLGetItem(SHADERS, shader)); + if(log === null) + { + log = "(unknown error)"; + } + + if(buf_len > 0 && buf_ptr) + { + let n = Math.min(buf_len, log.length); + log = log.substring(0, n); + LoadArray(Uint8Array, buf_len, buf_ptr).set(new TextEncoder().encode(log)) + + StoreSize(length_ptr, n); + } + }, + GetShaderiv: (shader_id, pname, p) => { + const shader = GLGetItem(SHADERS, shader); + if(p && shader) + { + if(pname == 35716) + { + let log = GL.getShaderInfoLog(shader); + if(log === null) + { + log = "(unknown error)"; + } + + StoreSize(p, log.length+1); + } + else if(pname == 35720) + { + let source = GL.getShaderSource(shader); + let sourceLength = (source === null || source.length == 0) ? 0 : source.length+1; + this.mem.storeInt(p, sourceLength); + } + else + { + let param = GL.getShaderParameter(shader, pname); + StoreI32(p, param); + } + } + else + { + SetGLError(1281); + } + }, + AttachShader: (program, shader) => + { + GL.attachShader(GLGetItem(PROGRAMS, program), GLGetItem(SHADERS, shader)); + }, + LinkProgram: (program) => + { + GL.linkProgram(GLGetItem(PROGRAMS, program)); + PROGRAM_INFO[program] = null; + PopulateUniformTable(program); + }, + }, +}; + +const other_gl_funcs = { + webgl: { + GetCurrentContextAttributes: () => { + if(!GL) { + return 0; + } + let attrs = GL.getContextAttributes(); + let res = 0; + if(!attrs.alpha) res |= 1<<0; + if(!attrs.antialias) res |= 1<<1; + if(!attrs.depth) res |= 1<<2; + if(attrs.failIfMajorPerformanceCaveat) res |= 1<<3; + if(!attrs.premultipliedAlpha) res |= 1<<4; + if(attrs.preserveDrawingBuffer) res |= 1<<5; + if(attrs.stencil) res |= 1<<6; + if(attrs.desynchronized) res |= 1<<7; + return res; + }, + + DrawingBufferWidth: () => GL.drawingBufferWidth, + DrawingBufferHeight: () => GL.drawingBufferHeight, + + IsExtensionSupported: (name_length, name_ptr) => { + let name = LoadString(name_length, name_ptr); + let extensions = GL.getSupportedExtensions(); + return extensions.indexOf(name) !== -1 + }, + + + GetWebGLVersion: (major_ptr, minor_ptr) => { + let version = GL.getParameter(0x1F02); + if(version.indexOf("WebGL 2.0") !== -1) { + this.mem.storeI32(major_ptr, 2); + this.mem.storeI32(minor_ptr, 0); + return; + } + + this.mem.storeI32(major_ptr, 1); + this.mem.storeI32(minor_ptr, 0); + }, + GetESVersion: (major_ptr, minor_ptr) => { + let version = GL.getParameter(0x1F02); + if(version.indexOf("OpenGL ES 3.0") !== -1) { + this.mem.storeI32(major_ptr, 3); + this.mem.storeI32(minor_ptr, 0); + return; + } + + this.mem.storeI32(major_ptr, 2); + this.mem.storeI32(minor_ptr, 0); + }, + BindAttribLocation: (program, index, name_length, name_ptr) => { + let name = LoadString(name_length, name_ptr); + GL.bindAttribLocation(PROGRAMS[program], index, name) + }, + BindFramebuffer: (target, framebuffer) => { + GL.bindFramebuffer(target, framebuffer ? FRAMEBUFFERS[framebuffer] : null) + }, + BlendColor: (red, green, blue, alpha) => { + GL.blendColor(red, green, blue, alpha); + }, + BlendEquation: (mode) => { + GL.blendEquation(mode); + }, + BlendEquationSeparate: (modeRGB, modeAlpha) => { + GL.blendEquationSeparate(modeRGB, modeAlpha); + }, + CompressedTexImage2D: (target, level, internalformat, width, height, border, imageSize, data) => { + if(data) { + GL.compressedTexImage2D(target, level, internalformat, width, height, border, this.mem.loadBytes(data, imageSize)); + } else { + GL.compressedTexImage2D(target, level, internalformat, width, height, border, null); + } + }, + CompressedTexSubImage2D: (target, level, xoffset, yoffset, width, height, format, imageSize, data) => { + if(data) { + GL.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, this.mem.loadBytes(data, imageSize)); + } else { + GL.compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, null); + } + }, + CopyTexImage2D: (target, level, internalformat, x, y, width, height, border) => { + GL.copyTexImage2D(target, level, internalformat, x, y, width, height, border); + }, + CopyTexSubImage2D: (target, level, xoffset, yoffset, x, y, width, height) => { + GL.copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); + }, + CreateFramebuffer: () => { + let buffer = GL.createFramebuffer(); + let id = this.getNewId(FRAMEBUFFERS); + buffer.name = id + FRAMEBUFFERS[id] = buffer; + return id; + }, + Clear: (x) => { + GL.clear(x); + }, + ClearColor: (r, g, b, a) => { + GL.clearColor(r, g, b, a); + }, + ClearDepth: (x) => { + GL.clearDepth(x); + }, + ClearStencil: (x) => { + GL.clearStencil(x); + }, + ColorMask: (r, g, b, a) => { + GL.colorMask(!!r, !!g, !!b, !!a); + }, + CompileShader: (shader) => { + GL.compileShader(SHADERS[shader]); + }, + UseProgram: (program) => { + if(program) GL.useProgram(PROGRAMS[program]); + }, + ValidateProgram: (program) => { + if(program) GL.validateProgram(PROGRAMS[program]); + }, + BindBufferBase: (target, index, buffer) => { + AssertWebGL2(); + GL.bindBufferBase(target, index, BUFFERS[buffer]); + }, + GetUniformBlockIndex: (program, uniformBlockName_ptr, uniformBlockName_len) => { + AssertWebGL2(); + return GL.getUniformBlockIndex(PROGRAMS[program], this.mem.loadString(uniformBlockName_ptr, uniformBlockName_len)); + }, + CullFace: (mode) => { + GL.cullFace(mode); + }, + CreateBuffer: () => { + let buffer = GL.createBuffer(); + if(!buffer) { + SetGLError(1282); + return 0; + } + let id = this.getNewId(BUFFERS); + buffer.name = id + BUFFERS[id] = buffer; + return id; + }, + Enable: (cap) => { + GL.enable(cap); + }, + EnableVertexAttribArray: (index) => { + GL.enableVertexAttribArray(index); + }, + Disable: (cap) => { + GL.disable(cap); + }, + DisableVertexAttribArray: (index) => { + GL.disableVertexAttribArray(index); + }, + FrontFace: (mode) => { + GL.frontFace(mode); + }, + BlendFuncSeparate: (srcRGB, dstRGB, srcAlpha, dstAlpha) => { + GL.blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); + }, + BindTexture: (target, texture) => { + GL.bindTexture(target, texture ? TEXTURES[texture] : null) + }, + TexParameterf: (target, pname, param) => { + GL.texParameterf(target, pname, param); + }, + TexParameteri: (target, pname, param) => { + GL.texParameteri(target, pname, param); + }, + TexImage2D: (target, level, internalformat, width, height, border, format, type, size, data) => { + let buffer = null; + + if(data) + { + switch(internalformat) + { + case GL.RGBA32F: + case GL.RGB32F: + case GL.RG32F: + case GL.R32F: buffer = this.mem.loadF32Array(data, size); break; + case GL.RGBA32UI: + case GL.RGB32UI: + case GL.RG32UI: + case GL.R32UI: buffer = this.mem.loadU32Array(data, size); break; + case GL.RGBA32I: + case GL.RGB32I: + case GL.RG32I: + case GL.R32I: buffer = this.mem.loadI32Array(data, size); break; + default: buffer = this.mem.loadBytes(data, size); break; + } + } + + GL.texImage2D(target, level, internalformat, width, height, border, format, type, buffer); + }, + DeleteVertexArray: (id) => { + AssertWebGL2(); + let obj = VAOS[id]; + if(obj && id != 0) { + GL.deleteVertexArray(obj); + VAOS[id] = null; + } + }, + BindVertexArray: (vertexArray) => { + AssertWebGL2(); + GL.bindVertexArray(VAOS[vertexArray]); + }, + BlendFunc: (sfactor, dfactor) => { + GL.blendFunc(sfactor, dfactor); + }, + BindBuffer: (target, buffer) => { + let bufferObj = buffer ? BUFFERS[buffer] : null; + if(target == 35051) { + GL.currentPixelPackBufferBinding = buffer; + } else { + if(target == 35052) { + GL.currentPixelUnpackBufferBinding = buffer; + } + GL.bindBuffer(target, bufferObj) + } + }, + BufferData: (target, size, data, usage) => { + if(data) { + GL.bufferData(target, this.mem.loadBytes(data, size), usage); + } else { + GL.bufferData(target, size, usage); + } + }, + BufferSubData: (target, offset, size, data) => { + if(data) { + GL.bufferSubData(target, offset, this.mem.loadBytes(data, size)); + } else { + GL.bufferSubData(target, offset, null); + } + }, + VertexAttribDivisor: (index, divisor) => { + AssertWebGL2(); + GL.vertexAttribDivisor(index, divisor); + }, + VertexAttribPointer: (index, size, type, normalized, stride, ptr) => { + GL.vertexAttribPointer(index, size, type, !!normalized, stride, ptr); + }, + Viewport: (x, y, w, h) => { + if(GLELEMENT) + { + GLELEMENT.width = w; + GLELEMENT.height = h; + } + + GL.viewport(x, y, w, h); + }, + DrawArraysInstanced: (mode, first, count, instanceCount) => { + AssertWebGL2(); + GL.drawArraysInstanced(mode, first, count, instanceCount); + }, + DrawElementsInstanced: (mode, count, type, offset, instanceCount) => { + AssertWebGL2(); + GL.drawElementsInstanced(mode, count, type, offset, instanceCount); + }, + ActiveTexture: (x) => { + GL.activeTexture(x); + }, + GetUniformLocation: (program, name_ptr, name_len) => { + let name = this.mem.loadString(name_ptr, name_len); + let arrayOffset = 0; + if(name.indexOf("]", name.length - 1) !== -1) { + let ls = name.lastIndexOf("["), + arrayIndex = name.slice(ls + 1, -1); + if(arrayIndex.length > 0 && (arrayOffset = parseInt(arrayIndex)) < 0) { + return -1; + } + name = name.slice(0, ls) + } + var ptable = PROGRAM_INFO[program]; + if(!ptable) { + return -1; + } + var uniformInfo = ptable.uniforms[name]; + return (uniformInfo && arrayOffset < uniformInfo[0]) ? uniformInfo[1] + arrayOffset : -1 + }, + Uniform1f: (location, v0) => { GL.uniform1f(GLGetItem(UNIFORMS, location), v0); }, + Uniform2f: (location, v0, v1) => { GL.uniform2f(GLGetItem(UNIFORMS, location), v0, v1); }, + Uniform3f: (location, v0, v1, v2) => { GL.uniform3f(GLGetItem(UNIFORMS, location), v0, v1, v2); }, + Uniform4f: (location, v0, v1, v2, v3) => { GL.uniform4f(GLGetItem(UNIFORMS, location), v0, v1, v2, v3); }, + Uniform1i: (location, v0) => { GL.uniform1i(GLGetItem(UNIFORMS, location), v0); }, + Uniform2i: (location, v0, v1) => { GL.uniform2i(GLGetItem(UNIFORMS, location), v0, v1); }, + Uniform3i: (location, v0, v1, v2) => { GL.uniform3i(GLGetItem(UNIFORMS, location), v0, v1, v2); }, + Uniform4i: (location, v0, v1, v2, v3) => { GL.uniform4i(GLGetItem(UNIFORMS, location), v0, v1, v2, v3); }, + UniformMatrix2fv: (location, addr) => { + let array = this.mem.loadF32Array(addr, 2*2); + GL.uniformMatrix2fv(GLGetItem(UNIFORMS, location), false, array); + }, + UniformMatrix3fv: (location, addr) => { + let array = this.mem.loadF32Array(addr, 3*3); + GL.uniformMatrix3fv(GLGetItem(UNIFORMS, location), false, array); + }, + UniformMatrix4fv: (location, addr) => { + let array = this.mem.loadF32Array(addr, 4*4); + GL.uniformMatrix4fv(GLGetItem(UNIFORMS, location), false, array); + }, + CreateProgram: () => { + let program = GL.createProgram(); + let id = this.getNewId(PROGRAMS); + program.name = id; + PROGRAMS[id] = program; + return id; + }, + CreateRenderbuffer: () => { + let buffer = GL.createRenderbuffer(); + let id = this.getNewId(RENDERBUFFERS); + buffer.name = id; + RENDERBUFFERS[id] = buffer; + return id; + }, + CreateShader: (shaderType) => { + let shader = GL.createShader(shaderType); + let id = this.getNewId(SHADERS); + shader.name = id; + SHADERS[id] = shader; + return id; + }, + DeleteBuffer: (id) => { + let obj = BUFFERS[id]; + if(obj && id != 0) { + GL.deleteBuffer(obj); + BUFFERS[id] = null; + } + }, + DeleteProgram: (id) => { + let obj = PROGRAMS[id]; + if(obj && id != 0) { + GL.deleteProgram(obj); + PROGRAMS[id] = null; + } + }, + DeleteRenderbuffer: (id) => { + let obj = RENDERBUFFERS[id]; + if(obj && id != 0) { + GL.deleteRenderbuffer(obj); + RENDERBUFFERS[id] = null; + } + }, + DeleteShader: (id) => { + let obj = SHADERS[id]; + if(obj && id != 0) { + GL.deleteShader(obj); + SHADERS[id] = null; + } + }, + DepthFunc: (func) => { + GL.depthFunc(func); + }, + DepthMask: (flag) => { + GL.depthMask(!!flag); + }, + DepthRange: (zNear, zFar) => { + GL.depthRange(zNear, zFar); + }, + DetachShader: (program, shader) => { + GL.detachShader(PROGRAMS[program], SHADERS[shader]); + }, + DrawArrays: (mode, first, count) => { + GL.drawArrays(mode, first, count); + }, + DrawElements: (mode, count, type, indices) => { + GL.drawElements(mode, count, type, indices); + }, + Finish: () => { + GL.finish(); + }, + Flush: () => { + GL.flush(); + }, + FramebufferRenderbuffer: (target, attachment, renderbuffertarget, renderbuffer) => { + GL.framebufferRenderbuffer(target, attachment, renderbuffertarget, RENDERBUFFERS[renderbuffer]); + }, + FramebufferTexture2D: (target, attachment, textarget, texture, level) => { + GL.framebufferTexture2D(target, attachment, textarget, TEXTURES[texture], level); + }, + GenerateMipmap: (target) => { + GL.generateMipmap(target); + }, + GetAttribLocation: (program, name_length, name_ptr) => { + let name = LoadString(name_length, name_ptr); + return GL.getAttribLocation(PROGRAMS[program], name); + }, + GetParameter: (pname) => { + return GL.getParameter(pname); + }, + GetParameter4i: (pname, v0, v1, v2, v3) => { + const i4 = GL.getParameter(pname); + this.mem.storeI32(v0, i4[0]); + this.mem.storeI32(v1, i4[1]); + this.mem.storeI32(v2, i4[2]); + this.mem.storeI32(v3, i4[3]); + }, + GetVertexAttribOffset: (index, pname) => { + return GL.getVertexAttribOffset(index, pname); + }, + Hint: (target, mode) => { + GL.hint(target, mode); + }, + IsBuffer: (buffer) => GL.isBuffer(BUFFERS[buffer]), + IsEnabled: (cap) => GL.isEnabled(cap), + IsFramebuffer: (framebuffer) => GL.isFramebuffer(FRAMEBUFFERS[framebuffer]), + IsProgram: (program) => GL.isProgram(PROGRAMS[program]), + IsRenderbuffer: (renderbuffer) => GL.isRenderbuffer(RENDERBUFFERS[renderbuffer]), + IsShader: (shader) => GL.isShader(SHADERS[shader]), + IsTexture: (texture) => GL.isTexture(TEXTURES[texture]), + LineWidth: (width) => { + GL.lineWidth(width); + }, + PixelStorei: (pname, param) => { + GL.pixelStorei(pname, param); + }, + PolygonOffset: (factor, units) => { + GL.polygonOffset(factor, units); + }, + ReadnPixels: (x, y, width, height, format, type, bufSize, data) => { + GL.readPixels(x, y, width, height, format, type, this.mem.loadBytes(data, bufSize)); + }, + RenderbufferStorage: (target, internalformat, width, height) => { + GL.renderbufferStorage(target, internalformat, width, height); + }, + SampleCoverage: (value, invert) => { + GL.sampleCoverage(value, !!invert); + }, + StencilFunc: (func, ref, mask) => { + GL.stencilFunc(func, ref, mask); + }, + StencilFuncSeparate: (face, func, ref, mask) => { + GL.stencilFuncSeparate(face, func, ref, mask); + }, + StencilMask: (mask) => { + GL.stencilMask(mask); + }, + StencilMaskSeparate: (face, mask) => { + GL.stencilMaskSeparate(face, mask); + }, + StencilOp: (fail, zfail, zpass) => { + GL.stencilOp(fail, zfail, zpass); + }, + StencilOpSeparate: (face, fail, zfail, zpass) => { + GL.stencilOpSeparate(face, fail, zfail, zpass); + }, + TexSubImage2D: (target, level, xoffset, yoffset, width, height, format, type, size, data) => { + GL.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, this.mem.loadBytes(data, size)); + }, + VertexAttrib1f: (index, x) => { + GL.vertexAttrib1f(index, x); + }, + VertexAttrib2f: (index, x, y) => { + GL.vertexAttrib2f(index, x, y); + }, + VertexAttrib3f: (index, x, y, z) => { + GL.vertexAttrib3f(index, x, y, z); + }, + VertexAttrib4f: (index, x, y, z, w) => { + GL.vertexAttrib4f(index, x, y, z, w); + }, + }, + webgl2: { + CopyBufferSubData: (readTarget, writeTarget, readOffset, writeOffset, size) => { + AssertWebGL2(); + GL.copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); + }, + GetBufferSubData: (target, srcByteOffset, dst_buffer_ptr, dst_buffer_len, dstOffset, length) => { + AssertWebGL2(); + GL.getBufferSubData(target, srcByteOffset, this.mem.loadBytes(dst_buffer_ptr, dst_buffer_len), dstOffset, length); + }, + /* Framebuffer objects */ + BlitFramebuffer: (srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter) => { + AssertWebGL2(); + GL.blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); + }, + FramebufferTextureLayer: (target, attachment, texture, level, layer) => { + AssertWebGL2(); + GL.framebufferTextureLayer(target, attachment, TEXTURES[texture], level, layer); + }, + InvalidateFramebuffer: (target, attachments_ptr, attachments_len) => { + AssertWebGL2(); + let attachments = this.mem.loadU32Array(attachments_ptr, attachments_len); + GL.invalidateFramebuffer(target, attachments); + }, + InvalidateSubFramebuffer: (target, attachments_ptr, attachments_len, x, y, width, height) => { + AssertWebGL2(); + let attachments = this.mem.loadU32Array(attachments_ptr, attachments_len); + GL.invalidateSubFramebuffer(target, attachments, x, y, width, height); + }, + ReadBuffer: (src) => { + AssertWebGL2(); + GL.readBuffer(src); + }, + + /* Renderbuffer objects */ + RenderbufferStorageMultisample: (target, samples, internalformat, width, height) => { + AssertWebGL2(); + GL.renderbufferStorageMultisample(target, samples, internalformat, width, height); + }, + + /* Texture objects */ + + TexStorage3D: (target, levels, internalformat, width, height, depth) => { + AssertWebGL2(); + GL.texStorage3D(target, levels, internalformat, width, height, depth); + }, + TexImage3D: (target, level, internalformat, width, height, depth, border, format, type, size, data) => { + AssertWebGL2(); + if(data) { + GL.texImage3D(target, level, internalformat, width, height, depth, border, format, type, this.mem.loadBytes(data, size)); + } else { + GL.texImage3D(target, level, internalformat, width, height, depth, border, format, type, null); + } + }, + TexSubImage3D: (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, size, data) => { + AssertWebGL2(); + GL.texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, this.mem.loadBytes(data, size)); + }, + CompressedTexImage3D: (target, level, internalformat, width, height, depth, border, imageSize, data) => { + AssertWebGL2(); + if(data) { + GL.compressedTexImage3D(target, level, internalformat, width, height, depth, border, this.mem.loadBytes(data, imageSize)); + } else { + GL.compressedTexImage3D(target, level, internalformat, width, height, depth, border, null); + } + }, + CompressedTexSubImage3D: (target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data) => { + AssertWebGL2(); + if(data) { + GL.compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, this.mem.loadBytes(data, imageSize)); + } else { + GL.compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, null); + } + }, + + CopyTexSubImage3D: (target, level, xoffset, yoffset, zoffset, x, y, width, height) => { + AssertWebGL2(); + GL.copyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); + }, + + /* Programs and shaders */ + GetFragDataLocation: (program, name_ptr, name_len) => { + AssertWebGL2(); + return GL.getFragDataLocation(PROGRAMS[program], this.mem.loadString(name_ptr, name_len)); + }, + + /* Uniforms */ + Uniform1ui: (location, v0) => { + AssertWebGL2(); + GL.uniform1ui(GLGetItem(UNIFORMS, location), v0); + }, + Uniform2ui: (location, v0, v1) => { + AssertWebGL2(); + GL.uniform2ui(GLGetItem(UNIFORMS, location), v0, v1); + }, + Uniform3ui: (location, v0, v1, v2) => { + AssertWebGL2(); + GL.uniform3ui(GLGetItem(UNIFORMS, location), v0, v1, v2); + }, + Uniform4ui: (location, v0, v1, v2, v3) => { + AssertWebGL2(); + GL.uniform4ui(GLGetItem(UNIFORMS, location), v0, v1, v2, v3); + }, + + UniformMatrix3x2fv: (location, addr) => { + AssertWebGL2(); + let array = this.mem.loadF32Array(addr, 3*2); + GL.uniformMatrix3x2fv(GLGetItem(UNIFORMS, location), false, array); + }, + UniformMatrix4x2fv: (location, addr) => { + AssertWebGL2(); + let array = this.mem.loadF32Array(addr, 4*2); + GL.uniformMatrix4x2fv(GLGetItem(UNIFORMS, location), false, array); + }, + UniformMatrix2x3fv: (location, addr) => { + AssertWebGL2(); + let array = this.mem.loadF32Array(addr, 2*3); + GL.uniformMatrix2x3fv(GLGetItem(UNIFORMS, location), false, array); + }, + UniformMatrix4x3fv: (location, addr) => { + AssertWebGL2(); + let array = this.mem.loadF32Array(addr, 4*3); + GL.uniformMatrix4x3fv(GLGetItem(UNIFORMS, location), false, array); + }, + UniformMatrix2x4fv: (location, addr) => { + AssertWebGL2(); + let array = this.mem.loadF32Array(addr, 2*4); + GL.uniformMatrix2x4fv(GLGetItem(UNIFORMS, location), false, array); + }, + UniformMatrix3x4fv: (location, addr) => { + AssertWebGL2(); + let array = this.mem.loadF32Array(addr, 3*4); + GL.uniformMatrix3x4fv(GLGetItem(UNIFORMS, location), false, array); + }, + + /* Vertex attribs */ + VertexAttribI4i: (index, x, y, z, w) => { + AssertWebGL2(); + GL.vertexAttribI4i(index, x, y, z, w); + }, + VertexAttribI4ui: (index, x, y, z, w) => { + AssertWebGL2(); + GL.vertexAttribI4ui(index, x, y, z, w); + }, + VertexAttribIPointer: (index, size, type, stride, offset) => { + AssertWebGL2(); + GL.vertexAttribIPointer(index, size, type, stride, offset); + }, + + /* Writing to the drawing buffer */ + DrawRangeElements: (mode, start, end, count, type, offset) => { + AssertWebGL2(); + GL.drawRangeElements(mode, start, end, count, type, offset); + }, + + /* Multiple Render Targets */ + DrawBuffers: (buffers_ptr, buffers_len) => { + AssertWebGL2(); + let array = this.mem.loadU32Array(buffers_ptr, buffers_len); + GL.drawBuffers(array); + }, + ClearBufferfv: (buffer, drawbuffer, values_ptr, values_len) => { + AssertWebGL2(); + let array = this.mem.loadF32Array(values_ptr, values_len); + GL.clearBufferfv(buffer, drawbuffer, array); + }, + ClearBufferiv: (buffer, drawbuffer, values_ptr, values_len) => { + AssertWebGL2(); + let array = this.mem.loadI32Array(values_ptr, values_len); + GL.clearBufferiv(buffer, drawbuffer, array); + }, + ClearBufferuiv: (buffer, drawbuffer, values_ptr, values_len) => { + AssertWebGL2(); + let array = this.mem.loadU32Array(values_ptr, values_len); + GL.clearBufferuiv(buffer, drawbuffer, array); + }, + ClearBufferfi: (buffer, drawbuffer, depth, stencil) => { + AssertWebGL2(); + GL.clearBufferfi(buffer, drawbuffer, depth, stencil); + }, + + /* Query Objects */ + CreateQuery: () => { + AssertWebGL2(); + let query = GL.createQuery(); + let id = this.getNewId(QUERIES); + query.name = id; + QUERIES[id] = query; + return id; + }, + DeleteQuery: (id) => { + AssertWebGL2(); + let obj = QUERIES[id]; + if(obj && id != 0) { + GL.deleteQuery(obj); + QUERIES[id] = null; + } + }, + IsQuery: (query) => { + AssertWebGL2(); + return GL.isQuery(QUERIES[query]); + }, + BeginQuery: (target, query) => { + AssertWebGL2(); + GL.beginQuery(target, QUERIES[query]) + }, + EndQuery: (target) => { + AssertWebGL2(); + GL.endQuery(target); + }, + GetQuery: (target, pname) => { + AssertWebGL2(); + let query = GL.getQuery(target, pname); + if(!query) { + return 0; + } + if(QUERIES.indexOf(query) !== -1) { + return query.name; + } + let id = this.getNewId(QUERIES); + query.name = id; + QUERIES[id] = query; + return id; + }, + + /* Sampler Objects */ + CreateSampler: () => { + AssertWebGL2(); + let sampler = GL.createSampler(); + let id = this.getNewId(this.samplers); + sampler.name = id; + this.samplers[id] = sampler; + return id; + }, + DeleteSampler: (id) => { + AssertWebGL2(); + let obj = this.samplers[id]; + if(obj && id != 0) { + GL.deleteSampler(obj); + this.samplers[id] = null; + } + }, + IsSampler: (sampler) => { + AssertWebGL2(); + return GL.isSampler(this.samplers[sampler]); + }, + BindSampler: (unit, sampler) => { + AssertWebGL2(); + GL.bindSampler(unit, this.samplers[sampler]); + }, + SamplerParameteri: (sampler, pname, param) => { + AssertWebGL2(); + GL.samplerParameteri(this.samplers[sampler], pname, param); + }, + SamplerParameterf: (sampler, pname, param) => { + AssertWebGL2(); + GL.samplerParameterf(this.samplers[sampler], pname, param); + }, + + /* Sync objects */ + FenceSync: (condition, flags) => { + AssertWebGL2(); + let sync = GL.fenceSync(condition, flags); + let id = this.getNewId(SYNCS); + sync.name = id; + SYNCS[id] = sync; + return id; + }, + IsSync: (sync) => { + AssertWebGL2(); + return GL.isSync(SYNCS[sync]); + }, + DeleteSync: (id) => { + AssertWebGL2(); + let obj = SYNCS[id]; + if(obj && id != 0) { + GL.deleteSampler(obj); + SYNCS[id] = null; + } + }, + ClientWaitSync: (sync, flags, timeout) => { + AssertWebGL2(); + return GL.clientWaitSync(SYNCS[sync], flags, timeout); + }, + WaitSync: (sync, flags, timeout) => { + AssertWebGL2(); + GL.waitSync(SYNCS[sync], flags, timeout) ; + }, + + + /* Transform Feedback */ + CreateTransformFeedback: () => { + AssertWebGL2(); + let transformFeedback = GL.createTransformFeedback(); + let id = this.getNewId(TRANSFORM_FEEDBACK); + transformFeedback.name = id; + TRANSFORM_FEEDBACK[id] = transformFeedback; + return id; + }, + DeleteTransformFeedback: (id) => { + AssertWebGL2(); + let obj = TRANSFORM_FEEDBACK[id]; + if(obj && id != 0) { + GL.deleteTransformFeedback(obj); + TRANSFORM_FEEDBACK[id] = null; + } + }, + IsTransformFeedback: (tf) => { + AssertWebGL2(); + return GL.isTransformFeedback(TRANSFORM_FEEDBACK[tf]); + }, + BindTransformFeedback: (target, tf) => { + AssertWebGL2(); + GL.bindTransformFeedback(target, TRANSFORM_FEEDBACK[tf]); + }, + BeginTransformFeedback: (primitiveMode) => { + AssertWebGL2(); + GL.beginTransformFeedback(primitiveMode); + }, + EndTransformFeedback: () => { + AssertWebGL2(); + GL.endTransformFeedback(); + }, + TransformFeedbackVaryings: (program, varyings_ptr, varyings_len, bufferMode) => { + AssertWebGL2(); + const stringSize = this.mem.intSize*2; + let varyings = []; + for(let i = 0; i < varyings_len; i++) { + let ptr = this.mem.loadPtr(varyings_ptr + i*stringSize + 0*4); + let len = this.mem.loadPtr(varyings_ptr + i*stringSize + 1*4); + varyings.push(this.mem.loadString(ptr, len)); + } + GL.transformFeedbackVaryings(PROGRAMS[program], varyings, bufferMode); + }, + PauseTransformFeedback: () => { + AssertWebGL2(); + GL.pauseTransformFeedback(); + }, + ResumeTransformFeedback: () => { + AssertWebGL2(); + GL.resumeTransformFeedback(); + }, + + + /* Uniform Buffer Objects and Transform Feedback Buffers */ + BindBufferRange: (target, index, buffer, offset, size) => { + AssertWebGL2(); + GL.bindBufferRange(target, index, BUFFERS[buffer], offset, size); + }, + // any getActiveUniformBlockParameter(WebGLProgram program, GLuint uniformBlockIndex, GLenum pname); + GetActiveUniformBlockName: (program, uniformBlockIndex, buf_ptr, buf_len, length_ptr) => { + AssertWebGL2(); + let name = GL.getActiveUniformBlockName(PROGRAMS[program], uniformBlockIndex); + + let n = Math.min(buf_len, name.length); + name = name.substring(0, n); + this.mem.loadBytes(buf_ptr, buf_len).set(new TextEncoder().encode(name)) + this.mem.storeInt(length_ptr, n); + }, + UniformBlockBinding: (program, uniformBlockIndex, uniformBlockBinding) => { + AssertWebGL2(); + GL.uniformBlockBinding(PROGRAMS[program], uniformBlockIndex, uniformBlockBinding); + }, + + /* Vertex Array Objects */ + IsVertexArray: (vertexArray) => { + AssertWebGL2(); + return GL.isVertexArray(VAOS[vertexArray]); + }, + }, +}; async function StartWasm(path) {