internal void Render()
{
if (!IsRendererSuppressed)
{
if (RenderTarget != null)
{
if (!RenderTarget.IsDisposed)
{
CountFPS(); // === Start count frame time
RenderTarget.BeginDraw();
RenderTarget.Clear(SceneManager.CurrentScene.BackgroundColor.RawColor);
for (int obj = 0; obj < SceneManager.CurrentScene.GameObjects.Count; obj++)
{
SceneManager.CurrentScene.GameObjects[obj].GetComponent <IRenderable>().OnRender(RenderFrame);
RenderTarget.Transform = Matrix3x2.Identity;
}
if (Debugging.DrawBounds)
{
for (int obj = 0; obj < SceneManager.CurrentScene.GameObjects.Count; obj++)
{
RenderTarget.DrawRectangle(SceneManager.CurrentScene.GameObjects[obj].Transform.DrawingBoundings.RawRectangle, DrawingBoundsBrush);
RenderTarget.DrawRectangle(SceneManager.CurrentScene.GameObjects[obj].CollisionBox.ColliderBounds, CollisionBoxesBrush);
RenderTarget.Transform = Matrix3x2.Identity;
}
}
RenderTarget.Transform = Matrix3x2.Identity;
RenderTarget.EndDraw();
switch (GameWindow.Current.WindowParameters.VSyncMode)
{
case VSyncMode.Off:
SwapChain.Present(0, DXGI.PresentFlags.None);
break;
case VSyncMode.On:
SwapChain.Present(1, DXGI.PresentFlags.None);
break;
case VSyncMode.Half:
SwapChain.Present(2, DXGI.PresentFlags.None);
break;
}
Clock.Restart(); // === End count frame time
}
}
}
}
public override void Present()
{
if (!nativeDevice.IsDisposed)
{
swapChain.Present(0, PresentFlags.None);
}
}
public void Present()
{
lock (deviceManager.DeviceLock)
{
swapChain.Present(0, DXGI.PresentFlags.None);
}
}
public void DrawContent(EditView view, Rectangle updateRect)
{
base.BegineDraw();
view.Draw(updateRect);
base.EndDraw();
swapchain.Present(1, DXGI.PresentFlags.None);
}
private void Draw()
{
//d3dDeviceContext.ClearRenderTargetView(renderTargetView, new SharpDX.Color(32, 103, 178));
//renderTargetView.
//byte[] bytes = CaptureFrame();
if (!capturedFrame)
{
//capturedFrame = true;
//GCHandle pinned = GCHandle.Alloc(outBytes, GCHandleType.Pinned);
//IntPtr ptr = pinned.AddrOfPinnedObject();
//pinned.Free();
//int ProcessorCount = Environment.ProcessorCount;
DrawByte(outBytes);
//DrawByte(frameBytes);
swapChain.Present(1, PresentFlags.None);
}
//DrawByte(frameBytes);
//apChain.Present(1, PresentFlags.None);
}
protected override void OnPaint(PaintEventArgs e)
{
CreateDeviceResources();
try
{
this._dc.BeginDraw();
try
{
this._dc.Transform = Matrix3x2.Identity;
this._dc.Clear(new Color(this.BackColor.R, this.BackColor.G, this.BackColor.B));
OnRender(_dc);
}
finally
{
try
{
this._dc.EndDraw();
_swapChain.Present(0, PresentFlags.None);
}
catch (SharpDX.SharpDXException ex)
{
if (ex.ResultCode == 0x8899000C) //D2DERR_RECREATE_TARGET
{
this.ReCreateDeviceIndependentResources();
Invalidate();
}
}
}
}
finally
{
CleanUpDeviceResources();
}
}
/// <summary>
///
/// </summary>
public override void EndDraw()
{
mRenderTarget2D.EndDraw();
bool WaitVerticalBlanking = false;
mSwapChain.Present(WaitVerticalBlanking ? 1 : 0, DXGI.PresentFlags.None);
}
private void Render()
{
Device.BeginDraw();
base.BeginRender(DateTime.Now);
Device.EndDraw();
mSwapChain.Present(0, dx.PresentFlags.None);
base.EndRender();
}
public void EndFrame()
{
chain.Present(1, PresentFlags.None);
curView?.Dispose();
curView = null;
curDraw?.Dispose();
curDraw = null;
curTarget?.Dispose();
curTarget = null;
}
/// <summary>
/// Presents a rendered image to the user. SwapChain::Present()
/// </summary>
/// <exception cref="System.Exception"></exception>
public void Present()
{
if (swapChain != null)
{
swapChain.Present(syncInterval, DXGI.PresentFlags.None);
}
else
{
throw new Exception(MethodBase.GetCurrentMethod().Name + " SwapChain is null");
}
}
void Draw()
{
m_d3d11DeviceContext.OutputMerger.SetRenderTargets(m_renderTargetView);
SharpDX.Mathematics.Interop.RawColor4 color = new SharpDX.Mathematics.Interop.RawColor4(32 / (float)255, 103 / (float)255, 178 / (float)255, 1);
m_d3d11DeviceContext.ClearRenderTargetView(m_renderTargetView, color);
m_d3d11DeviceContext.InputAssembler.SetVertexBuffers(0, new D3D11.VertexBufferBinding(m_triangleVertexBuffer, SharpDX.Utilities.SizeOf <VertexPositionColor>(), 0));
m_d3d11DeviceContext.Draw(m_vertices.Count(), 0);
m_swapChain.Present(1, DXGI.PresentFlags.None);
}
public void Render()
{
if (hmd == null)
{
return;
}
OculusWrap.OVR.Vector3f[] hmdToEyeViewOffsets = { eye_texes[0].HmdToEyeViewOffset, eye_texes[1].HmdToEyeViewOffset };
OculusWrap.OVR.FrameTiming frameTiming = hmd.GetFrameTiming(0);
OculusWrap.OVR.TrackingState trackingState = hmd.GetTrackingState(frameTiming.DisplayMidpointSeconds);
OculusWrap.OVR.Posef[] exe_poses = new OculusWrap.OVR.Posef[2];
// Calculate the position and orientation of each eye.
oculus.CalcEyePoses(trackingState.HeadPose.ThePose, hmdToEyeViewOffsets, ref exe_poses);
UVSCR_variable.Set(UVSCR());
for (int eye_idx = 0; eye_idx < 2; eye_idx++)
{
OculusWrap.OVR.EyeType eye = (OculusWrap.OVR.EyeType)eye_idx;
EyeTexture eye_tex = eye_texes[eye_idx];
layer_eye_fov.RenderPose[eye_idx] = exe_poses[eye_idx];
// Retrieve the index of the active texture and select the next texture as being active next.
int tex_idx = eye_tex.SwapTextureSet.CurrentIndex++;
ctx.OutputMerger.SetRenderTargets(eye_tex.DepthStencilView, eye_tex.RenderTargetViews[tex_idx]);
ctx.ClearDepthStencilView(eye_tex.DepthStencilView, DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, 1.0f, 0);
ctx.ClearRenderTargetView(eye_tex.RenderTargetViews[tex_idx], ScreenColor);
ctx.Rasterizer.SetViewport(eye_tex.Viewport);
UpdateTransform(exe_poses[eye_idx], eye_tex.FieldOfView);
DrawFigure();
}
hmd.SubmitFrame(0, layers);
ctx.CopyResource(mtex, buf0);
swap_chain.Present(0, PresentFlags.None);
}
public void Present()
{
if (!Initialized)
{
return;
}
cam.Update();
DeviceContext.InputAssembler.InputLayout = Detail.Shaders.InputLayout3D;
DeviceContext.VertexShader.SetShader(Detail.Shaders.VertexShader3D, null, 0);
DeviceContext.VertexShader.SetConstantBuffer(0, cam.TransformBuffer);
DeviceContext.PixelShader.SetShaderResource(0, WhiteView);
foreach (var scene in scenes)
{
if (scene.Enabled)
{
scene.Draw();
}
}
DeviceContext.InputAssembler.InputLayout = Detail.Shaders.InputLayout2D;
DeviceContext.VertexShader.SetShader(Detail.Shaders.VertexShader2D, null, 0);
DeviceContext.VertexShader.SetConstantBuffer(0, transfBuffer);
DeviceContext.PixelShader.SetShader(Detail.Shaders.PixelShader, null, 0);
foreach (var gbuf in gbufs)
{
if (gbuf.Enabled)
{
gbuf.Draw();
}
}
swapChain.Present(1, PresentFlags.None);
}
public void Present()
{
swapChain.Present(0, PresentFlags.None);
}
public void Present()
{
RenderTarget.EndDraw();
swapChain.Present(0, PresentFlags.None);
}
public void Present()
{
swapChain.Present(1, DXGI.PresentFlags.None);
}
private void RenderCallback()
{
renderer.Render();
swapChain.Present(1, DXGI.PresentFlags.None);
}
public void EndDraw()
{
renderTarget.EndDraw();
swapChain.Present(0, DXGI.PresentFlags.None);
}
public void RenderCallback()
{
//RenderBuffer = RequestFrame();
DrawBytes(RenderBuffer);
swapChain.Present(1, PresentFlags.None);
}