lambdaisland.daedalus — com.lambdaisland/daedalus 0.0.35

a-star cljs

(a-star {:keys [radius mesh] :as opts})

AStar cljs

bitmap-mesh cljs

(bitmap-mesh)

bitmap-object cljs

(bitmap-object)

BitmapMesh cljs

BitmapObject cljs

bmp-data->object cljs

(bmp-data->object bmp-data)

build-rect-mesh cljs

(build-rect-mesh w h)

clear cljs

(clear view)

constants cljs

(constants)

Constants cljs

constraint-segment cljs

(constraint-segment {:keys [fromShape] :as opts})

constraint-shape cljs

(constraint-shape {:keys [segments] :as opts})

ConstraintSegment cljs

ConstraintShape cljs

draw-entity cljs

(draw-entity view entity)

(draw-entity view entity clear-before?)

draw-mesh cljs

(draw-mesh view world)

(draw-mesh view world clear-before?)

draw-path cljs

(draw-path view path)

(draw-path view path clear-before?)

Edge cljs

edge cljs

(edge {:keys [fromConstraintSegments colorDebug isConstrained originVertex
              nextLeftEdge leftFace]
       :as opts})

edge-data cljs

(edge-data {:keys [sumDistancesSquared length nodesCount] :as opts})

EdgeData cljs

entity-ai cljs

(entity-ai {:keys [dirNormY dirNormX y x radius] :as opts})

EntityAI cljs

face cljs

(face {:keys [colorDebug] :as opts})

Face cljs

find-path cljs

(find-path path-finder to-x to-y)

(find-path path-finder to-x to-y path)

Uses the path-finder to find a path from the path-finder's entity's current position to the destination. Will fill up and return an array, which can be reused, or shared with a LinearPathsampler.

from-edge-to-rotated-edges cljs

(from-edge-to-rotated-edges)

from-face-to-inner-edges cljs

(from-face-to-inner-edges {:keys [fromFace] :as opts})

from-face-to-inner-vertices cljs

(from-face-to-inner-vertices {:keys [fromFace] :as opts})

from-face-to-neighbour-faces cljs

(from-face-to-neighbour-faces {:keys [fromFace] :as opts})

from-mesh-to-faces cljs

(from-mesh-to-faces {:keys [fromMesh] :as opts})

from-mesh-to-vertices cljs

(from-mesh-to-vertices {:keys [fromMesh] :as opts})

from-vertex-to-holding-faces cljs

(from-vertex-to-holding-faces {:keys [fromVertex] :as opts})

from-vertex-to-incoming-edges cljs

(from-vertex-to-incoming-edges {:keys [fromVertex] :as opts})

from-vertex-to-neighbour-vertices cljs

(from-vertex-to-neighbour-vertices {:keys [fromVertex] :as opts})

from-vertex-to-outgoing-edges cljs

(from-vertex-to-outgoing-edges {:keys [realEdgesOnly fromVertex] :as opts})

FromEdgeToRotatedEdges cljs

FromFaceToInnerEdges cljs

FromFaceToInnerVertices cljs

FromFaceToNeighbourFaces cljs

FromMeshToFaces cljs

FromMeshToVertices cljs

FromVertexToHoldingFaces cljs

FromVertexToIncomingEdges cljs

FromVertexToNeighbourVertices cljs

FromVertexToOutgoingEdges cljs

Funnel cljs

funnel cljs

(funnel {:keys [debugSurface radius] :as opts})

geom-2-d cljs

(geom-2-d)

Geom2D cljs

graph cljs

(graph)

Graph cljs

graph-edge cljs

(graph-edge {:keys [prev next rotPrevEdge rotNextEdge oppositeEdge sourceNode
                    destinationNode data]
             :as opts})

graph-node cljs

(graph-node {:keys [prev next outgoingEdge successorNodes data] :as opts})

GraphEdge cljs

GraphNode cljs

image-data->bmp-data cljs

(image-data->bmp-data image-data)

img->image-data cljs

(img->image-data img)

Return an ImageData for a given <img> tag, using an in-memory canvas

img->object cljs

(img->object img-element)

Convert a black-and-white bitmap image into an object that you can conj! onto your mesh. Takes a HTMLImageElement.

IPathHandler cljs protocol

debug-draw cljs

(debug-draw this)

(debug-draw this opts)

next! cljs

(next! this)

Move the entity one step closer to its destination. Updates entity.x / entity.y, returns nil.

next? cljs

(next? this)

Is the entity still moving?

set-destination cljs

(set-destination this x y)

Set the destination for the entity, clearing out the current path.

set-location cljs

(set-location this x y)

Move the entity to a new location, this will clear out the current path. Use this instead of setting :x/:y on the entity directly, to prevent the path sampler from overwriting them on the next iteration.

set-mesh cljs

(set-mesh this mesh)

Replace the mesh, this will clear the current path.

linear-path-sampler cljs

(linear-path-sampler {:keys [entity count samplingDistance path] :as opts})

LinearPathSampler cljs

matrix-2-d cljs

(matrix-2-d a_ b_ c_ d_ e_ f_ {:keys [a b c d e f] :as opts})

Matrix2D cljs

mesh cljs

(mesh width height {:keys [_vertices _edges _faces clipping] :as opts})

Mesh cljs

node-data cljs

(node-data {:keys [index point] :as opts})

NodeData cljs

object cljs

(object {:keys [pivotX pivotY scaleX scaleY rotation x y matrix coordinates
                constraintShape hasChanged]
         :as opts})

Object cljs

pairs cljs

(pairs path)

The path finder returns a flat list of x and y values, turn this into [x y] pairs for easier processing.

path-finder cljs

(path-finder {:keys [entity mesh] :as opts})

path-handler cljs

(path-handler {:keys [entity mesh sampling-distance view]
               :or {sampling-distance 5}})

Combined path-finder / path-sampler, hiding a bunch of implementation details, and helping to keep these different stateful objects in sync. See IPathHandler for method definitions.

path-iterator cljs

(path-iterator {:keys [entity path] :as opts})

PathFinder cljs

PathIterator cljs

point-2-d cljs

(point-2-d x_ y_ {:keys [x y] :as opts})

Point2D cljs

polygon cljs

(polygon coords)

Construct a polygon from a sequence of [x y] coordinate pairs. Can be conj!ed onto a mesh.

potrace cljs

(potrace)

Potrace cljs

rand-generator cljs

(rand-generator seed
                rangeMin_
                rangeMax_
                {:keys [rangeMin rangeMax seed] :as opts})

RandGenerator cljs

rect cljs

(rect x y w h)

rect-mesh cljs

(rect-mesh)

RectMesh cljs

reset cljs

(reset sampler-or-iterator)

Reset a linear-path-sampler or path-iterator

setup-type cljs

(setup-type type tag plain-vars getters setters)

shape-simplifier cljs

(shape-simplifier)

ShapeSimplifier cljs

simple-view cljs

(simple-view targetCanvas
             {:keys [edgesColor edgesWidth edgesAlpha constraintsColor
                     constraintsWidth constraintsAlpha verticesColor
                     verticesRadius verticesAlpha pathsColor pathsWidth
                     pathsAlpha entitiesColor entitiesWidth entitiesAlpha
                     faceColor faceWidth faceAlpha]
              :as opts})

SimpleView cljs

to-edn cljs

(to-edn plain-vars getters)

tools cljs

(tools)

Tools cljs

Vertex cljs

vertex cljs

(vertex {:keys [colorDebug fromConstraintSegments edge] :as opts})