#
#       This example uses PointLocatorData to shrink-wrap a sphere to a cube,
#       and then pushes the sphere along cube's normals.
#
app = Application
app.NewScene( "", 0 )
root = app.ActiveSceneRoot
CubeGeom = root.AddGeometry("Cube", "MeshSurface").ActivePrimitive.Geometry
SphereObj = root.AddGeometry("Sphere", "MeshSurface")
SphereObj.subdivv = 24
SphereObj.subdivu = 24
# Freeze it, otherwise its position array cannot be set:
app.FreezeObj(SphereObj)
SphereGeom = SphereObj.ActivePrimitive.Geometry
SphereOnCubePointLocators = CubeGeom.GetClosestLocations(SphereGeom.Points.PositionArray)
SphereOnCubePositions = CubeGeom.EvaluatePositions(SphereOnCubePointLocators)
SphereOnCubeNormals = CubeGeom.EvaluateNormals(SphereOnCubePointLocators)
SphereNewPositions = []
i = 0
while i < len(SphereOnCubePositions) :
        j = 0
        tmplist = []
        while j < len(SphereOnCubePositions[i]) :
                tmplist.append( SphereOnCubeNormals[i][j]*3 )
                j = j + 1
        SphereNewPositions.append(tmplist)
        i = i + 1
SphereGeom.Points.PositionArray = SphereNewPositions;

/*
        This example uses PointLocatorData to deform a polygon mesh based on
        the closest weight map value of a NURBS surface mesh.
*/
// Scene creation:
//     Polygon mesh grid and a NURBS surface grid.
//     On the NURBS grid, a weight map having a radial gradient
NewScene( null, false );
var root = Application.ActiveSceneRoot;
var MeshGridObj = root.AddGeometry("Grid", "MeshSurface");
MeshGridObj.subdivu = 24;
MeshGridObj.subdivv = 24;
// We must freeze it, otherwise setting its position array will be forbidden:
FreezeObj(MeshGridObj);
var MeshGridGeom = MeshGridObj.ActivePrimitive.Geometry;
var NURBSGridObj = root.AddGeometry("Grid", "NurbsSurface");
NURBSGridObj.subdivu = 2;
NURBSGridObj.subdivv = 2;
var NURBSGridGeom = NURBSGridObj.ActivePrimitive.Geometry;
var NURBSWeightMap = CreateWeightMap(null, NURBSGridObj, "Weight_Map").item(0);
SetValue(NURBSWeightMap + ".weightmapop.type", 5);
SetValue(NURBSWeightMap + ".weightmapop.weight", 1);
SetValue(NURBSWeightMap + ".weightmapop.invert", true);
NURBSWeightMap = GetValue(NURBSWeightMap);      // Get the weight map again to have an updated copy
// Applying the deformation
var MeshGridPos = MeshGridGeom.Points.PositionArray.toArray();
var MeshGridOnNURBSGridPointLocators = NURBSGridGeom.GetClosestLocations(MeshGridPos);
var WeightMapValuesForMesh = NURBSGridGeom.EvaluateClusterProperty(     MeshGridOnNURBSGridPointLocators,
                                                                        NURBSWeightMap.Parent,
                                                                        NURBSWeightMap ).toArray();
// Push mesh vertices along Y, modulated by NURBS grid's closest surface's weight map value
for(i = 0; i < MeshGridPos.length; i+=3)
        MeshGridPos[i+1] += WeightMapValuesForMesh[i/3]*5;
MeshGridGeom.Points.PositionArray = MeshGridPos;

