#
#	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;
}