@orbat-mapper/tactical-draw-adapter-maplibre 0.6.0 → 0.7.1

package/dist/index.d.mts

@@ -39,7 +39,11 @@ declare class PinResources {
   private invalidateDepth;
   private restore;
   constructor(map: Map$1);
-  setRoster(pins: readonly PinRender[]): void;
+  /**
+   * `pixelRatio` is the device pixels per CSS pixel the atlas is rasterized
+   * at; it is part of the roster key, so a change rebuilds the atlas.
+   */
+  setRoster(pins: readonly PinRender[], pixelRatio?: number): void;
   load(gl: WebGL2RenderingContext): Promise<PinResourceSnapshot | undefined>;
   dispose(): void;
 }
@@ -162,6 +166,8 @@ interface MapLibreLayerHandle {
    * skip calling it at all rather than pay for that every drag frame.
    */
   lastPinBatch?: readonly PinRender[];
+  /** The pixel ratio passed alongside `lastPinBatch`. */
+  lastPinPixelRatio?: number;
 }
 type PaintChannel = "fill" | "fill-pattern" | "line" | "circle" | "icon" | "text";
 interface MapLibreGroupBundle {
@@ -228,6 +234,13 @@ interface MapLibreAdapterOptions {
    * one draping pass per graphic. @default true
    */
   terrainBanding?: boolean;
+  /**
+   * Device pixels per CSS pixel at which pin symbols are rasterized into their
+   * texture atlas. Defaults to the map's pixel ratio capped at 2, which bounds
+   * texture memory on dense screens. Set it (e.g. to the map's `pixelRatio`)
+   * for offscreen renders above 2× so pins stay as sharp as the output.
+   */
+  pinPixelRatio?: number;
 }
 declare class MapLibreAdapter extends BaseMapAdapter<MapLibreLayerHandle, MapLibreEventToken, MapLibreViewToken> {
   private map;
@@ -236,6 +249,7 @@ declare class MapLibreAdapter extends BaseMapAdapter<MapLibreLayerHandle, MapLib
   readonly scalesGroundPointSymbolsNatively = true;
   private terrainActive;
   private terrainBanding;
+  private readonly pinPixelRatio?;
   private readonly handleTerrainChange;
   constructor(map: maplibregl.Map, options?: MapLibreAdapterOptions);
   /** Switches `terrainBanding` at runtime, re-banding every group if the effective state changes. */

package/dist/index.mjs

@@ -81,11 +81,15 @@ var PinResources = class {
 		map.on("webglcontextrestored", this.restore);
 		map.on("move", this.invalidateDepth);
 	}
-	setRoster(pins) {
+	/**
+	* `pixelRatio` is the device pixels per CSS pixel the atlas is rasterized
+	* at; it is part of the roster key, so a change rebuilds the atlas.
+	*/
+	setRoster(pins, pixelRatio = 1) {
 		this.needsDepth = pins.some((pin) => pin.presentation.occlusion === "terrain");
 		const resources = /* @__PURE__ */ new Map();
 		for (const pin of pins) {
-			const scale = pin.presentation.sizePixels / pin.octagonSize * Math.min(devicePixelRatio, 2);
+			const scale = pin.presentation.sizePixels / pin.octagonSize * pixelRatio;
 			if (scale > (resources.get(pin.resource.id)?.scale ?? 0)) resources.set(pin.resource.id, {
 				pin,
 				scale
@@ -239,14 +243,15 @@ void main() {
   else if(kind < 1.5) {
     vec2 delta = tp-gp; float len = length(delta);
     vec2 dir = len > .0001 ? delta/len : vec2(0,1);
-    vec2 p = mix(gp,tp,c.y) + vec2(-dir.y,dir.x) * (c.x-.5)*a_shape.x;
+    // Widen by 1px so the fragment edge fade has room to run.
+    vec2 p = mix(gp,tp,c.y) + vec2(-dir.y,dir.x) * (c.x-.5)*(a_shape.x+1.);
     clip = vec4(p/u_view*2., mix(ground.z/ground.w,target.z/target.w,c.y), 1.);
     offset = vec2(0);
   } else { offset = (c - vec2(.5,0)) * a_shape.xy + a_shape.zw; }
   clip.xy += offset * 2. / u_view * clip.w;
   if (ground.w <= 0. || target.w <= 0.) clip = vec4(2,2,2,1);
   gl_Position=clip;
-  v_local=(c-.5)*a_shape.xy;
+  v_local=(c-.5)*(a_shape.xy + (kind > .5 && kind < 1.5 ? vec2(1,0) : vec2(0)));
   v_uv=mix(a_uv.xy,a_uv.zw,vec2(c.x,1.-c.y));
   v_bounds=a_uv; v_color=a_color; v_shape=a_shape; v_flags=a_flags; v_radius=a_target.w;
 }`;
@@ -288,6 +293,10 @@ void main() {
   if(kind < .5) {
     float edge=length(v_local)-v_shape.x*.5;
     paint.a *= 1.-smoothstep(-1.,0.,edge);
+  } else if(kind < 1.5) {
+    // World-mode stems lean with perspective; fade the long edges over one device pixel.
+    float aa=max(fwidth(v_local.x),1e-4);
+    paint.a *= clamp((v_shape.x*.5-abs(v_local.x))/aa+.5,0.,1.);
   } else if(kind > 4.5) {
     // One optional halo instance; reuse the canonical atlas, including text and HQ staff.
     vec2 size = v_shape.xy - vec2(2. * v_radius);
@@ -1948,6 +1957,7 @@ var MapLibreAdapter = class extends BaseMapAdapter {
 	scalesGroundPointSymbolsNatively = true;
 	terrainActive = false;
 	terrainBanding;
+	pinPixelRatio;
 	handleTerrainChange = () => {
 		const active = this.terrainBanding && !!this.map.getTerrain?.();
 		if (active === this.terrainActive) return;
@@ -1959,6 +1969,7 @@ var MapLibreAdapter = class extends BaseMapAdapter {
 		this.map = map;
 		this.viewChangeMode = options.viewChangeMode ?? "continuous";
 		this.terrainBanding = options.terrainBanding ?? true;
+		this.pinPixelRatio = options.pinPixelRatio;
 		this.handleTerrainChange();
 		this.map.on("terrain", this.handleTerrainChange);
 	}
@@ -2098,10 +2109,12 @@ var MapLibreAdapter = class extends BaseMapAdapter {
 		const allPins = groups.flatMap((group) => group.pinBatch ?? []);
 		if (allPins.length) {
 			handle.pinResources ??= new PinResources(this.map);
+			const pixelRatio = this.pinPixelRatio ?? Math.min(this.map.getPixelRatio(), 2);
 			const previousBatch = handle.lastPinBatch;
-			if (!(previousBatch !== void 0 && previousBatch.length === allPins.length && allPins.every((pin, index) => pin === previousBatch[index]))) {
-				handle.pinResources.setRoster(allPins);
+			if (!(previousBatch !== void 0 && handle.lastPinPixelRatio === pixelRatio && previousBatch.length === allPins.length && allPins.every((pin, index) => pin === previousBatch[index]))) {
+				handle.pinResources.setRoster(allPins, pixelRatio);
 				handle.lastPinBatch = allPins;
+				handle.lastPinPixelRatio = pixelRatio;
 			}
 		}
 		const desiredGroupIds = new Set(groups.map((group) => group.id));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbat-mapper/tactical-draw-adapter-maplibre",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "MapLibre GL JS engine adapter for @orbat-mapper/tactical-draw. Draw and edit tactical control measures (MIL-STD-2525 / APP-6) on a MapLibre map.",
   "license": "MIT",
   "author": "Orbat Mapper",
@@ -37,8 +37,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@orbat-mapper/control-measures": "^0.27.0",
-    "@orbat-mapper/tactical-draw": "^0.10.1"
+    "@orbat-mapper/control-measures": "^0.28.0",
+    "@orbat-mapper/tactical-draw": "^0.10.2"
   },
   "peerDependencies": {
     "maplibre-gl": ">=5.8.0 <7.0.0"