// The following example is more complex but shows the PointLocatorData 
// at work in the context of a relatively complex scripted operator.
//
// This example creates a "skinning" custom operator, which a kind
// of shrink wrap-based cage deform operator. This operator
// wraps a deformed "body" object with a "skin" object having a different
// topology. In order to create the surface correspondance between
// the skin and the body, it uses a static copy of the "body", which
// is not animated and stands as a reference. The operator supports,
// too, arbitrary poses on each object.
//
// Since the skin and the reference body are not animated, the
// custom operator can create the point locators only once,
// at the first evaluation, and then only need to evaluate
// them on the deformed body at each frame. This improves a lot
// the performance since creating point locators from spatial
// proximity is much more costly than simply evaluating their
// positions or normals.
//
// Additionally, in order to improve the skinning result, the
// operator pushes the sking along the normals of the body,
// and the amplitude of this push can be controlled by a parameter.
NewScene( null, false );
var root = Application.ActiveSceneRoot;
Translate("Camera", 0, 0, 50.0, siRelative, siView, siObj, siXYZ);
// Create the reference body object, non-animated object (a cube),
// and move it to a non-trivial pose
var ReferenceCubeObj = root.AddGeometry("Cube", "MeshSurface");
Translate(ReferenceCubeObj, -25.0, 0, 0, siRelative, siView, siObj, siXYZ);
// Create the skin object (a sphere with more resolution),
// and move it to a non-trivial pose
var ShrinkWrappedSphereObj = root.AddGeometry("Sphere", "MeshSurface");
ShrinkWrappedSphereObj.subdivu = 25;
ShrinkWrappedSphereObj.subdivv = 25;
Rotate(ShrinkWrappedSphereObj, 0, 0, -60.0, siRelative, siLocal, siObj, siXYZ);
Scale(ShrinkWrappedSphereObj, 1.5, 1.5, 1.5, siRelative, siLocal, siObj, siXYZ);
Translate(ShrinkWrappedSphereObj, -25.0, 0, 0, siRelative, siView, siObj, siXYZ);
// Create the animated target body object.
// In order to show the scripted op at work, add kinematic and
// shape animation.
var TargetCubeObj = root.AddGeometry("Cube", "MeshSurface");
Translate(TargetCubeObj, 10.0, 10.0, 0, siRelative, siView, siObj, siXYZ);
SetValue("Context.constructionmode", 1);
Scale("cube1.pnt[2,3,6,LAST]", 0.3, 0.3, 0.3, siRelative, siLocal, siObj, siXYZ);
SaveShapeKey("cube1.pnt[2,3,6,LAST]", null, null, 1);
Scale("cube1.pnt[2,3,6,LAST]", 10.0, 10.0, 10.0, siRelative, siLocal, siObj, siXYZ);
SaveShapeKey("cube1.polymsh.cls.Shape", null, null, 100);
SaveKey("cube1.kine.local.posx,cube1.kine.local.posy,cube1.kine.local.posz");
SaveKey("cube1.kine.local.rotx,cube1.kine.local.roty,cube1.kine.local.rotz");
Rotate(TargetCubeObj, 50.0, 0, 50.0, siRelative, siLocal, siObj, siXYZ);
SetValue("PlayControl.Current", 100);
SaveKey("cube1.kine.local.rotx,cube1.kine.local.roty,cube1.kine.local.rotz", 100);
Translate(TargetCubeObj, -15.0, -15.0, 0.0, siRelative, siView, siObj, siXYZ);
SaveKey("cube1.kine.local.posx,cube1.kine.local.posy,cube1.kine.local.posz", 100);
SetValue("PlayControl.Current", 1);
// Apply the scripted op to the skin.
var SkinOp = ApplySkinOp( ShrinkWrappedSphereObj, ReferenceCubeObj, TargetCubeObj );
SetValue("PlayControl.Loop", true);
PlayForwardsFromStart();
InspectObj(SkinOp);
function ApplySkinOp( inSkinObj, inReferenceBody, inTargetBody )
{
        var op = XSIFactory.CreateScriptedOp( "MySkinOp", MySkinOp_Update.toString(), "JScript" );
        // Define connections
        var skin_group = op.AddPortGroup( "SkinGroup" );
        op.AddIOPort( inSkinObj.ActivePrimitive, "Geom", skin_group.Index );
        op.AddInputPort( inSkinObj.Kinematics.Global, "Pose", skin_group.Index );
        var ref_group = op.AddPortGroup( "ReferenceBodyGroup" );
        op.AddInputPort( inReferenceBody.ActivePrimitive, "Geom", ref_group.Index );
        op.AddInputPort( inReferenceBody.Kinematics.Global, "Pose", ref_group.Index );
        var tgt_group = op.AddPortGroup( "TargetBodyGroup" );
        op.AddInputPort( inTargetBody.ActivePrimitive, "Geom", tgt_group.Index );
        op.AddInputPort( inTargetBody.Kinematics.Global, "Pose", tgt_group.Index );
        // Define a parameter for the push amplitude
        var pdef = XSIFactory.CreateParamDef2( "PushAmplitude", siDouble, 2, -1, 5 );
        op.AddParameter(pdef);
        // Connect operator
        op.Connect(inSkinObj + ";" + inReferenceBody + ";" + inTargetBody);
        return op;
}
// This function contains the implementation of the scripted operator.
function MySkinOp_Update( ctx, out, InSkinGeom, InSkinPose, InReferenceBodyGeom, InReferenceBodyPose, InTargetBodyGeom, InTargetBodyPose )
{
        // TransformPositionArray: transforms in place an array of packed XYZ vectors
        function TransformPositionArray( array, transfo )
        {
                for (i = 0; i < array.length; i+=3)
                {
                        var TempVector3 = XSIMath.CreateVector3()
                        TempVector3.Set(array[i], array[i+1], array[i+2]);
                        TempVector3.MulByTransformationInPlace(transfo);
                        var XYZArray = TempVector3.Get2().toArray();
                        array[i] = XYZArray[0];
                        array[i+1] = XYZArray[1];
                        array[i+2] = XYZArray[2];
                }
        }
        var SkinGeom = InSkinGeom.Value.Geometry;
        var ReferenceBodyGeom = InReferenceBodyGeom.Value.Geometry;
        /////////////////////////////////////////////////////////
        //1) Create skin point locators relatively to the surface 
        //   proximity to the reference body. We intentionally keep
        //   a snapshot of the point locators to speed up the 
        //   next evaluations; we assume that InSkinGeom, InSkinPose, 
        //   InReferenceBodyGeom and InReferenceBodyPose are not
        //   animated.
        var SkinPointLocators = ctx.UserData;
        if(SkinPointLocators == null)   // No user data means that this is the first evaluation of the operator
        {
                // The skin object and the reference may have different poses, so we
                // will compute the surface proximity computation in global space.
                // We will use the closest smoothed surface method (2==siClosestSmoothedSurface).
                ReferenceBodyGeom.SetupPointLocatorQueries(2, InReferenceBodyPose.Value.Transform); 
                // Transform the skin positions in global space
                var SkinGeomPosArray = SkinGeom.Points.PositionArray.toArray();
                // TransformPositionArray: transforms in place an array of packed XYZ vectors
                TransformPositionArray( SkinGeomPosArray, InSkinPose.Value.Transform );
                SkinPointLocators = ReferenceBodyGeom.GetClosestLocations(SkinGeomPosArray);
                ctx.UserData = SkinPointLocators;
        }
        /////////////////////////////////////////////////////////
        //2) Evaluate the point locators on the target body, and
        //   displace them along target body's normals, with the
        //   amplitude given by the scirted op parameter.
        var TargetBodyGeom = InTargetBodyGeom.Value.Geometry;
        var SkinOnTargetBodyPositions = TargetBodyGeom.EvaluatePositions(SkinPointLocators).toArray();
        var SkinOnTargetBodyNormals = TargetBodyGeom.EvaluateNormals(SkinPointLocators).toArray();
        var SkinToTargetTransform = XSIMath.MapWorldPoseToObjectSpace(InSkinPose.Value.Transform, InTargetBodyPose.Value.Transform);
        var dPushAmplitude = ctx.Parameters("PushAmplitude").Value
        for (i = 0; i < SkinOnTargetBodyPositions.length; i++)
                SkinOnTargetBodyPositions[i] += SkinOnTargetBodyNormals[i]*dPushAmplitude;
        // TransformPositionArray: transforms in place an array of packed XYZ vectors
        TransformPositionArray( SkinOnTargetBodyPositions, SkinToTargetTransform );
        SkinGeom.Points.PositionArray = SkinOnTargetBodyPositions;
}