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:
@@ -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; }
|
||||
|
||||
Reference in New Issue
Block a user