mirror of https://github.com/RPCS3/rpcs3.git
925 lines
25 KiB
C++
925 lines
25 KiB
C++
|
|
/*=========================================================================*\
|
|
|
|
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
|
File: D2D1_1Helper.h
|
|
|
|
Module Name: D2D
|
|
|
|
Description: Helper files over the D2D interfaces and APIs.
|
|
|
|
\*=========================================================================*/
|
|
#pragma once
|
|
|
|
#ifndef _D2D1_1HELPER_H_
|
|
#define _D2D1_1HELPER_H_
|
|
|
|
#ifndef _D2D1_1_H_
|
|
#include <d2d1_1.h>
|
|
#endif // #ifndef _D2D1_H_
|
|
|
|
#ifndef D2D_USE_C_DEFINITIONS
|
|
|
|
#include <winapifamily.h>
|
|
|
|
#pragma region Application Family
|
|
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
|
|
|
|
namespace D2D1
|
|
{
|
|
template<>
|
|
struct TypeTraits<INT32>
|
|
{
|
|
typedef D2D1_POINT_2L Point;
|
|
typedef D2D1_RECT_L Rect;
|
|
};
|
|
|
|
template<>
|
|
struct TypeTraits<LONG>
|
|
{
|
|
typedef D2D1_POINT_2L Point;
|
|
typedef D2D1_RECT_L Rect;
|
|
};
|
|
|
|
class Matrix4x3F : public D2D1_MATRIX_4X3_F
|
|
{
|
|
public:
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
Matrix4x3F(
|
|
FLOAT m11, FLOAT m12, FLOAT m13,
|
|
FLOAT m21, FLOAT m22, FLOAT m23,
|
|
FLOAT m31, FLOAT m32, FLOAT m33,
|
|
FLOAT m41, FLOAT m42, FLOAT m43
|
|
)
|
|
{
|
|
_11 = m11;
|
|
_12 = m12;
|
|
_13 = m13;
|
|
|
|
_21 = m21;
|
|
_22 = m22;
|
|
_23 = m23;
|
|
|
|
_31 = m31;
|
|
_32 = m32;
|
|
_33 = m33;
|
|
|
|
_41 = m41;
|
|
_42 = m42;
|
|
_43 = m43;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
Matrix4x3F()
|
|
{
|
|
_11 = 1;
|
|
_12 = 0;
|
|
_13 = 0;
|
|
|
|
_21 = 0;
|
|
_22 = 1;
|
|
_23 = 0;
|
|
|
|
_31 = 0;
|
|
_32 = 0;
|
|
_33 = 1;
|
|
|
|
_41 = 0;
|
|
_42 = 0;
|
|
_43 = 0;
|
|
}
|
|
};
|
|
|
|
class Matrix4x4F : public D2D1_MATRIX_4X4_F
|
|
{
|
|
public:
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
Matrix4x4F(
|
|
FLOAT m11, FLOAT m12, FLOAT m13, FLOAT m14,
|
|
FLOAT m21, FLOAT m22, FLOAT m23, FLOAT m24,
|
|
FLOAT m31, FLOAT m32, FLOAT m33, FLOAT m34,
|
|
FLOAT m41, FLOAT m42, FLOAT m43, FLOAT m44
|
|
)
|
|
{
|
|
_11 = m11;
|
|
_12 = m12;
|
|
_13 = m13;
|
|
_14 = m14;
|
|
|
|
_21 = m21;
|
|
_22 = m22;
|
|
_23 = m23;
|
|
_24 = m24;
|
|
|
|
_31 = m31;
|
|
_32 = m32;
|
|
_33 = m33;
|
|
_34 = m34;
|
|
|
|
_41 = m41;
|
|
_42 = m42;
|
|
_43 = m43;
|
|
_44 = m44;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
Matrix4x4F()
|
|
{
|
|
_11 = 1;
|
|
_12 = 0;
|
|
_13 = 0;
|
|
_14 = 0;
|
|
|
|
_21 = 0;
|
|
_22 = 1;
|
|
_23 = 0;
|
|
_24 = 0;
|
|
|
|
_31 = 0;
|
|
_32 = 0;
|
|
_33 = 1;
|
|
_34 = 0;
|
|
|
|
_41 = 0;
|
|
_42 = 0;
|
|
_43 = 0;
|
|
_44 = 1;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
bool
|
|
operator==(
|
|
const Matrix4x4F& r
|
|
) const
|
|
{
|
|
return _11 == r._11 && _12 == r._12 && _13 == r._13 && _14 == r._14 &&
|
|
_21 == r._21 && _22 == r._22 && _23 == r._23 && _24 == r._24 &&
|
|
_31 == r._31 && _32 == r._32 && _33 == r._33 && _34 == r._34 &&
|
|
_41 == r._41 && _42 == r._42 && _43 == r._43 && _44 == r._44;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
bool
|
|
operator!=(
|
|
const Matrix4x4F& r
|
|
) const
|
|
{
|
|
return !(*this == r);
|
|
}
|
|
|
|
static
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
Matrix4x4F
|
|
Translation(FLOAT x, FLOAT y, FLOAT z)
|
|
{
|
|
Matrix4x4F translation;
|
|
|
|
translation._11 = 1.0; translation._12 = 0.0; translation._13 = 0.0; translation._14 = 0.0;
|
|
translation._21 = 0.0; translation._22 = 1.0; translation._23 = 0.0; translation._24 = 0.0;
|
|
translation._31 = 0.0; translation._32 = 0.0; translation._33 = 1.0; translation._34 = 0.0;
|
|
translation._41 = x; translation._42 = y; translation._43 = z; translation._44 = 1.0;
|
|
|
|
return translation;
|
|
}
|
|
|
|
static
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
Matrix4x4F
|
|
Scale(FLOAT x, FLOAT y, FLOAT z)
|
|
{
|
|
Matrix4x4F scale;
|
|
|
|
scale._11 = x; scale._12 = 0.0; scale._13 = 0.0; scale._14 = 0.0;
|
|
scale._21 = 0.0; scale._22 = y; scale._23 = 0.0; scale._24 = 0.0;
|
|
scale._31 = 0.0; scale._32 = 0.0; scale._33 = z; scale._34 = 0.0;
|
|
scale._41 = 0.0; scale._42 = 0.0; scale._43 = 0.0; scale._44 = 1.0;
|
|
|
|
return scale;
|
|
}
|
|
|
|
static
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
Matrix4x4F
|
|
RotationX(FLOAT degreeX)
|
|
{
|
|
FLOAT angleInRadian = degreeX * (3.141592654f / 180.0f);
|
|
|
|
FLOAT sinAngle = 0.0;
|
|
FLOAT cosAngle = 0.0;
|
|
D2D1SinCos(angleInRadian, &sinAngle, &cosAngle);
|
|
|
|
Matrix4x4F rotationX(
|
|
1, 0, 0, 0,
|
|
0, cosAngle, sinAngle, 0,
|
|
0, -sinAngle, cosAngle, 0,
|
|
0, 0, 0, 1
|
|
);
|
|
|
|
return rotationX;
|
|
}
|
|
|
|
static
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
Matrix4x4F
|
|
RotationY(FLOAT degreeY)
|
|
{
|
|
FLOAT angleInRadian = degreeY * (3.141592654f / 180.0f);
|
|
|
|
FLOAT sinAngle = 0.0;
|
|
FLOAT cosAngle = 0.0;
|
|
D2D1SinCos(angleInRadian, &sinAngle, &cosAngle);
|
|
|
|
Matrix4x4F rotationY(
|
|
cosAngle, 0, -sinAngle, 0,
|
|
0, 1, 0, 0,
|
|
sinAngle, 0, cosAngle, 0,
|
|
0, 0, 0, 1
|
|
);
|
|
|
|
return rotationY;
|
|
}
|
|
|
|
static
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
Matrix4x4F
|
|
RotationZ(FLOAT degreeZ)
|
|
{
|
|
FLOAT angleInRadian = degreeZ * (3.141592654f / 180.0f);
|
|
|
|
FLOAT sinAngle = 0.0;
|
|
FLOAT cosAngle = 0.0;
|
|
D2D1SinCos(angleInRadian, &sinAngle, &cosAngle);
|
|
|
|
Matrix4x4F rotationZ(
|
|
cosAngle, sinAngle, 0, 0,
|
|
-sinAngle, cosAngle, 0, 0,
|
|
0, 0, 1, 0,
|
|
0, 0, 0, 1
|
|
);
|
|
|
|
return rotationZ;
|
|
}
|
|
|
|
//
|
|
// 3D Rotation matrix for an arbitrary axis specified by x, y and z
|
|
//
|
|
static
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
Matrix4x4F
|
|
RotationArbitraryAxis(FLOAT x, FLOAT y, FLOAT z, FLOAT degree)
|
|
{
|
|
// Normalize the vector represented by x, y, and z
|
|
FLOAT magnitude = D2D1Vec3Length(x, y, z);
|
|
x /= magnitude;
|
|
y /= magnitude;
|
|
z /= magnitude;
|
|
|
|
FLOAT angleInRadian = degree * (3.141592654f / 180.0f);
|
|
|
|
FLOAT sinAngle = 0.0;
|
|
FLOAT cosAngle = 0.0;
|
|
D2D1SinCos(angleInRadian, &sinAngle, &cosAngle);
|
|
|
|
FLOAT oneMinusCosAngle = 1 - cosAngle;
|
|
|
|
Matrix4x4F rotationArb(
|
|
1 + oneMinusCosAngle * (x * x - 1),
|
|
z * sinAngle + oneMinusCosAngle * x * y,
|
|
-y * sinAngle + oneMinusCosAngle * x * z,
|
|
0,
|
|
|
|
-z * sinAngle + oneMinusCosAngle * y * x,
|
|
1 + oneMinusCosAngle * (y * y - 1),
|
|
x * sinAngle + oneMinusCosAngle * y * z,
|
|
0,
|
|
|
|
y * sinAngle + oneMinusCosAngle * z * x,
|
|
-x * sinAngle + oneMinusCosAngle * z * y,
|
|
1 + oneMinusCosAngle * (z * z - 1) ,
|
|
0,
|
|
|
|
0, 0, 0, 1
|
|
);
|
|
|
|
return rotationArb;
|
|
}
|
|
|
|
static
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
Matrix4x4F
|
|
SkewX(FLOAT degreeX)
|
|
{
|
|
FLOAT angleInRadian = degreeX * (3.141592654f / 180.0f);
|
|
|
|
FLOAT tanAngle = D2D1Tan(angleInRadian);
|
|
|
|
Matrix4x4F skewX(
|
|
1, 0, 0, 0,
|
|
tanAngle, 1, 0, 0,
|
|
0, 0, 1, 0,
|
|
0, 0, 0, 1
|
|
);
|
|
|
|
return skewX;
|
|
}
|
|
|
|
static
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
Matrix4x4F
|
|
SkewY(FLOAT degreeY)
|
|
{
|
|
FLOAT angleInRadian = degreeY * (3.141592654f / 180.0f);
|
|
|
|
FLOAT tanAngle = D2D1Tan(angleInRadian);
|
|
|
|
Matrix4x4F skewY(
|
|
1, tanAngle, 0, 0,
|
|
0, 1, 0, 0,
|
|
0, 0, 1, 0,
|
|
0, 0, 0, 1
|
|
);
|
|
|
|
return skewY;
|
|
}
|
|
|
|
|
|
static
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
Matrix4x4F
|
|
PerspectiveProjection(FLOAT depth)
|
|
{
|
|
float proj = 0;
|
|
|
|
if (depth > 0)
|
|
{
|
|
proj = -1/depth;
|
|
}
|
|
|
|
Matrix4x4F projection(
|
|
1, 0, 0, 0,
|
|
0, 1, 0, 0,
|
|
0, 0, 1, proj,
|
|
0, 0, 0, 1
|
|
);
|
|
|
|
return projection;
|
|
}
|
|
|
|
//
|
|
// Functions for convertion from the base D2D1_MATRIX_4X4_f to
|
|
// this type without making a copy
|
|
//
|
|
static
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
const Matrix4x4F*
|
|
ReinterpretBaseType(const D2D1_MATRIX_4X4_F *pMatrix)
|
|
{
|
|
return static_cast<const Matrix4x4F *>(pMatrix);
|
|
}
|
|
|
|
static
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
Matrix4x4F*
|
|
ReinterpretBaseType(D2D1_MATRIX_4X4_F *pMatrix)
|
|
{
|
|
return static_cast<Matrix4x4F *>(pMatrix);
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
FLOAT
|
|
Determinant() const
|
|
{
|
|
FLOAT minor1 = _41 * (_12 * (_23 * _34 - _33 * _24) - _13 * (_22 * _34 - _24 * _32) + _14 * (_22 * _33 - _23 * _32));
|
|
FLOAT minor2 = _42 * (_11 * (_21 * _34 - _31 * _24) - _13 * (_21 * _34 - _24 * _31) + _14 * (_21 * _33 - _23 * _31));
|
|
FLOAT minor3 = _43 * (_11 * (_22 * _34 - _32 * _24) - _12 * (_21 * _34 - _24 * _31) + _14 * (_21 * _32 - _22 * _31));
|
|
FLOAT minor4 = _44 * (_11 * (_22 * _33 - _32 * _23) - _12 * (_21 * _33 - _23 * _31) + _13 * (_21 * _32 - _22 * _31));
|
|
|
|
return minor1 - minor2 + minor3 - minor4;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
bool
|
|
IsIdentity() const
|
|
{
|
|
return _11 == 1.f && _12 == 0.f && _13 == 0.f && _14 == 0.f
|
|
&& _21 == 0.f && _22 == 1.f && _23 == 0.f && _24 == 0.f
|
|
&& _31 == 0.f && _32 == 0.f && _33 == 1.f && _34 == 0.f
|
|
&& _41 == 0.f && _42 == 0.f && _43 == 0.f && _44 == 1.f;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
void
|
|
SetProduct(const Matrix4x4F &a, const Matrix4x4F &b)
|
|
{
|
|
_11 = a._11 * b._11 + a._12 * b._21 + a._13 * b._31 + a._14 * b._41;
|
|
_12 = a._11 * b._12 + a._12 * b._22 + a._13 * b._32 + a._14 * b._42;
|
|
_13 = a._11 * b._13 + a._12 * b._23 + a._13 * b._33 + a._14 * b._43;
|
|
_14 = a._11 * b._14 + a._12 * b._24 + a._13 * b._34 + a._14 * b._44;
|
|
|
|
_21 = a._21 * b._11 + a._22 * b._21 + a._23 * b._31 + a._24 * b._41;
|
|
_22 = a._21 * b._12 + a._22 * b._22 + a._23 * b._32 + a._24 * b._42;
|
|
_23 = a._21 * b._13 + a._22 * b._23 + a._23 * b._33 + a._24 * b._43;
|
|
_24 = a._21 * b._14 + a._22 * b._24 + a._23 * b._34 + a._24 * b._44;
|
|
|
|
_31 = a._31 * b._11 + a._32 * b._21 + a._33 * b._31 + a._34 * b._41;
|
|
_32 = a._31 * b._12 + a._32 * b._22 + a._33 * b._32 + a._34 * b._42;
|
|
_33 = a._31 * b._13 + a._32 * b._23 + a._33 * b._33 + a._34 * b._43;
|
|
_34 = a._31 * b._14 + a._32 * b._24 + a._33 * b._34 + a._34 * b._44;
|
|
|
|
_41 = a._41 * b._11 + a._42 * b._21 + a._43 * b._31 + a._44 * b._41;
|
|
_42 = a._41 * b._12 + a._42 * b._22 + a._43 * b._32 + a._44 * b._42;
|
|
_43 = a._41 * b._13 + a._42 * b._23 + a._43 * b._33 + a._44 * b._43;
|
|
_44 = a._41 * b._14 + a._42 * b._24 + a._43 * b._34 + a._44 * b._44;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
Matrix4x4F
|
|
operator*(const Matrix4x4F &matrix) const
|
|
{
|
|
Matrix4x4F result;
|
|
|
|
result.SetProduct(*this, matrix);
|
|
|
|
return result;
|
|
}
|
|
};
|
|
|
|
|
|
class Matrix5x4F : public D2D1_MATRIX_5X4_F
|
|
{
|
|
public:
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
Matrix5x4F(
|
|
FLOAT m11, FLOAT m12, FLOAT m13, FLOAT m14,
|
|
FLOAT m21, FLOAT m22, FLOAT m23, FLOAT m24,
|
|
FLOAT m31, FLOAT m32, FLOAT m33, FLOAT m34,
|
|
FLOAT m41, FLOAT m42, FLOAT m43, FLOAT m44,
|
|
FLOAT m51, FLOAT m52, FLOAT m53, FLOAT m54
|
|
)
|
|
{
|
|
_11 = m11;
|
|
_12 = m12;
|
|
_13 = m13;
|
|
_14 = m14;
|
|
|
|
_21 = m21;
|
|
_22 = m22;
|
|
_23 = m23;
|
|
_24 = m24;
|
|
|
|
_31 = m31;
|
|
_32 = m32;
|
|
_33 = m33;
|
|
_34 = m34;
|
|
|
|
_41 = m41;
|
|
_42 = m42;
|
|
_43 = m43;
|
|
_44 = m44;
|
|
|
|
_51 = m51;
|
|
_52 = m52;
|
|
_53 = m53;
|
|
_54 = m54;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
Matrix5x4F()
|
|
{
|
|
_11 = 1;
|
|
_12 = 0;
|
|
_13 = 0;
|
|
_14 = 0;
|
|
|
|
_21 = 0;
|
|
_22 = 1;
|
|
_23 = 0;
|
|
_24 = 0;
|
|
|
|
_31 = 0;
|
|
_32 = 0;
|
|
_33 = 1;
|
|
_34 = 0;
|
|
|
|
_41 = 0;
|
|
_42 = 0;
|
|
_43 = 0;
|
|
_44 = 1;
|
|
|
|
_51 = 0;
|
|
_52 = 0;
|
|
_53 = 0;
|
|
_54 = 0;
|
|
}
|
|
};
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
inline
|
|
D2D1_COLOR_F
|
|
ConvertColorSpace(
|
|
D2D1_COLOR_SPACE sourceColorSpace,
|
|
D2D1_COLOR_SPACE destinationColorSpace,
|
|
const D2D1_COLOR_F& color
|
|
)
|
|
{
|
|
return D2D1ConvertColorSpace(
|
|
sourceColorSpace,
|
|
destinationColorSpace,
|
|
&color
|
|
);
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
D2D1FORCEINLINE
|
|
D2D1_DRAWING_STATE_DESCRIPTION1
|
|
DrawingStateDescription1(
|
|
D2D1_ANTIALIAS_MODE antialiasMode = D2D1_ANTIALIAS_MODE_PER_PRIMITIVE,
|
|
D2D1_TEXT_ANTIALIAS_MODE textAntialiasMode = D2D1_TEXT_ANTIALIAS_MODE_DEFAULT,
|
|
D2D1_TAG tag1 = 0,
|
|
D2D1_TAG tag2 = 0,
|
|
_In_ const D2D1_MATRIX_3X2_F &transform = D2D1::IdentityMatrix(),
|
|
D2D1_PRIMITIVE_BLEND primitiveBlend = D2D1_PRIMITIVE_BLEND_SOURCE_OVER,
|
|
D2D1_UNIT_MODE unitMode = D2D1_UNIT_MODE_DIPS
|
|
)
|
|
{
|
|
D2D1_DRAWING_STATE_DESCRIPTION1 drawingStateDescription1;
|
|
|
|
drawingStateDescription1.antialiasMode = antialiasMode;
|
|
drawingStateDescription1.textAntialiasMode = textAntialiasMode;
|
|
drawingStateDescription1.tag1 = tag1;
|
|
drawingStateDescription1.tag2 = tag2;
|
|
drawingStateDescription1.transform = transform;
|
|
drawingStateDescription1.primitiveBlend = primitiveBlend;
|
|
drawingStateDescription1.unitMode = unitMode;
|
|
|
|
return drawingStateDescription1;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
D2D1FORCEINLINE
|
|
D2D1_DRAWING_STATE_DESCRIPTION1
|
|
DrawingStateDescription1(
|
|
_In_ const D2D1_DRAWING_STATE_DESCRIPTION &desc,
|
|
D2D1_PRIMITIVE_BLEND primitiveBlend = D2D1_PRIMITIVE_BLEND_SOURCE_OVER,
|
|
D2D1_UNIT_MODE unitMode = D2D1_UNIT_MODE_DIPS
|
|
)
|
|
{
|
|
D2D1_DRAWING_STATE_DESCRIPTION1 drawingStateDescription1;
|
|
|
|
drawingStateDescription1.antialiasMode = desc.antialiasMode;
|
|
drawingStateDescription1.textAntialiasMode = desc.textAntialiasMode;
|
|
drawingStateDescription1.tag1 = desc.tag1;
|
|
drawingStateDescription1.tag2 = desc.tag2;
|
|
drawingStateDescription1.transform = desc.transform;
|
|
drawingStateDescription1.primitiveBlend = primitiveBlend;
|
|
drawingStateDescription1.unitMode = unitMode;
|
|
|
|
return drawingStateDescription1;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
D2D1FORCEINLINE
|
|
D2D1_BITMAP_PROPERTIES1
|
|
BitmapProperties1(
|
|
D2D1_BITMAP_OPTIONS bitmapOptions = D2D1_BITMAP_OPTIONS_NONE,
|
|
_In_ CONST D2D1_PIXEL_FORMAT pixelFormat = D2D1::PixelFormat(),
|
|
FLOAT dpiX = 96.0f,
|
|
FLOAT dpiY = 96.0f,
|
|
_In_opt_ ID2D1ColorContext *colorContext = NULL
|
|
)
|
|
{
|
|
D2D1_BITMAP_PROPERTIES1 bitmapProperties =
|
|
{
|
|
pixelFormat,
|
|
dpiX, dpiY,
|
|
bitmapOptions,
|
|
colorContext
|
|
};
|
|
|
|
return bitmapProperties;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
D2D1FORCEINLINE
|
|
D2D1_LAYER_PARAMETERS1
|
|
LayerParameters1(
|
|
_In_ CONST D2D1_RECT_F &contentBounds = D2D1::InfiniteRect(),
|
|
_In_opt_ ID2D1Geometry *geometricMask = NULL,
|
|
D2D1_ANTIALIAS_MODE maskAntialiasMode = D2D1_ANTIALIAS_MODE_PER_PRIMITIVE,
|
|
D2D1_MATRIX_3X2_F maskTransform = D2D1::IdentityMatrix(),
|
|
FLOAT opacity = 1.0,
|
|
_In_opt_ ID2D1Brush *opacityBrush = NULL,
|
|
D2D1_LAYER_OPTIONS1 layerOptions = D2D1_LAYER_OPTIONS1_NONE
|
|
)
|
|
{
|
|
D2D1_LAYER_PARAMETERS1 layerParameters = { 0 };
|
|
|
|
layerParameters.contentBounds = contentBounds;
|
|
layerParameters.geometricMask = geometricMask;
|
|
layerParameters.maskAntialiasMode = maskAntialiasMode;
|
|
layerParameters.maskTransform = maskTransform;
|
|
layerParameters.opacity = opacity;
|
|
layerParameters.opacityBrush = opacityBrush;
|
|
layerParameters.layerOptions = layerOptions;
|
|
|
|
return layerParameters;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
D2D1FORCEINLINE
|
|
D2D1_STROKE_STYLE_PROPERTIES1
|
|
StrokeStyleProperties1(
|
|
D2D1_CAP_STYLE startCap = D2D1_CAP_STYLE_FLAT,
|
|
D2D1_CAP_STYLE endCap = D2D1_CAP_STYLE_FLAT,
|
|
D2D1_CAP_STYLE dashCap = D2D1_CAP_STYLE_FLAT,
|
|
D2D1_LINE_JOIN lineJoin = D2D1_LINE_JOIN_MITER,
|
|
FLOAT miterLimit = 10.0f,
|
|
D2D1_DASH_STYLE dashStyle = D2D1_DASH_STYLE_SOLID,
|
|
FLOAT dashOffset = 0.0f,
|
|
D2D1_STROKE_TRANSFORM_TYPE transformType = D2D1_STROKE_TRANSFORM_TYPE_NORMAL
|
|
)
|
|
{
|
|
D2D1_STROKE_STYLE_PROPERTIES1 strokeStyleProperties;
|
|
|
|
strokeStyleProperties.startCap = startCap;
|
|
strokeStyleProperties.endCap = endCap;
|
|
strokeStyleProperties.dashCap = dashCap;
|
|
strokeStyleProperties.lineJoin = lineJoin;
|
|
strokeStyleProperties.miterLimit = miterLimit;
|
|
strokeStyleProperties.dashStyle = dashStyle;
|
|
strokeStyleProperties.dashOffset = dashOffset;
|
|
strokeStyleProperties.transformType = transformType;
|
|
|
|
return strokeStyleProperties;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
D2D1FORCEINLINE
|
|
D2D1_IMAGE_BRUSH_PROPERTIES
|
|
ImageBrushProperties(
|
|
D2D1_RECT_F sourceRectangle,
|
|
D2D1_EXTEND_MODE extendModeX = D2D1_EXTEND_MODE_CLAMP,
|
|
D2D1_EXTEND_MODE extendModeY = D2D1_EXTEND_MODE_CLAMP,
|
|
D2D1_INTERPOLATION_MODE interpolationMode = D2D1_INTERPOLATION_MODE_LINEAR
|
|
)
|
|
{
|
|
D2D1_IMAGE_BRUSH_PROPERTIES imageBrushProperties;
|
|
|
|
imageBrushProperties.extendModeX = extendModeX;
|
|
imageBrushProperties.extendModeY = extendModeY;
|
|
imageBrushProperties.interpolationMode = interpolationMode;
|
|
imageBrushProperties.sourceRectangle = sourceRectangle;
|
|
|
|
return imageBrushProperties;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
D2D1FORCEINLINE
|
|
D2D1_BITMAP_BRUSH_PROPERTIES1
|
|
BitmapBrushProperties1(
|
|
D2D1_EXTEND_MODE extendModeX = D2D1_EXTEND_MODE_CLAMP,
|
|
D2D1_EXTEND_MODE extendModeY = D2D1_EXTEND_MODE_CLAMP,
|
|
D2D1_INTERPOLATION_MODE interpolationMode = D2D1_INTERPOLATION_MODE_LINEAR
|
|
)
|
|
{
|
|
D2D1_BITMAP_BRUSH_PROPERTIES1 bitmapBrush1Properties;
|
|
|
|
bitmapBrush1Properties.extendModeX = extendModeX;
|
|
bitmapBrush1Properties.extendModeY = extendModeY;
|
|
bitmapBrush1Properties.interpolationMode = interpolationMode;
|
|
|
|
return bitmapBrush1Properties;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
D2D1FORCEINLINE
|
|
D2D1_PRINT_CONTROL_PROPERTIES
|
|
PrintControlProperties(
|
|
D2D1_PRINT_FONT_SUBSET_MODE fontSubsetMode = D2D1_PRINT_FONT_SUBSET_MODE_DEFAULT,
|
|
FLOAT rasterDpi = 150.0f,
|
|
D2D1_COLOR_SPACE colorSpace = D2D1_COLOR_SPACE_SRGB
|
|
)
|
|
{
|
|
D2D1_PRINT_CONTROL_PROPERTIES printControlProps;
|
|
|
|
printControlProps.fontSubset = fontSubsetMode;
|
|
printControlProps.rasterDPI = rasterDpi;
|
|
printControlProps.colorSpace = colorSpace;
|
|
|
|
return printControlProps;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
D2D1FORCEINLINE
|
|
D2D1_RENDERING_CONTROLS
|
|
RenderingControls(
|
|
D2D1_BUFFER_PRECISION bufferPrecision,
|
|
D2D1_SIZE_U tileSize
|
|
)
|
|
{
|
|
D2D1_RENDERING_CONTROLS renderingControls;
|
|
|
|
renderingControls.bufferPrecision = bufferPrecision;
|
|
renderingControls.tileSize = tileSize;
|
|
|
|
return renderingControls;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
D2D1FORCEINLINE
|
|
D2D1_EFFECT_INPUT_DESCRIPTION
|
|
EffectInputDescription(
|
|
ID2D1Effect *effect,
|
|
UINT32 inputIndex,
|
|
D2D1_RECT_F inputRectangle
|
|
)
|
|
{
|
|
D2D1_EFFECT_INPUT_DESCRIPTION description;
|
|
|
|
description.effect = effect;
|
|
description.inputIndex = inputIndex;
|
|
description.inputRectangle = inputRectangle;
|
|
|
|
return description;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
D2D1FORCEINLINE
|
|
D2D1_CREATION_PROPERTIES
|
|
CreationProperties(
|
|
D2D1_THREADING_MODE threadingMode,
|
|
D2D1_DEBUG_LEVEL debugLevel,
|
|
D2D1_DEVICE_CONTEXT_OPTIONS options
|
|
)
|
|
{
|
|
D2D1_CREATION_PROPERTIES creationProperties;
|
|
|
|
creationProperties.threadingMode = threadingMode;
|
|
creationProperties.debugLevel = debugLevel;
|
|
creationProperties.options = options;
|
|
|
|
return creationProperties;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
D2D1FORCEINLINE
|
|
D2D1_VECTOR_2F
|
|
Vector2F(
|
|
FLOAT x = 0.0f,
|
|
FLOAT y = 0.0f
|
|
)
|
|
{
|
|
D2D1_VECTOR_2F vec2 = {x, y};
|
|
return vec2;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
D2D1FORCEINLINE
|
|
D2D1_VECTOR_3F
|
|
Vector3F(
|
|
FLOAT x = 0.0f,
|
|
FLOAT y = 0.0f,
|
|
FLOAT z = 0.0f
|
|
)
|
|
{
|
|
D2D1_VECTOR_3F vec3 = {x, y, z};
|
|
return vec3;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
D2D1FORCEINLINE
|
|
D2D1_VECTOR_4F
|
|
Vector4F(
|
|
FLOAT x = 0.0f,
|
|
FLOAT y = 0.0f,
|
|
FLOAT z = 0.0f,
|
|
FLOAT w = 0.0f
|
|
)
|
|
{
|
|
D2D1_VECTOR_4F vec4 = {x, y, z, w};
|
|
return vec4;
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
D2D1FORCEINLINE
|
|
D2D1_POINT_2L
|
|
Point2L(
|
|
INT32 x = 0,
|
|
INT32 y = 0
|
|
)
|
|
{
|
|
return Point2<INT32>(x, y);
|
|
}
|
|
|
|
COM_DECLSPEC_NOTHROW
|
|
D2D1FORCEINLINE
|
|
D2D1_RECT_L
|
|
RectL(
|
|
INT32 left = 0.f,
|
|
INT32 top = 0.f,
|
|
INT32 right = 0.f,
|
|
INT32 bottom = 0.f
|
|
)
|
|
{
|
|
return Rect<INT32>(left, top, right, bottom);
|
|
}
|
|
|
|
//
|
|
// Sets a bitmap as an effect input, while inserting a DPI compensation effect
|
|
// to preserve visual appearance as the device context's DPI changes.
|
|
//
|
|
COM_DECLSPEC_NOTHROW
|
|
D2D1FORCEINLINE
|
|
HRESULT
|
|
SetDpiCompensatedEffectInput(
|
|
_In_ ID2D1DeviceContext *deviceContext,
|
|
_In_ ID2D1Effect *effect,
|
|
UINT32 inputIndex,
|
|
_In_opt_ ID2D1Bitmap *inputBitmap,
|
|
D2D1_INTERPOLATION_MODE interpolationMode = D2D1_INTERPOLATION_MODE_LINEAR,
|
|
D2D1_BORDER_MODE borderMode = D2D1_BORDER_MODE_HARD
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ID2D1Effect *dpiCompensationEffect = NULL;
|
|
|
|
if (!inputBitmap)
|
|
{
|
|
effect->SetInput(inputIndex, NULL);
|
|
return hr;
|
|
}
|
|
|
|
hr = deviceContext->CreateEffect(CLSID_D2D1DpiCompensation, &dpiCompensationEffect);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
dpiCompensationEffect->SetInput(0, inputBitmap);
|
|
|
|
D2D1_POINT_2F bitmapDpi;
|
|
inputBitmap->GetDpi(&bitmapDpi.x, &bitmapDpi.y);
|
|
hr = dpiCompensationEffect->SetValue(D2D1_DPICOMPENSATION_PROP_INPUT_DPI, bitmapDpi);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = dpiCompensationEffect->SetValue(D2D1_DPICOMPENSATION_PROP_INTERPOLATION_MODE, interpolationMode);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = dpiCompensationEffect->SetValue(D2D1_DPICOMPENSATION_PROP_BORDER_MODE, borderMode);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
effect->SetInputEffect(inputIndex, dpiCompensationEffect);
|
|
}
|
|
|
|
if (dpiCompensationEffect)
|
|
{
|
|
dpiCompensationEffect->Release();
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
} // namespace D2D1
|
|
|
|
#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */
|
|
#pragma endregion
|
|
|
|
#endif // #ifndef D2D_USE_C_DEFINITIONS
|
|
|
|
#endif // #ifndef _D2D1_HELPER_H_
|
|
|