public LevelView(ILevel level, ISpriteBatch spriteBatch, ITexture texture, ICamera camera)
 {
     _level = level;
     _spriteBatch = spriteBatch;
     _texture = texture;
     _camera = camera;
 }

 public VisualisationWindow(ZArrayDescriptor desc, ICamera cam, int width, int height, int fsaa_samples, bool vsync)
     : base(width, height, new GraphicsMode(32, 24, 0, fsaa_samples))
 {
     this.cam = cam;
     if(!vsync)
         this.VSync = VSyncMode.Off;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="RenderEventArg"/> class.
 /// </summary>
 /// <param name="renderMode">render mode.</param>
 /// <param name="camera">camera used during rendering.</param>
 /// <param name="pickingGeometryType">Target geometry type(point, line, triangle, quad or polygon) for color-coded-picking when <paramref name="renderMode"/> is <see cref="RenderModes.ColorCodedPicking"/>; otherwise useless.</param>
 public RenderEventArg(RenderModes renderMode, Rectangle viewport, ICamera camera, GeometryType pickingGeometryType = GeometryType.Point)
 {
     this.RenderMode = renderMode;
     this.CanvasRect = viewport;
     this.Camera = camera;
     this.PickingGeometryType = pickingGeometryType;
 }

        public CameraTracker(Game game, ICamera camera)
            : base(game)
        {
            Camera = camera;

            Tension = 0;
            Bias = 0;
            Continuity = 0;

            Waypoints = new List<Waypoint>();

            float time = 0.0f;
            float delta = 3.0f;

            // Waypoints und LookAt-Directions initialisieren
            Waypoints.Add(CreateWaypoint(new Vector3(10.0f, 5.0f, 10.0f), new Vector3(0.0f, 0.0f, 0.0f), time += delta));
            Waypoints.Add(CreateWaypoint(new Vector3(10.0f, 3.0f, -10.0f), new Vector3(0.0f, 3.0f, 0.0f), time += delta));
            Waypoints.Add(CreateWaypoint(new Vector3(-10.0f, 5.0f, -10.0f), new Vector3(0.0f, 0.0f, 0.0f), time += delta));
            Waypoints.Add(CreateWaypoint(new Vector3(-10.0f, 3.0f, 10.0f), new Vector3(0.0f, 3.0f, 0.0f), time += delta));
            Waypoints.Add(CreateWaypoint(new Vector3(-15.0f, 10.0f, 15.0f), new Vector3(5.0f, 0.0f, 0.0f), time += delta));
            Waypoints.Add(CreateWaypoint(new Vector3(-15.0f, 10.0f, -15.0f), new Vector3(0.0f, 0.0f, 5.0f), time += delta));
            Waypoints.Add(CreateWaypoint(new Vector3(1.0f, 5.0f, -1.0f), new Vector3(0.0f, 0.0f, 0.0f), time += delta));
            Waypoints.Add(CreateWaypoint(new Vector3(15.0f, 10.0f, 15.0f), new Vector3(0.0f, 0.0f, 0.0f), time += delta));
            Waypoints.Add(CreateWaypoint(new Vector3(10.0f, 5.0f, 0.0f), new Vector3(0.0f, 0.0f, 0.0f), time += delta));
            Waypoints.Add(CreateWaypoint(new Vector3(0.0f, 0.2f, 0.0f), new Vector3(-1.0f, 0.2f, 0.0f), time += delta));
            Waypoints.Add(CreateWaypoint(new Vector3(-10.0f, 5.0f, 0.0f), new Vector3(0.0f, 0.0f, 0.0f), time += delta));
        }

 public void EnableCameraTracking(ICamera camera)
 {
     this.AddLine("ViewPort: {0}", () => camera.SceneViewport);
     this.AddLine("Translation: {0}", () => camera.SceneTranslationVector);
     this.AddLine("Position: {0}", () => camera.Position);
     this.AddLine("Zooming: {0:f1}", () => camera.ZoomFactor);
 }

 public void GenerateShadowMatrix(ICamera camera, ILight light, out Matrix view, out Matrix projection)
 {
     /// view transforms into Lightspace. Depth is saved. The depth value is then written to the shadowmap position defined by projection (the normal modelviewprojection matrix)
     /// but this is nonsense cause projection will not generate the same position for every pixel across a ray originatin from the lightposition
     view = new Matrix();
     projection = new Matrix();
 }

        public override void Load(IModel model, ICamera camera, int width, int height)
        {
            _camera = camera;

            GL.MakeCurrent();
            GL.Enable(OpenGL.GL_TEXTURE_2D);
            GL.Enable(OpenGL.GL_CULL_FACE);
            GL.Enable(OpenGL.GL_DEPTH_TEST);
            GL.Enable(OpenGL.GL_BLEND);
            GL.Enable(OpenGL.GL_VERTEX_ARRAY);

            GL.Hint(HintTarget.LineSmooth, HintMode.Nicest);
            GL.Enable(OpenGL.GL_LINE_SMOOTH);
            GL.Enable(OpenGL.GL_BLEND);
            GL.BlendFunc(BlendingSourceFactor.SourceAlpha, BlendingDestinationFactor.OneMinusSourceAlpha);

            GL.Enable(OpenGL.GL_MULTISAMPLE);

            GL.MinSampleShading(4.0f);

            GL.PolygonMode(FaceMode.FrontAndBack, PolygonMode.Filled);

            _postProcesser = new PostProcesser(GL,width,height);

            _backgroundRenderer = new BackgroundRenderer(GL);

            var octreeModel = model as OctreeModel;
            if (octreeModel != null)
            {
                _octreeRenderer = new OctreeRenderer(octreeModel, GL);
            }
        }

        public void Render(GameTime gameTime, ICamera camera)
        {
            if (_basicEffect != null)
            {
                // Set the effect's parameters.
                Matrix projectionMatrix, viewMatrix;
                camera.GetMatrices(out projectionMatrix, out viewMatrix);

                _basicEffect.Projection = projectionMatrix;
                _basicEffect.View = viewMatrix;
                _basicEffect.World = SceneNode.Transformation;

                // Set the rasterizer state.
                _graphics.DepthStencilState = DepthStencilState.Default;
                _graphics.BlendState = BlendState.AlphaBlend;
                _graphics.RasterizerState = _rasterizerState;

                // Draw the vertex buffer.
                foreach (var effectPass in _basicEffect.CurrentTechnique.Passes)
                {
                    effectPass.Apply();
                    _graphics.DrawUserPrimitives(PrimitiveType.TriangleList, _particleVertices, 0, _particles.Length, VertexPositionColor.VertexDeclaration);
                }
            }
        }

        public async Task Initialize(ICamera camera, IStorage storage)
        {
            this.camera = camera;
            this.storage = storage;

            var cacheFolder = KnownFolders.PicturesLibrary;
            this.dropFolder = await cacheFolder.GetFolderAsync("securitysystem-cameradrop");
            this.dropFolderWatcher = dropFolder.CreateFileQuery();

            var images = await this.dropFolderWatcher.GetFilesAsync();
            var orderedImages = images.OrderByDescending(x => x.DateCreated);
            this.newestImage = orderedImages.FirstOrDefault();

            this.dropFolderWatcher.ContentsChanged += DropFolderWatcher_ContentsChanged;

            this.allJoynBusAttachment = new AllJoynBusAttachment();
            this.producer = new SecuritySystemProducer(this.allJoynBusAttachment);
            this.allJoynBusAttachment.AboutData.DefaultAppName = Package.Current.DisplayName;
            this.allJoynBusAttachment.AboutData.DefaultDescription = Package.Current.Description;
            this.allJoynBusAttachment.AboutData.DefaultManufacturer = Package.Current.Id.Publisher;
            this.allJoynBusAttachment.AboutData.SoftwareVersion = Package.Current.Id.Version.ToString();
            this.allJoynBusAttachment.AboutData.IsEnabled = true;
            this.producer.Service = this;
            this.producer.Start();
        }

        public override void Update(GameTime gameTime, ICamera camera)
        {
            if (_spaceShip == null || !Enabled)
            {
                return;
            }

            var keyboard = Keyboard.GetState();
            if (keyboard.IsKeyDown(Keys.W) || keyboard.IsKeyDown(Keys.Up))
            {
                _spaceShip.Thrust(Vector2.UnitY * -2500.0f);
            }
            if (keyboard.IsKeyDown(Keys.S) || keyboard.IsKeyDown(Keys.Down))
            {
                _spaceShip.Thrust(Vector2.UnitY * 2500.0f);
            }

            if (keyboard.IsKeyDown(Keys.E))
            {
                _spaceShip.Thrust(Vector2.UnitX * 2000.0f);
            }
            if (keyboard.IsKeyDown(Keys.Q))
            {
                _spaceShip.Thrust(Vector2.UnitX * -2000.0f);
            }

            if (keyboard.IsKeyDown(Keys.D) || keyboard.IsKeyDown(Keys.Right))
            {
                _spaceShip.Rotate(2500.0f);
            }
            if (keyboard.IsKeyDown(Keys.A) || keyboard.IsKeyDown(Keys.Left))
            {
                _spaceShip.Rotate(-2500.0f);
            }
        }

		public Terrain( Game game, IHeightMap heightMap, ICamera camera )
			: base( game ) {
			mGame = game;
			mHeightMap = heightMap;
			mCamera = camera;
			mTerrainCells = new List<TerrainCell>();
		}

 public SceneGraph(ICamera camera, IMap map)
 {
     this._RootGraphList = new List<GameObject>();
     this.RootGraph = _RootGraphList.AsReadOnly();
     this.Camera = camera;
     this.Map = map;
 }

        public Main()
        {
            graphics = new GraphicsDeviceManager(this);

            graphics.SynchronizeWithVerticalRetrace = false;
            graphics.ApplyChanges();

            resolution = Settings.Default.WindowResolution;

            graphics.PreferredBackBufferWidth = resolution.X;
            graphics.PreferredBackBufferHeight = resolution.Y;

            Content.RootDirectory = "Content";

            camera = new FreeLookCamera(this);
            cameraHandler = new CameraHandler(this);
            fps = new FPS(this);
            hud = new HUD(this);

            Components.Add(camera);
            Components.Add(cameraHandler);
            Components.Add(fps);
            Components.Add(hud);

            Services.AddService(typeof(ICamera), camera);

            fakeViewFrustum = new BoundingFrustum(Matrix.Identity);
        }

        public override void Initialize()
        {
            collisionManager = (ICollisionManager)Game.Services.GetService(typeof(ICollisionManager));
            camera = (ICamera)Game.Services.GetService(typeof(ICamera));

            base.Initialize();
        }

        public static void Configure(ICamera camera, GestureSensor gestureSensor)
        {
            var middleWidth = camera.ResolutionWidth/2;
            var middleHeight = camera.ResolutionHeight/2;
            var l = camera.LeftHand;
            var r = camera.RightHand;

            new GestureSlideLeft(l, middleWidth).SlideDetected += (s, a) =>
                gestureSensor.OnSlideLeft(new GestureEventArgs("Left Hand Slide Left"));
            new GestureSlideRight(l, middleWidth).SlideDetected += (s, a) =>
                gestureSensor.OnSlideRight(new GestureEventArgs("Left Hand Slide Right"));
            new GestureSlideUp(l, middleHeight).SlideDetected += (s, a) =>
                gestureSensor.OnSlideUp(new GestureEventArgs("Left Hand Slide Up"));
            new GestureSlideDown(l, middleHeight).SlideDetected += (s, a) =>
                gestureSensor.OnSlideDown(new GestureEventArgs("Left Hand Slide Down"));

            new GestureSlideLeft(r, middleWidth).SlideDetected += (s, a) =>
                gestureSensor.OnSlideLeft(new GestureEventArgs("Right Hand Slide Left"));
            new GestureSlideRight(r, middleWidth).SlideDetected += (s, a) =>
                gestureSensor.OnSlideRight(new GestureEventArgs("Right Hand Slide Right"));
            new GestureSlideUp(r, middleHeight).SlideDetected += (s, a) =>
                gestureSensor.OnSlideUp(new GestureEventArgs("Right Hand Slide Up"));
            new GestureSlideDown(r, middleHeight).SlideDetected += (s, a) =>
                gestureSensor.OnSlideDown(new GestureEventArgs("Right Hand Slide Down"));
        }

        protected override void Draw(GameTime gt, IObject obj, RenderHelper render, ICamera cam, IList<ILight> lights)
        {
            Vector3 dir = cam.Target - cam.Position;
            dir.Normalize();
            _shader.Parameters["forward"].SetValue(dir);
            _shader.Parameters["camUp"].SetValue(cam.Up);
            _shader.Parameters["scaleX"].SetValue(scale.X);
            _shader.Parameters["scaleY"].SetValue(scale.Y);
            _shader.Parameters["xWorld"].SetValue(obj.PhysicObject.WorldMatrix);
            _shader.Parameters["xView"].SetValue(cam.View);
            _shader.Parameters["xProjection"].SetValue(cam.Projection);                        
            //_shader.Parameters["xBillboardTexture"].SetValue(obj.Modelo.getTexture(TextureType.DIFFUSE,0,0));
            render.Textures[0] = obj.Modelo.getTexture(TextureType.DIFFUSE, 0, 0);
            _shader.Parameters["atenuation"].SetValue(atenuation);

            render.PushRasterizerState(RasterizerState.CullNone);

            BatchInformation batchInfo = obj.Modelo.GetBatchInformation(0)[0];            
            {
                _shader.Parameters["alphaTest"].SetValue(alphaTestLimit);
                render.RenderBatch(batchInfo, _shader);
            }

            render.PopRasterizerState();
        }

        public override void Initialize()
        {
            camera = (ICamera)Game.Services.GetService(typeof(ICamera));
            postprocessingManager = (IPostprocessingManager)Game.Services.GetService(typeof(IPostprocessingManager));

            projection = camera.Projection;
            view = camera.View;

            for (int i = 0; i < scenery.Length; ++i)
            {
                scenery[i] = new List<SceneryComponent>();
                for (int j = 0; j < OBJ_PER_LAYER; ++j)
                {

                    // Create initial scenery for each scenery channel, spawning them a random
                    // distance further behind the far plane.  This gives the impression that
                    // the scenery is coming in randomly, instead of initially appearing in a
                    // large group across the entire screen.
                    scenery[i].Add(CreateScenery(i == 0, j));
                    Vector3 pos = scenery[i][j].Position;
                    pos.Z -= (float)Utility.Prng.NextDouble() * 5000.0f;
                    scenery[i][j].Position = pos;
                    postprocessingManager.AddComponent(scenery[i][j]);
                }
            }

            base.Initialize();
        }

        /****************************************************************************************************
         * 
         ****************************************************************************************************/
        public void UpdateBuffer(DeviceContext context, Matrix world, ICamera camera)
        {
            var view = camera.CreateViewMatrix();
            var projection = camera.CreateProjectionMatrix(Resolution);
            Matrices[0] = Matrix.Transpose(world);
            Matrices[1] = Matrix.Transpose(view);
            Matrices[2] = Matrix.Transpose(projection);
            Matrices[3] = Matrix.Transpose(world * view);
            Matrices[4] = Matrix.Transpose(world * view * projection);
            Matrices[5] = Matrix.Transpose(view * projection);
            Matrices[6] = Matrix.Invert(world);
            Matrices[7] = Matrix.Invert(world * view);
            Matrices[8] = Matrix.Transpose(Matrix.Identity * Matrix.Scaling(LightPosition));
            Matrices[9] = new Matrix(new float[] 
            {
                LerpTime, AbsoluteTime, Resolution.X, Resolution.Y,
                BeatTime, Lead,0,0,
                Nisse0, Nisse1, Nisse2, Nisse3,
                0,0,0,0,
            });
            if (Buffer == null)
            {
                Buffer = new Buffer(context.Device, Matrices.Length * Utilities.SizeOf<Matrix>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
            }

            context.UpdateSubresource(Matrices, Buffer);
        }

        public void Draw(GameTime gameTime, ICamera cam, TextureCube skyTexture, Matrix proj)
        {
            // start the shader
            //oceanEffect.Begin();
            //oceanEffect.CurrentTechnique.Passes[0].Begin();

            // set the transforms
            oceanEffect.Parameters["World"].SetValue(Matrix.Identity);
            oceanEffect.Parameters["View"].SetValue(cam.CameraMatrix);
            oceanEffect.Parameters["Projection"].SetValue(proj);
            oceanEffect.Parameters["EyePos"].SetValue(cam.Position);

            // choose and set the ocean textures
            int oceanTexIndex = ((int)(gameTime.TotalGameTime.TotalSeconds) % 4);
            oceanEffect.Parameters["normalTex"].SetValue(OceanNormalMaps[(oceanTexIndex + 1) % 4]);
            oceanEffect.Parameters["normalTex2"].SetValue(OceanNormalMaps[(oceanTexIndex) % 4]);
            oceanEffect.Parameters["textureLerp"].SetValue((((((float)gameTime.TotalGameTime.TotalSeconds) - (int)(gameTime.TotalGameTime.TotalSeconds)) * 2 - 1) * 0.5f) + 0.5f);

            // set the time used for moving waves
            oceanEffect.Parameters["time"].SetValue((float)gameTime.TotalGameTime.TotalSeconds * 0.02f);

            // set the sky texture
            oceanEffect.Parameters["cubeTex"].SetValue(skyTexture);

            //oceanEffect.CommitChanges();
            oceanEffect.CurrentTechnique.Passes[0].Apply();
            // draw our geometry
            //Global.Graphics.VertexDeclaration = OceanVD;
            Global.Graphics.DrawUserPrimitives<VertexPositionNormalTexture>(PrimitiveType.TriangleList, OceanVerts, 0, 2);

            // and we're done!
            //oceanEffect.CurrentTechnique.Passes[0].End();
            //oceanEffect.End();
        }

 public FollowCamera(ICamera camera, IWorldObject target)
 {
     this.camera = camera;
     this.target = target;
     Distance = 1.0f;
     TicksToCatchUp = 200;
 }