/// <summary>
/// Initializes a new instance of the <see cref="DOF" /> class.
/// </summary>
/// <param name="deferredRenderer">The deferred renderer which will be using the DOF effect.</param>
public DOF(DeferredRenderer deferredRenderer)
{
this.deferredRenderer = deferredRenderer;
// Sensible defaults
this.FocalPlaneDistance = 42.0f;
this.FocalRange = 50.0f;
this.BlurDistance = 2.5f;
}
public void Should_Update_VisualNodes_When_Child_Moved_To_New_Parent()
{
using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
{
var dispatcher = new ImmediateDispatcher();
var loop = new Mock <IRenderLoop>();
Decorator moveFrom;
Decorator moveTo;
Canvas moveMe;
var root = new TestRoot
{
Child = new StackPanel
{
Children =
{
(moveFrom = new Decorator {
Child = moveMe = new Canvas(),
}),
(moveTo = new Decorator()),
}
}
};
var sceneBuilder = new SceneBuilder();
var target = new DeferredRenderer(
root,
loop.Object,
sceneBuilder: sceneBuilder,
dispatcher: dispatcher);
root.Renderer = target;
target.Start();
RunFrame(target);
moveFrom.Child = null;
moveTo.Child = moveMe;
RunFrame(target);
var scene = target.UnitTestScene();
var moveFromNode = (VisualNode)scene.FindNode(moveFrom);
var moveToNode = (VisualNode)scene.FindNode(moveTo);
Assert.Empty(moveFromNode.Children);
Assert.Equal(1, moveToNode.Children.Count);
Assert.Same(moveMe, moveToNode.Children[0].Visual);
}
}
public void Apply()
{
ShadowManager.Log("Applying to " + body);
CelestialBody celestialBody = Tools.GetCelestialBody(body);
Transform transform = Tools.GetScaledTransform(body);
if (transform != null)
{
Renderer mr = transform.GetComponent <Renderer>();
if (mr != null && hasSurface)
{
shadowMat = new Material(ShadowShader);
GameObject go = new GameObject();
materialPQS = go.AddComponent <MaterialPQS>();
localShadowMat = materialPQS.Apply(celestialBody, null, ShadowShader, false, true);
//shadowMaterial.ApplyMaterialProperties(shadowMat);
shadowMat.SetFloat(ShaderProperties._SunRadius_PROPERTY, (float)(ScaledSpace.InverseScaleFactor * Sun.Instance.sun.Radius));
localShadowMat.SetFloat(ShaderProperties._SunRadius_PROPERTY, (float)(Sun.Instance.sun.Radius));
shadowMat.name = materialName;
localShadowMat.name = materialName;
shadowMat.renderQueue = (int)Tools.Queue.Geometry + 3;
localShadowMat.renderQueue = (int)Tools.Queue.Geometry + 3;
DeferredRenderer.Add(mr.gameObject, shadowMat);
}
ScaledShadowComponent sc = transform.gameObject.AddComponent <ScaledShadowComponent>();
LocalShadowComponent lsc = FlightCamera.fetch.mainCamera.gameObject.AddComponent <LocalShadowComponent>();
List <CelestialBody> casters = new List <CelestialBody>();
if (caster != null)
{
foreach (String b in caster)
{
casters.Add(Tools.GetCelestialBody(b));
}
}
sc.Apply(shadowMat, celestialBody, casters);
lsc.Apply(localShadowMat, celestialBody, casters);
}
ApplyToMainMenu();
GameEvents.onGameSceneLoadRequested.Add(SceneLoaded);
if (HighLogic.LoadedScene == GameScenes.MAINMENU)
{
ApplyToMainMenu();
}
}
public void Should_Update_VisualNode_Order_On_ZIndex_Change_With_Dirty_Ancestor()
{
using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
{
var dispatcher = new ImmediateDispatcher();
var loop = new Mock <IRenderLoop>();
StackPanel stack;
Canvas canvas1;
Canvas canvas2;
var root = new TestRoot
{
Child = stack = new StackPanel
{
Children =
{
(canvas1 = new Canvas {
ZIndex =1
}), (canvas2= new Canvas {
ZIndex = 2
}),
}
}
};
var sceneBuilder = new SceneBuilder();
var target = new DeferredRenderer(
root,
loop.Object,
sceneBuilder: sceneBuilder,
dispatcher: dispatcher);
root.Renderer = target;
target.Start();
RunFrame(target);
root.InvalidateVisual();
canvas1.ZIndex = 3;
RunFrame(target);
var scene = target.UnitTestScene();
var stackNode = scene.FindNode(stack);
Assert.Same(stackNode.Children[0].Visual, canvas2);
Assert.Same(stackNode.Children[1].Visual, canvas1);
}
}
public void Should_Add_Dirty_Rect_On_Child_Remove()
{
using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
{
var dispatcher = new ImmediateDispatcher();
var loop = new Mock <IRenderLoop>();
Decorator decorator;
Border border;
var root = new TestRoot
{
Width = 100,
Height = 100,
Child = decorator = new Decorator
{
Child = border = new Border {
Width = 50, Height = 50, Background = Brushes.Red,
},
}
};
root.Measure(Size.Infinity);
root.Arrange(new Rect(root.DesiredSize));
var sceneBuilder = new SceneBuilder();
var target = new DeferredRenderer(
root,
loop.Object,
sceneBuilder: sceneBuilder,
dispatcher: dispatcher);
root.Renderer = target;
target.Start();
RunFrame(target);
decorator.Child = null;
RunFrame(target);
var scene = target.UnitTestScene();
var stackNode = scene.FindNode(decorator);
var dirty = scene.Layers[0].Dirty.ToList();
Assert.Equal(1, dirty.Count);
Assert.Equal(new Rect(25, 25, 50, 50), dirty[0]);
}
}
public static Renderable GetDefaultRenderable(DeferredRenderer renderer, DefaultMesh mesh)
{
IShaderProgram geometryShader = renderer.GetShader(DeferredRenderer.DrawableType.deferredDefaultMesh);
IShaderProgram lightViewShader = renderer.GetShader(DeferredRenderer.DrawableType.lightViewMesh);
IShaderProgram shadowMapShader = renderer.GetShader(DeferredRenderer.DrawableType.shadowMapMesh);
Renderable renderable = new Renderable();
VAO geometry = renderer.GetDrawable(mesh, DeferredRenderer.DrawableType.deferredDefaultMesh);
VAO lightViewMesh = renderer.GetDrawable(mesh, DeferredRenderer.DrawableType.lightViewMesh);
VAO shadowMapMesh = renderer.GetDrawable(mesh, DeferredRenderer.DrawableType.shadowMapMesh);
renderable.SetDeferredGeometryMesh(geometry, geometryShader);
renderable.SetLightViewMesh(geometry, lightViewShader);
renderable.SetShadowMapMesh(geometry, shadowMapShader);
return(renderable);
}
public void Should_Update_Dirty_Controls_In_Order()
{
using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
{
var dispatcher = new ImmediateDispatcher();
var loop = new Mock <IRenderLoop>();
Border border;
Decorator decorator;
Canvas canvas;
var root = new TestRoot
{
Child = decorator = new Decorator
{
Child = border = new Border {
Child = canvas = new Canvas()
}
}
};
var sceneBuilder = MockSceneBuilder(root);
var target = new DeferredRenderer(
root,
loop.Object,
sceneBuilder: sceneBuilder.Object,
dispatcher: dispatcher);
target.Start();
IgnoreFirstFrame(target, sceneBuilder);
target.AddDirty(border);
target.AddDirty(canvas);
target.AddDirty(root);
target.AddDirty(decorator);
var result = new List <IVisual>();
sceneBuilder.Setup(x => x.Update(It.IsAny <Scene>(), It.IsAny <IVisual>()))
.Callback <Scene, IVisual>((_, v) => result.Add(v));
RunFrame(target);
Assert.Equal(new List <IVisual> {
root, decorator, border, canvas
}, result);
}
}
public void First_Frame_Calls_SceneBuilder_UpdateAll()
{
var loop = new Mock <IRenderLoop>();
var root = new TestRoot();
var sceneBuilder = MockSceneBuilder(root);
var dispatcher = new ImmediateDispatcher();
var target = new DeferredRenderer(
root,
loop.Object,
sceneBuilder: sceneBuilder.Object,
dispatcher: dispatcher);
target.Start();
RunFrame(loop);
sceneBuilder.Verify(x => x.UpdateAll(It.IsAny <Scene>()));
}
public virtual void Enter(StateManager man, IState prev)
{
WorldManager = man;
if (LightManager == null)
{
LightManager = new LightManager(maxLights, maxLights, maxLights);
}
if (Renderer == null)
{
Renderer = new DeferredRenderer(Engine.Framebuffers, LightManager);
}
Engine.DeferredRenderer = Renderer;
Initializer?.Invoke();
}
public void Frame_Does_Not_Call_SceneBuilder_If_No_Dirty_Controls()
{
var loop = new Mock <IRenderLoop>();
var root = new TestRoot();
var sceneBuilder = MockSceneBuilder(root);
var target = new DeferredRenderer(
root,
loop.Object,
sceneBuilder: sceneBuilder.Object);
target.Start();
IgnoreFirstFrame(loop, sceneBuilder);
RunFrame(loop);
sceneBuilder.Verify(x => x.UpdateAll(It.IsAny <Scene>()), Times.Never);
sceneBuilder.Verify(x => x.Update(It.IsAny <Scene>(), It.IsAny <Visual>()), Times.Never);
}
public static void Render(Control target, SKCanvas canvas, double dpi = 96, bool useDeferredRenderer = false)
{
var renderTarget = new CanvasRenderTarget(canvas, dpi);
if (useDeferredRenderer)
{
using var renderer = new DeferredRenderer(target, renderTarget);
renderer.Start();
var renderLoopTask = renderer as IRenderLoopTask;
renderLoopTask.Update(TimeSpan.Zero);
renderLoopTask.Render();
}
else
{
ImmediateRenderer.Render(target, renderTarget);
}
}
private void ApplyToMainMenu()
{
if (HighLogic.LoadedScene == GameScenes.MAINMENU)
{
GameObject go = Tools.GetMainMenuObject(body);
if (go != mainMenuBody && go != null)
{
mainMenuBody = go;
Renderer r = mainMenuBody.GetComponent <Renderer>();
if (r != null)
{
scaledMat.SetTexture("_MainTex", r.material.GetTexture("_MainTex"));
Light sunlight = GameObject.FindObjectsOfType <Light>().Last(l => l.isActiveAndEnabled);
DeferredRenderer.Add(r.gameObject, scaledMat);
if (mainMenuBody.name.EndsWith("(Clone)"))
{
// There is a race condition with Kopernicus. Sometimes, it
// will have cloned a body that already had clouds. Hide old clouds.
for (var c = 0; c < mainMenuBody.transform.childCount; ++c)
{
var child = mainMenuBody.transform.GetChild(c).gameObject;
if (child.name.StartsWith("EVE City Lights") && child.name.EndsWith("(Clone)"))
{
child.SetActive(false);
}
}
}
ScaledCityComponent sc = r.gameObject.AddComponent <ScaledCityComponent>();
sc.Apply(scaledMat, sunlight);
CityLightsManager.Log("Applied to main Menu");
}
}
else if (go == null)
{
CityLightsManager.Log("Cannot Find to apply to main Menu!");
}
else if (mainMenuBody == go)
{
CityLightsManager.Log("Already Applied to main Menu!");
}
}
}
public Game(IContentLoader contentLoader, IRenderState renderState)
{
ui = new IslandUI(contentLoader);
this.renderState = renderState;
this.contentLoader = contentLoader;
renderer = new DeferredRenderer(contentLoader, renderState);
uiRenderer = new UIRenderer(contentLoader, renderState);
activeScene = new IslandScene(contentLoader, renderer);
waterEntity = activeScene.GetEntityByName("water");
if (waterEntity != null)
{
waterEntity.renderable.heightScaleFactor = 0.03f;
}
renderer.SetPointLights(activeScene.getPointLights());
activeCam = new FirstPersonCamera(campos, camrot.X, camrot.Y, Camera.ProjectionType.Perspective, fov: 1f, width: 20, height: 20, zPlaneFar: 100f);
startTime = DateTime.Now;
water = new Water(this.contentLoader);
}
public VoxelCustomRenderer(DX11Game game, DeferredRenderer dRenderer, DualContouringMeshBuilder dcMeshBuilder, DualContouringAlgorithm dcAlgo, MeshRenderDataFactory renderDataFactory)
{
this.game = game;
this.dRenderer = dRenderer;
this.dcMeshBuilder = dcMeshBuilder;
this.dcAlgo = dcAlgo;
this.renderDataFactory = renderDataFactory;
var tex = new RAMTexture();
defaultMaterial = new DCVoxelMaterial()
{
Texture = DCFiles.UVCheckerMap11_512
};
objectBuffer = DeferredMaterial.CreatePerObjectCB(game);
}
private DeferredRenderer CreateTargetAndRunFrame(
TestRoot root,
Mock <IRenderLoop> loop = null,
ISceneBuilder sceneBuilder = null,
IDispatcher dispatcher = null)
{
loop = loop ?? new Mock <IRenderLoop>();
var target = new DeferredRenderer(
root,
loop.Object,
sceneBuilder: sceneBuilder,
dispatcher: dispatcher ?? new ImmediateDispatcher());
root.Renderer = target;
target.Start();
RunFrame(loop);
return(target);
}
private DeferredRenderer CreateTargetAndRunFrame(
TestRoot root,
Mock <IRenderTimer> timer = null,
ISceneBuilder sceneBuilder = null,
IDispatcher dispatcher = null)
{
timer = timer ?? new Mock <IRenderTimer>();
dispatcher = dispatcher ?? new ImmediateDispatcher();
var target = new DeferredRenderer(
root,
new RenderLoop(timer.Object, dispatcher),
sceneBuilder: sceneBuilder,
dispatcher: dispatcher);
root.Renderer = target;
target.Start();
RunFrame(target);
return(target);
}
protected override void Dispose(bool disposing)
{
//GameWorld.Dispose(disposing);
try
{
Game.Device.ClearState();
}
catch { }
KeyboardInput.ReleaseDevice();
MouseInput.ReleaseDevice();
PrintText.Dispose();
EffectManager.Dispose();
SpriteDrawer.Dispose();
DeferredRenderer.Dispose();
SkyDome.Dispose();
TextureLoader.Dispose();
PhysicsEngine.Dispose();
}
public void Should_Update_VisualNode_Order_On_Child_Remove_Insert()
{
var dispatcher = new ImmediateDispatcher();
var loop = new Mock <IRenderLoop>();
StackPanel stack;
Canvas canvas1;
Canvas canvas2;
var root = new TestRoot
{
Child = stack = new StackPanel
{
Children =
{
(canvas1 = new Canvas()),
(canvas2 = new Canvas()),
}
}
};
var sceneBuilder = new SceneBuilder();
var target = new DeferredRenderer(
root,
loop.Object,
sceneBuilder: sceneBuilder,
dispatcher: dispatcher);
root.Renderer = target;
target.Start();
RunFrame(target);
stack.Children.Remove(canvas2);
stack.Children.Insert(0, canvas2);
RunFrame(target);
var scene = target.UnitTestScene();
var stackNode = scene.FindNode(stack);
Assert.Same(stackNode.Children[0].Visual, canvas2);
Assert.Same(stackNode.Children[1].Visual, canvas1);
}
public ParticleSystem(DeferredRenderer renderer, IContentLoader contentLoader)
{
random = new Random();
//Rendering
this.renderer = renderer;
deferredRenderable = new Renderable();
var plane = Meshes.CreatePlane(1, 1, 1, 1).Transform(Transformation.Rotation(-90, Axis.X));
IShaderProgram shader = renderer.GetShader(DeferredRenderer.DrawableType.particleMesh);
VAO planeVao = renderer.GetDrawable(plane, DeferredRenderer.DrawableType.particleMesh);
deferredRenderable.SetDeferredGeometryMesh(planeVao, shader);
ITexture2D defaultAlpha = contentLoader.Load <ITexture2D>("particleDefault.png");
deferredRenderable.SetAlbedoTexture(defaultAlpha);
deferredRenderable.SetAlphaMap(defaultAlpha);
deferredRenderable.faceCullingMode = FaceCullingMode.NONE;
VAO shadowPlaneVao = renderer.GetDrawable(plane, DeferredRenderer.DrawableType.particleShadowLightView);
IShaderProgram shadowShader = renderer.GetShader(DeferredRenderer.DrawableType.particleShadowLightView);
shadowRenderable = new Renderable();
shadowRenderable.SetDeferredGeometryMesh(shadowPlaneVao, shadowShader);
shadowRenderable.SetAlbedoTexture(defaultAlpha);
shadowRenderable.SetAlphaMap(defaultAlpha);
shadowRenderable.faceCullingMode = FaceCullingMode.NONE;
//ParticleSystemSetup
globalModules = new List <ParticleModule>();
perParticleModules = new List <ParticleModule>();
particleColor = new Range3D(new Vector3(1, 1, 1));
keepScaleRatio = true;
scaleAspect = new AspectRatio3D(AspectRatio3D.Axis.XAxis, 1);
particlePoolList = new List <Particle>();
spawnedParticleList = new List <Particle>();
particleRemoveList = new List <Particle>();
SetMaxParticles(100);
spawnArea = new Range3D(new Vector3(-0.1f, 0, -0.1f), new Vector3(0.1f, 0, 0.1f));
spawnScale = new Range3D(new Vector3(0f, 0f, 0f), new Vector3(1f, 1f, 1f));
spawnAcceleration = new Range3D(new Vector3(0, 0.1f, 0), new Vector3(0, 5f, 0));
spawnIntervallRange = new Range(0f, 1f);
spawnIntervall = spawnIntervallRange.GetRandomValue(random);
spawnRate = new Range(1, 1);
lifeTimeRange = new Range(10.0f);
}
private void Initialize()
{
_camera = new Camera2D(this);
_camera.NearClip = -1000;
_camera.FarClip = 1000;
_camera.Position = new Vector2(1496, 1624);
_inputService = (IInputService)Services.GetService(typeof(IInputService));
_inputService.MouseMove += _inputService_MouseMove;
_inputService.KeyDown += _inputService_KeyDown;
_textureFactory = new TextureFactory(this);
_maps = new Maps(this);
_shader = new DiffuseShader(this);
_renderer = new DeferredRenderer(this);
Tracer.Info("Loading Content...");
LoadContent();
}
public void TestDeferredRendererLineElement()
{
var game = new DX11Game();
game.InitDirectX();
var renderer = new DeferredRenderer(game);
var el = renderer.CreateLinesElement();
el.Lines.AddBox(new BoundingBox(Vector3.Zero, MathHelper.One), new Color4(1, 0, 0));
game.GameLoopEvent += delegate
{
renderer.Draw();
};
game.Run();
}
private void Window_Initialized(object sender, EventArgs e)
{
MainPlayer.Initialize();
float aspectRatio = (float)view1.Width / (float)view1.Height;
Camera.CurrentBehavior = Behavior.Spectator;
//Camera.Perspective((float)Math.PI / 4.0f, aspectRatio, 1.0f, 1000000.0f);
Camera.Perspective((float)Math.PI / 4.0f, aspectRatio, 1.0f, 4000.0f);
Camera.Position = new Vector3(0, 0, 0);
Camera.Velocity = new Vector3(40.0f, 40.0f, 40.0f);
Camera.RotationSpeed = 0.25f;
WorldTime.Speed = 0;
//compile shaders
List <BaseGameObject> shaders = WorldData.GetObjectsByType(typeof(Shader));
foreach (Shader s in shaders)
{
s.Recompile();
}
SpriteDrawer.Initialize();
DeferredRenderer.Initialize((int)view1.Width, (int)view1.Height);
DeferredRenderer.RenderHeight = (int)view1.Height;
DeferredRenderer.RenderWidth = (int)view1.Width;
SkyDome.Initialize();
Rendering.Grid.Initialize();
view1.OnRenderView += new EventHandler(view1_OnRender);
view1.D3DScene = new CellViewer((int)view1.Width, (int)view1.Height);
view1.OnRenderView += new EventHandler(view1_OnRender);
this.WindowState = System.Windows.WindowState.Maximized;
GameData.LoadGameData();
PhysicsEngine.Initialize();
ScriptManager.Initialize();
}
public override void OnGUI(GUI ui)
{
base.OnGUI(ui);
if (m_renderer == null)
{
m_renderer = Application.Engine.Renderer as DeferredRenderer;
if (m_renderer == null)
{
return;
}
}
var width = 320;
var height = 200;
ui.DrawTexture(new Rectangle(0, 0, width, height), m_renderer.ColorBuffer);
ui.DrawTexture(new Rectangle(0, height, width, height), m_renderer.NormalMap);
ui.DrawTexture(new Rectangle(0, height * 2, width, height), m_renderer.DepthBuffer);
ui.DrawTexture(new Rectangle(0, height * 3, width, height), m_renderer.LightMap);
}
private void btnOk_Click(object sender, RoutedEventArgs e)
{
lblErrMsg.Text = "";
if (objectToEdit == null)
{
objectToEdit = new Shader();
}
Shader obj = objectToEdit as Shader;
obj.BaseObjectId = txtBaseObjectId.Text;
obj.BaseObjectName = txtBaseObjectName.Text;
obj.ShaderString = shaderCode.Text;
string err = obj.Recompile();
if (!string.IsNullOrEmpty(err))
{
lblErrMsg.Text = err;
return;
}
else
{
lblErrMsg.Text = "";
DeferredRenderer.InitializeShaderMaterials();
}
obj.Category = objCategory;
bool success = isEditingObj ? WorldData.UpdateObject(obj) : WorldData.AddObject(obj);
if (!success)
{
MessageBox.Show(Application.Current.MainWindow, "ID already exists", "AddObject Failure", MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.Cancel);
}
else
{
//this.Close();
//if (parentWindow != null) parentWindow.Refresh();
}
}
public WorldRenderingSimulator()
{
deferred = TW.Graphics.AcquireRenderer();
//deferred.SSAO.MRadiusMultiplier = 10;
//deferred.SSAO.MNumDirs = 8;
//deferred.SSAO.MNumSteps = 2;
//deferred.SSAO.MContrast = 2;
deferred.SSAO.MRadiusMultiplier = 0.5f;
deferred.PointLightRenderer.ShadowUpdateInterval = 240;
var data = TW.Data.GetSingleton <Data>();
{
var light = deferred.CreateDirectionalLight();
light.LightDirection = Vector3.Normalize(new Vector3(1, -1, 1));
light.ShadowsEnabled = true;
data.LightCreated = true;
//var light = deferred.CreateSpotLight();
//light.LightPosition = new Vector3(-1,1,-1) *30;
//light.LightIntensity = 0.1f;
//if (data.SunEnabled)
// light.LightIntensity = 1;
//light.LightRadius = 400;
//light.SpotDirection = Vector3.Normalize(-light.LightPosition);
//light.ShadowsEnabled = true;
}
info = TW.Data.GetSingleton <CameraInfo>();
entitySimulator = new EntitySimulator();
wireframeSimulator = new WireframeBoxSimulator();
pointLightSimulator = new PointLightSimulator();
}
public void TestShowcaseSingleFrame()
{
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
var game = createGame();
game.SpectaterCamera = loadCamera(ShowcaseCamera);
game.Camera = game.SpectaterCamera;
var renderer = new DeferredRenderer(game);
var showcase = new ShowcaseSceneBuilder();
showcase.CreateScene(renderer);
game.GameLoopEvent += delegate
{
renderer.Draw();
game.Exit();
};
game.Run();
}
public void Frame_Does_Not_Call_SceneBuilder_If_No_Dirty_Controls()
{
using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
{
var dispatcher = new ImmediateDispatcher();
var loop = new Mock <IRenderLoop>();
var root = new TestRoot();
var sceneBuilder = MockSceneBuilder(root);
var target = new DeferredRenderer(
root,
loop.Object,
sceneBuilder: sceneBuilder.Object);
target.Start();
IgnoreFirstFrame(target, sceneBuilder);
RunFrame(target);
sceneBuilder.Verify(x => x.UpdateAll(It.IsAny <Scene>()), Times.Never);
sceneBuilder.Verify(x => x.Update(It.IsAny <Scene>(), It.IsAny <Visual>()), Times.Never);
}
}
private void initializeTW()
{
game = TW.Graphics;
deferredRenderer = TW.Graphics.AcquireRenderer();
var boxRenderer = BoxRenderer.Instance;
throw new NotImplementedException();
//boxRenderer.SetGame(game);
if (hideAxes)
{
//Hide axes, ugly hack
PropertyInfo prop = game.GetType().GetProperty("RenderAxis", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
prop.SetValue(game, false, null);
}
cameraLight = deferredRenderer.CreatePointLight();
cameraLight.LightRadius = 75;
extraLight = deferredRenderer.CreatePointLight();
extraLight.LightRadius = 100f;
extraLight.ShadowsEnabled = true;
extraLight.Color = new Vector3(1, 1, 0.85f);
extraLight.LightPosition = new Vector3(1000, 1000, 1000);
sun = deferredRenderer.CreatePointLight();
sun.LightRadius = 1000;
float intensity = 1.25f;
sun.Color = new Vector3(0.75f * intensity, 0.75f * intensity, 0.5f * intensity);
sun.ShadowsEnabled = true;
sun.LightPosition = new Vector3(-5, 30, 10);
seedDisplay = new TextTexture(game, 500, 50);
batchDisplay = new TextTexture(game, 500, 50);
infoDisplay = new TextTexture(game, 500, 50);
}
public void Remove()
{
CelestialBody celestialBody = Tools.GetCelestialBody(body);
ShadowManager.Log("Removing Shadow obj");
Transform transform = Tools.GetScaledTransform(body);
if (transform != null)
{
GameObject.DestroyImmediate(transform.gameObject.GetComponents <ScaledShadowComponent>().First(sc => sc.GUID == materialName));
LocalShadowComponent lc = FlightCamera.fetch.mainCamera.gameObject.GetComponents <LocalShadowComponent>().FirstOrDefault(sc => sc.GUID == materialName);
if (lc != null)
{
GameObject.DestroyImmediate(lc);
}
DeferredRenderer.Remove(transform.gameObject, shadowMat);
}
materialPQS.Remove();
GameObject.DestroyImmediate(materialPQS);
GameEvents.onGameSceneLoadRequested.Remove(SceneLoaded);
}
public static void ShowVoxelGrid(VoxelGrid grid)
{
var game = new DX11Game();
game.InitDirectX();
var renderer = new DeferredRenderer(game);
var light = renderer.CreateDirectionalLight();
var ret = grid;
IMesh voxelMesh = Voxelizer.CreateVoxelMesh(ret);
var voxel = renderer.CreateMeshElement(voxelMesh);
voxel.WorldMatrix = Matrix.Translation(0, 0, 0);
game.GameLoopEvent += delegate
{
renderer.Draw();
};
game.Run();
}
/// <summary>
///
/// </summary>
private void StartD3D()
{
if (EffectsManager == null || RenderTechniquesManager == null)
{
// Make sure both are null
RenderTechniquesManager = null;
EffectsManager = null;
RenderTechniquesManager = new DefaultRenderTechniquesManager();
EffectsManager = new DefaultEffectsManager(RenderTechniquesManager);
return; // StardD3D() is called from DP changed handler
}
surfaceD3D = new DX11ImageSource(EffectsManager.AdapterIndex);
surfaceD3D.IsFrontBufferAvailableChanged += OnIsFrontBufferAvailableChanged;
device = EffectsManager.Device;
deferredRenderer = new DeferredRenderer();
renderRenderable.DeferredRenderer = deferredRenderer;
CreateAndBindTargets();
SetDefaultRenderTargets();
Source = surfaceD3D;
InvalidateRender();
}
/// <summary>
///
/// </summary>
private void StartD3D()
{
this.surfaceD3D = new DX11ImageSource();
this.surfaceD3D.IsFrontBufferAvailableChanged += this.OnIsFrontBufferAvailableChanged;
this.device = EffectsManager.Device;
this.deferredRenderer = new DeferredRenderer();
this.renderRenderable.DeferredRenderer = this.deferredRenderer;
this.CreateAndBindTargets();
this.SetDefaultRenderTargets();
this.Source = this.surfaceD3D;
}
/// <summary>
///
/// </summary>
private void StartD3D()
{
if (EffectsManager == null || RenderTechniquesManager == null)
{
// Make sure both are null
RenderTechniquesManager = null;
EffectsManager = null;
RenderTechniquesManager = new DefaultRenderTechniquesManager();
EffectsManager = new DefaultEffectsManager(RenderTechniquesManager);
return; // StardD3D() is called from DP changed handler
}
surfaceD3D = new DX11ImageSource(EffectsManager.AdapterIndex);
surfaceD3D.IsFrontBufferAvailableChanged += OnIsFrontBufferAvailableChanged;
device = EffectsManager.Device;
deferredRenderer = new DeferredRenderer();
renderRenderable.DeferredRenderer = deferredRenderer;
CreateAndBindTargets();
SetDefaultRenderTargets();
Source = surfaceD3D;
InvalidateRender();
}
/// <summary>
///
/// </summary>
private void StartD3D()
{
surfaceD3D = new DX11ImageSource();
surfaceD3D.IsFrontBufferAvailableChanged += OnIsFrontBufferAvailableChanged;
device = EffectsManager.Device;
deferredRenderer = new DeferredRenderer();
renderRenderable.DeferredRenderer = deferredRenderer;
CreateAndBindTargets();
SetDefaultRenderTargets();
Source = surfaceD3D;
InvalidateRender();
}
/// <summary>
/// Initializes a new instance of the <see cref="SSAO" /> class.
/// </summary>
/// <param name="deferredRenderer">The deferred renderer which will be using the SSAO effect.</param>
public SSAO(DeferredRenderer deferredRenderer)
{
this.deferredRenderer = deferredRenderer;
}
