public void Render(Matrix pTransforme, float pScale)
{
mTimer = (float)(KryptonEngine.EngineSettings.Time.TotalGameTime.TotalMilliseconds / 10000);
mGrapicsDevice.SetRenderTarget(mFogTarget);
mGrapicsDevice.Clear(Color.Transparent);
mFogShader.Parameters["View"].SetValue(pTransforme.Translation);
mFogShader.Parameters["Scale"].SetValue(pScale);
mFogShader.Parameters["Timer"].SetValue(mTimer);
mFogShader.Parameters["Speed"].SetValue(mSpeed);
mFogShader.Parameters["FogFactorMin"].SetValue(mFogFactorMin);
mFogShader.Parameters["FogFactorMax"].SetValue(mFogFactorMax);
mFogShader.Parameters["FogStrength"].SetValue(0.3f);
mGrapicsDevice.Textures[1] = mSceneDepthMap;
mGrapicsDevice.Textures[2] = mFogTexture;
mGrapicsDevice.Textures[3] = mSceneDiffuseMap;
mFogShader.CurrentTechnique.Passes[0].Apply();
QuadRenderer.Render(mGrapicsDevice);
mGrapicsDevice.SetRenderTarget(null);
mGrapicsDevice.Clear(Color.Black);
mGrapicsDevice.Textures[1] = mFogTarget;
mSimpleDrawShader.CurrentTechnique.Passes[0].Apply();
QuadRenderer.Render(mGrapicsDevice);
}
public void Render()
{
KryptonEngine.EngineSettings.Graphics.GraphicsDevice.SetRenderTarget(mHatchingTarget);
KryptonEngine.EngineSettings.Graphics.GraphicsDevice.Clear(Color.Transparent);
HatchingShader.Parameters["repeat"].SetValue(mResolution);
KryptonEngine.EngineSettings.Graphics.GraphicsDevice.Textures[1] = mLightMap;
HatchingShader.CurrentTechnique.Passes[0].Apply();
QuadRenderer.Render(KryptonEngine.EngineSettings.Graphics.GraphicsDevice);
}
protected override void OnRenderFrame(FrameEventArgs args)
{
GL.Clear(ClearBufferMask.ColorBufferBit);
quadRenderer.Reset();
//vex.Render(quadRenderer);
helloText.Render(quadRenderer);
quadRenderer.Render();
Context.SwapBuffers();
base.OnRenderFrame(args);
}
public void ProcessLight(List <Light> pLightList, Matrix pTranslation)
{
EngineSettings.Graphics.GraphicsDevice.SetRenderTarget(mLightTarget);
EngineSettings.Graphics.GraphicsDevice.Clear(Color.Transparent);
EngineSettings.Graphics.GraphicsDevice.BlendState = mLightMapBlendState;
KryptonEngine.EngineSettings.Graphics.GraphicsDevice.Textures[0] = mGBuffer.RenderTargets[1];
KryptonEngine.EngineSettings.Graphics.GraphicsDevice.Textures[1] = mGBuffer.RenderTargets[3];
this.mTranslatetViewMatrix = Matrix.Multiply(mView, pTranslation);
//this.mLightShader.Parameters["World"].SetValue(this.mWorld);
this.mLightShader.Parameters["View"].SetValue(pTranslation);
//this.mLightShader.Parameters["Projection"].SetValue(this.mProjection);
foreach (Light l in pLightList)
{
if (!l.IsVisible)
{
continue;
}
Vector4 lightPos = new Vector4(l.Position, l.Depth * 720, 1f);
this.mLightShader.Parameters["View"].SetValue(pTranslation);
this.mLightShader.Parameters["LightIntensity"].SetValue(l.Intensity);
this.mLightShader.Parameters["LightColor"].SetValue(l.LightColor);
this.mLightShader.Parameters["LightPosition"].SetValue(lightPos);
this.mLightShader.Parameters["screen"].SetValue(new Vector2(EngineSettings.VirtualResWidth, EngineSettings.VirtualResHeight));
if (l.GetType() == typeof(PointLight))
{
PointLight tempPl = (PointLight)l;
mLightShader.Parameters["LightRadius"].SetValue(tempPl.Radius);
mLightShader.CurrentTechnique.Passes[0].Apply();
}
//directional Light!
QuadRenderer.Render(this.mGraphicsDevice);
}
EngineSettings.Graphics.GraphicsDevice.SetRenderTarget(null);
}
/// <summary>
/// Draws a directional light.
/// </summary>
/// <param name="lightDirection">The light direction.</param>
/// <param name="color">The color.</param>
void DrawDirectionalLight(RenderTarget2D colorRT, RenderTarget2D normalRT, RenderTarget2D depthRT, Camera camera)
{
// Set all parameters
directionalLightEffect.Parameters["colorMap"].SetValue(colorRT);
directionalLightEffect.Parameters["normalMap"].SetValue(normalRT);
directionalLightEffect.Parameters["depthMap"].SetValue(depthRT);
directionalLightEffect.Parameters["lightDirection"].SetValue(light.Direction);
directionalLightEffect.Parameters["Color"].SetValue(light.Color);
directionalLightEffect.Parameters["cameraPosition"].SetValue(camera.Position);
directionalLightEffect.Parameters["InvertViewProjection"].SetValue(Matrix.Invert(camera.ViewMatrix * camera.ProjectionMatrix));
directionalLightEffect.Parameters["halfPixel"].SetValue(halfPixel);
// Apply the Effect
directionalLightEffect.Techniques[0].Passes[0].Apply();
// Draw a FullscreenQuad
fullscreenQuad.Render(Vector2.One * -1, Vector2.One);
}
public void ProcessFinalScene()
{
EngineSettings.Graphics.GraphicsDevice.SetRenderTarget(mFinalTarget);
EngineSettings.Graphics.GraphicsDevice.Clear(Color.Transparent);
EngineSettings.Graphics.GraphicsDevice.Textures[0] = this.mGBuffer.RenderTargets[0];
EngineSettings.Graphics.GraphicsDevice.Textures[1] = mLightTarget;
EngineSettings.Graphics.GraphicsDevice.Textures[2] = this.mGBuffer.RenderTargets[2];
this.mCombineShader.Parameters["ambientColor"].SetValue(AmbientLight.LightColor);
this.mCombineShader.Parameters["ambientIntensity"].SetValue(AmbientLight.Intensity);
mCombineShader.CurrentTechnique.Passes[0].Apply();
QuadRenderer.Render(this.mGraphicsDevice);
EngineSettings.Graphics.GraphicsDevice.SetRenderTarget(null);
}
public RenderTarget2D RenderOcean(RenderTarget2D waterScene, Vector2 camMove)
{
noisePow = new Vector2(0.031f, 0.03125f) * 3; // 3 tile sample radius looks good
noiseFreq = 1.0f;
// TODO set offset by location in map (ocean currents)
noiseOffset += 0.0002f;
//oceanRippleEffect.Parameters["WorldViewProjection"].SetValue(wvm);
oceanRippleEffect.Parameters["noiseOffset"].SetValue(noiseOffset);
oceanRippleEffect.Parameters["noiseFrequency"].SetValue(noiseFreq);
oceanRippleEffect.Parameters["camMove"].SetValue(camMove);
oceanRippleEffect.Parameters["noisePower"].SetValue(noisePow);
oceanRippleEffect.Parameters["noiseTexture"].SetValue(noiseMap);
oceanRippleEffect.Parameters["water"].SetValue(waterScene);
_graphics.SetRenderTarget(oceanEffectRT);
_graphics.Clear(Color.PeachPuff);
oceanRippleEffect.CurrentTechnique.Passes[0].Apply();
_quadRenderer.Render(Vector2.One * -1, Vector2.One);
return(oceanEffectRT);
}
/// <summary>
/// Renders the current frame to each holographic display, according to the
/// current application and spatial positioning state. Returns true if the
/// frame was rendered to at least one display.
/// </summary>
public bool Render(HolographicFrame holographicFrame)
{
// Don't try to render anything before the first Update.
if (timer.FrameCount == 0)
{
return(false);
}
//
// TODO: Add code for pre-pass rendering here.
//
// Take care of any tasks that are not specific to an individual holographic
// camera. This includes anything that doesn't need the final view or projection
// matrix, such as lighting maps.
//
// Up-to-date frame predictions enhance the effectiveness of image stablization and
// allow more accurate positioning of holograms.
holographicFrame.UpdateCurrentPrediction();
HolographicFramePrediction prediction = holographicFrame.CurrentPrediction;
// Lock the set of holographic camera resources, then draw to each camera
// in this frame.
return(deviceResources.UseHolographicCameraResources(
(Dictionary <uint, CameraResources> cameraResourceDictionary) =>
{
bool atLeastOneCameraRendered = false;
foreach (var cameraPose in prediction.CameraPoses)
{
// This represents the device-based resources for a HolographicCamera.
CameraResources cameraResources = cameraResourceDictionary[cameraPose.HolographicCamera.Id];
// Get the device context.
var context = deviceResources.D3DDeviceContext;
var renderTargetView = cameraResources.BackBufferRenderTargetView;
var depthStencilView = cameraResources.DepthStencilView;
// Set render targets to the current holographic camera.
context.OutputMerger.SetRenderTargets(depthStencilView, renderTargetView);
// Clear the back buffer and depth stencil view.
if (canGetHolographicDisplayForCamera &&
cameraPose.HolographicCamera.Display.IsOpaque)
{
SharpDX.Mathematics.Interop.RawColor4 cornflowerBlue = new SharpDX.Mathematics.Interop.RawColor4(0.392156899f, 0.58431375f, 0.929411829f, 1.0f);
context.ClearRenderTargetView(renderTargetView, cornflowerBlue);
}
else
{
SharpDX.Mathematics.Interop.RawColor4 transparent = new SharpDX.Mathematics.Interop.RawColor4(0.0f, 0.0f, 0.0f, 0.0f);
context.ClearRenderTargetView(renderTargetView, transparent);
}
context.ClearDepthStencilView(
depthStencilView,
SharpDX.Direct3D11.DepthStencilClearFlags.Depth | SharpDX.Direct3D11.DepthStencilClearFlags.Stencil,
1.0f,
0);
//
// TODO: Replace the sample content with your own content.
//
// Notes regarding holographic content:
// * For drawing, remember that you have the potential to fill twice as many pixels
// in a stereoscopic render target as compared to a non-stereoscopic render target
// of the same resolution. Avoid unnecessary or repeated writes to the same pixel,
// and only draw holograms that the user can see.
// * To help occlude hologram geometry, you can create a depth map using geometry
// data obtained via the surface mapping APIs. You can use this depth map to avoid
// rendering holograms that are intended to be hidden behind tables, walls,
// monitors, and so on.
// * On HolographicDisplays that are transparent, black pixels will appear transparent
// to the user. On such devices, you should clear the screen to Transparent as shown
// above. You should still use alpha blending to draw semitransparent holograms.
//
// The view and projection matrices for each holographic camera will change
// every frame. This function refreshes the data in the constant buffer for
// the holographic camera indicated by cameraPose.
if (stationaryReferenceFrame != null)
{
cameraResources.UpdateViewProjectionBuffer(deviceResources, cameraPose, stationaryReferenceFrame.CoordinateSystem);
}
// Attach the view/projection constant buffer for this camera to the graphics pipeline.
bool cameraActive = cameraResources.AttachViewProjectionBuffer(deviceResources);
#if DRAW_SAMPLE_CONTENT
// Only render world-locked content when positional tracking is active.
if (cameraActive)
{
// Draw the sample hologram.
quadRendererR.Render();
quadRendererL.Render();
if (canCommitDirect3D11DepthBuffer)
{
// On versions of the platform that support the CommitDirect3D11DepthBuffer API, we can
// provide the depth buffer to the system, and it will use depth information to stabilize
// the image at a per-pixel level.
HolographicCameraRenderingParameters renderingParameters = holographicFrame.GetRenderingParameters(cameraPose);
SharpDX.Direct3D11.Texture2D depthBuffer = cameraResources.DepthBufferTexture2D;
// Direct3D interop APIs are used to provide the buffer to the WinRT API.
SharpDX.DXGI.Resource1 depthStencilResource = depthBuffer.QueryInterface <SharpDX.DXGI.Resource1>();
SharpDX.DXGI.Surface2 depthDxgiSurface = new SharpDX.DXGI.Surface2(depthStencilResource, 0);
IDirect3DSurface depthD3DSurface = InteropStatics.CreateDirect3DSurface(depthDxgiSurface.NativePointer);
if (depthD3DSurface != null)
{
// Calling CommitDirect3D11DepthBuffer causes the system to queue Direct3D commands to
// read the depth buffer. It will then use that information to stabilize the image as
// the HolographicFrame is presented.
renderingParameters.CommitDirect3D11DepthBuffer(depthD3DSurface);
}
}
}
#endif
atLeastOneCameraRendered = true;
}
return atLeastOneCameraRendered;
}));
}
protected override void LoadContent()
{
base.LoadContent();
ContentWrapper.Initialize(this);
_spriteBatch = new SpriteBatch(GraphicsDevice);
_lineBatch = new LineBatch(GraphicsDevice);
_quadRenderer = new QuadRenderer(GraphicsDevice);
_input.LoadContent(GraphicsDevice.Viewport);
#if WINDOWS
_counter.LoadContent();
#endif
// Create rendertarget for transitions
PresentationParameters pp = GraphicsDevice.PresentationParameters;
_transitions.Add(new RenderTarget2D(GraphicsDevice, pp.BackBufferWidth, pp.BackBufferHeight, false, SurfaceFormat.Color, pp.DepthStencilFormat, pp.MultiSampleCount, RenderTargetUsage.DiscardContents));
_menuScreen = new MenuScreen();
List <Type> DemosToLoad = new List <Type>();
Assembly samplesFramework = Assembly.GetExecutingAssembly();
foreach (Type sampleType in samplesFramework.GetTypes())
{
if (sampleType.IsSubclassOf(typeof(PhysicsDemoScreen)))
{
DemosToLoad.Add(sampleType);
}
}
DemosToLoad.Add(DemosToLoad[0]); // HACK: Load the first sample two times, since some delayed creation stuff with the rendertargets always breaks the first preview picture.
bool firstPreview = true;
foreach (Type sampleType in DemosToLoad)
{
PhysicsDemoScreen demoScreen = samplesFramework.CreateInstance(sampleType.ToString()) as PhysicsDemoScreen;
#if WINDOWS
if (!firstPreview)
{
Console.WriteLine("Loading demo: " + demoScreen.GetTitle());
}
#endif
RenderTarget2D preview = new RenderTarget2D(GraphicsDevice, pp.BackBufferWidth / 2, pp.BackBufferHeight / 2, false, SurfaceFormat.Color, pp.DepthStencilFormat, pp.MultiSampleCount, RenderTargetUsage.DiscardContents);
demoScreen.Framework = this;
demoScreen.IsExiting = false;
demoScreen.Sprites = _spriteBatch;
demoScreen.Lines = _lineBatch;
demoScreen.Quads = _quadRenderer;
demoScreen.LoadContent();
// "Abuse" transition rendertarget to render screen preview
GraphicsDevice.SetRenderTarget(_transitions[0]);
GraphicsDevice.Clear(Color.Transparent);
_quadRenderer.Begin();
_quadRenderer.Render(Vector2.Zero, new Vector2(_transitions[0].Width, _transitions[0].Height), null, true, ContentWrapper.Grey, Color.White * 0.3f);
_quadRenderer.End();
// Update ensures that the screen is fully visible, we "cover" it so that no physics are run
demoScreen.Update(new GameTime(demoScreen.TransitionOnTime, demoScreen.TransitionOnTime), true, false);
demoScreen.Draw(new GameTime());
demoScreen.Draw(new GameTime());
GraphicsDevice.SetRenderTarget(preview);
GraphicsDevice.Clear(Color.Transparent);
_spriteBatch.Begin();
_spriteBatch.Draw(_transitions[0], preview.Bounds, Color.White);
_spriteBatch.End();
GraphicsDevice.SetRenderTarget(null);
demoScreen.ExitScreen();
demoScreen.Update(new GameTime(demoScreen.TransitionOffTime, demoScreen.TransitionOffTime), true, false);
if (!firstPreview)
{
_menuScreen.AddMenuItem(demoScreen, preview);
}
else
{
firstPreview = false;
}
}
AddScreen(new BackgroundScreen());
AddScreen(_menuScreen);
//TODO: This can't be called at this point in time in MonoGame
//ResetElapsedTime();
}
/// <summary>
/// Renders the current frame to each holographic display, according to the
/// current application and spatial positioning state. Returns true if the
/// frame was rendered to at least one display.
/// </summary>
public bool Render(ref HolographicFrame holographicFrame)
{
// Don't try to render anything before the first Update.
if (timer.FrameCount == 0)
{
return(false);
}
//
// TODO: Add code for pre-pass rendering here.
//
// Take care of any tasks that are not specific to an individual holographic
// camera. This includes anything that doesn't need the final view or projection
// matrix, such as lighting maps.
//
// Up-to-date frame predictions enhance the effectiveness of image stablization and
// allow more accurate positioning of holograms.
holographicFrame.UpdateCurrentPrediction();
HolographicFramePrediction prediction = holographicFrame.CurrentPrediction;
// Lock the set of holographic camera resources, then draw to each camera
// in this frame.
return(deviceResources.UseHolographicCameraResources(
(Dictionary <uint, CameraResources> cameraResourceDictionary) =>
{
bool atLeastOneCameraRendered = false;
foreach (var cameraPose in prediction.CameraPoses)
{
// This represents the device-based resources for a HolographicCamera.
CameraResources cameraResources = cameraResourceDictionary[cameraPose.HolographicCamera.Id];
// Get the device context.
var context = deviceResources.D3DDeviceContext;
var renderTargetView = cameraResources.BackBufferRenderTargetView;
var depthStencilView = cameraResources.DepthStencilView;
// Set render targets to the current holographic camera.
context.OutputMerger.SetRenderTargets(depthStencilView, renderTargetView);
// Clear the back buffer and depth stencil view.
SharpDX.Mathematics.Interop.RawColor4 transparent = new SharpDX.Mathematics.Interop.RawColor4(0.0f, 0.0f, 0.0f, 0.0f);
context.ClearRenderTargetView(renderTargetView, transparent);
context.ClearDepthStencilView(
depthStencilView,
SharpDX.Direct3D11.DepthStencilClearFlags.Depth | SharpDX.Direct3D11.DepthStencilClearFlags.Stencil,
1.0f,
0);
//
// TODO: Replace the sample content with your own content.
//
// Notes regarding holographic content:
// * For drawing, remember that you have the potential to fill twice as many pixels
// in a stereoscopic render target as compared to a non-stereoscopic render target
// of the same resolution. Avoid unnecessary or repeated writes to the same pixel,
// and only draw holograms that the user can see.
// * To help occlude hologram geometry, you can create a depth map using geometry
// data obtained via the surface mapping APIs. You can use this depth map to avoid
// rendering holograms that are intended to be hidden behind tables, walls,
// monitors, and so on.
// * Black pixels will appear transparent to the user wearing the device, but you
// should still use alpha blending to draw semitransparent holograms. You should
// also clear the screen to Transparent as shown above.
//
// The view and projection matrices for each holographic camera will change
// every frame. This function refreshes the data in the constant buffer for
// the holographic camera indicated by cameraPose.
cameraResources.UpdateViewProjectionBuffer(deviceResources, cameraPose, referenceFrame.CoordinateSystem);
// Attach the view/projection constant buffer for this camera to the graphics pipeline.
bool cameraActive = cameraResources.AttachViewProjectionBuffer(deviceResources);
#if DRAW_SAMPLE_CONTENT
// Only render world-locked content when positional tracking is active.
if (cameraActive)
{
// Draw the sample hologram.
quadRenderer.Render();
}
#endif
atLeastOneCameraRendered = true;
}
return atLeastOneCameraRendered;
}));
}
