Index

Modules: necsus, necsus/compiletime/archetype, necsus/compiletime/archetypeBuilder, necsus/compiletime/attachDetachGen, necsus/compiletime/bundleGen, necsus/compiletime/codeGenInfo, necsus/compiletime/common, necsus/compiletime/componentDef, necsus/compiletime/converters, necsus/compiletime/debugGen, necsus/compiletime/deleteGen, necsus/compiletime/directiveArg, necsus/compiletime/directiveSet, necsus/compiletime/dualDirective, necsus/compiletime/eventGen, necsus/compiletime/localGen, necsus/compiletime/lookupGen, necsus/compiletime/marshalGen, necsus/compiletime/monoDirective, necsus/compiletime/parse, necsus/compiletime/queryGen, necsus/compiletime/restoreGen, necsus/compiletime/saveGen, necsus/compiletime/sendGen, necsus/compiletime/sharedGen, necsus/compiletime/spawnGen, necsus/compiletime/systemGen, necsus/compiletime/tickGen, necsus/compiletime/tickIdGen, necsus/compiletime/timeGen, necsus/compiletime/tools, necsus/compiletime/tupleDirective, necsus/compiletime/worldGen, necsus/runtime/archetypeStore, necsus/runtime/directives, necsus/runtime/entityId, necsus/runtime/inbox, necsus/runtime/necsusConf, necsus/runtime/pragmas, necsus/runtime/query, necsus/runtime/spawn, necsus/runtime/systemVar, necsus/runtime/tuples, necsus/runtime/world, necsus/util/bits, necsus/util/blockstore, necsus/util/dump, necsus/util/nimNode, necsus/util/profile, necsus/util/tools, necsus/util/typeReader.

API symbols

`$`:

• archetype: proc `$`[T](archetype: Archetype[T]): string
• componentDef: proc `$`(def: ComponentDef): string
• directiveArg: proc `$`(arg: DirectiveArg): string
• directiveSet: proc `$`[T](directives: DirectiveSet[T]): string
• dualDirective: proc `$`(dir: DualDirective): string
• monoDirective: proc `$`(dir: MonoDirective): string
• parse: proc `$`(check: ActiveCheck): string
• parse: proc `$`(system: ParsedSystem): string
• systemGen: proc `$`(arg: SystemArg): string
• tupleDirective: proc `$`(dir: TupleDirective): string
• entityId: proc `$`(entityId: EntityId): string
• systemVar: proc `$`[T](sysvar: SystemVar[T]): string
• bits: proc `$`(bitset: Bits): string

`()`:

• directives: proc `()`[T](comp: CallbackDir[Arity0Proc[T]]): T
• directives: proc `()`[A, T](comp: CallbackDir[Arity1Proc[A, T]]; a: A): T
• directives: proc `()`[A, B, T](comp: CallbackDir[Arity2Proc[A, B, T]]; a: A; b: B): T
• directives: proc `()`[C](lookup: Lookup[C]; entityId: EntityId): Option[C]
• directives: proc `()`[T](outbox: Outbox[T]; message: T)
• directives: proc `()`(restore: Restore; value: string)
• directives: proc `()`(save: Save): string

`+=`:

• bits: proc `+=`(a: var Bits; b: Bits)

`+`:

• bits: proc `+`(a, b: Bits): Bits

`-`:

• bits: proc `-`(a, b: Bits): Bits

`:=`:

• systemVar: proc `:=`[T](sysvar: SystemVar[T]; value: sink T)

`<=`:

• bits: proc `<=`(a, b: Bits): bool

`<`:

• componentDef: proc `<`(a, b: ComponentDef): auto
• directiveArg: proc `<`(a, b: DirectiveArg): auto
• tupleDirective: proc `<`(a, b: TupleDirective): auto
• bits: proc `<`(a, b: Bits): bool

`==`:

• archetype: proc `==`[T](a, b: Archetype[T]): bool
• archetypeBuilder: proc `==`(a, b: BuilderAction): bool
• componentDef: proc `==`(a, b: ComponentDef): bool
• directiveArg: proc `==`(a, b: DirectiveArg): auto
• monoDirective: proc `==`(a, b: MonoDirective): bool
• systemGen: proc `==`(a, b: DirectiveGen): bool
• systemGen: proc `==`(a, b: SystemArg): bool
• tupleDirective: proc `==`(a, b: TupleDirective): auto
• entityId: proc `==`(a, b: EntityId): bool
• systemVar: proc `==`[T](sysvar: SystemVar[T]; value: T): bool
• bits: proc `==`(a, b: Bits): bool

`=copy`:

• archetypeStore: proc `=copy`[Comps: tuple](target: var ArchetypeStore[Comps]; source: ArchetypeStore[Comps])
• archetypeStore: proc `=copy`[Comps: tuple](target: var ArchRow[Comps]; source: ArchRow[Comps])

`>`:

• bits: proc `>`(a, b: Bits): bool

`[]=`:

• blockstore: template `[]=`[V](store: BlockStore[V]; idx: uint; newValue: V)

`[]`:

• world: proc `[]`(world: World; entityId: EntityId): ptr EntityIndex
• blockstore: proc `[]`[V](store: BlockStore[V]; idx: uint): var V

`as`:

• tuples: proc `as`[T: tuple](value: T; typ: typedesc): T

`from`:

• systemVar: template `from`[T](variable: untyped; source: SystemVar[T]): bool

`type`:

• directiveArg: proc `type`(def: DirectiveArg): NimNode

`~`:

