C# Point3F.AsString方法代码示例

/// <summary>
/// @brief Multiply the vector by the transform assuming that w=0.
///    This function will multiply the given vector by the given transform such that translation will 
///    not affect the vector.
///    @param transform A transform.
///    @param vector A vector.
///    @return The transformed vector.
///    @ingroup Matrices)
/// 
/// </summary>
public  Point3F MatrixMulVector(TransformF transform, Point3F vector){
return new Point3F ( m_ts.fn_MatrixMulVector(transform.AsString(), vector.AsString()));
}

/// <summary>
/// @brief Applies a radial impulse to the object using the given origin and force.
/// 
///    @param origin World point of origin of the radial impulse.
///    @param radius The radius of the impulse area.
///    @param magnitude The strength of the impulse.
///    
///    @note Not all objects that derrive from GameBase have this defined.)
/// 
/// </summary>
public  void applyRadialImpulse(string gamebase, Point3F origin, float radius, float magnitude){
m_ts.fnGameBase_applyRadialImpulse(gamebase, origin.AsString(), radius, magnitude);
}

 /// <summary>
 /// @brief Tells the AIPlayer to aim at the location provided.
 /// 
 ///    @param target An \"x y z\" position in the game world to target.
 ///    
 ///    @see getAimLocation())
 /// 
 /// </summary>
 public void setAimLocation(Point3F target)
     {
     TorqueScriptTemplate.m_ts.fnAIPlayer_setAimLocation(_mSimObjectId, target.AsString());
     }

/// <summary>
///  )
/// 
/// </summary>
public  void renderLine(string edittsctrl, Point3F start, Point3F end, float lineWidth){
m_ts.fnEditTSCtrl_renderLine(edittsctrl, start.AsString(), end.AsString(), lineWidth);
}

/// <summary>
///  )
/// 
/// </summary>
public  void renderTriangle(string edittsctrl, Point3F a, Point3F b, Point3F c){
m_ts.fnEditTSCtrl_renderTriangle(edittsctrl, a.AsString(), b.AsString(), c.AsString());
}

/// <summary>
/// Set the velocity for the camera.
///                    @param velocity The camera's velocity in the form of \"x y z\".
///                    @note Only affects the Camera when in Newton mode.)
/// 
/// </summary>
public  void setVelocity(string camera, Point3F velocity){
m_ts.fnCamera_setVelocity(camera, velocity.AsString());
}

/// <summary>
///  )
/// 
/// </summary>
public  void renderBox(string edittsctrl, Point3F pos, Point3F size){
m_ts.fnEditTSCtrl_renderBox(edittsctrl, pos.AsString(), size.AsString());
}

/// <summary>
/// Subtract two vectors.
///    @param a The first vector.
///    @param b The second vector.
///    @return The vector @a a - @a b.
///    @tsexample
/// 	//-----------------------------------------------------------------------------
/// 	//
/// 	// VectorSub( %a, %b );
/// 	//
/// 	// The difference of vector a, (ax, ay, az), and vector b, (bx, by, bz) is:
/// 	//
/// 	//     a - b = ( ax - bx, ay - by, az - bz )
/// 	//
/// 	//-----------------------------------------------------------------------------
/// 
/// 	%a = \"1 0 0\";
/// 	%b = \"0 1 0\";
/// 
/// 	// %r = \"( 1 - 0, 0 - 1, 0 - 0 )\";
/// 	// %r = \"1 -1 0\";
/// 	%r = VectorSub( %a, %b );
///    @endtsexample
///    @ingroup Vectors )
/// 
/// </summary>
public  Point3F VectorSub(Point3F a, Point3F b){
return new Point3F ( m_ts.fn_VectorSub(a.AsString(), b.AsString()));
}

/// <summary>
/// @brief Tells the AIPlayer to aim at the location provided.
/// 
///    @param target An \"x y z\" position in the game world to target.
///    
///    @see getAimLocation())
/// 
/// </summary>
public  void setAimLocation(string aiplayer, Point3F target){
m_ts.fnAIPlayer_setAimLocation(aiplayer, target.AsString());
}

/// <summary>
/// Brings a vector into its unit form, i.e. such that it has the magnitute 1.
///    @param v The vector to normalize.
///    @return The vector @a v scaled to length 1.
///    @tsexample
/// 	//-----------------------------------------------------------------------------
/// 	//
/// 	// VectorNormalize( %a );
/// 	//
/// 	// The normalized vector a, (ax, ay, az), is:
/// 	//
/// 	//     a^ = a / ||a||
/// 	//        = ( ax / ||a||, ay / ||a||, az / ||a|| )
/// 	//
/// 	//-----------------------------------------------------------------------------
/// 
/// 	%a = \"1 1 0\";
/// 	%l = 1.414;
/// 
/// 	// %r = \"( 1 / 1.141, 1 / 1.141, 0 / 1.141 )\";
/// 	// %r = \"0.707 0.707 0\";
/// 	%r = VectorNormalize( %a );
///    @endtsexample
///    @ingroup Vectors )
/// 
/// </summary>
public  Point3F VectorNormalize(Point3F v){
return new Point3F ( m_ts.fn_VectorNormalize(v.AsString()));
}

