core/com.lehaine.littlekt.graphics

Package-level declarations

Types

Camera

abstract class Camera

Color

open class Color(r: Float, g: Float, b: Float, a: Float = 1.0f) : Vec4f

ColorGradient

class ColorGradient(colors: Pair<Float, Color>, n: Int = DEFAULT_N, toLinear: Boolean = false)

Cursor

actual class Cursor(pixmap: Pixmap, xHotspot: Int, yHotSpot: Int) : Disposable

expect class Cursor(pixmap: Pixmap, xHotspot: Int = 0, yHotSpot: Int = 0) : Disposable

actual class Cursor(val pixmap: Pixmap, val xHotspot: Int, val yHotSpot: Int) : Disposable

Fonts

object Fonts

An object that contains a bunch of common fonts that are used across LittleKt.

FrameBuffer

class FrameBuffer(val width: Int, val height: Int, val hasDepth: Boolean = false, val hasStencil: Boolean = false, var hasPackedDepthStencil: Boolean = false, val format: Pixmap.Format = Pixmap.Format.RGBA8888, val minFilter: TexMinFilter = TexMinFilter.LINEAR, val magFilter: TexMagFilter = TexMagFilter.LINEAR) : Preparable, Disposable

Encapsulates OpenGL frame buffer objects.

interface GL

GLVersion

class GLVersion(val platform: Context.Platform, version: String = "0.0", val vendor: String = "N/A", val renderer: String = "N/A")

IndexBufferObject

class IndexBufferObject(val gl: GL, val isStatic: Boolean = true, var buffer: ShortBuffer) : Disposable

Mesh

class Mesh(val gl: GL, val geometry: MeshGeometry, var autoBind: Boolean = true) : Disposable

MutableColor

open class MutableColor(r: Float, g: Float, b: Float, a: Float) : Color

OrthographicCamera

open class OrthographicCamera(virtualWidth: Float = 0.0f, virtualHeight: Float = 0.0f) : Camera

PerspectiveCamera

open class PerspectiveCamera(virtualWidth: Float = 0.0f, virtualHeight: Float = 0.0f) : Camera

Pixmap

class Pixmap(val width: Int, val height: Int, val pixels: ByteBuffer = createByteBuffer(width * height * 4))

PixmapSlice

data class PixmapSlice(val pixmap: Pixmap, val x: Int = 0, val y: Int = 0, val width: Int = pixmap.width, val height: Int = pixmap.height)

A rectangular slice of a pixmap.

Preparable

interface Preparable

SystemCursor

enum SystemCursor : Enum<SystemCursor>

Texture

class Texture(val textureData: TextureData) : Preparable, Disposable

TextureData

interface TextureData

Textures

object Textures

An object that contains a bunch of common texture slices that can be used to prevent texture switches.

VertexAttribute

data class VertexAttribute(val usage: VertexAttrUsage, val numComponents: Int, val alias: String, val type: VertexAttrType = if (usage == VertexAttrUsage.COLOR_PACKED) VertexAttrType.UNSIGNED_BYTE else VertexAttrType.FLOAT, val normalized: Boolean = usage == VertexAttrUsage.COLOR_PACKED, val unit: Int = 0, val asInt: Boolean = false)

VertexAttributes

class VertexAttributes(attributes: List<VertexAttribute>) : Iterable<VertexAttribute> , Comparable<VertexAttributes>

VertexAttrUsage

@JvmInline

value class VertexAttrUsage(val usage: Int)

VertexBufferObject

class VertexBufferObject(val gl: GL, val isStatic: Boolean, val attributes: VertexAttributes, var buffer: FloatBuffer) : Disposable

Functions

abgr

fun Color.abgr(): Int

addBorderToSlices

fun Pixmap.addBorderToSlices(context: Context, sliceWidth: Int, sliceHeight: Int, border: Int = 1, mipmaps: Boolean = false): Texture

