Index

Modules: boxy, boxy/blends, boxy/blurs, boxy/buffers, boxy/shaders, boxy/spreads, boxy/textures.

API symbols

addImage:

• boxy: proc addImage(boxy: Boxy; key: string; image: Image; genMipmaps = true)

applyTransform:

• boxy: proc applyTransform(boxy: Boxy; m: Mat3)

atlasVert:

• blends: proc atlasVert(vertexPos: Vec2; vertexUv: Vec2; vertexColor: Vec4; pos: var Vec2; uv: var Vec2; color: var Vec4)

beginFrame:

• boxy: proc beginFrame(boxy: Boxy; frameSize: IVec2; clearFrame = true)
• boxy: proc beginFrame(boxy: Boxy; frameSize: IVec2; proj: Mat4; clearFrame = true)

bindAttrib:

• shaders: proc bindAttrib(shader: Shader; name: string; buffer: Buffer)

bindBufferData:

• buffers: proc bindBufferData(buffer: Buffer; data: pointer)

bindTextureBufferData:

• textures: proc bindTextureBufferData(texture: Texture; buffer: Buffer; data: pointer)

bindTextureData:

• textures: proc bindTextureData(texture: Texture; data: pointer)

bindUniformBuffer:

• shaders: proc bindUniformBuffer(shader: Shader; name: string; buffer: Buffer; binding: GLuint)

bindUniforms:

• shaders: proc bindUniforms(shader: Shader)

bkMAT2:

• buffers: BufferKind.bkMAT2

bkMAT3:

• buffers: BufferKind.bkMAT3

bkMAT4:

• buffers: BufferKind.bkMAT4

bkSCALAR:

• buffers: BufferKind.bkSCALAR

bkVEC2:

• buffers: BufferKind.bkVEC2

bkVEC3:

• buffers: BufferKind.bkVEC3

bkVEC4:

• buffers: BufferKind.bkVEC4

blendingMain:

• blends: proc blendingMain(pos: Vec2; uv: Vec2; color: Vec4; fragColor: var Vec4)

blurEffect:

• boxy: proc blurEffect(boxy: Boxy; radius: float32)

blurXMain:

• blurs: proc blurXMain(pos: Vec2; uv: Vec2; color: Vec4; fragColor: var Vec4)

blurYMain:

• blurs: proc blurYMain(pos: Vec2; uv: Vec2; color: Vec4; fragColor: var Vec4)

Boxy:

• boxy: type Boxy

BoxyError:

• boxy: object BoxyError

Buffer:

• buffers: type Buffer

BufferKind:

• buffers: enum BufferKind

clearAtlas:

• boxy: proc clearAtlas(boxy: Boxy)

clearTransform:

• boxy: proc clearTransform(boxy: Boxy)

compileComputeShader:

• shaders: proc compileComputeShader(compute: (string, string)): GLuint
• shaders: proc compileComputeShader(path: string): GLuint

compileShaderFiles:

• shaders: proc compileShaderFiles(vert, frag: (string, string)): GLuint
• shaders: proc compileShaderFiles(vertPath, fragPath: string): GLuint

componentCount:

• buffers: proc componentCount(bufferKind: BufferKind): Positive

contains:

• boxy: proc contains(boxy: Boxy; key: string): bool

drawImage:

• boxy: proc drawImage(boxy: Boxy; key: string; rect: Rect; tint = color(1, 1, 1, 1))
• boxy: proc drawImage(boxy: Boxy; key: string; pos: Vec2; tint = color(1, 1, 1, 1))
• boxy: proc drawImage(boxy: Boxy; key: string; center: Vec2; angle: float32; tint = color(1, 1, 1, 1); scale: float32 = 1.0)

drawRect:

• boxy: proc drawRect(boxy: Boxy; rect: Rect; color: Color)

dropShadowEffect:

• boxy: proc dropShadowEffect(boxy: Boxy; tint: Color; offset: Vec2; radius, spread: float32)

endFrame:

• boxy: proc endFrame(boxy: Boxy)

flush:

• boxy: proc flush(boxy: Boxy)

fromScreen:

• boxy: proc fromScreen(boxy: Boxy; windowFrame: Vec2; v: Vec2): Vec2

getErrorLog:

• shaders: proc getErrorLog(id: GLuint; path: string; lenProc: typeof(glGetShaderiv); strProc: typeof(glGetShaderInfoLog)): string

getImage:

