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

 public override void GetFirstPersonCameraPosition( out Vec3 position, out Vec3 forward, out Vec3 up )
 {
     position = GetInterpolatedPosition() + Type.FPSCameraOffset * GetInterpolatedRotation();
     if( PlayerIntellect.Instance != null )
         forward = PlayerIntellect.Instance.LookDirection.GetVector();
     else
         forward = Vec3.XAxis;
     up = Vec3.ZAxis;
 }

 protected override bool OnGetEditorSelectionByRay( Ray ray, out Vec3 pos, ref float priority )
 {
     float scale1, scale2;
     bool ret = GetBox().RayIntersection( ray, out scale1, out scale2 );
     if( ret )
         pos = ray.GetPointOnRay( Math.Min( scale1, scale2 ) );
     else
         pos = Vec3.Zero;
     return ret;
 }

        public void SetMomentaryTurnToPosition( Vec3 pos )
        {
            if( ( pos - Position ).Length() < 4.0f )
            {
                Vec3 dir = ( pos - Position ).GetNormalize();
                pos += dir * 10;
            }

            MomentaryTurnToPositionUpdate( pos );
        }

 public void Push(Vec3 v)
 {
     if (!Entity.Local) {
         pushV += v;
     } else if (Entity.Model.Server != null) {
         Entity.Get<PositionComponent>().Position += v;
     } else {
         pushV += v;
     }
 }

 public override void PhysX_GetDriveVelocity( out Vec3 linear, out Vec3 angular )
 {
     if( nativeJoint == IntPtr.Zero )
     {
         linear = Vec3.Zero;
         angular = Vec3.Zero;
         return;
     }
     PhysXNativeWrapper.PhysXNativeD6Joint.GetDriveVelocity( nativeJoint, out linear, out angular );
 }