rl

package module

Go to main page

Versions in this module

v0

v0.60.0

May 14, 2026

Changes in this version

+ const Byte

+ const Double

+ const HalfFloat

+ const Int

+ const ShaderLocVertexBoneids

+ const ShaderLocVertexBonetransforms

+ const ShaderLocVertexBoneweights

+ const ShaderLocVertexInstancetransform

+ const Short

+ const UnsignedInt

+ const UnsignedShort

+ func CopyFramebuffer(x, y, width, height, format int32, pixels unsafe.Pointer)

+ func DisablePointMode()

+ func DisableStatePointer(vertexAttribType int32)

+ func DrawEllipseLinesV(center Vector2, radiusH, radiusV float32, col color.RGBA)

+ func DrawEllipseV(center Vector2, radiusH, radiusV float32, col color.RGBA)

+ func DrawLineDashed(startPos, endPos Vector2, dashSize, spaceSize int32, col color.RGBA)

+ func DrawTriangleStrip3D(points []Vector3, col color.RGBA)

+ func DrawVertexArray(offset int32, count int32)

+ func DrawVertexArrayElements(offset int32, count int32, buffer unsafe.Pointer)

+ func DrawVertexArrayElementsInstanced(offset int32, count int32, buffer unsafe.Pointer, instances int32)

+ func DrawVertexArrayInstanced(offset, count, instances int32)

+ func EnableStatePointer(vertexAttribType int32, buffer unsafe.Pointer)

+ func GenMeshTangents(mesh *Mesh)

+ func GetKeyName(key int32) string

+ func GetPixelColor(srcPtr unsafe.Pointer, format int32) color.RGBA

+ func GetPointSize() float32

+ func GetProcAddress(procName string) unsafe.Pointer

+ func GetShaderLocsDefault() []int32

+ func LoadImagePalette(img Image, maxPaletteSize int32) []color.RGBA

+ func LoadShaderId(code string, shaderType int32) uint32

+ func LoadShaderProgramCompute(csId uint32) uint32

+ func LoadShaderProgramEx(vsId, fsId uint32) uint32

+ func LoadVertexBufferElement[T any](buffer []T, dynamic bool) uint32

+ func LoadVertexBuffer[T any](buffer []T, dynamic bool) uint32

+ func ResizeFramebuffer(width, height int32)

+ func SetMain(func())

+ func SetPixelColor(dstPtr unsafe.Pointer, col color.RGBA, format int32)

+ func SetPointSize(size float32)

+ func SetShader(id uint32, locs *int32)

+ func SetVertexAttribute(index uint32, compSize int32, attrType int32, normalized bool, stride int32, ...)

+ func SetVertexAttributeDefault(locIndex int32, value unsafe.Pointer, attribType int32, count int32)

+ func SetVertexAttributes[T any](vertices []T, attributes []VertexAttributesConfig)

+ func SetWindowFocused()

+ func UnloadImagePalette(colors []color.RGBA)

+ func UnloadShaderId(id uint32)

+ func UnloadVertexArray(vaoId uint32)

+ func UpdateModelAnimationEx(model Model, animA ModelAnimation, frameA float32, animB ModelAnimation, ...)

+ func UpdateVertexBufferElements[T any](id uint32, data []T, offset int32)

+ func UpdateVertexBuffer[T any](bufferId uint32, data []T, offset int32)

type Asset

+ func NewAsset(root string) *Asset

+ func NewAssetFromFS(fsys fs.FS, root string) *Asset

+ func (a *Asset) Open(name string) (fs.File, error)

+ func (a *Asset) ReadDir(name string) ([]fs.DirEntry, error)

+ func (a *Asset) ReadFile(name string) ([]byte, error)

+ type AssetFile interface

+ Stat func() (fs.FileInfo, error)

type GlVersion

+ const OpenglEs30

+ const OpenglSoftware

type Mat2

+ func (m Mat2) MultiplyVector2(vector Vector2) Vector2

+ func (m Mat2) Transpose() Mat2

type Matrix

+ func (m Matrix) Add(right Matrix) Matrix

+ func (m Matrix) Decompose(translation *Vector3, rotation *Quaternion, scale *Vector3)

+ func (m Matrix) Determinant() float32

+ func (m Matrix) Invert() Matrix

+ func (m Matrix) Multiply(right Matrix) Matrix

+ func (m Matrix) Normalize() Matrix

+ func (m Matrix) Subtract(right Matrix) Matrix

+ func (m Matrix) ToFloat() []float32

+ func (m Matrix) ToFloatV() [16]float32

+ func (m Matrix) Trace() float32

+ func (m Matrix) Transpose() Matrix

type Mesh

+ BoneIndices *uint8

type Model

+ BoneMatrices *Matrix

+ CurrentPose ModelAnimPose

+ Skeleton ModelSkeleton

+ func (m Model) GetBoneMatrices() []Matrix

+ func (m Model) GetCurrentPose() []Transform

+ type ModelAnimPose = *Transform

type ModelAnimation

+ KeyframeCount int32

+ KeyframePoses *ModelAnimPose

+ type ModelSkeleton struct

+ BindPose ModelAnimPose

+ BoneCount int32

+ Bones *BoneInfo

+ func (m ModelSkeleton) GetBindPose() []Transform

+ func (m ModelSkeleton) GetBones() []BoneInfo

type Quaternion

+ func (q Quaternion) Add(q2 Quaternion) Quaternion

+ func (q Quaternion) AddValue(add float32) Quaternion

+ func (q Quaternion) Divide(q2 Quaternion) Quaternion

+ func (q Quaternion) Equals(p Quaternion) bool

+ func (q Quaternion) Invert() Quaternion

+ func (q Quaternion) Length() float32

+ func (q Quaternion) Lerp(q2 Quaternion, amount float32) Quaternion

+ func (q Quaternion) Multiply(q2 Quaternion) Quaternion

+ func (q Quaternion) Nlerp(q2 Quaternion, amount float32) Quaternion

+ func (q Quaternion) Normalize() Quaternion

+ func (q Quaternion) Scale(mul float32) Quaternion

+ func (q Quaternion) Slerp(q2 Quaternion, amount float32) Quaternion

+ func (q Quaternion) Subtract(q2 Quaternion) Quaternion

+ func (q Quaternion) SubtractValue(sub float32) Quaternion

+ func (q Quaternion) ToAxisAngle(outAxis *Vector3, outAngle *float32)

+ func (q Quaternion) ToEuler() Vector3

+ func (q Quaternion) ToMatrix() Matrix

+ func (q Quaternion) Transform(mat Matrix) Quaternion

type Rectangle

+ func GetImageAlphaBorder(image Image, threshold float32) Rectangle

type RenderBatch

+ CurrentDepth float32

type Vector2

+ func MeasureTextCodepoints(font Font, codepoints []rune, fontSize float32, spacing float32) Vector2

+ func (v Vector2) Add(v2 Vector2) Vector2

+ func (v Vector2) AddValue(add float32) Vector2

+ func (v Vector2) Angle(v2 Vector2) float32

+ func (v Vector2) Clamp(min Vector2, max Vector2) Vector2

+ func (v Vector2) ClampValue(min float32, max float32) Vector2

+ func (v Vector2) CrossProduct(v2 Vector2) float32

+ func (v Vector2) Distance(v2 Vector2) float32

+ func (v Vector2) DistanceSqr(v2 Vector2) float32

+ func (v Vector2) Divide(v2 Vector2) Vector2

+ func (v Vector2) DotProduct(v2 Vector2) float32

+ func (v Vector2) Equals(q Vector2) bool

+ func (v Vector2) Invert() Vector2

+ func (v Vector2) Length() float32

+ func (v Vector2) LengthSqr() float32

+ func (v Vector2) Lerp(v2 Vector2, amount float32) Vector2

+ func (v Vector2) LineAngle(end Vector2) float32

+ func (v Vector2) MoveTowards(target Vector2, maxDistance float32) Vector2

+ func (v Vector2) Multiply(v2 Vector2) Vector2

+ func (v Vector2) Negate() Vector2

+ func (v Vector2) Normalize() Vector2

+ func (v Vector2) Reflect(normal Vector2) Vector2

+ func (v Vector2) Rotate(angle float32) Vector2

+ func (v Vector2) Scale(scale float32) Vector2

+ func (v Vector2) Subtract(v2 Vector2) Vector2

+ func (v Vector2) SubtractValue(sub float32) Vector2

+ func (v Vector2) Transform(mat Matrix) Vector2

type Vector3

+ func (v Vector3) Add(v2 Vector3) Vector3

+ func (v Vector3) AddValue(add float32) Vector3

+ func (v Vector3) Angle(v2 Vector3) float32

+ func (v Vector3) Barycenter(a, b, c Vector3) Vector3

+ func (v Vector3) Clamp(min Vector3, max Vector3) Vector3

+ func (v Vector3) ClampValue(min float32, max float32) Vector3

+ func (v Vector3) CrossProduct(v2 Vector3) Vector3

+ func (v Vector3) Distance(v2 Vector3) float32

+ func (v Vector3) DistanceSqr(v2 Vector3) float32

+ func (v Vector3) Divide(v2 Vector3) Vector3

+ func (v Vector3) DotProduct(v2 Vector3) float32

+ func (v Vector3) Equals(q Vector3) bool

+ func (v Vector3) Invert() Vector3

+ func (v Vector3) Length() float32

+ func (v Vector3) LengthSqr() float32

+ func (v Vector3) Lerp(v2 Vector3, amount float32) Vector3

+ func (v Vector3) Max(vec2 Vector3) Vector3

+ func (v Vector3) Min(vec2 Vector3) Vector3

+ func (v Vector3) Multiply(v2 Vector3) Vector3

+ func (v Vector3) Negate() Vector3

+ func (v Vector3) Normalize() Vector3

+ func (v Vector3) Perpendicular() Vector3

+ func (v Vector3) Project(v2 Vector3) Vector3

+ func (v Vector3) Reflect(normal Vector3) Vector3

+ func (v Vector3) Refract(n Vector3, r float32) Vector3

+ func (v Vector3) Reject(v2 Vector3) Vector3

+ func (v Vector3) RotateByAxisAngle(axis Vector3, angle float32) Vector3

+ func (v Vector3) RotateByQuaternion(q Quaternion) Vector3

+ func (v Vector3) Scale(scale float32) Vector3

+ func (v Vector3) Subtract(v2 Vector3) Vector3

+ func (v Vector3) SubtractValue(sub float32) Vector3

+ func (v Vector3) ToFloat() []float32

+ func (v Vector3) ToFloatV() [3]float32

+ func (v Vector3) Transform(mat Matrix) Vector3

+ func (v Vector3) Unproject(projection Matrix, view Matrix) Vector3

+ type VertexAttributesConfig struct

+ Attribute uint32

+ Field string

+ Normalized bool

v0.56.0-dev

Aug 7, 2025

v0.55.1

May 21, 2025

Changes in this version

+ const BlendColor

+ const BlendDstAlpha

+ const BlendDstRgb

+ const BlendEquation

+ const BlendEquationAlpha

+ const BlendEquationRgb

+ const BlendSrcAlpha

+ const BlendSrcRgb

+ const ConstantAlpha

+ const ConstantColor

+ const DrawFramebuffer

+ const DstAlpha

+ const DstColor

+ const FuncAdd

+ const FuncReverseSubtract

+ const FuncSubtract

+ const Max

+ const Min

+ const One

+ const OneMinusConstantAlpha

+ const OneMinusConstantColor

+ const OneMinusDstAlpha

+ const OneMinusDstColor

+ const OneMinusSrcAlpha

+ const OneMinusSrcColor

+ const ReadFramebuffer

+ const SrcAlpha

+ const SrcAlphaSaturate

+ const SrcColor

+ const Zero

+ func UnloadSoundAlias(sound Sound)

type ModelAnimation

+ func (m ModelAnimation) GetBones() []BoneInfo

+ func (m ModelAnimation) GetFramePose(frame, bone int) Transform

+ func (m ModelAnimation) GetName() string

type Wave

+ Data unsafe.Pointer

v0.55.0

Dec 2, 2024

Changes in this version

+ const FlagBorderlessWindowedMode

+ func AttachAudioMixedProcessor(callback AudioCallback)