• boxy: proc getImage(boxy: Boxy; bounds: Rect): Image

getImageSize:

• boxy: proc getImageSize(boxy: Boxy; key: string): IVec2

getTransform:

• boxy: proc getTransform(boxy: Boxy): Mat3

gl_Position:

• blends: var gl_Position

hasUniform:

• shaders: proc hasUniform(shader: Shader; name: string): bool

magDefault:

• textures: MagFilter.magDefault

MagFilter:

• textures: enum MagFilter

magLinear:

• textures: MagFilter.magLinear

magNearest:

• textures: MagFilter.magNearest

minDefault:

• textures: MinFilter.minDefault

MinFilter:

• textures: enum MinFilter

minLinear:

• textures: MinFilter.minLinear

minLinearMipmapLinear:

• textures: MinFilter.minLinearMipmapLinear

minLinearMipmapNearest:

• textures: MinFilter.minLinearMipmapNearest

minNearest:

• textures: MinFilter.minNearest

minNearestMipmapLinear:

• textures: MinFilter.minNearestMipmapLinear

minNearestMipmapNearest:

• textures: MinFilter.minNearestMipmapNearest

newBoxy:

• boxy: proc newBoxy(atlasSize = 512; tileSize = 32 - 2; quadsPerBatch = 1024): Boxy

newShader:

• shaders: proc newShader(compute: (string, string)): Shader
• shaders: proc newShader(vert, frag: (string, string)): Shader
• shaders: proc newShader(computePath: string): Shader
• shaders: proc newShader(vertPath, fragPath: string): Shader

newShaderStatic:

• shaders: template newShaderStatic(computePath: string): Shader
• shaders: template newShaderStatic(vertPath, fragPath: string): Shader

newTexture:

• textures: proc newTexture(image: Image): Texture

popLayer:

• boxy: proc popLayer(boxy: Boxy; tint = color(1, 1, 1, 1); blendMode: BlendMode = NormalBlend)

pushLayer:

• boxy: proc pushLayer(boxy: Boxy)

readAtlas:

• boxy: proc readAtlas(boxy: Boxy): Image

readImage:

• textures: proc readImage(texture: Texture): Image

removeImage:

• boxy: proc removeImage(boxy: Boxy; key: string)

restoreTransform:

• boxy: proc restoreTransform(boxy: Boxy)

rotate:

• boxy: proc rotate(boxy: Boxy; angle: float32)

saveTransform:

• boxy: proc saveTransform(boxy: Boxy)

scale:

• boxy: proc scale(boxy: Boxy; scale: float32)
• boxy: proc scale(boxy: Boxy; scale: Vec2)

setTransform:

• boxy: proc setTransform(boxy: Boxy; m: Mat3)

setUniform:

• shaders: proc setUniform(shader: Shader; name: string; b: bool)
• shaders: proc setUniform(shader: Shader; name: string; m: Mat4)
• shaders: proc setUniform(shader: Shader; name: string; args: varargs[float32])
• shaders: proc setUniform(shader: Shader; name: string; args: varargs[int32])
• shaders: proc setUniform(shader: Shader; name: string; v: Vec2)
• shaders: proc setUniform(shader: Shader; name: string; v: Vec3)
• shaders: proc setUniform(shader: Shader; name: string; v: Vec4)

Shader:

• shaders: type Shader

size:

• buffers: proc size(componentType: GLenum): Positive

spreadXMain:

• spreads: proc spreadXMain(pos: Vec2; uv: Vec2; color: Vec4; fragColor: var Vec4)

spreadYMain:

• spreads: proc spreadYMain(pos: Vec2; uv: Vec2; color: Vec4; fragColor: var Vec4)

Texture:

• textures: type Texture

toScreen:

• boxy: proc toScreen(boxy: Boxy; windowFrame: Vec2; v: Vec2): Vec2

translate:

• boxy: proc translate(boxy: Boxy; v: Vec2)

updateSubImage:

• textures: proc updateSubImage(texture: Texture; x, y: int; image: Image)
• textures: proc updateSubImage(texture: Texture; x, y: int; image: Image; level: int)

wClampToEdge:

• textures: Wrap.wClampToEdge

wDefault:

• textures: Wrap.wDefault

wMirroredRepeat:

• textures: Wrap.wMirroredRepeat

Wrap:

• textures: enum Wrap

wRepeat:

• textures: Wrap.wRepeat

writeFile:

• textures: proc writeFile(texture: Texture; path: string)