Index

Modules: application, atlases, camera, chunks, clock, exceptions, generators, magic, meta, namedatlases, packs, resources, scenes, settings, textures, tilemap, tilesets, utils.

API symbols

`()`:

generators : `()`[T](gen: Generator[T]; x, y: int; noise = - 1.0'f64): T

aggregate:

magic : aggregate(type_name: expr; component_list: expr): stmt

App:

application : App

AppObj:

application : AppObj

AppSettings:

application : AppSettings

asTuple:

meta : asTuple(type_name: TypeName): tuple[name, params: NimNode]

Atlas:

atlases : Atlas

AtlasInfo:

atlases : AtlasInfo

AtlasManager:

atlases : AtlasManager

attach:

camera : attach[T](camera: Camera[T]; map: Tilemap[T]; focus: Point = (0, 0))

Camera:

camera : Camera

Chunk:

chunks : Chunk

chunkPosition:

tilemap : chunkPosition[Tilemap](tm: Tilemap; x, y: int): Point

cint2int:

utils : cint2int(x: cint): int

clear:

application : clear(app: App; r, g, b: uint8)

Clock:

clock : Clock

contains:

textures : contains(tm: TextureManager; name: string): bool

DadrenError:

exceptions : DadrenError

destroy:

resources : destroy(rm: ResourceManager)
textures : destroy(tm: TextureManager)

draw:

scenes : draw(self: Scene)

enter:

scenes : enter(self: Scene)

exported:

meta : exported(name: string): Name

Field:

meta : Field

Generator:

generators : Generator

GeneratorType:

generators : GeneratorType

get:

atlases : get(am: AtlasManager; name: string): Atlas
namedatlases : get(tmm: NamedAtlasManager; name: string): NamedAtlas
textures : get(tm: TextureManager; name: string): Texture
tilesets : get[](tm: TilesetManager; name): Tileset

getLogicalSize:

application : getLogicalSize(app: App): Size

getNameIndex:

namedatlases : getNameIndex(atlas: NamedAtlas; name: string): int

getTile:

tilemap : getTile[Tilemap](tm: Tilemap; x, y: int): Tile

handle:

scenes : handle(self: Scene; event: Event)

int2cint:

utils : int2cint(x: int): cint

int2uint:

utils : int2uint(x: int): uint

InvalidResourceError:

exceptions : InvalidResourceError

leave:

scenes : leave(self: Scene)

load:

atlases : load(am: AtlasManager; name, filename: string; width, height: int; description: string = nil; authors: seq[string] = nil): Atlas
namedatlases : load(tmm: NamedAtlasManager; name, filename: string; width, height: int; names: seq[string]; description: string = nil; authors: seq[string] = nil): NamedAtlas
textures : load(tm: TextureManager; name, filename: string; description: string = nil; authors: seq[string] = nil): Texture

loadPack:

atlases : loadPack(am: AtlasManager; filename: string)
namedatlases : loadPack(tsm: NamedAtlasManager; filename: string)
packs : loadPack(filename: string): ResourcePack
textures : loadPack(tm: TextureManager; filename: string)
tilesets : loadPack(tm: TilesetManager; filename: string)

loadSettings:

settings : loadSettings[T](filename: string): T

makeChunk:

tilemap : makeChunk[T](map: Tilemap[T]; pos: Point; size: Size): Chunk

merge:

utils : merge[K, V](d1: var Table[K, V]; d2: Table[K, V])

move:

camera : move[T](camera: Camera[T]; x, y: int)

Name:

meta : Name

NamedAtlas:

namedatlases : NamedAtlas

NamedAtlasInfo:

namedatlases : NamedAtlasInfo

NamedAtlasManager:

namedatlases : NamedAtlasManager

newAliasDesc:

meta : newAliasDesc(alias: TypeDesc): Desc

newApp:

application : newApp(settings: AppSettings): App
application : newApp(width, height: int; title: string; scale = 1.0'f64; vsync = true; accelerated = true): App

newAtlasManager:

atlases : newAtlasManager(window: WindowPtr; display: RendererPtr): AtlasManager

newBillowGenerator:

generators : newBillowGenerator[T](generators: seq[Generator[T]]; scale = 1.0'f64; jitter = 0.0'f64): Generator[T]

newBitonalGenerator:

generators : newBitonalGenerator[T](a, b: Generator[T]; scale = 1.0'f64): Generator[T]

newCamera:

camera : newCamera[T](position: Point; size: Size; tileset: Tileset): Camera[T]

newChunk:

chunks : newChunk(): Chunk

newClock:

clock : newClock(step: float): Clock

newEnumDesc:

meta : newEnumDesc(values: seq[Name]): Desc

newField:

meta : newField(name: Name; type_desc: TypeDesc): Field
meta : newField(name: string; type_name: string; is_ref: bool = false): Field

newIdentifier:

meta : newIdentifier(name: Name; type_desc: ref TypeDesc = nil; default: ref NimNode = nil): Identifier

newInheritedDesc:

meta : newInheritedDesc(fields: seq[Field]; inherits: TypeName): Desc

newName:

meta : newName(value: string; exported: bool = false): Name

newNamedAtlasManager:

namedatlases : newNamedAtlasManager(window: WindowPtr; display: RendererPtr): NamedAtlasManager

newRandomGenerator:

generators : newRandomGenerator[T](values: seq[Generator[T]]): Generator[T]

newRangedGenerator:

generators : newRangedGenerator[T](ranges: seq[(int, Generator[T])]; scale = 1.0'f64; jitter = 0.0'f64; child = false): Generator[T]

newResourceManager:

resources : newResourceManager(window: WindowPtr; display: RendererPtr): ResourceManager

newSceneManager:

scenes : newSceneManager(first_scene: Scene = nil): SceneManager

newSeqDesc:

meta : newSeqDesc(type_name: string): TypeDesc
meta : newSeqDesc(type_name: TypeName): TypeDesc

newStaticGenerator:

generators : newStaticGenerator[T](value: T): Generator[T]

newStructDesc:

meta : newStructDesc(fields: seq[Field]): Desc

newTextureManager:

textures : newTextureManager(window: WindowPtr; display: RendererPtr): TextureManager

newTilemap:

tilemap : newTilemap[T](chunk_size: Size; generator: Generator[T]): Tilemap[T]

newTilesetManager:

tilesets : newTilesetManager(window: WindowPtr; display: RendererPtr): TilesetManager

newTupleDesc:

meta : newTupleDesc(fields: seq[Field]): Desc

newTypeDef:

meta : newTypeDef(type_name: TypeName; desc: Desc; is_ref: bool = false): TypeDef

newTypeDesc:

meta : newTypeDesc(identifiers: seq[Field]; is_ref: bool = false): TypeDesc
meta : newTypeDesc(type_name: string; is_ref: bool = false): TypeDesc
meta : newTypeDesc(type_name: TypeName; is_ref: bool = false): TypeDesc

newTypeName:

meta : newTypeName(name: Name): TypeName
meta : newTypeName(name: Name; parameters: seq[TypeDesc]): TypeName
meta : newTypeName(name: Name; parameters: seq[TypeName]): TypeName
meta : newTypeName(name: string): TypeName

newVariantDesc:

meta : newVariantDesc(discriminator: Field; variants: Table[Name, seq[Field]]): Desc

newWeightedGenerator:

generators : newWeightedGenerator[T](choices: seq[(int, Generator[T])]): Generator[T]

NoiseGenerator:

generators : NoiseGenerator[T](cb: proc (x, y: int; noise: float): T): Generator[T]

NoSuchResourceError:

exceptions : NoSuchResourceError

Point:

utils : Point

Region:

utils : Region

render:

atlases : render(display: RendererPtr; atlas: Atlas; n, dx, dy: int)
atlases : render(display: RendererPtr; atlas: Atlas; rx, ry, dx, dy: int)
camera : render[T](camera: Camera[T]; display: RendererPtr)
meta : render(desc: Desc): NimNode
meta : render(field: Field): NimNode
meta : render(identifier: Identifier): NimNode
meta : render(name: Name): NimNode
meta : render(typedef: TypeDef): NimNode
meta : render(type_desc: TypeDesc): NimNode
meta : render(type_name: TypeName): NimNode
namedatlases : render(display: RendererPtr; atlas: NamedAtlas; name: string; dx, dy: int)
textures : render(display: RendererPtr; texture: Texture; x, y: int)
textures : render(display: RendererPtr; texture: Texture; sx, sy, dx, dy, width, height: int)
tilesets : render(display: RendererPtr; tileset: Tileset; name: string; dx, dy: int)

Resolution:

utils : Resolution

ResourceError:

exceptions : ResourceError

ResourceManager:

resources : ResourceManager

ResourcePack:

packs : ResourcePack

run:

application : run(app: App; first_scene: Scene)

Scene:

scenes : Scene

SceneManager:

scenes : SceneManager

set_scene:

scenes : set_scene(sm: SceneManager; scene: Scene)

SimpleGenerator:

generators : SimpleGenerator[T](cb: proc (x, y: int): T): Generator[T]

Size:

utils : Size

Texture:

textures : Texture

TextureInfo:

textures : TextureInfo

TextureManager:

textures : TextureManager

tick:

clock : tick(clock: Clock)

Tile:

chunks : Tile

Tilemap:

tilemap : Tilemap

tile_name:

chunks : tile_name(t: Tile): string

Tileset:

tilesets : Tileset

TilesetAtlasInfo:

tilesets : TilesetAtlasInfo

TilesetManager:

tilesets : TilesetManager

to_enum_name:

magic : to_enum_name(name: string): string

to_field_name:

magic : to_field_name(name: string): string

to_manager_name:

magic : to_manager_name(name: string): string

toName:

meta : toName(s: string): Name

to_object_name:

magic : to_object_name(name: string): string

to_table_name:

magic : to_table_name(name: string): string

to_value_name:

magic : to_value_name(a, b: string): string

TypeDesc:

meta : TypeDesc

TypeName:

meta : TypeName

uint2int:

utils : uint2int(x: uint): int

update:

scenes : update(self: Scene; t, dt: float)

weighted_choice:

utils : weighted_choice[T](options: seq[(int, T)]; rng: var MersenneTwister = mersenneTwisterInst): T

weighted_selection:

utils : weighted_selection[T](options: seq[(int, T)]; selection: float): T