public TextureSamplerSettings(TextureWrapping wrapU, TextureWrapping wrapV, TextureWrapping wrapW, TextureFiltering filter)
{
WrapU = wrapU;
WrapV = wrapV;
WrapW = wrapW;
Filter = filter;
}
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;
}