• necsus: proc `~`(system: proc): SystemFlag

accessory:

• archetypeBuilder: proc accessory[T](builder: var ArchetypeBuilder[T]; value: T)
• pragmas: template accessory()

active:

• pragmas: template active(states: varargs[typed])

ActiveCheck:

• parse: type ActiveCheck

addActiveChecks:

• tickGen: proc addActiveChecks(invocation: NimNode; codeGenInfo: CodeGenInfo; checks: seq[ActiveCheck]; phase: SystemPhase): NimNode

addLen:

• archetypeStore: proc addLen[Comps: tuple](store: var ArchetypeStore[Comps]; len: var uint)
• archetypeStore: proc addLen[Comps: tuple](store: var ArchetypeStore[Comps]; len: var uint; predicate: proc ( row: var Comps): bool {.nimcall, gcsafe, raises: [].})

addSignature:

• componentDef: proc addSignature(onto: var string; comp: ComponentDef)
• directiveArg: proc addSignature(onto: var string; arg: DirectiveArg)
• nimNode: proc addSignature(onto: var string; comp: NimNode)

AfterActiveCheck:

• systemGen: GenerateHook.AfterActiveCheck

allArgs:

• codeGenInfo: iterator allArgs(genInfo: CodeGenInfo): SystemArg
• parse: iterator allArgs(system: ParsedSystem): SystemArg
• systemGen: iterator allArgs(args: openArray[SystemArg]): SystemArg

allComponents:

• archetypeBuilder: iterator allComponents[T](builder: ArchetypeBuilder[T]): T

anyIntersect:

• bits: proc anyIntersect(a, b: Bits): bool

AnyQuery:

• query: type AnyQuery

AppInputs:

• systemGen: type AppInputs

appStateIdent:

• common: let appStateIdent

appStateInit:

• codeGenInfo: proc appStateInit(genInfo: CodeGenInfo): NimNode

appStatePtr:

• common: let appStatePtr

appStateTypeName:

• codeGenInfo: proc appStateTypeName(genInfo: CodeGenInfo): NimNode

archArchSymbolDef:

• archetype: proc archArchSymbolDef[T](archetype: Archetype[T]): NimNode

Archetype:

• archetype: type Archetype

ArchetypeBuilder:

• archetypeBuilder: type ArchetypeBuilder

archetypeCases:

• tools: iterator archetypeCases(details: GenerateContext): tuple[ofBranch: NimNode, archetype: Archetype[ComponentDef]]

archetypeFor:

• archetype: proc archetypeFor[T](archs: ArchetypeSet[T]; components: openArray[T]): Archetype[T]
• systemGen: proc archetypeFor(ctx: GenerateContext; components: openArray[ComponentDef]): Archetype[ ComponentDef]
• systemGen: proc archetypeFor(ctx: GenerateContext; dir: TupleDirective): Archetype[ComponentDef]

ArchetypeId:

• world: type ArchetypeId

ArchetypeSet:

• archetype: type ArchetypeSet

ArchetypeStore:

• archetypeStore: object ArchetypeStore

ArchRow:

• archetypeStore: object ArchRow

args:

• parse: iterator args(systems: openArray[ParsedSystem]): SystemArg
• tupleDirective: iterator args(directive: TupleDirective): DirectiveArg

asFullQuery:

• query: proc asFullQuery[Comps](rawQuery: RawQuery[Comps]): FullQuery[Comps]

asFullSpawn:

• spawn: proc asFullSpawn[Comps](rawSpawn: RawSpawn[Comps]): FullSpawn[Comps]

asQuery:

• query: proc asQuery[Comps](rawQuery: RawQuery[Comps]): Query[Comps]

asSpawn:

• spawn: proc asSpawn[Comps](rawSpawn: RawSpawn[Comps]): Spawn[Comps]

asStorageTuple:

• archetype: proc asStorageTuple(archetype: Archetype[ComponentDef]): NimNode

asTupleDir:

• archetype: proc asTupleDir(arch: Archetype[ComponentDef]): TupleDirective

asTupleType:

• tools: proc asTupleType(components: openArray[ComponentDef]): NimNode
• tools: proc asTupleType(args: openArray[DirectiveArg]): NimNode
• tools: proc asTupleType(tupleDir: TupleDirective): NimNode

Attach:

• directives: type Attach

attachable:

• archetypeBuilder: proc attachable[T](builder: var ArchetypeBuilder[T]; values: openArray[T]; filter: BitsFilter)

attachDetach:

• archetypeBuilder: proc attachDetach[T](builder: var ArchetypeBuilder[T]; attach: openArray[T]; detach: openArray[T]; optDetach: openArray[T] = []; filter: BitsFilter = builder.filter([], []))

attachGenerator:

• attachDetachGen: let attachGenerator

BeforeLoop:

• systemGen: GenerateHook.BeforeLoop

beginSpawn:

• spawn: proc beginSpawn[Comps: tuple](world: var World; store: ptr ArchetypeStore[Comps]): NewArchSlot[ Comps]

bits:

• tupleDirective: proc bits(dir: TupleDirective): Bits

Bits:

• bits: type Bits

BitsFilter:

• bits: type BitsFilter

BlockIter:

• blockstore: object BlockIter

BlockStore:

• blockstore: type BlockStore

both:

• tools: iterator both(a, b: auto): auto

build:

• archetypeBuilder: proc build[T](builder: ArchetypeBuilder[T]): ArchetypeSet[T]
• converters: proc build(adapter: TupleAdapter): NimNode

