commit 403ec4db89b5956f504fadf8f6adf7dee19a6f22 Author: NeilClack Date: Thu Mar 12 08:05:10 2026 -0500 Initial release: RadiantWave v1.0 diff --git a/.claude/settings.local.json b/.claude/settings.local.json new file mode 100644 index 0000000..28bc551 --- /dev/null +++ b/.claude/settings.local.json @@ -0,0 +1,24 @@ +{ + "permissions": { + "allow": [ + "Bash(cat:*)", + "Bash(git checkout:*)", + "Bash(dpkg:*)", + "Bash(chmod:*)", + "Bash(git add:*)", + "Bash(git commit:*)", + "Bash(./build.sh:*)", + "Bash(ls:*)", + "Bash(umask)", + "Bash(namei:*)", + "Bash(cd /home/nclack/Work/Rhema\\\\ Wave/RhemaWave && go list:*)", + "Bash(go mod download:*)", + "Bash(CGO_ENABLED=1 go build:*)", + "Bash(go vet:*)", + "Bash(go version:*)", + "Bash(dlv version:*)", + "Bash(sudo nixos-rebuild:*)", + "Bash(nix develop:*)" + ] + } +} diff --git a/.envrc b/.envrc new file mode 100644 index 0000000..3550a30 --- /dev/null +++ b/.envrc @@ -0,0 +1 @@ +use flake diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6aae662 --- /dev/null +++ b/.gitignore @@ -0,0 +1,45 @@ +# If you prefer the allow list template instead of the deny list, see community template: +# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore +# +# Binaries for programs and plugins +*.exe +*.exe~ +*.dll +*.so +*.dylib + +# Test binary, built with `go test -c` +*.test + +# Output of the go coverage tool, specifically when used with LiteIDE +*.out + +# Dependency directories (remove the comment below to include it) +# vendor/ + +# Go workspace file +go.work +go.work.sum + +# env file +.env + +__debug* + +# Project files used as symlinks for development +settings.json +logs/ + +# Build output +bin/ +*.pprof +*.log + +# Audio assets (large binary files) +share/rhemawave/audio/*.wav + +# Nix +.direnv/ +result + +notes.txt diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..13ae62a --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,45 @@ +# Rhema Wave Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## IMPORTANT! +`9cdef97` - This commit hash is considered the "Great Reset Point". +Many bugs, issues, and complexities have been discovered, leading to a restructure +of the project, packaging, deployment and even target machine environment. +All tags prior to this commit have been deleted. All releases removed, all archived +packages dropped from the server, and even the server structure has been changed. +v0.9.0 will represent the "beta" release from this point forward. Until full release, we will +remain at v0.9.x. + +## [Unreleased] + +### Added +- TOS screens now display real content from the RWT Welcome Screen document (10 sections) +- TOS content is stored in the database and seeded from HTML files on disk, making it easy to update without recompiling +- WiFi setup page now appears automatically before TOS screens if no internet connection is detected +- Dev script `setup.sh` for syncing assets to /usr/ on development machines + +--- + +## [v0.9.22] + +### Added +- Batched texture rendering path (BeginTextureRendering/RenderTextureBatched/EndTextureRendering) for ScrollerPage +- Ring buffer (LineDeque) for ScrollerPage line management — O(1) prepend/append/remove +- In-memory config value cache in db package — eliminates repeated SQLite queries +- Buffered channel-based logger — single writer goroutine replaces per-log goroutine spawning +- Cached uniform locations on Shader struct — looked up once at load, reused every frame + +### Changed +- FontManager now reuses a persistent FBO, VAO, and VBO for string texture rendering instead of creating/deleting per call +- RenderSolidColorQuad uses cached uniform locations and removes per-frame glGetError calls +- Welcome page caches init_font_size at Init instead of querying the database every frame +- ScrollerPage.Destroy uses gl.Flush instead of gl.Finish to avoid blocking CPU on page transitions +- Scroll offset calculation uses simple subtraction instead of math.Mod with float64 round-trip +- Application cleanup now properly shuts down the logger goroutine via logger.Close() + +### Removed +- Removed per-frame CheckGLError calls from RenderSolidColorQuad (caused GPU pipeline stalls) \ No newline at end of file diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..549b4d4 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,201 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## Project Overview + +RhemaWave is a Go-based fullscreen SDL2/OpenGL application designed to run on Linux kiosk systems. It displays proclamations with audio playback and animated visual patterns. The application uses a page-based navigation system and includes network connectivity validation, license key management, and an auto-update mechanism. + +## Build & Development + +### Development Workflow + +```bash +nix develop # enter dev shell (provides Go, SDL2, etc.) +go build -o bin/rhemawave rhemawave.go # build binary +./bin/rhemawave # run (requires display server + audio) +./dev_scripts/reset.sh # wipe local database and start fresh +``` + +The binary at `bin/rhemawave` resolves assets via `../share/rhemawave` relative to itself, so the repo layout (`bin/` + `share/rhemawave/`) works out of the box. + +### Nix Build + +```bash +nix build # produces ./result/bin/rhemawave + ./result/share/rhemawave/ +``` + +The flake's `postInstall` copies `share/` into `$out/`, preserving the same relative layout. + +### Testing +There are currently no automated tests in this codebase. + +## Architecture + +### Application Entry Point +- `rhemawave.go` is the main entry point, calls `internal/application.Run()` +- `internal/application/application.go` contains the core application lifecycle + +### Core Application Flow +1. **Initialization** + - Create application data directory (`~/.local/share/rhemawave`) + - Initialize SQLite database (`data.db`) with GORM + - Initialize SDL2 subsystems (VIDEO, AUDIO) + - Initialize SDL_ttf for font rendering + - Create fullscreen OpenGL 3.3 Core Profile window + - Initialize shader and font managers + - Hide cursor and enable relative mouse mode + +2. **Validation Phase** (startup page stack, top → bottom) + - WiFi setup page (if no internet connection detected) — shown first + - TOS sections from database (unaccepted only, ordered by section number) + - Email address page (if missing) + - License key page (if missing) + - Welcome page — always at bottom + - License key is also validated against the API + +3. **Event Loop** (60 FPS target) + - Poll SDL events + - Handle keyboard events via keybinds system + - Update current page with delta time + - Render current page + - Apply pending page transitions + +### Page System +Pages implement the `page.Page` interface: +- `Init(app ApplicationInterface) error` - Setup resources +- `HandleEvent(event *sdl.Event) error` - Handle input +- `Update(dt float32) error` - Update state +- `Render() error` - Draw to screen +- `Destroy() error` - Cleanup resources + +Pages can embed `page.Base` for common functionality (OpenGL quad rendering, projection matrix, screen dimensions). + +**Page Navigation:** +- `PushPage(p)` - Add page to stack (creates history) +- `SwitchPage(p)` - Replace current page +- `UnwindToPage(p)` - Pop back to a specific page (or create if not in stack) + +**Available Pages:** +- `Welcome` - Initial screen showing version +- `ScrollerPage` - Main proclamation player (F2) +- `Settings` - Settings menu (F3) +- `WiFiSetupPage` - Network configuration +- `LicenseKeyPage` - License key entry +- `EmailAddressPage` - Email address entry +- `AudioDevices` - Audio device selection +- `ProclamationOptions` - Proclamation selection +- `TOSPage` - Terms of Service acceptance screen (scrollable, Y/N to accept/decline) + +### Key Global Keybinds +Defined in `application.initKeybinds()`: +- `F1` - Navigate to Welcome page +- `F2` - Navigate to Player (ScrollerPage) +- `F3` - Navigate to Settings +- `SHIFT+UP` - Increase volume +- `SHIFT+DOWN` - Decrease volume +- `RIGHT_CTRL+Q` - Quit application + +### Package Structure + +**`internal/application`** - Core application lifecycle, event loop, page management, validation + +**`internal/page`** - Page interface and all page implementations + +**`internal/db`** - Database layer using GORM with SQLite +- Models: `Config`, `Proclamations`, `Log`, `TOSSection` +- Manages configuration key-value pairs +- Seeds default proclamations from `share/rhemawave/proclamations/` +- Seeds TOS sections from `share/rhemawave/tos/*.html` (filename format: `{NN} - {Title}.html`) + +**`internal/audio`** - SDL2 audio subsystem integration (currently minimal wrapper) + +**`internal/mixer`** - Audio playback manager for music and proclamations + +**`internal/graphics`** - OpenGL utilities and display orientation handling + +**`internal/shaderManager`** - Loads and manages OpenGL shaders from `share/rhemawave/shaders/` + +**`internal/fontManager`** - Loads and manages TrueType fonts from `share/rhemawave/fonts/` + +**`internal/keybinds`** - Global keyboard shortcut registration and dispatch + +**`internal/network`** - Network connectivity manager (uses D-Bus for NetworkManager on Linux) + +**`internal/logger`** - Logging system that writes to database and stdout + +**`internal/colors`** - Color utilities + +**`internal/pattern`** - Visual pattern generation (line patterns, color patterns) + +### Repository Layout + +``` +bin/ # build output (gitignored) + rhemawave +share/rhemawave/ # assets (checked in) + audio/ # Audio files (audio.wav, etc.) + fonts/ # TrueType fonts + shaders/ # GLSL shader files + proclamations/ # Proclamation text files + home/ # Non-commercial proclamations + commercial/ # Commercial proclamations + tos/ # TOS HTML files (seeded into DB on first run) +packaging/ # deployment configs (kiosk, updater, polkit) + kiosk/ # kiosk system configs + rhemawave-updater.py # auto-updater script +internal/ # Go source packages +dev_scripts/ + reset.sh # deletes ~/.local/share/rhemawave/ +flake.nix # Nix build and dev shell +``` + +### Important Implementation Details + +**Asset Resolution:** `resolveAssetsDir()` computes `filepath.Join(filepath.Dir(exe), "..", "share", "rhemawave")` — works in both dev (`bin/rhemawave` → `share/rhemawave/`) and Nix install (`$out/bin/rhemawave` → `$out/share/rhemawave/`). + +**OpenGL Context:** Uses OpenGL 3.3 Core Profile with VSync enabled. The page base class sets up a reusable quad VAO/VBO for texture and solid color rendering. + +**Database Location:** `~/.local/share/rhemawave/data.db` - Contains configuration, proclamations, and log entries + +**Fullscreen Mode:** Uses `SDL_WINDOW_FULLSCREEN_DESKTOP` to match native display resolution + +**Display Orientation:** Handled by `graphics.SetDisplayOrientation()` which swaps width/height for portrait displays + +**Version Injection:** Git version is injected at build time via ldflags: `-X 'rhemawavetech.com/rhemawave/internal/page.GitVersion=${VERSION}'` + +**Network Manager:** Uses D-Bus to communicate with NetworkManager for WiFi configuration and connectivity status + +## Development Workflow + +### Adding a New Page +1. Create `internal/page/.go` +2. Implement the `page.Page` interface +3. Embed `page.Base` for common functionality +4. Register keybind in `application.initKeybinds()` if needed +5. Add navigation logic from existing pages + +### Modifying Database Schema +1. Update models in `internal/db/db.go` +2. GORM AutoMigrate will handle schema changes on next run +3. Add seed data logic if needed in `ensureDefaultsExist()`, `seedDefaultProclamations()`, or `seedDefaultTOSSections()` + +### Adding New Assets +1. Place files in appropriate `share/rhemawave/` subdirectory +2. They will be included automatically in Nix builds via `postInstall` +3. Access via config values (`assets_dir`) or direct paths + +### Working with Shaders +1. Create `.vert` and `.frag` files in `share/rhemawave/shaders/` +2. Load via `shaderManager.GetShader("")` +3. Shader must have uniforms: `u_mvpMatrix`, `u_color` or `u_textColor`, `u_texture` (if using textures) + +## Important Constraints + +- Must build with `CGO_ENABLED=1` for SDL2 bindings +- Target platform is Linux (uses D-Bus for NetworkManager) +- Application expects to run as kiosk user with polkit rules for system operations +- Assets are resolved relative to the binary (`../share/rhemawave`), so `bin/` and `share/` must be siblings +- Version string comes from git tags (release) or commit hash (dev) +- ShaderManager, FontManager, and Logger use `sync.Once` singletons — they must be initialized (via their `Init()` or `Initialize()` functions) before calling `Get()`; calling `Get()` before initialization panics +- Deployed via NixOS-Anywhere to kiosk hardware diff --git a/MANUAL.md b/MANUAL.md new file mode 100644 index 0000000..3f5a586 --- /dev/null +++ b/MANUAL.md @@ -0,0 +1,21 @@ +# Rhema Wave User Manual + +## Keybinds +These are the basic keybinds for navigating Rhema Wave and operating the program. +Should you find a keybind that does something and is not listed here, please email nclack@rhemawavetech.com + +> When you see key combinations such as "SHIFT + UP ARROW", press and hold the first key, in this case SHIFT +> then press the second key. Do not hold the second key as right now, there is no way to stop a flood of commands +> from being sent to the program, and you could send more than the program can handle, causing things to "continue happening after you've let go of the keys". + + +### Navigation + +**F1** - The "Welcome" screen. The screen that appears when you first start Rhema Wave and is useful for finding the current version of Rhema Wave you have installed. +**F2** - The "Player". This is the main application where your proclamations and audio will be played. +**F3** - The "Settings" menu. Use this menu to connect to WiFi, manage Audio Output Devices, and select your active proclamations to be played. + +### Controls + +**SHIFT + UP ARROW** - Volume Up +**SHIFT + DOWN ARROW** - Volume Down diff --git a/README.md b/README.md new file mode 100644 index 0000000..e337b3e --- /dev/null +++ b/README.md @@ -0,0 +1,47 @@ +# RhemaWave + +A Go-based fullscreen SDL2/OpenGL application for Linux kiosk systems. Displays proclamations with audio playback and animated visual patterns. + +## Development + +Development uses Nix for a reproducible build environment. + +```bash +nix develop # enter dev shell +go build -o bin/rhemawave rhemawave.go # build +./bin/rhemawave # run +./dev_scripts/reset.sh # reset database (if needed) +``` + +### Prerequisites + +- Nix with flakes enabled +- A display server (X11/Wayland) and audio device for running the application + +## Architecture + +- **Page-based UI** — SDL2/OpenGL 3.3 fullscreen rendering with a page stack for navigation +- **Proclamation player** — scrolling text display with synchronized audio playback +- **Startup validation** — WiFi, TOS acceptance, email, license key checks +- **Singleton managers** — ShaderManager, FontManager, Logger (initialized once via `sync.Once`) + +### Key Directories + +``` +bin/ # build output (gitignored) +share/rhemawave/ # assets (fonts, shaders, proclamations, TOS) +internal/ # Go source packages +packaging/ # deployment configs (kiosk, updater, polkit) +dev_scripts/ # developer utilities +``` + +### Runtime Data + +Stored in `~/.local/share/rhemawave/`: +- `data.db` — SQLite database (config, proclamations, logs) +- `log.txt` — application log +- `license_key` — license key file + +## Deployment + +Deployed to kiosk hardware via NixOS-Anywhere. See `packaging/` for kiosk system configs. diff --git a/dev_scripts/reset.sh b/dev_scripts/reset.sh new file mode 100755 index 0000000..17c420a --- /dev/null +++ b/dev_scripts/reset.sh @@ -0,0 +1,5 @@ +#!/bin/bash + +rm -rf ~/.local/share/rhemawave/ + +echo "Data directory deleted, application reset." diff --git a/docs/greetd-autologin-setup.md b/docs/greetd-autologin-setup.md new file mode 100644 index 0000000..4ee2d08 --- /dev/null +++ b/docs/greetd-autologin-setup.md @@ -0,0 +1,67 @@ +# Greetd Auto-Login Setup for Ubuntu Server 24 + +## Overview +This guide configures greetd for automatic login of the `kiosk` user on Ubuntu Server 24, bypassing password authentication while keeping the user account password-protected for other purposes. + +## Installation + +```bash +# Install greetd +sudo apt update +sudo apt install greetd + +# Disable other display managers if running +sudo systemctl disable gdm3 lightdm sddm +``` + +## Configuration + +Edit `/etc/greetd/config.toml`: + +```toml +[terminal] +vt = 1 + +[default_session] +command = "agreety --cmd /bin/bash" +user = "kiosk" + +[initial_session] +command = "/bin/bash" +user = "kiosk" +``` + +## Auto-Start Application + +Create `/home/kiosk/.bash_profile`: + +```bash +#!/bin/bash +# Auto-start RhemaWave on login +if [ -z "$DISPLAY" ] && [ "$(tty)" = "/dev/tty1" ]; then + exec /usr/local/bin/rhemawave +fi +``` + +Make it executable: +```bash +chmod +x /home/kiosk/.bash_profile +chown kiosk:kiosk /home/kiosk/.bash_profile +``` + +## Enable Service + +```bash +sudo systemctl enable greetd +sudo systemctl start greetd +``` + +## Verification + +Reboot the system. The `kiosk` user should auto-login on tty1 and launch RhemaWave automatically. + +## Notes + +- The `kiosk` user password remains active for SSH, sudo, and manual logins on other TTYs +- Auto-login only applies to tty1 (the primary console) +- If RhemaWave crashes, the user remains logged in at a bash prompt diff --git a/docs/kiosk-setup-guide.md b/docs/kiosk-setup-guide.md new file mode 100644 index 0000000..9e1b49c --- /dev/null +++ b/docs/kiosk-setup-guide.md @@ -0,0 +1,189 @@ +# RhemaWave Kiosk Setup Guide - Ubuntu Server 24 + +Complete setup guide for a fresh Ubuntu Server 24 installation configured as a RhemaWave kiosk. + +## Initial System Setup + +### 1. Create Kiosk User + +```bash +sudo adduser kiosk +sudo usermod -aG sudo kiosk +``` + +### 2. Install Dependencies + +```bash +sudo apt update +sudo apt install -y \ + libsdl2-2.0-0 \ + libsdl2-ttf-2.0-0 \ + libsdl2-mixer-2.0-0 \ + libegl1-mesa \ + libgles2-mesa \ + libgbm1 \ + libinput10 \ + libxkbcommon0 \ + dbus \ + network-manager +``` + +### 3. Install Cage (Wayland Compositor) + +```bash +sudo apt install -y cage +``` + +### 4. Install Greetd + +```bash +sudo apt install -y greetd +``` + +### 5. Configure PAM for Greetd + +Create `/etc/pam.d/greetd`: + +```bash +sudo tee /etc/pam.d/greetd < +``` + +### View RhemaWave Logs +```bash +# From SSH session +sudo journalctl -u greetd -f +``` + +### Restart RhemaWave +```bash +sudo systemctl restart greetd +``` + +### Update RhemaWave +```bash +sudo apt update +sudo apt upgrade rhemawave +``` diff --git a/flake.lock b/flake.lock new file mode 100644 index 0000000..bf24a07 --- /dev/null +++ b/flake.lock @@ -0,0 +1,61 @@ +{ + "nodes": { + "flake-utils": { + "inputs": { + "systems": "systems" + }, + "locked": { + "lastModified": 1731533236, + "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=", + "owner": "numtide", + "repo": "flake-utils", + "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b", + "type": "github" + }, + "original": { + "owner": "numtide", + "repo": "flake-utils", + "type": "github" + } + }, + "nixpkgs": { + "locked": { + "lastModified": 1771848320, + "narHash": "sha256-0MAd+0mun3K/Ns8JATeHT1sX28faLII5hVLq0L3BdZU=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "2fc6539b481e1d2569f25f8799236694180c0993", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixos-unstable", + "repo": "nixpkgs", + "type": "github" + } + }, + "root": { + "inputs": { + "flake-utils": "flake-utils", + "nixpkgs": "nixpkgs" + } + }, + "systems": { + "locked": { + "lastModified": 1681028828, + "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", + "owner": "nix-systems", + "repo": "default", + "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", + "type": "github" + }, + "original": { + "owner": "nix-systems", + "repo": "default", + "type": "github" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/flake.nix b/flake.nix new file mode 100644 index 0000000..d48e1fc --- /dev/null +++ b/flake.nix @@ -0,0 +1,98 @@ +{ + description = "RhemaWave"; + + inputs = { + nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable"; + flake-utils.url = "github:numtide/flake-utils"; + }; + + outputs = { self, nixpkgs, flake-utils }: + (flake-utils.lib.eachDefaultSystem (system: + let + pkgs = import nixpkgs { + inherit system; + config.allowUnfreePredicate = pkg: (nixpkgs.lib.getName pkg) == "rhemawave"; + }; + + buildInputs = with pkgs; [ + SDL2 + SDL2_ttf + SDL2_image + SDL2_mixer + libGL + sqlite + dbus + wayland + wayland-protocols + libxkbcommon + libdecor + libx11 + libxext + ]; + + nativeBuildInputs = with pkgs; [ + go_1_24 + pkg-config + ]; + + audioFile = pkgs.fetchurl { + url = "https://files.neilclack.com/audio.wav"; + sha256 = "sha256-5Dikxx9RKOoPfY1ukIgMoVQ7tzpMirp+XPj6OphfEW0="; + }; + in + { + packages.default = pkgs.buildGoModule { + pname = "rhemawave"; + version = "v1.0.0"; + src = ./.; + + vendorHash = null; + + inherit buildInputs nativeBuildInputs; + + env.CGO_ENABLED = "1"; + + preBuild = '' + export CGO_CFLAGS="$(pkg-config --cflags SDL2_mixer SDL2_ttf SDL2_image) $CGO_CFLAGS" + export CGO_LDFLAGS="$(pkg-config --libs SDL2_mixer SDL2_ttf SDL2_image) $CGO_LDFLAGS" + ''; + + ldflags = [ "-s" "-w" ]; + + postInstall = '' + cp -r share $out/share + mkdir -p $out/share/rhemawave/audio + cp ${audioFile} $out/share/rhemawave/audio/audio.wav + ''; + + meta = with pkgs.lib; { + description = "RhemaWave kiosk application"; + license = licenses.unfree; + platforms = platforms.linux; + }; + }; + + devShells.default = pkgs.mkShell { + inherit buildInputs nativeBuildInputs; + + shellHook = '' + export OLD_PS1="$PS1" + export PS1="[nix-env] $OLD_PS1" + + export CGO_CFLAGS="$(pkg-config --cflags SDL2_mixer SDL2_ttf SDL2_image) $CGO_CFLAGS" + export CGO_LDFLAGS="$(pkg-config --libs SDL2_mixer SDL2_ttf SDL2_image) $CGO_LDFLAGS" + + echo "RhemaWave dev shell" + echo " go version: $(go version)" + echo " CGO_ENABLED=1" + echo "" + echo "Build: go build -o bin/rhemawave rhemawave.go" + echo "Run: ./bin/rhemawave" + echo "Reset: ./dev_scripts/reset.sh" + ''; + }; + } + )) // { + nixosModules.default = import ./nixos/module.nix self; + }; +} \ No newline at end of file diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..cbd77b7 --- /dev/null +++ b/go.mod @@ -0,0 +1,24 @@ +module rhemawavetech.com/rhemawave + +go 1.24.0 + +toolchain go1.24.2 + +require github.com/veandco/go-sdl2 v0.4.40 + +require github.com/go-gl/mathgl v1.2.0 + +require ( + github.com/go-gl/gl v0.0.0-20231021071112-07e5d0ea2e71 + github.com/godbus/dbus/v5 v5.1.0 + github.com/google/uuid v1.6.0 +) + +require ( + github.com/jinzhu/inflection v1.0.0 // indirect + github.com/jinzhu/now v1.1.5 // indirect + github.com/mattn/go-sqlite3 v1.14.32 // indirect + golang.org/x/text v0.31.0 // indirect + gorm.io/driver/sqlite v1.6.0 + gorm.io/gorm v1.31.1 +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..b0c2995 --- /dev/null +++ b/go.sum @@ -0,0 +1,29 @@ +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/go-gl/gl v0.0.0-20231021071112-07e5d0ea2e71 h1:5BVwOaUSBTlVZowGO6VZGw2H/zl9nrd3eCZfYV+NfQA= +github.com/go-gl/gl v0.0.0-20231021071112-07e5d0ea2e71/go.mod h1:9YTyiznxEY1fVinfM7RvRcjRHbw2xLBJ3AAGIT0I4Nw= +github.com/go-gl/mathgl v1.2.0 h1:v2eOj/y1B2afDxF6URV1qCYmo1KW08lAMtTbOn3KXCY= +github.com/go-gl/mathgl v1.2.0/go.mod h1:pf9+b5J3LFP7iZ4XXaVzZrCle0Q/vNpB/vDe5+3ulRE= +github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk= +github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= +github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= +github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= +github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= +github.com/mattn/go-sqlite3 v1.14.32 h1:JD12Ag3oLy1zQA+BNn74xRgaBbdhbNIDYvQUEuuErjs= +github.com/mattn/go-sqlite3 v1.14.32/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y= +github.com/mutecomm/go-sqlcipher/v4 v4.4.2 h1:eM10bFtI4UvibIsKr10/QT7Yfz+NADfjZYh0GKrXUNc= +github.com/mutecomm/go-sqlcipher/v4 v4.4.2/go.mod h1:mF2UmIpBnzFeBdu/ypTDb/LdbS0nk0dfSN1WUsWTjMA= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/veandco/go-sdl2 v0.4.40 h1:fZv6wC3zz1Xt167P09gazawnpa0KY5LM7JAvKpX9d/U= +github.com/veandco/go-sdl2 v0.4.40/go.mod h1:OROqMhHD43nT4/i9crJukyVecjPNYYuCofep6SNiAjY= +golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM= +golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM= +gorm.io/driver/sqlite v1.6.0 h1:WHRRrIiulaPiPFmDcod6prc4l2VGVWHz80KspNsxSfQ= +gorm.io/driver/sqlite v1.6.0/go.mod h1:AO9V1qIQddBESngQUKWL9yoH93HIeA1X6V633rBwyT8= +gorm.io/gorm v1.31.1 h1:7CA8FTFz/gRfgqgpeKIBcervUn3xSyPUmr6B2WXJ7kg= +gorm.io/gorm v1.31.1/go.mod h1:XyQVbO2k6YkOis7C2437jSit3SsDK72s7n7rsSHd+Gs= diff --git a/internal/application/application.go b/internal/application/application.go new file mode 100644 index 0000000..edb6023 --- /dev/null +++ b/internal/application/application.go @@ -0,0 +1,694 @@ +package application + +import ( + "fmt" + "io" + "net/http" + "os" + "path/filepath" + "sync/atomic" + "time" + + "github.com/go-gl/gl/v3.3-core/gl" + "github.com/veandco/go-sdl2/sdl" + "github.com/veandco/go-sdl2/ttf" + "rhemawavetech.com/rhemawave/internal/db" + "rhemawavetech.com/rhemawave/internal/fontManager" + "rhemawavetech.com/rhemawave/internal/graphics" + "rhemawavetech.com/rhemawave/internal/keybinds" + "rhemawavetech.com/rhemawave/internal/license" + "rhemawavetech.com/rhemawave/internal/logger" + "rhemawavetech.com/rhemawave/internal/mixer" + "rhemawavetech.com/rhemawave/internal/network" + "rhemawavetech.com/rhemawave/internal/page" + "rhemawavetech.com/rhemawave/internal/shaderManager" +) + +const ( + targetFPS = 60.0 + volumeStepSize = 16 + openGLMajorVersion = 3 + openGLMinorVersion = 3 + apiURL = "http://localhost:8000" + apiPath = "/api/v1/licenseKey/validate" + audioFileURL = "https://files.neilclack.com/audio.wav" +) + +type Application struct { + Window *sdl.Window + License *license.Response + pageStack []page.Page + pendingAction func() + running bool +} + +// ---------------------------------------------------------------------------- +// Main Entry Point +// ---------------------------------------------------------------------------- + +func Run() { + logger.Info("Starting application") + + appDataDir, err := initializeApplicationDirectory() + if err != nil { + logger.Fatal("Failed to initialize application directory: %v", err) + } + + logger.Info("App directory: %s", appDataDir) + logger.AddFile(filepath.Join(appDataDir, "log.txt")) + + if err := initializeDatabase(appDataDir); err != nil { + logger.Fatal("Database initialization failed: %v", err) + } + + app := &Application{} + + app.initializeSDLAndOpenGL() + defer app.cleanup() + + app.initializeManagers() + app.initializeAudio() + app.validateLicenseKey() + app.startupPageStack() + app.runEventLoop() +} + +// ---------------------------------------------------------------------------- +// Initialization Functions +// ---------------------------------------------------------------------------- + +func initializeApplicationDirectory() (string, error) { + homeDir, err := os.UserHomeDir() + if err != nil { + return "", fmt.Errorf("failed to get user home directory: %w", err) + } + + appDataDir := filepath.Join(homeDir, ".local", "share", "rhemawave") + + if err := os.MkdirAll(appDataDir, 0755); err != nil { + return "", fmt.Errorf("could not create application data directory %s: %w", appDataDir, err) + } + + testFile := filepath.Join(appDataDir, ".access_test") + f, err := os.Create(testFile) + if err != nil { + return "", fmt.Errorf("application data directory %s is not writable: %w", appDataDir, err) + } + f.Close() + os.Remove(testFile) + + return appDataDir, nil +} + +func initializeDatabase(appDataDir string) error { + dbPath := filepath.Join(appDataDir, "data.db") + if err := db.InitDatabase(dbPath); err != nil { + return fmt.Errorf("failed to initialize database: %w", err) + } + logger.AddDatabase(db.DB) + return nil +} + +type progressWriter struct { + w io.Writer + written *atomic.Int64 +} + +func (pw *progressWriter) Write(p []byte) (int, error) { + n, err := pw.w.Write(p) + pw.written.Add(int64(n)) + return n, err +} + +// ensureAudioFile checks whether the selected audio file exists. If it does, +// it returns nil. Otherwise it starts a background download and returns a +// DownloadProgressPage that tracks the download so it can be pushed onto the +// page stack. +func ensureAudioFile() *page.DownloadProgressPage { + assetsDir, err := db.GetConfigValue("assets_dir") + if err != nil { + logger.Error("Failed to get assets_dir: %v", err) + return nil + } + selectedAudio, err := db.GetConfigValue("selected_audio") + if err != nil || selectedAudio == "" { + logger.Warning("No selected_audio configured") + return nil + } + + audioPath := filepath.Join(assetsDir, selectedAudio) + if _, err := os.Stat(audioPath); err == nil { + logger.Info("Audio file found: %s", audioPath) + return nil + } + + logger.Info("Audio file not found at %s, downloading from %s", audioPath, audioFileURL) + + totalBytes := &atomic.Int64{} + bytesWritten := &atomic.Int64{} + done := &atomic.Bool{} + hasError := &atomic.Bool{} + + downloadPage := &page.DownloadProgressPage{ + TotalBytes: totalBytes, + BytesWritten: bytesWritten, + Done: done, + HasError: hasError, + } + + go func() { + defer done.Store(true) + + if err := os.MkdirAll(filepath.Dir(audioPath), 0755); err != nil { + logger.Error("Failed to create audio directory: %v", err) + hasError.Store(true) + return + } + + resp, err := http.Get(audioFileURL) + if err != nil { + logger.Error("Failed to download audio file: %v", err) + hasError.Store(true) + return + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + logger.Error("Audio download returned status %d", resp.StatusCode) + hasError.Store(true) + return + } + + if resp.ContentLength > 0 { + totalBytes.Store(resp.ContentLength) + } + + tmp := audioPath + ".tmp" + f, err := os.Create(tmp) + if err != nil { + logger.Error("Failed to create audio file: %v", err) + hasError.Store(true) + return + } + + pw := &progressWriter{w: f, written: bytesWritten} + _, err = io.Copy(pw, resp.Body) + f.Close() + if err != nil { + os.Remove(tmp) + logger.Error("Failed to write audio file: %v", err) + hasError.Store(true) + return + } + + if err := os.Rename(tmp, audioPath); err != nil { + os.Remove(tmp) + logger.Error("Failed to move audio file into place: %v", err) + hasError.Store(true) + return + } + + logger.Info("Audio file downloaded successfully (%d bytes)", bytesWritten.Load()) + }() + + return downloadPage +} + +func (app *Application) initializeSDLAndOpenGL() { + logger.Info("Initializing SDL") + if err := sdl.Init(sdl.INIT_VIDEO | sdl.INIT_AUDIO); err != nil { + logger.Fatal("SDL init failed: %v", err) + } + + logger.Info("Initializing TTF") + if err := ttf.Init(); err != nil { + logger.Fatal("TTF init failed: %v", err) + } + + sdl.GLSetAttribute(sdl.GL_CONTEXT_MAJOR_VERSION, openGLMajorVersion) + sdl.GLSetAttribute(sdl.GL_CONTEXT_MINOR_VERSION, openGLMinorVersion) + sdl.GLSetAttribute(sdl.GL_CONTEXT_PROFILE_MASK, sdl.GL_CONTEXT_PROFILE_CORE) + sdl.ShowCursor(sdl.DISABLE) + sdl.SetRelativeMouseMode(true) + + logger.Info("Querying display mode") + displayMode, err := sdl.GetDisplayMode(0, 0) + if err != nil { + logger.Fatal("Display mode query failed: %v", err) + } + if displayMode.W == 0 || displayMode.H == 0 { + logger.Fatal("Invalid display dimensions: %dx%d", displayMode.W, displayMode.H) + } + logger.Info("Display: %dx%d @ %dHz", displayMode.W, displayMode.H, displayMode.RefreshRate) + + logger.Info("Creating window") + window, err := sdl.CreateWindow( + "Rhema Wave", + sdl.WINDOWPOS_UNDEFINED, + sdl.WINDOWPOS_UNDEFINED, + displayMode.W, + displayMode.H, + sdl.WINDOW_OPENGL|sdl.WINDOW_FULLSCREEN_DESKTOP|sdl.WINDOW_SHOWN, + ) + if err != nil { + logger.Fatal("Window creation failed: %v", err) + } + app.Window = window + + logger.Info("Creating OpenGL context") + if _, err := app.Window.GLCreateContext(); err != nil { + logger.Fatal("OpenGL context creation failed: %v", err) + } + + logger.Info("Initializing go-gl") + if err := gl.InitWithProcAddrFunc(sdl.GLGetProcAddress); err != nil { + logger.Fatal("go-gl initialization failed: %v", err) + } + + logger.Info("OpenGL version: %s", gl.GoStr(gl.GetString(gl.VERSION))) + logger.Info("OpenGL renderer: %s", gl.GoStr(gl.GetString(gl.RENDERER))) + + if err := sdl.GLSetSwapInterval(1); err != nil { + logger.Warning("Failed to enable vsync: %v", err) + } + + w, h := app.Window.GLGetDrawableSize() + logger.Info("Drawable size: %dx%d", w, h) + + logger.Info("Initializing virtual framebuffer (%dx%d -> %dx%d)", + graphics.VirtualWidth, graphics.VirtualHeight, w, h) + if err := graphics.InitVirtualFramebuffer(w, h); err != nil { + logger.Fatal("Virtual framebuffer init failed: %v", err) + } + + app.initKeybinds() + logger.Info("SDL and OpenGL initialization complete") +} + +func (app *Application) initializeManagers() { + logger.Info("Initializing ShaderManager") + if err := shaderManager.InitShaderManager(); err != nil { + logger.Fatal("ShaderManager initialization failed: %v", err) + } + + logger.Info("Initializing FontManager") + if err := fontManager.InitFontManager(); err != nil { + logger.Fatal("FontManager initialization failed: %v", err) + } +} + +func (app *Application) initializeAudio() { + logger.Info("Initializing audio") + audioDevice, err := db.GetConfigValue("audio_device_name") + if err != nil { + logger.Warning("Failed to get audio device name from config: %v", err) + } + + if err := mixer.Init(audioDevice); err != nil { + logger.Error("Unable to initialize audio device '%s': %v", audioDevice, err) + logger.Error("Audio will be unavailable until a device is configured") + } else { + logger.Info("Audio initialized with device: '%s'", audioDevice) + } +} + +func (app *Application) cleanup() { + logger.Info("Cleaning up") + + for _, p := range app.pageStack { + p.Destroy() + } + app.pageStack = nil + + graphics.DestroyVirtualFramebuffer() + + if app.Window != nil { + app.Window.Destroy() + } + + ttf.Quit() + sdl.Quit() + logger.Info("Cleanup complete") + logger.Close() +} + +// ---------------------------------------------------------------------------- +// Event Loop +// ---------------------------------------------------------------------------- + +func (app *Application) runEventLoop() { + if len(app.pageStack) == 0 { + logger.Fatal("No initial page loaded, pageStack is empty") + } + + const frameDelay = time.Second / targetFPS + app.running = true + lastTime := time.Now() + + logger.Info("Entering event loop") + + for app.running { + frameStart := time.Now() + + app.handleEvents() + if !app.running { + break + } + + deltaTime := float32(time.Since(lastTime).Seconds()) + lastTime = time.Now() + + app.updateCurrentPage(deltaTime) + app.renderFrame() + app.applyPendingAction() + + frameTime := time.Since(frameStart) + if frameTime < frameDelay { + time.Sleep(frameDelay - frameTime) + } + } + + logger.Info("Event loop exited") +} + +func (app *Application) handleEvents() { + for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() { + switch e := event.(type) { + case *sdl.QuitEvent: + app.running = false + return + + case *sdl.KeyboardEvent: + if e.Type == sdl.KEYDOWN && e.Repeat == 0 { + isCtrlPressed := (e.Keysym.Mod&sdl.KMOD_CTRL) != 0 || (e.Keysym.Mod&sdl.KMOD_GUI) != 0 + if e.Keysym.Sym == sdl.K_c && isCtrlPressed { + continue + } + keybinds.PerformAction(e) + } + } + + if currentPage := app.currentPage(); currentPage != nil { + if err := currentPage.HandleEvent(&event); err != nil { + logger.Error("Page event handler error: %v", err) + } + } + } +} + +func (app *Application) updateCurrentPage(deltaTime float32) { + if currentPage := app.currentPage(); currentPage != nil { + currentPage.Update(deltaTime) + } +} + +func (app *Application) renderFrame() { + graphics.BeginVirtualRender() + gl.ClearColor(0.0, 0.0, 0.0, 1.0) + gl.Clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT) + + if currentPage := app.currentPage(); currentPage != nil { + currentPage.Render() + } + + graphics.BlitToScreen() + app.Window.GLSwap() +} + +// ---------------------------------------------------------------------------- +// Keybind Registration +// ---------------------------------------------------------------------------- + +func (app *Application) initKeybinds() { + keybinds.Register(sdl.K_F3, sdl.KMOD_NONE, func() { + app.PushPage(&page.Settings{}) + }) + + keybinds.Register(sdl.K_F2, sdl.KMOD_NONE, func() { + downloadPage := ensureAudioFile() + if downloadPage != nil { + downloadPage.NextPage = &page.ScrollerPage{} + app.PushPage(downloadPage) + } else { + app.PushPage(&page.ScrollerPage{}) + } + }) + + keybinds.Register(sdl.K_F1, sdl.KMOD_NONE, func() { + app.UnwindToPage(&page.Welcome{}) + }) + + keybinds.Register(sdl.K_q, sdl.KMOD_RCTRL, func() { + app.Stop() + }) + + keybinds.Register(sdl.K_UP, sdl.KMOD_SHIFT, func() { + mixer.SetVolume128(volumeStepSize) + }) + + keybinds.Register(sdl.K_DOWN, sdl.KMOD_SHIFT, func() { + mixer.SetVolume128(-volumeStepSize) + }) +} + +func (app *Application) Stop() { + app.running = false +} + +// ---------------------------------------------------------------------------- +// Page Management +// ---------------------------------------------------------------------------- + +func (app *Application) currentPage() page.Page { + if len(app.pageStack) == 0 { + return nil + } + return app.pageStack[len(app.pageStack)-1] +} + +func (app *Application) applyPendingAction() { + if app.pendingAction != nil { + app.pendingAction() + app.pendingAction = nil + } +} + +func (app *Application) schedulePush(p page.Page) { + app.pendingAction = func() { + if err := p.Init(app); err != nil { + logger.Error("Failed to init page on push: %v", err) + return + } + + if topPage := app.currentPage(); topPage != nil { + topPage.Destroy() + } + + app.pageStack = append(app.pageStack, p) + } +} + +func (app *Application) scheduleSwitch(p page.Page) { + app.pendingAction = func() { + if topPage := app.currentPage(); topPage != nil { + topPage.Destroy() + app.pageStack = app.pageStack[:len(app.pageStack)-1] + } + + if err := p.Init(app); err != nil { + logger.Error("Failed to init page on switch: %v", err) + return + } + + app.pageStack = append(app.pageStack, p) + } +} + +func (app *Application) scheduleUnwind(targetPage page.Page) { + app.pendingAction = func() { + foundIndex := -1 + for i := len(app.pageStack) - 1; i >= 0; i-- { + if app.pageStack[i] == targetPage { + foundIndex = i + break + } + } + + if foundIndex != -1 { + for i := len(app.pageStack) - 1; i > foundIndex; i-- { + app.pageStack[i].Destroy() + } + app.pageStack = app.pageStack[:foundIndex+1] + } else { + if topPage := app.currentPage(); topPage != nil { + topPage.Destroy() + app.pageStack = app.pageStack[:len(app.pageStack)-1] + } + + if err := targetPage.Init(app); err != nil { + logger.Error("Failed to init page on unwind: %v", err) + return + } + + app.pageStack = append(app.pageStack, targetPage) + } + } +} + +func (app *Application) SchedulePop() { + app.pendingAction = func() { + if len(app.pageStack) == 0 { + return + } + + topPage := app.pageStack[len(app.pageStack)-1] + topPage.Destroy() + app.pageStack = app.pageStack[:len(app.pageStack)-1] + + if newTop := app.currentPage(); newTop != nil { + if err := newTop.Init(app); err != nil { + logger.Error("Failed to re-init page after pop: %v", err) + } + } + } +} + +// ---------------------------------------------------------------------------- +// Public Page Navigation Interface +// ---------------------------------------------------------------------------- + +func (app *Application) PushPage(p page.Page) { + app.schedulePush(p) +} + +func (app *Application) SwitchPage(p page.Page) { + app.scheduleSwitch(p) +} + +func (app *Application) UnwindToPage(p page.Page) { + app.scheduleUnwind(p) +} + +func (app *Application) GetDrawableSize() (w, h int32) { + return graphics.VirtualWidth, graphics.VirtualHeight +} + +func (app *Application) PopPage() { + app.SchedulePop() +} + +// ---------------------------------------------------------------------------- +// License Validation +// ---------------------------------------------------------------------------- + +func (app *Application) validateLicenseKey() { + logger.Info("Validating license key") + validator := license.NewValidator(apiURL, apiPath) + + key, err := db.GetConfigValue("license_key") + if err != nil { + logger.Error("Failed to fetch license key from database: %v", err) + } + + email, err := db.GetConfigValue("email_address") + if err != nil { + logger.Error("Failed to fetch email from database: %v", err) + } + + result, err := validator.Validate(key, email) + if err != nil { + logger.Error("License validation failed: %v", err) + app.License = nil + return + } + + logger.Info("License validation successful") + app.License = result +} + +// ---------------------------------------------------------------------------- +// Startup Page Stack +// ---------------------------------------------------------------------------- + +func (app *Application) startupPageStack() { + app.PushPage(&page.Welcome{}) + app.applyPendingAction() + + key, _ := db.GetConfigValue("license_key") + if key == "" { + logger.Info("No license key found, pushing license key page") + app.PushPage(&page.LicenseKeyPage{}) + app.applyPendingAction() + } else { + // Ensure the license key file exists for the updater script. + // Older versions only stored the key in the database. + if homeDir, err := os.UserHomeDir(); err == nil { + keyPath := filepath.Join(homeDir, ".local", "share", "rhemawave", "license_key") + if _, err := os.Stat(keyPath); os.IsNotExist(err) { + logger.Info("License key file missing, writing from database") + if err := os.MkdirAll(filepath.Dir(keyPath), 0755); err != nil { + logger.Error("Failed to create license key directory: %v", err) + } else if err := os.WriteFile(keyPath, []byte(key), 0644); err != nil { + logger.Error("Failed to write license key file: %v", err) + } + } + } + } + + email, _ := db.GetConfigValue("email_address") + if email == "" { + logger.Info("No email address found, pushing email address page") + app.PushPage(&page.EmailAddressPage{}) + app.applyPendingAction() + } + + // TOS pages — must be accepted before anything else. + // Pushed last so they sit on top of the stack (shown first). + sections, err := db.GetTOSSections() + if err != nil { + logger.Error("Failed to load TOS sections: %v", err) + } + // Push in reverse order so section 1 is on top of the stack + for i := len(sections) - 1; i >= 0; i-- { + s := sections[i] + configKey := fmt.Sprintf("tos_section_%d_accepted", s.SectionNumber) + accepted, _ := db.GetConfigValue(configKey) + if accepted != "true" { + app.PushPage(&page.TOSPage{ + Title: s.Title, + Content: s.Content, + ConfigKey: configKey, + }) + app.applyPendingAction() + } + } + + // Internet check — pushed last so it appears first if no internet. + // Skip WiFi setup if ethernet is connected (it auto-configures) or if + // internet is already reachable through any interface. + nm, err := network.New() + if err != nil { + logger.Warning("Could not initialize network manager: %v", err) + } else { + status, err := nm.CheckInternetConnection() + if err != nil { + logger.Warning("Network connectivity check failed: %v", err) + } else { + switch status.StatusCode { + case network.StatusEthernetConnectedInternetUp, + network.StatusEthernetConnectedNoInternet, + network.StatusWifiConnectedInternetUp: + // Internet is up or ethernet is connected and will auto-configure + default: + logger.Info("No internet connection, pushing WiFi setup page") + app.PushPage(&page.WiFiSetupPage{}) + app.applyPendingAction() + } + } + } +} + +func (app *Application) Quit() { + logger.Info("User has quit the application") + app.running = false +} diff --git a/internal/colors/colors.go b/internal/colors/colors.go new file mode 100644 index 0000000..b0f156b --- /dev/null +++ b/internal/colors/colors.go @@ -0,0 +1,192 @@ +// Package sdlcolors provides a comprehensive palette of 256 standard colors +// for use with the Go SDL2 bindings. Each color is a public variable of +// type sdl.Color, making them easily accessible for rendering tasks. +package colors + +import "github.com/veandco/go-sdl2/sdl" + +// Basic Colors +var ( + White = sdl.Color{R: 255, G: 255, B: 255, A: 255} + Silver = sdl.Color{R: 192, G: 192, B: 192, A: 255} + Gray = sdl.Color{R: 128, G: 128, B: 128, A: 255} + Black = sdl.Color{R: 0, G: 0, B: 0, A: 255} + Red = sdl.Color{R: 255, G: 0, B: 0, A: 255} + Maroon = sdl.Color{R: 128, G: 0, B: 0, A: 255} + Yellow = sdl.Color{R: 255, G: 255, B: 0, A: 255} + Olive = sdl.Color{R: 128, G: 128, B: 0, A: 255} + Lime = sdl.Color{R: 0, G: 255, B: 0, A: 255} + Green = sdl.Color{R: 0, G: 128, B: 0, A: 255} + Aqua = sdl.Color{R: 0, G: 255, B: 255, A: 255} + Teal = sdl.Color{R: 0, G: 128, B: 128, A: 255} + Blue = sdl.Color{R: 0, G: 0, B: 255, A: 255} + Navy = sdl.Color{R: 0, G: 0, B: 128, A: 255} + Fuchsia = sdl.Color{R: 255, G: 0, B: 255, A: 255} + Purple = sdl.Color{R: 128, G: 0, B: 128, A: 255} +) + +// Grayscale +var ( + Gainsboro = sdl.Color{R: 220, G: 220, B: 220, A: 255} + LightGray = sdl.Color{R: 211, G: 211, B: 211, A: 255} + DarkGray = sdl.Color{R: 169, G: 169, B: 169, A: 255} + DimGray = sdl.Color{R: 105, G: 105, B: 105, A: 255} + LightSlateGray = sdl.Color{R: 119, G: 136, B: 153, A: 255} + SlateGray = sdl.Color{R: 112, G: 128, B: 144, A: 255} + DarkSlateGray = sdl.Color{R: 47, G: 79, B: 79, A: 255} +) + +// Error Colors +var ( + ErrorRed = sdl.Color{R: 255, G: 80, B: 80, A: 255} +) + +// Pinks & Reds +var ( + Pink = sdl.Color{R: 255, G: 192, B: 203, A: 255} + LightPink = sdl.Color{R: 255, G: 182, B: 193, A: 255} + HotPink = sdl.Color{R: 255, G: 105, B: 180, A: 255} + DeepPink = sdl.Color{R: 255, G: 20, B: 147, A: 255} + PaleVioletRed = sdl.Color{R: 219, G: 112, B: 147, A: 255} + MediumVioletRed = sdl.Color{R: 199, G: 21, B: 133, A: 255} + LightSalmon = sdl.Color{R: 255, G: 160, B: 122, A: 255} + Salmon = sdl.Color{R: 250, G: 128, B: 114, A: 255} + DarkSalmon = sdl.Color{R: 233, G: 150, B: 122, A: 255} + LightCoral = sdl.Color{R: 240, G: 128, B: 128, A: 255} + IndianRed = sdl.Color{R: 205, G: 92, B: 92, A: 255} + Crimson = sdl.Color{R: 220, G: 20, B: 60, A: 255} + Firebrick = sdl.Color{R: 178, G: 34, B: 34, A: 255} + DarkRed = sdl.Color{R: 139, G: 0, B: 0, A: 255} +) + +// Oranges +var ( + OrangeRed = sdl.Color{R: 255, G: 69, B: 0, A: 255} + Tomato = sdl.Color{R: 255, G: 99, B: 71, A: 255} + Coral = sdl.Color{R: 255, G: 127, B: 80, A: 255} + DarkOrange = sdl.Color{R: 255, G: 140, B: 0, A: 255} + Orange = sdl.Color{R: 255, G: 165, B: 0, A: 255} +) + +// Yellows +var ( + Gold = sdl.Color{R: 255, G: 215, B: 0, A: 255} + LightYellow = sdl.Color{R: 255, G: 255, B: 224, A: 255} + LemonChiffon = sdl.Color{R: 255, G: 250, B: 205, A: 255} + LightGoldenrodYellow = sdl.Color{R: 250, G: 250, B: 210, A: 255} + PapayaWhip = sdl.Color{R: 255, G: 239, B: 213, A: 255} + Moccasin = sdl.Color{R: 255, G: 228, B: 181, A: 255} + PeachPuff = sdl.Color{R: 255, G: 218, B: 185, A: 255} + PaleGoldenrod = sdl.Color{R: 238, G: 232, B: 170, A: 255} + Khaki = sdl.Color{R: 240, G: 230, B: 140, A: 255} + DarkKhaki = sdl.Color{R: 189, G: 183, B: 107, A: 255} +) + +// Purples & Violets +var ( + Lavender = sdl.Color{R: 230, G: 230, B: 250, A: 255} + Thistle = sdl.Color{R: 216, G: 191, B: 216, A: 255} + Plum = sdl.Color{R: 221, G: 160, B: 221, A: 255} + Violet = sdl.Color{R: 238, G: 130, B: 238, A: 255} + Orchid = sdl.Color{R: 218, G: 112, B: 214, A: 255} + Magenta = sdl.Color{R: 255, G: 0, B: 255, A: 255} + MediumOrchid = sdl.Color{R: 186, G: 85, B: 211, A: 255} + MediumPurple = sdl.Color{R: 147, G: 112, B: 219, A: 255} + RebeccaPurple = sdl.Color{R: 102, G: 51, B: 153, A: 255} + BlueViolet = sdl.Color{R: 138, G: 43, B: 226, A: 255} + DarkViolet = sdl.Color{R: 148, G: 0, B: 211, A: 255} + DarkOrchid = sdl.Color{R: 153, G: 50, B: 204, A: 255} + DarkMagenta = sdl.Color{R: 139, G: 0, B: 139, A: 255} + Indigo = sdl.Color{R: 75, G: 0, B: 130, A: 255} + SlateBlue = sdl.Color{R: 106, G: 90, B: 205, A: 255} + DarkSlateBlue = sdl.Color{R: 72, G: 61, B: 139, A: 255} +) + +// Greens +var ( + GreenYellow = sdl.Color{R: 173, G: 255, B: 47, A: 255} + Chartreuse = sdl.Color{R: 127, G: 255, B: 0, A: 255} + LawnGreen = sdl.Color{R: 124, G: 252, B: 0, A: 255} + LimeGreen = sdl.Color{R: 50, G: 205, B: 50, A: 255} + PaleGreen = sdl.Color{R: 152, G: 251, B: 152, A: 255} + LightGreen = sdl.Color{R: 144, G: 238, B: 144, A: 255} + MediumSpringGreen = sdl.Color{R: 0, G: 250, B: 154, A: 255} + SpringGreen = sdl.Color{R: 0, G: 255, B: 127, A: 255} + MediumSeaGreen = sdl.Color{R: 60, G: 179, B: 113, A: 255} + SeaGreen = sdl.Color{R: 46, G: 139, B: 87, A: 255} + ForestGreen = sdl.Color{R: 34, G: 139, B: 34, A: 255} + DarkGreen = sdl.Color{R: 0, G: 100, B: 0, A: 255} + YellowGreen = sdl.Color{R: 154, G: 205, B: 50, A: 255} + OliveDrab = sdl.Color{R: 107, G: 142, B: 35, A: 255} + DarkOliveGreen = sdl.Color{R: 85, G: 107, B: 47, A: 255} + MediumAquamarine = sdl.Color{R: 102, G: 205, B: 170, A: 255} + DarkSeaGreen = sdl.Color{R: 143, G: 188, B: 143, A: 255} + LightSeaGreen = sdl.Color{R: 32, G: 178, B: 170, A: 255} + DarkCyan = sdl.Color{R: 0, G: 139, B: 139, A: 255} +) + +// Blues & Cyans +var ( + LightCyan = sdl.Color{R: 224, G: 255, B: 255, A: 255} + Cyan = sdl.Color{R: 0, G: 255, B: 255, A: 255} + AquaMarine = sdl.Color{R: 127, G: 255, B: 212, A: 255} + PaleTurquoise = sdl.Color{R: 175, G: 238, B: 238, A: 255} + Turquoise = sdl.Color{R: 64, G: 224, B: 208, A: 255} + MediumTurquoise = sdl.Color{R: 72, G: 209, B: 204, A: 255} + DarkTurquoise = sdl.Color{R: 0, G: 206, B: 209, A: 255} + CadetBlue = sdl.Color{R: 95, G: 158, B: 160, A: 255} + SteelBlue = sdl.Color{R: 70, G: 130, B: 180, A: 255} + LightSteelBlue = sdl.Color{R: 176, G: 196, B: 222, A: 255} + PowderBlue = sdl.Color{R: 176, G: 224, B: 230, A: 255} + LightBlue = sdl.Color{R: 173, G: 216, B: 230, A: 255} + SkyBlue = sdl.Color{R: 135, G: 206, B: 235, A: 255} + LightSkyBlue = sdl.Color{R: 135, G: 206, B: 250, A: 255} + DeepSkyBlue = sdl.Color{R: 0, G: 191, B: 255, A: 255} + DodgerBlue = sdl.Color{R: 30, G: 144, B: 255, A: 255} + CornflowerBlue = sdl.Color{R: 100, G: 149, B: 237, A: 255} + MediumSlateBlue = sdl.Color{R: 123, G: 104, B: 238, A: 255} + RoyalBlue = sdl.Color{R: 65, G: 105, B: 225, A: 255} + MediumBlue = sdl.Color{R: 0, G: 0, B: 205, A: 255} + DarkBlue = sdl.Color{R: 0, G: 0, B: 139, A: 255} + MidnightBlue = sdl.Color{R: 25, G: 25, B: 112, A: 255} +) + +// Browns +var ( + Cornsilk = sdl.Color{R: 255, G: 248, B: 220, A: 255} + BlanchedAlmond = sdl.Color{R: 255, G: 235, B: 205, A: 255} + Bisque = sdl.Color{R: 255, G: 228, B: 196, A: 255} + NavajoWhite = sdl.Color{R: 255, G: 222, B: 173, A: 255} + Wheat = sdl.Color{R: 245, G: 222, B: 179, A: 255} + BurlyWood = sdl.Color{R: 222, G: 184, B: 135, A: 255} + Tan = sdl.Color{R: 210, G: 180, B: 140, A: 255} + RosyBrown = sdl.Color{R: 188, G: 143, B: 143, A: 255} + SandyBrown = sdl.Color{R: 244, G: 164, B: 96, A: 255} + Goldenrod = sdl.Color{R: 218, G: 165, B: 32, A: 255} + DarkGoldenrod = sdl.Color{R: 184, G: 134, B: 11, A: 255} + Peru = sdl.Color{R: 205, G: 133, B: 63, A: 255} + Chocolate = sdl.Color{R: 210, G: 105, B: 30, A: 255} + SaddleBrown = sdl.Color{R: 139, G: 69, B: 19, A: 255} + Sienna = sdl.Color{R: 160, G: 82, B: 45, A: 255} + Brown = sdl.Color{R: 165, G: 42, B: 42, A: 255} +) + +// Whites +var ( + Snow = sdl.Color{R: 255, G: 250, B: 250, A: 255} + Honeydew = sdl.Color{R: 240, G: 255, B: 240, A: 255} + MintCream = sdl.Color{R: 245, G: 255, B: 250, A: 255} + Azure = sdl.Color{R: 240, G: 255, B: 255, A: 255} + AliceBlue = sdl.Color{R: 240, G: 248, B: 255, A: 255} + GhostWhite = sdl.Color{R: 248, G: 248, B: 255, A: 255} + WhiteSmoke = sdl.Color{R: 245, G: 245, B: 245, A: 255} + Seashell = sdl.Color{R: 255, G: 245, B: 238, A: 255} + Beige = sdl.Color{R: 245, G: 245, B: 220, A: 255} + OldLace = sdl.Color{R: 253, G: 245, B: 230, A: 255} + FloralWhite = sdl.Color{R: 255, G: 250, B: 240, A: 255} + Ivory = sdl.Color{R: 255, G: 255, B: 240, A: 255} + AntiqueWhite = sdl.Color{R: 250, G: 235, B: 215, A: 255} + Linen = sdl.Color{R: 250, G: 240, B: 230, A: 255} + LavenderBlush = sdl.Color{R: 255, G: 240, B: 245, A: 255} + MistyRose = sdl.Color{R: 255, G: 228, B: 225, A: 255} +) diff --git a/internal/db/db.go b/internal/db/db.go new file mode 100644 index 0000000..8d924f1 --- /dev/null +++ b/internal/db/db.go @@ -0,0 +1,488 @@ +package db + +import ( + "fmt" + "log" + "os" + "path/filepath" + "strings" + "sync" + + "gorm.io/driver/sqlite" + "gorm.io/gorm" + "rhemawavetech.com/rhemawave/internal/logger" +) + +var DB *gorm.DB + +// configCache is an in-memory cache of config values to avoid repeated DB queries. +var configCache = struct { + sync.RWMutex + m map[string]string +}{m: make(map[string]string)} + +type Config struct { + gorm.Model + Key string `gorm:"uniqueIndex"` + Value string +} + +type Proclamations struct { + gorm.Model + Title string + Content string + Commercial bool + Selected bool + Favorite bool + Available bool +} + +type Log struct { + gorm.Model + Timestamp string + Level string + Message string +} + +func (Log) TableName() string { + return "log_entries" +} + +type TOSSection struct { + gorm.Model + SectionNumber int `gorm:"uniqueIndex"` + Title string + Content string // raw HTML +} + +var defaultConfigValues = map[string]string{ + "home_dir": "", + "assets_dir": "", // Set dynamically in seedDefaults() to $HOME/.local/share/rhemawave + "log_dir": "", // Set dynamically in seedDefaults() to $HOME/.local/share/rhemawave/logs.log + "email_address": "", + "license_key": "", + "system_type": "home", + "system_capabilities": "", + "selected_audio": "audio/audio.wav", + "audio_device_name": "", + "application_font": "Roboto-Regular", + "init_font_size": "128", + "standard_font_size": "32", + "line_pattern": "fibonacci", + "last_volume": "128", + "audio_enabled": "true", + "tos_section_1_accepted": "false", + "tos_section_2_accepted": "false", + "tos_section_3_accepted": "false", + "tos_section_4_accepted": "false", + "tos_section_5_accepted": "false", + "tos_section_6_accepted": "false", + "tos_section_7_accepted": "false", + "tos_section_8_accepted": "false", + "tos_section_9_accepted": "false", + "tos_section_10_accepted": "false", +} + +// InitDatabase initializes the SQLite database connection +// and performs auto-migration for all models +func InitDatabase(dbpath string) error { + // Create the directory for the database if it doesn't exist + dbDir := filepath.Dir(dbpath) + if err := os.MkdirAll(dbDir, 0700); err != nil { + log.Printf("Error creating database directory %s: %v", dbDir, err) + return err + } + + // Check if database file exists + _, err := os.Stat(dbpath) + dbExists := !os.IsNotExist(err) + + if !dbExists { + log.Printf("Database file does not exist at %s, creating new database", dbpath) + } + + dsn := fmt.Sprintf("file:%s", dbpath) + + DB, err = gorm.Open(sqlite.Open(dsn), &gorm.Config{}) + if err != nil { + log.Printf("Error opening database: %v", err) + return err + } + + // Get underlying sql.DB to set pragmas + sqlDB, err := DB.DB() + if err != nil { + logger.Error("Error getting underlying database connection: %v", err) + return err + } + + // Configure SQLite for reliability and performance + pragmas := []string{ + "PRAGMA journal_mode=WAL", // Write-Ahead Logging for better concurrency + "PRAGMA synchronous=FULL", // Maximum durability + "PRAGMA foreign_keys=ON", // Enable foreign key constraints + "PRAGMA busy_timeout=5000", // Wait up to 5 seconds for locks + "PRAGMA temp_store=MEMORY", // Keep temp tables in memory + } + + for _, pragma := range pragmas { + if _, err := sqlDB.Exec(pragma); err != nil { + logger.Error("Error setting pragma %s: %v", pragma, err) + return fmt.Errorf("failed to set pragma: %w", err) + } + } + + if err := sqlDB.Ping(); err != nil { + logger.Error("Error pinging database: %v", err) + return fmt.Errorf("database connection failed: %w", err) + } + + log.Println("Database connected successfully") + + // Auto-migrate models + err = DB.AutoMigrate(&Config{}, &Proclamations{}, &Log{}, &TOSSection{}) + if err != nil { + logger.Error("Error migrating database: %v", err) + return err + } + log.Println("Database migrated successfully") + + // Seed defaults + err = ensureDefaultsExist() + if err != nil { + logger.Error("Error seeding default configuration values: %v", err) + return err + } + err = seedDefaultProclamations() + if err != nil { + logger.Error("Error seeding default proclamations: %v", err) + return err + } + + err = seedDefaultTOSSections() + if err != nil { + logger.Error("Error seeding default TOS sections: %v", err) + return err + } + + log.Println("Database initialized successfully") + return nil +} + +// seedDefaultProclamations reads proclamation text files from the assets directory +// and populates the database on first run +func seedDefaultProclamations() error { + var count int64 + err := DB.Model(&Proclamations{}).Count(&count).Error + if err != nil { + logger.Error("Error counting proclamations: %v", err) + return err + } + + // Only seed if table is empty + if count > 0 { + return nil + } + + // Get the assets directory from config + assetsDir, err := GetConfigValue("assets_dir") + if err != nil { + logger.Error("Error getting assets_dir: %v", err) + return err + } + + proclamationsBaseDir := assetsDir + "/proclamations" + + // Process both home and commercial directories + subdirs := []string{"home", "commercial"} + totalSeeded := 0 + + for _, subdir := range subdirs { + proclamationsDir := proclamationsBaseDir + "/" + subdir + isCommercial := (subdir == "commercial") + + // Read all .txt files from the subdirectory + files, err := os.ReadDir(proclamationsDir) + if err != nil { + logger.Error("Error reading proclamations directory %s: %v", proclamationsDir, err) + continue // Continue with other directories even if one fails + } + + for _, file := range files { + if file.IsDir() || !strings.HasSuffix(file.Name(), ".txt") { + continue + } + + filePath := proclamationsDir + "/" + file.Name() + content, err := os.ReadFile(filePath) + if err != nil { + logger.Error("Error reading file %s: %v", filePath, err) + continue + } + + // Extract title from filename (remove .txt extension) + title := strings.TrimSuffix(file.Name(), ".txt") + + // Select "Relaxation" as the default proclamation + isSelected := (title == "Relaxation") + + proclamation := Proclamations{ + Title: title, + Content: string(content), + Commercial: isCommercial, + Selected: isSelected, + Favorite: false, + Available: true, + } + + if err := DB.Create(&proclamation).Error; err != nil { + logger.Error("Error creating proclamation from %s: %v", file.Name(), err) + return err + } + + if isSelected { + logger.Error("Set default proclamation: %s", title) + } + + totalSeeded++ + } + } + + logger.Error("Seeded %d default proclamations from %s", totalSeeded, proclamationsBaseDir) + return nil +} + +// GetConfigValue retrieves a configuration value by key. +// Results are cached in memory to avoid repeated DB queries. +func GetConfigValue(key string) (string, error) { + configCache.RLock() + if v, ok := configCache.m[key]; ok { + configCache.RUnlock() + return v, nil + } + configCache.RUnlock() + + var config Config + result := DB.First(&config, "key = ?", key) + if result.Error != nil { + return "", result.Error + } + + configCache.Lock() + configCache.m[key] = config.Value + configCache.Unlock() + + return config.Value, nil +} + +// GetConfigValues retrieves all configuration key-value pairs +// Returns a map of key-value pairs OR any error encountered +// This is mainly for compatibility with legacy code, but can +// be useful for bulkl config referrals +func GetConfigValues() (map[string]string, error) { + var configs []Config + result := DB.Find(&configs) + if result.Error != nil { + return nil, result.Error + } + configMap := make(map[string]string) + for _, config := range configs { + configMap[config.Key] = config.Value + } + return configMap, nil +} + +// SetConfigValue sets a configuration value by key +// Returns any error encountered || nil +func SetConfigValue(key, value string) error { + // First try to find existing config + var config Config + result := DB.Where("key = ?", key).First(&config) + + if result.Error != nil { + if result.Error == gorm.ErrRecordNotFound { + // Record doesn't exist, create new one + config = Config{Key: key, Value: value} + if err := DB.Create(&config).Error; err != nil { + return fmt.Errorf("failed to create config value for key %s: %w", key, err) + } + } else { + // Some other error occurred + return fmt.Errorf("failed to query config for key %s: %w", key, result.Error) + } + } else { + // Record exists, update it + config.Value = value + if err := DB.Save(&config).Error; err != nil { + return fmt.Errorf("failed to update config value for key %s: %w", key, err) + } + } + + // Update cache + configCache.Lock() + configCache.m[key] = value + configCache.Unlock() + + return nil +} + +// GetProclamations retrieves all proclamation entries from the database +// Returns a slice of Proclamations OR any error encountered +func GetProclamations() ([]Proclamations, error) { + var proclamations []Proclamations + result := DB.Find(&proclamations) + if result.Error != nil { + return nil, result.Error + } + return proclamations, nil +} + +// seedDefaultTOSSections reads HTML files from the assets directory and populates the +// TOS sections table on first run. +func seedDefaultTOSSections() error { + var count int64 + if err := DB.Model(&TOSSection{}).Count(&count).Error; err != nil { + return err + } + if count > 0 { + return nil + } + + assetsDir, err := GetConfigValue("assets_dir") + if err != nil { + return fmt.Errorf("getting assets_dir: %w", err) + } + + tosDir := filepath.Join(assetsDir, "tos") + files, err := os.ReadDir(tosDir) + if err != nil { + return fmt.Errorf("reading tos directory %s: %w", tosDir, err) + } + + seeded := 0 + for _, file := range files { + if file.IsDir() || !strings.HasSuffix(file.Name(), ".html") { + continue + } + + // Parse filename: "01 - WELCOME.html" -> number=1, title="WELCOME" + name := strings.TrimSuffix(file.Name(), ".html") + parts := strings.SplitN(name, " - ", 2) + if len(parts) != 2 { + logger.Error("Skipping TOS file with unexpected name format: %s", file.Name()) + continue + } + + var sectionNum int + if _, err := fmt.Sscanf(parts[0], "%d", §ionNum); err != nil { + logger.Error("Skipping TOS file, cannot parse section number: %s", file.Name()) + continue + } + title := strings.TrimSpace(parts[1]) + + content, err := os.ReadFile(filepath.Join(tosDir, file.Name())) + if err != nil { + logger.Error("Error reading TOS file %s: %v", file.Name(), err) + continue + } + + section := TOSSection{ + SectionNumber: sectionNum, + Title: title, + Content: string(content), + } + if err := DB.Create(§ion).Error; err != nil { + return fmt.Errorf("creating TOS section from %s: %w", file.Name(), err) + } + seeded++ + } + + logger.Info("Seeded %d TOS sections from %s", seeded, tosDir) + return nil +} + +// GetTOSSections returns all TOS sections ordered by section number. +func GetTOSSections() ([]TOSSection, error) { + var sections []TOSSection + result := DB.Order("section_number asc").Find(§ions) + if result.Error != nil { + return nil, result.Error + } + return sections, nil +} + +// GetLogs retrieves log entries from the database, ordered by creation time ascending. +// If limit > 0, at most that many entries are returned. +func GetLogs(limit int) ([]Log, error) { + var logs []Log + query := DB.Order("created_at DESC") + if limit > 0 { + query = query.Limit(limit) + } + return logs, query.Find(&logs).Error +} + +// ensureDefaultsExist checks the current configs table rows and inserts any new rows +// from defaultConfigValues to the database if they don't exist. +// This is essentially an automatic migration for new config values. +func ensureDefaultsExist() error { + for key, value := range defaultConfigValues { + var config Config + result := DB.Where("key = ?", key).First(&config) + + // Always re-resolve path-based config values from the current binary location + switch key { + case "assets_dir": + value = resolveAssetsDir() + case "log_dir": + value = filepath.Join(resolveAssetsDir(), "logs.log") + } + + if result.Error == gorm.ErrRecordNotFound { + // Key doesn't exist, create it with default value + if err := DB.Create(&Config{Key: key, Value: value}).Error; err != nil { + return fmt.Errorf("failed to create default config for %s: %w", key, err) + } + log.Printf("Added missing config key: %s", key) + } else if result.Error != nil { + return result.Error + } else if (key == "assets_dir" || key == "log_dir") && config.Value != value { + // Update stale path-based values (e.g. after Nix store update) + config.Value = value + if err := DB.Save(&config).Error; err != nil { + return fmt.Errorf("failed to update config for %s: %w", key, err) + } + log.Printf("Updated stale config key: %s", key) + } else if key == "selected_audio" && config.Value == "audio/7.83.wav" { + // Migrate renamed audio file + config.Value = value + if err := DB.Save(&config).Error; err != nil { + return fmt.Errorf("failed to migrate config for %s: %w", key, err) + } + log.Printf("Migrated config key: %s", key) + } + } + return nil +} + +func AudioEnabled() bool { + on, err := GetConfigValue("audio_enabled") + if err != nil { + return false + } + return on == "true" +} + +// resolveAssetsDir returns the assets directory by resolving relative to the +// running binary. For a binary at .../bin/rhemawave, assets are at +// .../share/rhemawave. Falls back to /usr/local/share/rhemawave. +func resolveAssetsDir() string { + exe, err := os.Executable() + if err == nil { + exe, err = filepath.EvalSymlinks(exe) + } + if err == nil { + return filepath.Join(filepath.Dir(exe), "..", "share", "rhemawave") + } + return filepath.Join("/usr", "local", "share", "rhemawave") +} diff --git a/internal/fontManager/fontManager.go b/internal/fontManager/fontManager.go new file mode 100644 index 0000000..433ce3a --- /dev/null +++ b/internal/fontManager/fontManager.go @@ -0,0 +1,829 @@ +package fontManager + +import ( + "fmt" + "os" + "path/filepath" + "strconv" + "strings" + "sync" + + "github.com/go-gl/gl/v3.3-core/gl" + "github.com/go-gl/mathgl/mgl32" + "github.com/veandco/go-sdl2/sdl" + "github.com/veandco/go-sdl2/ttf" + "rhemawavetech.com/rhemawave/internal/db" + "rhemawavetech.com/rhemawave/internal/graphics" + "rhemawavetech.com/rhemawave/internal/shaderManager" +) + +// FontManager handles the loading and management of fonts. +type FontManager struct { + Fonts map[string]*FontEntry + + // Reusable GPU objects for string texture rendering + stringFBO uint32 + stringVAO uint32 + stringVBO uint32 +} + +var ( + fontManagerInstance *FontManager + fontManagerOnce sync.Once + initErr error // Package-level variable to capture error from within sync.Once +) + +// InitFontManager initializes the FontManager singleton. +// It must be called once at startup after ShaderManager has been initialized. +func InitFontManager() error { + fontManagerOnce.Do(func() { + + // Dependency check: Ensure ShaderManager is ready + sm := shaderManager.Get() + if sm == nil { + initErr = fmt.Errorf("cannot initialize FontManager because ShaderManager is not initialized") + return // Exit the anonymous function + } + + fm := &FontManager{ + Fonts: make(map[string]*FontEntry), + } + + assetsDir, err := db.GetConfigValue("assets_dir") + if err != nil { + initErr = fmt.Errorf("could not get assets_dir from config: %w", err) + return + } + fontPath := filepath.Join(assetsDir, "fonts") + if err := fm.loadFonts(fontPath); err != nil { + initErr = fmt.Errorf("could not load fonts from '%s': %w", fontPath, err) + return + } + + // --- NEW: Create the scrambled font after loading normal fonts --- + // We will use "DejaVuSans" as the base. If you use a different default font, + // change this string. + baseFontForScramble := "Roboto-Regular" + if _, ok := fm.Fonts[baseFontForScramble]; ok { + if err := fm.CreateScrambledFont(baseFontForScramble, "Scrambled"); err != nil { + // This is not a fatal error for the whole application, so we just log it. + } + } else { + } + // --- END NEW --- + + // Create reusable GPU objects for string texture rendering + gl.GenFramebuffers(1, &fm.stringFBO) + gl.GenVertexArrays(1, &fm.stringVAO) + gl.GenBuffers(1, &fm.stringVBO) + + // Set up VAO attribute layout once + gl.BindVertexArray(fm.stringVAO) + gl.BindBuffer(gl.ARRAY_BUFFER, fm.stringVBO) + gl.BufferData(gl.ARRAY_BUFFER, 6*4*4, nil, gl.DYNAMIC_DRAW) // 6 vertices * 4 floats * 4 bytes + gl.EnableVertexAttribArray(0) + gl.VertexAttribPointerWithOffset(0, 2, gl.FLOAT, false, 4*4, 0) + gl.EnableVertexAttribArray(1) + gl.VertexAttribPointerWithOffset(1, 2, gl.FLOAT, false, 4*4, 2*4) + gl.BindVertexArray(0) + gl.BindBuffer(gl.ARRAY_BUFFER, 0) + + fontManagerInstance = fm + }) + + // Return the error that might have been captured inside the sync.Once block. + return initErr +} + +// Get returns the singleton instance of the FontManager. +// It will panic if InitFontManager has not been called successfully first. +func Get() *FontManager { + if fontManagerInstance == nil { + panic("FontManager has not been initialized or initialization failed. Call InitFontManager at application startup.") + } + return fontManagerInstance +} + +// FontEntry combines related Font information together +type FontEntry struct { + Name string + Font *ttf.Font + Map *FontMap +} + +// FontMap contains the character map for a specific font +type FontMap struct { + FontMapTextureID uint32 // Memory address of the FontMapTexture within the GPU + Width int32 // The width of the font map texture + Height int32 // The height of the font map FontMap Texture + Glyphs map[rune]Glyph // A map of runes and their locations within the Fontmap + padding int32 +} + +// TempGlyph is a temporary struct used only during font map creation. +type TempGlyph struct { + Rune rune + Advance int + surface *sdl.Surface +} + +// Glyph contains the rendering information for a single character +type Glyph struct { + Rune rune // The character this glyph represents. + SrcRect sdl.Rect // The source rectangle in the texture atlas. + Advance int // How far to advance the cursor after drawing this glyph. + TextureID uint32 // The ID of the texture atlas this glyph belongs to. +} + +// loadFonts scans the fonts directory, loads all .ttf/.otf files, and creates a font map for each. +func (fm *FontManager) loadFonts(fontDir string) error { + files, err := os.ReadDir(fontDir) + if err != nil { + return fmt.Errorf("could not read font directory '%s': %w", fontDir, err) + } + + for _, file := range files { + if file.IsDir() { + continue + } + fileName := file.Name() + if strings.HasSuffix(strings.ToLower(fileName), ".ttf") || strings.HasSuffix(strings.ToLower(fileName), ".otf") { + fontPath := filepath.Join(fontDir, fileName) + baseFontSizeStr, err := db.GetConfigValue("init_font_size") + if err != nil { + return fmt.Errorf("could not get standard_font_size from config: %w", err) + } + baseFontSize, err := strconv.Atoi(baseFontSizeStr) + if err != nil { + return fmt.Errorf("could not convert init_font_size to int: %w", err) + } + font, err := ttf.OpenFont(fontPath, baseFontSize) // Using a higher resolution for better quality + if err != nil { + continue + } + + fontName := strings.TrimSuffix(fileName, filepath.Ext(fileName)) + fm.Fonts[fontName] = &FontEntry{ + Name: fontName, + Font: font, + Map: nil, + } + } + } + + for _, fontEntry := range fm.Fonts { + if err := fm.createFontMap(fontEntry, false, nil); err != nil { + return fmt.Errorf("unable to create Font Map for font: %s : %v", fontEntry.Name, err) + } + } + + return nil +} + +// CreateScrambledFont generates a new font entry by scrambling the glyphs of a base font. +func (fm *FontManager) CreateScrambledFont(baseFontName string, newFontName string) error { + baseFont, ok := fm.Fonts[baseFontName] + if !ok { + return fmt.Errorf("base font '%s' not found", baseFontName) + } + + scrambledFontEntry := &FontEntry{ + Name: newFontName, + Font: baseFont.Font, // It uses the same underlying TTF font object for rendering + Map: nil, + } + + if err := fm.createFontMap(scrambledFontEntry, true, baseFont); err != nil { + return fmt.Errorf("unable to create scrambled font map: %w", err) + } + + fm.Fonts[newFontName] = scrambledFontEntry + return nil +} + +// ATTENTION: TED +// +// # Deterministic Fibonacci-Based Visual Pattern Generation for Character Data +// +// This method transforms rendered text characters into structured visual patterns that produce +// character-specific spatial frequency signatures while maintaining perfect reversibility. +// +// The technology addresses a fundamental limitation in subliminal text display: conventional +// approaches either use unmodified text (consciously readable, defeating the subliminal purpose) +// or simple blurring/masking (destroys information content and character-specific structure). +// Our method preserves complete character information in a transformed visual state that remains +// illegible to conscious observation while generating structured spatial patterns. +// +// The approach treats each rendered character as a two-dimensional grid and applies deterministic +// geometric transformations parameterized by Fibonacci sequence values. The character's Unicode +// value seeds all transformation parameters, ensuring identical characters produce identical +// patterns while different characters generate distinct spatial signatures. Multiple transformation +// stages compound to create high-entropy visual output with underlying mathematical structure. +// +// Key differentiators from existing solutions: +// - Operates on rendered visual data rather than underlying text data or encrypted values +// - Generates character-specific spatial frequency patterns rather than uniform noise +// - Uses Fibonacci-sequence-derived parameters to create mathematically structured transformations +// - Maintains pixel-perfect reversibility despite high visual entropy +// - Produces deterministic, reproducible patterns for each character +// +// Within our Rhema Wave generation system, these transformed characters create spatial interference +// patterns designed for subconscious processing. Each character contributes a unique frequency +// signature to the overall visual field, with Fibonacci-based geometry intended to create harmonic +// relationships between character patterns. The result is a consciously illegible display that +// maintains structured information content in the spatial domain, forming a component of the +// broader Rhema Wave output. +func (fm *FontManager) scrambleSurface(surface *sdl.Surface, r rune) error { + if surface.W < 8 || surface.H < 8 { + return nil + } + if err := surface.Lock(); err != nil { + return fmt.Errorf("could not lock surface for scrambling: %w", err) + } + defer surface.Unlock() + + W := int(surface.W) + H := int(surface.H) + + // Use much finer grid for complete illegibility + // Fibonacci number determines grid size: 5, 8, or 13 + fib := []int{5, 8, 13} + fibIndex := int(r) % len(fib) + gridSize := fib[fibIndex] + + // Ensure we have at least 8x8 grid for strong scrambling + if gridSize < 8 { + gridSize = 8 + } + + blockW := W / gridSize + blockH := H / gridSize + + if blockW == 0 || blockH == 0 { + // Surface too small, fall back to 4x4 + gridSize = 4 + blockW = W / gridSize + blockH = H / gridSize + if blockW == 0 || blockH == 0 { + return nil + } + } + + numBlocks := gridSize * gridSize + + // Create complete permutation using Fibonacci linear congruential generator + blockIndices := make([]int, numBlocks) + + // Use Fibonacci numbers for the LCG parameters + // F(7)=13, F(8)=21, F(9)=34, F(10)=55, F(11)=89 + fibSeq := []int{13, 21, 34, 55, 89, 144} + multiplier := fibSeq[int(r)%len(fibSeq)] + increment := fibSeq[(int(r)+1)%len(fibSeq)] + + // Generate pseudo-random permutation + for i := 0; i < numBlocks; i++ { + blockIndices[i] = (multiplier*i + increment*int(r)) % numBlocks + } + + // Additional scrambling: apply multiple Fibonacci-based transformations + numTransforms := 3 + (int(r) % 5) // 3-7 transformations + + for t := 0; t < numTransforms; t++ { + transformType := (int(r) + t*fibSeq[t%len(fibSeq)]) % 5 + + switch transformType { + case 0: // Reverse sections + sectionSize := gridSize / 2 + for i := 0; i < numBlocks; i += sectionSize { + end := i + sectionSize + if end > numBlocks { + end = numBlocks + } + reverseSlice(blockIndices[i:end]) + } + + case 1: // Spiral rotation + // Rotate blocks in a spiral pattern + for layer := 0; layer < gridSize/2; layer++ { + rotateLayer(blockIndices, gridSize, layer) + } + + case 2: // Fibonacci walk swap + step := fib[t%len(fib)] + for i := 0; i < numBlocks-step; i += step { + blockIndices[i], blockIndices[i+step] = blockIndices[i+step], blockIndices[i] + } + + case 3: // Checkerboard transpose + for i := 0; i < gridSize; i++ { + for j := 0; j < gridSize; j++ { + if (i+j)%2 == 0 { + idx1 := i*gridSize + j + idx2 := j*gridSize + i + if idx2 < numBlocks { + blockIndices[idx1], blockIndices[idx2] = blockIndices[idx2], blockIndices[idx1] + } + } + } + } + + case 4: // Random-walk permutation + walkLen := fib[(t+1)%len(fib)] + pos := int(r+rune(t)) % numBlocks + for w := 0; w < walkLen && pos < numBlocks-1; w++ { + nextPos := (pos + fib[w%len(fib)]) % numBlocks + blockIndices[pos], blockIndices[nextPos] = blockIndices[nextPos], blockIndices[pos] + pos = nextPos + } + } + } + + // Copy pixels to perform the scrambling + pixels := surface.Pixels() + bytesPerPixel := int(surface.Format.BytesPerPixel) + pitch := int(surface.Pitch) + originalPixels := make([]byte, len(pixels)) + copy(originalPixels, pixels) + + // Rearrange all blocks + for dstIdx := 0; dstIdx < numBlocks; dstIdx++ { + srcIdx := blockIndices[dstIdx] + + srcCol := srcIdx % gridSize + srcRow := srcIdx / gridSize + dstCol := dstIdx % gridSize + dstRow := dstIdx / gridSize + + srcX := srcCol * blockW + srcY := srcRow * blockH + dstX := dstCol * blockW + dstY := dstRow * blockH + + // Copy block pixel by pixel + for y := 0; y < blockH; y++ { + if srcY+y >= H || dstY+y >= H { + continue + } + + srcOffset := (srcY+y)*pitch + srcX*bytesPerPixel + dstOffset := (dstY+y)*pitch + dstX*bytesPerPixel + + rowLen := blockW * bytesPerPixel + if srcX+blockW > W { + rowLen = (W - srcX) * bytesPerPixel + } + if dstX+blockW > W { + maxLen := (W - dstX) * bytesPerPixel + if maxLen < rowLen { + rowLen = maxLen + } + } + + if srcOffset+rowLen <= len(originalPixels) && dstOffset+rowLen <= len(pixels) { + copy(pixels[dstOffset:dstOffset+rowLen], originalPixels[srcOffset:srcOffset+rowLen]) + } + } + } + + return nil +} + +// Helper function to reverse a slice +func reverseSlice(arr []int) { + for i, j := 0, len(arr)-1; i < j; i, j = i+1, j-1 { + arr[i], arr[j] = arr[j], arr[i] + } +} + +// Helper function to rotate a layer in spiral pattern +func rotateLayer(arr []int, gridSize, layer int) { + if layer >= gridSize/2 { + return + } + + // Extract the layer elements + var temp []int + + // Top edge + for i := layer; i < gridSize-layer; i++ { + temp = append(temp, arr[layer*gridSize+i]) + } + // Right edge + for i := layer + 1; i < gridSize-layer; i++ { + temp = append(temp, arr[i*gridSize+(gridSize-layer-1)]) + } + // Bottom edge + if gridSize-layer-1 > layer { + for i := gridSize - layer - 2; i >= layer; i-- { + temp = append(temp, arr[(gridSize-layer-1)*gridSize+i]) + } + } + // Left edge + if gridSize-layer-1 > layer { + for i := gridSize - layer - 2; i > layer; i-- { + temp = append(temp, arr[i*gridSize+layer]) + } + } + + // Rotate the temp array by 1 position + if len(temp) > 0 { + last := temp[len(temp)-1] + copy(temp[1:], temp[0:len(temp)-1]) + temp[0] = last + } + + // Put back the rotated elements + idx := 0 + // Top edge + for i := layer; i < gridSize-layer && idx < len(temp); i++ { + arr[layer*gridSize+i] = temp[idx] + idx++ + } + // Right edge + for i := layer + 1; i < gridSize-layer && idx < len(temp); i++ { + arr[i*gridSize+(gridSize-layer-1)] = temp[idx] + idx++ + } + // Bottom edge + if gridSize-layer-1 > layer { + for i := gridSize - layer - 2; i >= layer && idx < len(temp); i-- { + arr[(gridSize-layer-1)*gridSize+i] = temp[idx] + idx++ + } + } + // Left edge + if gridSize-layer-1 > layer { + for i := gridSize - layer - 2; i > layer && idx < len(temp); i-- { + arr[i*gridSize+layer] = temp[idx] + idx++ + } + } +} + +// createFontMap generates a texture atlas for a given font entry. +func (fm *FontManager) createFontMap(font *FontEntry, scramble bool, baseFont *FontEntry) error { + var chars []rune + for i := rune(32); i <= 126; i++ { // Common ASCII characters + chars = append(chars, i) + } + + tempGlyphs := make([]TempGlyph, 0, len(chars)) + var totalWidth, maxHeight int32 + padding := int32(2) // 2 pixels of padding between glyphs + + // If scrambling, use the base font's metrics but our new entry's name + fontToRenderFrom := font + if scramble && baseFont != nil { + fontToRenderFrom = baseFont + } + + for _, char := range chars { + tempGlyph, err := fm.createTempGlyph(fontToRenderFrom, char) + if err != nil { + continue + } + + // --- NEW: Scramble the surface if requested --- + if scramble { + if err := fm.scrambleSurface(tempGlyph.surface, char); err != nil { + // We can continue, it will just use the unscrambled glyph + } + } + // --- END NEW --- + + tempGlyphs = append(tempGlyphs, tempGlyph) + totalWidth += tempGlyph.surface.W + padding + if tempGlyph.surface.H > maxHeight { + maxHeight = tempGlyph.surface.H + } + } + + atlasSurface, err := sdl.CreateRGBSurface(0, totalWidth, maxHeight, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000) + if err != nil { + return fmt.Errorf("could not create atlas surface: %w", err) + } + defer atlasSurface.Free() + + fontMap := &FontMap{ + Glyphs: make(map[rune]Glyph), + padding: padding, + } + + var currentX int32 = 0 + for _, tempGlyph := range tempGlyphs { + dstRect := sdl.Rect{X: currentX, Y: 0, W: tempGlyph.surface.W, H: tempGlyph.surface.H} + if err := tempGlyph.surface.Blit(nil, atlasSurface, &dstRect); err != nil { + tempGlyph.surface.Free() + continue + } + + fontMap.Glyphs[tempGlyph.Rune] = Glyph{ + Rune: tempGlyph.Rune, + Advance: tempGlyph.Advance, + SrcRect: dstRect, + } + + currentX += tempGlyph.surface.W + padding + tempGlyph.surface.Free() + } + + textureID, err := graphics.CreateTextureFromSurface(atlasSurface) + if err != nil { + return fmt.Errorf("could not create texture from atlas surface: %w", err) + } + + fontMap.FontMapTextureID = textureID + fontMap.Width = atlasSurface.W + fontMap.Height = atlasSurface.H + + for r, g := range fontMap.Glyphs { + g.TextureID = textureID + fontMap.Glyphs[r] = g + } + + font.Map = fontMap + return nil +} + +// createTempGlyph renders a single character to a temporary SDL surface. +func (fm *FontManager) createTempGlyph(font *FontEntry, char rune) (TempGlyph, error) { + runeSurface, err := font.Font.RenderGlyphBlended(char, sdl.Color{R: 255, G: 255, B: 255, A: 255}) + if err != nil { + return TempGlyph{}, fmt.Errorf("unable to create glyph for char '%c': %w", char, err) + } + + metrics, err := font.Font.GlyphMetrics(char) + if err != nil { + runeSurface.Free() + return TempGlyph{}, fmt.Errorf("unable to fetch glyph metrics for char '%c': %w", char, err) + } + + return TempGlyph{ + Rune: char, + Advance: metrics.Advance, + surface: runeSurface, + }, nil +} + +// GetFont retrieves a loaded font by its name. +func (fm *FontManager) GetFont(name string) (*FontEntry, bool) { + fontEntry, ok := fm.Fonts[name] + return fontEntry, ok +} + +// GetGlyph retrieves the rendering data for a specific character from a font's map. +func (fm *FontManager) GetGlyph(fontName string, r rune) (Glyph, bool) { + fontEntry, ok := fm.Fonts[fontName] + if !ok || fontEntry.Map == nil { + return Glyph{}, false + } + glyph, ok := fontEntry.Map.Glyphs[r] + return glyph, ok +} + +// GetFontNames returns a slice of all loaded font names. +func (fm *FontManager) GetFontNames() []string { + names := make([]string, 0, len(fm.Fonts)) + for name := range fm.Fonts { + names = append(names, name) + } + return names +} + +// Close frees all loaded font resources, including the generated textures. +func (fm *FontManager) Close() { + for _, fontEntry := range fm.Fonts { + if fontEntry.Map != nil && fontEntry.Map.FontMapTextureID != 0 { + gl.DeleteTextures(1, &fontEntry.Map.FontMapTextureID) + } + if fontEntry.Font != nil { + fontEntry.Font.Close() + } + } + + if fm.stringFBO != 0 { + gl.DeleteFramebuffers(1, &fm.stringFBO) + } + if fm.stringVAO != 0 { + gl.DeleteVertexArrays(1, &fm.stringVAO) + } + if fm.stringVBO != 0 { + gl.DeleteBuffers(1, &fm.stringVBO) + } +} + +func (fm *FontManager) CreateStringTexture(fontName string, text string, shader *shaderManager.Shader) (textureID uint32, width int32, height int32, err error) { + shaderID := shader.ProgramID + if fontName == "" || text == "" { + return 0, 0, 0, fmt.Errorf("font name and text cannot be blank") + } + + selectedFont, ok := fm.Fonts[fontName] + if !ok || selectedFont.Map == nil { + return 0, 0, 0, fmt.Errorf("font '%s' not found or its font map is not created", fontName) + } + + var totalWidth, maxHeight int32 + glyphsToRender := make([]Glyph, 0, len(text)) + + for _, r := range text { + g, ok := selectedFont.Map.Glyphs[r] + if !ok { + g = selectedFont.Map.Glyphs['?'] // Fallback + } + totalWidth += g.SrcRect.W + selectedFont.Map.padding + if g.SrcRect.H > maxHeight { + maxHeight = g.SrcRect.H + } + glyphsToRender = append(glyphsToRender, g) + } + + if totalWidth <= 0 || maxHeight <= 0 { + return 0, 0, 0, fmt.Errorf("calculated texture dimensions are invalid: %dx%d", totalWidth, maxHeight) + } + + var lastFBO int32 + gl.GetIntegerv(gl.FRAMEBUFFER_BINDING, &lastFBO) + var lastViewport [4]int32 + gl.GetIntegerv(gl.VIEWPORT, &lastViewport[0]) + + gl.BindFramebuffer(gl.FRAMEBUFFER, fm.stringFBO) + + var newTextureID uint32 + gl.GenTextures(1, &newTextureID) + gl.BindTexture(gl.TEXTURE_2D, newTextureID) + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR) + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR) + gl.PixelStorei(gl.UNPACK_ALIGNMENT, 1) + + gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, totalWidth, maxHeight, 0, gl.RGBA, gl.UNSIGNED_BYTE, nil) + gl.FramebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, newTextureID, 0) + + if gl.CheckFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFER_COMPLETE { + gl.BindFramebuffer(gl.FRAMEBUFFER, uint32(lastFBO)) + gl.DeleteTextures(1, &newTextureID) + return 0, 0, 0, fmt.Errorf("framebuffer is not complete") + } + + gl.Viewport(0, 0, totalWidth, maxHeight) + gl.ClearColor(0.0, 0.0, 0.0, 0.0) + gl.Clear(gl.COLOR_BUFFER_BIT) + gl.UseProgram(shaderID) + + projection := mgl32.Ortho(0, float32(totalWidth), 0, float32(maxHeight), -1, 1) + gl.UniformMatrix4fv(shader.LocMVPMatrix, 1, false, &projection[0]) + + if shader.LocTextColor != -1 { + gl.Uniform4f(shader.LocTextColor, 1.0, 1.0, 1.0, 1.0) + } + + gl.ActiveTexture(gl.TEXTURE0) + gl.Uniform1i(shader.LocTexture, 0) + gl.Enable(gl.BLEND) + gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) + gl.BindTexture(gl.TEXTURE_2D, selectedFont.Map.FontMapTextureID) + + gl.BindVertexArray(fm.stringVAO) + gl.BindBuffer(gl.ARRAY_BUFFER, fm.stringVBO) + + var currentX float32 + atlasW, atlasH := float32(selectedFont.Map.Width), float32(selectedFont.Map.Height) + + for _, glyph := range glyphsToRender { + xPos := currentX + yPos := float32(0) + w, h := float32(glyph.SrcRect.W), float32(glyph.SrcRect.H) + u0 := float32(glyph.SrcRect.X) / atlasW + v0 := float32(glyph.SrcRect.Y) / atlasH + u1 := u0 + w/atlasW + v1 := v0 + h/atlasH + vertices := []float32{ + xPos, yPos + h, u0, v0, + xPos, yPos, u0, v1, + xPos + w, yPos, u1, v1, + xPos, yPos + h, u0, v0, + xPos + w, yPos, u1, v1, + xPos + w, yPos + h, u1, v0, + } + gl.BufferSubData(gl.ARRAY_BUFFER, 0, len(vertices)*4, gl.Ptr(vertices)) + gl.DrawArrays(gl.TRIANGLES, 0, 6) + currentX += float32(glyph.Advance) + } + + gl.BindVertexArray(0) + gl.BindFramebuffer(gl.FRAMEBUFFER, uint32(lastFBO)) + gl.Viewport(lastViewport[0], lastViewport[1], lastViewport[2], lastViewport[3]) + gl.Disable(gl.BLEND) + + return newTextureID, totalWidth, maxHeight, nil +} + +// NewCreateStringTexture does the same thing as CreateStringTexture, except that it returns the width in pixels used by the glyphs +// in the texture, rather than the width of the texture itself. This can be used for trimming. +func (fm *FontManager) NewCreateStringTexture(fontName string, text string, shader *shaderManager.Shader) (textureID uint32, width float32, height int32, err error) { + shaderID := shader.ProgramID + if fontName == "" || text == "" { + return 0, 0, 0, fmt.Errorf("font name and text cannot be blank") + } + + selectedFont, ok := fm.Fonts[fontName] + if !ok || selectedFont.Map == nil { + return 0, 0, 0, fmt.Errorf("font '%s' not found or its font map is not created", fontName) + } + + var totalWidth, maxHeight int32 + glyphsToRender := make([]Glyph, 0, len(text)) + + for _, r := range text { + g, ok := selectedFont.Map.Glyphs[r] + if !ok { + g = selectedFont.Map.Glyphs['?'] // Fallback + } + totalWidth += g.SrcRect.W + selectedFont.Map.padding + if g.SrcRect.H > maxHeight { + maxHeight = g.SrcRect.H + } + glyphsToRender = append(glyphsToRender, g) + } + + if totalWidth <= 0 || maxHeight <= 0 { + return 0, 0, 0, fmt.Errorf("calculated texture dimensions are invalid: %dx%d", totalWidth, maxHeight) + } + + var lastFBO int32 + gl.GetIntegerv(gl.FRAMEBUFFER_BINDING, &lastFBO) + var lastViewport [4]int32 + gl.GetIntegerv(gl.VIEWPORT, &lastViewport[0]) + + gl.BindFramebuffer(gl.FRAMEBUFFER, fm.stringFBO) + + var newTextureID uint32 + gl.GenTextures(1, &newTextureID) + gl.BindTexture(gl.TEXTURE_2D, newTextureID) + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR) + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR) + gl.PixelStorei(gl.UNPACK_ALIGNMENT, 1) + + gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA, totalWidth, maxHeight, 0, gl.RGBA, gl.UNSIGNED_BYTE, nil) + gl.FramebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, newTextureID, 0) + + if gl.CheckFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFER_COMPLETE { + gl.BindFramebuffer(gl.FRAMEBUFFER, uint32(lastFBO)) + gl.DeleteTextures(1, &newTextureID) + return 0, 0, 0, fmt.Errorf("framebuffer is not complete") + } + + gl.Viewport(0, 0, totalWidth, maxHeight) + gl.ClearColor(0.0, 0.0, 0.0, 0.0) + gl.Clear(gl.COLOR_BUFFER_BIT) + gl.UseProgram(shaderID) + + projection := mgl32.Ortho(0, float32(totalWidth), 0, float32(maxHeight), -1, 1) + gl.UniformMatrix4fv(shader.LocMVPMatrix, 1, false, &projection[0]) + + if shader.LocTextColor != -1 { + gl.Uniform4f(shader.LocTextColor, 1.0, 1.0, 1.0, 1.0) + } + + gl.ActiveTexture(gl.TEXTURE0) + gl.Uniform1i(shader.LocTexture, 0) + gl.Enable(gl.BLEND) + gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) + gl.BindTexture(gl.TEXTURE_2D, selectedFont.Map.FontMapTextureID) + + gl.BindVertexArray(fm.stringVAO) + gl.BindBuffer(gl.ARRAY_BUFFER, fm.stringVBO) + + var currentX float32 + atlasW, atlasH := float32(selectedFont.Map.Width), float32(selectedFont.Map.Height) + + for _, glyph := range glyphsToRender { + xPos := currentX + yPos := float32(0) + w, h := float32(glyph.SrcRect.W), float32(glyph.SrcRect.H) + u0 := float32(glyph.SrcRect.X) / atlasW + v0 := float32(glyph.SrcRect.Y) / atlasH + u1 := u0 + w/atlasW + v1 := v0 + h/atlasH + vertices := []float32{ + xPos, yPos + h, u0, v0, + xPos, yPos, u0, v1, + xPos + w, yPos, u1, v1, + xPos, yPos + h, u0, v0, + xPos + w, yPos, u1, v1, + xPos + w, yPos + h, u1, v0, + } + gl.BufferSubData(gl.ARRAY_BUFFER, 0, len(vertices)*4, gl.Ptr(vertices)) + gl.DrawArrays(gl.TRIANGLES, 0, 6) + currentX += float32(glyph.Advance) + } + + usedWidth := float32(currentX) + + gl.BindVertexArray(0) + gl.BindFramebuffer(gl.FRAMEBUFFER, uint32(lastFBO)) + gl.Viewport(lastViewport[0], lastViewport[1], lastViewport[2], lastViewport[3]) + gl.Disable(gl.BLEND) + + return newTextureID, usedWidth, maxHeight, nil +} diff --git a/internal/graphics/graphics.go b/internal/graphics/graphics.go new file mode 100644 index 0000000..89d158c --- /dev/null +++ b/internal/graphics/graphics.go @@ -0,0 +1,128 @@ +package graphics + +import ( + "fmt" + "log" + + "github.com/go-gl/gl/v3.3-core/gl" + "github.com/veandco/go-sdl2/sdl" +) + +// CreateTextureFromSurface uploads an SDL surface to an OpenGL texture and returns the texture ID. +func CreateTextureFromSurface(surface *sdl.Surface) (uint32, error) { + if surface == nil { + return 0, fmt.Errorf("CreateTextureFromSurface: input surface is nil") + } + + var textureID uint32 + var err error + + surfaceToUpload := surface + var convertedSurface *sdl.Surface = nil + + sdlFormatEnum := surface.Format.Format + var dataFormat uint32 + var internalFormat int32 = gl.RGBA8 + + if sdlFormatEnum == sdl.PIXELFORMAT_INDEX8 { + convertedSurface, err = surface.ConvertFormat(sdl.PIXELFORMAT_ARGB8888, 0) + if err != nil { + return 0, fmt.Errorf("failed to convert INDEX8 surface to ARGB8888: %w", err) + } + defer convertedSurface.Free() + + surfaceToUpload = convertedSurface + sdlFormatEnum = surfaceToUpload.Format.Format + } + + switch sdlFormatEnum { + case sdl.PIXELFORMAT_ARGB8888: + dataFormat = gl.BGRA + case sdl.PIXELFORMAT_ABGR8888: + dataFormat = gl.RGBA + case sdl.PIXELFORMAT_RGBA8888: + dataFormat = gl.RGBA + case sdl.PIXELFORMAT_BGRA8888: + dataFormat = gl.BGRA + default: + return 0, fmt.Errorf("unhandled SDL pixel format for OpenGL upload: %s", sdl.GetPixelFormatName(uint(sdlFormatEnum))) + } + + for errCode := gl.GetError(); errCode != gl.NO_ERROR; errCode = gl.GetError() { + log.Printf("OpenGL error pending before GenTextures: 0x%X", errCode) + } + + gl.GenTextures(1, &textureID) + if errCode := gl.GetError(); errCode != gl.NO_ERROR { + return 0, fmt.Errorf("OpenGL error 0x%X after GenTextures", errCode) + } + if textureID == 0 { + return 0, fmt.Errorf("gl.GenTextures returned textureID 0") + } + + gl.BindTexture(gl.TEXTURE_2D, textureID) + + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST) + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST) + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE) + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE) + + gl.PixelStorei(gl.UNPACK_ALIGNMENT, 1) + + expectedPitch := surfaceToUpload.W * int32(surfaceToUpload.Format.BytesPerPixel) + if int32(surfaceToUpload.Pitch) != expectedPitch { + gl.PixelStorei(gl.UNPACK_ROW_LENGTH, surfaceToUpload.Pitch/int32(surfaceToUpload.Format.BytesPerPixel)) + } else { + gl.PixelStorei(gl.UNPACK_ROW_LENGTH, 0) + } + + gl.TexImage2D( + gl.TEXTURE_2D, + 0, + internalFormat, + surfaceToUpload.W, + surfaceToUpload.H, + 0, + dataFormat, + gl.UNSIGNED_BYTE, + gl.Ptr(surfaceToUpload.Pixels()), + ) + + gl.PixelStorei(gl.UNPACK_ALIGNMENT, 4) + gl.PixelStorei(gl.UNPACK_ROW_LENGTH, 0) + + if glErr := gl.GetError(); glErr != gl.NO_ERROR { + gl.DeleteTextures(1, &textureID) + return 0, fmt.Errorf("OpenGL error 0x%X after TexImage2D", glErr) + } + + gl.BindTexture(gl.TEXTURE_2D, 0) + return textureID, nil +} + +// CheckGLError queries OpenGL for errors and returns the first one found. +func CheckGLError() error { + errCode := gl.GetError() + if errCode == gl.NO_ERROR { + return nil + } + + switch errCode { + case gl.INVALID_ENUM: + return fmt.Errorf("INVALID_ENUM") + case gl.INVALID_VALUE: + return fmt.Errorf("INVALID_VALUE") + case gl.INVALID_OPERATION: + return fmt.Errorf("INVALID_OPERATION") + case gl.STACK_OVERFLOW: + return fmt.Errorf("STACK_OVERFLOW") + case gl.STACK_UNDERFLOW: + return fmt.Errorf("STACK_UNDERFLOW") + case gl.OUT_OF_MEMORY: + return fmt.Errorf("OUT_OF_MEMORY") + case gl.INVALID_FRAMEBUFFER_OPERATION: + return fmt.Errorf("INVALID_FRAMEBUFFER_OPERATION") + default: + return fmt.Errorf("Unknown GL error: 0x%X", errCode) + } +} diff --git a/internal/graphics/virtual_framebuffer.go b/internal/graphics/virtual_framebuffer.go new file mode 100644 index 0000000..27d3663 --- /dev/null +++ b/internal/graphics/virtual_framebuffer.go @@ -0,0 +1,193 @@ +package graphics + +import ( + "fmt" + + "github.com/go-gl/gl/v3.3-core/gl" +) + +const ( + VirtualWidth int32 = 1920 + VirtualHeight int32 = 1080 +) + +var ( + vfbo uint32 + vfboTexture uint32 + vfboDepthStencil uint32 + blitVAO uint32 + blitVBO uint32 + blitShaderProg uint32 + nativeW, nativeH int32 +) + +// InitVirtualFramebuffer creates the FBO at virtual resolution and the blit shader. +// Call after OpenGL context is created. +func InitVirtualFramebuffer(displayW, displayH int32) error { + nativeW = displayW + nativeH = displayH + + // --- FBO setup --- + gl.GenFramebuffers(1, &vfbo) + gl.BindFramebuffer(gl.FRAMEBUFFER, vfbo) + + gl.GenTextures(1, &vfboTexture) + gl.BindTexture(gl.TEXTURE_2D, vfboTexture) + gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, VirtualWidth, VirtualHeight, 0, gl.RGBA, gl.UNSIGNED_BYTE, nil) + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR) + gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR) + gl.FramebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, vfboTexture, 0) + + // Depth/stencil renderbuffer + gl.GenRenderbuffers(1, &vfboDepthStencil) + gl.BindRenderbuffer(gl.RENDERBUFFER, vfboDepthStencil) + gl.RenderbufferStorage(gl.RENDERBUFFER, gl.DEPTH24_STENCIL8, VirtualWidth, VirtualHeight) + gl.FramebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, vfboDepthStencil) + + if status := gl.CheckFramebufferStatus(gl.FRAMEBUFFER); status != gl.FRAMEBUFFER_COMPLETE { + return fmt.Errorf("virtual framebuffer incomplete: 0x%X", status) + } + + gl.BindFramebuffer(gl.FRAMEBUFFER, 0) + + // --- Fullscreen quad --- + vertices := []float32{ + // pos (x,y) texcoord (u,v) + -1, -1, 0, 0, + 1, -1, 1, 0, + -1, 1, 0, 1, + 1, 1, 1, 1, + } + + gl.GenVertexArrays(1, &blitVAO) + gl.GenBuffers(1, &blitVBO) + gl.BindVertexArray(blitVAO) + gl.BindBuffer(gl.ARRAY_BUFFER, blitVBO) + gl.BufferData(gl.ARRAY_BUFFER, len(vertices)*4, gl.Ptr(vertices), gl.STATIC_DRAW) + + gl.EnableVertexAttribArray(0) + gl.VertexAttribPointerWithOffset(0, 2, gl.FLOAT, false, 4*4, 0) + gl.EnableVertexAttribArray(1) + gl.VertexAttribPointerWithOffset(1, 2, gl.FLOAT, false, 4*4, 2*4) + + gl.BindVertexArray(0) + + // --- Blit shader --- + var err error + blitShaderProg, err = compileBlitShader() + if err != nil { + return fmt.Errorf("blit shader compilation failed: %w", err) + } + + return nil +} + +// BeginVirtualRender binds the FBO so all subsequent draws go to the virtual 1080p buffer. +func BeginVirtualRender() { + gl.BindFramebuffer(gl.FRAMEBUFFER, vfbo) + gl.Viewport(0, 0, VirtualWidth, VirtualHeight) +} + +// BlitToScreen draws the virtual buffer to the actual screen at native resolution. +func BlitToScreen() { + gl.BindFramebuffer(gl.FRAMEBUFFER, 0) + gl.Viewport(0, 0, nativeW, nativeH) + gl.ClearColor(0, 0, 0, 1) + gl.Clear(gl.COLOR_BUFFER_BIT) + + gl.UseProgram(blitShaderProg) + gl.ActiveTexture(gl.TEXTURE0) + gl.BindTexture(gl.TEXTURE_2D, vfboTexture) + + gl.BindVertexArray(blitVAO) + gl.DrawArrays(gl.TRIANGLE_STRIP, 0, 4) + gl.BindVertexArray(0) +} + +// DestroyVirtualFramebuffer cleans up all FBO resources. +func DestroyVirtualFramebuffer() { + if blitShaderProg != 0 { + gl.DeleteProgram(blitShaderProg) + } + if blitVBO != 0 { + gl.DeleteBuffers(1, &blitVBO) + } + if blitVAO != 0 { + gl.DeleteVertexArrays(1, &blitVAO) + } + if vfboDepthStencil != 0 { + gl.DeleteRenderbuffers(1, &vfboDepthStencil) + } + if vfboTexture != 0 { + gl.DeleteTextures(1, &vfboTexture) + } + if vfbo != 0 { + gl.DeleteFramebuffers(1, &vfbo) + } +} + +func compileBlitShader() (uint32, error) { + vertSrc := `#version 330 core +layout(location = 0) in vec2 aPos; +layout(location = 1) in vec2 aTexCoord; +out vec2 vTexCoord; +void main() { + vTexCoord = aTexCoord; + gl_Position = vec4(aPos, 0.0, 1.0); +}` + "\x00" + + fragSrc := `#version 330 core +in vec2 vTexCoord; +out vec4 FragColor; +uniform sampler2D screenTexture; +void main() { + FragColor = texture(screenTexture, vTexCoord); +}` + "\x00" + + vertShader, err := compileShader(vertSrc, gl.VERTEX_SHADER) + if err != nil { + return 0, err + } + fragShader, err := compileShader(fragSrc, gl.FRAGMENT_SHADER) + if err != nil { + return 0, err + } + + prog := gl.CreateProgram() + gl.AttachShader(prog, vertShader) + gl.AttachShader(prog, fragShader) + gl.LinkProgram(prog) + + var status int32 + gl.GetProgramiv(prog, gl.LINK_STATUS, &status) + if status == gl.FALSE { + var logLen int32 + gl.GetProgramiv(prog, gl.INFO_LOG_LENGTH, &logLen) + logStr := make([]byte, logLen) + gl.GetProgramInfoLog(prog, logLen, nil, &logStr[0]) + return 0, fmt.Errorf("shader link error: %s", string(logStr)) + } + + gl.DeleteShader(vertShader) + gl.DeleteShader(fragShader) + return prog, nil +} + +func compileShader(src string, shaderType uint32) (uint32, error) { + shader := gl.CreateShader(shaderType) + csrc, free := gl.Strs(src) + gl.ShaderSource(shader, 1, csrc, nil) + free() + gl.CompileShader(shader) + + var status int32 + gl.GetShaderiv(shader, gl.COMPILE_STATUS, &status) + if status == gl.FALSE { + var logLen int32 + gl.GetShaderiv(shader, gl.INFO_LOG_LENGTH, &logLen) + logStr := make([]byte, logLen) + gl.GetShaderInfoLog(shader, logLen, nil, &logStr[0]) + return 0, fmt.Errorf("shader compile error: %s", string(logStr)) + } + return shader, nil +} diff --git a/internal/keybinds/keybinds.go b/internal/keybinds/keybinds.go new file mode 100644 index 0000000..96b3636 --- /dev/null +++ b/internal/keybinds/keybinds.go @@ -0,0 +1,79 @@ +// package keybinds provides keybind functionality for the entire application +package keybinds + +import ( + "github.com/veandco/go-sdl2/sdl" +) + +// KeyCombo represents a combination of a key and it's active modifier. +type KeyCombo struct { + Key sdl.Keycode + Mod sdl.Keymod +} + +// Binds contains all currently registered Keybinds. +var Binds = make(map[KeyCombo]func()) + +// Enabled controls whether PerformAction dispatches keybinds. Set to false +// to temporarily suppress all global keybinds (e.g. during a modal page). +var Enabled = true + +// Regiser registers a new keybind in Binds +func Register(k sdl.Keycode, m sdl.Keymod, action func()) { + mod := NormalizeModifiers(m) + newCombo := KeyCombo{k, mod} + _, ok := Binds[newCombo] + if ok { + } + Binds[newCombo] = action +} + +// BindKey adds a new KeyCombo and Function (the action to take) to the keybinds.Binds +func BindKey(k KeyCombo, f func()) { + k.Mod = NormalizeModifiers(k.Mod) + Binds[k] = f +} + +// UnbindKey removes a KeyCombo from the available binds +func UnbindKey(k KeyCombo) { + k.Mod = NormalizeModifiers(k.Mod) + delete(Binds, k) +} + +func PerformAction(event sdl.Event) { + if !Enabled { + return + } + switch e := event.(type) { + case *sdl.KeyboardEvent: + if e.Type == sdl.KEYDOWN { + key := e.Keysym.Sym + rawMod := e.Keysym.Mod + mod := NormalizeModifiers(sdl.Keymod(rawMod)) + combo := KeyCombo{key, mod} + action, ok := Binds[combo] + if ok { + action() + } + } + } +} + +// NormalizeModifiers converts a raw SDL modifier bitmask into a canonical form +// focusing on common modifiers (SHIFT, CTRL, ALT, GUI) and ignoring others like CapsLock. +func NormalizeModifiers(mod sdl.Keymod) sdl.Keymod { + var normalized sdl.Keymod = sdl.KMOD_NONE + if mod&sdl.KMOD_SHIFT != 0 { + normalized |= sdl.KMOD_SHIFT + } + if mod&sdl.KMOD_CTRL != 0 { + normalized |= sdl.KMOD_CTRL + } + if mod&sdl.KMOD_ALT != 0 { + normalized |= sdl.KMOD_ALT + } + if mod&sdl.KMOD_GUI != 0 { + normalized |= sdl.KMOD_GUI + } + return normalized +} diff --git a/internal/license/license.go b/internal/license/license.go new file mode 100644 index 0000000..dbee2cf --- /dev/null +++ b/internal/license/license.go @@ -0,0 +1,73 @@ +package license + +import ( + "encoding/json" + "fmt" + "net/http" + "net/url" + "path" + "time" +) + +var Level int + +type Validator struct { + client *http.Client + apiURL string + apiPath string +} + +type Response struct { + Key string `json:"key"` + Email string `json:"email"` + Active bool `json:"active"` + Type string `json:"type"` + Level string `json:"level"` + LastCheck time.Time `json:"lastCheck"` + NewCheck time.Time `json:"newCheck"` +} + +func NewValidator(apiURL, apiPath string) *Validator { + return &Validator{ + client: &http.Client{ + Timeout: 10 * time.Second, + Transport: &http.Transport{ + MaxIdleConns: 10, + IdleConnTimeout: 30 * time.Second, + DisableCompression: true, + }, + }, + apiURL: apiURL, + apiPath: apiPath, + } +} + +func (v *Validator) Validate(key, email string) (*Response, error) { + u, err := url.Parse(v.apiURL) + if err != nil { + return nil, err + } + u.Path = path.Join(u.Path, v.apiPath) + + q := u.Query() + q.Set("licenseKey", key) + q.Set("emailAddress", email) + u.RawQuery = q.Encode() + + resp, err := v.client.Get(u.String()) + if err != nil { + return nil, fmt.Errorf("request failed: %w", err) + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("unexpected status: %w", err) + } + + var result Response + if err := json.NewDecoder(resp.Body).Decode(&result); err != nil { + return nil, fmt.Errorf("failed ot decode response: %w", err) + } + + return &result, nil +} diff --git a/internal/logger/logger.go b/internal/logger/logger.go new file mode 100644 index 0000000..39f06f7 --- /dev/null +++ b/internal/logger/logger.go @@ -0,0 +1,138 @@ +package logger + +import ( + "fmt" + "log" + "os" + "sync" + "time" + + "gorm.io/gorm" +) + +type Level int + +const ( + LevelDebug Level = iota + LevelInfo + LevelWarning + LevelError + LevelFatal +) + +func (l Level) String() string { + return [...]string{"DEBUG", "INFO", "WARNING", "ERROR", "FATAL"}[l] +} + +type logEntry struct { + timestamp string + level string + message string +} + +var ( + mu sync.Mutex + db *gorm.DB + file *os.File + console = log.New(os.Stderr, "", 0) + + dbChan chan logEntry + dbChanOnce sync.Once +) + +// startDBWriter starts a single background goroutine to drain log entries to the database. +func startDBWriter() { + dbChan = make(chan logEntry, 256) + go func() { + for entry := range dbChan { + row := map[string]any{ + "timestamp": entry.timestamp, + "level": entry.level, + "message": entry.message, + } + if err := db.Table("log_entries").Create(row).Error; err != nil { + mu.Lock() + console.Printf("Failed to write log to database: %v", err) + mu.Unlock() + } + } + }() +} + +// AddFile attaches or replaces the file backend +func AddFile(path string) error { + mu.Lock() + defer mu.Unlock() + + if file != nil { + file.Close() + } + + f, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644) + if err != nil { + return err + } + file = f + return nil +} + +// AddDatabase attaches or replaces the database backend +func AddDatabase(d *gorm.DB) { + mu.Lock() + defer mu.Unlock() + db = d + dbChanOnce.Do(startDBWriter) +} + +// Close shuts down the database writer goroutine and closes the file backend. +func Close() error { + mu.Lock() + defer mu.Unlock() + + // Stop the DB writer goroutine by closing the channel + if dbChan != nil { + close(dbChan) + dbChan = nil + db = nil + } + + if file != nil { + err := file.Close() + file = nil + return err + } + return nil +} + +func logMsg(level Level, format string, args ...any) { + message := fmt.Sprintf(format, args...) + timestamp := time.Now().Format("2006-01-02 15:04:05.000") + line := fmt.Sprintf("%s [%s] %s", timestamp, level, message) + + mu.Lock() + console.Println(line) + + if file != nil { + fmt.Fprintln(file, line) + } + + if db != nil && dbChan != nil { // both cleared by Close() + select { + case dbChan <- logEntry{timestamp: timestamp, level: level.String(), message: message}: + default: + // Channel full, drop the DB write rather than blocking + } + } + mu.Unlock() +} + +func Debug(format string, args ...any) { logMsg(LevelDebug, format, args...) } +func Info(format string, args ...any) { logMsg(LevelInfo, format, args...) } +func Warning(format string, args ...any) { logMsg(LevelWarning, format, args...) } +func Error(format string, args ...any) { logMsg(LevelError, format, args...) } + +func Fatal(format string, args ...any) { + logMsg(LevelFatal, format, args...) + time.Sleep(100 * time.Millisecond) + os.Exit(1) +} diff --git a/internal/mixer/mixer.go b/internal/mixer/mixer.go new file mode 100644 index 0000000..5a8279f --- /dev/null +++ b/internal/mixer/mixer.go @@ -0,0 +1,346 @@ +// internal/audio/mixer/mixer.go +package mixer + +import ( + "errors" + "fmt" + "strconv" + "sync" + + "github.com/veandco/go-sdl2/mix" + "github.com/veandco/go-sdl2/sdl" + "rhemawavetech.com/rhemawave/internal/db" + "rhemawavetech.com/rhemawave/internal/logger" +) + +var ( + mu sync.Mutex + inited bool + deviceOpen bool + deviceName string + + currentMusic *mix.Music + currentPath string + currentLoops int // 0 = once, -1 = forever + currentVolume int // 0..128, defaults to MAX_VOLUME + + // Config knobs (could be made public or read from your config) + defaultFreq = 48000 + defaultFormat = uint16(sdl.AUDIO_F32) + defaultChannels = 2 + defaultChunkSize = 1024 + defaultAllow = sdl.AUDIO_ALLOW_ANY_CHANGE +) + +// Init initializes SDL audio + SDL_mixer. Safe to call multiple times. +func Init(wantedDevice string) error { + mu.Lock() + defer mu.Unlock() + if inited { + return nil + } + + // Let SDL choose the best audio driver for the system + // Remove hardcoded ALSA preference to support PulseAudio, PipeWire, etc. + // Users can set SDL_AUDIODRIVER environment variable if needed + + if err := sdl.InitSubSystem(sdl.INIT_AUDIO); err != nil { + return fmt.Errorf("SDL audio init failed: %w", err) + } + + // WAV-only does not require mix.Init(); add when you support OGG/MP3/etc. + if err := openDeviceLocked(wantedDevice); err != nil { + // Clean up the subsystem on failure so callers can retry later. + sdl.QuitSubSystem(sdl.INIT_AUDIO) + return err + } + + // Check if the volume is stored in the config; if not, default to max. + storedVolume, err := db.GetConfigValue("last_volume") + if err != nil { + return fmt.Errorf("retrieving last_volume from config: %w", err) + } + + lastVolume, err := strconv.Atoi(storedVolume) + if err != nil { + return fmt.Errorf("parsing last_volume %q: %w", storedVolume, err) + } + + if lastVolume < 0 { + lastVolume = int(mix.MAX_VOLUME) + currentVolume = lastVolume + if err := db.SetConfigValue("last_volume", strconv.Itoa(lastVolume)); err != nil { + } + } else { + currentVolume = lastVolume + } + + // mix.VolumeMusic(currentVolume) + + inited = true + return nil +} + +// openDeviceLocked tries to open the named device; if it fails and the name wasn't empty, falls back to default. +func openDeviceLocked(name string) error { + if err := mix.OpenAudioDevice(defaultFreq, defaultFormat, defaultChannels, defaultChunkSize, name, defaultAllow); err != nil { + if name != "" { + // Log the failure of the requested device + + // Fallback to default device + if err2 := mix.OpenAudioDevice(defaultFreq, defaultFormat, defaultChannels, defaultChunkSize, "", defaultAllow); err2 != nil { + return fmt.Errorf("failed to open device %q and default device: %w", name, err2) + } + deviceName = "" // actually opened default + } else { + return fmt.Errorf("failed to open default audio device: %w", err) + } + } else { + if name != "" { + } else { + } + deviceName = name + } + deviceOpen = true + return nil +} + +// Play loads a WAV (as music) and plays it. If loopForever is true, loops forever. +// If something is already playing, it stops and replaces it. +func Play(path string, loopForever bool) error { + if !db.AudioEnabled() { + return nil + } + + mu.Lock() + defer mu.Unlock() + + if !inited || !deviceOpen { + return errors.New("audio mixer not initialized") + } + if path == "" { + return errors.New("empty audio path") + } + + // Stop and free any prior music + mix.HaltMusic() + if currentMusic != nil { + currentMusic.Free() + currentMusic = nil + } + + m, err := mix.LoadMUS(path) + if err != nil { + return fmt.Errorf("LoadMUS(%q): %w", path, err) + } + currentMusic = m + currentPath = path + if loopForever { + currentLoops = -1 + } else { + currentLoops = 0 + } + + // Open the device + if err := openDeviceLocked(deviceName); err != nil { + logger.Error("Failed to open device: %w", err) + } + + // Apply remembered volume + mix.VolumeMusic(currentVolume) + + if err := currentMusic.Play(currentLoops); err != nil { + currentMusic.Free() + currentMusic = nil + return fmt.Errorf("music.Play: %w", err) + } + return nil +} + +// Stop stops playback. If fadeMs > 0, fades out asynchronously; otherwise halts immediately. +// It also frees the currently loaded music (so a new Play will reload). +func Stop(fadeMs int) { + if !db.AudioEnabled() { + return + } + + mu.Lock() + defer mu.Unlock() + if !inited { + return + } + + if fadeMs > 0 && mix.PlayingMusic() { + _ = mix.FadeOutMusic(fadeMs) // async fade; we’ll still free below + } + + mix.HaltMusic() + if currentMusic != nil { + currentMusic.Free() + currentMusic = nil + } + currentPath = "" + currentLoops = 0 +} + +// SetVolume128 sets music volume using SDL_mixer’s 0..128 scale. +func SetVolume128(increment int) { + if !db.AudioEnabled() { + return + } + + mu.Lock() + defer mu.Unlock() + + currentVolume += increment + + if currentVolume < 0 { + currentVolume = 0 + } else if currentVolume > mix.MAX_VOLUME { + currentVolume = int(mix.MAX_VOLUME) + } + + // Store in config + if err := db.SetConfigValue("last_volume", strconv.Itoa(currentVolume)); err != nil { + } + + // Apply to SDL_mixer + if inited && deviceOpen { + mix.VolumeMusic(currentVolume) + } +} + +// IsPlaying reports whether music is currently playing (or fading). +func IsPlaying() bool { + mu.Lock() + defer mu.Unlock() + if !inited { + return false + } + return mix.PlayingMusic() +} + +// ListDevices returns the list of available output device names (from core SDL). +func ListDevices() []string { + mu.Lock() + defer mu.Unlock() + n := sdl.GetNumAudioDevices(false) + if n <= 0 { + return nil + } + out := make([]string, 0, n) + for i := 0; i < n; i++ { + if name := sdl.GetAudioDeviceName(i, false); name != "" { + out = append(out, name) + } + } + return out +} + +// CurrentDevice returns the last requested/opened device name ("" means default). +func CurrentDevice() string { + mu.Lock() + defer mu.Unlock() + return deviceName +} + +// SwitchDevice switches output devices, preserving volume and resuming playback of the current track/loop state if any. +func SwitchDevice(newName string) error { + mu.Lock() + defer mu.Unlock() + + if !inited { + return errors.New("audio mixer not initialized") + } + + // Log device switch attempt + oldDevice := deviceName + if oldDevice == "" { + oldDevice = "system default" + } + newDeviceLog := newName + if newDeviceLog == "" { + newDeviceLog = "system default" + } + + // Capture current state + wasPlaying := mix.PlayingMusic() + savedPath := currentPath + savedLoops := currentLoops + savedVolume := currentVolume + + // Stop and release current music before reopening device + if wasPlaying { + } + mix.HaltMusic() + if currentMusic != nil { + currentMusic.Free() + currentMusic = nil + } + currentPath = "" + currentLoops = 0 + + // Close and reopen device + if deviceOpen { + mix.CloseAudio() + deviceOpen = false + } + if err := openDeviceLocked(newName); err != nil { + // Best effort: try to reopen the previous device (or default) so we don't leave audio dead + if restoreErr := openDeviceLocked(oldDevice); restoreErr != nil { + } else { + } + return err + } + + // Restore volume + mix.VolumeMusic(savedVolume) + + // Optionally resume previous track if there was one + if wasPlaying && savedPath != "" { + m, err := mix.LoadMUS(savedPath) + if err != nil { + // Don't fail the device switch just because reload failed + return fmt.Errorf("device switched, but reloading %q failed: %w", savedPath, err) + } + currentMusic = m + currentPath = savedPath + currentLoops = savedLoops + if err := currentMusic.Play(currentLoops); err != nil { + currentMusic.Free() + currentMusic = nil + currentPath = "" + currentLoops = 0 + return fmt.Errorf("device switched, but restarting playback failed: %w", err) + } + } + + return nil +} + +func GetVolume128() int { + mu.Lock() + defer mu.Unlock() + return currentVolume +} + +// Shutdown fully tears everything down. Call at app exit. +func Shutdown() { + mu.Lock() + defer mu.Unlock() + + mix.HaltMusic() + if currentMusic != nil { + currentMusic.Free() + currentMusic = nil + } + if deviceOpen { + mix.CloseAudio() + deviceOpen = false + } + // If you add mix.Init(decoderFlags) in the future, pair it with mix.Quit() here. + if inited { + sdl.QuitSubSystem(sdl.INIT_AUDIO) + inited = false + } +} diff --git a/internal/network/network.go b/internal/network/network.go new file mode 100644 index 0000000..a99f611 --- /dev/null +++ b/internal/network/network.go @@ -0,0 +1,428 @@ +// Package network provides a high-level utility for managing network +// connections via the system's D-Bus and NetworkManager. +package network + +import ( + "errors" + "fmt" + "log" + "net" + "sort" + "strings" + "time" + + "github.com/godbus/dbus/v5" + "github.com/google/uuid" +) + +// --- D-Bus NetworkManager Constants --- +const ( + nmService = "org.freedesktop.NetworkManager" + nmPath = "/org/freedesktop/NetworkManager" + nmInterface = "org.freedesktop.NetworkManager" + nmDeviceInterface = "org.freedesktop.NetworkManager.Device" + nmWirelessDeviceInterface = "org.freedesktop.NetworkManager.Device.Wireless" + nmAPInterface = "org.freedesktop.NetworkManager.AccessPoint" + + nmDeviceTypeEthernet uint32 = 1 + nmDeviceTypeWifi uint32 = 2 + nmDeviceStateActivated uint32 = 100 + APFlagsPrivacy uint32 = 0x00000001 // Equivalent to NM_802_11_AP_FLAGS_PRIVACY + APSecKeyMgmtEAP uint32 = 0x00000020 + APSecKeyMgmtPSK uint32 = 0x00000100 + APSecKeyMgmtOWE uint32 = 0x00000200 + APSecKeyMgmtSAE uint32 = 0x00000400 +) + +// ErrScanAborted is returned when a scan is cancelled via the stop channel. +var ErrScanAborted = errors.New("network scan aborted by caller") + +// Status defines the type for various connection status codes. +type Status int + +const ( + StatusError Status = iota + StatusNoDevicesFound + StatusWifiAvailableNotConnected + StatusWifiConnectedNoInternet + StatusWifiConnectedInternetUp + StatusEthernetNotConnected + StatusEthernetConnectedNoInternet + StatusEthernetConnectedInternetUp +) + +// ConnectionStatus holds the detailed result of a connectivity check. +type ConnectionStatus struct { + StatusCode Status + Message string +} + +// DeviceType defines the kind of network device. +type DeviceType int + +const ( + TypeUnknown DeviceType = iota + TypeEthernet + TypeWifi +) + +// Device holds information about a single network device. +type Device struct { + Path dbus.ObjectPath + InterfaceName string + Type DeviceType + State uint32 +} + +// Manager handles all D-Bus communication with NetworkManager. +type Manager struct { + conn *dbus.Conn + nmObject dbus.BusObject + Devices []Device +} + +// AccessPoint holds essential information about a discovered Wi-Fi network. +type AccessPoint struct { + ObjectPath dbus.ObjectPath + SSID string + Strength byte + IsProtected bool + IsActive bool + WpaFlags uint32 + RsnFlags uint32 +} + +// New creates a new network Manager and connects to the system D-Bus. +func New() (*Manager, error) { + conn, err := dbus.ConnectSystemBus() + if err != nil { + return nil, fmt.Errorf("failed to connect to system bus: %w", err) + } + nmObject := conn.Object(nmService, nmPath) + return &Manager{conn: conn, nmObject: nmObject}, nil +} + +// Conn returns the underlying dbus.Conn for advanced queries. +func (m *Manager) Conn() *dbus.Conn { + return m.conn +} + +// Close disconnects from the D-Bus. +func (m *Manager) Close() { + if m.conn != nil { + m.conn.Close() + } +} + +// FindDevices scans the system for all available network devices (Ethernet and Wi-Fi). +func (m *Manager) FindDevices() error { + var devicePaths []dbus.ObjectPath + call := m.nmObject.Call(nmInterface+".GetDevices", 0) + if call.Err != nil { + return fmt.Errorf("GetDevices D-Bus call failed: %w", call.Err) + } + if err := call.Store(&devicePaths); err != nil { + return fmt.Errorf("could not parse device list: %w", err) + } + + m.Devices = []Device{} + for _, path := range devicePaths { + deviceObj := m.conn.Object(nmService, path) + typeVariant, err := deviceObj.GetProperty(nmDeviceInterface + ".DeviceType") + if err != nil { + log.Printf("network: Skipping device %s, could not get DeviceType: %v", path, err) + continue + } + deviceType, _ := typeVariant.Value().(uint32) + + var newDevice Device + switch deviceType { + case nmDeviceTypeEthernet: + newDevice.Type = TypeEthernet + case nmDeviceTypeWifi: + newDevice.Type = TypeWifi + default: + continue + } + + newDevice.Path = path + ifaceVariant, _ := deviceObj.GetProperty(nmDeviceInterface + ".Interface") + newDevice.InterfaceName, _ = ifaceVariant.Value().(string) + stateVariant, _ := deviceObj.GetProperty(nmDeviceInterface + ".State") + newDevice.State, _ = stateVariant.Value().(uint32) + m.Devices = append(m.Devices, newDevice) + } + return nil +} + +// CheckInternetConnection performs a comprehensive check for an active internet connection. +func (m *Manager) CheckInternetConnection() (*ConnectionStatus, error) { + if err := m.FindDevices(); err != nil { + return &ConnectionStatus{StatusError, "Failed to scan for network devices"}, err + } + if len(m.Devices) == 0 { + return &ConnectionStatus{StatusNoDevicesFound, "No network hardware found."}, nil + } + + hasWifiAdapter := false + hasEthernetAdapter := false + + for _, device := range m.Devices { + if device.Type == TypeEthernet { + hasEthernetAdapter = true + if device.State == nmDeviceStateActivated { + if pingTest() { + return &ConnectionStatus{StatusEthernetConnectedInternetUp, "Ethernet connected with internet access."}, nil + } + return &ConnectionStatus{StatusEthernetConnectedNoInternet, "Ethernet connected, but no internet access."}, nil + } + } + } + + for _, device := range m.Devices { + if device.Type == TypeWifi { + hasWifiAdapter = true + if device.State == nmDeviceStateActivated { + if pingTest() { + return &ConnectionStatus{StatusWifiConnectedInternetUp, "Wi-Fi connected with internet access."}, nil + } + return &ConnectionStatus{StatusWifiConnectedNoInternet, "Wi-Fi connected, but no internet access."}, nil + } + } + } + + if hasWifiAdapter { + return &ConnectionStatus{StatusWifiAvailableNotConnected, "Wi-Fi adapter is available but not connected."}, nil + } + if hasEthernetAdapter { + return &ConnectionStatus{StatusEthernetNotConnected, "Ethernet adapter is available but not connected."}, nil + } + + return &ConnectionStatus{StatusNoDevicesFound, "No recognizable network hardware found."}, nil +} + +// StartScan performs a Wi-Fi scan asynchronously. The optional stopChan can be used to abort. +func (m *Manager) StartScan(resultsChan chan<- []AccessPoint, errorChan chan<- error, stopChan <-chan struct{}) { + var wifiDevice *Device + for i := range m.Devices { + if m.Devices[i].Type == TypeWifi { + wifiDevice = &m.Devices[i] + break + } + } + if wifiDevice == nil { + errorChan <- fmt.Errorf("no Wi-Fi device available for scanning") + return + } + + // Ensure Wi-Fi is enabled + nmObj := m.conn.Object(nmService, nmPath) + prop, err := nmObj.GetProperty(nmInterface + ".WirelessEnabled") + if err != nil { + errorChan <- fmt.Errorf("could not read WirelessEnabled property: %w", err) + return + } + if !prop.Value().(bool) { + call := nmObj.Call("org.freedesktop.DBus.Properties.Set", 0, + nmInterface, + "WirelessEnabled", + dbus.MakeVariant(true), + ) + if call.Err != nil { + errorChan <- fmt.Errorf("could not enable Wi-Fi: %w", call.Err) + return + } + time.Sleep(2 * time.Second) // Give NetworkManager time to bring up the device + } + + // Request a scan + wifiDeviceWireless := m.conn.Object(nmService, wifiDevice.Path) + call := wifiDeviceWireless.Call(nmWirelessDeviceInterface+".RequestScan", 0, make(map[string]dbus.Variant)) + if call.Err != nil { + errorChan <- fmt.Errorf("scan request failed: %w", call.Err) + return + } + + select { + case <-time.After(3 * time.Second): + case <-stopChan: + errorChan <- ErrScanAborted + return + } + + var apPaths []dbus.ObjectPath + call = wifiDeviceWireless.Call(nmWirelessDeviceInterface+".GetAllAccessPoints", 0) + if call.Err != nil { + errorChan <- fmt.Errorf("could not retrieve network list: %w", call.Err) + return + } + if err := call.Store(&apPaths); err != nil { + errorChan <- fmt.Errorf("could not parse network list: %w", err) + return + } + + processedAPs, err := m.scanAccessPoints(apPaths) + if err != nil { + errorChan <- err + return + } + resultsChan <- processedAPs +} + +// scanAccessPoints filters and sorts the raw list of D-Bus AP paths. +func (m *Manager) scanAccessPoints(apPaths []dbus.ObjectPath) ([]AccessPoint, error) { + tempNetworkMap := make(map[string]AccessPoint) + for _, apPath := range apPaths { + apObj := m.conn.Object(nmService, apPath) + props, err := m.getAllProperties(apObj, nmAPInterface) + if err != nil { + log.Printf("network: Failed to get properties for AP %s: %v", apPath, err) + continue + } + + ssidBytes, _ := props["Ssid"].Value().([]byte) + if len(ssidBytes) == 0 { + continue + } + + ssidStr := string(ssidBytes) + strength, _ := props["Strength"].Value().(byte) + flags, _ := props["Flags"].Value().(uint32) + wpaFlags, _ := props["WpaFlags"].Value().(uint32) + rsnFlags, _ := props["RsnFlags"].Value().(uint32) + + isProtected := (flags&APFlagsPrivacy != 0) || (wpaFlags != 0) || (rsnFlags != 0) + + currentAP := AccessPoint{ + ObjectPath: apPath, + SSID: ssidStr, + Strength: strength, + IsProtected: isProtected, + WpaFlags: wpaFlags, + RsnFlags: rsnFlags, + } + if existingAP, ok := tempNetworkMap[ssidStr]; !ok || strength > existingAP.Strength { + tempNetworkMap[ssidStr] = currentAP + } + } + + networkList := make([]AccessPoint, 0, len(tempNetworkMap)) + for _, ap := range tempNetworkMap { + networkList = append(networkList, ap) + } + sort.Slice(networkList, func(i, j int) bool { + if networkList[i].Strength != networkList[j].Strength { + return networkList[i].Strength > networkList[j].Strength + } + return strings.ToLower(networkList[i].SSID) < strings.ToLower(networkList[j].SSID) + }) + return networkList, nil +} + +// Connect attempts to connect a Wi-Fi device to a given access point. +func (m *Manager) Connect(wifiDevice Device, ap AccessPoint, passphrase string) error { + if wifiDevice.Type != TypeWifi { + return fmt.Errorf("cannot connect: provided device is not a Wi-Fi device") + } + + settings := map[string]map[string]dbus.Variant{ + "connection": { + "type": dbus.MakeVariant("802-11-wireless"), + "uuid": dbus.MakeVariant(uuid.NewString()), + "id": dbus.MakeVariant(ap.SSID), + "interface-name": dbus.MakeVariant(wifiDevice.InterfaceName), + }, + "802-11-wireless": { + "ssid": dbus.MakeVariant([]byte(ap.SSID)), + "mode": dbus.MakeVariant("infrastructure"), + }, + } + + if ap.IsProtected { + settings["802-11-wireless"]["security"] = dbus.MakeVariant("802-11-wireless-security") + secSettings := make(map[string]dbus.Variant) + + // Default to WPA-PSK, but override with more specific types if found. + secSettings["key-mgmt"] = dbus.MakeVariant("wpa-psk") + if (ap.RsnFlags & APSecKeyMgmtSAE) != 0 { + secSettings["key-mgmt"] = dbus.MakeVariant("sae") // WPA3 + } else if (ap.RsnFlags&APSecKeyMgmtEAP) != 0 || (ap.WpaFlags&APSecKeyMgmtEAP) != 0 { + log.Println("network: Enterprise AP (EAP) detected. Full configuration may be required.") + secSettings["key-mgmt"] = dbus.MakeVariant("wpa-eap") + } + + secSettings["psk"] = dbus.MakeVariant(passphrase) + settings["802-11-wireless-security"] = secSettings + } + + call := m.nmObject.Call(nmInterface+".AddAndActivateConnection", 0, settings, wifiDevice.Path, ap.ObjectPath) + if call.Err != nil { + return fmt.Errorf("AddAndActivateConnection D-Bus call error: %w", call.Err) + } + return nil +} + +// pingTest performs a simple DNS lookup to check for internet connectivity. +func pingTest() bool { + _, err := net.LookupHost("www.google.com") + return err == nil +} + +// getAllProperties is a helper to fetch all properties for a D-Bus object interface. +func (m *Manager) getAllProperties(obj dbus.BusObject, iface string) (map[string]dbus.Variant, error) { + var props map[string]dbus.Variant + call := obj.Call("org.freedesktop.DBus.Properties.GetAll", 0, iface) + if call.Err != nil { + return nil, call.Err + } + if err := call.Store(&props); err != nil { + return nil, err + } + return props, nil +} + +// WaitForInternet blocks until CheckInternetConnection reports Internet up, +// or until maxWait elapses. When it first sees "up", it requires that state +// to be stable for at least 'stableFor' before returning success to avoid flapping. +func (m *Manager) WaitForInternet(maxWait, stableFor time.Duration) (*ConnectionStatus, error) { + deadline := time.Now().Add(maxWait) + var lastErr error + var lastStatus *ConnectionStatus + var upSince time.Time + + // Reasonable poll cadence; NM typically completes within a few seconds. + const poll = 500 * time.Millisecond + + for time.Now().Before(deadline) { + st, err := m.CheckInternetConnection() + if err != nil { + lastErr = err + lastStatus = &ConnectionStatus{StatusError, "NetworkManager not ready"} + upSince = time.Time{} // reset stability + } else { + lastStatus = st + switch st.StatusCode { + case StatusEthernetConnectedInternetUp, StatusWifiConnectedInternetUp: + if upSince.IsZero() { + upSince = time.Now() + } + if time.Since(upSince) >= stableFor { + return st, nil // stable "up" + } + default: + // not up; keep waiting + upSince = time.Time{} + } + } + time.Sleep(poll) + } + + // Timed out; return the last observed status and error (if any). + if lastStatus == nil { + lastStatus = &ConnectionStatus{StatusError, "Timed out waiting for connectivity"} + } + if lastErr != nil { + return lastStatus, fmt.Errorf("timeout waiting for internet: %w", lastErr) + } + return lastStatus, nil +} diff --git a/internal/page/audioDevices.go b/internal/page/audioDevices.go new file mode 100644 index 0000000..325b80a --- /dev/null +++ b/internal/page/audioDevices.go @@ -0,0 +1,273 @@ +package page + +import ( + "fmt" + "strconv" + + "github.com/go-gl/gl/v3.3-core/gl" + "github.com/veandco/go-sdl2/sdl" + "rhemawavetech.com/rhemawave/internal/colors" + "rhemawavetech.com/rhemawave/internal/db" + "rhemawavetech.com/rhemawave/internal/fontManager" + "rhemawavetech.com/rhemawave/internal/mixer" + "rhemawavetech.com/rhemawave/internal/shaderManager" +) + +type AudioDevices struct { + Base + font *fontManager.FontEntry + textShader *shaderManager.Shader + solidShader *shaderManager.Shader + title StringItem + prompt StringItem + devices []StringItem + highlightIndex int + selectedIndex int + verticalMargin int32 +} + +func (p *AudioDevices) Init(app ApplicationInterface) error { + var err error + p.verticalMargin = int32(20) + + // Get font + fm := fontManager.Get() + font, ok := fm.GetFont("Roboto-Regular") + if !ok { + return fmt.Errorf("failed to get font: %w", sdl.GetError()) + } + p.font = font + + // Get shaders + sm := shaderManager.Get() + p.textShader, ok = sm.Get("text") + if !ok { + return fmt.Errorf("failed to get text shader: %w", sdl.GetError()) + } + p.solidShader, ok = sm.Get("solid_color") + if !ok { + return fmt.Errorf("failed to get solid_color shader: %w", sdl.GetError()) + } + + // Initialize base + if err := p.Base.Init(app); err != nil { + return fmt.Errorf("base init failed: %w", err) + } + + // Get font size from database + baseFontSizeStr, err := db.GetConfigValue("init_font_size") + if err != nil { + return fmt.Errorf("retrieving init_font_size from db: %w", err) + } + baseFontSize, err := strconv.Atoi(baseFontSizeStr) + if err != nil { + return fmt.Errorf("parsing init_font_size %q: %w", baseFontSizeStr, err) + } + + // Calculate scales + titleScale := float32(64) / float32(baseFontSize) + itemScale := float32(32) / float32(baseFontSize) + + // Create title + p.title, err = NewStringItem("Select an Audio Output Device", p.font, colors.White) + if err != nil { + return fmt.Errorf("creating title: %w", err) + } + p.title.Scale(titleScale) + + // Create prompt + p.prompt, err = NewStringItem("Use Arrow Keys to select, Enter to confirm", p.font, colors.White) + if err != nil { + return fmt.Errorf("creating prompt: %w", err) + } + p.prompt.Scale(itemScale) + + // Get list of audio output devices + devices := mixer.ListDevices() + if len(devices) == 0 { + // Create a default entry so the page doesn't break + devices = []string{"System Default"} + } + + // Get currently selected device from database + currentDevice, err := db.GetConfigValue("audio_device_name") + if err != nil { + return fmt.Errorf("retrieving audio_device_name from db: %w", err) + } + + // Create UI items for each device + for i, name := range devices { // Iterate over the devices + item, err := NewStringItem(name, p.font, colors.White) // Create a new string string texture + if err != nil { + return fmt.Errorf("failed to create device item name: %w", err) + } + item.Scale(itemScale) // Scale the new string item + p.devices = append(p.devices, item) // Add the new scaled string item to the list of items + + // Mark currently selected device + if name == currentDevice { + p.selectedIndex = i + p.highlightIndex = i // Start with cursor on current device + } + } + + on, err := db.GetConfigValue("audio_enabled") + if err != nil { + return fmt.Errorf("unable to query database for audio_enabled: %w", err) + } + + audioStatus := "Turn Audio On" + if on == "true" { + audioStatus = "Turn Audio Off" + } + + audioStatusStringItem, err := NewStringItem(audioStatus, p.font, colors.White) + if err != nil { + return fmt.Errorf("failed to create Turn Audio Off string item: %w", err) + } + + // Scale the new option + audioStatusStringItem.Scale(itemScale) + + p.devices = append(p.devices, audioStatusStringItem) + + p.layout() + return nil +} + +func (p *AudioDevices) layout() { + // Position title at bottom + p.title.X = p.ScreenCenterX - p.title.W/2 + p.title.Y = p.ScreenHeight - p.title.H - p.verticalMargin*2 + + // Position prompt above title + p.prompt.X = p.ScreenCenterX - p.prompt.W/2 + p.prompt.Y = p.title.Y - p.verticalMargin*2 - p.prompt.H + + // Position device items stacked upward from prompt + for i := range p.devices { + p.devices[i].X = p.ScreenCenterX - p.devices[i].W/2 + if i == 0 { + p.devices[i].Y = p.prompt.Y - p.verticalMargin*2 - p.devices[i].H + } else { + p.devices[i].Y = p.devices[i-1].Y - p.devices[i].H - 10 + } + } +} + +func (p *AudioDevices) HandleEvent(event *sdl.Event) error { + e, ok := (*event).(*sdl.KeyboardEvent) + if !ok || e.Type != sdl.KEYDOWN { + return nil + } + + switch e.Keysym.Sym { + case sdl.K_UP: + if p.highlightIndex > 0 { + p.highlightIndex-- + } + + case sdl.K_DOWN: + if p.highlightIndex < len(p.devices)-1 { + p.highlightIndex++ + } + + case sdl.K_RETURN: + selection := p.devices[p.highlightIndex].content + + // Handle audio disable + if selection == "Turn Audio Off" || selection == "Turn Audio On" { + on, err := db.GetConfigValue("audio_enabled") + if err != nil { + return fmt.Errorf("failed to fetch audio_enabled from database: %w", err) + } + + currentStatus, err := strconv.ParseBool(on) + if err != nil { + return fmt.Errorf("failed to parse audio_enabled value: %w", err) + } + + newStatus := strconv.FormatBool(!currentStatus) + if err := db.SetConfigValue("audio_enabled", newStatus); err != nil { + return fmt.Errorf("failed to update audio_enabled: %w", err) + } + + p.App.UnwindToPage(&Settings{}) + return nil + } + + // Map "System Default" to empty string for SDL + deviceName := selection + if selection == "System Default" { + deviceName = "" + } + + // Validate by attempting the switch + if err := mixer.SwitchDevice(deviceName); err != nil { + return fmt.Errorf("failed to switch to device %q: %w", selection, err) + } + + // Save settings + if err := db.SetConfigValue("audio_device_name", deviceName); err != nil { + return fmt.Errorf("failed to save audio device: %w", err) + } + if err := db.SetConfigValue("audio_enabled", "true"); err != nil { + return fmt.Errorf("failed to enable audio: %w", err) + } + + p.App.UnwindToPage(&Settings{}) + + case sdl.K_BACKSPACE: + p.App.UnwindToPage(&Settings{}) + } + + return nil +} + +func (p *AudioDevices) Render() error { + // Always render title and prompt + p.RenderTexture(p.textShader, p.title.ID, p.title.Position(), p.title.RawDimensions(), p.title.Color) + p.RenderTexture(p.textShader, p.prompt.ID, p.prompt.Position(), p.prompt.RawDimensions(), p.prompt.Color) + + // No devices to display + if len(p.devices) == 0 { + return nil + } + + // Render highlight box behind highlighted item + p.RenderSolidColorQuad( + p.solidShader, + p.devices[p.highlightIndex].Position(), + p.devices[p.highlightIndex].RawDimensions(), + colors.White, + ) + + // Render device items with appropriate colors + for i, item := range p.devices { + if i == p.highlightIndex && i == p.selectedIndex { + // Currently highlighted AND selected device - dark green + item.Color = colors.DarkGreen + } else if i == p.highlightIndex { + // Just highlighted - black (shows on white background) + item.Color = colors.Black + } else if i == p.selectedIndex { + // Just selected - green + item.Color = colors.Green + } else { + // Normal item - white + item.Color = colors.White + } + p.RenderTexture(p.textShader, item.ID, item.Position(), item.RawDimensions(), item.Color) + } + + return nil +} + +func (p *AudioDevices) Destroy() error { + gl.DeleteTextures(1, &p.title.ID) + gl.DeleteTextures(1, &p.prompt.ID) + for _, item := range p.devices { + gl.DeleteTextures(1, &item.ID) + } + return nil +} diff --git a/internal/page/downloadProgressPage.go b/internal/page/downloadProgressPage.go new file mode 100644 index 0000000..00e4224 --- /dev/null +++ b/internal/page/downloadProgressPage.go @@ -0,0 +1,276 @@ +package page + +import ( + "fmt" + "strconv" + "sync/atomic" + + "github.com/go-gl/gl/v3.3-core/gl" + "github.com/go-gl/mathgl/mgl32" + "github.com/veandco/go-sdl2/sdl" + "rhemawavetech.com/rhemawave/internal/colors" + "rhemawavetech.com/rhemawave/internal/db" + "rhemawavetech.com/rhemawave/internal/fontManager" + "rhemawavetech.com/rhemawave/internal/keybinds" + "rhemawavetech.com/rhemawave/internal/shaderManager" +) + +type downloadState int + +const ( + downloadStateDownloading downloadState = iota + downloadStateFinished +) + +// DownloadProgressPage displays a progress bar while an audio file is downloading. +// The page is inescapable: no input is accepted while downloading, and only +// Enter is accepted once the download finishes. +type DownloadProgressPage struct { + Base + textShader *shaderManager.Shader + solidShader *shaderManager.Shader + + // Set by the application before pushing this page. + TotalBytes *atomic.Int64 + BytesWritten *atomic.Int64 + Done *atomic.Bool + HasError *atomic.Bool + NextPage Page // where to navigate on success + + state downloadState + title StringItem + prompt StringItem + percentText StringItem + lastPercent int + + barX, barY, barW, barH int32 +} + +func (p *DownloadProgressPage) Init(app ApplicationInterface) error { + if err := p.Base.Init(app); err != nil { + return fmt.Errorf("failed base page initialization: %w", err) + } + + fm := fontManager.Get() + sm := shaderManager.Get() + + font, ok := fm.GetFont("Roboto-Regular") + if !ok { + return fmt.Errorf("failed to get font") + } + + p.textShader, ok = sm.Get("text") + if !ok { + return fmt.Errorf("failed to get text shader") + } + p.solidShader, ok = sm.Get("solid_color") + if !ok { + return fmt.Errorf("failed to get solid_color shader") + } + + baseFontSizeStr, err := db.GetConfigValue("init_font_size") + if err != nil { + return fmt.Errorf("retrieving init_font_size from db: %w", err) + } + baseFontSize, err := strconv.Atoi(baseFontSizeStr) + if err != nil { + return fmt.Errorf("parsing init_font_size: %w", err) + } + + titleScale := float32(48) / float32(baseFontSize) + p.title, err = NewStringItem("Downloading Audio...", font, colors.White) + if err != nil { + return fmt.Errorf("creating title: %w", err) + } + p.title.Scale(titleScale) + + promptScale := float32(32) / float32(baseFontSize) + p.prompt, err = NewStringItem("Press Enter to continue", font, colors.White) + if err != nil { + return fmt.Errorf("creating prompt: %w", err) + } + p.prompt.Scale(promptScale) + + p.percentText, err = NewStringItem("0%", font, colors.White) + if err != nil { + return fmt.Errorf("creating percent text: %w", err) + } + p.percentText.Scale(promptScale) + p.lastPercent = 0 + + // Progress bar dimensions: 60% of screen width, 30px tall, centered + p.barW = int32(float32(p.ScreenWidth) * 0.6) + p.barH = 30 + p.barX = p.ScreenCenterX - p.barW/2 + p.barY = p.ScreenCenterY - p.barH/2 + + // Position title above bar + p.title.X = p.ScreenCenterX - p.title.W/2 + p.title.Y = p.barY + p.barH + 40 + + p.state = downloadStateDownloading + keybinds.Enabled = false + + return nil +} + +func (p *DownloadProgressPage) Update(dt float32) error { + if p.state == downloadStateFinished { + return nil + } + + if p.Done.Load() { + p.state = downloadStateFinished + + // Force progress to 100% on success + if !p.HasError.Load() && p.TotalBytes.Load() > 0 { + p.BytesWritten.Store(p.TotalBytes.Load()) + p.lastPercent = 100 + + fm := fontManager.Get() + font, ok := fm.GetFont("Roboto-Regular") + if ok { + gl.DeleteTextures(1, &p.percentText.ID) + baseFontSizeStr, _ := db.GetConfigValue("init_font_size") + baseFontSize, _ := strconv.Atoi(baseFontSizeStr) + percentScale := float32(32) / float32(baseFontSize) + newText, err := NewStringItem("100%", font, colors.White) + if err == nil { + newText.Scale(percentScale) + p.percentText = newText + } + } + } + + // Update title to reflect result + fm := fontManager.Get() + font, ok := fm.GetFont("Roboto-Regular") + if !ok { + return nil + } + + baseFontSizeStr, _ := db.GetConfigValue("init_font_size") + baseFontSize, _ := strconv.Atoi(baseFontSizeStr) + titleScale := float32(48) / float32(baseFontSize) + + gl.DeleteTextures(1, &p.title.ID) + + var titleText string + if p.HasError.Load() { + titleText = "Download Failed" + } else { + titleText = "Download Complete" + } + newTitle, err := NewStringItem(titleText, font, colors.White) + if err == nil { + newTitle.Scale(titleScale) + p.title = newTitle + p.title.X = p.ScreenCenterX - p.title.W/2 + p.title.Y = p.barY + p.barH + 40 + } + + return nil + } + + // Update percentage texture when it changes + percent := 0 + if p.TotalBytes.Load() > 0 { + percent = int(p.BytesWritten.Load() * 100 / p.TotalBytes.Load()) + if percent > 100 { + percent = 100 + } + } + + if percent != p.lastPercent { + p.lastPercent = percent + + fm := fontManager.Get() + font, ok := fm.GetFont("Roboto-Regular") + if !ok { + return nil + } + + gl.DeleteTextures(1, &p.percentText.ID) + + baseFontSizeStr, _ := db.GetConfigValue("init_font_size") + baseFontSize, _ := strconv.Atoi(baseFontSizeStr) + percentScale := float32(32) / float32(baseFontSize) + + newText, err := NewStringItem(fmt.Sprintf("%d%%", percent), font, colors.White) + if err == nil { + newText.Scale(percentScale) + p.percentText = newText + } + } + + return nil +} + +func (p *DownloadProgressPage) HandleEvent(event *sdl.Event) error { + // Inescapable while downloading + if p.state != downloadStateFinished { + return nil + } + + switch e := (*event).(type) { + case *sdl.KeyboardEvent: + if e.Type != sdl.KEYDOWN { + return nil + } + if e.Keysym.Sym == sdl.K_RETURN { + if p.HasError.Load() || p.NextPage == nil { + p.App.SchedulePop() + } else { + p.App.SwitchPage(p.NextPage) + } + } + } + return nil +} + +func (p *DownloadProgressPage) Render() error { + // Render title + p.RenderTexture(p.textShader, p.title.ID, p.title.Position(), p.title.RawDimensions(), p.title.Color) + + // Progress bar background (dark gray) + bgColor := sdl.Color{R: 60, G: 60, B: 60, A: 255} + barPos := mgl32.Vec2{float32(p.barX), float32(p.barY)} + barDim := mgl32.Vec2{float32(p.barW), float32(p.barH)} + p.RenderSolidColorQuad(p.solidShader, barPos, barDim, bgColor) + + // Progress bar foreground + progress := float32(0) + if p.TotalBytes.Load() > 0 { + progress = float32(p.BytesWritten.Load()) / float32(p.TotalBytes.Load()) + if progress > 1.0 { + progress = 1.0 + } + } + if progress > 0 { + fgColor := sdl.Color{R: 255, G: 255, B: 255, A: 255} + fgDim := mgl32.Vec2{float32(p.barW) * progress, float32(p.barH)} + p.RenderSolidColorQuad(p.solidShader, barPos, fgDim, fgColor) + } + + // Render percentage text below bar + p.percentText.X = p.ScreenCenterX - p.percentText.W/2 + p.percentText.Y = p.barY - p.percentText.H - 20 + p.RenderTexture(p.textShader, p.percentText.ID, p.percentText.Position(), p.percentText.RawDimensions(), p.percentText.Color) + + // Show prompt when finished + if p.state == downloadStateFinished { + p.prompt.X = p.ScreenCenterX - p.prompt.W/2 + p.prompt.Y = p.barY - p.percentText.H - 20 - p.prompt.H - 20 + p.RenderTexture(p.textShader, p.prompt.ID, p.prompt.Position(), p.prompt.RawDimensions(), p.prompt.Color) + } + + return nil +} + +func (p *DownloadProgressPage) Destroy() error { + keybinds.Enabled = true + gl.DeleteTextures(1, &p.title.ID) + gl.DeleteTextures(1, &p.prompt.ID) + gl.DeleteTextures(1, &p.percentText.ID) + return nil +} diff --git a/internal/page/emailAddressPage.go b/internal/page/emailAddressPage.go new file mode 100644 index 0000000..f46d50a --- /dev/null +++ b/internal/page/emailAddressPage.go @@ -0,0 +1,395 @@ +package page + +import ( + "fmt" + "regexp" + "strconv" + + "github.com/go-gl/gl/v3.3-core/gl" + "github.com/go-gl/mathgl/mgl32" + "github.com/veandco/go-sdl2/sdl" + "rhemawavetech.com/rhemawave/internal/colors" + "rhemawavetech.com/rhemawave/internal/db" + "rhemawavetech.com/rhemawave/internal/fontManager" + "rhemawavetech.com/rhemawave/internal/shaderManager" +) + +// emailRegex validates email format +var emailRegex = regexp.MustCompile(`^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$`) + +type EmailAddressPage struct { + Base + + title string + titleTextureID uint32 + titleTextureWidth int32 + titleTextureHeight int32 + + currentEmailDisplayTextureID uint32 + currentEmailDisplayTextureWidth int32 + currentEmailDisplayTextureHeight int32 + + inputText string + inputTextTextureID uint32 + inputTextTextureWidth int32 + inputTextTextureHeight int32 + + // Error message handling + errorMessage string + errorTextureID uint32 + errorTextureWidth int32 + errorTextureHeight int32 + + // isFirstTimeSetup tracks whether page was loaded empty (first-time setup) + isFirstTimeSetup bool +} + +// isValidEmail checks if the given string is a valid email format +func isValidEmail(email string) bool { + return emailRegex.MatchString(email) +} + +// Init performs basic page initialization and creation of static assets. +func (p *EmailAddressPage) Init(app ApplicationInterface) error { + + if err := p.Base.Init(app); err != nil { + return fmt.Errorf("failed base page initialization: %w", err) + } + + p.title = "Your Email Address" + + // Get application font from database + applicationFont, err := db.GetConfigValue("application_font") + if err != nil { + return fmt.Errorf("retrieving application_font from db: %w", err) + } + + fm := fontManager.Get() + textShader, ok := shaderManager.Get().Get("text") + if !ok { + return fmt.Errorf("unable to fetch text shader") + } + + // Create title texture + titleTextureID, titleWidth, titleHeight, err := fm.CreateStringTexture(applicationFont, p.title, textShader) + if err != nil { + return fmt.Errorf("failed to create title texture: %w", err) + } + if titleTextureID == 0 { + return fmt.Errorf("CreateStringTexture returned a nil texture ID") + } + + p.titleTextureID = titleTextureID + p.titleTextureWidth = titleWidth + p.titleTextureHeight = titleHeight + + // Load existing email address from database + emailAddress, err := db.GetConfigValue("email_address") + if err != nil { + return fmt.Errorf("retrieving email_address from db: %w", err) + } + + if emailAddress != "" { + p.inputText = emailAddress + p.isFirstTimeSetup = false + + // Create current email display texture + currentEmailText := fmt.Sprintf("Current Email: %s", emailAddress) + currentEmailTextureID, currentEmailWidth, currentEmailHeight, err := fm.CreateStringTexture(applicationFont, currentEmailText, textShader) + if err != nil { + return fmt.Errorf("failed to create current email display texture: %w", err) + } + if currentEmailTextureID == 0 { + return fmt.Errorf("CreateStringTexture returned a nil texture ID for current email display") + } + + p.currentEmailDisplayTextureID = currentEmailTextureID + p.currentEmailDisplayTextureWidth = currentEmailWidth + p.currentEmailDisplayTextureHeight = currentEmailHeight + } else { + p.inputText = "" + p.isFirstTimeSetup = true + } + + sdl.StartTextInput() + + return nil +} + +// HandleEvent processes SDL events and handles them appropriately for the EmailAddressPage. +func (p *EmailAddressPage) HandleEvent(event *sdl.Event) error { + actualEvent := *event + if !sdl.IsTextInputActive() { + sdl.StartTextInput() + } + + switch e := actualEvent.(type) { + case *sdl.TextInputEvent: + p.inputText += e.GetText() + // Clear error when user starts typing + p.errorMessage = "" + case *sdl.KeyboardEvent: + if e.Type == sdl.KEYDOWN { + switch e.Keysym.Sym { + case sdl.K_ESCAPE: + // Block escape during first-time setup + if p.isFirstTimeSetup { + return nil + } + // Allow escape back to settings if coming from settings + sdl.StopTextInput() + p.App.UnwindToPage(&Settings{}) + case sdl.K_RETURN: + // Validate email - check empty first, then format + if p.inputText == "" { + p.errorMessage = "Email address cannot be empty" + return nil + } + if !isValidEmail(p.inputText) { + p.errorMessage = "Please enter a valid email address" + return nil + } + + sdl.StopTextInput() + + // Save email address to database + if err := db.SetConfigValue("email_address", p.inputText); err != nil { + return fmt.Errorf("failed to save email address: %w", err) + } + + if p.isFirstTimeSetup { + // First-time setup: navigate to License Key page + p.App.PushPage(&LicenseKeyPage{}) + } else { + // Coming from settings: rewind back to settings + p.App.UnwindToPage(&Settings{}) + } + case sdl.K_BACKSPACE: + if len(p.inputText) > 0 { + p.inputText = p.inputText[:len(p.inputText)-1] + // Clear error when user edits input + p.errorMessage = "" + } + } + } + } + return nil +} + +// Update updates animations and changing textures and other changes using `dt` which represents a time delta in float32. +func (p *EmailAddressPage) Update(dt float32) error { + // Get application font from database + applicationFont, err := db.GetConfigValue("application_font") + if err != nil { + return fmt.Errorf("retrieving application_font from db: %w", err) + } + + fm := fontManager.Get() + sm := shaderManager.Get() + shader, ok := sm.Get("text") + if !ok { + return fmt.Errorf("unable to fetch text shader") + } + + // Update input text texture + if len(p.inputText) > 0 { + // Create the new inputText texture + inputTextTextureID, inputTextTextureWidth, inputTextTextureHeight, err := fm.CreateStringTexture( + applicationFont, + p.inputText, + shader, + ) + if err != nil { + return fmt.Errorf("unable to create new input text texture: %w", err) + } + + // Delete old texture if it exists + if p.inputTextTextureID != 0 { + gl.DeleteTextures(1, &p.inputTextTextureID) + } + + p.inputTextTextureID = inputTextTextureID + p.inputTextTextureWidth = inputTextTextureWidth + p.inputTextTextureHeight = inputTextTextureHeight + } + + // Update error message texture + if p.errorMessage != "" { + errorTextureID, errorWidth, errorHeight, err := fm.CreateStringTexture( + applicationFont, + p.errorMessage, + shader, + ) + if err != nil { + return fmt.Errorf("unable to create error text texture: %w", err) + } + + // Delete old error texture if it exists + if p.errorTextureID != 0 { + gl.DeleteTextures(1, &p.errorTextureID) + } + + p.errorTextureID = errorTextureID + p.errorTextureWidth = errorWidth + p.errorTextureHeight = errorHeight + } else { + // Clear error texture if no error message + if p.errorTextureID != 0 { + gl.DeleteTextures(1, &p.errorTextureID) + p.errorTextureID = 0 + } + } + + return nil +} + +// Render performs page drawing logic. +func (p *EmailAddressPage) Render() error { + // Get base font size from database + baseFontSizeStr, err := db.GetConfigValue("init_font_size") + if err != nil { + return fmt.Errorf("retrieving init_font_size from db: %w", err) + } + baseFontSize, err := strconv.Atoi(baseFontSizeStr) + if err != nil { + return fmt.Errorf("parsing init_font_size: %w", err) + } + + sm := shaderManager.Get() + + // 1. Calculate Scale + titleFontSize := int32(64) + titleScale := float32(titleFontSize) / float32(baseFontSize) + currentEmailFontSize := int32(28) + currentEmailScale := float32(currentEmailFontSize) / float32(baseFontSize) + padding := int32(4) + verticalMargin := int32(20) + + // 2. Define dimensions + targetFontSize := int32(36) + scale := float32(targetFontSize) / float32(baseFontSize) + border := int32(3) + boxH := targetFontSize + (padding * 2) + boxW := int32(600) + (padding * 2) + boxDimensions := mgl32.Vec2{float32(boxW), float32(boxH)} + borderBoxH := boxH + (border * 2) + borderBoxW := boxW + (border * 2) + borderBoxDimensions := mgl32.Vec2{float32(borderBoxW), float32(borderBoxH)} + titleH := float32(p.titleTextureHeight) * titleScale + titleW := float32(p.titleTextureWidth) * titleScale + titleDimensions := mgl32.Vec2{titleW, titleH} + inputTextH := float32(p.inputTextTextureHeight) * scale + inputTextW := float32(p.inputTextTextureWidth) * scale + inputTextDimensions := mgl32.Vec2{inputTextW, inputTextH} + + var currentEmailDisplayH, currentEmailDisplayW float32 + var currentEmailDisplayDimensions mgl32.Vec2 + if p.currentEmailDisplayTextureID != 0 { + currentEmailDisplayH = float32(p.currentEmailDisplayTextureHeight) * currentEmailScale + currentEmailDisplayW = float32(p.currentEmailDisplayTextureWidth) * currentEmailScale + currentEmailDisplayDimensions = mgl32.Vec2{currentEmailDisplayW, currentEmailDisplayH} + } + + // Error text dimensions + errorFontSize := int32(20) + errorScale := float32(errorFontSize) / float32(baseFontSize) + var errorTextH, errorTextW float32 + var errorTextDimensions mgl32.Vec2 + if p.errorTextureID != 0 { + errorTextH = float32(p.errorTextureHeight) * errorScale + errorTextW = float32(p.errorTextureWidth) * errorScale + errorTextDimensions = mgl32.Vec2{errorTextW, errorTextH} + } + + // 3. Define positions + borderBoxY := p.Base.ScreenCenterY - (borderBoxH / 2) + borderBoxX := p.Base.ScreenCenterX - (borderBoxW / 2) + borderBoxPosition := mgl32.Vec2{float32(borderBoxX), float32(borderBoxY)} + boxY := p.Base.ScreenCenterY - (boxH / 2) + boxX := p.Base.ScreenCenterX - (boxW / 2) + boxPosition := mgl32.Vec2{float32(boxX), float32(boxY)} + titleY := borderBoxY + borderBoxH + verticalMargin + titleX := p.Base.ScreenCenterX - int32(titleW/2) + titlePosition := mgl32.Vec2{float32(titleX), float32(titleY)} + inputTextY := boxY + padding + inputTextX := boxX + padding + inputTextPosition := mgl32.Vec2{float32(inputTextX), float32(inputTextY)} + + var currentEmailDisplayPosition mgl32.Vec2 + if p.currentEmailDisplayTextureID != 0 { + currentEmailDisplayY := borderBoxY - int32(currentEmailDisplayH) - verticalMargin + currentEmailDisplayX := p.Base.ScreenCenterX - int32(currentEmailDisplayW/2) + currentEmailDisplayPosition = mgl32.Vec2{float32(currentEmailDisplayX), float32(currentEmailDisplayY)} + } + + // Error text position (below current email display to avoid overlap) + var errorTextPosition mgl32.Vec2 + if p.errorTextureID != 0 { + var errorTextY int32 + if p.currentEmailDisplayTextureID != 0 { + // Position below the current email display + errorTextY = borderBoxY - int32(currentEmailDisplayH) - verticalMargin - int32(errorTextH) - (verticalMargin / 2) + } else { + // No current email display, position below the input box + errorTextY = borderBoxY - int32(errorTextH) - (verticalMargin / 2) + } + errorTextX := p.Base.ScreenCenterX - int32(errorTextW/2) + errorTextPosition = mgl32.Vec2{float32(errorTextX), float32(errorTextY)} + } + + // 4. Define Colors + white := sdl.Color{R: 255, G: 255, B: 255, A: 255} + grey := sdl.Color{R: 120, G: 120, B: 120, A: 255} + darkGrey := sdl.Color{R: 30, G: 30, B: 30, A: 255} + + // 5. Get Shaders + textShader, _ := sm.Get("text") + solidShader, _ := sm.Get("solid_color") + + // 6. Draw everything + p.Base.RenderSolidColorQuad(solidShader, borderBoxPosition, borderBoxDimensions, grey) + p.Base.RenderSolidColorQuad(solidShader, boxPosition, boxDimensions, darkGrey) + p.Base.RenderTexture(textShader, p.titleTextureID, titlePosition, titleDimensions, white) + + // Draw current email display if it exists + if p.currentEmailDisplayTextureID != 0 { + p.Base.RenderTexture(textShader, p.currentEmailDisplayTextureID, currentEmailDisplayPosition, currentEmailDisplayDimensions, white) + } + + if len(p.inputText) > 0 { + p.Base.RenderTexture(textShader, p.inputTextTextureID, inputTextPosition, inputTextDimensions, white) + } + + // Draw error message if it exists + if p.errorTextureID != 0 { + p.Base.RenderTexture(textShader, p.errorTextureID, errorTextPosition, errorTextDimensions, colors.ErrorRed) + } + return nil +} + +// Destroy cleans up page-specific resources. +func (p *EmailAddressPage) Destroy() error { + + gl.DeleteTextures(1, &p.titleTextureID) + + // Delete current email display texture if it exists + if p.currentEmailDisplayTextureID != 0 { + gl.DeleteTextures(1, &p.currentEmailDisplayTextureID) + p.currentEmailDisplayTextureID = 0 + } + + // Delete input text texture if it exists + if p.inputTextTextureID != 0 { + gl.DeleteTextures(1, &p.inputTextTextureID) + p.inputTextTextureID = 0 + } + + // Delete error texture if it exists + if p.errorTextureID != 0 { + gl.DeleteTextures(1, &p.errorTextureID) + p.errorTextureID = 0 + } + + sdl.StopTextInput() + return p.Base.Destroy() +} diff --git a/internal/page/licenseKeyPage.go b/internal/page/licenseKeyPage.go new file mode 100644 index 0000000..d5f1e69 --- /dev/null +++ b/internal/page/licenseKeyPage.go @@ -0,0 +1,458 @@ +package page + +import ( + "fmt" + "os" + "path/filepath" + "strconv" + "strings" + + "github.com/go-gl/gl/v3.3-core/gl" + "github.com/go-gl/mathgl/mgl32" + "github.com/veandco/go-sdl2/sdl" + "rhemawavetech.com/rhemawave/internal/colors" + "rhemawavetech.com/rhemawave/internal/db" + "rhemawavetech.com/rhemawave/internal/fontManager" + "rhemawavetech.com/rhemawave/internal/logger" + "rhemawavetech.com/rhemawave/internal/shaderManager" +) + +type LicenseKeyPage struct { + Base + + title string + titleTextureID uint32 + titleTextureWidth int32 + titleTextureHeight int32 + + currentLicenseDisplayTextureID uint32 + currentLicenseDisplayTextureWidth int32 + currentLicenseDisplayTextureHeight int32 + + inputText string + inputTextTextureID uint32 + inputTextTextureWidth int32 + inputTextTextureHeight int32 + + // Error message handling + errorMessage string + errorTextureID uint32 + errorTextureWidth int32 + errorTextureHeight int32 + + // isFirstTimeSetup tracks whether page was loaded empty (first-time setup) + isFirstTimeSetup bool +} + +// isValidLicenseKey checks if the license key has exactly 16 alphanumeric characters +func isValidLicenseKey(key string) bool { + cleaned := strings.ReplaceAll(key, "-", "") + if len(cleaned) != 16 { + return false + } + for _, r := range cleaned { + if !((r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9')) { + return false + } + } + return true +} + +// Init performs basic page initialization and creation of static assets. +func (p *LicenseKeyPage) Init(app ApplicationInterface) error { + + if err := p.Base.Init(app); err != nil { + return fmt.Errorf("failed base page initialization: %w", err) + } + + p.title = "License Key" + + // Get application font from database + applicationFont, err := db.GetConfigValue("application_font") + if err != nil { + return fmt.Errorf("retrieving application_font from db: %w", err) + } + + fm := fontManager.Get() + textShader, ok := shaderManager.Get().Get("text") + if !ok { + return fmt.Errorf("unable to fetch text shader") + } + + // Create title texture + titleTextureID, titleWidth, titleHeight, err := fm.CreateStringTexture(applicationFont, p.title, textShader) + if err != nil { + return fmt.Errorf("failed to create title texture: %w", err) + } + if titleTextureID == 0 { + return fmt.Errorf("CreateStringTexture returned a nil texture ID") + } + + p.titleTextureID = titleTextureID + p.titleTextureWidth = titleWidth + p.titleTextureHeight = titleHeight + + // Load existing license key from database + licenseKey, err := db.GetConfigValue("license_key") + if err != nil { + return fmt.Errorf("retrieving license_key from db: %w", err) + } + + if licenseKey != "" { + p.inputText = licenseKey + p.isFirstTimeSetup = false + + // Create current license key display texture + currentLicenseText := fmt.Sprintf("Current License Key: %s", licenseKey) + currentLicenseTextureID, currentLicenseWidth, currentLicenseHeight, err := fm.CreateStringTexture(applicationFont, currentLicenseText, textShader) + if err != nil { + return fmt.Errorf("failed to create current license display texture: %w", err) + } + if currentLicenseTextureID == 0 { + return fmt.Errorf("CreateStringTexture returned a nil texture ID for current license display") + } + + p.currentLicenseDisplayTextureID = currentLicenseTextureID + p.currentLicenseDisplayTextureWidth = currentLicenseWidth + p.currentLicenseDisplayTextureHeight = currentLicenseHeight + } else { + p.inputText = "" + p.isFirstTimeSetup = true + } + + sdl.StartTextInput() + + return nil +} + +// formatLicenseKey formats the input string with dashes every 4 characters +// and limits to 16 alphanumeric characters (not counting dashes) +func formatLicenseKey(input string) string { + // Remove all dashes and non-alphanumeric characters + cleaned := strings.Map(func(r rune) rune { + if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') { + return r + } + return -1 + }, input) + + // Limit to 16 characters + if len(cleaned) > 16 { + cleaned = cleaned[:16] + } + + // Insert dashes every 4 characters + var result strings.Builder + for i, char := range cleaned { + if i > 0 && i%4 == 0 { + result.WriteRune('-') + } + result.WriteRune(char) + } + + return result.String() +} + +// HandleEvent processes SDL events and handles them appropriately for the LicenseKeyPage. +func (p *LicenseKeyPage) HandleEvent(event *sdl.Event) error { + actualEvent := *event + if !sdl.IsTextInputActive() { + sdl.StartTextInput() + } + + switch e := actualEvent.(type) { + case *sdl.TextInputEvent: + // Add the new character and reformat + p.inputText += e.GetText() + p.inputText = formatLicenseKey(p.inputText) + // Clear error when user starts typing + p.errorMessage = "" + case *sdl.KeyboardEvent: + if e.Type == sdl.KEYDOWN { + switch e.Keysym.Sym { + case sdl.K_ESCAPE: + // Block escape during first-time setup + if p.isFirstTimeSetup { + return nil + } + // Allow escape back to settings if coming from settings + sdl.StopTextInput() + p.App.UnwindToPage(&Settings{}) + case sdl.K_RETURN: + // Validate license key - check empty first, then length, then characters + cleaned := strings.ReplaceAll(p.inputText, "-", "") + if cleaned == "" { + p.errorMessage = "License key cannot be empty" + return nil + } + if len(cleaned) != 16 { + p.errorMessage = fmt.Sprintf("License key must be 16 characters (currently %d)", len(cleaned)) + return nil + } + // Check for invalid characters + for _, r := range cleaned { + if !((r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9')) { + p.errorMessage = "License key must contain only letters and numbers" + return nil + } + } + + sdl.StopTextInput() + + // Save license key to database + if err := db.SetConfigValue("license_key", p.inputText); err != nil { + return fmt.Errorf("failed to save license key: %w", err) + } + + // Write license key to plain text file for the updater + if homeDir, err := os.UserHomeDir(); err == nil { + keyPath := filepath.Join(homeDir, ".local", "share", "rhemawave", "license_key") + if err := os.WriteFile(keyPath, []byte(p.inputText), 0644); err != nil { + logger.Error("Failed to write license key file: %v", err) + } + } + + if p.isFirstTimeSetup { + // First-time setup: rewind to Welcome page + p.App.UnwindToPage(&Welcome{}) + } else { + // Coming from settings: rewind back to settings + p.App.UnwindToPage(&Settings{}) + } + case sdl.K_BACKSPACE: + if len(p.inputText) > 0 { + // Remove last character and reformat + // Strip all dashes first to get raw characters + cleaned := strings.ReplaceAll(p.inputText, "-", "") + if len(cleaned) > 0 { + cleaned = cleaned[:len(cleaned)-1] + } + p.inputText = formatLicenseKey(cleaned) + // Clear error when user edits input + p.errorMessage = "" + } + } + } + } + return nil +} + +// Update updates animations and changing textures and other changes using `dt` which represents a time delta in float32. +func (p *LicenseKeyPage) Update(dt float32) error { + // Get application font from database + applicationFont, err := db.GetConfigValue("application_font") + if err != nil { + return fmt.Errorf("retrieving application_font from db: %w", err) + } + + fm := fontManager.Get() + sm := shaderManager.Get() + shader, ok := sm.Get("text") + if !ok { + return fmt.Errorf("unable to fetch text shader") + } + + // Update input text texture + if len(p.inputText) > 0 { + // Create the new inputText texture + inputTextTextureID, inputTextTextureWidth, inputTextTextureHeight, err := fm.CreateStringTexture( + applicationFont, + p.inputText, + shader, + ) + if err != nil { + return fmt.Errorf("unable to create new input text texture: %w", err) + } + + // Delete old texture if it exists + if p.inputTextTextureID != 0 { + gl.DeleteTextures(1, &p.inputTextTextureID) + } + + p.inputTextTextureID = inputTextTextureID + p.inputTextTextureWidth = inputTextTextureWidth + p.inputTextTextureHeight = inputTextTextureHeight + } + + // Update error message texture + if p.errorMessage != "" { + errorTextureID, errorWidth, errorHeight, err := fm.CreateStringTexture( + applicationFont, + p.errorMessage, + shader, + ) + if err != nil { + return fmt.Errorf("unable to create error text texture: %w", err) + } + + // Delete old error texture if it exists + if p.errorTextureID != 0 { + gl.DeleteTextures(1, &p.errorTextureID) + } + + p.errorTextureID = errorTextureID + p.errorTextureWidth = errorWidth + p.errorTextureHeight = errorHeight + } else { + // Clear error texture if no error message + if p.errorTextureID != 0 { + gl.DeleteTextures(1, &p.errorTextureID) + p.errorTextureID = 0 + } + } + + return nil +} + +// Render performs page drawing logic. +func (p *LicenseKeyPage) Render() error { + // Get base font size from database + baseFontSizeStr, err := db.GetConfigValue("init_font_size") + if err != nil { + return fmt.Errorf("retrieving init_font_size from db: %w", err) + } + baseFontSize, err := strconv.Atoi(baseFontSizeStr) + if err != nil { + return fmt.Errorf("parsing init_font_size: %w", err) + } + + sm := shaderManager.Get() + + // 1. Calculate Scale + titleFontSize := int32(64) + titleScale := float32(titleFontSize) / float32(baseFontSize) + currentLicenseFontSize := int32(28) + currentLicenseScale := float32(currentLicenseFontSize) / float32(baseFontSize) + padding := int32(4) + verticalMargin := int32(20) + + // 2. Define dimensions + targetFontSize := int32(36) + scale := float32(targetFontSize) / float32(baseFontSize) + border := int32(3) + + boxH := targetFontSize + (padding * 2) + boxW := int32(600) + (padding * 2) + boxDimensions := mgl32.Vec2{float32(boxW), float32(boxH)} + + borderBoxH := boxH + (border * 2) + borderBoxW := boxW + (border * 2) + borderBoxDimensions := mgl32.Vec2{float32(borderBoxW), float32(borderBoxH)} + + titleH := float32(p.titleTextureHeight) * titleScale + titleW := float32(p.titleTextureWidth) * titleScale + titleDimensions := mgl32.Vec2{titleW, titleH} + + inputTextH := float32(p.inputTextTextureHeight) * scale + inputTextW := float32(p.inputTextTextureWidth) * scale + inputTextDimensions := mgl32.Vec2{inputTextW, inputTextH} + + var currentLicenseDisplayH, currentLicenseDisplayW float32 + var currentLicenseDisplayDimensions mgl32.Vec2 + if p.currentLicenseDisplayTextureID != 0 { + currentLicenseDisplayH = float32(p.currentLicenseDisplayTextureHeight) * currentLicenseScale + currentLicenseDisplayW = float32(p.currentLicenseDisplayTextureWidth) * currentLicenseScale + currentLicenseDisplayDimensions = mgl32.Vec2{currentLicenseDisplayW, currentLicenseDisplayH} + } + + // Error text dimensions + errorFontSize := int32(20) + errorScale := float32(errorFontSize) / float32(baseFontSize) + var errorTextH, errorTextW float32 + var errorTextDimensions mgl32.Vec2 + if p.errorTextureID != 0 { + errorTextH = float32(p.errorTextureHeight) * errorScale + errorTextW = float32(p.errorTextureWidth) * errorScale + errorTextDimensions = mgl32.Vec2{errorTextW, errorTextH} + } + + // 3. Define positions + borderBoxY := p.Base.ScreenCenterY - (borderBoxH / 2) + borderBoxX := p.Base.ScreenCenterX - (borderBoxW / 2) + borderBoxPosition := mgl32.Vec2{float32(borderBoxX), float32(borderBoxY)} + + boxY := p.Base.ScreenCenterY - (boxH / 2) + boxX := p.Base.ScreenCenterX - (boxW / 2) + boxPosition := mgl32.Vec2{float32(boxX), float32(boxY)} + + titleY := borderBoxY + borderBoxH + verticalMargin + titleX := p.Base.ScreenCenterX - int32(titleW/2) + titlePosition := mgl32.Vec2{float32(titleX), float32(titleY)} + + inputTextY := boxY + padding + inputTextX := boxX + padding + inputTextPosition := mgl32.Vec2{float32(inputTextX), float32(inputTextY)} + + var currentLicenseDisplayPosition mgl32.Vec2 + if p.currentLicenseDisplayTextureID != 0 { + currentLicenseDisplayY := borderBoxY - int32(currentLicenseDisplayH) - verticalMargin + currentLicenseDisplayX := p.Base.ScreenCenterX - int32(currentLicenseDisplayW/2) + currentLicenseDisplayPosition = mgl32.Vec2{float32(currentLicenseDisplayX), float32(currentLicenseDisplayY)} + } + + // Error text position (below current license display to avoid overlap) + var errorTextPosition mgl32.Vec2 + if p.errorTextureID != 0 { + var errorTextY int32 + if p.currentLicenseDisplayTextureID != 0 { + // Position below the current license display + errorTextY = borderBoxY - int32(currentLicenseDisplayH) - verticalMargin - int32(errorTextH) - (verticalMargin / 2) + } else { + // No current license display, position below the input box + errorTextY = borderBoxY - int32(errorTextH) - (verticalMargin / 2) + } + errorTextX := p.Base.ScreenCenterX - int32(errorTextW/2) + errorTextPosition = mgl32.Vec2{float32(errorTextX), float32(errorTextY)} + } + + // 4. Get Shaders + textShader, _ := sm.Get("text") + solidShader, _ := sm.Get("solid_color") + + // 5. Draw everything + p.Base.RenderSolidColorQuad(solidShader, borderBoxPosition, borderBoxDimensions, colors.Gray) + p.Base.RenderSolidColorQuad(solidShader, boxPosition, boxDimensions, colors.DarkGray) + p.Base.RenderTexture(textShader, p.titleTextureID, titlePosition, titleDimensions, colors.White) + + // Draw current license display if it exists + if p.currentLicenseDisplayTextureID != 0 { + p.Base.RenderTexture(textShader, p.currentLicenseDisplayTextureID, currentLicenseDisplayPosition, currentLicenseDisplayDimensions, colors.White) + } + + if len(p.inputText) > 0 { + p.Base.RenderTexture(textShader, p.inputTextTextureID, inputTextPosition, inputTextDimensions, colors.White) + } + + // Draw error message if it exists + if p.errorTextureID != 0 { + p.Base.RenderTexture(textShader, p.errorTextureID, errorTextPosition, errorTextDimensions, colors.ErrorRed) + } + return nil +} + +// Destroy cleans up page-specific resources. +func (p *LicenseKeyPage) Destroy() error { + + gl.DeleteTextures(1, &p.titleTextureID) + + // Delete current license display texture if it exists + if p.currentLicenseDisplayTextureID != 0 { + gl.DeleteTextures(1, &p.currentLicenseDisplayTextureID) + p.currentLicenseDisplayTextureID = 0 + } + + // Delete input text texture if it exists + if p.inputTextTextureID != 0 { + gl.DeleteTextures(1, &p.inputTextTextureID) + p.inputTextTextureID = 0 + } + + // Delete error texture if it exists + if p.errorTextureID != 0 { + gl.DeleteTextures(1, &p.errorTextureID) + p.errorTextureID = 0 + } + + sdl.StopTextInput() + return p.Base.Destroy() +} diff --git a/internal/page/logViewerPage.go b/internal/page/logViewerPage.go new file mode 100644 index 0000000..6f8878e --- /dev/null +++ b/internal/page/logViewerPage.go @@ -0,0 +1,251 @@ +package page + +import ( + "fmt" + "strconv" + "strings" + + "github.com/go-gl/gl/v3.3-core/gl" + "github.com/go-gl/mathgl/mgl32" + "github.com/veandco/go-sdl2/sdl" + "rhemawavetech.com/rhemawave/internal/db" + "rhemawavetech.com/rhemawave/internal/fontManager" + "rhemawavetech.com/rhemawave/internal/shaderManager" +) + +type LogViewerPage struct { + Base + + titleTextureID uint32 + titleTextureWidth int32 + titleTextureHeight int32 + + lines []string + lineTextureIDs []uint32 + lineTextureWidths []int32 + lineTextureHeights []int32 + + hintTextureID uint32 + hintTextureWidth int32 + hintTextureHeight int32 + + scrollOffset int32 + maxScrollOffset int32 + lineHeight int32 + visibleHeight int32 +} + +func (p *LogViewerPage) Init(app ApplicationInterface) error { + if err := p.Base.Init(app); err != nil { + return fmt.Errorf("failed base page initialization: %w", err) + } + + logs, err := db.GetLogs(1000) + if err != nil { + return fmt.Errorf("failed to get logs: %w", err) + } + + // Format and word-wrap each log entry + for _, entry := range logs { + formatted := fmt.Sprintf("[%s] [%s] %s", entry.Timestamp, entry.Level, entry.Message) + wrapped := wrapText(formatted, 100) + p.lines = append(p.lines, strings.Split(wrapped, "\n")...) + } + + applicationFont, err := db.GetConfigValue("application_font") + if err != nil { + return fmt.Errorf("retrieving application_font from db: %w", err) + } + + fm := fontManager.Get() + textShader, ok := shaderManager.Get().Get("text") + if !ok { + return fmt.Errorf("unable to fetch text shader") + } + + // Title texture + titleID, titleW, titleH, err := fm.CreateStringTexture(applicationFont, "Application Logs", textShader) + if err != nil { + return fmt.Errorf("failed to create title texture: %w", err) + } + p.titleTextureID = titleID + p.titleTextureWidth = titleW + p.titleTextureHeight = titleH + + // Line textures + p.lineTextureIDs = make([]uint32, len(p.lines)) + p.lineTextureWidths = make([]int32, len(p.lines)) + p.lineTextureHeights = make([]int32, len(p.lines)) + + for i, line := range p.lines { + if strings.TrimSpace(line) == "" { + continue + } + texID, w, h, err := fm.CreateStringTexture(applicationFont, line, textShader) + if err != nil { + return fmt.Errorf("failed to create line texture: %w", err) + } + p.lineTextureIDs[i] = texID + p.lineTextureWidths[i] = w + p.lineTextureHeights[i] = h + } + + // Hint texture + hintText := "Arrow Keys / PgUp/PgDn to scroll | F1|2|3 to Exit" + hintID, hintW, hintH, err := fm.CreateStringTexture(applicationFont, hintText, textShader) + if err != nil { + return fmt.Errorf("failed to create hint texture: %w", err) + } + p.hintTextureID = hintID + p.hintTextureWidth = hintW + p.hintTextureHeight = hintH + + return nil +} + +func (p *LogViewerPage) HandleEvent(event *sdl.Event) error { + switch e := (*event).(type) { + case *sdl.KeyboardEvent: + if e.Type == sdl.KEYDOWN { + switch e.Keysym.Sym { + case sdl.K_BACKSPACE: + p.App.SchedulePop() + case sdl.K_UP: + p.scrollOffset -= p.lineHeight + if p.scrollOffset < 0 { + p.scrollOffset = 0 + } + case sdl.K_DOWN: + p.scrollOffset += p.lineHeight + if p.scrollOffset > p.maxScrollOffset { + p.scrollOffset = p.maxScrollOffset + } + case sdl.K_PAGEUP: + p.scrollOffset -= p.visibleHeight + if p.scrollOffset < 0 { + p.scrollOffset = 0 + } + case sdl.K_PAGEDOWN: + p.scrollOffset += p.visibleHeight + if p.scrollOffset > p.maxScrollOffset { + p.scrollOffset = p.maxScrollOffset + } + case sdl.K_HOME: + p.scrollOffset = 0 + case sdl.K_END: + p.scrollOffset = p.maxScrollOffset + } + } + case *sdl.MouseWheelEvent: + p.scrollOffset -= e.Y * p.lineHeight * 3 + if p.scrollOffset < 0 { + p.scrollOffset = 0 + } + if p.scrollOffset > p.maxScrollOffset { + p.scrollOffset = p.maxScrollOffset + } + } + return nil +} + +func (p *LogViewerPage) Update(dt float32) error { + return nil +} + +func (p *LogViewerPage) Render() error { + baseFontSizeStr, err := db.GetConfigValue("init_font_size") + if err != nil { + return fmt.Errorf("retrieving init_font_size from db: %w", err) + } + baseFontSize, err := strconv.Atoi(baseFontSizeStr) + if err != nil { + return fmt.Errorf("parsing init_font_size: %w", err) + } + + sm := shaderManager.Get() + textShader, _ := sm.Get("text") + + white := sdl.Color{R: 255, G: 255, B: 255, A: 255} + grey := sdl.Color{R: 180, G: 180, B: 180, A: 255} + + titleFontSize := int32(48) + titleScale := float32(titleFontSize) / float32(baseFontSize) + contentFontSize := int32(24) + contentScale := float32(contentFontSize) / float32(baseFontSize) + hintFontSize := int32(20) + hintScale := float32(hintFontSize) / float32(baseFontSize) + + margin := int32(40) + lineSpacing := int32(4) + p.lineHeight = contentFontSize + lineSpacing + + contentColumnWidth := int32(float32(p.Base.ScreenWidth) * 0.55) + contentLeftX := p.Base.ScreenCenterX - contentColumnWidth/2 + + // Title + titleH := float32(p.titleTextureHeight) * titleScale + titleW := float32(p.titleTextureWidth) * titleScale + titleX := p.Base.ScreenCenterX - int32(titleW/2) + titleY := p.Base.ScreenHeight - margin - int32(titleH) + p.Base.RenderTexture(textShader, p.titleTextureID, mgl32.Vec2{float32(titleX), float32(titleY)}, mgl32.Vec2{titleW, titleH}, white) + + // Hint at bottom + hintH := float32(p.hintTextureHeight) * hintScale + hintW := float32(p.hintTextureWidth) * hintScale + hintX := p.Base.ScreenCenterX - int32(hintW/2) + hintY := margin + p.Base.RenderTexture(textShader, p.hintTextureID, mgl32.Vec2{float32(hintX), float32(hintY)}, mgl32.Vec2{hintW, hintH}, grey) + + // Content area bounds + contentTop := titleY - margin + contentBottom := hintY + int32(hintH) + margin + p.visibleHeight = contentTop - contentBottom + + // Total content height + totalContentHeight := int32(len(p.lines)) * p.lineHeight + p.maxScrollOffset = totalContentHeight - p.visibleHeight + if p.maxScrollOffset < 0 { + p.maxScrollOffset = 0 + } + + // Render visible lines + currentY := contentTop - p.lineHeight + p.scrollOffset + + for i, line := range p.lines { + if strings.TrimSpace(line) == "" { + currentY -= p.lineHeight + continue + } + + if p.lineTextureIDs[i] == 0 { + currentY -= p.lineHeight + continue + } + + if currentY > contentTop || currentY+p.lineHeight < contentBottom { + currentY -= p.lineHeight + continue + } + + lineW := float32(p.lineTextureWidths[i]) * contentScale + lineH := float32(p.lineTextureHeights[i]) * contentScale + + p.Base.RenderTexture(textShader, p.lineTextureIDs[i], mgl32.Vec2{float32(contentLeftX), float32(currentY)}, mgl32.Vec2{lineW, lineH}, white) + currentY -= p.lineHeight + } + + return nil +} + +func (p *LogViewerPage) Destroy() error { + gl.DeleteTextures(1, &p.titleTextureID) + gl.DeleteTextures(1, &p.hintTextureID) + + for _, texID := range p.lineTextureIDs { + if texID != 0 { + gl.DeleteTextures(1, &texID) + } + } + + return p.Base.Destroy() +} diff --git a/internal/page/page.go b/internal/page/page.go new file mode 100644 index 0000000..aa89f29 --- /dev/null +++ b/internal/page/page.go @@ -0,0 +1,198 @@ +// Package page provides the interface for pages +package page + +import ( + "fmt" + + "github.com/go-gl/gl/v3.3-core/gl" + "github.com/go-gl/mathgl/mgl32" + "github.com/veandco/go-sdl2/sdl" + "rhemawavetech.com/rhemawave/internal/shaderManager" +) + +// Page defines the contract for all application screens. +type Page interface { + Init(app ApplicationInterface) error + HandleEvent(event *sdl.Event) error + Update(dt float32) error + Render() error + // Destroy cleans up the page's resources. The Application's page manager + // is responsible for calling this method + Destroy() error +} + +// ApplicationInterface defines the set of methods that a page can use to +// interact with the main application. +type ApplicationInterface interface { + SwitchPage(p Page) + PushPage(p Page) + UnwindToPage(p Page) + GetDrawableSize() (int32, int32) + SchedulePop() + Quit() +} + +// Base is a helper struct that pages can embed to get common functionality. +type Base struct { + App ApplicationInterface + QuadVAO uint32 + QuadVBO uint32 + Projection mgl32.Mat4 + ScreenWidth int32 + ScreenHeight int32 + ScreenCenterX int32 + ScreenCenterY int32 +} + +// Init stores the application context and sets up common resources. +func (p *Base) Init(app ApplicationInterface) error { + p.App = app + + vertices := []float32{ + // pos(x,y) tex(u,v) + 0.0, 1.0, 0.0, 1.0, + 1.0, 0.0, 1.0, 0.0, + 0.0, 0.0, 0.0, 0.0, + + 0.0, 1.0, 0.0, 1.0, + 1.0, 1.0, 1.0, 1.0, + 1.0, 0.0, 1.0, 0.0, + } + + screenWidth, screenHeight := p.App.GetDrawableSize() + p.Projection = mgl32.Ortho(0, float32(screenWidth), 0, float32(screenHeight), -1, 1) + p.ScreenHeight = screenHeight + p.ScreenWidth = screenWidth + p.ScreenCenterX = screenWidth / 2 + p.ScreenCenterY = screenHeight / 2 + + gl.GenVertexArrays(1, &p.QuadVAO) + gl.GenBuffers(1, &p.QuadVBO) + gl.BindVertexArray(p.QuadVAO) + gl.BindBuffer(gl.ARRAY_BUFFER, p.QuadVBO) + gl.BufferData(gl.ARRAY_BUFFER, len(vertices)*4, gl.Ptr(vertices), gl.STATIC_DRAW) + + stride := int32(4 * 4) // Each vertex has 4 floats (pos.x, pos.y, tex.u, tex.v) + + // Attribute 0: Vertex Position (vec2) + gl.EnableVertexAttribArray(0) + gl.VertexAttribPointerWithOffset(0, 2, gl.FLOAT, false, stride, 0) + + // Attribute 1: Texture Coordinate (vec2) + gl.EnableVertexAttribArray(1) + gl.VertexAttribPointerWithOffset(1, 2, gl.FLOAT, false, stride, 2*4) // Offset by 2 floats + + gl.BindBuffer(gl.ARRAY_BUFFER, 0) + gl.BindVertexArray(0) + gl.Disable(gl.BLEND) + gl.UseProgram(0) + return nil +} + +// Destroy cleans up the common OpenGL resources. +func (p *Base) Destroy() error { + gl.DeleteBuffers(1, &p.QuadVBO) + gl.DeleteVertexArrays(1, &p.QuadVAO) + return nil +} + +// BeginTextureRendering sets up shared GL state for a batch of RenderTexture calls. +// Call this once before a series of RenderTexture calls, then EndTextureRendering after. +func (p *Base) BeginTextureRendering(shader *shaderManager.Shader) { + gl.UseProgram(shader.ProgramID) + gl.Uniform1i(shader.LocTexture, 0) + gl.ActiveTexture(gl.TEXTURE0) + gl.Enable(gl.BLEND) + gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) + gl.BindVertexArray(p.QuadVAO) +} + +// EndTextureRendering restores GL state after a batch of RenderTexture calls. +func (p *Base) EndTextureRendering() { + gl.BindVertexArray(0) + gl.Disable(gl.BLEND) + gl.UseProgram(0) +} + +// RenderTexture draws a given texture to the screen at a specified position and size. +// For best performance, wrap multiple calls with BeginTextureRendering/EndTextureRendering. +// This method also works standalone for one-off renders. +func (p *Base) RenderTexture(shader *shaderManager.Shader, textureID uint32, position, size mgl32.Vec2, color sdl.Color) error { + gl.UseProgram(shader.ProgramID) + gl.Uniform1i(shader.LocTexture, 0) + + if shader.LocTextColor == -1 { + return fmt.Errorf("could not find 'u_textColor' uniform in shader program %d", shader.ProgramID) + } + gl.Uniform4f(shader.LocTextColor, float32(color.R)/255.0, float32(color.G)/255.0, float32(color.B)/255.0, float32(color.A)/255.0) + + model := mgl32.Ident4() + model = model.Mul4(mgl32.Translate3D(position.X(), position.Y(), 0)) + model = model.Mul4(mgl32.Scale3D(size.X(), size.Y(), 1)) + mvp := p.Projection.Mul4(model) + gl.UniformMatrix4fv(shader.LocMVPMatrix, 1, false, &mvp[0]) + + gl.ActiveTexture(gl.TEXTURE0) + gl.BindTexture(gl.TEXTURE_2D, textureID) + gl.Enable(gl.BLEND) + gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) + + gl.BindVertexArray(p.QuadVAO) + gl.DrawArrays(gl.TRIANGLES, 0, 6) + + gl.BindVertexArray(0) + gl.Disable(gl.BLEND) + gl.UseProgram(0) + return nil +} + +// RenderTextureBatched is a lightweight version of RenderTexture for use inside +// a BeginTextureRendering/EndTextureRendering block. It skips redundant state setup. +func (p *Base) RenderTextureBatched(shader *shaderManager.Shader, textureID uint32, position, size mgl32.Vec2, color sdl.Color) { + gl.Uniform4f(shader.LocTextColor, float32(color.R)/255.0, float32(color.G)/255.0, float32(color.B)/255.0, float32(color.A)/255.0) + + model := mgl32.Ident4() + model = model.Mul4(mgl32.Translate3D(position.X(), position.Y(), 0)) + model = model.Mul4(mgl32.Scale3D(size.X(), size.Y(), 1)) + mvp := p.Projection.Mul4(model) + gl.UniformMatrix4fv(shader.LocMVPMatrix, 1, false, &mvp[0]) + + gl.BindTexture(gl.TEXTURE_2D, textureID) + gl.DrawArrays(gl.TRIANGLES, 0, 6) +} + +// RenderSolidColorQuad draws a rectangle of a solid color to the screen. +func (p *Base) RenderSolidColorQuad(shader *shaderManager.Shader, position, size mgl32.Vec2, color sdl.Color) error { + gl.UseProgram(shader.ProgramID) + + model := mgl32.Ident4() + model = model.Mul4(mgl32.Translate3D(position.X(), position.Y(), 0)) + model = model.Mul4(mgl32.Scale3D(size.X(), size.Y(), 1)) + mvp := p.Projection.Mul4(model) + + if shader.LocMVPMatrix == -1 { + return fmt.Errorf("RenderSolidColorQuad: could not find 'u_mvpMatrix' uniform") + } + gl.UniformMatrix4fv(shader.LocMVPMatrix, 1, false, &mvp[0]) + + if shader.LocColor == -1 { + return fmt.Errorf("RenderSolidColorQuad: could not find 'u_color' uniform") + } + gl.Uniform4f(shader.LocColor, float32(color.R)/255.0, float32(color.G)/255.0, float32(color.B)/255.0, float32(color.A)/255.0) + + gl.Enable(gl.BLEND) + gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA) + + gl.BindVertexArray(p.QuadVAO) + gl.DrawArrays(gl.TRIANGLES, 0, 6) + + gl.BindVertexArray(0) + gl.Disable(gl.BLEND) + gl.UseProgram(0) + return nil +} + +// Provide default implementations for the Page interface. +func (p *Base) HandleEvent(event sdl.Event) error { return nil } +func (p *Base) Update(dt float32) error { return nil } +func (p *Base) Render() error { return nil } diff --git a/internal/page/pageItem.go b/internal/page/pageItem.go new file mode 100644 index 0000000..e34cf2e --- /dev/null +++ b/internal/page/pageItem.go @@ -0,0 +1,83 @@ +package page + +import ( + "fmt" + + "github.com/go-gl/mathgl/mgl32" + "github.com/veandco/go-sdl2/sdl" + "rhemawavetech.com/rhemawave/internal/fontManager" + "rhemawavetech.com/rhemawave/internal/shaderManager" +) + +// PageItem defines the basic features of any item on any page +// This coupling makes creating, updating and managing pages easier +type PageItem struct { + ID uint32 + W int32 + H int32 + X int32 // Horizontal position + Y int32 // Vertical position + Color sdl.Color + // index int +} + +// Scale updates the W and H of an item based on a scale factor (usually determined by base font size / desired font size) +func (i *PageItem) Scale(scale float32) { + i.W = int32(float32(i.W) * scale) + i.H = int32(float32(i.H) * scale) +} + +// Dimensions returns an mgl32.Vec2 containing the W and H of an item, respectively +func (i *PageItem) Dimensions(scale float32) mgl32.Vec2 { + return mgl32.Vec2{float32(float32(i.W) * scale), float32(float32(i.H) * scale)} +} + +// RawDimensions returns a mgl32.Vec2 containing the W and H of an item, without scaling +// This method will replace Dimensions in the future. Future PageItems should first call Scale(), then RawDimensions() +func (i *PageItem) RawDimensions() mgl32.Vec2 { + return mgl32.Vec2{float32(i.W), float32(i.H)} +} + +// Position returns an mgl32.Vec2 contianing the X and Y positions of an item, respectively +func (i *PageItem) Position() mgl32.Vec2 { + return mgl32.Vec2{float32(i.X), float32(i.Y)} +} + +// StringItem is an extended PageItem that contains a string content and string specific methods +type StringItem struct { + PageItem + content string +} + +// NewStringItem creates a new StringItem with the given content, font, and color. +// It initializes the texture ID, width, and height by creating a string texture using the font +// and shader manager. +func NewStringItem(content string, font *fontManager.FontEntry, color sdl.Color) (StringItem, error) { + var err error + + fm := fontManager.Get() + sm := shaderManager.Get() + + shader, ok := sm.Get("text") + if !ok { + return StringItem{}, fmt.Errorf("failed to fetch shader") + } + + id, width, height, err := fm.CreateStringTexture(font.Name, content, shader) + if err != nil { + return StringItem{}, err + } + + newStringItem := StringItem{ + PageItem: PageItem{ + ID: id, + W: width, + H: height, + Color: color, + }, + content: content, + } + + return newStringItem, err + +} diff --git a/internal/page/proclamationOptions.go b/internal/page/proclamationOptions.go new file mode 100644 index 0000000..d9d1516 --- /dev/null +++ b/internal/page/proclamationOptions.go @@ -0,0 +1,243 @@ +package page + +import ( + "fmt" + "strconv" + + "github.com/go-gl/gl/v3.3-core/gl" + "github.com/veandco/go-sdl2/sdl" + "rhemawavetech.com/rhemawave/internal/colors" + "rhemawavetech.com/rhemawave/internal/db" + "rhemawavetech.com/rhemawave/internal/fontManager" + "rhemawavetech.com/rhemawave/internal/shaderManager" +) + +type ProclamationOptions struct { + Base + font *fontManager.FontEntry + textShader *shaderManager.Shader + solidShader *shaderManager.Shader + title StringItem + prompt StringItem + proclamations []StringItem + proclamationIDs []uint // Database IDs corresponding to each proclamation + activeMap map[int]bool // Maps display index to selected state + highlightIndex int + verticalMargin int32 +} + +func (p *ProclamationOptions) Init(app ApplicationInterface) error { + var err error + p.verticalMargin = int32(20) + p.activeMap = make(map[int]bool) + p.proclamationIDs = make([]uint, 0) + + // Get font + fm := fontManager.Get() + font, ok := fm.GetFont("Roboto-Regular") + if !ok { + return fmt.Errorf("failed to get font: %w", sdl.GetError()) + } + p.font = font + + // Get shaders + sm := shaderManager.Get() + p.textShader, ok = sm.Get("text") + if !ok { + return fmt.Errorf("failed to get text shader: %w", sdl.GetError()) + } + + p.solidShader, ok = sm.Get("solid_color") + if !ok { + return fmt.Errorf("failed to get solid_color shader: %w", sdl.GetError()) + } + + // Initialize base + if err := p.Base.Init(app); err != nil { + return fmt.Errorf("base init failed: %w", err) + } + + // Get font size from database + baseFontSizeStr, err := db.GetConfigValue("init_font_size") + if err != nil { + return fmt.Errorf("retrieving init_font_size from db: %w", err) + } + baseFontSize, err := strconv.Atoi(baseFontSizeStr) + if err != nil { + return fmt.Errorf("parsing init_font_size %q: %w", baseFontSizeStr, err) + } + + // Calculate scales + titleScale := float32(64) / float32(baseFontSize) + itemScale := float32(32) / float32(baseFontSize) + + // Create title + p.title, err = NewStringItem("Select Proclamations", p.font, colors.White) + if err != nil { + return fmt.Errorf("creating title: %w", err) + } + p.title.Scale(titleScale) + + // Create prompt + p.prompt, err = NewStringItem("Arrow Keys to navigate | Space to toggle | F2 to run | Enter to return", p.font, colors.White) + if err != nil { + return fmt.Errorf("creating prompt: %w", err) + } + p.prompt.Scale(itemScale) + + // Load proclamations from database + proclamations, err := db.GetProclamations() + if err != nil { + return fmt.Errorf("retrieving proclamations from db: %w", err) + } + + // Create UI items for each available proclamation + for _, proclamation := range proclamations { + if !proclamation.Available { + continue + } + + label, err := NewStringItem(proclamation.Title, p.font, colors.White) + if err != nil { + return fmt.Errorf("creating proclamation label: %w", err) + } + + label.Scale(itemScale) + p.proclamations = append(p.proclamations, label) + p.proclamationIDs = append(p.proclamationIDs, proclamation.ID) + + // Set initial selection state + if proclamation.Selected { + p.activeMap[len(p.proclamations)-1] = true + } + } + + p.layout() + return nil +} + +func (p *ProclamationOptions) layout() { + // Position title at bottom + p.title.X = p.ScreenCenterX - p.title.W/2 + p.title.Y = p.ScreenHeight - p.title.H - p.verticalMargin*2 + + // Position prompt above title + p.prompt.X = p.ScreenCenterX - p.prompt.W/2 + p.prompt.Y = p.title.Y - p.verticalMargin*2 - p.prompt.H + + // Position proclamation items stacked upward from prompt + for i := range p.proclamations { + p.proclamations[i].X = p.ScreenCenterX - p.proclamations[i].W/2 + if i == 0 { + p.proclamations[i].Y = p.prompt.Y - p.verticalMargin*2 - p.proclamations[i].H + } else { + p.proclamations[i].Y = p.proclamations[i-1].Y - p.proclamations[i].H - 10 + } + } +} + +func (p *ProclamationOptions) HandleEvent(event *sdl.Event) error { + switch e := (*event).(type) { + case *sdl.KeyboardEvent: + if e.Type != sdl.KEYDOWN { + return nil + } + switch e.Keysym.Sym { + case sdl.K_UP: + if p.highlightIndex > 0 { + p.highlightIndex-- + } + case sdl.K_DOWN: + if p.highlightIndex < len(p.proclamations)-1 { + p.highlightIndex++ + } + case sdl.K_BACKSPACE: + p.App.UnwindToPage(&Settings{}) + case sdl.K_SPACE: + // Toggle selection for highlighted item + if p.activeMap[p.highlightIndex] { + delete(p.activeMap, p.highlightIndex) + } else { + p.activeMap[p.highlightIndex] = true + } + + // Immediately save to database + if err := p.toggleProclamation(p.highlightIndex); err != nil { + return fmt.Errorf("failed to toggle proclamation: %w", err) + } + case sdl.K_RETURN: + // Just return to settings - no saving needed + p.App.UnwindToPage(&Settings{}) + } + } + return nil +} + +// toggleProclamation immediately updates the database for the proclamation at the given display index +func (p *ProclamationOptions) toggleProclamation(displayIndex int) error { + if displayIndex < 0 || displayIndex >= len(p.proclamationIDs) { + return fmt.Errorf("invalid display index %d", displayIndex) + } + + dbID := p.proclamationIDs[displayIndex] + isSelected := p.activeMap[displayIndex] + + // Get the proclamation from database + var proclamation db.Proclamations + if err := db.DB.First(&proclamation, dbID).Error; err != nil { + return fmt.Errorf("retrieving proclamation %d: %w", dbID, err) + } + + // Update the Selected field + proclamation.Selected = isSelected + if err := db.DB.Save(&proclamation).Error; err != nil { + return fmt.Errorf("updating proclamation %d: %w", dbID, err) + } + + return nil +} + +func (p *ProclamationOptions) Render() error { + // Always render title and prompt + p.RenderTexture(p.textShader, p.title.ID, p.title.Position(), p.title.RawDimensions(), p.title.Color) + p.RenderTexture(p.textShader, p.prompt.ID, p.prompt.Position(), p.prompt.RawDimensions(), p.prompt.Color) + + // No proclamations to display + if len(p.proclamations) == 0 { + return nil + } + + // Render highlight box behind selected item + p.RenderSolidColorQuad( + p.solidShader, + p.proclamations[p.highlightIndex].Position(), + p.proclamations[p.highlightIndex].RawDimensions(), + colors.White, + ) + + // Render proclamation items with appropriate colors + for i, item := range p.proclamations { + if p.activeMap[i] { + // Selected items are green + item.Color = colors.Green + } else if i == p.highlightIndex { + // Highlighted item is black (shows on white background) + item.Color = colors.Black + } else { + // Normal items are white + item.Color = colors.White + } + p.RenderTexture(p.textShader, item.ID, item.Position(), item.RawDimensions(), item.Color) + } + + return nil +} + +func (p *ProclamationOptions) Destroy() error { + gl.DeleteTextures(1, &p.title.ID) + gl.DeleteTextures(1, &p.prompt.ID) + for _, item := range p.proclamations { + gl.DeleteTextures(1, &item.ID) + } + return nil +} diff --git a/internal/page/scrollerPage.go b/internal/page/scrollerPage.go new file mode 100644 index 0000000..e12304b --- /dev/null +++ b/internal/page/scrollerPage.go @@ -0,0 +1,697 @@ +// ATTENTION: TED +// +// # Integrated Multi-Domain Rhema Wave Generation System +// +// This module implements the complete Rhema Wave generation system by synchronizing multiple +// subsystems that operate simultaneously across spatial, temporal, and chromatic +// domains to produce a unified frequency-structured visual output for subliminal proclamation display. +// +// The technology addresses the fundamental challenge of presenting textual proclamation content +// in a format optimized for subconscious processing rather than conscious reading. Conventional +// subliminal text systems use isolated techniques (simple masking, single-frequency flashing, or +// uniform scrolling) that operate in only one domain. Our system integrates four mathematically- +// synchronized subsystems, each generating Fibonacci-based patterns in different domains, creating +// a compound frequency signature designed to enhance subconscious absorption while maintaining +// conscious illegibility. +// +// The system architecture integrates: +// +// 1. Spatial Character Transformation - Each rendered character undergoes Fibonacci-based +// block scrambling (described separately), creating local spatial frequency patterns at +// the character level. +// +// 2. Spatial Line Distribution - Text lines contain varying word counts following an oscillating +// Fibonacci sequence (1, 1, 2, 3, 5, 8, 13... then reversing), creating a macro-level +// two-dimensional wave pattern in the display geometry and ensuring balanced temporal +// exposure of proclamation content segments. +// +// 3. Temporal Color Modulation - Sequential words receive colors from an intent-based palette, +// with color duration determined by an oscillating Fibonacci sequence, creating rhythmic +// chromatic variation synchronized with natural mathematical progression. +// +// 4. Temporal Velocity Modulation - Display scroll velocity oscillates between negative and +// positive extremes with acceleration/deceleration rates and hold periods, creating a +// "breathing" temporal rhythm for the entire visual field. +// +// The key innovation lies in the temporal and mathematical synchronization of these subsystems. +// All four operate on Fibonacci-derived parameters, creating harmonic relationships between the +// spatial frequencies (character scrambling, line wave patterns), chromatic frequencies (color +// duration oscillation), and temporal frequencies (scroll velocity modulation). This multi-domain +// integration produces what we term the "Rhema Wave" - a compound frequency signature where +// spatial, temporal, and chromatic patterns reinforce each other through mathematical harmony. +// +// Key differentiators from existing solutions: +// - Integrates four distinct Fibonacci-based frequency generators in a single system +// - Synchronizes pattern generation across spatial, temporal, and chromatic domains +// - Creates compound frequency signatures rather than isolated single-domain effects +// - Maintains character-specific and content-specific mathematical structure throughout +// - Uses bidirectional oscillation across multiple subsystems for rhythmic coherence +// - Combines macro-level (line patterns, velocity) and micro-level (character, color) modulation +// +// The system loads proclamation text content, processes it through all four subsystems simultaneously, +// and generates a continuously scrolling display where every element - from individual character +// pixels to overall scroll rhythm - contributes to the unified Rhema Wave output. The mathematical +// relationships between subsystems create interference patterns and harmonic resonances designed +// to enhance subconscious processing of the proclamation content while maintaining conscious +// illegibility through the character scrambling subsystem. +package page + +import ( + "fmt" + "math" + "path/filepath" + "strconv" + "strings" + + "github.com/go-gl/gl/v3.3-core/gl" + "github.com/veandco/go-sdl2/sdl" + "rhemawavetech.com/rhemawave/internal/colors" + "rhemawavetech.com/rhemawave/internal/db" + "rhemawavetech.com/rhemawave/internal/fontManager" + "rhemawavetech.com/rhemawave/internal/mixer" + colorPattern "rhemawavetech.com/rhemawave/internal/pattern/color" + linePattern "rhemawavetech.com/rhemawave/internal/pattern/line" + "rhemawavetech.com/rhemawave/internal/shaderManager" +) + +type Line struct { + words []StringItem + width int32 +} + +// LineDeque is a double-ended queue for Line values backed by a circular buffer. +// It avoids O(n) prepend and prevents capacity leaks from head-of-slice removal. +type LineDeque struct { + buf []Line + head, tail int + count int +} + +func NewLineDeque(cap int) *LineDeque { + if cap < 4 { + cap = 4 + } + return &LineDeque{buf: make([]Line, cap)} +} + +func (d *LineDeque) Len() int { return d.count } + +func (d *LineDeque) grow() { + newCap := len(d.buf) * 2 + newBuf := make([]Line, newCap) + for i := 0; i < d.count; i++ { + newBuf[i] = d.buf[(d.head+i)%len(d.buf)] + } + d.buf = newBuf + d.head = 0 + d.tail = d.count +} + +func (d *LineDeque) PushBack(l Line) { + if d.count == len(d.buf) { + d.grow() + } + d.buf[d.tail] = l + d.tail = (d.tail + 1) % len(d.buf) + d.count++ +} + +func (d *LineDeque) PushFront(l Line) { + if d.count == len(d.buf) { + d.grow() + } + d.head = (d.head - 1 + len(d.buf)) % len(d.buf) + d.buf[d.head] = l + d.count++ +} + +func (d *LineDeque) PopFront() Line { + l := d.buf[d.head] + d.buf[d.head] = Line{} // clear for GC + d.head = (d.head + 1) % len(d.buf) + d.count-- + return l +} + +func (d *LineDeque) PopBack() Line { + d.tail = (d.tail - 1 + len(d.buf)) % len(d.buf) + l := d.buf[d.tail] + d.buf[d.tail] = Line{} // clear for GC + d.count-- + return l +} + +func (d *LineDeque) Front() Line { return d.buf[d.head] } + +func (d *LineDeque) Back() Line { + return d.buf[(d.tail-1+len(d.buf))%len(d.buf)] +} + +func (d *LineDeque) Get(i int) *Line { + return &d.buf[(d.head+i)%len(d.buf)] +} + +func (d *LineDeque) Set(i int, l Line) { + d.buf[(d.head+i)%len(d.buf)] = l +} + +func (d *LineDeque) Clear() { + for i := 0; i < d.count; i++ { + d.buf[(d.head+i)%len(d.buf)] = Line{} + } + d.head, d.tail, d.count = 0, 0, 0 +} + +type ScrollerPage struct { + Base + + words []string + wordIndex int + lines *LineDeque + lineHeight int32 + fontScale float32 + shader *shaderManager.Shader + activePattern linePattern.LinePattern + font *fontManager.FontEntry + spaceWidth int32 + lineCtx *linePattern.LineRenderContext + colorPattern *colorPattern.ColorPattern + scrollOffset float32 + scrollY float32 + + increment float32 + velocity float32 + + // Time-based velocity control + velocityFloor float32 + velocityCeiling float32 + velocityStep float32 + velocityDelay float32 + velocityDirection int + velocityTimer float32 + velocityState int + autoVelocity bool + hold float32 +} + +func (p *ScrollerPage) Init(app ApplicationInterface) error { + p.increment = 100.0 + p.velocity = 800.0 + p.SetAutoVelocity(true, -4000.0, 4000.0, 100.0, 2.5, 6.0) + + sm := shaderManager.Get() + fm := fontManager.Get() + + // Get font + font, ok := fm.GetFont("Scrambled") + if !ok { + return fmt.Errorf("unable to fetch font 'Scrambled'") + } + p.font = font + + p.Base.Init(app) + + // Get text shader + textShader, ok := sm.Get("text") + if !ok { + return fmt.Errorf("text shader not found") + } + p.shader = textShader + + // Load proclamation words from database + if err := p.loadProclamations(); err != nil { + // Don't stop execution, just show fallback words + p.words = strings.Fields("No Proclamations Selected!") + } + p.wordIndex = 0 + + // Get line pattern from database + linePatternName, err := db.GetConfigValue("line_pattern") + if err != nil { + return fmt.Errorf("retrieving line_pattern from db: %w", err) + } + + p.activePattern, err = linePattern.Get(linePatternName) + if err != nil { + return fmt.Errorf("failed to load line pattern '%s': %w", linePatternName, err) + } + + // Initialize color pattern + var baseColors = []sdl.Color{ + colors.Tan, + colors.PeachPuff, + colors.LightCyan, + colors.LightSeaGreen, + colors.MediumTurquoise, + colors.DarkCyan, + colors.MediumPurple, + } + p.colorPattern = colorPattern.NewColorPattern(baseColors) + + // Get font sizes from database (optimize: load once, cache as int32) + standardFontSizeStr, err := db.GetConfigValue("standard_font_size") + if err != nil { + return fmt.Errorf("retrieving standard_font_size from db: %w", err) + } + standardFontSize, err := strconv.Atoi(standardFontSizeStr) + if err != nil { + return fmt.Errorf("parsing standard_font_size: %w", err) + } + + baseFontSizeStr, err := db.GetConfigValue("init_font_size") + if err != nil { + return fmt.Errorf("retrieving init_font_size from db: %w", err) + } + baseFontSize, err := strconv.Atoi(baseFontSizeStr) + if err != nil { + return fmt.Errorf("parsing init_font_size: %w", err) + } + + // Font setup (optimized: calculate once, reuse) + p.fontScale = float32(standardFontSize) / float32(baseFontSize) + nLines := int(p.ScreenHeight / int32(standardFontSize)) + p.lines = NewLineDeque(nLines * 2) + + // Calculate space width once + spaceGlyph, ok := fm.GetGlyph(p.font.Name, ' ') + if !ok { + return fmt.Errorf("failed to get space glyph") + } + p.spaceWidth = int32(float32(spaceGlyph.Advance) * p.fontScale) + + // Get line height from a sample string + tmpStrID, _, H, err := fm.NewCreateStringTexture(p.font.Name, "Mg", p.shader) + if err != nil { + return fmt.Errorf("failed to create sample texture: %w", err) + } + p.lineHeight = int32(float32(H) * p.fontScale) + gl.DeleteTextures(1, &tmpStrID) + + p.lineCtx = &linePattern.LineRenderContext{ + ScreenWidth: p.ScreenWidth, + Font: p.font, + FontScale: p.fontScale, + SpaceWidth: p.spaceWidth, + } + + // Create initial lines + for i := 0; i < nLines; i++ { + if err := p.createLine(i, true); err != nil { + return fmt.Errorf("failed to create initial line %d: %w", i, err) + } + } + + // Audio setup + audioDeviceName, err := db.GetConfigValue("audio_device_name") + if err != nil { + return fmt.Errorf("retrieving audio_device_name from db: %w", err) + } + + // Switch audio devices if needed + if mixer.CurrentDevice() != audioDeviceName { + if err := mixer.SwitchDevice(audioDeviceName); err != nil { + } else { + } + } + + // Start audio playback + selectedAudio, err := db.GetConfigValue("selected_audio") + if err != nil { + return fmt.Errorf("retrieving selected_audio from db: %w", err) + } + + assetsDir, err := db.GetConfigValue("assets_dir") + if err != nil { + return fmt.Errorf("retrieving assets_dir from db: %w", err) + } + + if selectedAudio == "" { + } else { + if err := mixer.Play(filepath.Join(assetsDir, selectedAudio), true); err != nil { + } + } + + currentDevice := mixer.CurrentDevice() + if currentDevice == "" { + currentDevice = "default" + } + + return nil +} + +// loadProclamations loads selected proclamations from the database +func (p *ScrollerPage) loadProclamations() error { + p.words = []string{} + + // Get all selected proclamations from database + proclamations, err := db.GetProclamations() + if err != nil { + return fmt.Errorf("retrieving proclamations from db: %w", err) + } + + // Build word list from selected, available proclamations + for _, proclamation := range proclamations { + if proclamation.Selected && proclamation.Available { + // Split content into words and add to list + words := strings.Fields(proclamation.Content) + p.words = append(p.words, words...) + } + } + + if len(p.words) == 0 { + p.words = strings.Fields("No Proclamations Selected!") + return fmt.Errorf("no proclamations selected or available") + } + + return nil +} + +// createLine is a helper to generate a new line at a specific index +// isInitial determines if this is during initialization (positions from top) +// or dynamic creation (positions relative to existing lines) +func (p *ScrollerPage) createLine(index int, isInitial bool) error { + words := p.activePattern.GetNextLine(p.words, &p.wordIndex, p.lineCtx) + line := Line{words: []StringItem{}} + + for _, word := range words { + if word == "" { + continue + } + item, err := NewStringItem(word, p.font, p.colorPattern.Color()) + if err != nil { + return fmt.Errorf("unable to create string item for word '%s': %w", word, err) + } + item.W = int32(float32(item.W) * p.fontScale) + item.H = int32(float32(item.H) * p.fontScale) + + if len(line.words) > 0 { + line.width += p.spaceWidth + } + line.words = append(line.words, item) + line.width += item.W + } + + // Calculate horizontal position (centered) + startX := p.ScreenCenterX - (line.width / 2) + + // Calculate vertical position + var baseY int32 + if isInitial { + baseY = int32(p.scrollY) - int32(p.lineHeight)*int32(index) + } else { + baseY = 0 // Will be set by caller based on context + } + + // Position all words in the line + for j := range line.words { + if j == 0 { + line.words[j].X = startX + } else { + line.words[j].X = line.words[j-1].X + line.words[j-1].W + p.spaceWidth + } + line.words[j].Y = baseY + } + + if isInitial { + p.lines.PushBack(line) + } + + return nil +} + +func (p *ScrollerPage) HandleEvent(event *sdl.Event) error { + switch e := (*event).(type) { + case *sdl.KeyboardEvent: + if e.Type != sdl.KEYDOWN { + return nil + } + switch e.Keysym.Sym { + case sdl.K_UP: + if !p.autoVelocity { + p.velocity += p.increment + } + case sdl.K_DOWN: + if !p.autoVelocity { + p.velocity -= p.increment + } + case sdl.K_a: + p.autoVelocity = !p.autoVelocity + if p.autoVelocity { + // Reset to initial state when enabling + p.velocity = p.velocityFloor + p.velocityDirection = 1 + p.velocityState = 0 + p.velocityTimer = 0.0 + } + } + return nil + } + return nil +} + +func (p *ScrollerPage) Update(dt float32) error { + p.updateAutoVelocity(dt) + + p.scrollOffset += dt * p.velocity + move := int32(p.scrollOffset) + if move == 0 { + return nil + } + p.scrollOffset -= float32(move) + + // Move all lines vertically + for i := 0; i < p.lines.Len(); i++ { + line := p.lines.Get(i) + for j := range line.words { + line.words[j].Y += move + } + } + + // Handle line replacement based on scroll direction + if p.velocity > 0 { + // Moving up: replace lines that go off top + for p.lines.Len() > 0 && len(p.lines.Front().words) > 0 && p.lines.Front().words[0].Y > p.ScreenHeight { + old := p.lines.PopFront() + for _, word := range old.words { + gl.DeleteTextures(1, &word.ID) + } + + if err := p.addLineAtBottom(); err != nil { + return err + } + } + } else if p.velocity < 0 { + // Moving down: replace lines that go off bottom + for p.lines.Len() > 0 { + back := p.lines.Back() + if len(back.words) == 0 || back.words[0].Y+back.words[0].H >= 0 { + break + } + + old := p.lines.PopBack() + for _, word := range old.words { + gl.DeleteTextures(1, &word.ID) + } + + if err := p.addLineAtTop(); err != nil { + return err + } + } + } + + return nil +} + +// addLineAtBottom creates and adds a new line at the bottom of the display +func (p *ScrollerPage) addLineAtBottom() error { + newWords := p.activePattern.GetNextLine(p.words, &p.wordIndex, p.lineCtx) + line := Line{words: []StringItem{}} + + for _, word := range newWords { + if word == "" { + continue + } + item, err := NewStringItem(word, p.font, p.colorPattern.Color()) + if err != nil { + return fmt.Errorf("unable to create string item for word '%s': %w", word, err) + } + item.W = int32(float32(item.W) * p.fontScale) + item.H = int32(float32(item.H) * p.fontScale) + + if len(line.words) > 0 { + line.width += p.spaceWidth + } + line.words = append(line.words, item) + line.width += item.W + } + + startX := p.ScreenCenterX - (line.width / 2) + + // Position relative to last existing line + var baseY int32 + if p.lines.Len() > 0 && len(p.lines.Back().words) > 0 { + baseY = p.lines.Back().words[0].Y - int32(p.lineHeight) + } else { + baseY = -int32(p.lineHeight) + } + + for j := range line.words { + if j == 0 { + line.words[j].X = startX + } else { + line.words[j].X = line.words[j-1].X + line.words[j-1].W + p.spaceWidth + } + line.words[j].Y = baseY + } + + p.lines.PushBack(line) + return nil +} + +// addLineAtTop creates and adds a new line at the top of the display +func (p *ScrollerPage) addLineAtTop() error { + newWords := p.activePattern.GetNextLine(p.words, &p.wordIndex, p.lineCtx) + line := Line{words: []StringItem{}} + + for _, word := range newWords { + if word == "" { + continue + } + item, err := NewStringItem(word, p.font, p.colorPattern.Color()) + if err != nil { + return fmt.Errorf("unable to create string item for word '%s': %w", word, err) + } + item.W = int32(float32(item.W) * p.fontScale) + item.H = int32(float32(item.H) * p.fontScale) + + if len(line.words) > 0 { + line.width += p.spaceWidth + } + line.words = append(line.words, item) + line.width += item.W + } + + startX := p.ScreenCenterX - (line.width / 2) + + // Position relative to first existing line + var baseY int32 + if p.lines.Len() > 0 && len(p.lines.Front().words) > 0 { + baseY = p.lines.Front().words[0].Y + int32(p.lineHeight) + } else { + baseY = p.ScreenHeight + } + + for j := range line.words { + if j == 0 { + line.words[j].X = startX + } else { + line.words[j].X = line.words[j-1].X + line.words[j-1].W + p.spaceWidth + } + line.words[j].Y = baseY + } + + p.lines.PushFront(line) + return nil +} + +func (p *ScrollerPage) Render() error { + p.BeginTextureRendering(p.shader) + for i := 0; i < p.lines.Len(); i++ { + line := p.lines.Get(i) + for _, word := range line.words { + if word.ID == 0 { + continue + } + p.RenderTextureBatched(p.shader, word.ID, word.Position(), word.RawDimensions(), word.Color) + } + } + p.EndTextureRendering() + return nil +} + +func (p *ScrollerPage) Destroy() error { + if p == nil { + return nil + } + + mixer.Stop(1000) + + // GL cleanup — delete all text textures + for i := 0; i < p.lines.Len(); i++ { + line := p.lines.Get(i) + for j := range line.words { + if id := line.words[j].ID; id != 0 { + gl.DeleteTextures(1, &line.words[j].ID) + line.words[j].ID = 0 + } + } + } + + gl.Flush() + + // Drop references for GC + p.lines = nil + p.words = nil + p.lineCtx = nil + p.font = nil + p.shader = nil + p.colorPattern = nil + + return nil +} + +// SetAutoVelocity configures the automatic velocity system for the ScrollerPage. +func (p *ScrollerPage) SetAutoVelocity(enabled bool, floor, ceiling, step, delay, hold float32) { + p.autoVelocity = enabled + p.velocityFloor = -float32(math.Abs(float64(floor))) + p.velocityCeiling = float32(math.Abs(float64(ceiling))) + p.velocityStep = float32(math.Abs(float64(step))) + p.velocityDelay = delay + p.hold = hold + + // Initialize state + p.velocityDirection = 1 + p.velocityState = 0 + p.velocityTimer = 0.0 + p.velocity = p.velocityFloor +} + +// updateAutoVelocity handles automatic velocity changes +func (p *ScrollerPage) updateAutoVelocity(dt float32) { + if !p.autoVelocity { + return + } + + switch p.velocityState { + case 0: // Changing velocity + if p.velocityDirection == 1 { + p.velocity += p.velocityStep * dt + if p.velocity >= p.velocityCeiling { + p.velocity = p.velocityCeiling + p.velocityState = 1 + p.velocityTimer = 0.0 + } + } else { + p.velocity -= p.velocityStep * dt + if p.velocity <= p.velocityFloor { + p.velocity = p.velocityFloor + p.velocityState = 2 + p.velocityTimer = 0.0 + } + } + + case 1: // Waiting at ceiling + p.velocityTimer += dt + if p.velocityTimer >= p.velocityDelay { + p.velocityDirection = -1 + p.velocityState = 0 + } + + case 2: // Waiting at floor + p.velocityTimer += dt + if p.velocityTimer >= p.velocityDelay { + p.velocityDirection = 1 + p.velocityState = 0 + } + } +} diff --git a/internal/page/settingsPage.go b/internal/page/settingsPage.go new file mode 100644 index 0000000..6ba9ee4 --- /dev/null +++ b/internal/page/settingsPage.go @@ -0,0 +1,253 @@ +package page + +import ( + "fmt" + "strconv" + + "github.com/go-gl/gl/v3.3-core/gl" + "github.com/veandco/go-sdl2/sdl" + "rhemawavetech.com/rhemawave/internal/colors" + "rhemawavetech.com/rhemawave/internal/db" + "rhemawavetech.com/rhemawave/internal/fontManager" + "rhemawavetech.com/rhemawave/internal/shaderManager" +) + +type Settings struct { + Base + font *fontManager.FontEntry + textShader *shaderManager.Shader + solidShader *shaderManager.Shader + title StringItem + prompt StringItem + options []Option + verticalMargin int32 + bgHighlight PageItem + highlightIndex int +} + +type Option struct { + page Page + label StringItem +} + +func (p *Settings) Init(app ApplicationInterface) error { + var err error + p.verticalMargin = int32(20) + + // Get font + fm := fontManager.Get() + font, ok := fm.GetFont("Roboto-Regular") + if !ok { + return fmt.Errorf("failed to get font: %w", sdl.GetError()) + } + p.font = font + + // Get shaders + sm := shaderManager.Get() + p.textShader, ok = sm.Get("text") + if !ok { + return fmt.Errorf("failed to get text shader: %w", sdl.GetError()) + } + p.solidShader, ok = sm.Get("solid_color") + if !ok { + return fmt.Errorf("failed to get solid_color shader: %w", sdl.GetError()) + } + + // Initialize base + if err := p.Base.Init(app); err != nil { + return fmt.Errorf("failed base page initialization: %w", err) + } + + // Create title + p.title, err = NewStringItem("Settings", font, colors.White) + if err != nil { + return fmt.Errorf("creating title: %w", err) + } + + // Create prompt + p.prompt, err = NewStringItem("Use Arrow Keys to Navigate, Enter to Select, or F1 to return to the Main Menu", font, colors.White) + if err != nil { + return fmt.Errorf("creating prompt: %w", err) + } + + // Create options + proclamationsLabel, err := NewStringItem("Proclamations", font, colors.White) + if err != nil { + return fmt.Errorf("creating proclamations label: %w", err) + } + p.options = append(p.options, Option{ + page: &ProclamationOptions{}, + label: proclamationsLabel, + }) + + wifiLabel, err := NewStringItem("WiFi Setup", font, colors.White) + if err != nil { + return fmt.Errorf("creating wifi label: %w", err) + } + p.options = append(p.options, Option{ + page: &WiFiSetupPage{}, + label: wifiLabel, + }) + + audioLabel, err := NewStringItem("Audio Device", font, colors.White) + if err != nil { + return fmt.Errorf("creating audio label: %w", err) + } + p.options = append(p.options, Option{ + page: &AudioDevices{}, + label: audioLabel, + }) + + emailLabel, err := NewStringItem("Email Address", font, colors.White) + if err != nil { + return fmt.Errorf("creating email label: %w", err) + } + p.options = append(p.options, Option{ + page: &EmailAddressPage{}, + label: emailLabel, + }) + + licenseKeyLabel, err := NewStringItem("License Key", font, colors.White) + if err != nil { + return fmt.Errorf("creating license key label: %w", err) + } + p.options = append(p.options, Option{ + page: &LicenseKeyPage{}, + label: licenseKeyLabel, + }) + + logsLabel, err := NewStringItem("Logs", font, colors.White) + if err != nil { + return fmt.Errorf("creating logs label: %w", err) + } + p.options = append(p.options, Option{ + page: &LogViewerPage{}, + label: logsLabel, + }) + + updateLabel, err := NewStringItem("Check for Updates", font, colors.White) + if err != nil { + return fmt.Errorf("creating update label: %w", err) + } + p.options = append(p.options, Option{ + page: &UpdateCheckPage{}, + label: updateLabel, + }) + + // Get base font size from database + baseFontSizeStr, err := db.GetConfigValue("init_font_size") + if err != nil { + return fmt.Errorf("retrieving init_font_size from db: %w", err) + } + baseFontSize, err := strconv.Atoi(baseFontSizeStr) + if err != nil { + return fmt.Errorf("parsing init_font_size: %w", err) + } + + // Calculate scales + titleScale := float32(64) / float32(baseFontSize) + scale := float32(32) / float32(baseFontSize) + + // Apply scales + p.title.Scale(titleScale) + p.prompt.Scale(scale) + + for i := range p.options { + p.options[i].label.Scale(scale) + } + + // Create background highlight using first option's dimensions + p.bgHighlight = PageItem{ + ID: 0, + W: p.options[0].label.W, + H: p.options[0].label.H, + Color: colors.White, + } + p.highlightIndex = 0 + + // Position title at bottom + p.title.X = p.Base.ScreenCenterX - p.title.W/2 + p.title.Y = p.ScreenHeight - p.title.H - p.verticalMargin*2 + + // Position prompt above title + p.prompt.X = p.ScreenCenterX - p.prompt.W/2 + p.prompt.Y = p.title.Y - p.verticalMargin*2 - p.prompt.H + + // Position options stacked upward from prompt + for i, option := range p.options { + p.options[i].label.X = p.ScreenCenterX - option.label.W/2 + if i == 0 { + p.options[i].label.Y = int32(float32(p.prompt.Y)-(float32(p.verticalMargin)*4)) - option.label.H + } else { + p.options[i].label.Y = p.options[i-1].label.Y - option.label.H - 10 + } + } + + return nil +} + +func (p *Settings) Update(dt float32) error { + return nil +} + +func (p *Settings) HandleEvent(event *sdl.Event) error { + switch e := (*event).(type) { + case *sdl.KeyboardEvent: + if e.Type != sdl.KEYDOWN { + return nil + } + switch e.Keysym.Sym { + case sdl.K_UP: + if p.highlightIndex > 0 { + p.highlightIndex-- + } + case sdl.K_DOWN: + if p.highlightIndex < len(p.options)-1 { + p.highlightIndex++ + } + case sdl.K_RETURN: + if p.highlightIndex >= 0 && p.highlightIndex < len(p.options) { + selectedOption := p.options[p.highlightIndex] + p.App.SwitchPage(selectedOption.page) + } + case sdl.K_BACKSPACE: + p.App.SwitchPage(&Welcome{}) + } + } + return nil +} + +func (p *Settings) Render() error { + // Render title and prompt + p.RenderTexture(p.textShader, p.title.ID, p.title.Position(), p.title.RawDimensions(), p.title.Color) + p.RenderTexture(p.textShader, p.prompt.ID, p.prompt.Position(), p.prompt.RawDimensions(), p.prompt.Color) + + // Render highlight behind selected option + p.RenderSolidColorQuad( + p.solidShader, + p.options[p.highlightIndex].label.Position(), + p.options[p.highlightIndex].label.RawDimensions(), + p.bgHighlight.Color, + ) + + // Render all options with appropriate colors + for i, option := range p.options { + if p.highlightIndex == i { + option.label.Color = colors.Black + } else { + option.label.Color = colors.White + } + p.RenderTexture(p.textShader, option.label.ID, option.label.Position(), option.label.RawDimensions(), option.label.Color) + } + + return nil +} + +func (p *Settings) Destroy() error { + gl.DeleteTextures(1, &p.title.ID) + gl.DeleteTextures(1, &p.prompt.ID) + for i := range p.options { + gl.DeleteTextures(1, &p.options[i].label.ID) + } + return nil +} diff --git a/internal/page/tosPage.go b/internal/page/tosPage.go new file mode 100644 index 0000000..1e549a0 --- /dev/null +++ b/internal/page/tosPage.go @@ -0,0 +1,388 @@ +package page + +import ( + "fmt" + "strconv" + "strings" + + "github.com/go-gl/gl/v3.3-core/gl" + "github.com/go-gl/mathgl/mgl32" + "github.com/veandco/go-sdl2/sdl" + "rhemawavetech.com/rhemawave/internal/db" + "rhemawavetech.com/rhemawave/internal/fontManager" + "rhemawavetech.com/rhemawave/internal/logger" + "rhemawavetech.com/rhemawave/internal/shaderManager" +) + +type TOSPage struct { + Base + + Title string + Content string + ConfigKey string + + titleTextureID uint32 + titleTextureWidth int32 + titleTextureHeight int32 + + lines []string + lineTextureIDs []uint32 + lineTextureWidths []int32 + lineTextureHeights []int32 + + promptTextureID uint32 + promptTextureWidth int32 + promptTextureHeight int32 + + scrollHintTextureID uint32 + scrollHintTextureWidth int32 + scrollHintTextureHeight int32 + + scrollOffset int32 + maxScrollOffset int32 + lineHeight int32 + visibleHeight int32 +} + +func (p *TOSPage) Init(app ApplicationInterface) error { + if err := p.Base.Init(app); err != nil { + return fmt.Errorf("failed base page initialization: %w", err) + } + + p.lines = parseHTMLToLines(p.Content, 60) + + applicationFont, err := db.GetConfigValue("application_font") + if err != nil { + return fmt.Errorf("retrieving application_font from db: %w", err) + } + + fm := fontManager.Get() + textShader, ok := shaderManager.Get().Get("text") + if !ok { + return fmt.Errorf("unable to fetch text shader") + } + + titleTextureID, titleWidth, titleHeight, err := fm.CreateStringTexture(applicationFont, p.Title, textShader) + if err != nil { + return fmt.Errorf("failed to create title texture: %w", err) + } + p.titleTextureID = titleTextureID + p.titleTextureWidth = titleWidth + p.titleTextureHeight = titleHeight + + p.lineTextureIDs = make([]uint32, len(p.lines)) + p.lineTextureWidths = make([]int32, len(p.lines)) + p.lineTextureHeights = make([]int32, len(p.lines)) + + for i, line := range p.lines { + if strings.TrimSpace(line) == "" { + continue + } + texID, w, h, err := fm.CreateStringTexture(applicationFont, line, textShader) + if err != nil { + return fmt.Errorf("failed to create line texture: %w", err) + } + p.lineTextureIDs[i] = texID + p.lineTextureWidths[i] = w + p.lineTextureHeights[i] = h + } + + promptText := "Press Y to Accept | Press N to Decline" + promptTextureID, promptWidth, promptHeight, err := fm.CreateStringTexture(applicationFont, promptText, textShader) + if err != nil { + return fmt.Errorf("failed to create prompt texture: %w", err) + } + p.promptTextureID = promptTextureID + p.promptTextureWidth = promptWidth + p.promptTextureHeight = promptHeight + + scrollHintText := "Scroll down: Arrow Keys / PgDn" + scrollHintID, scrollHintW, scrollHintH, err := fm.CreateStringTexture(applicationFont, scrollHintText, textShader) + if err != nil { + return fmt.Errorf("failed to create scroll hint texture: %w", err) + } + p.scrollHintTextureID = scrollHintID + p.scrollHintTextureWidth = scrollHintW + p.scrollHintTextureHeight = scrollHintH + + return nil +} + +// parseHTMLToLines converts HTML content to plain-text lines for rendering. +// Supported tags:

,
,

  • ,

    -

    . All other tags are stripped. +// HTML entities & < > " ' are decoded. +func parseHTMLToLines(html string, maxCharsPerLine int) []string { + var lines []string + + // Replace
    ,
    ,
    with newline markers + br := strings.NewReplacer( + "
    ", "\n", "
    ", "\n", "
    ", "\n", + "
    ", "\n", "
    ", "\n", "
    ", "\n", + ) + html = br.Replace(html) + + // Process block-level tags + // Replace

    ,
    - with paragraph break marker + for _, tag := range []string{"

    ", "", "", "", "", "", ""} { + html = strings.ReplaceAll(html, tag, "\n\n") + html = strings.ReplaceAll(html, strings.ToUpper(tag), "\n\n") + } + + // Replace
  • with list prefix marker + html = strings.ReplaceAll(html, "
  • ", "\n- ") + html = strings.ReplaceAll(html, "
  • ", "\n- ") + + // Strip all remaining HTML tags + var stripped strings.Builder + inTag := false + for _, r := range html { + if r == '<' { + inTag = true + continue + } + if r == '>' { + inTag = false + continue + } + if !inTag { + stripped.WriteRune(r) + } + } + text := stripped.String() + + // Decode HTML entities + text = strings.ReplaceAll(text, "&", "&") + text = strings.ReplaceAll(text, "<", "<") + text = strings.ReplaceAll(text, ">", ">") + text = strings.ReplaceAll(text, """, "\"") + text = strings.ReplaceAll(text, "'", "'") + + // Split into segments on double-newline (paragraph breaks) and single newline (line breaks) + paragraphs := strings.Split(text, "\n\n") + for i, para := range paragraphs { + para = strings.TrimSpace(para) + if para == "" { + continue + } + + // Handle single newlines within a paragraph (from
    tags) + sublines := strings.Split(para, "\n") + for _, sub := range sublines { + sub = strings.TrimSpace(sub) + if sub == "" { + continue + } + wrapped := wrapText(sub, maxCharsPerLine) + lines = append(lines, strings.Split(wrapped, "\n")...) + } + + // Add paragraph break (empty line) between paragraphs + if i < len(paragraphs)-1 { + lines = append(lines, "") + } + } + + return lines +} + +func wrapText(text string, maxCharsPerLine int) string { + var result strings.Builder + words := strings.Fields(text) + lineLen := 0 + + for _, word := range words { + if lineLen+len(word)+1 > maxCharsPerLine && lineLen > 0 { + result.WriteString("\n") + lineLen = 0 + } + if lineLen > 0 { + result.WriteString(" ") + lineLen++ + } + result.WriteString(word) + lineLen += len(word) + } + return result.String() +} + +func (p *TOSPage) HandleEvent(event *sdl.Event) error { + actualEvent := *event + + switch e := actualEvent.(type) { + case *sdl.KeyboardEvent: + if e.Type == sdl.KEYDOWN { + switch e.Keysym.Sym { + case sdl.K_n: + logger.Info("User declined TOS (%s); exiting", p.ConfigKey) + p.App.Quit() + case sdl.K_y: + if p.scrollOffset < p.maxScrollOffset { + return nil + } + logger.Info("User accepted TOS (%s)", p.ConfigKey) + if err := db.SetConfigValue(p.ConfigKey, "true"); err != nil { + return fmt.Errorf("failed to save TOS acceptance (%s): %w", p.ConfigKey, err) + } + p.App.SchedulePop() + case sdl.K_UP: + p.scrollOffset -= p.lineHeight + if p.scrollOffset < 0 { + p.scrollOffset = 0 + } + case sdl.K_DOWN: + p.scrollOffset += p.lineHeight + if p.scrollOffset > p.maxScrollOffset { + p.scrollOffset = p.maxScrollOffset + } + case sdl.K_PAGEUP: + p.scrollOffset -= p.visibleHeight + if p.scrollOffset < 0 { + p.scrollOffset = 0 + } + case sdl.K_PAGEDOWN: + p.scrollOffset += p.visibleHeight + if p.scrollOffset > p.maxScrollOffset { + p.scrollOffset = p.maxScrollOffset + } + case sdl.K_HOME: + p.scrollOffset = 0 + case sdl.K_END: + p.scrollOffset = p.maxScrollOffset + } + } + case *sdl.MouseWheelEvent: + p.scrollOffset -= e.Y * p.lineHeight * 3 + if p.scrollOffset < 0 { + p.scrollOffset = 0 + } + if p.scrollOffset > p.maxScrollOffset { + p.scrollOffset = p.maxScrollOffset + } + } + + return nil +} + +func (p *TOSPage) Update(dt float32) error { + return nil +} + +func (p *TOSPage) Render() error { + baseFontSizeStr, err := db.GetConfigValue("init_font_size") + if err != nil { + return fmt.Errorf("retrieving init_font_size from db: %w", err) + } + baseFontSize, err := strconv.Atoi(baseFontSizeStr) + if err != nil { + return fmt.Errorf("parsing init_font_size: %w", err) + } + + sm := shaderManager.Get() + textShader, _ := sm.Get("text") + + white := sdl.Color{R: 255, G: 255, B: 255, A: 255} + grey := sdl.Color{R: 180, G: 180, B: 180, A: 255} + + titleFontSize := int32(48) + titleScale := float32(titleFontSize) / float32(baseFontSize) + contentFontSize := int32(32) + contentScale := float32(contentFontSize) / float32(baseFontSize) + promptFontSize := int32(20) + promptScale := float32(promptFontSize) / float32(baseFontSize) + + margin := int32(40) + lineSpacing := int32(4) + paragraphSpacing := int32(16) + p.lineHeight = contentFontSize + lineSpacing + + // Center a content column at ~55% of screen width, left-align text within it + contentColumnWidth := int32(float32(p.Base.ScreenWidth) * 0.55) + contentLeftX := p.Base.ScreenCenterX - contentColumnWidth/2 + + // Title + titleH := float32(p.titleTextureHeight) * titleScale + titleW := float32(p.titleTextureWidth) * titleScale + titleX := p.Base.ScreenCenterX - int32(titleW/2) + titleY := p.Base.ScreenHeight - margin - int32(titleH) + p.Base.RenderTexture(textShader, p.titleTextureID, mgl32.Vec2{float32(titleX), float32(titleY)}, mgl32.Vec2{titleW, titleH}, white) + + // Prompt dimensions (calculate even if not shown, for content bounds) + promptH := float32(p.promptTextureHeight) * promptScale + promptW := float32(p.promptTextureWidth) * promptScale + promptX := p.Base.ScreenCenterX - int32(promptW/2) + promptY := margin + + // Content area bounds + contentTop := titleY - margin + contentBottom := promptY + int32(promptH) + margin + p.visibleHeight = contentTop - contentBottom + + // Calculate total content height (accounting for paragraph breaks) + totalContentHeight := int32(0) + for _, line := range p.lines { + if strings.TrimSpace(line) == "" { + totalContentHeight += paragraphSpacing + } else { + totalContentHeight += p.lineHeight + } + } + p.maxScrollOffset = totalContentHeight - p.visibleHeight + if p.maxScrollOffset < 0 { + p.maxScrollOffset = 0 + } + + // Render visible lines + currentY := contentTop - p.lineHeight + p.scrollOffset + + for i, line := range p.lines { + if strings.TrimSpace(line) == "" { + currentY -= paragraphSpacing + continue + } + + if p.lineTextureIDs[i] == 0 { + currentY -= p.lineHeight + continue + } + + // Skip lines outside visible area + if currentY > contentTop || currentY+p.lineHeight < contentBottom { + currentY -= p.lineHeight + continue + } + + lineW := float32(p.lineTextureWidths[i]) * contentScale + lineH := float32(p.lineTextureHeights[i]) * contentScale + + p.Base.RenderTexture(textShader, p.lineTextureIDs[i], mgl32.Vec2{float32(contentLeftX), float32(currentY)}, mgl32.Vec2{lineW, lineH}, white) + currentY -= p.lineHeight + } + + // Show accept/decline prompt when scrolled to bottom, scroll hint otherwise + if p.scrollOffset >= p.maxScrollOffset { + p.Base.RenderTexture(textShader, p.promptTextureID, mgl32.Vec2{float32(promptX), float32(promptY)}, mgl32.Vec2{promptW, promptH}, grey) + } else { + hintScale := promptScale + hintW := float32(p.scrollHintTextureWidth) * hintScale + hintH := float32(p.scrollHintTextureHeight) * hintScale + hintX := p.Base.ScreenCenterX - int32(hintW/2) + hintY := promptY + p.Base.RenderTexture(textShader, p.scrollHintTextureID, mgl32.Vec2{float32(hintX), float32(hintY)}, mgl32.Vec2{hintW, hintH}, grey) + } + + return nil +} + +func (p *TOSPage) Destroy() error { + gl.DeleteTextures(1, &p.titleTextureID) + gl.DeleteTextures(1, &p.promptTextureID) + gl.DeleteTextures(1, &p.scrollHintTextureID) + + for _, texID := range p.lineTextureIDs { + if texID != 0 { + gl.DeleteTextures(1, &texID) + } + } + + return p.Base.Destroy() +} diff --git a/internal/page/updateCheckPage.go b/internal/page/updateCheckPage.go new file mode 100644 index 0000000..da5c1d3 --- /dev/null +++ b/internal/page/updateCheckPage.go @@ -0,0 +1,196 @@ +package page + +import ( + "fmt" + "os/exec" + "strconv" + "strings" + + "github.com/go-gl/gl/v3.3-core/gl" + "github.com/veandco/go-sdl2/sdl" + "rhemawavetech.com/rhemawave/internal/colors" + "rhemawavetech.com/rhemawave/internal/db" + "rhemawavetech.com/rhemawave/internal/fontManager" + "rhemawavetech.com/rhemawave/internal/shaderManager" +) + +type updateCheckState int + +const ( + updateCheckStateChecking updateCheckState = iota + updateCheckStateDone +) + +type UpdateCheckPage struct { + Base + textShader *shaderManager.Shader + + state updateCheckState + + // "Checking for Updates." / ".." / "..." + checkingTextures [3]StringItem + + // "No updates available" and "Press F3 to return" + doneMessage StringItem + doneHint StringItem + + // Error message if service failed to start + errorMessage StringItem + hasError bool + + pollTimer float32 + dotIndex int + dotTimer float32 +} + +func (p *UpdateCheckPage) Init(app ApplicationInterface) error { + if err := p.Base.Init(app); err != nil { + return fmt.Errorf("failed base page initialization: %w", err) + } + + fm := fontManager.Get() + sm := shaderManager.Get() + + font, ok := fm.GetFont("Roboto-Regular") + if !ok { + return fmt.Errorf("failed to get font") + } + + p.textShader, ok = sm.Get("text") + if !ok { + return fmt.Errorf("failed to get text shader") + } + + // Get scale + baseFontSizeStr, err := db.GetConfigValue("init_font_size") + if err != nil { + return fmt.Errorf("retrieving init_font_size from db: %w", err) + } + baseFontSize, err := strconv.Atoi(baseFontSizeStr) + if err != nil { + return fmt.Errorf("parsing init_font_size: %w", err) + } + scale := float32(48) / float32(baseFontSize) + + // Create checking textures with animated dots + dots := []string{"Checking for Updates.", "Checking for Updates..", "Checking for Updates..."} + for i, text := range dots { + item, err := NewStringItem(text, font, colors.White) + if err != nil { + return fmt.Errorf("creating checking texture %d: %w", i, err) + } + item.Scale(scale) + p.checkingTextures[i] = item + } + + // Create done textures + hintScale := float32(32) / float32(baseFontSize) + + p.doneMessage, err = NewStringItem("No updates available", font, colors.White) + if err != nil { + return fmt.Errorf("creating done message: %w", err) + } + p.doneMessage.Scale(scale) + + p.doneHint, err = NewStringItem("Press F3 to return", font, colors.White) + if err != nil { + return fmt.Errorf("creating done hint: %w", err) + } + p.doneHint.Scale(hintScale) + + // Start the update service + p.state = updateCheckStateChecking + if err := exec.Command("systemctl", "start", "rhemawave-update.service").Run(); err != nil { + p.errorMessage, _ = NewStringItem("Update service unavailable", font, colors.White) + p.errorMessage.Scale(scale) + p.hasError = true + p.state = updateCheckStateDone + } + + return nil +} + +func (p *UpdateCheckPage) Update(dt float32) error { + if p.state != updateCheckStateChecking { + return nil + } + + // Animate dots + p.dotTimer += dt + if p.dotTimer >= 0.5 { + p.dotTimer -= 0.5 + p.dotIndex = (p.dotIndex + 1) % 3 + } + + // Poll service status every 2 seconds + p.pollTimer += dt + if p.pollTimer >= 2.0 { + p.pollTimer -= 2.0 + + output, _ := exec.Command("systemctl", "is-active", "rhemawave-update.service").Output() + status := strings.TrimSpace(string(output)) + if status != "active" && status != "activating" { + p.state = updateCheckStateDone + } + } + + return nil +} + +func (p *UpdateCheckPage) HandleEvent(event *sdl.Event) error { + if p.state != updateCheckStateDone { + return nil + } + + switch e := (*event).(type) { + case *sdl.KeyboardEvent: + if e.Type != sdl.KEYDOWN { + return nil + } + switch e.Keysym.Sym { + case sdl.K_F3, sdl.K_BACKSPACE: + p.App.UnwindToPage(&Settings{}) + } + } + return nil +} + +func (p *UpdateCheckPage) Render() error { + switch p.state { + case updateCheckStateChecking: + item := p.checkingTextures[p.dotIndex] + item.X = p.ScreenCenterX - item.W/2 + item.Y = p.ScreenCenterY - item.H/2 + p.RenderTexture(p.textShader, item.ID, item.Position(), item.RawDimensions(), item.Color) + + case updateCheckStateDone: + var msg *StringItem + if p.hasError { + msg = &p.errorMessage + } else { + msg = &p.doneMessage + } + + msg.X = p.ScreenCenterX - msg.W/2 + msg.Y = p.ScreenCenterY + msg.H/2 + p.RenderTexture(p.textShader, msg.ID, msg.Position(), msg.RawDimensions(), msg.Color) + + p.doneHint.X = p.ScreenCenterX - p.doneHint.W/2 + p.doneHint.Y = msg.Y - p.doneHint.H - 20 + p.RenderTexture(p.textShader, p.doneHint.ID, p.doneHint.Position(), p.doneHint.RawDimensions(), p.doneHint.Color) + } + + return nil +} + +func (p *UpdateCheckPage) Destroy() error { + for i := range p.checkingTextures { + gl.DeleteTextures(1, &p.checkingTextures[i].ID) + } + gl.DeleteTextures(1, &p.doneMessage.ID) + gl.DeleteTextures(1, &p.doneHint.ID) + if p.hasError { + gl.DeleteTextures(1, &p.errorMessage.ID) + } + return nil +} diff --git a/internal/page/welcome.go b/internal/page/welcome.go new file mode 100644 index 0000000..8123b19 --- /dev/null +++ b/internal/page/welcome.go @@ -0,0 +1,439 @@ +package page + +import ( + "fmt" + "os" + "path/filepath" + "strconv" + "strings" + "time" + + "github.com/go-gl/gl/v3.3-core/gl" + "github.com/go-gl/mathgl/mgl32" + "github.com/veandco/go-sdl2/sdl" + "rhemawavetech.com/rhemawave/internal/colors" + "rhemawavetech.com/rhemawave/internal/db" + "rhemawavetech.com/rhemawave/internal/fontManager" + "rhemawavetech.com/rhemawave/internal/shaderManager" +) + +var GitVersion = "dev" + +type Welcome struct { + Base + title StringItem + version StringItem + prompt StringItem + note StringItem + licenseInfoHeading StringItem + emailDisplay StringItem + licenseKeyDisplay StringItem + displayStatus StringItem + sdlDisplayStatus StringItem + hasLicenseInfo bool + lastDisplayUpdate time.Time + drmDisplayCount int + sdlDisplayCount int + baseFontSize int // cached from db at init +} + +// countConnectedDisplays returns the number of connected displays via DRM +func countConnectedDisplays() int { + matches, err := filepath.Glob("/sys/class/drm/card*/status") + if err != nil { + return 0 + } + + connected := 0 + for _, path := range matches { + content, err := os.ReadFile(path) + if err != nil { + continue + } + + status := strings.TrimSpace(string(content)) + if status == "connected" { + connected++ + } + } + + return connected +} + +// countSDLDisplays returns the number of displays detected by SDL +func countSDLDisplays() int { + numDisplays, err := sdl.GetNumVideoDisplays() + if err != nil { + return 0 + } + return numDisplays +} + +// updateDisplayCounts updates the display count textures +func (p *Welcome) updateDisplayCounts() error { + // Get font + fm := fontManager.Get() + font, ok := fm.GetFont("Roboto-Regular") + if !ok { + return fmt.Errorf("unable to fetch font") + } + + // Get base font size + baseFontSizeStr, err := db.GetConfigValue("init_font_size") + if err != nil { + return fmt.Errorf("retrieving init_font_size from db: %w", err) + } + baseFontSize, err := strconv.Atoi(baseFontSizeStr) + if err != nil { + return fmt.Errorf("parsing init_font_size: %w", err) + } + + // Update DRM count + p.drmDisplayCount = countConnectedDisplays() + + // Delete old texture + if p.displayStatus.ID != 0 { + gl.DeleteTextures(1, &p.displayStatus.ID) + } + + // Create new texture + displayStatusText := fmt.Sprintf("Connected Displays: %d", p.drmDisplayCount) + p.displayStatus, err = NewStringItem(displayStatusText, font, colors.White) + if err != nil { + return fmt.Errorf("unable to create display status texture: %w", err) + } + + displayStatusScale := float32(24) / float32(baseFontSize) + p.displayStatus.Scale(displayStatusScale) + + // Update SDL count + p.sdlDisplayCount = countSDLDisplays() + + // Delete old texture + if p.sdlDisplayStatus.ID != 0 { + gl.DeleteTextures(1, &p.sdlDisplayStatus.ID) + } + + // Create new texture + sdlDisplayStatusText := fmt.Sprintf("SDL Displays Detected: %d", p.sdlDisplayCount) + p.sdlDisplayStatus, err = NewStringItem(sdlDisplayStatusText, font, colors.White) + if err != nil { + return fmt.Errorf("unable to create SDL display status texture: %w", err) + } + + p.sdlDisplayStatus.Scale(displayStatusScale) + + return nil +} + +// Init performs basic page initialization and creation of static assets. +func (p *Welcome) Init(app ApplicationInterface) error { + + title := "Rhema Wave" + version := GitVersion + prompt := "Press F2 to Start, or F3 for Settings" + note := "You can always press F1 to return here" + + if err := p.Base.Init(app); err != nil { + return fmt.Errorf("failed base page initialization: %w", err) + } + + // Get font + fm := fontManager.Get() + font, ok := fm.GetFont("Roboto-Regular") + if !ok { + return fmt.Errorf("unable to fetch font") + } + + // Create title texture + var err error + p.title, err = NewStringItem(title, font, colors.White) + if err != nil { + return fmt.Errorf("unable to create title string texture: %w", err) + } + + // Create version texture + versionString := "Version: " + version + p.version, err = NewStringItem(versionString, font, colors.White) + if err != nil { + return fmt.Errorf("unable to create version string texture: %w", err) + } + + // Create prompt texture + p.prompt, err = NewStringItem(prompt, font, colors.White) + if err != nil { + return fmt.Errorf("unable to create prompt string texture: %w", err) + } + + // Create note texture + p.note, err = NewStringItem(note, font, colors.White) + if err != nil { + return fmt.Errorf("unable to create note string texture: %w", err) + } + + // Initialize display counts + p.lastDisplayUpdate = time.Now() + if err := p.updateDisplayCounts(); err != nil { + return fmt.Errorf("unable to update display counts: %w", err) + } + + // Load license information from database + emailAddress, err := db.GetConfigValue("email_address") + if err != nil { + return fmt.Errorf("retrieving email_address from db: %w", err) + } + + licenseKey, err := db.GetConfigValue("license_key") + if err != nil { + return fmt.Errorf("retrieving license_key from db: %w", err) + } + + // Create license info textures if data exists + if emailAddress != "" || licenseKey != "" { + p.hasLicenseInfo = true + + // Create heading + p.licenseInfoHeading, err = NewStringItem("License Info", font, colors.White) + if err != nil { + return fmt.Errorf("unable to create license info heading texture: %w", err) + } + + // Create email display if exists + if emailAddress != "" { + emailText := fmt.Sprintf("Email: %s", emailAddress) + p.emailDisplay, err = NewStringItem(emailText, font, colors.White) + if err != nil { + return fmt.Errorf("unable to create email display texture: %w", err) + } + } + + // Create license key display if exists + if licenseKey != "" { + licenseKeyText := fmt.Sprintf("License Key: %s", licenseKey) + p.licenseKeyDisplay, err = NewStringItem(licenseKeyText, font, colors.White) + if err != nil { + return fmt.Errorf("unable to create license key display texture: %w", err) + } + } + } + + // Get base font size from database + baseFontSizeStr, err := db.GetConfigValue("init_font_size") + if err != nil { + return fmt.Errorf("retrieving init_font_size from db: %w", err) + } + baseFontSize, err := strconv.Atoi(baseFontSizeStr) + if err != nil { + return fmt.Errorf("parsing init_font_size: %w", err) + } + + p.baseFontSize = baseFontSize + + // Scale the note text + fontSize := int32(32) + scale := float32(fontSize) / float32(baseFontSize) + p.note.Scale(scale * 0.75) + + // Scale license info texts + if p.hasLicenseInfo { + licenseInfoScale := float32(28) / float32(baseFontSize) + p.licenseInfoHeading.Scale(licenseInfoScale) + if p.emailDisplay.ID != 0 { + p.emailDisplay.Scale(licenseInfoScale * 0.85) + } + if p.licenseKeyDisplay.ID != 0 { + p.licenseKeyDisplay.Scale(licenseInfoScale * 0.85) + } + } + + return nil +} + +// HandleEvent processes SDL events and handles them appropriately for the Welcome page. +func (p *Welcome) HandleEvent(event *sdl.Event) error { + return nil +} + +// Update updates animations and changing textures and other changes using `dt` which represents a time delta in float32. +func (p *Welcome) Update(dt float32) error { + // Update display counts every 2 seconds + if time.Since(p.lastDisplayUpdate) >= 2*time.Second { + if err := p.updateDisplayCounts(); err != nil { + } + p.lastDisplayUpdate = time.Now() + } + return nil +} + +func (p *Welcome) Render() error { + baseFontSize := p.baseFontSize + sm := shaderManager.Get() + verticalMargin := int32(20) + + // 1) Calculate scales + titleFontSize := int32(64) + bodyFontSize := int32(32) + + titleScale := float32(titleFontSize) / float32(baseFontSize) + bodyScale := float32(bodyFontSize) / float32(baseFontSize) + + // 2) Calculate dimensions (scaled) + titleW := float32(p.title.W) * titleScale + titleH := float32(p.title.H) * titleScale + titleDim := mgl32.Vec2{titleW, titleH} + + versionW := float32(p.version.W) * bodyScale + versionH := float32(p.version.H) * bodyScale + versionDim := mgl32.Vec2{versionW, versionH} + + promptW := float32(p.prompt.W) * bodyScale + promptH := float32(p.prompt.H) * bodyScale + promptDim := mgl32.Vec2{promptW, promptH} + + // p.note already scaled in Init via p.note.Scale(scale*0.75) + noteDim := p.note.RawDimensions() + noteW, noteH := noteDim[0], noteDim[1] + + // 3) Calculate total height of the vertical stack + totalH := int32(titleH) + verticalMargin + + int32(versionH) + verticalMargin + + int32(promptH) + verticalMargin + + int32(noteH) + + // 4) Y-up layout: start from the TOP of the centered stack and step DOWN + top := p.Base.ScreenCenterY + totalH/2 + + titleY := top - int32(titleH) // Title sits at the top + versionY := titleY - verticalMargin - int32(versionH) + p.prompt.Y = versionY - verticalMargin - int32(promptH) + p.note.Y = p.prompt.Y - verticalMargin - int32(noteH) + + // 5) Center X for each item + titleX := p.Base.ScreenCenterX - int32(titleW/2) + versionX := p.Base.ScreenCenterX - int32(versionW/2) + p.prompt.X = p.Base.ScreenCenterX - int32(promptW/2) + p.note.X = p.Base.ScreenCenterX - int32(noteW/2) + + titlePos := mgl32.Vec2{float32(titleX), float32(titleY)} + versionPos := mgl32.Vec2{float32(versionX), float32(versionY)} + + // 6) Position display status in bottom left corner + displayStatusDim := p.displayStatus.RawDimensions() + displayStatusH := displayStatusDim[1] + + // sdlDisplayStatusDim := p.sdlDisplayStatus.RawDimensions() + // sdlDisplayStatusH := sdlDisplayStatusDim[1] + + displayStatusMargin := int32(5) + + p.displayStatus.X = 15 + p.displayStatus.Y = 15 + + p.sdlDisplayStatus.X = 15 + p.sdlDisplayStatus.Y = 15 + int32(displayStatusH) + displayStatusMargin + + // 7) Position license info at bottom center + if p.hasLicenseInfo { + licenseInfoMargin := int32(10) + bottomMargin := int32(20) + + // License info items are already scaled in Init + licenseHeadingDim := p.licenseInfoHeading.RawDimensions() + licenseHeadingW, licenseHeadingH := licenseHeadingDim[0], licenseHeadingDim[1] + + var emailDisplayH, licenseKeyDisplayH float32 + if p.emailDisplay.ID != 0 { + emailDisplayDim := p.emailDisplay.RawDimensions() + emailDisplayH = emailDisplayDim[1] + } + if p.licenseKeyDisplay.ID != 0 { + licenseKeyDisplayDim := p.licenseKeyDisplay.RawDimensions() + licenseKeyDisplayH = licenseKeyDisplayDim[1] + } + + // Calculate total height of license info block + licenseInfoTotalH := int32(licenseHeadingH) + if p.emailDisplay.ID != 0 { + licenseInfoTotalH += int32(emailDisplayH) + licenseInfoMargin + } + if p.licenseKeyDisplay.ID != 0 { + licenseInfoTotalH += int32(licenseKeyDisplayH) + licenseInfoMargin + } + + // Start from bottom and work up + currentY := bottomMargin + + // License key (bottom-most if it exists) + if p.licenseKeyDisplay.ID != 0 { + licenseKeyDisplayDim := p.licenseKeyDisplay.RawDimensions() + licenseKeyDisplayW := licenseKeyDisplayDim[0] + p.licenseKeyDisplay.X = p.Base.ScreenCenterX - int32(licenseKeyDisplayW/2) + p.licenseKeyDisplay.Y = currentY + currentY += int32(licenseKeyDisplayH) + licenseInfoMargin + } + + // Email + if p.emailDisplay.ID != 0 { + emailDisplayDim := p.emailDisplay.RawDimensions() + emailDisplayW := emailDisplayDim[0] + p.emailDisplay.X = p.Base.ScreenCenterX - int32(emailDisplayW/2) + p.emailDisplay.Y = currentY + currentY += int32(emailDisplayH) + licenseInfoMargin + } + + // Heading (top-most) + p.licenseInfoHeading.X = p.Base.ScreenCenterX - int32(licenseHeadingW/2) + p.licenseInfoHeading.Y = currentY + } + + // 8) Get shader and render + textShader, ok := sm.Get("text") + if !ok { + return fmt.Errorf("failed to fetch text shader") + } + color := colors.White + + p.Base.RenderTexture(textShader, p.title.ID, titlePos, titleDim, color) + p.Base.RenderTexture(textShader, p.version.ID, versionPos, versionDim, color) + p.Base.RenderTexture(textShader, p.prompt.ID, p.prompt.Position(), promptDim, color) + p.Base.RenderTexture(textShader, p.note.ID, p.note.Position(), p.note.RawDimensions(), color) + + // Render display status + p.Base.RenderTexture(textShader, p.displayStatus.ID, p.displayStatus.Position(), p.displayStatus.RawDimensions(), color) + p.Base.RenderTexture(textShader, p.sdlDisplayStatus.ID, p.sdlDisplayStatus.Position(), p.sdlDisplayStatus.RawDimensions(), color) + + // Render license info if it exists + if p.hasLicenseInfo { + p.Base.RenderTexture(textShader, p.licenseInfoHeading.ID, p.licenseInfoHeading.Position(), p.licenseInfoHeading.RawDimensions(), color) + if p.emailDisplay.ID != 0 { + p.Base.RenderTexture(textShader, p.emailDisplay.ID, p.emailDisplay.Position(), p.emailDisplay.RawDimensions(), color) + } + if p.licenseKeyDisplay.ID != 0 { + p.Base.RenderTexture(textShader, p.licenseKeyDisplay.ID, p.licenseKeyDisplay.Position(), p.licenseKeyDisplay.RawDimensions(), color) + } + } + + return nil +} + +// Destroy cleans up page-specific resources. +func (p *Welcome) Destroy() error { + gl.DeleteTextures(1, &p.title.ID) + gl.DeleteTextures(1, &p.version.ID) + gl.DeleteTextures(1, &p.prompt.ID) + gl.DeleteTextures(1, &p.note.ID) + gl.DeleteTextures(1, &p.displayStatus.ID) + gl.DeleteTextures(1, &p.sdlDisplayStatus.ID) + + if p.hasLicenseInfo { + gl.DeleteTextures(1, &p.licenseInfoHeading.ID) + if p.emailDisplay.ID != 0 { + gl.DeleteTextures(1, &p.emailDisplay.ID) + } + if p.licenseKeyDisplay.ID != 0 { + gl.DeleteTextures(1, &p.licenseKeyDisplay.ID) + } + } + + return p.Base.Destroy() +} diff --git a/internal/page/wifiSetupPage.go b/internal/page/wifiSetupPage.go new file mode 100644 index 0000000..daf4a75 --- /dev/null +++ b/internal/page/wifiSetupPage.go @@ -0,0 +1,790 @@ +package page + +import ( + "fmt" + "strconv" + "strings" + "time" + + "github.com/go-gl/gl/v3.3-core/gl" + "github.com/go-gl/mathgl/mgl32" + "github.com/godbus/dbus/v5" + "github.com/veandco/go-sdl2/sdl" + "rhemawavetech.com/rhemawave/internal/colors" + "rhemawavetech.com/rhemawave/internal/db" + "rhemawavetech.com/rhemawave/internal/fontManager" + "rhemawavetech.com/rhemawave/internal/keybinds" + "rhemawavetech.com/rhemawave/internal/network" + "rhemawavetech.com/rhemawave/internal/shaderManager" +) + +// accessPointUIItem holds both the network data and its rendered texture. +type accessPointUIItem struct { + AP network.AccessPoint + Item StringItem +} + +// WiFiSetupPage manages the discovery and connection to Wi-Fi networks. +type WiFiSetupPage struct { + Base + networkManager *network.Manager + applicationFont *fontManager.FontEntry + + // Page-specific UI elements + titleItem StringItem + scanningStatusItem StringItem + connectionStatusItem StringItem + passwordPromptItem StringItem + passwordInputItem StringItem + passwordErrorItem StringItem + + // Network list and selection + accessPoints []accessPointUIItem + selectedIndex int + scrollOffset int + + // State management + isScanning bool + isEnteringPassword bool + isConnecting bool + connectionError string + passwordInput string + selectedAP *network.AccessPoint + wifiDevice *network.Device + connectionStatus *network.ConnectionStatus + activeSSID string // Tracks the CONFIRMED active network + pendingSSID string // Tracks the network we are TRYING to connect to + connectionAttemptTime time.Time + connectionTimeout time.Duration + + // Text input deduplication + textInputSupported bool + + // Async management + resultsChan chan []network.AccessPoint + statusChan chan *network.ConnectionStatus + errorChan chan error + stopScan chan struct{} +} + +// Init sets up the page, initializes the network manager, and starts a scan. +func (p *WiFiSetupPage) Init(app ApplicationInterface) error { + + if err := p.Base.Init(app); err != nil { + return fmt.Errorf("failed base page initialization: %w", err) + } + + // Get application font from database + applicationFontName, err := db.GetConfigValue("application_font") + if err != nil { + return fmt.Errorf("retrieving application_font from db: %w", err) + } + + fm := fontManager.Get() + font, ok := fm.GetFont(applicationFontName) + if !ok { + return fmt.Errorf("could not find application font: %s", applicationFontName) + } + p.applicationFont = font + + // Initialize network manager + nm, err := network.New() + if err != nil { + return fmt.Errorf("failed to initialize network manager: %w", err) + } + p.networkManager = nm + + // Find Wi-Fi device + if err := p.networkManager.FindDevices(); err != nil { + } + for _, dev := range p.networkManager.Devices { + if dev.Type == network.TypeWifi { + d := dev + p.wifiDevice = &d + break + } + } + + // Create UI elements + white := sdl.Color{R: 255, G: 255, B: 255, A: 255} + p.titleItem, err = NewStringItem("Wi-Fi Setup", p.applicationFont, white) + if err != nil { + return fmt.Errorf("failed to create title item: %w", err) + } + p.scanningStatusItem, err = NewStringItem("Scanning for networks...", p.applicationFont, white) + if err != nil { + return fmt.Errorf("failed to create scanning status item: %w", err) + } + + // Initialize channels and timeout + p.resultsChan = make(chan []network.AccessPoint) + p.statusChan = make(chan *network.ConnectionStatus, 1) + p.errorChan = make(chan error) + p.stopScan = make(chan struct{}) + p.connectionTimeout = 15 * time.Second + + // Start scanning and status monitoring + p.startScan() + go p.checkConnectionStatusLoop() + + return nil +} + +// checkConnectionStatusLoop periodically checks the network status. +func (p *WiFiSetupPage) checkConnectionStatusLoop() { + ticker := time.NewTicker(2 * time.Second) // Check more frequently for better UX + defer ticker.Stop() + + status, _ := p.networkManager.CheckInternetConnection() + p.statusChan <- status + + for { + select { + case <-ticker.C: + status, _ := p.networkManager.CheckInternetConnection() + p.statusChan <- status + case <-p.stopScan: + return + } + } +} + +// startScan triggers a new asynchronous network scan. +func (p *WiFiSetupPage) startScan() { + p.isScanning = true + p.selectedIndex = 0 + p.scrollOffset = 0 + p.accessPoints = nil + + if p.wifiDevice != nil { + go p.networkManager.StartScan(p.resultsChan, p.errorChan, p.stopScan) + } else { + p.isScanning = false + } +} + +// HandleEvent processes user input. +func (p *WiFiSetupPage) HandleEvent(event *sdl.Event) error { + if p.isEnteringPassword && !sdl.IsTextInputActive() { + p.enterPasswordMode() + } + + switch e := (*event).(type) { + case *sdl.TextInputEvent: + if p.isEnteringPassword { + if !p.textInputSupported { + // First TextInputEvent: the keyboard fallback already + // handled this character, so just record that text input + // is supported and skip the duplicate append. + p.textInputSupported = true + } else { + p.passwordInput += e.GetText() + p.updatePasswordTexture() + } + } + case *sdl.KeyboardEvent: + if e.Type != sdl.KEYDOWN { + return nil + } + if p.isEnteringPassword { + p.handlePasswordInput(e.Keysym.Sym, e.Keysym.Mod) + } else { + p.handleNetworkSelection(e.Keysym.Sym) + } + } + return nil +} + +// handlePasswordInput manages keyboard events during password entry. +func (p *WiFiSetupPage) handlePasswordInput(sym sdl.Keycode, mod uint16) { + switch sym { + case sdl.K_RETURN: + p.exitPasswordMode() + p.pendingSSID = p.selectedAP.SSID + p.isConnecting = true + p.connectionError = "" + p.connectionAttemptTime = time.Now() + err := p.networkManager.Connect(*p.wifiDevice, *p.selectedAP, p.passwordInput) + if err != nil { + p.isConnecting = false + p.pendingSSID = "" + p.connectionError = "Failed to initiate connection" + } + p.isEnteringPassword = false + case sdl.K_BACKSPACE: + if len(p.passwordInput) > 0 { + p.passwordInput = p.passwordInput[:len(p.passwordInput)-1] + p.updatePasswordTexture() + } + case sdl.K_ESCAPE: + p.isEnteringPassword = false + p.pendingSSID = "" + p.connectionError = "" + p.exitPasswordMode() + default: + // Keyboard fallback: if TextInputEvent was not received for this + // event cycle, convert printable keycodes to characters directly. + // This handles kiosk systems without an input method framework. + if !p.textInputSupported { + if ch := keycodeToChar(sym, mod); ch != 0 { + p.passwordInput += string(ch) + p.updatePasswordTexture() + } + } + } +} + +// enterPasswordMode disables global keybinds and starts SDL text input. +func (p *WiFiSetupPage) enterPasswordMode() { + keybinds.Enabled = false + sdl.StartTextInput() +} + +// exitPasswordMode re-enables global keybinds and stops SDL text input. +func (p *WiFiSetupPage) exitPasswordMode() { + keybinds.Enabled = true + sdl.StopTextInput() +} + +// keycodeToChar converts an SDL keycode to a rune, respecting SHIFT state. +// Returns 0 for non-printable keys. +func keycodeToChar(sym sdl.Keycode, mod uint16) rune { + shifted := mod&sdl.KMOD_SHIFT != 0 + + // Letters + if sym >= sdl.K_a && sym <= sdl.K_z { + ch := rune(sym) + if shifted { + ch -= 'a' - 'A' + } + return ch + } + + // Digits and their shifted symbols + if sym >= sdl.K_0 && sym <= sdl.K_9 { + if shifted { + shiftDigits := []rune{')', '!', '@', '#', '$', '%', '^', '&', '*', '('} + return shiftDigits[sym-sdl.K_0] + } + return rune(sym) + } + + // Common punctuation / symbols + type charPair struct{ normal, shifted rune } + punctuation := map[sdl.Keycode]charPair{ + sdl.K_SPACE: {' ', ' '}, + sdl.K_MINUS: {'-', '_'}, + sdl.K_EQUALS: {'=', '+'}, + sdl.K_LEFTBRACKET: {'[', '{'}, + sdl.K_RIGHTBRACKET: {']', '}'}, + sdl.K_BACKSLASH: {'\\', '|'}, + sdl.K_SEMICOLON: {';', ':'}, + sdl.K_QUOTE: {'\'', '"'}, + sdl.K_BACKQUOTE: {'`', '~'}, + sdl.K_COMMA: {',', '<'}, + sdl.K_PERIOD: {'.', '>'}, + sdl.K_SLASH: {'/', '?'}, + } + if pair, ok := punctuation[sym]; ok { + if shifted { + return pair.shifted + } + return pair.normal + } + + return 0 +} + +// handleNetworkSelection manages keyboard events for the network list. +func (p *WiFiSetupPage) handleNetworkSelection(sym sdl.Keycode) { + switch sym { + case sdl.K_UP: + if p.selectedIndex > 0 { + p.selectedIndex-- + } + case sdl.K_DOWN: + if p.selectedIndex < len(p.accessPoints)-1 { + p.selectedIndex++ + } + case sdl.K_RETURN: + if len(p.accessPoints) > 0 && p.selectedIndex < len(p.accessPoints) { + p.selectedAP = &p.accessPoints[p.selectedIndex].AP + p.pendingSSID = p.selectedAP.SSID + p.connectionError = "" + if p.selectedAP.IsProtected { + p.isEnteringPassword = true + p.passwordInput = "" + p.updatePasswordTexture() + p.updatePasswordPromptTexture() + p.enterPasswordMode() + } else { + p.isConnecting = true + p.connectionAttemptTime = time.Now() + err := p.networkManager.Connect(*p.wifiDevice, *p.selectedAP, "") + if err != nil { + p.isConnecting = false + p.pendingSSID = "" + p.connectionError = "Failed to initiate connection" + } + } + } + case sdl.K_r: + if !p.isScanning { + p.startScan() + } + } +} + +// Update checks for async results and updates UI state. +func (p *WiFiSetupPage) Update(dt float32) error { + select { + case results := <-p.resultsChan: + p.isScanning = false + p.buildNetworkUIList(results) + case status := <-p.statusChan: + p.connectionStatus = status + p.handleConnectionStatusUpdate(status) + p.updateConnectionStatusItem() + case err := <-p.errorChan: + p.isScanning = false + fmt.Printf("error scannign for networks %v", err) + default: + } + + // Check for connection timeout + if p.isConnecting && time.Since(p.connectionAttemptTime) > p.connectionTimeout { + p.isConnecting = false + p.connectionError = "Connection timed out - Incorrect password?" + if p.selectedAP != nil && p.selectedAP.IsProtected { + p.isEnteringPassword = true + p.passwordInput = "" + p.updatePasswordTexture() + p.updatePasswordPromptTexture() + p.updatePasswordErrorTexture() + p.enterPasswordMode() + } + } + + return nil +} + +// handleConnectionStatusUpdate checks if connection succeeded or failed +func (p *WiFiSetupPage) handleConnectionStatusUpdate(status *network.ConnectionStatus) { + if !p.isConnecting { + return + } + + // Check if we successfully connected to our pending SSID + switch status.StatusCode { + case network.StatusWifiConnectedInternetUp: + activeSSID := p.getActiveSSID() + if activeSSID == p.pendingSSID { + p.isConnecting = false + p.pendingSSID = "" + p.connectionError = "" + p.refreshNetworkColors() + } + case network.StatusWifiAvailableNotConnected: + // Connection failed - we're trying to connect but now show as not connected + if time.Since(p.connectionAttemptTime) > 5*time.Second { + p.isConnecting = false + if p.selectedAP != nil && p.selectedAP.IsProtected { + p.connectionError = "Connection failed - Incorrect password?" + p.isEnteringPassword = true + p.passwordInput = "" + p.updatePasswordTexture() + p.updatePasswordPromptTexture() + p.updatePasswordErrorTexture() + p.enterPasswordMode() + } else { + p.connectionError = "Connection failed" + p.pendingSSID = "" + } + } + } +} + +// getActiveSSID queries NetworkManager for the currently active WiFi SSID +func (p *WiFiSetupPage) getActiveSSID() string { + if p.networkManager == nil || p.wifiDevice == nil { + return "" + } + + nmObj := p.networkManager.Conn().Object("org.freedesktop.NetworkManager", "/org/freedesktop/NetworkManager") + prop, err := nmObj.GetProperty("org.freedesktop.NetworkManager.ActiveConnections") + if err != nil { + return "" + } + + if paths, ok := prop.Value().([]dbus.ObjectPath); ok { + for _, path := range paths { + acObj := p.networkManager.Conn().Object("org.freedesktop.NetworkManager", path) + devProp, err := acObj.GetProperty("org.freedesktop.NetworkManager.Connection.Active.Devices") + if err == nil { + if devPaths, ok := devProp.Value().([]dbus.ObjectPath); ok { + for _, devPath := range devPaths { + if string(devPath) == string(p.wifiDevice.Path) { + idProp, err := acObj.GetProperty("org.freedesktop.NetworkManager.Connection.Active.Id") + if err == nil { + if id, ok := idProp.Value().(string); ok { + return id + } + } + } + } + } + } + } + } + return "" +} + +// refreshNetworkColors updates the colors of network items based on active status +func (p *WiFiSetupPage) refreshNetworkColors() { + activeSSID := p.getActiveSSID() + p.activeSSID = activeSSID + + for i := range p.accessPoints { + if p.accessPoints[i].AP.SSID == activeSSID { + p.accessPoints[i].Item.Color = colors.LawnGreen + } else { + p.accessPoints[i].Item.Color = colors.White + } + } +} + +// updateConnectionStatusItem creates the colored status message item. +func (p *WiFiSetupPage) updateConnectionStatusItem() { + if p.connectionStatusItem.ID != 0 { + gl.DeleteTextures(1, &p.connectionStatusItem.ID) + } + + // Show connecting message if in progress + if p.isConnecting { + message := fmt.Sprintf("Connecting to %s...", p.pendingSSID) + item, err := NewStringItem(message, p.applicationFont, colors.Yellow) + if err == nil { + p.connectionStatusItem = item + } + return + } + + // Show connection error if present + if p.connectionError != "" { + item, err := NewStringItem(p.connectionError, p.applicationFont, colors.Red) + if err == nil { + p.connectionStatusItem = item + } + return + } + + if p.connectionStatus == nil { + return + } + + switch p.connectionStatus.StatusCode { + case network.StatusWifiConnectedInternetUp: + message := fmt.Sprintf("Connected to %s - Internet accessible | F1 to exit", p.activeSSID) + item, err := NewStringItem(message, p.applicationFont, colors.LawnGreen) + if err == nil { + p.connectionStatusItem = item + } + p.refreshNetworkColors() + + case network.StatusWifiAvailableNotConnected: + message := "WiFi available - Not connected | Select network or press R to rescan" + item, err := NewStringItem(message, p.applicationFont, colors.Yellow) + if err == nil { + p.connectionStatusItem = item + } + + case network.StatusEthernetConnectedInternetUp: + message := "Ethernet connected - Internet accessible | F1 to exit" + item, err := NewStringItem(message, p.applicationFont, colors.LawnGreen) + if err == nil { + p.connectionStatusItem = item + } + + case network.StatusEthernetNotConnected: + message := "No network connection | Select WiFi network or press R to rescan" + item, err := NewStringItem(message, p.applicationFont, colors.Red) + if err == nil { + p.connectionStatusItem = item + } + + case network.StatusNoDevicesFound: + message := "No network devices found" + item, err := NewStringItem(message, p.applicationFont, colors.Red) + if err == nil { + p.connectionStatusItem = item + } + + case network.StatusError: + message := "Network status check failed" + item, err := NewStringItem(message, p.applicationFont, colors.Red) + if err == nil { + p.connectionStatusItem = item + } + + default: + item, err := NewStringItem(p.connectionStatus.Message, p.applicationFont, colors.White) + if err == nil { + p.connectionStatusItem = item + } + } +} + +// buildNetworkUIList creates the renderable textures for the list of discovered networks. +func (p *WiFiSetupPage) buildNetworkUIList(aps []network.AccessPoint) { + // Get the currently active Wi-Fi SSID + activeSSID := p.getActiveSSID() + p.activeSSID = activeSSID + + // Set IsActive flag based on the actual active SSID + for i := range aps { + aps[i].IsActive = (aps[i].SSID == p.activeSSID) + } + + p.accessPoints = make([]accessPointUIItem, len(aps)) + white := sdl.Color{R: 255, G: 255, B: 255, A: 255} + + for i, ap := range aps { + ssid := ap.SSID + if ap.IsProtected { + ssid += " [L]" + } + color := white + if ap.IsActive { + color = colors.LawnGreen + } + item, err := NewStringItem(ssid, p.applicationFont, color) + if err != nil { + continue + } + p.accessPoints[i] = accessPointUIItem{AP: ap, Item: item} + } +} + +// updatePasswordTexture regenerates the texture for the password input field. +func (p *WiFiSetupPage) updatePasswordTexture() { + if p.passwordInputItem.ID != 0 { + gl.DeleteTextures(1, &p.passwordInputItem.ID) + } + maskedPassword := strings.Repeat("*", len(p.passwordInput)) + if maskedPassword == "" { + maskedPassword = " " + } + item, err := NewStringItem(maskedPassword, p.applicationFont, sdl.Color{R: 255, G: 255, B: 255, A: 255}) + if err == nil { + p.passwordInputItem = item + } +} + +// updatePasswordPromptTexture creates the texture for the password prompt label. +func (p *WiFiSetupPage) updatePasswordPromptTexture() { + if p.passwordPromptItem.ID != 0 { + gl.DeleteTextures(1, &p.passwordPromptItem.ID) + } + prompt := fmt.Sprintf("Password for %s:", p.selectedAP.SSID) + item, err := NewStringItem(prompt, p.applicationFont, sdl.Color{R: 255, G: 255, B: 255, A: 255}) + if err == nil { + p.passwordPromptItem = item + } +} + +// updatePasswordErrorTexture creates the texture for password error message. +func (p *WiFiSetupPage) updatePasswordErrorTexture() { + if p.passwordErrorItem.ID != 0 { + gl.DeleteTextures(1, &p.passwordErrorItem.ID) + } + if p.connectionError != "" { + item, err := NewStringItem(p.connectionError, p.applicationFont, colors.DarkRed) + if err == nil { + p.passwordErrorItem = item + } + } +} + +// Render draws the entire page. +func (p *WiFiSetupPage) Render() error { + // Get base font size from database + baseFontSizeStr, err := db.GetConfigValue("init_font_size") + if err != nil { + return fmt.Errorf("retrieving init_font_size from db: %w", err) + } + baseFontSize, err := strconv.ParseFloat(baseFontSizeStr, 32) + if err != nil { + return fmt.Errorf("parsing init_font_size: %w", err) + } + + // Colors & Config + bgColor := sdl.Color{R: 0, G: 0, B: 0, A: 255} + selectionColor := sdl.Color{R: 68, G: 71, B: 90, A: 255} + white := sdl.Color{R: 255, G: 255, B: 255, A: 255} + verticalMargin := float32(20) + + solidShader, _ := shaderManager.Get().Get("solid_color") + textShader, _ := shaderManager.Get().Get("text") + + // Background + p.Base.RenderSolidColorQuad(solidShader, mgl32.Vec2{0, 0}, mgl32.Vec2{float32(p.ScreenWidth), float32(p.ScreenHeight)}, bgColor) + + // Title + titleScale := float32(48) / float32(baseFontSize) + titleW := float32(p.titleItem.W) * titleScale + titleH := float32(p.titleItem.H) * titleScale + titleX := float32(p.ScreenCenterX) - (titleW / 2) + titleY := float32(p.ScreenHeight) - titleH - 40 + p.Base.RenderTexture(textShader, p.titleItem.ID, mgl32.Vec2{titleX, titleY}, mgl32.Vec2{titleW, titleH}, white) + + // Status message + statusY := titleY - titleH - verticalMargin + if p.isScanning { + statusScale := float32(24) / float32(baseFontSize) + statusW := float32(p.scanningStatusItem.W) * statusScale + statusH := float32(p.scanningStatusItem.H) * statusScale + statusX := float32(p.ScreenCenterX) - (statusW / 2) + p.Base.RenderTexture(textShader, p.scanningStatusItem.ID, mgl32.Vec2{statusX, statusY}, mgl32.Vec2{statusW, statusH}, white) + } else if p.connectionStatusItem.ID != 0 { + statusScale := float32(24) / float32(baseFontSize) + statusW := float32(p.connectionStatusItem.W) * statusScale + statusH := float32(p.connectionStatusItem.H) * statusScale + statusX := float32(p.ScreenCenterX) - (statusW / 2) + p.Base.RenderTexture(textShader, p.connectionStatusItem.ID, mgl32.Vec2{statusX, statusY}, mgl32.Vec2{statusW, statusH}, p.connectionStatusItem.Color) + } + + // Network list + listY := statusY - verticalMargin + if len(p.accessPoints) > 0 { + itemHeight := int32(40) + listPadding := int32(10) + for i, apItem := range p.accessPoints { + itemYpos := listY - float32(int32(i+1)*itemHeight) + itemXpos := float32(p.ScreenCenterX - 350) + itemW := float32(700) + if i == p.selectedIndex { + p.Base.RenderSolidColorQuad(solidShader, mgl32.Vec2{itemXpos, itemYpos}, mgl32.Vec2{itemW, float32(itemHeight)}, selectionColor) + } + + textScale := float32(24) / float32(baseFontSize) + textW := float32(apItem.Item.W) * textScale + textH := float32(apItem.Item.H) * textScale + textY := itemYpos + (float32(itemHeight) / 2) - (textH / 2) + textX := itemXpos + float32(listPadding) + p.Base.RenderTexture(textShader, apItem.Item.ID, mgl32.Vec2{textX, textY}, mgl32.Vec2{textW, textH}, apItem.Item.Color) + } + } + + // Password dialog overlay + if p.isEnteringPassword { + if err := p.renderPasswordDialog(solidShader, textShader, float32(baseFontSize)); err != nil { + return err + } + } + + return nil +} + +// renderPasswordDialog draws the password entry modal. +func (p *WiFiSetupPage) renderPasswordDialog(solidShader, textShader *shaderManager.Shader, baseFontSize float32) error { + overlayColor := sdl.Color{R: 0, G: 0, B: 0, A: 150} + dialogBgColor := sdl.Color{R: 40, G: 42, B: 54, A: 255} + boxBorderColor := sdl.Color{R: 120, G: 120, B: 120, A: 255} + boxBgColor := sdl.Color{R: 30, G: 30, B: 30, A: 255} + white := sdl.Color{R: 255, G: 255, B: 255, A: 255} + + dialogW, dialogH := int32(600), int32(250) + if p.connectionError != "" { + dialogH = int32(300) // Make dialog taller if there's an error + } + dialogX, dialogY := p.ScreenCenterX-(dialogW/2), p.ScreenCenterY-(dialogH/2) + + // Overlay and dialog background + p.Base.RenderSolidColorQuad(solidShader, mgl32.Vec2{0, 0}, mgl32.Vec2{float32(p.ScreenWidth), float32(p.ScreenHeight)}, overlayColor) + p.Base.RenderSolidColorQuad(solidShader, mgl32.Vec2{float32(dialogX), float32(dialogY)}, mgl32.Vec2{float32(dialogW), float32(dialogH)}, dialogBgColor) + + currentY := float32(dialogY+dialogH) - 30 + + // Password error (if exists) - shown at the top in red + if p.passwordErrorItem.ID != 0 { + errorScale := float32(20) / baseFontSize + errorW := float32(p.passwordErrorItem.W) * errorScale + errorH := float32(p.passwordErrorItem.H) * errorScale + errorX := float32(p.ScreenCenterX) - (errorW / 2) + currentY -= errorH + p.Base.RenderTexture(textShader, p.passwordErrorItem.ID, mgl32.Vec2{errorX, currentY}, mgl32.Vec2{errorW, errorH}, colors.DarkRed) + currentY -= 20 + } + + // Password prompt + if p.passwordPromptItem.ID != 0 { + promptScale := float32(24) / baseFontSize + promptW := float32(p.passwordPromptItem.W) * promptScale + promptH := float32(p.passwordPromptItem.H) * promptScale + promptX := float32(p.ScreenCenterX) - (promptW / 2) + currentY -= promptH + p.Base.RenderTexture(textShader, p.passwordPromptItem.ID, mgl32.Vec2{promptX, currentY}, mgl32.Vec2{promptW, promptH}, white) + currentY -= 30 + } + + // Input box + padding, border := int32(4), int32(3) + boxW := int32(500) + targetFontSize := int32(36) + boxH := targetFontSize + (padding * 2) + borderBoxW, borderBoxH := boxW+(border*2), boxH+(border*2) + borderBoxX := p.ScreenCenterX - (borderBoxW / 2) + borderBoxY := int32(currentY) - boxH - (padding * 2) + boxX, boxY := p.ScreenCenterX-(boxW/2), int32(currentY)-boxH-padding + + p.Base.RenderSolidColorQuad(solidShader, mgl32.Vec2{float32(borderBoxX), float32(borderBoxY)}, mgl32.Vec2{float32(borderBoxW), float32(borderBoxH)}, boxBorderColor) + p.Base.RenderSolidColorQuad(solidShader, mgl32.Vec2{float32(boxX), float32(boxY)}, mgl32.Vec2{float32(boxW), float32(boxH)}, boxBgColor) + + // Password input text + if p.passwordInputItem.ID != 0 { + inputScale := float32(targetFontSize) / baseFontSize + inputW := float32(p.passwordInputItem.W) * inputScale + inputH := float32(p.passwordInputItem.H) * inputScale + inputX := float32(boxX + padding) + inputY := float32(boxY + padding) + p.Base.RenderTexture(textShader, p.passwordInputItem.ID, mgl32.Vec2{inputX, inputY}, mgl32.Vec2{inputW, inputH}, white) + } + + return nil +} + +// Destroy cleans up all resources used by the page. +func (p *WiFiSetupPage) Destroy() error { + // Re-enable global keybinds in case we're destroyed during password entry. + keybinds.Enabled = true + + if p.stopScan != nil { + close(p.stopScan) + p.stopScan = nil + } + + p.networkManager.Close() + + gl.DeleteTextures(1, &p.titleItem.ID) + gl.DeleteTextures(1, &p.scanningStatusItem.ID) + if p.connectionStatusItem.ID != 0 { + gl.DeleteTextures(1, &p.connectionStatusItem.ID) + } + if p.passwordPromptItem.ID != 0 { + gl.DeleteTextures(1, &p.passwordPromptItem.ID) + } + if p.passwordInputItem.ID != 0 { + gl.DeleteTextures(1, &p.passwordInputItem.ID) + } + if p.passwordErrorItem.ID != 0 { + gl.DeleteTextures(1, &p.passwordErrorItem.ID) + } + + for _, apItem := range p.accessPoints { + if apItem.Item.ID != 0 { + gl.DeleteTextures(1, &apItem.Item.ID) + } + } + + return p.Base.Destroy() +} diff --git a/internal/pattern/color/colorPatterns.go b/internal/pattern/color/colorPatterns.go new file mode 100644 index 0000000..196c750 --- /dev/null +++ b/internal/pattern/color/colorPatterns.go @@ -0,0 +1,100 @@ +package pattern + +import ( + "github.com/veandco/go-sdl2/sdl" + "rhemawavetech.com/rhemawave/internal/colors" +) + +type ColorPattern struct { + Colors []sdl.Color + colorIndex int + repeatsLeft int + a, b int + increasing bool +} + +func NewColorPattern(colors []sdl.Color) *ColorPattern { + if len(colors) < 2 { + panic("ColorPattern requires at least 2 colors") + } + return &ColorPattern{ + Colors: colors, + a: 0, + b: 1, + increasing: true, + repeatsLeft: 1, // Start with b (1) + } +} + +// ATTENTION: TED +// +// # Fibonacci-Oscillating Temporal Color Distribution for Sequential Text Elements +// +// This method distributes intent-based colors across sequential text elements (words) using an +// oscillating Fibonacci sequence to control temporal color duration, creating rhythmic color +// patterns that maintain visual balance while varying exposure times. +// +// The technology addresses the challenge of applying multiple psychologically-selected colors +// to scrolling text in a way that maintains even distribution over time while creating natural +// rhythm. Conventional approaches either apply colors randomly (creating unbalanced temporal +// distribution) or use fixed intervals (producing mechanical, unnatural patterns that lack +// harmonic variation). Our method ensures each color in the palette appears throughout the +// entire display duration while varying its temporal presence according to natural mathematical +// progression. +// +// The approach uses a bidirectional Fibonacci sequence to determine how many consecutive words +// receive each color. The sequence increases (1, 1, 2, 3, 5, 8, 13, 21, 34, 55 words) then +// decreases back down (55, 34, 21, 13, 8, 5, 3, 2, 1, 1 words), creating an oscillating pattern. +// Colors from the intent-based palette are applied in sequence, with each color's duration +// determined by the current Fibonacci value. This creates a "breathing" rhythm where colors +// appear briefly, expand to longer durations, then contract back to brief appearances before +// cycling to the next color. +// +// Key differentiators from existing solutions: +// - Uses bidirectional Fibonacci sequence (ascending then descending) rather than fixed intervals +// - Creates natural rhythmic variation in color exposure duration +// - Ensures all palette colors appear throughout entire display timeline, not in isolated sections +// - Combines intent-based color selection with mathematical temporal distribution +// - Produces harmonic color rhythm synchronized with natural numerical progression +// +// Within our Rhema Wave generation system, this color distribution works in conjunction with +// the spatially-scrambled character patterns. While the scrambling creates spatial frequency +// signatures, the Fibonacci-oscillating color pattern creates temporal frequency modulation. +// The colors themselves are selected according to color theory principles based on the proclamation's +// psychological intent, and the oscillating Fibonacci distribution ensures these therapeutic colors +// maintain presence throughout the viewing session while creating harmonic temporal rhythm that +// reinforces the overall Rhema Wave effect. +func (c *ColorPattern) Color() sdl.Color { + // 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418 + // This is a failsafe in case this pattern is used but colors are not supplied. Without this check, no text will display due to not having a color + // and becoming translucent. + if len(c.Colors) == 0 { + return colors.White // fallback to white + } + + color := c.Colors[c.colorIndex%len(c.Colors)] + c.repeatsLeft-- + + if c.repeatsLeft <= 0 { + // Move to next color in the palette + c.colorIndex = (c.colorIndex + 1) % len(c.Colors) + + // Update Fibonacci sequence for repeat count + if c.increasing { + c.a, c.b = c.b, c.a+c.b + if c.b > 55 { // Update this threahold to adjust the number of repeats + c.increasing = false + } + } else { + c.a, c.b = c.b-c.a, c.a + if c.a <= 0 { + c.a, c.b = 0, 1 + c.increasing = true + } + } + + c.repeatsLeft = c.b + } + + return color +} diff --git a/internal/pattern/line/fibonacci.go b/internal/pattern/line/fibonacci.go new file mode 100644 index 0000000..f63af7a --- /dev/null +++ b/internal/pattern/line/fibonacci.go @@ -0,0 +1,127 @@ +package pattern + +type FibonacciPattern struct { + masterSequence []int + sequence []int + increasing bool +} + +func init() { + Register("fibonacci", func() LinePattern { + return &FibonacciPattern{ + masterSequence: []int{1, 2, 3, 5, 8, 13, 21}, + sequence: []int{1}, + increasing: true, + } + }) +} + +func (f *FibonacciPattern) Name() string { return "Fibonacci" } + +// ATTENTION: TED +// +// # Fibonacci-Oscillating Spatial Distribution for Sequential Text Display +// +// This method arranges sequential text elements (words from proclamations) into display lines +// where the word count per line follows an oscillating Fibonacci sequence, creating both a +// visual wave pattern in two-dimensional space and ensuring even temporal distribution of +// content segments. +// +// The technology addresses the challenge of displaying repeated proclamation content in a way +// that maintains balanced exposure of all content portions while creating visually dynamic +// spatial patterns. Conventional scrolling text approaches either use fixed line lengths +// (creating uniform, non-dynamic displays) or random word counts (producing unbalanced content +// distribution where some portions appear more frequently than others). Our method ensures +// proclamation content is consumed in progressively sized segments that balance over time while +// creating a natural wave-like visual rhythm. +// +// The approach uses a bidirectional Fibonacci sequence to determine words per line. Starting +// with minimal word count (1, 1 words), the sequence expands (2, 3, 5, 8, 13, 21... words per +// line) until reaching a threshold, then contracts back down (21, 13, 8, 5, 3, 2, 1, 1 words), +// creating an oscillating wave. As lines scroll vertically, this varying horizontal word count +// creates a lateral wave pattern in the two-dimensional display space. Words are drawn sequentially +// from the proclamation text, and the varying segment sizes (1 word, then 2, then 3, then 5, etc.) +// ensure that over multiple oscillation cycles, the entire proclamation content receives balanced +// temporal exposure. +// +// Key differentiators from existing solutions: +// - Uses oscillating Fibonacci sequence for line word counts rather than fixed or random lengths +// - Creates two-dimensional wave pattern from one-dimensional text sequence +// - Ensures mathematical content distribution balance over time through progressive segmentation +// - Produces natural expansion-contraction rhythm synchronized with Fibonacci progression +// - Combines spatial wave formation with temporal content distribution in single mechanism +// +// Within our Rhema Wave generation system, this spatial distribution pattern works in concert +// with the character-level scrambling and color distribution methods. While character scrambling +// creates local spatial frequency patterns and color oscillation creates temporal color rhythm, +// the Fibonacci line length pattern generates a macro-level spatial wave that modulates the +// overall display geometry. The mathematical relationship between line lengths creates harmonic +// spatial progression, and the oscillating nature ensures proclamation content cycles through +// varying exposure durations, contributing to the layered frequency composition of the complete +// Rhema Wave output. +func (f *FibonacciPattern) GetNextLine(words []string, wordIndex *int, ctx *LineRenderContext) []string { + if ctx == nil || len(words) == 0 { + return nil + } + + numWords := f.sequence[len(f.sequence)-1] + targetWidth := int32(ctx.ScreenWidth) + + var line []string + var currentWidth int32 + wordsAdded := 0 + + for wordsAdded < numWords && len(words) > 0 { + if int(*wordIndex) > len(words) { + *wordIndex = 0 + } + word := words[*wordIndex%len(words)] + *wordIndex++ + + if word == "" { + continue + } + + wordWidth := estimateWordWidth(word, ctx.Font, ctx.FontScale) + if len(line) > 0 { + wordWidth += ctx.SpaceWidth + } + + if len(line) == 0 || currentWidth+wordWidth <= int32(float32(targetWidth)*float32(.9)) { + line = append(line, word) + currentWidth += wordWidth + wordsAdded++ + } else { + break + } + } + + // TODO: What should we do here instead? + // A line being longer than the display still needs to be handled, though, it should never happen + // if currentWidth >= ctx.ScreenWidth { + // syscall.Kill(syscall.Getpid(), syscall.SIGTRAP) + // } + + // Update the sequence based on direction + if f.increasing { + if len(f.sequence) < len(f.masterSequence) { + // Grow sequence by appending next Fibonacci number + f.sequence = append(f.sequence, f.masterSequence[len(f.sequence)]) + } else { + // Reached the top, now start shrinking + f.increasing = false + f.sequence = f.sequence[:len(f.sequence)-1] + } + } else { + if len(f.sequence) > 1 { + // Shrink the sequence + f.sequence = f.sequence[:len(f.sequence)-1] + } else { + // Hit bottom, start growing again + f.increasing = true + f.sequence = append(f.sequence, f.masterSequence[1]) // index 1 = second element = 2 + } + } + + return line +} diff --git a/internal/pattern/line/linePatterns.go b/internal/pattern/line/linePatterns.go new file mode 100644 index 0000000..4a04bc8 --- /dev/null +++ b/internal/pattern/line/linePatterns.go @@ -0,0 +1,71 @@ +package pattern + +import ( + "fmt" + + "rhemawavetech.com/rhemawave/internal/fontManager" +) + +type LinePattern interface { + GetNextLine(words []string, wordIndex *int, ctx *LineRenderContext) []string // Generates the next line in the pattern + Name() string // Used to display the name of a LinePattern +} + +// PatternInfo holds the public information about a registered pattern. +type PatternInfo struct { + Key string // The machine-readable key (e.g., "sine") + DisplayName string // The human-readable name for the UI (e.g., "Sine Wave") +} + +type LineRenderContext struct { + ScreenWidth int32 + Font *fontManager.FontEntry + FontScale float32 + SpaceWidth int32 +} + +var Registry = make(map[string]func() LinePattern) + +func Register(name string, constructor func() LinePattern) { + Registry[name] = constructor +} + +func Get(name string) (LinePattern, error) { + constructor, ok := Registry[name] + if !ok { + return nil, fmt.Errorf("failed to find line pattern %s in Registry", name) + } + return constructor(), nil +} + +// ListAvailable returns a slice of info for all registered patterns. +// This is used to build a settings menu. +func ListAvailable() []PatternInfo { + var list []PatternInfo + for key, constructor := range Registry { + pattern := constructor() // Create a temporary instance to get its name + list = append(list, PatternInfo{ + Key: key, + DisplayName: pattern.Name(), + }) + } + return list +} + +// estimateWordWidth provides a basic estimate of the width of a word based on the font and scale. +func estimateWordWidth(word string, font *fontManager.FontEntry, scale float32) int32 { + if font == nil { + // Basic fallback estimate + return int32(float32(len(word)) * 10 * scale) + } + + total := int32(0) + for _, ch := range word { + glyph, ok := fontManager.Get().GetGlyph(font.Name, ch) + if !ok { + continue + } + total += int32(float32(glyph.Advance) * scale) + } + return total +} diff --git a/internal/pattern/line/sineWavePattern.go b/internal/pattern/line/sineWavePattern.go new file mode 100644 index 0000000..fd73e3d --- /dev/null +++ b/internal/pattern/line/sineWavePattern.go @@ -0,0 +1,80 @@ +package pattern + +import ( + "math" + + "rhemawavetech.com/rhemawave/internal/fontManager" +) + +type SineWavePattern struct { + waveStepCounter int +} + +func init() { + Register("sine", func() LinePattern { return &SineWavePattern{} }) +} + +func (s *SineWavePattern) Name() string { return "Sine Wave" } +func (s *SineWavePattern) GetNextLine(words []string, wordIndex *int, ctx *LineRenderContext) []string { + const ( + totalLines = 67 + frequency = 5.0 // cycles across all lines + amplitude = 0.85 // how much wave can scale + baseRatio = 0.03 // minimum line width as % of screen + sharpness = 3.0 // sharpness of the curve + ) + + screenWidth := int32(800) + spaceWidth := int32(10) + font := (*fontManager.FontEntry)(nil) + fontScale := float32(1.0) + + if ctx != nil { + screenWidth = ctx.ScreenWidth + spaceWidth = ctx.SpaceWidth + font = ctx.Font + fontScale = ctx.FontScale + } + + // Sharpen the wave (skinnier troughs) + // raw := (math.Sin(2*math.Pi*frequency*float64(s.waveStepCounter)/totalLines) + 1.0) / 2.0 + // waveVal := math.Pow(raw, sharpness) + angle := 2 * math.Pi * frequency * float64(s.waveStepCounter) / totalLines + waveVal := (math.Sin(angle) + 1.0) / 2.0 + + // Target width in pixels + targetWidth := int32(float64(screenWidth) * (baseRatio + amplitude*waveVal)) + + var line []string + var currentWidth int32 + + for len(words) > 0 { + word := words[*wordIndex%len(words)] + *wordIndex++ + + if word == "" { + continue + } + + wordWidth := estimateWordWidth(word, font, fontScale) + if len(line) > 0 { + wordWidth += spaceWidth + } + + if len(line) == 0 { + // Always include the first word + line = append(line, word) + currentWidth += wordWidth + } else { + // Only add next word if it fits + if currentWidth+wordWidth > targetWidth { + break + } + line = append(line, word) + currentWidth += wordWidth + } + } + + s.waveStepCounter++ + return line +} diff --git a/internal/shaderManager/shaderManager.go b/internal/shaderManager/shaderManager.go new file mode 100644 index 0000000..bd95b92 --- /dev/null +++ b/internal/shaderManager/shaderManager.go @@ -0,0 +1,206 @@ +package shaderManager + +import ( + "fmt" + "os" + "path/filepath" + "strings" + "sync" + + "github.com/go-gl/gl/v3.3-core/gl" + "rhemawavetech.com/rhemawave/internal/db" +) + +// Shader represents a compiled GLSL program and its associated data. +type Shader struct { + Name string + ProgramID uint32 + Render func() // This will be used in the future. + + // Cached uniform locations (looked up once after linking) + LocMVPMatrix int32 + LocTexture int32 + LocTextColor int32 + LocColor int32 +} + +// ShaderManager handles the loading, compiling, and management of GLSL shader programs. +type ShaderManager struct { + shaders map[string]*Shader +} + +var ( + instance *ShaderManager + once sync.Once +) + +// InitShaderManager initializes the ShaderManager singleton. +func InitShaderManager() error { + var err error + once.Do(func() { + sm := &ShaderManager{ + shaders: make(map[string]*Shader), + } + if e := sm.LoadShaders(); e != nil { + err = fmt.Errorf("could not load shaders: %w", e) + return + } + instance = sm + }) + return err +} + +// Get returns the singleton ShaderManager instance. +func Get() *ShaderManager { + if instance == nil { + panic("ShaderManager has not been initialized. Call InitShaderManager at application startup.") + } + return instance +} + +// Get retrieves a compiled Shader object by its name. +func (sm *ShaderManager) Get(name string) (*Shader, bool) { + shader, ok := sm.shaders[name] + return shader, ok +} + +// ListShaders returns all shaders. +func (sm *ShaderManager) ListShaders() map[string]*Shader { + return sm.shaders +} + +// Close deletes all loaded shader programs from the GPU to free up resources. +func (sm *ShaderManager) Close() { + for name, shader := range sm.shaders { + gl.DeleteProgram(shader.ProgramID) + delete(sm.shaders, name) + } +} + +// LoadShaders scans a directory for .vert and .frag files and creates a shader program for each pair. +func (sm *ShaderManager) LoadShaders() error { + // Get assets directory from database + assetsDir, err := db.GetConfigValue("assets_dir") + if err != nil { + return fmt.Errorf("retrieving assets_dir from db: %w", err) + } + + srcDir := filepath.Join(assetsDir, "shaders") + shaderFiles := make(map[string]string) + + err = filepath.Walk(srcDir, func(path string, info os.FileInfo, err error) error { + if err != nil { + return err + } + if !info.IsDir() && strings.HasSuffix(info.Name(), ".vert") { + name := strings.TrimSuffix(info.Name(), ".vert") + shaderFiles[name] = path + } + return nil + }) + if err != nil { + return fmt.Errorf("error walking shader directory: %w", err) + } + + for name, vertPath := range shaderFiles { + fragPath := strings.Replace(vertPath, ".vert", ".frag", 1) + if _, err := os.Stat(fragPath); os.IsNotExist(err) { + continue + } + + programID, err := createShaderProgram(vertPath, fragPath) + if err != nil { + continue + } + + newShader := &Shader{ + Name: name, + ProgramID: programID, + Render: nil, // Render function is not yet assigned. + } + newShader.cacheUniformLocations() + sm.shaders[name] = newShader + } + + return nil +} + +// cacheUniformLocations looks up common uniform locations once and stores them on the Shader. +func (s *Shader) cacheUniformLocations() { + s.LocMVPMatrix = gl.GetUniformLocation(s.ProgramID, gl.Str("u_mvpMatrix\x00")) + s.LocTexture = gl.GetUniformLocation(s.ProgramID, gl.Str("u_texture\x00")) + s.LocTextColor = gl.GetUniformLocation(s.ProgramID, gl.Str("u_textColor\x00")) + s.LocColor = gl.GetUniformLocation(s.ProgramID, gl.Str("u_color\x00")) +} + +// createShaderProgram reads, compiles, and links a vertex and fragment shader from file paths. +func createShaderProgram(vertexPath, fragmentPath string) (uint32, error) { + vertexSource, err := os.ReadFile(vertexPath) + if err != nil { + return 0, fmt.Errorf("reading vertex shader %s: %w", vertexPath, err) + } + fragmentSource, err := os.ReadFile(fragmentPath) + if err != nil { + return 0, fmt.Errorf("reading fragment shader %s: %w", fragmentPath, err) + } + + vertexShader, err := compileShader(string(vertexSource)+"\x00", gl.VERTEX_SHADER) + if err != nil { + return 0, err + } + defer gl.DeleteShader(vertexShader) + + fragmentShader, err := compileShader(string(fragmentSource)+"\x00", gl.FRAGMENT_SHADER) + if err != nil { + return 0, err + } + defer gl.DeleteShader(fragmentShader) + + program := gl.CreateProgram() + gl.AttachShader(program, vertexShader) + gl.AttachShader(program, fragmentShader) + gl.LinkProgram(program) + + var status int32 + gl.GetProgramiv(program, gl.LINK_STATUS, &status) + if status == gl.FALSE { + var logLength int32 + gl.GetProgramiv(program, gl.INFO_LOG_LENGTH, &logLength) + log := strings.Repeat("\x00", int(logLength+1)) + gl.GetProgramInfoLog(program, logLength, nil, gl.Str(log)) + return 0, fmt.Errorf("failed to link program: %v", log) + } + + return program, nil +} + +// compileShader is a helper function that compiles a single shader source string. +func compileShader(source string, shaderType uint32) (uint32, error) { + shader := gl.CreateShader(shaderType) + csources, free := gl.Strs(source) + gl.ShaderSource(shader, 1, csources, nil) + free() + gl.CompileShader(shader) + + var status int32 + gl.GetShaderiv(shader, gl.COMPILE_STATUS, &status) + if status == gl.FALSE { + var logLength int32 + gl.GetShaderiv(shader, gl.INFO_LOG_LENGTH, &logLength) + log := strings.Repeat("\x00", int(logLength+1)) + gl.GetShaderInfoLog(shader, logLength, nil, gl.Str(log)) + + var shaderTypeName string + switch shaderType { + case gl.VERTEX_SHADER: + shaderTypeName = "Vertex" + case gl.FRAGMENT_SHADER: + shaderTypeName = "Fragment" + default: + shaderTypeName = "Unknown" + } + return 0, fmt.Errorf("failed to compile %s shader: %v", shaderTypeName, log) + } + + return shader, nil +} diff --git a/maintainer-guide.md b/maintainer-guide.md new file mode 100644 index 0000000..42685a1 --- /dev/null +++ b/maintainer-guide.md @@ -0,0 +1,796 @@ +# RhemaWave Kiosk Infrastructure — Complete Maintainer Guide + +## Purpose + +This document describes the **complete** infrastructure for building, distributing, and deploying the RhemaWave kiosk application on NixOS. It is written so that a new developer can reconstruct the entire system from scratch on a fresh machine. + +--- + +## Table of Contents + +1. Architecture Overview +2. Repositories +3. Key Files and Secrets — What Lives Where +4. Development Machine Setup (From Scratch) +5. The RhemaWave Flake (Application) +6. The NixConfig Flake (Kiosk System) +7. Binary Cache Setup +8. Caddy Server Configuration +9. Signing Keys +10. Sops-Nix Secrets Management +11. GitHub Access +12. Building and Publishing a New Release +13. Deploying a New Kiosk (nixos-anywhere) +14. Auto-Update System +15. Testing and Debugging +16. Common Errors and Solutions + +--- + +## 1. Architecture Overview + +``` +┌─────────────────────────────────┐ +│ Developer Machine (P15) │ +│ │ +│ RhemaWave repo NixConfig repo│ +│ (Go application) (NixOS cfg) │ +│ │ │ │ +│ nix build nix flake │ +│ nix store sign update │ +│ nix copy git push │ +│ │ │ │ +└─────────┼───────────────┼───────┘ + │ │ + ▼ ▼ +┌─────────────────┐ ┌──────────┐ +│ Web Server │ │ GitHub │ +│ (Caddy) │ │ (private)│ +│ │ │ │ +│ Binary cache: │ │ NixConfig│ +│ repository. │ │ flake │ +│ rhemawavetech │ │ │ +│ .com │ │ RhemaWave│ +│ │ │ flake │ +│ Static files: │ │ │ +│ .narinfo + .nar │ └────┬─────┘ +└────────┬────────┘ │ + │ │ + ▼ ▼ +┌─────────────────────────────────┐ +│ Kiosk Machines │ +│ │ +│ systemd timer (every 15min): │ +│ 1. Fetch NixConfig from │ +│ GitHub │ +│ 2. Evaluate flake │ +│ 3. Download RhemaWave binary │ +│ from binary cache │ +│ 4. nixos-rebuild switch │ +│ │ +│ Cage compositor → RhemaWave │ +│ (fullscreen, locked, no TTY │ +│ switching, auto-restart) │ +└─────────────────────────────────┘ +``` + +--- + +## 2. Repositories + +| Repo | URL | Branch | Contents | +|------|-----|--------|----------| +| RhemaWave | `github:Rhema-Wave-Technologies/RhemaWave` | `dev` | Go application source, `flake.nix` (package + NixOS module), `nixos/module.nix` | +| NixConfig | `github:Rhema-Wave-Technologies/NixConfig` | `main` | NixOS kiosk configuration, disk layout, encrypted secrets, sops config | + +Both repositories are **private**. Access requires a GitHub fine-grained personal access token with read-only Contents permission on both repos. + +--- + +## 3. Key Files and Secrets — What Lives Where + +### On the Developer Machine + +| File | Path | Purpose | Backup? | +|------|------|---------|---------| +| Binary cache private key | `~/Keys/nix/cache/rhemawave/cache-priv-key.pem` | Signs packages for the binary cache | **CRITICAL** — without this, you cannot publish new builds. Back up to encrypted offline storage. | +| Binary cache public key | `~/Keys/nix/cache/rhemawave/cache-pub-key.pem` | Distributed to all client machines for verification | Can be regenerated from private key | +| Sops age private key | `~/Keys/nix/sops/age-key.txt` | Encrypts/decrypts secrets in NixConfig | **CRITICAL** — without this, you cannot edit secrets. Back up to encrypted offline storage. | +| GitHub access token | `~/.config/nix/nix.conf` | Nix uses this to access private GitHub repos | Can be regenerated from GitHub | +| Sops age key env var | `~/.bashrc` | `SOPS_AGE_KEY_FILE=~/Keys/nix/sops/age-key.txt` | Convention only | + +### On the Web Server + +| File | Path | Purpose | +|------|------|---------| +| Binary cache files | `/var/lib/nix-cache/` | Static files served by Caddy | +| `nix-cache-info` | `/var/lib/nix-cache/nix-cache-info` | Metadata file for Nix clients | +| Caddy config | Caddyfile (location varies) | Serves the cache directory | + +The server does **not** need any signing keys. It is a dumb static file host. + +### On Each Kiosk + +| File | Path | Purpose | +|------|------|---------| +| SSH host key (private) | `/etc/ssh/ssh_host_ed25519_key` | Used by sops-nix to decrypt secrets | +| SSH host key (public) | `/etc/ssh/ssh_host_ed25519_key.pub` | Converted to age key for sops `.sops.yaml` | +| Decrypted secrets | `/run/secrets/*` | Runtime-only, never persisted to disk | + +### What to Back Up (Priority Order) + +1. **`~/Keys/nix/cache/rhemawave/cache-priv-key.pem`** — If lost, you must generate a new key pair and update the public key in every kiosk configuration and redeploy. +2. **`~/Keys/nix/sops/age-key.txt`** — If lost, you must re-encrypt all secrets with a new key. +3. **GitHub token** — Easily regenerated, low priority. + +Store backups on an encrypted USB drive or a password manager's secure notes. Never store these in any Git repository, cloud drive, or unencrypted medium. + +--- + +## 4. Development Machine Setup (From Scratch) + +Starting from a fresh NixOS installation on a development machine. + +### 4.1 NixOS Configuration Prerequisites + +In your system `configuration.nix`: + +```nix +nix.settings = { + experimental-features = [ "nix-command" "flakes" ]; + trusted-users = [ "root" "yourusername" ]; + substituters = [ + "https://cache.nixos.org" + "https://repository.rhemawavetech.com" + ]; + trusted-public-keys = [ + "cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY=" + "repository.rhemawavetech.com-1:hbaEpYz5jE9SeNgkF2jAgjMtjXzruj7lEk6Lvx9ll40=" + ]; +}; +nixpkgs.config.allowUnfree = true; +``` + +Rebuild: `sudo nixos-rebuild switch` + +### 4.2 Add the RhemaWave Flake to Your System Config + +In your system `flake.nix`, add the input and package: + +```nix +inputs.rhemawave = { + url = "github:Rhema-Wave-Technologies/RhemaWave/dev"; + inputs.nixpkgs.follows = "nixpkgs"; +}; +``` + +Add `rhemawave` to the `outputs` function arguments, then add to a module: + +```nix +{ + environment.systemPackages = [ + rhemawave.packages.x86_64-linux.default + ]; +} +``` + +### 4.3 GitHub Access Token + +Generate a fine-grained personal access token at `github.com/settings/tokens`: +- Resource owner: `Rhema-Wave-Technologies` +- Repository access: Select `NixConfig` and `RhemaWave` +- Permissions: Contents → Read-only +- Expiration: Set as appropriate + +Configure Nix to use it: + +```bash +mkdir -p ~/.config/nix +echo "access-tokens = github.com=YOUR_TOKEN_HERE" > ~/.config/nix/nix.conf +``` + +Also copy to root (needed for `sudo` operations): + +```bash +sudo mkdir -p /root/.config/nix +sudo cp ~/.config/nix/nix.conf /root/.config/nix/nix.conf +``` + +### 4.4 Signing Keys + +If you're taking over from an existing maintainer, obtain: +- `cache-priv-key.pem` → save to `~/Keys/nix/cache/rhemawave/cache-priv-key.pem` +- `age-key.txt` → save to `~/Keys/nix/sops/age-key.txt` + +If starting fresh (new cache): + +```bash +mkdir -p ~/Keys/nix/cache/rhemawave +nix key generate-secret --key-name repository.rhemawavetech.com-1 > ~/Keys/nix/cache/rhemawave/cache-priv-key.pem +nix key convert-secret-to-public < ~/Keys/nix/cache/rhemawave/cache-priv-key.pem > ~/Keys/nix/cache/rhemawave/cache-pub-key.pem +``` + +If starting fresh (new sops key): + +```bash +mkdir -p ~/Keys/nix/sops +nix shell nixpkgs#age -c age-keygen -o ~/Keys/nix/sops/age-key.txt +``` + +Note the public key (starts with `age1...`) — it goes in `.sops.yaml`. + +### 4.5 Sops Environment Variable + +Add to `~/.bashrc`: + +```bash +echo 'export SOPS_AGE_KEY_FILE=~/Keys/nix/sops/age-key.txt' >> ~/.bashrc +source ~/.bashrc +``` + +### 4.6 Clone the Repositories + +```bash +mkdir -p ~/Work/RhemaWave +cd ~/Work/RhemaWave +git clone git@github.com:Rhema-Wave-Technologies/RhemaWave.git +git clone git@github.com:Rhema-Wave-Technologies/NixConfig.git +``` + +### 4.7 Verify Everything Works + +```bash +# Test GitHub access +cd ~/Work/RhemaWave/NixConfig +nix flake show github:Rhema-Wave-Technologies/NixConfig + +# Test RhemaWave build +cd ~/Work/RhemaWave/RhemaWave +nix build .#default + +# Test binary runs +./result/bin/rhemawave + +# Test secrets decryption +cd ~/Work/RhemaWave/NixConfig +SOPS_AGE_KEY_FILE=~/Keys/nix/sops/age-key.txt nix shell nixpkgs#sops -c sops secrets.yaml +# Should open in editor with plaintext values +# Close without saving +``` + +--- + +## 5. The RhemaWave Flake (Application) + +Located at `~/Work/RhemaWave/RhemaWave/flake.nix`. + +### Key Points + +- Uses `buildGoModule` with `vendorHash = null` (vendor directory committed to repo) +- CGo is enabled (`env.CGO_ENABLED = "1"`) +- SDL2 mixer/ttf/image flags are set in `preBuild` via `pkg-config` +- The `share/` directory is copied to `$out/share` in `postInstall` +- License is set to `unfree` — consumers must set `allowUnfreePredicate` +- Exports `nixosModules.default` (the kiosk module) alongside per-system packages and dev shells + +### Flake Outputs + +| Output | Description | +|--------|-------------| +| `packages..default` | The RhemaWave binary | +| `devShells..default` | Development shell with Go + SDL2 deps | +| `nixosModules.default` | NixOS module for kiosk configuration (greetd, cage, PipeWire, polkit) | + +### The NixOS Module (`nixos/module.nix`) + +Imported via `import ./nixos/module.nix self` — the `self` argument gives the module access to the flake's packages. The module exposes `services.rhemawave.*` options. + +--- + +## 6. The NixConfig Flake (Kiosk System) + +Located at `~/Work/RhemaWave/NixConfig/flake.nix`. + +### Flake Inputs + +```nix +nixpkgs → github:NixOS/nixpkgs/nixpkgs-unstable +disko → github:nix-community/disko +nixos-facter → github:numtide/nixos-facter-modules +rhemawave → github:Rhema-Wave-Technologies/RhemaWave/dev +sops-nix → github:Mic92/sops-nix +``` + +All inputs follow `nixpkgs` to ensure a single nixpkgs version. + +### System Configuration Modules + +The NixOS system (`rhemawavekiosk`) loads these modules: +1. `disko.nixosModules.disko` — disk partitioning +2. `rhemawave.nixosModules.default` — RhemaWave kiosk module +3. `sops-nix.nixosModules.sops` — secrets management +4. `./configuration.nix` — main system config +5. Hardware facter report +6. Inline module adding `rhemawave.packages.x86_64-linux.default` to `environment.systemPackages` + +--- + +## 7. Binary Cache Setup + +### What It Is + +A Nix binary cache is a static HTTP file server with a specific directory structure. When a NixOS machine needs a package, it checks each configured cache by making HTTP GET requests for `.narinfo` files. If found and the signature is valid, it downloads the pre-built `.nar.xz` archive instead of building from source. + +### Directory Structure + +``` +/var/lib/nix-cache/ +├── nix-cache-info # Cache metadata +├── fv5iinvsldz9l2s8ikm0mw8ykhriad1g.narinfo # Package metadata + signature +├── nar/ +│ └── 1j7d9cif4xjq7i5rw5dmivxyninh7z1cm7zvdknsp8vjd9rjmzkc.nar.xz # Compressed package +└── ... (more .narinfo and .nar.xz files) +``` + +### nix-cache-info + +``` +StoreDir: /nix/store +WantMassQuery: 1 +Priority: 40 +``` + +This file must exist at the root. `Priority: 40` means this cache is checked after the official NixOS cache (priority 30). + +### Creating the Cache (One-Time) + +If setting up a new cache server: + +```bash +# On the server +sudo mkdir -p /var/lib/nix-cache +cat > /var/lib/nix-cache/nix-cache-info < cache-priv-key.pem +nix key convert-secret-to-public < cache-priv-key.pem > cache-pub-key.pem +``` + +### Deriving Public Key from Private Key + +```bash +nix key convert-secret-to-public < ~/Keys/nix/cache/rhemawave/cache-priv-key.pem +``` + +This outputs the public key string. It should match what's in every client's `trusted-public-keys`. + +### Current Public Key + +``` +repository.rhemawavetech.com-1:hbaEpYz5jE9SeNgkF2jAgjMtjXzruj7lEk6Lvx9ll40= +``` + +--- + +## 10. Sops-Nix Secrets Management + +### How It Works + +1. Secrets are encrypted in `secrets.yaml` using age public keys +2. `.sops.yaml` defines which keys can encrypt/decrypt +3. Each kiosk's SSH host key is converted to an age key for decryption +4. On activation, sops-nix decrypts secrets and places them at `/run/secrets/` + +### .sops.yaml + +```yaml +keys: + - &admin age1ptpn9zee8x7vjaaktx9dv65vysdjfmmgtj96wc3l49vd8g8huy6syk8l26 + - &kiosk-dev age1nmn0r66hl24wrz73q5htt0r90vfse9dvyjwae2evqwrealfgycfsy3apmy +creation_rules: + - path_regex: secrets\.yaml$ + key_groups: + - age: + - *admin + - *kiosk-dev +``` + +### Adding a New Kiosk + +1. Get the kiosk's SSH host public key: + ```bash + ssh root@KIOSK_IP "cat /etc/ssh/ssh_host_ed25519_key.pub" + ``` + +2. Convert to age key: + ```bash + nix shell nixpkgs#ssh-to-age -c ssh-to-age < <(ssh root@KIOSK_IP "cat /etc/ssh/ssh_host_ed25519_key.pub") + ``` + +3. Add the age key to `.sops.yaml` under `keys:` with a descriptive anchor (e.g., `&kiosk-prod-001`) + +4. Add the anchor reference to the creation rule's age list + +5. Re-encrypt secrets with the new key: + ```bash + SOPS_AGE_KEY_FILE=~/Keys/nix/sops/age-key.txt nix shell nixpkgs#sops -c sops updatekeys secrets.yaml + ``` + +6. Commit and push `.sops.yaml` and `secrets.yaml` + +### Editing Secrets + +```bash +cd ~/Work/RhemaWave/NixConfig +SOPS_AGE_KEY_FILE=~/Keys/nix/sops/age-key.txt nix shell nixpkgs#sops -c sops secrets.yaml +``` + +The file opens in your editor with plaintext values. Edit, save, close — sops re-encrypts automatically. + +### Secret Format for github-token + +The `github-token` secret must contain the full nix.conf line (because it's included via `!include`): + +```yaml +github-token: "access-tokens = github.com=ghp_yourtokenhere" +``` + +--- + +## 11. GitHub Access + +### Developer Machine + +The token is stored in `~/.config/nix/nix.conf`: + +``` +access-tokens = github.com=YOUR_TOKEN_HERE +``` + +Also needs to be in `/root/.config/nix/nix.conf` for `sudo` operations. + +Flake URLs use the `github:` scheme (not `git+https://`), which reads the `access-tokens` setting. + +### Kiosk Machines + +The token is managed via sops-nix and included in `nix.conf` via `!include /run/secrets/github-token`. + +### Token Scope + +Fine-grained personal access token: +- Resource owner: `Rhema-Wave-Technologies` +- Repositories: `NixConfig`, `RhemaWave` +- Permissions: Contents → Read-only + +--- + +## 12. Building and Publishing a New Release + +Complete procedure, every command, in order. All commands run on your development machine. + +### Step 1: Commit Application Changes + +```bash +cd ~/Work/RhemaWave/RhemaWave + +# If go.mod/go.sum changed: +nix shell nixpkgs#go -c go mod vendor +git add vendor/ + +git add -A +git commit -m "your changes" +git push origin dev +``` + +### Step 2: Build + +```bash +nix build .#default +``` + +### Step 3: Sign + +```bash +nix store sign --key-file ~/Keys/nix/cache/rhemawave/cache-priv-key.pem $(nix path-info ./result) +``` + +### Step 4: Export to Cache Format + +```bash +rm -rf /tmp/nix-cache +nix copy --to file:///tmp/nix-cache ./result --secret-key-files ~/Keys/nix/cache/rhemawave/cache-priv-key.pem +``` + +### Step 5: Verify Signature + +```bash +cat /tmp/nix-cache/*.narinfo | grep Sig +``` + +Must show `Sig: repository.rhemawavetech.com-1:...` + +### Step 6: Upload to Server + +```bash +rsync -av /tmp/nix-cache/ YOUR_USER@your-server:/var/lib/nix-cache/ +``` + +### Step 7: Bump NixConfig + +```bash +cd ~/Work/RhemaWave/NixConfig +nix flake update rhemawave +git add flake.lock +git commit -m "bump rhemawave" +git push +``` + +### Step 8: Wait + +Kiosks pick up the update within 15 minutes via the auto-update timer. + +--- + +## 13. Deploying a New Kiosk (nixos-anywhere) + +### Prerequisites + +- Target machine booted from NixOS installer USB +- SSH access to the target as root +- Target's IP address known + +### Procedure + +From your development machine: + +```bash +cd ~/Work/RhemaWave/NixConfig + +# Deploy +nix run github:nix-community/nixos-anywhere -- --flake .#rhemawavekiosk root@TARGET_IP +``` + +This: +1. kexec's into the NixOS installer on the target +2. Partitions the disk according to `disk-config.nix` +3. Installs NixOS with the full kiosk configuration +4. Reboots + +**Note:** Uses the local flake (`.#`) so it can access local files and secrets. The `--flake` path must be the NixConfig directory. + +### After Deployment + +1. Get the kiosk's age key (see section 10, "Adding a New Kiosk") +2. Add it to `.sops.yaml` and re-encrypt secrets +3. Push changes +4. The kiosk will pick up the updated secrets on its next auto-update cycle + +### If nixos-rebuild --target-host Fails with Bootloader Errors + +Use the manual three-step deploy instead: + +```bash +nix build .#nixosConfigurations.rhemawavekiosk.config.system.build.toplevel +nix copy --to ssh://root@TARGET_IP ./result +ssh root@TARGET_IP "$(readlink -f ./result)/bin/switch-to-configuration switch" +``` + +--- + +## 14. Auto-Update System + +### How It Works + +Each kiosk runs a systemd timer (`kiosk-auto-update.timer`) that fires every 15 minutes. The associated service runs: + +```bash +nixos-rebuild switch --flake github:Rhema-Wave-Technologies/NixConfig#rhemawavekiosk +``` + +This: +1. Fetches the latest NixConfig flake from GitHub (using the encrypted GitHub token) +2. Evaluates the configuration (including the pinned RhemaWave version from `flake.lock`) +3. Checks the binary cache for pre-built packages +4. Downloads any new packages +5. Switches to the new configuration + +### What Triggers an Update + +An update is triggered when either: +- `flake.lock` changes (new RhemaWave version pinned) +- `configuration.nix` or other NixConfig files change +- Any flake input is updated + +If nothing has changed, `nixos-rebuild` is a no-op. + +### Monitoring + +```bash +# Check timer status +ssh root@KIOSK_IP "systemctl status kiosk-auto-update.timer" + +# Check last update result +ssh root@KIOSK_IP "systemctl status kiosk-auto-update.service" + +# Full update logs +ssh root@KIOSK_IP "journalctl -u kiosk-auto-update -n 100" +``` + +### Force Immediate Update + +```bash +ssh root@KIOSK_IP "systemctl start kiosk-auto-update" +``` + +--- + +## 15. Testing and Debugging + +### SSH into a Running Kiosk + +Even with the kiosk locked down (cage compositor, single TTY), SSH always works: + +```bash +ssh root@KIOSK_IP +``` + +### Check What's Running + +```bash +ssh root@KIOSK_IP "systemctl status greetd" +ssh root@KIOSK_IP "systemctl status kiosk-auto-update.timer" +ssh root@KIOSK_IP "ls -la /run/secrets/" +ssh root@KIOSK_IP "cat /run/secrets/wifi-psk" # verify decryption +``` + +### Check Binary Cache Connectivity + +```bash +ssh root@KIOSK_IP "curl -s https://repository.rhemawavetech.com/nix-cache-info" +``` + +### Check GitHub Connectivity + +```bash +ssh root@KIOSK_IP "cat /etc/nix/nix.conf | grep access-tokens" +``` + +### Restart the Kiosk Application + +If the application crashes or you want to restart it without a full reboot: + +```bash +ssh root@KIOSK_IP "systemctl restart greetd" +``` + +greetd will restart, auto-login the kiosk user, and re-launch rhemawave in cage. + +### View Application Logs + +```bash +ssh root@KIOSK_IP "journalctl -u greetd -n 100" +``` + +### Test a Configuration Change Without Pushing + +Build and deploy directly from your development machine: + +```bash +cd ~/Work/RhemaWave/NixConfig +nix build .#nixosConfigurations.rhemawavekiosk.config.system.build.toplevel +nix copy --to ssh://root@KIOSK_IP ./result +ssh root@KIOSK_IP "$(readlink -f ./result)/bin/switch-to-configuration switch" +``` + +--- + +## 16. Common Errors and Solutions + +### `env attribute set cannot contain any attributes passed to derivation` + +**Cause:** `CGO_ENABLED` set as both a top-level attribute and in `env`. +**Fix:** Use only `env.CGO_ENABLED = "1";` in the `buildGoModule` block. + +### `vendor/modules.txt` inconsistency + +**Cause:** `go.mod` changed but `vendor/` wasn't updated. +**Fix:** Run `nix shell nixpkgs#go -c go mod vendor`, then `git add vendor/` and commit. + +### `unfree license, refusing to evaluate` + +**Cause:** Missing `allowUnfreePredicate` in the nixpkgs config. +**Fix:** Add `config.allowUnfreePredicate = pkg: (nixpkgs.lib.getName pkg) == "rhemawave";` to the `pkgs` import. + +### `warning: ignoring the client-specified setting 'secret-key-files'` + +**Cause:** Your user isn't in `trusted-users`. +**Fix:** Add your username to `nix.settings.trusted-users` and rebuild your NixOS system. + +### `invalid character in Base64 string` + +**Cause:** The `trusted-public-keys` value is malformed — likely doubled key name or invisible characters. +**Fix:** Regenerate the public key: `nix key convert-secret-to-public < cache-priv-key.pem` and paste it fresh into the config. + +### `attribute 'nixosModules' missing` + +**Cause:** The `flake.lock` points to an old RhemaWave commit that doesn't export `nixosModules`. +**Fix:** Run `nix flake update rhemawave` in the NixConfig directory. + +### `path '/home/...' is forbidden in pure evaluation mode` + +**Cause:** Using absolute paths (like `builtins.readFile /home/...`) in a flake. Flakes evaluate in pure mode. +**Fix:** Use relative paths (`./file.txt`) or manage secrets with sops-nix. + +### `access to absolute path '/home' is forbidden` + +**Cause:** Same as above — `readFile` with an absolute path. +**Fix:** Use sops-nix for secrets or deploy with the local flake (`.#`) instead of `github:`. + +### Bootloader errors during remote `nixos-rebuild --target-host` + +**Cause:** GRUB can't detect the disk layout properly over SSH. +**Fix:** Use the three-step manual deploy: `nix build` → `nix copy --to ssh://` → `switch-to-configuration switch`. + +### SSH host key changed warning + +**Cause:** After reinstalling a kiosk, its SSH host key changes. +**Fix:** `ssh-keygen -R KIOSK_IP` to remove the old key, then reconnect. + +### Auto-update not working on kiosk + +**Check:** +1. Timer is active: `systemctl status kiosk-auto-update.timer` +2. Service logs: `journalctl -u kiosk-auto-update -n 50` +3. GitHub token is decrypted: `cat /etc/nix/nix.conf | grep access-tokens` +4. Network connectivity: `curl https://github.com` +5. Cache connectivity: `curl https://repository.rhemawavetech.com/nix-cache-info` diff --git a/nixos/module.nix b/nixos/module.nix new file mode 100644 index 0000000..6da3ba5 --- /dev/null +++ b/nixos/module.nix @@ -0,0 +1,83 @@ +self: + +{ config, lib, pkgs, ... }: + +let + cfg = config.services.rhemawave; +in +{ + options.services.rhemawave = { + enable = lib.mkEnableOption "RhemaWave kiosk application"; + + package = lib.mkOption { + type = lib.types.package; + default = self.packages.${pkgs.system}.default; + description = "The RhemaWave package to use."; + }; + + # There should not be a "kioskUser" defined in the program + # That should be defined by the system, so everything kioskUser related + # has been commented out. + + user = lib.mkOption { + type = lib.types.str; + default = "kiosk"; + description = "User account that runs the kiosk session."; + }; + + # extraGroups = lib.mkOption { + # type = lib.types.listOf lib.types.str; + # default = []; + # description = "Additional groups for the kiosk user."; + # }; + + autoVolume = lib.mkOption { + type = lib.types.bool; + default = true; + description = "Set all PipeWire sinks to full volume before launching."; + }; + }; + + config = lib.mkIf cfg.enable { + # # --- Kiosk user --- + # users.users.${cfg.kioskUser} = { + # isNormalUser = true; + # group = cfg.kioskUser; + # extraGroups = [ "audio" "video" "input" "networkmanager" ] ++ cfg.extraGroups; + # }; + # users.groups.${cfg.kioskUser} = {}; + + # --- Display: agetty + cage --- + + + # --- Environment --- + environment.variables.SDL_VIDEODRIVER = "wayland"; + + # --- Networking --- + networking.networkmanager.enable = true; + + # --- Audio: PipeWire + WirePlumber --- + services.pipewire = { + enable = true; + alsa.enable = true; + pulse.enable = true; + wireplumber.enable = true; + }; + + # --- Polkit rules --- + security.polkit.extraConfig = '' + polkit.addRule(function(action, subject) { + // Allow restarting getty@tty1 + if (action.id == "org.freedesktop.systemd1.manage-units") { + var unit = action.lookup("unit"); + if (unit == "getty@tty1.service") { + return polkit.Result.YES; + } + } + }); + ''; + + # --- Make the package available system-wide --- + environment.systemPackages = [ cfg.package ]; + }; +} diff --git a/packaging/kiosk/99-rhemawave-updater.rules b/packaging/kiosk/99-rhemawave-updater.rules new file mode 100644 index 0000000..9cdbc4f --- /dev/null +++ b/packaging/kiosk/99-rhemawave-updater.rules @@ -0,0 +1,55 @@ +// Allow kiosk user to run apt update, apt install for rhemawave packages, +// and restart getty for application reloading +polkit.addRule(function(action, subject) { + if (action.id == "org.freedesktop.policykit.exec" && + subject.user == "kiosk") { + + var program = action.lookup("program"); + var cmdline = action.lookup("command_line"); + + // Allow dpkg --configure -a + if (program == "/usr/bin/dpkg") { + if (cmdline && cmdline.indexOf("--configure") >= 0) { + return polkit.Result.YES; + } + } + + // Allow apt update + if (program == "/usr/bin/apt") { + if (cmdline && cmdline.indexOf("update") >= 0) { + return polkit.Result.YES; + } + + // Allow: apt install --only-upgrade rhemawave[-dev] + if (cmdline && + cmdline.indexOf("install") >= 0 && + cmdline.indexOf("--only-upgrade") >= 0 && + cmdline.indexOf("rhemawave") >= 0) { + return polkit.Result.YES; + } + } + + // Allow systemctl restart getty@tty1.service + if (program == "/usr/bin/systemctl") { + if (cmdline && + cmdline.indexOf("restart") >= 0 && + cmdline.indexOf("getty@tty1.service") >= 0) { + return polkit.Result.YES; + } + } + + // Allow sh for Tailscale install script + if (program == "/usr/bin/sh" || program == "/bin/sh") { + if (cmdline && cmdline.indexOf("tailscale.com/install.sh") >= 0) { + return polkit.Result.YES; + } + } + + // Allow tailscale set --operator + if (program == "/usr/bin/tailscale") { + if (cmdline && cmdline.indexOf("set") >= 0 && cmdline.indexOf("--operator") >= 0) { + return polkit.Result.YES; + } + } + } +}); \ No newline at end of file diff --git a/packaging/kiosk/override.conf b/packaging/kiosk/override.conf new file mode 100644 index 0000000..5470b4e --- /dev/null +++ b/packaging/kiosk/override.conf @@ -0,0 +1,3 @@ +[Service] +ExecStart= +ExecStart=-/sbin/agetty --autologin kiosk --noclear %I $TERM \ No newline at end of file diff --git a/packaging/kiosk/post-install.sh b/packaging/kiosk/post-install.sh new file mode 100755 index 0000000..b1cb9aa --- /dev/null +++ b/packaging/kiosk/post-install.sh @@ -0,0 +1,24 @@ +#!/bin/bash +# Post-installation script for RhemaWave +set -e + +# Create kiosk group if it doesn't exist +if ! getent group kiosk > /dev/null 2>&1; then + echo "Creating kiosk group..." + groupadd --system kiosk +fi + +# Create kiosk user if it doesn't exist +if ! getent passwd kiosk > /dev/null 2>&1; then + echo "Creating kiosk user..." + useradd --system --gid kiosk --create-home --home-dir /home/kiosk \ + --shell /bin/bash --comment "RhemaWave Kiosk User" kiosk +fi + +# Set proper group ownership for writable directories +chgrp -R kiosk /usr/local/share/rhemawave + +# Ensure kiosk user can write to the data directory +chmod g+w /usr/local/share/rhemawave + +echo "✓ RhemaWave post-install complete" \ No newline at end of file diff --git a/packaging/kiosk/rhemawave-kiosk.sh b/packaging/kiosk/rhemawave-kiosk.sh new file mode 100755 index 0000000..911f67d --- /dev/null +++ b/packaging/kiosk/rhemawave-kiosk.sh @@ -0,0 +1,16 @@ +# RhemaWave kiosk auto-launch on tty1 +if [ -z "$WAYLAND_DISPLAY" ] && [ "$(tty)" = "/dev/tty1" ]; then + export XDG_RUNTIME_DIR=/run/user/$(id -u) + export SDL_VIDEODRIVER=wayland + + # Check for updates before launching + /usr/bin/python3 /usr/local/bin/rhemawave-updater.py || true + + # Set all sinks to full volume + for sink in $(wpctl status | grep -oP '^\s+\K\d+(?=\.)' | head -10); do + wpctl set-volume "$sink" 1.0 2>/dev/null + done + + exec cage -- /usr/local/bin/rhemawave +fi + diff --git a/packaging/rhemawave-updater.py b/packaging/rhemawave-updater.py new file mode 100755 index 0000000..42ed895 --- /dev/null +++ b/packaging/rhemawave-updater.py @@ -0,0 +1,564 @@ +#!/usr/bin/env python3 +""" +rhemawave-updater.py + +Auto-updater for RhemaWave kiosk application. +Uses apt to check for and install updates from the configured repository. + +USAGE: + Run as kiosk user: + python3 /usr/local/bin/rhemawave-updater.py +""" + +import sys +import subprocess +import json +import socket +import urllib.request +from pathlib import Path +from datetime import datetime + +# Configuration - templated by build script +PACKAGE_NAME = "__CHANNEL__" +HEADSCALE_URL = "https://headscale.rhemawavetech.com" +HEADSCALE_AUTHKEY = "803130d5b2e38bffa9fa5b6921a3d6403100e2e30fea1bd5" + +# Paths +LOG_FILE = Path("/home/kiosk/rhemawave-updater.log") +LICENSE_KEY_PATH = Path.home() / ".local/share/rhemawave/license_key" + + +class UpdaterLogger: + """Simple logger that writes to both stdout and file""" + + def __init__(self, log_file): + self.log_file = log_file + log_file.parent.mkdir(parents=True, exist_ok=True) + log_file.touch(exist_ok=True) + + def log(self, message): + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + formatted = f"[{timestamp}] {message}" + print(formatted) + try: + with open(self.log_file, 'a') as f: + f.write(formatted + '\n') + except IOError: + pass + + def error(self, message): + self.log(f"ERROR: {message}") + + def debug(self, message): + self.log(f"DEBUG: {message}") + + def success(self, message): + self.log(f"✓ {message}") + + +logger = UpdaterLogger(LOG_FILE) + + +def check_network(timeout=2): + """Quick check for internet connectivity.""" + logger.log("Checking network connectivity...") + try: + socket.create_connection(("1.1.1.1", 53), timeout=timeout) + logger.success("Network check passed (1.1.1.1:53 reachable)") + return True + except OSError as e: + logger.error(f"Network check failed: {e}") + return False + + +def run_command(cmd, description, use_pkexec=False): + """Run a command and return success status""" + if use_pkexec: + cmd = ["pkexec"] + cmd + + logger.log(f"{description}...") + logger.debug(f"Command: {' '.join(cmd)}") + + try: + result = subprocess.run( + cmd, + capture_output=True, + text=True, + timeout=300 + ) + + logger.debug(f"Return code: {result.returncode}") + + if result.stdout: + for line in result.stdout.splitlines(): + logger.log(f" {line}") + + if result.returncode != 0: + logger.error(f"{description} failed with return code {result.returncode}") + if result.stderr: + for line in result.stderr.splitlines(): + logger.error(f" {line}") + return False + + logger.success(f"{description} completed successfully") + return True + + except subprocess.TimeoutExpired: + logger.error(f"{description} timed out") + return False + except Exception as e: + logger.error(f"{description} failed: {e}") + return False + + +def configure_dpkg(): + logger.log("Checking for dpkg errors") + if not run_command( + ["dpkg", "--configure", "-a"], + 'Check for dpkg configuration errors and resolve them before performing updates', + use_pkexec=True): + logger.error("Unable to reconfigure system, please reach out to support!") + return + + +def is_tailscale_installed(): + """Check if Tailscale is installed.""" + logger.log("Checking if Tailscale is installed...") + try: + result = subprocess.run( + ["tailscale", "version"], + capture_output=True, + text=True, + check=True + ) + version = result.stdout.strip() + logger.success(f"Tailscale is installed: {version}") + return True + except FileNotFoundError: + logger.log("Tailscale binary not found") + return False + except subprocess.CalledProcessError as e: + logger.error(f"Tailscale version check failed: {e}") + return False + + +def install_tailscale(): + """Install Tailscale.""" + logger.log("Installing Tailscale...") + try: + logger.debug("Running: pkexec sh -c 'curl -fsSL https://tailscale.com/install.sh | sh'") + result = subprocess.run( + ["pkexec", "sh", "-c", "curl -fsSL https://tailscale.com/install.sh | sh"], + capture_output=True, + text=True, + timeout=120 + ) + logger.debug(f"Install return code: {result.returncode}") + if result.stdout: + for line in result.stdout.splitlines(): + logger.log(f" {line}") + if result.stderr: + for line in result.stderr.splitlines(): + logger.log(f" [stderr] {line}") + + if result.returncode != 0: + logger.error("Tailscale installation failed") + return False + + logger.success("Tailscale installed successfully") + return True + except subprocess.TimeoutExpired: + logger.error("Tailscale installation timed out") + return False + except subprocess.CalledProcessError as e: + logger.error(f"Tailscale installation failed: {e}") + if e.stderr: + logger.error(f"stderr: {e.stderr}") + return False + + +def set_tailscale_operator(): + """Set Tailscale operator to kiosk.""" + logger.log("Setting Tailscale operator to 'kiosk'...") + try: + result = subprocess.run( + ["pkexec", "tailscale", "set", "--operator=kiosk"], + capture_output=True, + text=True, + timeout=30 + ) + logger.debug(f"Return code: {result.returncode}") + if result.stdout: + logger.debug(f"stdout: {result.stdout}") + if result.stderr: + logger.debug(f"stderr: {result.stderr}") + + if result.returncode != 0: + logger.error(f"Failed to set operator: {result.stderr}") + return False + + logger.success("Tailscale operator set to 'kiosk'") + return True + except Exception as e: + logger.error(f"Failed to set Tailscale operator: {e}") + return False + + +def get_tailscale_status(): + """Get full Tailscale status as dict.""" + logger.log("Getting Tailscale status...") + try: + result = subprocess.run( + ["tailscale", "status", "--json"], + capture_output=True, + text=True, + timeout=10 + ) + logger.debug(f"Return code: {result.returncode}") + + if result.returncode != 0: + logger.error(f"tailscale status failed: {result.stderr}") + return None + + status = json.loads(result.stdout) + + # Log key status info + backend_state = status.get("BackendState", "unknown") + logger.log(f" BackendState: {backend_state}") + + self_info = status.get("Self", {}) + if self_info: + logger.log(f" HostName: {self_info.get('HostName', 'unknown')}") + logger.log(f" DNSName: {self_info.get('DNSName', 'unknown')}") + logger.log(f" Online: {self_info.get('Online', 'unknown')}") + tailscale_ips = self_info.get("TailscaleIPs", []) + logger.log(f" TailscaleIPs: {tailscale_ips}") + + # Check for health issues + health = status.get("Health", []) + if health: + logger.log(" Health issues:") + for issue in health: + logger.log(f" - {issue}") + + return status + except json.JSONDecodeError as e: + logger.error(f"Failed to parse Tailscale status JSON: {e}") + return None + except subprocess.TimeoutExpired: + logger.error("Tailscale status timed out") + return None + except Exception as e: + logger.error(f"Failed to get Tailscale status: {e}") + return None + + +def is_tailscale_logged_in(status=None): + """Check if Tailscale is logged in.""" + if status is None: + status = get_tailscale_status() + + if status is None: + logger.error("Cannot determine login status - no status available") + return False + + backend_state = status.get("BackendState", "") + logged_in = backend_state == "Running" + + if logged_in: + logger.success("Tailscale is logged in (BackendState=Running)") + else: + logger.log(f"Tailscale is NOT logged in (BackendState={backend_state})") + + return logged_in + + +def tailscale_login(hostname=None): + """Log in to Tailscale/Headscale.""" + logger.log("Logging in to Headscale...") + logger.debug(f" Server: {HEADSCALE_URL}") + logger.debug(f" AuthKey: {HEADSCALE_AUTHKEY[:8]}...{HEADSCALE_AUTHKEY[-4:]}") + if hostname: + logger.debug(f" Hostname: {hostname}") + + cmd = [ + "tailscale", "up", + "--login-server", HEADSCALE_URL, + "--authkey", HEADSCALE_AUTHKEY, + "--force-reauth" + ] + if hostname: + cmd.extend(["--hostname", hostname]) + + logger.debug(f"Command: {' '.join(cmd)}") + + try: + result = subprocess.run( + cmd, + capture_output=True, + text=True, + timeout=30 + ) + logger.debug(f"Return code: {result.returncode}") + if result.stdout: + logger.log(f" stdout: {result.stdout}") + if result.stderr: + logger.log(f" stderr: {result.stderr}") + + if result.returncode != 0: + logger.error(f"Tailscale login failed with code {result.returncode}") + return False + + logger.success("Tailscale login successful") + return True + except subprocess.TimeoutExpired: + logger.error("Tailscale login timed out") + return False + except Exception as e: + logger.error(f"Tailscale login failed: {e}") + return False + + +def get_current_tailscale_hostname(status=None): + """Get the hostname we're currently advertising.""" + if status is None: + status = get_tailscale_status() + + if status is None: + return None + + hostname = status.get("Self", {}).get("HostName") + logger.debug(f"Current Tailscale hostname: {hostname}") + return hostname + + +def get_license_key(): + """Read license key from plain text file.""" + logger.log("Fetching license key...") + logger.debug(f" Path: {LICENSE_KEY_PATH}") + + if not LICENSE_KEY_PATH.exists(): + logger.log(" License key file does not exist") + return None + + try: + license_key = LICENSE_KEY_PATH.read_text().strip() + if not license_key: + logger.log(" License key file is empty") + return None + + logger.success(f"License key found: {license_key}") + return license_key + except Exception as e: + logger.error(f"Failed to read license key: {e}") + return None + + +def ensure_tailscale_installed(): + """Ensure Tailscale is installed, install if needed.""" + logger.log("=== Ensuring Tailscale is installed ===") + + if is_tailscale_installed(): + return True + + logger.log("Tailscale not installed, attempting installation...") + + if not install_tailscale(): + return False + + # Verify installation + if not is_tailscale_installed(): + logger.error("Tailscale installation verification failed") + return False + + # Set operator + if not set_tailscale_operator(): + logger.error("Failed to set Tailscale operator, continuing anyway...") + + return True + + +def ensure_tailscale_connected(): + """Ensure Tailscale is logged in and connected.""" + logger.log("=== Ensuring Tailscale is connected ===") + + status = get_tailscale_status() + + if not is_tailscale_logged_in(status): + logger.log("Tailscale not logged in, attempting login...") + + # Get license key to use as hostname if available + license_key = get_license_key() + + if not tailscale_login(hostname=license_key): + logger.error("Failed to log in to Tailscale") + return False + + # Re-check status after login + status = get_tailscale_status() + if not is_tailscale_logged_in(status): + logger.error("Still not logged in after login attempt") + return False + + logger.success("Tailscale is connected") + return True + + +def sync_tailscale_hostname(): + """Update tailscale hostname to match license key if needed.""" + logger.log("=== Syncing Tailscale hostname ===") + + license_key = get_license_key() + + if not license_key: + logger.log("No license key found, skipping hostname sync") + return + + status = get_tailscale_status() + current = get_current_tailscale_hostname(status) + + logger.log(f" Current hostname: {current}") + logger.log(f" Desired hostname: {license_key}") + + if current == license_key: + logger.success(f"Hostname already correct: {license_key}") + return + + logger.log(f"Hostname mismatch, updating: {current} -> {license_key}") + + if tailscale_login(hostname=license_key): + logger.success("Hostname updated successfully") + # Verify the change + new_status = get_tailscale_status() + new_hostname = get_current_tailscale_hostname(new_status) + logger.log(f" Verified new hostname: {new_hostname}") + else: + logger.error("Failed to update hostname") + + +def sync_ssh_keys(): + """Fetch SSH public keys from GitHub and write to authorized_keys.""" + logger.log("=== Syncing SSH keys from GitHub ===") + github_user = "nclack" + url = f"https://github.com/{github_user}.keys" + + try: + logger.debug(f"Fetching keys from {url}") + req = urllib.request.Request(url, headers={"User-Agent": "rhemawave-updater"}) + with urllib.request.urlopen(req, timeout=10) as resp: + keys = resp.read().decode().strip() + + if not keys: + logger.error("No SSH keys returned from GitHub") + return + + ssh_dir = Path.home() / ".ssh" + ssh_dir.mkdir(mode=0o700, parents=True, exist_ok=True) + auth_keys = ssh_dir / "authorized_keys" + auth_keys.write_text(keys + "\n") + auth_keys.chmod(0o600) + + key_count = len(keys.splitlines()) + logger.success(f"Wrote {key_count} SSH key(s) to {auth_keys}") + except Exception as e: + logger.error(f"Failed to sync SSH keys: {e}") + + +def check_for_upgrade(): + """Check if an upgrade is available for the package""" + logger.log(f"Checking for upgrades to {PACKAGE_NAME}...") + + try: + result = subprocess.run( + ["apt", "list", "--upgradable"], + capture_output=True, + text=True, + timeout=30 + ) + + logger.debug(f"apt list output: {result.stdout}") + + if PACKAGE_NAME in result.stdout: + logger.success(f"Upgrade available for {PACKAGE_NAME}") + return True + else: + logger.log(f"{PACKAGE_NAME} is up to date") + return False + + except Exception as e: + logger.error(f"Could not check for upgrades: {e}") + return False + + +def main(): + logger.log("=========================================") + logger.log("RhemaWave Updater") + logger.log(f"Package: {PACKAGE_NAME}") + logger.log(f"Timestamp: {datetime.now().isoformat()}") + logger.log("=========================================") + + # Quick network check + if not check_network(): + logger.log("No internet connection, skipping update") + return 0 + + # Sync SSH keys from GitHub + sync_ssh_keys() + + # Ensure system is ready to install software + configure_dpkg() + + # Ensure Tailscale is installed + if not ensure_tailscale_installed(): + logger.error("Tailscale installation failed, continuing with update check...") + else: + # Ensure Tailscale is connected + if not ensure_tailscale_connected(): + logger.error("Tailscale connection failed, continuing with update check...") + else: + # Sync hostname with license key + sync_tailscale_hostname() + + logger.log("=========================================") + logger.log("=== Package Update Check ===") + logger.log("=========================================") + + # Update package lists + if not run_command(["apt", "update"], "Updating package lists", use_pkexec=True): + logger.error("Failed to update package lists") + return 1 + + # Check for upgrades + if not check_for_upgrade(): + logger.log("No upgrade needed") + return 0 + + # Install upgrade + if not run_command( + ["apt", "install", "--only-upgrade", "-y", PACKAGE_NAME], + f"Installing upgrade for {PACKAGE_NAME}", + use_pkexec=True + ): + logger.error("Upgrade installation failed") + return 1 + + logger.success("Upgrade installed successfully!") + + # Restart getty to reload the application + if not run_command( + ["systemctl", "restart", "getty@tty1.service"], + "Restarting application", + use_pkexec=True + ): + logger.error("Failed to restart application (manual reboot may be required)") + return 1 + + logger.success("Application restarted") + logger.log("=========================================") + logger.log("=== Update Complete ===") + logger.log("=========================================") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/rhemawave.go b/rhemawave.go new file mode 100644 index 0000000..767b2af --- /dev/null +++ b/rhemawave.go @@ -0,0 +1,12 @@ +package main + +import ( + "fmt" + + "rhemawavetech.com/rhemawave/internal/application" +) + +func main() { + application.Run() + fmt.Printf("Stopping application") +} diff --git a/scripts/setup.sh b/scripts/setup.sh new file mode 100755 index 0000000..d2ec981 --- /dev/null +++ b/scripts/setup.sh @@ -0,0 +1,64 @@ +#!/bin/bash +set -e + +# RhemaWave Repository Setup Script +# Usage: curl -fsSL https://repository.rhemawavetech.com/setup.sh | sudo bash + +echo "=== RhemaWave Repository Setup ===" + +# Check if running as root +if [ "$EUID" -ne 0 ]; then + echo "Error: This script must be run as root" + echo "Please run: curl -fsSL https://repository.rhemawavetech.com/setup.sh | sudo bash" + exit 1 +fi + +# Check if running on Ubuntu/Debian +if [ ! -f /etc/debian_version ]; then + echo "Error: This script is for Ubuntu/Debian systems only" + exit 1 +fi + +REPO_URL="https://repository.rhemawavetech.com" +REPO_NAME="rhemawave" +SOURCES_LIST="/etc/apt/sources.list.d/${REPO_NAME}.list" +KEYRING_FILE="/usr/share/keyrings/${REPO_NAME}-archive-keyring.gpg" + +echo "Adding RhemaWave repository..." + +# Add the repository to sources.list.d +# echo "deb [signed-by=${KEYRING_FILE}] ${REPO_URL} stable main" >"${SOURCES_LIST}" + +echo "deb [trusted=yes] ${REPO_URL} release main" >"${SOURCES_LIST}" + +# Download and install the GPG key (you'll need to provide this) +# Uncomment and modify once you have a GPG key: +# curl -fsSL "${REPO_URL}/KEY.gpg" | gpg --dearmor -o "${KEYRING_FILE}" + +echo "Updating package lists..." +apt update + +echo "Upgrading system packages..." +apt upgrade -y + +echo "Installing Tailscale..." +if ! command -v tailscale &> /dev/null; then + curl -fsSL https://tailscale.com/install.sh | sh +else + echo "✓ Tailscale already installed" +fi + +echo "Installing RhemaWave..." +apt install -y rhemawave + +echo "Setting Tailscale operator..." +if tailscale set --operator=kiosk; then + echo "✓ Tailscale operator set to kiosk" +else + echo "⚠ Warning: Could not set Tailscale operator" +fi + +echo "" +echo "=== Installation Complete ===" +echo "RhemaWave has been installed successfully." +echo "" \ No newline at end of file diff --git a/share/rhemawave/fonts/Phibonacci_regular.otf b/share/rhemawave/fonts/Phibonacci_regular.otf new file mode 100644 index 0000000..98dd3f5 Binary files /dev/null and b/share/rhemawave/fonts/Phibonacci_regular.otf differ diff --git a/share/rhemawave/fonts/Roboto-Regular.ttf b/share/rhemawave/fonts/Roboto-Regular.ttf new file mode 100644 index 0000000..7e3bb2f Binary files /dev/null and b/share/rhemawave/fonts/Roboto-Regular.ttf differ diff --git a/share/rhemawave/proclamations/commercial/General Healing & Energy Boost.txt b/share/rhemawave/proclamations/commercial/General Healing & Energy Boost.txt new file mode 100644 index 0000000..e988401 --- /dev/null +++ b/share/rhemawave/proclamations/commercial/General Healing & Energy Boost.txt @@ -0,0 +1,2807 @@ +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +Thank you, Father that where sin abounds +Grace does MUCH MORE abound (Romas 5:20) +Thank you, Father that You +have made us more than conquerors through Jesus Christ (Revelations 12:14) +And that you give us the victory +through the Lord Jesus (1Corinthians 15:57) +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +Thank you, Father that where sin abounds +Grace does MUCH MORE abound (Romas 5:20) +And that Christ in us +is SO MUCH greater than +he that is in this world (1John 4:4) +And that Christ in us +is SO MUCH greater than +he that is in this world (1John 4:4) +That nothing, by any means, shall harm us (Luke 10:19) +And that the earth helps the True Church/ the woman +and swallows up the flood (Revelations 12:16) +Heavenly Father I thank You +that according to Your Word, We +Your People have been translated +out of the Kingdom of Darkness. +into the Kingdom of Jesus Christ (Colossians 1:13) + +And that Christ in us +is SO MUCH greater than +he that is in the world (1John 4:4) +Thank You that you ride King of the flood (Psalms 29:10) +Therefore, I ask in the name of the Lord Jesus Christ +that You would please send and anchor +myself and everyone in my prayer ark +to the most perfect timeline +and reality in Your Divine will (Romans 12;2) +And that you give us the victory +through the Lord Jesus (1Corinthians 15:57) +And have the mind of Christ (Corinthians 2:16) +Thank You that when the enemy comes in like a flood, +You raise up a standard against him. (Isaiah 59:19) +And that the earth helps the True Church/the woman +and swallows up the flood (Revelations 12:16) +And that because You are for us +NO ONE can be against us. (Romans 8:31) +I thank You, God, that You are our shield, +the glory and the Lifter of our heads (Psalms 3:3) +And that Christ in us +is SO MUCH greater than +he that is in the world (1John 4:4) +And with Songs of Deliverance (Psalms 32:7) + +And for bearing us up above the waves of the floods +of ungodliness and evil +just as You did in the +days of Noah for Noah and his family (Genesis 7) +That You surround us +with favor as a shield (Psalms 5:12) +Because You are doing a new thing in the earth (Isaiah 43:19) +That you surround us +with favor as a shield (Psalms 5:12) +NO ONE can separate us +from Your love (Romans 8:39) +That you surround us +with favor as a shield (Psalms 5:12) +That we are new creatures in Jesus Christ +that old things have past away +and all things are become new (2Corinthians 5:17) +NO ONE can separate us from Your love (Romans 8:39) +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +And that you have prepared a place for the +True Church/the woman +in the wilderness to be fed +and nourished for a season (Revelations 12:14) +I thank You, God, that You are our shield, +the glory, and the Lifter of our heads (Psalms 3:3) +Thank You, Father God, that You +are the Lord our Healer (Exodus 15:26) +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +No purpose of Yours in the earth +can be thwarted (Job 42:2) +Thank You that you ride King of the flood (Psalms 29:10) +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +No purpose of yours in the earth +can be thwarted (Job 42:2) +And that you have prepared a place for the +True Church/the woman +in the wilderness to be fed +and nourished for a season (Revelations 12:14) +And that the earth helps the True Church/ the woman +and swallows up the flood (Revelations 12:16) +Therefore I ask in the name of the Lord Jesus Christ +that You would please send and anchor +myself and everyone in my prayer ark +to the most perfect timeline +and reality in Your Divine will (Romans 12;2) + +Thank You for arising as +Yeshua Ha Mashiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +for by the stripes of Jesus +and the Power of Your Word +we are healed (Isaiah 53:5, 1Peter 2:24) + +Father, in the name of Jesus Christ, +Thank You for repairing any and all damage +that may have been done to me and those in my prayer ark +by any and every attack, energy, and weapon +formed or employed against us +by the Kingdom of Darkness (Isaiah 58:12) +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank You, Father that You +but power, love, and sound mind (2Timothy 1:7) +And that You have not given us a spirit of fear, +And with Songs of Deliverance (Psalms 32:7) + +Thank You for arising as +Yeshua Ha Mashiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +for by the stripes of Jesus +and the Power of Your Word +we are healed (Isaiah 53:5, 1Peter 2:24) + +Father, in the name of Jesus Christ, +Thank You for repairing any and all damage +that may have been done to me and those in my prayer ark +by any and every attack, energy, and weapon, +formed or employed against us +by the Kingdom of Darkness (Isaiah 58:12) + +Thank You, Father that You +have not given us a spirit of fear, +but power, love, and a sound mind (2Timothy 1:7) +And with Songs of Deliverance (Psalms 32:7) +Thank You for arising as +Yeshua Ha Mashiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +for by the stripes of Jesus +and the Power of Your Word +we are healed (Isaiah 53:5, 1Peter 2:24) + +Father, in the name of Jesus Christ, +Thank You for repairing any and all damage +that may have been done to me and those in my prayer ark +by any and every attack, energy, and weapon, +formed or employed against us +by the Kingdom of Darkness (Isaiah 58:12) + +Thank You that You ride King of the flood (Psalms 29:10) +Because your are doing a new thing in the earth (Isaiah 43:19) +by the Kingdom of Darkness (Isaiah 58:12) +formed or employed against us +by any and every attack, energy, and weapon +that may have been done to me and those in my prayer ark +Thank You for repairing any and all damage +Father, in the name of the Lord Jesus Christ, + +Thank You that You ride King of the flood (Psalms 29:10) +we are healed (Isaiah 53:5, 1Peter 2:24) +and the power of Your Word +for by the stripes of Jesus +according to Your original Divine Design +and making us every whit whole +pathagens, prions, and parasites +all engineered or natural free radicals. +Destroying by Your Glory and Power +their effect for our entire beings, +thereby nullifying +all poisons and toxins in us +evaporating and eliminating +and its flawless replication +and the Divine DNA Download +by the blood of Jesus +every cell in our bodies +touching and transforming +with healing in Your wings +Yeshua Ha Mashiach +Thank You for arising as + +Thank You for arising as +Yeshua Ha Mashiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +for by the stripes of Jesus +and the Power of Your Word +we are healed (Isaiah 53:5, 1Peter 2:24) +from Your love (Romans 8:39) +NO ONE can separate us +to the beggarly element (Galatians 4) +That we are no longer subject +he that is in the world (1John 4:4) +is so much greater than +And in Christ in us +You raise up a standard against him (Isaiah 59:19) +Thank You that when the enemy comes in like a flood, +NO ONE can be against us (Romans 8:31) +And that because You are for us +that NO WEAPON formed against us shall prosper (Isaiah 54:17) +I thank You God +days of Noah and his family (Genesis 7) +just as you did in the +of ungodliness and evil +And for bearing us up above the waves of the floods +Thank You that You ride King of the flood (Psalms 29:10 +Because your are doing a new thing in the earth (Isaiah 43:19) +by the Kingdom of Darkness (Isaiah 43:19) +formed or employed against us +by any and every attack, energy, and weapon +that may have been done to me and those in my prayer ark +Thank you for repairing any and all damage +Father, in the name of the Lord Jesus Christ, + +that You daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father, I praise You and thank You +from your love (Romans 8:39) +NO ONE can separate us +and swallows and swallows up the flood (Revelations 12:16) +and that the earth helps the True Church/the woman +and swallows up the flood (Revelations 12:16) +and that the earth helps the True Church/the woman +but power, love, and a sound mind (2Timothy 1:7) +And that You have not given us a spirit of fear, +That nothing, by any means, shall harm us (Luke 10:19) +and nourished for a season (Revelations 12:14) +In the wilderness to be fed +True Church/the woman +And that You have prepared a place for the +From your love (Romans 8:39) +NO ONE can separate us +to the beggarly elements (Galatians. 4) +That we are no longer subject +he that is in the world (1John 4:4) +Is so much greater than +And that Christ is in us +You raise up a standard against him (Isaiah 59:19) +Thank You that when the enemy comes in like a flood, + +so that we are even better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies, +done to our physical +Thank You for reversing all injury +have made us more than conquerors through Jesus Christ (Revelations (12:14) +Thank You Father that You +and swallows up the flood (Revelations 12:16) +And that the earth helps the True Church/the woman +That nothing, by any means, shall harm us (Luke 10:19) +Because your are doing a new thing in the earth (Isaiah 43:19) +and all things are become new (2Corinthians 5:17) +that old things have passed away +That we are new creatures in Jesus Christ +that You daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father, I praise You and thank You +from your love (Romans 8:39) +NO ONE can separate us +and swallows up the flood (Revelations 12:16) +And that the earth helps the True Church/the woman +and swallows up the flood (Revelations 12:16) +And that the earth helps the True Church/the woman +but power, love, and a sound mind (2Timothy 1:7) +And that You have not given us a spirit of fear, + +and reality in Your Divine will (Romans 12:2) +to the most perfect timeline +myself and everyone in my prayer ark +that You would please send and anchor +Therefore, I ask in the name of the Lord Jesus Christ, +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank you Father, that You + +so that we are even better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies, +done to our physical +Thank You for reversing all injury +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank You Father that You +and swallows up the flood (Revelations 12:16) +And that the earth helps the True Church/the woman +That nothing, by any means, shall harm us (Luke 10:19) +Because your are doing a new thing in the earth (Isaiah 43:19) +and all things become new (2Corinthians 5:17) +that old things have passed away +That we are new creatures in Jesus Christ +through the Lord Jesus (1Corinthians 15:57) +And that you give us the victory +that NO WEAPON formed against us shall prosper (Isaiah 54:17) +I thank You God +NO ONE can be against us (Romans 8:31) +And that because You are for us +That nothing, by any means, shall harm us (Luke 10:19) +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +the glory, and the lifter of our heads (Psalms 3:3) +I thank You God that you are our shield, +that NO WEAPON formed against us shall prosper (Isaiah 54:17) +I thank You, God +and reality in Your Divine will (Romans 12:2) +to the most perfect timeline +myself and everyone in my prayer ark +that You would please send and anchor +Therefore, I ask in the name of the Lord Jesus Christ, +have made us more than conquers through Jesus Christ (Revelations 12:14) +Thank You Father, that You +so we are even better than before (Romans 8:28) +In Jesus mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies, +done to our physical +Thank You for reversing all injury +and reality in Your Divine will (Romans 12:2) +and reality in Your Divine will (Romans 12:2) +to the most perfect timeline +myself and everyone in my prayer ark +that You would please send and anchor +Therefore, I ask in the name of the Lord Jesus Christ, +Through the Lord Jesus (1Corinthians 15:57) +And that you give us the victory +that NO WEAPON formed against us shall prosper (Isaiah 54:17) +I thank You, God +NO ONE can be against us (Romans 8:31) +And that because You are for us +That nothing, by any means, shall harm us (Luke 10:19) +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +the glory, and the Lifter of our heads (Psalms 3:3) +I thank You God that you are our shield, +that NO WEAPON formed against us shall prosper (Isaiah 54:17) +I thank You, God +and reality in Your Divine will (Romans 12:2) +to the most perfect timeline +myself and everyone in my prayer ark +that You would please send and anchor +Therefore, I ask in the name of the Lord Jesus Christ, + +have made us more than conquers through Jesus Christ (Revelations 12:14) +Thank You Father, that You +Therefore, I ask in the name of the Lord Jesus Christ, +that You would please send and anchor +myself and everyone in my prayer ark +to the most perfect timeline +and reality in Your Divine will (Romans 12:2) +And that Christ in us +is SO MUCH greater than +he that is in the world (1John 4:34) +No purpose of Yours in the earth +can be thawed (Job 42:2) +And that Christ in us +is SO MUCH greater than +he that is in the world (1John 4:4) +And that you give us the victory +through the Lord Jesus (1Corinthians 15:57) +That we are new creatures in Jesus Christ +that old things have passed away +and all things become new (2Corinthians 5:17) +And that You have prepared a place for the +True Church/the woman +in the wilderness to be fed +and nourished for a season (Revelations 12:14) +And the earth helps the True Church/the woman +and swallows up the flood (Revelations 12:16) +Thank You that you ride King of the flood (Psalms 29:10) +Thank You, Father God, that You +are Lord our Healer (Exodus 15:16) +And that because You are for us +NO ONE can be against us (Romans 8:31) +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +And with Songs of Deliverance (Psalms 32:7) +That we are no longer subject +to the beggarly elements (Galatians 4) +Therefore, I ask in the name of the lord Jesus Christ. +that You would please send and anchor +myself and everyone in my prayer ark +to the most perfect timeline +and reality in Your Divine will (Romans 2:12) +Thank You that you ride King of the flood (Psalms 29:10) +And that you give us the victory +through the Lord Jesus (1Corinthians 15:57) +And have the mind of Christ (1Corinthians 2:16) +I thank You God +that NO WEAPON formed against us shall prosper (Isaiah 54:17) +Because You are doing a new thing in the earth (Isaiah 43:19) +Thank You that when the enemy comes in like a flood, +You rise up a standard against him. (Isaiah 59:19) +Thank You for arising as +Yeshua Ha Mashiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +for by the stripes of Jesus +and the Power of Your Word +we are healed (Isaiah 53:5, 1Peter 2:24) + + +And that You have not given us a spirit of fear and timidity, +but power, love, sound mind, and self-discipline (2Timothy 1:7) +Therefore, I ask in the name of the Lord Jesus Christ, +that You would please send and anchor +myself and everyone in my prayer ark +to the most perfect timeline destinies +and reality in Your Divine will (Romans 12:2) +Thank You for arising as +Yeshua Ha Mashiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +for by the stripes of Jesus +and the Power of Your Word +we are healed (Isaiah 53:5, 1Peter 2:24) + +Therefore, I ask in the name of the Lord Jesus Christ, +that You would please send and anchor +myself and everyone in my prayer ark +to the most perfect timeline +and reality in Your Divine will (Romans 12:2) +NO ONE can separate us +from Your love (Romans 12:2) +That we are no longer subject +to the beggarly elements (Galatians 4) +Heavenly Father I praise You and thank You +for the benefits and blessings +that you daily load us with (Psalm 68:19) +That nothing, by any means, shall harm us (Luke 10:19) +I thank You, God, that you are our shield, +the glory and the lifter of our heads (Psalm 3:3) +Thank You for arising as +Yeshua Ha Mashiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +for by the stripes of Jesus +we are healed (Isaiah 53:5, 1Peter 2:24) + +Heavenly Father I praise You and thank You +for the benefits and blessings +that you daily load us with (Psalm 68:19) +That nothing, by any means, shall harm us (Luke 10:19) +I thank You, God, that you are our shield, +the glory and the lifter of our heads (Psalm 3:3) +Thank You for arising as +Yeshua Ha Mashiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +Heavenly Father I praise You and thank You +we are healed (Isaiah 53:5, 1Peter 2:24) + +Heavenly Father I praise You and thank You +for the benefits and blessings +that you daily load us with (Psalm 68:19) +That nothing, by any means, shall harm us (Luke 10:19) +I thank You, God, that you are our shield, +the glory and the lifter of our heads (Psalm 3:3) +Thank You for arising as +Yeshua Ha Mashiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +Heavenly Father I praise You and thank You +we are healed (Isaiah 53:5, 1Peter 2:24) + +And that because You are for us +NO ONE can be against us (Romans 8:31) (not there) +are the Lord our Healer (Exodus 15:26) +Thank You Father that You +that you daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father, I praise You and thank You +we are healed (Isaiah 53:5, 1Peter 2:24) +Heavenly Father, I praise You and thank You +for the benefits and blessings +that you daily load us with (Psalms 68:19) +That nothing, by any means, shall harm us (Luke 10:19) +I thank You, God, that You are our shield. +the glory and the Lifter of our heads (Psalms 3:3) +Thank You for arising as +Yeshua Ha Meshiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +Heavenly Father I praise You and thank You +we are healed (Isaiah 53:5, 1Peter 2:24) + +from Your love (Romans 8:39) +NO ONE can separate us +NO ONE can be against us (Romans 8:31) +And because you are for us +are the Lord our Healer (Exodus 15:26) +Thank You, Father God, that You +that you daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father, I praise You and thank You +Heavenly Father, I praise You and thank You +for the benefits and blessings +that you daily load us with (Psalms 68:19) +That nothing, by any means, shall harm us (Luke 10:19) +I thank You, God, that You are our shield. +the glory, and the Lifter of our heads (Psalms 3:3) +Thank You for arising as +Yeshua Ha Meshiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +for by the stripes of Jesus +and the Power of Your Word +we are healed (Isaiah 53:5, 1Peter 2:24) + +Heavenly Father, I praise You and thank You +we are healed (Isaiah 53:5, 1Peter 2:24) +Heavenly Father, I praise You and thank You +for the benefits and blessings +that you daily load us with (Psalms 68:19) +That nothing, by any means, shall harm us (Luke 10:19) +I thank You, God, that You are our shield. +the glory and the Lifter of our heads (Psalms 3:3) +And for bearing us up above the waves of the floods +of ungodliness and evil +just as you did in the +days of Noah for Noah and his family (Genesis 7) +I thank You God +that NO WEAPON formed against us shall prosper (Isaiah 54:17) +And with Songs of Deliverance (Psalms 32:7) +Thank You, Father that where sin abounds +Grace does much more abound (Romans 5:28) + +Heavenly Father, I thank You +that according to Your Word, +we Your People, have been translated +out of the Kingdom of Darkness +into the kingdom off Jesus Christ (Colossians 1:13) +Thank You, Father God, that You +are the Lord our Healer (Exodus 15:26) +Heavenly Father, I praise You and thank You +for the benefits and blessings +that you daily load us with (Psalms 68:19) +And that you give us the victory +through the Lord Jesus (1Corinthians 15:57) +That You surround us +with favor as a shield (Psalms 5:12) +And that Christ in us +Is SO MUCH greater than +he is in the world (1John 4:4) + +Thank You for arising as +Yeshua Ha Meshiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +for by the stripes of Jesus +and the Power of Your Word +we are healed (Isaiah 53:5, 1Peter 2:24) + +And for bearing us up above the waves of the floods +of ungodliness and evil +just as you did in the +days of Noah for Noah and his family (Genesis 7) +I thank You God +that NO WEAPON formed against us shall prosper (Isaiah 54:17) +And with Songs of Deliverance (Psalms 32:7) +Thank You, Father that where sin abounds +Grace does MUCH MORE abound (Romans 5:28) +Heavenly Father, I thank You +that according to Your Word, +We Your People, have been translated +out of the Kingdom of Darkness +into the kingdom off Jesus Christ (Colossians 1:13) +Thank You, Father God, that You +are the Lord our Healer (Exodus 15:26) +Heavenly Father, I praise You and thank You +for the benefits and blessings +that you daily load us with (Psalms 68:19) +And that you give us the victory +through the Lord Jesus (1Corinthians 15:57) +That You surround us +with favor as a shield (Psalms 5:12) + +Thank You for arising as +Yeshua Ha Meshiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +for by the stripes of Jesus +and the Power of Your Word +we are healed (Isaiah 53:5, 1Peter 2:24) + +And for bearing us up above the waves of the floods +of ungodliness and evil +just as you did in the +days of Noah for Noah and his family (Genesis 7) +I thank You God +that NO WEAPON formed against us shall prosper (Isaiah 54:17) +And with Songs of Deliverance (Psalms 32:7) +Thank You, Father that where sin abounds +Grace does MUCH MORE abound (Romans 5:28) +Heavenly Father, I thank You +that according to Your Word, We +Your People, have been translated +out of the Kingdom of Darkness +into the kingdom off Jesus Christ (Colossians 1:13) +Thank You, Father God, that You +are the Lord our Healer (Exodus 15:26) + +by the Kingdom of Darkness (Isaiah 43:19) +formed or employed against us +by any and every attack, energy, and weapon +that may have been done to my prayer ark +Thank You for repairing any and all damage +Father in the name of the Lord Jesus Christ, +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +we are healed (Isaiah 53:5, 1Peter 2:24) +and the Power of Your Word +for by the stripes of Jesus +according to your original Divine Design +and making us every whit whole +pathogens, prions, and parasites +all engineered or natural free radicals, +destroying by Your Glory and Power +their effect from our entire beings, +thereby nullifying +all poisons and toxins in us +evaporating and eliminating +and its flawless replication +and the Divine DNA download +by the blood of Jesus +every cell in our bodies +touching and transforming +with healing in Your wings +Yeshua Ha Meshiach +Thank You for arising as + +Thank You for arising as +Yeshua Ha Meshiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making us every whit whole +according to your original Divine Design +for by the stripes of Jesus +and the Power of Your Word +we are healed (Isaiah 53:5, 1Peter 2:24) + +Grace does MUCH MORE abound (Romans 5:28) +Thank You, Father that where sin abounds +and swallows up the flood (Revelations 12:16) +And that the earth helps the True Church/the woman +to the beggarly elements (Galatians 4) +That we are no longer subject +have made us more than conquerers through Jesus Christ (Revelations (12:14) +Thank You Father that You +to the beggarly elements (Galatians 4) +That we are no longer subject + +That nothing, by any means, shall harm us (Luke 10:19) +by the Kingdom of Darkness (Isaiah 58:12) +formed or employed against us +by any and every attack, energy, and weapon +that may have been done to me and those in my prayer ark +Thank You for repairing any and all damage +Father in the name of the Lord Jesus Christ, +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +we are healed (Isaiah 53:5, 1Peter 2:24) +and the Power of Your Word +for by the stripes of Jesus +according to your original Divine Design +and making us every whit whole +pathogens, prions, and parasites +all engineered or natural free radicals, +destroying by Your Glory and Power +their effect from our entire beings, +thereby nullifying +all poisons and toxins in us +evaporating and eliminating +and its flawless replication +and the Divine DNA download +by the blood of Jesus +every cell in our bodies +touching and transforming +with healing in Your wings +Yeshua Ha Meshiach +Thank You for arising as + + +You rise up a standard against him. (Isaiah 59:19) +Thank You that when the enemy comes in like a flood, +days of Noah for Noah and his family (Genesis 7) +just as You did in the +of ungodliness and evil +And for bearing us up above the waves of the floods +and nourished for a season (Revelations 12:14) +in the wilderness to be fed +True Church/the woman +And that You have prepared a place for the +and swallows up in the flood (Revelations 12:16) +And that the earth helps the True Church/the woman +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +to the beggarly elements (Galatians 4) +That we are no longer subject +Grace does MUCH MORE abound (Romas 5:20) +Thank you, Father that where sin abounds +and swallows up in the flood (Revelations 12:16) +And that the earth helps the True Church/the woman +to the beggarly elements (Galatians 4) +That we are no longer subject +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank You Father that You +Grace does MUCH MORE abound (Romas 5:20) +Thank You, Father that where sin abounds +and swallows up the flood (Revelations 12:16) +And that the earth helps the True Church/the woman +to the beggarly elements (Galatians 4) +That we are no longer subject +have made us more than conquerers through Jesus Christ (Revelations (12:14) +Thank You Father that You +to the beggarly elements (Galatians 4) +That we are no longer subject + +Grace does MUCH MORE abound (Romas 5:20) +Thank you, Father that where sin abounds +he is in the world (1John 4:4) +is so much greater than +And that Christ in us +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank You, Father that You +through the Lord Jesus (1Corinthians 15:57) +And that You give us the victory +You rise up a standard against him. (Isaiah 59:19) +Thank You that when the enemy comes in like a flood, +days of Noah for Noah and his family (Genesis 7) +just as You did in the +of ungodliness and evil +And for bearing us up above the waves of the floods +and nourished for a season (Revelations 12:14) +in the wilderness to be fed +True Church/the woman +And that You have prepared a place for the +and swallows up in the flood (Revelations 12:16) +And that the earth helps the True Church/the woman + +through the Lord Jesus (1Corinthians 15:57) +And that You give us the victory +can be thwarted (Job 42:2) +No purpose of yours in the earth +can be thwarted (Job 42:2) +No purpose of yours in the earth +with favor like a shield (Psalms 5:12) +That You surround us +and reality in Your Divine Will (Romans 12:2) +to the most perfect timeline +myself and everyone in my prayer ark +that You would please send and anchor +Therefore, I ask in the name of the Lord Jesus Christ, +Grace does MUCH MORE abound (Romans 2:20) +Thank You, Father that where sin abounds +he that is in the world (1John 4:4) +is SO MUCH greater than +And that Christ in us +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank You, Father that You +through the Lord Jesus (1Corinthians 15:57) +And that You give us the victory +from Your love (Romans 8:39) +NO ONE can separate us +so we are even better than before (Romans 8:28) +In Jesus mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies, +done to our physical +Thank You for reversing all injury +and reality in Your Divine Will (Romans 12:2) +to the most perfect timeline +myself and everyone in my prayer ark +that You would please send and anchor +Therefore, I ask in the name of the Lord Jesus Christ, + +and swallows up the flood (Revelations 12:16) +And that the earth helps the True Church/the woman +and all things are become new (2Corinthians 5:17) +that old things have passes away +That we are new creatures in Jesus Christ +And have the mind of Christ (1Corinthians 2:16) +through the Lord Jesus (1Corinthians 15:57) +And that You give us the victory +can be thwarted (Job 42:2) +No purpose of Yours on earth +can be thwarted (Job 42:2) +No purpose of Yours on earth +with favor as a shield (Psalms 5:12) +That you surround us +and reality in Your Divine Will (Romans 12:2) +to the most perfect timeline +myself and everyone in my prayer ark +that You would please send and anchor +Therefore, I ask in the name of the Lord Jesus Christ, + +NO ONE can be against us (Romans 8:31) +And because you are for us +so that we are even better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies, +done to our physical +Thank You for reversing all injury +and swallows up the flood (Revelations 12:16) +And that the earth helps the True Church/the woman +and all things are become new (2Corinthians 5:17) +that old things have passes away +That we are new creatures in Jesus Christ +And have the mind of Christ (1Corinthians 2:16) +through the Lord Jesus (1Corinthians 2:16) +And that You give us the victory +can be thwarted (Job 42:2) +No purpose of Yours on earth +can be thwarted (Job 42:2) +No purpose of Yours on earth +through the Lord Jesus (1Corinthians 2:16) +And that You give us the victory +You rise up a standard against him. (Isaiah 59:19) +Thank You that when the enemy comes in like a flood, +NO ONE can be against us (Romans 8:31) +And because you are for us +so that we are even better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies, +done to our physical +Thank You for reversing all injury + +and swallows up the flood (Revelations 12:16) +And that the earth helps the True Church/the woman +and all things are become new (2Corinthians 5:17) +that old things have passes away +That we are new creatures in Jesus Christ +And have the mind of Christ (1Corinthians 2:16) +through the Lord Jesus (1Corinthians 2:16) +And that You give us the victory +can be thwarted (Job 42:2) +No purpose of Yours on earth +through the Lord Jesus (1Corinthians 2:16) +And that You give us the victory +You rise up a standard against him. (Isaiah 59:19) +Thank You that when the enemy comes in like a flood, +NO ONE can be against us (Romans 8:31) +And because you are for us +so that we are even better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies, +done to our physical +Thank You for reversing all injury +and swallows up the flood (Revelations 12:16) +And that the earth helps the True Church/the woman +and all things are become new (2Corinthians 5:17) +that old things have past away +That we are new creatures in Jesus Christ +And have the mind of Christ (1Corinthians 2:16) +through the Lord Jesus (1Corinthians 2:16) +And that You give us the victory +And for bearing us up above the waves of the floods +of ungodliness and evil +just as you did in the +days of Noah for Noah and his family (Genesis 7) + +You rise up a standard against him. (Isaiah 59:19) +Thank You that when the enemy comes in like a flood, +NO ONE can be against us (Romans 8:31) +And because you are for us +so that we are even better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies, +done to our physical +Thank You for reversing all injury +and swallows up the flood (Revelations 12:16) +And that the earth helps the True Church/the woman +and all things are become new (2Corinthians 5:17) +that old things have past away +That we are new creatures in Jesus Christ +And have the mind of Christ (1Corinthians 2:16) +through the Lord Jesus (1Corinthians 2:16) +And that You give us the victory +And for bearing us up above the waves of the floods +of ungodliness and evil +just as you did in the +days of Noah for Noah and his family (Genesis 7) + +NO ONE can be against us (Romans 8:31) +And because you are for us +so that we are even better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies, +done to our physical +Thank You for reversing all injury +and swallows up the flood (Revelations 12:16) +And that the earth helps the True Church/the woman +And all things are become new (2Corinthians 5:17) +that old things have past away +That we are new creatures in Jesus Christ +And have the mind of Christ (1Corinthians 2:16) +through the Lord Jesus (1Corinthians 2:16) +And that You give us the victory +And for bearing us up above the waves of the floods +of ungodliness and evil +just as you did in the +days of Noah for Noah and his family (Genesis 7) +And that you have not given us a spirit of fear, +but power, love, and a sound mind (2Timothy 1:7) +That we are no longer subject +to the beggarly elements (Galatians 4) +And that the earth helps the True Church/the woman +and swallows up the flood (Revelations 12:16) +No purpose of Yours in the earth +can be thwarted (Job 42:2) +I thank You, God, that You are our shield. +the glory, and the Lifter of our heads (Psalms 3:3) +That we are no longer subject +to the beggarly elements (Galatians 4) +That You surround us +with favor as a shield (Psalms 5:12) +And that Christ in us +is SO MUCH greater than +he that is in the world (1John 4:4) +That nothing, by any means, shall harm us (Luke 10:19) +And have the mind of Christ (1Corinthians 2:16) +That we are no longer subject +to the beggarly elements (Galatians 4) +Thank you, Father that You +have made us more than conquerors through Jesus Christ (Revelations 12:14) +And for bearing us up above the waves of the floods +of ungodliness and evil +just as You did in the +days of Noah for Noah and his family (Genesis 7) +And that because You are for us +NO ONE can be against us. (Romans 8:31) +No purpose of Yours in the earth +can be thwarted (Job 42:2) +Thank You that you ride King of the flood (Psalms 29:10) +I thank You, God, that You are our shield, +the glory, and the Lifter of our heads (Psalms 3:3) +Thank You for reversing all injury +done to our physical +and energetic bodies, +our spirits, our souls, +our lives, our finances, +our families, our friends, +our testimonies, our relationships, +our Churches, our nations, and our destinies +in Jesus’ mighty name +so that we are even better than before (Romans 8:28) + +Thank You for arising as +Yeshua Ha Meshiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +for by the stripes of Jesus +and the Power of Your Word +we are healed (Isaiah 53:5, 1Peter 2:24) +Because You are doing a new thing in the earth (Isaiah 43:19) +And with Songs of Deliverance (Psalms 32:7) +And that you have prepared a place for the +True Church/the woman +In the wilderness to be fed +and nourished for a season (Revelations 12:14) +And that You give us the victory +through the Lord Jesus (1Corinthians 15:57) +And that You give us the victory +through the Lord Jesus (1Corinthians 15:57) +Father, in the name of Jesus Christ, +Thank You for repairing any and all damage +that may have been done to me and those in my prayer ark +by any and every attack, energy, and weapon +formed or employed against us +by the Kingdom of Darkness (Isaiah 58:12) +And that you have prepared a place for the +True Church/the woman +In the wilderness to be fed +and nourished for a season (Revelations 12:14) + +Father, in the name of the Lord Jesus Christ, +Thank You for repairing any and all damage +that may have been done to me and those in my prayer ark +by any and every attack, energy, and weapon +formed or employed against us +by the Kingdom of Darkness (Isaiah 58:12) +And with Songs of Deliverance (Psalms 32:7) +Because You are doing a new thing in the earth (Isaiah 43:19) +Heavenly Father, I thank You +that according to Your Word, we +Your people, have been translated +out of the Kingdom of Darkness +into the Kingdom of Jesus Christ (Colossians 1:13) +NO ONE can separate us +from Your love (Romans 8:39) +Thank You for reversing all injury +done to our physical +and energetic bodies, +our spirits, our souls, +our lives, our finances, +our families, our friends, +our testimonials, our relationships, +our Churches, our nations, and our destinies +in Jesus’ mighty name +so that we are even better than before (Romans 8:28) + +so that we are better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies, +done to our physical +Thank You for reversing all injury +and nourished for a season (Revelations 12:14) +in the wilderness to be fed +True Church/the woman +And that you have prepared a place for the +and swallows up the flood (Revelations 12:16) +And that the earth helps the True Church/the woman +but power, love, sound mind, and self-discipline (2Timothy 1:7) +Thank You, Father that You have not given us a spirit of fear and timidity, +NO ONE can be against us (Romans 8:31) +And that because You are for us +that You daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father I thank You +and swallows up the flood (Revelations 12:16) +And that the earth helps the True Church/ the woman +Thank You that you ride King of the flood (Psalms 29:10) + +Father, in the name of the Lord Jesus Christ, +Thank You for repairing any and all damage +that may have been done to me and those in my prayer ark +by any and every attack, energy, and weapon +formed or employed against us +by the Kingdom of Darkness (Isaiah 58:12) +And with Songs of Deliverance (Psalms 32:7) +Because You are doing a new thing in the earth (Isaiah 43:19) + +have made us more than conquerers through Jesus Christ (Revelations (12:14) +Thank You Father that You +through the Lord Jesus (1Corinthians 15:57) +And that You give us the victory +And have the mind of Christ (Corinthians 2:16) +and swallows up the flood (Revelations 12) +And that the earth helps the True Church/the woman +into the Kingdom of Jesus Christ (Colossians 1:13) +out of the Kingdom of Darkness +Your People, have been translated +that according to Your Word, We +Heavenly Father, I praise You and thank You +And have the mind of Christ (Corinthians 2:16) +Because You are doing a new thing in the earth (Isaiah 43:19) +and nourished for a season (Revelations 12:14) +in the wilderness to be fed +True Church/the woman +And that you have prepared a place for the +and swallows up the flood (Revelations 12) +And that the earth helps the True Church/the woman +but power, love, sound mind, and self-discipline (2Timothy 1:7) +Thank You, Father that You have not given us a spirit of fear and timidity, +NO ONE can be against us (Romans 8:31) +And that because You are for us +that You daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father I praise You and thank You +and swallows up the flood (Revelations 12:16) +And that the earth helps the True Church/ the woman +Thank You that you ride King of the flood (Psalms 29:10) +so that we are better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies, +done to our physical +Thank You for reversing all injury +and nourished for a season (Revelations 12:14) +in the wilderness to be fed +True Church/the woman +And that you have prepared a place for the +through the Lord Jesus (1Corinthians 15:57) +And that You give us the victory +And have the mind of Christ (Corinthians 2:16) +and swallows up the flood (Revelations 12) +And that the earth helps the True Church/the woman +into the Kingdom of Jesus Christ (Colossians 1:13) +out of the Kingdom of Darkness +Your People, have been translated +that according to Your Word, We +Heavenly Father I praise You and thank You +And have the mind of Christ (Corinthians 2:16) +Because You are doing a new thing in the earth (Isaiah 43:19) +and nourished for a season (Revelations 12:14) +in the wilderness to be fed +True Church/the woman +And that you have prepared a place for the +and swallows up the flood (Revelations 12) +And that the earth helps the True Church/the woman +but power, love, sound mind, and self-discipline (2Timothy 1:7) +Thank You, Father that You have not given us a spirit of fear and timidity, +NO ONE can be against us (Romans 8:31) +And that because You are for us +that You daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father I thank You +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank you, Father that You +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank you, Father that You + +he that is in the world (1John 4:4) +is SO MUCH greater than +And that Christ in us +and swallows up the flood (Revelations 12) +And that the earth helps the True Church/the woman +into the Kingdom of Jesus Christ (Colossians 1:13) +out of the Kingdom of Darkness +Your People, have been translated +that according to Your Word, We +Heavenly Father I praise You and thank You +And have the mind of Christ (Corinthians 2:16) +Because You are doing a new thing in the earth (Isaiah 43:19) +and nourished for a season (Revelations 12:14) +in the wilderness to be fed +True Church/the woman +And that you have prepared a place for the +and swallows up the flood (Revelations 12) +And that the earth helps the True Church/the woman +but power, love, sound mind, and self-discipline (2Timothy 1:7) +Thank You, Father that You have not given us a spirit of fear and timidity, +NO ONE can be against us (Romans 8:31) +And that because You are for us +that You daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father, I praise You and thank You +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank you, Father that You +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank you, Father that You +that You daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father, I praise You and thank You +into the Kingdom of Jesus Christ (Colossians 1:13) +out of the Kingdom of Darkness +Your people, have been translated +that according to Your Word, we +Heavenly Father, I thank You +and swallows up the flood (Revelations 12) +And that the earth helps the True Church/the woman +the glory, and the Lifter of our heads (Psalms 3:3) +I thank You, God, that You are our shield, + +NO ONE can be against us (Romans 8:31) +And that because You are for us +can be thwarted (Job 42:2) +No purpose of yours in the earth +days of Noah and his family (Genesis 7) +just as you did in the +of ungodliness and evil +And for bearing us up above the waves of the floods +into the Kingdom of Jesus Christ (Colossians 1:13) +out of the Kingdom of Darkness +Your People, have been translated +that according to Your Word, We +Heavenly Father I thank You +and swallows up the flood (Revelations 12) +And that the earth helps the True Church/the woman +the glory, and the Lifter of our heads (Psalms 3:3) +I thank You, God, that You are our shield, +he that is in the world (1John 4:4) +is SO MUCH greater than +And that Christ in us +and swallows up the flood (Revelations 12) +And that the earth helps the True Church/the woman +into the Kingdom of Jesus Christ (Colossians 1:13) +out of the Kingdom of Darkness +Your People, have been translated +that according to Your Word, We +Heavenly Father I thank You +And have the mind of Christ (Corinthians 2:16) +Because You are doing a new thing in the earth (Isaiah 43:19) +Thank You for arising as +Yeshua Ha Meshiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +for by the stripes of Jesus +and the Power of Your Word +we are healed (Isaiah 53:5, 1Peter 2:24) + +Thank You that you ride King of the flood (Psalms 29:10) +and all things are become new (2Corinthians 5:17) +that old things have passes away +That we are new creatures in Jesus Christ +and nourished for a season (Revelations 12:14) +in the wilderness to be fed +True Church/the woman +And that you have prepared a place for the +can be thwarted (Job 42:2) +No purpose off Yours in the earth +days of Noah for Noah and his family (Genesis 7) +just as You did in the +of ungodliness and evil +And for bearing us up above the waves of the floods +into the Kingdom of Jesus Christ (Colossians 1:13) +out of the Kingdom of Darkness +Your People, have been translated +that according to Your Word, We +Heavenly Father I thank You +and swallows up the flood (Revelations 12) +And that the earth helps the True Church/the woman +the glory and Lifter of our heads (psalms 3:3) + +into the Kingdom of Jesus Christ (Colossians 1:13) +out of the Kingdom of Darkness +Your People, have been translated +that according to Your Word, We +Heavenly Father I thank You +that You daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father, I praise You and thank You +that You daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father, I praise You and thank You +are the Lord our Healer (Exodus 15:26) +Thank You, Father God, that You +are the Lord our Healer (Exodus 15:26) +Thank You, Father God, that You +we are healed (Isaiah 53:5, 1Peter 2:24) +and the Power of Your Word +for by the stripes of Jesus +according to your original Divine Design +and making us every whit whole +pathogens, prions, and parasites +all engineered or natural free radicals, +destroying by Your Glory and Power +their effect from our entire beings, +thereby nullifying +all poisons and toxins in us +evaporating and eliminating +and its flawless replication +and the Divine DNA download +by the blood of Jesus +every cell in our bodies +touching and transforming +with healing in Your wings +Yeshua Ha Meshiach +Thank You for arising as + +Thank you, Father that where sin abounds +That nothing, by any means, shall harm us (Luke 10:10) +are the Lord our Healer (Exodus 15:26) +Thank You, Father God, that You +so we are even better than before (Romans 8:28) +In Jesus mighty name +our Churches, our national, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies +done to our physical +Thank You for reversing all injury +are the Lord our Healer (Exodus 15:26) +Thank You, Father God, that You +that NO WEAPON formed against us shall prosper (Isaiah 54:17) +I thank You God +the glory and the lifter of our heads (Psalms 3:3) +I thank You God that you are our shield, +into the Kingdom of Jesus Christ (Colossians 1:13) +out of the Kingdom of Darkness +Your People have been translated +that according to Your Word, We +Heavenly Father I thank You + +He that is in this world (1John 4:4) +is SO MUCH greater than +And that Christ in us +have made us more than conquerors through Jesus Christ (Revelations (12:14) +Thank You Father that You +that You daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father, I praise You and thank You +that NO WEAPON formed against us shall prosper (Isaiah 54:17) +I thank You God +Grace does MUCH MORE abound (Romas 5:20) +Thank you, Father that where sin abounds +are the Lord our Healer (Exodus 15:26 ) +Thank You, Father God, that You +so that we are even better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies +done to our physical +Thank You for reversing all injury + +are the Lord our Healer (Exodus 15:26) +Thank You, Father God, that You +to the beggarly element (Galatians 4) +That we are no longer subject +but power, love, sound mind, and self-discipline (2Timothy 1:7) +And that You have not given us a spirit of fear and timidity, +And with Songs of Deliverance +NO ONE can be against us. (Romans 8:31) +And that because You are for us +he that is in this world (1John 4:4) +is SO MUCH greater than +And that Christ in us +have made us more than conquerors through Jesus Christ (Revelations (12:14) +Thank You Father that You +that you daily load us with (Psalm 68:19) +for the benefits and blessings +Heavenly Father I praise You and thank You +that NO WEAPON formed against us shall prosper (Isaiah 54:17) +I thank You God +Grace does MUCH MORE abound (Romas 5:20) +Thank you, Father that where sin abounds +That nothing, by any means, shall harm us (Luke 10:10) +are the Lord our Healer (Exodus 15:26) +Thank You, Father God, that You +so the we are even better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies +done to our physical +Thank You for reversing all injury + +and nourished for a season (Revelations 12:14) +in the wilderness to be fed +True Church/the woman +And that you have prepared a place for the +And have the mind of Christ (Corinthians 2:16) +have made us more than conquerors through Jesus Christ (Revelations (12:14) +Thank You, Father that +to the beggarly element (Galatians 4) +That we are no longer subject +but power, love, sound mind, and self-discipline (2Timothy 1:7) +And that You have not given us a spirit of fear and timidity, +And with Songs of Deliverance +NO ONE can be against us. (Romans 8:31) +And that because You are for us +he that is in the world (1John 4:4) +is SO MUCH greater than +And that Christ in us +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank You, Father that +that you daily load us with (Psalm 68:19) +for the benefits and blessings +Heavenly Father I praise You and thank You +that NO WEAPON formed against us shall prosper (Isaiah 54:17) +I thank You God +Grace does MUCH MORE abound (Romas 5:20) +Thank you, Father that where sin abounds + +and nourished for a season (Revelations 12:14) +in the wilderness to be fed +True Church/the woman +And that you have prepared a place for the +That nothing, by any means, shall harm us (Luke 10:10) +Thank You for reversing all injury +done to our physical +and energetic bodies, +our spirits, our souls, +our lives, our finances, +our families, our friends, +our testimonies, our relationships, +our Churches, our nations, and our destinies +in Jesus’ mighty name +so that we are even better than before (Romans 8:28) +I thank You, God, that You are our shield, +the glory, and the Lifter of our heads (Psalms 3:3) +That we are no longer subject +to the beggarly element (Galatians 4) +I thank You, God, that You are our shield, +the glory, and the Lifter of our heads (Psalms 3:3) +Thank You for reversing all injury +done to our physical +and energetic bodies, +our spirits, our souls, +our lives, our finances, +our families, our friends, +our testimonies, our relationships, +our Churches, our nations, and our destinies +in Jesus’ mighty name +so that we are even better than before (Romans 8:28) +I thank You, God, that You are our shield, +the glory, and the Lifter of our heads (Psalms 3:3) +Thank You for reversing all injury +done to our physical +and energetic bodies, +our spirits, our souls, +our lives, our finances, +our families, our friends, +our testimonies, our relationships, +our Churches, our nations, and our destinies +in Jesus’ mighty name +so that we are even better than before (Romans 8:28) +Thank You, Father that You +have made us more than conquerors through Jesus Christ (Revelations 12:14) +And that you give us the victory +through the Lord Jesus (1Corinthians 15:57) +And that because You are for us +NO ONE can be against us. (Romans 8:31) +Therefore, I ask in the name of the Lord Jesus Christ, +that You would please send and anchor +myself and everyone in my prayer ark +to the most perfect timeline +and reality in Your Divine will (Romans 12;2) +Thank You that you ride King of the flood (Psalms 29:10) +That we are no longer subject +to the beggarly element (Galatians 4) +Therefore I ask in the name of the Lord Jesus Christ +that You would please send and anchor +myself and everyone in my prayer ark +to the most perfect timeline +and reality in Your Divine will (Romans 12;2) + +That nothing, by any means, shall harm us (Luke 10:19) +Thank You for arising as +Yeshua Ha Meshiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making us every whit whole +according to your original Divine Design +by the stripes of Jesus +and the power of your Word +we are healed (Isaiah 53:5, 1Peter 2:24) + +And that Christ in us +Is SO MUCH greater than +he that is in the world (1John 4:4) +That we are new creatures in Jesus Christ +that old things have past away +and all things are become new (2Corinthians 5:17) +I thank You, God, that You are our shield, +the glory and the Lifter of our heads (Psalms 3:3) +Thank You, Father that You +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank You for reversing all injury +done to our physical +and energetic bodies, +our spirits, our souls, +our lives, our finances, +our families, our friends, +our testimonies, our relationships, +our Churches, our nations, and our destinies +in Jesus’ mighty name +so that we are even better than before (Romans 8:28) + +And that the earth helps the True Church/the woman +and swallows up the flood (Revelations 12:16) +Thank You, Father God, that You +Are the Lord our Healer (Exodus 15:16) +That we are new creatures in Jesus Christ +that old things have past away +and all things are become new (2Corinthians 5:17) +Heavenly Father I thank You +That according to Your Word, We, +Your people, have been translated +out of the Kingdom of Darkness +into the Kingdom of Jesus Christ (Colossians 1:13) +That we are no longer subject +to the beggarly element (Galatians 4) +Thank You, Father that You +have made us more than conquerors through Jesus Christ (Revelations 12:14) +And that you have prepared a place for the +True Church/the woman +In the wilderness to be fed +and nourished for a season (Revelations 12:14) +Therefore I ask in the name of the Lord Jesus Christ +that You would please send and anchor +myself and everyone in my prayer ark +to the most perfect timeline +and reality in Your Divine will (Romans 12;2) +And with Songs of Deliverance (Psalms 32:7) +That you surround us +with favor as a shield (Psalms 5:12) +And have the mind of Christ (1Corinthians 2:16) + +Thank You for reversing all injury +done to our physical +and energetic bodies, +our spirits, our souls, +our lives, our finances, +our families, our friends, +our testimonies, our relationships, +our Churches, our nations, and our destinies +in Jesus’ mighty name +so that we are even better than before (Romans 8:28) +And that the earth helps the True Church/the woman +and swallows up the flood (Revelations 12:16) +No purpose of yours in the earth +can be thwarted (Job 42:2) +And that the earth helps the True Church/the woman +and swallows up the flood (Revelations 12:16) +Thank You, Father God, that You +are the Lord our Healer (Exodus 15:16) +That we are new creatures in Jesus Christ +that old things have past away +and all things are become new (2Corinthians 5:17) +Heavenly Father I thank You +that according to Your Word, We +Your People, have been translated +out of the Kingdom of Darkness +into the Kingdom of Jesus Christ (Colossians 1:13) +That we are no longer subject +to the beggarly element (Galatians 4) +Thank You, Father that You +have made us more than conquerors through Jesus Christ (Revelations 12:14) +And that you have prepared a place for the +True Church/the woman +In the wilderness to be fed +and nourished for a season (Revelations 12:14) +Therefore I ask in the name of the Lord Jesus Christ +that You would please send and anchor +myself and everyone in my prayer ark +to the most perfect timeline +and reality in Your Divine will (Romans 12;2) +And that you give us the victory +through the Lord Jesus (1Corinthians 15:57) +And have the mind of Christ (Corinthians 2:16) + +Thank You Father, that You +are the Lord our Healer (Exodus 15:26) +That we are new creatures in Jesus Christ +that old things have past away +and all things are become new (2Corinthians 5:17) +Heavenly Father, I thank You +that according to Your Word, +We Your People, have been translated +out of the Kingdom of Darkness +into the kingdom off Jesus Christ (Colossians 1:13) +That we are no longer subject +to the beggarly element (Galatians 4) +Thank You, Father that You +have made us more than conquerors through Jesus Christ (Revelations 12:14) +And that you have prepared a place for the +True Church/the woman +In the wilderness to be fed +and nourished for a season (Revelations 12:14) +Therefore I ask in the name of the Lord Jesus Christ +that You would please send and anchor +myself and everyone in my prayer ark +to the most perfect timeline +and reality in Your Divine will (Romans 12;2) +And with Songs of Deliverance (Psalms 32:7) +That You surround us +with favor as a shield (Psalms 5:12) + +Father, in the name of the Lord Jesus Christ, +that old things have past away +and all things are become new (2Corinthians 5:17) +Heavenly Father I thank You +that according to Your Word, We +Your People have been translated +out of the Kingdom of Darkness +into the Kingdom of Jesus Christ (Colossians 1:13) +That we are no longer subject +to the beggarly element (Galatians 4) +Thank You, Father that You +have made us more than conquerors through Jesus Christ (Revelations 12:14) +And that you have prepared a place for the +True Church/the woman +In the wilderness to be fed +and nourished for a season (Revelations 12:14) +Therefore I ask in the name of the Lord Jesus Christ +that You would please send and anchor +myself and everyone in my prayer ark +to the most perfect timeline +and reality in Your Divine will (Romans 12;2) +And with Songs of Deliverance (Psalms 32:7) +That you surround us +with favor as a shield (Psalms 5:12) +And have the mind of Christ (1Corinthians 2:16) + +by the Kingdom of Darkness (Isaiah 58:12) +formed or employed against us +by any and every attack, energy, and weapon +that may have been done to me and those in my prayer ark +Thank You for repairing any and all damage +Father in the name of the Lord Jesus Christ, +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +and all things are become new (2Corinthians 5:17) +that old things have past away +That we are new creatures in Jesus Christ +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +by the Kingdom of Darkness (Isaiah 58:12) +formed or employed against us +by any and every attack, energy, and weapon, +that may have been done to me and those in my prayer ark +Thank You for repairing any and all damage +Father, in the name of the Lord Jesus Christ, +that old things have past away +and all things are become new (2Corinthians 5:17) +Heavenly Father I thank You +that according to Your Word, We +Your People, have been translated +out of the Kingdom of Darkness +into the Kingdom of Jesus Christ (Colossians 1:13) +That we are no longer subject +to the beggarly element (Galatians 4) +Thank You, Father that You +have made us more than conquerors through Jesus Christ (Revelations 12:14) +And that you have prepared a place for the +True Church/the woman +In the wilderness to be fed +and nourished for a season (Revelations 12:14) +Therefore I ask in the name of the Lord Jesus Christ +that You would please send and anchor +myself and everyone in my prayer ark +to the most perfect timeline +and reality in Your Divine will (Romans 12;2) +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +and all things are become new (2Corinthians 5:17) +that old things have past away +That we are new creatures in Jesus Christ +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +by the Kingdom of Darkness (Isaiah 58:12) +formed or employed against us +by any and every attack, energy, and weapon +that may have been done to me and those in my prayer ark +Thank You for repairing any and all damage +Father in the name of the Lord Jesus Christ, + + + +so that we are even better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies, +done to our physical +Thank You for reversing all injury +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +and all things are become new (2Corinthians 5:17) +that old things have past away +That we are new creatures in Jesus Christ +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +by the Kingdom of Darkness (Isaiah 43:19) +formed or employed against us +by any and every attack, energy, and weapon +that may have been done to me and those in my prayer ark +Thank you for repairing any and all damage +Father, in the name of the Lord Jesus Christ, +that old things have past away +and all things are become new (2Corinthians 5:17) +Heavenly Father I thank You +that according to Your Word, We +Your People have been translated +by the Kingdom of Darkness (Isaiah 43:19) +formed or employed against us +by any and every attack, energy, and weapon +that may have been done to me and those in my prayer ark +Thank you for repairing any and all damage +Father, in the name of the Lord Jesus Christ, +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank You, Father, that You +so that we are even better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies +done to our physical +Thank You for reversing all injury +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +and all things are become new (2Corinthians 5:17) +that old things have past away +That we are new creatures in Jesus Christ +For we are seated with Christ in Heavenly Places (Ephesians 2:6) + +We are healed (Isaiah 53:5, 1Peter 2:24) +and the Power of your Word +by the stripes of Jesus +destroying by Your original Divine Design +their effect from our entire beings, +thereby nullifying +all poisons and toxins in us +evaporating and eliminating +and its flawless replication +and the Divine DNA download +by the blood of Jesus +every cell in our bodies +touching and transforming +with healing in Your wings +Yeshua Ha Meshiach +Thank You for arising as +And have the mind of Christ (1Corinthians 2:16) +Thank You that you ride King of the flood (Psalms 29:10) +And with Songs of Deliverance (Psalms 32:7) +can be thwarted (Job 42:2) +No purpose of Yours in the earth +Thank You that you ride King of the flood (Psalms 29:10) +by the Kingdom of Darkness (Isaiah 58:12) +formed or employed against us +by any and every attack, energy, and weapon +that may have been done to me and those in my prayer ark +Thank You for repairing any and all damage +Father, in the name of the Lord Jesus Christ, +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank You, Father that You +so that we are even better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies +done to our physical +Thank You for reversing all injury + +Thank You for arising as +Yeshua Ha Meshiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +for by the stripes of Jesus +and the Power of Your Word +we are healed (Isaiah 53:5, 1Peter 2:24) +all poisons and toxins in us +evaporating and eliminating +and its flawless replication +and the Divine DNA download +by the blood of Jesus +every cell in our bodies +touching and transforming +with healing in Your wings +Yeshua Ha Meshiach +Thank You for arising as +And have the mind of Christ (Corinthians 2:16) +Thank You that you ride King of the flood (Psalms 29:10) +And with Songs of Deliverance (Psalms 32:7) +can be thwarted (Job 42:2) +No purpose of Yours in the earth +Thank You that you ride King of the flood (Psalms 29:10) +by the Kingdom of Darkness (Isaiah 58:12) +formed or employed against us +by any and every attack, energy, and weapon +that may have been done to me and those in my prayer ark +thank You for repairing any and all damage +Father, in the name of Jesus Christ, + +from Your love (Romans 8:39) +NO ONE can separate us +and all things are become new (2Corinthians 5:17) +that old things have past away +That we are new creatures in Jesus Christ +from Your love (Romans 8:39) +NO ONE can separate us +Grace does MUCH MORE abound (Romas 5:20) +Thank you, Father that where sin abounds +we are healed (Isaiah 53:5, 1Peter 2:24) +and the power of Your Word +for by the stripes of Jesus +according to Your original Divine Design +and making us every whit whole +pathagens, prions, and parasites +all engineered or natural free radicals. +destroying by Your Glory and Power +their effect for our entire beings, +thereby nullifying +all poisons and toxins in us +evaporating and eliminating +and its flawless replication +and the Divine DNA Download +by the blood of Jesus +every cell in our bodies +touching and transforming +with healing in Your wings +Yeshua Ha Meshiach +Thank You for arising as +by the Kingdom of Darkness (Isaiah 58:12) +formed or employed against us +by any and every attack, energy, and weapon +that may have been done to me and those in my prayer ark +Thank You for repairing any and all damage +Father, in the name of the Lord Jesus Christ, +Thank You that you ride King of the flood (Psalms 29:10) +And with Songs of Deliverance (Psalms 32:7) +And have the mind of Christ (Corinthians 2:16) +to the beggarly element (Galatians 4) +That we are no longer subject +that You daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father, I praise You and thank You +from your love (Romans 8:39) +NO ONE can separate us +and all things are become new (2Corinthians 5:17) +that old things have passed away +That we are new creatures in Jesus Christ +And have the mind of Christ (Corinthians 2:16) +from your love (Romans 8:39) +NO ONE can separate us +Grace does MUCH MORE abound (Romas 5:20 +Thank you, Father that where sin abounds + +into the Kingdom of Jesus Christ (Colossians 1:13) +out of the Kingdom of Darkness +Your People, have been translated +that according to Your Word, We +Heavenly Father, I praise You and thank You +days of Noah and his family (Genesis 7) +just as you did in the +of ungodliness and evil +And for bearing us up above the waves of the floods +and all things are become new (2Corinthians 5:17) +that old things have passed away +That we are new creatures in Jesus Christ +by the Kingdom of Darkness (Isaiah 43:19) +formed or employed against us +by any and every attack, energy, and weapon +that may have been done to me and those in my prayer ark +Thank you for repairing any and all damage +Father, in the name of the Lord Jesus Christ, +Thank You that you ride King of the flood (Psalms 29:10) +And with Songs of Deliverance (Psalms 32:7) +And have the mind of Christ (Corinthians 2:16) +to the beggarly element (Galatians 4) +That we are no longer subject +that You daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father, I praise You and thank You +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank You, Father that You +through the Lord Jesus (1Corinthians 15:57) +And that you give us the victory +through the Lord Jesus (1Corinthians 15:57) +And that you give us the victory +You raise up a standard against him (Isaiah 59:19) +Thank You that when the enemy comes in like a flood, +by the Kingdom of Darkness (Isaiah 58:12) +formed or employed against us +by any and every attack, energy, and weapon +that may have been done to me and those in my prayer ark +thank You for repairing any and all damage +Father, in the name of Jesus Christ, +into the Kingdom of Jesus Christ (Colossians 1:13) +out of the Kingdom of Darkness +Your People, have been translated +that according to Your Word, We +Heavenly Father, I praise You and thank You +days of Noah and his family (Genesis 7) +just as you did in the +of ungodliness and evil +And for bearing us up above the waves of the floods +and all things are become new (2Corinthians 5:17) +that old things have passed away +That we are new creatures in Jesus Christ + + + +Thank You that you ride King of the flood (Psalms 29:10) +are the Lord our Healer (Exodus 15:26) +Thank You Father, that You +to the beggarly element (Galatians 4) +That we are no longer subject +And with Songs of Deliverance (Psalms 32:7) +Into the Kingdom of Jesus Christ (Colossians 1:13) +out of the Kingdom of Darkness +Your People, have been translated +that according to Your Word, We +Heavenly Father, I praise You and thank You +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank You, Father that You +through the Lord Jesus (1Corinthians 15:57) +And that you give us the victory +through the Lord Jesus (1Corinthians 15:57) +And that you give us the victory +You raise up a standard against him (Isaiah 59:19) +Thank You that when the enemy comes in like a flood, +by the Kingdom of Darkness (Isaiah 58:12) +formed or employed against us +by any and every attack, energy, and weapon +that may have been done to me and those in my prayer ark +Thank You for repairing any and all damage +that You daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father, I praise You and thank You +Into the Kingdom of Jesus Christ (Colossians 1:13) +out of the Kingdom of Darkness +Your People, have been translated +that according to Your Word, We +Heavenly Father, I praise You and thank You +are the Lord our Healer (Exodus 15:26) +Thank You, Father God, that You +Because your are doing a new thing in the earth (Isaiah 43:19) +that NO WEAPON formed against us shall prosper (Isaiah 54:17) +I thank You God +Thank You that You ride King of the flood (Psalms 29:10) +days of Noah and his family (Genesis 7) +just as you did in the +of ungodliness and evil +And for bearing us up above the waves of the floods +are the Lord our Healer (Exodus 15:26) +Thank You Father that You +to the beggarly element (Galatians 4) +That we are no longer subject +And with Songs of Deliverance (Psalms 32:7) +Into the Kingdom of Jesus Christ (Colossians 1:13) +out of the Kingdom of Darkness +Your People, have been translated +that according to Your Word, We +Heavenly Father, I praise You and thank You +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank You, Father that You + +Into the Kingdom of Jesus Christ (Colossians 1:13) +out of the Kingdom of Darkness +Your People, have been translated +that according to Your Word, We +Heavenly Father, I praise You and thank You +to the beggarly elements (Galatians 4) +That we are no longer subject +are the Lord our Healer (Exodus 15:26) +Thank You, Father God, that You +that You daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father, I praise You and thank You +into the Kingdom of Jesus Christ (Colossians 1:13) +out of the Kingdom of Darkness +Your People, have been translated +that according to Your Word, We +Heavenly Father, I praise You and thank You +are the Lord our Healer (Exodus 15:26) +Thank You, Father God, that You +Because your are doing a new thing in the earth (Isaiah 43:19) +that NO WEAPON formed against us shall prosper (Isaiah 54:17) +I thank You God +Thank You that You ride King of the flood (Psalms 29:10) +are the Lord our Healer (Exodus 15:26) +Thank You, Father God, that You + +we are healed (Isaiah 53:5, 1Peter 2:24) +and the power of Your Word +for by the stripes of Jesus +according to Your original Divine Design +and making us every whit whole +pathagens, prions, and parasites +all engineered or natural free radicals. +Destroying by Your Glory and Power +their effect for our entire beings, +thereby nullifying +all poisons and toxins in us +evaporating and eliminating +and its flawless replication +and the Divine DNA Download +by the blood of Jesus +every cell in our bodies +touching and transforming +with healing in Your wings +Yeshua Ha Meshiach +Thank You for arising as +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank You, Father that You +to the beggarly elements (Galatians 4) +That we are no longer subject +into the Kingdom of Jesus Christ (Colossians 1:13) +out of the Kingdom of Darkness +Your People, have been translated +that according to Your Word, We +Heavenly Father, I praise You and thank You +to the beggarly elements (Galatians 4) +That we are no longer subject +are the Lord our Healer (Exodus 15:26) +Thank You, Father God, that You +that You daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father, I praise You and thank You +into the Kingdom of Jesus Christ (Colossians 1:13) + +we are healed (Isaiah 53:5, 1Peter 2:24) +and the power of Your Word +for by the stripes of Jesus +according to Your original Divine Design +and making us every whit whole +pathagens, prions, and parasites +all engineered or natural free radicals. +Destroying by Your Glory and Power +their effect for our entire beings, +thereby nullifying +all poisons and toxins in us +evaporating and eliminating +and its flawless replication +and the Divine DNA Download +by the blood of Jesus +every cell in our bodies +touching and transforming +with healing in Your wings +Yeshua Ha Meshiach +Thank You for arising as +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank You, Father that You +to the beggarly elements (Galatians 4) +That we are no longer subject +into the Kingdom of Jesus Christ (Colossians 1:13) +out of the Kingdom of Darkness +Your People, have been translated +that according to Your Word, We +Heavenly Father, I praise You and thank You +to the beggarly elements (Galatians 4) +That we are no longer subject +are the Lord our Healer (Exodus 15:26) +Thank You, Father God, that You +Thank You for arising as +Yeshua Ha Meshiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect for our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals. +pathagens, prions, and parasites +and making us every whit whole +according to Your original Divine Design +for by the stripes of Jesus +and the Power of Your Word +we are healed (Isaiah 53:5, 1Peter 2:24) +That nothing, by any means, shall harm us (Luke 10:19) +NO ONE can separate us +from Your love (Romans 8:39) +That You surround us +with favor as a shield (Psalms 5:12) +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +No purpose of Yours in the earth +can be thwarted (Job 42:2) +And that Christ in us +is SO MUCH greater than +he that is in the world (1John 4:4) +I thank You God +that NO WEAPON formed against us shall prosper (Isaiah 54:17) +Thank You for reversing all injury +done to our physical +and energetic bodies, +our spirits, our souls, +our lives, our finances, +our families, our friends, +our testimonies, our relationships, +our Churches, our nations, and our destinies +in Jesus’ mighty name +so that we are even better than before (Romans 8:28) +And that the earth helps the True Church/the woman +and swallows up the flood (Revelations 12:16) +Because You are doing a new thing in the earth (Isaiah 43:19) +Heavenly Father, I praise You and thank You +for the benefits and blessings +that You daily load us with (Psalms 68:19) +And have the mind of Christ (Corinthians 2:16) +And that Christ in us +is SO MUCH greater than +he that is in the world (1John 4:4) +Thank You for arising as +Yeshua Ha Meshiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +for by the stripes of Jesus +and the Power of Your Word +we are healed (Isaiah 53:5, 1Peter 2:24) +Father, in the name of Jesus Christ, +Thank You for repairing any and all damage +that may have been done to me and those in my prayer ark +by any and every attack, energy, and weapon +formed or employed against us +by the Kingdom of Darkness (Isaiah 58:12) +Thank You, Father that You have not given us a spirit of fear and timidity, +but power, love, sound mind, and self-discipline (2Timothy 1:7) +And with Songs of Deliverance (Psalms 32:7) + +Thank You for arising as +Yeshua Ha Meshiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +for by the stripes of Jesus +and the Power of Your Word +we are healed (Isaiah 53:5, 1Peter 2:24) +Father, in the name of Jesus Christ, +Thank You for repairing any and all damage +that may have been done to me and those in my prayer ark +by any and every attack, energy, and weapon +formed or employed against us +by the Kingdom of Darkness (Isaiah 58:12) +That nothing, by any means, shall harm us (Luke 10:19) +Therefore I ask in the name of the Lord Jesus Christ +that You would please send and anchor +myself and everyone in my prayer ark +to the most perfect timeline +and reality in Your Divine will (Romans 12;2) +And that Christ in us +is SO MUCH greater than +he that is in the world (1John 4:4) +Thank You for reversing all injury +done to our physical +and energetic bodies +our spirits, our souls, +our lives, our finances, +our families, our friends, +our testimonies, our relationships, +our Churches, our nations, and our destinies +in Jesus’ mighty name +so that we are even better than before (Romans 8:28) +Because You are doing a new thing in the earth (Isaiah 43:19) +NO ONE can separate us +from Your love (Romans 8:39) + +And with Songs of Deliverance (Psalms 32:7) +NO ONE can separate us +from Your love (Romans 8:39) +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +And have the mind of Christ (Corinthians 2:16) +That nothing, by any means, shall harm us (Luke 10:19) +I thank You God +that NO WEAPON formed against us shall prosper (Isaiah 54:17) +Therefore I ask in the name of the Lord Jesus Christ +that You would please send and anchor +myself and everyone in my prayer ark +to the most perfect timeline +and reality in Your Divine will (Romans 12;2) +Thank you, Father that where sin abounds +Grace does MUCH MORE abound (Romas 5:20) +Therefore I ask in the name of the Lord Jesus Christ +that You would please send and anchor +myself and everyone in my prayer ark +to the most perfect timeline +and reality in Your Divine will (Romans 12;2) +And that you have prepared a place for the +True Church/the woman +in the wilderness to be fed +and nourished for a season (Revelations 12:14) +Thank You that you ride King of the flood (Psalms 29:10) +Thank You that you ride King of the flood (Psalms 29:10) +Father, in the name of Lord Jesus Christ, +Thank You for repairing any and all damage +that may have been done to me and those in my prayer ark +by any and every attack, energy, and weapon +formed or employed against us +by the Kingdom of Darkness (Isaiah 58:12) +And with Songs of Deliverance (Psalms 32:7) +And that You have not given us a spirit of fear, +but power, love, and sound mind (2Timothy 1:7) +Heavenly Father, I praise You and thank You +for the benefits and blessings +that You daily load us with (Psalms 68:19) + +so that we are even better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies, +done to our physical +Thank You for reversing all injury +Thank you, Father that where sin abounds +Grace does MUCH MORE abound (Romas 5:20) +Therefore, I ask in the name of the Lord Jesus Christ +that You would please send and anchor +myself and everyone in my prayer ark +to the most perfect timeline +and reality in Your Divine will (Romans 12;2) +And that you have prepared a place for the +True Church/the woman +in the wilderness to be fed +and nourished for a season (Revelations 12:14) +Thank You that you ride King of the flood (Psalms 29:10) +Thank You that you ride King of the flood (Psalms 29:10) +Father, in the name of Lord Jesus Christ, +Thank You for repairing any and all damage +that may have been done to me and those in my prayer ark +by any and every attack, energy, and weapon +formed or employed against us +by the Kingdom of Darkness (Isaiah 58:12) +And with Songs of Deliverance (Psalms 32:7) +Thank You, Father that You have not given us a spirit of fear, +but power, love, and sound mind (2Timothy 1:7) +Heavenly Father, I praise You and thank You + +for the benefits and blessings +that You daily load us with (Psalms 68:19) +by the Kingdom of Darkness (Isaiah 58:12) +formed or employed against us +by any and every attack, energy, and weapon +that may have been done to me and those in my prayer ark +Thank You for repairing any and all damage +Father, in the name of Lord Jesus Christ, +so that we are even better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies, +done to our physical +Thank You for reversing all injury +Thank you, Father that where sin abounds +Grace does MUCH MORE abound (Romas 5:20) +Therefore, I ask in the name of the Lord Jesus Christ +that You would please send and anchor +myself and everyone in my prayer ark +to the most perfect timeline +and reality in Your Divine will (Romans 12:2) +And that you have prepared a place for the +True Church/the woman +in the wilderness to be fed +and nourished for a season (Revelations 12:14) + +but power, love, and sound mind (2Timothy 1:7) +Thank You, Father that You have not given us a spirit of fear, +That nothing, by any means, shall harm us (Luke 10:19) +And with Songs of Deliverance (Psalms 32:7) +That nothing, by any means, shall harm us (Luke 10:19) +Thank You that you ride King of the flood (Psalms 29:10) +Grace does MUCH MORE abound (Romas 5:20) +Thank you, Father that where sin abounds +and swallows up the flood (Revelations 12:16) +And that the earth helps the True Church/the woman +by the Kingdom of Darkness (Isaiah 58:12) +formed or employed against us +by any and every attack, energy, and weapon, +that may have been done to me and those in my prayer ark +Thank You for repairing any and all damage +Father, in the name of Jesus Christ, +so that we are even better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies, +done to our physical +Thank You for reversing all injury + +to the beggarly elements (Galatians 4) +That we are no longer subject +And with Songs of Deliverance (Psalms 32:7) +You rise up a standard against him. (Isaiah 59:19) +Thank You that when the enemy comes in like a flood, +And with Songs of Deliverance (Psalms 32:7) +that You daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father, I praise You and thank You +that You daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father, I praise You and thank You +from Your love (Romans 8:39) +NO ONE can separate us +but power, love, and sound mind (2Timothy 1:7) +Thank You, Father that You have not given us a spirit of fear, +That nothing, by any means, shall harm us (Luke 10:19) +And with Songs of Deliverance (Psalms 32:7) +Thank You that you ride King of the flood (Psalms 29:10) +Grace does MUCH MORE abound (Romas 5:20) +Thank you, Father that where sin abounds +and swallows up the flood (Revelations 12:16) +And that the earth helps the True Church/the woman +by the Kingdom of Darkness (Isaiah 58:12) +formed or employed against us +by any and every attack, energy, and weapon, +that may have been done to me and those in my prayer ark +Thank You for repairing any and all damage +Father, in the name of Jesus Christ, + +to the beggarly elements (Galatians 4) +That we are no longer subject +NO ONE can be against us. (Romans 8:31) +And that because You are for us +And with Songs of Deliverance (Psalms 32:7) +and swallows up the flood (Revelations 12:16) +And that the earth helps the True Church/the woman +and reality in Your Divine Will (Romans 12:2) +to the most perfect timeline +myself and everyone in my prayer ark +that You would please send and anchor +Therefore, I ask in the name of the Lord Jesus Christ, +to the beggarly elements (Galatians. 4) +That we are no longer subject +And with Songs of Deliverance (Psalms 32:7) +You raise up a standard against him. (Isaiah 59:19) +Thank You that when the enemy comes in like a flood, +And with Songs of Deliverance (Psalms 32:7) +that You daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father, I praise You and thank You +that You daily load us with (Psalms 68:19) +for the benefits and blessings +Heavenly Father, I praise You and thank You +from Your love (Romans 8:39) +NO ONE can separate us +And with Songs of Deliverance (Psalms 32:7) +by the Kingdom of Darkness (Isaiah 58:12) +formed or employed against us +by any and every attack, energy, and weapon, +that may have been done to me and those in my prayer ark +Thank You for repairing any and all damage +Father, in the name of the Lord Jesus Christ, +are the Lord our Healer (Exodus 15:26) +Thank You, Father God, that You +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank you, Father that You +to the beggarly element (Galatians 4) +That we are no longer subject +NO ONE can be against us. (Romans 8:31) +And that because You are for us +And with Songs of Deliverance (Psalms 32:7) +and swallows up the flood (Revelations 12:16) +And that the earth helps the True Church/the woman +and reality in Your Divine will (Romans 12;2) +to the most perfect timeline +myself and everyone in my prayer ark +that You would please send and anchor +Therefore, I ask in the name of the Lord Jesus Christ +to the beggarly element (Galatians 4) +That we are no longer subject + +we are healed (Isaiah 53:5, 1Peter 2:24) +and the power of Your Word +for by the stripes of Jesus +according to Your original Divine Design +and making us every whit whole +pathagens, prions, and parasites +all engineered or natural free radicals. +Destroying by Your Glory and Power +their effect for our entire beings, +thereby nullifying +all poisons and toxins in us +evaporating and eliminating +and its flawless replication +and the Divine DNA Download +by the blood of Jesus +every cell in our bodies +touching and transforming +with healing in Your wings +Yeshua Ha Meshiach +Thank You for arising as +And with Songs of Deliverance (Psalms 32:7) +by the Kingdom of Darkness (Isaiah 58:12) +formed or employed against us +by any and every attack, energy, and weapon, +that may have been done to me and those in my prayer ark +Thank You for repairing any and all damage +Father, in the name of the Lord Jesus Christ, +are the Lord our Healer (Exodus 15:26) +Thank You, Father God, that You +have made us more than conquerors through Jesus Christ (Revelations 12:14) +Thank you, Father that You +so that we are even better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies, +done to our physical +Thank You for reversing all injury +we are healed (Isaiah 53:5, 1Peter 2:24) +and the power of Your Word +for by the stripes of Jesus +according to Your original Divine Design +and making us every whit whole +pathagens, prions, and parasites +all engineered or natural free radicals. +Destroying by Your Glory and Power +their effect for our entire beings, +thereby nullifying +all poisons and toxins in us +evaporating and eliminating +and its flawless replication +and the Divine DNA Download +by the blood of Jesus +every cell in our bodies +touching and transforming +with healing in Your wings +Yeshua Ha Meshiach +Thank You for arising as + +You raise up a standard against him. (Isaiah 59:19) +Thank You that when the enemy comes in like a flood, +but power, love, and sound mind (2Timothy 1:7) +Thank You, Father, that You have not given us a spirit of fear, +You raise up a standard against him. (Isaiah 59:19) +Thank You that when the enemy comes in like a flood, +so that we are even better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies, +done to our physical +Thank You for reversing all injury +we are healed (Isaiah 53:5, 1Peter 2:24) +and the Power of Your Word +for by the stripes of Jesus +according to your original Divine Design +and making us every whit whole +pathagens, prions, and parasites +all engineered or natural free radicals. +Destroying by Your Glory and Power +their effect for our entire beings, +thereby nullifying +all poisons and toxins in us +evaporating and eliminating +and its flawless replication +and the Divine DNA Download +by the blood of Jesus +every cell in our bodies +touching and transforming +with healing in Your wings +Yeshua Ha Meshiach +Thank You for arising as +Thank You that you ride King of the flood (Psalms 29:10) +You raise up a standard against him (Isaiah 59:19) +Thank You that when the enemy comes in like a flood, +but power, love, and sound mind (2Timothy 1:7) +Thank You, Father, that You have not given us a spirit of fear, +You raise up a standard against him (Isaiah 59:19) +Thank You that when the enemy comes in like a flood, +so that we are even better than before (Romans 8:28) +in Jesus’ mighty name +our Churches, our nations, and our destinies +our testimonies, our relationships, +our families, our friends, +our lives, our finances, +our spirits, our souls, +and energetic bodies, +done to our physical +Thank You for reversing all injury +And for bearing us up above the waves of the floods +of ungodliness and evil +just as You did in the +days of Noah for Noah and his family (Genesis 7) + +Thank You for arising as +Yeshua Ha Meshiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +for by the stripes of Jesus +and the Power of Your Word +we are healed (Isaiah 53:5, 1Peter 2:24) +And that You have not given us a spirit of fear, +but power, love, and sound mind (2 Timothy 1:7) +Thank You that you ride King of the flood (Psalms 29:10) +For we are seated with Christ in Heavenly Places (Ephesians 2:6) +Heavenly Father, I thank You +that according to Your Word, +we Your People, have been translated +out of the Kingdom of Darkness +into the kingdom off Jesus Christ (Colossians 1:13) +I thank You God +that NO WEAPON formed against us shall prosper (Isaiah 54:17) +No purpose of Yours in the earth +can be thwarted (Job 42:2) +And that the earth helps the True Church/the woman +and swallows up the flood (Revelations 12:16) +And that you give us the victory +through the Lord Jesus (1Corinthians 15:57) + +And that Christ in us +is SO MUCH greater than +he that is in the world (1John 4:4) +Because You are doing a new thing in the earth (Isaiah 43:19) +And that the earth helps the True Church/the woman +and swallows up the flood (Revelations 12:16) +Thank You for arising as +Yeshua Ha Meshiach +with healing in Your wings +touching and transforming +every cell in our bodies +by the blood of Jesus +and the Divine DNA download +and its flawless replication +evaporating and eliminating +all poisons and toxins in us +thereby nullifying +their effect from our entire beings, +destroying by Your Glory and Power +all engineered or natural free radicals, +pathogens, prions, and parasites +and making every whit whole +according to Your original Divine Design +for by the stripes of Jesus +and the Power of Your Word +we are healed (Isaiah 53:5, 1Peter 2:24) \ No newline at end of file diff --git a/share/rhemawave/proclamations/home/Bathe In Blessings.txt b/share/rhemawave/proclamations/home/Bathe In Blessings.txt new file mode 100644 index 0000000..22291e4 --- /dev/null +++ b/share/rhemawave/proclamations/home/Bathe In Blessings.txt @@ -0,0 +1,49 @@ +shall the mind and body now: Project its awareness, attention, belief, and +intention into all times dimensions of undivided universal field of +consciousness and identity, accept and release attunement to all events, +information faults, and information faults hidden that compromises +awareness of, or define into existence, the transformed-from state? Or, +that cause this transformative information quanta to define into existence +the transformed-to system state? Or that cause this transformation to +seem dangerous, undeserved, or impossible to achieve? Create awareness, +acceptance, attunement, and belief of all corrective events and +transformative information quanta to define into existence the +transformed-to system state? + +Create the intention to collapse the quantum potential the field’s reality +quantum potential of the field’s reality quant to manifest this +transformation? Create optimal attunement and coherence to the source of +creation, GOD, innate intelligence, and the consciousness of healing and +accept the role of co-creator of all experienced reality, NOW? + +I am grateful GOD lives through me and blesses all aspects of my life. + +I am thankful for my health, vitality, and motivation to pursue a deeper +understanding of the Trinity so that I become a shining example of +someone who’s life is truly blessed and lived according to GOD’s design. + +I appreciate GOD providing strength and direction to every cell in my +body and blesses my life in countless ways. +I am pleased I have the freedom to worship our creator, follow his +teachings, and receive blessings according to GOD’s design. + +I enjoy knowing GOD protects me, blesses me, and allows me to pursue a +deep and personal relationship with him. + +I am happy I can pray, speak with GOD directly, seek his advice, follow +his teachings, and receive his blessings. + +I am grateful GOD’s healing hands are on me creating miracles in all +areas of my life. + +I am thankful I wake up each morning inspired to learn, trust, and follow +GOD’s plan for my life. + +I appreciate GOD’s almighty power flowing though me and creating +miracles in all areas of my life. + +I am pleased my life is blessed and I live a perpetually blissful life. + +I am grateful to GOD for all the blessings bestowed upon me. + +I am thankful to GOD for his forgiveness, understanding, and love. \ No newline at end of file diff --git a/share/rhemawave/proclamations/home/Become An Ultimate Optimist.txt b/share/rhemawave/proclamations/home/Become An Ultimate Optimist.txt new file mode 100644 index 0000000..78efa5e --- /dev/null +++ b/share/rhemawave/proclamations/home/Become An Ultimate Optimist.txt @@ -0,0 +1,56 @@ +shall the mind and body now: Project its awareness, attention, belief, and +intention into all times dimensions of undivided universal field of +consciousness and identity, accept and release attunement to all events, +information faults, and information faults hidden that compromises +awareness of, or define into existence, the transformed-from state? Or, +that cause this transformative information quanta to define into existence +the transformed-to system state? Or that cause this transformation to +seem dangerous, undeserved, or impossible to achieve? Create awareness, +acceptance, attunement, and belief of all corrective events and +transformative information quanta to define into existence the +transformed-to system state? + +Create the intention to collapse the quantum potential the field’s reality +quantum potential of the field’s reality quant to manifest this +transformation? Create optimal attunement and coherence to the source of +creation, GOD, innate intelligence, and the consciousness of healing and +accept the role of co-creator of all experienced reality, NOW? + +I am grateful GOD lives through me and inspires me to see the best in +every person and every opportunity. + +I am thankful for my life, health, and vitality and express my +appreciation by always focusing on the positive aspects of every +situation I encounter. + +I appreciate GOD providing strength and direction to every cell in my +body which I use to maintain a positive attitude regardless of my +personal situation. + +I am pleased I always think positive, manage my thoughts, and live each +day striving energetically to accomplish goals which positively effect +my life and the lives of those around me according to GOD’s design. + +I enjoy knowing GOD protects me and allows me to achieve things I once +thought impossible. + +I am happy I think positively, I do not dwell on negative issues, and I +control my thoughts at all times. + +I am grateful GOD’s healing hands are on me creating miracles in all +areas of my life. + +I am thankful I wake up each morning yearning to efficiently accomplish +as many tasks as possible to ensure success in all my endeavors. + +I appreciate GOD’s almighty power flowing through me and creating +miracles in all areas of my life as a reward my optimism. + +I am pleased my mental health and emotional stability allow me remain +positive and live a relaxed and perpetually blissful life. + +I am grateful to GOD for all the blessings bestowed upon me. + +I am thankful that I only seek the good in myself, the good in others, +the good in the world around me, and the greatness of the live I am +living. \ No newline at end of file diff --git a/share/rhemawave/proclamations/home/Blood Chemistry.txt b/share/rhemawave/proclamations/home/Blood Chemistry.txt new file mode 100644 index 0000000..950a3b0 --- /dev/null +++ b/share/rhemawave/proclamations/home/Blood Chemistry.txt @@ -0,0 +1,56 @@ +shall the mind and body now: Project its awareness, attention, belief, and +intention into all times dimensions of undivided universal field of +consciousness and identity, accept and release attunement to all events, +information faults, and information faults hidden that compromises +awareness of, or define into existence, the transformed-from state? Or, +that cause this transformative information quanta to define into existence +the transformed-to system state? Or that cause this transformation to +seem dangerous, undeserved, or impossible to achieve? Create awareness, +acceptance, attunement, and belief of all corrective events and +transformative information quanta to define into existence the +transformed-to system state? + +Create the intention to collapse the quantum potential the field’s reality +quantum potential of the field’s reality quant to manifest this +transformation? Create optimal attunement and coherence to the source of +creation, GOD, innate intelligence, and the consciousness of healing and +accept the role of co-creator of all experienced reality, NOW? + +I am grateful GOD lives through me and causes my circulatory system to +remain clear and unobstructed for for optimum health and longevity. + +I am thankful for my health, vitality, and motivation to eat properly, +exercise, and strengthen my body. + +I appreciate GOD providing strength and direction to every cell in my +body ensuring my blood chemistry is, and remains optimal for excellent +health and longevity. + +I am pleased my muscles, bones, joints, organs, nerves, tendons, and +ligaments all develop correctly and function normally. + +I enjoy knowing GOD protects me throughout and beyond the physical +healing and development process. + +I am happy my HDL, LDL, Triglycerides, and Blood Sugar levels are and +remain at ideal levels for my optimal health and longevity according to +GOD’s design. + +I am grateful GOD’s healing hands are on me creating miracles in all +areas of my life. + +I am thankful I wake up each morning yearning to eat healthy foods and +exercise in ways that ensure my HDL, LDL, Triglycerides, and Blood Sugar +levels are ideal. + +I appreciate GOD’s almighty power flowing though me, creating miracles +in all areas of my life, and correcting, curing, and developing all +healthy aspects of my mind and my body. + +I am pleased my blood, heart, arteries, and entire circulatory system +perpetually improves each day. + +I am grateful to GOD for all the blessings bestowed upon me. + +I am thankful I only crave healthy foods that provide my body with the +nutrition necessary for my optimum health and wellbeing. \ No newline at end of file diff --git a/share/rhemawave/proclamations/home/Deep Sleep.txt b/share/rhemawave/proclamations/home/Deep Sleep.txt new file mode 100644 index 0000000..306b437 --- /dev/null +++ b/share/rhemawave/proclamations/home/Deep Sleep.txt @@ -0,0 +1,61 @@ +shall the mind and body now: Project its awareness, attention, belief, and +intention into all times dimensions of undivided universal field of +consciousness and identity, accept and release attunement to all events, +information faults, and information faults hidden that compromises +awareness of, or define into existence, the transformed-from state? Or, +that cause this transformative information quanta to define into existence +the transformed-to system state? Or that cause this transformation to +seem dangerous, undeserved, or impossible to achieve? Create awareness, +acceptance, attunement, and belief of all corrective events and +transformative information quanta to define into existence the +transformed-to system state? + +Create the intention to collapse the quantum potential the field’s reality +quantum potential of the field’s reality quant to manifest this +transformation? Create optimal attunement and coherence to the source of +creation, GOD, innate intelligence, and the consciousness of healing and +accept the role of co-creator of all experienced reality, NOW? + +I am grateful GOD lives through me and inspires my body enter deep sleep +and heal miraculously during the night so that I enjoy optimum health. + +I am thankful for my health, vitality, and ability to experience deep +healing sleep each and every night. + +I appreciate GOD providing strength and direction to every cell in my +body allowing me to sleep deeply and heal all mental, physical, and +spiritual aspects of my being ensuring my optimum overall health. + +I am pleased my muscles, bones, joints, organs, nerves, tendons, and +ligaments all heal well during my deep sleep and remain in optimum +condition according to GOD’s design. + +I enjoy knowing GOD protects me throughout and beyond the physical +healing and development process. + +I am happy my body, mind, and spirit grows stronger each and every day +as a result of my experiencing deep and restful sleep. + +I am grateful GOD’s healing hands are on me creating miracles in all +areas of my life and allowing me to experience deep restful, healing +sleep each night. + +I am thankful I am able to easily clear my thoughts when I lay down at +night to sleep, enter deep and restful sleep, and enjoy wonderful +uplifting dreams as my body, mind, and spirit heal, advance, and grow +stronger. + +I appreciate GOD’s almighty power flowing though me, creating miracles +in all areas of my life, and correcting, curing, and developing all +healthy aspects of my mind and my body during my deep and restful sleep +each night. + +I am pleased to wake each morning well rested, energized, and prepared +to face the challenges each day brings with confidence, a positive +attitude, and perseverance. + +I am grateful to GOD for all the blessings bestowed upon me. + +I am thankful I only crave healthy foods that provide my body with the +nutrition necessary to rest well, sleep deep, heal swiftly, and optimize +my health and wellbeing. \ No newline at end of file diff --git a/share/rhemawave/proclamations/home/Empower My Relationship with God.txt b/share/rhemawave/proclamations/home/Empower My Relationship with God.txt new file mode 100644 index 0000000..50ae7b0 --- /dev/null +++ b/share/rhemawave/proclamations/home/Empower My Relationship with God.txt @@ -0,0 +1,56 @@ +shall the mind and body now: Project its awareness, attention, belief, and +intention into all times dimensions of undivided universal field of +consciousness and identity, accept and release attunement to all events, +information faults, and information faults hidden that compromises +awareness of, or define into existence, the transformed-from state? Or, +that cause this transformative information quanta to define into existence +the transformed-to system state? Or that cause this transformation to +seem dangerous, undeserved, or impossible to achieve? Create awareness, +acceptance, attunement, and belief of all corrective events and +transformative information quanta to define into existence the +transformed-to system state? + +Create the intention to collapse the quantum potential the field’s reality +quantum potential of the field’s reality quant to manifest this +transformation? Create optimal attunement and coherence to the source of +creation, GOD, innate intelligence, and the consciousness of healing and +accept the role of co-creator of all experienced reality, NOW? + +I am grateful GOD lives through me and inspires me to believe in him, +trust in him, and follow biblical teachings. + +I am thankful for my health, vitality, and motivation to include GOD in +all aspects of my life. + +I appreciate GOD providing strength and direction to every cell in my +body which empowers my relationship with him more and more each and +every day. + +I am pleased my personal relationship with GOD continues to grow stronger +as I strive to make him a greater influence in my life and live my life +according to GOD’s design. + +I enjoy knowing GOD protects me and allows me to develop a deeper and +stronger relationship with him and demonstrate my beliefs and +relationship in all aspects of my life. + +I am happy my deepening connection with GOD brings peace and harmony to +my life. + +I am grateful GOD’s healing hands are on me creating miracles in all +areas of my life that I set an outstanding example of living the life of +a true believer. + +I am thankful I wake up each morning yearning to share my faith and +understanding of our great Creator. + +I appreciate GOD’s almighty power flowing through me and creating +miracles in all areas of my life. + +I am pleased my undying faith in GOD allows me to live a relaxed and +perpetually blissful lifestyle. + +I am grateful to GOD for all the blessings bestowed upon me. + +I am thankful I know GOD and share my beliefs with others at every +opportunity. \ No newline at end of file diff --git a/share/rhemawave/proclamations/home/Goal Setting and Achievement.txt b/share/rhemawave/proclamations/home/Goal Setting and Achievement.txt new file mode 100644 index 0000000..453b9ef --- /dev/null +++ b/share/rhemawave/proclamations/home/Goal Setting and Achievement.txt @@ -0,0 +1,56 @@ +shall the mind and body now: Project its awareness, attention, belief, and +intention into all times dimensions of undivided universal field of +consciousness and identity, accept and release attunement to all events, +information faults, and information faults hidden that compromises +awareness of, or define into existence, the transformed-from state? Or, +that cause this transformative information quanta to define into existence +the transformed-to system state? Or that cause this transformation to +seem dangerous, undeserved, or impossible to achieve? Create awareness, +acceptance, attunement, and belief of all corrective events and +transformative information quanta to define into existence the +transformed-to system state? + +Create the intention to collapse the quantum potential the field’s reality +quantum potential of the field’s reality quant to manifest this +transformation? Create optimal attunement and coherence to the source of +creation, GOD, innate intelligence, and the consciousness of healing and +accept the role of co-creator of all experienced reality, NOW? + +I am grateful GOD lives through me and inspires me to set and accomplish +clear and concise goals. + +I am thankful for my health, vitality, and motivation to accomplish the +goals I set efficiently and effectively. + +I appreciate GOD providing strength and direction to every cell in my +body ensuring I plan, focus, and accomplish my goals and live according +to GOD’s design. + +I am pleased I can visualize, set, and accomplish goals I once thought +were beyond my abilities so long as they remain according to GOD’s +design. + +I enjoy knowing GOD protects me and enables me to accomplish tasks I once +believed were unattainable. + +I am happy I think positively and strive to legally and ethically +maximize my accomplishments and my profits. + +I am grateful GOD’s healing hands are on me and create miracles in all +areas of my life. + +I am thankful I wake up each morning yearning to work and accomplish my +list of goals and tasks in a timely manner. + +I appreciate GOD’s almighty power flowing though me, creating miracles +in all areas of my life, and enabling me to accomplish my goals +efficiently and effectively. + +I am pleased my ability to accomplish tasks and goals efficiently allows +me to live a relaxed and perpetually blissful life. + +I am grateful to GOD for all the blessings bestowed upon me. + +I am thankful that I only crave healthy foods that provide my mind and +body with the nutrition necessary for me to set and achieve all my goals +in record time. \ No newline at end of file diff --git a/share/rhemawave/proclamations/home/Health and Fitness.txt b/share/rhemawave/proclamations/home/Health and Fitness.txt new file mode 100644 index 0000000..2d5e770 --- /dev/null +++ b/share/rhemawave/proclamations/home/Health and Fitness.txt @@ -0,0 +1,53 @@ +shall the mind and body now: Project its awareness, attention, belief, and +intention into all times dimensions of undivided universal field of +consciousness and identity, accept and release attunement to all events, +information faults, and information faults hidden that compromises +awareness of, or define into existence, the transformed-from state? Or, +that cause this transformative information quanta to define into existence +the transformed-to system state? Or that cause this transformation to +seem dangerous, undeserved, or impossible to achieve? Create awareness, +acceptance, attunement, and belief of all corrective events and +transformative information quanta to define into existence the +transformed-to system state? + +Create the intention to collapse the quantum potential the field’s reality +quantum potential of the field’s reality quant to manifest this +transformation? Create optimal attunement and coherence to the source of +creation, GOD, innate intelligence, and the consciousness of healing and +accept the role of co-creator of all experienced reality, NOW? + +I am grateful GOD lives through me and inspires me to achieve optimum +health. + +I am thankful for my health, vitality, and motivation to eat properly, +exercise, and strengthen my body. + +I appreciate GOD providing strength and direction to every cell in my +body ensuring optimum health and fitness. + +I am pleased my muscles, bones, joints, organs, nerves, tendons, and +ligaments all develop correctly and function normally according to GOD’s +design. + +I enjoy knowing GOD protects me throughout and beyond the physical +healing and development process. + +I am happy my muscles and bones grow stronger each and every day. + +I am grateful GOD’s healing hands are on me creating miracles in all +areas of my life. + +I am thankful that I wake up each morning yearning to eat health foods +and exercise. + +I appreciate GOD’s almighty power flowing though me, creating miracles +in all areas of my life, and correcting, curing, and developing all +healthy aspects of my mind and my body. + +I am pleased my muscles and stamina develop rapidly and I continue +growing perpetually stronger each day. + +I am grateful to GOD for all the blessings bestowed upon me. + +I am thankful I only crave healthy foods that provide my body with the +nutrition necessary for my optimum health and wellbeing. \ No newline at end of file diff --git a/share/rhemawave/proclamations/home/Health and Wellbeing.txt b/share/rhemawave/proclamations/home/Health and Wellbeing.txt new file mode 100644 index 0000000..9c371da --- /dev/null +++ b/share/rhemawave/proclamations/home/Health and Wellbeing.txt @@ -0,0 +1,56 @@ +shall the mind and body now: Project its awareness, attention, belief, and +intention into all times dimensions of undivided universal field of +consciousness and identity, accept and release attunement to all events, +information faults, and information faults hidden that compromises +awareness of, or define into existence, the transformed-from state? Or, +that cause this transformative information quanta to define into existence +the transformed-to system state? Or that cause this transformation to +seem dangerous, undeserved, or impossible to achieve? Create awareness, +acceptance, attunement, and belief of all corrective events and +transformative information quanta to define into existence the +transformed-to system state? + +Create the intention to collapse the quantum potential the field’s reality +quantum potential of the field’s reality quant to manifest this +transformation? Create optimal attunement and coherence to the source of +creation, GOD, innate intelligence, and the consciousness of healing and +accept the role of co-creator of all experienced reality, NOW? + +I am grateful GOD lives through me and inspires me to achieve and +maintain optimum health & wellbeing. + +I am thankful for my health, vitality, and motivation to eat properly, +exercise, and maintain a strong and healthy body. + +I appreciate GOD providing strength and direction to every cell in my +body ensuring optimum health and wellbeing. + +I am pleased for having exceptional mental, physical, and emotional +health and stability allowing me to function at high levels of +efficiency and according to GOD’s design. + +I enjoy knowing GOD protects me and keeps me safe from injury and +illness. + +I am happy every cell in my body remains strong and my immune system +grows stronger each and every day. + +I am grateful GOD’s healing hands are on me creating miracles in all +areas of my life. + +I am thankful that I wake up each morning yearning to eat health foods +and exercise so that I maintain optimum health, wellbeing, and +longevity. +. +I appreciate GOD’s almighty flowing though me, creating miracles in all +areas of my life, and correcting, curing, and developing all healthy +aspects of my mind and my body. + +I am pleased my muscles are strong, my body is healthy, I have great +balance, mental clarity, exceptional stamina and I continue growing +perpetually stronger and healthier each day. + +I am grateful to GOD for all the blessings bestowed upon me. + +I am thankful I only crave healthy foods that provide my body with the +nutrition necessary for my optimum health and wellbeing. \ No newline at end of file diff --git a/share/rhemawave/proclamations/home/Improve Marital Relationships.txt b/share/rhemawave/proclamations/home/Improve Marital Relationships.txt new file mode 100644 index 0000000..a242d49 --- /dev/null +++ b/share/rhemawave/proclamations/home/Improve Marital Relationships.txt @@ -0,0 +1,58 @@ +shall the mind and body now: Project its awareness, attention, belief, and +intention into all times dimensions of undivided universal field of +consciousness and identity, accept and release attunement to all events, +information faults, and information faults hidden that compromises +awareness of, or define into existence, the transformed-from state? Or, +that cause this transformative information quanta to define into existence +the transformed-to system state? Or that cause this transformation to +seem dangerous, undeserved, or impossible to achieve? Create awareness, +acceptance, attunement, and belief of all corrective events and +transformative information quanta to define into existence the +transformed-to system state? + +Create the intention to collapse the quantum potential the field’s reality +quantum potential of the field’s reality quant to manifest this +transformation? Create optimal attunement and coherence to the source of +creation, GOD, innate intelligence, and the consciousness of healing and +accept the role of co-creator of all experienced reality, NOW? + +I am grateful GOD lives through me and inspires me to be a better, more +compassionate, and understanding partner and spouse each and every day. + +I am thankful for my health, vitality, and motivation to be a more +loving, compassionate, understanding, and supportive partner to my spouse +with each passing day. + +I appreciate GOD providing strength and direction to every cell in my +body ensuring I continue to grow and develop into a more loyal, +supportive, loving, compassionate, and understanding partner to my +spouse. + +I am pleased that I listen attentively to my spouse, ask them pertinent +questions, and allow my spouse to express their feelings, opinion, and +emotions without interruption or judgement. + +I enjoy knowing GOD protects me and enables me to be the best and most +loving and supportive spouse I can be. + +I am happy that I enjoy a wonderful, fun-filled, loving, and passionate +relationship with my spouse. + +I am grateful GOD’s healing hands are on me and create miracles in all +areas of my life. + +I am thankful I wake up each morning well rested, excited, and yearning +to spend quality time with my spouse. + +I appreciate GOD’s almighty power flowing though me, creating miracles +in all areas of my life, and enabling me to fulfill my spouse’s desires +and expectations. + +I am pleased spending quality time with my spouse, sharing special +moments, and living a relaxed and perpetually blissful life together. + +I am grateful to GOD for all the blessings bestowed upon me. + +I am thankful that I only crave healthy foods that provide my mind and +body with the nutrition necessary for me to enjoy optimum health and +fulfill all my marital duties & responsibilities. \ No newline at end of file diff --git a/share/rhemawave/proclamations/home/Maximize My Productivity.txt b/share/rhemawave/proclamations/home/Maximize My Productivity.txt new file mode 100644 index 0000000..0497a27 --- /dev/null +++ b/share/rhemawave/proclamations/home/Maximize My Productivity.txt @@ -0,0 +1,59 @@ +shall the mind and body now: Project its awareness, attention, belief, and +intention into all times dimensions of undivided universal field of +consciousness and identity, accept and release attunement to all events, +information faults, and information faults hidden that compromises +awareness of, or define into existence, the transformed-from state? Or, +that cause this transformative information quanta to define into existence +the transformed-to system state? Or that cause this transformation to +seem dangerous, undeserved, or impossible to achieve? Create awareness, +acceptance, attunement, and belief of all corrective events and +transformative information quanta to define into existence the +transformed-to system state? + +Create the intention to collapse the quantum potential the field’s reality +quantum potential of the field’s reality quant to manifest this +transformation? Create optimal attunement and coherence to the source of +creation, GOD, innate intelligence, and the consciousness of healing and +accept the role of co-creator of all experienced reality, NOW? + +I am grateful GOD lives through me and inspires me to prioritize and +accomplish my most important tasks throughout each day. + +I am thankful for my health, vitality, and motivation to organize and +execute as many tasks as possible each and every day. + +I appreciate GOD providing strength and direction to every cell in my +body ensuring I have the strength, focus, and determination to +accomplish my tasks while not wasting my time and energy on +unproductive things like snacking, watching TV, talking without purpose +in person or on the phone, or sleeping too much. + +I am pleased for the opportunity to focus on prioritizing and +efficiently accomplishing tasks in order to complete my projects +efficiently and effectively and live my life according to GOD’s design. + +I enjoy knowing GOD protects me and provides me with the time, talent, +insight, and focus to accomplish my tasks quickly, accurately, and +completely. + +I am happy I am productive each day and my accomplishments are +efficient, effective, and profitable. + +I am grateful GOD’s healing hands are on me and create miracles in all +areas of my life. + +I am thankful I wake up each morning yearning to eat healthy foods and +exercise in ways that enhance my ability to complete my tasks and +fulfill my responsibilities. + +I appreciate GOD’s almighty power flowing though me, creating miracles +in all areas of my life, and giving me miraculous insight, as well as +the motivation to be productive every minute of every day. + +I am pleased my schedule allows me time to focus on accomplishing my +tasks. + +I am grateful to GOD for all the blessings bestowed upon me. + +I am thankful I am creative, imaginative, constructive, and find great +satisfaction getting things accomplished. \ No newline at end of file diff --git a/share/rhemawave/proclamations/home/Overcome Fear, Anxiety and Panic Attacks.txt b/share/rhemawave/proclamations/home/Overcome Fear, Anxiety and Panic Attacks.txt new file mode 100644 index 0000000..5b5661c --- /dev/null +++ b/share/rhemawave/proclamations/home/Overcome Fear, Anxiety and Panic Attacks.txt @@ -0,0 +1,60 @@ +shall the mind and body now: Project its awareness, attention, belief, and +intention into all times dimensions of undivided universal field of +consciousness and identity, accept and release attunement to all events, +information faults, and information faults hidden that compromises +awareness of, or define into existence, the transformed-from state? Or, +that cause this transformative information quanta to define into existence +the transformed-to system state? Or that cause this transformation to +seem dangerous, undeserved, or impossible to achieve? Create awareness, +acceptance, attunement, and belief of all corrective events and +transformative information quanta to define into existence the +transformed-to system state? + +Create the intention to collapse the quantum potential the field’s reality +quantum potential of the field’s reality quant to manifest this +transformation? Create optimal attunement and coherence to the source of +creation, GOD, innate intelligence, and the consciousness of healing and +accept the role of co-creator of all experienced reality, NOW? + +I am grateful GOD lives through me and inspires me to find solace in all +aspects in my life. + +I am thankful for my mental wellbeing which allows me to focus on all the +positive aspects of my life, rather than dwelling on depressing, +stressful, or emotionally draining issues that detract from my emotional +stability. + +I appreciate GOD providing strength and direction to every cell in my +body, ensuring I remain emotionally stable and maintain a positive +outlook on my life regardless of my situation. + +I am pleased I always manage my thoughts, think positive, avoid negative +or depressing thoughts, and live each day with a upbeat, positive, and +emotionally stable state of mind according to GOD’s design. + +I enjoy knowing GOD protects me and gives me the mental fortitude to +control my thoughts and emotions while remaining positive and +emotionally stable knowing everything in my life will turn out well. + +I am happy I control my own thoughts at all times and no longer dwell on +negative thoughts or issues. + +I am grateful GOD’s healing hands are on me and create miracles in all +areas of my life. + +I am thankful I wake up each morning with a positive outlook on life that +lasts throughout my entire day and night ensuring I live a peaceful and +emotionally stable life. + +I appreciate GOD’s almighty power flowing though me, creating miracles +in all areas of my life, and correcting, curing, developing, and +improving my mind, my body, and my emotional stability. + +I am pleased my mental health and emotional stability allow me to live a +positive, relaxed, and perpetually blissful lifestyle. + +I am grateful to GOD for all the blessings bestowed upon me. + +I am thankful that I only focus on positive thoughts and crave healthy +foods that provide my mind and body with the nutrition necessary for my +optimum health, emotional wellbeing, and longevity. \ No newline at end of file diff --git a/share/rhemawave/proclamations/home/Overcoming ADHD.txt b/share/rhemawave/proclamations/home/Overcoming ADHD.txt new file mode 100644 index 0000000..74d11af --- /dev/null +++ b/share/rhemawave/proclamations/home/Overcoming ADHD.txt @@ -0,0 +1,58 @@ +shall the mind and body now: Project its awareness, attention, belief, and +intention into all times dimensions of undivided universal field of +consciousness and identity, accept and release attunement to all events, +information faults, and information faults hidden that compromises +awareness of, or define into existence, the transformed-from state? Or, +that cause this transformative information quanta to define into existence +the transformed-to system state? Or that cause this transformation to +seem dangerous, undeserved, or impossible to achieve? Create awareness, +acceptance, attunement, and belief of all corrective events and +transformative information quanta to define into existence the +transformed-to system state? + +Create the intention to collapse the quantum potential the field’s reality +quantum potential of the field’s reality quant to manifest this +transformation? Create optimal attunement and coherence to the source of +creation, GOD, innate intelligence, and the consciousness of healing and +accept the role of co-creator of all experienced reality, NOW? + +I am grateful GOD lives through me and inspires my mind and body to heal +miraculously so I no longer suffer from Attention Deficient or Hyper +Activity disorder. + +I am thankful for my health, vitality, and ability to control my +hyperactivity, remain calm, pay attention to details, and focus on tasks +through to completion. + +I appreciate GOD providing strength and direction to every cell in my +body ensuring efficient, effective, and proper healing of my Attention +Deficient Hyper Activity disorder throughout the entire curative +process. + +I am pleased my confidence grows with each passing day, I function +normally, I no longer suffer from low self-esteem, and I no longer have +difficulty maintaining meaningful relationships. + +I enjoy knowing GOD protects me throughout and beyond the healing and +developmental process as I no longer suffer from Attention Deficient +Hyper Activity disorder. + +I am happy my ability to focus grows stronger each and every day. + +I am grateful GOD’s healing hands are on me creating miracles in all +areas of my life. + +I am thankful I remain calm and in control of my hyperactivity. + +I appreciate GOD’s almighty power flowing though me, creating miracles +in all areas of my life, and correcting, curing, and developing all +healthy aspects of my mind and my body. + +I am pleased I am fully capable of being attentive and consistently +focusing on any and all projects and situations I encounter. + +I am grateful to GOD for all the blessings bestowed upon me. + +I am thankful I do not suffer from Attention Deficient Hyper Activity +disorder and only crave healthy foods that provide my body with the +nutrition necessary to optimize my health and wellbeing. \ No newline at end of file diff --git a/share/rhemawave/proclamations/home/Relaxation.txt b/share/rhemawave/proclamations/home/Relaxation.txt new file mode 100644 index 0000000..9c8f19c --- /dev/null +++ b/share/rhemawave/proclamations/home/Relaxation.txt @@ -0,0 +1,58 @@ +shall the mind and body now: Project its awareness, attention, belief, and +intention into all times dimensions of undivided universal field of +consciousness and identity, accept and release attunement to all events, +information faults, and information faults hidden that compromises +awareness of, or define into existence, the transformed-from state? Or, +that cause this transformative information quanta to define into existence +the transformed-to system state? Or that cause this transformation to +seem dangerous, undeserved, or impossible to achieve? Create awareness, +acceptance, attunement, and belief of all corrective events and +transformative information quanta to define into existence the +transformed-to system state? + +Create the intention to collapse the quantum potential the field’s reality +quantum potential of the field’s reality quant to manifest this +transformation? Create optimal attunement and coherence to the source of +creation, GOD, innate intelligence, and the consciousness of healing and +accept the role of co-creator of all experienced reality, NOW? + +I am grateful GOD lives through me and inspires me to achieve deep +relaxation, peace, and harmony in all aspects of my life. + +I am thankful for my health, vitality, and motivation to eat properly, +exercise, and always maintain control of my thoughts, emotions, and +mental state. + +I appreciate GOD providing strength and direction to every cell in my +body ensuring I am emotionally stable and maintain a relaxed and focused +attitude regardless of my personal situation. + +I am pleased I always think positive, manage my thoughts, and live each +day in a relaxed and emotionally stable state of mind according to GOD’s +design. + +I enjoy knowing GOD protects me and allows me to remain relaxed knowing +everything in my life will turn out well. + +I am happy I think positively, I do not dwell on negative issues, and I +control my thoughts at all times. + +I am grateful GOD’s healing hands are on me creating miracles in all +areas of my life. + +I am thankful I wake up each morning yearning to eat healthy foods and +exercise in ways that ensure I live a peaceful and emotionally stable +life. + +I appreciate GOD’s almighty power flowing though me, creating miracles +in all areas of my life, and correcting, curing, and developing all +healthy aspects of my mind and my body for the better. + +I am pleased my mental health and emotional stability allow me to live a +relaxed and perpetually blissful life. + +I am grateful to GOD for all the blessings bestowed upon me. + +I am thankful that I only crave healthy foods that provide my mind and +body with the nutrition necessary for my optimum health, wellbeing, and +longevity. \ No newline at end of file diff --git a/share/rhemawave/proclamations/home/Release Stress, Worry, Uncertainty & Nervousness.txt b/share/rhemawave/proclamations/home/Release Stress, Worry, Uncertainty & Nervousness.txt new file mode 100644 index 0000000..a8aac69 --- /dev/null +++ b/share/rhemawave/proclamations/home/Release Stress, Worry, Uncertainty & Nervousness.txt @@ -0,0 +1,59 @@ +shall the mind and body now: Project its awareness, attention, belief, and +intention into all times dimensions of undivided universal field of +consciousness and identity, accept and release attunement to all events, +information faults, and information faults hidden that compromises +awareness of, or define into existence, the transformed-from state? Or, +that cause this transformative information quanta to define into existence +the transformed-to system state? Or that cause this transformation to +seem dangerous, undeserved, or impossible to achieve? Create awareness, +acceptance, attunement, and belief of all corrective events and +transformative information quanta to define into existence the +transformed-to system state? + +Create the intention to collapse the quantum potential the field’s reality +quantum potential of the field’s reality quant to manifest this +transformation? Create optimal attunement and coherence to the source of +creation, GOD, innate intelligence, and the consciousness of healing and +accept the role of co-creator of all experienced reality, NOW? + +I am grateful GOD lives through me causing me to release stress, release +anxiety, and live a calm and peaceful life. + +I am thankful for my health, vitality, and the motivation to breathe +deeply, eat slowly, consume nutritious foods, and exercise as a means of +releasing my stress, worries, anxiety, and frustration. + +I appreciate GOD providing strength and direction to every cell in my +body ensuring I live free from stress, worry, uncertainty, and +nervousness. + +I am pleased I live a stress free, happy, and fun filled life with +exceptional mental, physical, and emotional health and stability. + +I enjoy knowing I can rely upon my relationship with GOD knowing GOD +protects me and keeps me safe so I have no reason to stress, no reason +to worry, no reason for uncertainty, and no reason to be nervous. + +I am happy every cell in my body remains strong and the confidence in my +ability to control my life and my future grows stronger each and every +day. + +I am grateful GOD’s healing hands are on me creating miracles in all +areas of my life. + +I am thankful that I wake up each morning yearning to confidently take on +whatever tasks come my way without stress, worry, uncertainly, or +nervousness. +. +I appreciate GOD’s almighty power flowing though me, creating miracles +in all areas of my life, and correcting, curing, and developing all +healthy aspects of my mind and my body. + +I am pleased with my mental clarity, my ability to remain calm and in +control off my activities, and focus on tasks without distraction as I +continue growing perpetually stronger and healthier each day. + +I am grateful to GOD for all the blessings bestowed upon me. + +I am thankful that I control my own destiny without fear, without +stress, without worry, without uncertainty, and without nervousness. \ No newline at end of file diff --git a/share/rhemawave/proclamations/home/Stimulate Healing.txt b/share/rhemawave/proclamations/home/Stimulate Healing.txt new file mode 100644 index 0000000..fcd8dbd --- /dev/null +++ b/share/rhemawave/proclamations/home/Stimulate Healing.txt @@ -0,0 +1,52 @@ +shall the mind and body now: Project its awareness, attention, belief, and +intention into all times dimensions of undivided universal field of +consciousness and identity, accept and release attunement to all events, +information faults, and information faults hidden that compromises +awareness of, or define into existence, the transformed-from state? Or, +that cause this transformative information quanta to define into existence +the transformed-to system state? Or that cause this transformation to +seem dangerous, undeserved, or impossible to achieve? Create awareness, +acceptance, attunement, and belief of all corrective events and +transformative information quanta to define into existence the +transformed-to system state? + +Create the intention to collapse the quantum potential the field’s reality +quantum potential of the field’s reality quant to manifest this +transformation? Create optimal attunement and coherence to the source of +creation, GOD, innate intelligence, and the consciousness of healing and +accept the role of co-creator of all experienced reality, NOW? + +I am grateful GOD lives through me and inspires my body to heal +miraculously, quickly achieving optimum health. + +I am thankful for my health, vitality, and ability to heal quickly. + +I appreciate GOD providing strength and direction to every cell in my +body ensuring efficient, effective, and proper healing throughout the +curative process. + +I am pleased my muscles, bones, joints, organs, nerves, tendons, and +ligaments all heal correctly and function normally according to GOD’s +design. + +I enjoy knowing GOD protects me throughout and beyond the physical +healing and development process. + +I am happy my muscles and bones grow stronger each and every day. + +I am grateful GOD’s healing hands are on me creating miracles in all +areas of my life. + +I am thankful my pain remains tolerable throughout the healing process. + +I appreciate GOD’s almighty power flowing though me, creating miracles +in all areas of my life, and correcting, curing, and developing all +healthy aspects of my mind and my body. + +I am pleased my injuries heal rapidly and I emerge stronger and healthier +than before my injury. + +I am grateful to GOD for all the blessings bestowed upon me. + +I am thankful I only crave healthy foods that provide my body with the +nutrition necessary to heal swiftly and optimize my health and wellbeing. \ No newline at end of file diff --git a/share/rhemawave/proclamations/home/Weight Loss.txt b/share/rhemawave/proclamations/home/Weight Loss.txt new file mode 100644 index 0000000..f2430ee --- /dev/null +++ b/share/rhemawave/proclamations/home/Weight Loss.txt @@ -0,0 +1,56 @@ +shall the mind and body now: Project its awareness, attention, belief, and +intention into all times dimensions of undivided universal field of +consciousness and identity, accept and release attunement to all events, +information faults, and information faults hidden that compromises +awareness of, or define into existence, the transformed-from state? Or, +that cause this transformative information quanta to define into existence +the transformed-to system state? Or that cause this transformation to +seem dangerous, undeserved, or impossible to achieve? Create awareness, +acceptance, attunement, and belief of all corrective events and +transformative information quanta to define into existence the +transformed-to system state? + +Create the intention to collapse the quantum potential the field’s reality +quantum potential of the field’s reality quant to manifest this +transformation? Create optimal attunement and coherence to the source of +creation, GOD, innate intelligence, and the consciousness of healing and +accept the role of co-creator of all experienced reality, NOW? + +I am grateful GOD lives through me and inspires me to eat right, +exercise, and reach my ideal weight quickly and effectively. + +I am thankful for my health, vitality, and motivation to eat properly, +exercise, and strengthen my body while losing unhealthy and unwanted fat. + +I am appreciate GOD providing strength and direction to every cell in my +body ensuring I control my food intake, exercise, and reach my weight +loss goal. + +I am pleased for having the time to buy and prepare healthy foods, +exercise, and focus on my overall health. + +I enjoy knowing GOD protects me and inspires me to become healthy and fit +and live my life according to GOD’s design. + +I am happy I have the desire and power to avoid eating sugary foods and +unhealthy snacks in order control my caloric intake and lose excess +weight. + +I am grateful GOD’s healing hands are on me and create miracles in all +areas of my life. + +I am thankful I wake up each morning yearning to eat healthy foods and +exercise in ways that ensure I reach and maintain my ideal body weight. + +I appreciate GOD’s almighty power flowing though me and empowering me to +do whatever it takes to reach my ultimate weight and fitness level. + +I am pleased my continued efforts to reach and maintain my ultimate +weight and fitness are rewarded with increased energy, great stamina, and +good mental and physical health. + +I am grateful to GOD for all the blessings bestowed upon me. + +I am thankful that I only crave healthy foods that provide my mind and +body with the nutrition necessary for my optimum health, wellbeing, and +longevity. \ No newline at end of file diff --git a/share/rhemawave/shaders/scroller.frag b/share/rhemawave/shaders/scroller.frag new file mode 100644 index 0000000..e481631 --- /dev/null +++ b/share/rhemawave/shaders/scroller.frag @@ -0,0 +1,13 @@ +#version 330 core + +in vec2 pass_TexCoord; +out vec4 out_Color; +uniform sampler2D u_fontTexture; +uniform vec4 u_textColor; + +void main() +{ + vec4 texel = texture(u_fontTexture, pass_TexCoord); + float mask = texel.a; + out_Color = vec4(u_textColor.rgb, u_textColor.a * mask); +} diff --git a/share/rhemawave/shaders/scroller.vert b/share/rhemawave/shaders/scroller.vert new file mode 100644 index 0000000..b5c9d31 --- /dev/null +++ b/share/rhemawave/shaders/scroller.vert @@ -0,0 +1,12 @@ +#version 330 core + +layout (location = 0) in vec2 in_Position; +layout (location = 1) in vec2 in_TexCoord; +out vec2 pass_TexCoord; +uniform mat4 u_mvpMatrix; + +void main() +{ + gl_Position = u_mvpMatrix * vec4(in_Position.x, in_Position.y, 0.0, 1.0); + pass_TexCoord = in_TexCoord; +} diff --git a/share/rhemawave/shaders/solid_color.frag b/share/rhemawave/shaders/solid_color.frag new file mode 100644 index 0000000..70f2cd9 --- /dev/null +++ b/share/rhemawave/shaders/solid_color.frag @@ -0,0 +1,9 @@ +#version 330 core + +out vec4 FragColor; + +uniform vec4 u_color; + +void main() { + FragColor = u_color; +} diff --git a/share/rhemawave/shaders/solid_color.vert b/share/rhemawave/shaders/solid_color.vert new file mode 100644 index 0000000..47fbf95 --- /dev/null +++ b/share/rhemawave/shaders/solid_color.vert @@ -0,0 +1,9 @@ +#version 330 core + +layout (location = 0) in vec2 aPos; + +uniform mat4 u_mvpMatrix; + +void main() { + gl_Position = u_mvpMatrix * vec4(aPos.xy, 0.0, 1.0); +} diff --git a/share/rhemawave/shaders/text.frag b/share/rhemawave/shaders/text.frag new file mode 100644 index 0000000..a713ad9 --- /dev/null +++ b/share/rhemawave/shaders/text.frag @@ -0,0 +1,17 @@ +#version 330 core + +// The final color output for the pixel +out vec4 FragColor; + +// Input from the vertex shader +in vec2 TexCoord; // The texture coordinate, interpolated for this specific pixel + +// The source texture (our FontMap "sticker sheet") +uniform sampler2D u_texture; +uniform vec4 u_textColor; + +void main() +{ + float mask = texture(u_texture, TexCoord).a; + FragColor = vec4(u_textColor.rgb, u_textColor.a * mask); +} diff --git a/share/rhemawave/shaders/text.vert b/share/rhemawave/shaders/text.vert new file mode 100644 index 0000000..8aee082 --- /dev/null +++ b/share/rhemawave/shaders/text.vert @@ -0,0 +1,21 @@ +#version 330 core + +// Input vertex data from the VBO +layout (location = 0) in vec2 aPos; // The (x, y) position of the vertex +layout (location = 1) in vec2 aTexCoord; // The (u, v) texture coordinate for this vertex + +// Output to the fragment shader +out vec2 TexCoord; + +// A matrix to handle projection (not strictly needed for this specific render-to-texture, +// but good practice to include for general purpose use) +uniform mat4 u_mvpMatrix; + +void main() +{ + // Set the final position of the vertex + gl_Position = u_mvpMatrix * vec4(aPos.x, aPos.y, 0.0, 1.0); + + // Pass the texture coordinate straight through to the fragment shader + TexCoord = aTexCoord; +} diff --git a/share/rhemawave/tos/01 - WELCOME.html b/share/rhemawave/tos/01 - WELCOME.html new file mode 100644 index 0000000..b6aa4e3 --- /dev/null +++ b/share/rhemawave/tos/01 - WELCOME.html @@ -0,0 +1,15 @@ +

    Welcome to RHEMA WAVE TECHNOLOGY!

    + +

    Please review the following screens carefully and completely as they provide important user information, as well as outline YOUR legal responsibilities!

    + +

    First and foremost, congratulations! Congratulations to YOU for having the foresight to invest in what we believe is one of the greatest breakthroughs in the history of humanity! More importantly, we congratulate YOU for investing in YOU!

    + +

    We would also like to express our appreciation for YOUR faith, patience, and understanding as we continue evolving our ingenious business model, our revolutionary patented products, and our unprecedented copy-written technology! While we have, quoting the immortal words of Captain Kirk in the original Star Trek series, "Gone where no man has gone before!" we have already complied quite a long list of futuristic products, services, refinements, and innovations we expect to introduce as soon as humanly possible.

    + +

    While RHEMA WAVE TECHNOLOGY is already on the cutting edge of technological advancement, we believe this is just the beginning as we intend to push the cutting edge of technology for decades into the future with yet unimaginable creations. Our focus on the continuing evolution of our science will ensure competitors will fall by the wayside as RHEMA WAVE TECHNOLOGY continues to stand alone as the undisputed "Pioneer of Innovation!"

    + +

    Welcoming you into our RHEMA WAVE TECHNOLOGY family is far more than simply a polite slogan. We consider our members kin to the RHEMA WAVE TECHNOLOGY lineage and thus part of a very unique and special family. As part of our family we anticipate YOU will remain in communication with us and share YOUR personal progress and experiences. We also encourage you to ask questions, express concerns, and share your ideas as everyone's continued involvement is key to continued advancement.

    + +

    In closing, and keeping with the original Star Trek theme, we feel it is amazingly appropriate to salute you in the same manner Spock, the half-human, half-Vulcan, pointy eared, logic-driven first officer aboard the StarShip Enterprise would,

    + +

    "Live long & Prosper!"

    diff --git a/share/rhemawave/tos/02 - NOTICE.html b/share/rhemawave/tos/02 - NOTICE.html new file mode 100644 index 0000000..b6e8483 --- /dev/null +++ b/share/rhemawave/tos/02 - NOTICE.html @@ -0,0 +1,15 @@ +

    RHEMA WAVE TECHNOLOGY, EQUIPMENT, AND SOFTWARE IS NOT INTENDED, MARKETED, OR SOLD AS A MEDICAL DEVICE.

    + +

    RHEMA WAVE TECHNOLOGY, EQUIPMENT, AND SOFTWARE IS NOT INTENDED TO DIAGNOSE, TREAT, OR CURE ANY ILLNESS, AILMENT, OR DISEASE.

    + +

    RHEMA WAVE TECHNOLOGY, EQUIPMENT, AND SOFTWARE MERELY CREATES WHAT WE BELIEVE TO BE A SUBTLE ENERGY FIELD THAT LIVING CELLS SEEM TO ABSORB. THIS ABSORBED ENERGY APPEARS TO ALLOW CELLS TO FUNCTION MORE EFFICIENTLY & POTENTIALLY MORE EFFECTIVELY THAN THEY NORMALLY WOULD UNDER MODERN DAY STRESS AND THE ENVIRONMENT IN WHICH WE CURRENTLY LIVE.

    + +

    RHEMA WAVE TECHNOLOGY MAKES NO CLAIMS AS TO THE EFFECTS, EFFECTIVENESS, OR RESULTS FROM USING RHEMA WAVE TECHNOLOGY PRODUCTS AND HEREBY DISCLAIMS ANY REPRESENTATION OR WARRANTY TO THAT EFFECT.

    + +

    USER/BUYER UNDERSTANDS AND AGREES NO MEDICAL OR HEALING CLAIMS ARE TO BE MADE REGARDING RHEMA WAVE TECHNOLOGY AND RHEMA WAVE SYSTEMS, TO INCLUDE SOFTWARE, HARDWARE, AND PROGRAMMING.

    + +

    USER/BUYER UNDERSTANDS AND AGREES IT IS USER/BUYER'S SOLE RESPONSIBILITY TO INFORM ANY AND ALL USERS THEY INVITE OR ALLOW TO EXPERIENCE THEIR RHEMA WAVE SYSTEM OF THESE TERMS AND CONDITIONS.

    + +

    USER/BUYER UNDERSTANDS AND AGREES USER/BUYER SHALL BE SOLELY RESPONSIBLE FOR COMPENSATION TO RHEMA WAVE TECHNOLOGY FOR ANY AND ALL CLAIMS, FINES, DAMAGES, AND LEGAL FEES RESULTING FROM USER/BUYER MAKING SUCH UNAUTHORIZED COMMENTS, INCLUDING THOSE LEVIED AGAINST RHEMA WAVE TECHNOLOGIES BY PERSONS, CORPORATIONS, AND FEDERAL AGENCIES.

    + +

    IT IS ALSO UNDERSTOOD EQUIPMENT PROVIDERS SHALL BE HELD HARMLESS AND NOT BE RESPONSIBLE FOR ANY AND ALL SUCH CLAIMS.

    diff --git a/share/rhemawave/tos/03 - Getting Started.html b/share/rhemawave/tos/03 - Getting Started.html new file mode 100644 index 0000000..2b7ece8 --- /dev/null +++ b/share/rhemawave/tos/03 - Getting Started.html @@ -0,0 +1,15 @@ +

    INSTRUCTIONS FOR USE

    + +

    1. Ensure you have adequate internet access.
    +2. Enter a valid email address for your account.
    +3. Enter a license key for your account. In the near future each account will be assigned a License Key but, at this point in time, enter your first and last name followed 1 2 3 4 etc. with no spaces until you achieve a total of 16 characters. Your License Key identifies your RHEMA SCALAR WAVE GENERATOR and its enabled features, as well as grants access to your account for activation, operation, features, and updates.
    +4. Begin by using the F3 key to access your systems features and you will see:

    + +

    PROCLAMATIONS
    +SCHEDULER
    +WiFi SETUP
    +AUDIO OPTIONS
    +EMAIL ADDRESS
    +LICENSE KEY

    + +

    Using the keyboard arrow keys you can scroll through the options and chose the one you would like to access by using the return key. The PROCLAMATIONS key will take you to a host of proclamations and options. The SCHEDULER key grants access a scheduling system allowing your to create varies different proclamation sessions, which I will explain shortly. The WiFi SETUP allows you to change WiFi networks. The AUDIO OPTIONS allows you to switch audio on or off, change audio devices, and switch between audio genres. EMAIL ADDRESS allows you to change your Email Address. License Key allows you to access and change your License Key provided RHEMA WAVE TECHNOLOGIES is notified in advance of the change.

    diff --git a/share/rhemawave/tos/04 - Proclamation Subscriptions.html b/share/rhemawave/tos/04 - Proclamation Subscriptions.html new file mode 100644 index 0000000..958d096 --- /dev/null +++ b/share/rhemawave/tos/04 - Proclamation Subscriptions.html @@ -0,0 +1,13 @@ +

    PROCLAMATIONS

    + +

    Use keyboard arrow keys and return key to select Proclamations. There you will find several options for activating monthly access to proclamations and RHEMA WAVE SAAS (software as a service).

    + +

    Option A: includes monthly access to SAAS, 10 proclamations of your choice, plus $1 for each additional activated proclamation.

    + +

    Option B: includes monthly access to SAAS and 25 proclamations of your choice, plus 75 cents for each additional activated proclamation.

    + +

    Option C: includes monthly access to SAAS and 50 proclamations of your choice, plus 50 cents for each additional activated proclamation.

    + +

    Option D: includes monthly access to SAAS and access to all available proclamations.

    + +

    Begin by using arrow keys and return key to select an proclamation category, then use the up and down arrow keys to scroll through all the proclamations in each category so that you are familiar with the complete library. You may want to consider making a list of the proclamations you would like to start with as this will simplify the process of selecting, activating, and scheduling your chosen proclamations.

    diff --git a/share/rhemawave/tos/05 - Scheduling Sessions.html b/share/rhemawave/tos/05 - Scheduling Sessions.html new file mode 100644 index 0000000..2ece180 --- /dev/null +++ b/share/rhemawave/tos/05 - Scheduling Sessions.html @@ -0,0 +1,5 @@ +

    Ideally we suggest using the SCHEDULER to create at least 4 separate lists of proclamations, one to start your morning, perhaps starting 30 minutes before your scheduled waking up time, one for an afternoon sessions, one for an evening "wind down" session, and a nighttime sleeping session. The SCHEDULER allows you to determine when one series of proclamations ends and the next series begins. Depending upon your particular schedule you may want to add more sessions. Upon completion of your review select desired proclamations by simply pressing the space bar. Activated proclamations appear GREEN, while inactive proclamations remain WHITE.

    + +

    We highly suggest (and would require if we could) activating Shangri-La in ALL sessions ALL the time so it runs constantly from now to eternity (or at least until we have the time to create a few alternatives)! Shangri-La is a relaxing, full body cellular supercharger designed to boost energy throughout the entire body. In addition to Shangri-La, we highly suggest activating 3 to 5 priority proclamations that also run in all sessions (continuously 24 hours a day) until you are satisfied with your results. Once you are satisfied with your results you can simply return to the SCHEDULER and select a different proclamation to take its place. A priority proclamation is an proclamation focused on a particular area or issue and easily recognized by an accompanying asterisk (*).

    + +

    General proclamations are those focused on desired behavioral changes and NOT marked with an asterisk (*). We suggest activating 10 to 20 different general proclamations for each scheduled session. Should you have sincere interest in certain general proclamations such as Health & Well-Being, Weight-Loss, or Reduce Stress, Anxiety, and Panic Attacks they can be included in more than one session, depending upon the severity and your desire to seek improvement. While initially this may seem like quite a few proclamations, other than Shangri-La, which runs a bit longer, most other proclamations are communicated in under 30 seconds so programming 20 proclamations, each would repeat 6 times an hour.

    diff --git a/share/rhemawave/tos/06 - Proclamation Recommendations.html b/share/rhemawave/tos/06 - Proclamation Recommendations.html new file mode 100644 index 0000000..597b7a1 --- /dev/null +++ b/share/rhemawave/tos/06 - Proclamation Recommendations.html @@ -0,0 +1,9 @@ +

    Now for the fun part! To ensure complete understanding I will explain a few more details about proclamations and make a few more recommendations.

    + +

    While proclamations like Deep Sleep, Relaxation, and Bathe in Blessings connote peace, rest, and relaxation, proclamations like Goal Setting & Achievement, Achieving Success, Mastering Money Management, and Maximize My Productivity exude connotations of action and mental activity. Accordingly, we recommend scheduling relaxing proclamations like Relaxation, Bathe in Blessings, and Deep Sleep for evening wind down sessions and especially nighttime sleep sessions, with more aggressive proclamations ideally activated first thing in the morning and though out the day.

    + +

    We highly suggest including proclamations like Deep Sleep, Vivid Dreams, and Heavenly Communication in your nighttime sleep session from the very beginning. Activating Deep Sleep in particular in nighttime sleep sessions is the simplest, fastest, and most efficient way to experience the effectiveness of RHEMA WAVES. Those who follow this recommendation report waking up amazed at how well-rested they feel and deep they slept. Just one undeniable personal experience such as this will do more to convince you just how amazing this technology truly is, as well as deepen your appreciation for the investment you are making in you than words ever could.

    + +

    Now, those of you lucky enough to work from home will certainly have an advantage spending more time in RHEMA WAVES and all your selected sessions. Even though your system may be set up in your bedroom and you work in your office or dining room, the RHEMA WAVES will still have an impact outside the main location, it just won't be as effective.

    + +

    Those of you not lucky enough to work from home should still use the SCHEDULER to create sessions. Having a morning session running while preparing for work as well as an evening session will be beneficial, as well as enjoying full sessions on weekends and whenever you spend more time at home. If you work outside the home and wish to make the most of your time in RHEMA WAVES, you can add more aggressive proclamations to your sleep sessions, but be sure to include Deep Sleep and a couple other relaxing proclamations along with them. You can also alter your general nighttime sleep session proclamations every couple of weeks, or as soon as you are satisfied with the session's effects.

    diff --git a/share/rhemawave/tos/07 - How Proclamations Work.html b/share/rhemawave/tos/07 - How Proclamations Work.html new file mode 100644 index 0000000..3a65984 --- /dev/null +++ b/share/rhemawave/tos/07 - How Proclamations Work.html @@ -0,0 +1,5 @@ +

    Obviously the variety of proclamations accessible to you will be determined by your choice of proclamation subscription. Please know that, while each specific proclamation takes anywhere from several hours to several days to create, we remain diligent and continue conducting research and developing additional proclamations, so you can anticipate continued expansion of our proclamation catalog.

    + +

    Each specific proclamation, as referenced by their titles, is meticulously designed and painstakingly created incorporating detailed information and very specific facts thoughtfully programmed to travel along our patented RHEMA WAVE ENERGY FIELD. The average human body is made up of approximately 37 trillion cells (plus or minus depending on your size and weight). Each of these cells appear capable of absorbing energy from RHEMA WAVE ENERGY FIELD and function more efficiently and effectively as a result. Results suggest we are capable of focusing a portion of the absorbed RHEMA WAVE energy on the specific area, habit, trait, or issue described in each proclamation's title.

    + +

    Either that, or we have simply created the most consistently effective placebo generator in the history of placebo generators! All I know is, if I, or someone I care about, was suffering from a dreadful condition and that dreadful condition was alleviated, I would be exceedingly happy the dreadful condition was gone, and far less concerned with how, why, or where it went! While all this may sound farfetched, the results show otherwise!

    diff --git a/share/rhemawave/tos/08 - Legal Notice.html b/share/rhemawave/tos/08 - Legal Notice.html new file mode 100644 index 0000000..ce836cc --- /dev/null +++ b/share/rhemawave/tos/08 - Legal Notice.html @@ -0,0 +1,11 @@ +

    Okay, all humor aside for this paragraph! Under U.S. federal law, specifically the Federal Food, Drug, and Cosmetic Act, a drug is generally defined as any substance intended for use in the diagnosis, cure, mitigation, treatment, or prevention of disease in humans or animals, or any substance other than food intended to affect the structure or function of the body. Thus, it is imperative anyone and everyone involved with RHEMA WAVE TECHNOLOGY understands that RHEMA WAVE TECHNOLOGY does not promote or provide drugs, medications, supplements, massage, manipulation, salves, ointments, injections, adjustments, surgeries, radiation, or any other therapies for that matter! Additionally, RHEMA WAVE TECHNOLOGY does not diagnose, cure, mitigate, treat, or prevent diseases in humans or animals!

    + +

    RHEMA WAVE TECHNOLOGY merely provides an environment offering your 37 trillion cells (+/-) the opportunity to recharge and hopefully function more efficiently and effectively. With this understanding it may be helpful to imagine the words "Focus On" in front of each proclamation title, as we believe focusing energy to certain predetermined areas simply allows your body to do what only it knows how to do!

    + +

    In order to maximize the effectiveness of your system we recommend placing it in your bedroom. This recommendation is based upon three factors:
    +1) The conscious mind is dormant during sleep, while the subconscious mind is not; thereby alleviating any conscious resistance.
    +2) Nighttime sleep sessions offer the largest amount of consecutive, uninterrupted, and disturbance free time our bodies have.
    +3) Our bodies generally heal more during sleep because we are inactive and not using energy for other purposes.
    +4) Results: those who sleep in the system tend to notice better and faster results, which is likely due to 1, 2, & 3!

    + +

    Understandably, there are certainly reasons for placing your system in other rooms, such as a living room in order to share the experience with family members, in an office if that is where you work, or wherever you generally spend the majority of your time. Regardless of where you place your system it will energize your home beyond the walls of the room where it resides; but obviously to a lesser extent. While the RHEMA WAVES will not be as effective outside the main area, customers who set their system up in their family room have called the very next day sharing how amazed they were at how well they slept even though the system was running in another room!

    diff --git a/share/rhemawave/tos/09 - Our Story.html b/share/rhemawave/tos/09 - Our Story.html new file mode 100644 index 0000000..b641696 --- /dev/null +++ b/share/rhemawave/tos/09 - Our Story.html @@ -0,0 +1,7 @@ +

    Okay, I have a confession to make and this seems like a good place to make it. I was lucky enough to find a very successful mentor who, in a matter months, taught me more about relationships, business, success, happiness, and just plain life than I ever learned in 16 years of school and college! I say that because, while the lessons I learned from him allowed me to reach the top 1% money earners on the planet and live a lifestyle few will ever experience, none of what I learned from my mentor is taught in school or college! Both what he taught me and the results I achieved following his advice not only inspired me to pursue this unprecedented opportunity, it also provided me with the wherewithal to conduct the research, develop and test designs, conduct experiments, and ultimately create RHEMA WAVE TECHNOLOGY! The miraculous products we currently offer, advances and refinements to those products, as well as products currently under development and yet to be conceived are all the result of what I learned under his mentorship. So, in some small way, my mentor is having an impact on you too!

    + +

    When I was first introduced to him he quickly realized my demeanor was very serious, critical, and structured. I had assumed this was how people conducted themselves in order to become successful. I was hoping he would be impressed with my performance because, in reality, I was broke, confused about how the world works, and desperately in need of guidance. The very first thing he said to me was, "If we are ever going to work together you must guarantee me one thing!" At that point in my life I was willing to do just about anything to learn what I knew I did not know and said, "Okay!" He said, "You must stop taking life so serious! And you must learn to NEVER, EVER lose your sense of humor! One thing you must understand is none of us are getting out of here alive anyway, so we might as well enjoy ourselves while we are here! Don't ever forget it!" I haven't.

    + +

    So if you are the kind of person whose demeanor is serious, critical, and structured, and you are unwilling to change, can't find a sense of humor, and refuse to stop taking life so serious, please return your system before you venture any further! Above all, the most important thing my mentor taught me was life is much better, more fun, and more fulfilling when we avoid dealing with people like I used to be! So, if you are committed to being like who I used to be, be a sport, send your system back, let those of us looking to enjoy health, vitality, happiness, and fulfillment enjoy the benefits of RHEMA WAVE TECHNOLOGY and just go on your merry way!

    + +

    As the Chief Developer who believed wholeheartedly in this amazing technology from the very beginning, I willingly and excitedly became the first RHEMA WAVE test subject. Almost immediately my home became my laboratory where every design, experiment, alteration, and advancement was tried and tested on me and my family. For well over a year we have been basking in RHEMA WAVES 24-hours a day, 7 days a week except for the occasional business meeting, short trips to the grocery store, or attending church! Currently we have 6 complete systems constantly running in our home simultaneously, 3 in bedrooms, 1 in the office, 1 in our kitchen/family room, and 1 in the home theater. Me, my wonderful wife, and our incredible children have been basking in, and continuously surrounded by RHEMA WAVES for well over a year with nothing but positive results to show for it! I purposely surrounded myself and my family with RHEMA WAVES for the sole purpose of proving the effectiveness and documenting NO NEGATIVE ADVERSE SIDE EFFECTS; that is how much I believe in RHEMA WAVE TECHNOLOGY!

    diff --git a/share/rhemawave/tos/10 - Results and Closing.html b/share/rhemawave/tos/10 - Results and Closing.html new file mode 100644 index 0000000..db41fbe --- /dev/null +++ b/share/rhemawave/tos/10 - Results and Closing.html @@ -0,0 +1,24 @@ +

    Now, the question I am asked most often, and the question likely on your mind is, "How long will it take before I notice changes?" Well, it depends:

    + +

    1) How old you are.
    +2) How many years/months you have been dealing with the issue.
    +3) What issues you will be striving to influence.
    +4) How many total issues you will be striving to influence.
    +5) How many issues you will be striving to influence simultaneously.
    +6) The severity of the issue(s) you will be striving to influence.
    +7) Where your system is located.
    +8) Primary activities taking place where your system is located: sleeping, working, eating, watching TV, exercising, etc.
    +9) Number of hours a day spent in the room where your system is located.
    +10) Whether you are genuinely excited about spending time in RHEMA WAVES and looking forward to positive results, or skeptical, pessimistic, and doubting you will experience positive influences.

    + +

    Each of these factors will have a profound affect on your results. While we are still unsure the extent to which a pessimistic attitude detracts from results, we do know those excited about spending time in RHEMA WAVES seem to achieve positive results sooner. Positive attitudes = Positive results! Negative attitudes = positive results too! (it just takes a bit more time!) If you are pessimistic, we suggest you including several "Attitude" and "Happiness" proclamations from the start!

    + +

    I actually heard from one of our beta testers early on who set their system up in their office because they spend more time in the office than in the bedroom. I recommended beginning with several proclamations including "Deep Sleep." They called me the very next morning amazed at how deeply they slept, how well rested they felt, and how their mind felt very clear! This despite the fact they rolled up in a blanket and slept on the office floor!

    + +

    We are excited for YOU and are available to answer your questions, satisfy your concerns, and entertain your ideas. We look forward to hearing from you and learning of your personal experiences as you bask in our RHEMA WAVE ENERGY FIELD! Always know that we will be basking right along with you!

    + +

    Welcome to a whole new world,

    + +

    RHEMA WAVE TECHNOLOGY
    +(817) 864-1111
    +rhemawavetechnology.com

    diff --git a/vendor/github.com/go-gl/gl/LICENSE b/vendor/github.com/go-gl/gl/LICENSE new file mode 100644 index 0000000..bac95ec --- /dev/null +++ b/vendor/github.com/go-gl/gl/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014 Eric Woroshow + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/vendor/github.com/go-gl/gl/v3.3-core/gl/KHR/dummy.go b/vendor/github.com/go-gl/gl/v3.3-core/gl/KHR/dummy.go new file mode 100644 index 0000000..9bdbdef --- /dev/null +++ b/vendor/github.com/go-gl/gl/v3.3-core/gl/KHR/dummy.go @@ -0,0 +1,5 @@ +//go:build required +// +build required + +// Package dummy prevents go tooling from stripping the c dependencies. +package dummy diff --git a/vendor/github.com/go-gl/gl/v3.3-core/gl/KHR/khrplatform.h b/vendor/github.com/go-gl/gl/v3.3-core/gl/KHR/khrplatform.h new file mode 100644 index 0000000..dd22d92 --- /dev/null +++ b/vendor/github.com/go-gl/gl/v3.3-core/gl/KHR/khrplatform.h @@ -0,0 +1,290 @@ +#ifndef __khrplatform_h_ +#define __khrplatform_h_ + +/* +** Copyright (c) 2008-2018 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +/* Khronos platform-specific types and definitions. + * + * The master copy of khrplatform.h is maintained in the Khronos EGL + * Registry repository at https://github.com/KhronosGroup/EGL-Registry + * The last semantic modification to khrplatform.h was at commit ID: + * 67a3e0864c2d75ea5287b9f3d2eb74a745936692 + * + * Adopters may modify this file to suit their platform. Adopters are + * encouraged to submit platform specific modifications to the Khronos + * group so that they can be included in future versions of this file. + * Please submit changes by filing pull requests or issues on + * the EGL Registry repository linked above. + * + * + * See the Implementer's Guidelines for information about where this file + * should be located on your system and for more details of its use: + * http://www.khronos.org/registry/implementers_guide.pdf + * + * This file should be included as + * #include + * by Khronos client API header files that use its types and defines. + * + * The types in khrplatform.h should only be used to define API-specific types. + * + * Types defined in khrplatform.h: + * khronos_int8_t signed 8 bit + * khronos_uint8_t unsigned 8 bit + * khronos_int16_t signed 16 bit + * khronos_uint16_t unsigned 16 bit + * khronos_int32_t signed 32 bit + * khronos_uint32_t unsigned 32 bit + * khronos_int64_t signed 64 bit + * khronos_uint64_t unsigned 64 bit + * khronos_intptr_t signed same number of bits as a pointer + * khronos_uintptr_t unsigned same number of bits as a pointer + * khronos_ssize_t signed size + * khronos_usize_t unsigned size + * khronos_float_t signed 32 bit floating point + * khronos_time_ns_t unsigned 64 bit time in nanoseconds + * khronos_utime_nanoseconds_t unsigned time interval or absolute time in + * nanoseconds + * khronos_stime_nanoseconds_t signed time interval in nanoseconds + * khronos_boolean_enum_t enumerated boolean type. This should + * only be used as a base type when a client API's boolean type is + * an enum. Client APIs which use an integer or other type for + * booleans cannot use this as the base type for their boolean. + * + * Tokens defined in khrplatform.h: + * + * KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values. + * + * KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0. + * KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0. + * + * Calling convention macros defined in this file: + * KHRONOS_APICALL + * KHRONOS_APIENTRY + * KHRONOS_APIATTRIBUTES + * + * These may be used in function prototypes as: + * + * KHRONOS_APICALL void KHRONOS_APIENTRY funcname( + * int arg1, + * int arg2) KHRONOS_APIATTRIBUTES; + */ + +#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) +# define KHRONOS_STATIC 1 +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(KHRONOS_STATIC) + /* If the preprocessor constant KHRONOS_STATIC is defined, make the + * header compatible with static linking. */ +# define KHRONOS_APICALL +#elif defined(_WIN32) +# define KHRONOS_APICALL __declspec(dllimport) +#elif defined (__SYMBIAN32__) +# define KHRONOS_APICALL IMPORT_C +#elif defined(__ANDROID__) +# define KHRONOS_APICALL __attribute__((visibility("default"))) +#else +# define KHRONOS_APICALL +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APIENTRY + *------------------------------------------------------------------------- + * This follows the return type of the function and precedes the function + * name in the function prototype. + */ +#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__) + /* Win32 but not WinCE */ +# define KHRONOS_APIENTRY __stdcall +#else +# define KHRONOS_APIENTRY +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APIATTRIBUTES + *------------------------------------------------------------------------- + * This follows the closing parenthesis of the function prototype arguments. + */ +#if defined (__ARMCC_2__) +#define KHRONOS_APIATTRIBUTES __softfp +#else +#define KHRONOS_APIATTRIBUTES +#endif + +/*------------------------------------------------------------------------- + * basic type definitions + *-----------------------------------------------------------------------*/ +#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__) + + +/* + * Using + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif defined(__VMS ) || defined(__sgi) + +/* + * Using + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif defined(_WIN32) && !defined(__SCITECH_SNAP__) + +/* + * Win32 + */ +typedef __int32 khronos_int32_t; +typedef unsigned __int32 khronos_uint32_t; +typedef __int64 khronos_int64_t; +typedef unsigned __int64 khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif defined(__sun__) || defined(__digital__) + +/* + * Sun or Digital + */ +typedef int khronos_int32_t; +typedef unsigned int khronos_uint32_t; +#if defined(__arch64__) || defined(_LP64) +typedef long int khronos_int64_t; +typedef unsigned long int khronos_uint64_t; +#else +typedef long long int khronos_int64_t; +typedef unsigned long long int khronos_uint64_t; +#endif /* __arch64__ */ +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif 0 + +/* + * Hypothetical platform with no float or int64 support + */ +typedef int khronos_int32_t; +typedef unsigned int khronos_uint32_t; +#define KHRONOS_SUPPORT_INT64 0 +#define KHRONOS_SUPPORT_FLOAT 0 + +#else + +/* + * Generic fallback + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#endif + + +/* + * Types that are (so far) the same on all platforms + */ +typedef signed char khronos_int8_t; +typedef unsigned char khronos_uint8_t; +typedef signed short int khronos_int16_t; +typedef unsigned short int khronos_uint16_t; + +/* + * Types that differ between LLP64 and LP64 architectures - in LLP64, + * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears + * to be the only LLP64 architecture in current use. + */ +#ifdef _WIN64 +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +typedef signed long int khronos_ssize_t; +typedef unsigned long int khronos_usize_t; +#endif + +#if KHRONOS_SUPPORT_FLOAT +/* + * Float type + */ +typedef float khronos_float_t; +#endif + +#if KHRONOS_SUPPORT_INT64 +/* Time types + * + * These types can be used to represent a time interval in nanoseconds or + * an absolute Unadjusted System Time. Unadjusted System Time is the number + * of nanoseconds since some arbitrary system event (e.g. since the last + * time the system booted). The Unadjusted System Time is an unsigned + * 64 bit value that wraps back to 0 every 584 years. Time intervals + * may be either signed or unsigned. + */ +typedef khronos_uint64_t khronos_utime_nanoseconds_t; +typedef khronos_int64_t khronos_stime_nanoseconds_t; +#endif + +/* + * Dummy value used to pad enum types to 32 bits. + */ +#ifndef KHRONOS_MAX_ENUM +#define KHRONOS_MAX_ENUM 0x7FFFFFFF +#endif + +/* + * Enumerated boolean type + * + * Values other than zero should be considered to be true. Therefore + * comparisons should not be made against KHRONOS_TRUE. + */ +typedef enum { + KHRONOS_FALSE = 0, + KHRONOS_TRUE = 1, + KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM +} khronos_boolean_enum_t; + +#endif /* __khrplatform_h_ */ diff --git a/vendor/github.com/go-gl/gl/v3.3-core/gl/build_cgo_hack.go b/vendor/github.com/go-gl/gl/v3.3-core/gl/build_cgo_hack.go new file mode 100644 index 0000000..6c59262 --- /dev/null +++ b/vendor/github.com/go-gl/gl/v3.3-core/gl/build_cgo_hack.go @@ -0,0 +1,17 @@ +//go:build required +// +build required + +package gl + +// This file exists purely to prevent the golang toolchain from stripping +// away the c source directories and files when `go mod vendor` is used +// to populate a `vendor/` directory of a project depending on `go-gl/go`. +// +// How it works: +// - every directory which only includes c source files receives a dummy.go file. +// - every directory we want to preserve is included here as a _ import. +// - this file is given a build tag to exclude it from the regular build. +import ( + // Prevent go tooling from stripping out the c source files. + _ "github.com/go-gl/gl/v3.3-core/gl/KHR" +) diff --git a/vendor/github.com/go-gl/gl/v3.3-core/gl/conversions.go b/vendor/github.com/go-gl/gl/v3.3-core/gl/conversions.go new file mode 100644 index 0000000..bd70f24 --- /dev/null +++ b/vendor/github.com/go-gl/gl/v3.3-core/gl/conversions.go @@ -0,0 +1,116 @@ +// Code generated by glow (https://github.com/go-gl/glow). DO NOT EDIT. + +package gl + +import ( + "fmt" + "reflect" + "strings" + "unsafe" +) + +// #include +import "C" + +// Ptr takes a slice or pointer (to a singular scalar value or the first +// element of an array or slice) and returns its GL-compatible address. +// +// For example: +// +// var data []uint8 +// ... +// gl.TexImage2D(gl.TEXTURE_2D, ..., gl.UNSIGNED_BYTE, gl.Ptr(&data[0])) +func Ptr(data interface{}) unsafe.Pointer { + if data == nil { + return unsafe.Pointer(nil) + } + var addr unsafe.Pointer + v := reflect.ValueOf(data) + switch v.Type().Kind() { + case reflect.Ptr: + e := v.Elem() + switch e.Kind() { + case + reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, + reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, + reflect.Float32, reflect.Float64: + addr = unsafe.Pointer(e.UnsafeAddr()) + default: + panic(fmt.Errorf("unsupported pointer to type %s; must be a slice or pointer to a singular scalar value or the first element of an array or slice", e.Kind())) + } + case reflect.Uintptr: + addr = unsafe.Pointer(data.(uintptr)) + case reflect.Slice: + addr = unsafe.Pointer(v.Index(0).UnsafeAddr()) + default: + panic(fmt.Errorf("unsupported type %s; must be a slice or pointer to a singular scalar value or the first element of an array or slice", v.Type())) + } + return addr +} + +// PtrOffset takes a pointer offset and returns a GL-compatible pointer. +// Originally intended for functions such as glVertexAttribPointer that take pointer +// parameters also for offsets, since Go 1.14 this is no longer recommended. +// +// Use a corresponding offset-compatible variant of the function instead. +// For example, for gl.VertexAttribPointer() there is gl.VertexAttribPointerWithOffset(). +// +// See https://github.com/go-gl/gl#go-114-and-checkptr for more details on the checkptr detector. +// See https://github.com/go-gl/glow#overloads, about adding new overloads. +// +// Deprecated: Use more appropriate overload function instead +func PtrOffset(offset int) unsafe.Pointer { + return unsafe.Pointer(uintptr(offset)) +} + +// Str takes a null-terminated Go string and returns its GL-compatible address. +// This function reaches into Go string storage in an unsafe way so the caller +// must ensure the string is not garbage collected. +func Str(str string) *uint8 { + if !strings.HasSuffix(str, "\x00") { + panic("str argument missing null terminator: " + str) + } + header := (*reflect.StringHeader)(unsafe.Pointer(&str)) + return (*uint8)(unsafe.Pointer(header.Data)) +} + +// GoStr takes a null-terminated string returned by OpenGL and constructs a +// corresponding Go string. +func GoStr(cstr *uint8) string { + return C.GoString((*C.char)(unsafe.Pointer(cstr))) +} + +// Strs takes a list of Go strings (with or without null-termination) and +// returns their C counterpart. +// +// The returned free function must be called once you are done using the strings +// in order to free the memory. +// +// If no strings are provided as a parameter this function will panic. +func Strs(strs ...string) (cstrs **uint8, free func()) { + if len(strs) == 0 { + panic("Strs: expected at least 1 string") + } + + // Allocate a contiguous array large enough to hold all the strings' contents. + n := 0 + for i := range strs { + n += len(strs[i]) + } + if n == 0 { + n = 1 // avoid allocating zero bytes in case all strings are empty. + } + data := C.malloc(C.size_t(n)) + + // Copy all the strings into data. + dataSlice := (*[1 << 30]byte)(data)[:n] + css := make([]*uint8, len(strs)) // Populated with pointers to each string. + offset := 0 + for i := range strs { + copy(dataSlice[offset:offset+len(strs[i])], strs[i][:]) // Copy strs[i] into proper data location. + css[i] = (*uint8)(unsafe.Pointer(&dataSlice[offset])) // Set a pointer to it. + offset += len(strs[i]) + } + + return (**uint8)(&css[0]), func() { C.free(data) } +} diff --git a/vendor/github.com/go-gl/gl/v3.3-core/gl/debug.go b/vendor/github.com/go-gl/gl/v3.3-core/gl/debug.go new file mode 100644 index 0000000..ee22784 --- /dev/null +++ b/vendor/github.com/go-gl/gl/v3.3-core/gl/debug.go @@ -0,0 +1,31 @@ +// Code generated by glow (https://github.com/go-gl/glow). DO NOT EDIT. + +package gl + +import "C" +import "unsafe" + +type DebugProc func( + source uint32, + gltype uint32, + id uint32, + severity uint32, + length int32, + message string, + userParam unsafe.Pointer) + +var userDebugCallback DebugProc + +//export glowDebugCallback_glcore33 +func glowDebugCallback_glcore33( + source uint32, + gltype uint32, + id uint32, + severity uint32, + length int32, + message *uint8, + userParam unsafe.Pointer) { + if userDebugCallback != nil { + userDebugCallback(source, gltype, id, severity, length, GoStr(message), userParam) + } +} diff --git a/vendor/github.com/go-gl/gl/v3.3-core/gl/package.go b/vendor/github.com/go-gl/gl/v3.3-core/gl/package.go new file mode 100644 index 0000000..1c38c37 --- /dev/null +++ b/vendor/github.com/go-gl/gl/v3.3-core/gl/package.go @@ -0,0 +1,15867 @@ +// Code generated by glow (https://github.com/go-gl/glow). DO NOT EDIT. + +// Copyright (c) 2010 Khronos Group. +// This material may be distributed subject to the terms and conditions +// set forth in the Open Publication License, v 1.0, 8 June 1999. +// http://opencontent.org/openpub/. +// +// Copyright (c) 1991-2006 Silicon Graphics, Inc. +// This document is licensed under the SGI Free Software B License. +// For details, see http://oss.sgi.com/projects/FreeB. + +// Package gl implements Go bindings to OpenGL. +// +// This package was automatically generated using Glow: +// +// https://github.com/go-gl/glow +package gl + +// #cgo !gles2,darwin LDFLAGS: -framework OpenGL +// #cgo gles2,darwin LDFLAGS: -framework OpenGLES +// #cgo !gles2,windows LDFLAGS: -lopengl32 +// #cgo gles2,windows LDFLAGS: -lGLESv2 +// #cgo !egl,linux !egl,freebsd !egl,netbsd !egl,openbsd pkg-config: gl +// #cgo egl,linux egl,freebsd egl,netbsd egl,openbsd pkg-config: egl +// #if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) +// #ifndef WIN32_LEAN_AND_MEAN +// #define WIN32_LEAN_AND_MEAN 1 +// #endif +// #include +// #endif +// #ifndef APIENTRY +// #define APIENTRY +// #endif +// #ifndef APIENTRYP +// #define APIENTRYP APIENTRY * +// #endif +// #ifndef GLAPI +// #define GLAPI extern +// #endif +// #include +// typedef unsigned int GLenum; +// typedef unsigned char GLboolean; +// typedef unsigned int GLbitfield; +// typedef khronos_int8_t GLbyte; +// typedef khronos_uint8_t GLubyte; +// typedef khronos_int16_t GLshort; +// typedef khronos_uint16_t GLushort; +// typedef int GLint; +// typedef unsigned int GLuint; +// typedef int GLsizei; +// typedef khronos_float_t GLfloat; +// typedef double GLdouble; +// typedef void *GLeglImageOES; +// typedef char GLchar; +// typedef khronos_intptr_t GLintptr; +// typedef khronos_ssize_t GLsizeiptr; +// typedef khronos_int64_t GLint64; +// typedef khronos_int64_t GLint64EXT; +// typedef khronos_uint64_t GLuint64; +// typedef khronos_uint64_t GLuint64EXT; +// typedef uintptr_t GLsync; +// struct _cl_context; +// struct _cl_event; +// typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +// typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +// typedef void (APIENTRY *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +// typedef void (APIENTRY *GLVULKANPROCNV)(void); +// extern void glowDebugCallback_glcore33(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam); +// static void APIENTRY glowCDebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam) { +// glowDebugCallback_glcore33(source, type, id, severity, length, message, userParam); +// } +// typedef void (APIENTRYP GPACTIVEPROGRAMEXT)(GLuint program); +// typedef void (APIENTRYP GPACTIVESHADERPROGRAM)(GLuint pipeline, GLuint program); +// typedef void (APIENTRYP GPACTIVESHADERPROGRAMEXT)(GLuint pipeline, GLuint program); +// typedef void (APIENTRYP GPACTIVETEXTURE)(GLenum texture); +// typedef void (APIENTRYP GPAPPLYFRAMEBUFFERATTACHMENTCMAAINTEL)(); +// typedef void (APIENTRYP GPATTACHSHADER)(GLuint program, GLuint shader); +// typedef void (APIENTRYP GPBEGINCONDITIONALRENDER)(GLuint id, GLenum mode); +// typedef void (APIENTRYP GPBEGINCONDITIONALRENDERNV)(GLuint id, GLenum mode); +// typedef void (APIENTRYP GPBEGINPERFMONITORAMD)(GLuint monitor); +// typedef void (APIENTRYP GPBEGINPERFQUERYINTEL)(GLuint queryHandle); +// typedef void (APIENTRYP GPBEGINQUERY)(GLenum target, GLuint id); +// typedef void (APIENTRYP GPBEGINQUERYINDEXED)(GLenum target, GLuint index, GLuint id); +// typedef void (APIENTRYP GPBEGINTRANSFORMFEEDBACK)(GLenum primitiveMode); +// typedef void (APIENTRYP GPBINDATTRIBLOCATION)(GLuint program, GLuint index, const GLchar * name); +// typedef void (APIENTRYP GPBINDBUFFER)(GLenum target, GLuint buffer); +// typedef void (APIENTRYP GPBINDBUFFERBASE)(GLenum target, GLuint index, GLuint buffer); +// typedef void (APIENTRYP GPBINDBUFFERRANGE)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +// typedef void (APIENTRYP GPBINDBUFFERSBASE)(GLenum target, GLuint first, GLsizei count, const GLuint * buffers); +// typedef void (APIENTRYP GPBINDBUFFERSRANGE)(GLenum target, GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizeiptr * sizes); +// typedef void (APIENTRYP GPBINDFRAGDATALOCATION)(GLuint program, GLuint color, const GLchar * name); +// typedef void (APIENTRYP GPBINDFRAGDATALOCATIONINDEXED)(GLuint program, GLuint colorNumber, GLuint index, const GLchar * name); +// typedef void (APIENTRYP GPBINDFRAMEBUFFER)(GLenum target, GLuint framebuffer); +// typedef void (APIENTRYP GPBINDIMAGETEXTURE)(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format); +// typedef void (APIENTRYP GPBINDIMAGETEXTURES)(GLuint first, GLsizei count, const GLuint * textures); +// typedef void (APIENTRYP GPBINDMULTITEXTUREEXT)(GLenum texunit, GLenum target, GLuint texture); +// typedef void (APIENTRYP GPBINDPROGRAMPIPELINE)(GLuint pipeline); +// typedef void (APIENTRYP GPBINDPROGRAMPIPELINEEXT)(GLuint pipeline); +// typedef void (APIENTRYP GPBINDRENDERBUFFER)(GLenum target, GLuint renderbuffer); +// typedef void (APIENTRYP GPBINDSAMPLER)(GLuint unit, GLuint sampler); +// typedef void (APIENTRYP GPBINDSAMPLERS)(GLuint first, GLsizei count, const GLuint * samplers); +// typedef void (APIENTRYP GPBINDSHADINGRATEIMAGENV)(GLuint texture); +// typedef void (APIENTRYP GPBINDTEXTURE)(GLenum target, GLuint texture); +// typedef void (APIENTRYP GPBINDTEXTUREUNIT)(GLuint unit, GLuint texture); +// typedef void (APIENTRYP GPBINDTEXTURES)(GLuint first, GLsizei count, const GLuint * textures); +// typedef void (APIENTRYP GPBINDTRANSFORMFEEDBACK)(GLenum target, GLuint id); +// typedef void (APIENTRYP GPBINDVERTEXARRAY)(GLuint array); +// typedef void (APIENTRYP GPBINDVERTEXBUFFER)(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride); +// typedef void (APIENTRYP GPBINDVERTEXBUFFERS)(GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizei * strides); +// typedef void (APIENTRYP GPBLENDBARRIERKHR)(); +// typedef void (APIENTRYP GPBLENDBARRIERNV)(); +// typedef void (APIENTRYP GPBLENDCOLOR)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +// typedef void (APIENTRYP GPBLENDEQUATION)(GLenum mode); +// typedef void (APIENTRYP GPBLENDEQUATIONSEPARATE)(GLenum modeRGB, GLenum modeAlpha); +// typedef void (APIENTRYP GPBLENDEQUATIONSEPARATEIARB)(GLuint buf, GLenum modeRGB, GLenum modeAlpha); +// typedef void (APIENTRYP GPBLENDEQUATIONIARB)(GLuint buf, GLenum mode); +// typedef void (APIENTRYP GPBLENDFUNC)(GLenum sfactor, GLenum dfactor); +// typedef void (APIENTRYP GPBLENDFUNCSEPARATE)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +// typedef void (APIENTRYP GPBLENDFUNCSEPARATEIARB)(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +// typedef void (APIENTRYP GPBLENDFUNCIARB)(GLuint buf, GLenum src, GLenum dst); +// typedef void (APIENTRYP GPBLENDPARAMETERINV)(GLenum pname, GLint value); +// typedef void (APIENTRYP GPBLITFRAMEBUFFER)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +// typedef void (APIENTRYP GPBLITNAMEDFRAMEBUFFER)(GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +// typedef void (APIENTRYP GPBUFFERADDRESSRANGENV)(GLenum pname, GLuint index, GLuint64EXT address, GLsizeiptr length); +// typedef void (APIENTRYP GPBUFFERATTACHMEMORYNV)(GLenum target, GLuint memory, GLuint64 offset); +// typedef void (APIENTRYP GPBUFFERDATA)(GLenum target, GLsizeiptr size, const void * data, GLenum usage); +// typedef void (APIENTRYP GPBUFFERPAGECOMMITMENTARB)(GLenum target, GLintptr offset, GLsizeiptr size, GLboolean commit); +// typedef void (APIENTRYP GPBUFFERPAGECOMMITMENTMEMNV)(GLenum target, GLintptr offset, GLsizeiptr size, GLuint memory, GLuint64 memOffset, GLboolean commit); +// typedef void (APIENTRYP GPBUFFERSTORAGE)(GLenum target, GLsizeiptr size, const void * data, GLbitfield flags); +// typedef void (APIENTRYP GPBUFFERSUBDATA)(GLenum target, GLintptr offset, GLsizeiptr size, const void * data); +// typedef void (APIENTRYP GPCALLCOMMANDLISTNV)(GLuint list); +// typedef GLenum (APIENTRYP GPCHECKFRAMEBUFFERSTATUS)(GLenum target); +// typedef GLenum (APIENTRYP GPCHECKNAMEDFRAMEBUFFERSTATUS)(GLuint framebuffer, GLenum target); +// typedef GLenum (APIENTRYP GPCHECKNAMEDFRAMEBUFFERSTATUSEXT)(GLuint framebuffer, GLenum target); +// typedef void (APIENTRYP GPCLAMPCOLOR)(GLenum target, GLenum clamp); +// typedef void (APIENTRYP GPCLEAR)(GLbitfield mask); +// typedef void (APIENTRYP GPCLEARBUFFERDATA)(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void * data); +// typedef void (APIENTRYP GPCLEARBUFFERSUBDATA)(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data); +// typedef void (APIENTRYP GPCLEARBUFFERFI)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +// typedef void (APIENTRYP GPCLEARBUFFERFV)(GLenum buffer, GLint drawbuffer, const GLfloat * value); +// typedef void (APIENTRYP GPCLEARBUFFERIV)(GLenum buffer, GLint drawbuffer, const GLint * value); +// typedef void (APIENTRYP GPCLEARBUFFERUIV)(GLenum buffer, GLint drawbuffer, const GLuint * value); +// typedef void (APIENTRYP GPCLEARCOLOR)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +// typedef void (APIENTRYP GPCLEARDEPTH)(GLdouble depth); +// typedef void (APIENTRYP GPCLEARDEPTHDNV)(GLdouble depth); +// typedef void (APIENTRYP GPCLEARDEPTHF)(GLfloat d); +// typedef void (APIENTRYP GPCLEARNAMEDBUFFERDATA)(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void * data); +// typedef void (APIENTRYP GPCLEARNAMEDBUFFERDATAEXT)(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void * data); +// typedef void (APIENTRYP GPCLEARNAMEDBUFFERSUBDATA)(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data); +// typedef void (APIENTRYP GPCLEARNAMEDBUFFERSUBDATAEXT)(GLuint buffer, GLenum internalformat, GLsizeiptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data); +// typedef void (APIENTRYP GPCLEARNAMEDFRAMEBUFFERFI)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +// typedef void (APIENTRYP GPCLEARNAMEDFRAMEBUFFERFV)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat * value); +// typedef void (APIENTRYP GPCLEARNAMEDFRAMEBUFFERIV)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint * value); +// typedef void (APIENTRYP GPCLEARNAMEDFRAMEBUFFERUIV)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint * value); +// typedef void (APIENTRYP GPCLEARSTENCIL)(GLint s); +// typedef void (APIENTRYP GPCLEARTEXIMAGE)(GLuint texture, GLint level, GLenum format, GLenum type, const void * data); +// typedef void (APIENTRYP GPCLEARTEXSUBIMAGE)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); +// typedef void (APIENTRYP GPCLIENTATTRIBDEFAULTEXT)(GLbitfield mask); +// typedef GLenum (APIENTRYP GPCLIENTWAITSYNC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +// typedef void (APIENTRYP GPCLIPCONTROL)(GLenum origin, GLenum depth); +// typedef void (APIENTRYP GPCOLORFORMATNV)(GLint size, GLenum type, GLsizei stride); +// typedef void (APIENTRYP GPCOLORMASK)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +// typedef void (APIENTRYP GPCOLORMASKI)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +// typedef void (APIENTRYP GPCOMMANDLISTSEGMENTSNV)(GLuint list, GLuint segments); +// typedef void (APIENTRYP GPCOMPILECOMMANDLISTNV)(GLuint list); +// typedef void (APIENTRYP GPCOMPILESHADER)(GLuint shader); +// typedef void (APIENTRYP GPCOMPILESHADERINCLUDEARB)(GLuint shader, GLsizei count, const GLchar *const* path, const GLint * length); +// typedef void (APIENTRYP GPCOMPRESSEDMULTITEXIMAGE1DEXT)(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * bits); +// typedef void (APIENTRYP GPCOMPRESSEDMULTITEXIMAGE2DEXT)(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * bits); +// typedef void (APIENTRYP GPCOMPRESSEDMULTITEXIMAGE3DEXT)(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * bits); +// typedef void (APIENTRYP GPCOMPRESSEDMULTITEXSUBIMAGE1DEXT)(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * bits); +// typedef void (APIENTRYP GPCOMPRESSEDMULTITEXSUBIMAGE2DEXT)(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * bits); +// typedef void (APIENTRYP GPCOMPRESSEDMULTITEXSUBIMAGE3DEXT)(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * bits); +// typedef void (APIENTRYP GPCOMPRESSEDTEXIMAGE1D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data); +// typedef void (APIENTRYP GPCOMPRESSEDTEXIMAGE2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data); +// typedef void (APIENTRYP GPCOMPRESSEDTEXIMAGE3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data); +// typedef void (APIENTRYP GPCOMPRESSEDTEXSUBIMAGE1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data); +// typedef void (APIENTRYP GPCOMPRESSEDTEXSUBIMAGE2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data); +// typedef void (APIENTRYP GPCOMPRESSEDTEXSUBIMAGE3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data); +// typedef void (APIENTRYP GPCOMPRESSEDTEXTUREIMAGE1DEXT)(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * bits); +// typedef void (APIENTRYP GPCOMPRESSEDTEXTUREIMAGE2DEXT)(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * bits); +// typedef void (APIENTRYP GPCOMPRESSEDTEXTUREIMAGE3DEXT)(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * bits); +// typedef void (APIENTRYP GPCOMPRESSEDTEXTURESUBIMAGE1D)(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data); +// typedef void (APIENTRYP GPCOMPRESSEDTEXTURESUBIMAGE1DEXT)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * bits); +// typedef void (APIENTRYP GPCOMPRESSEDTEXTURESUBIMAGE2D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data); +// typedef void (APIENTRYP GPCOMPRESSEDTEXTURESUBIMAGE2DEXT)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * bits); +// typedef void (APIENTRYP GPCOMPRESSEDTEXTURESUBIMAGE3D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data); +// typedef void (APIENTRYP GPCOMPRESSEDTEXTURESUBIMAGE3DEXT)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * bits); +// typedef void (APIENTRYP GPCONSERVATIVERASTERPARAMETERFNV)(GLenum pname, GLfloat value); +// typedef void (APIENTRYP GPCONSERVATIVERASTERPARAMETERINV)(GLenum pname, GLint param); +// typedef void (APIENTRYP GPCOPYBUFFERSUBDATA)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +// typedef void (APIENTRYP GPCOPYIMAGESUBDATA)(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth); +// typedef void (APIENTRYP GPCOPYMULTITEXIMAGE1DEXT)(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +// typedef void (APIENTRYP GPCOPYMULTITEXIMAGE2DEXT)(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +// typedef void (APIENTRYP GPCOPYMULTITEXSUBIMAGE1DEXT)(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +// typedef void (APIENTRYP GPCOPYMULTITEXSUBIMAGE2DEXT)(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPCOPYMULTITEXSUBIMAGE3DEXT)(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPCOPYNAMEDBUFFERSUBDATA)(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +// typedef void (APIENTRYP GPCOPYPATHNV)(GLuint resultPath, GLuint srcPath); +// typedef void (APIENTRYP GPCOPYTEXIMAGE1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +// typedef void (APIENTRYP GPCOPYTEXIMAGE2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +// typedef void (APIENTRYP GPCOPYTEXSUBIMAGE1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +// typedef void (APIENTRYP GPCOPYTEXSUBIMAGE2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPCOPYTEXSUBIMAGE3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPCOPYTEXTUREIMAGE1DEXT)(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +// typedef void (APIENTRYP GPCOPYTEXTUREIMAGE2DEXT)(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +// typedef void (APIENTRYP GPCOPYTEXTURESUBIMAGE1D)(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +// typedef void (APIENTRYP GPCOPYTEXTURESUBIMAGE1DEXT)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +// typedef void (APIENTRYP GPCOPYTEXTURESUBIMAGE2D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPCOPYTEXTURESUBIMAGE2DEXT)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPCOPYTEXTURESUBIMAGE3D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPCOPYTEXTURESUBIMAGE3DEXT)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPCOVERFILLPATHINSTANCEDNV)(GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat * transformValues); +// typedef void (APIENTRYP GPCOVERFILLPATHNV)(GLuint path, GLenum coverMode); +// typedef void (APIENTRYP GPCOVERSTROKEPATHINSTANCEDNV)(GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat * transformValues); +// typedef void (APIENTRYP GPCOVERSTROKEPATHNV)(GLuint path, GLenum coverMode); +// typedef void (APIENTRYP GPCOVERAGEMODULATIONNV)(GLenum components); +// typedef void (APIENTRYP GPCOVERAGEMODULATIONTABLENV)(GLsizei n, const GLfloat * v); +// typedef void (APIENTRYP GPCREATEBUFFERS)(GLsizei n, GLuint * buffers); +// typedef void (APIENTRYP GPCREATECOMMANDLISTSNV)(GLsizei n, GLuint * lists); +// typedef void (APIENTRYP GPCREATEFRAMEBUFFERS)(GLsizei n, GLuint * framebuffers); +// typedef void (APIENTRYP GPCREATEPERFQUERYINTEL)(GLuint queryId, GLuint * queryHandle); +// typedef GLuint (APIENTRYP GPCREATEPROGRAM)(); +// typedef void (APIENTRYP GPCREATEPROGRAMPIPELINES)(GLsizei n, GLuint * pipelines); +// typedef void (APIENTRYP GPCREATEQUERIES)(GLenum target, GLsizei n, GLuint * ids); +// typedef void (APIENTRYP GPCREATERENDERBUFFERS)(GLsizei n, GLuint * renderbuffers); +// typedef void (APIENTRYP GPCREATESAMPLERS)(GLsizei n, GLuint * samplers); +// typedef GLuint (APIENTRYP GPCREATESHADER)(GLenum type); +// typedef GLuint (APIENTRYP GPCREATESHADERPROGRAMEXT)(GLenum type, const GLchar * string); +// typedef GLuint (APIENTRYP GPCREATESHADERPROGRAMV)(GLenum type, GLsizei count, const GLchar *const* strings); +// typedef GLuint (APIENTRYP GPCREATESHADERPROGRAMVEXT)(GLenum type, GLsizei count, const GLchar ** strings); +// typedef void (APIENTRYP GPCREATESTATESNV)(GLsizei n, GLuint * states); +// typedef GLsync (APIENTRYP GPCREATESYNCFROMCLEVENTARB)(struct _cl_context * context, struct _cl_event * event, GLbitfield flags); +// typedef void (APIENTRYP GPCREATETEXTURES)(GLenum target, GLsizei n, GLuint * textures); +// typedef void (APIENTRYP GPCREATETRANSFORMFEEDBACKS)(GLsizei n, GLuint * ids); +// typedef void (APIENTRYP GPCREATEVERTEXARRAYS)(GLsizei n, GLuint * arrays); +// typedef void (APIENTRYP GPCULLFACE)(GLenum mode); +// typedef void (APIENTRYP GPDEBUGMESSAGECALLBACK)(GLDEBUGPROC callback, const void * userParam); +// typedef void (APIENTRYP GPDEBUGMESSAGECALLBACKARB)(GLDEBUGPROCARB callback, const void * userParam); +// typedef void (APIENTRYP GPDEBUGMESSAGECALLBACKKHR)(GLDEBUGPROCKHR callback, const void * userParam); +// typedef void (APIENTRYP GPDEBUGMESSAGECONTROL)(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint * ids, GLboolean enabled); +// typedef void (APIENTRYP GPDEBUGMESSAGECONTROLARB)(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint * ids, GLboolean enabled); +// typedef void (APIENTRYP GPDEBUGMESSAGECONTROLKHR)(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint * ids, GLboolean enabled); +// typedef void (APIENTRYP GPDEBUGMESSAGEINSERT)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar * buf); +// typedef void (APIENTRYP GPDEBUGMESSAGEINSERTARB)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar * buf); +// typedef void (APIENTRYP GPDEBUGMESSAGEINSERTKHR)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar * buf); +// typedef void (APIENTRYP GPDELETEBUFFERS)(GLsizei n, const GLuint * buffers); +// typedef void (APIENTRYP GPDELETECOMMANDLISTSNV)(GLsizei n, const GLuint * lists); +// typedef void (APIENTRYP GPDELETEFRAMEBUFFERS)(GLsizei n, const GLuint * framebuffers); +// typedef void (APIENTRYP GPDELETENAMEDSTRINGARB)(GLint namelen, const GLchar * name); +// typedef void (APIENTRYP GPDELETEPATHSNV)(GLuint path, GLsizei range); +// typedef void (APIENTRYP GPDELETEPERFMONITORSAMD)(GLsizei n, GLuint * monitors); +// typedef void (APIENTRYP GPDELETEPERFQUERYINTEL)(GLuint queryHandle); +// typedef void (APIENTRYP GPDELETEPROGRAM)(GLuint program); +// typedef void (APIENTRYP GPDELETEPROGRAMPIPELINES)(GLsizei n, const GLuint * pipelines); +// typedef void (APIENTRYP GPDELETEPROGRAMPIPELINESEXT)(GLsizei n, const GLuint * pipelines); +// typedef void (APIENTRYP GPDELETEQUERIES)(GLsizei n, const GLuint * ids); +// typedef void (APIENTRYP GPDELETERENDERBUFFERS)(GLsizei n, const GLuint * renderbuffers); +// typedef void (APIENTRYP GPDELETESAMPLERS)(GLsizei count, const GLuint * samplers); +// typedef void (APIENTRYP GPDELETESHADER)(GLuint shader); +// typedef void (APIENTRYP GPDELETESTATESNV)(GLsizei n, const GLuint * states); +// typedef void (APIENTRYP GPDELETESYNC)(GLsync sync); +// typedef void (APIENTRYP GPDELETETEXTURES)(GLsizei n, const GLuint * textures); +// typedef void (APIENTRYP GPDELETETRANSFORMFEEDBACKS)(GLsizei n, const GLuint * ids); +// typedef void (APIENTRYP GPDELETEVERTEXARRAYS)(GLsizei n, const GLuint * arrays); +// typedef void (APIENTRYP GPDEPTHBOUNDSDNV)(GLdouble zmin, GLdouble zmax); +// typedef void (APIENTRYP GPDEPTHFUNC)(GLenum func); +// typedef void (APIENTRYP GPDEPTHMASK)(GLboolean flag); +// typedef void (APIENTRYP GPDEPTHRANGE)(GLdouble n, GLdouble f); +// typedef void (APIENTRYP GPDEPTHRANGEARRAYDVNV)(GLuint first, GLsizei count, const GLdouble * v); +// typedef void (APIENTRYP GPDEPTHRANGEARRAYV)(GLuint first, GLsizei count, const GLdouble * v); +// typedef void (APIENTRYP GPDEPTHRANGEINDEXED)(GLuint index, GLdouble n, GLdouble f); +// typedef void (APIENTRYP GPDEPTHRANGEINDEXEDDNV)(GLuint index, GLdouble n, GLdouble f); +// typedef void (APIENTRYP GPDEPTHRANGEDNV)(GLdouble zNear, GLdouble zFar); +// typedef void (APIENTRYP GPDEPTHRANGEF)(GLfloat n, GLfloat f); +// typedef void (APIENTRYP GPDETACHSHADER)(GLuint program, GLuint shader); +// typedef void (APIENTRYP GPDISABLE)(GLenum cap); +// typedef void (APIENTRYP GPDISABLECLIENTSTATEINDEXEDEXT)(GLenum array, GLuint index); +// typedef void (APIENTRYP GPDISABLECLIENTSTATEIEXT)(GLenum array, GLuint index); +// typedef void (APIENTRYP GPDISABLEINDEXEDEXT)(GLenum target, GLuint index); +// typedef void (APIENTRYP GPDISABLEVERTEXARRAYATTRIB)(GLuint vaobj, GLuint index); +// typedef void (APIENTRYP GPDISABLEVERTEXARRAYATTRIBEXT)(GLuint vaobj, GLuint index); +// typedef void (APIENTRYP GPDISABLEVERTEXARRAYEXT)(GLuint vaobj, GLenum array); +// typedef void (APIENTRYP GPDISABLEVERTEXATTRIBARRAY)(GLuint index); +// typedef void (APIENTRYP GPDISABLEI)(GLenum target, GLuint index); +// typedef void (APIENTRYP GPDISPATCHCOMPUTE)(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z); +// typedef void (APIENTRYP GPDISPATCHCOMPUTEGROUPSIZEARB)(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z, GLuint group_size_x, GLuint group_size_y, GLuint group_size_z); +// typedef void (APIENTRYP GPDISPATCHCOMPUTEINDIRECT)(GLintptr indirect); +// typedef void (APIENTRYP GPDRAWARRAYS)(GLenum mode, GLint first, GLsizei count); +// typedef void (APIENTRYP GPDRAWARRAYSINDIRECT)(GLenum mode, const void * indirect); +// typedef void (APIENTRYP GPDRAWARRAYSINSTANCED)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +// typedef void (APIENTRYP GPDRAWARRAYSINSTANCEDARB)(GLenum mode, GLint first, GLsizei count, GLsizei primcount); +// typedef void (APIENTRYP GPDRAWARRAYSINSTANCEDBASEINSTANCE)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance); +// typedef void (APIENTRYP GPDRAWARRAYSINSTANCEDEXT)(GLenum mode, GLint start, GLsizei count, GLsizei primcount); +// typedef void (APIENTRYP GPDRAWBUFFER)(GLenum buf); +// typedef void (APIENTRYP GPDRAWBUFFERS)(GLsizei n, const GLenum * bufs); +// typedef void (APIENTRYP GPDRAWCOMMANDSADDRESSNV)(GLenum primitiveMode, const GLuint64 * indirects, const GLsizei * sizes, GLuint count); +// typedef void (APIENTRYP GPDRAWCOMMANDSNV)(GLenum primitiveMode, GLuint buffer, const GLintptr * indirects, const GLsizei * sizes, GLuint count); +// typedef void (APIENTRYP GPDRAWCOMMANDSSTATESADDRESSNV)(const GLuint64 * indirects, const GLsizei * sizes, const GLuint * states, const GLuint * fbos, GLuint count); +// typedef void (APIENTRYP GPDRAWCOMMANDSSTATESNV)(GLuint buffer, const GLintptr * indirects, const GLsizei * sizes, const GLuint * states, const GLuint * fbos, GLuint count); +// typedef void (APIENTRYP GPDRAWELEMENTS)(GLenum mode, GLsizei count, GLenum type, const void * indices); +// typedef void (APIENTRYP GPDRAWELEMENTSBASEVERTEX)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLint basevertex); +// typedef void (APIENTRYP GPDRAWELEMENTSINDIRECT)(GLenum mode, GLenum type, const void * indirect); +// typedef void (APIENTRYP GPDRAWELEMENTSINSTANCED)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount); +// typedef void (APIENTRYP GPDRAWELEMENTSINSTANCEDARB)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei primcount); +// typedef void (APIENTRYP GPDRAWELEMENTSINSTANCEDBASEINSTANCE)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLuint baseinstance); +// typedef void (APIENTRYP GPDRAWELEMENTSINSTANCEDBASEVERTEX)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex); +// typedef void (APIENTRYP GPDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCE)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance); +// typedef void (APIENTRYP GPDRAWELEMENTSINSTANCEDEXT)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei primcount); +// typedef void (APIENTRYP GPDRAWMESHTASKSINDIRECTNV)(GLintptr indirect); +// typedef void (APIENTRYP GPDRAWMESHTASKSNV)(GLuint first, GLuint count); +// typedef void (APIENTRYP GPDRAWRANGEELEMENTS)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices); +// typedef void (APIENTRYP GPDRAWRANGEELEMENTSBASEVERTEX)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices, GLint basevertex); +// typedef void (APIENTRYP GPDRAWTRANSFORMFEEDBACK)(GLenum mode, GLuint id); +// typedef void (APIENTRYP GPDRAWTRANSFORMFEEDBACKINSTANCED)(GLenum mode, GLuint id, GLsizei instancecount); +// typedef void (APIENTRYP GPDRAWTRANSFORMFEEDBACKSTREAM)(GLenum mode, GLuint id, GLuint stream); +// typedef void (APIENTRYP GPDRAWTRANSFORMFEEDBACKSTREAMINSTANCED)(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount); +// typedef void (APIENTRYP GPDRAWVKIMAGENV)(GLuint64 vkImage, GLuint sampler, GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1, GLfloat z, GLfloat s0, GLfloat t0, GLfloat s1, GLfloat t1); +// typedef void (APIENTRYP GPEGLIMAGETARGETTEXSTORAGEEXT)(GLenum target, GLeglImageOES image, const GLint* attrib_list); +// typedef void (APIENTRYP GPEGLIMAGETARGETTEXTURESTORAGEEXT)(GLuint texture, GLeglImageOES image, const GLint* attrib_list); +// typedef void (APIENTRYP GPEDGEFLAGFORMATNV)(GLsizei stride); +// typedef void (APIENTRYP GPENABLE)(GLenum cap); +// typedef void (APIENTRYP GPENABLECLIENTSTATEINDEXEDEXT)(GLenum array, GLuint index); +// typedef void (APIENTRYP GPENABLECLIENTSTATEIEXT)(GLenum array, GLuint index); +// typedef void (APIENTRYP GPENABLEINDEXEDEXT)(GLenum target, GLuint index); +// typedef void (APIENTRYP GPENABLEVERTEXARRAYATTRIB)(GLuint vaobj, GLuint index); +// typedef void (APIENTRYP GPENABLEVERTEXARRAYATTRIBEXT)(GLuint vaobj, GLuint index); +// typedef void (APIENTRYP GPENABLEVERTEXARRAYEXT)(GLuint vaobj, GLenum array); +// typedef void (APIENTRYP GPENABLEVERTEXATTRIBARRAY)(GLuint index); +// typedef void (APIENTRYP GPENABLEI)(GLenum target, GLuint index); +// typedef void (APIENTRYP GPENDCONDITIONALRENDER)(); +// typedef void (APIENTRYP GPENDCONDITIONALRENDERNV)(); +// typedef void (APIENTRYP GPENDPERFMONITORAMD)(GLuint monitor); +// typedef void (APIENTRYP GPENDPERFQUERYINTEL)(GLuint queryHandle); +// typedef void (APIENTRYP GPENDQUERY)(GLenum target); +// typedef void (APIENTRYP GPENDQUERYINDEXED)(GLenum target, GLuint index); +// typedef void (APIENTRYP GPENDTRANSFORMFEEDBACK)(); +// typedef void (APIENTRYP GPEVALUATEDEPTHVALUESARB)(); +// typedef GLsync (APIENTRYP GPFENCESYNC)(GLenum condition, GLbitfield flags); +// typedef void (APIENTRYP GPFINISH)(); +// typedef void (APIENTRYP GPFLUSH)(); +// typedef void (APIENTRYP GPFLUSHMAPPEDBUFFERRANGE)(GLenum target, GLintptr offset, GLsizeiptr length); +// typedef void (APIENTRYP GPFLUSHMAPPEDNAMEDBUFFERRANGE)(GLuint buffer, GLintptr offset, GLsizeiptr length); +// typedef void (APIENTRYP GPFLUSHMAPPEDNAMEDBUFFERRANGEEXT)(GLuint buffer, GLintptr offset, GLsizeiptr length); +// typedef void (APIENTRYP GPFOGCOORDFORMATNV)(GLenum type, GLsizei stride); +// typedef void (APIENTRYP GPFRAGMENTCOVERAGECOLORNV)(GLuint color); +// typedef void (APIENTRYP GPFRAMEBUFFERDRAWBUFFEREXT)(GLuint framebuffer, GLenum mode); +// typedef void (APIENTRYP GPFRAMEBUFFERDRAWBUFFERSEXT)(GLuint framebuffer, GLsizei n, const GLenum * bufs); +// typedef void (APIENTRYP GPFRAMEBUFFERFETCHBARRIEREXT)(); +// typedef void (APIENTRYP GPFRAMEBUFFERPARAMETERI)(GLenum target, GLenum pname, GLint param); +// typedef void (APIENTRYP GPFRAMEBUFFERPARAMETERIMESA)(GLenum target, GLenum pname, GLint param); +// typedef void (APIENTRYP GPFRAMEBUFFERREADBUFFEREXT)(GLuint framebuffer, GLenum mode); +// typedef void (APIENTRYP GPFRAMEBUFFERRENDERBUFFER)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +// typedef void (APIENTRYP GPFRAMEBUFFERSAMPLELOCATIONSFVARB)(GLenum target, GLuint start, GLsizei count, const GLfloat * v); +// typedef void (APIENTRYP GPFRAMEBUFFERSAMPLELOCATIONSFVNV)(GLenum target, GLuint start, GLsizei count, const GLfloat * v); +// typedef void (APIENTRYP GPFRAMEBUFFERTEXTURE)(GLenum target, GLenum attachment, GLuint texture, GLint level); +// typedef void (APIENTRYP GPFRAMEBUFFERTEXTURE1D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +// typedef void (APIENTRYP GPFRAMEBUFFERTEXTURE2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +// typedef void (APIENTRYP GPFRAMEBUFFERTEXTURE3D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +// typedef void (APIENTRYP GPFRAMEBUFFERTEXTUREARB)(GLenum target, GLenum attachment, GLuint texture, GLint level); +// typedef void (APIENTRYP GPFRAMEBUFFERTEXTUREFACEARB)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face); +// typedef void (APIENTRYP GPFRAMEBUFFERTEXTURELAYER)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +// typedef void (APIENTRYP GPFRAMEBUFFERTEXTURELAYERARB)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +// typedef void (APIENTRYP GPFRAMEBUFFERTEXTUREMULTIVIEWOVR)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews); +// typedef void (APIENTRYP GPFRONTFACE)(GLenum mode); +// typedef void (APIENTRYP GPGENBUFFERS)(GLsizei n, GLuint * buffers); +// typedef void (APIENTRYP GPGENFRAMEBUFFERS)(GLsizei n, GLuint * framebuffers); +// typedef GLuint (APIENTRYP GPGENPATHSNV)(GLsizei range); +// typedef void (APIENTRYP GPGENPERFMONITORSAMD)(GLsizei n, GLuint * monitors); +// typedef void (APIENTRYP GPGENPROGRAMPIPELINES)(GLsizei n, GLuint * pipelines); +// typedef void (APIENTRYP GPGENPROGRAMPIPELINESEXT)(GLsizei n, GLuint * pipelines); +// typedef void (APIENTRYP GPGENQUERIES)(GLsizei n, GLuint * ids); +// typedef void (APIENTRYP GPGENRENDERBUFFERS)(GLsizei n, GLuint * renderbuffers); +// typedef void (APIENTRYP GPGENSAMPLERS)(GLsizei count, GLuint * samplers); +// typedef void (APIENTRYP GPGENTEXTURES)(GLsizei n, GLuint * textures); +// typedef void (APIENTRYP GPGENTRANSFORMFEEDBACKS)(GLsizei n, GLuint * ids); +// typedef void (APIENTRYP GPGENVERTEXARRAYS)(GLsizei n, GLuint * arrays); +// typedef void (APIENTRYP GPGENERATEMIPMAP)(GLenum target); +// typedef void (APIENTRYP GPGENERATEMULTITEXMIPMAPEXT)(GLenum texunit, GLenum target); +// typedef void (APIENTRYP GPGENERATETEXTUREMIPMAP)(GLuint texture); +// typedef void (APIENTRYP GPGENERATETEXTUREMIPMAPEXT)(GLuint texture, GLenum target); +// typedef void (APIENTRYP GPGETACTIVEATOMICCOUNTERBUFFERIV)(GLuint program, GLuint bufferIndex, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETACTIVEATTRIB)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name); +// typedef void (APIENTRYP GPGETACTIVESUBROUTINENAME)(GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei * length, GLchar * name); +// typedef void (APIENTRYP GPGETACTIVESUBROUTINEUNIFORMNAME)(GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei * length, GLchar * name); +// typedef void (APIENTRYP GPGETACTIVESUBROUTINEUNIFORMIV)(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint * values); +// typedef void (APIENTRYP GPGETACTIVEUNIFORM)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name); +// typedef void (APIENTRYP GPGETACTIVEUNIFORMBLOCKNAME)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformBlockName); +// typedef void (APIENTRYP GPGETACTIVEUNIFORMBLOCKIV)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETACTIVEUNIFORMNAME)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformName); +// typedef void (APIENTRYP GPGETACTIVEUNIFORMSIV)(GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETATTACHEDSHADERS)(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders); +// typedef GLint (APIENTRYP GPGETATTRIBLOCATION)(GLuint program, const GLchar * name); +// typedef void (APIENTRYP GPGETBOOLEANINDEXEDVEXT)(GLenum target, GLuint index, GLboolean * data); +// typedef void (APIENTRYP GPGETBOOLEANI_V)(GLenum target, GLuint index, GLboolean * data); +// typedef void (APIENTRYP GPGETBOOLEANV)(GLenum pname, GLboolean * data); +// typedef void (APIENTRYP GPGETBUFFERPARAMETERI64V)(GLenum target, GLenum pname, GLint64 * params); +// typedef void (APIENTRYP GPGETBUFFERPARAMETERIV)(GLenum target, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETBUFFERPARAMETERUI64VNV)(GLenum target, GLenum pname, GLuint64EXT * params); +// typedef void (APIENTRYP GPGETBUFFERPOINTERV)(GLenum target, GLenum pname, void ** params); +// typedef void (APIENTRYP GPGETBUFFERSUBDATA)(GLenum target, GLintptr offset, GLsizeiptr size, void * data); +// typedef GLuint (APIENTRYP GPGETCOMMANDHEADERNV)(GLenum tokenID, GLuint size); +// typedef void (APIENTRYP GPGETCOMPRESSEDMULTITEXIMAGEEXT)(GLenum texunit, GLenum target, GLint lod, void * img); +// typedef void (APIENTRYP GPGETCOMPRESSEDTEXIMAGE)(GLenum target, GLint level, void * img); +// typedef void (APIENTRYP GPGETCOMPRESSEDTEXTUREIMAGE)(GLuint texture, GLint level, GLsizei bufSize, void * pixels); +// typedef void (APIENTRYP GPGETCOMPRESSEDTEXTUREIMAGEEXT)(GLuint texture, GLenum target, GLint lod, void * img); +// typedef void (APIENTRYP GPGETCOMPRESSEDTEXTURESUBIMAGE)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void * pixels); +// typedef void (APIENTRYP GPGETCOVERAGEMODULATIONTABLENV)(GLsizei bufSize, GLfloat * v); +// typedef GLuint (APIENTRYP GPGETDEBUGMESSAGELOG)(GLuint count, GLsizei bufSize, GLenum * sources, GLenum * types, GLuint * ids, GLenum * severities, GLsizei * lengths, GLchar * messageLog); +// typedef GLuint (APIENTRYP GPGETDEBUGMESSAGELOGARB)(GLuint count, GLsizei bufSize, GLenum * sources, GLenum * types, GLuint * ids, GLenum * severities, GLsizei * lengths, GLchar * messageLog); +// typedef GLuint (APIENTRYP GPGETDEBUGMESSAGELOGKHR)(GLuint count, GLsizei bufSize, GLenum * sources, GLenum * types, GLuint * ids, GLenum * severities, GLsizei * lengths, GLchar * messageLog); +// typedef void (APIENTRYP GPGETDOUBLEINDEXEDVEXT)(GLenum target, GLuint index, GLdouble * data); +// typedef void (APIENTRYP GPGETDOUBLEI_V)(GLenum target, GLuint index, GLdouble * data); +// typedef void (APIENTRYP GPGETDOUBLEI_VEXT)(GLenum pname, GLuint index, GLdouble * params); +// typedef void (APIENTRYP GPGETDOUBLEV)(GLenum pname, GLdouble * data); +// typedef GLenum (APIENTRYP GPGETERROR)(); +// typedef void (APIENTRYP GPGETFIRSTPERFQUERYIDINTEL)(GLuint * queryId); +// typedef void (APIENTRYP GPGETFLOATINDEXEDVEXT)(GLenum target, GLuint index, GLfloat * data); +// typedef void (APIENTRYP GPGETFLOATI_V)(GLenum target, GLuint index, GLfloat * data); +// typedef void (APIENTRYP GPGETFLOATI_VEXT)(GLenum pname, GLuint index, GLfloat * params); +// typedef void (APIENTRYP GPGETFLOATV)(GLenum pname, GLfloat * data); +// typedef GLint (APIENTRYP GPGETFRAGDATAINDEX)(GLuint program, const GLchar * name); +// typedef GLint (APIENTRYP GPGETFRAGDATALOCATION)(GLuint program, const GLchar * name); +// typedef void (APIENTRYP GPGETFRAMEBUFFERATTACHMENTPARAMETERIV)(GLenum target, GLenum attachment, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETFRAMEBUFFERPARAMETERIV)(GLenum target, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETFRAMEBUFFERPARAMETERIVEXT)(GLuint framebuffer, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETFRAMEBUFFERPARAMETERIVMESA)(GLenum target, GLenum pname, GLint * params); +// typedef GLenum (APIENTRYP GPGETGRAPHICSRESETSTATUS)(); +// typedef GLenum (APIENTRYP GPGETGRAPHICSRESETSTATUSARB)(); +// typedef GLenum (APIENTRYP GPGETGRAPHICSRESETSTATUSKHR)(); +// typedef GLuint64 (APIENTRYP GPGETIMAGEHANDLEARB)(GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format); +// typedef GLuint64 (APIENTRYP GPGETIMAGEHANDLENV)(GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format); +// typedef void (APIENTRYP GPGETINTEGER64I_V)(GLenum target, GLuint index, GLint64 * data); +// typedef void (APIENTRYP GPGETINTEGER64V)(GLenum pname, GLint64 * data); +// typedef void (APIENTRYP GPGETINTEGERINDEXEDVEXT)(GLenum target, GLuint index, GLint * data); +// typedef void (APIENTRYP GPGETINTEGERI_V)(GLenum target, GLuint index, GLint * data); +// typedef void (APIENTRYP GPGETINTEGERUI64I_VNV)(GLenum value, GLuint index, GLuint64EXT * result); +// typedef void (APIENTRYP GPGETINTEGERUI64VNV)(GLenum value, GLuint64EXT * result); +// typedef void (APIENTRYP GPGETINTEGERV)(GLenum pname, GLint * data); +// typedef void (APIENTRYP GPGETINTERNALFORMATSAMPLEIVNV)(GLenum target, GLenum internalformat, GLsizei samples, GLenum pname, GLsizei count, GLint * params); +// typedef void (APIENTRYP GPGETINTERNALFORMATI64V)(GLenum target, GLenum internalformat, GLenum pname, GLsizei count, GLint64 * params); +// typedef void (APIENTRYP GPGETINTERNALFORMATIV)(GLenum target, GLenum internalformat, GLenum pname, GLsizei count, GLint * params); +// typedef void (APIENTRYP GPGETMEMORYOBJECTDETACHEDRESOURCESUIVNV)(GLuint memory, GLenum pname, GLint first, GLsizei count, GLuint * params); +// typedef void (APIENTRYP GPGETMULTITEXENVFVEXT)(GLenum texunit, GLenum target, GLenum pname, GLfloat * params); +// typedef void (APIENTRYP GPGETMULTITEXENVIVEXT)(GLenum texunit, GLenum target, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETMULTITEXGENDVEXT)(GLenum texunit, GLenum coord, GLenum pname, GLdouble * params); +// typedef void (APIENTRYP GPGETMULTITEXGENFVEXT)(GLenum texunit, GLenum coord, GLenum pname, GLfloat * params); +// typedef void (APIENTRYP GPGETMULTITEXGENIVEXT)(GLenum texunit, GLenum coord, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETMULTITEXIMAGEEXT)(GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void * pixels); +// typedef void (APIENTRYP GPGETMULTITEXLEVELPARAMETERFVEXT)(GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat * params); +// typedef void (APIENTRYP GPGETMULTITEXLEVELPARAMETERIVEXT)(GLenum texunit, GLenum target, GLint level, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETMULTITEXPARAMETERIIVEXT)(GLenum texunit, GLenum target, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETMULTITEXPARAMETERIUIVEXT)(GLenum texunit, GLenum target, GLenum pname, GLuint * params); +// typedef void (APIENTRYP GPGETMULTITEXPARAMETERFVEXT)(GLenum texunit, GLenum target, GLenum pname, GLfloat * params); +// typedef void (APIENTRYP GPGETMULTITEXPARAMETERIVEXT)(GLenum texunit, GLenum target, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETMULTISAMPLEFV)(GLenum pname, GLuint index, GLfloat * val); +// typedef void (APIENTRYP GPGETNAMEDBUFFERPARAMETERI64V)(GLuint buffer, GLenum pname, GLint64 * params); +// typedef void (APIENTRYP GPGETNAMEDBUFFERPARAMETERIV)(GLuint buffer, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETNAMEDBUFFERPARAMETERIVEXT)(GLuint buffer, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETNAMEDBUFFERPARAMETERUI64VNV)(GLuint buffer, GLenum pname, GLuint64EXT * params); +// typedef void (APIENTRYP GPGETNAMEDBUFFERPOINTERV)(GLuint buffer, GLenum pname, void ** params); +// typedef void (APIENTRYP GPGETNAMEDBUFFERPOINTERVEXT)(GLuint buffer, GLenum pname, void ** params); +// typedef void (APIENTRYP GPGETNAMEDBUFFERSUBDATA)(GLuint buffer, GLintptr offset, GLsizeiptr size, void * data); +// typedef void (APIENTRYP GPGETNAMEDBUFFERSUBDATAEXT)(GLuint buffer, GLintptr offset, GLsizeiptr size, void * data); +// typedef void (APIENTRYP GPGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIV)(GLuint framebuffer, GLenum attachment, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXT)(GLuint framebuffer, GLenum attachment, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETNAMEDFRAMEBUFFERPARAMETERIV)(GLuint framebuffer, GLenum pname, GLint * param); +// typedef void (APIENTRYP GPGETNAMEDFRAMEBUFFERPARAMETERIVEXT)(GLuint framebuffer, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETNAMEDPROGRAMLOCALPARAMETERIIVEXT)(GLuint program, GLenum target, GLuint index, GLint * params); +// typedef void (APIENTRYP GPGETNAMEDPROGRAMLOCALPARAMETERIUIVEXT)(GLuint program, GLenum target, GLuint index, GLuint * params); +// typedef void (APIENTRYP GPGETNAMEDPROGRAMLOCALPARAMETERDVEXT)(GLuint program, GLenum target, GLuint index, GLdouble * params); +// typedef void (APIENTRYP GPGETNAMEDPROGRAMLOCALPARAMETERFVEXT)(GLuint program, GLenum target, GLuint index, GLfloat * params); +// typedef void (APIENTRYP GPGETNAMEDPROGRAMSTRINGEXT)(GLuint program, GLenum target, GLenum pname, void * string); +// typedef void (APIENTRYP GPGETNAMEDPROGRAMIVEXT)(GLuint program, GLenum target, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETNAMEDRENDERBUFFERPARAMETERIV)(GLuint renderbuffer, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETNAMEDRENDERBUFFERPARAMETERIVEXT)(GLuint renderbuffer, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETNAMEDSTRINGARB)(GLint namelen, const GLchar * name, GLsizei bufSize, GLint * stringlen, GLchar * string); +// typedef void (APIENTRYP GPGETNAMEDSTRINGIVARB)(GLint namelen, const GLchar * name, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETNEXTPERFQUERYIDINTEL)(GLuint queryId, GLuint * nextQueryId); +// typedef void (APIENTRYP GPGETOBJECTLABEL)(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei * length, GLchar * label); +// typedef void (APIENTRYP GPGETOBJECTLABELEXT)(GLenum type, GLuint object, GLsizei bufSize, GLsizei * length, GLchar * label); +// typedef void (APIENTRYP GPGETOBJECTLABELKHR)(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei * length, GLchar * label); +// typedef void (APIENTRYP GPGETOBJECTPTRLABEL)(const void * ptr, GLsizei bufSize, GLsizei * length, GLchar * label); +// typedef void (APIENTRYP GPGETOBJECTPTRLABELKHR)(const void * ptr, GLsizei bufSize, GLsizei * length, GLchar * label); +// typedef void (APIENTRYP GPGETPATHCOMMANDSNV)(GLuint path, GLubyte * commands); +// typedef void (APIENTRYP GPGETPATHCOORDSNV)(GLuint path, GLfloat * coords); +// typedef void (APIENTRYP GPGETPATHDASHARRAYNV)(GLuint path, GLfloat * dashArray); +// typedef GLfloat (APIENTRYP GPGETPATHLENGTHNV)(GLuint path, GLsizei startSegment, GLsizei numSegments); +// typedef void (APIENTRYP GPGETPATHMETRICRANGENV)(GLbitfield metricQueryMask, GLuint firstPathName, GLsizei numPaths, GLsizei stride, GLfloat * metrics); +// typedef void (APIENTRYP GPGETPATHMETRICSNV)(GLbitfield metricQueryMask, GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLsizei stride, GLfloat * metrics); +// typedef void (APIENTRYP GPGETPATHPARAMETERFVNV)(GLuint path, GLenum pname, GLfloat * value); +// typedef void (APIENTRYP GPGETPATHPARAMETERIVNV)(GLuint path, GLenum pname, GLint * value); +// typedef void (APIENTRYP GPGETPATHSPACINGNV)(GLenum pathListMode, GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, GLenum transformType, GLfloat * returnedSpacing); +// typedef void (APIENTRYP GPGETPERFCOUNTERINFOINTEL)(GLuint queryId, GLuint counterId, GLuint counterNameLength, GLchar * counterName, GLuint counterDescLength, GLchar * counterDesc, GLuint * counterOffset, GLuint * counterDataSize, GLuint * counterTypeEnum, GLuint * counterDataTypeEnum, GLuint64 * rawCounterMaxValue); +// typedef void (APIENTRYP GPGETPERFMONITORCOUNTERDATAAMD)(GLuint monitor, GLenum pname, GLsizei dataSize, GLuint * data, GLint * bytesWritten); +// typedef void (APIENTRYP GPGETPERFMONITORCOUNTERINFOAMD)(GLuint group, GLuint counter, GLenum pname, void * data); +// typedef void (APIENTRYP GPGETPERFMONITORCOUNTERSTRINGAMD)(GLuint group, GLuint counter, GLsizei bufSize, GLsizei * length, GLchar * counterString); +// typedef void (APIENTRYP GPGETPERFMONITORCOUNTERSAMD)(GLuint group, GLint * numCounters, GLint * maxActiveCounters, GLsizei counterSize, GLuint * counters); +// typedef void (APIENTRYP GPGETPERFMONITORGROUPSTRINGAMD)(GLuint group, GLsizei bufSize, GLsizei * length, GLchar * groupString); +// typedef void (APIENTRYP GPGETPERFMONITORGROUPSAMD)(GLint * numGroups, GLsizei groupsSize, GLuint * groups); +// typedef void (APIENTRYP GPGETPERFQUERYDATAINTEL)(GLuint queryHandle, GLuint flags, GLsizei dataSize, void * data, GLuint * bytesWritten); +// typedef void (APIENTRYP GPGETPERFQUERYIDBYNAMEINTEL)(GLchar * queryName, GLuint * queryId); +// typedef void (APIENTRYP GPGETPERFQUERYINFOINTEL)(GLuint queryId, GLuint queryNameLength, GLchar * queryName, GLuint * dataSize, GLuint * noCounters, GLuint * noInstances, GLuint * capsMask); +// typedef void (APIENTRYP GPGETPOINTERINDEXEDVEXT)(GLenum target, GLuint index, void ** data); +// typedef void (APIENTRYP GPGETPOINTERI_VEXT)(GLenum pname, GLuint index, void ** params); +// typedef void (APIENTRYP GPGETPOINTERV)(GLenum pname, void ** params); +// typedef void (APIENTRYP GPGETPOINTERVKHR)(GLenum pname, void ** params); +// typedef void (APIENTRYP GPGETPROGRAMBINARY)(GLuint program, GLsizei bufSize, GLsizei * length, GLenum * binaryFormat, void * binary); +// typedef void (APIENTRYP GPGETPROGRAMINFOLOG)(GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog); +// typedef void (APIENTRYP GPGETPROGRAMINTERFACEIV)(GLuint program, GLenum programInterface, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETPROGRAMPIPELINEINFOLOG)(GLuint pipeline, GLsizei bufSize, GLsizei * length, GLchar * infoLog); +// typedef void (APIENTRYP GPGETPROGRAMPIPELINEINFOLOGEXT)(GLuint pipeline, GLsizei bufSize, GLsizei * length, GLchar * infoLog); +// typedef void (APIENTRYP GPGETPROGRAMPIPELINEIV)(GLuint pipeline, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETPROGRAMPIPELINEIVEXT)(GLuint pipeline, GLenum pname, GLint * params); +// typedef GLuint (APIENTRYP GPGETPROGRAMRESOURCEINDEX)(GLuint program, GLenum programInterface, const GLchar * name); +// typedef GLint (APIENTRYP GPGETPROGRAMRESOURCELOCATION)(GLuint program, GLenum programInterface, const GLchar * name); +// typedef GLint (APIENTRYP GPGETPROGRAMRESOURCELOCATIONINDEX)(GLuint program, GLenum programInterface, const GLchar * name); +// typedef void (APIENTRYP GPGETPROGRAMRESOURCENAME)(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei * length, GLchar * name); +// typedef void (APIENTRYP GPGETPROGRAMRESOURCEFVNV)(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum * props, GLsizei count, GLsizei * length, GLfloat * params); +// typedef void (APIENTRYP GPGETPROGRAMRESOURCEIV)(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum * props, GLsizei count, GLsizei * length, GLint * params); +// typedef void (APIENTRYP GPGETPROGRAMSTAGEIV)(GLuint program, GLenum shadertype, GLenum pname, GLint * values); +// typedef void (APIENTRYP GPGETPROGRAMIV)(GLuint program, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETQUERYBUFFEROBJECTI64V)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset); +// typedef void (APIENTRYP GPGETQUERYBUFFEROBJECTIV)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset); +// typedef void (APIENTRYP GPGETQUERYBUFFEROBJECTUI64V)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset); +// typedef void (APIENTRYP GPGETQUERYBUFFEROBJECTUIV)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset); +// typedef void (APIENTRYP GPGETQUERYINDEXEDIV)(GLenum target, GLuint index, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETQUERYOBJECTI64V)(GLuint id, GLenum pname, GLint64 * params); +// typedef void (APIENTRYP GPGETQUERYOBJECTIV)(GLuint id, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETQUERYOBJECTUI64V)(GLuint id, GLenum pname, GLuint64 * params); +// typedef void (APIENTRYP GPGETQUERYOBJECTUIV)(GLuint id, GLenum pname, GLuint * params); +// typedef void (APIENTRYP GPGETQUERYIV)(GLenum target, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETRENDERBUFFERPARAMETERIV)(GLenum target, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETSAMPLERPARAMETERIIV)(GLuint sampler, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETSAMPLERPARAMETERIUIV)(GLuint sampler, GLenum pname, GLuint * params); +// typedef void (APIENTRYP GPGETSAMPLERPARAMETERFV)(GLuint sampler, GLenum pname, GLfloat * params); +// typedef void (APIENTRYP GPGETSAMPLERPARAMETERIV)(GLuint sampler, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETSHADERINFOLOG)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog); +// typedef void (APIENTRYP GPGETSHADERPRECISIONFORMAT)(GLenum shadertype, GLenum precisiontype, GLint * range, GLint * precision); +// typedef void (APIENTRYP GPGETSHADERSOURCE)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source); +// typedef void (APIENTRYP GPGETSHADERIV)(GLuint shader, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETSHADINGRATEIMAGEPALETTENV)(GLuint viewport, GLuint entry, GLenum * rate); +// typedef void (APIENTRYP GPGETSHADINGRATESAMPLELOCATIONIVNV)(GLenum rate, GLuint samples, GLuint index, GLint * location); +// typedef GLushort (APIENTRYP GPGETSTAGEINDEXNV)(GLenum shadertype); +// typedef const GLubyte * (APIENTRYP GPGETSTRING)(GLenum name); +// typedef const GLubyte * (APIENTRYP GPGETSTRINGI)(GLenum name, GLuint index); +// typedef GLuint (APIENTRYP GPGETSUBROUTINEINDEX)(GLuint program, GLenum shadertype, const GLchar * name); +// typedef GLint (APIENTRYP GPGETSUBROUTINEUNIFORMLOCATION)(GLuint program, GLenum shadertype, const GLchar * name); +// typedef void (APIENTRYP GPGETSYNCIV)(GLsync sync, GLenum pname, GLsizei count, GLsizei * length, GLint * values); +// typedef void (APIENTRYP GPGETTEXIMAGE)(GLenum target, GLint level, GLenum format, GLenum type, void * pixels); +// typedef void (APIENTRYP GPGETTEXLEVELPARAMETERFV)(GLenum target, GLint level, GLenum pname, GLfloat * params); +// typedef void (APIENTRYP GPGETTEXLEVELPARAMETERIV)(GLenum target, GLint level, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETTEXPARAMETERIIV)(GLenum target, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETTEXPARAMETERIUIV)(GLenum target, GLenum pname, GLuint * params); +// typedef void (APIENTRYP GPGETTEXPARAMETERFV)(GLenum target, GLenum pname, GLfloat * params); +// typedef void (APIENTRYP GPGETTEXPARAMETERIV)(GLenum target, GLenum pname, GLint * params); +// typedef GLuint64 (APIENTRYP GPGETTEXTUREHANDLEARB)(GLuint texture); +// typedef GLuint64 (APIENTRYP GPGETTEXTUREHANDLENV)(GLuint texture); +// typedef void (APIENTRYP GPGETTEXTUREIMAGE)(GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void * pixels); +// typedef void (APIENTRYP GPGETTEXTUREIMAGEEXT)(GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void * pixels); +// typedef void (APIENTRYP GPGETTEXTURELEVELPARAMETERFV)(GLuint texture, GLint level, GLenum pname, GLfloat * params); +// typedef void (APIENTRYP GPGETTEXTURELEVELPARAMETERFVEXT)(GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat * params); +// typedef void (APIENTRYP GPGETTEXTURELEVELPARAMETERIV)(GLuint texture, GLint level, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETTEXTURELEVELPARAMETERIVEXT)(GLuint texture, GLenum target, GLint level, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETTEXTUREPARAMETERIIV)(GLuint texture, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETTEXTUREPARAMETERIIVEXT)(GLuint texture, GLenum target, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETTEXTUREPARAMETERIUIV)(GLuint texture, GLenum pname, GLuint * params); +// typedef void (APIENTRYP GPGETTEXTUREPARAMETERIUIVEXT)(GLuint texture, GLenum target, GLenum pname, GLuint * params); +// typedef void (APIENTRYP GPGETTEXTUREPARAMETERFV)(GLuint texture, GLenum pname, GLfloat * params); +// typedef void (APIENTRYP GPGETTEXTUREPARAMETERFVEXT)(GLuint texture, GLenum target, GLenum pname, GLfloat * params); +// typedef void (APIENTRYP GPGETTEXTUREPARAMETERIV)(GLuint texture, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETTEXTUREPARAMETERIVEXT)(GLuint texture, GLenum target, GLenum pname, GLint * params); +// typedef GLuint64 (APIENTRYP GPGETTEXTURESAMPLERHANDLEARB)(GLuint texture, GLuint sampler); +// typedef GLuint64 (APIENTRYP GPGETTEXTURESAMPLERHANDLENV)(GLuint texture, GLuint sampler); +// typedef void (APIENTRYP GPGETTEXTURESUBIMAGE)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void * pixels); +// typedef void (APIENTRYP GPGETTRANSFORMFEEDBACKVARYING)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name); +// typedef void (APIENTRYP GPGETTRANSFORMFEEDBACKI64_V)(GLuint xfb, GLenum pname, GLuint index, GLint64 * param); +// typedef void (APIENTRYP GPGETTRANSFORMFEEDBACKI_V)(GLuint xfb, GLenum pname, GLuint index, GLint * param); +// typedef void (APIENTRYP GPGETTRANSFORMFEEDBACKIV)(GLuint xfb, GLenum pname, GLint * param); +// typedef GLuint (APIENTRYP GPGETUNIFORMBLOCKINDEX)(GLuint program, const GLchar * uniformBlockName); +// typedef void (APIENTRYP GPGETUNIFORMINDICES)(GLuint program, GLsizei uniformCount, const GLchar *const* uniformNames, GLuint * uniformIndices); +// typedef GLint (APIENTRYP GPGETUNIFORMLOCATION)(GLuint program, const GLchar * name); +// typedef void (APIENTRYP GPGETUNIFORMSUBROUTINEUIV)(GLenum shadertype, GLint location, GLuint * params); +// typedef void (APIENTRYP GPGETUNIFORMDV)(GLuint program, GLint location, GLdouble * params); +// typedef void (APIENTRYP GPGETUNIFORMFV)(GLuint program, GLint location, GLfloat * params); +// typedef void (APIENTRYP GPGETUNIFORMI64VARB)(GLuint program, GLint location, GLint64 * params); +// typedef void (APIENTRYP GPGETUNIFORMI64VNV)(GLuint program, GLint location, GLint64EXT * params); +// typedef void (APIENTRYP GPGETUNIFORMIV)(GLuint program, GLint location, GLint * params); +// typedef void (APIENTRYP GPGETUNIFORMUI64VARB)(GLuint program, GLint location, GLuint64 * params); +// typedef void (APIENTRYP GPGETUNIFORMUI64VNV)(GLuint program, GLint location, GLuint64EXT * params); +// typedef void (APIENTRYP GPGETUNIFORMUIV)(GLuint program, GLint location, GLuint * params); +// typedef void (APIENTRYP GPGETVERTEXARRAYINDEXED64IV)(GLuint vaobj, GLuint index, GLenum pname, GLint64 * param); +// typedef void (APIENTRYP GPGETVERTEXARRAYINDEXEDIV)(GLuint vaobj, GLuint index, GLenum pname, GLint * param); +// typedef void (APIENTRYP GPGETVERTEXARRAYINTEGERI_VEXT)(GLuint vaobj, GLuint index, GLenum pname, GLint * param); +// typedef void (APIENTRYP GPGETVERTEXARRAYINTEGERVEXT)(GLuint vaobj, GLenum pname, GLint * param); +// typedef void (APIENTRYP GPGETVERTEXARRAYPOINTERI_VEXT)(GLuint vaobj, GLuint index, GLenum pname, void ** param); +// typedef void (APIENTRYP GPGETVERTEXARRAYPOINTERVEXT)(GLuint vaobj, GLenum pname, void ** param); +// typedef void (APIENTRYP GPGETVERTEXARRAYIV)(GLuint vaobj, GLenum pname, GLint * param); +// typedef void (APIENTRYP GPGETVERTEXATTRIBIIV)(GLuint index, GLenum pname, GLint * params); +// typedef void (APIENTRYP GPGETVERTEXATTRIBIUIV)(GLuint index, GLenum pname, GLuint * params); +// typedef void (APIENTRYP GPGETVERTEXATTRIBLDV)(GLuint index, GLenum pname, GLdouble * params); +// typedef void (APIENTRYP GPGETVERTEXATTRIBLI64VNV)(GLuint index, GLenum pname, GLint64EXT * params); +// typedef void (APIENTRYP GPGETVERTEXATTRIBLUI64VARB)(GLuint index, GLenum pname, GLuint64EXT * params); +// typedef void (APIENTRYP GPGETVERTEXATTRIBLUI64VNV)(GLuint index, GLenum pname, GLuint64EXT * params); +// typedef void (APIENTRYP GPGETVERTEXATTRIBPOINTERV)(GLuint index, GLenum pname, void ** pointer); +// typedef void (APIENTRYP GPGETVERTEXATTRIBDV)(GLuint index, GLenum pname, GLdouble * params); +// typedef void (APIENTRYP GPGETVERTEXATTRIBFV)(GLuint index, GLenum pname, GLfloat * params); +// typedef void (APIENTRYP GPGETVERTEXATTRIBIV)(GLuint index, GLenum pname, GLint * params); +// typedef GLVULKANPROCNV (APIENTRYP GPGETVKPROCADDRNV)(const GLchar * name); +// typedef void (APIENTRYP GPGETNCOMPRESSEDTEXIMAGEARB)(GLenum target, GLint lod, GLsizei bufSize, void * img); +// typedef void (APIENTRYP GPGETNTEXIMAGEARB)(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void * img); +// typedef void (APIENTRYP GPGETNUNIFORMDVARB)(GLuint program, GLint location, GLsizei bufSize, GLdouble * params); +// typedef void (APIENTRYP GPGETNUNIFORMFV)(GLuint program, GLint location, GLsizei bufSize, GLfloat * params); +// typedef void (APIENTRYP GPGETNUNIFORMFVARB)(GLuint program, GLint location, GLsizei bufSize, GLfloat * params); +// typedef void (APIENTRYP GPGETNUNIFORMFVKHR)(GLuint program, GLint location, GLsizei bufSize, GLfloat * params); +// typedef void (APIENTRYP GPGETNUNIFORMI64VARB)(GLuint program, GLint location, GLsizei bufSize, GLint64 * params); +// typedef void (APIENTRYP GPGETNUNIFORMIV)(GLuint program, GLint location, GLsizei bufSize, GLint * params); +// typedef void (APIENTRYP GPGETNUNIFORMIVARB)(GLuint program, GLint location, GLsizei bufSize, GLint * params); +// typedef void (APIENTRYP GPGETNUNIFORMIVKHR)(GLuint program, GLint location, GLsizei bufSize, GLint * params); +// typedef void (APIENTRYP GPGETNUNIFORMUI64VARB)(GLuint program, GLint location, GLsizei bufSize, GLuint64 * params); +// typedef void (APIENTRYP GPGETNUNIFORMUIV)(GLuint program, GLint location, GLsizei bufSize, GLuint * params); +// typedef void (APIENTRYP GPGETNUNIFORMUIVARB)(GLuint program, GLint location, GLsizei bufSize, GLuint * params); +// typedef void (APIENTRYP GPGETNUNIFORMUIVKHR)(GLuint program, GLint location, GLsizei bufSize, GLuint * params); +// typedef void (APIENTRYP GPHINT)(GLenum target, GLenum mode); +// typedef void (APIENTRYP GPINDEXFORMATNV)(GLenum type, GLsizei stride); +// typedef void (APIENTRYP GPINSERTEVENTMARKEREXT)(GLsizei length, const GLchar * marker); +// typedef void (APIENTRYP GPINTERPOLATEPATHSNV)(GLuint resultPath, GLuint pathA, GLuint pathB, GLfloat weight); +// typedef void (APIENTRYP GPINVALIDATEBUFFERDATA)(GLuint buffer); +// typedef void (APIENTRYP GPINVALIDATEBUFFERSUBDATA)(GLuint buffer, GLintptr offset, GLsizeiptr length); +// typedef void (APIENTRYP GPINVALIDATEFRAMEBUFFER)(GLenum target, GLsizei numAttachments, const GLenum * attachments); +// typedef void (APIENTRYP GPINVALIDATENAMEDFRAMEBUFFERDATA)(GLuint framebuffer, GLsizei numAttachments, const GLenum * attachments); +// typedef void (APIENTRYP GPINVALIDATENAMEDFRAMEBUFFERSUBDATA)(GLuint framebuffer, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPINVALIDATESUBFRAMEBUFFER)(GLenum target, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPINVALIDATETEXIMAGE)(GLuint texture, GLint level); +// typedef void (APIENTRYP GPINVALIDATETEXSUBIMAGE)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth); +// typedef GLboolean (APIENTRYP GPISBUFFER)(GLuint buffer); +// typedef GLboolean (APIENTRYP GPISBUFFERRESIDENTNV)(GLenum target); +// typedef GLboolean (APIENTRYP GPISCOMMANDLISTNV)(GLuint list); +// typedef GLboolean (APIENTRYP GPISENABLED)(GLenum cap); +// typedef GLboolean (APIENTRYP GPISENABLEDINDEXEDEXT)(GLenum target, GLuint index); +// typedef GLboolean (APIENTRYP GPISENABLEDI)(GLenum target, GLuint index); +// typedef GLboolean (APIENTRYP GPISFRAMEBUFFER)(GLuint framebuffer); +// typedef GLboolean (APIENTRYP GPISIMAGEHANDLERESIDENTARB)(GLuint64 handle); +// typedef GLboolean (APIENTRYP GPISIMAGEHANDLERESIDENTNV)(GLuint64 handle); +// typedef GLboolean (APIENTRYP GPISNAMEDBUFFERRESIDENTNV)(GLuint buffer); +// typedef GLboolean (APIENTRYP GPISNAMEDSTRINGARB)(GLint namelen, const GLchar * name); +// typedef GLboolean (APIENTRYP GPISPATHNV)(GLuint path); +// typedef GLboolean (APIENTRYP GPISPOINTINFILLPATHNV)(GLuint path, GLuint mask, GLfloat x, GLfloat y); +// typedef GLboolean (APIENTRYP GPISPOINTINSTROKEPATHNV)(GLuint path, GLfloat x, GLfloat y); +// typedef GLboolean (APIENTRYP GPISPROGRAM)(GLuint program); +// typedef GLboolean (APIENTRYP GPISPROGRAMPIPELINE)(GLuint pipeline); +// typedef GLboolean (APIENTRYP GPISPROGRAMPIPELINEEXT)(GLuint pipeline); +// typedef GLboolean (APIENTRYP GPISQUERY)(GLuint id); +// typedef GLboolean (APIENTRYP GPISRENDERBUFFER)(GLuint renderbuffer); +// typedef GLboolean (APIENTRYP GPISSAMPLER)(GLuint sampler); +// typedef GLboolean (APIENTRYP GPISSHADER)(GLuint shader); +// typedef GLboolean (APIENTRYP GPISSTATENV)(GLuint state); +// typedef GLboolean (APIENTRYP GPISSYNC)(GLsync sync); +// typedef GLboolean (APIENTRYP GPISTEXTURE)(GLuint texture); +// typedef GLboolean (APIENTRYP GPISTEXTUREHANDLERESIDENTARB)(GLuint64 handle); +// typedef GLboolean (APIENTRYP GPISTEXTUREHANDLERESIDENTNV)(GLuint64 handle); +// typedef GLboolean (APIENTRYP GPISTRANSFORMFEEDBACK)(GLuint id); +// typedef GLboolean (APIENTRYP GPISVERTEXARRAY)(GLuint array); +// typedef void (APIENTRYP GPLABELOBJECTEXT)(GLenum type, GLuint object, GLsizei length, const GLchar * label); +// typedef void (APIENTRYP GPLINEWIDTH)(GLfloat width); +// typedef void (APIENTRYP GPLINKPROGRAM)(GLuint program); +// typedef void (APIENTRYP GPLISTDRAWCOMMANDSSTATESCLIENTNV)(GLuint list, GLuint segment, const void ** indirects, const GLsizei * sizes, const GLuint * states, const GLuint * fbos, GLuint count); +// typedef void (APIENTRYP GPLOGICOP)(GLenum opcode); +// typedef void (APIENTRYP GPMAKEBUFFERNONRESIDENTNV)(GLenum target); +// typedef void (APIENTRYP GPMAKEBUFFERRESIDENTNV)(GLenum target, GLenum access); +// typedef void (APIENTRYP GPMAKEIMAGEHANDLENONRESIDENTARB)(GLuint64 handle); +// typedef void (APIENTRYP GPMAKEIMAGEHANDLENONRESIDENTNV)(GLuint64 handle); +// typedef void (APIENTRYP GPMAKEIMAGEHANDLERESIDENTARB)(GLuint64 handle, GLenum access); +// typedef void (APIENTRYP GPMAKEIMAGEHANDLERESIDENTNV)(GLuint64 handle, GLenum access); +// typedef void (APIENTRYP GPMAKENAMEDBUFFERNONRESIDENTNV)(GLuint buffer); +// typedef void (APIENTRYP GPMAKENAMEDBUFFERRESIDENTNV)(GLuint buffer, GLenum access); +// typedef void (APIENTRYP GPMAKETEXTUREHANDLENONRESIDENTARB)(GLuint64 handle); +// typedef void (APIENTRYP GPMAKETEXTUREHANDLENONRESIDENTNV)(GLuint64 handle); +// typedef void (APIENTRYP GPMAKETEXTUREHANDLERESIDENTARB)(GLuint64 handle); +// typedef void (APIENTRYP GPMAKETEXTUREHANDLERESIDENTNV)(GLuint64 handle); +// typedef void * (APIENTRYP GPMAPBUFFER)(GLenum target, GLenum access); +// typedef void * (APIENTRYP GPMAPBUFFERRANGE)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +// typedef void * (APIENTRYP GPMAPNAMEDBUFFER)(GLuint buffer, GLenum access); +// typedef void * (APIENTRYP GPMAPNAMEDBUFFEREXT)(GLuint buffer, GLenum access); +// typedef void * (APIENTRYP GPMAPNAMEDBUFFERRANGE)(GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access); +// typedef void * (APIENTRYP GPMAPNAMEDBUFFERRANGEEXT)(GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access); +// typedef void (APIENTRYP GPMATRIXFRUSTUMEXT)(GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +// typedef void (APIENTRYP GPMATRIXLOAD3X2FNV)(GLenum matrixMode, const GLfloat * m); +// typedef void (APIENTRYP GPMATRIXLOAD3X3FNV)(GLenum matrixMode, const GLfloat * m); +// typedef void (APIENTRYP GPMATRIXLOADIDENTITYEXT)(GLenum mode); +// typedef void (APIENTRYP GPMATRIXLOADTRANSPOSE3X3FNV)(GLenum matrixMode, const GLfloat * m); +// typedef void (APIENTRYP GPMATRIXLOADTRANSPOSEDEXT)(GLenum mode, const GLdouble * m); +// typedef void (APIENTRYP GPMATRIXLOADTRANSPOSEFEXT)(GLenum mode, const GLfloat * m); +// typedef void (APIENTRYP GPMATRIXLOADDEXT)(GLenum mode, const GLdouble * m); +// typedef void (APIENTRYP GPMATRIXLOADFEXT)(GLenum mode, const GLfloat * m); +// typedef void (APIENTRYP GPMATRIXMULT3X2FNV)(GLenum matrixMode, const GLfloat * m); +// typedef void (APIENTRYP GPMATRIXMULT3X3FNV)(GLenum matrixMode, const GLfloat * m); +// typedef void (APIENTRYP GPMATRIXMULTTRANSPOSE3X3FNV)(GLenum matrixMode, const GLfloat * m); +// typedef void (APIENTRYP GPMATRIXMULTTRANSPOSEDEXT)(GLenum mode, const GLdouble * m); +// typedef void (APIENTRYP GPMATRIXMULTTRANSPOSEFEXT)(GLenum mode, const GLfloat * m); +// typedef void (APIENTRYP GPMATRIXMULTDEXT)(GLenum mode, const GLdouble * m); +// typedef void (APIENTRYP GPMATRIXMULTFEXT)(GLenum mode, const GLfloat * m); +// typedef void (APIENTRYP GPMATRIXORTHOEXT)(GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +// typedef void (APIENTRYP GPMATRIXPOPEXT)(GLenum mode); +// typedef void (APIENTRYP GPMATRIXPUSHEXT)(GLenum mode); +// typedef void (APIENTRYP GPMATRIXROTATEDEXT)(GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +// typedef void (APIENTRYP GPMATRIXROTATEFEXT)(GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +// typedef void (APIENTRYP GPMATRIXSCALEDEXT)(GLenum mode, GLdouble x, GLdouble y, GLdouble z); +// typedef void (APIENTRYP GPMATRIXSCALEFEXT)(GLenum mode, GLfloat x, GLfloat y, GLfloat z); +// typedef void (APIENTRYP GPMATRIXTRANSLATEDEXT)(GLenum mode, GLdouble x, GLdouble y, GLdouble z); +// typedef void (APIENTRYP GPMATRIXTRANSLATEFEXT)(GLenum mode, GLfloat x, GLfloat y, GLfloat z); +// typedef void (APIENTRYP GPMAXSHADERCOMPILERTHREADSARB)(GLuint count); +// typedef void (APIENTRYP GPMAXSHADERCOMPILERTHREADSKHR)(GLuint count); +// typedef void (APIENTRYP GPMEMORYBARRIER)(GLbitfield barriers); +// typedef void (APIENTRYP GPMEMORYBARRIERBYREGION)(GLbitfield barriers); +// typedef void (APIENTRYP GPMINSAMPLESHADINGARB)(GLfloat value); +// typedef void (APIENTRYP GPMULTIDRAWARRAYS)(GLenum mode, const GLint * first, const GLsizei * count, GLsizei drawcount); +// typedef void (APIENTRYP GPMULTIDRAWARRAYSINDIRECT)(GLenum mode, const void * indirect, GLsizei drawcount, GLsizei stride); +// typedef void (APIENTRYP GPMULTIDRAWARRAYSINDIRECTBINDLESSCOUNTNV)(GLenum mode, const void * indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount); +// typedef void (APIENTRYP GPMULTIDRAWARRAYSINDIRECTBINDLESSNV)(GLenum mode, const void * indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount); +// typedef void (APIENTRYP GPMULTIDRAWARRAYSINDIRECTCOUNTARB)(GLenum mode, const void * indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride); +// typedef void (APIENTRYP GPMULTIDRAWELEMENTS)(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount); +// typedef void (APIENTRYP GPMULTIDRAWELEMENTSBASEVERTEX)(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount, const GLint * basevertex); +// typedef void (APIENTRYP GPMULTIDRAWELEMENTSINDIRECT)(GLenum mode, GLenum type, const void * indirect, GLsizei drawcount, GLsizei stride); +// typedef void (APIENTRYP GPMULTIDRAWELEMENTSINDIRECTBINDLESSCOUNTNV)(GLenum mode, GLenum type, const void * indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount); +// typedef void (APIENTRYP GPMULTIDRAWELEMENTSINDIRECTBINDLESSNV)(GLenum mode, GLenum type, const void * indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount); +// typedef void (APIENTRYP GPMULTIDRAWELEMENTSINDIRECTCOUNTARB)(GLenum mode, GLenum type, const void * indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride); +// typedef void (APIENTRYP GPMULTIDRAWMESHTASKSINDIRECTCOUNTNV)(GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride); +// typedef void (APIENTRYP GPMULTIDRAWMESHTASKSINDIRECTNV)(GLintptr indirect, GLsizei drawcount, GLsizei stride); +// typedef void (APIENTRYP GPMULTITEXBUFFEREXT)(GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer); +// typedef void (APIENTRYP GPMULTITEXCOORDPOINTEREXT)(GLenum texunit, GLint size, GLenum type, GLsizei stride, const void * pointer); +// typedef void (APIENTRYP GPMULTITEXENVFEXT)(GLenum texunit, GLenum target, GLenum pname, GLfloat param); +// typedef void (APIENTRYP GPMULTITEXENVFVEXT)(GLenum texunit, GLenum target, GLenum pname, const GLfloat * params); +// typedef void (APIENTRYP GPMULTITEXENVIEXT)(GLenum texunit, GLenum target, GLenum pname, GLint param); +// typedef void (APIENTRYP GPMULTITEXENVIVEXT)(GLenum texunit, GLenum target, GLenum pname, const GLint * params); +// typedef void (APIENTRYP GPMULTITEXGENDEXT)(GLenum texunit, GLenum coord, GLenum pname, GLdouble param); +// typedef void (APIENTRYP GPMULTITEXGENDVEXT)(GLenum texunit, GLenum coord, GLenum pname, const GLdouble * params); +// typedef void (APIENTRYP GPMULTITEXGENFEXT)(GLenum texunit, GLenum coord, GLenum pname, GLfloat param); +// typedef void (APIENTRYP GPMULTITEXGENFVEXT)(GLenum texunit, GLenum coord, GLenum pname, const GLfloat * params); +// typedef void (APIENTRYP GPMULTITEXGENIEXT)(GLenum texunit, GLenum coord, GLenum pname, GLint param); +// typedef void (APIENTRYP GPMULTITEXGENIVEXT)(GLenum texunit, GLenum coord, GLenum pname, const GLint * params); +// typedef void (APIENTRYP GPMULTITEXIMAGE1DEXT)(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPMULTITEXIMAGE2DEXT)(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPMULTITEXIMAGE3DEXT)(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPMULTITEXPARAMETERIIVEXT)(GLenum texunit, GLenum target, GLenum pname, const GLint * params); +// typedef void (APIENTRYP GPMULTITEXPARAMETERIUIVEXT)(GLenum texunit, GLenum target, GLenum pname, const GLuint * params); +// typedef void (APIENTRYP GPMULTITEXPARAMETERFEXT)(GLenum texunit, GLenum target, GLenum pname, GLfloat param); +// typedef void (APIENTRYP GPMULTITEXPARAMETERFVEXT)(GLenum texunit, GLenum target, GLenum pname, const GLfloat * params); +// typedef void (APIENTRYP GPMULTITEXPARAMETERIEXT)(GLenum texunit, GLenum target, GLenum pname, GLint param); +// typedef void (APIENTRYP GPMULTITEXPARAMETERIVEXT)(GLenum texunit, GLenum target, GLenum pname, const GLint * params); +// typedef void (APIENTRYP GPMULTITEXRENDERBUFFEREXT)(GLenum texunit, GLenum target, GLuint renderbuffer); +// typedef void (APIENTRYP GPMULTITEXSUBIMAGE1DEXT)(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPMULTITEXSUBIMAGE2DEXT)(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPMULTITEXSUBIMAGE3DEXT)(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPNAMEDBUFFERATTACHMEMORYNV)(GLuint buffer, GLuint memory, GLuint64 offset); +// typedef void (APIENTRYP GPNAMEDBUFFERDATA)(GLuint buffer, GLsizeiptr size, const void * data, GLenum usage); +// typedef void (APIENTRYP GPNAMEDBUFFERDATAEXT)(GLuint buffer, GLsizeiptr size, const void * data, GLenum usage); +// typedef void (APIENTRYP GPNAMEDBUFFERPAGECOMMITMENTARB)(GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit); +// typedef void (APIENTRYP GPNAMEDBUFFERPAGECOMMITMENTEXT)(GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit); +// typedef void (APIENTRYP GPNAMEDBUFFERPAGECOMMITMENTMEMNV)(GLuint buffer, GLintptr offset, GLsizeiptr size, GLuint memory, GLuint64 memOffset, GLboolean commit); +// typedef void (APIENTRYP GPNAMEDBUFFERSTORAGE)(GLuint buffer, GLsizeiptr size, const void * data, GLbitfield flags); +// typedef void (APIENTRYP GPNAMEDBUFFERSTORAGEEXT)(GLuint buffer, GLsizeiptr size, const void * data, GLbitfield flags); +// typedef void (APIENTRYP GPNAMEDBUFFERSUBDATA)(GLuint buffer, GLintptr offset, GLsizeiptr size, const void * data); +// typedef void (APIENTRYP GPNAMEDBUFFERSUBDATAEXT)(GLuint buffer, GLintptr offset, GLsizeiptr size, const void * data); +// typedef void (APIENTRYP GPNAMEDCOPYBUFFERSUBDATAEXT)(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +// typedef void (APIENTRYP GPNAMEDFRAMEBUFFERDRAWBUFFER)(GLuint framebuffer, GLenum buf); +// typedef void (APIENTRYP GPNAMEDFRAMEBUFFERDRAWBUFFERS)(GLuint framebuffer, GLsizei n, const GLenum * bufs); +// typedef void (APIENTRYP GPNAMEDFRAMEBUFFERPARAMETERI)(GLuint framebuffer, GLenum pname, GLint param); +// typedef void (APIENTRYP GPNAMEDFRAMEBUFFERPARAMETERIEXT)(GLuint framebuffer, GLenum pname, GLint param); +// typedef void (APIENTRYP GPNAMEDFRAMEBUFFERREADBUFFER)(GLuint framebuffer, GLenum src); +// typedef void (APIENTRYP GPNAMEDFRAMEBUFFERRENDERBUFFER)(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +// typedef void (APIENTRYP GPNAMEDFRAMEBUFFERRENDERBUFFEREXT)(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +// typedef void (APIENTRYP GPNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARB)(GLuint framebuffer, GLuint start, GLsizei count, const GLfloat * v); +// typedef void (APIENTRYP GPNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNV)(GLuint framebuffer, GLuint start, GLsizei count, const GLfloat * v); +// typedef void (APIENTRYP GPNAMEDFRAMEBUFFERTEXTURE)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level); +// typedef void (APIENTRYP GPNAMEDFRAMEBUFFERTEXTURE1DEXT)(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +// typedef void (APIENTRYP GPNAMEDFRAMEBUFFERTEXTURE2DEXT)(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +// typedef void (APIENTRYP GPNAMEDFRAMEBUFFERTEXTURE3DEXT)(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +// typedef void (APIENTRYP GPNAMEDFRAMEBUFFERTEXTUREEXT)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level); +// typedef void (APIENTRYP GPNAMEDFRAMEBUFFERTEXTUREFACEEXT)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face); +// typedef void (APIENTRYP GPNAMEDFRAMEBUFFERTEXTURELAYER)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer); +// typedef void (APIENTRYP GPNAMEDFRAMEBUFFERTEXTURELAYEREXT)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer); +// typedef void (APIENTRYP GPNAMEDPROGRAMLOCALPARAMETER4DEXT)(GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +// typedef void (APIENTRYP GPNAMEDPROGRAMLOCALPARAMETER4DVEXT)(GLuint program, GLenum target, GLuint index, const GLdouble * params); +// typedef void (APIENTRYP GPNAMEDPROGRAMLOCALPARAMETER4FEXT)(GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +// typedef void (APIENTRYP GPNAMEDPROGRAMLOCALPARAMETER4FVEXT)(GLuint program, GLenum target, GLuint index, const GLfloat * params); +// typedef void (APIENTRYP GPNAMEDPROGRAMLOCALPARAMETERI4IEXT)(GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w); +// typedef void (APIENTRYP GPNAMEDPROGRAMLOCALPARAMETERI4IVEXT)(GLuint program, GLenum target, GLuint index, const GLint * params); +// typedef void (APIENTRYP GPNAMEDPROGRAMLOCALPARAMETERI4UIEXT)(GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +// typedef void (APIENTRYP GPNAMEDPROGRAMLOCALPARAMETERI4UIVEXT)(GLuint program, GLenum target, GLuint index, const GLuint * params); +// typedef void (APIENTRYP GPNAMEDPROGRAMLOCALPARAMETERS4FVEXT)(GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat * params); +// typedef void (APIENTRYP GPNAMEDPROGRAMLOCALPARAMETERSI4IVEXT)(GLuint program, GLenum target, GLuint index, GLsizei count, const GLint * params); +// typedef void (APIENTRYP GPNAMEDPROGRAMLOCALPARAMETERSI4UIVEXT)(GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint * params); +// typedef void (APIENTRYP GPNAMEDPROGRAMSTRINGEXT)(GLuint program, GLenum target, GLenum format, GLsizei len, const void * string); +// typedef void (APIENTRYP GPNAMEDRENDERBUFFERSTORAGE)(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPNAMEDRENDERBUFFERSTORAGEEXT)(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPNAMEDRENDERBUFFERSTORAGEMULTISAMPLE)(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPNAMEDRENDERBUFFERSTORAGEMULTISAMPLEADVANCEDAMD)(GLuint renderbuffer, GLsizei samples, GLsizei storageSamples, GLenum internalformat, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXT)(GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXT)(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPNAMEDSTRINGARB)(GLenum type, GLint namelen, const GLchar * name, GLint stringlen, const GLchar * string); +// typedef void (APIENTRYP GPNORMALFORMATNV)(GLenum type, GLsizei stride); +// typedef void (APIENTRYP GPOBJECTLABEL)(GLenum identifier, GLuint name, GLsizei length, const GLchar * label); +// typedef void (APIENTRYP GPOBJECTLABELKHR)(GLenum identifier, GLuint name, GLsizei length, const GLchar * label); +// typedef void (APIENTRYP GPOBJECTPTRLABEL)(const void * ptr, GLsizei length, const GLchar * label); +// typedef void (APIENTRYP GPOBJECTPTRLABELKHR)(const void * ptr, GLsizei length, const GLchar * label); +// typedef void (APIENTRYP GPPATCHPARAMETERFV)(GLenum pname, const GLfloat * values); +// typedef void (APIENTRYP GPPATCHPARAMETERI)(GLenum pname, GLint value); +// typedef void (APIENTRYP GPPATHCOMMANDSNV)(GLuint path, GLsizei numCommands, const GLubyte * commands, GLsizei numCoords, GLenum coordType, const void * coords); +// typedef void (APIENTRYP GPPATHCOORDSNV)(GLuint path, GLsizei numCoords, GLenum coordType, const void * coords); +// typedef void (APIENTRYP GPPATHCOVERDEPTHFUNCNV)(GLenum func); +// typedef void (APIENTRYP GPPATHDASHARRAYNV)(GLuint path, GLsizei dashCount, const GLfloat * dashArray); +// typedef GLenum (APIENTRYP GPPATHGLYPHINDEXARRAYNV)(GLuint firstPathName, GLenum fontTarget, const void * fontName, GLbitfield fontStyle, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale); +// typedef GLenum (APIENTRYP GPPATHGLYPHINDEXRANGENV)(GLenum fontTarget, const void * fontName, GLbitfield fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint * baseAndCount); +// typedef void (APIENTRYP GPPATHGLYPHRANGENV)(GLuint firstPathName, GLenum fontTarget, const void * fontName, GLbitfield fontStyle, GLuint firstGlyph, GLsizei numGlyphs, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale); +// typedef void (APIENTRYP GPPATHGLYPHSNV)(GLuint firstPathName, GLenum fontTarget, const void * fontName, GLbitfield fontStyle, GLsizei numGlyphs, GLenum type, const void * charcodes, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale); +// typedef GLenum (APIENTRYP GPPATHMEMORYGLYPHINDEXARRAYNV)(GLuint firstPathName, GLenum fontTarget, GLsizeiptr fontSize, const void * fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale); +// typedef void (APIENTRYP GPPATHPARAMETERFNV)(GLuint path, GLenum pname, GLfloat value); +// typedef void (APIENTRYP GPPATHPARAMETERFVNV)(GLuint path, GLenum pname, const GLfloat * value); +// typedef void (APIENTRYP GPPATHPARAMETERINV)(GLuint path, GLenum pname, GLint value); +// typedef void (APIENTRYP GPPATHPARAMETERIVNV)(GLuint path, GLenum pname, const GLint * value); +// typedef void (APIENTRYP GPPATHSTENCILDEPTHOFFSETNV)(GLfloat factor, GLfloat units); +// typedef void (APIENTRYP GPPATHSTENCILFUNCNV)(GLenum func, GLint ref, GLuint mask); +// typedef void (APIENTRYP GPPATHSTRINGNV)(GLuint path, GLenum format, GLsizei length, const void * pathString); +// typedef void (APIENTRYP GPPATHSUBCOMMANDSNV)(GLuint path, GLsizei commandStart, GLsizei commandsToDelete, GLsizei numCommands, const GLubyte * commands, GLsizei numCoords, GLenum coordType, const void * coords); +// typedef void (APIENTRYP GPPATHSUBCOORDSNV)(GLuint path, GLsizei coordStart, GLsizei numCoords, GLenum coordType, const void * coords); +// typedef void (APIENTRYP GPPAUSETRANSFORMFEEDBACK)(); +// typedef void (APIENTRYP GPPIXELSTOREF)(GLenum pname, GLfloat param); +// typedef void (APIENTRYP GPPIXELSTOREI)(GLenum pname, GLint param); +// typedef GLboolean (APIENTRYP GPPOINTALONGPATHNV)(GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, GLfloat * x, GLfloat * y, GLfloat * tangentX, GLfloat * tangentY); +// typedef void (APIENTRYP GPPOINTPARAMETERF)(GLenum pname, GLfloat param); +// typedef void (APIENTRYP GPPOINTPARAMETERFV)(GLenum pname, const GLfloat * params); +// typedef void (APIENTRYP GPPOINTPARAMETERI)(GLenum pname, GLint param); +// typedef void (APIENTRYP GPPOINTPARAMETERIV)(GLenum pname, const GLint * params); +// typedef void (APIENTRYP GPPOINTSIZE)(GLfloat size); +// typedef void (APIENTRYP GPPOLYGONMODE)(GLenum face, GLenum mode); +// typedef void (APIENTRYP GPPOLYGONOFFSET)(GLfloat factor, GLfloat units); +// typedef void (APIENTRYP GPPOLYGONOFFSETCLAMP)(GLfloat factor, GLfloat units, GLfloat clamp); +// typedef void (APIENTRYP GPPOLYGONOFFSETCLAMPEXT)(GLfloat factor, GLfloat units, GLfloat clamp); +// typedef void (APIENTRYP GPPOPDEBUGGROUP)(); +// typedef void (APIENTRYP GPPOPDEBUGGROUPKHR)(); +// typedef void (APIENTRYP GPPOPGROUPMARKEREXT)(); +// typedef void (APIENTRYP GPPRIMITIVEBOUNDINGBOXARB)(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW); +// typedef void (APIENTRYP GPPRIMITIVERESTARTINDEX)(GLuint index); +// typedef void (APIENTRYP GPPROGRAMBINARY)(GLuint program, GLenum binaryFormat, const void * binary, GLsizei length); +// typedef void (APIENTRYP GPPROGRAMPARAMETERI)(GLuint program, GLenum pname, GLint value); +// typedef void (APIENTRYP GPPROGRAMPARAMETERIARB)(GLuint program, GLenum pname, GLint value); +// typedef void (APIENTRYP GPPROGRAMPARAMETERIEXT)(GLuint program, GLenum pname, GLint value); +// typedef void (APIENTRYP GPPROGRAMPATHFRAGMENTINPUTGENNV)(GLuint program, GLint location, GLenum genMode, GLint components, const GLfloat * coeffs); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1D)(GLuint program, GLint location, GLdouble v0); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1DEXT)(GLuint program, GLint location, GLdouble x); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1DV)(GLuint program, GLint location, GLsizei count, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1DVEXT)(GLuint program, GLint location, GLsizei count, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1F)(GLuint program, GLint location, GLfloat v0); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1FEXT)(GLuint program, GLint location, GLfloat v0); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1FV)(GLuint program, GLint location, GLsizei count, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1FVEXT)(GLuint program, GLint location, GLsizei count, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1I)(GLuint program, GLint location, GLint v0); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1I64ARB)(GLuint program, GLint location, GLint64 x); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1I64NV)(GLuint program, GLint location, GLint64EXT x); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1I64VARB)(GLuint program, GLint location, GLsizei count, const GLint64 * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1I64VNV)(GLuint program, GLint location, GLsizei count, const GLint64EXT * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1IEXT)(GLuint program, GLint location, GLint v0); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1IV)(GLuint program, GLint location, GLsizei count, const GLint * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1IVEXT)(GLuint program, GLint location, GLsizei count, const GLint * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1UI)(GLuint program, GLint location, GLuint v0); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1UI64ARB)(GLuint program, GLint location, GLuint64 x); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1UI64NV)(GLuint program, GLint location, GLuint64EXT x); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1UI64VARB)(GLuint program, GLint location, GLsizei count, const GLuint64 * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1UI64VNV)(GLuint program, GLint location, GLsizei count, const GLuint64EXT * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1UIEXT)(GLuint program, GLint location, GLuint v0); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1UIV)(GLuint program, GLint location, GLsizei count, const GLuint * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM1UIVEXT)(GLuint program, GLint location, GLsizei count, const GLuint * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2D)(GLuint program, GLint location, GLdouble v0, GLdouble v1); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2DEXT)(GLuint program, GLint location, GLdouble x, GLdouble y); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2DV)(GLuint program, GLint location, GLsizei count, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2DVEXT)(GLuint program, GLint location, GLsizei count, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2F)(GLuint program, GLint location, GLfloat v0, GLfloat v1); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2FEXT)(GLuint program, GLint location, GLfloat v0, GLfloat v1); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2FV)(GLuint program, GLint location, GLsizei count, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2FVEXT)(GLuint program, GLint location, GLsizei count, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2I)(GLuint program, GLint location, GLint v0, GLint v1); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2I64ARB)(GLuint program, GLint location, GLint64 x, GLint64 y); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2I64NV)(GLuint program, GLint location, GLint64EXT x, GLint64EXT y); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2I64VARB)(GLuint program, GLint location, GLsizei count, const GLint64 * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2I64VNV)(GLuint program, GLint location, GLsizei count, const GLint64EXT * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2IEXT)(GLuint program, GLint location, GLint v0, GLint v1); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2IV)(GLuint program, GLint location, GLsizei count, const GLint * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2IVEXT)(GLuint program, GLint location, GLsizei count, const GLint * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2UI)(GLuint program, GLint location, GLuint v0, GLuint v1); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2UI64ARB)(GLuint program, GLint location, GLuint64 x, GLuint64 y); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2UI64NV)(GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2UI64VARB)(GLuint program, GLint location, GLsizei count, const GLuint64 * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2UI64VNV)(GLuint program, GLint location, GLsizei count, const GLuint64EXT * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2UIEXT)(GLuint program, GLint location, GLuint v0, GLuint v1); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2UIV)(GLuint program, GLint location, GLsizei count, const GLuint * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM2UIVEXT)(GLuint program, GLint location, GLsizei count, const GLuint * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3D)(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3DEXT)(GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3DV)(GLuint program, GLint location, GLsizei count, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3DVEXT)(GLuint program, GLint location, GLsizei count, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3F)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3FEXT)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3FV)(GLuint program, GLint location, GLsizei count, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3FVEXT)(GLuint program, GLint location, GLsizei count, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3I)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3I64ARB)(GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3I64NV)(GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3I64VARB)(GLuint program, GLint location, GLsizei count, const GLint64 * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3I64VNV)(GLuint program, GLint location, GLsizei count, const GLint64EXT * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3IEXT)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3IV)(GLuint program, GLint location, GLsizei count, const GLint * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3IVEXT)(GLuint program, GLint location, GLsizei count, const GLint * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3UI)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3UI64ARB)(GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3UI64NV)(GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3UI64VARB)(GLuint program, GLint location, GLsizei count, const GLuint64 * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3UI64VNV)(GLuint program, GLint location, GLsizei count, const GLuint64EXT * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3UIEXT)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3UIV)(GLuint program, GLint location, GLsizei count, const GLuint * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM3UIVEXT)(GLuint program, GLint location, GLsizei count, const GLuint * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4D)(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4DEXT)(GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4DV)(GLuint program, GLint location, GLsizei count, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4DVEXT)(GLuint program, GLint location, GLsizei count, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4F)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4FEXT)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4FV)(GLuint program, GLint location, GLsizei count, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4FVEXT)(GLuint program, GLint location, GLsizei count, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4I)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4I64ARB)(GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4I64NV)(GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4I64VARB)(GLuint program, GLint location, GLsizei count, const GLint64 * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4I64VNV)(GLuint program, GLint location, GLsizei count, const GLint64EXT * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4IEXT)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4IV)(GLuint program, GLint location, GLsizei count, const GLint * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4IVEXT)(GLuint program, GLint location, GLsizei count, const GLint * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4UI)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4UI64ARB)(GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4UI64NV)(GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4UI64VARB)(GLuint program, GLint location, GLsizei count, const GLuint64 * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4UI64VNV)(GLuint program, GLint location, GLsizei count, const GLuint64EXT * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4UIEXT)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4UIV)(GLuint program, GLint location, GLsizei count, const GLuint * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORM4UIVEXT)(GLuint program, GLint location, GLsizei count, const GLuint * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMHANDLEUI64ARB)(GLuint program, GLint location, GLuint64 value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMHANDLEUI64NV)(GLuint program, GLint location, GLuint64 value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMHANDLEUI64VARB)(GLuint program, GLint location, GLsizei count, const GLuint64 * values); +// typedef void (APIENTRYP GPPROGRAMUNIFORMHANDLEUI64VNV)(GLuint program, GLint location, GLsizei count, const GLuint64 * values); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX2DV)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX2DVEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX2FV)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX2FVEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX2X3DV)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX2X3DVEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX2X3FV)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX2X3FVEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX2X4DV)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX2X4DVEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX2X4FV)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX2X4FVEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX3DV)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX3DVEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX3FV)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX3FVEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX3X2DV)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX3X2DVEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX3X2FV)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX3X2FVEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX3X4DV)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX3X4DVEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX3X4FV)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX3X4FVEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX4DV)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX4DVEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX4FV)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX4FVEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX4X2DV)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX4X2DVEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX4X2FV)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX4X2FVEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX4X3DV)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX4X3DVEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX4X3FV)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMMATRIX4X3FVEXT)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMUI64NV)(GLuint program, GLint location, GLuint64EXT value); +// typedef void (APIENTRYP GPPROGRAMUNIFORMUI64VNV)(GLuint program, GLint location, GLsizei count, const GLuint64EXT * value); +// typedef void (APIENTRYP GPPROVOKINGVERTEX)(GLenum mode); +// typedef void (APIENTRYP GPPUSHCLIENTATTRIBDEFAULTEXT)(GLbitfield mask); +// typedef void (APIENTRYP GPPUSHDEBUGGROUP)(GLenum source, GLuint id, GLsizei length, const GLchar * message); +// typedef void (APIENTRYP GPPUSHDEBUGGROUPKHR)(GLenum source, GLuint id, GLsizei length, const GLchar * message); +// typedef void (APIENTRYP GPPUSHGROUPMARKEREXT)(GLsizei length, const GLchar * marker); +// typedef void (APIENTRYP GPQUERYCOUNTER)(GLuint id, GLenum target); +// typedef void (APIENTRYP GPRASTERSAMPLESEXT)(GLuint samples, GLboolean fixedsamplelocations); +// typedef void (APIENTRYP GPREADBUFFER)(GLenum src); +// typedef void (APIENTRYP GPREADPIXELS)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * pixels); +// typedef void (APIENTRYP GPREADNPIXELS)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void * data); +// typedef void (APIENTRYP GPREADNPIXELSARB)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void * data); +// typedef void (APIENTRYP GPREADNPIXELSKHR)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void * data); +// typedef void (APIENTRYP GPRELEASESHADERCOMPILER)(); +// typedef void (APIENTRYP GPRENDERBUFFERSTORAGE)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPRENDERBUFFERSTORAGEMULTISAMPLE)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPRENDERBUFFERSTORAGEMULTISAMPLEADVANCEDAMD)(GLenum target, GLsizei samples, GLsizei storageSamples, GLenum internalformat, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENV)(GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPRESETMEMORYOBJECTPARAMETERNV)(GLuint memory, GLenum pname); +// typedef void (APIENTRYP GPRESOLVEDEPTHVALUESNV)(); +// typedef void (APIENTRYP GPRESUMETRANSFORMFEEDBACK)(); +// typedef void (APIENTRYP GPSAMPLECOVERAGE)(GLfloat value, GLboolean invert); +// typedef void (APIENTRYP GPSAMPLEMASKI)(GLuint maskNumber, GLbitfield mask); +// typedef void (APIENTRYP GPSAMPLERPARAMETERIIV)(GLuint sampler, GLenum pname, const GLint * param); +// typedef void (APIENTRYP GPSAMPLERPARAMETERIUIV)(GLuint sampler, GLenum pname, const GLuint * param); +// typedef void (APIENTRYP GPSAMPLERPARAMETERF)(GLuint sampler, GLenum pname, GLfloat param); +// typedef void (APIENTRYP GPSAMPLERPARAMETERFV)(GLuint sampler, GLenum pname, const GLfloat * param); +// typedef void (APIENTRYP GPSAMPLERPARAMETERI)(GLuint sampler, GLenum pname, GLint param); +// typedef void (APIENTRYP GPSAMPLERPARAMETERIV)(GLuint sampler, GLenum pname, const GLint * param); +// typedef void (APIENTRYP GPSCISSOR)(GLint x, GLint y, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPSCISSORARRAYV)(GLuint first, GLsizei count, const GLint * v); +// typedef void (APIENTRYP GPSCISSOREXCLUSIVEARRAYVNV)(GLuint first, GLsizei count, const GLint * v); +// typedef void (APIENTRYP GPSCISSOREXCLUSIVENV)(GLint x, GLint y, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPSCISSORINDEXED)(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPSCISSORINDEXEDV)(GLuint index, const GLint * v); +// typedef void (APIENTRYP GPSECONDARYCOLORFORMATNV)(GLint size, GLenum type, GLsizei stride); +// typedef void (APIENTRYP GPSELECTPERFMONITORCOUNTERSAMD)(GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint * counterList); +// typedef void (APIENTRYP GPSHADERBINARY)(GLsizei count, const GLuint * shaders, GLenum binaryFormat, const void * binary, GLsizei length); +// typedef void (APIENTRYP GPSHADERSOURCE)(GLuint shader, GLsizei count, const GLchar *const* string, const GLint * length); +// typedef void (APIENTRYP GPSHADERSTORAGEBLOCKBINDING)(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding); +// typedef void (APIENTRYP GPSHADINGRATEIMAGEBARRIERNV)(GLboolean synchronize); +// typedef void (APIENTRYP GPSHADINGRATEIMAGEPALETTENV)(GLuint viewport, GLuint first, GLsizei count, const GLenum * rates); +// typedef void (APIENTRYP GPSHADINGRATESAMPLEORDERCUSTOMNV)(GLenum rate, GLuint samples, const GLint * locations); +// typedef void (APIENTRYP GPSHADINGRATESAMPLEORDERNV)(GLenum order); +// typedef void (APIENTRYP GPSIGNALVKFENCENV)(GLuint64 vkFence); +// typedef void (APIENTRYP GPSIGNALVKSEMAPHORENV)(GLuint64 vkSemaphore); +// typedef void (APIENTRYP GPSPECIALIZESHADERARB)(GLuint shader, const GLchar * pEntryPoint, GLuint numSpecializationConstants, const GLuint * pConstantIndex, const GLuint * pConstantValue); +// typedef void (APIENTRYP GPSTATECAPTURENV)(GLuint state, GLenum mode); +// typedef void (APIENTRYP GPSTENCILFILLPATHINSTANCEDNV)(GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum transformType, const GLfloat * transformValues); +// typedef void (APIENTRYP GPSTENCILFILLPATHNV)(GLuint path, GLenum fillMode, GLuint mask); +// typedef void (APIENTRYP GPSTENCILFUNC)(GLenum func, GLint ref, GLuint mask); +// typedef void (APIENTRYP GPSTENCILFUNCSEPARATE)(GLenum face, GLenum func, GLint ref, GLuint mask); +// typedef void (APIENTRYP GPSTENCILMASK)(GLuint mask); +// typedef void (APIENTRYP GPSTENCILMASKSEPARATE)(GLenum face, GLuint mask); +// typedef void (APIENTRYP GPSTENCILOP)(GLenum fail, GLenum zfail, GLenum zpass); +// typedef void (APIENTRYP GPSTENCILOPSEPARATE)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +// typedef void (APIENTRYP GPSTENCILSTROKEPATHINSTANCEDNV)(GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLint reference, GLuint mask, GLenum transformType, const GLfloat * transformValues); +// typedef void (APIENTRYP GPSTENCILSTROKEPATHNV)(GLuint path, GLint reference, GLuint mask); +// typedef void (APIENTRYP GPSTENCILTHENCOVERFILLPATHINSTANCEDNV)(GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat * transformValues); +// typedef void (APIENTRYP GPSTENCILTHENCOVERFILLPATHNV)(GLuint path, GLenum fillMode, GLuint mask, GLenum coverMode); +// typedef void (APIENTRYP GPSTENCILTHENCOVERSTROKEPATHINSTANCEDNV)(GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLint reference, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat * transformValues); +// typedef void (APIENTRYP GPSTENCILTHENCOVERSTROKEPATHNV)(GLuint path, GLint reference, GLuint mask, GLenum coverMode); +// typedef void (APIENTRYP GPSUBPIXELPRECISIONBIASNV)(GLuint xbits, GLuint ybits); +// typedef void (APIENTRYP GPTEXATTACHMEMORYNV)(GLenum target, GLuint memory, GLuint64 offset); +// typedef void (APIENTRYP GPTEXBUFFER)(GLenum target, GLenum internalformat, GLuint buffer); +// typedef void (APIENTRYP GPTEXBUFFERARB)(GLenum target, GLenum internalformat, GLuint buffer); +// typedef void (APIENTRYP GPTEXBUFFERRANGE)(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size); +// typedef void (APIENTRYP GPTEXCOORDFORMATNV)(GLint size, GLenum type, GLsizei stride); +// typedef void (APIENTRYP GPTEXIMAGE1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPTEXIMAGE2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPTEXIMAGE2DMULTISAMPLE)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +// typedef void (APIENTRYP GPTEXIMAGE3D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPTEXIMAGE3DMULTISAMPLE)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +// typedef void (APIENTRYP GPTEXPAGECOMMITMENTARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit); +// typedef void (APIENTRYP GPTEXPAGECOMMITMENTMEMNV)(GLenum target, GLint layer, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset, GLboolean commit); +// typedef void (APIENTRYP GPTEXPARAMETERIIV)(GLenum target, GLenum pname, const GLint * params); +// typedef void (APIENTRYP GPTEXPARAMETERIUIV)(GLenum target, GLenum pname, const GLuint * params); +// typedef void (APIENTRYP GPTEXPARAMETERF)(GLenum target, GLenum pname, GLfloat param); +// typedef void (APIENTRYP GPTEXPARAMETERFV)(GLenum target, GLenum pname, const GLfloat * params); +// typedef void (APIENTRYP GPTEXPARAMETERI)(GLenum target, GLenum pname, GLint param); +// typedef void (APIENTRYP GPTEXPARAMETERIV)(GLenum target, GLenum pname, const GLint * params); +// typedef void (APIENTRYP GPTEXSTORAGE1D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width); +// typedef void (APIENTRYP GPTEXSTORAGE2D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPTEXSTORAGE2DMULTISAMPLE)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +// typedef void (APIENTRYP GPTEXSTORAGE3D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); +// typedef void (APIENTRYP GPTEXSTORAGE3DMULTISAMPLE)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +// typedef void (APIENTRYP GPTEXSUBIMAGE1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPTEXSUBIMAGE2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPTEXSUBIMAGE3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPTEXTUREATTACHMEMORYNV)(GLuint texture, GLuint memory, GLuint64 offset); +// typedef void (APIENTRYP GPTEXTUREBARRIER)(); +// typedef void (APIENTRYP GPTEXTUREBARRIERNV)(); +// typedef void (APIENTRYP GPTEXTUREBUFFER)(GLuint texture, GLenum internalformat, GLuint buffer); +// typedef void (APIENTRYP GPTEXTUREBUFFEREXT)(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer); +// typedef void (APIENTRYP GPTEXTUREBUFFERRANGE)(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size); +// typedef void (APIENTRYP GPTEXTUREBUFFERRANGEEXT)(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size); +// typedef void (APIENTRYP GPTEXTUREIMAGE1DEXT)(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPTEXTUREIMAGE2DEXT)(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPTEXTUREIMAGE3DEXT)(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPTEXTUREPAGECOMMITMENTEXT)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit); +// typedef void (APIENTRYP GPTEXTUREPAGECOMMITMENTMEMNV)(GLuint texture, GLint layer, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset, GLboolean commit); +// typedef void (APIENTRYP GPTEXTUREPARAMETERIIV)(GLuint texture, GLenum pname, const GLint * params); +// typedef void (APIENTRYP GPTEXTUREPARAMETERIIVEXT)(GLuint texture, GLenum target, GLenum pname, const GLint * params); +// typedef void (APIENTRYP GPTEXTUREPARAMETERIUIV)(GLuint texture, GLenum pname, const GLuint * params); +// typedef void (APIENTRYP GPTEXTUREPARAMETERIUIVEXT)(GLuint texture, GLenum target, GLenum pname, const GLuint * params); +// typedef void (APIENTRYP GPTEXTUREPARAMETERF)(GLuint texture, GLenum pname, GLfloat param); +// typedef void (APIENTRYP GPTEXTUREPARAMETERFEXT)(GLuint texture, GLenum target, GLenum pname, GLfloat param); +// typedef void (APIENTRYP GPTEXTUREPARAMETERFV)(GLuint texture, GLenum pname, const GLfloat * param); +// typedef void (APIENTRYP GPTEXTUREPARAMETERFVEXT)(GLuint texture, GLenum target, GLenum pname, const GLfloat * params); +// typedef void (APIENTRYP GPTEXTUREPARAMETERI)(GLuint texture, GLenum pname, GLint param); +// typedef void (APIENTRYP GPTEXTUREPARAMETERIEXT)(GLuint texture, GLenum target, GLenum pname, GLint param); +// typedef void (APIENTRYP GPTEXTUREPARAMETERIV)(GLuint texture, GLenum pname, const GLint * param); +// typedef void (APIENTRYP GPTEXTUREPARAMETERIVEXT)(GLuint texture, GLenum target, GLenum pname, const GLint * params); +// typedef void (APIENTRYP GPTEXTURERENDERBUFFEREXT)(GLuint texture, GLenum target, GLuint renderbuffer); +// typedef void (APIENTRYP GPTEXTURESTORAGE1D)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width); +// typedef void (APIENTRYP GPTEXTURESTORAGE1DEXT)(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width); +// typedef void (APIENTRYP GPTEXTURESTORAGE2D)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPTEXTURESTORAGE2DEXT)(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPTEXTURESTORAGE2DMULTISAMPLE)(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +// typedef void (APIENTRYP GPTEXTURESTORAGE2DMULTISAMPLEEXT)(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +// typedef void (APIENTRYP GPTEXTURESTORAGE3D)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); +// typedef void (APIENTRYP GPTEXTURESTORAGE3DEXT)(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); +// typedef void (APIENTRYP GPTEXTURESTORAGE3DMULTISAMPLE)(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +// typedef void (APIENTRYP GPTEXTURESTORAGE3DMULTISAMPLEEXT)(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +// typedef void (APIENTRYP GPTEXTURESUBIMAGE1D)(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPTEXTURESUBIMAGE1DEXT)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPTEXTURESUBIMAGE2D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPTEXTURESUBIMAGE2DEXT)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPTEXTURESUBIMAGE3D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPTEXTURESUBIMAGE3DEXT)(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels); +// typedef void (APIENTRYP GPTEXTUREVIEW)(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers); +// typedef void (APIENTRYP GPTRANSFORMFEEDBACKBUFFERBASE)(GLuint xfb, GLuint index, GLuint buffer); +// typedef void (APIENTRYP GPTRANSFORMFEEDBACKBUFFERRANGE)(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +// typedef void (APIENTRYP GPTRANSFORMFEEDBACKVARYINGS)(GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode); +// typedef void (APIENTRYP GPTRANSFORMPATHNV)(GLuint resultPath, GLuint srcPath, GLenum transformType, const GLfloat * transformValues); +// typedef void (APIENTRYP GPUNIFORM1D)(GLint location, GLdouble x); +// typedef void (APIENTRYP GPUNIFORM1DV)(GLint location, GLsizei count, const GLdouble * value); +// typedef void (APIENTRYP GPUNIFORM1F)(GLint location, GLfloat v0); +// typedef void (APIENTRYP GPUNIFORM1FV)(GLint location, GLsizei count, const GLfloat * value); +// typedef void (APIENTRYP GPUNIFORM1I)(GLint location, GLint v0); +// typedef void (APIENTRYP GPUNIFORM1I64ARB)(GLint location, GLint64 x); +// typedef void (APIENTRYP GPUNIFORM1I64NV)(GLint location, GLint64EXT x); +// typedef void (APIENTRYP GPUNIFORM1I64VARB)(GLint location, GLsizei count, const GLint64 * value); +// typedef void (APIENTRYP GPUNIFORM1I64VNV)(GLint location, GLsizei count, const GLint64EXT * value); +// typedef void (APIENTRYP GPUNIFORM1IV)(GLint location, GLsizei count, const GLint * value); +// typedef void (APIENTRYP GPUNIFORM1UI)(GLint location, GLuint v0); +// typedef void (APIENTRYP GPUNIFORM1UI64ARB)(GLint location, GLuint64 x); +// typedef void (APIENTRYP GPUNIFORM1UI64NV)(GLint location, GLuint64EXT x); +// typedef void (APIENTRYP GPUNIFORM1UI64VARB)(GLint location, GLsizei count, const GLuint64 * value); +// typedef void (APIENTRYP GPUNIFORM1UI64VNV)(GLint location, GLsizei count, const GLuint64EXT * value); +// typedef void (APIENTRYP GPUNIFORM1UIV)(GLint location, GLsizei count, const GLuint * value); +// typedef void (APIENTRYP GPUNIFORM2D)(GLint location, GLdouble x, GLdouble y); +// typedef void (APIENTRYP GPUNIFORM2DV)(GLint location, GLsizei count, const GLdouble * value); +// typedef void (APIENTRYP GPUNIFORM2F)(GLint location, GLfloat v0, GLfloat v1); +// typedef void (APIENTRYP GPUNIFORM2FV)(GLint location, GLsizei count, const GLfloat * value); +// typedef void (APIENTRYP GPUNIFORM2I)(GLint location, GLint v0, GLint v1); +// typedef void (APIENTRYP GPUNIFORM2I64ARB)(GLint location, GLint64 x, GLint64 y); +// typedef void (APIENTRYP GPUNIFORM2I64NV)(GLint location, GLint64EXT x, GLint64EXT y); +// typedef void (APIENTRYP GPUNIFORM2I64VARB)(GLint location, GLsizei count, const GLint64 * value); +// typedef void (APIENTRYP GPUNIFORM2I64VNV)(GLint location, GLsizei count, const GLint64EXT * value); +// typedef void (APIENTRYP GPUNIFORM2IV)(GLint location, GLsizei count, const GLint * value); +// typedef void (APIENTRYP GPUNIFORM2UI)(GLint location, GLuint v0, GLuint v1); +// typedef void (APIENTRYP GPUNIFORM2UI64ARB)(GLint location, GLuint64 x, GLuint64 y); +// typedef void (APIENTRYP GPUNIFORM2UI64NV)(GLint location, GLuint64EXT x, GLuint64EXT y); +// typedef void (APIENTRYP GPUNIFORM2UI64VARB)(GLint location, GLsizei count, const GLuint64 * value); +// typedef void (APIENTRYP GPUNIFORM2UI64VNV)(GLint location, GLsizei count, const GLuint64EXT * value); +// typedef void (APIENTRYP GPUNIFORM2UIV)(GLint location, GLsizei count, const GLuint * value); +// typedef void (APIENTRYP GPUNIFORM3D)(GLint location, GLdouble x, GLdouble y, GLdouble z); +// typedef void (APIENTRYP GPUNIFORM3DV)(GLint location, GLsizei count, const GLdouble * value); +// typedef void (APIENTRYP GPUNIFORM3F)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +// typedef void (APIENTRYP GPUNIFORM3FV)(GLint location, GLsizei count, const GLfloat * value); +// typedef void (APIENTRYP GPUNIFORM3I)(GLint location, GLint v0, GLint v1, GLint v2); +// typedef void (APIENTRYP GPUNIFORM3I64ARB)(GLint location, GLint64 x, GLint64 y, GLint64 z); +// typedef void (APIENTRYP GPUNIFORM3I64NV)(GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z); +// typedef void (APIENTRYP GPUNIFORM3I64VARB)(GLint location, GLsizei count, const GLint64 * value); +// typedef void (APIENTRYP GPUNIFORM3I64VNV)(GLint location, GLsizei count, const GLint64EXT * value); +// typedef void (APIENTRYP GPUNIFORM3IV)(GLint location, GLsizei count, const GLint * value); +// typedef void (APIENTRYP GPUNIFORM3UI)(GLint location, GLuint v0, GLuint v1, GLuint v2); +// typedef void (APIENTRYP GPUNIFORM3UI64ARB)(GLint location, GLuint64 x, GLuint64 y, GLuint64 z); +// typedef void (APIENTRYP GPUNIFORM3UI64NV)(GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z); +// typedef void (APIENTRYP GPUNIFORM3UI64VARB)(GLint location, GLsizei count, const GLuint64 * value); +// typedef void (APIENTRYP GPUNIFORM3UI64VNV)(GLint location, GLsizei count, const GLuint64EXT * value); +// typedef void (APIENTRYP GPUNIFORM3UIV)(GLint location, GLsizei count, const GLuint * value); +// typedef void (APIENTRYP GPUNIFORM4D)(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +// typedef void (APIENTRYP GPUNIFORM4DV)(GLint location, GLsizei count, const GLdouble * value); +// typedef void (APIENTRYP GPUNIFORM4F)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +// typedef void (APIENTRYP GPUNIFORM4FV)(GLint location, GLsizei count, const GLfloat * value); +// typedef void (APIENTRYP GPUNIFORM4I)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +// typedef void (APIENTRYP GPUNIFORM4I64ARB)(GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w); +// typedef void (APIENTRYP GPUNIFORM4I64NV)(GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w); +// typedef void (APIENTRYP GPUNIFORM4I64VARB)(GLint location, GLsizei count, const GLint64 * value); +// typedef void (APIENTRYP GPUNIFORM4I64VNV)(GLint location, GLsizei count, const GLint64EXT * value); +// typedef void (APIENTRYP GPUNIFORM4IV)(GLint location, GLsizei count, const GLint * value); +// typedef void (APIENTRYP GPUNIFORM4UI)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +// typedef void (APIENTRYP GPUNIFORM4UI64ARB)(GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w); +// typedef void (APIENTRYP GPUNIFORM4UI64NV)(GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w); +// typedef void (APIENTRYP GPUNIFORM4UI64VARB)(GLint location, GLsizei count, const GLuint64 * value); +// typedef void (APIENTRYP GPUNIFORM4UI64VNV)(GLint location, GLsizei count, const GLuint64EXT * value); +// typedef void (APIENTRYP GPUNIFORM4UIV)(GLint location, GLsizei count, const GLuint * value); +// typedef void (APIENTRYP GPUNIFORMBLOCKBINDING)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); +// typedef void (APIENTRYP GPUNIFORMHANDLEUI64ARB)(GLint location, GLuint64 value); +// typedef void (APIENTRYP GPUNIFORMHANDLEUI64NV)(GLint location, GLuint64 value); +// typedef void (APIENTRYP GPUNIFORMHANDLEUI64VARB)(GLint location, GLsizei count, const GLuint64 * value); +// typedef void (APIENTRYP GPUNIFORMHANDLEUI64VNV)(GLint location, GLsizei count, const GLuint64 * value); +// typedef void (APIENTRYP GPUNIFORMMATRIX2DV)(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPUNIFORMMATRIX2FV)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPUNIFORMMATRIX2X3DV)(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPUNIFORMMATRIX2X3FV)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPUNIFORMMATRIX2X4DV)(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPUNIFORMMATRIX2X4FV)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPUNIFORMMATRIX3DV)(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPUNIFORMMATRIX3FV)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPUNIFORMMATRIX3X2DV)(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPUNIFORMMATRIX3X2FV)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPUNIFORMMATRIX3X4DV)(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPUNIFORMMATRIX3X4FV)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPUNIFORMMATRIX4DV)(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPUNIFORMMATRIX4FV)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPUNIFORMMATRIX4X2DV)(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPUNIFORMMATRIX4X2FV)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPUNIFORMMATRIX4X3DV)(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value); +// typedef void (APIENTRYP GPUNIFORMMATRIX4X3FV)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +// typedef void (APIENTRYP GPUNIFORMSUBROUTINESUIV)(GLenum shadertype, GLsizei count, const GLuint * indices); +// typedef void (APIENTRYP GPUNIFORMUI64NV)(GLint location, GLuint64EXT value); +// typedef void (APIENTRYP GPUNIFORMUI64VNV)(GLint location, GLsizei count, const GLuint64EXT * value); +// typedef GLboolean (APIENTRYP GPUNMAPBUFFER)(GLenum target); +// typedef GLboolean (APIENTRYP GPUNMAPNAMEDBUFFER)(GLuint buffer); +// typedef GLboolean (APIENTRYP GPUNMAPNAMEDBUFFEREXT)(GLuint buffer); +// typedef void (APIENTRYP GPUSEPROGRAM)(GLuint program); +// typedef void (APIENTRYP GPUSEPROGRAMSTAGES)(GLuint pipeline, GLbitfield stages, GLuint program); +// typedef void (APIENTRYP GPUSEPROGRAMSTAGESEXT)(GLuint pipeline, GLbitfield stages, GLuint program); +// typedef void (APIENTRYP GPUSESHADERPROGRAMEXT)(GLenum type, GLuint program); +// typedef void (APIENTRYP GPVALIDATEPROGRAM)(GLuint program); +// typedef void (APIENTRYP GPVALIDATEPROGRAMPIPELINE)(GLuint pipeline); +// typedef void (APIENTRYP GPVALIDATEPROGRAMPIPELINEEXT)(GLuint pipeline); +// typedef void (APIENTRYP GPVERTEXARRAYATTRIBBINDING)(GLuint vaobj, GLuint attribindex, GLuint bindingindex); +// typedef void (APIENTRYP GPVERTEXARRAYATTRIBFORMAT)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset); +// typedef void (APIENTRYP GPVERTEXARRAYATTRIBIFORMAT)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset); +// typedef void (APIENTRYP GPVERTEXARRAYATTRIBLFORMAT)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset); +// typedef void (APIENTRYP GPVERTEXARRAYBINDVERTEXBUFFEREXT)(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride); +// typedef void (APIENTRYP GPVERTEXARRAYBINDINGDIVISOR)(GLuint vaobj, GLuint bindingindex, GLuint divisor); +// typedef void (APIENTRYP GPVERTEXARRAYCOLOROFFSETEXT)(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset); +// typedef void (APIENTRYP GPVERTEXARRAYEDGEFLAGOFFSETEXT)(GLuint vaobj, GLuint buffer, GLsizei stride, GLintptr offset); +// typedef void (APIENTRYP GPVERTEXARRAYELEMENTBUFFER)(GLuint vaobj, GLuint buffer); +// typedef void (APIENTRYP GPVERTEXARRAYFOGCOORDOFFSETEXT)(GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset); +// typedef void (APIENTRYP GPVERTEXARRAYINDEXOFFSETEXT)(GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset); +// typedef void (APIENTRYP GPVERTEXARRAYMULTITEXCOORDOFFSETEXT)(GLuint vaobj, GLuint buffer, GLenum texunit, GLint size, GLenum type, GLsizei stride, GLintptr offset); +// typedef void (APIENTRYP GPVERTEXARRAYNORMALOFFSETEXT)(GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset); +// typedef void (APIENTRYP GPVERTEXARRAYSECONDARYCOLOROFFSETEXT)(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset); +// typedef void (APIENTRYP GPVERTEXARRAYTEXCOORDOFFSETEXT)(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset); +// typedef void (APIENTRYP GPVERTEXARRAYVERTEXATTRIBBINDINGEXT)(GLuint vaobj, GLuint attribindex, GLuint bindingindex); +// typedef void (APIENTRYP GPVERTEXARRAYVERTEXATTRIBDIVISOREXT)(GLuint vaobj, GLuint index, GLuint divisor); +// typedef void (APIENTRYP GPVERTEXARRAYVERTEXATTRIBFORMATEXT)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset); +// typedef void (APIENTRYP GPVERTEXARRAYVERTEXATTRIBIFORMATEXT)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset); +// typedef void (APIENTRYP GPVERTEXARRAYVERTEXATTRIBIOFFSETEXT)(GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset); +// typedef void (APIENTRYP GPVERTEXARRAYVERTEXATTRIBLFORMATEXT)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset); +// typedef void (APIENTRYP GPVERTEXARRAYVERTEXATTRIBLOFFSETEXT)(GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset); +// typedef void (APIENTRYP GPVERTEXARRAYVERTEXATTRIBOFFSETEXT)(GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset); +// typedef void (APIENTRYP GPVERTEXARRAYVERTEXBINDINGDIVISOREXT)(GLuint vaobj, GLuint bindingindex, GLuint divisor); +// typedef void (APIENTRYP GPVERTEXARRAYVERTEXBUFFER)(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride); +// typedef void (APIENTRYP GPVERTEXARRAYVERTEXBUFFERS)(GLuint vaobj, GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizei * strides); +// typedef void (APIENTRYP GPVERTEXARRAYVERTEXOFFSETEXT)(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset); +// typedef void (APIENTRYP GPVERTEXATTRIB1D)(GLuint index, GLdouble x); +// typedef void (APIENTRYP GPVERTEXATTRIB1DV)(GLuint index, const GLdouble * v); +// typedef void (APIENTRYP GPVERTEXATTRIB1F)(GLuint index, GLfloat x); +// typedef void (APIENTRYP GPVERTEXATTRIB1FV)(GLuint index, const GLfloat * v); +// typedef void (APIENTRYP GPVERTEXATTRIB1S)(GLuint index, GLshort x); +// typedef void (APIENTRYP GPVERTEXATTRIB1SV)(GLuint index, const GLshort * v); +// typedef void (APIENTRYP GPVERTEXATTRIB2D)(GLuint index, GLdouble x, GLdouble y); +// typedef void (APIENTRYP GPVERTEXATTRIB2DV)(GLuint index, const GLdouble * v); +// typedef void (APIENTRYP GPVERTEXATTRIB2F)(GLuint index, GLfloat x, GLfloat y); +// typedef void (APIENTRYP GPVERTEXATTRIB2FV)(GLuint index, const GLfloat * v); +// typedef void (APIENTRYP GPVERTEXATTRIB2S)(GLuint index, GLshort x, GLshort y); +// typedef void (APIENTRYP GPVERTEXATTRIB2SV)(GLuint index, const GLshort * v); +// typedef void (APIENTRYP GPVERTEXATTRIB3D)(GLuint index, GLdouble x, GLdouble y, GLdouble z); +// typedef void (APIENTRYP GPVERTEXATTRIB3DV)(GLuint index, const GLdouble * v); +// typedef void (APIENTRYP GPVERTEXATTRIB3F)(GLuint index, GLfloat x, GLfloat y, GLfloat z); +// typedef void (APIENTRYP GPVERTEXATTRIB3FV)(GLuint index, const GLfloat * v); +// typedef void (APIENTRYP GPVERTEXATTRIB3S)(GLuint index, GLshort x, GLshort y, GLshort z); +// typedef void (APIENTRYP GPVERTEXATTRIB3SV)(GLuint index, const GLshort * v); +// typedef void (APIENTRYP GPVERTEXATTRIB4NBV)(GLuint index, const GLbyte * v); +// typedef void (APIENTRYP GPVERTEXATTRIB4NIV)(GLuint index, const GLint * v); +// typedef void (APIENTRYP GPVERTEXATTRIB4NSV)(GLuint index, const GLshort * v); +// typedef void (APIENTRYP GPVERTEXATTRIB4NUB)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +// typedef void (APIENTRYP GPVERTEXATTRIB4NUBV)(GLuint index, const GLubyte * v); +// typedef void (APIENTRYP GPVERTEXATTRIB4NUIV)(GLuint index, const GLuint * v); +// typedef void (APIENTRYP GPVERTEXATTRIB4NUSV)(GLuint index, const GLushort * v); +// typedef void (APIENTRYP GPVERTEXATTRIB4BV)(GLuint index, const GLbyte * v); +// typedef void (APIENTRYP GPVERTEXATTRIB4D)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +// typedef void (APIENTRYP GPVERTEXATTRIB4DV)(GLuint index, const GLdouble * v); +// typedef void (APIENTRYP GPVERTEXATTRIB4F)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +// typedef void (APIENTRYP GPVERTEXATTRIB4FV)(GLuint index, const GLfloat * v); +// typedef void (APIENTRYP GPVERTEXATTRIB4IV)(GLuint index, const GLint * v); +// typedef void (APIENTRYP GPVERTEXATTRIB4S)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +// typedef void (APIENTRYP GPVERTEXATTRIB4SV)(GLuint index, const GLshort * v); +// typedef void (APIENTRYP GPVERTEXATTRIB4UBV)(GLuint index, const GLubyte * v); +// typedef void (APIENTRYP GPVERTEXATTRIB4UIV)(GLuint index, const GLuint * v); +// typedef void (APIENTRYP GPVERTEXATTRIB4USV)(GLuint index, const GLushort * v); +// typedef void (APIENTRYP GPVERTEXATTRIBBINDING)(GLuint attribindex, GLuint bindingindex); +// typedef void (APIENTRYP GPVERTEXATTRIBDIVISOR)(GLuint index, GLuint divisor); +// typedef void (APIENTRYP GPVERTEXATTRIBDIVISORARB)(GLuint index, GLuint divisor); +// typedef void (APIENTRYP GPVERTEXATTRIBFORMAT)(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset); +// typedef void (APIENTRYP GPVERTEXATTRIBFORMATNV)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride); +// typedef void (APIENTRYP GPVERTEXATTRIBI1I)(GLuint index, GLint x); +// typedef void (APIENTRYP GPVERTEXATTRIBI1IV)(GLuint index, const GLint * v); +// typedef void (APIENTRYP GPVERTEXATTRIBI1UI)(GLuint index, GLuint x); +// typedef void (APIENTRYP GPVERTEXATTRIBI1UIV)(GLuint index, const GLuint * v); +// typedef void (APIENTRYP GPVERTEXATTRIBI2I)(GLuint index, GLint x, GLint y); +// typedef void (APIENTRYP GPVERTEXATTRIBI2IV)(GLuint index, const GLint * v); +// typedef void (APIENTRYP GPVERTEXATTRIBI2UI)(GLuint index, GLuint x, GLuint y); +// typedef void (APIENTRYP GPVERTEXATTRIBI2UIV)(GLuint index, const GLuint * v); +// typedef void (APIENTRYP GPVERTEXATTRIBI3I)(GLuint index, GLint x, GLint y, GLint z); +// typedef void (APIENTRYP GPVERTEXATTRIBI3IV)(GLuint index, const GLint * v); +// typedef void (APIENTRYP GPVERTEXATTRIBI3UI)(GLuint index, GLuint x, GLuint y, GLuint z); +// typedef void (APIENTRYP GPVERTEXATTRIBI3UIV)(GLuint index, const GLuint * v); +// typedef void (APIENTRYP GPVERTEXATTRIBI4BV)(GLuint index, const GLbyte * v); +// typedef void (APIENTRYP GPVERTEXATTRIBI4I)(GLuint index, GLint x, GLint y, GLint z, GLint w); +// typedef void (APIENTRYP GPVERTEXATTRIBI4IV)(GLuint index, const GLint * v); +// typedef void (APIENTRYP GPVERTEXATTRIBI4SV)(GLuint index, const GLshort * v); +// typedef void (APIENTRYP GPVERTEXATTRIBI4UBV)(GLuint index, const GLubyte * v); +// typedef void (APIENTRYP GPVERTEXATTRIBI4UI)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +// typedef void (APIENTRYP GPVERTEXATTRIBI4UIV)(GLuint index, const GLuint * v); +// typedef void (APIENTRYP GPVERTEXATTRIBI4USV)(GLuint index, const GLushort * v); +// typedef void (APIENTRYP GPVERTEXATTRIBIFORMAT)(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset); +// typedef void (APIENTRYP GPVERTEXATTRIBIFORMATNV)(GLuint index, GLint size, GLenum type, GLsizei stride); +// typedef void (APIENTRYP GPVERTEXATTRIBIPOINTER)(GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer); +// typedef void (APIENTRYP GPVERTEXATTRIBL1D)(GLuint index, GLdouble x); +// typedef void (APIENTRYP GPVERTEXATTRIBL1DV)(GLuint index, const GLdouble * v); +// typedef void (APIENTRYP GPVERTEXATTRIBL1I64NV)(GLuint index, GLint64EXT x); +// typedef void (APIENTRYP GPVERTEXATTRIBL1I64VNV)(GLuint index, const GLint64EXT * v); +// typedef void (APIENTRYP GPVERTEXATTRIBL1UI64ARB)(GLuint index, GLuint64EXT x); +// typedef void (APIENTRYP GPVERTEXATTRIBL1UI64NV)(GLuint index, GLuint64EXT x); +// typedef void (APIENTRYP GPVERTEXATTRIBL1UI64VARB)(GLuint index, const GLuint64EXT * v); +// typedef void (APIENTRYP GPVERTEXATTRIBL1UI64VNV)(GLuint index, const GLuint64EXT * v); +// typedef void (APIENTRYP GPVERTEXATTRIBL2D)(GLuint index, GLdouble x, GLdouble y); +// typedef void (APIENTRYP GPVERTEXATTRIBL2DV)(GLuint index, const GLdouble * v); +// typedef void (APIENTRYP GPVERTEXATTRIBL2I64NV)(GLuint index, GLint64EXT x, GLint64EXT y); +// typedef void (APIENTRYP GPVERTEXATTRIBL2I64VNV)(GLuint index, const GLint64EXT * v); +// typedef void (APIENTRYP GPVERTEXATTRIBL2UI64NV)(GLuint index, GLuint64EXT x, GLuint64EXT y); +// typedef void (APIENTRYP GPVERTEXATTRIBL2UI64VNV)(GLuint index, const GLuint64EXT * v); +// typedef void (APIENTRYP GPVERTEXATTRIBL3D)(GLuint index, GLdouble x, GLdouble y, GLdouble z); +// typedef void (APIENTRYP GPVERTEXATTRIBL3DV)(GLuint index, const GLdouble * v); +// typedef void (APIENTRYP GPVERTEXATTRIBL3I64NV)(GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z); +// typedef void (APIENTRYP GPVERTEXATTRIBL3I64VNV)(GLuint index, const GLint64EXT * v); +// typedef void (APIENTRYP GPVERTEXATTRIBL3UI64NV)(GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z); +// typedef void (APIENTRYP GPVERTEXATTRIBL3UI64VNV)(GLuint index, const GLuint64EXT * v); +// typedef void (APIENTRYP GPVERTEXATTRIBL4D)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +// typedef void (APIENTRYP GPVERTEXATTRIBL4DV)(GLuint index, const GLdouble * v); +// typedef void (APIENTRYP GPVERTEXATTRIBL4I64NV)(GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w); +// typedef void (APIENTRYP GPVERTEXATTRIBL4I64VNV)(GLuint index, const GLint64EXT * v); +// typedef void (APIENTRYP GPVERTEXATTRIBL4UI64NV)(GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w); +// typedef void (APIENTRYP GPVERTEXATTRIBL4UI64VNV)(GLuint index, const GLuint64EXT * v); +// typedef void (APIENTRYP GPVERTEXATTRIBLFORMAT)(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset); +// typedef void (APIENTRYP GPVERTEXATTRIBLFORMATNV)(GLuint index, GLint size, GLenum type, GLsizei stride); +// typedef void (APIENTRYP GPVERTEXATTRIBLPOINTER)(GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer); +// typedef void (APIENTRYP GPVERTEXATTRIBP1UI)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +// typedef void (APIENTRYP GPVERTEXATTRIBP1UIV)(GLuint index, GLenum type, GLboolean normalized, const GLuint * value); +// typedef void (APIENTRYP GPVERTEXATTRIBP2UI)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +// typedef void (APIENTRYP GPVERTEXATTRIBP2UIV)(GLuint index, GLenum type, GLboolean normalized, const GLuint * value); +// typedef void (APIENTRYP GPVERTEXATTRIBP3UI)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +// typedef void (APIENTRYP GPVERTEXATTRIBP3UIV)(GLuint index, GLenum type, GLboolean normalized, const GLuint * value); +// typedef void (APIENTRYP GPVERTEXATTRIBP4UI)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +// typedef void (APIENTRYP GPVERTEXATTRIBP4UIV)(GLuint index, GLenum type, GLboolean normalized, const GLuint * value); +// typedef void (APIENTRYP GPVERTEXATTRIBPOINTER)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer); +// typedef void (APIENTRYP GPVERTEXBINDINGDIVISOR)(GLuint bindingindex, GLuint divisor); +// typedef void (APIENTRYP GPVERTEXFORMATNV)(GLint size, GLenum type, GLsizei stride); +// typedef void (APIENTRYP GPVIEWPORT)(GLint x, GLint y, GLsizei width, GLsizei height); +// typedef void (APIENTRYP GPVIEWPORTARRAYV)(GLuint first, GLsizei count, const GLfloat * v); +// typedef void (APIENTRYP GPVIEWPORTINDEXEDF)(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h); +// typedef void (APIENTRYP GPVIEWPORTINDEXEDFV)(GLuint index, const GLfloat * v); +// typedef void (APIENTRYP GPVIEWPORTPOSITIONWSCALENV)(GLuint index, GLfloat xcoeff, GLfloat ycoeff); +// typedef void (APIENTRYP GPVIEWPORTSWIZZLENV)(GLuint index, GLenum swizzlex, GLenum swizzley, GLenum swizzlez, GLenum swizzlew); +// typedef void (APIENTRYP GPWAITSYNC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +// typedef void (APIENTRYP GPWAITVKSEMAPHORENV)(GLuint64 vkSemaphore); +// typedef void (APIENTRYP GPWEIGHTPATHSNV)(GLuint resultPath, GLsizei numPaths, const GLuint * paths, const GLfloat * weights); +// typedef void (APIENTRYP GPWINDOWRECTANGLESEXT)(GLenum mode, GLsizei count, const GLint * box); +// static void glowActiveProgramEXT(GPACTIVEPROGRAMEXT fnptr, GLuint program) { +// (*fnptr)(program); +// } +// static void glowActiveShaderProgram(GPACTIVESHADERPROGRAM fnptr, GLuint pipeline, GLuint program) { +// (*fnptr)(pipeline, program); +// } +// static void glowActiveShaderProgramEXT(GPACTIVESHADERPROGRAMEXT fnptr, GLuint pipeline, GLuint program) { +// (*fnptr)(pipeline, program); +// } +// static void glowActiveTexture(GPACTIVETEXTURE fnptr, GLenum texture) { +// (*fnptr)(texture); +// } +// static void glowApplyFramebufferAttachmentCMAAINTEL(GPAPPLYFRAMEBUFFERATTACHMENTCMAAINTEL fnptr) { +// (*fnptr)(); +// } +// static void glowAttachShader(GPATTACHSHADER fnptr, GLuint program, GLuint shader) { +// (*fnptr)(program, shader); +// } +// static void glowBeginConditionalRender(GPBEGINCONDITIONALRENDER fnptr, GLuint id, GLenum mode) { +// (*fnptr)(id, mode); +// } +// static void glowBeginConditionalRenderNV(GPBEGINCONDITIONALRENDERNV fnptr, GLuint id, GLenum mode) { +// (*fnptr)(id, mode); +// } +// static void glowBeginPerfMonitorAMD(GPBEGINPERFMONITORAMD fnptr, GLuint monitor) { +// (*fnptr)(monitor); +// } +// static void glowBeginPerfQueryINTEL(GPBEGINPERFQUERYINTEL fnptr, GLuint queryHandle) { +// (*fnptr)(queryHandle); +// } +// static void glowBeginQuery(GPBEGINQUERY fnptr, GLenum target, GLuint id) { +// (*fnptr)(target, id); +// } +// static void glowBeginQueryIndexed(GPBEGINQUERYINDEXED fnptr, GLenum target, GLuint index, GLuint id) { +// (*fnptr)(target, index, id); +// } +// static void glowBeginTransformFeedback(GPBEGINTRANSFORMFEEDBACK fnptr, GLenum primitiveMode) { +// (*fnptr)(primitiveMode); +// } +// static void glowBindAttribLocation(GPBINDATTRIBLOCATION fnptr, GLuint program, GLuint index, const GLchar * name) { +// (*fnptr)(program, index, name); +// } +// static void glowBindBuffer(GPBINDBUFFER fnptr, GLenum target, GLuint buffer) { +// (*fnptr)(target, buffer); +// } +// static void glowBindBufferBase(GPBINDBUFFERBASE fnptr, GLenum target, GLuint index, GLuint buffer) { +// (*fnptr)(target, index, buffer); +// } +// static void glowBindBufferRange(GPBINDBUFFERRANGE fnptr, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) { +// (*fnptr)(target, index, buffer, offset, size); +// } +// static void glowBindBuffersBase(GPBINDBUFFERSBASE fnptr, GLenum target, GLuint first, GLsizei count, const GLuint * buffers) { +// (*fnptr)(target, first, count, buffers); +// } +// static void glowBindBuffersRange(GPBINDBUFFERSRANGE fnptr, GLenum target, GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizeiptr * sizes) { +// (*fnptr)(target, first, count, buffers, offsets, sizes); +// } +// static void glowBindFragDataLocation(GPBINDFRAGDATALOCATION fnptr, GLuint program, GLuint color, const GLchar * name) { +// (*fnptr)(program, color, name); +// } +// static void glowBindFragDataLocationIndexed(GPBINDFRAGDATALOCATIONINDEXED fnptr, GLuint program, GLuint colorNumber, GLuint index, const GLchar * name) { +// (*fnptr)(program, colorNumber, index, name); +// } +// static void glowBindFramebuffer(GPBINDFRAMEBUFFER fnptr, GLenum target, GLuint framebuffer) { +// (*fnptr)(target, framebuffer); +// } +// static void glowBindImageTexture(GPBINDIMAGETEXTURE fnptr, GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format) { +// (*fnptr)(unit, texture, level, layered, layer, access, format); +// } +// static void glowBindImageTextures(GPBINDIMAGETEXTURES fnptr, GLuint first, GLsizei count, const GLuint * textures) { +// (*fnptr)(first, count, textures); +// } +// static void glowBindMultiTextureEXT(GPBINDMULTITEXTUREEXT fnptr, GLenum texunit, GLenum target, GLuint texture) { +// (*fnptr)(texunit, target, texture); +// } +// static void glowBindProgramPipeline(GPBINDPROGRAMPIPELINE fnptr, GLuint pipeline) { +// (*fnptr)(pipeline); +// } +// static void glowBindProgramPipelineEXT(GPBINDPROGRAMPIPELINEEXT fnptr, GLuint pipeline) { +// (*fnptr)(pipeline); +// } +// static void glowBindRenderbuffer(GPBINDRENDERBUFFER fnptr, GLenum target, GLuint renderbuffer) { +// (*fnptr)(target, renderbuffer); +// } +// static void glowBindSampler(GPBINDSAMPLER fnptr, GLuint unit, GLuint sampler) { +// (*fnptr)(unit, sampler); +// } +// static void glowBindSamplers(GPBINDSAMPLERS fnptr, GLuint first, GLsizei count, const GLuint * samplers) { +// (*fnptr)(first, count, samplers); +// } +// static void glowBindShadingRateImageNV(GPBINDSHADINGRATEIMAGENV fnptr, GLuint texture) { +// (*fnptr)(texture); +// } +// static void glowBindTexture(GPBINDTEXTURE fnptr, GLenum target, GLuint texture) { +// (*fnptr)(target, texture); +// } +// static void glowBindTextureUnit(GPBINDTEXTUREUNIT fnptr, GLuint unit, GLuint texture) { +// (*fnptr)(unit, texture); +// } +// static void glowBindTextures(GPBINDTEXTURES fnptr, GLuint first, GLsizei count, const GLuint * textures) { +// (*fnptr)(first, count, textures); +// } +// static void glowBindTransformFeedback(GPBINDTRANSFORMFEEDBACK fnptr, GLenum target, GLuint id) { +// (*fnptr)(target, id); +// } +// static void glowBindVertexArray(GPBINDVERTEXARRAY fnptr, GLuint array) { +// (*fnptr)(array); +// } +// static void glowBindVertexBuffer(GPBINDVERTEXBUFFER fnptr, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride) { +// (*fnptr)(bindingindex, buffer, offset, stride); +// } +// static void glowBindVertexBuffers(GPBINDVERTEXBUFFERS fnptr, GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizei * strides) { +// (*fnptr)(first, count, buffers, offsets, strides); +// } +// static void glowBlendBarrierKHR(GPBLENDBARRIERKHR fnptr) { +// (*fnptr)(); +// } +// static void glowBlendBarrierNV(GPBLENDBARRIERNV fnptr) { +// (*fnptr)(); +// } +// static void glowBlendColor(GPBLENDCOLOR fnptr, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { +// (*fnptr)(red, green, blue, alpha); +// } +// static void glowBlendEquation(GPBLENDEQUATION fnptr, GLenum mode) { +// (*fnptr)(mode); +// } +// static void glowBlendEquationSeparate(GPBLENDEQUATIONSEPARATE fnptr, GLenum modeRGB, GLenum modeAlpha) { +// (*fnptr)(modeRGB, modeAlpha); +// } +// static void glowBlendEquationSeparateiARB(GPBLENDEQUATIONSEPARATEIARB fnptr, GLuint buf, GLenum modeRGB, GLenum modeAlpha) { +// (*fnptr)(buf, modeRGB, modeAlpha); +// } +// static void glowBlendEquationiARB(GPBLENDEQUATIONIARB fnptr, GLuint buf, GLenum mode) { +// (*fnptr)(buf, mode); +// } +// static void glowBlendFunc(GPBLENDFUNC fnptr, GLenum sfactor, GLenum dfactor) { +// (*fnptr)(sfactor, dfactor); +// } +// static void glowBlendFuncSeparate(GPBLENDFUNCSEPARATE fnptr, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) { +// (*fnptr)(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +// } +// static void glowBlendFuncSeparateiARB(GPBLENDFUNCSEPARATEIARB fnptr, GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) { +// (*fnptr)(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); +// } +// static void glowBlendFunciARB(GPBLENDFUNCIARB fnptr, GLuint buf, GLenum src, GLenum dst) { +// (*fnptr)(buf, src, dst); +// } +// static void glowBlendParameteriNV(GPBLENDPARAMETERINV fnptr, GLenum pname, GLint value) { +// (*fnptr)(pname, value); +// } +// static void glowBlitFramebuffer(GPBLITFRAMEBUFFER fnptr, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) { +// (*fnptr)(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); +// } +// static void glowBlitNamedFramebuffer(GPBLITNAMEDFRAMEBUFFER fnptr, GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) { +// (*fnptr)(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); +// } +// static void glowBufferAddressRangeNV(GPBUFFERADDRESSRANGENV fnptr, GLenum pname, GLuint index, GLuint64EXT address, GLsizeiptr length) { +// (*fnptr)(pname, index, address, length); +// } +// static void glowBufferAttachMemoryNV(GPBUFFERATTACHMEMORYNV fnptr, GLenum target, GLuint memory, GLuint64 offset) { +// (*fnptr)(target, memory, offset); +// } +// static void glowBufferData(GPBUFFERDATA fnptr, GLenum target, GLsizeiptr size, const void * data, GLenum usage) { +// (*fnptr)(target, size, data, usage); +// } +// static void glowBufferPageCommitmentARB(GPBUFFERPAGECOMMITMENTARB fnptr, GLenum target, GLintptr offset, GLsizeiptr size, GLboolean commit) { +// (*fnptr)(target, offset, size, commit); +// } +// static void glowBufferPageCommitmentMemNV(GPBUFFERPAGECOMMITMENTMEMNV fnptr, GLenum target, GLintptr offset, GLsizeiptr size, GLuint memory, GLuint64 memOffset, GLboolean commit) { +// (*fnptr)(target, offset, size, memory, memOffset, commit); +// } +// static void glowBufferStorage(GPBUFFERSTORAGE fnptr, GLenum target, GLsizeiptr size, const void * data, GLbitfield flags) { +// (*fnptr)(target, size, data, flags); +// } +// static void glowBufferSubData(GPBUFFERSUBDATA fnptr, GLenum target, GLintptr offset, GLsizeiptr size, const void * data) { +// (*fnptr)(target, offset, size, data); +// } +// static void glowCallCommandListNV(GPCALLCOMMANDLISTNV fnptr, GLuint list) { +// (*fnptr)(list); +// } +// static GLenum glowCheckFramebufferStatus(GPCHECKFRAMEBUFFERSTATUS fnptr, GLenum target) { +// return (*fnptr)(target); +// } +// static GLenum glowCheckNamedFramebufferStatus(GPCHECKNAMEDFRAMEBUFFERSTATUS fnptr, GLuint framebuffer, GLenum target) { +// return (*fnptr)(framebuffer, target); +// } +// static GLenum glowCheckNamedFramebufferStatusEXT(GPCHECKNAMEDFRAMEBUFFERSTATUSEXT fnptr, GLuint framebuffer, GLenum target) { +// return (*fnptr)(framebuffer, target); +// } +// static void glowClampColor(GPCLAMPCOLOR fnptr, GLenum target, GLenum clamp) { +// (*fnptr)(target, clamp); +// } +// static void glowClear(GPCLEAR fnptr, GLbitfield mask) { +// (*fnptr)(mask); +// } +// static void glowClearBufferData(GPCLEARBUFFERDATA fnptr, GLenum target, GLenum internalformat, GLenum format, GLenum type, const void * data) { +// (*fnptr)(target, internalformat, format, type, data); +// } +// static void glowClearBufferSubData(GPCLEARBUFFERSUBDATA fnptr, GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data) { +// (*fnptr)(target, internalformat, offset, size, format, type, data); +// } +// static void glowClearBufferfi(GPCLEARBUFFERFI fnptr, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) { +// (*fnptr)(buffer, drawbuffer, depth, stencil); +// } +// static void glowClearBufferfv(GPCLEARBUFFERFV fnptr, GLenum buffer, GLint drawbuffer, const GLfloat * value) { +// (*fnptr)(buffer, drawbuffer, value); +// } +// static void glowClearBufferiv(GPCLEARBUFFERIV fnptr, GLenum buffer, GLint drawbuffer, const GLint * value) { +// (*fnptr)(buffer, drawbuffer, value); +// } +// static void glowClearBufferuiv(GPCLEARBUFFERUIV fnptr, GLenum buffer, GLint drawbuffer, const GLuint * value) { +// (*fnptr)(buffer, drawbuffer, value); +// } +// static void glowClearColor(GPCLEARCOLOR fnptr, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { +// (*fnptr)(red, green, blue, alpha); +// } +// static void glowClearDepth(GPCLEARDEPTH fnptr, GLdouble depth) { +// (*fnptr)(depth); +// } +// static void glowClearDepthdNV(GPCLEARDEPTHDNV fnptr, GLdouble depth) { +// (*fnptr)(depth); +// } +// static void glowClearDepthf(GPCLEARDEPTHF fnptr, GLfloat d) { +// (*fnptr)(d); +// } +// static void glowClearNamedBufferData(GPCLEARNAMEDBUFFERDATA fnptr, GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void * data) { +// (*fnptr)(buffer, internalformat, format, type, data); +// } +// static void glowClearNamedBufferDataEXT(GPCLEARNAMEDBUFFERDATAEXT fnptr, GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void * data) { +// (*fnptr)(buffer, internalformat, format, type, data); +// } +// static void glowClearNamedBufferSubData(GPCLEARNAMEDBUFFERSUBDATA fnptr, GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data) { +// (*fnptr)(buffer, internalformat, offset, size, format, type, data); +// } +// static void glowClearNamedBufferSubDataEXT(GPCLEARNAMEDBUFFERSUBDATAEXT fnptr, GLuint buffer, GLenum internalformat, GLsizeiptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data) { +// (*fnptr)(buffer, internalformat, offset, size, format, type, data); +// } +// static void glowClearNamedFramebufferfi(GPCLEARNAMEDFRAMEBUFFERFI fnptr, GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) { +// (*fnptr)(framebuffer, buffer, drawbuffer, depth, stencil); +// } +// static void glowClearNamedFramebufferfv(GPCLEARNAMEDFRAMEBUFFERFV fnptr, GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat * value) { +// (*fnptr)(framebuffer, buffer, drawbuffer, value); +// } +// static void glowClearNamedFramebufferiv(GPCLEARNAMEDFRAMEBUFFERIV fnptr, GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint * value) { +// (*fnptr)(framebuffer, buffer, drawbuffer, value); +// } +// static void glowClearNamedFramebufferuiv(GPCLEARNAMEDFRAMEBUFFERUIV fnptr, GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint * value) { +// (*fnptr)(framebuffer, buffer, drawbuffer, value); +// } +// static void glowClearStencil(GPCLEARSTENCIL fnptr, GLint s) { +// (*fnptr)(s); +// } +// static void glowClearTexImage(GPCLEARTEXIMAGE fnptr, GLuint texture, GLint level, GLenum format, GLenum type, const void * data) { +// (*fnptr)(texture, level, format, type, data); +// } +// static void glowClearTexSubImage(GPCLEARTEXSUBIMAGE fnptr, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data) { +// (*fnptr)(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data); +// } +// static void glowClientAttribDefaultEXT(GPCLIENTATTRIBDEFAULTEXT fnptr, GLbitfield mask) { +// (*fnptr)(mask); +// } +// static GLenum glowClientWaitSync(GPCLIENTWAITSYNC fnptr, GLsync sync, GLbitfield flags, GLuint64 timeout) { +// return (*fnptr)(sync, flags, timeout); +// } +// static void glowClipControl(GPCLIPCONTROL fnptr, GLenum origin, GLenum depth) { +// (*fnptr)(origin, depth); +// } +// static void glowColorFormatNV(GPCOLORFORMATNV fnptr, GLint size, GLenum type, GLsizei stride) { +// (*fnptr)(size, type, stride); +// } +// static void glowColorMask(GPCOLORMASK fnptr, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { +// (*fnptr)(red, green, blue, alpha); +// } +// static void glowColorMaski(GPCOLORMASKI fnptr, GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) { +// (*fnptr)(index, r, g, b, a); +// } +// static void glowCommandListSegmentsNV(GPCOMMANDLISTSEGMENTSNV fnptr, GLuint list, GLuint segments) { +// (*fnptr)(list, segments); +// } +// static void glowCompileCommandListNV(GPCOMPILECOMMANDLISTNV fnptr, GLuint list) { +// (*fnptr)(list); +// } +// static void glowCompileShader(GPCOMPILESHADER fnptr, GLuint shader) { +// (*fnptr)(shader); +// } +// static void glowCompileShaderIncludeARB(GPCOMPILESHADERINCLUDEARB fnptr, GLuint shader, GLsizei count, const GLchar *const* path, const GLint * length) { +// (*fnptr)(shader, count, path, length); +// } +// static void glowCompressedMultiTexImage1DEXT(GPCOMPRESSEDMULTITEXIMAGE1DEXT fnptr, GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * bits) { +// (*fnptr)(texunit, target, level, internalformat, width, border, imageSize, bits); +// } +// static void glowCompressedMultiTexImage2DEXT(GPCOMPRESSEDMULTITEXIMAGE2DEXT fnptr, GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * bits) { +// (*fnptr)(texunit, target, level, internalformat, width, height, border, imageSize, bits); +// } +// static void glowCompressedMultiTexImage3DEXT(GPCOMPRESSEDMULTITEXIMAGE3DEXT fnptr, GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * bits) { +// (*fnptr)(texunit, target, level, internalformat, width, height, depth, border, imageSize, bits); +// } +// static void glowCompressedMultiTexSubImage1DEXT(GPCOMPRESSEDMULTITEXSUBIMAGE1DEXT fnptr, GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * bits) { +// (*fnptr)(texunit, target, level, xoffset, width, format, imageSize, bits); +// } +// static void glowCompressedMultiTexSubImage2DEXT(GPCOMPRESSEDMULTITEXSUBIMAGE2DEXT fnptr, GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * bits) { +// (*fnptr)(texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits); +// } +// static void glowCompressedMultiTexSubImage3DEXT(GPCOMPRESSEDMULTITEXSUBIMAGE3DEXT fnptr, GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * bits) { +// (*fnptr)(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits); +// } +// static void glowCompressedTexImage1D(GPCOMPRESSEDTEXIMAGE1D fnptr, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data) { +// (*fnptr)(target, level, internalformat, width, border, imageSize, data); +// } +// static void glowCompressedTexImage2D(GPCOMPRESSEDTEXIMAGE2D fnptr, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data) { +// (*fnptr)(target, level, internalformat, width, height, border, imageSize, data); +// } +// static void glowCompressedTexImage3D(GPCOMPRESSEDTEXIMAGE3D fnptr, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data) { +// (*fnptr)(target, level, internalformat, width, height, depth, border, imageSize, data); +// } +// static void glowCompressedTexSubImage1D(GPCOMPRESSEDTEXSUBIMAGE1D fnptr, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data) { +// (*fnptr)(target, level, xoffset, width, format, imageSize, data); +// } +// static void glowCompressedTexSubImage2D(GPCOMPRESSEDTEXSUBIMAGE2D fnptr, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data) { +// (*fnptr)(target, level, xoffset, yoffset, width, height, format, imageSize, data); +// } +// static void glowCompressedTexSubImage3D(GPCOMPRESSEDTEXSUBIMAGE3D fnptr, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data) { +// (*fnptr)(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +// } +// static void glowCompressedTextureImage1DEXT(GPCOMPRESSEDTEXTUREIMAGE1DEXT fnptr, GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * bits) { +// (*fnptr)(texture, target, level, internalformat, width, border, imageSize, bits); +// } +// static void glowCompressedTextureImage2DEXT(GPCOMPRESSEDTEXTUREIMAGE2DEXT fnptr, GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * bits) { +// (*fnptr)(texture, target, level, internalformat, width, height, border, imageSize, bits); +// } +// static void glowCompressedTextureImage3DEXT(GPCOMPRESSEDTEXTUREIMAGE3DEXT fnptr, GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * bits) { +// (*fnptr)(texture, target, level, internalformat, width, height, depth, border, imageSize, bits); +// } +// static void glowCompressedTextureSubImage1D(GPCOMPRESSEDTEXTURESUBIMAGE1D fnptr, GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data) { +// (*fnptr)(texture, level, xoffset, width, format, imageSize, data); +// } +// static void glowCompressedTextureSubImage1DEXT(GPCOMPRESSEDTEXTURESUBIMAGE1DEXT fnptr, GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * bits) { +// (*fnptr)(texture, target, level, xoffset, width, format, imageSize, bits); +// } +// static void glowCompressedTextureSubImage2D(GPCOMPRESSEDTEXTURESUBIMAGE2D fnptr, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data) { +// (*fnptr)(texture, level, xoffset, yoffset, width, height, format, imageSize, data); +// } +// static void glowCompressedTextureSubImage2DEXT(GPCOMPRESSEDTEXTURESUBIMAGE2DEXT fnptr, GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * bits) { +// (*fnptr)(texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits); +// } +// static void glowCompressedTextureSubImage3D(GPCOMPRESSEDTEXTURESUBIMAGE3D fnptr, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data) { +// (*fnptr)(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); +// } +// static void glowCompressedTextureSubImage3DEXT(GPCOMPRESSEDTEXTURESUBIMAGE3DEXT fnptr, GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * bits) { +// (*fnptr)(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits); +// } +// static void glowConservativeRasterParameterfNV(GPCONSERVATIVERASTERPARAMETERFNV fnptr, GLenum pname, GLfloat value) { +// (*fnptr)(pname, value); +// } +// static void glowConservativeRasterParameteriNV(GPCONSERVATIVERASTERPARAMETERINV fnptr, GLenum pname, GLint param) { +// (*fnptr)(pname, param); +// } +// static void glowCopyBufferSubData(GPCOPYBUFFERSUBDATA fnptr, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) { +// (*fnptr)(readTarget, writeTarget, readOffset, writeOffset, size); +// } +// static void glowCopyImageSubData(GPCOPYIMAGESUBDATA fnptr, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth) { +// (*fnptr)(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth); +// } +// static void glowCopyMultiTexImage1DEXT(GPCOPYMULTITEXIMAGE1DEXT fnptr, GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) { +// (*fnptr)(texunit, target, level, internalformat, x, y, width, border); +// } +// static void glowCopyMultiTexImage2DEXT(GPCOPYMULTITEXIMAGE2DEXT fnptr, GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { +// (*fnptr)(texunit, target, level, internalformat, x, y, width, height, border); +// } +// static void glowCopyMultiTexSubImage1DEXT(GPCOPYMULTITEXSUBIMAGE1DEXT fnptr, GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) { +// (*fnptr)(texunit, target, level, xoffset, x, y, width); +// } +// static void glowCopyMultiTexSubImage2DEXT(GPCOPYMULTITEXSUBIMAGE2DEXT fnptr, GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { +// (*fnptr)(texunit, target, level, xoffset, yoffset, x, y, width, height); +// } +// static void glowCopyMultiTexSubImage3DEXT(GPCOPYMULTITEXSUBIMAGE3DEXT fnptr, GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { +// (*fnptr)(texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height); +// } +// static void glowCopyNamedBufferSubData(GPCOPYNAMEDBUFFERSUBDATA fnptr, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) { +// (*fnptr)(readBuffer, writeBuffer, readOffset, writeOffset, size); +// } +// static void glowCopyPathNV(GPCOPYPATHNV fnptr, GLuint resultPath, GLuint srcPath) { +// (*fnptr)(resultPath, srcPath); +// } +// static void glowCopyTexImage1D(GPCOPYTEXIMAGE1D fnptr, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) { +// (*fnptr)(target, level, internalformat, x, y, width, border); +// } +// static void glowCopyTexImage2D(GPCOPYTEXIMAGE2D fnptr, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { +// (*fnptr)(target, level, internalformat, x, y, width, height, border); +// } +// static void glowCopyTexSubImage1D(GPCOPYTEXSUBIMAGE1D fnptr, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) { +// (*fnptr)(target, level, xoffset, x, y, width); +// } +// static void glowCopyTexSubImage2D(GPCOPYTEXSUBIMAGE2D fnptr, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { +// (*fnptr)(target, level, xoffset, yoffset, x, y, width, height); +// } +// static void glowCopyTexSubImage3D(GPCOPYTEXSUBIMAGE3D fnptr, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { +// (*fnptr)(target, level, xoffset, yoffset, zoffset, x, y, width, height); +// } +// static void glowCopyTextureImage1DEXT(GPCOPYTEXTUREIMAGE1DEXT fnptr, GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) { +// (*fnptr)(texture, target, level, internalformat, x, y, width, border); +// } +// static void glowCopyTextureImage2DEXT(GPCOPYTEXTUREIMAGE2DEXT fnptr, GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { +// (*fnptr)(texture, target, level, internalformat, x, y, width, height, border); +// } +// static void glowCopyTextureSubImage1D(GPCOPYTEXTURESUBIMAGE1D fnptr, GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) { +// (*fnptr)(texture, level, xoffset, x, y, width); +// } +// static void glowCopyTextureSubImage1DEXT(GPCOPYTEXTURESUBIMAGE1DEXT fnptr, GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) { +// (*fnptr)(texture, target, level, xoffset, x, y, width); +// } +// static void glowCopyTextureSubImage2D(GPCOPYTEXTURESUBIMAGE2D fnptr, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { +// (*fnptr)(texture, level, xoffset, yoffset, x, y, width, height); +// } +// static void glowCopyTextureSubImage2DEXT(GPCOPYTEXTURESUBIMAGE2DEXT fnptr, GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { +// (*fnptr)(texture, target, level, xoffset, yoffset, x, y, width, height); +// } +// static void glowCopyTextureSubImage3D(GPCOPYTEXTURESUBIMAGE3D fnptr, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { +// (*fnptr)(texture, level, xoffset, yoffset, zoffset, x, y, width, height); +// } +// static void glowCopyTextureSubImage3DEXT(GPCOPYTEXTURESUBIMAGE3DEXT fnptr, GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { +// (*fnptr)(texture, target, level, xoffset, yoffset, zoffset, x, y, width, height); +// } +// static void glowCoverFillPathInstancedNV(GPCOVERFILLPATHINSTANCEDNV fnptr, GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat * transformValues) { +// (*fnptr)(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues); +// } +// static void glowCoverFillPathNV(GPCOVERFILLPATHNV fnptr, GLuint path, GLenum coverMode) { +// (*fnptr)(path, coverMode); +// } +// static void glowCoverStrokePathInstancedNV(GPCOVERSTROKEPATHINSTANCEDNV fnptr, GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat * transformValues) { +// (*fnptr)(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues); +// } +// static void glowCoverStrokePathNV(GPCOVERSTROKEPATHNV fnptr, GLuint path, GLenum coverMode) { +// (*fnptr)(path, coverMode); +// } +// static void glowCoverageModulationNV(GPCOVERAGEMODULATIONNV fnptr, GLenum components) { +// (*fnptr)(components); +// } +// static void glowCoverageModulationTableNV(GPCOVERAGEMODULATIONTABLENV fnptr, GLsizei n, const GLfloat * v) { +// (*fnptr)(n, v); +// } +// static void glowCreateBuffers(GPCREATEBUFFERS fnptr, GLsizei n, GLuint * buffers) { +// (*fnptr)(n, buffers); +// } +// static void glowCreateCommandListsNV(GPCREATECOMMANDLISTSNV fnptr, GLsizei n, GLuint * lists) { +// (*fnptr)(n, lists); +// } +// static void glowCreateFramebuffers(GPCREATEFRAMEBUFFERS fnptr, GLsizei n, GLuint * framebuffers) { +// (*fnptr)(n, framebuffers); +// } +// static void glowCreatePerfQueryINTEL(GPCREATEPERFQUERYINTEL fnptr, GLuint queryId, GLuint * queryHandle) { +// (*fnptr)(queryId, queryHandle); +// } +// static GLuint glowCreateProgram(GPCREATEPROGRAM fnptr) { +// return (*fnptr)(); +// } +// static void glowCreateProgramPipelines(GPCREATEPROGRAMPIPELINES fnptr, GLsizei n, GLuint * pipelines) { +// (*fnptr)(n, pipelines); +// } +// static void glowCreateQueries(GPCREATEQUERIES fnptr, GLenum target, GLsizei n, GLuint * ids) { +// (*fnptr)(target, n, ids); +// } +// static void glowCreateRenderbuffers(GPCREATERENDERBUFFERS fnptr, GLsizei n, GLuint * renderbuffers) { +// (*fnptr)(n, renderbuffers); +// } +// static void glowCreateSamplers(GPCREATESAMPLERS fnptr, GLsizei n, GLuint * samplers) { +// (*fnptr)(n, samplers); +// } +// static GLuint glowCreateShader(GPCREATESHADER fnptr, GLenum type) { +// return (*fnptr)(type); +// } +// static GLuint glowCreateShaderProgramEXT(GPCREATESHADERPROGRAMEXT fnptr, GLenum type, const GLchar * string) { +// return (*fnptr)(type, string); +// } +// static GLuint glowCreateShaderProgramv(GPCREATESHADERPROGRAMV fnptr, GLenum type, GLsizei count, const GLchar *const* strings) { +// return (*fnptr)(type, count, strings); +// } +// static GLuint glowCreateShaderProgramvEXT(GPCREATESHADERPROGRAMVEXT fnptr, GLenum type, GLsizei count, const GLchar ** strings) { +// return (*fnptr)(type, count, strings); +// } +// static void glowCreateStatesNV(GPCREATESTATESNV fnptr, GLsizei n, GLuint * states) { +// (*fnptr)(n, states); +// } +// static GLsync glowCreateSyncFromCLeventARB(GPCREATESYNCFROMCLEVENTARB fnptr, struct _cl_context * context, struct _cl_event * event, GLbitfield flags) { +// return (*fnptr)(context, event, flags); +// } +// static void glowCreateTextures(GPCREATETEXTURES fnptr, GLenum target, GLsizei n, GLuint * textures) { +// (*fnptr)(target, n, textures); +// } +// static void glowCreateTransformFeedbacks(GPCREATETRANSFORMFEEDBACKS fnptr, GLsizei n, GLuint * ids) { +// (*fnptr)(n, ids); +// } +// static void glowCreateVertexArrays(GPCREATEVERTEXARRAYS fnptr, GLsizei n, GLuint * arrays) { +// (*fnptr)(n, arrays); +// } +// static void glowCullFace(GPCULLFACE fnptr, GLenum mode) { +// (*fnptr)(mode); +// } +// static void glowDebugMessageCallback(GPDEBUGMESSAGECALLBACK fnptr, GLDEBUGPROC callback, const void * userParam) { +// (*fnptr)(glowCDebugCallback, userParam); +// } +// static void glowDebugMessageCallbackARB(GPDEBUGMESSAGECALLBACKARB fnptr, GLDEBUGPROCARB callback, const void * userParam) { +// (*fnptr)(glowCDebugCallback, userParam); +// } +// static void glowDebugMessageCallbackKHR(GPDEBUGMESSAGECALLBACKKHR fnptr, GLDEBUGPROCKHR callback, const void * userParam) { +// (*fnptr)(glowCDebugCallback, userParam); +// } +// static void glowDebugMessageControl(GPDEBUGMESSAGECONTROL fnptr, GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint * ids, GLboolean enabled) { +// (*fnptr)(source, type, severity, count, ids, enabled); +// } +// static void glowDebugMessageControlARB(GPDEBUGMESSAGECONTROLARB fnptr, GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint * ids, GLboolean enabled) { +// (*fnptr)(source, type, severity, count, ids, enabled); +// } +// static void glowDebugMessageControlKHR(GPDEBUGMESSAGECONTROLKHR fnptr, GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint * ids, GLboolean enabled) { +// (*fnptr)(source, type, severity, count, ids, enabled); +// } +// static void glowDebugMessageInsert(GPDEBUGMESSAGEINSERT fnptr, GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar * buf) { +// (*fnptr)(source, type, id, severity, length, buf); +// } +// static void glowDebugMessageInsertARB(GPDEBUGMESSAGEINSERTARB fnptr, GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar * buf) { +// (*fnptr)(source, type, id, severity, length, buf); +// } +// static void glowDebugMessageInsertKHR(GPDEBUGMESSAGEINSERTKHR fnptr, GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar * buf) { +// (*fnptr)(source, type, id, severity, length, buf); +// } +// static void glowDeleteBuffers(GPDELETEBUFFERS fnptr, GLsizei n, const GLuint * buffers) { +// (*fnptr)(n, buffers); +// } +// static void glowDeleteCommandListsNV(GPDELETECOMMANDLISTSNV fnptr, GLsizei n, const GLuint * lists) { +// (*fnptr)(n, lists); +// } +// static void glowDeleteFramebuffers(GPDELETEFRAMEBUFFERS fnptr, GLsizei n, const GLuint * framebuffers) { +// (*fnptr)(n, framebuffers); +// } +// static void glowDeleteNamedStringARB(GPDELETENAMEDSTRINGARB fnptr, GLint namelen, const GLchar * name) { +// (*fnptr)(namelen, name); +// } +// static void glowDeletePathsNV(GPDELETEPATHSNV fnptr, GLuint path, GLsizei range) { +// (*fnptr)(path, range); +// } +// static void glowDeletePerfMonitorsAMD(GPDELETEPERFMONITORSAMD fnptr, GLsizei n, GLuint * monitors) { +// (*fnptr)(n, monitors); +// } +// static void glowDeletePerfQueryINTEL(GPDELETEPERFQUERYINTEL fnptr, GLuint queryHandle) { +// (*fnptr)(queryHandle); +// } +// static void glowDeleteProgram(GPDELETEPROGRAM fnptr, GLuint program) { +// (*fnptr)(program); +// } +// static void glowDeleteProgramPipelines(GPDELETEPROGRAMPIPELINES fnptr, GLsizei n, const GLuint * pipelines) { +// (*fnptr)(n, pipelines); +// } +// static void glowDeleteProgramPipelinesEXT(GPDELETEPROGRAMPIPELINESEXT fnptr, GLsizei n, const GLuint * pipelines) { +// (*fnptr)(n, pipelines); +// } +// static void glowDeleteQueries(GPDELETEQUERIES fnptr, GLsizei n, const GLuint * ids) { +// (*fnptr)(n, ids); +// } +// static void glowDeleteRenderbuffers(GPDELETERENDERBUFFERS fnptr, GLsizei n, const GLuint * renderbuffers) { +// (*fnptr)(n, renderbuffers); +// } +// static void glowDeleteSamplers(GPDELETESAMPLERS fnptr, GLsizei count, const GLuint * samplers) { +// (*fnptr)(count, samplers); +// } +// static void glowDeleteShader(GPDELETESHADER fnptr, GLuint shader) { +// (*fnptr)(shader); +// } +// static void glowDeleteStatesNV(GPDELETESTATESNV fnptr, GLsizei n, const GLuint * states) { +// (*fnptr)(n, states); +// } +// static void glowDeleteSync(GPDELETESYNC fnptr, GLsync sync) { +// (*fnptr)(sync); +// } +// static void glowDeleteTextures(GPDELETETEXTURES fnptr, GLsizei n, const GLuint * textures) { +// (*fnptr)(n, textures); +// } +// static void glowDeleteTransformFeedbacks(GPDELETETRANSFORMFEEDBACKS fnptr, GLsizei n, const GLuint * ids) { +// (*fnptr)(n, ids); +// } +// static void glowDeleteVertexArrays(GPDELETEVERTEXARRAYS fnptr, GLsizei n, const GLuint * arrays) { +// (*fnptr)(n, arrays); +// } +// static void glowDepthBoundsdNV(GPDEPTHBOUNDSDNV fnptr, GLdouble zmin, GLdouble zmax) { +// (*fnptr)(zmin, zmax); +// } +// static void glowDepthFunc(GPDEPTHFUNC fnptr, GLenum func) { +// (*fnptr)(func); +// } +// static void glowDepthMask(GPDEPTHMASK fnptr, GLboolean flag) { +// (*fnptr)(flag); +// } +// static void glowDepthRange(GPDEPTHRANGE fnptr, GLdouble n, GLdouble f) { +// (*fnptr)(n, f); +// } +// static void glowDepthRangeArraydvNV(GPDEPTHRANGEARRAYDVNV fnptr, GLuint first, GLsizei count, const GLdouble * v) { +// (*fnptr)(first, count, v); +// } +// static void glowDepthRangeArrayv(GPDEPTHRANGEARRAYV fnptr, GLuint first, GLsizei count, const GLdouble * v) { +// (*fnptr)(first, count, v); +// } +// static void glowDepthRangeIndexed(GPDEPTHRANGEINDEXED fnptr, GLuint index, GLdouble n, GLdouble f) { +// (*fnptr)(index, n, f); +// } +// static void glowDepthRangeIndexeddNV(GPDEPTHRANGEINDEXEDDNV fnptr, GLuint index, GLdouble n, GLdouble f) { +// (*fnptr)(index, n, f); +// } +// static void glowDepthRangedNV(GPDEPTHRANGEDNV fnptr, GLdouble zNear, GLdouble zFar) { +// (*fnptr)(zNear, zFar); +// } +// static void glowDepthRangef(GPDEPTHRANGEF fnptr, GLfloat n, GLfloat f) { +// (*fnptr)(n, f); +// } +// static void glowDetachShader(GPDETACHSHADER fnptr, GLuint program, GLuint shader) { +// (*fnptr)(program, shader); +// } +// static void glowDisable(GPDISABLE fnptr, GLenum cap) { +// (*fnptr)(cap); +// } +// static void glowDisableClientStateIndexedEXT(GPDISABLECLIENTSTATEINDEXEDEXT fnptr, GLenum array, GLuint index) { +// (*fnptr)(array, index); +// } +// static void glowDisableClientStateiEXT(GPDISABLECLIENTSTATEIEXT fnptr, GLenum array, GLuint index) { +// (*fnptr)(array, index); +// } +// static void glowDisableIndexedEXT(GPDISABLEINDEXEDEXT fnptr, GLenum target, GLuint index) { +// (*fnptr)(target, index); +// } +// static void glowDisableVertexArrayAttrib(GPDISABLEVERTEXARRAYATTRIB fnptr, GLuint vaobj, GLuint index) { +// (*fnptr)(vaobj, index); +// } +// static void glowDisableVertexArrayAttribEXT(GPDISABLEVERTEXARRAYATTRIBEXT fnptr, GLuint vaobj, GLuint index) { +// (*fnptr)(vaobj, index); +// } +// static void glowDisableVertexArrayEXT(GPDISABLEVERTEXARRAYEXT fnptr, GLuint vaobj, GLenum array) { +// (*fnptr)(vaobj, array); +// } +// static void glowDisableVertexAttribArray(GPDISABLEVERTEXATTRIBARRAY fnptr, GLuint index) { +// (*fnptr)(index); +// } +// static void glowDisablei(GPDISABLEI fnptr, GLenum target, GLuint index) { +// (*fnptr)(target, index); +// } +// static void glowDispatchCompute(GPDISPATCHCOMPUTE fnptr, GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z) { +// (*fnptr)(num_groups_x, num_groups_y, num_groups_z); +// } +// static void glowDispatchComputeGroupSizeARB(GPDISPATCHCOMPUTEGROUPSIZEARB fnptr, GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z, GLuint group_size_x, GLuint group_size_y, GLuint group_size_z) { +// (*fnptr)(num_groups_x, num_groups_y, num_groups_z, group_size_x, group_size_y, group_size_z); +// } +// static void glowDispatchComputeIndirect(GPDISPATCHCOMPUTEINDIRECT fnptr, GLintptr indirect) { +// (*fnptr)(indirect); +// } +// static void glowDrawArrays(GPDRAWARRAYS fnptr, GLenum mode, GLint first, GLsizei count) { +// (*fnptr)(mode, first, count); +// } +// static void glowDrawArraysIndirect(GPDRAWARRAYSINDIRECT fnptr, GLenum mode, const void * indirect) { +// (*fnptr)(mode, indirect); +// } +// static void glowDrawArraysInstanced(GPDRAWARRAYSINSTANCED fnptr, GLenum mode, GLint first, GLsizei count, GLsizei instancecount) { +// (*fnptr)(mode, first, count, instancecount); +// } +// static void glowDrawArraysInstancedARB(GPDRAWARRAYSINSTANCEDARB fnptr, GLenum mode, GLint first, GLsizei count, GLsizei primcount) { +// (*fnptr)(mode, first, count, primcount); +// } +// static void glowDrawArraysInstancedBaseInstance(GPDRAWARRAYSINSTANCEDBASEINSTANCE fnptr, GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance) { +// (*fnptr)(mode, first, count, instancecount, baseinstance); +// } +// static void glowDrawArraysInstancedEXT(GPDRAWARRAYSINSTANCEDEXT fnptr, GLenum mode, GLint start, GLsizei count, GLsizei primcount) { +// (*fnptr)(mode, start, count, primcount); +// } +// static void glowDrawBuffer(GPDRAWBUFFER fnptr, GLenum buf) { +// (*fnptr)(buf); +// } +// static void glowDrawBuffers(GPDRAWBUFFERS fnptr, GLsizei n, const GLenum * bufs) { +// (*fnptr)(n, bufs); +// } +// static void glowDrawCommandsAddressNV(GPDRAWCOMMANDSADDRESSNV fnptr, GLenum primitiveMode, const GLuint64 * indirects, const GLsizei * sizes, GLuint count) { +// (*fnptr)(primitiveMode, indirects, sizes, count); +// } +// static void glowDrawCommandsNV(GPDRAWCOMMANDSNV fnptr, GLenum primitiveMode, GLuint buffer, const GLintptr * indirects, const GLsizei * sizes, GLuint count) { +// (*fnptr)(primitiveMode, buffer, indirects, sizes, count); +// } +// static void glowDrawCommandsStatesAddressNV(GPDRAWCOMMANDSSTATESADDRESSNV fnptr, const GLuint64 * indirects, const GLsizei * sizes, const GLuint * states, const GLuint * fbos, GLuint count) { +// (*fnptr)(indirects, sizes, states, fbos, count); +// } +// static void glowDrawCommandsStatesNV(GPDRAWCOMMANDSSTATESNV fnptr, GLuint buffer, const GLintptr * indirects, const GLsizei * sizes, const GLuint * states, const GLuint * fbos, GLuint count) { +// (*fnptr)(buffer, indirects, sizes, states, fbos, count); +// } +// static void glowDrawElements(GPDRAWELEMENTS fnptr, GLenum mode, GLsizei count, GLenum type, const void * indices) { +// (*fnptr)(mode, count, type, indices); +// } +// static void glowDrawElementsWithOffset(GPDRAWELEMENTS fnptr, GLenum mode, GLsizei count, GLenum type, uintptr_t indices) { +// (*fnptr)(mode, count, type, (const void *)(indices)); +// } +// static void glowDrawElementsBaseVertex(GPDRAWELEMENTSBASEVERTEX fnptr, GLenum mode, GLsizei count, GLenum type, const void * indices, GLint basevertex) { +// (*fnptr)(mode, count, type, indices, basevertex); +// } +// static void glowDrawElementsBaseVertexWithOffset(GPDRAWELEMENTSBASEVERTEX fnptr, GLenum mode, GLsizei count, GLenum type, uintptr_t indices, GLint basevertex) { +// (*fnptr)(mode, count, type, (const void *)(indices), basevertex); +// } +// static void glowDrawElementsIndirect(GPDRAWELEMENTSINDIRECT fnptr, GLenum mode, GLenum type, const void * indirect) { +// (*fnptr)(mode, type, indirect); +// } +// static void glowDrawElementsInstanced(GPDRAWELEMENTSINSTANCED fnptr, GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount) { +// (*fnptr)(mode, count, type, indices, instancecount); +// } +// static void glowDrawElementsInstancedARB(GPDRAWELEMENTSINSTANCEDARB fnptr, GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei primcount) { +// (*fnptr)(mode, count, type, indices, primcount); +// } +// static void glowDrawElementsInstancedBaseInstance(GPDRAWELEMENTSINSTANCEDBASEINSTANCE fnptr, GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLuint baseinstance) { +// (*fnptr)(mode, count, type, indices, instancecount, baseinstance); +// } +// static void glowDrawElementsInstancedBaseVertex(GPDRAWELEMENTSINSTANCEDBASEVERTEX fnptr, GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex) { +// (*fnptr)(mode, count, type, indices, instancecount, basevertex); +// } +// static void glowDrawElementsInstancedBaseVertexBaseInstance(GPDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCE fnptr, GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance) { +// (*fnptr)(mode, count, type, indices, instancecount, basevertex, baseinstance); +// } +// static void glowDrawElementsInstancedEXT(GPDRAWELEMENTSINSTANCEDEXT fnptr, GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei primcount) { +// (*fnptr)(mode, count, type, indices, primcount); +// } +// static void glowDrawMeshTasksIndirectNV(GPDRAWMESHTASKSINDIRECTNV fnptr, GLintptr indirect) { +// (*fnptr)(indirect); +// } +// static void glowDrawMeshTasksNV(GPDRAWMESHTASKSNV fnptr, GLuint first, GLuint count) { +// (*fnptr)(first, count); +// } +// static void glowDrawRangeElements(GPDRAWRANGEELEMENTS fnptr, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices) { +// (*fnptr)(mode, start, end, count, type, indices); +// } +// static void glowDrawRangeElementsBaseVertex(GPDRAWRANGEELEMENTSBASEVERTEX fnptr, GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices, GLint basevertex) { +// (*fnptr)(mode, start, end, count, type, indices, basevertex); +// } +// static void glowDrawTransformFeedback(GPDRAWTRANSFORMFEEDBACK fnptr, GLenum mode, GLuint id) { +// (*fnptr)(mode, id); +// } +// static void glowDrawTransformFeedbackInstanced(GPDRAWTRANSFORMFEEDBACKINSTANCED fnptr, GLenum mode, GLuint id, GLsizei instancecount) { +// (*fnptr)(mode, id, instancecount); +// } +// static void glowDrawTransformFeedbackStream(GPDRAWTRANSFORMFEEDBACKSTREAM fnptr, GLenum mode, GLuint id, GLuint stream) { +// (*fnptr)(mode, id, stream); +// } +// static void glowDrawTransformFeedbackStreamInstanced(GPDRAWTRANSFORMFEEDBACKSTREAMINSTANCED fnptr, GLenum mode, GLuint id, GLuint stream, GLsizei instancecount) { +// (*fnptr)(mode, id, stream, instancecount); +// } +// static void glowDrawVkImageNV(GPDRAWVKIMAGENV fnptr, GLuint64 vkImage, GLuint sampler, GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1, GLfloat z, GLfloat s0, GLfloat t0, GLfloat s1, GLfloat t1) { +// (*fnptr)(vkImage, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1); +// } +// static void glowEGLImageTargetTexStorageEXT(GPEGLIMAGETARGETTEXSTORAGEEXT fnptr, GLenum target, GLeglImageOES image, const GLint* attrib_list) { +// (*fnptr)(target, image, attrib_list); +// } +// static void glowEGLImageTargetTextureStorageEXT(GPEGLIMAGETARGETTEXTURESTORAGEEXT fnptr, GLuint texture, GLeglImageOES image, const GLint* attrib_list) { +// (*fnptr)(texture, image, attrib_list); +// } +// static void glowEdgeFlagFormatNV(GPEDGEFLAGFORMATNV fnptr, GLsizei stride) { +// (*fnptr)(stride); +// } +// static void glowEnable(GPENABLE fnptr, GLenum cap) { +// (*fnptr)(cap); +// } +// static void glowEnableClientStateIndexedEXT(GPENABLECLIENTSTATEINDEXEDEXT fnptr, GLenum array, GLuint index) { +// (*fnptr)(array, index); +// } +// static void glowEnableClientStateiEXT(GPENABLECLIENTSTATEIEXT fnptr, GLenum array, GLuint index) { +// (*fnptr)(array, index); +// } +// static void glowEnableIndexedEXT(GPENABLEINDEXEDEXT fnptr, GLenum target, GLuint index) { +// (*fnptr)(target, index); +// } +// static void glowEnableVertexArrayAttrib(GPENABLEVERTEXARRAYATTRIB fnptr, GLuint vaobj, GLuint index) { +// (*fnptr)(vaobj, index); +// } +// static void glowEnableVertexArrayAttribEXT(GPENABLEVERTEXARRAYATTRIBEXT fnptr, GLuint vaobj, GLuint index) { +// (*fnptr)(vaobj, index); +// } +// static void glowEnableVertexArrayEXT(GPENABLEVERTEXARRAYEXT fnptr, GLuint vaobj, GLenum array) { +// (*fnptr)(vaobj, array); +// } +// static void glowEnableVertexAttribArray(GPENABLEVERTEXATTRIBARRAY fnptr, GLuint index) { +// (*fnptr)(index); +// } +// static void glowEnablei(GPENABLEI fnptr, GLenum target, GLuint index) { +// (*fnptr)(target, index); +// } +// static void glowEndConditionalRender(GPENDCONDITIONALRENDER fnptr) { +// (*fnptr)(); +// } +// static void glowEndConditionalRenderNV(GPENDCONDITIONALRENDERNV fnptr) { +// (*fnptr)(); +// } +// static void glowEndPerfMonitorAMD(GPENDPERFMONITORAMD fnptr, GLuint monitor) { +// (*fnptr)(monitor); +// } +// static void glowEndPerfQueryINTEL(GPENDPERFQUERYINTEL fnptr, GLuint queryHandle) { +// (*fnptr)(queryHandle); +// } +// static void glowEndQuery(GPENDQUERY fnptr, GLenum target) { +// (*fnptr)(target); +// } +// static void glowEndQueryIndexed(GPENDQUERYINDEXED fnptr, GLenum target, GLuint index) { +// (*fnptr)(target, index); +// } +// static void glowEndTransformFeedback(GPENDTRANSFORMFEEDBACK fnptr) { +// (*fnptr)(); +// } +// static void glowEvaluateDepthValuesARB(GPEVALUATEDEPTHVALUESARB fnptr) { +// (*fnptr)(); +// } +// static GLsync glowFenceSync(GPFENCESYNC fnptr, GLenum condition, GLbitfield flags) { +// return (*fnptr)(condition, flags); +// } +// static void glowFinish(GPFINISH fnptr) { +// (*fnptr)(); +// } +// static void glowFlush(GPFLUSH fnptr) { +// (*fnptr)(); +// } +// static void glowFlushMappedBufferRange(GPFLUSHMAPPEDBUFFERRANGE fnptr, GLenum target, GLintptr offset, GLsizeiptr length) { +// (*fnptr)(target, offset, length); +// } +// static void glowFlushMappedNamedBufferRange(GPFLUSHMAPPEDNAMEDBUFFERRANGE fnptr, GLuint buffer, GLintptr offset, GLsizeiptr length) { +// (*fnptr)(buffer, offset, length); +// } +// static void glowFlushMappedNamedBufferRangeEXT(GPFLUSHMAPPEDNAMEDBUFFERRANGEEXT fnptr, GLuint buffer, GLintptr offset, GLsizeiptr length) { +// (*fnptr)(buffer, offset, length); +// } +// static void glowFogCoordFormatNV(GPFOGCOORDFORMATNV fnptr, GLenum type, GLsizei stride) { +// (*fnptr)(type, stride); +// } +// static void glowFragmentCoverageColorNV(GPFRAGMENTCOVERAGECOLORNV fnptr, GLuint color) { +// (*fnptr)(color); +// } +// static void glowFramebufferDrawBufferEXT(GPFRAMEBUFFERDRAWBUFFEREXT fnptr, GLuint framebuffer, GLenum mode) { +// (*fnptr)(framebuffer, mode); +// } +// static void glowFramebufferDrawBuffersEXT(GPFRAMEBUFFERDRAWBUFFERSEXT fnptr, GLuint framebuffer, GLsizei n, const GLenum * bufs) { +// (*fnptr)(framebuffer, n, bufs); +// } +// static void glowFramebufferFetchBarrierEXT(GPFRAMEBUFFERFETCHBARRIEREXT fnptr) { +// (*fnptr)(); +// } +// static void glowFramebufferParameteri(GPFRAMEBUFFERPARAMETERI fnptr, GLenum target, GLenum pname, GLint param) { +// (*fnptr)(target, pname, param); +// } +// static void glowFramebufferParameteriMESA(GPFRAMEBUFFERPARAMETERIMESA fnptr, GLenum target, GLenum pname, GLint param) { +// (*fnptr)(target, pname, param); +// } +// static void glowFramebufferReadBufferEXT(GPFRAMEBUFFERREADBUFFEREXT fnptr, GLuint framebuffer, GLenum mode) { +// (*fnptr)(framebuffer, mode); +// } +// static void glowFramebufferRenderbuffer(GPFRAMEBUFFERRENDERBUFFER fnptr, GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { +// (*fnptr)(target, attachment, renderbuffertarget, renderbuffer); +// } +// static void glowFramebufferSampleLocationsfvARB(GPFRAMEBUFFERSAMPLELOCATIONSFVARB fnptr, GLenum target, GLuint start, GLsizei count, const GLfloat * v) { +// (*fnptr)(target, start, count, v); +// } +// static void glowFramebufferSampleLocationsfvNV(GPFRAMEBUFFERSAMPLELOCATIONSFVNV fnptr, GLenum target, GLuint start, GLsizei count, const GLfloat * v) { +// (*fnptr)(target, start, count, v); +// } +// static void glowFramebufferTexture(GPFRAMEBUFFERTEXTURE fnptr, GLenum target, GLenum attachment, GLuint texture, GLint level) { +// (*fnptr)(target, attachment, texture, level); +// } +// static void glowFramebufferTexture1D(GPFRAMEBUFFERTEXTURE1D fnptr, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { +// (*fnptr)(target, attachment, textarget, texture, level); +// } +// static void glowFramebufferTexture2D(GPFRAMEBUFFERTEXTURE2D fnptr, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { +// (*fnptr)(target, attachment, textarget, texture, level); +// } +// static void glowFramebufferTexture3D(GPFRAMEBUFFERTEXTURE3D fnptr, GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) { +// (*fnptr)(target, attachment, textarget, texture, level, zoffset); +// } +// static void glowFramebufferTextureARB(GPFRAMEBUFFERTEXTUREARB fnptr, GLenum target, GLenum attachment, GLuint texture, GLint level) { +// (*fnptr)(target, attachment, texture, level); +// } +// static void glowFramebufferTextureFaceARB(GPFRAMEBUFFERTEXTUREFACEARB fnptr, GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face) { +// (*fnptr)(target, attachment, texture, level, face); +// } +// static void glowFramebufferTextureLayer(GPFRAMEBUFFERTEXTURELAYER fnptr, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) { +// (*fnptr)(target, attachment, texture, level, layer); +// } +// static void glowFramebufferTextureLayerARB(GPFRAMEBUFFERTEXTURELAYERARB fnptr, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) { +// (*fnptr)(target, attachment, texture, level, layer); +// } +// static void glowFramebufferTextureMultiviewOVR(GPFRAMEBUFFERTEXTUREMULTIVIEWOVR fnptr, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews) { +// (*fnptr)(target, attachment, texture, level, baseViewIndex, numViews); +// } +// static void glowFrontFace(GPFRONTFACE fnptr, GLenum mode) { +// (*fnptr)(mode); +// } +// static void glowGenBuffers(GPGENBUFFERS fnptr, GLsizei n, GLuint * buffers) { +// (*fnptr)(n, buffers); +// } +// static void glowGenFramebuffers(GPGENFRAMEBUFFERS fnptr, GLsizei n, GLuint * framebuffers) { +// (*fnptr)(n, framebuffers); +// } +// static GLuint glowGenPathsNV(GPGENPATHSNV fnptr, GLsizei range) { +// return (*fnptr)(range); +// } +// static void glowGenPerfMonitorsAMD(GPGENPERFMONITORSAMD fnptr, GLsizei n, GLuint * monitors) { +// (*fnptr)(n, monitors); +// } +// static void glowGenProgramPipelines(GPGENPROGRAMPIPELINES fnptr, GLsizei n, GLuint * pipelines) { +// (*fnptr)(n, pipelines); +// } +// static void glowGenProgramPipelinesEXT(GPGENPROGRAMPIPELINESEXT fnptr, GLsizei n, GLuint * pipelines) { +// (*fnptr)(n, pipelines); +// } +// static void glowGenQueries(GPGENQUERIES fnptr, GLsizei n, GLuint * ids) { +// (*fnptr)(n, ids); +// } +// static void glowGenRenderbuffers(GPGENRENDERBUFFERS fnptr, GLsizei n, GLuint * renderbuffers) { +// (*fnptr)(n, renderbuffers); +// } +// static void glowGenSamplers(GPGENSAMPLERS fnptr, GLsizei count, GLuint * samplers) { +// (*fnptr)(count, samplers); +// } +// static void glowGenTextures(GPGENTEXTURES fnptr, GLsizei n, GLuint * textures) { +// (*fnptr)(n, textures); +// } +// static void glowGenTransformFeedbacks(GPGENTRANSFORMFEEDBACKS fnptr, GLsizei n, GLuint * ids) { +// (*fnptr)(n, ids); +// } +// static void glowGenVertexArrays(GPGENVERTEXARRAYS fnptr, GLsizei n, GLuint * arrays) { +// (*fnptr)(n, arrays); +// } +// static void glowGenerateMipmap(GPGENERATEMIPMAP fnptr, GLenum target) { +// (*fnptr)(target); +// } +// static void glowGenerateMultiTexMipmapEXT(GPGENERATEMULTITEXMIPMAPEXT fnptr, GLenum texunit, GLenum target) { +// (*fnptr)(texunit, target); +// } +// static void glowGenerateTextureMipmap(GPGENERATETEXTUREMIPMAP fnptr, GLuint texture) { +// (*fnptr)(texture); +// } +// static void glowGenerateTextureMipmapEXT(GPGENERATETEXTUREMIPMAPEXT fnptr, GLuint texture, GLenum target) { +// (*fnptr)(texture, target); +// } +// static void glowGetActiveAtomicCounterBufferiv(GPGETACTIVEATOMICCOUNTERBUFFERIV fnptr, GLuint program, GLuint bufferIndex, GLenum pname, GLint * params) { +// (*fnptr)(program, bufferIndex, pname, params); +// } +// static void glowGetActiveAttrib(GPGETACTIVEATTRIB fnptr, GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name) { +// (*fnptr)(program, index, bufSize, length, size, type, name); +// } +// static void glowGetActiveSubroutineName(GPGETACTIVESUBROUTINENAME fnptr, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei * length, GLchar * name) { +// (*fnptr)(program, shadertype, index, bufSize, length, name); +// } +// static void glowGetActiveSubroutineUniformName(GPGETACTIVESUBROUTINEUNIFORMNAME fnptr, GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei * length, GLchar * name) { +// (*fnptr)(program, shadertype, index, bufSize, length, name); +// } +// static void glowGetActiveSubroutineUniformiv(GPGETACTIVESUBROUTINEUNIFORMIV fnptr, GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint * values) { +// (*fnptr)(program, shadertype, index, pname, values); +// } +// static void glowGetActiveUniform(GPGETACTIVEUNIFORM fnptr, GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name) { +// (*fnptr)(program, index, bufSize, length, size, type, name); +// } +// static void glowGetActiveUniformBlockName(GPGETACTIVEUNIFORMBLOCKNAME fnptr, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformBlockName) { +// (*fnptr)(program, uniformBlockIndex, bufSize, length, uniformBlockName); +// } +// static void glowGetActiveUniformBlockiv(GPGETACTIVEUNIFORMBLOCKIV fnptr, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint * params) { +// (*fnptr)(program, uniformBlockIndex, pname, params); +// } +// static void glowGetActiveUniformName(GPGETACTIVEUNIFORMNAME fnptr, GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformName) { +// (*fnptr)(program, uniformIndex, bufSize, length, uniformName); +// } +// static void glowGetActiveUniformsiv(GPGETACTIVEUNIFORMSIV fnptr, GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint * params) { +// (*fnptr)(program, uniformCount, uniformIndices, pname, params); +// } +// static void glowGetAttachedShaders(GPGETATTACHEDSHADERS fnptr, GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders) { +// (*fnptr)(program, maxCount, count, shaders); +// } +// static GLint glowGetAttribLocation(GPGETATTRIBLOCATION fnptr, GLuint program, const GLchar * name) { +// return (*fnptr)(program, name); +// } +// static void glowGetBooleanIndexedvEXT(GPGETBOOLEANINDEXEDVEXT fnptr, GLenum target, GLuint index, GLboolean * data) { +// (*fnptr)(target, index, data); +// } +// static void glowGetBooleani_v(GPGETBOOLEANI_V fnptr, GLenum target, GLuint index, GLboolean * data) { +// (*fnptr)(target, index, data); +// } +// static void glowGetBooleanv(GPGETBOOLEANV fnptr, GLenum pname, GLboolean * data) { +// (*fnptr)(pname, data); +// } +// static void glowGetBufferParameteri64v(GPGETBUFFERPARAMETERI64V fnptr, GLenum target, GLenum pname, GLint64 * params) { +// (*fnptr)(target, pname, params); +// } +// static void glowGetBufferParameteriv(GPGETBUFFERPARAMETERIV fnptr, GLenum target, GLenum pname, GLint * params) { +// (*fnptr)(target, pname, params); +// } +// static void glowGetBufferParameterui64vNV(GPGETBUFFERPARAMETERUI64VNV fnptr, GLenum target, GLenum pname, GLuint64EXT * params) { +// (*fnptr)(target, pname, params); +// } +// static void glowGetBufferPointerv(GPGETBUFFERPOINTERV fnptr, GLenum target, GLenum pname, void ** params) { +// (*fnptr)(target, pname, params); +// } +// static void glowGetBufferSubData(GPGETBUFFERSUBDATA fnptr, GLenum target, GLintptr offset, GLsizeiptr size, void * data) { +// (*fnptr)(target, offset, size, data); +// } +// static GLuint glowGetCommandHeaderNV(GPGETCOMMANDHEADERNV fnptr, GLenum tokenID, GLuint size) { +// return (*fnptr)(tokenID, size); +// } +// static void glowGetCompressedMultiTexImageEXT(GPGETCOMPRESSEDMULTITEXIMAGEEXT fnptr, GLenum texunit, GLenum target, GLint lod, void * img) { +// (*fnptr)(texunit, target, lod, img); +// } +// static void glowGetCompressedTexImage(GPGETCOMPRESSEDTEXIMAGE fnptr, GLenum target, GLint level, void * img) { +// (*fnptr)(target, level, img); +// } +// static void glowGetCompressedTextureImage(GPGETCOMPRESSEDTEXTUREIMAGE fnptr, GLuint texture, GLint level, GLsizei bufSize, void * pixels) { +// (*fnptr)(texture, level, bufSize, pixels); +// } +// static void glowGetCompressedTextureImageEXT(GPGETCOMPRESSEDTEXTUREIMAGEEXT fnptr, GLuint texture, GLenum target, GLint lod, void * img) { +// (*fnptr)(texture, target, lod, img); +// } +// static void glowGetCompressedTextureSubImage(GPGETCOMPRESSEDTEXTURESUBIMAGE fnptr, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void * pixels) { +// (*fnptr)(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels); +// } +// static void glowGetCoverageModulationTableNV(GPGETCOVERAGEMODULATIONTABLENV fnptr, GLsizei bufSize, GLfloat * v) { +// (*fnptr)(bufSize, v); +// } +// static GLuint glowGetDebugMessageLog(GPGETDEBUGMESSAGELOG fnptr, GLuint count, GLsizei bufSize, GLenum * sources, GLenum * types, GLuint * ids, GLenum * severities, GLsizei * lengths, GLchar * messageLog) { +// return (*fnptr)(count, bufSize, sources, types, ids, severities, lengths, messageLog); +// } +// static GLuint glowGetDebugMessageLogARB(GPGETDEBUGMESSAGELOGARB fnptr, GLuint count, GLsizei bufSize, GLenum * sources, GLenum * types, GLuint * ids, GLenum * severities, GLsizei * lengths, GLchar * messageLog) { +// return (*fnptr)(count, bufSize, sources, types, ids, severities, lengths, messageLog); +// } +// static GLuint glowGetDebugMessageLogKHR(GPGETDEBUGMESSAGELOGKHR fnptr, GLuint count, GLsizei bufSize, GLenum * sources, GLenum * types, GLuint * ids, GLenum * severities, GLsizei * lengths, GLchar * messageLog) { +// return (*fnptr)(count, bufSize, sources, types, ids, severities, lengths, messageLog); +// } +// static void glowGetDoubleIndexedvEXT(GPGETDOUBLEINDEXEDVEXT fnptr, GLenum target, GLuint index, GLdouble * data) { +// (*fnptr)(target, index, data); +// } +// static void glowGetDoublei_v(GPGETDOUBLEI_V fnptr, GLenum target, GLuint index, GLdouble * data) { +// (*fnptr)(target, index, data); +// } +// static void glowGetDoublei_vEXT(GPGETDOUBLEI_VEXT fnptr, GLenum pname, GLuint index, GLdouble * params) { +// (*fnptr)(pname, index, params); +// } +// static void glowGetDoublev(GPGETDOUBLEV fnptr, GLenum pname, GLdouble * data) { +// (*fnptr)(pname, data); +// } +// static GLenum glowGetError(GPGETERROR fnptr) { +// return (*fnptr)(); +// } +// static void glowGetFirstPerfQueryIdINTEL(GPGETFIRSTPERFQUERYIDINTEL fnptr, GLuint * queryId) { +// (*fnptr)(queryId); +// } +// static void glowGetFloatIndexedvEXT(GPGETFLOATINDEXEDVEXT fnptr, GLenum target, GLuint index, GLfloat * data) { +// (*fnptr)(target, index, data); +// } +// static void glowGetFloati_v(GPGETFLOATI_V fnptr, GLenum target, GLuint index, GLfloat * data) { +// (*fnptr)(target, index, data); +// } +// static void glowGetFloati_vEXT(GPGETFLOATI_VEXT fnptr, GLenum pname, GLuint index, GLfloat * params) { +// (*fnptr)(pname, index, params); +// } +// static void glowGetFloatv(GPGETFLOATV fnptr, GLenum pname, GLfloat * data) { +// (*fnptr)(pname, data); +// } +// static GLint glowGetFragDataIndex(GPGETFRAGDATAINDEX fnptr, GLuint program, const GLchar * name) { +// return (*fnptr)(program, name); +// } +// static GLint glowGetFragDataLocation(GPGETFRAGDATALOCATION fnptr, GLuint program, const GLchar * name) { +// return (*fnptr)(program, name); +// } +// static void glowGetFramebufferAttachmentParameteriv(GPGETFRAMEBUFFERATTACHMENTPARAMETERIV fnptr, GLenum target, GLenum attachment, GLenum pname, GLint * params) { +// (*fnptr)(target, attachment, pname, params); +// } +// static void glowGetFramebufferParameteriv(GPGETFRAMEBUFFERPARAMETERIV fnptr, GLenum target, GLenum pname, GLint * params) { +// (*fnptr)(target, pname, params); +// } +// static void glowGetFramebufferParameterivEXT(GPGETFRAMEBUFFERPARAMETERIVEXT fnptr, GLuint framebuffer, GLenum pname, GLint * params) { +// (*fnptr)(framebuffer, pname, params); +// } +// static void glowGetFramebufferParameterivMESA(GPGETFRAMEBUFFERPARAMETERIVMESA fnptr, GLenum target, GLenum pname, GLint * params) { +// (*fnptr)(target, pname, params); +// } +// static GLenum glowGetGraphicsResetStatus(GPGETGRAPHICSRESETSTATUS fnptr) { +// return (*fnptr)(); +// } +// static GLenum glowGetGraphicsResetStatusARB(GPGETGRAPHICSRESETSTATUSARB fnptr) { +// return (*fnptr)(); +// } +// static GLenum glowGetGraphicsResetStatusKHR(GPGETGRAPHICSRESETSTATUSKHR fnptr) { +// return (*fnptr)(); +// } +// static GLuint64 glowGetImageHandleARB(GPGETIMAGEHANDLEARB fnptr, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format) { +// return (*fnptr)(texture, level, layered, layer, format); +// } +// static GLuint64 glowGetImageHandleNV(GPGETIMAGEHANDLENV fnptr, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format) { +// return (*fnptr)(texture, level, layered, layer, format); +// } +// static void glowGetInteger64i_v(GPGETINTEGER64I_V fnptr, GLenum target, GLuint index, GLint64 * data) { +// (*fnptr)(target, index, data); +// } +// static void glowGetInteger64v(GPGETINTEGER64V fnptr, GLenum pname, GLint64 * data) { +// (*fnptr)(pname, data); +// } +// static void glowGetIntegerIndexedvEXT(GPGETINTEGERINDEXEDVEXT fnptr, GLenum target, GLuint index, GLint * data) { +// (*fnptr)(target, index, data); +// } +// static void glowGetIntegeri_v(GPGETINTEGERI_V fnptr, GLenum target, GLuint index, GLint * data) { +// (*fnptr)(target, index, data); +// } +// static void glowGetIntegerui64i_vNV(GPGETINTEGERUI64I_VNV fnptr, GLenum value, GLuint index, GLuint64EXT * result) { +// (*fnptr)(value, index, result); +// } +// static void glowGetIntegerui64vNV(GPGETINTEGERUI64VNV fnptr, GLenum value, GLuint64EXT * result) { +// (*fnptr)(value, result); +// } +// static void glowGetIntegerv(GPGETINTEGERV fnptr, GLenum pname, GLint * data) { +// (*fnptr)(pname, data); +// } +// static void glowGetInternalformatSampleivNV(GPGETINTERNALFORMATSAMPLEIVNV fnptr, GLenum target, GLenum internalformat, GLsizei samples, GLenum pname, GLsizei count, GLint * params) { +// (*fnptr)(target, internalformat, samples, pname, count, params); +// } +// static void glowGetInternalformati64v(GPGETINTERNALFORMATI64V fnptr, GLenum target, GLenum internalformat, GLenum pname, GLsizei count, GLint64 * params) { +// (*fnptr)(target, internalformat, pname, count, params); +// } +// static void glowGetInternalformativ(GPGETINTERNALFORMATIV fnptr, GLenum target, GLenum internalformat, GLenum pname, GLsizei count, GLint * params) { +// (*fnptr)(target, internalformat, pname, count, params); +// } +// static void glowGetMemoryObjectDetachedResourcesuivNV(GPGETMEMORYOBJECTDETACHEDRESOURCESUIVNV fnptr, GLuint memory, GLenum pname, GLint first, GLsizei count, GLuint * params) { +// (*fnptr)(memory, pname, first, count, params); +// } +// static void glowGetMultiTexEnvfvEXT(GPGETMULTITEXENVFVEXT fnptr, GLenum texunit, GLenum target, GLenum pname, GLfloat * params) { +// (*fnptr)(texunit, target, pname, params); +// } +// static void glowGetMultiTexEnvivEXT(GPGETMULTITEXENVIVEXT fnptr, GLenum texunit, GLenum target, GLenum pname, GLint * params) { +// (*fnptr)(texunit, target, pname, params); +// } +// static void glowGetMultiTexGendvEXT(GPGETMULTITEXGENDVEXT fnptr, GLenum texunit, GLenum coord, GLenum pname, GLdouble * params) { +// (*fnptr)(texunit, coord, pname, params); +// } +// static void glowGetMultiTexGenfvEXT(GPGETMULTITEXGENFVEXT fnptr, GLenum texunit, GLenum coord, GLenum pname, GLfloat * params) { +// (*fnptr)(texunit, coord, pname, params); +// } +// static void glowGetMultiTexGenivEXT(GPGETMULTITEXGENIVEXT fnptr, GLenum texunit, GLenum coord, GLenum pname, GLint * params) { +// (*fnptr)(texunit, coord, pname, params); +// } +// static void glowGetMultiTexImageEXT(GPGETMULTITEXIMAGEEXT fnptr, GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void * pixels) { +// (*fnptr)(texunit, target, level, format, type, pixels); +// } +// static void glowGetMultiTexLevelParameterfvEXT(GPGETMULTITEXLEVELPARAMETERFVEXT fnptr, GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat * params) { +// (*fnptr)(texunit, target, level, pname, params); +// } +// static void glowGetMultiTexLevelParameterivEXT(GPGETMULTITEXLEVELPARAMETERIVEXT fnptr, GLenum texunit, GLenum target, GLint level, GLenum pname, GLint * params) { +// (*fnptr)(texunit, target, level, pname, params); +// } +// static void glowGetMultiTexParameterIivEXT(GPGETMULTITEXPARAMETERIIVEXT fnptr, GLenum texunit, GLenum target, GLenum pname, GLint * params) { +// (*fnptr)(texunit, target, pname, params); +// } +// static void glowGetMultiTexParameterIuivEXT(GPGETMULTITEXPARAMETERIUIVEXT fnptr, GLenum texunit, GLenum target, GLenum pname, GLuint * params) { +// (*fnptr)(texunit, target, pname, params); +// } +// static void glowGetMultiTexParameterfvEXT(GPGETMULTITEXPARAMETERFVEXT fnptr, GLenum texunit, GLenum target, GLenum pname, GLfloat * params) { +// (*fnptr)(texunit, target, pname, params); +// } +// static void glowGetMultiTexParameterivEXT(GPGETMULTITEXPARAMETERIVEXT fnptr, GLenum texunit, GLenum target, GLenum pname, GLint * params) { +// (*fnptr)(texunit, target, pname, params); +// } +// static void glowGetMultisamplefv(GPGETMULTISAMPLEFV fnptr, GLenum pname, GLuint index, GLfloat * val) { +// (*fnptr)(pname, index, val); +// } +// static void glowGetNamedBufferParameteri64v(GPGETNAMEDBUFFERPARAMETERI64V fnptr, GLuint buffer, GLenum pname, GLint64 * params) { +// (*fnptr)(buffer, pname, params); +// } +// static void glowGetNamedBufferParameteriv(GPGETNAMEDBUFFERPARAMETERIV fnptr, GLuint buffer, GLenum pname, GLint * params) { +// (*fnptr)(buffer, pname, params); +// } +// static void glowGetNamedBufferParameterivEXT(GPGETNAMEDBUFFERPARAMETERIVEXT fnptr, GLuint buffer, GLenum pname, GLint * params) { +// (*fnptr)(buffer, pname, params); +// } +// static void glowGetNamedBufferParameterui64vNV(GPGETNAMEDBUFFERPARAMETERUI64VNV fnptr, GLuint buffer, GLenum pname, GLuint64EXT * params) { +// (*fnptr)(buffer, pname, params); +// } +// static void glowGetNamedBufferPointerv(GPGETNAMEDBUFFERPOINTERV fnptr, GLuint buffer, GLenum pname, void ** params) { +// (*fnptr)(buffer, pname, params); +// } +// static void glowGetNamedBufferPointervEXT(GPGETNAMEDBUFFERPOINTERVEXT fnptr, GLuint buffer, GLenum pname, void ** params) { +// (*fnptr)(buffer, pname, params); +// } +// static void glowGetNamedBufferSubData(GPGETNAMEDBUFFERSUBDATA fnptr, GLuint buffer, GLintptr offset, GLsizeiptr size, void * data) { +// (*fnptr)(buffer, offset, size, data); +// } +// static void glowGetNamedBufferSubDataEXT(GPGETNAMEDBUFFERSUBDATAEXT fnptr, GLuint buffer, GLintptr offset, GLsizeiptr size, void * data) { +// (*fnptr)(buffer, offset, size, data); +// } +// static void glowGetNamedFramebufferAttachmentParameteriv(GPGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIV fnptr, GLuint framebuffer, GLenum attachment, GLenum pname, GLint * params) { +// (*fnptr)(framebuffer, attachment, pname, params); +// } +// static void glowGetNamedFramebufferAttachmentParameterivEXT(GPGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXT fnptr, GLuint framebuffer, GLenum attachment, GLenum pname, GLint * params) { +// (*fnptr)(framebuffer, attachment, pname, params); +// } +// static void glowGetNamedFramebufferParameteriv(GPGETNAMEDFRAMEBUFFERPARAMETERIV fnptr, GLuint framebuffer, GLenum pname, GLint * param) { +// (*fnptr)(framebuffer, pname, param); +// } +// static void glowGetNamedFramebufferParameterivEXT(GPGETNAMEDFRAMEBUFFERPARAMETERIVEXT fnptr, GLuint framebuffer, GLenum pname, GLint * params) { +// (*fnptr)(framebuffer, pname, params); +// } +// static void glowGetNamedProgramLocalParameterIivEXT(GPGETNAMEDPROGRAMLOCALPARAMETERIIVEXT fnptr, GLuint program, GLenum target, GLuint index, GLint * params) { +// (*fnptr)(program, target, index, params); +// } +// static void glowGetNamedProgramLocalParameterIuivEXT(GPGETNAMEDPROGRAMLOCALPARAMETERIUIVEXT fnptr, GLuint program, GLenum target, GLuint index, GLuint * params) { +// (*fnptr)(program, target, index, params); +// } +// static void glowGetNamedProgramLocalParameterdvEXT(GPGETNAMEDPROGRAMLOCALPARAMETERDVEXT fnptr, GLuint program, GLenum target, GLuint index, GLdouble * params) { +// (*fnptr)(program, target, index, params); +// } +// static void glowGetNamedProgramLocalParameterfvEXT(GPGETNAMEDPROGRAMLOCALPARAMETERFVEXT fnptr, GLuint program, GLenum target, GLuint index, GLfloat * params) { +// (*fnptr)(program, target, index, params); +// } +// static void glowGetNamedProgramStringEXT(GPGETNAMEDPROGRAMSTRINGEXT fnptr, GLuint program, GLenum target, GLenum pname, void * string) { +// (*fnptr)(program, target, pname, string); +// } +// static void glowGetNamedProgramivEXT(GPGETNAMEDPROGRAMIVEXT fnptr, GLuint program, GLenum target, GLenum pname, GLint * params) { +// (*fnptr)(program, target, pname, params); +// } +// static void glowGetNamedRenderbufferParameteriv(GPGETNAMEDRENDERBUFFERPARAMETERIV fnptr, GLuint renderbuffer, GLenum pname, GLint * params) { +// (*fnptr)(renderbuffer, pname, params); +// } +// static void glowGetNamedRenderbufferParameterivEXT(GPGETNAMEDRENDERBUFFERPARAMETERIVEXT fnptr, GLuint renderbuffer, GLenum pname, GLint * params) { +// (*fnptr)(renderbuffer, pname, params); +// } +// static void glowGetNamedStringARB(GPGETNAMEDSTRINGARB fnptr, GLint namelen, const GLchar * name, GLsizei bufSize, GLint * stringlen, GLchar * string) { +// (*fnptr)(namelen, name, bufSize, stringlen, string); +// } +// static void glowGetNamedStringivARB(GPGETNAMEDSTRINGIVARB fnptr, GLint namelen, const GLchar * name, GLenum pname, GLint * params) { +// (*fnptr)(namelen, name, pname, params); +// } +// static void glowGetNextPerfQueryIdINTEL(GPGETNEXTPERFQUERYIDINTEL fnptr, GLuint queryId, GLuint * nextQueryId) { +// (*fnptr)(queryId, nextQueryId); +// } +// static void glowGetObjectLabel(GPGETOBJECTLABEL fnptr, GLenum identifier, GLuint name, GLsizei bufSize, GLsizei * length, GLchar * label) { +// (*fnptr)(identifier, name, bufSize, length, label); +// } +// static void glowGetObjectLabelEXT(GPGETOBJECTLABELEXT fnptr, GLenum type, GLuint object, GLsizei bufSize, GLsizei * length, GLchar * label) { +// (*fnptr)(type, object, bufSize, length, label); +// } +// static void glowGetObjectLabelKHR(GPGETOBJECTLABELKHR fnptr, GLenum identifier, GLuint name, GLsizei bufSize, GLsizei * length, GLchar * label) { +// (*fnptr)(identifier, name, bufSize, length, label); +// } +// static void glowGetObjectPtrLabel(GPGETOBJECTPTRLABEL fnptr, const void * ptr, GLsizei bufSize, GLsizei * length, GLchar * label) { +// (*fnptr)(ptr, bufSize, length, label); +// } +// static void glowGetObjectPtrLabelKHR(GPGETOBJECTPTRLABELKHR fnptr, const void * ptr, GLsizei bufSize, GLsizei * length, GLchar * label) { +// (*fnptr)(ptr, bufSize, length, label); +// } +// static void glowGetPathCommandsNV(GPGETPATHCOMMANDSNV fnptr, GLuint path, GLubyte * commands) { +// (*fnptr)(path, commands); +// } +// static void glowGetPathCoordsNV(GPGETPATHCOORDSNV fnptr, GLuint path, GLfloat * coords) { +// (*fnptr)(path, coords); +// } +// static void glowGetPathDashArrayNV(GPGETPATHDASHARRAYNV fnptr, GLuint path, GLfloat * dashArray) { +// (*fnptr)(path, dashArray); +// } +// static GLfloat glowGetPathLengthNV(GPGETPATHLENGTHNV fnptr, GLuint path, GLsizei startSegment, GLsizei numSegments) { +// return (*fnptr)(path, startSegment, numSegments); +// } +// static void glowGetPathMetricRangeNV(GPGETPATHMETRICRANGENV fnptr, GLbitfield metricQueryMask, GLuint firstPathName, GLsizei numPaths, GLsizei stride, GLfloat * metrics) { +// (*fnptr)(metricQueryMask, firstPathName, numPaths, stride, metrics); +// } +// static void glowGetPathMetricsNV(GPGETPATHMETRICSNV fnptr, GLbitfield metricQueryMask, GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLsizei stride, GLfloat * metrics) { +// (*fnptr)(metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics); +// } +// static void glowGetPathParameterfvNV(GPGETPATHPARAMETERFVNV fnptr, GLuint path, GLenum pname, GLfloat * value) { +// (*fnptr)(path, pname, value); +// } +// static void glowGetPathParameterivNV(GPGETPATHPARAMETERIVNV fnptr, GLuint path, GLenum pname, GLint * value) { +// (*fnptr)(path, pname, value); +// } +// static void glowGetPathSpacingNV(GPGETPATHSPACINGNV fnptr, GLenum pathListMode, GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, GLenum transformType, GLfloat * returnedSpacing) { +// (*fnptr)(pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing); +// } +// static void glowGetPerfCounterInfoINTEL(GPGETPERFCOUNTERINFOINTEL fnptr, GLuint queryId, GLuint counterId, GLuint counterNameLength, GLchar * counterName, GLuint counterDescLength, GLchar * counterDesc, GLuint * counterOffset, GLuint * counterDataSize, GLuint * counterTypeEnum, GLuint * counterDataTypeEnum, GLuint64 * rawCounterMaxValue) { +// (*fnptr)(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue); +// } +// static void glowGetPerfMonitorCounterDataAMD(GPGETPERFMONITORCOUNTERDATAAMD fnptr, GLuint monitor, GLenum pname, GLsizei dataSize, GLuint * data, GLint * bytesWritten) { +// (*fnptr)(monitor, pname, dataSize, data, bytesWritten); +// } +// static void glowGetPerfMonitorCounterInfoAMD(GPGETPERFMONITORCOUNTERINFOAMD fnptr, GLuint group, GLuint counter, GLenum pname, void * data) { +// (*fnptr)(group, counter, pname, data); +// } +// static void glowGetPerfMonitorCounterStringAMD(GPGETPERFMONITORCOUNTERSTRINGAMD fnptr, GLuint group, GLuint counter, GLsizei bufSize, GLsizei * length, GLchar * counterString) { +// (*fnptr)(group, counter, bufSize, length, counterString); +// } +// static void glowGetPerfMonitorCountersAMD(GPGETPERFMONITORCOUNTERSAMD fnptr, GLuint group, GLint * numCounters, GLint * maxActiveCounters, GLsizei counterSize, GLuint * counters) { +// (*fnptr)(group, numCounters, maxActiveCounters, counterSize, counters); +// } +// static void glowGetPerfMonitorGroupStringAMD(GPGETPERFMONITORGROUPSTRINGAMD fnptr, GLuint group, GLsizei bufSize, GLsizei * length, GLchar * groupString) { +// (*fnptr)(group, bufSize, length, groupString); +// } +// static void glowGetPerfMonitorGroupsAMD(GPGETPERFMONITORGROUPSAMD fnptr, GLint * numGroups, GLsizei groupsSize, GLuint * groups) { +// (*fnptr)(numGroups, groupsSize, groups); +// } +// static void glowGetPerfQueryDataINTEL(GPGETPERFQUERYDATAINTEL fnptr, GLuint queryHandle, GLuint flags, GLsizei dataSize, void * data, GLuint * bytesWritten) { +// (*fnptr)(queryHandle, flags, dataSize, data, bytesWritten); +// } +// static void glowGetPerfQueryIdByNameINTEL(GPGETPERFQUERYIDBYNAMEINTEL fnptr, GLchar * queryName, GLuint * queryId) { +// (*fnptr)(queryName, queryId); +// } +// static void glowGetPerfQueryInfoINTEL(GPGETPERFQUERYINFOINTEL fnptr, GLuint queryId, GLuint queryNameLength, GLchar * queryName, GLuint * dataSize, GLuint * noCounters, GLuint * noInstances, GLuint * capsMask) { +// (*fnptr)(queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask); +// } +// static void glowGetPointerIndexedvEXT(GPGETPOINTERINDEXEDVEXT fnptr, GLenum target, GLuint index, void ** data) { +// (*fnptr)(target, index, data); +// } +// static void glowGetPointeri_vEXT(GPGETPOINTERI_VEXT fnptr, GLenum pname, GLuint index, void ** params) { +// (*fnptr)(pname, index, params); +// } +// static void glowGetPointerv(GPGETPOINTERV fnptr, GLenum pname, void ** params) { +// (*fnptr)(pname, params); +// } +// static void glowGetPointervKHR(GPGETPOINTERVKHR fnptr, GLenum pname, void ** params) { +// (*fnptr)(pname, params); +// } +// static void glowGetProgramBinary(GPGETPROGRAMBINARY fnptr, GLuint program, GLsizei bufSize, GLsizei * length, GLenum * binaryFormat, void * binary) { +// (*fnptr)(program, bufSize, length, binaryFormat, binary); +// } +// static void glowGetProgramInfoLog(GPGETPROGRAMINFOLOG fnptr, GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog) { +// (*fnptr)(program, bufSize, length, infoLog); +// } +// static void glowGetProgramInterfaceiv(GPGETPROGRAMINTERFACEIV fnptr, GLuint program, GLenum programInterface, GLenum pname, GLint * params) { +// (*fnptr)(program, programInterface, pname, params); +// } +// static void glowGetProgramPipelineInfoLog(GPGETPROGRAMPIPELINEINFOLOG fnptr, GLuint pipeline, GLsizei bufSize, GLsizei * length, GLchar * infoLog) { +// (*fnptr)(pipeline, bufSize, length, infoLog); +// } +// static void glowGetProgramPipelineInfoLogEXT(GPGETPROGRAMPIPELINEINFOLOGEXT fnptr, GLuint pipeline, GLsizei bufSize, GLsizei * length, GLchar * infoLog) { +// (*fnptr)(pipeline, bufSize, length, infoLog); +// } +// static void glowGetProgramPipelineiv(GPGETPROGRAMPIPELINEIV fnptr, GLuint pipeline, GLenum pname, GLint * params) { +// (*fnptr)(pipeline, pname, params); +// } +// static void glowGetProgramPipelineivEXT(GPGETPROGRAMPIPELINEIVEXT fnptr, GLuint pipeline, GLenum pname, GLint * params) { +// (*fnptr)(pipeline, pname, params); +// } +// static GLuint glowGetProgramResourceIndex(GPGETPROGRAMRESOURCEINDEX fnptr, GLuint program, GLenum programInterface, const GLchar * name) { +// return (*fnptr)(program, programInterface, name); +// } +// static GLint glowGetProgramResourceLocation(GPGETPROGRAMRESOURCELOCATION fnptr, GLuint program, GLenum programInterface, const GLchar * name) { +// return (*fnptr)(program, programInterface, name); +// } +// static GLint glowGetProgramResourceLocationIndex(GPGETPROGRAMRESOURCELOCATIONINDEX fnptr, GLuint program, GLenum programInterface, const GLchar * name) { +// return (*fnptr)(program, programInterface, name); +// } +// static void glowGetProgramResourceName(GPGETPROGRAMRESOURCENAME fnptr, GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei * length, GLchar * name) { +// (*fnptr)(program, programInterface, index, bufSize, length, name); +// } +// static void glowGetProgramResourcefvNV(GPGETPROGRAMRESOURCEFVNV fnptr, GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum * props, GLsizei count, GLsizei * length, GLfloat * params) { +// (*fnptr)(program, programInterface, index, propCount, props, count, length, params); +// } +// static void glowGetProgramResourceiv(GPGETPROGRAMRESOURCEIV fnptr, GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum * props, GLsizei count, GLsizei * length, GLint * params) { +// (*fnptr)(program, programInterface, index, propCount, props, count, length, params); +// } +// static void glowGetProgramStageiv(GPGETPROGRAMSTAGEIV fnptr, GLuint program, GLenum shadertype, GLenum pname, GLint * values) { +// (*fnptr)(program, shadertype, pname, values); +// } +// static void glowGetProgramiv(GPGETPROGRAMIV fnptr, GLuint program, GLenum pname, GLint * params) { +// (*fnptr)(program, pname, params); +// } +// static void glowGetQueryBufferObjecti64v(GPGETQUERYBUFFEROBJECTI64V fnptr, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) { +// (*fnptr)(id, buffer, pname, offset); +// } +// static void glowGetQueryBufferObjectiv(GPGETQUERYBUFFEROBJECTIV fnptr, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) { +// (*fnptr)(id, buffer, pname, offset); +// } +// static void glowGetQueryBufferObjectui64v(GPGETQUERYBUFFEROBJECTUI64V fnptr, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) { +// (*fnptr)(id, buffer, pname, offset); +// } +// static void glowGetQueryBufferObjectuiv(GPGETQUERYBUFFEROBJECTUIV fnptr, GLuint id, GLuint buffer, GLenum pname, GLintptr offset) { +// (*fnptr)(id, buffer, pname, offset); +// } +// static void glowGetQueryIndexediv(GPGETQUERYINDEXEDIV fnptr, GLenum target, GLuint index, GLenum pname, GLint * params) { +// (*fnptr)(target, index, pname, params); +// } +// static void glowGetQueryObjecti64v(GPGETQUERYOBJECTI64V fnptr, GLuint id, GLenum pname, GLint64 * params) { +// (*fnptr)(id, pname, params); +// } +// static void glowGetQueryObjectiv(GPGETQUERYOBJECTIV fnptr, GLuint id, GLenum pname, GLint * params) { +// (*fnptr)(id, pname, params); +// } +// static void glowGetQueryObjectui64v(GPGETQUERYOBJECTUI64V fnptr, GLuint id, GLenum pname, GLuint64 * params) { +// (*fnptr)(id, pname, params); +// } +// static void glowGetQueryObjectuiv(GPGETQUERYOBJECTUIV fnptr, GLuint id, GLenum pname, GLuint * params) { +// (*fnptr)(id, pname, params); +// } +// static void glowGetQueryiv(GPGETQUERYIV fnptr, GLenum target, GLenum pname, GLint * params) { +// (*fnptr)(target, pname, params); +// } +// static void glowGetRenderbufferParameteriv(GPGETRENDERBUFFERPARAMETERIV fnptr, GLenum target, GLenum pname, GLint * params) { +// (*fnptr)(target, pname, params); +// } +// static void glowGetSamplerParameterIiv(GPGETSAMPLERPARAMETERIIV fnptr, GLuint sampler, GLenum pname, GLint * params) { +// (*fnptr)(sampler, pname, params); +// } +// static void glowGetSamplerParameterIuiv(GPGETSAMPLERPARAMETERIUIV fnptr, GLuint sampler, GLenum pname, GLuint * params) { +// (*fnptr)(sampler, pname, params); +// } +// static void glowGetSamplerParameterfv(GPGETSAMPLERPARAMETERFV fnptr, GLuint sampler, GLenum pname, GLfloat * params) { +// (*fnptr)(sampler, pname, params); +// } +// static void glowGetSamplerParameteriv(GPGETSAMPLERPARAMETERIV fnptr, GLuint sampler, GLenum pname, GLint * params) { +// (*fnptr)(sampler, pname, params); +// } +// static void glowGetShaderInfoLog(GPGETSHADERINFOLOG fnptr, GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog) { +// (*fnptr)(shader, bufSize, length, infoLog); +// } +// static void glowGetShaderPrecisionFormat(GPGETSHADERPRECISIONFORMAT fnptr, GLenum shadertype, GLenum precisiontype, GLint * range, GLint * precision) { +// (*fnptr)(shadertype, precisiontype, range, precision); +// } +// static void glowGetShaderSource(GPGETSHADERSOURCE fnptr, GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source) { +// (*fnptr)(shader, bufSize, length, source); +// } +// static void glowGetShaderiv(GPGETSHADERIV fnptr, GLuint shader, GLenum pname, GLint * params) { +// (*fnptr)(shader, pname, params); +// } +// static void glowGetShadingRateImagePaletteNV(GPGETSHADINGRATEIMAGEPALETTENV fnptr, GLuint viewport, GLuint entry, GLenum * rate) { +// (*fnptr)(viewport, entry, rate); +// } +// static void glowGetShadingRateSampleLocationivNV(GPGETSHADINGRATESAMPLELOCATIONIVNV fnptr, GLenum rate, GLuint samples, GLuint index, GLint * location) { +// (*fnptr)(rate, samples, index, location); +// } +// static GLushort glowGetStageIndexNV(GPGETSTAGEINDEXNV fnptr, GLenum shadertype) { +// return (*fnptr)(shadertype); +// } +// static const GLubyte * glowGetString(GPGETSTRING fnptr, GLenum name) { +// return (*fnptr)(name); +// } +// static const GLubyte * glowGetStringi(GPGETSTRINGI fnptr, GLenum name, GLuint index) { +// return (*fnptr)(name, index); +// } +// static GLuint glowGetSubroutineIndex(GPGETSUBROUTINEINDEX fnptr, GLuint program, GLenum shadertype, const GLchar * name) { +// return (*fnptr)(program, shadertype, name); +// } +// static GLint glowGetSubroutineUniformLocation(GPGETSUBROUTINEUNIFORMLOCATION fnptr, GLuint program, GLenum shadertype, const GLchar * name) { +// return (*fnptr)(program, shadertype, name); +// } +// static void glowGetSynciv(GPGETSYNCIV fnptr, GLsync sync, GLenum pname, GLsizei count, GLsizei * length, GLint * values) { +// (*fnptr)(sync, pname, count, length, values); +// } +// static void glowGetTexImage(GPGETTEXIMAGE fnptr, GLenum target, GLint level, GLenum format, GLenum type, void * pixels) { +// (*fnptr)(target, level, format, type, pixels); +// } +// static void glowGetTexLevelParameterfv(GPGETTEXLEVELPARAMETERFV fnptr, GLenum target, GLint level, GLenum pname, GLfloat * params) { +// (*fnptr)(target, level, pname, params); +// } +// static void glowGetTexLevelParameteriv(GPGETTEXLEVELPARAMETERIV fnptr, GLenum target, GLint level, GLenum pname, GLint * params) { +// (*fnptr)(target, level, pname, params); +// } +// static void glowGetTexParameterIiv(GPGETTEXPARAMETERIIV fnptr, GLenum target, GLenum pname, GLint * params) { +// (*fnptr)(target, pname, params); +// } +// static void glowGetTexParameterIuiv(GPGETTEXPARAMETERIUIV fnptr, GLenum target, GLenum pname, GLuint * params) { +// (*fnptr)(target, pname, params); +// } +// static void glowGetTexParameterfv(GPGETTEXPARAMETERFV fnptr, GLenum target, GLenum pname, GLfloat * params) { +// (*fnptr)(target, pname, params); +// } +// static void glowGetTexParameteriv(GPGETTEXPARAMETERIV fnptr, GLenum target, GLenum pname, GLint * params) { +// (*fnptr)(target, pname, params); +// } +// static GLuint64 glowGetTextureHandleARB(GPGETTEXTUREHANDLEARB fnptr, GLuint texture) { +// return (*fnptr)(texture); +// } +// static GLuint64 glowGetTextureHandleNV(GPGETTEXTUREHANDLENV fnptr, GLuint texture) { +// return (*fnptr)(texture); +// } +// static void glowGetTextureImage(GPGETTEXTUREIMAGE fnptr, GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void * pixels) { +// (*fnptr)(texture, level, format, type, bufSize, pixels); +// } +// static void glowGetTextureImageEXT(GPGETTEXTUREIMAGEEXT fnptr, GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void * pixels) { +// (*fnptr)(texture, target, level, format, type, pixels); +// } +// static void glowGetTextureLevelParameterfv(GPGETTEXTURELEVELPARAMETERFV fnptr, GLuint texture, GLint level, GLenum pname, GLfloat * params) { +// (*fnptr)(texture, level, pname, params); +// } +// static void glowGetTextureLevelParameterfvEXT(GPGETTEXTURELEVELPARAMETERFVEXT fnptr, GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat * params) { +// (*fnptr)(texture, target, level, pname, params); +// } +// static void glowGetTextureLevelParameteriv(GPGETTEXTURELEVELPARAMETERIV fnptr, GLuint texture, GLint level, GLenum pname, GLint * params) { +// (*fnptr)(texture, level, pname, params); +// } +// static void glowGetTextureLevelParameterivEXT(GPGETTEXTURELEVELPARAMETERIVEXT fnptr, GLuint texture, GLenum target, GLint level, GLenum pname, GLint * params) { +// (*fnptr)(texture, target, level, pname, params); +// } +// static void glowGetTextureParameterIiv(GPGETTEXTUREPARAMETERIIV fnptr, GLuint texture, GLenum pname, GLint * params) { +// (*fnptr)(texture, pname, params); +// } +// static void glowGetTextureParameterIivEXT(GPGETTEXTUREPARAMETERIIVEXT fnptr, GLuint texture, GLenum target, GLenum pname, GLint * params) { +// (*fnptr)(texture, target, pname, params); +// } +// static void glowGetTextureParameterIuiv(GPGETTEXTUREPARAMETERIUIV fnptr, GLuint texture, GLenum pname, GLuint * params) { +// (*fnptr)(texture, pname, params); +// } +// static void glowGetTextureParameterIuivEXT(GPGETTEXTUREPARAMETERIUIVEXT fnptr, GLuint texture, GLenum target, GLenum pname, GLuint * params) { +// (*fnptr)(texture, target, pname, params); +// } +// static void glowGetTextureParameterfv(GPGETTEXTUREPARAMETERFV fnptr, GLuint texture, GLenum pname, GLfloat * params) { +// (*fnptr)(texture, pname, params); +// } +// static void glowGetTextureParameterfvEXT(GPGETTEXTUREPARAMETERFVEXT fnptr, GLuint texture, GLenum target, GLenum pname, GLfloat * params) { +// (*fnptr)(texture, target, pname, params); +// } +// static void glowGetTextureParameteriv(GPGETTEXTUREPARAMETERIV fnptr, GLuint texture, GLenum pname, GLint * params) { +// (*fnptr)(texture, pname, params); +// } +// static void glowGetTextureParameterivEXT(GPGETTEXTUREPARAMETERIVEXT fnptr, GLuint texture, GLenum target, GLenum pname, GLint * params) { +// (*fnptr)(texture, target, pname, params); +// } +// static GLuint64 glowGetTextureSamplerHandleARB(GPGETTEXTURESAMPLERHANDLEARB fnptr, GLuint texture, GLuint sampler) { +// return (*fnptr)(texture, sampler); +// } +// static GLuint64 glowGetTextureSamplerHandleNV(GPGETTEXTURESAMPLERHANDLENV fnptr, GLuint texture, GLuint sampler) { +// return (*fnptr)(texture, sampler); +// } +// static void glowGetTextureSubImage(GPGETTEXTURESUBIMAGE fnptr, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void * pixels) { +// (*fnptr)(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels); +// } +// static void glowGetTransformFeedbackVarying(GPGETTRANSFORMFEEDBACKVARYING fnptr, GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name) { +// (*fnptr)(program, index, bufSize, length, size, type, name); +// } +// static void glowGetTransformFeedbacki64_v(GPGETTRANSFORMFEEDBACKI64_V fnptr, GLuint xfb, GLenum pname, GLuint index, GLint64 * param) { +// (*fnptr)(xfb, pname, index, param); +// } +// static void glowGetTransformFeedbacki_v(GPGETTRANSFORMFEEDBACKI_V fnptr, GLuint xfb, GLenum pname, GLuint index, GLint * param) { +// (*fnptr)(xfb, pname, index, param); +// } +// static void glowGetTransformFeedbackiv(GPGETTRANSFORMFEEDBACKIV fnptr, GLuint xfb, GLenum pname, GLint * param) { +// (*fnptr)(xfb, pname, param); +// } +// static GLuint glowGetUniformBlockIndex(GPGETUNIFORMBLOCKINDEX fnptr, GLuint program, const GLchar * uniformBlockName) { +// return (*fnptr)(program, uniformBlockName); +// } +// static void glowGetUniformIndices(GPGETUNIFORMINDICES fnptr, GLuint program, GLsizei uniformCount, const GLchar *const* uniformNames, GLuint * uniformIndices) { +// (*fnptr)(program, uniformCount, uniformNames, uniformIndices); +// } +// static GLint glowGetUniformLocation(GPGETUNIFORMLOCATION fnptr, GLuint program, const GLchar * name) { +// return (*fnptr)(program, name); +// } +// static void glowGetUniformSubroutineuiv(GPGETUNIFORMSUBROUTINEUIV fnptr, GLenum shadertype, GLint location, GLuint * params) { +// (*fnptr)(shadertype, location, params); +// } +// static void glowGetUniformdv(GPGETUNIFORMDV fnptr, GLuint program, GLint location, GLdouble * params) { +// (*fnptr)(program, location, params); +// } +// static void glowGetUniformfv(GPGETUNIFORMFV fnptr, GLuint program, GLint location, GLfloat * params) { +// (*fnptr)(program, location, params); +// } +// static void glowGetUniformi64vARB(GPGETUNIFORMI64VARB fnptr, GLuint program, GLint location, GLint64 * params) { +// (*fnptr)(program, location, params); +// } +// static void glowGetUniformi64vNV(GPGETUNIFORMI64VNV fnptr, GLuint program, GLint location, GLint64EXT * params) { +// (*fnptr)(program, location, params); +// } +// static void glowGetUniformiv(GPGETUNIFORMIV fnptr, GLuint program, GLint location, GLint * params) { +// (*fnptr)(program, location, params); +// } +// static void glowGetUniformui64vARB(GPGETUNIFORMUI64VARB fnptr, GLuint program, GLint location, GLuint64 * params) { +// (*fnptr)(program, location, params); +// } +// static void glowGetUniformui64vNV(GPGETUNIFORMUI64VNV fnptr, GLuint program, GLint location, GLuint64EXT * params) { +// (*fnptr)(program, location, params); +// } +// static void glowGetUniformuiv(GPGETUNIFORMUIV fnptr, GLuint program, GLint location, GLuint * params) { +// (*fnptr)(program, location, params); +// } +// static void glowGetVertexArrayIndexed64iv(GPGETVERTEXARRAYINDEXED64IV fnptr, GLuint vaobj, GLuint index, GLenum pname, GLint64 * param) { +// (*fnptr)(vaobj, index, pname, param); +// } +// static void glowGetVertexArrayIndexediv(GPGETVERTEXARRAYINDEXEDIV fnptr, GLuint vaobj, GLuint index, GLenum pname, GLint * param) { +// (*fnptr)(vaobj, index, pname, param); +// } +// static void glowGetVertexArrayIntegeri_vEXT(GPGETVERTEXARRAYINTEGERI_VEXT fnptr, GLuint vaobj, GLuint index, GLenum pname, GLint * param) { +// (*fnptr)(vaobj, index, pname, param); +// } +// static void glowGetVertexArrayIntegervEXT(GPGETVERTEXARRAYINTEGERVEXT fnptr, GLuint vaobj, GLenum pname, GLint * param) { +// (*fnptr)(vaobj, pname, param); +// } +// static void glowGetVertexArrayPointeri_vEXT(GPGETVERTEXARRAYPOINTERI_VEXT fnptr, GLuint vaobj, GLuint index, GLenum pname, void ** param) { +// (*fnptr)(vaobj, index, pname, param); +// } +// static void glowGetVertexArrayPointervEXT(GPGETVERTEXARRAYPOINTERVEXT fnptr, GLuint vaobj, GLenum pname, void ** param) { +// (*fnptr)(vaobj, pname, param); +// } +// static void glowGetVertexArrayiv(GPGETVERTEXARRAYIV fnptr, GLuint vaobj, GLenum pname, GLint * param) { +// (*fnptr)(vaobj, pname, param); +// } +// static void glowGetVertexAttribIiv(GPGETVERTEXATTRIBIIV fnptr, GLuint index, GLenum pname, GLint * params) { +// (*fnptr)(index, pname, params); +// } +// static void glowGetVertexAttribIuiv(GPGETVERTEXATTRIBIUIV fnptr, GLuint index, GLenum pname, GLuint * params) { +// (*fnptr)(index, pname, params); +// } +// static void glowGetVertexAttribLdv(GPGETVERTEXATTRIBLDV fnptr, GLuint index, GLenum pname, GLdouble * params) { +// (*fnptr)(index, pname, params); +// } +// static void glowGetVertexAttribLi64vNV(GPGETVERTEXATTRIBLI64VNV fnptr, GLuint index, GLenum pname, GLint64EXT * params) { +// (*fnptr)(index, pname, params); +// } +// static void glowGetVertexAttribLui64vARB(GPGETVERTEXATTRIBLUI64VARB fnptr, GLuint index, GLenum pname, GLuint64EXT * params) { +// (*fnptr)(index, pname, params); +// } +// static void glowGetVertexAttribLui64vNV(GPGETVERTEXATTRIBLUI64VNV fnptr, GLuint index, GLenum pname, GLuint64EXT * params) { +// (*fnptr)(index, pname, params); +// } +// static void glowGetVertexAttribPointerv(GPGETVERTEXATTRIBPOINTERV fnptr, GLuint index, GLenum pname, void ** pointer) { +// (*fnptr)(index, pname, pointer); +// } +// static void glowGetVertexAttribPointerWithOffsetv(GPGETVERTEXATTRIBPOINTERV fnptr, GLuint index, GLenum pname, uintptr_t ** offset) { +// (*fnptr)(index, pname, (void **)(offset)); +// } +// static void glowGetVertexAttribdv(GPGETVERTEXATTRIBDV fnptr, GLuint index, GLenum pname, GLdouble * params) { +// (*fnptr)(index, pname, params); +// } +// static void glowGetVertexAttribfv(GPGETVERTEXATTRIBFV fnptr, GLuint index, GLenum pname, GLfloat * params) { +// (*fnptr)(index, pname, params); +// } +// static void glowGetVertexAttribiv(GPGETVERTEXATTRIBIV fnptr, GLuint index, GLenum pname, GLint * params) { +// (*fnptr)(index, pname, params); +// } +// static GLVULKANPROCNV glowGetVkProcAddrNV(GPGETVKPROCADDRNV fnptr, const GLchar * name) { +// return (*fnptr)(name); +// } +// static void glowGetnCompressedTexImageARB(GPGETNCOMPRESSEDTEXIMAGEARB fnptr, GLenum target, GLint lod, GLsizei bufSize, void * img) { +// (*fnptr)(target, lod, bufSize, img); +// } +// static void glowGetnTexImageARB(GPGETNTEXIMAGEARB fnptr, GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void * img) { +// (*fnptr)(target, level, format, type, bufSize, img); +// } +// static void glowGetnUniformdvARB(GPGETNUNIFORMDVARB fnptr, GLuint program, GLint location, GLsizei bufSize, GLdouble * params) { +// (*fnptr)(program, location, bufSize, params); +// } +// static void glowGetnUniformfv(GPGETNUNIFORMFV fnptr, GLuint program, GLint location, GLsizei bufSize, GLfloat * params) { +// (*fnptr)(program, location, bufSize, params); +// } +// static void glowGetnUniformfvARB(GPGETNUNIFORMFVARB fnptr, GLuint program, GLint location, GLsizei bufSize, GLfloat * params) { +// (*fnptr)(program, location, bufSize, params); +// } +// static void glowGetnUniformfvKHR(GPGETNUNIFORMFVKHR fnptr, GLuint program, GLint location, GLsizei bufSize, GLfloat * params) { +// (*fnptr)(program, location, bufSize, params); +// } +// static void glowGetnUniformi64vARB(GPGETNUNIFORMI64VARB fnptr, GLuint program, GLint location, GLsizei bufSize, GLint64 * params) { +// (*fnptr)(program, location, bufSize, params); +// } +// static void glowGetnUniformiv(GPGETNUNIFORMIV fnptr, GLuint program, GLint location, GLsizei bufSize, GLint * params) { +// (*fnptr)(program, location, bufSize, params); +// } +// static void glowGetnUniformivARB(GPGETNUNIFORMIVARB fnptr, GLuint program, GLint location, GLsizei bufSize, GLint * params) { +// (*fnptr)(program, location, bufSize, params); +// } +// static void glowGetnUniformivKHR(GPGETNUNIFORMIVKHR fnptr, GLuint program, GLint location, GLsizei bufSize, GLint * params) { +// (*fnptr)(program, location, bufSize, params); +// } +// static void glowGetnUniformui64vARB(GPGETNUNIFORMUI64VARB fnptr, GLuint program, GLint location, GLsizei bufSize, GLuint64 * params) { +// (*fnptr)(program, location, bufSize, params); +// } +// static void glowGetnUniformuiv(GPGETNUNIFORMUIV fnptr, GLuint program, GLint location, GLsizei bufSize, GLuint * params) { +// (*fnptr)(program, location, bufSize, params); +// } +// static void glowGetnUniformuivARB(GPGETNUNIFORMUIVARB fnptr, GLuint program, GLint location, GLsizei bufSize, GLuint * params) { +// (*fnptr)(program, location, bufSize, params); +// } +// static void glowGetnUniformuivKHR(GPGETNUNIFORMUIVKHR fnptr, GLuint program, GLint location, GLsizei bufSize, GLuint * params) { +// (*fnptr)(program, location, bufSize, params); +// } +// static void glowHint(GPHINT fnptr, GLenum target, GLenum mode) { +// (*fnptr)(target, mode); +// } +// static void glowIndexFormatNV(GPINDEXFORMATNV fnptr, GLenum type, GLsizei stride) { +// (*fnptr)(type, stride); +// } +// static void glowInsertEventMarkerEXT(GPINSERTEVENTMARKEREXT fnptr, GLsizei length, const GLchar * marker) { +// (*fnptr)(length, marker); +// } +// static void glowInterpolatePathsNV(GPINTERPOLATEPATHSNV fnptr, GLuint resultPath, GLuint pathA, GLuint pathB, GLfloat weight) { +// (*fnptr)(resultPath, pathA, pathB, weight); +// } +// static void glowInvalidateBufferData(GPINVALIDATEBUFFERDATA fnptr, GLuint buffer) { +// (*fnptr)(buffer); +// } +// static void glowInvalidateBufferSubData(GPINVALIDATEBUFFERSUBDATA fnptr, GLuint buffer, GLintptr offset, GLsizeiptr length) { +// (*fnptr)(buffer, offset, length); +// } +// static void glowInvalidateFramebuffer(GPINVALIDATEFRAMEBUFFER fnptr, GLenum target, GLsizei numAttachments, const GLenum * attachments) { +// (*fnptr)(target, numAttachments, attachments); +// } +// static void glowInvalidateNamedFramebufferData(GPINVALIDATENAMEDFRAMEBUFFERDATA fnptr, GLuint framebuffer, GLsizei numAttachments, const GLenum * attachments) { +// (*fnptr)(framebuffer, numAttachments, attachments); +// } +// static void glowInvalidateNamedFramebufferSubData(GPINVALIDATENAMEDFRAMEBUFFERSUBDATA fnptr, GLuint framebuffer, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height) { +// (*fnptr)(framebuffer, numAttachments, attachments, x, y, width, height); +// } +// static void glowInvalidateSubFramebuffer(GPINVALIDATESUBFRAMEBUFFER fnptr, GLenum target, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height) { +// (*fnptr)(target, numAttachments, attachments, x, y, width, height); +// } +// static void glowInvalidateTexImage(GPINVALIDATETEXIMAGE fnptr, GLuint texture, GLint level) { +// (*fnptr)(texture, level); +// } +// static void glowInvalidateTexSubImage(GPINVALIDATETEXSUBIMAGE fnptr, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth) { +// (*fnptr)(texture, level, xoffset, yoffset, zoffset, width, height, depth); +// } +// static GLboolean glowIsBuffer(GPISBUFFER fnptr, GLuint buffer) { +// return (*fnptr)(buffer); +// } +// static GLboolean glowIsBufferResidentNV(GPISBUFFERRESIDENTNV fnptr, GLenum target) { +// return (*fnptr)(target); +// } +// static GLboolean glowIsCommandListNV(GPISCOMMANDLISTNV fnptr, GLuint list) { +// return (*fnptr)(list); +// } +// static GLboolean glowIsEnabled(GPISENABLED fnptr, GLenum cap) { +// return (*fnptr)(cap); +// } +// static GLboolean glowIsEnabledIndexedEXT(GPISENABLEDINDEXEDEXT fnptr, GLenum target, GLuint index) { +// return (*fnptr)(target, index); +// } +// static GLboolean glowIsEnabledi(GPISENABLEDI fnptr, GLenum target, GLuint index) { +// return (*fnptr)(target, index); +// } +// static GLboolean glowIsFramebuffer(GPISFRAMEBUFFER fnptr, GLuint framebuffer) { +// return (*fnptr)(framebuffer); +// } +// static GLboolean glowIsImageHandleResidentARB(GPISIMAGEHANDLERESIDENTARB fnptr, GLuint64 handle) { +// return (*fnptr)(handle); +// } +// static GLboolean glowIsImageHandleResidentNV(GPISIMAGEHANDLERESIDENTNV fnptr, GLuint64 handle) { +// return (*fnptr)(handle); +// } +// static GLboolean glowIsNamedBufferResidentNV(GPISNAMEDBUFFERRESIDENTNV fnptr, GLuint buffer) { +// return (*fnptr)(buffer); +// } +// static GLboolean glowIsNamedStringARB(GPISNAMEDSTRINGARB fnptr, GLint namelen, const GLchar * name) { +// return (*fnptr)(namelen, name); +// } +// static GLboolean glowIsPathNV(GPISPATHNV fnptr, GLuint path) { +// return (*fnptr)(path); +// } +// static GLboolean glowIsPointInFillPathNV(GPISPOINTINFILLPATHNV fnptr, GLuint path, GLuint mask, GLfloat x, GLfloat y) { +// return (*fnptr)(path, mask, x, y); +// } +// static GLboolean glowIsPointInStrokePathNV(GPISPOINTINSTROKEPATHNV fnptr, GLuint path, GLfloat x, GLfloat y) { +// return (*fnptr)(path, x, y); +// } +// static GLboolean glowIsProgram(GPISPROGRAM fnptr, GLuint program) { +// return (*fnptr)(program); +// } +// static GLboolean glowIsProgramPipeline(GPISPROGRAMPIPELINE fnptr, GLuint pipeline) { +// return (*fnptr)(pipeline); +// } +// static GLboolean glowIsProgramPipelineEXT(GPISPROGRAMPIPELINEEXT fnptr, GLuint pipeline) { +// return (*fnptr)(pipeline); +// } +// static GLboolean glowIsQuery(GPISQUERY fnptr, GLuint id) { +// return (*fnptr)(id); +// } +// static GLboolean glowIsRenderbuffer(GPISRENDERBUFFER fnptr, GLuint renderbuffer) { +// return (*fnptr)(renderbuffer); +// } +// static GLboolean glowIsSampler(GPISSAMPLER fnptr, GLuint sampler) { +// return (*fnptr)(sampler); +// } +// static GLboolean glowIsShader(GPISSHADER fnptr, GLuint shader) { +// return (*fnptr)(shader); +// } +// static GLboolean glowIsStateNV(GPISSTATENV fnptr, GLuint state) { +// return (*fnptr)(state); +// } +// static GLboolean glowIsSync(GPISSYNC fnptr, GLsync sync) { +// return (*fnptr)(sync); +// } +// static GLboolean glowIsTexture(GPISTEXTURE fnptr, GLuint texture) { +// return (*fnptr)(texture); +// } +// static GLboolean glowIsTextureHandleResidentARB(GPISTEXTUREHANDLERESIDENTARB fnptr, GLuint64 handle) { +// return (*fnptr)(handle); +// } +// static GLboolean glowIsTextureHandleResidentNV(GPISTEXTUREHANDLERESIDENTNV fnptr, GLuint64 handle) { +// return (*fnptr)(handle); +// } +// static GLboolean glowIsTransformFeedback(GPISTRANSFORMFEEDBACK fnptr, GLuint id) { +// return (*fnptr)(id); +// } +// static GLboolean glowIsVertexArray(GPISVERTEXARRAY fnptr, GLuint array) { +// return (*fnptr)(array); +// } +// static void glowLabelObjectEXT(GPLABELOBJECTEXT fnptr, GLenum type, GLuint object, GLsizei length, const GLchar * label) { +// (*fnptr)(type, object, length, label); +// } +// static void glowLineWidth(GPLINEWIDTH fnptr, GLfloat width) { +// (*fnptr)(width); +// } +// static void glowLinkProgram(GPLINKPROGRAM fnptr, GLuint program) { +// (*fnptr)(program); +// } +// static void glowListDrawCommandsStatesClientNV(GPLISTDRAWCOMMANDSSTATESCLIENTNV fnptr, GLuint list, GLuint segment, const void ** indirects, const GLsizei * sizes, const GLuint * states, const GLuint * fbos, GLuint count) { +// (*fnptr)(list, segment, indirects, sizes, states, fbos, count); +// } +// static void glowLogicOp(GPLOGICOP fnptr, GLenum opcode) { +// (*fnptr)(opcode); +// } +// static void glowMakeBufferNonResidentNV(GPMAKEBUFFERNONRESIDENTNV fnptr, GLenum target) { +// (*fnptr)(target); +// } +// static void glowMakeBufferResidentNV(GPMAKEBUFFERRESIDENTNV fnptr, GLenum target, GLenum access) { +// (*fnptr)(target, access); +// } +// static void glowMakeImageHandleNonResidentARB(GPMAKEIMAGEHANDLENONRESIDENTARB fnptr, GLuint64 handle) { +// (*fnptr)(handle); +// } +// static void glowMakeImageHandleNonResidentNV(GPMAKEIMAGEHANDLENONRESIDENTNV fnptr, GLuint64 handle) { +// (*fnptr)(handle); +// } +// static void glowMakeImageHandleResidentARB(GPMAKEIMAGEHANDLERESIDENTARB fnptr, GLuint64 handle, GLenum access) { +// (*fnptr)(handle, access); +// } +// static void glowMakeImageHandleResidentNV(GPMAKEIMAGEHANDLERESIDENTNV fnptr, GLuint64 handle, GLenum access) { +// (*fnptr)(handle, access); +// } +// static void glowMakeNamedBufferNonResidentNV(GPMAKENAMEDBUFFERNONRESIDENTNV fnptr, GLuint buffer) { +// (*fnptr)(buffer); +// } +// static void glowMakeNamedBufferResidentNV(GPMAKENAMEDBUFFERRESIDENTNV fnptr, GLuint buffer, GLenum access) { +// (*fnptr)(buffer, access); +// } +// static void glowMakeTextureHandleNonResidentARB(GPMAKETEXTUREHANDLENONRESIDENTARB fnptr, GLuint64 handle) { +// (*fnptr)(handle); +// } +// static void glowMakeTextureHandleNonResidentNV(GPMAKETEXTUREHANDLENONRESIDENTNV fnptr, GLuint64 handle) { +// (*fnptr)(handle); +// } +// static void glowMakeTextureHandleResidentARB(GPMAKETEXTUREHANDLERESIDENTARB fnptr, GLuint64 handle) { +// (*fnptr)(handle); +// } +// static void glowMakeTextureHandleResidentNV(GPMAKETEXTUREHANDLERESIDENTNV fnptr, GLuint64 handle) { +// (*fnptr)(handle); +// } +// static void * glowMapBuffer(GPMAPBUFFER fnptr, GLenum target, GLenum access) { +// return (*fnptr)(target, access); +// } +// static void * glowMapBufferRange(GPMAPBUFFERRANGE fnptr, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) { +// return (*fnptr)(target, offset, length, access); +// } +// static void * glowMapNamedBuffer(GPMAPNAMEDBUFFER fnptr, GLuint buffer, GLenum access) { +// return (*fnptr)(buffer, access); +// } +// static void * glowMapNamedBufferEXT(GPMAPNAMEDBUFFEREXT fnptr, GLuint buffer, GLenum access) { +// return (*fnptr)(buffer, access); +// } +// static void * glowMapNamedBufferRange(GPMAPNAMEDBUFFERRANGE fnptr, GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access) { +// return (*fnptr)(buffer, offset, length, access); +// } +// static void * glowMapNamedBufferRangeEXT(GPMAPNAMEDBUFFERRANGEEXT fnptr, GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access) { +// return (*fnptr)(buffer, offset, length, access); +// } +// static void glowMatrixFrustumEXT(GPMATRIXFRUSTUMEXT fnptr, GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) { +// (*fnptr)(mode, left, right, bottom, top, zNear, zFar); +// } +// static void glowMatrixLoad3x2fNV(GPMATRIXLOAD3X2FNV fnptr, GLenum matrixMode, const GLfloat * m) { +// (*fnptr)(matrixMode, m); +// } +// static void glowMatrixLoad3x3fNV(GPMATRIXLOAD3X3FNV fnptr, GLenum matrixMode, const GLfloat * m) { +// (*fnptr)(matrixMode, m); +// } +// static void glowMatrixLoadIdentityEXT(GPMATRIXLOADIDENTITYEXT fnptr, GLenum mode) { +// (*fnptr)(mode); +// } +// static void glowMatrixLoadTranspose3x3fNV(GPMATRIXLOADTRANSPOSE3X3FNV fnptr, GLenum matrixMode, const GLfloat * m) { +// (*fnptr)(matrixMode, m); +// } +// static void glowMatrixLoadTransposedEXT(GPMATRIXLOADTRANSPOSEDEXT fnptr, GLenum mode, const GLdouble * m) { +// (*fnptr)(mode, m); +// } +// static void glowMatrixLoadTransposefEXT(GPMATRIXLOADTRANSPOSEFEXT fnptr, GLenum mode, const GLfloat * m) { +// (*fnptr)(mode, m); +// } +// static void glowMatrixLoaddEXT(GPMATRIXLOADDEXT fnptr, GLenum mode, const GLdouble * m) { +// (*fnptr)(mode, m); +// } +// static void glowMatrixLoadfEXT(GPMATRIXLOADFEXT fnptr, GLenum mode, const GLfloat * m) { +// (*fnptr)(mode, m); +// } +// static void glowMatrixMult3x2fNV(GPMATRIXMULT3X2FNV fnptr, GLenum matrixMode, const GLfloat * m) { +// (*fnptr)(matrixMode, m); +// } +// static void glowMatrixMult3x3fNV(GPMATRIXMULT3X3FNV fnptr, GLenum matrixMode, const GLfloat * m) { +// (*fnptr)(matrixMode, m); +// } +// static void glowMatrixMultTranspose3x3fNV(GPMATRIXMULTTRANSPOSE3X3FNV fnptr, GLenum matrixMode, const GLfloat * m) { +// (*fnptr)(matrixMode, m); +// } +// static void glowMatrixMultTransposedEXT(GPMATRIXMULTTRANSPOSEDEXT fnptr, GLenum mode, const GLdouble * m) { +// (*fnptr)(mode, m); +// } +// static void glowMatrixMultTransposefEXT(GPMATRIXMULTTRANSPOSEFEXT fnptr, GLenum mode, const GLfloat * m) { +// (*fnptr)(mode, m); +// } +// static void glowMatrixMultdEXT(GPMATRIXMULTDEXT fnptr, GLenum mode, const GLdouble * m) { +// (*fnptr)(mode, m); +// } +// static void glowMatrixMultfEXT(GPMATRIXMULTFEXT fnptr, GLenum mode, const GLfloat * m) { +// (*fnptr)(mode, m); +// } +// static void glowMatrixOrthoEXT(GPMATRIXORTHOEXT fnptr, GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) { +// (*fnptr)(mode, left, right, bottom, top, zNear, zFar); +// } +// static void glowMatrixPopEXT(GPMATRIXPOPEXT fnptr, GLenum mode) { +// (*fnptr)(mode); +// } +// static void glowMatrixPushEXT(GPMATRIXPUSHEXT fnptr, GLenum mode) { +// (*fnptr)(mode); +// } +// static void glowMatrixRotatedEXT(GPMATRIXROTATEDEXT fnptr, GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) { +// (*fnptr)(mode, angle, x, y, z); +// } +// static void glowMatrixRotatefEXT(GPMATRIXROTATEFEXT fnptr, GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) { +// (*fnptr)(mode, angle, x, y, z); +// } +// static void glowMatrixScaledEXT(GPMATRIXSCALEDEXT fnptr, GLenum mode, GLdouble x, GLdouble y, GLdouble z) { +// (*fnptr)(mode, x, y, z); +// } +// static void glowMatrixScalefEXT(GPMATRIXSCALEFEXT fnptr, GLenum mode, GLfloat x, GLfloat y, GLfloat z) { +// (*fnptr)(mode, x, y, z); +// } +// static void glowMatrixTranslatedEXT(GPMATRIXTRANSLATEDEXT fnptr, GLenum mode, GLdouble x, GLdouble y, GLdouble z) { +// (*fnptr)(mode, x, y, z); +// } +// static void glowMatrixTranslatefEXT(GPMATRIXTRANSLATEFEXT fnptr, GLenum mode, GLfloat x, GLfloat y, GLfloat z) { +// (*fnptr)(mode, x, y, z); +// } +// static void glowMaxShaderCompilerThreadsARB(GPMAXSHADERCOMPILERTHREADSARB fnptr, GLuint count) { +// (*fnptr)(count); +// } +// static void glowMaxShaderCompilerThreadsKHR(GPMAXSHADERCOMPILERTHREADSKHR fnptr, GLuint count) { +// (*fnptr)(count); +// } +// static void glowMemoryBarrier(GPMEMORYBARRIER fnptr, GLbitfield barriers) { +// (*fnptr)(barriers); +// } +// static void glowMemoryBarrierByRegion(GPMEMORYBARRIERBYREGION fnptr, GLbitfield barriers) { +// (*fnptr)(barriers); +// } +// static void glowMinSampleShadingARB(GPMINSAMPLESHADINGARB fnptr, GLfloat value) { +// (*fnptr)(value); +// } +// static void glowMultiDrawArrays(GPMULTIDRAWARRAYS fnptr, GLenum mode, const GLint * first, const GLsizei * count, GLsizei drawcount) { +// (*fnptr)(mode, first, count, drawcount); +// } +// static void glowMultiDrawArraysIndirect(GPMULTIDRAWARRAYSINDIRECT fnptr, GLenum mode, const void * indirect, GLsizei drawcount, GLsizei stride) { +// (*fnptr)(mode, indirect, drawcount, stride); +// } +// static void glowMultiDrawArraysIndirectBindlessCountNV(GPMULTIDRAWARRAYSINDIRECTBINDLESSCOUNTNV fnptr, GLenum mode, const void * indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount) { +// (*fnptr)(mode, indirect, drawCount, maxDrawCount, stride, vertexBufferCount); +// } +// static void glowMultiDrawArraysIndirectBindlessNV(GPMULTIDRAWARRAYSINDIRECTBINDLESSNV fnptr, GLenum mode, const void * indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount) { +// (*fnptr)(mode, indirect, drawCount, stride, vertexBufferCount); +// } +// static void glowMultiDrawArraysIndirectCountARB(GPMULTIDRAWARRAYSINDIRECTCOUNTARB fnptr, GLenum mode, const void * indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride) { +// (*fnptr)(mode, indirect, drawcount, maxdrawcount, stride); +// } +// static void glowMultiDrawElements(GPMULTIDRAWELEMENTS fnptr, GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount) { +// (*fnptr)(mode, count, type, indices, drawcount); +// } +// static void glowMultiDrawElementsBaseVertex(GPMULTIDRAWELEMENTSBASEVERTEX fnptr, GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount, const GLint * basevertex) { +// (*fnptr)(mode, count, type, indices, drawcount, basevertex); +// } +// static void glowMultiDrawElementsIndirect(GPMULTIDRAWELEMENTSINDIRECT fnptr, GLenum mode, GLenum type, const void * indirect, GLsizei drawcount, GLsizei stride) { +// (*fnptr)(mode, type, indirect, drawcount, stride); +// } +// static void glowMultiDrawElementsIndirectBindlessCountNV(GPMULTIDRAWELEMENTSINDIRECTBINDLESSCOUNTNV fnptr, GLenum mode, GLenum type, const void * indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount) { +// (*fnptr)(mode, type, indirect, drawCount, maxDrawCount, stride, vertexBufferCount); +// } +// static void glowMultiDrawElementsIndirectBindlessNV(GPMULTIDRAWELEMENTSINDIRECTBINDLESSNV fnptr, GLenum mode, GLenum type, const void * indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount) { +// (*fnptr)(mode, type, indirect, drawCount, stride, vertexBufferCount); +// } +// static void glowMultiDrawElementsIndirectCountARB(GPMULTIDRAWELEMENTSINDIRECTCOUNTARB fnptr, GLenum mode, GLenum type, const void * indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride) { +// (*fnptr)(mode, type, indirect, drawcount, maxdrawcount, stride); +// } +// static void glowMultiDrawMeshTasksIndirectCountNV(GPMULTIDRAWMESHTASKSINDIRECTCOUNTNV fnptr, GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride) { +// (*fnptr)(indirect, drawcount, maxdrawcount, stride); +// } +// static void glowMultiDrawMeshTasksIndirectNV(GPMULTIDRAWMESHTASKSINDIRECTNV fnptr, GLintptr indirect, GLsizei drawcount, GLsizei stride) { +// (*fnptr)(indirect, drawcount, stride); +// } +// static void glowMultiTexBufferEXT(GPMULTITEXBUFFEREXT fnptr, GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer) { +// (*fnptr)(texunit, target, internalformat, buffer); +// } +// static void glowMultiTexCoordPointerEXT(GPMULTITEXCOORDPOINTEREXT fnptr, GLenum texunit, GLint size, GLenum type, GLsizei stride, const void * pointer) { +// (*fnptr)(texunit, size, type, stride, pointer); +// } +// static void glowMultiTexEnvfEXT(GPMULTITEXENVFEXT fnptr, GLenum texunit, GLenum target, GLenum pname, GLfloat param) { +// (*fnptr)(texunit, target, pname, param); +// } +// static void glowMultiTexEnvfvEXT(GPMULTITEXENVFVEXT fnptr, GLenum texunit, GLenum target, GLenum pname, const GLfloat * params) { +// (*fnptr)(texunit, target, pname, params); +// } +// static void glowMultiTexEnviEXT(GPMULTITEXENVIEXT fnptr, GLenum texunit, GLenum target, GLenum pname, GLint param) { +// (*fnptr)(texunit, target, pname, param); +// } +// static void glowMultiTexEnvivEXT(GPMULTITEXENVIVEXT fnptr, GLenum texunit, GLenum target, GLenum pname, const GLint * params) { +// (*fnptr)(texunit, target, pname, params); +// } +// static void glowMultiTexGendEXT(GPMULTITEXGENDEXT fnptr, GLenum texunit, GLenum coord, GLenum pname, GLdouble param) { +// (*fnptr)(texunit, coord, pname, param); +// } +// static void glowMultiTexGendvEXT(GPMULTITEXGENDVEXT fnptr, GLenum texunit, GLenum coord, GLenum pname, const GLdouble * params) { +// (*fnptr)(texunit, coord, pname, params); +// } +// static void glowMultiTexGenfEXT(GPMULTITEXGENFEXT fnptr, GLenum texunit, GLenum coord, GLenum pname, GLfloat param) { +// (*fnptr)(texunit, coord, pname, param); +// } +// static void glowMultiTexGenfvEXT(GPMULTITEXGENFVEXT fnptr, GLenum texunit, GLenum coord, GLenum pname, const GLfloat * params) { +// (*fnptr)(texunit, coord, pname, params); +// } +// static void glowMultiTexGeniEXT(GPMULTITEXGENIEXT fnptr, GLenum texunit, GLenum coord, GLenum pname, GLint param) { +// (*fnptr)(texunit, coord, pname, param); +// } +// static void glowMultiTexGenivEXT(GPMULTITEXGENIVEXT fnptr, GLenum texunit, GLenum coord, GLenum pname, const GLint * params) { +// (*fnptr)(texunit, coord, pname, params); +// } +// static void glowMultiTexImage1DEXT(GPMULTITEXIMAGE1DEXT fnptr, GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(texunit, target, level, internalformat, width, border, format, type, pixels); +// } +// static void glowMultiTexImage2DEXT(GPMULTITEXIMAGE2DEXT fnptr, GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(texunit, target, level, internalformat, width, height, border, format, type, pixels); +// } +// static void glowMultiTexImage3DEXT(GPMULTITEXIMAGE3DEXT fnptr, GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(texunit, target, level, internalformat, width, height, depth, border, format, type, pixels); +// } +// static void glowMultiTexParameterIivEXT(GPMULTITEXPARAMETERIIVEXT fnptr, GLenum texunit, GLenum target, GLenum pname, const GLint * params) { +// (*fnptr)(texunit, target, pname, params); +// } +// static void glowMultiTexParameterIuivEXT(GPMULTITEXPARAMETERIUIVEXT fnptr, GLenum texunit, GLenum target, GLenum pname, const GLuint * params) { +// (*fnptr)(texunit, target, pname, params); +// } +// static void glowMultiTexParameterfEXT(GPMULTITEXPARAMETERFEXT fnptr, GLenum texunit, GLenum target, GLenum pname, GLfloat param) { +// (*fnptr)(texunit, target, pname, param); +// } +// static void glowMultiTexParameterfvEXT(GPMULTITEXPARAMETERFVEXT fnptr, GLenum texunit, GLenum target, GLenum pname, const GLfloat * params) { +// (*fnptr)(texunit, target, pname, params); +// } +// static void glowMultiTexParameteriEXT(GPMULTITEXPARAMETERIEXT fnptr, GLenum texunit, GLenum target, GLenum pname, GLint param) { +// (*fnptr)(texunit, target, pname, param); +// } +// static void glowMultiTexParameterivEXT(GPMULTITEXPARAMETERIVEXT fnptr, GLenum texunit, GLenum target, GLenum pname, const GLint * params) { +// (*fnptr)(texunit, target, pname, params); +// } +// static void glowMultiTexRenderbufferEXT(GPMULTITEXRENDERBUFFEREXT fnptr, GLenum texunit, GLenum target, GLuint renderbuffer) { +// (*fnptr)(texunit, target, renderbuffer); +// } +// static void glowMultiTexSubImage1DEXT(GPMULTITEXSUBIMAGE1DEXT fnptr, GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(texunit, target, level, xoffset, width, format, type, pixels); +// } +// static void glowMultiTexSubImage2DEXT(GPMULTITEXSUBIMAGE2DEXT fnptr, GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(texunit, target, level, xoffset, yoffset, width, height, format, type, pixels); +// } +// static void glowMultiTexSubImage3DEXT(GPMULTITEXSUBIMAGE3DEXT fnptr, GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); +// } +// static void glowNamedBufferAttachMemoryNV(GPNAMEDBUFFERATTACHMEMORYNV fnptr, GLuint buffer, GLuint memory, GLuint64 offset) { +// (*fnptr)(buffer, memory, offset); +// } +// static void glowNamedBufferData(GPNAMEDBUFFERDATA fnptr, GLuint buffer, GLsizeiptr size, const void * data, GLenum usage) { +// (*fnptr)(buffer, size, data, usage); +// } +// static void glowNamedBufferDataEXT(GPNAMEDBUFFERDATAEXT fnptr, GLuint buffer, GLsizeiptr size, const void * data, GLenum usage) { +// (*fnptr)(buffer, size, data, usage); +// } +// static void glowNamedBufferPageCommitmentARB(GPNAMEDBUFFERPAGECOMMITMENTARB fnptr, GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit) { +// (*fnptr)(buffer, offset, size, commit); +// } +// static void glowNamedBufferPageCommitmentEXT(GPNAMEDBUFFERPAGECOMMITMENTEXT fnptr, GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit) { +// (*fnptr)(buffer, offset, size, commit); +// } +// static void glowNamedBufferPageCommitmentMemNV(GPNAMEDBUFFERPAGECOMMITMENTMEMNV fnptr, GLuint buffer, GLintptr offset, GLsizeiptr size, GLuint memory, GLuint64 memOffset, GLboolean commit) { +// (*fnptr)(buffer, offset, size, memory, memOffset, commit); +// } +// static void glowNamedBufferStorage(GPNAMEDBUFFERSTORAGE fnptr, GLuint buffer, GLsizeiptr size, const void * data, GLbitfield flags) { +// (*fnptr)(buffer, size, data, flags); +// } +// static void glowNamedBufferStorageEXT(GPNAMEDBUFFERSTORAGEEXT fnptr, GLuint buffer, GLsizeiptr size, const void * data, GLbitfield flags) { +// (*fnptr)(buffer, size, data, flags); +// } +// static void glowNamedBufferSubData(GPNAMEDBUFFERSUBDATA fnptr, GLuint buffer, GLintptr offset, GLsizeiptr size, const void * data) { +// (*fnptr)(buffer, offset, size, data); +// } +// static void glowNamedBufferSubDataEXT(GPNAMEDBUFFERSUBDATAEXT fnptr, GLuint buffer, GLintptr offset, GLsizeiptr size, const void * data) { +// (*fnptr)(buffer, offset, size, data); +// } +// static void glowNamedCopyBufferSubDataEXT(GPNAMEDCOPYBUFFERSUBDATAEXT fnptr, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) { +// (*fnptr)(readBuffer, writeBuffer, readOffset, writeOffset, size); +// } +// static void glowNamedFramebufferDrawBuffer(GPNAMEDFRAMEBUFFERDRAWBUFFER fnptr, GLuint framebuffer, GLenum buf) { +// (*fnptr)(framebuffer, buf); +// } +// static void glowNamedFramebufferDrawBuffers(GPNAMEDFRAMEBUFFERDRAWBUFFERS fnptr, GLuint framebuffer, GLsizei n, const GLenum * bufs) { +// (*fnptr)(framebuffer, n, bufs); +// } +// static void glowNamedFramebufferParameteri(GPNAMEDFRAMEBUFFERPARAMETERI fnptr, GLuint framebuffer, GLenum pname, GLint param) { +// (*fnptr)(framebuffer, pname, param); +// } +// static void glowNamedFramebufferParameteriEXT(GPNAMEDFRAMEBUFFERPARAMETERIEXT fnptr, GLuint framebuffer, GLenum pname, GLint param) { +// (*fnptr)(framebuffer, pname, param); +// } +// static void glowNamedFramebufferReadBuffer(GPNAMEDFRAMEBUFFERREADBUFFER fnptr, GLuint framebuffer, GLenum src) { +// (*fnptr)(framebuffer, src); +// } +// static void glowNamedFramebufferRenderbuffer(GPNAMEDFRAMEBUFFERRENDERBUFFER fnptr, GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { +// (*fnptr)(framebuffer, attachment, renderbuffertarget, renderbuffer); +// } +// static void glowNamedFramebufferRenderbufferEXT(GPNAMEDFRAMEBUFFERRENDERBUFFEREXT fnptr, GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { +// (*fnptr)(framebuffer, attachment, renderbuffertarget, renderbuffer); +// } +// static void glowNamedFramebufferSampleLocationsfvARB(GPNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARB fnptr, GLuint framebuffer, GLuint start, GLsizei count, const GLfloat * v) { +// (*fnptr)(framebuffer, start, count, v); +// } +// static void glowNamedFramebufferSampleLocationsfvNV(GPNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNV fnptr, GLuint framebuffer, GLuint start, GLsizei count, const GLfloat * v) { +// (*fnptr)(framebuffer, start, count, v); +// } +// static void glowNamedFramebufferTexture(GPNAMEDFRAMEBUFFERTEXTURE fnptr, GLuint framebuffer, GLenum attachment, GLuint texture, GLint level) { +// (*fnptr)(framebuffer, attachment, texture, level); +// } +// static void glowNamedFramebufferTexture1DEXT(GPNAMEDFRAMEBUFFERTEXTURE1DEXT fnptr, GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { +// (*fnptr)(framebuffer, attachment, textarget, texture, level); +// } +// static void glowNamedFramebufferTexture2DEXT(GPNAMEDFRAMEBUFFERTEXTURE2DEXT fnptr, GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { +// (*fnptr)(framebuffer, attachment, textarget, texture, level); +// } +// static void glowNamedFramebufferTexture3DEXT(GPNAMEDFRAMEBUFFERTEXTURE3DEXT fnptr, GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) { +// (*fnptr)(framebuffer, attachment, textarget, texture, level, zoffset); +// } +// static void glowNamedFramebufferTextureEXT(GPNAMEDFRAMEBUFFERTEXTUREEXT fnptr, GLuint framebuffer, GLenum attachment, GLuint texture, GLint level) { +// (*fnptr)(framebuffer, attachment, texture, level); +// } +// static void glowNamedFramebufferTextureFaceEXT(GPNAMEDFRAMEBUFFERTEXTUREFACEEXT fnptr, GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face) { +// (*fnptr)(framebuffer, attachment, texture, level, face); +// } +// static void glowNamedFramebufferTextureLayer(GPNAMEDFRAMEBUFFERTEXTURELAYER fnptr, GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer) { +// (*fnptr)(framebuffer, attachment, texture, level, layer); +// } +// static void glowNamedFramebufferTextureLayerEXT(GPNAMEDFRAMEBUFFERTEXTURELAYEREXT fnptr, GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer) { +// (*fnptr)(framebuffer, attachment, texture, level, layer); +// } +// static void glowNamedProgramLocalParameter4dEXT(GPNAMEDPROGRAMLOCALPARAMETER4DEXT fnptr, GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { +// (*fnptr)(program, target, index, x, y, z, w); +// } +// static void glowNamedProgramLocalParameter4dvEXT(GPNAMEDPROGRAMLOCALPARAMETER4DVEXT fnptr, GLuint program, GLenum target, GLuint index, const GLdouble * params) { +// (*fnptr)(program, target, index, params); +// } +// static void glowNamedProgramLocalParameter4fEXT(GPNAMEDPROGRAMLOCALPARAMETER4FEXT fnptr, GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { +// (*fnptr)(program, target, index, x, y, z, w); +// } +// static void glowNamedProgramLocalParameter4fvEXT(GPNAMEDPROGRAMLOCALPARAMETER4FVEXT fnptr, GLuint program, GLenum target, GLuint index, const GLfloat * params) { +// (*fnptr)(program, target, index, params); +// } +// static void glowNamedProgramLocalParameterI4iEXT(GPNAMEDPROGRAMLOCALPARAMETERI4IEXT fnptr, GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w) { +// (*fnptr)(program, target, index, x, y, z, w); +// } +// static void glowNamedProgramLocalParameterI4ivEXT(GPNAMEDPROGRAMLOCALPARAMETERI4IVEXT fnptr, GLuint program, GLenum target, GLuint index, const GLint * params) { +// (*fnptr)(program, target, index, params); +// } +// static void glowNamedProgramLocalParameterI4uiEXT(GPNAMEDPROGRAMLOCALPARAMETERI4UIEXT fnptr, GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) { +// (*fnptr)(program, target, index, x, y, z, w); +// } +// static void glowNamedProgramLocalParameterI4uivEXT(GPNAMEDPROGRAMLOCALPARAMETERI4UIVEXT fnptr, GLuint program, GLenum target, GLuint index, const GLuint * params) { +// (*fnptr)(program, target, index, params); +// } +// static void glowNamedProgramLocalParameters4fvEXT(GPNAMEDPROGRAMLOCALPARAMETERS4FVEXT fnptr, GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat * params) { +// (*fnptr)(program, target, index, count, params); +// } +// static void glowNamedProgramLocalParametersI4ivEXT(GPNAMEDPROGRAMLOCALPARAMETERSI4IVEXT fnptr, GLuint program, GLenum target, GLuint index, GLsizei count, const GLint * params) { +// (*fnptr)(program, target, index, count, params); +// } +// static void glowNamedProgramLocalParametersI4uivEXT(GPNAMEDPROGRAMLOCALPARAMETERSI4UIVEXT fnptr, GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint * params) { +// (*fnptr)(program, target, index, count, params); +// } +// static void glowNamedProgramStringEXT(GPNAMEDPROGRAMSTRINGEXT fnptr, GLuint program, GLenum target, GLenum format, GLsizei len, const void * string) { +// (*fnptr)(program, target, format, len, string); +// } +// static void glowNamedRenderbufferStorage(GPNAMEDRENDERBUFFERSTORAGE fnptr, GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height) { +// (*fnptr)(renderbuffer, internalformat, width, height); +// } +// static void glowNamedRenderbufferStorageEXT(GPNAMEDRENDERBUFFERSTORAGEEXT fnptr, GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height) { +// (*fnptr)(renderbuffer, internalformat, width, height); +// } +// static void glowNamedRenderbufferStorageMultisample(GPNAMEDRENDERBUFFERSTORAGEMULTISAMPLE fnptr, GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) { +// (*fnptr)(renderbuffer, samples, internalformat, width, height); +// } +// static void glowNamedRenderbufferStorageMultisampleAdvancedAMD(GPNAMEDRENDERBUFFERSTORAGEMULTISAMPLEADVANCEDAMD fnptr, GLuint renderbuffer, GLsizei samples, GLsizei storageSamples, GLenum internalformat, GLsizei width, GLsizei height) { +// (*fnptr)(renderbuffer, samples, storageSamples, internalformat, width, height); +// } +// static void glowNamedRenderbufferStorageMultisampleCoverageEXT(GPNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXT fnptr, GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height) { +// (*fnptr)(renderbuffer, coverageSamples, colorSamples, internalformat, width, height); +// } +// static void glowNamedRenderbufferStorageMultisampleEXT(GPNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXT fnptr, GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) { +// (*fnptr)(renderbuffer, samples, internalformat, width, height); +// } +// static void glowNamedStringARB(GPNAMEDSTRINGARB fnptr, GLenum type, GLint namelen, const GLchar * name, GLint stringlen, const GLchar * string) { +// (*fnptr)(type, namelen, name, stringlen, string); +// } +// static void glowNormalFormatNV(GPNORMALFORMATNV fnptr, GLenum type, GLsizei stride) { +// (*fnptr)(type, stride); +// } +// static void glowObjectLabel(GPOBJECTLABEL fnptr, GLenum identifier, GLuint name, GLsizei length, const GLchar * label) { +// (*fnptr)(identifier, name, length, label); +// } +// static void glowObjectLabelKHR(GPOBJECTLABELKHR fnptr, GLenum identifier, GLuint name, GLsizei length, const GLchar * label) { +// (*fnptr)(identifier, name, length, label); +// } +// static void glowObjectPtrLabel(GPOBJECTPTRLABEL fnptr, const void * ptr, GLsizei length, const GLchar * label) { +// (*fnptr)(ptr, length, label); +// } +// static void glowObjectPtrLabelKHR(GPOBJECTPTRLABELKHR fnptr, const void * ptr, GLsizei length, const GLchar * label) { +// (*fnptr)(ptr, length, label); +// } +// static void glowPatchParameterfv(GPPATCHPARAMETERFV fnptr, GLenum pname, const GLfloat * values) { +// (*fnptr)(pname, values); +// } +// static void glowPatchParameteri(GPPATCHPARAMETERI fnptr, GLenum pname, GLint value) { +// (*fnptr)(pname, value); +// } +// static void glowPathCommandsNV(GPPATHCOMMANDSNV fnptr, GLuint path, GLsizei numCommands, const GLubyte * commands, GLsizei numCoords, GLenum coordType, const void * coords) { +// (*fnptr)(path, numCommands, commands, numCoords, coordType, coords); +// } +// static void glowPathCoordsNV(GPPATHCOORDSNV fnptr, GLuint path, GLsizei numCoords, GLenum coordType, const void * coords) { +// (*fnptr)(path, numCoords, coordType, coords); +// } +// static void glowPathCoverDepthFuncNV(GPPATHCOVERDEPTHFUNCNV fnptr, GLenum func) { +// (*fnptr)(func); +// } +// static void glowPathDashArrayNV(GPPATHDASHARRAYNV fnptr, GLuint path, GLsizei dashCount, const GLfloat * dashArray) { +// (*fnptr)(path, dashCount, dashArray); +// } +// static GLenum glowPathGlyphIndexArrayNV(GPPATHGLYPHINDEXARRAYNV fnptr, GLuint firstPathName, GLenum fontTarget, const void * fontName, GLbitfield fontStyle, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale) { +// return (*fnptr)(firstPathName, fontTarget, fontName, fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale); +// } +// static GLenum glowPathGlyphIndexRangeNV(GPPATHGLYPHINDEXRANGENV fnptr, GLenum fontTarget, const void * fontName, GLbitfield fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint * baseAndCount) { +// return (*fnptr)(fontTarget, fontName, fontStyle, pathParameterTemplate, emScale, baseAndCount); +// } +// static void glowPathGlyphRangeNV(GPPATHGLYPHRANGENV fnptr, GLuint firstPathName, GLenum fontTarget, const void * fontName, GLbitfield fontStyle, GLuint firstGlyph, GLsizei numGlyphs, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale) { +// (*fnptr)(firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale); +// } +// static void glowPathGlyphsNV(GPPATHGLYPHSNV fnptr, GLuint firstPathName, GLenum fontTarget, const void * fontName, GLbitfield fontStyle, GLsizei numGlyphs, GLenum type, const void * charcodes, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale) { +// (*fnptr)(firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale); +// } +// static GLenum glowPathMemoryGlyphIndexArrayNV(GPPATHMEMORYGLYPHINDEXARRAYNV fnptr, GLuint firstPathName, GLenum fontTarget, GLsizeiptr fontSize, const void * fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale) { +// return (*fnptr)(firstPathName, fontTarget, fontSize, fontData, faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale); +// } +// static void glowPathParameterfNV(GPPATHPARAMETERFNV fnptr, GLuint path, GLenum pname, GLfloat value) { +// (*fnptr)(path, pname, value); +// } +// static void glowPathParameterfvNV(GPPATHPARAMETERFVNV fnptr, GLuint path, GLenum pname, const GLfloat * value) { +// (*fnptr)(path, pname, value); +// } +// static void glowPathParameteriNV(GPPATHPARAMETERINV fnptr, GLuint path, GLenum pname, GLint value) { +// (*fnptr)(path, pname, value); +// } +// static void glowPathParameterivNV(GPPATHPARAMETERIVNV fnptr, GLuint path, GLenum pname, const GLint * value) { +// (*fnptr)(path, pname, value); +// } +// static void glowPathStencilDepthOffsetNV(GPPATHSTENCILDEPTHOFFSETNV fnptr, GLfloat factor, GLfloat units) { +// (*fnptr)(factor, units); +// } +// static void glowPathStencilFuncNV(GPPATHSTENCILFUNCNV fnptr, GLenum func, GLint ref, GLuint mask) { +// (*fnptr)(func, ref, mask); +// } +// static void glowPathStringNV(GPPATHSTRINGNV fnptr, GLuint path, GLenum format, GLsizei length, const void * pathString) { +// (*fnptr)(path, format, length, pathString); +// } +// static void glowPathSubCommandsNV(GPPATHSUBCOMMANDSNV fnptr, GLuint path, GLsizei commandStart, GLsizei commandsToDelete, GLsizei numCommands, const GLubyte * commands, GLsizei numCoords, GLenum coordType, const void * coords) { +// (*fnptr)(path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords); +// } +// static void glowPathSubCoordsNV(GPPATHSUBCOORDSNV fnptr, GLuint path, GLsizei coordStart, GLsizei numCoords, GLenum coordType, const void * coords) { +// (*fnptr)(path, coordStart, numCoords, coordType, coords); +// } +// static void glowPauseTransformFeedback(GPPAUSETRANSFORMFEEDBACK fnptr) { +// (*fnptr)(); +// } +// static void glowPixelStoref(GPPIXELSTOREF fnptr, GLenum pname, GLfloat param) { +// (*fnptr)(pname, param); +// } +// static void glowPixelStorei(GPPIXELSTOREI fnptr, GLenum pname, GLint param) { +// (*fnptr)(pname, param); +// } +// static GLboolean glowPointAlongPathNV(GPPOINTALONGPATHNV fnptr, GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, GLfloat * x, GLfloat * y, GLfloat * tangentX, GLfloat * tangentY) { +// return (*fnptr)(path, startSegment, numSegments, distance, x, y, tangentX, tangentY); +// } +// static void glowPointParameterf(GPPOINTPARAMETERF fnptr, GLenum pname, GLfloat param) { +// (*fnptr)(pname, param); +// } +// static void glowPointParameterfv(GPPOINTPARAMETERFV fnptr, GLenum pname, const GLfloat * params) { +// (*fnptr)(pname, params); +// } +// static void glowPointParameteri(GPPOINTPARAMETERI fnptr, GLenum pname, GLint param) { +// (*fnptr)(pname, param); +// } +// static void glowPointParameteriv(GPPOINTPARAMETERIV fnptr, GLenum pname, const GLint * params) { +// (*fnptr)(pname, params); +// } +// static void glowPointSize(GPPOINTSIZE fnptr, GLfloat size) { +// (*fnptr)(size); +// } +// static void glowPolygonMode(GPPOLYGONMODE fnptr, GLenum face, GLenum mode) { +// (*fnptr)(face, mode); +// } +// static void glowPolygonOffset(GPPOLYGONOFFSET fnptr, GLfloat factor, GLfloat units) { +// (*fnptr)(factor, units); +// } +// static void glowPolygonOffsetClamp(GPPOLYGONOFFSETCLAMP fnptr, GLfloat factor, GLfloat units, GLfloat clamp) { +// (*fnptr)(factor, units, clamp); +// } +// static void glowPolygonOffsetClampEXT(GPPOLYGONOFFSETCLAMPEXT fnptr, GLfloat factor, GLfloat units, GLfloat clamp) { +// (*fnptr)(factor, units, clamp); +// } +// static void glowPopDebugGroup(GPPOPDEBUGGROUP fnptr) { +// (*fnptr)(); +// } +// static void glowPopDebugGroupKHR(GPPOPDEBUGGROUPKHR fnptr) { +// (*fnptr)(); +// } +// static void glowPopGroupMarkerEXT(GPPOPGROUPMARKEREXT fnptr) { +// (*fnptr)(); +// } +// static void glowPrimitiveBoundingBoxARB(GPPRIMITIVEBOUNDINGBOXARB fnptr, GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW) { +// (*fnptr)(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW); +// } +// static void glowPrimitiveRestartIndex(GPPRIMITIVERESTARTINDEX fnptr, GLuint index) { +// (*fnptr)(index); +// } +// static void glowProgramBinary(GPPROGRAMBINARY fnptr, GLuint program, GLenum binaryFormat, const void * binary, GLsizei length) { +// (*fnptr)(program, binaryFormat, binary, length); +// } +// static void glowProgramParameteri(GPPROGRAMPARAMETERI fnptr, GLuint program, GLenum pname, GLint value) { +// (*fnptr)(program, pname, value); +// } +// static void glowProgramParameteriARB(GPPROGRAMPARAMETERIARB fnptr, GLuint program, GLenum pname, GLint value) { +// (*fnptr)(program, pname, value); +// } +// static void glowProgramParameteriEXT(GPPROGRAMPARAMETERIEXT fnptr, GLuint program, GLenum pname, GLint value) { +// (*fnptr)(program, pname, value); +// } +// static void glowProgramPathFragmentInputGenNV(GPPROGRAMPATHFRAGMENTINPUTGENNV fnptr, GLuint program, GLint location, GLenum genMode, GLint components, const GLfloat * coeffs) { +// (*fnptr)(program, location, genMode, components, coeffs); +// } +// static void glowProgramUniform1d(GPPROGRAMUNIFORM1D fnptr, GLuint program, GLint location, GLdouble v0) { +// (*fnptr)(program, location, v0); +// } +// static void glowProgramUniform1dEXT(GPPROGRAMUNIFORM1DEXT fnptr, GLuint program, GLint location, GLdouble x) { +// (*fnptr)(program, location, x); +// } +// static void glowProgramUniform1dv(GPPROGRAMUNIFORM1DV fnptr, GLuint program, GLint location, GLsizei count, const GLdouble * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform1dvEXT(GPPROGRAMUNIFORM1DVEXT fnptr, GLuint program, GLint location, GLsizei count, const GLdouble * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform1f(GPPROGRAMUNIFORM1F fnptr, GLuint program, GLint location, GLfloat v0) { +// (*fnptr)(program, location, v0); +// } +// static void glowProgramUniform1fEXT(GPPROGRAMUNIFORM1FEXT fnptr, GLuint program, GLint location, GLfloat v0) { +// (*fnptr)(program, location, v0); +// } +// static void glowProgramUniform1fv(GPPROGRAMUNIFORM1FV fnptr, GLuint program, GLint location, GLsizei count, const GLfloat * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform1fvEXT(GPPROGRAMUNIFORM1FVEXT fnptr, GLuint program, GLint location, GLsizei count, const GLfloat * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform1i(GPPROGRAMUNIFORM1I fnptr, GLuint program, GLint location, GLint v0) { +// (*fnptr)(program, location, v0); +// } +// static void glowProgramUniform1i64ARB(GPPROGRAMUNIFORM1I64ARB fnptr, GLuint program, GLint location, GLint64 x) { +// (*fnptr)(program, location, x); +// } +// static void glowProgramUniform1i64NV(GPPROGRAMUNIFORM1I64NV fnptr, GLuint program, GLint location, GLint64EXT x) { +// (*fnptr)(program, location, x); +// } +// static void glowProgramUniform1i64vARB(GPPROGRAMUNIFORM1I64VARB fnptr, GLuint program, GLint location, GLsizei count, const GLint64 * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform1i64vNV(GPPROGRAMUNIFORM1I64VNV fnptr, GLuint program, GLint location, GLsizei count, const GLint64EXT * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform1iEXT(GPPROGRAMUNIFORM1IEXT fnptr, GLuint program, GLint location, GLint v0) { +// (*fnptr)(program, location, v0); +// } +// static void glowProgramUniform1iv(GPPROGRAMUNIFORM1IV fnptr, GLuint program, GLint location, GLsizei count, const GLint * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform1ivEXT(GPPROGRAMUNIFORM1IVEXT fnptr, GLuint program, GLint location, GLsizei count, const GLint * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform1ui(GPPROGRAMUNIFORM1UI fnptr, GLuint program, GLint location, GLuint v0) { +// (*fnptr)(program, location, v0); +// } +// static void glowProgramUniform1ui64ARB(GPPROGRAMUNIFORM1UI64ARB fnptr, GLuint program, GLint location, GLuint64 x) { +// (*fnptr)(program, location, x); +// } +// static void glowProgramUniform1ui64NV(GPPROGRAMUNIFORM1UI64NV fnptr, GLuint program, GLint location, GLuint64EXT x) { +// (*fnptr)(program, location, x); +// } +// static void glowProgramUniform1ui64vARB(GPPROGRAMUNIFORM1UI64VARB fnptr, GLuint program, GLint location, GLsizei count, const GLuint64 * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform1ui64vNV(GPPROGRAMUNIFORM1UI64VNV fnptr, GLuint program, GLint location, GLsizei count, const GLuint64EXT * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform1uiEXT(GPPROGRAMUNIFORM1UIEXT fnptr, GLuint program, GLint location, GLuint v0) { +// (*fnptr)(program, location, v0); +// } +// static void glowProgramUniform1uiv(GPPROGRAMUNIFORM1UIV fnptr, GLuint program, GLint location, GLsizei count, const GLuint * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform1uivEXT(GPPROGRAMUNIFORM1UIVEXT fnptr, GLuint program, GLint location, GLsizei count, const GLuint * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform2d(GPPROGRAMUNIFORM2D fnptr, GLuint program, GLint location, GLdouble v0, GLdouble v1) { +// (*fnptr)(program, location, v0, v1); +// } +// static void glowProgramUniform2dEXT(GPPROGRAMUNIFORM2DEXT fnptr, GLuint program, GLint location, GLdouble x, GLdouble y) { +// (*fnptr)(program, location, x, y); +// } +// static void glowProgramUniform2dv(GPPROGRAMUNIFORM2DV fnptr, GLuint program, GLint location, GLsizei count, const GLdouble * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform2dvEXT(GPPROGRAMUNIFORM2DVEXT fnptr, GLuint program, GLint location, GLsizei count, const GLdouble * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform2f(GPPROGRAMUNIFORM2F fnptr, GLuint program, GLint location, GLfloat v0, GLfloat v1) { +// (*fnptr)(program, location, v0, v1); +// } +// static void glowProgramUniform2fEXT(GPPROGRAMUNIFORM2FEXT fnptr, GLuint program, GLint location, GLfloat v0, GLfloat v1) { +// (*fnptr)(program, location, v0, v1); +// } +// static void glowProgramUniform2fv(GPPROGRAMUNIFORM2FV fnptr, GLuint program, GLint location, GLsizei count, const GLfloat * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform2fvEXT(GPPROGRAMUNIFORM2FVEXT fnptr, GLuint program, GLint location, GLsizei count, const GLfloat * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform2i(GPPROGRAMUNIFORM2I fnptr, GLuint program, GLint location, GLint v0, GLint v1) { +// (*fnptr)(program, location, v0, v1); +// } +// static void glowProgramUniform2i64ARB(GPPROGRAMUNIFORM2I64ARB fnptr, GLuint program, GLint location, GLint64 x, GLint64 y) { +// (*fnptr)(program, location, x, y); +// } +// static void glowProgramUniform2i64NV(GPPROGRAMUNIFORM2I64NV fnptr, GLuint program, GLint location, GLint64EXT x, GLint64EXT y) { +// (*fnptr)(program, location, x, y); +// } +// static void glowProgramUniform2i64vARB(GPPROGRAMUNIFORM2I64VARB fnptr, GLuint program, GLint location, GLsizei count, const GLint64 * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform2i64vNV(GPPROGRAMUNIFORM2I64VNV fnptr, GLuint program, GLint location, GLsizei count, const GLint64EXT * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform2iEXT(GPPROGRAMUNIFORM2IEXT fnptr, GLuint program, GLint location, GLint v0, GLint v1) { +// (*fnptr)(program, location, v0, v1); +// } +// static void glowProgramUniform2iv(GPPROGRAMUNIFORM2IV fnptr, GLuint program, GLint location, GLsizei count, const GLint * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform2ivEXT(GPPROGRAMUNIFORM2IVEXT fnptr, GLuint program, GLint location, GLsizei count, const GLint * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform2ui(GPPROGRAMUNIFORM2UI fnptr, GLuint program, GLint location, GLuint v0, GLuint v1) { +// (*fnptr)(program, location, v0, v1); +// } +// static void glowProgramUniform2ui64ARB(GPPROGRAMUNIFORM2UI64ARB fnptr, GLuint program, GLint location, GLuint64 x, GLuint64 y) { +// (*fnptr)(program, location, x, y); +// } +// static void glowProgramUniform2ui64NV(GPPROGRAMUNIFORM2UI64NV fnptr, GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y) { +// (*fnptr)(program, location, x, y); +// } +// static void glowProgramUniform2ui64vARB(GPPROGRAMUNIFORM2UI64VARB fnptr, GLuint program, GLint location, GLsizei count, const GLuint64 * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform2ui64vNV(GPPROGRAMUNIFORM2UI64VNV fnptr, GLuint program, GLint location, GLsizei count, const GLuint64EXT * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform2uiEXT(GPPROGRAMUNIFORM2UIEXT fnptr, GLuint program, GLint location, GLuint v0, GLuint v1) { +// (*fnptr)(program, location, v0, v1); +// } +// static void glowProgramUniform2uiv(GPPROGRAMUNIFORM2UIV fnptr, GLuint program, GLint location, GLsizei count, const GLuint * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform2uivEXT(GPPROGRAMUNIFORM2UIVEXT fnptr, GLuint program, GLint location, GLsizei count, const GLuint * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform3d(GPPROGRAMUNIFORM3D fnptr, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) { +// (*fnptr)(program, location, v0, v1, v2); +// } +// static void glowProgramUniform3dEXT(GPPROGRAMUNIFORM3DEXT fnptr, GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z) { +// (*fnptr)(program, location, x, y, z); +// } +// static void glowProgramUniform3dv(GPPROGRAMUNIFORM3DV fnptr, GLuint program, GLint location, GLsizei count, const GLdouble * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform3dvEXT(GPPROGRAMUNIFORM3DVEXT fnptr, GLuint program, GLint location, GLsizei count, const GLdouble * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform3f(GPPROGRAMUNIFORM3F fnptr, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) { +// (*fnptr)(program, location, v0, v1, v2); +// } +// static void glowProgramUniform3fEXT(GPPROGRAMUNIFORM3FEXT fnptr, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) { +// (*fnptr)(program, location, v0, v1, v2); +// } +// static void glowProgramUniform3fv(GPPROGRAMUNIFORM3FV fnptr, GLuint program, GLint location, GLsizei count, const GLfloat * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform3fvEXT(GPPROGRAMUNIFORM3FVEXT fnptr, GLuint program, GLint location, GLsizei count, const GLfloat * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform3i(GPPROGRAMUNIFORM3I fnptr, GLuint program, GLint location, GLint v0, GLint v1, GLint v2) { +// (*fnptr)(program, location, v0, v1, v2); +// } +// static void glowProgramUniform3i64ARB(GPPROGRAMUNIFORM3I64ARB fnptr, GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z) { +// (*fnptr)(program, location, x, y, z); +// } +// static void glowProgramUniform3i64NV(GPPROGRAMUNIFORM3I64NV fnptr, GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z) { +// (*fnptr)(program, location, x, y, z); +// } +// static void glowProgramUniform3i64vARB(GPPROGRAMUNIFORM3I64VARB fnptr, GLuint program, GLint location, GLsizei count, const GLint64 * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform3i64vNV(GPPROGRAMUNIFORM3I64VNV fnptr, GLuint program, GLint location, GLsizei count, const GLint64EXT * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform3iEXT(GPPROGRAMUNIFORM3IEXT fnptr, GLuint program, GLint location, GLint v0, GLint v1, GLint v2) { +// (*fnptr)(program, location, v0, v1, v2); +// } +// static void glowProgramUniform3iv(GPPROGRAMUNIFORM3IV fnptr, GLuint program, GLint location, GLsizei count, const GLint * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform3ivEXT(GPPROGRAMUNIFORM3IVEXT fnptr, GLuint program, GLint location, GLsizei count, const GLint * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform3ui(GPPROGRAMUNIFORM3UI fnptr, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) { +// (*fnptr)(program, location, v0, v1, v2); +// } +// static void glowProgramUniform3ui64ARB(GPPROGRAMUNIFORM3UI64ARB fnptr, GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z) { +// (*fnptr)(program, location, x, y, z); +// } +// static void glowProgramUniform3ui64NV(GPPROGRAMUNIFORM3UI64NV fnptr, GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z) { +// (*fnptr)(program, location, x, y, z); +// } +// static void glowProgramUniform3ui64vARB(GPPROGRAMUNIFORM3UI64VARB fnptr, GLuint program, GLint location, GLsizei count, const GLuint64 * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform3ui64vNV(GPPROGRAMUNIFORM3UI64VNV fnptr, GLuint program, GLint location, GLsizei count, const GLuint64EXT * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform3uiEXT(GPPROGRAMUNIFORM3UIEXT fnptr, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) { +// (*fnptr)(program, location, v0, v1, v2); +// } +// static void glowProgramUniform3uiv(GPPROGRAMUNIFORM3UIV fnptr, GLuint program, GLint location, GLsizei count, const GLuint * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform3uivEXT(GPPROGRAMUNIFORM3UIVEXT fnptr, GLuint program, GLint location, GLsizei count, const GLuint * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform4d(GPPROGRAMUNIFORM4D fnptr, GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) { +// (*fnptr)(program, location, v0, v1, v2, v3); +// } +// static void glowProgramUniform4dEXT(GPPROGRAMUNIFORM4DEXT fnptr, GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { +// (*fnptr)(program, location, x, y, z, w); +// } +// static void glowProgramUniform4dv(GPPROGRAMUNIFORM4DV fnptr, GLuint program, GLint location, GLsizei count, const GLdouble * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform4dvEXT(GPPROGRAMUNIFORM4DVEXT fnptr, GLuint program, GLint location, GLsizei count, const GLdouble * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform4f(GPPROGRAMUNIFORM4F fnptr, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) { +// (*fnptr)(program, location, v0, v1, v2, v3); +// } +// static void glowProgramUniform4fEXT(GPPROGRAMUNIFORM4FEXT fnptr, GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) { +// (*fnptr)(program, location, v0, v1, v2, v3); +// } +// static void glowProgramUniform4fv(GPPROGRAMUNIFORM4FV fnptr, GLuint program, GLint location, GLsizei count, const GLfloat * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform4fvEXT(GPPROGRAMUNIFORM4FVEXT fnptr, GLuint program, GLint location, GLsizei count, const GLfloat * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform4i(GPPROGRAMUNIFORM4I fnptr, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) { +// (*fnptr)(program, location, v0, v1, v2, v3); +// } +// static void glowProgramUniform4i64ARB(GPPROGRAMUNIFORM4I64ARB fnptr, GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w) { +// (*fnptr)(program, location, x, y, z, w); +// } +// static void glowProgramUniform4i64NV(GPPROGRAMUNIFORM4I64NV fnptr, GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w) { +// (*fnptr)(program, location, x, y, z, w); +// } +// static void glowProgramUniform4i64vARB(GPPROGRAMUNIFORM4I64VARB fnptr, GLuint program, GLint location, GLsizei count, const GLint64 * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform4i64vNV(GPPROGRAMUNIFORM4I64VNV fnptr, GLuint program, GLint location, GLsizei count, const GLint64EXT * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform4iEXT(GPPROGRAMUNIFORM4IEXT fnptr, GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) { +// (*fnptr)(program, location, v0, v1, v2, v3); +// } +// static void glowProgramUniform4iv(GPPROGRAMUNIFORM4IV fnptr, GLuint program, GLint location, GLsizei count, const GLint * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform4ivEXT(GPPROGRAMUNIFORM4IVEXT fnptr, GLuint program, GLint location, GLsizei count, const GLint * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform4ui(GPPROGRAMUNIFORM4UI fnptr, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) { +// (*fnptr)(program, location, v0, v1, v2, v3); +// } +// static void glowProgramUniform4ui64ARB(GPPROGRAMUNIFORM4UI64ARB fnptr, GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w) { +// (*fnptr)(program, location, x, y, z, w); +// } +// static void glowProgramUniform4ui64NV(GPPROGRAMUNIFORM4UI64NV fnptr, GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w) { +// (*fnptr)(program, location, x, y, z, w); +// } +// static void glowProgramUniform4ui64vARB(GPPROGRAMUNIFORM4UI64VARB fnptr, GLuint program, GLint location, GLsizei count, const GLuint64 * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform4ui64vNV(GPPROGRAMUNIFORM4UI64VNV fnptr, GLuint program, GLint location, GLsizei count, const GLuint64EXT * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform4uiEXT(GPPROGRAMUNIFORM4UIEXT fnptr, GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) { +// (*fnptr)(program, location, v0, v1, v2, v3); +// } +// static void glowProgramUniform4uiv(GPPROGRAMUNIFORM4UIV fnptr, GLuint program, GLint location, GLsizei count, const GLuint * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniform4uivEXT(GPPROGRAMUNIFORM4UIVEXT fnptr, GLuint program, GLint location, GLsizei count, const GLuint * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProgramUniformHandleui64ARB(GPPROGRAMUNIFORMHANDLEUI64ARB fnptr, GLuint program, GLint location, GLuint64 value) { +// (*fnptr)(program, location, value); +// } +// static void glowProgramUniformHandleui64NV(GPPROGRAMUNIFORMHANDLEUI64NV fnptr, GLuint program, GLint location, GLuint64 value) { +// (*fnptr)(program, location, value); +// } +// static void glowProgramUniformHandleui64vARB(GPPROGRAMUNIFORMHANDLEUI64VARB fnptr, GLuint program, GLint location, GLsizei count, const GLuint64 * values) { +// (*fnptr)(program, location, count, values); +// } +// static void glowProgramUniformHandleui64vNV(GPPROGRAMUNIFORMHANDLEUI64VNV fnptr, GLuint program, GLint location, GLsizei count, const GLuint64 * values) { +// (*fnptr)(program, location, count, values); +// } +// static void glowProgramUniformMatrix2dv(GPPROGRAMUNIFORMMATRIX2DV fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix2dvEXT(GPPROGRAMUNIFORMMATRIX2DVEXT fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix2fv(GPPROGRAMUNIFORMMATRIX2FV fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix2fvEXT(GPPROGRAMUNIFORMMATRIX2FVEXT fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix2x3dv(GPPROGRAMUNIFORMMATRIX2X3DV fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix2x3dvEXT(GPPROGRAMUNIFORMMATRIX2X3DVEXT fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix2x3fv(GPPROGRAMUNIFORMMATRIX2X3FV fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix2x3fvEXT(GPPROGRAMUNIFORMMATRIX2X3FVEXT fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix2x4dv(GPPROGRAMUNIFORMMATRIX2X4DV fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix2x4dvEXT(GPPROGRAMUNIFORMMATRIX2X4DVEXT fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix2x4fv(GPPROGRAMUNIFORMMATRIX2X4FV fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix2x4fvEXT(GPPROGRAMUNIFORMMATRIX2X4FVEXT fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix3dv(GPPROGRAMUNIFORMMATRIX3DV fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix3dvEXT(GPPROGRAMUNIFORMMATRIX3DVEXT fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix3fv(GPPROGRAMUNIFORMMATRIX3FV fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix3fvEXT(GPPROGRAMUNIFORMMATRIX3FVEXT fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix3x2dv(GPPROGRAMUNIFORMMATRIX3X2DV fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix3x2dvEXT(GPPROGRAMUNIFORMMATRIX3X2DVEXT fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix3x2fv(GPPROGRAMUNIFORMMATRIX3X2FV fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix3x2fvEXT(GPPROGRAMUNIFORMMATRIX3X2FVEXT fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix3x4dv(GPPROGRAMUNIFORMMATRIX3X4DV fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix3x4dvEXT(GPPROGRAMUNIFORMMATRIX3X4DVEXT fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix3x4fv(GPPROGRAMUNIFORMMATRIX3X4FV fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix3x4fvEXT(GPPROGRAMUNIFORMMATRIX3X4FVEXT fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix4dv(GPPROGRAMUNIFORMMATRIX4DV fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix4dvEXT(GPPROGRAMUNIFORMMATRIX4DVEXT fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix4fv(GPPROGRAMUNIFORMMATRIX4FV fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix4fvEXT(GPPROGRAMUNIFORMMATRIX4FVEXT fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix4x2dv(GPPROGRAMUNIFORMMATRIX4X2DV fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix4x2dvEXT(GPPROGRAMUNIFORMMATRIX4X2DVEXT fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix4x2fv(GPPROGRAMUNIFORMMATRIX4X2FV fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix4x2fvEXT(GPPROGRAMUNIFORMMATRIX4X2FVEXT fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix4x3dv(GPPROGRAMUNIFORMMATRIX4X3DV fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix4x3dvEXT(GPPROGRAMUNIFORMMATRIX4X3DVEXT fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix4x3fv(GPPROGRAMUNIFORMMATRIX4X3FV fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformMatrix4x3fvEXT(GPPROGRAMUNIFORMMATRIX4X3FVEXT fnptr, GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(program, location, count, transpose, value); +// } +// static void glowProgramUniformui64NV(GPPROGRAMUNIFORMUI64NV fnptr, GLuint program, GLint location, GLuint64EXT value) { +// (*fnptr)(program, location, value); +// } +// static void glowProgramUniformui64vNV(GPPROGRAMUNIFORMUI64VNV fnptr, GLuint program, GLint location, GLsizei count, const GLuint64EXT * value) { +// (*fnptr)(program, location, count, value); +// } +// static void glowProvokingVertex(GPPROVOKINGVERTEX fnptr, GLenum mode) { +// (*fnptr)(mode); +// } +// static void glowPushClientAttribDefaultEXT(GPPUSHCLIENTATTRIBDEFAULTEXT fnptr, GLbitfield mask) { +// (*fnptr)(mask); +// } +// static void glowPushDebugGroup(GPPUSHDEBUGGROUP fnptr, GLenum source, GLuint id, GLsizei length, const GLchar * message) { +// (*fnptr)(source, id, length, message); +// } +// static void glowPushDebugGroupKHR(GPPUSHDEBUGGROUPKHR fnptr, GLenum source, GLuint id, GLsizei length, const GLchar * message) { +// (*fnptr)(source, id, length, message); +// } +// static void glowPushGroupMarkerEXT(GPPUSHGROUPMARKEREXT fnptr, GLsizei length, const GLchar * marker) { +// (*fnptr)(length, marker); +// } +// static void glowQueryCounter(GPQUERYCOUNTER fnptr, GLuint id, GLenum target) { +// (*fnptr)(id, target); +// } +// static void glowRasterSamplesEXT(GPRASTERSAMPLESEXT fnptr, GLuint samples, GLboolean fixedsamplelocations) { +// (*fnptr)(samples, fixedsamplelocations); +// } +// static void glowReadBuffer(GPREADBUFFER fnptr, GLenum src) { +// (*fnptr)(src); +// } +// static void glowReadPixels(GPREADPIXELS fnptr, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * pixels) { +// (*fnptr)(x, y, width, height, format, type, pixels); +// } +// static void glowReadnPixels(GPREADNPIXELS fnptr, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void * data) { +// (*fnptr)(x, y, width, height, format, type, bufSize, data); +// } +// static void glowReadnPixelsARB(GPREADNPIXELSARB fnptr, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void * data) { +// (*fnptr)(x, y, width, height, format, type, bufSize, data); +// } +// static void glowReadnPixelsKHR(GPREADNPIXELSKHR fnptr, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void * data) { +// (*fnptr)(x, y, width, height, format, type, bufSize, data); +// } +// static void glowReleaseShaderCompiler(GPRELEASESHADERCOMPILER fnptr) { +// (*fnptr)(); +// } +// static void glowRenderbufferStorage(GPRENDERBUFFERSTORAGE fnptr, GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { +// (*fnptr)(target, internalformat, width, height); +// } +// static void glowRenderbufferStorageMultisample(GPRENDERBUFFERSTORAGEMULTISAMPLE fnptr, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) { +// (*fnptr)(target, samples, internalformat, width, height); +// } +// static void glowRenderbufferStorageMultisampleAdvancedAMD(GPRENDERBUFFERSTORAGEMULTISAMPLEADVANCEDAMD fnptr, GLenum target, GLsizei samples, GLsizei storageSamples, GLenum internalformat, GLsizei width, GLsizei height) { +// (*fnptr)(target, samples, storageSamples, internalformat, width, height); +// } +// static void glowRenderbufferStorageMultisampleCoverageNV(GPRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENV fnptr, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height) { +// (*fnptr)(target, coverageSamples, colorSamples, internalformat, width, height); +// } +// static void glowResetMemoryObjectParameterNV(GPRESETMEMORYOBJECTPARAMETERNV fnptr, GLuint memory, GLenum pname) { +// (*fnptr)(memory, pname); +// } +// static void glowResolveDepthValuesNV(GPRESOLVEDEPTHVALUESNV fnptr) { +// (*fnptr)(); +// } +// static void glowResumeTransformFeedback(GPRESUMETRANSFORMFEEDBACK fnptr) { +// (*fnptr)(); +// } +// static void glowSampleCoverage(GPSAMPLECOVERAGE fnptr, GLfloat value, GLboolean invert) { +// (*fnptr)(value, invert); +// } +// static void glowSampleMaski(GPSAMPLEMASKI fnptr, GLuint maskNumber, GLbitfield mask) { +// (*fnptr)(maskNumber, mask); +// } +// static void glowSamplerParameterIiv(GPSAMPLERPARAMETERIIV fnptr, GLuint sampler, GLenum pname, const GLint * param) { +// (*fnptr)(sampler, pname, param); +// } +// static void glowSamplerParameterIuiv(GPSAMPLERPARAMETERIUIV fnptr, GLuint sampler, GLenum pname, const GLuint * param) { +// (*fnptr)(sampler, pname, param); +// } +// static void glowSamplerParameterf(GPSAMPLERPARAMETERF fnptr, GLuint sampler, GLenum pname, GLfloat param) { +// (*fnptr)(sampler, pname, param); +// } +// static void glowSamplerParameterfv(GPSAMPLERPARAMETERFV fnptr, GLuint sampler, GLenum pname, const GLfloat * param) { +// (*fnptr)(sampler, pname, param); +// } +// static void glowSamplerParameteri(GPSAMPLERPARAMETERI fnptr, GLuint sampler, GLenum pname, GLint param) { +// (*fnptr)(sampler, pname, param); +// } +// static void glowSamplerParameteriv(GPSAMPLERPARAMETERIV fnptr, GLuint sampler, GLenum pname, const GLint * param) { +// (*fnptr)(sampler, pname, param); +// } +// static void glowScissor(GPSCISSOR fnptr, GLint x, GLint y, GLsizei width, GLsizei height) { +// (*fnptr)(x, y, width, height); +// } +// static void glowScissorArrayv(GPSCISSORARRAYV fnptr, GLuint first, GLsizei count, const GLint * v) { +// (*fnptr)(first, count, v); +// } +// static void glowScissorExclusiveArrayvNV(GPSCISSOREXCLUSIVEARRAYVNV fnptr, GLuint first, GLsizei count, const GLint * v) { +// (*fnptr)(first, count, v); +// } +// static void glowScissorExclusiveNV(GPSCISSOREXCLUSIVENV fnptr, GLint x, GLint y, GLsizei width, GLsizei height) { +// (*fnptr)(x, y, width, height); +// } +// static void glowScissorIndexed(GPSCISSORINDEXED fnptr, GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) { +// (*fnptr)(index, left, bottom, width, height); +// } +// static void glowScissorIndexedv(GPSCISSORINDEXEDV fnptr, GLuint index, const GLint * v) { +// (*fnptr)(index, v); +// } +// static void glowSecondaryColorFormatNV(GPSECONDARYCOLORFORMATNV fnptr, GLint size, GLenum type, GLsizei stride) { +// (*fnptr)(size, type, stride); +// } +// static void glowSelectPerfMonitorCountersAMD(GPSELECTPERFMONITORCOUNTERSAMD fnptr, GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint * counterList) { +// (*fnptr)(monitor, enable, group, numCounters, counterList); +// } +// static void glowShaderBinary(GPSHADERBINARY fnptr, GLsizei count, const GLuint * shaders, GLenum binaryFormat, const void * binary, GLsizei length) { +// (*fnptr)(count, shaders, binaryFormat, binary, length); +// } +// static void glowShaderSource(GPSHADERSOURCE fnptr, GLuint shader, GLsizei count, const GLchar *const* string, const GLint * length) { +// (*fnptr)(shader, count, string, length); +// } +// static void glowShaderStorageBlockBinding(GPSHADERSTORAGEBLOCKBINDING fnptr, GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding) { +// (*fnptr)(program, storageBlockIndex, storageBlockBinding); +// } +// static void glowShadingRateImageBarrierNV(GPSHADINGRATEIMAGEBARRIERNV fnptr, GLboolean synchronize) { +// (*fnptr)(synchronize); +// } +// static void glowShadingRateImagePaletteNV(GPSHADINGRATEIMAGEPALETTENV fnptr, GLuint viewport, GLuint first, GLsizei count, const GLenum * rates) { +// (*fnptr)(viewport, first, count, rates); +// } +// static void glowShadingRateSampleOrderCustomNV(GPSHADINGRATESAMPLEORDERCUSTOMNV fnptr, GLenum rate, GLuint samples, const GLint * locations) { +// (*fnptr)(rate, samples, locations); +// } +// static void glowShadingRateSampleOrderNV(GPSHADINGRATESAMPLEORDERNV fnptr, GLenum order) { +// (*fnptr)(order); +// } +// static void glowSignalVkFenceNV(GPSIGNALVKFENCENV fnptr, GLuint64 vkFence) { +// (*fnptr)(vkFence); +// } +// static void glowSignalVkSemaphoreNV(GPSIGNALVKSEMAPHORENV fnptr, GLuint64 vkSemaphore) { +// (*fnptr)(vkSemaphore); +// } +// static void glowSpecializeShaderARB(GPSPECIALIZESHADERARB fnptr, GLuint shader, const GLchar * pEntryPoint, GLuint numSpecializationConstants, const GLuint * pConstantIndex, const GLuint * pConstantValue) { +// (*fnptr)(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue); +// } +// static void glowStateCaptureNV(GPSTATECAPTURENV fnptr, GLuint state, GLenum mode) { +// (*fnptr)(state, mode); +// } +// static void glowStencilFillPathInstancedNV(GPSTENCILFILLPATHINSTANCEDNV fnptr, GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum transformType, const GLfloat * transformValues) { +// (*fnptr)(numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues); +// } +// static void glowStencilFillPathNV(GPSTENCILFILLPATHNV fnptr, GLuint path, GLenum fillMode, GLuint mask) { +// (*fnptr)(path, fillMode, mask); +// } +// static void glowStencilFunc(GPSTENCILFUNC fnptr, GLenum func, GLint ref, GLuint mask) { +// (*fnptr)(func, ref, mask); +// } +// static void glowStencilFuncSeparate(GPSTENCILFUNCSEPARATE fnptr, GLenum face, GLenum func, GLint ref, GLuint mask) { +// (*fnptr)(face, func, ref, mask); +// } +// static void glowStencilMask(GPSTENCILMASK fnptr, GLuint mask) { +// (*fnptr)(mask); +// } +// static void glowStencilMaskSeparate(GPSTENCILMASKSEPARATE fnptr, GLenum face, GLuint mask) { +// (*fnptr)(face, mask); +// } +// static void glowStencilOp(GPSTENCILOP fnptr, GLenum fail, GLenum zfail, GLenum zpass) { +// (*fnptr)(fail, zfail, zpass); +// } +// static void glowStencilOpSeparate(GPSTENCILOPSEPARATE fnptr, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) { +// (*fnptr)(face, sfail, dpfail, dppass); +// } +// static void glowStencilStrokePathInstancedNV(GPSTENCILSTROKEPATHINSTANCEDNV fnptr, GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLint reference, GLuint mask, GLenum transformType, const GLfloat * transformValues) { +// (*fnptr)(numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues); +// } +// static void glowStencilStrokePathNV(GPSTENCILSTROKEPATHNV fnptr, GLuint path, GLint reference, GLuint mask) { +// (*fnptr)(path, reference, mask); +// } +// static void glowStencilThenCoverFillPathInstancedNV(GPSTENCILTHENCOVERFILLPATHINSTANCEDNV fnptr, GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat * transformValues) { +// (*fnptr)(numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues); +// } +// static void glowStencilThenCoverFillPathNV(GPSTENCILTHENCOVERFILLPATHNV fnptr, GLuint path, GLenum fillMode, GLuint mask, GLenum coverMode) { +// (*fnptr)(path, fillMode, mask, coverMode); +// } +// static void glowStencilThenCoverStrokePathInstancedNV(GPSTENCILTHENCOVERSTROKEPATHINSTANCEDNV fnptr, GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLint reference, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat * transformValues) { +// (*fnptr)(numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues); +// } +// static void glowStencilThenCoverStrokePathNV(GPSTENCILTHENCOVERSTROKEPATHNV fnptr, GLuint path, GLint reference, GLuint mask, GLenum coverMode) { +// (*fnptr)(path, reference, mask, coverMode); +// } +// static void glowSubpixelPrecisionBiasNV(GPSUBPIXELPRECISIONBIASNV fnptr, GLuint xbits, GLuint ybits) { +// (*fnptr)(xbits, ybits); +// } +// static void glowTexAttachMemoryNV(GPTEXATTACHMEMORYNV fnptr, GLenum target, GLuint memory, GLuint64 offset) { +// (*fnptr)(target, memory, offset); +// } +// static void glowTexBuffer(GPTEXBUFFER fnptr, GLenum target, GLenum internalformat, GLuint buffer) { +// (*fnptr)(target, internalformat, buffer); +// } +// static void glowTexBufferARB(GPTEXBUFFERARB fnptr, GLenum target, GLenum internalformat, GLuint buffer) { +// (*fnptr)(target, internalformat, buffer); +// } +// static void glowTexBufferRange(GPTEXBUFFERRANGE fnptr, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) { +// (*fnptr)(target, internalformat, buffer, offset, size); +// } +// static void glowTexCoordFormatNV(GPTEXCOORDFORMATNV fnptr, GLint size, GLenum type, GLsizei stride) { +// (*fnptr)(size, type, stride); +// } +// static void glowTexImage1D(GPTEXIMAGE1D fnptr, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(target, level, internalformat, width, border, format, type, pixels); +// } +// static void glowTexImage2D(GPTEXIMAGE2D fnptr, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(target, level, internalformat, width, height, border, format, type, pixels); +// } +// static void glowTexImage2DMultisample(GPTEXIMAGE2DMULTISAMPLE fnptr, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) { +// (*fnptr)(target, samples, internalformat, width, height, fixedsamplelocations); +// } +// static void glowTexImage3D(GPTEXIMAGE3D fnptr, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(target, level, internalformat, width, height, depth, border, format, type, pixels); +// } +// static void glowTexImage3DMultisample(GPTEXIMAGE3DMULTISAMPLE fnptr, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) { +// (*fnptr)(target, samples, internalformat, width, height, depth, fixedsamplelocations); +// } +// static void glowTexPageCommitmentARB(GPTEXPAGECOMMITMENTARB fnptr, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit) { +// (*fnptr)(target, level, xoffset, yoffset, zoffset, width, height, depth, commit); +// } +// static void glowTexPageCommitmentMemNV(GPTEXPAGECOMMITMENTMEMNV fnptr, GLenum target, GLint layer, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset, GLboolean commit) { +// (*fnptr)(target, layer, level, xoffset, yoffset, zoffset, width, height, depth, memory, offset, commit); +// } +// static void glowTexParameterIiv(GPTEXPARAMETERIIV fnptr, GLenum target, GLenum pname, const GLint * params) { +// (*fnptr)(target, pname, params); +// } +// static void glowTexParameterIuiv(GPTEXPARAMETERIUIV fnptr, GLenum target, GLenum pname, const GLuint * params) { +// (*fnptr)(target, pname, params); +// } +// static void glowTexParameterf(GPTEXPARAMETERF fnptr, GLenum target, GLenum pname, GLfloat param) { +// (*fnptr)(target, pname, param); +// } +// static void glowTexParameterfv(GPTEXPARAMETERFV fnptr, GLenum target, GLenum pname, const GLfloat * params) { +// (*fnptr)(target, pname, params); +// } +// static void glowTexParameteri(GPTEXPARAMETERI fnptr, GLenum target, GLenum pname, GLint param) { +// (*fnptr)(target, pname, param); +// } +// static void glowTexParameteriv(GPTEXPARAMETERIV fnptr, GLenum target, GLenum pname, const GLint * params) { +// (*fnptr)(target, pname, params); +// } +// static void glowTexStorage1D(GPTEXSTORAGE1D fnptr, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) { +// (*fnptr)(target, levels, internalformat, width); +// } +// static void glowTexStorage2D(GPTEXSTORAGE2D fnptr, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) { +// (*fnptr)(target, levels, internalformat, width, height); +// } +// static void glowTexStorage2DMultisample(GPTEXSTORAGE2DMULTISAMPLE fnptr, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) { +// (*fnptr)(target, samples, internalformat, width, height, fixedsamplelocations); +// } +// static void glowTexStorage3D(GPTEXSTORAGE3D fnptr, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) { +// (*fnptr)(target, levels, internalformat, width, height, depth); +// } +// static void glowTexStorage3DMultisample(GPTEXSTORAGE3DMULTISAMPLE fnptr, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) { +// (*fnptr)(target, samples, internalformat, width, height, depth, fixedsamplelocations); +// } +// static void glowTexSubImage1D(GPTEXSUBIMAGE1D fnptr, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(target, level, xoffset, width, format, type, pixels); +// } +// static void glowTexSubImage2D(GPTEXSUBIMAGE2D fnptr, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(target, level, xoffset, yoffset, width, height, format, type, pixels); +// } +// static void glowTexSubImage3D(GPTEXSUBIMAGE3D fnptr, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); +// } +// static void glowTextureAttachMemoryNV(GPTEXTUREATTACHMEMORYNV fnptr, GLuint texture, GLuint memory, GLuint64 offset) { +// (*fnptr)(texture, memory, offset); +// } +// static void glowTextureBarrier(GPTEXTUREBARRIER fnptr) { +// (*fnptr)(); +// } +// static void glowTextureBarrierNV(GPTEXTUREBARRIERNV fnptr) { +// (*fnptr)(); +// } +// static void glowTextureBuffer(GPTEXTUREBUFFER fnptr, GLuint texture, GLenum internalformat, GLuint buffer) { +// (*fnptr)(texture, internalformat, buffer); +// } +// static void glowTextureBufferEXT(GPTEXTUREBUFFEREXT fnptr, GLuint texture, GLenum target, GLenum internalformat, GLuint buffer) { +// (*fnptr)(texture, target, internalformat, buffer); +// } +// static void glowTextureBufferRange(GPTEXTUREBUFFERRANGE fnptr, GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) { +// (*fnptr)(texture, internalformat, buffer, offset, size); +// } +// static void glowTextureBufferRangeEXT(GPTEXTUREBUFFERRANGEEXT fnptr, GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) { +// (*fnptr)(texture, target, internalformat, buffer, offset, size); +// } +// static void glowTextureImage1DEXT(GPTEXTUREIMAGE1DEXT fnptr, GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(texture, target, level, internalformat, width, border, format, type, pixels); +// } +// static void glowTextureImage2DEXT(GPTEXTUREIMAGE2DEXT fnptr, GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(texture, target, level, internalformat, width, height, border, format, type, pixels); +// } +// static void glowTextureImage3DEXT(GPTEXTUREIMAGE3DEXT fnptr, GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(texture, target, level, internalformat, width, height, depth, border, format, type, pixels); +// } +// static void glowTexturePageCommitmentEXT(GPTEXTUREPAGECOMMITMENTEXT fnptr, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit) { +// (*fnptr)(texture, level, xoffset, yoffset, zoffset, width, height, depth, commit); +// } +// static void glowTexturePageCommitmentMemNV(GPTEXTUREPAGECOMMITMENTMEMNV fnptr, GLuint texture, GLint layer, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset, GLboolean commit) { +// (*fnptr)(texture, layer, level, xoffset, yoffset, zoffset, width, height, depth, memory, offset, commit); +// } +// static void glowTextureParameterIiv(GPTEXTUREPARAMETERIIV fnptr, GLuint texture, GLenum pname, const GLint * params) { +// (*fnptr)(texture, pname, params); +// } +// static void glowTextureParameterIivEXT(GPTEXTUREPARAMETERIIVEXT fnptr, GLuint texture, GLenum target, GLenum pname, const GLint * params) { +// (*fnptr)(texture, target, pname, params); +// } +// static void glowTextureParameterIuiv(GPTEXTUREPARAMETERIUIV fnptr, GLuint texture, GLenum pname, const GLuint * params) { +// (*fnptr)(texture, pname, params); +// } +// static void glowTextureParameterIuivEXT(GPTEXTUREPARAMETERIUIVEXT fnptr, GLuint texture, GLenum target, GLenum pname, const GLuint * params) { +// (*fnptr)(texture, target, pname, params); +// } +// static void glowTextureParameterf(GPTEXTUREPARAMETERF fnptr, GLuint texture, GLenum pname, GLfloat param) { +// (*fnptr)(texture, pname, param); +// } +// static void glowTextureParameterfEXT(GPTEXTUREPARAMETERFEXT fnptr, GLuint texture, GLenum target, GLenum pname, GLfloat param) { +// (*fnptr)(texture, target, pname, param); +// } +// static void glowTextureParameterfv(GPTEXTUREPARAMETERFV fnptr, GLuint texture, GLenum pname, const GLfloat * param) { +// (*fnptr)(texture, pname, param); +// } +// static void glowTextureParameterfvEXT(GPTEXTUREPARAMETERFVEXT fnptr, GLuint texture, GLenum target, GLenum pname, const GLfloat * params) { +// (*fnptr)(texture, target, pname, params); +// } +// static void glowTextureParameteri(GPTEXTUREPARAMETERI fnptr, GLuint texture, GLenum pname, GLint param) { +// (*fnptr)(texture, pname, param); +// } +// static void glowTextureParameteriEXT(GPTEXTUREPARAMETERIEXT fnptr, GLuint texture, GLenum target, GLenum pname, GLint param) { +// (*fnptr)(texture, target, pname, param); +// } +// static void glowTextureParameteriv(GPTEXTUREPARAMETERIV fnptr, GLuint texture, GLenum pname, const GLint * param) { +// (*fnptr)(texture, pname, param); +// } +// static void glowTextureParameterivEXT(GPTEXTUREPARAMETERIVEXT fnptr, GLuint texture, GLenum target, GLenum pname, const GLint * params) { +// (*fnptr)(texture, target, pname, params); +// } +// static void glowTextureRenderbufferEXT(GPTEXTURERENDERBUFFEREXT fnptr, GLuint texture, GLenum target, GLuint renderbuffer) { +// (*fnptr)(texture, target, renderbuffer); +// } +// static void glowTextureStorage1D(GPTEXTURESTORAGE1D fnptr, GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width) { +// (*fnptr)(texture, levels, internalformat, width); +// } +// static void glowTextureStorage1DEXT(GPTEXTURESTORAGE1DEXT fnptr, GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) { +// (*fnptr)(texture, target, levels, internalformat, width); +// } +// static void glowTextureStorage2D(GPTEXTURESTORAGE2D fnptr, GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) { +// (*fnptr)(texture, levels, internalformat, width, height); +// } +// static void glowTextureStorage2DEXT(GPTEXTURESTORAGE2DEXT fnptr, GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) { +// (*fnptr)(texture, target, levels, internalformat, width, height); +// } +// static void glowTextureStorage2DMultisample(GPTEXTURESTORAGE2DMULTISAMPLE fnptr, GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) { +// (*fnptr)(texture, samples, internalformat, width, height, fixedsamplelocations); +// } +// static void glowTextureStorage2DMultisampleEXT(GPTEXTURESTORAGE2DMULTISAMPLEEXT fnptr, GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) { +// (*fnptr)(texture, target, samples, internalformat, width, height, fixedsamplelocations); +// } +// static void glowTextureStorage3D(GPTEXTURESTORAGE3D fnptr, GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) { +// (*fnptr)(texture, levels, internalformat, width, height, depth); +// } +// static void glowTextureStorage3DEXT(GPTEXTURESTORAGE3DEXT fnptr, GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) { +// (*fnptr)(texture, target, levels, internalformat, width, height, depth); +// } +// static void glowTextureStorage3DMultisample(GPTEXTURESTORAGE3DMULTISAMPLE fnptr, GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) { +// (*fnptr)(texture, samples, internalformat, width, height, depth, fixedsamplelocations); +// } +// static void glowTextureStorage3DMultisampleEXT(GPTEXTURESTORAGE3DMULTISAMPLEEXT fnptr, GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) { +// (*fnptr)(texture, target, samples, internalformat, width, height, depth, fixedsamplelocations); +// } +// static void glowTextureSubImage1D(GPTEXTURESUBIMAGE1D fnptr, GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(texture, level, xoffset, width, format, type, pixels); +// } +// static void glowTextureSubImage1DEXT(GPTEXTURESUBIMAGE1DEXT fnptr, GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(texture, target, level, xoffset, width, format, type, pixels); +// } +// static void glowTextureSubImage2D(GPTEXTURESUBIMAGE2D fnptr, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(texture, level, xoffset, yoffset, width, height, format, type, pixels); +// } +// static void glowTextureSubImage2DEXT(GPTEXTURESUBIMAGE2DEXT fnptr, GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(texture, target, level, xoffset, yoffset, width, height, format, type, pixels); +// } +// static void glowTextureSubImage3D(GPTEXTURESUBIMAGE3D fnptr, GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); +// } +// static void glowTextureSubImage3DEXT(GPTEXTURESUBIMAGE3DEXT fnptr, GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels) { +// (*fnptr)(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); +// } +// static void glowTextureView(GPTEXTUREVIEW fnptr, GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers) { +// (*fnptr)(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers); +// } +// static void glowTransformFeedbackBufferBase(GPTRANSFORMFEEDBACKBUFFERBASE fnptr, GLuint xfb, GLuint index, GLuint buffer) { +// (*fnptr)(xfb, index, buffer); +// } +// static void glowTransformFeedbackBufferRange(GPTRANSFORMFEEDBACKBUFFERRANGE fnptr, GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) { +// (*fnptr)(xfb, index, buffer, offset, size); +// } +// static void glowTransformFeedbackVaryings(GPTRANSFORMFEEDBACKVARYINGS fnptr, GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode) { +// (*fnptr)(program, count, varyings, bufferMode); +// } +// static void glowTransformPathNV(GPTRANSFORMPATHNV fnptr, GLuint resultPath, GLuint srcPath, GLenum transformType, const GLfloat * transformValues) { +// (*fnptr)(resultPath, srcPath, transformType, transformValues); +// } +// static void glowUniform1d(GPUNIFORM1D fnptr, GLint location, GLdouble x) { +// (*fnptr)(location, x); +// } +// static void glowUniform1dv(GPUNIFORM1DV fnptr, GLint location, GLsizei count, const GLdouble * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform1f(GPUNIFORM1F fnptr, GLint location, GLfloat v0) { +// (*fnptr)(location, v0); +// } +// static void glowUniform1fv(GPUNIFORM1FV fnptr, GLint location, GLsizei count, const GLfloat * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform1i(GPUNIFORM1I fnptr, GLint location, GLint v0) { +// (*fnptr)(location, v0); +// } +// static void glowUniform1i64ARB(GPUNIFORM1I64ARB fnptr, GLint location, GLint64 x) { +// (*fnptr)(location, x); +// } +// static void glowUniform1i64NV(GPUNIFORM1I64NV fnptr, GLint location, GLint64EXT x) { +// (*fnptr)(location, x); +// } +// static void glowUniform1i64vARB(GPUNIFORM1I64VARB fnptr, GLint location, GLsizei count, const GLint64 * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform1i64vNV(GPUNIFORM1I64VNV fnptr, GLint location, GLsizei count, const GLint64EXT * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform1iv(GPUNIFORM1IV fnptr, GLint location, GLsizei count, const GLint * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform1ui(GPUNIFORM1UI fnptr, GLint location, GLuint v0) { +// (*fnptr)(location, v0); +// } +// static void glowUniform1ui64ARB(GPUNIFORM1UI64ARB fnptr, GLint location, GLuint64 x) { +// (*fnptr)(location, x); +// } +// static void glowUniform1ui64NV(GPUNIFORM1UI64NV fnptr, GLint location, GLuint64EXT x) { +// (*fnptr)(location, x); +// } +// static void glowUniform1ui64vARB(GPUNIFORM1UI64VARB fnptr, GLint location, GLsizei count, const GLuint64 * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform1ui64vNV(GPUNIFORM1UI64VNV fnptr, GLint location, GLsizei count, const GLuint64EXT * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform1uiv(GPUNIFORM1UIV fnptr, GLint location, GLsizei count, const GLuint * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform2d(GPUNIFORM2D fnptr, GLint location, GLdouble x, GLdouble y) { +// (*fnptr)(location, x, y); +// } +// static void glowUniform2dv(GPUNIFORM2DV fnptr, GLint location, GLsizei count, const GLdouble * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform2f(GPUNIFORM2F fnptr, GLint location, GLfloat v0, GLfloat v1) { +// (*fnptr)(location, v0, v1); +// } +// static void glowUniform2fv(GPUNIFORM2FV fnptr, GLint location, GLsizei count, const GLfloat * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform2i(GPUNIFORM2I fnptr, GLint location, GLint v0, GLint v1) { +// (*fnptr)(location, v0, v1); +// } +// static void glowUniform2i64ARB(GPUNIFORM2I64ARB fnptr, GLint location, GLint64 x, GLint64 y) { +// (*fnptr)(location, x, y); +// } +// static void glowUniform2i64NV(GPUNIFORM2I64NV fnptr, GLint location, GLint64EXT x, GLint64EXT y) { +// (*fnptr)(location, x, y); +// } +// static void glowUniform2i64vARB(GPUNIFORM2I64VARB fnptr, GLint location, GLsizei count, const GLint64 * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform2i64vNV(GPUNIFORM2I64VNV fnptr, GLint location, GLsizei count, const GLint64EXT * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform2iv(GPUNIFORM2IV fnptr, GLint location, GLsizei count, const GLint * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform2ui(GPUNIFORM2UI fnptr, GLint location, GLuint v0, GLuint v1) { +// (*fnptr)(location, v0, v1); +// } +// static void glowUniform2ui64ARB(GPUNIFORM2UI64ARB fnptr, GLint location, GLuint64 x, GLuint64 y) { +// (*fnptr)(location, x, y); +// } +// static void glowUniform2ui64NV(GPUNIFORM2UI64NV fnptr, GLint location, GLuint64EXT x, GLuint64EXT y) { +// (*fnptr)(location, x, y); +// } +// static void glowUniform2ui64vARB(GPUNIFORM2UI64VARB fnptr, GLint location, GLsizei count, const GLuint64 * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform2ui64vNV(GPUNIFORM2UI64VNV fnptr, GLint location, GLsizei count, const GLuint64EXT * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform2uiv(GPUNIFORM2UIV fnptr, GLint location, GLsizei count, const GLuint * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform3d(GPUNIFORM3D fnptr, GLint location, GLdouble x, GLdouble y, GLdouble z) { +// (*fnptr)(location, x, y, z); +// } +// static void glowUniform3dv(GPUNIFORM3DV fnptr, GLint location, GLsizei count, const GLdouble * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform3f(GPUNIFORM3F fnptr, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) { +// (*fnptr)(location, v0, v1, v2); +// } +// static void glowUniform3fv(GPUNIFORM3FV fnptr, GLint location, GLsizei count, const GLfloat * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform3i(GPUNIFORM3I fnptr, GLint location, GLint v0, GLint v1, GLint v2) { +// (*fnptr)(location, v0, v1, v2); +// } +// static void glowUniform3i64ARB(GPUNIFORM3I64ARB fnptr, GLint location, GLint64 x, GLint64 y, GLint64 z) { +// (*fnptr)(location, x, y, z); +// } +// static void glowUniform3i64NV(GPUNIFORM3I64NV fnptr, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z) { +// (*fnptr)(location, x, y, z); +// } +// static void glowUniform3i64vARB(GPUNIFORM3I64VARB fnptr, GLint location, GLsizei count, const GLint64 * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform3i64vNV(GPUNIFORM3I64VNV fnptr, GLint location, GLsizei count, const GLint64EXT * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform3iv(GPUNIFORM3IV fnptr, GLint location, GLsizei count, const GLint * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform3ui(GPUNIFORM3UI fnptr, GLint location, GLuint v0, GLuint v1, GLuint v2) { +// (*fnptr)(location, v0, v1, v2); +// } +// static void glowUniform3ui64ARB(GPUNIFORM3UI64ARB fnptr, GLint location, GLuint64 x, GLuint64 y, GLuint64 z) { +// (*fnptr)(location, x, y, z); +// } +// static void glowUniform3ui64NV(GPUNIFORM3UI64NV fnptr, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z) { +// (*fnptr)(location, x, y, z); +// } +// static void glowUniform3ui64vARB(GPUNIFORM3UI64VARB fnptr, GLint location, GLsizei count, const GLuint64 * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform3ui64vNV(GPUNIFORM3UI64VNV fnptr, GLint location, GLsizei count, const GLuint64EXT * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform3uiv(GPUNIFORM3UIV fnptr, GLint location, GLsizei count, const GLuint * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform4d(GPUNIFORM4D fnptr, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { +// (*fnptr)(location, x, y, z, w); +// } +// static void glowUniform4dv(GPUNIFORM4DV fnptr, GLint location, GLsizei count, const GLdouble * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform4f(GPUNIFORM4F fnptr, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) { +// (*fnptr)(location, v0, v1, v2, v3); +// } +// static void glowUniform4fv(GPUNIFORM4FV fnptr, GLint location, GLsizei count, const GLfloat * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform4i(GPUNIFORM4I fnptr, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) { +// (*fnptr)(location, v0, v1, v2, v3); +// } +// static void glowUniform4i64ARB(GPUNIFORM4I64ARB fnptr, GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w) { +// (*fnptr)(location, x, y, z, w); +// } +// static void glowUniform4i64NV(GPUNIFORM4I64NV fnptr, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w) { +// (*fnptr)(location, x, y, z, w); +// } +// static void glowUniform4i64vARB(GPUNIFORM4I64VARB fnptr, GLint location, GLsizei count, const GLint64 * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform4i64vNV(GPUNIFORM4I64VNV fnptr, GLint location, GLsizei count, const GLint64EXT * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform4iv(GPUNIFORM4IV fnptr, GLint location, GLsizei count, const GLint * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform4ui(GPUNIFORM4UI fnptr, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) { +// (*fnptr)(location, v0, v1, v2, v3); +// } +// static void glowUniform4ui64ARB(GPUNIFORM4UI64ARB fnptr, GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w) { +// (*fnptr)(location, x, y, z, w); +// } +// static void glowUniform4ui64NV(GPUNIFORM4UI64NV fnptr, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w) { +// (*fnptr)(location, x, y, z, w); +// } +// static void glowUniform4ui64vARB(GPUNIFORM4UI64VARB fnptr, GLint location, GLsizei count, const GLuint64 * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform4ui64vNV(GPUNIFORM4UI64VNV fnptr, GLint location, GLsizei count, const GLuint64EXT * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniform4uiv(GPUNIFORM4UIV fnptr, GLint location, GLsizei count, const GLuint * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniformBlockBinding(GPUNIFORMBLOCKBINDING fnptr, GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) { +// (*fnptr)(program, uniformBlockIndex, uniformBlockBinding); +// } +// static void glowUniformHandleui64ARB(GPUNIFORMHANDLEUI64ARB fnptr, GLint location, GLuint64 value) { +// (*fnptr)(location, value); +// } +// static void glowUniformHandleui64NV(GPUNIFORMHANDLEUI64NV fnptr, GLint location, GLuint64 value) { +// (*fnptr)(location, value); +// } +// static void glowUniformHandleui64vARB(GPUNIFORMHANDLEUI64VARB fnptr, GLint location, GLsizei count, const GLuint64 * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniformHandleui64vNV(GPUNIFORMHANDLEUI64VNV fnptr, GLint location, GLsizei count, const GLuint64 * value) { +// (*fnptr)(location, count, value); +// } +// static void glowUniformMatrix2dv(GPUNIFORMMATRIX2DV fnptr, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(location, count, transpose, value); +// } +// static void glowUniformMatrix2fv(GPUNIFORMMATRIX2FV fnptr, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(location, count, transpose, value); +// } +// static void glowUniformMatrix2x3dv(GPUNIFORMMATRIX2X3DV fnptr, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(location, count, transpose, value); +// } +// static void glowUniformMatrix2x3fv(GPUNIFORMMATRIX2X3FV fnptr, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(location, count, transpose, value); +// } +// static void glowUniformMatrix2x4dv(GPUNIFORMMATRIX2X4DV fnptr, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(location, count, transpose, value); +// } +// static void glowUniformMatrix2x4fv(GPUNIFORMMATRIX2X4FV fnptr, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(location, count, transpose, value); +// } +// static void glowUniformMatrix3dv(GPUNIFORMMATRIX3DV fnptr, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(location, count, transpose, value); +// } +// static void glowUniformMatrix3fv(GPUNIFORMMATRIX3FV fnptr, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(location, count, transpose, value); +// } +// static void glowUniformMatrix3x2dv(GPUNIFORMMATRIX3X2DV fnptr, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(location, count, transpose, value); +// } +// static void glowUniformMatrix3x2fv(GPUNIFORMMATRIX3X2FV fnptr, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(location, count, transpose, value); +// } +// static void glowUniformMatrix3x4dv(GPUNIFORMMATRIX3X4DV fnptr, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(location, count, transpose, value); +// } +// static void glowUniformMatrix3x4fv(GPUNIFORMMATRIX3X4FV fnptr, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(location, count, transpose, value); +// } +// static void glowUniformMatrix4dv(GPUNIFORMMATRIX4DV fnptr, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(location, count, transpose, value); +// } +// static void glowUniformMatrix4fv(GPUNIFORMMATRIX4FV fnptr, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(location, count, transpose, value); +// } +// static void glowUniformMatrix4x2dv(GPUNIFORMMATRIX4X2DV fnptr, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(location, count, transpose, value); +// } +// static void glowUniformMatrix4x2fv(GPUNIFORMMATRIX4X2FV fnptr, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(location, count, transpose, value); +// } +// static void glowUniformMatrix4x3dv(GPUNIFORMMATRIX4X3DV fnptr, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) { +// (*fnptr)(location, count, transpose, value); +// } +// static void glowUniformMatrix4x3fv(GPUNIFORMMATRIX4X3FV fnptr, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) { +// (*fnptr)(location, count, transpose, value); +// } +// static void glowUniformSubroutinesuiv(GPUNIFORMSUBROUTINESUIV fnptr, GLenum shadertype, GLsizei count, const GLuint * indices) { +// (*fnptr)(shadertype, count, indices); +// } +// static void glowUniformui64NV(GPUNIFORMUI64NV fnptr, GLint location, GLuint64EXT value) { +// (*fnptr)(location, value); +// } +// static void glowUniformui64vNV(GPUNIFORMUI64VNV fnptr, GLint location, GLsizei count, const GLuint64EXT * value) { +// (*fnptr)(location, count, value); +// } +// static GLboolean glowUnmapBuffer(GPUNMAPBUFFER fnptr, GLenum target) { +// return (*fnptr)(target); +// } +// static GLboolean glowUnmapNamedBuffer(GPUNMAPNAMEDBUFFER fnptr, GLuint buffer) { +// return (*fnptr)(buffer); +// } +// static GLboolean glowUnmapNamedBufferEXT(GPUNMAPNAMEDBUFFEREXT fnptr, GLuint buffer) { +// return (*fnptr)(buffer); +// } +// static void glowUseProgram(GPUSEPROGRAM fnptr, GLuint program) { +// (*fnptr)(program); +// } +// static void glowUseProgramStages(GPUSEPROGRAMSTAGES fnptr, GLuint pipeline, GLbitfield stages, GLuint program) { +// (*fnptr)(pipeline, stages, program); +// } +// static void glowUseProgramStagesEXT(GPUSEPROGRAMSTAGESEXT fnptr, GLuint pipeline, GLbitfield stages, GLuint program) { +// (*fnptr)(pipeline, stages, program); +// } +// static void glowUseShaderProgramEXT(GPUSESHADERPROGRAMEXT fnptr, GLenum type, GLuint program) { +// (*fnptr)(type, program); +// } +// static void glowValidateProgram(GPVALIDATEPROGRAM fnptr, GLuint program) { +// (*fnptr)(program); +// } +// static void glowValidateProgramPipeline(GPVALIDATEPROGRAMPIPELINE fnptr, GLuint pipeline) { +// (*fnptr)(pipeline); +// } +// static void glowValidateProgramPipelineEXT(GPVALIDATEPROGRAMPIPELINEEXT fnptr, GLuint pipeline) { +// (*fnptr)(pipeline); +// } +// static void glowVertexArrayAttribBinding(GPVERTEXARRAYATTRIBBINDING fnptr, GLuint vaobj, GLuint attribindex, GLuint bindingindex) { +// (*fnptr)(vaobj, attribindex, bindingindex); +// } +// static void glowVertexArrayAttribFormat(GPVERTEXARRAYATTRIBFORMAT fnptr, GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset) { +// (*fnptr)(vaobj, attribindex, size, type, normalized, relativeoffset); +// } +// static void glowVertexArrayAttribIFormat(GPVERTEXARRAYATTRIBIFORMAT fnptr, GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) { +// (*fnptr)(vaobj, attribindex, size, type, relativeoffset); +// } +// static void glowVertexArrayAttribLFormat(GPVERTEXARRAYATTRIBLFORMAT fnptr, GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) { +// (*fnptr)(vaobj, attribindex, size, type, relativeoffset); +// } +// static void glowVertexArrayBindVertexBufferEXT(GPVERTEXARRAYBINDVERTEXBUFFEREXT fnptr, GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride) { +// (*fnptr)(vaobj, bindingindex, buffer, offset, stride); +// } +// static void glowVertexArrayBindingDivisor(GPVERTEXARRAYBINDINGDIVISOR fnptr, GLuint vaobj, GLuint bindingindex, GLuint divisor) { +// (*fnptr)(vaobj, bindingindex, divisor); +// } +// static void glowVertexArrayColorOffsetEXT(GPVERTEXARRAYCOLOROFFSETEXT fnptr, GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset) { +// (*fnptr)(vaobj, buffer, size, type, stride, offset); +// } +// static void glowVertexArrayEdgeFlagOffsetEXT(GPVERTEXARRAYEDGEFLAGOFFSETEXT fnptr, GLuint vaobj, GLuint buffer, GLsizei stride, GLintptr offset) { +// (*fnptr)(vaobj, buffer, stride, offset); +// } +// static void glowVertexArrayElementBuffer(GPVERTEXARRAYELEMENTBUFFER fnptr, GLuint vaobj, GLuint buffer) { +// (*fnptr)(vaobj, buffer); +// } +// static void glowVertexArrayFogCoordOffsetEXT(GPVERTEXARRAYFOGCOORDOFFSETEXT fnptr, GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset) { +// (*fnptr)(vaobj, buffer, type, stride, offset); +// } +// static void glowVertexArrayIndexOffsetEXT(GPVERTEXARRAYINDEXOFFSETEXT fnptr, GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset) { +// (*fnptr)(vaobj, buffer, type, stride, offset); +// } +// static void glowVertexArrayMultiTexCoordOffsetEXT(GPVERTEXARRAYMULTITEXCOORDOFFSETEXT fnptr, GLuint vaobj, GLuint buffer, GLenum texunit, GLint size, GLenum type, GLsizei stride, GLintptr offset) { +// (*fnptr)(vaobj, buffer, texunit, size, type, stride, offset); +// } +// static void glowVertexArrayNormalOffsetEXT(GPVERTEXARRAYNORMALOFFSETEXT fnptr, GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset) { +// (*fnptr)(vaobj, buffer, type, stride, offset); +// } +// static void glowVertexArraySecondaryColorOffsetEXT(GPVERTEXARRAYSECONDARYCOLOROFFSETEXT fnptr, GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset) { +// (*fnptr)(vaobj, buffer, size, type, stride, offset); +// } +// static void glowVertexArrayTexCoordOffsetEXT(GPVERTEXARRAYTEXCOORDOFFSETEXT fnptr, GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset) { +// (*fnptr)(vaobj, buffer, size, type, stride, offset); +// } +// static void glowVertexArrayVertexAttribBindingEXT(GPVERTEXARRAYVERTEXATTRIBBINDINGEXT fnptr, GLuint vaobj, GLuint attribindex, GLuint bindingindex) { +// (*fnptr)(vaobj, attribindex, bindingindex); +// } +// static void glowVertexArrayVertexAttribDivisorEXT(GPVERTEXARRAYVERTEXATTRIBDIVISOREXT fnptr, GLuint vaobj, GLuint index, GLuint divisor) { +// (*fnptr)(vaobj, index, divisor); +// } +// static void glowVertexArrayVertexAttribFormatEXT(GPVERTEXARRAYVERTEXATTRIBFORMATEXT fnptr, GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset) { +// (*fnptr)(vaobj, attribindex, size, type, normalized, relativeoffset); +// } +// static void glowVertexArrayVertexAttribIFormatEXT(GPVERTEXARRAYVERTEXATTRIBIFORMATEXT fnptr, GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) { +// (*fnptr)(vaobj, attribindex, size, type, relativeoffset); +// } +// static void glowVertexArrayVertexAttribIOffsetEXT(GPVERTEXARRAYVERTEXATTRIBIOFFSETEXT fnptr, GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset) { +// (*fnptr)(vaobj, buffer, index, size, type, stride, offset); +// } +// static void glowVertexArrayVertexAttribLFormatEXT(GPVERTEXARRAYVERTEXATTRIBLFORMATEXT fnptr, GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) { +// (*fnptr)(vaobj, attribindex, size, type, relativeoffset); +// } +// static void glowVertexArrayVertexAttribLOffsetEXT(GPVERTEXARRAYVERTEXATTRIBLOFFSETEXT fnptr, GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset) { +// (*fnptr)(vaobj, buffer, index, size, type, stride, offset); +// } +// static void glowVertexArrayVertexAttribOffsetEXT(GPVERTEXARRAYVERTEXATTRIBOFFSETEXT fnptr, GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset) { +// (*fnptr)(vaobj, buffer, index, size, type, normalized, stride, offset); +// } +// static void glowVertexArrayVertexBindingDivisorEXT(GPVERTEXARRAYVERTEXBINDINGDIVISOREXT fnptr, GLuint vaobj, GLuint bindingindex, GLuint divisor) { +// (*fnptr)(vaobj, bindingindex, divisor); +// } +// static void glowVertexArrayVertexBuffer(GPVERTEXARRAYVERTEXBUFFER fnptr, GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride) { +// (*fnptr)(vaobj, bindingindex, buffer, offset, stride); +// } +// static void glowVertexArrayVertexBuffers(GPVERTEXARRAYVERTEXBUFFERS fnptr, GLuint vaobj, GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizei * strides) { +// (*fnptr)(vaobj, first, count, buffers, offsets, strides); +// } +// static void glowVertexArrayVertexOffsetEXT(GPVERTEXARRAYVERTEXOFFSETEXT fnptr, GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset) { +// (*fnptr)(vaobj, buffer, size, type, stride, offset); +// } +// static void glowVertexAttrib1d(GPVERTEXATTRIB1D fnptr, GLuint index, GLdouble x) { +// (*fnptr)(index, x); +// } +// static void glowVertexAttrib1dv(GPVERTEXATTRIB1DV fnptr, GLuint index, const GLdouble * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib1f(GPVERTEXATTRIB1F fnptr, GLuint index, GLfloat x) { +// (*fnptr)(index, x); +// } +// static void glowVertexAttrib1fv(GPVERTEXATTRIB1FV fnptr, GLuint index, const GLfloat * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib1s(GPVERTEXATTRIB1S fnptr, GLuint index, GLshort x) { +// (*fnptr)(index, x); +// } +// static void glowVertexAttrib1sv(GPVERTEXATTRIB1SV fnptr, GLuint index, const GLshort * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib2d(GPVERTEXATTRIB2D fnptr, GLuint index, GLdouble x, GLdouble y) { +// (*fnptr)(index, x, y); +// } +// static void glowVertexAttrib2dv(GPVERTEXATTRIB2DV fnptr, GLuint index, const GLdouble * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib2f(GPVERTEXATTRIB2F fnptr, GLuint index, GLfloat x, GLfloat y) { +// (*fnptr)(index, x, y); +// } +// static void glowVertexAttrib2fv(GPVERTEXATTRIB2FV fnptr, GLuint index, const GLfloat * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib2s(GPVERTEXATTRIB2S fnptr, GLuint index, GLshort x, GLshort y) { +// (*fnptr)(index, x, y); +// } +// static void glowVertexAttrib2sv(GPVERTEXATTRIB2SV fnptr, GLuint index, const GLshort * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib3d(GPVERTEXATTRIB3D fnptr, GLuint index, GLdouble x, GLdouble y, GLdouble z) { +// (*fnptr)(index, x, y, z); +// } +// static void glowVertexAttrib3dv(GPVERTEXATTRIB3DV fnptr, GLuint index, const GLdouble * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib3f(GPVERTEXATTRIB3F fnptr, GLuint index, GLfloat x, GLfloat y, GLfloat z) { +// (*fnptr)(index, x, y, z); +// } +// static void glowVertexAttrib3fv(GPVERTEXATTRIB3FV fnptr, GLuint index, const GLfloat * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib3s(GPVERTEXATTRIB3S fnptr, GLuint index, GLshort x, GLshort y, GLshort z) { +// (*fnptr)(index, x, y, z); +// } +// static void glowVertexAttrib3sv(GPVERTEXATTRIB3SV fnptr, GLuint index, const GLshort * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib4Nbv(GPVERTEXATTRIB4NBV fnptr, GLuint index, const GLbyte * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib4Niv(GPVERTEXATTRIB4NIV fnptr, GLuint index, const GLint * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib4Nsv(GPVERTEXATTRIB4NSV fnptr, GLuint index, const GLshort * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib4Nub(GPVERTEXATTRIB4NUB fnptr, GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) { +// (*fnptr)(index, x, y, z, w); +// } +// static void glowVertexAttrib4Nubv(GPVERTEXATTRIB4NUBV fnptr, GLuint index, const GLubyte * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib4Nuiv(GPVERTEXATTRIB4NUIV fnptr, GLuint index, const GLuint * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib4Nusv(GPVERTEXATTRIB4NUSV fnptr, GLuint index, const GLushort * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib4bv(GPVERTEXATTRIB4BV fnptr, GLuint index, const GLbyte * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib4d(GPVERTEXATTRIB4D fnptr, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { +// (*fnptr)(index, x, y, z, w); +// } +// static void glowVertexAttrib4dv(GPVERTEXATTRIB4DV fnptr, GLuint index, const GLdouble * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib4f(GPVERTEXATTRIB4F fnptr, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { +// (*fnptr)(index, x, y, z, w); +// } +// static void glowVertexAttrib4fv(GPVERTEXATTRIB4FV fnptr, GLuint index, const GLfloat * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib4iv(GPVERTEXATTRIB4IV fnptr, GLuint index, const GLint * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib4s(GPVERTEXATTRIB4S fnptr, GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) { +// (*fnptr)(index, x, y, z, w); +// } +// static void glowVertexAttrib4sv(GPVERTEXATTRIB4SV fnptr, GLuint index, const GLshort * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib4ubv(GPVERTEXATTRIB4UBV fnptr, GLuint index, const GLubyte * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib4uiv(GPVERTEXATTRIB4UIV fnptr, GLuint index, const GLuint * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttrib4usv(GPVERTEXATTRIB4USV fnptr, GLuint index, const GLushort * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribBinding(GPVERTEXATTRIBBINDING fnptr, GLuint attribindex, GLuint bindingindex) { +// (*fnptr)(attribindex, bindingindex); +// } +// static void glowVertexAttribDivisor(GPVERTEXATTRIBDIVISOR fnptr, GLuint index, GLuint divisor) { +// (*fnptr)(index, divisor); +// } +// static void glowVertexAttribDivisorARB(GPVERTEXATTRIBDIVISORARB fnptr, GLuint index, GLuint divisor) { +// (*fnptr)(index, divisor); +// } +// static void glowVertexAttribFormat(GPVERTEXATTRIBFORMAT fnptr, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset) { +// (*fnptr)(attribindex, size, type, normalized, relativeoffset); +// } +// static void glowVertexAttribFormatNV(GPVERTEXATTRIBFORMATNV fnptr, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride) { +// (*fnptr)(index, size, type, normalized, stride); +// } +// static void glowVertexAttribI1i(GPVERTEXATTRIBI1I fnptr, GLuint index, GLint x) { +// (*fnptr)(index, x); +// } +// static void glowVertexAttribI1iv(GPVERTEXATTRIBI1IV fnptr, GLuint index, const GLint * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribI1ui(GPVERTEXATTRIBI1UI fnptr, GLuint index, GLuint x) { +// (*fnptr)(index, x); +// } +// static void glowVertexAttribI1uiv(GPVERTEXATTRIBI1UIV fnptr, GLuint index, const GLuint * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribI2i(GPVERTEXATTRIBI2I fnptr, GLuint index, GLint x, GLint y) { +// (*fnptr)(index, x, y); +// } +// static void glowVertexAttribI2iv(GPVERTEXATTRIBI2IV fnptr, GLuint index, const GLint * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribI2ui(GPVERTEXATTRIBI2UI fnptr, GLuint index, GLuint x, GLuint y) { +// (*fnptr)(index, x, y); +// } +// static void glowVertexAttribI2uiv(GPVERTEXATTRIBI2UIV fnptr, GLuint index, const GLuint * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribI3i(GPVERTEXATTRIBI3I fnptr, GLuint index, GLint x, GLint y, GLint z) { +// (*fnptr)(index, x, y, z); +// } +// static void glowVertexAttribI3iv(GPVERTEXATTRIBI3IV fnptr, GLuint index, const GLint * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribI3ui(GPVERTEXATTRIBI3UI fnptr, GLuint index, GLuint x, GLuint y, GLuint z) { +// (*fnptr)(index, x, y, z); +// } +// static void glowVertexAttribI3uiv(GPVERTEXATTRIBI3UIV fnptr, GLuint index, const GLuint * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribI4bv(GPVERTEXATTRIBI4BV fnptr, GLuint index, const GLbyte * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribI4i(GPVERTEXATTRIBI4I fnptr, GLuint index, GLint x, GLint y, GLint z, GLint w) { +// (*fnptr)(index, x, y, z, w); +// } +// static void glowVertexAttribI4iv(GPVERTEXATTRIBI4IV fnptr, GLuint index, const GLint * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribI4sv(GPVERTEXATTRIBI4SV fnptr, GLuint index, const GLshort * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribI4ubv(GPVERTEXATTRIBI4UBV fnptr, GLuint index, const GLubyte * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribI4ui(GPVERTEXATTRIBI4UI fnptr, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) { +// (*fnptr)(index, x, y, z, w); +// } +// static void glowVertexAttribI4uiv(GPVERTEXATTRIBI4UIV fnptr, GLuint index, const GLuint * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribI4usv(GPVERTEXATTRIBI4USV fnptr, GLuint index, const GLushort * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribIFormat(GPVERTEXATTRIBIFORMAT fnptr, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) { +// (*fnptr)(attribindex, size, type, relativeoffset); +// } +// static void glowVertexAttribIFormatNV(GPVERTEXATTRIBIFORMATNV fnptr, GLuint index, GLint size, GLenum type, GLsizei stride) { +// (*fnptr)(index, size, type, stride); +// } +// static void glowVertexAttribIPointer(GPVERTEXATTRIBIPOINTER fnptr, GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer) { +// (*fnptr)(index, size, type, stride, pointer); +// } +// static void glowVertexAttribIPointerWithOffset(GPVERTEXATTRIBIPOINTER fnptr, GLuint index, GLint size, GLenum type, GLsizei stride, uintptr_t offset) { +// (*fnptr)(index, size, type, stride, (const void *)(offset)); +// } +// static void glowVertexAttribL1d(GPVERTEXATTRIBL1D fnptr, GLuint index, GLdouble x) { +// (*fnptr)(index, x); +// } +// static void glowVertexAttribL1dv(GPVERTEXATTRIBL1DV fnptr, GLuint index, const GLdouble * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribL1i64NV(GPVERTEXATTRIBL1I64NV fnptr, GLuint index, GLint64EXT x) { +// (*fnptr)(index, x); +// } +// static void glowVertexAttribL1i64vNV(GPVERTEXATTRIBL1I64VNV fnptr, GLuint index, const GLint64EXT * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribL1ui64ARB(GPVERTEXATTRIBL1UI64ARB fnptr, GLuint index, GLuint64EXT x) { +// (*fnptr)(index, x); +// } +// static void glowVertexAttribL1ui64NV(GPVERTEXATTRIBL1UI64NV fnptr, GLuint index, GLuint64EXT x) { +// (*fnptr)(index, x); +// } +// static void glowVertexAttribL1ui64vARB(GPVERTEXATTRIBL1UI64VARB fnptr, GLuint index, const GLuint64EXT * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribL1ui64vNV(GPVERTEXATTRIBL1UI64VNV fnptr, GLuint index, const GLuint64EXT * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribL2d(GPVERTEXATTRIBL2D fnptr, GLuint index, GLdouble x, GLdouble y) { +// (*fnptr)(index, x, y); +// } +// static void glowVertexAttribL2dv(GPVERTEXATTRIBL2DV fnptr, GLuint index, const GLdouble * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribL2i64NV(GPVERTEXATTRIBL2I64NV fnptr, GLuint index, GLint64EXT x, GLint64EXT y) { +// (*fnptr)(index, x, y); +// } +// static void glowVertexAttribL2i64vNV(GPVERTEXATTRIBL2I64VNV fnptr, GLuint index, const GLint64EXT * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribL2ui64NV(GPVERTEXATTRIBL2UI64NV fnptr, GLuint index, GLuint64EXT x, GLuint64EXT y) { +// (*fnptr)(index, x, y); +// } +// static void glowVertexAttribL2ui64vNV(GPVERTEXATTRIBL2UI64VNV fnptr, GLuint index, const GLuint64EXT * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribL3d(GPVERTEXATTRIBL3D fnptr, GLuint index, GLdouble x, GLdouble y, GLdouble z) { +// (*fnptr)(index, x, y, z); +// } +// static void glowVertexAttribL3dv(GPVERTEXATTRIBL3DV fnptr, GLuint index, const GLdouble * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribL3i64NV(GPVERTEXATTRIBL3I64NV fnptr, GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z) { +// (*fnptr)(index, x, y, z); +// } +// static void glowVertexAttribL3i64vNV(GPVERTEXATTRIBL3I64VNV fnptr, GLuint index, const GLint64EXT * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribL3ui64NV(GPVERTEXATTRIBL3UI64NV fnptr, GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z) { +// (*fnptr)(index, x, y, z); +// } +// static void glowVertexAttribL3ui64vNV(GPVERTEXATTRIBL3UI64VNV fnptr, GLuint index, const GLuint64EXT * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribL4d(GPVERTEXATTRIBL4D fnptr, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) { +// (*fnptr)(index, x, y, z, w); +// } +// static void glowVertexAttribL4dv(GPVERTEXATTRIBL4DV fnptr, GLuint index, const GLdouble * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribL4i64NV(GPVERTEXATTRIBL4I64NV fnptr, GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w) { +// (*fnptr)(index, x, y, z, w); +// } +// static void glowVertexAttribL4i64vNV(GPVERTEXATTRIBL4I64VNV fnptr, GLuint index, const GLint64EXT * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribL4ui64NV(GPVERTEXATTRIBL4UI64NV fnptr, GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w) { +// (*fnptr)(index, x, y, z, w); +// } +// static void glowVertexAttribL4ui64vNV(GPVERTEXATTRIBL4UI64VNV fnptr, GLuint index, const GLuint64EXT * v) { +// (*fnptr)(index, v); +// } +// static void glowVertexAttribLFormat(GPVERTEXATTRIBLFORMAT fnptr, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) { +// (*fnptr)(attribindex, size, type, relativeoffset); +// } +// static void glowVertexAttribLFormatNV(GPVERTEXATTRIBLFORMATNV fnptr, GLuint index, GLint size, GLenum type, GLsizei stride) { +// (*fnptr)(index, size, type, stride); +// } +// static void glowVertexAttribLPointer(GPVERTEXATTRIBLPOINTER fnptr, GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer) { +// (*fnptr)(index, size, type, stride, pointer); +// } +// static void glowVertexAttribLPointerWithOffset(GPVERTEXATTRIBLPOINTER fnptr, GLuint index, GLint size, GLenum type, GLsizei stride, uintptr_t offset) { +// (*fnptr)(index, size, type, stride, (const void *)(offset)); +// } +// static void glowVertexAttribP1ui(GPVERTEXATTRIBP1UI fnptr, GLuint index, GLenum type, GLboolean normalized, GLuint value) { +// (*fnptr)(index, type, normalized, value); +// } +// static void glowVertexAttribP1uiv(GPVERTEXATTRIBP1UIV fnptr, GLuint index, GLenum type, GLboolean normalized, const GLuint * value) { +// (*fnptr)(index, type, normalized, value); +// } +// static void glowVertexAttribP2ui(GPVERTEXATTRIBP2UI fnptr, GLuint index, GLenum type, GLboolean normalized, GLuint value) { +// (*fnptr)(index, type, normalized, value); +// } +// static void glowVertexAttribP2uiv(GPVERTEXATTRIBP2UIV fnptr, GLuint index, GLenum type, GLboolean normalized, const GLuint * value) { +// (*fnptr)(index, type, normalized, value); +// } +// static void glowVertexAttribP3ui(GPVERTEXATTRIBP3UI fnptr, GLuint index, GLenum type, GLboolean normalized, GLuint value) { +// (*fnptr)(index, type, normalized, value); +// } +// static void glowVertexAttribP3uiv(GPVERTEXATTRIBP3UIV fnptr, GLuint index, GLenum type, GLboolean normalized, const GLuint * value) { +// (*fnptr)(index, type, normalized, value); +// } +// static void glowVertexAttribP4ui(GPVERTEXATTRIBP4UI fnptr, GLuint index, GLenum type, GLboolean normalized, GLuint value) { +// (*fnptr)(index, type, normalized, value); +// } +// static void glowVertexAttribP4uiv(GPVERTEXATTRIBP4UIV fnptr, GLuint index, GLenum type, GLboolean normalized, const GLuint * value) { +// (*fnptr)(index, type, normalized, value); +// } +// static void glowVertexAttribPointer(GPVERTEXATTRIBPOINTER fnptr, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer) { +// (*fnptr)(index, size, type, normalized, stride, pointer); +// } +// static void glowVertexAttribPointerWithOffset(GPVERTEXATTRIBPOINTER fnptr, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, uintptr_t offset) { +// (*fnptr)(index, size, type, normalized, stride, (const void *)(offset)); +// } +// static void glowVertexBindingDivisor(GPVERTEXBINDINGDIVISOR fnptr, GLuint bindingindex, GLuint divisor) { +// (*fnptr)(bindingindex, divisor); +// } +// static void glowVertexFormatNV(GPVERTEXFORMATNV fnptr, GLint size, GLenum type, GLsizei stride) { +// (*fnptr)(size, type, stride); +// } +// static void glowViewport(GPVIEWPORT fnptr, GLint x, GLint y, GLsizei width, GLsizei height) { +// (*fnptr)(x, y, width, height); +// } +// static void glowViewportArrayv(GPVIEWPORTARRAYV fnptr, GLuint first, GLsizei count, const GLfloat * v) { +// (*fnptr)(first, count, v); +// } +// static void glowViewportIndexedf(GPVIEWPORTINDEXEDF fnptr, GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) { +// (*fnptr)(index, x, y, w, h); +// } +// static void glowViewportIndexedfv(GPVIEWPORTINDEXEDFV fnptr, GLuint index, const GLfloat * v) { +// (*fnptr)(index, v); +// } +// static void glowViewportPositionWScaleNV(GPVIEWPORTPOSITIONWSCALENV fnptr, GLuint index, GLfloat xcoeff, GLfloat ycoeff) { +// (*fnptr)(index, xcoeff, ycoeff); +// } +// static void glowViewportSwizzleNV(GPVIEWPORTSWIZZLENV fnptr, GLuint index, GLenum swizzlex, GLenum swizzley, GLenum swizzlez, GLenum swizzlew) { +// (*fnptr)(index, swizzlex, swizzley, swizzlez, swizzlew); +// } +// static void glowWaitSync(GPWAITSYNC fnptr, GLsync sync, GLbitfield flags, GLuint64 timeout) { +// (*fnptr)(sync, flags, timeout); +// } +// static void glowWaitVkSemaphoreNV(GPWAITVKSEMAPHORENV fnptr, GLuint64 vkSemaphore) { +// (*fnptr)(vkSemaphore); +// } +// static void glowWeightPathsNV(GPWEIGHTPATHSNV fnptr, GLuint resultPath, GLsizei numPaths, const GLuint * paths, const GLfloat * weights) { +// (*fnptr)(resultPath, numPaths, paths, weights); +// } +// static void glowWindowRectanglesEXT(GPWINDOWRECTANGLESEXT fnptr, GLenum mode, GLsizei count, const GLint * box) { +// (*fnptr)(mode, count, box); +// } +import "C" +import ( + "errors" + "unsafe" +) + +const ( + ACCUM_ADJACENT_PAIRS_NV = 0x90AD + ACTIVE_ATOMIC_COUNTER_BUFFERS = 0x92D9 + ACTIVE_ATTRIBUTES = 0x8B89 + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A + ACTIVE_PROGRAM = 0x8259 + ACTIVE_PROGRAM_EXT = 0x8B8D + ACTIVE_RESOURCES = 0x92F5 + ACTIVE_SUBROUTINES = 0x8DE5 + ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48 + ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6 + ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47 + ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49 + ACTIVE_TEXTURE = 0x84E0 + ACTIVE_UNIFORMS = 0x8B86 + ACTIVE_UNIFORM_BLOCKS = 0x8A36 + ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35 + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 + ACTIVE_VARIABLES = 0x9305 + ADJACENT_PAIRS_NV = 0x90AE + AFFINE_2D_NV = 0x9092 + AFFINE_3D_NV = 0x9094 + ALIASED_LINE_WIDTH_RANGE = 0x846E + ALL_BARRIER_BITS = 0xFFFFFFFF + ALL_SHADER_BITS = 0xFFFFFFFF + ALL_SHADER_BITS_EXT = 0xFFFFFFFF + ALPHA = 0x1906 + ALPHA_REF_COMMAND_NV = 0x000F + ALREADY_SIGNALED = 0x911A + ALWAYS = 0x0207 + AND = 0x1501 + AND_INVERTED = 0x1504 + AND_REVERSE = 0x1502 + ANY_SAMPLES_PASSED = 0x8C2F + ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8D6A + ARC_TO_NV = 0xFE + ARRAY_BUFFER = 0x8892 + ARRAY_BUFFER_BINDING = 0x8894 + ARRAY_SIZE = 0x92FB + ARRAY_STRIDE = 0x92FE + ATOMIC_COUNTER_BARRIER_BIT = 0x00001000 + ATOMIC_COUNTER_BUFFER = 0x92C0 + ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = 0x92C5 + ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = 0x92C6 + ATOMIC_COUNTER_BUFFER_BINDING = 0x92C1 + ATOMIC_COUNTER_BUFFER_DATA_SIZE = 0x92C4 + ATOMIC_COUNTER_BUFFER_INDEX = 0x9301 + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = 0x90ED + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = 0x92CB + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = 0x92CA + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_NV = 0x959E + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_NV = 0x959F + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = 0x92C8 + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x92C9 + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = 0x92C7 + ATOMIC_COUNTER_BUFFER_SIZE = 0x92C3 + ATOMIC_COUNTER_BUFFER_START = 0x92C2 + ATTACHED_MEMORY_OBJECT_NV = 0x95A4 + ATTACHED_MEMORY_OFFSET_NV = 0x95A5 + ATTACHED_SHADERS = 0x8B85 + ATTRIBUTE_ADDRESS_COMMAND_NV = 0x0009 + AUTO_GENERATE_MIPMAP = 0x8295 + BACK = 0x0405 + BACK_LEFT = 0x0402 + BACK_RIGHT = 0x0403 + BEVEL_NV = 0x90A6 + BGR = 0x80E0 + BGRA = 0x80E1 + BGRA_INTEGER = 0x8D9B + BGR_INTEGER = 0x8D9A + BLACKHOLE_RENDER_INTEL = 0x83FC + BLEND = 0x0BE2 + BLEND_ADVANCED_COHERENT_KHR = 0x9285 + BLEND_ADVANCED_COHERENT_NV = 0x9285 + BLEND_COLOR = 0x8005 + BLEND_COLOR_COMMAND_NV = 0x000B + BLEND_DST = 0x0BE0 + BLEND_DST_ALPHA = 0x80CA + BLEND_DST_RGB = 0x80C8 + BLEND_EQUATION = 0x8009 + BLEND_EQUATION_ALPHA = 0x883D + BLEND_EQUATION_RGB = 0x8009 + BLEND_OVERLAP_NV = 0x9281 + BLEND_PREMULTIPLIED_SRC_NV = 0x9280 + BLEND_SRC = 0x0BE1 + BLEND_SRC_ALPHA = 0x80CB + BLEND_SRC_RGB = 0x80C9 + BLOCK_INDEX = 0x92FD + BLUE = 0x1905 + BLUE_INTEGER = 0x8D96 + BLUE_NV = 0x1905 + BOLD_BIT_NV = 0x01 + BOOL = 0x8B56 + BOOL_VEC2 = 0x8B57 + BOOL_VEC3 = 0x8B58 + BOOL_VEC4 = 0x8B59 + BOUNDING_BOX_NV = 0x908D + BOUNDING_BOX_OF_BOUNDING_BOXES_NV = 0x909C + BUFFER = 0x82E0 + BUFFER_ACCESS = 0x88BB + BUFFER_ACCESS_FLAGS = 0x911F + BUFFER_BINDING = 0x9302 + BUFFER_DATA_SIZE = 0x9303 + BUFFER_GPU_ADDRESS_NV = 0x8F1D + BUFFER_IMMUTABLE_STORAGE = 0x821F + BUFFER_KHR = 0x82E0 + BUFFER_MAPPED = 0x88BC + BUFFER_MAP_LENGTH = 0x9120 + BUFFER_MAP_OFFSET = 0x9121 + BUFFER_MAP_POINTER = 0x88BD + BUFFER_OBJECT_EXT = 0x9151 + BUFFER_SIZE = 0x8764 + BUFFER_STORAGE_FLAGS = 0x8220 + BUFFER_UPDATE_BARRIER_BIT = 0x00000200 + BUFFER_USAGE = 0x8765 + BUFFER_VARIABLE = 0x92E5 + BYTE = 0x1400 + CAVEAT_SUPPORT = 0x82B8 + CCW = 0x0901 + CIRCULAR_CCW_ARC_TO_NV = 0xF8 + CIRCULAR_CW_ARC_TO_NV = 0xFA + CIRCULAR_TANGENT_ARC_TO_NV = 0xFC + CLAMP_READ_COLOR = 0x891C + CLAMP_TO_BORDER = 0x812D + CLAMP_TO_BORDER_ARB = 0x812D + CLAMP_TO_EDGE = 0x812F + CLEAR = 0x1500 + CLEAR_BUFFER = 0x82B4 + CLEAR_TEXTURE = 0x9365 + CLIENT_MAPPED_BUFFER_BARRIER_BIT = 0x00004000 + CLIENT_STORAGE_BIT = 0x0200 + CLIPPING_INPUT_PRIMITIVES_ARB = 0x82F6 + CLIPPING_OUTPUT_PRIMITIVES_ARB = 0x82F7 + CLIP_DEPTH_MODE = 0x935D + CLIP_DISTANCE0 = 0x3000 + CLIP_DISTANCE1 = 0x3001 + CLIP_DISTANCE2 = 0x3002 + CLIP_DISTANCE3 = 0x3003 + CLIP_DISTANCE4 = 0x3004 + CLIP_DISTANCE5 = 0x3005 + CLIP_DISTANCE6 = 0x3006 + CLIP_DISTANCE7 = 0x3007 + CLIP_ORIGIN = 0x935C + CLOSE_PATH_NV = 0x00 + COLOR = 0x1800 + COLORBURN_KHR = 0x929A + COLORBURN_NV = 0x929A + COLORDODGE_KHR = 0x9299 + COLORDODGE_NV = 0x9299 + COLOR_ARRAY_ADDRESS_NV = 0x8F23 + COLOR_ARRAY_LENGTH_NV = 0x8F2D + COLOR_ATTACHMENT0 = 0x8CE0 + COLOR_ATTACHMENT1 = 0x8CE1 + 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_ATTACHMENT2 = 0x8CE2 + 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_ATTACHMENT3 = 0x8CE3 + COLOR_ATTACHMENT30 = 0x8CFE + COLOR_ATTACHMENT31 = 0x8CFF + COLOR_ATTACHMENT4 = 0x8CE4 + COLOR_ATTACHMENT5 = 0x8CE5 + COLOR_ATTACHMENT6 = 0x8CE6 + COLOR_ATTACHMENT7 = 0x8CE7 + COLOR_ATTACHMENT8 = 0x8CE8 + COLOR_ATTACHMENT9 = 0x8CE9 + COLOR_BUFFER_BIT = 0x00004000 + COLOR_CLEAR_VALUE = 0x0C22 + COLOR_COMPONENTS = 0x8283 + COLOR_ENCODING = 0x8296 + COLOR_LOGIC_OP = 0x0BF2 + COLOR_RENDERABLE = 0x8286 + COLOR_SAMPLES_NV = 0x8E20 + COLOR_WRITEMASK = 0x0C23 + COMMAND_BARRIER_BIT = 0x00000040 + COMPARE_REF_TO_TEXTURE = 0x884E + COMPATIBLE_SUBROUTINES = 0x8E4B + COMPILE_STATUS = 0x8B81 + COMPLETION_STATUS_ARB = 0x91B1 + COMPLETION_STATUS_KHR = 0x91B1 + COMPRESSED_R11_EAC = 0x9270 + COMPRESSED_RED = 0x8225 + COMPRESSED_RED_RGTC1 = 0x8DBB + COMPRESSED_RG = 0x8226 + COMPRESSED_RG11_EAC = 0x9272 + COMPRESSED_RGB = 0x84ED + COMPRESSED_RGB8_ETC2 = 0x9274 + COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276 + COMPRESSED_RGBA = 0x84EE + COMPRESSED_RGBA8_ETC2_EAC = 0x9278 + COMPRESSED_RGBA_ASTC_10x10_KHR = 0x93BB + COMPRESSED_RGBA_ASTC_10x5_KHR = 0x93B8 + COMPRESSED_RGBA_ASTC_10x6_KHR = 0x93B9 + COMPRESSED_RGBA_ASTC_10x8_KHR = 0x93BA + COMPRESSED_RGBA_ASTC_12x10_KHR = 0x93BC + COMPRESSED_RGBA_ASTC_12x12_KHR = 0x93BD + COMPRESSED_RGBA_ASTC_4x4_KHR = 0x93B0 + COMPRESSED_RGBA_ASTC_5x4_KHR = 0x93B1 + COMPRESSED_RGBA_ASTC_5x5_KHR = 0x93B2 + COMPRESSED_RGBA_ASTC_6x5_KHR = 0x93B3 + COMPRESSED_RGBA_ASTC_6x6_KHR = 0x93B4 + COMPRESSED_RGBA_ASTC_8x5_KHR = 0x93B5 + COMPRESSED_RGBA_ASTC_8x6_KHR = 0x93B6 + COMPRESSED_RGBA_ASTC_8x8_KHR = 0x93B7 + COMPRESSED_RGBA_BPTC_UNORM_ARB = 0x8E8C + COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83F1 + COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83F2 + COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3 + COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB = 0x8E8E + COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB = 0x8E8F + COMPRESSED_RGB_S3TC_DXT1_EXT = 0x83F0 + COMPRESSED_RG_RGTC2 = 0x8DBD + COMPRESSED_SIGNED_R11_EAC = 0x9271 + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC + COMPRESSED_SIGNED_RG11_EAC = 0x9273 + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE + COMPRESSED_SRGB = 0x8C48 + COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = 0x93DB + COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = 0x93D8 + COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = 0x93D9 + COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = 0x93DA + COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = 0x93DC + COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = 0x93DD + COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = 0x93D0 + COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = 0x93D1 + COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = 0x93D2 + COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = 0x93D3 + COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = 0x93D4 + COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = 0x93D5 + COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = 0x93D6 + COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = 0x93D7 + COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279 + COMPRESSED_SRGB8_ETC2 = 0x9275 + COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277 + COMPRESSED_SRGB_ALPHA = 0x8C49 + COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB = 0x8E8D + COMPRESSED_TEXTURE_FORMATS = 0x86A3 + COMPUTE_SHADER = 0x91B9 + COMPUTE_SHADER_BIT = 0x00000020 + COMPUTE_SHADER_INVOCATIONS_ARB = 0x82F5 + COMPUTE_SUBROUTINE = 0x92ED + COMPUTE_SUBROUTINE_UNIFORM = 0x92F3 + COMPUTE_TEXTURE = 0x82A0 + COMPUTE_WORK_GROUP_SIZE = 0x8267 + CONDITION_SATISFIED = 0x911C + CONFORMANT_NV = 0x9374 + CONIC_CURVE_TO_NV = 0x1A + CONJOINT_NV = 0x9284 + CONSERVATIVE_RASTERIZATION_INTEL = 0x83FE + CONSERVATIVE_RASTERIZATION_NV = 0x9346 + CONSERVATIVE_RASTER_DILATE_GRANULARITY_NV = 0x937B + CONSERVATIVE_RASTER_DILATE_NV = 0x9379 + CONSERVATIVE_RASTER_DILATE_RANGE_NV = 0x937A + CONSERVATIVE_RASTER_MODE_NV = 0x954D + CONSERVATIVE_RASTER_MODE_POST_SNAP_NV = 0x954E + CONSERVATIVE_RASTER_MODE_PRE_SNAP_NV = 0x9550 + CONSERVATIVE_RASTER_MODE_PRE_SNAP_TRIANGLES_NV = 0x954F + CONSTANT_ALPHA = 0x8003 + CONSTANT_COLOR = 0x8001 + CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002 + CONTEXT_CORE_PROFILE_BIT = 0x00000001 + CONTEXT_FLAGS = 0x821E + CONTEXT_FLAG_DEBUG_BIT = 0x00000002 + CONTEXT_FLAG_DEBUG_BIT_KHR = 0x00000002 + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001 + CONTEXT_FLAG_NO_ERROR_BIT_KHR = 0x00000008 + CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB = 0x00000004 + CONTEXT_LOST = 0x0507 + CONTEXT_LOST_KHR = 0x0507 + CONTEXT_PROFILE_MASK = 0x9126 + CONTEXT_RELEASE_BEHAVIOR = 0x82FB + CONTEXT_RELEASE_BEHAVIOR_FLUSH = 0x82FC + CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR = 0x82FC + CONTEXT_RELEASE_BEHAVIOR_KHR = 0x82FB + CONTEXT_ROBUST_ACCESS = 0x90F3 + CONTEXT_ROBUST_ACCESS_KHR = 0x90F3 + CONTRAST_NV = 0x92A1 + CONVEX_HULL_NV = 0x908B + COPY = 0x1503 + COPY_INVERTED = 0x150C + COPY_READ_BUFFER = 0x8F36 + COPY_WRITE_BUFFER = 0x8F37 + COUNTER_RANGE_AMD = 0x8BC1 + COUNTER_TYPE_AMD = 0x8BC0 + COUNT_DOWN_NV = 0x9089 + COUNT_UP_NV = 0x9088 + COVERAGE_MODULATION_NV = 0x9332 + COVERAGE_MODULATION_TABLE_NV = 0x9331 + COVERAGE_MODULATION_TABLE_SIZE_NV = 0x9333 + CUBIC_CURVE_TO_NV = 0x0C + CULL_FACE = 0x0B44 + CULL_FACE_MODE = 0x0B45 + CURRENT_PROGRAM = 0x8B8D + CURRENT_QUERY = 0x8865 + CURRENT_VERTEX_ATTRIB = 0x8626 + CW = 0x0900 + DARKEN_KHR = 0x9297 + DARKEN_NV = 0x9297 + DEBUG_CALLBACK_FUNCTION = 0x8244 + DEBUG_CALLBACK_FUNCTION_ARB = 0x8244 + DEBUG_CALLBACK_FUNCTION_KHR = 0x8244 + DEBUG_CALLBACK_USER_PARAM = 0x8245 + DEBUG_CALLBACK_USER_PARAM_ARB = 0x8245 + DEBUG_CALLBACK_USER_PARAM_KHR = 0x8245 + DEBUG_GROUP_STACK_DEPTH = 0x826D + DEBUG_GROUP_STACK_DEPTH_KHR = 0x826D + DEBUG_LOGGED_MESSAGES = 0x9145 + DEBUG_LOGGED_MESSAGES_ARB = 0x9145 + DEBUG_LOGGED_MESSAGES_KHR = 0x9145 + DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = 0x8243 + DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB = 0x8243 + DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR = 0x8243 + DEBUG_OUTPUT = 0x92E0 + DEBUG_OUTPUT_KHR = 0x92E0 + DEBUG_OUTPUT_SYNCHRONOUS = 0x8242 + DEBUG_OUTPUT_SYNCHRONOUS_ARB = 0x8242 + DEBUG_OUTPUT_SYNCHRONOUS_KHR = 0x8242 + DEBUG_SEVERITY_HIGH = 0x9146 + DEBUG_SEVERITY_HIGH_ARB = 0x9146 + DEBUG_SEVERITY_HIGH_KHR = 0x9146 + DEBUG_SEVERITY_LOW = 0x9148 + DEBUG_SEVERITY_LOW_ARB = 0x9148 + DEBUG_SEVERITY_LOW_KHR = 0x9148 + DEBUG_SEVERITY_MEDIUM = 0x9147 + DEBUG_SEVERITY_MEDIUM_ARB = 0x9147 + DEBUG_SEVERITY_MEDIUM_KHR = 0x9147 + DEBUG_SEVERITY_NOTIFICATION = 0x826B + DEBUG_SEVERITY_NOTIFICATION_KHR = 0x826B + DEBUG_SOURCE_API = 0x8246 + DEBUG_SOURCE_API_ARB = 0x8246 + DEBUG_SOURCE_API_KHR = 0x8246 + DEBUG_SOURCE_APPLICATION = 0x824A + DEBUG_SOURCE_APPLICATION_ARB = 0x824A + DEBUG_SOURCE_APPLICATION_KHR = 0x824A + DEBUG_SOURCE_OTHER = 0x824B + DEBUG_SOURCE_OTHER_ARB = 0x824B + DEBUG_SOURCE_OTHER_KHR = 0x824B + DEBUG_SOURCE_SHADER_COMPILER = 0x8248 + DEBUG_SOURCE_SHADER_COMPILER_ARB = 0x8248 + DEBUG_SOURCE_SHADER_COMPILER_KHR = 0x8248 + DEBUG_SOURCE_THIRD_PARTY = 0x8249 + DEBUG_SOURCE_THIRD_PARTY_ARB = 0x8249 + DEBUG_SOURCE_THIRD_PARTY_KHR = 0x8249 + DEBUG_SOURCE_WINDOW_SYSTEM = 0x8247 + DEBUG_SOURCE_WINDOW_SYSTEM_ARB = 0x8247 + DEBUG_SOURCE_WINDOW_SYSTEM_KHR = 0x8247 + DEBUG_TYPE_DEPRECATED_BEHAVIOR = 0x824D + DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB = 0x824D + DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR = 0x824D + DEBUG_TYPE_ERROR = 0x824C + DEBUG_TYPE_ERROR_ARB = 0x824C + DEBUG_TYPE_ERROR_KHR = 0x824C + DEBUG_TYPE_MARKER = 0x8268 + DEBUG_TYPE_MARKER_KHR = 0x8268 + DEBUG_TYPE_OTHER = 0x8251 + DEBUG_TYPE_OTHER_ARB = 0x8251 + DEBUG_TYPE_OTHER_KHR = 0x8251 + DEBUG_TYPE_PERFORMANCE = 0x8250 + DEBUG_TYPE_PERFORMANCE_ARB = 0x8250 + DEBUG_TYPE_PERFORMANCE_KHR = 0x8250 + DEBUG_TYPE_POP_GROUP = 0x826A + DEBUG_TYPE_POP_GROUP_KHR = 0x826A + DEBUG_TYPE_PORTABILITY = 0x824F + DEBUG_TYPE_PORTABILITY_ARB = 0x824F + DEBUG_TYPE_PORTABILITY_KHR = 0x824F + DEBUG_TYPE_PUSH_GROUP = 0x8269 + DEBUG_TYPE_PUSH_GROUP_KHR = 0x8269 + DEBUG_TYPE_UNDEFINED_BEHAVIOR = 0x824E + DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB = 0x824E + DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR = 0x824E + DECODE_EXT = 0x8A49 + DECR = 0x1E03 + DECR_WRAP = 0x8508 + DELETE_STATUS = 0x8B80 + DEPTH = 0x1801 + DEPTH24_STENCIL8 = 0x88F0 + DEPTH32F_STENCIL8 = 0x8CAD + DEPTH32F_STENCIL8_NV = 0x8DAC + DEPTH_ATTACHMENT = 0x8D00 + DEPTH_BUFFER_BIT = 0x00000100 + DEPTH_BUFFER_FLOAT_MODE_NV = 0x8DAF + DEPTH_CLAMP = 0x864F + DEPTH_CLEAR_VALUE = 0x0B73 + DEPTH_COMPONENT = 0x1902 + DEPTH_COMPONENT16 = 0x81A5 + DEPTH_COMPONENT24 = 0x81A6 + DEPTH_COMPONENT32 = 0x81A7 + DEPTH_COMPONENT32F = 0x8CAC + DEPTH_COMPONENT32F_NV = 0x8DAB + DEPTH_COMPONENTS = 0x8284 + DEPTH_FUNC = 0x0B74 + DEPTH_RANGE = 0x0B70 + DEPTH_RENDERABLE = 0x8287 + DEPTH_SAMPLES_NV = 0x932D + DEPTH_STENCIL = 0x84F9 + DEPTH_STENCIL_ATTACHMENT = 0x821A + DEPTH_STENCIL_TEXTURE_MODE = 0x90EA + DEPTH_TEST = 0x0B71 + DEPTH_WRITEMASK = 0x0B72 + DETACHED_BUFFERS_NV = 0x95AB + DETACHED_MEMORY_INCARNATION_NV = 0x95A9 + DETACHED_TEXTURES_NV = 0x95AA + DIFFERENCE_KHR = 0x929E + DIFFERENCE_NV = 0x929E + DISJOINT_NV = 0x9283 + DISPATCH_INDIRECT_BUFFER = 0x90EE + DISPATCH_INDIRECT_BUFFER_BINDING = 0x90EF + DITHER = 0x0BD0 + DONT_CARE = 0x1100 + DOUBLE = 0x140A + DOUBLEBUFFER = 0x0C32 + DOUBLE_MAT2 = 0x8F46 + DOUBLE_MAT2x3 = 0x8F49 + DOUBLE_MAT2x4 = 0x8F4A + DOUBLE_MAT3 = 0x8F47 + DOUBLE_MAT3x2 = 0x8F4B + DOUBLE_MAT3x4 = 0x8F4C + DOUBLE_MAT4 = 0x8F48 + DOUBLE_MAT4x2 = 0x8F4D + DOUBLE_MAT4x3 = 0x8F4E + DOUBLE_VEC2 = 0x8FFC + DOUBLE_VEC3 = 0x8FFD + DOUBLE_VEC4 = 0x8FFE + DRAW_ARRAYS_COMMAND_NV = 0x0003 + DRAW_ARRAYS_INSTANCED_COMMAND_NV = 0x0007 + DRAW_ARRAYS_STRIP_COMMAND_NV = 0x0005 + DRAW_BUFFER = 0x0C01 + DRAW_BUFFER0 = 0x8825 + DRAW_BUFFER1 = 0x8826 + DRAW_BUFFER10 = 0x882F + DRAW_BUFFER11 = 0x8830 + DRAW_BUFFER12 = 0x8831 + DRAW_BUFFER13 = 0x8832 + DRAW_BUFFER14 = 0x8833 + DRAW_BUFFER15 = 0x8834 + 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_ELEMENTS_COMMAND_NV = 0x0002 + DRAW_ELEMENTS_INSTANCED_COMMAND_NV = 0x0006 + DRAW_ELEMENTS_STRIP_COMMAND_NV = 0x0004 + DRAW_FRAMEBUFFER = 0x8CA9 + DRAW_FRAMEBUFFER_BINDING = 0x8CA6 + DRAW_INDIRECT_ADDRESS_NV = 0x8F41 + DRAW_INDIRECT_BUFFER = 0x8F3F + DRAW_INDIRECT_BUFFER_BINDING = 0x8F43 + DRAW_INDIRECT_LENGTH_NV = 0x8F42 + DRAW_INDIRECT_UNIFIED_NV = 0x8F40 + DST_ALPHA = 0x0304 + DST_ATOP_NV = 0x928F + DST_COLOR = 0x0306 + DST_IN_NV = 0x928B + DST_NV = 0x9287 + DST_OUT_NV = 0x928D + DST_OVER_NV = 0x9289 + DUP_FIRST_CUBIC_CURVE_TO_NV = 0xF2 + DUP_LAST_CUBIC_CURVE_TO_NV = 0xF4 + DYNAMIC_COPY = 0x88EA + DYNAMIC_DRAW = 0x88E8 + DYNAMIC_READ = 0x88E9 + DYNAMIC_STORAGE_BIT = 0x0100 + EDGE_FLAG_ARRAY_ADDRESS_NV = 0x8F26 + EDGE_FLAG_ARRAY_LENGTH_NV = 0x8F30 + EFFECTIVE_RASTER_SAMPLES_EXT = 0x932C + ELEMENT_ADDRESS_COMMAND_NV = 0x0008 + ELEMENT_ARRAY_ADDRESS_NV = 0x8F29 + ELEMENT_ARRAY_BARRIER_BIT = 0x00000002 + ELEMENT_ARRAY_BUFFER = 0x8893 + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + ELEMENT_ARRAY_LENGTH_NV = 0x8F33 + ELEMENT_ARRAY_UNIFIED_NV = 0x8F1F + EQUAL = 0x0202 + EQUIV = 0x1509 + EXCLUSION_KHR = 0x92A0 + EXCLUSION_NV = 0x92A0 + EXCLUSIVE_EXT = 0x8F11 + EXTENSIONS = 0x1F03 + FACTOR_MAX_AMD = 0x901D + FACTOR_MIN_AMD = 0x901C + FALSE = 0 + FASTEST = 0x1101 + FILE_NAME_NV = 0x9074 + FILL = 0x1B02 + FILL_RECTANGLE_NV = 0x933C + FILTER = 0x829A + FIRST_TO_REST_NV = 0x90AF + FIRST_VERTEX_CONVENTION = 0x8E4D + FIXED = 0x140C + FIXED_ONLY = 0x891D + FLOAT = 0x1406 + FLOAT16_NV = 0x8FF8 + FLOAT16_VEC2_NV = 0x8FF9 + FLOAT16_VEC3_NV = 0x8FFA + FLOAT16_VEC4_NV = 0x8FFB + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD + FLOAT_32_UNSIGNED_INT_24_8_REV_NV = 0x8DAD + FLOAT_MAT2 = 0x8B5A + FLOAT_MAT2x3 = 0x8B65 + FLOAT_MAT2x4 = 0x8B66 + FLOAT_MAT3 = 0x8B5B + FLOAT_MAT3x2 = 0x8B67 + FLOAT_MAT3x4 = 0x8B68 + FLOAT_MAT4 = 0x8B5C + FLOAT_MAT4x2 = 0x8B69 + FLOAT_MAT4x3 = 0x8B6A + FLOAT_VEC2 = 0x8B50 + FLOAT_VEC3 = 0x8B51 + FLOAT_VEC4 = 0x8B52 + FOG_COORD_ARRAY_ADDRESS_NV = 0x8F28 + FOG_COORD_ARRAY_LENGTH_NV = 0x8F32 + FONT_ASCENDER_BIT_NV = 0x00200000 + FONT_DESCENDER_BIT_NV = 0x00400000 + FONT_GLYPHS_AVAILABLE_NV = 0x9368 + FONT_HAS_KERNING_BIT_NV = 0x10000000 + FONT_HEIGHT_BIT_NV = 0x00800000 + FONT_MAX_ADVANCE_HEIGHT_BIT_NV = 0x02000000 + FONT_MAX_ADVANCE_WIDTH_BIT_NV = 0x01000000 + FONT_NUM_GLYPH_INDICES_BIT_NV = 0x20000000 + FONT_TARGET_UNAVAILABLE_NV = 0x9369 + FONT_UNAVAILABLE_NV = 0x936A + FONT_UNDERLINE_POSITION_BIT_NV = 0x04000000 + FONT_UNDERLINE_THICKNESS_BIT_NV = 0x08000000 + FONT_UNINTELLIGIBLE_NV = 0x936B + FONT_UNITS_PER_EM_BIT_NV = 0x00100000 + FONT_X_MAX_BOUNDS_BIT_NV = 0x00040000 + FONT_X_MIN_BOUNDS_BIT_NV = 0x00010000 + FONT_Y_MAX_BOUNDS_BIT_NV = 0x00080000 + FONT_Y_MIN_BOUNDS_BIT_NV = 0x00020000 + FRACTIONAL_EVEN = 0x8E7C + FRACTIONAL_ODD = 0x8E7B + FRAGMENT_COVERAGE_COLOR_NV = 0x92DE + FRAGMENT_COVERAGE_TO_COLOR_NV = 0x92DD + FRAGMENT_INPUT_NV = 0x936D + FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D + FRAGMENT_SHADER = 0x8B30 + FRAGMENT_SHADER_BIT = 0x00000002 + FRAGMENT_SHADER_BIT_EXT = 0x00000002 + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B + FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT = 0x8A52 + FRAGMENT_SHADER_INVOCATIONS_ARB = 0x82F4 + FRAGMENT_SUBROUTINE = 0x92EC + FRAGMENT_SUBROUTINE_UNIFORM = 0x92F2 + FRAGMENT_TEXTURE = 0x829F + FRAMEBUFFER = 0x8D40 + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215 + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214 + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210 + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211 + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216 + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213 + FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7 + FRAMEBUFFER_ATTACHMENT_LAYERED_ARB = 0x8DA7 + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1 + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0 + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212 + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217 + FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR = 0x9632 + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4 + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2 + FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR = 0x9630 + FRAMEBUFFER_BARRIER_BIT = 0x00000400 + FRAMEBUFFER_BINDING = 0x8CA6 + FRAMEBUFFER_BLEND = 0x828B + FRAMEBUFFER_COMPLETE = 0x8CD5 + FRAMEBUFFER_DEFAULT = 0x8218 + FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = 0x9314 + FRAMEBUFFER_DEFAULT_HEIGHT = 0x9311 + FRAMEBUFFER_DEFAULT_LAYERS = 0x9312 + FRAMEBUFFER_DEFAULT_SAMPLES = 0x9313 + FRAMEBUFFER_DEFAULT_WIDTH = 0x9310 + FRAMEBUFFER_FLIP_X_MESA = 0x8BBC + FRAMEBUFFER_FLIP_Y_MESA = 0x8BBB + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6 + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB + FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB = 0x8DA9 + FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8 + FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB = 0x8DA8 + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7 + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56 + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC + FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR = 0x9633 + FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_ARB = 0x9342 + FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_NV = 0x9342 + FRAMEBUFFER_RENDERABLE = 0x8289 + FRAMEBUFFER_RENDERABLE_LAYERED = 0x828A + FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_ARB = 0x9343 + FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_NV = 0x9343 + FRAMEBUFFER_SRGB = 0x8DB9 + FRAMEBUFFER_SWAP_XY_MESA = 0x8BBD + FRAMEBUFFER_UNDEFINED = 0x8219 + FRAMEBUFFER_UNSUPPORTED = 0x8CDD + FRONT = 0x0404 + FRONT_AND_BACK = 0x0408 + FRONT_FACE = 0x0B46 + FRONT_FACE_COMMAND_NV = 0x0012 + FRONT_LEFT = 0x0400 + FRONT_RIGHT = 0x0401 + FULL_SUPPORT = 0x82B7 + FUNC_ADD = 0x8006 + FUNC_REVERSE_SUBTRACT = 0x800B + FUNC_SUBTRACT = 0x800A + GEOMETRY_INPUT_TYPE = 0x8917 + GEOMETRY_INPUT_TYPE_ARB = 0x8DDB + GEOMETRY_OUTPUT_TYPE = 0x8918 + GEOMETRY_OUTPUT_TYPE_ARB = 0x8DDC + GEOMETRY_SHADER = 0x8DD9 + GEOMETRY_SHADER_ARB = 0x8DD9 + GEOMETRY_SHADER_BIT = 0x00000004 + GEOMETRY_SHADER_INVOCATIONS = 0x887F + GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB = 0x82F3 + GEOMETRY_SUBROUTINE = 0x92EB + GEOMETRY_SUBROUTINE_UNIFORM = 0x92F1 + GEOMETRY_TEXTURE = 0x829E + GEOMETRY_VERTICES_OUT = 0x8916 + GEOMETRY_VERTICES_OUT_ARB = 0x8DDA + GEQUAL = 0x0206 + GET_TEXTURE_IMAGE_FORMAT = 0x8291 + GET_TEXTURE_IMAGE_TYPE = 0x8292 + GLYPH_HAS_KERNING_BIT_NV = 0x100 + GLYPH_HEIGHT_BIT_NV = 0x02 + GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV = 0x10 + GLYPH_HORIZONTAL_BEARING_X_BIT_NV = 0x04 + GLYPH_HORIZONTAL_BEARING_Y_BIT_NV = 0x08 + GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV = 0x80 + GLYPH_VERTICAL_BEARING_X_BIT_NV = 0x20 + GLYPH_VERTICAL_BEARING_Y_BIT_NV = 0x40 + GLYPH_WIDTH_BIT_NV = 0x01 + GPU_ADDRESS_NV = 0x8F34 + GREATER = 0x0204 + GREEN = 0x1904 + GREEN_INTEGER = 0x8D95 + GREEN_NV = 0x1904 + GUILTY_CONTEXT_RESET = 0x8253 + GUILTY_CONTEXT_RESET_ARB = 0x8253 + GUILTY_CONTEXT_RESET_KHR = 0x8253 + HALF_FLOAT = 0x140B + HARDLIGHT_KHR = 0x929B + HARDLIGHT_NV = 0x929B + HARDMIX_NV = 0x92A9 + HIGH_FLOAT = 0x8DF2 + HIGH_INT = 0x8DF5 + HORIZONTAL_LINE_TO_NV = 0x06 + HSL_COLOR_KHR = 0x92AF + HSL_COLOR_NV = 0x92AF + HSL_HUE_KHR = 0x92AD + HSL_HUE_NV = 0x92AD + HSL_LUMINOSITY_KHR = 0x92B0 + HSL_LUMINOSITY_NV = 0x92B0 + HSL_SATURATION_KHR = 0x92AE + HSL_SATURATION_NV = 0x92AE + IMAGE_1D = 0x904C + IMAGE_1D_ARRAY = 0x9052 + IMAGE_2D = 0x904D + IMAGE_2D_ARRAY = 0x9053 + IMAGE_2D_MULTISAMPLE = 0x9055 + IMAGE_2D_MULTISAMPLE_ARRAY = 0x9056 + IMAGE_2D_RECT = 0x904F + IMAGE_3D = 0x904E + IMAGE_BINDING_ACCESS = 0x8F3E + IMAGE_BINDING_FORMAT = 0x906E + IMAGE_BINDING_LAYER = 0x8F3D + IMAGE_BINDING_LAYERED = 0x8F3C + IMAGE_BINDING_LEVEL = 0x8F3B + IMAGE_BINDING_NAME = 0x8F3A + IMAGE_BUFFER = 0x9051 + IMAGE_CLASS_10_10_10_2 = 0x82C3 + IMAGE_CLASS_11_11_10 = 0x82C2 + IMAGE_CLASS_1_X_16 = 0x82BE + IMAGE_CLASS_1_X_32 = 0x82BB + IMAGE_CLASS_1_X_8 = 0x82C1 + IMAGE_CLASS_2_X_16 = 0x82BD + IMAGE_CLASS_2_X_32 = 0x82BA + IMAGE_CLASS_2_X_8 = 0x82C0 + IMAGE_CLASS_4_X_16 = 0x82BC + IMAGE_CLASS_4_X_32 = 0x82B9 + IMAGE_CLASS_4_X_8 = 0x82BF + IMAGE_COMPATIBILITY_CLASS = 0x82A8 + IMAGE_CUBE = 0x9050 + IMAGE_CUBE_MAP_ARRAY = 0x9054 + IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = 0x90C9 + IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = 0x90C8 + IMAGE_FORMAT_COMPATIBILITY_TYPE = 0x90C7 + IMAGE_PIXEL_FORMAT = 0x82A9 + IMAGE_PIXEL_TYPE = 0x82AA + IMAGE_TEXEL_SIZE = 0x82A7 + IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B + IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A + INCLUSIVE_EXT = 0x8F10 + INCR = 0x1E02 + INCR_WRAP = 0x8507 + INDEX_ARRAY_ADDRESS_NV = 0x8F24 + INDEX_ARRAY_LENGTH_NV = 0x8F2E + INFO_LOG_LENGTH = 0x8B84 + INNOCENT_CONTEXT_RESET = 0x8254 + INNOCENT_CONTEXT_RESET_ARB = 0x8254 + INNOCENT_CONTEXT_RESET_KHR = 0x8254 + INT = 0x1404 + INT16_NV = 0x8FE4 + INT16_VEC2_NV = 0x8FE5 + INT16_VEC3_NV = 0x8FE6 + INT16_VEC4_NV = 0x8FE7 + INT64_ARB = 0x140E + INT64_NV = 0x140E + INT64_VEC2_ARB = 0x8FE9 + INT64_VEC2_NV = 0x8FE9 + INT64_VEC3_ARB = 0x8FEA + INT64_VEC3_NV = 0x8FEA + INT64_VEC4_ARB = 0x8FEB + INT64_VEC4_NV = 0x8FEB + INT8_NV = 0x8FE0 + INT8_VEC2_NV = 0x8FE1 + INT8_VEC3_NV = 0x8FE2 + INT8_VEC4_NV = 0x8FE3 + INTERLEAVED_ATTRIBS = 0x8C8C + INTERNALFORMAT_ALPHA_SIZE = 0x8274 + INTERNALFORMAT_ALPHA_TYPE = 0x827B + INTERNALFORMAT_BLUE_SIZE = 0x8273 + INTERNALFORMAT_BLUE_TYPE = 0x827A + INTERNALFORMAT_DEPTH_SIZE = 0x8275 + INTERNALFORMAT_DEPTH_TYPE = 0x827C + INTERNALFORMAT_GREEN_SIZE = 0x8272 + INTERNALFORMAT_GREEN_TYPE = 0x8279 + INTERNALFORMAT_PREFERRED = 0x8270 + INTERNALFORMAT_RED_SIZE = 0x8271 + INTERNALFORMAT_RED_TYPE = 0x8278 + INTERNALFORMAT_SHARED_SIZE = 0x8277 + INTERNALFORMAT_STENCIL_SIZE = 0x8276 + INTERNALFORMAT_STENCIL_TYPE = 0x827D + INTERNALFORMAT_SUPPORTED = 0x826F + INT_2_10_10_10_REV = 0x8D9F + INT_IMAGE_1D = 0x9057 + INT_IMAGE_1D_ARRAY = 0x905D + INT_IMAGE_2D = 0x9058 + INT_IMAGE_2D_ARRAY = 0x905E + INT_IMAGE_2D_MULTISAMPLE = 0x9060 + INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9061 + INT_IMAGE_2D_RECT = 0x905A + INT_IMAGE_3D = 0x9059 + INT_IMAGE_BUFFER = 0x905C + INT_IMAGE_CUBE = 0x905B + INT_IMAGE_CUBE_MAP_ARRAY = 0x905F + INT_SAMPLER_1D = 0x8DC9 + INT_SAMPLER_1D_ARRAY = 0x8DCE + INT_SAMPLER_2D = 0x8DCA + INT_SAMPLER_2D_ARRAY = 0x8DCF + INT_SAMPLER_2D_MULTISAMPLE = 0x9109 + INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C + INT_SAMPLER_2D_RECT = 0x8DCD + INT_SAMPLER_3D = 0x8DCB + INT_SAMPLER_BUFFER = 0x8DD0 + INT_SAMPLER_CUBE = 0x8DCC + INT_SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900E + INT_VEC2 = 0x8B53 + INT_VEC3 = 0x8B54 + INT_VEC4 = 0x8B55 + INVALID_ENUM = 0x0500 + INVALID_FRAMEBUFFER_OPERATION = 0x0506 + INVALID_INDEX = 0xFFFFFFFF + INVALID_OPERATION = 0x0502 + INVALID_VALUE = 0x0501 + INVERT = 0x150A + INVERT_OVG_NV = 0x92B4 + INVERT_RGB_NV = 0x92A3 + ISOLINES = 0x8E7A + IS_PER_PATCH = 0x92E7 + IS_ROW_MAJOR = 0x9300 + ITALIC_BIT_NV = 0x02 + KEEP = 0x1E00 + LARGE_CCW_ARC_TO_NV = 0x16 + LARGE_CW_ARC_TO_NV = 0x18 + LAST_VERTEX_CONVENTION = 0x8E4E + LAYER_PROVOKING_VERTEX = 0x825E + LEFT = 0x0406 + LEQUAL = 0x0203 + LESS = 0x0201 + LIGHTEN_KHR = 0x9298 + LIGHTEN_NV = 0x9298 + LINE = 0x1B01 + LINEAR = 0x2601 + LINEARBURN_NV = 0x92A5 + LINEARDODGE_NV = 0x92A4 + LINEARLIGHT_NV = 0x92A7 + LINEAR_MIPMAP_LINEAR = 0x2703 + LINEAR_MIPMAP_NEAREST = 0x2701 + LINES = 0x0001 + LINES_ADJACENCY = 0x000A + LINES_ADJACENCY_ARB = 0x000A + LINE_LOOP = 0x0002 + LINE_SMOOTH = 0x0B20 + LINE_SMOOTH_HINT = 0x0C52 + LINE_STRIP = 0x0003 + LINE_STRIP_ADJACENCY = 0x000B + LINE_STRIP_ADJACENCY_ARB = 0x000B + LINE_TO_NV = 0x04 + LINE_WIDTH = 0x0B21 + LINE_WIDTH_COMMAND_NV = 0x000D + LINE_WIDTH_GRANULARITY = 0x0B23 + LINE_WIDTH_RANGE = 0x0B22 + LINK_STATUS = 0x8B82 + LOCATION = 0x930E + LOCATION_COMPONENT = 0x934A + LOCATION_INDEX = 0x930F + LOGIC_OP_MODE = 0x0BF0 + LOSE_CONTEXT_ON_RESET = 0x8252 + LOSE_CONTEXT_ON_RESET_ARB = 0x8252 + LOSE_CONTEXT_ON_RESET_KHR = 0x8252 + LOWER_LEFT = 0x8CA1 + LOW_FLOAT = 0x8DF0 + LOW_INT = 0x8DF3 + MAJOR_VERSION = 0x821B + MANUAL_GENERATE_MIPMAP = 0x8294 + MAP_COHERENT_BIT = 0x0080 + MAP_FLUSH_EXPLICIT_BIT = 0x0010 + MAP_INVALIDATE_BUFFER_BIT = 0x0008 + MAP_INVALIDATE_RANGE_BIT = 0x0004 + MAP_PERSISTENT_BIT = 0x0040 + MAP_READ_BIT = 0x0001 + MAP_UNSYNCHRONIZED_BIT = 0x0020 + MAP_WRITE_BIT = 0x0002 + MATRIX_STRIDE = 0x92FF + MAX = 0x8008 + MAX_3D_TEXTURE_SIZE = 0x8073 + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF + MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = 0x92DC + MAX_ATOMIC_COUNTER_BUFFER_SIZE = 0x92D8 + MAX_CLIP_DISTANCES = 0x0D32 + MAX_COARSE_FRAGMENT_SAMPLES_NV = 0x955F + MAX_COLOR_ATTACHMENTS = 0x8CDF + MAX_COLOR_FRAMEBUFFER_SAMPLES_AMD = 0x91B3 + MAX_COLOR_FRAMEBUFFER_STORAGE_SAMPLES_AMD = 0x91B4 + MAX_COLOR_TEXTURE_SAMPLES = 0x910E + MAX_COMBINED_ATOMIC_COUNTERS = 0x92D7 + MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = 0x92D1 + MAX_COMBINED_CLIP_AND_CULL_DISTANCES = 0x82FA + MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = 0x8266 + MAX_COMBINED_DIMENSIONS = 0x8282 + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33 + MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32 + MAX_COMBINED_IMAGE_UNIFORMS = 0x90CF + MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = 0x8F39 + MAX_COMBINED_MESH_UNIFORM_COMPONENTS_NV = 0x8E67 + MAX_COMBINED_SHADER_OUTPUT_RESOURCES = 0x8F39 + MAX_COMBINED_SHADER_STORAGE_BLOCKS = 0x90DC + MAX_COMBINED_TASK_UNIFORM_COMPONENTS_NV = 0x8E6F + MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E + MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D + MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31 + MAX_COMPUTE_ATOMIC_COUNTERS = 0x8265 + MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = 0x8264 + MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB = 0x90EB + MAX_COMPUTE_FIXED_GROUP_SIZE_ARB = 0x91BF + MAX_COMPUTE_IMAGE_UNIFORMS = 0x91BD + MAX_COMPUTE_SHADER_STORAGE_BLOCKS = 0x90DB + MAX_COMPUTE_SHARED_MEMORY_SIZE = 0x8262 + MAX_COMPUTE_TEXTURE_IMAGE_UNITS = 0x91BC + MAX_COMPUTE_UNIFORM_BLOCKS = 0x91BB + MAX_COMPUTE_UNIFORM_COMPONENTS = 0x8263 + MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB = 0x9344 + MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB = 0x9345 + MAX_COMPUTE_WORK_GROUP_COUNT = 0x91BE + MAX_COMPUTE_WORK_GROUP_INVOCATIONS = 0x90EB + MAX_COMPUTE_WORK_GROUP_SIZE = 0x91BF + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + MAX_CULL_DISTANCES = 0x82F9 + MAX_DEBUG_GROUP_STACK_DEPTH = 0x826C + MAX_DEBUG_GROUP_STACK_DEPTH_KHR = 0x826C + MAX_DEBUG_LOGGED_MESSAGES = 0x9144 + MAX_DEBUG_LOGGED_MESSAGES_ARB = 0x9144 + MAX_DEBUG_LOGGED_MESSAGES_KHR = 0x9144 + MAX_DEBUG_MESSAGE_LENGTH = 0x9143 + MAX_DEBUG_MESSAGE_LENGTH_ARB = 0x9143 + MAX_DEBUG_MESSAGE_LENGTH_KHR = 0x9143 + MAX_DEPTH = 0x8280 + MAX_DEPTH_STENCIL_FRAMEBUFFER_SAMPLES_AMD = 0x91B5 + MAX_DEPTH_TEXTURE_SAMPLES = 0x910F + MAX_DETACHED_BUFFERS_NV = 0x95AD + MAX_DETACHED_TEXTURES_NV = 0x95AC + MAX_DRAW_BUFFERS = 0x8824 + MAX_DRAW_MESH_TASKS_COUNT_NV = 0x953D + MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC + MAX_ELEMENTS_INDICES = 0x80E9 + MAX_ELEMENTS_VERTICES = 0x80E8 + MAX_ELEMENT_INDEX = 0x8D6B + MAX_FRAGMENT_ATOMIC_COUNTERS = 0x92D6 + MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = 0x92D0 + MAX_FRAGMENT_IMAGE_UNIFORMS = 0x90CE + MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125 + MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C + MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = 0x90DA + MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 + MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD + MAX_FRAMEBUFFER_HEIGHT = 0x9316 + MAX_FRAMEBUFFER_LAYERS = 0x9317 + MAX_FRAMEBUFFER_SAMPLES = 0x9318 + MAX_FRAMEBUFFER_WIDTH = 0x9315 + MAX_GEOMETRY_ATOMIC_COUNTERS = 0x92D5 + MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = 0x92CF + MAX_GEOMETRY_IMAGE_UNIFORMS = 0x90CD + MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123 + MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124 + MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0 + MAX_GEOMETRY_OUTPUT_VERTICES_ARB = 0x8DE0 + MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A + MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = 0x90D7 + MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29 + MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB = 0x8C29 + MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1 + MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB = 0x8DE1 + MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C + MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF + MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB = 0x8DDF + MAX_GEOMETRY_VARYING_COMPONENTS_ARB = 0x8DDD + MAX_HEIGHT = 0x827F + MAX_IMAGE_SAMPLES = 0x906D + MAX_IMAGE_UNITS = 0x8F38 + MAX_INTEGER_SAMPLES = 0x9110 + MAX_LABEL_LENGTH = 0x82E8 + MAX_LABEL_LENGTH_KHR = 0x82E8 + MAX_LAYERS = 0x8281 + MAX_MESH_ATOMIC_COUNTERS_NV = 0x8E65 + MAX_MESH_ATOMIC_COUNTER_BUFFERS_NV = 0x8E64 + MAX_MESH_IMAGE_UNIFORMS_NV = 0x8E62 + MAX_MESH_OUTPUT_PRIMITIVES_NV = 0x9539 + MAX_MESH_OUTPUT_VERTICES_NV = 0x9538 + MAX_MESH_SHADER_STORAGE_BLOCKS_NV = 0x8E66 + MAX_MESH_TEXTURE_IMAGE_UNITS_NV = 0x8E61 + MAX_MESH_TOTAL_MEMORY_SIZE_NV = 0x9536 + MAX_MESH_UNIFORM_BLOCKS_NV = 0x8E60 + MAX_MESH_UNIFORM_COMPONENTS_NV = 0x8E63 + MAX_MESH_VIEWS_NV = 0x9557 + MAX_MESH_WORK_GROUP_INVOCATIONS_NV = 0x95A2 + MAX_MESH_WORK_GROUP_SIZE_NV = 0x953B + MAX_MULTISAMPLE_COVERAGE_MODES_NV = 0x8E11 + MAX_NAME_LENGTH = 0x92F6 + MAX_NUM_ACTIVE_VARIABLES = 0x92F7 + MAX_NUM_COMPATIBLE_SUBROUTINES = 0x92F8 + MAX_PATCH_VERTICES = 0x8E7D + MAX_PROGRAM_TEXEL_OFFSET = 0x8905 + MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB = 0x8F9F + MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = 0x8E5F + MAX_RASTER_SAMPLES_EXT = 0x9329 + MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8 + MAX_RENDERBUFFER_SIZE = 0x84E8 + MAX_SAMPLES = 0x8D57 + MAX_SAMPLE_MASK_WORDS = 0x8E59 + MAX_SERVER_WAIT_TIMEOUT = 0x9111 + MAX_SHADER_BUFFER_ADDRESS_NV = 0x8F35 + MAX_SHADER_COMPILER_THREADS_ARB = 0x91B0 + MAX_SHADER_COMPILER_THREADS_KHR = 0x91B0 + MAX_SHADER_STORAGE_BLOCK_SIZE = 0x90DE + MAX_SHADER_STORAGE_BUFFER_BINDINGS = 0x90DD + MAX_SPARSE_3D_TEXTURE_SIZE_ARB = 0x9199 + MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB = 0x919A + MAX_SPARSE_TEXTURE_SIZE_ARB = 0x9198 + MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV = 0x9349 + MAX_SUBROUTINES = 0x8DE7 + MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8 + MAX_TASK_ATOMIC_COUNTERS_NV = 0x8E6D + MAX_TASK_ATOMIC_COUNTER_BUFFERS_NV = 0x8E6C + MAX_TASK_IMAGE_UNIFORMS_NV = 0x8E6A + MAX_TASK_OUTPUT_COUNT_NV = 0x953A + MAX_TASK_SHADER_STORAGE_BLOCKS_NV = 0x8E6E + MAX_TASK_TEXTURE_IMAGE_UNITS_NV = 0x8E69 + MAX_TASK_TOTAL_MEMORY_SIZE_NV = 0x9537 + MAX_TASK_UNIFORM_BLOCKS_NV = 0x8E68 + MAX_TASK_UNIFORM_COMPONENTS_NV = 0x8E6B + MAX_TASK_WORK_GROUP_INVOCATIONS_NV = 0x95A3 + MAX_TASK_WORK_GROUP_SIZE_NV = 0x953C + MAX_TESS_CONTROL_ATOMIC_COUNTERS = 0x92D3 + MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = 0x92CD + MAX_TESS_CONTROL_IMAGE_UNIFORMS = 0x90CB + MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C + MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83 + MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = 0x90D8 + MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81 + MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85 + MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89 + MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F + MAX_TESS_EVALUATION_ATOMIC_COUNTERS = 0x92D4 + MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = 0x92CE + MAX_TESS_EVALUATION_IMAGE_UNIFORMS = 0x90CC + MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D + MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86 + MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = 0x90D9 + MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82 + MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A + MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80 + MAX_TESS_GEN_LEVEL = 0x8E7E + MAX_TESS_PATCH_COMPONENTS = 0x8E84 + MAX_TEXTURE_BUFFER_SIZE = 0x8C2B + MAX_TEXTURE_BUFFER_SIZE_ARB = 0x8C2B + MAX_TEXTURE_IMAGE_UNITS = 0x8872 + MAX_TEXTURE_LOD_BIAS = 0x84FD + MAX_TEXTURE_MAX_ANISOTROPY = 0x84FF + MAX_TEXTURE_SIZE = 0x0D33 + MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70 + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80 + MAX_UNIFORM_BLOCK_SIZE = 0x8A30 + MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F + MAX_UNIFORM_LOCATIONS = 0x826E + MAX_VARYING_COMPONENTS = 0x8B4B + MAX_VARYING_FLOATS = 0x8B4B + MAX_VARYING_VECTORS = 0x8DFC + MAX_VERTEX_ATOMIC_COUNTERS = 0x92D2 + MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = 0x92CC + MAX_VERTEX_ATTRIBS = 0x8869 + MAX_VERTEX_ATTRIB_BINDINGS = 0x82DA + MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D9 + MAX_VERTEX_IMAGE_UNIFORMS = 0x90CA + MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122 + MAX_VERTEX_SHADER_STORAGE_BLOCKS = 0x90D6 + MAX_VERTEX_STREAMS = 0x8E71 + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C + MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A + MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB + MAX_VERTEX_VARYING_COMPONENTS_ARB = 0x8DDE + MAX_VIEWPORTS = 0x825B + MAX_VIEWPORT_DIMS = 0x0D3A + MAX_VIEWS_OVR = 0x9631 + MAX_WIDTH = 0x827E + MAX_WINDOW_RECTANGLES_EXT = 0x8F14 + MEDIUM_FLOAT = 0x8DF1 + MEDIUM_INT = 0x8DF4 + MEMORY_ATTACHABLE_ALIGNMENT_NV = 0x95A6 + MEMORY_ATTACHABLE_NV = 0x95A8 + MEMORY_ATTACHABLE_SIZE_NV = 0x95A7 + MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_NV = 0x9543 + MESH_OUTPUT_PER_VERTEX_GRANULARITY_NV = 0x92DF + MESH_OUTPUT_TYPE_NV = 0x957B + MESH_PRIMITIVES_OUT_NV = 0x957A + MESH_SHADER_BIT_NV = 0x00000040 + MESH_SHADER_NV = 0x9559 + MESH_SUBROUTINE_NV = 0x957C + MESH_SUBROUTINE_UNIFORM_NV = 0x957E + MESH_VERTICES_OUT_NV = 0x9579 + MESH_WORK_GROUP_SIZE_NV = 0x953E + MIN = 0x8007 + MINOR_VERSION = 0x821C + MINUS_CLAMPED_NV = 0x92B3 + MINUS_NV = 0x929F + MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B + MIN_MAP_BUFFER_ALIGNMENT = 0x90BC + MIN_PROGRAM_TEXEL_OFFSET = 0x8904 + MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = 0x8E5E + MIN_SAMPLE_SHADING_VALUE_ARB = 0x8C37 + MIPMAP = 0x8293 + MIRRORED_REPEAT = 0x8370 + MIRRORED_REPEAT_ARB = 0x8370 + MIRROR_CLAMP_TO_EDGE = 0x8743 + MITER_REVERT_NV = 0x90A7 + MITER_TRUNCATE_NV = 0x90A8 + MIXED_DEPTH_SAMPLES_SUPPORTED_NV = 0x932F + MIXED_STENCIL_SAMPLES_SUPPORTED_NV = 0x9330 + MOVE_TO_CONTINUES_NV = 0x90B6 + MOVE_TO_NV = 0x02 + MOVE_TO_RESETS_NV = 0x90B5 + MULTIPLY_KHR = 0x9294 + MULTIPLY_NV = 0x9294 + MULTISAMPLE = 0x809D + MULTISAMPLES_NV = 0x9371 + MULTISAMPLE_COVERAGE_MODES_NV = 0x8E12 + MULTISAMPLE_LINE_WIDTH_GRANULARITY_ARB = 0x9382 + MULTISAMPLE_LINE_WIDTH_RANGE_ARB = 0x9381 + MULTISAMPLE_RASTERIZATION_ALLOWED_EXT = 0x932B + NAMED_STRING_LENGTH_ARB = 0x8DE9 + NAMED_STRING_TYPE_ARB = 0x8DEA + NAME_LENGTH = 0x92F9 + NAND = 0x150E + NEAREST = 0x2600 + NEAREST_MIPMAP_LINEAR = 0x2702 + NEAREST_MIPMAP_NEAREST = 0x2700 + NEGATIVE_ONE_TO_ONE = 0x935E + NEVER = 0x0200 + NICEST = 0x1102 + NONE = 0 + NOOP = 0x1505 + NOP_COMMAND_NV = 0x0001 + NOR = 0x1508 + NORMAL_ARRAY_ADDRESS_NV = 0x8F22 + NORMAL_ARRAY_LENGTH_NV = 0x8F2C + NOTEQUAL = 0x0205 + NO_ERROR = 0 + NO_RESET_NOTIFICATION = 0x8261 + NO_RESET_NOTIFICATION_ARB = 0x8261 + NO_RESET_NOTIFICATION_KHR = 0x8261 + NUM_ACTIVE_VARIABLES = 0x9304 + NUM_COMPATIBLE_SUBROUTINES = 0x8E4A + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + NUM_EXTENSIONS = 0x821D + NUM_PROGRAM_BINARY_FORMATS = 0x87FE + NUM_SAMPLE_COUNTS = 0x9380 + NUM_SHADER_BINARY_FORMATS = 0x8DF9 + NUM_SPARSE_LEVELS_ARB = 0x91AA + NUM_SPIR_V_EXTENSIONS = 0x9554 + NUM_SUPPORTED_MULTISAMPLE_MODES_AMD = 0x91B6 + NUM_VIRTUAL_PAGE_SIZES_ARB = 0x91A8 + NUM_WINDOW_RECTANGLES_EXT = 0x8F15 + OBJECT_TYPE = 0x9112 + OFFSET = 0x92FC + ONE = 1 + ONE_MINUS_CONSTANT_ALPHA = 0x8004 + ONE_MINUS_CONSTANT_COLOR = 0x8002 + ONE_MINUS_DST_ALPHA = 0x0305 + ONE_MINUS_DST_COLOR = 0x0307 + ONE_MINUS_SRC1_ALPHA = 0x88FB + ONE_MINUS_SRC1_COLOR = 0x88FA + ONE_MINUS_SRC_ALPHA = 0x0303 + ONE_MINUS_SRC_COLOR = 0x0301 + OR = 0x1507 + OR_INVERTED = 0x150D + OR_REVERSE = 0x150B + OUT_OF_MEMORY = 0x0505 + OVERLAY_KHR = 0x9296 + OVERLAY_NV = 0x9296 + PACK_ALIGNMENT = 0x0D05 + PACK_COMPRESSED_BLOCK_DEPTH = 0x912D + PACK_COMPRESSED_BLOCK_HEIGHT = 0x912C + PACK_COMPRESSED_BLOCK_SIZE = 0x912E + PACK_COMPRESSED_BLOCK_WIDTH = 0x912B + PACK_IMAGE_HEIGHT = 0x806C + PACK_LSB_FIRST = 0x0D01 + PACK_ROW_LENGTH = 0x0D02 + PACK_SKIP_IMAGES = 0x806B + PACK_SKIP_PIXELS = 0x0D04 + PACK_SKIP_ROWS = 0x0D03 + PACK_SWAP_BYTES = 0x0D00 + PARAMETER_BUFFER_ARB = 0x80EE + PARAMETER_BUFFER_BINDING_ARB = 0x80EF + PATCHES = 0x000E + PATCH_DEFAULT_INNER_LEVEL = 0x8E73 + PATCH_DEFAULT_OUTER_LEVEL = 0x8E74 + PATCH_VERTICES = 0x8E72 + PATH_CLIENT_LENGTH_NV = 0x907F + PATH_COMMAND_COUNT_NV = 0x909D + PATH_COMPUTED_LENGTH_NV = 0x90A0 + PATH_COORD_COUNT_NV = 0x909E + PATH_COVER_DEPTH_FUNC_NV = 0x90BF + PATH_DASH_ARRAY_COUNT_NV = 0x909F + PATH_DASH_CAPS_NV = 0x907B + PATH_DASH_OFFSET_NV = 0x907E + PATH_DASH_OFFSET_RESET_NV = 0x90B4 + PATH_END_CAPS_NV = 0x9076 + PATH_ERROR_POSITION_NV = 0x90AB + PATH_FILL_BOUNDING_BOX_NV = 0x90A1 + PATH_FILL_COVER_MODE_NV = 0x9082 + PATH_FILL_MASK_NV = 0x9081 + PATH_FILL_MODE_NV = 0x9080 + PATH_FORMAT_PS_NV = 0x9071 + PATH_FORMAT_SVG_NV = 0x9070 + PATH_GEN_COEFF_NV = 0x90B1 + PATH_GEN_COMPONENTS_NV = 0x90B3 + PATH_GEN_MODE_NV = 0x90B0 + PATH_INITIAL_DASH_CAP_NV = 0x907C + PATH_INITIAL_END_CAP_NV = 0x9077 + PATH_JOIN_STYLE_NV = 0x9079 + PATH_MAX_MODELVIEW_STACK_DEPTH_NV = 0x0D36 + PATH_MAX_PROJECTION_STACK_DEPTH_NV = 0x0D38 + PATH_MITER_LIMIT_NV = 0x907A + PATH_MODELVIEW_MATRIX_NV = 0x0BA6 + PATH_MODELVIEW_NV = 0x1700 + PATH_MODELVIEW_STACK_DEPTH_NV = 0x0BA3 + PATH_OBJECT_BOUNDING_BOX_NV = 0x908A + PATH_PROJECTION_MATRIX_NV = 0x0BA7 + PATH_PROJECTION_NV = 0x1701 + PATH_PROJECTION_STACK_DEPTH_NV = 0x0BA4 + PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV = 0x90BD + PATH_STENCIL_DEPTH_OFFSET_UNITS_NV = 0x90BE + PATH_STENCIL_FUNC_NV = 0x90B7 + PATH_STENCIL_REF_NV = 0x90B8 + PATH_STENCIL_VALUE_MASK_NV = 0x90B9 + PATH_STROKE_BOUNDING_BOX_NV = 0x90A2 + PATH_STROKE_COVER_MODE_NV = 0x9083 + PATH_STROKE_MASK_NV = 0x9084 + PATH_STROKE_WIDTH_NV = 0x9075 + PATH_TERMINAL_DASH_CAP_NV = 0x907D + PATH_TERMINAL_END_CAP_NV = 0x9078 + PATH_TRANSPOSE_MODELVIEW_MATRIX_NV = 0x84E3 + PATH_TRANSPOSE_PROJECTION_MATRIX_NV = 0x84E4 + PERCENTAGE_AMD = 0x8BC3 + PERFMON_RESULT_AMD = 0x8BC6 + PERFMON_RESULT_AVAILABLE_AMD = 0x8BC4 + PERFMON_RESULT_SIZE_AMD = 0x8BC5 + PERFQUERY_COUNTER_DATA_BOOL32_INTEL = 0x94FC + PERFQUERY_COUNTER_DATA_DOUBLE_INTEL = 0x94FB + PERFQUERY_COUNTER_DATA_FLOAT_INTEL = 0x94FA + PERFQUERY_COUNTER_DATA_UINT32_INTEL = 0x94F8 + PERFQUERY_COUNTER_DATA_UINT64_INTEL = 0x94F9 + PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL = 0x94FF + PERFQUERY_COUNTER_DURATION_NORM_INTEL = 0x94F1 + PERFQUERY_COUNTER_DURATION_RAW_INTEL = 0x94F2 + PERFQUERY_COUNTER_EVENT_INTEL = 0x94F0 + PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL = 0x94FE + PERFQUERY_COUNTER_RAW_INTEL = 0x94F4 + PERFQUERY_COUNTER_THROUGHPUT_INTEL = 0x94F3 + PERFQUERY_COUNTER_TIMESTAMP_INTEL = 0x94F5 + PERFQUERY_DONOT_FLUSH_INTEL = 0x83F9 + PERFQUERY_FLUSH_INTEL = 0x83FA + PERFQUERY_GLOBAL_CONTEXT_INTEL = 0x00000001 + PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL = 0x9500 + PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL = 0x94FD + PERFQUERY_SINGLE_CONTEXT_INTEL = 0x00000000 + PERFQUERY_WAIT_INTEL = 0x83FB + PINLIGHT_NV = 0x92A8 + PIXEL_BUFFER_BARRIER_BIT = 0x00000080 + PIXEL_PACK_BUFFER = 0x88EB + PIXEL_PACK_BUFFER_ARB = 0x88EB + PIXEL_PACK_BUFFER_BINDING = 0x88ED + PIXEL_PACK_BUFFER_BINDING_ARB = 0x88ED + PIXEL_UNPACK_BUFFER = 0x88EC + PIXEL_UNPACK_BUFFER_ARB = 0x88EC + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF + PIXEL_UNPACK_BUFFER_BINDING_ARB = 0x88EF + PLUS_CLAMPED_ALPHA_NV = 0x92B2 + PLUS_CLAMPED_NV = 0x92B1 + PLUS_DARKER_NV = 0x9292 + PLUS_NV = 0x9291 + POINT = 0x1B00 + POINTS = 0x0000 + POINT_FADE_THRESHOLD_SIZE = 0x8128 + POINT_SIZE = 0x0B11 + POINT_SIZE_GRANULARITY = 0x0B13 + POINT_SIZE_RANGE = 0x0B12 + POINT_SPRITE_COORD_ORIGIN = 0x8CA0 + POLYGON_MODE = 0x0B40 + POLYGON_OFFSET_CLAMP = 0x8E1B + POLYGON_OFFSET_CLAMP_EXT = 0x8E1B + POLYGON_OFFSET_COMMAND_NV = 0x000E + POLYGON_OFFSET_FACTOR = 0x8038 + POLYGON_OFFSET_FILL = 0x8037 + POLYGON_OFFSET_LINE = 0x2A02 + POLYGON_OFFSET_POINT = 0x2A01 + POLYGON_OFFSET_UNITS = 0x2A00 + POLYGON_SMOOTH = 0x0B41 + POLYGON_SMOOTH_HINT = 0x0C53 + PRIMITIVES_GENERATED = 0x8C87 + PRIMITIVES_SUBMITTED_ARB = 0x82EF + PRIMITIVE_BOUNDING_BOX_ARB = 0x92BE + PRIMITIVE_RESTART = 0x8F9D + PRIMITIVE_RESTART_FIXED_INDEX = 0x8D69 + PRIMITIVE_RESTART_INDEX = 0x8F9E + PROGRAM = 0x82E2 + PROGRAMMABLE_SAMPLE_LOCATION_ARB = 0x9341 + PROGRAMMABLE_SAMPLE_LOCATION_NV = 0x9341 + PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB = 0x9340 + PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_NV = 0x9340 + PROGRAM_BINARY_FORMATS = 0x87FF + PROGRAM_BINARY_LENGTH = 0x8741 + PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257 + PROGRAM_INPUT = 0x92E3 + PROGRAM_KHR = 0x82E2 + PROGRAM_MATRIX_EXT = 0x8E2D + PROGRAM_MATRIX_STACK_DEPTH_EXT = 0x8E2F + PROGRAM_OBJECT_EXT = 0x8B40 + PROGRAM_OUTPUT = 0x92E4 + PROGRAM_PIPELINE = 0x82E4 + PROGRAM_PIPELINE_BINDING = 0x825A + PROGRAM_PIPELINE_BINDING_EXT = 0x825A + PROGRAM_PIPELINE_KHR = 0x82E4 + PROGRAM_PIPELINE_OBJECT_EXT = 0x8A4F + PROGRAM_POINT_SIZE = 0x8642 + PROGRAM_POINT_SIZE_ARB = 0x8642 + PROGRAM_SEPARABLE = 0x8258 + PROGRAM_SEPARABLE_EXT = 0x8258 + PROVOKING_VERTEX = 0x8E4F + PROXY_TEXTURE_1D = 0x8063 + PROXY_TEXTURE_1D_ARRAY = 0x8C19 + PROXY_TEXTURE_2D = 0x8064 + PROXY_TEXTURE_2D_ARRAY = 0x8C1B + PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101 + PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103 + PROXY_TEXTURE_3D = 0x8070 + PROXY_TEXTURE_CUBE_MAP = 0x851B + PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB = 0x900B + PROXY_TEXTURE_RECTANGLE = 0x84F7 + QUADRATIC_CURVE_TO_NV = 0x0A + QUADS = 0x0007 + QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C + QUERY = 0x82E3 + QUERY_BUFFER = 0x9192 + QUERY_BUFFER_BARRIER_BIT = 0x00008000 + QUERY_BUFFER_BINDING = 0x9193 + QUERY_BY_REGION_NO_WAIT = 0x8E16 + QUERY_BY_REGION_NO_WAIT_INVERTED = 0x8E1A + QUERY_BY_REGION_NO_WAIT_NV = 0x8E16 + QUERY_BY_REGION_WAIT = 0x8E15 + QUERY_BY_REGION_WAIT_INVERTED = 0x8E19 + QUERY_BY_REGION_WAIT_NV = 0x8E15 + QUERY_COUNTER_BITS = 0x8864 + QUERY_KHR = 0x82E3 + QUERY_NO_WAIT = 0x8E14 + QUERY_NO_WAIT_INVERTED = 0x8E18 + QUERY_NO_WAIT_NV = 0x8E14 + QUERY_OBJECT_EXT = 0x9153 + QUERY_RESULT = 0x8866 + QUERY_RESULT_AVAILABLE = 0x8867 + QUERY_RESULT_NO_WAIT = 0x9194 + QUERY_TARGET = 0x82EA + QUERY_WAIT = 0x8E13 + QUERY_WAIT_INVERTED = 0x8E17 + QUERY_WAIT_NV = 0x8E13 + R11F_G11F_B10F = 0x8C3A + R16 = 0x822A + R16F = 0x822D + R16I = 0x8233 + R16UI = 0x8234 + R16_SNORM = 0x8F98 + R32F = 0x822E + R32I = 0x8235 + R32UI = 0x8236 + R3_G3_B2 = 0x2A10 + R8 = 0x8229 + R8I = 0x8231 + R8UI = 0x8232 + R8_SNORM = 0x8F94 + RASTERIZER_DISCARD = 0x8C89 + RASTER_FIXED_SAMPLE_LOCATIONS_EXT = 0x932A + RASTER_MULTISAMPLE_EXT = 0x9327 + RASTER_SAMPLES_EXT = 0x9328 + READ_BUFFER = 0x0C02 + READ_FRAMEBUFFER = 0x8CA8 + READ_FRAMEBUFFER_BINDING = 0x8CAA + READ_ONLY = 0x88B8 + READ_PIXELS = 0x828C + READ_PIXELS_FORMAT = 0x828D + READ_PIXELS_TYPE = 0x828E + READ_WRITE = 0x88BA + RECT_NV = 0xF6 + RED = 0x1903 + RED_INTEGER = 0x8D94 + RED_NV = 0x1903 + REFERENCED_BY_COMPUTE_SHADER = 0x930B + REFERENCED_BY_FRAGMENT_SHADER = 0x930A + REFERENCED_BY_GEOMETRY_SHADER = 0x9309 + REFERENCED_BY_MESH_SHADER_NV = 0x95A0 + REFERENCED_BY_TASK_SHADER_NV = 0x95A1 + REFERENCED_BY_TESS_CONTROL_SHADER = 0x9307 + REFERENCED_BY_TESS_EVALUATION_SHADER = 0x9308 + REFERENCED_BY_VERTEX_SHADER = 0x9306 + RELATIVE_ARC_TO_NV = 0xFF + RELATIVE_CONIC_CURVE_TO_NV = 0x1B + RELATIVE_CUBIC_CURVE_TO_NV = 0x0D + RELATIVE_HORIZONTAL_LINE_TO_NV = 0x07 + RELATIVE_LARGE_CCW_ARC_TO_NV = 0x17 + RELATIVE_LARGE_CW_ARC_TO_NV = 0x19 + RELATIVE_LINE_TO_NV = 0x05 + RELATIVE_MOVE_TO_NV = 0x03 + RELATIVE_QUADRATIC_CURVE_TO_NV = 0x0B + RELATIVE_RECT_NV = 0xF7 + RELATIVE_ROUNDED_RECT2_NV = 0xEB + RELATIVE_ROUNDED_RECT4_NV = 0xED + RELATIVE_ROUNDED_RECT8_NV = 0xEF + RELATIVE_ROUNDED_RECT_NV = 0xE9 + RELATIVE_SMALL_CCW_ARC_TO_NV = 0x13 + RELATIVE_SMALL_CW_ARC_TO_NV = 0x15 + RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV = 0x11 + RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV = 0x0F + RELATIVE_VERTICAL_LINE_TO_NV = 0x09 + RENDERBUFFER = 0x8D41 + RENDERBUFFER_ALPHA_SIZE = 0x8D53 + RENDERBUFFER_BINDING = 0x8CA7 + RENDERBUFFER_BLUE_SIZE = 0x8D52 + RENDERBUFFER_COLOR_SAMPLES_NV = 0x8E10 + RENDERBUFFER_COVERAGE_SAMPLES_NV = 0x8CAB + RENDERBUFFER_DEPTH_SIZE = 0x8D54 + RENDERBUFFER_GREEN_SIZE = 0x8D51 + RENDERBUFFER_HEIGHT = 0x8D43 + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44 + RENDERBUFFER_RED_SIZE = 0x8D50 + RENDERBUFFER_SAMPLES = 0x8CAB + RENDERBUFFER_STENCIL_SIZE = 0x8D55 + RENDERBUFFER_STORAGE_SAMPLES_AMD = 0x91B2 + RENDERBUFFER_WIDTH = 0x8D42 + RENDERER = 0x1F01 + REPEAT = 0x2901 + REPLACE = 0x1E01 + REPRESENTATIVE_FRAGMENT_TEST_NV = 0x937F + RESET_NOTIFICATION_STRATEGY = 0x8256 + RESET_NOTIFICATION_STRATEGY_ARB = 0x8256 + RESET_NOTIFICATION_STRATEGY_KHR = 0x8256 + RESTART_PATH_NV = 0xF0 + RG = 0x8227 + RG16 = 0x822C + RG16F = 0x822F + RG16I = 0x8239 + RG16UI = 0x823A + RG16_SNORM = 0x8F99 + RG32F = 0x8230 + RG32I = 0x823B + RG32UI = 0x823C + RG8 = 0x822B + RG8I = 0x8237 + RG8UI = 0x8238 + RG8_SNORM = 0x8F95 + RGB = 0x1907 + RGB10 = 0x8052 + RGB10_A2 = 0x8059 + RGB10_A2UI = 0x906F + RGB12 = 0x8053 + RGB16 = 0x8054 + RGB16F = 0x881B + RGB16I = 0x8D89 + RGB16UI = 0x8D77 + RGB16_SNORM = 0x8F9A + RGB32F = 0x8815 + RGB32I = 0x8D83 + RGB32UI = 0x8D71 + RGB4 = 0x804F + RGB5 = 0x8050 + RGB565 = 0x8D62 + RGB5_A1 = 0x8057 + RGB8 = 0x8051 + RGB8I = 0x8D8F + RGB8UI = 0x8D7D + RGB8_SNORM = 0x8F96 + RGB9_E5 = 0x8C3D + RGBA = 0x1908 + RGBA12 = 0x805A + RGBA16 = 0x805B + RGBA16F = 0x881A + RGBA16I = 0x8D88 + RGBA16UI = 0x8D76 + RGBA16_SNORM = 0x8F9B + RGBA2 = 0x8055 + RGBA32F = 0x8814 + RGBA32I = 0x8D82 + RGBA32UI = 0x8D70 + RGBA4 = 0x8056 + RGBA8 = 0x8058 + RGBA8I = 0x8D8E + RGBA8UI = 0x8D7C + RGBA8_SNORM = 0x8F97 + RGBA_INTEGER = 0x8D99 + RGB_422_APPLE = 0x8A1F + RGB_INTEGER = 0x8D98 + RGB_RAW_422_APPLE = 0x8A51 + RG_INTEGER = 0x8228 + RIGHT = 0x0407 + ROUNDED_RECT2_NV = 0xEA + ROUNDED_RECT4_NV = 0xEC + ROUNDED_RECT8_NV = 0xEE + ROUNDED_RECT_NV = 0xE8 + ROUND_NV = 0x90A4 + SAMPLER = 0x82E6 + SAMPLER_1D = 0x8B5D + SAMPLER_1D_ARRAY = 0x8DC0 + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3 + SAMPLER_1D_SHADOW = 0x8B61 + SAMPLER_2D = 0x8B5E + SAMPLER_2D_ARRAY = 0x8DC1 + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4 + SAMPLER_2D_MULTISAMPLE = 0x9108 + SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B + SAMPLER_2D_RECT = 0x8B63 + SAMPLER_2D_RECT_SHADOW = 0x8B64 + SAMPLER_2D_SHADOW = 0x8B62 + SAMPLER_3D = 0x8B5F + SAMPLER_BINDING = 0x8919 + SAMPLER_BUFFER = 0x8DC2 + SAMPLER_CUBE = 0x8B60 + SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900C + SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB = 0x900D + SAMPLER_CUBE_SHADOW = 0x8DC5 + SAMPLER_KHR = 0x82E6 + SAMPLES = 0x80A9 + SAMPLES_PASSED = 0x8914 + SAMPLE_ALPHA_TO_COVERAGE = 0x809E + SAMPLE_ALPHA_TO_ONE = 0x809F + SAMPLE_BUFFERS = 0x80A8 + SAMPLE_COVERAGE = 0x80A0 + SAMPLE_COVERAGE_INVERT = 0x80AB + SAMPLE_COVERAGE_VALUE = 0x80AA + SAMPLE_LOCATION_ARB = 0x8E50 + SAMPLE_LOCATION_NV = 0x8E50 + SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB = 0x933F + SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_NV = 0x933F + SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB = 0x933E + SAMPLE_LOCATION_PIXEL_GRID_WIDTH_NV = 0x933E + SAMPLE_LOCATION_SUBPIXEL_BITS_ARB = 0x933D + SAMPLE_LOCATION_SUBPIXEL_BITS_NV = 0x933D + SAMPLE_MASK = 0x8E51 + SAMPLE_MASK_VALUE = 0x8E52 + SAMPLE_POSITION = 0x8E50 + SAMPLE_SHADING_ARB = 0x8C36 + SCISSOR_BOX = 0x0C10 + SCISSOR_BOX_EXCLUSIVE_NV = 0x9556 + SCISSOR_COMMAND_NV = 0x0011 + SCISSOR_TEST = 0x0C11 + SCISSOR_TEST_EXCLUSIVE_NV = 0x9555 + SCREEN_KHR = 0x9295 + SCREEN_NV = 0x9295 + SECONDARY_COLOR_ARRAY_ADDRESS_NV = 0x8F27 + SECONDARY_COLOR_ARRAY_LENGTH_NV = 0x8F31 + SEPARATE_ATTRIBS = 0x8C8D + SET = 0x150F + SHADER = 0x82E1 + SHADER_BINARY_FORMATS = 0x8DF8 + SHADER_BINARY_FORMAT_SPIR_V_ARB = 0x9551 + SHADER_COMPILER = 0x8DFA + SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV = 0x00000010 + SHADER_IMAGE_ACCESS_BARRIER_BIT = 0x00000020 + SHADER_IMAGE_ATOMIC = 0x82A6 + SHADER_IMAGE_LOAD = 0x82A4 + SHADER_IMAGE_STORE = 0x82A5 + SHADER_INCLUDE_ARB = 0x8DAE + SHADER_KHR = 0x82E1 + SHADER_OBJECT_EXT = 0x8B48 + SHADER_SOURCE_LENGTH = 0x8B88 + SHADER_STORAGE_BARRIER_BIT = 0x00002000 + SHADER_STORAGE_BLOCK = 0x92E6 + SHADER_STORAGE_BUFFER = 0x90D2 + SHADER_STORAGE_BUFFER_BINDING = 0x90D3 + SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = 0x90DF + SHADER_STORAGE_BUFFER_SIZE = 0x90D5 + SHADER_STORAGE_BUFFER_START = 0x90D4 + SHADER_TYPE = 0x8B4F + SHADING_LANGUAGE_VERSION = 0x8B8C + SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = 0x956F + SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = 0x9566 + SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = 0x9567 + SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = 0x9568 + SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = 0x9569 + SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = 0x956A + SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = 0x956B + SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = 0x9565 + SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = 0x956C + SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = 0x956D + SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = 0x956E + SHADING_RATE_IMAGE_BINDING_NV = 0x955B + SHADING_RATE_IMAGE_NV = 0x9563 + SHADING_RATE_IMAGE_PALETTE_COUNT_NV = 0x95B2 + SHADING_RATE_IMAGE_PALETTE_SIZE_NV = 0x955E + SHADING_RATE_IMAGE_PER_PRIMITIVE_NV = 0x95B1 + SHADING_RATE_IMAGE_TEXEL_HEIGHT_NV = 0x955D + SHADING_RATE_IMAGE_TEXEL_WIDTH_NV = 0x955C + SHADING_RATE_NO_INVOCATIONS_NV = 0x9564 + SHADING_RATE_SAMPLE_ORDER_DEFAULT_NV = 0x95AE + SHADING_RATE_SAMPLE_ORDER_PIXEL_MAJOR_NV = 0x95AF + SHADING_RATE_SAMPLE_ORDER_SAMPLE_MAJOR_NV = 0x95B0 + SHARED_EDGE_NV = 0xC0 + SHORT = 0x1402 + SIGNALED = 0x9119 + SIGNED_NORMALIZED = 0x8F9C + SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = 0x82AC + SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = 0x82AE + SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = 0x82AD + SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = 0x82AF + SKIP_DECODE_EXT = 0x8A4A + SKIP_MISSING_GLYPH_NV = 0x90A9 + SMALL_CCW_ARC_TO_NV = 0x12 + SMALL_CW_ARC_TO_NV = 0x14 + SMOOTH_CUBIC_CURVE_TO_NV = 0x10 + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + SMOOTH_POINT_SIZE_RANGE = 0x0B12 + SMOOTH_QUADRATIC_CURVE_TO_NV = 0x0E + SM_COUNT_NV = 0x933B + SOFTLIGHT_KHR = 0x929C + SOFTLIGHT_NV = 0x929C + SPARSE_BUFFER_PAGE_SIZE_ARB = 0x82F8 + SPARSE_STORAGE_BIT_ARB = 0x0400 + SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB = 0x91A9 + SPIR_V_BINARY_ARB = 0x9552 + SPIR_V_EXTENSIONS = 0x9553 + SQUARE_NV = 0x90A3 + SR8_EXT = 0x8FBD + SRC1_ALPHA = 0x8589 + SRC1_COLOR = 0x88F9 + SRC_ALPHA = 0x0302 + SRC_ALPHA_SATURATE = 0x0308 + SRC_ATOP_NV = 0x928E + SRC_COLOR = 0x0300 + SRC_IN_NV = 0x928A + SRC_NV = 0x9286 + SRC_OUT_NV = 0x928C + SRC_OVER_NV = 0x9288 + SRG8_EXT = 0x8FBE + SRGB = 0x8C40 + SRGB8 = 0x8C41 + SRGB8_ALPHA8 = 0x8C43 + SRGB_ALPHA = 0x8C42 + SRGB_DECODE_ARB = 0x8299 + SRGB_READ = 0x8297 + SRGB_WRITE = 0x8298 + STACK_OVERFLOW = 0x0503 + STACK_OVERFLOW_KHR = 0x0503 + STACK_UNDERFLOW = 0x0504 + STACK_UNDERFLOW_KHR = 0x0504 + STANDARD_FONT_FORMAT_NV = 0x936C + STANDARD_FONT_NAME_NV = 0x9072 + STATIC_COPY = 0x88E6 + STATIC_DRAW = 0x88E4 + STATIC_READ = 0x88E5 + STENCIL = 0x1802 + STENCIL_ATTACHMENT = 0x8D20 + STENCIL_BACK_FAIL = 0x8801 + STENCIL_BACK_FUNC = 0x8800 + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 + STENCIL_BACK_REF = 0x8CA3 + STENCIL_BACK_VALUE_MASK = 0x8CA4 + STENCIL_BACK_WRITEMASK = 0x8CA5 + STENCIL_BUFFER_BIT = 0x00000400 + STENCIL_CLEAR_VALUE = 0x0B91 + STENCIL_COMPONENTS = 0x8285 + STENCIL_FAIL = 0x0B94 + STENCIL_FUNC = 0x0B92 + STENCIL_INDEX = 0x1901 + STENCIL_INDEX1 = 0x8D46 + STENCIL_INDEX16 = 0x8D49 + STENCIL_INDEX4 = 0x8D47 + STENCIL_INDEX8 = 0x8D48 + STENCIL_PASS_DEPTH_FAIL = 0x0B95 + STENCIL_PASS_DEPTH_PASS = 0x0B96 + STENCIL_REF = 0x0B97 + STENCIL_REF_COMMAND_NV = 0x000C + STENCIL_RENDERABLE = 0x8288 + STENCIL_SAMPLES_NV = 0x932E + STENCIL_TEST = 0x0B90 + STENCIL_VALUE_MASK = 0x0B93 + STENCIL_WRITEMASK = 0x0B98 + STEREO = 0x0C33 + STREAM_COPY = 0x88E2 + STREAM_DRAW = 0x88E0 + STREAM_READ = 0x88E1 + SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR = 0x00000004 + SUBGROUP_FEATURE_BALLOT_BIT_KHR = 0x00000008 + SUBGROUP_FEATURE_BASIC_BIT_KHR = 0x00000001 + SUBGROUP_FEATURE_CLUSTERED_BIT_KHR = 0x00000040 + SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100 + SUBGROUP_FEATURE_QUAD_BIT_KHR = 0x00000080 + SUBGROUP_FEATURE_SHUFFLE_BIT_KHR = 0x00000010 + SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT_KHR = 0x00000020 + SUBGROUP_FEATURE_VOTE_BIT_KHR = 0x00000002 + SUBGROUP_QUAD_ALL_STAGES_KHR = 0x9535 + SUBGROUP_SIZE_KHR = 0x9532 + SUBGROUP_SUPPORTED_FEATURES_KHR = 0x9534 + SUBGROUP_SUPPORTED_STAGES_KHR = 0x9533 + SUBPIXEL_BITS = 0x0D50 + SUBPIXEL_PRECISION_BIAS_X_BITS_NV = 0x9347 + SUBPIXEL_PRECISION_BIAS_Y_BITS_NV = 0x9348 + SUPERSAMPLE_SCALE_X_NV = 0x9372 + SUPERSAMPLE_SCALE_Y_NV = 0x9373 + SUPPORTED_MULTISAMPLE_MODES_AMD = 0x91B7 + SYNC_CL_EVENT_ARB = 0x8240 + SYNC_CL_EVENT_COMPLETE_ARB = 0x8241 + SYNC_CONDITION = 0x9113 + SYNC_FENCE = 0x9116 + SYNC_FLAGS = 0x9115 + SYNC_FLUSH_COMMANDS_BIT = 0x00000001 + SYNC_GPU_COMMANDS_COMPLETE = 0x9117 + SYNC_STATUS = 0x9114 + SYSTEM_FONT_NAME_NV = 0x9073 + TASK_SHADER_BIT_NV = 0x00000080 + TASK_SHADER_NV = 0x955A + TASK_SUBROUTINE_NV = 0x957D + TASK_SUBROUTINE_UNIFORM_NV = 0x957F + TASK_WORK_GROUP_SIZE_NV = 0x953F + TERMINATE_SEQUENCE_COMMAND_NV = 0x0000 + TESS_CONTROL_OUTPUT_VERTICES = 0x8E75 + TESS_CONTROL_SHADER = 0x8E88 + TESS_CONTROL_SHADER_BIT = 0x00000008 + TESS_CONTROL_SHADER_PATCHES_ARB = 0x82F1 + TESS_CONTROL_SUBROUTINE = 0x92E9 + TESS_CONTROL_SUBROUTINE_UNIFORM = 0x92EF + TESS_CONTROL_TEXTURE = 0x829C + TESS_EVALUATION_SHADER = 0x8E87 + TESS_EVALUATION_SHADER_BIT = 0x00000010 + TESS_EVALUATION_SHADER_INVOCATIONS_ARB = 0x82F2 + TESS_EVALUATION_SUBROUTINE = 0x92EA + TESS_EVALUATION_SUBROUTINE_UNIFORM = 0x92F0 + TESS_EVALUATION_TEXTURE = 0x829D + TESS_GEN_MODE = 0x8E76 + TESS_GEN_POINT_MODE = 0x8E79 + TESS_GEN_SPACING = 0x8E77 + TESS_GEN_VERTEX_ORDER = 0x8E78 + TEXTURE = 0x1702 + TEXTURE0 = 0x84C0 + TEXTURE1 = 0x84C1 + TEXTURE10 = 0x84CA + TEXTURE11 = 0x84CB + TEXTURE12 = 0x84CC + TEXTURE13 = 0x84CD + TEXTURE14 = 0x84CE + TEXTURE15 = 0x84CF + TEXTURE16 = 0x84D0 + TEXTURE17 = 0x84D1 + TEXTURE18 = 0x84D2 + TEXTURE19 = 0x84D3 + TEXTURE2 = 0x84C2 + TEXTURE20 = 0x84D4 + TEXTURE21 = 0x84D5 + TEXTURE22 = 0x84D6 + TEXTURE23 = 0x84D7 + TEXTURE24 = 0x84D8 + TEXTURE25 = 0x84D9 + TEXTURE26 = 0x84DA + TEXTURE27 = 0x84DB + TEXTURE28 = 0x84DC + TEXTURE29 = 0x84DD + TEXTURE3 = 0x84C3 + TEXTURE30 = 0x84DE + TEXTURE31 = 0x84DF + TEXTURE4 = 0x84C4 + TEXTURE5 = 0x84C5 + TEXTURE6 = 0x84C6 + TEXTURE7 = 0x84C7 + TEXTURE8 = 0x84C8 + TEXTURE9 = 0x84C9 + TEXTURE_1D = 0x0DE0 + TEXTURE_1D_ARRAY = 0x8C18 + TEXTURE_2D = 0x0DE1 + TEXTURE_2D_ARRAY = 0x8C1A + TEXTURE_2D_MULTISAMPLE = 0x9100 + TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102 + TEXTURE_3D = 0x806F + TEXTURE_ALPHA_SIZE = 0x805F + TEXTURE_ALPHA_TYPE = 0x8C13 + TEXTURE_BASE_LEVEL = 0x813C + TEXTURE_BINDING_1D = 0x8068 + TEXTURE_BINDING_1D_ARRAY = 0x8C1C + TEXTURE_BINDING_2D = 0x8069 + TEXTURE_BINDING_2D_ARRAY = 0x8C1D + TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104 + TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105 + TEXTURE_BINDING_3D = 0x806A + TEXTURE_BINDING_BUFFER = 0x8C2C + TEXTURE_BINDING_BUFFER_ARB = 0x8C2C + TEXTURE_BINDING_CUBE_MAP = 0x8514 + TEXTURE_BINDING_CUBE_MAP_ARRAY = 0x900A + TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB = 0x900A + TEXTURE_BINDING_RECTANGLE = 0x84F6 + TEXTURE_BLUE_SIZE = 0x805E + TEXTURE_BLUE_TYPE = 0x8C12 + TEXTURE_BORDER_COLOR = 0x1004 + TEXTURE_BUFFER = 0x8C2A + TEXTURE_BUFFER_ARB = 0x8C2A + TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D + TEXTURE_BUFFER_DATA_STORE_BINDING_ARB = 0x8C2D + TEXTURE_BUFFER_FORMAT_ARB = 0x8C2E + TEXTURE_BUFFER_OFFSET = 0x919D + TEXTURE_BUFFER_OFFSET_ALIGNMENT = 0x919F + TEXTURE_BUFFER_SIZE = 0x919E + TEXTURE_COMPARE_FUNC = 0x884D + TEXTURE_COMPARE_MODE = 0x884C + TEXTURE_COMPRESSED = 0x86A1 + TEXTURE_COMPRESSED_BLOCK_HEIGHT = 0x82B2 + TEXTURE_COMPRESSED_BLOCK_SIZE = 0x82B3 + TEXTURE_COMPRESSED_BLOCK_WIDTH = 0x82B1 + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + TEXTURE_COMPRESSION_HINT = 0x84EF + TEXTURE_COORD_ARRAY_ADDRESS_NV = 0x8F25 + TEXTURE_COORD_ARRAY_LENGTH_NV = 0x8F2F + TEXTURE_CUBE_MAP = 0x8513 + TEXTURE_CUBE_MAP_ARRAY = 0x9009 + TEXTURE_CUBE_MAP_ARRAY_ARB = 0x9009 + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + TEXTURE_CUBE_MAP_SEAMLESS = 0x884F + TEXTURE_DEPTH = 0x8071 + TEXTURE_DEPTH_SIZE = 0x884A + TEXTURE_DEPTH_TYPE = 0x8C16 + TEXTURE_FETCH_BARRIER_BIT = 0x00000008 + TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107 + TEXTURE_GATHER = 0x82A2 + TEXTURE_GATHER_SHADOW = 0x82A3 + TEXTURE_GREEN_SIZE = 0x805D + TEXTURE_GREEN_TYPE = 0x8C11 + TEXTURE_HEIGHT = 0x1001 + TEXTURE_IMAGE_FORMAT = 0x828F + TEXTURE_IMAGE_TYPE = 0x8290 + TEXTURE_IMMUTABLE_FORMAT = 0x912F + TEXTURE_IMMUTABLE_LEVELS = 0x82DF + TEXTURE_INTERNAL_FORMAT = 0x1003 + TEXTURE_LOD_BIAS = 0x8501 + TEXTURE_MAG_FILTER = 0x2800 + TEXTURE_MAX_ANISOTROPY = 0x84FE + TEXTURE_MAX_LEVEL = 0x813D + TEXTURE_MAX_LOD = 0x813B + TEXTURE_MIN_FILTER = 0x2801 + TEXTURE_MIN_LOD = 0x813A + TEXTURE_RECTANGLE = 0x84F5 + TEXTURE_REDUCTION_MODE_ARB = 0x9366 + TEXTURE_REDUCTION_MODE_EXT = 0x9366 + TEXTURE_RED_SIZE = 0x805C + TEXTURE_RED_TYPE = 0x8C10 + TEXTURE_SAMPLES = 0x9106 + TEXTURE_SHADOW = 0x82A1 + TEXTURE_SHARED_SIZE = 0x8C3F + TEXTURE_SPARSE_ARB = 0x91A6 + TEXTURE_SRGB_DECODE_EXT = 0x8A48 + TEXTURE_STENCIL_SIZE = 0x88F1 + TEXTURE_SWIZZLE_A = 0x8E45 + TEXTURE_SWIZZLE_B = 0x8E44 + TEXTURE_SWIZZLE_G = 0x8E43 + TEXTURE_SWIZZLE_R = 0x8E42 + TEXTURE_SWIZZLE_RGBA = 0x8E46 + TEXTURE_TARGET = 0x1006 + TEXTURE_UPDATE_BARRIER_BIT = 0x00000100 + TEXTURE_VIEW = 0x82B5 + TEXTURE_VIEW_MIN_LAYER = 0x82DD + TEXTURE_VIEW_MIN_LEVEL = 0x82DB + TEXTURE_VIEW_NUM_LAYERS = 0x82DE + TEXTURE_VIEW_NUM_LEVELS = 0x82DC + TEXTURE_WIDTH = 0x1000 + TEXTURE_WRAP_R = 0x8072 + TEXTURE_WRAP_S = 0x2802 + TEXTURE_WRAP_T = 0x2803 + TIMEOUT_EXPIRED = 0x911B + TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF + TIMESTAMP = 0x8E28 + TIME_ELAPSED = 0x88BF + TOP_LEVEL_ARRAY_SIZE = 0x930C + TOP_LEVEL_ARRAY_STRIDE = 0x930D + TRANSFORM_FEEDBACK = 0x8E22 + TRANSFORM_FEEDBACK_BARRIER_BIT = 0x00000800 + TRANSFORM_FEEDBACK_BINDING = 0x8E25 + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E + TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24 + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F + TRANSFORM_FEEDBACK_BUFFER_INDEX = 0x934B + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F + TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23 + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85 + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84 + TRANSFORM_FEEDBACK_BUFFER_STRIDE = 0x934C + TRANSFORM_FEEDBACK_OVERFLOW_ARB = 0x82EC + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88 + TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB = 0x82ED + TRANSFORM_FEEDBACK_VARYING = 0x92F4 + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83 + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76 + TRANSLATE_2D_NV = 0x9090 + TRANSLATE_3D_NV = 0x9091 + TRANSLATE_X_NV = 0x908E + TRANSLATE_Y_NV = 0x908F + TRANSPOSE_AFFINE_2D_NV = 0x9096 + TRANSPOSE_AFFINE_3D_NV = 0x9098 + TRANSPOSE_PROGRAM_MATRIX_EXT = 0x8E2E + TRIANGLES = 0x0004 + TRIANGLES_ADJACENCY = 0x000C + TRIANGLES_ADJACENCY_ARB = 0x000C + TRIANGLE_FAN = 0x0006 + TRIANGLE_STRIP = 0x0005 + TRIANGLE_STRIP_ADJACENCY = 0x000D + TRIANGLE_STRIP_ADJACENCY_ARB = 0x000D + TRIANGULAR_NV = 0x90A5 + TRUE = 1 + TYPE = 0x92FA + UNCORRELATED_NV = 0x9282 + UNDEFINED_VERTEX = 0x8260 + UNIFORM = 0x92E1 + UNIFORM_ADDRESS_COMMAND_NV = 0x000A + UNIFORM_ARRAY_STRIDE = 0x8A3C + UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = 0x92DA + UNIFORM_BARRIER_BIT = 0x00000004 + UNIFORM_BLOCK = 0x92E2 + UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42 + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43 + UNIFORM_BLOCK_BINDING = 0x8A3F + UNIFORM_BLOCK_DATA_SIZE = 0x8A40 + UNIFORM_BLOCK_INDEX = 0x8A3A + UNIFORM_BLOCK_NAME_LENGTH = 0x8A41 + UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = 0x90EC + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46 + UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45 + UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_NV = 0x959C + UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_NV = 0x959D + UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0 + UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1 + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44 + UNIFORM_BUFFER = 0x8A11 + UNIFORM_BUFFER_ADDRESS_NV = 0x936F + UNIFORM_BUFFER_BINDING = 0x8A28 + UNIFORM_BUFFER_LENGTH_NV = 0x9370 + UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34 + UNIFORM_BUFFER_SIZE = 0x8A2A + UNIFORM_BUFFER_START = 0x8A29 + UNIFORM_BUFFER_UNIFIED_NV = 0x936E + UNIFORM_IS_ROW_MAJOR = 0x8A3E + UNIFORM_MATRIX_STRIDE = 0x8A3D + UNIFORM_NAME_LENGTH = 0x8A39 + UNIFORM_OFFSET = 0x8A3B + UNIFORM_SIZE = 0x8A38 + UNIFORM_TYPE = 0x8A37 + UNKNOWN_CONTEXT_RESET = 0x8255 + UNKNOWN_CONTEXT_RESET_ARB = 0x8255 + UNKNOWN_CONTEXT_RESET_KHR = 0x8255 + UNPACK_ALIGNMENT = 0x0CF5 + UNPACK_COMPRESSED_BLOCK_DEPTH = 0x9129 + UNPACK_COMPRESSED_BLOCK_HEIGHT = 0x9128 + UNPACK_COMPRESSED_BLOCK_SIZE = 0x912A + UNPACK_COMPRESSED_BLOCK_WIDTH = 0x9127 + UNPACK_IMAGE_HEIGHT = 0x806E + UNPACK_LSB_FIRST = 0x0CF1 + UNPACK_ROW_LENGTH = 0x0CF2 + UNPACK_SKIP_IMAGES = 0x806D + UNPACK_SKIP_PIXELS = 0x0CF4 + UNPACK_SKIP_ROWS = 0x0CF3 + UNPACK_SWAP_BYTES = 0x0CF0 + UNSIGNALED = 0x9118 + UNSIGNED_BYTE = 0x1401 + UNSIGNED_BYTE_2_3_3_REV = 0x8362 + UNSIGNED_BYTE_3_3_2 = 0x8032 + UNSIGNED_INT = 0x1405 + UNSIGNED_INT16_NV = 0x8FF0 + UNSIGNED_INT16_VEC2_NV = 0x8FF1 + UNSIGNED_INT16_VEC3_NV = 0x8FF2 + UNSIGNED_INT16_VEC4_NV = 0x8FF3 + UNSIGNED_INT64_AMD = 0x8BC2 + UNSIGNED_INT64_ARB = 0x140F + UNSIGNED_INT64_NV = 0x140F + UNSIGNED_INT64_VEC2_ARB = 0x8FF5 + UNSIGNED_INT64_VEC2_NV = 0x8FF5 + UNSIGNED_INT64_VEC3_ARB = 0x8FF6 + UNSIGNED_INT64_VEC3_NV = 0x8FF6 + UNSIGNED_INT64_VEC4_ARB = 0x8FF7 + UNSIGNED_INT64_VEC4_NV = 0x8FF7 + UNSIGNED_INT8_NV = 0x8FEC + UNSIGNED_INT8_VEC2_NV = 0x8FED + UNSIGNED_INT8_VEC3_NV = 0x8FEE + UNSIGNED_INT8_VEC4_NV = 0x8FEF + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B + UNSIGNED_INT_10_10_10_2 = 0x8036 + UNSIGNED_INT_24_8 = 0x84FA + UNSIGNED_INT_2_10_10_10_REV = 0x8368 + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E + UNSIGNED_INT_8_8_8_8 = 0x8035 + UNSIGNED_INT_8_8_8_8_REV = 0x8367 + UNSIGNED_INT_ATOMIC_COUNTER = 0x92DB + UNSIGNED_INT_IMAGE_1D = 0x9062 + UNSIGNED_INT_IMAGE_1D_ARRAY = 0x9068 + UNSIGNED_INT_IMAGE_2D = 0x9063 + UNSIGNED_INT_IMAGE_2D_ARRAY = 0x9069 + UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = 0x906B + UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x906C + UNSIGNED_INT_IMAGE_2D_RECT = 0x9065 + UNSIGNED_INT_IMAGE_3D = 0x9064 + UNSIGNED_INT_IMAGE_BUFFER = 0x9067 + UNSIGNED_INT_IMAGE_CUBE = 0x9066 + UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = 0x906A + UNSIGNED_INT_SAMPLER_1D = 0x8DD1 + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6 + UNSIGNED_INT_SAMPLER_2D = 0x8DD2 + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7 + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D + UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5 + UNSIGNED_INT_SAMPLER_3D = 0x8DD3 + UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8 + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4 + UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900F + UNSIGNED_INT_VEC2 = 0x8DC6 + UNSIGNED_INT_VEC3 = 0x8DC7 + UNSIGNED_INT_VEC4 = 0x8DC8 + UNSIGNED_NORMALIZED = 0x8C17 + UNSIGNED_SHORT = 0x1403 + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + UNSIGNED_SHORT_4_4_4_4 = 0x8033 + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + UNSIGNED_SHORT_5_5_5_1 = 0x8034 + UNSIGNED_SHORT_5_6_5 = 0x8363 + UNSIGNED_SHORT_5_6_5_REV = 0x8364 + UNSIGNED_SHORT_8_8_APPLE = 0x85BA + UNSIGNED_SHORT_8_8_REV_APPLE = 0x85BB + UPPER_LEFT = 0x8CA2 + USE_MISSING_GLYPH_NV = 0x90AA + UTF16_NV = 0x909B + UTF8_NV = 0x909A + VALIDATE_STATUS = 0x8B83 + VENDOR = 0x1F00 + VERSION = 0x1F02 + VERTEX_ARRAY = 0x8074 + VERTEX_ARRAY_ADDRESS_NV = 0x8F21 + VERTEX_ARRAY_BINDING = 0x85B5 + VERTEX_ARRAY_KHR = 0x8074 + VERTEX_ARRAY_LENGTH_NV = 0x8F2B + VERTEX_ARRAY_OBJECT_EXT = 0x9154 + VERTEX_ATTRIB_ARRAY_ADDRESS_NV = 0x8F20 + VERTEX_ATTRIB_ARRAY_BARRIER_BIT = 0x00000001 + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE + VERTEX_ATTRIB_ARRAY_DIVISOR_ARB = 0x88FE + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD + VERTEX_ATTRIB_ARRAY_LENGTH_NV = 0x8F2A + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 + VERTEX_ATTRIB_ARRAY_UNIFIED_NV = 0x8F1E + VERTEX_ATTRIB_BINDING = 0x82D4 + VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D5 + VERTEX_BINDING_DIVISOR = 0x82D6 + VERTEX_BINDING_OFFSET = 0x82D7 + VERTEX_BINDING_STRIDE = 0x82D8 + VERTEX_PROGRAM_POINT_SIZE = 0x8642 + VERTEX_SHADER = 0x8B31 + VERTEX_SHADER_BIT = 0x00000001 + VERTEX_SHADER_BIT_EXT = 0x00000001 + VERTEX_SHADER_INVOCATIONS_ARB = 0x82F0 + VERTEX_SUBROUTINE = 0x92E8 + VERTEX_SUBROUTINE_UNIFORM = 0x92EE + VERTEX_TEXTURE = 0x829B + VERTICAL_LINE_TO_NV = 0x08 + VERTICES_SUBMITTED_ARB = 0x82EE + VIEWPORT = 0x0BA2 + VIEWPORT_BOUNDS_RANGE = 0x825D + VIEWPORT_COMMAND_NV = 0x0010 + VIEWPORT_INDEX_PROVOKING_VERTEX = 0x825F + VIEWPORT_POSITION_W_SCALE_NV = 0x937C + VIEWPORT_POSITION_W_SCALE_X_COEFF_NV = 0x937D + VIEWPORT_POSITION_W_SCALE_Y_COEFF_NV = 0x937E + VIEWPORT_SUBPIXEL_BITS = 0x825C + VIEWPORT_SWIZZLE_NEGATIVE_W_NV = 0x9357 + VIEWPORT_SWIZZLE_NEGATIVE_X_NV = 0x9351 + VIEWPORT_SWIZZLE_NEGATIVE_Y_NV = 0x9353 + VIEWPORT_SWIZZLE_NEGATIVE_Z_NV = 0x9355 + VIEWPORT_SWIZZLE_POSITIVE_W_NV = 0x9356 + VIEWPORT_SWIZZLE_POSITIVE_X_NV = 0x9350 + VIEWPORT_SWIZZLE_POSITIVE_Y_NV = 0x9352 + VIEWPORT_SWIZZLE_POSITIVE_Z_NV = 0x9354 + VIEWPORT_SWIZZLE_W_NV = 0x935B + VIEWPORT_SWIZZLE_X_NV = 0x9358 + VIEWPORT_SWIZZLE_Y_NV = 0x9359 + VIEWPORT_SWIZZLE_Z_NV = 0x935A + VIEW_CLASS_128_BITS = 0x82C4 + VIEW_CLASS_16_BITS = 0x82CA + VIEW_CLASS_24_BITS = 0x82C9 + VIEW_CLASS_32_BITS = 0x82C8 + VIEW_CLASS_48_BITS = 0x82C7 + VIEW_CLASS_64_BITS = 0x82C6 + VIEW_CLASS_8_BITS = 0x82CB + VIEW_CLASS_96_BITS = 0x82C5 + VIEW_CLASS_ASTC_10x10_RGBA = 0x9393 + VIEW_CLASS_ASTC_10x5_RGBA = 0x9390 + VIEW_CLASS_ASTC_10x6_RGBA = 0x9391 + VIEW_CLASS_ASTC_10x8_RGBA = 0x9392 + VIEW_CLASS_ASTC_12x10_RGBA = 0x9394 + VIEW_CLASS_ASTC_12x12_RGBA = 0x9395 + VIEW_CLASS_ASTC_4x4_RGBA = 0x9388 + VIEW_CLASS_ASTC_5x4_RGBA = 0x9389 + VIEW_CLASS_ASTC_5x5_RGBA = 0x938A + VIEW_CLASS_ASTC_6x5_RGBA = 0x938B + VIEW_CLASS_ASTC_6x6_RGBA = 0x938C + VIEW_CLASS_ASTC_8x5_RGBA = 0x938D + VIEW_CLASS_ASTC_8x6_RGBA = 0x938E + VIEW_CLASS_ASTC_8x8_RGBA = 0x938F + VIEW_CLASS_BPTC_FLOAT = 0x82D3 + VIEW_CLASS_BPTC_UNORM = 0x82D2 + VIEW_CLASS_EAC_R11 = 0x9383 + VIEW_CLASS_EAC_RG11 = 0x9384 + VIEW_CLASS_ETC2_EAC_RGBA = 0x9387 + VIEW_CLASS_ETC2_RGB = 0x9385 + VIEW_CLASS_ETC2_RGBA = 0x9386 + VIEW_CLASS_RGTC1_RED = 0x82D0 + VIEW_CLASS_RGTC2_RG = 0x82D1 + VIEW_CLASS_S3TC_DXT1_RGB = 0x82CC + VIEW_CLASS_S3TC_DXT1_RGBA = 0x82CD + VIEW_CLASS_S3TC_DXT3_RGBA = 0x82CE + VIEW_CLASS_S3TC_DXT5_RGBA = 0x82CF + VIEW_COMPATIBILITY_CLASS = 0x82B6 + VIRTUAL_PAGE_SIZE_INDEX_ARB = 0x91A7 + VIRTUAL_PAGE_SIZE_X_ARB = 0x9195 + VIRTUAL_PAGE_SIZE_Y_ARB = 0x9196 + VIRTUAL_PAGE_SIZE_Z_ARB = 0x9197 + VIVIDLIGHT_NV = 0x92A6 + WAIT_FAILED = 0x911D + WARPS_PER_SM_NV = 0x933A + WARP_SIZE_NV = 0x9339 + WEIGHTED_AVERAGE_ARB = 0x9367 + WEIGHTED_AVERAGE_EXT = 0x9367 + WINDOW_RECTANGLE_EXT = 0x8F12 + WINDOW_RECTANGLE_MODE_EXT = 0x8F13 + WRITE_ONLY = 0x88B9 + XOR = 0x1506 + XOR_NV = 0x1506 + ZERO = 0 + ZERO_TO_ONE = 0x935F +) + +var ( + gpActiveProgramEXT C.GPACTIVEPROGRAMEXT + gpActiveShaderProgram C.GPACTIVESHADERPROGRAM + gpActiveShaderProgramEXT C.GPACTIVESHADERPROGRAMEXT + gpActiveTexture C.GPACTIVETEXTURE + gpApplyFramebufferAttachmentCMAAINTEL C.GPAPPLYFRAMEBUFFERATTACHMENTCMAAINTEL + gpAttachShader C.GPATTACHSHADER + gpBeginConditionalRender C.GPBEGINCONDITIONALRENDER + gpBeginConditionalRenderNV C.GPBEGINCONDITIONALRENDERNV + gpBeginPerfMonitorAMD C.GPBEGINPERFMONITORAMD + gpBeginPerfQueryINTEL C.GPBEGINPERFQUERYINTEL + gpBeginQuery C.GPBEGINQUERY + gpBeginQueryIndexed C.GPBEGINQUERYINDEXED + gpBeginTransformFeedback C.GPBEGINTRANSFORMFEEDBACK + gpBindAttribLocation C.GPBINDATTRIBLOCATION + gpBindBuffer C.GPBINDBUFFER + gpBindBufferBase C.GPBINDBUFFERBASE + gpBindBufferRange C.GPBINDBUFFERRANGE + gpBindBuffersBase C.GPBINDBUFFERSBASE + gpBindBuffersRange C.GPBINDBUFFERSRANGE + gpBindFragDataLocation C.GPBINDFRAGDATALOCATION + gpBindFragDataLocationIndexed C.GPBINDFRAGDATALOCATIONINDEXED + gpBindFramebuffer C.GPBINDFRAMEBUFFER + gpBindImageTexture C.GPBINDIMAGETEXTURE + gpBindImageTextures C.GPBINDIMAGETEXTURES + gpBindMultiTextureEXT C.GPBINDMULTITEXTUREEXT + gpBindProgramPipeline C.GPBINDPROGRAMPIPELINE + gpBindProgramPipelineEXT C.GPBINDPROGRAMPIPELINEEXT + gpBindRenderbuffer C.GPBINDRENDERBUFFER + gpBindSampler C.GPBINDSAMPLER + gpBindSamplers C.GPBINDSAMPLERS + gpBindShadingRateImageNV C.GPBINDSHADINGRATEIMAGENV + gpBindTexture C.GPBINDTEXTURE + gpBindTextureUnit C.GPBINDTEXTUREUNIT + gpBindTextures C.GPBINDTEXTURES + gpBindTransformFeedback C.GPBINDTRANSFORMFEEDBACK + gpBindVertexArray C.GPBINDVERTEXARRAY + gpBindVertexBuffer C.GPBINDVERTEXBUFFER + gpBindVertexBuffers C.GPBINDVERTEXBUFFERS + gpBlendBarrierKHR C.GPBLENDBARRIERKHR + gpBlendBarrierNV C.GPBLENDBARRIERNV + gpBlendColor C.GPBLENDCOLOR + gpBlendEquation C.GPBLENDEQUATION + gpBlendEquationSeparate C.GPBLENDEQUATIONSEPARATE + gpBlendEquationSeparateiARB C.GPBLENDEQUATIONSEPARATEIARB + gpBlendEquationiARB C.GPBLENDEQUATIONIARB + gpBlendFunc C.GPBLENDFUNC + gpBlendFuncSeparate C.GPBLENDFUNCSEPARATE + gpBlendFuncSeparateiARB C.GPBLENDFUNCSEPARATEIARB + gpBlendFunciARB C.GPBLENDFUNCIARB + gpBlendParameteriNV C.GPBLENDPARAMETERINV + gpBlitFramebuffer C.GPBLITFRAMEBUFFER + gpBlitNamedFramebuffer C.GPBLITNAMEDFRAMEBUFFER + gpBufferAddressRangeNV C.GPBUFFERADDRESSRANGENV + gpBufferAttachMemoryNV C.GPBUFFERATTACHMEMORYNV + gpBufferData C.GPBUFFERDATA + gpBufferPageCommitmentARB C.GPBUFFERPAGECOMMITMENTARB + gpBufferPageCommitmentMemNV C.GPBUFFERPAGECOMMITMENTMEMNV + gpBufferStorage C.GPBUFFERSTORAGE + gpBufferSubData C.GPBUFFERSUBDATA + gpCallCommandListNV C.GPCALLCOMMANDLISTNV + gpCheckFramebufferStatus C.GPCHECKFRAMEBUFFERSTATUS + gpCheckNamedFramebufferStatus C.GPCHECKNAMEDFRAMEBUFFERSTATUS + gpCheckNamedFramebufferStatusEXT C.GPCHECKNAMEDFRAMEBUFFERSTATUSEXT + gpClampColor C.GPCLAMPCOLOR + gpClear C.GPCLEAR + gpClearBufferData C.GPCLEARBUFFERDATA + gpClearBufferSubData C.GPCLEARBUFFERSUBDATA + gpClearBufferfi C.GPCLEARBUFFERFI + gpClearBufferfv C.GPCLEARBUFFERFV + gpClearBufferiv C.GPCLEARBUFFERIV + gpClearBufferuiv C.GPCLEARBUFFERUIV + gpClearColor C.GPCLEARCOLOR + gpClearDepth C.GPCLEARDEPTH + gpClearDepthdNV C.GPCLEARDEPTHDNV + gpClearDepthf C.GPCLEARDEPTHF + gpClearNamedBufferData C.GPCLEARNAMEDBUFFERDATA + gpClearNamedBufferDataEXT C.GPCLEARNAMEDBUFFERDATAEXT + gpClearNamedBufferSubData C.GPCLEARNAMEDBUFFERSUBDATA + gpClearNamedBufferSubDataEXT C.GPCLEARNAMEDBUFFERSUBDATAEXT + gpClearNamedFramebufferfi C.GPCLEARNAMEDFRAMEBUFFERFI + gpClearNamedFramebufferfv C.GPCLEARNAMEDFRAMEBUFFERFV + gpClearNamedFramebufferiv C.GPCLEARNAMEDFRAMEBUFFERIV + gpClearNamedFramebufferuiv C.GPCLEARNAMEDFRAMEBUFFERUIV + gpClearStencil C.GPCLEARSTENCIL + gpClearTexImage C.GPCLEARTEXIMAGE + gpClearTexSubImage C.GPCLEARTEXSUBIMAGE + gpClientAttribDefaultEXT C.GPCLIENTATTRIBDEFAULTEXT + gpClientWaitSync C.GPCLIENTWAITSYNC + gpClipControl C.GPCLIPCONTROL + gpColorFormatNV C.GPCOLORFORMATNV + gpColorMask C.GPCOLORMASK + gpColorMaski C.GPCOLORMASKI + gpCommandListSegmentsNV C.GPCOMMANDLISTSEGMENTSNV + gpCompileCommandListNV C.GPCOMPILECOMMANDLISTNV + gpCompileShader C.GPCOMPILESHADER + gpCompileShaderIncludeARB C.GPCOMPILESHADERINCLUDEARB + gpCompressedMultiTexImage1DEXT C.GPCOMPRESSEDMULTITEXIMAGE1DEXT + gpCompressedMultiTexImage2DEXT C.GPCOMPRESSEDMULTITEXIMAGE2DEXT + gpCompressedMultiTexImage3DEXT C.GPCOMPRESSEDMULTITEXIMAGE3DEXT + gpCompressedMultiTexSubImage1DEXT C.GPCOMPRESSEDMULTITEXSUBIMAGE1DEXT + gpCompressedMultiTexSubImage2DEXT C.GPCOMPRESSEDMULTITEXSUBIMAGE2DEXT + gpCompressedMultiTexSubImage3DEXT C.GPCOMPRESSEDMULTITEXSUBIMAGE3DEXT + gpCompressedTexImage1D C.GPCOMPRESSEDTEXIMAGE1D + gpCompressedTexImage2D C.GPCOMPRESSEDTEXIMAGE2D + gpCompressedTexImage3D C.GPCOMPRESSEDTEXIMAGE3D + gpCompressedTexSubImage1D C.GPCOMPRESSEDTEXSUBIMAGE1D + gpCompressedTexSubImage2D C.GPCOMPRESSEDTEXSUBIMAGE2D + gpCompressedTexSubImage3D C.GPCOMPRESSEDTEXSUBIMAGE3D + gpCompressedTextureImage1DEXT C.GPCOMPRESSEDTEXTUREIMAGE1DEXT + gpCompressedTextureImage2DEXT C.GPCOMPRESSEDTEXTUREIMAGE2DEXT + gpCompressedTextureImage3DEXT C.GPCOMPRESSEDTEXTUREIMAGE3DEXT + gpCompressedTextureSubImage1D C.GPCOMPRESSEDTEXTURESUBIMAGE1D + gpCompressedTextureSubImage1DEXT C.GPCOMPRESSEDTEXTURESUBIMAGE1DEXT + gpCompressedTextureSubImage2D C.GPCOMPRESSEDTEXTURESUBIMAGE2D + gpCompressedTextureSubImage2DEXT C.GPCOMPRESSEDTEXTURESUBIMAGE2DEXT + gpCompressedTextureSubImage3D C.GPCOMPRESSEDTEXTURESUBIMAGE3D + gpCompressedTextureSubImage3DEXT C.GPCOMPRESSEDTEXTURESUBIMAGE3DEXT + gpConservativeRasterParameterfNV C.GPCONSERVATIVERASTERPARAMETERFNV + gpConservativeRasterParameteriNV C.GPCONSERVATIVERASTERPARAMETERINV + gpCopyBufferSubData C.GPCOPYBUFFERSUBDATA + gpCopyImageSubData C.GPCOPYIMAGESUBDATA + gpCopyMultiTexImage1DEXT C.GPCOPYMULTITEXIMAGE1DEXT + gpCopyMultiTexImage2DEXT C.GPCOPYMULTITEXIMAGE2DEXT + gpCopyMultiTexSubImage1DEXT C.GPCOPYMULTITEXSUBIMAGE1DEXT + gpCopyMultiTexSubImage2DEXT C.GPCOPYMULTITEXSUBIMAGE2DEXT + gpCopyMultiTexSubImage3DEXT C.GPCOPYMULTITEXSUBIMAGE3DEXT + gpCopyNamedBufferSubData C.GPCOPYNAMEDBUFFERSUBDATA + gpCopyPathNV C.GPCOPYPATHNV + gpCopyTexImage1D C.GPCOPYTEXIMAGE1D + gpCopyTexImage2D C.GPCOPYTEXIMAGE2D + gpCopyTexSubImage1D C.GPCOPYTEXSUBIMAGE1D + gpCopyTexSubImage2D C.GPCOPYTEXSUBIMAGE2D + gpCopyTexSubImage3D C.GPCOPYTEXSUBIMAGE3D + gpCopyTextureImage1DEXT C.GPCOPYTEXTUREIMAGE1DEXT + gpCopyTextureImage2DEXT C.GPCOPYTEXTUREIMAGE2DEXT + gpCopyTextureSubImage1D C.GPCOPYTEXTURESUBIMAGE1D + gpCopyTextureSubImage1DEXT C.GPCOPYTEXTURESUBIMAGE1DEXT + gpCopyTextureSubImage2D C.GPCOPYTEXTURESUBIMAGE2D + gpCopyTextureSubImage2DEXT C.GPCOPYTEXTURESUBIMAGE2DEXT + gpCopyTextureSubImage3D C.GPCOPYTEXTURESUBIMAGE3D + gpCopyTextureSubImage3DEXT C.GPCOPYTEXTURESUBIMAGE3DEXT + gpCoverFillPathInstancedNV C.GPCOVERFILLPATHINSTANCEDNV + gpCoverFillPathNV C.GPCOVERFILLPATHNV + gpCoverStrokePathInstancedNV C.GPCOVERSTROKEPATHINSTANCEDNV + gpCoverStrokePathNV C.GPCOVERSTROKEPATHNV + gpCoverageModulationNV C.GPCOVERAGEMODULATIONNV + gpCoverageModulationTableNV C.GPCOVERAGEMODULATIONTABLENV + gpCreateBuffers C.GPCREATEBUFFERS + gpCreateCommandListsNV C.GPCREATECOMMANDLISTSNV + gpCreateFramebuffers C.GPCREATEFRAMEBUFFERS + gpCreatePerfQueryINTEL C.GPCREATEPERFQUERYINTEL + gpCreateProgram C.GPCREATEPROGRAM + gpCreateProgramPipelines C.GPCREATEPROGRAMPIPELINES + gpCreateQueries C.GPCREATEQUERIES + gpCreateRenderbuffers C.GPCREATERENDERBUFFERS + gpCreateSamplers C.GPCREATESAMPLERS + gpCreateShader C.GPCREATESHADER + gpCreateShaderProgramEXT C.GPCREATESHADERPROGRAMEXT + gpCreateShaderProgramv C.GPCREATESHADERPROGRAMV + gpCreateShaderProgramvEXT C.GPCREATESHADERPROGRAMVEXT + gpCreateStatesNV C.GPCREATESTATESNV + gpCreateSyncFromCLeventARB C.GPCREATESYNCFROMCLEVENTARB + gpCreateTextures C.GPCREATETEXTURES + gpCreateTransformFeedbacks C.GPCREATETRANSFORMFEEDBACKS + gpCreateVertexArrays C.GPCREATEVERTEXARRAYS + gpCullFace C.GPCULLFACE + gpDebugMessageCallback C.GPDEBUGMESSAGECALLBACK + gpDebugMessageCallbackARB C.GPDEBUGMESSAGECALLBACKARB + gpDebugMessageCallbackKHR C.GPDEBUGMESSAGECALLBACKKHR + gpDebugMessageControl C.GPDEBUGMESSAGECONTROL + gpDebugMessageControlARB C.GPDEBUGMESSAGECONTROLARB + gpDebugMessageControlKHR C.GPDEBUGMESSAGECONTROLKHR + gpDebugMessageInsert C.GPDEBUGMESSAGEINSERT + gpDebugMessageInsertARB C.GPDEBUGMESSAGEINSERTARB + gpDebugMessageInsertKHR C.GPDEBUGMESSAGEINSERTKHR + gpDeleteBuffers C.GPDELETEBUFFERS + gpDeleteCommandListsNV C.GPDELETECOMMANDLISTSNV + gpDeleteFramebuffers C.GPDELETEFRAMEBUFFERS + gpDeleteNamedStringARB C.GPDELETENAMEDSTRINGARB + gpDeletePathsNV C.GPDELETEPATHSNV + gpDeletePerfMonitorsAMD C.GPDELETEPERFMONITORSAMD + gpDeletePerfQueryINTEL C.GPDELETEPERFQUERYINTEL + gpDeleteProgram C.GPDELETEPROGRAM + gpDeleteProgramPipelines C.GPDELETEPROGRAMPIPELINES + gpDeleteProgramPipelinesEXT C.GPDELETEPROGRAMPIPELINESEXT + gpDeleteQueries C.GPDELETEQUERIES + gpDeleteRenderbuffers C.GPDELETERENDERBUFFERS + gpDeleteSamplers C.GPDELETESAMPLERS + gpDeleteShader C.GPDELETESHADER + gpDeleteStatesNV C.GPDELETESTATESNV + gpDeleteSync C.GPDELETESYNC + gpDeleteTextures C.GPDELETETEXTURES + gpDeleteTransformFeedbacks C.GPDELETETRANSFORMFEEDBACKS + gpDeleteVertexArrays C.GPDELETEVERTEXARRAYS + gpDepthBoundsdNV C.GPDEPTHBOUNDSDNV + gpDepthFunc C.GPDEPTHFUNC + gpDepthMask C.GPDEPTHMASK + gpDepthRange C.GPDEPTHRANGE + gpDepthRangeArraydvNV C.GPDEPTHRANGEARRAYDVNV + gpDepthRangeArrayv C.GPDEPTHRANGEARRAYV + gpDepthRangeIndexed C.GPDEPTHRANGEINDEXED + gpDepthRangeIndexeddNV C.GPDEPTHRANGEINDEXEDDNV + gpDepthRangedNV C.GPDEPTHRANGEDNV + gpDepthRangef C.GPDEPTHRANGEF + gpDetachShader C.GPDETACHSHADER + gpDisable C.GPDISABLE + gpDisableClientStateIndexedEXT C.GPDISABLECLIENTSTATEINDEXEDEXT + gpDisableClientStateiEXT C.GPDISABLECLIENTSTATEIEXT + gpDisableIndexedEXT C.GPDISABLEINDEXEDEXT + gpDisableVertexArrayAttrib C.GPDISABLEVERTEXARRAYATTRIB + gpDisableVertexArrayAttribEXT C.GPDISABLEVERTEXARRAYATTRIBEXT + gpDisableVertexArrayEXT C.GPDISABLEVERTEXARRAYEXT + gpDisableVertexAttribArray C.GPDISABLEVERTEXATTRIBARRAY + gpDisablei C.GPDISABLEI + gpDispatchCompute C.GPDISPATCHCOMPUTE + gpDispatchComputeGroupSizeARB C.GPDISPATCHCOMPUTEGROUPSIZEARB + gpDispatchComputeIndirect C.GPDISPATCHCOMPUTEINDIRECT + gpDrawArrays C.GPDRAWARRAYS + gpDrawArraysIndirect C.GPDRAWARRAYSINDIRECT + gpDrawArraysInstanced C.GPDRAWARRAYSINSTANCED + gpDrawArraysInstancedARB C.GPDRAWARRAYSINSTANCEDARB + gpDrawArraysInstancedBaseInstance C.GPDRAWARRAYSINSTANCEDBASEINSTANCE + gpDrawArraysInstancedEXT C.GPDRAWARRAYSINSTANCEDEXT + gpDrawBuffer C.GPDRAWBUFFER + gpDrawBuffers C.GPDRAWBUFFERS + gpDrawCommandsAddressNV C.GPDRAWCOMMANDSADDRESSNV + gpDrawCommandsNV C.GPDRAWCOMMANDSNV + gpDrawCommandsStatesAddressNV C.GPDRAWCOMMANDSSTATESADDRESSNV + gpDrawCommandsStatesNV C.GPDRAWCOMMANDSSTATESNV + gpDrawElements C.GPDRAWELEMENTS + gpDrawElementsBaseVertex C.GPDRAWELEMENTSBASEVERTEX + gpDrawElementsIndirect C.GPDRAWELEMENTSINDIRECT + gpDrawElementsInstanced C.GPDRAWELEMENTSINSTANCED + gpDrawElementsInstancedARB C.GPDRAWELEMENTSINSTANCEDARB + gpDrawElementsInstancedBaseInstance C.GPDRAWELEMENTSINSTANCEDBASEINSTANCE + gpDrawElementsInstancedBaseVertex C.GPDRAWELEMENTSINSTANCEDBASEVERTEX + gpDrawElementsInstancedBaseVertexBaseInstance C.GPDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCE + gpDrawElementsInstancedEXT C.GPDRAWELEMENTSINSTANCEDEXT + gpDrawMeshTasksIndirectNV C.GPDRAWMESHTASKSINDIRECTNV + gpDrawMeshTasksNV C.GPDRAWMESHTASKSNV + gpDrawRangeElements C.GPDRAWRANGEELEMENTS + gpDrawRangeElementsBaseVertex C.GPDRAWRANGEELEMENTSBASEVERTEX + gpDrawTransformFeedback C.GPDRAWTRANSFORMFEEDBACK + gpDrawTransformFeedbackInstanced C.GPDRAWTRANSFORMFEEDBACKINSTANCED + gpDrawTransformFeedbackStream C.GPDRAWTRANSFORMFEEDBACKSTREAM + gpDrawTransformFeedbackStreamInstanced C.GPDRAWTRANSFORMFEEDBACKSTREAMINSTANCED + gpDrawVkImageNV C.GPDRAWVKIMAGENV + gpEGLImageTargetTexStorageEXT C.GPEGLIMAGETARGETTEXSTORAGEEXT + gpEGLImageTargetTextureStorageEXT C.GPEGLIMAGETARGETTEXTURESTORAGEEXT + gpEdgeFlagFormatNV C.GPEDGEFLAGFORMATNV + gpEnable C.GPENABLE + gpEnableClientStateIndexedEXT C.GPENABLECLIENTSTATEINDEXEDEXT + gpEnableClientStateiEXT C.GPENABLECLIENTSTATEIEXT + gpEnableIndexedEXT C.GPENABLEINDEXEDEXT + gpEnableVertexArrayAttrib C.GPENABLEVERTEXARRAYATTRIB + gpEnableVertexArrayAttribEXT C.GPENABLEVERTEXARRAYATTRIBEXT + gpEnableVertexArrayEXT C.GPENABLEVERTEXARRAYEXT + gpEnableVertexAttribArray C.GPENABLEVERTEXATTRIBARRAY + gpEnablei C.GPENABLEI + gpEndConditionalRender C.GPENDCONDITIONALRENDER + gpEndConditionalRenderNV C.GPENDCONDITIONALRENDERNV + gpEndPerfMonitorAMD C.GPENDPERFMONITORAMD + gpEndPerfQueryINTEL C.GPENDPERFQUERYINTEL + gpEndQuery C.GPENDQUERY + gpEndQueryIndexed C.GPENDQUERYINDEXED + gpEndTransformFeedback C.GPENDTRANSFORMFEEDBACK + gpEvaluateDepthValuesARB C.GPEVALUATEDEPTHVALUESARB + gpFenceSync C.GPFENCESYNC + gpFinish C.GPFINISH + gpFlush C.GPFLUSH + gpFlushMappedBufferRange C.GPFLUSHMAPPEDBUFFERRANGE + gpFlushMappedNamedBufferRange C.GPFLUSHMAPPEDNAMEDBUFFERRANGE + gpFlushMappedNamedBufferRangeEXT C.GPFLUSHMAPPEDNAMEDBUFFERRANGEEXT + gpFogCoordFormatNV C.GPFOGCOORDFORMATNV + gpFragmentCoverageColorNV C.GPFRAGMENTCOVERAGECOLORNV + gpFramebufferDrawBufferEXT C.GPFRAMEBUFFERDRAWBUFFEREXT + gpFramebufferDrawBuffersEXT C.GPFRAMEBUFFERDRAWBUFFERSEXT + gpFramebufferFetchBarrierEXT C.GPFRAMEBUFFERFETCHBARRIEREXT + gpFramebufferParameteri C.GPFRAMEBUFFERPARAMETERI + gpFramebufferParameteriMESA C.GPFRAMEBUFFERPARAMETERIMESA + gpFramebufferReadBufferEXT C.GPFRAMEBUFFERREADBUFFEREXT + gpFramebufferRenderbuffer C.GPFRAMEBUFFERRENDERBUFFER + gpFramebufferSampleLocationsfvARB C.GPFRAMEBUFFERSAMPLELOCATIONSFVARB + gpFramebufferSampleLocationsfvNV C.GPFRAMEBUFFERSAMPLELOCATIONSFVNV + gpFramebufferTexture C.GPFRAMEBUFFERTEXTURE + gpFramebufferTexture1D C.GPFRAMEBUFFERTEXTURE1D + gpFramebufferTexture2D C.GPFRAMEBUFFERTEXTURE2D + gpFramebufferTexture3D C.GPFRAMEBUFFERTEXTURE3D + gpFramebufferTextureARB C.GPFRAMEBUFFERTEXTUREARB + gpFramebufferTextureFaceARB C.GPFRAMEBUFFERTEXTUREFACEARB + gpFramebufferTextureLayer C.GPFRAMEBUFFERTEXTURELAYER + gpFramebufferTextureLayerARB C.GPFRAMEBUFFERTEXTURELAYERARB + gpFramebufferTextureMultiviewOVR C.GPFRAMEBUFFERTEXTUREMULTIVIEWOVR + gpFrontFace C.GPFRONTFACE + gpGenBuffers C.GPGENBUFFERS + gpGenFramebuffers C.GPGENFRAMEBUFFERS + gpGenPathsNV C.GPGENPATHSNV + gpGenPerfMonitorsAMD C.GPGENPERFMONITORSAMD + gpGenProgramPipelines C.GPGENPROGRAMPIPELINES + gpGenProgramPipelinesEXT C.GPGENPROGRAMPIPELINESEXT + gpGenQueries C.GPGENQUERIES + gpGenRenderbuffers C.GPGENRENDERBUFFERS + gpGenSamplers C.GPGENSAMPLERS + gpGenTextures C.GPGENTEXTURES + gpGenTransformFeedbacks C.GPGENTRANSFORMFEEDBACKS + gpGenVertexArrays C.GPGENVERTEXARRAYS + gpGenerateMipmap C.GPGENERATEMIPMAP + gpGenerateMultiTexMipmapEXT C.GPGENERATEMULTITEXMIPMAPEXT + gpGenerateTextureMipmap C.GPGENERATETEXTUREMIPMAP + gpGenerateTextureMipmapEXT C.GPGENERATETEXTUREMIPMAPEXT + gpGetActiveAtomicCounterBufferiv C.GPGETACTIVEATOMICCOUNTERBUFFERIV + gpGetActiveAttrib C.GPGETACTIVEATTRIB + gpGetActiveSubroutineName C.GPGETACTIVESUBROUTINENAME + gpGetActiveSubroutineUniformName C.GPGETACTIVESUBROUTINEUNIFORMNAME + gpGetActiveSubroutineUniformiv C.GPGETACTIVESUBROUTINEUNIFORMIV + gpGetActiveUniform C.GPGETACTIVEUNIFORM + gpGetActiveUniformBlockName C.GPGETACTIVEUNIFORMBLOCKNAME + gpGetActiveUniformBlockiv C.GPGETACTIVEUNIFORMBLOCKIV + gpGetActiveUniformName C.GPGETACTIVEUNIFORMNAME + gpGetActiveUniformsiv C.GPGETACTIVEUNIFORMSIV + gpGetAttachedShaders C.GPGETATTACHEDSHADERS + gpGetAttribLocation C.GPGETATTRIBLOCATION + gpGetBooleanIndexedvEXT C.GPGETBOOLEANINDEXEDVEXT + gpGetBooleani_v C.GPGETBOOLEANI_V + gpGetBooleanv C.GPGETBOOLEANV + gpGetBufferParameteri64v C.GPGETBUFFERPARAMETERI64V + gpGetBufferParameteriv C.GPGETBUFFERPARAMETERIV + gpGetBufferParameterui64vNV C.GPGETBUFFERPARAMETERUI64VNV + gpGetBufferPointerv C.GPGETBUFFERPOINTERV + gpGetBufferSubData C.GPGETBUFFERSUBDATA + gpGetCommandHeaderNV C.GPGETCOMMANDHEADERNV + gpGetCompressedMultiTexImageEXT C.GPGETCOMPRESSEDMULTITEXIMAGEEXT + gpGetCompressedTexImage C.GPGETCOMPRESSEDTEXIMAGE + gpGetCompressedTextureImage C.GPGETCOMPRESSEDTEXTUREIMAGE + gpGetCompressedTextureImageEXT C.GPGETCOMPRESSEDTEXTUREIMAGEEXT + gpGetCompressedTextureSubImage C.GPGETCOMPRESSEDTEXTURESUBIMAGE + gpGetCoverageModulationTableNV C.GPGETCOVERAGEMODULATIONTABLENV + gpGetDebugMessageLog C.GPGETDEBUGMESSAGELOG + gpGetDebugMessageLogARB C.GPGETDEBUGMESSAGELOGARB + gpGetDebugMessageLogKHR C.GPGETDEBUGMESSAGELOGKHR + gpGetDoubleIndexedvEXT C.GPGETDOUBLEINDEXEDVEXT + gpGetDoublei_v C.GPGETDOUBLEI_V + gpGetDoublei_vEXT C.GPGETDOUBLEI_VEXT + gpGetDoublev C.GPGETDOUBLEV + gpGetError C.GPGETERROR + gpGetFirstPerfQueryIdINTEL C.GPGETFIRSTPERFQUERYIDINTEL + gpGetFloatIndexedvEXT C.GPGETFLOATINDEXEDVEXT + gpGetFloati_v C.GPGETFLOATI_V + gpGetFloati_vEXT C.GPGETFLOATI_VEXT + gpGetFloatv C.GPGETFLOATV + gpGetFragDataIndex C.GPGETFRAGDATAINDEX + gpGetFragDataLocation C.GPGETFRAGDATALOCATION + gpGetFramebufferAttachmentParameteriv C.GPGETFRAMEBUFFERATTACHMENTPARAMETERIV + gpGetFramebufferParameteriv C.GPGETFRAMEBUFFERPARAMETERIV + gpGetFramebufferParameterivEXT C.GPGETFRAMEBUFFERPARAMETERIVEXT + gpGetFramebufferParameterivMESA C.GPGETFRAMEBUFFERPARAMETERIVMESA + gpGetGraphicsResetStatus C.GPGETGRAPHICSRESETSTATUS + gpGetGraphicsResetStatusARB C.GPGETGRAPHICSRESETSTATUSARB + gpGetGraphicsResetStatusKHR C.GPGETGRAPHICSRESETSTATUSKHR + gpGetImageHandleARB C.GPGETIMAGEHANDLEARB + gpGetImageHandleNV C.GPGETIMAGEHANDLENV + gpGetInteger64i_v C.GPGETINTEGER64I_V + gpGetInteger64v C.GPGETINTEGER64V + gpGetIntegerIndexedvEXT C.GPGETINTEGERINDEXEDVEXT + gpGetIntegeri_v C.GPGETINTEGERI_V + gpGetIntegerui64i_vNV C.GPGETINTEGERUI64I_VNV + gpGetIntegerui64vNV C.GPGETINTEGERUI64VNV + gpGetIntegerv C.GPGETINTEGERV + gpGetInternalformatSampleivNV C.GPGETINTERNALFORMATSAMPLEIVNV + gpGetInternalformati64v C.GPGETINTERNALFORMATI64V + gpGetInternalformativ C.GPGETINTERNALFORMATIV + gpGetMemoryObjectDetachedResourcesuivNV C.GPGETMEMORYOBJECTDETACHEDRESOURCESUIVNV + gpGetMultiTexEnvfvEXT C.GPGETMULTITEXENVFVEXT + gpGetMultiTexEnvivEXT C.GPGETMULTITEXENVIVEXT + gpGetMultiTexGendvEXT C.GPGETMULTITEXGENDVEXT + gpGetMultiTexGenfvEXT C.GPGETMULTITEXGENFVEXT + gpGetMultiTexGenivEXT C.GPGETMULTITEXGENIVEXT + gpGetMultiTexImageEXT C.GPGETMULTITEXIMAGEEXT + gpGetMultiTexLevelParameterfvEXT C.GPGETMULTITEXLEVELPARAMETERFVEXT + gpGetMultiTexLevelParameterivEXT C.GPGETMULTITEXLEVELPARAMETERIVEXT + gpGetMultiTexParameterIivEXT C.GPGETMULTITEXPARAMETERIIVEXT + gpGetMultiTexParameterIuivEXT C.GPGETMULTITEXPARAMETERIUIVEXT + gpGetMultiTexParameterfvEXT C.GPGETMULTITEXPARAMETERFVEXT + gpGetMultiTexParameterivEXT C.GPGETMULTITEXPARAMETERIVEXT + gpGetMultisamplefv C.GPGETMULTISAMPLEFV + gpGetNamedBufferParameteri64v C.GPGETNAMEDBUFFERPARAMETERI64V + gpGetNamedBufferParameteriv C.GPGETNAMEDBUFFERPARAMETERIV + gpGetNamedBufferParameterivEXT C.GPGETNAMEDBUFFERPARAMETERIVEXT + gpGetNamedBufferParameterui64vNV C.GPGETNAMEDBUFFERPARAMETERUI64VNV + gpGetNamedBufferPointerv C.GPGETNAMEDBUFFERPOINTERV + gpGetNamedBufferPointervEXT C.GPGETNAMEDBUFFERPOINTERVEXT + gpGetNamedBufferSubData C.GPGETNAMEDBUFFERSUBDATA + gpGetNamedBufferSubDataEXT C.GPGETNAMEDBUFFERSUBDATAEXT + gpGetNamedFramebufferAttachmentParameteriv C.GPGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIV + gpGetNamedFramebufferAttachmentParameterivEXT C.GPGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXT + gpGetNamedFramebufferParameteriv C.GPGETNAMEDFRAMEBUFFERPARAMETERIV + gpGetNamedFramebufferParameterivEXT C.GPGETNAMEDFRAMEBUFFERPARAMETERIVEXT + gpGetNamedProgramLocalParameterIivEXT C.GPGETNAMEDPROGRAMLOCALPARAMETERIIVEXT + gpGetNamedProgramLocalParameterIuivEXT C.GPGETNAMEDPROGRAMLOCALPARAMETERIUIVEXT + gpGetNamedProgramLocalParameterdvEXT C.GPGETNAMEDPROGRAMLOCALPARAMETERDVEXT + gpGetNamedProgramLocalParameterfvEXT C.GPGETNAMEDPROGRAMLOCALPARAMETERFVEXT + gpGetNamedProgramStringEXT C.GPGETNAMEDPROGRAMSTRINGEXT + gpGetNamedProgramivEXT C.GPGETNAMEDPROGRAMIVEXT + gpGetNamedRenderbufferParameteriv C.GPGETNAMEDRENDERBUFFERPARAMETERIV + gpGetNamedRenderbufferParameterivEXT C.GPGETNAMEDRENDERBUFFERPARAMETERIVEXT + gpGetNamedStringARB C.GPGETNAMEDSTRINGARB + gpGetNamedStringivARB C.GPGETNAMEDSTRINGIVARB + gpGetNextPerfQueryIdINTEL C.GPGETNEXTPERFQUERYIDINTEL + gpGetObjectLabel C.GPGETOBJECTLABEL + gpGetObjectLabelEXT C.GPGETOBJECTLABELEXT + gpGetObjectLabelKHR C.GPGETOBJECTLABELKHR + gpGetObjectPtrLabel C.GPGETOBJECTPTRLABEL + gpGetObjectPtrLabelKHR C.GPGETOBJECTPTRLABELKHR + gpGetPathCommandsNV C.GPGETPATHCOMMANDSNV + gpGetPathCoordsNV C.GPGETPATHCOORDSNV + gpGetPathDashArrayNV C.GPGETPATHDASHARRAYNV + gpGetPathLengthNV C.GPGETPATHLENGTHNV + gpGetPathMetricRangeNV C.GPGETPATHMETRICRANGENV + gpGetPathMetricsNV C.GPGETPATHMETRICSNV + gpGetPathParameterfvNV C.GPGETPATHPARAMETERFVNV + gpGetPathParameterivNV C.GPGETPATHPARAMETERIVNV + gpGetPathSpacingNV C.GPGETPATHSPACINGNV + gpGetPerfCounterInfoINTEL C.GPGETPERFCOUNTERINFOINTEL + gpGetPerfMonitorCounterDataAMD C.GPGETPERFMONITORCOUNTERDATAAMD + gpGetPerfMonitorCounterInfoAMD C.GPGETPERFMONITORCOUNTERINFOAMD + gpGetPerfMonitorCounterStringAMD C.GPGETPERFMONITORCOUNTERSTRINGAMD + gpGetPerfMonitorCountersAMD C.GPGETPERFMONITORCOUNTERSAMD + gpGetPerfMonitorGroupStringAMD C.GPGETPERFMONITORGROUPSTRINGAMD + gpGetPerfMonitorGroupsAMD C.GPGETPERFMONITORGROUPSAMD + gpGetPerfQueryDataINTEL C.GPGETPERFQUERYDATAINTEL + gpGetPerfQueryIdByNameINTEL C.GPGETPERFQUERYIDBYNAMEINTEL + gpGetPerfQueryInfoINTEL C.GPGETPERFQUERYINFOINTEL + gpGetPointerIndexedvEXT C.GPGETPOINTERINDEXEDVEXT + gpGetPointeri_vEXT C.GPGETPOINTERI_VEXT + gpGetPointerv C.GPGETPOINTERV + gpGetPointervKHR C.GPGETPOINTERVKHR + gpGetProgramBinary C.GPGETPROGRAMBINARY + gpGetProgramInfoLog C.GPGETPROGRAMINFOLOG + gpGetProgramInterfaceiv C.GPGETPROGRAMINTERFACEIV + gpGetProgramPipelineInfoLog C.GPGETPROGRAMPIPELINEINFOLOG + gpGetProgramPipelineInfoLogEXT C.GPGETPROGRAMPIPELINEINFOLOGEXT + gpGetProgramPipelineiv C.GPGETPROGRAMPIPELINEIV + gpGetProgramPipelineivEXT C.GPGETPROGRAMPIPELINEIVEXT + gpGetProgramResourceIndex C.GPGETPROGRAMRESOURCEINDEX + gpGetProgramResourceLocation C.GPGETPROGRAMRESOURCELOCATION + gpGetProgramResourceLocationIndex C.GPGETPROGRAMRESOURCELOCATIONINDEX + gpGetProgramResourceName C.GPGETPROGRAMRESOURCENAME + gpGetProgramResourcefvNV C.GPGETPROGRAMRESOURCEFVNV + gpGetProgramResourceiv C.GPGETPROGRAMRESOURCEIV + gpGetProgramStageiv C.GPGETPROGRAMSTAGEIV + gpGetProgramiv C.GPGETPROGRAMIV + gpGetQueryBufferObjecti64v C.GPGETQUERYBUFFEROBJECTI64V + gpGetQueryBufferObjectiv C.GPGETQUERYBUFFEROBJECTIV + gpGetQueryBufferObjectui64v C.GPGETQUERYBUFFEROBJECTUI64V + gpGetQueryBufferObjectuiv C.GPGETQUERYBUFFEROBJECTUIV + gpGetQueryIndexediv C.GPGETQUERYINDEXEDIV + gpGetQueryObjecti64v C.GPGETQUERYOBJECTI64V + gpGetQueryObjectiv C.GPGETQUERYOBJECTIV + gpGetQueryObjectui64v C.GPGETQUERYOBJECTUI64V + gpGetQueryObjectuiv C.GPGETQUERYOBJECTUIV + gpGetQueryiv C.GPGETQUERYIV + gpGetRenderbufferParameteriv C.GPGETRENDERBUFFERPARAMETERIV + gpGetSamplerParameterIiv C.GPGETSAMPLERPARAMETERIIV + gpGetSamplerParameterIuiv C.GPGETSAMPLERPARAMETERIUIV + gpGetSamplerParameterfv C.GPGETSAMPLERPARAMETERFV + gpGetSamplerParameteriv C.GPGETSAMPLERPARAMETERIV + gpGetShaderInfoLog C.GPGETSHADERINFOLOG + gpGetShaderPrecisionFormat C.GPGETSHADERPRECISIONFORMAT + gpGetShaderSource C.GPGETSHADERSOURCE + gpGetShaderiv C.GPGETSHADERIV + gpGetShadingRateImagePaletteNV C.GPGETSHADINGRATEIMAGEPALETTENV + gpGetShadingRateSampleLocationivNV C.GPGETSHADINGRATESAMPLELOCATIONIVNV + gpGetStageIndexNV C.GPGETSTAGEINDEXNV + gpGetString C.GPGETSTRING + gpGetStringi C.GPGETSTRINGI + gpGetSubroutineIndex C.GPGETSUBROUTINEINDEX + gpGetSubroutineUniformLocation C.GPGETSUBROUTINEUNIFORMLOCATION + gpGetSynciv C.GPGETSYNCIV + gpGetTexImage C.GPGETTEXIMAGE + gpGetTexLevelParameterfv C.GPGETTEXLEVELPARAMETERFV + gpGetTexLevelParameteriv C.GPGETTEXLEVELPARAMETERIV + gpGetTexParameterIiv C.GPGETTEXPARAMETERIIV + gpGetTexParameterIuiv C.GPGETTEXPARAMETERIUIV + gpGetTexParameterfv C.GPGETTEXPARAMETERFV + gpGetTexParameteriv C.GPGETTEXPARAMETERIV + gpGetTextureHandleARB C.GPGETTEXTUREHANDLEARB + gpGetTextureHandleNV C.GPGETTEXTUREHANDLENV + gpGetTextureImage C.GPGETTEXTUREIMAGE + gpGetTextureImageEXT C.GPGETTEXTUREIMAGEEXT + gpGetTextureLevelParameterfv C.GPGETTEXTURELEVELPARAMETERFV + gpGetTextureLevelParameterfvEXT C.GPGETTEXTURELEVELPARAMETERFVEXT + gpGetTextureLevelParameteriv C.GPGETTEXTURELEVELPARAMETERIV + gpGetTextureLevelParameterivEXT C.GPGETTEXTURELEVELPARAMETERIVEXT + gpGetTextureParameterIiv C.GPGETTEXTUREPARAMETERIIV + gpGetTextureParameterIivEXT C.GPGETTEXTUREPARAMETERIIVEXT + gpGetTextureParameterIuiv C.GPGETTEXTUREPARAMETERIUIV + gpGetTextureParameterIuivEXT C.GPGETTEXTUREPARAMETERIUIVEXT + gpGetTextureParameterfv C.GPGETTEXTUREPARAMETERFV + gpGetTextureParameterfvEXT C.GPGETTEXTUREPARAMETERFVEXT + gpGetTextureParameteriv C.GPGETTEXTUREPARAMETERIV + gpGetTextureParameterivEXT C.GPGETTEXTUREPARAMETERIVEXT + gpGetTextureSamplerHandleARB C.GPGETTEXTURESAMPLERHANDLEARB + gpGetTextureSamplerHandleNV C.GPGETTEXTURESAMPLERHANDLENV + gpGetTextureSubImage C.GPGETTEXTURESUBIMAGE + gpGetTransformFeedbackVarying C.GPGETTRANSFORMFEEDBACKVARYING + gpGetTransformFeedbacki64_v C.GPGETTRANSFORMFEEDBACKI64_V + gpGetTransformFeedbacki_v C.GPGETTRANSFORMFEEDBACKI_V + gpGetTransformFeedbackiv C.GPGETTRANSFORMFEEDBACKIV + gpGetUniformBlockIndex C.GPGETUNIFORMBLOCKINDEX + gpGetUniformIndices C.GPGETUNIFORMINDICES + gpGetUniformLocation C.GPGETUNIFORMLOCATION + gpGetUniformSubroutineuiv C.GPGETUNIFORMSUBROUTINEUIV + gpGetUniformdv C.GPGETUNIFORMDV + gpGetUniformfv C.GPGETUNIFORMFV + gpGetUniformi64vARB C.GPGETUNIFORMI64VARB + gpGetUniformi64vNV C.GPGETUNIFORMI64VNV + gpGetUniformiv C.GPGETUNIFORMIV + gpGetUniformui64vARB C.GPGETUNIFORMUI64VARB + gpGetUniformui64vNV C.GPGETUNIFORMUI64VNV + gpGetUniformuiv C.GPGETUNIFORMUIV + gpGetVertexArrayIndexed64iv C.GPGETVERTEXARRAYINDEXED64IV + gpGetVertexArrayIndexediv C.GPGETVERTEXARRAYINDEXEDIV + gpGetVertexArrayIntegeri_vEXT C.GPGETVERTEXARRAYINTEGERI_VEXT + gpGetVertexArrayIntegervEXT C.GPGETVERTEXARRAYINTEGERVEXT + gpGetVertexArrayPointeri_vEXT C.GPGETVERTEXARRAYPOINTERI_VEXT + gpGetVertexArrayPointervEXT C.GPGETVERTEXARRAYPOINTERVEXT + gpGetVertexArrayiv C.GPGETVERTEXARRAYIV + gpGetVertexAttribIiv C.GPGETVERTEXATTRIBIIV + gpGetVertexAttribIuiv C.GPGETVERTEXATTRIBIUIV + gpGetVertexAttribLdv C.GPGETVERTEXATTRIBLDV + gpGetVertexAttribLi64vNV C.GPGETVERTEXATTRIBLI64VNV + gpGetVertexAttribLui64vARB C.GPGETVERTEXATTRIBLUI64VARB + gpGetVertexAttribLui64vNV C.GPGETVERTEXATTRIBLUI64VNV + gpGetVertexAttribPointerv C.GPGETVERTEXATTRIBPOINTERV + gpGetVertexAttribdv C.GPGETVERTEXATTRIBDV + gpGetVertexAttribfv C.GPGETVERTEXATTRIBFV + gpGetVertexAttribiv C.GPGETVERTEXATTRIBIV + gpGetVkProcAddrNV C.GPGETVKPROCADDRNV + gpGetnCompressedTexImageARB C.GPGETNCOMPRESSEDTEXIMAGEARB + gpGetnTexImageARB C.GPGETNTEXIMAGEARB + gpGetnUniformdvARB C.GPGETNUNIFORMDVARB + gpGetnUniformfv C.GPGETNUNIFORMFV + gpGetnUniformfvARB C.GPGETNUNIFORMFVARB + gpGetnUniformfvKHR C.GPGETNUNIFORMFVKHR + gpGetnUniformi64vARB C.GPGETNUNIFORMI64VARB + gpGetnUniformiv C.GPGETNUNIFORMIV + gpGetnUniformivARB C.GPGETNUNIFORMIVARB + gpGetnUniformivKHR C.GPGETNUNIFORMIVKHR + gpGetnUniformui64vARB C.GPGETNUNIFORMUI64VARB + gpGetnUniformuiv C.GPGETNUNIFORMUIV + gpGetnUniformuivARB C.GPGETNUNIFORMUIVARB + gpGetnUniformuivKHR C.GPGETNUNIFORMUIVKHR + gpHint C.GPHINT + gpIndexFormatNV C.GPINDEXFORMATNV + gpInsertEventMarkerEXT C.GPINSERTEVENTMARKEREXT + gpInterpolatePathsNV C.GPINTERPOLATEPATHSNV + gpInvalidateBufferData C.GPINVALIDATEBUFFERDATA + gpInvalidateBufferSubData C.GPINVALIDATEBUFFERSUBDATA + gpInvalidateFramebuffer C.GPINVALIDATEFRAMEBUFFER + gpInvalidateNamedFramebufferData C.GPINVALIDATENAMEDFRAMEBUFFERDATA + gpInvalidateNamedFramebufferSubData C.GPINVALIDATENAMEDFRAMEBUFFERSUBDATA + gpInvalidateSubFramebuffer C.GPINVALIDATESUBFRAMEBUFFER + gpInvalidateTexImage C.GPINVALIDATETEXIMAGE + gpInvalidateTexSubImage C.GPINVALIDATETEXSUBIMAGE + gpIsBuffer C.GPISBUFFER + gpIsBufferResidentNV C.GPISBUFFERRESIDENTNV + gpIsCommandListNV C.GPISCOMMANDLISTNV + gpIsEnabled C.GPISENABLED + gpIsEnabledIndexedEXT C.GPISENABLEDINDEXEDEXT + gpIsEnabledi C.GPISENABLEDI + gpIsFramebuffer C.GPISFRAMEBUFFER + gpIsImageHandleResidentARB C.GPISIMAGEHANDLERESIDENTARB + gpIsImageHandleResidentNV C.GPISIMAGEHANDLERESIDENTNV + gpIsNamedBufferResidentNV C.GPISNAMEDBUFFERRESIDENTNV + gpIsNamedStringARB C.GPISNAMEDSTRINGARB + gpIsPathNV C.GPISPATHNV + gpIsPointInFillPathNV C.GPISPOINTINFILLPATHNV + gpIsPointInStrokePathNV C.GPISPOINTINSTROKEPATHNV + gpIsProgram C.GPISPROGRAM + gpIsProgramPipeline C.GPISPROGRAMPIPELINE + gpIsProgramPipelineEXT C.GPISPROGRAMPIPELINEEXT + gpIsQuery C.GPISQUERY + gpIsRenderbuffer C.GPISRENDERBUFFER + gpIsSampler C.GPISSAMPLER + gpIsShader C.GPISSHADER + gpIsStateNV C.GPISSTATENV + gpIsSync C.GPISSYNC + gpIsTexture C.GPISTEXTURE + gpIsTextureHandleResidentARB C.GPISTEXTUREHANDLERESIDENTARB + gpIsTextureHandleResidentNV C.GPISTEXTUREHANDLERESIDENTNV + gpIsTransformFeedback C.GPISTRANSFORMFEEDBACK + gpIsVertexArray C.GPISVERTEXARRAY + gpLabelObjectEXT C.GPLABELOBJECTEXT + gpLineWidth C.GPLINEWIDTH + gpLinkProgram C.GPLINKPROGRAM + gpListDrawCommandsStatesClientNV C.GPLISTDRAWCOMMANDSSTATESCLIENTNV + gpLogicOp C.GPLOGICOP + gpMakeBufferNonResidentNV C.GPMAKEBUFFERNONRESIDENTNV + gpMakeBufferResidentNV C.GPMAKEBUFFERRESIDENTNV + gpMakeImageHandleNonResidentARB C.GPMAKEIMAGEHANDLENONRESIDENTARB + gpMakeImageHandleNonResidentNV C.GPMAKEIMAGEHANDLENONRESIDENTNV + gpMakeImageHandleResidentARB C.GPMAKEIMAGEHANDLERESIDENTARB + gpMakeImageHandleResidentNV C.GPMAKEIMAGEHANDLERESIDENTNV + gpMakeNamedBufferNonResidentNV C.GPMAKENAMEDBUFFERNONRESIDENTNV + gpMakeNamedBufferResidentNV C.GPMAKENAMEDBUFFERRESIDENTNV + gpMakeTextureHandleNonResidentARB C.GPMAKETEXTUREHANDLENONRESIDENTARB + gpMakeTextureHandleNonResidentNV C.GPMAKETEXTUREHANDLENONRESIDENTNV + gpMakeTextureHandleResidentARB C.GPMAKETEXTUREHANDLERESIDENTARB + gpMakeTextureHandleResidentNV C.GPMAKETEXTUREHANDLERESIDENTNV + gpMapBuffer C.GPMAPBUFFER + gpMapBufferRange C.GPMAPBUFFERRANGE + gpMapNamedBuffer C.GPMAPNAMEDBUFFER + gpMapNamedBufferEXT C.GPMAPNAMEDBUFFEREXT + gpMapNamedBufferRange C.GPMAPNAMEDBUFFERRANGE + gpMapNamedBufferRangeEXT C.GPMAPNAMEDBUFFERRANGEEXT + gpMatrixFrustumEXT C.GPMATRIXFRUSTUMEXT + gpMatrixLoad3x2fNV C.GPMATRIXLOAD3X2FNV + gpMatrixLoad3x3fNV C.GPMATRIXLOAD3X3FNV + gpMatrixLoadIdentityEXT C.GPMATRIXLOADIDENTITYEXT + gpMatrixLoadTranspose3x3fNV C.GPMATRIXLOADTRANSPOSE3X3FNV + gpMatrixLoadTransposedEXT C.GPMATRIXLOADTRANSPOSEDEXT + gpMatrixLoadTransposefEXT C.GPMATRIXLOADTRANSPOSEFEXT + gpMatrixLoaddEXT C.GPMATRIXLOADDEXT + gpMatrixLoadfEXT C.GPMATRIXLOADFEXT + gpMatrixMult3x2fNV C.GPMATRIXMULT3X2FNV + gpMatrixMult3x3fNV C.GPMATRIXMULT3X3FNV + gpMatrixMultTranspose3x3fNV C.GPMATRIXMULTTRANSPOSE3X3FNV + gpMatrixMultTransposedEXT C.GPMATRIXMULTTRANSPOSEDEXT + gpMatrixMultTransposefEXT C.GPMATRIXMULTTRANSPOSEFEXT + gpMatrixMultdEXT C.GPMATRIXMULTDEXT + gpMatrixMultfEXT C.GPMATRIXMULTFEXT + gpMatrixOrthoEXT C.GPMATRIXORTHOEXT + gpMatrixPopEXT C.GPMATRIXPOPEXT + gpMatrixPushEXT C.GPMATRIXPUSHEXT + gpMatrixRotatedEXT C.GPMATRIXROTATEDEXT + gpMatrixRotatefEXT C.GPMATRIXROTATEFEXT + gpMatrixScaledEXT C.GPMATRIXSCALEDEXT + gpMatrixScalefEXT C.GPMATRIXSCALEFEXT + gpMatrixTranslatedEXT C.GPMATRIXTRANSLATEDEXT + gpMatrixTranslatefEXT C.GPMATRIXTRANSLATEFEXT + gpMaxShaderCompilerThreadsARB C.GPMAXSHADERCOMPILERTHREADSARB + gpMaxShaderCompilerThreadsKHR C.GPMAXSHADERCOMPILERTHREADSKHR + gpMemoryBarrier C.GPMEMORYBARRIER + gpMemoryBarrierByRegion C.GPMEMORYBARRIERBYREGION + gpMinSampleShadingARB C.GPMINSAMPLESHADINGARB + gpMultiDrawArrays C.GPMULTIDRAWARRAYS + gpMultiDrawArraysIndirect C.GPMULTIDRAWARRAYSINDIRECT + gpMultiDrawArraysIndirectBindlessCountNV C.GPMULTIDRAWARRAYSINDIRECTBINDLESSCOUNTNV + gpMultiDrawArraysIndirectBindlessNV C.GPMULTIDRAWARRAYSINDIRECTBINDLESSNV + gpMultiDrawArraysIndirectCountARB C.GPMULTIDRAWARRAYSINDIRECTCOUNTARB + gpMultiDrawElements C.GPMULTIDRAWELEMENTS + gpMultiDrawElementsBaseVertex C.GPMULTIDRAWELEMENTSBASEVERTEX + gpMultiDrawElementsIndirect C.GPMULTIDRAWELEMENTSINDIRECT + gpMultiDrawElementsIndirectBindlessCountNV C.GPMULTIDRAWELEMENTSINDIRECTBINDLESSCOUNTNV + gpMultiDrawElementsIndirectBindlessNV C.GPMULTIDRAWELEMENTSINDIRECTBINDLESSNV + gpMultiDrawElementsIndirectCountARB C.GPMULTIDRAWELEMENTSINDIRECTCOUNTARB + gpMultiDrawMeshTasksIndirectCountNV C.GPMULTIDRAWMESHTASKSINDIRECTCOUNTNV + gpMultiDrawMeshTasksIndirectNV C.GPMULTIDRAWMESHTASKSINDIRECTNV + gpMultiTexBufferEXT C.GPMULTITEXBUFFEREXT + gpMultiTexCoordPointerEXT C.GPMULTITEXCOORDPOINTEREXT + gpMultiTexEnvfEXT C.GPMULTITEXENVFEXT + gpMultiTexEnvfvEXT C.GPMULTITEXENVFVEXT + gpMultiTexEnviEXT C.GPMULTITEXENVIEXT + gpMultiTexEnvivEXT C.GPMULTITEXENVIVEXT + gpMultiTexGendEXT C.GPMULTITEXGENDEXT + gpMultiTexGendvEXT C.GPMULTITEXGENDVEXT + gpMultiTexGenfEXT C.GPMULTITEXGENFEXT + gpMultiTexGenfvEXT C.GPMULTITEXGENFVEXT + gpMultiTexGeniEXT C.GPMULTITEXGENIEXT + gpMultiTexGenivEXT C.GPMULTITEXGENIVEXT + gpMultiTexImage1DEXT C.GPMULTITEXIMAGE1DEXT + gpMultiTexImage2DEXT C.GPMULTITEXIMAGE2DEXT + gpMultiTexImage3DEXT C.GPMULTITEXIMAGE3DEXT + gpMultiTexParameterIivEXT C.GPMULTITEXPARAMETERIIVEXT + gpMultiTexParameterIuivEXT C.GPMULTITEXPARAMETERIUIVEXT + gpMultiTexParameterfEXT C.GPMULTITEXPARAMETERFEXT + gpMultiTexParameterfvEXT C.GPMULTITEXPARAMETERFVEXT + gpMultiTexParameteriEXT C.GPMULTITEXPARAMETERIEXT + gpMultiTexParameterivEXT C.GPMULTITEXPARAMETERIVEXT + gpMultiTexRenderbufferEXT C.GPMULTITEXRENDERBUFFEREXT + gpMultiTexSubImage1DEXT C.GPMULTITEXSUBIMAGE1DEXT + gpMultiTexSubImage2DEXT C.GPMULTITEXSUBIMAGE2DEXT + gpMultiTexSubImage3DEXT C.GPMULTITEXSUBIMAGE3DEXT + gpNamedBufferAttachMemoryNV C.GPNAMEDBUFFERATTACHMEMORYNV + gpNamedBufferData C.GPNAMEDBUFFERDATA + gpNamedBufferDataEXT C.GPNAMEDBUFFERDATAEXT + gpNamedBufferPageCommitmentARB C.GPNAMEDBUFFERPAGECOMMITMENTARB + gpNamedBufferPageCommitmentEXT C.GPNAMEDBUFFERPAGECOMMITMENTEXT + gpNamedBufferPageCommitmentMemNV C.GPNAMEDBUFFERPAGECOMMITMENTMEMNV + gpNamedBufferStorage C.GPNAMEDBUFFERSTORAGE + gpNamedBufferStorageEXT C.GPNAMEDBUFFERSTORAGEEXT + gpNamedBufferSubData C.GPNAMEDBUFFERSUBDATA + gpNamedBufferSubDataEXT C.GPNAMEDBUFFERSUBDATAEXT + gpNamedCopyBufferSubDataEXT C.GPNAMEDCOPYBUFFERSUBDATAEXT + gpNamedFramebufferDrawBuffer C.GPNAMEDFRAMEBUFFERDRAWBUFFER + gpNamedFramebufferDrawBuffers C.GPNAMEDFRAMEBUFFERDRAWBUFFERS + gpNamedFramebufferParameteri C.GPNAMEDFRAMEBUFFERPARAMETERI + gpNamedFramebufferParameteriEXT C.GPNAMEDFRAMEBUFFERPARAMETERIEXT + gpNamedFramebufferReadBuffer C.GPNAMEDFRAMEBUFFERREADBUFFER + gpNamedFramebufferRenderbuffer C.GPNAMEDFRAMEBUFFERRENDERBUFFER + gpNamedFramebufferRenderbufferEXT C.GPNAMEDFRAMEBUFFERRENDERBUFFEREXT + gpNamedFramebufferSampleLocationsfvARB C.GPNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARB + gpNamedFramebufferSampleLocationsfvNV C.GPNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNV + gpNamedFramebufferTexture C.GPNAMEDFRAMEBUFFERTEXTURE + gpNamedFramebufferTexture1DEXT C.GPNAMEDFRAMEBUFFERTEXTURE1DEXT + gpNamedFramebufferTexture2DEXT C.GPNAMEDFRAMEBUFFERTEXTURE2DEXT + gpNamedFramebufferTexture3DEXT C.GPNAMEDFRAMEBUFFERTEXTURE3DEXT + gpNamedFramebufferTextureEXT C.GPNAMEDFRAMEBUFFERTEXTUREEXT + gpNamedFramebufferTextureFaceEXT C.GPNAMEDFRAMEBUFFERTEXTUREFACEEXT + gpNamedFramebufferTextureLayer C.GPNAMEDFRAMEBUFFERTEXTURELAYER + gpNamedFramebufferTextureLayerEXT C.GPNAMEDFRAMEBUFFERTEXTURELAYEREXT + gpNamedProgramLocalParameter4dEXT C.GPNAMEDPROGRAMLOCALPARAMETER4DEXT + gpNamedProgramLocalParameter4dvEXT C.GPNAMEDPROGRAMLOCALPARAMETER4DVEXT + gpNamedProgramLocalParameter4fEXT C.GPNAMEDPROGRAMLOCALPARAMETER4FEXT + gpNamedProgramLocalParameter4fvEXT C.GPNAMEDPROGRAMLOCALPARAMETER4FVEXT + gpNamedProgramLocalParameterI4iEXT C.GPNAMEDPROGRAMLOCALPARAMETERI4IEXT + gpNamedProgramLocalParameterI4ivEXT C.GPNAMEDPROGRAMLOCALPARAMETERI4IVEXT + gpNamedProgramLocalParameterI4uiEXT C.GPNAMEDPROGRAMLOCALPARAMETERI4UIEXT + gpNamedProgramLocalParameterI4uivEXT C.GPNAMEDPROGRAMLOCALPARAMETERI4UIVEXT + gpNamedProgramLocalParameters4fvEXT C.GPNAMEDPROGRAMLOCALPARAMETERS4FVEXT + gpNamedProgramLocalParametersI4ivEXT C.GPNAMEDPROGRAMLOCALPARAMETERSI4IVEXT + gpNamedProgramLocalParametersI4uivEXT C.GPNAMEDPROGRAMLOCALPARAMETERSI4UIVEXT + gpNamedProgramStringEXT C.GPNAMEDPROGRAMSTRINGEXT + gpNamedRenderbufferStorage C.GPNAMEDRENDERBUFFERSTORAGE + gpNamedRenderbufferStorageEXT C.GPNAMEDRENDERBUFFERSTORAGEEXT + gpNamedRenderbufferStorageMultisample C.GPNAMEDRENDERBUFFERSTORAGEMULTISAMPLE + gpNamedRenderbufferStorageMultisampleAdvancedAMD C.GPNAMEDRENDERBUFFERSTORAGEMULTISAMPLEADVANCEDAMD + gpNamedRenderbufferStorageMultisampleCoverageEXT C.GPNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXT + gpNamedRenderbufferStorageMultisampleEXT C.GPNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXT + gpNamedStringARB C.GPNAMEDSTRINGARB + gpNormalFormatNV C.GPNORMALFORMATNV + gpObjectLabel C.GPOBJECTLABEL + gpObjectLabelKHR C.GPOBJECTLABELKHR + gpObjectPtrLabel C.GPOBJECTPTRLABEL + gpObjectPtrLabelKHR C.GPOBJECTPTRLABELKHR + gpPatchParameterfv C.GPPATCHPARAMETERFV + gpPatchParameteri C.GPPATCHPARAMETERI + gpPathCommandsNV C.GPPATHCOMMANDSNV + gpPathCoordsNV C.GPPATHCOORDSNV + gpPathCoverDepthFuncNV C.GPPATHCOVERDEPTHFUNCNV + gpPathDashArrayNV C.GPPATHDASHARRAYNV + gpPathGlyphIndexArrayNV C.GPPATHGLYPHINDEXARRAYNV + gpPathGlyphIndexRangeNV C.GPPATHGLYPHINDEXRANGENV + gpPathGlyphRangeNV C.GPPATHGLYPHRANGENV + gpPathGlyphsNV C.GPPATHGLYPHSNV + gpPathMemoryGlyphIndexArrayNV C.GPPATHMEMORYGLYPHINDEXARRAYNV + gpPathParameterfNV C.GPPATHPARAMETERFNV + gpPathParameterfvNV C.GPPATHPARAMETERFVNV + gpPathParameteriNV C.GPPATHPARAMETERINV + gpPathParameterivNV C.GPPATHPARAMETERIVNV + gpPathStencilDepthOffsetNV C.GPPATHSTENCILDEPTHOFFSETNV + gpPathStencilFuncNV C.GPPATHSTENCILFUNCNV + gpPathStringNV C.GPPATHSTRINGNV + gpPathSubCommandsNV C.GPPATHSUBCOMMANDSNV + gpPathSubCoordsNV C.GPPATHSUBCOORDSNV + gpPauseTransformFeedback C.GPPAUSETRANSFORMFEEDBACK + gpPixelStoref C.GPPIXELSTOREF + gpPixelStorei C.GPPIXELSTOREI + gpPointAlongPathNV C.GPPOINTALONGPATHNV + gpPointParameterf C.GPPOINTPARAMETERF + gpPointParameterfv C.GPPOINTPARAMETERFV + gpPointParameteri C.GPPOINTPARAMETERI + gpPointParameteriv C.GPPOINTPARAMETERIV + gpPointSize C.GPPOINTSIZE + gpPolygonMode C.GPPOLYGONMODE + gpPolygonOffset C.GPPOLYGONOFFSET + gpPolygonOffsetClamp C.GPPOLYGONOFFSETCLAMP + gpPolygonOffsetClampEXT C.GPPOLYGONOFFSETCLAMPEXT + gpPopDebugGroup C.GPPOPDEBUGGROUP + gpPopDebugGroupKHR C.GPPOPDEBUGGROUPKHR + gpPopGroupMarkerEXT C.GPPOPGROUPMARKEREXT + gpPrimitiveBoundingBoxARB C.GPPRIMITIVEBOUNDINGBOXARB + gpPrimitiveRestartIndex C.GPPRIMITIVERESTARTINDEX + gpProgramBinary C.GPPROGRAMBINARY + gpProgramParameteri C.GPPROGRAMPARAMETERI + gpProgramParameteriARB C.GPPROGRAMPARAMETERIARB + gpProgramParameteriEXT C.GPPROGRAMPARAMETERIEXT + gpProgramPathFragmentInputGenNV C.GPPROGRAMPATHFRAGMENTINPUTGENNV + gpProgramUniform1d C.GPPROGRAMUNIFORM1D + gpProgramUniform1dEXT C.GPPROGRAMUNIFORM1DEXT + gpProgramUniform1dv C.GPPROGRAMUNIFORM1DV + gpProgramUniform1dvEXT C.GPPROGRAMUNIFORM1DVEXT + gpProgramUniform1f C.GPPROGRAMUNIFORM1F + gpProgramUniform1fEXT C.GPPROGRAMUNIFORM1FEXT + gpProgramUniform1fv C.GPPROGRAMUNIFORM1FV + gpProgramUniform1fvEXT C.GPPROGRAMUNIFORM1FVEXT + gpProgramUniform1i C.GPPROGRAMUNIFORM1I + gpProgramUniform1i64ARB C.GPPROGRAMUNIFORM1I64ARB + gpProgramUniform1i64NV C.GPPROGRAMUNIFORM1I64NV + gpProgramUniform1i64vARB C.GPPROGRAMUNIFORM1I64VARB + gpProgramUniform1i64vNV C.GPPROGRAMUNIFORM1I64VNV + gpProgramUniform1iEXT C.GPPROGRAMUNIFORM1IEXT + gpProgramUniform1iv C.GPPROGRAMUNIFORM1IV + gpProgramUniform1ivEXT C.GPPROGRAMUNIFORM1IVEXT + gpProgramUniform1ui C.GPPROGRAMUNIFORM1UI + gpProgramUniform1ui64ARB C.GPPROGRAMUNIFORM1UI64ARB + gpProgramUniform1ui64NV C.GPPROGRAMUNIFORM1UI64NV + gpProgramUniform1ui64vARB C.GPPROGRAMUNIFORM1UI64VARB + gpProgramUniform1ui64vNV C.GPPROGRAMUNIFORM1UI64VNV + gpProgramUniform1uiEXT C.GPPROGRAMUNIFORM1UIEXT + gpProgramUniform1uiv C.GPPROGRAMUNIFORM1UIV + gpProgramUniform1uivEXT C.GPPROGRAMUNIFORM1UIVEXT + gpProgramUniform2d C.GPPROGRAMUNIFORM2D + gpProgramUniform2dEXT C.GPPROGRAMUNIFORM2DEXT + gpProgramUniform2dv C.GPPROGRAMUNIFORM2DV + gpProgramUniform2dvEXT C.GPPROGRAMUNIFORM2DVEXT + gpProgramUniform2f C.GPPROGRAMUNIFORM2F + gpProgramUniform2fEXT C.GPPROGRAMUNIFORM2FEXT + gpProgramUniform2fv C.GPPROGRAMUNIFORM2FV + gpProgramUniform2fvEXT C.GPPROGRAMUNIFORM2FVEXT + gpProgramUniform2i C.GPPROGRAMUNIFORM2I + gpProgramUniform2i64ARB C.GPPROGRAMUNIFORM2I64ARB + gpProgramUniform2i64NV C.GPPROGRAMUNIFORM2I64NV + gpProgramUniform2i64vARB C.GPPROGRAMUNIFORM2I64VARB + gpProgramUniform2i64vNV C.GPPROGRAMUNIFORM2I64VNV + gpProgramUniform2iEXT C.GPPROGRAMUNIFORM2IEXT + gpProgramUniform2iv C.GPPROGRAMUNIFORM2IV + gpProgramUniform2ivEXT C.GPPROGRAMUNIFORM2IVEXT + gpProgramUniform2ui C.GPPROGRAMUNIFORM2UI + gpProgramUniform2ui64ARB C.GPPROGRAMUNIFORM2UI64ARB + gpProgramUniform2ui64NV C.GPPROGRAMUNIFORM2UI64NV + gpProgramUniform2ui64vARB C.GPPROGRAMUNIFORM2UI64VARB + gpProgramUniform2ui64vNV C.GPPROGRAMUNIFORM2UI64VNV + gpProgramUniform2uiEXT C.GPPROGRAMUNIFORM2UIEXT + gpProgramUniform2uiv C.GPPROGRAMUNIFORM2UIV + gpProgramUniform2uivEXT C.GPPROGRAMUNIFORM2UIVEXT + gpProgramUniform3d C.GPPROGRAMUNIFORM3D + gpProgramUniform3dEXT C.GPPROGRAMUNIFORM3DEXT + gpProgramUniform3dv C.GPPROGRAMUNIFORM3DV + gpProgramUniform3dvEXT C.GPPROGRAMUNIFORM3DVEXT + gpProgramUniform3f C.GPPROGRAMUNIFORM3F + gpProgramUniform3fEXT C.GPPROGRAMUNIFORM3FEXT + gpProgramUniform3fv C.GPPROGRAMUNIFORM3FV + gpProgramUniform3fvEXT C.GPPROGRAMUNIFORM3FVEXT + gpProgramUniform3i C.GPPROGRAMUNIFORM3I + gpProgramUniform3i64ARB C.GPPROGRAMUNIFORM3I64ARB + gpProgramUniform3i64NV C.GPPROGRAMUNIFORM3I64NV + gpProgramUniform3i64vARB C.GPPROGRAMUNIFORM3I64VARB + gpProgramUniform3i64vNV C.GPPROGRAMUNIFORM3I64VNV + gpProgramUniform3iEXT C.GPPROGRAMUNIFORM3IEXT + gpProgramUniform3iv C.GPPROGRAMUNIFORM3IV + gpProgramUniform3ivEXT C.GPPROGRAMUNIFORM3IVEXT + gpProgramUniform3ui C.GPPROGRAMUNIFORM3UI + gpProgramUniform3ui64ARB C.GPPROGRAMUNIFORM3UI64ARB + gpProgramUniform3ui64NV C.GPPROGRAMUNIFORM3UI64NV + gpProgramUniform3ui64vARB C.GPPROGRAMUNIFORM3UI64VARB + gpProgramUniform3ui64vNV C.GPPROGRAMUNIFORM3UI64VNV + gpProgramUniform3uiEXT C.GPPROGRAMUNIFORM3UIEXT + gpProgramUniform3uiv C.GPPROGRAMUNIFORM3UIV + gpProgramUniform3uivEXT C.GPPROGRAMUNIFORM3UIVEXT + gpProgramUniform4d C.GPPROGRAMUNIFORM4D + gpProgramUniform4dEXT C.GPPROGRAMUNIFORM4DEXT + gpProgramUniform4dv C.GPPROGRAMUNIFORM4DV + gpProgramUniform4dvEXT C.GPPROGRAMUNIFORM4DVEXT + gpProgramUniform4f C.GPPROGRAMUNIFORM4F + gpProgramUniform4fEXT C.GPPROGRAMUNIFORM4FEXT + gpProgramUniform4fv C.GPPROGRAMUNIFORM4FV + gpProgramUniform4fvEXT C.GPPROGRAMUNIFORM4FVEXT + gpProgramUniform4i C.GPPROGRAMUNIFORM4I + gpProgramUniform4i64ARB C.GPPROGRAMUNIFORM4I64ARB + gpProgramUniform4i64NV C.GPPROGRAMUNIFORM4I64NV + gpProgramUniform4i64vARB C.GPPROGRAMUNIFORM4I64VARB + gpProgramUniform4i64vNV C.GPPROGRAMUNIFORM4I64VNV + gpProgramUniform4iEXT C.GPPROGRAMUNIFORM4IEXT + gpProgramUniform4iv C.GPPROGRAMUNIFORM4IV + gpProgramUniform4ivEXT C.GPPROGRAMUNIFORM4IVEXT + gpProgramUniform4ui C.GPPROGRAMUNIFORM4UI + gpProgramUniform4ui64ARB C.GPPROGRAMUNIFORM4UI64ARB + gpProgramUniform4ui64NV C.GPPROGRAMUNIFORM4UI64NV + gpProgramUniform4ui64vARB C.GPPROGRAMUNIFORM4UI64VARB + gpProgramUniform4ui64vNV C.GPPROGRAMUNIFORM4UI64VNV + gpProgramUniform4uiEXT C.GPPROGRAMUNIFORM4UIEXT + gpProgramUniform4uiv C.GPPROGRAMUNIFORM4UIV + gpProgramUniform4uivEXT C.GPPROGRAMUNIFORM4UIVEXT + gpProgramUniformHandleui64ARB C.GPPROGRAMUNIFORMHANDLEUI64ARB + gpProgramUniformHandleui64NV C.GPPROGRAMUNIFORMHANDLEUI64NV + gpProgramUniformHandleui64vARB C.GPPROGRAMUNIFORMHANDLEUI64VARB + gpProgramUniformHandleui64vNV C.GPPROGRAMUNIFORMHANDLEUI64VNV + gpProgramUniformMatrix2dv C.GPPROGRAMUNIFORMMATRIX2DV + gpProgramUniformMatrix2dvEXT C.GPPROGRAMUNIFORMMATRIX2DVEXT + gpProgramUniformMatrix2fv C.GPPROGRAMUNIFORMMATRIX2FV + gpProgramUniformMatrix2fvEXT C.GPPROGRAMUNIFORMMATRIX2FVEXT + gpProgramUniformMatrix2x3dv C.GPPROGRAMUNIFORMMATRIX2X3DV + gpProgramUniformMatrix2x3dvEXT C.GPPROGRAMUNIFORMMATRIX2X3DVEXT + gpProgramUniformMatrix2x3fv C.GPPROGRAMUNIFORMMATRIX2X3FV + gpProgramUniformMatrix2x3fvEXT C.GPPROGRAMUNIFORMMATRIX2X3FVEXT + gpProgramUniformMatrix2x4dv C.GPPROGRAMUNIFORMMATRIX2X4DV + gpProgramUniformMatrix2x4dvEXT C.GPPROGRAMUNIFORMMATRIX2X4DVEXT + gpProgramUniformMatrix2x4fv C.GPPROGRAMUNIFORMMATRIX2X4FV + gpProgramUniformMatrix2x4fvEXT C.GPPROGRAMUNIFORMMATRIX2X4FVEXT + gpProgramUniformMatrix3dv C.GPPROGRAMUNIFORMMATRIX3DV + gpProgramUniformMatrix3dvEXT C.GPPROGRAMUNIFORMMATRIX3DVEXT + gpProgramUniformMatrix3fv C.GPPROGRAMUNIFORMMATRIX3FV + gpProgramUniformMatrix3fvEXT C.GPPROGRAMUNIFORMMATRIX3FVEXT + gpProgramUniformMatrix3x2dv C.GPPROGRAMUNIFORMMATRIX3X2DV + gpProgramUniformMatrix3x2dvEXT C.GPPROGRAMUNIFORMMATRIX3X2DVEXT + gpProgramUniformMatrix3x2fv C.GPPROGRAMUNIFORMMATRIX3X2FV + gpProgramUniformMatrix3x2fvEXT C.GPPROGRAMUNIFORMMATRIX3X2FVEXT + gpProgramUniformMatrix3x4dv C.GPPROGRAMUNIFORMMATRIX3X4DV + gpProgramUniformMatrix3x4dvEXT C.GPPROGRAMUNIFORMMATRIX3X4DVEXT + gpProgramUniformMatrix3x4fv C.GPPROGRAMUNIFORMMATRIX3X4FV + gpProgramUniformMatrix3x4fvEXT C.GPPROGRAMUNIFORMMATRIX3X4FVEXT + gpProgramUniformMatrix4dv C.GPPROGRAMUNIFORMMATRIX4DV + gpProgramUniformMatrix4dvEXT C.GPPROGRAMUNIFORMMATRIX4DVEXT + gpProgramUniformMatrix4fv C.GPPROGRAMUNIFORMMATRIX4FV + gpProgramUniformMatrix4fvEXT C.GPPROGRAMUNIFORMMATRIX4FVEXT + gpProgramUniformMatrix4x2dv C.GPPROGRAMUNIFORMMATRIX4X2DV + gpProgramUniformMatrix4x2dvEXT C.GPPROGRAMUNIFORMMATRIX4X2DVEXT + gpProgramUniformMatrix4x2fv C.GPPROGRAMUNIFORMMATRIX4X2FV + gpProgramUniformMatrix4x2fvEXT C.GPPROGRAMUNIFORMMATRIX4X2FVEXT + gpProgramUniformMatrix4x3dv C.GPPROGRAMUNIFORMMATRIX4X3DV + gpProgramUniformMatrix4x3dvEXT C.GPPROGRAMUNIFORMMATRIX4X3DVEXT + gpProgramUniformMatrix4x3fv C.GPPROGRAMUNIFORMMATRIX4X3FV + gpProgramUniformMatrix4x3fvEXT C.GPPROGRAMUNIFORMMATRIX4X3FVEXT + gpProgramUniformui64NV C.GPPROGRAMUNIFORMUI64NV + gpProgramUniformui64vNV C.GPPROGRAMUNIFORMUI64VNV + gpProvokingVertex C.GPPROVOKINGVERTEX + gpPushClientAttribDefaultEXT C.GPPUSHCLIENTATTRIBDEFAULTEXT + gpPushDebugGroup C.GPPUSHDEBUGGROUP + gpPushDebugGroupKHR C.GPPUSHDEBUGGROUPKHR + gpPushGroupMarkerEXT C.GPPUSHGROUPMARKEREXT + gpQueryCounter C.GPQUERYCOUNTER + gpRasterSamplesEXT C.GPRASTERSAMPLESEXT + gpReadBuffer C.GPREADBUFFER + gpReadPixels C.GPREADPIXELS + gpReadnPixels C.GPREADNPIXELS + gpReadnPixelsARB C.GPREADNPIXELSARB + gpReadnPixelsKHR C.GPREADNPIXELSKHR + gpReleaseShaderCompiler C.GPRELEASESHADERCOMPILER + gpRenderbufferStorage C.GPRENDERBUFFERSTORAGE + gpRenderbufferStorageMultisample C.GPRENDERBUFFERSTORAGEMULTISAMPLE + gpRenderbufferStorageMultisampleAdvancedAMD C.GPRENDERBUFFERSTORAGEMULTISAMPLEADVANCEDAMD + gpRenderbufferStorageMultisampleCoverageNV C.GPRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENV + gpResetMemoryObjectParameterNV C.GPRESETMEMORYOBJECTPARAMETERNV + gpResolveDepthValuesNV C.GPRESOLVEDEPTHVALUESNV + gpResumeTransformFeedback C.GPRESUMETRANSFORMFEEDBACK + gpSampleCoverage C.GPSAMPLECOVERAGE + gpSampleMaski C.GPSAMPLEMASKI + gpSamplerParameterIiv C.GPSAMPLERPARAMETERIIV + gpSamplerParameterIuiv C.GPSAMPLERPARAMETERIUIV + gpSamplerParameterf C.GPSAMPLERPARAMETERF + gpSamplerParameterfv C.GPSAMPLERPARAMETERFV + gpSamplerParameteri C.GPSAMPLERPARAMETERI + gpSamplerParameteriv C.GPSAMPLERPARAMETERIV + gpScissor C.GPSCISSOR + gpScissorArrayv C.GPSCISSORARRAYV + gpScissorExclusiveArrayvNV C.GPSCISSOREXCLUSIVEARRAYVNV + gpScissorExclusiveNV C.GPSCISSOREXCLUSIVENV + gpScissorIndexed C.GPSCISSORINDEXED + gpScissorIndexedv C.GPSCISSORINDEXEDV + gpSecondaryColorFormatNV C.GPSECONDARYCOLORFORMATNV + gpSelectPerfMonitorCountersAMD C.GPSELECTPERFMONITORCOUNTERSAMD + gpShaderBinary C.GPSHADERBINARY + gpShaderSource C.GPSHADERSOURCE + gpShaderStorageBlockBinding C.GPSHADERSTORAGEBLOCKBINDING + gpShadingRateImageBarrierNV C.GPSHADINGRATEIMAGEBARRIERNV + gpShadingRateImagePaletteNV C.GPSHADINGRATEIMAGEPALETTENV + gpShadingRateSampleOrderCustomNV C.GPSHADINGRATESAMPLEORDERCUSTOMNV + gpShadingRateSampleOrderNV C.GPSHADINGRATESAMPLEORDERNV + gpSignalVkFenceNV C.GPSIGNALVKFENCENV + gpSignalVkSemaphoreNV C.GPSIGNALVKSEMAPHORENV + gpSpecializeShaderARB C.GPSPECIALIZESHADERARB + gpStateCaptureNV C.GPSTATECAPTURENV + gpStencilFillPathInstancedNV C.GPSTENCILFILLPATHINSTANCEDNV + gpStencilFillPathNV C.GPSTENCILFILLPATHNV + gpStencilFunc C.GPSTENCILFUNC + gpStencilFuncSeparate C.GPSTENCILFUNCSEPARATE + gpStencilMask C.GPSTENCILMASK + gpStencilMaskSeparate C.GPSTENCILMASKSEPARATE + gpStencilOp C.GPSTENCILOP + gpStencilOpSeparate C.GPSTENCILOPSEPARATE + gpStencilStrokePathInstancedNV C.GPSTENCILSTROKEPATHINSTANCEDNV + gpStencilStrokePathNV C.GPSTENCILSTROKEPATHNV + gpStencilThenCoverFillPathInstancedNV C.GPSTENCILTHENCOVERFILLPATHINSTANCEDNV + gpStencilThenCoverFillPathNV C.GPSTENCILTHENCOVERFILLPATHNV + gpStencilThenCoverStrokePathInstancedNV C.GPSTENCILTHENCOVERSTROKEPATHINSTANCEDNV + gpStencilThenCoverStrokePathNV C.GPSTENCILTHENCOVERSTROKEPATHNV + gpSubpixelPrecisionBiasNV C.GPSUBPIXELPRECISIONBIASNV + gpTexAttachMemoryNV C.GPTEXATTACHMEMORYNV + gpTexBuffer C.GPTEXBUFFER + gpTexBufferARB C.GPTEXBUFFERARB + gpTexBufferRange C.GPTEXBUFFERRANGE + gpTexCoordFormatNV C.GPTEXCOORDFORMATNV + gpTexImage1D C.GPTEXIMAGE1D + gpTexImage2D C.GPTEXIMAGE2D + gpTexImage2DMultisample C.GPTEXIMAGE2DMULTISAMPLE + gpTexImage3D C.GPTEXIMAGE3D + gpTexImage3DMultisample C.GPTEXIMAGE3DMULTISAMPLE + gpTexPageCommitmentARB C.GPTEXPAGECOMMITMENTARB + gpTexPageCommitmentMemNV C.GPTEXPAGECOMMITMENTMEMNV + gpTexParameterIiv C.GPTEXPARAMETERIIV + gpTexParameterIuiv C.GPTEXPARAMETERIUIV + gpTexParameterf C.GPTEXPARAMETERF + gpTexParameterfv C.GPTEXPARAMETERFV + gpTexParameteri C.GPTEXPARAMETERI + gpTexParameteriv C.GPTEXPARAMETERIV + gpTexStorage1D C.GPTEXSTORAGE1D + gpTexStorage2D C.GPTEXSTORAGE2D + gpTexStorage2DMultisample C.GPTEXSTORAGE2DMULTISAMPLE + gpTexStorage3D C.GPTEXSTORAGE3D + gpTexStorage3DMultisample C.GPTEXSTORAGE3DMULTISAMPLE + gpTexSubImage1D C.GPTEXSUBIMAGE1D + gpTexSubImage2D C.GPTEXSUBIMAGE2D + gpTexSubImage3D C.GPTEXSUBIMAGE3D + gpTextureAttachMemoryNV C.GPTEXTUREATTACHMEMORYNV + gpTextureBarrier C.GPTEXTUREBARRIER + gpTextureBarrierNV C.GPTEXTUREBARRIERNV + gpTextureBuffer C.GPTEXTUREBUFFER + gpTextureBufferEXT C.GPTEXTUREBUFFEREXT + gpTextureBufferRange C.GPTEXTUREBUFFERRANGE + gpTextureBufferRangeEXT C.GPTEXTUREBUFFERRANGEEXT + gpTextureImage1DEXT C.GPTEXTUREIMAGE1DEXT + gpTextureImage2DEXT C.GPTEXTUREIMAGE2DEXT + gpTextureImage3DEXT C.GPTEXTUREIMAGE3DEXT + gpTexturePageCommitmentEXT C.GPTEXTUREPAGECOMMITMENTEXT + gpTexturePageCommitmentMemNV C.GPTEXTUREPAGECOMMITMENTMEMNV + gpTextureParameterIiv C.GPTEXTUREPARAMETERIIV + gpTextureParameterIivEXT C.GPTEXTUREPARAMETERIIVEXT + gpTextureParameterIuiv C.GPTEXTUREPARAMETERIUIV + gpTextureParameterIuivEXT C.GPTEXTUREPARAMETERIUIVEXT + gpTextureParameterf C.GPTEXTUREPARAMETERF + gpTextureParameterfEXT C.GPTEXTUREPARAMETERFEXT + gpTextureParameterfv C.GPTEXTUREPARAMETERFV + gpTextureParameterfvEXT C.GPTEXTUREPARAMETERFVEXT + gpTextureParameteri C.GPTEXTUREPARAMETERI + gpTextureParameteriEXT C.GPTEXTUREPARAMETERIEXT + gpTextureParameteriv C.GPTEXTUREPARAMETERIV + gpTextureParameterivEXT C.GPTEXTUREPARAMETERIVEXT + gpTextureRenderbufferEXT C.GPTEXTURERENDERBUFFEREXT + gpTextureStorage1D C.GPTEXTURESTORAGE1D + gpTextureStorage1DEXT C.GPTEXTURESTORAGE1DEXT + gpTextureStorage2D C.GPTEXTURESTORAGE2D + gpTextureStorage2DEXT C.GPTEXTURESTORAGE2DEXT + gpTextureStorage2DMultisample C.GPTEXTURESTORAGE2DMULTISAMPLE + gpTextureStorage2DMultisampleEXT C.GPTEXTURESTORAGE2DMULTISAMPLEEXT + gpTextureStorage3D C.GPTEXTURESTORAGE3D + gpTextureStorage3DEXT C.GPTEXTURESTORAGE3DEXT + gpTextureStorage3DMultisample C.GPTEXTURESTORAGE3DMULTISAMPLE + gpTextureStorage3DMultisampleEXT C.GPTEXTURESTORAGE3DMULTISAMPLEEXT + gpTextureSubImage1D C.GPTEXTURESUBIMAGE1D + gpTextureSubImage1DEXT C.GPTEXTURESUBIMAGE1DEXT + gpTextureSubImage2D C.GPTEXTURESUBIMAGE2D + gpTextureSubImage2DEXT C.GPTEXTURESUBIMAGE2DEXT + gpTextureSubImage3D C.GPTEXTURESUBIMAGE3D + gpTextureSubImage3DEXT C.GPTEXTURESUBIMAGE3DEXT + gpTextureView C.GPTEXTUREVIEW + gpTransformFeedbackBufferBase C.GPTRANSFORMFEEDBACKBUFFERBASE + gpTransformFeedbackBufferRange C.GPTRANSFORMFEEDBACKBUFFERRANGE + gpTransformFeedbackVaryings C.GPTRANSFORMFEEDBACKVARYINGS + gpTransformPathNV C.GPTRANSFORMPATHNV + gpUniform1d C.GPUNIFORM1D + gpUniform1dv C.GPUNIFORM1DV + gpUniform1f C.GPUNIFORM1F + gpUniform1fv C.GPUNIFORM1FV + gpUniform1i C.GPUNIFORM1I + gpUniform1i64ARB C.GPUNIFORM1I64ARB + gpUniform1i64NV C.GPUNIFORM1I64NV + gpUniform1i64vARB C.GPUNIFORM1I64VARB + gpUniform1i64vNV C.GPUNIFORM1I64VNV + gpUniform1iv C.GPUNIFORM1IV + gpUniform1ui C.GPUNIFORM1UI + gpUniform1ui64ARB C.GPUNIFORM1UI64ARB + gpUniform1ui64NV C.GPUNIFORM1UI64NV + gpUniform1ui64vARB C.GPUNIFORM1UI64VARB + gpUniform1ui64vNV C.GPUNIFORM1UI64VNV + gpUniform1uiv C.GPUNIFORM1UIV + gpUniform2d C.GPUNIFORM2D + gpUniform2dv C.GPUNIFORM2DV + gpUniform2f C.GPUNIFORM2F + gpUniform2fv C.GPUNIFORM2FV + gpUniform2i C.GPUNIFORM2I + gpUniform2i64ARB C.GPUNIFORM2I64ARB + gpUniform2i64NV C.GPUNIFORM2I64NV + gpUniform2i64vARB C.GPUNIFORM2I64VARB + gpUniform2i64vNV C.GPUNIFORM2I64VNV + gpUniform2iv C.GPUNIFORM2IV + gpUniform2ui C.GPUNIFORM2UI + gpUniform2ui64ARB C.GPUNIFORM2UI64ARB + gpUniform2ui64NV C.GPUNIFORM2UI64NV + gpUniform2ui64vARB C.GPUNIFORM2UI64VARB + gpUniform2ui64vNV C.GPUNIFORM2UI64VNV + gpUniform2uiv C.GPUNIFORM2UIV + gpUniform3d C.GPUNIFORM3D + gpUniform3dv C.GPUNIFORM3DV + gpUniform3f C.GPUNIFORM3F + gpUniform3fv C.GPUNIFORM3FV + gpUniform3i C.GPUNIFORM3I + gpUniform3i64ARB C.GPUNIFORM3I64ARB + gpUniform3i64NV C.GPUNIFORM3I64NV + gpUniform3i64vARB C.GPUNIFORM3I64VARB + gpUniform3i64vNV C.GPUNIFORM3I64VNV + gpUniform3iv C.GPUNIFORM3IV + gpUniform3ui C.GPUNIFORM3UI + gpUniform3ui64ARB C.GPUNIFORM3UI64ARB + gpUniform3ui64NV C.GPUNIFORM3UI64NV + gpUniform3ui64vARB C.GPUNIFORM3UI64VARB + gpUniform3ui64vNV C.GPUNIFORM3UI64VNV + gpUniform3uiv C.GPUNIFORM3UIV + gpUniform4d C.GPUNIFORM4D + gpUniform4dv C.GPUNIFORM4DV + gpUniform4f C.GPUNIFORM4F + gpUniform4fv C.GPUNIFORM4FV + gpUniform4i C.GPUNIFORM4I + gpUniform4i64ARB C.GPUNIFORM4I64ARB + gpUniform4i64NV C.GPUNIFORM4I64NV + gpUniform4i64vARB C.GPUNIFORM4I64VARB + gpUniform4i64vNV C.GPUNIFORM4I64VNV + gpUniform4iv C.GPUNIFORM4IV + gpUniform4ui C.GPUNIFORM4UI + gpUniform4ui64ARB C.GPUNIFORM4UI64ARB + gpUniform4ui64NV C.GPUNIFORM4UI64NV + gpUniform4ui64vARB C.GPUNIFORM4UI64VARB + gpUniform4ui64vNV C.GPUNIFORM4UI64VNV + gpUniform4uiv C.GPUNIFORM4UIV + gpUniformBlockBinding C.GPUNIFORMBLOCKBINDING + gpUniformHandleui64ARB C.GPUNIFORMHANDLEUI64ARB + gpUniformHandleui64NV C.GPUNIFORMHANDLEUI64NV + gpUniformHandleui64vARB C.GPUNIFORMHANDLEUI64VARB + gpUniformHandleui64vNV C.GPUNIFORMHANDLEUI64VNV + gpUniformMatrix2dv C.GPUNIFORMMATRIX2DV + gpUniformMatrix2fv C.GPUNIFORMMATRIX2FV + gpUniformMatrix2x3dv C.GPUNIFORMMATRIX2X3DV + gpUniformMatrix2x3fv C.GPUNIFORMMATRIX2X3FV + gpUniformMatrix2x4dv C.GPUNIFORMMATRIX2X4DV + gpUniformMatrix2x4fv C.GPUNIFORMMATRIX2X4FV + gpUniformMatrix3dv C.GPUNIFORMMATRIX3DV + gpUniformMatrix3fv C.GPUNIFORMMATRIX3FV + gpUniformMatrix3x2dv C.GPUNIFORMMATRIX3X2DV + gpUniformMatrix3x2fv C.GPUNIFORMMATRIX3X2FV + gpUniformMatrix3x4dv C.GPUNIFORMMATRIX3X4DV + gpUniformMatrix3x4fv C.GPUNIFORMMATRIX3X4FV + gpUniformMatrix4dv C.GPUNIFORMMATRIX4DV + gpUniformMatrix4fv C.GPUNIFORMMATRIX4FV + gpUniformMatrix4x2dv C.GPUNIFORMMATRIX4X2DV + gpUniformMatrix4x2fv C.GPUNIFORMMATRIX4X2FV + gpUniformMatrix4x3dv C.GPUNIFORMMATRIX4X3DV + gpUniformMatrix4x3fv C.GPUNIFORMMATRIX4X3FV + gpUniformSubroutinesuiv C.GPUNIFORMSUBROUTINESUIV + gpUniformui64NV C.GPUNIFORMUI64NV + gpUniformui64vNV C.GPUNIFORMUI64VNV + gpUnmapBuffer C.GPUNMAPBUFFER + gpUnmapNamedBuffer C.GPUNMAPNAMEDBUFFER + gpUnmapNamedBufferEXT C.GPUNMAPNAMEDBUFFEREXT + gpUseProgram C.GPUSEPROGRAM + gpUseProgramStages C.GPUSEPROGRAMSTAGES + gpUseProgramStagesEXT C.GPUSEPROGRAMSTAGESEXT + gpUseShaderProgramEXT C.GPUSESHADERPROGRAMEXT + gpValidateProgram C.GPVALIDATEPROGRAM + gpValidateProgramPipeline C.GPVALIDATEPROGRAMPIPELINE + gpValidateProgramPipelineEXT C.GPVALIDATEPROGRAMPIPELINEEXT + gpVertexArrayAttribBinding C.GPVERTEXARRAYATTRIBBINDING + gpVertexArrayAttribFormat C.GPVERTEXARRAYATTRIBFORMAT + gpVertexArrayAttribIFormat C.GPVERTEXARRAYATTRIBIFORMAT + gpVertexArrayAttribLFormat C.GPVERTEXARRAYATTRIBLFORMAT + gpVertexArrayBindVertexBufferEXT C.GPVERTEXARRAYBINDVERTEXBUFFEREXT + gpVertexArrayBindingDivisor C.GPVERTEXARRAYBINDINGDIVISOR + gpVertexArrayColorOffsetEXT C.GPVERTEXARRAYCOLOROFFSETEXT + gpVertexArrayEdgeFlagOffsetEXT C.GPVERTEXARRAYEDGEFLAGOFFSETEXT + gpVertexArrayElementBuffer C.GPVERTEXARRAYELEMENTBUFFER + gpVertexArrayFogCoordOffsetEXT C.GPVERTEXARRAYFOGCOORDOFFSETEXT + gpVertexArrayIndexOffsetEXT C.GPVERTEXARRAYINDEXOFFSETEXT + gpVertexArrayMultiTexCoordOffsetEXT C.GPVERTEXARRAYMULTITEXCOORDOFFSETEXT + gpVertexArrayNormalOffsetEXT C.GPVERTEXARRAYNORMALOFFSETEXT + gpVertexArraySecondaryColorOffsetEXT C.GPVERTEXARRAYSECONDARYCOLOROFFSETEXT + gpVertexArrayTexCoordOffsetEXT C.GPVERTEXARRAYTEXCOORDOFFSETEXT + gpVertexArrayVertexAttribBindingEXT C.GPVERTEXARRAYVERTEXATTRIBBINDINGEXT + gpVertexArrayVertexAttribDivisorEXT C.GPVERTEXARRAYVERTEXATTRIBDIVISOREXT + gpVertexArrayVertexAttribFormatEXT C.GPVERTEXARRAYVERTEXATTRIBFORMATEXT + gpVertexArrayVertexAttribIFormatEXT C.GPVERTEXARRAYVERTEXATTRIBIFORMATEXT + gpVertexArrayVertexAttribIOffsetEXT C.GPVERTEXARRAYVERTEXATTRIBIOFFSETEXT + gpVertexArrayVertexAttribLFormatEXT C.GPVERTEXARRAYVERTEXATTRIBLFORMATEXT + gpVertexArrayVertexAttribLOffsetEXT C.GPVERTEXARRAYVERTEXATTRIBLOFFSETEXT + gpVertexArrayVertexAttribOffsetEXT C.GPVERTEXARRAYVERTEXATTRIBOFFSETEXT + gpVertexArrayVertexBindingDivisorEXT C.GPVERTEXARRAYVERTEXBINDINGDIVISOREXT + gpVertexArrayVertexBuffer C.GPVERTEXARRAYVERTEXBUFFER + gpVertexArrayVertexBuffers C.GPVERTEXARRAYVERTEXBUFFERS + gpVertexArrayVertexOffsetEXT C.GPVERTEXARRAYVERTEXOFFSETEXT + gpVertexAttrib1d C.GPVERTEXATTRIB1D + gpVertexAttrib1dv C.GPVERTEXATTRIB1DV + gpVertexAttrib1f C.GPVERTEXATTRIB1F + gpVertexAttrib1fv C.GPVERTEXATTRIB1FV + gpVertexAttrib1s C.GPVERTEXATTRIB1S + gpVertexAttrib1sv C.GPVERTEXATTRIB1SV + gpVertexAttrib2d C.GPVERTEXATTRIB2D + gpVertexAttrib2dv C.GPVERTEXATTRIB2DV + gpVertexAttrib2f C.GPVERTEXATTRIB2F + gpVertexAttrib2fv C.GPVERTEXATTRIB2FV + gpVertexAttrib2s C.GPVERTEXATTRIB2S + gpVertexAttrib2sv C.GPVERTEXATTRIB2SV + gpVertexAttrib3d C.GPVERTEXATTRIB3D + gpVertexAttrib3dv C.GPVERTEXATTRIB3DV + gpVertexAttrib3f C.GPVERTEXATTRIB3F + gpVertexAttrib3fv C.GPVERTEXATTRIB3FV + gpVertexAttrib3s C.GPVERTEXATTRIB3S + gpVertexAttrib3sv C.GPVERTEXATTRIB3SV + gpVertexAttrib4Nbv C.GPVERTEXATTRIB4NBV + gpVertexAttrib4Niv C.GPVERTEXATTRIB4NIV + gpVertexAttrib4Nsv C.GPVERTEXATTRIB4NSV + gpVertexAttrib4Nub C.GPVERTEXATTRIB4NUB + gpVertexAttrib4Nubv C.GPVERTEXATTRIB4NUBV + gpVertexAttrib4Nuiv C.GPVERTEXATTRIB4NUIV + gpVertexAttrib4Nusv C.GPVERTEXATTRIB4NUSV + gpVertexAttrib4bv C.GPVERTEXATTRIB4BV + gpVertexAttrib4d C.GPVERTEXATTRIB4D + gpVertexAttrib4dv C.GPVERTEXATTRIB4DV + gpVertexAttrib4f C.GPVERTEXATTRIB4F + gpVertexAttrib4fv C.GPVERTEXATTRIB4FV + gpVertexAttrib4iv C.GPVERTEXATTRIB4IV + gpVertexAttrib4s C.GPVERTEXATTRIB4S + gpVertexAttrib4sv C.GPVERTEXATTRIB4SV + gpVertexAttrib4ubv C.GPVERTEXATTRIB4UBV + gpVertexAttrib4uiv C.GPVERTEXATTRIB4UIV + gpVertexAttrib4usv C.GPVERTEXATTRIB4USV + gpVertexAttribBinding C.GPVERTEXATTRIBBINDING + gpVertexAttribDivisor C.GPVERTEXATTRIBDIVISOR + gpVertexAttribDivisorARB C.GPVERTEXATTRIBDIVISORARB + gpVertexAttribFormat C.GPVERTEXATTRIBFORMAT + gpVertexAttribFormatNV C.GPVERTEXATTRIBFORMATNV + gpVertexAttribI1i C.GPVERTEXATTRIBI1I + gpVertexAttribI1iv C.GPVERTEXATTRIBI1IV + gpVertexAttribI1ui C.GPVERTEXATTRIBI1UI + gpVertexAttribI1uiv C.GPVERTEXATTRIBI1UIV + gpVertexAttribI2i C.GPVERTEXATTRIBI2I + gpVertexAttribI2iv C.GPVERTEXATTRIBI2IV + gpVertexAttribI2ui C.GPVERTEXATTRIBI2UI + gpVertexAttribI2uiv C.GPVERTEXATTRIBI2UIV + gpVertexAttribI3i C.GPVERTEXATTRIBI3I + gpVertexAttribI3iv C.GPVERTEXATTRIBI3IV + gpVertexAttribI3ui C.GPVERTEXATTRIBI3UI + gpVertexAttribI3uiv C.GPVERTEXATTRIBI3UIV + gpVertexAttribI4bv C.GPVERTEXATTRIBI4BV + gpVertexAttribI4i C.GPVERTEXATTRIBI4I + gpVertexAttribI4iv C.GPVERTEXATTRIBI4IV + gpVertexAttribI4sv C.GPVERTEXATTRIBI4SV + gpVertexAttribI4ubv C.GPVERTEXATTRIBI4UBV + gpVertexAttribI4ui C.GPVERTEXATTRIBI4UI + gpVertexAttribI4uiv C.GPVERTEXATTRIBI4UIV + gpVertexAttribI4usv C.GPVERTEXATTRIBI4USV + gpVertexAttribIFormat C.GPVERTEXATTRIBIFORMAT + gpVertexAttribIFormatNV C.GPVERTEXATTRIBIFORMATNV + gpVertexAttribIPointer C.GPVERTEXATTRIBIPOINTER + gpVertexAttribL1d C.GPVERTEXATTRIBL1D + gpVertexAttribL1dv C.GPVERTEXATTRIBL1DV + gpVertexAttribL1i64NV C.GPVERTEXATTRIBL1I64NV + gpVertexAttribL1i64vNV C.GPVERTEXATTRIBL1I64VNV + gpVertexAttribL1ui64ARB C.GPVERTEXATTRIBL1UI64ARB + gpVertexAttribL1ui64NV C.GPVERTEXATTRIBL1UI64NV + gpVertexAttribL1ui64vARB C.GPVERTEXATTRIBL1UI64VARB + gpVertexAttribL1ui64vNV C.GPVERTEXATTRIBL1UI64VNV + gpVertexAttribL2d C.GPVERTEXATTRIBL2D + gpVertexAttribL2dv C.GPVERTEXATTRIBL2DV + gpVertexAttribL2i64NV C.GPVERTEXATTRIBL2I64NV + gpVertexAttribL2i64vNV C.GPVERTEXATTRIBL2I64VNV + gpVertexAttribL2ui64NV C.GPVERTEXATTRIBL2UI64NV + gpVertexAttribL2ui64vNV C.GPVERTEXATTRIBL2UI64VNV + gpVertexAttribL3d C.GPVERTEXATTRIBL3D + gpVertexAttribL3dv C.GPVERTEXATTRIBL3DV + gpVertexAttribL3i64NV C.GPVERTEXATTRIBL3I64NV + gpVertexAttribL3i64vNV C.GPVERTEXATTRIBL3I64VNV + gpVertexAttribL3ui64NV C.GPVERTEXATTRIBL3UI64NV + gpVertexAttribL3ui64vNV C.GPVERTEXATTRIBL3UI64VNV + gpVertexAttribL4d C.GPVERTEXATTRIBL4D + gpVertexAttribL4dv C.GPVERTEXATTRIBL4DV + gpVertexAttribL4i64NV C.GPVERTEXATTRIBL4I64NV + gpVertexAttribL4i64vNV C.GPVERTEXATTRIBL4I64VNV + gpVertexAttribL4ui64NV C.GPVERTEXATTRIBL4UI64NV + gpVertexAttribL4ui64vNV C.GPVERTEXATTRIBL4UI64VNV + gpVertexAttribLFormat C.GPVERTEXATTRIBLFORMAT + gpVertexAttribLFormatNV C.GPVERTEXATTRIBLFORMATNV + gpVertexAttribLPointer C.GPVERTEXATTRIBLPOINTER + gpVertexAttribP1ui C.GPVERTEXATTRIBP1UI + gpVertexAttribP1uiv C.GPVERTEXATTRIBP1UIV + gpVertexAttribP2ui C.GPVERTEXATTRIBP2UI + gpVertexAttribP2uiv C.GPVERTEXATTRIBP2UIV + gpVertexAttribP3ui C.GPVERTEXATTRIBP3UI + gpVertexAttribP3uiv C.GPVERTEXATTRIBP3UIV + gpVertexAttribP4ui C.GPVERTEXATTRIBP4UI + gpVertexAttribP4uiv C.GPVERTEXATTRIBP4UIV + gpVertexAttribPointer C.GPVERTEXATTRIBPOINTER + gpVertexBindingDivisor C.GPVERTEXBINDINGDIVISOR + gpVertexFormatNV C.GPVERTEXFORMATNV + gpViewport C.GPVIEWPORT + gpViewportArrayv C.GPVIEWPORTARRAYV + gpViewportIndexedf C.GPVIEWPORTINDEXEDF + gpViewportIndexedfv C.GPVIEWPORTINDEXEDFV + gpViewportPositionWScaleNV C.GPVIEWPORTPOSITIONWSCALENV + gpViewportSwizzleNV C.GPVIEWPORTSWIZZLENV + gpWaitSync C.GPWAITSYNC + gpWaitVkSemaphoreNV C.GPWAITVKSEMAPHORENV + gpWeightPathsNV C.GPWEIGHTPATHSNV + gpWindowRectanglesEXT C.GPWINDOWRECTANGLESEXT +) + +// Helper functions +func boolToInt(b bool) int { + if b { + return 1 + } + return 0 +} +func ActiveProgramEXT(program uint32) { + C.glowActiveProgramEXT(gpActiveProgramEXT, (C.GLuint)(program)) +} + +// set the active program object for a program pipeline object +func ActiveShaderProgram(pipeline uint32, program uint32) { + C.glowActiveShaderProgram(gpActiveShaderProgram, (C.GLuint)(pipeline), (C.GLuint)(program)) +} +func ActiveShaderProgramEXT(pipeline uint32, program uint32) { + C.glowActiveShaderProgramEXT(gpActiveShaderProgramEXT, (C.GLuint)(pipeline), (C.GLuint)(program)) +} + +// select active texture unit +func ActiveTexture(texture uint32) { + C.glowActiveTexture(gpActiveTexture, (C.GLenum)(texture)) +} +func ApplyFramebufferAttachmentCMAAINTEL() { + C.glowApplyFramebufferAttachmentCMAAINTEL(gpApplyFramebufferAttachmentCMAAINTEL) +} + +// Attaches a shader object to a program object +func AttachShader(program uint32, shader uint32) { + C.glowAttachShader(gpAttachShader, (C.GLuint)(program), (C.GLuint)(shader)) +} + +// start conditional rendering +func BeginConditionalRender(id uint32, mode uint32) { + C.glowBeginConditionalRender(gpBeginConditionalRender, (C.GLuint)(id), (C.GLenum)(mode)) +} +func BeginConditionalRenderNV(id uint32, mode uint32) { + C.glowBeginConditionalRenderNV(gpBeginConditionalRenderNV, (C.GLuint)(id), (C.GLenum)(mode)) +} +func BeginPerfMonitorAMD(monitor uint32) { + C.glowBeginPerfMonitorAMD(gpBeginPerfMonitorAMD, (C.GLuint)(monitor)) +} +func BeginPerfQueryINTEL(queryHandle uint32) { + C.glowBeginPerfQueryINTEL(gpBeginPerfQueryINTEL, (C.GLuint)(queryHandle)) +} + +// delimit the boundaries of a query object +func BeginQuery(target uint32, id uint32) { + C.glowBeginQuery(gpBeginQuery, (C.GLenum)(target), (C.GLuint)(id)) +} +func BeginQueryIndexed(target uint32, index uint32, id uint32) { + C.glowBeginQueryIndexed(gpBeginQueryIndexed, (C.GLenum)(target), (C.GLuint)(index), (C.GLuint)(id)) +} + +// start transform feedback operation +func BeginTransformFeedback(primitiveMode uint32) { + C.glowBeginTransformFeedback(gpBeginTransformFeedback, (C.GLenum)(primitiveMode)) +} + +// Associates a generic vertex attribute index with a named attribute variable +func BindAttribLocation(program uint32, index uint32, name *uint8) { + C.glowBindAttribLocation(gpBindAttribLocation, (C.GLuint)(program), (C.GLuint)(index), (*C.GLchar)(unsafe.Pointer(name))) +} + +// bind a named buffer object +func BindBuffer(target uint32, buffer uint32) { + C.glowBindBuffer(gpBindBuffer, (C.GLenum)(target), (C.GLuint)(buffer)) +} + +// bind a buffer object to an indexed buffer target +func BindBufferBase(target uint32, index uint32, buffer uint32) { + C.glowBindBufferBase(gpBindBufferBase, (C.GLenum)(target), (C.GLuint)(index), (C.GLuint)(buffer)) +} + +// bind a range within a buffer object to an indexed buffer target +func BindBufferRange(target uint32, index uint32, buffer uint32, offset int, size int) { + C.glowBindBufferRange(gpBindBufferRange, (C.GLenum)(target), (C.GLuint)(index), (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(size)) +} + +// bind one or more buffer objects to a sequence of indexed buffer targets +func BindBuffersBase(target uint32, first uint32, count int32, buffers *uint32) { + C.glowBindBuffersBase(gpBindBuffersBase, (C.GLenum)(target), (C.GLuint)(first), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(buffers))) +} + +// bind ranges of one or more buffer objects to a sequence of indexed buffer targets +func BindBuffersRange(target uint32, first uint32, count int32, buffers *uint32, offsets *int, sizes *int) { + C.glowBindBuffersRange(gpBindBuffersRange, (C.GLenum)(target), (C.GLuint)(first), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(buffers)), (*C.GLintptr)(unsafe.Pointer(offsets)), (*C.GLsizeiptr)(unsafe.Pointer(sizes))) +} + +// bind a user-defined varying out variable to a fragment shader color number +func BindFragDataLocation(program uint32, color uint32, name *uint8) { + C.glowBindFragDataLocation(gpBindFragDataLocation, (C.GLuint)(program), (C.GLuint)(color), (*C.GLchar)(unsafe.Pointer(name))) +} + +// bind a user-defined varying out variable to a fragment shader color number and index +func BindFragDataLocationIndexed(program uint32, colorNumber uint32, index uint32, name *uint8) { + C.glowBindFragDataLocationIndexed(gpBindFragDataLocationIndexed, (C.GLuint)(program), (C.GLuint)(colorNumber), (C.GLuint)(index), (*C.GLchar)(unsafe.Pointer(name))) +} + +// bind a framebuffer to a framebuffer target +func BindFramebuffer(target uint32, framebuffer uint32) { + C.glowBindFramebuffer(gpBindFramebuffer, (C.GLenum)(target), (C.GLuint)(framebuffer)) +} + +// bind a level of a texture to an image unit +func BindImageTexture(unit uint32, texture uint32, level int32, layered bool, layer int32, access uint32, format uint32) { + C.glowBindImageTexture(gpBindImageTexture, (C.GLuint)(unit), (C.GLuint)(texture), (C.GLint)(level), (C.GLboolean)(boolToInt(layered)), (C.GLint)(layer), (C.GLenum)(access), (C.GLenum)(format)) +} + +// bind one or more named texture images to a sequence of consecutive image units +func BindImageTextures(first uint32, count int32, textures *uint32) { + C.glowBindImageTextures(gpBindImageTextures, (C.GLuint)(first), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(textures))) +} +func BindMultiTextureEXT(texunit uint32, target uint32, texture uint32) { + C.glowBindMultiTextureEXT(gpBindMultiTextureEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLuint)(texture)) +} + +// bind a program pipeline to the current context +func BindProgramPipeline(pipeline uint32) { + C.glowBindProgramPipeline(gpBindProgramPipeline, (C.GLuint)(pipeline)) +} +func BindProgramPipelineEXT(pipeline uint32) { + C.glowBindProgramPipelineEXT(gpBindProgramPipelineEXT, (C.GLuint)(pipeline)) +} + +// bind a renderbuffer to a renderbuffer target +func BindRenderbuffer(target uint32, renderbuffer uint32) { + C.glowBindRenderbuffer(gpBindRenderbuffer, (C.GLenum)(target), (C.GLuint)(renderbuffer)) +} + +// bind a named sampler to a texturing target +func BindSampler(unit uint32, sampler uint32) { + C.glowBindSampler(gpBindSampler, (C.GLuint)(unit), (C.GLuint)(sampler)) +} + +// bind one or more named sampler objects to a sequence of consecutive sampler units +func BindSamplers(first uint32, count int32, samplers *uint32) { + C.glowBindSamplers(gpBindSamplers, (C.GLuint)(first), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(samplers))) +} +func BindShadingRateImageNV(texture uint32) { + C.glowBindShadingRateImageNV(gpBindShadingRateImageNV, (C.GLuint)(texture)) +} + +// bind a named texture to a texturing target +func BindTexture(target uint32, texture uint32) { + C.glowBindTexture(gpBindTexture, (C.GLenum)(target), (C.GLuint)(texture)) +} + +// bind an existing texture object to the specified texture unit +func BindTextureUnit(unit uint32, texture uint32) { + C.glowBindTextureUnit(gpBindTextureUnit, (C.GLuint)(unit), (C.GLuint)(texture)) +} + +// bind one or more named textures to a sequence of consecutive texture units +func BindTextures(first uint32, count int32, textures *uint32) { + C.glowBindTextures(gpBindTextures, (C.GLuint)(first), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(textures))) +} + +// bind a transform feedback object +func BindTransformFeedback(target uint32, id uint32) { + C.glowBindTransformFeedback(gpBindTransformFeedback, (C.GLenum)(target), (C.GLuint)(id)) +} + +// bind a vertex array object +func BindVertexArray(array uint32) { + C.glowBindVertexArray(gpBindVertexArray, (C.GLuint)(array)) +} + +// bind a buffer to a vertex buffer bind point +func BindVertexBuffer(bindingindex uint32, buffer uint32, offset int, stride int32) { + C.glowBindVertexBuffer(gpBindVertexBuffer, (C.GLuint)(bindingindex), (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizei)(stride)) +} + +// attach multiple buffer objects to a vertex array object +func BindVertexBuffers(first uint32, count int32, buffers *uint32, offsets *int, strides *int32) { + C.glowBindVertexBuffers(gpBindVertexBuffers, (C.GLuint)(first), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(buffers)), (*C.GLintptr)(unsafe.Pointer(offsets)), (*C.GLsizei)(unsafe.Pointer(strides))) +} +func BlendBarrierKHR() { + C.glowBlendBarrierKHR(gpBlendBarrierKHR) +} +func BlendBarrierNV() { + C.glowBlendBarrierNV(gpBlendBarrierNV) +} + +// set the blend color +func BlendColor(red float32, green float32, blue float32, alpha float32) { + C.glowBlendColor(gpBlendColor, (C.GLfloat)(red), (C.GLfloat)(green), (C.GLfloat)(blue), (C.GLfloat)(alpha)) +} + +// specify the equation used for both the RGB blend equation and the Alpha blend equation +func BlendEquation(mode uint32) { + C.glowBlendEquation(gpBlendEquation, (C.GLenum)(mode)) +} + +// set the RGB blend equation and the alpha blend equation separately +func BlendEquationSeparate(modeRGB uint32, modeAlpha uint32) { + C.glowBlendEquationSeparate(gpBlendEquationSeparate, (C.GLenum)(modeRGB), (C.GLenum)(modeAlpha)) +} +func BlendEquationSeparateiARB(buf uint32, modeRGB uint32, modeAlpha uint32) { + C.glowBlendEquationSeparateiARB(gpBlendEquationSeparateiARB, (C.GLuint)(buf), (C.GLenum)(modeRGB), (C.GLenum)(modeAlpha)) +} +func BlendEquationiARB(buf uint32, mode uint32) { + C.glowBlendEquationiARB(gpBlendEquationiARB, (C.GLuint)(buf), (C.GLenum)(mode)) +} + +// specify pixel arithmetic +func BlendFunc(sfactor uint32, dfactor uint32) { + C.glowBlendFunc(gpBlendFunc, (C.GLenum)(sfactor), (C.GLenum)(dfactor)) +} + +// specify pixel arithmetic for RGB and alpha components separately +func BlendFuncSeparate(sfactorRGB uint32, dfactorRGB uint32, sfactorAlpha uint32, dfactorAlpha uint32) { + C.glowBlendFuncSeparate(gpBlendFuncSeparate, (C.GLenum)(sfactorRGB), (C.GLenum)(dfactorRGB), (C.GLenum)(sfactorAlpha), (C.GLenum)(dfactorAlpha)) +} +func BlendFuncSeparateiARB(buf uint32, srcRGB uint32, dstRGB uint32, srcAlpha uint32, dstAlpha uint32) { + C.glowBlendFuncSeparateiARB(gpBlendFuncSeparateiARB, (C.GLuint)(buf), (C.GLenum)(srcRGB), (C.GLenum)(dstRGB), (C.GLenum)(srcAlpha), (C.GLenum)(dstAlpha)) +} +func BlendFunciARB(buf uint32, src uint32, dst uint32) { + C.glowBlendFunciARB(gpBlendFunciARB, (C.GLuint)(buf), (C.GLenum)(src), (C.GLenum)(dst)) +} +func BlendParameteriNV(pname uint32, value int32) { + C.glowBlendParameteriNV(gpBlendParameteriNV, (C.GLenum)(pname), (C.GLint)(value)) +} + +// copy a block of pixels from one framebuffer object to another +func BlitFramebuffer(srcX0 int32, srcY0 int32, srcX1 int32, srcY1 int32, dstX0 int32, dstY0 int32, dstX1 int32, dstY1 int32, mask uint32, filter uint32) { + C.glowBlitFramebuffer(gpBlitFramebuffer, (C.GLint)(srcX0), (C.GLint)(srcY0), (C.GLint)(srcX1), (C.GLint)(srcY1), (C.GLint)(dstX0), (C.GLint)(dstY0), (C.GLint)(dstX1), (C.GLint)(dstY1), (C.GLbitfield)(mask), (C.GLenum)(filter)) +} + +// copy a block of pixels from one framebuffer object to another +func BlitNamedFramebuffer(readFramebuffer uint32, drawFramebuffer uint32, srcX0 int32, srcY0 int32, srcX1 int32, srcY1 int32, dstX0 int32, dstY0 int32, dstX1 int32, dstY1 int32, mask uint32, filter uint32) { + C.glowBlitNamedFramebuffer(gpBlitNamedFramebuffer, (C.GLuint)(readFramebuffer), (C.GLuint)(drawFramebuffer), (C.GLint)(srcX0), (C.GLint)(srcY0), (C.GLint)(srcX1), (C.GLint)(srcY1), (C.GLint)(dstX0), (C.GLint)(dstY0), (C.GLint)(dstX1), (C.GLint)(dstY1), (C.GLbitfield)(mask), (C.GLenum)(filter)) +} +func BufferAddressRangeNV(pname uint32, index uint32, address uint64, length int) { + C.glowBufferAddressRangeNV(gpBufferAddressRangeNV, (C.GLenum)(pname), (C.GLuint)(index), (C.GLuint64EXT)(address), (C.GLsizeiptr)(length)) +} +func BufferAttachMemoryNV(target uint32, memory uint32, offset uint64) { + C.glowBufferAttachMemoryNV(gpBufferAttachMemoryNV, (C.GLenum)(target), (C.GLuint)(memory), (C.GLuint64)(offset)) +} + +// creates and initializes a buffer object's data store +func BufferData(target uint32, size int, data unsafe.Pointer, usage uint32) { + C.glowBufferData(gpBufferData, (C.GLenum)(target), (C.GLsizeiptr)(size), data, (C.GLenum)(usage)) +} +func BufferPageCommitmentARB(target uint32, offset int, size int, commit bool) { + C.glowBufferPageCommitmentARB(gpBufferPageCommitmentARB, (C.GLenum)(target), (C.GLintptr)(offset), (C.GLsizeiptr)(size), (C.GLboolean)(boolToInt(commit))) +} +func BufferPageCommitmentMemNV(target uint32, offset int, size int, memory uint32, memOffset uint64, commit bool) { + C.glowBufferPageCommitmentMemNV(gpBufferPageCommitmentMemNV, (C.GLenum)(target), (C.GLintptr)(offset), (C.GLsizeiptr)(size), (C.GLuint)(memory), (C.GLuint64)(memOffset), (C.GLboolean)(boolToInt(commit))) +} + +// creates and initializes a buffer object's immutable data store +func BufferStorage(target uint32, size int, data unsafe.Pointer, flags uint32) { + C.glowBufferStorage(gpBufferStorage, (C.GLenum)(target), (C.GLsizeiptr)(size), data, (C.GLbitfield)(flags)) +} + +// updates a subset of a buffer object's data store +func BufferSubData(target uint32, offset int, size int, data unsafe.Pointer) { + C.glowBufferSubData(gpBufferSubData, (C.GLenum)(target), (C.GLintptr)(offset), (C.GLsizeiptr)(size), data) +} +func CallCommandListNV(list uint32) { + C.glowCallCommandListNV(gpCallCommandListNV, (C.GLuint)(list)) +} + +// check the completeness status of a framebuffer +func CheckFramebufferStatus(target uint32) uint32 { + ret := C.glowCheckFramebufferStatus(gpCheckFramebufferStatus, (C.GLenum)(target)) + return (uint32)(ret) +} + +// check the completeness status of a framebuffer +func CheckNamedFramebufferStatus(framebuffer uint32, target uint32) uint32 { + ret := C.glowCheckNamedFramebufferStatus(gpCheckNamedFramebufferStatus, (C.GLuint)(framebuffer), (C.GLenum)(target)) + return (uint32)(ret) +} +func CheckNamedFramebufferStatusEXT(framebuffer uint32, target uint32) uint32 { + ret := C.glowCheckNamedFramebufferStatusEXT(gpCheckNamedFramebufferStatusEXT, (C.GLuint)(framebuffer), (C.GLenum)(target)) + return (uint32)(ret) +} + +// specify whether data read via should be clamped +func ClampColor(target uint32, clamp uint32) { + C.glowClampColor(gpClampColor, (C.GLenum)(target), (C.GLenum)(clamp)) +} + +// clear buffers to preset values +func Clear(mask uint32) { + C.glowClear(gpClear, (C.GLbitfield)(mask)) +} + +// fill a buffer object's data store with a fixed value +func ClearBufferData(target uint32, internalformat uint32, format uint32, xtype uint32, data unsafe.Pointer) { + C.glowClearBufferData(gpClearBufferData, (C.GLenum)(target), (C.GLenum)(internalformat), (C.GLenum)(format), (C.GLenum)(xtype), data) +} + +// fill all or part of buffer object's data store with a fixed value +func ClearBufferSubData(target uint32, internalformat uint32, offset int, size int, format uint32, xtype uint32, data unsafe.Pointer) { + C.glowClearBufferSubData(gpClearBufferSubData, (C.GLenum)(target), (C.GLenum)(internalformat), (C.GLintptr)(offset), (C.GLsizeiptr)(size), (C.GLenum)(format), (C.GLenum)(xtype), data) +} +func ClearBufferfi(buffer uint32, drawbuffer int32, depth float32, stencil int32) { + C.glowClearBufferfi(gpClearBufferfi, (C.GLenum)(buffer), (C.GLint)(drawbuffer), (C.GLfloat)(depth), (C.GLint)(stencil)) +} +func ClearBufferfv(buffer uint32, drawbuffer int32, value *float32) { + C.glowClearBufferfv(gpClearBufferfv, (C.GLenum)(buffer), (C.GLint)(drawbuffer), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ClearBufferiv(buffer uint32, drawbuffer int32, value *int32) { + C.glowClearBufferiv(gpClearBufferiv, (C.GLenum)(buffer), (C.GLint)(drawbuffer), (*C.GLint)(unsafe.Pointer(value))) +} +func ClearBufferuiv(buffer uint32, drawbuffer int32, value *uint32) { + C.glowClearBufferuiv(gpClearBufferuiv, (C.GLenum)(buffer), (C.GLint)(drawbuffer), (*C.GLuint)(unsafe.Pointer(value))) +} + +// specify clear values for the color buffers +func ClearColor(red float32, green float32, blue float32, alpha float32) { + C.glowClearColor(gpClearColor, (C.GLfloat)(red), (C.GLfloat)(green), (C.GLfloat)(blue), (C.GLfloat)(alpha)) +} + +// specify the clear value for the depth buffer +func ClearDepth(depth float64) { + C.glowClearDepth(gpClearDepth, (C.GLdouble)(depth)) +} +func ClearDepthdNV(depth float64) { + C.glowClearDepthdNV(gpClearDepthdNV, (C.GLdouble)(depth)) +} + +// specify the clear value for the depth buffer +func ClearDepthf(d float32) { + C.glowClearDepthf(gpClearDepthf, (C.GLfloat)(d)) +} + +// fill a buffer object's data store with a fixed value +func ClearNamedBufferData(buffer uint32, internalformat uint32, format uint32, xtype uint32, data unsafe.Pointer) { + C.glowClearNamedBufferData(gpClearNamedBufferData, (C.GLuint)(buffer), (C.GLenum)(internalformat), (C.GLenum)(format), (C.GLenum)(xtype), data) +} +func ClearNamedBufferDataEXT(buffer uint32, internalformat uint32, format uint32, xtype uint32, data unsafe.Pointer) { + C.glowClearNamedBufferDataEXT(gpClearNamedBufferDataEXT, (C.GLuint)(buffer), (C.GLenum)(internalformat), (C.GLenum)(format), (C.GLenum)(xtype), data) +} + +// fill all or part of buffer object's data store with a fixed value +func ClearNamedBufferSubData(buffer uint32, internalformat uint32, offset int, size int, format uint32, xtype uint32, data unsafe.Pointer) { + C.glowClearNamedBufferSubData(gpClearNamedBufferSubData, (C.GLuint)(buffer), (C.GLenum)(internalformat), (C.GLintptr)(offset), (C.GLsizeiptr)(size), (C.GLenum)(format), (C.GLenum)(xtype), data) +} +func ClearNamedBufferSubDataEXT(buffer uint32, internalformat uint32, offset int, size int, format uint32, xtype uint32, data unsafe.Pointer) { + C.glowClearNamedBufferSubDataEXT(gpClearNamedBufferSubDataEXT, (C.GLuint)(buffer), (C.GLenum)(internalformat), (C.GLsizeiptr)(offset), (C.GLsizeiptr)(size), (C.GLenum)(format), (C.GLenum)(xtype), data) +} +func ClearNamedFramebufferfi(framebuffer uint32, buffer uint32, drawbuffer int32, depth float32, stencil int32) { + C.glowClearNamedFramebufferfi(gpClearNamedFramebufferfi, (C.GLuint)(framebuffer), (C.GLenum)(buffer), (C.GLint)(drawbuffer), (C.GLfloat)(depth), (C.GLint)(stencil)) +} +func ClearNamedFramebufferfv(framebuffer uint32, buffer uint32, drawbuffer int32, value *float32) { + C.glowClearNamedFramebufferfv(gpClearNamedFramebufferfv, (C.GLuint)(framebuffer), (C.GLenum)(buffer), (C.GLint)(drawbuffer), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ClearNamedFramebufferiv(framebuffer uint32, buffer uint32, drawbuffer int32, value *int32) { + C.glowClearNamedFramebufferiv(gpClearNamedFramebufferiv, (C.GLuint)(framebuffer), (C.GLenum)(buffer), (C.GLint)(drawbuffer), (*C.GLint)(unsafe.Pointer(value))) +} +func ClearNamedFramebufferuiv(framebuffer uint32, buffer uint32, drawbuffer int32, value *uint32) { + C.glowClearNamedFramebufferuiv(gpClearNamedFramebufferuiv, (C.GLuint)(framebuffer), (C.GLenum)(buffer), (C.GLint)(drawbuffer), (*C.GLuint)(unsafe.Pointer(value))) +} + +// specify the clear value for the stencil buffer +func ClearStencil(s int32) { + C.glowClearStencil(gpClearStencil, (C.GLint)(s)) +} + +// fills all a texture image with a constant value +func ClearTexImage(texture uint32, level int32, format uint32, xtype uint32, data unsafe.Pointer) { + C.glowClearTexImage(gpClearTexImage, (C.GLuint)(texture), (C.GLint)(level), (C.GLenum)(format), (C.GLenum)(xtype), data) +} + +// fills all or part of a texture image with a constant value +func ClearTexSubImage(texture uint32, level int32, xoffset int32, yoffset int32, zoffset int32, width int32, height int32, depth int32, format uint32, xtype uint32, data unsafe.Pointer) { + C.glowClearTexSubImage(gpClearTexSubImage, (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLenum)(format), (C.GLenum)(xtype), data) +} +func ClientAttribDefaultEXT(mask uint32) { + C.glowClientAttribDefaultEXT(gpClientAttribDefaultEXT, (C.GLbitfield)(mask)) +} + +// block and wait for a sync object to become signaled +func ClientWaitSync(sync uintptr, flags uint32, timeout uint64) uint32 { + ret := C.glowClientWaitSync(gpClientWaitSync, (C.GLsync)(sync), (C.GLbitfield)(flags), (C.GLuint64)(timeout)) + return (uint32)(ret) +} + +// control clip coordinate to window coordinate behavior +func ClipControl(origin uint32, depth uint32) { + C.glowClipControl(gpClipControl, (C.GLenum)(origin), (C.GLenum)(depth)) +} +func ColorFormatNV(size int32, xtype uint32, stride int32) { + C.glowColorFormatNV(gpColorFormatNV, (C.GLint)(size), (C.GLenum)(xtype), (C.GLsizei)(stride)) +} +func ColorMask(red bool, green bool, blue bool, alpha bool) { + C.glowColorMask(gpColorMask, (C.GLboolean)(boolToInt(red)), (C.GLboolean)(boolToInt(green)), (C.GLboolean)(boolToInt(blue)), (C.GLboolean)(boolToInt(alpha))) +} +func ColorMaski(index uint32, r bool, g bool, b bool, a bool) { + C.glowColorMaski(gpColorMaski, (C.GLuint)(index), (C.GLboolean)(boolToInt(r)), (C.GLboolean)(boolToInt(g)), (C.GLboolean)(boolToInt(b)), (C.GLboolean)(boolToInt(a))) +} +func CommandListSegmentsNV(list uint32, segments uint32) { + C.glowCommandListSegmentsNV(gpCommandListSegmentsNV, (C.GLuint)(list), (C.GLuint)(segments)) +} +func CompileCommandListNV(list uint32) { + C.glowCompileCommandListNV(gpCompileCommandListNV, (C.GLuint)(list)) +} + +// Compiles a shader object +func CompileShader(shader uint32) { + C.glowCompileShader(gpCompileShader, (C.GLuint)(shader)) +} +func CompileShaderIncludeARB(shader uint32, count int32, path **uint8, length *int32) { + C.glowCompileShaderIncludeARB(gpCompileShaderIncludeARB, (C.GLuint)(shader), (C.GLsizei)(count), (**C.GLchar)(unsafe.Pointer(path)), (*C.GLint)(unsafe.Pointer(length))) +} +func CompressedMultiTexImage1DEXT(texunit uint32, target uint32, level int32, internalformat uint32, width int32, border int32, imageSize int32, bits unsafe.Pointer) { + C.glowCompressedMultiTexImage1DEXT(gpCompressedMultiTexImage1DEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLint)(border), (C.GLsizei)(imageSize), bits) +} +func CompressedMultiTexImage2DEXT(texunit uint32, target uint32, level int32, internalformat uint32, width int32, height int32, border int32, imageSize int32, bits unsafe.Pointer) { + C.glowCompressedMultiTexImage2DEXT(gpCompressedMultiTexImage2DEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLint)(border), (C.GLsizei)(imageSize), bits) +} +func CompressedMultiTexImage3DEXT(texunit uint32, target uint32, level int32, internalformat uint32, width int32, height int32, depth int32, border int32, imageSize int32, bits unsafe.Pointer) { + C.glowCompressedMultiTexImage3DEXT(gpCompressedMultiTexImage3DEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLint)(border), (C.GLsizei)(imageSize), bits) +} +func CompressedMultiTexSubImage1DEXT(texunit uint32, target uint32, level int32, xoffset int32, width int32, format uint32, imageSize int32, bits unsafe.Pointer) { + C.glowCompressedMultiTexSubImage1DEXT(gpCompressedMultiTexSubImage1DEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLsizei)(width), (C.GLenum)(format), (C.GLsizei)(imageSize), bits) +} +func CompressedMultiTexSubImage2DEXT(texunit uint32, target uint32, level int32, xoffset int32, yoffset int32, width int32, height int32, format uint32, imageSize int32, bits unsafe.Pointer) { + C.glowCompressedMultiTexSubImage2DEXT(gpCompressedMultiTexSubImage2DEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLenum)(format), (C.GLsizei)(imageSize), bits) +} +func CompressedMultiTexSubImage3DEXT(texunit uint32, target uint32, level int32, xoffset int32, yoffset int32, zoffset int32, width int32, height int32, depth int32, format uint32, imageSize int32, bits unsafe.Pointer) { + C.glowCompressedMultiTexSubImage3DEXT(gpCompressedMultiTexSubImage3DEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLenum)(format), (C.GLsizei)(imageSize), bits) +} + +// specify a one-dimensional texture image in a compressed format +func CompressedTexImage1D(target uint32, level int32, internalformat uint32, width int32, border int32, imageSize int32, data unsafe.Pointer) { + C.glowCompressedTexImage1D(gpCompressedTexImage1D, (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLint)(border), (C.GLsizei)(imageSize), data) +} + +// specify a two-dimensional texture image in a compressed format +func CompressedTexImage2D(target uint32, level int32, internalformat uint32, width int32, height int32, border int32, imageSize int32, data unsafe.Pointer) { + C.glowCompressedTexImage2D(gpCompressedTexImage2D, (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLint)(border), (C.GLsizei)(imageSize), data) +} + +// specify a three-dimensional texture image in a compressed format +func CompressedTexImage3D(target uint32, level int32, internalformat uint32, width int32, height int32, depth int32, border int32, imageSize int32, data unsafe.Pointer) { + C.glowCompressedTexImage3D(gpCompressedTexImage3D, (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLint)(border), (C.GLsizei)(imageSize), data) +} + +// specify a one-dimensional texture subimage in a compressed format +func CompressedTexSubImage1D(target uint32, level int32, xoffset int32, width int32, format uint32, imageSize int32, data unsafe.Pointer) { + C.glowCompressedTexSubImage1D(gpCompressedTexSubImage1D, (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLsizei)(width), (C.GLenum)(format), (C.GLsizei)(imageSize), data) +} + +// specify a two-dimensional texture subimage in a compressed format +func CompressedTexSubImage2D(target uint32, level int32, xoffset int32, yoffset int32, width int32, height int32, format uint32, imageSize int32, data unsafe.Pointer) { + C.glowCompressedTexSubImage2D(gpCompressedTexSubImage2D, (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLenum)(format), (C.GLsizei)(imageSize), data) +} + +// specify a three-dimensional texture subimage in a compressed format +func CompressedTexSubImage3D(target uint32, level int32, xoffset int32, yoffset int32, zoffset int32, width int32, height int32, depth int32, format uint32, imageSize int32, data unsafe.Pointer) { + C.glowCompressedTexSubImage3D(gpCompressedTexSubImage3D, (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLenum)(format), (C.GLsizei)(imageSize), data) +} +func CompressedTextureImage1DEXT(texture uint32, target uint32, level int32, internalformat uint32, width int32, border int32, imageSize int32, bits unsafe.Pointer) { + C.glowCompressedTextureImage1DEXT(gpCompressedTextureImage1DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLint)(border), (C.GLsizei)(imageSize), bits) +} +func CompressedTextureImage2DEXT(texture uint32, target uint32, level int32, internalformat uint32, width int32, height int32, border int32, imageSize int32, bits unsafe.Pointer) { + C.glowCompressedTextureImage2DEXT(gpCompressedTextureImage2DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLint)(border), (C.GLsizei)(imageSize), bits) +} +func CompressedTextureImage3DEXT(texture uint32, target uint32, level int32, internalformat uint32, width int32, height int32, depth int32, border int32, imageSize int32, bits unsafe.Pointer) { + C.glowCompressedTextureImage3DEXT(gpCompressedTextureImage3DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLint)(border), (C.GLsizei)(imageSize), bits) +} + +// specify a one-dimensional texture subimage in a compressed format +func CompressedTextureSubImage1D(texture uint32, level int32, xoffset int32, width int32, format uint32, imageSize int32, data unsafe.Pointer) { + C.glowCompressedTextureSubImage1D(gpCompressedTextureSubImage1D, (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(xoffset), (C.GLsizei)(width), (C.GLenum)(format), (C.GLsizei)(imageSize), data) +} +func CompressedTextureSubImage1DEXT(texture uint32, target uint32, level int32, xoffset int32, width int32, format uint32, imageSize int32, bits unsafe.Pointer) { + C.glowCompressedTextureSubImage1DEXT(gpCompressedTextureSubImage1DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLsizei)(width), (C.GLenum)(format), (C.GLsizei)(imageSize), bits) +} + +// specify a two-dimensional texture subimage in a compressed format +func CompressedTextureSubImage2D(texture uint32, level int32, xoffset int32, yoffset int32, width int32, height int32, format uint32, imageSize int32, data unsafe.Pointer) { + C.glowCompressedTextureSubImage2D(gpCompressedTextureSubImage2D, (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLenum)(format), (C.GLsizei)(imageSize), data) +} +func CompressedTextureSubImage2DEXT(texture uint32, target uint32, level int32, xoffset int32, yoffset int32, width int32, height int32, format uint32, imageSize int32, bits unsafe.Pointer) { + C.glowCompressedTextureSubImage2DEXT(gpCompressedTextureSubImage2DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLenum)(format), (C.GLsizei)(imageSize), bits) +} + +// specify a three-dimensional texture subimage in a compressed format +func CompressedTextureSubImage3D(texture uint32, level int32, xoffset int32, yoffset int32, zoffset int32, width int32, height int32, depth int32, format uint32, imageSize int32, data unsafe.Pointer) { + C.glowCompressedTextureSubImage3D(gpCompressedTextureSubImage3D, (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLenum)(format), (C.GLsizei)(imageSize), data) +} +func CompressedTextureSubImage3DEXT(texture uint32, target uint32, level int32, xoffset int32, yoffset int32, zoffset int32, width int32, height int32, depth int32, format uint32, imageSize int32, bits unsafe.Pointer) { + C.glowCompressedTextureSubImage3DEXT(gpCompressedTextureSubImage3DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLenum)(format), (C.GLsizei)(imageSize), bits) +} +func ConservativeRasterParameterfNV(pname uint32, value float32) { + C.glowConservativeRasterParameterfNV(gpConservativeRasterParameterfNV, (C.GLenum)(pname), (C.GLfloat)(value)) +} +func ConservativeRasterParameteriNV(pname uint32, param int32) { + C.glowConservativeRasterParameteriNV(gpConservativeRasterParameteriNV, (C.GLenum)(pname), (C.GLint)(param)) +} + +// copy all or part of the data store of a buffer object to the data store of another buffer object +func CopyBufferSubData(readTarget uint32, writeTarget uint32, readOffset int, writeOffset int, size int) { + C.glowCopyBufferSubData(gpCopyBufferSubData, (C.GLenum)(readTarget), (C.GLenum)(writeTarget), (C.GLintptr)(readOffset), (C.GLintptr)(writeOffset), (C.GLsizeiptr)(size)) +} + +// perform a raw data copy between two images +func CopyImageSubData(srcName uint32, srcTarget uint32, srcLevel int32, srcX int32, srcY int32, srcZ int32, dstName uint32, dstTarget uint32, dstLevel int32, dstX int32, dstY int32, dstZ int32, srcWidth int32, srcHeight int32, srcDepth int32) { + C.glowCopyImageSubData(gpCopyImageSubData, (C.GLuint)(srcName), (C.GLenum)(srcTarget), (C.GLint)(srcLevel), (C.GLint)(srcX), (C.GLint)(srcY), (C.GLint)(srcZ), (C.GLuint)(dstName), (C.GLenum)(dstTarget), (C.GLint)(dstLevel), (C.GLint)(dstX), (C.GLint)(dstY), (C.GLint)(dstZ), (C.GLsizei)(srcWidth), (C.GLsizei)(srcHeight), (C.GLsizei)(srcDepth)) +} +func CopyMultiTexImage1DEXT(texunit uint32, target uint32, level int32, internalformat uint32, x int32, y int32, width int32, border int32) { + C.glowCopyMultiTexImage1DEXT(gpCopyMultiTexImage1DEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(internalformat), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLint)(border)) +} +func CopyMultiTexImage2DEXT(texunit uint32, target uint32, level int32, internalformat uint32, x int32, y int32, width int32, height int32, border int32) { + C.glowCopyMultiTexImage2DEXT(gpCopyMultiTexImage2DEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(internalformat), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLint)(border)) +} +func CopyMultiTexSubImage1DEXT(texunit uint32, target uint32, level int32, xoffset int32, x int32, y int32, width int32) { + C.glowCopyMultiTexSubImage1DEXT(gpCopyMultiTexSubImage1DEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width)) +} +func CopyMultiTexSubImage2DEXT(texunit uint32, target uint32, level int32, xoffset int32, yoffset int32, x int32, y int32, width int32, height int32) { + C.glowCopyMultiTexSubImage2DEXT(gpCopyMultiTexSubImage2DEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height)) +} +func CopyMultiTexSubImage3DEXT(texunit uint32, target uint32, level int32, xoffset int32, yoffset int32, zoffset int32, x int32, y int32, width int32, height int32) { + C.glowCopyMultiTexSubImage3DEXT(gpCopyMultiTexSubImage3DEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height)) +} + +// copy all or part of the data store of a buffer object to the data store of another buffer object +func CopyNamedBufferSubData(readBuffer uint32, writeBuffer uint32, readOffset int, writeOffset int, size int) { + C.glowCopyNamedBufferSubData(gpCopyNamedBufferSubData, (C.GLuint)(readBuffer), (C.GLuint)(writeBuffer), (C.GLintptr)(readOffset), (C.GLintptr)(writeOffset), (C.GLsizeiptr)(size)) +} +func CopyPathNV(resultPath uint32, srcPath uint32) { + C.glowCopyPathNV(gpCopyPathNV, (C.GLuint)(resultPath), (C.GLuint)(srcPath)) +} + +// copy pixels into a 1D texture image +func CopyTexImage1D(target uint32, level int32, internalformat uint32, x int32, y int32, width int32, border int32) { + C.glowCopyTexImage1D(gpCopyTexImage1D, (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(internalformat), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLint)(border)) +} + +// copy pixels into a 2D texture image +func CopyTexImage2D(target uint32, level int32, internalformat uint32, x int32, y int32, width int32, height int32, border int32) { + C.glowCopyTexImage2D(gpCopyTexImage2D, (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(internalformat), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLint)(border)) +} + +// copy a one-dimensional texture subimage +func CopyTexSubImage1D(target uint32, level int32, xoffset int32, x int32, y int32, width int32) { + C.glowCopyTexSubImage1D(gpCopyTexSubImage1D, (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width)) +} + +// copy a two-dimensional texture subimage +func CopyTexSubImage2D(target uint32, level int32, xoffset int32, yoffset int32, x int32, y int32, width int32, height int32) { + C.glowCopyTexSubImage2D(gpCopyTexSubImage2D, (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height)) +} + +// copy a three-dimensional texture subimage +func CopyTexSubImage3D(target uint32, level int32, xoffset int32, yoffset int32, zoffset int32, x int32, y int32, width int32, height int32) { + C.glowCopyTexSubImage3D(gpCopyTexSubImage3D, (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height)) +} +func CopyTextureImage1DEXT(texture uint32, target uint32, level int32, internalformat uint32, x int32, y int32, width int32, border int32) { + C.glowCopyTextureImage1DEXT(gpCopyTextureImage1DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(internalformat), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLint)(border)) +} +func CopyTextureImage2DEXT(texture uint32, target uint32, level int32, internalformat uint32, x int32, y int32, width int32, height int32, border int32) { + C.glowCopyTextureImage2DEXT(gpCopyTextureImage2DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(internalformat), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLint)(border)) +} + +// copy a one-dimensional texture subimage +func CopyTextureSubImage1D(texture uint32, level int32, xoffset int32, x int32, y int32, width int32) { + C.glowCopyTextureSubImage1D(gpCopyTextureSubImage1D, (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width)) +} +func CopyTextureSubImage1DEXT(texture uint32, target uint32, level int32, xoffset int32, x int32, y int32, width int32) { + C.glowCopyTextureSubImage1DEXT(gpCopyTextureSubImage1DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width)) +} + +// copy a two-dimensional texture subimage +func CopyTextureSubImage2D(texture uint32, level int32, xoffset int32, yoffset int32, x int32, y int32, width int32, height int32) { + C.glowCopyTextureSubImage2D(gpCopyTextureSubImage2D, (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height)) +} +func CopyTextureSubImage2DEXT(texture uint32, target uint32, level int32, xoffset int32, yoffset int32, x int32, y int32, width int32, height int32) { + C.glowCopyTextureSubImage2DEXT(gpCopyTextureSubImage2DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height)) +} + +// copy a three-dimensional texture subimage +func CopyTextureSubImage3D(texture uint32, level int32, xoffset int32, yoffset int32, zoffset int32, x int32, y int32, width int32, height int32) { + C.glowCopyTextureSubImage3D(gpCopyTextureSubImage3D, (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height)) +} +func CopyTextureSubImage3DEXT(texture uint32, target uint32, level int32, xoffset int32, yoffset int32, zoffset int32, x int32, y int32, width int32, height int32) { + C.glowCopyTextureSubImage3DEXT(gpCopyTextureSubImage3DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height)) +} +func CoverFillPathInstancedNV(numPaths int32, pathNameType uint32, paths unsafe.Pointer, pathBase uint32, coverMode uint32, transformType uint32, transformValues *float32) { + C.glowCoverFillPathInstancedNV(gpCoverFillPathInstancedNV, (C.GLsizei)(numPaths), (C.GLenum)(pathNameType), paths, (C.GLuint)(pathBase), (C.GLenum)(coverMode), (C.GLenum)(transformType), (*C.GLfloat)(unsafe.Pointer(transformValues))) +} +func CoverFillPathNV(path uint32, coverMode uint32) { + C.glowCoverFillPathNV(gpCoverFillPathNV, (C.GLuint)(path), (C.GLenum)(coverMode)) +} +func CoverStrokePathInstancedNV(numPaths int32, pathNameType uint32, paths unsafe.Pointer, pathBase uint32, coverMode uint32, transformType uint32, transformValues *float32) { + C.glowCoverStrokePathInstancedNV(gpCoverStrokePathInstancedNV, (C.GLsizei)(numPaths), (C.GLenum)(pathNameType), paths, (C.GLuint)(pathBase), (C.GLenum)(coverMode), (C.GLenum)(transformType), (*C.GLfloat)(unsafe.Pointer(transformValues))) +} +func CoverStrokePathNV(path uint32, coverMode uint32) { + C.glowCoverStrokePathNV(gpCoverStrokePathNV, (C.GLuint)(path), (C.GLenum)(coverMode)) +} +func CoverageModulationNV(components uint32) { + C.glowCoverageModulationNV(gpCoverageModulationNV, (C.GLenum)(components)) +} +func CoverageModulationTableNV(n int32, v *float32) { + C.glowCoverageModulationTableNV(gpCoverageModulationTableNV, (C.GLsizei)(n), (*C.GLfloat)(unsafe.Pointer(v))) +} + +// create buffer objects +func CreateBuffers(n int32, buffers *uint32) { + C.glowCreateBuffers(gpCreateBuffers, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(buffers))) +} +func CreateCommandListsNV(n int32, lists *uint32) { + C.glowCreateCommandListsNV(gpCreateCommandListsNV, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(lists))) +} + +// create framebuffer objects +func CreateFramebuffers(n int32, framebuffers *uint32) { + C.glowCreateFramebuffers(gpCreateFramebuffers, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(framebuffers))) +} +func CreatePerfQueryINTEL(queryId uint32, queryHandle *uint32) { + C.glowCreatePerfQueryINTEL(gpCreatePerfQueryINTEL, (C.GLuint)(queryId), (*C.GLuint)(unsafe.Pointer(queryHandle))) +} + +// Creates a program object +func CreateProgram() uint32 { + ret := C.glowCreateProgram(gpCreateProgram) + return (uint32)(ret) +} + +// create program pipeline objects +func CreateProgramPipelines(n int32, pipelines *uint32) { + C.glowCreateProgramPipelines(gpCreateProgramPipelines, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(pipelines))) +} + +// create query objects +func CreateQueries(target uint32, n int32, ids *uint32) { + C.glowCreateQueries(gpCreateQueries, (C.GLenum)(target), (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(ids))) +} + +// create renderbuffer objects +func CreateRenderbuffers(n int32, renderbuffers *uint32) { + C.glowCreateRenderbuffers(gpCreateRenderbuffers, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(renderbuffers))) +} + +// create sampler objects +func CreateSamplers(n int32, samplers *uint32) { + C.glowCreateSamplers(gpCreateSamplers, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(samplers))) +} + +// Creates a shader object +func CreateShader(xtype uint32) uint32 { + ret := C.glowCreateShader(gpCreateShader, (C.GLenum)(xtype)) + return (uint32)(ret) +} +func CreateShaderProgramEXT(xtype uint32, xstring *uint8) uint32 { + ret := C.glowCreateShaderProgramEXT(gpCreateShaderProgramEXT, (C.GLenum)(xtype), (*C.GLchar)(unsafe.Pointer(xstring))) + return (uint32)(ret) +} + +// create a stand-alone program from an array of null-terminated source code strings +func CreateShaderProgramv(xtype uint32, count int32, strings **uint8) uint32 { + ret := C.glowCreateShaderProgramv(gpCreateShaderProgramv, (C.GLenum)(xtype), (C.GLsizei)(count), (**C.GLchar)(unsafe.Pointer(strings))) + return (uint32)(ret) +} +func CreateShaderProgramvEXT(xtype uint32, count int32, strings **uint8) uint32 { + ret := C.glowCreateShaderProgramvEXT(gpCreateShaderProgramvEXT, (C.GLenum)(xtype), (C.GLsizei)(count), (**C.GLchar)(unsafe.Pointer(strings))) + return (uint32)(ret) +} +func CreateStatesNV(n int32, states *uint32) { + C.glowCreateStatesNV(gpCreateStatesNV, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(states))) +} + +// Parameter context has type *C.struct__cl_context. +// Parameter event has type *C.struct__cl_event. +func CreateSyncFromCLeventARB(context unsafe.Pointer, event unsafe.Pointer, flags uint32) uintptr { + ret := C.glowCreateSyncFromCLeventARB(gpCreateSyncFromCLeventARB, (*C.struct__cl_context)(context), (*C.struct__cl_event)(event), (C.GLbitfield)(flags)) + return (uintptr)(ret) +} + +// create texture objects +func CreateTextures(target uint32, n int32, textures *uint32) { + C.glowCreateTextures(gpCreateTextures, (C.GLenum)(target), (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(textures))) +} + +// create transform feedback objects +func CreateTransformFeedbacks(n int32, ids *uint32) { + C.glowCreateTransformFeedbacks(gpCreateTransformFeedbacks, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(ids))) +} + +// create vertex array objects +func CreateVertexArrays(n int32, arrays *uint32) { + C.glowCreateVertexArrays(gpCreateVertexArrays, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(arrays))) +} + +// specify whether front- or back-facing facets can be culled +func CullFace(mode uint32) { + C.glowCullFace(gpCullFace, (C.GLenum)(mode)) +} + +// specify a callback to receive debugging messages from the GL +func DebugMessageCallback(callback DebugProc, userParam unsafe.Pointer) { + userDebugCallback = callback + C.glowDebugMessageCallback(gpDebugMessageCallback, (C.GLDEBUGPROC)(unsafe.Pointer(&callback)), userParam) +} +func DebugMessageCallbackARB(callback DebugProc, userParam unsafe.Pointer) { + userDebugCallback = callback + C.glowDebugMessageCallbackARB(gpDebugMessageCallbackARB, (C.GLDEBUGPROCARB)(unsafe.Pointer(&callback)), userParam) +} +func DebugMessageCallbackKHR(callback DebugProc, userParam unsafe.Pointer) { + userDebugCallback = callback + C.glowDebugMessageCallbackKHR(gpDebugMessageCallbackKHR, (C.GLDEBUGPROCKHR)(unsafe.Pointer(&callback)), userParam) +} + +// control the reporting of debug messages in a debug context +func DebugMessageControl(source uint32, xtype uint32, severity uint32, count int32, ids *uint32, enabled bool) { + C.glowDebugMessageControl(gpDebugMessageControl, (C.GLenum)(source), (C.GLenum)(xtype), (C.GLenum)(severity), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(ids)), (C.GLboolean)(boolToInt(enabled))) +} +func DebugMessageControlARB(source uint32, xtype uint32, severity uint32, count int32, ids *uint32, enabled bool) { + C.glowDebugMessageControlARB(gpDebugMessageControlARB, (C.GLenum)(source), (C.GLenum)(xtype), (C.GLenum)(severity), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(ids)), (C.GLboolean)(boolToInt(enabled))) +} +func DebugMessageControlKHR(source uint32, xtype uint32, severity uint32, count int32, ids *uint32, enabled bool) { + C.glowDebugMessageControlKHR(gpDebugMessageControlKHR, (C.GLenum)(source), (C.GLenum)(xtype), (C.GLenum)(severity), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(ids)), (C.GLboolean)(boolToInt(enabled))) +} + +// inject an application-supplied message into the debug message queue +func DebugMessageInsert(source uint32, xtype uint32, id uint32, severity uint32, length int32, buf *uint8) { + C.glowDebugMessageInsert(gpDebugMessageInsert, (C.GLenum)(source), (C.GLenum)(xtype), (C.GLuint)(id), (C.GLenum)(severity), (C.GLsizei)(length), (*C.GLchar)(unsafe.Pointer(buf))) +} +func DebugMessageInsertARB(source uint32, xtype uint32, id uint32, severity uint32, length int32, buf *uint8) { + C.glowDebugMessageInsertARB(gpDebugMessageInsertARB, (C.GLenum)(source), (C.GLenum)(xtype), (C.GLuint)(id), (C.GLenum)(severity), (C.GLsizei)(length), (*C.GLchar)(unsafe.Pointer(buf))) +} +func DebugMessageInsertKHR(source uint32, xtype uint32, id uint32, severity uint32, length int32, buf *uint8) { + C.glowDebugMessageInsertKHR(gpDebugMessageInsertKHR, (C.GLenum)(source), (C.GLenum)(xtype), (C.GLuint)(id), (C.GLenum)(severity), (C.GLsizei)(length), (*C.GLchar)(unsafe.Pointer(buf))) +} + +// delete named buffer objects +func DeleteBuffers(n int32, buffers *uint32) { + C.glowDeleteBuffers(gpDeleteBuffers, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(buffers))) +} +func DeleteCommandListsNV(n int32, lists *uint32) { + C.glowDeleteCommandListsNV(gpDeleteCommandListsNV, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(lists))) +} + +// delete framebuffer objects +func DeleteFramebuffers(n int32, framebuffers *uint32) { + C.glowDeleteFramebuffers(gpDeleteFramebuffers, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(framebuffers))) +} +func DeleteNamedStringARB(namelen int32, name *uint8) { + C.glowDeleteNamedStringARB(gpDeleteNamedStringARB, (C.GLint)(namelen), (*C.GLchar)(unsafe.Pointer(name))) +} +func DeletePathsNV(path uint32, xrange int32) { + C.glowDeletePathsNV(gpDeletePathsNV, (C.GLuint)(path), (C.GLsizei)(xrange)) +} +func DeletePerfMonitorsAMD(n int32, monitors *uint32) { + C.glowDeletePerfMonitorsAMD(gpDeletePerfMonitorsAMD, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(monitors))) +} +func DeletePerfQueryINTEL(queryHandle uint32) { + C.glowDeletePerfQueryINTEL(gpDeletePerfQueryINTEL, (C.GLuint)(queryHandle)) +} + +// Deletes a program object +func DeleteProgram(program uint32) { + C.glowDeleteProgram(gpDeleteProgram, (C.GLuint)(program)) +} + +// delete program pipeline objects +func DeleteProgramPipelines(n int32, pipelines *uint32) { + C.glowDeleteProgramPipelines(gpDeleteProgramPipelines, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(pipelines))) +} +func DeleteProgramPipelinesEXT(n int32, pipelines *uint32) { + C.glowDeleteProgramPipelinesEXT(gpDeleteProgramPipelinesEXT, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(pipelines))) +} + +// delete named query objects +func DeleteQueries(n int32, ids *uint32) { + C.glowDeleteQueries(gpDeleteQueries, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(ids))) +} + +// delete renderbuffer objects +func DeleteRenderbuffers(n int32, renderbuffers *uint32) { + C.glowDeleteRenderbuffers(gpDeleteRenderbuffers, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(renderbuffers))) +} + +// delete named sampler objects +func DeleteSamplers(count int32, samplers *uint32) { + C.glowDeleteSamplers(gpDeleteSamplers, (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(samplers))) +} + +// Deletes a shader object +func DeleteShader(shader uint32) { + C.glowDeleteShader(gpDeleteShader, (C.GLuint)(shader)) +} +func DeleteStatesNV(n int32, states *uint32) { + C.glowDeleteStatesNV(gpDeleteStatesNV, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(states))) +} + +// delete a sync object +func DeleteSync(sync uintptr) { + C.glowDeleteSync(gpDeleteSync, (C.GLsync)(sync)) +} + +// delete named textures +func DeleteTextures(n int32, textures *uint32) { + C.glowDeleteTextures(gpDeleteTextures, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(textures))) +} + +// delete transform feedback objects +func DeleteTransformFeedbacks(n int32, ids *uint32) { + C.glowDeleteTransformFeedbacks(gpDeleteTransformFeedbacks, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(ids))) +} + +// delete vertex array objects +func DeleteVertexArrays(n int32, arrays *uint32) { + C.glowDeleteVertexArrays(gpDeleteVertexArrays, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(arrays))) +} +func DepthBoundsdNV(zmin float64, zmax float64) { + C.glowDepthBoundsdNV(gpDepthBoundsdNV, (C.GLdouble)(zmin), (C.GLdouble)(zmax)) +} + +// specify the value used for depth buffer comparisons +func DepthFunc(xfunc uint32) { + C.glowDepthFunc(gpDepthFunc, (C.GLenum)(xfunc)) +} + +// enable or disable writing into the depth buffer +func DepthMask(flag bool) { + C.glowDepthMask(gpDepthMask, (C.GLboolean)(boolToInt(flag))) +} + +// specify mapping of depth values from normalized device coordinates to window coordinates +func DepthRange(n float64, f float64) { + C.glowDepthRange(gpDepthRange, (C.GLdouble)(n), (C.GLdouble)(f)) +} +func DepthRangeArraydvNV(first uint32, count int32, v *float64) { + C.glowDepthRangeArraydvNV(gpDepthRangeArraydvNV, (C.GLuint)(first), (C.GLsizei)(count), (*C.GLdouble)(unsafe.Pointer(v))) +} +func DepthRangeArrayv(first uint32, count int32, v *float64) { + C.glowDepthRangeArrayv(gpDepthRangeArrayv, (C.GLuint)(first), (C.GLsizei)(count), (*C.GLdouble)(unsafe.Pointer(v))) +} + +// specify mapping of depth values from normalized device coordinates to window coordinates for a specified viewport +func DepthRangeIndexed(index uint32, n float64, f float64) { + C.glowDepthRangeIndexed(gpDepthRangeIndexed, (C.GLuint)(index), (C.GLdouble)(n), (C.GLdouble)(f)) +} +func DepthRangeIndexeddNV(index uint32, n float64, f float64) { + C.glowDepthRangeIndexeddNV(gpDepthRangeIndexeddNV, (C.GLuint)(index), (C.GLdouble)(n), (C.GLdouble)(f)) +} +func DepthRangedNV(zNear float64, zFar float64) { + C.glowDepthRangedNV(gpDepthRangedNV, (C.GLdouble)(zNear), (C.GLdouble)(zFar)) +} + +// specify mapping of depth values from normalized device coordinates to window coordinates +func DepthRangef(n float32, f float32) { + C.glowDepthRangef(gpDepthRangef, (C.GLfloat)(n), (C.GLfloat)(f)) +} + +// Detaches a shader object from a program object to which it is attached +func DetachShader(program uint32, shader uint32) { + C.glowDetachShader(gpDetachShader, (C.GLuint)(program), (C.GLuint)(shader)) +} +func Disable(cap uint32) { + C.glowDisable(gpDisable, (C.GLenum)(cap)) +} +func DisableClientStateIndexedEXT(array uint32, index uint32) { + C.glowDisableClientStateIndexedEXT(gpDisableClientStateIndexedEXT, (C.GLenum)(array), (C.GLuint)(index)) +} +func DisableClientStateiEXT(array uint32, index uint32) { + C.glowDisableClientStateiEXT(gpDisableClientStateiEXT, (C.GLenum)(array), (C.GLuint)(index)) +} +func DisableIndexedEXT(target uint32, index uint32) { + C.glowDisableIndexedEXT(gpDisableIndexedEXT, (C.GLenum)(target), (C.GLuint)(index)) +} + +// Enable or disable a generic vertex attribute array +func DisableVertexArrayAttrib(vaobj uint32, index uint32) { + C.glowDisableVertexArrayAttrib(gpDisableVertexArrayAttrib, (C.GLuint)(vaobj), (C.GLuint)(index)) +} +func DisableVertexArrayAttribEXT(vaobj uint32, index uint32) { + C.glowDisableVertexArrayAttribEXT(gpDisableVertexArrayAttribEXT, (C.GLuint)(vaobj), (C.GLuint)(index)) +} +func DisableVertexArrayEXT(vaobj uint32, array uint32) { + C.glowDisableVertexArrayEXT(gpDisableVertexArrayEXT, (C.GLuint)(vaobj), (C.GLenum)(array)) +} + +// Enable or disable a generic vertex attribute array +func DisableVertexAttribArray(index uint32) { + C.glowDisableVertexAttribArray(gpDisableVertexAttribArray, (C.GLuint)(index)) +} +func Disablei(target uint32, index uint32) { + C.glowDisablei(gpDisablei, (C.GLenum)(target), (C.GLuint)(index)) +} + +// launch one or more compute work groups +func DispatchCompute(num_groups_x uint32, num_groups_y uint32, num_groups_z uint32) { + C.glowDispatchCompute(gpDispatchCompute, (C.GLuint)(num_groups_x), (C.GLuint)(num_groups_y), (C.GLuint)(num_groups_z)) +} +func DispatchComputeGroupSizeARB(num_groups_x uint32, num_groups_y uint32, num_groups_z uint32, group_size_x uint32, group_size_y uint32, group_size_z uint32) { + C.glowDispatchComputeGroupSizeARB(gpDispatchComputeGroupSizeARB, (C.GLuint)(num_groups_x), (C.GLuint)(num_groups_y), (C.GLuint)(num_groups_z), (C.GLuint)(group_size_x), (C.GLuint)(group_size_y), (C.GLuint)(group_size_z)) +} + +// launch one or more compute work groups using parameters stored in a buffer +func DispatchComputeIndirect(indirect int) { + C.glowDispatchComputeIndirect(gpDispatchComputeIndirect, (C.GLintptr)(indirect)) +} + +// render primitives from array data +func DrawArrays(mode uint32, first int32, count int32) { + C.glowDrawArrays(gpDrawArrays, (C.GLenum)(mode), (C.GLint)(first), (C.GLsizei)(count)) +} + +// render primitives from array data, taking parameters from memory +func DrawArraysIndirect(mode uint32, indirect unsafe.Pointer) { + C.glowDrawArraysIndirect(gpDrawArraysIndirect, (C.GLenum)(mode), indirect) +} + +// draw multiple instances of a range of elements +func DrawArraysInstanced(mode uint32, first int32, count int32, instancecount int32) { + C.glowDrawArraysInstanced(gpDrawArraysInstanced, (C.GLenum)(mode), (C.GLint)(first), (C.GLsizei)(count), (C.GLsizei)(instancecount)) +} +func DrawArraysInstancedARB(mode uint32, first int32, count int32, primcount int32) { + C.glowDrawArraysInstancedARB(gpDrawArraysInstancedARB, (C.GLenum)(mode), (C.GLint)(first), (C.GLsizei)(count), (C.GLsizei)(primcount)) +} + +// draw multiple instances of a range of elements with offset applied to instanced attributes +func DrawArraysInstancedBaseInstance(mode uint32, first int32, count int32, instancecount int32, baseinstance uint32) { + C.glowDrawArraysInstancedBaseInstance(gpDrawArraysInstancedBaseInstance, (C.GLenum)(mode), (C.GLint)(first), (C.GLsizei)(count), (C.GLsizei)(instancecount), (C.GLuint)(baseinstance)) +} +func DrawArraysInstancedEXT(mode uint32, start int32, count int32, primcount int32) { + C.glowDrawArraysInstancedEXT(gpDrawArraysInstancedEXT, (C.GLenum)(mode), (C.GLint)(start), (C.GLsizei)(count), (C.GLsizei)(primcount)) +} + +// specify which color buffers are to be drawn into +func DrawBuffer(buf uint32) { + C.glowDrawBuffer(gpDrawBuffer, (C.GLenum)(buf)) +} + +// Specifies a list of color buffers to be drawn into +func DrawBuffers(n int32, bufs *uint32) { + C.glowDrawBuffers(gpDrawBuffers, (C.GLsizei)(n), (*C.GLenum)(unsafe.Pointer(bufs))) +} +func DrawCommandsAddressNV(primitiveMode uint32, indirects *uint64, sizes *int32, count uint32) { + C.glowDrawCommandsAddressNV(gpDrawCommandsAddressNV, (C.GLenum)(primitiveMode), (*C.GLuint64)(unsafe.Pointer(indirects)), (*C.GLsizei)(unsafe.Pointer(sizes)), (C.GLuint)(count)) +} +func DrawCommandsNV(primitiveMode uint32, buffer uint32, indirects *int, sizes *int32, count uint32) { + C.glowDrawCommandsNV(gpDrawCommandsNV, (C.GLenum)(primitiveMode), (C.GLuint)(buffer), (*C.GLintptr)(unsafe.Pointer(indirects)), (*C.GLsizei)(unsafe.Pointer(sizes)), (C.GLuint)(count)) +} +func DrawCommandsStatesAddressNV(indirects *uint64, sizes *int32, states *uint32, fbos *uint32, count uint32) { + C.glowDrawCommandsStatesAddressNV(gpDrawCommandsStatesAddressNV, (*C.GLuint64)(unsafe.Pointer(indirects)), (*C.GLsizei)(unsafe.Pointer(sizes)), (*C.GLuint)(unsafe.Pointer(states)), (*C.GLuint)(unsafe.Pointer(fbos)), (C.GLuint)(count)) +} +func DrawCommandsStatesNV(buffer uint32, indirects *int, sizes *int32, states *uint32, fbos *uint32, count uint32) { + C.glowDrawCommandsStatesNV(gpDrawCommandsStatesNV, (C.GLuint)(buffer), (*C.GLintptr)(unsafe.Pointer(indirects)), (*C.GLsizei)(unsafe.Pointer(sizes)), (*C.GLuint)(unsafe.Pointer(states)), (*C.GLuint)(unsafe.Pointer(fbos)), (C.GLuint)(count)) +} + +// render primitives from array data +func DrawElements(mode uint32, count int32, xtype uint32, indices unsafe.Pointer) { + C.glowDrawElements(gpDrawElements, (C.GLenum)(mode), (C.GLsizei)(count), (C.GLenum)(xtype), indices) +} +func DrawElementsWithOffset(mode uint32, count int32, xtype uint32, indices uintptr) { + C.glowDrawElementsWithOffset(gpDrawElements, (C.GLenum)(mode), (C.GLsizei)(count), (C.GLenum)(xtype), (C.uintptr_t)(indices)) +} + +// render primitives from array data with a per-element offset +func DrawElementsBaseVertex(mode uint32, count int32, xtype uint32, indices unsafe.Pointer, basevertex int32) { + C.glowDrawElementsBaseVertex(gpDrawElementsBaseVertex, (C.GLenum)(mode), (C.GLsizei)(count), (C.GLenum)(xtype), indices, (C.GLint)(basevertex)) +} +func DrawElementsBaseVertexWithOffset(mode uint32, count int32, xtype uint32, indices uintptr, basevertex int32) { + C.glowDrawElementsBaseVertexWithOffset(gpDrawElementsBaseVertex, (C.GLenum)(mode), (C.GLsizei)(count), (C.GLenum)(xtype), (C.uintptr_t)(indices), (C.GLint)(basevertex)) +} + +// render indexed primitives from array data, taking parameters from memory +func DrawElementsIndirect(mode uint32, xtype uint32, indirect unsafe.Pointer) { + C.glowDrawElementsIndirect(gpDrawElementsIndirect, (C.GLenum)(mode), (C.GLenum)(xtype), indirect) +} + +// draw multiple instances of a set of elements +func DrawElementsInstanced(mode uint32, count int32, xtype uint32, indices unsafe.Pointer, instancecount int32) { + C.glowDrawElementsInstanced(gpDrawElementsInstanced, (C.GLenum)(mode), (C.GLsizei)(count), (C.GLenum)(xtype), indices, (C.GLsizei)(instancecount)) +} +func DrawElementsInstancedARB(mode uint32, count int32, xtype uint32, indices unsafe.Pointer, primcount int32) { + C.glowDrawElementsInstancedARB(gpDrawElementsInstancedARB, (C.GLenum)(mode), (C.GLsizei)(count), (C.GLenum)(xtype), indices, (C.GLsizei)(primcount)) +} + +// draw multiple instances of a set of elements with offset applied to instanced attributes +func DrawElementsInstancedBaseInstance(mode uint32, count int32, xtype uint32, indices unsafe.Pointer, instancecount int32, baseinstance uint32) { + C.glowDrawElementsInstancedBaseInstance(gpDrawElementsInstancedBaseInstance, (C.GLenum)(mode), (C.GLsizei)(count), (C.GLenum)(xtype), indices, (C.GLsizei)(instancecount), (C.GLuint)(baseinstance)) +} + +// render multiple instances of a set of primitives from array data with a per-element offset +func DrawElementsInstancedBaseVertex(mode uint32, count int32, xtype uint32, indices unsafe.Pointer, instancecount int32, basevertex int32) { + C.glowDrawElementsInstancedBaseVertex(gpDrawElementsInstancedBaseVertex, (C.GLenum)(mode), (C.GLsizei)(count), (C.GLenum)(xtype), indices, (C.GLsizei)(instancecount), (C.GLint)(basevertex)) +} + +// render multiple instances of a set of primitives from array data with a per-element offset +func DrawElementsInstancedBaseVertexBaseInstance(mode uint32, count int32, xtype uint32, indices unsafe.Pointer, instancecount int32, basevertex int32, baseinstance uint32) { + C.glowDrawElementsInstancedBaseVertexBaseInstance(gpDrawElementsInstancedBaseVertexBaseInstance, (C.GLenum)(mode), (C.GLsizei)(count), (C.GLenum)(xtype), indices, (C.GLsizei)(instancecount), (C.GLint)(basevertex), (C.GLuint)(baseinstance)) +} +func DrawElementsInstancedEXT(mode uint32, count int32, xtype uint32, indices unsafe.Pointer, primcount int32) { + C.glowDrawElementsInstancedEXT(gpDrawElementsInstancedEXT, (C.GLenum)(mode), (C.GLsizei)(count), (C.GLenum)(xtype), indices, (C.GLsizei)(primcount)) +} +func DrawMeshTasksIndirectNV(indirect int) { + C.glowDrawMeshTasksIndirectNV(gpDrawMeshTasksIndirectNV, (C.GLintptr)(indirect)) +} +func DrawMeshTasksNV(first uint32, count uint32) { + C.glowDrawMeshTasksNV(gpDrawMeshTasksNV, (C.GLuint)(first), (C.GLuint)(count)) +} + +// render primitives from array data +func DrawRangeElements(mode uint32, start uint32, end uint32, count int32, xtype uint32, indices unsafe.Pointer) { + C.glowDrawRangeElements(gpDrawRangeElements, (C.GLenum)(mode), (C.GLuint)(start), (C.GLuint)(end), (C.GLsizei)(count), (C.GLenum)(xtype), indices) +} + +// render primitives from array data with a per-element offset +func DrawRangeElementsBaseVertex(mode uint32, start uint32, end uint32, count int32, xtype uint32, indices unsafe.Pointer, basevertex int32) { + C.glowDrawRangeElementsBaseVertex(gpDrawRangeElementsBaseVertex, (C.GLenum)(mode), (C.GLuint)(start), (C.GLuint)(end), (C.GLsizei)(count), (C.GLenum)(xtype), indices, (C.GLint)(basevertex)) +} + +// render primitives using a count derived from a transform feedback object +func DrawTransformFeedback(mode uint32, id uint32) { + C.glowDrawTransformFeedback(gpDrawTransformFeedback, (C.GLenum)(mode), (C.GLuint)(id)) +} + +// render multiple instances of primitives using a count derived from a transform feedback object +func DrawTransformFeedbackInstanced(mode uint32, id uint32, instancecount int32) { + C.glowDrawTransformFeedbackInstanced(gpDrawTransformFeedbackInstanced, (C.GLenum)(mode), (C.GLuint)(id), (C.GLsizei)(instancecount)) +} + +// render primitives using a count derived from a specifed stream of a transform feedback object +func DrawTransformFeedbackStream(mode uint32, id uint32, stream uint32) { + C.glowDrawTransformFeedbackStream(gpDrawTransformFeedbackStream, (C.GLenum)(mode), (C.GLuint)(id), (C.GLuint)(stream)) +} + +// render multiple instances of primitives using a count derived from a specifed stream of a transform feedback object +func DrawTransformFeedbackStreamInstanced(mode uint32, id uint32, stream uint32, instancecount int32) { + C.glowDrawTransformFeedbackStreamInstanced(gpDrawTransformFeedbackStreamInstanced, (C.GLenum)(mode), (C.GLuint)(id), (C.GLuint)(stream), (C.GLsizei)(instancecount)) +} +func DrawVkImageNV(vkImage uint64, sampler uint32, x0 float32, y0 float32, x1 float32, y1 float32, z float32, s0 float32, t0 float32, s1 float32, t1 float32) { + C.glowDrawVkImageNV(gpDrawVkImageNV, (C.GLuint64)(vkImage), (C.GLuint)(sampler), (C.GLfloat)(x0), (C.GLfloat)(y0), (C.GLfloat)(x1), (C.GLfloat)(y1), (C.GLfloat)(z), (C.GLfloat)(s0), (C.GLfloat)(t0), (C.GLfloat)(s1), (C.GLfloat)(t1)) +} + +// Parameter image has type C.GLeglImageOES. +func EGLImageTargetTexStorageEXT(target uint32, image unsafe.Pointer, attrib_list *int32) { + C.glowEGLImageTargetTexStorageEXT(gpEGLImageTargetTexStorageEXT, (C.GLenum)(target), (C.GLeglImageOES)(image), (*C.GLint)(unsafe.Pointer(attrib_list))) +} + +// Parameter image has type C.GLeglImageOES. +func EGLImageTargetTextureStorageEXT(texture uint32, image unsafe.Pointer, attrib_list *int32) { + C.glowEGLImageTargetTextureStorageEXT(gpEGLImageTargetTextureStorageEXT, (C.GLuint)(texture), (C.GLeglImageOES)(image), (*C.GLint)(unsafe.Pointer(attrib_list))) +} +func EdgeFlagFormatNV(stride int32) { + C.glowEdgeFlagFormatNV(gpEdgeFlagFormatNV, (C.GLsizei)(stride)) +} + +// enable or disable server-side GL capabilities +func Enable(cap uint32) { + C.glowEnable(gpEnable, (C.GLenum)(cap)) +} +func EnableClientStateIndexedEXT(array uint32, index uint32) { + C.glowEnableClientStateIndexedEXT(gpEnableClientStateIndexedEXT, (C.GLenum)(array), (C.GLuint)(index)) +} +func EnableClientStateiEXT(array uint32, index uint32) { + C.glowEnableClientStateiEXT(gpEnableClientStateiEXT, (C.GLenum)(array), (C.GLuint)(index)) +} +func EnableIndexedEXT(target uint32, index uint32) { + C.glowEnableIndexedEXT(gpEnableIndexedEXT, (C.GLenum)(target), (C.GLuint)(index)) +} + +// Enable or disable a generic vertex attribute array +func EnableVertexArrayAttrib(vaobj uint32, index uint32) { + C.glowEnableVertexArrayAttrib(gpEnableVertexArrayAttrib, (C.GLuint)(vaobj), (C.GLuint)(index)) +} +func EnableVertexArrayAttribEXT(vaobj uint32, index uint32) { + C.glowEnableVertexArrayAttribEXT(gpEnableVertexArrayAttribEXT, (C.GLuint)(vaobj), (C.GLuint)(index)) +} +func EnableVertexArrayEXT(vaobj uint32, array uint32) { + C.glowEnableVertexArrayEXT(gpEnableVertexArrayEXT, (C.GLuint)(vaobj), (C.GLenum)(array)) +} + +// Enable or disable a generic vertex attribute array +func EnableVertexAttribArray(index uint32) { + C.glowEnableVertexAttribArray(gpEnableVertexAttribArray, (C.GLuint)(index)) +} +func Enablei(target uint32, index uint32) { + C.glowEnablei(gpEnablei, (C.GLenum)(target), (C.GLuint)(index)) +} +func EndConditionalRender() { + C.glowEndConditionalRender(gpEndConditionalRender) +} +func EndConditionalRenderNV() { + C.glowEndConditionalRenderNV(gpEndConditionalRenderNV) +} +func EndPerfMonitorAMD(monitor uint32) { + C.glowEndPerfMonitorAMD(gpEndPerfMonitorAMD, (C.GLuint)(monitor)) +} +func EndPerfQueryINTEL(queryHandle uint32) { + C.glowEndPerfQueryINTEL(gpEndPerfQueryINTEL, (C.GLuint)(queryHandle)) +} +func EndQuery(target uint32) { + C.glowEndQuery(gpEndQuery, (C.GLenum)(target)) +} +func EndQueryIndexed(target uint32, index uint32) { + C.glowEndQueryIndexed(gpEndQueryIndexed, (C.GLenum)(target), (C.GLuint)(index)) +} +func EndTransformFeedback() { + C.glowEndTransformFeedback(gpEndTransformFeedback) +} +func EvaluateDepthValuesARB() { + C.glowEvaluateDepthValuesARB(gpEvaluateDepthValuesARB) +} + +// create a new sync object and insert it into the GL command stream +func FenceSync(condition uint32, flags uint32) uintptr { + ret := C.glowFenceSync(gpFenceSync, (C.GLenum)(condition), (C.GLbitfield)(flags)) + return (uintptr)(ret) +} + +// block until all GL execution is complete +func Finish() { + C.glowFinish(gpFinish) +} + +// force execution of GL commands in finite time +func Flush() { + C.glowFlush(gpFlush) +} + +// indicate modifications to a range of a mapped buffer +func FlushMappedBufferRange(target uint32, offset int, length int) { + C.glowFlushMappedBufferRange(gpFlushMappedBufferRange, (C.GLenum)(target), (C.GLintptr)(offset), (C.GLsizeiptr)(length)) +} + +// indicate modifications to a range of a mapped buffer +func FlushMappedNamedBufferRange(buffer uint32, offset int, length int) { + C.glowFlushMappedNamedBufferRange(gpFlushMappedNamedBufferRange, (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(length)) +} +func FlushMappedNamedBufferRangeEXT(buffer uint32, offset int, length int) { + C.glowFlushMappedNamedBufferRangeEXT(gpFlushMappedNamedBufferRangeEXT, (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(length)) +} +func FogCoordFormatNV(xtype uint32, stride int32) { + C.glowFogCoordFormatNV(gpFogCoordFormatNV, (C.GLenum)(xtype), (C.GLsizei)(stride)) +} +func FragmentCoverageColorNV(color uint32) { + C.glowFragmentCoverageColorNV(gpFragmentCoverageColorNV, (C.GLuint)(color)) +} +func FramebufferDrawBufferEXT(framebuffer uint32, mode uint32) { + C.glowFramebufferDrawBufferEXT(gpFramebufferDrawBufferEXT, (C.GLuint)(framebuffer), (C.GLenum)(mode)) +} +func FramebufferDrawBuffersEXT(framebuffer uint32, n int32, bufs *uint32) { + C.glowFramebufferDrawBuffersEXT(gpFramebufferDrawBuffersEXT, (C.GLuint)(framebuffer), (C.GLsizei)(n), (*C.GLenum)(unsafe.Pointer(bufs))) +} +func FramebufferFetchBarrierEXT() { + C.glowFramebufferFetchBarrierEXT(gpFramebufferFetchBarrierEXT) +} + +// set a named parameter of a framebuffer object +func FramebufferParameteri(target uint32, pname uint32, param int32) { + C.glowFramebufferParameteri(gpFramebufferParameteri, (C.GLenum)(target), (C.GLenum)(pname), (C.GLint)(param)) +} +func FramebufferParameteriMESA(target uint32, pname uint32, param int32) { + C.glowFramebufferParameteriMESA(gpFramebufferParameteriMESA, (C.GLenum)(target), (C.GLenum)(pname), (C.GLint)(param)) +} +func FramebufferReadBufferEXT(framebuffer uint32, mode uint32) { + C.glowFramebufferReadBufferEXT(gpFramebufferReadBufferEXT, (C.GLuint)(framebuffer), (C.GLenum)(mode)) +} + +// attach a renderbuffer as a logical buffer of a framebuffer object +func FramebufferRenderbuffer(target uint32, attachment uint32, renderbuffertarget uint32, renderbuffer uint32) { + C.glowFramebufferRenderbuffer(gpFramebufferRenderbuffer, (C.GLenum)(target), (C.GLenum)(attachment), (C.GLenum)(renderbuffertarget), (C.GLuint)(renderbuffer)) +} +func FramebufferSampleLocationsfvARB(target uint32, start uint32, count int32, v *float32) { + C.glowFramebufferSampleLocationsfvARB(gpFramebufferSampleLocationsfvARB, (C.GLenum)(target), (C.GLuint)(start), (C.GLsizei)(count), (*C.GLfloat)(unsafe.Pointer(v))) +} +func FramebufferSampleLocationsfvNV(target uint32, start uint32, count int32, v *float32) { + C.glowFramebufferSampleLocationsfvNV(gpFramebufferSampleLocationsfvNV, (C.GLenum)(target), (C.GLuint)(start), (C.GLsizei)(count), (*C.GLfloat)(unsafe.Pointer(v))) +} + +// attach a level of a texture object as a logical buffer of a framebuffer object +func FramebufferTexture(target uint32, attachment uint32, texture uint32, level int32) { + C.glowFramebufferTexture(gpFramebufferTexture, (C.GLenum)(target), (C.GLenum)(attachment), (C.GLuint)(texture), (C.GLint)(level)) +} +func FramebufferTexture1D(target uint32, attachment uint32, textarget uint32, texture uint32, level int32) { + C.glowFramebufferTexture1D(gpFramebufferTexture1D, (C.GLenum)(target), (C.GLenum)(attachment), (C.GLenum)(textarget), (C.GLuint)(texture), (C.GLint)(level)) +} + +// attach a level of a texture object as a logical buffer to the currently bound framebuffer object +func FramebufferTexture2D(target uint32, attachment uint32, textarget uint32, texture uint32, level int32) { + C.glowFramebufferTexture2D(gpFramebufferTexture2D, (C.GLenum)(target), (C.GLenum)(attachment), (C.GLenum)(textarget), (C.GLuint)(texture), (C.GLint)(level)) +} +func FramebufferTexture3D(target uint32, attachment uint32, textarget uint32, texture uint32, level int32, zoffset int32) { + C.glowFramebufferTexture3D(gpFramebufferTexture3D, (C.GLenum)(target), (C.GLenum)(attachment), (C.GLenum)(textarget), (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(zoffset)) +} +func FramebufferTextureARB(target uint32, attachment uint32, texture uint32, level int32) { + C.glowFramebufferTextureARB(gpFramebufferTextureARB, (C.GLenum)(target), (C.GLenum)(attachment), (C.GLuint)(texture), (C.GLint)(level)) +} +func FramebufferTextureFaceARB(target uint32, attachment uint32, texture uint32, level int32, face uint32) { + C.glowFramebufferTextureFaceARB(gpFramebufferTextureFaceARB, (C.GLenum)(target), (C.GLenum)(attachment), (C.GLuint)(texture), (C.GLint)(level), (C.GLenum)(face)) +} + +// attach a single layer of a texture object as a logical buffer of a framebuffer object +func FramebufferTextureLayer(target uint32, attachment uint32, texture uint32, level int32, layer int32) { + C.glowFramebufferTextureLayer(gpFramebufferTextureLayer, (C.GLenum)(target), (C.GLenum)(attachment), (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(layer)) +} +func FramebufferTextureLayerARB(target uint32, attachment uint32, texture uint32, level int32, layer int32) { + C.glowFramebufferTextureLayerARB(gpFramebufferTextureLayerARB, (C.GLenum)(target), (C.GLenum)(attachment), (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(layer)) +} +func FramebufferTextureMultiviewOVR(target uint32, attachment uint32, texture uint32, level int32, baseViewIndex int32, numViews int32) { + C.glowFramebufferTextureMultiviewOVR(gpFramebufferTextureMultiviewOVR, (C.GLenum)(target), (C.GLenum)(attachment), (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(baseViewIndex), (C.GLsizei)(numViews)) +} + +// define front- and back-facing polygons +func FrontFace(mode uint32) { + C.glowFrontFace(gpFrontFace, (C.GLenum)(mode)) +} + +// generate buffer object names +func GenBuffers(n int32, buffers *uint32) { + C.glowGenBuffers(gpGenBuffers, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(buffers))) +} + +// generate framebuffer object names +func GenFramebuffers(n int32, framebuffers *uint32) { + C.glowGenFramebuffers(gpGenFramebuffers, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(framebuffers))) +} +func GenPathsNV(xrange int32) uint32 { + ret := C.glowGenPathsNV(gpGenPathsNV, (C.GLsizei)(xrange)) + return (uint32)(ret) +} +func GenPerfMonitorsAMD(n int32, monitors *uint32) { + C.glowGenPerfMonitorsAMD(gpGenPerfMonitorsAMD, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(monitors))) +} + +// reserve program pipeline object names +func GenProgramPipelines(n int32, pipelines *uint32) { + C.glowGenProgramPipelines(gpGenProgramPipelines, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(pipelines))) +} +func GenProgramPipelinesEXT(n int32, pipelines *uint32) { + C.glowGenProgramPipelinesEXT(gpGenProgramPipelinesEXT, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(pipelines))) +} + +// generate query object names +func GenQueries(n int32, ids *uint32) { + C.glowGenQueries(gpGenQueries, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(ids))) +} + +// generate renderbuffer object names +func GenRenderbuffers(n int32, renderbuffers *uint32) { + C.glowGenRenderbuffers(gpGenRenderbuffers, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(renderbuffers))) +} + +// generate sampler object names +func GenSamplers(count int32, samplers *uint32) { + C.glowGenSamplers(gpGenSamplers, (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(samplers))) +} + +// generate texture names +func GenTextures(n int32, textures *uint32) { + C.glowGenTextures(gpGenTextures, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(textures))) +} + +// reserve transform feedback object names +func GenTransformFeedbacks(n int32, ids *uint32) { + C.glowGenTransformFeedbacks(gpGenTransformFeedbacks, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(ids))) +} + +// generate vertex array object names +func GenVertexArrays(n int32, arrays *uint32) { + C.glowGenVertexArrays(gpGenVertexArrays, (C.GLsizei)(n), (*C.GLuint)(unsafe.Pointer(arrays))) +} + +// generate mipmaps for a specified texture object +func GenerateMipmap(target uint32) { + C.glowGenerateMipmap(gpGenerateMipmap, (C.GLenum)(target)) +} +func GenerateMultiTexMipmapEXT(texunit uint32, target uint32) { + C.glowGenerateMultiTexMipmapEXT(gpGenerateMultiTexMipmapEXT, (C.GLenum)(texunit), (C.GLenum)(target)) +} + +// generate mipmaps for a specified texture object +func GenerateTextureMipmap(texture uint32) { + C.glowGenerateTextureMipmap(gpGenerateTextureMipmap, (C.GLuint)(texture)) +} +func GenerateTextureMipmapEXT(texture uint32, target uint32) { + C.glowGenerateTextureMipmapEXT(gpGenerateTextureMipmapEXT, (C.GLuint)(texture), (C.GLenum)(target)) +} + +// retrieve information about the set of active atomic counter buffers for a program +func GetActiveAtomicCounterBufferiv(program uint32, bufferIndex uint32, pname uint32, params *int32) { + C.glowGetActiveAtomicCounterBufferiv(gpGetActiveAtomicCounterBufferiv, (C.GLuint)(program), (C.GLuint)(bufferIndex), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} + +// Returns information about an active attribute variable for the specified program object +func GetActiveAttrib(program uint32, index uint32, bufSize int32, length *int32, size *int32, xtype *uint32, name *uint8) { + C.glowGetActiveAttrib(gpGetActiveAttrib, (C.GLuint)(program), (C.GLuint)(index), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLint)(unsafe.Pointer(size)), (*C.GLenum)(unsafe.Pointer(xtype)), (*C.GLchar)(unsafe.Pointer(name))) +} + +// query the name of an active shader subroutine +func GetActiveSubroutineName(program uint32, shadertype uint32, index uint32, bufSize int32, length *int32, name *uint8) { + C.glowGetActiveSubroutineName(gpGetActiveSubroutineName, (C.GLuint)(program), (C.GLenum)(shadertype), (C.GLuint)(index), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLchar)(unsafe.Pointer(name))) +} + +// query the name of an active shader subroutine uniform +func GetActiveSubroutineUniformName(program uint32, shadertype uint32, index uint32, bufSize int32, length *int32, name *uint8) { + C.glowGetActiveSubroutineUniformName(gpGetActiveSubroutineUniformName, (C.GLuint)(program), (C.GLenum)(shadertype), (C.GLuint)(index), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLchar)(unsafe.Pointer(name))) +} +func GetActiveSubroutineUniformiv(program uint32, shadertype uint32, index uint32, pname uint32, values *int32) { + C.glowGetActiveSubroutineUniformiv(gpGetActiveSubroutineUniformiv, (C.GLuint)(program), (C.GLenum)(shadertype), (C.GLuint)(index), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(values))) +} + +// Returns information about an active uniform variable for the specified program object +func GetActiveUniform(program uint32, index uint32, bufSize int32, length *int32, size *int32, xtype *uint32, name *uint8) { + C.glowGetActiveUniform(gpGetActiveUniform, (C.GLuint)(program), (C.GLuint)(index), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLint)(unsafe.Pointer(size)), (*C.GLenum)(unsafe.Pointer(xtype)), (*C.GLchar)(unsafe.Pointer(name))) +} + +// retrieve the name of an active uniform block +func GetActiveUniformBlockName(program uint32, uniformBlockIndex uint32, bufSize int32, length *int32, uniformBlockName *uint8) { + C.glowGetActiveUniformBlockName(gpGetActiveUniformBlockName, (C.GLuint)(program), (C.GLuint)(uniformBlockIndex), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLchar)(unsafe.Pointer(uniformBlockName))) +} + +// query information about an active uniform block +func GetActiveUniformBlockiv(program uint32, uniformBlockIndex uint32, pname uint32, params *int32) { + C.glowGetActiveUniformBlockiv(gpGetActiveUniformBlockiv, (C.GLuint)(program), (C.GLuint)(uniformBlockIndex), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} + +// query the name of an active uniform +func GetActiveUniformName(program uint32, uniformIndex uint32, bufSize int32, length *int32, uniformName *uint8) { + C.glowGetActiveUniformName(gpGetActiveUniformName, (C.GLuint)(program), (C.GLuint)(uniformIndex), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLchar)(unsafe.Pointer(uniformName))) +} + +// Returns information about several active uniform variables for the specified program object +func GetActiveUniformsiv(program uint32, uniformCount int32, uniformIndices *uint32, pname uint32, params *int32) { + C.glowGetActiveUniformsiv(gpGetActiveUniformsiv, (C.GLuint)(program), (C.GLsizei)(uniformCount), (*C.GLuint)(unsafe.Pointer(uniformIndices)), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} + +// Returns the handles of the shader objects attached to a program object +func GetAttachedShaders(program uint32, maxCount int32, count *int32, shaders *uint32) { + C.glowGetAttachedShaders(gpGetAttachedShaders, (C.GLuint)(program), (C.GLsizei)(maxCount), (*C.GLsizei)(unsafe.Pointer(count)), (*C.GLuint)(unsafe.Pointer(shaders))) +} + +// Returns the location of an attribute variable +func GetAttribLocation(program uint32, name *uint8) int32 { + ret := C.glowGetAttribLocation(gpGetAttribLocation, (C.GLuint)(program), (*C.GLchar)(unsafe.Pointer(name))) + return (int32)(ret) +} +func GetBooleanIndexedvEXT(target uint32, index uint32, data *bool) { + C.glowGetBooleanIndexedvEXT(gpGetBooleanIndexedvEXT, (C.GLenum)(target), (C.GLuint)(index), (*C.GLboolean)(unsafe.Pointer(data))) +} +func GetBooleani_v(target uint32, index uint32, data *bool) { + C.glowGetBooleani_v(gpGetBooleani_v, (C.GLenum)(target), (C.GLuint)(index), (*C.GLboolean)(unsafe.Pointer(data))) +} +func GetBooleanv(pname uint32, data *bool) { + C.glowGetBooleanv(gpGetBooleanv, (C.GLenum)(pname), (*C.GLboolean)(unsafe.Pointer(data))) +} + +// return parameters of a buffer object +func GetBufferParameteri64v(target uint32, pname uint32, params *int64) { + C.glowGetBufferParameteri64v(gpGetBufferParameteri64v, (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint64)(unsafe.Pointer(params))) +} + +// return parameters of a buffer object +func GetBufferParameteriv(target uint32, pname uint32, params *int32) { + C.glowGetBufferParameteriv(gpGetBufferParameteriv, (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetBufferParameterui64vNV(target uint32, pname uint32, params *uint64) { + C.glowGetBufferParameterui64vNV(gpGetBufferParameterui64vNV, (C.GLenum)(target), (C.GLenum)(pname), (*C.GLuint64EXT)(unsafe.Pointer(params))) +} + +// return the pointer to a mapped buffer object's data store +func GetBufferPointerv(target uint32, pname uint32, params *unsafe.Pointer) { + C.glowGetBufferPointerv(gpGetBufferPointerv, (C.GLenum)(target), (C.GLenum)(pname), params) +} + +// returns a subset of a buffer object's data store +func GetBufferSubData(target uint32, offset int, size int, data unsafe.Pointer) { + C.glowGetBufferSubData(gpGetBufferSubData, (C.GLenum)(target), (C.GLintptr)(offset), (C.GLsizeiptr)(size), data) +} +func GetCommandHeaderNV(tokenID uint32, size uint32) uint32 { + ret := C.glowGetCommandHeaderNV(gpGetCommandHeaderNV, (C.GLenum)(tokenID), (C.GLuint)(size)) + return (uint32)(ret) +} +func GetCompressedMultiTexImageEXT(texunit uint32, target uint32, lod int32, img unsafe.Pointer) { + C.glowGetCompressedMultiTexImageEXT(gpGetCompressedMultiTexImageEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(lod), img) +} + +// return a compressed texture image +func GetCompressedTexImage(target uint32, level int32, img unsafe.Pointer) { + C.glowGetCompressedTexImage(gpGetCompressedTexImage, (C.GLenum)(target), (C.GLint)(level), img) +} + +// return a compressed texture image +func GetCompressedTextureImage(texture uint32, level int32, bufSize int32, pixels unsafe.Pointer) { + C.glowGetCompressedTextureImage(gpGetCompressedTextureImage, (C.GLuint)(texture), (C.GLint)(level), (C.GLsizei)(bufSize), pixels) +} +func GetCompressedTextureImageEXT(texture uint32, target uint32, lod int32, img unsafe.Pointer) { + C.glowGetCompressedTextureImageEXT(gpGetCompressedTextureImageEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(lod), img) +} + +// retrieve a sub-region of a compressed texture image from a compressed texture object +func GetCompressedTextureSubImage(texture uint32, level int32, xoffset int32, yoffset int32, zoffset int32, width int32, height int32, depth int32, bufSize int32, pixels unsafe.Pointer) { + C.glowGetCompressedTextureSubImage(gpGetCompressedTextureSubImage, (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLsizei)(bufSize), pixels) +} +func GetCoverageModulationTableNV(bufSize int32, v *float32) { + C.glowGetCoverageModulationTableNV(gpGetCoverageModulationTableNV, (C.GLsizei)(bufSize), (*C.GLfloat)(unsafe.Pointer(v))) +} + +// retrieve messages from the debug message log +func GetDebugMessageLog(count uint32, bufSize int32, sources *uint32, types *uint32, ids *uint32, severities *uint32, lengths *int32, messageLog *uint8) uint32 { + ret := C.glowGetDebugMessageLog(gpGetDebugMessageLog, (C.GLuint)(count), (C.GLsizei)(bufSize), (*C.GLenum)(unsafe.Pointer(sources)), (*C.GLenum)(unsafe.Pointer(types)), (*C.GLuint)(unsafe.Pointer(ids)), (*C.GLenum)(unsafe.Pointer(severities)), (*C.GLsizei)(unsafe.Pointer(lengths)), (*C.GLchar)(unsafe.Pointer(messageLog))) + return (uint32)(ret) +} +func GetDebugMessageLogARB(count uint32, bufSize int32, sources *uint32, types *uint32, ids *uint32, severities *uint32, lengths *int32, messageLog *uint8) uint32 { + ret := C.glowGetDebugMessageLogARB(gpGetDebugMessageLogARB, (C.GLuint)(count), (C.GLsizei)(bufSize), (*C.GLenum)(unsafe.Pointer(sources)), (*C.GLenum)(unsafe.Pointer(types)), (*C.GLuint)(unsafe.Pointer(ids)), (*C.GLenum)(unsafe.Pointer(severities)), (*C.GLsizei)(unsafe.Pointer(lengths)), (*C.GLchar)(unsafe.Pointer(messageLog))) + return (uint32)(ret) +} +func GetDebugMessageLogKHR(count uint32, bufSize int32, sources *uint32, types *uint32, ids *uint32, severities *uint32, lengths *int32, messageLog *uint8) uint32 { + ret := C.glowGetDebugMessageLogKHR(gpGetDebugMessageLogKHR, (C.GLuint)(count), (C.GLsizei)(bufSize), (*C.GLenum)(unsafe.Pointer(sources)), (*C.GLenum)(unsafe.Pointer(types)), (*C.GLuint)(unsafe.Pointer(ids)), (*C.GLenum)(unsafe.Pointer(severities)), (*C.GLsizei)(unsafe.Pointer(lengths)), (*C.GLchar)(unsafe.Pointer(messageLog))) + return (uint32)(ret) +} +func GetDoubleIndexedvEXT(target uint32, index uint32, data *float64) { + C.glowGetDoubleIndexedvEXT(gpGetDoubleIndexedvEXT, (C.GLenum)(target), (C.GLuint)(index), (*C.GLdouble)(unsafe.Pointer(data))) +} +func GetDoublei_v(target uint32, index uint32, data *float64) { + C.glowGetDoublei_v(gpGetDoublei_v, (C.GLenum)(target), (C.GLuint)(index), (*C.GLdouble)(unsafe.Pointer(data))) +} +func GetDoublei_vEXT(pname uint32, index uint32, params *float64) { + C.glowGetDoublei_vEXT(gpGetDoublei_vEXT, (C.GLenum)(pname), (C.GLuint)(index), (*C.GLdouble)(unsafe.Pointer(params))) +} +func GetDoublev(pname uint32, data *float64) { + C.glowGetDoublev(gpGetDoublev, (C.GLenum)(pname), (*C.GLdouble)(unsafe.Pointer(data))) +} + +// return error information +func GetError() uint32 { + ret := C.glowGetError(gpGetError) + return (uint32)(ret) +} +func GetFirstPerfQueryIdINTEL(queryId *uint32) { + C.glowGetFirstPerfQueryIdINTEL(gpGetFirstPerfQueryIdINTEL, (*C.GLuint)(unsafe.Pointer(queryId))) +} +func GetFloatIndexedvEXT(target uint32, index uint32, data *float32) { + C.glowGetFloatIndexedvEXT(gpGetFloatIndexedvEXT, (C.GLenum)(target), (C.GLuint)(index), (*C.GLfloat)(unsafe.Pointer(data))) +} +func GetFloati_v(target uint32, index uint32, data *float32) { + C.glowGetFloati_v(gpGetFloati_v, (C.GLenum)(target), (C.GLuint)(index), (*C.GLfloat)(unsafe.Pointer(data))) +} +func GetFloati_vEXT(pname uint32, index uint32, params *float32) { + C.glowGetFloati_vEXT(gpGetFloati_vEXT, (C.GLenum)(pname), (C.GLuint)(index), (*C.GLfloat)(unsafe.Pointer(params))) +} +func GetFloatv(pname uint32, data *float32) { + C.glowGetFloatv(gpGetFloatv, (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(data))) +} + +// query the bindings of color indices to user-defined varying out variables +func GetFragDataIndex(program uint32, name *uint8) int32 { + ret := C.glowGetFragDataIndex(gpGetFragDataIndex, (C.GLuint)(program), (*C.GLchar)(unsafe.Pointer(name))) + return (int32)(ret) +} + +// query the bindings of color numbers to user-defined varying out variables +func GetFragDataLocation(program uint32, name *uint8) int32 { + ret := C.glowGetFragDataLocation(gpGetFragDataLocation, (C.GLuint)(program), (*C.GLchar)(unsafe.Pointer(name))) + return (int32)(ret) +} + +// retrieve information about attachments of a bound framebuffer object +func GetFramebufferAttachmentParameteriv(target uint32, attachment uint32, pname uint32, params *int32) { + C.glowGetFramebufferAttachmentParameteriv(gpGetFramebufferAttachmentParameteriv, (C.GLenum)(target), (C.GLenum)(attachment), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} + +// retrieve a named parameter from a framebuffer +func GetFramebufferParameteriv(target uint32, pname uint32, params *int32) { + C.glowGetFramebufferParameteriv(gpGetFramebufferParameteriv, (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetFramebufferParameterivEXT(framebuffer uint32, pname uint32, params *int32) { + C.glowGetFramebufferParameterivEXT(gpGetFramebufferParameterivEXT, (C.GLuint)(framebuffer), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetFramebufferParameterivMESA(target uint32, pname uint32, params *int32) { + C.glowGetFramebufferParameterivMESA(gpGetFramebufferParameterivMESA, (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} + +// check if the rendering context has not been lost due to software or hardware issues +func GetGraphicsResetStatus() uint32 { + ret := C.glowGetGraphicsResetStatus(gpGetGraphicsResetStatus) + return (uint32)(ret) +} +func GetGraphicsResetStatusARB() uint32 { + ret := C.glowGetGraphicsResetStatusARB(gpGetGraphicsResetStatusARB) + return (uint32)(ret) +} +func GetGraphicsResetStatusKHR() uint32 { + ret := C.glowGetGraphicsResetStatusKHR(gpGetGraphicsResetStatusKHR) + return (uint32)(ret) +} +func GetImageHandleARB(texture uint32, level int32, layered bool, layer int32, format uint32) uint64 { + ret := C.glowGetImageHandleARB(gpGetImageHandleARB, (C.GLuint)(texture), (C.GLint)(level), (C.GLboolean)(boolToInt(layered)), (C.GLint)(layer), (C.GLenum)(format)) + return (uint64)(ret) +} +func GetImageHandleNV(texture uint32, level int32, layered bool, layer int32, format uint32) uint64 { + ret := C.glowGetImageHandleNV(gpGetImageHandleNV, (C.GLuint)(texture), (C.GLint)(level), (C.GLboolean)(boolToInt(layered)), (C.GLint)(layer), (C.GLenum)(format)) + return (uint64)(ret) +} +func GetInteger64i_v(target uint32, index uint32, data *int64) { + C.glowGetInteger64i_v(gpGetInteger64i_v, (C.GLenum)(target), (C.GLuint)(index), (*C.GLint64)(unsafe.Pointer(data))) +} +func GetInteger64v(pname uint32, data *int64) { + C.glowGetInteger64v(gpGetInteger64v, (C.GLenum)(pname), (*C.GLint64)(unsafe.Pointer(data))) +} +func GetIntegerIndexedvEXT(target uint32, index uint32, data *int32) { + C.glowGetIntegerIndexedvEXT(gpGetIntegerIndexedvEXT, (C.GLenum)(target), (C.GLuint)(index), (*C.GLint)(unsafe.Pointer(data))) +} +func GetIntegeri_v(target uint32, index uint32, data *int32) { + C.glowGetIntegeri_v(gpGetIntegeri_v, (C.GLenum)(target), (C.GLuint)(index), (*C.GLint)(unsafe.Pointer(data))) +} +func GetIntegerui64i_vNV(value uint32, index uint32, result *uint64) { + C.glowGetIntegerui64i_vNV(gpGetIntegerui64i_vNV, (C.GLenum)(value), (C.GLuint)(index), (*C.GLuint64EXT)(unsafe.Pointer(result))) +} +func GetIntegerui64vNV(value uint32, result *uint64) { + C.glowGetIntegerui64vNV(gpGetIntegerui64vNV, (C.GLenum)(value), (*C.GLuint64EXT)(unsafe.Pointer(result))) +} +func GetIntegerv(pname uint32, data *int32) { + C.glowGetIntegerv(gpGetIntegerv, (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(data))) +} +func GetInternalformatSampleivNV(target uint32, internalformat uint32, samples int32, pname uint32, count int32, params *int32) { + C.glowGetInternalformatSampleivNV(gpGetInternalformatSampleivNV, (C.GLenum)(target), (C.GLenum)(internalformat), (C.GLsizei)(samples), (C.GLenum)(pname), (C.GLsizei)(count), (*C.GLint)(unsafe.Pointer(params))) +} +func GetInternalformati64v(target uint32, internalformat uint32, pname uint32, count int32, params *int64) { + C.glowGetInternalformati64v(gpGetInternalformati64v, (C.GLenum)(target), (C.GLenum)(internalformat), (C.GLenum)(pname), (C.GLsizei)(count), (*C.GLint64)(unsafe.Pointer(params))) +} + +// retrieve information about implementation-dependent support for internal formats +func GetInternalformativ(target uint32, internalformat uint32, pname uint32, count int32, params *int32) { + C.glowGetInternalformativ(gpGetInternalformativ, (C.GLenum)(target), (C.GLenum)(internalformat), (C.GLenum)(pname), (C.GLsizei)(count), (*C.GLint)(unsafe.Pointer(params))) +} +func GetMemoryObjectDetachedResourcesuivNV(memory uint32, pname uint32, first int32, count int32, params *uint32) { + C.glowGetMemoryObjectDetachedResourcesuivNV(gpGetMemoryObjectDetachedResourcesuivNV, (C.GLuint)(memory), (C.GLenum)(pname), (C.GLint)(first), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(params))) +} +func GetMultiTexEnvfvEXT(texunit uint32, target uint32, pname uint32, params *float32) { + C.glowGetMultiTexEnvfvEXT(gpGetMultiTexEnvfvEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(params))) +} +func GetMultiTexEnvivEXT(texunit uint32, target uint32, pname uint32, params *int32) { + C.glowGetMultiTexEnvivEXT(gpGetMultiTexEnvivEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetMultiTexGendvEXT(texunit uint32, coord uint32, pname uint32, params *float64) { + C.glowGetMultiTexGendvEXT(gpGetMultiTexGendvEXT, (C.GLenum)(texunit), (C.GLenum)(coord), (C.GLenum)(pname), (*C.GLdouble)(unsafe.Pointer(params))) +} +func GetMultiTexGenfvEXT(texunit uint32, coord uint32, pname uint32, params *float32) { + C.glowGetMultiTexGenfvEXT(gpGetMultiTexGenfvEXT, (C.GLenum)(texunit), (C.GLenum)(coord), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(params))) +} +func GetMultiTexGenivEXT(texunit uint32, coord uint32, pname uint32, params *int32) { + C.glowGetMultiTexGenivEXT(gpGetMultiTexGenivEXT, (C.GLenum)(texunit), (C.GLenum)(coord), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetMultiTexImageEXT(texunit uint32, target uint32, level int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowGetMultiTexImageEXT(gpGetMultiTexImageEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} +func GetMultiTexLevelParameterfvEXT(texunit uint32, target uint32, level int32, pname uint32, params *float32) { + C.glowGetMultiTexLevelParameterfvEXT(gpGetMultiTexLevelParameterfvEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(params))) +} +func GetMultiTexLevelParameterivEXT(texunit uint32, target uint32, level int32, pname uint32, params *int32) { + C.glowGetMultiTexLevelParameterivEXT(gpGetMultiTexLevelParameterivEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetMultiTexParameterIivEXT(texunit uint32, target uint32, pname uint32, params *int32) { + C.glowGetMultiTexParameterIivEXT(gpGetMultiTexParameterIivEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetMultiTexParameterIuivEXT(texunit uint32, target uint32, pname uint32, params *uint32) { + C.glowGetMultiTexParameterIuivEXT(gpGetMultiTexParameterIuivEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLuint)(unsafe.Pointer(params))) +} +func GetMultiTexParameterfvEXT(texunit uint32, target uint32, pname uint32, params *float32) { + C.glowGetMultiTexParameterfvEXT(gpGetMultiTexParameterfvEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(params))) +} +func GetMultiTexParameterivEXT(texunit uint32, target uint32, pname uint32, params *int32) { + C.glowGetMultiTexParameterivEXT(gpGetMultiTexParameterivEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} + +// retrieve the location of a sample +func GetMultisamplefv(pname uint32, index uint32, val *float32) { + C.glowGetMultisamplefv(gpGetMultisamplefv, (C.GLenum)(pname), (C.GLuint)(index), (*C.GLfloat)(unsafe.Pointer(val))) +} + +// return parameters of a buffer object +func GetNamedBufferParameteri64v(buffer uint32, pname uint32, params *int64) { + C.glowGetNamedBufferParameteri64v(gpGetNamedBufferParameteri64v, (C.GLuint)(buffer), (C.GLenum)(pname), (*C.GLint64)(unsafe.Pointer(params))) +} + +// return parameters of a buffer object +func GetNamedBufferParameteriv(buffer uint32, pname uint32, params *int32) { + C.glowGetNamedBufferParameteriv(gpGetNamedBufferParameteriv, (C.GLuint)(buffer), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetNamedBufferParameterivEXT(buffer uint32, pname uint32, params *int32) { + C.glowGetNamedBufferParameterivEXT(gpGetNamedBufferParameterivEXT, (C.GLuint)(buffer), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetNamedBufferParameterui64vNV(buffer uint32, pname uint32, params *uint64) { + C.glowGetNamedBufferParameterui64vNV(gpGetNamedBufferParameterui64vNV, (C.GLuint)(buffer), (C.GLenum)(pname), (*C.GLuint64EXT)(unsafe.Pointer(params))) +} + +// return the pointer to a mapped buffer object's data store +func GetNamedBufferPointerv(buffer uint32, pname uint32, params *unsafe.Pointer) { + C.glowGetNamedBufferPointerv(gpGetNamedBufferPointerv, (C.GLuint)(buffer), (C.GLenum)(pname), params) +} +func GetNamedBufferPointervEXT(buffer uint32, pname uint32, params *unsafe.Pointer) { + C.glowGetNamedBufferPointervEXT(gpGetNamedBufferPointervEXT, (C.GLuint)(buffer), (C.GLenum)(pname), params) +} + +// returns a subset of a buffer object's data store +func GetNamedBufferSubData(buffer uint32, offset int, size int, data unsafe.Pointer) { + C.glowGetNamedBufferSubData(gpGetNamedBufferSubData, (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(size), data) +} +func GetNamedBufferSubDataEXT(buffer uint32, offset int, size int, data unsafe.Pointer) { + C.glowGetNamedBufferSubDataEXT(gpGetNamedBufferSubDataEXT, (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(size), data) +} + +// retrieve information about attachments of a framebuffer object +func GetNamedFramebufferAttachmentParameteriv(framebuffer uint32, attachment uint32, pname uint32, params *int32) { + C.glowGetNamedFramebufferAttachmentParameteriv(gpGetNamedFramebufferAttachmentParameteriv, (C.GLuint)(framebuffer), (C.GLenum)(attachment), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetNamedFramebufferAttachmentParameterivEXT(framebuffer uint32, attachment uint32, pname uint32, params *int32) { + C.glowGetNamedFramebufferAttachmentParameterivEXT(gpGetNamedFramebufferAttachmentParameterivEXT, (C.GLuint)(framebuffer), (C.GLenum)(attachment), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} + +// query a named parameter of a framebuffer object +func GetNamedFramebufferParameteriv(framebuffer uint32, pname uint32, param *int32) { + C.glowGetNamedFramebufferParameteriv(gpGetNamedFramebufferParameteriv, (C.GLuint)(framebuffer), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(param))) +} +func GetNamedFramebufferParameterivEXT(framebuffer uint32, pname uint32, params *int32) { + C.glowGetNamedFramebufferParameterivEXT(gpGetNamedFramebufferParameterivEXT, (C.GLuint)(framebuffer), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetNamedProgramLocalParameterIivEXT(program uint32, target uint32, index uint32, params *int32) { + C.glowGetNamedProgramLocalParameterIivEXT(gpGetNamedProgramLocalParameterIivEXT, (C.GLuint)(program), (C.GLenum)(target), (C.GLuint)(index), (*C.GLint)(unsafe.Pointer(params))) +} +func GetNamedProgramLocalParameterIuivEXT(program uint32, target uint32, index uint32, params *uint32) { + C.glowGetNamedProgramLocalParameterIuivEXT(gpGetNamedProgramLocalParameterIuivEXT, (C.GLuint)(program), (C.GLenum)(target), (C.GLuint)(index), (*C.GLuint)(unsafe.Pointer(params))) +} +func GetNamedProgramLocalParameterdvEXT(program uint32, target uint32, index uint32, params *float64) { + C.glowGetNamedProgramLocalParameterdvEXT(gpGetNamedProgramLocalParameterdvEXT, (C.GLuint)(program), (C.GLenum)(target), (C.GLuint)(index), (*C.GLdouble)(unsafe.Pointer(params))) +} +func GetNamedProgramLocalParameterfvEXT(program uint32, target uint32, index uint32, params *float32) { + C.glowGetNamedProgramLocalParameterfvEXT(gpGetNamedProgramLocalParameterfvEXT, (C.GLuint)(program), (C.GLenum)(target), (C.GLuint)(index), (*C.GLfloat)(unsafe.Pointer(params))) +} +func GetNamedProgramStringEXT(program uint32, target uint32, pname uint32, xstring unsafe.Pointer) { + C.glowGetNamedProgramStringEXT(gpGetNamedProgramStringEXT, (C.GLuint)(program), (C.GLenum)(target), (C.GLenum)(pname), xstring) +} +func GetNamedProgramivEXT(program uint32, target uint32, pname uint32, params *int32) { + C.glowGetNamedProgramivEXT(gpGetNamedProgramivEXT, (C.GLuint)(program), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} + +// query a named parameter of a renderbuffer object +func GetNamedRenderbufferParameteriv(renderbuffer uint32, pname uint32, params *int32) { + C.glowGetNamedRenderbufferParameteriv(gpGetNamedRenderbufferParameteriv, (C.GLuint)(renderbuffer), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetNamedRenderbufferParameterivEXT(renderbuffer uint32, pname uint32, params *int32) { + C.glowGetNamedRenderbufferParameterivEXT(gpGetNamedRenderbufferParameterivEXT, (C.GLuint)(renderbuffer), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetNamedStringARB(namelen int32, name *uint8, bufSize int32, stringlen *int32, xstring *uint8) { + C.glowGetNamedStringARB(gpGetNamedStringARB, (C.GLint)(namelen), (*C.GLchar)(unsafe.Pointer(name)), (C.GLsizei)(bufSize), (*C.GLint)(unsafe.Pointer(stringlen)), (*C.GLchar)(unsafe.Pointer(xstring))) +} +func GetNamedStringivARB(namelen int32, name *uint8, pname uint32, params *int32) { + C.glowGetNamedStringivARB(gpGetNamedStringivARB, (C.GLint)(namelen), (*C.GLchar)(unsafe.Pointer(name)), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetNextPerfQueryIdINTEL(queryId uint32, nextQueryId *uint32) { + C.glowGetNextPerfQueryIdINTEL(gpGetNextPerfQueryIdINTEL, (C.GLuint)(queryId), (*C.GLuint)(unsafe.Pointer(nextQueryId))) +} + +// retrieve the label of a named object identified within a namespace +func GetObjectLabel(identifier uint32, name uint32, bufSize int32, length *int32, label *uint8) { + C.glowGetObjectLabel(gpGetObjectLabel, (C.GLenum)(identifier), (C.GLuint)(name), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLchar)(unsafe.Pointer(label))) +} +func GetObjectLabelEXT(xtype uint32, object uint32, bufSize int32, length *int32, label *uint8) { + C.glowGetObjectLabelEXT(gpGetObjectLabelEXT, (C.GLenum)(xtype), (C.GLuint)(object), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLchar)(unsafe.Pointer(label))) +} +func GetObjectLabelKHR(identifier uint32, name uint32, bufSize int32, length *int32, label *uint8) { + C.glowGetObjectLabelKHR(gpGetObjectLabelKHR, (C.GLenum)(identifier), (C.GLuint)(name), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLchar)(unsafe.Pointer(label))) +} + +// retrieve the label of a sync object identified by a pointer +func GetObjectPtrLabel(ptr unsafe.Pointer, bufSize int32, length *int32, label *uint8) { + C.glowGetObjectPtrLabel(gpGetObjectPtrLabel, ptr, (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLchar)(unsafe.Pointer(label))) +} +func GetObjectPtrLabelKHR(ptr unsafe.Pointer, bufSize int32, length *int32, label *uint8) { + C.glowGetObjectPtrLabelKHR(gpGetObjectPtrLabelKHR, ptr, (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLchar)(unsafe.Pointer(label))) +} +func GetPathCommandsNV(path uint32, commands *uint8) { + C.glowGetPathCommandsNV(gpGetPathCommandsNV, (C.GLuint)(path), (*C.GLubyte)(unsafe.Pointer(commands))) +} +func GetPathCoordsNV(path uint32, coords *float32) { + C.glowGetPathCoordsNV(gpGetPathCoordsNV, (C.GLuint)(path), (*C.GLfloat)(unsafe.Pointer(coords))) +} +func GetPathDashArrayNV(path uint32, dashArray *float32) { + C.glowGetPathDashArrayNV(gpGetPathDashArrayNV, (C.GLuint)(path), (*C.GLfloat)(unsafe.Pointer(dashArray))) +} +func GetPathLengthNV(path uint32, startSegment int32, numSegments int32) float32 { + ret := C.glowGetPathLengthNV(gpGetPathLengthNV, (C.GLuint)(path), (C.GLsizei)(startSegment), (C.GLsizei)(numSegments)) + return (float32)(ret) +} +func GetPathMetricRangeNV(metricQueryMask uint32, firstPathName uint32, numPaths int32, stride int32, metrics *float32) { + C.glowGetPathMetricRangeNV(gpGetPathMetricRangeNV, (C.GLbitfield)(metricQueryMask), (C.GLuint)(firstPathName), (C.GLsizei)(numPaths), (C.GLsizei)(stride), (*C.GLfloat)(unsafe.Pointer(metrics))) +} +func GetPathMetricsNV(metricQueryMask uint32, numPaths int32, pathNameType uint32, paths unsafe.Pointer, pathBase uint32, stride int32, metrics *float32) { + C.glowGetPathMetricsNV(gpGetPathMetricsNV, (C.GLbitfield)(metricQueryMask), (C.GLsizei)(numPaths), (C.GLenum)(pathNameType), paths, (C.GLuint)(pathBase), (C.GLsizei)(stride), (*C.GLfloat)(unsafe.Pointer(metrics))) +} +func GetPathParameterfvNV(path uint32, pname uint32, value *float32) { + C.glowGetPathParameterfvNV(gpGetPathParameterfvNV, (C.GLuint)(path), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(value))) +} +func GetPathParameterivNV(path uint32, pname uint32, value *int32) { + C.glowGetPathParameterivNV(gpGetPathParameterivNV, (C.GLuint)(path), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(value))) +} +func GetPathSpacingNV(pathListMode uint32, numPaths int32, pathNameType uint32, paths unsafe.Pointer, pathBase uint32, advanceScale float32, kerningScale float32, transformType uint32, returnedSpacing *float32) { + C.glowGetPathSpacingNV(gpGetPathSpacingNV, (C.GLenum)(pathListMode), (C.GLsizei)(numPaths), (C.GLenum)(pathNameType), paths, (C.GLuint)(pathBase), (C.GLfloat)(advanceScale), (C.GLfloat)(kerningScale), (C.GLenum)(transformType), (*C.GLfloat)(unsafe.Pointer(returnedSpacing))) +} +func GetPerfCounterInfoINTEL(queryId uint32, counterId uint32, counterNameLength uint32, counterName *uint8, counterDescLength uint32, counterDesc *uint8, counterOffset *uint32, counterDataSize *uint32, counterTypeEnum *uint32, counterDataTypeEnum *uint32, rawCounterMaxValue *uint64) { + C.glowGetPerfCounterInfoINTEL(gpGetPerfCounterInfoINTEL, (C.GLuint)(queryId), (C.GLuint)(counterId), (C.GLuint)(counterNameLength), (*C.GLchar)(unsafe.Pointer(counterName)), (C.GLuint)(counterDescLength), (*C.GLchar)(unsafe.Pointer(counterDesc)), (*C.GLuint)(unsafe.Pointer(counterOffset)), (*C.GLuint)(unsafe.Pointer(counterDataSize)), (*C.GLuint)(unsafe.Pointer(counterTypeEnum)), (*C.GLuint)(unsafe.Pointer(counterDataTypeEnum)), (*C.GLuint64)(unsafe.Pointer(rawCounterMaxValue))) +} +func GetPerfMonitorCounterDataAMD(monitor uint32, pname uint32, dataSize int32, data *uint32, bytesWritten *int32) { + C.glowGetPerfMonitorCounterDataAMD(gpGetPerfMonitorCounterDataAMD, (C.GLuint)(monitor), (C.GLenum)(pname), (C.GLsizei)(dataSize), (*C.GLuint)(unsafe.Pointer(data)), (*C.GLint)(unsafe.Pointer(bytesWritten))) +} +func GetPerfMonitorCounterInfoAMD(group uint32, counter uint32, pname uint32, data unsafe.Pointer) { + C.glowGetPerfMonitorCounterInfoAMD(gpGetPerfMonitorCounterInfoAMD, (C.GLuint)(group), (C.GLuint)(counter), (C.GLenum)(pname), data) +} +func GetPerfMonitorCounterStringAMD(group uint32, counter uint32, bufSize int32, length *int32, counterString *uint8) { + C.glowGetPerfMonitorCounterStringAMD(gpGetPerfMonitorCounterStringAMD, (C.GLuint)(group), (C.GLuint)(counter), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLchar)(unsafe.Pointer(counterString))) +} +func GetPerfMonitorCountersAMD(group uint32, numCounters *int32, maxActiveCounters *int32, counterSize int32, counters *uint32) { + C.glowGetPerfMonitorCountersAMD(gpGetPerfMonitorCountersAMD, (C.GLuint)(group), (*C.GLint)(unsafe.Pointer(numCounters)), (*C.GLint)(unsafe.Pointer(maxActiveCounters)), (C.GLsizei)(counterSize), (*C.GLuint)(unsafe.Pointer(counters))) +} +func GetPerfMonitorGroupStringAMD(group uint32, bufSize int32, length *int32, groupString *uint8) { + C.glowGetPerfMonitorGroupStringAMD(gpGetPerfMonitorGroupStringAMD, (C.GLuint)(group), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLchar)(unsafe.Pointer(groupString))) +} +func GetPerfMonitorGroupsAMD(numGroups *int32, groupsSize int32, groups *uint32) { + C.glowGetPerfMonitorGroupsAMD(gpGetPerfMonitorGroupsAMD, (*C.GLint)(unsafe.Pointer(numGroups)), (C.GLsizei)(groupsSize), (*C.GLuint)(unsafe.Pointer(groups))) +} +func GetPerfQueryDataINTEL(queryHandle uint32, flags uint32, dataSize int32, data unsafe.Pointer, bytesWritten *uint32) { + C.glowGetPerfQueryDataINTEL(gpGetPerfQueryDataINTEL, (C.GLuint)(queryHandle), (C.GLuint)(flags), (C.GLsizei)(dataSize), data, (*C.GLuint)(unsafe.Pointer(bytesWritten))) +} +func GetPerfQueryIdByNameINTEL(queryName *uint8, queryId *uint32) { + C.glowGetPerfQueryIdByNameINTEL(gpGetPerfQueryIdByNameINTEL, (*C.GLchar)(unsafe.Pointer(queryName)), (*C.GLuint)(unsafe.Pointer(queryId))) +} +func GetPerfQueryInfoINTEL(queryId uint32, queryNameLength uint32, queryName *uint8, dataSize *uint32, noCounters *uint32, noInstances *uint32, capsMask *uint32) { + C.glowGetPerfQueryInfoINTEL(gpGetPerfQueryInfoINTEL, (C.GLuint)(queryId), (C.GLuint)(queryNameLength), (*C.GLchar)(unsafe.Pointer(queryName)), (*C.GLuint)(unsafe.Pointer(dataSize)), (*C.GLuint)(unsafe.Pointer(noCounters)), (*C.GLuint)(unsafe.Pointer(noInstances)), (*C.GLuint)(unsafe.Pointer(capsMask))) +} +func GetPointerIndexedvEXT(target uint32, index uint32, data *unsafe.Pointer) { + C.glowGetPointerIndexedvEXT(gpGetPointerIndexedvEXT, (C.GLenum)(target), (C.GLuint)(index), data) +} +func GetPointeri_vEXT(pname uint32, index uint32, params *unsafe.Pointer) { + C.glowGetPointeri_vEXT(gpGetPointeri_vEXT, (C.GLenum)(pname), (C.GLuint)(index), params) +} + +// return the address of the specified pointer +func GetPointerv(pname uint32, params *unsafe.Pointer) { + C.glowGetPointerv(gpGetPointerv, (C.GLenum)(pname), params) +} +func GetPointervKHR(pname uint32, params *unsafe.Pointer) { + C.glowGetPointervKHR(gpGetPointervKHR, (C.GLenum)(pname), params) +} + +// return a binary representation of a program object's compiled and linked executable source +func GetProgramBinary(program uint32, bufSize int32, length *int32, binaryFormat *uint32, binary unsafe.Pointer) { + C.glowGetProgramBinary(gpGetProgramBinary, (C.GLuint)(program), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLenum)(unsafe.Pointer(binaryFormat)), binary) +} + +// Returns the information log for a program object +func GetProgramInfoLog(program uint32, bufSize int32, length *int32, infoLog *uint8) { + C.glowGetProgramInfoLog(gpGetProgramInfoLog, (C.GLuint)(program), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLchar)(unsafe.Pointer(infoLog))) +} +func GetProgramInterfaceiv(program uint32, programInterface uint32, pname uint32, params *int32) { + C.glowGetProgramInterfaceiv(gpGetProgramInterfaceiv, (C.GLuint)(program), (C.GLenum)(programInterface), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} + +// retrieve the info log string from a program pipeline object +func GetProgramPipelineInfoLog(pipeline uint32, bufSize int32, length *int32, infoLog *uint8) { + C.glowGetProgramPipelineInfoLog(gpGetProgramPipelineInfoLog, (C.GLuint)(pipeline), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLchar)(unsafe.Pointer(infoLog))) +} +func GetProgramPipelineInfoLogEXT(pipeline uint32, bufSize int32, length *int32, infoLog *uint8) { + C.glowGetProgramPipelineInfoLogEXT(gpGetProgramPipelineInfoLogEXT, (C.GLuint)(pipeline), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLchar)(unsafe.Pointer(infoLog))) +} +func GetProgramPipelineiv(pipeline uint32, pname uint32, params *int32) { + C.glowGetProgramPipelineiv(gpGetProgramPipelineiv, (C.GLuint)(pipeline), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetProgramPipelineivEXT(pipeline uint32, pname uint32, params *int32) { + C.glowGetProgramPipelineivEXT(gpGetProgramPipelineivEXT, (C.GLuint)(pipeline), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} + +// query the index of a named resource within a program +func GetProgramResourceIndex(program uint32, programInterface uint32, name *uint8) uint32 { + ret := C.glowGetProgramResourceIndex(gpGetProgramResourceIndex, (C.GLuint)(program), (C.GLenum)(programInterface), (*C.GLchar)(unsafe.Pointer(name))) + return (uint32)(ret) +} + +// query the location of a named resource within a program +func GetProgramResourceLocation(program uint32, programInterface uint32, name *uint8) int32 { + ret := C.glowGetProgramResourceLocation(gpGetProgramResourceLocation, (C.GLuint)(program), (C.GLenum)(programInterface), (*C.GLchar)(unsafe.Pointer(name))) + return (int32)(ret) +} + +// query the fragment color index of a named variable within a program +func GetProgramResourceLocationIndex(program uint32, programInterface uint32, name *uint8) int32 { + ret := C.glowGetProgramResourceLocationIndex(gpGetProgramResourceLocationIndex, (C.GLuint)(program), (C.GLenum)(programInterface), (*C.GLchar)(unsafe.Pointer(name))) + return (int32)(ret) +} + +// query the name of an indexed resource within a program +func GetProgramResourceName(program uint32, programInterface uint32, index uint32, bufSize int32, length *int32, name *uint8) { + C.glowGetProgramResourceName(gpGetProgramResourceName, (C.GLuint)(program), (C.GLenum)(programInterface), (C.GLuint)(index), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLchar)(unsafe.Pointer(name))) +} +func GetProgramResourcefvNV(program uint32, programInterface uint32, index uint32, propCount int32, props *uint32, count int32, length *int32, params *float32) { + C.glowGetProgramResourcefvNV(gpGetProgramResourcefvNV, (C.GLuint)(program), (C.GLenum)(programInterface), (C.GLuint)(index), (C.GLsizei)(propCount), (*C.GLenum)(unsafe.Pointer(props)), (C.GLsizei)(count), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLfloat)(unsafe.Pointer(params))) +} +func GetProgramResourceiv(program uint32, programInterface uint32, index uint32, propCount int32, props *uint32, count int32, length *int32, params *int32) { + C.glowGetProgramResourceiv(gpGetProgramResourceiv, (C.GLuint)(program), (C.GLenum)(programInterface), (C.GLuint)(index), (C.GLsizei)(propCount), (*C.GLenum)(unsafe.Pointer(props)), (C.GLsizei)(count), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLint)(unsafe.Pointer(params))) +} +func GetProgramStageiv(program uint32, shadertype uint32, pname uint32, values *int32) { + C.glowGetProgramStageiv(gpGetProgramStageiv, (C.GLuint)(program), (C.GLenum)(shadertype), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(values))) +} + +// Returns a parameter from a program object +func GetProgramiv(program uint32, pname uint32, params *int32) { + C.glowGetProgramiv(gpGetProgramiv, (C.GLuint)(program), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetQueryBufferObjecti64v(id uint32, buffer uint32, pname uint32, offset int) { + C.glowGetQueryBufferObjecti64v(gpGetQueryBufferObjecti64v, (C.GLuint)(id), (C.GLuint)(buffer), (C.GLenum)(pname), (C.GLintptr)(offset)) +} +func GetQueryBufferObjectiv(id uint32, buffer uint32, pname uint32, offset int) { + C.glowGetQueryBufferObjectiv(gpGetQueryBufferObjectiv, (C.GLuint)(id), (C.GLuint)(buffer), (C.GLenum)(pname), (C.GLintptr)(offset)) +} +func GetQueryBufferObjectui64v(id uint32, buffer uint32, pname uint32, offset int) { + C.glowGetQueryBufferObjectui64v(gpGetQueryBufferObjectui64v, (C.GLuint)(id), (C.GLuint)(buffer), (C.GLenum)(pname), (C.GLintptr)(offset)) +} +func GetQueryBufferObjectuiv(id uint32, buffer uint32, pname uint32, offset int) { + C.glowGetQueryBufferObjectuiv(gpGetQueryBufferObjectuiv, (C.GLuint)(id), (C.GLuint)(buffer), (C.GLenum)(pname), (C.GLintptr)(offset)) +} + +// return parameters of an indexed query object target +func GetQueryIndexediv(target uint32, index uint32, pname uint32, params *int32) { + C.glowGetQueryIndexediv(gpGetQueryIndexediv, (C.GLenum)(target), (C.GLuint)(index), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetQueryObjecti64v(id uint32, pname uint32, params *int64) { + C.glowGetQueryObjecti64v(gpGetQueryObjecti64v, (C.GLuint)(id), (C.GLenum)(pname), (*C.GLint64)(unsafe.Pointer(params))) +} +func GetQueryObjectiv(id uint32, pname uint32, params *int32) { + C.glowGetQueryObjectiv(gpGetQueryObjectiv, (C.GLuint)(id), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetQueryObjectui64v(id uint32, pname uint32, params *uint64) { + C.glowGetQueryObjectui64v(gpGetQueryObjectui64v, (C.GLuint)(id), (C.GLenum)(pname), (*C.GLuint64)(unsafe.Pointer(params))) +} + +// return parameters of a query object +func GetQueryObjectuiv(id uint32, pname uint32, params *uint32) { + C.glowGetQueryObjectuiv(gpGetQueryObjectuiv, (C.GLuint)(id), (C.GLenum)(pname), (*C.GLuint)(unsafe.Pointer(params))) +} + +// return parameters of a query object target +func GetQueryiv(target uint32, pname uint32, params *int32) { + C.glowGetQueryiv(gpGetQueryiv, (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} + +// retrieve information about a bound renderbuffer object +func GetRenderbufferParameteriv(target uint32, pname uint32, params *int32) { + C.glowGetRenderbufferParameteriv(gpGetRenderbufferParameteriv, (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetSamplerParameterIiv(sampler uint32, pname uint32, params *int32) { + C.glowGetSamplerParameterIiv(gpGetSamplerParameterIiv, (C.GLuint)(sampler), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetSamplerParameterIuiv(sampler uint32, pname uint32, params *uint32) { + C.glowGetSamplerParameterIuiv(gpGetSamplerParameterIuiv, (C.GLuint)(sampler), (C.GLenum)(pname), (*C.GLuint)(unsafe.Pointer(params))) +} +func GetSamplerParameterfv(sampler uint32, pname uint32, params *float32) { + C.glowGetSamplerParameterfv(gpGetSamplerParameterfv, (C.GLuint)(sampler), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(params))) +} +func GetSamplerParameteriv(sampler uint32, pname uint32, params *int32) { + C.glowGetSamplerParameteriv(gpGetSamplerParameteriv, (C.GLuint)(sampler), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} + +// Returns the information log for a shader object +func GetShaderInfoLog(shader uint32, bufSize int32, length *int32, infoLog *uint8) { + C.glowGetShaderInfoLog(gpGetShaderInfoLog, (C.GLuint)(shader), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLchar)(unsafe.Pointer(infoLog))) +} + +// retrieve the range and precision for numeric formats supported by the shader compiler +func GetShaderPrecisionFormat(shadertype uint32, precisiontype uint32, xrange *int32, precision *int32) { + C.glowGetShaderPrecisionFormat(gpGetShaderPrecisionFormat, (C.GLenum)(shadertype), (C.GLenum)(precisiontype), (*C.GLint)(unsafe.Pointer(xrange)), (*C.GLint)(unsafe.Pointer(precision))) +} + +// Returns the source code string from a shader object +func GetShaderSource(shader uint32, bufSize int32, length *int32, source *uint8) { + C.glowGetShaderSource(gpGetShaderSource, (C.GLuint)(shader), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLchar)(unsafe.Pointer(source))) +} + +// Returns a parameter from a shader object +func GetShaderiv(shader uint32, pname uint32, params *int32) { + C.glowGetShaderiv(gpGetShaderiv, (C.GLuint)(shader), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetShadingRateImagePaletteNV(viewport uint32, entry uint32, rate *uint32) { + C.glowGetShadingRateImagePaletteNV(gpGetShadingRateImagePaletteNV, (C.GLuint)(viewport), (C.GLuint)(entry), (*C.GLenum)(unsafe.Pointer(rate))) +} +func GetShadingRateSampleLocationivNV(rate uint32, samples uint32, index uint32, location *int32) { + C.glowGetShadingRateSampleLocationivNV(gpGetShadingRateSampleLocationivNV, (C.GLenum)(rate), (C.GLuint)(samples), (C.GLuint)(index), (*C.GLint)(unsafe.Pointer(location))) +} +func GetStageIndexNV(shadertype uint32) uint16 { + ret := C.glowGetStageIndexNV(gpGetStageIndexNV, (C.GLenum)(shadertype)) + return (uint16)(ret) +} + +// return a string describing the current GL connection +func GetString(name uint32) *uint8 { + ret := C.glowGetString(gpGetString, (C.GLenum)(name)) + return (*uint8)(ret) +} +func GetStringi(name uint32, index uint32) *uint8 { + ret := C.glowGetStringi(gpGetStringi, (C.GLenum)(name), (C.GLuint)(index)) + return (*uint8)(ret) +} + +// retrieve the index of a subroutine uniform of a given shader stage within a program +func GetSubroutineIndex(program uint32, shadertype uint32, name *uint8) uint32 { + ret := C.glowGetSubroutineIndex(gpGetSubroutineIndex, (C.GLuint)(program), (C.GLenum)(shadertype), (*C.GLchar)(unsafe.Pointer(name))) + return (uint32)(ret) +} + +// retrieve the location of a subroutine uniform of a given shader stage within a program +func GetSubroutineUniformLocation(program uint32, shadertype uint32, name *uint8) int32 { + ret := C.glowGetSubroutineUniformLocation(gpGetSubroutineUniformLocation, (C.GLuint)(program), (C.GLenum)(shadertype), (*C.GLchar)(unsafe.Pointer(name))) + return (int32)(ret) +} + +// query the properties of a sync object +func GetSynciv(sync uintptr, pname uint32, count int32, length *int32, values *int32) { + C.glowGetSynciv(gpGetSynciv, (C.GLsync)(sync), (C.GLenum)(pname), (C.GLsizei)(count), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLint)(unsafe.Pointer(values))) +} + +// return a texture image +func GetTexImage(target uint32, level int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowGetTexImage(gpGetTexImage, (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} +func GetTexLevelParameterfv(target uint32, level int32, pname uint32, params *float32) { + C.glowGetTexLevelParameterfv(gpGetTexLevelParameterfv, (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(params))) +} +func GetTexLevelParameteriv(target uint32, level int32, pname uint32, params *int32) { + C.glowGetTexLevelParameteriv(gpGetTexLevelParameteriv, (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetTexParameterIiv(target uint32, pname uint32, params *int32) { + C.glowGetTexParameterIiv(gpGetTexParameterIiv, (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetTexParameterIuiv(target uint32, pname uint32, params *uint32) { + C.glowGetTexParameterIuiv(gpGetTexParameterIuiv, (C.GLenum)(target), (C.GLenum)(pname), (*C.GLuint)(unsafe.Pointer(params))) +} +func GetTexParameterfv(target uint32, pname uint32, params *float32) { + C.glowGetTexParameterfv(gpGetTexParameterfv, (C.GLenum)(target), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(params))) +} +func GetTexParameteriv(target uint32, pname uint32, params *int32) { + C.glowGetTexParameteriv(gpGetTexParameteriv, (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetTextureHandleARB(texture uint32) uint64 { + ret := C.glowGetTextureHandleARB(gpGetTextureHandleARB, (C.GLuint)(texture)) + return (uint64)(ret) +} +func GetTextureHandleNV(texture uint32) uint64 { + ret := C.glowGetTextureHandleNV(gpGetTextureHandleNV, (C.GLuint)(texture)) + return (uint64)(ret) +} + +// return a texture image +func GetTextureImage(texture uint32, level int32, format uint32, xtype uint32, bufSize int32, pixels unsafe.Pointer) { + C.glowGetTextureImage(gpGetTextureImage, (C.GLuint)(texture), (C.GLint)(level), (C.GLenum)(format), (C.GLenum)(xtype), (C.GLsizei)(bufSize), pixels) +} +func GetTextureImageEXT(texture uint32, target uint32, level int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowGetTextureImageEXT(gpGetTextureImageEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} +func GetTextureLevelParameterfv(texture uint32, level int32, pname uint32, params *float32) { + C.glowGetTextureLevelParameterfv(gpGetTextureLevelParameterfv, (C.GLuint)(texture), (C.GLint)(level), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(params))) +} +func GetTextureLevelParameterfvEXT(texture uint32, target uint32, level int32, pname uint32, params *float32) { + C.glowGetTextureLevelParameterfvEXT(gpGetTextureLevelParameterfvEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(params))) +} +func GetTextureLevelParameteriv(texture uint32, level int32, pname uint32, params *int32) { + C.glowGetTextureLevelParameteriv(gpGetTextureLevelParameteriv, (C.GLuint)(texture), (C.GLint)(level), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetTextureLevelParameterivEXT(texture uint32, target uint32, level int32, pname uint32, params *int32) { + C.glowGetTextureLevelParameterivEXT(gpGetTextureLevelParameterivEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetTextureParameterIiv(texture uint32, pname uint32, params *int32) { + C.glowGetTextureParameterIiv(gpGetTextureParameterIiv, (C.GLuint)(texture), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetTextureParameterIivEXT(texture uint32, target uint32, pname uint32, params *int32) { + C.glowGetTextureParameterIivEXT(gpGetTextureParameterIivEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetTextureParameterIuiv(texture uint32, pname uint32, params *uint32) { + C.glowGetTextureParameterIuiv(gpGetTextureParameterIuiv, (C.GLuint)(texture), (C.GLenum)(pname), (*C.GLuint)(unsafe.Pointer(params))) +} +func GetTextureParameterIuivEXT(texture uint32, target uint32, pname uint32, params *uint32) { + C.glowGetTextureParameterIuivEXT(gpGetTextureParameterIuivEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLuint)(unsafe.Pointer(params))) +} +func GetTextureParameterfv(texture uint32, pname uint32, params *float32) { + C.glowGetTextureParameterfv(gpGetTextureParameterfv, (C.GLuint)(texture), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(params))) +} +func GetTextureParameterfvEXT(texture uint32, target uint32, pname uint32, params *float32) { + C.glowGetTextureParameterfvEXT(gpGetTextureParameterfvEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(params))) +} +func GetTextureParameteriv(texture uint32, pname uint32, params *int32) { + C.glowGetTextureParameteriv(gpGetTextureParameteriv, (C.GLuint)(texture), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetTextureParameterivEXT(texture uint32, target uint32, pname uint32, params *int32) { + C.glowGetTextureParameterivEXT(gpGetTextureParameterivEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func GetTextureSamplerHandleARB(texture uint32, sampler uint32) uint64 { + ret := C.glowGetTextureSamplerHandleARB(gpGetTextureSamplerHandleARB, (C.GLuint)(texture), (C.GLuint)(sampler)) + return (uint64)(ret) +} +func GetTextureSamplerHandleNV(texture uint32, sampler uint32) uint64 { + ret := C.glowGetTextureSamplerHandleNV(gpGetTextureSamplerHandleNV, (C.GLuint)(texture), (C.GLuint)(sampler)) + return (uint64)(ret) +} + +// retrieve a sub-region of a texture image from a texture object +func GetTextureSubImage(texture uint32, level int32, xoffset int32, yoffset int32, zoffset int32, width int32, height int32, depth int32, format uint32, xtype uint32, bufSize int32, pixels unsafe.Pointer) { + C.glowGetTextureSubImage(gpGetTextureSubImage, (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLenum)(format), (C.GLenum)(xtype), (C.GLsizei)(bufSize), pixels) +} + +// retrieve information about varying variables selected for transform feedback +func GetTransformFeedbackVarying(program uint32, index uint32, bufSize int32, length *int32, size *int32, xtype *uint32, name *uint8) { + C.glowGetTransformFeedbackVarying(gpGetTransformFeedbackVarying, (C.GLuint)(program), (C.GLuint)(index), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLsizei)(unsafe.Pointer(size)), (*C.GLenum)(unsafe.Pointer(xtype)), (*C.GLchar)(unsafe.Pointer(name))) +} +func GetTransformFeedbacki64_v(xfb uint32, pname uint32, index uint32, param *int64) { + C.glowGetTransformFeedbacki64_v(gpGetTransformFeedbacki64_v, (C.GLuint)(xfb), (C.GLenum)(pname), (C.GLuint)(index), (*C.GLint64)(unsafe.Pointer(param))) +} +func GetTransformFeedbacki_v(xfb uint32, pname uint32, index uint32, param *int32) { + C.glowGetTransformFeedbacki_v(gpGetTransformFeedbacki_v, (C.GLuint)(xfb), (C.GLenum)(pname), (C.GLuint)(index), (*C.GLint)(unsafe.Pointer(param))) +} + +// query the state of a transform feedback object. +func GetTransformFeedbackiv(xfb uint32, pname uint32, param *int32) { + C.glowGetTransformFeedbackiv(gpGetTransformFeedbackiv, (C.GLuint)(xfb), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(param))) +} + +// retrieve the index of a named uniform block +func GetUniformBlockIndex(program uint32, uniformBlockName *uint8) uint32 { + ret := C.glowGetUniformBlockIndex(gpGetUniformBlockIndex, (C.GLuint)(program), (*C.GLchar)(unsafe.Pointer(uniformBlockName))) + return (uint32)(ret) +} + +// retrieve the index of a named uniform block +func GetUniformIndices(program uint32, uniformCount int32, uniformNames **uint8, uniformIndices *uint32) { + C.glowGetUniformIndices(gpGetUniformIndices, (C.GLuint)(program), (C.GLsizei)(uniformCount), (**C.GLchar)(unsafe.Pointer(uniformNames)), (*C.GLuint)(unsafe.Pointer(uniformIndices))) +} + +// Returns the location of a uniform variable +func GetUniformLocation(program uint32, name *uint8) int32 { + ret := C.glowGetUniformLocation(gpGetUniformLocation, (C.GLuint)(program), (*C.GLchar)(unsafe.Pointer(name))) + return (int32)(ret) +} +func GetUniformSubroutineuiv(shadertype uint32, location int32, params *uint32) { + C.glowGetUniformSubroutineuiv(gpGetUniformSubroutineuiv, (C.GLenum)(shadertype), (C.GLint)(location), (*C.GLuint)(unsafe.Pointer(params))) +} +func GetUniformdv(program uint32, location int32, params *float64) { + C.glowGetUniformdv(gpGetUniformdv, (C.GLuint)(program), (C.GLint)(location), (*C.GLdouble)(unsafe.Pointer(params))) +} + +// Returns the value of a uniform variable +func GetUniformfv(program uint32, location int32, params *float32) { + C.glowGetUniformfv(gpGetUniformfv, (C.GLuint)(program), (C.GLint)(location), (*C.GLfloat)(unsafe.Pointer(params))) +} +func GetUniformi64vARB(program uint32, location int32, params *int64) { + C.glowGetUniformi64vARB(gpGetUniformi64vARB, (C.GLuint)(program), (C.GLint)(location), (*C.GLint64)(unsafe.Pointer(params))) +} +func GetUniformi64vNV(program uint32, location int32, params *int64) { + C.glowGetUniformi64vNV(gpGetUniformi64vNV, (C.GLuint)(program), (C.GLint)(location), (*C.GLint64EXT)(unsafe.Pointer(params))) +} + +// Returns the value of a uniform variable +func GetUniformiv(program uint32, location int32, params *int32) { + C.glowGetUniformiv(gpGetUniformiv, (C.GLuint)(program), (C.GLint)(location), (*C.GLint)(unsafe.Pointer(params))) +} +func GetUniformui64vARB(program uint32, location int32, params *uint64) { + C.glowGetUniformui64vARB(gpGetUniformui64vARB, (C.GLuint)(program), (C.GLint)(location), (*C.GLuint64)(unsafe.Pointer(params))) +} +func GetUniformui64vNV(program uint32, location int32, params *uint64) { + C.glowGetUniformui64vNV(gpGetUniformui64vNV, (C.GLuint)(program), (C.GLint)(location), (*C.GLuint64EXT)(unsafe.Pointer(params))) +} +func GetUniformuiv(program uint32, location int32, params *uint32) { + C.glowGetUniformuiv(gpGetUniformuiv, (C.GLuint)(program), (C.GLint)(location), (*C.GLuint)(unsafe.Pointer(params))) +} +func GetVertexArrayIndexed64iv(vaobj uint32, index uint32, pname uint32, param *int64) { + C.glowGetVertexArrayIndexed64iv(gpGetVertexArrayIndexed64iv, (C.GLuint)(vaobj), (C.GLuint)(index), (C.GLenum)(pname), (*C.GLint64)(unsafe.Pointer(param))) +} +func GetVertexArrayIndexediv(vaobj uint32, index uint32, pname uint32, param *int32) { + C.glowGetVertexArrayIndexediv(gpGetVertexArrayIndexediv, (C.GLuint)(vaobj), (C.GLuint)(index), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(param))) +} +func GetVertexArrayIntegeri_vEXT(vaobj uint32, index uint32, pname uint32, param *int32) { + C.glowGetVertexArrayIntegeri_vEXT(gpGetVertexArrayIntegeri_vEXT, (C.GLuint)(vaobj), (C.GLuint)(index), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(param))) +} +func GetVertexArrayIntegervEXT(vaobj uint32, pname uint32, param *int32) { + C.glowGetVertexArrayIntegervEXT(gpGetVertexArrayIntegervEXT, (C.GLuint)(vaobj), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(param))) +} +func GetVertexArrayPointeri_vEXT(vaobj uint32, index uint32, pname uint32, param *unsafe.Pointer) { + C.glowGetVertexArrayPointeri_vEXT(gpGetVertexArrayPointeri_vEXT, (C.GLuint)(vaobj), (C.GLuint)(index), (C.GLenum)(pname), param) +} +func GetVertexArrayPointervEXT(vaobj uint32, pname uint32, param *unsafe.Pointer) { + C.glowGetVertexArrayPointervEXT(gpGetVertexArrayPointervEXT, (C.GLuint)(vaobj), (C.GLenum)(pname), param) +} + +// retrieve parameters of a vertex array object +func GetVertexArrayiv(vaobj uint32, pname uint32, param *int32) { + C.glowGetVertexArrayiv(gpGetVertexArrayiv, (C.GLuint)(vaobj), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(param))) +} + +// Return a generic vertex attribute parameter +func GetVertexAttribIiv(index uint32, pname uint32, params *int32) { + C.glowGetVertexAttribIiv(gpGetVertexAttribIiv, (C.GLuint)(index), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} + +// Return a generic vertex attribute parameter +func GetVertexAttribIuiv(index uint32, pname uint32, params *uint32) { + C.glowGetVertexAttribIuiv(gpGetVertexAttribIuiv, (C.GLuint)(index), (C.GLenum)(pname), (*C.GLuint)(unsafe.Pointer(params))) +} + +// Return a generic vertex attribute parameter +func GetVertexAttribLdv(index uint32, pname uint32, params *float64) { + C.glowGetVertexAttribLdv(gpGetVertexAttribLdv, (C.GLuint)(index), (C.GLenum)(pname), (*C.GLdouble)(unsafe.Pointer(params))) +} +func GetVertexAttribLi64vNV(index uint32, pname uint32, params *int64) { + C.glowGetVertexAttribLi64vNV(gpGetVertexAttribLi64vNV, (C.GLuint)(index), (C.GLenum)(pname), (*C.GLint64EXT)(unsafe.Pointer(params))) +} +func GetVertexAttribLui64vARB(index uint32, pname uint32, params *uint64) { + C.glowGetVertexAttribLui64vARB(gpGetVertexAttribLui64vARB, (C.GLuint)(index), (C.GLenum)(pname), (*C.GLuint64EXT)(unsafe.Pointer(params))) +} +func GetVertexAttribLui64vNV(index uint32, pname uint32, params *uint64) { + C.glowGetVertexAttribLui64vNV(gpGetVertexAttribLui64vNV, (C.GLuint)(index), (C.GLenum)(pname), (*C.GLuint64EXT)(unsafe.Pointer(params))) +} + +// return the address of the specified generic vertex attribute pointer +func GetVertexAttribPointerv(index uint32, pname uint32, pointer *unsafe.Pointer) { + C.glowGetVertexAttribPointerv(gpGetVertexAttribPointerv, (C.GLuint)(index), (C.GLenum)(pname), pointer) +} +func GetVertexAttribPointerWithOffsetv(index uint32, pname uint32, offset **uintptr) { + C.glowGetVertexAttribPointerWithOffsetv(gpGetVertexAttribPointerv, (C.GLuint)(index), (C.GLenum)(pname), (**C.uintptr_t)(unsafe.Pointer(offset))) +} + +// Return a generic vertex attribute parameter +func GetVertexAttribdv(index uint32, pname uint32, params *float64) { + C.glowGetVertexAttribdv(gpGetVertexAttribdv, (C.GLuint)(index), (C.GLenum)(pname), (*C.GLdouble)(unsafe.Pointer(params))) +} + +// Return a generic vertex attribute parameter +func GetVertexAttribfv(index uint32, pname uint32, params *float32) { + C.glowGetVertexAttribfv(gpGetVertexAttribfv, (C.GLuint)(index), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(params))) +} + +// Return a generic vertex attribute parameter +func GetVertexAttribiv(index uint32, pname uint32, params *int32) { + C.glowGetVertexAttribiv(gpGetVertexAttribiv, (C.GLuint)(index), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} + +// Return value has type C.GLVULKANPROCNV. +func GetVkProcAddrNV(name *uint8) unsafe.Pointer { + ret := C.glowGetVkProcAddrNV(gpGetVkProcAddrNV, (*C.GLchar)(unsafe.Pointer(name))) + return (unsafe.Pointer)(ret) +} +func GetnCompressedTexImageARB(target uint32, lod int32, bufSize int32, img unsafe.Pointer) { + C.glowGetnCompressedTexImageARB(gpGetnCompressedTexImageARB, (C.GLenum)(target), (C.GLint)(lod), (C.GLsizei)(bufSize), img) +} +func GetnTexImageARB(target uint32, level int32, format uint32, xtype uint32, bufSize int32, img unsafe.Pointer) { + C.glowGetnTexImageARB(gpGetnTexImageARB, (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(format), (C.GLenum)(xtype), (C.GLsizei)(bufSize), img) +} +func GetnUniformdvARB(program uint32, location int32, bufSize int32, params *float64) { + C.glowGetnUniformdvARB(gpGetnUniformdvARB, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(bufSize), (*C.GLdouble)(unsafe.Pointer(params))) +} +func GetnUniformfv(program uint32, location int32, bufSize int32, params *float32) { + C.glowGetnUniformfv(gpGetnUniformfv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(bufSize), (*C.GLfloat)(unsafe.Pointer(params))) +} +func GetnUniformfvARB(program uint32, location int32, bufSize int32, params *float32) { + C.glowGetnUniformfvARB(gpGetnUniformfvARB, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(bufSize), (*C.GLfloat)(unsafe.Pointer(params))) +} +func GetnUniformfvKHR(program uint32, location int32, bufSize int32, params *float32) { + C.glowGetnUniformfvKHR(gpGetnUniformfvKHR, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(bufSize), (*C.GLfloat)(unsafe.Pointer(params))) +} +func GetnUniformi64vARB(program uint32, location int32, bufSize int32, params *int64) { + C.glowGetnUniformi64vARB(gpGetnUniformi64vARB, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(bufSize), (*C.GLint64)(unsafe.Pointer(params))) +} +func GetnUniformiv(program uint32, location int32, bufSize int32, params *int32) { + C.glowGetnUniformiv(gpGetnUniformiv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(bufSize), (*C.GLint)(unsafe.Pointer(params))) +} +func GetnUniformivARB(program uint32, location int32, bufSize int32, params *int32) { + C.glowGetnUniformivARB(gpGetnUniformivARB, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(bufSize), (*C.GLint)(unsafe.Pointer(params))) +} +func GetnUniformivKHR(program uint32, location int32, bufSize int32, params *int32) { + C.glowGetnUniformivKHR(gpGetnUniformivKHR, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(bufSize), (*C.GLint)(unsafe.Pointer(params))) +} +func GetnUniformui64vARB(program uint32, location int32, bufSize int32, params *uint64) { + C.glowGetnUniformui64vARB(gpGetnUniformui64vARB, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(bufSize), (*C.GLuint64)(unsafe.Pointer(params))) +} +func GetnUniformuiv(program uint32, location int32, bufSize int32, params *uint32) { + C.glowGetnUniformuiv(gpGetnUniformuiv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(bufSize), (*C.GLuint)(unsafe.Pointer(params))) +} +func GetnUniformuivARB(program uint32, location int32, bufSize int32, params *uint32) { + C.glowGetnUniformuivARB(gpGetnUniformuivARB, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(bufSize), (*C.GLuint)(unsafe.Pointer(params))) +} +func GetnUniformuivKHR(program uint32, location int32, bufSize int32, params *uint32) { + C.glowGetnUniformuivKHR(gpGetnUniformuivKHR, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(bufSize), (*C.GLuint)(unsafe.Pointer(params))) +} + +// specify implementation-specific hints +func Hint(target uint32, mode uint32) { + C.glowHint(gpHint, (C.GLenum)(target), (C.GLenum)(mode)) +} +func IndexFormatNV(xtype uint32, stride int32) { + C.glowIndexFormatNV(gpIndexFormatNV, (C.GLenum)(xtype), (C.GLsizei)(stride)) +} +func InsertEventMarkerEXT(length int32, marker *uint8) { + C.glowInsertEventMarkerEXT(gpInsertEventMarkerEXT, (C.GLsizei)(length), (*C.GLchar)(unsafe.Pointer(marker))) +} +func InterpolatePathsNV(resultPath uint32, pathA uint32, pathB uint32, weight float32) { + C.glowInterpolatePathsNV(gpInterpolatePathsNV, (C.GLuint)(resultPath), (C.GLuint)(pathA), (C.GLuint)(pathB), (C.GLfloat)(weight)) +} + +// invalidate the content of a buffer object's data store +func InvalidateBufferData(buffer uint32) { + C.glowInvalidateBufferData(gpInvalidateBufferData, (C.GLuint)(buffer)) +} + +// invalidate a region of a buffer object's data store +func InvalidateBufferSubData(buffer uint32, offset int, length int) { + C.glowInvalidateBufferSubData(gpInvalidateBufferSubData, (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(length)) +} + +// invalidate the content of some or all of a framebuffer's attachments +func InvalidateFramebuffer(target uint32, numAttachments int32, attachments *uint32) { + C.glowInvalidateFramebuffer(gpInvalidateFramebuffer, (C.GLenum)(target), (C.GLsizei)(numAttachments), (*C.GLenum)(unsafe.Pointer(attachments))) +} + +// invalidate the content of some or all of a framebuffer's attachments +func InvalidateNamedFramebufferData(framebuffer uint32, numAttachments int32, attachments *uint32) { + C.glowInvalidateNamedFramebufferData(gpInvalidateNamedFramebufferData, (C.GLuint)(framebuffer), (C.GLsizei)(numAttachments), (*C.GLenum)(unsafe.Pointer(attachments))) +} + +// invalidate the content of a region of some or all of a framebuffer's attachments +func InvalidateNamedFramebufferSubData(framebuffer uint32, numAttachments int32, attachments *uint32, x int32, y int32, width int32, height int32) { + C.glowInvalidateNamedFramebufferSubData(gpInvalidateNamedFramebufferSubData, (C.GLuint)(framebuffer), (C.GLsizei)(numAttachments), (*C.GLenum)(unsafe.Pointer(attachments)), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height)) +} + +// invalidate the content of a region of some or all of a framebuffer's attachments +func InvalidateSubFramebuffer(target uint32, numAttachments int32, attachments *uint32, x int32, y int32, width int32, height int32) { + C.glowInvalidateSubFramebuffer(gpInvalidateSubFramebuffer, (C.GLenum)(target), (C.GLsizei)(numAttachments), (*C.GLenum)(unsafe.Pointer(attachments)), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height)) +} + +// invalidate the entirety a texture image +func InvalidateTexImage(texture uint32, level int32) { + C.glowInvalidateTexImage(gpInvalidateTexImage, (C.GLuint)(texture), (C.GLint)(level)) +} + +// invalidate a region of a texture image +func InvalidateTexSubImage(texture uint32, level int32, xoffset int32, yoffset int32, zoffset int32, width int32, height int32, depth int32) { + C.glowInvalidateTexSubImage(gpInvalidateTexSubImage, (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth)) +} + +// determine if a name corresponds to a buffer object +func IsBuffer(buffer uint32) bool { + ret := C.glowIsBuffer(gpIsBuffer, (C.GLuint)(buffer)) + return ret == TRUE +} +func IsBufferResidentNV(target uint32) bool { + ret := C.glowIsBufferResidentNV(gpIsBufferResidentNV, (C.GLenum)(target)) + return ret == TRUE +} +func IsCommandListNV(list uint32) bool { + ret := C.glowIsCommandListNV(gpIsCommandListNV, (C.GLuint)(list)) + return ret == TRUE +} +func IsEnabled(cap uint32) bool { + ret := C.glowIsEnabled(gpIsEnabled, (C.GLenum)(cap)) + return ret == TRUE +} +func IsEnabledIndexedEXT(target uint32, index uint32) bool { + ret := C.glowIsEnabledIndexedEXT(gpIsEnabledIndexedEXT, (C.GLenum)(target), (C.GLuint)(index)) + return ret == TRUE +} +func IsEnabledi(target uint32, index uint32) bool { + ret := C.glowIsEnabledi(gpIsEnabledi, (C.GLenum)(target), (C.GLuint)(index)) + return ret == TRUE +} + +// determine if a name corresponds to a framebuffer object +func IsFramebuffer(framebuffer uint32) bool { + ret := C.glowIsFramebuffer(gpIsFramebuffer, (C.GLuint)(framebuffer)) + return ret == TRUE +} +func IsImageHandleResidentARB(handle uint64) bool { + ret := C.glowIsImageHandleResidentARB(gpIsImageHandleResidentARB, (C.GLuint64)(handle)) + return ret == TRUE +} +func IsImageHandleResidentNV(handle uint64) bool { + ret := C.glowIsImageHandleResidentNV(gpIsImageHandleResidentNV, (C.GLuint64)(handle)) + return ret == TRUE +} +func IsNamedBufferResidentNV(buffer uint32) bool { + ret := C.glowIsNamedBufferResidentNV(gpIsNamedBufferResidentNV, (C.GLuint)(buffer)) + return ret == TRUE +} +func IsNamedStringARB(namelen int32, name *uint8) bool { + ret := C.glowIsNamedStringARB(gpIsNamedStringARB, (C.GLint)(namelen), (*C.GLchar)(unsafe.Pointer(name))) + return ret == TRUE +} +func IsPathNV(path uint32) bool { + ret := C.glowIsPathNV(gpIsPathNV, (C.GLuint)(path)) + return ret == TRUE +} +func IsPointInFillPathNV(path uint32, mask uint32, x float32, y float32) bool { + ret := C.glowIsPointInFillPathNV(gpIsPointInFillPathNV, (C.GLuint)(path), (C.GLuint)(mask), (C.GLfloat)(x), (C.GLfloat)(y)) + return ret == TRUE +} +func IsPointInStrokePathNV(path uint32, x float32, y float32) bool { + ret := C.glowIsPointInStrokePathNV(gpIsPointInStrokePathNV, (C.GLuint)(path), (C.GLfloat)(x), (C.GLfloat)(y)) + return ret == TRUE +} + +// Determines if a name corresponds to a program object +func IsProgram(program uint32) bool { + ret := C.glowIsProgram(gpIsProgram, (C.GLuint)(program)) + return ret == TRUE +} + +// determine if a name corresponds to a program pipeline object +func IsProgramPipeline(pipeline uint32) bool { + ret := C.glowIsProgramPipeline(gpIsProgramPipeline, (C.GLuint)(pipeline)) + return ret == TRUE +} +func IsProgramPipelineEXT(pipeline uint32) bool { + ret := C.glowIsProgramPipelineEXT(gpIsProgramPipelineEXT, (C.GLuint)(pipeline)) + return ret == TRUE +} + +// determine if a name corresponds to a query object +func IsQuery(id uint32) bool { + ret := C.glowIsQuery(gpIsQuery, (C.GLuint)(id)) + return ret == TRUE +} + +// determine if a name corresponds to a renderbuffer object +func IsRenderbuffer(renderbuffer uint32) bool { + ret := C.glowIsRenderbuffer(gpIsRenderbuffer, (C.GLuint)(renderbuffer)) + return ret == TRUE +} + +// determine if a name corresponds to a sampler object +func IsSampler(sampler uint32) bool { + ret := C.glowIsSampler(gpIsSampler, (C.GLuint)(sampler)) + return ret == TRUE +} + +// Determines if a name corresponds to a shader object +func IsShader(shader uint32) bool { + ret := C.glowIsShader(gpIsShader, (C.GLuint)(shader)) + return ret == TRUE +} +func IsStateNV(state uint32) bool { + ret := C.glowIsStateNV(gpIsStateNV, (C.GLuint)(state)) + return ret == TRUE +} + +// determine if a name corresponds to a sync object +func IsSync(sync uintptr) bool { + ret := C.glowIsSync(gpIsSync, (C.GLsync)(sync)) + return ret == TRUE +} + +// determine if a name corresponds to a texture +func IsTexture(texture uint32) bool { + ret := C.glowIsTexture(gpIsTexture, (C.GLuint)(texture)) + return ret == TRUE +} +func IsTextureHandleResidentARB(handle uint64) bool { + ret := C.glowIsTextureHandleResidentARB(gpIsTextureHandleResidentARB, (C.GLuint64)(handle)) + return ret == TRUE +} +func IsTextureHandleResidentNV(handle uint64) bool { + ret := C.glowIsTextureHandleResidentNV(gpIsTextureHandleResidentNV, (C.GLuint64)(handle)) + return ret == TRUE +} + +// determine if a name corresponds to a transform feedback object +func IsTransformFeedback(id uint32) bool { + ret := C.glowIsTransformFeedback(gpIsTransformFeedback, (C.GLuint)(id)) + return ret == TRUE +} + +// determine if a name corresponds to a vertex array object +func IsVertexArray(array uint32) bool { + ret := C.glowIsVertexArray(gpIsVertexArray, (C.GLuint)(array)) + return ret == TRUE +} +func LabelObjectEXT(xtype uint32, object uint32, length int32, label *uint8) { + C.glowLabelObjectEXT(gpLabelObjectEXT, (C.GLenum)(xtype), (C.GLuint)(object), (C.GLsizei)(length), (*C.GLchar)(unsafe.Pointer(label))) +} + +// specify the width of rasterized lines +func LineWidth(width float32) { + C.glowLineWidth(gpLineWidth, (C.GLfloat)(width)) +} + +// Links a program object +func LinkProgram(program uint32) { + C.glowLinkProgram(gpLinkProgram, (C.GLuint)(program)) +} +func ListDrawCommandsStatesClientNV(list uint32, segment uint32, indirects *unsafe.Pointer, sizes *int32, states *uint32, fbos *uint32, count uint32) { + C.glowListDrawCommandsStatesClientNV(gpListDrawCommandsStatesClientNV, (C.GLuint)(list), (C.GLuint)(segment), indirects, (*C.GLsizei)(unsafe.Pointer(sizes)), (*C.GLuint)(unsafe.Pointer(states)), (*C.GLuint)(unsafe.Pointer(fbos)), (C.GLuint)(count)) +} + +// specify a logical pixel operation for rendering +func LogicOp(opcode uint32) { + C.glowLogicOp(gpLogicOp, (C.GLenum)(opcode)) +} +func MakeBufferNonResidentNV(target uint32) { + C.glowMakeBufferNonResidentNV(gpMakeBufferNonResidentNV, (C.GLenum)(target)) +} +func MakeBufferResidentNV(target uint32, access uint32) { + C.glowMakeBufferResidentNV(gpMakeBufferResidentNV, (C.GLenum)(target), (C.GLenum)(access)) +} +func MakeImageHandleNonResidentARB(handle uint64) { + C.glowMakeImageHandleNonResidentARB(gpMakeImageHandleNonResidentARB, (C.GLuint64)(handle)) +} +func MakeImageHandleNonResidentNV(handle uint64) { + C.glowMakeImageHandleNonResidentNV(gpMakeImageHandleNonResidentNV, (C.GLuint64)(handle)) +} +func MakeImageHandleResidentARB(handle uint64, access uint32) { + C.glowMakeImageHandleResidentARB(gpMakeImageHandleResidentARB, (C.GLuint64)(handle), (C.GLenum)(access)) +} +func MakeImageHandleResidentNV(handle uint64, access uint32) { + C.glowMakeImageHandleResidentNV(gpMakeImageHandleResidentNV, (C.GLuint64)(handle), (C.GLenum)(access)) +} +func MakeNamedBufferNonResidentNV(buffer uint32) { + C.glowMakeNamedBufferNonResidentNV(gpMakeNamedBufferNonResidentNV, (C.GLuint)(buffer)) +} +func MakeNamedBufferResidentNV(buffer uint32, access uint32) { + C.glowMakeNamedBufferResidentNV(gpMakeNamedBufferResidentNV, (C.GLuint)(buffer), (C.GLenum)(access)) +} +func MakeTextureHandleNonResidentARB(handle uint64) { + C.glowMakeTextureHandleNonResidentARB(gpMakeTextureHandleNonResidentARB, (C.GLuint64)(handle)) +} +func MakeTextureHandleNonResidentNV(handle uint64) { + C.glowMakeTextureHandleNonResidentNV(gpMakeTextureHandleNonResidentNV, (C.GLuint64)(handle)) +} +func MakeTextureHandleResidentARB(handle uint64) { + C.glowMakeTextureHandleResidentARB(gpMakeTextureHandleResidentARB, (C.GLuint64)(handle)) +} +func MakeTextureHandleResidentNV(handle uint64) { + C.glowMakeTextureHandleResidentNV(gpMakeTextureHandleResidentNV, (C.GLuint64)(handle)) +} + +// map all of a buffer object's data store into the client's address space +func MapBuffer(target uint32, access uint32) unsafe.Pointer { + ret := C.glowMapBuffer(gpMapBuffer, (C.GLenum)(target), (C.GLenum)(access)) + return (unsafe.Pointer)(ret) +} + +// map all or part of a buffer object's data store into the client's address space +func MapBufferRange(target uint32, offset int, length int, access uint32) unsafe.Pointer { + ret := C.glowMapBufferRange(gpMapBufferRange, (C.GLenum)(target), (C.GLintptr)(offset), (C.GLsizeiptr)(length), (C.GLbitfield)(access)) + return (unsafe.Pointer)(ret) +} + +// map all of a buffer object's data store into the client's address space +func MapNamedBuffer(buffer uint32, access uint32) unsafe.Pointer { + ret := C.glowMapNamedBuffer(gpMapNamedBuffer, (C.GLuint)(buffer), (C.GLenum)(access)) + return (unsafe.Pointer)(ret) +} +func MapNamedBufferEXT(buffer uint32, access uint32) unsafe.Pointer { + ret := C.glowMapNamedBufferEXT(gpMapNamedBufferEXT, (C.GLuint)(buffer), (C.GLenum)(access)) + return (unsafe.Pointer)(ret) +} + +// map all or part of a buffer object's data store into the client's address space +func MapNamedBufferRange(buffer uint32, offset int, length int, access uint32) unsafe.Pointer { + ret := C.glowMapNamedBufferRange(gpMapNamedBufferRange, (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(length), (C.GLbitfield)(access)) + return (unsafe.Pointer)(ret) +} +func MapNamedBufferRangeEXT(buffer uint32, offset int, length int, access uint32) unsafe.Pointer { + ret := C.glowMapNamedBufferRangeEXT(gpMapNamedBufferRangeEXT, (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(length), (C.GLbitfield)(access)) + return (unsafe.Pointer)(ret) +} +func MatrixFrustumEXT(mode uint32, left float64, right float64, bottom float64, top float64, zNear float64, zFar float64) { + C.glowMatrixFrustumEXT(gpMatrixFrustumEXT, (C.GLenum)(mode), (C.GLdouble)(left), (C.GLdouble)(right), (C.GLdouble)(bottom), (C.GLdouble)(top), (C.GLdouble)(zNear), (C.GLdouble)(zFar)) +} +func MatrixLoad3x2fNV(matrixMode uint32, m *float32) { + C.glowMatrixLoad3x2fNV(gpMatrixLoad3x2fNV, (C.GLenum)(matrixMode), (*C.GLfloat)(unsafe.Pointer(m))) +} +func MatrixLoad3x3fNV(matrixMode uint32, m *float32) { + C.glowMatrixLoad3x3fNV(gpMatrixLoad3x3fNV, (C.GLenum)(matrixMode), (*C.GLfloat)(unsafe.Pointer(m))) +} +func MatrixLoadIdentityEXT(mode uint32) { + C.glowMatrixLoadIdentityEXT(gpMatrixLoadIdentityEXT, (C.GLenum)(mode)) +} +func MatrixLoadTranspose3x3fNV(matrixMode uint32, m *float32) { + C.glowMatrixLoadTranspose3x3fNV(gpMatrixLoadTranspose3x3fNV, (C.GLenum)(matrixMode), (*C.GLfloat)(unsafe.Pointer(m))) +} +func MatrixLoadTransposedEXT(mode uint32, m *float64) { + C.glowMatrixLoadTransposedEXT(gpMatrixLoadTransposedEXT, (C.GLenum)(mode), (*C.GLdouble)(unsafe.Pointer(m))) +} +func MatrixLoadTransposefEXT(mode uint32, m *float32) { + C.glowMatrixLoadTransposefEXT(gpMatrixLoadTransposefEXT, (C.GLenum)(mode), (*C.GLfloat)(unsafe.Pointer(m))) +} +func MatrixLoaddEXT(mode uint32, m *float64) { + C.glowMatrixLoaddEXT(gpMatrixLoaddEXT, (C.GLenum)(mode), (*C.GLdouble)(unsafe.Pointer(m))) +} +func MatrixLoadfEXT(mode uint32, m *float32) { + C.glowMatrixLoadfEXT(gpMatrixLoadfEXT, (C.GLenum)(mode), (*C.GLfloat)(unsafe.Pointer(m))) +} +func MatrixMult3x2fNV(matrixMode uint32, m *float32) { + C.glowMatrixMult3x2fNV(gpMatrixMult3x2fNV, (C.GLenum)(matrixMode), (*C.GLfloat)(unsafe.Pointer(m))) +} +func MatrixMult3x3fNV(matrixMode uint32, m *float32) { + C.glowMatrixMult3x3fNV(gpMatrixMult3x3fNV, (C.GLenum)(matrixMode), (*C.GLfloat)(unsafe.Pointer(m))) +} +func MatrixMultTranspose3x3fNV(matrixMode uint32, m *float32) { + C.glowMatrixMultTranspose3x3fNV(gpMatrixMultTranspose3x3fNV, (C.GLenum)(matrixMode), (*C.GLfloat)(unsafe.Pointer(m))) +} +func MatrixMultTransposedEXT(mode uint32, m *float64) { + C.glowMatrixMultTransposedEXT(gpMatrixMultTransposedEXT, (C.GLenum)(mode), (*C.GLdouble)(unsafe.Pointer(m))) +} +func MatrixMultTransposefEXT(mode uint32, m *float32) { + C.glowMatrixMultTransposefEXT(gpMatrixMultTransposefEXT, (C.GLenum)(mode), (*C.GLfloat)(unsafe.Pointer(m))) +} +func MatrixMultdEXT(mode uint32, m *float64) { + C.glowMatrixMultdEXT(gpMatrixMultdEXT, (C.GLenum)(mode), (*C.GLdouble)(unsafe.Pointer(m))) +} +func MatrixMultfEXT(mode uint32, m *float32) { + C.glowMatrixMultfEXT(gpMatrixMultfEXT, (C.GLenum)(mode), (*C.GLfloat)(unsafe.Pointer(m))) +} +func MatrixOrthoEXT(mode uint32, left float64, right float64, bottom float64, top float64, zNear float64, zFar float64) { + C.glowMatrixOrthoEXT(gpMatrixOrthoEXT, (C.GLenum)(mode), (C.GLdouble)(left), (C.GLdouble)(right), (C.GLdouble)(bottom), (C.GLdouble)(top), (C.GLdouble)(zNear), (C.GLdouble)(zFar)) +} +func MatrixPopEXT(mode uint32) { + C.glowMatrixPopEXT(gpMatrixPopEXT, (C.GLenum)(mode)) +} +func MatrixPushEXT(mode uint32) { + C.glowMatrixPushEXT(gpMatrixPushEXT, (C.GLenum)(mode)) +} +func MatrixRotatedEXT(mode uint32, angle float64, x float64, y float64, z float64) { + C.glowMatrixRotatedEXT(gpMatrixRotatedEXT, (C.GLenum)(mode), (C.GLdouble)(angle), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z)) +} +func MatrixRotatefEXT(mode uint32, angle float32, x float32, y float32, z float32) { + C.glowMatrixRotatefEXT(gpMatrixRotatefEXT, (C.GLenum)(mode), (C.GLfloat)(angle), (C.GLfloat)(x), (C.GLfloat)(y), (C.GLfloat)(z)) +} +func MatrixScaledEXT(mode uint32, x float64, y float64, z float64) { + C.glowMatrixScaledEXT(gpMatrixScaledEXT, (C.GLenum)(mode), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z)) +} +func MatrixScalefEXT(mode uint32, x float32, y float32, z float32) { + C.glowMatrixScalefEXT(gpMatrixScalefEXT, (C.GLenum)(mode), (C.GLfloat)(x), (C.GLfloat)(y), (C.GLfloat)(z)) +} +func MatrixTranslatedEXT(mode uint32, x float64, y float64, z float64) { + C.glowMatrixTranslatedEXT(gpMatrixTranslatedEXT, (C.GLenum)(mode), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z)) +} +func MatrixTranslatefEXT(mode uint32, x float32, y float32, z float32) { + C.glowMatrixTranslatefEXT(gpMatrixTranslatefEXT, (C.GLenum)(mode), (C.GLfloat)(x), (C.GLfloat)(y), (C.GLfloat)(z)) +} +func MaxShaderCompilerThreadsARB(count uint32) { + C.glowMaxShaderCompilerThreadsARB(gpMaxShaderCompilerThreadsARB, (C.GLuint)(count)) +} +func MaxShaderCompilerThreadsKHR(count uint32) { + C.glowMaxShaderCompilerThreadsKHR(gpMaxShaderCompilerThreadsKHR, (C.GLuint)(count)) +} + +// defines a barrier ordering memory transactions +func MemoryBarrier(barriers uint32) { + C.glowMemoryBarrier(gpMemoryBarrier, (C.GLbitfield)(barriers)) +} +func MemoryBarrierByRegion(barriers uint32) { + C.glowMemoryBarrierByRegion(gpMemoryBarrierByRegion, (C.GLbitfield)(barriers)) +} +func MinSampleShadingARB(value float32) { + C.glowMinSampleShadingARB(gpMinSampleShadingARB, (C.GLfloat)(value)) +} + +// render multiple sets of primitives from array data +func MultiDrawArrays(mode uint32, first *int32, count *int32, drawcount int32) { + C.glowMultiDrawArrays(gpMultiDrawArrays, (C.GLenum)(mode), (*C.GLint)(unsafe.Pointer(first)), (*C.GLsizei)(unsafe.Pointer(count)), (C.GLsizei)(drawcount)) +} + +// render multiple sets of primitives from array data, taking parameters from memory +func MultiDrawArraysIndirect(mode uint32, indirect unsafe.Pointer, drawcount int32, stride int32) { + C.glowMultiDrawArraysIndirect(gpMultiDrawArraysIndirect, (C.GLenum)(mode), indirect, (C.GLsizei)(drawcount), (C.GLsizei)(stride)) +} +func MultiDrawArraysIndirectBindlessCountNV(mode uint32, indirect unsafe.Pointer, drawCount int32, maxDrawCount int32, stride int32, vertexBufferCount int32) { + C.glowMultiDrawArraysIndirectBindlessCountNV(gpMultiDrawArraysIndirectBindlessCountNV, (C.GLenum)(mode), indirect, (C.GLsizei)(drawCount), (C.GLsizei)(maxDrawCount), (C.GLsizei)(stride), (C.GLint)(vertexBufferCount)) +} +func MultiDrawArraysIndirectBindlessNV(mode uint32, indirect unsafe.Pointer, drawCount int32, stride int32, vertexBufferCount int32) { + C.glowMultiDrawArraysIndirectBindlessNV(gpMultiDrawArraysIndirectBindlessNV, (C.GLenum)(mode), indirect, (C.GLsizei)(drawCount), (C.GLsizei)(stride), (C.GLint)(vertexBufferCount)) +} +func MultiDrawArraysIndirectCountARB(mode uint32, indirect unsafe.Pointer, drawcount int, maxdrawcount int32, stride int32) { + C.glowMultiDrawArraysIndirectCountARB(gpMultiDrawArraysIndirectCountARB, (C.GLenum)(mode), indirect, (C.GLintptr)(drawcount), (C.GLsizei)(maxdrawcount), (C.GLsizei)(stride)) +} + +// render multiple sets of primitives by specifying indices of array data elements +func MultiDrawElements(mode uint32, count *int32, xtype uint32, indices *unsafe.Pointer, drawcount int32) { + C.glowMultiDrawElements(gpMultiDrawElements, (C.GLenum)(mode), (*C.GLsizei)(unsafe.Pointer(count)), (C.GLenum)(xtype), indices, (C.GLsizei)(drawcount)) +} + +// render multiple sets of primitives by specifying indices of array data elements and an index to apply to each index +func MultiDrawElementsBaseVertex(mode uint32, count *int32, xtype uint32, indices *unsafe.Pointer, drawcount int32, basevertex *int32) { + C.glowMultiDrawElementsBaseVertex(gpMultiDrawElementsBaseVertex, (C.GLenum)(mode), (*C.GLsizei)(unsafe.Pointer(count)), (C.GLenum)(xtype), indices, (C.GLsizei)(drawcount), (*C.GLint)(unsafe.Pointer(basevertex))) +} + +// render indexed primitives from array data, taking parameters from memory +func MultiDrawElementsIndirect(mode uint32, xtype uint32, indirect unsafe.Pointer, drawcount int32, stride int32) { + C.glowMultiDrawElementsIndirect(gpMultiDrawElementsIndirect, (C.GLenum)(mode), (C.GLenum)(xtype), indirect, (C.GLsizei)(drawcount), (C.GLsizei)(stride)) +} +func MultiDrawElementsIndirectBindlessCountNV(mode uint32, xtype uint32, indirect unsafe.Pointer, drawCount int32, maxDrawCount int32, stride int32, vertexBufferCount int32) { + C.glowMultiDrawElementsIndirectBindlessCountNV(gpMultiDrawElementsIndirectBindlessCountNV, (C.GLenum)(mode), (C.GLenum)(xtype), indirect, (C.GLsizei)(drawCount), (C.GLsizei)(maxDrawCount), (C.GLsizei)(stride), (C.GLint)(vertexBufferCount)) +} +func MultiDrawElementsIndirectBindlessNV(mode uint32, xtype uint32, indirect unsafe.Pointer, drawCount int32, stride int32, vertexBufferCount int32) { + C.glowMultiDrawElementsIndirectBindlessNV(gpMultiDrawElementsIndirectBindlessNV, (C.GLenum)(mode), (C.GLenum)(xtype), indirect, (C.GLsizei)(drawCount), (C.GLsizei)(stride), (C.GLint)(vertexBufferCount)) +} +func MultiDrawElementsIndirectCountARB(mode uint32, xtype uint32, indirect unsafe.Pointer, drawcount int, maxdrawcount int32, stride int32) { + C.glowMultiDrawElementsIndirectCountARB(gpMultiDrawElementsIndirectCountARB, (C.GLenum)(mode), (C.GLenum)(xtype), indirect, (C.GLintptr)(drawcount), (C.GLsizei)(maxdrawcount), (C.GLsizei)(stride)) +} +func MultiDrawMeshTasksIndirectCountNV(indirect int, drawcount int, maxdrawcount int32, stride int32) { + C.glowMultiDrawMeshTasksIndirectCountNV(gpMultiDrawMeshTasksIndirectCountNV, (C.GLintptr)(indirect), (C.GLintptr)(drawcount), (C.GLsizei)(maxdrawcount), (C.GLsizei)(stride)) +} +func MultiDrawMeshTasksIndirectNV(indirect int, drawcount int32, stride int32) { + C.glowMultiDrawMeshTasksIndirectNV(gpMultiDrawMeshTasksIndirectNV, (C.GLintptr)(indirect), (C.GLsizei)(drawcount), (C.GLsizei)(stride)) +} +func MultiTexBufferEXT(texunit uint32, target uint32, internalformat uint32, buffer uint32) { + C.glowMultiTexBufferEXT(gpMultiTexBufferEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLenum)(internalformat), (C.GLuint)(buffer)) +} +func MultiTexCoordPointerEXT(texunit uint32, size int32, xtype uint32, stride int32, pointer unsafe.Pointer) { + C.glowMultiTexCoordPointerEXT(gpMultiTexCoordPointerEXT, (C.GLenum)(texunit), (C.GLint)(size), (C.GLenum)(xtype), (C.GLsizei)(stride), pointer) +} +func MultiTexEnvfEXT(texunit uint32, target uint32, pname uint32, param float32) { + C.glowMultiTexEnvfEXT(gpMultiTexEnvfEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLenum)(pname), (C.GLfloat)(param)) +} +func MultiTexEnvfvEXT(texunit uint32, target uint32, pname uint32, params *float32) { + C.glowMultiTexEnvfvEXT(gpMultiTexEnvfvEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(params))) +} +func MultiTexEnviEXT(texunit uint32, target uint32, pname uint32, param int32) { + C.glowMultiTexEnviEXT(gpMultiTexEnviEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLenum)(pname), (C.GLint)(param)) +} +func MultiTexEnvivEXT(texunit uint32, target uint32, pname uint32, params *int32) { + C.glowMultiTexEnvivEXT(gpMultiTexEnvivEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func MultiTexGendEXT(texunit uint32, coord uint32, pname uint32, param float64) { + C.glowMultiTexGendEXT(gpMultiTexGendEXT, (C.GLenum)(texunit), (C.GLenum)(coord), (C.GLenum)(pname), (C.GLdouble)(param)) +} +func MultiTexGendvEXT(texunit uint32, coord uint32, pname uint32, params *float64) { + C.glowMultiTexGendvEXT(gpMultiTexGendvEXT, (C.GLenum)(texunit), (C.GLenum)(coord), (C.GLenum)(pname), (*C.GLdouble)(unsafe.Pointer(params))) +} +func MultiTexGenfEXT(texunit uint32, coord uint32, pname uint32, param float32) { + C.glowMultiTexGenfEXT(gpMultiTexGenfEXT, (C.GLenum)(texunit), (C.GLenum)(coord), (C.GLenum)(pname), (C.GLfloat)(param)) +} +func MultiTexGenfvEXT(texunit uint32, coord uint32, pname uint32, params *float32) { + C.glowMultiTexGenfvEXT(gpMultiTexGenfvEXT, (C.GLenum)(texunit), (C.GLenum)(coord), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(params))) +} +func MultiTexGeniEXT(texunit uint32, coord uint32, pname uint32, param int32) { + C.glowMultiTexGeniEXT(gpMultiTexGeniEXT, (C.GLenum)(texunit), (C.GLenum)(coord), (C.GLenum)(pname), (C.GLint)(param)) +} +func MultiTexGenivEXT(texunit uint32, coord uint32, pname uint32, params *int32) { + C.glowMultiTexGenivEXT(gpMultiTexGenivEXT, (C.GLenum)(texunit), (C.GLenum)(coord), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func MultiTexImage1DEXT(texunit uint32, target uint32, level int32, internalformat int32, width int32, border int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowMultiTexImage1DEXT(gpMultiTexImage1DEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(internalformat), (C.GLsizei)(width), (C.GLint)(border), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} +func MultiTexImage2DEXT(texunit uint32, target uint32, level int32, internalformat int32, width int32, height int32, border int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowMultiTexImage2DEXT(gpMultiTexImage2DEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLint)(border), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} +func MultiTexImage3DEXT(texunit uint32, target uint32, level int32, internalformat int32, width int32, height int32, depth int32, border int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowMultiTexImage3DEXT(gpMultiTexImage3DEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLint)(border), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} +func MultiTexParameterIivEXT(texunit uint32, target uint32, pname uint32, params *int32) { + C.glowMultiTexParameterIivEXT(gpMultiTexParameterIivEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func MultiTexParameterIuivEXT(texunit uint32, target uint32, pname uint32, params *uint32) { + C.glowMultiTexParameterIuivEXT(gpMultiTexParameterIuivEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLuint)(unsafe.Pointer(params))) +} +func MultiTexParameterfEXT(texunit uint32, target uint32, pname uint32, param float32) { + C.glowMultiTexParameterfEXT(gpMultiTexParameterfEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLenum)(pname), (C.GLfloat)(param)) +} +func MultiTexParameterfvEXT(texunit uint32, target uint32, pname uint32, params *float32) { + C.glowMultiTexParameterfvEXT(gpMultiTexParameterfvEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(params))) +} +func MultiTexParameteriEXT(texunit uint32, target uint32, pname uint32, param int32) { + C.glowMultiTexParameteriEXT(gpMultiTexParameteriEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLenum)(pname), (C.GLint)(param)) +} +func MultiTexParameterivEXT(texunit uint32, target uint32, pname uint32, params *int32) { + C.glowMultiTexParameterivEXT(gpMultiTexParameterivEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func MultiTexRenderbufferEXT(texunit uint32, target uint32, renderbuffer uint32) { + C.glowMultiTexRenderbufferEXT(gpMultiTexRenderbufferEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLuint)(renderbuffer)) +} +func MultiTexSubImage1DEXT(texunit uint32, target uint32, level int32, xoffset int32, width int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowMultiTexSubImage1DEXT(gpMultiTexSubImage1DEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLsizei)(width), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} +func MultiTexSubImage2DEXT(texunit uint32, target uint32, level int32, xoffset int32, yoffset int32, width int32, height int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowMultiTexSubImage2DEXT(gpMultiTexSubImage2DEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} +func MultiTexSubImage3DEXT(texunit uint32, target uint32, level int32, xoffset int32, yoffset int32, zoffset int32, width int32, height int32, depth int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowMultiTexSubImage3DEXT(gpMultiTexSubImage3DEXT, (C.GLenum)(texunit), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} +func NamedBufferAttachMemoryNV(buffer uint32, memory uint32, offset uint64) { + C.glowNamedBufferAttachMemoryNV(gpNamedBufferAttachMemoryNV, (C.GLuint)(buffer), (C.GLuint)(memory), (C.GLuint64)(offset)) +} + +// creates and initializes a buffer object's data store +func NamedBufferData(buffer uint32, size int, data unsafe.Pointer, usage uint32) { + C.glowNamedBufferData(gpNamedBufferData, (C.GLuint)(buffer), (C.GLsizeiptr)(size), data, (C.GLenum)(usage)) +} +func NamedBufferDataEXT(buffer uint32, size int, data unsafe.Pointer, usage uint32) { + C.glowNamedBufferDataEXT(gpNamedBufferDataEXT, (C.GLuint)(buffer), (C.GLsizeiptr)(size), data, (C.GLenum)(usage)) +} +func NamedBufferPageCommitmentARB(buffer uint32, offset int, size int, commit bool) { + C.glowNamedBufferPageCommitmentARB(gpNamedBufferPageCommitmentARB, (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(size), (C.GLboolean)(boolToInt(commit))) +} +func NamedBufferPageCommitmentEXT(buffer uint32, offset int, size int, commit bool) { + C.glowNamedBufferPageCommitmentEXT(gpNamedBufferPageCommitmentEXT, (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(size), (C.GLboolean)(boolToInt(commit))) +} +func NamedBufferPageCommitmentMemNV(buffer uint32, offset int, size int, memory uint32, memOffset uint64, commit bool) { + C.glowNamedBufferPageCommitmentMemNV(gpNamedBufferPageCommitmentMemNV, (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(size), (C.GLuint)(memory), (C.GLuint64)(memOffset), (C.GLboolean)(boolToInt(commit))) +} + +// creates and initializes a buffer object's immutable data store +func NamedBufferStorage(buffer uint32, size int, data unsafe.Pointer, flags uint32) { + C.glowNamedBufferStorage(gpNamedBufferStorage, (C.GLuint)(buffer), (C.GLsizeiptr)(size), data, (C.GLbitfield)(flags)) +} +func NamedBufferStorageEXT(buffer uint32, size int, data unsafe.Pointer, flags uint32) { + C.glowNamedBufferStorageEXT(gpNamedBufferStorageEXT, (C.GLuint)(buffer), (C.GLsizeiptr)(size), data, (C.GLbitfield)(flags)) +} + +// updates a subset of a buffer object's data store +func NamedBufferSubData(buffer uint32, offset int, size int, data unsafe.Pointer) { + C.glowNamedBufferSubData(gpNamedBufferSubData, (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(size), data) +} +func NamedBufferSubDataEXT(buffer uint32, offset int, size int, data unsafe.Pointer) { + C.glowNamedBufferSubDataEXT(gpNamedBufferSubDataEXT, (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(size), data) +} +func NamedCopyBufferSubDataEXT(readBuffer uint32, writeBuffer uint32, readOffset int, writeOffset int, size int) { + C.glowNamedCopyBufferSubDataEXT(gpNamedCopyBufferSubDataEXT, (C.GLuint)(readBuffer), (C.GLuint)(writeBuffer), (C.GLintptr)(readOffset), (C.GLintptr)(writeOffset), (C.GLsizeiptr)(size)) +} + +// specify which color buffers are to be drawn into +func NamedFramebufferDrawBuffer(framebuffer uint32, buf uint32) { + C.glowNamedFramebufferDrawBuffer(gpNamedFramebufferDrawBuffer, (C.GLuint)(framebuffer), (C.GLenum)(buf)) +} + +// Specifies a list of color buffers to be drawn into +func NamedFramebufferDrawBuffers(framebuffer uint32, n int32, bufs *uint32) { + C.glowNamedFramebufferDrawBuffers(gpNamedFramebufferDrawBuffers, (C.GLuint)(framebuffer), (C.GLsizei)(n), (*C.GLenum)(unsafe.Pointer(bufs))) +} + +// set a named parameter of a framebuffer object +func NamedFramebufferParameteri(framebuffer uint32, pname uint32, param int32) { + C.glowNamedFramebufferParameteri(gpNamedFramebufferParameteri, (C.GLuint)(framebuffer), (C.GLenum)(pname), (C.GLint)(param)) +} +func NamedFramebufferParameteriEXT(framebuffer uint32, pname uint32, param int32) { + C.glowNamedFramebufferParameteriEXT(gpNamedFramebufferParameteriEXT, (C.GLuint)(framebuffer), (C.GLenum)(pname), (C.GLint)(param)) +} + +// select a color buffer source for pixels +func NamedFramebufferReadBuffer(framebuffer uint32, src uint32) { + C.glowNamedFramebufferReadBuffer(gpNamedFramebufferReadBuffer, (C.GLuint)(framebuffer), (C.GLenum)(src)) +} + +// attach a renderbuffer as a logical buffer of a framebuffer object +func NamedFramebufferRenderbuffer(framebuffer uint32, attachment uint32, renderbuffertarget uint32, renderbuffer uint32) { + C.glowNamedFramebufferRenderbuffer(gpNamedFramebufferRenderbuffer, (C.GLuint)(framebuffer), (C.GLenum)(attachment), (C.GLenum)(renderbuffertarget), (C.GLuint)(renderbuffer)) +} +func NamedFramebufferRenderbufferEXT(framebuffer uint32, attachment uint32, renderbuffertarget uint32, renderbuffer uint32) { + C.glowNamedFramebufferRenderbufferEXT(gpNamedFramebufferRenderbufferEXT, (C.GLuint)(framebuffer), (C.GLenum)(attachment), (C.GLenum)(renderbuffertarget), (C.GLuint)(renderbuffer)) +} +func NamedFramebufferSampleLocationsfvARB(framebuffer uint32, start uint32, count int32, v *float32) { + C.glowNamedFramebufferSampleLocationsfvARB(gpNamedFramebufferSampleLocationsfvARB, (C.GLuint)(framebuffer), (C.GLuint)(start), (C.GLsizei)(count), (*C.GLfloat)(unsafe.Pointer(v))) +} +func NamedFramebufferSampleLocationsfvNV(framebuffer uint32, start uint32, count int32, v *float32) { + C.glowNamedFramebufferSampleLocationsfvNV(gpNamedFramebufferSampleLocationsfvNV, (C.GLuint)(framebuffer), (C.GLuint)(start), (C.GLsizei)(count), (*C.GLfloat)(unsafe.Pointer(v))) +} +func NamedFramebufferTexture(framebuffer uint32, attachment uint32, texture uint32, level int32) { + C.glowNamedFramebufferTexture(gpNamedFramebufferTexture, (C.GLuint)(framebuffer), (C.GLenum)(attachment), (C.GLuint)(texture), (C.GLint)(level)) +} +func NamedFramebufferTexture1DEXT(framebuffer uint32, attachment uint32, textarget uint32, texture uint32, level int32) { + C.glowNamedFramebufferTexture1DEXT(gpNamedFramebufferTexture1DEXT, (C.GLuint)(framebuffer), (C.GLenum)(attachment), (C.GLenum)(textarget), (C.GLuint)(texture), (C.GLint)(level)) +} +func NamedFramebufferTexture2DEXT(framebuffer uint32, attachment uint32, textarget uint32, texture uint32, level int32) { + C.glowNamedFramebufferTexture2DEXT(gpNamedFramebufferTexture2DEXT, (C.GLuint)(framebuffer), (C.GLenum)(attachment), (C.GLenum)(textarget), (C.GLuint)(texture), (C.GLint)(level)) +} +func NamedFramebufferTexture3DEXT(framebuffer uint32, attachment uint32, textarget uint32, texture uint32, level int32, zoffset int32) { + C.glowNamedFramebufferTexture3DEXT(gpNamedFramebufferTexture3DEXT, (C.GLuint)(framebuffer), (C.GLenum)(attachment), (C.GLenum)(textarget), (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(zoffset)) +} +func NamedFramebufferTextureEXT(framebuffer uint32, attachment uint32, texture uint32, level int32) { + C.glowNamedFramebufferTextureEXT(gpNamedFramebufferTextureEXT, (C.GLuint)(framebuffer), (C.GLenum)(attachment), (C.GLuint)(texture), (C.GLint)(level)) +} +func NamedFramebufferTextureFaceEXT(framebuffer uint32, attachment uint32, texture uint32, level int32, face uint32) { + C.glowNamedFramebufferTextureFaceEXT(gpNamedFramebufferTextureFaceEXT, (C.GLuint)(framebuffer), (C.GLenum)(attachment), (C.GLuint)(texture), (C.GLint)(level), (C.GLenum)(face)) +} + +// attach a single layer of a texture object as a logical buffer of a framebuffer object +func NamedFramebufferTextureLayer(framebuffer uint32, attachment uint32, texture uint32, level int32, layer int32) { + C.glowNamedFramebufferTextureLayer(gpNamedFramebufferTextureLayer, (C.GLuint)(framebuffer), (C.GLenum)(attachment), (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(layer)) +} +func NamedFramebufferTextureLayerEXT(framebuffer uint32, attachment uint32, texture uint32, level int32, layer int32) { + C.glowNamedFramebufferTextureLayerEXT(gpNamedFramebufferTextureLayerEXT, (C.GLuint)(framebuffer), (C.GLenum)(attachment), (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(layer)) +} +func NamedProgramLocalParameter4dEXT(program uint32, target uint32, index uint32, x float64, y float64, z float64, w float64) { + C.glowNamedProgramLocalParameter4dEXT(gpNamedProgramLocalParameter4dEXT, (C.GLuint)(program), (C.GLenum)(target), (C.GLuint)(index), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z), (C.GLdouble)(w)) +} +func NamedProgramLocalParameter4dvEXT(program uint32, target uint32, index uint32, params *float64) { + C.glowNamedProgramLocalParameter4dvEXT(gpNamedProgramLocalParameter4dvEXT, (C.GLuint)(program), (C.GLenum)(target), (C.GLuint)(index), (*C.GLdouble)(unsafe.Pointer(params))) +} +func NamedProgramLocalParameter4fEXT(program uint32, target uint32, index uint32, x float32, y float32, z float32, w float32) { + C.glowNamedProgramLocalParameter4fEXT(gpNamedProgramLocalParameter4fEXT, (C.GLuint)(program), (C.GLenum)(target), (C.GLuint)(index), (C.GLfloat)(x), (C.GLfloat)(y), (C.GLfloat)(z), (C.GLfloat)(w)) +} +func NamedProgramLocalParameter4fvEXT(program uint32, target uint32, index uint32, params *float32) { + C.glowNamedProgramLocalParameter4fvEXT(gpNamedProgramLocalParameter4fvEXT, (C.GLuint)(program), (C.GLenum)(target), (C.GLuint)(index), (*C.GLfloat)(unsafe.Pointer(params))) +} +func NamedProgramLocalParameterI4iEXT(program uint32, target uint32, index uint32, x int32, y int32, z int32, w int32) { + C.glowNamedProgramLocalParameterI4iEXT(gpNamedProgramLocalParameterI4iEXT, (C.GLuint)(program), (C.GLenum)(target), (C.GLuint)(index), (C.GLint)(x), (C.GLint)(y), (C.GLint)(z), (C.GLint)(w)) +} +func NamedProgramLocalParameterI4ivEXT(program uint32, target uint32, index uint32, params *int32) { + C.glowNamedProgramLocalParameterI4ivEXT(gpNamedProgramLocalParameterI4ivEXT, (C.GLuint)(program), (C.GLenum)(target), (C.GLuint)(index), (*C.GLint)(unsafe.Pointer(params))) +} +func NamedProgramLocalParameterI4uiEXT(program uint32, target uint32, index uint32, x uint32, y uint32, z uint32, w uint32) { + C.glowNamedProgramLocalParameterI4uiEXT(gpNamedProgramLocalParameterI4uiEXT, (C.GLuint)(program), (C.GLenum)(target), (C.GLuint)(index), (C.GLuint)(x), (C.GLuint)(y), (C.GLuint)(z), (C.GLuint)(w)) +} +func NamedProgramLocalParameterI4uivEXT(program uint32, target uint32, index uint32, params *uint32) { + C.glowNamedProgramLocalParameterI4uivEXT(gpNamedProgramLocalParameterI4uivEXT, (C.GLuint)(program), (C.GLenum)(target), (C.GLuint)(index), (*C.GLuint)(unsafe.Pointer(params))) +} +func NamedProgramLocalParameters4fvEXT(program uint32, target uint32, index uint32, count int32, params *float32) { + C.glowNamedProgramLocalParameters4fvEXT(gpNamedProgramLocalParameters4fvEXT, (C.GLuint)(program), (C.GLenum)(target), (C.GLuint)(index), (C.GLsizei)(count), (*C.GLfloat)(unsafe.Pointer(params))) +} +func NamedProgramLocalParametersI4ivEXT(program uint32, target uint32, index uint32, count int32, params *int32) { + C.glowNamedProgramLocalParametersI4ivEXT(gpNamedProgramLocalParametersI4ivEXT, (C.GLuint)(program), (C.GLenum)(target), (C.GLuint)(index), (C.GLsizei)(count), (*C.GLint)(unsafe.Pointer(params))) +} +func NamedProgramLocalParametersI4uivEXT(program uint32, target uint32, index uint32, count int32, params *uint32) { + C.glowNamedProgramLocalParametersI4uivEXT(gpNamedProgramLocalParametersI4uivEXT, (C.GLuint)(program), (C.GLenum)(target), (C.GLuint)(index), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(params))) +} +func NamedProgramStringEXT(program uint32, target uint32, format uint32, len int32, xstring unsafe.Pointer) { + C.glowNamedProgramStringEXT(gpNamedProgramStringEXT, (C.GLuint)(program), (C.GLenum)(target), (C.GLenum)(format), (C.GLsizei)(len), xstring) +} + +// establish data storage, format and dimensions of a renderbuffer object's image +func NamedRenderbufferStorage(renderbuffer uint32, internalformat uint32, width int32, height int32) { + C.glowNamedRenderbufferStorage(gpNamedRenderbufferStorage, (C.GLuint)(renderbuffer), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height)) +} +func NamedRenderbufferStorageEXT(renderbuffer uint32, internalformat uint32, width int32, height int32) { + C.glowNamedRenderbufferStorageEXT(gpNamedRenderbufferStorageEXT, (C.GLuint)(renderbuffer), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height)) +} + +// establish data storage, format, dimensions and sample count of a renderbuffer object's image +func NamedRenderbufferStorageMultisample(renderbuffer uint32, samples int32, internalformat uint32, width int32, height int32) { + C.glowNamedRenderbufferStorageMultisample(gpNamedRenderbufferStorageMultisample, (C.GLuint)(renderbuffer), (C.GLsizei)(samples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height)) +} +func NamedRenderbufferStorageMultisampleAdvancedAMD(renderbuffer uint32, samples int32, storageSamples int32, internalformat uint32, width int32, height int32) { + C.glowNamedRenderbufferStorageMultisampleAdvancedAMD(gpNamedRenderbufferStorageMultisampleAdvancedAMD, (C.GLuint)(renderbuffer), (C.GLsizei)(samples), (C.GLsizei)(storageSamples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height)) +} +func NamedRenderbufferStorageMultisampleCoverageEXT(renderbuffer uint32, coverageSamples int32, colorSamples int32, internalformat uint32, width int32, height int32) { + C.glowNamedRenderbufferStorageMultisampleCoverageEXT(gpNamedRenderbufferStorageMultisampleCoverageEXT, (C.GLuint)(renderbuffer), (C.GLsizei)(coverageSamples), (C.GLsizei)(colorSamples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height)) +} +func NamedRenderbufferStorageMultisampleEXT(renderbuffer uint32, samples int32, internalformat uint32, width int32, height int32) { + C.glowNamedRenderbufferStorageMultisampleEXT(gpNamedRenderbufferStorageMultisampleEXT, (C.GLuint)(renderbuffer), (C.GLsizei)(samples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height)) +} +func NamedStringARB(xtype uint32, namelen int32, name *uint8, stringlen int32, xstring *uint8) { + C.glowNamedStringARB(gpNamedStringARB, (C.GLenum)(xtype), (C.GLint)(namelen), (*C.GLchar)(unsafe.Pointer(name)), (C.GLint)(stringlen), (*C.GLchar)(unsafe.Pointer(xstring))) +} +func NormalFormatNV(xtype uint32, stride int32) { + C.glowNormalFormatNV(gpNormalFormatNV, (C.GLenum)(xtype), (C.GLsizei)(stride)) +} + +// label a named object identified within a namespace +func ObjectLabel(identifier uint32, name uint32, length int32, label *uint8) { + C.glowObjectLabel(gpObjectLabel, (C.GLenum)(identifier), (C.GLuint)(name), (C.GLsizei)(length), (*C.GLchar)(unsafe.Pointer(label))) +} +func ObjectLabelKHR(identifier uint32, name uint32, length int32, label *uint8) { + C.glowObjectLabelKHR(gpObjectLabelKHR, (C.GLenum)(identifier), (C.GLuint)(name), (C.GLsizei)(length), (*C.GLchar)(unsafe.Pointer(label))) +} + +// label a sync object identified by a pointer +func ObjectPtrLabel(ptr unsafe.Pointer, length int32, label *uint8) { + C.glowObjectPtrLabel(gpObjectPtrLabel, ptr, (C.GLsizei)(length), (*C.GLchar)(unsafe.Pointer(label))) +} +func ObjectPtrLabelKHR(ptr unsafe.Pointer, length int32, label *uint8) { + C.glowObjectPtrLabelKHR(gpObjectPtrLabelKHR, ptr, (C.GLsizei)(length), (*C.GLchar)(unsafe.Pointer(label))) +} +func PatchParameterfv(pname uint32, values *float32) { + C.glowPatchParameterfv(gpPatchParameterfv, (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(values))) +} + +// specifies the parameters for patch primitives +func PatchParameteri(pname uint32, value int32) { + C.glowPatchParameteri(gpPatchParameteri, (C.GLenum)(pname), (C.GLint)(value)) +} +func PathCommandsNV(path uint32, numCommands int32, commands *uint8, numCoords int32, coordType uint32, coords unsafe.Pointer) { + C.glowPathCommandsNV(gpPathCommandsNV, (C.GLuint)(path), (C.GLsizei)(numCommands), (*C.GLubyte)(unsafe.Pointer(commands)), (C.GLsizei)(numCoords), (C.GLenum)(coordType), coords) +} +func PathCoordsNV(path uint32, numCoords int32, coordType uint32, coords unsafe.Pointer) { + C.glowPathCoordsNV(gpPathCoordsNV, (C.GLuint)(path), (C.GLsizei)(numCoords), (C.GLenum)(coordType), coords) +} +func PathCoverDepthFuncNV(xfunc uint32) { + C.glowPathCoverDepthFuncNV(gpPathCoverDepthFuncNV, (C.GLenum)(xfunc)) +} +func PathDashArrayNV(path uint32, dashCount int32, dashArray *float32) { + C.glowPathDashArrayNV(gpPathDashArrayNV, (C.GLuint)(path), (C.GLsizei)(dashCount), (*C.GLfloat)(unsafe.Pointer(dashArray))) +} +func PathGlyphIndexArrayNV(firstPathName uint32, fontTarget uint32, fontName unsafe.Pointer, fontStyle uint32, firstGlyphIndex uint32, numGlyphs int32, pathParameterTemplate uint32, emScale float32) uint32 { + ret := C.glowPathGlyphIndexArrayNV(gpPathGlyphIndexArrayNV, (C.GLuint)(firstPathName), (C.GLenum)(fontTarget), fontName, (C.GLbitfield)(fontStyle), (C.GLuint)(firstGlyphIndex), (C.GLsizei)(numGlyphs), (C.GLuint)(pathParameterTemplate), (C.GLfloat)(emScale)) + return (uint32)(ret) +} +func PathGlyphIndexRangeNV(fontTarget uint32, fontName unsafe.Pointer, fontStyle uint32, pathParameterTemplate uint32, emScale float32, baseAndCount *uint32) uint32 { + ret := C.glowPathGlyphIndexRangeNV(gpPathGlyphIndexRangeNV, (C.GLenum)(fontTarget), fontName, (C.GLbitfield)(fontStyle), (C.GLuint)(pathParameterTemplate), (C.GLfloat)(emScale), (*C.GLuint)(unsafe.Pointer(baseAndCount))) + return (uint32)(ret) +} +func PathGlyphRangeNV(firstPathName uint32, fontTarget uint32, fontName unsafe.Pointer, fontStyle uint32, firstGlyph uint32, numGlyphs int32, handleMissingGlyphs uint32, pathParameterTemplate uint32, emScale float32) { + C.glowPathGlyphRangeNV(gpPathGlyphRangeNV, (C.GLuint)(firstPathName), (C.GLenum)(fontTarget), fontName, (C.GLbitfield)(fontStyle), (C.GLuint)(firstGlyph), (C.GLsizei)(numGlyphs), (C.GLenum)(handleMissingGlyphs), (C.GLuint)(pathParameterTemplate), (C.GLfloat)(emScale)) +} +func PathGlyphsNV(firstPathName uint32, fontTarget uint32, fontName unsafe.Pointer, fontStyle uint32, numGlyphs int32, xtype uint32, charcodes unsafe.Pointer, handleMissingGlyphs uint32, pathParameterTemplate uint32, emScale float32) { + C.glowPathGlyphsNV(gpPathGlyphsNV, (C.GLuint)(firstPathName), (C.GLenum)(fontTarget), fontName, (C.GLbitfield)(fontStyle), (C.GLsizei)(numGlyphs), (C.GLenum)(xtype), charcodes, (C.GLenum)(handleMissingGlyphs), (C.GLuint)(pathParameterTemplate), (C.GLfloat)(emScale)) +} +func PathMemoryGlyphIndexArrayNV(firstPathName uint32, fontTarget uint32, fontSize int, fontData unsafe.Pointer, faceIndex int32, firstGlyphIndex uint32, numGlyphs int32, pathParameterTemplate uint32, emScale float32) uint32 { + ret := C.glowPathMemoryGlyphIndexArrayNV(gpPathMemoryGlyphIndexArrayNV, (C.GLuint)(firstPathName), (C.GLenum)(fontTarget), (C.GLsizeiptr)(fontSize), fontData, (C.GLsizei)(faceIndex), (C.GLuint)(firstGlyphIndex), (C.GLsizei)(numGlyphs), (C.GLuint)(pathParameterTemplate), (C.GLfloat)(emScale)) + return (uint32)(ret) +} +func PathParameterfNV(path uint32, pname uint32, value float32) { + C.glowPathParameterfNV(gpPathParameterfNV, (C.GLuint)(path), (C.GLenum)(pname), (C.GLfloat)(value)) +} +func PathParameterfvNV(path uint32, pname uint32, value *float32) { + C.glowPathParameterfvNV(gpPathParameterfvNV, (C.GLuint)(path), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(value))) +} +func PathParameteriNV(path uint32, pname uint32, value int32) { + C.glowPathParameteriNV(gpPathParameteriNV, (C.GLuint)(path), (C.GLenum)(pname), (C.GLint)(value)) +} +func PathParameterivNV(path uint32, pname uint32, value *int32) { + C.glowPathParameterivNV(gpPathParameterivNV, (C.GLuint)(path), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(value))) +} +func PathStencilDepthOffsetNV(factor float32, units float32) { + C.glowPathStencilDepthOffsetNV(gpPathStencilDepthOffsetNV, (C.GLfloat)(factor), (C.GLfloat)(units)) +} +func PathStencilFuncNV(xfunc uint32, ref int32, mask uint32) { + C.glowPathStencilFuncNV(gpPathStencilFuncNV, (C.GLenum)(xfunc), (C.GLint)(ref), (C.GLuint)(mask)) +} +func PathStringNV(path uint32, format uint32, length int32, pathString unsafe.Pointer) { + C.glowPathStringNV(gpPathStringNV, (C.GLuint)(path), (C.GLenum)(format), (C.GLsizei)(length), pathString) +} +func PathSubCommandsNV(path uint32, commandStart int32, commandsToDelete int32, numCommands int32, commands *uint8, numCoords int32, coordType uint32, coords unsafe.Pointer) { + C.glowPathSubCommandsNV(gpPathSubCommandsNV, (C.GLuint)(path), (C.GLsizei)(commandStart), (C.GLsizei)(commandsToDelete), (C.GLsizei)(numCommands), (*C.GLubyte)(unsafe.Pointer(commands)), (C.GLsizei)(numCoords), (C.GLenum)(coordType), coords) +} +func PathSubCoordsNV(path uint32, coordStart int32, numCoords int32, coordType uint32, coords unsafe.Pointer) { + C.glowPathSubCoordsNV(gpPathSubCoordsNV, (C.GLuint)(path), (C.GLsizei)(coordStart), (C.GLsizei)(numCoords), (C.GLenum)(coordType), coords) +} + +// pause transform feedback operations +func PauseTransformFeedback() { + C.glowPauseTransformFeedback(gpPauseTransformFeedback) +} +func PixelStoref(pname uint32, param float32) { + C.glowPixelStoref(gpPixelStoref, (C.GLenum)(pname), (C.GLfloat)(param)) +} + +// set pixel storage modes +func PixelStorei(pname uint32, param int32) { + C.glowPixelStorei(gpPixelStorei, (C.GLenum)(pname), (C.GLint)(param)) +} +func PointAlongPathNV(path uint32, startSegment int32, numSegments int32, distance float32, x *float32, y *float32, tangentX *float32, tangentY *float32) bool { + ret := C.glowPointAlongPathNV(gpPointAlongPathNV, (C.GLuint)(path), (C.GLsizei)(startSegment), (C.GLsizei)(numSegments), (C.GLfloat)(distance), (*C.GLfloat)(unsafe.Pointer(x)), (*C.GLfloat)(unsafe.Pointer(y)), (*C.GLfloat)(unsafe.Pointer(tangentX)), (*C.GLfloat)(unsafe.Pointer(tangentY))) + return ret == TRUE +} +func PointParameterf(pname uint32, param float32) { + C.glowPointParameterf(gpPointParameterf, (C.GLenum)(pname), (C.GLfloat)(param)) +} +func PointParameterfv(pname uint32, params *float32) { + C.glowPointParameterfv(gpPointParameterfv, (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(params))) +} +func PointParameteri(pname uint32, param int32) { + C.glowPointParameteri(gpPointParameteri, (C.GLenum)(pname), (C.GLint)(param)) +} +func PointParameteriv(pname uint32, params *int32) { + C.glowPointParameteriv(gpPointParameteriv, (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} + +// specify the diameter of rasterized points +func PointSize(size float32) { + C.glowPointSize(gpPointSize, (C.GLfloat)(size)) +} + +// select a polygon rasterization mode +func PolygonMode(face uint32, mode uint32) { + C.glowPolygonMode(gpPolygonMode, (C.GLenum)(face), (C.GLenum)(mode)) +} + +// set the scale and units used to calculate depth values +func PolygonOffset(factor float32, units float32) { + C.glowPolygonOffset(gpPolygonOffset, (C.GLfloat)(factor), (C.GLfloat)(units)) +} +func PolygonOffsetClamp(factor float32, units float32, clamp float32) { + C.glowPolygonOffsetClamp(gpPolygonOffsetClamp, (C.GLfloat)(factor), (C.GLfloat)(units), (C.GLfloat)(clamp)) +} +func PolygonOffsetClampEXT(factor float32, units float32, clamp float32) { + C.glowPolygonOffsetClampEXT(gpPolygonOffsetClampEXT, (C.GLfloat)(factor), (C.GLfloat)(units), (C.GLfloat)(clamp)) +} + +// pop the active debug group +func PopDebugGroup() { + C.glowPopDebugGroup(gpPopDebugGroup) +} +func PopDebugGroupKHR() { + C.glowPopDebugGroupKHR(gpPopDebugGroupKHR) +} +func PopGroupMarkerEXT() { + C.glowPopGroupMarkerEXT(gpPopGroupMarkerEXT) +} +func PrimitiveBoundingBoxARB(minX float32, minY float32, minZ float32, minW float32, maxX float32, maxY float32, maxZ float32, maxW float32) { + C.glowPrimitiveBoundingBoxARB(gpPrimitiveBoundingBoxARB, (C.GLfloat)(minX), (C.GLfloat)(minY), (C.GLfloat)(minZ), (C.GLfloat)(minW), (C.GLfloat)(maxX), (C.GLfloat)(maxY), (C.GLfloat)(maxZ), (C.GLfloat)(maxW)) +} + +// specify the primitive restart index +func PrimitiveRestartIndex(index uint32) { + C.glowPrimitiveRestartIndex(gpPrimitiveRestartIndex, (C.GLuint)(index)) +} + +// load a program object with a program binary +func ProgramBinary(program uint32, binaryFormat uint32, binary unsafe.Pointer, length int32) { + C.glowProgramBinary(gpProgramBinary, (C.GLuint)(program), (C.GLenum)(binaryFormat), binary, (C.GLsizei)(length)) +} + +// specify a parameter for a program object +func ProgramParameteri(program uint32, pname uint32, value int32) { + C.glowProgramParameteri(gpProgramParameteri, (C.GLuint)(program), (C.GLenum)(pname), (C.GLint)(value)) +} +func ProgramParameteriARB(program uint32, pname uint32, value int32) { + C.glowProgramParameteriARB(gpProgramParameteriARB, (C.GLuint)(program), (C.GLenum)(pname), (C.GLint)(value)) +} +func ProgramParameteriEXT(program uint32, pname uint32, value int32) { + C.glowProgramParameteriEXT(gpProgramParameteriEXT, (C.GLuint)(program), (C.GLenum)(pname), (C.GLint)(value)) +} +func ProgramPathFragmentInputGenNV(program uint32, location int32, genMode uint32, components int32, coeffs *float32) { + C.glowProgramPathFragmentInputGenNV(gpProgramPathFragmentInputGenNV, (C.GLuint)(program), (C.GLint)(location), (C.GLenum)(genMode), (C.GLint)(components), (*C.GLfloat)(unsafe.Pointer(coeffs))) +} +func ProgramUniform1d(program uint32, location int32, v0 float64) { + C.glowProgramUniform1d(gpProgramUniform1d, (C.GLuint)(program), (C.GLint)(location), (C.GLdouble)(v0)) +} +func ProgramUniform1dEXT(program uint32, location int32, x float64) { + C.glowProgramUniform1dEXT(gpProgramUniform1dEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLdouble)(x)) +} +func ProgramUniform1dv(program uint32, location int32, count int32, value *float64) { + C.glowProgramUniform1dv(gpProgramUniform1dv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(unsafe.Pointer(value))) +} +func ProgramUniform1dvEXT(program uint32, location int32, count int32, value *float64) { + C.glowProgramUniform1dvEXT(gpProgramUniform1dvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform1f(program uint32, location int32, v0 float32) { + C.glowProgramUniform1f(gpProgramUniform1f, (C.GLuint)(program), (C.GLint)(location), (C.GLfloat)(v0)) +} +func ProgramUniform1fEXT(program uint32, location int32, v0 float32) { + C.glowProgramUniform1fEXT(gpProgramUniform1fEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLfloat)(v0)) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform1fv(program uint32, location int32, count int32, value *float32) { + C.glowProgramUniform1fv(gpProgramUniform1fv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniform1fvEXT(program uint32, location int32, count int32, value *float32) { + C.glowProgramUniform1fvEXT(gpProgramUniform1fvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform1i(program uint32, location int32, v0 int32) { + C.glowProgramUniform1i(gpProgramUniform1i, (C.GLuint)(program), (C.GLint)(location), (C.GLint)(v0)) +} +func ProgramUniform1i64ARB(program uint32, location int32, x int64) { + C.glowProgramUniform1i64ARB(gpProgramUniform1i64ARB, (C.GLuint)(program), (C.GLint)(location), (C.GLint64)(x)) +} +func ProgramUniform1i64NV(program uint32, location int32, x int64) { + C.glowProgramUniform1i64NV(gpProgramUniform1i64NV, (C.GLuint)(program), (C.GLint)(location), (C.GLint64EXT)(x)) +} +func ProgramUniform1i64vARB(program uint32, location int32, count int32, value *int64) { + C.glowProgramUniform1i64vARB(gpProgramUniform1i64vARB, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint64)(unsafe.Pointer(value))) +} +func ProgramUniform1i64vNV(program uint32, location int32, count int32, value *int64) { + C.glowProgramUniform1i64vNV(gpProgramUniform1i64vNV, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint64EXT)(unsafe.Pointer(value))) +} +func ProgramUniform1iEXT(program uint32, location int32, v0 int32) { + C.glowProgramUniform1iEXT(gpProgramUniform1iEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLint)(v0)) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform1iv(program uint32, location int32, count int32, value *int32) { + C.glowProgramUniform1iv(gpProgramUniform1iv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(unsafe.Pointer(value))) +} +func ProgramUniform1ivEXT(program uint32, location int32, count int32, value *int32) { + C.glowProgramUniform1ivEXT(gpProgramUniform1ivEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform1ui(program uint32, location int32, v0 uint32) { + C.glowProgramUniform1ui(gpProgramUniform1ui, (C.GLuint)(program), (C.GLint)(location), (C.GLuint)(v0)) +} +func ProgramUniform1ui64ARB(program uint32, location int32, x uint64) { + C.glowProgramUniform1ui64ARB(gpProgramUniform1ui64ARB, (C.GLuint)(program), (C.GLint)(location), (C.GLuint64)(x)) +} +func ProgramUniform1ui64NV(program uint32, location int32, x uint64) { + C.glowProgramUniform1ui64NV(gpProgramUniform1ui64NV, (C.GLuint)(program), (C.GLint)(location), (C.GLuint64EXT)(x)) +} +func ProgramUniform1ui64vARB(program uint32, location int32, count int32, value *uint64) { + C.glowProgramUniform1ui64vARB(gpProgramUniform1ui64vARB, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64)(unsafe.Pointer(value))) +} +func ProgramUniform1ui64vNV(program uint32, location int32, count int32, value *uint64) { + C.glowProgramUniform1ui64vNV(gpProgramUniform1ui64vNV, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64EXT)(unsafe.Pointer(value))) +} +func ProgramUniform1uiEXT(program uint32, location int32, v0 uint32) { + C.glowProgramUniform1uiEXT(gpProgramUniform1uiEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLuint)(v0)) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform1uiv(program uint32, location int32, count int32, value *uint32) { + C.glowProgramUniform1uiv(gpProgramUniform1uiv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(value))) +} +func ProgramUniform1uivEXT(program uint32, location int32, count int32, value *uint32) { + C.glowProgramUniform1uivEXT(gpProgramUniform1uivEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(value))) +} +func ProgramUniform2d(program uint32, location int32, v0 float64, v1 float64) { + C.glowProgramUniform2d(gpProgramUniform2d, (C.GLuint)(program), (C.GLint)(location), (C.GLdouble)(v0), (C.GLdouble)(v1)) +} +func ProgramUniform2dEXT(program uint32, location int32, x float64, y float64) { + C.glowProgramUniform2dEXT(gpProgramUniform2dEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLdouble)(x), (C.GLdouble)(y)) +} +func ProgramUniform2dv(program uint32, location int32, count int32, value *float64) { + C.glowProgramUniform2dv(gpProgramUniform2dv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(unsafe.Pointer(value))) +} +func ProgramUniform2dvEXT(program uint32, location int32, count int32, value *float64) { + C.glowProgramUniform2dvEXT(gpProgramUniform2dvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform2f(program uint32, location int32, v0 float32, v1 float32) { + C.glowProgramUniform2f(gpProgramUniform2f, (C.GLuint)(program), (C.GLint)(location), (C.GLfloat)(v0), (C.GLfloat)(v1)) +} +func ProgramUniform2fEXT(program uint32, location int32, v0 float32, v1 float32) { + C.glowProgramUniform2fEXT(gpProgramUniform2fEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLfloat)(v0), (C.GLfloat)(v1)) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform2fv(program uint32, location int32, count int32, value *float32) { + C.glowProgramUniform2fv(gpProgramUniform2fv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniform2fvEXT(program uint32, location int32, count int32, value *float32) { + C.glowProgramUniform2fvEXT(gpProgramUniform2fvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform2i(program uint32, location int32, v0 int32, v1 int32) { + C.glowProgramUniform2i(gpProgramUniform2i, (C.GLuint)(program), (C.GLint)(location), (C.GLint)(v0), (C.GLint)(v1)) +} +func ProgramUniform2i64ARB(program uint32, location int32, x int64, y int64) { + C.glowProgramUniform2i64ARB(gpProgramUniform2i64ARB, (C.GLuint)(program), (C.GLint)(location), (C.GLint64)(x), (C.GLint64)(y)) +} +func ProgramUniform2i64NV(program uint32, location int32, x int64, y int64) { + C.glowProgramUniform2i64NV(gpProgramUniform2i64NV, (C.GLuint)(program), (C.GLint)(location), (C.GLint64EXT)(x), (C.GLint64EXT)(y)) +} +func ProgramUniform2i64vARB(program uint32, location int32, count int32, value *int64) { + C.glowProgramUniform2i64vARB(gpProgramUniform2i64vARB, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint64)(unsafe.Pointer(value))) +} +func ProgramUniform2i64vNV(program uint32, location int32, count int32, value *int64) { + C.glowProgramUniform2i64vNV(gpProgramUniform2i64vNV, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint64EXT)(unsafe.Pointer(value))) +} +func ProgramUniform2iEXT(program uint32, location int32, v0 int32, v1 int32) { + C.glowProgramUniform2iEXT(gpProgramUniform2iEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLint)(v0), (C.GLint)(v1)) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform2iv(program uint32, location int32, count int32, value *int32) { + C.glowProgramUniform2iv(gpProgramUniform2iv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(unsafe.Pointer(value))) +} +func ProgramUniform2ivEXT(program uint32, location int32, count int32, value *int32) { + C.glowProgramUniform2ivEXT(gpProgramUniform2ivEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform2ui(program uint32, location int32, v0 uint32, v1 uint32) { + C.glowProgramUniform2ui(gpProgramUniform2ui, (C.GLuint)(program), (C.GLint)(location), (C.GLuint)(v0), (C.GLuint)(v1)) +} +func ProgramUniform2ui64ARB(program uint32, location int32, x uint64, y uint64) { + C.glowProgramUniform2ui64ARB(gpProgramUniform2ui64ARB, (C.GLuint)(program), (C.GLint)(location), (C.GLuint64)(x), (C.GLuint64)(y)) +} +func ProgramUniform2ui64NV(program uint32, location int32, x uint64, y uint64) { + C.glowProgramUniform2ui64NV(gpProgramUniform2ui64NV, (C.GLuint)(program), (C.GLint)(location), (C.GLuint64EXT)(x), (C.GLuint64EXT)(y)) +} +func ProgramUniform2ui64vARB(program uint32, location int32, count int32, value *uint64) { + C.glowProgramUniform2ui64vARB(gpProgramUniform2ui64vARB, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64)(unsafe.Pointer(value))) +} +func ProgramUniform2ui64vNV(program uint32, location int32, count int32, value *uint64) { + C.glowProgramUniform2ui64vNV(gpProgramUniform2ui64vNV, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64EXT)(unsafe.Pointer(value))) +} +func ProgramUniform2uiEXT(program uint32, location int32, v0 uint32, v1 uint32) { + C.glowProgramUniform2uiEXT(gpProgramUniform2uiEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLuint)(v0), (C.GLuint)(v1)) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform2uiv(program uint32, location int32, count int32, value *uint32) { + C.glowProgramUniform2uiv(gpProgramUniform2uiv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(value))) +} +func ProgramUniform2uivEXT(program uint32, location int32, count int32, value *uint32) { + C.glowProgramUniform2uivEXT(gpProgramUniform2uivEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(value))) +} +func ProgramUniform3d(program uint32, location int32, v0 float64, v1 float64, v2 float64) { + C.glowProgramUniform3d(gpProgramUniform3d, (C.GLuint)(program), (C.GLint)(location), (C.GLdouble)(v0), (C.GLdouble)(v1), (C.GLdouble)(v2)) +} +func ProgramUniform3dEXT(program uint32, location int32, x float64, y float64, z float64) { + C.glowProgramUniform3dEXT(gpProgramUniform3dEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z)) +} +func ProgramUniform3dv(program uint32, location int32, count int32, value *float64) { + C.glowProgramUniform3dv(gpProgramUniform3dv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(unsafe.Pointer(value))) +} +func ProgramUniform3dvEXT(program uint32, location int32, count int32, value *float64) { + C.glowProgramUniform3dvEXT(gpProgramUniform3dvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform3f(program uint32, location int32, v0 float32, v1 float32, v2 float32) { + C.glowProgramUniform3f(gpProgramUniform3f, (C.GLuint)(program), (C.GLint)(location), (C.GLfloat)(v0), (C.GLfloat)(v1), (C.GLfloat)(v2)) +} +func ProgramUniform3fEXT(program uint32, location int32, v0 float32, v1 float32, v2 float32) { + C.glowProgramUniform3fEXT(gpProgramUniform3fEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLfloat)(v0), (C.GLfloat)(v1), (C.GLfloat)(v2)) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform3fv(program uint32, location int32, count int32, value *float32) { + C.glowProgramUniform3fv(gpProgramUniform3fv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniform3fvEXT(program uint32, location int32, count int32, value *float32) { + C.glowProgramUniform3fvEXT(gpProgramUniform3fvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform3i(program uint32, location int32, v0 int32, v1 int32, v2 int32) { + C.glowProgramUniform3i(gpProgramUniform3i, (C.GLuint)(program), (C.GLint)(location), (C.GLint)(v0), (C.GLint)(v1), (C.GLint)(v2)) +} +func ProgramUniform3i64ARB(program uint32, location int32, x int64, y int64, z int64) { + C.glowProgramUniform3i64ARB(gpProgramUniform3i64ARB, (C.GLuint)(program), (C.GLint)(location), (C.GLint64)(x), (C.GLint64)(y), (C.GLint64)(z)) +} +func ProgramUniform3i64NV(program uint32, location int32, x int64, y int64, z int64) { + C.glowProgramUniform3i64NV(gpProgramUniform3i64NV, (C.GLuint)(program), (C.GLint)(location), (C.GLint64EXT)(x), (C.GLint64EXT)(y), (C.GLint64EXT)(z)) +} +func ProgramUniform3i64vARB(program uint32, location int32, count int32, value *int64) { + C.glowProgramUniform3i64vARB(gpProgramUniform3i64vARB, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint64)(unsafe.Pointer(value))) +} +func ProgramUniform3i64vNV(program uint32, location int32, count int32, value *int64) { + C.glowProgramUniform3i64vNV(gpProgramUniform3i64vNV, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint64EXT)(unsafe.Pointer(value))) +} +func ProgramUniform3iEXT(program uint32, location int32, v0 int32, v1 int32, v2 int32) { + C.glowProgramUniform3iEXT(gpProgramUniform3iEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLint)(v0), (C.GLint)(v1), (C.GLint)(v2)) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform3iv(program uint32, location int32, count int32, value *int32) { + C.glowProgramUniform3iv(gpProgramUniform3iv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(unsafe.Pointer(value))) +} +func ProgramUniform3ivEXT(program uint32, location int32, count int32, value *int32) { + C.glowProgramUniform3ivEXT(gpProgramUniform3ivEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform3ui(program uint32, location int32, v0 uint32, v1 uint32, v2 uint32) { + C.glowProgramUniform3ui(gpProgramUniform3ui, (C.GLuint)(program), (C.GLint)(location), (C.GLuint)(v0), (C.GLuint)(v1), (C.GLuint)(v2)) +} +func ProgramUniform3ui64ARB(program uint32, location int32, x uint64, y uint64, z uint64) { + C.glowProgramUniform3ui64ARB(gpProgramUniform3ui64ARB, (C.GLuint)(program), (C.GLint)(location), (C.GLuint64)(x), (C.GLuint64)(y), (C.GLuint64)(z)) +} +func ProgramUniform3ui64NV(program uint32, location int32, x uint64, y uint64, z uint64) { + C.glowProgramUniform3ui64NV(gpProgramUniform3ui64NV, (C.GLuint)(program), (C.GLint)(location), (C.GLuint64EXT)(x), (C.GLuint64EXT)(y), (C.GLuint64EXT)(z)) +} +func ProgramUniform3ui64vARB(program uint32, location int32, count int32, value *uint64) { + C.glowProgramUniform3ui64vARB(gpProgramUniform3ui64vARB, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64)(unsafe.Pointer(value))) +} +func ProgramUniform3ui64vNV(program uint32, location int32, count int32, value *uint64) { + C.glowProgramUniform3ui64vNV(gpProgramUniform3ui64vNV, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64EXT)(unsafe.Pointer(value))) +} +func ProgramUniform3uiEXT(program uint32, location int32, v0 uint32, v1 uint32, v2 uint32) { + C.glowProgramUniform3uiEXT(gpProgramUniform3uiEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLuint)(v0), (C.GLuint)(v1), (C.GLuint)(v2)) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform3uiv(program uint32, location int32, count int32, value *uint32) { + C.glowProgramUniform3uiv(gpProgramUniform3uiv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(value))) +} +func ProgramUniform3uivEXT(program uint32, location int32, count int32, value *uint32) { + C.glowProgramUniform3uivEXT(gpProgramUniform3uivEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(value))) +} +func ProgramUniform4d(program uint32, location int32, v0 float64, v1 float64, v2 float64, v3 float64) { + C.glowProgramUniform4d(gpProgramUniform4d, (C.GLuint)(program), (C.GLint)(location), (C.GLdouble)(v0), (C.GLdouble)(v1), (C.GLdouble)(v2), (C.GLdouble)(v3)) +} +func ProgramUniform4dEXT(program uint32, location int32, x float64, y float64, z float64, w float64) { + C.glowProgramUniform4dEXT(gpProgramUniform4dEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z), (C.GLdouble)(w)) +} +func ProgramUniform4dv(program uint32, location int32, count int32, value *float64) { + C.glowProgramUniform4dv(gpProgramUniform4dv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(unsafe.Pointer(value))) +} +func ProgramUniform4dvEXT(program uint32, location int32, count int32, value *float64) { + C.glowProgramUniform4dvEXT(gpProgramUniform4dvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform4f(program uint32, location int32, v0 float32, v1 float32, v2 float32, v3 float32) { + C.glowProgramUniform4f(gpProgramUniform4f, (C.GLuint)(program), (C.GLint)(location), (C.GLfloat)(v0), (C.GLfloat)(v1), (C.GLfloat)(v2), (C.GLfloat)(v3)) +} +func ProgramUniform4fEXT(program uint32, location int32, v0 float32, v1 float32, v2 float32, v3 float32) { + C.glowProgramUniform4fEXT(gpProgramUniform4fEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLfloat)(v0), (C.GLfloat)(v1), (C.GLfloat)(v2), (C.GLfloat)(v3)) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform4fv(program uint32, location int32, count int32, value *float32) { + C.glowProgramUniform4fv(gpProgramUniform4fv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniform4fvEXT(program uint32, location int32, count int32, value *float32) { + C.glowProgramUniform4fvEXT(gpProgramUniform4fvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform4i(program uint32, location int32, v0 int32, v1 int32, v2 int32, v3 int32) { + C.glowProgramUniform4i(gpProgramUniform4i, (C.GLuint)(program), (C.GLint)(location), (C.GLint)(v0), (C.GLint)(v1), (C.GLint)(v2), (C.GLint)(v3)) +} +func ProgramUniform4i64ARB(program uint32, location int32, x int64, y int64, z int64, w int64) { + C.glowProgramUniform4i64ARB(gpProgramUniform4i64ARB, (C.GLuint)(program), (C.GLint)(location), (C.GLint64)(x), (C.GLint64)(y), (C.GLint64)(z), (C.GLint64)(w)) +} +func ProgramUniform4i64NV(program uint32, location int32, x int64, y int64, z int64, w int64) { + C.glowProgramUniform4i64NV(gpProgramUniform4i64NV, (C.GLuint)(program), (C.GLint)(location), (C.GLint64EXT)(x), (C.GLint64EXT)(y), (C.GLint64EXT)(z), (C.GLint64EXT)(w)) +} +func ProgramUniform4i64vARB(program uint32, location int32, count int32, value *int64) { + C.glowProgramUniform4i64vARB(gpProgramUniform4i64vARB, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint64)(unsafe.Pointer(value))) +} +func ProgramUniform4i64vNV(program uint32, location int32, count int32, value *int64) { + C.glowProgramUniform4i64vNV(gpProgramUniform4i64vNV, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint64EXT)(unsafe.Pointer(value))) +} +func ProgramUniform4iEXT(program uint32, location int32, v0 int32, v1 int32, v2 int32, v3 int32) { + C.glowProgramUniform4iEXT(gpProgramUniform4iEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLint)(v0), (C.GLint)(v1), (C.GLint)(v2), (C.GLint)(v3)) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform4iv(program uint32, location int32, count int32, value *int32) { + C.glowProgramUniform4iv(gpProgramUniform4iv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(unsafe.Pointer(value))) +} +func ProgramUniform4ivEXT(program uint32, location int32, count int32, value *int32) { + C.glowProgramUniform4ivEXT(gpProgramUniform4ivEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform4ui(program uint32, location int32, v0 uint32, v1 uint32, v2 uint32, v3 uint32) { + C.glowProgramUniform4ui(gpProgramUniform4ui, (C.GLuint)(program), (C.GLint)(location), (C.GLuint)(v0), (C.GLuint)(v1), (C.GLuint)(v2), (C.GLuint)(v3)) +} +func ProgramUniform4ui64ARB(program uint32, location int32, x uint64, y uint64, z uint64, w uint64) { + C.glowProgramUniform4ui64ARB(gpProgramUniform4ui64ARB, (C.GLuint)(program), (C.GLint)(location), (C.GLuint64)(x), (C.GLuint64)(y), (C.GLuint64)(z), (C.GLuint64)(w)) +} +func ProgramUniform4ui64NV(program uint32, location int32, x uint64, y uint64, z uint64, w uint64) { + C.glowProgramUniform4ui64NV(gpProgramUniform4ui64NV, (C.GLuint)(program), (C.GLint)(location), (C.GLuint64EXT)(x), (C.GLuint64EXT)(y), (C.GLuint64EXT)(z), (C.GLuint64EXT)(w)) +} +func ProgramUniform4ui64vARB(program uint32, location int32, count int32, value *uint64) { + C.glowProgramUniform4ui64vARB(gpProgramUniform4ui64vARB, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64)(unsafe.Pointer(value))) +} +func ProgramUniform4ui64vNV(program uint32, location int32, count int32, value *uint64) { + C.glowProgramUniform4ui64vNV(gpProgramUniform4ui64vNV, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64EXT)(unsafe.Pointer(value))) +} +func ProgramUniform4uiEXT(program uint32, location int32, v0 uint32, v1 uint32, v2 uint32, v3 uint32) { + C.glowProgramUniform4uiEXT(gpProgramUniform4uiEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLuint)(v0), (C.GLuint)(v1), (C.GLuint)(v2), (C.GLuint)(v3)) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniform4uiv(program uint32, location int32, count int32, value *uint32) { + C.glowProgramUniform4uiv(gpProgramUniform4uiv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(value))) +} +func ProgramUniform4uivEXT(program uint32, location int32, count int32, value *uint32) { + C.glowProgramUniform4uivEXT(gpProgramUniform4uivEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(value))) +} +func ProgramUniformHandleui64ARB(program uint32, location int32, value uint64) { + C.glowProgramUniformHandleui64ARB(gpProgramUniformHandleui64ARB, (C.GLuint)(program), (C.GLint)(location), (C.GLuint64)(value)) +} +func ProgramUniformHandleui64NV(program uint32, location int32, value uint64) { + C.glowProgramUniformHandleui64NV(gpProgramUniformHandleui64NV, (C.GLuint)(program), (C.GLint)(location), (C.GLuint64)(value)) +} +func ProgramUniformHandleui64vARB(program uint32, location int32, count int32, values *uint64) { + C.glowProgramUniformHandleui64vARB(gpProgramUniformHandleui64vARB, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64)(unsafe.Pointer(values))) +} +func ProgramUniformHandleui64vNV(program uint32, location int32, count int32, values *uint64) { + C.glowProgramUniformHandleui64vNV(gpProgramUniformHandleui64vNV, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64)(unsafe.Pointer(values))) +} +func ProgramUniformMatrix2dv(program uint32, location int32, count int32, transpose bool, value *float64) { + C.glowProgramUniformMatrix2dv(gpProgramUniformMatrix2dv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix2dvEXT(program uint32, location int32, count int32, transpose bool, value *float64) { + C.glowProgramUniformMatrix2dvEXT(gpProgramUniformMatrix2dvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniformMatrix2fv(program uint32, location int32, count int32, transpose bool, value *float32) { + C.glowProgramUniformMatrix2fv(gpProgramUniformMatrix2fv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix2fvEXT(program uint32, location int32, count int32, transpose bool, value *float32) { + C.glowProgramUniformMatrix2fvEXT(gpProgramUniformMatrix2fvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix2x3dv(program uint32, location int32, count int32, transpose bool, value *float64) { + C.glowProgramUniformMatrix2x3dv(gpProgramUniformMatrix2x3dv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix2x3dvEXT(program uint32, location int32, count int32, transpose bool, value *float64) { + C.glowProgramUniformMatrix2x3dvEXT(gpProgramUniformMatrix2x3dvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniformMatrix2x3fv(program uint32, location int32, count int32, transpose bool, value *float32) { + C.glowProgramUniformMatrix2x3fv(gpProgramUniformMatrix2x3fv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix2x3fvEXT(program uint32, location int32, count int32, transpose bool, value *float32) { + C.glowProgramUniformMatrix2x3fvEXT(gpProgramUniformMatrix2x3fvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix2x4dv(program uint32, location int32, count int32, transpose bool, value *float64) { + C.glowProgramUniformMatrix2x4dv(gpProgramUniformMatrix2x4dv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix2x4dvEXT(program uint32, location int32, count int32, transpose bool, value *float64) { + C.glowProgramUniformMatrix2x4dvEXT(gpProgramUniformMatrix2x4dvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniformMatrix2x4fv(program uint32, location int32, count int32, transpose bool, value *float32) { + C.glowProgramUniformMatrix2x4fv(gpProgramUniformMatrix2x4fv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix2x4fvEXT(program uint32, location int32, count int32, transpose bool, value *float32) { + C.glowProgramUniformMatrix2x4fvEXT(gpProgramUniformMatrix2x4fvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix3dv(program uint32, location int32, count int32, transpose bool, value *float64) { + C.glowProgramUniformMatrix3dv(gpProgramUniformMatrix3dv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix3dvEXT(program uint32, location int32, count int32, transpose bool, value *float64) { + C.glowProgramUniformMatrix3dvEXT(gpProgramUniformMatrix3dvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniformMatrix3fv(program uint32, location int32, count int32, transpose bool, value *float32) { + C.glowProgramUniformMatrix3fv(gpProgramUniformMatrix3fv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix3fvEXT(program uint32, location int32, count int32, transpose bool, value *float32) { + C.glowProgramUniformMatrix3fvEXT(gpProgramUniformMatrix3fvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix3x2dv(program uint32, location int32, count int32, transpose bool, value *float64) { + C.glowProgramUniformMatrix3x2dv(gpProgramUniformMatrix3x2dv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix3x2dvEXT(program uint32, location int32, count int32, transpose bool, value *float64) { + C.glowProgramUniformMatrix3x2dvEXT(gpProgramUniformMatrix3x2dvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniformMatrix3x2fv(program uint32, location int32, count int32, transpose bool, value *float32) { + C.glowProgramUniformMatrix3x2fv(gpProgramUniformMatrix3x2fv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix3x2fvEXT(program uint32, location int32, count int32, transpose bool, value *float32) { + C.glowProgramUniformMatrix3x2fvEXT(gpProgramUniformMatrix3x2fvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix3x4dv(program uint32, location int32, count int32, transpose bool, value *float64) { + C.glowProgramUniformMatrix3x4dv(gpProgramUniformMatrix3x4dv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix3x4dvEXT(program uint32, location int32, count int32, transpose bool, value *float64) { + C.glowProgramUniformMatrix3x4dvEXT(gpProgramUniformMatrix3x4dvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniformMatrix3x4fv(program uint32, location int32, count int32, transpose bool, value *float32) { + C.glowProgramUniformMatrix3x4fv(gpProgramUniformMatrix3x4fv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix3x4fvEXT(program uint32, location int32, count int32, transpose bool, value *float32) { + C.glowProgramUniformMatrix3x4fvEXT(gpProgramUniformMatrix3x4fvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix4dv(program uint32, location int32, count int32, transpose bool, value *float64) { + C.glowProgramUniformMatrix4dv(gpProgramUniformMatrix4dv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix4dvEXT(program uint32, location int32, count int32, transpose bool, value *float64) { + C.glowProgramUniformMatrix4dvEXT(gpProgramUniformMatrix4dvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniformMatrix4fv(program uint32, location int32, count int32, transpose bool, value *float32) { + C.glowProgramUniformMatrix4fv(gpProgramUniformMatrix4fv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix4fvEXT(program uint32, location int32, count int32, transpose bool, value *float32) { + C.glowProgramUniformMatrix4fvEXT(gpProgramUniformMatrix4fvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix4x2dv(program uint32, location int32, count int32, transpose bool, value *float64) { + C.glowProgramUniformMatrix4x2dv(gpProgramUniformMatrix4x2dv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix4x2dvEXT(program uint32, location int32, count int32, transpose bool, value *float64) { + C.glowProgramUniformMatrix4x2dvEXT(gpProgramUniformMatrix4x2dvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniformMatrix4x2fv(program uint32, location int32, count int32, transpose bool, value *float32) { + C.glowProgramUniformMatrix4x2fv(gpProgramUniformMatrix4x2fv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix4x2fvEXT(program uint32, location int32, count int32, transpose bool, value *float32) { + C.glowProgramUniformMatrix4x2fvEXT(gpProgramUniformMatrix4x2fvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix4x3dv(program uint32, location int32, count int32, transpose bool, value *float64) { + C.glowProgramUniformMatrix4x3dv(gpProgramUniformMatrix4x3dv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix4x3dvEXT(program uint32, location int32, count int32, transpose bool, value *float64) { + C.glowProgramUniformMatrix4x3dvEXT(gpProgramUniformMatrix4x3dvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for a specified program object +func ProgramUniformMatrix4x3fv(program uint32, location int32, count int32, transpose bool, value *float32) { + C.glowProgramUniformMatrix4x3fv(gpProgramUniformMatrix4x3fv, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniformMatrix4x3fvEXT(program uint32, location int32, count int32, transpose bool, value *float32) { + C.glowProgramUniformMatrix4x3fvEXT(gpProgramUniformMatrix4x3fvEXT, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func ProgramUniformui64NV(program uint32, location int32, value uint64) { + C.glowProgramUniformui64NV(gpProgramUniformui64NV, (C.GLuint)(program), (C.GLint)(location), (C.GLuint64EXT)(value)) +} +func ProgramUniformui64vNV(program uint32, location int32, count int32, value *uint64) { + C.glowProgramUniformui64vNV(gpProgramUniformui64vNV, (C.GLuint)(program), (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64EXT)(unsafe.Pointer(value))) +} + +// specifiy the vertex to be used as the source of data for flat shaded varyings +func ProvokingVertex(mode uint32) { + C.glowProvokingVertex(gpProvokingVertex, (C.GLenum)(mode)) +} +func PushClientAttribDefaultEXT(mask uint32) { + C.glowPushClientAttribDefaultEXT(gpPushClientAttribDefaultEXT, (C.GLbitfield)(mask)) +} + +// push a named debug group into the command stream +func PushDebugGroup(source uint32, id uint32, length int32, message *uint8) { + C.glowPushDebugGroup(gpPushDebugGroup, (C.GLenum)(source), (C.GLuint)(id), (C.GLsizei)(length), (*C.GLchar)(unsafe.Pointer(message))) +} +func PushDebugGroupKHR(source uint32, id uint32, length int32, message *uint8) { + C.glowPushDebugGroupKHR(gpPushDebugGroupKHR, (C.GLenum)(source), (C.GLuint)(id), (C.GLsizei)(length), (*C.GLchar)(unsafe.Pointer(message))) +} +func PushGroupMarkerEXT(length int32, marker *uint8) { + C.glowPushGroupMarkerEXT(gpPushGroupMarkerEXT, (C.GLsizei)(length), (*C.GLchar)(unsafe.Pointer(marker))) +} + +// record the GL time into a query object after all previous commands have reached the GL server but have not yet necessarily executed. +func QueryCounter(id uint32, target uint32) { + C.glowQueryCounter(gpQueryCounter, (C.GLuint)(id), (C.GLenum)(target)) +} +func RasterSamplesEXT(samples uint32, fixedsamplelocations bool) { + C.glowRasterSamplesEXT(gpRasterSamplesEXT, (C.GLuint)(samples), (C.GLboolean)(boolToInt(fixedsamplelocations))) +} + +// select a color buffer source for pixels +func ReadBuffer(src uint32) { + C.glowReadBuffer(gpReadBuffer, (C.GLenum)(src)) +} + +// read a block of pixels from the frame buffer +func ReadPixels(x int32, y int32, width int32, height int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowReadPixels(gpReadPixels, (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} + +// read a block of pixels from the frame buffer +func ReadnPixels(x int32, y int32, width int32, height int32, format uint32, xtype uint32, bufSize int32, data unsafe.Pointer) { + C.glowReadnPixels(gpReadnPixels, (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLenum)(format), (C.GLenum)(xtype), (C.GLsizei)(bufSize), data) +} +func ReadnPixelsARB(x int32, y int32, width int32, height int32, format uint32, xtype uint32, bufSize int32, data unsafe.Pointer) { + C.glowReadnPixelsARB(gpReadnPixelsARB, (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLenum)(format), (C.GLenum)(xtype), (C.GLsizei)(bufSize), data) +} +func ReadnPixelsKHR(x int32, y int32, width int32, height int32, format uint32, xtype uint32, bufSize int32, data unsafe.Pointer) { + C.glowReadnPixelsKHR(gpReadnPixelsKHR, (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLenum)(format), (C.GLenum)(xtype), (C.GLsizei)(bufSize), data) +} + +// release resources consumed by the implementation's shader compiler +func ReleaseShaderCompiler() { + C.glowReleaseShaderCompiler(gpReleaseShaderCompiler) +} + +// establish data storage, format and dimensions of a renderbuffer object's image +func RenderbufferStorage(target uint32, internalformat uint32, width int32, height int32) { + C.glowRenderbufferStorage(gpRenderbufferStorage, (C.GLenum)(target), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height)) +} + +// establish data storage, format, dimensions and sample count of a renderbuffer object's image +func RenderbufferStorageMultisample(target uint32, samples int32, internalformat uint32, width int32, height int32) { + C.glowRenderbufferStorageMultisample(gpRenderbufferStorageMultisample, (C.GLenum)(target), (C.GLsizei)(samples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height)) +} +func RenderbufferStorageMultisampleAdvancedAMD(target uint32, samples int32, storageSamples int32, internalformat uint32, width int32, height int32) { + C.glowRenderbufferStorageMultisampleAdvancedAMD(gpRenderbufferStorageMultisampleAdvancedAMD, (C.GLenum)(target), (C.GLsizei)(samples), (C.GLsizei)(storageSamples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height)) +} +func RenderbufferStorageMultisampleCoverageNV(target uint32, coverageSamples int32, colorSamples int32, internalformat uint32, width int32, height int32) { + C.glowRenderbufferStorageMultisampleCoverageNV(gpRenderbufferStorageMultisampleCoverageNV, (C.GLenum)(target), (C.GLsizei)(coverageSamples), (C.GLsizei)(colorSamples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height)) +} +func ResetMemoryObjectParameterNV(memory uint32, pname uint32) { + C.glowResetMemoryObjectParameterNV(gpResetMemoryObjectParameterNV, (C.GLuint)(memory), (C.GLenum)(pname)) +} +func ResolveDepthValuesNV() { + C.glowResolveDepthValuesNV(gpResolveDepthValuesNV) +} + +// resume transform feedback operations +func ResumeTransformFeedback() { + C.glowResumeTransformFeedback(gpResumeTransformFeedback) +} + +// specify multisample coverage parameters +func SampleCoverage(value float32, invert bool) { + C.glowSampleCoverage(gpSampleCoverage, (C.GLfloat)(value), (C.GLboolean)(boolToInt(invert))) +} + +// set the value of a sub-word of the sample mask +func SampleMaski(maskNumber uint32, mask uint32) { + C.glowSampleMaski(gpSampleMaski, (C.GLuint)(maskNumber), (C.GLbitfield)(mask)) +} +func SamplerParameterIiv(sampler uint32, pname uint32, param *int32) { + C.glowSamplerParameterIiv(gpSamplerParameterIiv, (C.GLuint)(sampler), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(param))) +} +func SamplerParameterIuiv(sampler uint32, pname uint32, param *uint32) { + C.glowSamplerParameterIuiv(gpSamplerParameterIuiv, (C.GLuint)(sampler), (C.GLenum)(pname), (*C.GLuint)(unsafe.Pointer(param))) +} +func SamplerParameterf(sampler uint32, pname uint32, param float32) { + C.glowSamplerParameterf(gpSamplerParameterf, (C.GLuint)(sampler), (C.GLenum)(pname), (C.GLfloat)(param)) +} +func SamplerParameterfv(sampler uint32, pname uint32, param *float32) { + C.glowSamplerParameterfv(gpSamplerParameterfv, (C.GLuint)(sampler), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(param))) +} +func SamplerParameteri(sampler uint32, pname uint32, param int32) { + C.glowSamplerParameteri(gpSamplerParameteri, (C.GLuint)(sampler), (C.GLenum)(pname), (C.GLint)(param)) +} +func SamplerParameteriv(sampler uint32, pname uint32, param *int32) { + C.glowSamplerParameteriv(gpSamplerParameteriv, (C.GLuint)(sampler), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(param))) +} + +// define the scissor box +func Scissor(x int32, y int32, width int32, height int32) { + C.glowScissor(gpScissor, (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height)) +} +func ScissorArrayv(first uint32, count int32, v *int32) { + C.glowScissorArrayv(gpScissorArrayv, (C.GLuint)(first), (C.GLsizei)(count), (*C.GLint)(unsafe.Pointer(v))) +} +func ScissorExclusiveArrayvNV(first uint32, count int32, v *int32) { + C.glowScissorExclusiveArrayvNV(gpScissorExclusiveArrayvNV, (C.GLuint)(first), (C.GLsizei)(count), (*C.GLint)(unsafe.Pointer(v))) +} +func ScissorExclusiveNV(x int32, y int32, width int32, height int32) { + C.glowScissorExclusiveNV(gpScissorExclusiveNV, (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height)) +} + +// define the scissor box for a specific viewport +func ScissorIndexed(index uint32, left int32, bottom int32, width int32, height int32) { + C.glowScissorIndexed(gpScissorIndexed, (C.GLuint)(index), (C.GLint)(left), (C.GLint)(bottom), (C.GLsizei)(width), (C.GLsizei)(height)) +} +func ScissorIndexedv(index uint32, v *int32) { + C.glowScissorIndexedv(gpScissorIndexedv, (C.GLuint)(index), (*C.GLint)(unsafe.Pointer(v))) +} +func SecondaryColorFormatNV(size int32, xtype uint32, stride int32) { + C.glowSecondaryColorFormatNV(gpSecondaryColorFormatNV, (C.GLint)(size), (C.GLenum)(xtype), (C.GLsizei)(stride)) +} +func SelectPerfMonitorCountersAMD(monitor uint32, enable bool, group uint32, numCounters int32, counterList *uint32) { + C.glowSelectPerfMonitorCountersAMD(gpSelectPerfMonitorCountersAMD, (C.GLuint)(monitor), (C.GLboolean)(boolToInt(enable)), (C.GLuint)(group), (C.GLint)(numCounters), (*C.GLuint)(unsafe.Pointer(counterList))) +} + +// load pre-compiled shader binaries +func ShaderBinary(count int32, shaders *uint32, binaryFormat uint32, binary unsafe.Pointer, length int32) { + C.glowShaderBinary(gpShaderBinary, (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(shaders)), (C.GLenum)(binaryFormat), binary, (C.GLsizei)(length)) +} + +// Replaces the source code in a shader object +func ShaderSource(shader uint32, count int32, xstring **uint8, length *int32) { + C.glowShaderSource(gpShaderSource, (C.GLuint)(shader), (C.GLsizei)(count), (**C.GLchar)(unsafe.Pointer(xstring)), (*C.GLint)(unsafe.Pointer(length))) +} + +// change an active shader storage block binding +func ShaderStorageBlockBinding(program uint32, storageBlockIndex uint32, storageBlockBinding uint32) { + C.glowShaderStorageBlockBinding(gpShaderStorageBlockBinding, (C.GLuint)(program), (C.GLuint)(storageBlockIndex), (C.GLuint)(storageBlockBinding)) +} +func ShadingRateImageBarrierNV(synchronize bool) { + C.glowShadingRateImageBarrierNV(gpShadingRateImageBarrierNV, (C.GLboolean)(boolToInt(synchronize))) +} +func ShadingRateImagePaletteNV(viewport uint32, first uint32, count int32, rates *uint32) { + C.glowShadingRateImagePaletteNV(gpShadingRateImagePaletteNV, (C.GLuint)(viewport), (C.GLuint)(first), (C.GLsizei)(count), (*C.GLenum)(unsafe.Pointer(rates))) +} +func ShadingRateSampleOrderCustomNV(rate uint32, samples uint32, locations *int32) { + C.glowShadingRateSampleOrderCustomNV(gpShadingRateSampleOrderCustomNV, (C.GLenum)(rate), (C.GLuint)(samples), (*C.GLint)(unsafe.Pointer(locations))) +} +func ShadingRateSampleOrderNV(order uint32) { + C.glowShadingRateSampleOrderNV(gpShadingRateSampleOrderNV, (C.GLenum)(order)) +} +func SignalVkFenceNV(vkFence uint64) { + C.glowSignalVkFenceNV(gpSignalVkFenceNV, (C.GLuint64)(vkFence)) +} +func SignalVkSemaphoreNV(vkSemaphore uint64) { + C.glowSignalVkSemaphoreNV(gpSignalVkSemaphoreNV, (C.GLuint64)(vkSemaphore)) +} +func SpecializeShaderARB(shader uint32, pEntryPoint *uint8, numSpecializationConstants uint32, pConstantIndex *uint32, pConstantValue *uint32) { + C.glowSpecializeShaderARB(gpSpecializeShaderARB, (C.GLuint)(shader), (*C.GLchar)(unsafe.Pointer(pEntryPoint)), (C.GLuint)(numSpecializationConstants), (*C.GLuint)(unsafe.Pointer(pConstantIndex)), (*C.GLuint)(unsafe.Pointer(pConstantValue))) +} +func StateCaptureNV(state uint32, mode uint32) { + C.glowStateCaptureNV(gpStateCaptureNV, (C.GLuint)(state), (C.GLenum)(mode)) +} +func StencilFillPathInstancedNV(numPaths int32, pathNameType uint32, paths unsafe.Pointer, pathBase uint32, fillMode uint32, mask uint32, transformType uint32, transformValues *float32) { + C.glowStencilFillPathInstancedNV(gpStencilFillPathInstancedNV, (C.GLsizei)(numPaths), (C.GLenum)(pathNameType), paths, (C.GLuint)(pathBase), (C.GLenum)(fillMode), (C.GLuint)(mask), (C.GLenum)(transformType), (*C.GLfloat)(unsafe.Pointer(transformValues))) +} +func StencilFillPathNV(path uint32, fillMode uint32, mask uint32) { + C.glowStencilFillPathNV(gpStencilFillPathNV, (C.GLuint)(path), (C.GLenum)(fillMode), (C.GLuint)(mask)) +} + +// set front and back function and reference value for stencil testing +func StencilFunc(xfunc uint32, ref int32, mask uint32) { + C.glowStencilFunc(gpStencilFunc, (C.GLenum)(xfunc), (C.GLint)(ref), (C.GLuint)(mask)) +} + +// set front and/or back function and reference value for stencil testing +func StencilFuncSeparate(face uint32, xfunc uint32, ref int32, mask uint32) { + C.glowStencilFuncSeparate(gpStencilFuncSeparate, (C.GLenum)(face), (C.GLenum)(xfunc), (C.GLint)(ref), (C.GLuint)(mask)) +} + +// control the front and back writing of individual bits in the stencil planes +func StencilMask(mask uint32) { + C.glowStencilMask(gpStencilMask, (C.GLuint)(mask)) +} + +// control the front and/or back writing of individual bits in the stencil planes +func StencilMaskSeparate(face uint32, mask uint32) { + C.glowStencilMaskSeparate(gpStencilMaskSeparate, (C.GLenum)(face), (C.GLuint)(mask)) +} + +// set front and back stencil test actions +func StencilOp(fail uint32, zfail uint32, zpass uint32) { + C.glowStencilOp(gpStencilOp, (C.GLenum)(fail), (C.GLenum)(zfail), (C.GLenum)(zpass)) +} + +// set front and/or back stencil test actions +func StencilOpSeparate(face uint32, sfail uint32, dpfail uint32, dppass uint32) { + C.glowStencilOpSeparate(gpStencilOpSeparate, (C.GLenum)(face), (C.GLenum)(sfail), (C.GLenum)(dpfail), (C.GLenum)(dppass)) +} +func StencilStrokePathInstancedNV(numPaths int32, pathNameType uint32, paths unsafe.Pointer, pathBase uint32, reference int32, mask uint32, transformType uint32, transformValues *float32) { + C.glowStencilStrokePathInstancedNV(gpStencilStrokePathInstancedNV, (C.GLsizei)(numPaths), (C.GLenum)(pathNameType), paths, (C.GLuint)(pathBase), (C.GLint)(reference), (C.GLuint)(mask), (C.GLenum)(transformType), (*C.GLfloat)(unsafe.Pointer(transformValues))) +} +func StencilStrokePathNV(path uint32, reference int32, mask uint32) { + C.glowStencilStrokePathNV(gpStencilStrokePathNV, (C.GLuint)(path), (C.GLint)(reference), (C.GLuint)(mask)) +} +func StencilThenCoverFillPathInstancedNV(numPaths int32, pathNameType uint32, paths unsafe.Pointer, pathBase uint32, fillMode uint32, mask uint32, coverMode uint32, transformType uint32, transformValues *float32) { + C.glowStencilThenCoverFillPathInstancedNV(gpStencilThenCoverFillPathInstancedNV, (C.GLsizei)(numPaths), (C.GLenum)(pathNameType), paths, (C.GLuint)(pathBase), (C.GLenum)(fillMode), (C.GLuint)(mask), (C.GLenum)(coverMode), (C.GLenum)(transformType), (*C.GLfloat)(unsafe.Pointer(transformValues))) +} +func StencilThenCoverFillPathNV(path uint32, fillMode uint32, mask uint32, coverMode uint32) { + C.glowStencilThenCoverFillPathNV(gpStencilThenCoverFillPathNV, (C.GLuint)(path), (C.GLenum)(fillMode), (C.GLuint)(mask), (C.GLenum)(coverMode)) +} +func StencilThenCoverStrokePathInstancedNV(numPaths int32, pathNameType uint32, paths unsafe.Pointer, pathBase uint32, reference int32, mask uint32, coverMode uint32, transformType uint32, transformValues *float32) { + C.glowStencilThenCoverStrokePathInstancedNV(gpStencilThenCoverStrokePathInstancedNV, (C.GLsizei)(numPaths), (C.GLenum)(pathNameType), paths, (C.GLuint)(pathBase), (C.GLint)(reference), (C.GLuint)(mask), (C.GLenum)(coverMode), (C.GLenum)(transformType), (*C.GLfloat)(unsafe.Pointer(transformValues))) +} +func StencilThenCoverStrokePathNV(path uint32, reference int32, mask uint32, coverMode uint32) { + C.glowStencilThenCoverStrokePathNV(gpStencilThenCoverStrokePathNV, (C.GLuint)(path), (C.GLint)(reference), (C.GLuint)(mask), (C.GLenum)(coverMode)) +} +func SubpixelPrecisionBiasNV(xbits uint32, ybits uint32) { + C.glowSubpixelPrecisionBiasNV(gpSubpixelPrecisionBiasNV, (C.GLuint)(xbits), (C.GLuint)(ybits)) +} +func TexAttachMemoryNV(target uint32, memory uint32, offset uint64) { + C.glowTexAttachMemoryNV(gpTexAttachMemoryNV, (C.GLenum)(target), (C.GLuint)(memory), (C.GLuint64)(offset)) +} + +// attach a buffer object's data store to a buffer texture object +func TexBuffer(target uint32, internalformat uint32, buffer uint32) { + C.glowTexBuffer(gpTexBuffer, (C.GLenum)(target), (C.GLenum)(internalformat), (C.GLuint)(buffer)) +} +func TexBufferARB(target uint32, internalformat uint32, buffer uint32) { + C.glowTexBufferARB(gpTexBufferARB, (C.GLenum)(target), (C.GLenum)(internalformat), (C.GLuint)(buffer)) +} + +// attach a range of a buffer object's data store to a buffer texture object +func TexBufferRange(target uint32, internalformat uint32, buffer uint32, offset int, size int) { + C.glowTexBufferRange(gpTexBufferRange, (C.GLenum)(target), (C.GLenum)(internalformat), (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(size)) +} +func TexCoordFormatNV(size int32, xtype uint32, stride int32) { + C.glowTexCoordFormatNV(gpTexCoordFormatNV, (C.GLint)(size), (C.GLenum)(xtype), (C.GLsizei)(stride)) +} + +// specify a one-dimensional texture image +func TexImage1D(target uint32, level int32, internalformat int32, width int32, border int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowTexImage1D(gpTexImage1D, (C.GLenum)(target), (C.GLint)(level), (C.GLint)(internalformat), (C.GLsizei)(width), (C.GLint)(border), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} + +// specify a two-dimensional texture image +func TexImage2D(target uint32, level int32, internalformat int32, width int32, height int32, border int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowTexImage2D(gpTexImage2D, (C.GLenum)(target), (C.GLint)(level), (C.GLint)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLint)(border), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} + +// establish the data storage, format, dimensions, and number of samples of a multisample texture's image +func TexImage2DMultisample(target uint32, samples int32, internalformat uint32, width int32, height int32, fixedsamplelocations bool) { + C.glowTexImage2DMultisample(gpTexImage2DMultisample, (C.GLenum)(target), (C.GLsizei)(samples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLboolean)(boolToInt(fixedsamplelocations))) +} + +// specify a three-dimensional texture image +func TexImage3D(target uint32, level int32, internalformat int32, width int32, height int32, depth int32, border int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowTexImage3D(gpTexImage3D, (C.GLenum)(target), (C.GLint)(level), (C.GLint)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLint)(border), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} + +// establish the data storage, format, dimensions, and number of samples of a multisample texture's image +func TexImage3DMultisample(target uint32, samples int32, internalformat uint32, width int32, height int32, depth int32, fixedsamplelocations bool) { + C.glowTexImage3DMultisample(gpTexImage3DMultisample, (C.GLenum)(target), (C.GLsizei)(samples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLboolean)(boolToInt(fixedsamplelocations))) +} +func TexPageCommitmentARB(target uint32, level int32, xoffset int32, yoffset int32, zoffset int32, width int32, height int32, depth int32, commit bool) { + C.glowTexPageCommitmentARB(gpTexPageCommitmentARB, (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLboolean)(boolToInt(commit))) +} +func TexPageCommitmentMemNV(target uint32, layer int32, level int32, xoffset int32, yoffset int32, zoffset int32, width int32, height int32, depth int32, memory uint32, offset uint64, commit bool) { + C.glowTexPageCommitmentMemNV(gpTexPageCommitmentMemNV, (C.GLenum)(target), (C.GLint)(layer), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLuint)(memory), (C.GLuint64)(offset), (C.GLboolean)(boolToInt(commit))) +} +func TexParameterIiv(target uint32, pname uint32, params *int32) { + C.glowTexParameterIiv(gpTexParameterIiv, (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func TexParameterIuiv(target uint32, pname uint32, params *uint32) { + C.glowTexParameterIuiv(gpTexParameterIuiv, (C.GLenum)(target), (C.GLenum)(pname), (*C.GLuint)(unsafe.Pointer(params))) +} +func TexParameterf(target uint32, pname uint32, param float32) { + C.glowTexParameterf(gpTexParameterf, (C.GLenum)(target), (C.GLenum)(pname), (C.GLfloat)(param)) +} +func TexParameterfv(target uint32, pname uint32, params *float32) { + C.glowTexParameterfv(gpTexParameterfv, (C.GLenum)(target), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(params))) +} +func TexParameteri(target uint32, pname uint32, param int32) { + C.glowTexParameteri(gpTexParameteri, (C.GLenum)(target), (C.GLenum)(pname), (C.GLint)(param)) +} +func TexParameteriv(target uint32, pname uint32, params *int32) { + C.glowTexParameteriv(gpTexParameteriv, (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} + +// simultaneously specify storage for all levels of a one-dimensional texture +func TexStorage1D(target uint32, levels int32, internalformat uint32, width int32) { + C.glowTexStorage1D(gpTexStorage1D, (C.GLenum)(target), (C.GLsizei)(levels), (C.GLenum)(internalformat), (C.GLsizei)(width)) +} + +// simultaneously specify storage for all levels of a two-dimensional or one-dimensional array texture +func TexStorage2D(target uint32, levels int32, internalformat uint32, width int32, height int32) { + C.glowTexStorage2D(gpTexStorage2D, (C.GLenum)(target), (C.GLsizei)(levels), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height)) +} + +// specify storage for a two-dimensional multisample texture +func TexStorage2DMultisample(target uint32, samples int32, internalformat uint32, width int32, height int32, fixedsamplelocations bool) { + C.glowTexStorage2DMultisample(gpTexStorage2DMultisample, (C.GLenum)(target), (C.GLsizei)(samples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLboolean)(boolToInt(fixedsamplelocations))) +} + +// simultaneously specify storage for all levels of a three-dimensional, two-dimensional array or cube-map array texture +func TexStorage3D(target uint32, levels int32, internalformat uint32, width int32, height int32, depth int32) { + C.glowTexStorage3D(gpTexStorage3D, (C.GLenum)(target), (C.GLsizei)(levels), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth)) +} + +// specify storage for a two-dimensional multisample array texture +func TexStorage3DMultisample(target uint32, samples int32, internalformat uint32, width int32, height int32, depth int32, fixedsamplelocations bool) { + C.glowTexStorage3DMultisample(gpTexStorage3DMultisample, (C.GLenum)(target), (C.GLsizei)(samples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLboolean)(boolToInt(fixedsamplelocations))) +} + +// specify a one-dimensional texture subimage +func TexSubImage1D(target uint32, level int32, xoffset int32, width int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowTexSubImage1D(gpTexSubImage1D, (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLsizei)(width), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} + +// specify a two-dimensional texture subimage +func TexSubImage2D(target uint32, level int32, xoffset int32, yoffset int32, width int32, height int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowTexSubImage2D(gpTexSubImage2D, (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} + +// specify a three-dimensional texture subimage +func TexSubImage3D(target uint32, level int32, xoffset int32, yoffset int32, zoffset int32, width int32, height int32, depth int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowTexSubImage3D(gpTexSubImage3D, (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} +func TextureAttachMemoryNV(texture uint32, memory uint32, offset uint64) { + C.glowTextureAttachMemoryNV(gpTextureAttachMemoryNV, (C.GLuint)(texture), (C.GLuint)(memory), (C.GLuint64)(offset)) +} + +// controls the ordering of reads and writes to rendered fragments across drawing commands +func TextureBarrier() { + C.glowTextureBarrier(gpTextureBarrier) +} +func TextureBarrierNV() { + C.glowTextureBarrierNV(gpTextureBarrierNV) +} + +// attach a buffer object's data store to a buffer texture object +func TextureBuffer(texture uint32, internalformat uint32, buffer uint32) { + C.glowTextureBuffer(gpTextureBuffer, (C.GLuint)(texture), (C.GLenum)(internalformat), (C.GLuint)(buffer)) +} +func TextureBufferEXT(texture uint32, target uint32, internalformat uint32, buffer uint32) { + C.glowTextureBufferEXT(gpTextureBufferEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLenum)(internalformat), (C.GLuint)(buffer)) +} + +// attach a range of a buffer object's data store to a buffer texture object +func TextureBufferRange(texture uint32, internalformat uint32, buffer uint32, offset int, size int) { + C.glowTextureBufferRange(gpTextureBufferRange, (C.GLuint)(texture), (C.GLenum)(internalformat), (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(size)) +} +func TextureBufferRangeEXT(texture uint32, target uint32, internalformat uint32, buffer uint32, offset int, size int) { + C.glowTextureBufferRangeEXT(gpTextureBufferRangeEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLenum)(internalformat), (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(size)) +} +func TextureImage1DEXT(texture uint32, target uint32, level int32, internalformat int32, width int32, border int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowTextureImage1DEXT(gpTextureImage1DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(internalformat), (C.GLsizei)(width), (C.GLint)(border), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} +func TextureImage2DEXT(texture uint32, target uint32, level int32, internalformat int32, width int32, height int32, border int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowTextureImage2DEXT(gpTextureImage2DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLint)(border), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} +func TextureImage3DEXT(texture uint32, target uint32, level int32, internalformat int32, width int32, height int32, depth int32, border int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowTextureImage3DEXT(gpTextureImage3DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLint)(border), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} +func TexturePageCommitmentEXT(texture uint32, level int32, xoffset int32, yoffset int32, zoffset int32, width int32, height int32, depth int32, commit bool) { + C.glowTexturePageCommitmentEXT(gpTexturePageCommitmentEXT, (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLboolean)(boolToInt(commit))) +} +func TexturePageCommitmentMemNV(texture uint32, layer int32, level int32, xoffset int32, yoffset int32, zoffset int32, width int32, height int32, depth int32, memory uint32, offset uint64, commit bool) { + C.glowTexturePageCommitmentMemNV(gpTexturePageCommitmentMemNV, (C.GLuint)(texture), (C.GLint)(layer), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLuint)(memory), (C.GLuint64)(offset), (C.GLboolean)(boolToInt(commit))) +} +func TextureParameterIiv(texture uint32, pname uint32, params *int32) { + C.glowTextureParameterIiv(gpTextureParameterIiv, (C.GLuint)(texture), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func TextureParameterIivEXT(texture uint32, target uint32, pname uint32, params *int32) { + C.glowTextureParameterIivEXT(gpTextureParameterIivEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func TextureParameterIuiv(texture uint32, pname uint32, params *uint32) { + C.glowTextureParameterIuiv(gpTextureParameterIuiv, (C.GLuint)(texture), (C.GLenum)(pname), (*C.GLuint)(unsafe.Pointer(params))) +} +func TextureParameterIuivEXT(texture uint32, target uint32, pname uint32, params *uint32) { + C.glowTextureParameterIuivEXT(gpTextureParameterIuivEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLuint)(unsafe.Pointer(params))) +} +func TextureParameterf(texture uint32, pname uint32, param float32) { + C.glowTextureParameterf(gpTextureParameterf, (C.GLuint)(texture), (C.GLenum)(pname), (C.GLfloat)(param)) +} +func TextureParameterfEXT(texture uint32, target uint32, pname uint32, param float32) { + C.glowTextureParameterfEXT(gpTextureParameterfEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLenum)(pname), (C.GLfloat)(param)) +} +func TextureParameterfv(texture uint32, pname uint32, param *float32) { + C.glowTextureParameterfv(gpTextureParameterfv, (C.GLuint)(texture), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(param))) +} +func TextureParameterfvEXT(texture uint32, target uint32, pname uint32, params *float32) { + C.glowTextureParameterfvEXT(gpTextureParameterfvEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLfloat)(unsafe.Pointer(params))) +} +func TextureParameteri(texture uint32, pname uint32, param int32) { + C.glowTextureParameteri(gpTextureParameteri, (C.GLuint)(texture), (C.GLenum)(pname), (C.GLint)(param)) +} +func TextureParameteriEXT(texture uint32, target uint32, pname uint32, param int32) { + C.glowTextureParameteriEXT(gpTextureParameteriEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLenum)(pname), (C.GLint)(param)) +} +func TextureParameteriv(texture uint32, pname uint32, param *int32) { + C.glowTextureParameteriv(gpTextureParameteriv, (C.GLuint)(texture), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(param))) +} +func TextureParameterivEXT(texture uint32, target uint32, pname uint32, params *int32) { + C.glowTextureParameterivEXT(gpTextureParameterivEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint)(unsafe.Pointer(params))) +} +func TextureRenderbufferEXT(texture uint32, target uint32, renderbuffer uint32) { + C.glowTextureRenderbufferEXT(gpTextureRenderbufferEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLuint)(renderbuffer)) +} + +// simultaneously specify storage for all levels of a one-dimensional texture +func TextureStorage1D(texture uint32, levels int32, internalformat uint32, width int32) { + C.glowTextureStorage1D(gpTextureStorage1D, (C.GLuint)(texture), (C.GLsizei)(levels), (C.GLenum)(internalformat), (C.GLsizei)(width)) +} +func TextureStorage1DEXT(texture uint32, target uint32, levels int32, internalformat uint32, width int32) { + C.glowTextureStorage1DEXT(gpTextureStorage1DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLsizei)(levels), (C.GLenum)(internalformat), (C.GLsizei)(width)) +} + +// simultaneously specify storage for all levels of a two-dimensional or one-dimensional array texture +func TextureStorage2D(texture uint32, levels int32, internalformat uint32, width int32, height int32) { + C.glowTextureStorage2D(gpTextureStorage2D, (C.GLuint)(texture), (C.GLsizei)(levels), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height)) +} +func TextureStorage2DEXT(texture uint32, target uint32, levels int32, internalformat uint32, width int32, height int32) { + C.glowTextureStorage2DEXT(gpTextureStorage2DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLsizei)(levels), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height)) +} + +// specify storage for a two-dimensional multisample texture +func TextureStorage2DMultisample(texture uint32, samples int32, internalformat uint32, width int32, height int32, fixedsamplelocations bool) { + C.glowTextureStorage2DMultisample(gpTextureStorage2DMultisample, (C.GLuint)(texture), (C.GLsizei)(samples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLboolean)(boolToInt(fixedsamplelocations))) +} +func TextureStorage2DMultisampleEXT(texture uint32, target uint32, samples int32, internalformat uint32, width int32, height int32, fixedsamplelocations bool) { + C.glowTextureStorage2DMultisampleEXT(gpTextureStorage2DMultisampleEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLsizei)(samples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLboolean)(boolToInt(fixedsamplelocations))) +} + +// simultaneously specify storage for all levels of a three-dimensional, two-dimensional array or cube-map array texture +func TextureStorage3D(texture uint32, levels int32, internalformat uint32, width int32, height int32, depth int32) { + C.glowTextureStorage3D(gpTextureStorage3D, (C.GLuint)(texture), (C.GLsizei)(levels), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth)) +} +func TextureStorage3DEXT(texture uint32, target uint32, levels int32, internalformat uint32, width int32, height int32, depth int32) { + C.glowTextureStorage3DEXT(gpTextureStorage3DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLsizei)(levels), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth)) +} + +// specify storage for a two-dimensional multisample array texture +func TextureStorage3DMultisample(texture uint32, samples int32, internalformat uint32, width int32, height int32, depth int32, fixedsamplelocations bool) { + C.glowTextureStorage3DMultisample(gpTextureStorage3DMultisample, (C.GLuint)(texture), (C.GLsizei)(samples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLboolean)(boolToInt(fixedsamplelocations))) +} +func TextureStorage3DMultisampleEXT(texture uint32, target uint32, samples int32, internalformat uint32, width int32, height int32, depth int32, fixedsamplelocations bool) { + C.glowTextureStorage3DMultisampleEXT(gpTextureStorage3DMultisampleEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLsizei)(samples), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLboolean)(boolToInt(fixedsamplelocations))) +} + +// specify a one-dimensional texture subimage +func TextureSubImage1D(texture uint32, level int32, xoffset int32, width int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowTextureSubImage1D(gpTextureSubImage1D, (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(xoffset), (C.GLsizei)(width), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} +func TextureSubImage1DEXT(texture uint32, target uint32, level int32, xoffset int32, width int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowTextureSubImage1DEXT(gpTextureSubImage1DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLsizei)(width), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} + +// specify a two-dimensional texture subimage +func TextureSubImage2D(texture uint32, level int32, xoffset int32, yoffset int32, width int32, height int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowTextureSubImage2D(gpTextureSubImage2D, (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} +func TextureSubImage2DEXT(texture uint32, target uint32, level int32, xoffset int32, yoffset int32, width int32, height int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowTextureSubImage2DEXT(gpTextureSubImage2DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} + +// specify a three-dimensional texture subimage +func TextureSubImage3D(texture uint32, level int32, xoffset int32, yoffset int32, zoffset int32, width int32, height int32, depth int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowTextureSubImage3D(gpTextureSubImage3D, (C.GLuint)(texture), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} +func TextureSubImage3DEXT(texture uint32, target uint32, level int32, xoffset int32, yoffset int32, zoffset int32, width int32, height int32, depth int32, format uint32, xtype uint32, pixels unsafe.Pointer) { + C.glowTextureSubImage3DEXT(gpTextureSubImage3DEXT, (C.GLuint)(texture), (C.GLenum)(target), (C.GLint)(level), (C.GLint)(xoffset), (C.GLint)(yoffset), (C.GLint)(zoffset), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLsizei)(depth), (C.GLenum)(format), (C.GLenum)(xtype), pixels) +} + +// initialize a texture as a data alias of another texture's data store +func TextureView(texture uint32, target uint32, origtexture uint32, internalformat uint32, minlevel uint32, numlevels uint32, minlayer uint32, numlayers uint32) { + C.glowTextureView(gpTextureView, (C.GLuint)(texture), (C.GLenum)(target), (C.GLuint)(origtexture), (C.GLenum)(internalformat), (C.GLuint)(minlevel), (C.GLuint)(numlevels), (C.GLuint)(minlayer), (C.GLuint)(numlayers)) +} + +// bind a buffer object to a transform feedback buffer object +func TransformFeedbackBufferBase(xfb uint32, index uint32, buffer uint32) { + C.glowTransformFeedbackBufferBase(gpTransformFeedbackBufferBase, (C.GLuint)(xfb), (C.GLuint)(index), (C.GLuint)(buffer)) +} + +// bind a range within a buffer object to a transform feedback buffer object +func TransformFeedbackBufferRange(xfb uint32, index uint32, buffer uint32, offset int, size int) { + C.glowTransformFeedbackBufferRange(gpTransformFeedbackBufferRange, (C.GLuint)(xfb), (C.GLuint)(index), (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizeiptr)(size)) +} + +// specify values to record in transform feedback buffers +func TransformFeedbackVaryings(program uint32, count int32, varyings **uint8, bufferMode uint32) { + C.glowTransformFeedbackVaryings(gpTransformFeedbackVaryings, (C.GLuint)(program), (C.GLsizei)(count), (**C.GLchar)(unsafe.Pointer(varyings)), (C.GLenum)(bufferMode)) +} +func TransformPathNV(resultPath uint32, srcPath uint32, transformType uint32, transformValues *float32) { + C.glowTransformPathNV(gpTransformPathNV, (C.GLuint)(resultPath), (C.GLuint)(srcPath), (C.GLenum)(transformType), (*C.GLfloat)(unsafe.Pointer(transformValues))) +} +func Uniform1d(location int32, x float64) { + C.glowUniform1d(gpUniform1d, (C.GLint)(location), (C.GLdouble)(x)) +} +func Uniform1dv(location int32, count int32, value *float64) { + C.glowUniform1dv(gpUniform1dv, (C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform1f(location int32, v0 float32) { + C.glowUniform1f(gpUniform1f, (C.GLint)(location), (C.GLfloat)(v0)) +} + +// Specify the value of a uniform variable for the current program object +func Uniform1fv(location int32, count int32, value *float32) { + C.glowUniform1fv(gpUniform1fv, (C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform1i(location int32, v0 int32) { + C.glowUniform1i(gpUniform1i, (C.GLint)(location), (C.GLint)(v0)) +} +func Uniform1i64ARB(location int32, x int64) { + C.glowUniform1i64ARB(gpUniform1i64ARB, (C.GLint)(location), (C.GLint64)(x)) +} +func Uniform1i64NV(location int32, x int64) { + C.glowUniform1i64NV(gpUniform1i64NV, (C.GLint)(location), (C.GLint64EXT)(x)) +} +func Uniform1i64vARB(location int32, count int32, value *int64) { + C.glowUniform1i64vARB(gpUniform1i64vARB, (C.GLint)(location), (C.GLsizei)(count), (*C.GLint64)(unsafe.Pointer(value))) +} +func Uniform1i64vNV(location int32, count int32, value *int64) { + C.glowUniform1i64vNV(gpUniform1i64vNV, (C.GLint)(location), (C.GLsizei)(count), (*C.GLint64EXT)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform1iv(location int32, count int32, value *int32) { + C.glowUniform1iv(gpUniform1iv, (C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform1ui(location int32, v0 uint32) { + C.glowUniform1ui(gpUniform1ui, (C.GLint)(location), (C.GLuint)(v0)) +} +func Uniform1ui64ARB(location int32, x uint64) { + C.glowUniform1ui64ARB(gpUniform1ui64ARB, (C.GLint)(location), (C.GLuint64)(x)) +} +func Uniform1ui64NV(location int32, x uint64) { + C.glowUniform1ui64NV(gpUniform1ui64NV, (C.GLint)(location), (C.GLuint64EXT)(x)) +} +func Uniform1ui64vARB(location int32, count int32, value *uint64) { + C.glowUniform1ui64vARB(gpUniform1ui64vARB, (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64)(unsafe.Pointer(value))) +} +func Uniform1ui64vNV(location int32, count int32, value *uint64) { + C.glowUniform1ui64vNV(gpUniform1ui64vNV, (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64EXT)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform1uiv(location int32, count int32, value *uint32) { + C.glowUniform1uiv(gpUniform1uiv, (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(value))) +} +func Uniform2d(location int32, x float64, y float64) { + C.glowUniform2d(gpUniform2d, (C.GLint)(location), (C.GLdouble)(x), (C.GLdouble)(y)) +} +func Uniform2dv(location int32, count int32, value *float64) { + C.glowUniform2dv(gpUniform2dv, (C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform2f(location int32, v0 float32, v1 float32) { + C.glowUniform2f(gpUniform2f, (C.GLint)(location), (C.GLfloat)(v0), (C.GLfloat)(v1)) +} + +// Specify the value of a uniform variable for the current program object +func Uniform2fv(location int32, count int32, value *float32) { + C.glowUniform2fv(gpUniform2fv, (C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform2i(location int32, v0 int32, v1 int32) { + C.glowUniform2i(gpUniform2i, (C.GLint)(location), (C.GLint)(v0), (C.GLint)(v1)) +} +func Uniform2i64ARB(location int32, x int64, y int64) { + C.glowUniform2i64ARB(gpUniform2i64ARB, (C.GLint)(location), (C.GLint64)(x), (C.GLint64)(y)) +} +func Uniform2i64NV(location int32, x int64, y int64) { + C.glowUniform2i64NV(gpUniform2i64NV, (C.GLint)(location), (C.GLint64EXT)(x), (C.GLint64EXT)(y)) +} +func Uniform2i64vARB(location int32, count int32, value *int64) { + C.glowUniform2i64vARB(gpUniform2i64vARB, (C.GLint)(location), (C.GLsizei)(count), (*C.GLint64)(unsafe.Pointer(value))) +} +func Uniform2i64vNV(location int32, count int32, value *int64) { + C.glowUniform2i64vNV(gpUniform2i64vNV, (C.GLint)(location), (C.GLsizei)(count), (*C.GLint64EXT)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform2iv(location int32, count int32, value *int32) { + C.glowUniform2iv(gpUniform2iv, (C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform2ui(location int32, v0 uint32, v1 uint32) { + C.glowUniform2ui(gpUniform2ui, (C.GLint)(location), (C.GLuint)(v0), (C.GLuint)(v1)) +} +func Uniform2ui64ARB(location int32, x uint64, y uint64) { + C.glowUniform2ui64ARB(gpUniform2ui64ARB, (C.GLint)(location), (C.GLuint64)(x), (C.GLuint64)(y)) +} +func Uniform2ui64NV(location int32, x uint64, y uint64) { + C.glowUniform2ui64NV(gpUniform2ui64NV, (C.GLint)(location), (C.GLuint64EXT)(x), (C.GLuint64EXT)(y)) +} +func Uniform2ui64vARB(location int32, count int32, value *uint64) { + C.glowUniform2ui64vARB(gpUniform2ui64vARB, (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64)(unsafe.Pointer(value))) +} +func Uniform2ui64vNV(location int32, count int32, value *uint64) { + C.glowUniform2ui64vNV(gpUniform2ui64vNV, (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64EXT)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform2uiv(location int32, count int32, value *uint32) { + C.glowUniform2uiv(gpUniform2uiv, (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(value))) +} +func Uniform3d(location int32, x float64, y float64, z float64) { + C.glowUniform3d(gpUniform3d, (C.GLint)(location), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z)) +} +func Uniform3dv(location int32, count int32, value *float64) { + C.glowUniform3dv(gpUniform3dv, (C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform3f(location int32, v0 float32, v1 float32, v2 float32) { + C.glowUniform3f(gpUniform3f, (C.GLint)(location), (C.GLfloat)(v0), (C.GLfloat)(v1), (C.GLfloat)(v2)) +} + +// Specify the value of a uniform variable for the current program object +func Uniform3fv(location int32, count int32, value *float32) { + C.glowUniform3fv(gpUniform3fv, (C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform3i(location int32, v0 int32, v1 int32, v2 int32) { + C.glowUniform3i(gpUniform3i, (C.GLint)(location), (C.GLint)(v0), (C.GLint)(v1), (C.GLint)(v2)) +} +func Uniform3i64ARB(location int32, x int64, y int64, z int64) { + C.glowUniform3i64ARB(gpUniform3i64ARB, (C.GLint)(location), (C.GLint64)(x), (C.GLint64)(y), (C.GLint64)(z)) +} +func Uniform3i64NV(location int32, x int64, y int64, z int64) { + C.glowUniform3i64NV(gpUniform3i64NV, (C.GLint)(location), (C.GLint64EXT)(x), (C.GLint64EXT)(y), (C.GLint64EXT)(z)) +} +func Uniform3i64vARB(location int32, count int32, value *int64) { + C.glowUniform3i64vARB(gpUniform3i64vARB, (C.GLint)(location), (C.GLsizei)(count), (*C.GLint64)(unsafe.Pointer(value))) +} +func Uniform3i64vNV(location int32, count int32, value *int64) { + C.glowUniform3i64vNV(gpUniform3i64vNV, (C.GLint)(location), (C.GLsizei)(count), (*C.GLint64EXT)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform3iv(location int32, count int32, value *int32) { + C.glowUniform3iv(gpUniform3iv, (C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform3ui(location int32, v0 uint32, v1 uint32, v2 uint32) { + C.glowUniform3ui(gpUniform3ui, (C.GLint)(location), (C.GLuint)(v0), (C.GLuint)(v1), (C.GLuint)(v2)) +} +func Uniform3ui64ARB(location int32, x uint64, y uint64, z uint64) { + C.glowUniform3ui64ARB(gpUniform3ui64ARB, (C.GLint)(location), (C.GLuint64)(x), (C.GLuint64)(y), (C.GLuint64)(z)) +} +func Uniform3ui64NV(location int32, x uint64, y uint64, z uint64) { + C.glowUniform3ui64NV(gpUniform3ui64NV, (C.GLint)(location), (C.GLuint64EXT)(x), (C.GLuint64EXT)(y), (C.GLuint64EXT)(z)) +} +func Uniform3ui64vARB(location int32, count int32, value *uint64) { + C.glowUniform3ui64vARB(gpUniform3ui64vARB, (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64)(unsafe.Pointer(value))) +} +func Uniform3ui64vNV(location int32, count int32, value *uint64) { + C.glowUniform3ui64vNV(gpUniform3ui64vNV, (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64EXT)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform3uiv(location int32, count int32, value *uint32) { + C.glowUniform3uiv(gpUniform3uiv, (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(value))) +} +func Uniform4d(location int32, x float64, y float64, z float64, w float64) { + C.glowUniform4d(gpUniform4d, (C.GLint)(location), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z), (C.GLdouble)(w)) +} +func Uniform4dv(location int32, count int32, value *float64) { + C.glowUniform4dv(gpUniform4dv, (C.GLint)(location), (C.GLsizei)(count), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform4f(location int32, v0 float32, v1 float32, v2 float32, v3 float32) { + C.glowUniform4f(gpUniform4f, (C.GLint)(location), (C.GLfloat)(v0), (C.GLfloat)(v1), (C.GLfloat)(v2), (C.GLfloat)(v3)) +} + +// Specify the value of a uniform variable for the current program object +func Uniform4fv(location int32, count int32, value *float32) { + C.glowUniform4fv(gpUniform4fv, (C.GLint)(location), (C.GLsizei)(count), (*C.GLfloat)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform4i(location int32, v0 int32, v1 int32, v2 int32, v3 int32) { + C.glowUniform4i(gpUniform4i, (C.GLint)(location), (C.GLint)(v0), (C.GLint)(v1), (C.GLint)(v2), (C.GLint)(v3)) +} +func Uniform4i64ARB(location int32, x int64, y int64, z int64, w int64) { + C.glowUniform4i64ARB(gpUniform4i64ARB, (C.GLint)(location), (C.GLint64)(x), (C.GLint64)(y), (C.GLint64)(z), (C.GLint64)(w)) +} +func Uniform4i64NV(location int32, x int64, y int64, z int64, w int64) { + C.glowUniform4i64NV(gpUniform4i64NV, (C.GLint)(location), (C.GLint64EXT)(x), (C.GLint64EXT)(y), (C.GLint64EXT)(z), (C.GLint64EXT)(w)) +} +func Uniform4i64vARB(location int32, count int32, value *int64) { + C.glowUniform4i64vARB(gpUniform4i64vARB, (C.GLint)(location), (C.GLsizei)(count), (*C.GLint64)(unsafe.Pointer(value))) +} +func Uniform4i64vNV(location int32, count int32, value *int64) { + C.glowUniform4i64vNV(gpUniform4i64vNV, (C.GLint)(location), (C.GLsizei)(count), (*C.GLint64EXT)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform4iv(location int32, count int32, value *int32) { + C.glowUniform4iv(gpUniform4iv, (C.GLint)(location), (C.GLsizei)(count), (*C.GLint)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform4ui(location int32, v0 uint32, v1 uint32, v2 uint32, v3 uint32) { + C.glowUniform4ui(gpUniform4ui, (C.GLint)(location), (C.GLuint)(v0), (C.GLuint)(v1), (C.GLuint)(v2), (C.GLuint)(v3)) +} +func Uniform4ui64ARB(location int32, x uint64, y uint64, z uint64, w uint64) { + C.glowUniform4ui64ARB(gpUniform4ui64ARB, (C.GLint)(location), (C.GLuint64)(x), (C.GLuint64)(y), (C.GLuint64)(z), (C.GLuint64)(w)) +} +func Uniform4ui64NV(location int32, x uint64, y uint64, z uint64, w uint64) { + C.glowUniform4ui64NV(gpUniform4ui64NV, (C.GLint)(location), (C.GLuint64EXT)(x), (C.GLuint64EXT)(y), (C.GLuint64EXT)(z), (C.GLuint64EXT)(w)) +} +func Uniform4ui64vARB(location int32, count int32, value *uint64) { + C.glowUniform4ui64vARB(gpUniform4ui64vARB, (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64)(unsafe.Pointer(value))) +} +func Uniform4ui64vNV(location int32, count int32, value *uint64) { + C.glowUniform4ui64vNV(gpUniform4ui64vNV, (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64EXT)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func Uniform4uiv(location int32, count int32, value *uint32) { + C.glowUniform4uiv(gpUniform4uiv, (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(value))) +} + +// assign a binding point to an active uniform block +func UniformBlockBinding(program uint32, uniformBlockIndex uint32, uniformBlockBinding uint32) { + C.glowUniformBlockBinding(gpUniformBlockBinding, (C.GLuint)(program), (C.GLuint)(uniformBlockIndex), (C.GLuint)(uniformBlockBinding)) +} +func UniformHandleui64ARB(location int32, value uint64) { + C.glowUniformHandleui64ARB(gpUniformHandleui64ARB, (C.GLint)(location), (C.GLuint64)(value)) +} +func UniformHandleui64NV(location int32, value uint64) { + C.glowUniformHandleui64NV(gpUniformHandleui64NV, (C.GLint)(location), (C.GLuint64)(value)) +} +func UniformHandleui64vARB(location int32, count int32, value *uint64) { + C.glowUniformHandleui64vARB(gpUniformHandleui64vARB, (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64)(unsafe.Pointer(value))) +} +func UniformHandleui64vNV(location int32, count int32, value *uint64) { + C.glowUniformHandleui64vNV(gpUniformHandleui64vNV, (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64)(unsafe.Pointer(value))) +} +func UniformMatrix2dv(location int32, count int32, transpose bool, value *float64) { + C.glowUniformMatrix2dv(gpUniformMatrix2dv, (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func UniformMatrix2fv(location int32, count int32, transpose bool, value *float32) { + C.glowUniformMatrix2fv(gpUniformMatrix2fv, (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func UniformMatrix2x3dv(location int32, count int32, transpose bool, value *float64) { + C.glowUniformMatrix2x3dv(gpUniformMatrix2x3dv, (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func UniformMatrix2x3fv(location int32, count int32, transpose bool, value *float32) { + C.glowUniformMatrix2x3fv(gpUniformMatrix2x3fv, (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func UniformMatrix2x4dv(location int32, count int32, transpose bool, value *float64) { + C.glowUniformMatrix2x4dv(gpUniformMatrix2x4dv, (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func UniformMatrix2x4fv(location int32, count int32, transpose bool, value *float32) { + C.glowUniformMatrix2x4fv(gpUniformMatrix2x4fv, (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func UniformMatrix3dv(location int32, count int32, transpose bool, value *float64) { + C.glowUniformMatrix3dv(gpUniformMatrix3dv, (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func UniformMatrix3fv(location int32, count int32, transpose bool, value *float32) { + C.glowUniformMatrix3fv(gpUniformMatrix3fv, (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func UniformMatrix3x2dv(location int32, count int32, transpose bool, value *float64) { + C.glowUniformMatrix3x2dv(gpUniformMatrix3x2dv, (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func UniformMatrix3x2fv(location int32, count int32, transpose bool, value *float32) { + C.glowUniformMatrix3x2fv(gpUniformMatrix3x2fv, (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func UniformMatrix3x4dv(location int32, count int32, transpose bool, value *float64) { + C.glowUniformMatrix3x4dv(gpUniformMatrix3x4dv, (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func UniformMatrix3x4fv(location int32, count int32, transpose bool, value *float32) { + C.glowUniformMatrix3x4fv(gpUniformMatrix3x4fv, (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func UniformMatrix4dv(location int32, count int32, transpose bool, value *float64) { + C.glowUniformMatrix4dv(gpUniformMatrix4dv, (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func UniformMatrix4fv(location int32, count int32, transpose bool, value *float32) { + C.glowUniformMatrix4fv(gpUniformMatrix4fv, (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func UniformMatrix4x2dv(location int32, count int32, transpose bool, value *float64) { + C.glowUniformMatrix4x2dv(gpUniformMatrix4x2dv, (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func UniformMatrix4x2fv(location int32, count int32, transpose bool, value *float32) { + C.glowUniformMatrix4x2fv(gpUniformMatrix4x2fv, (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func UniformMatrix4x3dv(location int32, count int32, transpose bool, value *float64) { + C.glowUniformMatrix4x3dv(gpUniformMatrix4x3dv, (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLdouble)(unsafe.Pointer(value))) +} + +// Specify the value of a uniform variable for the current program object +func UniformMatrix4x3fv(location int32, count int32, transpose bool, value *float32) { + C.glowUniformMatrix4x3fv(gpUniformMatrix4x3fv, (C.GLint)(location), (C.GLsizei)(count), (C.GLboolean)(boolToInt(transpose)), (*C.GLfloat)(unsafe.Pointer(value))) +} +func UniformSubroutinesuiv(shadertype uint32, count int32, indices *uint32) { + C.glowUniformSubroutinesuiv(gpUniformSubroutinesuiv, (C.GLenum)(shadertype), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(indices))) +} +func Uniformui64NV(location int32, value uint64) { + C.glowUniformui64NV(gpUniformui64NV, (C.GLint)(location), (C.GLuint64EXT)(value)) +} +func Uniformui64vNV(location int32, count int32, value *uint64) { + C.glowUniformui64vNV(gpUniformui64vNV, (C.GLint)(location), (C.GLsizei)(count), (*C.GLuint64EXT)(unsafe.Pointer(value))) +} + +// release the mapping of a buffer object's data store into the client's address space +func UnmapBuffer(target uint32) bool { + ret := C.glowUnmapBuffer(gpUnmapBuffer, (C.GLenum)(target)) + return ret == TRUE +} + +// release the mapping of a buffer object's data store into the client's address space +func UnmapNamedBuffer(buffer uint32) bool { + ret := C.glowUnmapNamedBuffer(gpUnmapNamedBuffer, (C.GLuint)(buffer)) + return ret == TRUE +} +func UnmapNamedBufferEXT(buffer uint32) bool { + ret := C.glowUnmapNamedBufferEXT(gpUnmapNamedBufferEXT, (C.GLuint)(buffer)) + return ret == TRUE +} + +// Installs a program object as part of current rendering state +func UseProgram(program uint32) { + C.glowUseProgram(gpUseProgram, (C.GLuint)(program)) +} + +// bind stages of a program object to a program pipeline +func UseProgramStages(pipeline uint32, stages uint32, program uint32) { + C.glowUseProgramStages(gpUseProgramStages, (C.GLuint)(pipeline), (C.GLbitfield)(stages), (C.GLuint)(program)) +} +func UseProgramStagesEXT(pipeline uint32, stages uint32, program uint32) { + C.glowUseProgramStagesEXT(gpUseProgramStagesEXT, (C.GLuint)(pipeline), (C.GLbitfield)(stages), (C.GLuint)(program)) +} +func UseShaderProgramEXT(xtype uint32, program uint32) { + C.glowUseShaderProgramEXT(gpUseShaderProgramEXT, (C.GLenum)(xtype), (C.GLuint)(program)) +} + +// Validates a program object +func ValidateProgram(program uint32) { + C.glowValidateProgram(gpValidateProgram, (C.GLuint)(program)) +} + +// validate a program pipeline object against current GL state +func ValidateProgramPipeline(pipeline uint32) { + C.glowValidateProgramPipeline(gpValidateProgramPipeline, (C.GLuint)(pipeline)) +} +func ValidateProgramPipelineEXT(pipeline uint32) { + C.glowValidateProgramPipelineEXT(gpValidateProgramPipelineEXT, (C.GLuint)(pipeline)) +} +func VertexArrayAttribBinding(vaobj uint32, attribindex uint32, bindingindex uint32) { + C.glowVertexArrayAttribBinding(gpVertexArrayAttribBinding, (C.GLuint)(vaobj), (C.GLuint)(attribindex), (C.GLuint)(bindingindex)) +} + +// specify the organization of vertex arrays +func VertexArrayAttribFormat(vaobj uint32, attribindex uint32, size int32, xtype uint32, normalized bool, relativeoffset uint32) { + C.glowVertexArrayAttribFormat(gpVertexArrayAttribFormat, (C.GLuint)(vaobj), (C.GLuint)(attribindex), (C.GLint)(size), (C.GLenum)(xtype), (C.GLboolean)(boolToInt(normalized)), (C.GLuint)(relativeoffset)) +} +func VertexArrayAttribIFormat(vaobj uint32, attribindex uint32, size int32, xtype uint32, relativeoffset uint32) { + C.glowVertexArrayAttribIFormat(gpVertexArrayAttribIFormat, (C.GLuint)(vaobj), (C.GLuint)(attribindex), (C.GLint)(size), (C.GLenum)(xtype), (C.GLuint)(relativeoffset)) +} +func VertexArrayAttribLFormat(vaobj uint32, attribindex uint32, size int32, xtype uint32, relativeoffset uint32) { + C.glowVertexArrayAttribLFormat(gpVertexArrayAttribLFormat, (C.GLuint)(vaobj), (C.GLuint)(attribindex), (C.GLint)(size), (C.GLenum)(xtype), (C.GLuint)(relativeoffset)) +} +func VertexArrayBindVertexBufferEXT(vaobj uint32, bindingindex uint32, buffer uint32, offset int, stride int32) { + C.glowVertexArrayBindVertexBufferEXT(gpVertexArrayBindVertexBufferEXT, (C.GLuint)(vaobj), (C.GLuint)(bindingindex), (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizei)(stride)) +} + +// modify the rate at which generic vertex attributes advance +func VertexArrayBindingDivisor(vaobj uint32, bindingindex uint32, divisor uint32) { + C.glowVertexArrayBindingDivisor(gpVertexArrayBindingDivisor, (C.GLuint)(vaobj), (C.GLuint)(bindingindex), (C.GLuint)(divisor)) +} +func VertexArrayColorOffsetEXT(vaobj uint32, buffer uint32, size int32, xtype uint32, stride int32, offset int) { + C.glowVertexArrayColorOffsetEXT(gpVertexArrayColorOffsetEXT, (C.GLuint)(vaobj), (C.GLuint)(buffer), (C.GLint)(size), (C.GLenum)(xtype), (C.GLsizei)(stride), (C.GLintptr)(offset)) +} +func VertexArrayEdgeFlagOffsetEXT(vaobj uint32, buffer uint32, stride int32, offset int) { + C.glowVertexArrayEdgeFlagOffsetEXT(gpVertexArrayEdgeFlagOffsetEXT, (C.GLuint)(vaobj), (C.GLuint)(buffer), (C.GLsizei)(stride), (C.GLintptr)(offset)) +} + +// configures element array buffer binding of a vertex array object +func VertexArrayElementBuffer(vaobj uint32, buffer uint32) { + C.glowVertexArrayElementBuffer(gpVertexArrayElementBuffer, (C.GLuint)(vaobj), (C.GLuint)(buffer)) +} +func VertexArrayFogCoordOffsetEXT(vaobj uint32, buffer uint32, xtype uint32, stride int32, offset int) { + C.glowVertexArrayFogCoordOffsetEXT(gpVertexArrayFogCoordOffsetEXT, (C.GLuint)(vaobj), (C.GLuint)(buffer), (C.GLenum)(xtype), (C.GLsizei)(stride), (C.GLintptr)(offset)) +} +func VertexArrayIndexOffsetEXT(vaobj uint32, buffer uint32, xtype uint32, stride int32, offset int) { + C.glowVertexArrayIndexOffsetEXT(gpVertexArrayIndexOffsetEXT, (C.GLuint)(vaobj), (C.GLuint)(buffer), (C.GLenum)(xtype), (C.GLsizei)(stride), (C.GLintptr)(offset)) +} +func VertexArrayMultiTexCoordOffsetEXT(vaobj uint32, buffer uint32, texunit uint32, size int32, xtype uint32, stride int32, offset int) { + C.glowVertexArrayMultiTexCoordOffsetEXT(gpVertexArrayMultiTexCoordOffsetEXT, (C.GLuint)(vaobj), (C.GLuint)(buffer), (C.GLenum)(texunit), (C.GLint)(size), (C.GLenum)(xtype), (C.GLsizei)(stride), (C.GLintptr)(offset)) +} +func VertexArrayNormalOffsetEXT(vaobj uint32, buffer uint32, xtype uint32, stride int32, offset int) { + C.glowVertexArrayNormalOffsetEXT(gpVertexArrayNormalOffsetEXT, (C.GLuint)(vaobj), (C.GLuint)(buffer), (C.GLenum)(xtype), (C.GLsizei)(stride), (C.GLintptr)(offset)) +} +func VertexArraySecondaryColorOffsetEXT(vaobj uint32, buffer uint32, size int32, xtype uint32, stride int32, offset int) { + C.glowVertexArraySecondaryColorOffsetEXT(gpVertexArraySecondaryColorOffsetEXT, (C.GLuint)(vaobj), (C.GLuint)(buffer), (C.GLint)(size), (C.GLenum)(xtype), (C.GLsizei)(stride), (C.GLintptr)(offset)) +} +func VertexArrayTexCoordOffsetEXT(vaobj uint32, buffer uint32, size int32, xtype uint32, stride int32, offset int) { + C.glowVertexArrayTexCoordOffsetEXT(gpVertexArrayTexCoordOffsetEXT, (C.GLuint)(vaobj), (C.GLuint)(buffer), (C.GLint)(size), (C.GLenum)(xtype), (C.GLsizei)(stride), (C.GLintptr)(offset)) +} +func VertexArrayVertexAttribBindingEXT(vaobj uint32, attribindex uint32, bindingindex uint32) { + C.glowVertexArrayVertexAttribBindingEXT(gpVertexArrayVertexAttribBindingEXT, (C.GLuint)(vaobj), (C.GLuint)(attribindex), (C.GLuint)(bindingindex)) +} +func VertexArrayVertexAttribDivisorEXT(vaobj uint32, index uint32, divisor uint32) { + C.glowVertexArrayVertexAttribDivisorEXT(gpVertexArrayVertexAttribDivisorEXT, (C.GLuint)(vaobj), (C.GLuint)(index), (C.GLuint)(divisor)) +} +func VertexArrayVertexAttribFormatEXT(vaobj uint32, attribindex uint32, size int32, xtype uint32, normalized bool, relativeoffset uint32) { + C.glowVertexArrayVertexAttribFormatEXT(gpVertexArrayVertexAttribFormatEXT, (C.GLuint)(vaobj), (C.GLuint)(attribindex), (C.GLint)(size), (C.GLenum)(xtype), (C.GLboolean)(boolToInt(normalized)), (C.GLuint)(relativeoffset)) +} +func VertexArrayVertexAttribIFormatEXT(vaobj uint32, attribindex uint32, size int32, xtype uint32, relativeoffset uint32) { + C.glowVertexArrayVertexAttribIFormatEXT(gpVertexArrayVertexAttribIFormatEXT, (C.GLuint)(vaobj), (C.GLuint)(attribindex), (C.GLint)(size), (C.GLenum)(xtype), (C.GLuint)(relativeoffset)) +} +func VertexArrayVertexAttribIOffsetEXT(vaobj uint32, buffer uint32, index uint32, size int32, xtype uint32, stride int32, offset int) { + C.glowVertexArrayVertexAttribIOffsetEXT(gpVertexArrayVertexAttribIOffsetEXT, (C.GLuint)(vaobj), (C.GLuint)(buffer), (C.GLuint)(index), (C.GLint)(size), (C.GLenum)(xtype), (C.GLsizei)(stride), (C.GLintptr)(offset)) +} +func VertexArrayVertexAttribLFormatEXT(vaobj uint32, attribindex uint32, size int32, xtype uint32, relativeoffset uint32) { + C.glowVertexArrayVertexAttribLFormatEXT(gpVertexArrayVertexAttribLFormatEXT, (C.GLuint)(vaobj), (C.GLuint)(attribindex), (C.GLint)(size), (C.GLenum)(xtype), (C.GLuint)(relativeoffset)) +} +func VertexArrayVertexAttribLOffsetEXT(vaobj uint32, buffer uint32, index uint32, size int32, xtype uint32, stride int32, offset int) { + C.glowVertexArrayVertexAttribLOffsetEXT(gpVertexArrayVertexAttribLOffsetEXT, (C.GLuint)(vaobj), (C.GLuint)(buffer), (C.GLuint)(index), (C.GLint)(size), (C.GLenum)(xtype), (C.GLsizei)(stride), (C.GLintptr)(offset)) +} +func VertexArrayVertexAttribOffsetEXT(vaobj uint32, buffer uint32, index uint32, size int32, xtype uint32, normalized bool, stride int32, offset int) { + C.glowVertexArrayVertexAttribOffsetEXT(gpVertexArrayVertexAttribOffsetEXT, (C.GLuint)(vaobj), (C.GLuint)(buffer), (C.GLuint)(index), (C.GLint)(size), (C.GLenum)(xtype), (C.GLboolean)(boolToInt(normalized)), (C.GLsizei)(stride), (C.GLintptr)(offset)) +} +func VertexArrayVertexBindingDivisorEXT(vaobj uint32, bindingindex uint32, divisor uint32) { + C.glowVertexArrayVertexBindingDivisorEXT(gpVertexArrayVertexBindingDivisorEXT, (C.GLuint)(vaobj), (C.GLuint)(bindingindex), (C.GLuint)(divisor)) +} + +// bind a buffer to a vertex buffer bind point +func VertexArrayVertexBuffer(vaobj uint32, bindingindex uint32, buffer uint32, offset int, stride int32) { + C.glowVertexArrayVertexBuffer(gpVertexArrayVertexBuffer, (C.GLuint)(vaobj), (C.GLuint)(bindingindex), (C.GLuint)(buffer), (C.GLintptr)(offset), (C.GLsizei)(stride)) +} + +// attach multiple buffer objects to a vertex array object +func VertexArrayVertexBuffers(vaobj uint32, first uint32, count int32, buffers *uint32, offsets *int, strides *int32) { + C.glowVertexArrayVertexBuffers(gpVertexArrayVertexBuffers, (C.GLuint)(vaobj), (C.GLuint)(first), (C.GLsizei)(count), (*C.GLuint)(unsafe.Pointer(buffers)), (*C.GLintptr)(unsafe.Pointer(offsets)), (*C.GLsizei)(unsafe.Pointer(strides))) +} +func VertexArrayVertexOffsetEXT(vaobj uint32, buffer uint32, size int32, xtype uint32, stride int32, offset int) { + C.glowVertexArrayVertexOffsetEXT(gpVertexArrayVertexOffsetEXT, (C.GLuint)(vaobj), (C.GLuint)(buffer), (C.GLint)(size), (C.GLenum)(xtype), (C.GLsizei)(stride), (C.GLintptr)(offset)) +} +func VertexAttrib1d(index uint32, x float64) { + C.glowVertexAttrib1d(gpVertexAttrib1d, (C.GLuint)(index), (C.GLdouble)(x)) +} +func VertexAttrib1dv(index uint32, v *float64) { + C.glowVertexAttrib1dv(gpVertexAttrib1dv, (C.GLuint)(index), (*C.GLdouble)(unsafe.Pointer(v))) +} +func VertexAttrib1f(index uint32, x float32) { + C.glowVertexAttrib1f(gpVertexAttrib1f, (C.GLuint)(index), (C.GLfloat)(x)) +} +func VertexAttrib1fv(index uint32, v *float32) { + C.glowVertexAttrib1fv(gpVertexAttrib1fv, (C.GLuint)(index), (*C.GLfloat)(unsafe.Pointer(v))) +} +func VertexAttrib1s(index uint32, x int16) { + C.glowVertexAttrib1s(gpVertexAttrib1s, (C.GLuint)(index), (C.GLshort)(x)) +} +func VertexAttrib1sv(index uint32, v *int16) { + C.glowVertexAttrib1sv(gpVertexAttrib1sv, (C.GLuint)(index), (*C.GLshort)(unsafe.Pointer(v))) +} +func VertexAttrib2d(index uint32, x float64, y float64) { + C.glowVertexAttrib2d(gpVertexAttrib2d, (C.GLuint)(index), (C.GLdouble)(x), (C.GLdouble)(y)) +} +func VertexAttrib2dv(index uint32, v *float64) { + C.glowVertexAttrib2dv(gpVertexAttrib2dv, (C.GLuint)(index), (*C.GLdouble)(unsafe.Pointer(v))) +} +func VertexAttrib2f(index uint32, x float32, y float32) { + C.glowVertexAttrib2f(gpVertexAttrib2f, (C.GLuint)(index), (C.GLfloat)(x), (C.GLfloat)(y)) +} +func VertexAttrib2fv(index uint32, v *float32) { + C.glowVertexAttrib2fv(gpVertexAttrib2fv, (C.GLuint)(index), (*C.GLfloat)(unsafe.Pointer(v))) +} +func VertexAttrib2s(index uint32, x int16, y int16) { + C.glowVertexAttrib2s(gpVertexAttrib2s, (C.GLuint)(index), (C.GLshort)(x), (C.GLshort)(y)) +} +func VertexAttrib2sv(index uint32, v *int16) { + C.glowVertexAttrib2sv(gpVertexAttrib2sv, (C.GLuint)(index), (*C.GLshort)(unsafe.Pointer(v))) +} +func VertexAttrib3d(index uint32, x float64, y float64, z float64) { + C.glowVertexAttrib3d(gpVertexAttrib3d, (C.GLuint)(index), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z)) +} +func VertexAttrib3dv(index uint32, v *float64) { + C.glowVertexAttrib3dv(gpVertexAttrib3dv, (C.GLuint)(index), (*C.GLdouble)(unsafe.Pointer(v))) +} +func VertexAttrib3f(index uint32, x float32, y float32, z float32) { + C.glowVertexAttrib3f(gpVertexAttrib3f, (C.GLuint)(index), (C.GLfloat)(x), (C.GLfloat)(y), (C.GLfloat)(z)) +} +func VertexAttrib3fv(index uint32, v *float32) { + C.glowVertexAttrib3fv(gpVertexAttrib3fv, (C.GLuint)(index), (*C.GLfloat)(unsafe.Pointer(v))) +} +func VertexAttrib3s(index uint32, x int16, y int16, z int16) { + C.glowVertexAttrib3s(gpVertexAttrib3s, (C.GLuint)(index), (C.GLshort)(x), (C.GLshort)(y), (C.GLshort)(z)) +} +func VertexAttrib3sv(index uint32, v *int16) { + C.glowVertexAttrib3sv(gpVertexAttrib3sv, (C.GLuint)(index), (*C.GLshort)(unsafe.Pointer(v))) +} +func VertexAttrib4Nbv(index uint32, v *int8) { + C.glowVertexAttrib4Nbv(gpVertexAttrib4Nbv, (C.GLuint)(index), (*C.GLbyte)(unsafe.Pointer(v))) +} +func VertexAttrib4Niv(index uint32, v *int32) { + C.glowVertexAttrib4Niv(gpVertexAttrib4Niv, (C.GLuint)(index), (*C.GLint)(unsafe.Pointer(v))) +} +func VertexAttrib4Nsv(index uint32, v *int16) { + C.glowVertexAttrib4Nsv(gpVertexAttrib4Nsv, (C.GLuint)(index), (*C.GLshort)(unsafe.Pointer(v))) +} +func VertexAttrib4Nub(index uint32, x uint8, y uint8, z uint8, w uint8) { + C.glowVertexAttrib4Nub(gpVertexAttrib4Nub, (C.GLuint)(index), (C.GLubyte)(x), (C.GLubyte)(y), (C.GLubyte)(z), (C.GLubyte)(w)) +} +func VertexAttrib4Nubv(index uint32, v *uint8) { + C.glowVertexAttrib4Nubv(gpVertexAttrib4Nubv, (C.GLuint)(index), (*C.GLubyte)(unsafe.Pointer(v))) +} +func VertexAttrib4Nuiv(index uint32, v *uint32) { + C.glowVertexAttrib4Nuiv(gpVertexAttrib4Nuiv, (C.GLuint)(index), (*C.GLuint)(unsafe.Pointer(v))) +} +func VertexAttrib4Nusv(index uint32, v *uint16) { + C.glowVertexAttrib4Nusv(gpVertexAttrib4Nusv, (C.GLuint)(index), (*C.GLushort)(unsafe.Pointer(v))) +} +func VertexAttrib4bv(index uint32, v *int8) { + C.glowVertexAttrib4bv(gpVertexAttrib4bv, (C.GLuint)(index), (*C.GLbyte)(unsafe.Pointer(v))) +} +func VertexAttrib4d(index uint32, x float64, y float64, z float64, w float64) { + C.glowVertexAttrib4d(gpVertexAttrib4d, (C.GLuint)(index), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z), (C.GLdouble)(w)) +} +func VertexAttrib4dv(index uint32, v *float64) { + C.glowVertexAttrib4dv(gpVertexAttrib4dv, (C.GLuint)(index), (*C.GLdouble)(unsafe.Pointer(v))) +} +func VertexAttrib4f(index uint32, x float32, y float32, z float32, w float32) { + C.glowVertexAttrib4f(gpVertexAttrib4f, (C.GLuint)(index), (C.GLfloat)(x), (C.GLfloat)(y), (C.GLfloat)(z), (C.GLfloat)(w)) +} +func VertexAttrib4fv(index uint32, v *float32) { + C.glowVertexAttrib4fv(gpVertexAttrib4fv, (C.GLuint)(index), (*C.GLfloat)(unsafe.Pointer(v))) +} +func VertexAttrib4iv(index uint32, v *int32) { + C.glowVertexAttrib4iv(gpVertexAttrib4iv, (C.GLuint)(index), (*C.GLint)(unsafe.Pointer(v))) +} +func VertexAttrib4s(index uint32, x int16, y int16, z int16, w int16) { + C.glowVertexAttrib4s(gpVertexAttrib4s, (C.GLuint)(index), (C.GLshort)(x), (C.GLshort)(y), (C.GLshort)(z), (C.GLshort)(w)) +} +func VertexAttrib4sv(index uint32, v *int16) { + C.glowVertexAttrib4sv(gpVertexAttrib4sv, (C.GLuint)(index), (*C.GLshort)(unsafe.Pointer(v))) +} +func VertexAttrib4ubv(index uint32, v *uint8) { + C.glowVertexAttrib4ubv(gpVertexAttrib4ubv, (C.GLuint)(index), (*C.GLubyte)(unsafe.Pointer(v))) +} +func VertexAttrib4uiv(index uint32, v *uint32) { + C.glowVertexAttrib4uiv(gpVertexAttrib4uiv, (C.GLuint)(index), (*C.GLuint)(unsafe.Pointer(v))) +} +func VertexAttrib4usv(index uint32, v *uint16) { + C.glowVertexAttrib4usv(gpVertexAttrib4usv, (C.GLuint)(index), (*C.GLushort)(unsafe.Pointer(v))) +} + +// associate a vertex attribute and a vertex buffer binding for a vertex array object +func VertexAttribBinding(attribindex uint32, bindingindex uint32) { + C.glowVertexAttribBinding(gpVertexAttribBinding, (C.GLuint)(attribindex), (C.GLuint)(bindingindex)) +} + +// modify the rate at which generic vertex attributes advance during instanced rendering +func VertexAttribDivisor(index uint32, divisor uint32) { + C.glowVertexAttribDivisor(gpVertexAttribDivisor, (C.GLuint)(index), (C.GLuint)(divisor)) +} +func VertexAttribDivisorARB(index uint32, divisor uint32) { + C.glowVertexAttribDivisorARB(gpVertexAttribDivisorARB, (C.GLuint)(index), (C.GLuint)(divisor)) +} + +// specify the organization of vertex arrays +func VertexAttribFormat(attribindex uint32, size int32, xtype uint32, normalized bool, relativeoffset uint32) { + C.glowVertexAttribFormat(gpVertexAttribFormat, (C.GLuint)(attribindex), (C.GLint)(size), (C.GLenum)(xtype), (C.GLboolean)(boolToInt(normalized)), (C.GLuint)(relativeoffset)) +} +func VertexAttribFormatNV(index uint32, size int32, xtype uint32, normalized bool, stride int32) { + C.glowVertexAttribFormatNV(gpVertexAttribFormatNV, (C.GLuint)(index), (C.GLint)(size), (C.GLenum)(xtype), (C.GLboolean)(boolToInt(normalized)), (C.GLsizei)(stride)) +} +func VertexAttribI1i(index uint32, x int32) { + C.glowVertexAttribI1i(gpVertexAttribI1i, (C.GLuint)(index), (C.GLint)(x)) +} +func VertexAttribI1iv(index uint32, v *int32) { + C.glowVertexAttribI1iv(gpVertexAttribI1iv, (C.GLuint)(index), (*C.GLint)(unsafe.Pointer(v))) +} +func VertexAttribI1ui(index uint32, x uint32) { + C.glowVertexAttribI1ui(gpVertexAttribI1ui, (C.GLuint)(index), (C.GLuint)(x)) +} +func VertexAttribI1uiv(index uint32, v *uint32) { + C.glowVertexAttribI1uiv(gpVertexAttribI1uiv, (C.GLuint)(index), (*C.GLuint)(unsafe.Pointer(v))) +} +func VertexAttribI2i(index uint32, x int32, y int32) { + C.glowVertexAttribI2i(gpVertexAttribI2i, (C.GLuint)(index), (C.GLint)(x), (C.GLint)(y)) +} +func VertexAttribI2iv(index uint32, v *int32) { + C.glowVertexAttribI2iv(gpVertexAttribI2iv, (C.GLuint)(index), (*C.GLint)(unsafe.Pointer(v))) +} +func VertexAttribI2ui(index uint32, x uint32, y uint32) { + C.glowVertexAttribI2ui(gpVertexAttribI2ui, (C.GLuint)(index), (C.GLuint)(x), (C.GLuint)(y)) +} +func VertexAttribI2uiv(index uint32, v *uint32) { + C.glowVertexAttribI2uiv(gpVertexAttribI2uiv, (C.GLuint)(index), (*C.GLuint)(unsafe.Pointer(v))) +} +func VertexAttribI3i(index uint32, x int32, y int32, z int32) { + C.glowVertexAttribI3i(gpVertexAttribI3i, (C.GLuint)(index), (C.GLint)(x), (C.GLint)(y), (C.GLint)(z)) +} +func VertexAttribI3iv(index uint32, v *int32) { + C.glowVertexAttribI3iv(gpVertexAttribI3iv, (C.GLuint)(index), (*C.GLint)(unsafe.Pointer(v))) +} +func VertexAttribI3ui(index uint32, x uint32, y uint32, z uint32) { + C.glowVertexAttribI3ui(gpVertexAttribI3ui, (C.GLuint)(index), (C.GLuint)(x), (C.GLuint)(y), (C.GLuint)(z)) +} +func VertexAttribI3uiv(index uint32, v *uint32) { + C.glowVertexAttribI3uiv(gpVertexAttribI3uiv, (C.GLuint)(index), (*C.GLuint)(unsafe.Pointer(v))) +} +func VertexAttribI4bv(index uint32, v *int8) { + C.glowVertexAttribI4bv(gpVertexAttribI4bv, (C.GLuint)(index), (*C.GLbyte)(unsafe.Pointer(v))) +} +func VertexAttribI4i(index uint32, x int32, y int32, z int32, w int32) { + C.glowVertexAttribI4i(gpVertexAttribI4i, (C.GLuint)(index), (C.GLint)(x), (C.GLint)(y), (C.GLint)(z), (C.GLint)(w)) +} +func VertexAttribI4iv(index uint32, v *int32) { + C.glowVertexAttribI4iv(gpVertexAttribI4iv, (C.GLuint)(index), (*C.GLint)(unsafe.Pointer(v))) +} +func VertexAttribI4sv(index uint32, v *int16) { + C.glowVertexAttribI4sv(gpVertexAttribI4sv, (C.GLuint)(index), (*C.GLshort)(unsafe.Pointer(v))) +} +func VertexAttribI4ubv(index uint32, v *uint8) { + C.glowVertexAttribI4ubv(gpVertexAttribI4ubv, (C.GLuint)(index), (*C.GLubyte)(unsafe.Pointer(v))) +} +func VertexAttribI4ui(index uint32, x uint32, y uint32, z uint32, w uint32) { + C.glowVertexAttribI4ui(gpVertexAttribI4ui, (C.GLuint)(index), (C.GLuint)(x), (C.GLuint)(y), (C.GLuint)(z), (C.GLuint)(w)) +} +func VertexAttribI4uiv(index uint32, v *uint32) { + C.glowVertexAttribI4uiv(gpVertexAttribI4uiv, (C.GLuint)(index), (*C.GLuint)(unsafe.Pointer(v))) +} +func VertexAttribI4usv(index uint32, v *uint16) { + C.glowVertexAttribI4usv(gpVertexAttribI4usv, (C.GLuint)(index), (*C.GLushort)(unsafe.Pointer(v))) +} +func VertexAttribIFormat(attribindex uint32, size int32, xtype uint32, relativeoffset uint32) { + C.glowVertexAttribIFormat(gpVertexAttribIFormat, (C.GLuint)(attribindex), (C.GLint)(size), (C.GLenum)(xtype), (C.GLuint)(relativeoffset)) +} +func VertexAttribIFormatNV(index uint32, size int32, xtype uint32, stride int32) { + C.glowVertexAttribIFormatNV(gpVertexAttribIFormatNV, (C.GLuint)(index), (C.GLint)(size), (C.GLenum)(xtype), (C.GLsizei)(stride)) +} +func VertexAttribIPointer(index uint32, size int32, xtype uint32, stride int32, pointer unsafe.Pointer) { + C.glowVertexAttribIPointer(gpVertexAttribIPointer, (C.GLuint)(index), (C.GLint)(size), (C.GLenum)(xtype), (C.GLsizei)(stride), pointer) +} +func VertexAttribIPointerWithOffset(index uint32, size int32, xtype uint32, stride int32, offset uintptr) { + C.glowVertexAttribIPointerWithOffset(gpVertexAttribIPointer, (C.GLuint)(index), (C.GLint)(size), (C.GLenum)(xtype), (C.GLsizei)(stride), (C.uintptr_t)(offset)) +} +func VertexAttribL1d(index uint32, x float64) { + C.glowVertexAttribL1d(gpVertexAttribL1d, (C.GLuint)(index), (C.GLdouble)(x)) +} +func VertexAttribL1dv(index uint32, v *float64) { + C.glowVertexAttribL1dv(gpVertexAttribL1dv, (C.GLuint)(index), (*C.GLdouble)(unsafe.Pointer(v))) +} +func VertexAttribL1i64NV(index uint32, x int64) { + C.glowVertexAttribL1i64NV(gpVertexAttribL1i64NV, (C.GLuint)(index), (C.GLint64EXT)(x)) +} +func VertexAttribL1i64vNV(index uint32, v *int64) { + C.glowVertexAttribL1i64vNV(gpVertexAttribL1i64vNV, (C.GLuint)(index), (*C.GLint64EXT)(unsafe.Pointer(v))) +} +func VertexAttribL1ui64ARB(index uint32, x uint64) { + C.glowVertexAttribL1ui64ARB(gpVertexAttribL1ui64ARB, (C.GLuint)(index), (C.GLuint64EXT)(x)) +} +func VertexAttribL1ui64NV(index uint32, x uint64) { + C.glowVertexAttribL1ui64NV(gpVertexAttribL1ui64NV, (C.GLuint)(index), (C.GLuint64EXT)(x)) +} +func VertexAttribL1ui64vARB(index uint32, v *uint64) { + C.glowVertexAttribL1ui64vARB(gpVertexAttribL1ui64vARB, (C.GLuint)(index), (*C.GLuint64EXT)(unsafe.Pointer(v))) +} +func VertexAttribL1ui64vNV(index uint32, v *uint64) { + C.glowVertexAttribL1ui64vNV(gpVertexAttribL1ui64vNV, (C.GLuint)(index), (*C.GLuint64EXT)(unsafe.Pointer(v))) +} +func VertexAttribL2d(index uint32, x float64, y float64) { + C.glowVertexAttribL2d(gpVertexAttribL2d, (C.GLuint)(index), (C.GLdouble)(x), (C.GLdouble)(y)) +} +func VertexAttribL2dv(index uint32, v *float64) { + C.glowVertexAttribL2dv(gpVertexAttribL2dv, (C.GLuint)(index), (*C.GLdouble)(unsafe.Pointer(v))) +} +func VertexAttribL2i64NV(index uint32, x int64, y int64) { + C.glowVertexAttribL2i64NV(gpVertexAttribL2i64NV, (C.GLuint)(index), (C.GLint64EXT)(x), (C.GLint64EXT)(y)) +} +func VertexAttribL2i64vNV(index uint32, v *int64) { + C.glowVertexAttribL2i64vNV(gpVertexAttribL2i64vNV, (C.GLuint)(index), (*C.GLint64EXT)(unsafe.Pointer(v))) +} +func VertexAttribL2ui64NV(index uint32, x uint64, y uint64) { + C.glowVertexAttribL2ui64NV(gpVertexAttribL2ui64NV, (C.GLuint)(index), (C.GLuint64EXT)(x), (C.GLuint64EXT)(y)) +} +func VertexAttribL2ui64vNV(index uint32, v *uint64) { + C.glowVertexAttribL2ui64vNV(gpVertexAttribL2ui64vNV, (C.GLuint)(index), (*C.GLuint64EXT)(unsafe.Pointer(v))) +} +func VertexAttribL3d(index uint32, x float64, y float64, z float64) { + C.glowVertexAttribL3d(gpVertexAttribL3d, (C.GLuint)(index), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z)) +} +func VertexAttribL3dv(index uint32, v *float64) { + C.glowVertexAttribL3dv(gpVertexAttribL3dv, (C.GLuint)(index), (*C.GLdouble)(unsafe.Pointer(v))) +} +func VertexAttribL3i64NV(index uint32, x int64, y int64, z int64) { + C.glowVertexAttribL3i64NV(gpVertexAttribL3i64NV, (C.GLuint)(index), (C.GLint64EXT)(x), (C.GLint64EXT)(y), (C.GLint64EXT)(z)) +} +func VertexAttribL3i64vNV(index uint32, v *int64) { + C.glowVertexAttribL3i64vNV(gpVertexAttribL3i64vNV, (C.GLuint)(index), (*C.GLint64EXT)(unsafe.Pointer(v))) +} +func VertexAttribL3ui64NV(index uint32, x uint64, y uint64, z uint64) { + C.glowVertexAttribL3ui64NV(gpVertexAttribL3ui64NV, (C.GLuint)(index), (C.GLuint64EXT)(x), (C.GLuint64EXT)(y), (C.GLuint64EXT)(z)) +} +func VertexAttribL3ui64vNV(index uint32, v *uint64) { + C.glowVertexAttribL3ui64vNV(gpVertexAttribL3ui64vNV, (C.GLuint)(index), (*C.GLuint64EXT)(unsafe.Pointer(v))) +} +func VertexAttribL4d(index uint32, x float64, y float64, z float64, w float64) { + C.glowVertexAttribL4d(gpVertexAttribL4d, (C.GLuint)(index), (C.GLdouble)(x), (C.GLdouble)(y), (C.GLdouble)(z), (C.GLdouble)(w)) +} +func VertexAttribL4dv(index uint32, v *float64) { + C.glowVertexAttribL4dv(gpVertexAttribL4dv, (C.GLuint)(index), (*C.GLdouble)(unsafe.Pointer(v))) +} +func VertexAttribL4i64NV(index uint32, x int64, y int64, z int64, w int64) { + C.glowVertexAttribL4i64NV(gpVertexAttribL4i64NV, (C.GLuint)(index), (C.GLint64EXT)(x), (C.GLint64EXT)(y), (C.GLint64EXT)(z), (C.GLint64EXT)(w)) +} +func VertexAttribL4i64vNV(index uint32, v *int64) { + C.glowVertexAttribL4i64vNV(gpVertexAttribL4i64vNV, (C.GLuint)(index), (*C.GLint64EXT)(unsafe.Pointer(v))) +} +func VertexAttribL4ui64NV(index uint32, x uint64, y uint64, z uint64, w uint64) { + C.glowVertexAttribL4ui64NV(gpVertexAttribL4ui64NV, (C.GLuint)(index), (C.GLuint64EXT)(x), (C.GLuint64EXT)(y), (C.GLuint64EXT)(z), (C.GLuint64EXT)(w)) +} +func VertexAttribL4ui64vNV(index uint32, v *uint64) { + C.glowVertexAttribL4ui64vNV(gpVertexAttribL4ui64vNV, (C.GLuint)(index), (*C.GLuint64EXT)(unsafe.Pointer(v))) +} +func VertexAttribLFormat(attribindex uint32, size int32, xtype uint32, relativeoffset uint32) { + C.glowVertexAttribLFormat(gpVertexAttribLFormat, (C.GLuint)(attribindex), (C.GLint)(size), (C.GLenum)(xtype), (C.GLuint)(relativeoffset)) +} +func VertexAttribLFormatNV(index uint32, size int32, xtype uint32, stride int32) { + C.glowVertexAttribLFormatNV(gpVertexAttribLFormatNV, (C.GLuint)(index), (C.GLint)(size), (C.GLenum)(xtype), (C.GLsizei)(stride)) +} +func VertexAttribLPointer(index uint32, size int32, xtype uint32, stride int32, pointer unsafe.Pointer) { + C.glowVertexAttribLPointer(gpVertexAttribLPointer, (C.GLuint)(index), (C.GLint)(size), (C.GLenum)(xtype), (C.GLsizei)(stride), pointer) +} +func VertexAttribLPointerWithOffset(index uint32, size int32, xtype uint32, stride int32, offset uintptr) { + C.glowVertexAttribLPointerWithOffset(gpVertexAttribLPointer, (C.GLuint)(index), (C.GLint)(size), (C.GLenum)(xtype), (C.GLsizei)(stride), (C.uintptr_t)(offset)) +} +func VertexAttribP1ui(index uint32, xtype uint32, normalized bool, value uint32) { + C.glowVertexAttribP1ui(gpVertexAttribP1ui, (C.GLuint)(index), (C.GLenum)(xtype), (C.GLboolean)(boolToInt(normalized)), (C.GLuint)(value)) +} +func VertexAttribP1uiv(index uint32, xtype uint32, normalized bool, value *uint32) { + C.glowVertexAttribP1uiv(gpVertexAttribP1uiv, (C.GLuint)(index), (C.GLenum)(xtype), (C.GLboolean)(boolToInt(normalized)), (*C.GLuint)(unsafe.Pointer(value))) +} +func VertexAttribP2ui(index uint32, xtype uint32, normalized bool, value uint32) { + C.glowVertexAttribP2ui(gpVertexAttribP2ui, (C.GLuint)(index), (C.GLenum)(xtype), (C.GLboolean)(boolToInt(normalized)), (C.GLuint)(value)) +} +func VertexAttribP2uiv(index uint32, xtype uint32, normalized bool, value *uint32) { + C.glowVertexAttribP2uiv(gpVertexAttribP2uiv, (C.GLuint)(index), (C.GLenum)(xtype), (C.GLboolean)(boolToInt(normalized)), (*C.GLuint)(unsafe.Pointer(value))) +} +func VertexAttribP3ui(index uint32, xtype uint32, normalized bool, value uint32) { + C.glowVertexAttribP3ui(gpVertexAttribP3ui, (C.GLuint)(index), (C.GLenum)(xtype), (C.GLboolean)(boolToInt(normalized)), (C.GLuint)(value)) +} +func VertexAttribP3uiv(index uint32, xtype uint32, normalized bool, value *uint32) { + C.glowVertexAttribP3uiv(gpVertexAttribP3uiv, (C.GLuint)(index), (C.GLenum)(xtype), (C.GLboolean)(boolToInt(normalized)), (*C.GLuint)(unsafe.Pointer(value))) +} +func VertexAttribP4ui(index uint32, xtype uint32, normalized bool, value uint32) { + C.glowVertexAttribP4ui(gpVertexAttribP4ui, (C.GLuint)(index), (C.GLenum)(xtype), (C.GLboolean)(boolToInt(normalized)), (C.GLuint)(value)) +} +func VertexAttribP4uiv(index uint32, xtype uint32, normalized bool, value *uint32) { + C.glowVertexAttribP4uiv(gpVertexAttribP4uiv, (C.GLuint)(index), (C.GLenum)(xtype), (C.GLboolean)(boolToInt(normalized)), (*C.GLuint)(unsafe.Pointer(value))) +} + +// define an array of generic vertex attribute data +func VertexAttribPointer(index uint32, size int32, xtype uint32, normalized bool, stride int32, pointer unsafe.Pointer) { + C.glowVertexAttribPointer(gpVertexAttribPointer, (C.GLuint)(index), (C.GLint)(size), (C.GLenum)(xtype), (C.GLboolean)(boolToInt(normalized)), (C.GLsizei)(stride), pointer) +} +func VertexAttribPointerWithOffset(index uint32, size int32, xtype uint32, normalized bool, stride int32, offset uintptr) { + C.glowVertexAttribPointerWithOffset(gpVertexAttribPointer, (C.GLuint)(index), (C.GLint)(size), (C.GLenum)(xtype), (C.GLboolean)(boolToInt(normalized)), (C.GLsizei)(stride), (C.uintptr_t)(offset)) +} + +// modify the rate at which generic vertex attributes advance +func VertexBindingDivisor(bindingindex uint32, divisor uint32) { + C.glowVertexBindingDivisor(gpVertexBindingDivisor, (C.GLuint)(bindingindex), (C.GLuint)(divisor)) +} +func VertexFormatNV(size int32, xtype uint32, stride int32) { + C.glowVertexFormatNV(gpVertexFormatNV, (C.GLint)(size), (C.GLenum)(xtype), (C.GLsizei)(stride)) +} + +// set the viewport +func Viewport(x int32, y int32, width int32, height int32) { + C.glowViewport(gpViewport, (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height)) +} +func ViewportArrayv(first uint32, count int32, v *float32) { + C.glowViewportArrayv(gpViewportArrayv, (C.GLuint)(first), (C.GLsizei)(count), (*C.GLfloat)(unsafe.Pointer(v))) +} +func ViewportIndexedf(index uint32, x float32, y float32, w float32, h float32) { + C.glowViewportIndexedf(gpViewportIndexedf, (C.GLuint)(index), (C.GLfloat)(x), (C.GLfloat)(y), (C.GLfloat)(w), (C.GLfloat)(h)) +} +func ViewportIndexedfv(index uint32, v *float32) { + C.glowViewportIndexedfv(gpViewportIndexedfv, (C.GLuint)(index), (*C.GLfloat)(unsafe.Pointer(v))) +} +func ViewportPositionWScaleNV(index uint32, xcoeff float32, ycoeff float32) { + C.glowViewportPositionWScaleNV(gpViewportPositionWScaleNV, (C.GLuint)(index), (C.GLfloat)(xcoeff), (C.GLfloat)(ycoeff)) +} +func ViewportSwizzleNV(index uint32, swizzlex uint32, swizzley uint32, swizzlez uint32, swizzlew uint32) { + C.glowViewportSwizzleNV(gpViewportSwizzleNV, (C.GLuint)(index), (C.GLenum)(swizzlex), (C.GLenum)(swizzley), (C.GLenum)(swizzlez), (C.GLenum)(swizzlew)) +} + +// instruct the GL server to block until the specified sync object becomes signaled +func WaitSync(sync uintptr, flags uint32, timeout uint64) { + C.glowWaitSync(gpWaitSync, (C.GLsync)(sync), (C.GLbitfield)(flags), (C.GLuint64)(timeout)) +} +func WaitVkSemaphoreNV(vkSemaphore uint64) { + C.glowWaitVkSemaphoreNV(gpWaitVkSemaphoreNV, (C.GLuint64)(vkSemaphore)) +} +func WeightPathsNV(resultPath uint32, numPaths int32, paths *uint32, weights *float32) { + C.glowWeightPathsNV(gpWeightPathsNV, (C.GLuint)(resultPath), (C.GLsizei)(numPaths), (*C.GLuint)(unsafe.Pointer(paths)), (*C.GLfloat)(unsafe.Pointer(weights))) +} +func WindowRectanglesEXT(mode uint32, count int32, box *int32) { + C.glowWindowRectanglesEXT(gpWindowRectanglesEXT, (C.GLenum)(mode), (C.GLsizei)(count), (*C.GLint)(unsafe.Pointer(box))) +} + +// Init initializes the OpenGL bindings by loading the function pointers (for +// each OpenGL function) from the active OpenGL context. +// +// It must be called under the presence of an active OpenGL context, e.g., +// always after calling window.MakeContextCurrent() and always before calling +// any OpenGL functions exported by this package. +// +// On Windows, Init loads pointers that are context-specific (and hence you +// must re-init if switching between OpenGL contexts, although not calling Init +// again after switching between OpenGL contexts may work if the contexts belong +// to the same graphics driver/device). +// +// On macOS and the other POSIX systems, the behavior is different, but code +// written compatible with the Windows behavior is compatible with macOS and the +// other POSIX systems. That is, always Init under an active OpenGL context, and +// always re-init after switching graphics contexts. +// +// For information about caveats of Init, you should read the "Platform Specific +// Function Retrieval" section of https://www.opengl.org/wiki/Load_OpenGL_Functions. +func Init() error { + return InitWithProcAddrFunc(getProcAddress) +} + +// InitWithProcAddrFunc intializes the package using the specified OpenGL +// function pointer loading function. For more cases Init should be used +// instead. +func InitWithProcAddrFunc(getProcAddr func(name string) unsafe.Pointer) error { + gpActiveProgramEXT = (C.GPACTIVEPROGRAMEXT)(getProcAddr("glActiveProgramEXT")) + gpActiveShaderProgram = (C.GPACTIVESHADERPROGRAM)(getProcAddr("glActiveShaderProgram")) + gpActiveShaderProgramEXT = (C.GPACTIVESHADERPROGRAMEXT)(getProcAddr("glActiveShaderProgramEXT")) + gpActiveTexture = (C.GPACTIVETEXTURE)(getProcAddr("glActiveTexture")) + if gpActiveTexture == nil { + return errors.New("glActiveTexture") + } + gpApplyFramebufferAttachmentCMAAINTEL = (C.GPAPPLYFRAMEBUFFERATTACHMENTCMAAINTEL)(getProcAddr("glApplyFramebufferAttachmentCMAAINTEL")) + gpAttachShader = (C.GPATTACHSHADER)(getProcAddr("glAttachShader")) + if gpAttachShader == nil { + return errors.New("glAttachShader") + } + gpBeginConditionalRender = (C.GPBEGINCONDITIONALRENDER)(getProcAddr("glBeginConditionalRender")) + if gpBeginConditionalRender == nil { + return errors.New("glBeginConditionalRender") + } + gpBeginConditionalRenderNV = (C.GPBEGINCONDITIONALRENDERNV)(getProcAddr("glBeginConditionalRenderNV")) + gpBeginPerfMonitorAMD = (C.GPBEGINPERFMONITORAMD)(getProcAddr("glBeginPerfMonitorAMD")) + gpBeginPerfQueryINTEL = (C.GPBEGINPERFQUERYINTEL)(getProcAddr("glBeginPerfQueryINTEL")) + gpBeginQuery = (C.GPBEGINQUERY)(getProcAddr("glBeginQuery")) + if gpBeginQuery == nil { + return errors.New("glBeginQuery") + } + gpBeginQueryIndexed = (C.GPBEGINQUERYINDEXED)(getProcAddr("glBeginQueryIndexed")) + gpBeginTransformFeedback = (C.GPBEGINTRANSFORMFEEDBACK)(getProcAddr("glBeginTransformFeedback")) + if gpBeginTransformFeedback == nil { + return errors.New("glBeginTransformFeedback") + } + gpBindAttribLocation = (C.GPBINDATTRIBLOCATION)(getProcAddr("glBindAttribLocation")) + if gpBindAttribLocation == nil { + return errors.New("glBindAttribLocation") + } + gpBindBuffer = (C.GPBINDBUFFER)(getProcAddr("glBindBuffer")) + if gpBindBuffer == nil { + return errors.New("glBindBuffer") + } + gpBindBufferBase = (C.GPBINDBUFFERBASE)(getProcAddr("glBindBufferBase")) + if gpBindBufferBase == nil { + return errors.New("glBindBufferBase") + } + gpBindBufferRange = (C.GPBINDBUFFERRANGE)(getProcAddr("glBindBufferRange")) + if gpBindBufferRange == nil { + return errors.New("glBindBufferRange") + } + gpBindBuffersBase = (C.GPBINDBUFFERSBASE)(getProcAddr("glBindBuffersBase")) + gpBindBuffersRange = (C.GPBINDBUFFERSRANGE)(getProcAddr("glBindBuffersRange")) + gpBindFragDataLocation = (C.GPBINDFRAGDATALOCATION)(getProcAddr("glBindFragDataLocation")) + if gpBindFragDataLocation == nil { + return errors.New("glBindFragDataLocation") + } + gpBindFragDataLocationIndexed = (C.GPBINDFRAGDATALOCATIONINDEXED)(getProcAddr("glBindFragDataLocationIndexed")) + if gpBindFragDataLocationIndexed == nil { + return errors.New("glBindFragDataLocationIndexed") + } + gpBindFramebuffer = (C.GPBINDFRAMEBUFFER)(getProcAddr("glBindFramebuffer")) + if gpBindFramebuffer == nil { + return errors.New("glBindFramebuffer") + } + gpBindImageTexture = (C.GPBINDIMAGETEXTURE)(getProcAddr("glBindImageTexture")) + gpBindImageTextures = (C.GPBINDIMAGETEXTURES)(getProcAddr("glBindImageTextures")) + gpBindMultiTextureEXT = (C.GPBINDMULTITEXTUREEXT)(getProcAddr("glBindMultiTextureEXT")) + gpBindProgramPipeline = (C.GPBINDPROGRAMPIPELINE)(getProcAddr("glBindProgramPipeline")) + gpBindProgramPipelineEXT = (C.GPBINDPROGRAMPIPELINEEXT)(getProcAddr("glBindProgramPipelineEXT")) + gpBindRenderbuffer = (C.GPBINDRENDERBUFFER)(getProcAddr("glBindRenderbuffer")) + if gpBindRenderbuffer == nil { + return errors.New("glBindRenderbuffer") + } + gpBindSampler = (C.GPBINDSAMPLER)(getProcAddr("glBindSampler")) + if gpBindSampler == nil { + return errors.New("glBindSampler") + } + gpBindSamplers = (C.GPBINDSAMPLERS)(getProcAddr("glBindSamplers")) + gpBindShadingRateImageNV = (C.GPBINDSHADINGRATEIMAGENV)(getProcAddr("glBindShadingRateImageNV")) + gpBindTexture = (C.GPBINDTEXTURE)(getProcAddr("glBindTexture")) + if gpBindTexture == nil { + return errors.New("glBindTexture") + } + gpBindTextureUnit = (C.GPBINDTEXTUREUNIT)(getProcAddr("glBindTextureUnit")) + gpBindTextures = (C.GPBINDTEXTURES)(getProcAddr("glBindTextures")) + gpBindTransformFeedback = (C.GPBINDTRANSFORMFEEDBACK)(getProcAddr("glBindTransformFeedback")) + gpBindVertexArray = (C.GPBINDVERTEXARRAY)(getProcAddr("glBindVertexArray")) + if gpBindVertexArray == nil { + return errors.New("glBindVertexArray") + } + gpBindVertexBuffer = (C.GPBINDVERTEXBUFFER)(getProcAddr("glBindVertexBuffer")) + gpBindVertexBuffers = (C.GPBINDVERTEXBUFFERS)(getProcAddr("glBindVertexBuffers")) + gpBlendBarrierKHR = (C.GPBLENDBARRIERKHR)(getProcAddr("glBlendBarrierKHR")) + gpBlendBarrierNV = (C.GPBLENDBARRIERNV)(getProcAddr("glBlendBarrierNV")) + gpBlendColor = (C.GPBLENDCOLOR)(getProcAddr("glBlendColor")) + if gpBlendColor == nil { + return errors.New("glBlendColor") + } + gpBlendEquation = (C.GPBLENDEQUATION)(getProcAddr("glBlendEquation")) + if gpBlendEquation == nil { + return errors.New("glBlendEquation") + } + gpBlendEquationSeparate = (C.GPBLENDEQUATIONSEPARATE)(getProcAddr("glBlendEquationSeparate")) + if gpBlendEquationSeparate == nil { + return errors.New("glBlendEquationSeparate") + } + gpBlendEquationSeparateiARB = (C.GPBLENDEQUATIONSEPARATEIARB)(getProcAddr("glBlendEquationSeparateiARB")) + gpBlendEquationiARB = (C.GPBLENDEQUATIONIARB)(getProcAddr("glBlendEquationiARB")) + gpBlendFunc = (C.GPBLENDFUNC)(getProcAddr("glBlendFunc")) + if gpBlendFunc == nil { + return errors.New("glBlendFunc") + } + gpBlendFuncSeparate = (C.GPBLENDFUNCSEPARATE)(getProcAddr("glBlendFuncSeparate")) + if gpBlendFuncSeparate == nil { + return errors.New("glBlendFuncSeparate") + } + gpBlendFuncSeparateiARB = (C.GPBLENDFUNCSEPARATEIARB)(getProcAddr("glBlendFuncSeparateiARB")) + gpBlendFunciARB = (C.GPBLENDFUNCIARB)(getProcAddr("glBlendFunciARB")) + gpBlendParameteriNV = (C.GPBLENDPARAMETERINV)(getProcAddr("glBlendParameteriNV")) + gpBlitFramebuffer = (C.GPBLITFRAMEBUFFER)(getProcAddr("glBlitFramebuffer")) + if gpBlitFramebuffer == nil { + return errors.New("glBlitFramebuffer") + } + gpBlitNamedFramebuffer = (C.GPBLITNAMEDFRAMEBUFFER)(getProcAddr("glBlitNamedFramebuffer")) + gpBufferAddressRangeNV = (C.GPBUFFERADDRESSRANGENV)(getProcAddr("glBufferAddressRangeNV")) + gpBufferAttachMemoryNV = (C.GPBUFFERATTACHMEMORYNV)(getProcAddr("glBufferAttachMemoryNV")) + gpBufferData = (C.GPBUFFERDATA)(getProcAddr("glBufferData")) + if gpBufferData == nil { + return errors.New("glBufferData") + } + gpBufferPageCommitmentARB = (C.GPBUFFERPAGECOMMITMENTARB)(getProcAddr("glBufferPageCommitmentARB")) + gpBufferPageCommitmentMemNV = (C.GPBUFFERPAGECOMMITMENTMEMNV)(getProcAddr("glBufferPageCommitmentMemNV")) + gpBufferStorage = (C.GPBUFFERSTORAGE)(getProcAddr("glBufferStorage")) + gpBufferSubData = (C.GPBUFFERSUBDATA)(getProcAddr("glBufferSubData")) + if gpBufferSubData == nil { + return errors.New("glBufferSubData") + } + gpCallCommandListNV = (C.GPCALLCOMMANDLISTNV)(getProcAddr("glCallCommandListNV")) + gpCheckFramebufferStatus = (C.GPCHECKFRAMEBUFFERSTATUS)(getProcAddr("glCheckFramebufferStatus")) + if gpCheckFramebufferStatus == nil { + return errors.New("glCheckFramebufferStatus") + } + gpCheckNamedFramebufferStatus = (C.GPCHECKNAMEDFRAMEBUFFERSTATUS)(getProcAddr("glCheckNamedFramebufferStatus")) + gpCheckNamedFramebufferStatusEXT = (C.GPCHECKNAMEDFRAMEBUFFERSTATUSEXT)(getProcAddr("glCheckNamedFramebufferStatusEXT")) + gpClampColor = (C.GPCLAMPCOLOR)(getProcAddr("glClampColor")) + if gpClampColor == nil { + return errors.New("glClampColor") + } + gpClear = (C.GPCLEAR)(getProcAddr("glClear")) + if gpClear == nil { + return errors.New("glClear") + } + gpClearBufferData = (C.GPCLEARBUFFERDATA)(getProcAddr("glClearBufferData")) + gpClearBufferSubData = (C.GPCLEARBUFFERSUBDATA)(getProcAddr("glClearBufferSubData")) + gpClearBufferfi = (C.GPCLEARBUFFERFI)(getProcAddr("glClearBufferfi")) + if gpClearBufferfi == nil { + return errors.New("glClearBufferfi") + } + gpClearBufferfv = (C.GPCLEARBUFFERFV)(getProcAddr("glClearBufferfv")) + if gpClearBufferfv == nil { + return errors.New("glClearBufferfv") + } + gpClearBufferiv = (C.GPCLEARBUFFERIV)(getProcAddr("glClearBufferiv")) + if gpClearBufferiv == nil { + return errors.New("glClearBufferiv") + } + gpClearBufferuiv = (C.GPCLEARBUFFERUIV)(getProcAddr("glClearBufferuiv")) + if gpClearBufferuiv == nil { + return errors.New("glClearBufferuiv") + } + gpClearColor = (C.GPCLEARCOLOR)(getProcAddr("glClearColor")) + if gpClearColor == nil { + return errors.New("glClearColor") + } + gpClearDepth = (C.GPCLEARDEPTH)(getProcAddr("glClearDepth")) + if gpClearDepth == nil { + return errors.New("glClearDepth") + } + gpClearDepthdNV = (C.GPCLEARDEPTHDNV)(getProcAddr("glClearDepthdNV")) + gpClearDepthf = (C.GPCLEARDEPTHF)(getProcAddr("glClearDepthf")) + gpClearNamedBufferData = (C.GPCLEARNAMEDBUFFERDATA)(getProcAddr("glClearNamedBufferData")) + gpClearNamedBufferDataEXT = (C.GPCLEARNAMEDBUFFERDATAEXT)(getProcAddr("glClearNamedBufferDataEXT")) + gpClearNamedBufferSubData = (C.GPCLEARNAMEDBUFFERSUBDATA)(getProcAddr("glClearNamedBufferSubData")) + gpClearNamedBufferSubDataEXT = (C.GPCLEARNAMEDBUFFERSUBDATAEXT)(getProcAddr("glClearNamedBufferSubDataEXT")) + gpClearNamedFramebufferfi = (C.GPCLEARNAMEDFRAMEBUFFERFI)(getProcAddr("glClearNamedFramebufferfi")) + gpClearNamedFramebufferfv = (C.GPCLEARNAMEDFRAMEBUFFERFV)(getProcAddr("glClearNamedFramebufferfv")) + gpClearNamedFramebufferiv = (C.GPCLEARNAMEDFRAMEBUFFERIV)(getProcAddr("glClearNamedFramebufferiv")) + gpClearNamedFramebufferuiv = (C.GPCLEARNAMEDFRAMEBUFFERUIV)(getProcAddr("glClearNamedFramebufferuiv")) + gpClearStencil = (C.GPCLEARSTENCIL)(getProcAddr("glClearStencil")) + if gpClearStencil == nil { + return errors.New("glClearStencil") + } + gpClearTexImage = (C.GPCLEARTEXIMAGE)(getProcAddr("glClearTexImage")) + gpClearTexSubImage = (C.GPCLEARTEXSUBIMAGE)(getProcAddr("glClearTexSubImage")) + gpClientAttribDefaultEXT = (C.GPCLIENTATTRIBDEFAULTEXT)(getProcAddr("glClientAttribDefaultEXT")) + gpClientWaitSync = (C.GPCLIENTWAITSYNC)(getProcAddr("glClientWaitSync")) + if gpClientWaitSync == nil { + return errors.New("glClientWaitSync") + } + gpClipControl = (C.GPCLIPCONTROL)(getProcAddr("glClipControl")) + gpColorFormatNV = (C.GPCOLORFORMATNV)(getProcAddr("glColorFormatNV")) + gpColorMask = (C.GPCOLORMASK)(getProcAddr("glColorMask")) + if gpColorMask == nil { + return errors.New("glColorMask") + } + gpColorMaski = (C.GPCOLORMASKI)(getProcAddr("glColorMaski")) + if gpColorMaski == nil { + return errors.New("glColorMaski") + } + gpCommandListSegmentsNV = (C.GPCOMMANDLISTSEGMENTSNV)(getProcAddr("glCommandListSegmentsNV")) + gpCompileCommandListNV = (C.GPCOMPILECOMMANDLISTNV)(getProcAddr("glCompileCommandListNV")) + gpCompileShader = (C.GPCOMPILESHADER)(getProcAddr("glCompileShader")) + if gpCompileShader == nil { + return errors.New("glCompileShader") + } + gpCompileShaderIncludeARB = (C.GPCOMPILESHADERINCLUDEARB)(getProcAddr("glCompileShaderIncludeARB")) + gpCompressedMultiTexImage1DEXT = (C.GPCOMPRESSEDMULTITEXIMAGE1DEXT)(getProcAddr("glCompressedMultiTexImage1DEXT")) + gpCompressedMultiTexImage2DEXT = (C.GPCOMPRESSEDMULTITEXIMAGE2DEXT)(getProcAddr("glCompressedMultiTexImage2DEXT")) + gpCompressedMultiTexImage3DEXT = (C.GPCOMPRESSEDMULTITEXIMAGE3DEXT)(getProcAddr("glCompressedMultiTexImage3DEXT")) + gpCompressedMultiTexSubImage1DEXT = (C.GPCOMPRESSEDMULTITEXSUBIMAGE1DEXT)(getProcAddr("glCompressedMultiTexSubImage1DEXT")) + gpCompressedMultiTexSubImage2DEXT = (C.GPCOMPRESSEDMULTITEXSUBIMAGE2DEXT)(getProcAddr("glCompressedMultiTexSubImage2DEXT")) + gpCompressedMultiTexSubImage3DEXT = (C.GPCOMPRESSEDMULTITEXSUBIMAGE3DEXT)(getProcAddr("glCompressedMultiTexSubImage3DEXT")) + gpCompressedTexImage1D = (C.GPCOMPRESSEDTEXIMAGE1D)(getProcAddr("glCompressedTexImage1D")) + if gpCompressedTexImage1D == nil { + return errors.New("glCompressedTexImage1D") + } + gpCompressedTexImage2D = (C.GPCOMPRESSEDTEXIMAGE2D)(getProcAddr("glCompressedTexImage2D")) + if gpCompressedTexImage2D == nil { + return errors.New("glCompressedTexImage2D") + } + gpCompressedTexImage3D = (C.GPCOMPRESSEDTEXIMAGE3D)(getProcAddr("glCompressedTexImage3D")) + if gpCompressedTexImage3D == nil { + return errors.New("glCompressedTexImage3D") + } + gpCompressedTexSubImage1D = (C.GPCOMPRESSEDTEXSUBIMAGE1D)(getProcAddr("glCompressedTexSubImage1D")) + if gpCompressedTexSubImage1D == nil { + return errors.New("glCompressedTexSubImage1D") + } + gpCompressedTexSubImage2D = (C.GPCOMPRESSEDTEXSUBIMAGE2D)(getProcAddr("glCompressedTexSubImage2D")) + if gpCompressedTexSubImage2D == nil { + return errors.New("glCompressedTexSubImage2D") + } + gpCompressedTexSubImage3D = (C.GPCOMPRESSEDTEXSUBIMAGE3D)(getProcAddr("glCompressedTexSubImage3D")) + if gpCompressedTexSubImage3D == nil { + return errors.New("glCompressedTexSubImage3D") + } + gpCompressedTextureImage1DEXT = (C.GPCOMPRESSEDTEXTUREIMAGE1DEXT)(getProcAddr("glCompressedTextureImage1DEXT")) + gpCompressedTextureImage2DEXT = (C.GPCOMPRESSEDTEXTUREIMAGE2DEXT)(getProcAddr("glCompressedTextureImage2DEXT")) + gpCompressedTextureImage3DEXT = (C.GPCOMPRESSEDTEXTUREIMAGE3DEXT)(getProcAddr("glCompressedTextureImage3DEXT")) + gpCompressedTextureSubImage1D = (C.GPCOMPRESSEDTEXTURESUBIMAGE1D)(getProcAddr("glCompressedTextureSubImage1D")) + gpCompressedTextureSubImage1DEXT = (C.GPCOMPRESSEDTEXTURESUBIMAGE1DEXT)(getProcAddr("glCompressedTextureSubImage1DEXT")) + gpCompressedTextureSubImage2D = (C.GPCOMPRESSEDTEXTURESUBIMAGE2D)(getProcAddr("glCompressedTextureSubImage2D")) + gpCompressedTextureSubImage2DEXT = (C.GPCOMPRESSEDTEXTURESUBIMAGE2DEXT)(getProcAddr("glCompressedTextureSubImage2DEXT")) + gpCompressedTextureSubImage3D = (C.GPCOMPRESSEDTEXTURESUBIMAGE3D)(getProcAddr("glCompressedTextureSubImage3D")) + gpCompressedTextureSubImage3DEXT = (C.GPCOMPRESSEDTEXTURESUBIMAGE3DEXT)(getProcAddr("glCompressedTextureSubImage3DEXT")) + gpConservativeRasterParameterfNV = (C.GPCONSERVATIVERASTERPARAMETERFNV)(getProcAddr("glConservativeRasterParameterfNV")) + gpConservativeRasterParameteriNV = (C.GPCONSERVATIVERASTERPARAMETERINV)(getProcAddr("glConservativeRasterParameteriNV")) + gpCopyBufferSubData = (C.GPCOPYBUFFERSUBDATA)(getProcAddr("glCopyBufferSubData")) + if gpCopyBufferSubData == nil { + return errors.New("glCopyBufferSubData") + } + gpCopyImageSubData = (C.GPCOPYIMAGESUBDATA)(getProcAddr("glCopyImageSubData")) + gpCopyMultiTexImage1DEXT = (C.GPCOPYMULTITEXIMAGE1DEXT)(getProcAddr("glCopyMultiTexImage1DEXT")) + gpCopyMultiTexImage2DEXT = (C.GPCOPYMULTITEXIMAGE2DEXT)(getProcAddr("glCopyMultiTexImage2DEXT")) + gpCopyMultiTexSubImage1DEXT = (C.GPCOPYMULTITEXSUBIMAGE1DEXT)(getProcAddr("glCopyMultiTexSubImage1DEXT")) + gpCopyMultiTexSubImage2DEXT = (C.GPCOPYMULTITEXSUBIMAGE2DEXT)(getProcAddr("glCopyMultiTexSubImage2DEXT")) + gpCopyMultiTexSubImage3DEXT = (C.GPCOPYMULTITEXSUBIMAGE3DEXT)(getProcAddr("glCopyMultiTexSubImage3DEXT")) + gpCopyNamedBufferSubData = (C.GPCOPYNAMEDBUFFERSUBDATA)(getProcAddr("glCopyNamedBufferSubData")) + gpCopyPathNV = (C.GPCOPYPATHNV)(getProcAddr("glCopyPathNV")) + gpCopyTexImage1D = (C.GPCOPYTEXIMAGE1D)(getProcAddr("glCopyTexImage1D")) + if gpCopyTexImage1D == nil { + return errors.New("glCopyTexImage1D") + } + gpCopyTexImage2D = (C.GPCOPYTEXIMAGE2D)(getProcAddr("glCopyTexImage2D")) + if gpCopyTexImage2D == nil { + return errors.New("glCopyTexImage2D") + } + gpCopyTexSubImage1D = (C.GPCOPYTEXSUBIMAGE1D)(getProcAddr("glCopyTexSubImage1D")) + if gpCopyTexSubImage1D == nil { + return errors.New("glCopyTexSubImage1D") + } + gpCopyTexSubImage2D = (C.GPCOPYTEXSUBIMAGE2D)(getProcAddr("glCopyTexSubImage2D")) + if gpCopyTexSubImage2D == nil { + return errors.New("glCopyTexSubImage2D") + } + gpCopyTexSubImage3D = (C.GPCOPYTEXSUBIMAGE3D)(getProcAddr("glCopyTexSubImage3D")) + if gpCopyTexSubImage3D == nil { + return errors.New("glCopyTexSubImage3D") + } + gpCopyTextureImage1DEXT = (C.GPCOPYTEXTUREIMAGE1DEXT)(getProcAddr("glCopyTextureImage1DEXT")) + gpCopyTextureImage2DEXT = (C.GPCOPYTEXTUREIMAGE2DEXT)(getProcAddr("glCopyTextureImage2DEXT")) + gpCopyTextureSubImage1D = (C.GPCOPYTEXTURESUBIMAGE1D)(getProcAddr("glCopyTextureSubImage1D")) + gpCopyTextureSubImage1DEXT = (C.GPCOPYTEXTURESUBIMAGE1DEXT)(getProcAddr("glCopyTextureSubImage1DEXT")) + gpCopyTextureSubImage2D = (C.GPCOPYTEXTURESUBIMAGE2D)(getProcAddr("glCopyTextureSubImage2D")) + gpCopyTextureSubImage2DEXT = (C.GPCOPYTEXTURESUBIMAGE2DEXT)(getProcAddr("glCopyTextureSubImage2DEXT")) + gpCopyTextureSubImage3D = (C.GPCOPYTEXTURESUBIMAGE3D)(getProcAddr("glCopyTextureSubImage3D")) + gpCopyTextureSubImage3DEXT = (C.GPCOPYTEXTURESUBIMAGE3DEXT)(getProcAddr("glCopyTextureSubImage3DEXT")) + gpCoverFillPathInstancedNV = (C.GPCOVERFILLPATHINSTANCEDNV)(getProcAddr("glCoverFillPathInstancedNV")) + gpCoverFillPathNV = (C.GPCOVERFILLPATHNV)(getProcAddr("glCoverFillPathNV")) + gpCoverStrokePathInstancedNV = (C.GPCOVERSTROKEPATHINSTANCEDNV)(getProcAddr("glCoverStrokePathInstancedNV")) + gpCoverStrokePathNV = (C.GPCOVERSTROKEPATHNV)(getProcAddr("glCoverStrokePathNV")) + gpCoverageModulationNV = (C.GPCOVERAGEMODULATIONNV)(getProcAddr("glCoverageModulationNV")) + gpCoverageModulationTableNV = (C.GPCOVERAGEMODULATIONTABLENV)(getProcAddr("glCoverageModulationTableNV")) + gpCreateBuffers = (C.GPCREATEBUFFERS)(getProcAddr("glCreateBuffers")) + gpCreateCommandListsNV = (C.GPCREATECOMMANDLISTSNV)(getProcAddr("glCreateCommandListsNV")) + gpCreateFramebuffers = (C.GPCREATEFRAMEBUFFERS)(getProcAddr("glCreateFramebuffers")) + gpCreatePerfQueryINTEL = (C.GPCREATEPERFQUERYINTEL)(getProcAddr("glCreatePerfQueryINTEL")) + gpCreateProgram = (C.GPCREATEPROGRAM)(getProcAddr("glCreateProgram")) + if gpCreateProgram == nil { + return errors.New("glCreateProgram") + } + gpCreateProgramPipelines = (C.GPCREATEPROGRAMPIPELINES)(getProcAddr("glCreateProgramPipelines")) + gpCreateQueries = (C.GPCREATEQUERIES)(getProcAddr("glCreateQueries")) + gpCreateRenderbuffers = (C.GPCREATERENDERBUFFERS)(getProcAddr("glCreateRenderbuffers")) + gpCreateSamplers = (C.GPCREATESAMPLERS)(getProcAddr("glCreateSamplers")) + gpCreateShader = (C.GPCREATESHADER)(getProcAddr("glCreateShader")) + if gpCreateShader == nil { + return errors.New("glCreateShader") + } + gpCreateShaderProgramEXT = (C.GPCREATESHADERPROGRAMEXT)(getProcAddr("glCreateShaderProgramEXT")) + gpCreateShaderProgramv = (C.GPCREATESHADERPROGRAMV)(getProcAddr("glCreateShaderProgramv")) + gpCreateShaderProgramvEXT = (C.GPCREATESHADERPROGRAMVEXT)(getProcAddr("glCreateShaderProgramvEXT")) + gpCreateStatesNV = (C.GPCREATESTATESNV)(getProcAddr("glCreateStatesNV")) + gpCreateSyncFromCLeventARB = (C.GPCREATESYNCFROMCLEVENTARB)(getProcAddr("glCreateSyncFromCLeventARB")) + gpCreateTextures = (C.GPCREATETEXTURES)(getProcAddr("glCreateTextures")) + gpCreateTransformFeedbacks = (C.GPCREATETRANSFORMFEEDBACKS)(getProcAddr("glCreateTransformFeedbacks")) + gpCreateVertexArrays = (C.GPCREATEVERTEXARRAYS)(getProcAddr("glCreateVertexArrays")) + gpCullFace = (C.GPCULLFACE)(getProcAddr("glCullFace")) + if gpCullFace == nil { + return errors.New("glCullFace") + } + gpDebugMessageCallback = (C.GPDEBUGMESSAGECALLBACK)(getProcAddr("glDebugMessageCallback")) + gpDebugMessageCallbackARB = (C.GPDEBUGMESSAGECALLBACKARB)(getProcAddr("glDebugMessageCallbackARB")) + gpDebugMessageCallbackKHR = (C.GPDEBUGMESSAGECALLBACKKHR)(getProcAddr("glDebugMessageCallbackKHR")) + gpDebugMessageControl = (C.GPDEBUGMESSAGECONTROL)(getProcAddr("glDebugMessageControl")) + gpDebugMessageControlARB = (C.GPDEBUGMESSAGECONTROLARB)(getProcAddr("glDebugMessageControlARB")) + gpDebugMessageControlKHR = (C.GPDEBUGMESSAGECONTROLKHR)(getProcAddr("glDebugMessageControlKHR")) + gpDebugMessageInsert = (C.GPDEBUGMESSAGEINSERT)(getProcAddr("glDebugMessageInsert")) + gpDebugMessageInsertARB = (C.GPDEBUGMESSAGEINSERTARB)(getProcAddr("glDebugMessageInsertARB")) + gpDebugMessageInsertKHR = (C.GPDEBUGMESSAGEINSERTKHR)(getProcAddr("glDebugMessageInsertKHR")) + gpDeleteBuffers = (C.GPDELETEBUFFERS)(getProcAddr("glDeleteBuffers")) + if gpDeleteBuffers == nil { + return errors.New("glDeleteBuffers") + } + gpDeleteCommandListsNV = (C.GPDELETECOMMANDLISTSNV)(getProcAddr("glDeleteCommandListsNV")) + gpDeleteFramebuffers = (C.GPDELETEFRAMEBUFFERS)(getProcAddr("glDeleteFramebuffers")) + if gpDeleteFramebuffers == nil { + return errors.New("glDeleteFramebuffers") + } + gpDeleteNamedStringARB = (C.GPDELETENAMEDSTRINGARB)(getProcAddr("glDeleteNamedStringARB")) + gpDeletePathsNV = (C.GPDELETEPATHSNV)(getProcAddr("glDeletePathsNV")) + gpDeletePerfMonitorsAMD = (C.GPDELETEPERFMONITORSAMD)(getProcAddr("glDeletePerfMonitorsAMD")) + gpDeletePerfQueryINTEL = (C.GPDELETEPERFQUERYINTEL)(getProcAddr("glDeletePerfQueryINTEL")) + gpDeleteProgram = (C.GPDELETEPROGRAM)(getProcAddr("glDeleteProgram")) + if gpDeleteProgram == nil { + return errors.New("glDeleteProgram") + } + gpDeleteProgramPipelines = (C.GPDELETEPROGRAMPIPELINES)(getProcAddr("glDeleteProgramPipelines")) + gpDeleteProgramPipelinesEXT = (C.GPDELETEPROGRAMPIPELINESEXT)(getProcAddr("glDeleteProgramPipelinesEXT")) + gpDeleteQueries = (C.GPDELETEQUERIES)(getProcAddr("glDeleteQueries")) + if gpDeleteQueries == nil { + return errors.New("glDeleteQueries") + } + gpDeleteRenderbuffers = (C.GPDELETERENDERBUFFERS)(getProcAddr("glDeleteRenderbuffers")) + if gpDeleteRenderbuffers == nil { + return errors.New("glDeleteRenderbuffers") + } + gpDeleteSamplers = (C.GPDELETESAMPLERS)(getProcAddr("glDeleteSamplers")) + if gpDeleteSamplers == nil { + return errors.New("glDeleteSamplers") + } + gpDeleteShader = (C.GPDELETESHADER)(getProcAddr("glDeleteShader")) + if gpDeleteShader == nil { + return errors.New("glDeleteShader") + } + gpDeleteStatesNV = (C.GPDELETESTATESNV)(getProcAddr("glDeleteStatesNV")) + gpDeleteSync = (C.GPDELETESYNC)(getProcAddr("glDeleteSync")) + if gpDeleteSync == nil { + return errors.New("glDeleteSync") + } + gpDeleteTextures = (C.GPDELETETEXTURES)(getProcAddr("glDeleteTextures")) + if gpDeleteTextures == nil { + return errors.New("glDeleteTextures") + } + gpDeleteTransformFeedbacks = (C.GPDELETETRANSFORMFEEDBACKS)(getProcAddr("glDeleteTransformFeedbacks")) + gpDeleteVertexArrays = (C.GPDELETEVERTEXARRAYS)(getProcAddr("glDeleteVertexArrays")) + if gpDeleteVertexArrays == nil { + return errors.New("glDeleteVertexArrays") + } + gpDepthBoundsdNV = (C.GPDEPTHBOUNDSDNV)(getProcAddr("glDepthBoundsdNV")) + gpDepthFunc = (C.GPDEPTHFUNC)(getProcAddr("glDepthFunc")) + if gpDepthFunc == nil { + return errors.New("glDepthFunc") + } + gpDepthMask = (C.GPDEPTHMASK)(getProcAddr("glDepthMask")) + if gpDepthMask == nil { + return errors.New("glDepthMask") + } + gpDepthRange = (C.GPDEPTHRANGE)(getProcAddr("glDepthRange")) + if gpDepthRange == nil { + return errors.New("glDepthRange") + } + gpDepthRangeArraydvNV = (C.GPDEPTHRANGEARRAYDVNV)(getProcAddr("glDepthRangeArraydvNV")) + gpDepthRangeArrayv = (C.GPDEPTHRANGEARRAYV)(getProcAddr("glDepthRangeArrayv")) + gpDepthRangeIndexed = (C.GPDEPTHRANGEINDEXED)(getProcAddr("glDepthRangeIndexed")) + gpDepthRangeIndexeddNV = (C.GPDEPTHRANGEINDEXEDDNV)(getProcAddr("glDepthRangeIndexeddNV")) + gpDepthRangedNV = (C.GPDEPTHRANGEDNV)(getProcAddr("glDepthRangedNV")) + gpDepthRangef = (C.GPDEPTHRANGEF)(getProcAddr("glDepthRangef")) + gpDetachShader = (C.GPDETACHSHADER)(getProcAddr("glDetachShader")) + if gpDetachShader == nil { + return errors.New("glDetachShader") + } + gpDisable = (C.GPDISABLE)(getProcAddr("glDisable")) + if gpDisable == nil { + return errors.New("glDisable") + } + gpDisableClientStateIndexedEXT = (C.GPDISABLECLIENTSTATEINDEXEDEXT)(getProcAddr("glDisableClientStateIndexedEXT")) + gpDisableClientStateiEXT = (C.GPDISABLECLIENTSTATEIEXT)(getProcAddr("glDisableClientStateiEXT")) + gpDisableIndexedEXT = (C.GPDISABLEINDEXEDEXT)(getProcAddr("glDisableIndexedEXT")) + gpDisableVertexArrayAttrib = (C.GPDISABLEVERTEXARRAYATTRIB)(getProcAddr("glDisableVertexArrayAttrib")) + gpDisableVertexArrayAttribEXT = (C.GPDISABLEVERTEXARRAYATTRIBEXT)(getProcAddr("glDisableVertexArrayAttribEXT")) + gpDisableVertexArrayEXT = (C.GPDISABLEVERTEXARRAYEXT)(getProcAddr("glDisableVertexArrayEXT")) + gpDisableVertexAttribArray = (C.GPDISABLEVERTEXATTRIBARRAY)(getProcAddr("glDisableVertexAttribArray")) + if gpDisableVertexAttribArray == nil { + return errors.New("glDisableVertexAttribArray") + } + gpDisablei = (C.GPDISABLEI)(getProcAddr("glDisablei")) + if gpDisablei == nil { + return errors.New("glDisablei") + } + gpDispatchCompute = (C.GPDISPATCHCOMPUTE)(getProcAddr("glDispatchCompute")) + gpDispatchComputeGroupSizeARB = (C.GPDISPATCHCOMPUTEGROUPSIZEARB)(getProcAddr("glDispatchComputeGroupSizeARB")) + gpDispatchComputeIndirect = (C.GPDISPATCHCOMPUTEINDIRECT)(getProcAddr("glDispatchComputeIndirect")) + gpDrawArrays = (C.GPDRAWARRAYS)(getProcAddr("glDrawArrays")) + if gpDrawArrays == nil { + return errors.New("glDrawArrays") + } + gpDrawArraysIndirect = (C.GPDRAWARRAYSINDIRECT)(getProcAddr("glDrawArraysIndirect")) + gpDrawArraysInstanced = (C.GPDRAWARRAYSINSTANCED)(getProcAddr("glDrawArraysInstanced")) + if gpDrawArraysInstanced == nil { + return errors.New("glDrawArraysInstanced") + } + gpDrawArraysInstancedARB = (C.GPDRAWARRAYSINSTANCEDARB)(getProcAddr("glDrawArraysInstancedARB")) + gpDrawArraysInstancedBaseInstance = (C.GPDRAWARRAYSINSTANCEDBASEINSTANCE)(getProcAddr("glDrawArraysInstancedBaseInstance")) + gpDrawArraysInstancedEXT = (C.GPDRAWARRAYSINSTANCEDEXT)(getProcAddr("glDrawArraysInstancedEXT")) + gpDrawBuffer = (C.GPDRAWBUFFER)(getProcAddr("glDrawBuffer")) + if gpDrawBuffer == nil { + return errors.New("glDrawBuffer") + } + gpDrawBuffers = (C.GPDRAWBUFFERS)(getProcAddr("glDrawBuffers")) + if gpDrawBuffers == nil { + return errors.New("glDrawBuffers") + } + gpDrawCommandsAddressNV = (C.GPDRAWCOMMANDSADDRESSNV)(getProcAddr("glDrawCommandsAddressNV")) + gpDrawCommandsNV = (C.GPDRAWCOMMANDSNV)(getProcAddr("glDrawCommandsNV")) + gpDrawCommandsStatesAddressNV = (C.GPDRAWCOMMANDSSTATESADDRESSNV)(getProcAddr("glDrawCommandsStatesAddressNV")) + gpDrawCommandsStatesNV = (C.GPDRAWCOMMANDSSTATESNV)(getProcAddr("glDrawCommandsStatesNV")) + gpDrawElements = (C.GPDRAWELEMENTS)(getProcAddr("glDrawElements")) + if gpDrawElements == nil { + return errors.New("glDrawElements") + } + gpDrawElementsBaseVertex = (C.GPDRAWELEMENTSBASEVERTEX)(getProcAddr("glDrawElementsBaseVertex")) + if gpDrawElementsBaseVertex == nil { + return errors.New("glDrawElementsBaseVertex") + } + gpDrawElementsIndirect = (C.GPDRAWELEMENTSINDIRECT)(getProcAddr("glDrawElementsIndirect")) + gpDrawElementsInstanced = (C.GPDRAWELEMENTSINSTANCED)(getProcAddr("glDrawElementsInstanced")) + if gpDrawElementsInstanced == nil { + return errors.New("glDrawElementsInstanced") + } + gpDrawElementsInstancedARB = (C.GPDRAWELEMENTSINSTANCEDARB)(getProcAddr("glDrawElementsInstancedARB")) + gpDrawElementsInstancedBaseInstance = (C.GPDRAWELEMENTSINSTANCEDBASEINSTANCE)(getProcAddr("glDrawElementsInstancedBaseInstance")) + gpDrawElementsInstancedBaseVertex = (C.GPDRAWELEMENTSINSTANCEDBASEVERTEX)(getProcAddr("glDrawElementsInstancedBaseVertex")) + if gpDrawElementsInstancedBaseVertex == nil { + return errors.New("glDrawElementsInstancedBaseVertex") + } + gpDrawElementsInstancedBaseVertexBaseInstance = (C.GPDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCE)(getProcAddr("glDrawElementsInstancedBaseVertexBaseInstance")) + gpDrawElementsInstancedEXT = (C.GPDRAWELEMENTSINSTANCEDEXT)(getProcAddr("glDrawElementsInstancedEXT")) + gpDrawMeshTasksIndirectNV = (C.GPDRAWMESHTASKSINDIRECTNV)(getProcAddr("glDrawMeshTasksIndirectNV")) + gpDrawMeshTasksNV = (C.GPDRAWMESHTASKSNV)(getProcAddr("glDrawMeshTasksNV")) + gpDrawRangeElements = (C.GPDRAWRANGEELEMENTS)(getProcAddr("glDrawRangeElements")) + if gpDrawRangeElements == nil { + return errors.New("glDrawRangeElements") + } + gpDrawRangeElementsBaseVertex = (C.GPDRAWRANGEELEMENTSBASEVERTEX)(getProcAddr("glDrawRangeElementsBaseVertex")) + if gpDrawRangeElementsBaseVertex == nil { + return errors.New("glDrawRangeElementsBaseVertex") + } + gpDrawTransformFeedback = (C.GPDRAWTRANSFORMFEEDBACK)(getProcAddr("glDrawTransformFeedback")) + gpDrawTransformFeedbackInstanced = (C.GPDRAWTRANSFORMFEEDBACKINSTANCED)(getProcAddr("glDrawTransformFeedbackInstanced")) + gpDrawTransformFeedbackStream = (C.GPDRAWTRANSFORMFEEDBACKSTREAM)(getProcAddr("glDrawTransformFeedbackStream")) + gpDrawTransformFeedbackStreamInstanced = (C.GPDRAWTRANSFORMFEEDBACKSTREAMINSTANCED)(getProcAddr("glDrawTransformFeedbackStreamInstanced")) + gpDrawVkImageNV = (C.GPDRAWVKIMAGENV)(getProcAddr("glDrawVkImageNV")) + gpEGLImageTargetTexStorageEXT = (C.GPEGLIMAGETARGETTEXSTORAGEEXT)(getProcAddr("glEGLImageTargetTexStorageEXT")) + gpEGLImageTargetTextureStorageEXT = (C.GPEGLIMAGETARGETTEXTURESTORAGEEXT)(getProcAddr("glEGLImageTargetTextureStorageEXT")) + gpEdgeFlagFormatNV = (C.GPEDGEFLAGFORMATNV)(getProcAddr("glEdgeFlagFormatNV")) + gpEnable = (C.GPENABLE)(getProcAddr("glEnable")) + if gpEnable == nil { + return errors.New("glEnable") + } + gpEnableClientStateIndexedEXT = (C.GPENABLECLIENTSTATEINDEXEDEXT)(getProcAddr("glEnableClientStateIndexedEXT")) + gpEnableClientStateiEXT = (C.GPENABLECLIENTSTATEIEXT)(getProcAddr("glEnableClientStateiEXT")) + gpEnableIndexedEXT = (C.GPENABLEINDEXEDEXT)(getProcAddr("glEnableIndexedEXT")) + gpEnableVertexArrayAttrib = (C.GPENABLEVERTEXARRAYATTRIB)(getProcAddr("glEnableVertexArrayAttrib")) + gpEnableVertexArrayAttribEXT = (C.GPENABLEVERTEXARRAYATTRIBEXT)(getProcAddr("glEnableVertexArrayAttribEXT")) + gpEnableVertexArrayEXT = (C.GPENABLEVERTEXARRAYEXT)(getProcAddr("glEnableVertexArrayEXT")) + gpEnableVertexAttribArray = (C.GPENABLEVERTEXATTRIBARRAY)(getProcAddr("glEnableVertexAttribArray")) + if gpEnableVertexAttribArray == nil { + return errors.New("glEnableVertexAttribArray") + } + gpEnablei = (C.GPENABLEI)(getProcAddr("glEnablei")) + if gpEnablei == nil { + return errors.New("glEnablei") + } + gpEndConditionalRender = (C.GPENDCONDITIONALRENDER)(getProcAddr("glEndConditionalRender")) + if gpEndConditionalRender == nil { + return errors.New("glEndConditionalRender") + } + gpEndConditionalRenderNV = (C.GPENDCONDITIONALRENDERNV)(getProcAddr("glEndConditionalRenderNV")) + gpEndPerfMonitorAMD = (C.GPENDPERFMONITORAMD)(getProcAddr("glEndPerfMonitorAMD")) + gpEndPerfQueryINTEL = (C.GPENDPERFQUERYINTEL)(getProcAddr("glEndPerfQueryINTEL")) + gpEndQuery = (C.GPENDQUERY)(getProcAddr("glEndQuery")) + if gpEndQuery == nil { + return errors.New("glEndQuery") + } + gpEndQueryIndexed = (C.GPENDQUERYINDEXED)(getProcAddr("glEndQueryIndexed")) + gpEndTransformFeedback = (C.GPENDTRANSFORMFEEDBACK)(getProcAddr("glEndTransformFeedback")) + if gpEndTransformFeedback == nil { + return errors.New("glEndTransformFeedback") + } + gpEvaluateDepthValuesARB = (C.GPEVALUATEDEPTHVALUESARB)(getProcAddr("glEvaluateDepthValuesARB")) + gpFenceSync = (C.GPFENCESYNC)(getProcAddr("glFenceSync")) + if gpFenceSync == nil { + return errors.New("glFenceSync") + } + gpFinish = (C.GPFINISH)(getProcAddr("glFinish")) + if gpFinish == nil { + return errors.New("glFinish") + } + gpFlush = (C.GPFLUSH)(getProcAddr("glFlush")) + if gpFlush == nil { + return errors.New("glFlush") + } + gpFlushMappedBufferRange = (C.GPFLUSHMAPPEDBUFFERRANGE)(getProcAddr("glFlushMappedBufferRange")) + if gpFlushMappedBufferRange == nil { + return errors.New("glFlushMappedBufferRange") + } + gpFlushMappedNamedBufferRange = (C.GPFLUSHMAPPEDNAMEDBUFFERRANGE)(getProcAddr("glFlushMappedNamedBufferRange")) + gpFlushMappedNamedBufferRangeEXT = (C.GPFLUSHMAPPEDNAMEDBUFFERRANGEEXT)(getProcAddr("glFlushMappedNamedBufferRangeEXT")) + gpFogCoordFormatNV = (C.GPFOGCOORDFORMATNV)(getProcAddr("glFogCoordFormatNV")) + gpFragmentCoverageColorNV = (C.GPFRAGMENTCOVERAGECOLORNV)(getProcAddr("glFragmentCoverageColorNV")) + gpFramebufferDrawBufferEXT = (C.GPFRAMEBUFFERDRAWBUFFEREXT)(getProcAddr("glFramebufferDrawBufferEXT")) + gpFramebufferDrawBuffersEXT = (C.GPFRAMEBUFFERDRAWBUFFERSEXT)(getProcAddr("glFramebufferDrawBuffersEXT")) + gpFramebufferFetchBarrierEXT = (C.GPFRAMEBUFFERFETCHBARRIEREXT)(getProcAddr("glFramebufferFetchBarrierEXT")) + gpFramebufferParameteri = (C.GPFRAMEBUFFERPARAMETERI)(getProcAddr("glFramebufferParameteri")) + gpFramebufferParameteriMESA = (C.GPFRAMEBUFFERPARAMETERIMESA)(getProcAddr("glFramebufferParameteriMESA")) + gpFramebufferReadBufferEXT = (C.GPFRAMEBUFFERREADBUFFEREXT)(getProcAddr("glFramebufferReadBufferEXT")) + gpFramebufferRenderbuffer = (C.GPFRAMEBUFFERRENDERBUFFER)(getProcAddr("glFramebufferRenderbuffer")) + if gpFramebufferRenderbuffer == nil { + return errors.New("glFramebufferRenderbuffer") + } + gpFramebufferSampleLocationsfvARB = (C.GPFRAMEBUFFERSAMPLELOCATIONSFVARB)(getProcAddr("glFramebufferSampleLocationsfvARB")) + gpFramebufferSampleLocationsfvNV = (C.GPFRAMEBUFFERSAMPLELOCATIONSFVNV)(getProcAddr("glFramebufferSampleLocationsfvNV")) + gpFramebufferTexture = (C.GPFRAMEBUFFERTEXTURE)(getProcAddr("glFramebufferTexture")) + if gpFramebufferTexture == nil { + return errors.New("glFramebufferTexture") + } + gpFramebufferTexture1D = (C.GPFRAMEBUFFERTEXTURE1D)(getProcAddr("glFramebufferTexture1D")) + if gpFramebufferTexture1D == nil { + return errors.New("glFramebufferTexture1D") + } + gpFramebufferTexture2D = (C.GPFRAMEBUFFERTEXTURE2D)(getProcAddr("glFramebufferTexture2D")) + if gpFramebufferTexture2D == nil { + return errors.New("glFramebufferTexture2D") + } + gpFramebufferTexture3D = (C.GPFRAMEBUFFERTEXTURE3D)(getProcAddr("glFramebufferTexture3D")) + if gpFramebufferTexture3D == nil { + return errors.New("glFramebufferTexture3D") + } + gpFramebufferTextureARB = (C.GPFRAMEBUFFERTEXTUREARB)(getProcAddr("glFramebufferTextureARB")) + gpFramebufferTextureFaceARB = (C.GPFRAMEBUFFERTEXTUREFACEARB)(getProcAddr("glFramebufferTextureFaceARB")) + gpFramebufferTextureLayer = (C.GPFRAMEBUFFERTEXTURELAYER)(getProcAddr("glFramebufferTextureLayer")) + if gpFramebufferTextureLayer == nil { + return errors.New("glFramebufferTextureLayer") + } + gpFramebufferTextureLayerARB = (C.GPFRAMEBUFFERTEXTURELAYERARB)(getProcAddr("glFramebufferTextureLayerARB")) + gpFramebufferTextureMultiviewOVR = (C.GPFRAMEBUFFERTEXTUREMULTIVIEWOVR)(getProcAddr("glFramebufferTextureMultiviewOVR")) + gpFrontFace = (C.GPFRONTFACE)(getProcAddr("glFrontFace")) + if gpFrontFace == nil { + return errors.New("glFrontFace") + } + gpGenBuffers = (C.GPGENBUFFERS)(getProcAddr("glGenBuffers")) + if gpGenBuffers == nil { + return errors.New("glGenBuffers") + } + gpGenFramebuffers = (C.GPGENFRAMEBUFFERS)(getProcAddr("glGenFramebuffers")) + if gpGenFramebuffers == nil { + return errors.New("glGenFramebuffers") + } + gpGenPathsNV = (C.GPGENPATHSNV)(getProcAddr("glGenPathsNV")) + gpGenPerfMonitorsAMD = (C.GPGENPERFMONITORSAMD)(getProcAddr("glGenPerfMonitorsAMD")) + gpGenProgramPipelines = (C.GPGENPROGRAMPIPELINES)(getProcAddr("glGenProgramPipelines")) + gpGenProgramPipelinesEXT = (C.GPGENPROGRAMPIPELINESEXT)(getProcAddr("glGenProgramPipelinesEXT")) + gpGenQueries = (C.GPGENQUERIES)(getProcAddr("glGenQueries")) + if gpGenQueries == nil { + return errors.New("glGenQueries") + } + gpGenRenderbuffers = (C.GPGENRENDERBUFFERS)(getProcAddr("glGenRenderbuffers")) + if gpGenRenderbuffers == nil { + return errors.New("glGenRenderbuffers") + } + gpGenSamplers = (C.GPGENSAMPLERS)(getProcAddr("glGenSamplers")) + if gpGenSamplers == nil { + return errors.New("glGenSamplers") + } + gpGenTextures = (C.GPGENTEXTURES)(getProcAddr("glGenTextures")) + if gpGenTextures == nil { + return errors.New("glGenTextures") + } + gpGenTransformFeedbacks = (C.GPGENTRANSFORMFEEDBACKS)(getProcAddr("glGenTransformFeedbacks")) + gpGenVertexArrays = (C.GPGENVERTEXARRAYS)(getProcAddr("glGenVertexArrays")) + if gpGenVertexArrays == nil { + return errors.New("glGenVertexArrays") + } + gpGenerateMipmap = (C.GPGENERATEMIPMAP)(getProcAddr("glGenerateMipmap")) + if gpGenerateMipmap == nil { + return errors.New("glGenerateMipmap") + } + gpGenerateMultiTexMipmapEXT = (C.GPGENERATEMULTITEXMIPMAPEXT)(getProcAddr("glGenerateMultiTexMipmapEXT")) + gpGenerateTextureMipmap = (C.GPGENERATETEXTUREMIPMAP)(getProcAddr("glGenerateTextureMipmap")) + gpGenerateTextureMipmapEXT = (C.GPGENERATETEXTUREMIPMAPEXT)(getProcAddr("glGenerateTextureMipmapEXT")) + gpGetActiveAtomicCounterBufferiv = (C.GPGETACTIVEATOMICCOUNTERBUFFERIV)(getProcAddr("glGetActiveAtomicCounterBufferiv")) + gpGetActiveAttrib = (C.GPGETACTIVEATTRIB)(getProcAddr("glGetActiveAttrib")) + if gpGetActiveAttrib == nil { + return errors.New("glGetActiveAttrib") + } + gpGetActiveSubroutineName = (C.GPGETACTIVESUBROUTINENAME)(getProcAddr("glGetActiveSubroutineName")) + gpGetActiveSubroutineUniformName = (C.GPGETACTIVESUBROUTINEUNIFORMNAME)(getProcAddr("glGetActiveSubroutineUniformName")) + gpGetActiveSubroutineUniformiv = (C.GPGETACTIVESUBROUTINEUNIFORMIV)(getProcAddr("glGetActiveSubroutineUniformiv")) + gpGetActiveUniform = (C.GPGETACTIVEUNIFORM)(getProcAddr("glGetActiveUniform")) + if gpGetActiveUniform == nil { + return errors.New("glGetActiveUniform") + } + gpGetActiveUniformBlockName = (C.GPGETACTIVEUNIFORMBLOCKNAME)(getProcAddr("glGetActiveUniformBlockName")) + if gpGetActiveUniformBlockName == nil { + return errors.New("glGetActiveUniformBlockName") + } + gpGetActiveUniformBlockiv = (C.GPGETACTIVEUNIFORMBLOCKIV)(getProcAddr("glGetActiveUniformBlockiv")) + if gpGetActiveUniformBlockiv == nil { + return errors.New("glGetActiveUniformBlockiv") + } + gpGetActiveUniformName = (C.GPGETACTIVEUNIFORMNAME)(getProcAddr("glGetActiveUniformName")) + if gpGetActiveUniformName == nil { + return errors.New("glGetActiveUniformName") + } + gpGetActiveUniformsiv = (C.GPGETACTIVEUNIFORMSIV)(getProcAddr("glGetActiveUniformsiv")) + if gpGetActiveUniformsiv == nil { + return errors.New("glGetActiveUniformsiv") + } + gpGetAttachedShaders = (C.GPGETATTACHEDSHADERS)(getProcAddr("glGetAttachedShaders")) + if gpGetAttachedShaders == nil { + return errors.New("glGetAttachedShaders") + } + gpGetAttribLocation = (C.GPGETATTRIBLOCATION)(getProcAddr("glGetAttribLocation")) + if gpGetAttribLocation == nil { + return errors.New("glGetAttribLocation") + } + gpGetBooleanIndexedvEXT = (C.GPGETBOOLEANINDEXEDVEXT)(getProcAddr("glGetBooleanIndexedvEXT")) + gpGetBooleani_v = (C.GPGETBOOLEANI_V)(getProcAddr("glGetBooleani_v")) + if gpGetBooleani_v == nil { + return errors.New("glGetBooleani_v") + } + gpGetBooleanv = (C.GPGETBOOLEANV)(getProcAddr("glGetBooleanv")) + if gpGetBooleanv == nil { + return errors.New("glGetBooleanv") + } + gpGetBufferParameteri64v = (C.GPGETBUFFERPARAMETERI64V)(getProcAddr("glGetBufferParameteri64v")) + if gpGetBufferParameteri64v == nil { + return errors.New("glGetBufferParameteri64v") + } + gpGetBufferParameteriv = (C.GPGETBUFFERPARAMETERIV)(getProcAddr("glGetBufferParameteriv")) + if gpGetBufferParameteriv == nil { + return errors.New("glGetBufferParameteriv") + } + gpGetBufferParameterui64vNV = (C.GPGETBUFFERPARAMETERUI64VNV)(getProcAddr("glGetBufferParameterui64vNV")) + gpGetBufferPointerv = (C.GPGETBUFFERPOINTERV)(getProcAddr("glGetBufferPointerv")) + if gpGetBufferPointerv == nil { + return errors.New("glGetBufferPointerv") + } + gpGetBufferSubData = (C.GPGETBUFFERSUBDATA)(getProcAddr("glGetBufferSubData")) + if gpGetBufferSubData == nil { + return errors.New("glGetBufferSubData") + } + gpGetCommandHeaderNV = (C.GPGETCOMMANDHEADERNV)(getProcAddr("glGetCommandHeaderNV")) + gpGetCompressedMultiTexImageEXT = (C.GPGETCOMPRESSEDMULTITEXIMAGEEXT)(getProcAddr("glGetCompressedMultiTexImageEXT")) + gpGetCompressedTexImage = (C.GPGETCOMPRESSEDTEXIMAGE)(getProcAddr("glGetCompressedTexImage")) + if gpGetCompressedTexImage == nil { + return errors.New("glGetCompressedTexImage") + } + gpGetCompressedTextureImage = (C.GPGETCOMPRESSEDTEXTUREIMAGE)(getProcAddr("glGetCompressedTextureImage")) + gpGetCompressedTextureImageEXT = (C.GPGETCOMPRESSEDTEXTUREIMAGEEXT)(getProcAddr("glGetCompressedTextureImageEXT")) + gpGetCompressedTextureSubImage = (C.GPGETCOMPRESSEDTEXTURESUBIMAGE)(getProcAddr("glGetCompressedTextureSubImage")) + gpGetCoverageModulationTableNV = (C.GPGETCOVERAGEMODULATIONTABLENV)(getProcAddr("glGetCoverageModulationTableNV")) + gpGetDebugMessageLog = (C.GPGETDEBUGMESSAGELOG)(getProcAddr("glGetDebugMessageLog")) + gpGetDebugMessageLogARB = (C.GPGETDEBUGMESSAGELOGARB)(getProcAddr("glGetDebugMessageLogARB")) + gpGetDebugMessageLogKHR = (C.GPGETDEBUGMESSAGELOGKHR)(getProcAddr("glGetDebugMessageLogKHR")) + gpGetDoubleIndexedvEXT = (C.GPGETDOUBLEINDEXEDVEXT)(getProcAddr("glGetDoubleIndexedvEXT")) + gpGetDoublei_v = (C.GPGETDOUBLEI_V)(getProcAddr("glGetDoublei_v")) + gpGetDoublei_vEXT = (C.GPGETDOUBLEI_VEXT)(getProcAddr("glGetDoublei_vEXT")) + gpGetDoublev = (C.GPGETDOUBLEV)(getProcAddr("glGetDoublev")) + if gpGetDoublev == nil { + return errors.New("glGetDoublev") + } + gpGetError = (C.GPGETERROR)(getProcAddr("glGetError")) + if gpGetError == nil { + return errors.New("glGetError") + } + gpGetFirstPerfQueryIdINTEL = (C.GPGETFIRSTPERFQUERYIDINTEL)(getProcAddr("glGetFirstPerfQueryIdINTEL")) + gpGetFloatIndexedvEXT = (C.GPGETFLOATINDEXEDVEXT)(getProcAddr("glGetFloatIndexedvEXT")) + gpGetFloati_v = (C.GPGETFLOATI_V)(getProcAddr("glGetFloati_v")) + gpGetFloati_vEXT = (C.GPGETFLOATI_VEXT)(getProcAddr("glGetFloati_vEXT")) + gpGetFloatv = (C.GPGETFLOATV)(getProcAddr("glGetFloatv")) + if gpGetFloatv == nil { + return errors.New("glGetFloatv") + } + gpGetFragDataIndex = (C.GPGETFRAGDATAINDEX)(getProcAddr("glGetFragDataIndex")) + if gpGetFragDataIndex == nil { + return errors.New("glGetFragDataIndex") + } + gpGetFragDataLocation = (C.GPGETFRAGDATALOCATION)(getProcAddr("glGetFragDataLocation")) + if gpGetFragDataLocation == nil { + return errors.New("glGetFragDataLocation") + } + gpGetFramebufferAttachmentParameteriv = (C.GPGETFRAMEBUFFERATTACHMENTPARAMETERIV)(getProcAddr("glGetFramebufferAttachmentParameteriv")) + if gpGetFramebufferAttachmentParameteriv == nil { + return errors.New("glGetFramebufferAttachmentParameteriv") + } + gpGetFramebufferParameteriv = (C.GPGETFRAMEBUFFERPARAMETERIV)(getProcAddr("glGetFramebufferParameteriv")) + gpGetFramebufferParameterivEXT = (C.GPGETFRAMEBUFFERPARAMETERIVEXT)(getProcAddr("glGetFramebufferParameterivEXT")) + gpGetFramebufferParameterivMESA = (C.GPGETFRAMEBUFFERPARAMETERIVMESA)(getProcAddr("glGetFramebufferParameterivMESA")) + gpGetGraphicsResetStatus = (C.GPGETGRAPHICSRESETSTATUS)(getProcAddr("glGetGraphicsResetStatus")) + gpGetGraphicsResetStatusARB = (C.GPGETGRAPHICSRESETSTATUSARB)(getProcAddr("glGetGraphicsResetStatusARB")) + gpGetGraphicsResetStatusKHR = (C.GPGETGRAPHICSRESETSTATUSKHR)(getProcAddr("glGetGraphicsResetStatusKHR")) + gpGetImageHandleARB = (C.GPGETIMAGEHANDLEARB)(getProcAddr("glGetImageHandleARB")) + gpGetImageHandleNV = (C.GPGETIMAGEHANDLENV)(getProcAddr("glGetImageHandleNV")) + gpGetInteger64i_v = (C.GPGETINTEGER64I_V)(getProcAddr("glGetInteger64i_v")) + if gpGetInteger64i_v == nil { + return errors.New("glGetInteger64i_v") + } + gpGetInteger64v = (C.GPGETINTEGER64V)(getProcAddr("glGetInteger64v")) + if gpGetInteger64v == nil { + return errors.New("glGetInteger64v") + } + gpGetIntegerIndexedvEXT = (C.GPGETINTEGERINDEXEDVEXT)(getProcAddr("glGetIntegerIndexedvEXT")) + gpGetIntegeri_v = (C.GPGETINTEGERI_V)(getProcAddr("glGetIntegeri_v")) + if gpGetIntegeri_v == nil { + return errors.New("glGetIntegeri_v") + } + gpGetIntegerui64i_vNV = (C.GPGETINTEGERUI64I_VNV)(getProcAddr("glGetIntegerui64i_vNV")) + gpGetIntegerui64vNV = (C.GPGETINTEGERUI64VNV)(getProcAddr("glGetIntegerui64vNV")) + gpGetIntegerv = (C.GPGETINTEGERV)(getProcAddr("glGetIntegerv")) + if gpGetIntegerv == nil { + return errors.New("glGetIntegerv") + } + gpGetInternalformatSampleivNV = (C.GPGETINTERNALFORMATSAMPLEIVNV)(getProcAddr("glGetInternalformatSampleivNV")) + gpGetInternalformati64v = (C.GPGETINTERNALFORMATI64V)(getProcAddr("glGetInternalformati64v")) + gpGetInternalformativ = (C.GPGETINTERNALFORMATIV)(getProcAddr("glGetInternalformativ")) + gpGetMemoryObjectDetachedResourcesuivNV = (C.GPGETMEMORYOBJECTDETACHEDRESOURCESUIVNV)(getProcAddr("glGetMemoryObjectDetachedResourcesuivNV")) + gpGetMultiTexEnvfvEXT = (C.GPGETMULTITEXENVFVEXT)(getProcAddr("glGetMultiTexEnvfvEXT")) + gpGetMultiTexEnvivEXT = (C.GPGETMULTITEXENVIVEXT)(getProcAddr("glGetMultiTexEnvivEXT")) + gpGetMultiTexGendvEXT = (C.GPGETMULTITEXGENDVEXT)(getProcAddr("glGetMultiTexGendvEXT")) + gpGetMultiTexGenfvEXT = (C.GPGETMULTITEXGENFVEXT)(getProcAddr("glGetMultiTexGenfvEXT")) + gpGetMultiTexGenivEXT = (C.GPGETMULTITEXGENIVEXT)(getProcAddr("glGetMultiTexGenivEXT")) + gpGetMultiTexImageEXT = (C.GPGETMULTITEXIMAGEEXT)(getProcAddr("glGetMultiTexImageEXT")) + gpGetMultiTexLevelParameterfvEXT = (C.GPGETMULTITEXLEVELPARAMETERFVEXT)(getProcAddr("glGetMultiTexLevelParameterfvEXT")) + gpGetMultiTexLevelParameterivEXT = (C.GPGETMULTITEXLEVELPARAMETERIVEXT)(getProcAddr("glGetMultiTexLevelParameterivEXT")) + gpGetMultiTexParameterIivEXT = (C.GPGETMULTITEXPARAMETERIIVEXT)(getProcAddr("glGetMultiTexParameterIivEXT")) + gpGetMultiTexParameterIuivEXT = (C.GPGETMULTITEXPARAMETERIUIVEXT)(getProcAddr("glGetMultiTexParameterIuivEXT")) + gpGetMultiTexParameterfvEXT = (C.GPGETMULTITEXPARAMETERFVEXT)(getProcAddr("glGetMultiTexParameterfvEXT")) + gpGetMultiTexParameterivEXT = (C.GPGETMULTITEXPARAMETERIVEXT)(getProcAddr("glGetMultiTexParameterivEXT")) + gpGetMultisamplefv = (C.GPGETMULTISAMPLEFV)(getProcAddr("glGetMultisamplefv")) + if gpGetMultisamplefv == nil { + return errors.New("glGetMultisamplefv") + } + gpGetNamedBufferParameteri64v = (C.GPGETNAMEDBUFFERPARAMETERI64V)(getProcAddr("glGetNamedBufferParameteri64v")) + gpGetNamedBufferParameteriv = (C.GPGETNAMEDBUFFERPARAMETERIV)(getProcAddr("glGetNamedBufferParameteriv")) + gpGetNamedBufferParameterivEXT = (C.GPGETNAMEDBUFFERPARAMETERIVEXT)(getProcAddr("glGetNamedBufferParameterivEXT")) + gpGetNamedBufferParameterui64vNV = (C.GPGETNAMEDBUFFERPARAMETERUI64VNV)(getProcAddr("glGetNamedBufferParameterui64vNV")) + gpGetNamedBufferPointerv = (C.GPGETNAMEDBUFFERPOINTERV)(getProcAddr("glGetNamedBufferPointerv")) + gpGetNamedBufferPointervEXT = (C.GPGETNAMEDBUFFERPOINTERVEXT)(getProcAddr("glGetNamedBufferPointervEXT")) + gpGetNamedBufferSubData = (C.GPGETNAMEDBUFFERSUBDATA)(getProcAddr("glGetNamedBufferSubData")) + gpGetNamedBufferSubDataEXT = (C.GPGETNAMEDBUFFERSUBDATAEXT)(getProcAddr("glGetNamedBufferSubDataEXT")) + gpGetNamedFramebufferAttachmentParameteriv = (C.GPGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIV)(getProcAddr("glGetNamedFramebufferAttachmentParameteriv")) + gpGetNamedFramebufferAttachmentParameterivEXT = (C.GPGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXT)(getProcAddr("glGetNamedFramebufferAttachmentParameterivEXT")) + gpGetNamedFramebufferParameteriv = (C.GPGETNAMEDFRAMEBUFFERPARAMETERIV)(getProcAddr("glGetNamedFramebufferParameteriv")) + gpGetNamedFramebufferParameterivEXT = (C.GPGETNAMEDFRAMEBUFFERPARAMETERIVEXT)(getProcAddr("glGetNamedFramebufferParameterivEXT")) + gpGetNamedProgramLocalParameterIivEXT = (C.GPGETNAMEDPROGRAMLOCALPARAMETERIIVEXT)(getProcAddr("glGetNamedProgramLocalParameterIivEXT")) + gpGetNamedProgramLocalParameterIuivEXT = (C.GPGETNAMEDPROGRAMLOCALPARAMETERIUIVEXT)(getProcAddr("glGetNamedProgramLocalParameterIuivEXT")) + gpGetNamedProgramLocalParameterdvEXT = (C.GPGETNAMEDPROGRAMLOCALPARAMETERDVEXT)(getProcAddr("glGetNamedProgramLocalParameterdvEXT")) + gpGetNamedProgramLocalParameterfvEXT = (C.GPGETNAMEDPROGRAMLOCALPARAMETERFVEXT)(getProcAddr("glGetNamedProgramLocalParameterfvEXT")) + gpGetNamedProgramStringEXT = (C.GPGETNAMEDPROGRAMSTRINGEXT)(getProcAddr("glGetNamedProgramStringEXT")) + gpGetNamedProgramivEXT = (C.GPGETNAMEDPROGRAMIVEXT)(getProcAddr("glGetNamedProgramivEXT")) + gpGetNamedRenderbufferParameteriv = (C.GPGETNAMEDRENDERBUFFERPARAMETERIV)(getProcAddr("glGetNamedRenderbufferParameteriv")) + gpGetNamedRenderbufferParameterivEXT = (C.GPGETNAMEDRENDERBUFFERPARAMETERIVEXT)(getProcAddr("glGetNamedRenderbufferParameterivEXT")) + gpGetNamedStringARB = (C.GPGETNAMEDSTRINGARB)(getProcAddr("glGetNamedStringARB")) + gpGetNamedStringivARB = (C.GPGETNAMEDSTRINGIVARB)(getProcAddr("glGetNamedStringivARB")) + gpGetNextPerfQueryIdINTEL = (C.GPGETNEXTPERFQUERYIDINTEL)(getProcAddr("glGetNextPerfQueryIdINTEL")) + gpGetObjectLabel = (C.GPGETOBJECTLABEL)(getProcAddr("glGetObjectLabel")) + gpGetObjectLabelEXT = (C.GPGETOBJECTLABELEXT)(getProcAddr("glGetObjectLabelEXT")) + gpGetObjectLabelKHR = (C.GPGETOBJECTLABELKHR)(getProcAddr("glGetObjectLabelKHR")) + gpGetObjectPtrLabel = (C.GPGETOBJECTPTRLABEL)(getProcAddr("glGetObjectPtrLabel")) + gpGetObjectPtrLabelKHR = (C.GPGETOBJECTPTRLABELKHR)(getProcAddr("glGetObjectPtrLabelKHR")) + gpGetPathCommandsNV = (C.GPGETPATHCOMMANDSNV)(getProcAddr("glGetPathCommandsNV")) + gpGetPathCoordsNV = (C.GPGETPATHCOORDSNV)(getProcAddr("glGetPathCoordsNV")) + gpGetPathDashArrayNV = (C.GPGETPATHDASHARRAYNV)(getProcAddr("glGetPathDashArrayNV")) + gpGetPathLengthNV = (C.GPGETPATHLENGTHNV)(getProcAddr("glGetPathLengthNV")) + gpGetPathMetricRangeNV = (C.GPGETPATHMETRICRANGENV)(getProcAddr("glGetPathMetricRangeNV")) + gpGetPathMetricsNV = (C.GPGETPATHMETRICSNV)(getProcAddr("glGetPathMetricsNV")) + gpGetPathParameterfvNV = (C.GPGETPATHPARAMETERFVNV)(getProcAddr("glGetPathParameterfvNV")) + gpGetPathParameterivNV = (C.GPGETPATHPARAMETERIVNV)(getProcAddr("glGetPathParameterivNV")) + gpGetPathSpacingNV = (C.GPGETPATHSPACINGNV)(getProcAddr("glGetPathSpacingNV")) + gpGetPerfCounterInfoINTEL = (C.GPGETPERFCOUNTERINFOINTEL)(getProcAddr("glGetPerfCounterInfoINTEL")) + gpGetPerfMonitorCounterDataAMD = (C.GPGETPERFMONITORCOUNTERDATAAMD)(getProcAddr("glGetPerfMonitorCounterDataAMD")) + gpGetPerfMonitorCounterInfoAMD = (C.GPGETPERFMONITORCOUNTERINFOAMD)(getProcAddr("glGetPerfMonitorCounterInfoAMD")) + gpGetPerfMonitorCounterStringAMD = (C.GPGETPERFMONITORCOUNTERSTRINGAMD)(getProcAddr("glGetPerfMonitorCounterStringAMD")) + gpGetPerfMonitorCountersAMD = (C.GPGETPERFMONITORCOUNTERSAMD)(getProcAddr("glGetPerfMonitorCountersAMD")) + gpGetPerfMonitorGroupStringAMD = (C.GPGETPERFMONITORGROUPSTRINGAMD)(getProcAddr("glGetPerfMonitorGroupStringAMD")) + gpGetPerfMonitorGroupsAMD = (C.GPGETPERFMONITORGROUPSAMD)(getProcAddr("glGetPerfMonitorGroupsAMD")) + gpGetPerfQueryDataINTEL = (C.GPGETPERFQUERYDATAINTEL)(getProcAddr("glGetPerfQueryDataINTEL")) + gpGetPerfQueryIdByNameINTEL = (C.GPGETPERFQUERYIDBYNAMEINTEL)(getProcAddr("glGetPerfQueryIdByNameINTEL")) + gpGetPerfQueryInfoINTEL = (C.GPGETPERFQUERYINFOINTEL)(getProcAddr("glGetPerfQueryInfoINTEL")) + gpGetPointerIndexedvEXT = (C.GPGETPOINTERINDEXEDVEXT)(getProcAddr("glGetPointerIndexedvEXT")) + gpGetPointeri_vEXT = (C.GPGETPOINTERI_VEXT)(getProcAddr("glGetPointeri_vEXT")) + gpGetPointerv = (C.GPGETPOINTERV)(getProcAddr("glGetPointerv")) + gpGetPointervKHR = (C.GPGETPOINTERVKHR)(getProcAddr("glGetPointervKHR")) + gpGetProgramBinary = (C.GPGETPROGRAMBINARY)(getProcAddr("glGetProgramBinary")) + gpGetProgramInfoLog = (C.GPGETPROGRAMINFOLOG)(getProcAddr("glGetProgramInfoLog")) + if gpGetProgramInfoLog == nil { + return errors.New("glGetProgramInfoLog") + } + gpGetProgramInterfaceiv = (C.GPGETPROGRAMINTERFACEIV)(getProcAddr("glGetProgramInterfaceiv")) + gpGetProgramPipelineInfoLog = (C.GPGETPROGRAMPIPELINEINFOLOG)(getProcAddr("glGetProgramPipelineInfoLog")) + gpGetProgramPipelineInfoLogEXT = (C.GPGETPROGRAMPIPELINEINFOLOGEXT)(getProcAddr("glGetProgramPipelineInfoLogEXT")) + gpGetProgramPipelineiv = (C.GPGETPROGRAMPIPELINEIV)(getProcAddr("glGetProgramPipelineiv")) + gpGetProgramPipelineivEXT = (C.GPGETPROGRAMPIPELINEIVEXT)(getProcAddr("glGetProgramPipelineivEXT")) + gpGetProgramResourceIndex = (C.GPGETPROGRAMRESOURCEINDEX)(getProcAddr("glGetProgramResourceIndex")) + gpGetProgramResourceLocation = (C.GPGETPROGRAMRESOURCELOCATION)(getProcAddr("glGetProgramResourceLocation")) + gpGetProgramResourceLocationIndex = (C.GPGETPROGRAMRESOURCELOCATIONINDEX)(getProcAddr("glGetProgramResourceLocationIndex")) + gpGetProgramResourceName = (C.GPGETPROGRAMRESOURCENAME)(getProcAddr("glGetProgramResourceName")) + gpGetProgramResourcefvNV = (C.GPGETPROGRAMRESOURCEFVNV)(getProcAddr("glGetProgramResourcefvNV")) + gpGetProgramResourceiv = (C.GPGETPROGRAMRESOURCEIV)(getProcAddr("glGetProgramResourceiv")) + gpGetProgramStageiv = (C.GPGETPROGRAMSTAGEIV)(getProcAddr("glGetProgramStageiv")) + gpGetProgramiv = (C.GPGETPROGRAMIV)(getProcAddr("glGetProgramiv")) + if gpGetProgramiv == nil { + return errors.New("glGetProgramiv") + } + gpGetQueryBufferObjecti64v = (C.GPGETQUERYBUFFEROBJECTI64V)(getProcAddr("glGetQueryBufferObjecti64v")) + gpGetQueryBufferObjectiv = (C.GPGETQUERYBUFFEROBJECTIV)(getProcAddr("glGetQueryBufferObjectiv")) + gpGetQueryBufferObjectui64v = (C.GPGETQUERYBUFFEROBJECTUI64V)(getProcAddr("glGetQueryBufferObjectui64v")) + gpGetQueryBufferObjectuiv = (C.GPGETQUERYBUFFEROBJECTUIV)(getProcAddr("glGetQueryBufferObjectuiv")) + gpGetQueryIndexediv = (C.GPGETQUERYINDEXEDIV)(getProcAddr("glGetQueryIndexediv")) + gpGetQueryObjecti64v = (C.GPGETQUERYOBJECTI64V)(getProcAddr("glGetQueryObjecti64v")) + if gpGetQueryObjecti64v == nil { + return errors.New("glGetQueryObjecti64v") + } + gpGetQueryObjectiv = (C.GPGETQUERYOBJECTIV)(getProcAddr("glGetQueryObjectiv")) + if gpGetQueryObjectiv == nil { + return errors.New("glGetQueryObjectiv") + } + gpGetQueryObjectui64v = (C.GPGETQUERYOBJECTUI64V)(getProcAddr("glGetQueryObjectui64v")) + if gpGetQueryObjectui64v == nil { + return errors.New("glGetQueryObjectui64v") + } + gpGetQueryObjectuiv = (C.GPGETQUERYOBJECTUIV)(getProcAddr("glGetQueryObjectuiv")) + if gpGetQueryObjectuiv == nil { + return errors.New("glGetQueryObjectuiv") + } + gpGetQueryiv = (C.GPGETQUERYIV)(getProcAddr("glGetQueryiv")) + if gpGetQueryiv == nil { + return errors.New("glGetQueryiv") + } + gpGetRenderbufferParameteriv = (C.GPGETRENDERBUFFERPARAMETERIV)(getProcAddr("glGetRenderbufferParameteriv")) + if gpGetRenderbufferParameteriv == nil { + return errors.New("glGetRenderbufferParameteriv") + } + gpGetSamplerParameterIiv = (C.GPGETSAMPLERPARAMETERIIV)(getProcAddr("glGetSamplerParameterIiv")) + if gpGetSamplerParameterIiv == nil { + return errors.New("glGetSamplerParameterIiv") + } + gpGetSamplerParameterIuiv = (C.GPGETSAMPLERPARAMETERIUIV)(getProcAddr("glGetSamplerParameterIuiv")) + if gpGetSamplerParameterIuiv == nil { + return errors.New("glGetSamplerParameterIuiv") + } + gpGetSamplerParameterfv = (C.GPGETSAMPLERPARAMETERFV)(getProcAddr("glGetSamplerParameterfv")) + if gpGetSamplerParameterfv == nil { + return errors.New("glGetSamplerParameterfv") + } + gpGetSamplerParameteriv = (C.GPGETSAMPLERPARAMETERIV)(getProcAddr("glGetSamplerParameteriv")) + if gpGetSamplerParameteriv == nil { + return errors.New("glGetSamplerParameteriv") + } + gpGetShaderInfoLog = (C.GPGETSHADERINFOLOG)(getProcAddr("glGetShaderInfoLog")) + if gpGetShaderInfoLog == nil { + return errors.New("glGetShaderInfoLog") + } + gpGetShaderPrecisionFormat = (C.GPGETSHADERPRECISIONFORMAT)(getProcAddr("glGetShaderPrecisionFormat")) + gpGetShaderSource = (C.GPGETSHADERSOURCE)(getProcAddr("glGetShaderSource")) + if gpGetShaderSource == nil { + return errors.New("glGetShaderSource") + } + gpGetShaderiv = (C.GPGETSHADERIV)(getProcAddr("glGetShaderiv")) + if gpGetShaderiv == nil { + return errors.New("glGetShaderiv") + } + gpGetShadingRateImagePaletteNV = (C.GPGETSHADINGRATEIMAGEPALETTENV)(getProcAddr("glGetShadingRateImagePaletteNV")) + gpGetShadingRateSampleLocationivNV = (C.GPGETSHADINGRATESAMPLELOCATIONIVNV)(getProcAddr("glGetShadingRateSampleLocationivNV")) + gpGetStageIndexNV = (C.GPGETSTAGEINDEXNV)(getProcAddr("glGetStageIndexNV")) + gpGetString = (C.GPGETSTRING)(getProcAddr("glGetString")) + if gpGetString == nil { + return errors.New("glGetString") + } + gpGetStringi = (C.GPGETSTRINGI)(getProcAddr("glGetStringi")) + if gpGetStringi == nil { + return errors.New("glGetStringi") + } + gpGetSubroutineIndex = (C.GPGETSUBROUTINEINDEX)(getProcAddr("glGetSubroutineIndex")) + gpGetSubroutineUniformLocation = (C.GPGETSUBROUTINEUNIFORMLOCATION)(getProcAddr("glGetSubroutineUniformLocation")) + gpGetSynciv = (C.GPGETSYNCIV)(getProcAddr("glGetSynciv")) + if gpGetSynciv == nil { + return errors.New("glGetSynciv") + } + gpGetTexImage = (C.GPGETTEXIMAGE)(getProcAddr("glGetTexImage")) + if gpGetTexImage == nil { + return errors.New("glGetTexImage") + } + gpGetTexLevelParameterfv = (C.GPGETTEXLEVELPARAMETERFV)(getProcAddr("glGetTexLevelParameterfv")) + if gpGetTexLevelParameterfv == nil { + return errors.New("glGetTexLevelParameterfv") + } + gpGetTexLevelParameteriv = (C.GPGETTEXLEVELPARAMETERIV)(getProcAddr("glGetTexLevelParameteriv")) + if gpGetTexLevelParameteriv == nil { + return errors.New("glGetTexLevelParameteriv") + } + gpGetTexParameterIiv = (C.GPGETTEXPARAMETERIIV)(getProcAddr("glGetTexParameterIiv")) + if gpGetTexParameterIiv == nil { + return errors.New("glGetTexParameterIiv") + } + gpGetTexParameterIuiv = (C.GPGETTEXPARAMETERIUIV)(getProcAddr("glGetTexParameterIuiv")) + if gpGetTexParameterIuiv == nil { + return errors.New("glGetTexParameterIuiv") + } + gpGetTexParameterfv = (C.GPGETTEXPARAMETERFV)(getProcAddr("glGetTexParameterfv")) + if gpGetTexParameterfv == nil { + return errors.New("glGetTexParameterfv") + } + gpGetTexParameteriv = (C.GPGETTEXPARAMETERIV)(getProcAddr("glGetTexParameteriv")) + if gpGetTexParameteriv == nil { + return errors.New("glGetTexParameteriv") + } + gpGetTextureHandleARB = (C.GPGETTEXTUREHANDLEARB)(getProcAddr("glGetTextureHandleARB")) + gpGetTextureHandleNV = (C.GPGETTEXTUREHANDLENV)(getProcAddr("glGetTextureHandleNV")) + gpGetTextureImage = (C.GPGETTEXTUREIMAGE)(getProcAddr("glGetTextureImage")) + gpGetTextureImageEXT = (C.GPGETTEXTUREIMAGEEXT)(getProcAddr("glGetTextureImageEXT")) + gpGetTextureLevelParameterfv = (C.GPGETTEXTURELEVELPARAMETERFV)(getProcAddr("glGetTextureLevelParameterfv")) + gpGetTextureLevelParameterfvEXT = (C.GPGETTEXTURELEVELPARAMETERFVEXT)(getProcAddr("glGetTextureLevelParameterfvEXT")) + gpGetTextureLevelParameteriv = (C.GPGETTEXTURELEVELPARAMETERIV)(getProcAddr("glGetTextureLevelParameteriv")) + gpGetTextureLevelParameterivEXT = (C.GPGETTEXTURELEVELPARAMETERIVEXT)(getProcAddr("glGetTextureLevelParameterivEXT")) + gpGetTextureParameterIiv = (C.GPGETTEXTUREPARAMETERIIV)(getProcAddr("glGetTextureParameterIiv")) + gpGetTextureParameterIivEXT = (C.GPGETTEXTUREPARAMETERIIVEXT)(getProcAddr("glGetTextureParameterIivEXT")) + gpGetTextureParameterIuiv = (C.GPGETTEXTUREPARAMETERIUIV)(getProcAddr("glGetTextureParameterIuiv")) + gpGetTextureParameterIuivEXT = (C.GPGETTEXTUREPARAMETERIUIVEXT)(getProcAddr("glGetTextureParameterIuivEXT")) + gpGetTextureParameterfv = (C.GPGETTEXTUREPARAMETERFV)(getProcAddr("glGetTextureParameterfv")) + gpGetTextureParameterfvEXT = (C.GPGETTEXTUREPARAMETERFVEXT)(getProcAddr("glGetTextureParameterfvEXT")) + gpGetTextureParameteriv = (C.GPGETTEXTUREPARAMETERIV)(getProcAddr("glGetTextureParameteriv")) + gpGetTextureParameterivEXT = (C.GPGETTEXTUREPARAMETERIVEXT)(getProcAddr("glGetTextureParameterivEXT")) + gpGetTextureSamplerHandleARB = (C.GPGETTEXTURESAMPLERHANDLEARB)(getProcAddr("glGetTextureSamplerHandleARB")) + gpGetTextureSamplerHandleNV = (C.GPGETTEXTURESAMPLERHANDLENV)(getProcAddr("glGetTextureSamplerHandleNV")) + gpGetTextureSubImage = (C.GPGETTEXTURESUBIMAGE)(getProcAddr("glGetTextureSubImage")) + gpGetTransformFeedbackVarying = (C.GPGETTRANSFORMFEEDBACKVARYING)(getProcAddr("glGetTransformFeedbackVarying")) + if gpGetTransformFeedbackVarying == nil { + return errors.New("glGetTransformFeedbackVarying") + } + gpGetTransformFeedbacki64_v = (C.GPGETTRANSFORMFEEDBACKI64_V)(getProcAddr("glGetTransformFeedbacki64_v")) + gpGetTransformFeedbacki_v = (C.GPGETTRANSFORMFEEDBACKI_V)(getProcAddr("glGetTransformFeedbacki_v")) + gpGetTransformFeedbackiv = (C.GPGETTRANSFORMFEEDBACKIV)(getProcAddr("glGetTransformFeedbackiv")) + gpGetUniformBlockIndex = (C.GPGETUNIFORMBLOCKINDEX)(getProcAddr("glGetUniformBlockIndex")) + if gpGetUniformBlockIndex == nil { + return errors.New("glGetUniformBlockIndex") + } + gpGetUniformIndices = (C.GPGETUNIFORMINDICES)(getProcAddr("glGetUniformIndices")) + if gpGetUniformIndices == nil { + return errors.New("glGetUniformIndices") + } + gpGetUniformLocation = (C.GPGETUNIFORMLOCATION)(getProcAddr("glGetUniformLocation")) + if gpGetUniformLocation == nil { + return errors.New("glGetUniformLocation") + } + gpGetUniformSubroutineuiv = (C.GPGETUNIFORMSUBROUTINEUIV)(getProcAddr("glGetUniformSubroutineuiv")) + gpGetUniformdv = (C.GPGETUNIFORMDV)(getProcAddr("glGetUniformdv")) + gpGetUniformfv = (C.GPGETUNIFORMFV)(getProcAddr("glGetUniformfv")) + if gpGetUniformfv == nil { + return errors.New("glGetUniformfv") + } + gpGetUniformi64vARB = (C.GPGETUNIFORMI64VARB)(getProcAddr("glGetUniformi64vARB")) + gpGetUniformi64vNV = (C.GPGETUNIFORMI64VNV)(getProcAddr("glGetUniformi64vNV")) + gpGetUniformiv = (C.GPGETUNIFORMIV)(getProcAddr("glGetUniformiv")) + if gpGetUniformiv == nil { + return errors.New("glGetUniformiv") + } + gpGetUniformui64vARB = (C.GPGETUNIFORMUI64VARB)(getProcAddr("glGetUniformui64vARB")) + gpGetUniformui64vNV = (C.GPGETUNIFORMUI64VNV)(getProcAddr("glGetUniformui64vNV")) + gpGetUniformuiv = (C.GPGETUNIFORMUIV)(getProcAddr("glGetUniformuiv")) + if gpGetUniformuiv == nil { + return errors.New("glGetUniformuiv") + } + gpGetVertexArrayIndexed64iv = (C.GPGETVERTEXARRAYINDEXED64IV)(getProcAddr("glGetVertexArrayIndexed64iv")) + gpGetVertexArrayIndexediv = (C.GPGETVERTEXARRAYINDEXEDIV)(getProcAddr("glGetVertexArrayIndexediv")) + gpGetVertexArrayIntegeri_vEXT = (C.GPGETVERTEXARRAYINTEGERI_VEXT)(getProcAddr("glGetVertexArrayIntegeri_vEXT")) + gpGetVertexArrayIntegervEXT = (C.GPGETVERTEXARRAYINTEGERVEXT)(getProcAddr("glGetVertexArrayIntegervEXT")) + gpGetVertexArrayPointeri_vEXT = (C.GPGETVERTEXARRAYPOINTERI_VEXT)(getProcAddr("glGetVertexArrayPointeri_vEXT")) + gpGetVertexArrayPointervEXT = (C.GPGETVERTEXARRAYPOINTERVEXT)(getProcAddr("glGetVertexArrayPointervEXT")) + gpGetVertexArrayiv = (C.GPGETVERTEXARRAYIV)(getProcAddr("glGetVertexArrayiv")) + gpGetVertexAttribIiv = (C.GPGETVERTEXATTRIBIIV)(getProcAddr("glGetVertexAttribIiv")) + if gpGetVertexAttribIiv == nil { + return errors.New("glGetVertexAttribIiv") + } + gpGetVertexAttribIuiv = (C.GPGETVERTEXATTRIBIUIV)(getProcAddr("glGetVertexAttribIuiv")) + if gpGetVertexAttribIuiv == nil { + return errors.New("glGetVertexAttribIuiv") + } + gpGetVertexAttribLdv = (C.GPGETVERTEXATTRIBLDV)(getProcAddr("glGetVertexAttribLdv")) + gpGetVertexAttribLi64vNV = (C.GPGETVERTEXATTRIBLI64VNV)(getProcAddr("glGetVertexAttribLi64vNV")) + gpGetVertexAttribLui64vARB = (C.GPGETVERTEXATTRIBLUI64VARB)(getProcAddr("glGetVertexAttribLui64vARB")) + gpGetVertexAttribLui64vNV = (C.GPGETVERTEXATTRIBLUI64VNV)(getProcAddr("glGetVertexAttribLui64vNV")) + gpGetVertexAttribPointerv = (C.GPGETVERTEXATTRIBPOINTERV)(getProcAddr("glGetVertexAttribPointerv")) + if gpGetVertexAttribPointerv == nil { + return errors.New("glGetVertexAttribPointerv") + } + gpGetVertexAttribdv = (C.GPGETVERTEXATTRIBDV)(getProcAddr("glGetVertexAttribdv")) + if gpGetVertexAttribdv == nil { + return errors.New("glGetVertexAttribdv") + } + gpGetVertexAttribfv = (C.GPGETVERTEXATTRIBFV)(getProcAddr("glGetVertexAttribfv")) + if gpGetVertexAttribfv == nil { + return errors.New("glGetVertexAttribfv") + } + gpGetVertexAttribiv = (C.GPGETVERTEXATTRIBIV)(getProcAddr("glGetVertexAttribiv")) + if gpGetVertexAttribiv == nil { + return errors.New("glGetVertexAttribiv") + } + gpGetVkProcAddrNV = (C.GPGETVKPROCADDRNV)(getProcAddr("glGetVkProcAddrNV")) + gpGetnCompressedTexImageARB = (C.GPGETNCOMPRESSEDTEXIMAGEARB)(getProcAddr("glGetnCompressedTexImageARB")) + gpGetnTexImageARB = (C.GPGETNTEXIMAGEARB)(getProcAddr("glGetnTexImageARB")) + gpGetnUniformdvARB = (C.GPGETNUNIFORMDVARB)(getProcAddr("glGetnUniformdvARB")) + gpGetnUniformfv = (C.GPGETNUNIFORMFV)(getProcAddr("glGetnUniformfv")) + gpGetnUniformfvARB = (C.GPGETNUNIFORMFVARB)(getProcAddr("glGetnUniformfvARB")) + gpGetnUniformfvKHR = (C.GPGETNUNIFORMFVKHR)(getProcAddr("glGetnUniformfvKHR")) + gpGetnUniformi64vARB = (C.GPGETNUNIFORMI64VARB)(getProcAddr("glGetnUniformi64vARB")) + gpGetnUniformiv = (C.GPGETNUNIFORMIV)(getProcAddr("glGetnUniformiv")) + gpGetnUniformivARB = (C.GPGETNUNIFORMIVARB)(getProcAddr("glGetnUniformivARB")) + gpGetnUniformivKHR = (C.GPGETNUNIFORMIVKHR)(getProcAddr("glGetnUniformivKHR")) + gpGetnUniformui64vARB = (C.GPGETNUNIFORMUI64VARB)(getProcAddr("glGetnUniformui64vARB")) + gpGetnUniformuiv = (C.GPGETNUNIFORMUIV)(getProcAddr("glGetnUniformuiv")) + gpGetnUniformuivARB = (C.GPGETNUNIFORMUIVARB)(getProcAddr("glGetnUniformuivARB")) + gpGetnUniformuivKHR = (C.GPGETNUNIFORMUIVKHR)(getProcAddr("glGetnUniformuivKHR")) + gpHint = (C.GPHINT)(getProcAddr("glHint")) + if gpHint == nil { + return errors.New("glHint") + } + gpIndexFormatNV = (C.GPINDEXFORMATNV)(getProcAddr("glIndexFormatNV")) + gpInsertEventMarkerEXT = (C.GPINSERTEVENTMARKEREXT)(getProcAddr("glInsertEventMarkerEXT")) + gpInterpolatePathsNV = (C.GPINTERPOLATEPATHSNV)(getProcAddr("glInterpolatePathsNV")) + gpInvalidateBufferData = (C.GPINVALIDATEBUFFERDATA)(getProcAddr("glInvalidateBufferData")) + gpInvalidateBufferSubData = (C.GPINVALIDATEBUFFERSUBDATA)(getProcAddr("glInvalidateBufferSubData")) + gpInvalidateFramebuffer = (C.GPINVALIDATEFRAMEBUFFER)(getProcAddr("glInvalidateFramebuffer")) + gpInvalidateNamedFramebufferData = (C.GPINVALIDATENAMEDFRAMEBUFFERDATA)(getProcAddr("glInvalidateNamedFramebufferData")) + gpInvalidateNamedFramebufferSubData = (C.GPINVALIDATENAMEDFRAMEBUFFERSUBDATA)(getProcAddr("glInvalidateNamedFramebufferSubData")) + gpInvalidateSubFramebuffer = (C.GPINVALIDATESUBFRAMEBUFFER)(getProcAddr("glInvalidateSubFramebuffer")) + gpInvalidateTexImage = (C.GPINVALIDATETEXIMAGE)(getProcAddr("glInvalidateTexImage")) + gpInvalidateTexSubImage = (C.GPINVALIDATETEXSUBIMAGE)(getProcAddr("glInvalidateTexSubImage")) + gpIsBuffer = (C.GPISBUFFER)(getProcAddr("glIsBuffer")) + if gpIsBuffer == nil { + return errors.New("glIsBuffer") + } + gpIsBufferResidentNV = (C.GPISBUFFERRESIDENTNV)(getProcAddr("glIsBufferResidentNV")) + gpIsCommandListNV = (C.GPISCOMMANDLISTNV)(getProcAddr("glIsCommandListNV")) + gpIsEnabled = (C.GPISENABLED)(getProcAddr("glIsEnabled")) + if gpIsEnabled == nil { + return errors.New("glIsEnabled") + } + gpIsEnabledIndexedEXT = (C.GPISENABLEDINDEXEDEXT)(getProcAddr("glIsEnabledIndexedEXT")) + gpIsEnabledi = (C.GPISENABLEDI)(getProcAddr("glIsEnabledi")) + if gpIsEnabledi == nil { + return errors.New("glIsEnabledi") + } + gpIsFramebuffer = (C.GPISFRAMEBUFFER)(getProcAddr("glIsFramebuffer")) + if gpIsFramebuffer == nil { + return errors.New("glIsFramebuffer") + } + gpIsImageHandleResidentARB = (C.GPISIMAGEHANDLERESIDENTARB)(getProcAddr("glIsImageHandleResidentARB")) + gpIsImageHandleResidentNV = (C.GPISIMAGEHANDLERESIDENTNV)(getProcAddr("glIsImageHandleResidentNV")) + gpIsNamedBufferResidentNV = (C.GPISNAMEDBUFFERRESIDENTNV)(getProcAddr("glIsNamedBufferResidentNV")) + gpIsNamedStringARB = (C.GPISNAMEDSTRINGARB)(getProcAddr("glIsNamedStringARB")) + gpIsPathNV = (C.GPISPATHNV)(getProcAddr("glIsPathNV")) + gpIsPointInFillPathNV = (C.GPISPOINTINFILLPATHNV)(getProcAddr("glIsPointInFillPathNV")) + gpIsPointInStrokePathNV = (C.GPISPOINTINSTROKEPATHNV)(getProcAddr("glIsPointInStrokePathNV")) + gpIsProgram = (C.GPISPROGRAM)(getProcAddr("glIsProgram")) + if gpIsProgram == nil { + return errors.New("glIsProgram") + } + gpIsProgramPipeline = (C.GPISPROGRAMPIPELINE)(getProcAddr("glIsProgramPipeline")) + gpIsProgramPipelineEXT = (C.GPISPROGRAMPIPELINEEXT)(getProcAddr("glIsProgramPipelineEXT")) + gpIsQuery = (C.GPISQUERY)(getProcAddr("glIsQuery")) + if gpIsQuery == nil { + return errors.New("glIsQuery") + } + gpIsRenderbuffer = (C.GPISRENDERBUFFER)(getProcAddr("glIsRenderbuffer")) + if gpIsRenderbuffer == nil { + return errors.New("glIsRenderbuffer") + } + gpIsSampler = (C.GPISSAMPLER)(getProcAddr("glIsSampler")) + if gpIsSampler == nil { + return errors.New("glIsSampler") + } + gpIsShader = (C.GPISSHADER)(getProcAddr("glIsShader")) + if gpIsShader == nil { + return errors.New("glIsShader") + } + gpIsStateNV = (C.GPISSTATENV)(getProcAddr("glIsStateNV")) + gpIsSync = (C.GPISSYNC)(getProcAddr("glIsSync")) + if gpIsSync == nil { + return errors.New("glIsSync") + } + gpIsTexture = (C.GPISTEXTURE)(getProcAddr("glIsTexture")) + if gpIsTexture == nil { + return errors.New("glIsTexture") + } + gpIsTextureHandleResidentARB = (C.GPISTEXTUREHANDLERESIDENTARB)(getProcAddr("glIsTextureHandleResidentARB")) + gpIsTextureHandleResidentNV = (C.GPISTEXTUREHANDLERESIDENTNV)(getProcAddr("glIsTextureHandleResidentNV")) + gpIsTransformFeedback = (C.GPISTRANSFORMFEEDBACK)(getProcAddr("glIsTransformFeedback")) + gpIsVertexArray = (C.GPISVERTEXARRAY)(getProcAddr("glIsVertexArray")) + if gpIsVertexArray == nil { + return errors.New("glIsVertexArray") + } + gpLabelObjectEXT = (C.GPLABELOBJECTEXT)(getProcAddr("glLabelObjectEXT")) + gpLineWidth = (C.GPLINEWIDTH)(getProcAddr("glLineWidth")) + if gpLineWidth == nil { + return errors.New("glLineWidth") + } + gpLinkProgram = (C.GPLINKPROGRAM)(getProcAddr("glLinkProgram")) + if gpLinkProgram == nil { + return errors.New("glLinkProgram") + } + gpListDrawCommandsStatesClientNV = (C.GPLISTDRAWCOMMANDSSTATESCLIENTNV)(getProcAddr("glListDrawCommandsStatesClientNV")) + gpLogicOp = (C.GPLOGICOP)(getProcAddr("glLogicOp")) + if gpLogicOp == nil { + return errors.New("glLogicOp") + } + gpMakeBufferNonResidentNV = (C.GPMAKEBUFFERNONRESIDENTNV)(getProcAddr("glMakeBufferNonResidentNV")) + gpMakeBufferResidentNV = (C.GPMAKEBUFFERRESIDENTNV)(getProcAddr("glMakeBufferResidentNV")) + gpMakeImageHandleNonResidentARB = (C.GPMAKEIMAGEHANDLENONRESIDENTARB)(getProcAddr("glMakeImageHandleNonResidentARB")) + gpMakeImageHandleNonResidentNV = (C.GPMAKEIMAGEHANDLENONRESIDENTNV)(getProcAddr("glMakeImageHandleNonResidentNV")) + gpMakeImageHandleResidentARB = (C.GPMAKEIMAGEHANDLERESIDENTARB)(getProcAddr("glMakeImageHandleResidentARB")) + gpMakeImageHandleResidentNV = (C.GPMAKEIMAGEHANDLERESIDENTNV)(getProcAddr("glMakeImageHandleResidentNV")) + gpMakeNamedBufferNonResidentNV = (C.GPMAKENAMEDBUFFERNONRESIDENTNV)(getProcAddr("glMakeNamedBufferNonResidentNV")) + gpMakeNamedBufferResidentNV = (C.GPMAKENAMEDBUFFERRESIDENTNV)(getProcAddr("glMakeNamedBufferResidentNV")) + gpMakeTextureHandleNonResidentARB = (C.GPMAKETEXTUREHANDLENONRESIDENTARB)(getProcAddr("glMakeTextureHandleNonResidentARB")) + gpMakeTextureHandleNonResidentNV = (C.GPMAKETEXTUREHANDLENONRESIDENTNV)(getProcAddr("glMakeTextureHandleNonResidentNV")) + gpMakeTextureHandleResidentARB = (C.GPMAKETEXTUREHANDLERESIDENTARB)(getProcAddr("glMakeTextureHandleResidentARB")) + gpMakeTextureHandleResidentNV = (C.GPMAKETEXTUREHANDLERESIDENTNV)(getProcAddr("glMakeTextureHandleResidentNV")) + gpMapBuffer = (C.GPMAPBUFFER)(getProcAddr("glMapBuffer")) + if gpMapBuffer == nil { + return errors.New("glMapBuffer") + } + gpMapBufferRange = (C.GPMAPBUFFERRANGE)(getProcAddr("glMapBufferRange")) + if gpMapBufferRange == nil { + return errors.New("glMapBufferRange") + } + gpMapNamedBuffer = (C.GPMAPNAMEDBUFFER)(getProcAddr("glMapNamedBuffer")) + gpMapNamedBufferEXT = (C.GPMAPNAMEDBUFFEREXT)(getProcAddr("glMapNamedBufferEXT")) + gpMapNamedBufferRange = (C.GPMAPNAMEDBUFFERRANGE)(getProcAddr("glMapNamedBufferRange")) + gpMapNamedBufferRangeEXT = (C.GPMAPNAMEDBUFFERRANGEEXT)(getProcAddr("glMapNamedBufferRangeEXT")) + gpMatrixFrustumEXT = (C.GPMATRIXFRUSTUMEXT)(getProcAddr("glMatrixFrustumEXT")) + gpMatrixLoad3x2fNV = (C.GPMATRIXLOAD3X2FNV)(getProcAddr("glMatrixLoad3x2fNV")) + gpMatrixLoad3x3fNV = (C.GPMATRIXLOAD3X3FNV)(getProcAddr("glMatrixLoad3x3fNV")) + gpMatrixLoadIdentityEXT = (C.GPMATRIXLOADIDENTITYEXT)(getProcAddr("glMatrixLoadIdentityEXT")) + gpMatrixLoadTranspose3x3fNV = (C.GPMATRIXLOADTRANSPOSE3X3FNV)(getProcAddr("glMatrixLoadTranspose3x3fNV")) + gpMatrixLoadTransposedEXT = (C.GPMATRIXLOADTRANSPOSEDEXT)(getProcAddr("glMatrixLoadTransposedEXT")) + gpMatrixLoadTransposefEXT = (C.GPMATRIXLOADTRANSPOSEFEXT)(getProcAddr("glMatrixLoadTransposefEXT")) + gpMatrixLoaddEXT = (C.GPMATRIXLOADDEXT)(getProcAddr("glMatrixLoaddEXT")) + gpMatrixLoadfEXT = (C.GPMATRIXLOADFEXT)(getProcAddr("glMatrixLoadfEXT")) + gpMatrixMult3x2fNV = (C.GPMATRIXMULT3X2FNV)(getProcAddr("glMatrixMult3x2fNV")) + gpMatrixMult3x3fNV = (C.GPMATRIXMULT3X3FNV)(getProcAddr("glMatrixMult3x3fNV")) + gpMatrixMultTranspose3x3fNV = (C.GPMATRIXMULTTRANSPOSE3X3FNV)(getProcAddr("glMatrixMultTranspose3x3fNV")) + gpMatrixMultTransposedEXT = (C.GPMATRIXMULTTRANSPOSEDEXT)(getProcAddr("glMatrixMultTransposedEXT")) + gpMatrixMultTransposefEXT = (C.GPMATRIXMULTTRANSPOSEFEXT)(getProcAddr("glMatrixMultTransposefEXT")) + gpMatrixMultdEXT = (C.GPMATRIXMULTDEXT)(getProcAddr("glMatrixMultdEXT")) + gpMatrixMultfEXT = (C.GPMATRIXMULTFEXT)(getProcAddr("glMatrixMultfEXT")) + gpMatrixOrthoEXT = (C.GPMATRIXORTHOEXT)(getProcAddr("glMatrixOrthoEXT")) + gpMatrixPopEXT = (C.GPMATRIXPOPEXT)(getProcAddr("glMatrixPopEXT")) + gpMatrixPushEXT = (C.GPMATRIXPUSHEXT)(getProcAddr("glMatrixPushEXT")) + gpMatrixRotatedEXT = (C.GPMATRIXROTATEDEXT)(getProcAddr("glMatrixRotatedEXT")) + gpMatrixRotatefEXT = (C.GPMATRIXROTATEFEXT)(getProcAddr("glMatrixRotatefEXT")) + gpMatrixScaledEXT = (C.GPMATRIXSCALEDEXT)(getProcAddr("glMatrixScaledEXT")) + gpMatrixScalefEXT = (C.GPMATRIXSCALEFEXT)(getProcAddr("glMatrixScalefEXT")) + gpMatrixTranslatedEXT = (C.GPMATRIXTRANSLATEDEXT)(getProcAddr("glMatrixTranslatedEXT")) + gpMatrixTranslatefEXT = (C.GPMATRIXTRANSLATEFEXT)(getProcAddr("glMatrixTranslatefEXT")) + gpMaxShaderCompilerThreadsARB = (C.GPMAXSHADERCOMPILERTHREADSARB)(getProcAddr("glMaxShaderCompilerThreadsARB")) + gpMaxShaderCompilerThreadsKHR = (C.GPMAXSHADERCOMPILERTHREADSKHR)(getProcAddr("glMaxShaderCompilerThreadsKHR")) + gpMemoryBarrier = (C.GPMEMORYBARRIER)(getProcAddr("glMemoryBarrier")) + gpMemoryBarrierByRegion = (C.GPMEMORYBARRIERBYREGION)(getProcAddr("glMemoryBarrierByRegion")) + gpMinSampleShadingARB = (C.GPMINSAMPLESHADINGARB)(getProcAddr("glMinSampleShadingARB")) + gpMultiDrawArrays = (C.GPMULTIDRAWARRAYS)(getProcAddr("glMultiDrawArrays")) + if gpMultiDrawArrays == nil { + return errors.New("glMultiDrawArrays") + } + gpMultiDrawArraysIndirect = (C.GPMULTIDRAWARRAYSINDIRECT)(getProcAddr("glMultiDrawArraysIndirect")) + gpMultiDrawArraysIndirectBindlessCountNV = (C.GPMULTIDRAWARRAYSINDIRECTBINDLESSCOUNTNV)(getProcAddr("glMultiDrawArraysIndirectBindlessCountNV")) + gpMultiDrawArraysIndirectBindlessNV = (C.GPMULTIDRAWARRAYSINDIRECTBINDLESSNV)(getProcAddr("glMultiDrawArraysIndirectBindlessNV")) + gpMultiDrawArraysIndirectCountARB = (C.GPMULTIDRAWARRAYSINDIRECTCOUNTARB)(getProcAddr("glMultiDrawArraysIndirectCountARB")) + gpMultiDrawElements = (C.GPMULTIDRAWELEMENTS)(getProcAddr("glMultiDrawElements")) + if gpMultiDrawElements == nil { + return errors.New("glMultiDrawElements") + } + gpMultiDrawElementsBaseVertex = (C.GPMULTIDRAWELEMENTSBASEVERTEX)(getProcAddr("glMultiDrawElementsBaseVertex")) + if gpMultiDrawElementsBaseVertex == nil { + return errors.New("glMultiDrawElementsBaseVertex") + } + gpMultiDrawElementsIndirect = (C.GPMULTIDRAWELEMENTSINDIRECT)(getProcAddr("glMultiDrawElementsIndirect")) + gpMultiDrawElementsIndirectBindlessCountNV = (C.GPMULTIDRAWELEMENTSINDIRECTBINDLESSCOUNTNV)(getProcAddr("glMultiDrawElementsIndirectBindlessCountNV")) + gpMultiDrawElementsIndirectBindlessNV = (C.GPMULTIDRAWELEMENTSINDIRECTBINDLESSNV)(getProcAddr("glMultiDrawElementsIndirectBindlessNV")) + gpMultiDrawElementsIndirectCountARB = (C.GPMULTIDRAWELEMENTSINDIRECTCOUNTARB)(getProcAddr("glMultiDrawElementsIndirectCountARB")) + gpMultiDrawMeshTasksIndirectCountNV = (C.GPMULTIDRAWMESHTASKSINDIRECTCOUNTNV)(getProcAddr("glMultiDrawMeshTasksIndirectCountNV")) + gpMultiDrawMeshTasksIndirectNV = (C.GPMULTIDRAWMESHTASKSINDIRECTNV)(getProcAddr("glMultiDrawMeshTasksIndirectNV")) + gpMultiTexBufferEXT = (C.GPMULTITEXBUFFEREXT)(getProcAddr("glMultiTexBufferEXT")) + gpMultiTexCoordPointerEXT = (C.GPMULTITEXCOORDPOINTEREXT)(getProcAddr("glMultiTexCoordPointerEXT")) + gpMultiTexEnvfEXT = (C.GPMULTITEXENVFEXT)(getProcAddr("glMultiTexEnvfEXT")) + gpMultiTexEnvfvEXT = (C.GPMULTITEXENVFVEXT)(getProcAddr("glMultiTexEnvfvEXT")) + gpMultiTexEnviEXT = (C.GPMULTITEXENVIEXT)(getProcAddr("glMultiTexEnviEXT")) + gpMultiTexEnvivEXT = (C.GPMULTITEXENVIVEXT)(getProcAddr("glMultiTexEnvivEXT")) + gpMultiTexGendEXT = (C.GPMULTITEXGENDEXT)(getProcAddr("glMultiTexGendEXT")) + gpMultiTexGendvEXT = (C.GPMULTITEXGENDVEXT)(getProcAddr("glMultiTexGendvEXT")) + gpMultiTexGenfEXT = (C.GPMULTITEXGENFEXT)(getProcAddr("glMultiTexGenfEXT")) + gpMultiTexGenfvEXT = (C.GPMULTITEXGENFVEXT)(getProcAddr("glMultiTexGenfvEXT")) + gpMultiTexGeniEXT = (C.GPMULTITEXGENIEXT)(getProcAddr("glMultiTexGeniEXT")) + gpMultiTexGenivEXT = (C.GPMULTITEXGENIVEXT)(getProcAddr("glMultiTexGenivEXT")) + gpMultiTexImage1DEXT = (C.GPMULTITEXIMAGE1DEXT)(getProcAddr("glMultiTexImage1DEXT")) + gpMultiTexImage2DEXT = (C.GPMULTITEXIMAGE2DEXT)(getProcAddr("glMultiTexImage2DEXT")) + gpMultiTexImage3DEXT = (C.GPMULTITEXIMAGE3DEXT)(getProcAddr("glMultiTexImage3DEXT")) + gpMultiTexParameterIivEXT = (C.GPMULTITEXPARAMETERIIVEXT)(getProcAddr("glMultiTexParameterIivEXT")) + gpMultiTexParameterIuivEXT = (C.GPMULTITEXPARAMETERIUIVEXT)(getProcAddr("glMultiTexParameterIuivEXT")) + gpMultiTexParameterfEXT = (C.GPMULTITEXPARAMETERFEXT)(getProcAddr("glMultiTexParameterfEXT")) + gpMultiTexParameterfvEXT = (C.GPMULTITEXPARAMETERFVEXT)(getProcAddr("glMultiTexParameterfvEXT")) + gpMultiTexParameteriEXT = (C.GPMULTITEXPARAMETERIEXT)(getProcAddr("glMultiTexParameteriEXT")) + gpMultiTexParameterivEXT = (C.GPMULTITEXPARAMETERIVEXT)(getProcAddr("glMultiTexParameterivEXT")) + gpMultiTexRenderbufferEXT = (C.GPMULTITEXRENDERBUFFEREXT)(getProcAddr("glMultiTexRenderbufferEXT")) + gpMultiTexSubImage1DEXT = (C.GPMULTITEXSUBIMAGE1DEXT)(getProcAddr("glMultiTexSubImage1DEXT")) + gpMultiTexSubImage2DEXT = (C.GPMULTITEXSUBIMAGE2DEXT)(getProcAddr("glMultiTexSubImage2DEXT")) + gpMultiTexSubImage3DEXT = (C.GPMULTITEXSUBIMAGE3DEXT)(getProcAddr("glMultiTexSubImage3DEXT")) + gpNamedBufferAttachMemoryNV = (C.GPNAMEDBUFFERATTACHMEMORYNV)(getProcAddr("glNamedBufferAttachMemoryNV")) + gpNamedBufferData = (C.GPNAMEDBUFFERDATA)(getProcAddr("glNamedBufferData")) + gpNamedBufferDataEXT = (C.GPNAMEDBUFFERDATAEXT)(getProcAddr("glNamedBufferDataEXT")) + gpNamedBufferPageCommitmentARB = (C.GPNAMEDBUFFERPAGECOMMITMENTARB)(getProcAddr("glNamedBufferPageCommitmentARB")) + gpNamedBufferPageCommitmentEXT = (C.GPNAMEDBUFFERPAGECOMMITMENTEXT)(getProcAddr("glNamedBufferPageCommitmentEXT")) + gpNamedBufferPageCommitmentMemNV = (C.GPNAMEDBUFFERPAGECOMMITMENTMEMNV)(getProcAddr("glNamedBufferPageCommitmentMemNV")) + gpNamedBufferStorage = (C.GPNAMEDBUFFERSTORAGE)(getProcAddr("glNamedBufferStorage")) + gpNamedBufferStorageEXT = (C.GPNAMEDBUFFERSTORAGEEXT)(getProcAddr("glNamedBufferStorageEXT")) + gpNamedBufferSubData = (C.GPNAMEDBUFFERSUBDATA)(getProcAddr("glNamedBufferSubData")) + gpNamedBufferSubDataEXT = (C.GPNAMEDBUFFERSUBDATAEXT)(getProcAddr("glNamedBufferSubDataEXT")) + gpNamedCopyBufferSubDataEXT = (C.GPNAMEDCOPYBUFFERSUBDATAEXT)(getProcAddr("glNamedCopyBufferSubDataEXT")) + gpNamedFramebufferDrawBuffer = (C.GPNAMEDFRAMEBUFFERDRAWBUFFER)(getProcAddr("glNamedFramebufferDrawBuffer")) + gpNamedFramebufferDrawBuffers = (C.GPNAMEDFRAMEBUFFERDRAWBUFFERS)(getProcAddr("glNamedFramebufferDrawBuffers")) + gpNamedFramebufferParameteri = (C.GPNAMEDFRAMEBUFFERPARAMETERI)(getProcAddr("glNamedFramebufferParameteri")) + gpNamedFramebufferParameteriEXT = (C.GPNAMEDFRAMEBUFFERPARAMETERIEXT)(getProcAddr("glNamedFramebufferParameteriEXT")) + gpNamedFramebufferReadBuffer = (C.GPNAMEDFRAMEBUFFERREADBUFFER)(getProcAddr("glNamedFramebufferReadBuffer")) + gpNamedFramebufferRenderbuffer = (C.GPNAMEDFRAMEBUFFERRENDERBUFFER)(getProcAddr("glNamedFramebufferRenderbuffer")) + gpNamedFramebufferRenderbufferEXT = (C.GPNAMEDFRAMEBUFFERRENDERBUFFEREXT)(getProcAddr("glNamedFramebufferRenderbufferEXT")) + gpNamedFramebufferSampleLocationsfvARB = (C.GPNAMEDFRAMEBUFFERSAMPLELOCATIONSFVARB)(getProcAddr("glNamedFramebufferSampleLocationsfvARB")) + gpNamedFramebufferSampleLocationsfvNV = (C.GPNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNV)(getProcAddr("glNamedFramebufferSampleLocationsfvNV")) + gpNamedFramebufferTexture = (C.GPNAMEDFRAMEBUFFERTEXTURE)(getProcAddr("glNamedFramebufferTexture")) + gpNamedFramebufferTexture1DEXT = (C.GPNAMEDFRAMEBUFFERTEXTURE1DEXT)(getProcAddr("glNamedFramebufferTexture1DEXT")) + gpNamedFramebufferTexture2DEXT = (C.GPNAMEDFRAMEBUFFERTEXTURE2DEXT)(getProcAddr("glNamedFramebufferTexture2DEXT")) + gpNamedFramebufferTexture3DEXT = (C.GPNAMEDFRAMEBUFFERTEXTURE3DEXT)(getProcAddr("glNamedFramebufferTexture3DEXT")) + gpNamedFramebufferTextureEXT = (C.GPNAMEDFRAMEBUFFERTEXTUREEXT)(getProcAddr("glNamedFramebufferTextureEXT")) + gpNamedFramebufferTextureFaceEXT = (C.GPNAMEDFRAMEBUFFERTEXTUREFACEEXT)(getProcAddr("glNamedFramebufferTextureFaceEXT")) + gpNamedFramebufferTextureLayer = (C.GPNAMEDFRAMEBUFFERTEXTURELAYER)(getProcAddr("glNamedFramebufferTextureLayer")) + gpNamedFramebufferTextureLayerEXT = (C.GPNAMEDFRAMEBUFFERTEXTURELAYEREXT)(getProcAddr("glNamedFramebufferTextureLayerEXT")) + gpNamedProgramLocalParameter4dEXT = (C.GPNAMEDPROGRAMLOCALPARAMETER4DEXT)(getProcAddr("glNamedProgramLocalParameter4dEXT")) + gpNamedProgramLocalParameter4dvEXT = (C.GPNAMEDPROGRAMLOCALPARAMETER4DVEXT)(getProcAddr("glNamedProgramLocalParameter4dvEXT")) + gpNamedProgramLocalParameter4fEXT = (C.GPNAMEDPROGRAMLOCALPARAMETER4FEXT)(getProcAddr("glNamedProgramLocalParameter4fEXT")) + gpNamedProgramLocalParameter4fvEXT = (C.GPNAMEDPROGRAMLOCALPARAMETER4FVEXT)(getProcAddr("glNamedProgramLocalParameter4fvEXT")) + gpNamedProgramLocalParameterI4iEXT = (C.GPNAMEDPROGRAMLOCALPARAMETERI4IEXT)(getProcAddr("glNamedProgramLocalParameterI4iEXT")) + gpNamedProgramLocalParameterI4ivEXT = (C.GPNAMEDPROGRAMLOCALPARAMETERI4IVEXT)(getProcAddr("glNamedProgramLocalParameterI4ivEXT")) + gpNamedProgramLocalParameterI4uiEXT = (C.GPNAMEDPROGRAMLOCALPARAMETERI4UIEXT)(getProcAddr("glNamedProgramLocalParameterI4uiEXT")) + gpNamedProgramLocalParameterI4uivEXT = (C.GPNAMEDPROGRAMLOCALPARAMETERI4UIVEXT)(getProcAddr("glNamedProgramLocalParameterI4uivEXT")) + gpNamedProgramLocalParameters4fvEXT = (C.GPNAMEDPROGRAMLOCALPARAMETERS4FVEXT)(getProcAddr("glNamedProgramLocalParameters4fvEXT")) + gpNamedProgramLocalParametersI4ivEXT = (C.GPNAMEDPROGRAMLOCALPARAMETERSI4IVEXT)(getProcAddr("glNamedProgramLocalParametersI4ivEXT")) + gpNamedProgramLocalParametersI4uivEXT = (C.GPNAMEDPROGRAMLOCALPARAMETERSI4UIVEXT)(getProcAddr("glNamedProgramLocalParametersI4uivEXT")) + gpNamedProgramStringEXT = (C.GPNAMEDPROGRAMSTRINGEXT)(getProcAddr("glNamedProgramStringEXT")) + gpNamedRenderbufferStorage = (C.GPNAMEDRENDERBUFFERSTORAGE)(getProcAddr("glNamedRenderbufferStorage")) + gpNamedRenderbufferStorageEXT = (C.GPNAMEDRENDERBUFFERSTORAGEEXT)(getProcAddr("glNamedRenderbufferStorageEXT")) + gpNamedRenderbufferStorageMultisample = (C.GPNAMEDRENDERBUFFERSTORAGEMULTISAMPLE)(getProcAddr("glNamedRenderbufferStorageMultisample")) + gpNamedRenderbufferStorageMultisampleAdvancedAMD = (C.GPNAMEDRENDERBUFFERSTORAGEMULTISAMPLEADVANCEDAMD)(getProcAddr("glNamedRenderbufferStorageMultisampleAdvancedAMD")) + gpNamedRenderbufferStorageMultisampleCoverageEXT = (C.GPNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXT)(getProcAddr("glNamedRenderbufferStorageMultisampleCoverageEXT")) + gpNamedRenderbufferStorageMultisampleEXT = (C.GPNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXT)(getProcAddr("glNamedRenderbufferStorageMultisampleEXT")) + gpNamedStringARB = (C.GPNAMEDSTRINGARB)(getProcAddr("glNamedStringARB")) + gpNormalFormatNV = (C.GPNORMALFORMATNV)(getProcAddr("glNormalFormatNV")) + gpObjectLabel = (C.GPOBJECTLABEL)(getProcAddr("glObjectLabel")) + gpObjectLabelKHR = (C.GPOBJECTLABELKHR)(getProcAddr("glObjectLabelKHR")) + gpObjectPtrLabel = (C.GPOBJECTPTRLABEL)(getProcAddr("glObjectPtrLabel")) + gpObjectPtrLabelKHR = (C.GPOBJECTPTRLABELKHR)(getProcAddr("glObjectPtrLabelKHR")) + gpPatchParameterfv = (C.GPPATCHPARAMETERFV)(getProcAddr("glPatchParameterfv")) + gpPatchParameteri = (C.GPPATCHPARAMETERI)(getProcAddr("glPatchParameteri")) + gpPathCommandsNV = (C.GPPATHCOMMANDSNV)(getProcAddr("glPathCommandsNV")) + gpPathCoordsNV = (C.GPPATHCOORDSNV)(getProcAddr("glPathCoordsNV")) + gpPathCoverDepthFuncNV = (C.GPPATHCOVERDEPTHFUNCNV)(getProcAddr("glPathCoverDepthFuncNV")) + gpPathDashArrayNV = (C.GPPATHDASHARRAYNV)(getProcAddr("glPathDashArrayNV")) + gpPathGlyphIndexArrayNV = (C.GPPATHGLYPHINDEXARRAYNV)(getProcAddr("glPathGlyphIndexArrayNV")) + gpPathGlyphIndexRangeNV = (C.GPPATHGLYPHINDEXRANGENV)(getProcAddr("glPathGlyphIndexRangeNV")) + gpPathGlyphRangeNV = (C.GPPATHGLYPHRANGENV)(getProcAddr("glPathGlyphRangeNV")) + gpPathGlyphsNV = (C.GPPATHGLYPHSNV)(getProcAddr("glPathGlyphsNV")) + gpPathMemoryGlyphIndexArrayNV = (C.GPPATHMEMORYGLYPHINDEXARRAYNV)(getProcAddr("glPathMemoryGlyphIndexArrayNV")) + gpPathParameterfNV = (C.GPPATHPARAMETERFNV)(getProcAddr("glPathParameterfNV")) + gpPathParameterfvNV = (C.GPPATHPARAMETERFVNV)(getProcAddr("glPathParameterfvNV")) + gpPathParameteriNV = (C.GPPATHPARAMETERINV)(getProcAddr("glPathParameteriNV")) + gpPathParameterivNV = (C.GPPATHPARAMETERIVNV)(getProcAddr("glPathParameterivNV")) + gpPathStencilDepthOffsetNV = (C.GPPATHSTENCILDEPTHOFFSETNV)(getProcAddr("glPathStencilDepthOffsetNV")) + gpPathStencilFuncNV = (C.GPPATHSTENCILFUNCNV)(getProcAddr("glPathStencilFuncNV")) + gpPathStringNV = (C.GPPATHSTRINGNV)(getProcAddr("glPathStringNV")) + gpPathSubCommandsNV = (C.GPPATHSUBCOMMANDSNV)(getProcAddr("glPathSubCommandsNV")) + gpPathSubCoordsNV = (C.GPPATHSUBCOORDSNV)(getProcAddr("glPathSubCoordsNV")) + gpPauseTransformFeedback = (C.GPPAUSETRANSFORMFEEDBACK)(getProcAddr("glPauseTransformFeedback")) + gpPixelStoref = (C.GPPIXELSTOREF)(getProcAddr("glPixelStoref")) + if gpPixelStoref == nil { + return errors.New("glPixelStoref") + } + gpPixelStorei = (C.GPPIXELSTOREI)(getProcAddr("glPixelStorei")) + if gpPixelStorei == nil { + return errors.New("glPixelStorei") + } + gpPointAlongPathNV = (C.GPPOINTALONGPATHNV)(getProcAddr("glPointAlongPathNV")) + gpPointParameterf = (C.GPPOINTPARAMETERF)(getProcAddr("glPointParameterf")) + if gpPointParameterf == nil { + return errors.New("glPointParameterf") + } + gpPointParameterfv = (C.GPPOINTPARAMETERFV)(getProcAddr("glPointParameterfv")) + if gpPointParameterfv == nil { + return errors.New("glPointParameterfv") + } + gpPointParameteri = (C.GPPOINTPARAMETERI)(getProcAddr("glPointParameteri")) + if gpPointParameteri == nil { + return errors.New("glPointParameteri") + } + gpPointParameteriv = (C.GPPOINTPARAMETERIV)(getProcAddr("glPointParameteriv")) + if gpPointParameteriv == nil { + return errors.New("glPointParameteriv") + } + gpPointSize = (C.GPPOINTSIZE)(getProcAddr("glPointSize")) + if gpPointSize == nil { + return errors.New("glPointSize") + } + gpPolygonMode = (C.GPPOLYGONMODE)(getProcAddr("glPolygonMode")) + if gpPolygonMode == nil { + return errors.New("glPolygonMode") + } + gpPolygonOffset = (C.GPPOLYGONOFFSET)(getProcAddr("glPolygonOffset")) + if gpPolygonOffset == nil { + return errors.New("glPolygonOffset") + } + gpPolygonOffsetClamp = (C.GPPOLYGONOFFSETCLAMP)(getProcAddr("glPolygonOffsetClamp")) + gpPolygonOffsetClampEXT = (C.GPPOLYGONOFFSETCLAMPEXT)(getProcAddr("glPolygonOffsetClampEXT")) + gpPopDebugGroup = (C.GPPOPDEBUGGROUP)(getProcAddr("glPopDebugGroup")) + gpPopDebugGroupKHR = (C.GPPOPDEBUGGROUPKHR)(getProcAddr("glPopDebugGroupKHR")) + gpPopGroupMarkerEXT = (C.GPPOPGROUPMARKEREXT)(getProcAddr("glPopGroupMarkerEXT")) + gpPrimitiveBoundingBoxARB = (C.GPPRIMITIVEBOUNDINGBOXARB)(getProcAddr("glPrimitiveBoundingBoxARB")) + gpPrimitiveRestartIndex = (C.GPPRIMITIVERESTARTINDEX)(getProcAddr("glPrimitiveRestartIndex")) + if gpPrimitiveRestartIndex == nil { + return errors.New("glPrimitiveRestartIndex") + } + gpProgramBinary = (C.GPPROGRAMBINARY)(getProcAddr("glProgramBinary")) + gpProgramParameteri = (C.GPPROGRAMPARAMETERI)(getProcAddr("glProgramParameteri")) + gpProgramParameteriARB = (C.GPPROGRAMPARAMETERIARB)(getProcAddr("glProgramParameteriARB")) + gpProgramParameteriEXT = (C.GPPROGRAMPARAMETERIEXT)(getProcAddr("glProgramParameteriEXT")) + gpProgramPathFragmentInputGenNV = (C.GPPROGRAMPATHFRAGMENTINPUTGENNV)(getProcAddr("glProgramPathFragmentInputGenNV")) + gpProgramUniform1d = (C.GPPROGRAMUNIFORM1D)(getProcAddr("glProgramUniform1d")) + gpProgramUniform1dEXT = (C.GPPROGRAMUNIFORM1DEXT)(getProcAddr("glProgramUniform1dEXT")) + gpProgramUniform1dv = (C.GPPROGRAMUNIFORM1DV)(getProcAddr("glProgramUniform1dv")) + gpProgramUniform1dvEXT = (C.GPPROGRAMUNIFORM1DVEXT)(getProcAddr("glProgramUniform1dvEXT")) + gpProgramUniform1f = (C.GPPROGRAMUNIFORM1F)(getProcAddr("glProgramUniform1f")) + gpProgramUniform1fEXT = (C.GPPROGRAMUNIFORM1FEXT)(getProcAddr("glProgramUniform1fEXT")) + gpProgramUniform1fv = (C.GPPROGRAMUNIFORM1FV)(getProcAddr("glProgramUniform1fv")) + gpProgramUniform1fvEXT = (C.GPPROGRAMUNIFORM1FVEXT)(getProcAddr("glProgramUniform1fvEXT")) + gpProgramUniform1i = (C.GPPROGRAMUNIFORM1I)(getProcAddr("glProgramUniform1i")) + gpProgramUniform1i64ARB = (C.GPPROGRAMUNIFORM1I64ARB)(getProcAddr("glProgramUniform1i64ARB")) + gpProgramUniform1i64NV = (C.GPPROGRAMUNIFORM1I64NV)(getProcAddr("glProgramUniform1i64NV")) + gpProgramUniform1i64vARB = (C.GPPROGRAMUNIFORM1I64VARB)(getProcAddr("glProgramUniform1i64vARB")) + gpProgramUniform1i64vNV = (C.GPPROGRAMUNIFORM1I64VNV)(getProcAddr("glProgramUniform1i64vNV")) + gpProgramUniform1iEXT = (C.GPPROGRAMUNIFORM1IEXT)(getProcAddr("glProgramUniform1iEXT")) + gpProgramUniform1iv = (C.GPPROGRAMUNIFORM1IV)(getProcAddr("glProgramUniform1iv")) + gpProgramUniform1ivEXT = (C.GPPROGRAMUNIFORM1IVEXT)(getProcAddr("glProgramUniform1ivEXT")) + gpProgramUniform1ui = (C.GPPROGRAMUNIFORM1UI)(getProcAddr("glProgramUniform1ui")) + gpProgramUniform1ui64ARB = (C.GPPROGRAMUNIFORM1UI64ARB)(getProcAddr("glProgramUniform1ui64ARB")) + gpProgramUniform1ui64NV = (C.GPPROGRAMUNIFORM1UI64NV)(getProcAddr("glProgramUniform1ui64NV")) + gpProgramUniform1ui64vARB = (C.GPPROGRAMUNIFORM1UI64VARB)(getProcAddr("glProgramUniform1ui64vARB")) + gpProgramUniform1ui64vNV = (C.GPPROGRAMUNIFORM1UI64VNV)(getProcAddr("glProgramUniform1ui64vNV")) + gpProgramUniform1uiEXT = (C.GPPROGRAMUNIFORM1UIEXT)(getProcAddr("glProgramUniform1uiEXT")) + gpProgramUniform1uiv = (C.GPPROGRAMUNIFORM1UIV)(getProcAddr("glProgramUniform1uiv")) + gpProgramUniform1uivEXT = (C.GPPROGRAMUNIFORM1UIVEXT)(getProcAddr("glProgramUniform1uivEXT")) + gpProgramUniform2d = (C.GPPROGRAMUNIFORM2D)(getProcAddr("glProgramUniform2d")) + gpProgramUniform2dEXT = (C.GPPROGRAMUNIFORM2DEXT)(getProcAddr("glProgramUniform2dEXT")) + gpProgramUniform2dv = (C.GPPROGRAMUNIFORM2DV)(getProcAddr("glProgramUniform2dv")) + gpProgramUniform2dvEXT = (C.GPPROGRAMUNIFORM2DVEXT)(getProcAddr("glProgramUniform2dvEXT")) + gpProgramUniform2f = (C.GPPROGRAMUNIFORM2F)(getProcAddr("glProgramUniform2f")) + gpProgramUniform2fEXT = (C.GPPROGRAMUNIFORM2FEXT)(getProcAddr("glProgramUniform2fEXT")) + gpProgramUniform2fv = (C.GPPROGRAMUNIFORM2FV)(getProcAddr("glProgramUniform2fv")) + gpProgramUniform2fvEXT = (C.GPPROGRAMUNIFORM2FVEXT)(getProcAddr("glProgramUniform2fvEXT")) + gpProgramUniform2i = (C.GPPROGRAMUNIFORM2I)(getProcAddr("glProgramUniform2i")) + gpProgramUniform2i64ARB = (C.GPPROGRAMUNIFORM2I64ARB)(getProcAddr("glProgramUniform2i64ARB")) + gpProgramUniform2i64NV = (C.GPPROGRAMUNIFORM2I64NV)(getProcAddr("glProgramUniform2i64NV")) + gpProgramUniform2i64vARB = (C.GPPROGRAMUNIFORM2I64VARB)(getProcAddr("glProgramUniform2i64vARB")) + gpProgramUniform2i64vNV = (C.GPPROGRAMUNIFORM2I64VNV)(getProcAddr("glProgramUniform2i64vNV")) + gpProgramUniform2iEXT = (C.GPPROGRAMUNIFORM2IEXT)(getProcAddr("glProgramUniform2iEXT")) + gpProgramUniform2iv = (C.GPPROGRAMUNIFORM2IV)(getProcAddr("glProgramUniform2iv")) + gpProgramUniform2ivEXT = (C.GPPROGRAMUNIFORM2IVEXT)(getProcAddr("glProgramUniform2ivEXT")) + gpProgramUniform2ui = (C.GPPROGRAMUNIFORM2UI)(getProcAddr("glProgramUniform2ui")) + gpProgramUniform2ui64ARB = (C.GPPROGRAMUNIFORM2UI64ARB)(getProcAddr("glProgramUniform2ui64ARB")) + gpProgramUniform2ui64NV = (C.GPPROGRAMUNIFORM2UI64NV)(getProcAddr("glProgramUniform2ui64NV")) + gpProgramUniform2ui64vARB = (C.GPPROGRAMUNIFORM2UI64VARB)(getProcAddr("glProgramUniform2ui64vARB")) + gpProgramUniform2ui64vNV = (C.GPPROGRAMUNIFORM2UI64VNV)(getProcAddr("glProgramUniform2ui64vNV")) + gpProgramUniform2uiEXT = (C.GPPROGRAMUNIFORM2UIEXT)(getProcAddr("glProgramUniform2uiEXT")) + gpProgramUniform2uiv = (C.GPPROGRAMUNIFORM2UIV)(getProcAddr("glProgramUniform2uiv")) + gpProgramUniform2uivEXT = (C.GPPROGRAMUNIFORM2UIVEXT)(getProcAddr("glProgramUniform2uivEXT")) + gpProgramUniform3d = (C.GPPROGRAMUNIFORM3D)(getProcAddr("glProgramUniform3d")) + gpProgramUniform3dEXT = (C.GPPROGRAMUNIFORM3DEXT)(getProcAddr("glProgramUniform3dEXT")) + gpProgramUniform3dv = (C.GPPROGRAMUNIFORM3DV)(getProcAddr("glProgramUniform3dv")) + gpProgramUniform3dvEXT = (C.GPPROGRAMUNIFORM3DVEXT)(getProcAddr("glProgramUniform3dvEXT")) + gpProgramUniform3f = (C.GPPROGRAMUNIFORM3F)(getProcAddr("glProgramUniform3f")) + gpProgramUniform3fEXT = (C.GPPROGRAMUNIFORM3FEXT)(getProcAddr("glProgramUniform3fEXT")) + gpProgramUniform3fv = (C.GPPROGRAMUNIFORM3FV)(getProcAddr("glProgramUniform3fv")) + gpProgramUniform3fvEXT = (C.GPPROGRAMUNIFORM3FVEXT)(getProcAddr("glProgramUniform3fvEXT")) + gpProgramUniform3i = (C.GPPROGRAMUNIFORM3I)(getProcAddr("glProgramUniform3i")) + gpProgramUniform3i64ARB = (C.GPPROGRAMUNIFORM3I64ARB)(getProcAddr("glProgramUniform3i64ARB")) + gpProgramUniform3i64NV = (C.GPPROGRAMUNIFORM3I64NV)(getProcAddr("glProgramUniform3i64NV")) + gpProgramUniform3i64vARB = (C.GPPROGRAMUNIFORM3I64VARB)(getProcAddr("glProgramUniform3i64vARB")) + gpProgramUniform3i64vNV = (C.GPPROGRAMUNIFORM3I64VNV)(getProcAddr("glProgramUniform3i64vNV")) + gpProgramUniform3iEXT = (C.GPPROGRAMUNIFORM3IEXT)(getProcAddr("glProgramUniform3iEXT")) + gpProgramUniform3iv = (C.GPPROGRAMUNIFORM3IV)(getProcAddr("glProgramUniform3iv")) + gpProgramUniform3ivEXT = (C.GPPROGRAMUNIFORM3IVEXT)(getProcAddr("glProgramUniform3ivEXT")) + gpProgramUniform3ui = (C.GPPROGRAMUNIFORM3UI)(getProcAddr("glProgramUniform3ui")) + gpProgramUniform3ui64ARB = (C.GPPROGRAMUNIFORM3UI64ARB)(getProcAddr("glProgramUniform3ui64ARB")) + gpProgramUniform3ui64NV = (C.GPPROGRAMUNIFORM3UI64NV)(getProcAddr("glProgramUniform3ui64NV")) + gpProgramUniform3ui64vARB = (C.GPPROGRAMUNIFORM3UI64VARB)(getProcAddr("glProgramUniform3ui64vARB")) + gpProgramUniform3ui64vNV = (C.GPPROGRAMUNIFORM3UI64VNV)(getProcAddr("glProgramUniform3ui64vNV")) + gpProgramUniform3uiEXT = (C.GPPROGRAMUNIFORM3UIEXT)(getProcAddr("glProgramUniform3uiEXT")) + gpProgramUniform3uiv = (C.GPPROGRAMUNIFORM3UIV)(getProcAddr("glProgramUniform3uiv")) + gpProgramUniform3uivEXT = (C.GPPROGRAMUNIFORM3UIVEXT)(getProcAddr("glProgramUniform3uivEXT")) + gpProgramUniform4d = (C.GPPROGRAMUNIFORM4D)(getProcAddr("glProgramUniform4d")) + gpProgramUniform4dEXT = (C.GPPROGRAMUNIFORM4DEXT)(getProcAddr("glProgramUniform4dEXT")) + gpProgramUniform4dv = (C.GPPROGRAMUNIFORM4DV)(getProcAddr("glProgramUniform4dv")) + gpProgramUniform4dvEXT = (C.GPPROGRAMUNIFORM4DVEXT)(getProcAddr("glProgramUniform4dvEXT")) + gpProgramUniform4f = (C.GPPROGRAMUNIFORM4F)(getProcAddr("glProgramUniform4f")) + gpProgramUniform4fEXT = (C.GPPROGRAMUNIFORM4FEXT)(getProcAddr("glProgramUniform4fEXT")) + gpProgramUniform4fv = (C.GPPROGRAMUNIFORM4FV)(getProcAddr("glProgramUniform4fv")) + gpProgramUniform4fvEXT = (C.GPPROGRAMUNIFORM4FVEXT)(getProcAddr("glProgramUniform4fvEXT")) + gpProgramUniform4i = (C.GPPROGRAMUNIFORM4I)(getProcAddr("glProgramUniform4i")) + gpProgramUniform4i64ARB = (C.GPPROGRAMUNIFORM4I64ARB)(getProcAddr("glProgramUniform4i64ARB")) + gpProgramUniform4i64NV = (C.GPPROGRAMUNIFORM4I64NV)(getProcAddr("glProgramUniform4i64NV")) + gpProgramUniform4i64vARB = (C.GPPROGRAMUNIFORM4I64VARB)(getProcAddr("glProgramUniform4i64vARB")) + gpProgramUniform4i64vNV = (C.GPPROGRAMUNIFORM4I64VNV)(getProcAddr("glProgramUniform4i64vNV")) + gpProgramUniform4iEXT = (C.GPPROGRAMUNIFORM4IEXT)(getProcAddr("glProgramUniform4iEXT")) + gpProgramUniform4iv = (C.GPPROGRAMUNIFORM4IV)(getProcAddr("glProgramUniform4iv")) + gpProgramUniform4ivEXT = (C.GPPROGRAMUNIFORM4IVEXT)(getProcAddr("glProgramUniform4ivEXT")) + gpProgramUniform4ui = (C.GPPROGRAMUNIFORM4UI)(getProcAddr("glProgramUniform4ui")) + gpProgramUniform4ui64ARB = (C.GPPROGRAMUNIFORM4UI64ARB)(getProcAddr("glProgramUniform4ui64ARB")) + gpProgramUniform4ui64NV = (C.GPPROGRAMUNIFORM4UI64NV)(getProcAddr("glProgramUniform4ui64NV")) + gpProgramUniform4ui64vARB = (C.GPPROGRAMUNIFORM4UI64VARB)(getProcAddr("glProgramUniform4ui64vARB")) + gpProgramUniform4ui64vNV = (C.GPPROGRAMUNIFORM4UI64VNV)(getProcAddr("glProgramUniform4ui64vNV")) + gpProgramUniform4uiEXT = (C.GPPROGRAMUNIFORM4UIEXT)(getProcAddr("glProgramUniform4uiEXT")) + gpProgramUniform4uiv = (C.GPPROGRAMUNIFORM4UIV)(getProcAddr("glProgramUniform4uiv")) + gpProgramUniform4uivEXT = (C.GPPROGRAMUNIFORM4UIVEXT)(getProcAddr("glProgramUniform4uivEXT")) + gpProgramUniformHandleui64ARB = (C.GPPROGRAMUNIFORMHANDLEUI64ARB)(getProcAddr("glProgramUniformHandleui64ARB")) + gpProgramUniformHandleui64NV = (C.GPPROGRAMUNIFORMHANDLEUI64NV)(getProcAddr("glProgramUniformHandleui64NV")) + gpProgramUniformHandleui64vARB = (C.GPPROGRAMUNIFORMHANDLEUI64VARB)(getProcAddr("glProgramUniformHandleui64vARB")) + gpProgramUniformHandleui64vNV = (C.GPPROGRAMUNIFORMHANDLEUI64VNV)(getProcAddr("glProgramUniformHandleui64vNV")) + gpProgramUniformMatrix2dv = (C.GPPROGRAMUNIFORMMATRIX2DV)(getProcAddr("glProgramUniformMatrix2dv")) + gpProgramUniformMatrix2dvEXT = (C.GPPROGRAMUNIFORMMATRIX2DVEXT)(getProcAddr("glProgramUniformMatrix2dvEXT")) + gpProgramUniformMatrix2fv = (C.GPPROGRAMUNIFORMMATRIX2FV)(getProcAddr("glProgramUniformMatrix2fv")) + gpProgramUniformMatrix2fvEXT = (C.GPPROGRAMUNIFORMMATRIX2FVEXT)(getProcAddr("glProgramUniformMatrix2fvEXT")) + gpProgramUniformMatrix2x3dv = (C.GPPROGRAMUNIFORMMATRIX2X3DV)(getProcAddr("glProgramUniformMatrix2x3dv")) + gpProgramUniformMatrix2x3dvEXT = (C.GPPROGRAMUNIFORMMATRIX2X3DVEXT)(getProcAddr("glProgramUniformMatrix2x3dvEXT")) + gpProgramUniformMatrix2x3fv = (C.GPPROGRAMUNIFORMMATRIX2X3FV)(getProcAddr("glProgramUniformMatrix2x3fv")) + gpProgramUniformMatrix2x3fvEXT = (C.GPPROGRAMUNIFORMMATRIX2X3FVEXT)(getProcAddr("glProgramUniformMatrix2x3fvEXT")) + gpProgramUniformMatrix2x4dv = (C.GPPROGRAMUNIFORMMATRIX2X4DV)(getProcAddr("glProgramUniformMatrix2x4dv")) + gpProgramUniformMatrix2x4dvEXT = (C.GPPROGRAMUNIFORMMATRIX2X4DVEXT)(getProcAddr("glProgramUniformMatrix2x4dvEXT")) + gpProgramUniformMatrix2x4fv = (C.GPPROGRAMUNIFORMMATRIX2X4FV)(getProcAddr("glProgramUniformMatrix2x4fv")) + gpProgramUniformMatrix2x4fvEXT = (C.GPPROGRAMUNIFORMMATRIX2X4FVEXT)(getProcAddr("glProgramUniformMatrix2x4fvEXT")) + gpProgramUniformMatrix3dv = (C.GPPROGRAMUNIFORMMATRIX3DV)(getProcAddr("glProgramUniformMatrix3dv")) + gpProgramUniformMatrix3dvEXT = (C.GPPROGRAMUNIFORMMATRIX3DVEXT)(getProcAddr("glProgramUniformMatrix3dvEXT")) + gpProgramUniformMatrix3fv = (C.GPPROGRAMUNIFORMMATRIX3FV)(getProcAddr("glProgramUniformMatrix3fv")) + gpProgramUniformMatrix3fvEXT = (C.GPPROGRAMUNIFORMMATRIX3FVEXT)(getProcAddr("glProgramUniformMatrix3fvEXT")) + gpProgramUniformMatrix3x2dv = (C.GPPROGRAMUNIFORMMATRIX3X2DV)(getProcAddr("glProgramUniformMatrix3x2dv")) + gpProgramUniformMatrix3x2dvEXT = (C.GPPROGRAMUNIFORMMATRIX3X2DVEXT)(getProcAddr("glProgramUniformMatrix3x2dvEXT")) + gpProgramUniformMatrix3x2fv = (C.GPPROGRAMUNIFORMMATRIX3X2FV)(getProcAddr("glProgramUniformMatrix3x2fv")) + gpProgramUniformMatrix3x2fvEXT = (C.GPPROGRAMUNIFORMMATRIX3X2FVEXT)(getProcAddr("glProgramUniformMatrix3x2fvEXT")) + gpProgramUniformMatrix3x4dv = (C.GPPROGRAMUNIFORMMATRIX3X4DV)(getProcAddr("glProgramUniformMatrix3x4dv")) + gpProgramUniformMatrix3x4dvEXT = (C.GPPROGRAMUNIFORMMATRIX3X4DVEXT)(getProcAddr("glProgramUniformMatrix3x4dvEXT")) + gpProgramUniformMatrix3x4fv = (C.GPPROGRAMUNIFORMMATRIX3X4FV)(getProcAddr("glProgramUniformMatrix3x4fv")) + gpProgramUniformMatrix3x4fvEXT = (C.GPPROGRAMUNIFORMMATRIX3X4FVEXT)(getProcAddr("glProgramUniformMatrix3x4fvEXT")) + gpProgramUniformMatrix4dv = (C.GPPROGRAMUNIFORMMATRIX4DV)(getProcAddr("glProgramUniformMatrix4dv")) + gpProgramUniformMatrix4dvEXT = (C.GPPROGRAMUNIFORMMATRIX4DVEXT)(getProcAddr("glProgramUniformMatrix4dvEXT")) + gpProgramUniformMatrix4fv = (C.GPPROGRAMUNIFORMMATRIX4FV)(getProcAddr("glProgramUniformMatrix4fv")) + gpProgramUniformMatrix4fvEXT = (C.GPPROGRAMUNIFORMMATRIX4FVEXT)(getProcAddr("glProgramUniformMatrix4fvEXT")) + gpProgramUniformMatrix4x2dv = (C.GPPROGRAMUNIFORMMATRIX4X2DV)(getProcAddr("glProgramUniformMatrix4x2dv")) + gpProgramUniformMatrix4x2dvEXT = (C.GPPROGRAMUNIFORMMATRIX4X2DVEXT)(getProcAddr("glProgramUniformMatrix4x2dvEXT")) + gpProgramUniformMatrix4x2fv = (C.GPPROGRAMUNIFORMMATRIX4X2FV)(getProcAddr("glProgramUniformMatrix4x2fv")) + gpProgramUniformMatrix4x2fvEXT = (C.GPPROGRAMUNIFORMMATRIX4X2FVEXT)(getProcAddr("glProgramUniformMatrix4x2fvEXT")) + gpProgramUniformMatrix4x3dv = (C.GPPROGRAMUNIFORMMATRIX4X3DV)(getProcAddr("glProgramUniformMatrix4x3dv")) + gpProgramUniformMatrix4x3dvEXT = (C.GPPROGRAMUNIFORMMATRIX4X3DVEXT)(getProcAddr("glProgramUniformMatrix4x3dvEXT")) + gpProgramUniformMatrix4x3fv = (C.GPPROGRAMUNIFORMMATRIX4X3FV)(getProcAddr("glProgramUniformMatrix4x3fv")) + gpProgramUniformMatrix4x3fvEXT = (C.GPPROGRAMUNIFORMMATRIX4X3FVEXT)(getProcAddr("glProgramUniformMatrix4x3fvEXT")) + gpProgramUniformui64NV = (C.GPPROGRAMUNIFORMUI64NV)(getProcAddr("glProgramUniformui64NV")) + gpProgramUniformui64vNV = (C.GPPROGRAMUNIFORMUI64VNV)(getProcAddr("glProgramUniformui64vNV")) + gpProvokingVertex = (C.GPPROVOKINGVERTEX)(getProcAddr("glProvokingVertex")) + if gpProvokingVertex == nil { + return errors.New("glProvokingVertex") + } + gpPushClientAttribDefaultEXT = (C.GPPUSHCLIENTATTRIBDEFAULTEXT)(getProcAddr("glPushClientAttribDefaultEXT")) + gpPushDebugGroup = (C.GPPUSHDEBUGGROUP)(getProcAddr("glPushDebugGroup")) + gpPushDebugGroupKHR = (C.GPPUSHDEBUGGROUPKHR)(getProcAddr("glPushDebugGroupKHR")) + gpPushGroupMarkerEXT = (C.GPPUSHGROUPMARKEREXT)(getProcAddr("glPushGroupMarkerEXT")) + gpQueryCounter = (C.GPQUERYCOUNTER)(getProcAddr("glQueryCounter")) + if gpQueryCounter == nil { + return errors.New("glQueryCounter") + } + gpRasterSamplesEXT = (C.GPRASTERSAMPLESEXT)(getProcAddr("glRasterSamplesEXT")) + gpReadBuffer = (C.GPREADBUFFER)(getProcAddr("glReadBuffer")) + if gpReadBuffer == nil { + return errors.New("glReadBuffer") + } + gpReadPixels = (C.GPREADPIXELS)(getProcAddr("glReadPixels")) + if gpReadPixels == nil { + return errors.New("glReadPixels") + } + gpReadnPixels = (C.GPREADNPIXELS)(getProcAddr("glReadnPixels")) + gpReadnPixelsARB = (C.GPREADNPIXELSARB)(getProcAddr("glReadnPixelsARB")) + gpReadnPixelsKHR = (C.GPREADNPIXELSKHR)(getProcAddr("glReadnPixelsKHR")) + gpReleaseShaderCompiler = (C.GPRELEASESHADERCOMPILER)(getProcAddr("glReleaseShaderCompiler")) + gpRenderbufferStorage = (C.GPRENDERBUFFERSTORAGE)(getProcAddr("glRenderbufferStorage")) + if gpRenderbufferStorage == nil { + return errors.New("glRenderbufferStorage") + } + gpRenderbufferStorageMultisample = (C.GPRENDERBUFFERSTORAGEMULTISAMPLE)(getProcAddr("glRenderbufferStorageMultisample")) + if gpRenderbufferStorageMultisample == nil { + return errors.New("glRenderbufferStorageMultisample") + } + gpRenderbufferStorageMultisampleAdvancedAMD = (C.GPRENDERBUFFERSTORAGEMULTISAMPLEADVANCEDAMD)(getProcAddr("glRenderbufferStorageMultisampleAdvancedAMD")) + gpRenderbufferStorageMultisampleCoverageNV = (C.GPRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENV)(getProcAddr("glRenderbufferStorageMultisampleCoverageNV")) + gpResetMemoryObjectParameterNV = (C.GPRESETMEMORYOBJECTPARAMETERNV)(getProcAddr("glResetMemoryObjectParameterNV")) + gpResolveDepthValuesNV = (C.GPRESOLVEDEPTHVALUESNV)(getProcAddr("glResolveDepthValuesNV")) + gpResumeTransformFeedback = (C.GPRESUMETRANSFORMFEEDBACK)(getProcAddr("glResumeTransformFeedback")) + gpSampleCoverage = (C.GPSAMPLECOVERAGE)(getProcAddr("glSampleCoverage")) + if gpSampleCoverage == nil { + return errors.New("glSampleCoverage") + } + gpSampleMaski = (C.GPSAMPLEMASKI)(getProcAddr("glSampleMaski")) + if gpSampleMaski == nil { + return errors.New("glSampleMaski") + } + gpSamplerParameterIiv = (C.GPSAMPLERPARAMETERIIV)(getProcAddr("glSamplerParameterIiv")) + if gpSamplerParameterIiv == nil { + return errors.New("glSamplerParameterIiv") + } + gpSamplerParameterIuiv = (C.GPSAMPLERPARAMETERIUIV)(getProcAddr("glSamplerParameterIuiv")) + if gpSamplerParameterIuiv == nil { + return errors.New("glSamplerParameterIuiv") + } + gpSamplerParameterf = (C.GPSAMPLERPARAMETERF)(getProcAddr("glSamplerParameterf")) + if gpSamplerParameterf == nil { + return errors.New("glSamplerParameterf") + } + gpSamplerParameterfv = (C.GPSAMPLERPARAMETERFV)(getProcAddr("glSamplerParameterfv")) + if gpSamplerParameterfv == nil { + return errors.New("glSamplerParameterfv") + } + gpSamplerParameteri = (C.GPSAMPLERPARAMETERI)(getProcAddr("glSamplerParameteri")) + if gpSamplerParameteri == nil { + return errors.New("glSamplerParameteri") + } + gpSamplerParameteriv = (C.GPSAMPLERPARAMETERIV)(getProcAddr("glSamplerParameteriv")) + if gpSamplerParameteriv == nil { + return errors.New("glSamplerParameteriv") + } + gpScissor = (C.GPSCISSOR)(getProcAddr("glScissor")) + if gpScissor == nil { + return errors.New("glScissor") + } + gpScissorArrayv = (C.GPSCISSORARRAYV)(getProcAddr("glScissorArrayv")) + gpScissorExclusiveArrayvNV = (C.GPSCISSOREXCLUSIVEARRAYVNV)(getProcAddr("glScissorExclusiveArrayvNV")) + gpScissorExclusiveNV = (C.GPSCISSOREXCLUSIVENV)(getProcAddr("glScissorExclusiveNV")) + gpScissorIndexed = (C.GPSCISSORINDEXED)(getProcAddr("glScissorIndexed")) + gpScissorIndexedv = (C.GPSCISSORINDEXEDV)(getProcAddr("glScissorIndexedv")) + gpSecondaryColorFormatNV = (C.GPSECONDARYCOLORFORMATNV)(getProcAddr("glSecondaryColorFormatNV")) + gpSelectPerfMonitorCountersAMD = (C.GPSELECTPERFMONITORCOUNTERSAMD)(getProcAddr("glSelectPerfMonitorCountersAMD")) + gpShaderBinary = (C.GPSHADERBINARY)(getProcAddr("glShaderBinary")) + gpShaderSource = (C.GPSHADERSOURCE)(getProcAddr("glShaderSource")) + if gpShaderSource == nil { + return errors.New("glShaderSource") + } + gpShaderStorageBlockBinding = (C.GPSHADERSTORAGEBLOCKBINDING)(getProcAddr("glShaderStorageBlockBinding")) + gpShadingRateImageBarrierNV = (C.GPSHADINGRATEIMAGEBARRIERNV)(getProcAddr("glShadingRateImageBarrierNV")) + gpShadingRateImagePaletteNV = (C.GPSHADINGRATEIMAGEPALETTENV)(getProcAddr("glShadingRateImagePaletteNV")) + gpShadingRateSampleOrderCustomNV = (C.GPSHADINGRATESAMPLEORDERCUSTOMNV)(getProcAddr("glShadingRateSampleOrderCustomNV")) + gpShadingRateSampleOrderNV = (C.GPSHADINGRATESAMPLEORDERNV)(getProcAddr("glShadingRateSampleOrderNV")) + gpSignalVkFenceNV = (C.GPSIGNALVKFENCENV)(getProcAddr("glSignalVkFenceNV")) + gpSignalVkSemaphoreNV = (C.GPSIGNALVKSEMAPHORENV)(getProcAddr("glSignalVkSemaphoreNV")) + gpSpecializeShaderARB = (C.GPSPECIALIZESHADERARB)(getProcAddr("glSpecializeShaderARB")) + gpStateCaptureNV = (C.GPSTATECAPTURENV)(getProcAddr("glStateCaptureNV")) + gpStencilFillPathInstancedNV = (C.GPSTENCILFILLPATHINSTANCEDNV)(getProcAddr("glStencilFillPathInstancedNV")) + gpStencilFillPathNV = (C.GPSTENCILFILLPATHNV)(getProcAddr("glStencilFillPathNV")) + gpStencilFunc = (C.GPSTENCILFUNC)(getProcAddr("glStencilFunc")) + if gpStencilFunc == nil { + return errors.New("glStencilFunc") + } + gpStencilFuncSeparate = (C.GPSTENCILFUNCSEPARATE)(getProcAddr("glStencilFuncSeparate")) + if gpStencilFuncSeparate == nil { + return errors.New("glStencilFuncSeparate") + } + gpStencilMask = (C.GPSTENCILMASK)(getProcAddr("glStencilMask")) + if gpStencilMask == nil { + return errors.New("glStencilMask") + } + gpStencilMaskSeparate = (C.GPSTENCILMASKSEPARATE)(getProcAddr("glStencilMaskSeparate")) + if gpStencilMaskSeparate == nil { + return errors.New("glStencilMaskSeparate") + } + gpStencilOp = (C.GPSTENCILOP)(getProcAddr("glStencilOp")) + if gpStencilOp == nil { + return errors.New("glStencilOp") + } + gpStencilOpSeparate = (C.GPSTENCILOPSEPARATE)(getProcAddr("glStencilOpSeparate")) + if gpStencilOpSeparate == nil { + return errors.New("glStencilOpSeparate") + } + gpStencilStrokePathInstancedNV = (C.GPSTENCILSTROKEPATHINSTANCEDNV)(getProcAddr("glStencilStrokePathInstancedNV")) + gpStencilStrokePathNV = (C.GPSTENCILSTROKEPATHNV)(getProcAddr("glStencilStrokePathNV")) + gpStencilThenCoverFillPathInstancedNV = (C.GPSTENCILTHENCOVERFILLPATHINSTANCEDNV)(getProcAddr("glStencilThenCoverFillPathInstancedNV")) + gpStencilThenCoverFillPathNV = (C.GPSTENCILTHENCOVERFILLPATHNV)(getProcAddr("glStencilThenCoverFillPathNV")) + gpStencilThenCoverStrokePathInstancedNV = (C.GPSTENCILTHENCOVERSTROKEPATHINSTANCEDNV)(getProcAddr("glStencilThenCoverStrokePathInstancedNV")) + gpStencilThenCoverStrokePathNV = (C.GPSTENCILTHENCOVERSTROKEPATHNV)(getProcAddr("glStencilThenCoverStrokePathNV")) + gpSubpixelPrecisionBiasNV = (C.GPSUBPIXELPRECISIONBIASNV)(getProcAddr("glSubpixelPrecisionBiasNV")) + gpTexAttachMemoryNV = (C.GPTEXATTACHMEMORYNV)(getProcAddr("glTexAttachMemoryNV")) + gpTexBuffer = (C.GPTEXBUFFER)(getProcAddr("glTexBuffer")) + if gpTexBuffer == nil { + return errors.New("glTexBuffer") + } + gpTexBufferARB = (C.GPTEXBUFFERARB)(getProcAddr("glTexBufferARB")) + gpTexBufferRange = (C.GPTEXBUFFERRANGE)(getProcAddr("glTexBufferRange")) + gpTexCoordFormatNV = (C.GPTEXCOORDFORMATNV)(getProcAddr("glTexCoordFormatNV")) + gpTexImage1D = (C.GPTEXIMAGE1D)(getProcAddr("glTexImage1D")) + if gpTexImage1D == nil { + return errors.New("glTexImage1D") + } + gpTexImage2D = (C.GPTEXIMAGE2D)(getProcAddr("glTexImage2D")) + if gpTexImage2D == nil { + return errors.New("glTexImage2D") + } + gpTexImage2DMultisample = (C.GPTEXIMAGE2DMULTISAMPLE)(getProcAddr("glTexImage2DMultisample")) + if gpTexImage2DMultisample == nil { + return errors.New("glTexImage2DMultisample") + } + gpTexImage3D = (C.GPTEXIMAGE3D)(getProcAddr("glTexImage3D")) + if gpTexImage3D == nil { + return errors.New("glTexImage3D") + } + gpTexImage3DMultisample = (C.GPTEXIMAGE3DMULTISAMPLE)(getProcAddr("glTexImage3DMultisample")) + if gpTexImage3DMultisample == nil { + return errors.New("glTexImage3DMultisample") + } + gpTexPageCommitmentARB = (C.GPTEXPAGECOMMITMENTARB)(getProcAddr("glTexPageCommitmentARB")) + gpTexPageCommitmentMemNV = (C.GPTEXPAGECOMMITMENTMEMNV)(getProcAddr("glTexPageCommitmentMemNV")) + gpTexParameterIiv = (C.GPTEXPARAMETERIIV)(getProcAddr("glTexParameterIiv")) + if gpTexParameterIiv == nil { + return errors.New("glTexParameterIiv") + } + gpTexParameterIuiv = (C.GPTEXPARAMETERIUIV)(getProcAddr("glTexParameterIuiv")) + if gpTexParameterIuiv == nil { + return errors.New("glTexParameterIuiv") + } + gpTexParameterf = (C.GPTEXPARAMETERF)(getProcAddr("glTexParameterf")) + if gpTexParameterf == nil { + return errors.New("glTexParameterf") + } + gpTexParameterfv = (C.GPTEXPARAMETERFV)(getProcAddr("glTexParameterfv")) + if gpTexParameterfv == nil { + return errors.New("glTexParameterfv") + } + gpTexParameteri = (C.GPTEXPARAMETERI)(getProcAddr("glTexParameteri")) + if gpTexParameteri == nil { + return errors.New("glTexParameteri") + } + gpTexParameteriv = (C.GPTEXPARAMETERIV)(getProcAddr("glTexParameteriv")) + if gpTexParameteriv == nil { + return errors.New("glTexParameteriv") + } + gpTexStorage1D = (C.GPTEXSTORAGE1D)(getProcAddr("glTexStorage1D")) + gpTexStorage2D = (C.GPTEXSTORAGE2D)(getProcAddr("glTexStorage2D")) + gpTexStorage2DMultisample = (C.GPTEXSTORAGE2DMULTISAMPLE)(getProcAddr("glTexStorage2DMultisample")) + gpTexStorage3D = (C.GPTEXSTORAGE3D)(getProcAddr("glTexStorage3D")) + gpTexStorage3DMultisample = (C.GPTEXSTORAGE3DMULTISAMPLE)(getProcAddr("glTexStorage3DMultisample")) + gpTexSubImage1D = (C.GPTEXSUBIMAGE1D)(getProcAddr("glTexSubImage1D")) + if gpTexSubImage1D == nil { + return errors.New("glTexSubImage1D") + } + gpTexSubImage2D = (C.GPTEXSUBIMAGE2D)(getProcAddr("glTexSubImage2D")) + if gpTexSubImage2D == nil { + return errors.New("glTexSubImage2D") + } + gpTexSubImage3D = (C.GPTEXSUBIMAGE3D)(getProcAddr("glTexSubImage3D")) + if gpTexSubImage3D == nil { + return errors.New("glTexSubImage3D") + } + gpTextureAttachMemoryNV = (C.GPTEXTUREATTACHMEMORYNV)(getProcAddr("glTextureAttachMemoryNV")) + gpTextureBarrier = (C.GPTEXTUREBARRIER)(getProcAddr("glTextureBarrier")) + gpTextureBarrierNV = (C.GPTEXTUREBARRIERNV)(getProcAddr("glTextureBarrierNV")) + gpTextureBuffer = (C.GPTEXTUREBUFFER)(getProcAddr("glTextureBuffer")) + gpTextureBufferEXT = (C.GPTEXTUREBUFFEREXT)(getProcAddr("glTextureBufferEXT")) + gpTextureBufferRange = (C.GPTEXTUREBUFFERRANGE)(getProcAddr("glTextureBufferRange")) + gpTextureBufferRangeEXT = (C.GPTEXTUREBUFFERRANGEEXT)(getProcAddr("glTextureBufferRangeEXT")) + gpTextureImage1DEXT = (C.GPTEXTUREIMAGE1DEXT)(getProcAddr("glTextureImage1DEXT")) + gpTextureImage2DEXT = (C.GPTEXTUREIMAGE2DEXT)(getProcAddr("glTextureImage2DEXT")) + gpTextureImage3DEXT = (C.GPTEXTUREIMAGE3DEXT)(getProcAddr("glTextureImage3DEXT")) + gpTexturePageCommitmentEXT = (C.GPTEXTUREPAGECOMMITMENTEXT)(getProcAddr("glTexturePageCommitmentEXT")) + gpTexturePageCommitmentMemNV = (C.GPTEXTUREPAGECOMMITMENTMEMNV)(getProcAddr("glTexturePageCommitmentMemNV")) + gpTextureParameterIiv = (C.GPTEXTUREPARAMETERIIV)(getProcAddr("glTextureParameterIiv")) + gpTextureParameterIivEXT = (C.GPTEXTUREPARAMETERIIVEXT)(getProcAddr("glTextureParameterIivEXT")) + gpTextureParameterIuiv = (C.GPTEXTUREPARAMETERIUIV)(getProcAddr("glTextureParameterIuiv")) + gpTextureParameterIuivEXT = (C.GPTEXTUREPARAMETERIUIVEXT)(getProcAddr("glTextureParameterIuivEXT")) + gpTextureParameterf = (C.GPTEXTUREPARAMETERF)(getProcAddr("glTextureParameterf")) + gpTextureParameterfEXT = (C.GPTEXTUREPARAMETERFEXT)(getProcAddr("glTextureParameterfEXT")) + gpTextureParameterfv = (C.GPTEXTUREPARAMETERFV)(getProcAddr("glTextureParameterfv")) + gpTextureParameterfvEXT = (C.GPTEXTUREPARAMETERFVEXT)(getProcAddr("glTextureParameterfvEXT")) + gpTextureParameteri = (C.GPTEXTUREPARAMETERI)(getProcAddr("glTextureParameteri")) + gpTextureParameteriEXT = (C.GPTEXTUREPARAMETERIEXT)(getProcAddr("glTextureParameteriEXT")) + gpTextureParameteriv = (C.GPTEXTUREPARAMETERIV)(getProcAddr("glTextureParameteriv")) + gpTextureParameterivEXT = (C.GPTEXTUREPARAMETERIVEXT)(getProcAddr("glTextureParameterivEXT")) + gpTextureRenderbufferEXT = (C.GPTEXTURERENDERBUFFEREXT)(getProcAddr("glTextureRenderbufferEXT")) + gpTextureStorage1D = (C.GPTEXTURESTORAGE1D)(getProcAddr("glTextureStorage1D")) + gpTextureStorage1DEXT = (C.GPTEXTURESTORAGE1DEXT)(getProcAddr("glTextureStorage1DEXT")) + gpTextureStorage2D = (C.GPTEXTURESTORAGE2D)(getProcAddr("glTextureStorage2D")) + gpTextureStorage2DEXT = (C.GPTEXTURESTORAGE2DEXT)(getProcAddr("glTextureStorage2DEXT")) + gpTextureStorage2DMultisample = (C.GPTEXTURESTORAGE2DMULTISAMPLE)(getProcAddr("glTextureStorage2DMultisample")) + gpTextureStorage2DMultisampleEXT = (C.GPTEXTURESTORAGE2DMULTISAMPLEEXT)(getProcAddr("glTextureStorage2DMultisampleEXT")) + gpTextureStorage3D = (C.GPTEXTURESTORAGE3D)(getProcAddr("glTextureStorage3D")) + gpTextureStorage3DEXT = (C.GPTEXTURESTORAGE3DEXT)(getProcAddr("glTextureStorage3DEXT")) + gpTextureStorage3DMultisample = (C.GPTEXTURESTORAGE3DMULTISAMPLE)(getProcAddr("glTextureStorage3DMultisample")) + gpTextureStorage3DMultisampleEXT = (C.GPTEXTURESTORAGE3DMULTISAMPLEEXT)(getProcAddr("glTextureStorage3DMultisampleEXT")) + gpTextureSubImage1D = (C.GPTEXTURESUBIMAGE1D)(getProcAddr("glTextureSubImage1D")) + gpTextureSubImage1DEXT = (C.GPTEXTURESUBIMAGE1DEXT)(getProcAddr("glTextureSubImage1DEXT")) + gpTextureSubImage2D = (C.GPTEXTURESUBIMAGE2D)(getProcAddr("glTextureSubImage2D")) + gpTextureSubImage2DEXT = (C.GPTEXTURESUBIMAGE2DEXT)(getProcAddr("glTextureSubImage2DEXT")) + gpTextureSubImage3D = (C.GPTEXTURESUBIMAGE3D)(getProcAddr("glTextureSubImage3D")) + gpTextureSubImage3DEXT = (C.GPTEXTURESUBIMAGE3DEXT)(getProcAddr("glTextureSubImage3DEXT")) + gpTextureView = (C.GPTEXTUREVIEW)(getProcAddr("glTextureView")) + gpTransformFeedbackBufferBase = (C.GPTRANSFORMFEEDBACKBUFFERBASE)(getProcAddr("glTransformFeedbackBufferBase")) + gpTransformFeedbackBufferRange = (C.GPTRANSFORMFEEDBACKBUFFERRANGE)(getProcAddr("glTransformFeedbackBufferRange")) + gpTransformFeedbackVaryings = (C.GPTRANSFORMFEEDBACKVARYINGS)(getProcAddr("glTransformFeedbackVaryings")) + if gpTransformFeedbackVaryings == nil { + return errors.New("glTransformFeedbackVaryings") + } + gpTransformPathNV = (C.GPTRANSFORMPATHNV)(getProcAddr("glTransformPathNV")) + gpUniform1d = (C.GPUNIFORM1D)(getProcAddr("glUniform1d")) + gpUniform1dv = (C.GPUNIFORM1DV)(getProcAddr("glUniform1dv")) + gpUniform1f = (C.GPUNIFORM1F)(getProcAddr("glUniform1f")) + if gpUniform1f == nil { + return errors.New("glUniform1f") + } + gpUniform1fv = (C.GPUNIFORM1FV)(getProcAddr("glUniform1fv")) + if gpUniform1fv == nil { + return errors.New("glUniform1fv") + } + gpUniform1i = (C.GPUNIFORM1I)(getProcAddr("glUniform1i")) + if gpUniform1i == nil { + return errors.New("glUniform1i") + } + gpUniform1i64ARB = (C.GPUNIFORM1I64ARB)(getProcAddr("glUniform1i64ARB")) + gpUniform1i64NV = (C.GPUNIFORM1I64NV)(getProcAddr("glUniform1i64NV")) + gpUniform1i64vARB = (C.GPUNIFORM1I64VARB)(getProcAddr("glUniform1i64vARB")) + gpUniform1i64vNV = (C.GPUNIFORM1I64VNV)(getProcAddr("glUniform1i64vNV")) + gpUniform1iv = (C.GPUNIFORM1IV)(getProcAddr("glUniform1iv")) + if gpUniform1iv == nil { + return errors.New("glUniform1iv") + } + gpUniform1ui = (C.GPUNIFORM1UI)(getProcAddr("glUniform1ui")) + if gpUniform1ui == nil { + return errors.New("glUniform1ui") + } + gpUniform1ui64ARB = (C.GPUNIFORM1UI64ARB)(getProcAddr("glUniform1ui64ARB")) + gpUniform1ui64NV = (C.GPUNIFORM1UI64NV)(getProcAddr("glUniform1ui64NV")) + gpUniform1ui64vARB = (C.GPUNIFORM1UI64VARB)(getProcAddr("glUniform1ui64vARB")) + gpUniform1ui64vNV = (C.GPUNIFORM1UI64VNV)(getProcAddr("glUniform1ui64vNV")) + gpUniform1uiv = (C.GPUNIFORM1UIV)(getProcAddr("glUniform1uiv")) + if gpUniform1uiv == nil { + return errors.New("glUniform1uiv") + } + gpUniform2d = (C.GPUNIFORM2D)(getProcAddr("glUniform2d")) + gpUniform2dv = (C.GPUNIFORM2DV)(getProcAddr("glUniform2dv")) + gpUniform2f = (C.GPUNIFORM2F)(getProcAddr("glUniform2f")) + if gpUniform2f == nil { + return errors.New("glUniform2f") + } + gpUniform2fv = (C.GPUNIFORM2FV)(getProcAddr("glUniform2fv")) + if gpUniform2fv == nil { + return errors.New("glUniform2fv") + } + gpUniform2i = (C.GPUNIFORM2I)(getProcAddr("glUniform2i")) + if gpUniform2i == nil { + return errors.New("glUniform2i") + } + gpUniform2i64ARB = (C.GPUNIFORM2I64ARB)(getProcAddr("glUniform2i64ARB")) + gpUniform2i64NV = (C.GPUNIFORM2I64NV)(getProcAddr("glUniform2i64NV")) + gpUniform2i64vARB = (C.GPUNIFORM2I64VARB)(getProcAddr("glUniform2i64vARB")) + gpUniform2i64vNV = (C.GPUNIFORM2I64VNV)(getProcAddr("glUniform2i64vNV")) + gpUniform2iv = (C.GPUNIFORM2IV)(getProcAddr("glUniform2iv")) + if gpUniform2iv == nil { + return errors.New("glUniform2iv") + } + gpUniform2ui = (C.GPUNIFORM2UI)(getProcAddr("glUniform2ui")) + if gpUniform2ui == nil { + return errors.New("glUniform2ui") + } + gpUniform2ui64ARB = (C.GPUNIFORM2UI64ARB)(getProcAddr("glUniform2ui64ARB")) + gpUniform2ui64NV = (C.GPUNIFORM2UI64NV)(getProcAddr("glUniform2ui64NV")) + gpUniform2ui64vARB = (C.GPUNIFORM2UI64VARB)(getProcAddr("glUniform2ui64vARB")) + gpUniform2ui64vNV = (C.GPUNIFORM2UI64VNV)(getProcAddr("glUniform2ui64vNV")) + gpUniform2uiv = (C.GPUNIFORM2UIV)(getProcAddr("glUniform2uiv")) + if gpUniform2uiv == nil { + return errors.New("glUniform2uiv") + } + gpUniform3d = (C.GPUNIFORM3D)(getProcAddr("glUniform3d")) + gpUniform3dv = (C.GPUNIFORM3DV)(getProcAddr("glUniform3dv")) + gpUniform3f = (C.GPUNIFORM3F)(getProcAddr("glUniform3f")) + if gpUniform3f == nil { + return errors.New("glUniform3f") + } + gpUniform3fv = (C.GPUNIFORM3FV)(getProcAddr("glUniform3fv")) + if gpUniform3fv == nil { + return errors.New("glUniform3fv") + } + gpUniform3i = (C.GPUNIFORM3I)(getProcAddr("glUniform3i")) + if gpUniform3i == nil { + return errors.New("glUniform3i") + } + gpUniform3i64ARB = (C.GPUNIFORM3I64ARB)(getProcAddr("glUniform3i64ARB")) + gpUniform3i64NV = (C.GPUNIFORM3I64NV)(getProcAddr("glUniform3i64NV")) + gpUniform3i64vARB = (C.GPUNIFORM3I64VARB)(getProcAddr("glUniform3i64vARB")) + gpUniform3i64vNV = (C.GPUNIFORM3I64VNV)(getProcAddr("glUniform3i64vNV")) + gpUniform3iv = (C.GPUNIFORM3IV)(getProcAddr("glUniform3iv")) + if gpUniform3iv == nil { + return errors.New("glUniform3iv") + } + gpUniform3ui = (C.GPUNIFORM3UI)(getProcAddr("glUniform3ui")) + if gpUniform3ui == nil { + return errors.New("glUniform3ui") + } + gpUniform3ui64ARB = (C.GPUNIFORM3UI64ARB)(getProcAddr("glUniform3ui64ARB")) + gpUniform3ui64NV = (C.GPUNIFORM3UI64NV)(getProcAddr("glUniform3ui64NV")) + gpUniform3ui64vARB = (C.GPUNIFORM3UI64VARB)(getProcAddr("glUniform3ui64vARB")) + gpUniform3ui64vNV = (C.GPUNIFORM3UI64VNV)(getProcAddr("glUniform3ui64vNV")) + gpUniform3uiv = (C.GPUNIFORM3UIV)(getProcAddr("glUniform3uiv")) + if gpUniform3uiv == nil { + return errors.New("glUniform3uiv") + } + gpUniform4d = (C.GPUNIFORM4D)(getProcAddr("glUniform4d")) + gpUniform4dv = (C.GPUNIFORM4DV)(getProcAddr("glUniform4dv")) + gpUniform4f = (C.GPUNIFORM4F)(getProcAddr("glUniform4f")) + if gpUniform4f == nil { + return errors.New("glUniform4f") + } + gpUniform4fv = (C.GPUNIFORM4FV)(getProcAddr("glUniform4fv")) + if gpUniform4fv == nil { + return errors.New("glUniform4fv") + } + gpUniform4i = (C.GPUNIFORM4I)(getProcAddr("glUniform4i")) + if gpUniform4i == nil { + return errors.New("glUniform4i") + } + gpUniform4i64ARB = (C.GPUNIFORM4I64ARB)(getProcAddr("glUniform4i64ARB")) + gpUniform4i64NV = (C.GPUNIFORM4I64NV)(getProcAddr("glUniform4i64NV")) + gpUniform4i64vARB = (C.GPUNIFORM4I64VARB)(getProcAddr("glUniform4i64vARB")) + gpUniform4i64vNV = (C.GPUNIFORM4I64VNV)(getProcAddr("glUniform4i64vNV")) + gpUniform4iv = (C.GPUNIFORM4IV)(getProcAddr("glUniform4iv")) + if gpUniform4iv == nil { + return errors.New("glUniform4iv") + } + gpUniform4ui = (C.GPUNIFORM4UI)(getProcAddr("glUniform4ui")) + if gpUniform4ui == nil { + return errors.New("glUniform4ui") + } + gpUniform4ui64ARB = (C.GPUNIFORM4UI64ARB)(getProcAddr("glUniform4ui64ARB")) + gpUniform4ui64NV = (C.GPUNIFORM4UI64NV)(getProcAddr("glUniform4ui64NV")) + gpUniform4ui64vARB = (C.GPUNIFORM4UI64VARB)(getProcAddr("glUniform4ui64vARB")) + gpUniform4ui64vNV = (C.GPUNIFORM4UI64VNV)(getProcAddr("glUniform4ui64vNV")) + gpUniform4uiv = (C.GPUNIFORM4UIV)(getProcAddr("glUniform4uiv")) + if gpUniform4uiv == nil { + return errors.New("glUniform4uiv") + } + gpUniformBlockBinding = (C.GPUNIFORMBLOCKBINDING)(getProcAddr("glUniformBlockBinding")) + if gpUniformBlockBinding == nil { + return errors.New("glUniformBlockBinding") + } + gpUniformHandleui64ARB = (C.GPUNIFORMHANDLEUI64ARB)(getProcAddr("glUniformHandleui64ARB")) + gpUniformHandleui64NV = (C.GPUNIFORMHANDLEUI64NV)(getProcAddr("glUniformHandleui64NV")) + gpUniformHandleui64vARB = (C.GPUNIFORMHANDLEUI64VARB)(getProcAddr("glUniformHandleui64vARB")) + gpUniformHandleui64vNV = (C.GPUNIFORMHANDLEUI64VNV)(getProcAddr("glUniformHandleui64vNV")) + gpUniformMatrix2dv = (C.GPUNIFORMMATRIX2DV)(getProcAddr("glUniformMatrix2dv")) + gpUniformMatrix2fv = (C.GPUNIFORMMATRIX2FV)(getProcAddr("glUniformMatrix2fv")) + if gpUniformMatrix2fv == nil { + return errors.New("glUniformMatrix2fv") + } + gpUniformMatrix2x3dv = (C.GPUNIFORMMATRIX2X3DV)(getProcAddr("glUniformMatrix2x3dv")) + gpUniformMatrix2x3fv = (C.GPUNIFORMMATRIX2X3FV)(getProcAddr("glUniformMatrix2x3fv")) + if gpUniformMatrix2x3fv == nil { + return errors.New("glUniformMatrix2x3fv") + } + gpUniformMatrix2x4dv = (C.GPUNIFORMMATRIX2X4DV)(getProcAddr("glUniformMatrix2x4dv")) + gpUniformMatrix2x4fv = (C.GPUNIFORMMATRIX2X4FV)(getProcAddr("glUniformMatrix2x4fv")) + if gpUniformMatrix2x4fv == nil { + return errors.New("glUniformMatrix2x4fv") + } + gpUniformMatrix3dv = (C.GPUNIFORMMATRIX3DV)(getProcAddr("glUniformMatrix3dv")) + gpUniformMatrix3fv = (C.GPUNIFORMMATRIX3FV)(getProcAddr("glUniformMatrix3fv")) + if gpUniformMatrix3fv == nil { + return errors.New("glUniformMatrix3fv") + } + gpUniformMatrix3x2dv = (C.GPUNIFORMMATRIX3X2DV)(getProcAddr("glUniformMatrix3x2dv")) + gpUniformMatrix3x2fv = (C.GPUNIFORMMATRIX3X2FV)(getProcAddr("glUniformMatrix3x2fv")) + if gpUniformMatrix3x2fv == nil { + return errors.New("glUniformMatrix3x2fv") + } + gpUniformMatrix3x4dv = (C.GPUNIFORMMATRIX3X4DV)(getProcAddr("glUniformMatrix3x4dv")) + gpUniformMatrix3x4fv = (C.GPUNIFORMMATRIX3X4FV)(getProcAddr("glUniformMatrix3x4fv")) + if gpUniformMatrix3x4fv == nil { + return errors.New("glUniformMatrix3x4fv") + } + gpUniformMatrix4dv = (C.GPUNIFORMMATRIX4DV)(getProcAddr("glUniformMatrix4dv")) + gpUniformMatrix4fv = (C.GPUNIFORMMATRIX4FV)(getProcAddr("glUniformMatrix4fv")) + if gpUniformMatrix4fv == nil { + return errors.New("glUniformMatrix4fv") + } + gpUniformMatrix4x2dv = (C.GPUNIFORMMATRIX4X2DV)(getProcAddr("glUniformMatrix4x2dv")) + gpUniformMatrix4x2fv = (C.GPUNIFORMMATRIX4X2FV)(getProcAddr("glUniformMatrix4x2fv")) + if gpUniformMatrix4x2fv == nil { + return errors.New("glUniformMatrix4x2fv") + } + gpUniformMatrix4x3dv = (C.GPUNIFORMMATRIX4X3DV)(getProcAddr("glUniformMatrix4x3dv")) + gpUniformMatrix4x3fv = (C.GPUNIFORMMATRIX4X3FV)(getProcAddr("glUniformMatrix4x3fv")) + if gpUniformMatrix4x3fv == nil { + return errors.New("glUniformMatrix4x3fv") + } + gpUniformSubroutinesuiv = (C.GPUNIFORMSUBROUTINESUIV)(getProcAddr("glUniformSubroutinesuiv")) + gpUniformui64NV = (C.GPUNIFORMUI64NV)(getProcAddr("glUniformui64NV")) + gpUniformui64vNV = (C.GPUNIFORMUI64VNV)(getProcAddr("glUniformui64vNV")) + gpUnmapBuffer = (C.GPUNMAPBUFFER)(getProcAddr("glUnmapBuffer")) + if gpUnmapBuffer == nil { + return errors.New("glUnmapBuffer") + } + gpUnmapNamedBuffer = (C.GPUNMAPNAMEDBUFFER)(getProcAddr("glUnmapNamedBuffer")) + gpUnmapNamedBufferEXT = (C.GPUNMAPNAMEDBUFFEREXT)(getProcAddr("glUnmapNamedBufferEXT")) + gpUseProgram = (C.GPUSEPROGRAM)(getProcAddr("glUseProgram")) + if gpUseProgram == nil { + return errors.New("glUseProgram") + } + gpUseProgramStages = (C.GPUSEPROGRAMSTAGES)(getProcAddr("glUseProgramStages")) + gpUseProgramStagesEXT = (C.GPUSEPROGRAMSTAGESEXT)(getProcAddr("glUseProgramStagesEXT")) + gpUseShaderProgramEXT = (C.GPUSESHADERPROGRAMEXT)(getProcAddr("glUseShaderProgramEXT")) + gpValidateProgram = (C.GPVALIDATEPROGRAM)(getProcAddr("glValidateProgram")) + if gpValidateProgram == nil { + return errors.New("glValidateProgram") + } + gpValidateProgramPipeline = (C.GPVALIDATEPROGRAMPIPELINE)(getProcAddr("glValidateProgramPipeline")) + gpValidateProgramPipelineEXT = (C.GPVALIDATEPROGRAMPIPELINEEXT)(getProcAddr("glValidateProgramPipelineEXT")) + gpVertexArrayAttribBinding = (C.GPVERTEXARRAYATTRIBBINDING)(getProcAddr("glVertexArrayAttribBinding")) + gpVertexArrayAttribFormat = (C.GPVERTEXARRAYATTRIBFORMAT)(getProcAddr("glVertexArrayAttribFormat")) + gpVertexArrayAttribIFormat = (C.GPVERTEXARRAYATTRIBIFORMAT)(getProcAddr("glVertexArrayAttribIFormat")) + gpVertexArrayAttribLFormat = (C.GPVERTEXARRAYATTRIBLFORMAT)(getProcAddr("glVertexArrayAttribLFormat")) + gpVertexArrayBindVertexBufferEXT = (C.GPVERTEXARRAYBINDVERTEXBUFFEREXT)(getProcAddr("glVertexArrayBindVertexBufferEXT")) + gpVertexArrayBindingDivisor = (C.GPVERTEXARRAYBINDINGDIVISOR)(getProcAddr("glVertexArrayBindingDivisor")) + gpVertexArrayColorOffsetEXT = (C.GPVERTEXARRAYCOLOROFFSETEXT)(getProcAddr("glVertexArrayColorOffsetEXT")) + gpVertexArrayEdgeFlagOffsetEXT = (C.GPVERTEXARRAYEDGEFLAGOFFSETEXT)(getProcAddr("glVertexArrayEdgeFlagOffsetEXT")) + gpVertexArrayElementBuffer = (C.GPVERTEXARRAYELEMENTBUFFER)(getProcAddr("glVertexArrayElementBuffer")) + gpVertexArrayFogCoordOffsetEXT = (C.GPVERTEXARRAYFOGCOORDOFFSETEXT)(getProcAddr("glVertexArrayFogCoordOffsetEXT")) + gpVertexArrayIndexOffsetEXT = (C.GPVERTEXARRAYINDEXOFFSETEXT)(getProcAddr("glVertexArrayIndexOffsetEXT")) + gpVertexArrayMultiTexCoordOffsetEXT = (C.GPVERTEXARRAYMULTITEXCOORDOFFSETEXT)(getProcAddr("glVertexArrayMultiTexCoordOffsetEXT")) + gpVertexArrayNormalOffsetEXT = (C.GPVERTEXARRAYNORMALOFFSETEXT)(getProcAddr("glVertexArrayNormalOffsetEXT")) + gpVertexArraySecondaryColorOffsetEXT = (C.GPVERTEXARRAYSECONDARYCOLOROFFSETEXT)(getProcAddr("glVertexArraySecondaryColorOffsetEXT")) + gpVertexArrayTexCoordOffsetEXT = (C.GPVERTEXARRAYTEXCOORDOFFSETEXT)(getProcAddr("glVertexArrayTexCoordOffsetEXT")) + gpVertexArrayVertexAttribBindingEXT = (C.GPVERTEXARRAYVERTEXATTRIBBINDINGEXT)(getProcAddr("glVertexArrayVertexAttribBindingEXT")) + gpVertexArrayVertexAttribDivisorEXT = (C.GPVERTEXARRAYVERTEXATTRIBDIVISOREXT)(getProcAddr("glVertexArrayVertexAttribDivisorEXT")) + gpVertexArrayVertexAttribFormatEXT = (C.GPVERTEXARRAYVERTEXATTRIBFORMATEXT)(getProcAddr("glVertexArrayVertexAttribFormatEXT")) + gpVertexArrayVertexAttribIFormatEXT = (C.GPVERTEXARRAYVERTEXATTRIBIFORMATEXT)(getProcAddr("glVertexArrayVertexAttribIFormatEXT")) + gpVertexArrayVertexAttribIOffsetEXT = (C.GPVERTEXARRAYVERTEXATTRIBIOFFSETEXT)(getProcAddr("glVertexArrayVertexAttribIOffsetEXT")) + gpVertexArrayVertexAttribLFormatEXT = (C.GPVERTEXARRAYVERTEXATTRIBLFORMATEXT)(getProcAddr("glVertexArrayVertexAttribLFormatEXT")) + gpVertexArrayVertexAttribLOffsetEXT = (C.GPVERTEXARRAYVERTEXATTRIBLOFFSETEXT)(getProcAddr("glVertexArrayVertexAttribLOffsetEXT")) + gpVertexArrayVertexAttribOffsetEXT = (C.GPVERTEXARRAYVERTEXATTRIBOFFSETEXT)(getProcAddr("glVertexArrayVertexAttribOffsetEXT")) + gpVertexArrayVertexBindingDivisorEXT = (C.GPVERTEXARRAYVERTEXBINDINGDIVISOREXT)(getProcAddr("glVertexArrayVertexBindingDivisorEXT")) + gpVertexArrayVertexBuffer = (C.GPVERTEXARRAYVERTEXBUFFER)(getProcAddr("glVertexArrayVertexBuffer")) + gpVertexArrayVertexBuffers = (C.GPVERTEXARRAYVERTEXBUFFERS)(getProcAddr("glVertexArrayVertexBuffers")) + gpVertexArrayVertexOffsetEXT = (C.GPVERTEXARRAYVERTEXOFFSETEXT)(getProcAddr("glVertexArrayVertexOffsetEXT")) + gpVertexAttrib1d = (C.GPVERTEXATTRIB1D)(getProcAddr("glVertexAttrib1d")) + if gpVertexAttrib1d == nil { + return errors.New("glVertexAttrib1d") + } + gpVertexAttrib1dv = (C.GPVERTEXATTRIB1DV)(getProcAddr("glVertexAttrib1dv")) + if gpVertexAttrib1dv == nil { + return errors.New("glVertexAttrib1dv") + } + gpVertexAttrib1f = (C.GPVERTEXATTRIB1F)(getProcAddr("glVertexAttrib1f")) + if gpVertexAttrib1f == nil { + return errors.New("glVertexAttrib1f") + } + gpVertexAttrib1fv = (C.GPVERTEXATTRIB1FV)(getProcAddr("glVertexAttrib1fv")) + if gpVertexAttrib1fv == nil { + return errors.New("glVertexAttrib1fv") + } + gpVertexAttrib1s = (C.GPVERTEXATTRIB1S)(getProcAddr("glVertexAttrib1s")) + if gpVertexAttrib1s == nil { + return errors.New("glVertexAttrib1s") + } + gpVertexAttrib1sv = (C.GPVERTEXATTRIB1SV)(getProcAddr("glVertexAttrib1sv")) + if gpVertexAttrib1sv == nil { + return errors.New("glVertexAttrib1sv") + } + gpVertexAttrib2d = (C.GPVERTEXATTRIB2D)(getProcAddr("glVertexAttrib2d")) + if gpVertexAttrib2d == nil { + return errors.New("glVertexAttrib2d") + } + gpVertexAttrib2dv = (C.GPVERTEXATTRIB2DV)(getProcAddr("glVertexAttrib2dv")) + if gpVertexAttrib2dv == nil { + return errors.New("glVertexAttrib2dv") + } + gpVertexAttrib2f = (C.GPVERTEXATTRIB2F)(getProcAddr("glVertexAttrib2f")) + if gpVertexAttrib2f == nil { + return errors.New("glVertexAttrib2f") + } + gpVertexAttrib2fv = (C.GPVERTEXATTRIB2FV)(getProcAddr("glVertexAttrib2fv")) + if gpVertexAttrib2fv == nil { + return errors.New("glVertexAttrib2fv") + } + gpVertexAttrib2s = (C.GPVERTEXATTRIB2S)(getProcAddr("glVertexAttrib2s")) + if gpVertexAttrib2s == nil { + return errors.New("glVertexAttrib2s") + } + gpVertexAttrib2sv = (C.GPVERTEXATTRIB2SV)(getProcAddr("glVertexAttrib2sv")) + if gpVertexAttrib2sv == nil { + return errors.New("glVertexAttrib2sv") + } + gpVertexAttrib3d = (C.GPVERTEXATTRIB3D)(getProcAddr("glVertexAttrib3d")) + if gpVertexAttrib3d == nil { + return errors.New("glVertexAttrib3d") + } + gpVertexAttrib3dv = (C.GPVERTEXATTRIB3DV)(getProcAddr("glVertexAttrib3dv")) + if gpVertexAttrib3dv == nil { + return errors.New("glVertexAttrib3dv") + } + gpVertexAttrib3f = (C.GPVERTEXATTRIB3F)(getProcAddr("glVertexAttrib3f")) + if gpVertexAttrib3f == nil { + return errors.New("glVertexAttrib3f") + } + gpVertexAttrib3fv = (C.GPVERTEXATTRIB3FV)(getProcAddr("glVertexAttrib3fv")) + if gpVertexAttrib3fv == nil { + return errors.New("glVertexAttrib3fv") + } + gpVertexAttrib3s = (C.GPVERTEXATTRIB3S)(getProcAddr("glVertexAttrib3s")) + if gpVertexAttrib3s == nil { + return errors.New("glVertexAttrib3s") + } + gpVertexAttrib3sv = (C.GPVERTEXATTRIB3SV)(getProcAddr("glVertexAttrib3sv")) + if gpVertexAttrib3sv == nil { + return errors.New("glVertexAttrib3sv") + } + gpVertexAttrib4Nbv = (C.GPVERTEXATTRIB4NBV)(getProcAddr("glVertexAttrib4Nbv")) + if gpVertexAttrib4Nbv == nil { + return errors.New("glVertexAttrib4Nbv") + } + gpVertexAttrib4Niv = (C.GPVERTEXATTRIB4NIV)(getProcAddr("glVertexAttrib4Niv")) + if gpVertexAttrib4Niv == nil { + return errors.New("glVertexAttrib4Niv") + } + gpVertexAttrib4Nsv = (C.GPVERTEXATTRIB4NSV)(getProcAddr("glVertexAttrib4Nsv")) + if gpVertexAttrib4Nsv == nil { + return errors.New("glVertexAttrib4Nsv") + } + gpVertexAttrib4Nub = (C.GPVERTEXATTRIB4NUB)(getProcAddr("glVertexAttrib4Nub")) + if gpVertexAttrib4Nub == nil { + return errors.New("glVertexAttrib4Nub") + } + gpVertexAttrib4Nubv = (C.GPVERTEXATTRIB4NUBV)(getProcAddr("glVertexAttrib4Nubv")) + if gpVertexAttrib4Nubv == nil { + return errors.New("glVertexAttrib4Nubv") + } + gpVertexAttrib4Nuiv = (C.GPVERTEXATTRIB4NUIV)(getProcAddr("glVertexAttrib4Nuiv")) + if gpVertexAttrib4Nuiv == nil { + return errors.New("glVertexAttrib4Nuiv") + } + gpVertexAttrib4Nusv = (C.GPVERTEXATTRIB4NUSV)(getProcAddr("glVertexAttrib4Nusv")) + if gpVertexAttrib4Nusv == nil { + return errors.New("glVertexAttrib4Nusv") + } + gpVertexAttrib4bv = (C.GPVERTEXATTRIB4BV)(getProcAddr("glVertexAttrib4bv")) + if gpVertexAttrib4bv == nil { + return errors.New("glVertexAttrib4bv") + } + gpVertexAttrib4d = (C.GPVERTEXATTRIB4D)(getProcAddr("glVertexAttrib4d")) + if gpVertexAttrib4d == nil { + return errors.New("glVertexAttrib4d") + } + gpVertexAttrib4dv = (C.GPVERTEXATTRIB4DV)(getProcAddr("glVertexAttrib4dv")) + if gpVertexAttrib4dv == nil { + return errors.New("glVertexAttrib4dv") + } + gpVertexAttrib4f = (C.GPVERTEXATTRIB4F)(getProcAddr("glVertexAttrib4f")) + if gpVertexAttrib4f == nil { + return errors.New("glVertexAttrib4f") + } + gpVertexAttrib4fv = (C.GPVERTEXATTRIB4FV)(getProcAddr("glVertexAttrib4fv")) + if gpVertexAttrib4fv == nil { + return errors.New("glVertexAttrib4fv") + } + gpVertexAttrib4iv = (C.GPVERTEXATTRIB4IV)(getProcAddr("glVertexAttrib4iv")) + if gpVertexAttrib4iv == nil { + return errors.New("glVertexAttrib4iv") + } + gpVertexAttrib4s = (C.GPVERTEXATTRIB4S)(getProcAddr("glVertexAttrib4s")) + if gpVertexAttrib4s == nil { + return errors.New("glVertexAttrib4s") + } + gpVertexAttrib4sv = (C.GPVERTEXATTRIB4SV)(getProcAddr("glVertexAttrib4sv")) + if gpVertexAttrib4sv == nil { + return errors.New("glVertexAttrib4sv") + } + gpVertexAttrib4ubv = (C.GPVERTEXATTRIB4UBV)(getProcAddr("glVertexAttrib4ubv")) + if gpVertexAttrib4ubv == nil { + return errors.New("glVertexAttrib4ubv") + } + gpVertexAttrib4uiv = (C.GPVERTEXATTRIB4UIV)(getProcAddr("glVertexAttrib4uiv")) + if gpVertexAttrib4uiv == nil { + return errors.New("glVertexAttrib4uiv") + } + gpVertexAttrib4usv = (C.GPVERTEXATTRIB4USV)(getProcAddr("glVertexAttrib4usv")) + if gpVertexAttrib4usv == nil { + return errors.New("glVertexAttrib4usv") + } + gpVertexAttribBinding = (C.GPVERTEXATTRIBBINDING)(getProcAddr("glVertexAttribBinding")) + gpVertexAttribDivisor = (C.GPVERTEXATTRIBDIVISOR)(getProcAddr("glVertexAttribDivisor")) + if gpVertexAttribDivisor == nil { + return errors.New("glVertexAttribDivisor") + } + gpVertexAttribDivisorARB = (C.GPVERTEXATTRIBDIVISORARB)(getProcAddr("glVertexAttribDivisorARB")) + gpVertexAttribFormat = (C.GPVERTEXATTRIBFORMAT)(getProcAddr("glVertexAttribFormat")) + gpVertexAttribFormatNV = (C.GPVERTEXATTRIBFORMATNV)(getProcAddr("glVertexAttribFormatNV")) + gpVertexAttribI1i = (C.GPVERTEXATTRIBI1I)(getProcAddr("glVertexAttribI1i")) + if gpVertexAttribI1i == nil { + return errors.New("glVertexAttribI1i") + } + gpVertexAttribI1iv = (C.GPVERTEXATTRIBI1IV)(getProcAddr("glVertexAttribI1iv")) + if gpVertexAttribI1iv == nil { + return errors.New("glVertexAttribI1iv") + } + gpVertexAttribI1ui = (C.GPVERTEXATTRIBI1UI)(getProcAddr("glVertexAttribI1ui")) + if gpVertexAttribI1ui == nil { + return errors.New("glVertexAttribI1ui") + } + gpVertexAttribI1uiv = (C.GPVERTEXATTRIBI1UIV)(getProcAddr("glVertexAttribI1uiv")) + if gpVertexAttribI1uiv == nil { + return errors.New("glVertexAttribI1uiv") + } + gpVertexAttribI2i = (C.GPVERTEXATTRIBI2I)(getProcAddr("glVertexAttribI2i")) + if gpVertexAttribI2i == nil { + return errors.New("glVertexAttribI2i") + } + gpVertexAttribI2iv = (C.GPVERTEXATTRIBI2IV)(getProcAddr("glVertexAttribI2iv")) + if gpVertexAttribI2iv == nil { + return errors.New("glVertexAttribI2iv") + } + gpVertexAttribI2ui = (C.GPVERTEXATTRIBI2UI)(getProcAddr("glVertexAttribI2ui")) + if gpVertexAttribI2ui == nil { + return errors.New("glVertexAttribI2ui") + } + gpVertexAttribI2uiv = (C.GPVERTEXATTRIBI2UIV)(getProcAddr("glVertexAttribI2uiv")) + if gpVertexAttribI2uiv == nil { + return errors.New("glVertexAttribI2uiv") + } + gpVertexAttribI3i = (C.GPVERTEXATTRIBI3I)(getProcAddr("glVertexAttribI3i")) + if gpVertexAttribI3i == nil { + return errors.New("glVertexAttribI3i") + } + gpVertexAttribI3iv = (C.GPVERTEXATTRIBI3IV)(getProcAddr("glVertexAttribI3iv")) + if gpVertexAttribI3iv == nil { + return errors.New("glVertexAttribI3iv") + } + gpVertexAttribI3ui = (C.GPVERTEXATTRIBI3UI)(getProcAddr("glVertexAttribI3ui")) + if gpVertexAttribI3ui == nil { + return errors.New("glVertexAttribI3ui") + } + gpVertexAttribI3uiv = (C.GPVERTEXATTRIBI3UIV)(getProcAddr("glVertexAttribI3uiv")) + if gpVertexAttribI3uiv == nil { + return errors.New("glVertexAttribI3uiv") + } + gpVertexAttribI4bv = (C.GPVERTEXATTRIBI4BV)(getProcAddr("glVertexAttribI4bv")) + if gpVertexAttribI4bv == nil { + return errors.New("glVertexAttribI4bv") + } + gpVertexAttribI4i = (C.GPVERTEXATTRIBI4I)(getProcAddr("glVertexAttribI4i")) + if gpVertexAttribI4i == nil { + return errors.New("glVertexAttribI4i") + } + gpVertexAttribI4iv = (C.GPVERTEXATTRIBI4IV)(getProcAddr("glVertexAttribI4iv")) + if gpVertexAttribI4iv == nil { + return errors.New("glVertexAttribI4iv") + } + gpVertexAttribI4sv = (C.GPVERTEXATTRIBI4SV)(getProcAddr("glVertexAttribI4sv")) + if gpVertexAttribI4sv == nil { + return errors.New("glVertexAttribI4sv") + } + gpVertexAttribI4ubv = (C.GPVERTEXATTRIBI4UBV)(getProcAddr("glVertexAttribI4ubv")) + if gpVertexAttribI4ubv == nil { + return errors.New("glVertexAttribI4ubv") + } + gpVertexAttribI4ui = (C.GPVERTEXATTRIBI4UI)(getProcAddr("glVertexAttribI4ui")) + if gpVertexAttribI4ui == nil { + return errors.New("glVertexAttribI4ui") + } + gpVertexAttribI4uiv = (C.GPVERTEXATTRIBI4UIV)(getProcAddr("glVertexAttribI4uiv")) + if gpVertexAttribI4uiv == nil { + return errors.New("glVertexAttribI4uiv") + } + gpVertexAttribI4usv = (C.GPVERTEXATTRIBI4USV)(getProcAddr("glVertexAttribI4usv")) + if gpVertexAttribI4usv == nil { + return errors.New("glVertexAttribI4usv") + } + gpVertexAttribIFormat = (C.GPVERTEXATTRIBIFORMAT)(getProcAddr("glVertexAttribIFormat")) + gpVertexAttribIFormatNV = (C.GPVERTEXATTRIBIFORMATNV)(getProcAddr("glVertexAttribIFormatNV")) + gpVertexAttribIPointer = (C.GPVERTEXATTRIBIPOINTER)(getProcAddr("glVertexAttribIPointer")) + if gpVertexAttribIPointer == nil { + return errors.New("glVertexAttribIPointer") + } + gpVertexAttribL1d = (C.GPVERTEXATTRIBL1D)(getProcAddr("glVertexAttribL1d")) + gpVertexAttribL1dv = (C.GPVERTEXATTRIBL1DV)(getProcAddr("glVertexAttribL1dv")) + gpVertexAttribL1i64NV = (C.GPVERTEXATTRIBL1I64NV)(getProcAddr("glVertexAttribL1i64NV")) + gpVertexAttribL1i64vNV = (C.GPVERTEXATTRIBL1I64VNV)(getProcAddr("glVertexAttribL1i64vNV")) + gpVertexAttribL1ui64ARB = (C.GPVERTEXATTRIBL1UI64ARB)(getProcAddr("glVertexAttribL1ui64ARB")) + gpVertexAttribL1ui64NV = (C.GPVERTEXATTRIBL1UI64NV)(getProcAddr("glVertexAttribL1ui64NV")) + gpVertexAttribL1ui64vARB = (C.GPVERTEXATTRIBL1UI64VARB)(getProcAddr("glVertexAttribL1ui64vARB")) + gpVertexAttribL1ui64vNV = (C.GPVERTEXATTRIBL1UI64VNV)(getProcAddr("glVertexAttribL1ui64vNV")) + gpVertexAttribL2d = (C.GPVERTEXATTRIBL2D)(getProcAddr("glVertexAttribL2d")) + gpVertexAttribL2dv = (C.GPVERTEXATTRIBL2DV)(getProcAddr("glVertexAttribL2dv")) + gpVertexAttribL2i64NV = (C.GPVERTEXATTRIBL2I64NV)(getProcAddr("glVertexAttribL2i64NV")) + gpVertexAttribL2i64vNV = (C.GPVERTEXATTRIBL2I64VNV)(getProcAddr("glVertexAttribL2i64vNV")) + gpVertexAttribL2ui64NV = (C.GPVERTEXATTRIBL2UI64NV)(getProcAddr("glVertexAttribL2ui64NV")) + gpVertexAttribL2ui64vNV = (C.GPVERTEXATTRIBL2UI64VNV)(getProcAddr("glVertexAttribL2ui64vNV")) + gpVertexAttribL3d = (C.GPVERTEXATTRIBL3D)(getProcAddr("glVertexAttribL3d")) + gpVertexAttribL3dv = (C.GPVERTEXATTRIBL3DV)(getProcAddr("glVertexAttribL3dv")) + gpVertexAttribL3i64NV = (C.GPVERTEXATTRIBL3I64NV)(getProcAddr("glVertexAttribL3i64NV")) + gpVertexAttribL3i64vNV = (C.GPVERTEXATTRIBL3I64VNV)(getProcAddr("glVertexAttribL3i64vNV")) + gpVertexAttribL3ui64NV = (C.GPVERTEXATTRIBL3UI64NV)(getProcAddr("glVertexAttribL3ui64NV")) + gpVertexAttribL3ui64vNV = (C.GPVERTEXATTRIBL3UI64VNV)(getProcAddr("glVertexAttribL3ui64vNV")) + gpVertexAttribL4d = (C.GPVERTEXATTRIBL4D)(getProcAddr("glVertexAttribL4d")) + gpVertexAttribL4dv = (C.GPVERTEXATTRIBL4DV)(getProcAddr("glVertexAttribL4dv")) + gpVertexAttribL4i64NV = (C.GPVERTEXATTRIBL4I64NV)(getProcAddr("glVertexAttribL4i64NV")) + gpVertexAttribL4i64vNV = (C.GPVERTEXATTRIBL4I64VNV)(getProcAddr("glVertexAttribL4i64vNV")) + gpVertexAttribL4ui64NV = (C.GPVERTEXATTRIBL4UI64NV)(getProcAddr("glVertexAttribL4ui64NV")) + gpVertexAttribL4ui64vNV = (C.GPVERTEXATTRIBL4UI64VNV)(getProcAddr("glVertexAttribL4ui64vNV")) + gpVertexAttribLFormat = (C.GPVERTEXATTRIBLFORMAT)(getProcAddr("glVertexAttribLFormat")) + gpVertexAttribLFormatNV = (C.GPVERTEXATTRIBLFORMATNV)(getProcAddr("glVertexAttribLFormatNV")) + gpVertexAttribLPointer = (C.GPVERTEXATTRIBLPOINTER)(getProcAddr("glVertexAttribLPointer")) + gpVertexAttribP1ui = (C.GPVERTEXATTRIBP1UI)(getProcAddr("glVertexAttribP1ui")) + if gpVertexAttribP1ui == nil { + return errors.New("glVertexAttribP1ui") + } + gpVertexAttribP1uiv = (C.GPVERTEXATTRIBP1UIV)(getProcAddr("glVertexAttribP1uiv")) + if gpVertexAttribP1uiv == nil { + return errors.New("glVertexAttribP1uiv") + } + gpVertexAttribP2ui = (C.GPVERTEXATTRIBP2UI)(getProcAddr("glVertexAttribP2ui")) + if gpVertexAttribP2ui == nil { + return errors.New("glVertexAttribP2ui") + } + gpVertexAttribP2uiv = (C.GPVERTEXATTRIBP2UIV)(getProcAddr("glVertexAttribP2uiv")) + if gpVertexAttribP2uiv == nil { + return errors.New("glVertexAttribP2uiv") + } + gpVertexAttribP3ui = (C.GPVERTEXATTRIBP3UI)(getProcAddr("glVertexAttribP3ui")) + if gpVertexAttribP3ui == nil { + return errors.New("glVertexAttribP3ui") + } + gpVertexAttribP3uiv = (C.GPVERTEXATTRIBP3UIV)(getProcAddr("glVertexAttribP3uiv")) + if gpVertexAttribP3uiv == nil { + return errors.New("glVertexAttribP3uiv") + } + gpVertexAttribP4ui = (C.GPVERTEXATTRIBP4UI)(getProcAddr("glVertexAttribP4ui")) + if gpVertexAttribP4ui == nil { + return errors.New("glVertexAttribP4ui") + } + gpVertexAttribP4uiv = (C.GPVERTEXATTRIBP4UIV)(getProcAddr("glVertexAttribP4uiv")) + if gpVertexAttribP4uiv == nil { + return errors.New("glVertexAttribP4uiv") + } + gpVertexAttribPointer = (C.GPVERTEXATTRIBPOINTER)(getProcAddr("glVertexAttribPointer")) + if gpVertexAttribPointer == nil { + return errors.New("glVertexAttribPointer") + } + gpVertexBindingDivisor = (C.GPVERTEXBINDINGDIVISOR)(getProcAddr("glVertexBindingDivisor")) + gpVertexFormatNV = (C.GPVERTEXFORMATNV)(getProcAddr("glVertexFormatNV")) + gpViewport = (C.GPVIEWPORT)(getProcAddr("glViewport")) + if gpViewport == nil { + return errors.New("glViewport") + } + gpViewportArrayv = (C.GPVIEWPORTARRAYV)(getProcAddr("glViewportArrayv")) + gpViewportIndexedf = (C.GPVIEWPORTINDEXEDF)(getProcAddr("glViewportIndexedf")) + gpViewportIndexedfv = (C.GPVIEWPORTINDEXEDFV)(getProcAddr("glViewportIndexedfv")) + gpViewportPositionWScaleNV = (C.GPVIEWPORTPOSITIONWSCALENV)(getProcAddr("glViewportPositionWScaleNV")) + gpViewportSwizzleNV = (C.GPVIEWPORTSWIZZLENV)(getProcAddr("glViewportSwizzleNV")) + gpWaitSync = (C.GPWAITSYNC)(getProcAddr("glWaitSync")) + if gpWaitSync == nil { + return errors.New("glWaitSync") + } + gpWaitVkSemaphoreNV = (C.GPWAITVKSEMAPHORENV)(getProcAddr("glWaitVkSemaphoreNV")) + gpWeightPathsNV = (C.GPWEIGHTPATHSNV)(getProcAddr("glWeightPathsNV")) + gpWindowRectanglesEXT = (C.GPWINDOWRECTANGLESEXT)(getProcAddr("glWindowRectanglesEXT")) + return nil +} diff --git a/vendor/github.com/go-gl/gl/v3.3-core/gl/procaddr.go b/vendor/github.com/go-gl/gl/v3.3-core/gl/procaddr.go new file mode 100644 index 0000000..4bcc6b2 --- /dev/null +++ b/vendor/github.com/go-gl/gl/v3.3-core/gl/procaddr.go @@ -0,0 +1,75 @@ +// Code generated by glow (https://github.com/go-gl/glow). DO NOT EDIT. + +// This file implements GlowGetProcAddress for every supported platform. The +// correct version is chosen automatically based on build tags: +// +// windows: WGL +// darwin: CGL +// linux freebsd netbsd openbsd: GLX +// +// Use of EGL instead of the platform's default (listed above) is made possible +// via the "egl" build tag. +// +// It is also possible to install your own function outside this package for +// retrieving OpenGL function pointers, to do this see InitWithProcAddrFunc. + +package gl + +/* +#cgo windows CFLAGS: -DTAG_WINDOWS +#cgo !gles2,windows LDFLAGS: -lopengl32 +#cgo gles2,windows LDFLAGS: -lGLESv2 +#cgo darwin CFLAGS: -DTAG_DARWIN +#cgo !gles2,darwin LDFLAGS: -framework OpenGL +#cgo gles2,darwin LDFLAGS: -framework OpenGLES +#cgo linux freebsd netbsd openbsd CFLAGS: -DTAG_POSIX +#cgo !egl,linux !egl,freebsd !egl,netbsd !egl,openbsd pkg-config: gl +#cgo egl,linux egl,freebsd egl,netbsd egl,openbsd egl,windows CFLAGS: -DTAG_EGL +#cgo egl,linux egl,freebsd egl,netbsd egl,openbsd pkg-config: egl +#cgo egl,windows LDFLAGS: -lEGL +#cgo egl,darwin LDFLAGS: -lEGL +// Check the EGL tag first as it takes priority over the platform's default +// configuration of WGL/GLX/CGL. +#if defined(TAG_EGL) + #include + #include + static void* GlowGetProcAddress(const char* name) { + return eglGetProcAddress(name); + } +#elif defined(TAG_WINDOWS) + #define WIN32_LEAN_AND_MEAN 1 + #include + #include + static HMODULE ogl32dll = NULL; + static void* GlowGetProcAddress(const char* name) { + void* pf = wglGetProcAddress((LPCSTR) name); + if (pf) { + return pf; + } + if (ogl32dll == NULL) { + ogl32dll = LoadLibraryA("opengl32.dll"); + } + return GetProcAddress(ogl32dll, (LPCSTR) name); + } +#elif defined(TAG_DARWIN) + #include + #include + static void* GlowGetProcAddress(const char* name) { + return dlsym(RTLD_DEFAULT, name); + } +#elif defined(TAG_POSIX) + #include + #include + static void* GlowGetProcAddress(const char* name) { + return glXGetProcAddress((const GLubyte *) name); + } +#endif +*/ +import "C" +import "unsafe" + +func getProcAddress(namea string) unsafe.Pointer { + cname := C.CString(namea) + defer C.free(unsafe.Pointer(cname)) + return C.GlowGetProcAddress(cname) +} diff --git a/vendor/github.com/go-gl/mathgl/AUTHORS b/vendor/github.com/go-gl/mathgl/AUTHORS new file mode 100644 index 0000000..3de97dc --- /dev/null +++ b/vendor/github.com/go-gl/mathgl/AUTHORS @@ -0,0 +1,14 @@ +# This is the official list of go-gl/mathgl authors for copyright purposes. +# This file is distinct from the CONTRIBUTORS files. +# See the latter for an explanation. + +# Names should be added to this file as +# Name or Organization +# The email address is not required for organizations. + +# Please keep the list sorted. + +Alex Vasi +Dmitri Shuralyov +GlenKelley +Zoe Juozapaitis diff --git a/vendor/github.com/go-gl/mathgl/CONTRIBUTORS b/vendor/github.com/go-gl/mathgl/CONTRIBUTORS new file mode 100644 index 0000000..88569cd --- /dev/null +++ b/vendor/github.com/go-gl/mathgl/CONTRIBUTORS @@ -0,0 +1,21 @@ +# This is the official list of people who can contribute +# (and typically have contributed) code to the mathgl +# repository. +# +# The AUTHORS file lists the copyright holders; this file +# lists people. For example, Google employees would be listed here +# but not in AUTHORS, because Google would hold the copyright. +# +# When adding J Random Contributor's name to this file, +# either J's name or J's organization's name should be +# added to the AUTHORS file. +# +# Names should be added to this file like so: +# Name +# +# Please keep the list sorted. + +Alex Vasi +Dmitri Shuralyov +GlenKelley +Zoe Juozapaitis diff --git a/vendor/github.com/go-gl/mathgl/LICENSE b/vendor/github.com/go-gl/mathgl/LICENSE new file mode 100644 index 0000000..a780cbd --- /dev/null +++ b/vendor/github.com/go-gl/mathgl/LICENSE @@ -0,0 +1,23 @@ +Copyright ©2013 The go-gl Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of the gonum project nor the names of its authors and + contributors may be used to endorse or promote products derived from this + software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file diff --git a/vendor/github.com/go-gl/mathgl/mgl32/conv.go b/vendor/github.com/go-gl/mathgl/mgl32/conv.go new file mode 100644 index 0000000..b5b1775 --- /dev/null +++ b/vendor/github.com/go-gl/mathgl/mgl32/conv.go @@ -0,0 +1,94 @@ +// Copyright 2014 The go-gl Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package mgl32 + +import ( + "math" +) + +// CartesianToSpherical converts 3-dimensional cartesian coordinates (x,y,z) to spherical +// coordinates with radius r, inclination theta, and azimuth phi. +// +// All angles are in radians. +func CartesianToSpherical(coord Vec3) (r, theta, phi float32) { + r = coord.Len() + theta = float32(math.Acos(float64(coord[2] / r))) + phi = float32(math.Atan2(float64(coord[1]), float64(coord[0]))) + + return +} + +// CartesianToCylindical converts 3-dimensional cartesian coordinates (x,y,z) to +// cylindrical coordinates with radial distance r, azimuth phi, and height z. +// +// All angles are in radians. +func CartesianToCylindical(coord Vec3) (rho, phi, z float32) { + rho = float32(math.Hypot(float64(coord[0]), float64(coord[1]))) + + phi = float32(math.Atan2(float64(coord[1]), float64(coord[0]))) + + z = coord[2] + + return +} + +// SphericalToCartesian converts spherical coordinates with radius r, inclination theta, +// and azimuth phi to cartesian coordinates (x,y,z). +// +// Angles are in radians. +func SphericalToCartesian(r, theta, phi float32) Vec3 { + st, ct := math.Sincos(float64(theta)) + sp, cp := math.Sincos(float64(phi)) + + return Vec3{r * float32(st*cp), r * float32(st*sp), r * float32(ct)} +} + +// SphericalToCylindrical converts spherical coordinates with radius r, +// inclination theta, and azimuth phi to cylindrical coordinates with radial +// distance r, azimuth phi, and height z. +// +// Angles are in radians +func SphericalToCylindrical(r, theta, phi float32) (rho, phi2, z float32) { + s, c := math.Sincos(float64(theta)) + + rho = r * float32(s) + z = r * float32(c) + phi2 = phi + + return +} + +// CylindircalToSpherical converts cylindrical coordinates with radial distance +// r, azimuth phi, and height z to spherical coordinates with radius r, +// inclination theta, and azimuth phi. +// +// Angles are in radians +func CylindircalToSpherical(rho, phi, z float32) (r, theta, phi2 float32) { + r = float32(math.Hypot(float64(rho), float64(z))) + phi2 = phi + theta = float32(math.Atan2(float64(rho), float64(z))) + + return +} + +// CylindricalToCartesian converts cylindrical coordinates with radial distance +// r, azimuth phi, and height z to cartesian coordinates (x,y,z) +// +// Angles are in radians. +func CylindricalToCartesian(rho, phi, z float32) Vec3 { + s, c := math.Sincos(float64(phi)) + + return Vec3{rho * float32(c), rho * float32(s), z} +} + +// DegToRad converts degrees to radians +func DegToRad(angle float32) float32 { + return angle * float32(math.Pi) / 180 +} + +// RadToDeg converts radians to degrees +func RadToDeg(angle float32) float32 { + return angle * 180 / float32(math.Pi) +} diff --git a/vendor/github.com/go-gl/mathgl/mgl32/doc.go b/vendor/github.com/go-gl/mathgl/mgl32/doc.go new file mode 100644 index 0000000..c7fcf9f --- /dev/null +++ b/vendor/github.com/go-gl/mathgl/mgl32/doc.go @@ -0,0 +1,22 @@ +// Copyright 2014 The go-gl Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +/* +Package mgl[32|64] (an abbreviation of mathgl since the packages were split between 32 and 64-bit versions) +is a pure Go math package specialized for 3D math, with inspiration from GLM. It provides statically-sized vectors and matrices with +compile-time generated calculations for most basic math operations. It also provides several basic graphics utilities such as bezier curves and surfaces, +generation of basic primitives like circles, easy creation of common matrices such as perspective or rotation, and common operations like converting +to/from screen/OpenGL coordinates or Projecting/Unprojecting from an MVP matrix. Quaternions are also supported. + +The basic vectors and matrices are written with code generation, so looking directly at the source will probably be a bit confusing. I recommend looking at the Godoc +instead, as all basic functions are documented. + +This package is written in Column Major Order to make it easier with OpenGL. This means for uniform blocks you can use the default ordering, and when you call +pass-in functions you can leave the "transpose" argument as false. + +The package now contains variable sized vectors and matrices. Using these is discouraged. They exist for corner cases where you need "small" matrices that are still +bigger than 4x4. An example may be a Jacobean used for inverse kinematics. Things like computer vision or general linear algebra are best left to packages +more directly suited for that task -- OpenCV, BLAS, LAPACK, numpy, gonum (if you want to stay in Go), and so on. +*/ +package mgl32 diff --git a/vendor/github.com/go-gl/mathgl/mgl32/matmn.go b/vendor/github.com/go-gl/mathgl/mgl32/matmn.go new file mode 100644 index 0000000..82360e9 --- /dev/null +++ b/vendor/github.com/go-gl/mathgl/mgl32/matmn.go @@ -0,0 +1,511 @@ +// Copyright 2014 The go-gl Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package mgl32 + +import ( + "math" +) + +// MatMxN is an arbitrary mxn matrix backed by a slice of floats. +// +// This is emphatically not recommended for hardcore n-dimensional +// linear algebra. For that purpose I recommend github.com/gonum/matrix or +// well-tested C libraries such as BLAS or LAPACK. +// +// This is meant to complement future algorithms that may require matrices larger than +// 4x4, but still relatively small (e.g. Jacobeans for inverse kinematics). +// +// It makes use of the same memory sync.Pool set that VecN does, with the same sizing rules. +// +// MatMN will always check if the receiver is nil on any method. Meaning MathMN(nil).Add(dst,m2) +// should always work. Except for the Reshape function, the semantics of this is to "propogate" nils +// forward, so if an invalid operation occurs in a long chain of matrix operations, the overall result will be nil. +type MatMxN struct { + m, n int + dat []float32 +} + +// NewMatrix creates a matrix backed by a new slice of size m*n +func NewMatrix(m, n int) (mat *MatMxN) { + if shouldPool { + return &MatMxN{m: m, n: n, dat: grabFromPool(m * n)} + } else { + return &MatMxN{m: m, n: n, dat: make([]float32, m*n)} + } +} + +// NewMatrixFromData returns a matrix with data specified by the data in src +// +// For instance, to create a 3x3 MatMN from a Mat3 +// +// m1 := mgl32.Rotate3DX(3.14159) +// mat := mgl32.NewBackedMatrix(m1[:],3,3) +// +// will create an MN matrix matching the data in the original rotation matrix. +// This matrix is NOT backed by the initial slice; it's a copy of the data +// +// If m*n > cap(src), this function will panic. +func NewMatrixFromData(src []float32, m, n int) *MatMxN { + var internal []float32 + if shouldPool { + internal = grabFromPool(m * n) + } else { + internal = make([]float32, m*n) + } + copy(internal, src[:m*n]) + + return &MatMxN{m: m, n: n, dat: internal} +} + +// CopyMatMN copies src into dst. This Reshapes dst +// to the same size as src. +// +// If dst or src is nil, this is a no-op +func CopyMatMN(dst, src *MatMxN) { + if dst == nil || src == nil { + return + } + dst.Reshape(src.m, src.n) + copy(dst.dat, src.dat) +} + +// IdentN stores the NxN identity matrix in dst, reallocating as necessary. +func IdentN(dst *MatMxN, n int) *MatMxN { + dst = dst.Reshape(n, n) + + for i := 0; i < n; i++ { + for j := 0; j < n; j++ { + if i == j { + dst.Set(i, j, 1) + } else { + dst.Set(i, j, 0) + } + } + } + + return dst +} + +// DiagN creates an NxN diagonal matrix seeded by the diagonal vector diag. +// Meaning: for all entries, where i==j, dst.At(i,j) = diag[i]. Otherwise +// dst.At(i,j) = 0 +// +// This reshapes dst to the correct size, returning/grabbing from the memory +// pool as necessary. +func DiagN(dst *MatMxN, diag *VecN) *MatMxN { + dst = dst.Reshape(len(diag.vec), len(diag.vec)) + n := len(diag.vec) + + for i := 0; i < n; i++ { + for j := 0; j < n; j++ { + if i == j { + dst.Set(i, j, diag.vec[i]) + } else { + dst.Set(i, j, 0) + } + } + } + + return dst +} + +// Zero reshapes the matrix to m by n and zeroes out all +// elements. +func (mat *MatMxN) Zero(m, n int) { + if mat == nil { + return + } + + mat.Reshape(m, n) + for i := range mat.dat { + mat.dat[i] = 0 + } +} + +// destroy returns the underlying matrix slice to the memory pool +func (mat *MatMxN) destroy() { + if mat == nil { + return + } + + if shouldPool && mat.dat != nil { + returnToPool(mat.dat) + } + mat.m, mat.n = 0, 0 + mat.dat = nil +} + +// Reshape reshapes the matrix to the desired dimensions. +// If the overall size of the new matrix (m*n) is bigger +// than the current size, the underlying slice will +// be grown, sending the current slice to the memory pool +// and grabbing a bigger one if necessary +// +// If the caller is a nil pointer, the return value will be a new +// matrix, as if NewMatrix(m,n) had been called. Otherwise it's +// simply the caller. +func (mat *MatMxN) Reshape(m, n int) *MatMxN { + if mat == nil { + return NewMatrix(m, n) + } + + if m*n <= cap(mat.dat) { + if mat.dat != nil { + mat.dat = mat.dat[:m*n] + } else { + mat.dat = []float32{} + } + mat.m, mat.n = m, n + return mat + } + + if shouldPool && mat.dat != nil { + returnToPool(mat.dat) + } + (*mat) = (*NewMatrix(m, n)) + + return mat +} + +// InferMatrix infers an MxN matrix from a constant matrix from this package. +// For instance, a Mat2x3 inferred with this function will work just like +// NewMatrixFromData(m[:],2,3) where m is the Mat2x3. This uses a type switch. +// +// I personally recommend using NewMatrixFromData, because it avoids a +// potentially costly type switch. However, this is also more robust and less +// error prone if you change the size of your matrix somewhere. +// +// If the value passed in is not recognized, it returns an InferMatrixError. +func (mat *MatMxN) InferMatrix(m interface{}) (*MatMxN, error) { + switch raw := m.(type) { + case Mat2: + return NewMatrixFromData(raw[:], 2, 2), nil + case Mat2x3: + return NewMatrixFromData(raw[:], 2, 3), nil + case Mat2x4: + return NewMatrixFromData(raw[:], 2, 4), nil + case Mat3: + return NewMatrixFromData(raw[:], 3, 3), nil + case Mat3x2: + return NewMatrixFromData(raw[:], 3, 2), nil + case Mat3x4: + return NewMatrixFromData(raw[:], 3, 4), nil + case Mat4: + return NewMatrixFromData(raw[:], 4, 4), nil + case Mat4x2: + return NewMatrixFromData(raw[:], 4, 2), nil + case Mat4x3: + return NewMatrixFromData(raw[:], 4, 3), nil + default: + return nil, InferMatrixError{} + } +} + +// Trace returns the trace of a square matrix (sum of all diagonal elements). If +// the matrix is nil, or not square, the result will be NaN. +func (mat *MatMxN) Trace() float32 { + if mat == nil || mat.m != mat.n { + return float32(math.NaN()) + } + + var out float32 + for i := 0; i < mat.m; i++ { + out += mat.At(i, i) + } + + return out +} + +// Transpose takes the transpose of mat and puts it in dst. +// +// If dst is not of the correct dimensions, it will be Reshaped, +// if dst and mat are the same, a temporary matrix of the correct size will +// be allocated; these resources will be released via the memory pool. +// +// This should be improved in the future. +func (mat *MatMxN) Transpose(dst *MatMxN) (t *MatMxN) { + if mat == nil { + return nil + } + + if dst == mat { + dst = NewMatrix(mat.n, mat.m) + + // Copy data to correct matrix, + // delete temporary buffer, + // and set the return value to the + // correct one + defer func() { + copy(mat.dat, dst.dat) + + mat.m, mat.n = mat.n, mat.m + + dst.destroy() + t = mat + }() + + return mat + } else { + dst = dst.Reshape(mat.n, mat.m) + } + + for r := 0; r < mat.m; r++ { + for c := 0; c < mat.n; c++ { + dst.dat[r*dst.m+c] = mat.dat[c*mat.m+r] + } + } + + return dst +} + +// Raw returns the raw slice backing this matrix +func (mat *MatMxN) Raw() []float32 { + if mat == nil { + return nil + } + + return mat.dat +} + +// NumRows returns the number of rows in this matrix +func (mat *MatMxN) NumRows() int { + return mat.m +} + +// NumCols returns the number of columns in this matrix +func (mat *MatMxN) NumCols() int { + return mat.n +} + +// NumRowCols returns the number of rows and columns in this matrix +// as a single operation +func (mat *MatMxN) NumRowCols() (rows, cols int) { + return mat.m, mat.n +} + +// At returns the element at the given row and column. +// This is garbage in/garbage out and does no bounds +// checking. If the computation happens to lead to an invalid +// element, it will be returned; or it may panic. +func (mat *MatMxN) At(row, col int) float32 { + return mat.dat[col*mat.m+row] +} + +// Set sets the element at the given row and column. +// This is garbage in/garbage out and does no bounds +// checking. If the computation happens to lead to an invalid +// element, it will be set; or it may panic. +func (mat *MatMxN) Set(row, col int, val float32) { + mat.dat[col*mat.m+row] = val +} + +// Add is the arithemtic + operator defined on a MatMxN. +func (mat *MatMxN) Add(dst *MatMxN, addend *MatMxN) *MatMxN { + if mat == nil || addend == nil || mat.m != addend.m || mat.n != addend.n { + return nil + } + + dst = dst.Reshape(mat.m, mat.n) + + // No need to care about rows and columns + // since it's element-wise anyway + for i, el := range mat.dat { + dst.dat[i] = el + addend.dat[i] + } + + return dst +} + +// Sub is the arithemtic - operator defined on a MatMxN. +func (mat *MatMxN) Sub(dst *MatMxN, subtrahend *MatMxN) *MatMxN { + if mat == nil || subtrahend == nil || mat.m != subtrahend.m || mat.n != subtrahend.n { + return nil + } + + dst = dst.Reshape(mat.m, mat.n) + + // No need to care about rows and columns + // since it's element-wise anyway + for i, el := range mat.dat { + dst.dat[i] = el - subtrahend.dat[i] + } + + return dst +} + +// MulMxN performs matrix multiplication on MxN matrix mat and NxO matrix mul, +// storing the result in dst. This returns dst, or nil if the operation is not +// able to be performed. +// +// If mat == dst, or mul == dst a temporary matrix will be used. +// +// This uses the naive algorithm (though on smaller matrices, this can actually +// be faster; about len(mat)+len(mul) < ~100) +func (mat *MatMxN) MulMxN(dst *MatMxN, mul *MatMxN) *MatMxN { + if mat == nil || mul == nil || mat.n != mul.m { + return nil + } + + if dst == mul { + mul = NewMatrix(mul.m, mul.n) + copy(mul.dat, dst.dat) + + // If mat==dst==mul, we need to change + // mat too or we have a bug + if mat == dst { + mat = mul + } + + defer mul.destroy() + } else if dst == mat { + mat = NewMatrix(mat.m, mat.n) + copy(mat.dat, dst.dat) + + defer mat.destroy() + } + + dst = dst.Reshape(mat.m, mul.n) + for r1 := 0; r1 < mat.m; r1++ { + for c2 := 0; c2 < mul.n; c2++ { + + dst.dat[c2*mat.m+r1] = 0 + for i := 0; i < mat.n; i++ { + dst.dat[c2*mat.m+r1] += mat.dat[i*mat.m+r1] * mul.dat[c2*mul.m+i] + } + + } + } + + return dst +} + +// Mul performs a scalar multiplication between mat and some constant c, +// storing the result in dst. Mat and dst can be equal. If dst is not the +// correct size, a Reshape will occur. +func (mat *MatMxN) Mul(dst *MatMxN, c float32) *MatMxN { + if mat == nil { + return nil + } + + dst = dst.Reshape(mat.m, mat.n) + + for i, el := range mat.dat { + dst.dat[i] = el * c + } + + return dst +} + +// MulNx1 multiplies the matrix by a vector of size n. If mat or v is nil, this +// returns nil. If the number of columns in mat does not match the Size of v, +// this also returns nil. +// +// Dst will be resized if it's not big enough. If dst == v; a temporary vector +// will be allocated and returned via the realloc callback when complete. +func (mat *MatMxN) MulNx1(dst, v *VecN) *VecN { + if mat == nil || v == nil || mat.n != len(v.vec) { + return nil + } + if dst == v { + v = NewVecN(len(v.vec)) + copy(v.vec, dst.vec) + + defer v.destroy() + } + + dst = dst.Resize(mat.m) + + for r := 0; r < mat.m; r++ { + dst.vec[r] = 0 + + for c := 0; c < mat.n; c++ { + dst.vec[r] += mat.At(r, c) * v.vec[c] + } + } + + return dst +} + +// ApproxEqual returns whether the two vectors are approximately equal (See +// FloatEqual). +func (mat *MatMxN) ApproxEqual(m2 *MatMxN) bool { + if mat == m2 { + return true + } + if mat.m != m2.m || mat.n != m2.n { + return false + } + + for i, el := range mat.dat { + if !FloatEqual(el, m2.dat[i]) { + return false + } + } + + return true +} + +// ApproxEqualThreshold returns whether the two vectors are approximately equal +// to within the given threshold given by "epsilon" (See ApproxEqualThreshold). +func (mat *MatMxN) ApproxEqualThreshold(m2 *MatMxN, epsilon float32) bool { + if mat == m2 { + return true + } + if mat.m != m2.m || mat.n != m2.n { + return false + } + + for i, el := range mat.dat { + if !FloatEqualThreshold(el, m2.dat[i], epsilon) { + return false + } + } + + return true +} + +// ApproxEqualFunc returns whether the two vectors are approximately equal, +// given a function which compares two scalar elements. +func (mat *MatMxN) ApproxEqualFunc(m2 *MatMxN, comp func(float32, float32) bool) bool { + if mat == m2 { + return true + } + if mat.m != m2.m || mat.n != m2.n { + return false + } + + for i, el := range mat.dat { + if !comp(el, m2.dat[i]) { + return false + } + } + + return true +} + +// InferMatrixError may be returned by InferMatrix. +// +// Make sure you're using a constant matrix such as Mat3 from within the same +// package (meaning: mgl32.MatMxN can't handle a mgl64.Mat2x3). +type InferMatrixError struct{} + +func (me InferMatrixError) Error() string { + return "could not infer matrix. Make sure you're using a constant matrix such as Mat3 from within the same package (meaning: mgl32.MatMxN can't handle a mgl64.Mat2x3)." +} + +// RectangularMatrixError is returned when a rectangular matrix was expected but +// not given. +type RectangularMatrixError struct{} + +func (mse RectangularMatrixError) Error() string { + return "the matrix was the wrong shape, needed a square matrix." +} + +// NilMatrixError is returned when an operand to a function was unexpectedly 'nil'. +type NilMatrixError struct{} + +func (me NilMatrixError) Error() string { + return "the matrix is nil" +} diff --git a/vendor/github.com/go-gl/mathgl/mgl32/matrix.go b/vendor/github.com/go-gl/mathgl/mgl32/matrix.go new file mode 100644 index 0000000..8d8d25a --- /dev/null +++ b/vendor/github.com/go-gl/mathgl/mgl32/matrix.go @@ -0,0 +1,2430 @@ +// Copyright 2014 The go-gl/mathgl Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// This file is generated by codegen.go; DO NOT EDIT +// Edit matrix.tmpl and run "go generate" to make changes. + +package mgl32 + +import ( + "bytes" + "fmt" + "text/tabwriter" +) + +type Mat2 [2 * 2]float32 +type Mat2x3 [2 * 3]float32 +type Mat2x4 [2 * 4]float32 +type Mat3x2 [3 * 2]float32 +type Mat3 [3 * 3]float32 +type Mat3x4 [3 * 4]float32 +type Mat4x2 [4 * 2]float32 +type Mat4x3 [4 * 3]float32 +type Mat4 [4 * 4]float32 + +func (m Mat2) Mat3() Mat3 { + col0, col1 := m.Cols() + return Mat3FromCols( + col0.Vec3(0), + col1.Vec3(0), + Vec3{0, 0, 1}, + ) +} + +func (m Mat2) Mat4() Mat4 { + col0, col1 := m.Cols() + return Mat4FromCols( + col0.Vec4(0, 0), + col1.Vec4(0, 0), + Vec4{0, 0, 1, 0}, + Vec4{0, 0, 0, 1}, + ) +} + +func (m Mat3) Mat2() Mat2 { + col0, col1, _ := m.Cols() + return Mat2FromCols( + col0.Vec2(), + col1.Vec2(), + ) +} + +func (m Mat3) Mat4() Mat4 { + col0, col1, col2 := m.Cols() + return Mat4FromCols( + col0.Vec4(0), + col1.Vec4(0), + col2.Vec4(0), + Vec4{0, 0, 0, 1}, + ) +} + +func (m Mat4) Mat2() Mat2 { + col0, col1, _, _ := m.Cols() + return Mat2FromCols( + col0.Vec2(), + col1.Vec2(), + ) +} + +func (m Mat4) Mat3() Mat3 { + col0, col1, col2, _ := m.Cols() + return Mat3FromCols( + col0.Vec3(), + col1.Vec3(), + col2.Vec3(), + ) +} + +// SetCol sets a Column within the Matrix, so it mutates the calling matrix. +func (m *Mat2) SetCol(col int, v Vec2) { + m[col*2+0], m[col*2+1] = v[0], v[1] +} + +// SetRow sets a Row within the Matrix, so it mutates the calling matrix. +func (m *Mat2) SetRow(row int, v Vec2) { + m[row+0], m[row+2] = v[0], v[1] +} + +// Diag is a basic operation on a square matrix that simply +// returns main diagonal (meaning all elements such that row==col). +func (m Mat2) Diag() Vec2 { + return Vec2{m[0], m[3]} +} + +// Ident2 returns the 2x2 identity matrix. +// The identity matrix is a square matrix with the value 1 on its +// diagonals. The characteristic property of the identity matrix is that +// any matrix multiplied by it is itself. (MI = M; IN = N) +func Ident2() Mat2 { + return Mat2{1, 0, 0, 1} +} + +// Diag2 creates a diagonal matrix from the entries of the input vector. +// That is, for each pointer for row==col, vector[row] is the entry. Otherwise it's 0. +// +// Another way to think about it is that the identity is this function where the every vector element is 1. +func Diag2(v Vec2) Mat2 { + var m Mat2 + m[0], m[3] = v[0], v[1] + return m +} + +// Mat2FromRows builds a new matrix from row vectors. +// The resulting matrix will still be in column major order, but this can be +// good for hand-building matrices. + +func Mat2FromRows(row0, row1 Vec2) Mat2 { + return Mat2{row0[0], row1[0], row0[1], row1[1]} +} + +// Mat2FromCols builds a new matrix from column vectors. +func Mat2FromCols(col0, col1 Vec2) Mat2 { + return Mat2{col0[0], col0[1], col1[0], col1[1]} +} + +// Add performs an element-wise addition of two matrices, this is +// equivalent to iterating over every element of m1 and adding the corresponding value of m2. +func (m1 Mat2) Add(m2 Mat2) Mat2 { + return Mat2{m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2], m1[3] + m2[3]} +} + +// Sub performs an element-wise subtraction of two matrices, this is +// equivalent to iterating over every element of m1 and subtracting the corresponding value of m2. +func (m1 Mat2) Sub(m2 Mat2) Mat2 { + return Mat2{m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2], m1[3] - m2[3]} +} + +// Mul performs a scalar multiplcation of the matrix. This is equivalent to iterating +// over every element of the matrix and multiply it by c. +func (m1 Mat2) Mul(c float32) Mat2 { + return Mat2{m1[0] * c, m1[1] * c, m1[2] * c, m1[3] * c} +} + +// Mul2x1 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat2) Mul2x1(m2 Vec2) Vec2 { + return Vec2{ + m1[0]*m2[0] + m1[2]*m2[1], + m1[1]*m2[0] + m1[3]*m2[1], + } +} + +// Mul2 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat2) Mul2(m2 Mat2) Mat2 { + return Mat2{ + m1[0]*m2[0] + m1[2]*m2[1], + m1[1]*m2[0] + m1[3]*m2[1], + m1[0]*m2[2] + m1[2]*m2[3], + m1[1]*m2[2] + m1[3]*m2[3], + } +} + +// Mul2x3 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat2) Mul2x3(m2 Mat2x3) Mat2x3 { + return Mat2x3{ + m1[0]*m2[0] + m1[2]*m2[1], + m1[1]*m2[0] + m1[3]*m2[1], + m1[0]*m2[2] + m1[2]*m2[3], + m1[1]*m2[2] + m1[3]*m2[3], + m1[0]*m2[4] + m1[2]*m2[5], + m1[1]*m2[4] + m1[3]*m2[5], + } +} + +// Mul2x4 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat2) Mul2x4(m2 Mat2x4) Mat2x4 { + return Mat2x4{ + m1[0]*m2[0] + m1[2]*m2[1], + m1[1]*m2[0] + m1[3]*m2[1], + m1[0]*m2[2] + m1[2]*m2[3], + m1[1]*m2[2] + m1[3]*m2[3], + m1[0]*m2[4] + m1[2]*m2[5], + m1[1]*m2[4] + m1[3]*m2[5], + m1[0]*m2[6] + m1[2]*m2[7], + m1[1]*m2[6] + m1[3]*m2[7], + } +} + +// Transpose produces the transpose of this matrix. For any MxN matrix +// the transpose is an NxM matrix with the rows swapped with the columns. For instance +// the transpose of the Mat3x2 is a Mat2x3 like so: +// +// [[a b]] [[a c e]] +// [[c d]] = [[b d f]] +// [[e f]] +func (m1 Mat2) Transpose() Mat2 { + return Mat2{m1[0], m1[2], m1[1], m1[3]} +} + +// Det returns the determinant of a matrix. It is a measure of a square matrix's +// singularity and invertability, among other things. In this library, the +// determinant is hard coded based on pre-computed cofactor expansion, and uses +// no loops. Of course, the addition and multiplication must still be done. +func (m Mat2) Det() float32 { + return m[0]*m[3] - m[1]*m[2] +} + +// Inv computes the inverse of a square matrix. An inverse is a square matrix such that when multiplied by the +// original, yields the identity. +// +// M_inv * M = M * M_inv = I +// +// In this library, the math is precomputed, and uses no loops, though the multiplications, additions, determinant calculation, and scaling +// are still done. This can still be (relatively) expensive for a 4x4. +// +// This function checks the determinant to see if the matrix is invertible. +// If the determinant is 0.0, this function returns the zero matrix. However, due to floating point errors, it is +// entirely plausible to get a false positive or negative. +// In the future, an alternate function may be written which takes in a pre-computed determinant. +func (m Mat2) Inv() Mat2 { + det := m.Det() + if FloatEqual(det, float32(0.0)) { + return Mat2{} + } + + retMat := Mat2{m[3], -m[1], -m[2], m[0]} + + return retMat.Mul(1 / det) +} + +// ApproxEqual performs an element-wise approximate equality test between two matrices, +// as if FloatEqual had been used. +func (m1 Mat2) ApproxEqual(m2 Mat2) bool { + for i := range m1 { + if !FloatEqual(m1[i], m2[i]) { + return false + } + } + return true +} + +// ApproxEqualThreshold performs an element-wise approximate equality test between two matrices +// with a given epsilon threshold, as if FloatEqualThreshold had been used. +func (m1 Mat2) ApproxEqualThreshold(m2 Mat2, threshold float32) bool { + for i := range m1 { + if !FloatEqualThreshold(m1[i], m2[i], threshold) { + return false + } + } + return true +} + +// ApproxFuncEqual performs an element-wise approximate equality test between two matrices +// with a given equality functions, intended to be used with FloatEqualFunc; although and comparison +// function may be used in practice. +func (m1 Mat2) ApproxFuncEqual(m2 Mat2, eq func(float32, float32) bool) bool { + for i := range m1 { + if !eq(m1[i], m2[i]) { + return false + } + } + return true +} + +// NumRows returns the number of rows in this matrix +func (m Mat2) NumRows() int { + return 2 +} + +// NumCols returns the number of columns in this matrix +func (m Mat2) NumCols() int { + return 2 +} + +// At returns the matrix element at the given row and column. +// This is equivalent to mat[col * numRow + row] where numRow is constant +// (E.G. for a Mat3x2 it's equal to 3) +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// At(5,0) will work just like At(1,1). Or it may panic if it's out of bounds. +func (m Mat2) At(row, col int) float32 { + return m[col*2+row] +} + +// Set sets the corresponding matrix element at the given row and column. +// This has a pointer receiver because it mutates the matrix. +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// Set(5,0,val) will work just like Set(1,1,val). Or it may panic if it's out of bounds. +func (m *Mat2) Set(row, col int, value float32) { + m[col*2+row] = value +} + +// Index returns the index of the given row and column, to be used with direct +// access. E.G. Index(0,0) = 0. +// +// This is a garbage-in garbage-out method. For instance, on a Mat4 asking for the index of +// (5,0) will work the same as asking for (1,1). Or it may give you a value that will cause +// a panic if you try to access the array with it if it's truly out of bounds. +func (m Mat2) Index(row, col int) int { + return col*2 + row +} + +// Row returns a vector representing the corresponding row (starting at row 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecM for a MxN matrix. +func (m Mat2) Row(row int) Vec2 { + return Vec2{m[row+0], m[row+2]} +} + +// Rows decomposes a matrix into its corresponding row vectors. +// This is equivalent to calling mat.Row for each row. +func (m Mat2) Rows() (row0, row1 Vec2) { + return m.Row(0), m.Row(1) +} + +// Col returns a vector representing the corresponding column (starting at col 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecN for a MxN matrix. +func (m Mat2) Col(col int) Vec2 { + return Vec2{m[col*2+0], m[col*2+1]} +} + +// Cols decomposes a matrix into its corresponding column vectors. +// This is equivalent to calling mat.Col for each column. +func (m Mat2) Cols() (col0, col1 Vec2) { + return m.Col(0), m.Col(1) +} + +// Trace is a basic operation on a square matrix that simply +// sums up all elements on the main diagonal (meaning all elements such that row==col). +func (m Mat2) Trace() float32 { + return m[0] + m[3] +} + +// Abs returns the element-wise absolute value of this matrix +func (m Mat2) Abs() Mat2 { + return Mat2{Abs(m[0]), Abs(m[1]), Abs(m[2]), Abs(m[3])} +} + +// Pretty prints the matrix +func (m Mat2) String() string { + buf := new(bytes.Buffer) + w := tabwriter.NewWriter(buf, 4, 4, 1, ' ', tabwriter.AlignRight) + for i := 0; i < 2; i++ { + for _, col := range m.Row(i) { + fmt.Fprintf(w, "%f\t", col) + } + + fmt.Fprintln(w, "") + } + w.Flush() + + return buf.String() +} + +// SetCol sets a Column within the Matrix, so it mutates the calling matrix. +func (m *Mat2x3) SetCol(col int, v Vec2) { + m[col*2+0], m[col*2+1] = v[0], v[1] +} + +// SetRow sets a Row within the Matrix, so it mutates the calling matrix. +func (m *Mat2x3) SetRow(row int, v Vec3) { + m[row+0], m[row+2], m[row+4] = v[0], v[1], v[2] +} + +// Mat2x3FromRows builds a new matrix from row vectors. +// The resulting matrix will still be in column major order, but this can be +// good for hand-building matrices. + +func Mat2x3FromRows(row0, row1 Vec3) Mat2x3 { + return Mat2x3{row0[0], row1[0], row0[1], row1[1], row0[2], row1[2]} +} + +// Mat2x3FromCols builds a new matrix from column vectors. +func Mat2x3FromCols(col0, col1, col2 Vec2) Mat2x3 { + return Mat2x3{col0[0], col0[1], col1[0], col1[1], col2[0], col2[1]} +} + +// Add performs an element-wise addition of two matrices, this is +// equivalent to iterating over every element of m1 and adding the corresponding value of m2. +func (m1 Mat2x3) Add(m2 Mat2x3) Mat2x3 { + return Mat2x3{m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2], m1[3] + m2[3], m1[4] + m2[4], m1[5] + m2[5]} +} + +// Sub performs an element-wise subtraction of two matrices, this is +// equivalent to iterating over every element of m1 and subtracting the corresponding value of m2. +func (m1 Mat2x3) Sub(m2 Mat2x3) Mat2x3 { + return Mat2x3{m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2], m1[3] - m2[3], m1[4] - m2[4], m1[5] - m2[5]} +} + +// Mul performs a scalar multiplcation of the matrix. This is equivalent to iterating +// over every element of the matrix and multiply it by c. +func (m1 Mat2x3) Mul(c float32) Mat2x3 { + return Mat2x3{m1[0] * c, m1[1] * c, m1[2] * c, m1[3] * c, m1[4] * c, m1[5] * c} +} + +// Mul3x1 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat2x3) Mul3x1(m2 Vec3) Vec2 { + return Vec2{ + m1[0]*m2[0] + m1[2]*m2[1] + m1[4]*m2[2], + m1[1]*m2[0] + m1[3]*m2[1] + m1[5]*m2[2], + } +} + +// Mul3x2 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat2x3) Mul3x2(m2 Mat3x2) Mat2 { + return Mat2{ + m1[0]*m2[0] + m1[2]*m2[1] + m1[4]*m2[2], + m1[1]*m2[0] + m1[3]*m2[1] + m1[5]*m2[2], + m1[0]*m2[3] + m1[2]*m2[4] + m1[4]*m2[5], + m1[1]*m2[3] + m1[3]*m2[4] + m1[5]*m2[5], + } +} + +// Mul3 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat2x3) Mul3(m2 Mat3) Mat2x3 { + return Mat2x3{ + m1[0]*m2[0] + m1[2]*m2[1] + m1[4]*m2[2], + m1[1]*m2[0] + m1[3]*m2[1] + m1[5]*m2[2], + m1[0]*m2[3] + m1[2]*m2[4] + m1[4]*m2[5], + m1[1]*m2[3] + m1[3]*m2[4] + m1[5]*m2[5], + m1[0]*m2[6] + m1[2]*m2[7] + m1[4]*m2[8], + m1[1]*m2[6] + m1[3]*m2[7] + m1[5]*m2[8], + } +} + +// Mul3x4 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat2x3) Mul3x4(m2 Mat3x4) Mat2x4 { + return Mat2x4{ + m1[0]*m2[0] + m1[2]*m2[1] + m1[4]*m2[2], + m1[1]*m2[0] + m1[3]*m2[1] + m1[5]*m2[2], + m1[0]*m2[3] + m1[2]*m2[4] + m1[4]*m2[5], + m1[1]*m2[3] + m1[3]*m2[4] + m1[5]*m2[5], + m1[0]*m2[6] + m1[2]*m2[7] + m1[4]*m2[8], + m1[1]*m2[6] + m1[3]*m2[7] + m1[5]*m2[8], + m1[0]*m2[9] + m1[2]*m2[10] + m1[4]*m2[11], + m1[1]*m2[9] + m1[3]*m2[10] + m1[5]*m2[11], + } +} + +// Transpose produces the transpose of this matrix. For any MxN matrix +// the transpose is an NxM matrix with the rows swapped with the columns. For instance +// the transpose of the Mat3x2 is a Mat2x3 like so: +// +// [[a b]] [[a c e]] +// [[c d]] = [[b d f]] +// [[e f]] +func (m1 Mat2x3) Transpose() Mat3x2 { + return Mat3x2{m1[0], m1[2], m1[4], m1[1], m1[3], m1[5]} +} + +// ApproxEqual performs an element-wise approximate equality test between two matrices, +// as if FloatEqual had been used. +func (m1 Mat2x3) ApproxEqual(m2 Mat2x3) bool { + for i := range m1 { + if !FloatEqual(m1[i], m2[i]) { + return false + } + } + return true +} + +// ApproxEqualThreshold performs an element-wise approximate equality test between two matrices +// with a given epsilon threshold, as if FloatEqualThreshold had been used. +func (m1 Mat2x3) ApproxEqualThreshold(m2 Mat2x3, threshold float32) bool { + for i := range m1 { + if !FloatEqualThreshold(m1[i], m2[i], threshold) { + return false + } + } + return true +} + +// ApproxFuncEqual performs an element-wise approximate equality test between two matrices +// with a given equality functions, intended to be used with FloatEqualFunc; although and comparison +// function may be used in practice. +func (m1 Mat2x3) ApproxFuncEqual(m2 Mat2x3, eq func(float32, float32) bool) bool { + for i := range m1 { + if !eq(m1[i], m2[i]) { + return false + } + } + return true +} + +// NumRows returns the number of rows in this matrix +func (m Mat2x3) NumRows() int { + return 2 +} + +// NumCols returns the number of columns in this matrix +func (m Mat2x3) NumCols() int { + return 3 +} + +// At returns the matrix element at the given row and column. +// This is equivalent to mat[col * numRow + row] where numRow is constant +// (E.G. for a Mat3x2 it's equal to 3) +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// At(5,0) will work just like At(1,1). Or it may panic if it's out of bounds. +func (m Mat2x3) At(row, col int) float32 { + return m[col*2+row] +} + +// Set sets the corresponding matrix element at the given row and column. +// This has a pointer receiver because it mutates the matrix. +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// Set(5,0,val) will work just like Set(1,1,val). Or it may panic if it's out of bounds. +func (m *Mat2x3) Set(row, col int, value float32) { + m[col*2+row] = value +} + +// Index returns the index of the given row and column, to be used with direct +// access. E.G. Index(0,0) = 0. +// +// This is a garbage-in garbage-out method. For instance, on a Mat4 asking for the index of +// (5,0) will work the same as asking for (1,1). Or it may give you a value that will cause +// a panic if you try to access the array with it if it's truly out of bounds. +func (m Mat2x3) Index(row, col int) int { + return col*2 + row +} + +// Row returns a vector representing the corresponding row (starting at row 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecM for a MxN matrix. +func (m Mat2x3) Row(row int) Vec3 { + return Vec3{m[row+0], m[row+2], m[row+4]} +} + +// Rows decomposes a matrix into its corresponding row vectors. +// This is equivalent to calling mat.Row for each row. +func (m Mat2x3) Rows() (row0, row1 Vec3) { + return m.Row(0), m.Row(1) +} + +// Col returns a vector representing the corresponding column (starting at col 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecN for a MxN matrix. +func (m Mat2x3) Col(col int) Vec2 { + return Vec2{m[col*2+0], m[col*2+1]} +} + +// Cols decomposes a matrix into its corresponding column vectors. +// This is equivalent to calling mat.Col for each column. +func (m Mat2x3) Cols() (col0, col1, col2 Vec2) { + return m.Col(0), m.Col(1), m.Col(2) +} + +// Abs returns the element-wise absolute value of this matrix +func (m Mat2x3) Abs() Mat2x3 { + return Mat2x3{Abs(m[0]), Abs(m[1]), Abs(m[2]), Abs(m[3]), Abs(m[4]), Abs(m[5])} +} + +// Pretty prints the matrix +func (m Mat2x3) String() string { + buf := new(bytes.Buffer) + w := tabwriter.NewWriter(buf, 4, 4, 1, ' ', tabwriter.AlignRight) + for i := 0; i < 2; i++ { + for _, col := range m.Row(i) { + fmt.Fprintf(w, "%f\t", col) + } + + fmt.Fprintln(w, "") + } + w.Flush() + + return buf.String() +} + +// SetCol sets a Column within the Matrix, so it mutates the calling matrix. +func (m *Mat2x4) SetCol(col int, v Vec2) { + m[col*2+0], m[col*2+1] = v[0], v[1] +} + +// SetRow sets a Row within the Matrix, so it mutates the calling matrix. +func (m *Mat2x4) SetRow(row int, v Vec4) { + m[row+0], m[row+2], m[row+4], m[row+6] = v[0], v[1], v[2], v[3] +} + +// Mat2x4FromRows builds a new matrix from row vectors. +// The resulting matrix will still be in column major order, but this can be +// good for hand-building matrices. + +func Mat2x4FromRows(row0, row1 Vec4) Mat2x4 { + return Mat2x4{row0[0], row1[0], row0[1], row1[1], row0[2], row1[2], row0[3], row1[3]} +} + +// Mat2x4FromCols builds a new matrix from column vectors. +func Mat2x4FromCols(col0, col1, col2, col3 Vec2) Mat2x4 { + return Mat2x4{col0[0], col0[1], col1[0], col1[1], col2[0], col2[1], col3[0], col3[1]} +} + +// Add performs an element-wise addition of two matrices, this is +// equivalent to iterating over every element of m1 and adding the corresponding value of m2. +func (m1 Mat2x4) Add(m2 Mat2x4) Mat2x4 { + return Mat2x4{m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2], m1[3] + m2[3], m1[4] + m2[4], m1[5] + m2[5], m1[6] + m2[6], m1[7] + m2[7]} +} + +// Sub performs an element-wise subtraction of two matrices, this is +// equivalent to iterating over every element of m1 and subtracting the corresponding value of m2. +func (m1 Mat2x4) Sub(m2 Mat2x4) Mat2x4 { + return Mat2x4{m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2], m1[3] - m2[3], m1[4] - m2[4], m1[5] - m2[5], m1[6] - m2[6], m1[7] - m2[7]} +} + +// Mul performs a scalar multiplcation of the matrix. This is equivalent to iterating +// over every element of the matrix and multiply it by c. +func (m1 Mat2x4) Mul(c float32) Mat2x4 { + return Mat2x4{m1[0] * c, m1[1] * c, m1[2] * c, m1[3] * c, m1[4] * c, m1[5] * c, m1[6] * c, m1[7] * c} +} + +// Mul4x1 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat2x4) Mul4x1(m2 Vec4) Vec2 { + return Vec2{ + m1[0]*m2[0] + m1[2]*m2[1] + m1[4]*m2[2] + m1[6]*m2[3], + m1[1]*m2[0] + m1[3]*m2[1] + m1[5]*m2[2] + m1[7]*m2[3], + } +} + +// Mul4x2 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat2x4) Mul4x2(m2 Mat4x2) Mat2 { + return Mat2{ + m1[0]*m2[0] + m1[2]*m2[1] + m1[4]*m2[2] + m1[6]*m2[3], + m1[1]*m2[0] + m1[3]*m2[1] + m1[5]*m2[2] + m1[7]*m2[3], + m1[0]*m2[4] + m1[2]*m2[5] + m1[4]*m2[6] + m1[6]*m2[7], + m1[1]*m2[4] + m1[3]*m2[5] + m1[5]*m2[6] + m1[7]*m2[7], + } +} + +// Mul4x3 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat2x4) Mul4x3(m2 Mat4x3) Mat2x3 { + return Mat2x3{ + m1[0]*m2[0] + m1[2]*m2[1] + m1[4]*m2[2] + m1[6]*m2[3], + m1[1]*m2[0] + m1[3]*m2[1] + m1[5]*m2[2] + m1[7]*m2[3], + m1[0]*m2[4] + m1[2]*m2[5] + m1[4]*m2[6] + m1[6]*m2[7], + m1[1]*m2[4] + m1[3]*m2[5] + m1[5]*m2[6] + m1[7]*m2[7], + m1[0]*m2[8] + m1[2]*m2[9] + m1[4]*m2[10] + m1[6]*m2[11], + m1[1]*m2[8] + m1[3]*m2[9] + m1[5]*m2[10] + m1[7]*m2[11], + } +} + +// Mul4 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat2x4) Mul4(m2 Mat4) Mat2x4 { + return Mat2x4{ + m1[0]*m2[0] + m1[2]*m2[1] + m1[4]*m2[2] + m1[6]*m2[3], + m1[1]*m2[0] + m1[3]*m2[1] + m1[5]*m2[2] + m1[7]*m2[3], + m1[0]*m2[4] + m1[2]*m2[5] + m1[4]*m2[6] + m1[6]*m2[7], + m1[1]*m2[4] + m1[3]*m2[5] + m1[5]*m2[6] + m1[7]*m2[7], + m1[0]*m2[8] + m1[2]*m2[9] + m1[4]*m2[10] + m1[6]*m2[11], + m1[1]*m2[8] + m1[3]*m2[9] + m1[5]*m2[10] + m1[7]*m2[11], + m1[0]*m2[12] + m1[2]*m2[13] + m1[4]*m2[14] + m1[6]*m2[15], + m1[1]*m2[12] + m1[3]*m2[13] + m1[5]*m2[14] + m1[7]*m2[15], + } +} + +// Transpose produces the transpose of this matrix. For any MxN matrix +// the transpose is an NxM matrix with the rows swapped with the columns. For instance +// the transpose of the Mat3x2 is a Mat2x3 like so: +// +// [[a b]] [[a c e]] +// [[c d]] = [[b d f]] +// [[e f]] +func (m1 Mat2x4) Transpose() Mat4x2 { + return Mat4x2{m1[0], m1[2], m1[4], m1[6], m1[1], m1[3], m1[5], m1[7]} +} + +// ApproxEqual performs an element-wise approximate equality test between two matrices, +// as if FloatEqual had been used. +func (m1 Mat2x4) ApproxEqual(m2 Mat2x4) bool { + for i := range m1 { + if !FloatEqual(m1[i], m2[i]) { + return false + } + } + return true +} + +// ApproxEqualThreshold performs an element-wise approximate equality test between two matrices +// with a given epsilon threshold, as if FloatEqualThreshold had been used. +func (m1 Mat2x4) ApproxEqualThreshold(m2 Mat2x4, threshold float32) bool { + for i := range m1 { + if !FloatEqualThreshold(m1[i], m2[i], threshold) { + return false + } + } + return true +} + +// ApproxFuncEqual performs an element-wise approximate equality test between two matrices +// with a given equality functions, intended to be used with FloatEqualFunc; although and comparison +// function may be used in practice. +func (m1 Mat2x4) ApproxFuncEqual(m2 Mat2x4, eq func(float32, float32) bool) bool { + for i := range m1 { + if !eq(m1[i], m2[i]) { + return false + } + } + return true +} + +// NumRows returns the number of rows in this matrix +func (m Mat2x4) NumRows() int { + return 2 +} + +// NumCols returns the number of columns in this matrix +func (m Mat2x4) NumCols() int { + return 4 +} + +// At returns the matrix element at the given row and column. +// This is equivalent to mat[col * numRow + row] where numRow is constant +// (E.G. for a Mat3x2 it's equal to 3) +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// At(5,0) will work just like At(1,1). Or it may panic if it's out of bounds. +func (m Mat2x4) At(row, col int) float32 { + return m[col*2+row] +} + +// Set sets the corresponding matrix element at the given row and column. +// This has a pointer receiver because it mutates the matrix. +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// Set(5,0,val) will work just like Set(1,1,val). Or it may panic if it's out of bounds. +func (m *Mat2x4) Set(row, col int, value float32) { + m[col*2+row] = value +} + +// Index returns the index of the given row and column, to be used with direct +// access. E.G. Index(0,0) = 0. +// +// This is a garbage-in garbage-out method. For instance, on a Mat4 asking for the index of +// (5,0) will work the same as asking for (1,1). Or it may give you a value that will cause +// a panic if you try to access the array with it if it's truly out of bounds. +func (m Mat2x4) Index(row, col int) int { + return col*2 + row +} + +// Row returns a vector representing the corresponding row (starting at row 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecM for a MxN matrix. +func (m Mat2x4) Row(row int) Vec4 { + return Vec4{m[row+0], m[row+2], m[row+4], m[row+6]} +} + +// Rows decomposes a matrix into its corresponding row vectors. +// This is equivalent to calling mat.Row for each row. +func (m Mat2x4) Rows() (row0, row1 Vec4) { + return m.Row(0), m.Row(1) +} + +// Col returns a vector representing the corresponding column (starting at col 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecN for a MxN matrix. +func (m Mat2x4) Col(col int) Vec2 { + return Vec2{m[col*2+0], m[col*2+1]} +} + +// Cols decomposes a matrix into its corresponding column vectors. +// This is equivalent to calling mat.Col for each column. +func (m Mat2x4) Cols() (col0, col1, col2, col3 Vec2) { + return m.Col(0), m.Col(1), m.Col(2), m.Col(3) +} + +// Abs returns the element-wise absolute value of this matrix +func (m Mat2x4) Abs() Mat2x4 { + return Mat2x4{Abs(m[0]), Abs(m[1]), Abs(m[2]), Abs(m[3]), Abs(m[4]), Abs(m[5]), Abs(m[6]), Abs(m[7])} +} + +// Pretty prints the matrix +func (m Mat2x4) String() string { + buf := new(bytes.Buffer) + w := tabwriter.NewWriter(buf, 4, 4, 1, ' ', tabwriter.AlignRight) + for i := 0; i < 2; i++ { + for _, col := range m.Row(i) { + fmt.Fprintf(w, "%f\t", col) + } + + fmt.Fprintln(w, "") + } + w.Flush() + + return buf.String() +} + +// SetCol sets a Column within the Matrix, so it mutates the calling matrix. +func (m *Mat3x2) SetCol(col int, v Vec3) { + m[col*3+0], m[col*3+1], m[col*3+2] = v[0], v[1], v[2] +} + +// SetRow sets a Row within the Matrix, so it mutates the calling matrix. +func (m *Mat3x2) SetRow(row int, v Vec2) { + m[row+0], m[row+3] = v[0], v[1] +} + +// Mat3x2FromRows builds a new matrix from row vectors. +// The resulting matrix will still be in column major order, but this can be +// good for hand-building matrices. + +func Mat3x2FromRows(row0, row1, row2 Vec2) Mat3x2 { + return Mat3x2{row0[0], row1[0], row2[0], row0[1], row1[1], row2[1]} +} + +// Mat3x2FromCols builds a new matrix from column vectors. +func Mat3x2FromCols(col0, col1 Vec3) Mat3x2 { + return Mat3x2{col0[0], col0[1], col0[2], col1[0], col1[1], col1[2]} +} + +// Add performs an element-wise addition of two matrices, this is +// equivalent to iterating over every element of m1 and adding the corresponding value of m2. +func (m1 Mat3x2) Add(m2 Mat3x2) Mat3x2 { + return Mat3x2{m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2], m1[3] + m2[3], m1[4] + m2[4], m1[5] + m2[5]} +} + +// Sub performs an element-wise subtraction of two matrices, this is +// equivalent to iterating over every element of m1 and subtracting the corresponding value of m2. +func (m1 Mat3x2) Sub(m2 Mat3x2) Mat3x2 { + return Mat3x2{m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2], m1[3] - m2[3], m1[4] - m2[4], m1[5] - m2[5]} +} + +// Mul performs a scalar multiplcation of the matrix. This is equivalent to iterating +// over every element of the matrix and multiply it by c. +func (m1 Mat3x2) Mul(c float32) Mat3x2 { + return Mat3x2{m1[0] * c, m1[1] * c, m1[2] * c, m1[3] * c, m1[4] * c, m1[5] * c} +} + +// Mul2x1 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat3x2) Mul2x1(m2 Vec2) Vec3 { + return Vec3{ + m1[0]*m2[0] + m1[3]*m2[1], + m1[1]*m2[0] + m1[4]*m2[1], + m1[2]*m2[0] + m1[5]*m2[1], + } +} + +// Mul2 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat3x2) Mul2(m2 Mat2) Mat3x2 { + return Mat3x2{ + m1[0]*m2[0] + m1[3]*m2[1], + m1[1]*m2[0] + m1[4]*m2[1], + m1[2]*m2[0] + m1[5]*m2[1], + m1[0]*m2[2] + m1[3]*m2[3], + m1[1]*m2[2] + m1[4]*m2[3], + m1[2]*m2[2] + m1[5]*m2[3], + } +} + +// Mul2x3 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat3x2) Mul2x3(m2 Mat2x3) Mat3 { + return Mat3{ + m1[0]*m2[0] + m1[3]*m2[1], + m1[1]*m2[0] + m1[4]*m2[1], + m1[2]*m2[0] + m1[5]*m2[1], + m1[0]*m2[2] + m1[3]*m2[3], + m1[1]*m2[2] + m1[4]*m2[3], + m1[2]*m2[2] + m1[5]*m2[3], + m1[0]*m2[4] + m1[3]*m2[5], + m1[1]*m2[4] + m1[4]*m2[5], + m1[2]*m2[4] + m1[5]*m2[5], + } +} + +// Mul2x4 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat3x2) Mul2x4(m2 Mat2x4) Mat3x4 { + return Mat3x4{ + m1[0]*m2[0] + m1[3]*m2[1], + m1[1]*m2[0] + m1[4]*m2[1], + m1[2]*m2[0] + m1[5]*m2[1], + m1[0]*m2[2] + m1[3]*m2[3], + m1[1]*m2[2] + m1[4]*m2[3], + m1[2]*m2[2] + m1[5]*m2[3], + m1[0]*m2[4] + m1[3]*m2[5], + m1[1]*m2[4] + m1[4]*m2[5], + m1[2]*m2[4] + m1[5]*m2[5], + m1[0]*m2[6] + m1[3]*m2[7], + m1[1]*m2[6] + m1[4]*m2[7], + m1[2]*m2[6] + m1[5]*m2[7], + } +} + +// Transpose produces the transpose of this matrix. For any MxN matrix +// the transpose is an NxM matrix with the rows swapped with the columns. For instance +// the transpose of the Mat3x2 is a Mat2x3 like so: +// +// [[a b]] [[a c e]] +// [[c d]] = [[b d f]] +// [[e f]] +func (m1 Mat3x2) Transpose() Mat2x3 { + return Mat2x3{m1[0], m1[3], m1[1], m1[4], m1[2], m1[5]} +} + +// ApproxEqual performs an element-wise approximate equality test between two matrices, +// as if FloatEqual had been used. +func (m1 Mat3x2) ApproxEqual(m2 Mat3x2) bool { + for i := range m1 { + if !FloatEqual(m1[i], m2[i]) { + return false + } + } + return true +} + +// ApproxEqualThreshold performs an element-wise approximate equality test between two matrices +// with a given epsilon threshold, as if FloatEqualThreshold had been used. +func (m1 Mat3x2) ApproxEqualThreshold(m2 Mat3x2, threshold float32) bool { + for i := range m1 { + if !FloatEqualThreshold(m1[i], m2[i], threshold) { + return false + } + } + return true +} + +// ApproxFuncEqual performs an element-wise approximate equality test between two matrices +// with a given equality functions, intended to be used with FloatEqualFunc; although and comparison +// function may be used in practice. +func (m1 Mat3x2) ApproxFuncEqual(m2 Mat3x2, eq func(float32, float32) bool) bool { + for i := range m1 { + if !eq(m1[i], m2[i]) { + return false + } + } + return true +} + +// NumRows returns the number of rows in this matrix +func (m Mat3x2) NumRows() int { + return 3 +} + +// NumCols returns the number of columns in this matrix +func (m Mat3x2) NumCols() int { + return 2 +} + +// At returns the matrix element at the given row and column. +// This is equivalent to mat[col * numRow + row] where numRow is constant +// (E.G. for a Mat3x2 it's equal to 3) +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// At(5,0) will work just like At(1,1). Or it may panic if it's out of bounds. +func (m Mat3x2) At(row, col int) float32 { + return m[col*3+row] +} + +// Set sets the corresponding matrix element at the given row and column. +// This has a pointer receiver because it mutates the matrix. +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// Set(5,0,val) will work just like Set(1,1,val). Or it may panic if it's out of bounds. +func (m *Mat3x2) Set(row, col int, value float32) { + m[col*3+row] = value +} + +// Index returns the index of the given row and column, to be used with direct +// access. E.G. Index(0,0) = 0. +// +// This is a garbage-in garbage-out method. For instance, on a Mat4 asking for the index of +// (5,0) will work the same as asking for (1,1). Or it may give you a value that will cause +// a panic if you try to access the array with it if it's truly out of bounds. +func (m Mat3x2) Index(row, col int) int { + return col*3 + row +} + +// Row returns a vector representing the corresponding row (starting at row 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecM for a MxN matrix. +func (m Mat3x2) Row(row int) Vec2 { + return Vec2{m[row+0], m[row+3]} +} + +// Rows decomposes a matrix into its corresponding row vectors. +// This is equivalent to calling mat.Row for each row. +func (m Mat3x2) Rows() (row0, row1, row2 Vec2) { + return m.Row(0), m.Row(1), m.Row(2) +} + +// Col returns a vector representing the corresponding column (starting at col 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecN for a MxN matrix. +func (m Mat3x2) Col(col int) Vec3 { + return Vec3{m[col*3+0], m[col*3+1], m[col*3+2]} +} + +// Cols decomposes a matrix into its corresponding column vectors. +// This is equivalent to calling mat.Col for each column. +func (m Mat3x2) Cols() (col0, col1 Vec3) { + return m.Col(0), m.Col(1) +} + +// Abs returns the element-wise absolute value of this matrix +func (m Mat3x2) Abs() Mat3x2 { + return Mat3x2{Abs(m[0]), Abs(m[1]), Abs(m[2]), Abs(m[3]), Abs(m[4]), Abs(m[5])} +} + +// Pretty prints the matrix +func (m Mat3x2) String() string { + buf := new(bytes.Buffer) + w := tabwriter.NewWriter(buf, 4, 4, 1, ' ', tabwriter.AlignRight) + for i := 0; i < 3; i++ { + for _, col := range m.Row(i) { + fmt.Fprintf(w, "%f\t", col) + } + + fmt.Fprintln(w, "") + } + w.Flush() + + return buf.String() +} + +// SetCol sets a Column within the Matrix, so it mutates the calling matrix. +func (m *Mat3) SetCol(col int, v Vec3) { + m[col*3+0], m[col*3+1], m[col*3+2] = v[0], v[1], v[2] +} + +// SetRow sets a Row within the Matrix, so it mutates the calling matrix. +func (m *Mat3) SetRow(row int, v Vec3) { + m[row+0], m[row+3], m[row+6] = v[0], v[1], v[2] +} + +// Diag is a basic operation on a square matrix that simply +// returns main diagonal (meaning all elements such that row==col). +func (m Mat3) Diag() Vec3 { + return Vec3{m[0], m[4], m[8]} +} + +// Ident3 returns the 3x3 identity matrix. +// The identity matrix is a square matrix with the value 1 on its +// diagonals. The characteristic property of the identity matrix is that +// any matrix multiplied by it is itself. (MI = M; IN = N) +func Ident3() Mat3 { + return Mat3{1, 0, 0, 0, 1, 0, 0, 0, 1} +} + +// Diag3 creates a diagonal matrix from the entries of the input vector. +// That is, for each pointer for row==col, vector[row] is the entry. Otherwise it's 0. +// +// Another way to think about it is that the identity is this function where the every vector element is 1. +func Diag3(v Vec3) Mat3 { + var m Mat3 + m[0], m[4], m[8] = v[0], v[1], v[2] + return m +} + +// Mat3FromRows builds a new matrix from row vectors. +// The resulting matrix will still be in column major order, but this can be +// good for hand-building matrices. + +func Mat3FromRows(row0, row1, row2 Vec3) Mat3 { + return Mat3{row0[0], row1[0], row2[0], row0[1], row1[1], row2[1], row0[2], row1[2], row2[2]} +} + +// Mat3FromCols builds a new matrix from column vectors. +func Mat3FromCols(col0, col1, col2 Vec3) Mat3 { + return Mat3{col0[0], col0[1], col0[2], col1[0], col1[1], col1[2], col2[0], col2[1], col2[2]} +} + +// Add performs an element-wise addition of two matrices, this is +// equivalent to iterating over every element of m1 and adding the corresponding value of m2. +func (m1 Mat3) Add(m2 Mat3) Mat3 { + return Mat3{m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2], m1[3] + m2[3], m1[4] + m2[4], m1[5] + m2[5], m1[6] + m2[6], m1[7] + m2[7], m1[8] + m2[8]} +} + +// Sub performs an element-wise subtraction of two matrices, this is +// equivalent to iterating over every element of m1 and subtracting the corresponding value of m2. +func (m1 Mat3) Sub(m2 Mat3) Mat3 { + return Mat3{m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2], m1[3] - m2[3], m1[4] - m2[4], m1[5] - m2[5], m1[6] - m2[6], m1[7] - m2[7], m1[8] - m2[8]} +} + +// Mul performs a scalar multiplcation of the matrix. This is equivalent to iterating +// over every element of the matrix and multiply it by c. +func (m1 Mat3) Mul(c float32) Mat3 { + return Mat3{m1[0] * c, m1[1] * c, m1[2] * c, m1[3] * c, m1[4] * c, m1[5] * c, m1[6] * c, m1[7] * c, m1[8] * c} +} + +// Mul3x1 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat3) Mul3x1(m2 Vec3) Vec3 { + return Vec3{ + m1[0]*m2[0] + m1[3]*m2[1] + m1[6]*m2[2], + m1[1]*m2[0] + m1[4]*m2[1] + m1[7]*m2[2], + m1[2]*m2[0] + m1[5]*m2[1] + m1[8]*m2[2], + } +} + +// Mul3x2 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat3) Mul3x2(m2 Mat3x2) Mat3x2 { + return Mat3x2{ + m1[0]*m2[0] + m1[3]*m2[1] + m1[6]*m2[2], + m1[1]*m2[0] + m1[4]*m2[1] + m1[7]*m2[2], + m1[2]*m2[0] + m1[5]*m2[1] + m1[8]*m2[2], + m1[0]*m2[3] + m1[3]*m2[4] + m1[6]*m2[5], + m1[1]*m2[3] + m1[4]*m2[4] + m1[7]*m2[5], + m1[2]*m2[3] + m1[5]*m2[4] + m1[8]*m2[5], + } +} + +// Mul3 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat3) Mul3(m2 Mat3) Mat3 { + return Mat3{ + m1[0]*m2[0] + m1[3]*m2[1] + m1[6]*m2[2], + m1[1]*m2[0] + m1[4]*m2[1] + m1[7]*m2[2], + m1[2]*m2[0] + m1[5]*m2[1] + m1[8]*m2[2], + m1[0]*m2[3] + m1[3]*m2[4] + m1[6]*m2[5], + m1[1]*m2[3] + m1[4]*m2[4] + m1[7]*m2[5], + m1[2]*m2[3] + m1[5]*m2[4] + m1[8]*m2[5], + m1[0]*m2[6] + m1[3]*m2[7] + m1[6]*m2[8], + m1[1]*m2[6] + m1[4]*m2[7] + m1[7]*m2[8], + m1[2]*m2[6] + m1[5]*m2[7] + m1[8]*m2[8], + } +} + +// Mul3x4 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat3) Mul3x4(m2 Mat3x4) Mat3x4 { + return Mat3x4{ + m1[0]*m2[0] + m1[3]*m2[1] + m1[6]*m2[2], + m1[1]*m2[0] + m1[4]*m2[1] + m1[7]*m2[2], + m1[2]*m2[0] + m1[5]*m2[1] + m1[8]*m2[2], + m1[0]*m2[3] + m1[3]*m2[4] + m1[6]*m2[5], + m1[1]*m2[3] + m1[4]*m2[4] + m1[7]*m2[5], + m1[2]*m2[3] + m1[5]*m2[4] + m1[8]*m2[5], + m1[0]*m2[6] + m1[3]*m2[7] + m1[6]*m2[8], + m1[1]*m2[6] + m1[4]*m2[7] + m1[7]*m2[8], + m1[2]*m2[6] + m1[5]*m2[7] + m1[8]*m2[8], + m1[0]*m2[9] + m1[3]*m2[10] + m1[6]*m2[11], + m1[1]*m2[9] + m1[4]*m2[10] + m1[7]*m2[11], + m1[2]*m2[9] + m1[5]*m2[10] + m1[8]*m2[11], + } +} + +// Transpose produces the transpose of this matrix. For any MxN matrix +// the transpose is an NxM matrix with the rows swapped with the columns. For instance +// the transpose of the Mat3x2 is a Mat2x3 like so: +// +// [[a b]] [[a c e]] +// [[c d]] = [[b d f]] +// [[e f]] +func (m1 Mat3) Transpose() Mat3 { + return Mat3{m1[0], m1[3], m1[6], m1[1], m1[4], m1[7], m1[2], m1[5], m1[8]} +} + +// Det returns the determinant of a matrix. It is a measure of a square matrix's +// singularity and invertability, among other things. In this library, the +// determinant is hard coded based on pre-computed cofactor expansion, and uses +// no loops. Of course, the addition and multiplication must still be done. +func (m Mat3) Det() float32 { + return m[0]*m[4]*m[8] + m[3]*m[7]*m[2] + m[6]*m[1]*m[5] - m[6]*m[4]*m[2] - m[3]*m[1]*m[8] - m[0]*m[7]*m[5] +} + +// Inv computes the inverse of a square matrix. An inverse is a square matrix such that when multiplied by the +// original, yields the identity. +// +// M_inv * M = M * M_inv = I +// +// In this library, the math is precomputed, and uses no loops, though the multiplications, additions, determinant calculation, and scaling +// are still done. This can still be (relatively) expensive for a 4x4. +// +// This function checks the determinant to see if the matrix is invertible. +// If the determinant is 0.0, this function returns the zero matrix. However, due to floating point errors, it is +// entirely plausible to get a false positive or negative. +// In the future, an alternate function may be written which takes in a pre-computed determinant. +func (m Mat3) Inv() Mat3 { + det := m.Det() + if FloatEqual(det, float32(0.0)) { + return Mat3{} + } + + retMat := Mat3{ + m[4]*m[8] - m[5]*m[7], + m[2]*m[7] - m[1]*m[8], + m[1]*m[5] - m[2]*m[4], + m[5]*m[6] - m[3]*m[8], + m[0]*m[8] - m[2]*m[6], + m[2]*m[3] - m[0]*m[5], + m[3]*m[7] - m[4]*m[6], + m[1]*m[6] - m[0]*m[7], + m[0]*m[4] - m[1]*m[3], + } + + return retMat.Mul(1 / det) +} + +// ApproxEqual performs an element-wise approximate equality test between two matrices, +// as if FloatEqual had been used. +func (m1 Mat3) ApproxEqual(m2 Mat3) bool { + for i := range m1 { + if !FloatEqual(m1[i], m2[i]) { + return false + } + } + return true +} + +// ApproxEqualThreshold performs an element-wise approximate equality test between two matrices +// with a given epsilon threshold, as if FloatEqualThreshold had been used. +func (m1 Mat3) ApproxEqualThreshold(m2 Mat3, threshold float32) bool { + for i := range m1 { + if !FloatEqualThreshold(m1[i], m2[i], threshold) { + return false + } + } + return true +} + +// ApproxFuncEqual performs an element-wise approximate equality test between two matrices +// with a given equality functions, intended to be used with FloatEqualFunc; although and comparison +// function may be used in practice. +func (m1 Mat3) ApproxFuncEqual(m2 Mat3, eq func(float32, float32) bool) bool { + for i := range m1 { + if !eq(m1[i], m2[i]) { + return false + } + } + return true +} + +// NumRows returns the number of rows in this matrix +func (m Mat3) NumRows() int { + return 3 +} + +// NumCols returns the number of columns in this matrix +func (m Mat3) NumCols() int { + return 3 +} + +// At returns the matrix element at the given row and column. +// This is equivalent to mat[col * numRow + row] where numRow is constant +// (E.G. for a Mat3x2 it's equal to 3) +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// At(5,0) will work just like At(1,1). Or it may panic if it's out of bounds. +func (m Mat3) At(row, col int) float32 { + return m[col*3+row] +} + +// Set sets the corresponding matrix element at the given row and column. +// This has a pointer receiver because it mutates the matrix. +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// Set(5,0,val) will work just like Set(1,1,val). Or it may panic if it's out of bounds. +func (m *Mat3) Set(row, col int, value float32) { + m[col*3+row] = value +} + +// Index returns the index of the given row and column, to be used with direct +// access. E.G. Index(0,0) = 0. +// +// This is a garbage-in garbage-out method. For instance, on a Mat4 asking for the index of +// (5,0) will work the same as asking for (1,1). Or it may give you a value that will cause +// a panic if you try to access the array with it if it's truly out of bounds. +func (m Mat3) Index(row, col int) int { + return col*3 + row +} + +// Row returns a vector representing the corresponding row (starting at row 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecM for a MxN matrix. +func (m Mat3) Row(row int) Vec3 { + return Vec3{m[row+0], m[row+3], m[row+6]} +} + +// Rows decomposes a matrix into its corresponding row vectors. +// This is equivalent to calling mat.Row for each row. +func (m Mat3) Rows() (row0, row1, row2 Vec3) { + return m.Row(0), m.Row(1), m.Row(2) +} + +// Col returns a vector representing the corresponding column (starting at col 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecN for a MxN matrix. +func (m Mat3) Col(col int) Vec3 { + return Vec3{m[col*3+0], m[col*3+1], m[col*3+2]} +} + +// Cols decomposes a matrix into its corresponding column vectors. +// This is equivalent to calling mat.Col for each column. +func (m Mat3) Cols() (col0, col1, col2 Vec3) { + return m.Col(0), m.Col(1), m.Col(2) +} + +// Trace is a basic operation on a square matrix that simply +// sums up all elements on the main diagonal (meaning all elements such that row==col). +func (m Mat3) Trace() float32 { + return m[0] + m[4] + m[8] +} + +// Abs returns the element-wise absolute value of this matrix +func (m Mat3) Abs() Mat3 { + return Mat3{Abs(m[0]), Abs(m[1]), Abs(m[2]), Abs(m[3]), Abs(m[4]), Abs(m[5]), Abs(m[6]), Abs(m[7]), Abs(m[8])} +} + +// Pretty prints the matrix +func (m Mat3) String() string { + buf := new(bytes.Buffer) + w := tabwriter.NewWriter(buf, 4, 4, 1, ' ', tabwriter.AlignRight) + for i := 0; i < 3; i++ { + for _, col := range m.Row(i) { + fmt.Fprintf(w, "%f\t", col) + } + + fmt.Fprintln(w, "") + } + w.Flush() + + return buf.String() +} + +// SetCol sets a Column within the Matrix, so it mutates the calling matrix. +func (m *Mat3x4) SetCol(col int, v Vec3) { + m[col*3+0], m[col*3+1], m[col*3+2] = v[0], v[1], v[2] +} + +// SetRow sets a Row within the Matrix, so it mutates the calling matrix. +func (m *Mat3x4) SetRow(row int, v Vec4) { + m[row+0], m[row+3], m[row+6], m[row+9] = v[0], v[1], v[2], v[3] +} + +// Mat3x4FromRows builds a new matrix from row vectors. +// The resulting matrix will still be in column major order, but this can be +// good for hand-building matrices. + +func Mat3x4FromRows(row0, row1, row2 Vec4) Mat3x4 { + return Mat3x4{row0[0], row1[0], row2[0], row0[1], row1[1], row2[1], row0[2], row1[2], row2[2], row0[3], row1[3], row2[3]} +} + +// Mat3x4FromCols builds a new matrix from column vectors. +func Mat3x4FromCols(col0, col1, col2, col3 Vec3) Mat3x4 { + return Mat3x4{col0[0], col0[1], col0[2], col1[0], col1[1], col1[2], col2[0], col2[1], col2[2], col3[0], col3[1], col3[2]} +} + +// Add performs an element-wise addition of two matrices, this is +// equivalent to iterating over every element of m1 and adding the corresponding value of m2. +func (m1 Mat3x4) Add(m2 Mat3x4) Mat3x4 { + return Mat3x4{m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2], m1[3] + m2[3], m1[4] + m2[4], m1[5] + m2[5], m1[6] + m2[6], m1[7] + m2[7], m1[8] + m2[8], m1[9] + m2[9], m1[10] + m2[10], m1[11] + m2[11]} +} + +// Sub performs an element-wise subtraction of two matrices, this is +// equivalent to iterating over every element of m1 and subtracting the corresponding value of m2. +func (m1 Mat3x4) Sub(m2 Mat3x4) Mat3x4 { + return Mat3x4{m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2], m1[3] - m2[3], m1[4] - m2[4], m1[5] - m2[5], m1[6] - m2[6], m1[7] - m2[7], m1[8] - m2[8], m1[9] - m2[9], m1[10] - m2[10], m1[11] - m2[11]} +} + +// Mul performs a scalar multiplcation of the matrix. This is equivalent to iterating +// over every element of the matrix and multiply it by c. +func (m1 Mat3x4) Mul(c float32) Mat3x4 { + return Mat3x4{m1[0] * c, m1[1] * c, m1[2] * c, m1[3] * c, m1[4] * c, m1[5] * c, m1[6] * c, m1[7] * c, m1[8] * c, m1[9] * c, m1[10] * c, m1[11] * c} +} + +// Mul4x1 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat3x4) Mul4x1(m2 Vec4) Vec3 { + return Vec3{ + m1[0]*m2[0] + m1[3]*m2[1] + m1[6]*m2[2] + m1[9]*m2[3], + m1[1]*m2[0] + m1[4]*m2[1] + m1[7]*m2[2] + m1[10]*m2[3], + m1[2]*m2[0] + m1[5]*m2[1] + m1[8]*m2[2] + m1[11]*m2[3], + } +} + +// Mul4x2 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat3x4) Mul4x2(m2 Mat4x2) Mat3x2 { + return Mat3x2{ + m1[0]*m2[0] + m1[3]*m2[1] + m1[6]*m2[2] + m1[9]*m2[3], + m1[1]*m2[0] + m1[4]*m2[1] + m1[7]*m2[2] + m1[10]*m2[3], + m1[2]*m2[0] + m1[5]*m2[1] + m1[8]*m2[2] + m1[11]*m2[3], + m1[0]*m2[4] + m1[3]*m2[5] + m1[6]*m2[6] + m1[9]*m2[7], + m1[1]*m2[4] + m1[4]*m2[5] + m1[7]*m2[6] + m1[10]*m2[7], + m1[2]*m2[4] + m1[5]*m2[5] + m1[8]*m2[6] + m1[11]*m2[7], + } +} + +// Mul4x3 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat3x4) Mul4x3(m2 Mat4x3) Mat3 { + return Mat3{ + m1[0]*m2[0] + m1[3]*m2[1] + m1[6]*m2[2] + m1[9]*m2[3], + m1[1]*m2[0] + m1[4]*m2[1] + m1[7]*m2[2] + m1[10]*m2[3], + m1[2]*m2[0] + m1[5]*m2[1] + m1[8]*m2[2] + m1[11]*m2[3], + m1[0]*m2[4] + m1[3]*m2[5] + m1[6]*m2[6] + m1[9]*m2[7], + m1[1]*m2[4] + m1[4]*m2[5] + m1[7]*m2[6] + m1[10]*m2[7], + m1[2]*m2[4] + m1[5]*m2[5] + m1[8]*m2[6] + m1[11]*m2[7], + m1[0]*m2[8] + m1[3]*m2[9] + m1[6]*m2[10] + m1[9]*m2[11], + m1[1]*m2[8] + m1[4]*m2[9] + m1[7]*m2[10] + m1[10]*m2[11], + m1[2]*m2[8] + m1[5]*m2[9] + m1[8]*m2[10] + m1[11]*m2[11], + } +} + +// Mul4 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat3x4) Mul4(m2 Mat4) Mat3x4 { + return Mat3x4{ + m1[0]*m2[0] + m1[3]*m2[1] + m1[6]*m2[2] + m1[9]*m2[3], + m1[1]*m2[0] + m1[4]*m2[1] + m1[7]*m2[2] + m1[10]*m2[3], + m1[2]*m2[0] + m1[5]*m2[1] + m1[8]*m2[2] + m1[11]*m2[3], + m1[0]*m2[4] + m1[3]*m2[5] + m1[6]*m2[6] + m1[9]*m2[7], + m1[1]*m2[4] + m1[4]*m2[5] + m1[7]*m2[6] + m1[10]*m2[7], + m1[2]*m2[4] + m1[5]*m2[5] + m1[8]*m2[6] + m1[11]*m2[7], + m1[0]*m2[8] + m1[3]*m2[9] + m1[6]*m2[10] + m1[9]*m2[11], + m1[1]*m2[8] + m1[4]*m2[9] + m1[7]*m2[10] + m1[10]*m2[11], + m1[2]*m2[8] + m1[5]*m2[9] + m1[8]*m2[10] + m1[11]*m2[11], + m1[0]*m2[12] + m1[3]*m2[13] + m1[6]*m2[14] + m1[9]*m2[15], + m1[1]*m2[12] + m1[4]*m2[13] + m1[7]*m2[14] + m1[10]*m2[15], + m1[2]*m2[12] + m1[5]*m2[13] + m1[8]*m2[14] + m1[11]*m2[15], + } +} + +// Transpose produces the transpose of this matrix. For any MxN matrix +// the transpose is an NxM matrix with the rows swapped with the columns. For instance +// the transpose of the Mat3x2 is a Mat2x3 like so: +// +// [[a b]] [[a c e]] +// [[c d]] = [[b d f]] +// [[e f]] +func (m1 Mat3x4) Transpose() Mat4x3 { + return Mat4x3{m1[0], m1[3], m1[6], m1[9], m1[1], m1[4], m1[7], m1[10], m1[2], m1[5], m1[8], m1[11]} +} + +// ApproxEqual performs an element-wise approximate equality test between two matrices, +// as if FloatEqual had been used. +func (m1 Mat3x4) ApproxEqual(m2 Mat3x4) bool { + for i := range m1 { + if !FloatEqual(m1[i], m2[i]) { + return false + } + } + return true +} + +// ApproxEqualThreshold performs an element-wise approximate equality test between two matrices +// with a given epsilon threshold, as if FloatEqualThreshold had been used. +func (m1 Mat3x4) ApproxEqualThreshold(m2 Mat3x4, threshold float32) bool { + for i := range m1 { + if !FloatEqualThreshold(m1[i], m2[i], threshold) { + return false + } + } + return true +} + +// ApproxFuncEqual performs an element-wise approximate equality test between two matrices +// with a given equality functions, intended to be used with FloatEqualFunc; although and comparison +// function may be used in practice. +func (m1 Mat3x4) ApproxFuncEqual(m2 Mat3x4, eq func(float32, float32) bool) bool { + for i := range m1 { + if !eq(m1[i], m2[i]) { + return false + } + } + return true +} + +// NumRows returns the number of rows in this matrix +func (m Mat3x4) NumRows() int { + return 3 +} + +// NumCols returns the number of columns in this matrix +func (m Mat3x4) NumCols() int { + return 4 +} + +// At returns the matrix element at the given row and column. +// This is equivalent to mat[col * numRow + row] where numRow is constant +// (E.G. for a Mat3x2 it's equal to 3) +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// At(5,0) will work just like At(1,1). Or it may panic if it's out of bounds. +func (m Mat3x4) At(row, col int) float32 { + return m[col*3+row] +} + +// Set sets the corresponding matrix element at the given row and column. +// This has a pointer receiver because it mutates the matrix. +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// Set(5,0,val) will work just like Set(1,1,val). Or it may panic if it's out of bounds. +func (m *Mat3x4) Set(row, col int, value float32) { + m[col*3+row] = value +} + +// Index returns the index of the given row and column, to be used with direct +// access. E.G. Index(0,0) = 0. +// +// This is a garbage-in garbage-out method. For instance, on a Mat4 asking for the index of +// (5,0) will work the same as asking for (1,1). Or it may give you a value that will cause +// a panic if you try to access the array with it if it's truly out of bounds. +func (m Mat3x4) Index(row, col int) int { + return col*3 + row +} + +// Row returns a vector representing the corresponding row (starting at row 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecM for a MxN matrix. +func (m Mat3x4) Row(row int) Vec4 { + return Vec4{m[row+0], m[row+3], m[row+6], m[row+9]} +} + +// Rows decomposes a matrix into its corresponding row vectors. +// This is equivalent to calling mat.Row for each row. +func (m Mat3x4) Rows() (row0, row1, row2 Vec4) { + return m.Row(0), m.Row(1), m.Row(2) +} + +// Col returns a vector representing the corresponding column (starting at col 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecN for a MxN matrix. +func (m Mat3x4) Col(col int) Vec3 { + return Vec3{m[col*3+0], m[col*3+1], m[col*3+2]} +} + +// Cols decomposes a matrix into its corresponding column vectors. +// This is equivalent to calling mat.Col for each column. +func (m Mat3x4) Cols() (col0, col1, col2, col3 Vec3) { + return m.Col(0), m.Col(1), m.Col(2), m.Col(3) +} + +// Abs returns the element-wise absolute value of this matrix +func (m Mat3x4) Abs() Mat3x4 { + return Mat3x4{Abs(m[0]), Abs(m[1]), Abs(m[2]), Abs(m[3]), Abs(m[4]), Abs(m[5]), Abs(m[6]), Abs(m[7]), Abs(m[8]), Abs(m[9]), Abs(m[10]), Abs(m[11])} +} + +// Pretty prints the matrix +func (m Mat3x4) String() string { + buf := new(bytes.Buffer) + w := tabwriter.NewWriter(buf, 4, 4, 1, ' ', tabwriter.AlignRight) + for i := 0; i < 3; i++ { + for _, col := range m.Row(i) { + fmt.Fprintf(w, "%f\t", col) + } + + fmt.Fprintln(w, "") + } + w.Flush() + + return buf.String() +} + +// SetCol sets a Column within the Matrix, so it mutates the calling matrix. +func (m *Mat4x2) SetCol(col int, v Vec4) { + m[col*4+0], m[col*4+1], m[col*4+2], m[col*4+3] = v[0], v[1], v[2], v[3] +} + +// SetRow sets a Row within the Matrix, so it mutates the calling matrix. +func (m *Mat4x2) SetRow(row int, v Vec2) { + m[row+0], m[row+4] = v[0], v[1] +} + +// Mat4x2FromRows builds a new matrix from row vectors. +// The resulting matrix will still be in column major order, but this can be +// good for hand-building matrices. + +func Mat4x2FromRows(row0, row1, row2, row3 Vec2) Mat4x2 { + return Mat4x2{row0[0], row1[0], row2[0], row3[0], row0[1], row1[1], row2[1], row3[1]} +} + +// Mat4x2FromCols builds a new matrix from column vectors. +func Mat4x2FromCols(col0, col1 Vec4) Mat4x2 { + return Mat4x2{col0[0], col0[1], col0[2], col0[3], col1[0], col1[1], col1[2], col1[3]} +} + +// Add performs an element-wise addition of two matrices, this is +// equivalent to iterating over every element of m1 and adding the corresponding value of m2. +func (m1 Mat4x2) Add(m2 Mat4x2) Mat4x2 { + return Mat4x2{m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2], m1[3] + m2[3], m1[4] + m2[4], m1[5] + m2[5], m1[6] + m2[6], m1[7] + m2[7]} +} + +// Sub performs an element-wise subtraction of two matrices, this is +// equivalent to iterating over every element of m1 and subtracting the corresponding value of m2. +func (m1 Mat4x2) Sub(m2 Mat4x2) Mat4x2 { + return Mat4x2{m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2], m1[3] - m2[3], m1[4] - m2[4], m1[5] - m2[5], m1[6] - m2[6], m1[7] - m2[7]} +} + +// Mul performs a scalar multiplcation of the matrix. This is equivalent to iterating +// over every element of the matrix and multiply it by c. +func (m1 Mat4x2) Mul(c float32) Mat4x2 { + return Mat4x2{m1[0] * c, m1[1] * c, m1[2] * c, m1[3] * c, m1[4] * c, m1[5] * c, m1[6] * c, m1[7] * c} +} + +// Mul2x1 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat4x2) Mul2x1(m2 Vec2) Vec4 { + return Vec4{ + m1[0]*m2[0] + m1[4]*m2[1], + m1[1]*m2[0] + m1[5]*m2[1], + m1[2]*m2[0] + m1[6]*m2[1], + m1[3]*m2[0] + m1[7]*m2[1], + } +} + +// Mul2 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat4x2) Mul2(m2 Mat2) Mat4x2 { + return Mat4x2{ + m1[0]*m2[0] + m1[4]*m2[1], + m1[1]*m2[0] + m1[5]*m2[1], + m1[2]*m2[0] + m1[6]*m2[1], + m1[3]*m2[0] + m1[7]*m2[1], + m1[0]*m2[2] + m1[4]*m2[3], + m1[1]*m2[2] + m1[5]*m2[3], + m1[2]*m2[2] + m1[6]*m2[3], + m1[3]*m2[2] + m1[7]*m2[3], + } +} + +// Mul2x3 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat4x2) Mul2x3(m2 Mat2x3) Mat4x3 { + return Mat4x3{ + m1[0]*m2[0] + m1[4]*m2[1], + m1[1]*m2[0] + m1[5]*m2[1], + m1[2]*m2[0] + m1[6]*m2[1], + m1[3]*m2[0] + m1[7]*m2[1], + m1[0]*m2[2] + m1[4]*m2[3], + m1[1]*m2[2] + m1[5]*m2[3], + m1[2]*m2[2] + m1[6]*m2[3], + m1[3]*m2[2] + m1[7]*m2[3], + m1[0]*m2[4] + m1[4]*m2[5], + m1[1]*m2[4] + m1[5]*m2[5], + m1[2]*m2[4] + m1[6]*m2[5], + m1[3]*m2[4] + m1[7]*m2[5], + } +} + +// Mul2x4 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat4x2) Mul2x4(m2 Mat2x4) Mat4 { + return Mat4{ + m1[0]*m2[0] + m1[4]*m2[1], + m1[1]*m2[0] + m1[5]*m2[1], + m1[2]*m2[0] + m1[6]*m2[1], + m1[3]*m2[0] + m1[7]*m2[1], + m1[0]*m2[2] + m1[4]*m2[3], + m1[1]*m2[2] + m1[5]*m2[3], + m1[2]*m2[2] + m1[6]*m2[3], + m1[3]*m2[2] + m1[7]*m2[3], + m1[0]*m2[4] + m1[4]*m2[5], + m1[1]*m2[4] + m1[5]*m2[5], + m1[2]*m2[4] + m1[6]*m2[5], + m1[3]*m2[4] + m1[7]*m2[5], + m1[0]*m2[6] + m1[4]*m2[7], + m1[1]*m2[6] + m1[5]*m2[7], + m1[2]*m2[6] + m1[6]*m2[7], + m1[3]*m2[6] + m1[7]*m2[7], + } +} + +// Transpose produces the transpose of this matrix. For any MxN matrix +// the transpose is an NxM matrix with the rows swapped with the columns. For instance +// the transpose of the Mat3x2 is a Mat2x3 like so: +// +// [[a b]] [[a c e]] +// [[c d]] = [[b d f]] +// [[e f]] +func (m1 Mat4x2) Transpose() Mat2x4 { + return Mat2x4{m1[0], m1[4], m1[1], m1[5], m1[2], m1[6], m1[3], m1[7]} +} + +// ApproxEqual performs an element-wise approximate equality test between two matrices, +// as if FloatEqual had been used. +func (m1 Mat4x2) ApproxEqual(m2 Mat4x2) bool { + for i := range m1 { + if !FloatEqual(m1[i], m2[i]) { + return false + } + } + return true +} + +// ApproxEqualThreshold performs an element-wise approximate equality test between two matrices +// with a given epsilon threshold, as if FloatEqualThreshold had been used. +func (m1 Mat4x2) ApproxEqualThreshold(m2 Mat4x2, threshold float32) bool { + for i := range m1 { + if !FloatEqualThreshold(m1[i], m2[i], threshold) { + return false + } + } + return true +} + +// ApproxFuncEqual performs an element-wise approximate equality test between two matrices +// with a given equality functions, intended to be used with FloatEqualFunc; although and comparison +// function may be used in practice. +func (m1 Mat4x2) ApproxFuncEqual(m2 Mat4x2, eq func(float32, float32) bool) bool { + for i := range m1 { + if !eq(m1[i], m2[i]) { + return false + } + } + return true +} + +// NumRows returns the number of rows in this matrix +func (m Mat4x2) NumRows() int { + return 4 +} + +// NumCols returns the number of columns in this matrix +func (m Mat4x2) NumCols() int { + return 2 +} + +// At returns the matrix element at the given row and column. +// This is equivalent to mat[col * numRow + row] where numRow is constant +// (E.G. for a Mat3x2 it's equal to 3) +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// At(5,0) will work just like At(1,1). Or it may panic if it's out of bounds. +func (m Mat4x2) At(row, col int) float32 { + return m[col*4+row] +} + +// Set sets the corresponding matrix element at the given row and column. +// This has a pointer receiver because it mutates the matrix. +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// Set(5,0,val) will work just like Set(1,1,val). Or it may panic if it's out of bounds. +func (m *Mat4x2) Set(row, col int, value float32) { + m[col*4+row] = value +} + +// Index returns the index of the given row and column, to be used with direct +// access. E.G. Index(0,0) = 0. +// +// This is a garbage-in garbage-out method. For instance, on a Mat4 asking for the index of +// (5,0) will work the same as asking for (1,1). Or it may give you a value that will cause +// a panic if you try to access the array with it if it's truly out of bounds. +func (m Mat4x2) Index(row, col int) int { + return col*4 + row +} + +// Row returns a vector representing the corresponding row (starting at row 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecM for a MxN matrix. +func (m Mat4x2) Row(row int) Vec2 { + return Vec2{m[row+0], m[row+4]} +} + +// Rows decomposes a matrix into its corresponding row vectors. +// This is equivalent to calling mat.Row for each row. +func (m Mat4x2) Rows() (row0, row1, row2, row3 Vec2) { + return m.Row(0), m.Row(1), m.Row(2), m.Row(3) +} + +// Col returns a vector representing the corresponding column (starting at col 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecN for a MxN matrix. +func (m Mat4x2) Col(col int) Vec4 { + return Vec4{m[col*4+0], m[col*4+1], m[col*4+2], m[col*4+3]} +} + +// Cols decomposes a matrix into its corresponding column vectors. +// This is equivalent to calling mat.Col for each column. +func (m Mat4x2) Cols() (col0, col1 Vec4) { + return m.Col(0), m.Col(1) +} + +// Abs returns the element-wise absolute value of this matrix +func (m Mat4x2) Abs() Mat4x2 { + return Mat4x2{Abs(m[0]), Abs(m[1]), Abs(m[2]), Abs(m[3]), Abs(m[4]), Abs(m[5]), Abs(m[6]), Abs(m[7])} +} + +// Pretty prints the matrix +func (m Mat4x2) String() string { + buf := new(bytes.Buffer) + w := tabwriter.NewWriter(buf, 4, 4, 1, ' ', tabwriter.AlignRight) + for i := 0; i < 4; i++ { + for _, col := range m.Row(i) { + fmt.Fprintf(w, "%f\t", col) + } + + fmt.Fprintln(w, "") + } + w.Flush() + + return buf.String() +} + +// SetCol sets a Column within the Matrix, so it mutates the calling matrix. +func (m *Mat4x3) SetCol(col int, v Vec4) { + m[col*4+0], m[col*4+1], m[col*4+2], m[col*4+3] = v[0], v[1], v[2], v[3] +} + +// SetRow sets a Row within the Matrix, so it mutates the calling matrix. +func (m *Mat4x3) SetRow(row int, v Vec3) { + m[row+0], m[row+4], m[row+8] = v[0], v[1], v[2] +} + +// Mat4x3FromRows builds a new matrix from row vectors. +// The resulting matrix will still be in column major order, but this can be +// good for hand-building matrices. + +func Mat4x3FromRows(row0, row1, row2, row3 Vec3) Mat4x3 { + return Mat4x3{row0[0], row1[0], row2[0], row3[0], row0[1], row1[1], row2[1], row3[1], row0[2], row1[2], row2[2], row3[2]} +} + +// Mat4x3FromCols builds a new matrix from column vectors. +func Mat4x3FromCols(col0, col1, col2 Vec4) Mat4x3 { + return Mat4x3{col0[0], col0[1], col0[2], col0[3], col1[0], col1[1], col1[2], col1[3], col2[0], col2[1], col2[2], col2[3]} +} + +// Add performs an element-wise addition of two matrices, this is +// equivalent to iterating over every element of m1 and adding the corresponding value of m2. +func (m1 Mat4x3) Add(m2 Mat4x3) Mat4x3 { + return Mat4x3{m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2], m1[3] + m2[3], m1[4] + m2[4], m1[5] + m2[5], m1[6] + m2[6], m1[7] + m2[7], m1[8] + m2[8], m1[9] + m2[9], m1[10] + m2[10], m1[11] + m2[11]} +} + +// Sub performs an element-wise subtraction of two matrices, this is +// equivalent to iterating over every element of m1 and subtracting the corresponding value of m2. +func (m1 Mat4x3) Sub(m2 Mat4x3) Mat4x3 { + return Mat4x3{m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2], m1[3] - m2[3], m1[4] - m2[4], m1[5] - m2[5], m1[6] - m2[6], m1[7] - m2[7], m1[8] - m2[8], m1[9] - m2[9], m1[10] - m2[10], m1[11] - m2[11]} +} + +// Mul performs a scalar multiplcation of the matrix. This is equivalent to iterating +// over every element of the matrix and multiply it by c. +func (m1 Mat4x3) Mul(c float32) Mat4x3 { + return Mat4x3{m1[0] * c, m1[1] * c, m1[2] * c, m1[3] * c, m1[4] * c, m1[5] * c, m1[6] * c, m1[7] * c, m1[8] * c, m1[9] * c, m1[10] * c, m1[11] * c} +} + +// Mul3x1 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat4x3) Mul3x1(m2 Vec3) Vec4 { + return Vec4{ + m1[0]*m2[0] + m1[4]*m2[1] + m1[8]*m2[2], + m1[1]*m2[0] + m1[5]*m2[1] + m1[9]*m2[2], + m1[2]*m2[0] + m1[6]*m2[1] + m1[10]*m2[2], + m1[3]*m2[0] + m1[7]*m2[1] + m1[11]*m2[2], + } +} + +// Mul3x2 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat4x3) Mul3x2(m2 Mat3x2) Mat4x2 { + return Mat4x2{ + m1[0]*m2[0] + m1[4]*m2[1] + m1[8]*m2[2], + m1[1]*m2[0] + m1[5]*m2[1] + m1[9]*m2[2], + m1[2]*m2[0] + m1[6]*m2[1] + m1[10]*m2[2], + m1[3]*m2[0] + m1[7]*m2[1] + m1[11]*m2[2], + m1[0]*m2[3] + m1[4]*m2[4] + m1[8]*m2[5], + m1[1]*m2[3] + m1[5]*m2[4] + m1[9]*m2[5], + m1[2]*m2[3] + m1[6]*m2[4] + m1[10]*m2[5], + m1[3]*m2[3] + m1[7]*m2[4] + m1[11]*m2[5], + } +} + +// Mul3 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat4x3) Mul3(m2 Mat3) Mat4x3 { + return Mat4x3{ + m1[0]*m2[0] + m1[4]*m2[1] + m1[8]*m2[2], + m1[1]*m2[0] + m1[5]*m2[1] + m1[9]*m2[2], + m1[2]*m2[0] + m1[6]*m2[1] + m1[10]*m2[2], + m1[3]*m2[0] + m1[7]*m2[1] + m1[11]*m2[2], + m1[0]*m2[3] + m1[4]*m2[4] + m1[8]*m2[5], + m1[1]*m2[3] + m1[5]*m2[4] + m1[9]*m2[5], + m1[2]*m2[3] + m1[6]*m2[4] + m1[10]*m2[5], + m1[3]*m2[3] + m1[7]*m2[4] + m1[11]*m2[5], + m1[0]*m2[6] + m1[4]*m2[7] + m1[8]*m2[8], + m1[1]*m2[6] + m1[5]*m2[7] + m1[9]*m2[8], + m1[2]*m2[6] + m1[6]*m2[7] + m1[10]*m2[8], + m1[3]*m2[6] + m1[7]*m2[7] + m1[11]*m2[8], + } +} + +// Mul3x4 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat4x3) Mul3x4(m2 Mat3x4) Mat4 { + return Mat4{ + m1[0]*m2[0] + m1[4]*m2[1] + m1[8]*m2[2], + m1[1]*m2[0] + m1[5]*m2[1] + m1[9]*m2[2], + m1[2]*m2[0] + m1[6]*m2[1] + m1[10]*m2[2], + m1[3]*m2[0] + m1[7]*m2[1] + m1[11]*m2[2], + m1[0]*m2[3] + m1[4]*m2[4] + m1[8]*m2[5], + m1[1]*m2[3] + m1[5]*m2[4] + m1[9]*m2[5], + m1[2]*m2[3] + m1[6]*m2[4] + m1[10]*m2[5], + m1[3]*m2[3] + m1[7]*m2[4] + m1[11]*m2[5], + m1[0]*m2[6] + m1[4]*m2[7] + m1[8]*m2[8], + m1[1]*m2[6] + m1[5]*m2[7] + m1[9]*m2[8], + m1[2]*m2[6] + m1[6]*m2[7] + m1[10]*m2[8], + m1[3]*m2[6] + m1[7]*m2[7] + m1[11]*m2[8], + m1[0]*m2[9] + m1[4]*m2[10] + m1[8]*m2[11], + m1[1]*m2[9] + m1[5]*m2[10] + m1[9]*m2[11], + m1[2]*m2[9] + m1[6]*m2[10] + m1[10]*m2[11], + m1[3]*m2[9] + m1[7]*m2[10] + m1[11]*m2[11], + } +} + +// Transpose produces the transpose of this matrix. For any MxN matrix +// the transpose is an NxM matrix with the rows swapped with the columns. For instance +// the transpose of the Mat3x2 is a Mat2x3 like so: +// +// [[a b]] [[a c e]] +// [[c d]] = [[b d f]] +// [[e f]] +func (m1 Mat4x3) Transpose() Mat3x4 { + return Mat3x4{m1[0], m1[4], m1[8], m1[1], m1[5], m1[9], m1[2], m1[6], m1[10], m1[3], m1[7], m1[11]} +} + +// ApproxEqual performs an element-wise approximate equality test between two matrices, +// as if FloatEqual had been used. +func (m1 Mat4x3) ApproxEqual(m2 Mat4x3) bool { + for i := range m1 { + if !FloatEqual(m1[i], m2[i]) { + return false + } + } + return true +} + +// ApproxEqualThreshold performs an element-wise approximate equality test between two matrices +// with a given epsilon threshold, as if FloatEqualThreshold had been used. +func (m1 Mat4x3) ApproxEqualThreshold(m2 Mat4x3, threshold float32) bool { + for i := range m1 { + if !FloatEqualThreshold(m1[i], m2[i], threshold) { + return false + } + } + return true +} + +// ApproxFuncEqual performs an element-wise approximate equality test between two matrices +// with a given equality functions, intended to be used with FloatEqualFunc; although and comparison +// function may be used in practice. +func (m1 Mat4x3) ApproxFuncEqual(m2 Mat4x3, eq func(float32, float32) bool) bool { + for i := range m1 { + if !eq(m1[i], m2[i]) { + return false + } + } + return true +} + +// NumRows returns the number of rows in this matrix +func (m Mat4x3) NumRows() int { + return 4 +} + +// NumCols returns the number of columns in this matrix +func (m Mat4x3) NumCols() int { + return 3 +} + +// At returns the matrix element at the given row and column. +// This is equivalent to mat[col * numRow + row] where numRow is constant +// (E.G. for a Mat3x2 it's equal to 3) +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// At(5,0) will work just like At(1,1). Or it may panic if it's out of bounds. +func (m Mat4x3) At(row, col int) float32 { + return m[col*4+row] +} + +// Set sets the corresponding matrix element at the given row and column. +// This has a pointer receiver because it mutates the matrix. +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// Set(5,0,val) will work just like Set(1,1,val). Or it may panic if it's out of bounds. +func (m *Mat4x3) Set(row, col int, value float32) { + m[col*4+row] = value +} + +// Index returns the index of the given row and column, to be used with direct +// access. E.G. Index(0,0) = 0. +// +// This is a garbage-in garbage-out method. For instance, on a Mat4 asking for the index of +// (5,0) will work the same as asking for (1,1). Or it may give you a value that will cause +// a panic if you try to access the array with it if it's truly out of bounds. +func (m Mat4x3) Index(row, col int) int { + return col*4 + row +} + +// Row returns a vector representing the corresponding row (starting at row 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecM for a MxN matrix. +func (m Mat4x3) Row(row int) Vec3 { + return Vec3{m[row+0], m[row+4], m[row+8]} +} + +// Rows decomposes a matrix into its corresponding row vectors. +// This is equivalent to calling mat.Row for each row. +func (m Mat4x3) Rows() (row0, row1, row2, row3 Vec3) { + return m.Row(0), m.Row(1), m.Row(2), m.Row(3) +} + +// Col returns a vector representing the corresponding column (starting at col 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecN for a MxN matrix. +func (m Mat4x3) Col(col int) Vec4 { + return Vec4{m[col*4+0], m[col*4+1], m[col*4+2], m[col*4+3]} +} + +// Cols decomposes a matrix into its corresponding column vectors. +// This is equivalent to calling mat.Col for each column. +func (m Mat4x3) Cols() (col0, col1, col2 Vec4) { + return m.Col(0), m.Col(1), m.Col(2) +} + +// Abs returns the element-wise absolute value of this matrix +func (m Mat4x3) Abs() Mat4x3 { + return Mat4x3{Abs(m[0]), Abs(m[1]), Abs(m[2]), Abs(m[3]), Abs(m[4]), Abs(m[5]), Abs(m[6]), Abs(m[7]), Abs(m[8]), Abs(m[9]), Abs(m[10]), Abs(m[11])} +} + +// Pretty prints the matrix +func (m Mat4x3) String() string { + buf := new(bytes.Buffer) + w := tabwriter.NewWriter(buf, 4, 4, 1, ' ', tabwriter.AlignRight) + for i := 0; i < 4; i++ { + for _, col := range m.Row(i) { + fmt.Fprintf(w, "%f\t", col) + } + + fmt.Fprintln(w, "") + } + w.Flush() + + return buf.String() +} + +// SetCol sets a Column within the Matrix, so it mutates the calling matrix. +func (m *Mat4) SetCol(col int, v Vec4) { + m[col*4+0], m[col*4+1], m[col*4+2], m[col*4+3] = v[0], v[1], v[2], v[3] +} + +// SetRow sets a Row within the Matrix, so it mutates the calling matrix. +func (m *Mat4) SetRow(row int, v Vec4) { + m[row+0], m[row+4], m[row+8], m[row+12] = v[0], v[1], v[2], v[3] +} + +// Diag is a basic operation on a square matrix that simply +// returns main diagonal (meaning all elements such that row==col). +func (m Mat4) Diag() Vec4 { + return Vec4{m[0], m[5], m[10], m[15]} +} + +// Ident4 returns the 4x4 identity matrix. +// The identity matrix is a square matrix with the value 1 on its +// diagonals. The characteristic property of the identity matrix is that +// any matrix multiplied by it is itself. (MI = M; IN = N) +func Ident4() Mat4 { + return Mat4{1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1} +} + +// Diag4 creates a diagonal matrix from the entries of the input vector. +// That is, for each pointer for row==col, vector[row] is the entry. Otherwise it's 0. +// +// Another way to think about it is that the identity is this function where the every vector element is 1. +func Diag4(v Vec4) Mat4 { + var m Mat4 + m[0], m[5], m[10], m[15] = v[0], v[1], v[2], v[3] + return m +} + +// Mat4FromRows builds a new matrix from row vectors. +// The resulting matrix will still be in column major order, but this can be +// good for hand-building matrices. + +func Mat4FromRows(row0, row1, row2, row3 Vec4) Mat4 { + return Mat4{row0[0], row1[0], row2[0], row3[0], row0[1], row1[1], row2[1], row3[1], row0[2], row1[2], row2[2], row3[2], row0[3], row1[3], row2[3], row3[3]} +} + +// Mat4FromCols builds a new matrix from column vectors. +func Mat4FromCols(col0, col1, col2, col3 Vec4) Mat4 { + return Mat4{col0[0], col0[1], col0[2], col0[3], col1[0], col1[1], col1[2], col1[3], col2[0], col2[1], col2[2], col2[3], col3[0], col3[1], col3[2], col3[3]} +} + +// Add performs an element-wise addition of two matrices, this is +// equivalent to iterating over every element of m1 and adding the corresponding value of m2. +func (m1 Mat4) Add(m2 Mat4) Mat4 { + return Mat4{m1[0] + m2[0], m1[1] + m2[1], m1[2] + m2[2], m1[3] + m2[3], m1[4] + m2[4], m1[5] + m2[5], m1[6] + m2[6], m1[7] + m2[7], m1[8] + m2[8], m1[9] + m2[9], m1[10] + m2[10], m1[11] + m2[11], m1[12] + m2[12], m1[13] + m2[13], m1[14] + m2[14], m1[15] + m2[15]} +} + +// Sub performs an element-wise subtraction of two matrices, this is +// equivalent to iterating over every element of m1 and subtracting the corresponding value of m2. +func (m1 Mat4) Sub(m2 Mat4) Mat4 { + return Mat4{m1[0] - m2[0], m1[1] - m2[1], m1[2] - m2[2], m1[3] - m2[3], m1[4] - m2[4], m1[5] - m2[5], m1[6] - m2[6], m1[7] - m2[7], m1[8] - m2[8], m1[9] - m2[9], m1[10] - m2[10], m1[11] - m2[11], m1[12] - m2[12], m1[13] - m2[13], m1[14] - m2[14], m1[15] - m2[15]} +} + +// Mul performs a scalar multiplcation of the matrix. This is equivalent to iterating +// over every element of the matrix and multiply it by c. +func (m1 Mat4) Mul(c float32) Mat4 { + return Mat4{m1[0] * c, m1[1] * c, m1[2] * c, m1[3] * c, m1[4] * c, m1[5] * c, m1[6] * c, m1[7] * c, m1[8] * c, m1[9] * c, m1[10] * c, m1[11] * c, m1[12] * c, m1[13] * c, m1[14] * c, m1[15] * c} +} + +// Mul4x1 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat4) Mul4x1(m2 Vec4) Vec4 { + return Vec4{ + m1[0]*m2[0] + m1[4]*m2[1] + m1[8]*m2[2] + m1[12]*m2[3], + m1[1]*m2[0] + m1[5]*m2[1] + m1[9]*m2[2] + m1[13]*m2[3], + m1[2]*m2[0] + m1[6]*m2[1] + m1[10]*m2[2] + m1[14]*m2[3], + m1[3]*m2[0] + m1[7]*m2[1] + m1[11]*m2[2] + m1[15]*m2[3], + } +} + +// Mul4x2 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat4) Mul4x2(m2 Mat4x2) Mat4x2 { + return Mat4x2{ + m1[0]*m2[0] + m1[4]*m2[1] + m1[8]*m2[2] + m1[12]*m2[3], + m1[1]*m2[0] + m1[5]*m2[1] + m1[9]*m2[2] + m1[13]*m2[3], + m1[2]*m2[0] + m1[6]*m2[1] + m1[10]*m2[2] + m1[14]*m2[3], + m1[3]*m2[0] + m1[7]*m2[1] + m1[11]*m2[2] + m1[15]*m2[3], + m1[0]*m2[4] + m1[4]*m2[5] + m1[8]*m2[6] + m1[12]*m2[7], + m1[1]*m2[4] + m1[5]*m2[5] + m1[9]*m2[6] + m1[13]*m2[7], + m1[2]*m2[4] + m1[6]*m2[5] + m1[10]*m2[6] + m1[14]*m2[7], + m1[3]*m2[4] + m1[7]*m2[5] + m1[11]*m2[6] + m1[15]*m2[7], + } +} + +// Mul4x3 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat4) Mul4x3(m2 Mat4x3) Mat4x3 { + return Mat4x3{ + m1[0]*m2[0] + m1[4]*m2[1] + m1[8]*m2[2] + m1[12]*m2[3], + m1[1]*m2[0] + m1[5]*m2[1] + m1[9]*m2[2] + m1[13]*m2[3], + m1[2]*m2[0] + m1[6]*m2[1] + m1[10]*m2[2] + m1[14]*m2[3], + m1[3]*m2[0] + m1[7]*m2[1] + m1[11]*m2[2] + m1[15]*m2[3], + m1[0]*m2[4] + m1[4]*m2[5] + m1[8]*m2[6] + m1[12]*m2[7], + m1[1]*m2[4] + m1[5]*m2[5] + m1[9]*m2[6] + m1[13]*m2[7], + m1[2]*m2[4] + m1[6]*m2[5] + m1[10]*m2[6] + m1[14]*m2[7], + m1[3]*m2[4] + m1[7]*m2[5] + m1[11]*m2[6] + m1[15]*m2[7], + m1[0]*m2[8] + m1[4]*m2[9] + m1[8]*m2[10] + m1[12]*m2[11], + m1[1]*m2[8] + m1[5]*m2[9] + m1[9]*m2[10] + m1[13]*m2[11], + m1[2]*m2[8] + m1[6]*m2[9] + m1[10]*m2[10] + m1[14]*m2[11], + m1[3]*m2[8] + m1[7]*m2[9] + m1[11]*m2[10] + m1[15]*m2[11], + } +} + +// Mul4 performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 Mat4) Mul4(m2 Mat4) Mat4 { + return Mat4{ + m1[0]*m2[0] + m1[4]*m2[1] + m1[8]*m2[2] + m1[12]*m2[3], + m1[1]*m2[0] + m1[5]*m2[1] + m1[9]*m2[2] + m1[13]*m2[3], + m1[2]*m2[0] + m1[6]*m2[1] + m1[10]*m2[2] + m1[14]*m2[3], + m1[3]*m2[0] + m1[7]*m2[1] + m1[11]*m2[2] + m1[15]*m2[3], + m1[0]*m2[4] + m1[4]*m2[5] + m1[8]*m2[6] + m1[12]*m2[7], + m1[1]*m2[4] + m1[5]*m2[5] + m1[9]*m2[6] + m1[13]*m2[7], + m1[2]*m2[4] + m1[6]*m2[5] + m1[10]*m2[6] + m1[14]*m2[7], + m1[3]*m2[4] + m1[7]*m2[5] + m1[11]*m2[6] + m1[15]*m2[7], + m1[0]*m2[8] + m1[4]*m2[9] + m1[8]*m2[10] + m1[12]*m2[11], + m1[1]*m2[8] + m1[5]*m2[9] + m1[9]*m2[10] + m1[13]*m2[11], + m1[2]*m2[8] + m1[6]*m2[9] + m1[10]*m2[10] + m1[14]*m2[11], + m1[3]*m2[8] + m1[7]*m2[9] + m1[11]*m2[10] + m1[15]*m2[11], + m1[0]*m2[12] + m1[4]*m2[13] + m1[8]*m2[14] + m1[12]*m2[15], + m1[1]*m2[12] + m1[5]*m2[13] + m1[9]*m2[14] + m1[13]*m2[15], + m1[2]*m2[12] + m1[6]*m2[13] + m1[10]*m2[14] + m1[14]*m2[15], + m1[3]*m2[12] + m1[7]*m2[13] + m1[11]*m2[14] + m1[15]*m2[15], + } +} + +// Transpose produces the transpose of this matrix. For any MxN matrix +// the transpose is an NxM matrix with the rows swapped with the columns. For instance +// the transpose of the Mat3x2 is a Mat2x3 like so: +// +// [[a b]] [[a c e]] +// [[c d]] = [[b d f]] +// [[e f]] +func (m1 Mat4) Transpose() Mat4 { + return Mat4{m1[0], m1[4], m1[8], m1[12], m1[1], m1[5], m1[9], m1[13], m1[2], m1[6], m1[10], m1[14], m1[3], m1[7], m1[11], m1[15]} +} + +// Det returns the determinant of a matrix. It is a measure of a square matrix's +// singularity and invertability, among other things. In this library, the +// determinant is hard coded based on pre-computed cofactor expansion, and uses +// no loops. Of course, the addition and multiplication must still be done. +func (m Mat4) Det() float32 { + return m[0]*m[5]*m[10]*m[15] - m[0]*m[5]*m[11]*m[14] - m[0]*m[6]*m[9]*m[15] + m[0]*m[6]*m[11]*m[13] + m[0]*m[7]*m[9]*m[14] - m[0]*m[7]*m[10]*m[13] - m[1]*m[4]*m[10]*m[15] + m[1]*m[4]*m[11]*m[14] + m[1]*m[6]*m[8]*m[15] - m[1]*m[6]*m[11]*m[12] - m[1]*m[7]*m[8]*m[14] + m[1]*m[7]*m[10]*m[12] + m[2]*m[4]*m[9]*m[15] - m[2]*m[4]*m[11]*m[13] - m[2]*m[5]*m[8]*m[15] + m[2]*m[5]*m[11]*m[12] + m[2]*m[7]*m[8]*m[13] - m[2]*m[7]*m[9]*m[12] - m[3]*m[4]*m[9]*m[14] + m[3]*m[4]*m[10]*m[13] + m[3]*m[5]*m[8]*m[14] - m[3]*m[5]*m[10]*m[12] - m[3]*m[6]*m[8]*m[13] + m[3]*m[6]*m[9]*m[12] +} + +// Inv computes the inverse of a square matrix. An inverse is a square matrix such that when multiplied by the +// original, yields the identity. +// +// M_inv * M = M * M_inv = I +// +// In this library, the math is precomputed, and uses no loops, though the multiplications, additions, determinant calculation, and scaling +// are still done. This can still be (relatively) expensive for a 4x4. +// +// This function checks the determinant to see if the matrix is invertible. +// If the determinant is 0.0, this function returns the zero matrix. However, due to floating point errors, it is +// entirely plausible to get a false positive or negative. +// In the future, an alternate function may be written which takes in a pre-computed determinant. +func (m Mat4) Inv() Mat4 { + det := m.Det() + if FloatEqual(det, float32(0.0)) { + return Mat4{} + } + + retMat := Mat4{ + -m[7]*m[10]*m[13] + m[6]*m[11]*m[13] + m[7]*m[9]*m[14] - m[5]*m[11]*m[14] - m[6]*m[9]*m[15] + m[5]*m[10]*m[15], + m[3]*m[10]*m[13] - m[2]*m[11]*m[13] - m[3]*m[9]*m[14] + m[1]*m[11]*m[14] + m[2]*m[9]*m[15] - m[1]*m[10]*m[15], + -m[3]*m[6]*m[13] + m[2]*m[7]*m[13] + m[3]*m[5]*m[14] - m[1]*m[7]*m[14] - m[2]*m[5]*m[15] + m[1]*m[6]*m[15], + m[3]*m[6]*m[9] - m[2]*m[7]*m[9] - m[3]*m[5]*m[10] + m[1]*m[7]*m[10] + m[2]*m[5]*m[11] - m[1]*m[6]*m[11], + m[7]*m[10]*m[12] - m[6]*m[11]*m[12] - m[7]*m[8]*m[14] + m[4]*m[11]*m[14] + m[6]*m[8]*m[15] - m[4]*m[10]*m[15], + -m[3]*m[10]*m[12] + m[2]*m[11]*m[12] + m[3]*m[8]*m[14] - m[0]*m[11]*m[14] - m[2]*m[8]*m[15] + m[0]*m[10]*m[15], + m[3]*m[6]*m[12] - m[2]*m[7]*m[12] - m[3]*m[4]*m[14] + m[0]*m[7]*m[14] + m[2]*m[4]*m[15] - m[0]*m[6]*m[15], + -m[3]*m[6]*m[8] + m[2]*m[7]*m[8] + m[3]*m[4]*m[10] - m[0]*m[7]*m[10] - m[2]*m[4]*m[11] + m[0]*m[6]*m[11], + -m[7]*m[9]*m[12] + m[5]*m[11]*m[12] + m[7]*m[8]*m[13] - m[4]*m[11]*m[13] - m[5]*m[8]*m[15] + m[4]*m[9]*m[15], + m[3]*m[9]*m[12] - m[1]*m[11]*m[12] - m[3]*m[8]*m[13] + m[0]*m[11]*m[13] + m[1]*m[8]*m[15] - m[0]*m[9]*m[15], + -m[3]*m[5]*m[12] + m[1]*m[7]*m[12] + m[3]*m[4]*m[13] - m[0]*m[7]*m[13] - m[1]*m[4]*m[15] + m[0]*m[5]*m[15], + m[3]*m[5]*m[8] - m[1]*m[7]*m[8] - m[3]*m[4]*m[9] + m[0]*m[7]*m[9] + m[1]*m[4]*m[11] - m[0]*m[5]*m[11], + m[6]*m[9]*m[12] - m[5]*m[10]*m[12] - m[6]*m[8]*m[13] + m[4]*m[10]*m[13] + m[5]*m[8]*m[14] - m[4]*m[9]*m[14], + -m[2]*m[9]*m[12] + m[1]*m[10]*m[12] + m[2]*m[8]*m[13] - m[0]*m[10]*m[13] - m[1]*m[8]*m[14] + m[0]*m[9]*m[14], + m[2]*m[5]*m[12] - m[1]*m[6]*m[12] - m[2]*m[4]*m[13] + m[0]*m[6]*m[13] + m[1]*m[4]*m[14] - m[0]*m[5]*m[14], + -m[2]*m[5]*m[8] + m[1]*m[6]*m[8] + m[2]*m[4]*m[9] - m[0]*m[6]*m[9] - m[1]*m[4]*m[10] + m[0]*m[5]*m[10], + } + + return retMat.Mul(1 / det) +} + +// ApproxEqual performs an element-wise approximate equality test between two matrices, +// as if FloatEqual had been used. +func (m1 Mat4) ApproxEqual(m2 Mat4) bool { + for i := range m1 { + if !FloatEqual(m1[i], m2[i]) { + return false + } + } + return true +} + +// ApproxEqualThreshold performs an element-wise approximate equality test between two matrices +// with a given epsilon threshold, as if FloatEqualThreshold had been used. +func (m1 Mat4) ApproxEqualThreshold(m2 Mat4, threshold float32) bool { + for i := range m1 { + if !FloatEqualThreshold(m1[i], m2[i], threshold) { + return false + } + } + return true +} + +// ApproxFuncEqual performs an element-wise approximate equality test between two matrices +// with a given equality functions, intended to be used with FloatEqualFunc; although and comparison +// function may be used in practice. +func (m1 Mat4) ApproxFuncEqual(m2 Mat4, eq func(float32, float32) bool) bool { + for i := range m1 { + if !eq(m1[i], m2[i]) { + return false + } + } + return true +} + +// NumRows returns the number of rows in this matrix +func (m Mat4) NumRows() int { + return 4 +} + +// NumCols returns the number of columns in this matrix +func (m Mat4) NumCols() int { + return 4 +} + +// At returns the matrix element at the given row and column. +// This is equivalent to mat[col * numRow + row] where numRow is constant +// (E.G. for a Mat3x2 it's equal to 3) +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// At(5,0) will work just like At(1,1). Or it may panic if it's out of bounds. +func (m Mat4) At(row, col int) float32 { + return m[col*4+row] +} + +// Set sets the corresponding matrix element at the given row and column. +// This has a pointer receiver because it mutates the matrix. +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// Set(5,0,val) will work just like Set(1,1,val). Or it may panic if it's out of bounds. +func (m *Mat4) Set(row, col int, value float32) { + m[col*4+row] = value +} + +// Index returns the index of the given row and column, to be used with direct +// access. E.G. Index(0,0) = 0. +// +// This is a garbage-in garbage-out method. For instance, on a Mat4 asking for the index of +// (5,0) will work the same as asking for (1,1). Or it may give you a value that will cause +// a panic if you try to access the array with it if it's truly out of bounds. +func (m Mat4) Index(row, col int) int { + return col*4 + row +} + +// Row returns a vector representing the corresponding row (starting at row 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecM for a MxN matrix. +func (m Mat4) Row(row int) Vec4 { + return Vec4{m[row+0], m[row+4], m[row+8], m[row+12]} +} + +// Rows decomposes a matrix into its corresponding row vectors. +// This is equivalent to calling mat.Row for each row. +func (m Mat4) Rows() (row0, row1, row2, row3 Vec4) { + return m.Row(0), m.Row(1), m.Row(2), m.Row(3) +} + +// Col returns a vector representing the corresponding column (starting at col 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecN for a MxN matrix. +func (m Mat4) Col(col int) Vec4 { + return Vec4{m[col*4+0], m[col*4+1], m[col*4+2], m[col*4+3]} +} + +// Cols decomposes a matrix into its corresponding column vectors. +// This is equivalent to calling mat.Col for each column. +func (m Mat4) Cols() (col0, col1, col2, col3 Vec4) { + return m.Col(0), m.Col(1), m.Col(2), m.Col(3) +} + +// Trace is a basic operation on a square matrix that simply +// sums up all elements on the main diagonal (meaning all elements such that row==col). +func (m Mat4) Trace() float32 { + return m[0] + m[5] + m[10] + m[15] +} + +// Abs returns the element-wise absolute value of this matrix +func (m Mat4) Abs() Mat4 { + return Mat4{Abs(m[0]), Abs(m[1]), Abs(m[2]), Abs(m[3]), Abs(m[4]), Abs(m[5]), Abs(m[6]), Abs(m[7]), Abs(m[8]), Abs(m[9]), Abs(m[10]), Abs(m[11]), Abs(m[12]), Abs(m[13]), Abs(m[14]), Abs(m[15])} +} + +// Pretty prints the matrix +func (m Mat4) String() string { + buf := new(bytes.Buffer) + w := tabwriter.NewWriter(buf, 4, 4, 1, ' ', tabwriter.AlignRight) + for i := 0; i < 4; i++ { + for _, col := range m.Row(i) { + fmt.Fprintf(w, "%f\t", col) + } + + fmt.Fprintln(w, "") + } + w.Flush() + + return buf.String() +} diff --git a/vendor/github.com/go-gl/mathgl/mgl32/matrix.tmpl b/vendor/github.com/go-gl/mathgl/mgl32/matrix.tmpl new file mode 100644 index 0000000..54aa6b0 --- /dev/null +++ b/vendor/github.com/go-gl/mathgl/mgl32/matrix.tmpl @@ -0,0 +1,379 @@ +// Copyright 2014 The go-gl/mathgl Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// <<.Comment>> +// Edit <<.TemplateName>> and run "go generate" to make changes. + +package mgl32 + +import ( + "bytes" + "fmt" + "text/tabwriter" +) + +type Mat2 [2*2]float32 +type Mat2x3 [2*3]float32 +type Mat2x4 [2*4]float32 +type Mat3x2 [3*2]float32 +type Mat3 [3*3]float32 +type Mat3x4 [3*4]float32 +type Mat4x2 [4*2]float32 +type Mat4x3 [4*3]float32 +type Mat4 [4*4]float32 + +func (m Mat2) Mat3() Mat3 { + col0, col1 := m.Cols() + return Mat3FromCols( + col0.Vec3(0), + col1.Vec3(0), + Vec3{0, 0, 1}, + ) +} + +func (m Mat2) Mat4() Mat4 { + col0, col1 := m.Cols() + return Mat4FromCols( + col0.Vec4(0, 0), + col1.Vec4(0, 0), + Vec4{0, 0, 1, 0}, + Vec4{0, 0, 0, 1}, + ) +} + +func (m Mat3) Mat2() Mat2 { + col0, col1, _ := m.Cols() + return Mat2FromCols( + col0.Vec2(), + col1.Vec2(), + ) +} + +func (m Mat3) Mat4() Mat4 { + col0, col1, col2 := m.Cols() + return Mat4FromCols( + col0.Vec4(0), + col1.Vec4(0), + col2.Vec4(0), + Vec4{0, 0, 0, 1}, + ) +} + +func (m Mat4) Mat2() Mat2 { + col0, col1, _, _ := m.Cols() + return Mat2FromCols( + col0.Vec2(), + col1.Vec2(), + ) +} + +func (m Mat4) Mat3() Mat3 { + col0, col1, col2, _ := m.Cols() + return Mat3FromCols( + col0.Vec3(), + col1.Vec3(), + col2.Vec3(), + ) +} + + +<> +<><> +<<$type := typename $m $n>> + +// SetCol sets a Column within the Matrix, so it mutates the calling matrix. +func (m *<<$type>>) SetCol(col int, v <>) { + <><>m[col*<<$m>>+<<$i>>]<> = <> +} + +// SetRow sets a Row within the Matrix, so it mutates the calling matrix. +func (m *<<$type>>) SetRow(row int, v <>) { + <><>m[row+<>]<> = <> +} + +<> +// Diag is a basic operation on a square matrix that simply +// returns main diagonal (meaning all elements such that row==col). +func (m <<$type>>) Diag() <> { + return <>{<>m[<>],<>} +} +<> + +<> +// Ident<<$m>> returns the <<$m>>x<<$n>> identity matrix. +// The identity matrix is a square matrix with the value 1 on its +// diagonals. The characteristic property of the identity matrix is that +// any matrix multiplied by it is itself. (MI = M; IN = N) +func Ident<<$m>>() <<$type>> { + return <<$type>>{<><>1<>0<>,<>} +} +<> + +<> +// Diag<<$m>> creates a diagonal matrix from the entries of the input vector. +// That is, for each pointer for row==col, vector[row] is the entry. Otherwise it's 0. +// +// Another way to think about it is that the identity is this function where the every vector element is 1. +func Diag<<$m>>(v <>) <<$type>> { + var m <<$type>> + <><>m[<>]<> = <> + return m +} +<> + +// <<$type>>FromRows builds a new matrix from row vectors. +// The resulting matrix will still be in column major order, but this can be +// good for hand-building matrices. + +func <<$type>>FromRows(<><>row<<$i>><> <>) <<$type>> { + return <<$type>>{<>row<<$i.M>>[<<$i.N>>],<>} +} + +// <<$type>>FromCols builds a new matrix from column vectors. +func <<$type>>FromCols(<> <>) <<$type>> { + return <<$type>>{<>col<<$i.N>>[<<$i.M>>], <>} +} + +// Add performs an element-wise addition of two matrices, this is +// equivalent to iterating over every element of m1 and adding the corresponding value of m2. +func (m1 <<$type>>) Add(m2 <<$type>>) <<$type>> { + return <<$type>>{<< range $i := matiter $m $n>>m1[<<$i>>] + m2[<<$i>>], <>} +} + +// Sub performs an element-wise subtraction of two matrices, this is +// equivalent to iterating over every element of m1 and subtracting the corresponding value of m2. +func (m1 <<$type>>) Sub(m2 <<$type>>) <<$type>> { + return <<$type>>{<< range $i := matiter $m $n>>m1[<<$i>>] - m2[<<$i>>], <>} +} + +// Mul performs a scalar multiplcation of the matrix. This is equivalent to iterating +// over every element of the matrix and multiply it by c. +func (m1 <<$type>>) Mul(c float32) <<$type>> { + return <<$type>>{<< range $i := matiter $m $n>>m1[<<$i>>] * c, <>} +} + +<> +// Mul<<$n>><>x<<$o>><> performs a "matrix product" between this matrix +// and another of the given dimension. For any two matrices of dimensionality +// MxN and NxO, the result will be MxO. For instance, Mat4 multiplied using +// Mul4x2 will result in a Mat4x2. +func (m1 <<$type>>) Mul<<$n>><>x<<$o>><>(m2 <>) <> { + return <>{<> + <><>m1[<>]*m2[<>]<>,<> + } +} +<> + +// Transpose produces the transpose of this matrix. For any MxN matrix +// the transpose is an NxM matrix with the rows swapped with the columns. For instance +// the transpose of the Mat3x2 is a Mat2x3 like so: +// +// [[a b]] [[a c e]] +// [[c d]] = [[b d f]] +// [[e f]] +func (m1 <<$type>>) Transpose() <> { + return <>{<>m1[<>], <>} +} + +<> +// Det returns the determinant of a matrix. It is a measure of a square matrix's +// singularity and invertability, among other things. In this library, the +// determinant is hard coded based on pre-computed cofactor expansion, and uses +// no loops. Of course, the addition and multiplication must still be done. +func (m <<$type>>) Det() float32 { + <> + return m[0]*m[3] - m[1]*m[2] + <> + return m[0]*m[4]*m[8] + m[3]*m[7]*m[2] + m[6]*m[1]*m[5] - m[6]*m[4]*m[2] - m[3]*m[1]*m[8] - m[0]*m[7]*m[5] + <> + return m[0]*m[5]*m[10]*m[15] - m[0]*m[5]*m[11]*m[14] - m[0]*m[6]*m[9]*m[15] + m[0]*m[6]*m[11]*m[13] + m[0]*m[7]*m[9]*m[14] - m[0]*m[7]*m[10]*m[13] - m[1]*m[4]*m[10]*m[15] + m[1]*m[4]*m[11]*m[14] + m[1]*m[6]*m[8]*m[15] - m[1]*m[6]*m[11]*m[12] - m[1]*m[7]*m[8]*m[14] + m[1]*m[7]*m[10]*m[12] + m[2]*m[4]*m[9]*m[15] - m[2]*m[4]*m[11]*m[13] - m[2]*m[5]*m[8]*m[15] + m[2]*m[5]*m[11]*m[12] + m[2]*m[7]*m[8]*m[13] - m[2]*m[7]*m[9]*m[12] - m[3]*m[4]*m[9]*m[14] + m[3]*m[4]*m[10]*m[13] + m[3]*m[5]*m[8]*m[14] - m[3]*m[5]*m[10]*m[12] - m[3]*m[6]*m[8]*m[13] + m[3]*m[6]*m[9]*m[12] + <> +} +<> + +<> +// Inv computes the inverse of a square matrix. An inverse is a square matrix such that when multiplied by the +// original, yields the identity. +// +// M_inv * M = M * M_inv = I +// +// In this library, the math is precomputed, and uses no loops, though the multiplications, additions, determinant calculation, and scaling +// are still done. This can still be (relatively) expensive for a 4x4. +// +// This function checks the determinant to see if the matrix is invertible. +// If the determinant is 0.0, this function returns the zero matrix. However, due to floating point errors, it is +// entirely plausible to get a false positive or negative. +// In the future, an alternate function may be written which takes in a pre-computed determinant. +func (m <<$type>>) Inv() <<$type>> { + det := m.Det() + if FloatEqual(det, float32(0.0)) { + return <<$type>>{} + } + <> + retMat := Mat2{m[3], -m[1], -m[2], m[0]} + <> + retMat := Mat3{ + m[4]*m[8] - m[5]*m[7], + m[2]*m[7] - m[1]*m[8], + m[1]*m[5] - m[2]*m[4], + m[5]*m[6] - m[3]*m[8], + m[0]*m[8] - m[2]*m[6], + m[2]*m[3] - m[0]*m[5], + m[3]*m[7] - m[4]*m[6], + m[1]*m[6] - m[0]*m[7], + m[0]*m[4] - m[1]*m[3], + } + <> + retMat := Mat4{ + -m[7]*m[10]*m[13] + m[6]*m[11]*m[13] + m[7]*m[9]*m[14] - m[5]*m[11]*m[14] - m[6]*m[9]*m[15] + m[5]*m[10]*m[15], + m[3]*m[10]*m[13] - m[2]*m[11]*m[13] - m[3]*m[9]*m[14] + m[1]*m[11]*m[14] + m[2]*m[9]*m[15] - m[1]*m[10]*m[15], + -m[3]*m[6]*m[13] + m[2]*m[7]*m[13] + m[3]*m[5]*m[14] - m[1]*m[7]*m[14] - m[2]*m[5]*m[15] + m[1]*m[6]*m[15], + m[3]*m[6]*m[9] - m[2]*m[7]*m[9] - m[3]*m[5]*m[10] + m[1]*m[7]*m[10] + m[2]*m[5]*m[11] - m[1]*m[6]*m[11], + m[7]*m[10]*m[12] - m[6]*m[11]*m[12] - m[7]*m[8]*m[14] + m[4]*m[11]*m[14] + m[6]*m[8]*m[15] - m[4]*m[10]*m[15], + -m[3]*m[10]*m[12] + m[2]*m[11]*m[12] + m[3]*m[8]*m[14] - m[0]*m[11]*m[14] - m[2]*m[8]*m[15] + m[0]*m[10]*m[15], + m[3]*m[6]*m[12] - m[2]*m[7]*m[12] - m[3]*m[4]*m[14] + m[0]*m[7]*m[14] + m[2]*m[4]*m[15] - m[0]*m[6]*m[15], + -m[3]*m[6]*m[8] + m[2]*m[7]*m[8] + m[3]*m[4]*m[10] - m[0]*m[7]*m[10] - m[2]*m[4]*m[11] + m[0]*m[6]*m[11], + -m[7]*m[9]*m[12] + m[5]*m[11]*m[12] + m[7]*m[8]*m[13] - m[4]*m[11]*m[13] - m[5]*m[8]*m[15] + m[4]*m[9]*m[15], + m[3]*m[9]*m[12] - m[1]*m[11]*m[12] - m[3]*m[8]*m[13] + m[0]*m[11]*m[13] + m[1]*m[8]*m[15] - m[0]*m[9]*m[15], + -m[3]*m[5]*m[12] + m[1]*m[7]*m[12] + m[3]*m[4]*m[13] - m[0]*m[7]*m[13] - m[1]*m[4]*m[15] + m[0]*m[5]*m[15], + m[3]*m[5]*m[8] - m[1]*m[7]*m[8] - m[3]*m[4]*m[9] + m[0]*m[7]*m[9] + m[1]*m[4]*m[11] - m[0]*m[5]*m[11], + m[6]*m[9]*m[12] - m[5]*m[10]*m[12] - m[6]*m[8]*m[13] + m[4]*m[10]*m[13] + m[5]*m[8]*m[14] - m[4]*m[9]*m[14], + -m[2]*m[9]*m[12] + m[1]*m[10]*m[12] + m[2]*m[8]*m[13] - m[0]*m[10]*m[13] - m[1]*m[8]*m[14] + m[0]*m[9]*m[14], + m[2]*m[5]*m[12] - m[1]*m[6]*m[12] - m[2]*m[4]*m[13] + m[0]*m[6]*m[13] + m[1]*m[4]*m[14] - m[0]*m[5]*m[14], + -m[2]*m[5]*m[8] + m[1]*m[6]*m[8] + m[2]*m[4]*m[9] - m[0]*m[6]*m[9] - m[1]*m[4]*m[10] + m[0]*m[5]*m[10], + } + <> + return retMat.Mul(1 / det) +} +<> + +// ApproxEqual performs an element-wise approximate equality test between two matrices, +// as if FloatEqual had been used. +func (m1 <<$type>>) ApproxEqual(m2 <<$type>>) bool { + for i := range m1 { + if !FloatEqual(m1[i], m2[i]) { + return false + } + } + return true +} + +// ApproxEqualThreshold performs an element-wise approximate equality test between two matrices +// with a given epsilon threshold, as if FloatEqualThreshold had been used. +func (m1 <<$type>>) ApproxEqualThreshold(m2 <<$type>>, threshold float32) bool { + for i := range m1 { + if !FloatEqualThreshold(m1[i], m2[i], threshold) { + return false + } + } + return true +} + +// ApproxFuncEqual performs an element-wise approximate equality test between two matrices +// with a given equality functions, intended to be used with FloatEqualFunc; although and comparison +// function may be used in practice. +func (m1 <<$type>>) ApproxFuncEqual(m2 <<$type>>, eq func(float32, float32) bool) bool { + for i := range m1 { + if !eq(m1[i], m2[i]) { + return false + } + } + return true +} + +// NumRows returns the number of rows in this matrix +func (m <<$type>>) NumRows() int { + return <<$m>> +} + +// NumCols returns the number of columns in this matrix +func (m <<$type>>) NumCols() int { + return <<$n>> +} + +// At returns the matrix element at the given row and column. +// This is equivalent to mat[col * numRow + row] where numRow is constant +// (E.G. for a Mat3x2 it's equal to 3) +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// At(5,0) will work just like At(1,1). Or it may panic if it's out of bounds. +func (m <<$type>>) At(row, col int) float32 { + return m[col*<<$m>>+row] +} + +// Set sets the corresponding matrix element at the given row and column. +// This has a pointer receiver because it mutates the matrix. +// +// This method is garbage-in garbage-out. For instance, on a Mat4 asking for +// Set(5,0,val) will work just like Set(1,1,val). Or it may panic if it's out of bounds. +func (m *<<$type>>) Set(row, col int, value float32) { + m[col*<<$m>>+row] = value +} + +// Index returns the index of the given row and column, to be used with direct +// access. E.G. Index(0,0) = 0. +// +// This is a garbage-in garbage-out method. For instance, on a Mat4 asking for the index of +// (5,0) will work the same as asking for (1,1). Or it may give you a value that will cause +// a panic if you try to access the array with it if it's truly out of bounds. +func (m <<$type>>) Index(row, col int) int { + return col*<<$m>> + row +} + +// Row returns a vector representing the corresponding row (starting at row 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecM for a MxN matrix. +func (m <<$type>>) Row(row int) <> { + return <>{<>m[row+<>],<>} +} + +// Rows decomposes a matrix into its corresponding row vectors. +// This is equivalent to calling mat.Row for each row. +func (m <<$type>>) Rows() (<> <>) { + return <> +} + +// Col returns a vector representing the corresponding column (starting at col 0). +// This package makes no distinction between row and column vectors, so it +// will be a normal VecN for a MxN matrix. +func (m <<$type>>) Col(col int) <> { + return <>{<>m[col*<<$m>>+<<$i>>],<>} +} + +// Cols decomposes a matrix into its corresponding column vectors. +// This is equivalent to calling mat.Col for each column. +func (m <<$type>>) Cols() (<> <>) { + return <> +} + +<> +// Trace is a basic operation on a square matrix that simply +// sums up all elements on the main diagonal (meaning all elements such that row==col). +func (m <<$type>>) Trace() float32 { + return <><> m[<>]<> +} +<> + +// Abs returns the element-wise absolute value of this matrix +func (m <<$type>>) Abs() <<$type>> { + return <<$type>>{<>} +} + +// Pretty prints the matrix +func (m <<$type>>) String() string { + buf := new(bytes.Buffer) + w := tabwriter.NewWriter(buf, 4, 4, 1, ' ', tabwriter.AlignRight) + for i := 0; i < <<$m>>; i++ { + for _, col := range m.Row(i) { + fmt.Fprintf(w, "%f\t", col) + } + + fmt.Fprintln(w, "") + } + w.Flush() + + return buf.String() +} + +<><> <> diff --git a/vendor/github.com/go-gl/mathgl/mgl32/mempool.go b/vendor/github.com/go-gl/mathgl/mgl32/mempool.go new file mode 100644 index 0000000..9c27151 --- /dev/null +++ b/vendor/github.com/go-gl/mathgl/mgl32/mempool.go @@ -0,0 +1,121 @@ +// Copyright 2014 The go-gl Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package mgl32 + +import ( + "sync" +) + +var ( + slicePools []*sync.Pool + listLock sync.RWMutex +) + +var shouldPool = true + +func DisableMemoryPooling() { + shouldPool = false +} + +// Returns the given memory pool. If the pool doesn't exist, it will +// create all pools up to element i. The number "i" corresponds to "p" +// in most other comments. That is, it's Ceil(log_2(whatever)). So i=0 +// means you'll get the pool for slices of size 1, i=1 for size 2, i=2 for size 4, +// and so on. +// +// This is concurrency safe and uses an RWMutex to protect the list expansion. +func getPool(i int) *sync.Pool { + listLock.RLock() + if i >= len(slicePools) { + + // Promote to a write lock because we now + // need to mutate the pool + listLock.RUnlock() + listLock.Lock() + defer listLock.Unlock() + + for n := i - len(slicePools); n >= 0; n-- { + newFunc := genPoolNew(1 << uint(len(slicePools))) + slicePools = append(slicePools, &sync.Pool{New: newFunc}) + } + } else { + defer listLock.RUnlock() + } + + return slicePools[i] +} + +func genPoolNew(i int) func() interface{} { + return func() interface{} { + return make([]float32, 0, i) + } +} + +// Grabs a slice from the memory pool, such that its cap +// is 2^p where p is Ceil(log_2(size)). It will be downsliced +// such that the len is size. +func grabFromPool(size int) []float32 { + pool, exact := binLog(size) + + // Tried to grab something of size + // zero or less + if pool == -1 { + return nil + } + + // If the log is not exact, we + // need to "overallocate" so we have + // log+1 + if !exact { + pool++ + } + + slice := getPool(pool).Get().([]float32) + slice = slice[:size] + return slice +} + +// Returns a slice to the appropriate pool. If the slice does not have a cap that's precisely +// a power of 2, this will panic. +func returnToPool(slice []float32) { + if cap(slice) == 0 { + return + } + + pool, exact := binLog(cap(slice)) + + if !exact { + panic("attempt to pool slice with non-exact cap. If you're a user, please file an issue with github.com/go-gl/mathgl about this bug. This should never happen.") + } + + getPool(pool).Put(slice) +} + +// This returns the integer base 2 log of the value +// and whether the log is exact or rounded down. +// +// This is only for positive integers. +// +// There are faster ways to do this, I'm open to suggestions. Most rely on knowing system endianness +// which Go makes hard to do. I'm hesistant to use float conversions and the math package because of off-by-one errors. +func binLog(val int) (int, bool) { + if val <= 0 { + return -1, false + } + + exact := true + l := 0 + for ; val > 1; val = val >> 1 { + // If the current lsb is 1 and the number + // is not equal to 1, this is not an exact + // log, but rather a rounding of it + if val&1 != 0 { + exact = false + } + l++ + } + + return l, exact +} diff --git a/vendor/github.com/go-gl/mathgl/mgl32/project.go b/vendor/github.com/go-gl/mathgl/mgl32/project.go new file mode 100644 index 0000000..07c074e --- /dev/null +++ b/vendor/github.com/go-gl/mathgl/mgl32/project.go @@ -0,0 +1,109 @@ +// Copyright 2014 The go-gl Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package mgl32 + +import ( + "errors" + "math" +) + +// Ortho generates an Ortho Matrix. +func Ortho(left, right, bottom, top, near, far float32) Mat4 { + rml, tmb, fmn := (right - left), (top - bottom), (far - near) + + return Mat4{float32(2. / rml), 0, 0, 0, 0, float32(2. / tmb), 0, 0, 0, 0, float32(-2. / fmn), 0, float32(-(right + left) / rml), float32(-(top + bottom) / tmb), float32(-(far + near) / fmn), 1} +} + +// Ortho2D is equivalent to Ortho with the near and far planes being -1 and 1, +// respectively. +func Ortho2D(left, right, bottom, top float32) Mat4 { + return Ortho(left, right, bottom, top, -1, 1) +} + +// Perspective generates a Perspective Matrix. +func Perspective(fovy, aspect, near, far float32) Mat4 { + // fovy = (fovy * math.Pi) / 180.0 // convert from degrees to radians + nmf, f := near-far, float32(1./math.Tan(float64(fovy)/2.0)) + + return Mat4{float32(f / aspect), 0, 0, 0, 0, float32(f), 0, 0, 0, 0, float32((near + far) / nmf), -1, 0, 0, float32((2. * far * near) / nmf), 0} +} + +// Frustum generates a Frustum Matrix. +func Frustum(left, right, bottom, top, near, far float32) Mat4 { + rml, tmb, fmn := (right - left), (top - bottom), (far - near) + A, B, C, D := (right+left)/rml, (top+bottom)/tmb, -(far+near)/fmn, -(2*far*near)/fmn + + return Mat4{float32((2. * near) / rml), 0, 0, 0, 0, float32((2. * near) / tmb), 0, 0, float32(A), float32(B), float32(C), -1, 0, 0, float32(D), 0} +} + +// LookAt generates a transform matrix from world space to the given eye space. +func LookAt(eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ float32) Mat4 { + return LookAtV(Vec3{eyeX, eyeY, eyeZ}, Vec3{centerX, centerY, centerZ}, Vec3{upX, upY, upZ}) +} + +// LookAtV generates a transform matrix from world space into the specific eye +// space. +func LookAtV(eye, center, up Vec3) Mat4 { + f := center.Sub(eye).Normalize() + s := f.Cross(up).Normalize() + u := s.Cross(f) + + M := Mat4{ + s[0], u[0], -f[0], 0, + s[1], u[1], -f[1], 0, + s[2], u[2], -f[2], 0, + 0, 0, 0, 1, + } + + return M.Mul4(Translate3D(float32(-eye[0]), float32(-eye[1]), float32(-eye[2]))) +} + +// Project transforms a set of coordinates from object space (in obj) to window +// coordinates (with depth). +// +// Window coordinates are continuous, not discrete (well, as continuous as an +// IEEE Floating Point can be), so you won't get exact pixel locations without +// rounding or similar +func Project(obj Vec3, modelview, projection Mat4, initialX, initialY, width, height int) (win Vec3) { + obj4 := obj.Vec4(1) + + vpp := projection.Mul4(modelview).Mul4x1(obj4) + vpp = vpp.Mul(1 / vpp.W()) + win[0] = float32(initialX) + (float32(width)*(vpp[0]+1))/2 + win[1] = float32(initialY) + (float32(height)*(vpp[1]+1))/2 + win[2] = (vpp[2] + 1) / 2 + + return win +} + +// UnProject transforms a set of window coordinates to object space. If your MVP +// (projection.Mul(modelview) matrix is not invertible, this will return an +// error. +// +// Note that the projection may not be perfect if you use strict pixel locations +// rather than the exact values given by Projectf. (It's still unlikely to be +// perfect due to precision errors, but it will be closer) +func UnProject(win Vec3, modelview, projection Mat4, initialX, initialY, width, height int) (obj Vec3, err error) { + inv := projection.Mul4(modelview).Inv() + var blank Mat4 + if inv == blank { + return Vec3{}, errors.New("Could not find matrix inverse (projection times modelview is probably non-singular)") + } + + obj4 := inv.Mul4x1(Vec4{ + (2 * (win[0] - float32(initialX)) / float32(width)) - 1, + (2 * (win[1] - float32(initialY)) / float32(height)) - 1, + 2*win[2] - 1, + 1.0, + }) + obj = obj4.Vec3() + + //if obj4[3] > MinValue {} + obj[0] /= obj4[3] + obj[1] /= obj4[3] + obj[2] /= obj4[3] + + return obj, nil +} diff --git a/vendor/github.com/go-gl/mathgl/mgl32/quat.go b/vendor/github.com/go-gl/mathgl/mgl32/quat.go new file mode 100644 index 0000000..9825b32 --- /dev/null +++ b/vendor/github.com/go-gl/mathgl/mgl32/quat.go @@ -0,0 +1,469 @@ +// Copyright 2014 The go-gl Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package mgl32 + +import ( + "math" +) + +// RotationOrder is the order in which rotations will be transformed for the +// purposes of AnglesToQuat. +type RotationOrder int + +// The RotationOrder constants represent a series of rotations along the given +// axes for the use of AnglesToQuat. +const ( + XYX RotationOrder = iota + XYZ + XZX + XZY + YXY + YXZ + YZY + YZX + ZYZ + ZYX + ZXZ + ZXY +) + +// Quat represents a Quaternion, which is an extension of the imaginary numbers; +// there's all sorts of interesting theory behind it. In 3D graphics we mostly +// use it as a cheap way of representing rotation since quaternions are cheaper +// to multiply by, and easier to interpolate than matrices. +// +// A Quaternion has two parts: W, the so-called scalar component, and "V", the +// vector component. The vector component is considered to be the part in 3D +// space, while W (loosely interpreted) is its 4D coordinate. +type Quat struct { + W float32 + V Vec3 +} + +// QuatIdent returns the quaternion identity: W=1; V=(0,0,0). +// +// As with all identities, multiplying any quaternion by this will yield the same +// quaternion you started with. +func QuatIdent() Quat { + return Quat{1., Vec3{0, 0, 0}} +} + +// QuatRotate creates an angle from an axis and an angle relative to that axis. +// +// This is cheaper than HomogRotate3D. +func QuatRotate(angle float32, axis Vec3) Quat { + // angle = (float32(math.Pi) * angle) / 180.0 + + sn, cs := math.Sincos(float64(angle / 2)) + s, c := float32(sn), float32(cs) + + return Quat{c, axis.Mul(s)} +} + +// X is a convenient alias for q.V[0] +func (q Quat) X() float32 { + return q.V[0] +} + +// Y is a convenient alias for q.V[1] +func (q Quat) Y() float32 { + return q.V[1] +} + +// Z is a convenient alias for q.V[2] +func (q Quat) Z() float32 { + return q.V[2] +} + +// Add adds two quaternions. It's no more complicated than +// adding their W and V components. +func (q1 Quat) Add(q2 Quat) Quat { + return Quat{q1.W + q2.W, q1.V.Add(q2.V)} +} + +// Sub subtracts two quaternions. It's no more complicated than +// subtracting their W and V components. +func (q1 Quat) Sub(q2 Quat) Quat { + return Quat{q1.W - q2.W, q1.V.Sub(q2.V)} +} + +// Mul multiplies two quaternions. This can be seen as a rotation. Note that +// Multiplication is NOT commutative, meaning q1.Mul(q2) does not necessarily +// equal q2.Mul(q1). +func (q1 Quat) Mul(q2 Quat) Quat { + return Quat{q1.W*q2.W - q1.V.Dot(q2.V), q1.V.Cross(q2.V).Add(q2.V.Mul(q1.W)).Add(q1.V.Mul(q2.W))} +} + +// Scale every element of the quaternion by some constant factor. +func (q1 Quat) Scale(c float32) Quat { + return Quat{q1.W * c, Vec3{q1.V[0] * c, q1.V[1] * c, q1.V[2] * c}} +} + +// Conjugate returns the conjugate of a quaternion. Equivalent to +// Quat{q1.W, q1.V.Mul(-1)}. +func (q1 Quat) Conjugate() Quat { + return Quat{q1.W, q1.V.Mul(-1)} +} + +// Len gives the Length of the quaternion, also known as its Norm. This is the +// same thing as the Len of a Vec4. +func (q1 Quat) Len() float32 { + return float32(math.Sqrt(float64(q1.W*q1.W + q1.V[0]*q1.V[0] + q1.V[1]*q1.V[1] + q1.V[2]*q1.V[2]))) +} + +// Norm is an alias for Len() since both are very common terms. +func (q1 Quat) Norm() float32 { + return q1.Len() +} + +// Normalize the quaternion, returning its versor (unit quaternion). +// +// This is the same as normalizing it as a Vec4. +func (q1 Quat) Normalize() Quat { + length := q1.Len() + + if FloatEqual(1, length) { + return q1 + } + if length == 0 { + return QuatIdent() + } + if length == InfPos { + length = MaxValue + } + + return Quat{q1.W * 1 / length, q1.V.Mul(1 / length)} +} + +// Inverse of a quaternion. The inverse is equivalent +// to the conjugate divided by the square of the length. +// +// This method computes the square norm by directly adding the sum +// of the squares of all terms instead of actually squaring q1.Len(), +// both for performance and precision. +func (q1 Quat) Inverse() Quat { + return q1.Conjugate().Scale(1 / q1.Dot(q1)) +} + +// Rotate a vector by the rotation this quaternion represents. +// This will result in a 3D vector. Strictly speaking, this is +// equivalent to q1.v.q* where the "."" is quaternion multiplication and v is interpreted +// as a quaternion with W 0 and V v. In code: +// q1.Mul(Quat{0,v}).Mul(q1.Conjugate()), and +// then retrieving the imaginary (vector) part. +// +// In practice, we hand-compute this in the general case and simplify +// to save a few operations. +func (q1 Quat) Rotate(v Vec3) Vec3 { + cross := q1.V.Cross(v) + // v + 2q_w * (q_v x v) + 2q_v x (q_v x v) + return v.Add(cross.Mul(2 * q1.W)).Add(q1.V.Mul(2).Cross(cross)) +} + +// Mat4 returns the homogeneous 3D rotation matrix corresponding to the +// quaternion. +func (q1 Quat) Mat4() Mat4 { + w, x, y, z := q1.W, q1.V[0], q1.V[1], q1.V[2] + return Mat4{ + 1 - 2*y*y - 2*z*z, 2*x*y + 2*w*z, 2*x*z - 2*w*y, 0, + 2*x*y - 2*w*z, 1 - 2*x*x - 2*z*z, 2*y*z + 2*w*x, 0, + 2*x*z + 2*w*y, 2*y*z - 2*w*x, 1 - 2*x*x - 2*y*y, 0, + 0, 0, 0, 1, + } +} + +// Dot product between two quaternions, equivalent to if this was a Vec4. +func (q1 Quat) Dot(q2 Quat) float32 { + return q1.W*q2.W + q1.V[0]*q2.V[0] + q1.V[1]*q2.V[1] + q1.V[2]*q2.V[2] +} + +// ApproxEqual returns whether the quaternions are approximately equal, as if +// FloatEqual was called on each matching element +func (q1 Quat) ApproxEqual(q2 Quat) bool { + return FloatEqual(q1.W, q2.W) && q1.V.ApproxEqual(q2.V) +} + +// ApproxEqualThreshold returns whether the quaternions are approximately equal with a given tolerence, as if +// FloatEqualThreshold was called on each matching element with the given epsilon +func (q1 Quat) ApproxEqualThreshold(q2 Quat, epsilon float32) bool { + return FloatEqualThreshold(q1.W, q2.W, epsilon) && q1.V.ApproxEqualThreshold(q2.V, epsilon) +} + +// ApproxEqualFunc returns whether the quaternions are approximately equal using the given comparison function, as if +// the function had been called on each individual element +func (q1 Quat) ApproxEqualFunc(q2 Quat, f func(float32, float32) bool) bool { + return f(q1.W, q2.W) && q1.V.ApproxFuncEqual(q2.V, f) +} + +// OrientationEqual returns whether the quaternions represents the same orientation +// +// Different values can represent the same orientation (q == -q) because quaternions avoid singularities +// and discontinuities involved with rotation in 3 dimensions by adding extra dimensions +func (q1 Quat) OrientationEqual(q2 Quat) bool { + return q1.OrientationEqualThreshold(q2, Epsilon) +} + +// OrientationEqualThreshold returns whether the quaternions represents the same orientation with a given tolerence +func (q1 Quat) OrientationEqualThreshold(q2 Quat, epsilon float32) bool { + return Abs(q1.Normalize().Dot(q2.Normalize())) > 1-epsilon +} + +// QuatSlerp is *S*pherical *L*inear Int*erp*olation, a method of interpolating +// between two quaternions. This always takes the straightest and shortest path on the sphere between +// the two quaternions, and maintains constant velocity. +// +// However, it's expensive and QuatSlerp(q1,q2) is not the same as QuatSlerp(q2,q1) +func QuatSlerp(q1, q2 Quat, amount float32) Quat { + q1, q2 = q1.Normalize(), q2.Normalize() + dot := q1.Dot(q2) + + // Make sure we take the shortest path in case dot product is negative. + if dot < 0.0 { + q2 = q2.Scale(-1) + dot = -dot + } + + // If the inputs are too close for comfort, linearly interpolate and normalize the result. + if dot > 0.9995 { + return QuatNlerp(q1, q2, amount) + } + + // This is here for precision errors, I'm perfectly aware that *technically* the dot is bound [-1,1], but since Acos will freak out if it's not (even if it's just a liiiiitle bit over due to normal error) we need to clamp it + dot = Clamp(dot, -1, 1) + + theta := float32(math.Acos(float64(dot))) * amount + sn, cs := math.Sincos(float64(theta)) + s, c := float32(sn), float32(cs) + rel := q2.Sub(q1.Scale(dot)).Normalize() + + return q1.Scale(c).Add(rel.Scale(s)) +} + +// QuatLerp is a *L*inear Int*erp*olation between two Quaternions, cheap and simple. +// +// Not excessively useful, but uses can be found. +func QuatLerp(q1, q2 Quat, amount float32) Quat { + return q1.Add(q2.Sub(q1).Scale(amount)) +} + +// QuatNlerp is a *Normalized* *L*inear Int*erp*olation between two Quaternions. Cheaper than Slerp +// and usually just as good. This is literally Lerp with Normalize() called on it. +// +// Unlike Slerp, constant velocity isn't maintained, but it's much faster and +// Nlerp(q1,q2) and Nlerp(q2,q1) return the same path. You should probably +// use this more often unless you're suffering from choppiness due to the +// non-constant velocity problem. +func QuatNlerp(q1, q2 Quat, amount float32) Quat { + return QuatLerp(q1, q2, amount).Normalize() +} + +// AnglesToQuat performs a rotation in the specified order. If the order is not +// a valid RotationOrder, this function will panic +// +// The rotation "order" is more of an axis descriptor. For instance XZX would +// tell the function to interpret angle1 as a rotation about the X axis, angle2 about +// the Z axis, and angle3 about the X axis again. +// +// Based off the code for the Matlab function "angle2quat", though this implementation +// only supports 3 single angles as opposed to multiple angles. +func AnglesToQuat(angle1, angle2, angle3 float32, order RotationOrder) Quat { + var s [3]float64 + var c [3]float64 + + s[0], c[0] = math.Sincos(float64(angle1 / 2)) + s[1], c[1] = math.Sincos(float64(angle2 / 2)) + s[2], c[2] = math.Sincos(float64(angle3 / 2)) + + ret := Quat{} + switch order { + case ZYX: + ret.W = float32(c[0]*c[1]*c[2] + s[0]*s[1]*s[2]) + ret.V = Vec3{float32(c[0]*c[1]*s[2] - s[0]*s[1]*c[2]), + float32(c[0]*s[1]*c[2] + s[0]*c[1]*s[2]), + float32(s[0]*c[1]*c[2] - c[0]*s[1]*s[2]), + } + case ZYZ: + ret.W = float32(c[0]*c[1]*c[2] - s[0]*c[1]*s[2]) + ret.V = Vec3{float32(c[0]*s[1]*s[2] - s[0]*s[1]*c[2]), + float32(c[0]*s[1]*c[2] + s[0]*s[1]*s[2]), + float32(s[0]*c[1]*c[2] + c[0]*c[1]*s[2]), + } + case ZXY: + ret.W = float32(c[0]*c[1]*c[2] - s[0]*s[1]*s[2]) + ret.V = Vec3{float32(c[0]*s[1]*c[2] - s[0]*c[1]*s[2]), + float32(c[0]*c[1]*s[2] + s[0]*s[1]*c[2]), + float32(c[0]*s[1]*s[2] + s[0]*c[1]*c[2]), + } + case ZXZ: + ret.W = float32(c[0]*c[1]*c[2] - s[0]*c[1]*s[2]) + ret.V = Vec3{float32(c[0]*s[1]*c[2] + s[0]*s[1]*s[2]), + float32(s[0]*s[1]*c[2] - c[0]*s[1]*s[2]), + float32(c[0]*c[1]*s[2] + s[0]*c[1]*c[2]), + } + case YXZ: + ret.W = float32(c[0]*c[1]*c[2] + s[0]*s[1]*s[2]) + ret.V = Vec3{float32(c[0]*s[1]*c[2] + s[0]*c[1]*s[2]), + float32(s[0]*c[1]*c[2] - c[0]*s[1]*s[2]), + float32(c[0]*c[1]*s[2] - s[0]*s[1]*c[2]), + } + case YXY: + ret.W = float32(c[0]*c[1]*c[2] - s[0]*c[1]*s[2]) + ret.V = Vec3{float32(c[0]*s[1]*c[2] + s[0]*s[1]*s[2]), + float32(s[0]*c[1]*c[2] + c[0]*c[1]*s[2]), + float32(c[0]*s[1]*s[2] - s[0]*s[1]*c[2]), + } + case YZX: + ret.W = float32(c[0]*c[1]*c[2] - s[0]*s[1]*s[2]) + ret.V = Vec3{float32(c[0]*c[1]*s[2] + s[0]*s[1]*c[2]), + float32(c[0]*s[1]*s[2] + s[0]*c[1]*c[2]), + float32(c[0]*s[1]*c[2] - s[0]*c[1]*s[2]), + } + case YZY: + ret.W = float32(c[0]*c[1]*c[2] - s[0]*c[1]*s[2]) + ret.V = Vec3{float32(s[0]*s[1]*c[2] - c[0]*s[1]*s[2]), + float32(c[0]*c[1]*s[2] + s[0]*c[1]*c[2]), + float32(c[0]*s[1]*c[2] + s[0]*s[1]*s[2]), + } + case XYZ: + ret.W = float32(c[0]*c[1]*c[2] - s[0]*s[1]*s[2]) + ret.V = Vec3{float32(c[0]*s[1]*s[2] + s[0]*c[1]*c[2]), + float32(c[0]*s[1]*c[2] - s[0]*c[1]*s[2]), + float32(c[0]*c[1]*s[2] + s[0]*s[1]*c[2]), + } + case XYX: + ret.W = float32(c[0]*c[1]*c[2] - s[0]*c[1]*s[2]) + ret.V = Vec3{float32(c[0]*c[1]*s[2] + s[0]*c[1]*c[2]), + float32(c[0]*s[1]*c[2] + s[0]*s[1]*s[2]), + float32(s[0]*s[1]*c[2] - c[0]*s[1]*s[2]), + } + case XZY: + ret.W = float32(c[0]*c[1]*c[2] + s[0]*s[1]*s[2]) + ret.V = Vec3{float32(s[0]*c[1]*c[2] - c[0]*s[1]*s[2]), + float32(c[0]*c[1]*s[2] - s[0]*s[1]*c[2]), + float32(c[0]*s[1]*c[2] + s[0]*c[1]*s[2]), + } + case XZX: + ret.W = float32(c[0]*c[1]*c[2] - s[0]*c[1]*s[2]) + ret.V = Vec3{float32(c[0]*c[1]*s[2] + s[0]*c[1]*c[2]), + float32(c[0]*s[1]*s[2] - s[0]*s[1]*c[2]), + float32(c[0]*s[1]*c[2] + s[0]*s[1]*s[2]), + } + default: + panic("Unsupported rotation order") + } + return ret +} + +// Mat4ToQuat converts a pure rotation matrix into a quaternion +func Mat4ToQuat(m Mat4) Quat { + // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm + + if tr := m[0] + m[5] + m[10]; tr > 0 { + s := float32(0.5 / math.Sqrt(float64(tr+1.0))) + return Quat{ + 0.25 / s, + Vec3{ + (m[6] - m[9]) * s, + (m[8] - m[2]) * s, + (m[1] - m[4]) * s, + }, + } + } + + if (m[0] > m[5]) && (m[0] > m[10]) { + s := float32(2.0 * math.Sqrt(float64(1.0+m[0]-m[5]-m[10]))) + return Quat{ + (m[6] - m[9]) / s, + Vec3{ + 0.25 * s, + (m[4] + m[1]) / s, + (m[8] + m[2]) / s, + }, + } + } + + if m[5] > m[10] { + s := float32(2.0 * math.Sqrt(float64(1.0+m[5]-m[0]-m[10]))) + return Quat{ + (m[8] - m[2]) / s, + Vec3{ + (m[4] + m[1]) / s, + 0.25 * s, + (m[9] + m[6]) / s, + }, + } + + } + + s := float32(2.0 * math.Sqrt(float64(1.0+m[10]-m[0]-m[5]))) + return Quat{ + (m[1] - m[4]) / s, + Vec3{ + (m[8] + m[2]) / s, + (m[9] + m[6]) / s, + 0.25 * s, + }, + } +} + +// QuatLookAtV creates a rotation from an eye vector to a center vector +// +// It assumes the front of the rotated object at Z- and up at Y+ +func QuatLookAtV(eye, center, up Vec3) Quat { + // http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-17-quaternions/#I_need_an_equivalent_of_gluLookAt__How_do_I_orient_an_object_towards_a_point__ + // https://bitbucket.org/sinbad/ogre/src/d2ef494c4a2f5d6e2f0f17d3bfb9fd936d5423bb/OgreMain/src/OgreCamera.cpp?at=default#cl-161 + + direction := center.Sub(eye).Normalize() + + // Find the rotation between the front of the object (that we assume towards Z-, + // but this depends on your model) and the desired direction + rotDir := QuatBetweenVectors(Vec3{0, 0, -1}, direction) + + // Recompute up so that it's perpendicular to the direction + // You can skip that part if you really want to force up + //right := direction.Cross(up) + //up = right.Cross(direction) + + // Because of the 1rst rotation, the up is probably completely screwed up. + // Find the rotation between the "up" of the rotated object, and the desired up + upCur := rotDir.Rotate(Vec3{0, 1, 0}) + rotUp := QuatBetweenVectors(upCur, up) + + rotTarget := rotUp.Mul(rotDir) // remember, in reverse order. + return rotTarget.Inverse() // camera rotation should be inversed! +} + +// QuatBetweenVectors calculates the rotation between two vectors +func QuatBetweenVectors(start, dest Vec3) Quat { + // http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-17-quaternions/#I_need_an_equivalent_of_gluLookAt__How_do_I_orient_an_object_towards_a_point__ + // https://github.com/g-truc/glm/blob/0.9.5/glm/gtx/quaternion.inl#L225 + // https://bitbucket.org/sinbad/ogre/src/d2ef494c4a2f5d6e2f0f17d3bfb9fd936d5423bb/OgreMain/include/OgreVector3.h?at=default#cl-654 + + start = start.Normalize() + dest = dest.Normalize() + epsilon := float32(0.001) + + cosTheta := start.Dot(dest) + if cosTheta < -1.0+epsilon { + // special case when vectors in opposite directions: + // there is no "ideal" rotation axis + // So guess one; any will do as long as it's perpendicular to start + axis := Vec3{1, 0, 0}.Cross(start) + if axis.Dot(axis) < epsilon { + // bad luck, they were parallel, try again! + axis = Vec3{0, 1, 0}.Cross(start) + } + + return QuatRotate(math.Pi, axis.Normalize()) + } + + axis := start.Cross(dest) + s := float32(math.Sqrt(float64(1.0+cosTheta) * 2.0)) + + return Quat{ + s * 0.5, + axis.Mul(1.0 / s), + } +} diff --git a/vendor/github.com/go-gl/mathgl/mgl32/shapes.go b/vendor/github.com/go-gl/mathgl/mgl32/shapes.go new file mode 100644 index 0000000..6e147c5 --- /dev/null +++ b/vendor/github.com/go-gl/mathgl/mgl32/shapes.go @@ -0,0 +1,321 @@ +// Copyright 2014 The go-gl Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package mgl32 + +import ( + "fmt" + "math" +) + +// Circle generates a circle centered at (0,0) with a given radius. +// The radii are assumed to be in GL's coordinate sizing. +// +// Technically this draws an ellipse with two axes that match with the X and Y axes, the reason it has a radiusX and radiusY is because GL's coordinate system +// is proportional to screen width and screen height. So if you have a non-square viewport, a single radius will appear +// to "squash" the circle in one direction (usually the Y direction), so the X and Y radius allow for a circle to be made. +// A good way to get the correct radii is with mathgl.ScreenToGLCoords(radius, radius, screenWidth, screenHeight) which will get you the correct +// proportional GL coords. +// +// The numSlices argument specifies how many triangles you want your circle divided into, setting this +// number to too low a value may cause problem (and too high will cause it to take a lot of memory and time to compute +// without much gain in resolution). +// +// This uses discrete triangles, not a triangle fan +func Circle(radiusX, radiusY float32, numSlices int) []Vec2 { + twoPi := float32(2.0 * math.Pi) + + circlePoints := make([]Vec2, 0, numSlices*3) + center := Vec2{0.0, 0.0} + previous := Vec2{radiusX, 0.0} + + for theta := twoPi / float32(numSlices); !FloatEqual(theta, twoPi); theta = Clamp(theta+twoPi/float32(numSlices), 0.0, twoPi) { + sin, cos := math.Sincos(float64(theta)) + curr := Vec2{float32(cos) * radiusX, float32(sin) * radiusY} + + circlePoints = append(circlePoints, center, previous, curr) + previous = curr + } + + // Now add the final point at theta=2pi + circlePoints = append(circlePoints, center, previous, Vec2{radiusX, 0.0}) + return circlePoints +} + +// Rect generates a 2-triangle rectangle for use with GL_TRIANGLES. The width and height should use GL's proportions (that is, where a width of 1.0 +// is equivalent to half of the width of the render target); however, the y-coordinates grow downwards, not upwards. That is, it +// assumes you want the origin of the rectangle with the top-left corner at (0.0,0.0). +// +// Keep in mind that GL's coordinate system is proportional, so width=height will not result in a square unless your viewport is square. +// If you want to maintain proportionality regardless of screen size, use the results of w,h := ScreenToGLCoordsf(absoluteWidth, absoluteHeight, screenWidth, screenHeight); +// w,h=w+1,h-1 in the call to this function. (The w+1,h-1 step maps the coordinates to start at 0.0 rather than -1.0) +func Rect(width, height float32) []Vec2 { + return []Vec2{ + {0.0, 0.0}, + {0.0, -height}, + {width, -height}, + + {0.0, 0.0}, + {width, -height}, + {width, 0.0}, + } +} + +// QuadraticBezierCurve2D interpolates the point t on the given bezier curve. +func QuadraticBezierCurve2D(t float32, cPoint1, cPoint2, cPoint3 Vec2) Vec2 { + if t < 0.0 || t > 1.0 { + panic("Can't interpolate on bezier curve with t out of range [0.0,1.0]") + } + + return cPoint1.Mul((1.0 - t) * (1.0 - t)).Add(cPoint2.Mul(2 * (1 - t) * t)).Add(cPoint3.Mul(t * t)) +} + +// QuadraticBezierCurve3D interpolates the point t on the given bezier curve. +func QuadraticBezierCurve3D(t float32, cPoint1, cPoint2, cPoint3 Vec3) Vec3 { + if t < 0.0 || t > 1.0 { + panic("Can't interpolate on bezier curve with t out of range [0.0,1.0]") + } + + return cPoint1.Mul((1.0 - t) * (1.0 - t)).Add(cPoint2.Mul(2 * (1 - t) * t)).Add(cPoint3.Mul(t * t)) +} + +// CubicBezierCurve2D interpolates the point t on the given bezier curve. +func CubicBezierCurve2D(t float32, cPoint1, cPoint2, cPoint3, cPoint4 Vec2) Vec2 { + if t < 0.0 || t > 1.0 { + panic("Can't interpolate on bezier curve with t out of range [0.0,1.0]") + } + + sum14 := cPoint1.Mul((1 - t) * (1 - t) * (1 - t)).Add(cPoint4.Mul(t * t * t)) + sum23 := cPoint2.Mul(3 * (1 - t) * (1 - t) * t).Add(cPoint3.Mul(3 * (1 - t) * t * t)) + return sum14.Add(sum23) +} + +// CubicBezierCurve3D interpolates the point t on the given bezier curve. +func CubicBezierCurve3D(t float32, cPoint1, cPoint2, cPoint3, cPoint4 Vec3) Vec3 { + if t < 0.0 || t > 1.0 { + panic("Can't interpolate on bezier curve with t out of range [0.0,1.0]") + } + + sum14 := cPoint1.Mul((1 - t) * (1 - t) * (1 - t)).Add(cPoint4.Mul(t * t * t)) + sum23 := cPoint2.Mul(3 * (1 - t) * (1 - t) * t).Add(cPoint3.Mul(3 * (1 - t) * t * t)) + return sum14.Add(sum23) +} + +// BezierCurve2D returns the point at point t along an n-control point Bezier curve +// +// t must be in the range 0.0 and 1.0 or this function will panic. Consider [0.0,1.0] to be similar to a percentage, +// 0.0 is first control point, and the point at 1.0 is the last control point. Any point in between is how far along the path you are between 0 and 1. +// +// This function is not sensitive to the coordinate system of the control points. It will correctly interpolate regardless of whether they're in screen coords, +// gl coords, or something else entirely +func BezierCurve2D(t float32, cPoints []Vec2) Vec2 { + if t < 0.0 || t > 1.0 { + panic("Input to bezier has t not in range [0,1]. If you think this is a precision error, use mathgl.Clamp[f|d] before calling this function") + } + + n := len(cPoints) - 1 + point := cPoints[0].Mul(float32(math.Pow(float64(1.0-t), float64(n)))) + + for i := 1; i <= n; i++ { + point = point.Add(cPoints[i].Mul(float32(float64(choose(n, i)) * math.Pow(float64(1-t), float64(n-i)) * math.Pow(float64(t), float64(i))))) // P += P_i * nCi * (1-t)^(n-i) * t^i + } + + return point +} + +// BezierCurve3D same as the 2D version, except the line is in 3D space +func BezierCurve3D(t float32, cPoints []Vec3) Vec3 { + if t < 0.0 || t > 1.0 { + panic("Input to bezier has t not in range [0,1]. If you think this is a precision error, use mathgl.Clamp[f|d] before calling this function") + } + + n := len(cPoints) - 1 + point := cPoints[0].Mul(float32(math.Pow(float64(1.0-t), float64(n)))) + + for i := 1; i <= n; i++ { + point = point.Add(cPoints[i].Mul(float32(float64(choose(n, i)) * math.Pow(float64(1-t), float64(n-i)) * math.Pow(float64(t), float64(i))))) // P += P_i * nCi * (1-t)^(n-i) * t^i + } + + return point +} + +// MakeBezierCurve2D generates a bezier curve with controlPoints cPoints. The +// numPoints argument determines how many "samples" it makes along the line. For +// instance, a call to this with numPoints 2 will have exactly two points: the +// start and end points For any points above 2 it will divide it into +// numPoints-1 chunks (which means it will generate numPoints-2 vertices other +// than the beginning and end). So for 3 points it will divide it in half, 4 +// points into thirds, and so on. +// +// This is likely to get rather expensive for anything over perhaps a cubic +// curve. +func MakeBezierCurve2D(numPoints int, cPoints []Vec2) (line []Vec2) { + line = make([]Vec2, numPoints) + if numPoints == 0 { + return + } else if numPoints == 1 { + line[0] = cPoints[0] + return + } else if numPoints == 2 { + line[0] = cPoints[0] + line[1] = cPoints[len(cPoints)-1] + return + } + + line[0] = cPoints[0] + for i := 1; i < numPoints-1; i++ { + line[i] = BezierCurve2D(Clamp(float32(i)/float32(numPoints-1), 0.0, 1.0), cPoints) + } + line[numPoints-1] = cPoints[len(cPoints)-1] + + return +} + +// MakeBezierCurve3D same as the 2D version, except with the line in 3D space. +func MakeBezierCurve3D(numPoints int, cPoints []Vec3) (line []Vec3) { + line = make([]Vec3, numPoints) + if numPoints == 0 { + return + } else if numPoints == 1 { + line[0] = cPoints[0] + return + } else if numPoints == 2 { + line[0] = cPoints[0] + line[1] = cPoints[len(cPoints)-1] + return + } + + line[0] = cPoints[0] + for i := 1; i < numPoints-1; i++ { + line[i] = BezierCurve3D(Clamp(float32(i)/float32(numPoints-1), 0.0, 1.0), cPoints) + } + line[numPoints-1] = cPoints[len(cPoints)-1] + + return +} + +// BezierSurface creates a 2-dimensional Bezier surface of arbitrary degree in +// 3D Space Like the curve functions, if u or v are not in the range [0.0,1.0] +// the function will panic, use Clamp[f|d] to ensure it is correct. +// +// The control point matrix must not be jagged, or this will end up panicking +// from an index out of bounds exception +func BezierSurface(u, v float32, cPoints [][]Vec3) Vec3 { + if u < 0.0 || u > 1.0 || v < 1.0 || v > 1.0 { + panic("u or v not in range [0.0,1.0] in BezierSurface") + } + + n := len(cPoints) - 1 + m := len(cPoints[0]) - 1 + + point := cPoints[0][0].Mul(float32(math.Pow(float64(1.0-u), float64(n)) * math.Pow(float64(1.0-v), float64(m)))) + + for i := 0; i <= n; i++ { + for j := 0; j <= m; j++ { + if i == 0 && j == 0 { + continue + } + + point = point.Add(cPoints[i][j].Mul(float32(float64(choose(n, i)) * math.Pow(float64(u), float64(i)) * math.Pow(float64(1.0-u), float64(n-i)) * float64(choose(m, j)) * math.Pow(float64(v), float64(j)) * math.Pow(float64(1.0-v), float64(m-j))))) + } + } + + return point +} + +// BezierSplineInterpolate2D does interpolation over a spline of several bezier +// curves. Each bezier curve must have a finite range, though the spline may be +// disjoint. The bezier curves are not required to be in any particular order. +// +// If t is out of the range of all given curves, this function will panic +func BezierSplineInterpolate2D(t float32, ranges [][2]float32, cPoints [][]Vec2) Vec2 { + if len(ranges) != len(cPoints) { + panic("Each bezier curve needs a range") + } + + for i, curveRange := range ranges { + if t >= curveRange[0] && t <= curveRange[1] { + return BezierCurve2D((t-curveRange[0])/(curveRange[1]-curveRange[0]), cPoints[i]) + } + } + + panic("t is out of the range of all bezier curves in this spline") +} + +// BezierSplineInterpolate3D does interpolation over a spline of several bezier +// curves. Each bezier curve must have a finite range, though the spline may be +// disjoint. The bezier curves are not required to be in any particular order. +// +// If t is out of the range of all given curves, this function will panic +func BezierSplineInterpolate3D(t float32, ranges [][2]float32, cPoints [][]Vec3) Vec3 { + if len(ranges) != len(cPoints) { + panic("Each bezier curve needs a range") + } + + for i, curveRange := range ranges { + if t >= curveRange[0] && t <= curveRange[1] { + return BezierCurve3D((t-curveRange[0])/(curveRange[1]-curveRange[0]), cPoints[i]) + } + } + + panic("t is out of the range of all bezier curves in this spline") +} + +// ReticulateSplines reticulates ALL the Splines. +// +// For the overly serious: the function is just for fun. It does nothing except prints a Maxis reference. Technically you could "reticulate splines" +// by joining a bunch of splines together, but that ruins the joke. +func ReticulateSplines(ranges [][][2]float32, cPoints [][][]Vec2, withLlamas bool) { + if !withLlamas { + fmt.Println("You can't reticulate splines without llamas, silly.") + } else { + fmt.Println("Actually, you can't even reticulate splines WITH llamas") + } +} + +// ScreenToGLCoords transforms from pixel coordinates to GL coordinates. +// +// This assumes that your pixel coordinate system considers its origin to be in the top left corner (GL's is in the bottom left). +// The coordinates x and y may be out of the range [0,screenWidth-1] and [0,screeneHeight-1]. +// +// GL's coordinate system maps [screenWidth-1,0] to [1.0,1.0] and [0,screenHeight-1] to [-1.0,-1.0]. If x and y are out of the range, they'll still +// be mapped correctly, just off the screen. (e.g. if y = 2*(screenHeight-1) you'll get -3.0 for yOut) +// +// This is similar to Unproject, except for 2D cases and much simpler (especially since an inverse may always be found) +func ScreenToGLCoords(x, y int, screenWidth, screenHeight int) (xOut, yOut float32) { + xOut = 2.0*float32(x)/float32(screenWidth-1) - 1.0 + yOut = -2.0*float32(y)/float32(screenHeight-1) + 1.0 + + return +} + +// GLToScreenCoords transforms from GL's proportional system to pixel coordinates. +// +// Assumes the pixel coordinate system has its origin in the top left corner. (GL's is in the bottom left) +// +// GL's coordinate system maps [screenWidth-1,0] to [1.0,1.0] and [0,screenHeight-1] to [-1.0,-1.0]. If x and y are out of the range, they'll still +// be mapped correctly, just off the screen. (e.g. if y=-3.0, you'll get 2*(screenHeight-1) for yOut) +// +// This is similar to Project, except for 2D cases and much simpler +func GLToScreenCoords(x, y float32, screenWidth, screenHeight int) (xOut, yOut int) { + xOut = int((x + 1.0) * float32(screenWidth-1) / 2.0) + yOut = int((1.0 - y) * float32(screenHeight-1) / 2.0) + + return +} + +// choose calculates the binomial coefficient C(n,k) aka nCk +func choose(n, k int) int { + if k == 0 { + return 1 + } else if n == 0 { + return 0 + } + result := float32(n - (k - 1)) + for i := 2; i <= k; i++ { + result *= float32(n-(k-i)) / float32(i) + } + + return int(result) +} diff --git a/vendor/github.com/go-gl/mathgl/mgl32/transform.go b/vendor/github.com/go-gl/mathgl/mgl32/transform.go new file mode 100644 index 0000000..a2759f4 --- /dev/null +++ b/vendor/github.com/go-gl/mathgl/mgl32/transform.go @@ -0,0 +1,234 @@ +// Copyright 2014 The go-gl Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package mgl32 + +import "math" + +// Rotate2D returns a rotation Matrix about a angle in 2-D space. Specifically about the origin. +// It is a 2x2 matrix, if you need a 3x3 for Homogeneous math (e.g. composition with a Translation matrix) +// see HomogRotate2D +func Rotate2D(angle float32) Mat2 { + //angle = (angle * math.Pi) / 180.0 + sn, cs := math.Sincos(float64(angle)) + sin, cos := float32(sn), float32(cs) + return Mat2{cos, sin, -sin, cos} +} + +// Rotate3DX returns a 3x3 (non-homogeneous) Matrix that rotates by angle about the X-axis +// +// Where c is cos(angle) and s is sin(angle) +// +// [1 0 0] +// [0 c -s] +// [0 s c ] +func Rotate3DX(angle float32) Mat3 { + //angle = (angle * math.Pi) / 180.0 + sn, cs := math.Sincos(float64(angle)) + sin, cos := float32(sn), float32(cs) + return Mat3{1, 0, 0, 0, cos, sin, 0, -sin, cos} +} + +// Rotate3DY returns a 3x3 (non-homogeneous) Matrix that rotates by angle about the Y-axis +// +// Where c is cos(angle) and s is sin(angle) +// +// [c 0 s] +// [0 1 0] +// [s 0 c ] +func Rotate3DY(angle float32) Mat3 { + //angle = (angle * math.Pi) / 180.0 + sn, cs := math.Sincos(float64(angle)) + sin, cos := float32(sn), float32(cs) + return Mat3{cos, 0, -sin, 0, 1, 0, sin, 0, cos} +} + +// Rotate3DZ returns a 3x3 (non-homogeneous) Matrix that rotates by angle about the Z-axis +// +// Where c is cos(angle) and s is sin(angle) +// +// [c -s 0] +// [s c 0] +// [0 0 1 ] +func Rotate3DZ(angle float32) Mat3 { + //angle = (angle * math.Pi) / 180.0 + sn, cs := math.Sincos(float64(angle)) + sin, cos := float32(sn), float32(cs) + return Mat3{cos, sin, 0, -sin, cos, 0, 0, 0, 1} +} + +// Translate2D returns a homogeneous (3x3 for 2D-space) Translation matrix that moves a point by Tx units in the x-direction and Ty units in the y-direction +// +// [[1, 0, Tx]] +// [[0, 1, Ty]] +// [[0, 0, 1 ]] +func Translate2D(Tx, Ty float32) Mat3 { + return Mat3{1, 0, 0, 0, 1, 0, float32(Tx), float32(Ty), 1} +} + +// Translate3D returns a homogeneous (4x4 for 3D-space) Translation matrix that moves a point by Tx units in the x-direction, Ty units in the y-direction, +// and Tz units in the z-direction +// +// [[1, 0, 0, Tx]] +// [[0, 1, 0, Ty]] +// [[0, 0, 1, Tz]] +// [[0, 0, 0, 1 ]] +func Translate3D(Tx, Ty, Tz float32) Mat4 { + return Mat4{1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, float32(Tx), float32(Ty), float32(Tz), 1} +} + +// HomogRotate2D is the same as Rotate2D, except homogeneous (3x3 with the extra row/col being all zeroes with a one in the bottom right) +func HomogRotate2D(angle float32) Mat3 { + //angle = (angle * math.Pi) / 180.0 + sn, cs := math.Sincos(float64(angle)) + sin, cos := float32(sn), float32(cs) + return Mat3{cos, sin, 0, -sin, cos, 0, 0, 0, 1} +} + +// HomogRotate3DX is the same as Rotate3DX, except homogeneous (4x4 with the extra row/col being all zeroes with a one in the bottom right) +func HomogRotate3DX(angle float32) Mat4 { + //angle = (angle * math.Pi) / 180.0 + sn, cs := math.Sincos(float64(angle)) + sin, cos := float32(sn), float32(cs) + + return Mat4{1, 0, 0, 0, 0, cos, sin, 0, 0, -sin, cos, 0, 0, 0, 0, 1} +} + +// HomogRotate3DY is the same as Rotate3DY, except homogeneous (4x4 with the extra row/col being all zeroes with a one in the bottom right) +func HomogRotate3DY(angle float32) Mat4 { + //angle = (angle * math.Pi) / 180.0 + sn, cs := math.Sincos(float64(angle)) + sin, cos := float32(sn), float32(cs) + return Mat4{cos, 0, -sin, 0, 0, 1, 0, 0, sin, 0, cos, 0, 0, 0, 0, 1} +} + +// HomogRotate3DZ is the same as Rotate3DZ, except homogeneous (4x4 with the extra row/col being all zeroes with a one in the bottom right) +func HomogRotate3DZ(angle float32) Mat4 { + //angle = (angle * math.Pi) / 180.0 + sn, cs := math.Sincos(float64(angle)) + sin, cos := float32(sn), float32(cs) + return Mat4{cos, sin, 0, 0, -sin, cos, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1} +} + +// Scale3D creates a homogeneous 3D scaling matrix +// [[ scaleX, 0 , 0 , 0 ]] +// [[ 0 , scaleY, 0 , 0 ]] +// [[ 0 , 0 , scaleZ, 0 ]] +// [[ 0 , 0 , 0 , 1 ]] +func Scale3D(scaleX, scaleY, scaleZ float32) Mat4 { + + return Mat4{float32(scaleX), 0, 0, 0, 0, float32(scaleY), 0, 0, 0, 0, float32(scaleZ), 0, 0, 0, 0, 1} +} + +// Scale2D creates a homogeneous 2D scaling matrix +// [[ scaleX, 0 , 0 ]] +// [[ 0 , scaleY, 0 ]] +// [[ 0 , 0 , 1 ]] +func Scale2D(scaleX, scaleY float32) Mat3 { + return Mat3{float32(scaleX), 0, 0, 0, float32(scaleY), 0, 0, 0, 1} +} + +// ShearX2D creates a homogeneous 2D shear matrix along the X-axis +func ShearX2D(shear float32) Mat3 { + return Mat3{1, 0, 0, float32(shear), 1, 0, 0, 0, 1} +} + +// ShearY2D creates a homogeneous 2D shear matrix along the Y-axis +func ShearY2D(shear float32) Mat3 { + return Mat3{1, float32(shear), 0, 0, 1, 0, 0, 0, 1} +} + +// ShearX3D creates a homogeneous 3D shear matrix along the X-axis +func ShearX3D(shearY, shearZ float32) Mat4 { + + return Mat4{1, float32(shearY), float32(shearZ), 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1} +} + +// ShearY3D creates a homogeneous 3D shear matrix along the Y-axis +func ShearY3D(shearX, shearZ float32) Mat4 { + return Mat4{1, 0, 0, 0, float32(shearX), 1, float32(shearZ), 0, 0, 0, 1, 0, 0, 0, 0, 1} +} + +// ShearZ3D creates a homogeneous 3D shear matrix along the Z-axis +func ShearZ3D(shearX, shearY float32) Mat4 { + return Mat4{1, 0, 0, 0, 0, 1, 0, 0, float32(shearX), float32(shearY), 1, 0, 0, 0, 0, 1} +} + +// HomogRotate3D creates a 3D rotation Matrix that rotates by (radian) angle about some arbitrary axis given by a normalized Vector. +// It produces a homogeneous matrix (4x4) +// +// Where c is cos(angle) and s is sin(angle), and x, y, and z are the first, second, and third elements of the axis vector (respectively): +// +// [[ x^2(1-c)+c, xy(1-c)-zs, xz(1-c)+ys, 0 ]] +// [[ xy(1-c)+zs, y^2(1-c)+c, yz(1-c)-xs, 0 ]] +// [[ xz(1-c)-ys, yz(1-c)+xs, z^2(1-c)+c, 0 ]] +// [[ 0 , 0 , 0 , 1 ]] +func HomogRotate3D(angle float32, axis Vec3) Mat4 { + x, y, z := axis[0], axis[1], axis[2] + sn, cs := math.Sincos(float64(angle)) + s, c := float32(sn), float32(cs) + k := 1 - c + + return Mat4{x*x*k + c, x*y*k + z*s, x*z*k - y*s, 0, x*y*k - z*s, y*y*k + c, y*z*k + x*s, 0, x*z*k + y*s, y*z*k - x*s, z*z*k + c, 0, 0, 0, 0, 1} +} + +// Extract3DScale extracts the 3d scaling from a homogeneous matrix +func Extract3DScale(m Mat4) (x, y, z float32) { + return float32(math.Sqrt(float64(m[0]*m[0] + m[1]*m[1] + m[2]*m[2]))), + float32(math.Sqrt(float64(m[4]*m[4] + m[5]*m[5] + m[6]*m[6]))), + float32(math.Sqrt(float64(m[8]*m[8] + m[9]*m[9] + m[10]*m[10]))) +} + +// ExtractMaxScale extracts the maximum scaling from a homogeneous matrix +func ExtractMaxScale(m Mat4) float32 { + scaleX := float64(m[0]*m[0] + m[1]*m[1] + m[2]*m[2]) + scaleY := float64(m[4]*m[4] + m[5]*m[5] + m[6]*m[6]) + scaleZ := float64(m[8]*m[8] + m[9]*m[9] + m[10]*m[10]) + + return float32(math.Sqrt(math.Max(scaleX, math.Max(scaleY, scaleZ)))) +} + +// Mat4Normal calculates the Normal of the Matrix (aka the inverse transpose) +func Mat4Normal(m Mat4) Mat3 { + n := m.Inv().Transpose() + return Mat3{n[0], n[1], n[2], n[4], n[5], n[6], n[8], n[9], n[10]} +} + +// TransformCoordinate multiplies a 3D vector by a transformation given by +// the homogeneous 4D matrix m, applying any translation. +// If this transformation is non-affine, it will project this +// vector onto the plane w=1 before returning the result. +// +// This is similar to saying you're transforming and projecting a point. +// +// This is effectively equivalent to the GLSL code +// +// vec4 r = (m * vec4(v,1.)); +// r = r/r.w; +// vec3 newV = r.xyz; +func TransformCoordinate(v Vec3, m Mat4) Vec3 { + t := v.Vec4(1) + t = m.Mul4x1(t) + t = t.Mul(1 / t[3]) + + return t.Vec3() +} + +// TransformNormal multiplies a 3D vector by a transformation given by +// the homogeneous 4D matrix m, NOT applying any translations. +// +// This is similar to saying you're applying a transformation +// to a direction or normal. Rotation still applies (as does scaling), +// but translating a direction or normal is meaningless. +// +// This is effectively equivalent to the GLSL code +// +// vec4 r = (m * vec4(v,0.)); +// vec3 newV = r.xyz +func TransformNormal(v Vec3, m Mat4) Vec3 { + t := v.Vec4(0) + t = m.Mul4x1(t) + + return t.Vec3() +} diff --git a/vendor/github.com/go-gl/mathgl/mgl32/util.go b/vendor/github.com/go-gl/mathgl/mgl32/util.go new file mode 100644 index 0000000..6b50e45 --- /dev/null +++ b/vendor/github.com/go-gl/mathgl/mgl32/util.go @@ -0,0 +1,144 @@ +// Copyright 2014 The go-gl Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:generate go run codegen.go -template vector.tmpl -output vector.go +//go:generate go run codegen.go -template matrix.tmpl -output matrix.go +//go:generate go run codegen.go -mgl64 + +package mgl32 + +import ( + "math" +) + +// Epsilon is some tiny value that determines how precisely equal we want our floats to be +// This is exported and left as a variable in case you want to change the default threshold for the +// purposes of certain methods (e.g. Unproject uses the default epsilon when determining +// if the determinant is "close enough" to zero to mean there's no inverse). +// +// This is, obviously, not mutex protected so be **absolutely sure** that no functions using Epsilon +// are being executed when you change this. +var Epsilon float32 = 1e-10 + +// Abs is a direct copy of the math package's Abs. This is here for the mgl32 +// package, to prevent rampant type conversions during equality tests. +func Abs(a float32) float32 { + if a < 0 { + return -a + } else if a == 0 { + return 0 + } + + return a +} + +// FloatEqual is a safe utility function to compare floats. +// It's Taken from http://floating-point-gui.de/errors/comparison/ +// +// It is slightly altered to not call Abs when not needed. +func FloatEqual(a, b float32) bool { + return FloatEqualThreshold(a, b, Epsilon) +} + +// FloatEqualFunc is a utility closure that will generate a function that +// always approximately compares floats like FloatEqualThreshold with a different +// threshold. +func FloatEqualFunc(epsilon float32) func(float32, float32) bool { + return func(a, b float32) bool { + return FloatEqualThreshold(a, b, epsilon) + } +} + +// Various useful constants. +var ( + MinNormal = float32(1.1754943508222875e-38) // 1 / 2**(127 - 1) + MinValue = float32(math.SmallestNonzeroFloat32) + MaxValue = float32(math.MaxFloat32) + + InfPos = float32(math.Inf(1)) + InfNeg = float32(math.Inf(-1)) + NaN = float32(math.NaN()) +) + +// FloatEqualThreshold is a utility function to compare floats. +// It's Taken from http://floating-point-gui.de/errors/comparison/ +// +// It is slightly altered to not call Abs when not needed. +// +// This differs from FloatEqual in that it lets you pass in your comparison threshold, so that you can adjust the comparison value to your specific needs +func FloatEqualThreshold(a, b, epsilon float32) bool { + if a == b { // Handles the case of inf or shortcuts the loop when no significant error has accumulated + return true + } + + diff := Abs(a - b) + if a*b == 0 || diff < MinNormal { // If a or b are 0 or both are extremely close to it + return diff < epsilon*epsilon + } + + // Else compare difference + return diff/(Abs(a)+Abs(b)) < epsilon +} + +// Clamp takes in a value and two thresholds. If the value is smaller than the low +// threshold, it returns the low threshold. If it's bigger than the high threshold +// it returns the high threshold. Otherwise it returns the value. +// +// Useful to prevent some functions from freaking out because a value was +// teeeeechnically out of range. +func Clamp(a, low, high float32) float32 { + if a < low { + return low + } else if a > high { + return high + } + + return a +} + +// ClampFunc generates a closure that returns its parameter +// clamped to the range [low,high]. +func ClampFunc(low, high float32) func(float32) float32 { + return func(a float32) float32 { + return Clamp(a, low, high) + } +} + +// IsClamped checks if a is clamped between low and high as if +// Clamp(a, low, high) had been called. +// +// In most cases it's probably better to just call Clamp +// without checking this since it's relatively cheap. +// +// The IsClamped functions use strict equality (meaning: not the FloatEqual +// function) there shouldn't be any major issues with this since clamp is often +// used to fix minor errors +func IsClamped(a, low, high float32) bool { + return a >= low && a <= high +} + +// SetMin sets a to b if a > b. +func SetMin(a, b *float32) { + if *b < *a { + *a = *b + } +} + +// SetMax sets a to b if a < b. +func SetMax(a, b *float32) { + if *a < *b { + *a = *b + } +} + +// Round shortens a float32 value to a specified precision (number of digits after the decimal point) +// with "round half up" tie-braking rule. Half-way values (23.5) are always rounded up (24). +func Round(v float32, precision int) float32 { + p := float64(precision) + t := float64(v) * math.Pow(10, p) + if t >= 0 { + return float32(math.Floor(t+0.5) / math.Pow(10, p)) + } + return float32(math.Ceil(t-0.5) / math.Pow(10, p)) +} diff --git a/vendor/github.com/go-gl/mathgl/mgl32/vecn.go b/vendor/github.com/go-gl/mathgl/mgl32/vecn.go new file mode 100644 index 0000000..26fb4e3 --- /dev/null +++ b/vendor/github.com/go-gl/mathgl/mgl32/vecn.go @@ -0,0 +1,371 @@ +// Copyright 2014 The go-gl Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package mgl32 + +import ( + "math" +) + +// VecN represents a vector of N elements backed by a slice. +// +// As with MatMxN, this is not for hardcore linear algebra with large dimensions. Use github.com/gonum/matrix +// or something like BLAS/LAPACK for that. This is for corner cases in 3D math where you require +// something a little bigger that 4D, but still relatively small. +// +// This VecN uses several sync.Pool objects as a memory pool. The rule is that for any sized vector, the backing slice +// has CAPACITY (not length) of 2^p where p is Ceil(log_2(N)) -- or in other words, rounding up the base-2 +// log of the size of the vector. E.G. a VecN of size 17 will have a backing slice of Cap 32. +type VecN struct { + vec []float32 +} + +// NewVecNFromData creates a new vector with a backing slice filled with the contents +// of initial. It is NOT backed by initial, but rather a slice with cap +// 2^p where p is Ceil(log_2(len(initial))), with the data from initial copied into +// it. +func NewVecNFromData(initial []float32) *VecN { + if initial == nil { + return &VecN{} + } + var internal []float32 + if shouldPool { + internal = grabFromPool(len(initial)) + } else { + internal = make([]float32, len(initial)) + } + copy(internal, initial) + return &VecN{vec: internal} +} + +// NewVecN creates a new vector with a backing slice of +// 2^p where p = Ceil(log_2(n)) +func NewVecN(n int) *VecN { + if shouldPool { + return &VecN{vec: grabFromPool(n)} + } else { + return &VecN{vec: make([]float32, n)} + } +} + +// Raw returns the raw slice backing the VecN +// +// This may be sent back to the memory pool at any time +// and you aren't advised to rely on this value +func (vn VecN) Raw() []float32 { + return vn.vec +} + +// Get the element at index i from the vector. This does not bounds check, and +// will panic if i is out of range. +func (vn VecN) Get(i int) float32 { + return vn.vec[i] +} + +// Set the element at index i to val. +func (vn *VecN) Set(i int, val float32) { + vn.vec[i] = val +} + +// Sends the allocated memory through the callback if it exists +func (vn *VecN) destroy() { + if vn == nil || vn.vec == nil { + return + } + + if shouldPool { + returnToPool(vn.vec) + } + vn.vec = nil +} + +// Resize the underlying slice to the desired amount, reallocating or retrieving +// from the pool if necessary. The values after a Resize cannot be expected to +// be related to the values before a Resize. +// +// If the caller is a nil pointer, this returns a value as if NewVecN(n) had +// been called, otherwise it simply returns the caller. +func (vn *VecN) Resize(n int) *VecN { + if vn == nil { + return NewVecN(n) + } + + if n <= cap(vn.vec) { + if vn.vec != nil { + vn.vec = vn.vec[:n] + } else { + vn.vec = []float32{} + } + return vn + } + + if shouldPool && vn.vec != nil { + returnToPool(vn.vec) + } + *vn = (*NewVecN(n)) + + return vn +} + +// SetBackingSlice sets the vector's backing slice to the given +// new one. +func (vn *VecN) SetBackingSlice(newSlice []float32) { + vn.vec = newSlice +} + +// Size returns the len of the vector's underlying slice. +// This is not titled Len because it conflicts the package's +// convention of calling the Norm the Len. +func (vn *VecN) Size() int { + return len(vn.vec) +} + +// Cap Returns the cap of the vector's underlying slice. +func (vn *VecN) Cap() int { + return cap(vn.vec) +} + +// Zero sets the vector's size to n and zeroes out the vector. +// If n is bigger than the vector's size, it will realloc. +func (vn *VecN) Zero(n int) { + vn.Resize(n) + for i := range vn.vec { + vn.vec[i] = 0 + } +} + +// Add adds vn and addend, storing the result in dst. +// If dst does not have sufficient size it will be resized +// Dst may be one of the other arguments. If dst is nil, it will be allocated. +// The value returned is dst, for easier method chaining +// +// If vn and addend are not the same size, this function will add min(vn.Size(), addend.Size()) +// elements. +func (vn *VecN) Add(dst *VecN, subtrahend *VecN) *VecN { + if vn == nil || subtrahend == nil { + return nil + } + size := intMin(len(vn.vec), len(subtrahend.vec)) + dst = dst.Resize(size) + + for i := 0; i < size; i++ { + dst.vec[i] = vn.vec[i] + subtrahend.vec[i] + } + + return dst +} + +// Sub subtracts addend from vn, storing the result in dst. +// If dst does not have sufficient size it will be resized +// Dst may be one of the other arguments. If dst is nil, it will be allocated. +// The value returned is dst, for easier method chaining +// +// If vn and addend are not the same size, this function will add min(vn.Size(), addend.Size()) +// elements. +func (vn *VecN) Sub(dst *VecN, addend *VecN) *VecN { + if vn == nil || addend == nil { + return nil + } + size := intMin(len(vn.vec), len(addend.vec)) + dst = dst.Resize(size) + + for i := 0; i < size; i++ { + dst.vec[i] = vn.vec[i] - addend.vec[i] + } + + return dst +} + +// Cross takes the binary cross product of vn and other, and stores it in dst. +// If either vn or other are not of size 3 this function will panic +// +// If dst is not of sufficient size, or is nil, a new slice is allocated. +// Dst is permitted to be one of the other arguments +func (vn *VecN) Cross(dst *VecN, other *VecN) *VecN { + if vn == nil || other == nil { + return nil + } + if len(vn.vec) != 3 || len(other.vec) != 3 { + panic("Cannot take binary cross product of non-3D elements (7D cross product not implemented)") + } + + dst = dst.Resize(3) + dst.vec[0], dst.vec[1], dst.vec[2] = vn.vec[1]*other.vec[2]-vn.vec[2]*other.vec[1], vn.vec[2]*other.vec[0]-vn.vec[0]*other.vec[2], vn.vec[0]*other.vec[1]-vn.vec[1]*other.vec[0] + + return dst +} + +func intMin(a, b int) int { + if a < b { + return a + } + + return b +} + +// Dot computes the dot product of two VecNs, if +// the two vectors are not of the same length -- this +// will return NaN. +func (vn *VecN) Dot(other *VecN) float32 { + if vn == nil || other == nil || len(vn.vec) != len(other.vec) { + return float32(math.NaN()) + } + + var result float32 = 0.0 + for i, el := range vn.vec { + result += el * other.vec[i] + } + + return result +} + +// Len computes the vector length (also called the Norm) of the +// vector. Equivalent to math.Sqrt(vn.Dot(vn)) with the appropriate +// type conversions. +// +// If vn is nil, this returns NaN +func (vn *VecN) Len() float32 { + if vn == nil { + return float32(math.NaN()) + } + if len(vn.vec) == 0 { + return 0 + } + + return float32(math.Sqrt(float64(vn.Dot(vn)))) +} + +// LenSqr returns the vector's square length. This is equivalent to the sum of the squares of all elements. +func (vn *VecN) LenSqr() float32 { + if vn == nil { + return float32(math.NaN()) + } + if len(vn.vec) == 0 { + return 0 + } + + return vn.Dot(vn) +} + +// Normalize the vector and stores the result in dst, which +// will be returned. Dst will be appropraitely resized to the +// size of vn. +// +// The destination can be vn itself and nothing will go wrong. +// +// This is equivalent to vn.Mul(dst, 1/vn.Len()) +func (vn *VecN) Normalize(dst *VecN) *VecN { + if vn == nil { + return nil + } + + return vn.Mul(dst, 1/vn.Len()) +} + +// Mul multiplies the vector by some scalar value and stores the result in dst, +// which will be returned. Dst will be appropriately resized to the size of vn. +// +// The destination can be vn itself and nothing will go wrong. +func (vn *VecN) Mul(dst *VecN, c float32) *VecN { + if vn == nil { + return nil + } + dst = dst.Resize(len(vn.vec)) + + for i, el := range vn.vec { + dst.vec[i] = el * c + } + + return dst +} + +// OuterProd performs the vector outer product between vn and v2. +// The outer product is like a "reverse" dot product. Where the dot product +// aligns both vectors with the "sized" part facing "inward" (Vec3*Vec3=Mat1x3*Mat3x1=Mat1x1=Scalar). +// The outer product multiplied them with it facing "outward" +// (Vec3*Vec3=Mat3x1*Mat1x3=Mat3x3). +// +// The matrix dst will be Reshaped to the correct size, if vn or v2 are nil, +// this returns nil. +func (vn *VecN) OuterProd(dst *MatMxN, v2 *VecN) *MatMxN { + if vn == nil || v2 == nil { + return nil + } + + dst = dst.Reshape(len(vn.vec), len(v2.vec)) + + for c, el1 := range v2.vec { + for r, el2 := range vn.vec { + dst.Set(r, c, el1*el2) + } + } + + return dst +} + +// ApproxEqual returns whether the two vectors are approximately equal (See +// FloatEqual). +func (vn *VecN) ApproxEqual(vn2 *VecN) bool { + if vn == nil || vn2 == nil || len(vn.vec) != len(vn2.vec) { + return false + } + + for i, el := range vn.vec { + if !FloatEqual(el, vn2.vec[i]) { + return false + } + } + + return true +} + +// ApproxEqualThreshold returns whether the two vectors are approximately equal +// to within the given threshold given by "epsilon" (See ApproxEqualThreshold). +func (vn *VecN) ApproxEqualThreshold(vn2 *VecN, epsilon float32) bool { + if vn == nil || vn2 == nil || len(vn.vec) != len(vn2.vec) { + return false + } + + for i, el := range vn.vec { + if !FloatEqualThreshold(el, vn2.vec[i], epsilon) { + return false + } + } + + return true +} + +// ApproxEqualFunc returns whether the two vectors are approximately equal, +// given a function which compares two scalar elements. +func (vn *VecN) ApproxEqualFunc(vn2 *VecN, comp func(float32, float32) bool) bool { + if vn == nil || vn2 == nil || len(vn.vec) != len(vn2.vec) { + return false + } + + for i, el := range vn.vec { + if !comp(el, vn2.vec[i]) { + return false + } + } + + return true +} + +// Vec2 constructs a 2-dimensional vector by discarding coordinates. +func (vn *VecN) Vec2() Vec2 { + raw := vn.Raw() + return Vec2{raw[0], raw[1]} +} + +// Vec3 constructs a 3-dimensional vector by discarding coordinates. +func (vn *VecN) Vec3() Vec3 { + raw := vn.Raw() + return Vec3{raw[0], raw[1], raw[2]} +} + +// Vec4 constructs a 4-dimensional vector by discarding coordinates. +func (vn *VecN) Vec4() Vec4 { + raw := vn.Raw() + return Vec4{raw[0], raw[1], raw[2], raw[3]} +} diff --git a/vendor/github.com/go-gl/mathgl/mgl32/vector.go b/vendor/github.com/go-gl/mathgl/mgl32/vector.go new file mode 100644 index 0000000..cda68d3 --- /dev/null +++ b/vendor/github.com/go-gl/mathgl/mgl32/vector.go @@ -0,0 +1,591 @@ +// Copyright 2014 The go-gl/mathgl Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// This file is generated by codegen.go; DO NOT EDIT +// Edit vector.tmpl and run "go generate" to make changes. + +package mgl32 + +import ( + "math" +) + +type Vec2 [2]float32 +type Vec3 [3]float32 +type Vec4 [4]float32 + +// Vec3 constructs a 3-dimensional vector by appending the given coordinates. +func (v Vec2) Vec3(z float32) Vec3 { + return Vec3{v[0], v[1], z} +} + +// Vec4 constructs a 4-dimensional vector by appending the given coordinates. +func (v Vec2) Vec4(z, w float32) Vec4 { + return Vec4{v[0], v[1], z, w} +} + +// Vec4 constructs a 4-dimensional vector by appending the given coordinates. +func (v Vec3) Vec4(w float32) Vec4 { + return Vec4{v[0], v[1], v[2], w} +} + +// Vec2 constructs a 2-dimensional vector by discarding coordinates. +func (v Vec3) Vec2() Vec2 { + return Vec2{v[0], v[1]} +} + +// Vec2 constructs a 2-dimensional vector by discarding coordinates. +func (v Vec4) Vec2() Vec2 { + return Vec2{v[0], v[1]} +} + +// Vec3 constructs a 3-dimensional vector by discarding coordinates. +func (v Vec4) Vec3() Vec3 { + return Vec3{v[0], v[1], v[2]} +} + +// Elem extracts the elements of the vector for direct value assignment. +func (v Vec2) Elem() (x, y float32) { + return v[0], v[1] +} + +// Elem extracts the elements of the vector for direct value assignment. +func (v Vec3) Elem() (x, y, z float32) { + return v[0], v[1], v[2] +} + +// Elem extracts the elements of the vector for direct value assignment. +func (v Vec4) Elem() (x, y, z, w float32) { + return v[0], v[1], v[2], v[3] +} + +// Cross is the vector cross product. This operation is only defined on 3D +// vectors. It is equivalent to Vec3{v1[1]*v2[2]-v1[2]*v2[1], +// v1[2]*v2[0]-v1[0]*v2[2], v1[0]*v2[1] - v1[1]*v2[0]}. Another interpretation +// is that it's the vector whose magnitude is |v1||v2|sin(theta) where theta is +// the angle between v1 and v2. +// +// The cross product is most often used for finding surface normals. The cross +// product of vectors will generate a vector that is perpendicular to the plane +// they form. +// +// Technically, a generalized cross product exists as an "(N-1)ary" operation +// (that is, the 4D cross product requires 3 4D vectors). But the binary 3D (and +// 7D) cross product is the most important. It can be considered the area of a +// parallelogram with sides v1 and v2. +// +// Like the dot product, the cross product is roughly a measure of +// directionality. Two normalized perpendicular vectors will return a vector +// with a magnitude of 1.0 or -1.0 and two parallel vectors will return a vector +// with magnitude 0.0. The cross product is "anticommutative" meaning +// v1.Cross(v2) = -v2.Cross(v1), this property can be useful to know when +// finding normals, as taking the wrong cross product can lead to the opposite +// normal of the one you want. +func (v1 Vec3) Cross(v2 Vec3) Vec3 { + return Vec3{v1[1]*v2[2] - v1[2]*v2[1], v1[2]*v2[0] - v1[0]*v2[2], v1[0]*v2[1] - v1[1]*v2[0]} +} + +// Quat reinterprets this vector as a quaternion, with the individual elements +// staying the same. +func (v Vec4) Quat() Quat { + return Quat{v[3], Vec3{v[0], v[1], v[2]}} +} + +// Add performs element-wise addition between two vectors. It is equivalent to iterating +// over every element of v1 and adding the corresponding element of v2 to it. +func (v1 Vec2) Add(v2 Vec2) Vec2 { + return Vec2{v1[0] + v2[0], v1[1] + v2[1]} +} + +// Sub performs element-wise subtraction between two vectors. It is equivalent to iterating +// over every element of v1 and subtracting the corresponding element of v2 from it. +func (v1 Vec2) Sub(v2 Vec2) Vec2 { + return Vec2{v1[0] - v2[0], v1[1] - v2[1]} +} + +// Mul performs a scalar multiplication between the vector and some constant value +// c. This is equivalent to iterating over every vector element and multiplying by c. +func (v1 Vec2) Mul(c float32) Vec2 { + return Vec2{v1[0] * c, v1[1] * c} +} + +// Dot returns the dot product of this vector with another. There are multiple ways +// to describe this value. One is the multiplication of their lengths and cos(theta) where +// theta is the angle between the vectors: v1.v2 = |v1||v2|cos(theta). +// +// The other (and what is actually done) is the sum of the element-wise multiplication of all +// elements. So for instance, two Vec3s would yield v1.x * v2.x + v1.y * v2.y + v1.z * v2.z. +// +// This means that the dot product of a vector and itself is the square of its Len (within +// the bounds of floating points error). +// +// The dot product is roughly a measure of how closely two vectors are to pointing in the same +// direction. If both vectors are normalized, the value will be -1 for opposite pointing, +// one for same pointing, and 0 for perpendicular vectors. +func (v1 Vec2) Dot(v2 Vec2) float32 { + return v1[0]*v2[0] + v1[1]*v2[1] +} + +// Len returns the vector's length. Note that this is NOT the dimension of +// the vector (len(v)), but the mathematical length. This is equivalent to the square +// root of the sum of the squares of all elements. E.G. for a Vec2 it's +// math.Hypot(v[0], v[1]). +func (v1 Vec2) Len() float32 { + + return float32(math.Hypot(float64(v1[0]), float64(v1[1]))) + +} + +// LenSqr returns the vector's square length. This is equivalent to the sum of the squares of all elements. +func (v1 Vec2) LenSqr() float32 { + return v1[0]*v1[0] + v1[1]*v1[1] +} + +// Normalize normalizes the vector. Normalization is (1/|v|)*v, +// making this equivalent to v.Scale(1/v.Len()). If the len is 0.0, +// this function will return an infinite value for all elements due +// to how floating point division works in Go (n/0.0 = math.Inf(Sign(n))). +// +// Normalization makes a vector's Len become 1.0 (within the margin of floating point error), +// while maintaining its directionality. +// +// (Can be seen here: http://play.golang.org/p/Aaj7SnbqIp ) +func (v1 Vec2) Normalize() Vec2 { + l := 1.0 / v1.Len() + return Vec2{v1[0] * l, v1[1] * l} +} + +// ApproxEqual takes in a vector and does an element-wise approximate float +// comparison as if FloatEqual had been used +func (v1 Vec2) ApproxEqual(v2 Vec2) bool { + for i := range v1 { + if !FloatEqual(v1[i], v2[i]) { + return false + } + } + return true +} + +// ApproxEqualThreshold takes in a threshold for comparing two floats, and uses +// it to do an element-wise comparison of the vector to another. +func (v1 Vec2) ApproxEqualThreshold(v2 Vec2, threshold float32) bool { + for i := range v1 { + if !FloatEqualThreshold(v1[i], v2[i], threshold) { + return false + } + } + return true +} + +// ApproxFuncEqual takes in a func that compares two floats, and uses it to do an element-wise +// comparison of the vector to another. This is intended to be used with FloatEqualFunc +func (v1 Vec2) ApproxFuncEqual(v2 Vec2, eq func(float32, float32) bool) bool { + for i := range v1 { + if !eq(v1[i], v2[i]) { + return false + } + } + return true +} + +// X is an element access func, it is equivalent to v[n] where +// n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks +// show that this is more or less as fast as direct acces, probably due to +// inlining, so use v[0] or v.X() depending on personal preference. +func (v Vec2) X() float32 { + return v[0] +} + +// Y is an element access func, it is equivalent to v[n] where +// n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks +// show that this is more or less as fast as direct acces, probably due to +// inlining, so use v[0] or v.X() depending on personal preference. +func (v Vec2) Y() float32 { + return v[1] +} + +// OuterProd2 does the vector outer product +// of two vectors. The outer product produces an +// 2x2 matrix. E.G. a Vec2 * Vec2 = Mat2. +// +// The outer product can be thought of as the "opposite" +// of the Dot product. The Dot product treats both vectors like matrices +// oriented such that the left one has N columns and the right has N rows. +// So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar. +// +// The outer product orients it so they're facing "outward": Vec2*Vec3 +// = Mat2x1*Mat1x3 = Mat2x3. +func (v1 Vec2) OuterProd2(v2 Vec2) Mat2 { + return Mat2{v1[0] * v2[0], v1[1] * v2[0], v1[0] * v2[1], v1[1] * v2[1]} +} + +// OuterProd3 does the vector outer product +// of two vectors. The outer product produces an +// 2x3 matrix. E.G. a Vec2 * Vec3 = Mat2x3. +// +// The outer product can be thought of as the "opposite" +// of the Dot product. The Dot product treats both vectors like matrices +// oriented such that the left one has N columns and the right has N rows. +// So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar. +// +// The outer product orients it so they're facing "outward": Vec2*Vec3 +// = Mat2x1*Mat1x3 = Mat2x3. +func (v1 Vec2) OuterProd3(v2 Vec3) Mat2x3 { + return Mat2x3{v1[0] * v2[0], v1[1] * v2[0], v1[0] * v2[1], v1[1] * v2[1], v1[0] * v2[2], v1[1] * v2[2]} +} + +// OuterProd4 does the vector outer product +// of two vectors. The outer product produces an +// 2x4 matrix. E.G. a Vec2 * Vec4 = Mat2x4. +// +// The outer product can be thought of as the "opposite" +// of the Dot product. The Dot product treats both vectors like matrices +// oriented such that the left one has N columns and the right has N rows. +// So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar. +// +// The outer product orients it so they're facing "outward": Vec2*Vec3 +// = Mat2x1*Mat1x3 = Mat2x3. +func (v1 Vec2) OuterProd4(v2 Vec4) Mat2x4 { + return Mat2x4{v1[0] * v2[0], v1[1] * v2[0], v1[0] * v2[1], v1[1] * v2[1], v1[0] * v2[2], v1[1] * v2[2], v1[0] * v2[3], v1[1] * v2[3]} +} + +// Add performs element-wise addition between two vectors. It is equivalent to iterating +// over every element of v1 and adding the corresponding element of v2 to it. +func (v1 Vec3) Add(v2 Vec3) Vec3 { + return Vec3{v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2]} +} + +// Sub performs element-wise subtraction between two vectors. It is equivalent to iterating +// over every element of v1 and subtracting the corresponding element of v2 from it. +func (v1 Vec3) Sub(v2 Vec3) Vec3 { + return Vec3{v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2]} +} + +// Mul performs a scalar multiplication between the vector and some constant value +// c. This is equivalent to iterating over every vector element and multiplying by c. +func (v1 Vec3) Mul(c float32) Vec3 { + return Vec3{v1[0] * c, v1[1] * c, v1[2] * c} +} + +// Dot returns the dot product of this vector with another. There are multiple ways +// to describe this value. One is the multiplication of their lengths and cos(theta) where +// theta is the angle between the vectors: v1.v2 = |v1||v2|cos(theta). +// +// The other (and what is actually done) is the sum of the element-wise multiplication of all +// elements. So for instance, two Vec3s would yield v1.x * v2.x + v1.y * v2.y + v1.z * v2.z. +// +// This means that the dot product of a vector and itself is the square of its Len (within +// the bounds of floating points error). +// +// The dot product is roughly a measure of how closely two vectors are to pointing in the same +// direction. If both vectors are normalized, the value will be -1 for opposite pointing, +// one for same pointing, and 0 for perpendicular vectors. +func (v1 Vec3) Dot(v2 Vec3) float32 { + return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2] +} + +// Len returns the vector's length. Note that this is NOT the dimension of +// the vector (len(v)), but the mathematical length. This is equivalent to the square +// root of the sum of the squares of all elements. E.G. for a Vec2 it's +// math.Hypot(v[0], v[1]). +func (v1 Vec3) Len() float32 { + + return float32(math.Sqrt(float64(v1[0]*v1[0] + v1[1]*v1[1] + v1[2]*v1[2]))) + +} + +// LenSqr returns the vector's square length. This is equivalent to the sum of the squares of all elements. +func (v1 Vec3) LenSqr() float32 { + return v1[0]*v1[0] + v1[1]*v1[1] + v1[2]*v1[2] +} + +// Normalize normalizes the vector. Normalization is (1/|v|)*v, +// making this equivalent to v.Scale(1/v.Len()). If the len is 0.0, +// this function will return an infinite value for all elements due +// to how floating point division works in Go (n/0.0 = math.Inf(Sign(n))). +// +// Normalization makes a vector's Len become 1.0 (within the margin of floating point error), +// while maintaining its directionality. +// +// (Can be seen here: http://play.golang.org/p/Aaj7SnbqIp ) +func (v1 Vec3) Normalize() Vec3 { + l := 1.0 / v1.Len() + return Vec3{v1[0] * l, v1[1] * l, v1[2] * l} +} + +// ApproxEqual takes in a vector and does an element-wise approximate float +// comparison as if FloatEqual had been used +func (v1 Vec3) ApproxEqual(v2 Vec3) bool { + for i := range v1 { + if !FloatEqual(v1[i], v2[i]) { + return false + } + } + return true +} + +// ApproxEqualThreshold takes in a threshold for comparing two floats, and uses +// it to do an element-wise comparison of the vector to another. +func (v1 Vec3) ApproxEqualThreshold(v2 Vec3, threshold float32) bool { + for i := range v1 { + if !FloatEqualThreshold(v1[i], v2[i], threshold) { + return false + } + } + return true +} + +// ApproxFuncEqual takes in a func that compares two floats, and uses it to do an element-wise +// comparison of the vector to another. This is intended to be used with FloatEqualFunc +func (v1 Vec3) ApproxFuncEqual(v2 Vec3, eq func(float32, float32) bool) bool { + for i := range v1 { + if !eq(v1[i], v2[i]) { + return false + } + } + return true +} + +// X is an element access func, it is equivalent to v[n] where +// n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks +// show that this is more or less as fast as direct acces, probably due to +// inlining, so use v[0] or v.X() depending on personal preference. +func (v Vec3) X() float32 { + return v[0] +} + +// Y is an element access func, it is equivalent to v[n] where +// n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks +// show that this is more or less as fast as direct acces, probably due to +// inlining, so use v[0] or v.X() depending on personal preference. +func (v Vec3) Y() float32 { + return v[1] +} + +// Z is an element access func, it is equivalent to v[n] where +// n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks +// show that this is more or less as fast as direct acces, probably due to +// inlining, so use v[0] or v.X() depending on personal preference. +func (v Vec3) Z() float32 { + return v[2] +} + +// OuterProd2 does the vector outer product +// of two vectors. The outer product produces an +// 3x2 matrix. E.G. a Vec3 * Vec2 = Mat3x2. +// +// The outer product can be thought of as the "opposite" +// of the Dot product. The Dot product treats both vectors like matrices +// oriented such that the left one has N columns and the right has N rows. +// So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar. +// +// The outer product orients it so they're facing "outward": Vec2*Vec3 +// = Mat2x1*Mat1x3 = Mat2x3. +func (v1 Vec3) OuterProd2(v2 Vec2) Mat3x2 { + return Mat3x2{v1[0] * v2[0], v1[1] * v2[0], v1[2] * v2[0], v1[0] * v2[1], v1[1] * v2[1], v1[2] * v2[1]} +} + +// OuterProd3 does the vector outer product +// of two vectors. The outer product produces an +// 3x3 matrix. E.G. a Vec3 * Vec3 = Mat3. +// +// The outer product can be thought of as the "opposite" +// of the Dot product. The Dot product treats both vectors like matrices +// oriented such that the left one has N columns and the right has N rows. +// So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar. +// +// The outer product orients it so they're facing "outward": Vec2*Vec3 +// = Mat2x1*Mat1x3 = Mat2x3. +func (v1 Vec3) OuterProd3(v2 Vec3) Mat3 { + return Mat3{v1[0] * v2[0], v1[1] * v2[0], v1[2] * v2[0], v1[0] * v2[1], v1[1] * v2[1], v1[2] * v2[1], v1[0] * v2[2], v1[1] * v2[2], v1[2] * v2[2]} +} + +// OuterProd4 does the vector outer product +// of two vectors. The outer product produces an +// 3x4 matrix. E.G. a Vec3 * Vec4 = Mat3x4. +// +// The outer product can be thought of as the "opposite" +// of the Dot product. The Dot product treats both vectors like matrices +// oriented such that the left one has N columns and the right has N rows. +// So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar. +// +// The outer product orients it so they're facing "outward": Vec2*Vec3 +// = Mat2x1*Mat1x3 = Mat2x3. +func (v1 Vec3) OuterProd4(v2 Vec4) Mat3x4 { + return Mat3x4{v1[0] * v2[0], v1[1] * v2[0], v1[2] * v2[0], v1[0] * v2[1], v1[1] * v2[1], v1[2] * v2[1], v1[0] * v2[2], v1[1] * v2[2], v1[2] * v2[2], v1[0] * v2[3], v1[1] * v2[3], v1[2] * v2[3]} +} + +// Add performs element-wise addition between two vectors. It is equivalent to iterating +// over every element of v1 and adding the corresponding element of v2 to it. +func (v1 Vec4) Add(v2 Vec4) Vec4 { + return Vec4{v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2], v1[3] + v2[3]} +} + +// Sub performs element-wise subtraction between two vectors. It is equivalent to iterating +// over every element of v1 and subtracting the corresponding element of v2 from it. +func (v1 Vec4) Sub(v2 Vec4) Vec4 { + return Vec4{v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2], v1[3] - v2[3]} +} + +// Mul performs a scalar multiplication between the vector and some constant value +// c. This is equivalent to iterating over every vector element and multiplying by c. +func (v1 Vec4) Mul(c float32) Vec4 { + return Vec4{v1[0] * c, v1[1] * c, v1[2] * c, v1[3] * c} +} + +// Dot returns the dot product of this vector with another. There are multiple ways +// to describe this value. One is the multiplication of their lengths and cos(theta) where +// theta is the angle between the vectors: v1.v2 = |v1||v2|cos(theta). +// +// The other (and what is actually done) is the sum of the element-wise multiplication of all +// elements. So for instance, two Vec3s would yield v1.x * v2.x + v1.y * v2.y + v1.z * v2.z. +// +// This means that the dot product of a vector and itself is the square of its Len (within +// the bounds of floating points error). +// +// The dot product is roughly a measure of how closely two vectors are to pointing in the same +// direction. If both vectors are normalized, the value will be -1 for opposite pointing, +// one for same pointing, and 0 for perpendicular vectors. +func (v1 Vec4) Dot(v2 Vec4) float32 { + return v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2] + v1[3]*v2[3] +} + +// Len returns the vector's length. Note that this is NOT the dimension of +// the vector (len(v)), but the mathematical length. This is equivalent to the square +// root of the sum of the squares of all elements. E.G. for a Vec2 it's +// math.Hypot(v[0], v[1]). +func (v1 Vec4) Len() float32 { + + return float32(math.Sqrt(float64(v1[0]*v1[0] + v1[1]*v1[1] + v1[2]*v1[2] + v1[3]*v1[3]))) + +} + +// LenSqr returns the vector's square length. This is equivalent to the sum of the squares of all elements. +func (v1 Vec4) LenSqr() float32 { + return v1[0]*v1[0] + v1[1]*v1[1] + v1[2]*v1[2] + v1[3]*v1[3] +} + +// Normalize normalizes the vector. Normalization is (1/|v|)*v, +// making this equivalent to v.Scale(1/v.Len()). If the len is 0.0, +// this function will return an infinite value for all elements due +// to how floating point division works in Go (n/0.0 = math.Inf(Sign(n))). +// +// Normalization makes a vector's Len become 1.0 (within the margin of floating point error), +// while maintaining its directionality. +// +// (Can be seen here: http://play.golang.org/p/Aaj7SnbqIp ) +func (v1 Vec4) Normalize() Vec4 { + l := 1.0 / v1.Len() + return Vec4{v1[0] * l, v1[1] * l, v1[2] * l, v1[3] * l} +} + +// ApproxEqual takes in a vector and does an element-wise approximate float +// comparison as if FloatEqual had been used +func (v1 Vec4) ApproxEqual(v2 Vec4) bool { + for i := range v1 { + if !FloatEqual(v1[i], v2[i]) { + return false + } + } + return true +} + +// ApproxEqualThreshold takes in a threshold for comparing two floats, and uses +// it to do an element-wise comparison of the vector to another. +func (v1 Vec4) ApproxEqualThreshold(v2 Vec4, threshold float32) bool { + for i := range v1 { + if !FloatEqualThreshold(v1[i], v2[i], threshold) { + return false + } + } + return true +} + +// ApproxFuncEqual takes in a func that compares two floats, and uses it to do an element-wise +// comparison of the vector to another. This is intended to be used with FloatEqualFunc +func (v1 Vec4) ApproxFuncEqual(v2 Vec4, eq func(float32, float32) bool) bool { + for i := range v1 { + if !eq(v1[i], v2[i]) { + return false + } + } + return true +} + +// X is an element access func, it is equivalent to v[n] where +// n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks +// show that this is more or less as fast as direct acces, probably due to +// inlining, so use v[0] or v.X() depending on personal preference. +func (v Vec4) X() float32 { + return v[0] +} + +// Y is an element access func, it is equivalent to v[n] where +// n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks +// show that this is more or less as fast as direct acces, probably due to +// inlining, so use v[0] or v.X() depending on personal preference. +func (v Vec4) Y() float32 { + return v[1] +} + +// Z is an element access func, it is equivalent to v[n] where +// n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks +// show that this is more or less as fast as direct acces, probably due to +// inlining, so use v[0] or v.X() depending on personal preference. +func (v Vec4) Z() float32 { + return v[2] +} + +// W is an element access func, it is equivalent to v[n] where +// n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks +// show that this is more or less as fast as direct acces, probably due to +// inlining, so use v[0] or v.X() depending on personal preference. +func (v Vec4) W() float32 { + return v[3] +} + +// OuterProd2 does the vector outer product +// of two vectors. The outer product produces an +// 4x2 matrix. E.G. a Vec4 * Vec2 = Mat4x2. +// +// The outer product can be thought of as the "opposite" +// of the Dot product. The Dot product treats both vectors like matrices +// oriented such that the left one has N columns and the right has N rows. +// So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar. +// +// The outer product orients it so they're facing "outward": Vec2*Vec3 +// = Mat2x1*Mat1x3 = Mat2x3. +func (v1 Vec4) OuterProd2(v2 Vec2) Mat4x2 { + return Mat4x2{v1[0] * v2[0], v1[1] * v2[0], v1[2] * v2[0], v1[3] * v2[0], v1[0] * v2[1], v1[1] * v2[1], v1[2] * v2[1], v1[3] * v2[1]} +} + +// OuterProd3 does the vector outer product +// of two vectors. The outer product produces an +// 4x3 matrix. E.G. a Vec4 * Vec3 = Mat4x3. +// +// The outer product can be thought of as the "opposite" +// of the Dot product. The Dot product treats both vectors like matrices +// oriented such that the left one has N columns and the right has N rows. +// So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar. +// +// The outer product orients it so they're facing "outward": Vec2*Vec3 +// = Mat2x1*Mat1x3 = Mat2x3. +func (v1 Vec4) OuterProd3(v2 Vec3) Mat4x3 { + return Mat4x3{v1[0] * v2[0], v1[1] * v2[0], v1[2] * v2[0], v1[3] * v2[0], v1[0] * v2[1], v1[1] * v2[1], v1[2] * v2[1], v1[3] * v2[1], v1[0] * v2[2], v1[1] * v2[2], v1[2] * v2[2], v1[3] * v2[2]} +} + +// OuterProd4 does the vector outer product +// of two vectors. The outer product produces an +// 4x4 matrix. E.G. a Vec4 * Vec4 = Mat4. +// +// The outer product can be thought of as the "opposite" +// of the Dot product. The Dot product treats both vectors like matrices +// oriented such that the left one has N columns and the right has N rows. +// So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar. +// +// The outer product orients it so they're facing "outward": Vec2*Vec3 +// = Mat2x1*Mat1x3 = Mat2x3. +func (v1 Vec4) OuterProd4(v2 Vec4) Mat4 { + return Mat4{v1[0] * v2[0], v1[1] * v2[0], v1[2] * v2[0], v1[3] * v2[0], v1[0] * v2[1], v1[1] * v2[1], v1[2] * v2[1], v1[3] * v2[1], v1[0] * v2[2], v1[1] * v2[2], v1[2] * v2[2], v1[3] * v2[2], v1[0] * v2[3], v1[1] * v2[3], v1[2] * v2[3], v1[3] * v2[3]} +} diff --git a/vendor/github.com/go-gl/mathgl/mgl32/vector.tmpl b/vendor/github.com/go-gl/mathgl/mgl32/vector.tmpl new file mode 100644 index 0000000..c047bba --- /dev/null +++ b/vendor/github.com/go-gl/mathgl/mgl32/vector.tmpl @@ -0,0 +1,226 @@ +// Copyright 2014 The go-gl/mathgl Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// <<.Comment>> +// Edit <<.TemplateName>> and run "go generate" to make changes. + +package mgl32 + +import ( + "math" +) + +type Vec2 [2]float32 +type Vec3 [3]float32 +type Vec4 [4]float32 + +// Vec3 constructs a 3-dimensional vector by appending the given coordinates. +func (v Vec2) Vec3(z float32) Vec3 { + return Vec3{v[0], v[1], z} +} + +// Vec4 constructs a 4-dimensional vector by appending the given coordinates. +func (v Vec2) Vec4(z, w float32) Vec4 { + return Vec4{v[0], v[1], z, w} +} + +// Vec4 constructs a 4-dimensional vector by appending the given coordinates. +func (v Vec3) Vec4(w float32) Vec4 { + return Vec4{v[0], v[1], v[2], w} +} + +// Vec2 constructs a 2-dimensional vector by discarding coordinates. +func (v Vec3) Vec2() Vec2 { + return Vec2{v[0], v[1]} +} + +// Vec2 constructs a 2-dimensional vector by discarding coordinates. +func (v Vec4) Vec2() Vec2 { + return Vec2{v[0], v[1]} +} + +// Vec3 constructs a 3-dimensional vector by discarding coordinates. +func (v Vec4) Vec3() Vec3 { + return Vec3{v[0], v[1], v[2]} +} + +// Elem extracts the elements of the vector for direct value assignment. +func (v Vec2) Elem() (x, y float32) { + return v[0], v[1] +} + +// Elem extracts the elements of the vector for direct value assignment. +func (v Vec3) Elem() (x, y, z float32) { + return v[0], v[1], v[2] +} + +// Elem extracts the elements of the vector for direct value assignment. +func (v Vec4) Elem() (x, y, z, w float32) { + return v[0], v[1], v[2], v[3] +} + +// Cross is the vector cross product. This operation is only defined on 3D +// vectors. It is equivalent to Vec3{v1[1]*v2[2]-v1[2]*v2[1], +// v1[2]*v2[0]-v1[0]*v2[2], v1[0]*v2[1] - v1[1]*v2[0]}. Another interpretation +// is that it's the vector whose magnitude is |v1||v2|sin(theta) where theta is +// the angle between v1 and v2. +// +// The cross product is most often used for finding surface normals. The cross +// product of vectors will generate a vector that is perpendicular to the plane +// they form. +// +// Technically, a generalized cross product exists as an "(N-1)ary" operation +// (that is, the 4D cross product requires 3 4D vectors). But the binary 3D (and +// 7D) cross product is the most important. It can be considered the area of a +// parallelogram with sides v1 and v2. +// +// Like the dot product, the cross product is roughly a measure of +// directionality. Two normalized perpendicular vectors will return a vector +// with a magnitude of 1.0 or -1.0 and two parallel vectors will return a vector +// with magnitude 0.0. The cross product is "anticommutative" meaning +// v1.Cross(v2) = -v2.Cross(v1), this property can be useful to know when +// finding normals, as taking the wrong cross product can lead to the opposite +// normal of the one you want. +func (v1 Vec3) Cross(v2 Vec3) Vec3 { + return Vec3{v1[1]*v2[2] - v1[2]*v2[1], v1[2]*v2[0] - v1[0]*v2[2], v1[0]*v2[1] - v1[1]*v2[0]} +} + +// Quat reinterprets this vector as a quaternion, with the individual elements +// staying the same. +func (v Vec4) Quat() Quat { + return Quat{v[3], Vec3{v[0], v[1], v[2]}} +} + + +<> +<> +<<$type := typename $m 1>> + +// Add performs element-wise addition between two vectors. It is equivalent to iterating +// over every element of v1 and adding the corresponding element of v2 to it. +func (v1 <<$type>>) Add(v2 <<$type>>) <<$type>> { + return <<$type>>{<> v1[<<$i>>] + v2[<<$i>>], <>} +} + +// Sub performs element-wise subtraction between two vectors. It is equivalent to iterating +// over every element of v1 and subtracting the corresponding element of v2 from it. +func (v1 <<$type>>) Sub(v2 <<$type>>) <<$type>> { + return <<$type>>{<> v1[<<$i>>] - v2[<<$i>>], <>} +} + +// Mul performs a scalar multiplication between the vector and some constant value +// c. This is equivalent to iterating over every vector element and multiplying by c. +func (v1 <<$type>>) Mul(c float32) <<$type>> { + return <<$type>>{<> v1[<<$i>>] * c, <>} +} + +// Dot returns the dot product of this vector with another. There are multiple ways +// to describe this value. One is the multiplication of their lengths and cos(theta) where +// theta is the angle between the vectors: v1.v2 = |v1||v2|cos(theta). +// +// The other (and what is actually done) is the sum of the element-wise multiplication of all +// elements. So for instance, two Vec3s would yield v1.x * v2.x + v1.y * v2.y + v1.z * v2.z. +// +// This means that the dot product of a vector and itself is the square of its Len (within +// the bounds of floating points error). +// +// The dot product is roughly a measure of how closely two vectors are to pointing in the same +// direction. If both vectors are normalized, the value will be -1 for opposite pointing, +// one for same pointing, and 0 for perpendicular vectors. +func (v1 <<$type>>) Dot(v2 <<$type>>) float32 { + return <><> v1[<<$i>>]*v2[<<$i>>] <> +} + +// Len returns the vector's length. Note that this is NOT the dimension of +// the vector (len(v)), but the mathematical length. This is equivalent to the square +// root of the sum of the squares of all elements. E.G. for a Vec2 it's +// math.Hypot(v[0], v[1]). +func (v1 <<$type>>) Len() float32 { + <> + return float32(math.Hypot(float64(v1[0]), float64(v1[1]))) + <> + return float32(math.Sqrt(float64(<>))) + <> +} + +// LenSqr returns the vector's square length. This is equivalent to the sum of the squares of all elements. +func (v1 <<$type>>) LenSqr() float32 { + return <> +} + +// Normalize normalizes the vector. Normalization is (1/|v|)*v, +// making this equivalent to v.Scale(1/v.Len()). If the len is 0.0, +// this function will return an infinite value for all elements due +// to how floating point division works in Go (n/0.0 = math.Inf(Sign(n))). +// +// Normalization makes a vector's Len become 1.0 (within the margin of floating point error), +// while maintaining its directionality. +// +// (Can be seen here: http://play.golang.org/p/Aaj7SnbqIp ) +func (v1 <<$type>>) Normalize() <<$type>> { + l := 1.0 / v1.Len() + return <<$type>>{<>v1[<<$i>>] * l,<>} +} + +// ApproxEqual takes in a vector and does an element-wise approximate float +// comparison as if FloatEqual had been used +func (v1 <<$type>>) ApproxEqual(v2 <<$type>>) bool { + for i := range v1 { + if !FloatEqual(v1[i], v2[i]) { + return false + } + } + return true +} + +// ApproxEqualThreshold takes in a threshold for comparing two floats, and uses +// it to do an element-wise comparison of the vector to another. +func (v1 <<$type>>) ApproxEqualThreshold(v2 <<$type>>, threshold float32) bool { + for i := range v1 { + if !FloatEqualThreshold(v1[i], v2[i], threshold) { + return false + } + } + return true +} + +// ApproxFuncEqual takes in a func that compares two floats, and uses it to do an element-wise +// comparison of the vector to another. This is intended to be used with FloatEqualFunc +func (v1 <<$type>>) ApproxFuncEqual(v2 <<$type>>, eq func(float32, float32) bool) bool { + for i := range v1 { + if !eq(v1[i], v2[i]) { + return false + } + } + return true +} + +<> +// <> is an element access func, it is equivalent to v[n] where +// n is some valid index. The mappings are XYZW (X=0, Y=1 etc). Benchmarks +// show that this is more or less as fast as direct acces, probably due to +// inlining, so use v[0] or v.X() depending on personal preference. +func (v <<$type>>) <>() float32 { + return v[<<$i>>] +} +<> + +<> +// OuterProd<<$n>> does the vector outer product +// of two vectors. The outer product produces an +// <<$m>>x<<$n>> matrix. E.G. a Vec<<$m>> * Vec<<$n>> = <>. +// +// The outer product can be thought of as the "opposite" +// of the Dot product. The Dot product treats both vectors like matrices +// oriented such that the left one has N columns and the right has N rows. +// So Vec3.Vec3 = Mat1x3*Mat3x1 = Mat1 = Scalar. +// +// The outer product orients it so they're facing "outward": Vec2*Vec3 +// = Mat2x1*Mat1x3 = Mat2x3. +func (v1 <<$type>>) OuterProd<<$n>>(v2 <>) <> { + return <>{<>v1[<<$i.M>>] * v2[<<$i.N>>], <>} +} +<> + +<> <> diff --git a/vendor/github.com/godbus/dbus/v5/CONTRIBUTING.md b/vendor/github.com/godbus/dbus/v5/CONTRIBUTING.md new file mode 100644 index 0000000..c88f9b2 --- /dev/null +++ b/vendor/github.com/godbus/dbus/v5/CONTRIBUTING.md @@ -0,0 +1,50 @@ +# How to Contribute + +## Getting Started + +- Fork the repository on GitHub +- Read the [README](README.markdown) for build and test instructions +- Play with the project, submit bugs, submit patches! + +## Contribution Flow + +This is a rough outline of what a contributor's workflow looks like: + +- Create a topic branch from where you want to base your work (usually master). +- Make commits of logical units. +- Make sure your commit messages are in the proper format (see below). +- Push your changes to a topic branch in your fork of the repository. +- Make sure the tests pass, and add any new tests as appropriate. +- Submit a pull request to the original repository. + +Thanks for your contributions! + +### Format of the Commit Message + +We follow a rough convention for commit messages that is designed to answer two +questions: what changed and why. The subject line should feature the what and +the body of the commit should describe the why. + +``` +scripts: add the test-cluster command + +this uses tmux to setup a test cluster that you can easily kill and +start for debugging. + +Fixes #38 +``` + +The format can be described more formally as follows: + +``` +: + + + +