# SensorBench (module)
Measures what a sensor look costs on the machine it runs on, with the engine's own profiler: engine CPU time per frame (`profiler.cost`) with no sensor look and with a look on, and the GPU time of the look's own passes (`profiler.gpuFrame`: styleKit's per-block passes and shared capture). It spawns test objects first (2,500 by default) and removes them after. The same code runs in the desktop app and in the browser, and `engine.platform` in the result says which, so the two are measured the same way. sensorBlocks' README publishes its numbers; the showcase's sensor panel has a "Measure cost on this device" button that runs it.
```luau
local Bench = require("~sensorBlocks.SensorBench")
local r = Bench.run({ looks = { "militaryThermal", "gen3NightVision" } }) -- in play, takes a minute
print(r.platform, r.drawn, r.off.cpu, r.looks.militaryThermal.gpu, r.looks.militaryThermal.cpuDelta)
```
## Known limits
- GPU numbers need timestamp queries; where the device or browser has none, `gpuSupported` is false and only CPU is reported.
- The numbers are this machine's at the size it draws; post-process GPU cost scales with the number of pixels.
- Other programs on the same machine move the CPU numbers a little; compare the look-on and look-off windows, not single frames.
# Sensors (module)
The runtime half of sensorBlocks: it puts a sensor look (thermal camera, night vision, x-ray, sonar...) on screen, sends the sonar pings and bright flashes every player shares, and every frame tells the sensor blocks what they need (this machine's goggles state, the live pings, and the players, enemies and pickups near the camera with their roles). Game scripts and sensorGoggles call it.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("militaryThermal") -- a whole look, your own view only
Sensors.use("thermalIronbow") -- or a single block
Sensors.use("gen3NightVision", { shared = true }) -- every player, kept with the scene
Sensors.use("militaryThermal", { settings = { noise = 0.1 } })
Sensors.tune({ palette = 0 }) -- change settings, keep the look
Sensors.off() -- back to the scene's own look
Sensors.ping(player.position, { range = 40 }) -- a sonar ring, shared
Sensors.flash(grenade.position, 1) -- blinds night vision, shared
```
## What it gives
| Call | What it does |
|---|---|
| `Sensors.use(what, opts)` | `what` is a look id, a block id or a list of stack entries. Local to this machine by default (styleKit local entries); `shared = true` puts it on the scene's synced stack, keeping the scene's non-sensor blocks. `settings` lays settings over every entry. |
| `Sensors.off(opts)` | Takes this machine's look off; `shared = true` also takes sensor blocks off the synced stack. |
| `Sensors.tune(settings)` / `Sensors.current()` | Change settings of the look on now / which look is on. |
| `Sensors.ping(origin, opts)` | A ring that ripples out and reveals the world as it passes. opts: `speed` (30 m/s), `range` (60 m), `kind` (0 sonar, 1 echolocation), `strength`. |
| `Sensors.flash(pos, strength)` | A muzzle flash, flashbang, flare or lightning. Night vision facing it washes out, never more than 3 full-screen washes a second. |
| `Sensors.setLocal(state)` / `Sensors.localState()` | This machine's power, powerStyle, illuminator and gain (sensorGoggles drives these). |
| `Sensors.blocks()` / `Sensors.looks()` | Every installed block or look tagged `sensor`. |
| `Sensors.status()` / `Sensors.pulses()` | What it drew last frame / the live pings. |
| `Sensors.ROLE_NUMBERS` / `Sensors.CONTACT_RULES` | Roles blocks mark, and the name words used when a game gave none. |
## Who reads as what
Contacts come from, in order: the scene's players (you, and everyone else as an ally), roles a game gave with `StyleRoles.give` or `StyleKit.give`, then entity names (guard, soldier, zombie, monster read as enemy; pickup, loot, ammo, coin, key, medkit as pickup; hazard, mine, trap, laser, camera as hazard; objective, exit, goal as objective).
## Known limits
- At most 32 contacts and 8 pings are drawn, nearest first.
- Pings and flashes sent before a player joined are not replayed to them.
- Contact shapes are boxes fitted to bounds when first seen.
# XrayPass (module)
Makes the layer images the x-ray blocks read, on this machine only and only while an x-ray block is in the stack. Two geometry passes draw every surface, then only the metal things heatSignatures knows (crates, barrels, engines, vehicles, electronics), into screen-sized images with additive blending, both sides and no depth test, so each pixel adds up what lies along its ray. They are published to styleKit as the `xray` and `xrayMetal` inputs.
Who calls it: Sensors' frame (through the sensorField render feature). Game code never needs it; a block of your own reads the layers with `reads: ["input:xray", "input:xrayMetal"]` in its block.yaml.
## Known limits
- It counts surfaces, not real density or thickness: a hollow box and a solid one of the same size read alike.
- What counts as metal comes from heatSignatures's classes (names and HeatSource), not from materials.
- Two extra full-scene passes while an x-ray block is on.
# nightVision (shader)
The shader every sensorBlocks night vision block runs: an image intensifier. It amplifies the frame's light with an automatic gain (measured fresh each frame from a coarse look at the picture, so it never pumps), adds an infrared illuminator cone and the near-infrared glow of leaves, blooms bright lights into halos, adds scintillating per-pixel grain, the tube's honeycomb, optional pixels and scanlines for digital and security cameras, and lands it on a phosphor colour. Flashes from `Sensors.flash` wash it out (rate limited by the runtime) and the goggles' power-on plays on it.
## Known limits
- The automatic gain reads 16 points of the picture each frame; one tiny very bright light does not dim the whole picture the way a real tube's gain would.
- See the sensorBlocks README for the rest.
# Night vision: auto-gated (styleBlock, Colour)
Auto-gated gen-3 night vision, the special-forces tube: a clean green picture that dims itself the moment a bright light comes into view. A lamp, a fire or a muzzle flash stays a small hot spot with a tight halo instead of washing the tube out, and the picture comes back up when the light leaves the view.
The shader reads how much bright light sits on a 4 x 4 grid of points of the frame and cuts its gain to a third and its halos by up to 70% as that grows. It ramps with the amount of light rather than switching, so a flickering campfire dims the picture gently and never flashes the whole screen. `autoGate` sets how strongly it gates (0 off, 1 full); any other night vision block can turn it on too.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("nvAutoGated") -- on this machine only (your goggles)
Sensors.use("autoGatedNightVision") -- the ready-made look: auto-gated through binocular tubes
Sensors.flash(explosion.position, 1) -- a flash still dazzles it, for a moment
```
## What it gives up in motion
Amplified light moves with the scene, so nothing slides. The fine grain changes every frame per pixel, a noise rather than a flicker. The gate is worked out fresh each frame from 16 fixed points of the picture and ramps with how much bright light they see, so a light turning into view dims the picture smoothly and a flickering fire moves it only a little; it never switches the whole screen on and off. A flash washes the picture out and it recovers over about a second and a half; the runtime lets at most three of those begin in any second. The honeycomb is fixed to the screen, as on a real tube.
## How it treats content
- Opaque things: their light amplified, plus the illuminator near and ahead; the whole picture dims while a bright light is in view.
- Transparent things (glass, water): their light like anything else; a lamp behind glass gates the tube like any lamp.
- Particles and smoke: bright particles (fire, sparks, muzzle flashes) are what the gate reacts to: they stay small hot spots with tight halos.
- Sky: a moonlit sky turns green; a bright sky fills the gate's points and keeps the picture dimmed.
- Fog: lit fog brightens the picture and can gate it a little when it glows strongly.
- Skinned characters: like any surface, with their role marked so players and enemies read apart.
- Foliage: leaves read brighter (near infrared).
- World text: amplified like the rest and readable when lit; screen UI is drawn after the stack and is never touched.
- Black does not stay black: an intensifier makes visible what the eye could not see.
## Known limits
- The gate looks at 16 fixed points of the frame, so a very small light between them dims the picture less than a large one.
- It gates on what is bright on screen, not on where a light is: a bright white wall in the illuminator's beam dims it too.
# Night vision: cheap digital (styleBlock, Colour)
A cheap digital night vision scope: a blocky, smeary sensor in a sickly green with scanlines, crushed blacks, heavy noise in the dark and a weak infrared lamp.
It is one of the seven night vision blocks; all run the `nightVision` shader with their own defaults, so any one swaps for another in the Colour slot with one change. Put an optic (opticsMonocular, opticsBinocular, opticsQuad, opticsScope) in the Medium slot to see it through a tube.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("nvGen3Green") -- on this machine only (your goggles)
Sensors.flash(explosion.position, 1) -- every player whose night vision sees it is dazzled
```
## What it gives up in motion
Amplified light moves with the scene, so nothing slides. The scintillating grain changes every frame per pixel, a fine noise rather than a flicker. The automatic gain is measured fresh each frame from 16 points of the picture, so it follows a light coming into view at once instead of pumping. A flash washes the picture out and it recovers over about a second and a half; the runtime lets at most three of those begin in any second. The honeycomb and scanlines are fixed to the screen, as on a real tube.
## How it treats content
- Opaque things: their light amplified, plus the illuminator near and ahead.
- Transparent things (glass, water): their light like anything else; a lamp behind glass still blooms.
- Particles and smoke: bright particles (fire, sparks, muzzle flashes) bloom into halos.
- Sky: a moonlit sky turns a bright green; a black sky stays the phosphor's floor.
- Fog: lit fog brightens and flattens the picture, as it does through real goggles.
- Skinned characters: like any surface, with their role marked so players and enemies read apart.
- Foliage: leaves read brighter (near infrared).
- World text: amplified like the rest and readable when lit; screen UI is drawn after the stack and is never touched.
- Black does not stay black: an intensifier makes visible what the eye could not see.
## Known limits
- The illuminator is a cone in the middle of the view, not a real light; it does not cast shadows.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# Night vision: gen 1 green (styleBlock, Colour)
First-generation night vision: a heavy, grainy green picture, soft and blurred toward the edges with a strong illuminator glow in the middle, the old Soviet-surplus tube.
It is one of the seven night vision blocks; all run the `nightVision` shader with their own defaults, so any one swaps for another in the Colour slot with one change. Put an optic (opticsMonocular, opticsBinocular, opticsQuad, opticsScope) in the Medium slot to see it through a tube.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("nvGen3Green") -- on this machine only (your goggles)
Sensors.flash(explosion.position, 1) -- every player whose night vision sees it is dazzled
```
## What it gives up in motion
Amplified light moves with the scene, so nothing slides. The scintillating grain changes every frame per pixel, a fine noise rather than a flicker. The automatic gain is measured fresh each frame from 16 points of the picture, so it follows a light coming into view at once instead of pumping. A flash washes the picture out and it recovers over about a second and a half; the runtime lets at most three of those begin in any second. The honeycomb and scanlines are fixed to the screen, as on a real tube.
## How it treats content
- Opaque things: their light amplified, plus the illuminator near and ahead.
- Transparent things (glass, water): their light like anything else; a lamp behind glass still blooms.
- Particles and smoke: bright particles (fire, sparks, muzzle flashes) bloom into halos.
- Sky: a moonlit sky turns a bright green; a black sky stays the phosphor's floor.
- Fog: lit fog brightens and flattens the picture, as it does through real goggles.
- Skinned characters: like any surface, with their role marked so players and enemies read apart.
- Foliage: leaves read brighter (near infrared).
- World text: amplified like the rest and readable when lit; screen UI is drawn after the stack and is never touched.
- Black does not stay black: an intensifier makes visible what the eye could not see.
## Known limits
- The illuminator is a cone in the middle of the view, not a real light; it does not cast shadows.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# Night vision: gen 2 green (styleBlock, Colour)
Gen-2 night vision, the generation between the grainy first tubes and modern gen 3: a green picture with visible grain and honeycomb, a little soft toward the edge, and wide halos round lights. The classic cold-war and police tube.
It is one of the seven night vision blocks; all run the `nightVision` shader with their own defaults, so any one swaps for another in the Colour slot with one change. Put an optic (opticsMonocular, opticsBinocular, opticsQuad, opticsScope) in the Medium slot to see it through a tube.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("nvGen2Green") -- on this machine only (your goggles)
Sensors.use("gen2NightVision") -- the ready-made look: gen 2 through a monocular
```
## What it gives up in motion
Amplified light moves with the scene, so nothing slides. The grain is coarser than gen 3's and changes every frame per pixel, a noise rather than a flicker. The automatic gain is measured fresh each frame from fixed points of the picture, so it follows a light coming into view at once instead of pumping. A flash washes the picture out and it recovers over about a second and a half; the runtime lets at most three of those begin in any second. The honeycomb is fixed to the screen, as on a real tube, and the edge of the tube stays softer than its middle.
## How it treats content
- Opaque things: their light amplified, plus the illuminator near and ahead.
- Transparent things (glass, water): their light like anything else; a lamp behind glass still blooms into a wide halo.
- Particles and smoke: bright particles (fire, sparks, muzzle flashes) bloom into wide halos.
- Sky: a moonlit sky turns a bright green; a black sky stays the phosphor's floor.
- Fog: lit fog brightens and flattens the picture, as it does through real goggles.
- Skinned characters: like any surface, with their role marked so players and enemies read apart.
- Foliage: leaves read brighter (near infrared).
- World text: amplified like the rest and readable when lit, a little soft toward the edge of the tube; screen UI is drawn after the stack and is never touched.
- Black does not stay black: an intensifier makes visible what the eye could not see.
## Known limits
- Like every night vision block it amplifies the light the scene already has; a scene with no light at all relies on the goggles' illuminator.
- The sensorBlocks package README Known limits lists the rest.
# Night vision: gen 3 green (styleBlock, Colour)
Modern gen-3 night vision: a clean, bright green picture with fine grain, crisp to the edges, and bright round halos around every light.
It is one of the seven night vision blocks; all run the `nightVision` shader with their own defaults, so any one swaps for another in the Colour slot with one change. Put an optic (opticsMonocular, opticsBinocular, opticsQuad, opticsScope) in the Medium slot to see it through a tube.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("nvGen3Green") -- on this machine only (your goggles)
Sensors.flash(explosion.position, 1) -- every player whose night vision sees it is dazzled
```
## What it gives up in motion
Amplified light moves with the scene, so nothing slides. The scintillating grain changes every frame per pixel, a fine noise rather than a flicker. The automatic gain is measured fresh each frame from 16 points of the picture, so it follows a light coming into view at once instead of pumping. A flash washes the picture out and it recovers over about a second and a half; the runtime lets at most three of those begin in any second. The honeycomb and scanlines are fixed to the screen, as on a real tube.
## How it treats content
- Opaque things: their light amplified, plus the illuminator near and ahead.
- Transparent things (glass, water): their light like anything else; a lamp behind glass still blooms.
- Particles and smoke: bright particles (fire, sparks, muzzle flashes) bloom into halos.
- Sky: a moonlit sky turns a bright green; a black sky stays the phosphor's floor.
- Fog: lit fog brightens and flattens the picture, as it does through real goggles.
- Skinned characters: like any surface, with their role marked so players and enemies read apart.
- Foliage: leaves read brighter (near infrared).
- World text: amplified like the rest and readable when lit; screen UI is drawn after the stack and is never touched.
- Black does not stay black: an intensifier makes visible what the eye could not see.
## Known limits
- The illuminator is a cone in the middle of the view, not a real light; it does not cast shadows.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# Night vision: security camera infrared (styleBlock, Colour)
A security camera in infrared night mode: flat black and white, leaves and skin glowing pale, a bright ring of infrared light near the lens and dark beyond it.
It is one of the seven night vision blocks; all run the `nightVision` shader with their own defaults, so any one swaps for another in the Colour slot with one change. Put an optic (opticsMonocular, opticsBinocular, opticsQuad, opticsScope) in the Medium slot to see it through a tube.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("nvGen3Green") -- on this machine only (your goggles)
Sensors.flash(explosion.position, 1) -- every player whose night vision sees it is dazzled
```
## What it gives up in motion
Amplified light moves with the scene, so nothing slides. The scintillating grain changes every frame per pixel, a fine noise rather than a flicker. The automatic gain is measured fresh each frame from 16 points of the picture, so it follows a light coming into view at once instead of pumping. A flash washes the picture out and it recovers over about a second and a half; the runtime lets at most three of those begin in any second. The honeycomb and scanlines are fixed to the screen, as on a real tube.
## How it treats content
- Opaque things: their light amplified, plus the illuminator near and ahead.
- Transparent things (glass, water): their light like anything else; a lamp behind glass still blooms.
- Particles and smoke: bright particles (fire, sparks, muzzle flashes) bloom into halos.
- Sky: a moonlit sky turns a bright green; a black sky stays the phosphor's floor.
- Fog: lit fog brightens and flattens the picture, as it does through real goggles.
- Skinned characters: like any surface, with their role marked so players and enemies read apart.
- Foliage: leaves read brighter (near infrared).
- World text: amplified like the rest and readable when lit; screen UI is drawn after the stack and is never touched.
- Black does not stay black: an intensifier makes visible what the eye could not see.
## Known limits
- The illuminator is a cone in the middle of the view, not a real light; it does not cast shadows.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# Night vision: white phosphor (styleBlock, Colour)
White phosphor night vision: a crisp blue-white and black picture with more apparent contrast than green, the newest military tubes.
It is one of the seven night vision blocks; all run the `nightVision` shader with their own defaults, so any one swaps for another in the Colour slot with one change. Put an optic (opticsMonocular, opticsBinocular, opticsQuad, opticsScope) in the Medium slot to see it through a tube.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("nvGen3Green") -- on this machine only (your goggles)
Sensors.flash(explosion.position, 1) -- every player whose night vision sees it is dazzled
```
## What it gives up in motion
Amplified light moves with the scene, so nothing slides. The scintillating grain changes every frame per pixel, a fine noise rather than a flicker. The automatic gain is measured fresh each frame from 16 points of the picture, so it follows a light coming into view at once instead of pumping. A flash washes the picture out and it recovers over about a second and a half; the runtime lets at most three of those begin in any second. The honeycomb and scanlines are fixed to the screen, as on a real tube.
## How it treats content
- Opaque things: their light amplified, plus the illuminator near and ahead.
- Transparent things (glass, water): their light like anything else; a lamp behind glass still blooms.
- Particles and smoke: bright particles (fire, sparks, muzzle flashes) bloom into halos.
- Sky: a moonlit sky turns a bright green; a black sky stays the phosphor's floor.
- Fog: lit fog brightens and flattens the picture, as it does through real goggles.
- Skinned characters: like any surface, with their role marked so players and enemies read apart.
- Foliage: leaves read brighter (near infrared).
- World text: amplified like the rest and readable when lit; screen UI is drawn after the stack and is never touched.
- Black does not stay black: an intensifier makes visible what the eye could not see.
## Known limits
- The illuminator is a cone in the middle of the view, not a real light; it does not cast shadows.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# optics (shader)
The shader every sensorBlocks optics block runs (Medium slot): the eyepieces of the device. `tubes` 1 draws a monocular, 2 binoculars, 4 four-tube panoramic goggles, 0 a rifle scope. Each tube darkens toward its rim, bends the picture a little (`distortion`) and can carry a reticle (1 crosshair with posts, 2 mil-dots, 3 a chevron). Everything outside the tubes is the housing colour.
## Known limits
- The tubes are drawn over the whole frame; the picture inside is the same picture, not a second camera per tube.
- See the sensorBlocks README for the rest.
# Optics: binocular (styleBlock, Medium)
The view through binocular goggles or field glasses: two overlapping round pictures in a black housing.
It is one of the four optics blocks; all run the `optics` shader with their own defaults, so any one swaps for another in the Medium slot with one change, under any sensor in the Colour slot (or none: binoculars over the plain scene work too).
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.add("opticsBinocular", { id = "optic" })
StyleKit.swap("optic", "opticsScope")
```
## What it gives up in motion
It belongs to the device, so it is fixed to the screen by design. The scope's parallax drifts slowly; nothing flickers.
## How it treats content
- Opaque things: seen through the tubes, a little bent and darker toward each rim.
- Transparent things (glass, water): the same.
- Particles and smoke: the same.
- Sky: the same; the housing covers the corners.
- Fog: the same.
- Skinned characters: the same.
- Foliage: the same.
- World text: bent with the picture inside a tube and hidden by the housing outside it; screen UI is drawn after the stack and is never touched.
- Black stays black inside the tubes; the housing is its own colour.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# Optics: monocular (styleBlock, Medium)
The view through a single night vision tube: one round picture in the middle of a black housing, darker and slightly bent toward the rim.
It is one of the four optics blocks; all run the `optics` shader with their own defaults, so any one swaps for another in the Medium slot with one change, under any sensor in the Colour slot (or none: binoculars over the plain scene work too).
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.add("opticsBinocular", { id = "optic" })
StyleKit.swap("optic", "opticsScope")
```
## What it gives up in motion
It belongs to the device, so it is fixed to the screen by design. The scope's parallax drifts slowly; nothing flickers.
## How it treats content
- Opaque things: seen through the tubes, a little bent and darker toward each rim.
- Transparent things (glass, water): the same.
- Particles and smoke: the same.
- Sky: the same; the housing covers the corners.
- Fog: the same.
- Skinned characters: the same.
- Foliage: the same.
- World text: bent with the picture inside a tube and hidden by the housing outside it; screen UI is drawn after the stack and is never touched.
- Black stays black inside the tubes; the housing is its own colour.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
Part of sensorBlocks, version 1.0.0.
# Optics: four-tube panoramic (styleBlock, Medium)
The view through four-tube panoramic goggles: two overlapping tubes in the middle and two more angled out to the sides, a wide field broken by the gaps between tubes.
It is one of the four optics blocks; all run the `optics` shader with their own defaults, so any one swaps for another in the Medium slot with one change, under any sensor in the Colour slot (or none: binoculars over the plain scene work too).
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.add("opticsBinocular", { id = "optic" })
StyleKit.swap("optic", "opticsScope")
```
## What it gives up in motion
It belongs to the device, so it is fixed to the screen by design. The scope's parallax drifts slowly; nothing flickers.
## How it treats content
- Opaque things: seen through the tubes, a little bent and darker toward each rim.
- Transparent things (glass, water): the same.
- Particles and smoke: the same.
- Sky: the same; the housing covers the corners.
- Fog: the same.
- Skinned characters: the same.
- Foliage: the same.
- World text: bent with the picture inside a tube and hidden by the housing outside it; screen UI is drawn after the stack and is never touched.
- Black stays black inside the tubes; the housing is its own colour.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
Part of sensorBlocks, version 1.0.0.
# Optics: rifle scope (styleBlock, Medium)
The view down a rifle scope: one sharp round picture with a mil-dot crosshair, a black ring and a slow parallax drift.
It is one of the four optics blocks; all run the `optics` shader with their own defaults, so any one swaps for another in the Medium slot with one change, under any sensor in the Colour slot (or none: binoculars over the plain scene work too).
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.add("opticsBinocular", { id = "optic" })
StyleKit.swap("optic", "opticsScope")
```
## What it gives up in motion
It belongs to the device, so it is fixed to the screen by design. The scope's parallax drifts slowly; nothing flickers.
## How it treats content
- Opaque things: seen through the tubes, a little bent and darker toward each rim.
- Transparent things (glass, water): the same.
- Particles and smoke: the same.
- Sky: the same; the housing covers the corners.
- Fog: the same.
- Skinned characters: the same.
- Foliage: the same.
- World text: bent with the picture inside a tube and hidden by the housing outside it; screen UI is drawn after the stack and is never touched.
- Black stays black inside the tubes; the housing is its own colour.
## Known limits
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# Colour infrared (styleBlock, Colour)
Colour infrared film, the Aerochrome look: foliage turns red and magenta, skies deep blue, people and soil in strange pinks and greens.
It is one of the six "other light" blocks; all run the `spectral` shader with their own defaults, so any one swaps for another in the Colour slot with one change. Infrared reflectance and ultraviolet fluorescence are read from each surface's base colour, so a scene reads right without tagging: green surfaces are leaves, saturated bright paint is day-glo, near-whites carry optical brighteners.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("uvBlacklight")
```
## What it gives up in motion
Everything is computed from the scene each frame and fixed to surfaces, so nothing slides. Grain changes per pixel per frame; the electron microscope's row noise steps eight times a second, row by row, never the whole screen at once.
## How it treats content
- Opaque things: by their base colour and the light on them, in the chosen band.
- Transparent things (glass, water): not in the depth, so they show what is behind; still water seen from above is darkened in infrared as it should be.
- Particles and smoke: by their brightness in the frame (fire glows; blacklight leaves them dim violet).
- Sky: black in infrared film, deep blue in colour infrared, violet-dark under blacklight, black-blue in false colour, black in a depth map.
- Fog: lit fog brightens the picture as in the frame.
- Skinned characters: like any surface, with their role marked so players and enemies read apart.
- Foliage: white in infrared film, red in colour infrared, dim under blacklight.
- World text: readable where its colours differ in the band; screen UI is drawn after the stack and is never touched.
- Black does not stay black where a band shows what the eye could not (fluorescence, infrared).
## Known limits
- Reflectance and fluorescence are guesses from base colour, not measured per material; give a thing a style role or a distinct colour to change how it reads.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# Depth map (styleBlock, Colour)
A depth map: near things white fading to black with distance, or in a colour map, the way a depth camera or rangefinder sees.
It is one of the six "other light" blocks; all run the `spectral` shader with their own defaults, so any one swaps for another in the Colour slot with one change. Infrared reflectance and ultraviolet fluorescence are read from each surface's base colour, so a scene reads right without tagging: green surfaces are leaves, saturated bright paint is day-glo, near-whites carry optical brighteners.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("uvBlacklight")
```
## What it gives up in motion
Everything is computed from the scene each frame and fixed to surfaces, so nothing slides. Grain changes per pixel per frame; the electron microscope's row noise steps eight times a second, row by row, never the whole screen at once.
## How it treats content
- Opaque things: by their base colour and the light on them, in the chosen band.
- Transparent things (glass, water): not in the depth, so they show what is behind; still water seen from above is darkened in infrared as it should be.
- Particles and smoke: by their brightness in the frame (fire glows; blacklight leaves them dim violet).
- Sky: black in infrared film, deep blue in colour infrared, violet-dark under blacklight, black-blue in false colour, black in a depth map.
- Fog: lit fog brightens the picture as in the frame.
- Skinned characters: like any surface, with their role marked so players and enemies read apart.
- Foliage: white in infrared film, red in colour infrared, dim under blacklight.
- World text: readable where its colours differ in the band; screen UI is drawn after the stack and is never touched.
- Black does not stay black where a band shows what the eye could not (fluorescence, infrared).
## Known limits
- Reflectance and fluorescence are guesses from base colour, not measured per material; give a thing a style role or a distinct colour to change how it reads.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# Electron microscope (styleBlock, Colour)
A scanning electron microscope: grey surfaces bright at every edge and steep slope, lit from one side, grainy row by row, with a data bar and scale along the bottom.
It is one of the six "other light" blocks; all run the `spectral` shader with their own defaults, so any one swaps for another in the Colour slot with one change. Infrared reflectance and ultraviolet fluorescence are read from each surface's base colour, so a scene reads right without tagging: green surfaces are leaves, saturated bright paint is day-glo, near-whites carry optical brighteners.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("uvBlacklight")
```
## What it gives up in motion
Everything is computed from the scene each frame and fixed to surfaces, so nothing slides. Grain changes per pixel per frame; the electron microscope's row noise steps eight times a second, row by row, never the whole screen at once.
## How it treats content
- Opaque things: by their base colour and the light on them, in the chosen band.
- Transparent things (glass, water): not in the depth, so they show what is behind; still water seen from above is darkened in infrared as it should be.
- Particles and smoke: by their brightness in the frame (fire glows; blacklight leaves them dim violet).
- Sky: black in infrared film, deep blue in colour infrared, violet-dark under blacklight, black-blue in false colour, black in a depth map.
- Fog: lit fog brightens the picture as in the frame.
- Skinned characters: like any surface, with their role marked so players and enemies read apart.
- Foliage: white in infrared film, red in colour infrared, dim under blacklight.
- World text: readable where its colours differ in the band; screen UI is drawn after the stack and is never touched.
- Black does not stay black where a band shows what the eye could not (fluorescence, infrared).
## Known limits
- Reflectance and fluorescence are guesses from base colour, not measured per material; give a thing a style role or a distinct colour to change how it reads.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# Infrared film (styleBlock, Colour)
Black-and-white infrared film: trees and grass glowing white like snow, clear sky and still water black, skin pale, a soft halation round bright areas and fine film grain.
It is one of the six "other light" blocks; all run the `spectral` shader with their own defaults, so any one swaps for another in the Colour slot with one change. Infrared reflectance and ultraviolet fluorescence are read from each surface's base colour, so a scene reads right without tagging: green surfaces are leaves, saturated bright paint is day-glo, near-whites carry optical brighteners.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("uvBlacklight")
```
## What it gives up in motion
Everything is computed from the scene each frame and fixed to surfaces, so nothing slides. Grain changes per pixel per frame; the electron microscope's row noise steps eight times a second, row by row, never the whole screen at once.
## How it treats content
- Opaque things: by their base colour and the light on them, in the chosen band.
- Transparent things (glass, water): not in the depth, so they show what is behind; still water seen from above is darkened in infrared as it should be.
- Particles and smoke: by their brightness in the frame (fire glows; blacklight leaves them dim violet).
- Sky: black in infrared film, deep blue in colour infrared, violet-dark under blacklight, black-blue in false colour, black in a depth map.
- Fog: lit fog brightens the picture as in the frame.
- Skinned characters: like any surface, with their role marked so players and enemies read apart.
- Foliage: white in infrared film, red in colour infrared, dim under blacklight.
- World text: readable where its colours differ in the band; screen UI is drawn after the stack and is never touched.
- Black does not stay black where a band shows what the eye could not (fluorescence, infrared).
## Known limits
- Reflectance and fluorescence are guesses from base colour, not measured per material; give a thing a style role or a distinct colour to change how it reads.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
Part of sensorBlocks, version 1.0.0.
# Space telescope false colour (styleBlock, Colour)
Space telescope false colour: dark teal lows, gold mids and white highlights like a nebula image, with diffraction spikes on the brightest points.
It is one of the six "other light" blocks; all run the `spectral` shader with their own defaults, so any one swaps for another in the Colour slot with one change. Infrared reflectance and ultraviolet fluorescence are read from each surface's base colour, so a scene reads right without tagging: green surfaces are leaves, saturated bright paint is day-glo, near-whites carry optical brighteners.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("uvBlacklight")
```
## What it gives up in motion
Everything is computed from the scene each frame and fixed to surfaces, so nothing slides. Grain changes per pixel per frame; the electron microscope's row noise steps eight times a second, row by row, never the whole screen at once.
## How it treats content
- Opaque things: by their base colour and the light on them, in the chosen band.
- Transparent things (glass, water): not in the depth, so they show what is behind; still water seen from above is darkened in infrared as it should be.
- Particles and smoke: by their brightness in the frame (fire glows; blacklight leaves them dim violet).
- Sky: black in infrared film, deep blue in colour infrared, violet-dark under blacklight, black-blue in false colour, black in a depth map.
- Fog: lit fog brightens the picture as in the frame.
- Skinned characters: like any surface, with their role marked so players and enemies read apart.
- Foliage: white in infrared film, red in colour infrared, dim under blacklight.
- World text: readable where its colours differ in the band; screen UI is drawn after the stack and is never touched.
- Black does not stay black where a band shows what the eye could not (fluorescence, infrared).
## Known limits
- Reflectance and fluorescence are guesses from base colour, not measured per material; give a thing a style role or a distinct colour to change how it reads.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# spectral (shader)
The shader every sensorBlocks "other light" block runs (`mode`): 0 black-and-white infrared film (leaves white, clear sky and water black, halation round bright areas), 1 colour infrared (near infrared shown as red, so foliage turns red and magenta), 2 UV blacklight (saturated bright paint and near-whites fluoresce and bloom, the rest a dim violet), 3 space telescope false colour (teal lows, gold mids, white highs, diffraction spikes on the brightest points), 4 a depth map (white near to black far, or a colour map), 5 a scanning electron microscope (edge-effect brightness, side-detector shading, row noise and a data bar).
## Known limits
- Reflectance in near infrared and fluorescence under ultraviolet are guessed from each surface's base colour (green reads as leaves, saturated bright as day-glo paint), not stored per material.
- See the sensorBlocks README for the rest.
# UV blacklight (styleBlock, Colour)
Ultraviolet blacklight: the world a dim violet, day-glo paint, highlighter colours and bright whites blazing neon with a soft glow.
It is one of the six "other light" blocks; all run the `spectral` shader with their own defaults, so any one swaps for another in the Colour slot with one change. Infrared reflectance and ultraviolet fluorescence are read from each surface's base colour, so a scene reads right without tagging: green surfaces are leaves, saturated bright paint is day-glo, near-whites carry optical brighteners.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("uvBlacklight")
```
## What it gives up in motion
Everything is computed from the scene each frame and fixed to surfaces, so nothing slides. Grain changes per pixel per frame; the electron microscope's row noise steps eight times a second, row by row, never the whole screen at once.
## How it treats content
- Opaque things: by their base colour and the light on them, in the chosen band.
- Transparent things (glass, water): not in the depth, so they show what is behind; still water seen from above is darkened in infrared as it should be.
- Particles and smoke: by their brightness in the frame (fire glows; blacklight leaves them dim violet).
- Sky: black in infrared film, deep blue in colour infrared, violet-dark under blacklight, black-blue in false colour, black in a depth map.
- Fog: lit fog brightens the picture as in the frame.
- Skinned characters: like any surface, with their role marked so players and enemies read apart.
- Foliage: white in infrared film, red in colour infrared, dim under blacklight.
- World text: readable where its colours differ in the band; screen UI is drawn after the stack and is never touched.
- Black does not stay black where a band shows what the eye could not (fluorescence, infrared).
## Known limits
- Reflectance and fluorescence are guesses from base colour, not measured per material; give a thing a style role or a distinct colour to change how it reads.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# Sweep: echolocation (styleBlock, Colour)
Echolocation in the dark: soft white ripples spread from each click and outline the world for a moment, with faint shapes always there close by, like a bat or a blind hero.
It is one of the five sweep blocks; all run the `sweep` shader with their own defaults, so any one swaps for another in the Colour slot with one change. Pings come from `Sensors.ping(origin)` (sensorGoggles sends one from the wearer every few seconds while a ping sensor is on) and every player in the world sees the same ping; contacts and their roles come from styleRoles roles, the scene's players and entity names.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("sonarPing")
Sensors.ping(player.position, { speed = 25, range = 50 })
```
## What it gives up in motion
What a ping or beam revealed is fixed to the world, so it stays on surfaces as you move. The radar beam turns about once every three seconds and a ping ring travels at tens of metres a second; both light a band of the world, never the whole screen at once. Grain changes per pixel per frame.
## How it treats content
- Opaque things: dark until the beam, ping or scan line reaches them, then lit with their outline and fading.
- Transparent things (glass, water): not in the depth, so a ping passes through them and lights what is behind.
- Particles and smoke: not detected, like a real sonar or lidar.
- Sky: nothing returns, so it stays the background colour.
- Fog: ignored; the display shows returns, not light.
- Skinned characters: revealed like any surface, with their role marked; the motion tracker shows them only while they move.
- Foliage: revealed as a soft mass of outlines.
- World text: unreadable on the display; screen UI is drawn after the stack and is never touched.
- Black does not stay black: the display makes its own light.
## Known limits
- The beam, ring and scan line light every surface they pass through; they do not stop at walls the way a real signal would.
- At most 8 pings and the 32 nearest contacts are drawn.
- The sensorBlocks package README's Known limits lists the rest.
# Sweep: laser scan line (styleBlock, Colour)
A lidar laser scan: a bright line rises and falls through the world, leaving a trail of points that fade and take their colour from distance.
It is one of the five sweep blocks; all run the `sweep` shader with their own defaults, so any one swaps for another in the Colour slot with one change. Pings come from `Sensors.ping(origin)` (sensorGoggles sends one from the wearer every few seconds while a ping sensor is on) and every player in the world sees the same ping; contacts and their roles come from styleRoles roles, the scene's players and entity names.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("sonarPing")
Sensors.ping(player.position, { speed = 25, range = 50 })
```
## What it gives up in motion
What a ping or beam revealed is fixed to the world, so it stays on surfaces as you move. The radar beam turns about once every three seconds and a ping ring travels at tens of metres a second; both light a band of the world, never the whole screen at once. Grain changes per pixel per frame.
## How it treats content
- Opaque things: dark until the beam, ping or scan line reaches them, then lit with their outline and fading.
- Transparent things (glass, water): not in the depth, so a ping passes through them and lights what is behind.
- Particles and smoke: not detected, like a real sonar or lidar.
- Sky: nothing returns, so it stays the background colour.
- Fog: ignored; the display shows returns, not light.
- Skinned characters: revealed like any surface, with their role marked; the motion tracker shows them only while they move.
- Foliage: revealed as a soft mass of outlines.
- World text: unreadable on the display; screen UI is drawn after the stack and is never touched.
- Black does not stay black: the display makes its own light.
## Known limits
- The beam, ring and scan line light every surface they pass through; they do not stop at walls the way a real signal would.
- At most 8 pings and the 32 nearest contacts are drawn.
- The sensorBlocks package README's Known limits lists the rest.
# Sweep: motion tracker (styleBlock, Colour)
A motion tracker: the world dark but for faint outlines, anything moving glows, and a fan-shaped scope pulses and shows blips only for what moves.
It is one of the five sweep blocks; all run the `sweep` shader with their own defaults, so any one swaps for another in the Colour slot with one change. Pings come from `Sensors.ping(origin)` (sensorGoggles sends one from the wearer every few seconds while a ping sensor is on) and every player in the world sees the same ping; contacts and their roles come from styleRoles roles, the scene's players and entity names.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("sonarPing")
Sensors.ping(player.position, { speed = 25, range = 50 })
```
## What it gives up in motion
What a ping or beam revealed is fixed to the world, so it stays on surfaces as you move. The radar beam turns about once every three seconds and a ping ring travels at tens of metres a second; both light a band of the world, never the whole screen at once. Grain changes per pixel per frame.
## How it treats content
- Opaque things: dark until the beam, ping or scan line reaches them, then lit with their outline and fading.
- Transparent things (glass, water): not in the depth, so a ping passes through them and lights what is behind.
- Particles and smoke: not detected, like a real sonar or lidar.
- Sky: nothing returns, so it stays the background colour.
- Fog: ignored; the display shows returns, not light.
- Skinned characters: revealed like any surface, with their role marked; the motion tracker shows them only while they move.
- Foliage: revealed as a soft mass of outlines.
- World text: unreadable on the display; screen UI is drawn after the stack and is never touched.
- Black does not stay black: the display makes its own light.
## Known limits
- The beam, ring and scan line light every surface they pass through; they do not stop at walls the way a real signal would.
- At most 8 pings and the 32 nearest contacts are drawn.
- The sensorBlocks package README's Known limits lists the rest.
# Sweep: radar (styleBlock, Colour)
A rotating radar sweep: the world dark green with range rings, lit only where the turning beam passes and fading behind it, with a round scope in the corner whose blips glow and fade.
It is one of the five sweep blocks; all run the `sweep` shader with their own defaults, so any one swaps for another in the Colour slot with one change. Pings come from `Sensors.ping(origin)` (sensorGoggles sends one from the wearer every few seconds while a ping sensor is on) and every player in the world sees the same ping; contacts and their roles come from styleRoles roles, the scene's players and entity names.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("sonarPing")
Sensors.ping(player.position, { speed = 25, range = 50 })
```
## What it gives up in motion
What a ping or beam revealed is fixed to the world, so it stays on surfaces as you move. The radar beam turns about once every three seconds and a ping ring travels at tens of metres a second; both light a band of the world, never the whole screen at once. Grain changes per pixel per frame.
## How it treats content
- Opaque things: dark until the beam, ping or scan line reaches them, then lit with their outline and fading.
- Transparent things (glass, water): not in the depth, so a ping passes through them and lights what is behind.
- Particles and smoke: not detected, like a real sonar or lidar.
- Sky: nothing returns, so it stays the background colour.
- Fog: ignored; the display shows returns, not light.
- Skinned characters: revealed like any surface, with their role marked; the motion tracker shows them only while they move.
- Foliage: revealed as a soft mass of outlines.
- World text: unreadable on the display; screen UI is drawn after the stack and is never touched.
- Black does not stay black: the display makes its own light.
## Known limits
- The beam, ring and scan line light every surface they pass through; they do not stop at walls the way a real signal would.
- At most 8 pings and the 32 nearest contacts are drawn.
- The sensorBlocks package README's Known limits lists the rest.
# Sweep: sonar ping (styleBlock, Colour)
A sonar ping: the world black until a ring ripples out from the ping, lighting surfaces cyan as it passes and fading slowly behind it.
It is one of the five sweep blocks; all run the `sweep` shader with their own defaults, so any one swaps for another in the Colour slot with one change. Pings come from `Sensors.ping(origin)` (sensorGoggles sends one from the wearer every few seconds while a ping sensor is on) and every player in the world sees the same ping; contacts and their roles come from styleRoles roles, the scene's players and entity names.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("sonarPing")
Sensors.ping(player.position, { speed = 25, range = 50 })
```
## What it gives up in motion
What a ping or beam revealed is fixed to the world, so it stays on surfaces as you move. The radar beam turns about once every three seconds and a ping ring travels at tens of metres a second; both light a band of the world, never the whole screen at once. Grain changes per pixel per frame.
## How it treats content
- Opaque things: dark until the beam, ping or scan line reaches them, then lit with their outline and fading.
- Transparent things (glass, water): not in the depth, so a ping passes through them and lights what is behind.
- Particles and smoke: not detected, like a real sonar or lidar.
- Sky: nothing returns, so it stays the background colour.
- Fog: ignored; the display shows returns, not light.
- Skinned characters: revealed like any surface, with their role marked; the motion tracker shows them only while they move.
- Foliage: revealed as a soft mass of outlines.
- World text: unreadable on the display; screen UI is drawn after the stack and is never touched.
- Black does not stay black: the display makes its own light.
## Known limits
- The beam, ring and scan line light every surface they pass through; they do not stop at walls the way a real signal would.
- At most 8 pings and the 32 nearest contacts are drawn.
- The sensorBlocks package README's Known limits lists the rest.
# sweep (shader)
The shader every sensorBlocks sweep block runs: the world revealed by what a sensor sends out (`mode`): 0 a radar beam turning round the viewer with range rings, fading blips and a scope in the corner, 1 sonar pings (Sensors.ping, shared by every player) rippling out and revealing then fading, 2 echolocation (pings plus faint outlines near you), 3 a laser scan line rising and falling with a fading point-cloud trail, 4 a motion tracker that shows only what moves on a fan-shaped scope. Contacts and their roles come from the sensor input.
## Known limits
- The radar beam is a screen effect on the world around the viewer, not a raycast: it does not stop at walls.
- See the sensorBlocks README for the rest.
# thermal (shader)
The shader every sensorBlocks thermal block runs: the temperature of what each pixel shows, read from heatSignatures's `heat` input with the `heatField` shader module, mapped across the climate's display range (or a fixed one) and drawn through one of eight palettes (`palette` 0 white hot, 1 black hot, 2 ironbow, 3 rainbow, 4 arctic, 5 lava, 6 medical, 7 threshold). It adds digital detail enhancement (a little of the scene's own edges), coarse sensor cells, per-pixel grain, the role marks that keep players, enemies and pickups apart, flash blinding and the goggles' power-on.
## Known limits
- Transparent things are not in the depth, so a window shows the heat of what is behind it rather than the cold glass a real thermal camera sees.
- See the sensorBlocks README for the rest.
# Thermal: arctic (styleBlock, Colour)
A thermal camera in arctic: the cold world in deep blues and ice whites, only warm things in gold and orange.
It is one of the eight thermal blocks; all run the `thermal` shader with their own defaults, so any one swaps for another in the Colour slot with one change, and every setting of one works on the others. The temperature comes from heatSignatures (install it; it finds people, animals, fires, engines, metal and water by their names, and `HeatSource` sets anything else), mapped over the climate's display range.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.add("thermalWhiteHot", { id = "sensor" })
StyleKit.swap("sensor", "thermalIronbow") -- one change
```
## What it gives up in motion
The heat of a moving thing moves with it, so nothing slides. The grain changes every frame per pixel at 30 steps a second, a fine sensor noise rather than a flicker; nothing lights the whole screen in a pulse. The coarse sensor cells (`resolution`) are fixed to the screen, as a real core is.
## How it treats content
- Opaque things: their heat, from heatSignatures's shapes and the climate, with a little of their shape and edges (`detail`).
- Transparent things (glass, water): drawn as the heat of what is behind them, since they are not in the depth. Give water a HeatSource or a name heatSignatures knows (stream, river, water) so its surface reads cool.
- Particles and smoke: fire particles are bright in the frame, and what glows reads hot; cold smoke is invisible, as on a real thermal camera.
- Sky: the climate's sky temperature, the coldest thing in the picture at night.
- Fog: ignored; thermal sees through light fog.
- Skinned characters: warm, from heatSignatures's person and animal classes, with cooler edges where clothes turn away.
- Foliage: green surfaces sit near the air temperature.
- World text: drawn as heat (unreadable, as on a real camera); keep labels a player must read in the screen UI, which is drawn after the stack.
- Black does not stay black: a sensor makes light where the eye saw none.
## Known limits
- Heat shapes are boxes and ellipsoids fitted to each thing's bounds; at most the 64 nearest the camera are drawn.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# Thermal: black hot (styleBlock, Colour)
A thermal camera in black hot: warm things are black on a pale world, easier on the eye for long watches and searching snow.
It is one of the eight thermal blocks; all run the `thermal` shader with their own defaults, so any one swaps for another in the Colour slot with one change, and every setting of one works on the others. The temperature comes from heatSignatures (install it; it finds people, animals, fires, engines, metal and water by their names, and `HeatSource` sets anything else), mapped over the climate's display range.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.add("thermalWhiteHot", { id = "sensor" })
StyleKit.swap("sensor", "thermalIronbow") -- one change
```
## What it gives up in motion
The heat of a moving thing moves with it, so nothing slides. The grain changes every frame per pixel at 30 steps a second, a fine sensor noise rather than a flicker; nothing lights the whole screen in a pulse. The coarse sensor cells (`resolution`) are fixed to the screen, as a real core is.
## How it treats content
- Opaque things: their heat, from heatSignatures's shapes and the climate, with a little of their shape and edges (`detail`).
- Transparent things (glass, water): drawn as the heat of what is behind them, since they are not in the depth. Give water a HeatSource or a name heatSignatures knows (stream, river, water) so its surface reads cool.
- Particles and smoke: fire particles are bright in the frame, and what glows reads hot; cold smoke is invisible, as on a real thermal camera.
- Sky: the climate's sky temperature, the coldest thing in the picture at night.
- Fog: ignored; thermal sees through light fog.
- Skinned characters: warm, from heatSignatures's person and animal classes, with cooler edges where clothes turn away.
- Foliage: green surfaces sit near the air temperature.
- World text: drawn as heat (unreadable, as on a real camera); keep labels a player must read in the screen UI, which is drawn after the stack.
- Black does not stay black: a sensor makes light where the eye saw none.
## Known limits
- Heat shapes are boxes and ellipsoids fitted to each thing's bounds; at most the 64 nearest the camera are drawn.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# Thermal: ironbow (styleBlock, Colour)
A thermal camera in ironbow: cold blue-black through purple and red to orange, yellow and white for the hottest, the inspection camera look.
It is one of the eight thermal blocks; all run the `thermal` shader with their own defaults, so any one swaps for another in the Colour slot with one change, and every setting of one works on the others. The temperature comes from heatSignatures (install it; it finds people, animals, fires, engines, metal and water by their names, and `HeatSource` sets anything else), mapped over the climate's display range.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.add("thermalWhiteHot", { id = "sensor" })
StyleKit.swap("sensor", "thermalIronbow") -- one change
```
## What it gives up in motion
The heat of a moving thing moves with it, so nothing slides. The grain changes every frame per pixel at 30 steps a second, a fine sensor noise rather than a flicker; nothing lights the whole screen in a pulse. The coarse sensor cells (`resolution`) are fixed to the screen, as a real core is.
## How it treats content
- Opaque things: their heat, from heatSignatures's shapes and the climate, with a little of their shape and edges (`detail`).
- Transparent things (glass, water): drawn as the heat of what is behind them, since they are not in the depth. Give water a HeatSource or a name heatSignatures knows (stream, river, water) so its surface reads cool.
- Particles and smoke: fire particles are bright in the frame, and what glows reads hot; cold smoke is invisible, as on a real thermal camera.
- Sky: the climate's sky temperature, the coldest thing in the picture at night.
- Fog: ignored; thermal sees through light fog.
- Skinned characters: warm, from heatSignatures's person and animal classes, with cooler edges where clothes turn away.
- Foliage: green surfaces sit near the air temperature.
- World text: drawn as heat (unreadable, as on a real camera); keep labels a player must read in the screen UI, which is drawn after the stack.
- Black does not stay black: a sensor makes light where the eye saw none.
## Known limits
- Heat shapes are boxes and ellipsoids fitted to each thing's bounds; at most the 64 nearest the camera are drawn.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# Thermal: lava (styleBlock, Colour)
A thermal camera in lava: black and deep red for the cold, orange and yellow-white for heat, like looking into embers.
It is one of the eight thermal blocks; all run the `thermal` shader with their own defaults, so any one swaps for another in the Colour slot with one change, and every setting of one works on the others. The temperature comes from heatSignatures (install it; it finds people, animals, fires, engines, metal and water by their names, and `HeatSource` sets anything else), mapped over the climate's display range.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.add("thermalWhiteHot", { id = "sensor" })
StyleKit.swap("sensor", "thermalIronbow") -- one change
```
## What it gives up in motion
The heat of a moving thing moves with it, so nothing slides. The grain changes every frame per pixel at 30 steps a second, a fine sensor noise rather than a flicker; nothing lights the whole screen in a pulse. The coarse sensor cells (`resolution`) are fixed to the screen, as a real core is.
## How it treats content
- Opaque things: their heat, from heatSignatures's shapes and the climate, with a little of their shape and edges (`detail`).
- Transparent things (glass, water): drawn as the heat of what is behind them, since they are not in the depth. Give water a HeatSource or a name heatSignatures knows (stream, river, water) so its surface reads cool.
- Particles and smoke: fire particles are bright in the frame, and what glows reads hot; cold smoke is invisible, as on a real thermal camera.
- Sky: the climate's sky temperature, the coldest thing in the picture at night.
- Fog: ignored; thermal sees through light fog.
- Skinned characters: warm, from heatSignatures's person and animal classes, with cooler edges where clothes turn away.
- Foliage: green surfaces sit near the air temperature.
- World text: drawn as heat (unreadable, as on a real camera); keep labels a player must read in the screen UI, which is drawn after the stack.
- Black does not stay black: a sensor makes light where the eye saw none.
## Known limits
- Heat shapes are boxes and ellipsoids fitted to each thing's bounds; at most the 64 nearest the camera are drawn.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# Thermal: medical (styleBlock, Colour)
A medical thermography palette: stepped colour bands from blue to red and white across a narrow range, so a fever or inflammation stands out as its own band.
It is one of the eight thermal blocks; all run the `thermal` shader with their own defaults, so any one swaps for another in the Colour slot with one change, and every setting of one works on the others. The temperature comes from heatSignatures (install it; it finds people, animals, fires, engines, metal and water by their names, and `HeatSource` sets anything else), mapped over the climate's display range.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.add("thermalWhiteHot", { id = "sensor" })
StyleKit.swap("sensor", "thermalIronbow") -- one change
```
## What it gives up in motion
The heat of a moving thing moves with it, so nothing slides. The grain changes every frame per pixel at 30 steps a second, a fine sensor noise rather than a flicker; nothing lights the whole screen in a pulse. The coarse sensor cells (`resolution`) are fixed to the screen, as a real core is.
## How it treats content
- Opaque things: their heat, from heatSignatures's shapes and the climate, with a little of their shape and edges (`detail`).
- Transparent things (glass, water): drawn as the heat of what is behind them, since they are not in the depth. Give water a HeatSource or a name heatSignatures knows (stream, river, water) so its surface reads cool.
- Particles and smoke: fire particles are bright in the frame, and what glows reads hot; cold smoke is invisible, as on a real thermal camera.
- Sky: the climate's sky temperature, the coldest thing in the picture at night.
- Fog: ignored; thermal sees through light fog.
- Skinned characters: warm, from heatSignatures's person and animal classes, with cooler edges where clothes turn away.
- Foliage: green surfaces sit near the air temperature.
- World text: drawn as heat (unreadable, as on a real camera); keep labels a player must read in the screen UI, which is drawn after the stack.
- Black does not stay black: a sensor makes light where the eye saw none.
## Known limits
- Heat shapes are boxes and ellipsoids fitted to each thing's bounds; at most the 64 nearest the camera are drawn.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# Thermal: rainbow (styleBlock, Colour)
A thermal camera in high-contrast rainbow: blue, cyan, green, yellow, red and white, so small temperature steps stand apart.
It is one of the eight thermal blocks; all run the `thermal` shader with their own defaults, so any one swaps for another in the Colour slot with one change, and every setting of one works on the others. The temperature comes from heatSignatures (install it; it finds people, animals, fires, engines, metal and water by their names, and `HeatSource` sets anything else), mapped over the climate's display range.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.add("thermalWhiteHot", { id = "sensor" })
StyleKit.swap("sensor", "thermalIronbow") -- one change
```
## What it gives up in motion
The heat of a moving thing moves with it, so nothing slides. The grain changes every frame per pixel at 30 steps a second, a fine sensor noise rather than a flicker; nothing lights the whole screen in a pulse. The coarse sensor cells (`resolution`) are fixed to the screen, as a real core is.
## How it treats content
- Opaque things: their heat, from heatSignatures's shapes and the climate, with a little of their shape and edges (`detail`).
- Transparent things (glass, water): drawn as the heat of what is behind them, since they are not in the depth. Give water a HeatSource or a name heatSignatures knows (stream, river, water) so its surface reads cool.
- Particles and smoke: fire particles are bright in the frame, and what glows reads hot; cold smoke is invisible, as on a real thermal camera.
- Sky: the climate's sky temperature, the coldest thing in the picture at night.
- Fog: ignored; thermal sees through light fog.
- Skinned characters: warm, from heatSignatures's person and animal classes, with cooler edges where clothes turn away.
- Foliage: green surfaces sit near the air temperature.
- World text: drawn as heat (unreadable, as on a real camera); keep labels a player must read in the screen UI, which is drawn after the stack.
- Black does not stay black: a sensor makes light where the eye saw none.
## Known limits
- Heat shapes are boxes and ellipsoids fitted to each thing's bounds; at most the 64 nearest the camera are drawn.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# Thermal: threshold (styleBlock, Colour)
Only things above a set heat show: the world in dull grey, anything hotter than the threshold in red, orange and yellow, a target-finder or isotherm alarm.
It is one of the eight thermal blocks; all run the `thermal` shader with their own defaults, so any one swaps for another in the Colour slot with one change, and every setting of one works on the others. The temperature comes from heatSignatures (install it; it finds people, animals, fires, engines, metal and water by their names, and `HeatSource` sets anything else), mapped over the climate's display range.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.add("thermalWhiteHot", { id = "sensor" })
StyleKit.swap("sensor", "thermalIronbow") -- one change
```
## What it gives up in motion
The heat of a moving thing moves with it, so nothing slides. The grain changes every frame per pixel at 30 steps a second, a fine sensor noise rather than a flicker; nothing lights the whole screen in a pulse. The coarse sensor cells (`resolution`) are fixed to the screen, as a real core is.
## How it treats content
- Opaque things: their heat, from heatSignatures's shapes and the climate, with a little of their shape and edges (`detail`).
- Transparent things (glass, water): drawn as the heat of what is behind them, since they are not in the depth. Give water a HeatSource or a name heatSignatures knows (stream, river, water) so its surface reads cool.
- Particles and smoke: fire particles are bright in the frame, and what glows reads hot; cold smoke is invisible, as on a real thermal camera.
- Sky: the climate's sky temperature, the coldest thing in the picture at night.
- Fog: ignored; thermal sees through light fog.
- Skinned characters: warm, from heatSignatures's person and animal classes, with cooler edges where clothes turn away.
- Foliage: green surfaces sit near the air temperature.
- World text: drawn as heat (unreadable, as on a real camera); keep labels a player must read in the screen UI, which is drawn after the stack.
- Black does not stay black: a sensor makes light where the eye saw none.
## Known limits
- Heat shapes are boxes and ellipsoids fitted to each thing's bounds; at most the 64 nearest the camera are drawn.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# Thermal: white hot (styleBlock, Colour)
A thermal camera in white hot: warm things glow white on a black and grey world, the classic military and police look.
It is one of the eight thermal blocks; all run the `thermal` shader with their own defaults, so any one swaps for another in the Colour slot with one change, and every setting of one works on the others. The temperature comes from heatSignatures (install it; it finds people, animals, fires, engines, metal and water by their names, and `HeatSource` sets anything else), mapped over the climate's display range.
```luau
local StyleKit = require("~styleKit.StyleKit")
StyleKit.add("thermalWhiteHot", { id = "sensor" })
StyleKit.swap("sensor", "thermalIronbow") -- one change
```
## What it gives up in motion
The heat of a moving thing moves with it, so nothing slides. The grain changes every frame per pixel at 30 steps a second, a fine sensor noise rather than a flicker; nothing lights the whole screen in a pulse. The coarse sensor cells (`resolution`) are fixed to the screen, as a real core is.
## How it treats content
- Opaque things: their heat, from heatSignatures's shapes and the climate, with a little of their shape and edges (`detail`).
- Transparent things (glass, water): drawn as the heat of what is behind them, since they are not in the depth. Give water a HeatSource or a name heatSignatures knows (stream, river, water) so its surface reads cool.
- Particles and smoke: fire particles are bright in the frame, and what glows reads hot; cold smoke is invisible, as on a real thermal camera.
- Sky: the climate's sky temperature, the coldest thing in the picture at night.
- Fog: ignored; thermal sees through light fog.
- Skinned characters: warm, from heatSignatures's person and animal classes, with cooler edges where clothes turn away.
- Foliage: green surfaces sit near the air temperature.
- World text: drawn as heat (unreadable, as on a real camera); keep labels a player must read in the screen UI, which is drawn after the stack.
- Black does not stay black: a sensor makes light where the eye saw none.
## Known limits
- Heat shapes are boxes and ellipsoids fitted to each thing's bounds; at most the 64 nearest the camera are drawn.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# xray (shader)
The shader every sensorBlocks x-ray block runs. It reads the `xray` and `xrayMetal` inputs that XrayPass draws (every surface summed along each pixel's ray, walls seen edge-on counting more, and metal on its own) and makes one of five pictures (`mode`): 0 a medical film, 1 its negative, 2 an airport baggage scanner's false colours (organic orange, mixed green, metal blue), 3 a sci-fi see-through scan with glowing edges and an optional scan line, 4 a soft green live fluoroscope.
## Known limits
- It sums surfaces rather than measuring real density, so there are no bones inside a character unless the model has them; a character reads as its outline and folds.
- See the sensorBlocks README for the rest.
# X-ray: airport baggage scanner (styleBlock, Colour)
An airport baggage scanner in its false colours: organic things orange, mixed materials green, metal blue and the densest metal near black, on white.
It is one of the five x-ray blocks; all run the `xray` shader with their own defaults, so any one swaps for another in the Colour slot with one change. The see-through layers are drawn by the sensor runtime (XrayPass) only while an x-ray block is on, and metal comes from heatSignatures's classes (crates, engines, vehicles, electronics, or a HeatSource with class metal).
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("xrayBaggage")
```
## What it gives up in motion
The layers are drawn fresh every frame from the scene's geometry, so they move with things and nothing slides. Grain changes per pixel per frame; the sci-fi scan line sweeps slowly (seconds per pass) and never flashes the whole screen.
## How it treats content
- Opaque things: seen through, every surface along the ray adding to the picture, walls seen edge-on most.
- Transparent things (glass, water): drawn as layers like anything else, so glass shows in an x-ray.
- Particles and smoke: particles that are meshes add faint layers; screen-space effects do not.
- Sky: nothing absorbs, so it is the film's background.
- Fog: ignored; rays pass through fog.
- Skinned characters: their skinned surfaces add layers, so a character reads as a translucent outline with its folds.
- Foliage: leaves and grass add many thin layers, a soft haze.
- World text: text drawn on surfaces disappears into the layers; screen UI is drawn after the stack and is never touched.
- Black does not stay black: the picture is the x-ray, not the light.
## Known limits
- It counts surfaces, not real density, so a hollow box and a solid one of the same size read alike, and a character has no bones unless its model does.
- It redraws every surface once more (twice for metal) while it is on; see the sensorBlocks README for the measured cost.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# X-ray: green fluoroscope (styleBlock, Colour)
A live green fluoroscope: a soft, noisy, moving x-ray in phosphor green inside a round screen, like an old shoe-fitting machine or a cath lab monitor.
It is one of the five x-ray blocks; all run the `xray` shader with their own defaults, so any one swaps for another in the Colour slot with one change. The see-through layers are drawn by the sensor runtime (XrayPass) only while an x-ray block is on, and metal comes from heatSignatures's classes (crates, engines, vehicles, electronics, or a HeatSource with class metal).
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("xrayBaggage")
```
## What it gives up in motion
The layers are drawn fresh every frame from the scene's geometry, so they move with things and nothing slides. Grain changes per pixel per frame; the sci-fi scan line sweeps slowly (seconds per pass) and never flashes the whole screen.
## How it treats content
- Opaque things: seen through, every surface along the ray adding to the picture, walls seen edge-on most.
- Transparent things (glass, water): drawn as layers like anything else, so glass shows in an x-ray.
- Particles and smoke: particles that are meshes add faint layers; screen-space effects do not.
- Sky: nothing absorbs, so it is the film's background.
- Fog: ignored; rays pass through fog.
- Skinned characters: their skinned surfaces add layers, so a character reads as a translucent outline with its folds.
- Foliage: leaves and grass add many thin layers, a soft haze.
- World text: text drawn on surfaces disappears into the layers; screen UI is drawn after the stack and is never touched.
- Black does not stay black: the picture is the x-ray, not the light.
## Known limits
- It counts surfaces, not real density, so a hollow box and a solid one of the same size read alike, and a character has no bones unless its model does.
- It redraws every surface once more (twice for metal) while it is on; see the sensorBlocks README for the measured cost.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# X-ray: medical film (styleBlock, Colour)
A medical x-ray film: everything turned to blue-grey translucent layers on near black, dense and metal things bright white, edges glowing like bone.
It is one of the five x-ray blocks; all run the `xray` shader with their own defaults, so any one swaps for another in the Colour slot with one change. The see-through layers are drawn by the sensor runtime (XrayPass) only while an x-ray block is on, and metal comes from heatSignatures's classes (crates, engines, vehicles, electronics, or a HeatSource with class metal).
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("xrayBaggage")
```
## What it gives up in motion
The layers are drawn fresh every frame from the scene's geometry, so they move with things and nothing slides. Grain changes per pixel per frame; the sci-fi scan line sweeps slowly (seconds per pass) and never flashes the whole screen.
## How it treats content
- Opaque things: seen through, every surface along the ray adding to the picture, walls seen edge-on most.
- Transparent things (glass, water): drawn as layers like anything else, so glass shows in an x-ray.
- Particles and smoke: particles that are meshes add faint layers; screen-space effects do not.
- Sky: nothing absorbs, so it is the film's background.
- Fog: ignored; rays pass through fog.
- Skinned characters: their skinned surfaces add layers, so a character reads as a translucent outline with its folds.
- Foliage: leaves and grass add many thin layers, a soft haze.
- World text: text drawn on surfaces disappears into the layers; screen UI is drawn after the stack and is never touched.
- Black does not stay black: the picture is the x-ray, not the light.
## Known limits
- It counts surfaces, not real density, so a hollow box and a solid one of the same size read alike, and a character has no bones unless its model does.
- It redraws every surface once more (twice for metal) while it is on; see the sensorBlocks README for the measured cost.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# X-ray: negative (styleBlock, Colour)
An x-ray negative: dense things dark on a pale film, like an old radiograph held against a light box.
It is one of the five x-ray blocks; all run the `xray` shader with their own defaults, so any one swaps for another in the Colour slot with one change. The see-through layers are drawn by the sensor runtime (XrayPass) only while an x-ray block is on, and metal comes from heatSignatures's classes (crates, engines, vehicles, electronics, or a HeatSource with class metal).
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("xrayBaggage")
```
## What it gives up in motion
The layers are drawn fresh every frame from the scene's geometry, so they move with things and nothing slides. Grain changes per pixel per frame; the sci-fi scan line sweeps slowly (seconds per pass) and never flashes the whole screen.
## How it treats content
- Opaque things: seen through, every surface along the ray adding to the picture, walls seen edge-on most.
- Transparent things (glass, water): drawn as layers like anything else, so glass shows in an x-ray.
- Particles and smoke: particles that are meshes add faint layers; screen-space effects do not.
- Sky: nothing absorbs, so it is the film's background.
- Fog: ignored; rays pass through fog.
- Skinned characters: their skinned surfaces add layers, so a character reads as a translucent outline with its folds.
- Foliage: leaves and grass add many thin layers, a soft haze.
- World text: text drawn on surfaces disappears into the layers; screen UI is drawn after the stack and is never touched.
- Black does not stay black: the picture is the x-ray, not the light.
## Known limits
- It counts surfaces, not real density, so a hollow box and a solid one of the same size read alike, and a character has no bones unless its model does.
- It redraws every surface once more (twice for metal) while it is on; see the sensorBlocks README for the measured cost.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# X-ray: sci-fi wall scan (styleBlock, Colour)
A sci-fi see-through scan: walls turn to translucent cyan glass on a dark void, every edge burning bright, with a slow scan line sweeping down.
It is one of the five x-ray blocks; all run the `xray` shader with their own defaults, so any one swaps for another in the Colour slot with one change. The see-through layers are drawn by the sensor runtime (XrayPass) only while an x-ray block is on, and metal comes from heatSignatures's classes (crates, engines, vehicles, electronics, or a HeatSource with class metal).
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("xrayBaggage")
```
## What it gives up in motion
The layers are drawn fresh every frame from the scene's geometry, so they move with things and nothing slides. Grain changes per pixel per frame; the sci-fi scan line sweeps slowly (seconds per pass) and never flashes the whole screen.
## How it treats content
- Opaque things: seen through, every surface along the ray adding to the picture, walls seen edge-on most.
- Transparent things (glass, water): drawn as layers like anything else, so glass shows in an x-ray.
- Particles and smoke: particles that are meshes add faint layers; screen-space effects do not.
- Sky: nothing absorbs, so it is the film's background.
- Fog: ignored; rays pass through fog.
- Skinned characters: their skinned surfaces add layers, so a character reads as a translucent outline with its folds.
- Foliage: leaves and grass add many thin layers, a soft haze.
- World text: text drawn on surfaces disappears into the layers; screen UI is drawn after the stack and is never touched.
- Black does not stay black: the picture is the x-ray, not the light.
## Known limits
- It counts surfaces, not real density, so a hollow box and a solid one of the same size read alike, and a character has no bones unless its model does.
- It redraws every surface once more (twice for metal) while it is on; see the sensorBlocks README for the measured cost.
- It runs on the whole frame after antialiasing, so offscreen captures, mirrors and render-to-texture cameras do not show it.
- The sensorBlocks package README's Known limits lists the rest.
# Aerochrome (styleLook)
Colour infrared film: red and magenta forests, deep blue skies, the surreal Aerochrome landscape.
Blocks: colourInfrared, softGrain.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("aerochrome") -- your own view only (goggles)
Sensors.use("aerochrome", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Airport scanner (styleLook)
An airport baggage scanner: everything in false colours on white, organic orange, mixed green, metal blue.
Blocks: xrayBaggage.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("airportScanner") -- your own view only (goggles)
Sensors.use("airportScanner", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Auto-gated night vision (styleLook)
Special-forces auto-gated night vision: clean gen-3 green that dims itself when a lamp, a fire or a flash comes into view, seen through binocular tubes.
Blocks: nvAutoGated (Colour), opticsBinocular (Medium).
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("autoGatedNightVision") -- your own view only (goggles)
Sensors.use("autoGatedNightVision", { shared = true }) -- every player, kept with the scene
```
## Known limits
- Every block it names must be installed (sensorBlocks); a look with a missing block is refused.
- The gate reads 16 points of the frame; see the nvAutoGated block's Known limits.
# Blacklight party (styleLook)
A blacklight party: the room a deep violet, day-glo paint, neon and white clothes blazing with a soft glow.
Blocks: uvBlacklight, vignette.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("blacklightParty") -- your own view only (goggles)
Sensors.use("blacklightParty", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Deep space false colour (styleLook)
A space telescope image: the world in teal and gold false colour with diffraction spikes on bright lights.
Blocks: spaceFalseColour.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("deepSpace") -- your own view only (goggles)
Sensors.use("deepSpace", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Depth camera (styleLook)
A depth camera's view: distance in a colour map from red near to blue far.
Blocks: depthMap (colour map).
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("depthCamera") -- your own view only (goggles)
Sensors.use("depthCamera", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Echolocation horror (styleLook)
Blind in the dark: nothing but soft white ripples from each click outlining the world for a moment, and the dark closing in at the edges.
Blocks: echolocation, vignette.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("echoHorror") -- your own view only (goggles)
Sensors.use("echoHorror", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Gen-1 night vision (styleLook)
Old first-generation night vision: a grainy, blurry green tube with a hot illuminator spot, seen through one monocular.
Blocks: nvGen1Green, opticsMonocular.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("gen1NightVision") -- your own view only (goggles)
Sensors.use("gen1NightVision", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Gen-2 night vision (styleLook)
Gen-2 night vision goggles, the classic cold-war and police tube: a green picture with visible grain, a honeycomb and wide halos, through a single monocular.
Blocks: nvGen2Green (Colour), opticsMonocular (Medium).
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("gen2NightVision") -- your own view only (goggles)
Sensors.use("gen2NightVision", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has, and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Gen-3 night vision (styleLook)
Modern gen-3 night vision goggles: a clean bright green picture with halos round every light, seen through binocular tubes.
Blocks: military,.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("gen3NightVision") -- your own view only (goggles)
Sensors.use("gen3NightVision", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Horror infrared (styleLook)
Found-footage horror in infrared: a grainy black-and-white security camera night mode with a bright ring near the lens and darkness beyond, framed by a heavy vignette.
Blocks: nvSecurityIR, softGrain, vignette.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("horrorInfrared") -- your own view only (goggles)
Sensors.use("horrorInfrared", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Infrared landscape (styleLook)
Black-and-white infrared landscape photography: trees and grass white as snow under a black sky, with halation and film grain.
Blocks: irFilm, softGrain, vignette.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("infraredLandscape") -- your own view only (goggles)
Sensors.use("infraredLandscape", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Lab microscope (styleLook)
A scanning electron microscope image: grey surfaces bright on every edge, grainy row by row, with a data bar.
Blocks: electronMicroscope.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("labMicroscope") -- your own view only (goggles)
Sensors.use("labMicroscope", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Medical thermography (styleLook)
A medical thermography screen: stepped colour bands over a narrow range so a fever stands out.
Blocks: thermalMedical.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("medicalThermal") -- your own view only (goggles)
Sensors.use("medicalThermal", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Medical x-ray (styleLook)
A hospital x-ray film: translucent blue-grey layers on black, dense things bright.
Blocks: xrayMedical, softGrain.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("medicalXray") -- your own view only (goggles)
Sensors.use("medicalXray", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Military thermal (styleLook)
A military thermal weapon sight: white-hot thermal with a coarse sensor and crisp detail, seen through a wide round sight with a crosshair.
Blocks: thermalWhiteHot, opticsScope (wide, crosshair).
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("militaryThermal") -- your own view only (goggles)
Sensors.use("militaryThermal", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
Part of sensorBlocks, version 1.0.0.
# Motion tracker (styleLook)
A space marine's motion tracker: the world almost black, anything moving glows, and the fan scope pulses at the bottom.
Blocks: motionTracker, softGrain.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("motionTrackerLook") -- your own view only (goggles)
Sensors.use("motionTrackerLook", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Predator vision (styleLook)
A hunting creature's heat vision: a coarse rainbow thermal picture where every warm body blazes red and white.
Blocks: thermalRainbow (coarse), vignette.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("predatorVision") -- your own view only (goggles)
Sensors.use("predatorVision", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Four-tube white phosphor (styleLook)
Special forces four-tube panoramic goggles in white phosphor: a wide blue-white view broken by the gaps between tubes.
Blocks: nvWhitePhosphor, opticsQuad.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("quadNightVision") -- your own view only (goggles)
Sensors.use("quadNightVision", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Radar operator (styleLook)
A radar operator's display: the turning green beam paints the land and range rings, blips glow and fade on the scope.
Blocks: radarSweep, vignette.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("radarOperator") -- your own view only (goggles)
Sensors.use("radarOperator", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Sci-fi scanner (styleLook)
A sci-fi visor scan: walls turn to glowing cyan glass with burning edges, and a laser scan line rises and falls through the world.
Blocks: xraySciFi, laserScan (laid over at 0.4).
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("sciFiScanner") -- your own view only (goggles)
Sensors.use("sciFiScanner", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Security camera (styleLook)
A cheap security camera at night: chunky pixels, scanlines and black and white infrared.
Blocks: nvSecurityIR, chunkyPixels.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("securityCamera") -- your own view only (goggles)
Sensors.use("securityCamera", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Sniper thermal scope (styleLook)
A black-hot thermal rifle scope: warm bodies dark on a pale world through a sharp scope with mil-dots.
Blocks: thermalBlackHot, opticsScope.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("sniperThermal") -- your own view only (goggles)
Sensors.use("sniperThermal", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
# Submarine sonar (styleLook)
A submarine's sonar: a black world where green pings ripple out and paint what they touch, with a radar scope in the corner.
Blocks: sonarPing (green), radarSweep (laid over at 0.35 for its scope), vignette.
```luau
local Sensors = require("~sensorBlocks.Sensors")
Sensors.use("submarineSonar") -- your own view only (goggles)
Sensors.use("submarineSonar", { shared = true }) -- every player, kept with the scene
```
It lays its blocks over whatever look the scene already has (an ink line, a paper or a film grain from the Style Cookbook stay under it), and `Sensors.off()` takes it away again.
## Known limits
- Every block it names must be installed (sensorBlocks, and starterBlocks for grain, vignette and pixels); a look with a missing block is refused.
- The sensorBlocks package README Known limits lists the rest.
·renderfeature · born here
❒asset # sensorField (render feature)
sensorBlocks' per-frame hook. In its `render` step each frame it calls `Sensors.frame`, which packs this machine's sensor state (goggles power, flash blinding, gain, heading), the live sonar pings and the nearest contacts with their roles into a 41 x 4 data texture and publishes it to styleKit as the `sensor` input; while an x-ray block is on it also queues XrayPass's two geometry passes. All of this happens before the style stack runs at the end of the frame, so nothing shows from it alone: the sensor blocks turn it into rings, outlines and wash-outs.
`Sensors.use` and `Sensors.start()` create it on each machine; you never create it yourself.
## Known limits
- Main camera only: offscreen captures, mirrors and render-to-texture cameras get no sensor input.
# sensorCommon (shader module)
What every sensor block shares, in WGSL: reading the `sensor` input (viewer, time, flash blinding, goggles power, sweep angle, gain, heading, infrared illuminator), the live pings, the contact under a pixel with its role, per-pixel sensor grain, and the exit every sensor block returns through. Used by all six sensorBlocks shaders (thermal, nightVision, optics, xray, sweep, spectral) and by any sensor block you write.
| Function | What it gives |
|---|---|
| `sn_contact(uv)` | The contact at uv: x role (0 none, 1 you, 2 ally, 3 enemy, 4 elite or boss, 5 pickup, 6 hazard, 7 objective), y how far inside, z moving, w index. |
| `sn_role_cue(col, uv, c, strength, ink, tint)` | Marks the role so things read apart in one colour: you and allies a steady outline with a slow 1 Hz friend-or-foe blink, enemies a bright outline and diagonal hatching, pickups a slow shimmer, hazards a dashed outline. |
| `sn_role_colour(role)` | A role's accent colour for sensors that show colour. |
| `sn_blind_apply(col, ink, sensitivity)` | The flash wash-out (rate-limited by Sensors). |
| `sn_power_apply(col, uv, ink)` | Goggles switching on: instant, tube warm-up, old monitor or digital boot. |
| `sn_grain(uv, rate, cell)` | Fine per-pixel noise, never a whole-screen flicker. |
| `sn_silhouette(uv, px)` | Where an outline belongs. |
| `sn_finish(uv, src, styled)` | Use instead of `sk_finish`: strength, mask and layer mode as styleKit applies them, without the black-stays-black cap (a sensor makes light where the eye saw none). |
```wgsl
// block.yaml: reads: [frame, depth, normal, albedo, "input:sensor"]
// properties.yaml: - { name: in_sensor, type: texture, default: black }
#include "~styleKit.shaders.skCommon"
#include "~sensorBlocks.shaders.sensorCommon"
```
Include it after styleKit's `skCommon`. With nothing published it falls back to safe values (power on, no pings, no contacts).
## Known limits
- At most 32 contacts and 8 pings are in the input.
- Contact shapes are boxes fitted to bounds, so outlines follow the box edge where the silhouette test finds none.
# sensorInk (shader module)
Keeps the ink of the blocks under a sensor. styleKit runs the Line slot before the Colour slot, and every sensor block replaces all colour, so without this a Style Cookbook line (starterBlocks, inkBlocks) would vanish under thermal, night vision or x-ray. `sn_keep_ink(col, uv, amount)` compares the picture the earlier blocks handed on with the frame as it entered the stack (`sk_rendered`), finds the thin strokes they darkened, and draws them back over the sensor picture as a distinct line: dark on a bright picture, light on a dark one. Broad washes and tints do not print, and with nothing under the sensor it costs two texture reads.
The thermal, night vision, x-ray, sweep and spectral shaders include it; every sensor block has a `keepInk` setting (0 drops the ink, 1 keeps it fully).
```wgsl
#include "~styleKit.shaders.skCommon"
#include "~styleKit.shaders.skRendered"
#include "~sensorBlocks.shaders.sensorInk"
// properties: sk_rendered (texture) straight after the shared header, keepInk (float)
// block.yaml: reads: [..., rendered]
col = sn_keep_ink(col, in.uv, material.keepInk);
```
## Known limits
- It finds ink by darkening, so a light-coloured line (chalk on a board) under a sensor is not carried over.
- A stroke wider than about six reference pixels reads as a wash and fades out.
Used by sensorBlocks 1.0.6 and later.
# xrayLayers (shader)
sensorBlocks internal surface shader for the x-ray passes (XrayPass): every surface draws into a screen image with additive blending, both sides and no depth test, so each pixel sums what lies along its ray (r: layers weighted toward surfaces seen edge-on, g: how many surfaces). The x-ray blocks read the result as the `xray` and `xrayMetal` inputs.
## Known limits
- It counts surfaces rather than measuring true thickness, so a thin hollow box and a solid one of the same size read alike.
# sensorBlocks (test suite)
Checks sensorBlocks as a game uses it: all 33 sensor blocks pass styleKit's block rules, all 22 sensor looks name only installed blocks, `Sensors.use` lays a look as local styleKit entries on this machine without touching the synced stack and `Sensors.off` takes them back, `Sensors.use` with `shared = true` puts the look on the synced stack and `Sensors.off({ shared = true })` removes only the sensor blocks (a `softGrain` entry from starterBlocks stays), pings are listed by `Sensors.pulses` with an age that grows and never jumps, flashes at the camera blind night vision with no more than three new washes a second (read through `Sensors.status().blind` over frames), and the x-ray passes run while `xraySciFi` is local.
The suite saves the synced stack and this machine's sensor look and puts both back. It leaves the blocks' pictures (what thermal or night vision looks like) to the Lookbook and to visual review.
Run: `asset.resolve("sensorBlocks", "testSuite"):run()`.
## Known limits
- Runs in edit mode with a drawn view: the flash, x-ray and frame checks need `Sensors.frame`, which the sensorField render feature calls each frame.
- The flash test aims at the camera position from `renderer.mainCameraView`; a camera moving fast while it runs can move the numbers.
- The shared test writes the synced StyleStack, so other players see night vision for a moment while it runs.
- "a ping's age is monotonic" fails on sensorBlocks 1.0.0: `now()` in `Sensors.module/init.luau` adds `time.realtime() % 1` to `os.time()`, whose seconds do not tick together, so an age jumps by about a second once a second.
# sensorWorld
Turn an existing scene into a sensor look (a thermal camera, night vision goggles, x-ray, sonar, infrared) with heatSignatures, sensorBlocks and sensorGoggles, without editing any material or code.
## What it does
1. **Survey.** Reads the scene before changing anything: every entity's name, what heatSignatures finds by itself (`Heat.sources()`), what is warm or cold in fact but was missed or matched wrongly, characters with the role each should read as, pickups, hazards, transparent things and any style stack already in place.
2. **Climate.** Chooses a heat climate for the place and time (temperate night, desert day, arctic, factory, horror lair, with overrides) and applies it for every player.
3. **Heat.** Adds `HeatSource` components where the name defaults miss or are wrong, sets what is working or warms when moving, and adds name rules where many things share a word.
4. **Look.** Picks a sensor look (or a sensor block and an optic), puts it on, and tunes its settings in up to three rounds against presented frames so warm things stand out and night vision stays readable.
5. **Roles.** Gives roles with styleRoles (or `StyleKit.give`) so the player, enemies, pickups and hazards read apart under the sensor (outline and blink, hatching, shimmer, dashes), and picks the stealth or spooky role set where it fits.
6. **Goggles.** Adds one `GogglesRig` with suitable modes, power style and readout so each player has their own goggles, and presses the controls to prove them; or, with `goggles = false`, puts the look on the shared stack for everyone.
7. **Verify.** Checks the presented frame: one player's goggles do not change another's view, flashes wash out night vision no more than three times a second, pings ripple and fade, UI reads, transparent things are noted.
8. **Cost.** Measures frame time with and without the sensor look.
9. **Report.** Answers with the climate, every HeatSource, rule and role added, the look and its tuning, the goggles, the checks, the cost, and how to remove each change.
Everything it adds is a HeatSource, a name rule, a role, a climate, a GogglesRig or stack entries; each is listed with how to take it off.
## What it needs
sensorGoggles installed (it brings sensorBlocks, heatSignatures and styleKit), and the world in play for the look, goggles and verification steps. styleRoles is used when installed.
## Starting it
zero workflow start --name sensorWorld --args '{"scene":"forestNight","look":"military thermal scope with night vision as the second mode"}'
`scene` names the scene (default: the loaded one); `look` is the feel in the asker's words (default: the run proposes one); `goggles` false puts the look on for every player instead of per-player goggles (default true).
## Known limits
- Tuned settings do not carry into goggle modes, which take plain look ids; the run says which tuning mattered.
- Name rules (`Heat.addRule`) are per machine, so the run says where to call them from; HeatSource components are synced.
- The sensorBlocks package README's Known limits lists the rest.