BuildArchetype:

• systemGen: type BuildArchetype

buildArchetype:

• systemGen: proc buildArchetype(builder: var ArchetypeBuilder[ComponentDef]; systemArgs: seq[SystemArg]; arg: SystemArg)

buildConverter:

• converters: proc buildConverter(convert: ConverterDef): NimNode

Bundle:

• directives: type Bundle

bundleGenerator:

• bundleGen: let bundleGenerator

calculateSize:

• archetype: proc calculateSize(arch: Archetype[ComponentDef]): Option[NimNode]

callbackSysMailboxName:

• parse: proc callbackSysMailboxName(system: ParsedSystem): NimNode

callbackSysType:

• parse: proc callbackSysType(system: ParsedSystem): NimNode

callSystems:

• tickGen: proc callSystems(codeGenInfo: CodeGenInfo; phases: set[SystemPhase]): NimNode

card:

• bits: proc card(bitset: Bits): int

clear:

• systemVar: proc clear[T](sysvar: SystemVar[T])

cmp:

• nimNode: proc cmp(a: NimNode; b: NimNode): int

CodeGenInfo:

• codeGenInfo: type CodeGenInfo

commit:

• blockstore: proc commit[V](entry: Entry[V])

ComponentDef:

• componentDef: type ComponentDef

components:

• parse: iterator components(systems: openArray[ParsedSystem]): ComponentDef
• parse: iterator components(app: ParsedApp): ComponentDef
• parse: iterator components(arg: SystemArg): ComponentDef

comps:

• directiveArg: proc comps(args: openArray[DirectiveArg]): seq[ComponentDef]
• tupleDirective: proc comps(directive: TupleDirective): seq[ComponentDef]

confIdent:

• common: let confIdent

containing:

• directiveSet: proc containing(queries: DirectiveSet[TupleDirective]; components: openArray[ComponentDef]): seq[TupleDirective]

contains:

• archetype: proc contains[T](archetype: Archetype[T]; value: T): bool
• archetype: proc contains[T](archetypes: ArchetypeSet[T]; archetype: Archetype[T]): bool
• tupleDirective: proc contains(directive: TupleDirective; comp: ComponentDef): bool
• bits: proc contains(bitset: Bits; value: uint16): bool

containsAllOf:

• archetype: proc containsAllOf[T](archetype: Archetype[T]; others: openArray[T]): bool

containsAnyOf:

• archetype: proc containsAnyOf[T](archetype: Archetype[T]; others: openArray[T]): bool

ConverterDef:

• systemGen: type ConverterDef

converters:

• systemGen: proc converters(ctx: GenerateContext; arg: SystemArg): seq[ConverterDef]

ConvertExtractor:

• systemGen: type ConvertExtractor

createAppReturn:

• worldGen: proc createAppReturn(genInfo: CodeGenInfo; errorLocation: NimNode): NimNode

createAppStateDestructor:

• worldGen: proc createAppStateDestructor(genInfo: CodeGenInfo): NimNode

createAppStateInit:

• worldGen: proc createAppStateInit(genInfo: CodeGenInfo): NimNode

createAppStateInstance:

• worldGen: proc createAppStateInstance(genInfo: CodeGenInfo): NimNode

createAppStateType:

• worldGen: proc createAppStateType(genInfo: CodeGenInfo): NimNode

createArchetypeIdSyms:

• worldGen: proc createArchetypeIdSyms(details: CodeGenInfo): NimNode

createConverterProcs:

• worldGen: proc createConverterProcs(details: CodeGenInfo): NimNode

createMarshalProcs:

• marshalGen: proc createMarshalProcs(genInfo: CodeGenInfo): NimNode

createSendProcs:

• sendGen: proc createSendProcs(details: CodeGenInfo): NimNode

createTickProc:

• tickGen: proc createTickProc(genInfo: CodeGenInfo): NimNode

createTickRunner:

• tickGen: proc createTickRunner(genInfo: CodeGenInfo; runner: NimNode): NimNode

define:

• archetypeBuilder: proc define[T](builder: var ArchetypeBuilder[T]; values: openArray[T])

del:

• archetypeStore: proc del(store: var ArchetypeStore; index: uint)
• world: proc del(world: var World; entityId: EntityId): Option[EntityIndex]
• blockstore: proc del[V](store: var BlockStore[V]; idx: uint): V

Delete:

• directives: type Delete

DeleteAll:

• directives: type DeleteAll

deleteAllGenerator:

• deleteGen: let deleteAllGenerator

deleteGenerator:

• deleteGen: let deleteGenerator

deltaGenerator:

• timeGen: let deltaGenerator

depends:

• pragmas: template depends(dependencies: varargs[typed])

destroySystems:

• tickGen: proc destroySystems(codeGenInfo: CodeGenInfo): NimNode

Detach:

• directives: type Detach

detachable:

• archetypeBuilder: proc detachable[T](builder: var ArchetypeBuilder[T]; values: openArray[T]; optional: openArray[T] = [])

detachGenerator:

• attachDetachGen: let detachGenerator

DirectiveArg:

• directiveArg: type DirectiveArg

DirectiveArgKind:

• directiveArg: enum DirectiveArgKind

DirectiveGen:

• systemGen: type DirectiveGen

DirectiveKind:

• systemGen: enum DirectiveKind

directives:

• directiveSet: proc directives[T](directives: DirectiveSet[T]): seq[T]

DirectiveSet:

• directiveSet: type DirectiveSet

DualDirective:

