bool IRenderable.Render(Camera camera, Light light)
{
this.device.RawDevice.SetRenderState(RenderState.ZEnable, false);
this.device.RawDevice.SetRenderState(RenderState.ZWriteEnable, false);
this.device.RawDevice.SetRenderState(RenderState.AlphaBlendEnable, false);
this.device.RawDevice.VertexDeclaration = this.device.ScreenVertexDecl.RawDecl;
if (this.device.RawDevice.SetStreamSource(0, this.device.ScreenVertexBuffer.RawBuffer, 0, this.device.ScreenVertexBuffer.ElementSize).IsFailure)
return false;
this.shader.Params["m_ViewInv"].SetValue(camera.ViewMatrix.Invert());
this.shader.Params["diffuseTexture"].SetValue(SkyTexture);
this.shader.Params["ambientColor"].SetValue(AmbientColor);
this.shader.Params["scale"].SetValue(1.0f);
this.shader.Params["aspectRatio"].SetValue(camera.AspectRatio);
bool ret = this.shader.RenderTechnique((pass) =>
{
return this.device.RawDevice.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2).IsSuccess;
}, "Skybox");
this.device.RawDevice.SetRenderState(RenderState.ZEnable, true);
this.device.RawDevice.SetRenderState(RenderState.ZWriteEnable, true);
return ret;
}
public void Camera_EyePos_Test()
{
Camera camera = new Camera();
Assert.AreEqual(Vector3.Zero, camera.EyePos);
var newPos = new Vector3(1.0f, 2.0f, 3.0f);
camera.EyePos = newPos;
Assert.AreEqual(newPos, camera.EyePos);
}
public SceneManager(Device device, AssetManager assetManager)
{
this.device = device;
this.assetManager = assetManager;
// Create default camera and light.
Camera = new Camera();
Light = new Light();
}
public void Camera_AspectRatio_Test()
{
var camera = new Camera();
Assert.AreEqual(1.0f / 3, camera.AspectRatio);
var expected = 800.0f / 600.0f;
camera.AspectRatio = expected;
Assert.AreEqual(expected, camera.AspectRatio);
}
private bool RenderToRenderTarget(IRenderTarget target, IList<IRenderable> renderables, IList<ISprite> sprites, bool doPresent, Camera camera, Light light)
{
this.device.SetRenderTarget(target);
if (target.ClearBackGround)
this.device.RawDevice.Clear(target.ClearOptions, target.ClearColor.ToArgb(), 1.0f, 0);
Result result = this.device.RawDevice.BeginScene();
if (result.IsFailure)
{
Log.Msg(TraceLevel.Error, this, "BeginScene failed, " + result.ToString());
return false;
}
try
{
if (renderables != null && renderables.Count > 0)
{
foreach (var renderable in renderables)
{
renderable.Render(camera, light);
}
}
if (sprites != null && sprites.Count > 0)
{
this.spriteRenderer.RawSprite.Begin(SpriteFlags.AlphaBlend);
foreach (var sprite in sprites)
{
sprite.Render(this.spriteRenderer);
}
this.spriteRenderer.RawSprite.End();
}
}
finally
{
this.device.RawDevice.EndScene();
}
if (doPresent)
this.device.RawDevice.Present();
target.OnRender();
return true;
}
public bool Render(Material material, Light light, Camera camera, Matrix4 worldMatrix, Func<int, bool> renderDelegate)
{
Params["m_World"].SetValue(worldMatrix);
Params["m_WorldIT"].SetValue(worldMatrix.Invert().Transpose());
Params["m_WVP"].SetValue(worldMatrix * camera.ViewMatrix * camera.ProjectionMatrix);
Params["g_vLightPos"].SetValue(light.Position);
Params["m_ViewInv"].SetValue(camera.ViewMatrix.Invert());
Params["DiffuseTexture"].SetValue(material.DiffuseTexture);
Params["useNormalMap"].SetValue(material.UseNormalMap);
Params["NormalTexture"].SetValue(material.NormalTexture);
Params["specularPower"].SetValue(material.SpecularPower);
Params["specularColor"].SetValue(material.SpecularColor);
Params["useOffsetMapping"].SetValue(material.UseOffsetMapping);
Params["HeightMapTexture"].SetValue(material.HeightMapTexture);
Params["g_fOffsetBias"].SetValue(material.OffsetHeight);
return RenderTechnique(renderDelegate, material.Technique);
}
bool IRenderable.Render(Camera camera, Light light)
{
this.device.RawDevice.VertexDeclaration = this.device.MeshVertexDecl.RawDecl;
if (this.device.RawDevice.SetStreamSource(0, this.mesh.VertexBuffer.RawBuffer, 0, this.mesh.VertexBuffer.ElementSize).IsFailure)
return false;
this.device.RawDevice.Indices = this.mesh.IndexBuffer.RawBuffer;
return this.mesh.Material.Shader.Render(this.mesh.Material, light, camera, WorldMatrix,
(pass) =>
{
var drawResult = this.device.RawDevice.DrawIndexedPrimitives(D3D.PrimitiveType.TriangleList,
0, this.mesh.Attribute.VertexStart, this.mesh.Attribute.VertexCount,
this.mesh.Attribute.FaceStart * 3, this.mesh.Attribute.FaceCount);
return drawResult.IsSuccess;
});
}
public void Camera_Direction_Test()
{
var camera = new Camera();
Assert.AreEqual(Vector3.UnitZ, camera.Direction);
var dir = new Vector3(1.0f, 2.0f, 3.0f);
camera.Direction = dir;
TestHelpers.AreEqual(dir.Normalize(), camera.Direction);
var eyePos = new Vector3(1.0f, 2.0f, 3.0f);
camera.EyePos = eyePos;
var lookAt = new Vector3(4.0f, 5.0f, 6.0f);
camera.LookAt = lookAt;
TestHelpers.AreEqual((lookAt - eyePos).Normalize(), camera.Direction);
// Set zero vector has no effect
var oldDir = camera.Direction;
camera.Direction = Vector3.Zero;
Assert.AreEqual(oldDir, camera.Direction);
}
bool IRenderable.Render(Camera camera, Light light)
{
for (int i = 0; i < this.materials.Count; ++i)
{
var material = this.materials[i];
bool ret = material.Shader.Render(material, light, camera, Matrix4.Identity,
(pass) =>
{
foreach (var patch in this.patches)
{
if (patch.Render(i) == false)
return false;
}
return true;
});
if (ret == false)
return false;
}
return true;
}
bool IRenderable.Render(Camera camera, Light light)
{
if (IsEnabled == false)
return true;
if (this.textureRenderTarget == null ||
this.textureRenderTarget.Size.Width != this.device.RenderTarget.Size.Width ||
this.textureRenderTarget.Size.Height != this.device.RenderTarget.Size.Height)
{
this.textureRenderTarget = new TextureRenderTarget(this.device, this.device.RenderTarget.Size);
}
// Copy rendered buffer to our texture render target
this.device.RawDevice.StretchRectangle(this.device.RenderTarget.TargetSurface, this.textureRenderTarget.TargetSurface, TextureFilter.None);
this.device.RawDevice.SetRenderState(RenderState.ZEnable, false);
this.device.RawDevice.SetRenderState(RenderState.ZWriteEnable, false);
this.device.RawDevice.SetRenderState(RenderState.AlphaBlendEnable, false);
this.device.RawDevice.VertexDeclaration = this.device.ScreenVertexDecl.RawDecl;
if (this.device.RawDevice.SetStreamSource(0, this.device.ScreenVertexBuffer.RawBuffer, 0, this.device.ScreenVertexBuffer.ElementSize).IsFailure)
return false;
var windowSize = new Vector2(this.textureRenderTarget.Size.Width, this.textureRenderTarget.Size.Height);
this.shader.Params["windowSize"].SetValue(windowSize);
this.shader.Params["sceneMapTexture"].SetValue(this.textureRenderTarget.Texture);
this.shader.Params["screenBorderFadeoutMapTexture"].SetValue(BorderTexture);
bool ret = this.shader.RenderTechnique((pass) =>
{
return this.device.RawDevice.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2).IsSuccess;
}, "ScreenDarkenBorder");
this.device.RawDevice.SetRenderState(RenderState.ZEnable, true);
this.device.RawDevice.SetRenderState(RenderState.ZWriteEnable, true);
return ret;
}
bool IRenderable.Render(Camera camera, Light light)
{
if (IsEnabled == false)
return true;
var finalRenderTarget = this.device.RenderTarget;
CreateTextureRenderTargets(finalRenderTarget.Size);
CopyRenderTarget(finalRenderTarget, this.sceneMapRenderTarget);
this.device.RawDevice.SetRenderState(RenderState.ZEnable, false);
this.device.RawDevice.SetRenderState(RenderState.ZWriteEnable, false);
this.device.RawDevice.SetRenderState(RenderState.AlphaBlendEnable, false);
this.device.RawDevice.VertexDeclaration = this.device.ScreenVertexDecl.RawDecl;
if (this.device.RawDevice.SetStreamSource(0, this.device.ScreenVertexBuffer.RawBuffer, 0, this.device.ScreenVertexBuffer.ElementSize).IsFailure)
return false;
var windowSize = new Vector2(finalRenderTarget.Size.Width, finalRenderTarget.Size.Height);
this.shader.Params["windowSize"].SetValue(windowSize);
this.shader.Params["radialBlurScaleFactor"].SetValue(RadialBlurScaleFactor);
this.shader.Params["sceneMapTexture"].SetValue(this.sceneMapRenderTarget.Texture);
this.shader.Params["radialSceneMapTexture"].SetValue(this.radialSceneMapRenderTarget.Texture);
this.shader.Params["downsampleMapTexture"].SetValue(this.downsampleMapRenderTarget.Texture);
this.shader.Params["blurMap1Texture"].SetValue(this.blurMap1RenderTarget.Texture);
this.shader.Params["blurMap2Texture"].SetValue(this.blurMap2RenderTarget.Texture);
this.shader.Params["blurWidth"].SetValue(BlurWidth);
this.shader.Params["glowIntensity"].SetValue(GlowIntensity);
this.shader.Params["highlightIntensity"].SetValue(HighlightIntensity);
bool ret = this.shader.RenderTechnique(RenderPass, "ScreenGlow");
this.device.RawDevice.SetRenderState(RenderState.ZEnable, true);
this.device.RawDevice.SetRenderState(RenderState.ZWriteEnable, true);
return ret;
}
public bool Render(IRenderTarget renderTarget, IList<IRenderable> renderables, IList<ISprite> sprites, Camera camera, Light light, bool present)
{
if (camera == null || light == null)
throw new ArgumentNullException("Argument camera or light is null");
bool renderSuccess = false;
try
{
// Save primary
PrimaryRenderTarget.TargetSurface = this.device.RawDevice.GetRenderTarget(0);
PrimaryRenderTarget.DepthStencilSurface = this.device.RawDevice.DepthStencilSurface;
// Render this render target
renderSuccess = RenderToRenderTarget(renderTarget, renderables, sprites, present, camera, light);
}
finally
{
// Restore primary
this.device.SetRenderTarget(PrimaryRenderTarget);
}
return renderSuccess;
}
public void Camera_Orientation_Test()
{
var camera = new Camera();
Assert.AreEqual(Quaternion.Identity, camera.Orientation);
var newOrientation = Quaternion.CreateFromAxisAngle(Vector3.UnitY, new Radian(MathUtils.PI / 2.0f));
camera.Orientation = newOrientation;
Assert.AreEqual(newOrientation, camera.Orientation);
}
public void Camera_AspectRatio_Invalid_NegativeValue_Test()
{
var camera = new Camera();
camera.AspectRatio = -1.0f;
}
public void Camera_PlaneDistance_FarShouldBeLargerThanNear_Test()
{
var camera = new Camera();
camera.SetPlaneDistance(100.0f, 100.0f);
}
public void Camera_ViewMatrix_Test()
{
Camera camera = new Camera();
camera.EyePos = new Vector3(1.0f, 2.0f, 3.0f);
camera.LookAt = new Vector3(0.0f, 0.0f, 0.0f);
camera.UpVec = new Vector3(2.0f, 3.0f, 4.0f);
var zaxis = camera.Direction;
var xaxis = Vector3.Cross(camera.UpVec, zaxis).Normalize();
var yaxis = Vector3.Cross(zaxis, xaxis);
var col0 = new Vector4(xaxis, -Vector3.Dot(xaxis, camera.EyePos));
var col1 = new Vector4(yaxis, -Vector3.Dot(yaxis, camera.EyePos));
var col2 = new Vector4(zaxis, -Vector3.Dot(zaxis, camera.EyePos));
var expected = new Matrix4(col0, col1, col2, new Vector4(0, 0, 0, 1));
Assert.AreEqual(expected, camera.ViewMatrix);
}
public void Camera_FovY_Invalid_OverPI_Test()
{
var camera = new Camera();
camera.FovY = new Radian(MathUtils.PI * 1.1f);
}
public void Camera_PlaneDistance_Test()
{
var camera = new Camera();
Assert.AreEqual(1.0f, camera.NearPlaneDistance);
Assert.AreEqual(100000.0f, camera.FarPlaneDistance);
var expectedNear = 200.0f;
var expectedFar = 50000.0f;
camera.SetPlaneDistance(expectedNear, expectedFar);
Assert.AreEqual(expectedNear, camera.NearPlaneDistance);
Assert.AreEqual(expectedFar, camera.FarPlaneDistance);
}
public void Camera_MoveRelative_Test()
{
var camera = new Camera()
{
EyePos = Vector3.UnitX,
Direction = Vector3.UnitZ
};
var moveVec = new Vector3(1.0f, 1.0f, 0.0f);
camera.MoveRelative(moveVec);
TestHelpers.AreEqual(Vector3.UnitX + moveVec, camera.EyePos);
}
public void Camera_ProjectionMatrix_Test()
{
var camera = new Camera();
var projMat = camera.ProjectionMatrix;
// FovY changes
var oldFovY = camera.FovY;
camera.FovY = oldFovY / 2;
Assert.AreNotEqual(projMat, camera.ProjectionMatrix);
camera.FovY = oldFovY; // restore
Assert.AreEqual(projMat, camera.ProjectionMatrix);
// Aspect ratio changes
var oldAspect = camera.AspectRatio;
camera.AspectRatio = oldAspect / 2;
Assert.AreNotEqual(projMat, camera.ProjectionMatrix);
camera.AspectRatio = oldAspect;
Assert.AreEqual(projMat, camera.ProjectionMatrix);
// Plane distance changes
var oldNear = camera.NearPlaneDistance;
var oldFar = camera.FarPlaneDistance;
camera.SetPlaneDistance(oldNear / 2, oldFar / 2);
Assert.AreNotEqual(projMat, camera.ProjectionMatrix);
camera.SetPlaneDistance(oldNear, oldFar);
Assert.AreEqual(projMat, camera.ProjectionMatrix);
}
public void Camera_Yaw_Test()
{
var camera = new Camera();
var angle = new Radian(MathUtils.PI / 2);
camera.Yaw(angle);
var expected = Quaternion.CreateFromAxisAngle(Vector3.UnitY, angle);
TestHelpers.QuaternionAreNearEqual(expected, camera.Orientation);
}
public void Camera_AspectRatio_Invalid_ZeroValue_Test()
{
var camera = new Camera();
camera.AspectRatio = 0.0f;
}
public void Camera_Move_Test()
{
var camera = new Camera();
camera.Direction = Vector3.UnitY;
var moveVec = new Vector3(1.0f, 1.0f, 0.0f);
camera.Move(moveVec);
Assert.AreEqual(moveVec, camera.EyePos);
}
public void Camera_FovY_Invalid_Under0_Test()
{
var camera = new Camera();
camera.FovY = new Radian(-0.1f);
}
public void Camera_FovY_Test()
{
var camera = new Camera();
Assert.AreEqual(new Radian(MathUtils.PI / 4.0f), camera.FovY);
var expectedFovY = new Radian(2.0f);
camera.FovY = expectedFovY;
Assert.AreEqual(expectedFovY, camera.FovY);
// FieldOfView is between 0 and pi (180 degrees)
camera.FovY = new Radian(0.0f);
camera.FovY = new Radian(MathUtils.PI);
}
bool IRenderable.Render(Camera camera, Light light)
{
RenderCalled(this, EventArgs.Empty);
return true;
}
public void Camera_UpVec_Test()
{
Camera camera = new Camera();
Assert.AreEqual(Vector3.UnitY, camera.UpVec);
var upVec = new Vector3(1.0f, 2.0f, 3.0f);
camera.UpVec = upVec;
Assert.AreEqual(upVec, camera.UpVec);
}