Slice up the pixmap with the given size with an added border but returns the newly created Texture. This can be used to prevent atlas bleeding.

fun Texture.addBorderToSlices(context: Context, sliceWidth: Int, sliceHeight: Int, border: Int = 1, mipmaps: Boolean = false): Texture

Slice up the texture with the given size with an added border but returns the newly created Texture. This can be used to prevent atlas bleeding.

colorMesh

fun <T : ContextListener> T.colorMesh(size: Int = 1000, grow: Boolean = false, generate: Mesh.() -> Unit): Mesh

Creates a mesh with VertexAttribute.POSITION_2D and VertexAttribute.COLOR_UNPACKED attributes.

fun colorMesh(gl: GL, size: Int = 1000, grow: Boolean = false, generate: Mesh.() -> Unit): Mesh

Creates a mesh with VertexAttribute.POSITION_2D and VertexAttribute.COLOR_PACKED attributes.

colorMeshUnpacked

fun <T : ContextListener> T.colorMeshUnpacked(size: Int = 1000, grow: Boolean = false, generate: Mesh.() -> Unit): Mesh

fun colorMeshUnpacked(gl: GL, size: Int = 1000, grow: Boolean = false, generate: Mesh.() -> Unit): Mesh

Creates a mesh with VertexAttribute.POSITION_2D and VertexAttribute.COLOR_UNPACKED attributes.

generateMipMap

fun <T : TextureData> T.generateMipMap(context: Context, target: TextureTarget, pixmap: Pixmap, width: Int, height: Int, useHWMipMap: Boolean = true)

mesh

fun <T : ContextListener> T.mesh(attributes: List<VertexAttribute>, size: Int = 1000, grow: Boolean = false, generate: Mesh.() -> Unit): Mesh

inline fun mesh(gl: GL, attributes: List<VertexAttribute>, size: Int = 1000, grow: Boolean = false, generate: Mesh.() -> Unit): Mesh

positionMesh

fun positionMesh(gl: GL, size: Int = 1000, grow: Boolean = false, generate: Mesh.() -> Unit): Mesh

rgba

fun Color.rgba(): Int

slice

fun Texture.slice(): TextureSlice

fun Pixmap.slice(sliceWidth: Int, sliceHeight: Int): Array<Array<PixmapSlice>>

fun Texture.slice(sliceWidth: Int, sliceHeight: Int): Array<Array<TextureSlice>>

sliceWithBorder

fun Pixmap.sliceWithBorder(context: Context, sliceWidth: Int, sliceHeight: Int, border: Int = 1, mipmaps: Boolean = false): List<TextureSlice>

fun Texture.sliceWithBorder(context: Context, sliceWidth: Int, sliceHeight: Int, border: Int = 1, mipmaps: Boolean = false): List<TextureSlice>

Slice up the texture in a list of TextureSlice with the given size with an added border. This can be used to prevent atlas bleeding.

textureMesh

fun <T : ContextListener> T.textureMesh(size: Int = 1000, grow: Boolean = false, generate: Mesh.() -> Unit): Mesh

fun textureMesh(gl: GL, size: Int = 1000, grow: Boolean = false, generate: Mesh.() -> Unit): Mesh

Creates a mesh with VertexAttribute.POSITION_2D, VertexAttribute.COLOR_PACKED, and VertexAttribute.TEX_COORDS attributes.

toAgbr8888

fun Color.toAgbr8888(): Int

toFloatBits

fun Color.toFloatBits(): Float

Packs the color components into a 32-bit integer with the format ABGR and then converts it to a float. Alpha is compressed from 0-255 to use only even numbers between 0-254 to avoid using float bits in the NaN range. Converting a color to a float and back can be lossy for alpha.

toRgba8888

fun Color.toRgba8888(): Int

uploadImageData

fun <T : TextureData> T.uploadImageData(context: Context, target: TextureTarget, data: TextureData, mipLevel: Int = 0)