+ func BeginVrStereoMode(config VrStereoConfig)

+ func BindFramebuffer(target, framebuffer uint32)

+ func BindShaderBuffer(id uint32, index uint32)

+ func BlitFramebuffer(...)

+ func CheckCollisionCircleLine(center Vector2, radius float32, p1, p2 Vector2) bool

+ func ColorLerp(col1, col2 color.RGBA, factor float32) color.RGBA

+ func ColorMask(r, g, b, a bool)

+ func CopyShaderBuffer(destId uint32, srcId uint32, destOffset uint32, srcOffset uint32, count uint32)

+ func DetachAudioMixedProcessor(callback AudioCallback)

+ func DrawCircleLinesV(center Vector2, radius float32, col color.RGBA)

+ func DrawModelPoints(model Model, position Vector3, scale float32, tint color.RGBA)

+ func DrawModelPointsEx(model Model, position Vector3, rotationAxis Vector3, rotationAngle float32, ...)

+ func DrawRectangleRoundedLinesEx(rec Rectangle, roundness float32, segments int32, lineThick float32, ...)

+ func DrawRenderBatch(batch *RenderBatch)

+ func DrawTextCodepoint(font Font, codepoint rune, position Vector2, fontSize float32, tint color.RGBA)

+ func DrawTextCodepoints(font Font, codepoints []rune, position Vector2, fontSize float32, ...)

+ func DrawTextPro(font Font, text string, position Vector2, origin Vector2, ...)

+ func DrawTriangle3D(v1 Vector3, v2 Vector3, v3 Vector3, col color.RGBA)

+ func EndVrStereoMode()

+ func GetActiveFramebuffer() uint32

+ func GetCullDistanceFar() float64

+ func GetCullDistanceNear() float64

+ func GlClose()

+ func GlInit(width int32, height int32)

+ func ImageDrawLineEx(dst *Image, start, end Vector2, thick int32, col color.RGBA)

+ func ImageDrawTriangle(dst *Image, v1, v2, v3 Vector2, col color.RGBA)

+ func ImageDrawTriangleEx(dst *Image, v1, v2, v3 Vector2, c1, c2, c3 color.RGBA)

+ func ImageDrawTriangleFan(dst *Image, points []Vector2, col color.RGBA)

+ func ImageDrawTriangleLines(dst *Image, v1, v2, v3 Vector2, col color.RGBA)

+ func ImageDrawTriangleStrip(dst *Image, points []Vector2, col color.RGBA)

+ func ImageKernelConvolution(image *Image, kernel []float32)

+ func IsAudioStreamValid(stream AudioStream) bool

+ func IsFontValid(font Font) bool

+ func IsImageValid(image *Image) bool

+ func IsMaterialValid(material Material) bool

+ func IsModelValid(model Model) bool

+ func IsMusicValid(music Music) bool

+ func IsRenderTextureValid(target RenderTexture2D) bool

+ func IsShaderValid(shader Shader) bool

+ func IsSoundValid(sound Sound) bool

+ func IsTextureValid(texture Texture2D) bool

+ func IsWaveValid(wave Wave) bool

+ func LoadComputeShaderProgram(shaderID uint32) uint32

+ func LoadShaderBuffer(size uint32, data unsafe.Pointer, usageHint int32) uint32

+ func MatrixDecompose(mat Matrix, translation *Vector3, rotation *Quaternion, scale *Vector3)

+ func MultMatrix(m Matrix)

+ func PollInputEvents()

+ func ReadShaderBuffer(id uint32, dest unsafe.Pointer, count uint32, offset uint32)

+ func SetClipPlanes(nearPlane, farPlane float64)

+ func SetGamepadVibration(gamepad int32, leftMotor, rightMotor, duration float32)

+ func SetRenderBatchActive(batch *RenderBatch)

+ func SetUniform(locIndex int32, value []float32, uniformType int32)

+ func SetUniformMatrices(locIndex int32, mat []Matrix)

+ func SetUniformMatrix(locIndex int32, mat Matrix)

+ func SwapScreenBuffer()

+ func ToggleBorderlessWindowed()

+ func UnloadRenderBatch(batch RenderBatch)

+ func UnloadShaderBuffer(id uint32)

+ func UnloadVrStereoConfig(config VrStereoConfig)

+ func UpdateModelAnimationBones(model Model, anim ModelAnimation, frame int32)

+ func UpdateShaderBuffer(id uint32, data unsafe.Pointer, dataSize uint32, offset uint32)

+ func WaitTime(seconds float64)

type AutomationEventList

+ func (a *AutomationEventList) GetEvents() []AutomationEvent

+ type DrawCall struct

+ Mode int32

+ TextureId uint32

+ VertexAlignment int32

+ VertexCount int32

+ type FramebufferAttachTextureType = int32

+ type FramebufferAttachType = int32

+ type GlVersion = int32

type Image

+ Data unsafe.Pointer

+ func GenImageFontAtlas(glyphs []GlyphInfo, glyphRecs []*Rectangle, fontSize int32, padding int32, ...) Image

+ func GetClipboardImage() Image

+ func ImageFromChannel(image Image, selectedChannel int32) Image

+ func ImageFromImage(image Image, rec Rectangle) Image

+ func LoadImageAnimFromMemory(fileType string, fileData []byte, dataSize int32, frames *int32) *Image

type Mesh

+ BoneCount int32

+ BoneMatrices *Matrix

+ type MouseButton int32

type Ray

+ func GetScreenToWorldRay(position Vector2, camera Camera) Ray

+ func GetScreenToWorldRayEx(position Vector2, camera Camera, width, height int32) Ray

type Rectangle

+ func GetShapesTextureRectangle() Rectangle

+ type RenderBatch struct

+ BufferCount int32

+ CurrentBuffer int32

+ DrawCounter int32

+ Draws *DrawCall

+ DurrentDepth float32

+ VertexBuffer *VertexBuffer

+ func LoadRenderBatch(numBuffers int32, bufferElements int32) RenderBatch

+ type ShaderAttributeDataType = int32

type ShaderUniformDataType

+ const ShaderUniformUint

+ const ShaderUniformUivec2

+ const ShaderUniformUivec3

+ const ShaderUniformUivec4

type Texture2D

+ func GetShapesTexture() Texture2D

+ func LoadTextureCubemap(image *Image, layout int32) Texture2D

+ type VertexBuffer struct

+ Colors *uint8

+ ElementCount int32

+ Indices *uint32

+ Normals *float32

+ Texcoords *float32

+ VaoId uint32

+ VboId [5]uint32

+ Vertices *float32

type VrStereoConfig

+ func LoadVrStereoConfig(device VrDeviceInfo) VrStereoConfig

v0.50.0

Nov 18, 2023

Changes in this version

+ const AttachmentColorChannel0

+ const AttachmentColorChannel1

+ const AttachmentColorChannel2

+ const AttachmentColorChannel3

+ const AttachmentColorChannel4

+ const AttachmentColorChannel5

+ const AttachmentColorChannel6

+ const AttachmentColorChannel7

+ const AttachmentCubemapNegativeX

+ const AttachmentCubemapNegativeY

+ const AttachmentCubemapNegativeZ

+ const AttachmentCubemapPositiveX

+ const AttachmentCubemapPositiveY

+ const AttachmentCubemapPositiveZ

+ const AttachmentDepth

+ const AttachmentRenderbuffer

+ const AttachmentStencil

+ const AttachmentTexture2d

+ const ComputeShader

+ const CubemapLayoutAutoDetect

+ const CubemapLayoutCrossFourByThree

+ const CubemapLayoutCrossThreeByFour

+ const CubemapLayoutLineHorizontal

+ const CubemapLayoutLineVertical

+ const CubemapLayoutPanorama

+ const DynamicCopy

+ const DynamicDraw

+ const DynamicRead

+ const Float

+ const FontBitmap

+ const FontDefault

+ const FontSdf

+ const FragmentShader

+ const GamepadAxisLeftTrigger

+ const GamepadAxisLeftX

+ const GamepadAxisLeftY

+ const GamepadAxisRightTrigger

+ const GamepadAxisRightX

+ const GamepadAxisRightY

+ const GamepadButtonLeftFaceDown

+ const GamepadButtonLeftFaceLeft

+ const GamepadButtonLeftFaceRight

+ const GamepadButtonLeftFaceUp

+ const GamepadButtonLeftThumb

+ const GamepadButtonLeftTrigger1

+ const GamepadButtonLeftTrigger2

+ const GamepadButtonMiddle

+ const GamepadButtonMiddleLeft

+ const GamepadButtonMiddleRight

+ const GamepadButtonRightFaceDown

+ const GamepadButtonRightFaceLeft

+ const GamepadButtonRightFaceRight

+ const GamepadButtonRightFaceUp

+ const GamepadButtonRightThumb

+ const GamepadButtonRightTrigger1

+ const GamepadButtonRightTrigger2

+ const GamepadButtonUnknown

+ const KeyNull

+ const Lines

+ const MapBrdf

+ const Modelview

+ const MouseButtonBack

+ const MouseButtonExtra

+ const MouseButtonForward

+ const MouseButtonLeft

+ const MouseButtonMiddle

+ const MouseButtonRight

+ const MouseButtonSide

+ const Opengl11

+ const Opengl21

+ const Opengl33

+ const Opengl43

+ const OpenglEs20

+ const Projection

+ const Quads

+ const ShaderAttribFloat

+ const ShaderAttribVec2

+ const ShaderAttribVec3

+ const ShaderAttribVec4

+ const ShaderLocColorAmbient

+ const ShaderLocColorDiffuse

+ const ShaderLocColorSpecular

+ const ShaderLocMapAlbedo

+ const ShaderLocMapBrdf

+ const ShaderLocMapCubemap

+ const ShaderLocMapDiffuse

+ const ShaderLocMapEmission

+ const ShaderLocMapHeight

+ const ShaderLocMapIrradiance

+ const ShaderLocMapMetalness

+ const ShaderLocMapNormal

+ const ShaderLocMapOcclusion

+ const ShaderLocMapPrefilter

+ const ShaderLocMapRoughness

+ const ShaderLocMapSpecular

+ const ShaderLocMatrixModel

+ const ShaderLocMatrixMvp

+ const ShaderLocMatrixNormal

+ const ShaderLocMatrixProjection

+ const ShaderLocMatrixView

+ const ShaderLocVectorView

+ const ShaderLocVertexColor

+ const ShaderLocVertexNormal

+ const ShaderLocVertexPosition

+ const ShaderLocVertexTangent

+ const ShaderLocVertexTexcoord01

+ const ShaderLocVertexTexcoord02

+ const StaticCopy

+ const StaticDraw

+ const StaticRead

+ const StreamCopy

+ const StreamDraw

+ const StreamRead

+ const Texture

+ const TextureFilterAnisotropic

+ const TextureFilterLinear

+ const TextureFilterLinearMipNearest

+ const TextureFilterMipLinear

+ const TextureFilterMipNearest

+ const TextureFilterNearest

+ const TextureFilterNearestMipLinear

+ const TextureMagFilter

+ const TextureMinFilter

+ const TextureMipmapBiasRatio

+ const TextureWrapClamp

+ const TextureWrapMirrorClamp

+ const TextureWrapMirrorRepeat

+ const TextureWrapRepeat

+ const TextureWrapS

+ const TextureWrapT

+ const Triangles

+ const UnsignedByte

+ const VertexShader

+ func CameraMoveForward(camera *Camera, distance float32, moveInWorldPlane uint8)

+ func CameraMoveRight(camera *Camera, distance float32, moveInWorldPlane uint8)

+ func CameraMoveToTarget(camera *Camera, delta float32)

+ func CameraMoveUp(camera *Camera, distance float32)

+ func CameraPitch(camera *Camera, angle float32, lockView uint8, rotateAroundTarget uint8, ...)

+ func CameraRoll(camera *Camera, angle float32)

+ func CameraYaw(camera *Camera, angle float32, rotateAroundTarget uint8)

+ func CubemapParameters(id uint32, param int32, value int32)

+ func DrawBillboardPro(camera Camera, texture Texture2D, sourceRec Rectangle, position Vector3, ...)

+ func DrawRenderBatchActive()

