#+title: First attempt at a creature!

 #+author: Robert McIntyre

 #+email: rlm@mit.edu

 #+description: 

 #+keywords: simulation, jMonkeyEngine3, clojure

 #+SETUPFILE: ../../aurellem/org/setup.org

 #+INCLUDE: ../../aurellem/org/level-0.org

 

 * Intro 

 So far, I've made the following senses -- 

  - Vision

  - Hearing

  - Touch

  - Proprioception

 

 And one effector: 

  - Movement

 

 However, the code so far has only enabled these senses, but has not

 actually implemented them.  For example, there is still a lot of work

 to be done for vision. I need to be able to create an /eyeball/ in

 simulation that can be moved around and see the world from different

 angles. I also need to determine weather to use log-polar or cartesian

 for the visual input, and I need to determine how/wether to

 disceritise the visual input.

 

 I also want to be able to visualize both the sensors and the

 effectors in pretty pictures. This semi-retarted creature will by my

 first attempt at bringing everything together.

 

 * The creature's body

 

 Still going to do an eve-like body in blender, but due to problems

 importing the joints, etc into jMonkeyEngine3, I',m going to do all

 the connecting here in clojure code, using the names of the individual

 components and trial and error. Later, I'll maybe make some sort of

 creature-building modifications to blender that support whatever

 discreitized senses I'm going to make.

 

 #+name: body-1

 #+begin_src clojure 

 (ns cortex.silly

   "let's play!"

   {:author "Robert McIntyre"})

 

 ;; TODO remove this!

 (require 'cortex.import)

 (cortex.import/mega-import-jme3)

 (use '(cortex world util body hearing touch vision))

 

 (use '[clojure.contrib [seq :only [find-first]]])

 

 

 (rlm.rlm-commands/help)

 

 (defn load-blender-model

   "Load a .blend file using an asset folder relative path."

   [^String model]

   (.loadModel

    (doto (asset-manager)

      (.registerLoader BlenderModelLoader (into-array String ["blend"])))

    model))

 

 (defn meta-data [blender-node key]

   (if-let [data (.getUserData blender-node "properties")]

     (.findValue data key)

     nil))

 

 (defn hand2 []

   (load-blender-model "Models/creature1/try-again.blend"))

 

 (defn hand []

   (load-blender-model "Models/creature1/one.blend"))

 

 

   

 (def hand-names

   #{

     "middle-1"

     "middle-2"

     "middle-3"

     "palm"

     "pinky-1"

     "pinky-2"

     "pinky-3"

     "pointer-1"

     "pointer-2"

     "pointer-3"

     "ring-1"

     "ring-2"

     "ring-3"

     "thumb-1"

     "thumb-2"})

 

 (defn hand-pieces []

   (filter

    (comp hand-names #(apply str (drop-last (.getName %)))) (node-seq (hand))))

 

 (defn hand-joints []

   (map #(.getWorldTranslation %)

        (filter #(re-matches #"joint\.\d\d\d" (.getName %))

                (node-seq (hand)))))

 

 (defn worm-pieces []

   (filter

    (comp #{"worm-2" "worm-1"}

          #(apply str (drop-last (.getName %))))

    (node-seq (hand2))))

 

 (defn worm-joints []

   [Vector3f/ZERO])

 

 

 

 (defn find-joint

   [#^Node parts #^Vector3f joint-position]

   (loop [radius (float 0.01)]

     (let [results (CollisionResults.)]

       (.collideWith

        parts

        (BoundingBox. joint-position radius radius radius)

        results)

       (let [targets

             (distinct

              (map  #(.getGeometry %) results))]

         (if (>= (count targets) 2)

           (take 2 targets)

           (recur (float (* radius 2))))))))

 

 

 

 (defn connect-at-point

   [obj-a obj-b point]

   (let [center-a (.getWorldTranslation obj-a)

         center-b (.getWorldTranslation obj-b)

         pivot-a (.subtract point center-a)

         pivot-b (.subtract point center-b)

         ;; A side-effect of creating a joint registers

         ;; it with both physics objects which in turn

         ;; will register the joint with the physics system

         ;; when the simulation is started.

         joint (Point2PointJoint.

                (.getControl obj-a RigidBodyControl)

                (.getControl obj-b RigidBodyControl)

                pivot-a

                pivot-b)]

     obj-a))

 

 

 (defn physical-hand [#^Node pieces joints]

   ;; Make each piece a physical entity in the simulation.

   (dorun

    (map

     (fn [geom]

       (let [physics-control

             (RigidBodyControl.

              (HullCollisionShape.

               (.getMesh geom))

              ;; TODO: fix this.

              (float 1.0))]

         (.addControl geom physics-control)))

     (filter #(isa? (class %) Geometry )

             (node-seq pieces))))

   (dorun

    (map

     (fn [joint-position]

       (let [[geom-a geom-b] (find-joint pieces joint-position)]

         (connect-at-point geom-a geom-b joint-position)))

       joints))

    pieces)

 

 

 (defn the-hand! [] (physical-hand  (hand) (hand-joints)))

 

 

 (defn test-hand []

   (world

    (nodify [(the-hand!)

             (box 10 1 10 :position (Vector3f. 0 -10 0)

                  :color ColorRGBA/Gray

                  :mass 0)])

    standard-debug-controls

    enable-debug 

    (fn [_ _] 

      (Thread/sleep 100))))

 

 

 

 

 

 

 

 #+end_src

 

 #+results: body-1

 : #'cortex.silly/test-hand

 

 

 

 * COMMENT generate source

 #+begin_src clojure :tangle ../src/cortex/silly.clj

 <<body-1>>

 #+end_src