anchor.diff:    :spread-angle
     :force-X
     :force-Y
  -  :force-Z)
  +  :force-Z
  +  ;; terrain node params
  +
  +  (:height-map-res 10000)
  +  :terrain-material
  +  :mesh-quality
  +  :skirt-height
  +  :block-size)
  +
   
   ;;; Helper macro to define a horde3d API function and declare it inline.
   (defmacro defh3fun ((cname lname) result-type &body body)
  
positive.code: 
  ;; int findNodes( NodeHandle startNode, const char *name, int type );
  (defh3fun ("findNodes" find-nodes) :int
    " Finds scene nodes with the specified properties.
  
    This function loops recursively over all children of startNode and adds them to an internal list
    of results if they match the specified name and type. The result list is cleared each time this
    function is called. The function returns the number of nodes which were found and added to the list.
  
    Parameters:
            startNode       - handle to the node where the search begins
            name            - name of nodes to be searched (empty string for all nodes)
            type            - type of nodes to be searched (SceneNodeTypes::Undefined for all types)
  
    Returns:
            number of search results
  "
    (start-node node-handle) (name :string) (type scene-node-type))
  
  
  ;; NodeHandle getNodeFindResult( int index );
  (defh3fun ("getNodeFindResult" get-node-find-result) node-handle
    " Gets a result from the findNodes query.
  
    This function returns the n-th (index) result of a previous findNodes query. The result is the handle
    to a scene node with the poperties specified at the findNodes query. If the index doesn't exist in the
    result list the function returns 0.
  
    Parameters:
            index   - index of search result
  
    Returns:
            handle to scene node from findNodes query or 0 if result doesn't exist
  "
    (index :int))
  
  
  ;; int castRay( NodeHandle node, float ox, float oy, float oz, float dx, float dy, float dz, int numNearest );
  (defh3fun ("castRay" cast-ray) :int
    " Performs a recursive ray collision query.
  
    This function checks recursively if the specified ray intersects the specified node or one of its children.
   The function finds intersections relative to the ray origin and returns the number of intersecting scene
   nodes. The ray is a line segment and is specified by a starting point (the origin) and a finite direction
    vector which also defines its length. Currently this function is limited to returning intersections with Meshes.
  
    Parameters:
            node            - node at which intersection check is beginning
            ox, oy, oz      - ray origin
            dx, dy, dz      - ray direction vector also specifying ray length
            numNearest      - maximum number of intersection points to be stored (0 for all)
  
    Returns:
            number of intersections
  "
    (node node-handle)
    (ox :float) (oy :float) (oz :float)
  
negative.code: 
  ;; bool setModelAnimParams( NodeHandle modelNode, int stage, float time, float weight );
  (defh3fun ("setModelAnimParams" set-model-anim-params) :boolean
    "Sets the parameters of an animation stage in a Model node.
  
  This function sets the current animation time and weight for a specified stage
  of the specified model.  The time corresponds to the frames of the animation and
  the animation is looped if the time is higher than the maximum number of frames
  in the Animation resource. The weight is used for animation blending and
  determines how much influence the stage has compared to the other active
  stages. When the sum of the weights of all stages is more than one, the
  animations on the lower stages get priority.
  
  Parameters:
          modelNode       - handle to the Model node to be modified
          stage           - index of the animation stage to be modified
          time            - new animation time/frame
          weight          - new blend weight
  
  Returns:
           true in case of success, otherwise false
  "
    (model-node node-handle) (stage :int) (time :float) (weight :float))
  
  
  ;; bool setModelMorpher( NodeHandle modelNode, const char *target, float weight );
  (defh3fun ("setModelMorpher" set-model-morpher) :boolean
    "Sets the weight of a morph target.
  
  This function sets the weight of a specified morph target. If the target
  parameter is an empty string the weight of all morph targets in the specified
  Model node is modified.  If the specified morph target is not found the function
  returns false.
  
  Parameters:
          modelNode       - handle to the Model node to be modified
          target          - name of morph target
          weight          - new weight for morph target
  
  Returns:
           true in case of success, otherwise false
  "
    (model-node node-handle) (target :string) (weight :float))
  
  