+ func DrawSplineBasis(points []Vector2, thick float32, col color.RGBA)

+ func DrawSplineBezierCubic(points []Vector2, thick float32, col color.RGBA)

+ func DrawSplineBezierQuadratic(points []Vector2, thick float32, col color.RGBA)

+ func DrawSplineCatmullRom(points []Vector2, thick float32, col color.RGBA)

+ func DrawSplineLinear(points []Vector2, thick float32, col color.RGBA)

+ func DrawSplineSegmentBasis(p1, p2, p3, p4 Vector2, thick float32, col color.RGBA)

+ func DrawSplineSegmentBezierCubic(p1, p2, p3, p4 Vector2, thick float32, col color.RGBA)

+ func DrawSplineSegmentBezierQuadratic(p1, p2, p3 Vector2, thick float32, col color.RGBA)

+ func DrawSplineSegmentCatmullRom(p1, p2, p3, p4 Vector2, thick float32, col color.RGBA)

+ func DrawSplineSegmentLinear(p1, p2 Vector2, thick float32, col color.RGBA)

+ func EnablePointMode()

+ func ExportAutomationEventList(list AutomationEventList, fileName string) bool

+ func ExportImageToMemory(image Image, fileType string) []byte

+ func FloatEquals(x, y float32) bool

+ func Frustum(left float64, right float64, bottom float64, top float64, znear float64, ...)

+ func GetMasterVolume() float32

+ func ImageRotate(image *Image, degrees int32)

+ func IsKeyPressedRepeat(key int32) bool

+ func Lerp(start, end, amount float32) float32

+ func LoadTextureDepth(width, height int32, useRenderBuffer bool)

+ func MatrixToFloatV(mat Matrix) [16]float32

+ func Normalize(value, start, end float32) float32

+ func PlayAutomationEvent(event AutomationEvent)

+ func QuaternionEquals(p, q Quaternion) bool

+ func Remap(value, inputStart, inputEnd, outputStart, outputEnd float32) float32

+ func SetAudioStreamCallback(stream AudioStream, callback AudioCallback)

+ func SetAutomationEventBaseFrame(frame int)

+ func SetAutomationEventList(list *AutomationEventList)

+ func SetCullFace(mode int32)

+ func SetTextLineSpacing(spacing int)

+ func SetTraceLogLevel(logLevel TraceLogLevel)

+ func SetWindowMaxSize(w, h int)

+ func StartAutomationEventRecording()

+ func StopAutomationEventRecording()

+ func UnloadAutomationEventList(list *AutomationEventList)

+ func UnloadFontData(glyphs []GlyphInfo)

+ func UnloadImageColors(cols []color.RGBA)

+ func UpdateMeshBuffer(mesh Mesh, index int, data []byte, offset int)

+ func Vector2DistanceSqr(v1 Vector2, v2 Vector2) float32

+ func Vector2Equals(p Vector2, q Vector2) bool

+ func Vector2LengthSqr(v Vector2) float32

+ func Vector2LineAngle(start Vector2, end Vector2) float32

+ func Vector3Angle(v1 Vector3, v2 Vector3) float32

+ func Vector3DistanceSqr(v1 Vector3, v2 Vector3) float32

+ func Vector3Equals(p Vector3, q Vector3) bool

+ func Vector3LengthSqr(v Vector3) float32

+ func Vector3OrthoNormalize(v1, v2 *Vector3)

+ func Vector3ToFloatV(v Vector3) [3]float32

+ func Wrap(value, min, max float32) float32

+ type AudioBuffer struct

+ Callback *[0]byte

+ Converter maDataConverter

+ Data *uint8

+ FrameCursorPos uint32

+ FramesProcessed uint32

+ IsSubBufferProcessed [2]bool

+ Looping bool

+ Next *AudioBuffer

+ Pan float32

+ Paused bool

+ Pitch float32

+ Playing bool

+ Prev *AudioBuffer

+ Processor *AudioProcessor

+ SizeInFrames uint32

+ Usage int32

+ Volume float32

+ type AudioCallback func(data []float32, frames int)

+ type AudioProcessor struct

+ Next *AudioProcessor

+ Prev *AudioProcessor

+ Process *[0]byte

+ type AutomationEvent struct

+ Frame uint32

+ Params [4]int32

+ Type uint32

+ type AutomationEventList struct

+ Capacity uint32

+ Count uint32

+ Events *AutomationEvent

+ func LoadAutomationEventList(fileName string) AutomationEventList

type Image

+ func GenImageGradientLinear(width, height, direction int, start, end color.RGBA) *Image

+ func GenImageGradientSquare(width, height int, density float32, inner, outer color.RGBA) *Image

+ func LoadImageSvg(fileNameOrString string, width, height int32) *Image

type Matrix

+ func GetCameraProjectionMatrix(camera *Camera, aspect float32) Matrix

+ func GetCameraViewMatrix(camera *Camera) Matrix

+ func MatrixRotateZYX(angle Vector3) Matrix

type Model

+ func (m Model) GetBindPose() []Transform

+ func (m Model) GetBones() []BoneInfo

+ func (m Model) GetMaterials() []Material

+ func (m Model) GetMeshes() []Mesh

type ModelAnimation

+ Name [32]int8

type Quaternion

+ func QuaternionAdd(q1 Quaternion, q2 Quaternion) Quaternion

+ func QuaternionAddValue(q Quaternion, add float32) Quaternion

+ func QuaternionDivide(q1 Quaternion, q2 Quaternion) Quaternion

+ func QuaternionFromEuler(pitch, yaw, roll float32) Quaternion

+ func QuaternionFromVector3ToVector3(from Vector3, to Vector3) Quaternion

+ func QuaternionIdentity() Quaternion

+ func QuaternionLerp(q1 Quaternion, q2 Quaternion, amount float32) Quaternion

+ func QuaternionNlerp(q1 Quaternion, q2 Quaternion, amount float32) Quaternion

+ func QuaternionScale(q Quaternion, mul float32) Quaternion

+ func QuaternionSubtract(q1 Quaternion, q2 Quaternion) Quaternion

+ func QuaternionSubtractValue(q Quaternion, sub float32) Quaternion

type Sound

+ func LoadSoundAlias(source Sound) Sound

type Vector2

+ func GetSplinePointBasis(p1, p2, p3, p4 Vector2, t float32) Vector2

+ func GetSplinePointBezierCubic(p1, p2, p3, p4 Vector2, t float32) Vector2

+ func GetSplinePointBezierQuad(p1, p2, p3 Vector2, t float32) Vector2

+ func GetSplinePointCatmullRom(p1, p2, p3, p4 Vector2, t float32) Vector2

+ func GetSplinePointLinear(p1, p2 Vector2, t float32) Vector2

+ func Vector2AddValue(v Vector2, add float32) Vector2

+ func Vector2Clamp(v Vector2, min Vector2, max Vector2) Vector2

+ func Vector2ClampValue(v Vector2, min float32, max float32) Vector2

+ func Vector2Divide(v1, v2 Vector2) Vector2

+ func Vector2Invert(v Vector2) Vector2

+ func Vector2MoveTowards(v Vector2, target Vector2, maxDistance float32) Vector2

+ func Vector2Reflect(v Vector2, normal Vector2) Vector2

+ func Vector2Rotate(v Vector2, angle float32) Vector2

+ func Vector2SubtractValue(v Vector2, sub float32) Vector2

+ func Vector2Transform(v Vector2, mat Matrix) Vector2

type Vector3

+ func GetCameraForward(camera *Camera) Vector3

+ func GetCameraRight(camera *Camera) Vector3

+ func GetCameraUp(camera *Camera) Vector3

+ func QuaternionToEuler(q Quaternion) Vector3

+ func Vector3AddValue(v Vector3, add float32) Vector3

+ func Vector3Clamp(v Vector3, min Vector3, max Vector3) Vector3

+ func Vector3ClampValue(v Vector3, min float32, max float32) Vector3

+ func Vector3Divide(v1 Vector3, v2 Vector3) Vector3

+ func Vector3Invert(v Vector3) Vector3

+ func Vector3Project(v1, v2 Vector3) Vector3

+ func Vector3Refract(v Vector3, n Vector3, r float32) Vector3

+ func Vector3Reject(v1, v2 Vector3) Vector3

+ func Vector3RotateByAxisAngle(v Vector3, axis Vector3, angle float32) Vector3

+ func Vector3RotateByQuaternion(v Vector3, q Quaternion) Vector3

+ func Vector3SubtractValue(v Vector3, sub float32) Vector3

+ func Vector3Unproject(source Vector3, projection Matrix, view Matrix) Vector3

+ type VrDeviceInfo struct

+ ChromaAbCorrection [4]float32

+ EyeToScreenDistance float32

+ HResolution int32

+ HScreenSize float32

+ InterpupillaryDistance float32

+ LensDistortionValues [4]float32

+ LensSeparationDistance float32

+ VResolution int32

+ VScreenCenter float32

+ VScreenSize float32

+ type VrStereoConfig struct

+ LeftLensCenter [2]float32

+ LeftScreenCenter [2]float32

+ Projection [2]Matrix

+ RightLensCenter [2]float32

+ RightScreenCenter [2]float32

+ Scale [2]float32

+ ScaleIn [2]float32

+ ViewOffset [2]Matrix

v0.45.0

May 11, 2023

Changes in this version

+ const MouseBackButton

+ const MouseExtraButton

+ const MouseForwardButton

+ const MouseSideButton

+ const RL_ATTACHMENT_COLOR_CHANNEL0

+ const RL_ATTACHMENT_COLOR_CHANNEL1

+ const RL_ATTACHMENT_COLOR_CHANNEL2

+ const RL_ATTACHMENT_COLOR_CHANNEL3

+ const RL_ATTACHMENT_COLOR_CHANNEL4

+ const RL_ATTACHMENT_COLOR_CHANNEL5

+ const RL_ATTACHMENT_COLOR_CHANNEL6

+ const RL_ATTACHMENT_COLOR_CHANNEL7

+ const RL_ATTACHMENT_CUBEMAP_NEGATIVE_X

+ const RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y

+ const RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z

+ const RL_ATTACHMENT_CUBEMAP_POSITIVE_X

+ const RL_ATTACHMENT_CUBEMAP_POSITIVE_Y

+ const RL_ATTACHMENT_CUBEMAP_POSITIVE_Z

+ const RL_ATTACHMENT_DEPTH

+ const RL_ATTACHMENT_RENDERBUFFER

+ const RL_ATTACHMENT_STENCIL

+ const RL_ATTACHMENT_TEXTURE2D

+ const RL_BLEND_ADDITIVE

+ const RL_BLEND_ADD_COLORS

+ const RL_BLEND_ALPHA

+ const RL_BLEND_ALPHA_PREMULTIPLY

+ const RL_BLEND_CUSTOM

+ const RL_BLEND_CUSTOM_SEPARATE

+ const RL_BLEND_MULTIPLIED

+ const RL_BLEND_SUBTRACT_COLORS

+ const RL_COMPUTE_SHADER

+ const RL_DYNAMIC_COPY

+ const RL_DYNAMIC_DRAW

+ const RL_DYNAMIC_READ

+ const RL_FLOAT

+ const RL_FRAGMENT_SHADER

+ const RL_LINES

+ const RL_LOG_ALL

+ const RL_LOG_DEBUG

+ const RL_LOG_ERROR

+ const RL_LOG_FATAL

+ const RL_LOG_INFO

+ const RL_LOG_NONE

+ const RL_LOG_TRACE

+ const RL_LOG_WARNING

+ const RL_MODELVIEW

+ const RL_OPENGL_11

+ const RL_OPENGL_21

+ const RL_OPENGL_33

+ const RL_OPENGL_43

+ const RL_OPENGL_ES_20

+ const RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA

+ const RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA

+ const RL_PIXELFORMAT_COMPRESSED_DXT1_RGB

+ const RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA

+ const RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA

+ const RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA

+ const RL_PIXELFORMAT_COMPRESSED_ETC1_RGB

+ const RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA

+ const RL_PIXELFORMAT_COMPRESSED_ETC2_RGB

+ const RL_PIXELFORMAT_COMPRESSED_PVRT_RGB

+ const RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA

+ const RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE

+ const RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA

