Anthroposcaper — User Guide

1. Introduction

What it is

The topology (where the faces are, where the edges are, where the corners are) is derived from the drawing automatically, while the rules for turning 2D into 3D are defined declaratively — through tags and attributes, not nodes or code. Adjust a single tag or a single template, and everything that uses it is recomputed.

Anthroposcaper wins on scale and repetition — when you need to place miles of similar elements along the streets of a district. Typical users are architectural visualization artists (environments for rendering), architects and urban planners (conceptual district plans), landscape designers (paths, lawns, fences, and curbs as reusable templates), and gamedev (levels and environments).

General workflow

Drawing (nominally 2D)  →  Topology (DCEL)  →  Tags/attributes/templates  →  3D model

1. Draw or import (DXF) a plan.
2. Faces and edges are built automatically from the intersections of lines (topology).
3. Assign tags and attributes with rules to faces, edges, and objects.
4. Prepare templates for complex geometry (curb, fence) by importing 3D models (GLB).
5. Click Build 3D — the system assembles the 3D scene.

2. Getting Started

Interface

The app runs in your browser (no installation). The main areas are:

• Viewport in the center — a single 3D view with a free camera.
• Left panel — project tree, layers, coordinate systems, and the DCEL panel.
• Right panel — properties of the current selection, plus the "Attributes" / "Layer Attributes" panels.
• Tool toolbar and status bar.
• Bottom panel — display checkboxes (axes, DCEL, 3D) and the Build 3D button.

Viewport and Camera

The camera is orbital — it rotates around a target point. Mouse controls:

Standard views and projections (keyboard shortcuts; views are oriented to the active coordinate system):

Projects and Storage

• Projects are stored in the browser (IndexedDB) and/or exported to a file (.asprj).
• Operations: new, open, save, save as, close.
• A project is self-contained: the drawing, imported textures, meshes, materials, and class sets are all kept in a single file.
• An asterisk in the title bar indicates unsaved changes.

