public void Render(RenderContext context)
		{
			var value = Template.GetValue(context.RenderModel, this.Key);

			if(context.RenderValue != null)
			{
				var rendered = context.RenderValue(this.Key, value, context);
				if(rendered)
				{
					return;
				}
			}

			if(value == null)
			{
				return;
			}

			var iRenderizable = value as IRenderizable;
			if(iRenderizable != null)
			{
				iRenderizable.Render(context);
			}
			else
			{
				context.Writer.Write(value.ToString());
			}
		}

        // TODO: Find a way to replug this

        /// <summary>
        /// Adds a default frustum culling for rendering only meshes that are only inside the frustum/
        /// </summary>
        /// <param name="modelRenderer">The model renderer.</param>
        /// <returns>ModelRenderer.</returns>
        //public static ModelComponentRenderer AddDefaultFrustumCulling(this ModelComponentRenderer modelRenderer)
        //{
        //    modelRenderer.UpdateMeshes = FrustumCulling;
        //    return modelRenderer;
        //}

        private static void FrustumCulling(RenderContext context, FastList<RenderMesh> meshes)
        {
            Matrix viewProjection, mat1, mat2;

            // Compute view * projection
            context.Parameters.Get(TransformationKeys.View, out mat1);
            context.Parameters.Get(TransformationKeys.Projection, out mat2);
            Matrix.Multiply(ref mat1, ref mat2, out viewProjection);

            var frustum = new BoundingFrustum(ref viewProjection);

            for (var i = 0; i < meshes.Count; ++i)
            {
                var renderMesh = meshes[i];

                // Fast AABB transform: http://zeuxcg.org/2010/10/17/aabb-from-obb-with-component-wise-abs/
                // Get world matrix
                renderMesh.Mesh.Parameters.Get(TransformationKeys.World, out mat1);

                // Compute transformed AABB (by world)
                var boundingBoxExt = new BoundingBoxExt(renderMesh.Mesh.BoundingBox);
                boundingBoxExt.Transform(mat1);

                // Perform frustum culling
                if (!frustum.Contains(ref boundingBoxExt))
                {
                    meshes.SwapRemoveAt(i--);
                }
            }
        }

        protected override void DrawCore(RenderContext context, RenderItemCollection renderItems, int fromIndex, int toIndex)
        {
            var graphicsDevice = context.GraphicsDevice;
            var destination = new RectangleF(0, 0, 1, 1);

            // find the last background to display with valid texture
            BackgroundComponent background = null;
            for (var i = toIndex; i >= fromIndex; --i)
            {
                background = (BackgroundComponent)renderItems[i].DrawContext;
                if (background.Texture != null)
                    break;
            }

            // Abort if not valid background component
            if (background == null || background.Texture == null)
                return;

            var texture = background.Texture;
            var target = CurrentRenderFrame;
            var imageBufferMinRatio = Math.Min(texture.ViewWidth / (float)target.Width, texture.ViewHeight / (float)target.Height);
            var sourceSize = new Vector2(target.Width * imageBufferMinRatio, target.Height * imageBufferMinRatio);
            var source = new RectangleF((texture.ViewWidth - sourceSize.X) / 2, (texture.ViewHeight - sourceSize.Y) / 2, sourceSize.X, sourceSize.Y);

            spriteBatch.Parameters.Add(BackgroundEffectKeys.Intensity, background.Intensity);
            spriteBatch.Begin(SpriteSortMode.FrontToBack, graphicsDevice.BlendStates.Opaque, graphicsDevice.SamplerStates.LinearClamp, graphicsDevice.DepthStencilStates.None, null, backgroundEffect);
            spriteBatch.Draw(texture, destination, source, Color.White, 0, Vector2.Zero);
            spriteBatch.End();
        }

 protected override void OnRenderContent(RenderContext context)
 {
     if (Head != null)
         Head.OnRender(context);
     if (Body != null)
         Body.OnRender(context);
 }

 /// <summary>
 /// Create a new instance of the class.
 /// </summary>
 /// <param name="context">the context</param>
 public RadiancePrefilteringGGX(RenderContext context)
     : base(context, "RadiancePrefilteringGGX")
 {
     computeShader = new ComputeEffectShader(context) { ShaderSourceName = "RadiancePrefilteringGGXEffect" };
     DoNotFilterHighestLevel = true;
     samplingsCount = 1024;
 }

 /// <summary>
 /// Create a new instance of the class.
 /// </summary>
 /// <param name="context">the context</param>
 public RadiancePrefilteringGGXNoCompute(RenderContext context)
     : base(context, "RadiancePrefilteringGGX")
 {
     shader = new ImageEffectShader("RadiancePrefilteringGGXNoComputeEffect");
     DoNotFilterHighestLevel = true;
     samplingsCount = 1024;
 }

 public override bool Render(RenderContext dest)
 {
     dest.ForceLineBreak();
     dest.Append(Comment);
     dest.ForceLineBreak();
     return false;
 }

 public override bool Render(RenderContext dest)
 {
     dest.Append("while(");
     Condition.Render(dest);
     dest.Append(")");
     return Code.RenderIndented(dest);
 }

        public Color renderPixel(int x, int y)
        {
            Color color;
              HitRecord hitRecord = new HitRecord();
              Ray ray;
              RenderContext renderContext = new RenderContext( this.scene );

              float step = 2 / (float)this.scene.getXResolution();
              float xStart = -1 + ( 0.5f * step );
              float yStart = (-(float)this.scene.getYResolution() * (0.5f * step)) + (0.5f * step);

              ray = this.scene.getCamera().generateRay( xStart + (x * step), yStart + (y * step) );
              this.scene.traceRay( ray, hitRecord, renderContext );

              if ( hitRecord.getT() == float.PositiveInfinity || hitRecord.getMaterial() == null || hitRecord.getPrimitive() == null ) {

             color = this.scene.getBackground().getColor( renderContext, ray );

              } else {

             color = hitRecord.getMaterial().shade( renderContext, ray, hitRecord, 1 );

              }

              return color;
        }

        public static void UpdateParameters(RenderContext context, CameraComponent camera)
        {
            if (camera == null) throw new ArgumentNullException("camera");

            // Setup viewport size
            var currentViewport = context.GraphicsDevice.Viewport;
            var aspectRatio = currentViewport.AspectRatio;

            // Update the aspect ratio
            if (camera.UseCustomAspectRatio)
            {
                aspectRatio = camera.AspectRatio;
            }

            // If the aspect ratio is calculated automatically from the current viewport, update matrices here
            camera.Update(aspectRatio);

            // Store the current view/projection matrix in the context
            var viewParameters = context.Parameters;
            viewParameters.Set(TransformationKeys.View, camera.ViewMatrix);
            viewParameters.Set(TransformationKeys.Projection, camera.ProjectionMatrix);
            viewParameters.Set(TransformationKeys.ViewProjection, camera.ViewProjectionMatrix);
            viewParameters.Set(CameraKeys.NearClipPlane, camera.NearClipPlane);
            viewParameters.Set(CameraKeys.FarClipPlane, camera.FarClipPlane);
            viewParameters.Set(CameraKeys.VerticalFieldOfView, camera.VerticalFieldOfView);
            viewParameters.Set(CameraKeys.OrthoSize, camera.OrthographicSize);
            viewParameters.Set(CameraKeys.ViewSize, new Vector2(currentViewport.Width, currentViewport.Height));
            viewParameters.Set(CameraKeys.AspectRatio, aspectRatio);

            //viewParameters.Set(CameraKeys.FocusDistance, camera.FocusDistance);
        }

        /// <summary>
        /// Clears the current render target (which must be the G-buffer).
        /// </summary>
        /// <param name="context">The render context.</param>
        public void Render(RenderContext context)
        {
            if (context == null)
            throw new ArgumentNullException("context");

              context.Validate(_effect);

              var graphicsDevice = _effect.GraphicsDevice;
              var savedRenderState = new RenderStateSnapshot(graphicsDevice);
              graphicsDevice.DepthStencilState = DepthStencilState.None;
              graphicsDevice.RasterizerState = RasterizerState.CullNone;
              graphicsDevice.BlendState = BlendState.Opaque;

              // Clear to maximum depth.
              _parameterDepth.SetValue(1.0f);

              // The environment is facing the camera.
              // --> Set normal = cameraBackward.
              var cameraNode = context.CameraNode;
              _parameterNormal.SetValue((cameraNode != null) ? (Vector3)cameraNode.ViewInverse.GetColumn(2).XYZ : Vector3.Backward);

              // Clear specular to arbitrary value.
              _parameterSpecularPower.SetValue(1.0f);

              _effect.CurrentTechnique.Passes[0].Apply();

              // Draw full-screen quad using clip space coordinates.
              graphicsDevice.DrawQuad(
            new VertexPositionTexture(new Vector3(-1, 1, 0), new Vector2(0, 0)),
            new VertexPositionTexture(new Vector3(1, -1, 0), new Vector2(1, 1)));

              savedRenderState.Restore();
        }

 public override bool Render(RenderContext dest)
 {
     dest.Append("with(");
     Expression.Render(dest);
     dest.Append(")");
     return Code.RenderIndented(dest);
 }

        public override void Render(RenderContext context)
        {
            if (renderHost.RenderTechnique == renderHost.RenderTechniquesManager.RenderTechniques.Get(DeferredRenderTechniqueNames.Deferred) ||
                renderHost.RenderTechnique == renderHost.RenderTechniquesManager.RenderTechniques.Get(DeferredRenderTechniqueNames.GBuffer))
            {
                return;
            }

            if (this.IsRendering)
            {
                /// --- turn-on the light
                lightColors[lightIndex] = this.Color;
            }
            else
            {
                // --- turn-off the light
                lightColors[lightIndex] = new global::SharpDX.Color4(0, 0, 0, 0);
            }

            /// --- Set lighting parameters
            lightPositions[lightIndex] = this.Position.ToVector4();
            lightAtt[lightIndex] = new Vector4((float)this.Attenuation.X, (float)this.Attenuation.Y, (float)this.Attenuation.Z, (float)this.Range);

            /// --- Update lighting variables
            this.vLightPos.Set(lightPositions);
            this.vLightColor.Set(lightColors);
            this.vLightAtt.Set(lightAtt);
            this.iLightType.Set(lightTypes);
        }

 protected override void PrepareCore(RenderContext context, RenderItemCollection opaqueList, RenderItemCollection transparentList)
 {
     if (lightComponentForwardRenderer != null)
     {
         lightComponentForwardRenderer.Draw(context);
     }
 }

        protected override void DrawCore(RenderContext context)
        {
            var input = GetSafeInput(0);

            // TODO: Check that input is power of two
            // input.Size.Width 

            Texture fromTexture = input;
            Texture downTexture = null;
            var nextSize = input.Size;
            bool isFirstPass = true;
            while (nextSize.Width > 3 && nextSize.Height > 3)
            {
                var previousSize = nextSize;
                nextSize = nextSize.Down2();

                // If the next half size of the texture is not an exact *2, make it 1 pixel larger to avoid loosing pixels min/max.
                if ((nextSize.Width * 2) < previousSize.Width)
                {
                    nextSize.Width += 1;
                }
                if ((nextSize.Height * 2) < previousSize.Height)
                {
                    nextSize.Height += 1;
                }

                downTexture = NewScopedRenderTarget2D(nextSize.Width, nextSize.Height, PixelFormat.R32G32_Float, 1);

                effect.Parameters.Set(DepthMinMaxShaderKeys.TextureMap, fromTexture);
                effect.Parameters.Set(DepthMinMaxShaderKeys.TextureReduction, fromTexture);

                effect.SetOutput(downTexture);
                effect.Parameters.Set(IsFirstPassKey, isFirstPass);
                effect.Draw(context);

                fromTexture = downTexture;

                isFirstPass = false;
            }

            readback.SetInput(downTexture);
            readback.Draw();
            IsResultAvailable = readback.IsResultAvailable;
            if (IsResultAvailable)
            {
                float min = float.MaxValue;
                float max = -float.MaxValue;
                var results = readback.Result;
                foreach (var result in results)
                {
                    min = Math.Min(result.X, min);
                    if (result.Y != 1.0f)
                    {
                        max = Math.Max(result.Y, max);
                    }
                }

                Result = new Vector2(min, max);
            }
        }

        public override void Update(RenderContext renderContext)
        {
            if (CanDrop) return;

            if (_isFalling)
            {
                var deltaTime = (float)renderContext.GameTime.ElapsedGameTime.TotalSeconds;
                _currentSpeed += Gravity * deltaTime;

                var rockPos = _rockSprite.LocalPosition;
                rockPos.Y += _currentSpeed * deltaTime;
                _rockSprite.Translate(rockPos);

                if (rockPos.Y >= 390)
                {
                    _isFalling = false;
                    _rockSprite.CanDraw = false;

                    _explosionSprite.CanDraw = true;
                    _explosionSprite.Translate(rockPos);
                    _explosionSprite.PlayAnimation();
                }
            }
            else
            {
                if (!_explosionSprite.IsPlaying)
                {
                    _explosionSprite.CanDraw = false;
                    CanDrop = true;
                }
            }

            base.Update(renderContext);
        }

        public override Color shade(RenderContext rc, Ray ray, HitRecord hrec, int depth)
        {
            Point hp = ray.pointOn(hrec.getT());
              Vector normal = hrec.getPrimitive().normal(hp);

              hp += 0.0001f * normal;

              Scene scene = rc.getScene();
              int numlights = scene.numberOfLights();
              Color finalc = new Color(0,0,0);
              for ( int i = 0; i < numlights; i++ ) {

              Vector ldir = new Vector();
             Color lcolor = new Color();
             float ldist = scene.getLight(i).getLight(ref lcolor, ref ldir, rc, hp);

             HitRecord shadowhr = new HitRecord();
             Ray shadowray = new Ray(hp, ldir);
             scene.getObject().intersect(ref shadowhr, rc, shadowray);
             if ( shadowhr.getT() >= ldist || shadowhr.getT() < 0.01 ) {

                float dp = Vector.dot(normal, ldir);
                if( dp > 0 ) {
                   finalc += dp*lcolor;
                }

             }
              }

              return color * ( finalc * kd + scene.getAmbient() * ka );
        }

        protected override void OnProcess(RenderContext context)
        {
            var graphicsDevice = GraphicsService.GraphicsDevice;

              // Set sampler state. (Floating-point textures cannot use linear filtering. (XNA would throw an exception.))
              if (TextureHelper.IsFloatingPointFormat(context.SourceTexture.Format))
            graphicsDevice.SamplerStates[0] = SamplerState.PointClamp;
              else
            graphicsDevice.SamplerStates[0] = SamplerState.LinearClamp;

              // Set the render target - but only if no kind of alpha blending is currently set.
              // If alpha-blending is set, then we have to assume that the render target is already
              // set - everything else does not make sense.
              if (graphicsDevice.BlendState.ColorDestinationBlend == Blend.Zero
              && graphicsDevice.BlendState.AlphaDestinationBlend == Blend.Zero)
              {
            graphicsDevice.SetRenderTarget(context.RenderTarget);
            graphicsDevice.Viewport = context.Viewport;
              }

              _viewportSizeParameter.SetValue(new Vector2(graphicsDevice.Viewport.Width, graphicsDevice.Viewport.Height));
              _sourceTextureParameter.SetValue(context.SourceTexture);
              _effect.CurrentTechnique.Passes[0].Apply();
              graphicsDevice.DrawFullScreenQuad();

              _sourceTextureParameter.SetValue((Texture2D)null);
        }

        protected override void DrawCore(RenderContext context, RenderFrame output)
        {
            var input = Input.GetSafeRenderFrame(context);

            // If RenderFrame input or output are null, we can't do anything
            if (input == null)
            {
                return;
            }

            // If an effect is set, we are using it
            if (Effect != null)
            {
                Effect.SetInput(0, input);
                if (input.DepthStencil != null)
                {
                    Effect.SetInput(1, input.DepthStencil);
                }
                Effect.SetOutput(output);
                Effect.Draw(context);
            }
            else if (input != output)
            {
                // Else only use a scaler if input and output don't match
                // TODO: Is this something we want by default or we just don't output anything?
                var effect = context.GetSharedEffect<ImageScaler>();
                effect.SetInput(0, input);
                effect.SetOutput(output);
                effect.Draw(context);
            }
        }

 protected override void PreDrawCore(RenderContext context)
 {
     base.PreDrawCore(context);
     Parameters.Set(FactorCount, InputCount);
     Parameters.Set(ColorCombinerShaderKeys.Factors, factors);
     Parameters.Set(ColorCombinerShaderKeys.ModulateRGB, ModulateRGB);
 }