//============================================================
// <T>开始处理。</T>
//
// @param x 横向偏移
// @param y 纵向偏移
//============================================================
public void Begin(float x, float y, float width, float height)
{
_nativeParameters.ContentBounds = new RectangleF(0, 0, width, height);
_nativeParameters.Opacity = 1;
_deviceTarget.Transform = Matrix3x2.Translation(x, y);
_deviceTarget.PushLayer(_native, _nativeParameters);
}
// 進行と描画
public void 進行描画する(DeviceContext d2ddc)
{
var 描画矩形 = new RectangleF(122f, 313f, 240f, 30f);
// 初回または名前が変更された場合に TextLayout を再構築する。
if ((this._TextLayout is null) || (this._前回表示した名前 != this.前))
{
const float 最大幅 = 1000f;
this._TextLayout = new TextLayout(Global.GraphicResources.DWriteFactory, this.前, this._TextFormat, 最大幅, 30f)
{
TextAlignment = TextAlignment.Leading,
WordWrapping = WordWrapping.NoWrap, // 最大幅を超えても改行しない（はみ出し分は切り捨て）
};
float 文字列幅dpx = this._TextLayout.Metrics.WidthIncludingTrailingWhitespace;
this._拡大率X = (文字列幅dpx <= 描画矩形.Width) ? 1.0f : (描画矩形.Width / 文字列幅dpx);
}
var preTrans = d2ddc.Transform;
d2ddc.Transform =
Matrix3x2.Scaling(this._拡大率X, 1.0f) * // 拡大縮小
Matrix3x2.Translation(描画矩形.X, 描画矩形.Y) * // 平行移動
preTrans;
// 座標（描画矩形）は拡大率の影響をうけるので、このメソッドではなく、Matrix3x2.Translation() で設定するほうが楽。
d2ddc.DrawTextLayout(Vector2.Zero, this._TextLayout, this._文字色);
d2ddc.Transform = preTrans;
// 更新
this._前回表示した名前 = this.前;
}
public void Draw(D2D.RenderTarget target, float fontSize, string text, PointF point, DW.TextAlignment alignment,
D2D.SolidColorBrush fillBrush, D2D.SolidColorBrush edgeBrush, float edgeWidth)
{
D2D.Geometry geometry = CreateGeometry(fontSize, text);
switch (alignment)
{
case DW.TextAlignment.Leading:
target.Transform = Matrix3x2.Translation(point);
break;
case DW.TextAlignment.Center:
{
RectangleF bounds = D2D.Geometry.GetBounds(geometry);
target.Transform = Matrix3x2.Translation(point.X - bounds.Width / 2f, point.Y);
}
break;
case DW.TextAlignment.Trailing:
{
RectangleF bounds = D2D.Geometry.GetBounds(geometry);
target.Transform = Matrix3x2.Translation(point.X - bounds.Width, point.Y);
}
break;
}
target.DrawGeometry(geometry, edgeBrush, edgeWidth);
target.FillGeometry(geometry, fillBrush);
}
protected override void OnRender(WindowRenderTarget renderTarget)
{
RectF bounds = new RectF(new PointF(), renderTarget.Size);
renderTarget.FillRect(_gridPatternBrush, bounds);
RectF brushRect = new RectF(0, 0, 150, 150);
RectF textRect = new RectF(0, 165, 150, 35);
renderTarget.Transform = Matrix3x2.Translation(new SizeF(5.5f, 5.5f));
renderTarget.FillRect(_yellowGreenBrush, brushRect);
renderTarget.DrawRect(_blackBrush, 1, brushRect);
renderTarget.DrawText("SolidColorBrush", this._textFormat, textRect, this._blackBrush, DrawTextOptions.None, MeasuringMode.Natural);
renderTarget.Transform = Matrix3x2.Translation(new SizeF(200.5f, 5.5f));
renderTarget.FillRect(_linearGradientBrush, brushRect);
renderTarget.DrawRect(_blackBrush, 1, brushRect);
renderTarget.DrawText("LinearGradientBrush", this._textFormat, textRect, this._blackBrush, DrawTextOptions.None, MeasuringMode.Natural);
renderTarget.Transform = Matrix3x2.Translation(new SizeF(5.5f, 200.5f));
renderTarget.FillEllipse(_radialGradientBrush, new Ellipse(brushRect));
renderTarget.DrawEllipse(_blackBrush, 1, new Ellipse(brushRect));
renderTarget.DrawText("RadialGradientBrush", this._textFormat, textRect, this._blackBrush, DrawTextOptions.None, MeasuringMode.Natural);
renderTarget.Transform = Matrix3x2.Translation(new SizeF(200.5f, 200.5f));
renderTarget.FillRect(_bitmapBrush, brushRect);
renderTarget.DrawRect(_blackBrush, 1, brushRect);
renderTarget.DrawText("BitmapBrush", this._textFormat, textRect, this._blackBrush, DrawTextOptions.None, MeasuringMode.Natural);
}
private void DrawArrow(Brush brush, Brush borderBrush, RawVector2 arrowTip, float rotAngle, float flowSize, bool moveForward, float borderWidth)
{
var transform = Surface.RenderTarget2D.Transform;
var scaleVector = new Vector2(flowSize, flowSize);
if (!moveForward)
{
rotAngle -= (float)Math.PI;
}
var translationVector = arrowTip + ((Matrix3x2)Surface.RenderTarget2D.Transform).TranslationVector;
var scale = Matrix3x2.Scaling(scaleVector);
var rotation = Matrix3x2.Rotation(rotAngle, Vector2.Zero);
var translation = Matrix3x2.Translation(translationVector);
Surface.RenderTarget2D.Transform = scale * rotation * translation;
if (brush != null)
{
Surface.RenderTarget2D.FillGeometry(LineFlow, brush);
}
if (borderBrush != null)
{
Surface.RenderTarget2D.DrawGeometry(LineFlow, borderBrush, borderWidth);
}
Surface.RenderTarget2D.Transform = transform;
}
private void renderPorts(
IEnumerable <IDraggable> ports,
Matrix3x2 modelTransform,
int x,
int y,
int size,
int stride)
{
var portTransform = Matrix3x2.Translation(x, y);
foreach (var port in ports)
{
port.X = (int)(modelTransform.TranslationVector.X + portTransform.TranslationVector.X);
port.Y = (int)(modelTransform.TranslationVector.Y + portTransform.TranslationVector.Y);
port.Width = size;
port.Height = size;
applyTransform(modelTransform * portTransform);
var sinkTitle = new TextLayout(context.FontFactory, port.Name, portFont, 10000f, 0f);
context.RenderTarget.DrawTextLayout(Vector2.Zero, sinkTitle, boxBrush);
context.RenderTarget.DrawRectangle(new RectangleF
{
Left = 0,
Top = 0,
Width = size,
Height = size
}, boxBrush, 1f / zoom);
portTransform *= Matrix3x2.Translation(0f, stride);
}
}
public void DrawTexture(string textureKey, RectangleF rect, float rotation = 0.0f, float opacity = 1.0f)
{
var textureEntry = this.textureManager.GetTexture(textureKey);
if (textureEntry == null)
{
throw new TextureNotFoundException(textureKey);
}
if (rotation == 0.0f)
{
this.context.RenderTarget.DrawBitmap(textureEntry.Bitmap, rect, opacity, BitmapInterpolationMode.Linear);
}
else
{
var mtx = this.context.RenderTarget.Transform;
var scaling = new Vector2((float)rect.Width / textureEntry.Bitmap.Size.Width, (float)rect.Height / textureEntry.Bitmap.Size.Height);
this.context.RenderTarget.Transform = Matrix3x2.Translation(-textureEntry.Center)
* Matrix3x2.Rotation(rotation)
* Matrix3x2.Translation(textureEntry.Center)
* Matrix3x2.Scaling(scaling)
* Matrix3x2.Translation(rect.Location);
this.context.RenderTarget.DrawBitmap(textureEntry.Bitmap, opacity, BitmapInterpolationMode.Linear);
this.context.RenderTarget.Transform = mtx;
}
}
public override Result DrawStrikethrough(object clientDrawingContext, float baselineOriginX, float baselineOriginY, ref Strikethrough strikethrough, ComObject clientDrawingEffect)
{
PathGeometry pg = new PathGeometry(this.factory);
GeometrySink sink = pg.Open();
Vector2 topLeft = new Vector2(0.0f, strikethrough.Offset);
sink.BeginFigure(topLeft, FigureBegin.Filled);
topLeft.X += strikethrough.Width;
sink.AddLine(topLeft);
topLeft.Y += strikethrough.Thickness;
sink.AddLine(topLeft);
topLeft.X -= strikethrough.Width;
sink.AddLine(topLeft);
sink.EndFigure(FigureEnd.Closed);
sink.Close();
TransformedGeometry tg = new TransformedGeometry(this.factory, pg, Matrix3x2.Translation(baselineOriginX, baselineOriginY) * Matrix3x2.Scaling(1.0f, -1.0f));
pg.Dispose();
sink.Dispose();
this.AddGeometry(tg);
return(Result.Ok);
}
public override Result DrawUnderline(object clientDrawingContext, float baselineOriginX, float baselineOriginY, ref Underline underline, ComObject clientDrawingEffect)
{
using (PathGeometry pg = new PathGeometry(this.factory))
{
using (GeometrySink sink = pg.Open())
{
Vector2 topLeft = new Vector2(0.0f, underline.Offset);
sink.BeginFigure(topLeft, FigureBegin.Filled);
topLeft.X += underline.Width;
sink.AddLine(topLeft);
topLeft.Y += underline.Thickness;
sink.AddLine(topLeft);
topLeft.X -= underline.Width;
sink.AddLine(topLeft);
sink.EndFigure(FigureEnd.Closed);
sink.Close();
Matrix3x2 mat = Matrix3x2.Translation(baselineOriginX, baselineOriginY) * Matrix3x2.Scaling(1.0f, -1.0f);
TransformedGeometry tg = new TransformedGeometry(this.factory, pg, *(RawMat *)&mat);
this.AddGeometry(tg);
return(Result.Ok);
}
}
}
public bool SendFrame(TimeSpan elapsedTime, int frameIndex)
{
var a = Math.PI * elapsedTime.TotalSeconds;
var h = VideoFrameHeight - _ballEllipse.RadiusY;
var y = (float)(VideoFrameHeight - Math.Abs(Math.Sin(a) * h));
var pos = new RawVector2(VideoFrameWidth * 0.5f, y);
using (var df = TakeNextFrameForSending())
{
if (!df.TryGetFrame(out FrameD3D11 frame))
{
return(false);
}
// TODO: Draw bouncing ball.
_context2D.Target = frame.Bitmap;
_context2D.BeginDraw();
_context2D.Transform = Matrix3x2.Identity;
_context2D.DrawBitmap(_backgroundBitmap, new RawRectangleF(0, 0, VideoFrameWidth, VideoFrameHeight),
1, D2D1.BitmapInterpolationMode.NearestNeighbor);
_context2D.Transform = BallPosition.HasValue
? Matrix3x2.Translation(BallPosition.Value * new Vector2(VideoFrameWidth, VideoFrameHeight))
: Matrix3x2.Translation(pos);
_context2D.FillEllipse(_ballEllipse, _ballBrush);
_context2D.EndDraw();
_context2D.Target = null;
return(true);
}
}
private void _プレビュー画像を描画する(DeviceContext d2ddc)
{
// 枠
const float 枠の太さdpx = 5f;
d2ddc.FillRectangle(
new RectangleF(
this._プレビュー画像表示位置dpx.X - 枠の太さdpx,
this._プレビュー画像表示位置dpx.Y - 枠の太さdpx,
this._プレビュー画像表示サイズdpx.X + 枠の太さdpx * 2f,
this._プレビュー画像表示サイズdpx.Y + 枠の太さdpx * 2f),
this._プレビュー枠ブラシ);
// プレビュー画像
var preimage = Global.App.演奏譜面.最高記録を現行化済み ?
(Global.App.演奏譜面.プレビュー画像 ?? this._既定のノード画像) :
this._現行化前のノード画像;
var 換行列2D =
Matrix3x2.Scaling(
this._プレビュー画像表示サイズdpx.X / preimage.サイズ.Width,
this._プレビュー画像表示サイズdpx.Y / preimage.サイズ.Height) *
Matrix3x2.Translation(
this._プレビュー画像表示位置dpx.X,
this._プレビュー画像表示位置dpx.Y);
preimage.描画する(d2ddc, 換行列2D);
}
// 進行と描画
public void 描画する(DeviceContext dc, float 達成率)
{
var 描画領域 = new RectangleF(220f, 650f, 165f, 80f);
達成率 = Math.Max(Math.Min(達成率, 99.99f), 0f); // 0～99.99にクリッピング
string 達成率文字列 = (達成率.ToString("0.00") + '%').PadLeft(6).Replace(' ', 'o'); // 右詰め、余白は'o'。例:"99.00%", "o8.12%", "o0.00%"
// 達成率ロゴを描画する
var 換行列2D =
Matrix3x2.Scaling(0.4f, 0.5f) *
Matrix3x2.Translation(描画領域.X - 30f, 描画領域.Y - 60f);
this._達成率ロゴ画像.描画する(dc, 換行列2D);
// 小数部を描画する（'%'含む）
this._数字画像.描画する(dc, 描画領域.X + 65f, 描画領域.Y + (描画領域.Height * 0.2f), 達成率文字列.Substring(3), new Size2F(0.5f, 0.8f));
// 整数部を描画する（'.'含む）
this._数字画像.描画する(dc, 描画領域.X, 描画領域.Y, 達成率文字列.Substring(0, 3), new Size2F(0.5f, 1.0f));
}
private void DrawRow(string characters)
{
var old = DeviceContext.Transform;
for (int i = 0; i < characters.Length; i++)
{
if (CharUnicodeInfo.GetUnicodeCategory(characters[i]) != UnicodeCategory.PrivateUse)
{
var ch = characters[i].ToString();
using (var layout = new TextLayout(DWriteFactory, ch, _textFormat, _cellWidth, _cellHeight))
{
DrawCharacter(ch, false, layout);
}
}
else
{
var ch = _puaCharacters[char.ConvertToUtf32(characters, i)];
using (var layout = new TextLayout(DWriteFactory, ch, _textFormat, _cellWidth, _cellHeight))
{
DrawCompoundCharacter(ch, layout);
}
}
var transform = Matrix3x2.Multiply(DeviceContext.Transform, Matrix3x2.Translation(_cellWidth, 0));
DeviceContext.Transform = transform;
}
DeviceContext.Transform = old;
}
public override Result DrawGlyphRun(object clientDrawingContext, float baselineOriginX, float baselineOriginY, MeasuringMode measuringMode, GlyphRun glyphRun, GlyphRunDescription glyphRunDescription, ComObject clientDrawingEffect)
{
using (PathGeometry path = new PathGeometry(_factory))
using (GeometrySink sink = path.Open())
{
glyphRun.FontFace.GetGlyphRunOutline(glyphRun.FontSize, glyphRun.Indices, glyphRun.Advances, glyphRun.Offsets, glyphRun.IsSideways, false, sink);
sink.Close();
var translation = Matrix3x2.Translation(baselineOriginX, baselineOriginY);
var outline = new TransformedGeometry(_factory, path, translation);
using (var strokeStyle = new StrokeStyle(_factory, new StrokeStyleProperties {
LineJoin = LineJoin.Round
}))
{
for (int i = 1; i < 8; i++)
{
var color = Color.White;
color.A /= (byte)Math.Ceiling(i / 1.5);
using (var brush = new SolidColorBrush(_surface, color))
{
_surface.DrawGeometry(outline, brush, i, strokeStyle);
}
}
}
}
return(new Result());
}
/// <summary>
/// Draw the layer.
/// </summary>
/// <param name="renderTime">Time since last render.</param>
/// <remarks>include base.Render(renderTime); in overloads to preserve updating RenderTime field.</remarks>
public override void Render(RenderTime renderTime)
{
// if we don't have a data provider, don't render
if (DataProvider == null || _kdProxy == null || MM_Repository.OverallDisplay.Contour == MM_Display.MM_Contour_Enum.None)
{
return;
}
base.Render(renderTime);
var displayView = Surface.Coordinates.GetViewXY();
var displayRect = Surface.DisplayRectangle;
var size = Surface.RenderTarget2D.PixelSize;
bool resized = _displayRect != displayRect;
bool viewSizeMatchesDisplaySize = displayView.Width == displayRect.Width && displayView.Height == displayRect.Height;
if ((displayView != _displayView || _bmp == null || _bmp.IsDisposed || resized) && !((MM_Network_Map_DX)Surface).HandlingMouse && viewSizeMatchesDisplaySize && !isRendering)
{
_displayRect = displayRect;
_displayView = displayView;
_size = size;
DrawBitmap(Surface.RenderTarget2D.PixelSize.Height / 10,
Surface.RenderTarget2D.PixelSize.Width / 10,
(float)MM_Coordinates.GConstants[_zoomLevel][1] * _zoomLevel * _zoomLevel, _displayView);
}
if (_bmp != null && Surface.RenderTarget2D != null && !((MM_Network_Map_DX)Surface).HandlingMouse)
{
var stateLayer = Surface.GetLayers <StateRegionsLayer>().FirstOrDefault();
var tx = Surface.RenderTarget2D.Transform;
Surface.RenderTarget2D.Transform = Matrix3x2.Translation(-Surface.Coordinates.TopLeftXY.X, -Surface.Coordinates.TopLeftXY.Y);
var dest = new SharpDX.RectangleF(-Surface.RenderTarget2D.Transform.M31, -Surface.RenderTarget2D.Transform.M32, Surface.RenderTarget2D.Size.Width, Surface.RenderTarget2D.Size.Height);
if (MM_Repository.OverallDisplay.ClipContours && stateLayer != null && stateLayer.State != null && stateLayer.State.Geometry != null && !(DataProvider is LineLoadingPercentageContourData))
{
var layerParameters = new LayerParameters()
{
ContentBounds = RectangleF.Infinite,
GeometricMask = stateLayer.State.Geometry,
Opacity = 1,
MaskTransform = tx
};
using (var layer = new Layer(Surface.RenderTarget2D, Surface.RenderTarget2D.Size))
{
Surface.RenderTarget2D.PushLayer(ref layerParameters, layer);
Surface.RenderTarget2D.DrawBitmap(_bmp, dest, 0.5f, BitmapInterpolationMode.Linear);
Surface.RenderTarget2D.PopLayer();
}
}
else
{
Surface.RenderTarget2D.DrawBitmap(_bmp, dest, 0.5f, BitmapInterpolationMode.Linear);
}
Surface.RenderTarget2D.Transform = tx;
}
}
private void _難易度パネルを１つ描画する(DeviceContext dc, Matrix3x2 pretrans, float 基点X, float 基点Y, string 難易度ラベル, float 難易度値, Brush 文字ブラシ, Brush 見出し背景ブラシ, Brush 数値背景ブラシ)
{
dc.Transform = pretrans;
dc.FillRectangle(new RectangleF(基点X, 基点Y, 157f, 20f), 見出し背景ブラシ);
dc.FillRectangle(new RectangleF(基点X, 基点Y + 20f, 157f, 66f), 数値背景ブラシ);
this._見出し用TextFormat.TextAlignment = TextAlignment.Trailing;
dc.DrawText(難易度ラベル, this._見出し用TextFormat, new RectangleF(基点X + 4f, 基点Y, 157f - 8f, 18f), 文字ブラシ);
if (難易度ラベル.Nullでも空でもない() && 0.00 != 難易度値)
{
var 難易度値文字列 = 難易度値.ToString("0.00").PadLeft(1); // 整数部は２桁を保証（１桁なら十の位は空白文字）
//// 小数部を描画する
dc.Transform =
Matrix3x2.Scaling(0.5f, 0.5f) *
Matrix3x2.Translation(基点X + 84f, 基点Y + 36f) *
pretrans;
this._数字画像.描画する(dc, 0f, 0f, 難易度値文字列.Substring(2));
// 整数部を描画する（'.'含む）
dc.Transform =
Matrix3x2.Scaling(0.7f, 0.7f) *
Matrix3x2.Translation(基点X + 20f, 基点Y + 20f) *
pretrans;
this._数字画像.描画する(dc, 0f, 0f, 難易度値文字列.Substring(0, 2));
}
}
/// <summary>
/// Called when [render].
/// </summary>
/// <param name="context">The context.</param>
protected override void OnRender(RenderContext2D context)
{
if (background == null)
{
Background = new D2D.SolidColorBrush(context.DeviceContext, new Color4(0.8f, 0.8f, 0.8f, 0.6f));
}
if (foreground == null)
{
Foreground = new D2D.SolidColorBrush(context.DeviceContext, Color.Blue);
}
var str = statistics.GetDetailString();
if (str != previousStr)
{
previousStr = str;
RemoveAndDispose(ref textLayout);
textLayout = Collect(new TextLayout(factory, str, format, float.MaxValue, float.MaxValue));
}
var metrices = textLayout.Metrics;
renderBound.Width = Math.Max(metrices.Width, renderBound.Width);
renderBound.Height = metrices.Height;
context.DeviceContext.Transform = Matrix3x2.Translation((float)context.ActualWidth - renderBound.Width, 0);
context.DeviceContext.FillRectangle(renderBound, background);
context.DeviceContext.DrawTextLayout(Vector2.Zero, textLayout, foreground);
}
public void 進行描画する(DeviceContext dc, double?スキル値)
{
if (null == スキル値)
{
return;
}
var skill = (double)スキル値;
var 描画領域 = new RectangleF(108f, 780f, 275f, 98f);
string スキル値文字列 = skill.ToString("0.00").PadLeft(6).Replace(' ', 'o'); // 右詰め、余白は'o'。
// 曲別SKILLアイコンを描画する
dc.Transform =
Matrix3x2.Scaling(0.375f, 0.5f) *
Matrix3x2.Translation(描画領域.X, 描画領域.Y);
this._ロゴ画像.描画する(dc, 0f, 0f);
// 小数部を描画する
dc.Transform =
Matrix3x2.Scaling(0.65f, 0.8f) *
Matrix3x2.Translation(描画領域.X + 90f + 105f, 描画領域.Y + (描画領域.Height * 0.2f));
this._数字画像.描画する(dc, 0f, 0f, スキル値文字列.Substring(4));
// 整数部を描画する（'.'含む）
dc.Transform =
Matrix3x2.Scaling(0.65f, 1.0f) *
Matrix3x2.Translation(描画領域.X + 90f, 描画領域.Y);
this._数字画像.描画する(dc, 0f, 0f, スキル値文字列.Substring(0, 4));
}
/// <summary>
/// Draw the layer.
/// </summary>
/// <param name="renderTime">Time since last render.</param>
/// <remarks>include base.Render(renderTime); in overloads to preserve updating RenderTime field.</remarks>
public override void Render(RenderTime renderTime)
{
base.Render(renderTime);
var tx = Surface.RenderTarget2D.Transform;
Surface.RenderTarget2D.Transform = Matrix3x2.Translation(-Surface.Coordinates.TopLeftXY.X, -Surface.Coordinates.TopLeftXY.Y);
var coordinateBounds = Surface.Coordinates.GetBounds();
if (MM_Repository.OverallDisplay.DisplayCounties)
{
foreach (var dxRegion in regions)
{
var region = dxRegion.Value;
if (coordinateBounds.Overlaps(region.Bounds))
{
Surface.RenderTarget2D.DrawGeometry(region.Geometry, brushes.GetBrush(region.Color), region.Width);
}
}
}
if (MM_Repository.OverallDisplay.DisplayStateBorder && state != null)
{
if (coordinateBounds.Overlaps(state.Bounds))
{
Surface.RenderTarget2D.DrawGeometry(state.Geometry, brushes.GetBrush(state.Color), state.Width);
}
}
Surface.RenderTarget2D.Transform = tx;
}
// 進行と描画
public void 進行描画する(DeviceContext dc)
{
var 描画矩形 = new RectangleF(122f, 313f, 240f, 30f);
// 初回または名前が変更された場合に TextLayout を再構築する。
if ((null == this._TextLayout) || (this._前回表示した名前 != this.前))
{
this._TextLayout = new TextLayout(DXResources.Instance.DWriteFactory, this.前, this._TextFormat, 1000f, 30f) // 最大1000dpxまで
{
TextAlignment = TextAlignment.Leading,
WordWrapping = WordWrapping.NoWrap, // 1000dpxを超えても改行しない（はみ出し分は切り捨て）
};
float 文字列幅dpx = this._TextLayout.Metrics.WidthIncludingTrailingWhitespace;
this._拡大率X = (文字列幅dpx <= 描画矩形.Width) ? 1.0f : (描画矩形.Width / 文字列幅dpx);
}
DXResources.Instance.D2DBatchDraw(dc, () => {
var pretrans = dc.Transform;
dc.PrimitiveBlend = PrimitiveBlend.SourceOver;
dc.Transform =
Matrix3x2.Scaling(this._拡大率X, 1.0f) * // 拡大縮小
Matrix3x2.Translation(描画矩形.X, 描画矩形.Y) * // 平行移動
pretrans;
dc.DrawTextLayout(Vector2.Zero, this._TextLayout, this._文字色); // 座標（描画矩形）は拡大率の影響をうけるので、このメソッドではなく、Matrix3x2.Translation() で設定するほうが楽。
dc.Transform = pretrans;
});
this._前回表示した名前 = this.前;
}
void Render()
{
if (resized)
{
Resize();
resized = false;
}
d2dDeviceContext.BeginDraw();
d2dDeviceContext.Clear(Color4.White);
d2dDeviceContext.PushAxisAlignedClip(new RectangleF(5, 5, Child.Width - 10, Child.Height - 10), AntialiasMode.Aliased);
d2dDeviceContext.Transform = Matrix3x2.Translation(Child.Width / 2f / Scale + Translation.X, Child.Height / 2f / Scale + Translation.Y) * Matrix3x2.Scaling(Scale);
d2dDeviceContext.AntialiasMode = AntialiasMode.Aliased;
d2dDeviceContext.DrawLine(new Vector2(0, int.MinValue), new Vector2(0, int.MaxValue), RasterDrawBrush, 1 / Scale);
d2dDeviceContext.DrawLine(new Vector2(int.MinValue, 0), new Vector2(int.MaxValue, 0), RasterDrawBrush, 1 / Scale);
d2dDeviceContext.AntialiasMode = AntialiasMode.PerPrimitive;
RenderGeometry();
d2dDeviceContext.Transform = Matrix3x2.Identity;
d2dDeviceContext.PopAxisAlignedClip();
d2dDeviceContext.EndDraw();
swapChain.Present(0, PresentFlags.None);
}
private Matrix3x2 GetWorldToFormTransform()
{
float worldExtent = 20;
var size = renderEnvironment.Size;
float scaling = Math.Min(size.Width, size.Height) / worldExtent;
return(new Matrix3x2(1, 0, 0, -1, 0, 0) * Matrix3x2.Scaling(scaling) * Matrix3x2.Translation(size.Width / 2, size.Height / 2));
}
public static Matrix3x2 Translate(this Matrix3x2 target, float dx, float dy)
{
return(Matrix3x2.Multiply(Matrix3x2.Translation(dx, dy), target));
/*target.M31 += dx;
* target.M32 += dy;
* return target;*/
}
/// <summary>
/// <para>Renders the element in the specified context. To override Render, please override <see cref="OnRender"/></para>
/// <para>Uses <see cref="CanRender"/> to call OnRender or not. </para>
/// </summary>
/// <param name="context">The context.</param>
public void Render(RenderContext2D context)
{
if (!IsRenderable)
{
return;
}
if (IsTransformDirty)
{
RelativeMatrix = Matrix3x2.Translation(-RenderSize * RenderTransformOrigin)
* ModelMatrix * Matrix3x2.Translation(RenderSize * RenderTransformOrigin)
* LayoutTranslate;
TotalModelMatrix = RelativeMatrix * ParentMatrix;
IsTransformDirty = false;
InvalidateVisual();
}
LayoutBoundWithTransform = LayoutBound.Translate(TotalModelMatrix.TranslationVector);
#if DISABLEBITMAPCACHE
IsBitmapCacheValid = false;
#else
EnsureBitmapCache(context, new Size2((int)Math.Ceiling(LayoutClipBound.Width), (int)Math.Ceiling(LayoutClipBound.Height)), context.DeviceContext.MaximumBitmapSize);
#endif
if (EnableBitmapCache && IsBitmapCacheValid)
{
if (IsVisualDirty)
{
#if DEBUGDRAWING
if (logger.IsEnabled(LogLevel.Debug))
{
logger.LogDebug("Redraw bitmap cache");
}
#endif
context.PushRenderTarget(bitmapCache, true);
context.DeviceContext.Transform = Matrix3x2.Identity;
context.PushRelativeTransform(Matrix3x2.Identity);
RenderCore.Transform = context.RelativeTransform;
OnRender(context);
context.PopRelativeTransform();
context.PopRenderTarget();
IsVisualDirty = false;
}
if (context.HasTarget)
{
context.DeviceContext.Transform = context.RelativeTransform * RelativeMatrix;
context.DeviceContext.DrawImage(bitmapCache, new Vector2(0, 0), LayoutClipBound,
InterpolationMode.Linear, global::SharpDX.Direct2D1.CompositeMode.SourceOver);
}
}
else if (context.HasTarget)
{
context.PushRelativeTransform(context.RelativeTransform * RelativeMatrix);
RenderCore.Transform = context.RelativeTransform;
OnRender(context);
context.PopRelativeTransform();
IsVisualDirty = false;
}
}
private void ClientAreaChanged(Vector2 position, Vector2 size)
{
mClientRectangle = new RectangleF(position.X, position.Y, size.X, size.Y);
mCaptionRect = new RectangleF(position.X - 1, position.Y - 18, size.X + 1, 18.0f);
mClipRect = new RectangleF(1, 1, size.X - 2, size.Y - 2);
mTransform = Matrix3x2.Translation(position);
mCaptionText.Size = new Size2F(size.X - 6, 18.0f);
}
public void Draw(BitmapManager bmp, RenderTarget ctx)
{
ctx.Transform =
Matrix3x2.Translation(-24, -24) *
Matrix3x2.Rotation(RotationAngle) *
Matrix3x2.Scaling(Scale) *
Matrix3x2.Translation(X, Y);
ctx.DrawBitmap(bmp[_snow], 1.0f, BitmapInterpolationMode.Linear);
}
public void 描画する(グラフィックデバイス gd)
{
var 見出し描画領域 = new RectangleF(783f, 117f, 414f, 63f);
var 数値描画領域 = new RectangleF(783f, 180f, 414f, 213f);
var node = App.曲ツリー.フォーカス曲ノード;
var anker = App.曲ツリー.フォーカス難易度;
(string label, float level)難易度;
if (node.親ノード is SetNode)
{
// 親が SetNode なら、難易度はそっちから取得する。
難易度 = node.親ノード.難易度[anker];
}
else
{
難易度 = node.難易度[anker];
}
gd.D2DBatchDraw((dc) => {
var pretrans = dc.Transform;
using (var 見出し背景ブラシ = new SolidColorBrush(dc, Node.難易度色[anker]))
using (var 黒ブラシ = new SolidColorBrush(dc, Color4.Black))
using (var 黒透過ブラシ = new SolidColorBrush(dc, new Color4(Color3.Black, 0.5f)))
using (var 白ブラシ = new SolidColorBrush(dc, Color4.White))
{
dc.Transform = pretrans;
// 背景領域を塗りつぶす。
dc.FillRectangle(見出し描画領域, 見出し背景ブラシ);
dc.FillRectangle(数値描画領域, 黒ブラシ);
// 見出し文字列を描画する。
this._見出し用TextFormat.TextAlignment = TextAlignment.Trailing;
var 見出し文字領域 = 見出し描画領域;
見出し文字領域.Width -= 8f; // 右マージン
dc.DrawText(難易度.label, this._見出し用TextFormat, 見出し文字領域, 白ブラシ);
// 小数部を描画する。
var 数値文字列 = 難易度.level.ToString("0.00").PadLeft(1);
dc.Transform =
Matrix3x2.Scaling(2.2f, 2.2f) *
Matrix3x2.Translation(数値描画領域.X + 175f, 数値描画領域.Y) *
pretrans;
this._数字画像.描画する(dc, 0f, 0f, 数値文字列.Substring(2));
// 整数部と小数点を描画する。
dc.Transform =
Matrix3x2.Scaling(2.2f, 2.2f) *
Matrix3x2.Translation(数値描画領域.X + 15f, 数値描画領域.Y) *
pretrans;
this._数字画像.描画する(dc, 0f, 0f, 数値文字列.Substring(0, 2));
}
});
}
protected override void OnRender(WindowRenderTarget renderTarget)
{
RectF bounds = new RectF(new PointF(), renderTarget.Size);
renderTarget.FillRect(_gridPatternBrush, bounds);
renderTarget.Transform = Matrix3x2.Translation(50, 50);
RenderScene(renderTarget);
RenderWithLayer(renderTarget);
}
D2D.Effect ApplyShadow(D2D.Bitmap1 bitmap)
{
_shadow.SetInput(0, bitmap);
_shadow.BlurStandardDeviation = 5f;
_affineTransform.SetInputEffect(0, _shadow);
_affineTransform.TransformMatrix = Matrix3x2.Translation(20f, 20f);
_composite.SetInputEffect(0, _affineTransform);
_composite.SetInput(1, bitmap);
return(_composite);
}
private Matrix3x2 GetCenterRenderTransform(float scaleFactor, float xLocation, float yLocation, float rotation)
{
var scaleTransform = Matrix3x2.Scaling(scaleFactor);
var geometryBounds = GetBounds(scaleTransform);
float centerScalingOffset = scaleFactor * 4;
float xTranslate = xLocation - (geometryBounds.Right - geometryBounds.Left) + centerScalingOffset;
float yTranslate = yLocation - (geometryBounds.Bottom - geometryBounds.Top) + centerScalingOffset;
return(scaleTransform * Matrix3x2.Rotation(rotation) * Matrix3x2.Translation(xTranslate, yTranslate));
}