C# Vec3类代码示例

        public SceneData(Enigma.D3.Scene scene)
        {
            scene_id = scene.x000_Id;
            scene_sno_id = scene.x0E8_SceneSnoId;
            area_sno_id = scene.x018_LevelAreaSnoId;

            min = new Vec3(scene.x0FC_MeshMinX, scene.x100_MeshMinY, scene.x104_MeshMinZ);
            max = new Vec3(scene.x174_MeshMaxX, scene.x178_MeshMaxY, scene.x104_MeshMinZ); //there is no max z, so consider all grid cells flat
        }

		static void JetPackTick() {

			if (JetPackCtl) {
				float rotz = Mem.ReadFloat(ADDRESSES.DISPLAY.CAMERA_Z_ROT);
				var xVal = Math.Abs((float)Math.Cos(rotz)) * (rotz > 0 && rotz < HALF_PI || (rotz > (PI * 2 - HALF_PI) && rotz < PI * 2) ? -1 : 1);
				var yVal = Math.Abs((float)Math.Sin(rotz)) * (rotz > PI && rotz < PI * 2 ? 1 : -1);

				var coords = new Vec3(Mem.PtrToAddr(ADDRESSES.PLAYER.PlayerPointer, ADDRESSES.PLAYER.COORDS_X_OFFSET));
				coords.X += xVal * JetPackSpeed;
				coords.Y += yVal * JetPackSpeed;
				if ((bool)Config.jetPackCtlEnableZ.Value) {
					float rotx = Mem.ReadFloat(ADDRESSES.DISPLAY.CAMERA_X_ROT);
					coords.Z += rotx / HALF_PI * JetPackSpeed;
				}
				coords.MemWrite(Mem.PtrToAddr(ADDRESSES.PLAYER.PlayerPointer, ADDRESSES.PLAYER.COORDS_X_OFFSET));
			}

			new Vec3(0, 0, 0.0066016f).MemWrite(Mem.PtrToAddr(ADDRESSES.PLAYER.PlayerPointer, ADDRESSES.PLAYER.X_MOVE_SPEED));

			if (JetPackUp)
				Mem.WriteFloat(ADDRESSES.IsInVehicle	? Mem.PtrToAddr(ADDRESSES.VEHICLE.VehiclePointer, ADDRESSES.VEHICLE.SPEED_Z_OFFSET)
													: Mem.PtrToAddr(ADDRESSES.PLAYER.PlayerPointer, ADDRESSES.PLAYER.Z_MOVE_SPEED), JetPackSpeed * PI * 2);
			else if (JetPackDown)
				Mem.WriteFloat(ADDRESSES.IsInVehicle	? Mem.PtrToAddr(ADDRESSES.VEHICLE.VehiclePointer, ADDRESSES.VEHICLE.SPEED_Z_OFFSET)
													: Mem.PtrToAddr(ADDRESSES.PLAYER.PlayerPointer, ADDRESSES.PLAYER.Z_MOVE_SPEED), -JetPackSpeed * PI * 2);
		}

        protected override void OnGetCameraTransform( out Vec3 position, out Vec3 forward,
			out Vec3 up, ref Degree cameraFov )
        {
            position = Vec3.Zero;
            forward = Vec3.XAxis;
            up = Vec3.ZAxis;

            Unit unit = GetPlayerUnit();
            if( unit == null )
                return;

            PlayerIntellect.Instance.FPSCamera = false;

            //To use data about orientation the camera if the cut scene is switched on
            if( IsCutSceneEnabled() )
            {
                if( CutSceneManager.Instance.GetCamera( out position, out forward, out up, out cameraFov ) )
                    return;
            }

            float distance = 25;
            position = unit.GetInterpolatedPosition() + new Vec3( 0, -distance, 0 );
            forward = Vec3.YAxis;
            up = Vec3.ZAxis;
        }

 public Vertex(Vec3 position, Vec3 normal, Vec2 texCoord, Vec3 tangent)
 {
     this.position = position;
     this.normal = normal;
     this.texCoord = texCoord;
     this.tangent = tangent;
 }

 public AttackTask(Weapon weapon, Vec3 target)
 {
     this.taskTime = 0f;
     this.weapon = weapon;
     this.targetPosition = target;
     this.targetEntity = null;
 }

 public ExploreCell(AABB aabb, List<Cell> cells, Vec3 position, int id = -1)
     : base(aabb.Min.X, aabb.Min.Y, 0, aabb.Max.X, aabb.Max.Y, 0, MovementFlag.None, id)
 {
     InitExploreCell();
     Position = position;
     Cells = cells;            
 }

        public bool CellsContains2D(Vec3 p)
        {
            if (!Contains2D(p))
                return false;

            return Cells.Exists(c => c.Contains2D(p));
        }

 public override float GetIllumination( Vec3 position, Vec3 normal )
 {
     //normal
     float normalCoef = Vec3.Dot( normal, -lightDirection );
     MathFunctions.Saturate( ref normalCoef );
     return normalCoef;
 }

        public static unsafe extern IntPtr Initialize(
			 ref Vec3 bmin, ref Vec3 bmax,
			 float tileSize, float cellSize, float cellHeight,
			 int minRegionSize, int mergeRegionSize, [MarshalAs( UnmanagedType.U1 )] bool monotonePartitioning,
			 float maxEgdeLength, float maxEdgeError,
			 int vertsPerPoly, float detailSampleDistance, float detailMaxSampleError,
			 float agentHeight, float agentRadius, float agentMaxClimb, float agentMaxSlope );

 public DirectionalLight(SceneGraph graph, Vec3 intensity, Vec3 direction, float maxShadowDepth)
     : base(graph)
 {
     Intensity = intensity;
     MaxShadowDepth = maxShadowDepth;
     Direction = direction.Normalized;
 }

 public Mat33(float exx, float exy, float exz, float eyx, float eyy, float eyz, float ezx,
     float ezy, float ezz)
 {
     ex = new Vec3(exx, exy, exz);
     ey = new Vec3(eyx, eyy, eyz);
     ez = new Vec3(ezx, ezy, ezz);
 }

 public TransformNode(SceneGraph graph, SceneNode node, Vec3 offset, Vec3 orientation, Vec3 scale)
     : base(graph, node)
 {
     _offset = offset;
     _orientation = orientation;
     _scale = scale;
     UpdateTransform ();
 }

 // Position callback
 public static void myPositionCallback(Object sender, TimeValue timestamp, Int32 sensor, Vec3 report)
 {
     Console.WriteLine("Got POSITION report: Position = ({0}, {1}, {2}), Sensor = ({3})",
         report.x,
         report.y,
         report.z,
         sensor);
 }

        public override Ray GetCheckVisibilityRay( Vec3 position )
        {
            Vec3 dataPosition = position - lightDirection * 10000.0f;

            Vec3 diff = position - dataPosition;
            Vec3 dir = diff.GetNormalize();
            return new Ray( dataPosition, diff - dir * .01f );
        }

        public void SetForceFireRotationLookTo( Vec3 lookTo )
        {
            setForceFireRotation = true;

            Vec3 diff = lookTo - Position;
            //Vec3 diff = lookTo - GetFirePosition( false );

            forceFireRotation = Quat.FromDirectionZAxisUp( diff );
        }