Your data stays with you. The app runs entirely in the browser: projects, imported files, and build results are never sent anywhere. We do not receive or store your working data on any server — everything lives locally on your device (in the browser's storage and in the files you export yourself).

⚠ Back up to disk. Browser storage (IndexedDB) isn't permanent: it's easy to lose — when you clear site data, in incognito mode (wiped after the window closes), when you switch to another browser or device, or when you reinstall the browser. Regularly export important projects to an .asprj file (Save As / export to disk) — that's the only truly reliable backup.

3. The Drawing

The drawing is three-dimensional: every point has X, Y, and Z (height) coordinates, and objects can be built in any plane. That said, faces (closed regions) are determined from line intersections in top view — topology is computed on the projection onto the horizontal plane, with the Z height carried into it from the objects themselves. Curves are broken down into segments — after all, the end goal is a 3D model.

Primitives

	Type	Description
	Point	A point in space.
	Polyline	A polyline (a sequence of vertices); can be closed.
	Circle	A circle — center, radius, segment count, plane normal, rotation angle.
	Arc	An arc — center, radius, start and end angle, segment count, plane normal.
	Image	A reference image — a rectangle with a picture, positioned and scaled in space.
	MeshInstance	Placement of an imported 3D mesh (a reference to a template in the tree + a transform).

Segment count on curves is a user setting for the precision of the final mesh. In the viewport you see exactly the approximation that will end up in the 3D model. In the "segments" field you can enter either a number (N segments) or the length of a single segment in meters — for example 3m: the segment count is then computed automatically from the curve's length (the longer the arc or circle, the more segments for the same specified length).

Plane orientation. Circle, Arc, and Image each store their own plane normal. This lets you draw them in any tilted plane. New objects immediately land in the plane of the active coordinate system.

Drawing tools

Tools are selected on the toolbar. Some have keyboard shortcuts (see the reference).

	Tool	What it does
	Point	Add a single point.
	Polyline	A polyline (multiple segments; Enter finishes it).
	Rect	A rectangle (by 2 corners, or by a base line plus a third point).
	Circle	A circle (center → point on the circle).
	Arc	An arc of a circle.
	Image	Insert a raster reference image with positioning.
	PlaceMesh	Place a 3D mesh template in the drawing.
	CS	Create a coordinate system (see §5).

Editing tools

Selection comes in three modes — whole objects, individual points, individual segments; plus topology face selection. Switch between them with ` / 1 / 2 / 4.

	Tool	Key	What it does
	Select	`	Select whole objects (click or box; Ctrl+click — multi-select).
	PointSelect	1	Select individual vertices/points.
	SegmentSelect	2	Select individual segments.
	FaceSelect (DCEL)	4	Select topology faces (to assign attributes to faces).
	Move	W	Move the selection.
	Rotate	E	Rotate the selection.
	Scale	R	Scale the selection.
	Trim	—	Trim segments back to intersections.
	Extend	—	Extend edges to the nearest intersection.
	Refine	—	Insert a vertex on a segment.
	Break	—	Break a polyline into separate parts.
	Merge	—	Merge adjacent objects (polylines, arcs) into one.
	Fillet	—	Round a corner with an arc (radius set by the r parameter).
	Chamfer	—	Cut a corner with a straight line (leg set by the d parameter).
	Offset	—	A parallel copy at a given distance.
	Mirror	—	Mirror across an axis.
	ArrayRect	—	A rectangular array of copies.
	ArrayPolar	—	A radial (circular) array of copies.
	Explode	—	Break a compound object into parts.
	Q	Q	Return to the last selection tool.

Clipboard: Ctrl+C copy, Ctrl+X cut, Ctrl+Shift+C copy with a base point (set it with a click), Ctrl+V paste (the ghost geometry follows the cursor).

It's not just the primitives themselves that get copied, but also their layers, colors, and parametric attributes (tags and values, including those on individual vertices and segments). On paste, layers are carried over by name: if the target drawing already has a layer with the same name, objects land on it; otherwise the layer is created.

The clipboard is shared across the whole application and persists when you open or create another project. So you can paste not only into another drawing of the same project, but also into another file: copy in one project, open/create another — and paste.

4. Precise Construction

Two mechanisms provide construction precision: object snaps (attach the cursor to geometry) and coordinate input (exact numbers from the keyboard).

Object Snaps

Snaps make the cursor "stick" to characteristic points of the geometry. Toggle them on and off with the S key; configure individual modes with Shift+S.

Snap Tracking

This feature remembers the points you have snapped to and builds invisible tracking rays from them. Hover the cursor over a snapped point and hold it there briefly (a short hover) — the point is "acquired." Once acquired, rays extend from it (extension, normal, bisector, ortho), and the cursor can snap to their intersections with rays from other acquired points. This lets you build "at the intersection of extensions" without any helper geometry.

Coordinate Input (Constraints)

While constructing, a floating panel appears next to the cursor with fields for exact values — these override the cursor position. To set a value, move to the field you want with the Tab key (Shift+Tab to go back) and type a number. You don't type the field labels themselves (x, len, ang…) — they are just captions. Which fields are shown is configured with Shift+C. Values are interpreted in the local coordinates of the active coordinate system.

Display vs Lock. An unlocked field (Display) simply shows the current value and updates as you move the mouse. A locked field fixes its value (the background is highlighted), and the cursor snaps to points that satisfy the constraint. If you lock conflicting constraints, a CONFLICT message appears; unlock one of the fields.

How to lock and unlock. First select the field you want with Tab / Shift+Tab. Then type a number and apply it by pressing Tab, Enter, or Esc — the field is applied according to its content:

• field not empty → the constraint is locked to that value;
• field empty → the lock is released (field cleared).

The only difference between the keys is where the focus goes after you apply:

• Tab / Shift+Tab — to the next / previous field;
• Enter — stay in this field (for tools like the polyline, also finish the construction);
• Esc — return focus to the canvas; a second Esc (outside a field) cancels the tool's operation.

5. Layers, coordinate systems, isolation

Layers

Every object belongs to a layer. A layer defines:

• Name and color (used when an object doesn't set its own color).
• Visibility — invisible objects are excluded from rendering and snapping.
• Lock — locked objects are drawn dimmed; snapping still works against them, but they can't be selected or edited.
• Exclusion from topology building — to keep a layer out of face building, give it the noDcel tag (in the Layer Attributes). The same tag can be applied to an individual object, or through a class whose body is {noDcel}.
• Layer Attributes — a shared set of tags/attributes for every object on the layer (edited in the right-hand Layer Attributes panel).

Coordinate systems (UCS)

You can create custom coordinate systems. Construction and coordinate entry are performed relative to the active CS.

• World always exists; it can't be deleted or renamed.
• There are two tools for creating a CS:
  • CS (origin + X) — two clicks: the origin and the direction of the X axis. The plane stays horizontal (the Z axis = world vertical).
  • CS (origin + X + Y) — three clicks: the origin, the direction of the X axis, and a point defining the XY plane. This lets you set an arbitrary tilted orientation in 3D.
• The active CS affects: snap projection, coordinate entry (in local axes), axis display, standard views (T/F/L), and the plane of new objects.
• Points are stored in world coordinates; input is interpreted in the active CS.

Object isolation

Temporary hiding (lives only in the current session — it isn't saved to the file) that works on whole objects:

6. Import

• DXF — the interchange format for 2D drawings (drafting from other CAD systems). Z coordinates come in with the import.
• GLB — an open, standard 3D format (geometry + PBR materials + textures; the "JPEG of 3D"). What gets imported is a self-contained .glb file — all geometry, textures, and materials are packed inside a single file. The text-based .gltf variant with external resources (separate geometry/texture files) is not supported. On import, a folder named after the file is created, containing the images, textures, materials, and the mesh itself. To place copies of the mesh in the drawing, use the PlaceMesh tool.

Imported meshes live "outside" the planar topology — they don't take part in face building.

7. Topology (faces and edges)

When you draw a plan — roads, intersections, lawns — the system automatically recognizes every closed face and the edges between them. There is no need to draw "fill outlines" by hand: topology is derived from the intersections of lines.

• Faces and edges are built automatically from all intersections of the drawing's lines.
• Construction always happens in the world XY plane (top-down plan); the active coordinate system has no effect on topology.
• Any edit to the drawing triggers a reactive rebuild in the background — the interface never blocks.
• A layer can be excluded from topology construction — give it the noDcel tag (under "Layer Attributes"; see §5). The same tag also works on an individual object.
• Faces do not exist in the drawing as objects — select them with the FaceSelect tool (4).

Displaying topology: F2 is the master toggle for topology display (the colored face fill and all DCEL rendering turn on and off together); Shift+F2 is the diagnostic mode (shows half-edges and problem vertices).

8. Parameterization

Parameterization is how a 2D drawing becomes 3D. Elements carry tags and attributes that drive geometry generation.

Tags and attributes

• Tag — a key with no value, for example road or grass. It acts as a label/class: only the "presence of the key" is checked.
• Attribute — a key with a value, for example dz: -0.2 or material: asphalt. A specific value is checked.

They are assigned through the right-hand "Attributes" panel. Typing into the field (confirmed with Enter): a line with a : adds an attribute; a line without a : adds a tag. Attributes can be placed on:

• Objects in the drawing (Polyline, Circle, Arc, Point, Image, MeshInstance);
• Subobjects — individual vertices and segments of a polyline;
• Faces of the topology (selected via FaceSelect);
• Layers (the "Layer Attributes" panel).

Classes

A class is a named set of attributes. It is defined in a ContentClass node in the project tree (you can have several such nodes, organized by theme). Each class has a name and a body (a set of attributes).

A class is applied by assigning a tag whose name matches the class. For example, the class urban-street with the body road; dz: -0.1; material: asphalt expands as soon as you attach the urban-street tag to an object or face.

Priorities (cascade): a direct attribute overrides an attribute from a class; an object's attribute overrides a layer's attribute.

Face attributes

These control the geometry of the face itself. A face goes into 3D if it has at least one of the keys dz / material / slope / proj.

Edge and vertex attributes

Assigned to polyline segments/vertices to act locally on the joints between faces.

Multi-group example: dz: -0.15 grass sidewalk 0.1 road — on the side of the grass and sidewalk faces the edge is lowered by 15 cm, and on the side of road it is raised by 10 cm. This way a single edge can set a different height for each of its neighbors.

9. Templates along edges

A template is a complex piece of geometry (a curb, fence, railing, or guardrail) that the system automatically lays out along the edges of your model, taking length, bends, and corners into account. The topology comes from the plan, and the template itself is drawn like an ordinary drawing.

Basics (the T marker)

A template is a small closed contour split by an internal segment (path) into two faces. Each of the two faces carries class tags that describe which edges the template applies to (for example, the left face is road, the right face is grass). You can also attach tags and attributes to the dividing segment (path) itself: they refine the selection (the template is placed only on edges marked with the same tag) and control how copies are distributed along the edge (see Distribution). Inside the contour you place 3D meshes imported from GLB (with their materials and textures) and positioned with the PlaceMesh tool — these are what get laid out along the edge.

All objects of a template are tied together by a family name — the tag T: <name> (for example T: bordur). It must be present on every object of the template — on the contour faces and on the meshes alike. The most convenient approach is to create a separate layer for the template and attach T: <name> to it (in "Layer Attributes"): then every object on the layer inherits the tag automatically, and you don't have to set it on each object by hand.

How it is applied. The system takes each edge of your plan and looks at the tags of its two adjacent faces. If they match the tags of the template's left and right faces, the template is laid out along that edge. Where the template itself is drawn doesn't matter: templates are searched for across the whole project, so you can keep them off to the side or in a separate library drawing.

Template "bordur":        On the model:
  left face:  road           an edge with a road side and a grass side → matched,
  right face: grass           the curb is laid out along the edge

Roles (TR)

A single logical template (a "family") can consist of several contours with different roles — you draw each one separately and mark it with the tag TR: <role>. The system places the right role in the right spot along the strip.

Any other TR value (not in the list) is treated as user-defined — it's used to separate sets of meshes within a family. The begin/end caps appear automatically at the boundaries of a stretch, and corners appear at bends; the fence "doesn't bend" at a turn.

Distribution along an edge

How exactly the template is repeated along an edge is set by tags/attributes on the template's internal edge (path). By default (with no tags) it uses "round-N" mode: the number of copies ≈ length ÷ template length, with each one stretched slightly.

Examples: n: 4 — exactly 4 copies; clip: center — whole copies, clipped on both sides; n: 3 + clip: end — 3 whole copies, clipped on the right; break: 30 + minScale: 0.5 — cut at bends ≥ 30°, but don't shrink below 50%.

Per-mesh parameters in a template

You can attach extra attributes to a specific mesh (MeshInstance) inside a template:

“along” templates (open polyline)

If a template is applied not by faces but simply along the object itself (a fence along a lawn line, a railing along an edge), you can define it as an open polyline:

• Draw an open polyline and attach the tag T: <name> to it (and, if you like, TR: + distribution tags). Its endpoints set the template's length and direction.
• Place the geometry next to it (it goes to the left/right of the line).
• On the target object (Polyline/Arc/Circle), set the attribute along: <name> — the template will be stretched along it, regardless of topology.
• The direction is set by the vertex order (Polyline) or by the Reverse flag in the properties; it's shown by an arrow in point mode (F4).

10. 3D generation and export

The 3D scene is recomputed on command (not automatically — so that you stay in control of heavy builds):

• Ctrl+B — build the 3D and turn its display on.
• B — toggle the display of the generated geometry.
• The bottom bar has a "3D" checkbox and a build button.

What goes into the build:

1. Faces with the dz/material/slope/proj attributes — triangulated into a surface.
2. Edges with templates (the T: tag) — geometry is laid out along them.
3. Objects with along — a template is swept along the line.

Export. You can export the finished geometry from the menu: Export GLB writes the 3D scene to a .glb file (with all meshes and materials), and Export DXF produces a flat drawing. The result opens in Blender, 3ds Max, and other packages.

11. Undo / Redo

Every operation that modifies the project can be reversed. The history is linear and shared across the entire project: it is common to all drawings, so undo/redo carry over when you switch between drawings (Ctrl+Z undoes the last action even if it was made in a different drawing).

Camera changes are not part of the history. Once you perform a new operation, the redo branch is discarded (as usual in editors).

12. Reference

Keyboard shortcuts

Camera and views

Tools

Display

Editing, clipboard, isolation

Snaps and input

Coordinate input fields

Attribute summary

Parametrization / faces

Templates (tags/attributes)