+ const RL_PIXELFORMAT_UNCOMPRESSED_R32

+ const RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32

+ const RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32

+ const RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4

+ const RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1

+ const RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5

+ const RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8

+ const RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8

+ const RL_PROJECTION

+ const RL_QUADS

+ const RL_SHADER_ATTRIB_FLOAT

+ const RL_SHADER_ATTRIB_VEC2

+ const RL_SHADER_ATTRIB_VEC3

+ const RL_SHADER_ATTRIB_VEC4

+ const RL_SHADER_LOC_COLOR_AMBIENT

+ const RL_SHADER_LOC_COLOR_DIFFUSE

+ const RL_SHADER_LOC_COLOR_SPECULAR

+ const RL_SHADER_LOC_MAP_ALBEDO

+ const RL_SHADER_LOC_MAP_BRDF

+ const RL_SHADER_LOC_MAP_CUBEMAP

+ const RL_SHADER_LOC_MAP_EMISSION

+ const RL_SHADER_LOC_MAP_HEIGHT

+ const RL_SHADER_LOC_MAP_IRRADIANCE

+ const RL_SHADER_LOC_MAP_METALNESS

+ const RL_SHADER_LOC_MAP_NORMAL

+ const RL_SHADER_LOC_MAP_OCCLUSION

+ const RL_SHADER_LOC_MAP_PREFILTER

+ const RL_SHADER_LOC_MAP_ROUGHNESS

+ const RL_SHADER_LOC_MATRIX_MODEL

+ const RL_SHADER_LOC_MATRIX_MVP

+ const RL_SHADER_LOC_MATRIX_NORMAL

+ const RL_SHADER_LOC_MATRIX_PROJECTION

+ const RL_SHADER_LOC_MATRIX_VIEW

+ const RL_SHADER_LOC_VECTOR_VIEW

+ const RL_SHADER_LOC_VERTEX_COLOR

+ const RL_SHADER_LOC_VERTEX_NORMAL

+ const RL_SHADER_LOC_VERTEX_POSITION

+ const RL_SHADER_LOC_VERTEX_TANGENT

+ const RL_SHADER_LOC_VERTEX_TEXCOORD01

+ const RL_SHADER_LOC_VERTEX_TEXCOORD02

+ const RL_SHADER_UNIFORM_FLOAT

+ const RL_SHADER_UNIFORM_INT

+ const RL_SHADER_UNIFORM_IVEC2

+ const RL_SHADER_UNIFORM_IVEC3

+ const RL_SHADER_UNIFORM_IVEC4

+ const RL_SHADER_UNIFORM_SAMPLER2D

+ const RL_SHADER_UNIFORM_VEC2

+ const RL_SHADER_UNIFORM_VEC3

+ const RL_SHADER_UNIFORM_VEC4

+ const RL_STATIC_COPY

+ const RL_STATIC_DRAW

+ const RL_STATIC_READ

+ const RL_STREAM_COPY

+ const RL_STREAM_DRAW

+ const RL_STREAM_READ

+ const RL_TEXTURE

+ const RL_TEXTURE_FILTER_ANISOTROPIC

+ const RL_TEXTURE_FILTER_ANISOTROPIC_16X

+ const RL_TEXTURE_FILTER_ANISOTROPIC_4X

+ const RL_TEXTURE_FILTER_ANISOTROPIC_8X

+ const RL_TEXTURE_FILTER_BILINEAR

+ const RL_TEXTURE_FILTER_LINEAR

+ const RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST

+ const RL_TEXTURE_FILTER_MIP_LINEAR

+ const RL_TEXTURE_FILTER_MIP_NEAREST

+ const RL_TEXTURE_FILTER_NEAREST

+ const RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR

+ const RL_TEXTURE_FILTER_POINT

+ const RL_TEXTURE_FILTER_TRILINEAR

+ const RL_TEXTURE_MAG_FILTER

+ const RL_TEXTURE_MIN_FILTER

+ const RL_TEXTURE_MIPMAP_BIAS_RATIO

+ const RL_TEXTURE_WRAP_CLAMP

+ const RL_TEXTURE_WRAP_MIRROR_CLAMP

+ const RL_TEXTURE_WRAP_MIRROR_REPEAT

+ const RL_TEXTURE_WRAP_REPEAT

+ const RL_TEXTURE_WRAP_S

+ const RL_TEXTURE_WRAP_T

+ const RL_TRIANGLES

+ const RL_UNSIGNED_BYTE

+ const RL_VERTEX_SHADER

+ func ActiveDrawBuffers(count int32)

+ func ActiveTextureSlot(slot int32)

+ func Begin(mode int32)

+ func BindImageTexture(id uint32, index uint32, format int32, readonly bool)

+ func CheckCollisionPointPoly(point Vector2, points []Vector2, pointCount int32) bool

+ func CheckErrors()

+ func CheckRenderBatchLimit(vCount int32) bool

+ func ClearColor(r uint8, g uint8, b uint8, a uint8)

+ func ClearScreenBuffers()

+ func Color3f(x float32, y float32, z float32)

+ func Color4f(x float32, y float32, z float32, w float32)

+ func Color4ub(r uint8, g uint8, b uint8, a uint8)

+ func ColorBrightness(col color.RGBA, factor float32) color.RGBA

+ func ColorContrast(col color.RGBA, contrast float32) color.RGBA

+ func ColorTint(col color.RGBA, tint color.RGBA) color.RGBA

+ func CompileShader(shaderCode string, type_ int32) uint32

+ func ComputeShaderDispatch(groupX uint32, groupY uint32, groupZ uint32)

+ func DisableBackfaceCulling()

+ func DisableColorBlend()

+ func DisableDepthMask()

+ func DisableDepthTest()

+ func DisableFramebuffer()

+ func DisableScissorTest()

+ func DisableShader()

+ func DisableSmoothLines()

+ func DisableStereoRender()

+ func DisableTexture()

+ func DisableTextureCubemap()

+ func DisableVertexArray()

+ func DisableVertexAttribute(index uint32)

+ func DisableVertexBuffer()

+ func DisableVertexBufferElement()

+ func DisableWireMode()

+ func DrawCapsule(startPos, endPos Vector3, radius float32, slices, rings int32, col color.RGBA)

+ func DrawCapsuleWires(startPos, endPos Vector3, radius float32, slices, rings int32, col color.RGBA)

+ func DrawCylinderEx(startPos Vector3, endPos Vector3, startRadius float32, endRadius float32, ...)

+ func DrawCylinderWiresEx(startPos Vector3, endPos Vector3, startRadius float32, endRadius float32, ...)

+ func DrawTextureNPatch(texture Texture2D, nPatchInfo NPatchInfo, dest Rectangle, origin Vector2, ...)

+ func EnableBackfaceCulling()

+ func EnableColorBlend()

+ func EnableDepthMask()

+ func EnableDepthTest()

+ func EnableFramebuffer(id uint32)

+ func EnableScissorTest()

+ func EnableShader(id uint32)

+ func EnableSmoothLines()

+ func EnableStereoRender()

+ func EnableTexture(id uint32)

+ func EnableTextureCubemap(id uint32)

+ func EnableVertexArray(vaoId uint32) bool

+ func EnableVertexAttribute(index uint32)

+ func EnableVertexBuffer(id uint32)

+ func EnableVertexBufferElement(id uint32)

+ func EnableWireMode()

+ func End()

+ func FramebufferAttach(fboId uint32, texId uint32, attachType int32, texType int32, mipLevel int32)

+ func FramebufferComplete(id uint32) bool

+ func GetFramebufferHeight() int32

+ func GetFramebufferWidth() int32

+ func GetLineWidth() float32

+ func GetLocationAttrib(shaderId uint32, attribName string) int32

+ func GetLocationUniform(shaderId uint32, uniformName string) int32

+ func GetShaderBufferSize(id uint32) uint32

+ func GetShaderIdDefault() uint32

+ func GetTextureIdDefault() uint32

+ func GetVersion() int32

+ func ImageBlurGaussian(image *Image, blurSize int32)

+ func ImageDrawCircleLines(dst *Image, centerX, centerY, radius int32, col color.RGBA)

+ func ImageDrawCircleLinesV(dst *Image, center Vector2, radius int32, col color.RGBA)

+ func ImageDrawLine(dst *Image, startPosX, startPosY, endPosX, endPosY int32, col color.RGBA)

+ func ImageDrawLineV(dst *Image, start, end Vector2, col color.RGBA)

+ func IsAudioStreamReady(stream AudioStream) bool

+ func IsFontReady(font Font) bool

+ func IsImageReady(image *Image) bool

+ func IsMaterialReady(material Material) bool

+ func IsModelReady(model Model) bool

+ func IsMusicReady(music Music) bool

+ func IsRenderTextureReady(target RenderTexture2D) bool

+ func IsShaderReady(shader Shader) bool

+ func IsSoundReady(sound Sound) bool

+ func IsStereoRenderEnabled() bool

+ func IsTextureReady(texture Texture2D) bool

+ func IsWaveReady(wave Wave) bool

+ func LoadDrawCube()

+ func LoadDrawQuad()

+ func LoadFramebuffer(width int32, height int32) uint32

+ func LoadIdentity()

+ func LoadShaderCode(vsCode string, fsCode string) uint32

+ func LoadShaderProgram(vShaderId uint32, fShaderId uint32) uint32

+ func LoadVertexArray() uint32

+ func MatrixMode(mode int32)

+ func Normal3f(x float32, y float32, z float32)

+ func Ortho(left float64, right float64, bottom float64, top float64, znear float64, ...)

+ func PopMatrix()

+ func PushMatrix()

+ func Rotatef(angle float32, x float32, y float32, z float32)

+ func Scalef(x float32, y float32, z float32)

+ func Scissor(x int32, y int32, width int32, height int32)

+ func SetBlendFactors(glSrcFactor int32, glDstFactor int32, glEquation int32)

+ func SetBlendFactorsSeparate(glSrcRGB int32, glDstRGB int32, glSrcAlpha int32, glDstAlpha int32, ...)

+ func SetBlendMode(mode int32)

+ func SetFramebufferHeight(height int32)

+ func SetFramebufferWidth(width int32)

+ func SetLineWidth(width float32)

+ func SetMatrixProjectionStereo(right Matrix, left Matrix)

+ func SetMatrixViewOffsetStereo(right Matrix, left Matrix)

+ func SetTexture(id uint32)

+ func SetUniformSampler(locIndex int32, textureId uint32)

+ func SetVertexAttributeDivisor(index uint32, divisor int32)

+ func SetWindowIcons(images []Image, count int32)

+ func TexCoord2f(x float32, y float32)

+ func TextureParameters(id uint32, param int32, value int32)

+ func Translatef(x float32, y float32, z float32)

+ func UnloadFramebuffer(id uint32)

+ func UnloadShaderProgram(id uint32)

+ func UnloadVertexBuffer(vboId uint32)

+ func UpdateCameraPro(camera *Camera, movement Vector3, rotation Vector3, zoom float32)

+ func UploadMesh(mesh *Mesh, dynamic bool)

+ func Vertex2f(x float32, y float32)

+ func Vertex2i(x int32, y int32)

+ func Vertex3f(x float32, y float32, z float32)

+ func Viewport(x int32, y int32, width int32, height int32)

type BlendMode

+ const BlendAlphaPremultiply

+ const BlendCustomSeparate

type Image

+ func GenImagePerlinNoise(width, height, offsetX, offsetY int, scale float32) *Image

+ func GenImageText(width, height int, text string) *Image

+ func LoadImageFromScreen() *Image

type Matrix

+ func GetMatrixModelview() Matrix

+ func GetMatrixProjection() Matrix

+ func GetMatrixProjectionStereo(eye int32) Matrix

+ func GetMatrixTransform() Matrix

+ func GetMatrixViewOffsetStereo(eye int32) Matrix

+ type MouseCursor = int32

+ const MouseCursorArrow

+ const MouseCursorCrosshair

+ const MouseCursorDefault

+ const MouseCursorIBeam

+ const MouseCursorNotAllowed

+ const MouseCursorPointingHand

+ const MouseCursorResizeAll

+ const MouseCursorResizeEW

+ const MouseCursorResizeNESW