/// <summary>
/// Scales a vector by a scalar.
///    @param a The vector to scale.
///    @param scalar The scale factor.
///    @return The vector @a a * @a scalar.
///    @tsexample
/// 	//-----------------------------------------------------------------------------
/// 	//
/// 	// VectorScale( %a, %v );
/// 	//
/// 	// Scaling vector a, (ax, ay, az), but the scalar, v, is:
/// 	//
/// 	//     a * v = ( ax * v, ay * v, az * v )
/// 	//
/// 	//-----------------------------------------------------------------------------
/// 
/// 	%a = \"1 1 0\";
/// 	%v = \"2\";
/// 
/// 	// %r = \"( 1 * 2, 1 * 2, 0 * 2 )\";
/// 	// %r = \"2 2 0\";
/// 	%r = VectorScale( %a, %v );
///    @endtsexample
///    @ingroup Vectors )
/// 
/// </summary>
public  Point3F VectorScale(Point3F a, float scalar){
return new Point3F ( m_ts.fn_VectorScale(a.AsString(), scalar));
}

/// <summary>
/// Linearly interpolate between two vectors by @a t.
///    @param a Vector to start interpolation from.
///    @param b Vector to interpolate to.
///    @param t Interpolation factor (0-1).  At zero, @a a is returned and at one, @a b is returned.  In between, an interpolated vector 
///       between @a a and @a b is returned.
///    @return An interpolated vector between @a a and @a b.
///    @tsexample
/// 	//-----------------------------------------------------------------------------
/// 	//
/// 	// VectorLerp( %a, %b );
/// 	//
/// 	// The point between vector a, (ax, ay, az), and vector b, (bx, by, bz), which is
/// 	// weighted by the interpolation factor, t, is
/// 	//
/// 	//     r = a + t * ( b - a )
/// 	//       = ( ax + t * ( bx - ax ), ay + t * ( by - ay ), az + t * ( bz - az ) )
/// 	//
/// 	//-----------------------------------------------------------------------------
/// 
/// 	%a = \"1 1 0\";
/// 	%b = \"2 0 1\";
/// 	%v = \"0.25\";
/// 
/// 	// %r = \"( 1 + 0.25 * ( 2 - 1 ), 1 + 0.25 * ( 0 - 1 ), 0 + 0.25 * ( 1 - 0 ) )\";
/// 	// %r = \"1.25 0.75 0.25\";
/// 	%r = VectorLerp( %a, %b );
///    @endtsexample
///    @ingroup Vectors )
/// 
/// </summary>
public  Point3F VectorLerp(Point3F a, Point3F b, float t){
return new Point3F ( m_ts.fn_VectorLerp(a.AsString(), b.AsString(), t));
}

/// <summary>
/// Calculate the magnitude of the given vector.
///    @param v A vector.
///    @return The length of vector @a v.
///    @tsexample
/// 	//-----------------------------------------------------------------------------
/// 	//
/// 	// VectorLen( %a );
/// 	//
/// 	// The length or magnitude of  vector a, (ax, ay, az), is:
/// 	//
/// 	//     ||a|| = Sqrt( ax * ax + ay * ay + az * az )
/// 	//
/// 	//-----------------------------------------------------------------------------
/// 
/// 	%a = \"1 1 0\";
/// 
/// 	// %r = mSqrt( 1 * 1 + 1 * 1 + 0 * 0 );
/// 	// %r = mSqrt( 2 );
/// 	// %r = 1.414;
/// 	%r = VectorLen( %a );
///    @endtsexample
///    @ingroup Vectors )
/// 
/// </summary>
public  float VectorLen(Point3F v){
return m_ts.fn_VectorLen(v.AsString());
}

/// <summary>
/// Compute the dot product of two vectors.
///    @param a The first vector.
///    @param b The second vector.
///    @return The dot product @a a * @a b.
///    @tsexample
/// 	//-----------------------------------------------------------------------------
/// 	//
/// 	// VectorDot( %a, %b );
/// 	//
/// 	// The dot product between vector a, (ax, ay, az), and vector b, (bx, by, bz), is:
/// 	//
/// 	//     a . b = ( ax * bx + ay * by + az * bz )
/// 	//
/// 	//-----------------------------------------------------------------------------
/// 
/// 	%a = \"1 1 0\";
/// 	%b = \"2 0 1\";
/// 
/// 	// %r = \"( 1 * 2 + 1 * 0 + 0 * 1 )\";
/// 	// %r = 2;
/// 	%r = VectorDot( %a, %b );
///    @endtsexample
///    @ingroup Vectors )
/// 
/// </summary>
public  float VectorDot(Point3F a, Point3F b){
return m_ts.fn_VectorDot(a.AsString(), b.AsString());
}

/// <summary>
/// Set the camera's Euler rotation in radians.
///                    @param rot The rotation in radians in the form of \"x y z\".
///                    @note Rotation around the Y axis is ignored )
/// 
/// </summary>
public  void setRotation(string camera, Point3F rot){
m_ts.fnCamera_setRotation(camera, rot.AsString());
}