Hammerite API reference

Every class on this list is supported: from 1.0 only a major release removes or changes what is documented here. Anything else in the addons is experimental and may change in any release - see API stability. This reference is generated from the documentation comments in the source; Godot's built-in help (F1 in the Godot editor) shows the same text.

Autoloads

Class
`Hammerite`	Hammerite core runtime facade (autoload: `Hammerite`).
`HammeriteEditor`	Hammerite editor integration facade (autoload: `HammeriteEditor`).
`HammeriteAudio`	Hammerite Audio runtime facade (autoload: `HammeriteAudio`).
`HammeriteNavigation`	Hammerite Navigation runtime facade (autoload: `HammeriteNavigation`).

Core: the map

Class
`HammeriteMap`	A level as authored: brushes, entities, layers and prefab instances, with the lighting baked for it and the world compiled from it.
`HammeriteBrush`	A convex volume bounded by `HammeriteFace` planes: the unit a `HammeriteMap` is authored in.
`HammeriteFace`	One bounding plane of a `HammeriteBrush`, and what its surface looks like.
`HammeriteEntity`	One placed thing in a `HammeriteMap` that is not world geometry: a light, a prop, a spawn point.
`HammeriteBrushEntity`	An entity made of brushes rather than standing at a point: a door, a pool, a trigger volume.
`HammeriteLayer`	A named, nestable group of brushes, entities and prefab instances that are shown, ghosted, hidden or locked together - and, optionally, a variant of the map.
`HammeriteCell`	One convex piece of carved air, derived by the compiler; rooms are groups of these.
`HammeritePortal`	A derived portal joining two rooms in the subtractive world model.
`HammeriteBoundaryWall`	A cell-wall face after portal apertures have been punched out of it.
`HammeritePrefab`	A prefab containing brushes and entities.
`HammeritePrefabSet`	A collection of prefabs.
`HammeritePrefabInstance`	A prefab instance in the map.
`HammeriteSkybox`	What is outside a map: a scale model of the world beyond it, and the sky over that.

Core: in the scene

Class
`HammeriteMap3D`	3D representation of a `HammeriteMap`.
`HammeriteWorldrepCompile`	A just-loaded map's worldrep, compiled on a worker thread so that whoever loaded it can go on drawing, say how far the compile has got, and let it be cancelled (#109).
`HammeriteCompileProgress`	How far a worldrep compile has got, and whether it has been asked to stop.

Core: entities

Class
`HammeritePointEntityNode3D`	Base for the node of an entity that stands at one point: a light, a marker, a pickup.
`HammeritePointEntityAnimatableBody3D`	A point entity that MOVES and that the world can collide with: a door leaf, a lift, a drawbridge.
`HammeritePointEntityRigidBody3D`	A point entity the PHYSICS decides where to put: a crate, a bottle, anything that can be knocked over, picked up or thrown.
`HammeriteBrushEntityNode3D`	Base for the node of an entity made of brushes: a door, a volume of water, a trigger.
`HammeriteBrushEntityStaticBody3D`	The interface of `HammeriteBrushEntityNode3D` on a `StaticBody3D`: brushwork that is solid, such as a door leaf.
`HammeriteBrushEntityArea3D`	The interface of `HammeriteBrushEntityNode3D` on an `Area3D`: brushwork that notices what is inside it, such as water or a trigger.
`HammeriteEntityNodes`	What the six entity base classes share, and the one way to ask whether a node is an entity's.
`HammeritePointLight3D`	A baked point light (entity type `light_point`): a lamp that is part of the bake and cannot be switched.
`HammeriteDynamicLight3D`	A baked light that can be switched and dimmed at run time: what `HammeriteDynamicPointLight3D` and `HammeriteDynamicDirectionalLight3D` are.
`HammeriteDynamicPointLight3D`	A baked point light that can be switched and dimmed at run time (entity type `light_point_dynamic`).
`HammeriteDirectionalLight3D`	A baked directional light (entity type `light_directional`): sun or moonlight, entering through the map's sky faces.
`HammeriteDynamicDirectionalLight3D`	A baked directional light that can be switched and dimmed at run time (entity type `light_directional_dynamic`): lightning, say, or a sun that sets.
`HammeriteGenericBrushEntity`	Brushwork that is drawn and solid and does nothing else: what grouping brushes into an entity makes until the game says otherwise (`HammeriteMap.default_brush_entity_type`), so a group is something that works with nothing but core installed.
`HammeritePropModel`	A model placed in a map (entity type `prop_model`): a crate, a statue, a barrel.
`HammeriteDecal3D`	A picture stuck on a wall: a scorch mark, a poster, a bloodstain.
`HammeriteGizmoBuffer`	What the editor is asked to draw over the level for one frame: the shape a tool is dragging out, a selection's wireframe, a marker on the cursor.
`HammeriteEditorHandle`	One point in the world an author can take hold of and drag.