+ const MouseCursorResizeNS

+ const MouseCursorResizeNWSE

+ type NPatchInfo struct

+ Bottom int32

+ Layout NPatchLayout

+ Left int32

+ Right int32

+ Source Rectangle

+ Top int32

+ type NPatchLayout int32

+ const NPatchNinePatch

+ const NPatchThreePatchHorizontal

+ const NPatchThreePatchVertical

+ type TraceLogLevel int

v0.42.0

Aug 27, 2022

Changes in this version

+ const FlagWindowMousePassthrough

+ func DisableEventWaiting()

+ func DrawLineBezierCubic(startPos Vector2, endPos Vector2, startControlPos Vector2, ...)

+ func DrawLineBezierQuad(startPos Vector2, endPos Vector2, controlPos Vector2, thick float32, ...)

+ func DrawLineStrip(points []Vector2, pointCount int32, col color.RGBA)

+ func DrawPolyLinesEx(center Vector2, sides int32, radius float32, rotation float32, ...)

+ func DrawTextureQuad(texture Texture2D, tiling, offset Vector2, rectangle Rectangle, ...)

+ func DrawTextureTiled(texture Texture2D, sourceRec, destRec Rectangle, origin Vector2, ...)

+ func EnableEventWaiting()

+ func GetRenderHeight() int

+ func GetRenderWidth() int

+ func GetWindowHandle() unsafe.Pointer

+ func IsModelAnimationValid(model Model, anim ModelAnimation) bool

+ func LoadDroppedFiles() []string

+ func OpenURL(url string)

+ func SetAudioStreamPan(stream AudioStream, pan float32)

+ func SetGamepadMappings(mappings string) int32

+ func SetMouseCursor(cursor int32)

+ func SetMusicPan(music Music, pan float32)

+ func SetSoundPan(sound Sound, pan float32)

+ func SetWindowOpacity(opacity float32)

+ func UnloadDroppedFiles()

+ func UnloadModelAnimation(anim ModelAnimation)

+ func UnloadModelAnimations(animations []ModelAnimation)

+ func UpdateModelAnimation(model Model, anim ModelAnimation, frame int32)

type AudioStream

+ Processor *C.rAudioProcessor

type Matrix

+ func MatrixRotateXYZ(ang Vector3) Matrix

+ type ModelAnimation struct

+ BoneCount int32

+ Bones *BoneInfo

+ FrameCount int32

+ FramePoses **Transform

+ func LoadModelAnimations(fileName string) []ModelAnimation

type Music

+ FrameCount uint32

type Sound

+ FrameCount uint32

type Vector2

+ func GetMouseWheelMoveV() Vector2

+ func GetWorldToScreenEx(position Vector3, camera Camera, width int32, height int32) Vector2

type Wave

+ FrameCount uint32

v0.40.0

Nov 11, 2021

Changes in this version

+ const Deg2rad

+ const FlagFullscreenMode

+ const FlagInterlacedHint

+ const FlagMsaa4xHint

+ const FlagVsyncHint

+ const FlagWindowAlwaysRun

+ const FlagWindowHidden

+ const FlagWindowHighdpi

+ const FlagWindowMaximized

+ const FlagWindowMinimized

+ const FlagWindowResizable

+ const FlagWindowTopmost

+ const FlagWindowTransparent

+ const FlagWindowUndecorated

+ const FlagWindowUnfocused

+ const GamepadAndroidButtonA

+ const GamepadAndroidButtonB

+ const GamepadAndroidButtonC

+ const GamepadAndroidButtonL1

+ const GamepadAndroidButtonL2

+ const GamepadAndroidButtonR1

+ const GamepadAndroidButtonR2

+ const GamepadAndroidButtonX

+ const GamepadAndroidButtonY

+ const GamepadAndroidButtonZ

+ const GamepadAndroidDpadCenter

+ const GamepadAndroidDpadDown

+ const GamepadAndroidDpadLeft

+ const GamepadAndroidDpadRight

+ const GamepadAndroidDpadUp

+ const GamepadPlayer1

+ const GamepadPlayer2

+ const GamepadPlayer3

+ const GamepadPlayer4

+ const GamepadPs3AxisL2

+ const GamepadPs3AxisLeftX

+ const GamepadPs3AxisLeftY

+ const GamepadPs3AxisR2

+ const GamepadPs3AxisRightX

+ const GamepadPs3AxisRightY

+ const GamepadPs3ButtonCircle

+ const GamepadPs3ButtonCross

+ const GamepadPs3ButtonDown

+ const GamepadPs3ButtonL1

+ const GamepadPs3ButtonL2

+ const GamepadPs3ButtonLeft

+ const GamepadPs3ButtonPs

+ const GamepadPs3ButtonR1

+ const GamepadPs3ButtonR2

+ const GamepadPs3ButtonRight

+ const GamepadPs3ButtonSelect

+ const GamepadPs3ButtonSquare

+ const GamepadPs3ButtonStart

+ const GamepadPs3ButtonTriangle

+ const GamepadPs3ButtonUp

+ const GamepadXboxAxisLeftX

+ const GamepadXboxAxisLeftY

+ const GamepadXboxAxisLt

+ const GamepadXboxAxisRightX

+ const GamepadXboxAxisRightY

+ const GamepadXboxAxisRt

+ const GamepadXboxButtonA

+ const GamepadXboxButtonB

+ const GamepadXboxButtonDown

+ const GamepadXboxButtonHome

+ const GamepadXboxButtonLb

+ const GamepadXboxButtonLeft

+ const GamepadXboxButtonRb

+ const GamepadXboxButtonRight

+ const GamepadXboxButtonSelect

+ const GamepadXboxButtonStart

+ const GamepadXboxButtonUp

+ const GamepadXboxButtonX

+ const GamepadXboxButtonY

+ const KeyA

+ const KeyApostrophe

+ const KeyB

+ const KeyBack

+ const KeyBackSlash

+ const KeyBackspace

+ const KeyC

+ const KeyCapsLock

+ const KeyComma

+ const KeyD

+ const KeyDelete

+ const KeyDown

+ const KeyE

+ const KeyEight

+ const KeyEnd

+ const KeyEnter

+ const KeyEqual

+ const KeyEscape

+ const KeyF

+ const KeyF1

+ const KeyF10

+ const KeyF11

+ const KeyF12

+ const KeyF2

+ const KeyF3

+ const KeyF4

+ const KeyF5

+ const KeyF6

+ const KeyF7

+ const KeyF8

+ const KeyF9

+ const KeyFive

+ const KeyFour

+ const KeyG

+ const KeyGrave

+ const KeyH

+ const KeyHome

+ const KeyI

+ const KeyInsert

+ const KeyJ

+ const KeyK

+ const KeyKbMenu

+ const KeyKp0

+ const KeyKp1

+ const KeyKp2

+ const KeyKp3

+ const KeyKp4

+ const KeyKp5

+ const KeyKp6

+ const KeyKp7

+ const KeyKp8

+ const KeyKp9

+ const KeyKpAdd

+ const KeyKpDecimal

+ const KeyKpDivide

+ const KeyKpEnter

+ const KeyKpEqual

+ const KeyKpMultiply

+ const KeyKpSubtract

+ const KeyL

+ const KeyLeft

+ const KeyLeftAlt

+ const KeyLeftBracket

+ const KeyLeftControl

+ const KeyLeftShift

+ const KeyLeftSuper

+ const KeyM

+ const KeyMenu

+ const KeyMinus

+ const KeyN

+ const KeyNine

+ const KeyNumLock

+ const KeyO

+ const KeyOne

+ const KeyP

+ const KeyPageDown

+ const KeyPageUp

+ const KeyPause

+ const KeyPeriod

+ const KeyPrintScreen

+ const KeyQ

+ const KeyR

+ const KeyRight

+ const KeyRightAlt

+ const KeyRightBracket

+ const KeyRightControl

+ const KeyRightShift

+ const KeyRightSuper

+ const KeyS

+ const KeyScrollLock

+ const KeySemicolon

+ const KeySeven

+ const KeySix

+ const KeySlash

+ const KeySpace

+ const KeyT

+ const KeyTab

+ const KeyThree

+ const KeyTwo

+ const KeyU

+ const KeyUp

+ const KeyV

+ const KeyVolumeDown

+ const KeyVolumeUp

+ const KeyW

+ const KeyX

+ const KeyY

+ const KeyZ

+ const KeyZero

+ const LocColorAmbient

+ const LocColorDiffuse

+ const LocColorSpecular

+ const LocMapAlbedo

+ const LocMapBrdf

+ const LocMapCubemap

+ const LocMapDiffuse

+ const LocMapEmission

+ const LocMapHeight

+ const LocMapIrradiance

+ const LocMapMetalness

+ const LocMapNormal

+ const LocMapOcclusion

+ const LocMapPrefilter

+ const LocMapRoughness

+ const LocMapSpecular

+ const LocMatrixModel

+ const LocMatrixMvp

+ const LocMatrixNormal

+ const LocMatrixProjection

+ const LocMatrixView

+ const LocVectorView

+ const LocVertexColor

+ const LocVertexNormal

+ const LocVertexPosition

+ const LocVertexTangent

+ const LocVertexTexcoord01

+ const LocVertexTexcoord02

+ const LogAll

+ const LogDebug

+ const LogError

+ const LogFatal

+ const LogInfo

+ const LogNone

+ const LogTrace

+ const LogWarning

+ const MapAlbedo

+ const MapBrdg

+ const MapCubemap

+ const MapDiffuse

+ const MapEmission

+ const MapHeight

+ const MapIrradiance

+ const MapMetalness

+ const MapNormal

+ const MapOcclusion

+ const MapPrefilter

+ const MapRoughness

+ const MapSpecular

+ const MaxMaterialMaps

+ const MaxShaderLocations

+ const MaxTouchPoints

+ const MouseLeftButton

+ const MouseMiddleButton

+ const MouseRightButton

+ const Pi

+ const Rad2deg

+ var Beige = NewColor(211, 176, 131, 255)

+ var Black = NewColor(0, 0, 0, 255)

+ var Blank = NewColor(0, 0, 0, 0)

+ var Blue = NewColor(0, 121, 241, 255)

+ var Brown = NewColor(127, 106, 79, 255)

+ var DarkBlue = NewColor(0, 82, 172, 255)

+ var DarkBrown = NewColor(76, 63, 47, 255)

+ var DarkGray = NewColor(80, 80, 80, 255)

+ var DarkGreen = NewColor(0, 117, 44, 255)

+ var DarkPurple = NewColor(112, 31, 126, 255)

+ var Gold = NewColor(255, 203, 0, 255)

+ var Gray = NewColor(130, 130, 130, 255)

+ var Green = NewColor(0, 228, 48, 255)

+ var LightGray = NewColor(200, 200, 200, 255)

+ var Lime = NewColor(0, 158, 47, 255)

+ var Magenta = NewColor(255, 0, 255, 255)

+ var Maroon = NewColor(190, 33, 55, 255)

+ var Orange = NewColor(255, 161, 0, 255)

+ var Pink = NewColor(255, 109, 194, 255)

+ var Purple = NewColor(200, 122, 255, 255)

+ var RayWhite = NewColor(245, 245, 245, 255)

+ var Red = NewColor(230, 41, 55, 255)

+ var SkyBlue = NewColor(102, 191, 255, 255)

+ var Violet = NewColor(135, 60, 190, 255)

+ var White = NewColor(255, 255, 255, 255)

+ var Yellow = NewColor(253, 249, 0, 255)

+ func BeginBlendMode(mode BlendMode)

+ func BeginDrawing()

+ func BeginMode2D(camera Camera2D)

+ func BeginMode3D(camera Camera)

+ func BeginScissorMode(x, y, width, height int32)

+ func BeginShaderMode(shader Shader)

+ func BeginTextureMode(target RenderTexture2D)

+ func CheckCollisionBoxSphere(box BoundingBox, centerSphere Vector3, radiusSphere float32) bool

+ func CheckCollisionBoxes(box1 BoundingBox, box2 BoundingBox) bool

+ func CheckCollisionCircleRec(center Vector2, radius float32, rec Rectangle) bool

+ func CheckCollisionCircles(center1 Vector2, radius1 float32, center2 Vector2, radius2 float32) bool

