public TextureSamplerSettings(TextureWrapping wrapU, TextureWrapping wrapV, TextureWrapping wrapW, TextureFiltering filter) { WrapU = wrapU; WrapV = wrapV; WrapW = wrapW; Filter = filter; }
/// <summary> /// Enables the adecuate texture filtering /// </summary> static void EnableFiltering(TextureFiltering texFilt, TexureSize texSize) { Gl.glTexEnvf(Gl.GL_TEXTURE_ENV, Gl.GL_TEXTURE_ENV_MODE, Gl.GL_MODULATE); if (texSize == TexureSize.NPOT) { switch (texFilt) { case TextureFiltering.Linear: Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_NEAREST_MIPMAP_NEAREST); Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR); break; case TextureFiltering.Bilinear: Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR_MIPMAP_NEAREST); Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR); break; case TextureFiltering.Trilinear: Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR_MIPMAP_LINEAR); Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR); break; case TextureFiltering.Anisotropy: Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAX_ANISOTROPY_EXT, maximumAnisotropy); break; default: break; } } else { switch (texFilt) { case TextureFiltering.Linear: Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_NEAREST); Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_NEAREST); break; case TextureFiltering.Bilinear: Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_NEAREST); Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR); break; case TextureFiltering.Trilinear: Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MIN_FILTER, Gl.GL_LINEAR); Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAG_FILTER, Gl.GL_LINEAR); break; case TextureFiltering.Anisotropy: Gl.glTexParameterf(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAX_ANISOTROPY_EXT, maximumAnisotropy); break; default: break; } } }
public void SetFiltering(TextureFiltering filtering) { if (currentFiltering == filtering) { return; } BindTo(4); SetTargetFiltering(GL.GL_TEXTURE_CUBE_MAP, filtering); }
protected void SetTargetFiltering(int target, TextureFiltering filtering) { currentFiltering = filtering; if (LevelCount > 1) { if (GLExtensions.Anisotropy && currentFiltering != TextureFiltering.Anisotropic) { GL.TexParameterf(target, GL.GL_TEXTURE_MAX_ANISOTROPY_EXT, 1); } switch (filtering) { case TextureFiltering.Anisotropic: GL.TexParameteri(target, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR_MIPMAP_LINEAR); GL.TexParameteri(target, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR); if (GLExtensions.Anisotropy) { GL.TexParameterf(target, GL.GL_TEXTURE_MAX_ANISOTROPY_EXT, RenderContext.Instance.AnisotropyLevel); } break; case TextureFiltering.Trilinear: GL.TexParameteri(target, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR_MIPMAP_LINEAR); GL.TexParameteri(target, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR); break; case TextureFiltering.Bilinear: GL.TexParameteri(target, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR_MIPMAP_NEAREST); GL.TexParameteri(target, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR); break; case TextureFiltering.Linear: GL.TexParameteri(target, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR); GL.TexParameteri(target, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR); break; case TextureFiltering.Nearest: GL.TexParameteri(target, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST); GL.TexParameteri(target, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST); break; } } else { switch (filtering) { case TextureFiltering.Nearest: GL.TexParameteri(target, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST); GL.TexParameteri(target, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST); break; default: GL.TexParameteri(target, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR); GL.TexParameteri(target, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR); break; } } }
public void SetFiltering(TextureFiltering filtering) { if (currentFiltering == filtering) { return; } currentFiltering = filtering; BindTo(4); if (LevelCount > 1) { switch (filtering) { case TextureFiltering.Trilinear: GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR_MIPMAP_LINEAR); GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR); break; case TextureFiltering.Bilinear: GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR_MIPMAP_NEAREST); GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR); break; case TextureFiltering.Linear: GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR); GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR); break; case TextureFiltering.Nearest: GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST); GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST); break; } } else { switch (filtering) { case TextureFiltering.Nearest: GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST); GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST); break; default: GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR); GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR); break; } } }
private Filter GetFilterType(TextureFiltering filter) { switch(filter) { case TextureFiltering.MinMagMipPoint: return Filter.MinMagMipPoint; case TextureFiltering.MinMagPointMipLinear: return Filter.MinMagPointMipLinear; case TextureFiltering.MinPointMagLinearMipPoint: return Filter.MinPointMagLinearMipPoint; case TextureFiltering.MinPointMagMipLinear: return Filter.MinPointMagMipLinear; case TextureFiltering.MinLinearMagMipPoint: return Filter.MinLinearMagMipPoint; case TextureFiltering.MinLinearMagPointMipLinear: return Filter.MinLinearMagPointMipLinear; case TextureFiltering.MinMagLinearMipPoint: return Filter.MinMagLinearMipPoint; case TextureFiltering.MinMagMipLinear: return Filter.MinMagMipLinear; case TextureFiltering.Anisotropic: return Filter.Anisotropic; case TextureFiltering.ComparisonMinMagMipPoint: return Filter.ComparisonMinMagMipPoint; case TextureFiltering.ComparisonMinMagPointMipLinear: return Filter.ComparisonMinMagPointMipLinear; case TextureFiltering.ComparisonMinPointMagLinearMipPoint: return Filter.ComparisonMinPointMagLinearMipPoint; case TextureFiltering.ComparisonMinPointMagMipLinear: return Filter.ComparisonMinPointMagMipLinear; case TextureFiltering.ComparisonMinLinearMagMipPoint: return Filter.ComparisonMinLinearMagMipPoint; case TextureFiltering.ComparisonMinLinearMagPointMipLinear: return Filter.ComparisonMinLinearMagPointMipLinear; case TextureFiltering.ComparisonMinMagLinearMipPoint: return Filter.ComparisonMinMagLinearMipPoint; case TextureFiltering.ComparisonMinMagMipLinear: return Filter.ComparisonMinMagMipLinear; case TextureFiltering.ComparisonAnisotropic: return Filter.ComparisonAnisotropic; case TextureFiltering.MinimumMinMagMipPoint: return Filter.MinimumMinMagMipPoint; case TextureFiltering.MinimumMinMagPointMipLinear: return Filter.MinimumMinMagPointMipLinear; case TextureFiltering.MinimumMinPointMagLinearMipPoint: return Filter.MinimumMinPointMagLinearMipPoint; case TextureFiltering.MinimumMinPointMagMipLinear: return Filter.MinimumMinPointMagMipLinear; case TextureFiltering.MinimumMinLinearMagMipPoint: return Filter.MinimumMinLinearMagMipPoint; case TextureFiltering.MinimumMinLinearMagPointMipLinear: return Filter.MinimumMinLinearMagPointMipLinear; case TextureFiltering.MinimumMinMagLinearMipPoint: return Filter.MinimumMinMagLinearMipPoint; case TextureFiltering.MinimumMinMagMipLinear: return Filter.MinimumMinMagMipLinear; case TextureFiltering.MinimumAnisotropic: return Filter.MinimumAnisotropic; case TextureFiltering.MaximumMinMagMipPoint: return Filter.MaximumMinMagMipPoint; case TextureFiltering.MaximumMinMagPointMipLinear: return Filter.MaximumMinMagPointMipLinear; case TextureFiltering.MaximumMinPointMagLinearMipPoint: return Filter.MaximumMinPointMagLinearMipPoint; case TextureFiltering.MaximumMinPointMagMipLinear: return Filter.MaximumMinPointMagMipLinear; case TextureFiltering.MaximumMinLinearMagMipPoint: return Filter.MaximumMinLinearMagMipPoint; case TextureFiltering.MaximumMinLinearMagPointMipLinear: return Filter.MaximumMinLinearMagPointMipLinear; case TextureFiltering.MaximumMinMagLinearMipPoint: return Filter.MaximumMinMagLinearMipPoint; case TextureFiltering.MaximumMinMagMipLinear: return Filter.MaximumMinMagMipLinear; case TextureFiltering.MaximumAnisotropic: return Filter.MaximumAnisotropic; default: throw new NotSupportedException(); } }
public void Begin(Matrix3x2?transform, TextureFiltering textureFiltering) { // Save old state _oldDepthState = _device.DepthState; _oldFaceCullingEnabled = _device.FaceCullingEnabled; _oldBlendState = _device.BlendState; _oldScissorEnabled = _device.ScissorTestEnabled; // Set new state _device.DepthState = DepthState.None; _device.FaceCullingEnabled = false; _device.BlendState = BlendState.AlphaBlend; _device.ScissorTestEnabled = true; _batch.Begin(); _beginCalled = true; _transform = transform; _filtering = textureFiltering; }
/// <overload> /// <summary> /// Sets the default texture filtering to be used for loaded textures, for when textures are /// loaded automatically (e.g. by Material class) or when 'load' is called with the default /// parameters by the application. /// </summary> /// </overload> /// <param name="filtering"></param> public virtual void SetDefaultTextureFiltering(TextureFiltering filtering) { this._filtering = filtering; switch (filtering) { case TextureFiltering.None: SetDefaultTextureFiltering(FilterOptions.Point, FilterOptions.Point, FilterOptions.None); break; case TextureFiltering.Bilinear: SetDefaultTextureFiltering(FilterOptions.Linear, FilterOptions.Linear, FilterOptions.Point); break; case TextureFiltering.Trilinear: SetDefaultTextureFiltering(FilterOptions.Linear, FilterOptions.Linear, FilterOptions.Linear); break; case TextureFiltering.Anisotropic: SetDefaultTextureFiltering(FilterOptions.Anisotropic, FilterOptions.Anisotropic, FilterOptions.Linear); break; } }
/// <exception cref="InvalidEnumArgumentException">texFilter</exception> private void SetTextureFiltering(uint index, TextureFiltering texFilter) { switch (texFilter) { case TextureFiltering.None: this.renderSystem._setTextureUnitFiltering(index, FilterOptions.FO_NONE, FilterOptions.FO_NONE, FilterOptions.FO_NONE); break; case TextureFiltering.Linear: this.renderSystem._setTextureUnitFiltering(index, FilterOptions.FO_LINEAR, FilterOptions.FO_LINEAR, FilterOptions.FO_NONE); break; case TextureFiltering.Point: this.renderSystem._setTextureUnitFiltering(index, FilterOptions.FO_POINT, FilterOptions.FO_POINT, FilterOptions.FO_NONE); break; case TextureFiltering.Anisotropic: this.renderSystem._setTextureUnitFiltering(index, FilterOptions.FO_ANISOTROPIC, FilterOptions.FO_ANISOTROPIC, FilterOptions.FO_NONE); break; default: throw new InvalidEnumArgumentException("texFilter", (int)texFilter, typeof(TextureFiltering)); } }
protected void UpdateInput(Object source, FrameEventArgs e) { Input.Capture(); float scaleMove = 200 * e.TimeSinceLastFrame; // reset acceleration zero camAccel = Vector3.Zero; // set the scaling of camera motion cameraScale = 100 * e.TimeSinceLastFrame; float speed = 350 * e.TimeSinceLastFrame; float change = 15 * e.TimeSinceLastFrame; if (Input.IsKeyPressed(KeyCodes.Escape)) { Root.Instance.QueueEndRendering(); //return false; } if (Input.IsKeyPressed(KeyCodes.A)) { camAccel.x = -0.5f; } if (Input.IsKeyPressed(KeyCodes.D)) { camAccel.x = 0.5f; } if (Input.IsKeyPressed(KeyCodes.W)) { camAccel.z = -1.0f; } if (Input.IsKeyPressed(KeyCodes.S)) { camAccel.z = 1.0f; } //camAccel.y += (float)( input.RelativeMouseZ * 0.1f ); // knock out the mouse stuff here isUsingKbCameraLook = false; if (Input.IsKeyPressed(KeyCodes.Left)) { frustumNode.Yaw(cameraScale, TransformSpace.Parent); //Camera.Yaw(cameraScale); isUsingKbCameraLook = true; } if (Input.IsKeyPressed(KeyCodes.Right)) { frustumNode.Yaw(-cameraScale, TransformSpace.Parent); //Camera.Yaw(-cameraScale); isUsingKbCameraLook = true; } if (Input.IsKeyPressed(KeyCodes.Up)) { frustumNode.Pitch(cameraScale); //Camera.Pitch(cameraScale); isUsingKbCameraLook = true; } if (Input.IsKeyPressed(KeyCodes.Down)) { frustumNode.Pitch(-cameraScale); //Camera.Pitch(-cameraScale); isUsingKbCameraLook = true; } // Mouse camera movement. if (!isUsingKbCameraLook) { mouseRotateVector = Vector3.Zero; mouseRotateVector.x += Input.RelativeMouseX * 0.13f; mouseRotateVector.y += Input.RelativeMouseY * 0.13f; frustumNode.Yaw(-mouseRotateVector.x, TransformSpace.Parent); frustumNode.Pitch(-mouseRotateVector.y); //Camera.Yaw(-mouseRotateVector.x); //Camera.Pitch(-mouseRotateVector.y); } isUsingKbCameraLook = false; // subtract the time since last frame to delay specific key presses toggleDelay -= e.TimeSinceLastFrame; // toggle rendering mode if (Input.IsKeyPressed(KeyCodes.R) && toggleDelay < 0) { if (Camera.PolygonMode == PolygonMode.Points) { Camera.PolygonMode = PolygonMode.Solid; } else if (Camera.PolygonMode == PolygonMode.Solid) { Camera.PolygonMode = PolygonMode.Wireframe; } else { Camera.PolygonMode = PolygonMode.Points; } Console.WriteLine("Rendering mode changed to '{0}'.", Camera.PolygonMode); toggleDelay = 1; } if (Input.IsKeyPressed(KeyCodes.T) && toggleDelay < 0) { // toggle the texture settings switch (filtering) { case TextureFiltering.Bilinear: filtering = TextureFiltering.Trilinear; aniso = 1; break; case TextureFiltering.Trilinear: filtering = TextureFiltering.Anisotropic; aniso = 8; break; case TextureFiltering.Anisotropic: filtering = TextureFiltering.Bilinear; aniso = 1; break; } Console.WriteLine("Texture Filtering changed to '{0}'.", filtering); // set the new default MaterialManager.Instance.SetDefaultTextureFiltering(filtering); MaterialManager.Instance.DefaultAnisotropy = aniso; toggleDelay = 1; } if (Input.IsKeyPressed(KeyCodes.P)) { string[] temp = Directory.GetFiles(Environment.CurrentDirectory, "screenshot*.jpg"); string fileName = string.Format("screenshot{0}.jpg", temp.Length + 1); TakeScreenshot(fileName); // show briefly on the screen debugText = string.Format("Wrote screenshot '{0}'.", fileName); // show for 2 seconds debugTextDelay = 2.0f; } if (Input.IsKeyPressed(KeyCodes.B)) { m_sceneManager.ShowBoundingBoxes = !m_sceneManager.ShowBoundingBoxes; } if (Input.IsKeyPressed(KeyCodes.F)) { // hide all overlays, includes ones besides the debug overlay Viewport.ShowOverlays = !Viewport.ShowOverlays; } //if ( !input.IsMousePressed( MouseButtons.Left ) ) //{ // float cameraYaw = -input.RelativeMouseX * .13f; // float cameraPitch = -input.RelativeMouseY * .13f; // camera.Yaw( cameraYaw ); // camera.Pitch( cameraPitch ); //} //else //{ // cameraVector.x += input.RelativeMouseX * 0.13f; //} camVelocity += (camAccel * scaleMove * camSpeed); // move the camera based on the accumulated movement vector //Camera.MoveRelative(camVelocity * e.TimeSinceLastFrame); // move in current body direction (not the goal direction) this.frustumNode.Translate(camVelocity * e.TimeSinceLastFrame, TransformSpace.Local); // Now dampen the Velocity - only if user is not accelerating if (camAccel == Vector3.Zero) { camVelocity *= (1 - (6 * e.TimeSinceLastFrame)); } }
protected virtual bool OnFrameStarted(Object source, FrameEventArgs e) { float scaleMove = 200 * e.TimeSinceLastFrame; // reset acceleration zero camAccel = Vector3.Zero; // set the scaling of camera motion cameraScale = 100 * e.TimeSinceLastFrame; // TODO: Move this into an event queueing mechanism that is processed every frame input.Capture(); if (input.IsKeyPressed(KeyCodes.Escape)) { Root.Instance.QueueEndRendering(); return(false); } if (input.IsKeyPressed(KeyCodes.A)) { camAccel.z = -0.5f; } if (input.IsKeyPressed(KeyCodes.D)) { camAccel.z = 0.5f; } if (input.IsKeyPressed(KeyCodes.W)) { camAccel.x = -1.0f; } if (input.IsKeyPressed(KeyCodes.S)) { camAccel.x = 1.0f; } //camAccel.y += (float)( input.RelativeMouseZ * 0.1f ); if (input.IsKeyPressed(KeyCodes.Left)) { camera.Yaw(cameraScale); } if (input.IsKeyPressed(KeyCodes.Right)) { camera.Yaw(-cameraScale); } if (input.IsKeyPressed(KeyCodes.Up)) { camera.Pitch(cameraScale); } if (input.IsKeyPressed(KeyCodes.Down)) { camera.Pitch(-cameraScale); } // subtract the time since last frame to delay specific key presses toggleDelay -= e.TimeSinceLastFrame; // toggle rendering mode if (input.IsKeyPressed(KeyCodes.R) && toggleDelay < 0) { if (camera.PolygonMode == PolygonMode.Points) { camera.PolygonMode = PolygonMode.Solid; } else if (camera.PolygonMode == PolygonMode.Solid) { camera.PolygonMode = PolygonMode.Wireframe; } else { camera.PolygonMode = PolygonMode.Points; } SetDebugText(String.Format("Rendering mode changed to '{0}'.", camera.PolygonMode)); toggleDelay = .3f; } if (input.IsKeyPressed(KeyCodes.T) && toggleDelay < 0) { // toggle the texture settings switch (filtering) { case TextureFiltering.Bilinear: filtering = TextureFiltering.Trilinear; aniso = 1; break; case TextureFiltering.Trilinear: filtering = TextureFiltering.Anisotropic; aniso = 8; break; case TextureFiltering.Anisotropic: filtering = TextureFiltering.Bilinear; aniso = 1; break; } SetDebugText(String.Format("Texture Filtering changed to '{0}'.", filtering)); // set the new default MaterialManager.Instance.SetDefaultTextureFiltering(filtering); MaterialManager.Instance.DefaultAnisotropy = aniso; toggleDelay = .3f; } if (input.IsKeyPressed(KeyCodes.P) && toggleDelay < 0) { string[] temp = Directory.GetFiles(Environment.CurrentDirectory, "screenshot*.jpg"); string fileName = string.Format("screenshot{0}.jpg", temp.Length + 1); TakeScreenshot(fileName); // show on the screen for some seconds SetDebugText(string.Format("Wrote screenshot '{0}'.", fileName)); toggleDelay = .3f; } if (input.IsKeyPressed(KeyCodes.B) && toggleDelay < 0) { scene.ShowBoundingBoxes = !scene.ShowBoundingBoxes; SetDebugText(String.Format("Bounding boxes {0}.", scene.ShowBoundingBoxes ? "visible" : "hidden")); toggleDelay = .3f; } if (input.IsKeyPressed(KeyCodes.F) && toggleDelay < 0) { // hide all overlays, includes ones besides the debug overlay viewport.ShowOverlays = !viewport.ShowOverlays; toggleDelay = .3f; } if (input.IsKeyPressed(KeyCodes.Comma) && toggleDelay < 0) { Root.Instance.MaxFramesPerSecond = 60; SetDebugText(String.Format("Limiting framerate to {0} FPS.", Root.Instance.MaxFramesPerSecond)); toggleDelay = .3f; } if (input.IsKeyPressed(KeyCodes.Period) && toggleDelay < 0) { Root.Instance.MaxFramesPerSecond = 0; SetDebugText(String.Format("Framerate limit OFF.", Root.Instance.MaxFramesPerSecond)); toggleDelay = .3f; } camVelocity += (camAccel * scaleMove * camSpeed); // move the camera based on the accumulated movement vector camera.Move(camVelocity * e.TimeSinceLastFrame); // Now dampen the Velocity - only if user is not accelerating if (camAccel == Vector3.Zero) { camVelocity *= (1 - (6 * e.TimeSinceLastFrame)); } // update performance stats once per second if (statDelay < 0.0f && showDebugOverlay) { UpdateStats(); statDelay = 1.0f; } else { statDelay -= e.TimeSinceLastFrame; } // turn off debug text when delay ends if (debugTextDelay < 0.0f) { debugTextDelay = 0.0f; debugText = ""; } else if (debugTextDelay > 0.0f) { debugTextDelay -= e.TimeSinceLastFrame; } OverlayElement element = OverlayManager.Instance.Elements.GetElement("Core/DebugText"); element.Text = debugText; return(true); }
protected virtual void OnFrameStarted(Object source, FrameEventArgs e) { onFrameStartedMeter.Enter(); float scaleMove = 200 * e.TimeSinceLastFrame; // reset acceleration zero camAccel = Vector3.Zero; // set the scaling of camera motion cameraScale = 100 * e.TimeSinceLastFrame; // TODO: Move this into an event queueing mechanism that is processed every frame input.Capture(); if (input.IsKeyPressed(KeyCodes.Escape)) { Root.Instance.QueueEndRendering(); onFrameStartedMeter.Exit(); return; } if (input.IsKeyPressed(KeyCodes.A)) { camAccel.x = -0.5f; } if (input.IsKeyPressed(KeyCodes.D)) { camAccel.x = 0.5f; } if (input.IsKeyPressed(KeyCodes.W)) { camAccel.z = -1.0f; } if (input.IsKeyPressed(KeyCodes.S)) { camAccel.z = 1.0f; } camAccel.y += (float)(input.RelativeMouseZ * 0.1f); if (input.IsKeyPressed(KeyCodes.Left)) { camera.Yaw(cameraScale); } if (input.IsKeyPressed(KeyCodes.Right)) { camera.Yaw(-cameraScale); } if (input.IsKeyPressed(KeyCodes.Up)) { camera.Pitch(cameraScale); } if (input.IsKeyPressed(KeyCodes.Down)) { camera.Pitch(-cameraScale); } // subtract the time since last frame to delay specific key presses toggleDelay -= e.TimeSinceLastFrame; // toggle rendering mode if (input.IsKeyPressed(KeyCodes.R) && toggleDelay < 0) { if (camera.SceneDetail == SceneDetailLevel.Points) { camera.SceneDetail = SceneDetailLevel.Solid; } else if (camera.SceneDetail == SceneDetailLevel.Solid) { camera.SceneDetail = SceneDetailLevel.Wireframe; } else { camera.SceneDetail = SceneDetailLevel.Points; } log.InfoFormat("Rendering mode changed to '{0}'.", camera.SceneDetail); toggleDelay = 1; } if (input.IsKeyPressed(KeyCodes.T) && toggleDelay < 0) { // toggle the texture settings switch (filtering) { case TextureFiltering.Bilinear: filtering = TextureFiltering.Trilinear; aniso = 1; break; case TextureFiltering.Trilinear: filtering = TextureFiltering.Anisotropic; aniso = 8; break; case TextureFiltering.Anisotropic: filtering = TextureFiltering.Bilinear; aniso = 1; break; } log.InfoFormat("Texture Filtering changed to '{0}'.", filtering); // set the new default MaterialManager.Instance.SetDefaultTextureFiltering(filtering); MaterialManager.Instance.DefaultAnisotropy = aniso; toggleDelay = 1; } if (input.IsKeyPressed(KeyCodes.P)) { string[] temp = Directory.GetFiles(Environment.CurrentDirectory, "screenshot*.jpg"); string fileName = string.Format("screenshot{0}.jpg", temp.Length + 1); TakeScreenshot(fileName); // show briefly on the screen window.DebugText = string.Format("Wrote screenshot '{0}'.", fileName); // show for 2 seconds debugTextDelay = 2.0f; } if (input.IsKeyPressed(KeyCodes.B)) { scene.ShowBoundingBoxes = !scene.ShowBoundingBoxes; } if (input.IsKeyPressed(KeyCodes.F)) { // hide all overlays, includes ones besides the debug overlay viewport.OverlaysEnabled = !viewport.OverlaysEnabled; } if (!input.IsMousePressed(MouseButtons.Left)) { float cameraYaw = -input.RelativeMouseX * .13f; float cameraPitch = -input.RelativeMouseY * .13f; camera.Yaw(cameraYaw); camera.Pitch(cameraPitch); } else { cameraVector.x += input.RelativeMouseX * 0.13f; } camVelocity += (camAccel * scaleMove * camSpeed); // move the camera based on the accumulated movement vector camera.MoveRelative(camVelocity * e.TimeSinceLastFrame); // Now dampen the Velocity - only if user is not accelerating if (camAccel == Vector3.Zero) { camVelocity *= (1 - (6 * e.TimeSinceLastFrame)); } // update performance stats once per second if (statDelay < 0.0f && showDebugOverlay) { UpdateStats(); statDelay = 1.0f; } else { statDelay -= e.TimeSinceLastFrame; } // turn off debug text when delay ends if (debugTextDelay < 0.0f) { debugTextDelay = 0.0f; window.DebugText = ""; } else if (debugTextDelay > 0.0f) { debugTextDelay -= e.TimeSinceLastFrame; } OverlayElement element = OverlayElementManager.Instance.GetElement("Core/DebugText"); element.Text = window.DebugText; onFrameStartedMeter.Exit(); }
public void SetFiltering(TextureFiltering filtering) { if (currentFiltering == filtering) { return; } if (GLExtensions.Anisotropy && currentFiltering == TextureFiltering.Anisotropic) { GL.TexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAX_ANISOTROPY_EXT, 1); } currentFiltering = filtering; BindTo(4); if (LevelCount > 1) { switch (filtering) { case TextureFiltering.Anisotropic: GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR_MIPMAP_LINEAR); GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR); if (GLExtensions.Anisotropy) { GL.TexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAX_ANISOTROPY_EXT, RenderState.Instance.AnisotropyLevel); } break; case TextureFiltering.Trilinear: GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR_MIPMAP_LINEAR); GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR); break; case TextureFiltering.Bilinear: GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR_MIPMAP_NEAREST); GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR); break; case TextureFiltering.Linear: GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR); GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR); break; case TextureFiltering.Nearest: GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST); GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST); break; } } else { switch (filtering) { case TextureFiltering.Nearest: GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST); GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST); break; default: GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR); GL.TexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR); break; } } }
private void SetTexture(uint index, Texture tp, TextureFiltering texFilter, float alpha) { this.renderSystem._setTexture(index, true, tp); this.SetTextureFiltering(index, texFilter); this.SetTextureAlpha(index, alpha); }
private void SetTexture(uint index, string name, TextureFiltering texFilter, float alpha) { this.SetTexture(index, (Texture)this.RenderManager.MiyagiSystem.Backend.LoadTexture(name), texFilter, alpha); }
public void LookupUV(Vector2 uv, UVAddressMode addressMode, TextureFiltering filtering, out Vector3 color) { switch (addressMode) { case UVAddressMode.Clamp: this.ClampUV(ref uv); break; case UVAddressMode.Wrap: this.WrapUV(ref uv); break; case UVAddressMode.Mirror: this.MirrorUV(ref uv); break; default: throw new ArgumentException("Value does not fall within the expected range", "addressMode"); } switch (filtering) { case TextureFiltering.Point: this.GetColorPoint(ref uv, out color); break; case TextureFiltering.Bilinear: this.GetColorBilinear(ref uv, out color); break; default: throw new ArgumentException("Value does not fall within the expected range", "filtering"); } }
/// <summary> /// Sets the default texture filtering to be used for loaded textures, for when textures are /// loaded automatically (e.g. by Material class) or when 'load' is called with the default /// parameters by the application. /// </summary> /// <param name="options">Default options to use.</param> public virtual void SetDefaultTextureFiltering(TextureFiltering filtering) { this.filtering = filtering; switch (filtering) { case TextureFiltering.None: SetDefaultTextureFiltering(FilterOptions.Point, FilterOptions.Point, FilterOptions.None); break; case TextureFiltering.Bilinear: SetDefaultTextureFiltering(FilterOptions.Linear, FilterOptions.Linear, FilterOptions.Point); break; case TextureFiltering.Trilinear: SetDefaultTextureFiltering(FilterOptions.Linear, FilterOptions.Linear, FilterOptions.Linear); break; case TextureFiltering.Anisotropic: SetDefaultTextureFiltering(FilterOptions.Anisotropic, FilterOptions.Anisotropic, FilterOptions.Linear); break; } }
/// <summary> /// Set the texture filtering for this unit, using the simplified interface. /// </summary> /// <remarks> /// You also have the option of specifying the minification, magnification /// and mip filter individually if you want more control over filtering /// options. See the SetTextureFiltering overloads for details. /// <p/> /// Note: This option applies in both the fixed function and programmable pipeline. /// </remarks> /// <param name="filter"> /// The high-level filter type to use. /// </param> public void SetTextureFiltering( TextureFiltering filter ) { switch ( filter ) { case TextureFiltering.None: SetTextureFiltering( FilterOptions.Point, FilterOptions.Point, FilterOptions.None ); break; case TextureFiltering.Bilinear: SetTextureFiltering( FilterOptions.Linear, FilterOptions.Linear, FilterOptions.Point ); break; case TextureFiltering.Trilinear: SetTextureFiltering( FilterOptions.Linear, FilterOptions.Linear, FilterOptions.Linear ); break; case TextureFiltering.Anisotropic: SetTextureFiltering( FilterOptions.Anisotropic, FilterOptions.Anisotropic, FilterOptions.Linear ); break; } // no longer set to current default this.isDefaultFiltering = false; }
private Filter GetFilterType(TextureFiltering filter) { switch (filter) { case TextureFiltering.MinMagMipPoint: return(Filter.MinMagMipPoint); case TextureFiltering.MinMagPointMipLinear: return(Filter.MinMagPointMipLinear); case TextureFiltering.MinPointMagLinearMipPoint: return(Filter.MinPointMagLinearMipPoint); case TextureFiltering.MinPointMagMipLinear: return(Filter.MinPointMagMipLinear); case TextureFiltering.MinLinearMagMipPoint: return(Filter.MinLinearMagMipPoint); case TextureFiltering.MinLinearMagPointMipLinear: return(Filter.MinLinearMagPointMipLinear); case TextureFiltering.MinMagLinearMipPoint: return(Filter.MinMagLinearMipPoint); case TextureFiltering.MinMagMipLinear: return(Filter.MinMagMipLinear); case TextureFiltering.Anisotropic: return(Filter.Anisotropic); case TextureFiltering.ComparisonMinMagMipPoint: return(Filter.ComparisonMinMagMipPoint); case TextureFiltering.ComparisonMinMagPointMipLinear: return(Filter.ComparisonMinMagPointMipLinear); case TextureFiltering.ComparisonMinPointMagLinearMipPoint: return(Filter.ComparisonMinPointMagLinearMipPoint); case TextureFiltering.ComparisonMinPointMagMipLinear: return(Filter.ComparisonMinPointMagMipLinear); case TextureFiltering.ComparisonMinLinearMagMipPoint: return(Filter.ComparisonMinLinearMagMipPoint); case TextureFiltering.ComparisonMinLinearMagPointMipLinear: return(Filter.ComparisonMinLinearMagPointMipLinear); case TextureFiltering.ComparisonMinMagLinearMipPoint: return(Filter.ComparisonMinMagLinearMipPoint); case TextureFiltering.ComparisonMinMagMipLinear: return(Filter.ComparisonMinMagMipLinear); case TextureFiltering.ComparisonAnisotropic: return(Filter.ComparisonAnisotropic); case TextureFiltering.MinimumMinMagMipPoint: return(Filter.MinimumMinMagMipPoint); case TextureFiltering.MinimumMinMagPointMipLinear: return(Filter.MinimumMinMagPointMipLinear); case TextureFiltering.MinimumMinPointMagLinearMipPoint: return(Filter.MinimumMinPointMagLinearMipPoint); case TextureFiltering.MinimumMinPointMagMipLinear: return(Filter.MinimumMinPointMagMipLinear); case TextureFiltering.MinimumMinLinearMagMipPoint: return(Filter.MinimumMinLinearMagMipPoint); case TextureFiltering.MinimumMinLinearMagPointMipLinear: return(Filter.MinimumMinLinearMagPointMipLinear); case TextureFiltering.MinimumMinMagLinearMipPoint: return(Filter.MinimumMinMagLinearMipPoint); case TextureFiltering.MinimumMinMagMipLinear: return(Filter.MinimumMinMagMipLinear); case TextureFiltering.MinimumAnisotropic: return(Filter.MinimumAnisotropic); case TextureFiltering.MaximumMinMagMipPoint: return(Filter.MaximumMinMagMipPoint); case TextureFiltering.MaximumMinMagPointMipLinear: return(Filter.MaximumMinMagPointMipLinear); case TextureFiltering.MaximumMinPointMagLinearMipPoint: return(Filter.MaximumMinPointMagLinearMipPoint); case TextureFiltering.MaximumMinPointMagMipLinear: return(Filter.MaximumMinPointMagMipLinear); case TextureFiltering.MaximumMinLinearMagMipPoint: return(Filter.MaximumMinLinearMagMipPoint); case TextureFiltering.MaximumMinLinearMagPointMipLinear: return(Filter.MaximumMinLinearMagPointMipLinear); case TextureFiltering.MaximumMinMagLinearMipPoint: return(Filter.MaximumMinMagLinearMipPoint); case TextureFiltering.MaximumMinMagMipLinear: return(Filter.MaximumMinMagMipLinear); case TextureFiltering.MaximumAnisotropic: return(Filter.MaximumAnisotropic); default: throw new NotSupportedException(); } }
protected virtual void OnFrameStarted(Object source, FrameEventArgs e) { onFrameStartedMeter.Enter(); float scaleMove = 200 * e.TimeSinceLastFrame; // reset acceleration zero camAccel = Vector3.Zero; // set the scaling of camera motion cameraScale = 100 * e.TimeSinceLastFrame; // TODO: Move this into an event queueing mechanism that is processed every frame input.Capture(); if(input.IsKeyPressed(KeyCodes.Escape)) { Root.Instance.QueueEndRendering(); onFrameStartedMeter.Exit(); return; } if(input.IsKeyPressed(KeyCodes.A)) { camAccel.x = -0.5f; } if(input.IsKeyPressed(KeyCodes.D)) { camAccel.x = 0.5f; } if(input.IsKeyPressed(KeyCodes.W)) { camAccel.z = -1.0f; } if(input.IsKeyPressed(KeyCodes.S)) { camAccel.z = 1.0f; } camAccel.y += (float)(input.RelativeMouseZ * 0.1f); if(input.IsKeyPressed(KeyCodes.Left)) { camera.Yaw(cameraScale); } if(input.IsKeyPressed(KeyCodes.Right)) { camera.Yaw(-cameraScale); } if(input.IsKeyPressed(KeyCodes.Up)) { camera.Pitch(cameraScale); } if(input.IsKeyPressed(KeyCodes.Down)) { camera.Pitch(-cameraScale); } // subtract the time since last frame to delay specific key presses toggleDelay -= e.TimeSinceLastFrame; // toggle rendering mode if(input.IsKeyPressed(KeyCodes.R) && toggleDelay < 0) { if(camera.SceneDetail == SceneDetailLevel.Points) { camera.SceneDetail = SceneDetailLevel.Solid; } else if(camera.SceneDetail == SceneDetailLevel.Solid) { camera.SceneDetail = SceneDetailLevel.Wireframe; } else { camera.SceneDetail = SceneDetailLevel.Points; } log.InfoFormat("Rendering mode changed to '{0}'.", camera.SceneDetail); toggleDelay = 1; } if(input.IsKeyPressed(KeyCodes.T) && toggleDelay < 0) { // toggle the texture settings switch(filtering) { case TextureFiltering.Bilinear: filtering = TextureFiltering.Trilinear; aniso = 1; break; case TextureFiltering.Trilinear: filtering = TextureFiltering.Anisotropic; aniso = 8; break; case TextureFiltering.Anisotropic: filtering = TextureFiltering.Bilinear; aniso = 1; break; } log.InfoFormat("Texture Filtering changed to '{0}'.", filtering); // set the new default MaterialManager.Instance.SetDefaultTextureFiltering(filtering); MaterialManager.Instance.DefaultAnisotropy = aniso; toggleDelay = 1; } if(input.IsKeyPressed(KeyCodes.P)) { string[] temp = Directory.GetFiles(Environment.CurrentDirectory, "screenshot*.jpg"); string fileName = string.Format("screenshot{0}.jpg", temp.Length + 1); TakeScreenshot(fileName); // show briefly on the screen window.DebugText = string.Format("Wrote screenshot '{0}'.", fileName); // show for 2 seconds debugTextDelay = 2.0f; } if(input.IsKeyPressed(KeyCodes.B)) { scene.ShowBoundingBoxes = !scene.ShowBoundingBoxes; } if(input.IsKeyPressed(KeyCodes.F)) { // hide all overlays, includes ones besides the debug overlay viewport.OverlaysEnabled = !viewport.OverlaysEnabled; } if(!input.IsMousePressed(MouseButtons.Left)) { float cameraYaw = -input.RelativeMouseX * .13f; float cameraPitch = -input.RelativeMouseY * .13f; camera.Yaw(cameraYaw); camera.Pitch(cameraPitch); } else { cameraVector.x += input.RelativeMouseX * 0.13f; } camVelocity += (camAccel * scaleMove * camSpeed); // move the camera based on the accumulated movement vector camera.MoveRelative(camVelocity * e.TimeSinceLastFrame); // Now dampen the Velocity - only if user is not accelerating if (camAccel == Vector3.Zero) { camVelocity *= (1 - (6 * e.TimeSinceLastFrame)); } // update performance stats once per second if(statDelay < 0.0f && showDebugOverlay) { UpdateStats(); statDelay = 1.0f; } else { statDelay -= e.TimeSinceLastFrame; } // turn off debug text when delay ends if(debugTextDelay < 0.0f) { debugTextDelay = 0.0f; window.DebugText = ""; } else if(debugTextDelay > 0.0f) { debugTextDelay -= e.TimeSinceLastFrame; } OverlayElement element = OverlayElementManager.Instance.GetElement("Core/DebugText"); element.Text = window.DebugText; onFrameStartedMeter.Exit(); }
protected virtual void OnFrameStarted( object source, FrameEventArgs evt ) { evt.StopRendering = false; float scaleMove = 200 * evt.TimeSinceLastFrame; // reset acceleration zero camAccel = Vector3.Zero; // set the scaling of camera motion cameraScale = 100 * evt.TimeSinceLastFrame; #if !( SIS ) // TODO: Move this into an event queueing mechanism that is processed every frame input.Capture(); if ( input.IsKeyPressed( KeyCodes.Escape ) ) { //Root.Instance.QueueEndRendering(); evt.StopRendering = true; return; } if ( input.IsKeyPressed( KeyCodes.A ) ) { camAccel.x = -0.5f; } if ( input.IsKeyPressed( KeyCodes.D ) ) { camAccel.x = 0.5f; } if ( input.IsKeyPressed( KeyCodes.W ) ) { camAccel.z = -1.0f; } if ( input.IsKeyPressed( KeyCodes.S ) ) { camAccel.z = 1.0f; } //camAccel.y += (float)( input.RelativeMouseZ * 0.1f ); if ( input.IsKeyPressed( KeyCodes.Left ) ) { camera.Yaw( cameraScale ); } if ( input.IsKeyPressed( KeyCodes.Right ) ) { camera.Yaw( -cameraScale ); } if ( input.IsKeyPressed( KeyCodes.Up ) ) { camera.Pitch( cameraScale ); } if ( input.IsKeyPressed( KeyCodes.Down ) ) { camera.Pitch( -cameraScale ); } // subtract the time since last frame to delay specific key presses keypressDelay -= evt.TimeSinceLastFrame; // toggle rendering mode if ( input.IsKeyPressed( KeyCodes.R ) && keypressDelay < 0 ) { if ( camera.PolygonMode == PolygonMode.Points ) { camera.PolygonMode = PolygonMode.Solid; } else if ( camera.PolygonMode == PolygonMode.Solid ) { camera.PolygonMode = PolygonMode.Wireframe; } else { //camera.PolygonMode = PolygonMode.Points; } SetDebugText( String.Format( "Rendering mode changed to '{0}'.", camera.PolygonMode ) ); keypressDelay = .3f; } if ( input.IsKeyPressed( KeyCodes.T ) && keypressDelay < 0 ) { // toggle the texture settings switch ( filtering ) { case TextureFiltering.Bilinear: filtering = TextureFiltering.Trilinear; aniso = 1; break; case TextureFiltering.Trilinear: filtering = TextureFiltering.Anisotropic; aniso = 8; break; case TextureFiltering.Anisotropic: filtering = TextureFiltering.Bilinear; aniso = 1; break; } SetDebugText( String.Format( "Texture Filtering changed to '{0}'.", filtering ) ); // set the new default MaterialManager.Instance.SetDefaultTextureFiltering( filtering ); MaterialManager.Instance.DefaultAnisotropy = aniso; keypressDelay = .3f; } #if !( XBOX || XBOX360 ) if ( input.IsKeyPressed( KeyCodes.P ) && keypressDelay < 0 ) { string[] temp = Directory.GetFiles( Environment.CurrentDirectory, "screenshot*.jpg" ); string fileName = string.Format( "screenshot{0}.jpg", temp.Length + 1 ); TakeScreenshot( fileName ); // show on the screen for some seconds SetDebugText( string.Format( "Wrote screenshot '{0}'.", fileName ) ); keypressDelay = .3f; } #endif if ( input.IsKeyPressed( KeyCodes.B ) && keypressDelay < 0 ) { scene.ShowBoundingBoxes = !scene.ShowBoundingBoxes; SetDebugText( String.Format( "Bounding boxes {0}.", scene.ShowBoundingBoxes ? "visible" : "hidden" ) ); keypressDelay = .3f; } if ( input.IsKeyPressed( KeyCodes.F ) && keypressDelay < 0 ) { // hide all overlays, includes ones besides the debug overlay viewport.ShowOverlays = !viewport.ShowOverlays; keypressDelay = .3f; } if ( input.IsKeyPressed( KeyCodes.Comma ) && keypressDelay < 0 ) { Root.Instance.MaxFramesPerSecond = 60; SetDebugText( String.Format( "Limiting framerate to {0} FPS.", Root.Instance.MaxFramesPerSecond ) ); keypressDelay = .3f; } if ( input.IsKeyPressed( KeyCodes.Period ) && keypressDelay < 0 ) { Root.Instance.MaxFramesPerSecond = 0; SetDebugText( String.Format( "Framerate limit OFF.", Root.Instance.MaxFramesPerSecond ) ); keypressDelay = .3f; } // turn off debug text when delay ends if ( debugTextDelay < 0.0f ) { debugTextDelay = 0.0f; debugText = ""; } else if ( debugTextDelay > 0.0f ) { debugTextDelay -= evt.TimeSinceLastFrame; } #if DEBUG if ( !input.IsMousePressed( MouseButtons.Left ) ) { float cameraYaw = -input.RelativeMouseX * .13f; float cameraPitch = -input.RelativeMouseY * .13f; camera.Yaw( cameraYaw ); camera.Pitch( cameraPitch ); } else { // TODO unused cameraVector.x += input.RelativeMouseX * 0.13f; } #endif #endif #if ( SIS ) // TODO: Move this into an event queueing mechanism that is processed every frame mouse.Capture(); keyboard.Capture(); if ( keyboard.IsKeyDown( SharpInputSystem.KeyCode.Key_ESCAPE ) ) { Root.Instance.QueueEndRendering(); return; } if ( keyboard.IsKeyDown( SharpInputSystem.KeyCode.Key_A ) ) { camAccel.x = -0.5f; } if ( keyboard.IsKeyDown( SharpInputSystem.KeyCode.Key_D ) ) { camAccel.x = 0.5f; } if ( keyboard.IsKeyDown( SharpInputSystem.KeyCode.Key_W ) ) { camAccel.z = -1.0f; } if ( keyboard.IsKeyDown( SharpInputSystem.KeyCode.Key_S ) ) { camAccel.z = 1.0f; } camAccel.y += (float)( mouse.MouseState.Z.Relative * 0.1f ); if ( keyboard.IsKeyDown( SharpInputSystem.KeyCode.Key_LEFT ) ) { camera.Yaw( cameraScale ); } if ( keyboard.IsKeyDown( SharpInputSystem.KeyCode.Key_RIGHT ) ) { camera.Yaw( -cameraScale ); } if ( keyboard.IsKeyDown( SharpInputSystem.KeyCode.Key_UP ) ) { camera.Pitch( cameraScale ); } if ( keyboard.IsKeyDown( SharpInputSystem.KeyCode.Key_DOWN ) ) { camera.Pitch( -cameraScale ); } // subtract the time since last frame to delay specific key presses toggleDelay -= e.TimeSinceLastFrame; // toggle rendering mode if ( keyboard.IsKeyDown( SharpInputSystem.KeyCode.Key_R ) && toggleDelay < 0 ) { if ( camera.SceneDetail == SceneDetailLevel.Points ) { camera.SceneDetail = SceneDetailLevel.Solid; } else if ( camera.SceneDetail == SceneDetailLevel.Solid ) { camera.SceneDetail = SceneDetailLevel.Wireframe; } else { camera.SceneDetail = SceneDetailLevel.Points; } Console.WriteLine( "Rendering mode changed to '{0}'.", camera.SceneDetail ); toggleDelay = 1; } if ( keyboard.IsKeyDown( SharpInputSystem.KeyCode.Key_T ) && toggleDelay < 0 ) { // toggle the texture settings switch ( filtering ) { case TextureFiltering.Bilinear: filtering = TextureFiltering.Trilinear; aniso = 1; break; case TextureFiltering.Trilinear: filtering = TextureFiltering.Anisotropic; aniso = 8; break; case TextureFiltering.Anisotropic: filtering = TextureFiltering.Bilinear; aniso = 1; break; } Console.WriteLine( "Texture Filtering changed to '{0}'.", filtering ); // set the new default MaterialManager.Instance.SetDefaultTextureFiltering( filtering ); MaterialManager.Instance.DefaultAnisotropy = aniso; toggleDelay = 1; } if ( keyboard.IsKeyDown( SharpInputSystem.KeyCode.Key_P ) ) { string[] temp = Directory.GetFiles( Environment.CurrentDirectory, "screenshot*.jpg" ); string fileName = string.Format( "screenshot{0}.jpg", temp.Length + 1 ); TakeScreenshot( fileName ); // show briefly on the screen window.DebugText = string.Format( "Wrote screenshot '{0}'.", fileName ); // show for 2 seconds debugTextDelay = 2.0f; } if ( keyboard.IsKeyDown( SharpInputSystem.KeyCode.Key_B ) ) { scene.ShowBoundingBoxes = !scene.ShowBoundingBoxes; } if ( keyboard.IsKeyDown( SharpInputSystem.KeyCode.Key_F ) ) { // hide all overlays, includes ones besides the debug overlay viewport.OverlaysEnabled = !viewport.OverlaysEnabled; } if ( !mouse.MouseState.IsButtonDown( SharpInputSystem.MouseButtonID.Left ) ) { float cameraYaw = -mouse.MouseState.X.Relative * .13f; float cameraPitch = -mouse.MouseState.Y.Relative * .13f; camera.Yaw( cameraYaw ); camera.Pitch( cameraPitch ); } else { cameraVector.x += mouse.MouseState.X.Relative * 0.13f; } #endif camVelocity += ( camAccel * scaleMove * camSpeed ); // move the camera based on the accumulated movement vector camera.MoveRelative( camVelocity * evt.TimeSinceLastFrame ); // Now dampen the Velocity - only if user is not accelerating if ( camAccel == Vector3.Zero ) { camVelocity *= ( 1 - ( 6 * evt.TimeSinceLastFrame ) ); } evt.StopRendering = false; }
public void ToggleTexture() { int aniso = 1; // toggle the texture settings switch (filtering) { case TextureFiltering.Bilinear: filtering = TextureFiltering.Trilinear; aniso = 1; break; case TextureFiltering.Trilinear: filtering = TextureFiltering.Anisotropic; aniso = 8; break; case TextureFiltering.Anisotropic: filtering = TextureFiltering.Bilinear; aniso = 1; break; } log.InfoFormat("Texture Filtering changed to '{0}'.", filtering); // set the new default MaterialManager.Instance.SetDefaultTextureFiltering(filtering); MaterialManager.Instance.DefaultAnisotropy = aniso; }