DirectXTex updated to January 2023 (#47)
This commit is contained in:
Родитель
95f3f7fe34
Коммит
9aabad0707
|
@ -84,9 +84,9 @@ namespace
|
|||
|
||||
for (size_t iPoint = 0; iPoint < NUM_PIXELS_PER_BLOCK; iPoint++)
|
||||
{
|
||||
#ifdef COLOR_WEIGHTS
|
||||
#ifdef COLOR_WEIGHTS
|
||||
if (pPoints[iPoint].a > 0.0f)
|
||||
#endif // COLOR_WEIGHTS
|
||||
#endif // COLOR_WEIGHTS
|
||||
{
|
||||
if (pPoints[iPoint].r < X.r)
|
||||
X.r = pPoints[iPoint].r;
|
||||
|
@ -144,7 +144,7 @@ namespace
|
|||
|
||||
float f;
|
||||
|
||||
#ifdef COLOR_WEIGHTS
|
||||
#ifdef COLOR_WEIGHTS
|
||||
f = Pt.r + Pt.g + Pt.b;
|
||||
fDir[0] += pPoints[iPoint].a * f * f;
|
||||
|
||||
|
@ -156,7 +156,7 @@ namespace
|
|||
|
||||
f = Pt.r - Pt.g - Pt.b;
|
||||
fDir[3] += pPoints[iPoint].a * f * f;
|
||||
#else
|
||||
#else
|
||||
f = Pt.r + Pt.g + Pt.b;
|
||||
fDir[0] += f * f;
|
||||
|
||||
|
@ -168,7 +168,7 @@ namespace
|
|||
|
||||
f = Pt.r - Pt.g - Pt.b;
|
||||
fDir[3] += f * f;
|
||||
#endif // COLOR_WEIGHTS
|
||||
#endif // COLOR_WEIGHTS
|
||||
}
|
||||
|
||||
float fDirMax = fDir[0];
|
||||
|
@ -264,13 +264,13 @@ namespace
|
|||
Diff.b = pSteps[iStep].b - pPoints[iPoint].b;
|
||||
Diff.a = 0.0f;
|
||||
|
||||
#ifdef COLOR_WEIGHTS
|
||||
#ifdef COLOR_WEIGHTS
|
||||
const float fC = pC[iStep] * pPoints[iPoint].a * (1.0f / 8.0f);
|
||||
const float fD = pD[iStep] * pPoints[iPoint].a * (1.0f / 8.0f);
|
||||
#else
|
||||
#else
|
||||
const float fC = pC[iStep] * (1.0f / 8.0f);
|
||||
const float fD = pD[iStep] * (1.0f / 8.0f);
|
||||
#endif // COLOR_WEIGHTS
|
||||
#endif // COLOR_WEIGHTS
|
||||
|
||||
d2X += fC * pC[iStep];
|
||||
dX.r += fC * Diff.r;
|
||||
|
@ -434,11 +434,11 @@ namespace
|
|||
Color[i].g = static_cast<float>(static_cast<int32_t>(Clr.g * 63.0f + 0.5f)) * (1.0f / 63.0f);
|
||||
Color[i].b = static_cast<float>(static_cast<int32_t>(Clr.b * 31.0f + 0.5f)) * (1.0f / 31.0f);
|
||||
|
||||
#ifdef COLOR_WEIGHTS
|
||||
#ifdef COLOR_WEIGHTS
|
||||
Color[i].a = pColor[i].a;
|
||||
#else
|
||||
#else
|
||||
Color[i].a = 1.0f;
|
||||
#endif // COLOR_WEIGHTS
|
||||
#endif // COLOR_WEIGHTS
|
||||
|
||||
if (flags & BC_FLAGS_DITHER_RGB)
|
||||
{
|
||||
|
@ -688,7 +688,7 @@ namespace
|
|||
#ifdef COLOR_WEIGHTS
|
||||
void EncodeSolidBC1(_Out_ D3DX_BC1 *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const HDRColorA *pColor)
|
||||
{
|
||||
#ifdef COLOR_AVG_0WEIGHTS
|
||||
#ifdef COLOR_AVG_0WEIGHTS
|
||||
// Compute avg color
|
||||
HDRColorA Color;
|
||||
Color.r = pColor[0].r;
|
||||
|
@ -707,9 +707,9 @@ namespace
|
|||
Color.b *= 1.0f / 16.0f;
|
||||
|
||||
const uint16_t wColor = Encode565(&Color);
|
||||
#else
|
||||
#else
|
||||
const uint16_t wColor = 0x0000;
|
||||
#endif // COLOR_AVG_0WEIGHTS
|
||||
#endif // COLOR_AVG_0WEIGHTS
|
||||
|
||||
// Encode solid block
|
||||
pBC->rgb[0] = wColor;
|
||||
|
@ -814,7 +814,7 @@ void DirectX::D3DXDecodeBC2(XMVECTOR *pColor, const uint8_t *pBC) noexcept
|
|||
|
||||
for (size_t i = 0; i < 8; ++i, dw >>= 4)
|
||||
{
|
||||
#pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
|
||||
#pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
|
||||
pColor[i] = XMVectorSetW(pColor[i], static_cast<float>(dw & 0xf) * (1.0f / 15.0f));
|
||||
}
|
||||
|
||||
|
|
|
@ -27,141 +27,150 @@ namespace DirectX
|
|||
// Constants
|
||||
//-------------------------------------------------------------------------------------
|
||||
|
||||
enum BC_FLAGS : uint32_t
|
||||
{
|
||||
BC_FLAGS_NONE = 0x0,
|
||||
BC_FLAGS_DITHER_RGB = 0x10000, // Enables dithering for RGB colors for BC1-3
|
||||
BC_FLAGS_DITHER_A = 0x20000, // Enables dithering for Alpha channel for BC1-3
|
||||
BC_FLAGS_UNIFORM = 0x40000, // By default, uses perceptual weighting for BC1-3; this flag makes it a uniform weighting
|
||||
BC_FLAGS_USE_3SUBSETS = 0x80000, // By default, BC7 skips mode 0 & 2; this flag adds those modes back
|
||||
BC_FLAGS_FORCE_BC7_MODE6 = 0x100000, // BC7 should only use mode 6; skip other modes
|
||||
};
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
// Structures
|
||||
//-------------------------------------------------------------------------------------
|
||||
class LDRColorA;
|
||||
|
||||
class HDRColorA
|
||||
{
|
||||
public:
|
||||
float r, g, b, a;
|
||||
|
||||
public:
|
||||
HDRColorA() = default;
|
||||
HDRColorA(float _r, float _g, float _b, float _a) noexcept : r(_r), g(_g), b(_b), a(_a) {}
|
||||
HDRColorA(const HDRColorA& c) noexcept : r(c.r), g(c.g), b(c.b), a(c.a) {}
|
||||
|
||||
// binary operators
|
||||
HDRColorA operator + (const HDRColorA& c) const noexcept
|
||||
enum BC_FLAGS : uint32_t
|
||||
{
|
||||
return HDRColorA(r + c.r, g + c.g, b + c.b, a + c.a);
|
||||
}
|
||||
BC_FLAGS_NONE = 0x0,
|
||||
|
||||
HDRColorA operator - (const HDRColorA& c) const noexcept
|
||||
BC_FLAGS_DITHER_RGB = 0x10000,
|
||||
// Enables dithering for RGB colors for BC1-3
|
||||
|
||||
BC_FLAGS_DITHER_A = 0x20000,
|
||||
// Enables dithering for Alpha channel for BC1-3
|
||||
|
||||
BC_FLAGS_UNIFORM = 0x40000,
|
||||
// By default, uses perceptual weighting for BC1-3; this flag makes it a uniform weighting
|
||||
|
||||
BC_FLAGS_USE_3SUBSETS = 0x80000,
|
||||
// By default, BC7 skips mode 0 & 2; this flag adds those modes back
|
||||
|
||||
BC_FLAGS_FORCE_BC7_MODE6 = 0x100000,
|
||||
// BC7 should only use mode 6; skip other modes
|
||||
};
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
// Structures
|
||||
//-------------------------------------------------------------------------------------
|
||||
class LDRColorA;
|
||||
|
||||
class HDRColorA
|
||||
{
|
||||
return HDRColorA(r - c.r, g - c.g, b - c.b, a - c.a);
|
||||
}
|
||||
public:
|
||||
float r, g, b, a;
|
||||
|
||||
HDRColorA operator * (float f) const noexcept
|
||||
public:
|
||||
HDRColorA() = default;
|
||||
HDRColorA(float _r, float _g, float _b, float _a) noexcept : r(_r), g(_g), b(_b), a(_a) {}
|
||||
|
||||
// binary operators
|
||||
HDRColorA operator + (const HDRColorA& c) const noexcept
|
||||
{
|
||||
return HDRColorA(r + c.r, g + c.g, b + c.b, a + c.a);
|
||||
}
|
||||
|
||||
HDRColorA operator - (const HDRColorA& c) const noexcept
|
||||
{
|
||||
return HDRColorA(r - c.r, g - c.g, b - c.b, a - c.a);
|
||||
}
|
||||
|
||||
HDRColorA operator * (float f) const noexcept
|
||||
{
|
||||
return HDRColorA(r * f, g * f, b * f, a * f);
|
||||
}
|
||||
|
||||
HDRColorA operator / (float f) const noexcept
|
||||
{
|
||||
const float fInv = 1.0f / f;
|
||||
return HDRColorA(r * fInv, g * fInv, b * fInv, a * fInv);
|
||||
}
|
||||
|
||||
float operator * (const HDRColorA& c) const noexcept
|
||||
{
|
||||
return r * c.r + g * c.g + b * c.b + a * c.a;
|
||||
}
|
||||
|
||||
// assignment operators
|
||||
HDRColorA& operator += (const HDRColorA& c) noexcept
|
||||
{
|
||||
r += c.r;
|
||||
g += c.g;
|
||||
b += c.b;
|
||||
a += c.a;
|
||||
return *this;
|
||||
}
|
||||
|
||||
HDRColorA& operator -= (const HDRColorA& c) noexcept
|
||||
{
|
||||
r -= c.r;
|
||||
g -= c.g;
|
||||
b -= c.b;
|
||||
a -= c.a;
|
||||
return *this;
|
||||
}
|
||||
|
||||
HDRColorA& operator *= (float f) noexcept
|
||||
{
|
||||
r *= f;
|
||||
g *= f;
|
||||
b *= f;
|
||||
a *= f;
|
||||
return *this;
|
||||
}
|
||||
|
||||
HDRColorA& operator /= (float f) noexcept
|
||||
{
|
||||
const float fInv = 1.0f / f;
|
||||
r *= fInv;
|
||||
g *= fInv;
|
||||
b *= fInv;
|
||||
a *= fInv;
|
||||
return *this;
|
||||
}
|
||||
|
||||
HDRColorA& Clamp(_In_ float fMin, _In_ float fMax) noexcept
|
||||
{
|
||||
r = std::min<float>(fMax, std::max<float>(fMin, r));
|
||||
g = std::min<float>(fMax, std::max<float>(fMin, g));
|
||||
b = std::min<float>(fMax, std::max<float>(fMin, b));
|
||||
a = std::min<float>(fMax, std::max<float>(fMin, a));
|
||||
return *this;
|
||||
}
|
||||
|
||||
HDRColorA(const LDRColorA& c) noexcept;
|
||||
HDRColorA& operator = (const LDRColorA& c) noexcept;
|
||||
LDRColorA ToLDRColorA() const noexcept;
|
||||
};
|
||||
|
||||
inline HDRColorA* HDRColorALerp(_Out_ HDRColorA *pOut, _In_ const HDRColorA *pC1, _In_ const HDRColorA *pC2, _In_ float s) noexcept
|
||||
{
|
||||
return HDRColorA(r * f, g * f, b * f, a * f);
|
||||
pOut->r = pC1->r + s * (pC2->r - pC1->r);
|
||||
pOut->g = pC1->g + s * (pC2->g - pC1->g);
|
||||
pOut->b = pC1->b + s * (pC2->b - pC1->b);
|
||||
pOut->a = pC1->a + s * (pC2->a - pC1->a);
|
||||
return pOut;
|
||||
}
|
||||
|
||||
HDRColorA operator / (float f) const noexcept
|
||||
{
|
||||
const float fInv = 1.0f / f;
|
||||
return HDRColorA(r * fInv, g * fInv, b * fInv, a * fInv);
|
||||
}
|
||||
|
||||
float operator * (const HDRColorA& c) const noexcept
|
||||
{
|
||||
return r * c.r + g * c.g + b * c.b + a * c.a;
|
||||
}
|
||||
|
||||
// assignment operators
|
||||
HDRColorA& operator += (const HDRColorA& c) noexcept
|
||||
{
|
||||
r += c.r;
|
||||
g += c.g;
|
||||
b += c.b;
|
||||
a += c.a;
|
||||
return *this;
|
||||
}
|
||||
|
||||
HDRColorA& operator -= (const HDRColorA& c) noexcept
|
||||
{
|
||||
r -= c.r;
|
||||
g -= c.g;
|
||||
b -= c.b;
|
||||
a -= c.a;
|
||||
return *this;
|
||||
}
|
||||
|
||||
HDRColorA& operator *= (float f) noexcept
|
||||
{
|
||||
r *= f;
|
||||
g *= f;
|
||||
b *= f;
|
||||
a *= f;
|
||||
return *this;
|
||||
}
|
||||
|
||||
HDRColorA& operator /= (float f) noexcept
|
||||
{
|
||||
const float fInv = 1.0f / f;
|
||||
r *= fInv;
|
||||
g *= fInv;
|
||||
b *= fInv;
|
||||
a *= fInv;
|
||||
return *this;
|
||||
}
|
||||
|
||||
HDRColorA& Clamp(_In_ float fMin, _In_ float fMax) noexcept
|
||||
{
|
||||
r = std::min<float>(fMax, std::max<float>(fMin, r));
|
||||
g = std::min<float>(fMax, std::max<float>(fMin, g));
|
||||
b = std::min<float>(fMax, std::max<float>(fMin, b));
|
||||
a = std::min<float>(fMax, std::max<float>(fMin, a));
|
||||
return *this;
|
||||
}
|
||||
|
||||
HDRColorA(const LDRColorA& c) noexcept;
|
||||
HDRColorA& operator = (const LDRColorA& c) noexcept;
|
||||
LDRColorA ToLDRColorA() const noexcept;
|
||||
};
|
||||
|
||||
inline HDRColorA* HDRColorALerp(_Out_ HDRColorA *pOut, _In_ const HDRColorA *pC1, _In_ const HDRColorA *pC2, _In_ float s) noexcept
|
||||
{
|
||||
pOut->r = pC1->r + s * (pC2->r - pC1->r);
|
||||
pOut->g = pC1->g + s * (pC2->g - pC1->g);
|
||||
pOut->b = pC1->b + s * (pC2->b - pC1->b);
|
||||
pOut->a = pC1->a + s * (pC2->a - pC1->a);
|
||||
return pOut;
|
||||
}
|
||||
|
||||
#pragma pack(push,1)
|
||||
// BC1/DXT1 compression (4 bits per texel)
|
||||
struct D3DX_BC1
|
||||
{
|
||||
uint16_t rgb[2]; // 565 colors
|
||||
uint32_t bitmap; // 2bpp rgb bitmap
|
||||
};
|
||||
struct D3DX_BC1
|
||||
{
|
||||
uint16_t rgb[2]; // 565 colors
|
||||
uint32_t bitmap; // 2bpp rgb bitmap
|
||||
};
|
||||
|
||||
// BC2/DXT2/3 compression (8 bits per texel)
|
||||
struct D3DX_BC2
|
||||
{
|
||||
uint32_t bitmap[2]; // 4bpp alpha bitmap
|
||||
D3DX_BC1 bc1; // BC1 rgb data
|
||||
};
|
||||
// BC2/DXT2/3 compression (8 bits per texel)
|
||||
struct D3DX_BC2
|
||||
{
|
||||
uint32_t bitmap[2]; // 4bpp alpha bitmap
|
||||
D3DX_BC1 bc1; // BC1 rgb data
|
||||
};
|
||||
|
||||
// BC3/DXT4/5 compression (8 bits per texel)
|
||||
struct D3DX_BC3
|
||||
{
|
||||
uint8_t alpha[2]; // alpha values
|
||||
uint8_t bitmap[6]; // 3bpp alpha bitmap
|
||||
D3DX_BC1 bc1; // BC1 rgb data
|
||||
};
|
||||
// BC3/DXT4/5 compression (8 bits per texel)
|
||||
struct D3DX_BC3
|
||||
{
|
||||
uint8_t alpha[2]; // alpha values
|
||||
uint8_t bitmap[6]; // 3bpp alpha bitmap
|
||||
D3DX_BC1 bc1; // BC1 rgb data
|
||||
};
|
||||
#pragma pack(pop)
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
|
@ -169,162 +178,162 @@ struct D3DX_BC3
|
|||
//-------------------------------------------------------------------------------------
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable : 4127)
|
||||
template <bool bRange> void OptimizeAlpha(float *pX, float *pY, const float *pPoints, uint32_t cSteps) noexcept
|
||||
{
|
||||
static const float pC6[] = { 5.0f / 5.0f, 4.0f / 5.0f, 3.0f / 5.0f, 2.0f / 5.0f, 1.0f / 5.0f, 0.0f / 5.0f };
|
||||
static const float pD6[] = { 0.0f / 5.0f, 1.0f / 5.0f, 2.0f / 5.0f, 3.0f / 5.0f, 4.0f / 5.0f, 5.0f / 5.0f };
|
||||
static const float pC8[] = { 7.0f / 7.0f, 6.0f / 7.0f, 5.0f / 7.0f, 4.0f / 7.0f, 3.0f / 7.0f, 2.0f / 7.0f, 1.0f / 7.0f, 0.0f / 7.0f };
|
||||
static const float pD8[] = { 0.0f / 7.0f, 1.0f / 7.0f, 2.0f / 7.0f, 3.0f / 7.0f, 4.0f / 7.0f, 5.0f / 7.0f, 6.0f / 7.0f, 7.0f / 7.0f };
|
||||
|
||||
const float *pC = (6 == cSteps) ? pC6 : pC8;
|
||||
const float *pD = (6 == cSteps) ? pD6 : pD8;
|
||||
|
||||
constexpr float MAX_VALUE = 1.0f;
|
||||
constexpr float MIN_VALUE = (bRange) ? -1.0f : 0.0f;
|
||||
|
||||
// Find Min and Max points, as starting point
|
||||
float fX = MAX_VALUE;
|
||||
float fY = MIN_VALUE;
|
||||
|
||||
if (8 == cSteps)
|
||||
template <bool bRange> void OptimizeAlpha(float *pX, float *pY, const float *pPoints, uint32_t cSteps) noexcept
|
||||
{
|
||||
for (size_t iPoint = 0; iPoint < NUM_PIXELS_PER_BLOCK; iPoint++)
|
||||
{
|
||||
if (pPoints[iPoint] < fX)
|
||||
fX = pPoints[iPoint];
|
||||
static const float pC6[] = { 5.0f / 5.0f, 4.0f / 5.0f, 3.0f / 5.0f, 2.0f / 5.0f, 1.0f / 5.0f, 0.0f / 5.0f };
|
||||
static const float pD6[] = { 0.0f / 5.0f, 1.0f / 5.0f, 2.0f / 5.0f, 3.0f / 5.0f, 4.0f / 5.0f, 5.0f / 5.0f };
|
||||
static const float pC8[] = { 7.0f / 7.0f, 6.0f / 7.0f, 5.0f / 7.0f, 4.0f / 7.0f, 3.0f / 7.0f, 2.0f / 7.0f, 1.0f / 7.0f, 0.0f / 7.0f };
|
||||
static const float pD8[] = { 0.0f / 7.0f, 1.0f / 7.0f, 2.0f / 7.0f, 3.0f / 7.0f, 4.0f / 7.0f, 5.0f / 7.0f, 6.0f / 7.0f, 7.0f / 7.0f };
|
||||
|
||||
if (pPoints[iPoint] > fY)
|
||||
fY = pPoints[iPoint];
|
||||
const float *pC = (6 == cSteps) ? pC6 : pC8;
|
||||
const float *pD = (6 == cSteps) ? pD6 : pD8;
|
||||
|
||||
constexpr float MAX_VALUE = 1.0f;
|
||||
constexpr float MIN_VALUE = (bRange) ? -1.0f : 0.0f;
|
||||
|
||||
// Find Min and Max points, as starting point
|
||||
float fX = MAX_VALUE;
|
||||
float fY = MIN_VALUE;
|
||||
|
||||
if (8 == cSteps)
|
||||
{
|
||||
for (size_t iPoint = 0; iPoint < NUM_PIXELS_PER_BLOCK; iPoint++)
|
||||
{
|
||||
if (pPoints[iPoint] < fX)
|
||||
fX = pPoints[iPoint];
|
||||
|
||||
if (pPoints[iPoint] > fY)
|
||||
fY = pPoints[iPoint];
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (size_t iPoint = 0; iPoint < NUM_PIXELS_PER_BLOCK; iPoint++)
|
||||
{
|
||||
if (pPoints[iPoint] < fX && pPoints[iPoint] > MIN_VALUE)
|
||||
fX = pPoints[iPoint];
|
||||
|
||||
if (pPoints[iPoint] > fY && pPoints[iPoint] < MAX_VALUE)
|
||||
fY = pPoints[iPoint];
|
||||
}
|
||||
|
||||
if (fX == fY)
|
||||
{
|
||||
fY = MAX_VALUE;
|
||||
}
|
||||
}
|
||||
|
||||
// Use Newton's Method to find local minima of sum-of-squares error.
|
||||
auto const fSteps = static_cast<float>(cSteps - 1);
|
||||
|
||||
for (size_t iIteration = 0; iIteration < 8; iIteration++)
|
||||
{
|
||||
if ((fY - fX) < (1.0f / 256.0f))
|
||||
break;
|
||||
|
||||
float const fScale = fSteps / (fY - fX);
|
||||
|
||||
// Calculate new steps
|
||||
float pSteps[8];
|
||||
|
||||
for (size_t iStep = 0; iStep < cSteps; iStep++)
|
||||
pSteps[iStep] = pC[iStep] * fX + pD[iStep] * fY;
|
||||
|
||||
if (6 == cSteps)
|
||||
{
|
||||
pSteps[6] = MIN_VALUE;
|
||||
pSteps[7] = MAX_VALUE;
|
||||
}
|
||||
|
||||
// Evaluate function, and derivatives
|
||||
float dX = 0.0f;
|
||||
float dY = 0.0f;
|
||||
float d2X = 0.0f;
|
||||
float d2Y = 0.0f;
|
||||
|
||||
for (size_t iPoint = 0; iPoint < NUM_PIXELS_PER_BLOCK; iPoint++)
|
||||
{
|
||||
const float fDot = (pPoints[iPoint] - fX) * fScale;
|
||||
|
||||
uint32_t iStep;
|
||||
if (fDot <= 0.0f)
|
||||
{
|
||||
// D3DX10 / D3DX11 didn't take into account the proper minimum value for the bRange (BC4S/BC5S) case
|
||||
iStep = ((6 == cSteps) && (pPoints[iPoint] <= (fX + MIN_VALUE) * 0.5f)) ? 6u : 0u;
|
||||
}
|
||||
else if (fDot >= fSteps)
|
||||
{
|
||||
iStep = ((6 == cSteps) && (pPoints[iPoint] >= (fY + MAX_VALUE) * 0.5f)) ? 7u : (cSteps - 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
iStep = uint32_t(fDot + 0.5f);
|
||||
}
|
||||
|
||||
if (iStep < cSteps)
|
||||
{
|
||||
// D3DX had this computation backwards (pPoints[iPoint] - pSteps[iStep])
|
||||
// this fix improves RMS of the alpha component
|
||||
const float fDiff = pSteps[iStep] - pPoints[iPoint];
|
||||
|
||||
dX += pC[iStep] * fDiff;
|
||||
d2X += pC[iStep] * pC[iStep];
|
||||
|
||||
dY += pD[iStep] * fDiff;
|
||||
d2Y += pD[iStep] * pD[iStep];
|
||||
}
|
||||
}
|
||||
|
||||
// Move endpoints
|
||||
if (d2X > 0.0f)
|
||||
fX -= dX / d2X;
|
||||
|
||||
if (d2Y > 0.0f)
|
||||
fY -= dY / d2Y;
|
||||
|
||||
if (fX > fY)
|
||||
{
|
||||
const float f = fX; fX = fY; fY = f;
|
||||
}
|
||||
|
||||
if ((dX * dX < (1.0f / 64.0f)) && (dY * dY < (1.0f / 64.0f)))
|
||||
break;
|
||||
}
|
||||
|
||||
*pX = (fX < MIN_VALUE) ? MIN_VALUE : (fX > MAX_VALUE) ? MAX_VALUE : fX;
|
||||
*pY = (fY < MIN_VALUE) ? MIN_VALUE : (fY > MAX_VALUE) ? MAX_VALUE : fY;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (size_t iPoint = 0; iPoint < NUM_PIXELS_PER_BLOCK; iPoint++)
|
||||
{
|
||||
if (pPoints[iPoint] < fX && pPoints[iPoint] > MIN_VALUE)
|
||||
fX = pPoints[iPoint];
|
||||
|
||||
if (pPoints[iPoint] > fY && pPoints[iPoint] < MAX_VALUE)
|
||||
fY = pPoints[iPoint];
|
||||
}
|
||||
|
||||
if (fX == fY)
|
||||
{
|
||||
fY = MAX_VALUE;
|
||||
}
|
||||
}
|
||||
|
||||
// Use Newton's Method to find local minima of sum-of-squares error.
|
||||
auto const fSteps = static_cast<float>(cSteps - 1);
|
||||
|
||||
for (size_t iIteration = 0; iIteration < 8; iIteration++)
|
||||
{
|
||||
if ((fY - fX) < (1.0f / 256.0f))
|
||||
break;
|
||||
|
||||
float const fScale = fSteps / (fY - fX);
|
||||
|
||||
// Calculate new steps
|
||||
float pSteps[8];
|
||||
|
||||
for (size_t iStep = 0; iStep < cSteps; iStep++)
|
||||
pSteps[iStep] = pC[iStep] * fX + pD[iStep] * fY;
|
||||
|
||||
if (6 == cSteps)
|
||||
{
|
||||
pSteps[6] = MIN_VALUE;
|
||||
pSteps[7] = MAX_VALUE;
|
||||
}
|
||||
|
||||
// Evaluate function, and derivatives
|
||||
float dX = 0.0f;
|
||||
float dY = 0.0f;
|
||||
float d2X = 0.0f;
|
||||
float d2Y = 0.0f;
|
||||
|
||||
for (size_t iPoint = 0; iPoint < NUM_PIXELS_PER_BLOCK; iPoint++)
|
||||
{
|
||||
const float fDot = (pPoints[iPoint] - fX) * fScale;
|
||||
|
||||
uint32_t iStep;
|
||||
if (fDot <= 0.0f)
|
||||
{
|
||||
// D3DX10 / D3DX11 didn't take into account the proper minimum value for the bRange (BC4S/BC5S) case
|
||||
iStep = ((6 == cSteps) && (pPoints[iPoint] <= (fX + MIN_VALUE) * 0.5f)) ? 6u : 0u;
|
||||
}
|
||||
else if (fDot >= fSteps)
|
||||
{
|
||||
iStep = ((6 == cSteps) && (pPoints[iPoint] >= (fY + MAX_VALUE) * 0.5f)) ? 7u : (cSteps - 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
iStep = uint32_t(fDot + 0.5f);
|
||||
}
|
||||
|
||||
if (iStep < cSteps)
|
||||
{
|
||||
// D3DX had this computation backwards (pPoints[iPoint] - pSteps[iStep])
|
||||
// this fix improves RMS of the alpha component
|
||||
const float fDiff = pSteps[iStep] - pPoints[iPoint];
|
||||
|
||||
dX += pC[iStep] * fDiff;
|
||||
d2X += pC[iStep] * pC[iStep];
|
||||
|
||||
dY += pD[iStep] * fDiff;
|
||||
d2Y += pD[iStep] * pD[iStep];
|
||||
}
|
||||
}
|
||||
|
||||
// Move endpoints
|
||||
if (d2X > 0.0f)
|
||||
fX -= dX / d2X;
|
||||
|
||||
if (d2Y > 0.0f)
|
||||
fY -= dY / d2Y;
|
||||
|
||||
if (fX > fY)
|
||||
{
|
||||
const float f = fX; fX = fY; fY = f;
|
||||
}
|
||||
|
||||
if ((dX * dX < (1.0f / 64.0f)) && (dY * dY < (1.0f / 64.0f)))
|
||||
break;
|
||||
}
|
||||
|
||||
*pX = (fX < MIN_VALUE) ? MIN_VALUE : (fX > MAX_VALUE) ? MAX_VALUE : fX;
|
||||
*pY = (fY < MIN_VALUE) ? MIN_VALUE : (fY > MAX_VALUE) ? MAX_VALUE : fY;
|
||||
}
|
||||
#pragma warning(pop)
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
// Functions
|
||||
//-------------------------------------------------------------------------------------
|
||||
|
||||
typedef void (*BC_DECODE)(XMVECTOR *pColor, const uint8_t *pBC);
|
||||
typedef void (*BC_ENCODE)(uint8_t *pDXT, const XMVECTOR *pColor, uint32_t flags);
|
||||
typedef void (*BC_DECODE)(XMVECTOR *pColor, const uint8_t *pBC);
|
||||
typedef void (*BC_ENCODE)(uint8_t *pDXT, const XMVECTOR *pColor, uint32_t flags);
|
||||
|
||||
void D3DXDecodeBC1(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(8) const uint8_t *pBC) noexcept;
|
||||
void D3DXDecodeBC2(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
|
||||
void D3DXDecodeBC3(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
|
||||
void D3DXDecodeBC4U(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(8) const uint8_t *pBC) noexcept;
|
||||
void D3DXDecodeBC4S(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(8) const uint8_t *pBC) noexcept;
|
||||
void D3DXDecodeBC5U(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
|
||||
void D3DXDecodeBC5S(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
|
||||
void D3DXDecodeBC6HU(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
|
||||
void D3DXDecodeBC6HS(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
|
||||
void D3DXDecodeBC7(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
|
||||
void D3DXDecodeBC1(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(8) const uint8_t *pBC) noexcept;
|
||||
void D3DXDecodeBC2(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
|
||||
void D3DXDecodeBC3(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
|
||||
void D3DXDecodeBC4U(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(8) const uint8_t *pBC) noexcept;
|
||||
void D3DXDecodeBC4S(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(8) const uint8_t *pBC) noexcept;
|
||||
void D3DXDecodeBC5U(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
|
||||
void D3DXDecodeBC5S(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
|
||||
void D3DXDecodeBC6HU(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
|
||||
void D3DXDecodeBC6HS(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
|
||||
void D3DXDecodeBC7(_Out_writes_(NUM_PIXELS_PER_BLOCK) XMVECTOR *pColor, _In_reads_(16) const uint8_t *pBC) noexcept;
|
||||
|
||||
void D3DXEncodeBC1(_Out_writes_(8) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ float threshold, _In_ uint32_t flags) noexcept;
|
||||
// BC1 requires one additional parameter, so it doesn't match signature of BC_ENCODE above
|
||||
void D3DXEncodeBC1(_Out_writes_(8) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ float threshold, _In_ uint32_t flags) noexcept;
|
||||
// BC1 requires one additional parameter, so it doesn't match signature of BC_ENCODE above
|
||||
|
||||
void D3DXEncodeBC2(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
|
||||
void D3DXEncodeBC3(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
|
||||
void D3DXEncodeBC4U(_Out_writes_(8) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
|
||||
void D3DXEncodeBC4S(_Out_writes_(8) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
|
||||
void D3DXEncodeBC5U(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
|
||||
void D3DXEncodeBC5S(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
|
||||
void D3DXEncodeBC6HU(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
|
||||
void D3DXEncodeBC6HS(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
|
||||
void D3DXEncodeBC7(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
|
||||
void D3DXEncodeBC2(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
|
||||
void D3DXEncodeBC3(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
|
||||
void D3DXEncodeBC4U(_Out_writes_(8) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
|
||||
void D3DXEncodeBC4S(_Out_writes_(8) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
|
||||
void D3DXEncodeBC5U(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
|
||||
void D3DXEncodeBC5S(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
|
||||
void D3DXEncodeBC6HU(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
|
||||
void D3DXEncodeBC6HS(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
|
||||
void D3DXEncodeBC7(_Out_writes_(16) uint8_t *pBC, _In_reads_(NUM_PIXELS_PER_BLOCK) const XMVECTOR *pColor, _In_ uint32_t flags) noexcept;
|
||||
|
||||
} // namespace
|
||||
|
|
|
@ -395,7 +395,7 @@ void DirectX::D3DXDecodeBC4U(XMVECTOR *pColor, const uint8_t *pBC) noexcept
|
|||
|
||||
for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
|
||||
{
|
||||
#pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
|
||||
#pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
|
||||
pColor[i] = XMVectorSet(pBC4->R(i), 0, 0, 1.0f);
|
||||
}
|
||||
}
|
||||
|
@ -410,7 +410,7 @@ void DirectX::D3DXDecodeBC4S(XMVECTOR *pColor, const uint8_t *pBC) noexcept
|
|||
|
||||
for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
|
||||
{
|
||||
#pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
|
||||
#pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
|
||||
pColor[i] = XMVectorSet(pBC4->R(i), 0, 0, 1.0f);
|
||||
}
|
||||
}
|
||||
|
@ -472,7 +472,7 @@ void DirectX::D3DXDecodeBC5U(XMVECTOR *pColor, const uint8_t *pBC) noexcept
|
|||
|
||||
for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
|
||||
{
|
||||
#pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
|
||||
#pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
|
||||
pColor[i] = XMVectorSet(pBCR->R(i), pBCG->R(i), 0, 1.0f);
|
||||
}
|
||||
}
|
||||
|
@ -488,7 +488,7 @@ void DirectX::D3DXDecodeBC5S(XMVECTOR *pColor, const uint8_t *pBC) noexcept
|
|||
|
||||
for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
|
||||
{
|
||||
#pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
|
||||
#pragma prefast(suppress:22103, "writing blocks in two halves confuses tool")
|
||||
pColor[i] = XMVectorSet(pBCR->R(i), pBCG->R(i), 0, 1.0f);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -452,7 +452,6 @@ namespace
|
|||
public:
|
||||
INTColor() = default;
|
||||
INTColor(int nr, int ng, int nb) noexcept : r(nr), g(ng), b(nb), pad(0) {}
|
||||
INTColor(const INTColor& c) noexcept : r(c.r), g(c.g), b(c.b), pad(0) {}
|
||||
|
||||
INTColor& operator += (_In_ const INTColor& c) noexcept
|
||||
{
|
||||
|
@ -660,8 +659,8 @@ namespace
|
|||
void Encode(_In_ bool bSigned, _In_reads_(NUM_PIXELS_PER_BLOCK) const HDRColorA* const pIn) noexcept;
|
||||
|
||||
private:
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable : 4480)
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable : 4480)
|
||||
enum EField : uint8_t
|
||||
{
|
||||
NA, // N/A
|
||||
|
@ -680,7 +679,7 @@ namespace
|
|||
BY,
|
||||
BZ,
|
||||
};
|
||||
#pragma warning(pop)
|
||||
#pragma warning(pop)
|
||||
|
||||
struct ModeDescriptor
|
||||
{
|
||||
|
@ -697,8 +696,8 @@ namespace
|
|||
LDRColorA RGBAPrec[BC6H_MAX_REGIONS][2];
|
||||
};
|
||||
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable : 4512)
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable : 4512)
|
||||
struct EncodeParams
|
||||
{
|
||||
float fBestErr;
|
||||
|
@ -718,7 +717,7 @@ namespace
|
|||
}
|
||||
}
|
||||
};
|
||||
#pragma warning(pop)
|
||||
#pragma warning(pop)
|
||||
|
||||
static int Quantize(_In_ int iValue, _In_ int prec, _In_ bool bSigned) noexcept;
|
||||
static int Unquantize(_In_ int comp, _In_ uint8_t uBitsPerComp, _In_ bool bSigned) noexcept;
|
||||
|
@ -751,9 +750,12 @@ namespace
|
|||
float RoughMSE(_Inout_ EncodeParams* pEP) const noexcept;
|
||||
|
||||
private:
|
||||
static const ModeDescriptor ms_aDesc[][82];
|
||||
static const ModeInfo ms_aInfo[];
|
||||
static const int ms_aModeToInfo[];
|
||||
static constexpr uint8_t c_NumModes = 14;
|
||||
static constexpr uint8_t c_NumModeInfo = 32;
|
||||
|
||||
static const ModeDescriptor ms_aDesc[c_NumModes][82];
|
||||
static const ModeInfo ms_aInfo[c_NumModes];
|
||||
static const int ms_aModeToInfo[c_NumModeInfo];
|
||||
};
|
||||
|
||||
// BC67 compression (16b bits per texel)
|
||||
|
@ -777,8 +779,8 @@ namespace
|
|||
LDRColorA RGBAPrecWithP;
|
||||
};
|
||||
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable : 4512)
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable : 4512)
|
||||
struct EncodeParams
|
||||
{
|
||||
uint8_t uMode;
|
||||
|
@ -788,7 +790,7 @@ namespace
|
|||
|
||||
EncodeParams(const HDRColorA* const aOriginal) noexcept : uMode(0), aEndPts{}, aLDRPixels{}, aHDRPixels(aOriginal) {}
|
||||
};
|
||||
#pragma warning(pop)
|
||||
#pragma warning(pop)
|
||||
|
||||
static uint8_t Quantize(_In_ uint8_t comp, _In_ uint8_t uPrec) noexcept
|
||||
{
|
||||
|
@ -856,12 +858,14 @@ namespace
|
|||
static float RoughMSE(_Inout_ EncodeParams* pEP, _In_ size_t uShape, _In_ size_t uIndexMode) noexcept;
|
||||
|
||||
private:
|
||||
static const ModeInfo ms_aInfo[];
|
||||
static constexpr uint8_t c_NumModes = 8;
|
||||
|
||||
static const ModeInfo ms_aInfo[c_NumModes];
|
||||
};
|
||||
}
|
||||
|
||||
// BC6H Compression
|
||||
const D3DX_BC6H::ModeDescriptor D3DX_BC6H::ms_aDesc[14][82] =
|
||||
const D3DX_BC6H::ModeDescriptor D3DX_BC6H::ms_aDesc[D3DX_BC6H::c_NumModes][82] =
|
||||
{
|
||||
{ // Mode 1 (0x00) - 10 5 5 5
|
||||
{ M, 0}, { M, 1}, {GY, 4}, {BY, 4}, {BZ, 4}, {RW, 0}, {RW, 1}, {RW, 2}, {RW, 3}, {RW, 4},
|
||||
|
@ -1033,25 +1037,25 @@ const D3DX_BC6H::ModeDescriptor D3DX_BC6H::ms_aDesc[14][82] =
|
|||
};
|
||||
|
||||
// Mode, Partitions, Transformed, IndexPrec, RGBAPrec
|
||||
const D3DX_BC6H::ModeInfo D3DX_BC6H::ms_aInfo[] =
|
||||
const D3DX_BC6H::ModeInfo D3DX_BC6H::ms_aInfo[D3DX_BC6H::c_NumModes] =
|
||||
{
|
||||
{0x00, 1, true, 3, { { LDRColorA(10,10,10,0), LDRColorA( 5, 5, 5,0) }, { LDRColorA(5,5,5,0), LDRColorA(5,5,5,0) } } }, // Mode 1
|
||||
{0x01, 1, true, 3, { { LDRColorA( 7, 7, 7,0), LDRColorA( 6, 6, 6,0) }, { LDRColorA(6,6,6,0), LDRColorA(6,6,6,0) } } }, // Mode 2
|
||||
{0x02, 1, true, 3, { { LDRColorA(11,11,11,0), LDRColorA( 5, 4, 4,0) }, { LDRColorA(5,4,4,0), LDRColorA(5,4,4,0) } } }, // Mode 3
|
||||
{0x06, 1, true, 3, { { LDRColorA(11,11,11,0), LDRColorA( 4, 5, 4,0) }, { LDRColorA(4,5,4,0), LDRColorA(4,5,4,0) } } }, // Mode 4
|
||||
{0x0a, 1, true, 3, { { LDRColorA(11,11,11,0), LDRColorA( 4, 4, 5,0) }, { LDRColorA(4,4,5,0), LDRColorA(4,4,5,0) } } }, // Mode 5
|
||||
{0x0e, 1, true, 3, { { LDRColorA( 9, 9, 9,0), LDRColorA( 5, 5, 5,0) }, { LDRColorA(5,5,5,0), LDRColorA(5,5,5,0) } } }, // Mode 6
|
||||
{0x12, 1, true, 3, { { LDRColorA( 8, 8, 8,0), LDRColorA( 6, 5, 5,0) }, { LDRColorA(6,5,5,0), LDRColorA(6,5,5,0) } } }, // Mode 7
|
||||
{0x16, 1, true, 3, { { LDRColorA( 8, 8, 8,0), LDRColorA( 5, 6, 5,0) }, { LDRColorA(5,6,5,0), LDRColorA(5,6,5,0) } } }, // Mode 8
|
||||
{0x1a, 1, true, 3, { { LDRColorA( 8, 8, 8,0), LDRColorA( 5, 5, 6,0) }, { LDRColorA(5,5,6,0), LDRColorA(5,5,6,0) } } }, // Mode 9
|
||||
{0x1e, 1, false, 3, { { LDRColorA( 6, 6, 6,0), LDRColorA( 6, 6, 6,0) }, { LDRColorA(6,6,6,0), LDRColorA(6,6,6,0) } } }, // Mode 10
|
||||
{0x00, 1, true, 3, { { LDRColorA(10,10,10,0), LDRColorA(5, 5, 5,0) }, { LDRColorA(5,5,5,0), LDRColorA(5,5,5,0) } } }, // Mode 1
|
||||
{0x01, 1, true, 3, { { LDRColorA(7, 7, 7,0), LDRColorA(6, 6, 6,0) }, { LDRColorA(6,6,6,0), LDRColorA(6,6,6,0) } } }, // Mode 2
|
||||
{0x02, 1, true, 3, { { LDRColorA(11,11,11,0), LDRColorA(5, 4, 4,0) }, { LDRColorA(5,4,4,0), LDRColorA(5,4,4,0) } } }, // Mode 3
|
||||
{0x06, 1, true, 3, { { LDRColorA(11,11,11,0), LDRColorA(4, 5, 4,0) }, { LDRColorA(4,5,4,0), LDRColorA(4,5,4,0) } } }, // Mode 4
|
||||
{0x0a, 1, true, 3, { { LDRColorA(11,11,11,0), LDRColorA(4, 4, 5,0) }, { LDRColorA(4,4,5,0), LDRColorA(4,4,5,0) } } }, // Mode 5
|
||||
{0x0e, 1, true, 3, { { LDRColorA(9, 9, 9,0), LDRColorA(5, 5, 5,0) }, { LDRColorA(5,5,5,0), LDRColorA(5,5,5,0) } } }, // Mode 6
|
||||
{0x12, 1, true, 3, { { LDRColorA(8, 8, 8,0), LDRColorA(6, 5, 5,0) }, { LDRColorA(6,5,5,0), LDRColorA(6,5,5,0) } } }, // Mode 7
|
||||
{0x16, 1, true, 3, { { LDRColorA(8, 8, 8,0), LDRColorA(5, 6, 5,0) }, { LDRColorA(5,6,5,0), LDRColorA(5,6,5,0) } } }, // Mode 8
|
||||
{0x1a, 1, true, 3, { { LDRColorA(8, 8, 8,0), LDRColorA(5, 5, 6,0) }, { LDRColorA(5,5,6,0), LDRColorA(5,5,6,0) } } }, // Mode 9
|
||||
{0x1e, 1, false, 3, { { LDRColorA(6, 6, 6,0), LDRColorA(6, 6, 6,0) }, { LDRColorA(6,6,6,0), LDRColorA(6,6,6,0) } } }, // Mode 10
|
||||
{0x03, 0, false, 4, { { LDRColorA(10,10,10,0), LDRColorA(10,10,10,0) }, { LDRColorA(0,0,0,0), LDRColorA(0,0,0,0) } } }, // Mode 11
|
||||
{0x07, 0, true, 4, { { LDRColorA(11,11,11,0), LDRColorA( 9, 9, 9,0) }, { LDRColorA(0,0,0,0), LDRColorA(0,0,0,0) } } }, // Mode 12
|
||||
{0x0b, 0, true, 4, { { LDRColorA(12,12,12,0), LDRColorA( 8, 8, 8,0) }, { LDRColorA(0,0,0,0), LDRColorA(0,0,0,0) } } }, // Mode 13
|
||||
{0x0f, 0, true, 4, { { LDRColorA(16,16,16,0), LDRColorA( 4, 4, 4,0) }, { LDRColorA(0,0,0,0), LDRColorA(0,0,0,0) } } }, // Mode 14
|
||||
{0x07, 0, true, 4, { { LDRColorA(11,11,11,0), LDRColorA(9, 9, 9,0) }, { LDRColorA(0,0,0,0), LDRColorA(0,0,0,0) } } }, // Mode 12
|
||||
{0x0b, 0, true, 4, { { LDRColorA(12,12,12,0), LDRColorA(8, 8, 8,0) }, { LDRColorA(0,0,0,0), LDRColorA(0,0,0,0) } } }, // Mode 13
|
||||
{0x0f, 0, true, 4, { { LDRColorA(16,16,16,0), LDRColorA(4, 4, 4,0) }, { LDRColorA(0,0,0,0), LDRColorA(0,0,0,0) } } }, // Mode 14
|
||||
};
|
||||
|
||||
const int D3DX_BC6H::ms_aModeToInfo[] =
|
||||
const int D3DX_BC6H::ms_aModeToInfo[D3DX_BC6H::c_NumModeInfo] =
|
||||
{
|
||||
0, // Mode 1 - 0x00
|
||||
1, // Mode 2 - 0x01
|
||||
|
@ -1088,7 +1092,7 @@ const int D3DX_BC6H::ms_aModeToInfo[] =
|
|||
};
|
||||
|
||||
// BC7 compression: uPartitions, uPartitionBits, uPBits, uRotationBits, uIndexModeBits, uIndexPrec, uIndexPrec2, RGBAPrec, RGBAPrecWithP
|
||||
const D3DX_BC7::ModeInfo D3DX_BC7::ms_aInfo[] =
|
||||
const D3DX_BC7::ModeInfo D3DX_BC7::ms_aInfo[D3DX_BC7::c_NumModes] =
|
||||
{
|
||||
{2, 4, 6, 0, 0, 3, 0, LDRColorA(4,4,4,0), LDRColorA(5,5,5,0)},
|
||||
// Mode 0: Color only, 3 Subsets, RGBP 4441 (unique P-bit), 3-bit indecies, 16 partitions
|
||||
|
@ -1628,13 +1632,13 @@ namespace
|
|||
{
|
||||
for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
// Use Magenta in debug as a highly-visible error color
|
||||
pOut[i] = HDRColorA(1.0f, 0.0f, 1.0f, 1.0f);
|
||||
#else
|
||||
#else
|
||||
// In production use, default to black
|
||||
pOut[i] = HDRColorA(0.0f, 0.0f, 0.0f, 1.0f);
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1655,17 +1659,14 @@ void D3DX_BC6H::Decode(bool bSigned, HDRColorA* pOut) const noexcept
|
|||
uMode = static_cast<uint8_t>((unsigned(GetBits(uStartBit, 3)) << 2) | uMode);
|
||||
}
|
||||
|
||||
assert(uMode < 32);
|
||||
_Analysis_assume_(uMode < 32);
|
||||
assert(uMode < c_NumModeInfo);
|
||||
_Analysis_assume_(uMode < c_NumModeInfo);
|
||||
|
||||
if (ms_aModeToInfo[uMode] >= 0)
|
||||
{
|
||||
assert(static_cast<unsigned int>(ms_aModeToInfo[uMode]) < std::size(ms_aInfo));
|
||||
_Analysis_assume_(ms_aModeToInfo[uMode] < std::size(ms_aInfo));
|
||||
assert(static_cast<unsigned int>(ms_aModeToInfo[uMode]) < c_NumModes);
|
||||
_Analysis_assume_(ms_aModeToInfo[uMode] < c_NumModes);
|
||||
const ModeDescriptor* desc = ms_aDesc[ms_aModeToInfo[uMode]];
|
||||
|
||||
assert(static_cast<unsigned int>(ms_aModeToInfo[uMode]) < std::size(ms_aDesc));
|
||||
_Analysis_assume_(ms_aModeToInfo[uMode] < std::size(ms_aDesc));
|
||||
const ModeInfo& info = ms_aInfo[ms_aModeToInfo[uMode]];
|
||||
|
||||
INTEndPntPair aEndPts[BC6H_MAX_REGIONS] = {};
|
||||
|
@ -1694,13 +1695,13 @@ void D3DX_BC6H::Decode(bool bSigned, HDRColorA* pOut) const noexcept
|
|||
case BY: aEndPts[1].A.b |= 1 << uint32_t(desc[uCurBit].m_uBit); break;
|
||||
case BZ: aEndPts[1].B.b |= 1 << uint32_t(desc[uCurBit].m_uBit); break;
|
||||
default:
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
OutputDebugStringA("BC6H: Invalid header bits encountered during decoding\n");
|
||||
#endif
|
||||
FillWithErrorColors(pOut);
|
||||
return;
|
||||
}
|
||||
{
|
||||
#if defined(_WIN32) && defined(_DEBUG)
|
||||
OutputDebugStringA("BC6H: Invalid header bits encountered during decoding\n");
|
||||
#endif
|
||||
FillWithErrorColors(pOut);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1739,9 +1740,9 @@ void D3DX_BC6H::Decode(bool bSigned, HDRColorA* pOut) const noexcept
|
|||
const size_t uNumBits = IsFixUpOffset(info.uPartitions, uShape, i) ? info.uIndexPrec - 1u : info.uIndexPrec;
|
||||
if (uStartBit + uNumBits > 128)
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
#if defined(_WIN32) && defined(_DEBUG)
|
||||
OutputDebugStringA("BC6H: Invalid block encountered during decoding\n");
|
||||
#endif
|
||||
#endif
|
||||
FillWithErrorColors(pOut);
|
||||
return;
|
||||
}
|
||||
|
@ -1749,9 +1750,9 @@ void D3DX_BC6H::Decode(bool bSigned, HDRColorA* pOut) const noexcept
|
|||
|
||||
if (uIndex >= ((info.uPartitions > 0) ? 8 : 16))
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
#if defined(_WIN32) && defined(_DEBUG)
|
||||
OutputDebugStringA("BC6H: Invalid index encountered during decoding\n");
|
||||
#endif
|
||||
#endif
|
||||
FillWithErrorColors(pOut);
|
||||
return;
|
||||
}
|
||||
|
@ -1784,7 +1785,7 @@ void D3DX_BC6H::Decode(bool bSigned, HDRColorA* pOut) const noexcept
|
|||
}
|
||||
else
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
#if defined(_WIN32) && defined(_DEBUG)
|
||||
const char* warnstr = "BC6H: Invalid mode encountered during decoding\n";
|
||||
switch (uMode)
|
||||
{
|
||||
|
@ -1794,7 +1795,7 @@ void D3DX_BC6H::Decode(bool bSigned, HDRColorA* pOut) const noexcept
|
|||
case 0x1F: warnstr = "BC6H: Reserved mode 11111 encountered during decoding\n"; break;
|
||||
}
|
||||
OutputDebugStringA(warnstr);
|
||||
#endif
|
||||
#endif
|
||||
// Per the BC6H format spec, we must return opaque black
|
||||
for (size_t i = 0; i < NUM_PIXELS_PER_BLOCK; ++i)
|
||||
{
|
||||
|
@ -1811,7 +1812,7 @@ void D3DX_BC6H::Encode(bool bSigned, const HDRColorA* const pIn) noexcept
|
|||
|
||||
EncodeParams EP(pIn, bSigned);
|
||||
|
||||
for (EP.uMode = 0; EP.uMode < std::size(ms_aInfo) && EP.fBestErr > 0; ++EP.uMode)
|
||||
for (EP.uMode = 0; EP.uMode < c_NumModes && EP.fBestErr > 0; ++EP.uMode)
|
||||
{
|
||||
const uint8_t uShapes = ms_aInfo[EP.uMode].uPartitions ? 32u : 1u;
|
||||
// Number of rough cases to look at. reasonable values of this are 1, uShapes/4, and uShapes
|
||||
|
@ -1936,6 +1937,9 @@ _Use_decl_annotations_
|
|||
bool D3DX_BC6H::EndPointsFit(const EncodeParams* pEP, const INTEndPntPair aEndPts[]) noexcept
|
||||
{
|
||||
assert(pEP);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const bool bTransformed = ms_aInfo[pEP->uMode].bTransformed;
|
||||
const bool bIsSigned = pEP->bSigned;
|
||||
const LDRColorA& Prec0 = ms_aInfo[pEP->uMode].RGBAPrec[0][0];
|
||||
|
@ -1978,6 +1982,9 @@ _Use_decl_annotations_
|
|||
void D3DX_BC6H::GeneratePaletteQuantized(const EncodeParams* pEP, const INTEndPntPair& endPts, INTColor aPalette[]) const noexcept
|
||||
{
|
||||
assert(pEP);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const size_t uIndexPrec = ms_aInfo[pEP->uMode].uIndexPrec;
|
||||
const size_t uNumIndices = size_t(1) << uIndexPrec;
|
||||
assert(uNumIndices > 0);
|
||||
|
@ -2003,7 +2010,7 @@ void D3DX_BC6H::GeneratePaletteQuantized(const EncodeParams* pEP, const INTEndPn
|
|||
assert(false);
|
||||
for (size_t i = 0; i < uNumIndices; ++i)
|
||||
{
|
||||
#pragma prefast(suppress:22102 22103, "writing blocks in two halves confuses tool")
|
||||
#pragma prefast(suppress:22102 22103, "writing blocks in two halves confuses tool")
|
||||
aPalette[i] = INTColor(0, 0, 0);
|
||||
}
|
||||
return;
|
||||
|
@ -2029,6 +2036,8 @@ _Use_decl_annotations_
|
|||
float D3DX_BC6H::MapColorsQuantized(const EncodeParams* pEP, const INTColor aColors[], size_t np, const INTEndPntPair &endPts) const noexcept
|
||||
{
|
||||
assert(pEP);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const uint8_t uIndexPrec = ms_aInfo[pEP->uMode].uIndexPrec;
|
||||
auto const uNumIndices = static_cast<const uint8_t>(1u << uIndexPrec);
|
||||
|
@ -2065,6 +2074,9 @@ float D3DX_BC6H::PerturbOne(const EncodeParams* pEP, const INTColor aColors[], s
|
|||
const INTEndPntPair& oldEndPts, INTEndPntPair& newEndPts, float fOldErr, int do_b) const noexcept
|
||||
{
|
||||
assert(pEP);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
uint8_t uPrec;
|
||||
switch (ch)
|
||||
{
|
||||
|
@ -2178,6 +2190,9 @@ _Use_decl_annotations_
|
|||
void D3DX_BC6H::OptimizeEndPoints(const EncodeParams* pEP, const float aOrgErr[], const INTEndPntPair aOrgEndPts[], INTEndPntPair aOptEndPts[]) const noexcept
|
||||
{
|
||||
assert(pEP);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const uint8_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
|
||||
assert(uPartitions < BC6H_MAX_REGIONS);
|
||||
_Analysis_assume_(uPartitions < BC6H_MAX_REGIONS);
|
||||
|
@ -2205,6 +2220,9 @@ _Use_decl_annotations_
|
|||
void D3DX_BC6H::SwapIndices(const EncodeParams* pEP, INTEndPntPair aEndPts[], size_t aIndices[]) noexcept
|
||||
{
|
||||
assert(pEP);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const size_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
|
||||
const size_t uNumIndices = size_t(1) << ms_aInfo[pEP->uMode].uIndexPrec;
|
||||
const size_t uHighIndexBit = uNumIndices >> 1;
|
||||
|
@ -2234,6 +2252,9 @@ _Use_decl_annotations_
|
|||
void D3DX_BC6H::AssignIndices(const EncodeParams* pEP, const INTEndPntPair aEndPts[], size_t aIndices[], float aTotErr[]) const noexcept
|
||||
{
|
||||
assert(pEP);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const uint8_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
|
||||
auto const uNumIndices = static_cast<const uint8_t>(1u << ms_aInfo[pEP->uMode].uIndexPrec);
|
||||
|
||||
|
@ -2276,6 +2297,9 @@ _Use_decl_annotations_
|
|||
void D3DX_BC6H::QuantizeEndPts(const EncodeParams* pEP, INTEndPntPair* aQntEndPts) const noexcept
|
||||
{
|
||||
assert(pEP && aQntEndPts);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const INTEndPntPair* aUnqEndPts = pEP->aUnqEndPts[pEP->uShape];
|
||||
const LDRColorA& Prec = ms_aInfo[pEP->uMode].RGBAPrec[0][0];
|
||||
const uint8_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
|
||||
|
@ -2298,6 +2322,9 @@ _Use_decl_annotations_
|
|||
void D3DX_BC6H::EmitBlock(const EncodeParams* pEP, const INTEndPntPair aEndPts[], const size_t aIndices[]) noexcept
|
||||
{
|
||||
assert(pEP);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const uint8_t uRealMode = ms_aInfo[pEP->uMode].uMode;
|
||||
const uint8_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
|
||||
const uint8_t uIndexPrec = ms_aInfo[pEP->uMode].uIndexPrec;
|
||||
|
@ -2342,6 +2369,9 @@ _Use_decl_annotations_
|
|||
void D3DX_BC6H::Refine(EncodeParams* pEP) noexcept
|
||||
{
|
||||
assert(pEP);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const uint8_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
|
||||
assert(uPartitions < BC6H_MAX_REGIONS);
|
||||
_Analysis_assume_(uPartitions < BC6H_MAX_REGIONS);
|
||||
|
@ -2394,6 +2424,9 @@ void D3DX_BC6H::GeneratePaletteUnquantized(const EncodeParams* pEP, size_t uRegi
|
|||
assert(pEP);
|
||||
assert(uRegion < BC6H_MAX_REGIONS && pEP->uShape < BC6H_MAX_SHAPES);
|
||||
_Analysis_assume_(uRegion < BC6H_MAX_REGIONS && pEP->uShape < BC6H_MAX_SHAPES);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const INTEndPntPair& endPts = pEP->aUnqEndPts[pEP->uShape][uRegion];
|
||||
const uint8_t uIndexPrec = ms_aInfo[pEP->uMode].uIndexPrec;
|
||||
auto const uNumIndices = static_cast<const uint8_t>(1u << uIndexPrec);
|
||||
|
@ -2409,7 +2442,7 @@ void D3DX_BC6H::GeneratePaletteUnquantized(const EncodeParams* pEP, size_t uRegi
|
|||
assert(false);
|
||||
for (size_t i = 0; i < uNumIndices; ++i)
|
||||
{
|
||||
#pragma prefast(suppress:22102 22103, "writing blocks in two halves confuses tool")
|
||||
#pragma prefast(suppress:22102 22103, "writing blocks in two halves confuses tool")
|
||||
aPalette[i] = INTColor(0, 0, 0);
|
||||
}
|
||||
return;
|
||||
|
@ -2428,6 +2461,9 @@ _Use_decl_annotations_
|
|||
float D3DX_BC6H::MapColors(const EncodeParams* pEP, size_t uRegion, size_t np, const size_t* auIndex) const noexcept
|
||||
{
|
||||
assert(pEP);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const uint8_t uIndexPrec = ms_aInfo[pEP->uMode].uIndexPrec;
|
||||
auto const uNumIndices = static_cast<const uint8_t>(1u << uIndexPrec);
|
||||
INTColor aPalette[BC6H_MAX_INDICES];
|
||||
|
@ -2455,6 +2491,8 @@ float D3DX_BC6H::RoughMSE(EncodeParams* pEP) const noexcept
|
|||
assert(pEP);
|
||||
assert(pEP->uShape < BC6H_MAX_SHAPES);
|
||||
_Analysis_assume_(pEP->uShape < BC6H_MAX_SHAPES);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
INTEndPntPair* aEndPts = pEP->aUnqEndPts[pEP->uShape];
|
||||
|
||||
|
@ -2558,9 +2596,9 @@ void D3DX_BC7::Decode(HDRColorA* pOut) const noexcept
|
|||
{
|
||||
if (uStartBit + RGBAPrec.r > 128)
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
#if defined(_WIN32) && defined(_DEBUG)
|
||||
OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
|
||||
#endif
|
||||
#endif
|
||||
FillWithErrorColors(pOut);
|
||||
return;
|
||||
}
|
||||
|
@ -2573,9 +2611,9 @@ void D3DX_BC7::Decode(HDRColorA* pOut) const noexcept
|
|||
{
|
||||
if (uStartBit + RGBAPrec.g > 128)
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
#if defined(_WIN32) && defined(_DEBUG)
|
||||
OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
|
||||
#endif
|
||||
#endif
|
||||
FillWithErrorColors(pOut);
|
||||
return;
|
||||
}
|
||||
|
@ -2588,9 +2626,9 @@ void D3DX_BC7::Decode(HDRColorA* pOut) const noexcept
|
|||
{
|
||||
if (uStartBit + RGBAPrec.b > 128)
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
#if defined(_WIN32) && defined(_DEBUG)
|
||||
OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
|
||||
#endif
|
||||
#endif
|
||||
FillWithErrorColors(pOut);
|
||||
return;
|
||||
}
|
||||
|
@ -2603,9 +2641,9 @@ void D3DX_BC7::Decode(HDRColorA* pOut) const noexcept
|
|||
{
|
||||
if (uStartBit + RGBAPrec.a > 128)
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
#if defined(_WIN32) && defined(_DEBUG)
|
||||
OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
|
||||
#endif
|
||||
#endif
|
||||
FillWithErrorColors(pOut);
|
||||
return;
|
||||
}
|
||||
|
@ -2620,9 +2658,9 @@ void D3DX_BC7::Decode(HDRColorA* pOut) const noexcept
|
|||
{
|
||||
if (uStartBit > 127)
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
#if defined(_WIN32) && defined(_DEBUG)
|
||||
OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
|
||||
#endif
|
||||
#endif
|
||||
FillWithErrorColors(pOut);
|
||||
return;
|
||||
}
|
||||
|
@ -2658,9 +2696,9 @@ void D3DX_BC7::Decode(HDRColorA* pOut) const noexcept
|
|||
const size_t uNumBits = IsFixUpOffset(ms_aInfo[uMode].uPartitions, uShape, i) ? uIndexPrec - 1u : uIndexPrec;
|
||||
if (uStartBit + uNumBits > 128)
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
#if defined(_WIN32) && defined(_DEBUG)
|
||||
OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
|
||||
#endif
|
||||
#endif
|
||||
FillWithErrorColors(pOut);
|
||||
return;
|
||||
}
|
||||
|
@ -2675,9 +2713,9 @@ void D3DX_BC7::Decode(HDRColorA* pOut) const noexcept
|
|||
const size_t uNumBits = i ? uIndexPrec2 : uIndexPrec2 - 1u;
|
||||
if (uStartBit + uNumBits > 128)
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
#if defined(_WIN32) && defined(_DEBUG)
|
||||
OutputDebugStringA("BC7: Invalid block encountered during decoding\n");
|
||||
#endif
|
||||
#endif
|
||||
FillWithErrorColors(pOut);
|
||||
return;
|
||||
}
|
||||
|
@ -2717,9 +2755,9 @@ void D3DX_BC7::Decode(HDRColorA* pOut) const noexcept
|
|||
}
|
||||
else
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
#if defined(_WIN32) && defined(_DEBUG)
|
||||
OutputDebugStringA("BC7: Reserved mode 8 encountered during decoding\n");
|
||||
#endif
|
||||
#endif
|
||||
// Per the BC7 format spec, we must return transparent black
|
||||
memset(pOut, 0, sizeof(HDRColorA) * NUM_PIXELS_PER_BLOCK);
|
||||
}
|
||||
|
@ -2838,6 +2876,9 @@ _Use_decl_annotations_
|
|||
void D3DX_BC7::GeneratePaletteQuantized(const EncodeParams* pEP, size_t uIndexMode, const LDREndPntPair& endPts, LDRColorA aPalette[]) const noexcept
|
||||
{
|
||||
assert(pEP);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const size_t uIndexPrec = uIndexMode ? ms_aInfo[pEP->uMode].uIndexPrec2 : ms_aInfo[pEP->uMode].uIndexPrec;
|
||||
const size_t uIndexPrec2 = uIndexMode ? ms_aInfo[pEP->uMode].uIndexPrec : ms_aInfo[pEP->uMode].uIndexPrec2;
|
||||
const size_t uNumIndices = size_t(1) << uIndexPrec;
|
||||
|
@ -2868,6 +2909,9 @@ float D3DX_BC7::PerturbOne(const EncodeParams* pEP, const LDRColorA aColors[], s
|
|||
const LDREndPntPair &oldEndPts, LDREndPntPair &newEndPts, float fOldErr, uint8_t do_b) const noexcept
|
||||
{
|
||||
assert(pEP);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const int prec = ms_aInfo[pEP->uMode].RGBAPrecWithP[ch];
|
||||
LDREndPntPair tmp_endPts = newEndPts = oldEndPts;
|
||||
float fMinErr = fOldErr;
|
||||
|
@ -2910,6 +2954,9 @@ void D3DX_BC7::Exhaustive(const EncodeParams* pEP, const LDRColorA aColors[], si
|
|||
float& fOrgErr, LDREndPntPair& optEndPt) const noexcept
|
||||
{
|
||||
assert(pEP);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const uint8_t uPrec = ms_aInfo[pEP->uMode].RGBAPrecWithP[ch];
|
||||
LDREndPntPair tmpEndPt;
|
||||
if (fOrgErr == 0)
|
||||
|
@ -2981,6 +3028,8 @@ void D3DX_BC7::OptimizeOne(const EncodeParams* pEP, const LDRColorA aColors[], s
|
|||
float fOrgErr, const LDREndPntPair& org, LDREndPntPair& opt) const noexcept
|
||||
{
|
||||
assert(pEP);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
float fOptErr = fOrgErr;
|
||||
opt = org;
|
||||
|
@ -3047,6 +3096,9 @@ void D3DX_BC7::OptimizeEndPoints(const EncodeParams* pEP, size_t uShape, size_t
|
|||
const LDREndPntPair aOrgEndPts[], LDREndPntPair aOptEndPts[]) const noexcept
|
||||
{
|
||||
assert(pEP);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const uint8_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
|
||||
assert(uPartitions < BC7_MAX_REGIONS && uShape < BC7_MAX_SHAPES);
|
||||
_Analysis_assume_(uPartitions < BC7_MAX_REGIONS && uShape < BC7_MAX_SHAPES);
|
||||
|
@ -3072,6 +3124,8 @@ void D3DX_BC7::AssignIndices(const EncodeParams* pEP, size_t uShape, size_t uInd
|
|||
assert(pEP);
|
||||
assert(uShape < BC7_MAX_SHAPES);
|
||||
_Analysis_assume_(uShape < BC7_MAX_SHAPES);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const uint8_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
|
||||
assert(uPartitions < BC7_MAX_REGIONS);
|
||||
|
@ -3149,6 +3203,9 @@ _Use_decl_annotations_
|
|||
void D3DX_BC7::EmitBlock(const EncodeParams* pEP, size_t uShape, size_t uRotation, size_t uIndexMode, const LDREndPntPair aEndPts[], const size_t aIndex[], const size_t aIndex2[]) noexcept
|
||||
{
|
||||
assert(pEP);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const uint8_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
|
||||
assert(uPartitions < BC7_MAX_REGIONS);
|
||||
_Analysis_assume_(uPartitions < BC7_MAX_REGIONS);
|
||||
|
@ -3201,7 +3258,7 @@ void D3DX_BC7::EmitBlock(const EncodeParams* pEP, size_t uShape, size_t uRotatio
|
|||
|
||||
for (i = 0; i < uPBits; i++)
|
||||
{
|
||||
SetBits(uStartBit, 1, aPVote[i] > (aCount[i] >> 1) ? 1u : 0u);
|
||||
SetBits(uStartBit, 1, (aPVote[i] >(aCount[i] >> 1)) ? 1u : 0u);
|
||||
}
|
||||
}
|
||||
else
|
||||
|
@ -3236,6 +3293,9 @@ _Use_decl_annotations_
|
|||
void D3DX_BC7::FixEndpointPBits(const EncodeParams* pEP, const LDREndPntPair *pOrigEndpoints, LDREndPntPair *pFixedEndpoints) noexcept
|
||||
{
|
||||
assert(pEP);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const size_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
|
||||
assert(uPartitions < BC7_MAX_REGIONS);
|
||||
_Analysis_assume_(uPartitions < BC7_MAX_REGIONS);
|
||||
|
@ -3323,6 +3383,8 @@ float D3DX_BC7::Refine(const EncodeParams* pEP, size_t uShape, size_t uRotation,
|
|||
assert(pEP);
|
||||
assert(uShape < BC7_MAX_SHAPES);
|
||||
_Analysis_assume_(uShape < BC7_MAX_SHAPES);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const size_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
|
||||
assert(uPartitions < BC7_MAX_REGIONS);
|
||||
|
@ -3379,6 +3441,9 @@ _Use_decl_annotations_
|
|||
float D3DX_BC7::MapColors(const EncodeParams* pEP, const LDRColorA aColors[], size_t np, size_t uIndexMode, const LDREndPntPair& endPts, float fMinErr) const noexcept
|
||||
{
|
||||
assert(pEP);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
const uint8_t uIndexPrec = uIndexMode ? ms_aInfo[pEP->uMode].uIndexPrec2 : ms_aInfo[pEP->uMode].uIndexPrec;
|
||||
const uint8_t uIndexPrec2 = uIndexMode ? ms_aInfo[pEP->uMode].uIndexPrec : ms_aInfo[pEP->uMode].uIndexPrec2;
|
||||
LDRColorA aPalette[BC7_MAX_INDICES];
|
||||
|
@ -3404,6 +3469,9 @@ float D3DX_BC7::RoughMSE(EncodeParams* pEP, size_t uShape, size_t uIndexMode) no
|
|||
assert(pEP);
|
||||
assert(uShape < BC7_MAX_SHAPES);
|
||||
_Analysis_assume_(uShape < BC7_MAX_SHAPES);
|
||||
assert(pEP->uMode < c_NumModes);
|
||||
_Analysis_assume_(pEP->uMode < c_NumModes);
|
||||
|
||||
LDREndPntPair* aEndPts = pEP->aEndPts[uShape];
|
||||
|
||||
const uint8_t uPartitions = ms_aInfo[pEP->uMode].uPartitions;
|
||||
|
|
|
@ -20,13 +20,13 @@ using Microsoft::WRL::ComPtr;
|
|||
|
||||
namespace
|
||||
{
|
||||
#include "BC7Encode_EncodeBlockCS.inc"
|
||||
#include "BC7Encode_TryMode02CS.inc"
|
||||
#include "BC7Encode_TryMode137CS.inc"
|
||||
#include "BC7Encode_TryMode456CS.inc"
|
||||
#include "BC6HEncode_EncodeBlockCS.inc"
|
||||
#include "BC6HEncode_TryModeG10CS.inc"
|
||||
#include "BC6HEncode_TryModeLE10CS.inc"
|
||||
#include "BC7Encode_EncodeBlockCS.inc"
|
||||
#include "BC7Encode_TryMode02CS.inc"
|
||||
#include "BC7Encode_TryMode137CS.inc"
|
||||
#include "BC7Encode_TryMode456CS.inc"
|
||||
#include "BC6HEncode_EncodeBlockCS.inc"
|
||||
#include "BC6HEncode_TryModeG10CS.inc"
|
||||
#include "BC6HEncode_TryModeLE10CS.inc"
|
||||
|
||||
struct BufferBC6HBC7
|
||||
{
|
||||
|
|
|
@ -25,19 +25,19 @@ namespace DirectX
|
|||
|
||||
#pragma pack(push,1)
|
||||
|
||||
constexpr uint32_t DDS_MAGIC = 0x20534444; // "DDS "
|
||||
constexpr uint32_t DDS_MAGIC = 0x20534444; // "DDS "
|
||||
|
||||
struct DDS_PIXELFORMAT
|
||||
{
|
||||
uint32_t size;
|
||||
uint32_t flags;
|
||||
uint32_t fourCC;
|
||||
uint32_t RGBBitCount;
|
||||
uint32_t RBitMask;
|
||||
uint32_t GBitMask;
|
||||
uint32_t BBitMask;
|
||||
uint32_t ABitMask;
|
||||
};
|
||||
struct DDS_PIXELFORMAT
|
||||
{
|
||||
uint32_t size;
|
||||
uint32_t flags;
|
||||
uint32_t fourCC;
|
||||
uint32_t RGBBitCount;
|
||||
uint32_t RBitMask;
|
||||
uint32_t GBitMask;
|
||||
uint32_t BBitMask;
|
||||
uint32_t ABitMask;
|
||||
};
|
||||
|
||||
#define DDS_FOURCC 0x00000004 // DDPF_FOURCC
|
||||
#define DDS_RGB 0x00000040 // DDPF_RGB
|
||||
|
@ -52,7 +52,7 @@ struct DDS_PIXELFORMAT
|
|||
// DDS_BUMPLUMINANCE 0x00040000
|
||||
|
||||
#ifndef MAKEFOURCC
|
||||
#define MAKEFOURCC(ch0, ch1, ch2, ch3) \
|
||||
#define MAKEFOURCC(ch0, ch1, ch2, ch3) \
|
||||
(static_cast<uint32_t>(static_cast<uint8_t>(ch0)) \
|
||||
| (static_cast<uint32_t>(static_cast<uint8_t>(ch1)) << 8) \
|
||||
| (static_cast<uint32_t>(static_cast<uint8_t>(ch2)) << 16) \
|
||||
|
@ -60,131 +60,131 @@ struct DDS_PIXELFORMAT
|
|||
#endif /* MAKEFOURCC */
|
||||
|
||||
#ifndef DDSGLOBALCONST
|
||||
#if defined(__GNUC__) && !defined(__MINGW32__)
|
||||
#define DDSGLOBALCONST extern const __attribute__((weak))
|
||||
#else
|
||||
#define DDSGLOBALCONST extern const __declspec(selectany)
|
||||
#endif
|
||||
#if defined(__GNUC__) && !defined(__MINGW32__)
|
||||
#define DDSGLOBALCONST extern const __attribute__((weak))
|
||||
#else
|
||||
#define DDSGLOBALCONST extern const __declspec(selectany)
|
||||
#endif
|
||||
#endif /* DDSGLOBALCONST */
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT1 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT1 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','1'), 0, 0, 0, 0, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT2 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT2 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','2'), 0, 0, 0, 0, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT3 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT3 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','3'), 0, 0, 0, 0, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT4 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT4 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','4'), 0, 0, 0, 0, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT5 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DXT5 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','T','5'), 0, 0, 0, 0, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC4_UNORM =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC4_UNORM =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','4','U'), 0, 0, 0, 0, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC4_SNORM =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC4_SNORM =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','4','S'), 0, 0, 0, 0, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC5_UNORM =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC5_UNORM =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','5','U'), 0, 0, 0, 0, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC5_SNORM =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_BC5_SNORM =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('B','C','5','S'), 0, 0, 0, 0, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R8G8_B8G8 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R8G8_B8G8 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('R','G','B','G'), 0, 0, 0, 0, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_G8R8_G8B8 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_G8R8_G8B8 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('G','R','G','B'), 0, 0, 0, 0, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_YUY2 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_YUY2 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('Y','U','Y','2'), 0, 0, 0, 0, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_UYVY =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_UYVY =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('U','Y','V','Y'), 0, 0, 0, 0, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8R8G8B8 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8R8G8B8 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X8R8G8B8 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X8R8G8B8 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 32, 0x00ff0000, 0x0000ff00, 0x000000ff, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8B8G8R8 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8B8G8R8 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X8B8G8R8 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X8B8G8R8 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_G16R16 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_G16R16 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 32, 0x0000ffff, 0xffff0000, 0, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R5G6B5 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R5G6B5 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0xf800, 0x07e0, 0x001f, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A1R5G5B5 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A1R5G5B5 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x7c00, 0x03e0, 0x001f, 0x8000 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X1R5G5B5 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X1R5G5B5 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0x7c00, 0x03e0, 0x001f, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A4R4G4B4 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A4R4G4B4 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x0f00, 0x00f0, 0x000f, 0xf000 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X4R4G4B4 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_X4R4G4B4 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0x0f00, 0x00f0, 0x000f, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R8G8B8 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R8G8B8 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 24, 0xff0000, 0x00ff00, 0x0000ff, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8R3G3B2 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8R3G3B2 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x00e0, 0x001c, 0x0003, 0xff00 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R3G3B2 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_R3G3B2 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 8, 0xe0, 0x1c, 0x03, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A4L4 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A4L4 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_LUMINANCEA, 0, 8, 0x0f, 0, 0, 0xf0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L8 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L8 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_LUMINANCE, 0, 8, 0xff, 0, 0, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L16 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L16 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_LUMINANCE, 0, 16, 0xffff, 0, 0, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8L8 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8L8 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_LUMINANCEA, 0, 16, 0x00ff, 0, 0, 0xff00 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8L8_ALT =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8L8_ALT =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_LUMINANCEA, 0, 8, 0x00ff, 0, 0, 0xff00 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L8_NVTT1 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L8_NVTT1 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 8, 0xff, 0, 0, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L16_NVTT1 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_L16_NVTT1 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_RGB, 0, 16, 0xffff, 0, 0, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8L8_NVTT1 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8L8_NVTT1 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 16, 0x00ff, 0, 0, 0xff00 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A8 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_ALPHA, 0, 8, 0, 0, 0, 0xff };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_V8U8 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_V8U8 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_BUMPDUDV, 0, 16, 0x00ff, 0xff00, 0, 0 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_Q8W8V8U8 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_Q8W8V8U8 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_BUMPDUDV, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000 };
|
||||
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_V16U16 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_V16U16 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_BUMPDUDV, 0, 32, 0x0000ffff, 0xffff0000, 0, 0 };
|
||||
|
||||
// D3DFMT_A2R10G10B10/D3DFMT_A2B10G10R10 should be written using DX10 extension to avoid D3DX 10:10:10:2 reversal issue
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A2R10G10B10 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A2R10G10B10 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x000003ff, 0x000ffc00, 0x3ff00000, 0xc0000000 };
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A2B10G10R10 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A2B10G10R10 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_RGBA, 0, 32, 0x3ff00000, 0x000ffc00, 0x000003ff, 0xc0000000 };
|
||||
|
||||
// We do not support the following legacy Direct3D 9 formats:
|
||||
|
@ -193,7 +193,7 @@ DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_A2B10G10R10 =
|
|||
// DDSPF_X8L8V8U8 = { sizeof(DDS_PIXELFORMAT), DDS_BUMPLUMINANCE, 0, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0 };
|
||||
|
||||
// This indicates the DDS_HEADER_DXT10 extension is present (the format is in dxgiFormat)
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DX10 =
|
||||
DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DX10 =
|
||||
{ sizeof(DDS_PIXELFORMAT), DDS_FOURCC, MAKEFOURCC('D','X','1','0'), 0, 0, 0, 0, 0 };
|
||||
|
||||
#define DDS_HEADER_FLAGS_TEXTURE 0x00001007 // DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT
|
||||
|
@ -225,66 +225,66 @@ DDSGLOBALCONST DDS_PIXELFORMAT DDSPF_DX10 =
|
|||
#define DDS_FLAGS_VOLUME 0x00200000 // DDSCAPS2_VOLUME
|
||||
|
||||
// Subset here matches D3D10_RESOURCE_DIMENSION and D3D11_RESOURCE_DIMENSION
|
||||
enum DDS_RESOURCE_DIMENSION : uint32_t
|
||||
{
|
||||
DDS_DIMENSION_TEXTURE1D = 2,
|
||||
DDS_DIMENSION_TEXTURE2D = 3,
|
||||
DDS_DIMENSION_TEXTURE3D = 4,
|
||||
};
|
||||
enum DDS_RESOURCE_DIMENSION : uint32_t
|
||||
{
|
||||
DDS_DIMENSION_TEXTURE1D = 2,
|
||||
DDS_DIMENSION_TEXTURE2D = 3,
|
||||
DDS_DIMENSION_TEXTURE3D = 4,
|
||||
};
|
||||
|
||||
// Subset here matches D3D10_RESOURCE_MISC_FLAG and D3D11_RESOURCE_MISC_FLAG
|
||||
enum DDS_RESOURCE_MISC_FLAG : uint32_t
|
||||
{
|
||||
DDS_RESOURCE_MISC_TEXTURECUBE = 0x4L,
|
||||
};
|
||||
// Subset here matches D3D10_RESOURCE_MISC_FLAG and D3D11_RESOURCE_MISC_FLAG
|
||||
enum DDS_RESOURCE_MISC_FLAG : uint32_t
|
||||
{
|
||||
DDS_RESOURCE_MISC_TEXTURECUBE = 0x4L,
|
||||
};
|
||||
|
||||
enum DDS_MISC_FLAGS2 : uint32_t
|
||||
{
|
||||
DDS_MISC_FLAGS2_ALPHA_MODE_MASK = 0x7L,
|
||||
};
|
||||
enum DDS_MISC_FLAGS2 : uint32_t
|
||||
{
|
||||
DDS_MISC_FLAGS2_ALPHA_MODE_MASK = 0x7L,
|
||||
};
|
||||
|
||||
#ifndef DDS_ALPHA_MODE_DEFINED
|
||||
#define DDS_ALPHA_MODE_DEFINED
|
||||
enum DDS_ALPHA_MODE : uint32_t
|
||||
{
|
||||
DDS_ALPHA_MODE_UNKNOWN = 0,
|
||||
DDS_ALPHA_MODE_STRAIGHT = 1,
|
||||
DDS_ALPHA_MODE_PREMULTIPLIED = 2,
|
||||
DDS_ALPHA_MODE_OPAQUE = 3,
|
||||
DDS_ALPHA_MODE_CUSTOM = 4,
|
||||
};
|
||||
enum DDS_ALPHA_MODE : uint32_t
|
||||
{
|
||||
DDS_ALPHA_MODE_UNKNOWN = 0,
|
||||
DDS_ALPHA_MODE_STRAIGHT = 1,
|
||||
DDS_ALPHA_MODE_PREMULTIPLIED = 2,
|
||||
DDS_ALPHA_MODE_OPAQUE = 3,
|
||||
DDS_ALPHA_MODE_CUSTOM = 4,
|
||||
};
|
||||
#endif
|
||||
|
||||
struct DDS_HEADER
|
||||
{
|
||||
uint32_t size;
|
||||
uint32_t flags;
|
||||
uint32_t height;
|
||||
uint32_t width;
|
||||
uint32_t pitchOrLinearSize;
|
||||
uint32_t depth; // only if DDS_HEADER_FLAGS_VOLUME is set in flags
|
||||
uint32_t mipMapCount;
|
||||
uint32_t reserved1[11];
|
||||
DDS_PIXELFORMAT ddspf;
|
||||
uint32_t caps;
|
||||
uint32_t caps2;
|
||||
uint32_t caps3;
|
||||
uint32_t caps4;
|
||||
uint32_t reserved2;
|
||||
};
|
||||
struct DDS_HEADER
|
||||
{
|
||||
uint32_t size;
|
||||
uint32_t flags;
|
||||
uint32_t height;
|
||||
uint32_t width;
|
||||
uint32_t pitchOrLinearSize;
|
||||
uint32_t depth; // only if DDS_HEADER_FLAGS_VOLUME is set in flags
|
||||
uint32_t mipMapCount;
|
||||
uint32_t reserved1[11];
|
||||
DDS_PIXELFORMAT ddspf;
|
||||
uint32_t caps;
|
||||
uint32_t caps2;
|
||||
uint32_t caps3;
|
||||
uint32_t caps4;
|
||||
uint32_t reserved2;
|
||||
};
|
||||
|
||||
struct DDS_HEADER_DXT10
|
||||
{
|
||||
DXGI_FORMAT dxgiFormat;
|
||||
uint32_t resourceDimension;
|
||||
uint32_t miscFlag; // see D3D11_RESOURCE_MISC_FLAG
|
||||
uint32_t arraySize;
|
||||
uint32_t miscFlags2; // see DDS_MISC_FLAGS2
|
||||
};
|
||||
struct DDS_HEADER_DXT10
|
||||
{
|
||||
DXGI_FORMAT dxgiFormat;
|
||||
uint32_t resourceDimension;
|
||||
uint32_t miscFlag; // see D3D11_RESOURCE_MISC_FLAG
|
||||
uint32_t arraySize;
|
||||
uint32_t miscFlags2; // see DDS_MISC_FLAGS2
|
||||
};
|
||||
|
||||
#pragma pack(pop)
|
||||
|
||||
static_assert( sizeof(DDS_HEADER) == 124, "DDS Header size mismatch" );
|
||||
static_assert( sizeof(DDS_HEADER_DXT10) == 20, "DDS DX10 Extended Header size mismatch");
|
||||
static_assert(sizeof(DDS_HEADER) == 124, "DDS Header size mismatch");
|
||||
static_assert(sizeof(DDS_HEADER_DXT10) == 20, "DDS DX10 Extended Header size mismatch");
|
||||
|
||||
} // namespace
|
||||
|
|
|
@ -17,7 +17,7 @@
|
|||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#if defined(WIN32) || defined(_WIN32)
|
||||
#ifdef _WIN32
|
||||
#if !defined(__d3d11_h__) && !defined(__d3d11_x_h__) && !defined(__d3d12_h__) && !defined(__d3d12_x_h__) && !defined(__XBOX_D3D12_X__)
|
||||
#ifdef _GAMING_XBOX_SCARLETT
|
||||
#include <d3d12_xs.h>
|
||||
|
@ -36,8 +36,8 @@
|
|||
|
||||
#include <DirectXMath.h>
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef NTDDI_WIN10_FE
|
||||
#ifdef _WIN32
|
||||
#if defined(NTDDI_WIN10_FE) || defined(__MINGW32__)
|
||||
#include <ocidl.h>
|
||||
#else
|
||||
#include <OCIdl.h>
|
||||
|
@ -47,7 +47,7 @@ struct IWICImagingFactory;
|
|||
struct IWICMetadataQueryReader;
|
||||
#endif
|
||||
|
||||
#define DIRECTX_TEX_VERSION 195
|
||||
#define DIRECTX_TEX_VERSION 198
|
||||
|
||||
|
||||
namespace DirectX
|
||||
|
@ -63,6 +63,7 @@ namespace DirectX
|
|||
bool __cdecl IsPalettized(_In_ DXGI_FORMAT fmt) noexcept;
|
||||
bool __cdecl IsDepthStencil(_In_ DXGI_FORMAT fmt) noexcept;
|
||||
bool __cdecl IsSRGB(_In_ DXGI_FORMAT fmt) noexcept;
|
||||
bool __cdecl IsBGR(_In_ DXGI_FORMAT fmt) noexcept;
|
||||
bool __cdecl IsTypeless(_In_ DXGI_FORMAT fmt, _In_ bool partialTypeless = true) noexcept;
|
||||
|
||||
bool __cdecl HasAlpha(_In_ DXGI_FORMAT fmt) noexcept;
|
||||
|
@ -85,16 +86,35 @@ namespace DirectX
|
|||
|
||||
enum CP_FLAGS : unsigned long
|
||||
{
|
||||
CP_FLAGS_NONE = 0x0, // Normal operation
|
||||
CP_FLAGS_LEGACY_DWORD = 0x1, // Assume pitch is DWORD aligned instead of BYTE aligned
|
||||
CP_FLAGS_PARAGRAPH = 0x2, // Assume pitch is 16-byte aligned instead of BYTE aligned
|
||||
CP_FLAGS_YMM = 0x4, // Assume pitch is 32-byte aligned instead of BYTE aligned
|
||||
CP_FLAGS_ZMM = 0x8, // Assume pitch is 64-byte aligned instead of BYTE aligned
|
||||
CP_FLAGS_PAGE4K = 0x200, // Assume pitch is 4096-byte aligned instead of BYTE aligned
|
||||
CP_FLAGS_BAD_DXTN_TAILS = 0x1000, // BC formats with malformed mipchain blocks smaller than 4x4
|
||||
CP_FLAGS_24BPP = 0x10000, // Override with a legacy 24 bits-per-pixel format size
|
||||
CP_FLAGS_16BPP = 0x20000, // Override with a legacy 16 bits-per-pixel format size
|
||||
CP_FLAGS_8BPP = 0x40000, // Override with a legacy 8 bits-per-pixel format size
|
||||
CP_FLAGS_NONE = 0x0,
|
||||
// Normal operation
|
||||
|
||||
CP_FLAGS_LEGACY_DWORD = 0x1,
|
||||
// Assume pitch is DWORD aligned instead of BYTE aligned
|
||||
|
||||
CP_FLAGS_PARAGRAPH = 0x2,
|
||||
// Assume pitch is 16-byte aligned instead of BYTE aligned
|
||||
|
||||
CP_FLAGS_YMM = 0x4,
|
||||
// Assume pitch is 32-byte aligned instead of BYTE aligned
|
||||
|
||||
CP_FLAGS_ZMM = 0x8,
|
||||
// Assume pitch is 64-byte aligned instead of BYTE aligned
|
||||
|
||||
CP_FLAGS_PAGE4K = 0x200,
|
||||
// Assume pitch is 4096-byte aligned instead of BYTE aligned
|
||||
|
||||
CP_FLAGS_BAD_DXTN_TAILS = 0x1000,
|
||||
// BC formats with malformed mipchain blocks smaller than 4x4
|
||||
|
||||
CP_FLAGS_24BPP = 0x10000,
|
||||
// Override with a legacy 24 bits-per-pixel format size
|
||||
|
||||
CP_FLAGS_16BPP = 0x20000,
|
||||
// Override with a legacy 16 bits-per-pixel format size
|
||||
|
||||
CP_FLAGS_8BPP = 0x40000,
|
||||
// Override with a legacy 8 bits-per-pixel format size
|
||||
};
|
||||
|
||||
HRESULT __cdecl ComputePitch(
|
||||
|
@ -104,6 +124,7 @@ namespace DirectX
|
|||
size_t __cdecl ComputeScanlines(_In_ DXGI_FORMAT fmt, _In_ size_t height) noexcept;
|
||||
|
||||
DXGI_FORMAT __cdecl MakeSRGB(_In_ DXGI_FORMAT fmt) noexcept;
|
||||
DXGI_FORMAT __cdecl MakeLinear(_In_ DXGI_FORMAT fmt) noexcept;
|
||||
DXGI_FORMAT __cdecl MakeTypeless(_In_ DXGI_FORMAT fmt) noexcept;
|
||||
DXGI_FORMAT __cdecl MakeTypelessUNORM(_In_ DXGI_FORMAT fmt) noexcept;
|
||||
DXGI_FORMAT __cdecl MakeTypelessFLOAT(_In_ DXGI_FORMAT fmt) noexcept;
|
||||
|
@ -113,18 +134,18 @@ namespace DirectX
|
|||
enum TEX_DIMENSION
|
||||
// Subset here matches D3D10_RESOURCE_DIMENSION and D3D11_RESOURCE_DIMENSION
|
||||
{
|
||||
TEX_DIMENSION_TEXTURE1D = 2,
|
||||
TEX_DIMENSION_TEXTURE2D = 3,
|
||||
TEX_DIMENSION_TEXTURE3D = 4,
|
||||
TEX_DIMENSION_TEXTURE1D = 2,
|
||||
TEX_DIMENSION_TEXTURE2D = 3,
|
||||
TEX_DIMENSION_TEXTURE3D = 4,
|
||||
};
|
||||
|
||||
enum TEX_MISC_FLAG
|
||||
enum TEX_MISC_FLAG : unsigned long
|
||||
// Subset here matches D3D10_RESOURCE_MISC_FLAG and D3D11_RESOURCE_MISC_FLAG
|
||||
{
|
||||
TEX_MISC_TEXTURECUBE = 0x4L,
|
||||
};
|
||||
|
||||
enum TEX_MISC_FLAG2
|
||||
enum TEX_MISC_FLAG2 : unsigned long
|
||||
{
|
||||
TEX_MISC2_ALPHA_MODE_MASK = 0x7L,
|
||||
};
|
||||
|
@ -132,11 +153,11 @@ namespace DirectX
|
|||
enum TEX_ALPHA_MODE
|
||||
// Matches DDS_ALPHA_MODE, encoded in MISC_FLAGS2
|
||||
{
|
||||
TEX_ALPHA_MODE_UNKNOWN = 0,
|
||||
TEX_ALPHA_MODE_STRAIGHT = 1,
|
||||
TEX_ALPHA_MODE_UNKNOWN = 0,
|
||||
TEX_ALPHA_MODE_STRAIGHT = 1,
|
||||
TEX_ALPHA_MODE_PREMULTIPLIED = 2,
|
||||
TEX_ALPHA_MODE_OPAQUE = 3,
|
||||
TEX_ALPHA_MODE_CUSTOM = 4,
|
||||
TEX_ALPHA_MODE_OPAQUE = 3,
|
||||
TEX_ALPHA_MODE_CUSTOM = 4,
|
||||
};
|
||||
|
||||
struct TexMetadata
|
||||
|
@ -168,106 +189,106 @@ namespace DirectX
|
|||
|
||||
enum DDS_FLAGS : unsigned long
|
||||
{
|
||||
DDS_FLAGS_NONE = 0x0,
|
||||
DDS_FLAGS_NONE = 0x0,
|
||||
|
||||
DDS_FLAGS_LEGACY_DWORD = 0x1,
|
||||
// Assume pitch is DWORD aligned instead of BYTE aligned (used by some legacy DDS files)
|
||||
DDS_FLAGS_LEGACY_DWORD = 0x1,
|
||||
// Assume pitch is DWORD aligned instead of BYTE aligned (used by some legacy DDS files)
|
||||
|
||||
DDS_FLAGS_NO_LEGACY_EXPANSION = 0x2,
|
||||
// Do not implicitly convert legacy formats that result in larger pixel sizes (24 bpp, 3:3:2, A8L8, A4L4, P8, A8P8)
|
||||
DDS_FLAGS_NO_LEGACY_EXPANSION = 0x2,
|
||||
// Do not implicitly convert legacy formats that result in larger pixel sizes (24 bpp, 3:3:2, A8L8, A4L4, P8, A8P8)
|
||||
|
||||
DDS_FLAGS_NO_R10B10G10A2_FIXUP = 0x4,
|
||||
// Do not use work-around for long-standing D3DX DDS file format issue which reversed the 10:10:10:2 color order masks
|
||||
DDS_FLAGS_NO_R10B10G10A2_FIXUP = 0x4,
|
||||
// Do not use work-around for long-standing D3DX DDS file format issue which reversed the 10:10:10:2 color order masks
|
||||
|
||||
DDS_FLAGS_FORCE_RGB = 0x8,
|
||||
// Convert DXGI 1.1 BGR formats to DXGI_FORMAT_R8G8B8A8_UNORM to avoid use of optional WDDM 1.1 formats
|
||||
DDS_FLAGS_FORCE_RGB = 0x8,
|
||||
// Convert DXGI 1.1 BGR formats to DXGI_FORMAT_R8G8B8A8_UNORM to avoid use of optional WDDM 1.1 formats
|
||||
|
||||
DDS_FLAGS_NO_16BPP = 0x10,
|
||||
// Conversions avoid use of 565, 5551, and 4444 formats and instead expand to 8888 to avoid use of optional WDDM 1.2 formats
|
||||
DDS_FLAGS_NO_16BPP = 0x10,
|
||||
// Conversions avoid use of 565, 5551, and 4444 formats and instead expand to 8888 to avoid use of optional WDDM 1.2 formats
|
||||
|
||||
DDS_FLAGS_EXPAND_LUMINANCE = 0x20,
|
||||
// When loading legacy luminance formats expand replicating the color channels rather than leaving them packed (L8, L16, A8L8)
|
||||
DDS_FLAGS_EXPAND_LUMINANCE = 0x20,
|
||||
// When loading legacy luminance formats expand replicating the color channels rather than leaving them packed (L8, L16, A8L8)
|
||||
|
||||
DDS_FLAGS_BAD_DXTN_TAILS = 0x40,
|
||||
// Some older DXTn DDS files incorrectly handle mipchain tails for blocks smaller than 4x4
|
||||
DDS_FLAGS_BAD_DXTN_TAILS = 0x40,
|
||||
// Some older DXTn DDS files incorrectly handle mipchain tails for blocks smaller than 4x4
|
||||
|
||||
DDS_FLAGS_FORCE_DX10_EXT = 0x10000,
|
||||
// Always use the 'DX10' header extension for DDS writer (i.e. don't try to write DX9 compatible DDS files)
|
||||
DDS_FLAGS_FORCE_DX10_EXT = 0x10000,
|
||||
// Always use the 'DX10' header extension for DDS writer (i.e. don't try to write DX9 compatible DDS files)
|
||||
|
||||
DDS_FLAGS_FORCE_DX10_EXT_MISC2 = 0x20000,
|
||||
// DDS_FLAGS_FORCE_DX10_EXT including miscFlags2 information (result may not be compatible with D3DX10 or D3DX11)
|
||||
DDS_FLAGS_FORCE_DX10_EXT_MISC2 = 0x20000,
|
||||
// DDS_FLAGS_FORCE_DX10_EXT including miscFlags2 information (result may not be compatible with D3DX10 or D3DX11)
|
||||
|
||||
DDS_FLAGS_FORCE_DX9_LEGACY = 0x40000,
|
||||
// Force use of legacy header for DDS writer (will fail if unable to write as such)
|
||||
DDS_FLAGS_FORCE_DX9_LEGACY = 0x40000,
|
||||
// Force use of legacy header for DDS writer (will fail if unable to write as such)
|
||||
|
||||
DDS_FLAGS_ALLOW_LARGE_FILES = 0x1000000,
|
||||
// Enables the loader to read large dimension .dds files (i.e. greater than known hardware requirements)
|
||||
DDS_FLAGS_ALLOW_LARGE_FILES = 0x1000000,
|
||||
// Enables the loader to read large dimension .dds files (i.e. greater than known hardware requirements)
|
||||
};
|
||||
|
||||
enum TGA_FLAGS : unsigned long
|
||||
{
|
||||
TGA_FLAGS_NONE = 0x0,
|
||||
TGA_FLAGS_NONE = 0x0,
|
||||
|
||||
TGA_FLAGS_BGR = 0x1,
|
||||
// 24bpp files are returned as BGRX; 32bpp files are returned as BGRA
|
||||
TGA_FLAGS_BGR = 0x1,
|
||||
// 24bpp files are returned as BGRX; 32bpp files are returned as BGRA
|
||||
|
||||
TGA_FLAGS_ALLOW_ALL_ZERO_ALPHA = 0x2,
|
||||
// If the loaded image has an all zero alpha channel, normally we assume it should be opaque. This flag leaves it alone.
|
||||
// If the loaded image has an all zero alpha channel, normally we assume it should be opaque. This flag leaves it alone.
|
||||
|
||||
TGA_FLAGS_IGNORE_SRGB = 0x10,
|
||||
// Ignores sRGB TGA 2.0 metadata if present in the file
|
||||
TGA_FLAGS_IGNORE_SRGB = 0x10,
|
||||
// Ignores sRGB TGA 2.0 metadata if present in the file
|
||||
|
||||
TGA_FLAGS_FORCE_SRGB = 0x20,
|
||||
// Writes sRGB metadata into the file reguardless of format (TGA 2.0 only)
|
||||
TGA_FLAGS_FORCE_SRGB = 0x20,
|
||||
// Writes sRGB metadata into the file reguardless of format (TGA 2.0 only)
|
||||
|
||||
TGA_FLAGS_FORCE_LINEAR = 0x40,
|
||||
// Writes linear gamma metadata into the file reguardless of format (TGA 2.0 only)
|
||||
TGA_FLAGS_FORCE_LINEAR = 0x40,
|
||||
// Writes linear gamma metadata into the file reguardless of format (TGA 2.0 only)
|
||||
|
||||
TGA_FLAGS_DEFAULT_SRGB = 0x80,
|
||||
// If no colorspace is specified in TGA 2.0 metadata, assume sRGB
|
||||
TGA_FLAGS_DEFAULT_SRGB = 0x80,
|
||||
// If no colorspace is specified in TGA 2.0 metadata, assume sRGB
|
||||
};
|
||||
|
||||
enum WIC_FLAGS : unsigned long
|
||||
{
|
||||
WIC_FLAGS_NONE = 0x0,
|
||||
WIC_FLAGS_NONE = 0x0,
|
||||
|
||||
WIC_FLAGS_FORCE_RGB = 0x1,
|
||||
// Loads DXGI 1.1 BGR formats as DXGI_FORMAT_R8G8B8A8_UNORM to avoid use of optional WDDM 1.1 formats
|
||||
WIC_FLAGS_FORCE_RGB = 0x1,
|
||||
// Loads DXGI 1.1 BGR formats as DXGI_FORMAT_R8G8B8A8_UNORM to avoid use of optional WDDM 1.1 formats
|
||||
|
||||
WIC_FLAGS_NO_X2_BIAS = 0x2,
|
||||
// Loads DXGI 1.1 X2 10:10:10:2 format as DXGI_FORMAT_R10G10B10A2_UNORM
|
||||
WIC_FLAGS_NO_X2_BIAS = 0x2,
|
||||
// Loads DXGI 1.1 X2 10:10:10:2 format as DXGI_FORMAT_R10G10B10A2_UNORM
|
||||
|
||||
WIC_FLAGS_NO_16BPP = 0x4,
|
||||
// Loads 565, 5551, and 4444 formats as 8888 to avoid use of optional WDDM 1.2 formats
|
||||
WIC_FLAGS_NO_16BPP = 0x4,
|
||||
// Loads 565, 5551, and 4444 formats as 8888 to avoid use of optional WDDM 1.2 formats
|
||||
|
||||
WIC_FLAGS_ALLOW_MONO = 0x8,
|
||||
// Loads 1-bit monochrome (black & white) as R1_UNORM rather than 8-bit grayscale
|
||||
WIC_FLAGS_ALLOW_MONO = 0x8,
|
||||
// Loads 1-bit monochrome (black & white) as R1_UNORM rather than 8-bit grayscale
|
||||
|
||||
WIC_FLAGS_ALL_FRAMES = 0x10,
|
||||
// Loads all images in a multi-frame file, converting/resizing to match the first frame as needed, defaults to 0th frame otherwise
|
||||
WIC_FLAGS_ALL_FRAMES = 0x10,
|
||||
// Loads all images in a multi-frame file, converting/resizing to match the first frame as needed, defaults to 0th frame otherwise
|
||||
|
||||
WIC_FLAGS_IGNORE_SRGB = 0x20,
|
||||
// Ignores sRGB metadata if present in the file
|
||||
WIC_FLAGS_IGNORE_SRGB = 0x20,
|
||||
// Ignores sRGB metadata if present in the file
|
||||
|
||||
WIC_FLAGS_FORCE_SRGB = 0x40,
|
||||
// Writes sRGB metadata into the file reguardless of format
|
||||
WIC_FLAGS_FORCE_SRGB = 0x40,
|
||||
// Writes sRGB metadata into the file reguardless of format
|
||||
|
||||
WIC_FLAGS_FORCE_LINEAR = 0x80,
|
||||
// Writes linear gamma metadata into the file reguardless of format
|
||||
WIC_FLAGS_FORCE_LINEAR = 0x80,
|
||||
// Writes linear gamma metadata into the file reguardless of format
|
||||
|
||||
WIC_FLAGS_DEFAULT_SRGB = 0x100,
|
||||
// If no colorspace is specified, assume sRGB
|
||||
WIC_FLAGS_DEFAULT_SRGB = 0x100,
|
||||
// If no colorspace is specified, assume sRGB
|
||||
|
||||
WIC_FLAGS_DITHER = 0x10000,
|
||||
// Use ordered 4x4 dithering for any required conversions
|
||||
WIC_FLAGS_DITHER = 0x10000,
|
||||
// Use ordered 4x4 dithering for any required conversions
|
||||
|
||||
WIC_FLAGS_DITHER_DIFFUSION = 0x20000,
|
||||
// Use error-diffusion dithering for any required conversions
|
||||
WIC_FLAGS_DITHER_DIFFUSION = 0x20000,
|
||||
// Use error-diffusion dithering for any required conversions
|
||||
|
||||
WIC_FLAGS_FILTER_POINT = 0x100000,
|
||||
WIC_FLAGS_FILTER_LINEAR = 0x200000,
|
||||
WIC_FLAGS_FILTER_CUBIC = 0x300000,
|
||||
WIC_FLAGS_FILTER_FANT = 0x400000, // Combination of Linear and Box filter
|
||||
WIC_FLAGS_FILTER_POINT = 0x100000,
|
||||
WIC_FLAGS_FILTER_LINEAR = 0x200000,
|
||||
WIC_FLAGS_FILTER_CUBIC = 0x300000,
|
||||
WIC_FLAGS_FILTER_FANT = 0x400000, // Combination of Linear and Box filter
|
||||
// Filtering mode to use for any required image resizing (only needed when loading arrays of differently sized images; defaults to Fant)
|
||||
};
|
||||
|
||||
|
@ -296,7 +317,7 @@ namespace DirectX
|
|||
_In_ TGA_FLAGS flags,
|
||||
_Out_ TexMetadata& metadata) noexcept;
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
HRESULT __cdecl GetMetadataFromWICMemory(
|
||||
_In_reads_bytes_(size) const void* pSource, _In_ size_t size,
|
||||
_In_ WIC_FLAGS flags,
|
||||
|
@ -467,7 +488,7 @@ namespace DirectX
|
|||
_In_z_ const wchar_t* szFile, _In_opt_ const TexMetadata* metadata = nullptr) noexcept;
|
||||
|
||||
// WIC operations
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
HRESULT __cdecl LoadFromWICMemory(
|
||||
_In_reads_bytes_(size) const void* pSource, _In_ size_t size,
|
||||
_In_ WIC_FLAGS flags,
|
||||
|
@ -515,15 +536,15 @@ namespace DirectX
|
|||
|
||||
enum TEX_FR_FLAGS : unsigned long
|
||||
{
|
||||
TEX_FR_ROTATE0 = 0x0,
|
||||
TEX_FR_ROTATE90 = 0x1,
|
||||
TEX_FR_ROTATE180 = 0x2,
|
||||
TEX_FR_ROTATE270 = 0x3,
|
||||
TEX_FR_FLIP_HORIZONTAL = 0x08,
|
||||
TEX_FR_FLIP_VERTICAL = 0x10,
|
||||
TEX_FR_ROTATE0 = 0x0,
|
||||
TEX_FR_ROTATE90 = 0x1,
|
||||
TEX_FR_ROTATE180 = 0x2,
|
||||
TEX_FR_ROTATE270 = 0x3,
|
||||
TEX_FR_FLIP_HORIZONTAL = 0x08,
|
||||
TEX_FR_FLIP_VERTICAL = 0x10,
|
||||
};
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
HRESULT __cdecl FlipRotate(_In_ const Image& srcImage, _In_ TEX_FR_FLAGS flags, _Out_ ScratchImage& image) noexcept;
|
||||
HRESULT __cdecl FlipRotate(
|
||||
_In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
|
||||
|
@ -533,60 +554,60 @@ namespace DirectX
|
|||
|
||||
enum TEX_FILTER_FLAGS : unsigned long
|
||||
{
|
||||
TEX_FILTER_DEFAULT = 0,
|
||||
TEX_FILTER_DEFAULT = 0,
|
||||
|
||||
TEX_FILTER_WRAP_U = 0x1,
|
||||
TEX_FILTER_WRAP_V = 0x2,
|
||||
TEX_FILTER_WRAP_W = 0x4,
|
||||
TEX_FILTER_WRAP = (TEX_FILTER_WRAP_U | TEX_FILTER_WRAP_V | TEX_FILTER_WRAP_W),
|
||||
TEX_FILTER_MIRROR_U = 0x10,
|
||||
TEX_FILTER_MIRROR_V = 0x20,
|
||||
TEX_FILTER_MIRROR_W = 0x40,
|
||||
TEX_FILTER_MIRROR = (TEX_FILTER_MIRROR_U | TEX_FILTER_MIRROR_V | TEX_FILTER_MIRROR_W),
|
||||
// Wrap vs. Mirror vs. Clamp filtering options
|
||||
TEX_FILTER_WRAP_U = 0x1,
|
||||
TEX_FILTER_WRAP_V = 0x2,
|
||||
TEX_FILTER_WRAP_W = 0x4,
|
||||
TEX_FILTER_WRAP = (TEX_FILTER_WRAP_U | TEX_FILTER_WRAP_V | TEX_FILTER_WRAP_W),
|
||||
TEX_FILTER_MIRROR_U = 0x10,
|
||||
TEX_FILTER_MIRROR_V = 0x20,
|
||||
TEX_FILTER_MIRROR_W = 0x40,
|
||||
TEX_FILTER_MIRROR = (TEX_FILTER_MIRROR_U | TEX_FILTER_MIRROR_V | TEX_FILTER_MIRROR_W),
|
||||
// Wrap vs. Mirror vs. Clamp filtering options
|
||||
|
||||
TEX_FILTER_SEPARATE_ALPHA = 0x100,
|
||||
// Resize color and alpha channel independently
|
||||
TEX_FILTER_SEPARATE_ALPHA = 0x100,
|
||||
// Resize color and alpha channel independently
|
||||
|
||||
TEX_FILTER_FLOAT_X2BIAS = 0x200,
|
||||
// Enable *2 - 1 conversion cases for unorm<->float and positive-only float formats
|
||||
TEX_FILTER_FLOAT_X2BIAS = 0x200,
|
||||
// Enable *2 - 1 conversion cases for unorm<->float and positive-only float formats
|
||||
|
||||
TEX_FILTER_RGB_COPY_RED = 0x1000,
|
||||
TEX_FILTER_RGB_COPY_GREEN = 0x2000,
|
||||
TEX_FILTER_RGB_COPY_BLUE = 0x4000,
|
||||
// When converting RGB to R, defaults to using grayscale. These flags indicate copying a specific channel instead
|
||||
// When converting RGB to RG, defaults to copying RED | GREEN. These flags control which channels are selected instead.
|
||||
TEX_FILTER_RGB_COPY_RED = 0x1000,
|
||||
TEX_FILTER_RGB_COPY_GREEN = 0x2000,
|
||||
TEX_FILTER_RGB_COPY_BLUE = 0x4000,
|
||||
// When converting RGB to R, defaults to using grayscale. These flags indicate copying a specific channel instead
|
||||
// When converting RGB to RG, defaults to copying RED | GREEN. These flags control which channels are selected instead.
|
||||
|
||||
TEX_FILTER_DITHER = 0x10000,
|
||||
// Use ordered 4x4 dithering for any required conversions
|
||||
TEX_FILTER_DITHER = 0x10000,
|
||||
// Use ordered 4x4 dithering for any required conversions
|
||||
TEX_FILTER_DITHER_DIFFUSION = 0x20000,
|
||||
// Use error-diffusion dithering for any required conversions
|
||||
// Use error-diffusion dithering for any required conversions
|
||||
|
||||
TEX_FILTER_POINT = 0x100000,
|
||||
TEX_FILTER_LINEAR = 0x200000,
|
||||
TEX_FILTER_CUBIC = 0x300000,
|
||||
TEX_FILTER_BOX = 0x400000,
|
||||
TEX_FILTER_FANT = 0x400000, // Equiv to Box filtering for mipmap generation
|
||||
TEX_FILTER_TRIANGLE = 0x500000,
|
||||
// Filtering mode to use for any required image resizing
|
||||
TEX_FILTER_POINT = 0x100000,
|
||||
TEX_FILTER_LINEAR = 0x200000,
|
||||
TEX_FILTER_CUBIC = 0x300000,
|
||||
TEX_FILTER_BOX = 0x400000,
|
||||
TEX_FILTER_FANT = 0x400000, // Equiv to Box filtering for mipmap generation
|
||||
TEX_FILTER_TRIANGLE = 0x500000,
|
||||
// Filtering mode to use for any required image resizing
|
||||
|
||||
TEX_FILTER_SRGB_IN = 0x1000000,
|
||||
TEX_FILTER_SRGB_OUT = 0x2000000,
|
||||
TEX_FILTER_SRGB = (TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT),
|
||||
// sRGB <-> RGB for use in conversion operations
|
||||
// if the input format type is IsSRGB(), then SRGB_IN is on by default
|
||||
// if the output format type is IsSRGB(), then SRGB_OUT is on by default
|
||||
TEX_FILTER_SRGB_IN = 0x1000000,
|
||||
TEX_FILTER_SRGB_OUT = 0x2000000,
|
||||
TEX_FILTER_SRGB = (TEX_FILTER_SRGB_IN | TEX_FILTER_SRGB_OUT),
|
||||
// sRGB <-> RGB for use in conversion operations
|
||||
// if the input format type is IsSRGB(), then SRGB_IN is on by default
|
||||
// if the output format type is IsSRGB(), then SRGB_OUT is on by default
|
||||
|
||||
TEX_FILTER_FORCE_NON_WIC = 0x10000000,
|
||||
// Forces use of the non-WIC path when both are an option
|
||||
TEX_FILTER_FORCE_NON_WIC = 0x10000000,
|
||||
// Forces use of the non-WIC path when both are an option
|
||||
|
||||
TEX_FILTER_FORCE_WIC = 0x20000000,
|
||||
// Forces use of the WIC path even when logic would have picked a non-WIC path when both are an option
|
||||
TEX_FILTER_FORCE_WIC = 0x20000000,
|
||||
// Forces use of the WIC path even when logic would have picked a non-WIC path when both are an option
|
||||
};
|
||||
|
||||
constexpr unsigned long TEX_FILTER_DITHER_MASK = 0xF0000;
|
||||
constexpr unsigned long TEX_FILTER_MODE_MASK = 0xF00000;
|
||||
constexpr unsigned long TEX_FILTER_SRGB_MASK = 0xF000000;
|
||||
constexpr unsigned long TEX_FILTER_DITHER_MASK = 0xF0000;
|
||||
constexpr unsigned long TEX_FILTER_MODE_MASK = 0xF00000;
|
||||
constexpr unsigned long TEX_FILTER_SRGB_MASK = 0xF000000;
|
||||
|
||||
HRESULT __cdecl Resize(
|
||||
_In_ const Image& srcImage, _In_ size_t width, _In_ size_t height,
|
||||
|
@ -640,19 +661,19 @@ namespace DirectX
|
|||
|
||||
enum TEX_PMALPHA_FLAGS : unsigned long
|
||||
{
|
||||
TEX_PMALPHA_DEFAULT = 0,
|
||||
TEX_PMALPHA_DEFAULT = 0,
|
||||
|
||||
TEX_PMALPHA_IGNORE_SRGB = 0x1,
|
||||
// ignores sRGB colorspace conversions
|
||||
TEX_PMALPHA_IGNORE_SRGB = 0x1,
|
||||
// ignores sRGB colorspace conversions
|
||||
|
||||
TEX_PMALPHA_REVERSE = 0x2,
|
||||
// converts from premultiplied alpha back to straight alpha
|
||||
TEX_PMALPHA_REVERSE = 0x2,
|
||||
// converts from premultiplied alpha back to straight alpha
|
||||
|
||||
TEX_PMALPHA_SRGB_IN = 0x1000000,
|
||||
TEX_PMALPHA_SRGB_OUT = 0x2000000,
|
||||
TEX_PMALPHA_SRGB = (TEX_PMALPHA_SRGB_IN | TEX_PMALPHA_SRGB_OUT),
|
||||
// if the input format type is IsSRGB(), then SRGB_IN is on by default
|
||||
// if the output format type is IsSRGB(), then SRGB_OUT is on by default
|
||||
TEX_PMALPHA_SRGB_IN = 0x1000000,
|
||||
TEX_PMALPHA_SRGB_OUT = 0x2000000,
|
||||
TEX_PMALPHA_SRGB = (TEX_PMALPHA_SRGB_IN | TEX_PMALPHA_SRGB_OUT),
|
||||
// if the input format type is IsSRGB(), then SRGB_IN is on by default
|
||||
// if the output format type is IsSRGB(), then SRGB_OUT is on by default
|
||||
};
|
||||
|
||||
HRESULT __cdecl PremultiplyAlpha(_In_ const Image& srcImage, _In_ TEX_PMALPHA_FLAGS flags, _Out_ ScratchImage& image) noexcept;
|
||||
|
@ -663,34 +684,34 @@ namespace DirectX
|
|||
|
||||
enum TEX_COMPRESS_FLAGS : unsigned long
|
||||
{
|
||||
TEX_COMPRESS_DEFAULT = 0,
|
||||
TEX_COMPRESS_DEFAULT = 0,
|
||||
|
||||
TEX_COMPRESS_RGB_DITHER = 0x10000,
|
||||
// Enables dithering RGB colors for BC1-3 compression
|
||||
TEX_COMPRESS_RGB_DITHER = 0x10000,
|
||||
// Enables dithering RGB colors for BC1-3 compression
|
||||
|
||||
TEX_COMPRESS_A_DITHER = 0x20000,
|
||||
// Enables dithering alpha for BC1-3 compression
|
||||
TEX_COMPRESS_A_DITHER = 0x20000,
|
||||
// Enables dithering alpha for BC1-3 compression
|
||||
|
||||
TEX_COMPRESS_DITHER = 0x30000,
|
||||
// Enables both RGB and alpha dithering for BC1-3 compression
|
||||
TEX_COMPRESS_DITHER = 0x30000,
|
||||
// Enables both RGB and alpha dithering for BC1-3 compression
|
||||
|
||||
TEX_COMPRESS_UNIFORM = 0x40000,
|
||||
// Uniform color weighting for BC1-3 compression; by default uses perceptual weighting
|
||||
TEX_COMPRESS_UNIFORM = 0x40000,
|
||||
// Uniform color weighting for BC1-3 compression; by default uses perceptual weighting
|
||||
|
||||
TEX_COMPRESS_BC7_USE_3SUBSETS = 0x80000,
|
||||
// Enables exhaustive search for BC7 compress for mode 0 and 2; by default skips trying these modes
|
||||
TEX_COMPRESS_BC7_USE_3SUBSETS = 0x80000,
|
||||
// Enables exhaustive search for BC7 compress for mode 0 and 2; by default skips trying these modes
|
||||
|
||||
TEX_COMPRESS_BC7_QUICK = 0x100000,
|
||||
// Minimal modes (usually mode 6) for BC7 compression
|
||||
TEX_COMPRESS_BC7_QUICK = 0x100000,
|
||||
// Minimal modes (usually mode 6) for BC7 compression
|
||||
|
||||
TEX_COMPRESS_SRGB_IN = 0x1000000,
|
||||
TEX_COMPRESS_SRGB_OUT = 0x2000000,
|
||||
TEX_COMPRESS_SRGB = (TEX_COMPRESS_SRGB_IN | TEX_COMPRESS_SRGB_OUT),
|
||||
// if the input format type is IsSRGB(), then SRGB_IN is on by default
|
||||
// if the output format type is IsSRGB(), then SRGB_OUT is on by default
|
||||
TEX_COMPRESS_SRGB_IN = 0x1000000,
|
||||
TEX_COMPRESS_SRGB_OUT = 0x2000000,
|
||||
TEX_COMPRESS_SRGB = (TEX_COMPRESS_SRGB_IN | TEX_COMPRESS_SRGB_OUT),
|
||||
// if the input format type is IsSRGB(), then SRGB_IN is on by default
|
||||
// if the output format type is IsSRGB(), then SRGB_OUT is on by default
|
||||
|
||||
TEX_COMPRESS_PARALLEL = 0x10000000,
|
||||
// Compress is free to use multithreading to improve performance (by default it does not use multithreading)
|
||||
TEX_COMPRESS_PARALLEL = 0x10000000,
|
||||
// Compress is free to use multithreading to improve performance (by default it does not use multithreading)
|
||||
};
|
||||
|
||||
HRESULT __cdecl Compress(
|
||||
|
@ -721,26 +742,26 @@ namespace DirectX
|
|||
|
||||
enum CNMAP_FLAGS : unsigned long
|
||||
{
|
||||
CNMAP_DEFAULT = 0,
|
||||
CNMAP_DEFAULT = 0,
|
||||
|
||||
CNMAP_CHANNEL_RED = 0x1,
|
||||
CNMAP_CHANNEL_GREEN = 0x2,
|
||||
CNMAP_CHANNEL_BLUE = 0x3,
|
||||
CNMAP_CHANNEL_ALPHA = 0x4,
|
||||
CNMAP_CHANNEL_RED = 0x1,
|
||||
CNMAP_CHANNEL_GREEN = 0x2,
|
||||
CNMAP_CHANNEL_BLUE = 0x3,
|
||||
CNMAP_CHANNEL_ALPHA = 0x4,
|
||||
CNMAP_CHANNEL_LUMINANCE = 0x5,
|
||||
// Channel selection when evaluting color value for height
|
||||
// Luminance is a combination of red, green, and blue
|
||||
// Channel selection when evaluting color value for height
|
||||
// Luminance is a combination of red, green, and blue
|
||||
|
||||
CNMAP_MIRROR_U = 0x1000,
|
||||
CNMAP_MIRROR_V = 0x2000,
|
||||
CNMAP_MIRROR = 0x3000,
|
||||
// Use mirror semantics for scanline references (defaults to wrap)
|
||||
CNMAP_MIRROR_U = 0x1000,
|
||||
CNMAP_MIRROR_V = 0x2000,
|
||||
CNMAP_MIRROR = 0x3000,
|
||||
// Use mirror semantics for scanline references (defaults to wrap)
|
||||
|
||||
CNMAP_INVERT_SIGN = 0x4000,
|
||||
// Inverts normal sign
|
||||
CNMAP_INVERT_SIGN = 0x4000,
|
||||
// Inverts normal sign
|
||||
|
||||
CNMAP_COMPUTE_OCCLUSION = 0x8000,
|
||||
// Computes a crude occlusion term stored in the alpha channel
|
||||
// Computes a crude occlusion term stored in the alpha channel
|
||||
};
|
||||
|
||||
HRESULT __cdecl ComputeNormalMap(
|
||||
|
@ -770,21 +791,21 @@ namespace DirectX
|
|||
|
||||
enum CMSE_FLAGS : unsigned long
|
||||
{
|
||||
CMSE_DEFAULT = 0,
|
||||
CMSE_DEFAULT = 0,
|
||||
|
||||
CMSE_IMAGE1_SRGB = 0x1,
|
||||
CMSE_IMAGE2_SRGB = 0x2,
|
||||
// Indicates that image needs gamma correction before comparision
|
||||
CMSE_IMAGE1_SRGB = 0x1,
|
||||
CMSE_IMAGE2_SRGB = 0x2,
|
||||
// Indicates that image needs gamma correction before comparision
|
||||
|
||||
CMSE_IGNORE_RED = 0x10,
|
||||
CMSE_IGNORE_GREEN = 0x20,
|
||||
CMSE_IGNORE_BLUE = 0x40,
|
||||
CMSE_IGNORE_ALPHA = 0x80,
|
||||
// Ignore the channel when computing MSE
|
||||
CMSE_IGNORE_RED = 0x10,
|
||||
CMSE_IGNORE_GREEN = 0x20,
|
||||
CMSE_IGNORE_BLUE = 0x40,
|
||||
CMSE_IGNORE_ALPHA = 0x80,
|
||||
// Ignore the channel when computing MSE
|
||||
|
||||
CMSE_IMAGE1_X2_BIAS = 0x100,
|
||||
CMSE_IMAGE2_X2_BIAS = 0x200,
|
||||
// Indicates that image should be scaled and biased before comparison (i.e. UNORM -> SNORM)
|
||||
CMSE_IMAGE1_X2_BIAS = 0x100,
|
||||
CMSE_IMAGE2_X2_BIAS = 0x200,
|
||||
// Indicates that image should be scaled and biased before comparison (i.e. UNORM -> SNORM)
|
||||
};
|
||||
|
||||
HRESULT __cdecl ComputeMSE(_In_ const Image& image1, _In_ const Image& image2, _Out_ float& mse, _Out_writes_opt_(4) float* mseV, _In_ CMSE_FLAGS flags = CMSE_DEFAULT) noexcept;
|
||||
|
@ -799,17 +820,17 @@ namespace DirectX
|
|||
HRESULT __cdecl TransformImage(
|
||||
_In_ const Image& image,
|
||||
_In_ std::function<void __cdecl(_Out_writes_(width) XMVECTOR* outPixels,
|
||||
_In_reads_(width) const XMVECTOR* inPixels, size_t width, size_t y)> pixelFunc,
|
||||
_In_reads_(width) const XMVECTOR* inPixels, size_t width, size_t y)> pixelFunc,
|
||||
ScratchImage& result);
|
||||
HRESULT __cdecl TransformImage(
|
||||
_In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
|
||||
_In_ std::function<void __cdecl(_Out_writes_(width) XMVECTOR* outPixels,
|
||||
_In_reads_(width) const XMVECTOR* inPixels, size_t width, size_t y)> pixelFunc,
|
||||
_In_reads_(width) const XMVECTOR* inPixels, size_t width, size_t y)> pixelFunc,
|
||||
ScratchImage& result);
|
||||
|
||||
//---------------------------------------------------------------------------------
|
||||
// WIC utility code
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
enum WICCodecs
|
||||
{
|
||||
WIC_CODEC_BMP = 1, // Windows Bitmap (.bmp)
|
||||
|
@ -836,6 +857,15 @@ namespace DirectX
|
|||
_Out_ size_t& required) noexcept;
|
||||
|
||||
//---------------------------------------------------------------------------------
|
||||
// Direct3D interop
|
||||
|
||||
enum CREATETEX_FLAGS : uint32_t
|
||||
{
|
||||
CREATETEX_DEFAULT = 0,
|
||||
CREATETEX_FORCE_SRGB = 0x1,
|
||||
CREATETEX_IGNORE_SRGB = 0x2,
|
||||
};
|
||||
|
||||
// Direct3D 11 functions
|
||||
#if defined(__d3d11_h__) || defined(__d3d11_x_h__)
|
||||
bool __cdecl IsSupportedTexture(_In_ ID3D11Device* pDevice, _In_ const TexMetadata& metadata) noexcept;
|
||||
|
@ -850,18 +880,17 @@ namespace DirectX
|
|||
|
||||
HRESULT __cdecl CreateTextureEx(
|
||||
_In_ ID3D11Device* pDevice, _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
|
||||
_In_ D3D11_USAGE usage, _In_ unsigned int bindFlags, _In_ unsigned int cpuAccessFlags, _In_ unsigned int miscFlags, _In_ bool forceSRGB,
|
||||
_In_ D3D11_USAGE usage, _In_ unsigned int bindFlags, _In_ unsigned int cpuAccessFlags, _In_ unsigned int miscFlags, _In_ CREATETEX_FLAGS flags,
|
||||
_Outptr_ ID3D11Resource** ppResource) noexcept;
|
||||
|
||||
HRESULT __cdecl CreateShaderResourceViewEx(
|
||||
_In_ ID3D11Device* pDevice, _In_reads_(nimages) const Image* srcImages, _In_ size_t nimages, _In_ const TexMetadata& metadata,
|
||||
_In_ D3D11_USAGE usage, _In_ unsigned int bindFlags, _In_ unsigned int cpuAccessFlags, _In_ unsigned int miscFlags, _In_ bool forceSRGB,
|
||||
_In_ D3D11_USAGE usage, _In_ unsigned int bindFlags, _In_ unsigned int cpuAccessFlags, _In_ unsigned int miscFlags, _In_ CREATETEX_FLAGS flags,
|
||||
_Outptr_ ID3D11ShaderResourceView** ppSRV) noexcept;
|
||||
|
||||
HRESULT __cdecl CaptureTexture(_In_ ID3D11Device* pDevice, _In_ ID3D11DeviceContext* pContext, _In_ ID3D11Resource* pSource, _Out_ ScratchImage& result) noexcept;
|
||||
#endif
|
||||
|
||||
//---------------------------------------------------------------------------------
|
||||
// Direct3D 12 functions
|
||||
#if defined(__d3d12_h__) || defined(__d3d12_x_h__) || defined(__XBOX_D3D12_X__)
|
||||
bool __cdecl IsSupportedTexture(_In_ ID3D12Device* pDevice, _In_ const TexMetadata& metadata) noexcept;
|
||||
|
@ -872,7 +901,7 @@ namespace DirectX
|
|||
|
||||
HRESULT __cdecl CreateTextureEx(
|
||||
_In_ ID3D12Device* pDevice, _In_ const TexMetadata& metadata,
|
||||
_In_ D3D12_RESOURCE_FLAGS resFlags, _In_ bool forceSRGB,
|
||||
_In_ D3D12_RESOURCE_FLAGS resFlags, _In_ CREATETEX_FLAGS flags,
|
||||
_Outptr_ ID3D12Resource** ppResource) noexcept;
|
||||
|
||||
HRESULT __cdecl PrepareUpload(
|
||||
|
|
|
@ -24,6 +24,7 @@ DEFINE_ENUM_FLAG_OPERATORS(TEX_PMALPHA_FLAGS);
|
|||
DEFINE_ENUM_FLAG_OPERATORS(TEX_COMPRESS_FLAGS);
|
||||
DEFINE_ENUM_FLAG_OPERATORS(CNMAP_FLAGS);
|
||||
DEFINE_ENUM_FLAG_OPERATORS(CMSE_FLAGS);
|
||||
DEFINE_ENUM_FLAG_OPERATORS(CREATETEX_FLAGS);
|
||||
|
||||
// WIC_FILTER modes match TEX_FILTER modes
|
||||
constexpr WIC_FLAGS operator|(WIC_FLAGS a, TEX_FILTER_FLAGS b) { return static_cast<WIC_FLAGS>(static_cast<unsigned long>(a) | static_cast<unsigned long>(b & TEX_FILTER_MODE_MASK)); }
|
||||
|
@ -53,31 +54,31 @@ inline bool __cdecl IsCompressed(DXGI_FORMAT fmt) noexcept
|
|||
{
|
||||
switch (fmt)
|
||||
{
|
||||
case DXGI_FORMAT_BC1_TYPELESS:
|
||||
case DXGI_FORMAT_BC1_UNORM:
|
||||
case DXGI_FORMAT_BC1_UNORM_SRGB:
|
||||
case DXGI_FORMAT_BC2_TYPELESS:
|
||||
case DXGI_FORMAT_BC2_UNORM:
|
||||
case DXGI_FORMAT_BC2_UNORM_SRGB:
|
||||
case DXGI_FORMAT_BC3_TYPELESS:
|
||||
case DXGI_FORMAT_BC3_UNORM:
|
||||
case DXGI_FORMAT_BC3_UNORM_SRGB:
|
||||
case DXGI_FORMAT_BC4_TYPELESS:
|
||||
case DXGI_FORMAT_BC4_UNORM:
|
||||
case DXGI_FORMAT_BC4_SNORM:
|
||||
case DXGI_FORMAT_BC5_TYPELESS:
|
||||
case DXGI_FORMAT_BC5_UNORM:
|
||||
case DXGI_FORMAT_BC5_SNORM:
|
||||
case DXGI_FORMAT_BC6H_TYPELESS:
|
||||
case DXGI_FORMAT_BC6H_UF16:
|
||||
case DXGI_FORMAT_BC6H_SF16:
|
||||
case DXGI_FORMAT_BC7_TYPELESS:
|
||||
case DXGI_FORMAT_BC7_UNORM:
|
||||
case DXGI_FORMAT_BC7_UNORM_SRGB:
|
||||
return true;
|
||||
case DXGI_FORMAT_BC1_TYPELESS:
|
||||
case DXGI_FORMAT_BC1_UNORM:
|
||||
case DXGI_FORMAT_BC1_UNORM_SRGB:
|
||||
case DXGI_FORMAT_BC2_TYPELESS:
|
||||
case DXGI_FORMAT_BC2_UNORM:
|
||||
case DXGI_FORMAT_BC2_UNORM_SRGB:
|
||||
case DXGI_FORMAT_BC3_TYPELESS:
|
||||
case DXGI_FORMAT_BC3_UNORM:
|
||||
case DXGI_FORMAT_BC3_UNORM_SRGB:
|
||||
case DXGI_FORMAT_BC4_TYPELESS:
|
||||
case DXGI_FORMAT_BC4_UNORM:
|
||||
case DXGI_FORMAT_BC4_SNORM:
|
||||
case DXGI_FORMAT_BC5_TYPELESS:
|
||||
case DXGI_FORMAT_BC5_UNORM:
|
||||
case DXGI_FORMAT_BC5_SNORM:
|
||||
case DXGI_FORMAT_BC6H_TYPELESS:
|
||||
case DXGI_FORMAT_BC6H_UF16:
|
||||
case DXGI_FORMAT_BC6H_SF16:
|
||||
case DXGI_FORMAT_BC7_TYPELESS:
|
||||
case DXGI_FORMAT_BC7_UNORM:
|
||||
case DXGI_FORMAT_BC7_UNORM_SRGB:
|
||||
return true;
|
||||
|
||||
default:
|
||||
return false;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -86,14 +87,14 @@ inline bool __cdecl IsPalettized(DXGI_FORMAT fmt) noexcept
|
|||
{
|
||||
switch (fmt)
|
||||
{
|
||||
case DXGI_FORMAT_AI44:
|
||||
case DXGI_FORMAT_IA44:
|
||||
case DXGI_FORMAT_P8:
|
||||
case DXGI_FORMAT_A8P8:
|
||||
return true;
|
||||
case DXGI_FORMAT_AI44:
|
||||
case DXGI_FORMAT_IA44:
|
||||
case DXGI_FORMAT_P8:
|
||||
case DXGI_FORMAT_A8P8:
|
||||
return true;
|
||||
|
||||
default:
|
||||
return false;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -102,17 +103,38 @@ inline bool __cdecl IsSRGB(DXGI_FORMAT fmt) noexcept
|
|||
{
|
||||
switch (fmt)
|
||||
{
|
||||
case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
|
||||
case DXGI_FORMAT_BC1_UNORM_SRGB:
|
||||
case DXGI_FORMAT_BC2_UNORM_SRGB:
|
||||
case DXGI_FORMAT_BC3_UNORM_SRGB:
|
||||
case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
|
||||
case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
|
||||
case DXGI_FORMAT_BC7_UNORM_SRGB:
|
||||
return true;
|
||||
case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
|
||||
case DXGI_FORMAT_BC1_UNORM_SRGB:
|
||||
case DXGI_FORMAT_BC2_UNORM_SRGB:
|
||||
case DXGI_FORMAT_BC3_UNORM_SRGB:
|
||||
case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
|
||||
case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
|
||||
case DXGI_FORMAT_BC7_UNORM_SRGB:
|
||||
return true;
|
||||
|
||||
default:
|
||||
return false;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
_Use_decl_annotations_
|
||||
inline bool __cdecl IsBGR(DXGI_FORMAT fmt) noexcept
|
||||
{
|
||||
switch (fmt)
|
||||
{
|
||||
case DXGI_FORMAT_B5G6R5_UNORM:
|
||||
case DXGI_FORMAT_B5G5R5A1_UNORM:
|
||||
case DXGI_FORMAT_B8G8R8A8_UNORM:
|
||||
case DXGI_FORMAT_B8G8R8X8_UNORM:
|
||||
case DXGI_FORMAT_B8G8R8A8_TYPELESS:
|
||||
case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
|
||||
case DXGI_FORMAT_B8G8R8X8_TYPELESS:
|
||||
case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
|
||||
case DXGI_FORMAT_B4G4R4A4_UNORM:
|
||||
return true;
|
||||
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -158,7 +158,7 @@ namespace
|
|||
{
|
||||
for (size_t s = pw; s < 4; ++s)
|
||||
{
|
||||
#pragma prefast(suppress: 26000, "PREFAST false positive")
|
||||
#pragma prefast(suppress: 26000, "PREFAST false positive")
|
||||
temp[(t << 2) | s] = temp[(t << 2) | uSrc[s]];
|
||||
}
|
||||
}
|
||||
|
@ -170,7 +170,7 @@ namespace
|
|||
{
|
||||
for (size_t s = 0; s < 4; ++s)
|
||||
{
|
||||
#pragma prefast(suppress: 26000, "PREFAST false positive")
|
||||
#pragma prefast(suppress: 26000, "PREFAST false positive")
|
||||
temp[(t << 2) | s] = temp[(uSrc[t] << 2) | s];
|
||||
}
|
||||
}
|
||||
|
@ -239,7 +239,7 @@ namespace
|
|||
|
||||
bool fail = false;
|
||||
|
||||
#pragma omp parallel for
|
||||
#pragma omp parallel for
|
||||
for (int nb = 0; nb < static_cast<int>(nBlocks); ++nb)
|
||||
{
|
||||
const int nbWidth = std::max<int>(1, int((image.width + 3) / 4));
|
||||
|
@ -615,11 +615,11 @@ HRESULT DirectX::Compress(
|
|||
// Compress single image
|
||||
if (compress & TEX_COMPRESS_PARALLEL)
|
||||
{
|
||||
#ifndef _OPENMP
|
||||
#ifndef _OPENMP
|
||||
return E_NOTIMPL;
|
||||
#else
|
||||
#else
|
||||
hr = CompressBC_Parallel(srcImage, *img, GetBCFlags(compress), GetSRGBFlags(compress), threshold);
|
||||
#endif // _OPENMP
|
||||
#endif // _OPENMP
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -687,9 +687,9 @@ HRESULT DirectX::Compress(
|
|||
|
||||
if ((compress & TEX_COMPRESS_PARALLEL))
|
||||
{
|
||||
#ifndef _OPENMP
|
||||
#ifndef _OPENMP
|
||||
return E_NOTIMPL;
|
||||
#else
|
||||
#else
|
||||
if (compress & TEX_COMPRESS_PARALLEL)
|
||||
{
|
||||
hr = CompressBC_Parallel(src, dest[index], GetBCFlags(compress), GetSRGBFlags(compress), threshold);
|
||||
|
@ -699,7 +699,7 @@ HRESULT DirectX::Compress(
|
|||
return hr;
|
||||
}
|
||||
}
|
||||
#endif // _OPENMP
|
||||
#endif // _OPENMP
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
|
@ -311,108 +311,108 @@ HRESULT DirectX::Compress(
|
|||
{
|
||||
case TEX_DIMENSION_TEXTURE1D:
|
||||
case TEX_DIMENSION_TEXTURE2D:
|
||||
{
|
||||
size_t w = metadata.width;
|
||||
size_t h = metadata.height;
|
||||
|
||||
for (size_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
hr = gpubc->Prepare(w, h, compress, format, alphaWeight);
|
||||
if (FAILED(hr))
|
||||
size_t w = metadata.width;
|
||||
size_t h = metadata.height;
|
||||
|
||||
for (size_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
cImages.Release();
|
||||
return hr;
|
||||
}
|
||||
|
||||
for (size_t item = 0; item < metadata.arraySize; ++item)
|
||||
{
|
||||
const size_t index = metadata.ComputeIndex(level, item, 0);
|
||||
if (index >= nimages)
|
||||
{
|
||||
cImages.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
assert(dest[index].format == format);
|
||||
|
||||
const Image& src = srcImages[index];
|
||||
|
||||
if (src.width != dest[index].width || src.height != dest[index].height)
|
||||
{
|
||||
cImages.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
hr = GPUCompress(gpubc.get(), src, dest[index], compress);
|
||||
hr = gpubc->Prepare(w, h, compress, format, alphaWeight);
|
||||
if (FAILED(hr))
|
||||
{
|
||||
cImages.Release();
|
||||
return hr;
|
||||
}
|
||||
|
||||
for (size_t item = 0; item < metadata.arraySize; ++item)
|
||||
{
|
||||
const size_t index = metadata.ComputeIndex(level, item, 0);
|
||||
if (index >= nimages)
|
||||
{
|
||||
cImages.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
assert(dest[index].format == format);
|
||||
|
||||
const Image& src = srcImages[index];
|
||||
|
||||
if (src.width != dest[index].width || src.height != dest[index].height)
|
||||
{
|
||||
cImages.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
hr = GPUCompress(gpubc.get(), src, dest[index], compress);
|
||||
if (FAILED(hr))
|
||||
{
|
||||
cImages.Release();
|
||||
return hr;
|
||||
}
|
||||
}
|
||||
|
||||
if (h > 1)
|
||||
h >>= 1;
|
||||
|
||||
if (w > 1)
|
||||
w >>= 1;
|
||||
}
|
||||
|
||||
if (h > 1)
|
||||
h >>= 1;
|
||||
|
||||
if (w > 1)
|
||||
w >>= 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
case TEX_DIMENSION_TEXTURE3D:
|
||||
{
|
||||
size_t w = metadata.width;
|
||||
size_t h = metadata.height;
|
||||
size_t d = metadata.depth;
|
||||
|
||||
for (size_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
hr = gpubc->Prepare(w, h, compress, format, alphaWeight);
|
||||
if (FAILED(hr))
|
||||
size_t w = metadata.width;
|
||||
size_t h = metadata.height;
|
||||
size_t d = metadata.depth;
|
||||
|
||||
for (size_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
cImages.Release();
|
||||
return hr;
|
||||
}
|
||||
|
||||
for (size_t slice = 0; slice < d; ++slice)
|
||||
{
|
||||
const size_t index = metadata.ComputeIndex(level, 0, slice);
|
||||
if (index >= nimages)
|
||||
{
|
||||
cImages.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
assert(dest[index].format == format);
|
||||
|
||||
const Image& src = srcImages[index];
|
||||
|
||||
if (src.width != dest[index].width || src.height != dest[index].height)
|
||||
{
|
||||
cImages.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
hr = GPUCompress(gpubc.get(), src, dest[index], compress);
|
||||
hr = gpubc->Prepare(w, h, compress, format, alphaWeight);
|
||||
if (FAILED(hr))
|
||||
{
|
||||
cImages.Release();
|
||||
return hr;
|
||||
}
|
||||
|
||||
for (size_t slice = 0; slice < d; ++slice)
|
||||
{
|
||||
const size_t index = metadata.ComputeIndex(level, 0, slice);
|
||||
if (index >= nimages)
|
||||
{
|
||||
cImages.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
assert(dest[index].format == format);
|
||||
|
||||
const Image& src = srcImages[index];
|
||||
|
||||
if (src.width != dest[index].width || src.height != dest[index].height)
|
||||
{
|
||||
cImages.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
hr = GPUCompress(gpubc.get(), src, dest[index], compress);
|
||||
if (FAILED(hr))
|
||||
{
|
||||
cImages.Release();
|
||||
return hr;
|
||||
}
|
||||
}
|
||||
|
||||
if (h > 1)
|
||||
h >>= 1;
|
||||
|
||||
if (w > 1)
|
||||
w >>= 1;
|
||||
|
||||
if (d > 1)
|
||||
d >>= 1;
|
||||
}
|
||||
|
||||
if (h > 1)
|
||||
h >>= 1;
|
||||
|
||||
if (w > 1)
|
||||
w >>= 1;
|
||||
|
||||
if (d > 1)
|
||||
d >>= 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
default:
|
||||
return HRESULT_E_NOT_SUPPORTED;
|
||||
|
|
|
@ -69,7 +69,8 @@ namespace
|
|||
{
|
||||
Exponent--;
|
||||
Mantissa <<= 1;
|
||||
} while ((Mantissa & 0x80) == 0);
|
||||
}
|
||||
while ((Mantissa & 0x80) == 0);
|
||||
|
||||
Mantissa &= 0x7F;
|
||||
}
|
||||
|
@ -135,7 +136,8 @@ namespace
|
|||
{
|
||||
Exponent--;
|
||||
Mantissa <<= 1;
|
||||
} while ((Mantissa & 0x40) == 0);
|
||||
}
|
||||
while ((Mantissa & 0x40) == 0);
|
||||
|
||||
Mantissa &= 0x3F;
|
||||
}
|
||||
|
@ -190,9 +192,9 @@ namespace
|
|||
#endif
|
||||
|
||||
const XMVECTORF32 g_Grayscale = { { { 0.2125f, 0.7154f, 0.0721f, 0.0f } } };
|
||||
const XMVECTORF32 g_HalfMin = { { { -65504.f, -65504.f, -65504.f, -65504.f } } };
|
||||
const XMVECTORF32 g_HalfMax = { { { 65504.f, 65504.f, 65504.f, 65504.f } } };
|
||||
const XMVECTORF32 g_8BitBias = { { { 0.5f / 255.f, 0.5f / 255.f, 0.5f / 255.f, 0.5f / 255.f } } };
|
||||
const XMVECTORF32 g_HalfMin = { { { -65504.f, -65504.f, -65504.f, -65504.f } } };
|
||||
const XMVECTORF32 g_HalfMax = { { { 65504.f, 65504.f, 65504.f, 65504.f } } };
|
||||
const XMVECTORF32 g_8BitBias = { { { 0.5f / 255.f, 0.5f / 255.f, 0.5f / 255.f, 0.5f / 255.f } } };
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
|
@ -776,11 +778,11 @@ _Use_decl_annotations_ bool DirectX::Internal::LoadScanline(
|
|||
switch (static_cast<int>(format))
|
||||
{
|
||||
case DXGI_FORMAT_R32G32B32A32_FLOAT:
|
||||
{
|
||||
const size_t msize = (size > (sizeof(XMVECTOR)*count)) ? (sizeof(XMVECTOR)*count) : size;
|
||||
memcpy(dPtr, pSource, msize);
|
||||
}
|
||||
return true;
|
||||
{
|
||||
const size_t msize = (size > (sizeof(XMVECTOR)*count)) ? (sizeof(XMVECTOR)*count) : size;
|
||||
memcpy(dPtr, pSource, msize);
|
||||
}
|
||||
return true;
|
||||
|
||||
case DXGI_FORMAT_R32G32B32A32_UINT:
|
||||
LOAD_SCANLINE(XMUINT4, XMLoadUInt4)
|
||||
|
@ -822,6 +824,24 @@ _Use_decl_annotations_ bool DirectX::Internal::LoadScanline(
|
|||
LOAD_SCANLINE2(XMINT2, XMLoadSInt2, g_XMIdentityR3)
|
||||
|
||||
case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
|
||||
{
|
||||
constexpr size_t psize = sizeof(float) + sizeof(uint32_t);
|
||||
if (size >= psize)
|
||||
{
|
||||
auto sPtr = static_cast<const float*>(pSource);
|
||||
for (size_t icount = 0; icount < (size - psize + 1); icount += psize)
|
||||
{
|
||||
auto ps8 = reinterpret_cast<const uint8_t*>(&sPtr[1]);
|
||||
if (dPtr >= ePtr) break;
|
||||
*(dPtr++) = XMVectorSet(sPtr[0], static_cast<float>(*ps8), 0.f, 1.f);
|
||||
sPtr += 2;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
|
||||
case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS:
|
||||
{
|
||||
constexpr size_t psize = sizeof(float) + sizeof(uint32_t);
|
||||
if (size >= psize)
|
||||
|
@ -829,9 +849,8 @@ _Use_decl_annotations_ bool DirectX::Internal::LoadScanline(
|
|||
auto sPtr = static_cast<const float*>(pSource);
|
||||
for (size_t icount = 0; icount < (size - psize + 1); icount += psize)
|
||||
{
|
||||
auto ps8 = reinterpret_cast<const uint8_t*>(&sPtr[1]);
|
||||
if (dPtr >= ePtr) break;
|
||||
*(dPtr++) = XMVectorSet(sPtr[0], static_cast<float>(*ps8), 0.f, 1.f);
|
||||
*(dPtr++) = XMVectorSet(sPtr[0], 0.f /* typeless component assumed zero */, 0.f, 1.f);
|
||||
sPtr += 2;
|
||||
}
|
||||
return true;
|
||||
|
@ -839,40 +858,23 @@ _Use_decl_annotations_ bool DirectX::Internal::LoadScanline(
|
|||
}
|
||||
return false;
|
||||
|
||||
case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS:
|
||||
{
|
||||
constexpr size_t psize = sizeof(float) + sizeof(uint32_t);
|
||||
if (size >= psize)
|
||||
{
|
||||
auto sPtr = static_cast<const float*>(pSource);
|
||||
for (size_t icount = 0; icount < (size - psize + 1); icount += psize)
|
||||
{
|
||||
if (dPtr >= ePtr) break;
|
||||
*(dPtr++) = XMVectorSet(sPtr[0], 0.f /* typeless component assumed zero */, 0.f, 1.f);
|
||||
sPtr += 2;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
|
||||
case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT:
|
||||
{
|
||||
constexpr size_t psize = sizeof(float) + sizeof(uint32_t);
|
||||
if (size >= psize)
|
||||
{
|
||||
auto sPtr = static_cast<const float*>(pSource);
|
||||
for (size_t icount = 0; icount < (size - psize + 1); icount += psize)
|
||||
constexpr size_t psize = sizeof(float) + sizeof(uint32_t);
|
||||
if (size >= psize)
|
||||
{
|
||||
auto pg8 = reinterpret_cast<const uint8_t*>(&sPtr[1]);
|
||||
if (dPtr >= ePtr) break;
|
||||
*(dPtr++) = XMVectorSet(0.f /* typeless component assumed zero */, static_cast<float>(*pg8), 0.f, 1.f);
|
||||
sPtr += 2;
|
||||
auto sPtr = static_cast<const float*>(pSource);
|
||||
for (size_t icount = 0; icount < (size - psize + 1); icount += psize)
|
||||
{
|
||||
auto pg8 = reinterpret_cast<const uint8_t*>(&sPtr[1]);
|
||||
if (dPtr >= ePtr) break;
|
||||
*(dPtr++) = XMVectorSet(0.f /* typeless component assumed zero */, static_cast<float>(*pg8), 0.f, 1.f);
|
||||
sPtr += 2;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
return false;
|
||||
|
||||
case DXGI_FORMAT_R10G10B10A2_UNORM:
|
||||
LOAD_SCANLINE(XMUDECN4, XMLoadUDecN4)
|
||||
|
@ -1687,26 +1689,26 @@ bool DirectX::Internal::StoreScanline(
|
|||
STORE_SCANLINE(XMINT2, XMStoreSInt2)
|
||||
|
||||
case DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
|
||||
{
|
||||
constexpr size_t psize = sizeof(float) + sizeof(uint32_t);
|
||||
if (size >= psize)
|
||||
{
|
||||
auto dPtr = static_cast<float*>(pDestination);
|
||||
for (size_t icount = 0; icount < (size - psize + 1); icount += psize)
|
||||
constexpr size_t psize = sizeof(float) + sizeof(uint32_t);
|
||||
if (size >= psize)
|
||||
{
|
||||
if (sPtr >= ePtr) break;
|
||||
XMFLOAT4 f;
|
||||
XMStoreFloat4(&f, *sPtr++);
|
||||
dPtr[0] = f.x;
|
||||
auto ps8 = reinterpret_cast<uint8_t*>(&dPtr[1]);
|
||||
ps8[0] = static_cast<uint8_t>(std::min<float>(255.f, std::max<float>(0.f, f.y)));
|
||||
ps8[1] = ps8[2] = ps8[3] = 0;
|
||||
dPtr += 2;
|
||||
auto dPtr = static_cast<float*>(pDestination);
|
||||
for (size_t icount = 0; icount < (size - psize + 1); icount += psize)
|
||||
{
|
||||
if (sPtr >= ePtr) break;
|
||||
XMFLOAT4 f;
|
||||
XMStoreFloat4(&f, *sPtr++);
|
||||
dPtr[0] = f.x;
|
||||
auto ps8 = reinterpret_cast<uint8_t*>(&dPtr[1]);
|
||||
ps8[0] = static_cast<uint8_t>(std::min<float>(255.f, std::max<float>(0.f, f.y)));
|
||||
ps8[1] = ps8[2] = ps8[3] = 0;
|
||||
dPtr += 2;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
return false;
|
||||
|
||||
case DXGI_FORMAT_R10G10B10A2_UNORM:
|
||||
STORE_SCANLINE(XMUDECN4, XMStoreUDecN4)
|
||||
|
@ -2066,7 +2068,11 @@ bool DirectX::Internal::StoreScanline(
|
|||
{
|
||||
if (sPtr >= ePtr) break;
|
||||
XMVECTOR v = XMVectorSwizzle<2, 1, 0, 3>(*sPtr++);
|
||||
#if defined(_M_ARM) || defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __arm__ || __aarch64__
|
||||
v = XMVectorMultiplyAdd(v, s_Scale, g_XMOneHalf);
|
||||
#else
|
||||
v = XMVectorMultiply(v, s_Scale);
|
||||
#endif
|
||||
XMStoreU565(dPtr++, v);
|
||||
}
|
||||
return true;
|
||||
|
@ -2077,12 +2083,19 @@ bool DirectX::Internal::StoreScanline(
|
|||
if (size >= sizeof(XMU555))
|
||||
{
|
||||
static const XMVECTORF32 s_Scale = { { { 31.f, 31.f, 31.f, 1.f } } };
|
||||
#if defined(_M_ARM) || defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __arm__ || __aarch64__
|
||||
static const XMVECTORF32 s_OneHalfXYZ = { { { 0.5f, 0.5f, 0.5f, 0.f } } };
|
||||
#endif
|
||||
XMU555 * __restrict dPtr = static_cast<XMU555*>(pDestination);
|
||||
for (size_t icount = 0; icount < (size - sizeof(XMU555) + 1); icount += sizeof(XMU555))
|
||||
{
|
||||
if (sPtr >= ePtr) break;
|
||||
XMVECTOR v = XMVectorSwizzle<2, 1, 0, 3>(*sPtr++);
|
||||
#if defined(_M_ARM) || defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __arm__ || __aarch64__
|
||||
v = XMVectorMultiplyAdd(v, s_Scale, s_OneHalfXYZ);
|
||||
#else
|
||||
v = XMVectorMultiply(v, s_Scale);
|
||||
#endif
|
||||
XMStoreU555(dPtr, v);
|
||||
dPtr->w = (XMVectorGetW(v) > threshold) ? 1u : 0u;
|
||||
++dPtr;
|
||||
|
@ -2240,15 +2253,11 @@ bool DirectX::Internal::StoreScanline(
|
|||
const int u0 = ((-38 * rgb1.x - 74 * rgb1.y + 112 * rgb1.z + 128) >> 8) + 128;
|
||||
const int v0 = ((112 * rgb1.x - 94 * rgb1.y - 18 * rgb1.z + 128) >> 8) + 128;
|
||||
|
||||
XMUBYTEN4 rgb2;
|
||||
XMUBYTEN4 rgb2 = {};
|
||||
if (sPtr < ePtr)
|
||||
{
|
||||
XMStoreUByteN4(&rgb2, *sPtr++);
|
||||
}
|
||||
else
|
||||
{
|
||||
rgb2.x = rgb2.y = rgb2.z = rgb2.w = 0;
|
||||
}
|
||||
|
||||
const int y1 = ((66 * rgb2.x + 129 * rgb2.y + 25 * rgb2.z + 128) >> 8) + 16;
|
||||
const int u1 = ((-38 * rgb2.x - 74 * rgb2.y + 112 * rgb2.z + 128) >> 8) + 128;
|
||||
|
@ -2285,15 +2294,11 @@ bool DirectX::Internal::StoreScanline(
|
|||
const int u0 = static_cast<int>((-9683 * r - 19017 * g + 28700 * b + 32768) >> 16) + 512;
|
||||
const int v0 = static_cast<int>((28700 * r - 24033 * g - 4667 * b + 32768) >> 16) + 512;
|
||||
|
||||
XMUDECN4 rgb2;
|
||||
XMUDECN4 rgb2 = {};
|
||||
if (sPtr < ePtr)
|
||||
{
|
||||
XMStoreUDecN4(&rgb2, *sPtr++);
|
||||
}
|
||||
else
|
||||
{
|
||||
rgb2.x = rgb2.y = rgb2.z = rgb2.w = 0;
|
||||
}
|
||||
|
||||
r = rgb2.x;
|
||||
g = rgb2.y;
|
||||
|
@ -2333,15 +2338,11 @@ bool DirectX::Internal::StoreScanline(
|
|||
const int u0 = static_cast<int>((-9674 * r - 18998 * g + 28672 * b + 32768) >> 16) + 32768;
|
||||
const int v0 = static_cast<int>((28672 * r - 24010 * g - 4662 * b + 32768) >> 16) + 32768;
|
||||
|
||||
XMUSHORTN4 rgb2;
|
||||
XMUSHORTN4 rgb2 = {};
|
||||
if (sPtr < ePtr)
|
||||
{
|
||||
XMStoreUShortN4(&rgb2, *sPtr++);
|
||||
}
|
||||
else
|
||||
{
|
||||
rgb2.x = rgb2.y = rgb2.z = rgb2.w = 0;
|
||||
}
|
||||
|
||||
r = int64_t(rgb2.x);
|
||||
g = int64_t(rgb2.y);
|
||||
|
@ -2370,7 +2371,11 @@ bool DirectX::Internal::StoreScanline(
|
|||
{
|
||||
if (sPtr >= ePtr) break;
|
||||
XMVECTOR v = XMVectorSwizzle<2, 1, 0, 3>(*sPtr++);
|
||||
#if defined(_M_ARM) || defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __arm__ || __aarch64__
|
||||
v = XMVectorMultiplyAdd(v, s_Scale, g_XMOneHalf);
|
||||
#else
|
||||
v = XMVectorMultiply(v, s_Scale);
|
||||
#endif
|
||||
XMStoreUNibble4(dPtr++, v);
|
||||
}
|
||||
return true;
|
||||
|
@ -2446,8 +2451,11 @@ bool DirectX::Internal::StoreScanline(
|
|||
for (size_t icount = 0; icount < (size - sizeof(uint8_t) + 1); icount += sizeof(uint8_t))
|
||||
{
|
||||
if (sPtr >= ePtr) break;
|
||||
#if defined(_M_ARM) || defined(_M_ARM64) || defined(_M_HYBRID_X86_ARM64) || defined(_M_ARM64EC) || __arm__ || __aarch64__
|
||||
const XMVECTOR v = XMVectorMultiplyAdd(*sPtr++, s_Scale, g_XMOneHalf);
|
||||
#else
|
||||
const XMVECTOR v = XMVectorMultiply(*sPtr++, s_Scale);
|
||||
|
||||
#endif
|
||||
XMUNIBBLE4 nibble;
|
||||
XMStoreUNibble4(&nibble, v);
|
||||
*dPtr = static_cast<uint8_t>(nibble.v);
|
||||
|
@ -3227,28 +3235,28 @@ void DirectX::Internal::ConvertScanline(
|
|||
switch (flags & (TEX_FILTER_RGB_COPY_RED | TEX_FILTER_RGB_COPY_GREEN | TEX_FILTER_RGB_COPY_BLUE))
|
||||
{
|
||||
case TEX_FILTER_RGB_COPY_GREEN:
|
||||
{
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
const XMVECTOR v1 = XMVectorSplatY(v);
|
||||
*ptr++ = XMVectorSelect(v, v1, g_XMSelect1000);
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
const XMVECTOR v1 = XMVectorSplatY(v);
|
||||
*ptr++ = XMVectorSelect(v, v1, g_XMSelect1000);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
case TEX_FILTER_RGB_COPY_BLUE:
|
||||
{
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
const XMVECTOR v1 = XMVectorSplatZ(v);
|
||||
*ptr++ = XMVectorSelect(v, v1, g_XMSelect1000);
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
const XMVECTOR v1 = XMVectorSplatZ(v);
|
||||
*ptr++ = XMVectorSelect(v, v1, g_XMSelect1000);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
default:
|
||||
if ((in->flags & CONVF_UNORM) && ((in->flags & CONVF_RGB_MASK) == (CONVF_R | CONVF_G | CONVF_B)))
|
||||
|
@ -3263,25 +3271,25 @@ void DirectX::Internal::ConvertScanline(
|
|||
break;
|
||||
}
|
||||
|
||||
#if (__cplusplus >= 201703L)
|
||||
#if (__cplusplus >= 201703L)
|
||||
[[fallthrough]];
|
||||
#elif defined(__clang__)
|
||||
#elif defined(__clang__)
|
||||
[[clang::fallthrough]];
|
||||
#elif defined(_MSC_VER)
|
||||
#elif defined(_MSC_VER)
|
||||
__fallthrough;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
case TEX_FILTER_RGB_COPY_RED:
|
||||
{
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
const XMVECTOR v1 = XMVectorSplatX(v);
|
||||
*ptr++ = XMVectorSelect(v, v1, g_XMSelect1000);
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
const XMVECTOR v1 = XMVectorSplatX(v);
|
||||
*ptr++ = XMVectorSelect(v, v1, g_XMSelect1000);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
}
|
||||
|
||||
// Finialize type conversion for depth (red channel)
|
||||
|
@ -3520,26 +3528,26 @@ void DirectX::Internal::ConvertScanline(
|
|||
switch (flags & (TEX_FILTER_RGB_COPY_RED | TEX_FILTER_RGB_COPY_GREEN | TEX_FILTER_RGB_COPY_BLUE))
|
||||
{
|
||||
case TEX_FILTER_RGB_COPY_GREEN:
|
||||
{
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
*ptr++ = XMVectorSplatY(v);
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
*ptr++ = XMVectorSplatY(v);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
case TEX_FILTER_RGB_COPY_BLUE:
|
||||
{
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
*ptr++ = XMVectorSplatZ(v);
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
*ptr++ = XMVectorSplatZ(v);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
default:
|
||||
if ((in->flags & CONVF_UNORM) && ((in->flags & CONVF_RGB_MASK) == (CONVF_R | CONVF_G | CONVF_B)))
|
||||
|
@ -3553,24 +3561,24 @@ void DirectX::Internal::ConvertScanline(
|
|||
break;
|
||||
}
|
||||
|
||||
#if (__cplusplus >= 201703L)
|
||||
#if (__cplusplus >= 201703L)
|
||||
[[fallthrough]];
|
||||
#elif defined(__clang__)
|
||||
#elif defined(__clang__)
|
||||
[[clang::fallthrough]];
|
||||
#elif defined(_MSC_VER)
|
||||
#elif defined(_MSC_VER)
|
||||
__fallthrough;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
case TEX_FILTER_RGB_COPY_RED:
|
||||
{
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
*ptr++ = XMVectorSplatX(v);
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
*ptr++ = XMVectorSplatX(v);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (((in->flags & CONVF_RGBA_MASK) == CONVF_A) && !(out->flags & CONVF_A))
|
||||
|
@ -3616,28 +3624,28 @@ void DirectX::Internal::ConvertScanline(
|
|||
switch (flags & (TEX_FILTER_RGB_COPY_RED | TEX_FILTER_RGB_COPY_GREEN | TEX_FILTER_RGB_COPY_BLUE))
|
||||
{
|
||||
case TEX_FILTER_RGB_COPY_GREEN:
|
||||
{
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
const XMVECTOR v1 = XMVectorSplatY(v);
|
||||
*ptr++ = XMVectorSelect(v, v1, g_XMSelect1110);
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
const XMVECTOR v1 = XMVectorSplatY(v);
|
||||
*ptr++ = XMVectorSelect(v, v1, g_XMSelect1110);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
case TEX_FILTER_RGB_COPY_BLUE:
|
||||
{
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
const XMVECTOR v1 = XMVectorSplatZ(v);
|
||||
*ptr++ = XMVectorSelect(v, v1, g_XMSelect1110);
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
const XMVECTOR v1 = XMVectorSplatZ(v);
|
||||
*ptr++ = XMVectorSelect(v, v1, g_XMSelect1110);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
default:
|
||||
if (in->flags & CONVF_UNORM)
|
||||
|
@ -3652,13 +3660,13 @@ void DirectX::Internal::ConvertScanline(
|
|||
break;
|
||||
}
|
||||
|
||||
#if (__cplusplus >= 201703L)
|
||||
#if (__cplusplus >= 201703L)
|
||||
[[fallthrough]];
|
||||
#elif defined(__clang__)
|
||||
#elif defined(__clang__)
|
||||
[[clang::fallthrough]];
|
||||
#elif defined(_MSC_VER)
|
||||
#elif defined(_MSC_VER)
|
||||
__fallthrough;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
case TEX_FILTER_RGB_COPY_RED:
|
||||
// Leave data unchanged and the store will handle this...
|
||||
|
@ -3670,31 +3678,31 @@ void DirectX::Internal::ConvertScanline(
|
|||
// RGB format -> RG format
|
||||
switch (static_cast<int>(flags & (TEX_FILTER_RGB_COPY_RED | TEX_FILTER_RGB_COPY_GREEN | TEX_FILTER_RGB_COPY_BLUE)))
|
||||
{
|
||||
case static_cast<int>(TEX_FILTER_RGB_COPY_RED) | static_cast<int>(TEX_FILTER_RGB_COPY_BLUE):
|
||||
{
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
case (static_cast<int>(TEX_FILTER_RGB_COPY_RED) | static_cast<int>(TEX_FILTER_RGB_COPY_BLUE)):
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
const XMVECTOR v1 = XMVectorSwizzle<0, 2, 0, 2>(v);
|
||||
*ptr++ = XMVectorSelect(v, v1, g_XMSelect1100);
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
const XMVECTOR v1 = XMVectorSwizzle<0, 2, 0, 2>(v);
|
||||
*ptr++ = XMVectorSelect(v, v1, g_XMSelect1100);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
case static_cast<int>(TEX_FILTER_RGB_COPY_GREEN) | static_cast<int>(TEX_FILTER_RGB_COPY_BLUE):
|
||||
{
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
case (static_cast<int>(TEX_FILTER_RGB_COPY_GREEN) | static_cast<int>(TEX_FILTER_RGB_COPY_BLUE)):
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
const XMVECTOR v1 = XMVectorSwizzle<1, 2, 3, 0>(v);
|
||||
*ptr++ = XMVectorSelect(v, v1, g_XMSelect1100);
|
||||
XMVECTOR* ptr = pBuffer;
|
||||
for (size_t i = 0; i < count; ++i)
|
||||
{
|
||||
const XMVECTOR v = *ptr;
|
||||
const XMVECTOR v1 = XMVectorSwizzle<1, 2, 3, 0>(v);
|
||||
*ptr++ = XMVectorSelect(v, v1, g_XMSelect1100);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
case static_cast<int>(TEX_FILTER_RGB_COPY_RED) | static_cast<int>(TEX_FILTER_RGB_COPY_GREEN):
|
||||
case (static_cast<int>(TEX_FILTER_RGB_COPY_RED) | static_cast<int>(TEX_FILTER_RGB_COPY_GREEN)):
|
||||
default:
|
||||
// Leave data unchanged and the store will handle this...
|
||||
break;
|
||||
|
@ -3733,15 +3741,15 @@ namespace
|
|||
-0.468750f, 0.031250f, -0.343750f, 0.156250f, -0.468750f, 0.031250f, -0.343750f, 0.156250f,
|
||||
};
|
||||
|
||||
const XMVECTORF32 g_Scale16pc = { { { 65535.f, 65535.f, 65535.f, 65535.f } } };
|
||||
const XMVECTORF32 g_Scale15pc = { { { 32767.f, 32767.f, 32767.f, 32767.f } } };
|
||||
const XMVECTORF32 g_Scale10pc = { { { 1023.f, 1023.f, 1023.f, 3.f } } };
|
||||
const XMVECTORF32 g_Scale9pc = { { { 511.f, 511.f, 511.f, 3.f } } };
|
||||
const XMVECTORF32 g_Scale8pc = { { { 255.f, 255.f, 255.f, 255.f } } };
|
||||
const XMVECTORF32 g_Scale7pc = { { { 127.f, 127.f, 127.f, 127.f } } };
|
||||
const XMVECTORF32 g_Scale565pc = { { { 31.f, 63.f, 31.f, 1.f } } };
|
||||
const XMVECTORF32 g_Scale16pc = { { { 65535.f, 65535.f, 65535.f, 65535.f } } };
|
||||
const XMVECTORF32 g_Scale15pc = { { { 32767.f, 32767.f, 32767.f, 32767.f } } };
|
||||
const XMVECTORF32 g_Scale10pc = { { { 1023.f, 1023.f, 1023.f, 3.f } } };
|
||||
const XMVECTORF32 g_Scale9pc = { { { 511.f, 511.f, 511.f, 3.f } } };
|
||||
const XMVECTORF32 g_Scale8pc = { { { 255.f, 255.f, 255.f, 255.f } } };
|
||||
const XMVECTORF32 g_Scale7pc = { { { 127.f, 127.f, 127.f, 127.f } } };
|
||||
const XMVECTORF32 g_Scale565pc = { { { 31.f, 63.f, 31.f, 1.f } } };
|
||||
const XMVECTORF32 g_Scale5551pc = { { { 31.f, 31.f, 31.f, 1.f } } };
|
||||
const XMVECTORF32 g_Scale4pc = { { { 15.f, 15.f, 15.f, 15.f } } };
|
||||
const XMVECTORF32 g_Scale4pc = { { { 15.f, 15.f, 15.f, 15.f } } };
|
||||
|
||||
const XMVECTORF32 g_ErrorWeight3 = { { { 3.f / 16.f, 3.f / 16.f, 3.f / 16.f, 3.f / 16.f } } };
|
||||
const XMVECTORF32 g_ErrorWeight5 = { { { 5.f / 16.f, 5.f / 16.f, 5.f / 16.f, 5.f / 16.f } } };
|
||||
|
@ -3997,7 +4005,7 @@ bool DirectX::Internal::StoreScanlineDither(
|
|||
if (size >= sizeof(XMUDEC4))
|
||||
{
|
||||
static const XMVECTORF32 Scale = { { { 510.0f, 510.0f, 510.0f, 3.0f } } };
|
||||
static const XMVECTORF32 Bias = { { { 384.0f, 384.0f, 384.0f, 0.0f } } };
|
||||
static const XMVECTORF32 Bias = { { { 384.0f, 384.0f, 384.0f, 0.0f } } };
|
||||
static const XMVECTORF32 MinXR = { { { -0.7529f, -0.7529f, -0.7529f, 0.f } } };
|
||||
static const XMVECTORF32 MaxXR = { { { 1.2529f, 1.2529f, 1.2529f, 1.0f } } };
|
||||
|
||||
|
@ -4018,8 +4026,8 @@ bool DirectX::Internal::StoreScanlineDither(
|
|||
vError = XMVectorDivide(vError, Scale);
|
||||
|
||||
// Distribute error to next scanline and next pixel
|
||||
pDiffusionErrors[index - delta] = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[index - delta]);
|
||||
pDiffusionErrors[index + 1] = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[index + 1]);
|
||||
pDiffusionErrors[index - delta] = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[index - delta]);
|
||||
pDiffusionErrors[index + 1] = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[index + 1]);
|
||||
pDiffusionErrors[index + 2 + delta] = XMVectorMultiplyAdd(g_ErrorWeight1, vError, pDiffusionErrors[index + 2 + delta]);
|
||||
vError = XMVectorMultiply(vError, g_ErrorWeight7);
|
||||
}
|
||||
|
@ -4075,8 +4083,8 @@ bool DirectX::Internal::StoreScanlineDither(
|
|||
case DXGI_FORMAT_D24_UNORM_S8_UINT:
|
||||
if (size >= sizeof(uint32_t))
|
||||
{
|
||||
static const XMVECTORF32 Clamp = { { { 1.f, 255.f, 0.f, 0.f } } };
|
||||
static const XMVECTORF32 Scale = { { { 16777215.f, 1.f, 0.f, 0.f } } };
|
||||
static const XMVECTORF32 Clamp = { { { 1.f, 255.f, 0.f, 0.f } } };
|
||||
static const XMVECTORF32 Scale = { { { 16777215.f, 1.f, 0.f, 0.f } } };
|
||||
static const XMVECTORF32 Scale2 = { { { 16777215.f, 255.f, 0.f, 0.f } } };
|
||||
|
||||
uint32_t * __restrict dest = static_cast<uint32_t*>(pDestination);
|
||||
|
@ -4097,8 +4105,8 @@ bool DirectX::Internal::StoreScanlineDither(
|
|||
vError = XMVectorDivide(vError, Scale);
|
||||
|
||||
// Distribute error to next scanline and next pixel
|
||||
pDiffusionErrors[index - delta] = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[index - delta]);
|
||||
pDiffusionErrors[index + 1] = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[index + 1]);
|
||||
pDiffusionErrors[index - delta] = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[index - delta]);
|
||||
pDiffusionErrors[index + 1] = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[index + 1]);
|
||||
pDiffusionErrors[index + 2 + delta] = XMVectorMultiplyAdd(g_ErrorWeight1, vError, pDiffusionErrors[index + 2 + delta]);
|
||||
vError = XMVectorMultiply(vError, g_ErrorWeight7);
|
||||
}
|
||||
|
@ -4185,8 +4193,8 @@ bool DirectX::Internal::StoreScanlineDither(
|
|||
vError = XMVectorDivide(vError, g_Scale565pc);
|
||||
|
||||
// Distribute error to next scanline and next pixel
|
||||
pDiffusionErrors[index - delta] = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[index - delta]);
|
||||
pDiffusionErrors[index + 1] = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[index + 1]);
|
||||
pDiffusionErrors[index - delta] = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[index - delta]);
|
||||
pDiffusionErrors[index + 1] = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[index + 1]);
|
||||
pDiffusionErrors[index + 2 + delta] = XMVectorMultiplyAdd(g_ErrorWeight1, vError, pDiffusionErrors[index + 2 + delta]);
|
||||
vError = XMVectorMultiply(vError, g_ErrorWeight7);
|
||||
}
|
||||
|
@ -4234,8 +4242,8 @@ bool DirectX::Internal::StoreScanlineDither(
|
|||
vError = XMVectorDivide(vError, g_Scale5551pc);
|
||||
|
||||
// Distribute error to next scanline and next pixel
|
||||
pDiffusionErrors[index - delta] = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[index - delta]);
|
||||
pDiffusionErrors[index + 1] = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[index + 1]);
|
||||
pDiffusionErrors[index - delta] = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[index - delta]);
|
||||
pDiffusionErrors[index + 1] = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[index + 1]);
|
||||
pDiffusionErrors[index + 2 + delta] = XMVectorMultiplyAdd(g_ErrorWeight1, vError, pDiffusionErrors[index + 2 + delta]);
|
||||
vError = XMVectorMultiply(vError, g_ErrorWeight7);
|
||||
}
|
||||
|
@ -4289,8 +4297,8 @@ bool DirectX::Internal::StoreScanlineDither(
|
|||
vError = XMVectorDivide(vError, g_Scale8pc);
|
||||
|
||||
// Distribute error to next scanline and next pixel
|
||||
pDiffusionErrors[index - delta] = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[index - delta]);
|
||||
pDiffusionErrors[index + 1] = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[index + 1]);
|
||||
pDiffusionErrors[index - delta] = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[index - delta]);
|
||||
pDiffusionErrors[index + 1] = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[index + 1]);
|
||||
pDiffusionErrors[index + 2 + delta] = XMVectorMultiplyAdd(g_ErrorWeight1, vError, pDiffusionErrors[index + 2 + delta]);
|
||||
vError = XMVectorMultiply(vError, g_ErrorWeight7);
|
||||
}
|
||||
|
@ -4344,8 +4352,8 @@ bool DirectX::Internal::StoreScanlineDither(
|
|||
vError = XMVectorDivide(vError, g_Scale4pc);
|
||||
|
||||
// Distribute error to next scanline and next pixel
|
||||
pDiffusionErrors[index - delta] = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[index - delta]);
|
||||
pDiffusionErrors[index + 1] = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[index + 1]);
|
||||
pDiffusionErrors[index - delta] = XMVectorMultiplyAdd(g_ErrorWeight3, vError, pDiffusionErrors[index - delta]);
|
||||
pDiffusionErrors[index + 1] = XMVectorMultiplyAdd(g_ErrorWeight5, vError, pDiffusionErrors[index + 1]);
|
||||
pDiffusionErrors[index + 2 + delta] = XMVectorMultiplyAdd(g_ErrorWeight1, vError, pDiffusionErrors[index + 2 + delta]);
|
||||
vError = XMVectorMultiply(vError, g_ErrorWeight7);
|
||||
}
|
||||
|
@ -4392,14 +4400,14 @@ namespace
|
|||
_Out_ WICPixelFormatGUID& pfGUID,
|
||||
_Out_ WICPixelFormatGUID& targetGUID) noexcept
|
||||
{
|
||||
#ifndef WIN32
|
||||
#ifndef _WIN32
|
||||
UNREFERENCED_PARAMETER(filter);
|
||||
UNREFERENCED_PARAMETER(sformat);
|
||||
UNREFERENCED_PARAMETER(tformat);
|
||||
UNREFERENCED_PARAMETER(pfGUID);
|
||||
UNREFERENCED_PARAMETER(targetGUID);
|
||||
return false;
|
||||
#else
|
||||
#else
|
||||
memset(&pfGUID, 0, sizeof(GUID));
|
||||
memset(&targetGUID, 0, sizeof(GUID));
|
||||
|
||||
|
@ -4434,7 +4442,7 @@ namespace
|
|||
}
|
||||
|
||||
// Check for special cases
|
||||
#if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
|
||||
#if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
|
||||
if (sformat == DXGI_FORMAT_R16G16B16A16_FLOAT
|
||||
|| sformat == DXGI_FORMAT_R16_FLOAT
|
||||
|| tformat == DXGI_FORMAT_R16G16B16A16_FLOAT
|
||||
|
@ -4443,7 +4451,7 @@ namespace
|
|||
// Use non-WIC code paths as these conversions are not supported by Xbox version of WIC
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
switch (sformat)
|
||||
{
|
||||
|
@ -4541,7 +4549,7 @@ namespace
|
|||
}
|
||||
|
||||
return true;
|
||||
#endif // WIN32
|
||||
#endif // WIN32
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
|
@ -4555,7 +4563,7 @@ namespace
|
|||
_In_ float threshold,
|
||||
_In_ const Image& destImage)
|
||||
{
|
||||
#ifndef WIN32
|
||||
#ifndef _WIN32
|
||||
UNREFERENCED_PARAMETER(srcImage);
|
||||
UNREFERENCED_PARAMETER(pfGUID);
|
||||
UNREFERENCED_PARAMETER(targetGUID);
|
||||
|
@ -4563,7 +4571,7 @@ namespace
|
|||
UNREFERENCED_PARAMETER(threshold);
|
||||
UNREFERENCED_PARAMETER(destImage);
|
||||
return E_NOTIMPL;
|
||||
#else
|
||||
#else
|
||||
assert(srcImage.width == destImage.width);
|
||||
assert(srcImage.height == destImage.height);
|
||||
|
||||
|
@ -4609,7 +4617,7 @@ namespace
|
|||
return hr;
|
||||
|
||||
return S_OK;
|
||||
#endif // WIN32
|
||||
#endif // WIN32
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
|
@ -4773,6 +4781,10 @@ namespace
|
|||
}\
|
||||
}
|
||||
|
||||
#ifdef __clang__
|
||||
#pragma clang diagnostic ignored "-Wextra-semi-stmt"
|
||||
#endif
|
||||
|
||||
HRESULT ConvertToSinglePlane_(_In_ const Image& srcImage, _In_ const Image& destImage) noexcept
|
||||
{
|
||||
assert(srcImage.width == destImage.width);
|
||||
|
@ -4787,21 +4799,33 @@ namespace
|
|||
{
|
||||
case DXGI_FORMAT_NV12:
|
||||
assert(destImage.format == DXGI_FORMAT_YUY2);
|
||||
CONVERT_420_TO_422(uint8_t, XMUBYTEN4)
|
||||
if ((srcImage.width % 2) != 0 || (srcImage.height % 2) != 0)
|
||||
return E_INVALIDARG;
|
||||
|
||||
CONVERT_420_TO_422(uint8_t, XMUBYTEN4);
|
||||
return S_OK;
|
||||
|
||||
case DXGI_FORMAT_P010:
|
||||
assert(destImage.format == DXGI_FORMAT_Y210);
|
||||
CONVERT_420_TO_422(uint16_t, XMUSHORTN4)
|
||||
if ((srcImage.width % 2) != 0 || (srcImage.height % 2) != 0)
|
||||
return E_INVALIDARG;
|
||||
|
||||
CONVERT_420_TO_422(uint16_t, XMUSHORTN4);
|
||||
return S_OK;
|
||||
|
||||
case DXGI_FORMAT_P016:
|
||||
assert(destImage.format == DXGI_FORMAT_Y216);
|
||||
CONVERT_420_TO_422(uint16_t, XMUSHORTN4)
|
||||
if ((srcImage.width % 2) != 0 || (srcImage.height % 2) != 0)
|
||||
return E_INVALIDARG;
|
||||
|
||||
CONVERT_420_TO_422(uint16_t, XMUSHORTN4);
|
||||
return S_OK;
|
||||
|
||||
case DXGI_FORMAT_NV11:
|
||||
assert(destImage.format == DXGI_FORMAT_YUY2);
|
||||
if ((srcImage.width % 4) != 0)
|
||||
return E_INVALIDARG;
|
||||
|
||||
// Convert 4:1:1 to 4:2:2
|
||||
{
|
||||
const size_t rowPitch = srcImage.rowPitch;
|
||||
|
@ -5007,62 +5031,62 @@ HRESULT DirectX::Convert(
|
|||
break;
|
||||
|
||||
case TEX_DIMENSION_TEXTURE3D:
|
||||
{
|
||||
size_t index = 0;
|
||||
size_t d = metadata.depth;
|
||||
for (size_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
for (size_t slice = 0; slice < d; ++slice, ++index)
|
||||
size_t index = 0;
|
||||
size_t d = metadata.depth;
|
||||
for (size_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
if (index >= nimages)
|
||||
for (size_t slice = 0; slice < d; ++slice, ++index)
|
||||
{
|
||||
result.Release();
|
||||
return E_FAIL;
|
||||
if (index >= nimages)
|
||||
{
|
||||
result.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
const Image& src = srcImages[index];
|
||||
if (src.format != metadata.format)
|
||||
{
|
||||
result.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
if ((src.width > UINT32_MAX) || (src.height > UINT32_MAX))
|
||||
{
|
||||
result.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
const Image& dst = dest[index];
|
||||
assert(dst.format == format);
|
||||
|
||||
if (src.width != dst.width || src.height != dst.height)
|
||||
{
|
||||
result.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
if (usewic)
|
||||
{
|
||||
hr = ConvertUsingWIC(src, pfGUID, targetGUID, filter, threshold, dst);
|
||||
}
|
||||
else
|
||||
{
|
||||
hr = ConvertCustom(src, filter, dst, threshold, slice);
|
||||
}
|
||||
|
||||
if (FAILED(hr))
|
||||
{
|
||||
result.Release();
|
||||
return hr;
|
||||
}
|
||||
}
|
||||
|
||||
const Image& src = srcImages[index];
|
||||
if (src.format != metadata.format)
|
||||
{
|
||||
result.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
if ((src.width > UINT32_MAX) || (src.height > UINT32_MAX))
|
||||
{
|
||||
result.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
const Image& dst = dest[index];
|
||||
assert(dst.format == format);
|
||||
|
||||
if (src.width != dst.width || src.height != dst.height)
|
||||
{
|
||||
result.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
if (usewic)
|
||||
{
|
||||
hr = ConvertUsingWIC(src, pfGUID, targetGUID, filter, threshold, dst);
|
||||
}
|
||||
else
|
||||
{
|
||||
hr = ConvertCustom(src, filter, dst, threshold, slice);
|
||||
}
|
||||
|
||||
if (FAILED(hr))
|
||||
{
|
||||
result.Release();
|
||||
return hr;
|
||||
}
|
||||
if (d > 1)
|
||||
d >>= 1;
|
||||
}
|
||||
|
||||
if (d > 1)
|
||||
d >>= 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
default:
|
||||
result.Release();
|
||||
|
|
|
@ -39,7 +39,7 @@ namespace
|
|||
if (!pContext || !pSource || !result.GetPixels())
|
||||
return E_POINTER;
|
||||
|
||||
#if defined(_XBOX_ONE) && defined(_TITLE)
|
||||
#if defined(_XBOX_ONE) && defined(_TITLE)
|
||||
|
||||
ComPtr<ID3D11Device> d3dDevice;
|
||||
pContext->GetDevice(d3dDevice.GetAddressOf());
|
||||
|
@ -64,7 +64,7 @@ namespace
|
|||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if (metadata.IsVolumemap())
|
||||
{
|
||||
|
@ -171,11 +171,13 @@ namespace
|
|||
return E_UNEXPECTED;
|
||||
}
|
||||
|
||||
const size_t msize = (metadata.dimension == TEX_DIMENSION_TEXTURE2D)
|
||||
? std::min<size_t>(img->rowPitch, mapped.RowPitch) : img->rowPitch;
|
||||
|
||||
auto sptr = static_cast<const uint8_t*>(mapped.pData);
|
||||
uint8_t* dptr = img->pixels;
|
||||
for (size_t h = 0; h < lines; ++h)
|
||||
{
|
||||
const size_t msize = std::min<size_t>(img->rowPitch, mapped.RowPitch);
|
||||
memcpy(dptr, sptr, msize);
|
||||
sptr += mapped.RowPitch;
|
||||
dptr += img->rowPitch;
|
||||
|
@ -217,6 +219,9 @@ bool DirectX::IsSupportedTexture(
|
|||
if (!IsValid(fmt))
|
||||
return false;
|
||||
|
||||
const size_t iWidth = metadata.width;
|
||||
const size_t iHeight = metadata.height;
|
||||
|
||||
switch (fmt)
|
||||
{
|
||||
case DXGI_FORMAT_BC4_TYPELESS:
|
||||
|
@ -239,6 +244,49 @@ bool DirectX::IsSupportedTexture(
|
|||
return false;
|
||||
break;
|
||||
|
||||
case DXGI_FORMAT_NV12:
|
||||
case DXGI_FORMAT_P010:
|
||||
case DXGI_FORMAT_P016:
|
||||
case DXGI_FORMAT_420_OPAQUE:
|
||||
if ((metadata.dimension != TEX_DIMENSION_TEXTURE2D)
|
||||
|| (iWidth % 2) != 0 || (iHeight % 2) != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
|
||||
case DXGI_FORMAT_YUY2:
|
||||
case DXGI_FORMAT_Y210:
|
||||
case DXGI_FORMAT_Y216:
|
||||
case WIN10_DXGI_FORMAT_P208:
|
||||
if ((iWidth % 2) != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
|
||||
case DXGI_FORMAT_NV11:
|
||||
if ((iWidth % 4) != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
|
||||
case DXGI_FORMAT_AI44:
|
||||
case DXGI_FORMAT_IA44:
|
||||
case DXGI_FORMAT_P8:
|
||||
case DXGI_FORMAT_A8P8:
|
||||
// Legacy video stream formats are not supported by Direct3D.
|
||||
return false;
|
||||
|
||||
case WIN10_DXGI_FORMAT_V208:
|
||||
if ((metadata.dimension != TEX_DIMENSION_TEXTURE2D)
|
||||
|| (iHeight % 2) != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
@ -249,8 +297,6 @@ bool DirectX::IsSupportedTexture(
|
|||
|
||||
// Validate array size, dimension, and width/height
|
||||
const size_t arraySize = metadata.arraySize;
|
||||
const size_t iWidth = metadata.width;
|
||||
const size_t iHeight = metadata.height;
|
||||
const size_t iDepth = metadata.depth;
|
||||
|
||||
// Most cases are known apriori based on feature level, but we use this for robustness to handle the few optional cases
|
||||
|
@ -409,7 +455,7 @@ HRESULT DirectX::CreateTexture(
|
|||
{
|
||||
return CreateTextureEx(
|
||||
pDevice, srcImages, nimages, metadata,
|
||||
D3D11_USAGE_DEFAULT, D3D11_BIND_SHADER_RESOURCE, 0, 0, false,
|
||||
D3D11_USAGE_DEFAULT, D3D11_BIND_SHADER_RESOURCE, 0, 0, CREATETEX_DEFAULT,
|
||||
ppResource);
|
||||
}
|
||||
|
||||
|
@ -423,7 +469,7 @@ HRESULT DirectX::CreateTextureEx(
|
|||
unsigned int bindFlags,
|
||||
unsigned int cpuAccessFlags,
|
||||
unsigned int miscFlags,
|
||||
bool forceSRGB,
|
||||
CREATETEX_FLAGS flags,
|
||||
ID3D11Resource** ppResource) noexcept
|
||||
{
|
||||
if (!pDevice || !srcImages || !nimages || !ppResource)
|
||||
|
@ -541,64 +587,72 @@ HRESULT DirectX::CreateTextureEx(
|
|||
// Create texture using static initialization data
|
||||
HRESULT hr = E_UNEXPECTED;
|
||||
|
||||
const DXGI_FORMAT tformat = (forceSRGB) ? MakeSRGB(metadata.format) : metadata.format;
|
||||
DXGI_FORMAT format = metadata.format;
|
||||
if (flags & CREATETEX_FORCE_SRGB)
|
||||
{
|
||||
format = MakeSRGB(format);
|
||||
}
|
||||
else if (flags & CREATETEX_IGNORE_SRGB)
|
||||
{
|
||||
format = MakeLinear(format);
|
||||
}
|
||||
|
||||
switch (metadata.dimension)
|
||||
{
|
||||
case TEX_DIMENSION_TEXTURE1D:
|
||||
{
|
||||
D3D11_TEXTURE1D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.ArraySize = static_cast<UINT>(metadata.arraySize);
|
||||
desc.Format = tformat;
|
||||
desc.Usage = usage;
|
||||
desc.BindFlags = bindFlags;
|
||||
desc.CPUAccessFlags = cpuAccessFlags;
|
||||
desc.MiscFlags = miscFlags & ~static_cast<uint32_t>(D3D11_RESOURCE_MISC_TEXTURECUBE);
|
||||
|
||||
hr = pDevice->CreateTexture1D(&desc, initData.get(), reinterpret_cast<ID3D11Texture1D**>(ppResource));
|
||||
}
|
||||
break;
|
||||
|
||||
case TEX_DIMENSION_TEXTURE2D:
|
||||
{
|
||||
D3D11_TEXTURE2D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.Height = static_cast<UINT>(metadata.height);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.ArraySize = static_cast<UINT>(metadata.arraySize);
|
||||
desc.Format = tformat;
|
||||
desc.SampleDesc.Count = 1;
|
||||
desc.SampleDesc.Quality = 0;
|
||||
desc.Usage = usage;
|
||||
desc.BindFlags = bindFlags;
|
||||
desc.CPUAccessFlags = cpuAccessFlags;
|
||||
if (metadata.IsCubemap())
|
||||
desc.MiscFlags = miscFlags | D3D11_RESOURCE_MISC_TEXTURECUBE;
|
||||
else
|
||||
{
|
||||
D3D11_TEXTURE1D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.ArraySize = static_cast<UINT>(metadata.arraySize);
|
||||
desc.Format = format;
|
||||
desc.Usage = usage;
|
||||
desc.BindFlags = bindFlags;
|
||||
desc.CPUAccessFlags = cpuAccessFlags;
|
||||
desc.MiscFlags = miscFlags & ~static_cast<uint32_t>(D3D11_RESOURCE_MISC_TEXTURECUBE);
|
||||
|
||||
hr = pDevice->CreateTexture2D(&desc, initData.get(), reinterpret_cast<ID3D11Texture2D**>(ppResource));
|
||||
}
|
||||
break;
|
||||
hr = pDevice->CreateTexture1D(&desc, initData.get(), reinterpret_cast<ID3D11Texture1D**>(ppResource));
|
||||
}
|
||||
break;
|
||||
|
||||
case TEX_DIMENSION_TEXTURE2D:
|
||||
{
|
||||
D3D11_TEXTURE2D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.Height = static_cast<UINT>(metadata.height);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.ArraySize = static_cast<UINT>(metadata.arraySize);
|
||||
desc.Format = format;
|
||||
desc.SampleDesc.Count = 1;
|
||||
desc.SampleDesc.Quality = 0;
|
||||
desc.Usage = usage;
|
||||
desc.BindFlags = bindFlags;
|
||||
desc.CPUAccessFlags = cpuAccessFlags;
|
||||
if (metadata.IsCubemap())
|
||||
desc.MiscFlags = miscFlags | D3D11_RESOURCE_MISC_TEXTURECUBE;
|
||||
else
|
||||
desc.MiscFlags = miscFlags & ~static_cast<uint32_t>(D3D11_RESOURCE_MISC_TEXTURECUBE);
|
||||
|
||||
hr = pDevice->CreateTexture2D(&desc, initData.get(), reinterpret_cast<ID3D11Texture2D**>(ppResource));
|
||||
}
|
||||
break;
|
||||
|
||||
case TEX_DIMENSION_TEXTURE3D:
|
||||
{
|
||||
D3D11_TEXTURE3D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.Height = static_cast<UINT>(metadata.height);
|
||||
desc.Depth = static_cast<UINT>(metadata.depth);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.Format = tformat;
|
||||
desc.Usage = usage;
|
||||
desc.BindFlags = bindFlags;
|
||||
desc.CPUAccessFlags = cpuAccessFlags;
|
||||
desc.MiscFlags = miscFlags & ~static_cast<uint32_t>(D3D11_RESOURCE_MISC_TEXTURECUBE);
|
||||
{
|
||||
D3D11_TEXTURE3D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.Height = static_cast<UINT>(metadata.height);
|
||||
desc.Depth = static_cast<UINT>(metadata.depth);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.Format = format;
|
||||
desc.Usage = usage;
|
||||
desc.BindFlags = bindFlags;
|
||||
desc.CPUAccessFlags = cpuAccessFlags;
|
||||
desc.MiscFlags = miscFlags & ~static_cast<uint32_t>(D3D11_RESOURCE_MISC_TEXTURECUBE);
|
||||
|
||||
hr = pDevice->CreateTexture3D(&desc, initData.get(), reinterpret_cast<ID3D11Texture3D**>(ppResource));
|
||||
}
|
||||
break;
|
||||
hr = pDevice->CreateTexture3D(&desc, initData.get(), reinterpret_cast<ID3D11Texture3D**>(ppResource));
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return hr;
|
||||
|
@ -618,7 +672,7 @@ HRESULT DirectX::CreateShaderResourceView(
|
|||
{
|
||||
return CreateShaderResourceViewEx(
|
||||
pDevice, srcImages, nimages, metadata,
|
||||
D3D11_USAGE_DEFAULT, D3D11_BIND_SHADER_RESOURCE, 0, 0, false,
|
||||
D3D11_USAGE_DEFAULT, D3D11_BIND_SHADER_RESOURCE, 0, 0, CREATETEX_DEFAULT,
|
||||
ppSRV);
|
||||
}
|
||||
|
||||
|
@ -632,7 +686,7 @@ HRESULT DirectX::CreateShaderResourceViewEx(
|
|||
unsigned int bindFlags,
|
||||
unsigned int cpuAccessFlags,
|
||||
unsigned int miscFlags,
|
||||
bool forceSRGB,
|
||||
CREATETEX_FLAGS flags,
|
||||
ID3D11ShaderResourceView** ppSRV) noexcept
|
||||
{
|
||||
if (!ppSRV)
|
||||
|
@ -645,7 +699,7 @@ HRESULT DirectX::CreateShaderResourceViewEx(
|
|||
|
||||
ComPtr<ID3D11Resource> resource;
|
||||
HRESULT hr = CreateTextureEx(pDevice, srcImages, nimages, metadata,
|
||||
usage, bindFlags, cpuAccessFlags, miscFlags, forceSRGB,
|
||||
usage, bindFlags, cpuAccessFlags, miscFlags, flags,
|
||||
resource.GetAddressOf());
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
@ -653,10 +707,18 @@ HRESULT DirectX::CreateShaderResourceViewEx(
|
|||
assert(resource);
|
||||
|
||||
D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc = {};
|
||||
if (forceSRGB)
|
||||
if (flags & CREATETEX_FORCE_SRGB)
|
||||
{
|
||||
SRVDesc.Format = MakeSRGB(metadata.format);
|
||||
}
|
||||
else if (flags & CREATETEX_IGNORE_SRGB)
|
||||
{
|
||||
SRVDesc.Format = MakeLinear(metadata.format);
|
||||
}
|
||||
else
|
||||
{
|
||||
SRVDesc.Format = metadata.format;
|
||||
}
|
||||
|
||||
switch (metadata.dimension)
|
||||
{
|
||||
|
@ -744,215 +806,215 @@ HRESULT DirectX::CaptureTexture(
|
|||
switch (resType)
|
||||
{
|
||||
case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
|
||||
{
|
||||
ComPtr<ID3D11Texture1D> pTexture;
|
||||
hr = pSource->QueryInterface(IID_GRAPHICS_PPV_ARGS(pTexture.GetAddressOf()));
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
|
||||
assert(pTexture);
|
||||
|
||||
D3D11_TEXTURE1D_DESC desc;
|
||||
pTexture->GetDesc(&desc);
|
||||
|
||||
ComPtr<ID3D11Texture1D> pStaging;
|
||||
if ((desc.Usage == D3D11_USAGE_STAGING) && (desc.CPUAccessFlags & D3D11_CPU_ACCESS_READ))
|
||||
{
|
||||
// Handle case where the source is already a staging texture we can use directly
|
||||
pStaging = pTexture;
|
||||
}
|
||||
else
|
||||
{
|
||||
desc.BindFlags = 0;
|
||||
desc.MiscFlags = 0;
|
||||
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
|
||||
desc.Usage = D3D11_USAGE_STAGING;
|
||||
|
||||
hr = pDevice->CreateTexture1D(&desc, nullptr, pStaging.GetAddressOf());
|
||||
ComPtr<ID3D11Texture1D> pTexture;
|
||||
hr = pSource->QueryInterface(IID_GRAPHICS_PPV_ARGS(pTexture.GetAddressOf()));
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
|
||||
assert(pStaging);
|
||||
assert(pTexture);
|
||||
|
||||
pContext->CopyResource(pStaging.Get(), pSource);
|
||||
D3D11_TEXTURE1D_DESC desc;
|
||||
pTexture->GetDesc(&desc);
|
||||
|
||||
ComPtr<ID3D11Texture1D> pStaging;
|
||||
if ((desc.Usage == D3D11_USAGE_STAGING) && (desc.CPUAccessFlags & D3D11_CPU_ACCESS_READ))
|
||||
{
|
||||
// Handle case where the source is already a staging texture we can use directly
|
||||
pStaging = pTexture;
|
||||
}
|
||||
else
|
||||
{
|
||||
desc.BindFlags = 0;
|
||||
desc.MiscFlags = 0;
|
||||
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
|
||||
desc.Usage = D3D11_USAGE_STAGING;
|
||||
|
||||
hr = pDevice->CreateTexture1D(&desc, nullptr, pStaging.GetAddressOf());
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
|
||||
assert(pStaging);
|
||||
|
||||
pContext->CopyResource(pStaging.Get(), pSource);
|
||||
}
|
||||
|
||||
TexMetadata mdata;
|
||||
mdata.width = desc.Width;
|
||||
mdata.height = mdata.depth = 1;
|
||||
mdata.arraySize = desc.ArraySize;
|
||||
mdata.mipLevels = desc.MipLevels;
|
||||
mdata.miscFlags = 0;
|
||||
mdata.miscFlags2 = 0;
|
||||
mdata.format = desc.Format;
|
||||
mdata.dimension = TEX_DIMENSION_TEXTURE1D;
|
||||
|
||||
hr = result.Initialize(mdata);
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
|
||||
hr = Capture(pContext, pStaging.Get(), mdata, result);
|
||||
}
|
||||
|
||||
TexMetadata mdata;
|
||||
mdata.width = desc.Width;
|
||||
mdata.height = mdata.depth = 1;
|
||||
mdata.arraySize = desc.ArraySize;
|
||||
mdata.mipLevels = desc.MipLevels;
|
||||
mdata.miscFlags = 0;
|
||||
mdata.miscFlags2 = 0;
|
||||
mdata.format = desc.Format;
|
||||
mdata.dimension = TEX_DIMENSION_TEXTURE1D;
|
||||
|
||||
hr = result.Initialize(mdata);
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
|
||||
hr = Capture(pContext, pStaging.Get(), mdata, result);
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
|
||||
{
|
||||
ComPtr<ID3D11Texture2D> pTexture;
|
||||
hr = pSource->QueryInterface(IID_GRAPHICS_PPV_ARGS(pTexture.GetAddressOf()));
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
|
||||
assert(pTexture);
|
||||
|
||||
D3D11_TEXTURE2D_DESC desc;
|
||||
pTexture->GetDesc(&desc);
|
||||
|
||||
ComPtr<ID3D11Texture2D> pStaging;
|
||||
if (desc.SampleDesc.Count > 1)
|
||||
{
|
||||
desc.SampleDesc.Count = 1;
|
||||
desc.SampleDesc.Quality = 0;
|
||||
|
||||
ComPtr<ID3D11Texture2D> pTemp;
|
||||
hr = pDevice->CreateTexture2D(&desc, nullptr, pTemp.GetAddressOf());
|
||||
ComPtr<ID3D11Texture2D> pTexture;
|
||||
hr = pSource->QueryInterface(IID_GRAPHICS_PPV_ARGS(pTexture.GetAddressOf()));
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
|
||||
assert(pTemp);
|
||||
assert(pTexture);
|
||||
|
||||
DXGI_FORMAT fmt = desc.Format;
|
||||
if (IsTypeless(fmt))
|
||||
D3D11_TEXTURE2D_DESC desc;
|
||||
pTexture->GetDesc(&desc);
|
||||
|
||||
ComPtr<ID3D11Texture2D> pStaging;
|
||||
if (desc.SampleDesc.Count > 1)
|
||||
{
|
||||
// Assume a UNORM if it exists otherwise use FLOAT
|
||||
fmt = MakeTypelessUNORM(fmt);
|
||||
fmt = MakeTypelessFLOAT(fmt);
|
||||
}
|
||||
desc.SampleDesc.Count = 1;
|
||||
desc.SampleDesc.Quality = 0;
|
||||
|
||||
UINT support = 0;
|
||||
hr = pDevice->CheckFormatSupport(fmt, &support);
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
ComPtr<ID3D11Texture2D> pTemp;
|
||||
hr = pDevice->CreateTexture2D(&desc, nullptr, pTemp.GetAddressOf());
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
|
||||
if (!(support & D3D11_FORMAT_SUPPORT_MULTISAMPLE_RESOLVE))
|
||||
{
|
||||
hr = E_FAIL;
|
||||
break;
|
||||
}
|
||||
assert(pTemp);
|
||||
|
||||
for (UINT item = 0; item < desc.ArraySize; ++item)
|
||||
{
|
||||
for (UINT level = 0; level < desc.MipLevels; ++level)
|
||||
DXGI_FORMAT fmt = desc.Format;
|
||||
if (IsTypeless(fmt))
|
||||
{
|
||||
const UINT index = D3D11CalcSubresource(level, item, desc.MipLevels);
|
||||
pContext->ResolveSubresource(pTemp.Get(), index, pSource, index, fmt);
|
||||
// Assume a UNORM if it exists otherwise use FLOAT
|
||||
fmt = MakeTypelessUNORM(fmt);
|
||||
fmt = MakeTypelessFLOAT(fmt);
|
||||
}
|
||||
|
||||
UINT support = 0;
|
||||
hr = pDevice->CheckFormatSupport(fmt, &support);
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
|
||||
if (!(support & D3D11_FORMAT_SUPPORT_MULTISAMPLE_RESOLVE))
|
||||
{
|
||||
hr = E_FAIL;
|
||||
break;
|
||||
}
|
||||
|
||||
for (UINT item = 0; item < desc.ArraySize; ++item)
|
||||
{
|
||||
for (UINT level = 0; level < desc.MipLevels; ++level)
|
||||
{
|
||||
const UINT index = D3D11CalcSubresource(level, item, desc.MipLevels);
|
||||
pContext->ResolveSubresource(pTemp.Get(), index, pSource, index, fmt);
|
||||
}
|
||||
}
|
||||
|
||||
desc.BindFlags = 0;
|
||||
desc.MiscFlags &= D3D11_RESOURCE_MISC_TEXTURECUBE;
|
||||
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
|
||||
desc.Usage = D3D11_USAGE_STAGING;
|
||||
|
||||
hr = pDevice->CreateTexture2D(&desc, nullptr, pStaging.GetAddressOf());
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
|
||||
assert(pStaging);
|
||||
|
||||
pContext->CopyResource(pStaging.Get(), pTemp.Get());
|
||||
}
|
||||
else if ((desc.Usage == D3D11_USAGE_STAGING) && (desc.CPUAccessFlags & D3D11_CPU_ACCESS_READ))
|
||||
{
|
||||
// Handle case where the source is already a staging texture we can use directly
|
||||
pStaging = pTexture;
|
||||
}
|
||||
else
|
||||
{
|
||||
desc.BindFlags = 0;
|
||||
desc.MiscFlags &= D3D11_RESOURCE_MISC_TEXTURECUBE;
|
||||
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
|
||||
desc.Usage = D3D11_USAGE_STAGING;
|
||||
|
||||
hr = pDevice->CreateTexture2D(&desc, nullptr, &pStaging);
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
|
||||
assert(pStaging);
|
||||
|
||||
pContext->CopyResource(pStaging.Get(), pSource);
|
||||
}
|
||||
|
||||
desc.BindFlags = 0;
|
||||
desc.MiscFlags &= D3D11_RESOURCE_MISC_TEXTURECUBE;
|
||||
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
|
||||
desc.Usage = D3D11_USAGE_STAGING;
|
||||
TexMetadata mdata;
|
||||
mdata.width = desc.Width;
|
||||
mdata.height = desc.Height;
|
||||
mdata.depth = 1;
|
||||
mdata.arraySize = desc.ArraySize;
|
||||
mdata.mipLevels = desc.MipLevels;
|
||||
mdata.miscFlags = (desc.MiscFlags & D3D11_RESOURCE_MISC_TEXTURECUBE) ? TEX_MISC_TEXTURECUBE : 0u;
|
||||
mdata.miscFlags2 = 0;
|
||||
mdata.format = desc.Format;
|
||||
mdata.dimension = TEX_DIMENSION_TEXTURE2D;
|
||||
|
||||
hr = pDevice->CreateTexture2D(&desc, nullptr, pStaging.GetAddressOf());
|
||||
hr = result.Initialize(mdata);
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
|
||||
assert(pStaging);
|
||||
|
||||
pContext->CopyResource(pStaging.Get(), pTemp.Get());
|
||||
hr = Capture(pContext, pStaging.Get(), mdata, result);
|
||||
}
|
||||
else if ((desc.Usage == D3D11_USAGE_STAGING) && (desc.CPUAccessFlags & D3D11_CPU_ACCESS_READ))
|
||||
{
|
||||
// Handle case where the source is already a staging texture we can use directly
|
||||
pStaging = pTexture;
|
||||
}
|
||||
else
|
||||
{
|
||||
desc.BindFlags = 0;
|
||||
desc.MiscFlags &= D3D11_RESOURCE_MISC_TEXTURECUBE;
|
||||
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
|
||||
desc.Usage = D3D11_USAGE_STAGING;
|
||||
|
||||
hr = pDevice->CreateTexture2D(&desc, nullptr, &pStaging);
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
|
||||
assert(pStaging);
|
||||
|
||||
pContext->CopyResource(pStaging.Get(), pSource);
|
||||
}
|
||||
|
||||
TexMetadata mdata;
|
||||
mdata.width = desc.Width;
|
||||
mdata.height = desc.Height;
|
||||
mdata.depth = 1;
|
||||
mdata.arraySize = desc.ArraySize;
|
||||
mdata.mipLevels = desc.MipLevels;
|
||||
mdata.miscFlags = (desc.MiscFlags & D3D11_RESOURCE_MISC_TEXTURECUBE) ? TEX_MISC_TEXTURECUBE : 0u;
|
||||
mdata.miscFlags2 = 0;
|
||||
mdata.format = desc.Format;
|
||||
mdata.dimension = TEX_DIMENSION_TEXTURE2D;
|
||||
|
||||
hr = result.Initialize(mdata);
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
|
||||
hr = Capture(pContext, pStaging.Get(), mdata, result);
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
|
||||
{
|
||||
ComPtr<ID3D11Texture3D> pTexture;
|
||||
hr = pSource->QueryInterface(IID_GRAPHICS_PPV_ARGS(pTexture.GetAddressOf()));
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
|
||||
assert(pTexture);
|
||||
|
||||
D3D11_TEXTURE3D_DESC desc;
|
||||
pTexture->GetDesc(&desc);
|
||||
|
||||
ComPtr<ID3D11Texture3D> pStaging;
|
||||
if ((desc.Usage == D3D11_USAGE_STAGING) && (desc.CPUAccessFlags & D3D11_CPU_ACCESS_READ))
|
||||
{
|
||||
// Handle case where the source is already a staging texture we can use directly
|
||||
pStaging = pTexture;
|
||||
}
|
||||
else
|
||||
{
|
||||
desc.BindFlags = 0;
|
||||
desc.MiscFlags = 0;
|
||||
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
|
||||
desc.Usage = D3D11_USAGE_STAGING;
|
||||
|
||||
hr = pDevice->CreateTexture3D(&desc, nullptr, pStaging.GetAddressOf());
|
||||
ComPtr<ID3D11Texture3D> pTexture;
|
||||
hr = pSource->QueryInterface(IID_GRAPHICS_PPV_ARGS(pTexture.GetAddressOf()));
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
|
||||
assert(pStaging);
|
||||
assert(pTexture);
|
||||
|
||||
pContext->CopyResource(pStaging.Get(), pSource);
|
||||
D3D11_TEXTURE3D_DESC desc;
|
||||
pTexture->GetDesc(&desc);
|
||||
|
||||
ComPtr<ID3D11Texture3D> pStaging;
|
||||
if ((desc.Usage == D3D11_USAGE_STAGING) && (desc.CPUAccessFlags & D3D11_CPU_ACCESS_READ))
|
||||
{
|
||||
// Handle case where the source is already a staging texture we can use directly
|
||||
pStaging = pTexture;
|
||||
}
|
||||
else
|
||||
{
|
||||
desc.BindFlags = 0;
|
||||
desc.MiscFlags = 0;
|
||||
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
|
||||
desc.Usage = D3D11_USAGE_STAGING;
|
||||
|
||||
hr = pDevice->CreateTexture3D(&desc, nullptr, pStaging.GetAddressOf());
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
|
||||
assert(pStaging);
|
||||
|
||||
pContext->CopyResource(pStaging.Get(), pSource);
|
||||
}
|
||||
|
||||
TexMetadata mdata;
|
||||
mdata.width = desc.Width;
|
||||
mdata.height = desc.Height;
|
||||
mdata.depth = desc.Depth;
|
||||
mdata.arraySize = 1;
|
||||
mdata.mipLevels = desc.MipLevels;
|
||||
mdata.miscFlags = 0;
|
||||
mdata.miscFlags2 = 0;
|
||||
mdata.format = desc.Format;
|
||||
mdata.dimension = TEX_DIMENSION_TEXTURE3D;
|
||||
|
||||
hr = result.Initialize(mdata);
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
|
||||
hr = Capture(pContext, pStaging.Get(), mdata, result);
|
||||
}
|
||||
|
||||
TexMetadata mdata;
|
||||
mdata.width = desc.Width;
|
||||
mdata.height = desc.Height;
|
||||
mdata.depth = desc.Depth;
|
||||
mdata.arraySize = 1;
|
||||
mdata.mipLevels = desc.MipLevels;
|
||||
mdata.miscFlags = 0;
|
||||
mdata.miscFlags2 = 0;
|
||||
mdata.format = desc.Format;
|
||||
mdata.dimension = TEX_DIMENSION_TEXTURE3D;
|
||||
|
||||
hr = result.Initialize(mdata);
|
||||
if (FAILED(hr))
|
||||
break;
|
||||
|
||||
hr = Capture(pContext, pStaging.Get(), mdata, result);
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
default:
|
||||
hr = E_FAIL;
|
||||
|
|
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
|
@ -34,7 +34,7 @@
|
|||
|
||||
using namespace DirectX;
|
||||
|
||||
#ifndef WIN32
|
||||
#ifndef _WIN32
|
||||
#include <cstdarg>
|
||||
|
||||
#define strncpy_s strncpy
|
||||
|
@ -77,9 +77,9 @@ namespace
|
|||
return 0;
|
||||
}
|
||||
|
||||
#ifndef WIN32
|
||||
#ifndef _WIN32
|
||||
template<size_t sizeOfBuffer>
|
||||
inline int sprintf_s(char (&buffer)[sizeOfBuffer], const char* format, ...)
|
||||
inline int sprintf_s(char(&buffer)[sizeOfBuffer], const char* format, ...)
|
||||
{
|
||||
// This is adapter code. It is not a full implementation of sprintf_s!
|
||||
va_list ap;
|
||||
|
@ -400,7 +400,7 @@ namespace
|
|||
return 0;
|
||||
}
|
||||
|
||||
#ifdef WRITE_OLD_COLORS
|
||||
#ifdef WRITE_OLD_COLORS
|
||||
size_t encSize = 0;
|
||||
|
||||
const uint8_t* scanPtr = rgbe;
|
||||
|
@ -502,7 +502,7 @@ namespace
|
|||
}
|
||||
|
||||
return encSize;
|
||||
#else
|
||||
#else
|
||||
enc[0] = 2;
|
||||
enc[1] = 2;
|
||||
enc[2] = uint8_t(width >> 8);
|
||||
|
@ -569,7 +569,7 @@ namespace
|
|||
}
|
||||
|
||||
return encSize;
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -598,7 +598,7 @@ HRESULT DirectX::GetMetadataFromHDRFile(const wchar_t* szFile, TexMetadata& meta
|
|||
if (!szFile)
|
||||
return E_INVALIDARG;
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
|
||||
ScopedHandle hFile(safe_handle(CreateFile2(szFile, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr)));
|
||||
#else
|
||||
|
@ -652,7 +652,7 @@ HRESULT DirectX::GetMetadataFromHDRFile(const wchar_t* szFile, TexMetadata& meta
|
|||
// Read the first part of the file to find the header
|
||||
uint8_t header[8192] = {};
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
DWORD bytesRead = 0;
|
||||
if (!ReadFile(hFile.get(), header, std::min<DWORD>(sizeof(header), fileInfo.EndOfFile.LowPart), &bytesRead, nullptr))
|
||||
{
|
||||
|
@ -748,7 +748,7 @@ HRESULT DirectX::LoadFromHDRMemory(const void* pSource, size_t size, TexMetadata
|
|||
for (int channel = 0; channel < 4; ++channel)
|
||||
{
|
||||
auto pixelLoc = scanLine + channel;
|
||||
for(size_t pixelCount = 0; pixelCount < mdata.width;)
|
||||
for (size_t pixelCount = 0; pixelCount < mdata.width;)
|
||||
{
|
||||
if (pixelLen < 2)
|
||||
{
|
||||
|
@ -902,7 +902,7 @@ HRESULT DirectX::LoadFromHDRFile(const wchar_t* szFile, TexMetadata* metadata, S
|
|||
|
||||
image.Release();
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
|
||||
ScopedHandle hFile(safe_handle(CreateFile2(szFile, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr)));
|
||||
#else
|
||||
|
@ -960,7 +960,7 @@ HRESULT DirectX::LoadFromHDRFile(const wchar_t* szFile, TexMetadata* metadata, S
|
|||
return E_OUTOFMEMORY;
|
||||
}
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
DWORD bytesRead = 0;
|
||||
if (!ReadFile(hFile.get(), temp.get(), fileInfo.EndOfFile.LowPart, &bytesRead, nullptr))
|
||||
{
|
||||
|
@ -1125,7 +1125,7 @@ HRESULT DirectX::SaveToHDRFile(const Image& image, const wchar_t* szFile) noexce
|
|||
}
|
||||
|
||||
// Create file and write header
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
|
||||
ScopedHandle hFile(safe_handle(CreateFile2(szFile,
|
||||
GENERIC_WRITE, 0, CREATE_ALWAYS, nullptr)));
|
||||
|
@ -1163,7 +1163,7 @@ HRESULT DirectX::SaveToHDRFile(const Image& image, const wchar_t* szFile) noexce
|
|||
return hr;
|
||||
|
||||
// Write blob
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
auto const bytesToWrite = static_cast<const DWORD>(blob.GetBufferSize());
|
||||
DWORD bytesWritten;
|
||||
if (!WriteFile(hFile.get(), blob.GetBufferPointer(), bytesToWrite, &bytesWritten, nullptr))
|
||||
|
@ -1175,13 +1175,13 @@ HRESULT DirectX::SaveToHDRFile(const Image& image, const wchar_t* szFile) noexce
|
|||
{
|
||||
return E_FAIL;
|
||||
}
|
||||
#else
|
||||
#else
|
||||
outFile.write(reinterpret_cast<char*>(blob.GetBufferPointer()),
|
||||
static_cast<std::streamsize>(blob.GetBufferSize()));
|
||||
|
||||
if (!outFile)
|
||||
return E_FAIL;
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -1196,7 +1196,7 @@ HRESULT DirectX::SaveToHDRFile(const Image& image, const wchar_t* szFile) noexce
|
|||
char header[256] = {};
|
||||
sprintf_s(header, g_Header, image.height, image.width);
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
auto const headerLen = static_cast<DWORD>(strlen(header));
|
||||
|
||||
DWORD bytesWritten;
|
||||
|
@ -1207,21 +1207,21 @@ HRESULT DirectX::SaveToHDRFile(const Image& image, const wchar_t* szFile) noexce
|
|||
|
||||
if (bytesWritten != headerLen)
|
||||
return E_FAIL;
|
||||
#else
|
||||
#else
|
||||
outFile.write(reinterpret_cast<char*>(header), static_cast<std::streamsize>(strlen(header)));
|
||||
if (!outFile)
|
||||
return E_FAIL;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef DISABLE_COMPRESS
|
||||
// Uncompressed write
|
||||
#ifdef DISABLE_COMPRESS
|
||||
// Uncompressed write
|
||||
auto sPtr = reinterpret_cast<const uint8_t*>(image.pixels);
|
||||
for (size_t scan = 0; scan < image.height; ++scan)
|
||||
{
|
||||
FloatToRGBE(rgbe, reinterpret_cast<const float*>(sPtr), image.width, fpp);
|
||||
sPtr += image.rowPitch;
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
if (!WriteFile(hFile.get(), rgbe, static_cast<DWORD>(rowPitch), &bytesWritten, nullptr))
|
||||
{
|
||||
return HRESULT_FROM_WIN32(GetLastError());
|
||||
|
@ -1229,20 +1229,20 @@ HRESULT DirectX::SaveToHDRFile(const Image& image, const wchar_t* szFile) noexce
|
|||
|
||||
if (bytesWritten != rowPitch)
|
||||
return E_FAIL;
|
||||
#else
|
||||
#else
|
||||
outFile.write(reinterpret_cast<char*>(rgbe), static_cast<std::streamsize>(rowPitch));
|
||||
if (!outFile)
|
||||
return E_FAIL;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
}
|
||||
#else
|
||||
#else
|
||||
auto enc = temp.get() + rowPitch;
|
||||
|
||||
const uint8_t* sPtr = image.pixels;
|
||||
for (size_t scan = 0; scan < image.height; ++scan)
|
||||
{
|
||||
if (image.format == DXGI_FORMAT_R32G32B32A32_FLOAT || image.format == DXGI_FORMAT_R32G32B32_FLOAT)
|
||||
if (image.format == DXGI_FORMAT_R32G32B32A32_FLOAT || image.format == DXGI_FORMAT_R32G32B32_FLOAT)
|
||||
{
|
||||
FloatToRGBE(rgbe, reinterpret_cast<const float*>(sPtr), image.width, fpp);
|
||||
}
|
||||
|
@ -1258,7 +1258,7 @@ HRESULT DirectX::SaveToHDRFile(const Image& image, const wchar_t* szFile) noexce
|
|||
if (encSize > UINT32_MAX)
|
||||
return HRESULT_E_ARITHMETIC_OVERFLOW;
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
if (!WriteFile(hFile.get(), enc, static_cast<DWORD>(encSize), &bytesWritten, nullptr))
|
||||
{
|
||||
return HRESULT_FROM_WIN32(GetLastError());
|
||||
|
@ -1266,15 +1266,15 @@ HRESULT DirectX::SaveToHDRFile(const Image& image, const wchar_t* szFile) noexce
|
|||
|
||||
if (bytesWritten != encSize)
|
||||
return E_FAIL;
|
||||
#else
|
||||
#else
|
||||
outFile.write(reinterpret_cast<char*>(enc), static_cast<std::streamsize>(encSize));
|
||||
if (!outFile)
|
||||
return E_FAIL;
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
if (!WriteFile(hFile.get(), rgbe, static_cast<DWORD>(rowPitch), &bytesWritten, nullptr))
|
||||
{
|
||||
return HRESULT_FROM_WIN32(GetLastError());
|
||||
|
@ -1282,17 +1282,17 @@ HRESULT DirectX::SaveToHDRFile(const Image& image, const wchar_t* szFile) noexce
|
|||
|
||||
if (bytesWritten != rowPitch)
|
||||
return E_FAIL;
|
||||
#else
|
||||
#else
|
||||
outFile.write(reinterpret_cast<char*>(rgbe), static_cast<std::streamsize>(rowPitch));
|
||||
if (!outFile)
|
||||
return E_FAIL;
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
delonfail.clear();
|
||||
#endif
|
||||
|
||||
|
|
|
@ -14,7 +14,7 @@
|
|||
using namespace DirectX;
|
||||
using namespace DirectX::Internal;
|
||||
|
||||
#ifndef WIN32
|
||||
#ifndef _WIN32
|
||||
namespace
|
||||
{
|
||||
inline void * _aligned_malloc(size_t size, size_t alignment)
|
||||
|
@ -23,7 +23,7 @@ namespace
|
|||
return std::aligned_alloc(alignment, size);
|
||||
}
|
||||
|
||||
#define _aligned_free free
|
||||
#define _aligned_free free
|
||||
}
|
||||
#endif
|
||||
|
||||
|
@ -31,7 +31,7 @@ namespace
|
|||
// Determines number of image array entries and pixel size
|
||||
//-------------------------------------------------------------------------------------
|
||||
_Use_decl_annotations_
|
||||
bool DirectX::Internal::DetermineImageArray(
|
||||
HRESULT DirectX::Internal::DetermineImageArray(
|
||||
const TexMetadata& metadata,
|
||||
CP_FLAGS cpFlags,
|
||||
size_t& nImages,
|
||||
|
@ -56,10 +56,11 @@ bool DirectX::Internal::DetermineImageArray(
|
|||
for (size_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
size_t rowPitch, slicePitch;
|
||||
if (FAILED(ComputePitch(metadata.format, w, h, rowPitch, slicePitch, cpFlags)))
|
||||
HRESULT hr = ComputePitch(metadata.format, w, h, rowPitch, slicePitch, cpFlags);
|
||||
if (FAILED(hr))
|
||||
{
|
||||
nImages = pixelSize = 0;
|
||||
return false;
|
||||
return hr;
|
||||
}
|
||||
|
||||
totalPixelSize += uint64_t(slicePitch);
|
||||
|
@ -75,41 +76,42 @@ bool DirectX::Internal::DetermineImageArray(
|
|||
break;
|
||||
|
||||
case TEX_DIMENSION_TEXTURE3D:
|
||||
{
|
||||
size_t w = metadata.width;
|
||||
size_t h = metadata.height;
|
||||
size_t d = metadata.depth;
|
||||
|
||||
for (size_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
size_t rowPitch, slicePitch;
|
||||
if (FAILED(ComputePitch(metadata.format, w, h, rowPitch, slicePitch, cpFlags)))
|
||||
size_t w = metadata.width;
|
||||
size_t h = metadata.height;
|
||||
size_t d = metadata.depth;
|
||||
|
||||
for (size_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
nImages = pixelSize = 0;
|
||||
return false;
|
||||
size_t rowPitch, slicePitch;
|
||||
HRESULT hr = ComputePitch(metadata.format, w, h, rowPitch, slicePitch, cpFlags);
|
||||
if (FAILED(hr))
|
||||
{
|
||||
nImages = pixelSize = 0;
|
||||
return hr;
|
||||
}
|
||||
|
||||
for (size_t slice = 0; slice < d; ++slice)
|
||||
{
|
||||
totalPixelSize += uint64_t(slicePitch);
|
||||
++nimages;
|
||||
}
|
||||
|
||||
if (h > 1)
|
||||
h >>= 1;
|
||||
|
||||
if (w > 1)
|
||||
w >>= 1;
|
||||
|
||||
if (d > 1)
|
||||
d >>= 1;
|
||||
}
|
||||
|
||||
for (size_t slice = 0; slice < d; ++slice)
|
||||
{
|
||||
totalPixelSize += uint64_t(slicePitch);
|
||||
++nimages;
|
||||
}
|
||||
|
||||
if (h > 1)
|
||||
h >>= 1;
|
||||
|
||||
if (w > 1)
|
||||
w >>= 1;
|
||||
|
||||
if (d > 1)
|
||||
d >>= 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
default:
|
||||
nImages = pixelSize = 0;
|
||||
return false;
|
||||
return E_INVALIDARG;
|
||||
}
|
||||
|
||||
#if defined(_M_IX86) || defined(_M_ARM) || defined(_M_HYBRID_X86_ARM64)
|
||||
|
@ -117,7 +119,7 @@ bool DirectX::Internal::DetermineImageArray(
|
|||
if (totalPixelSize > UINT32_MAX)
|
||||
{
|
||||
nImages = pixelSize = 0;
|
||||
return false;
|
||||
return HRESULT_E_ARITHMETIC_OVERFLOW;
|
||||
}
|
||||
#else
|
||||
static_assert(sizeof(size_t) == 8, "Not a 64-bit platform!");
|
||||
|
@ -126,7 +128,7 @@ bool DirectX::Internal::DetermineImageArray(
|
|||
nImages = nimages;
|
||||
pixelSize = static_cast<size_t>(totalPixelSize);
|
||||
|
||||
return true;
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
|
||||
|
@ -202,57 +204,57 @@ bool DirectX::Internal::SetupImageArray(
|
|||
return true;
|
||||
|
||||
case TEX_DIMENSION_TEXTURE3D:
|
||||
{
|
||||
if (metadata.mipLevels == 0 || metadata.depth == 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
size_t w = metadata.width;
|
||||
size_t h = metadata.height;
|
||||
size_t d = metadata.depth;
|
||||
|
||||
for (size_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
size_t rowPitch, slicePitch;
|
||||
if (FAILED(ComputePitch(metadata.format, w, h, rowPitch, slicePitch, cpFlags)))
|
||||
return false;
|
||||
|
||||
for (size_t slice = 0; slice < d; ++slice)
|
||||
if (metadata.mipLevels == 0 || metadata.depth == 0)
|
||||
{
|
||||
if (index >= nImages)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// We use the same memory organization that Direct3D 11 needs for D3D11_SUBRESOURCE_DATA
|
||||
// with all slices of a given miplevel being continuous in memory
|
||||
images[index].width = w;
|
||||
images[index].height = h;
|
||||
images[index].format = metadata.format;
|
||||
images[index].rowPitch = rowPitch;
|
||||
images[index].slicePitch = slicePitch;
|
||||
images[index].pixels = pixels;
|
||||
++index;
|
||||
|
||||
pixels += slicePitch;
|
||||
if (pixels > pEndBits)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
if (h > 1)
|
||||
h >>= 1;
|
||||
size_t w = metadata.width;
|
||||
size_t h = metadata.height;
|
||||
size_t d = metadata.depth;
|
||||
|
||||
if (w > 1)
|
||||
w >>= 1;
|
||||
for (size_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
size_t rowPitch, slicePitch;
|
||||
if (FAILED(ComputePitch(metadata.format, w, h, rowPitch, slicePitch, cpFlags)))
|
||||
return false;
|
||||
|
||||
if (d > 1)
|
||||
d >>= 1;
|
||||
for (size_t slice = 0; slice < d; ++slice)
|
||||
{
|
||||
if (index >= nImages)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// We use the same memory organization that Direct3D 11 needs for D3D11_SUBRESOURCE_DATA
|
||||
// with all slices of a given miplevel being continuous in memory
|
||||
images[index].width = w;
|
||||
images[index].height = h;
|
||||
images[index].format = metadata.format;
|
||||
images[index].rowPitch = rowPitch;
|
||||
images[index].slicePitch = slicePitch;
|
||||
images[index].pixels = pixels;
|
||||
++index;
|
||||
|
||||
pixels += slicePitch;
|
||||
if (pixels > pEndBits)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (h > 1)
|
||||
h >>= 1;
|
||||
|
||||
if (w > 1)
|
||||
w >>= 1;
|
||||
|
||||
if (d > 1)
|
||||
d >>= 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
return true;
|
||||
|
||||
default:
|
||||
return false;
|
||||
|
@ -348,8 +350,9 @@ HRESULT ScratchImage::Initialize(const TexMetadata& mdata, CP_FLAGS flags) noexc
|
|||
m_metadata.dimension = mdata.dimension;
|
||||
|
||||
size_t pixelSize, nimages;
|
||||
if (!DetermineImageArray(m_metadata, flags, nimages, pixelSize))
|
||||
return HRESULT_E_ARITHMETIC_OVERFLOW;
|
||||
HRESULT hr = DetermineImageArray(m_metadata, flags, nimages, pixelSize);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
m_image = new (std::nothrow) Image[nimages];
|
||||
if (!m_image)
|
||||
|
@ -364,7 +367,9 @@ HRESULT ScratchImage::Initialize(const TexMetadata& mdata, CP_FLAGS flags) noexc
|
|||
Release();
|
||||
return E_OUTOFMEMORY;
|
||||
}
|
||||
memset(m_memory, 0, pixelSize);
|
||||
m_size = pixelSize;
|
||||
|
||||
if (!SetupImageArray(m_memory, pixelSize, m_metadata, flags, m_image, nimages))
|
||||
{
|
||||
Release();
|
||||
|
@ -415,8 +420,9 @@ HRESULT ScratchImage::Initialize2D(DXGI_FORMAT fmt, size_t width, size_t height,
|
|||
m_metadata.dimension = TEX_DIMENSION_TEXTURE2D;
|
||||
|
||||
size_t pixelSize, nimages;
|
||||
if (!DetermineImageArray(m_metadata, flags, nimages, pixelSize))
|
||||
return HRESULT_E_ARITHMETIC_OVERFLOW;
|
||||
HRESULT hr = DetermineImageArray(m_metadata, flags, nimages, pixelSize);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
m_image = new (std::nothrow) Image[nimages];
|
||||
if (!m_image)
|
||||
|
@ -431,7 +437,9 @@ HRESULT ScratchImage::Initialize2D(DXGI_FORMAT fmt, size_t width, size_t height,
|
|||
Release();
|
||||
return E_OUTOFMEMORY;
|
||||
}
|
||||
memset(m_memory, 0, pixelSize);
|
||||
m_size = pixelSize;
|
||||
|
||||
if (!SetupImageArray(m_memory, pixelSize, m_metadata, flags, m_image, nimages))
|
||||
{
|
||||
Release();
|
||||
|
@ -466,8 +474,9 @@ HRESULT ScratchImage::Initialize3D(DXGI_FORMAT fmt, size_t width, size_t height,
|
|||
m_metadata.dimension = TEX_DIMENSION_TEXTURE3D;
|
||||
|
||||
size_t pixelSize, nimages;
|
||||
if (!DetermineImageArray(m_metadata, flags, nimages, pixelSize))
|
||||
return HRESULT_E_ARITHMETIC_OVERFLOW;
|
||||
HRESULT hr = DetermineImageArray(m_metadata, flags, nimages, pixelSize);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
m_image = new (std::nothrow) Image[nimages];
|
||||
if (!m_image)
|
||||
|
@ -484,6 +493,7 @@ HRESULT ScratchImage::Initialize3D(DXGI_FORMAT fmt, size_t width, size_t height,
|
|||
Release();
|
||||
return E_OUTOFMEMORY;
|
||||
}
|
||||
memset(m_memory, 0, pixelSize);
|
||||
m_size = pixelSize;
|
||||
|
||||
if (!SetupImageArray(m_memory, pixelSize, m_metadata, flags, m_image, nimages))
|
||||
|
@ -801,7 +811,7 @@ bool ScratchImage::IsAlphaAllOpaque() const noexcept
|
|||
|
||||
for (size_t index = 0; index < m_nimages; ++index)
|
||||
{
|
||||
#pragma warning( suppress : 6011 )
|
||||
#pragma warning( suppress : 6011 )
|
||||
const Image& img = m_image[index];
|
||||
|
||||
const uint8_t *pPixels = img.pixels;
|
||||
|
|
|
@ -65,7 +65,7 @@ namespace
|
|||
return mipLevels;
|
||||
}
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
HRESULT EnsureWicBitmapPixelFormat(
|
||||
_In_ IWICImagingFactory* pWIC,
|
||||
_In_ IWICBitmap* src,
|
||||
|
@ -264,13 +264,13 @@ namespace
|
|||
XMVECTOR r1 = XMVectorSplatW(*pRow1);
|
||||
|
||||
XMVECTOR v1 = XMVectorSaturate(XMVectorMultiply(r0, scale));
|
||||
XMVECTOR v2 = XMVectorSaturate(XMVectorMultiply(r1, scale));
|
||||
const XMVECTOR v2 = XMVectorSaturate(XMVectorMultiply(r1, scale));
|
||||
|
||||
r0 = XMVectorSplatW(*(++pRow0));
|
||||
r1 = XMVectorSplatW(*(++pRow1));
|
||||
|
||||
XMVECTOR v3 = XMVectorSaturate(XMVectorMultiply(XMVectorSplatW(r0), scale));
|
||||
XMVECTOR v4 = XMVectorSaturate(XMVectorMultiply(XMVectorSplatW(r1), scale));
|
||||
const XMVECTOR v4 = XMVectorSaturate(XMVectorMultiply(XMVectorSplatW(r1), scale));
|
||||
|
||||
v1 = XMVectorMergeXY(v1, v2); // [v1.x v2.x --- ---]
|
||||
v3 = XMVectorMergeXY(v3, v4); // [v3.x v4.x --- ---]
|
||||
|
@ -305,10 +305,10 @@ namespace
|
|||
|
||||
|
||||
HRESULT EstimateAlphaScaleForCoverage(
|
||||
const Image& srcImage,
|
||||
float alphaReference,
|
||||
float targetCoverage,
|
||||
float& alphaScale) noexcept
|
||||
const Image& srcImage,
|
||||
float alphaReference,
|
||||
float targetCoverage,
|
||||
float& alphaScale) noexcept
|
||||
{
|
||||
float minAlphaScale = 0.0f;
|
||||
float maxAlphaScale = 4.0f;
|
||||
|
@ -399,7 +399,7 @@ bool DirectX::Internal::CalculateMipLevels3D(
|
|||
return true;
|
||||
}
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
//--- Resizing color and alpha channels separately using WIC ---
|
||||
_Use_decl_annotations_
|
||||
HRESULT DirectX::Internal::ResizeSeparateColorAndAlpha(
|
||||
|
@ -454,16 +454,16 @@ HRESULT DirectX::Internal::ResizeSeparateColorAndAlpha(
|
|||
}
|
||||
else
|
||||
{
|
||||
#if(_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
|
||||
#if(_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
|
||||
if (iswic2)
|
||||
{
|
||||
colorBytesInPixel = colorBytesPerPixel = 12;
|
||||
colorPixelFormat = GUID_WICPixelFormat96bppRGBFloat;
|
||||
}
|
||||
else
|
||||
#else
|
||||
#else
|
||||
UNREFERENCED_PARAMETER(iswic2);
|
||||
#endif
|
||||
#endif
|
||||
{
|
||||
colorBytesInPixel = 12;
|
||||
colorBytesPerPixel = 16;
|
||||
|
@ -543,7 +543,7 @@ HRESULT DirectX::Internal::ResizeSeparateColorAndAlpha(
|
|||
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
WICInProcPointer colorWithAlphaData = nullptr;
|
||||
BYTE* colorWithAlphaData = nullptr;
|
||||
UINT colorWithAlphaSizeInBytes = 0;
|
||||
UINT colorWithAlphaStride = 0;
|
||||
|
||||
|
@ -560,7 +560,7 @@ HRESULT DirectX::Internal::ResizeSeparateColorAndAlpha(
|
|||
}
|
||||
}
|
||||
|
||||
WICInProcPointer colorData = nullptr;
|
||||
BYTE* colorData = nullptr;
|
||||
UINT colorSizeInBytes = 0;
|
||||
UINT colorStride = 0;
|
||||
if (SUCCEEDED(hr))
|
||||
|
@ -593,7 +593,7 @@ HRESULT DirectX::Internal::ResizeSeparateColorAndAlpha(
|
|||
}
|
||||
else
|
||||
{
|
||||
#pragma warning( suppress : 26014 6386 ) // No overflow possible here
|
||||
#pragma warning( suppress : 26014 6386 ) // No overflow possible here
|
||||
memcpy_s(colorWithAlphaData + colorWithAlphaIndex, colorWithAlphaBytesPerPixel, colorData + colorIndex, colorBytesInPixel);
|
||||
}
|
||||
}
|
||||
|
@ -620,7 +620,7 @@ HRESULT DirectX::Internal::ResizeSeparateColorAndAlpha(
|
|||
|
||||
namespace
|
||||
{
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
//--- determine when to use WIC vs. non-WIC paths ---
|
||||
bool UseWICFiltering(_In_ DXGI_FORMAT format, _In_ TEX_FILTER_FLAGS filter) noexcept
|
||||
{
|
||||
|
@ -642,14 +642,14 @@ namespace
|
|||
return false;
|
||||
}
|
||||
|
||||
#if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
|
||||
#if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
|
||||
if (format == DXGI_FORMAT_R16G16B16A16_FLOAT
|
||||
|| format == DXGI_FORMAT_R16_FLOAT)
|
||||
{
|
||||
// Use non-WIC code paths as these conversions are not supported by Xbox version of WIC
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
static_assert(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MODE_MASK");
|
||||
|
||||
|
@ -686,6 +686,14 @@ namespace
|
|||
case TEX_FILTER_TRIANGLE:
|
||||
// WIC does not implement this filter
|
||||
return false;
|
||||
|
||||
default:
|
||||
if (BitsPerColor(format) > 8)
|
||||
{
|
||||
// Avoid the WIC bitmap scaler when doing filtering of XR/HDR formats
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return true;
|
||||
|
@ -921,9 +929,9 @@ namespace
|
|||
// Resize base image to each target mip level
|
||||
for (size_t level = 1; level < levels; ++level)
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
memset(row, 0xCD, sizeof(XMVECTOR)*width);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// 2D point filter
|
||||
const Image* src = mipChain.GetImage(level - 1, item, 0);
|
||||
|
@ -1129,10 +1137,10 @@ namespace
|
|||
const size_t nheight = (height > 1) ? (height >> 1) : 1;
|
||||
CreateLinearFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, lfY);
|
||||
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
memset(row0, 0xCD, sizeof(XMVECTOR)*width);
|
||||
memset(row1, 0xDD, sizeof(XMVECTOR)*width);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
size_t u0 = size_t(-1);
|
||||
size_t u1 = size_t(-1);
|
||||
|
@ -1190,6 +1198,10 @@ namespace
|
|||
}
|
||||
|
||||
//--- 2D Cubic Filter ---
|
||||
#ifdef __clang__
|
||||
#pragma clang diagnostic ignored "-Wextra-semi-stmt"
|
||||
#endif
|
||||
|
||||
HRESULT Generate2DMipsCubicFilter(size_t levels, TEX_FILTER_FLAGS filter, const ScratchImage& mipChain, size_t item) noexcept
|
||||
{
|
||||
using namespace DirectX::Filters;
|
||||
|
@ -1244,12 +1256,12 @@ namespace
|
|||
const size_t nheight = (height > 1) ? (height >> 1) : 1;
|
||||
CreateCubicFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, (filter & TEX_FILTER_MIRROR_V) != 0, cfY);
|
||||
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
memset(row0, 0xCD, sizeof(XMVECTOR)*width);
|
||||
memset(row1, 0xDD, sizeof(XMVECTOR)*width);
|
||||
memset(row2, 0xED, sizeof(XMVECTOR)*width);
|
||||
memset(row3, 0xFD, sizeof(XMVECTOR)*width);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
size_t u0 = size_t(-1);
|
||||
size_t u1 = size_t(-1);
|
||||
|
@ -1353,12 +1365,12 @@ namespace
|
|||
|
||||
XMVECTOR C0, C1, C2, C3;
|
||||
|
||||
CUBIC_INTERPOLATE(C0, toX.x, row0[toX.u0], row0[toX.u1], row0[toX.u2], row0[toX.u3])
|
||||
CUBIC_INTERPOLATE(C1, toX.x, row1[toX.u0], row1[toX.u1], row1[toX.u2], row1[toX.u3])
|
||||
CUBIC_INTERPOLATE(C2, toX.x, row2[toX.u0], row2[toX.u1], row2[toX.u2], row2[toX.u3])
|
||||
CUBIC_INTERPOLATE(C3, toX.x, row3[toX.u0], row3[toX.u1], row3[toX.u2], row3[toX.u3])
|
||||
CUBIC_INTERPOLATE(C0, toX.x, row0[toX.u0], row0[toX.u1], row0[toX.u2], row0[toX.u3]);
|
||||
CUBIC_INTERPOLATE(C1, toX.x, row1[toX.u0], row1[toX.u1], row1[toX.u2], row1[toX.u3]);
|
||||
CUBIC_INTERPOLATE(C2, toX.x, row2[toX.u0], row2[toX.u1], row2[toX.u2], row2[toX.u3]);
|
||||
CUBIC_INTERPOLATE(C3, toX.x, row3[toX.u0], row3[toX.u1], row3[toX.u2], row3[toX.u3]);
|
||||
|
||||
CUBIC_INTERPOLATE(target[x], toY.x, C0, C1, C2, C3)
|
||||
CUBIC_INTERPOLATE(target[x], toY.x, C0, C1, C2, C3);
|
||||
}
|
||||
|
||||
if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
|
||||
|
@ -1433,9 +1445,9 @@ namespace
|
|||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
memset(row, 0xCD, sizeof(XMVECTOR)*width);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
auto xFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfX.get()) + tfX->sizeInBytes);
|
||||
auto yFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfY.get()) + tfY->sizeInBytes);
|
||||
|
@ -1550,18 +1562,18 @@ namespace
|
|||
{
|
||||
case DXGI_FORMAT_R10G10B10A2_UNORM:
|
||||
case DXGI_FORMAT_R10G10B10A2_UINT:
|
||||
{
|
||||
// Need to slightly bias results for floating-point error accumulation which can
|
||||
// be visible with harshly quantized values
|
||||
static const XMVECTORF32 Bias = { { { 0.f, 0.f, 0.f, 0.1f } } };
|
||||
|
||||
XMVECTOR* ptr = pAccSrc;
|
||||
for (size_t i = 0; i < dest->width; ++i, ++ptr)
|
||||
{
|
||||
*ptr = XMVectorAdd(*ptr, Bias);
|
||||
// Need to slightly bias results for floating-point error accumulation which can
|
||||
// be visible with harshly quantized values
|
||||
static const XMVECTORF32 Bias = { { { 0.f, 0.f, 0.f, 0.1f } } };
|
||||
|
||||
XMVECTOR* ptr = pAccSrc;
|
||||
for (size_t i = 0; i < dest->width; ++i, ++ptr)
|
||||
{
|
||||
*ptr = XMVectorAdd(*ptr, Bias);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
|
@ -1673,9 +1685,9 @@ namespace
|
|||
// Resize base image to each target mip level
|
||||
for (size_t level = 1; level < levels; ++level)
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
memset(row, 0xCD, sizeof(XMVECTOR)*width);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if (depth > 1)
|
||||
{
|
||||
|
@ -2012,12 +2024,12 @@ namespace
|
|||
const size_t nheight = (height > 1) ? (height >> 1) : 1;
|
||||
CreateLinearFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, lfY);
|
||||
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
memset(urow0, 0xCD, sizeof(XMVECTOR)*width);
|
||||
memset(urow1, 0xDD, sizeof(XMVECTOR)*width);
|
||||
memset(vrow0, 0xED, sizeof(XMVECTOR)*width);
|
||||
memset(vrow1, 0xFD, sizeof(XMVECTOR)*width);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if (depth > 1)
|
||||
{
|
||||
|
@ -2216,7 +2228,7 @@ namespace
|
|||
const size_t nheight = (height > 1) ? (height >> 1) : 1;
|
||||
CreateCubicFilter(height, nheight, (filter & TEX_FILTER_WRAP_V) != 0, (filter & TEX_FILTER_MIRROR_V) != 0, cfY);
|
||||
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
for (size_t j = 0; j < 4; ++j)
|
||||
{
|
||||
memset(urow[j], 0xCD, sizeof(XMVECTOR)*width);
|
||||
|
@ -2224,7 +2236,7 @@ namespace
|
|||
memset(srow[j], 0xED, sizeof(XMVECTOR)*width);
|
||||
memset(trow[j], 0xFD, sizeof(XMVECTOR)*width);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if (depth > 1)
|
||||
{
|
||||
|
@ -2384,15 +2396,15 @@ namespace
|
|||
for (size_t j = 0; j < 4; ++j)
|
||||
{
|
||||
XMVECTOR C0, C1, C2, C3;
|
||||
CUBIC_INTERPOLATE(C0, toX.x, urow[j][toX.u0], urow[j][toX.u1], urow[j][toX.u2], urow[j][toX.u3])
|
||||
CUBIC_INTERPOLATE(C1, toX.x, vrow[j][toX.u0], vrow[j][toX.u1], vrow[j][toX.u2], vrow[j][toX.u3])
|
||||
CUBIC_INTERPOLATE(C2, toX.x, srow[j][toX.u0], srow[j][toX.u1], srow[j][toX.u2], srow[j][toX.u3])
|
||||
CUBIC_INTERPOLATE(C3, toX.x, trow[j][toX.u0], trow[j][toX.u1], trow[j][toX.u2], trow[j][toX.u3])
|
||||
CUBIC_INTERPOLATE(C0, toX.x, urow[j][toX.u0], urow[j][toX.u1], urow[j][toX.u2], urow[j][toX.u3]);
|
||||
CUBIC_INTERPOLATE(C1, toX.x, vrow[j][toX.u0], vrow[j][toX.u1], vrow[j][toX.u2], vrow[j][toX.u3]);
|
||||
CUBIC_INTERPOLATE(C2, toX.x, srow[j][toX.u0], srow[j][toX.u1], srow[j][toX.u2], srow[j][toX.u3]);
|
||||
CUBIC_INTERPOLATE(C3, toX.x, trow[j][toX.u0], trow[j][toX.u1], trow[j][toX.u2], trow[j][toX.u3]);
|
||||
|
||||
CUBIC_INTERPOLATE(D[j], toY.x, C0, C1, C2, C3)
|
||||
CUBIC_INTERPOLATE(D[j], toY.x, C0, C1, C2, C3);
|
||||
}
|
||||
|
||||
CUBIC_INTERPOLATE(target[x], toZ.x, D[0], D[1], D[2], D[3])
|
||||
CUBIC_INTERPOLATE(target[x], toZ.x, D[0], D[1], D[2], D[3]);
|
||||
}
|
||||
|
||||
if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
|
||||
|
@ -2516,12 +2528,12 @@ namespace
|
|||
auto const& toX = cfX[x];
|
||||
|
||||
XMVECTOR C0, C1, C2, C3;
|
||||
CUBIC_INTERPOLATE(C0, toX.x, urow[0][toX.u0], urow[0][toX.u1], urow[0][toX.u2], urow[0][toX.u3])
|
||||
CUBIC_INTERPOLATE(C1, toX.x, vrow[0][toX.u0], vrow[0][toX.u1], vrow[0][toX.u2], vrow[0][toX.u3])
|
||||
CUBIC_INTERPOLATE(C2, toX.x, srow[0][toX.u0], srow[0][toX.u1], srow[0][toX.u2], srow[0][toX.u3])
|
||||
CUBIC_INTERPOLATE(C3, toX.x, trow[0][toX.u0], trow[0][toX.u1], trow[0][toX.u2], trow[0][toX.u3])
|
||||
CUBIC_INTERPOLATE(C0, toX.x, urow[0][toX.u0], urow[0][toX.u1], urow[0][toX.u2], urow[0][toX.u3]);
|
||||
CUBIC_INTERPOLATE(C1, toX.x, vrow[0][toX.u0], vrow[0][toX.u1], vrow[0][toX.u2], vrow[0][toX.u3]);
|
||||
CUBIC_INTERPOLATE(C2, toX.x, srow[0][toX.u0], srow[0][toX.u1], srow[0][toX.u2], srow[0][toX.u3]);
|
||||
CUBIC_INTERPOLATE(C3, toX.x, trow[0][toX.u0], trow[0][toX.u1], trow[0][toX.u2], trow[0][toX.u3]);
|
||||
|
||||
CUBIC_INTERPOLATE(target[x], toY.x, C0, C1, C2, C3)
|
||||
CUBIC_INTERPOLATE(target[x], toY.x, C0, C1, C2, C3);
|
||||
}
|
||||
|
||||
if (!StoreScanlineLinear(pDest, dest->rowPitch, dest->format, target, nwidth, filter))
|
||||
|
@ -2592,9 +2604,9 @@ namespace
|
|||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
memset(row, 0xCD, sizeof(XMVECTOR)*width);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
auto xFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfX.get()) + tfX->sizeInBytes);
|
||||
auto yFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfY.get()) + tfY->sizeInBytes);
|
||||
|
@ -2739,18 +2751,18 @@ namespace
|
|||
{
|
||||
case DXGI_FORMAT_R10G10B10A2_UNORM:
|
||||
case DXGI_FORMAT_R10G10B10A2_UINT:
|
||||
{
|
||||
// Need to slightly bias results for floating-point error accumulation which can
|
||||
// be visible with harshly quantized values
|
||||
static const XMVECTORF32 Bias = { { { 0.f, 0.f, 0.f, 0.1f } } };
|
||||
|
||||
XMVECTOR* ptr = pAccSrc;
|
||||
for (size_t i = 0; i < dest->width; ++i, ++ptr)
|
||||
{
|
||||
*ptr = XMVectorAdd(*ptr, Bias);
|
||||
// Need to slightly bias results for floating-point error accumulation which can
|
||||
// be visible with harshly quantized values
|
||||
static const XMVECTORF32 Bias = { { { 0.f, 0.f, 0.f, 0.1f } } };
|
||||
|
||||
XMVECTOR* ptr = pAccSrc;
|
||||
for (size_t i = 0; i < dest->width; ++i, ++ptr)
|
||||
{
|
||||
*ptr = XMVectorAdd(*ptr, Bias);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
|
@ -2824,7 +2836,7 @@ HRESULT DirectX::GenerateMipMaps(
|
|||
|
||||
static_assert(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MODE_MASK");
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
bool usewic = UseWICFiltering(baseImage.format, filter);
|
||||
|
||||
WICPixelFormatGUID pfGUID = {};
|
||||
|
@ -2854,56 +2866,56 @@ HRESULT DirectX::GenerateMipMaps(
|
|||
case TEX_FILTER_FANT: // Equivalent to Box filter
|
||||
case TEX_FILTER_LINEAR:
|
||||
case TEX_FILTER_CUBIC:
|
||||
{
|
||||
static_assert(TEX_FILTER_FANT == TEX_FILTER_BOX, "TEX_FILTER_ flag alias mismatch");
|
||||
|
||||
if (wicpf)
|
||||
{
|
||||
// Case 1: Base image format is supported by Windows Imaging Component
|
||||
hr = (baseImage.height > 1 || !allow1D)
|
||||
? mipChain.Initialize2D(baseImage.format, baseImage.width, baseImage.height, 1, levels)
|
||||
: mipChain.Initialize1D(baseImage.format, baseImage.width, 1, levels);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
static_assert(TEX_FILTER_FANT == TEX_FILTER_BOX, "TEX_FILTER_ flag alias mismatch");
|
||||
|
||||
return GenerateMipMapsUsingWIC(baseImage, filter, levels, pfGUID, mipChain, 0);
|
||||
if (wicpf)
|
||||
{
|
||||
// Case 1: Base image format is supported by Windows Imaging Component
|
||||
hr = (baseImage.height > 1 || !allow1D)
|
||||
? mipChain.Initialize2D(baseImage.format, baseImage.width, baseImage.height, 1, levels)
|
||||
: mipChain.Initialize1D(baseImage.format, baseImage.width, 1, levels);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
return GenerateMipMapsUsingWIC(baseImage, filter, levels, pfGUID, mipChain, 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Case 2: Base image format is not supported by WIC, so we have to convert, generate, and convert back
|
||||
assert(baseImage.format != DXGI_FORMAT_R32G32B32A32_FLOAT);
|
||||
ScratchImage temp;
|
||||
hr = ConvertToR32G32B32A32(baseImage, temp);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
const Image *timg = temp.GetImage(0, 0, 0);
|
||||
if (!timg)
|
||||
return E_POINTER;
|
||||
|
||||
ScratchImage tMipChain;
|
||||
hr = (baseImage.height > 1 || !allow1D)
|
||||
? tMipChain.Initialize2D(DXGI_FORMAT_R32G32B32A32_FLOAT, baseImage.width, baseImage.height, 1, levels)
|
||||
: tMipChain.Initialize1D(DXGI_FORMAT_R32G32B32A32_FLOAT, baseImage.width, 1, levels);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
hr = GenerateMipMapsUsingWIC(*timg, filter, levels, GUID_WICPixelFormat128bppRGBAFloat, tMipChain, 0);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
temp.Release();
|
||||
|
||||
return ConvertFromR32G32B32A32(tMipChain.GetImages(), tMipChain.GetImageCount(), tMipChain.GetMetadata(), baseImage.format, mipChain);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Case 2: Base image format is not supported by WIC, so we have to convert, generate, and convert back
|
||||
assert(baseImage.format != DXGI_FORMAT_R32G32B32A32_FLOAT);
|
||||
ScratchImage temp;
|
||||
hr = ConvertToR32G32B32A32(baseImage, temp);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
const Image *timg = temp.GetImage(0, 0, 0);
|
||||
if (!timg)
|
||||
return E_POINTER;
|
||||
|
||||
ScratchImage tMipChain;
|
||||
hr = (baseImage.height > 1 || !allow1D)
|
||||
? tMipChain.Initialize2D(DXGI_FORMAT_R32G32B32A32_FLOAT, baseImage.width, baseImage.height, 1, levels)
|
||||
: tMipChain.Initialize1D(DXGI_FORMAT_R32G32B32A32_FLOAT, baseImage.width, 1, levels);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
hr = GenerateMipMapsUsingWIC(*timg, filter, levels, GUID_WICPixelFormat128bppRGBAFloat, tMipChain, 0);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
temp.Release();
|
||||
|
||||
return ConvertFromR32G32B32A32(tMipChain.GetImages(), tMipChain.GetImageCount(), tMipChain.GetMetadata(), baseImage.format, mipChain);
|
||||
}
|
||||
}
|
||||
|
||||
default:
|
||||
return HRESULT_E_NOT_SUPPORTED;
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif // WIN32
|
||||
#endif // WIN32
|
||||
{
|
||||
//--- Use custom filters to generate mipmaps ----------------------------------
|
||||
TexMetadata mdata = {};
|
||||
|
@ -3039,7 +3051,7 @@ HRESULT DirectX::GenerateMipMaps(
|
|||
|
||||
static_assert(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MODE_MASK");
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
bool usewic = !metadata.IsPMAlpha() && UseWICFiltering(metadata.format, filter);
|
||||
|
||||
WICPixelFormatGUID pfGUID = {};
|
||||
|
@ -3069,69 +3081,69 @@ HRESULT DirectX::GenerateMipMaps(
|
|||
case TEX_FILTER_FANT: // Equivalent to Box filter
|
||||
case TEX_FILTER_LINEAR:
|
||||
case TEX_FILTER_CUBIC:
|
||||
{
|
||||
static_assert(TEX_FILTER_FANT == TEX_FILTER_BOX, "TEX_FILTER_ flag alias mismatch");
|
||||
|
||||
if (wicpf)
|
||||
{
|
||||
// Case 1: Base image format is supported by Windows Imaging Component
|
||||
TexMetadata mdata2 = metadata;
|
||||
mdata2.mipLevels = levels;
|
||||
hr = mipChain.Initialize(mdata2);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
static_assert(TEX_FILTER_FANT == TEX_FILTER_BOX, "TEX_FILTER_ flag alias mismatch");
|
||||
|
||||
for (size_t item = 0; item < metadata.arraySize; ++item)
|
||||
if (wicpf)
|
||||
{
|
||||
hr = GenerateMipMapsUsingWIC(baseImages[item], filter, levels, pfGUID, mipChain, item);
|
||||
// Case 1: Base image format is supported by Windows Imaging Component
|
||||
TexMetadata mdata2 = metadata;
|
||||
mdata2.mipLevels = levels;
|
||||
hr = mipChain.Initialize(mdata2);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
for (size_t item = 0; item < metadata.arraySize; ++item)
|
||||
{
|
||||
mipChain.Release();
|
||||
return hr;
|
||||
hr = GenerateMipMapsUsingWIC(baseImages[item], filter, levels, pfGUID, mipChain, item);
|
||||
if (FAILED(hr))
|
||||
{
|
||||
mipChain.Release();
|
||||
return hr;
|
||||
}
|
||||
}
|
||||
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
return S_OK;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Case 2: Base image format is not supported by WIC, so we have to convert, generate, and convert back
|
||||
assert(metadata.format != DXGI_FORMAT_R32G32B32A32_FLOAT);
|
||||
|
||||
TexMetadata mdata2 = metadata;
|
||||
mdata2.mipLevels = levels;
|
||||
mdata2.format = DXGI_FORMAT_R32G32B32A32_FLOAT;
|
||||
ScratchImage tMipChain;
|
||||
hr = tMipChain.Initialize(mdata2);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
for (size_t item = 0; item < metadata.arraySize; ++item)
|
||||
else
|
||||
{
|
||||
ScratchImage temp;
|
||||
hr = ConvertToR32G32B32A32(baseImages[item], temp);
|
||||
// Case 2: Base image format is not supported by WIC, so we have to convert, generate, and convert back
|
||||
assert(metadata.format != DXGI_FORMAT_R32G32B32A32_FLOAT);
|
||||
|
||||
TexMetadata mdata2 = metadata;
|
||||
mdata2.mipLevels = levels;
|
||||
mdata2.format = DXGI_FORMAT_R32G32B32A32_FLOAT;
|
||||
ScratchImage tMipChain;
|
||||
hr = tMipChain.Initialize(mdata2);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
const Image *timg = temp.GetImage(0, 0, 0);
|
||||
if (!timg)
|
||||
return E_POINTER;
|
||||
for (size_t item = 0; item < metadata.arraySize; ++item)
|
||||
{
|
||||
ScratchImage temp;
|
||||
hr = ConvertToR32G32B32A32(baseImages[item], temp);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
hr = GenerateMipMapsUsingWIC(*timg, filter, levels, GUID_WICPixelFormat128bppRGBAFloat, tMipChain, item);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
const Image *timg = temp.GetImage(0, 0, 0);
|
||||
if (!timg)
|
||||
return E_POINTER;
|
||||
|
||||
hr = GenerateMipMapsUsingWIC(*timg, filter, levels, GUID_WICPixelFormat128bppRGBAFloat, tMipChain, item);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
}
|
||||
|
||||
return ConvertFromR32G32B32A32(tMipChain.GetImages(), tMipChain.GetImageCount(), tMipChain.GetMetadata(), metadata.format, mipChain);
|
||||
}
|
||||
|
||||
return ConvertFromR32G32B32A32(tMipChain.GetImages(), tMipChain.GetImageCount(), tMipChain.GetMetadata(), metadata.format, mipChain);
|
||||
}
|
||||
}
|
||||
|
||||
default:
|
||||
return HRESULT_E_NOT_SUPPORTED;
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif // WIN32
|
||||
#endif // WIN32
|
||||
{
|
||||
//--- Use custom filters to generate mipmaps ----------------------------------
|
||||
TexMetadata mdata2 = metadata;
|
||||
|
|
|
@ -246,9 +246,9 @@ namespace
|
|||
if (!LoadScanline(sScanline, width, pSrc, spitch, srcImage.format))
|
||||
return E_FAIL;
|
||||
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
memset(dScanline, 0xCD, sizeof(XMVECTOR)*width);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
pixelFunc(dScanline, sScanline, width, h);
|
||||
|
||||
|
@ -563,33 +563,33 @@ HRESULT DirectX::EvaluateImage(
|
|||
break;
|
||||
|
||||
case TEX_DIMENSION_TEXTURE3D:
|
||||
{
|
||||
size_t index = 0;
|
||||
size_t d = metadata.depth;
|
||||
for (size_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
for (size_t slice = 0; slice < d; ++slice, ++index)
|
||||
size_t index = 0;
|
||||
size_t d = metadata.depth;
|
||||
for (size_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
if (index >= nimages)
|
||||
return E_FAIL;
|
||||
for (size_t slice = 0; slice < d; ++slice, ++index)
|
||||
{
|
||||
if (index >= nimages)
|
||||
return E_FAIL;
|
||||
|
||||
const Image& img = images[index];
|
||||
if (img.format != format)
|
||||
return E_FAIL;
|
||||
const Image& img = images[index];
|
||||
if (img.format != format)
|
||||
return E_FAIL;
|
||||
|
||||
if ((img.width > UINT32_MAX) || (img.height > UINT32_MAX))
|
||||
return E_FAIL;
|
||||
if ((img.width > UINT32_MAX) || (img.height > UINT32_MAX))
|
||||
return E_FAIL;
|
||||
|
||||
HRESULT hr = EvaluateImage_(img, pixelFunc);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
HRESULT hr = EvaluateImage_(img, pixelFunc);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
}
|
||||
|
||||
if (d > 1)
|
||||
d >>= 1;
|
||||
}
|
||||
|
||||
if (d > 1)
|
||||
d >>= 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
default:
|
||||
return E_FAIL;
|
||||
|
@ -710,53 +710,53 @@ HRESULT DirectX::TransformImage(
|
|||
break;
|
||||
|
||||
case TEX_DIMENSION_TEXTURE3D:
|
||||
{
|
||||
size_t index = 0;
|
||||
size_t d = metadata.depth;
|
||||
for (size_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
for (size_t slice = 0; slice < d; ++slice, ++index)
|
||||
size_t index = 0;
|
||||
size_t d = metadata.depth;
|
||||
for (size_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
if (index >= nimages)
|
||||
for (size_t slice = 0; slice < d; ++slice, ++index)
|
||||
{
|
||||
result.Release();
|
||||
return E_FAIL;
|
||||
if (index >= nimages)
|
||||
{
|
||||
result.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
const Image& src = srcImages[index];
|
||||
if (src.format != metadata.format)
|
||||
{
|
||||
result.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
if ((src.width > UINT32_MAX) || (src.height > UINT32_MAX))
|
||||
{
|
||||
result.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
const Image& dst = dest[index];
|
||||
|
||||
if (src.width != dst.width || src.height != dst.height)
|
||||
{
|
||||
result.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
hr = TransformImage_(src, pixelFunc, dst);
|
||||
if (FAILED(hr))
|
||||
{
|
||||
result.Release();
|
||||
return hr;
|
||||
}
|
||||
}
|
||||
|
||||
const Image& src = srcImages[index];
|
||||
if (src.format != metadata.format)
|
||||
{
|
||||
result.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
if ((src.width > UINT32_MAX) || (src.height > UINT32_MAX))
|
||||
{
|
||||
result.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
const Image& dst = dest[index];
|
||||
|
||||
if (src.width != dst.width || src.height != dst.height)
|
||||
{
|
||||
result.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
hr = TransformImage_(src, pixelFunc, dst);
|
||||
if (FAILED(hr))
|
||||
{
|
||||
result.Release();
|
||||
return hr;
|
||||
}
|
||||
if (d > 1)
|
||||
d >>= 1;
|
||||
}
|
||||
|
||||
if (d > 1)
|
||||
d >>= 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
default:
|
||||
result.Release();
|
||||
|
|
|
@ -34,11 +34,11 @@ namespace
|
|||
case CNMAP_CHANNEL_ALPHA: return XMVectorGetW(val);
|
||||
|
||||
case CNMAP_CHANNEL_LUMINANCE:
|
||||
{
|
||||
const XMVECTOR v = XMVectorMultiply(val, lScale);
|
||||
XMStoreFloat4A(&f, v);
|
||||
return f.x + f.y + f.z;
|
||||
}
|
||||
{
|
||||
const XMVECTOR v = XMVectorMultiply(val, lScale);
|
||||
XMStoreFloat4A(&f, v);
|
||||
return f.x + f.y + f.z;
|
||||
}
|
||||
|
||||
default:
|
||||
assert(false);
|
||||
|
|
|
@ -19,7 +19,7 @@ using Microsoft::WRL::ComPtr;
|
|||
|
||||
namespace
|
||||
{
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
//--- Do image resize using WIC ---
|
||||
HRESULT PerformResizeUsingWIC(
|
||||
const Image& srcImage,
|
||||
|
@ -189,14 +189,14 @@ namespace
|
|||
return false;
|
||||
}
|
||||
|
||||
#if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
|
||||
#if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
|
||||
if (format == DXGI_FORMAT_R16G16B16A16_FLOAT
|
||||
|| format == DXGI_FORMAT_R16_FLOAT)
|
||||
{
|
||||
// Use non-WIC code paths as these conversions are not supported by Xbox version of WIC
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
static_assert(TEX_FILTER_POINT == 0x100000, "TEX_FILTER_ flag values don't match TEX_FILTER_MASK");
|
||||
|
||||
|
@ -233,6 +233,14 @@ namespace
|
|||
case TEX_FILTER_TRIANGLE:
|
||||
// WIC does not implement this filter
|
||||
return false;
|
||||
|
||||
default:
|
||||
if (BitsPerColor(format) > 8)
|
||||
{
|
||||
// Avoid the WIC bitmap scaler when doing filtering of XR/HDR formats
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return true;
|
||||
|
@ -258,9 +266,9 @@ namespace
|
|||
|
||||
XMVECTOR* row = target + destImage.width;
|
||||
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
memset(row, 0xCD, sizeof(XMVECTOR)*srcImage.width);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
const uint8_t* pSrc = srcImage.pixels;
|
||||
uint8_t* pDest = destImage.pixels;
|
||||
|
@ -321,10 +329,10 @@ namespace
|
|||
XMVECTOR* urow0 = target + destImage.width;
|
||||
XMVECTOR* urow1 = urow0 + srcImage.width;
|
||||
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
memset(urow0, 0xCD, sizeof(XMVECTOR)*srcImage.width);
|
||||
memset(urow1, 0xDD, sizeof(XMVECTOR)*srcImage.width);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
const XMVECTOR* urow2 = urow0 + 1;
|
||||
const XMVECTOR* urow3 = urow1 + 1;
|
||||
|
@ -391,10 +399,10 @@ namespace
|
|||
XMVECTOR* row0 = target + destImage.width;
|
||||
XMVECTOR* row1 = row0 + srcImage.width;
|
||||
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
memset(row0, 0xCD, sizeof(XMVECTOR)*srcImage.width);
|
||||
memset(row1, 0xDD, sizeof(XMVECTOR)*srcImage.width);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
const uint8_t* pSrc = srcImage.pixels;
|
||||
uint8_t* pDest = destImage.pixels;
|
||||
|
@ -451,6 +459,10 @@ namespace
|
|||
|
||||
|
||||
//--- Cubic Filter ---
|
||||
#ifdef __clang__
|
||||
#pragma clang diagnostic ignored "-Wextra-semi-stmt"
|
||||
#endif
|
||||
|
||||
HRESULT ResizeCubicFilter(const Image& srcImage, TEX_FILTER_FLAGS filter, const Image& destImage) noexcept
|
||||
{
|
||||
using namespace DirectX::Filters;
|
||||
|
@ -480,12 +492,12 @@ namespace
|
|||
XMVECTOR* row2 = row0 + srcImage.width * 2;
|
||||
XMVECTOR* row3 = row0 + srcImage.width * 3;
|
||||
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
memset(row0, 0xCD, sizeof(XMVECTOR)*srcImage.width);
|
||||
memset(row1, 0xDD, sizeof(XMVECTOR)*srcImage.width);
|
||||
memset(row2, 0xED, sizeof(XMVECTOR)*srcImage.width);
|
||||
memset(row3, 0xFD, sizeof(XMVECTOR)*srcImage.width);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
const uint8_t* pSrc = srcImage.pixels;
|
||||
uint8_t* pDest = destImage.pixels;
|
||||
|
@ -594,12 +606,12 @@ namespace
|
|||
|
||||
XMVECTOR C0, C1, C2, C3;
|
||||
|
||||
CUBIC_INTERPOLATE(C0, toX.x, row0[toX.u0], row0[toX.u1], row0[toX.u2], row0[toX.u3])
|
||||
CUBIC_INTERPOLATE(C1, toX.x, row1[toX.u0], row1[toX.u1], row1[toX.u2], row1[toX.u3])
|
||||
CUBIC_INTERPOLATE(C2, toX.x, row2[toX.u0], row2[toX.u1], row2[toX.u2], row2[toX.u3])
|
||||
CUBIC_INTERPOLATE(C3, toX.x, row3[toX.u0], row3[toX.u1], row3[toX.u2], row3[toX.u3])
|
||||
CUBIC_INTERPOLATE(C0, toX.x, row0[toX.u0], row0[toX.u1], row0[toX.u2], row0[toX.u3]);
|
||||
CUBIC_INTERPOLATE(C1, toX.x, row1[toX.u0], row1[toX.u1], row1[toX.u2], row1[toX.u3]);
|
||||
CUBIC_INTERPOLATE(C2, toX.x, row2[toX.u0], row2[toX.u1], row2[toX.u2], row2[toX.u3]);
|
||||
CUBIC_INTERPOLATE(C3, toX.x, row3[toX.u0], row3[toX.u1], row3[toX.u2], row3[toX.u3]);
|
||||
|
||||
CUBIC_INTERPOLATE(target[x], toY.x, C0, C1, C2, C3)
|
||||
CUBIC_INTERPOLATE(target[x], toY.x, C0, C1, C2, C3);
|
||||
}
|
||||
|
||||
if (!StoreScanlineLinear(pDest, destImage.rowPitch, destImage.format, target, destImage.width, filter))
|
||||
|
@ -642,9 +654,9 @@ namespace
|
|||
|
||||
XMVECTOR* row = scanline.get();
|
||||
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
memset(row, 0xCD, sizeof(XMVECTOR)*srcImage.width);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
auto xFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfX.get()) + tfX->sizeInBytes);
|
||||
auto yFromEnd = reinterpret_cast<const FilterFrom*>(reinterpret_cast<const uint8_t*>(tfY.get()) + tfY->sizeInBytes);
|
||||
|
@ -757,18 +769,18 @@ namespace
|
|||
{
|
||||
case DXGI_FORMAT_R10G10B10A2_UNORM:
|
||||
case DXGI_FORMAT_R10G10B10A2_UINT:
|
||||
{
|
||||
// Need to slightly bias results for floating-point error accumulation which can
|
||||
// be visible with harshly quantized values
|
||||
static const XMVECTORF32 Bias = { { { 0.f, 0.f, 0.f, 0.1f } } };
|
||||
|
||||
XMVECTOR* ptr = pAccSrc;
|
||||
for (size_t i = 0; i < destImage.width; ++i, ++ptr)
|
||||
{
|
||||
*ptr = XMVectorAdd(*ptr, Bias);
|
||||
// Need to slightly bias results for floating-point error accumulation which can
|
||||
// be visible with harshly quantized values
|
||||
static const XMVECTORF32 Bias = { { { 0.f, 0.f, 0.f, 0.1f } } };
|
||||
|
||||
XMVECTOR* ptr = pAccSrc;
|
||||
for (size_t i = 0; i < destImage.width; ++i, ++ptr)
|
||||
{
|
||||
*ptr = XMVectorAdd(*ptr, Bias);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
|
@ -864,7 +876,7 @@ HRESULT DirectX::Resize(
|
|||
return HRESULT_E_NOT_SUPPORTED;
|
||||
}
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
bool usewic = UseWICFiltering(srcImage.format, filter);
|
||||
|
||||
WICPixelFormatGUID pfGUID = {};
|
||||
|
@ -893,7 +905,7 @@ HRESULT DirectX::Resize(
|
|||
if (!rimage)
|
||||
return E_POINTER;
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
if (usewic)
|
||||
{
|
||||
if (wicpf)
|
||||
|
@ -908,7 +920,7 @@ HRESULT DirectX::Resize(
|
|||
}
|
||||
}
|
||||
else
|
||||
#endif
|
||||
#endif
|
||||
{
|
||||
// Case 3: not using WIC resizing
|
||||
hr = PerformResizeUsingCustomFilters(srcImage, filter, *rimage);
|
||||
|
@ -951,7 +963,7 @@ HRESULT DirectX::Resize(
|
|||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
bool usewic = !metadata.IsPMAlpha() && UseWICFiltering(metadata.format, filter);
|
||||
|
||||
WICPixelFormatGUID pfGUID = {};
|
||||
|
@ -1007,7 +1019,7 @@ HRESULT DirectX::Resize(
|
|||
return E_FAIL;
|
||||
}
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
if (usewic)
|
||||
{
|
||||
if (wicpf)
|
||||
|
@ -1022,7 +1034,7 @@ HRESULT DirectX::Resize(
|
|||
}
|
||||
}
|
||||
else
|
||||
#endif
|
||||
#endif
|
||||
{
|
||||
// Case 3: not using WIC resizing
|
||||
hr = PerformResizeUsingCustomFilters(*srcimg, filter, *destimg);
|
||||
|
@ -1068,7 +1080,7 @@ HRESULT DirectX::Resize(
|
|||
return E_FAIL;
|
||||
}
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
if (usewic)
|
||||
{
|
||||
if (wicpf)
|
||||
|
@ -1083,7 +1095,7 @@ HRESULT DirectX::Resize(
|
|||
}
|
||||
}
|
||||
else
|
||||
#endif
|
||||
#endif
|
||||
{
|
||||
// Case 3: not using WIC resizing
|
||||
hr = PerformResizeUsingCustomFilters(*srcimg, filter, *destimg);
|
||||
|
|
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
|
@ -32,7 +32,7 @@ using Microsoft::WRL::ComPtr;
|
|||
|
||||
namespace
|
||||
{
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
//-------------------------------------------------------------------------------------
|
||||
// WIC Pixel Format Translation Data
|
||||
//-------------------------------------------------------------------------------------
|
||||
|
@ -122,12 +122,12 @@ namespace
|
|||
return std::aligned_alloc(alignment, size);
|
||||
}
|
||||
|
||||
#define _aligned_free free
|
||||
#define _aligned_free free
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
//=====================================================================================
|
||||
// WIC Utilities
|
||||
//=====================================================================================
|
||||
|
@ -157,56 +157,56 @@ bool DirectX::Internal::DXGIToWIC(DXGI_FORMAT format, GUID& guid, bool ignoreRGB
|
|||
{
|
||||
switch (format)
|
||||
{
|
||||
case DXGI_FORMAT_R8G8B8A8_UNORM:
|
||||
case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
|
||||
if (ignoreRGBvsBGR)
|
||||
{
|
||||
// If we are not doing conversion so don't really care about BGR vs RGB color-order,
|
||||
// we can use the canonical WIC 32bppBGRA format which avoids an extra format conversion when using the WIC scaler
|
||||
memcpy(&guid, &GUID_WICPixelFormat32bppBGRA, sizeof(GUID));
|
||||
}
|
||||
else
|
||||
{
|
||||
memcpy(&guid, &GUID_WICPixelFormat32bppRGBA, sizeof(GUID));
|
||||
}
|
||||
return true;
|
||||
|
||||
case DXGI_FORMAT_D32_FLOAT:
|
||||
memcpy(&guid, &GUID_WICPixelFormat32bppGrayFloat, sizeof(GUID));
|
||||
return true;
|
||||
|
||||
case DXGI_FORMAT_D16_UNORM:
|
||||
memcpy(&guid, &GUID_WICPixelFormat16bppGray, sizeof(GUID));
|
||||
return true;
|
||||
|
||||
case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
|
||||
case DXGI_FORMAT_R8G8B8A8_UNORM:
|
||||
case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
|
||||
if (ignoreRGBvsBGR)
|
||||
{
|
||||
// If we are not doing conversion so don't really care about BGR vs RGB color-order,
|
||||
// we can use the canonical WIC 32bppBGRA format which avoids an extra format conversion when using the WIC scaler
|
||||
memcpy(&guid, &GUID_WICPixelFormat32bppBGRA, sizeof(GUID));
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
memcpy(&guid, &GUID_WICPixelFormat32bppRGBA, sizeof(GUID));
|
||||
}
|
||||
return true;
|
||||
|
||||
case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
|
||||
memcpy(&guid, &GUID_WICPixelFormat32bppBGR, sizeof(GUID));
|
||||
return true;
|
||||
case DXGI_FORMAT_D32_FLOAT:
|
||||
memcpy(&guid, &GUID_WICPixelFormat32bppGrayFloat, sizeof(GUID));
|
||||
return true;
|
||||
|
||||
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
|
||||
case DXGI_FORMAT_R32G32B32_FLOAT:
|
||||
if (g_WIC2)
|
||||
case DXGI_FORMAT_D16_UNORM:
|
||||
memcpy(&guid, &GUID_WICPixelFormat16bppGray, sizeof(GUID));
|
||||
return true;
|
||||
|
||||
case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
|
||||
memcpy(&guid, &GUID_WICPixelFormat32bppBGRA, sizeof(GUID));
|
||||
return true;
|
||||
|
||||
case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
|
||||
memcpy(&guid, &GUID_WICPixelFormat32bppBGR, sizeof(GUID));
|
||||
return true;
|
||||
|
||||
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
|
||||
case DXGI_FORMAT_R32G32B32_FLOAT:
|
||||
if (g_WIC2)
|
||||
{
|
||||
memcpy(&guid, &GUID_WICPixelFormat96bppRGBFloat, sizeof(GUID));
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
|
||||
default:
|
||||
for (size_t i = 0; i < std::size(g_WICFormats); ++i)
|
||||
{
|
||||
if (g_WICFormats[i].format == format)
|
||||
{
|
||||
memcpy(&guid, &GUID_WICPixelFormat96bppRGBFloat, sizeof(GUID));
|
||||
memcpy(&guid, &g_WICFormats[i].wic, sizeof(GUID));
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
|
||||
default:
|
||||
for (size_t i = 0; i < std::size(g_WICFormats); ++i)
|
||||
{
|
||||
if (g_WICFormats[i].format == format)
|
||||
{
|
||||
memcpy(&guid, &g_WICFormats[i].wic, sizeof(GUID));
|
||||
return true;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
memset(&guid, 0, sizeof(GUID));
|
||||
|
@ -319,14 +319,14 @@ void DirectX::SetWICFactory(_In_opt_ IWICImagingFactory* pWIC) noexcept
|
|||
bool iswic2 = false;
|
||||
if (pWIC)
|
||||
{
|
||||
#if(_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
|
||||
#if(_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
|
||||
ComPtr<IWICImagingFactory2> wic2;
|
||||
HRESULT hr = pWIC->QueryInterface(IID_PPV_ARGS(wic2.GetAddressOf()));
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
iswic2 = true;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
pWIC->AddRef();
|
||||
}
|
||||
|
||||
|
@ -973,6 +973,11 @@ HRESULT DirectX::ComputePitch(DXGI_FORMAT fmt, size_t width, size_t height,
|
|||
|
||||
case DXGI_FORMAT_NV12:
|
||||
case DXGI_FORMAT_420_OPAQUE:
|
||||
if ((height % 2) != 0)
|
||||
{
|
||||
// Requires a height alignment of 2.
|
||||
return E_INVALIDARG;
|
||||
}
|
||||
assert(IsPlanar(fmt));
|
||||
pitch = ((uint64_t(width) + 1u) >> 1) * 2u;
|
||||
slice = pitch * (uint64_t(height) + ((uint64_t(height) + 1u) >> 1));
|
||||
|
@ -980,6 +985,20 @@ HRESULT DirectX::ComputePitch(DXGI_FORMAT fmt, size_t width, size_t height,
|
|||
|
||||
case DXGI_FORMAT_P010:
|
||||
case DXGI_FORMAT_P016:
|
||||
if ((height % 2) != 0)
|
||||
{
|
||||
// Requires a height alignment of 2.
|
||||
return E_INVALIDARG;
|
||||
}
|
||||
|
||||
#if (__cplusplus >= 201703L)
|
||||
[[fallthrough]];
|
||||
#elif defined(__clang__)
|
||||
[[clang::fallthrough]];
|
||||
#elif defined(_MSC_VER)
|
||||
__fallthrough;
|
||||
#endif
|
||||
|
||||
case XBOX_DXGI_FORMAT_D16_UNORM_S8_UINT:
|
||||
case XBOX_DXGI_FORMAT_R16_UNORM_X8_TYPELESS:
|
||||
case XBOX_DXGI_FORMAT_X16_TYPELESS_G8_UINT:
|
||||
|
@ -1001,6 +1020,11 @@ HRESULT DirectX::ComputePitch(DXGI_FORMAT fmt, size_t width, size_t height,
|
|||
break;
|
||||
|
||||
case WIN10_DXGI_FORMAT_V208:
|
||||
if ((height % 2) != 0)
|
||||
{
|
||||
// Requires a height alignment of 2.
|
||||
return E_INVALIDARG;
|
||||
}
|
||||
assert(IsPlanar(fmt));
|
||||
pitch = uint64_t(width);
|
||||
slice = pitch * (uint64_t(height) + (((uint64_t(height) + 1u) >> 1) * 2u));
|
||||
|
@ -1183,6 +1207,41 @@ DXGI_FORMAT DirectX::MakeSRGB(DXGI_FORMAT fmt) noexcept
|
|||
}
|
||||
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
// Converts to an non-SRGB equivalent type
|
||||
//-------------------------------------------------------------------------------------
|
||||
_Use_decl_annotations_
|
||||
DXGI_FORMAT DirectX::MakeLinear(DXGI_FORMAT fmt) noexcept
|
||||
{
|
||||
switch (fmt)
|
||||
{
|
||||
case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
|
||||
return DXGI_FORMAT_R8G8B8A8_UNORM;
|
||||
|
||||
case DXGI_FORMAT_BC1_UNORM_SRGB:
|
||||
return DXGI_FORMAT_BC1_UNORM;
|
||||
|
||||
case DXGI_FORMAT_BC2_UNORM_SRGB:
|
||||
return DXGI_FORMAT_BC2_UNORM;
|
||||
|
||||
case DXGI_FORMAT_BC3_UNORM_SRGB:
|
||||
return DXGI_FORMAT_BC3_UNORM;
|
||||
|
||||
case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
|
||||
return DXGI_FORMAT_B8G8R8A8_UNORM;
|
||||
|
||||
case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
|
||||
return DXGI_FORMAT_B8G8R8X8_UNORM;
|
||||
|
||||
case DXGI_FORMAT_BC7_UNORM_SRGB:
|
||||
return DXGI_FORMAT_BC7_UNORM;
|
||||
|
||||
default:
|
||||
return fmt;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
// Converts to a format to an equivalent TYPELESS format if available
|
||||
//-------------------------------------------------------------------------------------
|
||||
|
|
|
@ -106,7 +106,7 @@ namespace
|
|||
{
|
||||
if (memcmp(&GUID_WICPixelFormat96bppRGBFixedPoint, &pixelFormat, sizeof(WICPixelFormatGUID)) == 0)
|
||||
{
|
||||
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
|
||||
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) || defined(_WIN7_PLATFORM_UPDATE)
|
||||
if (iswic2)
|
||||
{
|
||||
if (pConvert)
|
||||
|
@ -114,9 +114,9 @@ namespace
|
|||
format = DXGI_FORMAT_R32G32B32_FLOAT;
|
||||
}
|
||||
else
|
||||
#else
|
||||
#else
|
||||
UNREFERENCED_PARAMETER(iswic2);
|
||||
#endif
|
||||
#endif
|
||||
{
|
||||
if (pConvert)
|
||||
memcpy_s(pConvert, sizeof(WICPixelFormatGUID), &GUID_WICPixelFormat128bppRGBAFloat, sizeof(GUID));
|
||||
|
@ -600,7 +600,7 @@ namespace
|
|||
sRGB = (flags & WIC_FLAGS_DEFAULT_SRGB) != 0;
|
||||
}
|
||||
}
|
||||
#if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
|
||||
#if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
|
||||
else if (memcmp(&containerFormat, &GUID_ContainerFormatJpeg, sizeof(GUID)) == 0)
|
||||
{
|
||||
if (SUCCEEDED(metareader->GetMetadataByName(L"/app1/ifd/exif/{ushort=40961}", &value)) && value.vt == VT_UI2)
|
||||
|
@ -623,7 +623,7 @@ namespace
|
|||
sRGB = (flags & WIC_FLAGS_DEFAULT_SRGB) != 0;
|
||||
}
|
||||
}
|
||||
#else
|
||||
#else
|
||||
else if (SUCCEEDED(metareader->GetMetadataByName(L"System.Image.ColorSpace", &value)) && value.vt == VT_UI2)
|
||||
{
|
||||
sRGB = (value.uiVal == 1);
|
||||
|
@ -632,7 +632,7 @@ namespace
|
|||
{
|
||||
sRGB = (flags & WIC_FLAGS_DEFAULT_SRGB) != 0;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
std::ignore = PropVariantClear(&value);
|
||||
|
||||
|
@ -913,7 +913,7 @@ namespace
|
|||
std::ignore = metawriter->RemoveMetadataByName(L"/sRGB/RenderingIntent");
|
||||
}
|
||||
}
|
||||
#if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
|
||||
#if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)
|
||||
else if (memcmp(&containerFormat, &GUID_ContainerFormatJpeg, sizeof(GUID)) == 0)
|
||||
{
|
||||
// Set Software name
|
||||
|
@ -940,7 +940,7 @@ namespace
|
|||
std::ignore = metawriter->SetMetadataByName(L"/ifd/exif/{ushort=40961}", &value);
|
||||
}
|
||||
}
|
||||
#else
|
||||
#else
|
||||
else
|
||||
{
|
||||
// Set Software name
|
||||
|
@ -954,7 +954,7 @@ namespace
|
|||
std::ignore = metawriter->SetMetadataByName(L"System.Image.ColorSpace", &value);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
else if (hr == WINCODEC_ERR_UNSUPPORTEDOPERATION)
|
||||
{
|
||||
|
|
|
@ -72,65 +72,65 @@ HRESULT Xbox::CreateTexture(
|
|||
switch (metadata.dimension)
|
||||
{
|
||||
case DirectX::TEX_DIMENSION_TEXTURE1D:
|
||||
{
|
||||
D3D11_TEXTURE1D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.ArraySize = static_cast<UINT>(metadata.arraySize);
|
||||
desc.Format = metadata.format;
|
||||
desc.Usage = D3D11_USAGE_DEFAULT;
|
||||
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
|
||||
|
||||
ID3D11Texture1D* tex = nullptr;
|
||||
hr = d3dDevice->CreatePlacementTexture1D(&desc, xbox.GetTileMode(), 0, *grfxMemory, &tex);
|
||||
if (SUCCEEDED(hr) && tex)
|
||||
{
|
||||
*ppResource = tex;
|
||||
D3D11_TEXTURE1D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.ArraySize = static_cast<UINT>(metadata.arraySize);
|
||||
desc.Format = metadata.format;
|
||||
desc.Usage = D3D11_USAGE_DEFAULT;
|
||||
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
|
||||
|
||||
ID3D11Texture1D* tex = nullptr;
|
||||
hr = d3dDevice->CreatePlacementTexture1D(&desc, xbox.GetTileMode(), 0, *grfxMemory, &tex);
|
||||
if (SUCCEEDED(hr) && tex)
|
||||
{
|
||||
*ppResource = tex;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
case DirectX::TEX_DIMENSION_TEXTURE2D:
|
||||
{
|
||||
D3D11_TEXTURE2D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.Height = static_cast<UINT>(metadata.height);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.ArraySize = static_cast<UINT>(metadata.arraySize);
|
||||
desc.Format = metadata.format;
|
||||
desc.SampleDesc.Count = 1;
|
||||
desc.Usage = D3D11_USAGE_DEFAULT;
|
||||
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
|
||||
desc.MiscFlags = (metadata.miscFlags & DirectX::TEX_MISC_TEXTURECUBE) ? D3D11_RESOURCE_MISC_TEXTURECUBE : 0;
|
||||
|
||||
ID3D11Texture2D* tex = nullptr;
|
||||
hr = d3dDevice->CreatePlacementTexture2D(&desc, xbox.GetTileMode(), 0, *grfxMemory, &tex);
|
||||
if (SUCCEEDED(hr) && tex)
|
||||
{
|
||||
*ppResource = tex;
|
||||
D3D11_TEXTURE2D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.Height = static_cast<UINT>(metadata.height);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.ArraySize = static_cast<UINT>(metadata.arraySize);
|
||||
desc.Format = metadata.format;
|
||||
desc.SampleDesc.Count = 1;
|
||||
desc.Usage = D3D11_USAGE_DEFAULT;
|
||||
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
|
||||
desc.MiscFlags = (metadata.miscFlags & DirectX::TEX_MISC_TEXTURECUBE) ? D3D11_RESOURCE_MISC_TEXTURECUBE : 0;
|
||||
|
||||
ID3D11Texture2D* tex = nullptr;
|
||||
hr = d3dDevice->CreatePlacementTexture2D(&desc, xbox.GetTileMode(), 0, *grfxMemory, &tex);
|
||||
if (SUCCEEDED(hr) && tex)
|
||||
{
|
||||
*ppResource = tex;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
case DirectX::TEX_DIMENSION_TEXTURE3D:
|
||||
{
|
||||
D3D11_TEXTURE3D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.Height = static_cast<UINT>(metadata.height);
|
||||
desc.Depth = static_cast<UINT>(metadata.depth);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.Format = metadata.format;
|
||||
desc.Usage = D3D11_USAGE_DEFAULT;
|
||||
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
|
||||
|
||||
ID3D11Texture3D* tex = nullptr;
|
||||
hr = d3dDevice->CreatePlacementTexture3D(&desc, xbox.GetTileMode(), 0, *grfxMemory, &tex);
|
||||
if (SUCCEEDED(hr) && tex)
|
||||
{
|
||||
*ppResource = tex;
|
||||
D3D11_TEXTURE3D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.Height = static_cast<UINT>(metadata.height);
|
||||
desc.Depth = static_cast<UINT>(metadata.depth);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.Format = metadata.format;
|
||||
desc.Usage = D3D11_USAGE_DEFAULT;
|
||||
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
|
||||
|
||||
ID3D11Texture3D* tex = nullptr;
|
||||
hr = d3dDevice->CreatePlacementTexture3D(&desc, xbox.GetTileMode(), 0, *grfxMemory, &tex);
|
||||
if (SUCCEEDED(hr) && tex)
|
||||
{
|
||||
*ppResource = tex;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
default:
|
||||
hr = E_FAIL;
|
||||
|
|
|
@ -33,10 +33,10 @@ namespace
|
|||
XALLOC_MEMTYPE_GRAPHICS_WRITECOMBINE_GPU_READONLY,
|
||||
XALLOC_PAGESIZE_64KB,
|
||||
XALLOC_ALIGNMENT_64K
|
||||
#ifdef _GAMING_XBOX
|
||||
#ifdef _GAMING_XBOX
|
||||
, 0
|
||||
#endif
|
||||
);
|
||||
#endif
|
||||
);
|
||||
}
|
||||
|
||||
//=====================================================================================
|
||||
|
|
|
@ -116,17 +116,17 @@ namespace
|
|||
auto xboxext = reinterpret_cast<const DDS_HEADER_XBOX*>(
|
||||
reinterpret_cast<const uint8_t*>(pSource) + sizeof(uint32_t) + sizeof(DDS_HEADER));
|
||||
|
||||
#ifdef _GXDK_VER
|
||||
#ifdef _GXDK_VER
|
||||
if (xboxext->xdkVer < _GXDK_VER)
|
||||
{
|
||||
OutputDebugStringA("WARNING: DDS XBOX file may be outdated and need regeneration\n");
|
||||
}
|
||||
#elif defined(_XDK_VER)
|
||||
#elif defined(_XDK_VER)
|
||||
if (xboxext->xdkVer < _XDK_VER)
|
||||
{
|
||||
OutputDebugStringA("WARNING: DDS XBOX file may be outdated and need regeneration\n");
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
metadata.arraySize = xboxext->arraySize;
|
||||
if (metadata.arraySize == 0)
|
||||
|
@ -196,17 +196,17 @@ namespace
|
|||
return HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
||||
}
|
||||
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
else if (!(xboxext->tileMode & XBOX_TILEMODE_SCARLETT))
|
||||
{
|
||||
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
|
||||
}
|
||||
#else
|
||||
#else
|
||||
else if (xboxext->tileMode & XBOX_TILEMODE_SCARLETT)
|
||||
{
|
||||
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
static_assert(static_cast<int>(TEX_MISC2_ALPHA_MODE_MASK) == static_cast<int>(DDS_MISC_FLAGS2_ALPHA_MODE_MASK), "DDS header mismatch");
|
||||
|
||||
|
@ -368,19 +368,19 @@ namespace
|
|||
|
||||
xboxext->miscFlags2 = metadata.miscFlags2;
|
||||
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
xboxext->tileMode = static_cast<uint32_t>(xbox.GetTileMode()) | XBOX_TILEMODE_SCARLETT;
|
||||
#else
|
||||
#else
|
||||
xboxext->tileMode = static_cast<uint32_t>(xbox.GetTileMode());
|
||||
#endif
|
||||
#endif
|
||||
|
||||
xboxext->baseAlignment = xbox.GetAlignment();
|
||||
xboxext->dataSize = xbox.GetSize();
|
||||
#ifdef _GXDK_VER
|
||||
#ifdef _GXDK_VER
|
||||
xboxext->xdkVer = _GXDK_VER;
|
||||
#elif defined(_XDK_VER)
|
||||
#elif defined(_XDK_VER)
|
||||
xboxext->xdkVer = _XDK_VER;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
return S_OK;
|
||||
}
|
||||
|
|
|
@ -47,12 +47,12 @@ namespace
|
|||
|
||||
for (size_t x = 0; x < w; ++x)
|
||||
{
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
const UINT64 element = (packed) ? (x >> 1) : x;
|
||||
const size_t offset = computer->GetTexelElementOffsetBytes(0, level, element, 0, item, 0, nullptr);
|
||||
#else
|
||||
#else
|
||||
const size_t offset = computer->GetTexelElementOffsetBytes(0, level, x, 0, item, 0);
|
||||
#endif
|
||||
#endif
|
||||
if (offset == size_t(-1))
|
||||
return E_FAIL;
|
||||
|
||||
|
@ -107,12 +107,12 @@ namespace
|
|||
|
||||
for (size_t x = 0; x < w; ++x)
|
||||
{
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
const UINT64 element = (packed) ? (x >> 1) : x;
|
||||
const size_t offset = computer->GetTexelElementOffsetBytes(0, level, element, y, item, 0, nullptr);
|
||||
#else
|
||||
#else
|
||||
const size_t offset = computer->GetTexelElementOffsetBytes(0, level, x, y, item, 0);
|
||||
#endif
|
||||
#endif
|
||||
if (offset == size_t(-1))
|
||||
return E_FAIL;
|
||||
|
||||
|
@ -163,12 +163,12 @@ namespace
|
|||
|
||||
for (size_t x = 0; x < w; ++x)
|
||||
{
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
const UINT64 element = (packed) ? (x >> 1) : x;
|
||||
const size_t offset = computer->GetTexelElementOffsetBytes(0, level, element, y, z, 0, nullptr);
|
||||
#else
|
||||
#else
|
||||
const size_t offset = computer->GetTexelElementOffsetBytes(0, level, x, y, z, 0);
|
||||
#endif
|
||||
#endif
|
||||
if (offset == size_t(-1))
|
||||
return E_FAIL;
|
||||
|
||||
|
@ -219,10 +219,10 @@ namespace
|
|||
assert(!IsCompressed(format));
|
||||
|
||||
bool byelement = IsTypeless(format);
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
if (nimages > 1)
|
||||
byelement = true;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if (IsPacked(format))
|
||||
{
|
||||
|
@ -258,12 +258,12 @@ namespace
|
|||
XMVECTOR* target = scanline.get();
|
||||
XMVECTOR* tiled = target + result[0]->width;
|
||||
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
memset(target, 0xCD, sizeof(XMVECTOR) * result[0]->width);
|
||||
memset(tiled, 0xDD, sizeof(XMVECTOR) * tiledPixels);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Load tiled texture
|
||||
// Load tiled texture
|
||||
if ((xbox.GetSize() - mip.OffsetBytes) < mip.SizeBytes)
|
||||
return E_FAIL;
|
||||
|
||||
|
@ -284,11 +284,11 @@ namespace
|
|||
|
||||
for (size_t x = 0; x < img->width; ++x)
|
||||
{
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
size_t offset = computer->GetTexelElementOffsetBytes(0, level, x, 0, item, 0, nullptr);
|
||||
#else
|
||||
#else
|
||||
size_t offset = computer->GetTexelElementOffsetBytes(0, level, x, 0, item, 0);
|
||||
#endif
|
||||
#endif
|
||||
if (offset == size_t(-1))
|
||||
return E_FAIL;
|
||||
|
||||
|
@ -336,10 +336,10 @@ namespace
|
|||
assert(format == xbox.GetMetadata().format);
|
||||
|
||||
bool byelement = IsTypeless(format);
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
if (nimages > 1)
|
||||
byelement = true;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if (IsCompressed(format))
|
||||
{
|
||||
|
@ -399,12 +399,12 @@ namespace
|
|||
XMVECTOR* target = scanline.get();
|
||||
XMVECTOR* tiled = target + result[0]->width;
|
||||
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
memset(target, 0xCD, sizeof(XMVECTOR) * result[0]->width);
|
||||
memset(tiled, 0xDD, sizeof(XMVECTOR) * tiledPixels);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Load tiled texture
|
||||
// Load tiled texture
|
||||
if ((xbox.GetSize() - mip.OffsetBytes) < mip.SizeBytes)
|
||||
return E_FAIL;
|
||||
|
||||
|
@ -428,11 +428,11 @@ namespace
|
|||
{
|
||||
for (size_t x = 0; x < img->width; ++x)
|
||||
{
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
size_t offset = computer->GetTexelElementOffsetBytes(0, level, x, y, item, 0, nullptr);
|
||||
#else
|
||||
#else
|
||||
size_t offset = computer->GetTexelElementOffsetBytes(0, level, x, y, item, 0);
|
||||
#endif
|
||||
#endif
|
||||
if (offset == size_t(-1))
|
||||
return E_FAIL;
|
||||
|
||||
|
@ -475,11 +475,11 @@ namespace
|
|||
|
||||
assert(layout.Planes == 1);
|
||||
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
const bool byelement = true;
|
||||
#else
|
||||
#else
|
||||
const bool byelement = IsTypeless(result.format);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if (IsCompressed(result.format))
|
||||
{
|
||||
|
@ -535,12 +535,12 @@ namespace
|
|||
XMVECTOR* target = scanline.get();
|
||||
XMVECTOR* tiled = target + result.width;
|
||||
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
memset(target, 0xCD, sizeof(XMVECTOR) * result.width);
|
||||
memset(tiled, 0xDD, sizeof(XMVECTOR) * tiledPixels);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Load tiled texture
|
||||
// Load tiled texture
|
||||
if ((xbox.GetSize() - mip.OffsetBytes) < mip.SizeBytes)
|
||||
return E_FAIL;
|
||||
|
||||
|
@ -578,11 +578,11 @@ namespace
|
|||
{
|
||||
for (size_t x = 0; x < result.width; ++x)
|
||||
{
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
size_t offset = computer->GetTexelElementOffsetBytes(0, level, x, y, z, 0, nullptr);
|
||||
#else
|
||||
#else
|
||||
size_t offset = computer->GetTexelElementOffsetBytes(0, level, x, y, z, 0);
|
||||
#endif
|
||||
#endif
|
||||
if (offset == size_t(-1))
|
||||
return E_FAIL;
|
||||
|
||||
|
@ -651,223 +651,223 @@ HRESULT Xbox::Detile(
|
|||
switch (metadata.dimension)
|
||||
{
|
||||
case TEX_DIMENSION_TEXTURE1D:
|
||||
{
|
||||
XG_TEXTURE1D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.ArraySize = static_cast<UINT>(metadata.arraySize);
|
||||
desc.Format = static_cast<XG_FORMAT>(metadata.format);
|
||||
desc.Usage = XG_USAGE_DEFAULT;
|
||||
desc.BindFlags = XG_BIND_SHADER_RESOURCE;
|
||||
desc.MiscFlags = (metadata.IsCubemap()) ? XG_RESOURCE_MISC_TEXTURECUBE : 0;
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
desc.SwizzleMode = xbox.GetTileMode();
|
||||
#else
|
||||
desc.TileMode = xbox.GetTileMode();
|
||||
#endif
|
||||
|
||||
ComPtr<XGTextureAddressComputer> computer;
|
||||
HRESULT hr = XGCreateTexture1DComputer(&desc, computer.GetAddressOf());
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
hr = computer->GetResourceLayout(&layout);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
if (layout.Planes != 1)
|
||||
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
|
||||
|
||||
if (layout.SizeBytes != xbox.GetSize()
|
||||
|| layout.BaseAlignmentBytes != xbox.GetAlignment())
|
||||
return E_UNEXPECTED;
|
||||
|
||||
hr = image.Initialize(metadata);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
for (uint32_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
if (metadata.arraySize > 1)
|
||||
XG_TEXTURE1D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.ArraySize = static_cast<UINT>(metadata.arraySize);
|
||||
desc.Format = static_cast<XG_FORMAT>(metadata.format);
|
||||
desc.Usage = XG_USAGE_DEFAULT;
|
||||
desc.BindFlags = XG_BIND_SHADER_RESOURCE;
|
||||
desc.MiscFlags = (metadata.IsCubemap()) ? XG_RESOURCE_MISC_TEXTURECUBE : 0;
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
desc.SwizzleMode = xbox.GetTileMode();
|
||||
#else
|
||||
desc.TileMode = xbox.GetTileMode();
|
||||
#endif
|
||||
|
||||
ComPtr<XGTextureAddressComputer> computer;
|
||||
HRESULT hr = XGCreateTexture1DComputer(&desc, computer.GetAddressOf());
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
hr = computer->GetResourceLayout(&layout);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
if (layout.Planes != 1)
|
||||
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
|
||||
|
||||
if (layout.SizeBytes != xbox.GetSize()
|
||||
|| layout.BaseAlignmentBytes != xbox.GetAlignment())
|
||||
return E_UNEXPECTED;
|
||||
|
||||
hr = image.Initialize(metadata);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
for (uint32_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
std::vector<const Image*> images;
|
||||
images.reserve(metadata.arraySize);
|
||||
for (uint32_t item = 0; item < metadata.arraySize; ++item)
|
||||
if (metadata.arraySize > 1)
|
||||
{
|
||||
const Image* img = image.GetImage(level, item, 0);
|
||||
std::vector<const Image*> images;
|
||||
images.reserve(metadata.arraySize);
|
||||
for (uint32_t item = 0; item < metadata.arraySize; ++item)
|
||||
{
|
||||
const Image* img = image.GetImage(level, item, 0);
|
||||
if (!img)
|
||||
{
|
||||
image.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
images.push_back(img);
|
||||
}
|
||||
|
||||
hr = Detile1D(xbox, level, computer.Get(), layout, &images[0], images.size());
|
||||
}
|
||||
else
|
||||
{
|
||||
const Image* img = image.GetImage(level, 0, 0);
|
||||
if (!img)
|
||||
{
|
||||
image.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
images.push_back(img);
|
||||
hr = Detile1D(xbox, level, computer.Get(), layout, &img, 1);
|
||||
}
|
||||
|
||||
hr = Detile1D(xbox, level, computer.Get(), layout, &images[0], images.size());
|
||||
}
|
||||
else
|
||||
{
|
||||
const Image* img = image.GetImage(level, 0, 0);
|
||||
if (!img)
|
||||
if (FAILED(hr))
|
||||
{
|
||||
image.Release();
|
||||
return E_FAIL;
|
||||
return hr;
|
||||
}
|
||||
|
||||
hr = Detile1D(xbox, level, computer.Get(), layout, &img, 1);
|
||||
}
|
||||
|
||||
if (FAILED(hr))
|
||||
{
|
||||
image.Release();
|
||||
return hr;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
case TEX_DIMENSION_TEXTURE2D:
|
||||
{
|
||||
XG_TEXTURE2D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.Height = static_cast<UINT>(metadata.height);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.ArraySize = static_cast<UINT>(metadata.arraySize);
|
||||
desc.Format = static_cast<XG_FORMAT>(metadata.format);
|
||||
desc.SampleDesc.Count = 1;
|
||||
desc.Usage = XG_USAGE_DEFAULT;
|
||||
desc.BindFlags = XG_BIND_SHADER_RESOURCE;
|
||||
desc.MiscFlags = (metadata.miscFlags & TEX_MISC_TEXTURECUBE) ? XG_RESOURCE_MISC_TEXTURECUBE : 0;
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
desc.SwizzleMode = xbox.GetTileMode();
|
||||
#else
|
||||
desc.TileMode = xbox.GetTileMode();
|
||||
#endif
|
||||
|
||||
ComPtr<XGTextureAddressComputer> computer;
|
||||
HRESULT hr = XGCreateTexture2DComputer(&desc, computer.GetAddressOf());
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
hr = computer->GetResourceLayout(&layout);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
if (layout.Planes != 1)
|
||||
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
|
||||
|
||||
if (layout.SizeBytes != xbox.GetSize()
|
||||
|| layout.BaseAlignmentBytes != xbox.GetAlignment())
|
||||
return E_UNEXPECTED;
|
||||
|
||||
hr = image.Initialize(metadata);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
for (uint32_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
if (metadata.arraySize > 1)
|
||||
XG_TEXTURE2D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.Height = static_cast<UINT>(metadata.height);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.ArraySize = static_cast<UINT>(metadata.arraySize);
|
||||
desc.Format = static_cast<XG_FORMAT>(metadata.format);
|
||||
desc.SampleDesc.Count = 1;
|
||||
desc.Usage = XG_USAGE_DEFAULT;
|
||||
desc.BindFlags = XG_BIND_SHADER_RESOURCE;
|
||||
desc.MiscFlags = (metadata.miscFlags & TEX_MISC_TEXTURECUBE) ? XG_RESOURCE_MISC_TEXTURECUBE : 0;
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
desc.SwizzleMode = xbox.GetTileMode();
|
||||
#else
|
||||
desc.TileMode = xbox.GetTileMode();
|
||||
#endif
|
||||
|
||||
ComPtr<XGTextureAddressComputer> computer;
|
||||
HRESULT hr = XGCreateTexture2DComputer(&desc, computer.GetAddressOf());
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
hr = computer->GetResourceLayout(&layout);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
if (layout.Planes != 1)
|
||||
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
|
||||
|
||||
if (layout.SizeBytes != xbox.GetSize()
|
||||
|| layout.BaseAlignmentBytes != xbox.GetAlignment())
|
||||
return E_UNEXPECTED;
|
||||
|
||||
hr = image.Initialize(metadata);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
for (uint32_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
std::vector<const Image*> images;
|
||||
images.reserve(metadata.arraySize);
|
||||
for (uint32_t item = 0; item < metadata.arraySize; ++item)
|
||||
if (metadata.arraySize > 1)
|
||||
{
|
||||
const Image* img = image.GetImage(level, item, 0);
|
||||
std::vector<const Image*> images;
|
||||
images.reserve(metadata.arraySize);
|
||||
for (uint32_t item = 0; item < metadata.arraySize; ++item)
|
||||
{
|
||||
const Image* img = image.GetImage(level, item, 0);
|
||||
if (!img)
|
||||
{
|
||||
image.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
images.push_back(img);
|
||||
}
|
||||
|
||||
hr = Detile2D(xbox, level, computer.Get(), layout, &images[0], images.size());
|
||||
}
|
||||
else
|
||||
{
|
||||
const Image* img = image.GetImage(level, 0, 0);
|
||||
if (!img)
|
||||
{
|
||||
image.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
images.push_back(img);
|
||||
hr = Detile2D(xbox, level, computer.Get(), layout, &img, 1);
|
||||
}
|
||||
|
||||
hr = Detile2D(xbox, level, computer.Get(), layout, &images[0], images.size());
|
||||
if (FAILED(hr))
|
||||
{
|
||||
image.Release();
|
||||
return hr;
|
||||
}
|
||||
}
|
||||
else
|
||||
}
|
||||
break;
|
||||
|
||||
case TEX_DIMENSION_TEXTURE3D:
|
||||
{
|
||||
XG_TEXTURE3D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.Height = static_cast<UINT>(metadata.height);
|
||||
desc.Depth = static_cast<UINT>(metadata.depth);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.Format = static_cast<XG_FORMAT>(metadata.format);
|
||||
desc.Usage = XG_USAGE_DEFAULT;
|
||||
desc.BindFlags = XG_BIND_SHADER_RESOURCE;
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
desc.SwizzleMode = xbox.GetTileMode();
|
||||
#else
|
||||
desc.TileMode = xbox.GetTileMode();
|
||||
#endif
|
||||
|
||||
ComPtr<XGTextureAddressComputer> computer;
|
||||
HRESULT hr = XGCreateTexture3DComputer(&desc, computer.GetAddressOf());
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
hr = computer->GetResourceLayout(&layout);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
if (layout.Planes != 1)
|
||||
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
|
||||
|
||||
if (layout.SizeBytes != xbox.GetSize()
|
||||
|| layout.BaseAlignmentBytes != xbox.GetAlignment())
|
||||
return E_UNEXPECTED;
|
||||
|
||||
hr = image.Initialize(metadata);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
uint32_t d = static_cast<uint32_t>(metadata.depth);
|
||||
|
||||
size_t index = 0;
|
||||
for (uint32_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
const Image* img = image.GetImage(level, 0, 0);
|
||||
if (!img)
|
||||
if ((index + d) > image.GetImageCount())
|
||||
{
|
||||
image.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
hr = Detile2D(xbox, level, computer.Get(), layout, &img, 1);
|
||||
}
|
||||
// Relies on the fact that slices are contiguous
|
||||
hr = Detile3D(xbox, level, d, computer.Get(), layout, image.GetImages()[index]);
|
||||
if (FAILED(hr))
|
||||
{
|
||||
image.Release();
|
||||
return hr;
|
||||
}
|
||||
|
||||
if (FAILED(hr))
|
||||
{
|
||||
image.Release();
|
||||
return hr;
|
||||
index += d;
|
||||
|
||||
if (d > 1)
|
||||
d >>= 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case TEX_DIMENSION_TEXTURE3D:
|
||||
{
|
||||
XG_TEXTURE3D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.Height = static_cast<UINT>(metadata.height);
|
||||
desc.Depth = static_cast<UINT>(metadata.depth);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.Format = static_cast<XG_FORMAT>(metadata.format);
|
||||
desc.Usage = XG_USAGE_DEFAULT;
|
||||
desc.BindFlags = XG_BIND_SHADER_RESOURCE;
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
desc.SwizzleMode = xbox.GetTileMode();
|
||||
#else
|
||||
desc.TileMode = xbox.GetTileMode();
|
||||
#endif
|
||||
|
||||
ComPtr<XGTextureAddressComputer> computer;
|
||||
HRESULT hr = XGCreateTexture3DComputer(&desc, computer.GetAddressOf());
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
hr = computer->GetResourceLayout(&layout);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
if (layout.Planes != 1)
|
||||
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
|
||||
|
||||
if (layout.SizeBytes != xbox.GetSize()
|
||||
|| layout.BaseAlignmentBytes != xbox.GetAlignment())
|
||||
return E_UNEXPECTED;
|
||||
|
||||
hr = image.Initialize(metadata);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
uint32_t d = static_cast<uint32_t>(metadata.depth);
|
||||
|
||||
size_t index = 0;
|
||||
for (uint32_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
if ((index + d) > image.GetImageCount())
|
||||
{
|
||||
image.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
// Relies on the fact that slices are contiguous
|
||||
hr = Detile3D(xbox, level, d, computer.Get(), layout, image.GetImages()[index]);
|
||||
if (FAILED(hr))
|
||||
{
|
||||
image.Release();
|
||||
return hr;
|
||||
}
|
||||
|
||||
index += d;
|
||||
|
||||
if (d > 1)
|
||||
d >>= 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
default:
|
||||
return E_FAIL;
|
||||
|
|
|
@ -14,128 +14,128 @@ using namespace DirectX;
|
|||
using namespace Xbox;
|
||||
|
||||
// Sanity check XG library values against DirectXTex's values
|
||||
static_assert(static_cast<int>(XG_FORMAT_UNKNOWN) == static_cast<int>(DXGI_FORMAT_UNKNOWN) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32B32A32_TYPELESS) == static_cast<int>(DXGI_FORMAT_R32G32B32A32_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32B32A32_FLOAT) == static_cast<int>(DXGI_FORMAT_R32G32B32A32_FLOAT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32B32A32_UINT) == static_cast<int>(DXGI_FORMAT_R32G32B32A32_UINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32B32A32_SINT) == static_cast<int>(DXGI_FORMAT_R32G32B32A32_SINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32B32_TYPELESS) == static_cast<int>(DXGI_FORMAT_R32G32B32_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32B32_FLOAT) == static_cast<int>(DXGI_FORMAT_R32G32B32_FLOAT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32B32_UINT) == static_cast<int>(DXGI_FORMAT_R32G32B32_UINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32B32_SINT) == static_cast<int>(DXGI_FORMAT_R32G32B32_SINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16B16A16_TYPELESS) == static_cast<int>(DXGI_FORMAT_R16G16B16A16_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16B16A16_FLOAT) == static_cast<int>(DXGI_FORMAT_R16G16B16A16_FLOAT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16B16A16_UNORM) == static_cast<int>(DXGI_FORMAT_R16G16B16A16_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16B16A16_UINT) == static_cast<int>(DXGI_FORMAT_R16G16B16A16_UINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16B16A16_SNORM) == static_cast<int>(DXGI_FORMAT_R16G16B16A16_SNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16B16A16_SINT) == static_cast<int>(DXGI_FORMAT_R16G16B16A16_SINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32_TYPELESS) == static_cast<int>(DXGI_FORMAT_R32G32_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32_FLOAT) == static_cast<int>(DXGI_FORMAT_R32G32_FLOAT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32_UINT) == static_cast<int>(DXGI_FORMAT_R32G32_UINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32_SINT) == static_cast<int>(DXGI_FORMAT_R32G32_SINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G8X24_TYPELESS) == static_cast<int>(DXGI_FORMAT_R32G8X24_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_D32_FLOAT_S8X24_UINT) == static_cast<int>(DXGI_FORMAT_D32_FLOAT_S8X24_UINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32_FLOAT_X8X24_TYPELESS) == static_cast<int>(DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_X32_TYPELESS_G8X24_UINT) == static_cast<int>(DXGI_FORMAT_X32_TYPELESS_G8X24_UINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R10G10B10A2_TYPELESS) == static_cast<int>(DXGI_FORMAT_R10G10B10A2_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R10G10B10A2_UNORM) == static_cast<int>(DXGI_FORMAT_R10G10B10A2_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R10G10B10A2_UINT) == static_cast<int>(DXGI_FORMAT_R10G10B10A2_UINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R11G11B10_FLOAT) == static_cast<int>(DXGI_FORMAT_R11G11B10_FLOAT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8B8A8_TYPELESS) == static_cast<int>(DXGI_FORMAT_R8G8B8A8_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8B8A8_UNORM) == static_cast<int>(DXGI_FORMAT_R8G8B8A8_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8B8A8_UNORM_SRGB) == static_cast<int>(DXGI_FORMAT_R8G8B8A8_UNORM_SRGB) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8B8A8_UINT) == static_cast<int>(DXGI_FORMAT_R8G8B8A8_UINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8B8A8_SNORM) == static_cast<int>(DXGI_FORMAT_R8G8B8A8_SNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8B8A8_SINT) == static_cast<int>(DXGI_FORMAT_R8G8B8A8_SINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16_TYPELESS) == static_cast<int>(DXGI_FORMAT_R16G16_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16_FLOAT) == static_cast<int>(DXGI_FORMAT_R16G16_FLOAT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16_UNORM) == static_cast<int>(DXGI_FORMAT_R16G16_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16_UINT) == static_cast<int>(DXGI_FORMAT_R16G16_UINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16_SNORM) == static_cast<int>(DXGI_FORMAT_R16G16_SNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16_SINT) == static_cast<int>(DXGI_FORMAT_R16G16_SINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32_TYPELESS) == static_cast<int>(DXGI_FORMAT_R32_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_D32_FLOAT) == static_cast<int>(DXGI_FORMAT_D32_FLOAT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32_FLOAT) == static_cast<int>(DXGI_FORMAT_R32_FLOAT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32_UINT) == static_cast<int>(DXGI_FORMAT_R32_UINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32_SINT) == static_cast<int>(DXGI_FORMAT_R32_SINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R24G8_TYPELESS) == static_cast<int>(DXGI_FORMAT_R24G8_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_D24_UNORM_S8_UINT) == static_cast<int>(DXGI_FORMAT_D24_UNORM_S8_UINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R24_UNORM_X8_TYPELESS) == static_cast<int>(DXGI_FORMAT_R24_UNORM_X8_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_X24_TYPELESS_G8_UINT) == static_cast<int>(DXGI_FORMAT_X24_TYPELESS_G8_UINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8_TYPELESS) == static_cast<int>(DXGI_FORMAT_R8G8_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8_UNORM) == static_cast<int>(DXGI_FORMAT_R8G8_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8_UINT) == static_cast<int>(DXGI_FORMAT_R8G8_UINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8_SNORM) == static_cast<int>(DXGI_FORMAT_R8G8_SNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8_SINT) == static_cast<int>(DXGI_FORMAT_R8G8_SINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16_TYPELESS) == static_cast<int>(DXGI_FORMAT_R16_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16_FLOAT) == static_cast<int>(DXGI_FORMAT_R16_FLOAT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_D16_UNORM) == static_cast<int>(DXGI_FORMAT_D16_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16_UNORM) == static_cast<int>(DXGI_FORMAT_R16_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16_UINT) == static_cast<int>(DXGI_FORMAT_R16_UINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16_SNORM) == static_cast<int>(DXGI_FORMAT_R16_SNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16_SINT) == static_cast<int>(DXGI_FORMAT_R16_SINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8_TYPELESS) == static_cast<int>(DXGI_FORMAT_R8_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8_UNORM) == static_cast<int>(DXGI_FORMAT_R8_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8_UINT) == static_cast<int>(DXGI_FORMAT_R8_UINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8_SNORM) == static_cast<int>(DXGI_FORMAT_R8_SNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8_SINT) == static_cast<int>(DXGI_FORMAT_R8_SINT) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_A8_UNORM) == static_cast<int>(DXGI_FORMAT_A8_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R1_UNORM) == static_cast<int>(DXGI_FORMAT_R1_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R9G9B9E5_SHAREDEXP) == static_cast<int>(DXGI_FORMAT_R9G9B9E5_SHAREDEXP) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8_B8G8_UNORM) == static_cast<int>(DXGI_FORMAT_R8G8_B8G8_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_G8R8_G8B8_UNORM) == static_cast<int>(DXGI_FORMAT_G8R8_G8B8_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC1_TYPELESS) == static_cast<int>(DXGI_FORMAT_BC1_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC1_UNORM) == static_cast<int>(DXGI_FORMAT_BC1_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC1_UNORM_SRGB) == static_cast<int>(DXGI_FORMAT_BC1_UNORM_SRGB) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC2_TYPELESS) == static_cast<int>(DXGI_FORMAT_BC2_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC2_UNORM) == static_cast<int>(DXGI_FORMAT_BC2_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC2_UNORM_SRGB) == static_cast<int>(DXGI_FORMAT_BC2_UNORM_SRGB) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC3_TYPELESS) == static_cast<int>(DXGI_FORMAT_BC3_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC3_UNORM) == static_cast<int>(DXGI_FORMAT_BC3_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC3_UNORM_SRGB) == static_cast<int>(DXGI_FORMAT_BC3_UNORM_SRGB) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC4_TYPELESS) == static_cast<int>(DXGI_FORMAT_BC4_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC4_UNORM) == static_cast<int>(DXGI_FORMAT_BC4_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC4_SNORM) == static_cast<int>(DXGI_FORMAT_BC4_SNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC5_TYPELESS) == static_cast<int>(DXGI_FORMAT_BC5_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC5_UNORM) == static_cast<int>(DXGI_FORMAT_BC5_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC5_SNORM) == static_cast<int>(DXGI_FORMAT_BC5_SNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_B5G6R5_UNORM) == static_cast<int>(DXGI_FORMAT_B5G6R5_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_B5G5R5A1_UNORM) == static_cast<int>(DXGI_FORMAT_B5G5R5A1_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_B8G8R8A8_UNORM) == static_cast<int>(DXGI_FORMAT_B8G8R8A8_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_B8G8R8X8_UNORM) == static_cast<int>(DXGI_FORMAT_B8G8R8X8_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R10G10B10_XR_BIAS_A2_UNORM) == static_cast<int>(DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_B8G8R8A8_TYPELESS) == static_cast<int>(DXGI_FORMAT_B8G8R8A8_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_B8G8R8A8_UNORM_SRGB) == static_cast<int>(DXGI_FORMAT_B8G8R8A8_UNORM_SRGB) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_B8G8R8X8_TYPELESS) == static_cast<int>(DXGI_FORMAT_B8G8R8X8_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_B8G8R8X8_UNORM_SRGB) == static_cast<int>(DXGI_FORMAT_B8G8R8X8_UNORM_SRGB) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC6H_TYPELESS) == static_cast<int>(DXGI_FORMAT_BC6H_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC6H_UF16) == static_cast<int>(DXGI_FORMAT_BC6H_UF16) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC6H_SF16) == static_cast<int>(DXGI_FORMAT_BC6H_SF16) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC7_TYPELESS) == static_cast<int>(DXGI_FORMAT_BC7_TYPELESS) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC7_UNORM) == static_cast<int>(DXGI_FORMAT_BC7_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC7_UNORM_SRGB) == static_cast<int>(DXGI_FORMAT_BC7_UNORM_SRGB) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_AYUV) == static_cast<int>(DXGI_FORMAT_AYUV) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_Y410) == static_cast<int>(DXGI_FORMAT_Y410) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_Y416) == static_cast<int>(DXGI_FORMAT_Y416) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_NV12) == static_cast<int>(DXGI_FORMAT_NV12) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_P010) == static_cast<int>(DXGI_FORMAT_P010) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_P016) == static_cast<int>(DXGI_FORMAT_P016) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_420_OPAQUE) == static_cast<int>(DXGI_FORMAT_420_OPAQUE) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_YUY2) == static_cast<int>(DXGI_FORMAT_YUY2) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_Y210) == static_cast<int>(DXGI_FORMAT_Y210) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_Y216) == static_cast<int>(DXGI_FORMAT_Y216) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_NV11) == static_cast<int>(DXGI_FORMAT_NV11) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_AI44) == static_cast<int>(DXGI_FORMAT_AI44) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_IA44) == static_cast<int>(DXGI_FORMAT_IA44) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_P8) == static_cast<int>(DXGI_FORMAT_P8) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_A8P8) == static_cast<int>(DXGI_FORMAT_A8P8) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_B4G4R4A4_UNORM) == static_cast<int>(DXGI_FORMAT_B4G4R4A4_UNORM) , "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_UNKNOWN) == static_cast<int>(DXGI_FORMAT_UNKNOWN), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32B32A32_TYPELESS) == static_cast<int>(DXGI_FORMAT_R32G32B32A32_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32B32A32_FLOAT) == static_cast<int>(DXGI_FORMAT_R32G32B32A32_FLOAT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32B32A32_UINT) == static_cast<int>(DXGI_FORMAT_R32G32B32A32_UINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32B32A32_SINT) == static_cast<int>(DXGI_FORMAT_R32G32B32A32_SINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32B32_TYPELESS) == static_cast<int>(DXGI_FORMAT_R32G32B32_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32B32_FLOAT) == static_cast<int>(DXGI_FORMAT_R32G32B32_FLOAT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32B32_UINT) == static_cast<int>(DXGI_FORMAT_R32G32B32_UINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32B32_SINT) == static_cast<int>(DXGI_FORMAT_R32G32B32_SINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16B16A16_TYPELESS) == static_cast<int>(DXGI_FORMAT_R16G16B16A16_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16B16A16_FLOAT) == static_cast<int>(DXGI_FORMAT_R16G16B16A16_FLOAT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16B16A16_UNORM) == static_cast<int>(DXGI_FORMAT_R16G16B16A16_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16B16A16_UINT) == static_cast<int>(DXGI_FORMAT_R16G16B16A16_UINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16B16A16_SNORM) == static_cast<int>(DXGI_FORMAT_R16G16B16A16_SNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16B16A16_SINT) == static_cast<int>(DXGI_FORMAT_R16G16B16A16_SINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32_TYPELESS) == static_cast<int>(DXGI_FORMAT_R32G32_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32_FLOAT) == static_cast<int>(DXGI_FORMAT_R32G32_FLOAT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32_UINT) == static_cast<int>(DXGI_FORMAT_R32G32_UINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G32_SINT) == static_cast<int>(DXGI_FORMAT_R32G32_SINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32G8X24_TYPELESS) == static_cast<int>(DXGI_FORMAT_R32G8X24_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_D32_FLOAT_S8X24_UINT) == static_cast<int>(DXGI_FORMAT_D32_FLOAT_S8X24_UINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32_FLOAT_X8X24_TYPELESS) == static_cast<int>(DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_X32_TYPELESS_G8X24_UINT) == static_cast<int>(DXGI_FORMAT_X32_TYPELESS_G8X24_UINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R10G10B10A2_TYPELESS) == static_cast<int>(DXGI_FORMAT_R10G10B10A2_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R10G10B10A2_UNORM) == static_cast<int>(DXGI_FORMAT_R10G10B10A2_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R10G10B10A2_UINT) == static_cast<int>(DXGI_FORMAT_R10G10B10A2_UINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R11G11B10_FLOAT) == static_cast<int>(DXGI_FORMAT_R11G11B10_FLOAT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8B8A8_TYPELESS) == static_cast<int>(DXGI_FORMAT_R8G8B8A8_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8B8A8_UNORM) == static_cast<int>(DXGI_FORMAT_R8G8B8A8_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8B8A8_UNORM_SRGB) == static_cast<int>(DXGI_FORMAT_R8G8B8A8_UNORM_SRGB), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8B8A8_UINT) == static_cast<int>(DXGI_FORMAT_R8G8B8A8_UINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8B8A8_SNORM) == static_cast<int>(DXGI_FORMAT_R8G8B8A8_SNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8B8A8_SINT) == static_cast<int>(DXGI_FORMAT_R8G8B8A8_SINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16_TYPELESS) == static_cast<int>(DXGI_FORMAT_R16G16_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16_FLOAT) == static_cast<int>(DXGI_FORMAT_R16G16_FLOAT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16_UNORM) == static_cast<int>(DXGI_FORMAT_R16G16_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16_UINT) == static_cast<int>(DXGI_FORMAT_R16G16_UINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16_SNORM) == static_cast<int>(DXGI_FORMAT_R16G16_SNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16G16_SINT) == static_cast<int>(DXGI_FORMAT_R16G16_SINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32_TYPELESS) == static_cast<int>(DXGI_FORMAT_R32_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_D32_FLOAT) == static_cast<int>(DXGI_FORMAT_D32_FLOAT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32_FLOAT) == static_cast<int>(DXGI_FORMAT_R32_FLOAT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32_UINT) == static_cast<int>(DXGI_FORMAT_R32_UINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R32_SINT) == static_cast<int>(DXGI_FORMAT_R32_SINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R24G8_TYPELESS) == static_cast<int>(DXGI_FORMAT_R24G8_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_D24_UNORM_S8_UINT) == static_cast<int>(DXGI_FORMAT_D24_UNORM_S8_UINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R24_UNORM_X8_TYPELESS) == static_cast<int>(DXGI_FORMAT_R24_UNORM_X8_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_X24_TYPELESS_G8_UINT) == static_cast<int>(DXGI_FORMAT_X24_TYPELESS_G8_UINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8_TYPELESS) == static_cast<int>(DXGI_FORMAT_R8G8_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8_UNORM) == static_cast<int>(DXGI_FORMAT_R8G8_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8_UINT) == static_cast<int>(DXGI_FORMAT_R8G8_UINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8_SNORM) == static_cast<int>(DXGI_FORMAT_R8G8_SNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8_SINT) == static_cast<int>(DXGI_FORMAT_R8G8_SINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16_TYPELESS) == static_cast<int>(DXGI_FORMAT_R16_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16_FLOAT) == static_cast<int>(DXGI_FORMAT_R16_FLOAT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_D16_UNORM) == static_cast<int>(DXGI_FORMAT_D16_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16_UNORM) == static_cast<int>(DXGI_FORMAT_R16_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16_UINT) == static_cast<int>(DXGI_FORMAT_R16_UINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16_SNORM) == static_cast<int>(DXGI_FORMAT_R16_SNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R16_SINT) == static_cast<int>(DXGI_FORMAT_R16_SINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8_TYPELESS) == static_cast<int>(DXGI_FORMAT_R8_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8_UNORM) == static_cast<int>(DXGI_FORMAT_R8_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8_UINT) == static_cast<int>(DXGI_FORMAT_R8_UINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8_SNORM) == static_cast<int>(DXGI_FORMAT_R8_SNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8_SINT) == static_cast<int>(DXGI_FORMAT_R8_SINT), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_A8_UNORM) == static_cast<int>(DXGI_FORMAT_A8_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R1_UNORM) == static_cast<int>(DXGI_FORMAT_R1_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R9G9B9E5_SHAREDEXP) == static_cast<int>(DXGI_FORMAT_R9G9B9E5_SHAREDEXP), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R8G8_B8G8_UNORM) == static_cast<int>(DXGI_FORMAT_R8G8_B8G8_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_G8R8_G8B8_UNORM) == static_cast<int>(DXGI_FORMAT_G8R8_G8B8_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC1_TYPELESS) == static_cast<int>(DXGI_FORMAT_BC1_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC1_UNORM) == static_cast<int>(DXGI_FORMAT_BC1_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC1_UNORM_SRGB) == static_cast<int>(DXGI_FORMAT_BC1_UNORM_SRGB), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC2_TYPELESS) == static_cast<int>(DXGI_FORMAT_BC2_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC2_UNORM) == static_cast<int>(DXGI_FORMAT_BC2_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC2_UNORM_SRGB) == static_cast<int>(DXGI_FORMAT_BC2_UNORM_SRGB), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC3_TYPELESS) == static_cast<int>(DXGI_FORMAT_BC3_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC3_UNORM) == static_cast<int>(DXGI_FORMAT_BC3_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC3_UNORM_SRGB) == static_cast<int>(DXGI_FORMAT_BC3_UNORM_SRGB), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC4_TYPELESS) == static_cast<int>(DXGI_FORMAT_BC4_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC4_UNORM) == static_cast<int>(DXGI_FORMAT_BC4_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC4_SNORM) == static_cast<int>(DXGI_FORMAT_BC4_SNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC5_TYPELESS) == static_cast<int>(DXGI_FORMAT_BC5_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC5_UNORM) == static_cast<int>(DXGI_FORMAT_BC5_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC5_SNORM) == static_cast<int>(DXGI_FORMAT_BC5_SNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_B5G6R5_UNORM) == static_cast<int>(DXGI_FORMAT_B5G6R5_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_B5G5R5A1_UNORM) == static_cast<int>(DXGI_FORMAT_B5G5R5A1_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_B8G8R8A8_UNORM) == static_cast<int>(DXGI_FORMAT_B8G8R8A8_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_B8G8R8X8_UNORM) == static_cast<int>(DXGI_FORMAT_B8G8R8X8_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_R10G10B10_XR_BIAS_A2_UNORM) == static_cast<int>(DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_B8G8R8A8_TYPELESS) == static_cast<int>(DXGI_FORMAT_B8G8R8A8_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_B8G8R8A8_UNORM_SRGB) == static_cast<int>(DXGI_FORMAT_B8G8R8A8_UNORM_SRGB), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_B8G8R8X8_TYPELESS) == static_cast<int>(DXGI_FORMAT_B8G8R8X8_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_B8G8R8X8_UNORM_SRGB) == static_cast<int>(DXGI_FORMAT_B8G8R8X8_UNORM_SRGB), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC6H_TYPELESS) == static_cast<int>(DXGI_FORMAT_BC6H_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC6H_UF16) == static_cast<int>(DXGI_FORMAT_BC6H_UF16), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC6H_SF16) == static_cast<int>(DXGI_FORMAT_BC6H_SF16), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC7_TYPELESS) == static_cast<int>(DXGI_FORMAT_BC7_TYPELESS), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC7_UNORM) == static_cast<int>(DXGI_FORMAT_BC7_UNORM), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_BC7_UNORM_SRGB) == static_cast<int>(DXGI_FORMAT_BC7_UNORM_SRGB), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_AYUV) == static_cast<int>(DXGI_FORMAT_AYUV), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_Y410) == static_cast<int>(DXGI_FORMAT_Y410), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_Y416) == static_cast<int>(DXGI_FORMAT_Y416), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_NV12) == static_cast<int>(DXGI_FORMAT_NV12), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_P010) == static_cast<int>(DXGI_FORMAT_P010), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_P016) == static_cast<int>(DXGI_FORMAT_P016), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_420_OPAQUE) == static_cast<int>(DXGI_FORMAT_420_OPAQUE), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_YUY2) == static_cast<int>(DXGI_FORMAT_YUY2), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_Y210) == static_cast<int>(DXGI_FORMAT_Y210), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_Y216) == static_cast<int>(DXGI_FORMAT_Y216), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_NV11) == static_cast<int>(DXGI_FORMAT_NV11), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_AI44) == static_cast<int>(DXGI_FORMAT_AI44), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_IA44) == static_cast<int>(DXGI_FORMAT_IA44), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_P8) == static_cast<int>(DXGI_FORMAT_P8), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_A8P8) == static_cast<int>(DXGI_FORMAT_A8P8), "XG vs. DXGI mismatch");
|
||||
static_assert(static_cast<int>(XG_FORMAT_B4G4R4A4_UNORM) == static_cast<int>(DXGI_FORMAT_B4G4R4A4_UNORM), "XG vs. DXGI mismatch");
|
||||
|
||||
static_assert(static_cast<int>(XG_RESOURCE_DIMENSION_TEXTURE1D) == static_cast<int>(TEX_DIMENSION_TEXTURE1D), "XG vs. Direct3D 11 mismatch");
|
||||
static_assert(static_cast<int>(XG_RESOURCE_DIMENSION_TEXTURE2D) == static_cast<int>(TEX_DIMENSION_TEXTURE2D), "XG vs. Direct3D 11 mismatch");
|
||||
static_assert(static_cast<int>(XG_RESOURCE_DIMENSION_TEXTURE3D) == static_cast<int>(TEX_DIMENSION_TEXTURE3D), "XG vs. Direct3D 11 mismatch");
|
||||
|
||||
static_assert(static_cast<int>(XG_RESOURCE_MISC_TEXTURECUBE) == static_cast<int>(TEX_MISC_TEXTURECUBE), "XG vs. Direct3D 11 mismatch" );
|
||||
static_assert(static_cast<int>(XG_RESOURCE_MISC_TEXTURECUBE) == static_cast<int>(TEX_MISC_TEXTURECUBE), "XG vs. Direct3D 11 mismatch");
|
||||
|
||||
//--------------------------------------------------------------------------------------
|
||||
// Initialize memory
|
||||
|
|
|
@ -50,12 +50,12 @@ namespace
|
|||
|
||||
for (size_t x = 0; x < w; ++x)
|
||||
{
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
UINT64 element = (packed) ? (x >> 1) : x;
|
||||
size_t offset = computer->GetTexelElementOffsetBytes(0, level, element, 0, item, 0, nullptr);
|
||||
#else
|
||||
#else
|
||||
size_t offset = computer->GetTexelElementOffsetBytes(0, level, x, 0, item, 0);
|
||||
#endif
|
||||
#endif
|
||||
if (offset == size_t(-1))
|
||||
return E_FAIL;
|
||||
|
||||
|
@ -110,12 +110,12 @@ namespace
|
|||
|
||||
for (size_t x = 0; x < w; ++x)
|
||||
{
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
UINT64 element = (packed) ? (x >> 1) : x;
|
||||
size_t offset = computer->GetTexelElementOffsetBytes(0, level, element, y, item, 0, nullptr);
|
||||
#else
|
||||
#else
|
||||
size_t offset = computer->GetTexelElementOffsetBytes(0, level, x, y, item, 0);
|
||||
#endif
|
||||
#endif
|
||||
if (offset == size_t(-1))
|
||||
return E_FAIL;
|
||||
|
||||
|
@ -165,12 +165,12 @@ namespace
|
|||
|
||||
for (size_t x = 0; x < w; ++x)
|
||||
{
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
UINT64 element = (packed) ? (x >> 1) : x;
|
||||
size_t offset = computer->GetTexelElementOffsetBytes(0, level, element, y, z, 0, nullptr);
|
||||
#else
|
||||
#else
|
||||
size_t offset = computer->GetTexelElementOffsetBytes(0, level, x, y, z, 0);
|
||||
#endif
|
||||
#endif
|
||||
if (offset == size_t(-1))
|
||||
return E_FAIL;
|
||||
|
||||
|
@ -202,11 +202,11 @@ namespace
|
|||
wchar_t buff[2048] = {};
|
||||
swprintf_s(buff, L"XG_TEXTURE1D_DESC = { %u, %u, %u, %u, %u, %u, %u, %u, %u, %u }\n",
|
||||
desc.Width, desc.MipLevels, desc.ArraySize, desc.Format, desc.Usage, desc.BindFlags, desc.CPUAccessFlags, desc.MiscFlags,
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
desc.SwizzleMode,
|
||||
#else
|
||||
#else
|
||||
desc.TileMode,
|
||||
#endif
|
||||
#endif
|
||||
desc.Pitch);
|
||||
OutputDebugStringW(buff);
|
||||
}
|
||||
|
@ -216,11 +216,11 @@ namespace
|
|||
wchar_t buff[2048] = {};
|
||||
swprintf_s(buff, L"XG_TEXTURE2D_DESC = { %u, %u, %u, %u, %u, { %u, %u }, %u, %u, %u, %u, %u, %u }\n",
|
||||
desc.Width, desc.Height, desc.MipLevels, desc.ArraySize, desc.Format, desc.SampleDesc.Count, desc.SampleDesc.Quality, desc.Usage, desc.BindFlags, desc.CPUAccessFlags, desc.MiscFlags,
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
desc.SwizzleMode,
|
||||
#else
|
||||
#else
|
||||
desc.TileMode,
|
||||
#endif
|
||||
#endif
|
||||
desc.Pitch);
|
||||
OutputDebugStringW(buff);
|
||||
}
|
||||
|
@ -230,11 +230,11 @@ namespace
|
|||
wchar_t buff[2048] = {};
|
||||
swprintf_s(buff, L"XG_TEXTURE3D_DESC = { %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u }\n",
|
||||
desc.Width, desc.Height, desc.Depth, desc.MipLevels, desc.Format, desc.Usage, desc.BindFlags, desc.CPUAccessFlags, desc.MiscFlags,
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
desc.SwizzleMode,
|
||||
#else
|
||||
#else
|
||||
desc.TileMode,
|
||||
#endif
|
||||
#endif
|
||||
desc.Pitch);
|
||||
OutputDebugStringW(buff);
|
||||
}
|
||||
|
@ -267,11 +267,11 @@ namespace
|
|||
swprintf_s(buff, L"\t\tpitch %u pixels (%u bytes)\n", mip.PitchPixels, mip.PitchBytes);
|
||||
OutputDebugStringW(buff);
|
||||
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
swprintf_s(buff, L"\t\t\t%u samples, %u swizzlemode\n", mip.SampleCount, mip.SwizzleMode);
|
||||
#else
|
||||
#else
|
||||
swprintf_s(buff, L"\t\t\t%u samples, %u tilemode\n", mip.SampleCount, mip.TileMode);
|
||||
#endif
|
||||
#endif
|
||||
OutputDebugStringW(buff);
|
||||
}
|
||||
}
|
||||
|
@ -304,10 +304,10 @@ namespace
|
|||
assert(!IsCompressed(format));
|
||||
|
||||
bool byelement = IsTypeless(format);
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
if (nimages > 1)
|
||||
byelement = true;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if (IsPacked(format))
|
||||
{
|
||||
|
@ -343,9 +343,9 @@ namespace
|
|||
XMVECTOR* row = scanline.get();
|
||||
XMVECTOR* tiled = row + images[0]->width;
|
||||
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
memset(row, 0xCD, sizeof(XMVECTOR) * images[0]->width);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
memset(tiled, 0, sizeof(XMVECTOR) * tiledPixels);
|
||||
|
||||
|
@ -367,11 +367,11 @@ namespace
|
|||
|
||||
for (size_t x = 0; x < img->width; ++x)
|
||||
{
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
size_t offset = computer->GetTexelElementOffsetBytes(0, level, x, 0, item, 0, nullptr);
|
||||
#else
|
||||
#else
|
||||
size_t offset = computer->GetTexelElementOffsetBytes(0, level, x, 0, item, 0);
|
||||
#endif
|
||||
#endif
|
||||
if (offset == size_t(-1))
|
||||
return E_FAIL;
|
||||
|
||||
|
@ -419,10 +419,10 @@ namespace
|
|||
assert(format == xbox.GetMetadata().format);
|
||||
|
||||
bool byelement = IsTypeless(format);
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
if (nimages > 1)
|
||||
byelement = true;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if (IsCompressed(format))
|
||||
{
|
||||
|
@ -482,9 +482,9 @@ namespace
|
|||
XMVECTOR* row = scanline.get();
|
||||
XMVECTOR* tiled = row + images[0]->width;
|
||||
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
memset(row, 0xCD, sizeof(XMVECTOR) * images[0]->width);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
memset(tiled, 0, sizeof(XMVECTOR) * tiledPixels);
|
||||
|
||||
|
@ -511,11 +511,11 @@ namespace
|
|||
|
||||
for (size_t x = 0; x < img->width; ++x)
|
||||
{
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
size_t offset = computer->GetTexelElementOffsetBytes(0, level, x, y, item, 0, nullptr);
|
||||
#else
|
||||
#else
|
||||
size_t offset = computer->GetTexelElementOffsetBytes(0, level, x, y, item, 0);
|
||||
#endif
|
||||
#endif
|
||||
if (offset == size_t(-1))
|
||||
return E_FAIL;
|
||||
|
||||
|
@ -560,11 +560,11 @@ namespace
|
|||
|
||||
assert(image.format == xbox.GetMetadata().format);
|
||||
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
const bool byelement = true;
|
||||
#else
|
||||
#else
|
||||
const bool byelement = IsTypeless(image.format);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if (IsCompressed(image.format))
|
||||
{
|
||||
|
@ -620,9 +620,9 @@ namespace
|
|||
XMVECTOR* row = scanline.get();
|
||||
XMVECTOR* tiled = row + image.width;
|
||||
|
||||
#ifdef _DEBUG
|
||||
#ifdef _DEBUG
|
||||
memset(row, 0xCD, sizeof(XMVECTOR) * image.width);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
memset(tiled, 0, sizeof(XMVECTOR) * tiledPixels);
|
||||
|
||||
|
@ -641,11 +641,11 @@ namespace
|
|||
|
||||
for (size_t x = 0; x < image.width; ++x)
|
||||
{
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
size_t offset = computer->GetTexelElementOffsetBytes(0, level, x, y, z, 0, nullptr);
|
||||
#else
|
||||
#else
|
||||
size_t offset = computer->GetTexelElementOffsetBytes(0, level, x, y, z, 0);
|
||||
#endif
|
||||
#endif
|
||||
if (offset == size_t(-1))
|
||||
return E_FAIL;
|
||||
|
||||
|
@ -722,15 +722,15 @@ HRESULT Xbox::Tile(
|
|||
if (mode == c_XboxTileModeInvalid)
|
||||
{
|
||||
// If no specific tile mode is given, assume the optimal default
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
mode = XGComputeOptimalSwizzleMode(XG_RESOURCE_DIMENSION_TEXTURE2D, static_cast<XG_FORMAT>(srcImage.format),
|
||||
static_cast<UINT>(srcImage.width), static_cast<UINT>(srcImage.height),
|
||||
1, 1, XG_BIND_SHADER_RESOURCE);
|
||||
#else
|
||||
#else
|
||||
mode = XGComputeOptimalTileMode(XG_RESOURCE_DIMENSION_TEXTURE2D, static_cast<XG_FORMAT>(srcImage.format),
|
||||
static_cast<UINT>(srcImage.width), static_cast<UINT>(srcImage.height),
|
||||
1, 1, XG_BIND_SHADER_RESOURCE);
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
XG_TEXTURE2D_DESC desc = {};
|
||||
|
@ -819,18 +819,18 @@ HRESULT Xbox::Tile(
|
|||
|
||||
if (mode == c_XboxTileModeInvalid)
|
||||
{
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
mode = XGComputeOptimalSwizzleMode(static_cast<XG_RESOURCE_DIMENSION>(metadata.dimension), static_cast<XG_FORMAT>(metadata.format),
|
||||
static_cast<UINT>(metadata.width), static_cast<UINT>(metadata.height),
|
||||
static_cast<UINT>((metadata.dimension == TEX_DIMENSION_TEXTURE3D) ? metadata.depth : metadata.arraySize),
|
||||
1, XG_BIND_SHADER_RESOURCE);
|
||||
#else
|
||||
// If no specific tile mode is given, assume the optimal default
|
||||
#else
|
||||
// If no specific tile mode is given, assume the optimal default
|
||||
mode = XGComputeOptimalTileMode(static_cast<XG_RESOURCE_DIMENSION>(metadata.dimension), static_cast<XG_FORMAT>(metadata.format),
|
||||
static_cast<UINT>(metadata.width), static_cast<UINT>(metadata.height),
|
||||
static_cast<UINT>((metadata.dimension == TEX_DIMENSION_TEXTURE3D) ? metadata.depth : metadata.arraySize),
|
||||
1, XG_BIND_SHADER_RESOURCE);
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
XG_RESOURCE_LAYOUT layout = {};
|
||||
|
@ -838,237 +838,237 @@ HRESULT Xbox::Tile(
|
|||
switch (metadata.dimension)
|
||||
{
|
||||
case TEX_DIMENSION_TEXTURE1D:
|
||||
{
|
||||
XG_TEXTURE1D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.ArraySize = static_cast<UINT>(metadata.arraySize);
|
||||
desc.Format = static_cast<XG_FORMAT>(metadata.format);
|
||||
desc.Usage = XG_USAGE_DEFAULT;
|
||||
desc.BindFlags = XG_BIND_SHADER_RESOURCE;
|
||||
desc.MiscFlags = (metadata.IsCubemap()) ? XG_RESOURCE_MISC_TEXTURECUBE : 0;
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
desc.SwizzleMode = mode;
|
||||
#else
|
||||
desc.TileMode = mode;
|
||||
#endif
|
||||
|
||||
#ifdef VERBOSE
|
||||
DebugPrintDesc(desc);
|
||||
#endif
|
||||
|
||||
ComPtr<XGTextureAddressComputer> computer;
|
||||
HRESULT hr = XGCreateTexture1DComputer(&desc, computer.GetAddressOf());
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
hr = computer->GetResourceLayout(&layout);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
#ifdef VERBOSE
|
||||
DebugPrintLayout(layout);
|
||||
#endif
|
||||
|
||||
if (layout.Planes != 1)
|
||||
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
|
||||
|
||||
hr = xbox.Initialize(desc, layout, metadata.miscFlags2);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
for (uint32_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
if (metadata.arraySize > 1)
|
||||
XG_TEXTURE1D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.ArraySize = static_cast<UINT>(metadata.arraySize);
|
||||
desc.Format = static_cast<XG_FORMAT>(metadata.format);
|
||||
desc.Usage = XG_USAGE_DEFAULT;
|
||||
desc.BindFlags = XG_BIND_SHADER_RESOURCE;
|
||||
desc.MiscFlags = (metadata.IsCubemap()) ? XG_RESOURCE_MISC_TEXTURECUBE : 0;
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
desc.SwizzleMode = mode;
|
||||
#else
|
||||
desc.TileMode = mode;
|
||||
#endif
|
||||
|
||||
#ifdef VERBOSE
|
||||
DebugPrintDesc(desc);
|
||||
#endif
|
||||
|
||||
ComPtr<XGTextureAddressComputer> computer;
|
||||
HRESULT hr = XGCreateTexture1DComputer(&desc, computer.GetAddressOf());
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
hr = computer->GetResourceLayout(&layout);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
#ifdef VERBOSE
|
||||
DebugPrintLayout(layout);
|
||||
#endif
|
||||
|
||||
if (layout.Planes != 1)
|
||||
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
|
||||
|
||||
hr = xbox.Initialize(desc, layout, metadata.miscFlags2);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
for (uint32_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
std::vector<const Image*> images;
|
||||
images.reserve(metadata.arraySize);
|
||||
for (uint32_t item = 0; item < metadata.arraySize; ++item)
|
||||
if (metadata.arraySize > 1)
|
||||
{
|
||||
const size_t index = metadata.ComputeIndex(level, item, 0);
|
||||
std::vector<const Image*> images;
|
||||
images.reserve(metadata.arraySize);
|
||||
for (uint32_t item = 0; item < metadata.arraySize; ++item)
|
||||
{
|
||||
const size_t index = metadata.ComputeIndex(level, item, 0);
|
||||
if (index >= nimages)
|
||||
{
|
||||
xbox.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
images.push_back(&srcImages[index]);
|
||||
}
|
||||
|
||||
hr = Tile1D(&images[0], images.size(), level, computer.Get(), layout, xbox);
|
||||
}
|
||||
else
|
||||
{
|
||||
const size_t index = metadata.ComputeIndex(level, 0, 0);
|
||||
if (index >= nimages)
|
||||
{
|
||||
xbox.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
images.push_back(&srcImages[index]);
|
||||
const Image* images = &srcImages[index];
|
||||
hr = Tile1D(&images, 1, level, computer.Get(), layout, xbox);
|
||||
}
|
||||
|
||||
hr = Tile1D(&images[0], images.size(), level, computer.Get(), layout, xbox);
|
||||
}
|
||||
else
|
||||
{
|
||||
const size_t index = metadata.ComputeIndex(level, 0, 0);
|
||||
if (index >= nimages)
|
||||
if (FAILED(hr))
|
||||
{
|
||||
xbox.Release();
|
||||
return E_FAIL;
|
||||
return hr;
|
||||
}
|
||||
|
||||
const Image* images = &srcImages[index];
|
||||
hr = Tile1D(&images, 1, level, computer.Get(), layout, xbox);
|
||||
}
|
||||
|
||||
if (FAILED(hr))
|
||||
{
|
||||
xbox.Release();
|
||||
return hr;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
case TEX_DIMENSION_TEXTURE2D:
|
||||
{
|
||||
XG_TEXTURE2D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.Height = static_cast<UINT>(metadata.height);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.ArraySize = static_cast<UINT>(metadata.arraySize);
|
||||
desc.Format = static_cast<XG_FORMAT>(metadata.format);
|
||||
desc.SampleDesc.Count = 1;
|
||||
desc.Usage = XG_USAGE_DEFAULT;
|
||||
desc.BindFlags = XG_BIND_SHADER_RESOURCE;
|
||||
desc.MiscFlags = (metadata.miscFlags & TEX_MISC_TEXTURECUBE) ? XG_RESOURCE_MISC_TEXTURECUBE : 0;
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
desc.SwizzleMode = mode;
|
||||
#else
|
||||
desc.TileMode = mode;
|
||||
#endif
|
||||
|
||||
#ifdef VERBOSE
|
||||
DebugPrintDesc(desc);
|
||||
#endif
|
||||
|
||||
ComPtr<XGTextureAddressComputer> computer;
|
||||
HRESULT hr = XGCreateTexture2DComputer(&desc, computer.GetAddressOf());
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
hr = computer->GetResourceLayout(&layout);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
#ifdef VERBOSE
|
||||
DebugPrintLayout(layout);
|
||||
#endif
|
||||
|
||||
if (layout.Planes != 1)
|
||||
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
|
||||
|
||||
hr = xbox.Initialize(desc, layout, metadata.miscFlags2);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
for (uint32_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
if (metadata.arraySize > 1)
|
||||
XG_TEXTURE2D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.Height = static_cast<UINT>(metadata.height);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.ArraySize = static_cast<UINT>(metadata.arraySize);
|
||||
desc.Format = static_cast<XG_FORMAT>(metadata.format);
|
||||
desc.SampleDesc.Count = 1;
|
||||
desc.Usage = XG_USAGE_DEFAULT;
|
||||
desc.BindFlags = XG_BIND_SHADER_RESOURCE;
|
||||
desc.MiscFlags = (metadata.miscFlags & TEX_MISC_TEXTURECUBE) ? XG_RESOURCE_MISC_TEXTURECUBE : 0;
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
desc.SwizzleMode = mode;
|
||||
#else
|
||||
desc.TileMode = mode;
|
||||
#endif
|
||||
|
||||
#ifdef VERBOSE
|
||||
DebugPrintDesc(desc);
|
||||
#endif
|
||||
|
||||
ComPtr<XGTextureAddressComputer> computer;
|
||||
HRESULT hr = XGCreateTexture2DComputer(&desc, computer.GetAddressOf());
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
hr = computer->GetResourceLayout(&layout);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
#ifdef VERBOSE
|
||||
DebugPrintLayout(layout);
|
||||
#endif
|
||||
|
||||
if (layout.Planes != 1)
|
||||
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
|
||||
|
||||
hr = xbox.Initialize(desc, layout, metadata.miscFlags2);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
for (uint32_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
std::vector<const Image*> images;
|
||||
images.reserve(metadata.arraySize);
|
||||
for (uint32_t item = 0; item < metadata.arraySize; ++item)
|
||||
if (metadata.arraySize > 1)
|
||||
{
|
||||
const size_t index = metadata.ComputeIndex(level, item, 0);
|
||||
std::vector<const Image*> images;
|
||||
images.reserve(metadata.arraySize);
|
||||
for (uint32_t item = 0; item < metadata.arraySize; ++item)
|
||||
{
|
||||
const size_t index = metadata.ComputeIndex(level, item, 0);
|
||||
if (index >= nimages)
|
||||
{
|
||||
xbox.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
images.push_back(&srcImages[index]);
|
||||
}
|
||||
|
||||
hr = Tile2D(&images[0], images.size(), level, computer.Get(), layout, xbox);
|
||||
}
|
||||
else
|
||||
{
|
||||
const size_t index = metadata.ComputeIndex(level, 0, 0);
|
||||
if (index >= nimages)
|
||||
{
|
||||
xbox.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
images.push_back(&srcImages[index]);
|
||||
const Image* images = &srcImages[index];
|
||||
hr = Tile2D(&images, 1, level, computer.Get(), layout, xbox);
|
||||
}
|
||||
|
||||
hr = Tile2D(&images[0], images.size(), level, computer.Get(), layout, xbox);
|
||||
if (FAILED(hr))
|
||||
{
|
||||
xbox.Release();
|
||||
return hr;
|
||||
}
|
||||
}
|
||||
else
|
||||
}
|
||||
break;
|
||||
|
||||
case TEX_DIMENSION_TEXTURE3D:
|
||||
{
|
||||
XG_TEXTURE3D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.Height = static_cast<UINT>(metadata.height);
|
||||
desc.Depth = static_cast<UINT>(metadata.depth);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.Format = static_cast<XG_FORMAT>(metadata.format);
|
||||
desc.Usage = XG_USAGE_DEFAULT;
|
||||
desc.BindFlags = XG_BIND_SHADER_RESOURCE;
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
desc.SwizzleMode = mode;
|
||||
#else
|
||||
desc.TileMode = mode;
|
||||
#endif
|
||||
|
||||
#ifdef VERBOSE
|
||||
DebugPrintDesc(desc);
|
||||
#endif
|
||||
|
||||
ComPtr<XGTextureAddressComputer> computer;
|
||||
HRESULT hr = XGCreateTexture3DComputer(&desc, computer.GetAddressOf());
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
hr = computer->GetResourceLayout(&layout);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
#ifdef VERBOSE
|
||||
DebugPrintLayout(layout);
|
||||
#endif
|
||||
|
||||
if (layout.Planes != 1)
|
||||
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
|
||||
|
||||
hr = xbox.Initialize(desc, layout, metadata.miscFlags2);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
uint32_t d = static_cast<uint32_t>(metadata.depth);
|
||||
|
||||
size_t index = 0;
|
||||
for (uint32_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
const size_t index = metadata.ComputeIndex(level, 0, 0);
|
||||
if (index >= nimages)
|
||||
if ((index + d) > nimages)
|
||||
{
|
||||
xbox.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
const Image* images = &srcImages[index];
|
||||
hr = Tile2D(&images, 1, level, computer.Get(), layout, xbox);
|
||||
}
|
||||
// Relies on the fact that slices are contiguous
|
||||
hr = Tile3D(srcImages[index], level, d, computer.Get(), layout, xbox);
|
||||
if (FAILED(hr))
|
||||
{
|
||||
xbox.Release();
|
||||
return hr;
|
||||
}
|
||||
|
||||
if (FAILED(hr))
|
||||
{
|
||||
xbox.Release();
|
||||
return hr;
|
||||
index += d;
|
||||
|
||||
if (d > 1)
|
||||
d >>= 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case TEX_DIMENSION_TEXTURE3D:
|
||||
{
|
||||
XG_TEXTURE3D_DESC desc = {};
|
||||
desc.Width = static_cast<UINT>(metadata.width);
|
||||
desc.Height = static_cast<UINT>(metadata.height);
|
||||
desc.Depth = static_cast<UINT>(metadata.depth);
|
||||
desc.MipLevels = static_cast<UINT>(metadata.mipLevels);
|
||||
desc.Format = static_cast<XG_FORMAT>(metadata.format);
|
||||
desc.Usage = XG_USAGE_DEFAULT;
|
||||
desc.BindFlags = XG_BIND_SHADER_RESOURCE;
|
||||
#if defined(_GAMING_XBOX_SCARLETT) || defined(_USE_SCARLETT)
|
||||
desc.SwizzleMode = mode;
|
||||
#else
|
||||
desc.TileMode = mode;
|
||||
#endif
|
||||
|
||||
#ifdef VERBOSE
|
||||
DebugPrintDesc(desc);
|
||||
#endif
|
||||
|
||||
ComPtr<XGTextureAddressComputer> computer;
|
||||
HRESULT hr = XGCreateTexture3DComputer(&desc, computer.GetAddressOf());
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
hr = computer->GetResourceLayout(&layout);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
#ifdef VERBOSE
|
||||
DebugPrintLayout(layout);
|
||||
#endif
|
||||
|
||||
if (layout.Planes != 1)
|
||||
return HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
|
||||
|
||||
hr = xbox.Initialize(desc, layout, metadata.miscFlags2);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
uint32_t d = static_cast<uint32_t>(metadata.depth);
|
||||
|
||||
size_t index = 0;
|
||||
for (uint32_t level = 0; level < metadata.mipLevels; ++level)
|
||||
{
|
||||
if ((index + d) > nimages)
|
||||
{
|
||||
xbox.Release();
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
// Relies on the fact that slices are contiguous
|
||||
hr = Tile3D(srcImages[index], level, d, computer.Get(), layout, xbox);
|
||||
if (FAILED(hr))
|
||||
{
|
||||
xbox.Release();
|
||||
return hr;
|
||||
}
|
||||
|
||||
index += d;
|
||||
|
||||
if (d > 1)
|
||||
d >>= 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
default:
|
||||
return E_FAIL;
|
||||
|
|
|
@ -19,7 +19,7 @@
|
|||
<ProjectGuid>{9E4D1C18-9E5E-4B35-83BE-74830B9B3C34}</ProjectGuid>
|
||||
<RootNamespace>DirectXTex</RootNamespace>
|
||||
<Keyword>Win32Proj</Keyword>
|
||||
<WindowsTargetPlatformVersion>10.0.19041.0</WindowsTargetPlatformVersion>
|
||||
<WindowsTargetPlatformVersion>10.0.17763.0</WindowsTargetPlatformVersion>
|
||||
<PreferredToolArchitecture>x64</PreferredToolArchitecture>
|
||||
</PropertyGroup>
|
||||
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
|
||||
|
|
|
@ -12,7 +12,7 @@
|
|||
#pragma once
|
||||
|
||||
// Off by default warnings
|
||||
#pragma warning(disable : 4619 4616 4061 4265 4365 4571 4623 4625 4626 4628 4668 4710 4711 4746 4774 4820 4987 5026 5027 5031 5032 5039 5045 5219 26812)
|
||||
#pragma warning(disable : 4619 4616 4061 4265 4365 4571 4623 4625 4626 4628 4668 4710 4711 4746 4774 4820 4987 5026 5027 5031 5032 5039 5045 5219 5246 5264 26812)
|
||||
// C4619/4616 #pragma warning warnings
|
||||
// C4061 enumerator 'X' in switch of enum 'X' is not explicitly handled by a case label
|
||||
// C4265 class has virtual functions, but destructor is not virtual
|
||||
|
@ -35,6 +35,8 @@
|
|||
// C5039 pointer or reference to potentially throwing function passed to extern C function under - EHc
|
||||
// C5045 Spectre mitigation warning
|
||||
// C5219 implicit conversion from 'int' to 'float', possible loss of data
|
||||
// C5246 the initialization of a subobject should be wrapped in braces
|
||||
// C5264 'const' variable is not used
|
||||
// 26812: The enum type 'x' is unscoped. Prefer 'enum class' over 'enum' (Enum.3).
|
||||
|
||||
// Windows 8.1 SDK related Off by default warnings
|
||||
|
@ -68,16 +70,17 @@
|
|||
#pragma clang diagnostic ignored "-Wswitch-enum"
|
||||
#pragma clang diagnostic ignored "-Wtautological-type-limit-compare"
|
||||
#pragma clang diagnostic ignored "-Wunknown-pragmas"
|
||||
#pragma clang diagnostic ignored "-Wundef"
|
||||
#endif
|
||||
|
||||
#if defined(WIN32) || defined(_WIN32)
|
||||
#ifdef _WIN32
|
||||
#ifndef WIN32_LEAN_AND_MEAN
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#endif
|
||||
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable : 4005)
|
||||
#define NOMINMAX
|
||||
#define NOMINMAX 1
|
||||
#define NODRAWTEXT
|
||||
#define NOGDI
|
||||
#define NOBITMAP
|
||||
|
@ -88,6 +91,10 @@
|
|||
|
||||
#include <Windows.h>
|
||||
|
||||
#ifdef __MINGW32__
|
||||
#include <unknwn.h>
|
||||
#endif
|
||||
|
||||
#ifndef _WIN32_WINNT_WIN10
|
||||
#define _WIN32_WINNT_WIN10 0x0A00
|
||||
#endif
|
||||
|
@ -132,7 +139,7 @@
|
|||
#include <new>
|
||||
#include <tuple>
|
||||
|
||||
#ifndef WIN32
|
||||
#ifndef _WIN32
|
||||
#include <fstream>
|
||||
#include <filesystem>
|
||||
#include <thread>
|
||||
|
@ -148,10 +155,10 @@
|
|||
|
||||
#include "DirectXTex.h"
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <malloc.h>
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef NTDDI_WIN10_FE
|
||||
#if defined(NTDDI_WIN10_FE) || defined(__MINGW32__)
|
||||
#include <ole2.h>
|
||||
#else
|
||||
#include <Ole2.h>
|
||||
|
@ -180,6 +187,10 @@ using WICPixelFormatGUID = GUID;
|
|||
|
||||
#define XBOX_DXGI_FORMAT_R4G4_UNORM DXGI_FORMAT(190)
|
||||
|
||||
#if defined(__MINGW32__) && !defined(E_BOUNDS)
|
||||
#define E_BOUNDS static_cast<HRESULT>(0x8000000BL)
|
||||
#endif
|
||||
|
||||
// HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW)
|
||||
#define HRESULT_E_ARITHMETIC_OVERFLOW static_cast<HRESULT>(0x80070216L)
|
||||
|
||||
|
@ -210,7 +221,7 @@ namespace DirectX
|
|||
{
|
||||
//-----------------------------------------------------------------------------
|
||||
// WIC helper functions
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
DXGI_FORMAT __cdecl WICToDXGI(_In_ const GUID& guid) noexcept;
|
||||
bool __cdecl DXGIToWIC(_In_ DXGI_FORMAT format, _Out_ GUID& guid, _In_ bool ignoreRGBvsBGR = false) noexcept;
|
||||
|
||||
|
@ -295,11 +306,11 @@ namespace DirectX
|
|||
return WICBitmapInterpolationModeFant;
|
||||
}
|
||||
}
|
||||
#endif // WIN32
|
||||
#endif // WIN32
|
||||
|
||||
//---------------------------------------------------------------------------------
|
||||
// Image helper functions
|
||||
_Success_(return) bool __cdecl DetermineImageArray(
|
||||
HRESULT __cdecl DetermineImageArray(
|
||||
_In_ const TexMetadata& metadata, _In_ CP_FLAGS cpFlags,
|
||||
_Out_ size_t& nImages, _Out_ size_t& pixelSize) noexcept;
|
||||
|
||||
|
@ -313,32 +324,36 @@ namespace DirectX
|
|||
|
||||
enum TEXP_SCANLINE_FLAGS : uint32_t
|
||||
{
|
||||
TEXP_SCANLINE_NONE = 0,
|
||||
TEXP_SCANLINE_SETALPHA = 0x1, // Set alpha channel to known opaque value
|
||||
TEXP_SCANLINE_LEGACY = 0x2, // Enables specific legacy format conversion cases
|
||||
TEXP_SCANLINE_NONE = 0,
|
||||
|
||||
TEXP_SCANLINE_SETALPHA = 0x1,
|
||||
// Set alpha channel to known opaque value
|
||||
|
||||
TEXP_SCANLINE_LEGACY = 0x2,
|
||||
// Enables specific legacy format conversion cases
|
||||
};
|
||||
|
||||
enum CONVERT_FLAGS : uint32_t
|
||||
{
|
||||
CONVF_FLOAT = 0x1,
|
||||
CONVF_UNORM = 0x2,
|
||||
CONVF_UINT = 0x4,
|
||||
CONVF_SNORM = 0x8,
|
||||
CONVF_SINT = 0x10,
|
||||
CONVF_DEPTH = 0x20,
|
||||
CONVF_STENCIL = 0x40,
|
||||
CONVF_FLOAT = 0x1,
|
||||
CONVF_UNORM = 0x2,
|
||||
CONVF_UINT = 0x4,
|
||||
CONVF_SNORM = 0x8,
|
||||
CONVF_SINT = 0x10,
|
||||
CONVF_DEPTH = 0x20,
|
||||
CONVF_STENCIL = 0x40,
|
||||
CONVF_SHAREDEXP = 0x80,
|
||||
CONVF_BGR = 0x100,
|
||||
CONVF_XR = 0x200,
|
||||
CONVF_PACKED = 0x400,
|
||||
CONVF_BC = 0x800,
|
||||
CONVF_YUV = 0x1000,
|
||||
CONVF_POS_ONLY = 0x2000,
|
||||
CONVF_R = 0x10000,
|
||||
CONVF_G = 0x20000,
|
||||
CONVF_B = 0x40000,
|
||||
CONVF_A = 0x80000,
|
||||
CONVF_RGB_MASK = 0x70000,
|
||||
CONVF_BGR = 0x100,
|
||||
CONVF_XR = 0x200,
|
||||
CONVF_PACKED = 0x400,
|
||||
CONVF_BC = 0x800,
|
||||
CONVF_YUV = 0x1000,
|
||||
CONVF_POS_ONLY = 0x2000,
|
||||
CONVF_R = 0x10000,
|
||||
CONVF_G = 0x20000,
|
||||
CONVF_B = 0x40000,
|
||||
CONVF_A = 0x80000,
|
||||
CONVF_RGB_MASK = 0x70000,
|
||||
CONVF_RGBA_MASK = 0xF0000,
|
||||
};
|
||||
|
||||
|
@ -413,13 +428,13 @@ namespace DirectX
|
|||
bool __cdecl CalculateMipLevels3D(_In_ size_t width, _In_ size_t height, _In_ size_t depth,
|
||||
_Inout_ size_t& mipLevels) noexcept;
|
||||
|
||||
#ifdef WIN32
|
||||
#ifdef _WIN32
|
||||
HRESULT __cdecl ResizeSeparateColorAndAlpha(_In_ IWICImagingFactory* pWIC,
|
||||
_In_ bool iswic2,
|
||||
_In_ IWICBitmap* original,
|
||||
_In_ size_t newWidth, _In_ size_t newHeight, _In_ TEX_FILTER_FLAGS filter,
|
||||
_Inout_ const Image* img) noexcept;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
} // namespace Internal
|
||||
} // namespace DirectX
|
||||
|
|
|
@ -6,11 +6,11 @@ http://go.microsoft.com/fwlink/?LinkId=248926
|
|||
|
||||
Copyright (c) Microsoft Corporation.
|
||||
|
||||
**March 24, 2022**
|
||||
**January 31, 2023**
|
||||
|
||||
This package contains DirectXTex, a shared source library for reading and writing ``.DDS`` files, and performing various texture content processing operations including resizing, format conversion, mip-map generation, block compression for Direct3D runtime texture resources, and height-map to normal-map conversion. This library makes use of the Windows Image Component (WIC) APIs. It also includes ``.TGA`` and ``.HDR`` readers and writers since these image file formats are commonly used for texture content processing pipelines, but are not currently supported by a built-in WIC codec.
|
||||
|
||||
This code is designed to build with Visual Studio 2017 ([15.9](https://walbourn.github.io/vs-2017-15-9-update/)), Visual Studio 2019, Visual Studio 2022, or clang for Windows v11 or later. Use of the Windows 10 May 2020 Update SDK ([19041](https://walbourn.github.io/windows-10-may-2020-update-sdk/)) or later is required.
|
||||
This code is designed to build with Visual Studio 2019 (16.11), Visual Studio 2022, clang for Windows v12 or later, or MinGW 12.2. Use of the Windows 10 May 2020 Update SDK ([19041](https://walbourn.github.io/windows-10-may-2020-update-sdk/)) or later is required for Visual Studio. It can also be built for Windows Subsystem for Linux using GCC 11 or later.
|
||||
|
||||
These components are designed to work without requiring any content from the legacy DirectX SDK. For details, see [Where is the DirectX SDK?](https://aka.ms/dxsdk).
|
||||
|
||||
|
@ -25,6 +25,10 @@ These components are designed to work without requiring any content from the leg
|
|||
> The majority of the header files here are intended for internal implementation
|
||||
of the library only (``BC.h``, ``BCDirectCompute.h``, ``DDS.h``, ``DirectXTexP.h``, etc.). Only ``DirectXTex.h`` and ``DirectXTex.inl`` are meant as the 'public' header for the library.
|
||||
|
||||
* ``Auxiliary\``
|
||||
|
||||
+ Contains optional source files for the DirectXTex library, such as adapter loading functions using the OpenEXR library.
|
||||
|
||||
* ``Texconv\``
|
||||
|
||||
+ This DirectXTex sample is an implementation of the [texconv](https://github.com/Microsoft/DirectXTex/wiki/Texconv) command-line texture utility from the DirectX SDK utilizing DirectXTex rather than D3DX.
|
||||
|
@ -59,7 +63,11 @@ These components are designed to work without requiring any content from the leg
|
|||
|
||||
> DDSTextureLoader12, ScreenGrab12, and WICTextureLoader12 are 'stand-alone' versions of the same modules provided in the [DirectX Tool Kit for DX12](https://github.com/Microsoft/DirectXTK12).
|
||||
|
||||
# Documentation
|
||||
* ``build\``
|
||||
|
||||
+ Contains YAML files for the build pipelines along with some miscellaneous build files and scripts.
|
||||
|
||||
## Documentation
|
||||
|
||||
Documentation is available on the [GitHub wiki](https://github.com/Microsoft/DirectXTex/wiki).
|
||||
|
||||
|
@ -71,6 +79,8 @@ For the latest version of DirectXTex, bug reports, etc. please visit the project
|
|||
|
||||
## Release Notes
|
||||
|
||||
* Starting with the July 2022 release, the ``bool forceSRGB`` parameter for the CreateTextureEx and CreateShaderResourceViewEx functions is now a ``CREATETEX_FLAGS`` typed enum bitmask flag parameter. This may have a *breaking change* impact to client code. Replace ``true`` with ``CREATETEX_FORCE_SRGB`` and ``false`` with ``CREATETEX_DEFAULT``.
|
||||
|
||||
* Starting with the June 2020 release, this library makes use of typed enum bitmask flags per the recommendation of the _C++ Standard_ section *17.5.2.1.3 Bitmask types*. This is consistent with Direct3D 12's use of the ``DEFINE_ENUM_FLAG_OPERATORS`` macro. This may have *breaking change* impacts to client code:
|
||||
|
||||
* You cannot pass the ``0`` literal as your flags value. Instead you must make use of the appropriate default enum value: ``CP_FLAGS_NONE``, ``DDS_FLAGS_NONE``, ``WIC_FLAGS_NONE``, ``TEX_FR_ROTATE0``, ``TEX_FILTER_DEFAULT``, ``TEX_FILTER_DEFAULT``, ``TEX_FILTER_DEFAULT``, ``CNMAP_DEFAULT``, or ``CNMAP_DEFAULT``.
|
||||
|
@ -87,7 +97,9 @@ For the latest version of DirectXTex, bug reports, etc. please visit the project
|
|||
|
||||
* Loading of 96bpp floating-point TIFF files results in a corrupted image prior to Windows 8. This fix is available on Windows 7 SP1 with KB 2670838 installed.
|
||||
|
||||
* The UWP projects and the Win10 classic desktop project include configurations for the ARM64 platform. These require VS 2017 (15.9 update) or later to build, with the ARM64 toolset installed.
|
||||
* The UWP projects and the Win10 classic desktop project include configurations for the ARM64 platform. Building these requires installing the ARM64 toolset.
|
||||
|
||||
* When using clang/LLVM for the ARM64 platform, the Windows 11 SDK ([22000](https://walbourn.github.io/windows-sdk-for-windows-11/)) is required.
|
||||
|
||||
* The ``CompileShaders.cmd`` script must have Windows-style (CRLF) line-endings. If it is changed to Linux-style (LF) line-endings, it can fail to build all the required shaders.
|
||||
|
||||
|
|
|
@ -18,7 +18,7 @@
|
|||
#define MAX_INT asint(0x7FFFFFFF)
|
||||
#define MIN_INT asint(0x80000000)
|
||||
|
||||
cbuffer cbCS : register( b0 )
|
||||
cbuffer cbCS : register(b0)
|
||||
{
|
||||
uint g_tex_width;
|
||||
uint g_num_block_x;
|
||||
|
@ -73,14 +73,14 @@ static const uint candidateFixUpIndex1D[32] =
|
|||
};
|
||||
|
||||
//0, 9, 18, 27, 37, 46, 55, 64
|
||||
static const uint aStep1[64] = {0,0,0,0,0,1,1,1,
|
||||
static const uint aStep1[64] = { 0,0,0,0,0,1,1,1,
|
||||
1,1,1,1,1,1,2,2,
|
||||
2,2,2,2,2,2,2,3,
|
||||
3,3,3,3,3,3,3,3,
|
||||
3,4,4,4,4,4,4,4,
|
||||
4,4,5,5,5,5,5,5,
|
||||
5,5,5,6,6,6,6,6,
|
||||
6,6,6,6,7,7,7,7};
|
||||
6,6,6,6,7,7,7,7 };
|
||||
|
||||
//0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64
|
||||
static const uint aStep2[64] = { 0, 0, 0, 1, 1, 1, 1, 2,
|
||||
|
@ -90,7 +90,7 @@ static const uint aStep2[64] = { 0, 0, 0, 1, 1, 1, 1, 2,
|
|||
7, 8, 8, 8, 8, 9, 9, 9,
|
||||
9,10,10,10,10,10,11,11,
|
||||
11,11,12,12,12,12,13,13,
|
||||
13,13,14,14,14,14,15,15};
|
||||
13,13,14,14,14,14,15,15 };
|
||||
|
||||
static const float3 RGB2LUM = float3(0.2126f, 0.7152f, 0.0722f);
|
||||
|
||||
|
@ -101,23 +101,23 @@ static const float3 RGB2LUM = float3(0.2126f, 0.7152f, 0.0722f);
|
|||
|
||||
|
||||
//Forward declaration
|
||||
uint3 float2half( float3 pixel_f );
|
||||
int3 start_quantize( uint3 pixel_h );
|
||||
void quantize( inout int2x3 endPoint, uint prec );
|
||||
void finish_quantize_0( inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed );
|
||||
void finish_quantize_1( inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed );
|
||||
void finish_quantize( out bool bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed );
|
||||
uint3 float2half(float3 pixel_f);
|
||||
int3 start_quantize(uint3 pixel_h);
|
||||
void quantize(inout int2x3 endPoint, uint prec);
|
||||
void finish_quantize_0(inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed);
|
||||
void finish_quantize_1(inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed);
|
||||
void finish_quantize(out bool bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed);
|
||||
|
||||
void start_unquantize( inout int2x3 endPoint[2], uint4 prec, bool transformed );
|
||||
void start_unquantize( inout int2x3 endPoint, uint4 prec, bool transformed );
|
||||
void unquantize( inout int2x3 color, uint prec );
|
||||
uint3 finish_unquantize( int3 color );
|
||||
void generate_palette_unquantized8( out uint3 palette, int3 low, int3 high, int i );
|
||||
void generate_palette_unquantized16( out uint3 palette, int3 low, int3 high, int i );
|
||||
float3 half2float(uint3 color_h );
|
||||
void start_unquantize(inout int2x3 endPoint[2], uint4 prec, bool transformed);
|
||||
void start_unquantize(inout int2x3 endPoint, uint4 prec, bool transformed);
|
||||
void unquantize(inout int2x3 color, uint prec);
|
||||
uint3 finish_unquantize(int3 color);
|
||||
void generate_palette_unquantized8(out uint3 palette, int3 low, int3 high, int i);
|
||||
void generate_palette_unquantized16(out uint3 palette, int3 low, int3 high, int i);
|
||||
float3 half2float(uint3 color_h);
|
||||
|
||||
void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint partition_index );
|
||||
void block_package( inout uint4 block, int2x3 endPoint, uint mode_type );
|
||||
void block_package(inout uint4 block, int2x3 endPoint[2], uint mode_type, uint partition_index);
|
||||
void block_package(inout uint4 block, int2x3 endPoint, uint mode_type);
|
||||
|
||||
void swap(inout int3 lhs, inout int3 rhs)
|
||||
{
|
||||
|
@ -126,10 +126,10 @@ void swap(inout int3 lhs, inout int3 rhs)
|
|||
rhs = tmp;
|
||||
}
|
||||
|
||||
Texture2D<float4> g_Input : register( t0 );
|
||||
StructuredBuffer<uint4> g_InBuff : register( t1 );
|
||||
Texture2D<float4> g_Input : register(t0);
|
||||
StructuredBuffer<uint4> g_InBuff : register(t1);
|
||||
|
||||
RWStructuredBuffer<uint4> g_OutBuff : register( u0 );
|
||||
RWStructuredBuffer<uint4> g_OutBuff : register(u0);
|
||||
|
||||
struct SharedData
|
||||
{
|
||||
|
@ -148,8 +148,8 @@ struct SharedData
|
|||
|
||||
groupshared SharedData shared_temp[THREAD_GROUP_SIZE];
|
||||
|
||||
[numthreads( THREAD_GROUP_SIZE, 1, 1 )]
|
||||
void TryModeG10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
||||
[numthreads(THREAD_GROUP_SIZE, 1, 1)]
|
||||
void TryModeG10CS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
|
||||
{
|
||||
const uint MAX_USED_THREAD = 16;
|
||||
uint BLOCK_IN_GROUP = THREAD_GROUP_SIZE / MAX_USED_THREAD;
|
||||
|
@ -172,11 +172,11 @@ void TryModeG10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
|||
|
||||
if (threadInBlock < 16)
|
||||
{
|
||||
shared_temp[GI].pixel = g_Input.Load( uint3( base_x + threadInBlock % 4, base_y + threadInBlock / 4, 0 ) ).rgb;
|
||||
uint3 pixel_h = float2half( shared_temp[GI].pixel );
|
||||
shared_temp[GI].pixel = g_Input.Load(uint3(base_x + threadInBlock % 4, base_y + threadInBlock / 4, 0)).rgb;
|
||||
uint3 pixel_h = float2half(shared_temp[GI].pixel);
|
||||
shared_temp[GI].pixel_hr = half2float(pixel_h);
|
||||
shared_temp[GI].pixel_lum = dot(shared_temp[GI].pixel_hr, RGB2LUM);
|
||||
shared_temp[GI].pixel_ph = start_quantize( pixel_h );
|
||||
shared_temp[GI].pixel_ph = start_quantize(pixel_h);
|
||||
|
||||
shared_temp[GI].endPoint_low = shared_temp[GI].pixel_ph;
|
||||
shared_temp[GI].endPoint_high = shared_temp[GI].pixel_ph;
|
||||
|
@ -253,7 +253,7 @@ void TryModeG10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
|||
#endif
|
||||
|
||||
//ergod mode_type 11:14
|
||||
if ( threadInBlock == 0 )
|
||||
if (threadInBlock == 0)
|
||||
{
|
||||
int2x3 endPoint;
|
||||
// find_axis
|
||||
|
@ -262,9 +262,9 @@ void TryModeG10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
|||
|
||||
//compute_index
|
||||
float3 span = endPoint[1] - endPoint[0];// fixed a bug in v0.2
|
||||
float span_norm_sqr = dot( span, span );// fixed a bug in v0.2
|
||||
float dotProduct = dot( span, shared_temp[threadBase + 0].pixel_ph - endPoint[0] );// fixed a bug in v0.2
|
||||
if ( span_norm_sqr > 0 && dotProduct >= 0 && uint( dotProduct * 63.49999 / span_norm_sqr ) > 32 )
|
||||
float span_norm_sqr = dot(span, span);// fixed a bug in v0.2
|
||||
float dotProduct = dot(span, shared_temp[threadBase + 0].pixel_ph - endPoint[0]);// fixed a bug in v0.2
|
||||
if (span_norm_sqr > 0 && dotProduct >= 0 && uint(dotProduct * 63.49999 / span_norm_sqr) > 32)
|
||||
{
|
||||
swap(endPoint[0], endPoint[1]);
|
||||
|
||||
|
@ -283,11 +283,11 @@ void TryModeG10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
|||
endPoint[1] = shared_temp[threadBase + 0].endPoint_high;
|
||||
|
||||
float3 span = endPoint[1] - endPoint[0];
|
||||
float span_norm_sqr = dot( span, span );
|
||||
float span_norm_sqr = dot(span, span);
|
||||
|
||||
uint4 prec = candidateModePrec[threadInBlock + 10];
|
||||
int2x3 endPoint_q = endPoint;
|
||||
quantize( endPoint_q, prec.x );
|
||||
quantize(endPoint_q, prec.x);
|
||||
|
||||
bool transformed = candidateModeTransformed[threadInBlock + 10];
|
||||
if (transformed)
|
||||
|
@ -296,26 +296,26 @@ void TryModeG10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
|||
}
|
||||
|
||||
bool bBadQuantize;
|
||||
finish_quantize( bBadQuantize, endPoint_q, prec, transformed );
|
||||
finish_quantize(bBadQuantize, endPoint_q, prec, transformed);
|
||||
|
||||
start_unquantize( endPoint_q, prec, transformed );
|
||||
start_unquantize(endPoint_q, prec, transformed);
|
||||
|
||||
unquantize( endPoint_q, prec.x );
|
||||
unquantize(endPoint_q, prec.x);
|
||||
|
||||
float error = 0;
|
||||
[loop]for ( uint j = 0; j < 16; j ++ )
|
||||
[loop] for (uint j = 0; j < 16; j++)
|
||||
{
|
||||
float dotProduct = dot( span, shared_temp[threadBase + j].pixel_ph - endPoint[0] );// fixed a bug in v0.2
|
||||
uint index = ( span_norm_sqr <= 0 || dotProduct <= 0 ) ? 0
|
||||
: ( ( dotProduct < span_norm_sqr ) ? aStep2[ uint( dotProduct * 63.49999 / span_norm_sqr ) ] : aStep2[63] );
|
||||
float dotProduct = dot(span, shared_temp[threadBase + j].pixel_ph - endPoint[0]);// fixed a bug in v0.2
|
||||
uint index = (span_norm_sqr <= 0 || dotProduct <= 0) ? 0
|
||||
: ((dotProduct < span_norm_sqr) ? aStep2[uint(dotProduct * 63.49999 / span_norm_sqr)] : aStep2[63]);
|
||||
|
||||
uint3 pixel_rh;
|
||||
generate_palette_unquantized16( pixel_rh, endPoint_q[0], endPoint_q[1], index );
|
||||
float3 pixel_r = half2float( pixel_rh );
|
||||
generate_palette_unquantized16(pixel_rh, endPoint_q[0], endPoint_q[1], index);
|
||||
float3 pixel_r = half2float(pixel_rh);
|
||||
pixel_r -= shared_temp[threadBase + j].pixel_hr;
|
||||
error += dot(pixel_r, pixel_r);
|
||||
}
|
||||
if ( bBadQuantize )
|
||||
if (bBadQuantize)
|
||||
error = 1e20f;
|
||||
|
||||
shared_temp[GI].error = error;
|
||||
|
@ -327,7 +327,7 @@ void TryModeG10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
|||
|
||||
if (threadInBlock < 2)
|
||||
{
|
||||
if ( shared_temp[GI].error > shared_temp[GI + 2].error )
|
||||
if (shared_temp[GI].error > shared_temp[GI + 2].error)
|
||||
{
|
||||
shared_temp[GI].error = shared_temp[GI + 2].error;
|
||||
shared_temp[GI].best_mode = shared_temp[GI + 2].best_mode;
|
||||
|
@ -338,7 +338,7 @@ void TryModeG10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
|||
#endif
|
||||
if (threadInBlock < 1)
|
||||
{
|
||||
if ( shared_temp[GI].error > shared_temp[GI + 1].error )
|
||||
if (shared_temp[GI].error > shared_temp[GI + 1].error)
|
||||
{
|
||||
shared_temp[GI].error = shared_temp[GI + 1].error;
|
||||
shared_temp[GI].best_mode = shared_temp[GI + 1].best_mode;
|
||||
|
@ -348,8 +348,8 @@ void TryModeG10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
|||
}
|
||||
}
|
||||
|
||||
[numthreads( THREAD_GROUP_SIZE, 1, 1 )]
|
||||
void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
||||
[numthreads(THREAD_GROUP_SIZE, 1, 1)]
|
||||
void TryModeLE10CS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
|
||||
{
|
||||
const uint MAX_USED_THREAD = 32;
|
||||
uint BLOCK_IN_GROUP = THREAD_GROUP_SIZE / MAX_USED_THREAD;
|
||||
|
@ -378,11 +378,11 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
|||
|
||||
if (threadInBlock < 16)
|
||||
{
|
||||
shared_temp[GI].pixel = g_Input.Load( uint3( base_x + threadInBlock % 4, base_y + threadInBlock / 4, 0 ) ).rgb;
|
||||
uint3 pixel_h = float2half( shared_temp[GI].pixel );
|
||||
shared_temp[GI].pixel = g_Input.Load(uint3(base_x + threadInBlock % 4, base_y + threadInBlock / 4, 0)).rgb;
|
||||
uint3 pixel_h = float2half(shared_temp[GI].pixel);
|
||||
shared_temp[GI].pixel_hr = half2float(pixel_h);
|
||||
shared_temp[GI].pixel_lum = dot(shared_temp[GI].pixel_hr, RGB2LUM);
|
||||
shared_temp[GI].pixel_ph = start_quantize( pixel_h );
|
||||
shared_temp[GI].pixel_ph = start_quantize(pixel_h);
|
||||
}
|
||||
#ifdef REF_DEVICE
|
||||
GroupMemoryBarrierWithGroupSync();
|
||||
|
@ -405,11 +405,11 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
|||
endPoint_lum[1][1] = MIN_FLOAT;
|
||||
|
||||
uint bit = candidateSectionBit[threadInBlock];
|
||||
for ( uint i = 0; i < 16; i ++ )
|
||||
for (uint i = 0; i < 16; i++)
|
||||
{
|
||||
int3 pixel_ph = shared_temp[threadBase + i].pixel_ph;
|
||||
float pixel_lum = shared_temp[threadBase + i].pixel_lum;
|
||||
if ( (bit >> i) & 1 ) //It gets error when using "candidateSection" as "endPoint_ph" index
|
||||
if ((bit >> i) & 1) //It gets error when using "candidateSection" as "endPoint_ph" index
|
||||
{
|
||||
if (endPoint_lum[1][0] > pixel_lum)
|
||||
{
|
||||
|
@ -441,13 +441,13 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
|||
float3 span[2];// fixed a bug in v0.2
|
||||
float span_norm_sqr[2];// fixed a bug in v0.2
|
||||
[unroll]
|
||||
for (uint p = 0; p < 2; ++ p)
|
||||
for (uint p = 0; p < 2; ++p)
|
||||
{
|
||||
span[p] = endPoint[p][1] - endPoint[p][0];
|
||||
span_norm_sqr[p] = dot( span[p], span[p] );
|
||||
span_norm_sqr[p] = dot(span[p], span[p]);
|
||||
|
||||
float dotProduct = dot( span[p], shared_temp[threadBase + (0 == p ? 0 : candidateFixUpIndex1D[threadInBlock])].pixel_ph - endPoint[p][0] );// fixed a bug in v0.2
|
||||
if ( span_norm_sqr[p] > 0 && dotProduct >= 0 && uint( dotProduct * 63.49999 / span_norm_sqr[p] ) > 32 )
|
||||
float dotProduct = dot(span[p], shared_temp[threadBase + (0 == p ? 0 : candidateFixUpIndex1D[threadInBlock])].pixel_ph - endPoint[p][0]);// fixed a bug in v0.2
|
||||
if (span_norm_sqr[p] > 0 && dotProduct >= 0 && uint(dotProduct * 63.49999 / span_norm_sqr[p]) > 32)
|
||||
{
|
||||
span[p] = -span[p];
|
||||
swap(endPoint[p][0], endPoint[p][1]);
|
||||
|
@ -456,8 +456,8 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
|||
|
||||
uint4 prec = candidateModePrec[g_mode_id];
|
||||
int2x3 endPoint_q[2] = endPoint;
|
||||
quantize( endPoint_q[0], prec.x );
|
||||
quantize( endPoint_q[1], prec.x );
|
||||
quantize(endPoint_q[0], prec.x);
|
||||
quantize(endPoint_q[1], prec.x);
|
||||
|
||||
bool transformed = candidateModeTransformed[g_mode_id];
|
||||
if (transformed)
|
||||
|
@ -468,38 +468,38 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
|||
}
|
||||
|
||||
int bBadQuantize = 0;
|
||||
finish_quantize_0( bBadQuantize, endPoint_q[0], prec, transformed );
|
||||
finish_quantize_1( bBadQuantize, endPoint_q[1], prec, transformed );
|
||||
finish_quantize_0(bBadQuantize, endPoint_q[0], prec, transformed);
|
||||
finish_quantize_1(bBadQuantize, endPoint_q[1], prec, transformed);
|
||||
|
||||
start_unquantize( endPoint_q, prec, transformed );
|
||||
start_unquantize(endPoint_q, prec, transformed);
|
||||
|
||||
unquantize( endPoint_q[0], prec.x );
|
||||
unquantize( endPoint_q[1], prec.x );
|
||||
unquantize(endPoint_q[0], prec.x);
|
||||
unquantize(endPoint_q[1], prec.x);
|
||||
|
||||
float error = 0;
|
||||
for ( uint j = 0; j < 16; j ++ )
|
||||
for (uint j = 0; j < 16; j++)
|
||||
{
|
||||
uint3 pixel_rh;
|
||||
if ((bit >> j) & 1)
|
||||
{
|
||||
float dotProduct = dot( span[1], shared_temp[threadBase + j].pixel_ph - endPoint[1][0] );// fixed a bug in v0.2
|
||||
uint index = ( span_norm_sqr[1] <= 0 || dotProduct <= 0 ) ? 0
|
||||
: ( ( dotProduct < span_norm_sqr[1] ) ? aStep1[ uint( dotProduct * 63.49999 / span_norm_sqr[1] ) ] : aStep1[63] );
|
||||
generate_palette_unquantized8( pixel_rh, endPoint_q[1][0], endPoint_q[1][1], index );
|
||||
float dotProduct = dot(span[1], shared_temp[threadBase + j].pixel_ph - endPoint[1][0]);// fixed a bug in v0.2
|
||||
uint index = (span_norm_sqr[1] <= 0 || dotProduct <= 0) ? 0
|
||||
: ((dotProduct < span_norm_sqr[1]) ? aStep1[uint(dotProduct * 63.49999 / span_norm_sqr[1])] : aStep1[63]);
|
||||
generate_palette_unquantized8(pixel_rh, endPoint_q[1][0], endPoint_q[1][1], index);
|
||||
}
|
||||
else
|
||||
{
|
||||
float dotProduct = dot( span[0], shared_temp[threadBase + j].pixel_ph - endPoint[0][0] );// fixed a bug in v0.2
|
||||
uint index = ( span_norm_sqr[0] <= 0 || dotProduct <= 0 ) ? 0
|
||||
: ( ( dotProduct < span_norm_sqr[0] ) ? aStep1[ uint( dotProduct * 63.49999 / span_norm_sqr[0] ) ] : aStep1[63] );
|
||||
generate_palette_unquantized8( pixel_rh, endPoint_q[0][0], endPoint_q[0][1], index );
|
||||
float dotProduct = dot(span[0], shared_temp[threadBase + j].pixel_ph - endPoint[0][0]);// fixed a bug in v0.2
|
||||
uint index = (span_norm_sqr[0] <= 0 || dotProduct <= 0) ? 0
|
||||
: ((dotProduct < span_norm_sqr[0]) ? aStep1[uint(dotProduct * 63.49999 / span_norm_sqr[0])] : aStep1[63]);
|
||||
generate_palette_unquantized8(pixel_rh, endPoint_q[0][0], endPoint_q[0][1], index);
|
||||
}
|
||||
|
||||
float3 pixel_r = half2float( pixel_rh );
|
||||
float3 pixel_r = half2float(pixel_rh);
|
||||
pixel_r -= shared_temp[threadBase + j].pixel_hr;
|
||||
error += dot(pixel_r, pixel_r);
|
||||
}
|
||||
if ( bBadQuantize )
|
||||
if (bBadQuantize)
|
||||
error = 1e20f;
|
||||
|
||||
shared_temp[GI].error = error;
|
||||
|
@ -512,7 +512,7 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
|||
|
||||
if (threadInBlock < 16)
|
||||
{
|
||||
if ( shared_temp[GI].error > shared_temp[GI + 16].error )
|
||||
if (shared_temp[GI].error > shared_temp[GI + 16].error)
|
||||
{
|
||||
shared_temp[GI].error = shared_temp[GI + 16].error;
|
||||
shared_temp[GI].best_mode = shared_temp[GI + 16].best_mode;
|
||||
|
@ -524,7 +524,7 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
|||
#endif
|
||||
if (threadInBlock < 8)
|
||||
{
|
||||
if ( shared_temp[GI].error > shared_temp[GI + 8].error )
|
||||
if (shared_temp[GI].error > shared_temp[GI + 8].error)
|
||||
{
|
||||
shared_temp[GI].error = shared_temp[GI + 8].error;
|
||||
shared_temp[GI].best_mode = shared_temp[GI + 8].best_mode;
|
||||
|
@ -536,7 +536,7 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
|||
#endif
|
||||
if (threadInBlock < 4)
|
||||
{
|
||||
if ( shared_temp[GI].error > shared_temp[GI + 4].error )
|
||||
if (shared_temp[GI].error > shared_temp[GI + 4].error)
|
||||
{
|
||||
shared_temp[GI].error = shared_temp[GI + 4].error;
|
||||
shared_temp[GI].best_mode = shared_temp[GI + 4].best_mode;
|
||||
|
@ -548,7 +548,7 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
|||
#endif
|
||||
if (threadInBlock < 2)
|
||||
{
|
||||
if ( shared_temp[GI].error > shared_temp[GI + 2].error )
|
||||
if (shared_temp[GI].error > shared_temp[GI + 2].error)
|
||||
{
|
||||
shared_temp[GI].error = shared_temp[GI + 2].error;
|
||||
shared_temp[GI].best_mode = shared_temp[GI + 2].best_mode;
|
||||
|
@ -560,7 +560,7 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
|||
#endif
|
||||
if (threadInBlock < 1)
|
||||
{
|
||||
if ( shared_temp[GI].error > shared_temp[GI + 1].error )
|
||||
if (shared_temp[GI].error > shared_temp[GI + 1].error)
|
||||
{
|
||||
shared_temp[GI].error = shared_temp[GI + 1].error;
|
||||
shared_temp[GI].best_mode = shared_temp[GI + 1].best_mode;
|
||||
|
@ -578,7 +578,7 @@ void TryModeLE10CS( uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID )
|
|||
}
|
||||
}
|
||||
|
||||
[numthreads( THREAD_GROUP_SIZE, 1, 1 )]
|
||||
[numthreads(THREAD_GROUP_SIZE, 1, 1)]
|
||||
void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
|
||||
{
|
||||
const uint MAX_USED_THREAD = 32;
|
||||
|
@ -602,10 +602,10 @@ void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
|
|||
|
||||
if (threadInBlock < 16)
|
||||
{
|
||||
shared_temp[GI].pixel = g_Input.Load( uint3( base_x + threadInBlock % 4, base_y + threadInBlock / 4, 0 ) ).rgb;
|
||||
shared_temp[GI].pixel = g_Input.Load(uint3(base_x + threadInBlock % 4, base_y + threadInBlock / 4, 0)).rgb;
|
||||
shared_temp[GI].pixel_lum = dot(shared_temp[GI].pixel, RGB2LUM);
|
||||
uint3 pixel_h = float2half( shared_temp[GI].pixel );
|
||||
shared_temp[GI].pixel_ph = start_quantize( pixel_h );
|
||||
uint3 pixel_h = float2half(shared_temp[GI].pixel);
|
||||
shared_temp[GI].pixel_ph = start_quantize(pixel_h);
|
||||
}
|
||||
#ifdef REF_DEVICE
|
||||
GroupMemoryBarrierWithGroupSync();
|
||||
|
@ -750,9 +750,9 @@ void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
|
|||
}
|
||||
|
||||
float3 span = endPoint[1] - endPoint[0];
|
||||
float span_norm_sqr = dot( span, span );
|
||||
float dotProduct = dot( span, shared_temp[threadBase + fixup].pixel_ph - endPoint[0] );
|
||||
if ( span_norm_sqr > 0 && dotProduct >= 0 && uint( dotProduct * 63.49999 / span_norm_sqr ) > 32 )
|
||||
float span_norm_sqr = dot(span, span);
|
||||
float dotProduct = dot(span, shared_temp[threadBase + fixup].pixel_ph - endPoint[0]);
|
||||
if (span_norm_sqr > 0 && dotProduct >= 0 && uint(dotProduct * 63.49999 / span_norm_sqr) > 32)
|
||||
{
|
||||
swap(endPoint[0], endPoint[1]);
|
||||
}
|
||||
|
@ -781,19 +781,19 @@ void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
|
|||
if ((bits >> threadInBlock) & 1)
|
||||
{
|
||||
span = shared_temp[threadBase + 1].endPoint_high - shared_temp[threadBase + 1].endPoint_low;
|
||||
dotProduct = dot( span, shared_temp[threadBase + threadInBlock].pixel_ph - shared_temp[threadBase + 1].endPoint_low );
|
||||
dotProduct = dot(span, shared_temp[threadBase + threadInBlock].pixel_ph - shared_temp[threadBase + 1].endPoint_low);
|
||||
}
|
||||
else
|
||||
{
|
||||
span = shared_temp[threadBase + 0].endPoint_high - shared_temp[threadBase + 0].endPoint_low;
|
||||
dotProduct = dot( span, shared_temp[threadBase + threadInBlock].pixel_ph - shared_temp[threadBase + 0].endPoint_low );
|
||||
dotProduct = dot(span, shared_temp[threadBase + threadInBlock].pixel_ph - shared_temp[threadBase + 0].endPoint_low);
|
||||
}
|
||||
float span_norm_sqr = dot( span, span );
|
||||
float span_norm_sqr = dot(span, span);
|
||||
|
||||
if (best_mode > 10)
|
||||
{
|
||||
uint index = ( span_norm_sqr <= 0 || dotProduct <= 0 ) ? 0
|
||||
: ( ( dotProduct < span_norm_sqr ) ? aStep2[ uint( dotProduct * 63.49999 / span_norm_sqr ) ] : aStep2[63] );
|
||||
uint index = (span_norm_sqr <= 0 || dotProduct <= 0) ? 0
|
||||
: ((dotProduct < span_norm_sqr) ? aStep2[uint(dotProduct * 63.49999 / span_norm_sqr)] : aStep2[63]);
|
||||
if (threadInBlock == 0)
|
||||
{
|
||||
block.z |= index << 1;
|
||||
|
@ -809,8 +809,8 @@ void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
|
|||
}
|
||||
else
|
||||
{
|
||||
uint index = ( span_norm_sqr <= 0 || dotProduct <= 0 ) ? 0
|
||||
: ( ( dotProduct < span_norm_sqr ) ? aStep1[ uint( dotProduct * 63.49999 / span_norm_sqr ) ] : aStep1[63] );
|
||||
uint index = (span_norm_sqr <= 0 || dotProduct <= 0) ? 0
|
||||
: ((dotProduct < span_norm_sqr) ? aStep1[uint(dotProduct * 63.49999 / span_norm_sqr)] : aStep1[63]);
|
||||
|
||||
uint fixup = candidateFixUpIndex1D[best_partition];
|
||||
int2 offset = int2((fixup != 2), (fixup == 15));
|
||||
|
@ -889,7 +889,7 @@ void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
|
|||
endPoint_q[0] = shared_temp[threadBase + 0].endPoint_low;
|
||||
endPoint_q[1] = shared_temp[threadBase + 0].endPoint_high;
|
||||
|
||||
quantize( endPoint_q, prec.x );
|
||||
quantize(endPoint_q, prec.x);
|
||||
if (transformed)
|
||||
{
|
||||
endPoint_q[1] -= endPoint_q[0];
|
||||
|
@ -910,7 +910,7 @@ void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
|
|||
|
||||
if (best_mode <= 10)
|
||||
{
|
||||
quantize( endPoint_q, prec.x );
|
||||
quantize(endPoint_q, prec.x);
|
||||
if (transformed)
|
||||
{
|
||||
endPoint_q[0] -= ep0;
|
||||
|
@ -936,18 +936,18 @@ void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
|
|||
{
|
||||
if (best_mode > 10)
|
||||
{
|
||||
finish_quantize( bBadQuantize, endPoint_q, prec, transformed );
|
||||
finish_quantize(bBadQuantize, endPoint_q, prec, transformed);
|
||||
}
|
||||
else
|
||||
{
|
||||
finish_quantize_0( bBadQuantize, endPoint_q, prec, transformed );
|
||||
finish_quantize_0(bBadQuantize, endPoint_q, prec, transformed);
|
||||
}
|
||||
}
|
||||
else // if (threadInBlock == 1)
|
||||
{
|
||||
if (best_mode <= 10)
|
||||
{
|
||||
finish_quantize_1( bBadQuantize, endPoint_q, prec, transformed );
|
||||
finish_quantize_1(bBadQuantize, endPoint_q, prec, transformed);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -958,7 +958,7 @@ void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
|
|||
GroupMemoryBarrierWithGroupSync();
|
||||
#endif
|
||||
|
||||
if ( threadInBlock == 0 )
|
||||
if (threadInBlock == 0)
|
||||
{
|
||||
int2x3 endPoint_q[2];
|
||||
endPoint_q[0][0] = shared_temp[threadBase + 0].endPoint_low;
|
||||
|
@ -966,20 +966,20 @@ void EncodeBlockCS(uint GI : SV_GroupIndex, uint3 groupID : SV_GroupID)
|
|||
endPoint_q[1][0] = shared_temp[threadBase + 1].endPoint_low;
|
||||
endPoint_q[1][1] = shared_temp[threadBase + 1].endPoint_high;
|
||||
|
||||
if ( best_mode > 10 )
|
||||
if (best_mode > 10)
|
||||
{
|
||||
block_package( block, endPoint_q[0], best_mode );
|
||||
block_package(block, endPoint_q[0], best_mode);
|
||||
}
|
||||
else
|
||||
{
|
||||
block_package( block, endPoint_q, best_mode, best_partition );
|
||||
block_package(block, endPoint_q, best_mode, best_partition);
|
||||
}
|
||||
|
||||
g_OutBuff[blockID] = block;
|
||||
}
|
||||
}
|
||||
|
||||
uint float2half1( float f )
|
||||
uint float2half1(float f)
|
||||
{
|
||||
uint Result;
|
||||
|
||||
|
@ -1012,7 +1012,7 @@ uint float2half1( float f )
|
|||
return (Result|Sign);
|
||||
}
|
||||
|
||||
uint3 float2half( float3 endPoint_f )
|
||||
uint3 float2half(float3 endPoint_f)
|
||||
{
|
||||
//uint3 sign = asuint(endPoint_f) & 0x80000000;
|
||||
//uint3 expo = asuint(endPoint_f) & 0x7F800000;
|
||||
|
@ -1027,140 +1027,140 @@ uint3 float2half( float3 endPoint_f )
|
|||
// : ( ( sign >> 16 ) | ( ( ( expo - 0x38000000 ) | base ) >> 13 ) ) ) );
|
||||
|
||||
|
||||
return uint3( float2half1( endPoint_f.x ), float2half1( endPoint_f.y ), float2half1( endPoint_f.z ) );
|
||||
return uint3(float2half1(endPoint_f.x), float2half1(endPoint_f.y), float2half1(endPoint_f.z));
|
||||
}
|
||||
int3 start_quantize( uint3 pixel_h )
|
||||
int3 start_quantize(uint3 pixel_h)
|
||||
{
|
||||
if ( g_format == UNSIGNED_F16 )
|
||||
if (g_format == UNSIGNED_F16)
|
||||
{
|
||||
return asint( ( pixel_h << 6 ) / 31 );
|
||||
return asint((pixel_h << 6) / 31);
|
||||
}
|
||||
else
|
||||
{
|
||||
return ( pixel_h < 0x8000 ) ? ( ( pixel_h == 0x7bff ) ? 0x7fff : asint( ( pixel_h << 5 ) / 31 ) )// fixed a bug in v0.2
|
||||
: ( ( pixel_h == 0x7bff ) ? 0xffff8001 : -asint( ( ( 0x00007fff & pixel_h ) << 5 ) / 31 ) );// fixed a bug in v0.2
|
||||
return (pixel_h < 0x8000) ? ((pixel_h == 0x7bff) ? 0x7fff : asint((pixel_h << 5) / 31))// fixed a bug in v0.2
|
||||
: ((pixel_h == 0x7bff) ? 0xffff8001 : -asint(((0x00007fff & pixel_h) << 5) / 31));// fixed a bug in v0.2
|
||||
}
|
||||
}
|
||||
void quantize( inout int2x3 endPoint, uint prec )
|
||||
void quantize(inout int2x3 endPoint, uint prec)
|
||||
{
|
||||
int iprec = asint( prec );
|
||||
if ( g_format == UNSIGNED_F16 )
|
||||
int iprec = asint(prec);
|
||||
if (g_format == UNSIGNED_F16)
|
||||
{
|
||||
endPoint = ( ( iprec >= 15 ) | ( endPoint == 0 ) ) ? endPoint
|
||||
: ( ( endPoint == asint(0xFFFF) ) ? ( ( 1 << iprec ) - 1 )
|
||||
: ( ( ( endPoint << iprec ) + asint(0x0000) ) >> 16 ) );
|
||||
endPoint = ((iprec >= 15) | (endPoint == 0)) ? endPoint
|
||||
: ((endPoint == asint(0xFFFF)) ? ((1 << iprec) - 1)
|
||||
: (((endPoint << iprec) + asint(0x0000)) >> 16));
|
||||
}
|
||||
else
|
||||
{
|
||||
endPoint = ( ( iprec >= 16 ) | ( endPoint == 0 ) ) ? endPoint
|
||||
: ( ( endPoint >= 0 ) ? ( ( endPoint == asint(0x7FFF) ) ? ( ( 1 << ( iprec - 1 ) ) - 1 ) : ( ( ( endPoint << ( iprec - 1 ) ) + asint(0x0000) ) >> 15 ) )
|
||||
: ( ( -endPoint == asint(0x7FFF) ) ? -( ( 1 << ( iprec - 1 ) ) - 1 ) : -( ( ( -endPoint << ( iprec - 1 ) ) + asint(0x0000) ) >> 15 ) ) );
|
||||
endPoint = ((iprec >= 16) | (endPoint == 0)) ? endPoint
|
||||
: ((endPoint >= 0) ? ((endPoint == asint(0x7FFF)) ? ((1 << (iprec - 1)) - 1) : (((endPoint << (iprec - 1)) + asint(0x0000)) >> 15))
|
||||
: ((-endPoint == asint(0x7FFF)) ? -((1 << (iprec - 1)) - 1) : -(((-endPoint << (iprec - 1)) + asint(0x0000)) >> 15)));
|
||||
}
|
||||
}
|
||||
void finish_quantize_0( inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed )
|
||||
void finish_quantize_0(inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed)
|
||||
{
|
||||
if ( transformed )
|
||||
if (transformed)
|
||||
{
|
||||
bool3 bBadComponent = ( endPoint[1] >= 0 ) ? ( endPoint[1] >= ( 1 << ( prec.yzw - 1 ) ) )
|
||||
: ( -endPoint[1] > ( 1 << ( prec.yzw - 1 ) ) );
|
||||
bool3 bBadComponent = (endPoint[1] >= 0) ? (endPoint[1] >= (1 << (prec.yzw - 1)))
|
||||
: (-endPoint[1] > (1 << (prec.yzw - 1)));
|
||||
bBadQuantize |= any(bBadComponent);
|
||||
|
||||
endPoint[0] = endPoint[0] & ( ( 1 << prec.x ) - 1 );
|
||||
endPoint[1] = ( endPoint[1] >= 0 ) ? ( ( endPoint[1] >= ( 1 << ( prec.yzw - 1 ) ) ) ? ( ( 1 << ( prec.yzw - 1 ) ) - 1 ) : endPoint[1] )
|
||||
: ( ( -endPoint[1] > ( 1 << ( prec.yzw - 1 ) ) ) ? ( 1 << ( prec.yzw - 1 ) ) : ( endPoint[1] & ( ( 1 << prec.yzw ) - 1 ) ) );
|
||||
endPoint[0] = endPoint[0] & ((1 << prec.x) - 1);
|
||||
endPoint[1] = (endPoint[1] >= 0) ? ((endPoint[1] >= (1 << (prec.yzw - 1))) ? ((1 << (prec.yzw - 1)) - 1) : endPoint[1])
|
||||
: ((-endPoint[1] > (1 << (prec.yzw - 1))) ? (1 << (prec.yzw - 1)) : (endPoint[1] & ((1 << prec.yzw) - 1)));
|
||||
}
|
||||
else
|
||||
{
|
||||
endPoint &= ( ( 1 << prec.x ) - 1 );
|
||||
endPoint &= ((1 << prec.x) - 1);
|
||||
}
|
||||
}
|
||||
void finish_quantize_1( inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed )
|
||||
void finish_quantize_1(inout int bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed)
|
||||
{
|
||||
if ( transformed )
|
||||
if (transformed)
|
||||
{
|
||||
bool2x3 bBadComponent;
|
||||
bBadComponent[0] = ( endPoint[0] >= 0 ) ? ( endPoint[0] >= ( 1 << ( prec.yzw - 1 ) ) )
|
||||
: ( -endPoint[0] > ( 1 << ( prec.yzw - 1 ) ) );
|
||||
bBadComponent[1] = ( endPoint[1] >= 0 ) ? ( endPoint[1] >= ( 1 << ( prec.yzw - 1 ) ) )
|
||||
: ( -endPoint[1] > ( 1 << ( prec.yzw - 1 ) ) );
|
||||
bBadComponent[0] = (endPoint[0] >= 0) ? (endPoint[0] >= (1 << (prec.yzw - 1)))
|
||||
: (-endPoint[0] > (1 << (prec.yzw - 1)));
|
||||
bBadComponent[1] = (endPoint[1] >= 0) ? (endPoint[1] >= (1 << (prec.yzw - 1)))
|
||||
: (-endPoint[1] > (1 << (prec.yzw - 1)));
|
||||
bBadQuantize |= any(bBadComponent);
|
||||
|
||||
endPoint[0] = ( endPoint[0] >= 0 ) ? ( ( endPoint[0] >= ( 1 << ( prec.yzw - 1 ) ) ) ? ( ( 1 << ( prec.yzw - 1 ) ) - 1 ) : endPoint[0] )
|
||||
: ( ( -endPoint[0] > ( 1 << ( prec.yzw - 1 ) ) ) ? ( 1 << ( prec.yzw - 1 ) ) : ( endPoint[0] & ( ( 1 << prec.yzw ) - 1 ) ) );
|
||||
endPoint[1] = ( endPoint[1] >= 0 ) ? ( ( endPoint[1] >= ( 1 << ( prec.yzw - 1 ) ) ) ? ( ( 1 << ( prec.yzw - 1 ) ) - 1 ) : endPoint[1] )
|
||||
: ( ( -endPoint[1] > ( 1 << ( prec.yzw - 1 ) ) ) ? ( 1 << ( prec.yzw - 1 ) ) : ( endPoint[1] & ( ( 1 << prec.yzw ) - 1 ) ) );
|
||||
endPoint[0] = (endPoint[0] >= 0) ? ((endPoint[0] >= (1 << (prec.yzw - 1))) ? ((1 << (prec.yzw - 1)) - 1) : endPoint[0])
|
||||
: ((-endPoint[0] > (1 << (prec.yzw - 1))) ? (1 << (prec.yzw - 1)) : (endPoint[0] & ((1 << prec.yzw) - 1)));
|
||||
endPoint[1] = (endPoint[1] >= 0) ? ((endPoint[1] >= (1 << (prec.yzw - 1))) ? ((1 << (prec.yzw - 1)) - 1) : endPoint[1])
|
||||
: ((-endPoint[1] > (1 << (prec.yzw - 1))) ? (1 << (prec.yzw - 1)) : (endPoint[1] & ((1 << prec.yzw) - 1)));
|
||||
}
|
||||
else
|
||||
{
|
||||
endPoint &= ( ( 1 << prec.x ) - 1 );
|
||||
endPoint &= ((1 << prec.x) - 1);
|
||||
}
|
||||
}
|
||||
void finish_quantize( out bool bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed )
|
||||
void finish_quantize(out bool bBadQuantize, inout int2x3 endPoint, uint4 prec, bool transformed)
|
||||
{
|
||||
if ( transformed )
|
||||
if (transformed)
|
||||
{
|
||||
bool3 bBadComponent;
|
||||
bBadComponent = ( endPoint[1] >= 0 ) ? ( endPoint[1] >= ( 1 << ( prec.yzw - 1 ) ) )
|
||||
: ( -endPoint[1] > ( 1 << ( prec.yzw - 1 ) ) );
|
||||
bBadQuantize = any( bBadComponent );
|
||||
bBadComponent = (endPoint[1] >= 0) ? (endPoint[1] >= (1 << (prec.yzw - 1)))
|
||||
: (-endPoint[1] > (1 << (prec.yzw - 1)));
|
||||
bBadQuantize = any(bBadComponent);
|
||||
|
||||
endPoint[0] = endPoint[0] & ( ( 1 << prec.x ) - 1 );
|
||||
endPoint[1] = ( endPoint[1] >= 0 ) ? ( ( endPoint[1] >= ( 1 << ( prec.yzw - 1 ) ) ) ? ( ( 1 << ( prec.yzw - 1 ) ) - 1 ) : endPoint[1] )
|
||||
: ( ( -endPoint[1] > ( 1 << ( prec.yzw - 1 ) ) ) ? ( 1 << ( prec.yzw - 1 ) ) : ( endPoint[1] & ( ( 1 << prec.yzw ) - 1 ) ) );
|
||||
endPoint[0] = endPoint[0] & ((1 << prec.x) - 1);
|
||||
endPoint[1] = (endPoint[1] >= 0) ? ((endPoint[1] >= (1 << (prec.yzw - 1))) ? ((1 << (prec.yzw - 1)) - 1) : endPoint[1])
|
||||
: ((-endPoint[1] > (1 << (prec.yzw - 1))) ? (1 << (prec.yzw - 1)) : (endPoint[1] & ((1 << prec.yzw) - 1)));
|
||||
}
|
||||
else
|
||||
{
|
||||
endPoint &= ( ( 1 << prec.x ) - 1 );
|
||||
endPoint &= ((1 << prec.x) - 1);
|
||||
|
||||
bBadQuantize = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void SIGN_EXTEND( uint3 prec, inout int3 color )
|
||||
void SIGN_EXTEND(uint3 prec, inout int3 color)
|
||||
{
|
||||
uint3 p = 1 << (prec - 1);
|
||||
color = (color & p) ? (color & (p - 1)) - p : color;
|
||||
}
|
||||
|
||||
void sign_extend( bool transformed, uint4 prec, inout int2x3 endPoint )
|
||||
void sign_extend(bool transformed, uint4 prec, inout int2x3 endPoint)
|
||||
{
|
||||
if ( g_format == SIGNED_F16 )
|
||||
SIGN_EXTEND( prec.x, endPoint[0] );
|
||||
if ( g_format == SIGNED_F16 || transformed )
|
||||
SIGN_EXTEND( prec.yzw, endPoint[1] );
|
||||
if (g_format == SIGNED_F16)
|
||||
SIGN_EXTEND(prec.x, endPoint[0]);
|
||||
if (g_format == SIGNED_F16 || transformed)
|
||||
SIGN_EXTEND(prec.yzw, endPoint[1]);
|
||||
}
|
||||
|
||||
void sign_extend( bool transformed, uint4 prec, inout int2x3 endPoint[2] )
|
||||
void sign_extend(bool transformed, uint4 prec, inout int2x3 endPoint[2])
|
||||
{
|
||||
if ( g_format == SIGNED_F16 )
|
||||
SIGN_EXTEND( prec.x, endPoint[0][0] );
|
||||
if ( g_format == SIGNED_F16 || transformed )
|
||||
if (g_format == SIGNED_F16)
|
||||
SIGN_EXTEND(prec.x, endPoint[0][0]);
|
||||
if (g_format == SIGNED_F16 || transformed)
|
||||
{
|
||||
SIGN_EXTEND( prec.yzw, endPoint[0][1] );
|
||||
SIGN_EXTEND( prec.yzw, endPoint[1][0] );
|
||||
SIGN_EXTEND( prec.yzw, endPoint[1][1] );
|
||||
SIGN_EXTEND(prec.yzw, endPoint[0][1]);
|
||||
SIGN_EXTEND(prec.yzw, endPoint[1][0]);
|
||||
SIGN_EXTEND(prec.yzw, endPoint[1][1]);
|
||||
}
|
||||
}
|
||||
void start_unquantize( inout int2x3 endPoint[2], uint4 prec, bool transformed )
|
||||
void start_unquantize(inout int2x3 endPoint[2], uint4 prec, bool transformed)
|
||||
{
|
||||
sign_extend( transformed, prec, endPoint );
|
||||
if ( transformed )
|
||||
sign_extend(transformed, prec, endPoint);
|
||||
if (transformed)
|
||||
{
|
||||
endPoint[0][1] += endPoint[0][0];
|
||||
endPoint[1][0] += endPoint[0][0];
|
||||
endPoint[1][1] += endPoint[0][0];
|
||||
}
|
||||
}
|
||||
void start_unquantize( inout int2x3 endPoint, uint4 prec, bool transformed )
|
||||
void start_unquantize(inout int2x3 endPoint, uint4 prec, bool transformed)
|
||||
{
|
||||
sign_extend( transformed, prec, endPoint );
|
||||
if ( transformed )
|
||||
sign_extend(transformed, prec, endPoint);
|
||||
if (transformed)
|
||||
endPoint[1] += endPoint[0];
|
||||
}
|
||||
void unquantize( inout int2x3 color, uint prec )
|
||||
void unquantize(inout int2x3 color, uint prec)
|
||||
{
|
||||
int iprec = asint( prec );
|
||||
if (g_format == UNSIGNED_F16 )
|
||||
int iprec = asint(prec);
|
||||
if (g_format == UNSIGNED_F16)
|
||||
{
|
||||
if (prec < 15)
|
||||
{
|
||||
|
@ -1178,33 +1178,33 @@ void unquantize( inout int2x3 color, uint prec )
|
|||
}
|
||||
}
|
||||
}
|
||||
uint3 finish_unquantize( int3 color )
|
||||
uint3 finish_unquantize(int3 color)
|
||||
{
|
||||
if ( g_format == UNSIGNED_F16 )
|
||||
color = ( color * 31 ) >> 6;
|
||||
if (g_format == UNSIGNED_F16)
|
||||
color = (color * 31) >> 6;
|
||||
else
|
||||
{
|
||||
color = ( color < 0 ) ? -( ( -color * 31 ) >> 5 ) : ( color * 31 ) >> 5;
|
||||
color = ( color < 0 ) ? ( ( -color ) | 0x8000 ) : color;
|
||||
color = (color < 0) ? -((-color * 31) >> 5) : (color * 31) >> 5;
|
||||
color = (color < 0) ? ((-color) | 0x8000) : color;
|
||||
}
|
||||
return asuint(color);
|
||||
}
|
||||
void generate_palette_unquantized8( out uint3 palette, int3 low, int3 high, int i )
|
||||
void generate_palette_unquantized8(out uint3 palette, int3 low, int3 high, int i)
|
||||
{
|
||||
static const int aWeight3[] = {0, 9, 18, 27, 37, 46, 55, 64};
|
||||
static const int aWeight3[] = { 0, 9, 18, 27, 37, 46, 55, 64 };
|
||||
|
||||
int3 tmp = ( low * ( 64 - aWeight3[i] ) + high * aWeight3[i] + 32 ) >> 6;
|
||||
palette = finish_unquantize( tmp );
|
||||
int3 tmp = (low * (64 - aWeight3[i]) + high * aWeight3[i] + 32) >> 6;
|
||||
palette = finish_unquantize(tmp);
|
||||
}
|
||||
void generate_palette_unquantized16( out uint3 palette, int3 low, int3 high, int i )
|
||||
void generate_palette_unquantized16(out uint3 palette, int3 low, int3 high, int i)
|
||||
{
|
||||
static const int aWeight4[] = {0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64};
|
||||
static const int aWeight4[] = { 0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64 };
|
||||
|
||||
int3 tmp = ( low * ( 64 - aWeight4[i] ) + high * aWeight4[i] + 32 ) >> 6;
|
||||
palette = finish_unquantize( tmp );
|
||||
int3 tmp = (low * (64 - aWeight4[i]) + high * aWeight4[i] + 32) >> 6;
|
||||
palette = finish_unquantize(tmp);
|
||||
}
|
||||
|
||||
float half2float1( uint Value )
|
||||
float half2float1(uint Value)
|
||||
{
|
||||
uint Mantissa = (uint)(Value & 0x03FF);
|
||||
|
||||
|
@ -1232,13 +1232,13 @@ float half2float1( uint Value )
|
|||
}
|
||||
|
||||
uint Result = ((Value & 0x8000) << 16) | // Sign
|
||||
((Exponent + 112) << 23) | // Exponent
|
||||
(Mantissa << 13); // Mantissa
|
||||
((Exponent + 112) << 23) | // Exponent
|
||||
(Mantissa << 13); // Mantissa
|
||||
|
||||
return asfloat(Result);
|
||||
}
|
||||
|
||||
float3 half2float(uint3 color_h )
|
||||
float3 half2float(uint3 color_h)
|
||||
{
|
||||
//uint3 sign = color_h & 0x8000;
|
||||
//uint3 expo = color_h & 0x7C00;
|
||||
|
@ -1246,17 +1246,17 @@ float3 half2float(uint3 color_h )
|
|||
//return ( expo == 0 ) ? asfloat( ( sign << 16 ) | asuint( float3(base) / 16777216 ) ) //16777216 = 2^24
|
||||
// : asfloat( ( sign << 16 ) | ( ( ( expo + 0x1C000 ) | base ) << 13 ) ); //0x1C000 = 0x1FC00 - 0x3C00
|
||||
|
||||
return float3( half2float1( color_h.x ), half2float1( color_h.y ), half2float1( color_h.z ) );
|
||||
return float3(half2float1(color_h.x), half2float1(color_h.y), half2float1(color_h.z));
|
||||
}
|
||||
|
||||
void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint partition_index ) // for mode 1 - 10
|
||||
void block_package(inout uint4 block, int2x3 endPoint[2], uint mode_type, uint partition_index) // for mode 1 - 10
|
||||
{
|
||||
block.xy = 0;
|
||||
block.z &= 0xFFFC0000;
|
||||
|
||||
//block.z |= (partition_index & 0x1f) << 13;
|
||||
|
||||
if ( mode_type == candidateModeFlag[0])
|
||||
if (mode_type == candidateModeFlag[0])
|
||||
{
|
||||
/*block.x = candidateModeMemory[0];
|
||||
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
|
||||
|
@ -1355,7 +1355,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
|
|||
block.z |= ((partition_index >> 3) & 1) << 16;
|
||||
block.z |= ((partition_index >> 4) & 1) << 17;
|
||||
}
|
||||
else if ( mode_type == candidateModeFlag[1])
|
||||
else if (mode_type == candidateModeFlag[1])
|
||||
{
|
||||
/*block.x = candidateModeMemory[1];
|
||||
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00000FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x003F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
|
||||
|
@ -1453,7 +1453,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
|
|||
block.z |= ((partition_index >> 3) & 1) << 16;
|
||||
block.z |= ((partition_index >> 4) & 1) << 17;
|
||||
}
|
||||
else if ( mode_type == candidateModeFlag[2])
|
||||
else if (mode_type == candidateModeFlag[2])
|
||||
{
|
||||
/*block.x = candidateModeMemory[2];
|
||||
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
|
||||
|
@ -1550,7 +1550,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
|
|||
block.z |= ((partition_index >> 3) & 1) << 16;
|
||||
block.z |= ((partition_index >> 4) & 1) << 17;
|
||||
}
|
||||
else if ( mode_type == candidateModeFlag[3])
|
||||
else if (mode_type == candidateModeFlag[3])
|
||||
{
|
||||
/*block.x = candidateModeMemory[3];
|
||||
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
|
||||
|
@ -1651,7 +1651,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
|
|||
block.z |= ((partition_index >> 3) & 1) << 16;
|
||||
block.z |= ((partition_index >> 4) & 1) << 17;
|
||||
}
|
||||
else if ( mode_type == candidateModeFlag[4])
|
||||
else if (mode_type == candidateModeFlag[4])
|
||||
{
|
||||
/*block.x = candidateModeMemory[4];
|
||||
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
|
||||
|
@ -1750,7 +1750,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
|
|||
block.z |= ((partition_index >> 3) & 1) << 16;
|
||||
block.z |= ((partition_index >> 4) & 1) << 17;
|
||||
}
|
||||
else if ( mode_type == candidateModeFlag[5])
|
||||
else if (mode_type == candidateModeFlag[5])
|
||||
{
|
||||
/*block.x = candidateModeMemory[5];
|
||||
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00003FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x00FF8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000);
|
||||
|
@ -1849,7 +1849,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
|
|||
block.z |= ((partition_index >> 3) & 1) << 16;
|
||||
block.z |= ((partition_index >> 4) & 1) << 17;
|
||||
}
|
||||
else if ( mode_type == candidateModeFlag[6])
|
||||
else if (mode_type == candidateModeFlag[6])
|
||||
{
|
||||
/*block.x = candidateModeMemory[6];
|
||||
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00001FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x007F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
|
||||
|
@ -1947,7 +1947,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
|
|||
block.z |= ((partition_index >> 3) & 1) << 16;
|
||||
block.z |= ((partition_index >> 4) & 1) << 17;
|
||||
}
|
||||
else if ( mode_type == candidateModeFlag[7])
|
||||
else if (mode_type == candidateModeFlag[7])
|
||||
{
|
||||
/*block.x = candidateModeMemory[7];
|
||||
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00001FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x007F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
|
||||
|
@ -2047,7 +2047,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
|
|||
block.z |= ((partition_index >> 3) & 1) << 16;
|
||||
block.z |= ((partition_index >> 4) & 1) << 17;
|
||||
}
|
||||
else if ( mode_type == candidateModeFlag[8])
|
||||
else if (mode_type == candidateModeFlag[8])
|
||||
{
|
||||
/*block.x = candidateModeMemory[8];
|
||||
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x00001FE0 ) | ( ( endPoint[0][0].g << 15 ) & 0x007F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0xFE000000 );
|
||||
|
@ -2147,7 +2147,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
|
|||
block.z |= ((partition_index >> 3) & 1) << 16;
|
||||
block.z |= ((partition_index >> 4) & 1) << 17;
|
||||
}
|
||||
else if ( mode_type == candidateModeFlag[9])
|
||||
else if (mode_type == candidateModeFlag[9])
|
||||
{
|
||||
/*block.x = candidateModeMemory[9];
|
||||
block.x |= ( ( endPoint[0][0].r << 5 ) & 0x000007E0 ) | ( ( endPoint[0][0].g << 15 ) & 0x001F8000 ) | ( ( endPoint[0][0].b << 25 ) & 0x7E000000 );
|
||||
|
@ -2246,7 +2246,7 @@ void block_package( inout uint4 block, int2x3 endPoint[2], uint mode_type, uint
|
|||
block.z |= ((partition_index >> 4) & 1) << 17;
|
||||
}
|
||||
}
|
||||
void block_package( inout uint4 block, int2x3 endPoint, uint mode_type ) // for mode 11 - 14
|
||||
void block_package(inout uint4 block, int2x3 endPoint, uint mode_type) // for mode 11 - 14
|
||||
{
|
||||
/*block.x = ( ( endPoint[0].r << 5 ) & 0x00007FE0 ) | ( ( endPoint[0].g << 15 ) & 0x01FF8000 ) | ( ( endPoint[0].b << 25 ) & 0xFE000000 );
|
||||
block.y |= ( endPoint[0].b >> 7 ) & 0x00000007;*/
|
||||
|
@ -2255,11 +2255,11 @@ void block_package( inout uint4 block, int2x3 endPoint, uint mode_type ) // for
|
|||
block.z &= 0xFFFFFFFE;
|
||||
|
||||
|
||||
if ( mode_type == candidateModeFlag[10])
|
||||
if (mode_type == candidateModeFlag[10])
|
||||
{
|
||||
/* block.x |= candidateModeMemory[10];
|
||||
block.y |= ( ( endPoint[1].r << 3 ) & 0x00001FF8 ) | ( ( endPoint[1].g << 13 ) & 0x007FE000 ) | ( ( endPoint[1].b << 23 ) & 0xFF800000 );
|
||||
block.z |= ( endPoint[1].b >> 9 ) & 0x00000001;*/
|
||||
/* block.x |= candidateModeMemory[10];
|
||||
block.y |= ( ( endPoint[1].r << 3 ) & 0x00001FF8 ) | ( ( endPoint[1].g << 13 ) & 0x007FE000 ) | ( ( endPoint[1].b << 23 ) & 0xFF800000 );
|
||||
block.z |= ( endPoint[1].b >> 9 ) & 0x00000001;*/
|
||||
|
||||
block.x |= ((candidateModeMemory[10] >> 0) & 1) << 0;
|
||||
block.x |= ((candidateModeMemory[10] >> 1) & 1) << 1;
|
||||
|
|
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
|
@ -37,13 +37,14 @@ if %error% == 0 (
|
|||
echo Shaders compiled ok
|
||||
) else (
|
||||
echo There were shader compilation errors!
|
||||
exit /b 1
|
||||
)
|
||||
|
||||
endlocal
|
||||
exit /b
|
||||
exit /b 0
|
||||
|
||||
:CompileShader
|
||||
set fxc=%PCFXC% %1.hlsl %FXCOPTS% /Tcs_4_0 /E%2 "/Fh%CompileShadersOutput%\%1_%2.inc" "/Fd%CompileShadersOutput%\%1_%2.pdb" /Vn%1_%2
|
||||
set fxc=%PCFXC% "%1.hlsl" %FXCOPTS% /Tcs_4_0 /E%2 "/Fh%CompileShadersOutput%\%1_%2.inc" "/Fd%CompileShadersOutput%\%1_%2.pdb" /Vn%1_%2
|
||||
echo.
|
||||
echo %fxc%
|
||||
%fxc% || set error=1
|
||||
|
|
|
@ -28,7 +28,7 @@ namespace DirectX
|
|||
XMGLOBALCONST XMVECTORF32 g_boxScale = { { { 0.25f, 0.25f, 0.25f, 0.25f } } };
|
||||
XMGLOBALCONST XMVECTORF32 g_boxScale3D = { { { 0.125f, 0.125f, 0.125f, 0.125f } } };
|
||||
|
||||
#define AVERAGE4( res, p0, p1, p2, p3 ) \
|
||||
#define AVERAGE4( res, p0, p1, p2, p3 ) \
|
||||
{ \
|
||||
XMVECTOR v = XMVectorAdd((p0), (p1)); \
|
||||
v = XMVectorAdd(v, (p2)); \
|
||||
|
@ -36,7 +36,7 @@ namespace DirectX
|
|||
res = XMVectorMultiply(v, g_boxScale); \
|
||||
}
|
||||
|
||||
#define AVERAGE8( res, p0, p1, p2, p3, p4, p5, p6, p7) \
|
||||
#define AVERAGE8( res, p0, p1, p2, p3, p4, p5, p6, p7) \
|
||||
{ \
|
||||
XMVECTOR v = XMVectorAdd((p0), (p1)); \
|
||||
v = XMVectorAdd(v, (p2)); \
|
||||
|
@ -99,11 +99,11 @@ namespace DirectX
|
|||
}
|
||||
}
|
||||
|
||||
#define BILINEAR_INTERPOLATE( res, x, y, r0, r1 ) \
|
||||
#define BILINEAR_INTERPOLATE( res, x, y, r0, r1 ) \
|
||||
res = XMVectorAdd(XMVectorScale(XMVectorAdd(XMVectorScale((r0)[ x.u0 ], x.weight0), XMVectorScale((r0)[ x.u1 ], x.weight1)), y.weight0), \
|
||||
XMVectorScale(XMVectorAdd(XMVectorScale((r1)[ x.u0 ], x.weight0), XMVectorScale((r1)[ x.u1 ], x.weight1)), y.weight1) );
|
||||
|
||||
#define TRILINEAR_INTERPOLATE( res, x, y, z, r0, r1, r2, r3 ) \
|
||||
#define TRILINEAR_INTERPOLATE( res, x, y, z, r0, r1, r2, r3 ) \
|
||||
{\
|
||||
const XMVECTOR a0 = XMVectorScale(XMVectorAdd(XMVectorScale((r0)[ x.u0 ], x.weight0 ), XMVectorScale((r0)[ x.u1 ], x.weight1)), y.weight0); \
|
||||
const XMVECTOR a1 = XMVectorScale(XMVectorAdd(XMVectorScale((r1)[ x.u0 ], x.weight0 ), XMVectorScale((r1)[ x.u1 ], x.weight1)), y.weight1); \
|
||||
|
@ -189,7 +189,7 @@ namespace DirectX
|
|||
}
|
||||
}
|
||||
|
||||
#define CUBIC_INTERPOLATE( res, dx, p0, p1, p2, p3 ) \
|
||||
#define CUBIC_INTERPOLATE( res, dx, p0, p1, p2, p3 ) \
|
||||
{ \
|
||||
const XMVECTOR a0 = (p1); \
|
||||
const XMVECTOR d0 = XMVectorSubtract(p0, a0); \
|
||||
|
|
|
@ -15,7 +15,7 @@
|
|||
#include <memory>
|
||||
#include <tuple>
|
||||
|
||||
#ifndef WIN32
|
||||
#ifndef _WIN32
|
||||
#include <cstdlib>
|
||||
|
||||
struct aligned_deleter { void operator()(void* p) noexcept { free(p); } };
|
||||
|
@ -29,7 +29,7 @@ inline ScopedAlignedArrayFloat make_AlignedArrayFloat(uint64_t count)
|
|||
if (size > static_cast<uint64_t>(UINT32_MAX))
|
||||
return nullptr;
|
||||
|
||||
auto ptr = aligned_alloc(16, static_cast<size_t>(size) );
|
||||
auto ptr = aligned_alloc(16, static_cast<size_t>(size));
|
||||
return ScopedAlignedArrayFloat(static_cast<float*>(ptr));
|
||||
}
|
||||
|
||||
|
|
|
@ -45,12 +45,12 @@ namespace
|
|||
{
|
||||
blob.reset();
|
||||
|
||||
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
|
||||
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
|
||||
ScopedHandle hFile(safe_handle(CreateFile2(szFile, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr)));
|
||||
#else
|
||||
#else
|
||||
ScopedHandle hFile(safe_handle(CreateFileW(szFile, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
|
||||
FILE_FLAG_SEQUENTIAL_SCAN, nullptr)));
|
||||
#endif
|
||||
#endif
|
||||
if (!hFile)
|
||||
{
|
||||
return HRESULT_FROM_WIN32(GetLastError());
|
||||
|
|
|
@ -23,6 +23,7 @@
|
|||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <cstdio>
|
||||
#include <memory>
|
||||
#include <new>
|
||||
#include <tuple>
|
||||
|
@ -82,12 +83,12 @@ namespace
|
|||
{
|
||||
blob.reset();
|
||||
|
||||
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
|
||||
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
|
||||
ScopedHandle hFile(safe_handle(CreateFile2(szFile, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr)));
|
||||
#else
|
||||
#else
|
||||
ScopedHandle hFile(safe_handle(CreateFileW(szFile, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
|
||||
FILE_FLAG_SEQUENTIAL_SCAN, nullptr)));
|
||||
#endif
|
||||
#endif
|
||||
if (!hFile)
|
||||
{
|
||||
return HRESULT_FROM_WIN32(GetLastError());
|
||||
|
@ -257,30 +258,30 @@ HRESULT __cdecl LoadFromPortablePixMap(
|
|||
break;
|
||||
|
||||
case PPM_HEIGHT:
|
||||
{
|
||||
if (u == 0)
|
||||
return E_FAIL;
|
||||
|
||||
if (metadata)
|
||||
{
|
||||
*metadata = {};
|
||||
metadata->width = width;
|
||||
metadata->height = u;
|
||||
metadata->depth = metadata->arraySize = metadata->mipLevels = 1;
|
||||
metadata->format = DXGI_FORMAT_R8G8B8A8_UNORM;
|
||||
metadata->dimension = TEX_DIMENSION_TEXTURE2D;
|
||||
if (u == 0)
|
||||
return E_FAIL;
|
||||
|
||||
if (metadata)
|
||||
{
|
||||
*metadata = {};
|
||||
metadata->width = width;
|
||||
metadata->height = u;
|
||||
metadata->depth = metadata->arraySize = metadata->mipLevels = 1;
|
||||
metadata->format = DXGI_FORMAT_R8G8B8A8_UNORM;
|
||||
metadata->dimension = TEX_DIMENSION_TEXTURE2D;
|
||||
}
|
||||
|
||||
hr = image.Initialize2D(DXGI_FORMAT_R8G8B8A8_UNORM, width, u, 1, 1);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
auto img = image.GetImage(0, 0, 0);
|
||||
|
||||
pixels = reinterpret_cast<uint32_t*>(img->pixels);
|
||||
pixelEnd = pixels + width * u;
|
||||
}
|
||||
|
||||
hr = image.Initialize2D(DXGI_FORMAT_R8G8B8A8_UNORM, width, u, 1, 1);
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
|
||||
auto img = image.GetImage(0, 0, 0);
|
||||
|
||||
pixels = reinterpret_cast<uint32_t*>(img->pixels);
|
||||
pixelEnd = pixels + width * u;
|
||||
}
|
||||
break;
|
||||
break;
|
||||
|
||||
case PPM_MAX:
|
||||
if (u == 0)
|
||||
|
|
|
@ -20,11 +20,14 @@
|
|||
#define NOHELP
|
||||
#pragma warning(pop)
|
||||
|
||||
#include <ShlObj.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <cstddef>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <cwchar>
|
||||
#include <cwctype>
|
||||
#include <fstream>
|
||||
|
@ -46,7 +49,6 @@
|
|||
#include <wincodec.h>
|
||||
|
||||
#pragma warning(disable : 4619 4616 4091 4838 26812)
|
||||
#include <ShlObj.h>
|
||||
|
||||
#include "DirectXTex.h"
|
||||
#include "DirectXTexXbox.h"
|
||||
|
@ -788,16 +790,16 @@ namespace
|
|||
switch (info.GetAlphaMode())
|
||||
{
|
||||
case TEX_ALPHA_MODE_OPAQUE:
|
||||
wprintf(L" \x0e0:Opaque");
|
||||
wprintf(L" \x03B1:Opaque");
|
||||
break;
|
||||
case TEX_ALPHA_MODE_PREMULTIPLIED:
|
||||
wprintf(L" \x0e0:PM");
|
||||
wprintf(L" \x03B1:PM");
|
||||
break;
|
||||
case TEX_ALPHA_MODE_STRAIGHT:
|
||||
wprintf(L" \x0e0:NonPM");
|
||||
wprintf(L" \x03B1:NonPM");
|
||||
break;
|
||||
case TEX_ALPHA_MODE_CUSTOM:
|
||||
wprintf(L" \x0e0:Custom");
|
||||
wprintf(L" \x03B1:Custom");
|
||||
break;
|
||||
case TEX_ALPHA_MODE_UNKNOWN:
|
||||
break;
|
||||
|
@ -871,81 +873,97 @@ namespace
|
|||
{
|
||||
PrintLogo();
|
||||
|
||||
wprintf(L"Usage: texconv <options> <files>\n\n");
|
||||
wprintf(L" -r wildcard filename search is recursive\n");
|
||||
wprintf(L" -r:flatten flatten the directory structure (default)\n");
|
||||
wprintf(L" -r:keep keep the directory structure\n");
|
||||
wprintf(L" -flist <filename> use text file with a list of input files (one per line)\n");
|
||||
wprintf(L"\n -w <n> width\n");
|
||||
wprintf(L" -h <n> height\n");
|
||||
wprintf(L" -m <n> miplevels\n");
|
||||
wprintf(L" -f <format> format\n");
|
||||
wprintf(L"\n -if <filter> image filtering\n");
|
||||
wprintf(L" -srgb{i|o} sRGB {input, output}\n");
|
||||
wprintf(L"\n -px <string> name prefix\n");
|
||||
wprintf(L" -sx <string> name suffix\n");
|
||||
wprintf(L" -o <directory> output directory\n");
|
||||
wprintf(L" -l force output filename to lower case\n");
|
||||
wprintf(L" -y overwrite existing output file (if any)\n");
|
||||
wprintf(L" -ft <filetype> output file type\n");
|
||||
wprintf(L"\n -hflip horizonal flip of source image\n");
|
||||
wprintf(L" -vflip vertical flip of source image\n");
|
||||
wprintf(L"\n -sepalpha resize/generate mips alpha channel separately\n");
|
||||
wprintf(L" from color channels\n");
|
||||
wprintf(L" -keepcoverage <ref> Preserve alpha coverage in mips for alpha test ref\n");
|
||||
wprintf(L"\n -nowic Force non-WIC filtering\n");
|
||||
wprintf(L" -wrap, -mirror texture addressing mode (wrap, mirror, or clamp)\n");
|
||||
wprintf(L" -pmalpha convert final texture to use premultiplied alpha\n");
|
||||
wprintf(L" -alpha convert premultiplied alpha to straight alpha\n");
|
||||
wprintf(
|
||||
static const wchar_t* const s_usage =
|
||||
L"Usage: texconv <options> <files>\n"
|
||||
L"\n"
|
||||
L" -r wildcard filename search is recursive\n"
|
||||
L" -r:flatten flatten the directory structure (default)\n"
|
||||
L" -r:keep keep the directory structure\n"
|
||||
L" -flist <filename> use text file with a list of input files (one per line)\n"
|
||||
L"\n"
|
||||
L" -w <n> width\n"
|
||||
L" -h <n> height\n"
|
||||
L" -m <n> miplevels\n"
|
||||
L" -f <format> format\n"
|
||||
L"\n"
|
||||
L" -if <filter> image filtering\n"
|
||||
L" -srgb{i|o} sRGB {input, output}\n"
|
||||
L"\n"
|
||||
L" -px <string> name prefix\n"
|
||||
L" -sx <string> name suffix\n"
|
||||
L" -o <directory> output directory\n"
|
||||
L" -l force output filename to lower case\n"
|
||||
L" -y overwrite existing output file (if any)\n"
|
||||
L" -ft <filetype> output file type\n"
|
||||
L"\n"
|
||||
L" -hflip horizonal flip of source image\n"
|
||||
L" -vflip vertical flip of source image\n"
|
||||
L"\n"
|
||||
L" -sepalpha resize/generate mips alpha channel separately\n"
|
||||
L" from color channels\n"
|
||||
L" -keepcoverage <ref> Preserve alpha coverage in mips for alpha test ref\n"
|
||||
L"\n"
|
||||
L" -nowic Force non-WIC filtering\n"
|
||||
L" -wrap, -mirror texture addressing mode (wrap, mirror, or clamp)\n"
|
||||
L" -pmalpha convert final texture to use premultiplied alpha\n"
|
||||
L" -alpha convert premultiplied alpha to straight alpha\n"
|
||||
L" -at <threshold> Alpha threshold used for BC1, RGBA5551, and WIC\n"
|
||||
L" (defaults to 0.5)\n");
|
||||
wprintf(L"\n -fl <feature-level> Set maximum feature level target (defaults to 11.0)\n");
|
||||
wprintf(L" -pow2 resize to fit a power-of-2, respecting aspect ratio\n");
|
||||
wprintf(
|
||||
L"\n -nmap <options> converts height-map to normal-map\n"
|
||||
L" (defaults to 0.5)\n"
|
||||
L"\n"
|
||||
L" -fl <feature-level> Set maximum feature level target (defaults to 11.0)\n"
|
||||
L" -pow2 resize to fit a power-of-2, respecting aspect ratio\n"
|
||||
L"\n"
|
||||
L" -nmap <options> converts height-map to normal-map\n"
|
||||
L" options must be one or more of\n"
|
||||
L" r, g, b, a, l, m, u, v, i, o\n");
|
||||
wprintf(L" -nmapamp <weight> normal map amplitude (defaults to 1.0)\n");
|
||||
wprintf(L"\n (DDS input only)\n");
|
||||
wprintf(L" -t{u|f} TYPELESS format is treated as UNORM or FLOAT\n");
|
||||
wprintf(L" -dword Use DWORD instead of BYTE alignment\n");
|
||||
wprintf(L" -badtails Fix for older DXTn with bad mipchain tails\n");
|
||||
wprintf(L" -fixbc4x4 Fix for odd-sized BC files that Direct3D can't load\n");
|
||||
wprintf(L" -xlum expand legacy L8, L16, and A8P8 formats\n");
|
||||
wprintf(L"\n (DDS output only)\n");
|
||||
wprintf(L" -dx10 Force use of 'DX10' extended header\n");
|
||||
wprintf(L" -dx9 Force use of legacy DX9 header\n");
|
||||
wprintf(L" -xbox Tile and use 'XBOX' variant of DDS\n");
|
||||
wprintf(L" -xgmode <mode> Tile using provided memory layout mode\n");
|
||||
wprintf(L"\n (TGA output only)\n");
|
||||
wprintf(L" -tga20 Write file including TGA 2.0 extension area\n");
|
||||
wprintf(L"\n (BMP, PNG, JPG, TIF, WDP output only)\n");
|
||||
wprintf(L" -wicq <quality> When writing images with WIC use quality (0.0 to 1.0)\n");
|
||||
wprintf(L" -wiclossless When writing images with WIC use lossless mode\n");
|
||||
wprintf(L" -wicmulti When writing images with WIC encode multiframe images\n");
|
||||
wprintf(L"\n -nologo suppress copyright message\n");
|
||||
wprintf(L" -timing Display elapsed processing time\n\n");
|
||||
L" r, g, b, a, l, m, u, v, i, o\n"
|
||||
L" -nmapamp <weight> normal map amplitude (defaults to 1.0)\n"
|
||||
L"\n"
|
||||
L" (DDS input only)\n"
|
||||
L" -t{u|f} TYPELESS format is treated as UNORM or FLOAT\n"
|
||||
L" -dword Use DWORD instead of BYTE alignment\n"
|
||||
L" -badtails Fix for older DXTn with bad mipchain tails\n"
|
||||
L" -fixbc4x4 Fix for odd-sized BC files that Direct3D can't load\n"
|
||||
L" -xlum expand legacy L8, L16, and A8P8 formats\n"
|
||||
L"\n"
|
||||
L" (DDS output only)\n"
|
||||
L" -dx10 Force use of 'DX10' extended header\n"
|
||||
L" -dx9 Force use of legacy DX9 header\n"
|
||||
L" -xbox Tile and use 'XBOX' variant of DDS\n"
|
||||
L" -xgmode <mode> Tile using provided memory layout mode\n"
|
||||
L"\n"
|
||||
L" (TGA output only)\n"
|
||||
L" -tga20 Write file including TGA 2.0 extension area\n"
|
||||
L"\n"
|
||||
L" (BMP, PNG, JPG, TIF, WDP output only)\n"
|
||||
L" -wicq <quality> When writing images with WIC use quality (0.0 to 1.0)\n"
|
||||
L" -wiclossless When writing images with WIC use lossless mode\n"
|
||||
L" -wicmulti When writing images with WIC encode multiframe images\n"
|
||||
L"\n"
|
||||
L" -nologo suppress copyright message\n"
|
||||
L" -timing Display elapsed processing time\n"
|
||||
L"\n"
|
||||
#ifdef _OPENMP
|
||||
wprintf(L" -singleproc Do not use multi-threaded compression\n");
|
||||
L" -singleproc Do not use multi-threaded compression\n"
|
||||
#endif
|
||||
wprintf(L" -gpu <adapter> Select GPU for DirectCompute-based codecs (0 is default)\n");
|
||||
wprintf(L" -nogpu Do not use DirectCompute-based codecs\n");
|
||||
wprintf(
|
||||
L"\n -bc <options> Sets options for BC compression\n"
|
||||
L" -gpu <adapter> Select GPU for DirectCompute-based codecs (0 is default)\n"
|
||||
L" -nogpu Do not use DirectCompute-based codecs\n"
|
||||
L"\n"
|
||||
L" -bc <options> Sets options for BC compression\n"
|
||||
L" options must be one or more of\n"
|
||||
L" d, u, q, x\n");
|
||||
wprintf(
|
||||
L" d, u, q, x\n"
|
||||
L" -aw <weight> BC7 GPU compressor weighting for alpha error metric\n"
|
||||
L" (defaults to 1.0)\n");
|
||||
wprintf(L"\n -c <hex-RGB> colorkey (a.k.a. chromakey) transparency\n");
|
||||
wprintf(L" -rotatecolor <rot> rotates color primaries and/or applies a curve\n");
|
||||
wprintf(L" -nits <value> paper-white value in nits to use for HDR10 (def: 200.0)\n");
|
||||
wprintf(L" -tonemap Apply a tonemap operator based on maximum luminance\n");
|
||||
wprintf(L" -x2bias Enable *2 - 1 conversion cases for unorm/pos-only-float\n");
|
||||
wprintf(L" -inverty Invert Y (i.e. green) channel values\n");
|
||||
wprintf(L" -reconstructz Rebuild Z (blue) channel assuming X/Y are normals\n");
|
||||
wprintf(L" -swizzle <rgba> Swizzle image channels using HLSL-style mask\n");
|
||||
L" (defaults to 1.0)\n"
|
||||
L"\n"
|
||||
L" -c <hex-RGB> colorkey (a.k.a. chromakey) transparency\n"
|
||||
L" -rotatecolor <rot> rotates color primaries and/or applies a curve\n"
|
||||
L" -nits <value> paper-white value in nits to use for HDR10 (def: 200.0)\n"
|
||||
L" -tonemap Apply a tonemap operator based on maximum luminance\n"
|
||||
L" -x2bias Enable *2 - 1 conversion cases for unorm/pos-only-float\n"
|
||||
L" -inverty Invert Y (i.e. green) channel values\n"
|
||||
L" -reconstructz Rebuild Z (blue) channel assuming X/Y are normals\n"
|
||||
L" -swizzle <rgba> Swizzle image channels using HLSL-style mask\n";
|
||||
|
||||
wprintf(L"%ls", s_usage);
|
||||
|
||||
wprintf(L"\n <format>: ");
|
||||
PrintList(13, g_pFormats);
|
||||
|
@ -2097,7 +2115,9 @@ int __cdecl wmain(_In_ int argc, _In_z_count_(argc) wchar_t* argv[])
|
|||
}
|
||||
else if (_wcsicmp(ext, L".tga") == 0)
|
||||
{
|
||||
hr = LoadFromTGAFile(pConv->szSrc, TGA_FLAGS_NONE, &info, *image);
|
||||
TGA_FLAGS tgaFlags = (IsBGR(format)) ? TGA_FLAGS_BGR : TGA_FLAGS_NONE;
|
||||
|
||||
hr = LoadFromTGAFile(pConv->szSrc, tgaFlags, &info, *image);
|
||||
if (FAILED(hr))
|
||||
{
|
||||
wprintf(L" FAILED (%08X%ls)\n", static_cast<unsigned int>(hr), GetErrorDesc(hr));
|
||||
|
@ -2909,7 +2929,7 @@ int __cdecl wmain(_In_ int argc, _In_z_count_(argc) wchar_t* argv[])
|
|||
{
|
||||
case DXGI_FORMAT_BC4_SNORM:
|
||||
case DXGI_FORMAT_BC5_SNORM:
|
||||
nmfmt = DXGI_FORMAT_R8G8B8A8_SNORM;
|
||||
nmfmt = (BitsPerColor(info.format) > 8) ? DXGI_FORMAT_R16G16B16A16_SNORM : DXGI_FORMAT_R8G8B8A8_SNORM;
|
||||
break;
|
||||
|
||||
case DXGI_FORMAT_BC6H_SF16:
|
||||
|
@ -2918,7 +2938,7 @@ int __cdecl wmain(_In_ int argc, _In_z_count_(argc) wchar_t* argv[])
|
|||
break;
|
||||
|
||||
default:
|
||||
nmfmt = DXGI_FORMAT_R8G8B8A8_UNORM;
|
||||
nmfmt = (BitsPerColor(info.format) > 8) ? DXGI_FORMAT_R16G16B16A16_UNORM : DXGI_FORMAT_R8G8B8A8_UNORM;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
Загрузка…
Ссылка в новой задаче