• dualDirective: type DualDirective

dumpAnalysis:

• archetype: proc dumpAnalysis[T](archetypes: ArchetypeSet[T])

dumpGeneratedCode:

• dump: proc dumpGeneratedCode(output: NimNode; app: ParsedApp; systems: openArray[ParsedSystem])

elapsedGenerator:

• timeGen: let elapsedGenerator

emitEntityTrace:

• tools: proc emitEntityTrace(args: varargs[NimNode, loggable]): NimNode

emitEventTrace:

• tools: proc emitEventTrace(args: varargs[NimNode, loggable]): NimNode

emitLog:

• tools: proc emitLog(args: varargs[NimNode, loggable]): NimNode

emitQueryTrace:

• tools: proc emitQueryTrace(args: varargs[NimNode, loggable]): NimNode

emitSaveTrace:

• tools: proc emitSaveTrace(args: varargs[NimNode, loggable]): NimNode

ensureAlloced:

• archetypeStore: proc ensureAlloced[Comps: tuple](store: var ArchetypeStore[Comps])

EntityDebug:

• directives: type EntityDebug

entityDebugGenerator:

• debugGen: let entityDebugGenerator

entityId:

• archetypeStore: proc entityId[Comps: tuple](entry: NewArchSlot[Comps]): EntityId

EntityId:

• entityId: type EntityId

entityId:

• world: proc entityId(newEntity: NewEntity): EntityId

entityIds:

• archetypeStore: iterator entityIds[Comps](store: var ArchetypeStore[Comps]): EntityId

EntityIndex:

• world: object EntityIndex

Entry:

• blockstore: type Entry

EventCallback:

• parse: SystemPhase.EventCallback

eventSys:

• pragmas: template eventSys()

EventSystemInstance:

• directives: type EventSystemInstance

Exclude:

• directiveArg: DirectiveArgKind.Exclude

exec:

• directives: proc exec[A](comp: CallbackDir[Arity1Proc[A, void]]; a: A)
• directives: proc exec[A, B](comp: CallbackDir[Arity2Proc[A, B, void]]; a: A; b: B)
• directives: proc exec[T](outbox: Outbox[T]; message: T)

ExitLoop:

• necsus: NecsusRun.ExitLoop

extend:

• tuples: macro extend(tuples: varargs[typed]): typedesc

filter:

• archetypeBuilder: proc filter[T](builder: var ArchetypeBuilder[T]; mustContain: openArray[T]; mustExclude: openArray[T]): BitsFilter
• tupleDirective: proc filter(dir: TupleDirective): BitsFilter

findChildSyms:

• typeReader: proc findChildSyms(node: NimNode; output: var seq[NimNode])

findPragma:

• typeReader: proc findPragma(node: NimNode): NimNode

findSym:

• typeReader: proc findSym(node: NimNode): NimNode

FullQuery:

• query: type FullQuery

fullQueryGenerator:

• queryGen: let fullQueryGenerator

FullSpawn:

• spawn: type FullSpawn

fullSpawnGenerator:

• spawnGen: let fullSpawnGenerator

gameLoop:

• necsus: proc gameLoop(exit: Shared[NecsusRun]; tick: proc (): void)

GenerateContext:

• systemGen: type GenerateContext

generateForHook:

• codeGenInfo: proc generateForHook(codeGen: CodeGenInfo; hook: GenerateHook): NimNode
• codeGenInfo: proc generateForHook(codeGen: CodeGenInfo; system: ParsedSystem; hook: GenerateHook): NimNode
• systemGen: proc generateForHook(arg: SystemArg; details: GenerateContext; name: string): NimNode

GenerateHook:

• systemGen: enum GenerateHook

generateName:

• componentDef: proc generateName(components: openArray[ComponentDef]): string
• directiveArg: proc generateName(args: openArray[DirectiveArg]): string
• systemGen: proc generateName(arg: SystemArg): string

get:

• directives: proc get[T](comp: CallbackDir[Arity0Proc[T]]): T
• directives: proc get[A, T](comp: CallbackDir[Arity1Proc[A, T]]; a: A): T
• directives: proc get[A, B, T](comp: CallbackDir[Arity2Proc[A, B, T]]; a: A; b: B): T
• directives: proc get[C](lookup: Lookup[C]; entityId: EntityId): Option[C]
• systemVar: proc get[T](sysvar: SystemVar[T]): T
• systemVar: proc get[T](sysvar: SystemVar[T]; default: T): T

getComps:

• archetypeStore: proc getComps[Comps: tuple](store: var ArchetypeStore[Comps]; index: uint): ptr Comps

getNewEntityId:

• world: proc getNewEntityId(world: var World): EntityId

getOrPut:

• systemVar: proc getOrPut[T](sysvar: SystemVar[T]): var T
• systemVar: template getOrPut[T](sysvar: SystemVar[T]; build: typed): var T

getOrRaise:

• systemVar: proc getOrRaise[T](sysvar: SystemVar[T]): var T

globalName:

• systemGen: proc globalName(ctx: GenerateContext; name: string): NimNode

globalStr:

• systemGen: proc globalStr(ctx: GenerateContext; name: string): string

hasAccessories:

• archetype: proc hasAccessories(arch: Archetype): bool
• tupleDirective: proc hasAccessories(dir: TupleDirective): bool

hash:

• archetype: proc hash[T](archetype: Archetype[T]): Hash
• archetypeBuilder: proc hash(action: BuilderAction): Hash
• componentDef: proc hash(def: ComponentDef): Hash
• directiveArg: proc hash(arg: DirectiveArg): Hash
• dualDirective: proc hash(directive: DualDirective): Hash
• monoDirective: proc hash(directive: MonoDirective): Hash
• systemGen: proc hash(gen: DirectiveGen): Hash
• systemGen: proc hash(arg: SystemArg): Hash
• tupleDirective: proc hash(directive: TupleDirective): Hash
• entityId: proc hash(entityId: EntityId): Hash
• bits: proc hash(bitset: Bits): Hash
• bits: proc hash(filter: BitsFilter): Hash
• nimNode: proc hash(node: NimNode): Hash

hasPragma:

• typeReader: proc hasPragma(node, pragma: NimNode): bool

HookGenerator:

• systemGen: type HookGenerator

ident:

• archetype: proc ident(archetype: Archetype[ComponentDef]): NimNode
• componentDef: proc ident(def: ComponentDef): NimNode

idSymbol:

• archetype: proc idSymbol[T](archetype: Archetype[T]): NimNode

Inbox:

• inbox: type Inbox

inboxGenerator:

• eventGen: let inboxGenerator

incGen:

• entityId: proc incGen(entityId: EntityId): EntityId

incl:

• bits: proc incl(bitset: var Bits; value: uint16)

Include:

• directiveArg: DirectiveArgKind.Include

index:

• archetypeStore: proc index[Comps: tuple](entry: NewArchSlot[Comps]): uint
• blockstore: proc index[V](entry: Entry[V]): uint

indexOf:

• archetype: proc indexOf[T](archetype: Archetype[T]; value: T): int
• tupleDirective: proc indexOf(directive: TupleDirective; comp: ComponentDef): int

IndirectEventCallback:

• parse: SystemPhase.IndirectEventCallback

initializeSystems:

• tickGen: proc initializeSystems(codeGenInfo: CodeGenInfo): NimNode

initInbox:

• eventGen: proc initInbox(name, typ: NimNode): NimNode

initIndirectEventInboxes:

• sendGen: proc initIndirectEventInboxes(details: CodeGenInfo): NimNode

instanced:

• pragmas: template instanced()

instancedInfo:

• parse: proc instancedInfo(system: ParsedSystem): Option[ tuple[fieldName: NimNode, typ: NimNode]]

invokeSystem:

• tickGen: proc invokeSystem(codeGenInfo: CodeGenInfo; system: ParsedSystem; phases: set[SystemPhase]; prefixArgs: openArray[NimNode] = []): NimNode

isAccessory:

• archetype: proc isAccessory[T](arch: Archetype[T]; value: T): bool
• directiveArg: proc isAccessory(arg: DirectiveArg): bool

isDone:

• blockstore: proc isDone(iter: BlockIter): bool

isEmpty:

• systemVar: proc isEmpty[T](sysvar: SystemVar[T]): bool

isFastCompileMode:

• common: template isFastCompileMode(title: untyped): bool

isFirst:

• blockstore: proc isFirst(iter: BlockIter): bool

isPragma:

• typeReader: proc isPragma(found, expect: NimNode): bool

isSinkMemoryCorruptionFixed:

• tools: proc isSinkMemoryCorruptionFixed(): bool

isSome:

• systemVar: proc isSome[T](sysvar: SystemVar[T]): bool

items:

• archetype: iterator items[T](archetype: Archetype[T]): T
• archetype: iterator items[T](archetypes: ArchetypeSet[T]): Archetype[T]
• dualDirective: iterator items(directive: DualDirective): ComponentDef
• tupleDirective: iterator items(directive: TupleDirective): ComponentDef
• inbox: iterator items[T](inbox: Inbox[T]): lent T
• query: iterator items[Comps: tuple](query: AnyQuery[Comps]): Comps
• systemVar: iterator items[T](sysvar: var SystemVar[T]): var T
• systemVar: iterator items[T](sysvar: SystemVar[T]): lent T
• bits: iterator items(bitset: Bits): uint16
• blockstore: iterator items[V](store: var BlockStore[V]): var V

join:

• tuples: macro join(exprs: varargs[typed]): untyped

joinStrs:

• tools: proc joinStrs(args: varargs[NimNode]): NimNode

kind:

• parse: proc kind(arg: SystemArg): auto

Late:

• systemGen: GenerateHook.Late

len:

• archetype: proc len[T](archetypes: ArchetypeSet[T]): int
• inbox: proc len[T](inbox: Inbox[T]): uint
• query: proc len[Comps: tuple](query: AnyQuery[Comps]): uint
• blockstore: proc len[V](blockstore: var BlockStore[V]): uint

lifecycle:

• common: let lifecycle

Local:

• systemVar: type Local

localGenerator:

• localGen: let localGenerator

LocalOrT:

• systemVar: type LocalOrT

loggable:

• tools: proc loggable(node: NimNode): NimNode
• tools: proc loggable(str: string): NimNode

Lookup:

• directives: type Lookup

lookupGenerator:

• lookupGen: let lookupGenerator

LoopEnd:

• systemGen: GenerateHook.LoopEnd

LoopPhase:

• parse: SystemPhase.LoopPhase

LoopStart:

• systemGen: GenerateHook.LoopStart

loopSys:

• pragmas: template loopSys()

matches:

• archetype: proc matches(arch: Archetype; filter: BitsFilter): bool
• bits: proc matches(filter: BitsFilter; all: Bits; optional: Bits = newBits()): bool

maxCapacity:

