internal void Draw(DrawCommand cmd)
{
somethingWasDrawn = true;
if (cmd.CommandType == DrawCommand.DrawCommandType.Texture)
{
cmd.Texture.IsDirty = false;
}
switch (cmd.CommandType)
{
case DrawCommand.DrawCommandType.String:
DrawString(cmd.Font, cmd.Text, cmd.Position, cmd.Color, cmd.Rotation, cmd.Origin, cmd.Scale, cmd.Effects, cmd.LayerDepth);
break;
case DrawCommand.DrawCommandType.Texture:
if (float.IsInfinity(cmd.Scale.X)) cmd.Scale.X = 0;
if (float.IsInfinity(cmd.Scale.Y)) cmd.Scale.Y = 0;
if (cmd.ShaderEffect != null)
{
Draw(cmd.Texture, cmd.Position, ref cmd.SourceRectangle, cmd.ShaderEffect, cmd.Rotation, cmd.Origin, cmd.Scale, cmd.Effects, cmd.LayerDepth);
}
else
{
Draw(cmd.Texture, cmd.Position, ref cmd.SourceRectangle, cmd.Color, cmd.Rotation, cmd.Origin, cmd.Scale, cmd.Effects, cmd.LayerDepth);
}
break;
}
}
internal override void Draw(DrawCommand cmd)
{
_childRenderer.Draw(cmd);
}
/// <summary>
/// Executes the rendering function.</summary>
/// <param name="cmd">The CMD.</param>
/// <param name="offset">The offset.</param>
internal void CallFunction(DrawCommand cmd, int offset)
{
float[] f = cmd.VertexBuffer;
switch (cmd.Function)
{
case Function.glColor3fv:
Gl.glColor3f(f[offset], f[offset + 1], f[offset + 2]);
break;
case Function.glNormal3fv:
Gl.glNormal3f(f[offset], f[offset + 1], f[offset + 2]);
break;
case Function.glTexCoord2fv:
Gl.glTexCoord2f(f[offset], f[offset + 1]);
break;
case Function.glVertex3fv:
Gl.glVertex3f(f[offset], f[offset + 1], f[offset + 2]);
break;
}
}
private void AddCommand(string bindingName, Function func)
{
ISubMesh submesh = this.As<ISubMesh>();
IEnumerable<IDataSet> datasets;
if (submesh != null)
{
datasets = submesh.DataSets;
}
else
{
IMesh mesh = TryGetMesh();
datasets = mesh.DataSets;
}
int bindingIndex = m_primitives.FindBinding(bindingName);
if (bindingIndex != -1)
{
// Find the data Set
foreach (IDataSet dataSet in datasets)
{
if (dataSet.Name == bindingName)
{
DrawCommand cmd = new DrawCommand(func, bindingIndex, dataSet.Data, dataSet.ElementSize);
m_commands.Add(cmd);
if (func == Function.glVertex3fv)
{
m_vxCommand = cmd;
}
break;
}
}
}
}
private void runShader(DrawCommand dc) //int penId, RenderTexture rtPos, Color color, float maxDist, bool preserveAlpha, bool smoothTip, float smoothTipExp, float width, float strength, float opacity, float fade, bool prevPainted, bool historyDecay, float historyDecayTime) {
{
if (!ensureTextures(dc.penId))
{
return;
}
RenderTexture rtHist = null;
RenderTexture rtOldPos = null;
PenData pen = null;
if (pens.TryGetValue(dc.penId, out pen))
{
rtHist = pen.rtHist;
rtOldPos = pen.rtOldPos;
if (dc.rtPos != null && (dc.strength > 0.0f || dc.opacity > 0.0f))
{
pen.lastDrawn = 3;
}
dc.prevPainted = pen.checkPrevPainted(dc.strength, dc.opacity, dc.color, dc.prevPainted, dc.smoothTip, dc.smoothTipExp);
}
texProcMat.SetTexture("_MainTex", rtCurrent);
texProcMat.SetTexture("_OrigTex", rtOriginal);
if (dc.prevPainted)
{
texProcMat.SetTexture("_HistTex", rtHist);
texProcMat.SetTexture("_CoordTexA", rtOldPos);
}
else
{
if (pen != null && pen.rtHist != null)
{
discardRT(pen.rtHist);
pen.rtHist = null;
rtHist = null;
}
texProcMat.SetTexture("_HistTex", null);
texProcMat.SetTexture("_CoordTexA", dc.rtPos);
}
if (dc.rtPos == null)
{
texProcMat.SetTexture("_CoordTexA", null);
}
texProcMat.SetTexture("_CoordTexB", dc.rtPos);
texProcMat.SetFloat("_Fade", dc.fade);
texProcMat.SetFloat("_SurfaceID", (float)id);
texProcMat.SetFloat("_MaxDist", dc.maxDist / (float)rtCurrent.width);
texProcMat.SetFloat("_PreserveAlpha", dc.preserveAlpha ? 1.0f : 0.0f);
texProcMat.SetColor("_PenColor", dc.color);
texProcMat.SetFloat("_PenThickness", dc.width / (float)rtCurrent.width);
texProcMat.SetFloat("_SmoothTip", dc.smoothTip ? 1.0f : 0.0f);
texProcMat.SetFloat("_SmoothExp", dc.smoothTipExp);
texProcMat.SetFloat("_Opacity", dc.opacity);
texProcMat.SetFloat("_EraserStrength", dc.strength);
texProcMat.SetTexture("_StampTex", dc.stampTexture);
Vector4 stampSize = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
stampSize.x = (dc.stampPixelSize.x / rtCurrent.width) * dc.stampScaleFactor.x;
stampSize.y = (dc.stampPixelSize.y / rtCurrent.width) * dc.stampScaleFactor.y;
texProcMat.SetVector("_StampSize", stampSize);
texProcMat.SetFloat("_StampAngle", dc.stampAngle);
texProcMat.SetFloat("_StampAlpha", dc.stampOpacity);
texProcMat.SetColor("_StampTint", dc.tintColor);
texProcMat.SetColor("_StampTintFactor", dc.enableTint ? dc.tintStrength : new Vector4(0.0f, 0.0f, 0.0f, 0.0f));
texProcMat.SetFloat("_HistoryWrite", 0.0f);
texProcMat.SetFloat("_HistoryTime", dc.historyDecay ? dc.historyDecayTime : 0.000001f);
if (pen != null)
{
float decay = dc.historyDecay ? Time.time - pen.lastTime : 0.0f;
texProcMat.SetFloat("_HistoryDecay", decay);
}
else
{
texProcMat.SetFloat("_HistoryDecay", 0.0f);
}
RenderTexture rtNew = RenderTexture.GetTemporary(rtCurrent.width, rtCurrent.height, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.sRGB);
if (rtNew.useMipMap)
{
rtNew.Release();
rtNew.useMipMap = false;
rtNew.Create();
}
rtNew.wrapMode = rtCurrent.wrapMode;
if (rtCurrent == targetMaterial.mainTexture)
{
Graphics.Blit(rtCurrent, rtNew, texProcMat);
}
else
{
Graphics.Blit(targetMaterial.mainTexture, rtNew, texProcMat);
}
targetMaterial.mainTexture = rtNew;
discardRT(rtCurrent);
rtCurrent = rtNew;
if (pen != null)
{
if ((dc.opacity > 0.0f && dc.opacity < 1.0f) || (dc.strength > 0.0f && dc.strength < 1.0f) || dc.smoothTip)
{
rtNew = RenderTexture.GetTemporary(rtCurrent.width, rtCurrent.height, 0, RenderTextureFormat.RGHalf, RenderTextureReadWrite.Linear);
if (rtNew.useMipMap)
{
rtNew.Release();
rtNew.useMipMap = false;
rtNew.Create();
}
rtNew.wrapMode = rtCurrent.wrapMode;
texProcMat.SetTexture("_MainTex", null);
texProcMat.SetTexture("_OrigTex", null);
texProcMat.SetTexture("_HistTex", rtHist);
texProcMat.SetFloat("_Fade", 0.0f);
texProcMat.SetColor("_PenColor", Color.white);
texProcMat.SetVector("_StampSize", new Vector2(0.0f, 0.0f));
texProcMat.SetFloat("_Opacity", 1.0f);
texProcMat.SetFloat("_EraserStrength", 0.0f);
pen.lastTime = Time.time;
texProcMat.SetFloat("_HistoryWrite", 1.0f);
Graphics.Blit(rtCurrent, rtNew, texProcMat);
discardRT(pen.rtHist);
pen.rtHist = rtNew;
}
else
{
discardRT(pen.rtHist);
pen.rtHist = null;
}
Graphics.Blit(dc.rtPos, pen.rtOldPos);
}
targetMaterial.renderQueue = renderQueue;
}
internal override void Draw(DrawCommand cmd)
{
somethingWasDrawn = true;
base.Draw(cmd);
_currentChildRenderer.Draw(cmd);
}
private static void InitLookup()
{
_lookup[(int)CommandType.Action] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
ActionCommand.Run(ref GetCommand <ActionCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.CompileShader] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
CompileShaderCommand.Run(ref GetCommand <CompileShaderCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.CreateBuffer] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
CreateBufferCommand.Run(ref GetCommand <CreateBufferCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.CreateProgram] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
CreateProgramCommand.Run(ref GetCommand <CreateProgramCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.CreateSampler] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
CreateSamplerCommand.Run(ref GetCommand <CreateSamplerCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.CreateSync] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
CreateSyncCommand.Run(ref GetCommand <CreateSyncCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.CreateTexture] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
CreateTextureCommand.Run(ref GetCommand <CreateTextureCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.GetCapabilities] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
GetCapabilitiesCommand.Run(ref GetCommand <GetCapabilitiesCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.PreFrame] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
PreFrameCommand.Run(ref GetCommand <PreFrameCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.ReportCounter] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
ReportCounterCommand.Run(ref GetCommand <ReportCounterCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.ResetCounter] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
ResetCounterCommand.Run(ref GetCommand <ResetCounterCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.UpdateCounters] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
UpdateCountersCommand.Run(ref GetCommand <UpdateCountersCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.BufferDispose] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
BufferDisposeCommand.Run(ref GetCommand <BufferDisposeCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.BufferGetData] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
BufferGetDataCommand.Run(ref GetCommand <BufferGetDataCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.BufferSetData] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
BufferSetDataCommand.Run(ref GetCommand <BufferSetDataCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.CounterEventDispose] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
CounterEventDisposeCommand.Run(ref GetCommand <CounterEventDisposeCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.CounterEventFlush] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
CounterEventFlushCommand.Run(ref GetCommand <CounterEventFlushCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.ProgramDispose] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
ProgramDisposeCommand.Run(ref GetCommand <ProgramDisposeCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.ProgramGetBinary] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
ProgramGetBinaryCommand.Run(ref GetCommand <ProgramGetBinaryCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.ProgramCheckLink] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
ProgramCheckLinkCommand.Run(ref GetCommand <ProgramCheckLinkCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SamplerDispose] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SamplerDisposeCommand.Run(ref GetCommand <SamplerDisposeCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.ShaderDispose] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
ShaderDisposeCommand.Run(ref GetCommand <ShaderDisposeCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.TextureCopyTo] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
TextureCopyToCommand.Run(ref GetCommand <TextureCopyToCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.TextureCopyToScaled] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
TextureCopyToScaledCommand.Run(ref GetCommand <TextureCopyToScaledCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.TextureCopyToSlice] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
TextureCopyToSliceCommand.Run(ref GetCommand <TextureCopyToSliceCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.TextureCreateView] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
TextureCreateViewCommand.Run(ref GetCommand <TextureCreateViewCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.TextureGetData] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
TextureGetDataCommand.Run(ref GetCommand <TextureGetDataCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.TextureRelease] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
TextureReleaseCommand.Run(ref GetCommand <TextureReleaseCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.TextureSetData] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
TextureSetDataCommand.Run(ref GetCommand <TextureSetDataCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.TextureSetDataSlice] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
TextureSetDataSliceCommand.Run(ref GetCommand <TextureSetDataSliceCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.TextureSetStorage] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
TextureSetStorageCommand.Run(ref GetCommand <TextureSetStorageCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.WindowPresent] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
WindowPresentCommand.Run(ref GetCommand <WindowPresentCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.Barrier] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
BarrierCommand.Run(ref GetCommand <BarrierCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.BeginTransformFeedback] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
BeginTransformFeedbackCommand.Run(ref GetCommand <BeginTransformFeedbackCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.ClearBuffer] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
ClearBufferCommand.Run(ref GetCommand <ClearBufferCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.ClearRenderTargetColor] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
ClearRenderTargetColorCommand.Run(ref GetCommand <ClearRenderTargetColorCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.ClearRenderTargetDepthStencil] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
ClearRenderTargetDepthStencilCommand.Run(ref GetCommand <ClearRenderTargetDepthStencilCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.CommandBufferBarrier] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
CommandBufferBarrierCommand.Run(ref GetCommand <CommandBufferBarrierCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.CopyBuffer] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
CopyBufferCommand.Run(ref GetCommand <CopyBufferCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.DispatchCompute] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
DispatchComputeCommand.Run(ref GetCommand <DispatchComputeCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.Draw] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
DrawCommand.Run(ref GetCommand <DrawCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.DrawIndexed] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
DrawIndexedCommand.Run(ref GetCommand <DrawIndexedCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.DrawTexture] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
DrawTextureCommand.Run(ref GetCommand <DrawTextureCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.EndHostConditionalRendering] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
EndHostConditionalRenderingCommand.Run(renderer);
_lookup[(int)CommandType.EndTransformFeedback] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
EndTransformFeedbackCommand.Run(ref GetCommand <EndTransformFeedbackCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.MultiDrawIndirectCount] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
MultiDrawIndirectCountCommand.Run(ref GetCommand <MultiDrawIndirectCountCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.MultiDrawIndexedIndirectCount] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
MultiDrawIndexedIndirectCountCommand.Run(ref GetCommand <MultiDrawIndexedIndirectCountCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetAlphaTest] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetAlphaTestCommand.Run(ref GetCommand <SetAlphaTestCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetBlendState] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetBlendStateCommand.Run(ref GetCommand <SetBlendStateCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetDepthBias] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetDepthBiasCommand.Run(ref GetCommand <SetDepthBiasCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetDepthClamp] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetDepthClampCommand.Run(ref GetCommand <SetDepthClampCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetDepthMode] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetDepthModeCommand.Run(ref GetCommand <SetDepthModeCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetDepthTest] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetDepthTestCommand.Run(ref GetCommand <SetDepthTestCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetFaceCulling] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetFaceCullingCommand.Run(ref GetCommand <SetFaceCullingCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetFrontFace] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetFrontFaceCommand.Run(ref GetCommand <SetFrontFaceCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetStorageBuffers] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetStorageBuffersCommand.Run(ref GetCommand <SetStorageBuffersCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetTransformFeedbackBuffers] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetTransformFeedbackBuffersCommand.Run(ref GetCommand <SetTransformFeedbackBuffersCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetUniformBuffers] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetUniformBuffersCommand.Run(ref GetCommand <SetUniformBuffersCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetImage] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetImageCommand.Run(ref GetCommand <SetImageCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetIndexBuffer] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetIndexBufferCommand.Run(ref GetCommand <SetIndexBufferCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetLineParameters] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetLineParametersCommand.Run(ref GetCommand <SetLineParametersCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetLogicOpState] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetLogicOpStateCommand.Run(ref GetCommand <SetLogicOpStateCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetPatchParameters] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetPatchParametersCommand.Run(ref GetCommand <SetPatchParametersCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetPointParameters] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetPointParametersCommand.Run(ref GetCommand <SetPointParametersCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetPolygonMode] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetPolygonModeCommand.Run(ref GetCommand <SetPolygonModeCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetPrimitiveRestart] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetPrimitiveRestartCommand.Run(ref GetCommand <SetPrimitiveRestartCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetPrimitiveTopology] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetPrimitiveTopologyCommand.Run(ref GetCommand <SetPrimitiveTopologyCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetProgram] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetProgramCommand.Run(ref GetCommand <SetProgramCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetRasterizerDiscard] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetRasterizerDiscardCommand.Run(ref GetCommand <SetRasterizerDiscardCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetRenderTargetColorMasks] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetRenderTargetColorMasksCommand.Run(ref GetCommand <SetRenderTargetColorMasksCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetRenderTargetScale] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetRenderTargetScaleCommand.Run(ref GetCommand <SetRenderTargetScaleCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetRenderTargets] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetRenderTargetsCommand.Run(ref GetCommand <SetRenderTargetsCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetSampler] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetSamplerCommand.Run(ref GetCommand <SetSamplerCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetScissor] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetScissorCommand.Run(ref GetCommand <SetScissorCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetStencilTest] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetStencilTestCommand.Run(ref GetCommand <SetStencilTestCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetTexture] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetTextureCommand.Run(ref GetCommand <SetTextureCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetUserClipDistance] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetUserClipDistanceCommand.Run(ref GetCommand <SetUserClipDistanceCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetVertexAttribs] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetVertexAttribsCommand.Run(ref GetCommand <SetVertexAttribsCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetVertexBuffers] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetVertexBuffersCommand.Run(ref GetCommand <SetVertexBuffersCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.SetViewports] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
SetViewportsCommand.Run(ref GetCommand <SetViewportsCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.TextureBarrier] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
TextureBarrierCommand.Run(ref GetCommand <TextureBarrierCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.TextureBarrierTiled] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
TextureBarrierTiledCommand.Run(ref GetCommand <TextureBarrierTiledCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.TryHostConditionalRendering] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
TryHostConditionalRenderingCommand.Run(ref GetCommand <TryHostConditionalRenderingCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.TryHostConditionalRenderingFlush] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
TryHostConditionalRenderingFlushCommand.Run(ref GetCommand <TryHostConditionalRenderingFlushCommand>(memory), threaded, renderer);
_lookup[(int)CommandType.UpdateRenderScale] = (Span <byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
UpdateRenderScaleCommand.Run(ref GetCommand <UpdateRenderScaleCommand>(memory), threaded, renderer);
}
/// <summary>
/// Draw a text primitive and merge the result to the text mesh.
/// </summary>
/// <param name="primitive"></param>
/// <param name="rect"></param>
/// <param name="style"></param>
public void DrawText(TextPrimitive primitive, Rect rect, StyleRuleSet style)
{
//check if we need to rebuild the glyph data of this text primitive
var needRebuild = this.CheckTextPrimitive(primitive, style);
var fontFamily = style.FontFamily;
var fontSize = style.FontSize;
var fontColor = style.FontColor;
//build text mesh
if (needRebuild)
{
primitive.Glyphs.Clear();
primitive.Offsets.Clear();
primitive.FontSize = fontSize;
primitive.FontFamily = fontFamily;
primitive.FontStyle = style.FontStyle;
primitive.FontWeight = style.FontWeight;
var fontStretch = FontStretch.Normal;
var fontStyle = style.FontStyle;
var fontWeight = style.FontWeight;
var textAlignment = (TextAlignment)style.Get <int>(GUIStyleName.TextAlignment);//TODO apply text alignment
var textContext = new OSImplentation.TypographyTextContext(primitive.Text,
fontFamily,
fontSize,
fontStretch,
fontStyle,
fontWeight,
(int)rect.Size.Width,
(int)rect.Size.Height,
textAlignment);
textContext.Build(rect.Location);
primitive.Offsets.AddRange(textContext.GlyphOffsets);
foreach (var character in primitive.Text)
{
Typography.OpenFont.Glyph glyph = OSImplentation.TypographyTextContext.LookUpGlyph(fontFamily, character);
Typography.OpenFont.GlyphLoader.Read(glyph, out var polygons, out var bezierSegments);
var glyphData = GlyphCache.Default.GetGlyph(character, fontFamily, fontStyle, fontWeight);
if (glyphData == null)
{
glyphData = GlyphCache.Default.AddGlyph(character, fontFamily, fontStyle, fontWeight, polygons, bezierSegments);
}
Debug.Assert(glyphData != null);
primitive.Glyphs.Add(glyphData);
}
}
//FIXME Should each text segment consume a draw call? NO!
//add a new draw command
DrawCommand cmd = new DrawCommand();
cmd.ClipRect = Rect.Big;
cmd.TextureData = null;
this.TextMesh.Commands.Add(cmd);
var oldIndexBufferCount = this.TextMesh.IndexBuffer.Count;
var scale = OSImplentation.TypographyTextContext.GetScale(fontFamily, fontSize);
int index = -1;
// get glyph data from typeface
foreach (var character in primitive.Text)
{
index++;
var glyphData = primitive.Glyphs[index];
Vector glyphOffset = primitive.Offsets[index];
this.TextMesh.Append((Vector)rect.Location + primitive.Offset, glyphData, glyphOffset, scale, fontColor, false);
}
var newIndexBufferCount = this.TextMesh.IndexBuffer.Count;
// Update command
var command = this.TextMesh.Commands[this.TextMesh.Commands.Count - 1];
command.ElemCount += newIndexBufferCount - oldIndexBufferCount;
this.TextMesh.Commands[this.TextMesh.Commands.Count - 1] = command;
}
public Map()
{
_selectObjectCommand = ReactiveCommand.Create <object>(x => { SelectedObject = x; });
DrawCommand = ReactiveCommand.Create(() =>
{
Children.Clear();
if (SimulationService == null)
{
return;
}
foreach (var cityRoad in SimulationService.CityMap.Roads)
{
Children.Add(CreateElementForRoad(cityRoad));
}
foreach (var cityPlace in SimulationService.CityMap.Places)
{
Children.Add(CreateElementForPlace(cityPlace));
Children.Add(LabelPlace(cityPlace));
}
RenderTransform = new TransformGroup
{
Children = new Transforms {
new TranslateTransform(500, 500), new ScaleTransform(0.5, 0.5)
}
};
});
this.WhenAnyValue(x => x.SimulationService)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(x =>
{
if (x == null)
{
return;
}
DrawCommand.Execute(null);
RecolorRoads();
x.MinuteInterval
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ =>
{
RecolorRoads();
MoveVehicles();
});
x.DayInterval
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ =>
{
foreach (var vehicleView in Children.OfType <Button>()
.Where(x => x.DataContext is IVehicle)
.ToArray())
{
Children.Remove(vehicleView);
}
foreach (var vehicle in SimulationService.Solutions.Select(x => x.Vehicle))
{
Children.Add(CreateElementForVehicle(vehicle));
}
});
});
}
static public void Remove(DrawCommand drawFunc)
{
drawDelegate -= drawFunc;
}
static public void Add(DrawCommand drawFunc)
{
drawDelegate += drawFunc;
}