Core: lighting

Class
`HammeriteLightmapper`	Bakes a map's light into lightmaps on its faces and props and into its light probes, on the GPU.
`HammeriteBakeSettings`	How a map is baked: everything `HammeriteLightmapper` reads that is not the map itself.
`HammeriteLightmapBakeReport`	What each pass of a bake did to the light: how much energy the texels and probes held after it, static and switchable, and how many held any.
`HammeriteBakedLight`	The runtime handle of one light slot a bake wrote into the lightmaps and probes.
`HammeriteLightProbeSet`	A map's baked light probes, with a uniform spatial grid for finding the nearest ones.
`HammeriteLightCurve`	What a measured light level is worth to the eye, as a gain over the level itself.
`HammeriteEyeAdaptation3D`	Eye adaptation: what the player is standing in decides how bright the screen is.
`HammeriteBakeOccluders`	Process-wide registry of things that STOP light without ever being lit.
`HammeriteBakeOccluder`	One lump of matter that stops light in a bake and is never lit by it.
`HammeriteBrushEntityLighting`	The handover for brushwork that is baked into the world and then moves.
`HammeriteShaderGlobals`	The global shader uniforms Hammerite's materials read.

Core: files, names and extension

Class
`HammeriteDataFile`	Saves and loads a map - or any resource made of Hammerite's own - as data that cannot run code, at any path on disk (#85).
`HammeriteUnknownData`	An object of a class this game does not have, carried through a data file unread (#124).
`HammeriteReferences`	What a map names that lives outside it - a texture, a model, a sound, a scene somebody plays out - and who provided each one when the map was saved (#86).
`HammeriteReferenceChange`	One thing a map uses that is not what it was when the map was saved (`HammeriteReferences.check()`).
`HammeriteTextureLibrary`	Where a texture NAME becomes a texture.
`HammeriteModelLibrary`	Where a prop's model name becomes a mesh (#87).
`HammeriteAssetLibrary`	Where a NAME becomes a model, a sound - a resource of one kind (#87).
`HammeriteBrushPropertySchema`	A named group of extendable brush properties contributed by an addon.
`HammeriteBrushPropertyDef`	One extendable property an addon has declared, on a brush or on the sky.
`HammeriteBrushPropertyRegistry`	Process-wide registry of the extendable brush property schemas addons have contributed.
`HammeriteBrushFill`	A kind of medium an air brush can be filled with - water, and whatever else a game invents.
`HammeriteBrushFillRegistry`	Process-wide registry of the fills an air brush can be filled with, and the classes a game wants instantiated over them.
`HammeriteSkyPropertySchema`	A set of properties a game or an addon adds to the sky (see `HammeriteSkyPropertyRegistry`): weather, a haze, whatever it draws under a sky that Hammerite has no opinion about.
`HammeriteSkyPropertyRegistry`	The properties games and addons have added to the sky: the seam through which a game puts its own weather on a map's sky without Hammerite knowing what weather is.
`HammeriteEntityTypeRegistry`	Process-wide registry of entity types: each type's name, whether it is a point or brushwork, and the whole of what its entities carry, with the default of each.
`HammeriteUtils`	Small node helpers shared across the Hammerite addons.
`HammeriteVersion`	Which Hammerite this is.

Editor

Class
`HammeriteMapEditor`	The in-game level editor: a `Control` that edits a `HammeriteMap` through the game's own `HammeriteMap3D`, and the object games and addons extend it through.
`HammeriteMapEditorSettings`	The project's starting configuration for `HammeriteMapEditor`: its palette, its starting UI scale, and the defaults of the options an author can toggle.
`HammeriteEditorColors`	Every colour the editor draws the WORLD in: the viewports, the overlays, the gizmos (#48).
`HammeriteEditorTheme`	What the editor looks like: one `Theme` every control in it inherits.
`HammeriteEditorCommand`	One thing the editor can be asked to do, and how it is asked.
`HammeriteEditorCommands`	Every command the editor has, what it is bound to, and where it appears.
`HammeriteEditorTool`	Base class for an editor tool: the one thing the author's clicks and keys go to in the viewports.
`HammeritePropertyControl`	One property's editing control, as the property panel expects to find it.
`HammeriteEditorWorkspaces`	The level editor as one workspace among several, and a tab strip to change between them.
`HammeriteManual`	The manual: its sections, their pages, links between them and search over all of it.
`HammeriteManualSection`	One section of the manual: an addon's or a game's directory of pages.
`HammeriteManualPage`	One page of the manual: its front matter, its headings and its markdown.
`HammeriteNotableSizes`	The measurements a game finds worth naming, so a dimension being dragged can say what it is.

Audio

Class
`HammeriteAudioRuntime`	Process-wide access to the audio managers, the game's sound-type table, and the bake.
`HammeriteAudioManager`	One map's sound: plays sounds through its audio graph, sets the reverb, and tells listeners.
`HammeriteAudioHearing`	What a map's listeners can hear: the gameplay half of acoustics, apart from the mixing.
`HammeriteAudioMixSettings`	How a map's sound is mixed: everything `HammeriteAudioManager` reads that is not the map, the graph or the game's sound types.
`HammeriteAudioSoundSpec`	What to play and how: the description a sound is created from.
`HammeriteAudioBakeReport`	What one acoustic bake made of a map, and what it could not make of it.
`HammeriteAudioEmitter3D`	A thing in the world that makes a sound, as a node.
`HammeriteAudioReceiver3D`	Something in the world that can hear, as a node.
`HammeriteAudioSoundTypes`	The game's table of `HammeriteAudioSoundType`s, assigned to `HammeriteAudio.sound_types`.
`HammeriteAudioSoundType`	One kind of sound, as far as gameplay is concerned: how loud it is and how far it carries.
`HammeriteAudioSoundEvent`	One sound, as heard by one listener.
`HammeriteAudioPreset`	One reverb character a room can have.
`HammeriteAudioMaterials`	What each material does to sound: a table of material names to `HammeriteAudioMaterial`.
`HammeriteAudioMaterial`	What one material does to sound: a row of `HammeriteAudioMaterials`.
`HammeriteAudioBrushProperties`	The acoustic character of a room, authored on the air brush that carves it.
`HammeriteAudioPortalProperties`	Authored acoustic values on a portal, stored on the face the aperture is punched from.
`HammeriteAudioEditorExtension`	Acoustic System Editor Plugin.

Navigation

Class
`HammeriteNavigationRuntime`	Process-wide navigation state, and the one route by which a bake happens.
`HammeriteNavigationAgentProfile`	One kind of thing that moves, as far as navigation is concerned: how big it is and what it can haul itself up, drop off or jump across.
`HammeriteNavigationAgentProfiles`	The game's table of `HammeriteNavigationAgentProfile`s, handed to the bake.
`HammeriteNavigationBrushProperties`	What a room costs to cross, authored on the air brush that carves it.
`HammeriteNavigationEditorExtension`	Adds the navigation tool to a Hammerite HammeriteMapEditor.
`HammeriteNavigationLinkEntity3D`	The 3D presence of an authored navigation link: a ladder, a rope, a drainpipe.
`HammeriteNavigationBakeReport`	What one navigation bake did, and what it could not do.
`HammeriteNavigationSurface`	One convex patch of ground an agent could stand on, and what is measured about it.
`HammeriteNavigationLinkData`	A way from one patch of ground to another that is not walking: a window climbed through, a ledge dropped off, a gap jumped, a ladder someone placed.
`HammeriteNavigationBuilder`	Derives the walkable ground of a compiled map.
`HammeriteNavigationLinkBuilder`	Finds the ways through a level that are not walking, and measures them.
`HammeriteNavigationMeshWriter`	Turns measured ground into Godot navigation meshes, one per room.