• componentDef: proc maxCapacity(errorSite: NimNode; components: auto): Option[NimNode]
• pragmas: template maxCapacity(capacity: Natural)

mentioning:

• directiveSet: proc mentioning(queries: DirectiveSet[TupleDirective]; components: openArray[ComponentDef]): seq[TupleDirective]

MonoDirective:

• monoDirective: type MonoDirective

moveEntity:

• archetypeStore: proc moveEntity[FromArch: tuple; NewComps: tuple; ToArch: tuple](world: var World; entityIndex: ptr EntityIndex; fromArch: var ArchetypeStore[FromArch]; toArch: var ArchetypeStore[ToArch]; newValues: sink NewComps; combine: proc ( existing: sink FromArch; newValues: sink NewComps; output: var ToArch): bool {. gcsafe, raises: [], nimcall.})

name:

• systemGen: proc name(convert: ConverterDef): NimNode

NameChooser:

• systemGen: type NameChooser

nameOf:

• codeGenInfo: proc nameOf(genInfo: CodeGenInfo; arg: SystemArg): string
• directiveSet: proc nameOf[T](directives: DirectiveSet[T]; value: T): string
• systemGen: proc nameOf(ctx: GenerateContext; arg: SystemArg): string

necsus:

• necsus: macro necsus(runner: typed{sym}; systems: openArray[SystemFlag]; conf: NecsusConf; pragmaProc: untyped)
• necsus: macro necsus(systems: openArray[SystemFlag]; conf: NecsusConf; pragmaProc: untyped)

NecsusConf:

• necsusConf: type NecsusConf

NecsusLogger:

• necsusConf: type NecsusLogger

NecsusRun:

• necsus: enum NecsusRun

NestedArgsExtractor:

• systemGen: type NestedArgsExtractor

newAdapter:

• converters: proc newAdapter(fromArch: Archetype[ComponentDef]; newVals: openArray[ComponentDef]; produce: DirectiveArg | ComponentDef; addingSource: NimNode = adding; existingSource: NimNode = input): TupleAdapter

newArchetype:

• archetype: proc newArchetype[T](values: openArray[T]; accessories: Bits): Archetype[T]

newArchetypeBuilder:

• archetypeBuilder: proc newArchetypeBuilder[T](): ArchetypeBuilder[T]

newArchetypeSet:

• archetype: proc newArchetypeSet[T](values: openArray[Archetype[T]]; accessories: Bits): ArchetypeSet[ T]

newArchetypeStore:

• archetypeStore: proc newArchetypeStore[Comps: tuple](archetype: ArchetypeId; initialSize: SomeInteger): ArchetypeStore[ Comps]

NewArchSlot:

• archetypeStore: type NewArchSlot

newBits:

• bits: proc newBits(values: varargs[uint16]): Bits

newBlockStore:

• blockstore: proc newBlockStore[V](size: SomeInteger): BlockStore[V]

newCallbackDir:

• directives: proc newCallbackDir[T: proc](appState: pointer; callback: T): CallbackDir[T]

newCodeGenInfo:

• codeGenInfo: proc newCodeGenInfo(config: NimNode; app: ParsedApp; allSystems: openArray[ParsedSystem]): CodeGenInfo

newComponentDef:

• componentDef: proc newComponentDef(node: NimNode): ComponentDef

newConverter:

• systemGen: proc newConverter(input: Archetype[ComponentDef]; adding: seq[ComponentDef]; output: Archetype[ComponentDef]; sinkParams: bool): ConverterDef
• systemGen: proc newConverter(input: Archetype[ComponentDef]; output: TupleDirective): ConverterDef

newDirectiveArg:

• directiveArg: proc newDirectiveArg(component: ComponentDef; isPointer: bool; kind: DirectiveArgKind): DirectiveArg

newDirectiveSet:

• directiveSet: proc newDirectiveSet[T](prefix: string; values: openArray[T]): DirectiveSet[T]

newDualDir:

• dualDirective: proc newDualDir(first: seq[DirectiveArg]; second: seq[DirectiveArg]): DualDirective

newEmptyApp:

• parse: proc newEmptyApp(name: string): ParsedApp

newEmptyCodeGenInfo:

• codeGenInfo: proc newEmptyCodeGenInfo(config: NimNode; app: ParsedApp): CodeGenInfo

NewEntity:

• world: type NewEntity

newEntity:

• world: proc newEntity(world: var World): NewEntity

newFilter:

• bits: proc newFilter(mustContain, mustExclude: Bits): BitsFilter

newGenerateContext:

• codeGenInfo: proc newGenerateContext(codeGen: CodeGenInfo; hook: GenerateHook): GenerateContext

newGenerator:

• systemGen: proc newGenerator(ident: string; interest: set[GenerateHook]; generate: HookGenerator[DualDirective]; archetype: BuildArchetype[DualDirective] = noArchetype; chooseName: NameChooser[DualDirective] = defaultName; worldFields: proc ( name: string; dir: DualDirective): seq[WorldField] = defaultWorldField; systemArg: SystemArgExtractor[DualDirective] = defaultSystemArg; nestedArgs: NestedArgsExtractor[DualDirective] = defaultNestedArgs; converters: ConvertExtractor[DualDirective] = defaultConverters): DirectiveGen
• systemGen: proc newGenerator(ident: string; interest: set[GenerateHook]; generate: HookGenerator[MonoDirective]; archetype: BuildArchetype[MonoDirective] = noArchetype; chooseName: NameChooser[MonoDirective] = defaultName; systemReturn: proc ( args: DirectiveSet[SystemArg]; returns: MonoDirective): Option[NimNode] = defaultSystemReturn; worldFields: proc (name: string; dir: MonoDirective): seq[WorldField] = defaultWorldField; systemArg: SystemArgExtractor[MonoDirective] = defaultSystemArg; nestedArgs: NestedArgsExtractor[MonoDirective] = defaultNestedArgs): DirectiveGen
• systemGen: proc newGenerator(ident: string; interest: set[GenerateHook]; generate: HookGenerator[TupleDirective]; archetype: BuildArchetype[TupleDirective] = noArchetype; chooseName: NameChooser[TupleDirective] = defaultName; worldFields: proc ( name: string; dir: TupleDirective): seq[WorldField] = defaultWorldField; systemArg: SystemArgExtractor[TupleDirective] = defaultSystemArg; nestedArgs: NestedArgsExtractor[TupleDirective] = defaultNestedArgs; converters: ConvertExtractor[TupleDirective] = defaultConverters): DirectiveGen
• systemGen: proc newGenerator(ident: string; interest: set[GenerateHook]; generate: HookGenerator[void]; worldFields: proc (name: string): seq[ WorldField] = defaultWorldFieldNone; systemArg: SystemArgExtractor[void] = defaultSystemArgNone): DirectiveGen

newMonoDir:

• monoDirective: proc newMonoDir(argType: NimNode): MonoDirective

newNecsusConf:

• necsusConf: proc newNecsusConf(entitySize: int = DEFAULT_ENTITY_COUNT; componentSize: int = ceilDiv(entitySize, 3); inboxSize: int = max(entitySize div 20, 20); eagerAlloc: bool = false): NecsusConf
• necsusConf: proc newNecsusConf(getTime: proc (): BiggestFloat {.gcsafe.}; log: NecsusLogger; eagerAlloc: bool = false): NecsusConf
• necsusConf: proc newNecsusConf(getTime: proc (): BiggestFloat {.gcsafe.}; log: NecsusLogger; entitySize: int; componentSize: int; inboxSize: int; eagerAlloc: bool = false): NecsusConf

newQuery:

• query: proc newQuery[Comps: tuple](appState: pointer; getLen: QueryGetLen; getNext: QueryNext[Comps]): RawQuery[Comps]

newSlot:

• archetypeStore: proc newSlot[Comps: tuple](store: var ArchetypeStore[Comps]; entityId: EntityId): NewArchSlot[ Comps]

newSpawn:

• spawn: proc newSpawn[Comps: tuple](app: pointer; callback: proc (app: pointer; value: sink Comps): EntityId {.nimcall, raises: [], gcsafe.}): RawSpawn[ Comps]

newSystemArg:

• systemGen: proc newSystemArg[T: TupleDirective | MonoDirective | DualDirective | void]( source: NimNode; generator: DirectiveGen; originalName: string; name: string; nestedArgs: seq[SystemArg] = @[]; directive: T): SystemArg

newTupleDir:

• tupleDirective: proc newTupleDir(comps: openArray[ComponentDef]): TupleDirective
• tupleDirective: proc newTupleDir(args: openArray[DirectiveArg]): TupleDirective

newWorld:

• world: proc newWorld(initialSize: SomeInteger): World

next:

• archetypeStore: proc next[Comps: tuple](store: var ArchetypeStore[Comps]; iter: var BlockIter; eid: var EntityId): ptr Comps
• blockstore: proc next[V](store: var BlockStore[V]; iter: var BlockIter): ptr V

nodes:

• systemGen: iterator nodes(arg: SystemArg): NimNode

Not:

• query: type Not

Optional:

• directiveArg: DirectiveArgKind.Optional

optionPtr:

• tools: template optionPtr[T](opt: Option[T]): Option[ptr T]

Outbox:

• directives: type Outbox

outboxGenerator:

• eventGen: let outboxGenerator

OutboxProc:

• directives: type OutboxProc

Outside:

• systemGen: GenerateHook.Outside

pairs:

• directiveSet: iterator pairs[T](directives: DirectiveSet[T]): tuple[name: string, value: T]
• query: iterator pairs[Comps: tuple](query: FullQuery[Comps]): QueryItem[Comps]

parseApp:

• parse: proc parseApp(appProc: NimNode; runner: NimNode): ParsedApp

ParsedApp:

• parse: type ParsedApp

ParsedSystem:

• parse: type ParsedSystem

parseSystemDef:

• parse: proc parseSystemDef(ident: NimNode; impl: NimNode): ParsedSystem

parseSystemList:

• parse: proc parseSystemList(systems: NimNode): seq[ParsedSystem]

Profiler:

• profile: object Profiler

profilingEnabled:

• codeGenInfo: proc profilingEnabled(): bool

push:

• blockstore: template push[V](store: var BlockStore[V]; newValue: V): uint

Query:

• query: type Query

queryGenerator:

• queryGen: let queryGenerator

QueryItem:

• query: tuple QueryItem

QueryNext:

• query: type QueryNext

RawNestedArg:

• systemGen: tuple RawNestedArg

RawQuery:

• query: type RawQuery

RawSpawn:

• spawn: type RawSpawn

readable:

• tupleDirective: proc readable(dir: TupleDirective): string

readableName:

• archetype: proc readableName(arch: Archetype[ComponentDef]): string
• componentDef: proc readableName(comp: ComponentDef): string

readArchetype:

• archetypeStore: proc readArchetype(store: ArchetypeStore): ArchetypeId

