cortex: org/test-creature.org comparison

comparison org/test-creature.org @ 156:e8df6e76c3e5

refactored touch

author	Robert McIntyre <rlm@mit.edu>
date	Fri, 03 Feb 2012 06:15:34 -0700
parents	95bf55614211
children	84c67be00abe

comparison

equal deleted inserted replaced

-:95bf55614211
+:e8df6e76c3e5
 [#^Vector3f in]
 (Vector3f. (.getX in)
 (.getZ in)
 (- (.getY in))))
-(defn world-to-local
-"Convert the world coordinates into coordinates relative to the
-object (i.e. local coordinates), taking into account the rotation
-of object."
-[#^Spatial object world-coordinate]
-(.worldToLocal object world-coordinate nil))
-(defn local-to-world
-"Convert the local coordinates into coordinates into world relative
-coordinates"
-[#^Spatial object local-coordinate]
-(.localToWorld object local-coordinate nil))
 (defmulti joint-dispatch
 "Translate blender pseudo-joints into real JME joints."
 (fn [constraints & _]
 (:type constraints)))
 (def hand "Models/creature1/one.blend")
 (def worm "Models/creature1/try-again.blend")
-(def touch "Models/creature1/touch.blend")
 (defn worm-model [] (load-blender-model worm))
 (defn x-ray [#^ColorRGBA color]
 (doto (Material. (asset-manager)
 "Common/MatDefs/Misc/Unshaded.j3md")
 (import jme3tools.converters.ImageToAwt)
 (import ij.ImagePlus)
-;; Every Mesh has many triangles, each with its own index.
-;; Every vertex has its own index as well.
-(defn tactile-sensor-image
-"Return the touch-sensor distribution image in BufferedImage format,
-or nil if it does not exist."
-[#^Geometry obj]
-(if-let [image-path (meta-data obj "touch")]
-(ImageToAwt/convert
-(.getImage
-(.loadTexture
-(asset-manager)
-image-path))
-false false 0)))
-(defn triangle
-"Get the triangle specified by triangle-index from the mesh within
-bounds."
-[#^Mesh mesh triangle-index]
-(let [scratch (Triangle.)]
-(.getTriangle mesh triangle-index scratch)
-scratch))
-(defn triangle-vertex-indices
-"Get the triangle vertex indices of a given triangle from a given
-mesh."
-[#^Mesh mesh triangle-index]
-(let [indices (int-array 3)]
-(.getTriangle mesh triangle-index indices)
-(vec indices)))
-(defn vertex-UV-coord
-"Get the uv-coordinates of the vertex named by vertex-index"
-[#^Mesh mesh vertex-index]
-(let [UV-buffer
-(.getData
-(.getBuffer
-mesh
-VertexBuffer$Type/TexCoord))]
-[(.get UV-buffer (* vertex-index 2))
-(.get UV-buffer (+ 1 (* vertex-index 2)))]))
-(defn triangle-UV-coord
-"Get the uv-cooridnates of the triangle's verticies."
-[#^Mesh mesh width height triangle-index]
-(map (fn [[u v]] (vector (* width u) (* height v)))
-(map (partial vertex-UV-coord mesh)
-(triangle-vertex-indices mesh triangle-index))))
-(defn same-side?
-"Given the points p1 and p2 and the reference point ref, is point p
-on the same side of the line that goes through p1 and p2 as ref is?"
-[p1 p2 ref p]
-(<=
-0
-(.dot
-(.cross (.subtract p2 p1) (.subtract p p1))
-(.cross (.subtract p2 p1) (.subtract ref p1)))))
-(defn triangle-seq [#^Triangle tri]
-[(.get1 tri) (.get2 tri) (.get3 tri)])
-(defn vector3f-seq [#^Vector3f v]
-[(.getX v) (.getY v) (.getZ v)])
-(defn inside-triangle?
-"Is the point inside the triangle?"
-{:author "Dylan Holmes"}
-[#^Triangle tri #^Vector3f p]
-(let [[vert-1 vert-2 vert-3] (triangle-seq tri)]
-(and
-(same-side? vert-1 vert-2 vert-3 p)
-(same-side? vert-2 vert-3 vert-1 p)
-(same-side? vert-3 vert-1 vert-2 p))))
-(defn triangle->matrix4f
-"Converts the triangle into a 4x4 matrix: The first three columns
-contain the vertices of the triangle; the last contains the unit
-normal of the triangle. The bottom row is filled with 1s."
-[#^Triangle t]
-(let [mat (Matrix4f.)
-[vert-1 vert-2 vert-3]
-((comp vec map) #(.get t %) (range 3))
-unit-normal (do (.calculateNormal t)(.getNormal t))
-vertices [vert-1 vert-2 vert-3 unit-normal]]
-(dorun
-(for [row (range 4) col (range 3)]
-(do
-(.set mat col row (.get (vertices row)col))
-(.set mat 3 row 1))))
-mat))
-(defn triangle-transformation
-"Returns the affine transformation that converts each vertex in the
-first triangle into the corresponding vertex in the second
-triangle."
-[#^Triangle tri-1 #^Triangle tri-2]
-(.mult
-(triangle->matrix4f tri-2)
-(.invert (triangle->matrix4f tri-1))))
-(defn point->vector2f [[u v]]
-(Vector2f. u v))
-(defn vector2f->vector3f [v]
-(Vector3f. (.getX v) (.getY v) 0))
-(defn map-triangle [f #^Triangle tri]
-(Triangle.
-(f 0 (.get1 tri))
-(f 1 (.get2 tri))
-(f 2 (.get3 tri))))
-(defn points->triangle
-"Convert a list of points into a triangle."
-[points]
-(apply #(Triangle. %1 %2 %3)
-(map (fn [point]
-(let [point (vec point)]
-(Vector3f. (get point 0 0)
-(get point 1 0)
-(get point 2 0))))
-(take 3 points))))
-(defn convex-bounds
-;;dylan
-"Returns the smallest square containing the given
-vertices, as a vector of integers [left top width height]."
-;; "Dimensions of the smallest integer bounding square of the list of
-;;  2D verticies in the form: [x y width height]."
-[uv-verts]
-(let [xs (map first uv-verts)
-ys (map second uv-verts)
-x0 (Math/floor (apply min xs))
-y0 (Math/floor (apply min ys))
-x1 (Math/ceil (apply max xs))
-y1 (Math/ceil (apply max ys))]
-[x0 y0 (- x1 x0) (- y1 y0)]))
-(defn sensors-in-triangle
-;;dylan
-"Locate the touch sensors in the triangle, returning a map of their UV and geometry-relative coordinates."
-;;"Find the locations of the touch sensors within a triangle in both
-;; UV and gemoetry relative coordinates."
-[image mesh tri-index]
-(let [width (.getWidth image)
-height (.getHeight image)
-UV-vertex-coords (triangle-UV-coord mesh width height tri-index)
-bounds (convex-bounds UV-vertex-coords)
-cutout-triangle (points->triangle UV-vertex-coords)
-UV-sensor-coords
-(filter (comp (partial inside-triangle? cutout-triangle)
-(fn [[u v]] (Vector3f. u v 0)))
-(white-coordinates image bounds))
-UV->geometry (triangle-transformation
-cutout-triangle
-(triangle mesh tri-index))
-geometry-sensor-coords
-(map (fn [[u v]] (.mult UV->geometry (Vector3f. u v 0)))
-UV-sensor-coords)]
-{:UV UV-sensor-coords :geometry geometry-sensor-coords}))
-(defn-memo locate-feelers
-"Search the geometry's tactile UV image for touch sensors, returning
-their positions in geometry-relative coordinates."
-[#^Geometry geo]
-(let [mesh (.getMesh geo)
-num-triangles (.getTriangleCount mesh)]
-(if-let [image (tactile-sensor-image geo)]
-(map
-(partial sensors-in-triangle image mesh)
-(range num-triangles))
-(repeat (.getTriangleCount mesh) {:UV nil :geometry nil}))))
-(use 'clojure.contrib.def)
-(defn-memo touch-topology [#^Gemoetry geo]
-(vec (collapse (reduce concat (map :UV (locate-feelers geo))))))
-(defn-memo feeler-coordinates [#^Geometry geo]
-(vec (map :geometry (locate-feelers geo))))
-(defn enable-touch [#^Geometry geo]
-(let [feeler-coords (feeler-coordinates geo)
-tris (triangles geo)
-limit 0.1
-;;results (CollisionResults.)
-]
-(if (empty? (touch-topology geo))
-nil
-(fn [node]
-(let [sensor-origins
-(map
-#(map (partial local-to-world geo) %)
-feeler-coords)
-triangle-normals
-(map (partial get-ray-direction geo)
-tris)
-rays
-(flatten
-(map (fn [origins norm]
-(map #(doto (Ray. % norm)
-(.setLimit limit)) origins))
-sensor-origins triangle-normals))]
-(vector
-(touch-topology geo)
-(vec
-(for [ray rays]
-(do
-(let [results (CollisionResults.)]
-(.collideWith node ray results)
-(let [touch-objects
-(filter #(not (= geo (.getGeometry %)))
-results)]
-(- 255
-(if (empty? touch-objects) 255
-(rem
-(int
-(* 255 (/ (.getDistance
-(first touch-objects)) limit)))
-256))))))))))))))
-(defn touch [#^Node pieces]
-(filter (comp not nil?)
-(map enable-touch
-(filter #(isa? (class %) Geometry)
-(node-seq pieces)))))
 (defn test-eye  []
 (.getChild
 (.getChild (worm-model) "eyes")

Mercurial > cortex

comparison org/test-creature.org @ 156:e8df6e76c3e5