High Level Peripherals

A CC:Tweaked monitor peripheral that actually keeps up with what you want to build.

A fork of Tom’s Peripherals, rebuilt to be far more usable, stable, and complete —
bigger screens, real GPU-rendered shaders, full mouse/touch input, and a cleaner API
that doesn’t fight you.

✨ Features

🖥️ Big, sharp monitors

Build arrays up to 32×32 blocks (admin-adjustable up to 64×64), with per-block
resolution up to 4096×4096. Draw with a full 2D API — filled shapes, gradients, text
with custom fonts, image loading, double buffering — all running server-side, synced
to every client automatically.

⚡ Real GPU shaders, not Lua math

Write a small GLSL-like shader once and it renders **live on every viewer’s own
graphics card**, at their own framerate, completely decoupled from the server tick.
No more choking the game with per-pixel Lua raymarching — the shader engine handles
that with zero Lua involved per pixel. Includes first-class raytracing primitives
(sphere/plane/box intersection) so you’re not hand-rolling ray math from scratch.

gpu.compileShader([[
  color = vec3(uv.x, uv.y, sin(time));
]])

That’s it — it’s already rendering.

🖱️ Full mouse input

Click, right-click, drag, and scroll directly on a monitor’s screen face, with
pixel-accurate coordinates delivered straight to your script. Respects whatever
controls the player has configured — no hardcoded key assumptions. Perfect for
building actual interactive UIs, not just static displays.

🎮 3D immediate-mode rendering

An OpenGL-1-style API (glBegin/glVertex/glTranslate/glRotate/lighting) for
building real 3D scenes on a monitor without writing a shader — great for models,
diagrams, or simple games.

🔆 Brightness control

Scale a monitor’s output brightness in nits, from dim ambient displays to
eye-searingly bright — applies to both drawn pixels and live shaders.

🧠 Room to build big

Generous default VRAM budget (~2 GiB per screen) shared across framebuffers, images,
and shader textures, with server-configurable limits for bigger builds.

Why this fork?

Tom’s Peripherals gave monitors and a GPU peripheral, but hit real ceilings fast —
low resolution limits, no shader rendering, no mouse input, and a handful of
long-standing multiblock/sync bugs. High Level Peripherals keeps the same familiar
peripheral.find("tm_monitor") API you already know, and pushes every one of those
ceilings out — so your builds stop being limited by the peripheral and start being
limited by your imagination.

Getting started

local gpu = peripheral.find("tm_monitor")
gpu.fill(0x000000)
gpu.drawText(10, 10, "Hello, HLPS!", 0xFFFFFF)

Full API reference below.

Docs

`tm_monitor` Lua API Reference

Complete reference for the monitor peripheral: 2D drawing, text, images, the 3D
immediate-mode API, mouse/scroll input, and the shader engine.

1. Limits

2. Color format

Packed 0xRRGGBB ints, or (r,g,b[,a]) 0-255 each.

Alpha 0 or 255 → opaque.
Alpha 1..254 → source-over blend: out = (src*a + dst*(255-a)) / 255.
getPixel/getpx return 0xRRGGBB (alpha stripped).

3. Sizing

Keep setSize low (64-256) if drawing per-pixel in Lua — use the shader engine
(section 8) instead for anything procedural.

4. Basic 2D drawing

All coordinates are 1-based.

5. Double buffering

gpu.setDoubleBuffered(true)
-- ... draw calls ...
gpu.flush()   -- presents + syncs

gpu.sync() pushes the framebuffer directly (throttled internally) — not usually
needed outside double-buffering/shader flows.

6. Text

7. Images and buffers

All charge VRAM (w*h*4 bytes) up front and throw if over budget.

8. The shader engine

Write a small GLSL-like program once; it runs per-pixel on the real GPU, no Lua
involved.

gpu.compileShader([[
  float sdSphere(vec3 p, float r) { return length(p) - r; }
  uniform float speed;
  color = vec3(uv.x, uv.y, sin(time * speed));
]])
gpu.setUniform("speed", 2.0)

There’s no main — code after the function defs runs top-to-bottom; color is the
pixel output. gpu.clearShader() returns to normal 2D drawing.

gpu.isGpuMode() → true while a shader is live.
gpu.setUniform(name, value) / gpu.setUniform3(name, x, y, z) — live-update, no recompile.
gpu.setGpuResolution(w, h) — resolution the shader renders at (independent of setSize). Match your array’s cols:rows shape or don’t call it.

A live shader has no ongoing tie to the computer that started it — it stops only if
the last attached computer disconnects, or you call gpu.clearShader().

texture() isn’t GPU-accelerated yet — a texture-sampling shader compiles fine
but won’t auto-render. Drive it yourself:

gpu.compileShader(src)
gpu.uploadTexture(0, w, h, pixels)
while true do
  gpu.runShader(os.clock())
  gpu.sync()
  sleep(0)
end

Shader language

Two types: float, vec3.
Predefined: color (write this), uv (.x/.y 0..1, .y=0 at top), res, time.
uniform <float|vec3> name;
Functions: <float|vec3> name(params) { ...; return expr; }. No recursion. Must appear before any other top-level statement, including uniform declarations.
Control flow: if/else, for (init; cond; update) {}, break;, return expr;.
Operators: + - * /, unary - !, comparisons, && ||, .x .y .z swizzle. vec3 * float works; float * vec3 does not.
Built-ins: vec3(f,f,f), sin cos tan sqrt abs floor fract exp pow mod min max step clamp mix smoothstep length dot cross normalize reflect, texture(slot, u, v).
Raytracing builtins (return nearest positive hit distance, or -1.0 for a miss): intersectSphere(ro, rd, center, radius), intersectPlane(ro, rd, planeY), intersectBox(ro, rd, center, halfSize).

9. Memory

10. Mouse & scroll input

Fires only while looking at the screen face with no GUI open. Sneaking has no effect.
Keyboard input isn’t captured here — that’s a separate keyboard peripheral.

x, y are screen-absolute (1-based) across the whole array.

while true do
  local ev, side, x, y, button, action = os.pullEvent("tm_monitor_mouse")
  gpu.setPixel(x, y, 0xFF0000)
  gpu.sync()
end

11. 3D immediate-mode API

gpu3d = gpu.createWindow3D(...)
gpu3d.glFrustum(70, 0.1, 100)
gpu3d.glLoadIdentity()
gpu3d.glTranslate(0, 0, -5)
gpu3d.glDirLight(0, -1, 0)
gpu3d.glBegin(4)   -- triangles
gpu3d.glColor(0xFF0000)
gpu3d.glVertex(-1, -1, 0)
gpu3d.glVertex( 1, -1, 0)
gpu3d.glVertex( 0,  1, 0)
gpu3d.glEnd()
gpu3d.render()
gpu3d.sync()

12. Performance

All drawing is server-side Java, always — singleplayer, LAN, or dedicated. Pushing
pixels to the client is the one real client cost, done via a bulk memory copy.

Per-pixel Lua drawing (raymarching, plasma, etc.) will choke a client — use the shader
engine instead, which runs on the GPU with zero Lua per pixel.

13. Brightness (nits)

gpu.setBrightness(200)   -- 2x normal
print(gpu.getBrightness())

nits / 100 scales final pixel output — 100 is default (1.0x). Applies to both CPU
drawing and GPU shaders. Values that would exceed 255 clip instead of wrapping. Range
is server-configurable (minBrightnessNits/maxBrightnessNits, default 10–400).

High Level Peripherals

介绍