RPCS3/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2024-11-23 03:02:53 +01:00
Code Issues Releases Wiki Activity
ac712bf4e3
rpcs3/3rdparty/minidx12/Include/d2d1_1helper.h
AnnieL afefecf1f0 Moves GL, minidx12, OpenAL, stblib to 3rdparty 
Moves GL, minidx12, OpenAL, stblib to 3rdparty

Fixes AppVeyor and CMakeLists (travis-ci.yml doesn't need any changes)

Points directories in the VS solution files to the new ones on the
externals directory

Includes stuff with the < > syntax instead of " "
2016-03-20 22:20:23 +00:00

925 lines
25 KiB
C++
Raw Blame History

/*=========================================================================*\
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_
Reference in New Issue View Git Blame Copy Permalink