SkinMeshBody (Artisynth API documentation)

java.lang.Object
- artisynth.core.modelbase.ModelComponentBase
- - artisynth.core.modelbase.RenderableComponentBase
  - - artisynth.core.mechmodels.MeshComponent
    - - artisynth.core.mechmodels.SkinMeshBase
      - artisynth.core.femmodels.SkinMeshBody

All Implemented Interfaces:

Collidable, CollidableBody, HasSlaveObjects, HasSurfaceMesh, PointAttachable, ComponentChangeListener, CompositeComponent, IndexedComponentList, ModelComponent, RenderableComponent, TransformableGeometry, ScalableUnits, java.lang.Cloneable, HasProperties, HierarchyNode, HasRenderProps, IsRenderable, IsSelectable, Renderable, Scannable
```
public class SkinMeshBody
extends SkinMeshBase
implements CollidableBody, PointAttachable
```
A MeshComponent that supports "skinning", in which the position of each mesh vertex is controlled by the position of one or more "master" components (such as Frames or FEM nodes).
SkinMeshBody manages this skinning by assigning a PointSkinAttachment to each vertex within the mesh, which stores the master components used to control the vertex position and computes that position using the computePosState() method.
PointSkinAttachment is an instance of PointAttachment, and when used by SkinMeshBody to control vertex positions it does not connect to any Point component as a slave (i.e., getSlave() returns null. However, PointSkinAttachments can also be used to attach a point or a marker to the "skin" of a SkinMeshBody, and so allow velocities to propagate from the master components to the point, and forces to propagate from the point to the masters.
Master components can currently include Frame, FemNode3d (within a specific FemModel3d), and individual Particle objects. The set of master components can vary from vertex to vertex. PointSkinAttachment maintains a set of connections to each master component, each with a specified weight, and computes the final vertex position as a weighted sum of the positions computed for each connection. In pseudocode, this can be expressed as:
```
    vertexPos = 0;
    for (each connection c) {
       vertexPos += c.weight * c.connectionPos();
    }
 
```
Frames control vertex positions using various skinning techniques known in the literature. These include linear, linear dual quaternion, and iterative dual quaternion skinning. The technique used is controlled by the getFrameBlending() and setFrameBlending() methods. Implementing these techniques requires SkinMeshBody to maintain additional information for each Frame. Therefore it is necessary for all Frames used in skinning to be registered with the SkinMeshBody using addFrame().
FEM nodes can control vertex positions using linear combinations of either their current position values, or their current displacements from the rest position. It is also recommended that any FemModel used in skinning be registered with the SkinMeshBody using addFemModel(), although neither of the currently implemented FemNode control methods actually require this.
Finally, it is also possible to use a vertex's initial base position to control a portion of its final position. Vertex base positions are also used for Frame-based skinning. Vertex base positions are set initially when a mesh is assigned to the skin. Base positions can be queried and set using getBasePosition() and setBasePosition(), and can be reset en mass using resetBasePositions().
Setting up a SkinMeshBody involves three basic steps:
- Creating the SkinMeshBody and assigning it a PolygonalMesh;
- Registering all Frames and FemModels that will be used to control it;
- Creating appropriate attachments for each vertex.
This process can be as simple as follows:
```
    skinMesh = new SkinMeshBody (polyMesh);
    skinMesh.addFrame (rigidBody1);
    skinMesh.addFrame (rigidBody2);
    skinMesh.addFemModel (femModel1);
    skinMesh.computeDisplacementAttachments();
 
```
Here, computeDisplacementAttachments() automatically computes an attachment for each vertex involving all registered Frames and FemModels that contain a polygonal mesh. The weights connecting each vertex to these master components is based on their current distance to the vertex. Other functions for computing attachments, based on different schemes, may be added in the future.
Alternatively, the application may compute attachments directly. A sketch of the required code might look like this:
```
    skinMesh.clearAttachments();
    for (int i=0; i < skinMesh.numVertices(); i++) {
       Vertex3d vtx = skinMesh.getVertex (i);

       ... use vertex position to compute weights w1, w2, w3, w4
           relating it to various master components ...

       PointSkinAttachment a = new PointSkinAttachment();
       // add new connections:
       a.addFrameConnection (body1Index, w1);
       a.addFrameConnection (body2Index, w2);
       a.addFemDisplacementConnection (femNode4, w3);
       a.addFemDisplacementConnection (femNode6, w4);
       a.finalizeConnections();
       skinMesh.addAttachment (a);
    }
 
```
The initial call to clearAttachments() is necessary if the skinMesh already contains attachments. Then for each vertex, master components are determined, along with their associated weights, and an attachment is created with master connections added using various addXXXConnection() methods followed by a call to finalizeConnections(). The method addFrameConnection() specifies a Frame master, which controls the vertex position using the skinning technique returned by getFrameBlending(). The Frame itself is specified using its FrameInfo structure within SkinMeshBody, which can be obtained using getFrameInfo(). The method addFemDisplacementConnection() specifies a FemNode3d as a master, which controls the vertex position using its current displacement from its own rest position. Other types of connections are possible; one should consult the source code or documentation for PointSkinAttachment.
When calculating attachment weights, an application will likely to need access to the Frames and FemModels that are registered with the SkinMeshBody (for example, to make distance queries on their surface meshes). This can be done using methods such as numFrames(), getFrame(int), numFemModels(), and getFemModel().

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`SkinMeshBody.BodyInfo` Base class for information about bodies (e.g., Frames or FemNodels) used to control the skinning.
`class`	`SkinMeshBody.FemModelInfo` Contains information for each FemModel controlling this SkinMeshBody.
`static class`	`SkinMeshBody.FrameBlending` Characterizes the blend mechanism used for the frame-based portion of the skinning.
`class`	`SkinMeshBody.FrameInfo` Contains information for each frame controlling this SkinMeshBody.

Nested classes/interfaces inherited from interface artisynth.core.mechmodels.Collidable
Collidable.Collidability, Collidable.Group

Nested classes/interfaces inherited from interface artisynth.core.modelbase.ModelComponent
ModelComponent.NavpanelVisibility

Nested classes/interfaces inherited from interface artisynth.core.modelbase.CompositeComponent
CompositeComponent.NavpanelDisplay

Field Summary

Fields
Modifier and Type	Field and Description
`static SkinMeshBody.FrameBlending`	`DEFAULT_FRAME_BLENDING`
`static double`	`DQ_BLEND_TOLERANCE`
`static int`	`DQ_MAX_BLEND_STEPS`
`static double`	`myDefaultSigma`
`static PropertyList`	`myProps`

Fields inherited from class artisynth.core.mechmodels.MeshComponent
DEFAULT_COLOR_INTERPOLATION, DEFAULT_VERTEX_COLOR_MIXING

Fields inherited from class artisynth.core.modelbase.ModelComponentBase
enforceUniqueCompositeNames, enforceUniqueNames, myNumber, NULL_OBJ, useCompactPathNames

Fields inherited from interface artisynth.core.mechmodels.Collidable
All, AllBodies, Deformable, Rigid, Self

Fields inherited from interface artisynth.core.modelbase.TransformableGeometry
TG_ARTICULATED, TG_DRAGGER, TG_PRESERVE_ORIENTATION, TG_SIMULATING

Fields inherited from interface maspack.render.IsRenderable
TRANSPARENT, TWO_DIMENSIONAL

Constructor Summary

Constructors
Constructor and Description

SkinMeshBody()
Creates an empty SkinMeshBody.

SkinMeshBody(MeshBase mesh)
Creates a SkinMeshBody with a specified mesh.

Constructors
Constructor and Description
`SkinMeshBody()` Creates an empty SkinMeshBody.
`SkinMeshBody(MeshBase mesh)` Creates a SkinMeshBody with a specified mesh.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addAttachment(PointSkinAttachment a)` Adds an attachment to this SkinMeshBody.
`void`	`addAttachment(PointSkinAttachment a, boolean initBase)` Adds an attachment to this SkinMeshBody.
`void`	`addFemModel(FemModel3d fem)` Registers a FemModel with this SkinMeshBody so that it can be used for skinning control.
`void`	`addFrame(Frame frame)` Registers a Frame with this SkinMeshBody so that it can be used for skinning control.
`boolean`	`allowCollision(ContactPoint cpnt, Collidable other, java.util.Set<Vertex3d> attachedVertices)` Returns `true` if a collision between this Collidable and `other` should be allowed for the contact point `cpnt`.
`void`	`clearAttachments()` Clears all the attachments associated with this SkinMeshBody.
`void`	`computeDisplacementAttachments(double sigma)` Computes displacement-based attachments for each vertex attachment in this skin mesh.
`void`	`computeWeights()`
`void`	`connectToHierarchy()` Called by the system after this component is added to the component hierarchy (i.e., when it is added as a child of another CompositeComponent).
`boolean`	`containsContactMaster(CollidableDynamicComponent comp)` Returns true if this Collidable contains a specified contact master component.
`PointSkinAttachment`	`createPointAttachment(Point pnt)` Returns a PointAttachment that attaches `pnt` to this component.
`void`	`disconnectFromHierarchy()` Called by the system after this component is removed from the component hierarchy (i.e., when it is removed as a child of its parent).
`java.util.List<SkinMeshBody.FemModelInfo>`	`getAllFemModelInfo()` Returns the information structures of all FemModels that are currently registered with this SkinMeshBody.
`java.util.List<SkinMeshBody.FrameInfo>`	`getAllFrameInfo()` Returns the information structures of all Frames that are currently registered with this SkinMeshBody.
`PropertyList`	`getAllPropertyInfo()` Returns a list giving static information about all properties exported by this object.
`PointSkinAttachment`	`getAttachment(int idx)` Returns the attachment for the idx-th vertex of this SkinMeshBody.
`Point3d`	`getBasePosition(int idx)` Returns the base position for a specified vertex attachment in this SkinMeshBody.
`Collidable.Collidability`	`getCollidable()` Returns the `Collidable.Collidability` of this Collidable.
`Collidable`	`getCollidableAncestor()` Returns the most immediate Collidable ancestor of this Collidable, if any.
`int`	`getCollidableIndex()`
`PolygonalMesh`	`getCollisionMesh()` Returns the mesh that should be used for computing collisions, or `null` if there is no such mesh.
`DistanceGrid`	`getDistanceGrid()` Returns a signed distance grid that can be used with a SignedDistanceCollider, or `null` if this Collidable does not support a signed distance grid (i.e., if `CollidableBody.hasDistanceGrid()` returns `false`).
`FemModel3d`	`getFemModel(int idx)` Returns a FemModel that is currently registered with SkinMeshBody.
`int`	`getFemModelIndex(FemModel fem)` Returns the index of a FemModelthat is currently registered with t this SkinMeshBody, or -1 if the FemModel is not registered.
`SkinMeshBody.FemModelInfo`	`getFemModelInfo(int idx)` Returns an information structure for a FemModel that is currently registered with this SkinMeshBody.
`Frame`	`getFrame(int idx)` Returns a Frame that is currently registered with SkinMeshBody.
`SkinMeshBody.FrameBlending`	`getFrameBlending()` Returns the blend type for that part of the skinning that depends on frames.
`SkinMeshBody.FrameInfo`	`getFrameInfo(Frame frame)` Returns the FrameInfo for a Frame that is currently registered with this SkinMeshBody, or null if the Frame is not registered.
`SkinMeshBody.FrameInfo`	`getFrameInfo(int idx)` Returns an information structure for a Frame that is currently registered with this SkinMeshBody.
`double`	`getMass()`
`void`	`getSoftReferences(java.util.List<ModelComponent> refs)` Appends all soft references for this component to a list.
`void`	`getVertexMasters(java.util.List<ContactMaster> mlist, Vertex3d vtx)` Returns all the contact master components associated with a particular mesh vertex.
`boolean`	`hasDistanceGrid()` Returns `true` if this Collidable supports a signed distance grid that can be used with a SignedDistanceCollider.
`boolean`	`hasFemModel(FemModel3d fem)` Returns true is a specified FemModel is currently registered with this SkinMeshBody.
`boolean`	`hasFrame(Frame frame)` Returns true is a specified Frame is currently registered with this SkinMeshBody.
`boolean`	`isCompound()` Queries whether or not this collidable has sub-collidables.
`boolean`	`isDeformable()` Returns `true` if this collidable is deformable.
`int`	`numAttachments()` Returns the number of attachments currently in this SkinMeshBody.
`int`	`numFemModels()` Returns the number of FemModels currently registered with this SkinMeshBody.
`int`	`numFrames()` Returns the number of Frames currently registered with this SkinMeshBody.
`boolean`	`removeFrame(Frame frame)` Removes a Frame from this SkinMeshBody
`void`	`scan(ReaderTokenizer rtok, java.lang.Object ref)` Scans this element from a ReaderTokenizer.
`void`	`setAttachment(int idx, PointSkinAttachment a)`
`void`	`setAttachment(int idx, PointSkinAttachment a, boolean initBase)`
`void`	`setBasePosition(int idx, Vector3d pos)` Sets the base position for a specified vertex attachment in the SkinMeshBody.
`void`	`setCollidable(Collidable.Collidability c)`
`void`	`setCollidableIndex(int idx)`
`void`	`setFrameBlending(SkinMeshBody.FrameBlending type)` Sets the blend type for that part of the skinning that depends on frames.
`void`	`setMesh(MeshBase mesh)` Sets the mesh associated with the this SkinMeshBody.
`void`	`smoothWeights()`
`void`	`smoothWeights(int networkDist)`
`void`	`smoothWeights(SISOFunction weightFunction, int networkDist)` Smooths weights according to a weighting function of distance.
`void`	`transformGeometry(GeometryTransformer gtr, TransformGeometryContext context, int flags)` Transforms the geometry of this component, using the geometry transformer `gtr` to transform its individual attributes.
`void`	`updateReferences(boolean undo, java.util.Deque<java.lang.Object> undoInfo)` May be called by the system if any of the soft references for this component are removed from the the component hierarchy.
`void`	`updateSlavePos()` Updates the mesh vertices to reflect the current position of the attached Frames, FemModels, and points.

Methods inherited from class artisynth.core.mechmodels.SkinMeshBase
componentChanged, copy, findComponent, get, get, getByNumber, getNavpanelDisplay, getNavpanelVisibility, getNumberLimit, getSurfaceMesh, getSurfaceMeshes, hierarchyContainsReferences, indexOf, numComponents, numSurfaceMeshes, postscan, scaleDistance, setDisplayMode, setNavpanelDisplay, updateNameMap, updateSlaveVel

Methods inherited from class artisynth.core.mechmodels.MeshComponent
addTransformableDependencies, createRenderProps, createSurfaceMeshArray, getColorInterpolation, getFileTransform, getMesh, getMeshToWorld, getSurfaceMeshes, getVertex, getVertexColorMixing, isFileTransformRigid, isMeshModfied, numSurfaceMeshes, numVertices, prerender, render, render, scaleMass, setColorInterpolation, setDefaultValues, setMesh, setMesh, setMeshToWorld, setVertexColorMixing, transformGeometry, updateBounds, updatePosition

Methods inherited from class artisynth.core.modelbase.RenderableComponentBase
getRenderHints, getRenderProps, getSelection, isSelectable, numSelectionQueriesNeeded, setRenderProps, updateRenderProps

Methods inherited from class artisynth.core.modelbase.ModelComponentBase
checkFlag, checkName, checkNameUniqueness, clearFlag, clone, createTempFlag, getChildren, getGrandParent, getHardReferences, getName, getNameRange, getNavpanelVisibility, getNumber, getParent, getProperty, hasChildren, hasState, isConnectedToHierarchy, isFixed, isMarked, isSelected, isWritable, makeValidName, makeValidName, notifyParentOfChange, printReferences, recursivelyContained, recursivelyContains, removeTempFlag, setFixed, setFlag, setMarked, setName, setNavpanelVisibility, setNavpanelVisibility, setNumber, setParent, setSelected, write

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface artisynth.core.modelbase.ModelComponent
getHardReferences, getName, getNavpanelVisibility, getNumber, getParent, hasState, isFixed, isMarked, isSelected, notifyParentOfChange, postscan, setFixed, setMarked, setName, setNumber, setParent, setSelected

Methods inherited from interface maspack.properties.HasProperties
getProperty

Methods inherited from interface maspack.properties.HierarchyNode
getChildren, hasChildren

Methods inherited from interface maspack.util.Scannable
isWritable, write

- Field Detail
  - DEFAULT_FRAME_BLENDING
```
public static SkinMeshBody.FrameBlending DEFAULT_FRAME_BLENDING
```
  - DQ_MAX_BLEND_STEPS
```
public static int DQ_MAX_BLEND_STEPS
```
  - DQ_BLEND_TOLERANCE
```
public static double DQ_BLEND_TOLERANCE
```
  - myDefaultSigma
```
public static double myDefaultSigma
```
  - myProps
```
public static PropertyList myProps
```
- Constructor Detail
  - SkinMeshBody
```
public SkinMeshBody()
```
    Creates an empty SkinMeshBody.
  - SkinMeshBody
```
public SkinMeshBody(MeshBase mesh)
```
    Creates a SkinMeshBody with a specified mesh.
- Method Detail
  - getAllPropertyInfo
```
public PropertyList getAllPropertyInfo()
```
    Description copied from interface: HasProperties
    
    Returns a list giving static information about all properties exported by this object.
    
    Specified by:
    
    getAllPropertyInfo in interface HasProperties
    
    Overrides:
    
    getAllPropertyInfo in class SkinMeshBase
    
    Returns:
    
    static information for all exported properties
  - setFrameBlending
```
public void setFrameBlending(SkinMeshBody.FrameBlending type)
```
    Sets the blend type for that part of the skinning that depends on frames.
  - getFrameBlending
```
public SkinMeshBody.FrameBlending getFrameBlending()
```
    Returns the blend type for that part of the skinning that depends on frames.
  - numAttachments
```
public int numAttachments()
```
    Returns the number of attachments currently in this SkinMeshBody.
    
    Specified by:
    
    numAttachments in class SkinMeshBase
  - addAttachment
```
public void addAttachment(PointSkinAttachment a)
```
    Adds an attachment to this SkinMeshBody. The associated vertex is assumed from the index of the new attachment point, and the attachment's base position is set to the current vertex position. The number of attachments cannot exceed the current number of mesh vertices.
  - addAttachment
```
public void addAttachment(PointSkinAttachment a,
                          boolean initBase)
```
    Adds an attachment to this SkinMeshBody. The associated vertex is assumed from the index of the new attachment point. If initBase is true, then the attachment's base position is set to the current vertex position. The number of attachments cannot exceed the current number of mesh vertices.
  - setAttachment
```
public void setAttachment(int idx,
                          PointSkinAttachment a)
```
  - setAttachment
```
public void setAttachment(int idx,
                          PointSkinAttachment a,
                          boolean initBase)
```
  - clearAttachments
```
public void clearAttachments()
```
    Clears all the attachments associated with this SkinMeshBody.
  - getAttachment
```
public PointSkinAttachment getAttachment(int idx)
```
    Returns the attachment for the idx-th vertex of this SkinMeshBody.
    
    Specified by:
    
    getAttachment in class SkinMeshBase
    
    Parameters:
    
    idx - index of the vertex for which the attachment is desired. Must be less that numAttachments().
  - setMesh
```
public void setMesh(MeshBase mesh)
```
    Sets the mesh associated with the this SkinMeshBody. A new set of attachment components will be created for each vertex, each with their base position set to the current vertex position.
    
    Overrides:
    
    setMesh in class MeshComponent
  - addFrame
```
public void addFrame(Frame frame)
```
    Registers a Frame with this SkinMeshBody so that it can be used for skinning control.
    
    Parameters:
    
    frame - Frame to be registered
  - removeFrame
```
public boolean removeFrame(Frame frame)
```
    Removes a Frame from this SkinMeshBody
    
    Parameters:
    
    frame - Frmae to be removed
    
    Returns:
    
    true if frame found aand removed, false otherwise
  - hasFrame
```
public boolean hasFrame(Frame frame)
```
    Returns true is a specified Frame is currently registered with this SkinMeshBody.
    
    Parameters:
    
    frame - Frame to be queried
  - numFrames
```
public int numFrames()
```
    Returns the number of Frames currently registered with this SkinMeshBody.
  - getFrameInfo
```
public SkinMeshBody.FrameInfo getFrameInfo(int idx)
```
    Returns an information structure for a Frame that is currently registered with this SkinMeshBody.
    
    Parameters:
    
    idx - identities the Frame; must be between 0 and the number returned by numFrames().
  - getAllFrameInfo
```
public java.util.List<SkinMeshBody.FrameInfo> getAllFrameInfo()
```
    Returns the information structures of all Frames that are currently registered with this SkinMeshBody.
  - getFrame
```
public Frame getFrame(int idx)
```
    Returns a Frame that is currently registered with SkinMeshBody.
    
    Parameters:
    
    idx - identities the Frame; must be between 0 and the number returned by numFrames().
  - getFrameInfo
```
public SkinMeshBody.FrameInfo getFrameInfo(Frame frame)
```
    Returns the FrameInfo for a Frame that is currently registered with this SkinMeshBody, or null if the Frame is not registered.
    
    Parameters:
    
    frame - Frame whose FrameInfo is desired
  - addFemModel
```
public void addFemModel(FemModel3d fem)
```
    Registers a FemModel with this SkinMeshBody so that it can be used for skinning control.
    
    Parameters:
    
    fem - FemModel to be registered
  - hasFemModel
```
public boolean hasFemModel(FemModel3d fem)
```
    Returns true is a specified FemModel is currently registered with this SkinMeshBody.
    
    Parameters:
    
    fem - FemModel to be queried
  - numFemModels
```
public int numFemModels()
```
    Returns the number of FemModels currently registered with this SkinMeshBody.
  - getFemModelInfo
```
public SkinMeshBody.FemModelInfo getFemModelInfo(int idx)
```
    Returns an information structure for a FemModel that is currently registered with this SkinMeshBody.
    
    Parameters:
    
    idx - identities the FemModel; must be between 0 and the number returned by numFemModels().
  - getAllFemModelInfo
```
public java.util.List<SkinMeshBody.FemModelInfo> getAllFemModelInfo()
```
    Returns the information structures of all FemModels that are currently registered with this SkinMeshBody.
  - getFemModel
```
public FemModel3d getFemModel(int idx)
```
    Returns a FemModel that is currently registered with SkinMeshBody.
    
    Parameters:
    
    idx - identities the FemModel; must be between 0 and the number returned by numFemModels().
  - getFemModelIndex
```
public int getFemModelIndex(FemModel fem)
```
    Returns the index of a FemModelthat is currently registered with t this SkinMeshBody, or -1 if the FemModel is not registered.
    
    Parameters:
    
    fem - FemModel whose index is desired
  - getBasePosition
```
public Point3d getBasePosition(int idx)
```
    Returns the base position for a specified vertex attachment in this SkinMeshBody. Base positions are used to calculate vertex positions for skinning strategies that are based on displacement.
    
    Parameters:
    
    idx - index of the attachment. Must be less than numAttachments().
  - setBasePosition
```
public void setBasePosition(int idx,
                            Vector3d pos)
```
    Sets the base position for a specified vertex attachment in the SkinMeshBody.
    
    Parameters:
    
    idx - index of the attachment. Must be less than numAttachments().
    
    pos - new base positon
  - smoothWeights
```
public void smoothWeights(SISOFunction weightFunction,
                          int networkDist)
```
    Smooths weights according to a weighting function of distance. At present, this only smooths the weights associated with Frame connections. Results when the SkinMeshBody contains other types of attachment connections are undefined.
    
    Parameters:
    
    weightFunction - single-input single-output function of distance to use as weights
    
    networkDist - number of paths to traverse to collect vertices
  - smoothWeights
```
public void smoothWeights(int networkDist)
```
  - smoothWeights
```
public void smoothWeights()
```
  - computeWeights
```
public void computeWeights()
```
  - computeDisplacementAttachments
```
public void computeDisplacementAttachments(double sigma)
```
    Computes displacement-based attachments for each vertex attachment in this skin mesh. For each vertex, the weights are determined using the relative distances from the vertex to the surface meshes of each of the controlling bodies (Frame, FemModel, etc.). Controlling bodies which don't have a surface mesh are ignored.
    Bodies further away have a lower weighting. If sigma is non-positive, the weighting is determined using an inverse-square attenuation. Otherwise, the weighting is determined using a Gaussian attention controlled by sigma.
    
    Parameters:
    
    sigma - if greater than 0, specifies a Gaussian weighting attenuation.
  - updateSlavePos
```
public void updateSlavePos()
```
    Updates the mesh vertices to reflect the current position of the attached Frames, FemModels, and points.
    
    Specified by:
    
    updateSlavePos in interface HasSlaveObjects
    
    Overrides:
    
    updateSlavePos in class SkinMeshBase
  - transformGeometry
```
public void transformGeometry(GeometryTransformer gtr,
                              TransformGeometryContext context,
                              int flags)
```
    Description copied from interface: TransformableGeometry
    
    Transforms the geometry of this component, using the geometry transformer gtr to transform its individual attributes. The context argument supplies information about what other components are currently being transformed, and also allows the requesting of update actions to be performed after all transform called have completed. The context is also the usual entity that calls this method, from within its TransformGeometryContext.apply(maspack.geometry.GeometryTransformer, int) method. The argument flags provides flags to specify various conditions associated with the the transformation. At present, the available flags are TransformableGeometry.TG_SIMULATING and TransformableGeometry.TG_ARTICULATED.
    This method is not usually called directly by applications. Instead, it is typically called from within the TransformGeometryContext.apply(maspack.geometry.GeometryTransformer, int) method of the context, which takes care of the various operations needed for a complete transform operation, including calling TransformableGeometry.addTransformableDependencies(artisynth.core.modelbase.TransformGeometryContext, int) to collect other components that should be transformed, calling TransformableGeometry.transformGeometry(maspack.matrix.AffineTransform3dBase) for each component, notifying component parents that the geometry has changed, and calling any requested TransformGeometryActions. More details are given in the documentation for TransformGeometryContext.apply(maspack.geometry.GeometryTransformer, int).
    TransformGeometryContext provides a number of static convenience transform methods which take care of building the context and calling apply() for a specified set of components.
    This method should not generally call transformGeometry() for its descendant components. Instead, descendants needing transformation should be specified by adding them to the context in the method TransformableGeometry.addTransformableDependencies(artisynth.core.modelbase.TransformGeometryContext, int).
    
    Specified by:
    
    transformGeometry in interface TransformableGeometry
    
    Overrides:
    
    transformGeometry in class SkinMeshBase
    
    Parameters:
    
    gtr - transformer implementing the transform
    
    context - context information, including what other components are being transformed
    
    flags - specifies conditions associated with the transformation
  - scan
```
public void scan(ReaderTokenizer rtok,
                 java.lang.Object ref)
          throws java.io.IOException
```
    Description copied from class: ModelComponentBase
    
    Scans this element from a ReaderTokenizer. The expected text format is assumed to be compatible with that produced by write.
    
    Specified by:
    
    scan in interface ModelComponent
    
    Specified by:
    
    scan in interface Scannable
    
    Overrides:
    
    scan in class SkinMeshBase
    
    Parameters:
    
    rtok - Tokenizer from which to scan the element
    
    ref - optional reference object which can be used for resolving references to other objects
    
    Throws:
    
    java.io.IOException - if an I/O or formatting error occured
  - connectToHierarchy
```
public void connectToHierarchy()
```
    Description copied from class: ModelComponentBase
    
    Called by the system after this component is added to the component hierarchy (i.e., when it is added as a child of another CompositeComponent). This method is responsible for doing any required hierarchy-dependent initialization.
    When this method is called, ModelComponent.getParent() will return the new parent component; the system will have set this beforehand.
    
    Specified by:
    
    connectToHierarchy in interface ModelComponent
    
    Overrides:
    
    connectToHierarchy in class ModelComponentBase
  - disconnectFromHierarchy
```
public void disconnectFromHierarchy()
```
    Description copied from class: ModelComponentBase
    
    Called by the system after this component is removed from the component hierarchy (i.e., when it is removed as a child of its parent). This method is responsible for any required hierarchy-dependent deinitialization.
    When this method is called, ModelComponent.getParent() will still return this original parent component; the system will set this to null after.
    
    Specified by:
    
    disconnectFromHierarchy in interface ModelComponent
    
    Overrides:
    
    disconnectFromHierarchy in class ModelComponentBase
  - getSoftReferences
```
public void getSoftReferences(java.util.List<ModelComponent> refs)
```
    Appends all soft references for this component to a list. References are other components, outside of this component's immediate ancestry, on which this component depends. For example, an ExcitationComponent may refer to one or more other ExcitationComponents to act as excitation sources. A soft reference is one which can be removed from the referring component. In particular, if any soft references for a component are deleted, then that component's updateReferences() method will be called to update its internal reference information.
    
    Specified by:
    
    getSoftReferences in interface ModelComponent
    
    Overrides:
    
    getSoftReferences in class ModelComponentBase
    
    Parameters:
    
    refs - list to which soft references are appended
  - updateReferences
```
public void updateReferences(boolean undo,
                             java.util.Deque<java.lang.Object> undoInfo)
```
    May be called by the system if any of the soft references for this component are removed from the the component hierarchy. If called with undo equal to false, this component should then examine its soft references and use ComponentUtils.isConnected() to determine which of them have been disconnected from the hierarchy. Disconnected references should be removed, and sufficient information should be appended to undoInfo to allow this update to be undone if this method is called later with undo equal to true. When undoing an update, the undo information should be removed from the front of undoInfo.
    
    Specified by:
    
    updateReferences in interface ModelComponent
    
    Overrides:
    
    updateReferences in class ModelComponentBase
    
    Parameters:
    
    undo - if true, indicates that the most recent reference update should be undone, using the supplied undo information.
    
    undoInfo - if undo is false, should be used to store information allowing the reference update to be undone. Otherwise, if undo is true, then this supplied information to undo the most recent update.
  - getCollisionMesh
```
public PolygonalMesh getCollisionMesh()
```
    Description copied from interface: CollidableBody
    
    Returns the mesh that should be used for computing collisions, or null if there is no such mesh. If this method returns null, then no collisions will be performed for this collidable, regardless any default or explicit collision behaviors that have been arranged by the system.
    
    Specified by:
    
    getCollisionMesh in interface CollidableBody
    
    Returns:
    
    collision mesh for this collidable.
  - hasDistanceGrid
```
public boolean hasDistanceGrid()
```
    Description copied from interface: CollidableBody
    
    Returns true if this Collidable supports a signed distance grid that can be used with a SignedDistanceCollider. At present, this will only be true for non-deformable bodies.
    
    Specified by:
    
    hasDistanceGrid in interface CollidableBody
    
    Returns:
    
    true if this Collidable supports a signed distance grid
  - getDistanceGrid
```
public DistanceGrid getDistanceGrid()
```
    Description copied from interface: CollidableBody
    
    Returns a signed distance grid that can be used with a SignedDistanceCollider, or null if this Collidable does not support a signed distance grid (i.e., if CollidableBody.hasDistanceGrid() returns false).
    
    Specified by:
    
    getDistanceGrid in interface CollidableBody
  - getCollidable
```
public Collidable.Collidability getCollidable()
```
    Description copied from interface: Collidable
    
    Returns the Collidable.Collidability of this Collidable. This provides control over whether external and/or internal collisions are enabled for this Collidable. This setting takes precedence over default and explicitly requested collision behaviors.
    Note that for collisions to actually occur, they still need to be enabled through either a default or explicit collision behavior in the MechModel.
    
    Specified by:
    
    getCollidable in interface Collidable
    
    Returns:
    
    Collidability of this collidable.
  - setCollidable
```
public void setCollidable(Collidable.Collidability c)
```
  - getCollidableAncestor
```
public Collidable getCollidableAncestor()
```
    Description copied from interface: Collidable
    
    Returns the most immediate Collidable ancestor of this Collidable, if any. Otherwise, return null.
    
    Specified by:
    
    getCollidableAncestor in interface Collidable
    
    Returns:
    
    immediate Collidable ancestor, or null.
  - isCompound
```
public boolean isCompound()
```
    Description copied from interface: Collidable
    
    Queries whether or not this collidable has sub-collidables.
    
    Specified by:
    
    isCompound in interface Collidable
    
    Returns:
    
    true if this collidable has sub-collidables
  - isDeformable
```
public boolean isDeformable()
```
    Description copied from interface: Collidable
    
    Returns true if this collidable is deformable. Whether or not a collidable is deformable determines how it responds to default collision behaviors involving deformable and rigid collidables. Also, self-collisions among sub-collidables of a collidable A are permitted only if A is deformable.
    
    Specified by:
    
    isDeformable in interface Collidable
    
    Returns:
    
    true if this collidable is deformable
  - getMass
```
public double getMass()
```
    Specified by:
    
    getMass in interface CollidableBody
  - getVertexMasters
```
public void getVertexMasters(java.util.List<ContactMaster> mlist,
                             Vertex3d vtx)
```
    Description copied from interface: CollidableBody
    
    Returns all the contact master components associated with a particular mesh vertex. Information for each contact master should be appended to mlist. The list should not be cleared. The vertex should be a vertex of the mesh returned by CollidableBody.getCollisionMesh().
    
    Specified by:
    
    getVertexMasters in interface CollidableBody
    
    Parameters:
    
    mlist - collected master component information
    
    vtx - vertex for which the master components are requested
  - containsContactMaster
```
public boolean containsContactMaster(CollidableDynamicComponent comp)
```
    Description copied from interface: CollidableBody
    
    Returns true if this Collidable contains a specified contact master component.
    
    Specified by:
    
    containsContactMaster in interface CollidableBody
    
    Parameters:
    
    comp - component to test for
    
    Returns:
    
    true if comp is contained in this Collidable
  - allowCollision
```
public boolean allowCollision(ContactPoint cpnt,
                              Collidable other,
                              java.util.Set<Vertex3d> attachedVertices)
```
    Description copied from interface: CollidableBody
    
    Returns true if a collision between this Collidable and other should be allowed for the contact point cpnt. In making this decision, this method may refer to attachedVertices, which supplies a list of vertices on this Collidable which are attached in some way to the other Collidable.
    
    Specified by:
    
    allowCollision in interface CollidableBody
    
    Parameters:
    
    cpnt - contact point being tested
    
    other - opposing collidable
    
    attachedVertices - list of vertices attached to other.
    
    Returns:
    
    true if the collision should be allowed
  - getCollidableIndex
```
public int getCollidableIndex()
```
    Specified by:
    
    getCollidableIndex in interface CollidableBody
  - setCollidableIndex
```
public void setCollidableIndex(int idx)
```
    Specified by:
    
    setCollidableIndex in interface CollidableBody
  - createPointAttachment
```
public PointSkinAttachment createPointAttachment(Point pnt)
```
    Description copied from interface: PointAttachable
    
    Returns a PointAttachment that attaches pnt to this component. It should not be assumed that pnt is currently connected to the component hierarchy, and no attempt should be made to connect the returned attachment to the hierarchy; the latter, if desired, is the responsibility of the caller.
    In some cases, it may not be possible to attach the point at its present location. In that case, the method will create an attachment to the nearest feasible location.
    
    Specified by:
    
    createPointAttachment in interface PointAttachable
    
    Parameters:
    
    pnt - point for which an attachment should be created
    
    Returns:
    
    attachment connecting pnt to this component

Class SkinMeshBody

Nested Class Summary

Nested classes/interfaces inherited from interface artisynth.core.mechmodels.Collidable

Nested classes/interfaces inherited from interface artisynth.core.modelbase.ModelComponent

Nested classes/interfaces inherited from interface artisynth.core.modelbase.CompositeComponent

Field Summary

Fields inherited from class artisynth.core.mechmodels.MeshComponent

Fields inherited from class artisynth.core.modelbase.ModelComponentBase

Fields inherited from interface artisynth.core.mechmodels.Collidable

Fields inherited from interface artisynth.core.modelbase.TransformableGeometry

Fields inherited from interface maspack.render.IsRenderable

Constructor Summary

Method Summary

Methods inherited from class artisynth.core.mechmodels.SkinMeshBase

Methods inherited from class artisynth.core.mechmodels.MeshComponent

Methods inherited from class artisynth.core.modelbase.RenderableComponentBase

Methods inherited from class artisynth.core.modelbase.ModelComponentBase

Methods inherited from class java.lang.Object

Methods inherited from interface artisynth.core.modelbase.ModelComponent

Methods inherited from interface maspack.properties.HasProperties

Methods inherited from interface maspack.properties.HierarchyNode

Methods inherited from interface maspack.util.Scannable

Field Detail

DEFAULT_FRAME_BLENDING

DQ_MAX_BLEND_STEPS

DQ_BLEND_TOLERANCE

myDefaultSigma

myProps

Constructor Detail

SkinMeshBody

SkinMeshBody

Method Detail

getAllPropertyInfo

setFrameBlending

getFrameBlending

numAttachments

addAttachment

addAttachment

setAttachment

setAttachment

clearAttachments

getAttachment

setMesh

addFrame

removeFrame

hasFrame

numFrames

getFrameInfo

getAllFrameInfo

getFrame

getFrameInfo

addFemModel

hasFemModel

numFemModels

getFemModelInfo

getAllFemModelInfo

getFemModel

getFemModelIndex

getBasePosition

setBasePosition

smoothWeights

smoothWeights

smoothWeights

computeWeights

computeDisplacementAttachments

updateSlavePos

transformGeometry

scan

connectToHierarchy

disconnectFromHierarchy

getSoftReferences

updateReferences

getCollisionMesh

hasDistanceGrid

getDistanceGrid

getCollidable

setCollidable

getCollidableAncestor

isCompound

isDeformable