+ func CheckCollisionLines(startPos1, endPos1, startPos2, endPos2 Vector2, point *Vector2) bool

+ func CheckCollisionPointCircle(point Vector2, center Vector2, radius float32) bool

+ func CheckCollisionPointLine(point, p1, p2 Vector2, threshold int32) bool

+ func CheckCollisionPointRec(point Vector2, rec Rectangle) bool

+ func CheckCollisionPointTriangle(point, p1, p2, p3 Vector2) bool

+ func CheckCollisionRecs(rec1, rec2 Rectangle) bool

+ func CheckCollisionSpheres(centerA Vector3, radiusA float32, centerB Vector3, radiusB float32) bool

+ func Clamp(value, min, max float32) float32

+ func ClearBackground(color Color)

+ func ClearDroppedFiles()

+ func ClearWindowState(flags byte)

+ func CloseAudioDevice()

+ func CloseWindow()

+ func ColorToInt(color Color) int32

+ func DisableCursor()

+ func DrawBillboard(camera Camera, texture Texture2D, center Vector3, size float32, tint Color)

+ func DrawBillboardRec(camera Camera, texture Texture2D, sourceRec Rectangle, center Vector3, ...)

+ func DrawBoundingBox(box BoundingBox, color Color)

+ func DrawCircle(centerX, centerY int32, radius float32, color Color)

+ func DrawCircle3D(center Vector3, radius float32, rotationAxis Vector3, rotationAngle float32, ...)

+ func DrawCircleGradient(centerX, centerY int32, radius float32, color1, color2 Color)

+ func DrawCircleLines(centerX, centerY int32, radius float32, color Color)

+ func DrawCircleSector(center Vector2, radius, startAngle, endAngle float32, segments int32, ...)

+ func DrawCircleSectorLines(center Vector2, radius, startAngle, endAngle float32, segments int32, ...)

+ func DrawCircleV(center Vector2, radius float32, color Color)

+ func DrawCube(position Vector3, width float32, height float32, length float32, color Color)

+ func DrawCubeTexture(texture Texture2D, position Vector3, width float32, height float32, ...)

+ func DrawCubeV(position Vector3, size Vector3, color Color)

+ func DrawCubeWires(position Vector3, width float32, height float32, length float32, color Color)

+ func DrawCubeWiresV(position Vector3, size Vector3, color Color)

+ func DrawCylinder(position Vector3, radiusTop float32, radiusBottom float32, height float32, ...)

+ func DrawCylinderWires(position Vector3, radiusTop float32, radiusBottom float32, height float32, ...)

+ func DrawEllipse(centerX, centerY int32, radiusH, radiusV float32, color Color)

+ func DrawEllipseLines(centerX, centerY int32, radiusH, radiusV float32, color Color)

+ func DrawFPS(posX int32, posY int32)

+ func DrawGrid(slices int32, spacing float32)

+ func DrawLine(startPosX, startPosY, endPosX, endPosY int32, color Color)

+ func DrawLine3D(startPos Vector3, endPos Vector3, color Color)

+ func DrawLineBezier(startPos, endPos Vector2, thick float32, color Color)

+ func DrawLineEx(startPos, endPos Vector2, thick float32, color Color)

+ func DrawLineV(startPos, endPos Vector2, color Color)

+ func DrawMesh(mesh Mesh, material Material, transform Matrix)

+ func DrawMeshInstanced(mesh Mesh, material Material, transforms []Matrix, instances int)

+ func DrawModel(model Model, position Vector3, scale float32, tint Color)

+ func DrawModelEx(model Model, position Vector3, rotationAxis Vector3, rotationAngle float32, ...)

+ func DrawModelWires(model Model, position Vector3, scale float32, tint Color)

+ func DrawModelWiresEx(model Model, position Vector3, rotationAxis Vector3, rotationAngle float32, ...)

+ func DrawPixel(posX, posY int32, color Color)

+ func DrawPixelV(position Vector2, color Color)

+ func DrawPlane(centerPos Vector3, size Vector2, color Color)

+ func DrawPoint3D(position Vector3, color Color)

+ func DrawPoly(center Vector2, sides int32, radius, rotation float32, color Color)

+ func DrawPolyLines(center Vector2, sides int32, radius, rotation float32, color Color)

+ func DrawRay(ray Ray, color Color)

+ func DrawRectangle(posX, posY, width, height int32, color Color)

+ func DrawRectangleGradientEx(rec Rectangle, color1, color2, color3, color4 Color)

+ func DrawRectangleGradientH(posX, posY, width, height int32, color1, color2 Color)

+ func DrawRectangleGradientV(posX, posY, width, height int32, color1, color2 Color)

+ func DrawRectangleLines(posX, posY, width, height int32, color Color)

+ func DrawRectangleLinesEx(rec Rectangle, lineThick float32, color Color)

+ func DrawRectanglePro(rec Rectangle, origin Vector2, rotation float32, color Color)

+ func DrawRectangleRec(rec Rectangle, color Color)

+ func DrawRectangleRounded(rec Rectangle, roundness float32, segments int32, color Color)

+ func DrawRectangleRoundedLines(rec Rectangle, roundness float32, segments, lineThick float32, color Color)

+ func DrawRectangleV(position Vector2, size Vector2, color Color)

+ func DrawRing(center Vector2, innerRadius, outerRadius, startAngle, endAngle float32, ...)

+ func DrawRingLines(center Vector2, innerRadius, outerRadius, startAngle, endAngle float32, ...)

+ func DrawSphere(centerPos Vector3, radius float32, color Color)

+ func DrawSphereEx(centerPos Vector3, radius float32, rings int32, slices int32, color Color)

+ func DrawSphereWires(centerPos Vector3, radius float32, rings int32, slices int32, color Color)

+ func DrawText(text string, posX int32, posY int32, fontSize int32, color Color)

+ func DrawTextEx(font Font, text string, position Vector2, fontSize float32, spacing float32, ...)

+ func DrawTexture(texture Texture2D, posX int32, posY int32, tint Color)

+ func DrawTextureEx(texture Texture2D, position Vector2, rotation, scale float32, tint Color)

+ func DrawTexturePro(texture Texture2D, sourceRec, destRec Rectangle, origin Vector2, ...)

+ func DrawTextureRec(texture Texture2D, sourceRec Rectangle, position Vector2, tint Color)

+ func DrawTextureV(texture Texture2D, position Vector2, tint Color)

+ func DrawTriangle(v1, v2, v3 Vector2, color Color)

+ func DrawTriangleFan(points []Vector2, color Color)

+ func DrawTriangleLines(v1, v2, v3 Vector2, color Color)

+ func DrawTriangleStrip(points []Vector2, color Color)

+ func EnableCursor()

+ func EndBlendMode()

+ func EndDrawing()

+ func EndMode2D()

+ func EndMode3D()

+ func EndScissorMode()

+ func EndShaderMode()

+ func EndTextureMode()

+ func ExportImage(image Image, name string)

+ func ExportMesh(mesh Mesh, fileName string)

+ func ExportWave(wave Wave, fileName string)

+ func GenTextureMipmaps(texture *Texture2D)

+ func GetCharPressed() int32

+ func GetClipboardText() string

+ func GetCurrentMonitor() int

+ func GetDroppedFiles(count *int32) []string

+ func GetFPS() float32

+ func GetFrameTime() float32

+ func GetGamepadAxisCount(gamepad int32) int32

+ func GetGamepadAxisMovement(gamepad, axis int32) float32

+ func GetGamepadButtonPressed() int32

+ func GetGamepadName(gamepad int32) string

+ func GetGestureDragAngle() float32

+ func GetGestureHoldDuration() float32

+ func GetGesturePinchAngle() float32

+ func GetGlyphIndex(font Font, codepoint int32) int32

+ func GetKeyPressed() int32

+ func GetMonitorCount() int

+ func GetMonitorHeight(monitor int) int

+ func GetMonitorName(monitor int) string

+ func GetMonitorPhysicalHeight(monitor int) int

+ func GetMonitorPhysicalWidth(monitor int) int

+ func GetMonitorRefreshRate(monitor int) int

+ func GetMonitorWidth(monitor int) int

+ func GetMouseWheelMove() int32

+ func GetMouseX() int32

+ func GetMouseY() int32

+ func GetMusicTimeLength(music Music) float32

+ func GetMusicTimePlayed(music Music) float32

+ func GetPixelDataSize(width, height, format int32) int32

+ func GetRandomValue(min, max int32) int32

+ func GetScreenHeight() int

+ func GetScreenWidth() int

+ func GetShaderLocation(shader Shader, uniformName string) int32

+ func GetShaderLocationAttrib(shader Shader, attribName string) int32

+ func GetSoundsPlaying() int

+ func GetTime() float32

+ func GetTouchPointCount() int32

+ func GetTouchPointId(index int32) int32

+ func GetTouchX() int32

+ func GetTouchY() int32

+ func HideCursor()

+ func HomeDir() string

+ func ImageAlphaClear(image *Image, color Color, threshold float32)

+ func ImageAlphaCrop(image *Image, threshold float32)

+ func ImageAlphaMask(image, alphaMask *Image)

+ func ImageAlphaPremultiply(image *Image)

+ func ImageClearBackground(dst *Image, color Color)

+ func ImageColorBrightness(image *Image, brightness int32)

+ func ImageColorContrast(image *Image, contrast float32)

+ func ImageColorGrayscale(image *Image)

+ func ImageColorInvert(image *Image)

+ func ImageColorReplace(image *Image, color, replace Color)

+ func ImageColorTint(image *Image, color Color)

+ func ImageCrop(image *Image, crop Rectangle)

+ func ImageDither(image *Image, rBpp, gBpp, bBpp, aBpp int32)

+ func ImageDraw(dst, src *Image, srcRec, dstRec Rectangle, tint Color)

+ func ImageDrawCircle(dst *Image, centerX, centerY, radius int32, color Color)

+ func ImageDrawCircleV(dst *Image, center Vector2, radius int32, color Color)

+ func ImageDrawPixel(dst *Image, posX, posY int32, color Color)

+ func ImageDrawPixelV(dst *Image, position Vector2, color Color)

+ func ImageDrawRectangle(dst *Image, x, y, width, height int32, color Color)

+ func ImageDrawRectangleLines(dst *Image, rec Rectangle, thick int, color Color)

+ func ImageDrawRectangleRec(dst *Image, rec Rectangle, color Color)

+ func ImageDrawRectangleV(dst *Image, position, size Vector2, color Color)

+ func ImageDrawText(dst *Image, posX, posY int32, text string, fontSize int32, color Color)

+ func ImageDrawTextEx(dst *Image, position Vector2, font Font, text string, ...)

+ func ImageFlipHorizontal(image *Image)

+ func ImageFlipVertical(image *Image)

+ func ImageFormat(image *Image, newFormat PixelFormat)

+ func ImageMipmaps(image *Image)

+ func ImageResize(image *Image, newWidth, newHeight int32)

+ func ImageResizeCanvas(image *Image, newWidth, newHeight, offsetX, offsetY int32, color Color)

+ func ImageResizeNN(image *Image, newWidth, newHeight int32)

+ func ImageRotateCCW(image *Image)

+ func ImageRotateCW(image *Image)

+ func ImageToPOT(image *Image, fillColor Color)

+ func InitAudioDevice()

+ func InitWindow(width int32, height int32, title string)

+ func IsAudioDeviceReady() bool

+ func IsAudioStreamPlaying(stream AudioStream) bool

+ func IsAudioStreamProcessed(stream AudioStream) bool

+ func IsCursorHidden() bool

+ func IsCursorOnScreen() bool

+ func IsFileDropped() bool

+ func IsGamepadAvailable(gamepad int32) bool

+ func IsGamepadButtonDown(gamepad, button int32) bool

+ func IsGamepadButtonPressed(gamepad, button int32) bool

+ func IsGamepadButtonReleased(gamepad, button int32) bool

+ func IsGamepadButtonUp(gamepad, button int32) bool

+ func IsGestureDetected(gesture Gestures) bool

+ func IsKeyDown(key int32) bool

+ func IsKeyPressed(key int32) bool

+ func IsKeyReleased(key int32) bool

+ func IsKeyUp(key int32) bool

