/// <summary>
/// 描画処理を行います
/// </summary>
/// <param name="alphaBlendContext"></param>
protected override void DrawImpl(AlphaBlendContext alphaBlendContext)
{
var initialAlpha = alphaBlendContext.Alpha;
var initialDepth = alphaBlendContext.SRTDepth;
manager.Draw((filename, structure) =>
{
var ir = resourceManager.GetResource <ImageResourceBase>(filename);
if (ir != null)
{
alphaBlendContext.Texture = ir.Texture;
alphaBlendContext.Vertex = ir.Vertex;
alphaBlendContext.Alpha = initialAlpha * structure.ComposedAlpha;
if (structure.ComposedBlendMode != BlendMode.None)
{
alphaBlendContext.BlendMode = structure.ComposedBlendMode;
}
alphaBlendContext.SRTDepth = initialDepth + 1;
foreach (var matrix in structure.ComposedMatrices)
{
alphaBlendContext.SetSRT(matrix, alphaBlendContext.SRTDepth++);
}
var pos = new Vector2(-ir.Width / 2, -ir.Height / 2);
if (Alignment == EffectAlignment.TopLeft)
{
pos = Vector2.Zero;
}
alphaBlendContext.SetSRT(Matrix.Translation(new Vector3(pos, 0)), alphaBlendContext.SRTDepth);
device.GetModule <AlphaBlend>().Draw(device, alphaBlendContext);
}
});
}
public AlphaBlendContext Clone(AlphaBlendContext context)
{
var newContext = Get();
context.Clone(newContext);
return(newContext);
}
/// <summary>
/// 描画します
/// </summary>
/// <param name="alphaBlendContext">コンテキスト</param>
/// <param name="startX">表示をはじめるピクセルのx座標(0からwidth)</param>
/// <param name="endX">表示をおえるピクセルのx座標(0からwidthかつsx以上)</param>
public void Draw(AlphaBlendContext alphaBlendContext, float startX, float endX)
{
if (Hidden || isSpace)
{
return;
}
if (prevPosition != Position || prevStartX != startX || prevEndX != endX)
{
prevPosition = Position;
prevStartX = startX;
prevEndX = endX;
float posX0 = Position.X + startX, posX1 = Position.X + endX,
posY0 = Position.Y, posY1 = Position.Y + cci.Height;
var rect = cci.GetActualUVRectangle(startX / (float)cci.Width, 0, endX / (float)cci.Width, 1);
vertices.Write(new[] {
new ColoredTexturedVertex(new Vector3(posX0, posY0, 0.5f), rect.TopLeft),
new ColoredTexturedVertex(new Vector3(posX1, posY0, 0.5f), rect.TopRight),
new ColoredTexturedVertex(new Vector3(posX0, posY1, 0.5f), rect.BottomLeft),
new ColoredTexturedVertex(new Vector3(posX1, posY1, 0.5f), rect.BottomRight)
});
}
alphaBlendContext.Texture = cci.Texture;
alphaBlendContext.Vertex = vertices;
device.GetModule <AlphaBlend>().Draw(device, alphaBlendContext);
}
/// <summary>
/// 描画処理を行います
/// </summary>
/// <param name="alphaBlendContext"></param>
protected override void DrawImpl(AlphaBlendContext alphaBlendContext)
{
if (imageResource == null)
{
return;
}
var initialAlpha = alphaBlendContext.Alpha;
var initialDepth = alphaBlendContext.SRTDepth;
alphaBlendContext.Texture = imageResource.Texture;
alphaBlendContext.Vertex = imageResource.Vertex;
alphaBlendContext.Alpha = initialAlpha * effestState.ComposedAlpha;
alphaBlendContext.SRTDepth = initialDepth + 1;
if (effestState.ComposedBlendMode != BlendMode.None)
{
alphaBlendContext.BlendMode = effestState.ComposedBlendMode;
}
foreach (var matrix in effestState.ComposedMatrices)
{
alphaBlendContext.SetSRT(matrix, alphaBlendContext.SRTDepth++);
}
var pos = new SharpDX.Vector2(-imageResource.Width / 2, -imageResource.Height / 2);
alphaBlendContext.SetSRT(SharpDX.Matrix.Translation(new SharpDX.Vector3(pos, 0)), alphaBlendContext.SRTDepth);
device.GetModule <AlphaBlend>().Draw(device, alphaBlendContext);
}
/// <summary>
/// 描画できるかどうかイベントで判定します。
/// </summary>
/// <returns></returns>
protected virtual bool OnCanDrawEvent(AlphaBlendContext alphaBlendContext, int depth, int childIndex)
{
if (CanDraw != null)
{
return(CanDraw(this, alphaBlendContext, depth, childIndex));
}
return(true);
}
/// <summary>
/// 描画します
/// </summary>
public void Draw(AlphaBlendContext alphaBlendContext)
{
if (Hidden || isSpace)
{
return;
}
Draw(alphaBlendContext, 0, cci.Width);
}
/// <summary>
/// 描画します。
/// </summary>
/// <param name="alphaBlendContext"></param>
protected override void DrawImpl(AlphaBlendContext alphaBlendContext)
{
while (contexts.Count > 0)
{
var context = contexts.Dequeue();
context.GameComponent.DrawInternal(context.AlphaBlendContext, context.Depth);
}
}
/// <summary>
/// 描画の処理
/// </summary>
/// <param name="alphaBlendContext"></param>
protected override void DrawImpl(AlphaBlendContext alphaBlendContext)
{
alphaBlendContext.Texture = imageResource.Texture;
foreach (var vertices in numberVertices)
{
alphaBlendContext.Vertex = vertices;
device.GetModule <AlphaBlend>().Draw(device, alphaBlendContext);
}
}
/// <summary>
/// 追加します。
/// </summary>
/// <param name="gameComponent"></param>
/// <param name="alphaBlendContext"></param>
/// <param name="depth"></param>
public void Add(GameComponent gameComponent, AlphaBlendContext alphaBlendContext, int depth)
{
contexts.Enqueue(new Context
{
GameComponent = gameComponent,
AlphaBlendContext = device.GetModule <AlphaBlendContextCache>().Clone(alphaBlendContext),
Depth = depth
});
}
protected override void DrawImpl(AlphaBlendContext alphaBlendContext)
{
alphaBlendContext.Texture = markConnectionCommon.ImageResource.Texture;
foreach (var vertex in vertices)
{
alphaBlendContext.Vertex = vertex;
device.GetModule <AlphaBlend>().Draw(device, alphaBlendContext, PrimitiveType.TriangleStrip, drawCount - 2,
(MarkConnectionCommon.SplitCount - drawCount) / 2, drawCount);
}
}
protected override void DrawImpl(AlphaBlendContext alphaBlendContext)
{
TextureBase texture;
if ((texture = Texture) == null)
{
return;
}
alphaBlendContext.Texture = texture;
alphaBlendContext.Vertex = vertices;
device.GetModule <AlphaBlend>().Draw(device, alphaBlendContext);
}
protected override void DrawImpl(AlphaBlendContext alphaBlendContext)
{
alphaBlendContext.Texture = trace.ImageResource.Texture;
if (drawVerticesCount1 > 2)
{
alphaBlendContext.Vertex = vertices1;
device.GetModule <AlphaBlend>().Draw(device, alphaBlendContext, PrimitiveType.TriangleStrip, drawVerticesCount1 - 2, 0, drawVerticesCount1);
}
if (drawVerticesCount2 > 2)
{
alphaBlendContext.Vertex = vertices2;
device.GetModule <AlphaBlend>().Draw(device, alphaBlendContext, PrimitiveType.TriangleStrip, drawVerticesCount2 - 2, 0, drawVerticesCount2);
}
}
/// <summary>
/// 描画する
/// </summary>
/// <param name="alphaBlendContext"></param>
/// <param name="depth"></param>
/// <param name="childIndex"></param>
protected virtual void Draw(AlphaBlendContext alphaBlendContext, int depth, int childIndex)
{
if (disposed || Hidden || alphaBlendContext.Alpha <= 0 || !OnCanDraw(alphaBlendContext, depth, childIndex) || !OnCanDrawEvent(alphaBlendContext, depth, childIndex))
{
return;
}
if (PostDrawManager != null)
{
PostDrawManager.Add(this, alphaBlendContext, depth);
}
else
{
DrawInternal(alphaBlendContext, depth);
}
}
private void DrawWithSpare(AlphaBlendContext alphaBlendContext)
{
float sum = 0;
for (int i = 0; i < chars.Length; i++)
{
if (chars[i].Width + sum + sparechar.Width <= maxwidth)
{
sum += chars[i].Width;
chars[i].Draw(alphaBlendContext);
}
else
{
sparechar.Position = chars[i].Position;
sparechar.Draw(alphaBlendContext);
break;
}
}
}
public AlphaBlendContext Get()
{
AlphaBlendContext ret;
lock (allContexts)
{
if (allContexts.Count <= gotIndex)
{
ret = new AlphaBlendContext();
allContexts.Add(ret);
}
else
{
ret = allContexts[gotIndex];
ret.Initialize();
}
gotIndex++;
}
return(ret);
}
/// <summary>
/// 子要素を描画します。
/// </summary>
/// <param name="alphaBlendContext"></param>
/// <param name="currentAlpha"></param>
/// <param name="currentBlendMode"></param>
/// <param name="currentFilterCount"></param>
/// <param name="depth"></param>
protected virtual void DrawChildrenImpl(AlphaBlendContext alphaBlendContext, float currentAlpha, BlendMode currentBlendMode, int currentFilterCount, int depth)
{
if (Clip != null)
{
Matrix m = Matrix.Identity;
for (var i = 0; i < alphaBlendContext.SRTDepth + 1; i++)
{
m *= alphaBlendContext.SRTS[i];
}
for (int i = children.Count - 1; i >= 0; i--)
{
var top = Vector2.TransformCoordinate(children[i].Position, m).Y;
var bottom = Vector2.TransformCoordinate(children[i].Position + new Vector2(0, children[i].Height), m).Y;
if ((bottom < Clip.PositionY) || top > (Clip.PositionY + Clip.Height))
{
continue;
}
alphaBlendContext.Alpha = currentAlpha * children[i].Alpha;
alphaBlendContext.BlendMode = currentBlendMode;
alphaBlendContext.FilterCount = currentFilterCount;
if (OnCanDrawChild(alphaBlendContext, depth, i) && OnCanDrawChildEvent(alphaBlendContext, depth, i))
{
children[i].Draw(alphaBlendContext, depth, i);
}
}
}
else
{
for (int i = children.Count - 1; i >= 0; i--)
{
alphaBlendContext.Alpha = currentAlpha * children[i].Alpha;
alphaBlendContext.BlendMode = currentBlendMode;
alphaBlendContext.FilterCount = currentFilterCount;
if (OnCanDrawChild(alphaBlendContext, depth, i) && OnCanDrawChildEvent(alphaBlendContext, depth, i))
{
children[i].Draw(alphaBlendContext, depth, i);
}
}
}
}
protected override bool OnCanDraw(AlphaBlendContext alphaBlendContext, int depth, int childIndex)
{
return(displayNum >= 2);
}
protected override bool OnCanDraw(AlphaBlendContext alphaBlendContext, int depth, int childIndex)
{
return(!(mk1.Hidden || mk2.Hidden || mk1.ColorHidden || mk2.ColorHidden));
}
protected override bool OnCanDraw(AlphaBlendContext alphaBlendContext, int depth, int childIndex)
{
return(resource != null && rectangleWidth > 0 && rectangleHeight > 0 && borderThickness > 0);
}
protected override bool OnCanDraw(AlphaBlendContext alphaBlendContext, int depth, int childIndex)
{
return(initialized);
}
protected override bool OnCanDraw(AlphaBlendContext alphaBlendContext, int depth, int childIndex)
{
return(!(PPDSetting.Setting.TextBoxDisabled || Hidden || (DrawOnlyFocus && !Focused)));
}
protected override void DrawImpl(AlphaBlendContext alphaBlendContext)
{
//host.SetClipping((int)this.ScreenPos.X - thickness, (int)this.ScreenPos.Y - thickness, (int)TextBoxWidth + caretMargin + 2 * thickness, (int)TextBoxHeight + 2 * thickness + caretMargin);
//host.RestoreClipping();
}
protected override bool OnCanDraw(AlphaBlendContext alphaBlendContext, int depth, int childIndex)
{
return(allocator != null && allocator.TextureCreated);
}
internal void DrawInternal(AlphaBlendContext alphaBlendContext, int depth)
{
if (Clip != null)
{
Clip.GameHost.SetClipping(Clip.PositionX, Clip.PositionY, Clip.Width, Clip.Height);
}
if (preScreenFilters.Count > 0)
{
device.GetModule <AlphaBlend>().Flush();
foreach (var filter in preScreenFilters)
{
filter.Filter(device);
}
}
if (BlendMode != BlendMode.None)
{
alphaBlendContext.BlendMode = BlendMode;
}
alphaBlendContext.SetSRT(Matrix.Transformation2D(ScaleCenter, 0, Scale, RotationCenter, Rotation, Position + Offset), depth);
alphaBlendContext.SRTDepth = depth;
for (var i = colorFilters.Count - 1; i >= 0; i--)
{
alphaBlendContext.SetFilter(colorFilters[i], alphaBlendContext.FilterCount++);
}
var currentAlpha = alphaBlendContext.Alpha;
var currentBlendMode = alphaBlendContext.BlendMode;
var currentFilterCount = alphaBlendContext.FilterCount;
var enabledRenderMask = renderMasks.Where(m => m.Enabled).ToArray();
WorkspaceTexture renderMaskTexture = null;
if (enabledRenderMask.Length > 0 && !PPDSetting.Setting.ShaderDisabled)
{
device.GetModule <AlphaBlend>().Flush();
var renderTarget = device.GetRenderTarget();
renderMaskTexture = device.Workspace.Get();
device.SetRenderTarget(renderMaskTexture);
device.Clear();
DrawImpl(alphaBlendContext);
device.GetModule <AlphaBlend>().Flush();
device.SetRenderTarget(renderTarget);
}
WorkspaceTexture maskTexture = null;
if (Mask != null && !PPDSetting.Setting.ShaderDisabled)
{
device.GetModule <AlphaBlend>().Flush();
maskTexture = device.Workspace.Get();
var renderTarget = device.GetRenderTarget();
device.SetRenderTarget(maskTexture);
device.Clear(MaskType == MaskType.Include ? new Color4(0, 0, 0, 0) : new Color4(0, 0, 0, 1));
using (var handler = device.GetModule <AlphaBlend>().StartMaskGeneration(MaskType))
{
Mask.Draw(device.GetModule <AlphaBlendContextCache>().Clone(alphaBlendContext), depth + 1, 0);
}
device.SetRenderTarget(renderTarget);
alphaBlendContext.MaskTexture = maskTexture.Texture;
}
WorkspaceTexture filterTargetTexture = null;
WorkspaceTexture prevRenderTarget = null;
if (currentFilterCount >= 2 && !PPDSetting.Setting.ShaderDisabled)
{
device.GetModule <AlphaBlend>().Flush();
alphaBlendContext.Alpha = 1;
alphaBlendContext.BlendMode = BlendMode.Normal;
filterTargetTexture = device.Workspace.Get();
prevRenderTarget = device.GetRenderTarget();
device.SetRenderTarget(filterTargetTexture);
device.Clear(new Color4(0, 0, 0, 0));
}
DrawImpl(alphaBlendContext);
if (currentFilterCount >= 2 && !PPDSetting.Setting.ShaderDisabled)
{
device.GetModule <AlphaBlend>().Flush();
var context = device.GetModule <AlphaBlendContextCache>().Get();
context.Alpha = 1;
context.BlendMode = BlendMode.Normal;
context.Vertex = device.GetModule <ShaderCommon>().ScreenVertex;
context.SetSRT(Matrix.Identity, 0);
WorkspaceTexture renderedTexture = filterTargetTexture;
for (var i = currentFilterCount - 2; i >= 0; i--)
{
context.Texture = renderedTexture.Texture;
var newRenderTarget = device.Workspace.Get();
device.SetRenderTarget(newRenderTarget);
context.SetFilter(alphaBlendContext.Filters[i], 0);
context.FilterCount = 1;
device.GetModule <AlphaBlend>().Draw(device, context);
renderedTexture.Dispose();
renderedTexture = newRenderTarget;
if (i == 0)
{
context.Alpha = currentAlpha;
context.BlendMode = currentBlendMode;
context.Texture = renderedTexture.Texture;
context.FilterCount = 0;
device.SetRenderTarget(prevRenderTarget);
device.GetModule <AlphaBlend>().Draw(device, context);
}
}
if (renderedTexture != null)
{
renderedTexture.Dispose();
}
}
if (enabledRenderMask.Length > 0 && !PPDSetting.Setting.ShaderDisabled)
{
device.GetModule <AlphaBlend>().Flush();
foreach (var renderMask in enabledRenderMask)
{
renderMask.Draw(device, renderMaskTexture);
}
if (renderMaskTexture != null)
{
renderMaskTexture.Dispose();
}
}
DrawChildrenImpl(alphaBlendContext, currentAlpha, currentBlendMode, currentFilterCount, depth + 1);
if (Mask != null && !PPDSetting.Setting.ShaderDisabled)
{
alphaBlendContext.MaskTexture = null;
if (maskTexture != null)
{
maskTexture.Dispose();
}
}
alphaBlendContext.SRTDepth = depth;
alphaBlendContext.Alpha = currentAlpha;
alphaBlendContext.BlendMode = currentBlendMode;
alphaBlendContext.FilterCount = currentFilterCount;
AfterChildenDraw(alphaBlendContext);
if (postScreenFilters.Count > 0)
{
device.GetModule <AlphaBlend>().Flush();
foreach (var filter in postScreenFilters)
{
filter.Filter(device);
}
}
if (Clip != null)
{
Clip.GameHost.RestoreClipping();
}
}
/// <summary>
/// 描画します
/// </summary>
/// <param name="alphaBlendContext"></param>
protected override void DrawImpl(AlphaBlendContext alphaBlendContext)
{
alphaBlendContext.Texture = imageResource.Texture;
alphaBlendContext.Vertex = useCustomVertices ? vertices : imageResource.Vertex;
device.GetModule <AlphaBlend>().Draw(device, alphaBlendContext);
}
/// <summary>
/// 子を描画した後の描画の処理
/// </summary>
/// <param name="alphaBlendContext"></param>
protected virtual void AfterChildenDraw(AlphaBlendContext alphaBlendContext)
{
}
/// <summary>
/// 描画の処理
/// </summary>
/// <param name="alphaBlendContext"></param>
protected virtual void DrawImpl(AlphaBlendContext alphaBlendContext)
{
}
protected override bool OnCanDraw(AlphaBlendContext alphaBlendContext, int depth, int childIndex)
{
return(!Hidden && OverFocused);
}
/// <summary>
/// 描画するかどうかを返します
/// </summary>
/// <param name="alphaBlendContext"></param>
/// <param name="depth"></param>
/// <param name="childIndex"></param>
/// <returns></returns>
protected virtual bool OnCanDraw(AlphaBlendContext alphaBlendContext, int depth, int childIndex)
{
return(true);
}
protected override void Draw(AlphaBlendContext alphaBlendContext, int depth, int childIndex)
{
Drawing?.Invoke();
}
