public SimpleCamera(BaseGame game) : base(game) { }
/// <summary> /// Render /// </summary> /// <param name="setMat">Set matrix</param> /// <param name="techniqueName">Technique name</param> /// <param name="renderDelegate">Render delegate</param> public void RenderCave(Material setMat, //auto: List<Vector3> setLightPositions, BaseGame.RenderDelegate renderDelegate) { // And set all the other parameters detailGroundDiffuseTexture.SetValue(groundDiffuseTexture.XnaTexture); detailGroundNormalTexture.SetValue(groundNormalTexture.XnaTexture); detailGroundHeightTexture.SetValue(groundHeightTexture.XnaTexture); detailWallDiffuseTexture.SetValue(wallDiffuseTexture.XnaTexture); detailWallNormalTexture.SetValue(wallNormalTexture.XnaTexture); detailWallHeightTexture.SetValue(wallHeightTexture.XnaTexture); // Set all the basic parameters. SetParameters(setMat); // Set all light positions that are close to us. if (LightManager.closestLightsForRendering.Count != 6) throw new InvalidOperationException( "You must always set exactly " + LightManager.NumberOfLights + " lights for the shader!"); lightPositions.SetValue(LightManager.closestLightsForRendering.ToArray()); // Start effect (current technique should be set) xnaEffect.Begin(SaveStateMode.None); // Start first pass xnaEffect.CurrentTechnique.Passes[0].Begin(); // Render renderDelegate(); // End pass and shader xnaEffect.CurrentTechnique.Passes[0].End(); xnaEffect.End(); }
/// <summary> /// Render single pass shader, little faster and simpler than /// Render and it just uses the current technique and renderes only /// the first pass (most shaders have only 1 pass anyway). /// Used for MeshRenderManager! /// </summary> /// <param name="renderDelegate">Render delegate</param> public void RenderSinglePassShader( BaseGame.RenderDelegate renderDelegate) { // Start effect (current technique should be set) xnaEffect.Begin(SaveStateMode.None); // Start first pass currentPass = 0; xnaEffect.CurrentTechnique.Passes[currentPass].Begin(); // Render. // NOTE: This delegate might change the pass, e.g. used // when rendering complex shadow mapping shaders! renderDelegate(); // End pass and shader xnaEffect.CurrentTechnique.Passes[currentPass].End(); xnaEffect.End(); }
/// <summary> /// Render shadows /// </summary> /// <param name="renderCode">Render code</param> public void RenderShadows(BaseGame.RenderDelegate renderCode) { // Render into our scene map texture sceneMapTexture.SetRenderTarget(); //*TODO DepthStencilBuffer remBackBufferSurface = null; if (sceneMapTexture.ZBufferSurface != null) { remBackBufferSurface = BaseGame.Device.DepthStencilBuffer; BaseGame.Device.DepthStencilBuffer = sceneMapTexture.ZBufferSurface; } // if (sceneMapTexture.ZBufferSurface) //*/ // Clear render target sceneMapTexture.Clear(Color.White); // Render everything renderCode(); // Resolve render target sceneMapTexture.Resolve(); // Restore back buffer as render target BaseGame.ResetRenderTarget(false); //*TODO if (sceneMapTexture.ZBufferSurface != null) BaseGame.Device.DepthStencilBuffer = remBackBufferSurface; //*/ }
/// <summary> /// Render /// </summary> /// <param name="techniqueName">Technique name</param> /// <param name="renderDelegate">Render delegate</param> public void RenderNoLight(string techniqueName, BaseGame.RenderDelegate renderDelegate) { RenderNoLight(null, techniqueName, renderDelegate); }
/// <summary> /// Render single pass shader, little faster and simpler than /// Render and it just uses the current technique and renderes only /// the first pass (most shaders have only 1 pass anyway). /// Used for MeshRenderManager! /// </summary> /// <param name="renderDelegate">Render delegate</param> public void RenderSinglePassShader( Material setMat, //always use the LightManager! List<Vector3> setLightPositions, BaseGame.RenderDelegate renderDelegate) { SetParameters(setMat); // Set all light positions that are close to us. //NOTE: We are only using 6 lights for the cave itself, all the // static and animated models are just using 3 lights (faster). if (LightManager.closestLightsForRendering.Count < 3) throw new InvalidOperationException( "You must always have at least 3 lights for the shader!"); if (lightPositions != null) lightPositions.SetValue( LightManager.closestLightsForRendering.GetRange(0, 3).ToArray()); // Start effect (current technique should be set) xnaEffect.Begin(SaveStateMode.None); // Start first pass xnaEffect.CurrentTechnique.Passes[0].Begin(); // Render renderDelegate(); // End pass and shader xnaEffect.CurrentTechnique.Passes[0].End(); xnaEffect.End(); }
public RotationCamera(BaseGame game) : base(game) { }
/// <summary> /// Render /// </summary> /// <param name="setMat">Set matrix</param> /// <param name="techniqueName">Technique name</param> /// <param name="renderDelegate">Render delegate</param> public void RenderNoLight(Material setMat, string techniqueName, BaseGame.RenderDelegate renderDelegate) { SetParameters(setMat); /*will become important later in the book. // Can we do the requested technique?0 // For graphic cards not supporting ps2.0, fall back to ps1.1 if (BaseGame.CanUsePS20 == false && techniqueName.EndsWith("20")) // Use same technique without the 20 ending! techniqueName = techniqueName.Substring(0, techniqueName.Length - 2); */ // Start shader xnaEffect.CurrentTechnique = xnaEffect.Techniques[techniqueName]; xnaEffect.Begin(SaveStateMode.None); // Render all passes (usually just one) //foreach (EffectPass pass in effect.CurrentTechnique.Passes) for (int num = 0; num < xnaEffect.CurrentTechnique.Passes.Count; num++) { EffectPass pass = xnaEffect.CurrentTechnique.Passes[num]; pass.Begin(); renderDelegate(); pass.End(); } // foreach (pass) // End shader xnaEffect.End(); }
public ScreenshotCapturer(BaseGame setGame) : base(setGame) { game = setGame; screenshotNum = GetCurrentScreenshotNum(); }
/// <summary> /// Generate shadow /// </summary> internal void GenerateShadows(BaseGame.RenderDelegate renderObjects) { // Can't generate shadow if loading failed! if (xnaEffect == null) return; // This method sets all required shader variables. this.SetParameters(); Matrix remViewMatrix = BaseGame.ViewMatrix; Matrix remProjMatrix = BaseGame.ProjectionMatrix; CalcSimpleDirectionalShadowMappingMatrix(); DepthStencilBuffer remBackBufferSurface = null; // Time to generate the shadow texture try { // Start rendering onto the shadow map shadowMapTexture.SetRenderTarget(); if (shadowMapTexture.ZBufferSurface != null) { remBackBufferSurface = BaseGame.Device.DepthStencilBuffer; BaseGame.Device.DepthStencilBuffer = shadowMapTexture.ZBufferSurface; } // if (shadowMapTexture.ZBufferSurface) // Make sure depth buffer is on BaseGame.Device.RenderState.DepthBufferEnable = true; // Disable alpha BaseGame.Device.RenderState.AlphaBlendEnable = false; // Clear render target shadowMapTexture.Clear(Color.White); //tst: //ShaderEffect.normalMapping.RenderSinglePassShader(renderObjects); //if (BaseGame.CanUsePS20) xnaEffect.CurrentTechnique = xnaEffect.Techniques["GenerateShadowMap20"]; //not supported for skinning: else // xnaEffect.CurrentTechnique = xnaEffect.Techniques["GenerateShadowMap"]; // Render shadows with help of the GenerateShadowMap shader RenderSinglePassShader(renderObjects); /* xnaEffect.Begin(SaveStateMode.None); foreach (EffectPass pass in xnaEffect.CurrentTechnique.Passes) { pass.Begin(); renderObjects(); pass.End(); } // foreach (pass) */ } // try finally { //xnaEffect.End(); // Resolve the render target to get the texture (required for Xbox) shadowMapTexture.Resolve(); // Set render target back to default BaseGame.ResetRenderTarget(false); if (shadowMapTexture.ZBufferSurface != null) BaseGame.Device.DepthStencilBuffer = remBackBufferSurface; /* #if DEBUG //tst: show light shadow view pos if (Input.Keyboard.IsKeyDown(Keys.Tab) == false) #endif { */ BaseGame.ProjectionMatrix = remProjMatrix; BaseGame.ViewMatrix = remViewMatrix; //} // if } // finally }
/// <summary> /// Calc shadows with help of generated light depth map, /// all objects have to be rendered again for comparing. /// We could save a pass when directly rendering here, but this /// has 2 disadvantages: 1. we can't post screen blur the shadow /// and 2. we can't use any other shader, especially bump and specular /// mapping shaders don't have any instructions left with ps_1_1. /// This way everything is kept simple, we can do as complex shaders /// as we want, the shadow shaders work seperately. /// </summary> /// <param name="renderObjects">Render objects</param> public void RenderShadows(BaseGame.RenderDelegate renderObjects) { // Can't calc shadows if loading failed! if (xnaEffect == null) return; // Make sure z buffer and writing z buffer is on BaseGame.Device.RenderState.DepthBufferEnable = true; BaseGame.Device.RenderState.DepthBufferWriteEnable = true; // Render shadows into our shadowMapBlur render target shadowMapBlur.RenderShadows( delegate { //if (BaseGame.CanUsePS20) xnaEffect.CurrentTechnique = xnaEffect.Techniques["UseShadowMap20"]; //unsupported for skinning: else // xnaEffect.CurrentTechnique = xnaEffect.Techniques["UseShadowMap"]; // This method sets all required shader variables. this.SetParameters(); // Use the shadow map texture here which was generated in // GenerateShadows(). shadowMap.SetValue(shadowMapTexture.XnaTexture); //ShaderEffect.normalMapping.RenderSinglePassShader(renderObjects); // Render shadows with help of the UseShadowMap shader RenderSinglePassShader(renderObjects); /*not required // Make sure warping is on, stupid xna bug again BaseGame.Device.SamplerStates[0].AddressU = TextureAddressMode.Wrap; BaseGame.Device.SamplerStates[0].AddressV = TextureAddressMode.Wrap; BaseGame.Device.SamplerStates[1].AddressU = TextureAddressMode.Wrap; BaseGame.Device.SamplerStates[1].AddressV = TextureAddressMode.Wrap; */ /* // Render everything into the current render target (set before // or just use the screen). try { xnaEffect.Begin(SaveStateMode.None); foreach (EffectPass pass in xnaEffect.CurrentTechnique.Passes) { pass.Begin(); renderObjects(); pass.End(); } // foreach (pass) } // try finally { xnaEffect.End(); } // finally */ }); // Start rendering the shadow map blur (pass 1, which messes up our // background), pass 2 can be done below without any render targets. shadowMapBlur.ShowShadowsPart1(); // Kill background z buffer DungeonQuestGame.Device.Clear( ClearOptions.DepthBuffer, //also kill color! //doesn't help: ClearOptions.DepthBuffer | ClearOptions.Target, BaseGame.BackgroundColor, 1, 0); }
public ThirdPersonCamera(BaseGame game) : base(game) { // Assign keys. Warning: This is VERY slow, never use it // inside any render loop (getting Settings, etc.)! //Note: Not true anymore for the new GameSettings class, it is faster! moveLeftKey = GameSettings.Default.MoveLeftKey; moveRightKey = GameSettings.Default.MoveRightKey; moveUpKey = GameSettings.Default.MoveForwardKey; moveDownKey = GameSettings.Default.MoveBackwardKey; }
/// <summary> /// Create base camera /// </summary> /// <param name="game">Game</param> public BaseCamera(BaseGame game) : base(game) { }