+ func IsMouseButtonDown(button int32) bool

+ func IsMouseButtonPressed(button int32) bool

+ func IsMouseButtonReleased(button int32) bool

+ func IsMouseButtonUp(button int32) bool

+ func IsMusicStreamPlaying(music Music) bool

+ func IsSoundPlaying(sound Sound) bool

+ func IsWindowFocused() bool

+ func IsWindowFullscreen() bool

+ func IsWindowHidden() bool

+ func IsWindowMaximized() bool

+ func IsWindowMinimized() bool

+ func IsWindowReady() bool

+ func IsWindowResized() bool

+ func IsWindowState(flag byte) bool

+ func LoadStorageValue(position int32) int32

+ func LoadWaveSamples(wave Wave) []float32

+ func Mat2Set(matrix *Mat2, radians float32)

+ func MatrixDeterminant(mat Matrix) float32

+ func MatrixToFloat(mat Matrix) []float32

+ func MatrixTrace(mat Matrix) float32

+ func MaximizeWindow()

+ func MeasureText(text string, fontSize int32) int32

+ func MinimizeWindow()

+ func PauseAudioStream(stream AudioStream)

+ func PauseMusicStream(music Music)

+ func PauseSound(sound Sound)

+ func PlayAudioStream(stream AudioStream)

+ func PlayMusicStream(music Music)

+ func PlaySound(sound Sound)

+ func PlaySoundMulti(sound Sound)

+ func QuaternionLength(quat Quaternion) float32

+ func QuaternionToAxisAngle(q Quaternion, outAxis *Vector3, outAngle *float32)

+ func RestoreWindow()

+ func ResumeAudioStream(stream AudioStream)

+ func ResumeMusicStream(music Music)

+ func ResumeSound(sound Sound)

+ func SaveStorageValue(position, value int32)

+ func SeekMusicStream(music Music, position float32)

+ func SetAudioStreamBufferSizeDefault(size int32)

+ func SetAudioStreamPitch(stream AudioStream, pitch float32)

+ func SetAudioStreamVolume(stream AudioStream, volume float32)

+ func SetCallbackFunc(func())

+ func SetCameraAltControl(altKey int32)

+ func SetCameraMode(camera Camera, mode CameraMode)

+ func SetCameraMoveControls(frontKey int32, backKey int32, rightKey int32, leftKey int32, upKey int32, ...)

+ func SetCameraPanControl(panKey int32)

+ func SetCameraSmoothZoomControl(szKey int32)

+ func SetClipboardText(data string)

+ func SetConfigFlags(flags byte)

+ func SetExitKey(key int32)

+ func SetGamepadMapping(mappings string) int32

+ func SetGesturesEnabled(gestureFlags uint32)

+ func SetMasterVolume(volume float32)

+ func SetMaterialTexture(material *Material, mapType int32, texture Texture2D)

+ func SetMatrixModelview(view Matrix)

+ func SetMatrixProjection(proj Matrix)

+ func SetModelMeshMaterial(model *Model, meshId int32, materialId int32)

+ func SetMouseOffset(offsetX, offsetY int)

+ func SetMousePosition(x, y int)

+ func SetMouseScale(scaleX, scaleY float32)

+ func SetMusicPitch(music Music, pitch float32)

+ func SetMusicVolume(music Music, volume float32)

+ func SetShaderValue(shader Shader, locIndex int32, value []float32, ...)

+ func SetShaderValueMatrix(shader Shader, locIndex int32, mat Matrix)

+ func SetShaderValueTexture(shader Shader, locIndex int32, texture Texture2D)

+ func SetShaderValueV(shader Shader, locIndex int32, value []float32, ...)

+ func SetShapesTexture(texture Texture2D, source Rectangle)

+ func SetSoundPitch(sound Sound, pitch float32)

+ func SetSoundVolume(sound Sound, volume float32)

+ func SetTargetFPS(fps int32)

+ func SetTextureFilter(texture Texture2D, filterMode TextureFilterMode)

+ func SetTextureWrap(texture Texture2D, wrapMode TextureWrapMode)

+ func SetTraceLog(typeFlags int)

+ func SetTraceLogCallback(fn TraceLogCallbackFun)

+ func SetWindowIcon(image Image)

+ func SetWindowMinSize(w, h int)

+ func SetWindowMonitor(monitor int)

+ func SetWindowPosition(x, y int)

+ func SetWindowSize(w, h int)

+ func SetWindowState(flags byte)

+ func SetWindowTitle(title string)

+ func ShowCursor()

+ func StopAudioStream(stream AudioStream)

+ func StopMusicStream(music Music)

+ func StopSound(sound Sound)

+ func StopSoundMulti()

+ func TakeScreenshot(name string)

+ func ToggleFullscreen()

+ func TraceLog(msgType int, text string, v ...interface{})

+ func UnloadAudioStream(stream AudioStream)

+ func UnloadFont(font Font)

+ func UnloadImage(image *Image)

+ func UnloadMaterial(material Material)

+ func UnloadMesh(mesh *Mesh)

+ func UnloadModel(model Model)

+ func UnloadMusicStream(music Music)

+ func UnloadRenderTexture(target RenderTexture2D)

+ func UnloadShader(shader Shader)

+ func UnloadSound(sound Sound)

+ func UnloadTexture(texture Texture2D)

+ func UnloadWave(wave Wave)

+ func UnloadWaveSamples(samples []float32)

+ func UpdateAudioStream(stream AudioStream, data []float32, samplesCount int32)

+ func UpdateCamera(camera *Camera)

+ func UpdateMusicStream(music Music)

+ func UpdateSound(sound Sound, data []byte, samplesCount int32)

+ func UpdateTexture(texture Texture2D, pixels []Color)

+ func UpdateTextureRec(texture Texture2D, rec Rectangle, pixels []Color)

+ func Vector2Angle(v1, v2 Vector2) float32

+ func Vector2CrossProduct(v1, v2 Vector2) float32

+ func Vector2Distance(v1, v2 Vector2) float32

+ func Vector2DotProduct(v1, v2 Vector2) float32

+ func Vector2LenSqr(vector Vector2) float32

+ func Vector2Length(v Vector2) float32

+ func Vector3Distance(v1, v2 Vector3) float32

+ func Vector3DotProduct(v1, v2 Vector3) float32

+ func Vector3Length(v Vector3) float32

+ func Vector3ToFloat(vec Vector3) []float32

+ func WaveCrop(wave Wave, initSample int32, finalSample int32)

+ func WaveFormat(wave Wave, sampleRate int32, sampleSize int32, channels int32)

+ func WindowShouldClose() bool

+ type Asset interface

+ func OpenAsset(name string) (Asset, error)

+ type AudioStream struct

+ Buffer *C.rAudioBuffer

+ Channels uint32

+ SampleRate uint32

+ SampleSize uint32

+ func LoadAudioStream(sampleRate uint32, sampleSize uint32, channels uint32) AudioStream

+ type BlendMode int32

+ const BlendAddColors

+ const BlendAdditive

+ const BlendAlpha

+ const BlendCustom

+ const BlendMultiplied

+ const BlendSubtractColors

+ type BoneInfo struct

+ Name [32]int8

+ Parent int32

+ type BoundingBox struct

+ Max Vector3

+ Min Vector3

+ func GetMeshBoundingBox(mesh Mesh) BoundingBox

+ func GetModelBoundingBox(model Model) BoundingBox

+ func NewBoundingBox(min, max Vector3) BoundingBox

+ type Camera = Camera3D

+ type Camera2D struct

+ Offset Vector2

+ Rotation float32

+ Target Vector2

+ Zoom float32

+ func NewCamera2D(offset, target Vector2, rotation, zoom float32) Camera2D

+ type Camera3D struct

+ Fovy float32

+ Position Vector3

+ Projection CameraProjection

+ Target Vector3

+ Up Vector3

+ func NewCamera3D(pos, target, up Vector3, fovy float32, ct CameraProjection) Camera3D

+ type CameraMode int32

+ const CameraCustom

+ const CameraFirstPerson

+ const CameraFree

+ const CameraOrbital

+ const CameraThirdPerson

+ type CameraProjection int32

+ const CameraOrthographic

+ const CameraPerspective

+ type Color struct

+ A uint8

+ B uint8

+ G uint8

+ R uint8

+ func ColorAlpha(color Color, alpha float32) Color

+ func ColorAlphaBlend(src, dst, tint Color) Color

+ func ColorFromHSV(hue, saturation, value float32) Color

+ func ColorFromNormalized(normalized Vector4) Color

+ func Fade(color Color, alpha float32) Color

+ func GetColor(hexValue uint) Color

+ func GetImageColor(image Image, x, y int32) Color

+ func LoadImageColors(img *Image) []Color

+ func NewColor(r, g, b, a uint8) Color

+ type Font struct

+ BaseSize int32

+ Chars *GlyphInfo

+ CharsCount int32

+ CharsPadding int32

+ Recs *Rectangle

+ Texture Texture2D

+ func GetFontDefault() Font

+ func LoadFont(fileName string) Font

+ func LoadFontEx(fileName string, fontSize int32, fontChars *int32, charsCount int32) Font

+ func LoadFontFromImage(image Image, key Color, firstChar int32) Font

+ func LoadFontFromMemory(fileType string, fileData []byte, dataSize int32, fontSize int32, ...) Font

+ type Gestures int32

+ const GestureDoubletap

+ const GestureDrag

+ const GestureHold

+ const GestureNone

+ const GesturePinchIn

+ const GesturePinchOut

+ const GestureSwipeDown

+ const GestureSwipeLeft

+ const GestureSwipeRight

+ const GestureSwipeUp

+ const GestureTap

+ func GetGestureDetected() Gestures

+ type GlyphInfo struct

+ AdvanceX int32

+ Image Image

+ OffsetX int32

+ OffsetY int32

+ Value int32

+ func GetGlyphInfo(font Font, codepoint int32) GlyphInfo

+ func LoadFontData(fileData []byte, dataSize int32, fontSize int32, fontChars *int32, ...) *GlyphInfo

+ func NewGlyphInfo(value int32, offsetX, offsetY, advanceX int32, image Image) GlyphInfo

+ type Image struct

+ Format PixelFormat

+ Height int32

+ Mipmaps int32

+ Width int32

+ func GenImageCellular(width, height, tileSize int) *Image

+ func GenImageChecked(width, height, checksX, checksY int, col1, col2 Color) *Image

+ func GenImageColor(width, height int, color Color) *Image

+ func GenImageGradientH(width, height int, left, right Color) *Image

+ func GenImageGradientRadial(width, height int, density float32, inner, outer Color) *Image

+ func GenImageGradientV(width, height int, top, bottom Color) *Image

+ func GenImageWhiteNoise(width, height int, factor float32) *Image

+ func ImageCopy(image *Image) *Image

+ func ImageText(text string, fontSize int32, color Color) *Image

+ func ImageTextEx(font Font, text string, fontSize, spacing float32, tint Color) *Image

+ func LoadImage(fileName string) *Image

+ func LoadImageAnim(fileName string, frames *int32) *Image

+ func LoadImageFromMemory(fileType string, fileData []byte, dataSize int32) *Image

+ func LoadImageFromTexture(texture Texture2D) *Image

+ func LoadImageRaw(fileName string, width, height int32, format PixelFormat, headerSize int32) *Image

+ func NewImage(data []byte, width, height, mipmaps int32, format PixelFormat) *Image

+ func NewImageFromImage(img image.Image) *Image

+ func (i *Image) ToImage() image.Image

+ type Mat2 struct

+ M00 float32

+ M01 float32

+ M10 float32

+ M11 float32

+ func Mat2Radians(radians float32) Mat2

+ func Mat2Transpose(matrix Mat2) Mat2

+ func NewMat2(m0, m1, m10, m11 float32) Mat2

+ type Material struct

+ Maps *MaterialMap

+ Params [4]float32

+ Shader Shader

+ func LoadMaterialDefault() Material

+ func LoadMaterials(fileName string) Material

+ func (mt Material) GetMap(index int32) *MaterialMap

+ type MaterialMap struct

+ Color Color

+ Texture Texture2D

+ Value float32

+ type Matrix struct

+ M0 float32

+ M1 float32

