public static System.Numerics.Matrix3x2 ToMatrix3x2(this RawMatrix3x2 matrix)
{
Union u = _union;
u.RawMatrix3x2 = matrix;
return(u.Matrix3x2);
}
static public RawMatrix3x2 TransMatrixToRawMatrix3x2(System.Drawing.Drawing2D.Matrix m)
{
float[] val = m.Elements;
RawMatrix3x2 rawMatrix = new RawMatrix3x2(val[0], val[1], val[2], val[3], val[4], val[5]);
return(rawMatrix);
}
public Result DrawUnderline(object clientDrawingContext, float baselineOriginX, float baselineOriginY, ref Underline underline, ComObject clientDrawingEffect)
{
var rect = new SharpDX.RectangleF(0, underline.Offset, underline.Width, underline.Offset + underline.Thickness);
var rectangleGeometry = new RectangleGeometry(_d2DFactory, rect);
RawMatrix3x2 matrix = new RawMatrix3x2(
1.0f, 0.0f,
0.0f, 1.0f,
baselineOriginX, baselineOriginY
);
var transformedGeometry = new TransformedGeometry(_d2DFactory, rectangleGeometry, matrix);
var brushColor = (Color4)Color.Black;
if (clientDrawingEffect != null && clientDrawingEffect is ColorDrawingEffect)
{
brushColor = (Color4)(clientDrawingEffect as ColorDrawingEffect).Color;
}
var brush = new SolidColorBrush(_renderTarget, brushColor);
_renderTarget.DrawGeometry(transformedGeometry, brush);
_renderTarget.FillGeometry(transformedGeometry, brush);
rectangleGeometry.Dispose();
transformedGeometry.Dispose();
brush.Dispose();
return(SharpDX.Result.Ok);
}
public void ComputeTransLastHitGeometry()
{
switch (scMgr.GraphicsType)
{
case GraphicsType.GDIPLUS:
if (hitGraphicsPath == null)
{
return;
}
transLastHitGraphicsPath = (GraphicsPath)hitGraphicsPath.Clone();
transLastHitGraphicsPath.Transform(globalMatrix);
break;
case GraphicsType.D2D:
if (hitPathGeometry == null)
{
return;
}
SharpDX.Direct2D1.Factory d2dFactory = D2DGraphics.d2dFactory;
RawMatrix3x2 m32 = GDIDataD2DUtils.TransMatrixToRawMatrix3x2(globalMatrix);
transLastHitPathGeometry = new TransformedGeometry(d2dFactory, hitPathGeometry, m32);
break;
}
}
/// <summary>
/// Gets a transform attribute
/// </summary>
/// <param name="name">Attribute name</param>
/// <param name="matrix">When this returns , contains the attribute value</param>
public unsafe void GetAttributeValue(string name, out RawMatrix3x2 matrix)
{
fixed(RawMatrix3x2 *ptr = &matrix)
{
GetAttributeValue(name, SvgAttributePodType.Matrix, new IntPtr(ptr), sizeof(RawMatrix3x2));
}
}
public override void CreateRealizations(DeviceContext1 deviceContext)
{
var matrix = new RawMatrix3x2(Matrix3x2.Identity.M11, Matrix3x2.Identity.M12, Matrix3x2.Identity.M21, Matrix3x2.Identity.M22, Matrix3x2.Identity.M31, Matrix3x2.Identity.M32);
var tolerance = D2D1.ComputeFlatteningTolerance(ref matrix, maxZoomFactor: 4);
FilledRealization = new GeometryRealization(deviceContext, Geometry, tolerance);
StrokedRealization = new GeometryRealization(deviceContext, Geometry, tolerance, 1f, null);
}
public TCM_GraphicsObject(TCM_Graphics g)
{
transform = new RawMatrix3x2(1, 0, 0, 1, 0, 0);
frontChildren = new List <TCM_GraphicsObject>();
backChildren = new List <TCM_GraphicsObject>();
parent = null;
graphics = g;
}
public static RawVector2 transformPoint(float x, float y, RawMatrix3x2 transform)
{
RawVector2 output = new RawVector2();
output.X = x * transform.M11 + y * transform.M21 + transform.M31;
output.Y = x * transform.M12 + y * transform.M22 + transform.M32;
return(output);
}
/// <summary>
/// Converts the <see cref="RawMatrix3x2"/> to the equivalend float array.
/// </summary>
/// <param name="matrix">The matrix to convert.</param>
/// <returns>The converted result array.</returns>
private static float[] ToArray(RawMatrix3x2 matrix)
{
return(new[]
{
matrix.M11, matrix.M12,
matrix.M21, matrix.M22,
matrix.M31, matrix.M32,
});
}
public Frame()
{
transform = new RawMatrix3x2(1, 0, 0, 1, 0, 0);
frontChildren = new List <Frame>();
backChildren = new List <Frame>();
visuals = new List <Visual>();
hitboxes = new List <Hitbox>();
parent = null;
}
public override void Transform(Matrix3x3 m)
{
currentTransform.Multiply(m);
RawMatrix3x2 mat = new RawMatrix3x2(currentTransform[0], currentTransform[1],
currentTransform[2], currentTransform[3],
currentTransform[4], currentTransform[5]);
renderTarget.Transform = mat;
}
public virtual void Render(RawMatrix3x2 transform, RawColor4 color)
{
this.SetColor(color);
this.RenderTarget.Transform = transform;
this.RenderTarget.FillGeometry(this.Geometry, this.Brush);
this.RenderTarget.Transform = Helpers.Matrix3x2Helper.Identity;
}
/// <summary>
/// Converts a Direct2D <see cref="RawMatrix3x2"/> to a Perspex <see cref="Perspex.Matrix"/>.
/// </summary>
/// <param name="matrix">The matrix</param>
/// <returns>a <see cref="Perspex.Matrix"/>.</returns>
public static Matrix ToPerspex(this RawMatrix3x2 matrix)
{
return(new Matrix(
matrix.M11,
matrix.M12,
matrix.M21,
matrix.M22,
matrix.M31,
matrix.M32));
}
/// <summary>
/// Converts a Direct2D <see cref="RawMatrix3x2"/> to a Avalonia <see cref="Avalonia.Matrix"/>.
/// </summary>
/// <param name="matrix">The matrix</param>
/// <returns>a <see cref="Avalonia.Matrix"/>.</returns>
public static Matrix ToAvalonia(this RawMatrix3x2 matrix)
{
return(new Matrix(
matrix.M11,
matrix.M12,
matrix.M21,
matrix.M22,
matrix.M31,
matrix.M32));
}
/// <summary>
/// transforms the screen space coordinates into a canonical coordinate system [-1, 1] with y up
/// </summary>
/// <param name="start">screen space start</param>
/// <param name="end">screen space end</param>
/// <returns>canonical transform</returns>
public Transform SetCanonical(Float2 start, Float2 end)
{
RawMatrix3x2 t = new RawMatrix3x2(
(end.X - start.X) * 0.5f, 0.0f, // column 1
0.0f, -(end.Y - start.Y) * 0.5f, // column 2
(end.X - start.X) * 0.5f + start.X, (end.Y - start.Y) * 0.5f + start.Y // column 3
);
return(new Transform(parent, t));
}
/// <summary>
/// Initializes a new instance of the <see cref="LayerParameters1"/> struct.
/// </summary>
/// <param name="contentBounds">The content bounds.</param>
/// <param name="geometryMask">The geometry mask.</param>
/// <param name="maskAntialiasMode">The mask antialias mode.</param>
/// <param name="maskTransform">The mask transform.</param>
/// <param name="opacity">The opacity.</param>
/// <param name="opacityBrush">The opacity brush.</param>
/// <param name="layerOptions">The layer options.</param>
public LayerParameters1(RawRectangleF contentBounds, Geometry geometryMask, AntialiasMode maskAntialiasMode, RawMatrix3x2 maskTransform, float opacity, Brush opacityBrush, LayerOptions1 layerOptions)
: this()
{
ContentBounds = contentBounds;
GeometricMask = geometryMask;
MaskAntialiasMode = maskAntialiasMode;
MaskTransform = maskTransform;
Opacity = opacity;
OpacityBrush = opacityBrush;
LayerOptions = layerOptions;
}
public RawVector2[] getGlobalCorners()
{
RawVector2[] output = new RawVector2[4];
RawMatrix3x2 transform = getFullTransform();
output[0] = TCM_Matrix3x2.transformPoint(boundingBox.Left, boundingBox.Top, transform);
output[1] = TCM_Matrix3x2.transformPoint(boundingBox.Right, boundingBox.Top, transform);
output[2] = TCM_Matrix3x2.transformPoint(boundingBox.Right, boundingBox.Bottom, transform);
output[3] = TCM_Matrix3x2.transformPoint(boundingBox.Left, boundingBox.Bottom, transform);
return(output);
}
/// <summary>
/// Multiplies two RawMatrix3x2 objects as if they were 3x3 matrices, with the final column being (0,0,1).
/// Can apply a transform 'a' onto a transform 'b'.
/// </summary>
/// <param name="a">The first matrix</param>
/// <param name="b">The second matrix</param>
/// <returns></returns>
public static RawMatrix3x2 multiply(RawMatrix3x2 a, RawMatrix3x2 b)
{
RawMatrix3x2 output = new RawMatrix3x2();
output.M11 = a.M11 * b.M11 + a.M12 * b.M21;
output.M12 = a.M11 * b.M12 + a.M12 * b.M22;
output.M21 = a.M21 * b.M11 + a.M22 * b.M21;
output.M22 = a.M21 * b.M12 + a.M22 * b.M22;
output.M31 = a.M31 * b.M11 + a.M32 * b.M21 + b.M31;
output.M32 = a.M31 * b.M12 + a.M32 * b.M22 + b.M32;
return(output);
}
/// <summary>
/// 座標の回転・平行移動
/// </summary>
/// <param name="x">xの平行移動</param>
/// <param name="y">yの平行移動</param>
/// <param name="theta">回転角</param>
/// <returns>座標変換の行列</returns>
private RawMatrix3x2 TransrationMatrix(float x, float y, double theta)
{
//自分で書かないといけないのにキレそう
var matrix = new RawMatrix3x2();
matrix.M11 = (float)Math.Cos(theta);
matrix.M12 = (float)Math.Sin(theta);
matrix.M21 = (float)Math.Sin(theta) * (-1);
matrix.M22 = (float)Math.Cos(theta);
matrix.M31 = x;
matrix.M32 = y;
return(matrix);
}
/// <summary>
/// Extension method for Matrix3x2 to conver to RawMatrix3x2
/// </summary>
/// <param name="self"></param>
/// <returns></returns>
public static RawMatrix3x2 ToRawMatrix3x2(this Matrix3x2 self)
{
RawMatrix3x2 raw = new RawMatrix3x2();
raw.M11 = self.M11;
raw.M12 = self.M12;
raw.M21 = self.M21;
raw.M22 = self.M22;
raw.M31 = self.M31;
raw.M32 = self.M32;
return(raw);
}
// Token: 0x0600019C RID: 412 RVA: 0x00014410 File Offset: 0x00012610
public void DrawTexture(string textureKey, RectangleF rect, float rotation = 0f, float opacity = 1f)
{
D3D11Texture texture = this.textureManager.GetTexture(textureKey);
if (rotation == 0f)
{
this.context.RenderTarget.DrawBitmap(texture.Bitmap, rect, opacity, BitmapInterpolationMode.Linear);
return;
}
RawMatrix3x2 transform = this.context.RenderTarget.Transform;
Vector2 vector;
vector..ctor(rect.Width / texture.Bitmap.Size.Width, rect.Height / texture.Bitmap.Size.Height);
this.context.RenderTarget.Transform = Matrix3x2.Translation(-texture.Center) * Matrix3x2.Rotation(rotation) * Matrix3x2.Translation(texture.Center) * Matrix3x2.Scaling(vector) * Matrix3x2.Translation(rect.Location);
this.context.RenderTarget.DrawBitmap(texture.Bitmap, opacity, BitmapInterpolationMode.Linear);
this.context.RenderTarget.Transform = transform;
}
/// <summary>
/// Computes the appropriate flattening tolerance to pass to APIs that take a flattening tolerance (for instance, <see cref="DeviceContext.CreateFilledGeometryRealization"/>).
/// </summary>
/// <param name="matrix">The matrix that will be applied subsequently to the geometry being flattened.</param>
/// <param name="dpiX">The horizontal DPI of the render target that the geometry will be rendered onto (a choice of 96 implies no DPI correction).</param>
/// <param name="dpiY">The vertical DPI of the render target that the geometry will be rendered onto (a choice of 96 implies no DPI correction).</param>
/// <param name="maxZoomFactor">The maximum amount of additional scaling (on top of any scaling implied by the matrix or the DPI) that will be applied to the geometry.</param>
/// <returns>The flattening tolerance.</returns>
public static float ComputeFlatteningTolerance(ref RawMatrix3x2 matrix, float dpiX = DefaultDpi, float dpiY = DefaultDpi, float maxZoomFactor = 1f)
{
var scaleX = dpiX / DefaultDpi;
var scaleY = dpiY / DefaultDpi;
var dpiDependentTransform = new RawMatrix3x2
{
M11 = matrix.M11 * scaleX,
M12 = matrix.M12 * scaleY,
M21 = matrix.M21 * scaleX,
M22 = matrix.M22 * scaleY,
M31 = matrix.M31 * scaleX,
M32 = matrix.M32 * scaleY
};
var absMaxZoomFactor = maxZoomFactor > 0f ? maxZoomFactor : -maxZoomFactor;
return(DefaultFlatteningTolerance / (absMaxZoomFactor * ComputeMaximumScaleFactor(ref dpiDependentTransform)));
}
void Init()
{
_oriTransform = _rt.Transform;
brush = new SolidColorBrush(_rt, new SharpDX.Color(0, 255, 255));
brushRed = new SolidColorBrush(_rt, SharpDX.Color.Red);
formatNear = new TextFormat(_fdw, FontName, 32 * Scale)
{
TextAlignment = TextAlignment.Leading,
ParagraphAlignment = ParagraphAlignment.Center
};
formatCenter = new TextFormat(_fdw, FontName, 65 * Scale)
{
TextAlignment = TextAlignment.Center,
ParagraphAlignment = ParagraphAlignment.Center
};
_tyNear = new TextLayout(_fdw, "", formatNear, Width, Height);
_tyCenter = new TextLayout(_fdw, "", formatCenter, Width, Height);
}
public MainWindow()
{
keyboard = new Keyboard();
keyboard.KeyDown += OnKeyboardKeyDown;
clearColor = new RawColor4(0f, 0f, 0f, 1f);
textColor = new RawColor4(1f, 1f, 1f, 1f);
zoom = 1f;
zoomFactor = 2f;
minZoom = 1f;
maxZoom = 64f;
translation = Vector2.Zero;
identityMatrix = Matrix3x2.Identity;
ticksPerFrame = 1;
framesPerTick = 1;
performanceMonitor = new PerformanceMonitor(TimeSpan.FromMilliseconds(1000));
performaceText = "0 FPS | 0 TPS";
//fileSystemWatcher = new FileSystemWatcher {NotifyFilter = NotifyFilters.LastWrite};
//fileSystemWatcher.Changed += OnFileSystemWatcherChanged;
}
static private RawMatrix3x2 MatrixMultiplication(RawMatrix3x2 x1, RawMatrix3x2 x2)
{
var result = new RawMatrix3x2(x1.M11 * x2.M11 + x1.M21 + x2.M12, x1.M11 * x2.M21 + x1.M21 * x2.M22, x1.M12 * x2.M11 + x1.M22 * x2.M12, x1.M12 * x2.M21 + x1.M22 * x2.M22, 0f, 0f);
return(result);
}
static private RawMatrix3x2 BuildOrientationMatrix(double Radian)
{
var result = new RawMatrix3x2((float)Math.Cos(Radian), (float)Math.Sin(Radian), (float)-Math.Sin(Radian), (float)Math.Cos(Radian), 0f, 0f);
return(result);
}
/// <summary>
/// Sets the named property to the given value.
/// </summary>
/// <param name="index">Index of the property</param>
/// <param name="value">Value of the property</param>
/// <unmanaged>HRESULT ID2D1Properties::SetValue([In] const wchar_t* name,[In] D2D1_PROPERTY_TYPE type,[In, Buffer] const void* data,[In] unsigned int dataSize)</unmanaged>
public unsafe void SetValue(int index, RawMatrix3x2 value)
{
SetValue(index, PropertyType.Matrix3x2, new IntPtr(&value), sizeof(RawMatrix3x2));
}
private Glyph ImportGlyph(Factory factory, FontFace fontFace, char character, FontMetrics fontMetrics, float fontSize, FontAntiAliasMode antiAliasMode)
{
var indices = fontFace.GetGlyphIndices(new int[] { character });
var metrics = fontFace.GetDesignGlyphMetrics(indices, false);
var metric = metrics[0];
var width = (float)(metric.AdvanceWidth - metric.LeftSideBearing - metric.RightSideBearing) / fontMetrics.DesignUnitsPerEm * fontSize;
var height = (float)(metric.AdvanceHeight - metric.TopSideBearing - metric.BottomSideBearing) / fontMetrics.DesignUnitsPerEm * fontSize;
var xOffset = (float)metric.LeftSideBearing / fontMetrics.DesignUnitsPerEm * fontSize;
var yOffset = (float)(metric.TopSideBearing - metric.VerticalOriginY) / fontMetrics.DesignUnitsPerEm * fontSize;
var advanceWidth = (float)metric.AdvanceWidth / fontMetrics.DesignUnitsPerEm * fontSize;
//var advanceHeight = (float)metric.AdvanceHeight / fontMetrics.DesignUnitsPerEm * fontSize;
var pixelWidth = (int)Math.Ceiling(width + 4);
var pixelHeight = (int)Math.Ceiling(height + 4);
var matrix = new RawMatrix3x2
{
M11 = 1,
M22 = 1,
M31 = -(float)Math.Floor(xOffset) + 1,
M32 = -(float)Math.Floor(yOffset) + 1
};
Bitmap bitmap;
if (char.IsWhiteSpace(character))
{
bitmap = new Bitmap(1, 1, PixelFormat.Format32bppArgb);
}
else
{
var glyphRun = new GlyphRun
{
FontFace = fontFace,
Advances = new[] { (float)Math.Ceiling(advanceWidth) },
FontSize = fontSize,
BidiLevel = 0,
Indices = indices,
IsSideways = false,
Offsets = new[] { new GlyphOffset() }
};
RenderingMode renderingMode;
if (antiAliasMode != FontAntiAliasMode.Aliased)
{
var rtParams = new RenderingParams(factory);
renderingMode = fontFace.GetRecommendedRenderingMode(fontSize, 1.0f, MeasuringMode.Natural, rtParams);
rtParams.Dispose();
}
else
{
renderingMode = RenderingMode.Aliased;
}
using (var runAnalysis = new GlyphRunAnalysis(factory,
glyphRun,
1.0f,
matrix,
renderingMode,
MeasuringMode.Natural,
0.0f,
0.0f))
{
var bounds = new RawRectangle(0, 0, pixelWidth, pixelHeight);
bitmap = new Bitmap(pixelWidth, pixelHeight, PixelFormat.Format32bppArgb);
if (renderingMode == RenderingMode.Aliased)
{
var texture = new byte[pixelWidth * pixelHeight];
runAnalysis.CreateAlphaTexture(TextureType.Aliased1x1, bounds, texture, texture.Length);
for (int y = 0; y < pixelHeight; y++)
{
for (int x = 0; x < pixelWidth; x++)
{
int pixelX = y * pixelWidth + x;
var grey = texture[pixelX];
var color = Color.FromArgb(grey, grey, grey);
bitmap.SetPixel(x, y, color);
}
}
}
else
{
var texture = new byte[pixelWidth * pixelHeight * 3];
runAnalysis.CreateAlphaTexture(TextureType.Cleartype3x1, bounds, texture, texture.Length);
for (int y = 0; y < pixelHeight; y++)
{
for (int x = 0; x < pixelWidth; x++)
{
int pixelX = (y * pixelWidth + x) * 3;
var red = LinearToGamma(texture[pixelX]);
var green = LinearToGamma(texture[pixelX + 1]);
var blue = LinearToGamma(texture[pixelX + 2]);
var color = Color.FromArgb(red, green, blue);
bitmap.SetPixel(x, y, color);
}
}
}
}
}
var glyph = new Glyph(character, bitmap)
{
XOffset = -matrix.M31,
XAdvance = advanceWidth,
YOffset = -matrix.M32,
};
return(glyph);
}
public static void Translation(float x, float y, out RawMatrix3x2 result)
{
result = Identity;
result.M31 = x;
result.M32 = y;
}
public Transform(Direct2D parent, RawMatrix3x2 transform)
{
this.parent = parent;
original = parent.target.Transform;
parent.target.Transform = transform;
}
