cortex: org/body.org comparison

comparison org/body.org @ 306:7e7f8d6d9ec5

massive spellchecking

author	Robert McIntyre <rlm@mit.edu>
date	Sat, 18 Feb 2012 10:59:41 -0700
parents	23aadf376e9d
children	5d448182c807

comparison

equal deleted inserted replaced

-:19c43ec6958d
+:7e7f8d6d9ec5
 #+title: Building a Body
 #+author: Robert McIntyre
 #+email: rlm@mit.edu
-#+description: Simulating a body (movement, touch, propioception) in jMonkeyEngine3.
+#+description: Simulating a body (movement, touch, proprioception) in jMonkeyEngine3.
 #+SETUPFILE: ../../aurellem/org/setup.org
 #+INCLUDE: ../../aurellem/org/level-0.org
 * Design Constraints
 which describes the creature's entire body. To this you add an
 skeleton which deforms this mesh. This technique is used extensively
 to model humans and create realistic animations. It is hard to use for
 my purposes because it is difficult to update the creature's Physics
 Collision Mesh in tandem with its Geometric Mesh under the influence
-of the armature. Withouth this the creature will not be able to grab
+of the armature. Without this the creature will not be able to grab
 things in its environment, and it won't be able to tell where its
 physical body is by using its eyes. Also, armatures do not specify
 any rotational limits for a joint, making it hard to model elbows,
 shoulders, etc.
 "eve-like". The main reason that I use eve-style bodies is so that
 there will be correspondence between the AI's vision and the physical
 presence of its body. Each individual section is simulated by a
 separate rigid body that corresponds exactly with its visual
 representation and does not change. Sections are connected by
-invisible joints that are well supported in jMonkyeEngine. Bullet, the
+invisible joints that are well supported in jMonkeyEngine. Bullet, the
 physics backend for jMonkeyEngine, can efficiently simulate hundreds
 of rigid bodies connected by joints. Sections do not have to stay as
 one piece forever; they can be dynamically replaced with multiple
 sections to simulate splitting in two. This could be used to simulate
-retractable claws or EVE's hands, which are able to coalece into one
+retractable claws or EVE's hands, which are able to coalesce into one
 object in the movie.
 * Solidifying the Body
 Here is a hand designed eve-style in blender.
 <source src="../video/ghost-hand.ogg" type="video/ogg"
 	  preload="none" poster="../images/aurellem-1280x480.png" />
 </video>
 </center>
 <p>The hand model directly loaded from blender. It has no physical
-presense in the simulation. </p>
+presence in the simulation. </p>
 </div>
 #+end_html
 You will notice that the hand has no physical presence -- it's a
 hologram through which everything passes.  Therefore, the first thing
 #+attr_html: width="755"
 #+caption: Joints hack in blender. Each empty node here will be transformed into a joint in jMonkeyEngine
 [[../images/hand-screenshot1.png]]
 The empty node in the upper right, highlighted in yellow, is the
-parent node of all the emptys which represent joints. The following
+parent node of all the empties which represent joints. The following
 functions must do three things to translate these into real joints:
 - Find the children of the "joints" node.
 - Determine the two spatials the joint it meant to connect.
 - Create the joint based on the meta-data of the empty node.
 "Return the children of the creature's \"joints\" node.")
 #+end_src
 ** Joint Targets and Orientation
-This technique for finding a joint's targets is very similiar to
+This technique for finding a joint's targets is very similar to
 =cortex.sense/closest-node=.  A small cube, centered around the
 empty-node, grows exponentially until it intersects two /physical/
 objects. The objects are ordered according to the joint's rotation,
 with the first one being the object that has more negative coordinates
 in the joint's reference frame. Since the objects must be physical,
 ** Generating Joints
 This section of code iterates through all the different ways of
 specifying joints using blender meta-data and converts each one to the
-appropriate jMonkyeEngine joint.
+appropriate jMonkeyEngine joint.
 #+name: joints-4
 #+begin_src clojure
 (defmulti joint-dispatch
 "Translate blender pseudo-joints into real JME joints."
 control-b
 pivot-a
 pivot-b))
 ;; but instead we must do this:
-(println-repl "substuting 6DOF joint for POINT2POINT joint!")
+(println-repl "substituting 6DOF joint for POINT2POINT joint!")
 (doto
 (SixDofJoint.
 control-a
 control-b
 pivot-a
 for debug purposes. You can see that they correspond to the empty
 nodes in the blender file.
 * Wrap-Up!
-It is convienent to combine =physical!= and =joints!= into one
+It is convenient to combine =physical!= and =joints!= into one
 function that completely creates the creature's physical body.
 #+name: joints-6
 #+begin_src clojure
 (defn body!
 "Endow the creature with a physical body connected with joints.  The
-particulars of the joints and the masses of each pody part are
+particulars of the joints and the masses of each body part are
 determined in blender."
 [#^Node creature]
 (physical! creature)
 (joints! creature))
 #+end_src
 #+name: body-header
 #+begin_src clojure
 (ns cortex.body
 "Assemble a physical creature using the definitions found in a
 specially prepared blender file. Creates rigid bodies and joints so
-that a creature can have a physical presense in the simulation."
+that a creature can have a physical presence in the simulation."
 {:author "Robert McIntyre"}
 (:use (cortex world util sense))
 (:use clojure.contrib.def)
 (:import
 (com.jme3.math Vector3f Quaternion Vector2f Matrix3f)

Mercurial > cortex

comparison org/body.org @ 306:7e7f8d6d9ec5