From cfb39703945858b20c4b3687a06cf2756e804c39 Mon Sep 17 00:00:00 2001 From: Antonis Geralis <43617260+planetis-m@users.noreply.github.com> Date: Mon, 27 Dec 2021 15:35:43 +0300 Subject: [PATCH 01/13] Generate bindings from the JSON files --- common.nim | 227 ++ raylib_api.json | 6826 ++++++++++++++++++++++++++++++++++++++++++++++ raylib_gen.nim | 459 ++++ raymath_api.json | 962 +++++++ raymath_gen.nim | 140 + 5 files changed, 8614 insertions(+) create mode 100644 common.nim create mode 100644 raylib_api.json create mode 100644 raylib_gen.nim create mode 100644 raymath_api.json create mode 100644 raymath_gen.nim diff --git a/common.nim b/common.nim new file mode 100644 index 0000000..8e45d88 --- /dev/null +++ b/common.nim @@ -0,0 +1,227 @@ +import eminim, std/[algorithm, strutils, strscans, strformat, streams, parsejson] + +const + nimKeyw = ["addr", "and", "as", "asm", + "bind", "block", "break", + "case", "cast", "concept", "const", "continue", "converter", + "defer", "discard", "distinct", "div", "do", + "elif", "else", "end", "enum", "except", "export", + "finally", "for", "from", "func", + "if", "import", "in", "include", "interface", "is", "isnot", "iterator", + "let", + "macro", "method", "mixin", "mod", + "nil", "not", "notin", + "object", "of", "or", "out", + "proc", "ptr", + "raise", "ref", "return", + "shl", "shr", "static", + "template", "try", "tuple", "type", + "using", + "var", + "when", "while", + "xor", + "yield"] + +proc isKeyword*(s: string): bool {.inline.} = + ## Checks if an indentifier is a Nim keyword + binarySearch(nimKeyw, s) >= 0 + +## The raylib_parser produces JSON with the following structure. +## The type definitions are used by the deserializer to process the file. +type + Topmost* = object + structs*: seq[StructInfo] + enums*: seq[EnumInfo] + functions*: seq[FunctionInfo] + + FunctionInfo* = object + name*, description*, returnType*: string + params*: Params + Params* = seq[(string, string)] # Could have used an OrderedTable instead. + + StructInfo* = object + name*, description*: string + fields*: seq[FieldInfo] + + FieldInfo* = object + name*, `type`*, description*: string + + EnumInfo* = object + name*, description*: string + values*: seq[ValueInfo] + + ValueInfo* = object + name*: string + value*: int + description*: string + +# The deserializer doesn't support anonymous tuples by default, process manually. +proc initFromJson(dst: var Params; p: var JsonParser) = + eat(p, tkCurlyLe) + while p.tok != tkCurlyRi: + if p.tok != tkString: + raiseParseErr(p, "string literal as key") + var keyValPair: (string, string) + keyValPair[0] = move p.a + discard getTok(p) + eat(p, tkColon) + initFromJson(keyValPair[1], p) + dst.add keyValPair + if p.tok != tkComma: break + discard getTok(p) + eat(p, tkCurlyRi) + +proc parseApi*(fname: string): Topmost = + var inp: FileStream + try: + inp = openFileStream(fname) + result = inp.jsonTo(Topmost) + finally: + if inp != nil: inp.close() + +proc addIndent*(result: var string, indent: int) = + result.add("\n") + for i in 1..indent: + result.add(' ') + +proc toNimType*(x: string): string = + ## Translates a single C identifier to the equivalent Nim type. + ## Also used to make replacements. + case x + of "float": + "float32" + of "double": + "float" + of "short": + "int16" + of "long": + "int64" + of "rAudioBuffer": + "RAudioBuffer" + of "float3": + "Float3" + of "float16": + "Float16" + else: x + +proc convertType*(s: string, pattern: string, many: bool): string = + ## Converts a C type to the equivalent Nim type. + ## Should work with function parameters, return, and struct fields types. + ## If a `pattern` is provided, it substitutes the found base type and returns it. + ## `many` hints the generation of `ptr UncheckedArray` instead of `ptr`. + ## NOTE: expects `s` to be formatted with spaces, `MyType*` needs to be `MyType *` + var isVoid = false + var isPointer = false + var isDoublePointer = false + var isChar = false + var isUnsigned = false + var isSizeT = false + var isSigned = false + for (token, isSep) in tokenize(s): + if isSep: continue + case token + of "const": + discard + of "void": + isVoid = true + of "*": + isPointer = true + of "**": + isDoublePointer = true + of "char": + isChar = true + of "unsigned": + isUnsigned = true + of "size_t": + isSizeT = true + of "signed": + isSigned = true + of "int": + discard + else: + result = toNimType(token) + if result == "": result = "int32" + if isSizeT: + result = "csize_t" + elif isChar: + if isUnsigned: + result = "uint8" + else: + result = "char" + elif isUnsigned: + result = "u" & result + if pattern != "": + result = pattern % result + elif isChar and not isUnsigned: + if isDoublePointer: + result = "cstringArray" + elif isPointer: + result = "cstring" + elif isPointer: + if isVoid: + result = "pointer" + elif many: + result = "ptr UncheckedArray[" & result & "]" + else: + result = "ptr " & result + elif isDoublePointer: + if isVoid: + result = "ptr pointer" + elif many: + result = "ptr UncheckedArray[ptr " & result & "]" + else: + result = "ptr ptr " & result + +proc hasMany*(x: string): bool {.inline.} = + ## Tries to determine if an identifier is plural + let x = strip(x, false, chars = Digits) + x.endsWith("es") or (not x.endsWith("ss") and x.endsWith('s')) or + endsWith(x.normalize, "data") + +proc transFieldName*(x: string): (string, string) = + ## Returns the identifier name(s) and if an array is detected, separated. + var name: string + var len: int + # In C array definition follows the identifier, `name[4]`. + if scanf(x, "$w[$i]$.", name, len): + result = (name, &"array[{len}, $1]") + else: + if validIdentifier(x): + result = (x, "") + else: + # Multiple identifiers in the same line. + # Make sure all but the last one, are exported. + result = (replace(x, ",", "*,"), "") + +proc camelCaseAscii*(s: string): string = + ## Converts snake_case to CamelCase + var L = s.len + while L > 0 and s[L-1] == '_': dec L + result = newStringOfCap(L) + var i = 0 + result.add s[i] + inc i + var flip = false + while i < L: + if s[i] == '_': + flip = true + else: + if flip: + result.add toUpperAscii(s[i]) + flip = false + else: result.add toLowerAscii(s[i]) + inc i + +proc allSequential*(x: seq[ValueInfo]): bool = + ## Checks that the enum has no holes. + var prev = x[0].value + for i in 1..x.high: + let xi = x[i].value + if prev + 1 < xi: + return false + prev = xi + result = true + +proc uncapitalizeAscii*(s: string): string = + if s.len == 0: result = "" + else: result = toLowerAscii(s[0]) & substr(s, 1) diff --git a/raylib_api.json b/raylib_api.json new file mode 100644 index 0000000..34caea8 --- /dev/null +++ b/raylib_api.json @@ -0,0 +1,6826 @@ +{ + "structs": [ + { + "name": "Vector2", + "description": "Vector2, 2 components", + "fields": [ + { + "name": "x", + "type": "float", + "description": "Vector x component" + }, + { + "name": "y", + "type": "float", + "description": "Vector y component" + } + ] + }, + { + "name": "Vector3", + "description": "Vector3, 3 components", + "fields": [ + { + "name": "x", + "type": "float", + "description": "Vector x component" + }, + { + "name": "y", + "type": "float", + "description": "Vector y component" + }, + { + "name": "z", + "type": "float", + "description": "Vector z component" + } + ] + }, + { + "name": "Vector4", + "description": "Vector4, 4 components", + "fields": [ + { + "name": "x", + "type": "float", + "description": "Vector x component" + }, + { + "name": "y", + "type": "float", + "description": "Vector y component" + }, + { + "name": "z", + "type": "float", + "description": "Vector z component" + }, + { + "name": "w", + "type": "float", + "description": "Vector w component" + } + ] + }, + { + "name": "Matrix", + "description": "Matrix, 4x4 components, column major, OpenGL style, right handed", + "fields": [ + { + "name": "m0, m4, m8, m12", + "type": "float", + "description": "Matrix first row (4 components)" + }, + { + "name": "m1, m5, m9, m13", + "type": "float", + "description": "Matrix second row (4 components)" + }, + { + "name": "m2, m6, m10, m14", + "type": "float", + "description": "Matrix third row (4 components)" + }, + { + "name": "m3, m7, m11, m15", + "type": "float", + "description": "Matrix fourth row (4 components)" + } + ] + }, + { + "name": "Color", + "description": "Color, 4 components, R8G8B8A8 (32bit)", + "fields": [ + { + "name": "r", + "type": "unsigned char", + "description": "Color red value" + }, + { + "name": "g", + "type": "unsigned char", + "description": "Color green value" + }, + { + "name": "b", + "type": "unsigned char", + "description": "Color blue value" + }, + { + "name": "a", + "type": "unsigned char", + "description": "Color alpha value" + } + ] + }, + { + "name": "Rectangle", + "description": "Rectangle, 4 components", + "fields": [ + { + "name": "x", + "type": "float", + "description": "Rectangle top-left corner position x" + }, + { + "name": "y", + "type": "float", + "description": "Rectangle top-left corner position y" + }, + { + "name": "width", + "type": "float", + "description": "Rectangle width" + }, + { + "name": "height", + "type": "float", + "description": "Rectangle height" + } + ] + }, + { + "name": "Image", + "description": "Image, pixel data stored in CPU memory (RAM)", + "fields": [ + { + "name": "data", + "type": "void *", + "description": "Image raw data" + }, + { + "name": "width", + "type": "int", + "description": "Image base width" + }, + { + "name": "height", + "type": "int", + "description": "Image base height" + }, + { + "name": "mipmaps", + "type": "int", + "description": "Mipmap levels, 1 by default" + }, + { + "name": "format", + "type": "int", + "description": "Data format (PixelFormat type)" + } + ] + }, + { + "name": "Texture", + "description": "Texture, tex data stored in GPU memory (VRAM)", + "fields": [ + { + "name": "id", + "type": "unsigned int", + "description": "OpenGL texture id" + }, + { + "name": "width", + "type": "int", + "description": "Texture base width" + }, + { + "name": "height", + "type": "int", + "description": "Texture base height" + }, + { + "name": "mipmaps", + "type": "int", + "description": "Mipmap levels, 1 by default" + }, + { + "name": "format", + "type": "int", + "description": "Data format (PixelFormat type)" + } + ] + }, + { + "name": "RenderTexture", + "description": "RenderTexture, fbo for texture rendering", + "fields": [ + { + "name": "id", + "type": "unsigned int", + "description": "OpenGL framebuffer object id" + }, + { + "name": "texture", + "type": "Texture", + "description": "Color buffer attachment texture" + }, + { + "name": "depth", + "type": "Texture", + "description": "Depth buffer attachment texture" + } + ] + }, + { + "name": "NPatchInfo", + "description": "NPatchInfo, n-patch layout info", + "fields": [ + { + "name": "source", + "type": "Rectangle", + "description": "Texture source rectangle" + }, + { + "name": "left", + "type": "int", + "description": "Left border offset" + }, + { + "name": "top", + "type": "int", + "description": "Top border offset" + }, + { + "name": "right", + "type": "int", + "description": "Right border offset" + }, + { + "name": "bottom", + "type": "int", + "description": "Bottom border offset" + }, + { + "name": "layout", + "type": "int", + "description": "Layout of the n-patch: 3x3, 1x3 or 3x1" + } + ] + }, + { + "name": "GlyphInfo", + "description": "GlyphInfo, font characters glyphs info", + "fields": [ + { + "name": "value", + "type": "int", + "description": "Character value (Unicode)" + }, + { + "name": "offsetX", + "type": "int", + "description": "Character offset X when drawing" + }, + { + "name": "offsetY", + "type": "int", + "description": "Character offset Y when drawing" + }, + { + "name": "advanceX", + "type": "int", + "description": "Character advance position X" + }, + { + "name": "image", + "type": "Image", + "description": "Character image data" + } + ] + }, + { + "name": "Font", + "description": "Font, font texture and GlyphInfo array data", + "fields": [ + { + "name": "baseSize", + "type": "int", + "description": "Base size (default chars height)" + }, + { + "name": "glyphCount", + "type": "int", + "description": "Number of glyph characters" + }, + { + "name": "glyphPadding", + "type": "int", + "description": "Padding around the glyph characters" + }, + { + "name": "texture", + "type": "Texture2D", + "description": "Texture atlas containing the glyphs" + }, + { + "name": "recs", + "type": "Rectangle *", + "description": "Rectangles in texture for the glyphs" + }, + { + "name": "glyphs", + "type": "GlyphInfo *", + "description": "Glyphs info data" + } + ] + }, + { + "name": "Camera3D", + "description": "Camera, defines position/orientation in 3d space", + "fields": [ + { + "name": "position", + "type": "Vector3", + "description": "Camera position" + }, + { + "name": "target", + "type": "Vector3", + "description": "Camera target it looks-at" + }, + { + "name": "up", + "type": "Vector3", + "description": "Camera up vector (rotation over its axis)" + }, + { + "name": "fovy", + "type": "float", + "description": "Camera field-of-view apperture in Y (degrees) in perspective, used as near plane width in orthographic" + }, + { + "name": "projection", + "type": "int", + "description": "Camera projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC" + } + ] + }, + { + "name": "Camera2D", + "description": "Camera2D, defines position/orientation in 2d space", + "fields": [ + { + "name": "offset", + "type": "Vector2", + "description": "Camera offset (displacement from target)" + }, + { + "name": "target", + "type": "Vector2", + "description": "Camera target (rotation and zoom origin)" + }, + { + "name": "rotation", + "type": "float", + "description": "Camera rotation in degrees" + }, + { + "name": "zoom", + "type": "float", + "description": "Camera zoom (scaling), should be 1.0f by default" + } + ] + }, + { + "name": "Mesh", + "description": "Mesh, vertex data and vao/vbo", + "fields": [ + { + "name": "vertexCount", + "type": "int", + "description": "Number of vertices stored in arrays" + }, + { + "name": "triangleCount", + "type": "int", + "description": "Number of triangles stored (indexed or not)" + }, + { + "name": "vertices", + "type": "float *", + "description": "Vertex position (XYZ - 3 components per vertex) (shader-location = 0)" + }, + { + "name": "texcoords", + "type": "float *", + "description": "Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)" + }, + { + "name": "texcoords2", + "type": "float *", + "description": "Vertex second texture coordinates (useful for lightmaps) (shader-location = 5)" + }, + { + "name": "normals", + "type": "float *", + "description": "Vertex normals (XYZ - 3 components per vertex) (shader-location = 2)" + }, + { + "name": "tangents", + "type": "float *", + "description": "Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4)" + }, + { + "name": "colors", + "type": "unsigned char *", + "description": "Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)" + }, + { + "name": "indices", + "type": "unsigned short *", + "description": "Vertex indices (in case vertex data comes indexed)" + }, + { + "name": "animVertices", + "type": "float *", + "description": "Animated vertex positions (after bones transformations)" + }, + { + "name": "animNormals", + "type": "float *", + "description": "Animated normals (after bones transformations)" + }, + { + "name": "boneIds", + "type": "unsigned char *", + "description": "Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning)" + }, + { + "name": "boneWeights", + "type": "float *", + "description": "Vertex bone weight, up to 4 bones influence by vertex (skinning)" + }, + { + "name": "vaoId", + "type": "unsigned int", + "description": "OpenGL Vertex Array Object id" + }, + { + "name": "vboId", + "type": "unsigned int *", + "description": "OpenGL Vertex Buffer Objects id (default vertex data)" + } + ] + }, + { + "name": "Shader", + "description": "Shader", + "fields": [ + { + "name": "id", + "type": "unsigned int", + "description": "Shader program id" + }, + { + "name": "locs", + "type": "int *", + "description": "Shader locations array (RL_MAX_SHADER_LOCATIONS)" + } + ] + }, + { + "name": "MaterialMap", + "description": "MaterialMap", + "fields": [ + { + "name": "texture", + "type": "Texture2D", + "description": "Material map texture" + }, + { + "name": "color", + "type": "Color", + "description": "Material map color" + }, + { + "name": "value", + "type": "float", + "description": "Material map value" + } + ] + }, + { + "name": "Material", + "description": "Material, includes shader and maps", + "fields": [ + { + "name": "shader", + "type": "Shader", + "description": "Material shader" + }, + { + "name": "maps", + "type": "MaterialMap *", + "description": "Material maps array (MAX_MATERIAL_MAPS)" + }, + { + "name": "params[4]", + "type": "float", + "description": "Material generic parameters (if required)" + } + ] + }, + { + "name": "Transform", + "description": "Transform, vectex transformation data", + "fields": [ + { + "name": "translation", + "type": "Vector3", + "description": "Translation" + }, + { + "name": "rotation", + "type": "Quaternion", + "description": "Rotation" + }, + { + "name": "scale", + "type": "Vector3", + "description": "Scale" + } + ] + }, + { + "name": "BoneInfo", + "description": "Bone, skeletal animation bone", + "fields": [ + { + "name": "name[32]", + "type": "char", + "description": "Bone name" + }, + { + "name": "parent", + "type": "int", + "description": "Bone parent" + } + ] + }, + { + "name": "Model", + "description": "Model, meshes, materials and animation data", + "fields": [ + { + "name": "transform", + "type": "Matrix", + "description": "Local transform matrix" + }, + { + "name": "meshCount", + "type": "int", + "description": "Number of meshes" + }, + { + "name": "materialCount", + "type": "int", + "description": "Number of materials" + }, + { + "name": "meshes", + "type": "Mesh *", + "description": "Meshes array" + }, + { + "name": "materials", + "type": "Material *", + "description": "Materials array" + }, + { + "name": "meshMaterial", + "type": "int *", + "description": "Mesh material number" + }, + { + "name": "boneCount", + "type": "int", + "description": "Number of bones" + }, + { + "name": "bones", + "type": "BoneInfo *", + "description": "Bones information (skeleton)" + }, + { + "name": "bindPose", + "type": "Transform *", + "description": "Bones base transformation (pose)" + } + ] + }, + { + "name": "ModelAnimation", + "description": "ModelAnimation", + "fields": [ + { + "name": "boneCount", + "type": "int", + "description": "Number of bones" + }, + { + "name": "frameCount", + "type": "int", + "description": "Number of animation frames" + }, + { + "name": "bones", + "type": "BoneInfo *", + "description": "Bones information (skeleton)" + }, + { + "name": "framePoses", + "type": "Transform **", + "description": "Poses array by frame" + } + ] + }, + { + "name": "Ray", + "description": "Ray, ray for raycasting", + "fields": [ + { + "name": "position", + "type": "Vector3", + "description": "Ray position (origin)" + }, + { + "name": "direction", + "type": "Vector3", + "description": "Ray direction" + } + ] + }, + { + "name": "RayCollision", + "description": "RayCollision, ray hit information", + "fields": [ + { + "name": "hit", + "type": "bool", + "description": "Did the ray hit something?" + }, + { + "name": "distance", + "type": "float", + "description": "Distance to nearest hit" + }, + { + "name": "point", + "type": "Vector3", + "description": "Point of nearest hit" + }, + { + "name": "normal", + "type": "Vector3", + "description": "Surface normal of hit" + } + ] + }, + { + "name": "BoundingBox", + "description": "BoundingBox", + "fields": [ + { + "name": "min", + "type": "Vector3", + "description": "Minimum vertex box-corner" + }, + { + "name": "max", + "type": "Vector3", + "description": "Maximum vertex box-corner" + } + ] + }, + { + "name": "Wave", + "description": "Wave, audio wave data", + "fields": [ + { + "name": "frameCount", + "type": "unsigned int", + "description": "Total number of frames (considering channels)" + }, + { + "name": "sampleRate", + "type": "unsigned int", + "description": "Frequency (samples per second)" + }, + { + "name": "sampleSize", + "type": "unsigned int", + "description": "Bit depth (bits per sample): 8, 16, 32 (24 not supported)" + }, + { + "name": "channels", + "type": "unsigned int", + "description": "Number of channels (1-mono, 2-stereo, ...)" + }, + { + "name": "data", + "type": "void *", + "description": "Buffer data pointer" + } + ] + }, + { + "name": "AudioStream", + "description": "AudioStream, custom audio stream", + "fields": [ + { + "name": "buffer", + "type": "rAudioBuffer *", + "description": "Pointer to internal data used by the audio system" + }, + { + "name": "sampleRate", + "type": "unsigned int", + "description": "Frequency (samples per second)" + }, + { + "name": "sampleSize", + "type": "unsigned int", + "description": "Bit depth (bits per sample): 8, 16, 32 (24 not supported)" + }, + { + "name": "channels", + "type": "unsigned int", + "description": "Number of channels (1-mono, 2-stereo, ...)" + } + ] + }, + { + "name": "Sound", + "description": "Sound", + "fields": [ + { + "name": "stream", + "type": "AudioStream", + "description": "Audio stream" + }, + { + "name": "frameCount", + "type": "unsigned int", + "description": "Total number of frames (considering channels)" + } + ] + }, + { + "name": "Music", + "description": "Music, audio stream, anything longer than ~10 seconds should be streamed", + "fields": [ + { + "name": "stream", + "type": "AudioStream", + "description": "Audio stream" + }, + { + "name": "frameCount", + "type": "unsigned int", + "description": "Total number of frames (considering channels)" + }, + { + "name": "looping", + "type": "bool", + "description": "Music looping enable" + }, + { + "name": "ctxType", + "type": "int", + "description": "Type of music context (audio filetype)" + }, + { + "name": "ctxData", + "type": "void *", + "description": "Audio context data, depends on type" + } + ] + }, + { + "name": "VrDeviceInfo", + "description": "VrDeviceInfo, Head-Mounted-Display device parameters", + "fields": [ + { + "name": "hResolution", + "type": "int", + "description": "Horizontal resolution in pixels" + }, + { + "name": "vResolution", + "type": "int", + "description": "Vertical resolution in pixels" + }, + { + "name": "hScreenSize", + "type": "float", + "description": "Horizontal size in meters" + }, + { + "name": "vScreenSize", + "type": "float", + "description": "Vertical size in meters" + }, + { + "name": "vScreenCenter", + "type": "float", + "description": "Screen center in meters" + }, + { + "name": "eyeToScreenDistance", + "type": "float", + "description": "Distance between eye and display in meters" + }, + { + "name": "lensSeparationDistance", + "type": "float", + "description": "Lens separation distance in meters" + }, + { + "name": "interpupillaryDistance", + "type": "float", + "description": "IPD (distance between pupils) in meters" + }, + { + "name": "lensDistortionValues[4]", + "type": "float", + "description": "Lens distortion constant parameters" + }, + { + "name": "chromaAbCorrection[4]", + "type": "float", + "description": "Chromatic aberration correction parameters" + } + ] + }, + { + "name": "VrStereoConfig", + "description": "VrStereoConfig, VR stereo rendering configuration for simulator", + "fields": [ + { + "name": "projection[2]", + "type": "Matrix", + "description": "VR projection matrices (per eye)" + }, + { + "name": "viewOffset[2]", + "type": "Matrix", + "description": "VR view offset matrices (per eye)" + }, + { + "name": "leftLensCenter[2]", + "type": "float", + "description": "VR left lens center" + }, + { + "name": "rightLensCenter[2]", + "type": "float", + "description": "VR right lens center" + }, + { + "name": "leftScreenCenter[2]", + "type": "float", + "description": "VR left screen center" + }, + { + "name": "rightScreenCenter[2]", + "type": "float", + "description": "VR right screen center" + }, + { + "name": "scale[2]", + "type": "float", + "description": "VR distortion scale" + }, + { + "name": "scaleIn[2]", + "type": "float", + "description": "VR distortion scale in" + } + ] + } + ], + "enums": [ + { + "name": "ConfigFlags", + "description": "System/Window config flags", + "values": [ + { + "name": "FLAG_VSYNC_HINT", + "value": 64, + "description": "Set to try enabling V-Sync on GPU" + }, + { + "name": "FLAG_FULLSCREEN_MODE", + "value": 2, + "description": "Set to run program in fullscreen" + }, + { + "name": "FLAG_WINDOW_RESIZABLE", + "value": 4, + "description": "Set to allow resizable window" + }, + { + "name": "FLAG_WINDOW_UNDECORATED", + "value": 8, + "description": "Set to disable window decoration (frame and buttons)" + }, + { + "name": "FLAG_WINDOW_HIDDEN", + "value": 128, + "description": "Set to hide window" + }, + { + "name": "FLAG_WINDOW_MINIMIZED", + "value": 512, + "description": "Set to minimize window (iconify)" + }, + { + "name": "FLAG_WINDOW_MAXIMIZED", + "value": 1024, + "description": "Set to maximize window (expanded to monitor)" + }, + { + "name": "FLAG_WINDOW_UNFOCUSED", + "value": 2048, + "description": "Set to window non focused" + }, + { + "name": "FLAG_WINDOW_TOPMOST", + "value": 4096, + "description": "Set to window always on top" + }, + { + "name": "FLAG_WINDOW_ALWAYS_RUN", + "value": 256, + "description": "Set to allow windows running while minimized" + }, + { + "name": "FLAG_WINDOW_TRANSPARENT", + "value": 16, + "description": "Set to allow transparent framebuffer" + }, + { + "name": "FLAG_WINDOW_HIGHDPI", + "value": 8192, + "description": "Set to support HighDPI" + }, + { + "name": "FLAG_MSAA_4X_HINT", + "value": 32, + "description": "Set to try enabling MSAA 4X" + }, + { + "name": "FLAG_INTERLACED_HINT", + "value": 65536, + "description": "Set to try enabling interlaced video format (for V3D)" + } + ] + }, + { + "name": "TraceLogLevel", + "description": "Trace log level", + "values": [ + { + "name": "LOG_ALL", + "value": 0, + "description": "Display all logs" + }, + { + "name": "LOG_TRACE", + "value": 1, + "description": "Trace logging, intended for internal use only" + }, + { + "name": "LOG_DEBUG", + "value": 2, + "description": "Debug logging, used for internal debugging, it should be disabled on release builds" + }, + { + "name": "LOG_INFO", + "value": 3, + "description": "Info logging, used for program execution info" + }, + { + "name": "LOG_WARNING", + "value": 4, + "description": "Warning logging, used on recoverable failures" + }, + { + "name": "LOG_ERROR", + "value": 5, + "description": "Error logging, used on unrecoverable failures" + }, + { + "name": "LOG_FATAL", + "value": 6, + "description": "Fatal logging, used to abort program: exit(EXIT_FAILURE)" + }, + { + "name": "LOG_NONE", + "value": 7, + "description": "Disable logging" + } + ] + }, + { + "name": "KeyboardKey", + "description": "Keyboard keys (US keyboard layout)", + "values": [ + { + "name": "KEY_NULL", + "value": 0, + "description": "Key: NULL, used for no key pressed" + }, + { + "name": "KEY_APOSTROPHE", + "value": 39, + "description": "Key: '" + }, + { + "name": "KEY_COMMA", + "value": 44, + "description": "Key: ," + }, + { + "name": "KEY_MINUS", + "value": 45, + "description": "Key: -" + }, + { + "name": "KEY_PERIOD", + "value": 46, + "description": "Key: ." + }, + { + "name": "KEY_SLASH", + "value": 47, + "description": "Key: /" + }, + { + "name": "KEY_ZERO", + "value": 48, + "description": "Key: 0" + }, + { + "name": "KEY_ONE", + "value": 49, + "description": "Key: 1" + }, + { + "name": "KEY_TWO", + "value": 50, + "description": "Key: 2" + }, + { + "name": "KEY_THREE", + "value": 51, + "description": "Key: 3" + }, + { + "name": "KEY_FOUR", + "value": 52, + "description": "Key: 4" + }, + { + "name": "KEY_FIVE", + "value": 53, + "description": "Key: 5" + }, + { + "name": "KEY_SIX", + "value": 54, + "description": "Key: 6" + }, + { + "name": "KEY_SEVEN", + "value": 55, + "description": "Key: 7" + }, + { + "name": "KEY_EIGHT", + "value": 56, + "description": "Key: 8" + }, + { + "name": "KEY_NINE", + "value": 57, + "description": "Key: 9" + }, + { + "name": "KEY_SEMICOLON", + "value": 59, + "description": "Key: ;" + }, + { + "name": "KEY_EQUAL", + "value": 61, + "description": "Key: =" + }, + { + "name": "KEY_A", + "value": 65, + "description": "Key: A | a" + }, + { + "name": "KEY_B", + "value": 66, + "description": "Key: B | b" + }, + { + "name": "KEY_C", + "value": 67, + "description": "Key: C | c" + }, + { + "name": "KEY_D", + "value": 68, + "description": "Key: D | d" + }, + { + "name": "KEY_E", + "value": 69, + "description": "Key: E | e" + }, + { + "name": "KEY_F", + "value": 70, + "description": "Key: F | f" + }, + { + "name": "KEY_G", + "value": 71, + "description": "Key: G | g" + }, + { + "name": "KEY_H", + "value": 72, + "description": "Key: H | h" + }, + { + "name": "KEY_I", + "value": 73, + "description": "Key: I | i" + }, + { + "name": "KEY_J", + "value": 74, + "description": "Key: J | j" + }, + { + "name": "KEY_K", + "value": 75, + "description": "Key: K | k" + }, + { + "name": "KEY_L", + "value": 76, + "description": "Key: L | l" + }, + { + "name": "KEY_M", + "value": 77, + "description": "Key: M | m" + }, + { + "name": "KEY_N", + "value": 78, + "description": "Key: N | n" + }, + { + "name": "KEY_O", + "value": 79, + "description": "Key: O | o" + }, + { + "name": "KEY_P", + "value": 80, + "description": "Key: P | p" + }, + { + "name": "KEY_Q", + "value": 81, + "description": "Key: Q | q" + }, + { + "name": "KEY_R", + "value": 82, + "description": "Key: R | r" + }, + { + "name": "KEY_S", + "value": 83, + "description": "Key: S | s" + }, + { + "name": "KEY_T", + "value": 84, + "description": "Key: T | t" + }, + { + "name": "KEY_U", + "value": 85, + "description": "Key: U | u" + }, + { + "name": "KEY_V", + "value": 86, + "description": "Key: V | v" + }, + { + "name": "KEY_W", + "value": 87, + "description": "Key: W | w" + }, + { + "name": "KEY_X", + "value": 88, + "description": "Key: X | x" + }, + { + "name": "KEY_Y", + "value": 89, + "description": "Key: Y | y" + }, + { + "name": "KEY_Z", + "value": 90, + "description": "Key: Z | z" + }, + { + "name": "KEY_LEFT_BRACKET", + "value": 91, + "description": "Key: [" + }, + { + "name": "KEY_BACKSLASH", + "value": 92, + "description": "Key: '\\'" + }, + { + "name": "KEY_RIGHT_BRACKET", + "value": 93, + "description": "Key: ]" + }, + { + "name": "KEY_GRAVE", + "value": 96, + "description": "Key: `" + }, + { + "name": "KEY_SPACE", + "value": 32, + "description": "Key: Space" + }, + { + "name": "KEY_ESCAPE", + "value": 256, + "description": "Key: Esc" + }, + { + "name": "KEY_ENTER", + "value": 257, + "description": "Key: Enter" + }, + { + "name": "KEY_TAB", + "value": 258, + "description": "Key: Tab" + }, + { + "name": "KEY_BACKSPACE", + "value": 259, + "description": "Key: Backspace" + }, + { + "name": "KEY_INSERT", + "value": 260, + "description": "Key: Ins" + }, + { + "name": "KEY_DELETE", + "value": 261, + "description": "Key: Del" + }, + { + "name": "KEY_RIGHT", + "value": 262, + "description": "Key: Cursor right" + }, + { + "name": "KEY_LEFT", + "value": 263, + "description": "Key: Cursor left" + }, + { + "name": "KEY_DOWN", + "value": 264, + "description": "Key: Cursor down" + }, + { + "name": "KEY_UP", + "value": 265, + "description": "Key: Cursor up" + }, + { + "name": "KEY_PAGE_UP", + "value": 266, + "description": "Key: Page up" + }, + { + "name": "KEY_PAGE_DOWN", + "value": 267, + "description": "Key: Page down" + }, + { + "name": "KEY_HOME", + "value": 268, + "description": "Key: Home" + }, + { + "name": "KEY_END", + "value": 269, + "description": "Key: End" + }, + { + "name": "KEY_CAPS_LOCK", + "value": 280, + "description": "Key: Caps lock" + }, + { + "name": "KEY_SCROLL_LOCK", + "value": 281, + "description": "Key: Scroll down" + }, + { + "name": "KEY_NUM_LOCK", + "value": 282, + "description": "Key: Num lock" + }, + { + "name": "KEY_PRINT_SCREEN", + "value": 283, + "description": "Key: Print screen" + }, + { + "name": "KEY_PAUSE", + "value": 284, + "description": "Key: Pause" + }, + { + "name": "KEY_F1", + "value": 290, + "description": "Key: F1" + }, + { + "name": "KEY_F2", + "value": 291, + "description": "Key: F2" + }, + { + "name": "KEY_F3", + "value": 292, + "description": "Key: F3" + }, + { + "name": "KEY_F4", + "value": 293, + "description": "Key: F4" + }, + { + "name": "KEY_F5", + "value": 294, + "description": "Key: F5" + }, + { + "name": "KEY_F6", + "value": 295, + "description": "Key: F6" + }, + { + "name": "KEY_F7", + "value": 296, + "description": "Key: F7" + }, + { + "name": "KEY_F8", + "value": 297, + "description": "Key: F8" + }, + { + "name": "KEY_F9", + "value": 298, + "description": "Key: F9" + }, + { + "name": "KEY_F10", + "value": 299, + "description": "Key: F10" + }, + { + "name": "KEY_F11", + "value": 300, + "description": "Key: F11" + }, + { + "name": "KEY_F12", + "value": 301, + "description": "Key: F12" + }, + { + "name": "KEY_LEFT_SHIFT", + "value": 340, + "description": "Key: Shift left" + }, + { + "name": "KEY_LEFT_CONTROL", + "value": 341, + "description": "Key: Control left" + }, + { + "name": "KEY_LEFT_ALT", + "value": 342, + "description": "Key: Alt left" + }, + { + "name": "KEY_LEFT_SUPER", + "value": 343, + "description": "Key: Super left" + }, + { + "name": "KEY_RIGHT_SHIFT", + "value": 344, + "description": "Key: Shift right" + }, + { + "name": "KEY_RIGHT_CONTROL", + "value": 345, + "description": "Key: Control right" + }, + { + "name": "KEY_RIGHT_ALT", + "value": 346, + "description": "Key: Alt right" + }, + { + "name": "KEY_RIGHT_SUPER", + "value": 347, + "description": "Key: Super right" + }, + { + "name": "KEY_KB_MENU", + "value": 348, + "description": "Key: KB menu" + }, + { + "name": "KEY_KP_0", + "value": 320, + "description": "Key: Keypad 0" + }, + { + "name": "KEY_KP_1", + "value": 321, + "description": "Key: Keypad 1" + }, + { + "name": "KEY_KP_2", + "value": 322, + "description": "Key: Keypad 2" + }, + { + "name": "KEY_KP_3", + "value": 323, + "description": "Key: Keypad 3" + }, + { + "name": "KEY_KP_4", + "value": 324, + "description": "Key: Keypad 4" + }, + { + "name": "KEY_KP_5", + "value": 325, + "description": "Key: Keypad 5" + }, + { + "name": "KEY_KP_6", + "value": 326, + "description": "Key: Keypad 6" + }, + { + "name": "KEY_KP_7", + "value": 327, + "description": "Key: Keypad 7" + }, + { + "name": "KEY_KP_8", + "value": 328, + "description": "Key: Keypad 8" + }, + { + "name": "KEY_KP_9", + "value": 329, + "description": "Key: Keypad 9" + }, + { + "name": "KEY_KP_DECIMAL", + "value": 330, + "description": "Key: Keypad ." + }, + { + "name": "KEY_KP_DIVIDE", + "value": 331, + "description": "Key: Keypad /" + }, + { + "name": "KEY_KP_MULTIPLY", + "value": 332, + "description": "Key: Keypad *" + }, + { + "name": "KEY_KP_SUBTRACT", + "value": 333, + "description": "Key: Keypad -" + }, + { + "name": "KEY_KP_ADD", + "value": 334, + "description": "Key: Keypad +" + }, + { + "name": "KEY_KP_ENTER", + "value": 335, + "description": "Key: Keypad Enter" + }, + { + "name": "KEY_KP_EQUAL", + "value": 336, + "description": "Key: Keypad =" + }, + { + "name": "KEY_BACK", + "value": 4, + "description": "Key: Android back button" + }, + { + "name": "KEY_MENU", + "value": 82, + "description": "Key: Android menu button" + }, + { + "name": "KEY_VOLUME_UP", + "value": 24, + "description": "Key: Android volume up button" + }, + { + "name": "KEY_VOLUME_DOWN", + "value": 25, + "description": "Key: Android volume down button" + } + ] + }, + { + "name": "MouseButton", + "description": "Mouse buttons", + "values": [ + { + "name": "MOUSE_BUTTON_LEFT", + "value": 0, + "description": "Mouse button left" + }, + { + "name": "MOUSE_BUTTON_RIGHT", + "value": 1, + "description": "Mouse button right" + }, + { + "name": "MOUSE_BUTTON_MIDDLE", + "value": 2, + "description": "Mouse button middle (pressed wheel)" + }, + { + "name": "MOUSE_BUTTON_SIDE", + "value": 3, + "description": "Mouse button side (advanced mouse device)" + }, + { + "name": "MOUSE_BUTTON_EXTRA", + "value": 4, + "description": "Mouse button extra (advanced mouse device)" + }, + { + "name": "MOUSE_BUTTON_FORWARD", + "value": 5, + "description": "Mouse button fordward (advanced mouse device)" + }, + { + "name": "MOUSE_BUTTON_BACK", + "value": 6, + "description": "Mouse button back (advanced mouse device)" + } + ] + }, + { + "name": "MouseCursor", + "description": "Mouse cursor", + "values": [ + { + "name": "MOUSE_CURSOR_DEFAULT", + "value": 0, + "description": "Default pointer shape" + }, + { + "name": "MOUSE_CURSOR_ARROW", + "value": 1, + "description": "Arrow shape" + }, + { + "name": "MOUSE_CURSOR_IBEAM", + "value": 2, + "description": "Text writing cursor shape" + }, + { + "name": "MOUSE_CURSOR_CROSSHAIR", + "value": 3, + "description": "Cross shape" + }, + { + "name": "MOUSE_CURSOR_POINTING_HAND", + "value": 4, + "description": "Pointing hand cursor" + }, + { + "name": "MOUSE_CURSOR_RESIZE_EW", + "value": 5, + "description": "Horizontal resize/move arrow shape" + }, + { + "name": "MOUSE_CURSOR_RESIZE_NS", + "value": 6, + "description": "Vertical resize/move arrow shape" + }, + { + "name": "MOUSE_CURSOR_RESIZE_NWSE", + "value": 7, + "description": "Top-left to bottom-right diagonal resize/move arrow shape" + }, + { + "name": "MOUSE_CURSOR_RESIZE_NESW", + "value": 8, + "description": "The top-right to bottom-left diagonal resize/move arrow shape" + }, + { + "name": "MOUSE_CURSOR_RESIZE_ALL", + "value": 9, + "description": "The omni-directional resize/move cursor shape" + }, + { + "name": "MOUSE_CURSOR_NOT_ALLOWED", + "value": 10, + "description": "The operation-not-allowed shape" + } + ] + }, + { + "name": "GamepadButton", + "description": "Gamepad buttons", + "values": [ + { + "name": "GAMEPAD_BUTTON_UNKNOWN", + "value": 0, + "description": "Unknown button, just for error checking" + }, + { + "name": "GAMEPAD_BUTTON_LEFT_FACE_UP", + "value": 1, + "description": "Gamepad left DPAD up button" + }, + { + "name": "GAMEPAD_BUTTON_LEFT_FACE_RIGHT", + "value": 2, + "description": "Gamepad left DPAD right button" + }, + { + "name": "GAMEPAD_BUTTON_LEFT_FACE_DOWN", + "value": 3, + "description": "Gamepad left DPAD down button" + }, + { + "name": "GAMEPAD_BUTTON_LEFT_FACE_LEFT", + "value": 4, + "description": "Gamepad left DPAD left button" + }, + { + "name": "GAMEPAD_BUTTON_RIGHT_FACE_UP", + "value": 5, + "description": "Gamepad right button up (i.e. PS3: Triangle, Xbox: Y)" + }, + { + "name": "GAMEPAD_BUTTON_RIGHT_FACE_RIGHT", + "value": 6, + "description": "Gamepad right button right (i.e. PS3: Square, Xbox: X)" + }, + { + "name": "GAMEPAD_BUTTON_RIGHT_FACE_DOWN", + "value": 7, + "description": "Gamepad right button down (i.e. PS3: Cross, Xbox: A)" + }, + { + "name": "GAMEPAD_BUTTON_RIGHT_FACE_LEFT", + "value": 8, + "description": "Gamepad right button left (i.e. PS3: Circle, Xbox: B)" + }, + { + "name": "GAMEPAD_BUTTON_LEFT_TRIGGER_1", + "value": 9, + "description": "Gamepad top/back trigger left (first), it could be a trailing button" + }, + { + "name": "GAMEPAD_BUTTON_LEFT_TRIGGER_2", + "value": 10, + "description": "Gamepad top/back trigger left (second), it could be a trailing button" + }, + { + "name": "GAMEPAD_BUTTON_RIGHT_TRIGGER_1", + "value": 11, + "description": "Gamepad top/back trigger right (one), it could be a trailing button" + }, + { + "name": "GAMEPAD_BUTTON_RIGHT_TRIGGER_2", + "value": 12, + "description": "Gamepad top/back trigger right (second), it could be a trailing button" + }, + { + "name": "GAMEPAD_BUTTON_MIDDLE_LEFT", + "value": 13, + "description": "Gamepad center buttons, left one (i.e. PS3: Select)" + }, + { + "name": "GAMEPAD_BUTTON_MIDDLE", + "value": 14, + "description": "Gamepad center buttons, middle one (i.e. PS3: PS, Xbox: XBOX)" + }, + { + "name": "GAMEPAD_BUTTON_MIDDLE_RIGHT", + "value": 15, + "description": "Gamepad center buttons, right one (i.e. PS3: Start)" + }, + { + "name": "GAMEPAD_BUTTON_LEFT_THUMB", + "value": 16, + "description": "Gamepad joystick pressed button left" + }, + { + "name": "GAMEPAD_BUTTON_RIGHT_THUMB", + "value": 17, + "description": "Gamepad joystick pressed button right" + } + ] + }, + { + "name": "GamepadAxis", + "description": "Gamepad axis", + "values": [ + { + "name": "GAMEPAD_AXIS_LEFT_X", + "value": 0, + "description": "Gamepad left stick X axis" + }, + { + "name": "GAMEPAD_AXIS_LEFT_Y", + "value": 1, + "description": "Gamepad left stick Y axis" + }, + { + "name": "GAMEPAD_AXIS_RIGHT_X", + "value": 2, + "description": "Gamepad right stick X axis" + }, + { + "name": "GAMEPAD_AXIS_RIGHT_Y", + "value": 3, + "description": "Gamepad right stick Y axis" + }, + { + "name": "GAMEPAD_AXIS_LEFT_TRIGGER", + "value": 4, + "description": "Gamepad back trigger left, pressure level: [1..-1]" + }, + { + "name": "GAMEPAD_AXIS_RIGHT_TRIGGER", + "value": 5, + "description": "Gamepad back trigger right, pressure level: [1..-1]" + } + ] + }, + { + "name": "MaterialMapIndex", + "description": "Material map index", + "values": [ + { + "name": "MATERIAL_MAP_ALBEDO", + "value": 0, + "description": "Albedo material (same as: MATERIAL_MAP_DIFFUSE)" + }, + { + "name": "MATERIAL_MAP_METALNESS", + "value": 1, + "description": "Metalness material (same as: MATERIAL_MAP_SPECULAR)" + }, + { + "name": "MATERIAL_MAP_NORMAL", + "value": 2, + "description": "Normal material" + }, + { + "name": "MATERIAL_MAP_ROUGHNESS", + "value": 3, + "description": "Roughness material" + }, + { + "name": "MATERIAL_MAP_OCCLUSION", + "value": 4, + "description": "Ambient occlusion material" + }, + { + "name": "MATERIAL_MAP_EMISSION", + "value": 5, + "description": "Emission material" + }, + { + "name": "MATERIAL_MAP_HEIGHT", + "value": 6, + "description": "Heightmap material" + }, + { + "name": "MATERIAL_MAP_CUBEMAP", + "value": 7, + "description": "Cubemap material (NOTE: Uses GL_TEXTURE_CUBE_MAP)" + }, + { + "name": "MATERIAL_MAP_IRRADIANCE", + "value": 8, + "description": "Irradiance material (NOTE: Uses GL_TEXTURE_CUBE_MAP)" + }, + { + "name": "MATERIAL_MAP_PREFILTER", + "value": 9, + "description": "Prefilter material (NOTE: Uses GL_TEXTURE_CUBE_MAP)" + }, + { + "name": "MATERIAL_MAP_BRDF", + "value": 10, + "description": "Brdf material" + } + ] + }, + { + "name": "ShaderLocationIndex", + "description": "Shader location index", + "values": [ + { + "name": "SHADER_LOC_VERTEX_POSITION", + "value": 0, + "description": "Shader location: vertex attribute: position" + }, + { + "name": "SHADER_LOC_VERTEX_TEXCOORD01", + "value": 1, + "description": "Shader location: vertex attribute: texcoord01" + }, + { + "name": "SHADER_LOC_VERTEX_TEXCOORD02", + "value": 2, + "description": "Shader location: vertex attribute: texcoord02" + }, + { + "name": "SHADER_LOC_VERTEX_NORMAL", + "value": 3, + "description": "Shader location: vertex attribute: normal" + }, + { + "name": "SHADER_LOC_VERTEX_TANGENT", + "value": 4, + "description": "Shader location: vertex attribute: tangent" + }, + { + "name": "SHADER_LOC_VERTEX_COLOR", + "value": 5, + "description": "Shader location: vertex attribute: color" + }, + { + "name": "SHADER_LOC_MATRIX_MVP", + "value": 6, + "description": "Shader location: matrix uniform: model-view-projection" + }, + { + "name": "SHADER_LOC_MATRIX_VIEW", + "value": 7, + "description": "Shader location: matrix uniform: view (camera transform)" + }, + { + "name": "SHADER_LOC_MATRIX_PROJECTION", + "value": 8, + "description": "Shader location: matrix uniform: projection" + }, + { + "name": "SHADER_LOC_MATRIX_MODEL", + "value": 9, + "description": "Shader location: matrix uniform: model (transform)" + }, + { + "name": "SHADER_LOC_MATRIX_NORMAL", + "value": 10, + "description": "Shader location: matrix uniform: normal" + }, + { + "name": "SHADER_LOC_VECTOR_VIEW", + "value": 11, + "description": "Shader location: vector uniform: view" + }, + { + "name": "SHADER_LOC_COLOR_DIFFUSE", + "value": 12, + "description": "Shader location: vector uniform: diffuse color" + }, + { + "name": "SHADER_LOC_COLOR_SPECULAR", + "value": 13, + "description": "Shader location: vector uniform: specular color" + }, + { + "name": "SHADER_LOC_COLOR_AMBIENT", + "value": 14, + "description": "Shader location: vector uniform: ambient color" + }, + { + "name": "SHADER_LOC_MAP_ALBEDO", + "value": 15, + "description": "Shader location: sampler2d texture: albedo (same as: SHADER_LOC_MAP_DIFFUSE)" + }, + { + "name": "SHADER_LOC_MAP_METALNESS", + "value": 16, + "description": "Shader location: sampler2d texture: metalness (same as: SHADER_LOC_MAP_SPECULAR)" + }, + { + "name": "SHADER_LOC_MAP_NORMAL", + "value": 17, + "description": "Shader location: sampler2d texture: normal" + }, + { + "name": "SHADER_LOC_MAP_ROUGHNESS", + "value": 18, + "description": "Shader location: sampler2d texture: roughness" + }, + { + "name": "SHADER_LOC_MAP_OCCLUSION", + "value": 19, + "description": "Shader location: sampler2d texture: occlusion" + }, + { + "name": "SHADER_LOC_MAP_EMISSION", + "value": 20, + "description": "Shader location: sampler2d texture: emission" + }, + { + "name": "SHADER_LOC_MAP_HEIGHT", + "value": 21, + "description": "Shader location: sampler2d texture: height" + }, + { + "name": "SHADER_LOC_MAP_CUBEMAP", + "value": 22, + "description": "Shader location: samplerCube texture: cubemap" + }, + { + "name": "SHADER_LOC_MAP_IRRADIANCE", + "value": 23, + "description": "Shader location: samplerCube texture: irradiance" + }, + { + "name": "SHADER_LOC_MAP_PREFILTER", + "value": 24, + "description": "Shader location: samplerCube texture: prefilter" + }, + { + "name": "SHADER_LOC_MAP_BRDF", + "value": 25, + "description": "Shader location: sampler2d texture: brdf" + } + ] + }, + { + "name": "ShaderUniformDataType", + "description": "Shader uniform data type", + "values": [ + { + "name": "SHADER_UNIFORM_FLOAT", + "value": 0, + "description": "Shader uniform type: float" + }, + { + "name": "SHADER_UNIFORM_VEC2", + "value": 1, + "description": "Shader uniform type: vec2 (2 float)" + }, + { + "name": "SHADER_UNIFORM_VEC3", + "value": 2, + "description": "Shader uniform type: vec3 (3 float)" + }, + { + "name": "SHADER_UNIFORM_VEC4", + "value": 3, + "description": "Shader uniform type: vec4 (4 float)" + }, + { + "name": "SHADER_UNIFORM_INT", + "value": 4, + "description": "Shader uniform type: int" + }, + { + "name": "SHADER_UNIFORM_IVEC2", + "value": 5, + "description": "Shader uniform type: ivec2 (2 int)" + }, + { + "name": "SHADER_UNIFORM_IVEC3", + "value": 6, + "description": "Shader uniform type: ivec3 (3 int)" + }, + { + "name": "SHADER_UNIFORM_IVEC4", + "value": 7, + "description": "Shader uniform type: ivec4 (4 int)" + }, + { + "name": "SHADER_UNIFORM_SAMPLER2D", + "value": 8, + "description": "Shader uniform type: sampler2d" + } + ] + }, + { + "name": "ShaderAttributeDataType", + "description": "Shader attribute data types", + "values": [ + { + "name": "SHADER_ATTRIB_FLOAT", + "value": 0, + "description": "Shader attribute type: float" + }, + { + "name": "SHADER_ATTRIB_VEC2", + "value": 1, + "description": "Shader attribute type: vec2 (2 float)" + }, + { + "name": "SHADER_ATTRIB_VEC3", + "value": 2, + "description": "Shader attribute type: vec3 (3 float)" + }, + { + "name": "SHADER_ATTRIB_VEC4", + "value": 3, + "description": "Shader attribute type: vec4 (4 float)" + } + ] + }, + { + "name": "PixelFormat", + "description": "Pixel formats", + "values": [ + { + "name": "PIXELFORMAT_UNCOMPRESSED_GRAYSCALE", + "value": 1, + "description": "8 bit per pixel (no alpha)" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA", + "value": 2, + "description": "8*2 bpp (2 channels)" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_R5G6B5", + "value": 3, + "description": "16 bpp" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_R8G8B8", + "value": 4, + "description": "24 bpp" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_R5G5B5A1", + "value": 5, + "description": "16 bpp (1 bit alpha)" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_R4G4B4A4", + "value": 6, + "description": "16 bpp (4 bit alpha)" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_R8G8B8A8", + "value": 7, + "description": "32 bpp" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_R32", + "value": 8, + "description": "32 bpp (1 channel - float)" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_R32G32B32", + "value": 9, + "description": "32*3 bpp (3 channels - float)" + }, + { + "name": "PIXELFORMAT_UNCOMPRESSED_R32G32B32A32", + "value": 10, + "description": "32*4 bpp (4 channels - float)" + }, + { + "name": "PIXELFORMAT_COMPRESSED_DXT1_RGB", + "value": 11, + "description": "4 bpp (no alpha)" + }, + { + "name": "PIXELFORMAT_COMPRESSED_DXT1_RGBA", + "value": 12, + "description": "4 bpp (1 bit alpha)" + }, + { + "name": "PIXELFORMAT_COMPRESSED_DXT3_RGBA", + "value": 13, + "description": "8 bpp" + }, + { + "name": "PIXELFORMAT_COMPRESSED_DXT5_RGBA", + "value": 14, + "description": "8 bpp" + }, + { + "name": "PIXELFORMAT_COMPRESSED_ETC1_RGB", + "value": 15, + "description": "4 bpp" + }, + { + "name": "PIXELFORMAT_COMPRESSED_ETC2_RGB", + "value": 16, + "description": "4 bpp" + }, + { + "name": "PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA", + "value": 17, + "description": "8 bpp" + }, + { + "name": "PIXELFORMAT_COMPRESSED_PVRT_RGB", + "value": 18, + "description": "4 bpp" + }, + { + "name": "PIXELFORMAT_COMPRESSED_PVRT_RGBA", + "value": 19, + "description": "4 bpp" + }, + { + "name": "PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA", + "value": 20, + "description": "8 bpp" + }, + { + "name": "PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA", + "value": 21, + "description": "2 bpp" + } + ] + }, + { + "name": "TextureFilter", + "description": "Texture parameters: filter mode", + "values": [ + { + "name": "TEXTURE_FILTER_POINT", + "value": 0, + "description": "No filter, just pixel approximation" + }, + { + "name": "TEXTURE_FILTER_BILINEAR", + "value": 1, + "description": "Linear filtering" + }, + { + "name": "TEXTURE_FILTER_TRILINEAR", + "value": 2, + "description": "Trilinear filtering (linear with mipmaps)" + }, + { + "name": "TEXTURE_FILTER_ANISOTROPIC_4X", + "value": 3, + "description": "Anisotropic filtering 4x" + }, + { + "name": "TEXTURE_FILTER_ANISOTROPIC_8X", + "value": 4, + "description": "Anisotropic filtering 8x" + }, + { + "name": "TEXTURE_FILTER_ANISOTROPIC_16X", + "value": 5, + "description": "Anisotropic filtering 16x" + } + ] + }, + { + "name": "TextureWrap", + "description": "Texture parameters: wrap mode", + "values": [ + { + "name": "TEXTURE_WRAP_REPEAT", + "value": 0, + "description": "Repeats texture in tiled mode" + }, + { + "name": "TEXTURE_WRAP_CLAMP", + "value": 1, + "description": "Clamps texture to edge pixel in tiled mode" + }, + { + "name": "TEXTURE_WRAP_MIRROR_REPEAT", + "value": 2, + "description": "Mirrors and repeats the texture in tiled mode" + }, + { + "name": "TEXTURE_WRAP_MIRROR_CLAMP", + "value": 3, + "description": "Mirrors and clamps to border the texture in tiled mode" + } + ] + }, + { + "name": "CubemapLayout", + "description": "Cubemap layouts", + "values": [ + { + "name": "CUBEMAP_LAYOUT_AUTO_DETECT", + "value": 0, + "description": "Automatically detect layout type" + }, + { + "name": "CUBEMAP_LAYOUT_LINE_VERTICAL", + "value": 1, + "description": "Layout is defined by a vertical line with faces" + }, + { + "name": "CUBEMAP_LAYOUT_LINE_HORIZONTAL", + "value": 2, + "description": "Layout is defined by an horizontal line with faces" + }, + { + "name": "CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR", + "value": 3, + "description": "Layout is defined by a 3x4 cross with cubemap faces" + }, + { + "name": "CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE", + "value": 4, + "description": "Layout is defined by a 4x3 cross with cubemap faces" + }, + { + "name": "CUBEMAP_LAYOUT_PANORAMA", + "value": 5, + "description": "Layout is defined by a panorama image (equirectangular map)" + } + ] + }, + { + "name": "FontType", + "description": "Font type, defines generation method", + "values": [ + { + "name": "FONT_DEFAULT", + "value": 0, + "description": "Default font generation, anti-aliased" + }, + { + "name": "FONT_BITMAP", + "value": 1, + "description": "Bitmap font generation, no anti-aliasing" + }, + { + "name": "FONT_SDF", + "value": 2, + "description": "SDF font generation, requires external shader" + } + ] + }, + { + "name": "BlendMode", + "description": "Color blending modes (pre-defined)", + "values": [ + { + "name": "BLEND_ALPHA", + "value": 0, + "description": "Blend textures considering alpha (default)" + }, + { + "name": "BLEND_ADDITIVE", + "value": 1, + "description": "Blend textures adding colors" + }, + { + "name": "BLEND_MULTIPLIED", + "value": 2, + "description": "Blend textures multiplying colors" + }, + { + "name": "BLEND_ADD_COLORS", + "value": 3, + "description": "Blend textures adding colors (alternative)" + }, + { + "name": "BLEND_SUBTRACT_COLORS", + "value": 4, + "description": "Blend textures subtracting colors (alternative)" + }, + { + "name": "BLEND_CUSTOM", + "value": 5, + "description": "Belnd textures using custom src/dst factors (use rlSetBlendMode())" + } + ] + }, + { + "name": "Gesture", + "description": "Gesture", + "values": [ + { + "name": "GESTURE_NONE", + "value": 0, + "description": "No gesture" + }, + { + "name": "GESTURE_TAP", + "value": 1, + "description": "Tap gesture" + }, + { + "name": "GESTURE_DOUBLETAP", + "value": 2, + "description": "Double tap gesture" + }, + { + "name": "GESTURE_HOLD", + "value": 4, + "description": "Hold gesture" + }, + { + "name": "GESTURE_DRAG", + "value": 8, + "description": "Drag gesture" + }, + { + "name": "GESTURE_SWIPE_RIGHT", + "value": 16, + "description": "Swipe right gesture" + }, + { + "name": "GESTURE_SWIPE_LEFT", + "value": 32, + "description": "Swipe left gesture" + }, + { + "name": "GESTURE_SWIPE_UP", + "value": 64, + "description": "Swipe up gesture" + }, + { + "name": "GESTURE_SWIPE_DOWN", + "value": 128, + "description": "Swipe down gesture" + }, + { + "name": "GESTURE_PINCH_IN", + "value": 256, + "description": "Pinch in gesture" + }, + { + "name": "GESTURE_PINCH_OUT", + "value": 512, + "description": "Pinch out gesture" + } + ] + }, + { + "name": "CameraMode", + "description": "Camera system modes", + "values": [ + { + "name": "CAMERA_CUSTOM", + "value": 0, + "description": "Custom camera" + }, + { + "name": "CAMERA_FREE", + "value": 1, + "description": "Free camera" + }, + { + "name": "CAMERA_ORBITAL", + "value": 2, + "description": "Orbital camera" + }, + { + "name": "CAMERA_FIRST_PERSON", + "value": 3, + "description": "First person camera" + }, + { + "name": "CAMERA_THIRD_PERSON", + "value": 4, + "description": "Third person camera" + } + ] + }, + { + "name": "CameraProjection", + "description": "Camera projection", + "values": [ + { + "name": "CAMERA_PERSPECTIVE", + "value": 0, + "description": "Perspective projection" + }, + { + "name": "CAMERA_ORTHOGRAPHIC", + "value": 1, + "description": "Orthographic projection" + } + ] + }, + { + "name": "NPatchLayout", + "description": "N-patch layout", + "values": [ + { + "name": "NPATCH_NINE_PATCH", + "value": 0, + "description": "Npatch layout: 3x3 tiles" + }, + { + "name": "NPATCH_THREE_PATCH_VERTICAL", + "value": 1, + "description": "Npatch layout: 1x3 tiles" + }, + { + "name": "NPATCH_THREE_PATCH_HORIZONTAL", + "value": 2, + "description": "Npatch layout: 3x1 tiles" + } + ] + } + ], + "functions": [ + { + "name": "InitWindow", + "description": "Initialize window and OpenGL context", + "returnType": "void", + "params": { + "width": "int", + "height": "int", + "title": "const char *" + } + }, + { + "name": "WindowShouldClose", + "description": "Check if KEY_ESCAPE pressed or Close icon pressed", + "returnType": "bool" + }, + { + "name": "CloseWindow", + "description": "Close window and unload OpenGL context", + "returnType": "void" + }, + { + "name": "IsWindowReady", + "description": "Check if window has been initialized successfully", + "returnType": "bool" + }, + { + "name": "IsWindowFullscreen", + "description": "Check if window is currently fullscreen", + "returnType": "bool" + }, + { + "name": "IsWindowHidden", + "description": "Check if window is currently hidden (only PLATFORM_DESKTOP)", + "returnType": "bool" + }, + { + "name": "IsWindowMinimized", + "description": "Check if window is currently minimized (only PLATFORM_DESKTOP)", + "returnType": "bool" + }, + { + "name": "IsWindowMaximized", + "description": "Check if window is currently maximized (only PLATFORM_DESKTOP)", + "returnType": "bool" + }, + { + "name": "IsWindowFocused", + "description": "Check if window is currently focused (only PLATFORM_DESKTOP)", + "returnType": "bool" + }, + { + "name": "IsWindowResized", + "description": "Check if window has been resized last frame", + "returnType": "bool" + }, + { + "name": "IsWindowState", + "description": "Check if one specific window flag is enabled", + "returnType": "bool", + "params": { + "flag": "unsigned int" + } + }, + { + "name": "SetWindowState", + "description": "Set window configuration state using flags", + "returnType": "void", + "params": { + "flags": "unsigned int" + } + }, + { + "name": "ClearWindowState", + "description": "Clear window configuration state flags", + "returnType": "void", + "params": { + "flags": "unsigned int" + } + }, + { + "name": "ToggleFullscreen", + "description": "Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP)", + "returnType": "void" + }, + { + "name": "MaximizeWindow", + "description": "Set window state: maximized, if resizable (only PLATFORM_DESKTOP)", + "returnType": "void" + }, + { + "name": "MinimizeWindow", + "description": "Set window state: minimized, if resizable (only PLATFORM_DESKTOP)", + "returnType": "void" + }, + { + "name": "RestoreWindow", + "description": "Set window state: not minimized/maximized (only PLATFORM_DESKTOP)", + "returnType": "void" + }, + { + "name": "SetWindowIcon", + "description": "Set icon for window (only PLATFORM_DESKTOP)", + "returnType": "void", + "params": { + "image": "Image" + } + }, + { + "name": "SetWindowTitle", + "description": "Set title for window (only PLATFORM_DESKTOP)", + "returnType": "void", + "params": { + "title": "const char *" + } + }, + { + "name": "SetWindowPosition", + "description": "Set window position on screen (only PLATFORM_DESKTOP)", + "returnType": "void", + "params": { + "x": "int", + "y": "int" + } + }, + { + "name": "SetWindowMonitor", + "description": "Set monitor for the current window (fullscreen mode)", + "returnType": "void", + "params": { + "monitor": "int" + } + }, + { + "name": "SetWindowMinSize", + "description": "Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)", + "returnType": "void", + "params": { + "width": "int", + "height": "int" + } + }, + { + "name": "SetWindowSize", + "description": "Set window dimensions", + "returnType": "void", + "params": { + "width": "int", + "height": "int" + } + }, + { + "name": "GetWindowHandle", + "description": "Get native window handle", + "returnType": "void *" + }, + { + "name": "GetScreenWidth", + "description": "Get current screen width", + "returnType": "int" + }, + { + "name": "GetScreenHeight", + "description": "Get current screen height", + "returnType": "int" + }, + { + "name": "GetRenderWidth", + "description": "Get current render width (it considers HiDPI)", + "returnType": "int" + }, + { + "name": "GetRenderHeight", + "description": "Get current render height (it considers HiDPI)", + "returnType": "int" + }, + { + "name": "GetMonitorCount", + "description": "Get number of connected monitors", + "returnType": "int" + }, + { + "name": "GetCurrentMonitor", + "description": "Get current connected monitor", + "returnType": "int" + }, + { + "name": "GetMonitorPosition", + "description": "Get specified monitor position", + "returnType": "Vector2", + "params": { + "monitor": "int" + } + }, + { + "name": "GetMonitorWidth", + "description": "Get specified monitor width (max available by monitor)", + "returnType": "int", + "params": { + "monitor": "int" + } + }, + { + "name": "GetMonitorHeight", + "description": "Get specified monitor height (max available by monitor)", + "returnType": "int", + "params": { + "monitor": "int" + } + }, + { + "name": "GetMonitorPhysicalWidth", + "description": "Get specified monitor physical width in millimetres", + "returnType": "int", + "params": { + "monitor": "int" + } + }, + { + "name": "GetMonitorPhysicalHeight", + "description": "Get specified monitor physical height in millimetres", + "returnType": "int", + "params": { + "monitor": "int" + } + }, + { + "name": "GetMonitorRefreshRate", + "description": "Get specified monitor refresh rate", + "returnType": "int", + "params": { + "monitor": "int" + } + }, + { + "name": "GetWindowPosition", + "description": "Get window position XY on monitor", + "returnType": "Vector2" + }, + { + "name": "GetWindowScaleDPI", + "description": "Get window scale DPI factor", + "returnType": "Vector2" + }, + { + "name": "GetMonitorName", + "description": "Get the human-readable, UTF-8 encoded name of the primary monitor", + "returnType": "const char *", + "params": { + "monitor": "int" + } + }, + { + "name": "SetClipboardText", + "description": "Set clipboard text content", + "returnType": "void", + "params": { + "text": "const char *" + } + }, + { + "name": "GetClipboardText", + "description": "Get clipboard text content", + "returnType": "const char *" + }, + { + "name": "SwapScreenBuffer", + "description": "Swap back buffer with front buffer (screen drawing)", + "returnType": "void" + }, + { + "name": "PollInputEvents", + "description": "Register all input events", + "returnType": "void" + }, + { + "name": "WaitTime", + "description": "Wait for some milliseconds (halt program execution)", + "returnType": "void", + "params": { + "ms": "float" + } + }, + { + "name": "ShowCursor", + "description": "Shows cursor", + "returnType": "void" + }, + { + "name": "HideCursor", + "description": "Hides cursor", + "returnType": "void" + }, + { + "name": "IsCursorHidden", + "description": "Check if cursor is not visible", + "returnType": "bool" + }, + { + "name": "EnableCursor", + "description": "Enables cursor (unlock cursor)", + "returnType": "void" + }, + { + "name": "DisableCursor", + "description": "Disables cursor (lock cursor)", + "returnType": "void" + }, + { + "name": "IsCursorOnScreen", + "description": "Check if cursor is on the screen", + "returnType": "bool" + }, + { + "name": "ClearBackground", + "description": "Set background color (framebuffer clear color)", + "returnType": "void", + "params": { + "color": "Color" + } + }, + { + "name": "BeginDrawing", + "description": "Setup canvas (framebuffer) to start drawing", + "returnType": "void" + }, + { + "name": "EndDrawing", + "description": "End canvas drawing and swap buffers (double buffering)", + "returnType": "void" + }, + { + "name": "BeginMode2D", + "description": "Begin 2D mode with custom camera (2D)", + "returnType": "void", + "params": { + "camera": "Camera2D" + } + }, + { + "name": "EndMode2D", + "description": "Ends 2D mode with custom camera", + "returnType": "void" + }, + { + "name": "BeginMode3D", + "description": "Begin 3D mode with custom camera (3D)", + "returnType": "void", + "params": { + "camera": "Camera3D" + } + }, + { + "name": "EndMode3D", + "description": "Ends 3D mode and returns to default 2D orthographic mode", + "returnType": "void" + }, + { + "name": "BeginTextureMode", + "description": "Begin drawing to render texture", + "returnType": "void", + "params": { + "target": "RenderTexture2D" + } + }, + { + "name": "EndTextureMode", + "description": "Ends drawing to render texture", + "returnType": "void" + }, + { + "name": "BeginShaderMode", + "description": "Begin custom shader drawing", + "returnType": "void", + "params": { + "shader": "Shader" + } + }, + { + "name": "EndShaderMode", + "description": "End custom shader drawing (use default shader)", + "returnType": "void" + }, + { + "name": "BeginBlendMode", + "description": "Begin blending mode (alpha, additive, multiplied, subtract, custom)", + "returnType": "void", + "params": { + "mode": "int" + } + }, + { + "name": "EndBlendMode", + "description": "End blending mode (reset to default: alpha blending)", + "returnType": "void" + }, + { + "name": "BeginScissorMode", + "description": "Begin scissor mode (define screen area for following drawing)", + "returnType": "void", + "params": { + "x": "int", + "y": "int", + "width": "int", + "height": "int" + } + }, + { + "name": "EndScissorMode", + "description": "End scissor mode", + "returnType": "void" + }, + { + "name": "BeginVrStereoMode", + "description": "Begin stereo rendering (requires VR simulator)", + "returnType": "void", + "params": { + "config": "VrStereoConfig" + } + }, + { + "name": "EndVrStereoMode", + "description": "End stereo rendering (requires VR simulator)", + "returnType": "void" + }, + { + "name": "LoadVrStereoConfig", + "description": "Load VR stereo config for VR simulator device parameters", + "returnType": "VrStereoConfig", + "params": { + "device": "VrDeviceInfo" + } + }, + { + "name": "UnloadVrStereoConfig", + "description": "Unload VR stereo config", + "returnType": "void", + "params": { + "config": "VrStereoConfig" + } + }, + { + "name": "LoadShader", + "description": "Load shader from files and bind default locations", + "returnType": "Shader", + "params": { + "vsFileName": "const char *", + "fsFileName": "const char *" + } + }, + { + "name": "LoadShaderFromMemory", + "description": "Load shader from code strings and bind default locations", + "returnType": "Shader", + "params": { + "vsCode": "const char *", + "fsCode": "const char *" + } + }, + { + "name": "GetShaderLocation", + "description": "Get shader uniform location", + "returnType": "int", + "params": { + "shader": "Shader", + "uniformName": "const char *" + } + }, + { + "name": "GetShaderLocationAttrib", + "description": "Get shader attribute location", + "returnType": "int", + "params": { + "shader": "Shader", + "attribName": "const char *" + } + }, + { + "name": "SetShaderValue", + "description": "Set shader uniform value", + "returnType": "void", + "params": { + "shader": "Shader", + "locIndex": "int", + "value": "const void *", + "uniformType": "int" + } + }, + { + "name": "SetShaderValueV", + "description": "Set shader uniform value vector", + "returnType": "void", + "params": { + "shader": "Shader", + "locIndex": "int", + "value": "const void *", + "uniformType": "int", + "count": "int" + } + }, + { + "name": "SetShaderValueMatrix", + "description": "Set shader uniform value (matrix 4x4)", + "returnType": "void", + "params": { + "shader": "Shader", + "locIndex": "int", + "mat": "Matrix" + } + }, + { + "name": "SetShaderValueTexture", + "description": "Set shader uniform value for texture (sampler2d)", + "returnType": "void", + "params": { + "shader": "Shader", + "locIndex": "int", + "texture": "Texture2D" + } + }, + { + "name": "UnloadShader", + "description": "Unload shader from GPU memory (VRAM)", + "returnType": "void", + "params": { + "shader": "Shader" + } + }, + { + "name": "GetMouseRay", + "description": "Get a ray trace from mouse position", + "returnType": "Ray", + "params": { + "mousePosition": "Vector2", + "camera": "Camera" + } + }, + { + "name": "GetCameraMatrix", + "description": "Get camera transform matrix (view matrix)", + "returnType": "Matrix", + "params": { + "camera": "Camera" + } + }, + { + "name": "GetCameraMatrix2D", + "description": "Get camera 2d transform matrix", + "returnType": "Matrix", + "params": { + "camera": "Camera2D" + } + }, + { + "name": "GetWorldToScreen", + "description": "Get the screen space position for a 3d world space position", + "returnType": "Vector2", + "params": { + "position": "Vector3", + "camera": "Camera" + } + }, + { + "name": "GetWorldToScreenEx", + "description": "Get size position for a 3d world space position", + "returnType": "Vector2", + "params": { + "position": "Vector3", + "camera": "Camera", + "width": "int", + "height": "int" + } + }, + { + "name": "GetWorldToScreen2D", + "description": "Get the screen space position for a 2d camera world space position", + "returnType": "Vector2", + "params": { + "position": "Vector2", + "camera": "Camera2D" + } + }, + { + "name": "GetScreenToWorld2D", + "description": "Get the world space position for a 2d camera screen space position", + "returnType": "Vector2", + "params": { + "position": "Vector2", + "camera": "Camera2D" + } + }, + { + "name": "SetTargetFPS", + "description": "Set target FPS (maximum)", + "returnType": "void", + "params": { + "fps": "int" + } + }, + { + "name": "GetFPS", + "description": "Get current FPS", + "returnType": "int" + }, + { + "name": "GetFrameTime", + "description": "Get time in seconds for last frame drawn (delta time)", + "returnType": "float" + }, + { + "name": "GetTime", + "description": "Get elapsed time in seconds since InitWindow()", + "returnType": "double" + }, + { + "name": "GetRandomValue", + "description": "Get a random value between min and max (both included)", + "returnType": "int", + "params": { + "min": "int", + "max": "int" + } + }, + { + "name": "SetRandomSeed", + "description": "Set the seed for the random number generator", + "returnType": "void", + "params": { + "seed": "unsigned int" + } + }, + { + "name": "TakeScreenshot", + "description": "Takes a screenshot of current screen (filename extension defines format)", + "returnType": "void", + "params": { + "fileName": "const char *" + } + }, + { + "name": "SetConfigFlags", + "description": "Setup init configuration flags (view FLAGS)", + "returnType": "void", + "params": { + "flags": "unsigned int" + } + }, + { + "name": "TraceLog", + "description": "Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...)", + "returnType": "void", + "params": { + "logLevel": "int", + "text": "const char *", + "": "" + } + }, + { + "name": "SetTraceLogLevel", + "description": "Set the current threshold (minimum) log level", + "returnType": "void", + "params": { + "logLevel": "int" + } + }, + { + "name": "MemAlloc", + "description": "Internal memory allocator", + "returnType": "void *", + "params": { + "size": "int" + } + }, + { + "name": "MemRealloc", + "description": "Internal memory reallocator", + "returnType": "void *", + "params": { + "ptr": "void *", + "size": "int" + } + }, + { + "name": "MemFree", + "description": "Internal memory free", + "returnType": "void", + "params": { + "ptr": "void *" + } + }, + { + "name": "SetTraceLogCallback", + "description": "Set custom trace log", + "returnType": "void", + "params": { + "callback": "TraceLogCallback" + } + }, + { + "name": "SetLoadFileDataCallback", + "description": "Set custom file binary data loader", + "returnType": "void", + "params": { + "callback": "LoadFileDataCallback" + } + }, + { + "name": "SetSaveFileDataCallback", + "description": "Set custom file binary data saver", + "returnType": "void", + "params": { + "callback": "SaveFileDataCallback" + } + }, + { + "name": "SetLoadFileTextCallback", + "description": "Set custom file text data loader", + "returnType": "void", + "params": { + "callback": "LoadFileTextCallback" + } + }, + { + "name": "SetSaveFileTextCallback", + "description": "Set custom file text data saver", + "returnType": "void", + "params": { + "callback": "SaveFileTextCallback" + } + }, + { + "name": "LoadFileData", + "description": "Load file data as byte array (read)", + "returnType": "unsigned char *", + "params": { + "fileName": "const char *", + "bytesRead": "unsigned int *" + } + }, + { + "name": "UnloadFileData", + "description": "Unload file data allocated by LoadFileData()", + "returnType": "void", + "params": { + "data": "unsigned char *" + } + }, + { + "name": "SaveFileData", + "description": "Save data to file from byte array (write), returns true on success", + "returnType": "bool", + "params": { + "fileName": "const char *", + "data": "void *", + "bytesToWrite": "unsigned int" + } + }, + { + "name": "LoadFileText", + "description": "Load text data from file (read), returns a '\\0' terminated string", + "returnType": "char *", + "params": { + "fileName": "const char *" + } + }, + { + "name": "UnloadFileText", + "description": "Unload file text data allocated by LoadFileText()", + "returnType": "void", + "params": { + "text": "char *" + } + }, + { + "name": "SaveFileText", + "description": "Save text data to file (write), string must be '\\0' terminated, returns true on success", + "returnType": "bool", + "params": { + "fileName": "const char *", + "text": "char *" + } + }, + { + "name": "FileExists", + "description": "Check if file exists", + "returnType": "bool", + "params": { + "fileName": "const char *" + } + }, + { + "name": "DirectoryExists", + "description": "Check if a directory path exists", + "returnType": "bool", + "params": { + "dirPath": "const char *" + } + }, + { + "name": "IsFileExtension", + "description": "Check file extension (including point: .png, .wav)", + "returnType": "bool", + "params": { + "fileName": "const char *", + "ext": "const char *" + } + }, + { + "name": "GetFileExtension", + "description": "Get pointer to extension for a filename string (includes dot: '.png')", + "returnType": "const char *", + "params": { + "fileName": "const char *" + } + }, + { + "name": "GetFileName", + "description": "Get pointer to filename for a path string", + "returnType": "const char *", + "params": { + "filePath": "const char *" + } + }, + { + "name": "GetFileNameWithoutExt", + "description": "Get filename string without extension (uses static string)", + "returnType": "const char *", + "params": { + "filePath": "const char *" + } + }, + { + "name": "GetDirectoryPath", + "description": "Get full path for a given fileName with path (uses static string)", + "returnType": "const char *", + "params": { + "filePath": "const char *" + } + }, + { + "name": "GetPrevDirectoryPath", + "description": "Get previous directory path for a given path (uses static string)", + "returnType": "const char *", + "params": { + "dirPath": "const char *" + } + }, + { + "name": "GetWorkingDirectory", + "description": "Get current working directory (uses static string)", + "returnType": "const char *" + }, + { + "name": "GetDirectoryFiles", + "description": "Get filenames in a directory path (memory should be freed)", + "returnType": "char **", + "params": { + "dirPath": "const char *", + "count": "int *" + } + }, + { + "name": "ClearDirectoryFiles", + "description": "Clear directory files paths buffers (free memory)", + "returnType": "void" + }, + { + "name": "ChangeDirectory", + "description": "Change working directory, return true on success", + "returnType": "bool", + "params": { + "dir": "const char *" + } + }, + { + "name": "IsFileDropped", + "description": "Check if a file has been dropped into window", + "returnType": "bool" + }, + { + "name": "GetDroppedFiles", + "description": "Get dropped files names (memory should be freed)", + "returnType": "char **", + "params": { + "count": "int *" + } + }, + { + "name": "ClearDroppedFiles", + "description": "Clear dropped files paths buffer (free memory)", + "returnType": "void" + }, + { + "name": "GetFileModTime", + "description": "Get file modification time (last write time)", + "returnType": "long", + "params": { + "fileName": "const char *" + } + }, + { + "name": "CompressData", + "description": "Compress data (DEFLATE algorithm)", + "returnType": "unsigned char *", + "params": { + "data": "unsigned char *", + "dataLength": "int", + "compDataLength": "int *" + } + }, + { + "name": "DecompressData", + "description": "Decompress data (DEFLATE algorithm)", + "returnType": "unsigned char *", + "params": { + "compData": "unsigned char *", + "compDataLength": "int", + "dataLength": "int *" + } + }, + { + "name": "EncodeDataBase64", + "description": "Encode data to Base64 string", + "returnType": "char *", + "params": { + "data": "const unsigned char *", + "dataLength": "int", + "outputLength": "int *" + } + }, + { + "name": "DecodeDataBase64", + "description": "Decode Base64 string data", + "returnType": "unsigned char *", + "params": { + "data": "unsigned char *", + "outputLength": "int *" + } + }, + { + "name": "SaveStorageValue", + "description": "Save integer value to storage file (to defined position), returns true on success", + "returnType": "bool", + "params": { + "position": "unsigned int", + "value": "int" + } + }, + { + "name": "LoadStorageValue", + "description": "Load integer value from storage file (from defined position)", + "returnType": "int", + "params": { + "position": "unsigned int" + } + }, + { + "name": "OpenURL", + "description": "Open URL with default system browser (if available)", + "returnType": "void", + "params": { + "url": "const char *" + } + }, + { + "name": "IsKeyPressed", + "description": "Check if a key has been pressed once", + "returnType": "bool", + "params": { + "key": "int" + } + }, + { + "name": "IsKeyDown", + "description": "Check if a key is being pressed", + "returnType": "bool", + "params": { + "key": "int" + } + }, + { + "name": "IsKeyReleased", + "description": "Check if a key has been released once", + "returnType": "bool", + "params": { + "key": "int" + } + }, + { + "name": "IsKeyUp", + "description": "Check if a key is NOT being pressed", + "returnType": "bool", + "params": { + "key": "int" + } + }, + { + "name": "SetExitKey", + "description": "Set a custom key to exit program (default is ESC)", + "returnType": "void", + "params": { + "key": "int" + } + }, + { + "name": "GetKeyPressed", + "description": "Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty", + "returnType": "int" + }, + { + "name": "GetCharPressed", + "description": "Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty", + "returnType": "int" + }, + { + "name": "IsGamepadAvailable", + "description": "Check if a gamepad is available", + "returnType": "bool", + "params": { + "gamepad": "int" + } + }, + { + "name": "GetGamepadName", + "description": "Get gamepad internal name id", + "returnType": "const char *", + "params": { + "gamepad": "int" + } + }, + { + "name": "IsGamepadButtonPressed", + "description": "Check if a gamepad button has been pressed once", + "returnType": "bool", + "params": { + "gamepad": "int", + "button": "int" + } + }, + { + "name": "IsGamepadButtonDown", + "description": "Check if a gamepad button is being pressed", + "returnType": "bool", + "params": { + "gamepad": "int", + "button": "int" + } + }, + { + "name": "IsGamepadButtonReleased", + "description": "Check if a gamepad button has been released once", + "returnType": "bool", + "params": { + "gamepad": "int", + "button": "int" + } + }, + { + "name": "IsGamepadButtonUp", + "description": "Check if a gamepad button is NOT being pressed", + "returnType": "bool", + "params": { + "gamepad": "int", + "button": "int" + } + }, + { + "name": "GetGamepadButtonPressed", + "description": "Get the last gamepad button pressed", + "returnType": "int" + }, + { + "name": "GetGamepadAxisCount", + "description": "Get gamepad axis count for a gamepad", + "returnType": "int", + "params": { + "gamepad": "int" + } + }, + { + "name": "GetGamepadAxisMovement", + "description": "Get axis movement value for a gamepad axis", + "returnType": "float", + "params": { + "gamepad": "int", + "axis": "int" + } + }, + { + "name": "SetGamepadMappings", + "description": "Set internal gamepad mappings (SDL_GameControllerDB)", + "returnType": "int", + "params": { + "mappings": "const char *" + } + }, + { + "name": "IsMouseButtonPressed", + "description": "Check if a mouse button has been pressed once", + "returnType": "bool", + "params": { + "button": "int" + } + }, + { + "name": "IsMouseButtonDown", + "description": "Check if a mouse button is being pressed", + "returnType": "bool", + "params": { + "button": "int" + } + }, + { + "name": "IsMouseButtonReleased", + "description": "Check if a mouse button has been released once", + "returnType": "bool", + "params": { + "button": "int" + } + }, + { + "name": "IsMouseButtonUp", + "description": "Check if a mouse button is NOT being pressed", + "returnType": "bool", + "params": { + "button": "int" + } + }, + { + "name": "GetMouseX", + "description": "Get mouse position X", + "returnType": "int" + }, + { + "name": "GetMouseY", + "description": "Get mouse position Y", + "returnType": "int" + }, + { + "name": "GetMousePosition", + "description": "Get mouse position XY", + "returnType": "Vector2" + }, + { + "name": "GetMouseDelta", + "description": "Get mouse delta between frames", + "returnType": "Vector2" + }, + { + "name": "SetMousePosition", + "description": "Set mouse position XY", + "returnType": "void", + "params": { + "x": "int", + "y": "int" + } + }, + { + "name": "SetMouseOffset", + "description": "Set mouse offset", + "returnType": "void", + "params": { + "offsetX": "int", + "offsetY": "int" + } + }, + { + "name": "SetMouseScale", + "description": "Set mouse scaling", + "returnType": "void", + "params": { + "scaleX": "float", + "scaleY": "float" + } + }, + { + "name": "GetMouseWheelMove", + "description": "Get mouse wheel movement Y", + "returnType": "float" + }, + { + "name": "SetMouseCursor", + "description": "Set mouse cursor", + "returnType": "void", + "params": { + "cursor": "int" + } + }, + { + "name": "GetTouchX", + "description": "Get touch position X for touch point 0 (relative to screen size)", + "returnType": "int" + }, + { + "name": "GetTouchY", + "description": "Get touch position Y for touch point 0 (relative to screen size)", + "returnType": "int" + }, + { + "name": "GetTouchPosition", + "description": "Get touch position XY for a touch point index (relative to screen size)", + "returnType": "Vector2", + "params": { + "index": "int" + } + }, + { + "name": "GetTouchPointId", + "description": "Get touch point identifier for given index", + "returnType": "int", + "params": { + "index": "int" + } + }, + { + "name": "GetTouchPointCount", + "description": "Get number of touch points", + "returnType": "int" + }, + { + "name": "SetGesturesEnabled", + "description": "Enable a set of gestures using flags", + "returnType": "void", + "params": { + "flags": "unsigned int" + } + }, + { + "name": "IsGestureDetected", + "description": "Check if a gesture have been detected", + "returnType": "bool", + "params": { + "gesture": "int" + } + }, + { + "name": "GetGestureDetected", + "description": "Get latest detected gesture", + "returnType": "int" + }, + { + "name": "GetGestureHoldDuration", + "description": "Get gesture hold time in milliseconds", + "returnType": "float" + }, + { + "name": "GetGestureDragVector", + "description": "Get gesture drag vector", + "returnType": "Vector2" + }, + { + "name": "GetGestureDragAngle", + "description": "Get gesture drag angle", + "returnType": "float" + }, + { + "name": "GetGesturePinchVector", + "description": "Get gesture pinch delta", + "returnType": "Vector2" + }, + { + "name": "GetGesturePinchAngle", + "description": "Get gesture pinch angle", + "returnType": "float" + }, + { + "name": "SetCameraMode", + "description": "Set camera mode (multiple camera modes available)", + "returnType": "void", + "params": { + "camera": "Camera", + "mode": "int" + } + }, + { + "name": "UpdateCamera", + "description": "Update camera position for selected mode", + "returnType": "void", + "params": { + "camera": "Camera *" + } + }, + { + "name": "SetCameraPanControl", + "description": "Set camera pan key to combine with mouse movement (free camera)", + "returnType": "void", + "params": { + "keyPan": "int" + } + }, + { + "name": "SetCameraAltControl", + "description": "Set camera alt key to combine with mouse movement (free camera)", + "returnType": "void", + "params": { + "keyAlt": "int" + } + }, + { + "name": "SetCameraSmoothZoomControl", + "description": "Set camera smooth zoom key to combine with mouse (free camera)", + "returnType": "void", + "params": { + "keySmoothZoom": "int" + } + }, + { + "name": "SetCameraMoveControls", + "description": "Set camera move controls (1st person and 3rd person cameras)", + "returnType": "void", + "params": { + "keyFront": "int", + "keyBack": "int", + "keyRight": "int", + "keyLeft": "int", + "keyUp": "int", + "keyDown": "int" + } + }, + { + "name": "SetShapesTexture", + "description": "Set texture and rectangle to be used on shapes drawing", + "returnType": "void", + "params": { + "texture": "Texture2D", + "source": "Rectangle" + } + }, + { + "name": "DrawPixel", + "description": "Draw a pixel", + "returnType": "void", + "params": { + "posX": "int", + "posY": "int", + "color": "Color" + } + }, + { + "name": "DrawPixelV", + "description": "Draw a pixel (Vector version)", + "returnType": "void", + "params": { + "position": "Vector2", + "color": "Color" + } + }, + { + "name": "DrawLine", + "description": "Draw a line", + "returnType": "void", + "params": { + "startPosX": "int", + "startPosY": "int", + "endPosX": "int", + "endPosY": "int", + "color": "Color" + } + }, + { + "name": "DrawLineV", + "description": "Draw a line (Vector version)", + "returnType": "void", + "params": { + "startPos": "Vector2", + "endPos": "Vector2", + "color": "Color" + } + }, + { + "name": "DrawLineEx", + "description": "Draw a line defining thickness", + "returnType": "void", + "params": { + "startPos": "Vector2", + "endPos": "Vector2", + "thick": "float", + "color": "Color" + } + }, + { + "name": "DrawLineBezier", + "description": "Draw a line using cubic-bezier curves in-out", + "returnType": "void", + "params": { + "startPos": "Vector2", + "endPos": "Vector2", + "thick": "float", + "color": "Color" + } + }, + { + "name": "DrawLineBezierQuad", + "description": "Draw line using quadratic bezier curves with a control point", + "returnType": "void", + "params": { + "startPos": "Vector2", + "endPos": "Vector2", + "controlPos": "Vector2", + "thick": "float", + "color": "Color" + } + }, + { + "name": "DrawLineBezierCubic", + "description": "Draw line using cubic bezier curves with 2 control points", + "returnType": "void", + "params": { + "startPos": "Vector2", + "endPos": "Vector2", + "startControlPos": "Vector2", + "endControlPos": "Vector2", + "thick": "float", + "color": "Color" + } + }, + { + "name": "DrawLineStrip", + "description": "Draw lines sequence", + "returnType": "void", + "params": { + "points": "Vector2 *", + "pointCount": "int", + "color": "Color" + } + }, + { + "name": "DrawCircle", + "description": "Draw a color-filled circle", + "returnType": "void", + "params": { + "centerX": "int", + "centerY": "int", + "radius": "float", + "color": "Color" + } + }, + { + "name": "DrawCircleSector", + "description": "Draw a piece of a circle", + "returnType": "void", + "params": { + "center": "Vector2", + "radius": "float", + "startAngle": "float", + "endAngle": "float", + "segments": "int", + "color": "Color" + } + }, + { + "name": "DrawCircleSectorLines", + "description": "Draw circle sector outline", + "returnType": "void", + "params": { + "center": "Vector2", + "radius": "float", + "startAngle": "float", + "endAngle": "float", + "segments": "int", + "color": "Color" + } + }, + { + "name": "DrawCircleGradient", + "description": "Draw a gradient-filled circle", + "returnType": "void", + "params": { + "centerX": "int", + "centerY": "int", + "radius": "float", + "color1": "Color", + "color2": "Color" + } + }, + { + "name": "DrawCircleV", + "description": "Draw a color-filled circle (Vector version)", + "returnType": "void", + "params": { + "center": "Vector2", + "radius": "float", + "color": "Color" + } + }, + { + "name": "DrawCircleLines", + "description": "Draw circle outline", + "returnType": "void", + "params": { + "centerX": "int", + "centerY": "int", + "radius": "float", + "color": "Color" + } + }, + { + "name": "DrawEllipse", + "description": "Draw ellipse", + "returnType": "void", + "params": { + "centerX": "int", + "centerY": "int", + "radiusH": "float", + "radiusV": "float", + "color": "Color" + } + }, + { + "name": "DrawEllipseLines", + "description": "Draw ellipse outline", + "returnType": "void", + "params": { + "centerX": "int", + "centerY": "int", + "radiusH": "float", + "radiusV": "float", + "color": "Color" + } + }, + { + "name": "DrawRing", + "description": "Draw ring", + "returnType": "void", + "params": { + "center": "Vector2", + "innerRadius": "float", + "outerRadius": "float", + "startAngle": "float", + "endAngle": "float", + "segments": "int", + "color": "Color" + } + }, + { + "name": "DrawRingLines", + "description": "Draw ring outline", + "returnType": "void", + "params": { + "center": "Vector2", + "innerRadius": "float", + "outerRadius": "float", + "startAngle": "float", + "endAngle": "float", + "segments": "int", + "color": "Color" + } + }, + { + "name": "DrawRectangle", + "description": "Draw a color-filled rectangle", + "returnType": "void", + "params": { + "posX": "int", + "posY": "int", + "width": "int", + "height": "int", + "color": "Color" + } + }, + { + "name": "DrawRectangleV", + "description": "Draw a color-filled rectangle (Vector version)", + "returnType": "void", + "params": { + "position": "Vector2", + "size": "Vector2", + "color": "Color" + } + }, + { + "name": "DrawRectangleRec", + "description": "Draw a color-filled rectangle", + "returnType": "void", + "params": { + "rec": "Rectangle", + "color": "Color" + } + }, + { + "name": "DrawRectanglePro", + "description": "Draw a color-filled rectangle with pro parameters", + "returnType": "void", + "params": { + "rec": "Rectangle", + "origin": "Vector2", + "rotation": "float", + "color": "Color" + } + }, + { + "name": "DrawRectangleGradientV", + "description": "Draw a vertical-gradient-filled rectangle", + "returnType": "void", + "params": { + "posX": "int", + "posY": "int", + "width": "int", + "height": "int", + "color1": "Color", + "color2": "Color" + } + }, + { + "name": "DrawRectangleGradientH", + "description": "Draw a horizontal-gradient-filled rectangle", + "returnType": "void", + "params": { + "posX": "int", + "posY": "int", + "width": "int", + "height": "int", + "color1": "Color", + "color2": "Color" + } + }, + { + "name": "DrawRectangleGradientEx", + "description": "Draw a gradient-filled rectangle with custom vertex colors", + "returnType": "void", + "params": { + "rec": "Rectangle", + "col1": "Color", + "col2": "Color", + "col3": "Color", + "col4": "Color" + } + }, + { + "name": "DrawRectangleLines", + "description": "Draw rectangle outline", + "returnType": "void", + "params": { + "posX": "int", + "posY": "int", + "width": "int", + "height": "int", + "color": "Color" + } + }, + { + "name": "DrawRectangleLinesEx", + "description": "Draw rectangle outline with extended parameters", + "returnType": "void", + "params": { + "rec": "Rectangle", + "lineThick": "float", + "color": "Color" + } + }, + { + "name": "DrawRectangleRounded", + "description": "Draw rectangle with rounded edges", + "returnType": "void", + "params": { + "rec": "Rectangle", + "roundness": "float", + "segments": "int", + "color": "Color" + } + }, + { + "name": "DrawRectangleRoundedLines", + "description": "Draw rectangle with rounded edges outline", + "returnType": "void", + "params": { + "rec": "Rectangle", + "roundness": "float", + "segments": "int", + "lineThick": "float", + "color": "Color" + } + }, + { + "name": "DrawTriangle", + "description": "Draw a color-filled triangle (vertex in counter-clockwise order!)", + "returnType": "void", + "params": { + "v1": "Vector2", + "v2": "Vector2", + "v3": "Vector2", + "color": "Color" + } + }, + { + "name": "DrawTriangleLines", + "description": "Draw triangle outline (vertex in counter-clockwise order!)", + "returnType": "void", + "params": { + "v1": "Vector2", + "v2": "Vector2", + "v3": "Vector2", + "color": "Color" + } + }, + { + "name": "DrawTriangleFan", + "description": "Draw a triangle fan defined by points (first vertex is the center)", + "returnType": "void", + "params": { + "points": "Vector2 *", + "pointCount": "int", + "color": "Color" + } + }, + { + "name": "DrawTriangleStrip", + "description": "Draw a triangle strip defined by points", + "returnType": "void", + "params": { + "points": "Vector2 *", + "pointCount": "int", + "color": "Color" + } + }, + { + "name": "DrawPoly", + "description": "Draw a regular polygon (Vector version)", + "returnType": "void", + "params": { + "center": "Vector2", + "sides": "int", + "radius": "float", + "rotation": "float", + "color": "Color" + } + }, + { + "name": "DrawPolyLines", + "description": "Draw a polygon outline of n sides", + "returnType": "void", + "params": { + "center": "Vector2", + "sides": "int", + "radius": "float", + "rotation": "float", + "color": "Color" + } + }, + { + "name": "DrawPolyLinesEx", + "description": "Draw a polygon outline of n sides with extended parameters", + "returnType": "void", + "params": { + "center": "Vector2", + "sides": "int", + "radius": "float", + "rotation": "float", + "lineThick": "float", + "color": "Color" + } + }, + { + "name": "CheckCollisionRecs", + "description": "Check collision between two rectangles", + "returnType": "bool", + "params": { + "rec1": "Rectangle", + "rec2": "Rectangle" + } + }, + { + "name": "CheckCollisionCircles", + "description": "Check collision between two circles", + "returnType": "bool", + "params": { + "center1": "Vector2", + "radius1": "float", + "center2": "Vector2", + "radius2": "float" + } + }, + { + "name": "CheckCollisionCircleRec", + "description": "Check collision between circle and rectangle", + "returnType": "bool", + "params": { + "center": "Vector2", + "radius": "float", + "rec": "Rectangle" + } + }, + { + "name": "CheckCollisionPointRec", + "description": "Check if point is inside rectangle", + "returnType": "bool", + "params": { + "point": "Vector2", + "rec": "Rectangle" + } + }, + { + "name": "CheckCollisionPointCircle", + "description": "Check if point is inside circle", + "returnType": "bool", + "params": { + "point": "Vector2", + "center": "Vector2", + "radius": "float" + } + }, + { + "name": "CheckCollisionPointTriangle", + "description": "Check if point is inside a triangle", + "returnType": "bool", + "params": { + "point": "Vector2", + "p1": "Vector2", + "p2": "Vector2", + "p3": "Vector2" + } + }, + { + "name": "CheckCollisionLines", + "description": "Check the collision between two lines defined by two points each, returns collision point by reference", + "returnType": "bool", + "params": { + "startPos1": "Vector2", + "endPos1": "Vector2", + "startPos2": "Vector2", + "endPos2": "Vector2", + "collisionPoint": "Vector2 *" + } + }, + { + "name": "CheckCollisionPointLine", + "description": "Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold]", + "returnType": "bool", + "params": { + "point": "Vector2", + "p1": "Vector2", + "p2": "Vector2", + "threshold": "int" + } + }, + { + "name": "GetCollisionRec", + "description": "Get collision rectangle for two rectangles collision", + "returnType": "Rectangle", + "params": { + "rec1": "Rectangle", + "rec2": "Rectangle" + } + }, + { + "name": "LoadImage", + "description": "Load image from file into CPU memory (RAM)", + "returnType": "Image", + "params": { + "fileName": "const char *" + } + }, + { + "name": "LoadImageRaw", + "description": "Load image from RAW file data", + "returnType": "Image", + "params": { + "fileName": "const char *", + "width": "int", + "height": "int", + "format": "int", + "headerSize": "int" + } + }, + { + "name": "LoadImageAnim", + "description": "Load image sequence from file (frames appended to image.data)", + "returnType": "Image", + "params": { + "fileName": "const char *", + "frames": "int *" + } + }, + { + "name": "LoadImageFromMemory", + "description": "Load image from memory buffer, fileType refers to extension: i.e. '.png'", + "returnType": "Image", + "params": { + "fileType": "const char *", + "fileData": "const unsigned char *", + "dataSize": "int" + } + }, + { + "name": "LoadImageFromTexture", + "description": "Load image from GPU texture data", + "returnType": "Image", + "params": { + "texture": "Texture2D" + } + }, + { + "name": "LoadImageFromScreen", + "description": "Load image from screen buffer and (screenshot)", + "returnType": "Image" + }, + { + "name": "UnloadImage", + "description": "Unload image from CPU memory (RAM)", + "returnType": "void", + "params": { + "image": "Image" + } + }, + { + "name": "ExportImage", + "description": "Export image data to file, returns true on success", + "returnType": "bool", + "params": { + "image": "Image", + "fileName": "const char *" + } + }, + { + "name": "ExportImageAsCode", + "description": "Export image as code file defining an array of bytes, returns true on success", + "returnType": "bool", + "params": { + "image": "Image", + "fileName": "const char *" + } + }, + { + "name": "GenImageColor", + "description": "Generate image: plain color", + "returnType": "Image", + "params": { + "width": "int", + "height": "int", + "color": "Color" + } + }, + { + "name": "GenImageGradientV", + "description": "Generate image: vertical gradient", + "returnType": "Image", + "params": { + "width": "int", + "height": "int", + "top": "Color", + "bottom": "Color" + } + }, + { + "name": "GenImageGradientH", + "description": "Generate image: horizontal gradient", + "returnType": "Image", + "params": { + "width": "int", + "height": "int", + "left": "Color", + "right": "Color" + } + }, + { + "name": "GenImageGradientRadial", + "description": "Generate image: radial gradient", + "returnType": "Image", + "params": { + "width": "int", + "height": "int", + "density": "float", + "inner": "Color", + "outer": "Color" + } + }, + { + "name": "GenImageChecked", + "description": "Generate image: checked", + "returnType": "Image", + "params": { + "width": "int", + "height": "int", + "checksX": "int", + "checksY": "int", + "col1": "Color", + "col2": "Color" + } + }, + { + "name": "GenImageWhiteNoise", + "description": "Generate image: white noise", + "returnType": "Image", + "params": { + "width": "int", + "height": "int", + "factor": "float" + } + }, + { + "name": "GenImageCellular", + "description": "Generate image: cellular algorithm, bigger tileSize means bigger cells", + "returnType": "Image", + "params": { + "width": "int", + "height": "int", + "tileSize": "int" + } + }, + { + "name": "ImageCopy", + "description": "Create an image duplicate (useful for transformations)", + "returnType": "Image", + "params": { + "image": "Image" + } + }, + { + "name": "ImageFromImage", + "description": "Create an image from another image piece", + "returnType": "Image", + "params": { + "image": "Image", + "rec": "Rectangle" + } + }, + { + "name": "ImageText", + "description": "Create an image from text (default font)", + "returnType": "Image", + "params": { + "text": "const char *", + "fontSize": "int", + "color": "Color" + } + }, + { + "name": "ImageTextEx", + "description": "Create an image from text (custom sprite font)", + "returnType": "Image", + "params": { + "font": "Font", + "text": "const char *", + "fontSize": "float", + "spacing": "float", + "tint": "Color" + } + }, + { + "name": "ImageFormat", + "description": "Convert image data to desired format", + "returnType": "void", + "params": { + "image": "Image *", + "newFormat": "int" + } + }, + { + "name": "ImageToPOT", + "description": "Convert image to POT (power-of-two)", + "returnType": "void", + "params": { + "image": "Image *", + "fill": "Color" + } + }, + { + "name": "ImageCrop", + "description": "Crop an image to a defined rectangle", + "returnType": "void", + "params": { + "image": "Image *", + "crop": "Rectangle" + } + }, + { + "name": "ImageAlphaCrop", + "description": "Crop image depending on alpha value", + "returnType": "void", + "params": { + "image": "Image *", + "threshold": "float" + } + }, + { + "name": "ImageAlphaClear", + "description": "Clear alpha channel to desired color", + "returnType": "void", + "params": { + "image": "Image *", + "color": "Color", + "threshold": "float" + } + }, + { + "name": "ImageAlphaMask", + "description": "Apply alpha mask to image", + "returnType": "void", + "params": { + "image": "Image *", + "alphaMask": "Image" + } + }, + { + "name": "ImageAlphaPremultiply", + "description": "Premultiply alpha channel", + "returnType": "void", + "params": { + "image": "Image *" + } + }, + { + "name": "ImageResize", + "description": "Resize image (Bicubic scaling algorithm)", + "returnType": "void", + "params": { + "image": "Image *", + "newWidth": "int", + "newHeight": "int" + } + }, + { + "name": "ImageResizeNN", + "description": "Resize image (Nearest-Neighbor scaling algorithm)", + "returnType": "void", + "params": { + "image": "Image *", + "newWidth": "int", + "newHeight": "int" + } + }, + { + "name": "ImageResizeCanvas", + "description": "Resize canvas and fill with color", + "returnType": "void", + "params": { + "image": "Image *", + "newWidth": "int", + "newHeight": "int", + "offsetX": "int", + "offsetY": "int", + "fill": "Color" + } + }, + { + "name": "ImageMipmaps", + "description": "Compute all mipmap levels for a provided image", + "returnType": "void", + "params": { + "image": "Image *" + } + }, + { + "name": "ImageDither", + "description": "Dither image data to 16bpp or lower (Floyd-Steinberg dithering)", + "returnType": "void", + "params": { + "image": "Image *", + "rBpp": "int", + "gBpp": "int", + "bBpp": "int", + "aBpp": "int" + } + }, + { + "name": "ImageFlipVertical", + "description": "Flip image vertically", + "returnType": "void", + "params": { + "image": "Image *" + } + }, + { + "name": "ImageFlipHorizontal", + "description": "Flip image horizontally", + "returnType": "void", + "params": { + "image": "Image *" + } + }, + { + "name": "ImageRotateCW", + "description": "Rotate image clockwise 90deg", + "returnType": "void", + "params": { + "image": "Image *" + } + }, + { + "name": "ImageRotateCCW", + "description": "Rotate image counter-clockwise 90deg", + "returnType": "void", + "params": { + "image": "Image *" + } + }, + { + "name": "ImageColorTint", + "description": "Modify image color: tint", + "returnType": "void", + "params": { + "image": "Image *", + "color": "Color" + } + }, + { + "name": "ImageColorInvert", + "description": "Modify image color: invert", + "returnType": "void", + "params": { + "image": "Image *" + } + }, + { + "name": "ImageColorGrayscale", + "description": "Modify image color: grayscale", + "returnType": "void", + "params": { + "image": "Image *" + } + }, + { + "name": "ImageColorContrast", + "description": "Modify image color: contrast (-100 to 100)", + "returnType": "void", + "params": { + "image": "Image *", + "contrast": "float" + } + }, + { + "name": "ImageColorBrightness", + "description": "Modify image color: brightness (-255 to 255)", + "returnType": "void", + "params": { + "image": "Image *", + "brightness": "int" + } + }, + { + "name": "ImageColorReplace", + "description": "Modify image color: replace color", + "returnType": "void", + "params": { + "image": "Image *", + "color": "Color", + "replace": "Color" + } + }, + { + "name": "LoadImageColors", + "description": "Load color data from image as a Color array (RGBA - 32bit)", + "returnType": "Color *", + "params": { + "image": "Image" + } + }, + { + "name": "LoadImagePalette", + "description": "Load colors palette from image as a Color array (RGBA - 32bit)", + "returnType": "Color *", + "params": { + "image": "Image", + "maxPaletteSize": "int", + "colorCount": "int *" + } + }, + { + "name": "UnloadImageColors", + "description": "Unload color data loaded with LoadImageColors()", + "returnType": "void", + "params": { + "colors": "Color *" + } + }, + { + "name": "UnloadImagePalette", + "description": "Unload colors palette loaded with LoadImagePalette()", + "returnType": "void", + "params": { + "colors": "Color *" + } + }, + { + "name": "GetImageAlphaBorder", + "description": "Get image alpha border rectangle", + "returnType": "Rectangle", + "params": { + "image": "Image", + "threshold": "float" + } + }, + { + "name": "GetImageColor", + "description": "Get image pixel color at (x, y) position", + "returnType": "Color", + "params": { + "image": "Image", + "x": "int", + "y": "int" + } + }, + { + "name": "ImageClearBackground", + "description": "Clear image background with given color", + "returnType": "void", + "params": { + "dst": "Image *", + "color": "Color" + } + }, + { + "name": "ImageDrawPixel", + "description": "Draw pixel within an image", + "returnType": "void", + "params": { + "dst": "Image *", + "posX": "int", + "posY": "int", + "color": "Color" + } + }, + { + "name": "ImageDrawPixelV", + "description": "Draw pixel within an image (Vector version)", + "returnType": "void", + "params": { + "dst": "Image *", + "position": "Vector2", + "color": "Color" + } + }, + { + "name": "ImageDrawLine", + "description": "Draw line within an image", + "returnType": "void", + "params": { + "dst": "Image *", + "startPosX": "int", + "startPosY": "int", + "endPosX": "int", + "endPosY": "int", + "color": "Color" + } + }, + { + "name": "ImageDrawLineV", + "description": "Draw line within an image (Vector version)", + "returnType": "void", + "params": { + "dst": "Image *", + "start": "Vector2", + "end": "Vector2", + "color": "Color" + } + }, + { + "name": "ImageDrawCircle", + "description": "Draw circle within an image", + "returnType": "void", + "params": { + "dst": "Image *", + "centerX": "int", + "centerY": "int", + "radius": "int", + "color": "Color" + } + }, + { + "name": "ImageDrawCircleV", + "description": "Draw circle within an image (Vector version)", + "returnType": "void", + "params": { + "dst": "Image *", + "center": "Vector2", + "radius": "int", + "color": "Color" + } + }, + { + "name": "ImageDrawRectangle", + "description": "Draw rectangle within an image", + "returnType": "void", + "params": { + "dst": "Image *", + "posX": "int", + "posY": "int", + "width": "int", + "height": "int", + "color": "Color" + } + }, + { + "name": "ImageDrawRectangleV", + "description": "Draw rectangle within an image (Vector version)", + "returnType": "void", + "params": { + "dst": "Image *", + "position": "Vector2", + "size": "Vector2", + "color": "Color" + } + }, + { + "name": "ImageDrawRectangleRec", + "description": "Draw rectangle within an image", + "returnType": "void", + "params": { + "dst": "Image *", + "rec": "Rectangle", + "color": "Color" + } + }, + { + "name": "ImageDrawRectangleLines", + "description": "Draw rectangle lines within an image", + "returnType": "void", + "params": { + "dst": "Image *", + "rec": "Rectangle", + "thick": "int", + "color": "Color" + } + }, + { + "name": "ImageDraw", + "description": "Draw a source image within a destination image (tint applied to source)", + "returnType": "void", + "params": { + "dst": "Image *", + "src": "Image", + "srcRec": "Rectangle", + "dstRec": "Rectangle", + "tint": "Color" + } + }, + { + "name": "ImageDrawText", + "description": "Draw text (using default font) within an image (destination)", + "returnType": "void", + "params": { + "dst": "Image *", + "text": "const char *", + "posX": "int", + "posY": "int", + "fontSize": "int", + "color": "Color" + } + }, + { + "name": "ImageDrawTextEx", + "description": "Draw text (custom sprite font) within an image (destination)", + "returnType": "void", + "params": { + "dst": "Image *", + "font": "Font", + "text": "const char *", + "position": "Vector2", + "fontSize": "float", + "spacing": "float", + "tint": "Color" + } + }, + { + "name": "LoadTexture", + "description": "Load texture from file into GPU memory (VRAM)", + "returnType": "Texture2D", + "params": { + "fileName": "const char *" + } + }, + { + "name": "LoadTextureFromImage", + "description": "Load texture from image data", + "returnType": "Texture2D", + "params": { + "image": "Image" + } + }, + { + "name": "LoadTextureCubemap", + "description": "Load cubemap from image, multiple image cubemap layouts supported", + "returnType": "TextureCubemap", + "params": { + "image": "Image", + "layout": "int" + } + }, + { + "name": "LoadRenderTexture", + "description": "Load texture for rendering (framebuffer)", + "returnType": "RenderTexture2D", + "params": { + "width": "int", + "height": "int" + } + }, + { + "name": "UnloadTexture", + "description": "Unload texture from GPU memory (VRAM)", + "returnType": "void", + "params": { + "texture": "Texture2D" + } + }, + { + "name": "UnloadRenderTexture", + "description": "Unload render texture from GPU memory (VRAM)", + "returnType": "void", + "params": { + "target": "RenderTexture2D" + } + }, + { + "name": "UpdateTexture", + "description": "Update GPU texture with new data", + "returnType": "void", + "params": { + "texture": "Texture2D", + "pixels": "const void *" + } + }, + { + "name": "UpdateTextureRec", + "description": "Update GPU texture rectangle with new data", + "returnType": "void", + "params": { + "texture": "Texture2D", + "rec": "Rectangle", + "pixels": "const void *" + } + }, + { + "name": "GenTextureMipmaps", + "description": "Generate GPU mipmaps for a texture", + "returnType": "void", + "params": { + "texture": "Texture2D *" + } + }, + { + "name": "SetTextureFilter", + "description": "Set texture scaling filter mode", + "returnType": "void", + "params": { + "texture": "Texture2D", + "filter": "int" + } + }, + { + "name": "SetTextureWrap", + "description": "Set texture wrapping mode", + "returnType": "void", + "params": { + "texture": "Texture2D", + "wrap": "int" + } + }, + { + "name": "DrawTexture", + "description": "Draw a Texture2D", + "returnType": "void", + "params": { + "texture": "Texture2D", + "posX": "int", + "posY": "int", + "tint": "Color" + } + }, + { + "name": "DrawTextureV", + "description": "Draw a Texture2D with position defined as Vector2", + "returnType": "void", + "params": { + "texture": "Texture2D", + "position": "Vector2", + "tint": "Color" + } + }, + { + "name": "DrawTextureEx", + "description": "Draw a Texture2D with extended parameters", + "returnType": "void", + "params": { + "texture": "Texture2D", + "position": "Vector2", + "rotation": "float", + "scale": "float", + "tint": "Color" + } + }, + { + "name": "DrawTextureRec", + "description": "Draw a part of a texture defined by a rectangle", + "returnType": "void", + "params": { + "texture": "Texture2D", + "source": "Rectangle", + "position": "Vector2", + "tint": "Color" + } + }, + { + "name": "DrawTextureQuad", + "description": "Draw texture quad with tiling and offset parameters", + "returnType": "void", + "params": { + "texture": "Texture2D", + "tiling": "Vector2", + "offset": "Vector2", + "quad": "Rectangle", + "tint": "Color" + } + }, + { + "name": "DrawTextureTiled", + "description": "Draw part of a texture (defined by a rectangle) with rotation and scale tiled into dest.", + "returnType": "void", + "params": { + "texture": "Texture2D", + "source": "Rectangle", + "dest": "Rectangle", + "origin": "Vector2", + "rotation": "float", + "scale": "float", + "tint": "Color" + } + }, + { + "name": "DrawTexturePro", + "description": "Draw a part of a texture defined by a rectangle with 'pro' parameters", + "returnType": "void", + "params": { + "texture": "Texture2D", + "source": "Rectangle", + "dest": "Rectangle", + "origin": "Vector2", + "rotation": "float", + "tint": "Color" + } + }, + { + "name": "DrawTextureNPatch", + "description": "Draws a texture (or part of it) that stretches or shrinks nicely", + "returnType": "void", + "params": { + "texture": "Texture2D", + "nPatchInfo": "NPatchInfo", + "dest": "Rectangle", + "origin": "Vector2", + "rotation": "float", + "tint": "Color" + } + }, + { + "name": "DrawTexturePoly", + "description": "Draw a textured polygon", + "returnType": "void", + "params": { + "texture": "Texture2D", + "center": "Vector2", + "points": "Vector2 *", + "texcoords": "Vector2 *", + "pointCount": "int", + "tint": "Color" + } + }, + { + "name": "Fade", + "description": "Get color with alpha applied, alpha goes from 0.0f to 1.0f", + "returnType": "Color", + "params": { + "color": "Color", + "alpha": "float" + } + }, + { + "name": "ColorToInt", + "description": "Get hexadecimal value for a Color", + "returnType": "int", + "params": { + "color": "Color" + } + }, + { + "name": "ColorNormalize", + "description": "Get Color normalized as float [0..1]", + "returnType": "Vector4", + "params": { + "color": "Color" + } + }, + { + "name": "ColorFromNormalized", + "description": "Get Color from normalized values [0..1]", + "returnType": "Color", + "params": { + "normalized": "Vector4" + } + }, + { + "name": "ColorToHSV", + "description": "Get HSV values for a Color, hue [0..360], saturation/value [0..1]", + "returnType": "Vector3", + "params": { + "color": "Color" + } + }, + { + "name": "ColorFromHSV", + "description": "Get a Color from HSV values, hue [0..360], saturation/value [0..1]", + "returnType": "Color", + "params": { + "hue": "float", + "saturation": "float", + "value": "float" + } + }, + { + "name": "ColorAlpha", + "description": "Get color with alpha applied, alpha goes from 0.0f to 1.0f", + "returnType": "Color", + "params": { + "color": "Color", + "alpha": "float" + } + }, + { + "name": "ColorAlphaBlend", + "description": "Get src alpha-blended into dst color with tint", + "returnType": "Color", + "params": { + "dst": "Color", + "src": "Color", + "tint": "Color" + } + }, + { + "name": "GetColor", + "description": "Get Color structure from hexadecimal value", + "returnType": "Color", + "params": { + "hexValue": "unsigned int" + } + }, + { + "name": "GetPixelColor", + "description": "Get Color from a source pixel pointer of certain format", + "returnType": "Color", + "params": { + "srcPtr": "void *", + "format": "int" + } + }, + { + "name": "SetPixelColor", + "description": "Set color formatted into destination pixel pointer", + "returnType": "void", + "params": { + "dstPtr": "void *", + "color": "Color", + "format": "int" + } + }, + { + "name": "GetPixelDataSize", + "description": "Get pixel data size in bytes for certain format", + "returnType": "int", + "params": { + "width": "int", + "height": "int", + "format": "int" + } + }, + { + "name": "GetFontDefault", + "description": "Get the default Font", + "returnType": "Font" + }, + { + "name": "LoadFont", + "description": "Load font from file into GPU memory (VRAM)", + "returnType": "Font", + "params": { + "fileName": "const char *" + } + }, + { + "name": "LoadFontEx", + "description": "Load font from file with extended parameters, use NULL for fontChars and 0 for glyphCount to load the default character set", + "returnType": "Font", + "params": { + "fileName": "const char *", + "fontSize": "int", + "fontChars": "int *", + "glyphCount": "int" + } + }, + { + "name": "LoadFontFromImage", + "description": "Load font from Image (XNA style)", + "returnType": "Font", + "params": { + "image": "Image", + "key": "Color", + "firstChar": "int" + } + }, + { + "name": "LoadFontFromMemory", + "description": "Load font from memory buffer, fileType refers to extension: i.e. '.ttf'", + "returnType": "Font", + "params": { + "fileType": "const char *", + "fileData": "const unsigned char *", + "dataSize": "int", + "fontSize": "int", + "fontChars": "int *", + "glyphCount": "int" + } + }, + { + "name": "LoadFontData", + "description": "Load font data for further use", + "returnType": "GlyphInfo *", + "params": { + "fileData": "const unsigned char *", + "dataSize": "int", + "fontSize": "int", + "fontChars": "int *", + "glyphCount": "int", + "type": "int" + } + }, + { + "name": "GenImageFontAtlas", + "description": "Generate image font atlas using chars info", + "returnType": "Image", + "params": { + "chars": "const GlyphInfo *", + "recs": "Rectangle **", + "glyphCount": "int", + "fontSize": "int", + "padding": "int", + "packMethod": "int" + } + }, + { + "name": "UnloadFontData", + "description": "Unload font chars info data (RAM)", + "returnType": "void", + "params": { + "chars": "GlyphInfo *", + "glyphCount": "int" + } + }, + { + "name": "UnloadFont", + "description": "Unload Font from GPU memory (VRAM)", + "returnType": "void", + "params": { + "font": "Font" + } + }, + { + "name": "DrawFPS", + "description": "Draw current FPS", + "returnType": "void", + "params": { + "posX": "int", + "posY": "int" + } + }, + { + "name": "DrawText", + "description": "Draw text (using default font)", + "returnType": "void", + "params": { + "text": "const char *", + "posX": "int", + "posY": "int", + "fontSize": "int", + "color": "Color" + } + }, + { + "name": "DrawTextEx", + "description": "Draw text using font and additional parameters", + "returnType": "void", + "params": { + "font": "Font", + "text": "const char *", + "position": "Vector2", + "fontSize": "float", + "spacing": "float", + "tint": "Color" + } + }, + { + "name": "DrawTextPro", + "description": "Draw text using Font and pro parameters (rotation)", + "returnType": "void", + "params": { + "font": "Font", + "text": "const char *", + "position": "Vector2", + "origin": "Vector2", + "rotation": "float", + "fontSize": "float", + "spacing": "float", + "tint": "Color" + } + }, + { + "name": "DrawTextCodepoint", + "description": "Draw one character (codepoint)", + "returnType": "void", + "params": { + "font": "Font", + "codepoint": "int", + "position": "Vector2", + "fontSize": "float", + "tint": "Color" + } + }, + { + "name": "MeasureText", + "description": "Measure string width for default font", + "returnType": "int", + "params": { + "text": "const char *", + "fontSize": "int" + } + }, + { + "name": "MeasureTextEx", + "description": "Measure string size for Font", + "returnType": "Vector2", + "params": { + "font": "Font", + "text": "const char *", + "fontSize": "float", + "spacing": "float" + } + }, + { + "name": "GetGlyphIndex", + "description": "Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found", + "returnType": "int", + "params": { + "font": "Font", + "codepoint": "int" + } + }, + { + "name": "GetGlyphInfo", + "description": "Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found", + "returnType": "GlyphInfo", + "params": { + "font": "Font", + "codepoint": "int" + } + }, + { + "name": "GetGlyphAtlasRec", + "description": "Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found", + "returnType": "Rectangle", + "params": { + "font": "Font", + "codepoint": "int" + } + }, + { + "name": "LoadCodepoints", + "description": "Load all codepoints from a UTF-8 text string, codepoints count returned by parameter", + "returnType": "int *", + "params": { + "text": "const char *", + "count": "int *" + } + }, + { + "name": "UnloadCodepoints", + "description": "Unload codepoints data from memory", + "returnType": "void", + "params": { + "codepoints": "int *" + } + }, + { + "name": "GetCodepointCount", + "description": "Get total number of codepoints in a UTF-8 encoded string", + "returnType": "int", + "params": { + "text": "const char *" + } + }, + { + "name": "GetCodepoint", + "description": "Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure", + "returnType": "int", + "params": { + "text": "const char *", + "bytesProcessed": "int *" + } + }, + { + "name": "CodepointToUTF8", + "description": "Encode one codepoint into UTF-8 byte array (array length returned as parameter)", + "returnType": "const char *", + "params": { + "codepoint": "int", + "byteSize": "int *" + } + }, + { + "name": "TextCodepointsToUTF8", + "description": "Encode text as codepoints array into UTF-8 text string (WARNING: memory must be freed!)", + "returnType": "char *", + "params": { + "codepoints": "int *", + "length": "int" + } + }, + { + "name": "TextCopy", + "description": "Copy one string to another, returns bytes copied", + "returnType": "int", + "params": { + "dst": "char *", + "src": "const char *" + } + }, + { + "name": "TextIsEqual", + "description": "Check if two text string are equal", + "returnType": "bool", + "params": { + "text1": "const char *", + "text2": "const char *" + } + }, + { + "name": "TextLength", + "description": "Get text length, checks for '\\0' ending", + "returnType": "unsigned int", + "params": { + "text": "const char *" + } + }, + { + "name": "TextFormat", + "description": "Text formatting with variables (sprintf() style)", + "returnType": "const char *", + "params": { + "text": "const char *", + "": "" + } + }, + { + "name": "TextSubtext", + "description": "Get a piece of a text string", + "returnType": "const char *", + "params": { + "text": "const char *", + "position": "int", + "length": "int" + } + }, + { + "name": "TextReplace", + "description": "Replace text string (WARNING: memory must be freed!)", + "returnType": "char *", + "params": { + "text": "char *", + "replace": "const char *", + "by": "const char *" + } + }, + { + "name": "TextInsert", + "description": "Insert text in a position (WARNING: memory must be freed!)", + "returnType": "char *", + "params": { + "text": "const char *", + "insert": "const char *", + "position": "int" + } + }, + { + "name": "TextJoin", + "description": "Join text strings with delimiter", + "returnType": "const char *", + "params": { + "textList": "const char **", + "count": "int", + "delimiter": "const char *" + } + }, + { + "name": "TextSplit", + "description": "Split text into multiple strings", + "returnType": "const char **", + "params": { + "text": "const char *", + "delimiter": "char", + "count": "int *" + } + }, + { + "name": "TextAppend", + "description": "Append text at specific position and move cursor!", + "returnType": "void", + "params": { + "text": "char *", + "append": "const char *", + "position": "int *" + } + }, + { + "name": "TextFindIndex", + "description": "Find first text occurrence within a string", + "returnType": "int", + "params": { + "text": "const char *", + "find": "const char *" + } + }, + { + "name": "TextToUpper", + "description": "Get upper case version of provided string", + "returnType": "const char *", + "params": { + "text": "const char *" + } + }, + { + "name": "TextToLower", + "description": "Get lower case version of provided string", + "returnType": "const char *", + "params": { + "text": "const char *" + } + }, + { + "name": "TextToPascal", + "description": "Get Pascal case notation version of provided string", + "returnType": "const char *", + "params": { + "text": "const char *" + } + }, + { + "name": "TextToInteger", + "description": "Get integer value from text (negative values not supported)", + "returnType": "int", + "params": { + "text": "const char *" + } + }, + { + "name": "DrawLine3D", + "description": "Draw a line in 3D world space", + "returnType": "void", + "params": { + "startPos": "Vector3", + "endPos": "Vector3", + "color": "Color" + } + }, + { + "name": "DrawPoint3D", + "description": "Draw a point in 3D space, actually a small line", + "returnType": "void", + "params": { + "position": "Vector3", + "color": "Color" + } + }, + { + "name": "DrawCircle3D", + "description": "Draw a circle in 3D world space", + "returnType": "void", + "params": { + "center": "Vector3", + "radius": "float", + "rotationAxis": "Vector3", + "rotationAngle": "float", + "color": "Color" + } + }, + { + "name": "DrawTriangle3D", + "description": "Draw a color-filled triangle (vertex in counter-clockwise order!)", + "returnType": "void", + "params": { + "v1": "Vector3", + "v2": "Vector3", + "v3": "Vector3", + "color": "Color" + } + }, + { + "name": "DrawTriangleStrip3D", + "description": "Draw a triangle strip defined by points", + "returnType": "void", + "params": { + "points": "Vector3 *", + "pointCount": "int", + "color": "Color" + } + }, + { + "name": "DrawCube", + "description": "Draw cube", + "returnType": "void", + "params": { + "position": "Vector3", + "width": "float", + "height": "float", + "length": "float", + "color": "Color" + } + }, + { + "name": "DrawCubeV", + "description": "Draw cube (Vector version)", + "returnType": "void", + "params": { + "position": "Vector3", + "size": "Vector3", + "color": "Color" + } + }, + { + "name": "DrawCubeWires", + "description": "Draw cube wires", + "returnType": "void", + "params": { + "position": "Vector3", + "width": "float", + "height": "float", + "length": "float", + "color": "Color" + } + }, + { + "name": "DrawCubeWiresV", + "description": "Draw cube wires (Vector version)", + "returnType": "void", + "params": { + "position": "Vector3", + "size": "Vector3", + "color": "Color" + } + }, + { + "name": "DrawCubeTexture", + "description": "Draw cube textured", + "returnType": "void", + "params": { + "texture": "Texture2D", + "position": "Vector3", + "width": "float", + "height": "float", + "length": "float", + "color": "Color" + } + }, + { + "name": "DrawCubeTextureRec", + "description": "Draw cube with a region of a texture", + "returnType": "void", + "params": { + "texture": "Texture2D", + "source": "Rectangle", + "position": "Vector3", + "width": "float", + "height": "float", + "length": "float", + "color": "Color" + } + }, + { + "name": "DrawSphere", + "description": "Draw sphere", + "returnType": "void", + "params": { + "centerPos": "Vector3", + "radius": "float", + "color": "Color" + } + }, + { + "name": "DrawSphereEx", + "description": "Draw sphere with extended parameters", + "returnType": "void", + "params": { + "centerPos": "Vector3", + "radius": "float", + "rings": "int", + "slices": "int", + "color": "Color" + } + }, + { + "name": "DrawSphereWires", + "description": "Draw sphere wires", + "returnType": "void", + "params": { + "centerPos": "Vector3", + "radius": "float", + "rings": "int", + "slices": "int", + "color": "Color" + } + }, + { + "name": "DrawCylinder", + "description": "Draw a cylinder/cone", + "returnType": "void", + "params": { + "position": "Vector3", + "radiusTop": "float", + "radiusBottom": "float", + "height": "float", + "slices": "int", + "color": "Color" + } + }, + { + "name": "DrawCylinderEx", + "description": "Draw a cylinder with base at startPos and top at endPos", + "returnType": "void", + "params": { + "startPos": "Vector3", + "endPos": "Vector3", + "startRadius": "float", + "endRadius": "float", + "sides": "int", + "color": "Color" + } + }, + { + "name": "DrawCylinderWires", + "description": "Draw a cylinder/cone wires", + "returnType": "void", + "params": { + "position": "Vector3", + "radiusTop": "float", + "radiusBottom": "float", + "height": "float", + "slices": "int", + "color": "Color" + } + }, + { + "name": "DrawCylinderWiresEx", + "description": "Draw a cylinder wires with base at startPos and top at endPos", + "returnType": "void", + "params": { + "startPos": "Vector3", + "endPos": "Vector3", + "startRadius": "float", + "endRadius": "float", + "sides": "int", + "color": "Color" + } + }, + { + "name": "DrawPlane", + "description": "Draw a plane XZ", + "returnType": "void", + "params": { + "centerPos": "Vector3", + "size": "Vector2", + "color": "Color" + } + }, + { + "name": "DrawRay", + "description": "Draw a ray line", + "returnType": "void", + "params": { + "ray": "Ray", + "color": "Color" + } + }, + { + "name": "DrawGrid", + "description": "Draw a grid (centered at (0, 0, 0))", + "returnType": "void", + "params": { + "slices": "int", + "spacing": "float" + } + }, + { + "name": "LoadModel", + "description": "Load model from files (meshes and materials)", + "returnType": "Model", + "params": { + "fileName": "const char *" + } + }, + { + "name": "LoadModelFromMesh", + "description": "Load model from generated mesh (default material)", + "returnType": "Model", + "params": { + "mesh": "Mesh" + } + }, + { + "name": "UnloadModel", + "description": "Unload model (including meshes) from memory (RAM and/or VRAM)", + "returnType": "void", + "params": { + "model": "Model" + } + }, + { + "name": "UnloadModelKeepMeshes", + "description": "Unload model (but not meshes) from memory (RAM and/or VRAM)", + "returnType": "void", + "params": { + "model": "Model" + } + }, + { + "name": "GetModelBoundingBox", + "description": "Compute model bounding box limits (considers all meshes)", + "returnType": "BoundingBox", + "params": { + "model": "Model" + } + }, + { + "name": "DrawModel", + "description": "Draw a model (with texture if set)", + "returnType": "void", + "params": { + "model": "Model", + "position": "Vector3", + "scale": "float", + "tint": "Color" + } + }, + { + "name": "DrawModelEx", + "description": "Draw a model with extended parameters", + "returnType": "void", + "params": { + "model": "Model", + "position": "Vector3", + "rotationAxis": "Vector3", + "rotationAngle": "float", + "scale": "Vector3", + "tint": "Color" + } + }, + { + "name": "DrawModelWires", + "description": "Draw a model wires (with texture if set)", + "returnType": "void", + "params": { + "model": "Model", + "position": "Vector3", + "scale": "float", + "tint": "Color" + } + }, + { + "name": "DrawModelWiresEx", + "description": "Draw a model wires (with texture if set) with extended parameters", + "returnType": "void", + "params": { + "model": "Model", + "position": "Vector3", + "rotationAxis": "Vector3", + "rotationAngle": "float", + "scale": "Vector3", + "tint": "Color" + } + }, + { + "name": "DrawBoundingBox", + "description": "Draw bounding box (wires)", + "returnType": "void", + "params": { + "box": "BoundingBox", + "color": "Color" + } + }, + { + "name": "DrawBillboard", + "description": "Draw a billboard texture", + "returnType": "void", + "params": { + "camera": "Camera", + "texture": "Texture2D", + "position": "Vector3", + "size": "float", + "tint": "Color" + } + }, + { + "name": "DrawBillboardRec", + "description": "Draw a billboard texture defined by source", + "returnType": "void", + "params": { + "camera": "Camera", + "texture": "Texture2D", + "source": "Rectangle", + "position": "Vector3", + "size": "Vector2", + "tint": "Color" + } + }, + { + "name": "DrawBillboardPro", + "description": "Draw a billboard texture defined by source and rotation", + "returnType": "void", + "params": { + "camera": "Camera", + "texture": "Texture2D", + "source": "Rectangle", + "position": "Vector3", + "up": "Vector3", + "size": "Vector2", + "origin": "Vector2", + "rotation": "float", + "tint": "Color" + } + }, + { + "name": "UploadMesh", + "description": "Upload mesh vertex data in GPU and provide VAO/VBO ids", + "returnType": "void", + "params": { + "mesh": "Mesh *", + "dynamic": "bool" + } + }, + { + "name": "UpdateMeshBuffer", + "description": "Update mesh vertex data in GPU for a specific buffer index", + "returnType": "void", + "params": { + "mesh": "Mesh", + "index": "int", + "data": "void *", + "dataSize": "int", + "offset": "int" + } + }, + { + "name": "UnloadMesh", + "description": "Unload mesh data from CPU and GPU", + "returnType": "void", + "params": { + "mesh": "Mesh" + } + }, + { + "name": "DrawMesh", + "description": "Draw a 3d mesh with material and transform", + "returnType": "void", + "params": { + "mesh": "Mesh", + "material": "Material", + "transform": "Matrix" + } + }, + { + "name": "DrawMeshInstanced", + "description": "Draw multiple mesh instances with material and different transforms", + "returnType": "void", + "params": { + "mesh": "Mesh", + "material": "Material", + "transforms": "Matrix *", + "instances": "int" + } + }, + { + "name": "ExportMesh", + "description": "Export mesh data to file, returns true on success", + "returnType": "bool", + "params": { + "mesh": "Mesh", + "fileName": "const char *" + } + }, + { + "name": "GetMeshBoundingBox", + "description": "Compute mesh bounding box limits", + "returnType": "BoundingBox", + "params": { + "mesh": "Mesh" + } + }, + { + "name": "GenMeshTangents", + "description": "Compute mesh tangents", + "returnType": "void", + "params": { + "mesh": "Mesh *" + } + }, + { + "name": "GenMeshBinormals", + "description": "Compute mesh binormals", + "returnType": "void", + "params": { + "mesh": "Mesh *" + } + }, + { + "name": "GenMeshPoly", + "description": "Generate polygonal mesh", + "returnType": "Mesh", + "params": { + "sides": "int", + "radius": "float" + } + }, + { + "name": "GenMeshPlane", + "description": "Generate plane mesh (with subdivisions)", + "returnType": "Mesh", + "params": { + "width": "float", + "length": "float", + "resX": "int", + "resZ": "int" + } + }, + { + "name": "GenMeshCube", + "description": "Generate cuboid mesh", + "returnType": "Mesh", + "params": { + "width": "float", + "height": "float", + "length": "float" + } + }, + { + "name": "GenMeshSphere", + "description": "Generate sphere mesh (standard sphere)", + "returnType": "Mesh", + "params": { + "radius": "float", + "rings": "int", + "slices": "int" + } + }, + { + "name": "GenMeshHemiSphere", + "description": "Generate half-sphere mesh (no bottom cap)", + "returnType": "Mesh", + "params": { + "radius": "float", + "rings": "int", + "slices": "int" + } + }, + { + "name": "GenMeshCylinder", + "description": "Generate cylinder mesh", + "returnType": "Mesh", + "params": { + "radius": "float", + "height": "float", + "slices": "int" + } + }, + { + "name": "GenMeshCone", + "description": "Generate cone/pyramid mesh", + "returnType": "Mesh", + "params": { + "radius": "float", + "height": "float", + "slices": "int" + } + }, + { + "name": "GenMeshTorus", + "description": "Generate torus mesh", + "returnType": "Mesh", + "params": { + "radius": "float", + "size": "float", + "radSeg": "int", + "sides": "int" + } + }, + { + "name": "GenMeshKnot", + "description": "Generate trefoil knot mesh", + "returnType": "Mesh", + "params": { + "radius": "float", + "size": "float", + "radSeg": "int", + "sides": "int" + } + }, + { + "name": "GenMeshHeightmap", + "description": "Generate heightmap mesh from image data", + "returnType": "Mesh", + "params": { + "heightmap": "Image", + "size": "Vector3" + } + }, + { + "name": "GenMeshCubicmap", + "description": "Generate cubes-based map mesh from image data", + "returnType": "Mesh", + "params": { + "cubicmap": "Image", + "cubeSize": "Vector3" + } + }, + { + "name": "LoadMaterials", + "description": "Load materials from model file", + "returnType": "Material *", + "params": { + "fileName": "const char *", + "materialCount": "int *" + } + }, + { + "name": "LoadMaterialDefault", + "description": "Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)", + "returnType": "Material" + }, + { + "name": "UnloadMaterial", + "description": "Unload material from GPU memory (VRAM)", + "returnType": "void", + "params": { + "material": "Material" + } + }, + { + "name": "SetMaterialTexture", + "description": "Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...)", + "returnType": "void", + "params": { + "material": "Material *", + "mapType": "int", + "texture": "Texture2D" + } + }, + { + "name": "SetModelMeshMaterial", + "description": "Set material for a mesh", + "returnType": "void", + "params": { + "model": "Model *", + "meshId": "int", + "materialId": "int" + } + }, + { + "name": "LoadModelAnimations", + "description": "Load model animations from file", + "returnType": "ModelAnimation *", + "params": { + "fileName": "const char *", + "animCount": "unsigned int *" + } + }, + { + "name": "UpdateModelAnimation", + "description": "Update model animation pose", + "returnType": "void", + "params": { + "model": "Model", + "anim": "ModelAnimation", + "frame": "int" + } + }, + { + "name": "UnloadModelAnimation", + "description": "Unload animation data", + "returnType": "void", + "params": { + "anim": "ModelAnimation" + } + }, + { + "name": "UnloadModelAnimations", + "description": "Unload animation array data", + "returnType": "void", + "params": { + "animations": "ModelAnimation *", + "count": "unsigned int" + } + }, + { + "name": "IsModelAnimationValid", + "description": "Check model animation skeleton match", + "returnType": "bool", + "params": { + "model": "Model", + "anim": "ModelAnimation" + } + }, + { + "name": "CheckCollisionSpheres", + "description": "Check collision between two spheres", + "returnType": "bool", + "params": { + "center1": "Vector3", + "radius1": "float", + "center2": "Vector3", + "radius2": "float" + } + }, + { + "name": "CheckCollisionBoxes", + "description": "Check collision between two bounding boxes", + "returnType": "bool", + "params": { + "box1": "BoundingBox", + "box2": "BoundingBox" + } + }, + { + "name": "CheckCollisionBoxSphere", + "description": "Check collision between box and sphere", + "returnType": "bool", + "params": { + "box": "BoundingBox", + "center": "Vector3", + "radius": "float" + } + }, + { + "name": "GetRayCollisionSphere", + "description": "Get collision info between ray and sphere", + "returnType": "RayCollision", + "params": { + "ray": "Ray", + "center": "Vector3", + "radius": "float" + } + }, + { + "name": "GetRayCollisionBox", + "description": "Get collision info between ray and box", + "returnType": "RayCollision", + "params": { + "ray": "Ray", + "box": "BoundingBox" + } + }, + { + "name": "GetRayCollisionModel", + "description": "Get collision info between ray and model", + "returnType": "RayCollision", + "params": { + "ray": "Ray", + "model": "Model" + } + }, + { + "name": "GetRayCollisionMesh", + "description": "Get collision info between ray and mesh", + "returnType": "RayCollision", + "params": { + "ray": "Ray", + "mesh": "Mesh", + "transform": "Matrix" + } + }, + { + "name": "GetRayCollisionTriangle", + "description": "Get collision info between ray and triangle", + "returnType": "RayCollision", + "params": { + "ray": "Ray", + "p1": "Vector3", + "p2": "Vector3", + "p3": "Vector3" + } + }, + { + "name": "GetRayCollisionQuad", + "description": "Get collision info between ray and quad", + "returnType": "RayCollision", + "params": { + "ray": "Ray", + "p1": "Vector3", + "p2": "Vector3", + "p3": "Vector3", + "p4": "Vector3" + } + }, + { + "name": "InitAudioDevice", + "description": "Initialize audio device and context", + "returnType": "void" + }, + { + "name": "CloseAudioDevice", + "description": "Close the audio device and context", + "returnType": "void" + }, + { + "name": "IsAudioDeviceReady", + "description": "Check if audio device has been initialized successfully", + "returnType": "bool" + }, + { + "name": "SetMasterVolume", + "description": "Set master volume (listener)", + "returnType": "void", + "params": { + "volume": "float" + } + }, + { + "name": "LoadWave", + "description": "Load wave data from file", + "returnType": "Wave", + "params": { + "fileName": "const char *" + } + }, + { + "name": "LoadWaveFromMemory", + "description": "Load wave from memory buffer, fileType refers to extension: i.e. '.wav'", + "returnType": "Wave", + "params": { + "fileType": "const char *", + "fileData": "const unsigned char *", + "dataSize": "int" + } + }, + { + "name": "LoadSound", + "description": "Load sound from file", + "returnType": "Sound", + "params": { + "fileName": "const char *" + } + }, + { + "name": "LoadSoundFromWave", + "description": "Load sound from wave data", + "returnType": "Sound", + "params": { + "wave": "Wave" + } + }, + { + "name": "UpdateSound", + "description": "Update sound buffer with new data", + "returnType": "void", + "params": { + "sound": "Sound", + "data": "const void *", + "sampleCount": "int" + } + }, + { + "name": "UnloadWave", + "description": "Unload wave data", + "returnType": "void", + "params": { + "wave": "Wave" + } + }, + { + "name": "UnloadSound", + "description": "Unload sound", + "returnType": "void", + "params": { + "sound": "Sound" + } + }, + { + "name": "ExportWave", + "description": "Export wave data to file, returns true on success", + "returnType": "bool", + "params": { + "wave": "Wave", + "fileName": "const char *" + } + }, + { + "name": "ExportWaveAsCode", + "description": "Export wave sample data to code (.h), returns true on success", + "returnType": "bool", + "params": { + "wave": "Wave", + "fileName": "const char *" + } + }, + { + "name": "PlaySound", + "description": "Play a sound", + "returnType": "void", + "params": { + "sound": "Sound" + } + }, + { + "name": "StopSound", + "description": "Stop playing a sound", + "returnType": "void", + "params": { + "sound": "Sound" + } + }, + { + "name": "PauseSound", + "description": "Pause a sound", + "returnType": "void", + "params": { + "sound": "Sound" + } + }, + { + "name": "ResumeSound", + "description": "Resume a paused sound", + "returnType": "void", + "params": { + "sound": "Sound" + } + }, + { + "name": "PlaySoundMulti", + "description": "Play a sound (using multichannel buffer pool)", + "returnType": "void", + "params": { + "sound": "Sound" + } + }, + { + "name": "StopSoundMulti", + "description": "Stop any sound playing (using multichannel buffer pool)", + "returnType": "void" + }, + { + "name": "GetSoundsPlaying", + "description": "Get number of sounds playing in the multichannel", + "returnType": "int" + }, + { + "name": "IsSoundPlaying", + "description": "Check if a sound is currently playing", + "returnType": "bool", + "params": { + "sound": "Sound" + } + }, + { + "name": "SetSoundVolume", + "description": "Set volume for a sound (1.0 is max level)", + "returnType": "void", + "params": { + "sound": "Sound", + "volume": "float" + } + }, + { + "name": "SetSoundPitch", + "description": "Set pitch for a sound (1.0 is base level)", + "returnType": "void", + "params": { + "sound": "Sound", + "pitch": "float" + } + }, + { + "name": "WaveFormat", + "description": "Convert wave data to desired format", + "returnType": "void", + "params": { + "wave": "Wave *", + "sampleRate": "int", + "sampleSize": "int", + "channels": "int" + } + }, + { + "name": "WaveCopy", + "description": "Copy a wave to a new wave", + "returnType": "Wave", + "params": { + "wave": "Wave" + } + }, + { + "name": "WaveCrop", + "description": "Crop a wave to defined samples range", + "returnType": "void", + "params": { + "wave": "Wave *", + "initSample": "int", + "finalSample": "int" + } + }, + { + "name": "LoadWaveSamples", + "description": "Load samples data from wave as a floats array", + "returnType": "float *", + "params": { + "wave": "Wave" + } + }, + { + "name": "UnloadWaveSamples", + "description": "Unload samples data loaded with LoadWaveSamples()", + "returnType": "void", + "params": { + "samples": "float *" + } + }, + { + "name": "LoadMusicStream", + "description": "Load music stream from file", + "returnType": "Music", + "params": { + "fileName": "const char *" + } + }, + { + "name": "LoadMusicStreamFromMemory", + "description": "Load music stream from data", + "returnType": "Music", + "params": { + "fileType": "const char *", + "data": "unsigned char *", + "dataSize": "int" + } + }, + { + "name": "UnloadMusicStream", + "description": "Unload music stream", + "returnType": "void", + "params": { + "music": "Music" + } + }, + { + "name": "PlayMusicStream", + "description": "Start music playing", + "returnType": "void", + "params": { + "music": "Music" + } + }, + { + "name": "IsMusicStreamPlaying", + "description": "Check if music is playing", + "returnType": "bool", + "params": { + "music": "Music" + } + }, + { + "name": "UpdateMusicStream", + "description": "Updates buffers for music streaming", + "returnType": "void", + "params": { + "music": "Music" + } + }, + { + "name": "StopMusicStream", + "description": "Stop music playing", + "returnType": "void", + "params": { + "music": "Music" + } + }, + { + "name": "PauseMusicStream", + "description": "Pause music playing", + "returnType": "void", + "params": { + "music": "Music" + } + }, + { + "name": "ResumeMusicStream", + "description": "Resume playing paused music", + "returnType": "void", + "params": { + "music": "Music" + } + }, + { + "name": "SeekMusicStream", + "description": "Seek music to a position (in seconds)", + "returnType": "void", + "params": { + "music": "Music", + "position": "float" + } + }, + { + "name": "SetMusicVolume", + "description": "Set volume for music (1.0 is max level)", + "returnType": "void", + "params": { + "music": "Music", + "volume": "float" + } + }, + { + "name": "SetMusicPitch", + "description": "Set pitch for a music (1.0 is base level)", + "returnType": "void", + "params": { + "music": "Music", + "pitch": "float" + } + }, + { + "name": "GetMusicTimeLength", + "description": "Get music time length (in seconds)", + "returnType": "float", + "params": { + "music": "Music" + } + }, + { + "name": "GetMusicTimePlayed", + "description": "Get current music time played (in seconds)", + "returnType": "float", + "params": { + "music": "Music" + } + }, + { + "name": "LoadAudioStream", + "description": "Load audio stream (to stream raw audio pcm data)", + "returnType": "AudioStream", + "params": { + "sampleRate": "unsigned int", + "sampleSize": "unsigned int", + "channels": "unsigned int" + } + }, + { + "name": "UnloadAudioStream", + "description": "Unload audio stream and free memory", + "returnType": "void", + "params": { + "stream": "AudioStream" + } + }, + { + "name": "UpdateAudioStream", + "description": "Update audio stream buffers with data", + "returnType": "void", + "params": { + "stream": "AudioStream", + "data": "const void *", + "frameCount": "int" + } + }, + { + "name": "IsAudioStreamProcessed", + "description": "Check if any audio stream buffers requires refill", + "returnType": "bool", + "params": { + "stream": "AudioStream" + } + }, + { + "name": "PlayAudioStream", + "description": "Play audio stream", + "returnType": "void", + "params": { + "stream": "AudioStream" + } + }, + { + "name": "PauseAudioStream", + "description": "Pause audio stream", + "returnType": "void", + "params": { + "stream": "AudioStream" + } + }, + { + "name": "ResumeAudioStream", + "description": "Resume audio stream", + "returnType": "void", + "params": { + "stream": "AudioStream" + } + }, + { + "name": "IsAudioStreamPlaying", + "description": "Check if audio stream is playing", + "returnType": "bool", + "params": { + "stream": "AudioStream" + } + }, + { + "name": "StopAudioStream", + "description": "Stop audio stream", + "returnType": "void", + "params": { + "stream": "AudioStream" + } + }, + { + "name": "SetAudioStreamVolume", + "description": "Set volume for audio stream (1.0 is max level)", + "returnType": "void", + "params": { + "stream": "AudioStream", + "volume": "float" + } + }, + { + "name": "SetAudioStreamPitch", + "description": "Set pitch for audio stream (1.0 is base level)", + "returnType": "void", + "params": { + "stream": "AudioStream", + "pitch": "float" + } + }, + { + "name": "SetAudioStreamBufferSizeDefault", + "description": "Default size for new audio streams", + "returnType": "void", + "params": { + "size": "int" + } + } + ] +} diff --git a/raylib_gen.nim b/raylib_gen.nim new file mode 100644 index 0000000..f678080 --- /dev/null +++ b/raylib_gen.nim @@ -0,0 +1,459 @@ +import common, std/[algorithm, streams] +import strutils except indent + +const + indWidth = 2 + extraTypes = [ + "Quaternion* = Vector4 ## Quaternion, 4 components (Vector4 alias)", + "Texture2D* = Texture ## Texture2D, same as Texture", + "TextureCubemap* = Texture ## TextureCubemap, same as Texture", + "RenderTexture2D* = RenderTexture ## RenderTexture2D, same as RenderTexture", + "Camera* = Camera3D ## Camera type fallback, defaults to Camera3D", + "RAudioBuffer* {.importc: \"rAudioBuffer\", bycopy.} = object" + ] + header = """ +const lext = when defined(windows): ".dll" elif defined(macosx): ".dylib" else: ".so" +{.pragma: rlapi, cdecl, dynlib: "libraylib" & lext.} + +const + RaylibVersion* = "4.0" + + MaxShaderLocations* = 32 ## Maximum number of shader locations supported + MaxMaterialMaps* = 12 ## Maximum number of shader maps supported + MaxMeshVertexBuffers* = 7 ## Maximum vertex buffers (VBO) per mesh +""" + flagsHelper = """ + + Enums = ConfigFlags|Gesture + Flag*[E: Enums] = distinct uint32 + +proc flag*[E: Enums](e: varargs[E]): Flag[E] {.inline.} = + var res = 0'u32 + for val in items(e): + res = res or uint32(val) + Flag[E](res) +""" + duplicateVal = """ + +const + Menu* = KeyboardKey.R ## Key: Android menu button +""" + colors = """ + + LightGray* = Color(r: 200, g: 200, b: 200, a: 255) + Gray* = Color(r: 130, g: 130, b: 130, a: 255) + DarkGray* = Color(r: 80, g: 80, b: 80, a: 255) + Yellow* = Color(r: 253, g: 249, b: 0, a: 255) + Gold* = Color(r: 255, g: 203, b: 0, a: 255) + Orange* = Color(r: 255, g: 161, b: 0, a: 255) + Pink* = Color(r: 255, g: 109, b: 194, a: 255) + Red* = Color(r: 230, g: 41, b: 55, a: 255) + Maroon* = Color(r: 190, g: 33, b: 55, a: 255) + Green* = Color(r: 0, g: 228, b: 48, a: 255) + Lime* = Color(r: 0, g: 158, b: 47, a: 255) + DarkGreen* = Color(r: 0, g: 117, b: 44, a: 255) + SkyBlue* = Color(r: 102, g: 191, b: 255, a: 255) + Blue* = Color(r: 0, g: 121, b: 241, a: 255) + DarkBlue* = Color(r: 0, g: 82, b: 172, a: 255) + Purple* = Color(r: 200, g: 122, b: 255, a: 255) + Violet* = Color(r: 135, g: 60, b: 190, a: 255) + DarkPurple* = Color(r: 112, g: 31, b: 126, a: 255) + Beige* = Color(r: 211, g: 176, b: 131, a: 255) + Brown* = Color(r: 127, g: 106, b: 79, a: 255) + DarkBrown* = Color(r: 76, g: 63, b: 47, a: 255) + White* = Color(r: 255, g: 255, b: 255, a: 255) + Black* = Color(r: 0, g: 0, b: 0, a: 255) + Blank* = Color(r: 0, g: 0, b: 0, a: 0) + Magenta* = Color(r: 255, g: 0, b: 255, a: 255) + RayWhite* = Color(r: 245, g: 245, b: 245, a: 255) +""" + enumPrefixes = [ + ("ConfigFlags", "FLAG_"), + ("TraceLogLevel", "LOG_"), + ("KeyboardKey", "KEY_"), + ("MouseButton", "MOUSE_BUTTON_"), + ("MouseCursor", "MOUSE_CURSOR_"), + ("GamepadButton", "GAMEPAD_BUTTON_"), + ("GamepadAxis", "GAMEPAD_AXIS_"), + ("MaterialMapIndex", "MATERIAL_MAP_"), + ("ShaderLocationIndex", "SHADER_LOC_"), + ("ShaderUniformDataType", "SHADER_UNIFORM_"), + ("ShaderAttributeDataType", "SHADER_ATTRIB_"), + ("PixelFormat", "PIXELFORMAT_"), + ("TextureFilter", "TEXTURE_FILTER_"), + ("TextureWrap", "TEXTURE_WRAP_"), + ("CubemapLayout", "CUBEMAP_LAYOUT_"), + ("FontType", "FONT_"), + ("BlendMode", "BLEND_"), + ("Gesture", "GESTURE_"), + ("CameraMode", "CAMERA_"), + ("CameraProjection", "CAMERA_"), + ("NPatchLayout", "NPATCH_") + ] + enumInFuncParams = [ + # KeyboardKey + ("IsKeyPressed", "KeyboardKey", @["key"]), + ("IsKeyDown", "KeyboardKey", @["key"]), + ("IsKeyReleased", "KeyboardKey", @["key"]), + ("IsKeyUp", "KeyboardKey", @["key"]), + ("SetExitKey", "KeyboardKey", @["key"]), + ("GetKeyPressed", "KeyboardKey", @["returnType"]), + ("SetCameraPanControl", "KeyboardKey", @["keyPan"]), + ("SetCameraAltControl", "KeyboardKey", @["keyAlt"]), + ("SetCameraSmoothZoomControl", "KeyboardKey", @["keySmoothZoom"]), + ("SetCameraMoveControls", "KeyboardKey", @["keyFront", "keyBack", "keyRight", "keyLeft", "keyUp", "keyDown"]), + # GamepadButton + ("IsGamepadButtonPressed", "GamepadButton", @["button"]), + ("IsGamepadButtonDown", "GamepadButton", @["button"]), + ("IsGamepadButtonReleased", "GamepadButton", @["button"]), + ("IsGamepadButtonUp", "GamepadButton", @["button"]), + ("GetGamepadButtonPressed", "GamepadButton", @["returnType"]), + # GamepadAxis + ("GetGamepadAxisMovement", "GamepadAxis", @["axis"]), + # MouseCursor + ("SetMouseCursor", "MouseCursor", @["cursor"]), + # MouseButton + ("IsMouseButtonPressed", "MouseButton", @["button"]), + ("IsMouseButtonDown", "MouseButton", @["button"]), + ("IsMouseButtonReleased", "MouseButton", @["button"]), + ("IsMouseButtonUp", "MouseButton", @["button"]), + # Gesture + ("SetGesturesEnabled", "Flag[Gesture]", @["flags"]), + ("IsGestureDetected", "Gesture", @["gesture"]), + ("GetGestureDetected", "Gesture", @["returnType"]), + # ConfigFlags + ("SetConfigFlags", "Flag[ConfigFlags]", @["flags"]), + ("IsWindowState", "ConfigFlags", @["flag"]), + ("SetWindowState", "Flag[ConfigFlags]", @["flags"]), + ("ClearWindowState", "Flag[ConfigFlags]", @["flags"]), + # TraceLogLevel + ("TraceLog", "TraceLogLevel", @["logLevel"]), + ("SetTraceLogLevel", "TraceLogLevel", @["logLevel"]), + # CameraMode + ("SetCameraMode", "CameraMode", @["mode"]), + # BlendMode + ("BeginBlendMode", "BlendMode", @["mode"]), + # MaterialMapIndex + ("SetMaterialTexture", "MaterialMapIndex", @["mapType"]), + # ShaderUniformDataType + ("SetShaderValue", "ShaderUniformDataType", @["uniformType"]), + ("SetShaderValueV", "ShaderUniformDataType", @["uniformType"]), + # PixelFormat + ("LoadImageRaw", "PixelFormat", @["format"]), + ("ImageFormat", "PixelFormat", @["newFormat"]), + ("GetPixelColor", "PixelFormat", @["format"]), + ("SetPixelColor", "PixelFormat", @["format"]), + ("GetPixelDataSize", "PixelFormat", @["format"]), + # TextureFilter + ("SetTextureFilter", "TextureFilter", @["filter"]), + # TextureWrap + ("SetTextureWrap", "TextureWrap", @["wrap"]), + # CubemapLayout + ("LoadTextureCubemap", "CubemapLayout", @["layout"]), + # FontType + ("LoadFontData", "FontType", @["type"]), + ] + excluded = [ + # Text strings management functions + "TextCopy", + "TextIsEqual", + "TextLength", + "TextFormat", + "TextSubtext", + "TextReplace", + "TextInsert", + "TextJoin", + "TextSplit", + "TextAppend", + "TextFindIndex", + "TextToUpper", + "TextToLower", + "TextToPascal", + "TextToInteger", + # Misc + "GetRandomValue", + "SetRandomSeed", + "MemAlloc", + "MemRealloc", + "MemFree", + "OpenURL", + # Files management functions + "LoadFileData", + "UnloadFileData", + "SaveFileData", + "LoadFileText", + "UnloadFileText", + "SaveFileText", + "FileExists", + "DirectoryExists", + "IsFileExtension", + "GetFileExtension", + "GetFileName", + "GetFileNameWithoutExt", + "GetDirectoryPath", + "GetPrevDirectoryPath", + "GetWorkingDirectory", + "GetDirectoryFiles", + "ClearDirectoryFiles", + "ChangeDirectory", + "GetFileModTime", + # Compression/Encoding functionality + "CompressData", + "DecompressData", + "EncodeDataBase64", + "DecodeDataBase64" + ] + raylibDestructors = """ + +proc `=destroy`*(x: var Image) = + if x.data != nil: unloadImage(x) +proc `=copy`*(dest: var Image; source: Image) = + if dest.data != source.data: + `=destroy`(dest) + wasMoved(dest) + dest = imageCopy(source) + +proc `=destroy`*(x: var Texture) = + if x.id > 0: unloadTexture(x) +proc `=copy`*(dest: var Texture; source: Texture) {.error.} + +proc `=destroy`*(x: var RenderTexture) = + if x.id > 0: unloadRenderTexture(x) +proc `=copy`*(dest: var RenderTexture; source: RenderTexture) {.error.} + +proc `=destroy`*(x: var Font) = + if x.texture.id > 0: unloadFont(x) +proc `=copy`*(dest: var Font; source: Font) {.error.} + +proc `=destroy`*(x: var Mesh) = + if x.vboId != nil: unloadMesh(x) +proc `=copy`*(dest: var Mesh; source: Mesh) {.error.} + +proc `=destroy`*(x: var Shader) = + if x.id > 0: unloadShader(x) +proc `=copy`*(dest: var Shader; source: Shader) {.error.} + +proc `=destroy`*(x: var Material) = + if x.maps != nil: unloadMaterial(x) +proc `=copy`*(dest: var Material; source: Material) {.error.} + +proc `=destroy`*(x: var Model) = + if x.meshes != nil: unloadModel(x) +proc `=copy`*(dest: var Model; source: Model) {.error.} + +proc `=destroy`*(x: var ModelAnimation) = + if x.framePoses != nil: unloadModelAnimation(x) +proc `=copy`*(dest: var ModelAnimation; source: ModelAnimation) {.error.} + +proc `=destroy`*(x: var Wave) = + if x.data != nil: unloadWave(x) +proc `=copy`*(dest: var Wave; source: Wave) = + if dest.data != source.data: + `=destroy`(dest) + wasMoved(dest) + dest = waveCopy(source) + +proc `=destroy`*(x: var AudioStream) = + if x.buffer != nil: unloadAudioStream(x) +proc `=copy`*(dest: var AudioStream; source: AudioStream) {.error.} + +proc `=destroy`*(x: var Sound) = + if x.stream.buffer != nil: unloadSound(x) +proc `=copy`*(dest: var Sound; source: Sound) {.error.} + +proc `=destroy`*(x: var Music) = + if x.stream.buffer != nil: unloadMusicStream(x) +proc `=copy`*(dest: var Music; source: Music) {.error.} +""" + callbacks = """ + +type va_list* {.importc: "va_list", header: "".} = object ## Only used by TraceLogCallback +proc vprintf*(format: cstring, args: va_list) {.cdecl, importc: "vprintf", header: "".} + +## Callbacks to hook some internal functions +## WARNING: This callbacks are intended for advance users +type + TraceLogCallback* = proc (logLevel: cint; text: cstring; args: va_list) {.cdecl.} ## Logging: Redirect trace log messages + LoadFileDataCallback* = proc (fileName: cstring; bytesRead: ptr uint32): ptr UncheckedArray[uint8] {. + cdecl.} ## FileIO: Load binary data + SaveFileDataCallback* = proc (fileName: cstring; data: pointer; bytesToWrite: uint32): bool {. + cdecl.} ## FileIO: Save binary data + LoadFileTextCallback* = proc (fileName: cstring): cstring {.cdecl.} ## FileIO: Load text data + SaveFileTextCallback* = proc (fileName: cstring; text: cstring): bool {.cdecl.} ## FileIO: Save text data +""" + +const + raylibApi = "../api/raylib_api.json" + outputname = "../raylib.nim" + +proc main = + template ident(x: string) = + buf.setLen 0 + let isKeyw = isKeyword(x) + if isKeyw: + buf.add '`' + buf.add x + if isKeyw: + buf.add '`' + otp.write buf + template lit(x: string) = otp.write x + template spaces = + buf.setLen 0 + addIndent(buf, indent) + otp.write buf + template doc(x: untyped) = + if x.description != "": + lit " ## " + lit x.description + template scope(body: untyped) = + inc indent, indWidth + body + dec indent, indWidth + + var top = parseApi(raylibApi) + + var buf = newStringOfCap(50) + var indent = 0 + var otp: FileStream + try: + otp = openFileStream(outputname, fmWrite) + lit header + # Generate type definitions + lit "\ntype" + scope: + for obj in items(top.structs): + spaces + ident obj.name + lit "* {.bycopy.} = object" + doc obj + scope: + for fld in items(obj.fields): + spaces + var (name, pat) = transFieldName(fld.name) + ident name + lit "*: " + # Replace `int32` with the respective enum type. + if obj.name == "Camera3D" and name == "projection": + lit "CameraProjection" + elif obj.name == "Image" and name == "format": + lit "PixelFormat" + elif obj.name == "Texture" and name == "format": + lit "PixelFormat" + elif obj.name == "NPatchInfo" and name == "layout": + lit "NPatchLayout" + else: + let many = hasMany(fld.name) or + (obj.name == "Model" and (fld.name == "meshMaterial" or fld.name == "bindPose")) + # Manual replacements for some fields + if obj.name == "ModelAnimation" and fld.name == "framePoses": + pat = "ptr UncheckedArray[ptr UncheckedArray[$1]]" + elif obj.name == "Mesh" and fld.name == "vboId": + pat = "ptr array[MaxMeshVertexBuffers, $1]" + elif obj.name == "Material" and fld.name == "maps": + pat = "ptr array[MaxMaterialMaps, $1]" + elif obj.name == "Shader" and fld.name == "locs": + pat = "ptr array[MaxShaderLocations, $1]" + let kind = convertType(fld.`type`, pat, many) + lit kind + doc fld + # + case obj.name + of "Vector4": + spaces + lit extraTypes[0] + of "AudioStream": + spaces + lit extraTypes[5] + of "Texture": + spaces + lit extraTypes[1] + spaces + lit extraTypes[2] + of "RenderTexture": + spaces + lit extraTypes[3] + of "Camera3D": + spaces + lit extraTypes[4] + lit "\n" + # Generate enums definitions + for enm in mitems(top.enums): + spaces + ident enm.name + lit "* {.size: sizeof(cint).} = enum" + doc enm + scope: + proc cmpValueInfo(x, y: ValueInfo): int = cmp(x.value, y.value) + sort(enm.values, cmpValueInfo) + let allSeq = allSequential(enm.values) + for (i, val) in mpairs(enm.values): + if i-1>=0 and enm.values[i-1].value == val.value: # duplicate! + continue + spaces + for (name, prefix) in enumPrefixes.items: + if enm.name == name: + removePrefix(val.name, prefix) + break + ident camelCaseAscii(val.name) + if not allSeq or (i == 0 and val.value != 0): + lit " = " + lit $val.value + doc val + lit "\n" + lit callbacks + lit flagsHelper + lit duplicateVal + lit colors + # Generate functions + for fnc in items(top.functions): + if fnc.name in excluded: continue + lit "\nproc " + ident uncapitalizeAscii(fnc.name) + lit "*(" + var hasVarargs = false + for i, (name, kind) in fnc.params.pairs: + if name == "" and kind == "": + hasVarargs = true + else: + if i > 0: lit ", " + ident name + lit ": " + block outer: + for (fname, kind, params) in enumInFuncParams.items: + if fname == fnc.name and name in params: + lit kind + break outer + let many = (fnc.name != "LoadImageAnim" or name != "frames") and hasMany(name) + var pat = "" + if fnc.name == "GenImageFontAtlas" and name == "recs": + pat = "ptr ptr UncheckedArray[$1]" + let kind = convertType(kind, pat, many) + lit kind + lit ")" + if fnc.returnType != "void": + lit ": " + block outer: + for (fname, kind, params) in enumInFuncParams.items: + if fname == fnc.name and "returnType" in params: + lit kind + break outer + let many = hasMany(fnc.name) or fnc.name == "LoadImagePalette" + let kind = convertType(fnc.returnType, "", many) + ident kind + lit " {.importc: \"" + ident fnc.name + lit "\"" + if hasVarargs: + lit ", varargs" + lit ", rlapi.}" + scope: + if fnc.description != "": + spaces + lit "## " + lit fnc.description + lit "\n" + lit raylibDestructors + finally: + if otp != nil: otp.close() + +main() diff --git a/raymath_api.json b/raymath_api.json new file mode 100644 index 0000000..bf5ff28 --- /dev/null +++ b/raymath_api.json @@ -0,0 +1,962 @@ +{ + "structs": [ + { + "name": "Vector2", + "description": "Vector2 type", + "fields": [ + { + "name": "x", + "type": "float", + "description": "" + }, + { + "name": "y", + "type": "float", + "description": "" + } + ] + }, + { + "name": "Vector3", + "description": "Vector3 type", + "fields": [ + { + "name": "x", + "type": "float", + "description": "" + }, + { + "name": "y", + "type": "float", + "description": "" + }, + { + "name": "z", + "type": "float", + "description": "" + } + ] + }, + { + "name": "Vector4", + "description": "Vector4 type", + "fields": [ + { + "name": "x", + "type": "float", + "description": "" + }, + { + "name": "y", + "type": "float", + "description": "" + }, + { + "name": "z", + "type": "float", + "description": "" + }, + { + "name": "w", + "type": "float", + "description": "" + } + ] + }, + { + "name": "Matrix", + "description": "Matrix type (OpenGL style 4x4 - right handed, column major)", + "fields": [ + { + "name": "m0, m4, m8, m12", + "type": "float", + "description": "Matrix first row (4 components)" + }, + { + "name": "m1, m5, m9, m13", + "type": "float", + "description": "Matrix second row (4 components)" + }, + { + "name": "m2, m6, m10, m14", + "type": "float", + "description": "Matrix third row (4 components)" + }, + { + "name": "m3, m7, m11, m15", + "type": "float", + "description": "Matrix fourth row (4 components)" + } + ] + }, + { + "name": "float3", + "description": "NOTE: Helper types to be used instead of array return types for *ToFloat functions", + "fields": [ + { + "name": "v[3]", + "type": "float", + "description": "" + } + ] + }, + { + "name": "float16", + "description": "", + "fields": [ + { + "name": "v[16]", + "type": "float", + "description": "" + } + ] + } + ], + "enums": [ + ], + "functions": [ + { + "name": "Clamp", + "description": "Clamp float value", + "returnType": "float", + "params": { + "value": "float", + "min": "float", + "max": "float" + } + }, + { + "name": "Lerp", + "description": "Calculate linear interpolation between two floats", + "returnType": "float", + "params": { + "start": "float", + "end": "float", + "amount": "float" + } + }, + { + "name": "Normalize", + "description": "Normalize input value within input range", + "returnType": "float", + "params": { + "value": "float", + "start": "float", + "end": "float" + } + }, + { + "name": "Remap", + "description": "Remap input value within input range to output range", + "returnType": "float", + "params": { + "value": "float", + "inputStart": "float", + "inputEnd": "float", + "outputStart": "float", + "outputEnd": "float" + } + }, + { + "name": "Vector2Zero", + "description": "Vector with components value 0.0f", + "returnType": "Vector2" + }, + { + "name": "Vector2One", + "description": "Vector with components value 1.0f", + "returnType": "Vector2" + }, + { + "name": "Vector2Add", + "description": "Add two vectors (v1 + v2)", + "returnType": "Vector2", + "params": { + "v1": "Vector2", + "v2": "Vector2" + } + }, + { + "name": "Vector2AddValue", + "description": "Add vector and float value", + "returnType": "Vector2", + "params": { + "v": "Vector2", + "add": "float" + } + }, + { + "name": "Vector2Subtract", + "description": "Subtract two vectors (v1 - v2)", + "returnType": "Vector2", + "params": { + "v1": "Vector2", + "v2": "Vector2" + } + }, + { + "name": "Vector2SubtractValue", + "description": "Subtract vector by float value", + "returnType": "Vector2", + "params": { + "v": "Vector2", + "sub": "float" + } + }, + { + "name": "Vector2Length", + "description": "Calculate vector length", + "returnType": "float", + "params": { + "v": "Vector2" + } + }, + { + "name": "Vector2LengthSqr", + "description": "Calculate vector square length", + "returnType": "float", + "params": { + "v": "Vector2" + } + }, + { + "name": "Vector2DotProduct", + "description": "Calculate two vectors dot product", + "returnType": "float", + "params": { + "v1": "Vector2", + "v2": "Vector2" + } + }, + { + "name": "Vector2Distance", + "description": "Calculate distance between two vectors", + "returnType": "float", + "params": { + "v1": "Vector2", + "v2": "Vector2" + } + }, + { + "name": "Vector2Angle", + "description": "Calculate angle from two vectors", + "returnType": "float", + "params": { + "v1": "Vector2", + "v2": "Vector2" + } + }, + { + "name": "Vector2Scale", + "description": "Scale vector (multiply by value)", + "returnType": "Vector2", + "params": { + "v": "Vector2", + "scale": "float" + } + }, + { + "name": "Vector2Multiply", + "description": "Multiply vector by vector", + "returnType": "Vector2", + "params": { + "v1": "Vector2", + "v2": "Vector2" + } + }, + { + "name": "Vector2Negate", + "description": "Negate vector", + "returnType": "Vector2", + "params": { + "v": "Vector2" + } + }, + { + "name": "Vector2Divide", + "description": "Divide vector by vector", + "returnType": "Vector2", + "params": { + "v1": "Vector2", + "v2": "Vector2" + } + }, + { + "name": "Vector2Normalize", + "description": "Normalize provided vector", + "returnType": "Vector2", + "params": { + "v": "Vector2" + } + }, + { + "name": "Vector2Lerp", + "description": "Calculate linear interpolation between two vectors", + "returnType": "Vector2", + "params": { + "v1": "Vector2", + "v2": "Vector2", + "amount": "float" + } + }, + { + "name": "Vector2Reflect", + "description": "Calculate reflected vector to normal", + "returnType": "Vector2", + "params": { + "v": "Vector2", + "normal": "Vector2" + } + }, + { + "name": "Vector2Rotate", + "description": "Rotate vector by angle", + "returnType": "Vector2", + "params": { + "v": "Vector2", + "angle": "float" + } + }, + { + "name": "Vector2MoveTowards", + "description": "Move Vector towards target", + "returnType": "Vector2", + "params": { + "v": "Vector2", + "target": "Vector2", + "maxDistance": "float" + } + }, + { + "name": "Vector3Zero", + "description": "Vector with components value 0.0f", + "returnType": "Vector3" + }, + { + "name": "Vector3One", + "description": "Vector with components value 1.0f", + "returnType": "Vector3" + }, + { + "name": "Vector3Add", + "description": "Add two vectors", + "returnType": "Vector3", + "params": { + "v1": "Vector3", + "v2": "Vector3" + } + }, + { + "name": "Vector3AddValue", + "description": "Add vector and float value", + "returnType": "Vector3", + "params": { + "v": "Vector3", + "add": "float" + } + }, + { + "name": "Vector3Subtract", + "description": "Subtract two vectors", + "returnType": "Vector3", + "params": { + "v1": "Vector3", + "v2": "Vector3" + } + }, + { + "name": "Vector3SubtractValue", + "description": "Subtract vector by float value", + "returnType": "Vector3", + "params": { + "v": "Vector3", + "sub": "float" + } + }, + { + "name": "Vector3Scale", + "description": "Multiply vector by scalar", + "returnType": "Vector3", + "params": { + "v": "Vector3", + "scalar": "float" + } + }, + { + "name": "Vector3Multiply", + "description": "Multiply vector by vector", + "returnType": "Vector3", + "params": { + "v1": "Vector3", + "v2": "Vector3" + } + }, + { + "name": "Vector3CrossProduct", + "description": "Calculate two vectors cross product", + "returnType": "Vector3", + "params": { + "v1": "Vector3", + "v2": "Vector3" + } + }, + { + "name": "Vector3Perpendicular", + "description": "Calculate one vector perpendicular vector", + "returnType": "Vector3", + "params": { + "v": "Vector3" + } + }, + { + "name": "Vector3Length", + "description": "Calculate vector length", + "returnType": "float", + "params": { + "v": "const Vector3" + } + }, + { + "name": "Vector3LengthSqr", + "description": "Calculate vector square length", + "returnType": "float", + "params": { + "v": "const Vector3" + } + }, + { + "name": "Vector3DotProduct", + "description": "Calculate two vectors dot product", + "returnType": "float", + "params": { + "v1": "Vector3", + "v2": "Vector3" + } + }, + { + "name": "Vector3Distance", + "description": "Calculate distance between two vectors", + "returnType": "float", + "params": { + "v1": "Vector3", + "v2": "Vector3" + } + }, + { + "name": "Vector3Angle", + "description": "Calculate angle between two vectors", + "returnType": "float", + "params": { + "v1": "Vector3", + "v2": "Vector3" + } + }, + { + "name": "Vector3Negate", + "description": "Negate provided vector (invert direction)", + "returnType": "Vector3", + "params": { + "v": "Vector3" + } + }, + { + "name": "Vector3Divide", + "description": "Divide vector by vector", + "returnType": "Vector3", + "params": { + "v1": "Vector3", + "v2": "Vector3" + } + }, + { + "name": "Vector3Normalize", + "description": "Normalize provided vector", + "returnType": "Vector3", + "params": { + "v": "Vector3" + } + }, + { + "name": "Vector3OrthoNormalize", + "description": "Orthonormalize provided vectors. Makes vectors normalized and orthogonal to each other. Gram-Schmidt function implementation", + "returnType": "void", + "params": { + "v1": "Vector3 *", + "v2": "Vector3 *" + } + }, + { + "name": "Vector3Transform", + "description": "Transforms a Vector3 by a given Matrix", + "returnType": "Vector3", + "params": { + "v": "Vector3", + "mat": "Matrix" + } + }, + { + "name": "Vector3RotateByQuaternion", + "description": "Transform a vector by quaternion rotation", + "returnType": "Vector3", + "params": { + "v": "Vector3", + "q": "Quaternion" + } + }, + { + "name": "Vector3Lerp", + "description": "Calculate linear interpolation between two vectors", + "returnType": "Vector3", + "params": { + "v1": "Vector3", + "v2": "Vector3", + "amount": "float" + } + }, + { + "name": "Vector3Reflect", + "description": "Calculate reflected vector to normal", + "returnType": "Vector3", + "params": { + "v": "Vector3", + "normal": "Vector3" + } + }, + { + "name": "Vector3Min", + "description": "Get min value for each pair of components", + "returnType": "Vector3", + "params": { + "v1": "Vector3", + "v2": "Vector3" + } + }, + { + "name": "Vector3Max", + "description": "Get max value for each pair of components", + "returnType": "Vector3", + "params": { + "v1": "Vector3", + "v2": "Vector3" + } + }, + { + "name": "Vector3Barycenter", + "description": "Compute barycenter coordinates (u, v, w) for point p with respect to triangle (a, b, c). NOTE: Assumes P is on the plane of ", + "returnType": "Vector3", + "params": { + "p": "Vector3", + "a": "Vector3", + "b": "Vector3", + "c": "Vector3" + } + }, + { + "name": "Vector3Unproject", + "description": "Projects a Vector3 from screen space into object space. NOTE: We are avoiding calling other raymath functions despite availa", + "returnType": "Vector3", + "params": { + "source": "Vector3", + "projection": "Matrix", + "view": "Matrix" + } + }, + { + "name": "Vector3ToFloatV", + "description": "Get Vector3 as float array", + "returnType": "float3", + "params": { + "v": "Vector3" + } + }, + { + "name": "MatrixDeterminant", + "description": "Compute matrix determinant", + "returnType": "float", + "params": { + "mat": "Matrix" + } + }, + { + "name": "MatrixTrace", + "description": "Get the trace of the matrix (sum of the values along the diagonal)", + "returnType": "float", + "params": { + "mat": "Matrix" + } + }, + { + "name": "MatrixTranspose", + "description": "Transposes provided matrix", + "returnType": "Matrix", + "params": { + "mat": "Matrix" + } + }, + { + "name": "MatrixInvert", + "description": "Invert provided matrix", + "returnType": "Matrix", + "params": { + "mat": "Matrix" + } + }, + { + "name": "MatrixNormalize", + "description": "Normalize provided matrix", + "returnType": "Matrix", + "params": { + "mat": "Matrix" + } + }, + { + "name": "MatrixIdentity", + "description": "Get identity matrix", + "returnType": "Matrix" + }, + { + "name": "MatrixAdd", + "description": "Add two matrices", + "returnType": "Matrix", + "params": { + "left": "Matrix", + "right": "Matrix" + } + }, + { + "name": "MatrixSubtract", + "description": "Subtract two matrices (left - right)", + "returnType": "Matrix", + "params": { + "left": "Matrix", + "right": "Matrix" + } + }, + { + "name": "MatrixMultiply", + "description": "Get two matrix multiplication. NOTE: When multiplying matrices... the order matters!", + "returnType": "Matrix", + "params": { + "left": "Matrix", + "right": "Matrix" + } + }, + { + "name": "MatrixTranslate", + "description": "Get translation matrix", + "returnType": "Matrix", + "params": { + "x": "float", + "y": "float", + "z": "float" + } + }, + { + "name": "MatrixRotate", + "description": "Create rotation matrix from axis and angle. NOTE: Angle should be provided in radians", + "returnType": "Matrix", + "params": { + "axis": "Vector3", + "angle": "float" + } + }, + { + "name": "MatrixRotateX", + "description": "Get x-rotation matrix (angle in radians)", + "returnType": "Matrix", + "params": { + "angle": "float" + } + }, + { + "name": "MatrixRotateY", + "description": "Get y-rotation matrix (angle in radians)", + "returnType": "Matrix", + "params": { + "angle": "float" + } + }, + { + "name": "MatrixRotateZ", + "description": "Get z-rotation matrix (angle in radians)", + "returnType": "Matrix", + "params": { + "angle": "float" + } + }, + { + "name": "MatrixRotateXYZ", + "description": "Get xyz-rotation matrix (angles in radians)", + "returnType": "Matrix", + "params": { + "ang": "Vector3" + } + }, + { + "name": "MatrixRotateZYX", + "description": "Get zyx-rotation matrix (angles in radians)", + "returnType": "Matrix", + "params": { + "ang": "Vector3" + } + }, + { + "name": "MatrixScale", + "description": "Get scaling matrix", + "returnType": "Matrix", + "params": { + "x": "float", + "y": "float", + "z": "float" + } + }, + { + "name": "MatrixFrustum", + "description": "Get perspective projection matrix", + "returnType": "Matrix", + "params": { + "left": "double", + "right": "double", + "bottom": "double", + "top": "double", + "near": "double", + "far": "double" + } + }, + { + "name": "MatrixPerspective", + "description": "Get perspective projection matrix. NOTE: Angle should be provided in radians", + "returnType": "Matrix", + "params": { + "fovy": "double", + "aspect": "double", + "near": "double", + "far": "double" + } + }, + { + "name": "MatrixOrtho", + "description": "Get orthographic projection matrix", + "returnType": "Matrix", + "params": { + "left": "double", + "right": "double", + "bottom": "double", + "top": "double", + "near": "double", + "far": "double" + } + }, + { + "name": "MatrixLookAt", + "description": "Get camera look-at matrix (view matrix)", + "returnType": "Matrix", + "params": { + "eye": "Vector3", + "target": "Vector3", + "up": "Vector3" + } + }, + { + "name": "MatrixToFloatV", + "description": "Get float array of matrix data", + "returnType": "float16", + "params": { + "mat": "Matrix" + } + }, + { + "name": "QuaternionAdd", + "description": "Add two quaternions", + "returnType": "Quaternion", + "params": { + "q1": "Quaternion", + "q2": "Quaternion" + } + }, + { + "name": "QuaternionAddValue", + "description": "Add quaternion and float value", + "returnType": "Quaternion", + "params": { + "q": "Quaternion", + "add": "float" + } + }, + { + "name": "QuaternionSubtract", + "description": "Subtract two quaternions", + "returnType": "Quaternion", + "params": { + "q1": "Quaternion", + "q2": "Quaternion" + } + }, + { + "name": "QuaternionSubtractValue", + "description": "Subtract quaternion and float value", + "returnType": "Quaternion", + "params": { + "q": "Quaternion", + "sub": "float" + } + }, + { + "name": "QuaternionIdentity", + "description": "Get identity quaternion", + "returnType": "Quaternion" + }, + { + "name": "QuaternionLength", + "description": "Computes the length of a quaternion", + "returnType": "float", + "params": { + "q": "Quaternion" + } + }, + { + "name": "QuaternionNormalize", + "description": "Normalize provided quaternion", + "returnType": "Quaternion", + "params": { + "q": "Quaternion" + } + }, + { + "name": "QuaternionInvert", + "description": "Invert provided quaternion", + "returnType": "Quaternion", + "params": { + "q": "Quaternion" + } + }, + { + "name": "QuaternionMultiply", + "description": "Calculate two quaternion multiplication", + "returnType": "Quaternion", + "params": { + "q1": "Quaternion", + "q2": "Quaternion" + } + }, + { + "name": "QuaternionScale", + "description": "Scale quaternion by float value", + "returnType": "Quaternion", + "params": { + "q": "Quaternion", + "mul": "float" + } + }, + { + "name": "QuaternionDivide", + "description": "Divide two quaternions", + "returnType": "Quaternion", + "params": { + "q1": "Quaternion", + "q2": "Quaternion" + } + }, + { + "name": "QuaternionLerp", + "description": "Calculate linear interpolation between two quaternions", + "returnType": "Quaternion", + "params": { + "q1": "Quaternion", + "q2": "Quaternion", + "amount": "float" + } + }, + { + "name": "QuaternionNlerp", + "description": "Calculate slerp-optimized interpolation between two quaternions", + "returnType": "Quaternion", + "params": { + "q1": "Quaternion", + "q2": "Quaternion", + "amount": "float" + } + }, + { + "name": "QuaternionSlerp", + "description": "Calculates spherical linear interpolation between two quaternions", + "returnType": "Quaternion", + "params": { + "q1": "Quaternion", + "q2": "Quaternion", + "amount": "float" + } + }, + { + "name": "QuaternionFromVector3ToVector3", + "description": "Calculate quaternion based on the rotation from one vector to another", + "returnType": "Quaternion", + "params": { + "from": "Vector3", + "to": "Vector3" + } + }, + { + "name": "QuaternionFromMatrix", + "description": "Get a quaternion for a given rotation matrix", + "returnType": "Quaternion", + "params": { + "mat": "Matrix" + } + }, + { + "name": "QuaternionToMatrix", + "description": "Get a matrix for a given quaternion", + "returnType": "Matrix", + "params": { + "q": "Quaternion" + } + }, + { + "name": "QuaternionFromAxisAngle", + "description": "Get rotation quaternion for an angle and axis. NOTE: angle must be provided in radians", + "returnType": "Quaternion", + "params": { + "axis": "Vector3", + "angle": "float" + } + }, + { + "name": "QuaternionToAxisAngle", + "description": "Get the rotation angle and axis for a given quaternion", + "returnType": "void", + "params": { + "q": "Quaternion", + "outAxis": "Vector3 *", + "outAngle": "float *" + } + }, + { + "name": "QuaternionFromEuler", + "description": "Get the quaternion equivalent to Euler angles. NOTE: Rotation order is ZYX", + "returnType": "Quaternion", + "params": { + "pitch": "float", + "yaw": "float", + "roll": "float" + } + }, + { + "name": "QuaternionToEuler", + "description": "Get the Euler angles equivalent to quaternion (roll, pitch, yaw). NOTE: Angles are returned in a Vector3 struct in radians", + "returnType": "Vector3", + "params": { + "q": "Quaternion" + } + }, + { + "name": "QuaternionTransform", + "description": "Transform a quaternion given a transformation matrix", + "returnType": "Quaternion", + "params": { + "q": "Quaternion", + "mat": "Matrix" + } + } + ] +} diff --git a/raymath_gen.nim b/raymath_gen.nim new file mode 100644 index 0000000..9a0c0a2 --- /dev/null +++ b/raymath_gen.nim @@ -0,0 +1,140 @@ +import common, std/[algorithm, streams, strformat] +import strutils except indent + +const + indWidth = 2 + header = """ +from raylib import Vector2, Vector3, Vector4, Quaternion, Matrix + +const lext = when defined(windows): ".dll" elif defined(macosx): ".dylib" else: ".so" +{.pragma: rmapi, cdecl, dynlib: "libraylib" & lext.} +""" + excluded = [ + "Vector2", + "Vector3", + "Vector4", + "Matrix" + ] + raymathOps = """ + +template `+`*[T: Vector2 | Vector3 | Quaternion | Matrix](v1, v2: T): T = add(v1, v2) +template `+=`*[T: Vector2 | Vector3 | Quaternion | Matrix](v1: var T, v2: T) = v1 = add(v1, v2) +template `+`*[T: Vector2 | Vector3 | Quaternion](v1: T, value: float32): T = addValue(v1, value) +template `+=`*[T: Vector2 | Vector3 | Quaternion](v1: var T, value: float32) = v1 = addValue(v1, value) + +template `-`*[T: Vector2 | Vector3 | Quaternion | Matrix](v1, v2: T): T = subtract(v1, v2) +template `-=`*[T: Vector2 | Vector3 | Quaternion | Matrix](v1: var T, v2: T) = v1 = subtract(v1, v2) +template `-`*[T: Vector2 | Vector3 | Quaternion](v1: T, value: float32): T = subtractValue(v1, value) +template `-=`*[T: Vector2 | Vector3 | Quaternion](v1: var T, value: float32) = v1 = subtractValue(v1, value) + +template `*`*[T: Vector2 | Vector3 | Quaternion | Matrix](v1, v2: T): T = multiply(v1, v2) +template `*=`*[T: Vector2 | Vector3 | Quaternion | Matrix](v1: var T, v2: T) = v1 = multiply(v1, v2) +template `*`*[T: Vector2 | Vector3 | Quaternion](v1: T, value: float32): T = scale(v1, value) +template `*=`*[T: Vector2 | Vector3 | Quaternion](v1: var T, value: float32) = v1 = scale(v1, value) + +template `/`*[T: Vector2 | Vector3 | Quaternion | Matrix](v1, v2: T): T = divide(v1, v2) +template `/=`*[T: Vector2 | Vector3 | Quaternion | Matrix](v1: var T, v2: T) = v1 = divide(v1, v2) +template `/`*[T: Vector2 | Vector3 | Quaternion](v1: T, value: float32): T = scale(v1, 1'f32/value) +template `/=`*[T: Vector2 | Vector3 | Quaternion](v1: var T, value: float32) = v1 = scale(v1, 1'f32/value) + +template `-`*[T: Vector2 | Vector3](v1: T): T = negate(v1) +""" + +const + raylibApi = "../api/raymath_api.json" + outputname = "../raymath.nim" + +proc main = + template ident(x: string) = + buf.setLen 0 + let isKeyw = isKeyword(x) + if isKeyw: + buf.add '`' + buf.add x + if isKeyw: + buf.add '`' + otp.write buf + template lit(x: string) = otp.write x + template spaces = + buf.setLen 0 + addIndent(buf, indent) + otp.write buf + template doc(x: untyped) = + if x.description != "": + lit " ## " + lit x.description + template scope(body: untyped) = + inc indent, indWidth + body + dec indent, indWidth + + var top = parseApi(raylibApi) + + var buf = newStringOfCap(50) + var indent = 0 + var otp: FileStream + try: + otp = openFileStream(outputname, fmWrite) + lit header + # Generate type definitions + lit "\ntype" + scope: + for obj in items(top.structs): + if obj.name in excluded: continue + spaces + ident capitalizeAscii(obj.name) + lit "* {.bycopy.} = object" + doc obj + scope: + for fld in items(obj.fields): + spaces + var (name, sub) = transFieldName(fld.name) + ident name + lit "*: " + let kind = convertType(fld.`type`, sub, false) + lit kind + doc fld + lit "\n" + for fnc in items(top.functions): + lit "\nproc " + var name = fnc.name + if name notin ["Vector2Zero", "Vector2One", "Vector3Zero", + "Vector3One", "MatrixIdentity", "QuaternionIdentity"]: + removePrefix(name, "Vector2") + removePrefix(name, "Vector3") + removePrefix(name, "Matrix") + removePrefix(name, "Quaternion") + ident uncapitalizeAscii(name) + lit "*(" + var hasVarargs = false + for i, (name, kind) in fnc.params.pairs: + if name == "" and kind == "": + hasVarargs = true + else: + if i > 0: lit ", " + ident name + lit ": " + let kind = convertType(kind, "", false) + lit kind + lit ")" + if fnc.returnType != "void": + lit ": " + let kind = convertType(fnc.returnType, "", false) + ident kind + lit " {.importc: \"" + ident fnc.name + lit "\"" + if hasVarargs: + lit ", varargs" + lit ", rmapi.}" + scope: + if fnc.description != "": + spaces + lit "## " + lit fnc.description + lit "\n" + lit raymathOps + finally: + if otp != nil: otp.close() + +main() From c8d2cb1fd79895686516cd96ccf66181e566e6ae Mon Sep 17 00:00:00 2001 From: Antonis Geralis <43617260+planetis-m@users.noreply.github.com> Date: Mon, 27 Dec 2021 18:14:44 +0200 Subject: [PATCH 02/13] Attempt to refactor raymath_gen --- raymath_gen.nim | 49 +++++++++++++++++++++++++------------------------ 1 file changed, 25 insertions(+), 24 deletions(-) diff --git a/raymath_gen.nim b/raymath_gen.nim index 9a0c0a2..d1ac3bb 100644 --- a/raymath_gen.nim +++ b/raymath_gen.nim @@ -2,8 +2,7 @@ import common, std/[algorithm, streams, strformat] import strutils except indent const - indWidth = 2 - header = """ + raymathHeader = """ from raylib import Vector2, Vector3, Vector4, Quaternion, Matrix const lext = when defined(windows): ".dll" elif defined(macosx): ".dylib" else: ".so" @@ -40,11 +39,7 @@ template `/=`*[T: Vector2 | Vector3 | Quaternion](v1: var T, value: float32) = v template `-`*[T: Vector2 | Vector3](v1: T): T = negate(v1) """ -const - raylibApi = "../api/raymath_api.json" - outputname = "../raymath.nim" - -proc main = +proc genBindings(t: Topmost, fname: string, header, footer: string) = template ident(x: string) = buf.setLen 0 let isKeyw = isKeyword(x) @@ -59,27 +54,25 @@ proc main = buf.setLen 0 addIndent(buf, indent) otp.write buf - template doc(x: untyped) = - if x.description != "": - lit " ## " - lit x.description template scope(body: untyped) = inc indent, indWidth body dec indent, indWidth - - var top = parseApi(raylibApi) + template doc(x: untyped) = + if x.description != "": + lit " ## " + lit x.description var buf = newStringOfCap(50) var indent = 0 var otp: FileStream try: - otp = openFileStream(outputname, fmWrite) + otp = openFileStream(fname, fmWrite) lit header # Generate type definitions lit "\ntype" scope: - for obj in items(top.structs): + for obj in items(t.structs): if obj.name in excluded: continue spaces ident capitalizeAscii(obj.name) @@ -88,14 +81,14 @@ proc main = scope: for fld in items(obj.fields): spaces - var (name, sub) = transFieldName(fld.name) + var (name, pat) = transFieldName(fld.name) ident name lit "*: " - let kind = convertType(fld.`type`, sub, false) + let kind = convertType(fld.`type`, pat, false) lit kind doc fld lit "\n" - for fnc in items(top.functions): + for fnc in items(t.functions): lit "\nproc " var name = fnc.name if name notin ["Vector2Zero", "Vector2One", "Vector3Zero", @@ -107,12 +100,12 @@ proc main = ident uncapitalizeAscii(name) lit "*(" var hasVarargs = false - for i, (name, kind) in fnc.params.pairs: - if name == "" and kind == "": + for i, (param, kind) in fnc.params.pairs: + if param == "" and kind == "": hasVarargs = true else: if i > 0: lit ", " - ident name + ident param lit ": " let kind = convertType(kind, "", false) lit kind @@ -127,14 +120,22 @@ proc main = if hasVarargs: lit ", varargs" lit ", rmapi.}" - scope: - if fnc.description != "": + if fnc.description != "": + scope: spaces lit "## " lit fnc.description lit "\n" - lit raymathOps + lit footer finally: if otp != nil: otp.close() +const + raylibApi = "../api/raymath_api.json" + outputname = "../raymath.nim" + +proc main = + var t = parseApi(raylibApi) + genBindings(t, outputname, raymathHeader, raymathOps) + main() From 143f5db1e1b5902cd3a442153ed6b7b2371b58f0 Mon Sep 17 00:00:00 2001 From: Antonis Geralis <43617260+planetis-m@users.noreply.github.com> Date: Mon, 27 Dec 2021 18:15:18 +0200 Subject: [PATCH 03/13] refactor raylib_gen --- raylib_gen.nim | 270 ++++++++++++++++++++++++------------------------- 1 file changed, 135 insertions(+), 135 deletions(-) diff --git a/raylib_gen.nim b/raylib_gen.nim index f678080..3dcb54e 100644 --- a/raylib_gen.nim +++ b/raylib_gen.nim @@ -2,16 +2,15 @@ import common, std/[algorithm, streams] import strutils except indent const - indWidth = 2 - extraTypes = [ - "Quaternion* = Vector4 ## Quaternion, 4 components (Vector4 alias)", - "Texture2D* = Texture ## Texture2D, same as Texture", - "TextureCubemap* = Texture ## TextureCubemap, same as Texture", - "RenderTexture2D* = RenderTexture ## RenderTexture2D, same as RenderTexture", - "Camera* = Camera3D ## Camera type fallback, defaults to Camera3D", - "RAudioBuffer* {.importc: \"rAudioBuffer\", bycopy.} = object" - ] - header = """ + extraTypes = { + "Vector4": "Quaternion* = Vector4 ## Quaternion, 4 components (Vector4 alias)", + "Texture": "Texture2D* = Texture ## Texture2D, same as Texture", + "Texture": "TextureCubemap* = Texture ## TextureCubemap, same as Texture", + "RenderTexture": "RenderTexture2D* = RenderTexture ## RenderTexture2D, same as RenderTexture", + "Camera3D": "Camera* = Camera3D ## Camera type fallback, defaults to Camera3D", + "AudioStream": "RAudioBuffer* {.importc: \"rAudioBuffer\", bycopy.} = object" + } + raylibHeader = """ const lext = when defined(windows): ".dll" elif defined(macosx): ".dylib" else: ".so" {.pragma: rlapi, cdecl, dynlib: "libraylib" & lext.} @@ -22,7 +21,20 @@ const MaxMaterialMaps* = 12 ## Maximum number of shader maps supported MaxMeshVertexBuffers* = 7 ## Maximum vertex buffers (VBO) per mesh """ - flagsHelper = """ + helpers = """ +type va_list* {.importc: "va_list", header: "".} = object ## Only used by TraceLogCallback +proc vprintf*(format: cstring, args: va_list) {.cdecl, importc: "vprintf", header: "".} + +## Callbacks to hook some internal functions +## WARNING: This callbacks are intended for advance users +type + TraceLogCallback* = proc (logLevel: cint; text: cstring; args: va_list) {.cdecl.} ## Logging: Redirect trace log messages + LoadFileDataCallback* = proc (fileName: cstring; bytesRead: ptr uint32): ptr UncheckedArray[uint8] {. + cdecl.} ## FileIO: Load binary data + SaveFileDataCallback* = proc (fileName: cstring; data: pointer; bytesToWrite: uint32): bool {. + cdecl.} ## FileIO: Save binary data + LoadFileTextCallback* = proc (fileName: cstring): cstring {.cdecl.} ## FileIO: Load text data + SaveFileTextCallback* = proc (fileName: cstring; text: cstring): bool {.cdecl.} ## FileIO: Save text data Enums = ConfigFlags|Gesture Flag*[E: Enums] = distinct uint32 @@ -32,13 +44,9 @@ proc flag*[E: Enums](e: varargs[E]): Flag[E] {.inline.} = for val in items(e): res = res or uint32(val) Flag[E](res) -""" - duplicateVal = """ const Menu* = KeyboardKey.R ## Key: Android menu button -""" - colors = """ LightGray* = Color(r: 200, g: 200, b: 200, a: 255) Gray* = Color(r: 130, g: 130, b: 130, a: 255) @@ -67,29 +75,6 @@ const Magenta* = Color(r: 255, g: 0, b: 255, a: 255) RayWhite* = Color(r: 245, g: 245, b: 245, a: 255) """ - enumPrefixes = [ - ("ConfigFlags", "FLAG_"), - ("TraceLogLevel", "LOG_"), - ("KeyboardKey", "KEY_"), - ("MouseButton", "MOUSE_BUTTON_"), - ("MouseCursor", "MOUSE_CURSOR_"), - ("GamepadButton", "GAMEPAD_BUTTON_"), - ("GamepadAxis", "GAMEPAD_AXIS_"), - ("MaterialMapIndex", "MATERIAL_MAP_"), - ("ShaderLocationIndex", "SHADER_LOC_"), - ("ShaderUniformDataType", "SHADER_UNIFORM_"), - ("ShaderAttributeDataType", "SHADER_ATTRIB_"), - ("PixelFormat", "PIXELFORMAT_"), - ("TextureFilter", "TEXTURE_FILTER_"), - ("TextureWrap", "TEXTURE_WRAP_"), - ("CubemapLayout", "CUBEMAP_LAYOUT_"), - ("FontType", "FONT_"), - ("BlendMode", "BLEND_"), - ("Gesture", "GESTURE_"), - ("CameraMode", "CAMERA_"), - ("CameraProjection", "CAMERA_"), - ("NPatchLayout", "NPATCH_") - ] enumInFuncParams = [ # KeyboardKey ("IsKeyPressed", "KeyboardKey", @["key"]), @@ -153,7 +138,7 @@ const # FontType ("LoadFontData", "FontType", @["type"]), ] - excluded = [ + excludedFuncs = [ # Text strings management functions "TextCopy", "TextIsEqual", @@ -265,28 +250,60 @@ proc `=destroy`*(x: var Music) = if x.stream.buffer != nil: unloadMusicStream(x) proc `=copy`*(dest: var Music; source: Music) {.error.} """ - callbacks = """ -type va_list* {.importc: "va_list", header: "".} = object ## Only used by TraceLogCallback -proc vprintf*(format: cstring, args: va_list) {.cdecl, importc: "vprintf", header: "".} +proc removeEnumPrefix(enm, val: string): string = + # Remove prefixes from enum fields. + const + enumPrefixes = { + "ConfigFlags": "FLAG_", + "TraceLogLevel": "LOG_", + "KeyboardKey": "KEY_", + "MouseButton": "MOUSE_BUTTON_", + "MouseCursor": "MOUSE_CURSOR_", + "GamepadButton": "GAMEPAD_BUTTON_", + "GamepadAxis": "GAMEPAD_AXIS_", + "MaterialMapIndex": "MATERIAL_MAP_", + "ShaderLocationIndex": "SHADER_LOC_", + "ShaderUniformDataType": "SHADER_UNIFORM_", + "ShaderAttributeDataType": "SHADER_ATTRIB_", + "PixelFormat": "PIXELFORMAT_", + "TextureFilter": "TEXTURE_FILTER_", + "TextureWrap": "TEXTURE_WRAP_", + "CubemapLayout": "CUBEMAP_LAYOUT_", + "FontType": "FONT_", + "BlendMode": "BLEND_", + "Gesture": "GESTURE_", + "CameraMode": "CAMERA_", + "CameraProjection": "CAMERA_", + "NPatchLayout": "NPATCH_" + } + result = val + for x, prefix in enumPrefixes.items: + if enm == x: + removePrefix(result, prefix) + return -## Callbacks to hook some internal functions -## WARNING: This callbacks are intended for advance users -type - TraceLogCallback* = proc (logLevel: cint; text: cstring; args: va_list) {.cdecl.} ## Logging: Redirect trace log messages - LoadFileDataCallback* = proc (fileName: cstring; bytesRead: ptr uint32): ptr UncheckedArray[uint8] {. - cdecl.} ## FileIO: Load binary data - SaveFileDataCallback* = proc (fileName: cstring; data: pointer; bytesToWrite: uint32): bool {. - cdecl.} ## FileIO: Save binary data - LoadFileTextCallback* = proc (fileName: cstring): cstring {.cdecl.} ## FileIO: Load text data - SaveFileTextCallback* = proc (fileName: cstring; text: cstring): bool {.cdecl.} ## FileIO: Save text data -""" +proc replaceCintField(obj, fld: string): string = + # Replace `int32` with the respective enum type. + const enumReplacements = [ + ("Camera3D", "projection", "CameraProjection"), + ("Image", "format", "PixelFormat"), + ("Texture", "format", "PixelFormat"), + ("NPatchInfo", "layout", "NPatchLayout") + ] + result = "" + for x, y, kind in enumReplacements.items: + if obj == x and fld == y: + return kind -const - raylibApi = "../api/raylib_api.json" - outputname = "../raylib.nim" +proc getSpecialPattern(x, y: string, replacements: openarray[(string, string, string)]): string = + # Manual replacements for some fields + result = "" + for a, b, pattern in replacements.items: + if x == a and y == b: + return pattern -proc main = +proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = template ident(x: string) = buf.setLen 0 let isKeyw = isKeyword(x) @@ -301,27 +318,25 @@ proc main = buf.setLen 0 addIndent(buf, indent) otp.write buf - template doc(x: untyped) = - if x.description != "": - lit " ## " - lit x.description template scope(body: untyped) = inc indent, indWidth body dec indent, indWidth - - var top = parseApi(raylibApi) + template doc(x: untyped) = + if x.description != "": + lit " ## " + lit x.description var buf = newStringOfCap(50) var indent = 0 var otp: FileStream try: - otp = openFileStream(outputname, fmWrite) + otp = openFileStream(fname, fmWrite) lit header # Generate type definitions lit "\ntype" scope: - for obj in items(top.structs): + for obj in items(t.structs): spaces ident obj.name lit "* {.bycopy.} = object" @@ -332,109 +347,83 @@ proc main = var (name, pat) = transFieldName(fld.name) ident name lit "*: " - # Replace `int32` with the respective enum type. - if obj.name == "Camera3D" and name == "projection": - lit "CameraProjection" - elif obj.name == "Image" and name == "format": - lit "PixelFormat" - elif obj.name == "Texture" and name == "format": - lit "PixelFormat" - elif obj.name == "NPatchInfo" and name == "layout": - lit "NPatchLayout" + let kind = replaceCintField(obj.name, name) + if kind != "": + lit kind else: - let many = hasMany(fld.name) or - (obj.name == "Model" and (fld.name == "meshMaterial" or fld.name == "bindPose")) - # Manual replacements for some fields - if obj.name == "ModelAnimation" and fld.name == "framePoses": - pat = "ptr UncheckedArray[ptr UncheckedArray[$1]]" - elif obj.name == "Mesh" and fld.name == "vboId": - pat = "ptr array[MaxMeshVertexBuffers, $1]" - elif obj.name == "Material" and fld.name == "maps": - pat = "ptr array[MaxMaterialMaps, $1]" - elif obj.name == "Shader" and fld.name == "locs": - pat = "ptr array[MaxShaderLocations, $1]" + let many = hasMany(name) or (obj.name, name) in {"Model": "meshMaterial", "Model": "bindPose"} + const replacements = [ + ("ModelAnimation", "framePoses", "ptr UncheckedArray[ptr UncheckedArray[$1]]"), + ("Mesh", "vboId", "ptr array[MaxMeshVertexBuffers, $1]"), + ("Material", "maps", "ptr array[MaxMaterialMaps, $1]"), + ("Shader", "locs", "ptr array[MaxShaderLocations, $1]") + ] + let tmp = getSpecialPattern(obj.name, name, replacements) + if tmp != "": pat = tmp let kind = convertType(fld.`type`, pat, many) lit kind doc fld - # - case obj.name - of "Vector4": - spaces - lit extraTypes[0] - of "AudioStream": - spaces - lit extraTypes[5] - of "Texture": - spaces - lit extraTypes[1] - spaces - lit extraTypes[2] - of "RenderTexture": - spaces - lit extraTypes[3] - of "Camera3D": - spaces - lit extraTypes[4] + # Add a type alias or a missing type after the respective type. + for name, extra in extraTypes.items: + if obj.name == name: + spaces + lit extra lit "\n" # Generate enums definitions - for enm in mitems(top.enums): + for enm in items(t.enums): spaces ident enm.name lit "* {.size: sizeof(cint).} = enum" doc enm scope: - proc cmpValueInfo(x, y: ValueInfo): int = cmp(x.value, y.value) - sort(enm.values, cmpValueInfo) let allSeq = allSequential(enm.values) - for (i, val) in mpairs(enm.values): - if i-1>=0 and enm.values[i-1].value == val.value: # duplicate! + for i, val in pairs(enm.values): + if i-1>=0 and enm.values[i-1].value == val.value: # omit duplicate! continue spaces - for (name, prefix) in enumPrefixes.items: - if enm.name == name: - removePrefix(val.name, prefix) - break - ident camelCaseAscii(val.name) + # Follow Nim's naming convention for enum fields. + let name = removeEnumPrefix(enm.name, val.name) + ident camelCaseAscii(name) + # Set the int value if the enum has holes and it doesn't start at 0. if not allSeq or (i == 0 and val.value != 0): lit " = " lit $val.value doc val lit "\n" - lit callbacks - lit flagsHelper - lit duplicateVal - lit colors + lit middle # Generate functions - for fnc in items(top.functions): - if fnc.name in excluded: continue + for fnc in items(t.functions): + if fnc.name in excludedFuncs: continue lit "\nproc " - ident uncapitalizeAscii(fnc.name) + ident uncapitalizeAscii(fnc.name) # Follow Nim's naming convention for proc names. lit "*(" var hasVarargs = false - for i, (name, kind) in fnc.params.pairs: - if name == "" and kind == "": + for i, (param, kind) in fnc.params.pairs: + if param == "" and kind == "": # , ...) { hasVarargs = true else: if i > 0: lit ", " - ident name + ident param lit ": " block outer: - for (fname, kind, params) in enumInFuncParams.items: - if fname == fnc.name and name in params: + for (name, kind, params) in enumInFuncParams.items: + if name == fnc.name and param in params: lit kind break outer - let many = (fnc.name != "LoadImageAnim" or name != "frames") and hasMany(name) - var pat = "" - if fnc.name == "GenImageFontAtlas" and name == "recs": - pat = "ptr ptr UncheckedArray[$1]" + let many = (fnc.name, param) notin {"LoadImageAnim": "frames"} and hasMany(param) + const + replacements = [ + ("GenImageFontAtlas", "recs", "ptr ptr UncheckedArray[$1]") + ] + let pat = getSpecialPattern(fnc.name, param, replacements) let kind = convertType(kind, pat, many) lit kind lit ")" if fnc.returnType != "void": lit ": " block outer: - for (fname, kind, params) in enumInFuncParams.items: - if fname == fnc.name and "returnType" in params: + for (name, kind, params) in enumInFuncParams.items: + if name == fnc.name and "returnType" in params: lit kind break outer let many = hasMany(fnc.name) or fnc.name == "LoadImagePalette" @@ -446,14 +435,25 @@ proc main = if hasVarargs: lit ", varargs" lit ", rlapi.}" - scope: - if fnc.description != "": + if fnc.description != "": + scope: spaces lit "## " lit fnc.description lit "\n" - lit raylibDestructors + lit footer finally: if otp != nil: otp.close() +const + raylibApi = "../api/raylib_api.json" + outputname = "../raylib.nim" + +proc main = + proc cmp(x, y: ValueInfo): int = cmp(x.value, y.value) + var t = parseApi(raylibApi) + # Some enums are unsorted! + for enm in mitems(t.enums): sort(enm.values, cmp) + genBindings(t, outputname, raylibHeader, helpers, raylibDestructors) + main() From b87001f1314674bccc5f0f87dc5650a47759817a Mon Sep 17 00:00:00 2001 From: Antonis Geralis <43617260+planetis-m@users.noreply.github.com> Date: Mon, 27 Dec 2021 18:16:23 +0200 Subject: [PATCH 04/13] add indWidth to common --- common.nim | 1 + 1 file changed, 1 insertion(+) diff --git a/common.nim b/common.nim index 8e45d88..e1f83d5 100644 --- a/common.nim +++ b/common.nim @@ -1,6 +1,7 @@ import eminim, std/[algorithm, strutils, strscans, strformat, streams, parsejson] const + indWidth* = 2 nimKeyw = ["addr", "and", "as", "asm", "bind", "block", "break", "case", "cast", "concept", "const", "continue", "converter", From c3abeeae45f21c3fb0aa93829b6fb6ce66d929b5 Mon Sep 17 00:00:00 2001 From: Antonis Geralis <43617260+planetis-m@users.noreply.github.com> Date: Sat, 1 Jan 2022 18:24:46 +0200 Subject: [PATCH 05/13] Update common.nim --- common.nim | 35 +++++++++++++++++++++++++++++++---- 1 file changed, 31 insertions(+), 4 deletions(-) diff --git a/common.nim b/common.nim index e1f83d5..bb9093c 100644 --- a/common.nim +++ b/common.nim @@ -1,4 +1,5 @@ -import eminim, std/[algorithm, strutils, strscans, strformat, streams, parsejson] +import eminim, std/[algorithm, strscans, strformat, streams, parsejson] +import strutils except indent const indWidth* = 2 @@ -105,7 +106,7 @@ proc toNimType*(x: string): string = "Float16" else: x -proc convertType*(s: string, pattern: string, many: bool): string = +proc convertType*(s: string, pattern: string, many, isVar: bool): string = ## Converts a C type to the equivalent Nim type. ## Should work with function parameters, return, and struct fields types. ## If a `pattern` is provided, it substitutes the found base type and returns it. @@ -164,7 +165,9 @@ proc convertType*(s: string, pattern: string, many: bool): string = elif many: result = "ptr UncheckedArray[" & result & "]" else: - result = "ptr " & result + if isVar: + result = "var " & result + else: result = "ptr " & result elif isDoublePointer: if isVoid: result = "ptr pointer" @@ -173,7 +176,7 @@ proc convertType*(s: string, pattern: string, many: bool): string = else: result = "ptr ptr " & result -proc hasMany*(x: string): bool {.inline.} = +proc isPlural*(x: string): bool {.inline.} = ## Tries to determine if an identifier is plural let x = strip(x, false, chars = Digits) x.endsWith("es") or (not x.endsWith("ss") and x.endsWith('s')) or @@ -226,3 +229,27 @@ proc allSequential*(x: seq[ValueInfo]): bool = proc uncapitalizeAscii*(s: string): string = if s.len == 0: result = "" else: result = toLowerAscii(s[0]) & substr(s, 1) + +# used internally by the genBindings procs +template ident*(x: string) = + buf.setLen 0 + let isKeyw = isKeyword(x) + if isKeyw: + buf.add '`' + buf.add x + if isKeyw: + buf.add '`' + otp.write buf +template lit*(x: string) = otp.write x +template spaces* = + buf.setLen 0 + addIndent(buf, indent) + otp.write buf +template scope*(body: untyped) = + inc indent, indWidth + body + dec indent, indWidth +template doc*(x: untyped) = + if x.description != "": + lit " ## " + lit x.description From 7ce91bf26363fc2a05706db6124587642cc86c70 Mon Sep 17 00:00:00 2001 From: Antonis Geralis <43617260+planetis-m@users.noreply.github.com> Date: Sat, 1 Jan 2022 18:25:13 +0200 Subject: [PATCH 06/13] Update raylib_gen.nim --- raylib_gen.nim | 320 ++++++++++++++++++++++++++----------------------- 1 file changed, 167 insertions(+), 153 deletions(-) diff --git a/raylib_gen.nim b/raylib_gen.nim index 3dcb54e..76a2371 100644 --- a/raylib_gen.nim +++ b/raylib_gen.nim @@ -1,5 +1,4 @@ -import common, std/[algorithm, streams] -import strutils except indent +import common, std/[algorithm, streams, strutils, sugar] const extraTypes = { @@ -22,6 +21,7 @@ const MaxMeshVertexBuffers* = 7 ## Maximum vertex buffers (VBO) per mesh """ helpers = """ + type va_list* {.importc: "va_list", header: "".} = object ## Only used by TraceLogCallback proc vprintf*(format: cstring, args: va_list) {.cdecl, importc: "vprintf", header: "".} @@ -75,68 +75,123 @@ const Magenta* = Color(r: 255, g: 0, b: 255, a: 255) RayWhite* = Color(r: 245, g: 245, b: 245, a: 255) """ + enumInFuncReturn = [ + ("GetKeyPressed", 0), + ("GetGamepadButtonPressed", 14), + ("GetGestureDetected", 25) + ] enumInFuncParams = [ # KeyboardKey - ("IsKeyPressed", "KeyboardKey", @["key"]), - ("IsKeyDown", "KeyboardKey", @["key"]), - ("IsKeyReleased", "KeyboardKey", @["key"]), - ("IsKeyUp", "KeyboardKey", @["key"]), - ("SetExitKey", "KeyboardKey", @["key"]), - ("GetKeyPressed", "KeyboardKey", @["returnType"]), - ("SetCameraPanControl", "KeyboardKey", @["keyPan"]), - ("SetCameraAltControl", "KeyboardKey", @["keyAlt"]), - ("SetCameraSmoothZoomControl", "KeyboardKey", @["keySmoothZoom"]), - ("SetCameraMoveControls", "KeyboardKey", @["keyFront", "keyBack", "keyRight", "keyLeft", "keyUp", "keyDown"]), + ("IsKeyPressed", "key"), + ("IsKeyDown", "key"), + ("IsKeyReleased", "key"), + ("IsKeyUp", "key"), + ("SetExitKey", "key"), + ("SetCameraPanControl", "keyPan"), + ("SetCameraAltControl", "keyAlt"), + ("SetCameraSmoothZoomControl", "keySmoothZoom"), + ("SetCameraMoveControls", "keyFront"), + ("SetCameraMoveControls", "keyBack"), + ("SetCameraMoveControls", "keyRight"), + ("SetCameraMoveControls", "keyLeft"), + ("SetCameraMoveControls", "keyUp"), + ("SetCameraMoveControls", "keyDown"), # GamepadButton - ("IsGamepadButtonPressed", "GamepadButton", @["button"]), - ("IsGamepadButtonDown", "GamepadButton", @["button"]), - ("IsGamepadButtonReleased", "GamepadButton", @["button"]), - ("IsGamepadButtonUp", "GamepadButton", @["button"]), - ("GetGamepadButtonPressed", "GamepadButton", @["returnType"]), + ("IsGamepadButtonPressed", "button"), + ("IsGamepadButtonDown", "button"), + ("IsGamepadButtonReleased", "button"), + ("IsGamepadButtonUp", "button"), # GamepadAxis - ("GetGamepadAxisMovement", "GamepadAxis", @["axis"]), + ("GetGamepadAxisMovement", "axis"), # MouseCursor - ("SetMouseCursor", "MouseCursor", @["cursor"]), + ("SetMouseCursor", "cursor"), # MouseButton - ("IsMouseButtonPressed", "MouseButton", @["button"]), - ("IsMouseButtonDown", "MouseButton", @["button"]), - ("IsMouseButtonReleased", "MouseButton", @["button"]), - ("IsMouseButtonUp", "MouseButton", @["button"]), + ("IsMouseButtonPressed", "button"), + ("IsMouseButtonDown", "button"), + ("IsMouseButtonReleased", "button"), + ("IsMouseButtonUp", "button"), # Gesture - ("SetGesturesEnabled", "Flag[Gesture]", @["flags"]), - ("IsGestureDetected", "Gesture", @["gesture"]), - ("GetGestureDetected", "Gesture", @["returnType"]), + ("SetGesturesEnabled", "flags"), + ("IsGestureDetected", "gesture"), # ConfigFlags - ("SetConfigFlags", "Flag[ConfigFlags]", @["flags"]), - ("IsWindowState", "ConfigFlags", @["flag"]), - ("SetWindowState", "Flag[ConfigFlags]", @["flags"]), - ("ClearWindowState", "Flag[ConfigFlags]", @["flags"]), + ("SetConfigFlags", "flags"), + ("SetWindowState", "flags"), + ("ClearWindowState", "flags"), + ("IsWindowState", "flag"), # TraceLogLevel - ("TraceLog", "TraceLogLevel", @["logLevel"]), - ("SetTraceLogLevel", "TraceLogLevel", @["logLevel"]), + ("TraceLog", "logLevel"), + ("SetTraceLogLevel", "logLevel"), # CameraMode - ("SetCameraMode", "CameraMode", @["mode"]), + ("SetCameraMode", "mode"), # BlendMode - ("BeginBlendMode", "BlendMode", @["mode"]), + ("BeginBlendMode", "mode"), # MaterialMapIndex - ("SetMaterialTexture", "MaterialMapIndex", @["mapType"]), + ("SetMaterialTexture", "mapType"), # ShaderUniformDataType - ("SetShaderValue", "ShaderUniformDataType", @["uniformType"]), - ("SetShaderValueV", "ShaderUniformDataType", @["uniformType"]), + ("SetShaderValue", "uniformType"), + ("SetShaderValueV", "uniformType"), # PixelFormat - ("LoadImageRaw", "PixelFormat", @["format"]), - ("ImageFormat", "PixelFormat", @["newFormat"]), - ("GetPixelColor", "PixelFormat", @["format"]), - ("SetPixelColor", "PixelFormat", @["format"]), - ("GetPixelDataSize", "PixelFormat", @["format"]), + ("LoadImageRaw", "format"), + ("ImageFormat", "newFormat"), + ("GetPixelColor", "format"), + ("SetPixelColor", "format"), + ("GetPixelDataSize", "format"), # TextureFilter - ("SetTextureFilter", "TextureFilter", @["filter"]), + ("SetTextureFilter", "filter"), # TextureWrap - ("SetTextureWrap", "TextureWrap", @["wrap"]), + ("SetTextureWrap", "wrap"), # CubemapLayout - ("LoadTextureCubemap", "CubemapLayout", @["layout"]), + ("LoadTextureCubemap", "layout"), # FontType - ("LoadFontData", "FontType", @["type"]), + ("LoadFontData", "type") + ] + enumInFuncs = [ + "KeyboardKey", + "KeyboardKey", + "KeyboardKey", + "KeyboardKey", + "KeyboardKey", + "KeyboardKey", + "KeyboardKey", + "KeyboardKey", + "KeyboardKey", + "KeyboardKey", + "KeyboardKey", + "KeyboardKey", + "KeyboardKey", + "KeyboardKey", + "GamepadButton", + "GamepadButton", + "GamepadButton", + "GamepadButton", + "GamepadAxis", + "MouseCursor", + "MouseButton", + "MouseButton", + "MouseButton", + "MouseButton", + "Flag[Gesture]", + "Gesture", + "Flag[ConfigFlags]", + "Flag[ConfigFlags]", + "Flag[ConfigFlags]", + "ConfigFlags", + "TraceLogLevel", + "TraceLogLevel", + "CameraMode", + "BlendMode", + "MaterialMapIndex", + "ShaderUniformDataType", + "ShaderUniformDataType", + "PixelFormat", + "PixelFormat", + "PixelFormat", + "PixelFormat", + "PixelFormat", + "TextureFilter", + "TextureWrap", + "CubemapLayout", + "FontType" ] excludedFuncs = [ # Text strings management functions @@ -158,9 +213,6 @@ const # Misc "GetRandomValue", "SetRandomSeed", - "MemAlloc", - "MemRealloc", - "MemFree", "OpenURL", # Files management functions "LoadFileData", @@ -186,70 +238,49 @@ const "CompressData", "DecompressData", "EncodeDataBase64", - "DecodeDataBase64" + "DecodeDataBase64", + # Text codepoints management functions (unicode characters) + "LoadCodepoints", + "UnloadCodepoints", + "GetCodepointCount", + "GetCodepoint", + "CodepointToUTF8", + "TextCodepointsToUTF8", + ] + allocFuncs = [ + "MemAlloc", + "MemRealloc", + "MemFree" + ] + privateFuncs = [ + "GetMonitorName", + "GetClipboardText", + "GetDroppedFiles", + "GetGamepadName", + "LoadModelAnimations", + "UnloadModelAnimations", + "LoadWaveSamples", + "UnloadWaveSamples", + "LoadImagePalette", + "UnloadImagePalette", + "LoadImageColors", + "UnloadImageColors", + "LoadFontData", + "UnloadFontData", + "LoadMaterials", + "DrawLineStrip", + "DrawTriangleFan", + "DrawTriangleStrip", + "LoadImageFromMemory", + "DrawTexturePoly", + "LoadFontEx", + "LoadFontFromMemory", + "GenImageFontAtlas", + "DrawTriangleStrip3D", + "DrawMeshInstanced", + "LoadWaveFromMemory", + "LoadMusicStreamFromMemory" ] - raylibDestructors = """ - -proc `=destroy`*(x: var Image) = - if x.data != nil: unloadImage(x) -proc `=copy`*(dest: var Image; source: Image) = - if dest.data != source.data: - `=destroy`(dest) - wasMoved(dest) - dest = imageCopy(source) - -proc `=destroy`*(x: var Texture) = - if x.id > 0: unloadTexture(x) -proc `=copy`*(dest: var Texture; source: Texture) {.error.} - -proc `=destroy`*(x: var RenderTexture) = - if x.id > 0: unloadRenderTexture(x) -proc `=copy`*(dest: var RenderTexture; source: RenderTexture) {.error.} - -proc `=destroy`*(x: var Font) = - if x.texture.id > 0: unloadFont(x) -proc `=copy`*(dest: var Font; source: Font) {.error.} - -proc `=destroy`*(x: var Mesh) = - if x.vboId != nil: unloadMesh(x) -proc `=copy`*(dest: var Mesh; source: Mesh) {.error.} - -proc `=destroy`*(x: var Shader) = - if x.id > 0: unloadShader(x) -proc `=copy`*(dest: var Shader; source: Shader) {.error.} - -proc `=destroy`*(x: var Material) = - if x.maps != nil: unloadMaterial(x) -proc `=copy`*(dest: var Material; source: Material) {.error.} - -proc `=destroy`*(x: var Model) = - if x.meshes != nil: unloadModel(x) -proc `=copy`*(dest: var Model; source: Model) {.error.} - -proc `=destroy`*(x: var ModelAnimation) = - if x.framePoses != nil: unloadModelAnimation(x) -proc `=copy`*(dest: var ModelAnimation; source: ModelAnimation) {.error.} - -proc `=destroy`*(x: var Wave) = - if x.data != nil: unloadWave(x) -proc `=copy`*(dest: var Wave; source: Wave) = - if dest.data != source.data: - `=destroy`(dest) - wasMoved(dest) - dest = waveCopy(source) - -proc `=destroy`*(x: var AudioStream) = - if x.buffer != nil: unloadAudioStream(x) -proc `=copy`*(dest: var AudioStream; source: AudioStream) {.error.} - -proc `=destroy`*(x: var Sound) = - if x.stream.buffer != nil: unloadSound(x) -proc `=copy`*(dest: var Sound; source: Sound) {.error.} - -proc `=destroy`*(x: var Music) = - if x.stream.buffer != nil: unloadMusicStream(x) -proc `=copy`*(dest: var Music; source: Music) {.error.} -""" proc removeEnumPrefix(enm, val: string): string = # Remove prefixes from enum fields. @@ -304,29 +335,6 @@ proc getSpecialPattern(x, y: string, replacements: openarray[(string, string, st return pattern proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = - template ident(x: string) = - buf.setLen 0 - let isKeyw = isKeyword(x) - if isKeyw: - buf.add '`' - buf.add x - if isKeyw: - buf.add '`' - otp.write buf - template lit(x: string) = otp.write x - template spaces = - buf.setLen 0 - addIndent(buf, indent) - otp.write buf - template scope(body: untyped) = - inc indent, indWidth - body - dec indent, indWidth - template doc(x: untyped) = - if x.description != "": - lit " ## " - lit x.description - var buf = newStringOfCap(50) var indent = 0 var otp: FileStream @@ -351,7 +359,7 @@ proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = if kind != "": lit kind else: - let many = hasMany(name) or (obj.name, name) in {"Model": "meshMaterial", "Model": "bindPose"} + let many = isPlural(name) or (obj.name, name) in {"Model": "meshMaterial", "Model": "bindPose"} const replacements = [ ("ModelAnimation", "framePoses", "ptr UncheckedArray[ptr UncheckedArray[$1]]"), ("Mesh", "vboId", "ptr array[MaxMeshVertexBuffers, $1]"), @@ -360,7 +368,7 @@ proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = ] let tmp = getSpecialPattern(obj.name, name, replacements) if tmp != "": pat = tmp - let kind = convertType(fld.`type`, pat, many) + let kind = convertType(fld.`type`, pat, many, false) lit kind doc fld # Add a type alias or a missing type after the respective type. @@ -396,7 +404,14 @@ proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = if fnc.name in excludedFuncs: continue lit "\nproc " ident uncapitalizeAscii(fnc.name) # Follow Nim's naming convention for proc names. - lit "*(" + let isPrivate = fnc.name in privateFuncs + let isAlloc = fnc.name in allocFuncs + if isPrivate: + lit "Priv(" + elif isAlloc: + lit "(" + else: + lit "*(" var hasVarargs = false for i, (param, kind) in fnc.params.pairs: if param == "" and kind == "": # , ...) { @@ -406,36 +421,36 @@ proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = ident param lit ": " block outer: - for (name, kind, params) in enumInFuncParams.items: - if name == fnc.name and param in params: - lit kind + for j, (name, param1) in enumInFuncParams.pairs: + if name == fnc.name and param1 == param: + lit enumInFuncs[j] break outer - let many = (fnc.name, param) notin {"LoadImageAnim": "frames"} and hasMany(param) + let many = (fnc.name, param) != ("LoadImageAnim", "frames") and isPlural(param) const replacements = [ ("GenImageFontAtlas", "recs", "ptr ptr UncheckedArray[$1]") ] let pat = getSpecialPattern(fnc.name, param, replacements) - let kind = convertType(kind, pat, many) + let kind = convertType(kind, pat, many, not isPrivate) lit kind lit ")" if fnc.returnType != "void": lit ": " block outer: - for (name, kind, params) in enumInFuncParams.items: - if name == fnc.name and "returnType" in params: - lit kind + for (name, idx) in enumInFuncReturn.items: + if name == fnc.name: + lit enumInFuncs[idx] break outer - let many = hasMany(fnc.name) or fnc.name == "LoadImagePalette" - let kind = convertType(fnc.returnType, "", many) - ident kind + let many = isPlural(fnc.name) or fnc.name == "LoadImagePalette" + let kind = convertType(fnc.returnType, "", many, not isPrivate) + lit kind lit " {.importc: \"" ident fnc.name lit "\"" if hasVarargs: lit ", varargs" lit ", rlapi.}" - if fnc.description != "": + if not (isAlloc or isPrivate) and fnc.description != "": scope: spaces lit "## " @@ -450,10 +465,9 @@ const outputname = "../raylib.nim" proc main = - proc cmp(x, y: ValueInfo): int = cmp(x.value, y.value) var t = parseApi(raylibApi) # Some enums are unsorted! - for enm in mitems(t.enums): sort(enm.values, cmp) - genBindings(t, outputname, raylibHeader, helpers, raylibDestructors) + for enm in mitems(t.enums): sort(enm.values, (x, y) => cmp(x.value, y.value)) + genBindings(t, outputname, raylibHeader, helpers, readFile("raylib_wrap.nim")) main() From 24948c20e5ca8179461b6e9773cc11e989844ce4 Mon Sep 17 00:00:00 2001 From: Antonis Geralis <43617260+planetis-m@users.noreply.github.com> Date: Sat, 1 Jan 2022 18:25:41 +0200 Subject: [PATCH 07/13] Update raymath_gen.nim --- raymath_gen.nim | 32 ++++---------------------------- 1 file changed, 4 insertions(+), 28 deletions(-) diff --git a/raymath_gen.nim b/raymath_gen.nim index d1ac3bb..07a1910 100644 --- a/raymath_gen.nim +++ b/raymath_gen.nim @@ -1,5 +1,4 @@ -import common, std/[algorithm, streams, strformat] -import strutils except indent +import common, std/[algorithm, strutils, streams, strformat] const raymathHeader = """ @@ -8,7 +7,7 @@ from raylib import Vector2, Vector3, Vector4, Quaternion, Matrix const lext = when defined(windows): ".dll" elif defined(macosx): ".dylib" else: ".so" {.pragma: rmapi, cdecl, dynlib: "libraylib" & lext.} """ - excluded = [ + excludedTypes = [ "Vector2", "Vector3", "Vector4", @@ -40,29 +39,6 @@ template `-`*[T: Vector2 | Vector3](v1: T): T = negate(v1) """ proc genBindings(t: Topmost, fname: string, header, footer: string) = - template ident(x: string) = - buf.setLen 0 - let isKeyw = isKeyword(x) - if isKeyw: - buf.add '`' - buf.add x - if isKeyw: - buf.add '`' - otp.write buf - template lit(x: string) = otp.write x - template spaces = - buf.setLen 0 - addIndent(buf, indent) - otp.write buf - template scope(body: untyped) = - inc indent, indWidth - body - dec indent, indWidth - template doc(x: untyped) = - if x.description != "": - lit " ## " - lit x.description - var buf = newStringOfCap(50) var indent = 0 var otp: FileStream @@ -73,7 +49,7 @@ proc genBindings(t: Topmost, fname: string, header, footer: string) = lit "\ntype" scope: for obj in items(t.structs): - if obj.name in excluded: continue + if obj.name in excludedTypes: continue spaces ident capitalizeAscii(obj.name) lit "* {.bycopy.} = object" @@ -113,7 +89,7 @@ proc genBindings(t: Topmost, fname: string, header, footer: string) = if fnc.returnType != "void": lit ": " let kind = convertType(fnc.returnType, "", false) - ident kind + lit kind lit " {.importc: \"" ident fnc.name lit "\"" From 29a8da17e7e112f80a288f2266556d11b8f34872 Mon Sep 17 00:00:00 2001 From: Antonis Geralis <43617260+planetis-m@users.noreply.github.com> Date: Sat, 1 Jan 2022 18:27:04 +0200 Subject: [PATCH 08/13] Create raylib_wrap.nim --- raylib_wrap.nim | 191 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 191 insertions(+) create mode 100644 raylib_wrap.nim diff --git a/raylib_wrap.nim b/raylib_wrap.nim new file mode 100644 index 0000000..1ca8197 --- /dev/null +++ b/raylib_wrap.nim @@ -0,0 +1,191 @@ + +proc `=destroy`*(x: var Image) = + if x.data != nil: unloadImage(x) +proc `=copy`*(dest: var Image; source: Image) = + if dest.data != source.data: + `=destroy`(dest) + wasMoved(dest) + dest = imageCopy(source) + +proc `=destroy`*(x: var Texture) = + if x.id > 0: unloadTexture(x) +proc `=copy`*(dest: var Texture; source: Texture) {.error.} + +proc `=destroy`*(x: var RenderTexture) = + if x.id > 0: unloadRenderTexture(x) +proc `=copy`*(dest: var RenderTexture; source: RenderTexture) {.error.} + +proc `=destroy`*(x: var Font) = + if x.texture.id > 0: unloadFont(x) +proc `=copy`*(dest: var Font; source: Font) {.error.} + +proc `=destroy`*(x: var Mesh) = + if x.vboId != nil: unloadMesh(x) +proc `=copy`*(dest: var Mesh; source: Mesh) {.error.} + +proc `=destroy`*(x: var Shader) = + if x.id > 0: unloadShader(x) +proc `=copy`*(dest: var Shader; source: Shader) {.error.} + +proc `=destroy`*(x: var Material) = + if x.maps != nil: unloadMaterial(x) +proc `=copy`*(dest: var Material; source: Material) {.error.} + +proc `=destroy`*(x: var Model) = + if x.meshes != nil: unloadModel(x) +proc `=copy`*(dest: var Model; source: Model) {.error.} + +proc `=destroy`*(x: var ModelAnimation) = + if x.framePoses != nil: unloadModelAnimation(x) +proc `=copy`*(dest: var ModelAnimation; source: ModelAnimation) {.error.} + +proc `=destroy`*(x: var Wave) = + if x.data != nil: unloadWave(x) +proc `=copy`*(dest: var Wave; source: Wave) = + if dest.data != source.data: + `=destroy`(dest) + wasMoved(dest) + dest = waveCopy(source) + +proc `=destroy`*(x: var AudioStream) = + if x.buffer != nil: unloadAudioStream(x) +proc `=copy`*(dest: var AudioStream; source: AudioStream) {.error.} + +proc `=destroy`*(x: var Sound) = + if x.stream.buffer != nil: unloadSound(x) +proc `=copy`*(dest: var Sound; source: Sound) {.error.} + +proc `=destroy`*(x: var Music) = + if x.stream.buffer != nil: unloadMusicStream(x) +proc `=copy`*(dest: var Music; source: Music) {.error.} + +proc getMonitorName*(monitor: int32): string {.inline.} = + ## Get the human-readable, UTF-8 encoded name of the primary monitor + result = $getMonitorNamePriv(monitor) + +proc getClipboardText*(): string {.inline.} = + ## Get clipboard text content + result = $getClipboardTextPriv() + +proc getDroppedFiles*(): seq[string] = + ## Get dropped files names (memory should be freed) + var count = 0'i32 + let dropfiles = getDroppedFilesPriv(count.addr) + result = cstringArrayToSeq(dropfiles, count) + +proc getGamepadName*(gamepad: int32): string {.inline.} = + ## Get gamepad internal name id + result = $getGamepadNamePriv(gamepad) + +proc loadModelAnimations*(fileName: string): seq[ModelAnimation] = + ## Load model animations from file + var len = 0'u32 + let data = loadModelAnimationsPriv(fileName.cstring, len.addr) + if len <= 0: + raise newException(IOError, "No model animations loaded from " & filename) + result = newSeq[ModelAnimation](len.int) + copyMem(result[0].addr, data, len.int * sizeof(ModelAnimation)) + #for i in 0.. Date: Tue, 4 Jan 2022 00:31:57 +0200 Subject: [PATCH 09/13] Update raylib_gen.nim --- raylib_gen.nim | 143 +++++++++++++++++++------------------------------ 1 file changed, 55 insertions(+), 88 deletions(-) diff --git a/raylib_gen.nim b/raylib_gen.nim index 76a2371..c09ea8d 100644 --- a/raylib_gen.nim +++ b/raylib_gen.nim @@ -1,4 +1,4 @@ -import common, std/[algorithm, streams, strutils, sugar] +import common, std/[streams, strutils] const extraTypes = { @@ -7,20 +7,13 @@ const "Texture": "TextureCubemap* = Texture ## TextureCubemap, same as Texture", "RenderTexture": "RenderTexture2D* = RenderTexture ## RenderTexture2D, same as RenderTexture", "Camera3D": "Camera* = Camera3D ## Camera type fallback, defaults to Camera3D", - "AudioStream": "RAudioBuffer* {.importc: \"rAudioBuffer\", bycopy.} = object" + "AudioStream": """RAudioBuffer* {.importc: "rAudioBuffer", header: "raylib.h", bycopy.} = object""" } raylibHeader = """ -const lext = when defined(windows): ".dll" elif defined(macosx): ".dylib" else: ".so" -{.pragma: rlapi, cdecl, dynlib: "libraylib" & lext.} +{.passL: "-lraylib -lGL -lm -lpthread -ldl -lrt -lX11 -DPLATFORM_DESKTOP".} const - RaylibVersion* = "4.0" - - MaxShaderLocations* = 32 ## Maximum number of shader locations supported - MaxMaterialMaps* = 12 ## Maximum number of shader maps supported - MaxMeshVertexBuffers* = 7 ## Maximum vertex buffers (VBO) per mesh -""" - helpers = """ + RaylibVersion* = "4.1-dev" type va_list* {.importc: "va_list", header: "".} = object ## Only used by TraceLogCallback proc vprintf*(format: cstring, args: va_list) {.cdecl, importc: "vprintf", header: "".} @@ -35,7 +28,20 @@ type cdecl.} ## FileIO: Save binary data LoadFileTextCallback* = proc (fileName: cstring): cstring {.cdecl.} ## FileIO: Load text data SaveFileTextCallback* = proc (fileName: cstring; text: cstring): bool {.cdecl.} ## FileIO: Save text data +""" + extraDistinct = """ + + MaterialMapDiffuse* = MaterialMapAlbedo + MaterialMapSpecular* = MaterialMapMetalness + + ShaderLocMapDiffuse* = ShaderLocMapAlbedo + ShaderLocMapSpecular* = ShaderLocMapMetalness + # Taken from raylib/src/config.h + MaxShaderLocations* = ShaderLocationIndex(32) ## Maximum number of shader locations supported + MaxMaterialMaps* = MaterialMapIndex(12) ## Maximum number of shader maps supported + MaxMeshVertexBuffers* = 7 ## Maximum vertex buffers (VBO) per mesh +type Enums = ConfigFlags|Gesture Flag*[E: Enums] = distinct uint32 @@ -44,10 +50,10 @@ proc flag*[E: Enums](e: varargs[E]): Flag[E] {.inline.} = for val in items(e): res = res or uint32(val) Flag[E](res) +""" + helpers = """ const - Menu* = KeyboardKey.R ## Key: Android menu button - LightGray* = Color(r: 200, g: 200, b: 200, a: 255) Gray* = Color(r: 130, g: 130, b: 130, a: 255) DarkGray* = Color(r: 80, g: 80, b: 80, a: 255) @@ -282,52 +288,7 @@ const "LoadMusicStreamFromMemory" ] -proc removeEnumPrefix(enm, val: string): string = - # Remove prefixes from enum fields. - const - enumPrefixes = { - "ConfigFlags": "FLAG_", - "TraceLogLevel": "LOG_", - "KeyboardKey": "KEY_", - "MouseButton": "MOUSE_BUTTON_", - "MouseCursor": "MOUSE_CURSOR_", - "GamepadButton": "GAMEPAD_BUTTON_", - "GamepadAxis": "GAMEPAD_AXIS_", - "MaterialMapIndex": "MATERIAL_MAP_", - "ShaderLocationIndex": "SHADER_LOC_", - "ShaderUniformDataType": "SHADER_UNIFORM_", - "ShaderAttributeDataType": "SHADER_ATTRIB_", - "PixelFormat": "PIXELFORMAT_", - "TextureFilter": "TEXTURE_FILTER_", - "TextureWrap": "TEXTURE_WRAP_", - "CubemapLayout": "CUBEMAP_LAYOUT_", - "FontType": "FONT_", - "BlendMode": "BLEND_", - "Gesture": "GESTURE_", - "CameraMode": "CAMERA_", - "CameraProjection": "CAMERA_", - "NPatchLayout": "NPATCH_" - } - result = val - for x, prefix in enumPrefixes.items: - if enm == x: - removePrefix(result, prefix) - return - -proc replaceCintField(obj, fld: string): string = - # Replace `int32` with the respective enum type. - const enumReplacements = [ - ("Camera3D", "projection", "CameraProjection"), - ("Image", "format", "PixelFormat"), - ("Texture", "format", "PixelFormat"), - ("NPatchInfo", "layout", "NPatchLayout") - ] - result = "" - for x, y, kind in enumReplacements.items: - if obj == x and fld == y: - return kind - -proc getSpecialPattern(x, y: string, replacements: openarray[(string, string, string)]): string = +proc getReplacement(x, y: string, replacements: openarray[(string, string, string)]): string = # Manual replacements for some fields result = "" for a, b, pattern in replacements.items: @@ -341,13 +302,35 @@ proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = try: otp = openFileStream(fname, fmWrite) lit header + # Generate enum definitions + lit "\ntype" + scope: + for enm in items(t.enums): + spaces + ident enm.name + lit "* = distinct int32" + doc enm + lit "\n\nconst" + scope: + for enm in items(t.enums): + for i, val in pairs(enm.values): + spaces + ident camelCaseAscii(val.name) + lit "* = " + ident enm.name + lit "(" + lit $val.value + lit ")" + doc val + lit "\n" + lit extraDistinct # Generate type definitions lit "\ntype" scope: for obj in items(t.structs): spaces ident obj.name - lit "* {.bycopy.} = object" + lit "* {.header: \"raylib.h\", bycopy.} = object" doc obj scope: for fld in items(obj.fields): @@ -355,7 +338,13 @@ proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = var (name, pat) = transFieldName(fld.name) ident name lit "*: " - let kind = replaceCintField(obj.name, name) + const replacements = [ + ("Camera3D", "projection", "CameraProjection"), + ("Image", "format", "PixelFormat"), + ("Texture", "format", "PixelFormat"), + ("NPatchInfo", "layout", "NPatchLayout") + ] + let kind = getReplacement(obj.name, name, replacements) if kind != "": lit kind else: @@ -366,7 +355,7 @@ proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = ("Material", "maps", "ptr array[MaxMaterialMaps, $1]"), ("Shader", "locs", "ptr array[MaxShaderLocations, $1]") ] - let tmp = getSpecialPattern(obj.name, name, replacements) + let tmp = getReplacement(obj.name, name, replacements) if tmp != "": pat = tmp let kind = convertType(fld.`type`, pat, many, false) lit kind @@ -377,29 +366,9 @@ proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = spaces lit extra lit "\n" - # Generate enums definitions - for enm in items(t.enums): - spaces - ident enm.name - lit "* {.size: sizeof(cint).} = enum" - doc enm - scope: - let allSeq = allSequential(enm.values) - for i, val in pairs(enm.values): - if i-1>=0 and enm.values[i-1].value == val.value: # omit duplicate! - continue - spaces - # Follow Nim's naming convention for enum fields. - let name = removeEnumPrefix(enm.name, val.name) - ident camelCaseAscii(name) - # Set the int value if the enum has holes and it doesn't start at 0. - if not allSeq or (i == 0 and val.value != 0): - lit " = " - lit $val.value - doc val - lit "\n" lit middle # Generate functions + lit "\n{.push callconv: cdecl, header: \"raylib.h\".}" for fnc in items(t.functions): if fnc.name in excludedFuncs: continue lit "\nproc " @@ -430,7 +399,7 @@ proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = replacements = [ ("GenImageFontAtlas", "recs", "ptr ptr UncheckedArray[$1]") ] - let pat = getSpecialPattern(fnc.name, param, replacements) + let pat = getReplacement(fnc.name, param, replacements) let kind = convertType(kind, pat, many, not isPrivate) lit kind lit ")" @@ -449,13 +418,13 @@ proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = lit "\"" if hasVarargs: lit ", varargs" - lit ", rlapi.}" + lit ".}" if not (isAlloc or isPrivate) and fnc.description != "": scope: spaces lit "## " lit fnc.description - lit "\n" + lit "\n{.pop.}\n" lit footer finally: if otp != nil: otp.close() @@ -466,8 +435,6 @@ const proc main = var t = parseApi(raylibApi) - # Some enums are unsorted! - for enm in mitems(t.enums): sort(enm.values, (x, y) => cmp(x.value, y.value)) genBindings(t, outputname, raylibHeader, helpers, readFile("raylib_wrap.nim")) main() From 817536c9f59fc5e7b2ab3c9fc250c07a7983e1d6 Mon Sep 17 00:00:00 2001 From: Antonis Geralis <43617260+planetis-m@users.noreply.github.com> Date: Thu, 20 Jan 2022 16:55:55 +0200 Subject: [PATCH 10/13] Update raylib_gen.nim --- raylib_gen.nim | 72 +++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 56 insertions(+), 16 deletions(-) diff --git a/raylib_gen.nim b/raylib_gen.nim index c09ea8d..26202b5 100644 --- a/raylib_gen.nim +++ b/raylib_gen.nim @@ -37,8 +37,8 @@ type ShaderLocMapDiffuse* = ShaderLocMapAlbedo ShaderLocMapSpecular* = ShaderLocMapMetalness # Taken from raylib/src/config.h - MaxShaderLocations* = ShaderLocationIndex(32) ## Maximum number of shader locations supported - MaxMaterialMaps* = MaterialMapIndex(12) ## Maximum number of shader maps supported + MaxShaderLocations* = 32 ## Maximum number of shader locations supported + MaxMaterialMaps* = 12 ## Maximum number of shader maps supported MaxMeshVertexBuffers* = 7 ## Maximum vertex buffers (VBO) per mesh type @@ -236,6 +236,7 @@ const "GetDirectoryPath", "GetPrevDirectoryPath", "GetWorkingDirectory", + "GetApplicationDirectory", "GetDirectoryFiles", "ClearDirectoryFiles", "ChangeDirectory", @@ -295,7 +296,7 @@ proc getReplacement(x, y: string, replacements: openarray[(string, string, strin if x == a and y == b: return pattern -proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = +proc genBindings(t: TopLevel, fname: string; header, middle: string) = var buf = newStringOfCap(50) var indent = 0 var otp: FileStream @@ -325,6 +326,8 @@ proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = lit "\n" lit extraDistinct # Generate type definitions + var procProperties: seq[(string, string, string)] = @[] + var procArrays: seq[(string, string, string)] = @[] lit "\ntype" scope: for obj in items(t.structs): @@ -337,7 +340,9 @@ proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = spaces var (name, pat) = transFieldName(fld.name) ident name - lit "*: " + let isPrivate = (obj.name, name) notin + {"Wave": "frameCount", "Sound": "frameCount", "Music": "frameCount"} and + name.endsWith("Count") const replacements = [ ("Camera3D", "projection", "CameraProjection"), ("Image", "format", "PixelFormat"), @@ -346,9 +351,11 @@ proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = ] let kind = getReplacement(obj.name, name, replacements) if kind != "": + lit "*: " lit kind else: - let many = isPlural(name) or (obj.name, name) in {"Model": "meshMaterial", "Model": "bindPose"} + let many = name notin ["mipmaps", "channels"] and isPlural(name) or + (obj.name, name) in {"Model": "meshMaterial", "Model": "bindPose", "Mesh": "vboId"} const replacements = [ ("ModelAnimation", "framePoses", "ptr UncheckedArray[ptr UncheckedArray[$1]]"), ("Mesh", "vboId", "ptr array[MaxMeshVertexBuffers, $1]"), @@ -357,8 +364,19 @@ proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = ] let tmp = getReplacement(obj.name, name, replacements) if tmp != "": pat = tmp - let kind = convertType(fld.`type`, pat, many, false) + var baseKind = "" + let kind = convertType(fld.`type`, pat, many, false, baseKind) + var isArray = many and not endsWith(name.normalize, "data") and + (obj.name, name) notin {"Material": "params", "VrDeviceInfo": "lensDistortionValues"} + if isPrivate or isArray: + lit ": " + else: + lit "*: " lit kind + if isPrivate: + procProperties.add (obj.name, name, kind) + if isArray: + procArrays.add (obj.name, name, baseKind) doc fld # Add a type alias or a missing type after the respective type. for name, extra in extraTypes.items: @@ -366,6 +384,13 @@ proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = spaces lit extra lit "\n" + for obj, name, _ in procArrays.items: + spaces + lit obj + lit capitalizeAscii(name) + lit "* = distinct " + ident obj + lit "\n" lit middle # Generate functions lit "\n{.push callconv: cdecl, header: \"raylib.h\".}" @@ -382,25 +407,26 @@ proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = else: lit "*(" var hasVarargs = false - for i, (param, kind) in fnc.params.pairs: - if param == "" and kind == "": # , ...) { + for i, param in fnc.params.pairs: + if param.name == "" and param.`type` == "": # , ...) { hasVarargs = true else: if i > 0: lit ", " - ident param + ident param.name lit ": " block outer: for j, (name, param1) in enumInFuncParams.pairs: - if name == fnc.name and param1 == param: + if name == fnc.name and param1 == param.name: lit enumInFuncs[j] break outer - let many = (fnc.name, param) != ("LoadImageAnim", "frames") and isPlural(param) + let many = (fnc.name, param.name) != ("LoadImageAnim", "frames") and isPlural(param.name) const replacements = [ ("GenImageFontAtlas", "recs", "ptr ptr UncheckedArray[$1]") ] - let pat = getReplacement(fnc.name, param, replacements) - let kind = convertType(kind, pat, many, not isPrivate) + let pat = getReplacement(fnc.name, param.name, replacements) + var baseKind = "" + let kind = convertType(param.`type`, pat, many, not isPrivate, baseKind) lit kind lit ")" if fnc.returnType != "void": @@ -411,7 +437,8 @@ proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = lit enumInFuncs[idx] break outer let many = isPlural(fnc.name) or fnc.name == "LoadImagePalette" - let kind = convertType(fnc.returnType, "", many, not isPrivate) + var baseKind = "" + let kind = convertType(fnc.returnType, "", many, not isPrivate, baseKind) lit kind lit " {.importc: \"" ident fnc.name @@ -425,7 +452,20 @@ proc genBindings(t: Topmost, fname: string; header, middle, footer: string) = lit "## " lit fnc.description lit "\n{.pop.}\n" - lit footer + lit readFile("raylib_types.nim") + lit "\n" + for obj, field, kind in procProperties.items: + lit "proc " + ident field + lit "*(x: " + ident obj + lit "): " + lit kind + lit " {.inline.} = x." + ident field + lit "\n" + lit readFile("raylib_wrap.nim") + lit readFile("raylib_fields.nim") finally: if otp != nil: otp.close() @@ -435,6 +475,6 @@ const proc main = var t = parseApi(raylibApi) - genBindings(t, outputname, raylibHeader, helpers, readFile("raylib_wrap.nim")) + genBindings(t, outputname, raylibHeader, helpers) main() From 7bb479b415c86d8cfdbfca3d8dd6c398d109830f Mon Sep 17 00:00:00 2001 From: Antonis Geralis <43617260+planetis-m@users.noreply.github.com> Date: Thu, 20 Jan 2022 16:56:41 +0200 Subject: [PATCH 11/13] Update raylib_wrap.nim --- raylib_wrap.nim | 60 ------------------------------------------------- 1 file changed, 60 deletions(-) diff --git a/raylib_wrap.nim b/raylib_wrap.nim index 1ca8197..3bad00e 100644 --- a/raylib_wrap.nim +++ b/raylib_wrap.nim @@ -1,64 +1,4 @@ -proc `=destroy`*(x: var Image) = - if x.data != nil: unloadImage(x) -proc `=copy`*(dest: var Image; source: Image) = - if dest.data != source.data: - `=destroy`(dest) - wasMoved(dest) - dest = imageCopy(source) - -proc `=destroy`*(x: var Texture) = - if x.id > 0: unloadTexture(x) -proc `=copy`*(dest: var Texture; source: Texture) {.error.} - -proc `=destroy`*(x: var RenderTexture) = - if x.id > 0: unloadRenderTexture(x) -proc `=copy`*(dest: var RenderTexture; source: RenderTexture) {.error.} - -proc `=destroy`*(x: var Font) = - if x.texture.id > 0: unloadFont(x) -proc `=copy`*(dest: var Font; source: Font) {.error.} - -proc `=destroy`*(x: var Mesh) = - if x.vboId != nil: unloadMesh(x) -proc `=copy`*(dest: var Mesh; source: Mesh) {.error.} - -proc `=destroy`*(x: var Shader) = - if x.id > 0: unloadShader(x) -proc `=copy`*(dest: var Shader; source: Shader) {.error.} - -proc `=destroy`*(x: var Material) = - if x.maps != nil: unloadMaterial(x) -proc `=copy`*(dest: var Material; source: Material) {.error.} - -proc `=destroy`*(x: var Model) = - if x.meshes != nil: unloadModel(x) -proc `=copy`*(dest: var Model; source: Model) {.error.} - -proc `=destroy`*(x: var ModelAnimation) = - if x.framePoses != nil: unloadModelAnimation(x) -proc `=copy`*(dest: var ModelAnimation; source: ModelAnimation) {.error.} - -proc `=destroy`*(x: var Wave) = - if x.data != nil: unloadWave(x) -proc `=copy`*(dest: var Wave; source: Wave) = - if dest.data != source.data: - `=destroy`(dest) - wasMoved(dest) - dest = waveCopy(source) - -proc `=destroy`*(x: var AudioStream) = - if x.buffer != nil: unloadAudioStream(x) -proc `=copy`*(dest: var AudioStream; source: AudioStream) {.error.} - -proc `=destroy`*(x: var Sound) = - if x.stream.buffer != nil: unloadSound(x) -proc `=copy`*(dest: var Sound; source: Sound) {.error.} - -proc `=destroy`*(x: var Music) = - if x.stream.buffer != nil: unloadMusicStream(x) -proc `=copy`*(dest: var Music; source: Music) {.error.} - proc getMonitorName*(monitor: int32): string {.inline.} = ## Get the human-readable, UTF-8 encoded name of the primary monitor result = $getMonitorNamePriv(monitor) From 7901781403b3c68675f599cae0a6461b7020b056 Mon Sep 17 00:00:00 2001 From: Antonis Geralis <43617260+planetis-m@users.noreply.github.com> Date: Thu, 20 Jan 2022 16:57:13 +0200 Subject: [PATCH 12/13] Create raylib_fields.nim --- raylib_fields.nim | 334 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 334 insertions(+) create mode 100644 raylib_fields.nim diff --git a/raylib_fields.nim b/raylib_fields.nim new file mode 100644 index 0000000..8b18233 --- /dev/null +++ b/raylib_fields.nim @@ -0,0 +1,334 @@ + +proc raiseRangeDefect {.noinline, noreturn.} = + raise newException(RangeDefect, "array access out of bounds") + +template checkArrayAccess(a, x, len) = + when compileOption("boundChecks"): + {.line.}: + if a == nil or x.uint32 >= len.uint32: + raiseRangeDefect() + +template recs*(x: Font): FontRecs = FontRecs(x) + +proc `[]`*(x: FontRecs, i: int): Rectangle = + checkArrayAccess(Font(x).recs, i, Font(x).glyphCount) + result = Font(x).recs[i] + +proc `[]`*(x: var FontRecs, i: int): var Rectangle = + checkArrayAccess(Font(x).recs, i, Font(x).glyphCount) + result = Font(x).recs[i] + +proc `[]=`*(x: var FontRecs, i: int, val: Rectangle) = + checkArrayAccess(Font(x).recs, i, Font(x).glyphCount) + Font(x).recs[i] = val + +template glyphs*(x: Font): FontGlyphs = FontGlyphs(x) + +proc `[]`*(x: FontGlyphs, i: int): lent GlyphInfo = + checkArrayAccess(Font(x).glyphs, i, Font(x).glyphCount) + result = Font(x).glyphs[i] + +proc `[]`*(x: var FontGlyphs, i: int): var GlyphInfo = + checkArrayAccess(Font(x).glyphs, i, Font(x).glyphCount) + result = Font(x).glyphs[i] + +proc `[]=`*(x: var FontGlyphs, i: int, val: GlyphInfo) = + checkArrayAccess(Font(x).glyphs, i, Font(x).glyphCount) + Font(x).glyphs[i] = val + +template vertices*(x: Mesh): MeshVertices = MeshVertices(x) + +proc `[]`*(x: MeshVertices, i: int): Vector3 = + checkArrayAccess(Mesh(x).vertices, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[Vector3]](Mesh(x).vertices)[i] + +proc `[]`*(x: var MeshVertices, i: int): var Vector3 = + checkArrayAccess(Mesh(x).vertices, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[Vector3]](Mesh(x).vertices)[i] + +proc `[]=`*(x: var MeshVertices, i: int, val: Vector3) = + checkArrayAccess(Mesh(x).vertices, i, Mesh(x).vertexCount) + cast[ptr UncheckedArray[Vector3]](Mesh(x).vertices)[i] = val + +template texcoords*(x: Mesh): MeshTexcoords = MeshTexcoords(x) + +proc `[]`*(x: MeshTexcoords, i: int): Vector2 = + checkArrayAccess(Mesh(x).texcoords, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[Vector2]](Mesh(x).texcoords)[i] + +proc `[]`*(x: var MeshTexcoords, i: int): var Vector2 = + checkArrayAccess(Mesh(x).texcoords, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[Vector2]](Mesh(x).texcoords)[i] + +proc `[]=`*(x: var MeshTexcoords, i: int, val: Vector2) = + checkArrayAccess(Mesh(x).texcoords, i, Mesh(x).vertexCount) + cast[ptr UncheckedArray[Vector2]](Mesh(x).texcoords)[i] = val + +template texcoords2*(x: Mesh): MeshTexcoords2 = MeshTexcoords2(x) + +proc `[]`*(x: MeshTexcoords2, i: int): Vector2 = + checkArrayAccess(Mesh(x).texcoords2, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[Vector2]](Mesh(x).texcoords2)[i] + +proc `[]`*(x: var MeshTexcoords2, i: int): var Vector2 = + checkArrayAccess(Mesh(x).texcoords2, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[Vector2]](Mesh(x).texcoords2)[i] + +proc `[]=`*(x: var MeshTexcoords2, i: int, val: Vector2) = + checkArrayAccess(Mesh(x).texcoords2, i, Mesh(x).vertexCount) + cast[ptr UncheckedArray[Vector2]](Mesh(x).texcoords2)[i] = val + +template normals*(x: Mesh): MeshNormals = MeshNormals(x) + +proc `[]`*(x: MeshNormals, i: int): Vector3 = + checkArrayAccess(Mesh(x).normals, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[Vector3]](Mesh(x).normals)[i] + +proc `[]`*(x: var MeshNormals, i: int): var Vector3 = + checkArrayAccess(Mesh(x).normals, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[Vector3]](Mesh(x).normals)[i] + +proc `[]=`*(x: var MeshNormals, i: int, val: Vector3) = + checkArrayAccess(Mesh(x).normals, i, Mesh(x).vertexCount) + cast[ptr UncheckedArray[Vector3]](Mesh(x).normals)[i] = val + +template tangents*(x: Mesh): MeshTangents = MeshTangents(x) + +proc `[]`*(x: MeshTangents, i: int): Vector4 = + checkArrayAccess(Mesh(x).tangents, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[Vector4]](Mesh(x).tangents)[i] + +proc `[]`*(x: var MeshTangents, i: int): var Vector4 = + checkArrayAccess(Mesh(x).tangents, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[Vector4]](Mesh(x).tangents)[i] + +proc `[]=`*(x: var MeshTangents, i: int, val: Vector4) = + checkArrayAccess(Mesh(x).tangents, i, Mesh(x).vertexCount) + cast[ptr UncheckedArray[Vector4]](Mesh(x).tangents)[i] = val + +template colors*(x: Mesh): MeshColors = MeshColors(x) + +proc `[]`*(x: MeshColors, i: int): Color = + checkArrayAccess(Mesh(x).colors, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[Color]](Mesh(x).colors)[i] + +proc `[]`*(x: var MeshColors, i: int): var Color = + checkArrayAccess(Mesh(x).colors, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[Color]](Mesh(x).colors)[i] + +proc `[]=`*(x: var MeshColors, i: int, val: Color) = + checkArrayAccess(Mesh(x).colors, i, Mesh(x).vertexCount) + cast[ptr UncheckedArray[Color]](Mesh(x).colors)[i] = val + +template indices*(x: Mesh): MeshIndices = MeshIndices(x) + +proc `[]`*(x: MeshIndices, i: int): array[3, uint16] = + checkArrayAccess(Mesh(x).indices, i, Mesh(x).triangleCount) + result = cast[ptr UncheckedArray[typeof(result)]](Mesh(x).indices)[i] + +proc `[]`*(x: var MeshIndices, i: int): var array[3, uint16] = + checkArrayAccess(Mesh(x).indices, i, Mesh(x).triangleCount) + result = cast[ptr UncheckedArray[typeof(result)]](Mesh(x).indices)[i] + +proc `[]=`*(x: var MeshIndices, i: int, val: array[3, uint16]) = + checkArrayAccess(Mesh(x).indices, i, Mesh(x).triangleCount) + cast[ptr UncheckedArray[typeof(val)]](Mesh(x).indices)[i] = val + +template animVertices*(x: Mesh): MeshAnimVertices = MeshAnimVertices(x) + +proc `[]`*(x: MeshAnimVertices, i: int): Vector3 = + checkArrayAccess(Mesh(x).animVertices, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[Vector3]](Mesh(x).animVertices)[i] + +proc `[]`*(x: var MeshAnimVertices, i: int): var Vector3 = + checkArrayAccess(Mesh(x).animVertices, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[Vector3]](Mesh(x).animVertices)[i] + +proc `[]=`*(x: var MeshAnimVertices, i: int, val: Vector3) = + checkArrayAccess(Mesh(x).animVertices, i, Mesh(x).vertexCount) + cast[ptr UncheckedArray[Vector3]](Mesh(x).animVertices)[i] = val + +template animNormals*(x: Mesh): MeshAnimNormals = MeshAnimNormals(x) + +proc `[]`*(x: MeshAnimNormals, i: int): Vector3 = + checkArrayAccess(Mesh(x).animNormals, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[Vector3]](Mesh(x).animNormals)[i] + +proc `[]`*(x: var MeshAnimNormals, i: int): var Vector3 = + checkArrayAccess(Mesh(x).animNormals, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[Vector3]](Mesh(x).animNormals)[i] + +proc `[]=`*(x: var MeshAnimNormals, i: int, val: Vector3) = + checkArrayAccess(Mesh(x).animNormals, i, Mesh(x).vertexCount) + cast[ptr UncheckedArray[Vector3]](Mesh(x).animNormals)[i] = val + +template boneIds*(x: Mesh): MeshBoneIds = MeshBoneIds(x) + +proc `[]`*(x: MeshBoneIds, i: int): array[4, uint8] = + checkArrayAccess(Mesh(x).boneIds, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[typeof(result)]](Mesh(x).boneIds)[i] + +proc `[]`*(x: var MeshBoneIds, i: int): var array[4, uint8] = + checkArrayAccess(Mesh(x).boneIds, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[typeof(result)]](Mesh(x).boneIds)[i] + +proc `[]=`*(x: var MeshBoneIds, i: int, val: array[4, uint8]) = + checkArrayAccess(Mesh(x).boneIds, i, Mesh(x).vertexCount) + cast[ptr UncheckedArray[typeof(val)]](Mesh(x).boneIds)[i] = val + +template boneWeights*(x: Mesh): MeshBoneWeights = MeshBoneWeights(x) + +proc `[]`*(x: MeshBoneWeights, i: int): Vector4 = + checkArrayAccess(Mesh(x).boneWeights, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[Vector4]](Mesh(x).boneWeights)[i] + +proc `[]`*(x: var MeshBoneWeights, i: int): var Vector4 = + checkArrayAccess(Mesh(x).boneWeights, i, Mesh(x).vertexCount) + result = cast[ptr UncheckedArray[Vector4]](Mesh(x).boneWeights)[i] + +proc `[]=`*(x: var MeshBoneWeights, i: int, val: Vector4) = + checkArrayAccess(Mesh(x).boneWeights, i, Mesh(x).vertexCount) + cast[ptr UncheckedArray[Vector4]](Mesh(x).boneWeights)[i] = val + +template vboId*(x: Mesh): MeshVboId = MeshVboId(x) + +proc `[]`*(x: MeshVboId, i: int): uint32 = + checkArrayAccess(Mesh(x).vboId, i, MaxMeshVertexBuffers) + result = Mesh(x).vboId[i] + +proc `[]`*(x: var MeshVboId, i: int): var uint32 = + checkArrayAccess(Mesh(x).vboId, i, MaxMeshVertexBuffers) + result = Mesh(x).vboId[i] + +proc `[]=`*(x: var MeshVboId, i: int, val: uint32) = + checkArrayAccess(Mesh(x).vboId, i, MaxMeshVertexBuffers) + Mesh(x).vboId[i] = val + +template locs*(x: Shader): ShaderLocs = ShaderLocs(x) + +proc `[]`*(x: ShaderLocs, i: ShaderLocationIndex): int32 = + checkArrayAccess(Shader(x).locs, i, MaxShaderLocations) + result = Shader(x).locs[i.int] + +proc `[]`*(x: var ShaderLocs, i: ShaderLocationIndex): var int32 = + checkArrayAccess(Shader(x).locs, i, MaxShaderLocations) + result = Shader(x).locs[i.int] + +proc `[]=`*(x: var ShaderLocs, i: ShaderLocationIndex, val: int32) = + checkArrayAccess(Shader(x).locs, i, MaxShaderLocations) + Shader(x).locs[i.int] = val + +template maps*(x: Material): MaterialMaps = MaterialMaps(x) + +proc `[]`*(x: MaterialMaps, i: MaterialMapIndex): lent MaterialMap = + checkArrayAccess(Material(x).maps, i, MaxMaterialMaps) + result = Material(x).maps[i.int] + +proc `[]`*(x: var MaterialMaps, i: MaterialMapIndex): var MaterialMap = + checkArrayAccess(Material(x).maps, i, MaxMaterialMaps) + result = Material(x).maps[i.int] + +proc `[]=`*(x: var MaterialMaps, i: MaterialMapIndex, val: MaterialMap) = + checkArrayAccess(Material(x).maps, i, MaxMaterialMaps) + Material(x).maps[i.int] = val + +template meshes*(x: Model): ModelMeshes = ModelMeshes(x) + +proc `[]`*(x: ModelMeshes, i: int): lent Mesh = + checkArrayAccess(Model(x).meshes, i, Model(x).meshCount) + result = Model(x).meshes[i] + +proc `[]`*(x: var ModelMeshes, i: int): var Mesh = + checkArrayAccess(Model(x).meshes, i, Model(x).meshCount) + result = Model(x).meshes[i] + +proc `[]=`*(x: var ModelMeshes, i: int, val: Mesh) = + checkArrayAccess(Model(x).meshes, i, Model(x).meshCount) + Model(x).meshes[i] = val + +template materials*(x: Model): ModelMaterials = ModelMaterials(x) + +proc `[]`*(x: ModelMaterials, i: int): lent Material = + checkArrayAccess(Model(x).materials, i, Model(x).materialCount) + result = Model(x).materials[i] + +proc `[]`*(x: var ModelMaterials, i: int): var Material = + checkArrayAccess(Model(x).materials, i, Model(x).materialCount) + result = Model(x).materials[i] + +proc `[]=`*(x: var ModelMaterials, i: int, val: Material) = + checkArrayAccess(Model(x).materials, i, Model(x).materialCount) + Model(x).materials[i] = val + +template meshMaterial*(x: Model): ModelMeshMaterial = ModelMeshMaterial(x) + +proc `[]`*(x: ModelMeshMaterial, i: int): int32 = + checkArrayAccess(Model(x).meshMaterial, i, Model(x).meshCount) + result = Model(x).meshMaterial[i] + +proc `[]`*(x: var ModelMeshMaterial, i: int): var int32 = + checkArrayAccess(Model(x).meshMaterial, i, Model(x).meshCount) + result = Model(x).meshMaterial[i] + +proc `[]=`*(x: var ModelMeshMaterial, i: int, val: int32) = + checkArrayAccess(Model(x).meshMaterial, i, Model(x).meshCount) + Model(x).meshMaterial[i] = val + +template bones*(x: Model): ModelBones = ModelBones(x) + +proc `[]`*(x: ModelBones, i: int): lent BoneInfo = + checkArrayAccess(Model(x).bones, i, Model(x).boneCount) + result = Model(x).bones[i] + +proc `[]`*(x: var ModelBones, i: int): var BoneInfo = + checkArrayAccess(Model(x).bones, i, Model(x).boneCount) + result = Model(x).bones[i] + +proc `[]=`*(x: var ModelBones, i: int, val: BoneInfo) = + checkArrayAccess(Model(x).bones, i, Model(x).boneCount) + Model(x).bones[i] = val + +template bindPose*(x: Model): ModelBindPose = ModelBindPose(x) + +proc `[]`*(x: ModelBindPose, i: int): lent Transform = + checkArrayAccess(Model(x).bindPose, i, Model(x).boneCount) + result = Model(x).bindPose[i] + +proc `[]`*(x: var ModelBindPose, i: int): var Transform = + checkArrayAccess(Model(x).bindPose, i, Model(x).boneCount) + result = Model(x).bindPose[i] + +proc `[]=`*(x: var ModelBindPose, i: int, val: Transform) = + checkArrayAccess(Model(x).bindPose, i, Model(x).boneCount) + Model(x).bindPose[i] = val + +template bones*(x: ModelAnimation): ModelAnimationBones = ModelAnimationBones(x) + +proc `[]`*(x: ModelAnimationBones, i: int): lent BoneInfo = + checkArrayAccess(ModelAnimation(x).bones, i, ModelAnimation(x).boneCount) + result = ModelAnimation(x).bones[i] + +proc `[]`*(x: var ModelAnimationBones, i: int): var BoneInfo = + checkArrayAccess(ModelAnimation(x).bones, i, ModelAnimation(x).boneCount) + result = ModelAnimation(x).bones[i] + +proc `[]=`*(x: var ModelAnimationBones, i: int, val: BoneInfo) = + checkArrayAccess(ModelAnimation(x).bones, i, ModelAnimation(x).boneCount) + ModelAnimation(x).bones[i] = val + +template framePoses*(x: ModelAnimation): ModelAnimationFramePoses = ModelAnimationFramePoses(x) + +proc `[]`*(x: ModelAnimationFramePoses; i, j: int): lent Transform = + checkArrayAccess(ModelAnimation(x).framePoses, i, ModelAnimation(x).frameCount) + checkArrayAccess(ModelAnimation(x).framePoses[i], j, ModelAnimation(x).boneCount) + result = ModelAnimation(x).framePoses[i][j] + +proc `[]`*(x: var ModelAnimationFramePoses; i, j: int): var Transform = + checkArrayAccess(ModelAnimation(x).framePoses, i, ModelAnimation(x).frameCount) + checkArrayAccess(ModelAnimation(x).framePoses[i], j, ModelAnimation(x).boneCount) + result = ModelAnimation(x).framePoses[i][j] + +proc `[]=`*(x: var ModelAnimationFramePoses; i, j: int, val: Transform) = + checkArrayAccess(ModelAnimation(x).framePoses, i, ModelAnimation(x).frameCount) + checkArrayAccess(ModelAnimation(x).framePoses[i], j, ModelAnimation(x).boneCount) + ModelAnimation(x).framePoses[i][j] = val From f4bd707101de8be1fae21e94fa1c45dd5e1d0118 Mon Sep 17 00:00:00 2001 From: Antonis Geralis <43617260+planetis-m@users.noreply.github.com> Date: Thu, 20 Jan 2022 16:57:56 +0200 Subject: [PATCH 13/13] Create raylib_types.nim --- raylib_types.nim | 60 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 raylib_types.nim diff --git a/raylib_types.nim b/raylib_types.nim new file mode 100644 index 0000000..082f66e --- /dev/null +++ b/raylib_types.nim @@ -0,0 +1,60 @@ + +proc `=destroy`*(x: var Image) = + if x.data != nil: unloadImage(x) +proc `=copy`*(dest: var Image; source: Image) = + if dest.data != source.data: + `=destroy`(dest) + wasMoved(dest) + dest = imageCopy(source) + +proc `=destroy`*(x: var Texture) = + if x.id > 0: unloadTexture(x) +proc `=copy`*(dest: var Texture; source: Texture) {.error.} + +proc `=destroy`*(x: var RenderTexture) = + if x.id > 0: unloadRenderTexture(x) +proc `=copy`*(dest: var RenderTexture; source: RenderTexture) {.error.} + +proc `=destroy`*(x: var Font) = + if x.texture.id > 0: unloadFont(x) +proc `=copy`*(dest: var Font; source: Font) {.error.} + +proc `=destroy`*(x: var Mesh) = + if x.vboId != nil: unloadMesh(x) +proc `=copy`*(dest: var Mesh; source: Mesh) {.error.} + +proc `=destroy`*(x: var Shader) = + if x.id > 0: unloadShader(x) +proc `=copy`*(dest: var Shader; source: Shader) {.error.} + +proc `=destroy`*(x: var Material) = + if x.maps != nil: unloadMaterial(x) +proc `=copy`*(dest: var Material; source: Material) {.error.} + +proc `=destroy`*(x: var Model) = + if x.meshes != nil: unloadModel(x) +proc `=copy`*(dest: var Model; source: Model) {.error.} + +proc `=destroy`*(x: var ModelAnimation) = + if x.framePoses != nil: unloadModelAnimation(x) +proc `=copy`*(dest: var ModelAnimation; source: ModelAnimation) {.error.} + +proc `=destroy`*(x: var Wave) = + if x.data != nil: unloadWave(x) +proc `=copy`*(dest: var Wave; source: Wave) = + if dest.data != source.data: + `=destroy`(dest) + wasMoved(dest) + dest = waveCopy(source) + +proc `=destroy`*(x: var AudioStream) = + if x.buffer != nil: unloadAudioStream(x) +proc `=copy`*(dest: var AudioStream; source: AudioStream) {.error.} + +proc `=destroy`*(x: var Sound) = + if x.stream.buffer != nil: unloadSound(x) +proc `=copy`*(dest: var Sound; source: Sound) {.error.} + +proc `=destroy`*(x: var Music) = + if x.stream.buffer != nil: unloadMusicStream(x) +proc `=copy`*(dest: var Music; source: Music) {.error.}