Fix issue #101: Add lights to maps
All checks were successful
Test / test (push) Successful in 2s
All checks were successful
Test / test (push) Successful in 2s
This commit is contained in:
@@ -22,6 +22,11 @@ $themes: (
|
||||
|
||||
note-border: #202324,
|
||||
|
||||
// A map's lighting: the dark the lights are carved out of, and the walls that cut them. The map
|
||||
// canvas reads both off these variables (see components/viewer/map/MapViewerPane.vue).
|
||||
map-darkness: #000000d9,
|
||||
map-wall: #e06c75,
|
||||
|
||||
hover: #21262d,
|
||||
selected: #4a4a4b,
|
||||
border-color: #819796,
|
||||
@@ -70,6 +75,11 @@ $themes: (
|
||||
|
||||
note-border: #e0e0e0,
|
||||
|
||||
// Same lighting keys as the dark map; the dark over a map is the dark of a room whichever theme
|
||||
// the app is drawn in, and its walls are darkened to stay readable over a light image.
|
||||
map-darkness: #000000d9,
|
||||
map-wall: #c62828,
|
||||
|
||||
border-color: #e0e0e0,
|
||||
border: #f0f0f0,
|
||||
hover: #e9e9e9,
|
||||
|
||||
@@ -5,6 +5,7 @@ import { ClearWindow, CreateWindow, GetFirstWindowId } from '@/services/Windows'
|
||||
import { HideContextMenu, ShowContextMenu } from '~/services/ContextMenu';
|
||||
import { BuildNoteOptions, OptionLabel, ToImagePoint, ToScreenPoint } from '~/services/MapPins';
|
||||
import { ActorDragId, CellCentre, IsActorDrag, MoveByCells, TokenSize } from '~/services/MapTokens';
|
||||
import { CastLight, SnapToGridVertex, WallAt } from '~/services/MapLighting';
|
||||
import { DisplayToast } from '~/services/Toaster';
|
||||
import Server, { getBaseUrl } from '~/services/Server';
|
||||
import { emitter } from '~/services/Emitter';
|
||||
@@ -29,6 +30,15 @@ const zoom = ref(1);
|
||||
const pan = ref({ x: 0, y: 0 });
|
||||
const imageSize = ref({ width: 0, height: 0 });
|
||||
const showGrid = ref(true);
|
||||
// Lighting over the map: the dark the lights are carved out of. Off by default, so a map reads as the
|
||||
// picture it is until whoever is running the table asks for the dark.
|
||||
const showLighting = ref(false);
|
||||
// Drawing walls instead of panning the map: a wall is dragged from one corner of the grid to another.
|
||||
const wallMode = ref(false);
|
||||
// The wall being drawn — the corner it starts at and the one the pointer has reached. It is written
|
||||
// once, when the pointer lets go, so drawing a wall is not one request per mouse move.
|
||||
const drawingWall = ref(null);
|
||||
let wallPointerId = null;
|
||||
const dragging = ref(false);
|
||||
|
||||
const minZoom = 0.05;
|
||||
@@ -114,6 +124,8 @@ let lastPointer = { x: 0, y: 0 };
|
||||
|
||||
function onPointerDown(event) {
|
||||
if (event.button !== 0 || !viewport.value) return;
|
||||
// The wall tool takes the pointer for itself: holding the map then draws a wall instead of moving it.
|
||||
if (wallMode.value && startWallDrag(event)) return;
|
||||
dragging.value = true;
|
||||
pointerId = event.pointerId;
|
||||
lastPointer = { x: event.clientX, y: event.clientY };
|
||||
@@ -121,12 +133,14 @@ function onPointerDown(event) {
|
||||
}
|
||||
|
||||
function onPointerMove(event) {
|
||||
if (moveWallDrag(event)) return;
|
||||
if (!dragging.value || event.pointerId !== pointerId) return;
|
||||
pan.value = { x: pan.value.x + (event.clientX - lastPointer.x), y: pan.value.y + (event.clientY - lastPointer.y) };
|
||||
lastPointer = { x: event.clientX, y: event.clientY };
|
||||
}
|
||||
|
||||
function onPointerUp(event) {
|
||||
async function onPointerUp(event) {
|
||||
if (await endWallDrag(event)) return;
|
||||
if (event.pointerId !== pointerId) return;
|
||||
dragging.value = false;
|
||||
pointerId = null;
|
||||
@@ -195,20 +209,37 @@ function onMapContextMenu(event) {
|
||||
const spot = ToImagePoint({ x: event.clientX - bounds.left, y: event.clientY - bounds.top }, viewState());
|
||||
if (!spot) return;
|
||||
|
||||
if (!noteOptions.value.length) {
|
||||
ShowContextMenu([{ name: t('campaigns.map.pins.none'), action: () => HideContextMenu() }]);
|
||||
return;
|
||||
const items = [];
|
||||
if (!noteOptions.value.length) items.push({ name: t('campaigns.map.pins.none'), action: () => HideContextMenu() });
|
||||
else {
|
||||
items.push({
|
||||
name: t('campaigns.map.pins.add'),
|
||||
icon: '/icons/iconoir/regular/map-pin-plus.svg',
|
||||
context: noteOptions.value.map((option) => ({
|
||||
name: option.label,
|
||||
icon: '/icons/iconoir/regular/notes.svg',
|
||||
action: () => { HideContextMenu(); savePin(option.value, spot); }
|
||||
}))
|
||||
});
|
||||
}
|
||||
|
||||
ShowContextMenu([{
|
||||
name: t('campaigns.map.pins.add'),
|
||||
icon: '/icons/iconoir/regular/map-pin-plus.svg',
|
||||
context: noteOptions.value.map((option) => ({
|
||||
name: option.label,
|
||||
icon: '/icons/iconoir/regular/notes.svg',
|
||||
action: () => { HideContextMenu(); savePin(option.value, spot); }
|
||||
}))
|
||||
}]);
|
||||
items.push({ divider: true });
|
||||
items.push({
|
||||
name: t('campaigns.map.lights.add'),
|
||||
icon: '/icons/iconoir/regular/fire-flame.svg',
|
||||
action: () => { HideContextMenu(); placeLight(spot); }
|
||||
});
|
||||
// A wall is a line, not a marker to hold: right clicking along it is how it is taken off again.
|
||||
const wall = WallAt(spot, walls.value, WALL_PICK_PX / Math.max(0.05, zoom.value));
|
||||
if (wall) {
|
||||
items.push({
|
||||
name: t('campaigns.map.walls.remove'),
|
||||
icon: '/icons/iconoir/regular/xmark-circle.svg',
|
||||
action: () => { HideContextMenu(); removeWall(wall); }
|
||||
});
|
||||
}
|
||||
|
||||
ShowContextMenu(items);
|
||||
}
|
||||
|
||||
function onPinContextMenu(pin) {
|
||||
@@ -503,6 +534,328 @@ function handleActorEntry({ entityType, entry }) {
|
||||
actors.value = [entry, ...actors.value.filter((current) => String(current._id) !== String(entry._id))];
|
||||
}
|
||||
|
||||
// --- Lights, and the walls that stop them ---
|
||||
// A light shines from one spot of the image and is as free to place as a pin. The walls of the map are
|
||||
// what cuts its reach into a shadow: CastLight works out the shape a light paints and the canvas below
|
||||
// paints that shape out of the dark laid over the map.
|
||||
|
||||
// A new light covers this much of the map it is placed on, and half of that is bright light.
|
||||
const LIGHT_CELLS = 3;
|
||||
// How near a line a right click has to come to mean that wall, in screen pixels (it is divided by the
|
||||
// zoom to become image pixels, so picking a wall is as easy zoomed out as zoomed in).
|
||||
const WALL_PICK_PX = 10;
|
||||
|
||||
const lightingCanvas = ref(null);
|
||||
const lights = computed(() => map.value?.lights ?? []);
|
||||
const walls = computed(() => map.value?.walls ?? []);
|
||||
// The light a pointer is holding, and the spot it holds it at: like a token, the move stays local until
|
||||
// the pointer lets go, so dragging a light across the map is one save and not one per mouse move.
|
||||
const movingLight = ref(null);
|
||||
let lightPointerId = null;
|
||||
|
||||
// A colour from the theme the canvas paints with. The canvas cannot be styled with `var(--color-…)`
|
||||
// like a stylesheet, so it asks the document for the same variable the stylesheets use.
|
||||
function themeColor(name, fallback) {
|
||||
if (typeof window === 'undefined' || typeof getComputedStyle !== 'function') return fallback;
|
||||
return getComputedStyle(document.documentElement).getPropertyValue(name).trim() || fallback;
|
||||
}
|
||||
|
||||
// A hex colour with an alpha end ('#ffc46b' + '4d'), because a canvas gradient needs its stops spelled
|
||||
// out. Anything that is not a plain hex colour is painted as it is.
|
||||
function withAlpha(color, alpha) {
|
||||
const value = String(color ?? '').trim();
|
||||
if (/^#[0-9a-f]{6}$/i.test(value)) return `${value}${alpha}`;
|
||||
if (/^#[0-9a-f]{3}$/i.test(value)) return `#${value.slice(1)}${value.slice(1)}${alpha}`;
|
||||
return value;
|
||||
}
|
||||
|
||||
// The light a marker is drawn for: the spot it is being held at while a pointer drags it, and its own
|
||||
// spot otherwise.
|
||||
function heldLight(light) {
|
||||
if (movingLight.value && String(movingLight.value.light?._id) === String(light?._id)) return movingLight.value;
|
||||
return { x: Number(light?.x) || 0, y: Number(light?.y) || 0 };
|
||||
}
|
||||
|
||||
function lightStyle(light) {
|
||||
const point = ToScreenPoint(heldLight(light), viewState());
|
||||
return { left: `${point.x}px`, top: `${point.y}px` };
|
||||
}
|
||||
|
||||
// The reach a light is given when it is placed: enough of the map to matter at the grid it stands on.
|
||||
function defaultLightReach() {
|
||||
const cell = Math.max(1, Number(map.value?.gridSize) || 50);
|
||||
const radius = Math.round(cell * LIGHT_CELLS);
|
||||
return { radius, bright: Math.round(radius / 2) };
|
||||
}
|
||||
|
||||
async function placeLight(spot) {
|
||||
const reach = defaultLightReach();
|
||||
await updateMap('/map/place-light', {
|
||||
id: map.value?._id, x: spot.x, y: spot.y, ...reach
|
||||
}, t('campaigns.map.lights.error'));
|
||||
}
|
||||
|
||||
async function removeLight(light) {
|
||||
await updateMap('/map/remove-light', { id: map.value?._id, light: light?._id }, t('campaigns.map.lights.error'));
|
||||
}
|
||||
|
||||
function onLightPointerDown(event, light) {
|
||||
// Holding a light moves the light, never the map.
|
||||
event.stopPropagation();
|
||||
if (event.button !== 0) return;
|
||||
|
||||
lightPointerId = event.pointerId;
|
||||
event.currentTarget.setPointerCapture?.(event.pointerId);
|
||||
movingLight.value = { light: { ...light }, x: Number(light.x) || 0, y: Number(light.y) || 0 };
|
||||
}
|
||||
|
||||
function onLightPointerMove(event) {
|
||||
if (!movingLight.value || event.pointerId !== lightPointerId) return;
|
||||
|
||||
const spot = imagePointOf(event);
|
||||
// Dragged off the image, the light keeps its spot: a light is never lost over the edge.
|
||||
if (!spot) return;
|
||||
movingLight.value = { ...movingLight.value, x: spot.x, y: spot.y };
|
||||
}
|
||||
|
||||
async function onLightPointerUp(event) {
|
||||
if (!movingLight.value || event.pointerId !== lightPointerId) return;
|
||||
|
||||
const { light, x, y } = movingLight.value;
|
||||
lightPointerId = null;
|
||||
movingLight.value = null;
|
||||
event.currentTarget?.releasePointerCapture?.(event.pointerId);
|
||||
|
||||
if (x === Number(light.x) && y === Number(light.y)) return;
|
||||
await updateMap('/map/update-light', { id: map.value?._id, light: light._id, x, y }, t('campaigns.map.lights.error'));
|
||||
}
|
||||
|
||||
function onLightContextMenu(light) {
|
||||
ShowContextMenu([{
|
||||
name: t('campaigns.map.lights.remove'),
|
||||
icon: '/icons/iconoir/regular/xmark-circle.svg',
|
||||
action: () => { HideContextMenu(); removeLight(light); }
|
||||
}]);
|
||||
}
|
||||
|
||||
// Delete takes a focused light off the map, like it does a focused token.
|
||||
async function onLightKeydown(event, light) {
|
||||
if (event.key === 'Delete' || event.key === 'Backspace') {
|
||||
event.preventDefault();
|
||||
await removeLight(light);
|
||||
}
|
||||
}
|
||||
|
||||
// --- Drawing walls ---
|
||||
// With the wall tool on, the pointer draws instead of panning: it is held down at one corner of the
|
||||
// grid and let go at another, and the wall between those two corners is what gets saved.
|
||||
|
||||
// Holds down the first corner of a wall, or says the wall tool has nothing to hold (off the image).
|
||||
function startWallDrag(event) {
|
||||
const spot = imagePointOf(event);
|
||||
if (!spot) return false;
|
||||
const corner = SnapToGridVertex(spot, grid.value);
|
||||
if (!corner) return false;
|
||||
|
||||
wallPointerId = event.pointerId;
|
||||
viewport.value?.setPointerCapture?.(event.pointerId);
|
||||
drawingWall.value = { x1: corner.x, y1: corner.y, x2: corner.x, y2: corner.y };
|
||||
return true;
|
||||
}
|
||||
|
||||
function moveWallDrag(event) {
|
||||
if (!drawingWall.value || event.pointerId !== wallPointerId) return false;
|
||||
|
||||
const spot = imagePointOf(event);
|
||||
// Off the image the wall keeps the end it had: a wall cannot hang outside of the map.
|
||||
if (!spot) return true;
|
||||
const corner = SnapToGridVertex(spot, grid.value);
|
||||
if (!corner) return true;
|
||||
if (corner.x === drawingWall.value.x2 && corner.y === drawingWall.value.y2) return true;
|
||||
drawingWall.value = { ...drawingWall.value, x2: corner.x, y2: corner.y };
|
||||
return true;
|
||||
}
|
||||
|
||||
async function endWallDrag(event) {
|
||||
if (!drawingWall.value || event.pointerId !== wallPointerId) return false;
|
||||
|
||||
const wall = drawingWall.value;
|
||||
wallPointerId = null;
|
||||
drawingWall.value = null;
|
||||
viewport.value?.releasePointerCapture?.(event.pointerId);
|
||||
|
||||
// Dragged out and back to the same corner is not a wall: it stops nothing and cannot be picked
|
||||
// up again, so it is dropped where it was drawn.
|
||||
if (wall.x1 === wall.x2 && wall.y1 === wall.y2) return true;
|
||||
await saveWall(wall);
|
||||
return true;
|
||||
}
|
||||
|
||||
async function saveWall(wall) {
|
||||
await updateMap('/map/wall', { id: map.value?._id, ...wall }, t('campaigns.map.walls.error'));
|
||||
}
|
||||
|
||||
async function removeWall(wall) {
|
||||
await updateMap('/map/remove-wall', { id: map.value?._id, wall: wall?._id }, t('campaigns.map.walls.error'));
|
||||
}
|
||||
|
||||
// --- Painting the lights ---
|
||||
// One canvas over the map, drawn in screen pixels like the pins and the tokens, and repainted whenever
|
||||
// the view or the map changes. With the lighting on it lays the dark over the image and erases the shape
|
||||
// of every light out of it, so what is left dark is exactly what its walls hide. With the lighting off
|
||||
// the same shapes are drawn as thin outlines, which is what makes reaching for a light's size possible
|
||||
// while it is still being placed.
|
||||
|
||||
function imageScreenRect() {
|
||||
const origin = ToScreenPoint({ x: 0, y: 0 }, viewState());
|
||||
return {
|
||||
x: origin.x,
|
||||
y: origin.y,
|
||||
width: imageSize.value.width * zoom.value,
|
||||
height: imageSize.value.height * zoom.value
|
||||
};
|
||||
}
|
||||
|
||||
function tracePolygon(context, points, view) {
|
||||
context.beginPath();
|
||||
points.forEach((point, index) => {
|
||||
const screen = ToScreenPoint(point, view);
|
||||
if (index) context.lineTo(screen.x, screen.y);
|
||||
else context.moveTo(screen.x, screen.y);
|
||||
});
|
||||
context.closePath();
|
||||
}
|
||||
|
||||
function paintDarkness(context, image) {
|
||||
const view = viewState();
|
||||
context.save();
|
||||
context.fillStyle = themeColor('--color-map-darkness', '#000000d9');
|
||||
context.fillRect(image.x, image.y, image.width, image.height);
|
||||
|
||||
// The lights erase the dark they stand in: only how much a gradient is transparent matters here, so
|
||||
// a light fades from fully lit at its middle to nothing at the end of its reach.
|
||||
context.globalCompositeOperation = 'destination-out';
|
||||
for (const light of lights.value) {
|
||||
const shape = CastLight(light, walls.value);
|
||||
if (!shape.length) continue;
|
||||
const centre = ToScreenPoint(heldLight(light), view);
|
||||
const reach = Math.max(1, (Number(light.radius) || 0) * zoom.value);
|
||||
const core = Math.max(0, Math.min(1, (Number(light.bright) || 0) / (Number(light.radius) || 1)));
|
||||
|
||||
context.save();
|
||||
tracePolygon(context, shape, view);
|
||||
context.clip();
|
||||
const gradient = context.createRadialGradient(centre.x, centre.y, 0, centre.x, centre.y, reach);
|
||||
gradient.addColorStop(0, '#000000ff');
|
||||
gradient.addColorStop(core, '#000000f5');
|
||||
gradient.addColorStop(1, '#00000000');
|
||||
context.fillStyle = gradient;
|
||||
context.fillRect(image.x, image.y, image.width, image.height);
|
||||
context.restore();
|
||||
}
|
||||
|
||||
// The tint of a coloured light, laid back over the light it colours: a lantern reads warm and a
|
||||
// spell cold, and a light with no colour of its own leaves the map as it is.
|
||||
context.globalCompositeOperation = 'source-over';
|
||||
for (const light of lights.value) {
|
||||
if (!light.color) continue;
|
||||
const shape = CastLight(light, walls.value);
|
||||
if (!shape.length) continue;
|
||||
const centre = ToScreenPoint(heldLight(light), view);
|
||||
const reach = Math.max(1, (Number(light.radius) || 0) * zoom.value);
|
||||
|
||||
context.save();
|
||||
tracePolygon(context, shape, view);
|
||||
context.clip();
|
||||
const gradient = context.createRadialGradient(centre.x, centre.y, 0, centre.x, centre.y, reach);
|
||||
gradient.addColorStop(0, withAlpha(light.color, '33'));
|
||||
gradient.addColorStop(1, withAlpha(light.color, '00'));
|
||||
context.fillStyle = gradient;
|
||||
context.fillRect(image.x, image.y, image.width, image.height);
|
||||
context.restore();
|
||||
}
|
||||
context.restore();
|
||||
}
|
||||
|
||||
function paintLightOutlines(context) {
|
||||
const view = viewState();
|
||||
context.save();
|
||||
context.lineWidth = 1;
|
||||
for (const light of lights.value) {
|
||||
const shape = CastLight(light, walls.value);
|
||||
if (!shape.length) continue;
|
||||
tracePolygon(context, shape, view);
|
||||
context.strokeStyle = withAlpha(light.color || '#ffffff', '59');
|
||||
context.stroke();
|
||||
}
|
||||
context.restore();
|
||||
}
|
||||
|
||||
function paintWalls(context) {
|
||||
if (!walls.value.length && !drawingWall.value) return;
|
||||
const view = viewState();
|
||||
context.save();
|
||||
context.lineCap = 'round';
|
||||
context.strokeStyle = themeColor('--color-map-wall', '#e06c75');
|
||||
// The wall tool asks for a firmer line: it is the tool that has to see what it has drawn already.
|
||||
context.lineWidth = wallMode.value ? 3 : 2;
|
||||
for (const wall of walls.value) {
|
||||
const from = ToScreenPoint({ x: Number(wall.x1) || 0, y: Number(wall.y1) || 0 }, view);
|
||||
const to = ToScreenPoint({ x: Number(wall.x2) || 0, y: Number(wall.y2) || 0 }, view);
|
||||
context.beginPath();
|
||||
context.moveTo(from.x, from.y);
|
||||
context.lineTo(to.x, to.y);
|
||||
context.stroke();
|
||||
}
|
||||
// The wall being drawn, along the grid corners the pointer has reached so far.
|
||||
if (drawingWall.value) {
|
||||
context.setLineDash([6, 4]);
|
||||
const from = ToScreenPoint({ x: drawingWall.value.x1, y: drawingWall.value.y1 }, view);
|
||||
const to = ToScreenPoint({ x: drawingWall.value.x2, y: drawingWall.value.y2 }, view);
|
||||
context.beginPath();
|
||||
context.moveTo(from.x, from.y);
|
||||
context.lineTo(to.x, to.y);
|
||||
context.stroke();
|
||||
}
|
||||
context.restore();
|
||||
}
|
||||
|
||||
function drawLighting() {
|
||||
const canvas = lightingCanvas.value;
|
||||
const bounds = viewport.value?.getBoundingClientRect();
|
||||
if (!canvas || !bounds) return;
|
||||
|
||||
const width = Math.max(1, Math.round(bounds.width));
|
||||
const height = Math.max(1, Math.round(bounds.height));
|
||||
if (canvas.width !== width) canvas.width = width;
|
||||
if (canvas.height !== height) canvas.height = height;
|
||||
|
||||
const context = canvas.getContext?.('2d');
|
||||
if (!context) return;
|
||||
context.clearRect(0, 0, width, height);
|
||||
if (!imageUrl.value) return;
|
||||
|
||||
if (showLighting.value) paintDarkness(context, imageScreenRect());
|
||||
else paintLightOutlines(context);
|
||||
paintWalls(context);
|
||||
}
|
||||
|
||||
// Every move of the view, and every light or wall that changes, is painted again.
|
||||
watch(
|
||||
[zoom, pan, imageSize, showLighting, wallMode, drawingWall, lights, walls, imageUrl],
|
||||
() => nextTick(drawLighting),
|
||||
{ deep: true }
|
||||
);
|
||||
|
||||
onMounted(() => {
|
||||
window.addEventListener('resize', drawLighting);
|
||||
nextTick(drawLighting);
|
||||
});
|
||||
|
||||
onBeforeUnmount(() => {
|
||||
window.removeEventListener('resize', drawLighting);
|
||||
});
|
||||
|
||||
// A different map was anchored while this pane was already mounted.
|
||||
watch(() => props.map, (incoming, previous) => {
|
||||
if (incoming === previous) return;
|
||||
@@ -510,6 +863,9 @@ watch(() => props.map, (incoming, previous) => {
|
||||
imageSize.value = { width: 0, height: 0 };
|
||||
movingToken.value = null;
|
||||
draggingActor.value = false;
|
||||
movingLight.value = null;
|
||||
drawingWall.value = null;
|
||||
wallPointerId = null;
|
||||
});
|
||||
|
||||
watch(campaignId, () => {
|
||||
@@ -550,6 +906,14 @@ onBeforeUnmount(() => {
|
||||
:aria-label="$t('campaigns.map.toggle-grid')" :aria-pressed="showGrid.toString()" @click="showGrid = !showGrid">
|
||||
<img class="tool-icon" src="/icons/iconoir/regular/view-grid.svg" alt="" aria-hidden="true">
|
||||
</button>
|
||||
<button class="viewer-tool" :class="{ selected: showLighting }" type="button" :title="$t('campaigns.map.toggle-lighting')"
|
||||
:aria-label="$t('campaigns.map.toggle-lighting')" :aria-pressed="showLighting.toString()" @click="showLighting = !showLighting">
|
||||
<img class="tool-icon" src="/icons/iconoir/regular/light-bulb-on.svg" alt="" aria-hidden="true">
|
||||
</button>
|
||||
<button class="viewer-tool" :class="{ selected: wallMode }" type="button" :title="$t('campaigns.map.toggle-walls')"
|
||||
:aria-label="$t('campaigns.map.toggle-walls')" :aria-pressed="wallMode.toString()" @click="wallMode = !wallMode">
|
||||
<img class="tool-icon" src="/icons/iconoir/regular/linear.svg" alt="" aria-hidden="true">
|
||||
</button>
|
||||
<button class="viewer-tool" type="button" :title="$t('campaigns.map.zoom-out')" :aria-label="$t('campaigns.map.zoom-out')" @click="zoomFromToolbar(false)">
|
||||
<img class="tool-icon" src="/icons/iconoir/regular/minus.svg" alt="" aria-hidden="true">
|
||||
</button>
|
||||
@@ -573,7 +937,7 @@ onBeforeUnmount(() => {
|
||||
<div
|
||||
ref="viewport"
|
||||
class="map-viewport"
|
||||
:class="{ dragging }"
|
||||
:class="{ dragging, 'wall-mode': wallMode }"
|
||||
@wheel.prevent="onWheel"
|
||||
@pointerdown="onPointerDown"
|
||||
@pointermove="onPointerMove"
|
||||
@@ -587,6 +951,28 @@ onBeforeUnmount(() => {
|
||||
<template v-if="imageUrl">
|
||||
<img class="map-image" :src="imageUrl" :style="stageStyle" :alt="map?.name" draggable="false" @load="onImageLoaded">
|
||||
<div class="map-grid" :style="gridStyle" aria-hidden="true"></div>
|
||||
<canvas ref="lightingCanvas" class="map-lighting" aria-hidden="true"></canvas>
|
||||
<div class="map-lights">
|
||||
<button
|
||||
v-for="light in lights"
|
||||
:key="light._id"
|
||||
class="map-light"
|
||||
:class="{ moving: movingLight && String(movingLight.light?._id) === String(light._id) }"
|
||||
type="button"
|
||||
:style="lightStyle(light)"
|
||||
:title="$t('campaigns.map.lights.light')"
|
||||
:aria-label="$t('campaigns.map.lights.light')"
|
||||
draggable="false"
|
||||
@pointerdown="onLightPointerDown($event, light)"
|
||||
@pointermove="onLightPointerMove"
|
||||
@pointerup="onLightPointerUp"
|
||||
@pointercancel="onLightPointerUp"
|
||||
@contextmenu.stop.prevent="onLightContextMenu(light)"
|
||||
@keydown="onLightKeydown($event, light)"
|
||||
>
|
||||
<img class="light-icon" src="/icons/iconoir/regular/fire-flame.svg" alt="" aria-hidden="true">
|
||||
</button>
|
||||
</div>
|
||||
<div class="map-pins">
|
||||
<button
|
||||
v-for="pin in pins"
|
||||
@@ -629,6 +1015,7 @@ onBeforeUnmount(() => {
|
||||
</button>
|
||||
</div>
|
||||
<div v-if="draggingActor" class="map-drop-hint">{{ $t('campaigns.map.tokens.drop-hint') }}</div>
|
||||
<div v-if="wallMode" class="map-drop-hint">{{ $t('campaigns.map.walls.hint') }}</div>
|
||||
</template>
|
||||
<div v-else class="map-empty">
|
||||
{{ $t('campaigns.map.no-image') }}
|
||||
@@ -654,6 +1041,23 @@ onBeforeUnmount(() => {
|
||||
.map-viewport.dragging { cursor: grabbing; }
|
||||
.map-image { position: absolute; top: 0; left: 0; max-width: none; transform-origin: top left; user-select: none; }
|
||||
.map-grid { position: absolute; top: 0; left: 0; opacity: .55; pointer-events: none; }
|
||||
.map-viewport.wall-mode { cursor: crosshair; }
|
||||
/* The lights are painted on a canvas over the image and in screen space, like the pins: the dark over
|
||||
the map and the shape each light cuts in it are redrawn whenever the view moves (see drawLighting).
|
||||
The canvas never catches the mouse; the light markers below do that. */
|
||||
.map-lighting { position: absolute; top: 0; left: 0; pointer-events: none; }
|
||||
.map-lights { position: absolute; inset: 0; pointer-events: none; }
|
||||
.map-light {
|
||||
position: absolute; transform: translate(-50%, -50%); pointer-events: auto;
|
||||
display: flex; align-items: center; justify-content: center; width: 26px; height: 26px;
|
||||
margin: 0; padding: 0; border: 1px solid var(--color-link); border-radius: 50%;
|
||||
background: var(--color-background-soft); color: var(--color-text);
|
||||
cursor: grab; user-select: none; box-shadow: 0px 0px 6px -1px rgba(0,0,0,0.55);
|
||||
}
|
||||
.map-light:hover { background: var(--color-button-hover); }
|
||||
.map-light:focus-visible { outline: 1px solid var(--color-link); outline-offset: 2px; }
|
||||
.map-light.moving { cursor: grabbing; }
|
||||
.light-icon { width: 14px; height: 14px; filter: invert(var(--color-icon-invert)); }
|
||||
/* Pins live in image pixels but are drawn in screen space (see ToScreenPoint), so the overlay stays
|
||||
unscaled and their markers are readable at every zoom. Only the markers catch the mouse. */
|
||||
.map-pins { position: absolute; inset: 0; pointer-events: none; }
|
||||
|
||||
200
frontend/app/services/MapLighting.js
Normal file
200
frontend/app/services/MapLighting.js
Normal file
@@ -0,0 +1,200 @@
|
||||
// The rules behind the lights of a map (place a light, draw the walls that stop it, know which wall a
|
||||
// click landed on). Like the pins and the tokens, a light is stored in image pixels, so these helpers
|
||||
// only work out geometry: they hold no state and talk to no API.
|
||||
//
|
||||
// The shadow of a light is the standard visibility polygon: rays are aimed at every corner of every
|
||||
// wall (just past it, so a corner never leaves a slit open) and at the midpoints between them, and each
|
||||
// ray stops at the first wall it meets or at the reach of the light. Joining where those rays end gives
|
||||
// the shape the light paints, walls cutting it wherever they stand.
|
||||
|
||||
// Aiming a hair to either side of a wall corner, so the ray passes it instead of landing on it.
|
||||
const RAY_EPSILON = 0.0001;
|
||||
// How finely an open arc is drawn where no wall corner asks for a ray of its own (about 7.5°).
|
||||
const MAX_ARC_STEP = Math.PI / 24;
|
||||
// A wall touching the light itself does not hide it, and a ray that close has nothing to say.
|
||||
const MIN_HIT = 1e-6;
|
||||
|
||||
// The walls of a map as plain segments: only the ones with two real ends count, and a light is not
|
||||
// asked to block anything it is standing on.
|
||||
function ToWallSegments(walls) {
|
||||
return (walls ?? [])
|
||||
.map((wall) => ({
|
||||
x1: Number(wall?.x1),
|
||||
y1: Number(wall?.y1),
|
||||
x2: Number(wall?.x2),
|
||||
y2: Number(wall?.y2)
|
||||
}))
|
||||
.filter((wall) => [wall.x1, wall.y1, wall.x2, wall.y2].every(Number.isFinite)
|
||||
&& (wall.x1 !== wall.x2 || wall.y1 !== wall.y2));
|
||||
}
|
||||
|
||||
// The corner of the grid a point of the image is closest to, in image pixels: this is where a wall end
|
||||
// is kept, so a wall runs along the lines of the grid it was drawn on. The backend snaps the same way,
|
||||
// so a wall does not move when the line that drew it is saved.
|
||||
function SnapToGridVertex(point, grid) {
|
||||
const size = Math.max(1, Number(grid?.gridSize) || 50);
|
||||
const offsetX = Number(grid?.offsetX) || 0;
|
||||
const offsetY = Number(grid?.offsetY) || 0;
|
||||
|
||||
const x = Number(point?.x);
|
||||
const y = Number(point?.y);
|
||||
if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
|
||||
|
||||
// Spots off the top left corner count from the corner itself, and only whole pixels count: both
|
||||
// the way the route reads a coordinate, like the cells a token stands in.
|
||||
const column = Math.round((Math.max(0, Math.round(x)) - offsetX) / size);
|
||||
const row = Math.round((Math.max(0, Math.round(y)) - offsetY) / size);
|
||||
return {
|
||||
x: Math.max(0, Math.round(offsetX + column * size)),
|
||||
y: Math.max(0, Math.round(offsetY + row * size))
|
||||
};
|
||||
}
|
||||
|
||||
// Wrapping an angle into [-PI, PI), so the rays of a light are counted once round and not twice.
|
||||
function NormalizeAngle(angle) {
|
||||
const full = Math.PI * 2;
|
||||
let wrapped = angle % full;
|
||||
if (wrapped >= Math.PI) wrapped -= full;
|
||||
if (wrapped < -Math.PI) wrapped += full;
|
||||
return wrapped;
|
||||
}
|
||||
|
||||
// The directions to aim a ray: every wall corner from the light, a hair either side, and enough
|
||||
// midpoints between them that the lit arc stays round instead of turning into a star.
|
||||
function RayAngles(centre, segments) {
|
||||
const angles = [];
|
||||
for (const segment of segments) {
|
||||
for (const corner of [{ x: segment.x1, y: segment.y1 }, { x: segment.x2, y: segment.y2 }]) {
|
||||
const angle = Math.atan2(corner.y - centre.y, corner.x - centre.x);
|
||||
if (!Number.isFinite(angle)) continue;
|
||||
angles.push(NormalizeAngle(angle - RAY_EPSILON), NormalizeAngle(angle), NormalizeAngle(angle + RAY_EPSILON));
|
||||
}
|
||||
}
|
||||
if (!angles.length) return EvenAngles();
|
||||
|
||||
// Two corners in a line from the light ask for the same ray: keep it once.
|
||||
angles.sort((a, b) => a - b);
|
||||
const ordered = [];
|
||||
for (const angle of angles) {
|
||||
if (ordered.length && angle - ordered[ordered.length - 1] < RAY_EPSILON) continue;
|
||||
ordered.push(angle);
|
||||
}
|
||||
// The first and the last angle can be the same ray seen across the wrap round.
|
||||
if (ordered.length > 1 && (ordered[0] + Math.PI * 2) - ordered[ordered.length - 1] < RAY_EPSILON) ordered.pop();
|
||||
|
||||
const rays = [];
|
||||
for (let index = 0; index < ordered.length; index += 1) {
|
||||
const current = ordered[index];
|
||||
// The last angle wraps round to the first: a light shines the whole way round.
|
||||
const next = index + 1 < ordered.length ? ordered[index + 1] : ordered[0] + Math.PI * 2;
|
||||
rays.push(current);
|
||||
const steps = Math.max(1, Math.ceil((next - current) / MAX_ARC_STEP));
|
||||
for (let step = 1; step < steps; step += 1) rays.push(NormalizeAngle(current + ((next - current) * step) / steps));
|
||||
}
|
||||
return rays;
|
||||
}
|
||||
|
||||
// A light with no walls in sight still has an edge, so it is drawn as a circle of as many rays as an
|
||||
// open arc is cut into.
|
||||
function EvenAngles() {
|
||||
const angles = [];
|
||||
const steps = Math.ceil((Math.PI * 2) / MAX_ARC_STEP);
|
||||
for (let step = 0; step < steps; step += 1) angles.push(NormalizeAngle((Math.PI * 2) * (step / steps)));
|
||||
return angles;
|
||||
}
|
||||
|
||||
// How far along the ray from `centre` (aimed at unit direction `dx`/`dy`) a segment stands, or null
|
||||
// when the ray misses it. Parallel rays miss, and so does a segment behind the light.
|
||||
function RaySegmentDistance(centre, dx, dy, segment) {
|
||||
const bx = segment.x2 - segment.x1;
|
||||
const by = segment.y2 - segment.y1;
|
||||
const cross = dx * by - dy * bx;
|
||||
if (Math.abs(cross) < 1e-12) return null;
|
||||
|
||||
const ax = segment.x1 - centre.x;
|
||||
const ay = segment.y1 - centre.y;
|
||||
const along = (ax * by - ay * bx) / cross;
|
||||
const across = (ax * dy - ay * dx) / cross;
|
||||
if (along <= MIN_HIT || across < 0 || across > 1) return null;
|
||||
return along;
|
||||
}
|
||||
|
||||
// The first wall a ray runs into, or Infinity when it reaches into the open.
|
||||
function RayDistance(centre, angle, segments) {
|
||||
const dx = Math.cos(angle);
|
||||
const dy = Math.sin(angle);
|
||||
let nearest = Infinity;
|
||||
for (const segment of segments) {
|
||||
const hit = RaySegmentDistance(centre, dx, dy, segment);
|
||||
if (hit !== null && hit < nearest) nearest = hit;
|
||||
}
|
||||
return nearest;
|
||||
}
|
||||
|
||||
// The shape a light paints, in image pixels: the points of its visibility polygon, aimed round from
|
||||
// the light itself. Nothing is lit where a wall stands between it and the light, and a light that
|
||||
// cannot be placed lights nothing at all.
|
||||
function CastLight(light, walls) {
|
||||
const centre = { x: Number(light?.x), y: Number(light?.y) };
|
||||
const radius = Number(light?.radius);
|
||||
if (!Number.isFinite(centre.x) || !Number.isFinite(centre.y) || !Number.isFinite(radius) || radius <= 0) return [];
|
||||
|
||||
const segments = ToWallSegments(walls);
|
||||
const points = [];
|
||||
for (const angle of RayAngles(centre, segments)) {
|
||||
const reached = Math.min(radius, RayDistance(centre, angle, segments));
|
||||
// A wall crossing the light itself leaves that ray with no lit pixel of its own to end on.
|
||||
if (reached <= MIN_HIT) continue;
|
||||
points.push({
|
||||
x: centre.x + Math.cos(angle) * reached,
|
||||
y: centre.y + Math.sin(angle) * reached
|
||||
});
|
||||
}
|
||||
return points;
|
||||
}
|
||||
|
||||
// How far a point of the image stands from a wall, in image pixels.
|
||||
function DistanceToWall(point, wall) {
|
||||
const x = Number(point?.x);
|
||||
const y = Number(point?.y);
|
||||
const x1 = Number(wall?.x1);
|
||||
const y1 = Number(wall?.y1);
|
||||
const x2 = Number(wall?.x2);
|
||||
const y2 = Number(wall?.y2);
|
||||
if (![x, y, x1, y1, x2, y2].every(Number.isFinite)) return Infinity;
|
||||
|
||||
const bx = x2 - x1;
|
||||
const by = y2 - y1;
|
||||
const length = bx * bx + by * by;
|
||||
if (!length) return Math.hypot(x - x1, y - y1);
|
||||
|
||||
// The closest point of the segment is the perpendicular foot, held inside its own ends.
|
||||
const along = Math.max(0, Math.min(1, ((x - x1) * bx + (y - y1) * by) / length));
|
||||
return Math.hypot(x - (x1 + bx * along), y - (y1 + by * along));
|
||||
}
|
||||
|
||||
// The wall a point is standing on — the one nearest to it within `tolerance` image pixels, or null
|
||||
// when there is no wall there. This is what lets a right click pick the wall it meant.
|
||||
function WallAt(point, walls, tolerance) {
|
||||
const limit = Number(tolerance);
|
||||
if (!Number.isFinite(limit)) return null;
|
||||
|
||||
let nearest = null;
|
||||
let nearestDistance = Math.max(0, limit);
|
||||
for (const wall of walls ?? []) {
|
||||
const distance = DistanceToWall(point, wall);
|
||||
if (distance > nearestDistance) continue;
|
||||
nearest = wall;
|
||||
nearestDistance = distance;
|
||||
}
|
||||
return nearest;
|
||||
}
|
||||
|
||||
export {
|
||||
CastLight,
|
||||
DistanceToWall,
|
||||
NormalizeAngle,
|
||||
SnapToGridVertex,
|
||||
ToWallSegments,
|
||||
WallAt
|
||||
};
|
||||
Reference in New Issue
Block a user