C# Vector3D.ToUnmanaged方法代码示例

 public Position2D GetScreenCoordinatesFrom3DPosition(Vector3D position, CameraSceneNode camera)
 {
     IntPtr cam = (camera == null ? IntPtr.Zero : camera.Raw);
     int[] sc = new int[2];
     SceneCollisionManager_GetScreenCoordinatesFrom3DPosition(_raw, position.ToUnmanaged(), cam, sc);
     return Position2D.FromUnmanaged(sc);
 }

 public Vector3D GetCollisionResultPoint(TriangleSelector selector, Vector3D ellipsoidPosition, Vector3D ellipsoidRadius, Vector3D ellipsoidDirectionAndSpeed, out Triangle3D outTriangle, out bool outFalling, float slidingSpeed, Vector3D gravityDirectionAndSpeed)
 {
     float[] outtri = new float[9];
     float[] outpos = new float[3];
     outFalling = false;
     SceneCollisionManager_GetCollisionResultPoint(_raw, selector.Raw, ellipsoidPosition.ToUnmanaged(), ellipsoidRadius.ToUnmanaged(), ellipsoidDirectionAndSpeed.ToUnmanaged(), outtri, ref outFalling, slidingSpeed, gravityDirectionAndSpeed.ToUnmanaged(), outpos);
     outTriangle = Triangle3D.FromUnmanaged(outtri);
     return Vector3D.FromUnmanaged(outpos);
 }

 public TextSceneNode AddBillboardTextSceneNodeW(GUIFont font, string text, SceneNode parent, Dimension2Df size, Vector3D position, int id, Color shade_top, Color shade_down)
 {
     IntPtr par = IntPtr.Zero;
     if (parent != null)
         par = parent.Raw;
     return (TextSceneNode)
         NativeElement.GetObject(SceneManager_AddTextSceneNode2W(_raw, font.Raw, text, par, size.ToUnmanaged(), position.ToUnmanaged(),
                                                         id, shade_top.ToUnmanaged(), shade_down.ToUnmanaged()),
                                 typeof(TextSceneNode));
 }

 /// <summary>
 /// Creates a simple animator that will rotate.
 /// </summary>
 /// <returns>An Animator</returns>
 /// <param name="rotation">Rotation</param>
 public Animator CreateRotationAnimator(Vector3D rotation)
 {
     return (Animator)
         NativeElement.GetObject(SceneManager_CreateRotationAnimator(_raw, rotation.ToUnmanaged()),
                                 typeof(Animator));
 }

 /// <summary>
 /// Creates an animator that will fly from one point to... another one !
 /// </summary>
 /// <returns>An Animator</returns>
 /// <param name="start">Start</param>
 /// <param name="end">End</param>
 /// <param name="time">Time needed</param>
 /// <param name="loop">May the movement be looped ?</param>
 public Animator CreateFlyStraightAnimator(Vector3D start, Vector3D end, uint time, bool loop)
 {
     return (Animator)
         NativeElement.GetObject(SceneManager_CreateFlyStraightAnimator(_raw, start.ToUnmanaged(), end.ToUnmanaged(), time, loop),
                                 typeof(Animator));
 }

 /// <summary>
 /// Creates an animator that will fly around a center
 /// </summary>
 /// <returns>An Animator</returns>
 /// <param name="center">Center</param>
 /// <param name="radius">Radius</param>
 /// <param name="speed">Speed</param>
 public Animator CreateFlyCircleAnimator(Vector3D center, float radius, float speed)
 {
     return (Animator)
         NativeElement.GetObject(SceneManager_CreateFlyCircleAnimator(_raw, center.ToUnmanaged(), radius, speed),
                                 typeof(Animator));
 }

 /// <summary>
 /// Creates a simple animator for collision detection
 /// </summary>
 /// <returns>An Animator</returns>
 /// <param name="world">"World", meaning the triangle selector of the terrain/map</param>
 /// <param name="node">Node. Notice that this node MUST BE THE ONE THE ANIMATOR IS ADDED</param>
 /// <param name="ellipsoidRadius">Ellipsoid radius. Usually it's the difference between the node's skybox's max edge and its center</param>
 /// <param name="gravityPerSecond">How much gravity (don't try (0, -100000, 0), even on Jupiter you wouldn't have such gravity)</param>
 /// <param name="ellipsoidTranslation">By default (0, 0, 0), meaning the center of the scene node. You can modify it if needed</param>
 /// <param name="slidingValue">Sliding value, usually 0.0005f</param>
 public Animator CreateCollisionResponseAnimator(TriangleSelector world, SceneNode node, Vector3D ellipsoidRadius, Vector3D gravityPerSecond, Vector3D ellipsoidTranslation, float slidingValue)
 {
     return (Animator)
         NativeElement.GetObject(SceneManager_CreateCollisionResponseAnimator(_raw, world.Raw, node.Raw, ellipsoidRadius.ToUnmanaged(), gravityPerSecond.ToUnmanaged(), ellipsoidTranslation.ToUnmanaged(), slidingValue),
                                 typeof(Animator));
 }

 public SceneNode AddTreeSceneNode(string XMLString, SceneNode parent, int id, Vector3D position,
     Vector3D rotation, Vector3D scale, Texture TreeTexture, Texture LeafTexture, Texture BillTexture)
 {
     IntPtr par = IntPtr.Zero;
     if (parent != null)
         par = parent.Raw;
     return (SceneNode)
         NativeElement.GetObject(SceneManager_AddTreeSceneNode(_raw, XMLString, par, id, position.ToUnmanaged(), rotation.ToUnmanaged(), scale.ToUnmanaged(), TreeTexture.Raw, LeafTexture.Raw, BillTexture.Raw, (int)MaterialType.TransparentAlphaChannel), typeof(SceneNode));
 }

 public TerrainSceneNode AddTerrainSceneNodeFromRawData(float[,] data, int width, SceneNode parent, int id, Vector3D position, Vector3D rotation, Vector3D scale, Color vertexColor, int maxLOD, TerrainPatchSize patchSize, int smoothFactor)
 {
     IntPtr par = IntPtr.Zero;
     if (parent != null)
         par = parent.Raw;
     return (TerrainSceneNode)
         NativeElement.GetObject(SceneManager_AddTerrainSceneNodeFromRawData(_raw, data, data.Length, width, par, id, position.ToUnmanaged(), rotation.ToUnmanaged(), scale.ToUnmanaged(), vertexColor.ToUnmanaged(), maxLOD, patchSize, smoothFactor),
                                 typeof(TerrainSceneNode));
 }

 /// <summary>
 /// Adds a heightmap-based terrain on the scene
 /// </summary>
 /// <returns>The terrain node</returns>
 /// <param name="heightMap">Relative or non-relative path to the heightmap.</param>
 /// <param name="parent">Parent from the terrain</param>
 /// <param name="id">ID (-1 for automatic assign.)</param>
 /// <param name="position">Position of the node</param>
 /// <param name="rotation">Rotation of the node</param>
 /// <param name="scale">Scale of the node</param>
 /// <param name="vertexColor">Default color of all the vertices used if no texture is assigned to the node.</param>
 /// <param name="maxLOD">Maximal LOD, set 5 or change it ONLY IF YOU KNOW WHAT YOU ARE DOING</param>
 /// <param name="patchSize">PatchSize, should be 17 and you mustn't change it unless you know what you're doing</param>
 public TerrainSceneNode AddTerrainSceneNode(string heightMap, SceneNode parent, int id, Vector3D position, Vector3D rotation, Vector3D scale, Color vertexColor, int maxLOD, TerrainPatchSize patchSize, int smoothFactor)
 {
     IntPtr par = IntPtr.Zero;
     if(parent != null)
         par = parent.Raw;
     return (TerrainSceneNode)
         NativeElement.GetObject(SceneManager_AddTerrainSceneNode(_raw, heightMap, par, id, position.ToUnmanaged(), rotation.ToUnmanaged(), scale.ToUnmanaged(), vertexColor.ToUnmanaged(), maxLOD, patchSize, smoothFactor),
                                 typeof(TerrainSceneNode));
 }

 /// <summary>
 /// Adds a light scene node to the scene
 /// </summary>
 /// <returns>The light</returns>
 /// <param name="parent">Parent from the node</param>
 /// <param name="position">Initial position of the light</param>
 /// <param name="color">Floating color of the light</param>
 /// <param name="radius">Radius of the light</param>
 /// <param name="id">ID (-1 for automatic assignation)</param>
 public LightSceneNode AddLightSceneNode(SceneNode parent, Vector3D position, Colorf color, float radius, int id)
 {
     IntPtr par = IntPtr.Zero;
     if(parent != null)
         par = parent.Raw;
     return (LightSceneNode)
         NativeElement.GetObject(SceneManager_AddLightSceneNode(_raw, par, position.ToUnmanaged(), color.ToUnmanaged(), radius, id),
                                 typeof(LightSceneNode));
 }

 public void Draw3DLine(Vector3D start, Vector3D end, Color color)
 {
     VideoDriver_Draw3DLine(_raw, start.ToUnmanaged(), end.ToUnmanaged(), color.ToUnmanaged());
 }

		public ParticleEmitter CreatePointEmitter(Vector3D direction, uint minPPS, uint maxPPS, Color minSC, Color maxSC, uint minLT, uint maxLT, int maxAngleDegrees)
		{
			return (ParticleEmitter)
				NativeElement.GetObject(Particle_CreatePointEmitter(_raw, direction.ToUnmanaged(), minPPS, maxPPS, minSC.ToUnmanaged(), maxSC.ToUnmanaged(), minLT, maxLT, maxAngleDegrees),
										typeof(ParticleEmitter));
		}

		public ParticleAffector CreateGravityAffector(Vector3D gravity, uint timeForceLost)
		{
			return (ParticleAffector)
				NativeElement.GetObject(Particle_CreateGravityAffector(_raw, gravity.ToUnmanaged(), timeForceLost),
										typeof(ParticleAffector));
		}

 /// <summary>
 /// Scales the whole mesh. 
 /// </summary>
 /// <param name="mesh">Mesh on which the operation is performed. </param>
 /// <param name="scale">Scale factor. </param>
 public void ScaleMesh(Mesh mesh, Vector3D scale)
 {
     MeshManipulator_ScaleMesh(_raw, mesh.Raw, scale.ToUnmanaged());
 }