record:

• profile: proc record(profiler: var Profiler; time: BiggestFloat)

removeAndAdd:

• archetype: proc removeAndAdd[T](archetype: Archetype[T]; remove: Bits; add: openArray[T]): seq[T]

reserve:

• blockstore: proc reserve[V](blockstore: var BlockStore[V]): Entry[V]

resolveAlias:

• typeReader: proc resolveAlias(typeDef: NimNode): Option[NimNode]

resolveBracketGeneric:

• typeReader: proc resolveBracketGeneric(typeDef: NimNode): NimNode

resolveTo:

• typeReader: proc resolveTo(typeDef: NimNode; expectKind: set[NimNodeKind]): Option[NimNode]

Restore:

• directives: type Restore

RestoreCallback:

• parse: SystemPhase.RestoreCallback

restoreGenerator:

• restoreGen: let restoreGenerator

restoreSys:

• pragmas: template restoreSys()

RunLoop:

• necsus: NecsusRun.RunLoop

runSystemOnce:

• necsus: macro runSystemOnce(systemDef: typed): untyped

Save:

• directives: type Save

SaveCallback:

• parse: SystemPhase.SaveCallback

saveGenerator:

• saveGen: let saveGenerator

saveSys:

• pragmas: template saveSys()

SaveSystemInstance:

• directives: type SaveSystemInstance

sendEventProcName:

• systemGen: proc sendEventProcName(directive: MonoDirective): tuple[internal, external: NimNode]

set:

• spawn: proc set[C: tuple](spawn: FullSpawn[C]; values: sink C): EntityId
• spawn: proc set[C: tuple](spawn: Spawn[C]; values: sink C)
• systemVar: proc set[T](sysvar: SystemVar[T]; value: sink T)
• blockstore: template set[V](entry: Entry[V]; newValue: V)

setArchetypeDetails:

• world: proc setArchetypeDetails(entry: NewEntity; archetype: ArchetypeId; index: uint)

setComp:

• archetypeStore: proc setComp[Comps: tuple](slot: NewArchSlot[Comps]; comps: sink Comps): EntityId

Shared:

• systemVar: type Shared

sharedGenerator:

• sharedGen: let sharedGenerator

SharedOrT:

• systemVar: type SharedOrT

signature:

• monoDirective: proc signature(dir: MonoDirective): string
• systemGen: proc signature(conv: ConverterDef): string
• tupleDirective: proc signature(dir: TupleDirective): string

single:

• query: proc single[Comps: tuple](query: AnyQuery[Comps]): Option[Comps]

Spawn:

• spawn: type Spawn

spawnGenerator:

• spawnGen: let spawnGenerator

Standard:

• systemGen: GenerateHook.Standard

startTime:

• common: let startTime

StartupPhase:

• parse: SystemPhase.StartupPhase

startupSys:

• pragmas: template startupSys()

stringify:

• tools: proc stringify[T](value: T): string

summarize:

• profile: proc summarize(profilers: var openArray[Profiler]; conf: NecsusConf)

Swap:

• directives: type Swap

swapGenerator:

• attachDetachGen: let swapGenerator

symbol:

• directiveSet: proc symbol[T](directives: DirectiveSet[T]): string

symbols:

• nimNode: proc symbols(node: NimNode): seq[string]

systemArg:

• codeGenInfo: proc systemArg(genInfo: CodeGenInfo; arg: SystemArg): NimNode

SystemArg:

• systemGen: type SystemArg

systemArg:

• systemGen: proc systemArg(ctx: GenerateContext; arg: SystemArg): NimNode
• systemGen: proc systemArg(directives: Table[DirectiveGen, DirectiveSet[SystemArg]]; arg: SystemArg): NimNode

SystemArgExtractor:

• systemGen: type SystemArgExtractor

SystemFlag:

• necsus: object SystemFlag

SystemInstance:

• directives: type SystemInstance

SystemPhase:

• parse: enum SystemPhase

SystemVar:

• systemVar: type SystemVar

SystemVarData:

• systemVar: object SystemVarData

TeardownPhase:

• parse: SystemPhase.TeardownPhase

teardownSys:

• pragmas: template teardownSys()

thisTime:

• common: let thisTime

TickId:

• directives: type TickId

tickIdGenerator:

• tickIdGen: let tickIdGenerator

TimeDelta:

• directives: type TimeDelta

TimeElapsed:

• directives: type TimeElapsed

toInt:

• entityId: proc toInt(entityId: EntityId): uint

TupleAdapter:

• converters: type TupleAdapter

TupleDirective:

• tupleDirective: type TupleDirective

unwrap:

• systemVar: proc unwrap[T](sysvar: SharedOrT[T] | LocalOrT[T]): T
• systemVar: proc unwrap[T](sysvar: SharedOrT[T] | LocalOrT[T]; otherwise: T): T

value:

• blockstore: template value[V](entry: Entry[V]): var V

values:

• archetype: proc values[T](archetype: Archetype[T]): seq[T]

with:

• spawn: template with[C: tuple](spawn: FullSpawn[C]; values: varargs[typed]): EntityId
• spawn: template with[C: tuple](spawn: Spawn[C]; values: varargs[typed])

World:

• world: object World

WorldField:

• systemGen: tuple WorldField

worldFields:

• codeGenInfo: proc worldFields(codeGen: CodeGenInfo): seq[WorldField]
• systemGen: proc worldFields(arg: SystemArg; name: string): seq[WorldField]

worldIdent:

• common: let worldIdent