+ M10 float32

+ M11 float32

+ M12 float32

+ M13 float32

+ M14 float32

+ M15 float32

+ M2 float32

+ M3 float32

+ M4 float32

+ M5 float32

+ M6 float32

+ M7 float32

+ M8 float32

+ M9 float32

+ func GetCameraMatrix(camera Camera) Matrix

+ func GetCameraMatrix2D(camera Camera2D) Matrix

+ func MatrixAdd(left, right Matrix) Matrix

+ func MatrixFrustum(left, right, bottom, top, near, far float32) Matrix

+ func MatrixIdentity() Matrix

+ func MatrixInvert(mat Matrix) Matrix

+ func MatrixLookAt(eye, target, up Vector3) Matrix

+ func MatrixMultiply(left, right Matrix) Matrix

+ func MatrixNormalize(mat Matrix) Matrix

+ func MatrixOrtho(left, right, bottom, top, near, far float32) Matrix

+ func MatrixPerspective(fovy, aspect, near, far float32) Matrix

+ func MatrixRotate(axis Vector3, angle float32) Matrix

+ func MatrixRotateX(angle float32) Matrix

+ func MatrixRotateY(angle float32) Matrix

+ func MatrixRotateZ(angle float32) Matrix

+ func MatrixScale(x, y, z float32) Matrix

+ func MatrixSubtract(left, right Matrix) Matrix

+ func MatrixTranslate(x, y, z float32) Matrix

+ func MatrixTranspose(mat Matrix) Matrix

+ func NewMatrix(m0, m4, m8, m12, m1, m5, m9, m13, m2, m6, m10, m14, m3, m7, m11, m15 float32) Matrix

+ func QuaternionToMatrix(q Quaternion) Matrix

+ type Mesh struct

+ AnimNormals *float32

+ AnimVertices *float32

+ BoneIds *int32

+ BoneWeights *float32

+ Colors *uint8

+ Indices *uint16

+ Normals *float32

+ Tangents *float32

+ Texcoords *float32

+ Texcoords2 *float32

+ TriangleCount int32

+ VaoID uint32

+ VboID *uint32

+ VertexCount int32

+ Vertices *float32

+ func GenMeshCone(radius, height float32, slices int) Mesh

+ func GenMeshCube(width, height, length float32) Mesh

+ func GenMeshCubicmap(cubicmap Image, size Vector3) Mesh

+ func GenMeshCylinder(radius, height float32, slices int) Mesh

+ func GenMeshHeightmap(heightmap Image, size Vector3) Mesh

+ func GenMeshHemiSphere(radius float32, rings, slices int) Mesh

+ func GenMeshKnot(radius, size float32, radSeg, sides int) Mesh

+ func GenMeshPlane(width, length float32, resX, resZ int) Mesh

+ func GenMeshPoly(sides int, radius float32) Mesh

+ func GenMeshSphere(radius float32, rings, slices int) Mesh

+ func GenMeshTorus(radius, size float32, radSeg, sides int) Mesh

+ type Model struct

+ BindPose *Transform

+ BoneCount int32

+ Bones *BoneInfo

+ MaterialCount int32

+ Materials *Material

+ MeshCount int32

+ MeshMaterial *int32

+ Meshes *Mesh

+ Transform Matrix

+ func LoadModel(fileName string) Model

+ func LoadModelFromMesh(data Mesh) Model

+ type Music struct

+ CtxData unsafe.Pointer

+ CtxType int32

+ Looping bool

+ SampleCount uint32

+ Stream AudioStream

+ func LoadMusicStream(fileName string) Music

+ func LoadMusicStreamFromMemory(fileType string, fileData []byte, dataSize int32) Music

+ type PixelFormat int32

+ const CompressedAstc4x4Rgba

+ const CompressedAstc8x8Rgba

+ const CompressedDxt1Rgb

+ const CompressedDxt1Rgba

+ const CompressedDxt3Rgba

+ const CompressedDxt5Rgba

+ const CompressedEtc1Rgb

+ const CompressedEtc2EacRgba

+ const CompressedEtc2Rgb

+ const CompressedPvrtRgb

+ const CompressedPvrtRgba

+ const UncompressedGrayAlpha

+ const UncompressedGrayscale

+ const UncompressedR32

+ const UncompressedR32g32b32

+ const UncompressedR32g32b32a32

+ const UncompressedR4g4b4a4

+ const UncompressedR5g5b5a1

+ const UncompressedR5g6b5

+ const UncompressedR8g8b8

+ const UncompressedR8g8b8a8

+ type Quaternion struct

+ W float32

+ X float32

+ Y float32

+ Z float32

+ func NewQuaternion(x, y, z, w float32) Quaternion

+ func QuaternionFromAxisAngle(axis Vector3, angle float32) Quaternion

+ func QuaternionFromMatrix(matrix Matrix) Quaternion

+ func QuaternionInvert(quat Quaternion) Quaternion

+ func QuaternionMultiply(q1, q2 Quaternion) Quaternion

+ func QuaternionNormalize(q Quaternion) Quaternion

+ func QuaternionSlerp(q1, q2 Quaternion, amount float32) Quaternion

+ func QuaternionTransform(q Quaternion, mat Matrix) Quaternion

+ type Ray struct

+ Direction Vector3

+ Position Vector3

+ func GetMouseRay(mousePosition Vector2, camera Camera) Ray

+ func NewRay(position, direction Vector3) Ray

+ type RayCollision struct

+ Distance float32

+ Hit bool

+ Normal Vector3

+ Point Vector3

+ func GetRayCollisionBox(ray Ray, box BoundingBox) RayCollision

+ func GetRayCollisionMesh(ray Ray, mesh Mesh, transform Matrix) RayCollision

+ func GetRayCollisionModel(ray Ray, model Model) RayCollision

+ func GetRayCollisionQuad(ray Ray, p1, p2, p3, p4 Vector3) RayCollision

+ func GetRayCollisionSphere(ray Ray, center Vector3, radius float32) RayCollision

+ func GetRayCollisionTriangle(ray Ray, p1, p2, p3 Vector3) RayCollision

+ func NewRayCollision(hit bool, distance float32, point, normal Vector3) RayCollision

+ type Rectangle struct

+ Height float32

+ Width float32

+ X float32

+ Y float32

+ func GetCollisionRec(rec1, rec2 Rectangle) Rectangle

+ func GetGlyphAtlasRec(font Font, codepoint int32) Rectangle

+ func NewRectangle(x, y, width, height float32) Rectangle

+ func (r *Rectangle) ToInt32() RectangleInt32

+ type RectangleInt32 struct

+ Height int32

+ Width int32

+ X int32

+ Y int32

+ func (r *RectangleInt32) ToFloat32() Rectangle

+ type RenderTexture2D struct

+ Depth Texture2D

+ ID uint32

+ Texture Texture2D

+ func LoadRenderTexture(width, height int32) RenderTexture2D

+ func NewRenderTexture2D(id uint32, texture, depth Texture2D) RenderTexture2D

+ type Shader struct

+ ID uint32

+ Locs *int32

+ func LoadShader(vsFileName string, fsFileName string) Shader

+ func LoadShaderFromMemory(vsCode string, fsCode string) Shader

+ func NewShader(id uint32, locs *int32) Shader

+ func (sh Shader) GetLocation(index int32) int32

+ func (sh Shader) UpdateLocation(index int32, loc int32)

+ type ShaderUniformDataType int32

+ const ShaderUniformFloat

+ const ShaderUniformInt

+ const ShaderUniformIvec2

+ const ShaderUniformIvec3

+ const ShaderUniformIvec4

+ const ShaderUniformSampler2d

+ const ShaderUniformVec2

+ const ShaderUniformVec3

+ const ShaderUniformVec4

+ type Sound struct

+ SampleCount uint32

+ Stream AudioStream

+ func LoadSound(fileName string) Sound

+ func LoadSoundFromWave(wave Wave) Sound

+ type Texture2D struct

+ Format PixelFormat

+ Height int32

+ ID uint32

+ Mipmaps int32

+ Width int32

+ func LoadTexture(fileName string) Texture2D

+ func LoadTextureFromImage(image *Image) Texture2D

+ func NewTexture2D(id uint32, width, height, mipmaps int32, format PixelFormat) Texture2D

+ type TextureFilterMode int32

+ const FilterAnisotropic16x

+ const FilterAnisotropic4x

+ const FilterAnisotropic8x

+ const FilterBilinear

+ const FilterPoint

+ const FilterTrilinear

+ type TextureWrapMode int32

+ const WrapClamp

+ const WrapMirrorClamp

+ const WrapMirrorRepeat

+ const WrapRepeat

+ type TraceLogCallbackFun func(int, string)

+ type Transform struct

+ Rotation Vector4

+ Scale Vector3

+ Translation Vector3

+ type Vector2 struct

+ X float32

+ Y float32

+ func GetGestureDragVector() Vector2

+ func GetGesturePinchVector() Vector2

+ func GetMonitorPosition(monitor int) Vector2

+ func GetMouseDelta() Vector2

+ func GetMousePosition() Vector2

+ func GetScreenToWorld2D(position Vector2, camera Camera2D) Vector2

+ func GetTouchPosition(index int32) Vector2

+ func GetWindowPosition() Vector2

+ func GetWindowScaleDPI() Vector2

+ func GetWorldToScreen(position Vector3, camera Camera) Vector2

+ func GetWorldToScreen2D(position Vector2, camera Camera2D) Vector2

+ func Mat2MultiplyVector2(matrix Mat2, vector Vector2) Vector2

+ func MeasureTextEx(font Font, text string, fontSize float32, spacing float32) Vector2

+ func NewVector2(x, y float32) Vector2

+ func Vector2Add(v1, v2 Vector2) Vector2

+ func Vector2Cross(value float32, vector Vector2) Vector2

+ func Vector2DivideV(v1, v2 Vector2) Vector2

+ func Vector2Lerp(v1, v2 Vector2, amount float32) Vector2

+ func Vector2Multiply(v1, v2 Vector2) Vector2

+ func Vector2Negate(v Vector2) Vector2

+ func Vector2Normalize(v Vector2) Vector2

+ func Vector2One() Vector2

+ func Vector2Scale(v Vector2, scale float32) Vector2

+ func Vector2Subtract(v1, v2 Vector2) Vector2

+ func Vector2Zero() Vector2

+ type Vector3 struct

+ X float32

+ Y float32

+ Z float32

+ func ColorToHSV(color Color) Vector3

+ func NewVector3(X, Y, Z float32) Vector3

+ func Vector3Add(v1, v2 Vector3) Vector3

+ func Vector3Barycenter(p, a, b, c Vector3) Vector3

+ func Vector3CrossProduct(v1, v2 Vector3) Vector3

+ func Vector3Lerp(v1, v2 Vector3, amount float32) Vector3

+ func Vector3Max(vec1, vec2 Vector3) Vector3

+ func Vector3Min(vec1, vec2 Vector3) Vector3

+ func Vector3Multiply(v Vector3, scalar float32) Vector3

+ func Vector3MultiplyV(v1, v2 Vector3) Vector3

+ func Vector3Negate(v Vector3) Vector3

+ func Vector3Normalize(v Vector3) Vector3

+ func Vector3One() Vector3

+ func Vector3Perpendicular(v Vector3) Vector3

+ func Vector3Reflect(vector, normal Vector3) Vector3

+ func Vector3Scale(v Vector3, scale float32) Vector3

+ func Vector3Subtract(v1, v2 Vector3) Vector3

+ func Vector3Transform(v Vector3, mat Matrix) Vector3

+ func Vector3Zero() Vector3

+ type Vector4 struct

+ W float32

+ X float32

+ Y float32

+ Z float32

+ func ColorNormalize(color Color) Vector4

+ func NewVector4(X, Y, Z, W float32) Vector4

+ type Wave struct

+ Channels uint32

+ SampleCount uint32

+ SampleRate uint32

+ SampleSize uint32

+ func LoadWave(fileName string) Wave

+ func LoadWaveFromMemory(fileType string, fileData []byte, dataSize int32) Wave

+ func NewWave(sampleCount, sampleRate, sampleSize, channels uint32, data []byte) Wave

+ func WaveCopy(wave Wave) Wave

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL