mirror of
https://github.com/love2d/love.git
synced 2026-08-15 15:51:12 +02:00
Compressed texture formats have explicit sRGB variants
This commit is contained in:
@@ -925,7 +925,7 @@ void Graphics::setRenderTargets(const RenderTargets &rts)
|
||||
PixelFormat dsformat = PIXELFORMAT_STENCIL8;
|
||||
if (wantsdepth && wantsstencil)
|
||||
dsformat = PIXELFORMAT_DEPTH24_UNORM_STENCIL8;
|
||||
else if (wantsdepth && isPixelFormatSupported(PIXELFORMAT_DEPTH24_UNORM, PIXELFORMATUSAGEFLAGS_RENDERTARGET, false))
|
||||
else if (wantsdepth && isPixelFormatSupported(PIXELFORMAT_DEPTH24_UNORM, PIXELFORMATUSAGEFLAGS_RENDERTARGET))
|
||||
dsformat = PIXELFORMAT_DEPTH24_UNORM;
|
||||
else if (wantsdepth)
|
||||
dsformat = PIXELFORMAT_DEPTH16_UNORM;
|
||||
@@ -2395,7 +2395,7 @@ PixelFormat Graphics::getSizedFormat(PixelFormat format) const
|
||||
{
|
||||
case PIXELFORMAT_NORMAL:
|
||||
if (isGammaCorrect())
|
||||
return PIXELFORMAT_RGBA8_UNORM_sRGB;
|
||||
return PIXELFORMAT_RGBA8_sRGB;
|
||||
else
|
||||
return PIXELFORMAT_RGBA8_UNORM;
|
||||
case PIXELFORMAT_HDR:
|
||||
|
||||
@@ -824,7 +824,7 @@ public:
|
||||
/**
|
||||
* Gets whether the specified pixel format usage is supported.
|
||||
**/
|
||||
virtual bool isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRGB = false) = 0;
|
||||
virtual bool isPixelFormatSupported(PixelFormat format, uint32 usage) = 0;
|
||||
|
||||
/**
|
||||
* Gets the renderer used by love.graphics.
|
||||
|
||||
@@ -168,7 +168,6 @@ Texture::Texture(Graphics *gfx, const Settings &settings, const Slices *slices)
|
||||
, computeWrite(settings.computeWrite)
|
||||
, readable(true)
|
||||
, mipmapsMode(settings.mipmaps)
|
||||
, sRGB(false)
|
||||
, width(settings.width)
|
||||
, height(settings.height)
|
||||
, depth(settings.type == TEXTURE_VOLUME ? settings.layers : 1)
|
||||
@@ -236,7 +235,8 @@ Texture::Texture(Graphics *gfx, const Settings &settings, const Slices *slices)
|
||||
readable = !renderTarget || !isPixelFormatDepthStencil(format);
|
||||
|
||||
format = gfx->getSizedFormat(format);
|
||||
sRGB = isPixelFormatSRGB(format) || (isCompressed() && isGammaCorrect() && !settings.linear);
|
||||
if (!isGammaCorrect() || settings.linear)
|
||||
format = getLinearPixelFormat(format);
|
||||
|
||||
if (mipmapsMode == MIPMAPS_AUTO && isCompressed())
|
||||
mipmapsMode = MIPMAPS_MANUAL;
|
||||
@@ -291,7 +291,7 @@ Texture::Texture(Graphics *gfx, const Settings &settings, const Slices *slices)
|
||||
if (computeWrite)
|
||||
usage |= PIXELFORMATUSAGEFLAGS_COMPUTEWRITE;
|
||||
|
||||
if (!gfx->isPixelFormatSupported(format, (PixelFormatUsageFlags) usage, sRGB))
|
||||
if (!gfx->isPixelFormatSupported(format, (PixelFormatUsageFlags) usage))
|
||||
{
|
||||
const char *fstr = "unknown";
|
||||
love::getConstant(format, fstr);
|
||||
@@ -622,7 +622,7 @@ bool Texture::isCompressed() const
|
||||
|
||||
bool Texture::isFormatLinear() const
|
||||
{
|
||||
return isGammaCorrect() && !sRGB && !isPixelFormatSRGB(format);
|
||||
return isGammaCorrect() && !isPixelFormatSRGB(format);
|
||||
}
|
||||
|
||||
bool Texture::isValidSlice(int slice, int mip) const
|
||||
|
||||
@@ -325,8 +325,6 @@ protected:
|
||||
|
||||
MipmapsMode mipmapsMode;
|
||||
|
||||
bool sRGB;
|
||||
|
||||
int width;
|
||||
int height;
|
||||
|
||||
|
||||
@@ -110,7 +110,7 @@ public:
|
||||
|
||||
void setWireframe(bool enable) override;
|
||||
|
||||
bool isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRGB = false) override;
|
||||
bool isPixelFormatSupported(PixelFormat format, uint32 usage) override;
|
||||
Renderer getRenderer() const override;
|
||||
bool usesGLSLES() const override;
|
||||
RendererInfo getRendererInfo() const override;
|
||||
|
||||
@@ -503,7 +503,7 @@ void Graphics::setViewportSize(int width, int height, int pixelwidth, int pixelh
|
||||
backbufferMSAA.set(nullptr);
|
||||
if (settings.msaa > 1)
|
||||
{
|
||||
settings.format = isGammaCorrect() ? PIXELFORMAT_BGRA8_UNORM_sRGB : PIXELFORMAT_BGRA8_UNORM;
|
||||
settings.format = isGammaCorrect() ? PIXELFORMAT_BGRA8_sRGB : PIXELFORMAT_BGRA8_UNORM;
|
||||
backbufferMSAA.set(newTexture(settings), Acquire::NORETAIN);
|
||||
}
|
||||
|
||||
@@ -681,7 +681,7 @@ id<MTLRenderCommandEncoder> Graphics::useRenderEncoder()
|
||||
attachmentStoreActions.stencil = MTLStoreActionDontCare;
|
||||
|
||||
auto &key = lastRenderPipelineKey;
|
||||
key.colorRenderTargetFormats = isGammaCorrect() ? PIXELFORMAT_BGRA8_UNORM_sRGB : PIXELFORMAT_BGRA8_UNORM;
|
||||
key.colorRenderTargetFormats = isGammaCorrect() ? PIXELFORMAT_BGRA8_sRGB : PIXELFORMAT_BGRA8_UNORM;
|
||||
key.depthStencilFormat = backbufferDepthStencil->getPixelFormat();
|
||||
key.msaa = backbufferMSAA ? (uint8) backbufferMSAA->getMSAA() : 1;
|
||||
}
|
||||
@@ -1864,13 +1864,10 @@ void Graphics::setWireframe(bool enable)
|
||||
}
|
||||
}
|
||||
|
||||
bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRGB)
|
||||
bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage)
|
||||
{
|
||||
format = getSizedFormat(format);
|
||||
|
||||
if (sRGB)
|
||||
format = getSRGBPixelFormat(format);
|
||||
|
||||
const uint32 sample = PIXELFORMATUSAGEFLAGS_SAMPLE;
|
||||
const uint32 filter = PIXELFORMATUSAGEFLAGS_LINEAR;
|
||||
const uint32 rt = PIXELFORMATUSAGEFLAGS_RENDERTARGET;
|
||||
@@ -1958,8 +1955,8 @@ bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRG
|
||||
case PIXELFORMAT_BGRA8_UNORM:
|
||||
flags |= all;
|
||||
break;
|
||||
case PIXELFORMAT_RGBA8_UNORM_sRGB:
|
||||
case PIXELFORMAT_BGRA8_UNORM_sRGB:
|
||||
case PIXELFORMAT_RGBA8_sRGB:
|
||||
case PIXELFORMAT_BGRA8_sRGB:
|
||||
if (families.apple[1] || families.mac[1] || families.macCatalyst[1])
|
||||
flags |= commonsample | commonrender;
|
||||
if (families.apple[2])
|
||||
@@ -2058,8 +2055,11 @@ bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRG
|
||||
break;
|
||||
|
||||
case PIXELFORMAT_DXT1_UNORM:
|
||||
case PIXELFORMAT_DXT1_sRGB:
|
||||
case PIXELFORMAT_DXT3_UNORM:
|
||||
case PIXELFORMAT_DXT3_sRGB:
|
||||
case PIXELFORMAT_DXT5_UNORM:
|
||||
case PIXELFORMAT_DXT5_sRGB:
|
||||
case PIXELFORMAT_BC4_UNORM:
|
||||
case PIXELFORMAT_BC4_SNORM:
|
||||
case PIXELFORMAT_BC5_UNORM:
|
||||
@@ -2067,22 +2067,30 @@ bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRG
|
||||
case PIXELFORMAT_BC6H_UFLOAT:
|
||||
case PIXELFORMAT_BC6H_FLOAT:
|
||||
case PIXELFORMAT_BC7_UNORM:
|
||||
case PIXELFORMAT_BC7_sRGB:
|
||||
if (families.mac[1] || families.macCatalyst[1])
|
||||
flags |= commonsample;
|
||||
break;
|
||||
|
||||
case PIXELFORMAT_PVR1_RGB2_UNORM:
|
||||
case PIXELFORMAT_PVR1_RGB2_sRGB:
|
||||
case PIXELFORMAT_PVR1_RGB4_UNORM:
|
||||
case PIXELFORMAT_PVR1_RGB4_sRGB:
|
||||
case PIXELFORMAT_PVR1_RGBA2_UNORM:
|
||||
case PIXELFORMAT_PVR1_RGBA2_sRGB:
|
||||
case PIXELFORMAT_PVR1_RGBA4_UNORM:
|
||||
case PIXELFORMAT_PVR1_RGBA4_sRGB:
|
||||
if (families.apple[1])
|
||||
flags |= commonsample;
|
||||
break;
|
||||
|
||||
case PIXELFORMAT_ETC1_UNORM:
|
||||
case PIXELFORMAT_ETC2_RGB_UNORM:
|
||||
case PIXELFORMAT_ETC2_RGB_sRGB:
|
||||
case PIXELFORMAT_ETC2_RGBA_UNORM:
|
||||
case PIXELFORMAT_ETC2_RGBA_sRGB:
|
||||
case PIXELFORMAT_ETC2_RGBA1_UNORM:
|
||||
case PIXELFORMAT_ETC2_RGBA1_sRGB:
|
||||
case PIXELFORMAT_EAC_R_UNORM:
|
||||
case PIXELFORMAT_EAC_R_SNORM:
|
||||
case PIXELFORMAT_EAC_RG_UNORM:
|
||||
@@ -2091,20 +2099,34 @@ bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRG
|
||||
flags |= commonsample;
|
||||
break;
|
||||
|
||||
case PIXELFORMAT_ASTC_4x4:
|
||||
case PIXELFORMAT_ASTC_5x4:
|
||||
case PIXELFORMAT_ASTC_5x5:
|
||||
case PIXELFORMAT_ASTC_6x5:
|
||||
case PIXELFORMAT_ASTC_6x6:
|
||||
case PIXELFORMAT_ASTC_8x5:
|
||||
case PIXELFORMAT_ASTC_8x6:
|
||||
case PIXELFORMAT_ASTC_8x8:
|
||||
case PIXELFORMAT_ASTC_10x5:
|
||||
case PIXELFORMAT_ASTC_10x6:
|
||||
case PIXELFORMAT_ASTC_10x8:
|
||||
case PIXELFORMAT_ASTC_10x10:
|
||||
case PIXELFORMAT_ASTC_12x10:
|
||||
case PIXELFORMAT_ASTC_12x12:
|
||||
case PIXELFORMAT_ASTC_4x4_UNORM:
|
||||
case PIXELFORMAT_ASTC_5x4_UNORM:
|
||||
case PIXELFORMAT_ASTC_5x5_UNORM:
|
||||
case PIXELFORMAT_ASTC_6x5_UNORM:
|
||||
case PIXELFORMAT_ASTC_6x6_UNORM:
|
||||
case PIXELFORMAT_ASTC_8x5_UNORM:
|
||||
case PIXELFORMAT_ASTC_8x6_UNORM:
|
||||
case PIXELFORMAT_ASTC_8x8_UNORM:
|
||||
case PIXELFORMAT_ASTC_10x5_UNORM:
|
||||
case PIXELFORMAT_ASTC_10x6_UNORM:
|
||||
case PIXELFORMAT_ASTC_10x8_UNORM:
|
||||
case PIXELFORMAT_ASTC_10x10_UNORM:
|
||||
case PIXELFORMAT_ASTC_12x10_UNORM:
|
||||
case PIXELFORMAT_ASTC_12x12_UNORM:
|
||||
case PIXELFORMAT_ASTC_4x4_sRGB:
|
||||
case PIXELFORMAT_ASTC_5x4_sRGB:
|
||||
case PIXELFORMAT_ASTC_5x5_sRGB:
|
||||
case PIXELFORMAT_ASTC_6x5_sRGB:
|
||||
case PIXELFORMAT_ASTC_6x6_sRGB:
|
||||
case PIXELFORMAT_ASTC_8x5_sRGB:
|
||||
case PIXELFORMAT_ASTC_8x6_sRGB:
|
||||
case PIXELFORMAT_ASTC_8x8_sRGB:
|
||||
case PIXELFORMAT_ASTC_10x5_sRGB:
|
||||
case PIXELFORMAT_ASTC_10x6_sRGB:
|
||||
case PIXELFORMAT_ASTC_10x8_sRGB:
|
||||
case PIXELFORMAT_ASTC_10x10_sRGB:
|
||||
case PIXELFORMAT_ASTC_12x10_sRGB:
|
||||
case PIXELFORMAT_ASTC_12x12_sRGB:
|
||||
if (families.apple[2])
|
||||
flags |= commonsample;
|
||||
break;
|
||||
|
||||
@@ -43,7 +43,7 @@ public:
|
||||
API_AVAILABLE(macos(10.15), ios(13.0)) MTLTextureSwizzleChannels swizzle;
|
||||
};
|
||||
|
||||
static PixelFormatDesc convertPixelFormat(id<MTLDevice> device, PixelFormat format, bool &isSRGB);
|
||||
static PixelFormatDesc convertPixelFormat(id<MTLDevice> device, PixelFormat format);
|
||||
|
||||
}; // Metal
|
||||
|
||||
|
||||
@@ -28,17 +28,11 @@ namespace graphics
|
||||
namespace metal
|
||||
{
|
||||
|
||||
Metal::PixelFormatDesc Metal::convertPixelFormat(id<MTLDevice> device, PixelFormat format, bool &isSRGB)
|
||||
Metal::PixelFormatDesc Metal::convertPixelFormat(id<MTLDevice> device, PixelFormat format)
|
||||
{
|
||||
MTLPixelFormat mtlformat = MTLPixelFormatInvalid;
|
||||
PixelFormatDesc desc = {};
|
||||
|
||||
if (isSRGB)
|
||||
format = getSRGBPixelFormat(format);
|
||||
|
||||
if (!isPixelFormatCompressed(format) && !isPixelFormatSRGB(format))
|
||||
isSRGB = false;
|
||||
|
||||
switch (format)
|
||||
{
|
||||
case PIXELFORMAT_R8_UNORM:
|
||||
@@ -50,13 +44,13 @@ Metal::PixelFormatDesc Metal::convertPixelFormat(id<MTLDevice> device, PixelForm
|
||||
case PIXELFORMAT_RGBA8_UNORM:
|
||||
mtlformat = MTLPixelFormatRGBA8Unorm;
|
||||
break;
|
||||
case PIXELFORMAT_RGBA8_UNORM_sRGB:
|
||||
case PIXELFORMAT_RGBA8_sRGB:
|
||||
mtlformat = MTLPixelFormatRGBA8Unorm_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_BGRA8_UNORM:
|
||||
mtlformat = MTLPixelFormatBGRA8Unorm;
|
||||
break;
|
||||
case PIXELFORMAT_BGRA8_UNORM_sRGB:
|
||||
case PIXELFORMAT_BGRA8_sRGB:
|
||||
mtlformat = MTLPixelFormatBGRA8Unorm_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_R16_UNORM:
|
||||
@@ -205,177 +199,264 @@ Metal::PixelFormatDesc Metal::convertPixelFormat(id<MTLDevice> device, PixelForm
|
||||
|
||||
case PIXELFORMAT_DXT1_UNORM:
|
||||
#ifndef LOVE_IOS
|
||||
mtlformat = isSRGB ? MTLPixelFormatBC1_RGBA_sRGB : MTLPixelFormatBC1_RGBA;
|
||||
mtlformat = MTLPixelFormatBC1_RGBA;
|
||||
#endif
|
||||
break;
|
||||
case PIXELFORMAT_DXT1_sRGB:
|
||||
#ifndef LOVE_IOS
|
||||
mtlformat = MTLPixelFormatBC1_RGBA_sRGB;
|
||||
#endif
|
||||
break;
|
||||
case PIXELFORMAT_DXT3_UNORM:
|
||||
#ifndef LOVE_IOS
|
||||
mtlformat = isSRGB ? MTLPixelFormatBC2_RGBA_sRGB : MTLPixelFormatBC2_RGBA;
|
||||
mtlformat = MTLPixelFormatBC2_RGBA;
|
||||
#endif
|
||||
break;
|
||||
case PIXELFORMAT_DXT3_sRGB:
|
||||
#ifndef LOVE_IOS
|
||||
mtlformat = MTLPixelFormatBC2_RGBA_sRGB;
|
||||
#endif
|
||||
break;
|
||||
case PIXELFORMAT_DXT5_UNORM:
|
||||
#ifndef LOVE_IOS
|
||||
mtlformat = isSRGB ? MTLPixelFormatBC3_RGBA_sRGB : MTLPixelFormatBC3_RGBA;
|
||||
mtlformat = MTLPixelFormatBC3_RGBA;
|
||||
#endif
|
||||
break;
|
||||
case PIXELFORMAT_DXT5_sRGB:
|
||||
#ifndef LOVE_IOS
|
||||
mtlformat = MTLPixelFormatBC3_RGBA_sRGB;
|
||||
#endif
|
||||
break;
|
||||
case PIXELFORMAT_BC4_UNORM:
|
||||
#ifndef LOVE_IOS
|
||||
isSRGB = false;
|
||||
mtlformat = MTLPixelFormatBC4_RUnorm;
|
||||
#endif
|
||||
break;
|
||||
case PIXELFORMAT_BC4_SNORM:
|
||||
#ifndef LOVE_IOS
|
||||
isSRGB = false;
|
||||
mtlformat = MTLPixelFormatBC4_RSnorm;
|
||||
#endif
|
||||
break;
|
||||
case PIXELFORMAT_BC5_UNORM:
|
||||
#ifndef LOVE_IOS
|
||||
isSRGB = false;
|
||||
mtlformat = MTLPixelFormatBC5_RGUnorm;
|
||||
#endif
|
||||
break;
|
||||
case PIXELFORMAT_BC5_SNORM:
|
||||
#ifndef LOVE_IOS
|
||||
isSRGB = false;
|
||||
mtlformat = MTLPixelFormatBC5_RGSnorm;
|
||||
#endif
|
||||
break;
|
||||
case PIXELFORMAT_BC6H_UFLOAT:
|
||||
#ifndef LOVE_IOS
|
||||
isSRGB = false;
|
||||
mtlformat = MTLPixelFormatBC6H_RGBUfloat;
|
||||
#endif
|
||||
break;
|
||||
case PIXELFORMAT_BC6H_FLOAT:
|
||||
#ifndef LOVE_IOS
|
||||
isSRGB = false;
|
||||
mtlformat = MTLPixelFormatBC6H_RGBFloat;
|
||||
#endif
|
||||
break;
|
||||
case PIXELFORMAT_BC7_UNORM:
|
||||
#ifndef LOVE_IOS
|
||||
mtlformat = isSRGB ? MTLPixelFormatBC7_RGBAUnorm_sRGB : MTLPixelFormatBC7_RGBAUnorm;
|
||||
mtlformat = MTLPixelFormatBC7_RGBAUnorm;
|
||||
#endif
|
||||
break;
|
||||
case PIXELFORMAT_BC7_sRGB:
|
||||
#ifndef LOVE_IOS
|
||||
mtlformat = MTLPixelFormatBC7_RGBAUnorm_sRGB;
|
||||
#endif
|
||||
break;
|
||||
|
||||
case PIXELFORMAT_PVR1_RGB2_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatPVRTC_RGB_2BPP_sRGB : MTLPixelFormatPVRTC_RGB_2BPP;
|
||||
mtlformat = MTLPixelFormatPVRTC_RGB_2BPP;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGB2_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatPVRTC_RGB_2BPP_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGB4_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatPVRTC_RGB_4BPP_sRGB : MTLPixelFormatPVRTC_RGB_4BPP;
|
||||
mtlformat = MTLPixelFormatPVRTC_RGB_4BPP;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGB4_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatPVRTC_RGB_4BPP_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGBA2_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatPVRTC_RGB_2BPP_sRGB : MTLPixelFormatPVRTC_RGBA_2BPP;
|
||||
mtlformat = MTLPixelFormatPVRTC_RGBA_2BPP;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGBA2_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatPVRTC_RGB_2BPP_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGBA4_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatPVRTC_RGB_4BPP_sRGB : MTLPixelFormatPVRTC_RGBA_4BPP;
|
||||
mtlformat = MTLPixelFormatPVRTC_RGBA_4BPP;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGBA4_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatPVRTC_RGB_4BPP_sRGB;
|
||||
break;
|
||||
|
||||
case PIXELFORMAT_ETC1_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatETC2_RGB8_sRGB : MTLPixelFormatETC2_RGB8;
|
||||
mtlformat = MTLPixelFormatETC2_RGB8;
|
||||
break;
|
||||
case PIXELFORMAT_ETC2_RGB_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatETC2_RGB8_sRGB : MTLPixelFormatETC2_RGB8;
|
||||
mtlformat = MTLPixelFormatETC2_RGB8;
|
||||
break;
|
||||
case PIXELFORMAT_ETC2_RGB_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatETC2_RGB8_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_ETC2_RGBA_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatEAC_RGBA8_sRGB : MTLPixelFormatEAC_RGBA8;
|
||||
mtlformat = MTLPixelFormatEAC_RGBA8;
|
||||
break;
|
||||
case PIXELFORMAT_ETC2_RGBA_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatEAC_RGBA8_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_ETC2_RGBA1_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatETC2_RGB8A1_sRGB : MTLPixelFormatETC2_RGB8A1;
|
||||
mtlformat = MTLPixelFormatETC2_RGB8A1;
|
||||
break;
|
||||
case PIXELFORMAT_ETC2_RGBA1_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatETC2_RGB8A1_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_EAC_R_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
{
|
||||
isSRGB = false;
|
||||
mtlformat = MTLPixelFormatEAC_R11Unorm;
|
||||
}
|
||||
break;
|
||||
case PIXELFORMAT_EAC_R_SNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
{
|
||||
isSRGB = false;
|
||||
mtlformat = MTLPixelFormatEAC_R11Snorm;
|
||||
}
|
||||
break;
|
||||
case PIXELFORMAT_EAC_RG_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
{
|
||||
isSRGB = false;
|
||||
mtlformat = MTLPixelFormatEAC_RG11Unorm;
|
||||
}
|
||||
break;
|
||||
case PIXELFORMAT_EAC_RG_SNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
{
|
||||
isSRGB = false;
|
||||
mtlformat = MTLPixelFormatEAC_RG11Snorm;
|
||||
}
|
||||
break;
|
||||
|
||||
case PIXELFORMAT_ASTC_4x4:
|
||||
case PIXELFORMAT_ASTC_4x4_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatASTC_4x4_sRGB : MTLPixelFormatASTC_4x4_LDR;
|
||||
mtlformat = MTLPixelFormatASTC_4x4_LDR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_5x4:
|
||||
case PIXELFORMAT_ASTC_5x4_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatASTC_5x4_sRGB : MTLPixelFormatASTC_5x4_LDR;
|
||||
mtlformat = MTLPixelFormatASTC_5x4_LDR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_5x5:
|
||||
case PIXELFORMAT_ASTC_5x5_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatASTC_5x5_sRGB : MTLPixelFormatASTC_5x5_LDR;
|
||||
mtlformat = MTLPixelFormatASTC_5x5_LDR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_6x5:
|
||||
case PIXELFORMAT_ASTC_6x5_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatASTC_6x5_sRGB : MTLPixelFormatASTC_6x5_LDR;
|
||||
mtlformat = MTLPixelFormatASTC_6x5_LDR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_6x6:
|
||||
case PIXELFORMAT_ASTC_6x6_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatASTC_6x6_sRGB : MTLPixelFormatASTC_6x6_LDR;
|
||||
mtlformat = MTLPixelFormatASTC_6x6_LDR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_8x5:
|
||||
case PIXELFORMAT_ASTC_8x5_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatASTC_8x5_sRGB : MTLPixelFormatASTC_8x5_LDR;
|
||||
mtlformat = MTLPixelFormatASTC_8x5_LDR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_8x6:
|
||||
case PIXELFORMAT_ASTC_8x6_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatASTC_8x6_sRGB : MTLPixelFormatASTC_8x6_LDR;
|
||||
mtlformat = MTLPixelFormatASTC_8x6_LDR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_8x8:
|
||||
case PIXELFORMAT_ASTC_8x8_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatASTC_8x8_sRGB : MTLPixelFormatASTC_8x8_LDR;
|
||||
mtlformat = MTLPixelFormatASTC_8x8_LDR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x5:
|
||||
case PIXELFORMAT_ASTC_10x5_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatASTC_10x5_sRGB : MTLPixelFormatASTC_10x5_LDR;
|
||||
mtlformat = MTLPixelFormatASTC_10x5_LDR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x6:
|
||||
case PIXELFORMAT_ASTC_10x6_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatASTC_10x6_sRGB : MTLPixelFormatASTC_10x6_LDR;
|
||||
mtlformat = MTLPixelFormatASTC_10x6_LDR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x8:
|
||||
case PIXELFORMAT_ASTC_10x8_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatASTC_10x8_sRGB : MTLPixelFormatASTC_10x8_LDR;
|
||||
mtlformat = MTLPixelFormatASTC_10x8_LDR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x10:
|
||||
case PIXELFORMAT_ASTC_10x10_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatASTC_10x10_sRGB : MTLPixelFormatASTC_10x10_LDR;
|
||||
mtlformat = MTLPixelFormatASTC_10x10_LDR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_12x10:
|
||||
case PIXELFORMAT_ASTC_12x10_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatASTC_12x10_sRGB : MTLPixelFormatASTC_12x10_LDR;
|
||||
mtlformat = MTLPixelFormatASTC_12x10_LDR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_12x12:
|
||||
case PIXELFORMAT_ASTC_12x12_UNORM:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = isSRGB ? MTLPixelFormatASTC_12x12_sRGB : MTLPixelFormatASTC_12x12_LDR;
|
||||
mtlformat = MTLPixelFormatASTC_12x12_LDR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_4x4_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatASTC_4x4_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_5x4_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatASTC_5x4_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_5x5_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatASTC_5x5_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_6x5_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatASTC_6x5_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_6x6_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatASTC_6x6_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_8x5_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatASTC_8x5_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_8x6_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatASTC_8x6_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_8x8_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatASTC_8x8_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x5_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatASTC_10x5_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x6_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatASTC_10x6_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x8_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatASTC_10x8_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x10_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatASTC_10x10_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_12x10_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatASTC_12x10_sRGB;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_12x12_sRGB:
|
||||
if (@available(macOS 11.0, iOS 8.0, *))
|
||||
mtlformat = MTLPixelFormatASTC_12x12_sRGB;
|
||||
break;
|
||||
|
||||
case PIXELFORMAT_UNKNOWN:
|
||||
|
||||
@@ -62,7 +62,7 @@ Texture::Texture(love::graphics::Graphics *gfxbase, id<MTLDevice> device, const
|
||||
desc.mipmapLevelCount = mipmapCount;
|
||||
desc.textureType = getMTLTextureType(texType, 1);
|
||||
|
||||
auto formatdesc = Metal::convertPixelFormat(device, format, sRGB);
|
||||
auto formatdesc = Metal::convertPixelFormat(device, format);
|
||||
desc.pixelFormat = formatdesc.format;
|
||||
if (formatdesc.swizzled)
|
||||
{
|
||||
|
||||
@@ -250,7 +250,7 @@ void Graphics::updateBackbuffer(int width, int height, int /*pixelwidth*/, int p
|
||||
settings.renderTarget = true;
|
||||
settings.readable.set(false);
|
||||
|
||||
settings.format = isGammaCorrect() ? PIXELFORMAT_RGBA8_UNORM_sRGB : PIXELFORMAT_RGBA8_UNORM;
|
||||
settings.format = isGammaCorrect() ? PIXELFORMAT_RGBA8_sRGB : PIXELFORMAT_RGBA8_UNORM;
|
||||
internalBackbuffer.set(newTexture(settings), Acquire::NORETAIN);
|
||||
|
||||
settings.format = PIXELFORMAT_DEPTH24_UNORM_STENCIL8;
|
||||
@@ -1189,8 +1189,7 @@ GLuint Graphics::bindCachedFBO(const RenderTargets &targets)
|
||||
auto attachRT = [&](const RenderTarget &rt)
|
||||
{
|
||||
bool renderbuffer = msaa > 1 || !rt.texture->isReadable();
|
||||
bool srgb = false;
|
||||
OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(rt.texture->getPixelFormat(), renderbuffer, srgb);
|
||||
OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(rt.texture->getPixelFormat(), renderbuffer);
|
||||
|
||||
if (fmt.framebufferAttachments[0] == GL_COLOR_ATTACHMENT0)
|
||||
{
|
||||
@@ -1754,9 +1753,8 @@ uint32 Graphics::computePixelFormatUsage(PixelFormat format, bool readable)
|
||||
{
|
||||
GLuint texture = 0;
|
||||
GLuint renderbuffer = 0;
|
||||
bool sRGB = isPixelFormatSRGB(format);
|
||||
|
||||
OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(format, !readable, sRGB);
|
||||
OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(format, !readable);
|
||||
|
||||
GLuint current_fbo = gl.getFramebuffer(OpenGL::FRAMEBUFFER_ALL);
|
||||
|
||||
@@ -1778,7 +1776,7 @@ uint32 Graphics::computePixelFormatUsage(PixelFormat format, bool readable)
|
||||
s.minFilter = s.magFilter = SamplerState::FILTER_NEAREST;
|
||||
gl.setSamplerState(TEXTURE_2D, s);
|
||||
|
||||
gl.rawTexStorage(TEXTURE_2D, 1, format, sRGB, 1, 1);
|
||||
gl.rawTexStorage(TEXTURE_2D, 1, format, 1, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
@@ -1814,11 +1812,8 @@ uint32 Graphics::computePixelFormatUsage(PixelFormat format, bool readable)
|
||||
return usage;
|
||||
}
|
||||
|
||||
bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRGB)
|
||||
bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage)
|
||||
{
|
||||
if (sRGB)
|
||||
format = getSRGBPixelFormat(format);
|
||||
|
||||
format = getSizedFormat(format);
|
||||
|
||||
bool readable = (usage & PIXELFORMATUSAGEFLAGS_SAMPLE) != 0;
|
||||
|
||||
@@ -106,7 +106,7 @@ public:
|
||||
|
||||
void setWireframe(bool enable) override;
|
||||
|
||||
bool isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRGB = false) override;
|
||||
bool isPixelFormatSupported(PixelFormat format, uint32 usage) override;
|
||||
Renderer getRenderer() const override;
|
||||
bool usesGLSLES() const override;
|
||||
RendererInfo getRendererInfo() const override;
|
||||
|
||||
@@ -646,11 +646,9 @@ void OpenGL::createDefaultTexture()
|
||||
|
||||
const GLubyte *p = datatype == DATA_BASETYPE_FLOAT ? pix : intpix;
|
||||
|
||||
bool isSRGB = false;
|
||||
rawTexStorage(type, 1, format, isSRGB, 1, 1);
|
||||
|
||||
TextureFormat fmt = convertPixelFormat(format, false, isSRGB);
|
||||
rawTexStorage(type, 1, format, 1, 1);
|
||||
|
||||
TextureFormat fmt = convertPixelFormat(format, false);
|
||||
int slices = type == TEXTURE_CUBE ? 6 : 1;
|
||||
|
||||
for (int slice = 0; slice < slices; slice++)
|
||||
@@ -1433,10 +1431,10 @@ void OpenGL::setSamplerState(TextureType target, SamplerState &s)
|
||||
}
|
||||
}
|
||||
|
||||
bool OpenGL::rawTexStorage(TextureType target, int levels, PixelFormat pixelformat, bool &isSRGB, int width, int height, int depth)
|
||||
bool OpenGL::rawTexStorage(TextureType target, int levels, PixelFormat pixelformat, int width, int height, int depth)
|
||||
{
|
||||
GLenum gltarget = getGLTextureType(target);
|
||||
TextureFormat fmt = convertPixelFormat(pixelformat, false, isSRGB);
|
||||
TextureFormat fmt = convertPixelFormat(pixelformat, false);
|
||||
|
||||
// This shouldn't be needed for glTexStorage, but some drivers don't follow
|
||||
// the spec apparently.
|
||||
@@ -1700,16 +1698,14 @@ OpenGL::Vendor OpenGL::getVendor() const
|
||||
return vendor;
|
||||
}
|
||||
|
||||
OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool renderbuffer, bool &isSRGB)
|
||||
OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool renderbuffer)
|
||||
{
|
||||
TextureFormat f;
|
||||
|
||||
f.framebufferAttachments[0] = GL_COLOR_ATTACHMENT0;
|
||||
f.framebufferAttachments[1] = GL_NONE;
|
||||
|
||||
if (isSRGB)
|
||||
pixelformat = getSRGBPixelFormat(pixelformat);
|
||||
else if (pixelformat == PIXELFORMAT_ETC1_UNORM)
|
||||
if (pixelformat == PIXELFORMAT_ETC1_UNORM)
|
||||
{
|
||||
// The ETC2 format can load ETC1 textures.
|
||||
if (GLAD_ES_VERSION_3_0 || GLAD_VERSION_4_3 || GLAD_ARB_ES3_compatibility)
|
||||
@@ -1742,7 +1738,7 @@ OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool r
|
||||
f.externalformat = GL_RGBA;
|
||||
f.type = GL_UNSIGNED_BYTE;
|
||||
break;
|
||||
case PIXELFORMAT_RGBA8_UNORM_sRGB:
|
||||
case PIXELFORMAT_RGBA8_sRGB:
|
||||
f.internalformat = GL_SRGB8_ALPHA8;
|
||||
f.type = GL_UNSIGNED_BYTE;
|
||||
if (GLAD_ES_VERSION_2_0 && !GLAD_ES_VERSION_3_0)
|
||||
@@ -1751,7 +1747,7 @@ OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool r
|
||||
f.externalformat = GL_RGBA;
|
||||
break;
|
||||
case PIXELFORMAT_BGRA8_UNORM:
|
||||
case PIXELFORMAT_BGRA8_UNORM_sRGB:
|
||||
case PIXELFORMAT_BGRA8_sRGB:
|
||||
// Not supported right now.
|
||||
break;
|
||||
case PIXELFORMAT_R16_UNORM:
|
||||
@@ -2026,123 +2022,190 @@ OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool r
|
||||
break;
|
||||
|
||||
case PIXELFORMAT_DXT1_UNORM:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT : GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
|
||||
f.internalformat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
|
||||
break;
|
||||
case PIXELFORMAT_DXT1_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;
|
||||
break;
|
||||
case PIXELFORMAT_DXT3_UNORM:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT : GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
|
||||
f.internalformat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
|
||||
break;
|
||||
case PIXELFORMAT_DXT3_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT;
|
||||
break;
|
||||
case PIXELFORMAT_DXT5_UNORM:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT : GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
|
||||
f.internalformat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
|
||||
break;
|
||||
case PIXELFORMAT_DXT5_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;
|
||||
break;
|
||||
case PIXELFORMAT_BC4_UNORM:
|
||||
isSRGB = false;
|
||||
f.internalformat = GL_COMPRESSED_RED_RGTC1;
|
||||
break;
|
||||
case PIXELFORMAT_BC4_SNORM:
|
||||
isSRGB = false;
|
||||
f.internalformat = GL_COMPRESSED_SIGNED_RED_RGTC1;
|
||||
break;
|
||||
case PIXELFORMAT_BC5_UNORM:
|
||||
isSRGB = false;
|
||||
f.internalformat = GL_COMPRESSED_RG_RGTC2;
|
||||
break;
|
||||
case PIXELFORMAT_BC5_SNORM:
|
||||
isSRGB = false;
|
||||
f.internalformat = GL_COMPRESSED_SIGNED_RG_RGTC2;
|
||||
break;
|
||||
case PIXELFORMAT_BC6H_UFLOAT:
|
||||
isSRGB = false;
|
||||
f.internalformat = GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT;
|
||||
break;
|
||||
case PIXELFORMAT_BC6H_FLOAT:
|
||||
isSRGB = false;
|
||||
f.internalformat = GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT;
|
||||
break;
|
||||
case PIXELFORMAT_BC7_UNORM:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM : GL_COMPRESSED_RGBA_BPTC_UNORM;
|
||||
f.internalformat = GL_COMPRESSED_RGBA_BPTC_UNORM;
|
||||
break;
|
||||
case PIXELFORMAT_BC7_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM;
|
||||
break;
|
||||
|
||||
case PIXELFORMAT_PVR1_RGB2_UNORM:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT : GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
|
||||
f.internalformat = GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGB2_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGB4_UNORM:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT : GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
|
||||
f.internalformat = GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGB4_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGBA2_UNORM:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT : GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
|
||||
f.internalformat = GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGBA2_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGBA4_UNORM:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT : GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
|
||||
f.internalformat = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGBA4_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT;
|
||||
break;
|
||||
|
||||
case PIXELFORMAT_ETC1_UNORM:
|
||||
isSRGB = false;
|
||||
f.internalformat = GL_ETC1_RGB8_OES;
|
||||
break;
|
||||
case PIXELFORMAT_ETC2_RGB_UNORM:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ETC2 : GL_COMPRESSED_RGB8_ETC2;
|
||||
f.internalformat = GL_COMPRESSED_RGB8_ETC2;
|
||||
break;
|
||||
case PIXELFORMAT_ETC2_RGB_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB8_ETC2;
|
||||
break;
|
||||
case PIXELFORMAT_ETC2_RGBA_UNORM:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC : GL_COMPRESSED_RGBA8_ETC2_EAC;
|
||||
f.internalformat = GL_COMPRESSED_RGBA8_ETC2_EAC;
|
||||
break;
|
||||
case PIXELFORMAT_ETC2_RGBA_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC;
|
||||
break;
|
||||
case PIXELFORMAT_ETC2_RGBA1_UNORM:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 : GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2;
|
||||
f.internalformat = GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2;
|
||||
break;
|
||||
case PIXELFORMAT_ETC2_RGBA1_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2;
|
||||
break;
|
||||
case PIXELFORMAT_EAC_R_UNORM:
|
||||
isSRGB = false;
|
||||
f.internalformat = GL_COMPRESSED_R11_EAC;
|
||||
break;
|
||||
case PIXELFORMAT_EAC_R_SNORM:
|
||||
isSRGB = false;
|
||||
f.internalformat = GL_COMPRESSED_SIGNED_R11_EAC;
|
||||
break;
|
||||
case PIXELFORMAT_EAC_RG_UNORM:
|
||||
isSRGB = false;
|
||||
f.internalformat = GL_COMPRESSED_RG11_EAC;
|
||||
break;
|
||||
case PIXELFORMAT_EAC_RG_SNORM:
|
||||
isSRGB = false;
|
||||
f.internalformat = GL_COMPRESSED_SIGNED_RG11_EAC;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_4x4:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR : GL_COMPRESSED_RGBA_ASTC_4x4_KHR;
|
||||
|
||||
case PIXELFORMAT_ASTC_4x4_UNORM:
|
||||
f.internalformat = GL_COMPRESSED_RGBA_ASTC_4x4_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_5x4:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR : GL_COMPRESSED_RGBA_ASTC_5x4_KHR;
|
||||
case PIXELFORMAT_ASTC_4x4_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_5x5:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR : GL_COMPRESSED_RGBA_ASTC_5x5_KHR;
|
||||
case PIXELFORMAT_ASTC_5x4_UNORM:
|
||||
f.internalformat = GL_COMPRESSED_RGBA_ASTC_5x4_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_6x5:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR : GL_COMPRESSED_RGBA_ASTC_6x5_KHR;
|
||||
case PIXELFORMAT_ASTC_5x4_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_6x6:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR : GL_COMPRESSED_RGBA_ASTC_6x6_KHR;
|
||||
case PIXELFORMAT_ASTC_5x5_UNORM:
|
||||
f.internalformat = GL_COMPRESSED_RGBA_ASTC_5x5_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_8x5:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR : GL_COMPRESSED_RGBA_ASTC_8x5_KHR;
|
||||
case PIXELFORMAT_ASTC_5x5_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_8x6:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR : GL_COMPRESSED_RGBA_ASTC_8x6_KHR;
|
||||
case PIXELFORMAT_ASTC_6x5_UNORM:
|
||||
f.internalformat = GL_COMPRESSED_RGBA_ASTC_6x5_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_8x8:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR : GL_COMPRESSED_RGBA_ASTC_8x8_KHR;
|
||||
case PIXELFORMAT_ASTC_6x5_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x5:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR : GL_COMPRESSED_RGBA_ASTC_10x5_KHR;
|
||||
case PIXELFORMAT_ASTC_6x6_UNORM:
|
||||
f.internalformat = GL_COMPRESSED_RGBA_ASTC_6x6_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x6:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR : GL_COMPRESSED_RGBA_ASTC_10x6_KHR;
|
||||
case PIXELFORMAT_ASTC_6x6_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x8:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR : GL_COMPRESSED_RGBA_ASTC_10x8_KHR;
|
||||
case PIXELFORMAT_ASTC_8x5_UNORM:
|
||||
f.internalformat = GL_COMPRESSED_RGBA_ASTC_8x5_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x10:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR : GL_COMPRESSED_RGBA_ASTC_10x10_KHR;
|
||||
case PIXELFORMAT_ASTC_8x5_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_12x10:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR : GL_COMPRESSED_RGBA_ASTC_12x10_KHR;
|
||||
case PIXELFORMAT_ASTC_8x6_UNORM:
|
||||
f.internalformat = GL_COMPRESSED_RGBA_ASTC_8x6_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_12x12:
|
||||
f.internalformat = isSRGB ? GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR : GL_COMPRESSED_RGBA_ASTC_12x12_KHR;
|
||||
case PIXELFORMAT_ASTC_8x6_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_8x8_UNORM:
|
||||
f.internalformat = GL_COMPRESSED_RGBA_ASTC_8x8_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_8x8_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x5_UNORM:
|
||||
f.internalformat = GL_COMPRESSED_RGBA_ASTC_10x5_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x5_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x6_UNORM:
|
||||
f.internalformat = GL_COMPRESSED_RGBA_ASTC_10x6_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x6_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x8_UNORM:
|
||||
f.internalformat = GL_COMPRESSED_RGBA_ASTC_10x8_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x8_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x10_UNORM:
|
||||
f.internalformat = GL_COMPRESSED_RGBA_ASTC_10x10_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x10_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_12x10_UNORM:
|
||||
f.internalformat = GL_COMPRESSED_RGBA_ASTC_12x10_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_12x10_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_12x12_UNORM:
|
||||
f.internalformat = GL_COMPRESSED_RGBA_ASTC_12x12_KHR;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_12x12_sRGB:
|
||||
f.internalformat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR;
|
||||
break;
|
||||
|
||||
default:
|
||||
@@ -2164,9 +2227,6 @@ OpenGL::TextureFormat OpenGL::convertPixelFormat(PixelFormat pixelformat, bool r
|
||||
{
|
||||
f.internalformat = f.externalformat;
|
||||
}
|
||||
|
||||
if (!isPixelFormatSRGB(pixelformat))
|
||||
isSRGB = false;
|
||||
}
|
||||
|
||||
return f;
|
||||
@@ -2198,7 +2258,7 @@ uint32 OpenGL::getPixelFormatUsageFlags(PixelFormat pixelformat)
|
||||
if (GLAD_VERSION_4_3 || GLAD_ES_VERSION_3_1)
|
||||
flags |= computewrite;
|
||||
break;
|
||||
case PIXELFORMAT_RGBA8_UNORM_sRGB:
|
||||
case PIXELFORMAT_RGBA8_sRGB:
|
||||
if (gl.bugs.brokenSRGB)
|
||||
break;
|
||||
if (GLAD_ES_VERSION_3_0 || GLAD_VERSION_2_1 || GLAD_EXT_texture_sRGB)
|
||||
@@ -2210,7 +2270,7 @@ uint32 OpenGL::getPixelFormatUsageFlags(PixelFormat pixelformat)
|
||||
flags |= computewrite;
|
||||
break;
|
||||
case PIXELFORMAT_BGRA8_UNORM:
|
||||
case PIXELFORMAT_BGRA8_UNORM_sRGB:
|
||||
case PIXELFORMAT_BGRA8_sRGB:
|
||||
// Not supported right now.
|
||||
break;
|
||||
case PIXELFORMAT_R16_UNORM:
|
||||
@@ -2278,47 +2338,47 @@ uint32 OpenGL::getPixelFormatUsageFlags(PixelFormat pixelformat)
|
||||
flags |= computewrite;
|
||||
break;
|
||||
|
||||
case PIXELFORMAT_R8_INT:
|
||||
case PIXELFORMAT_R8_UINT:
|
||||
case PIXELFORMAT_RG8_INT:
|
||||
case PIXELFORMAT_RG8_UINT:
|
||||
case PIXELFORMAT_RGBA8_INT:
|
||||
case PIXELFORMAT_RGBA8_UINT:
|
||||
case PIXELFORMAT_R16_INT:
|
||||
case PIXELFORMAT_R16_UINT:
|
||||
case PIXELFORMAT_RG16_INT:
|
||||
case PIXELFORMAT_RG16_UINT:
|
||||
case PIXELFORMAT_RGBA16_INT:
|
||||
case PIXELFORMAT_RGBA16_UINT:
|
||||
case PIXELFORMAT_R32_INT:
|
||||
case PIXELFORMAT_R32_UINT:
|
||||
case PIXELFORMAT_RG32_INT:
|
||||
case PIXELFORMAT_RG32_UINT:
|
||||
case PIXELFORMAT_RGBA32_INT:
|
||||
case PIXELFORMAT_RGBA32_UINT:
|
||||
if (GLAD_VERSION_3_0 || GLAD_ES_VERSION_3_0)
|
||||
flags |= PIXELFORMATUSAGEFLAGS_SAMPLE | PIXELFORMATUSAGEFLAGS_RENDERTARGET;
|
||||
if (GLAD_VERSION_4_3)
|
||||
flags |= computewrite;
|
||||
if (GLAD_ES_VERSION_3_1)
|
||||
case PIXELFORMAT_R8_INT:
|
||||
case PIXELFORMAT_R8_UINT:
|
||||
case PIXELFORMAT_RG8_INT:
|
||||
case PIXELFORMAT_RG8_UINT:
|
||||
case PIXELFORMAT_RGBA8_INT:
|
||||
case PIXELFORMAT_RGBA8_UINT:
|
||||
case PIXELFORMAT_R16_INT:
|
||||
case PIXELFORMAT_R16_UINT:
|
||||
case PIXELFORMAT_RG16_INT:
|
||||
case PIXELFORMAT_RG16_UINT:
|
||||
case PIXELFORMAT_RGBA16_INT:
|
||||
case PIXELFORMAT_RGBA16_UINT:
|
||||
case PIXELFORMAT_R32_INT:
|
||||
case PIXELFORMAT_R32_UINT:
|
||||
case PIXELFORMAT_RG32_INT:
|
||||
case PIXELFORMAT_RG32_UINT:
|
||||
case PIXELFORMAT_RGBA32_INT:
|
||||
case PIXELFORMAT_RGBA32_UINT:
|
||||
if (GLAD_VERSION_3_0 || GLAD_ES_VERSION_3_0)
|
||||
flags |= PIXELFORMATUSAGEFLAGS_SAMPLE | PIXELFORMATUSAGEFLAGS_RENDERTARGET;
|
||||
if (GLAD_VERSION_4_3)
|
||||
flags |= computewrite;
|
||||
if (GLAD_ES_VERSION_3_1)
|
||||
{
|
||||
switch (pixelformat)
|
||||
{
|
||||
switch (pixelformat)
|
||||
{
|
||||
case PIXELFORMAT_RGBA8_INT:
|
||||
case PIXELFORMAT_RGBA8_UINT:
|
||||
case PIXELFORMAT_RGBA16_INT:
|
||||
case PIXELFORMAT_RGBA16_UINT:
|
||||
case PIXELFORMAT_R32_INT:
|
||||
case PIXELFORMAT_R32_UINT:
|
||||
case PIXELFORMAT_RGBA32_INT:
|
||||
case PIXELFORMAT_RGBA32_UINT:
|
||||
flags |= computewrite;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
case PIXELFORMAT_RGBA8_INT:
|
||||
case PIXELFORMAT_RGBA8_UINT:
|
||||
case PIXELFORMAT_RGBA16_INT:
|
||||
case PIXELFORMAT_RGBA16_UINT:
|
||||
case PIXELFORMAT_R32_INT:
|
||||
case PIXELFORMAT_R32_UINT:
|
||||
case PIXELFORMAT_RGBA32_INT:
|
||||
case PIXELFORMAT_RGBA32_UINT:
|
||||
flags |= computewrite;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
case PIXELFORMAT_LA8_UNORM:
|
||||
flags |= commonsample;
|
||||
@@ -2380,14 +2440,17 @@ uint32 OpenGL::getPixelFormatUsageFlags(PixelFormat pixelformat)
|
||||
break;
|
||||
|
||||
case PIXELFORMAT_DXT1_UNORM:
|
||||
case PIXELFORMAT_DXT1_sRGB:
|
||||
if (GLAD_EXT_texture_compression_s3tc || GLAD_EXT_texture_compression_dxt1)
|
||||
flags |= commonsample;
|
||||
break;
|
||||
case PIXELFORMAT_DXT3_UNORM:
|
||||
case PIXELFORMAT_DXT3_sRGB:
|
||||
if (GLAD_EXT_texture_compression_s3tc || GLAD_ANGLE_texture_compression_dxt3)
|
||||
flags |= commonsample;
|
||||
break;
|
||||
case PIXELFORMAT_DXT5_UNORM:
|
||||
case PIXELFORMAT_DXT5_sRGB:
|
||||
if (GLAD_EXT_texture_compression_s3tc || GLAD_ANGLE_texture_compression_dxt5)
|
||||
flags |= commonsample;
|
||||
break;
|
||||
@@ -2401,6 +2464,7 @@ uint32 OpenGL::getPixelFormatUsageFlags(PixelFormat pixelformat)
|
||||
case PIXELFORMAT_BC6H_UFLOAT:
|
||||
case PIXELFORMAT_BC6H_FLOAT:
|
||||
case PIXELFORMAT_BC7_UNORM:
|
||||
case PIXELFORMAT_BC7_sRGB:
|
||||
if (GLAD_VERSION_4_2 || GLAD_ARB_texture_compression_bptc)
|
||||
flags |= commonsample;
|
||||
break;
|
||||
@@ -2411,14 +2475,24 @@ uint32 OpenGL::getPixelFormatUsageFlags(PixelFormat pixelformat)
|
||||
if (GLAD_IMG_texture_compression_pvrtc)
|
||||
flags |= commonsample;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGB2_sRGB:
|
||||
case PIXELFORMAT_PVR1_RGB4_sRGB:
|
||||
case PIXELFORMAT_PVR1_RGBA2_sRGB:
|
||||
case PIXELFORMAT_PVR1_RGBA4_sRGB:
|
||||
if (GLAD_EXT_pvrtc_sRGB)
|
||||
flags |= commonsample;
|
||||
break;
|
||||
case PIXELFORMAT_ETC1_UNORM:
|
||||
// ETC2 support guarantees ETC1 support as well.
|
||||
if (GLAD_ES_VERSION_3_0 || GLAD_VERSION_4_3 || GLAD_ARB_ES3_compatibility || GLAD_OES_compressed_ETC1_RGB8_texture)
|
||||
flags |= commonsample;
|
||||
break;
|
||||
case PIXELFORMAT_ETC2_RGB_UNORM:
|
||||
case PIXELFORMAT_ETC2_RGB_sRGB:
|
||||
case PIXELFORMAT_ETC2_RGBA_UNORM:
|
||||
case PIXELFORMAT_ETC2_RGBA_sRGB:
|
||||
case PIXELFORMAT_ETC2_RGBA1_UNORM:
|
||||
case PIXELFORMAT_ETC2_RGBA1_sRGB:
|
||||
case PIXELFORMAT_EAC_R_UNORM:
|
||||
case PIXELFORMAT_EAC_R_SNORM:
|
||||
case PIXELFORMAT_EAC_RG_UNORM:
|
||||
@@ -2426,20 +2500,34 @@ uint32 OpenGL::getPixelFormatUsageFlags(PixelFormat pixelformat)
|
||||
if (GLAD_ES_VERSION_3_0 || GLAD_VERSION_4_3 || GLAD_ARB_ES3_compatibility)
|
||||
flags |= commonsample;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_4x4:
|
||||
case PIXELFORMAT_ASTC_5x4:
|
||||
case PIXELFORMAT_ASTC_5x5:
|
||||
case PIXELFORMAT_ASTC_6x5:
|
||||
case PIXELFORMAT_ASTC_6x6:
|
||||
case PIXELFORMAT_ASTC_8x5:
|
||||
case PIXELFORMAT_ASTC_8x6:
|
||||
case PIXELFORMAT_ASTC_8x8:
|
||||
case PIXELFORMAT_ASTC_10x5:
|
||||
case PIXELFORMAT_ASTC_10x6:
|
||||
case PIXELFORMAT_ASTC_10x8:
|
||||
case PIXELFORMAT_ASTC_10x10:
|
||||
case PIXELFORMAT_ASTC_12x10:
|
||||
case PIXELFORMAT_ASTC_12x12:
|
||||
case PIXELFORMAT_ASTC_4x4_UNORM:
|
||||
case PIXELFORMAT_ASTC_5x4_UNORM:
|
||||
case PIXELFORMAT_ASTC_5x5_UNORM:
|
||||
case PIXELFORMAT_ASTC_6x5_UNORM:
|
||||
case PIXELFORMAT_ASTC_6x6_UNORM:
|
||||
case PIXELFORMAT_ASTC_8x5_UNORM:
|
||||
case PIXELFORMAT_ASTC_8x6_UNORM:
|
||||
case PIXELFORMAT_ASTC_8x8_UNORM:
|
||||
case PIXELFORMAT_ASTC_10x5_UNORM:
|
||||
case PIXELFORMAT_ASTC_10x6_UNORM:
|
||||
case PIXELFORMAT_ASTC_10x8_UNORM:
|
||||
case PIXELFORMAT_ASTC_10x10_UNORM:
|
||||
case PIXELFORMAT_ASTC_12x10_UNORM:
|
||||
case PIXELFORMAT_ASTC_12x12_UNORM:
|
||||
case PIXELFORMAT_ASTC_4x4_sRGB:
|
||||
case PIXELFORMAT_ASTC_5x4_sRGB:
|
||||
case PIXELFORMAT_ASTC_5x5_sRGB:
|
||||
case PIXELFORMAT_ASTC_6x5_sRGB:
|
||||
case PIXELFORMAT_ASTC_6x6_sRGB:
|
||||
case PIXELFORMAT_ASTC_8x5_sRGB:
|
||||
case PIXELFORMAT_ASTC_8x6_sRGB:
|
||||
case PIXELFORMAT_ASTC_8x8_sRGB:
|
||||
case PIXELFORMAT_ASTC_10x5_sRGB:
|
||||
case PIXELFORMAT_ASTC_10x6_sRGB:
|
||||
case PIXELFORMAT_ASTC_10x8_sRGB:
|
||||
case PIXELFORMAT_ASTC_10x10_sRGB:
|
||||
case PIXELFORMAT_ASTC_12x10_sRGB:
|
||||
case PIXELFORMAT_ASTC_12x12_sRGB:
|
||||
if (GLAD_ES_VERSION_3_2 || GLAD_KHR_texture_compression_astc_ldr)
|
||||
flags |= commonsample;
|
||||
break;
|
||||
|
||||
@@ -381,7 +381,7 @@ public:
|
||||
* to glTexImage2D/3D for all levels and slices of a texture otherwise.
|
||||
* NOTE: this does not handle compressed texture formats.
|
||||
**/
|
||||
bool rawTexStorage(TextureType target, int levels, PixelFormat pixelformat, bool &isSRGB, int width, int height, int depth = 1);
|
||||
bool rawTexStorage(TextureType target, int levels, PixelFormat pixelformat, int width, int height, int depth = 1);
|
||||
|
||||
bool isTextureTypeSupported(TextureType type) const;
|
||||
bool isBufferUsageSupported(BufferUsage usage) const;
|
||||
@@ -475,7 +475,7 @@ public:
|
||||
static GLint getGLWrapMode(SamplerState::WrapMode wmode);
|
||||
static GLint getGLCompareMode(CompareMode mode);
|
||||
|
||||
static TextureFormat convertPixelFormat(PixelFormat pixelformat, bool renderbuffer, bool &isSRGB);
|
||||
static TextureFormat convertPixelFormat(PixelFormat pixelformat, bool renderbuffer);
|
||||
static bool isTexStorageSupported();
|
||||
static uint32 getPixelFormatUsageFlags(PixelFormat pixelformat);
|
||||
|
||||
|
||||
@@ -175,8 +175,7 @@ void Shader::mapActiveUniforms()
|
||||
else if ((u.access & ACCESS_READ) != 0)
|
||||
binding.access = GL_READ_ONLY;
|
||||
|
||||
bool sRGB = false;
|
||||
auto fmt = OpenGL::convertPixelFormat(u.storageTextureFormat, false, sRGB);
|
||||
auto fmt = OpenGL::convertPixelFormat(u.storageTextureFormat, false);
|
||||
binding.internalFormat = fmt.internalformat;
|
||||
|
||||
for (int i = 0; i < u.count; i++)
|
||||
|
||||
@@ -56,8 +56,7 @@ static GLenum createFBO(GLuint &framebuffer, TextureType texType, PixelFormat fo
|
||||
glReadBuffer(GL_NONE);
|
||||
}
|
||||
|
||||
bool unusedSRGB = false;
|
||||
OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(format, false, unusedSRGB);
|
||||
OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(format, false);
|
||||
|
||||
int faces = texType == TEXTURE_CUBE ? 6 : 1;
|
||||
|
||||
@@ -125,8 +124,7 @@ static GLenum createFBO(GLuint &framebuffer, TextureType texType, PixelFormat fo
|
||||
|
||||
static GLenum newRenderbuffer(int width, int height, int &samples, PixelFormat pixelformat, GLuint &buffer)
|
||||
{
|
||||
bool unusedSRGB = false;
|
||||
OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(pixelformat, true, unusedSRGB);
|
||||
OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(pixelformat, true);
|
||||
|
||||
GLuint current_fbo = gl.getFramebuffer(OpenGL::FRAMEBUFFER_ALL);
|
||||
|
||||
@@ -282,7 +280,7 @@ void Texture::createTexture()
|
||||
// remember some driver issues on some old Android systems, maybe...
|
||||
// For now, the base class enforces data on init for compressed textures.
|
||||
if (!isCompressed())
|
||||
gl.rawTexStorage(texType, mipcount, format, sRGB, pixelWidth, pixelHeight, texType == TEXTURE_VOLUME ? depth : layers);
|
||||
gl.rawTexStorage(texType, mipcount, format, pixelWidth, pixelHeight, texType == TEXTURE_VOLUME ? depth : layers);
|
||||
|
||||
// rawTexStorage handles this for uncompressed textures.
|
||||
if (isCompressed() && (GLAD_VERSION_1_1 || GLAD_ES_VERSION_3_0))
|
||||
@@ -292,7 +290,7 @@ void Texture::createTexture()
|
||||
int h = pixelHeight;
|
||||
int d = depth;
|
||||
|
||||
OpenGL::TextureFormat fmt = gl.convertPixelFormat(format, false, sRGB);
|
||||
OpenGL::TextureFormat fmt = gl.convertPixelFormat(format, false);
|
||||
|
||||
for (int mip = 0; mip < mipcount; mip++)
|
||||
{
|
||||
@@ -460,7 +458,7 @@ void Texture::uploadByteData(PixelFormat pixelformat, const void *data, size_t s
|
||||
|
||||
gl.bindTextureToUnit(this, 0, false);
|
||||
|
||||
OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(pixelformat, false, sRGB);
|
||||
OpenGL::TextureFormat fmt = OpenGL::convertPixelFormat(pixelformat, false);
|
||||
GLenum gltarget = OpenGL::getGLTextureType(texType);
|
||||
|
||||
if (texType == TEXTURE_CUBE)
|
||||
@@ -508,8 +506,7 @@ void Texture::readbackInternal(int slice, int mipmap, const Rect &rect, int dest
|
||||
|
||||
gl.bindTextureToUnit(this, 0, false);
|
||||
|
||||
bool isSRGB = false;
|
||||
OpenGL::TextureFormat fmt = gl.convertPixelFormat(format, false, isSRGB);
|
||||
OpenGL::TextureFormat fmt = gl.convertPixelFormat(format, false);
|
||||
|
||||
if (gl.isCopyTextureToBufferSupported())
|
||||
{
|
||||
|
||||
@@ -1057,11 +1057,11 @@ void Graphics::setWireframe(bool enable)
|
||||
states.back().wireframe = enable;
|
||||
}
|
||||
|
||||
bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRGB)
|
||||
bool Graphics::isPixelFormatSupported(PixelFormat format, uint32 usage)
|
||||
{
|
||||
format = getSizedFormat(format);
|
||||
|
||||
auto vulkanFormat = Vulkan::getTextureFormat(format, sRGB);
|
||||
auto vulkanFormat = Vulkan::getTextureFormat(format);
|
||||
|
||||
VkFormatProperties formatProperties;
|
||||
vkGetPhysicalDeviceFormatProperties(physicalDevice, vulkanFormat.internalFormat, &formatProperties);
|
||||
@@ -2444,12 +2444,12 @@ void Graphics::setRenderPass(const RenderTargets &rts, int pixelw, int pixelh, b
|
||||
RenderPassConfiguration renderPassConfiguration{};
|
||||
for (const auto &color : rts.colors)
|
||||
renderPassConfiguration.colorAttachments.push_back({
|
||||
Vulkan::getTextureFormat(color.texture->getPixelFormat(), isPixelFormatSRGB(color.texture->getPixelFormat())).internalFormat,
|
||||
Vulkan::getTextureFormat(color.texture->getPixelFormat()).internalFormat,
|
||||
VK_ATTACHMENT_LOAD_OP_LOAD,
|
||||
dynamic_cast<Texture*>(color.texture)->getMsaaSamples() });
|
||||
if (rts.depthStencil.texture != nullptr)
|
||||
renderPassConfiguration.staticData.depthStencilAttachment = {
|
||||
Vulkan::getTextureFormat(rts.depthStencil.texture->getPixelFormat(), false).internalFormat,
|
||||
Vulkan::getTextureFormat(rts.depthStencil.texture->getPixelFormat()).internalFormat,
|
||||
VK_ATTACHMENT_LOAD_OP_LOAD,
|
||||
VK_ATTACHMENT_LOAD_OP_LOAD,
|
||||
dynamic_cast<Texture*>(rts.depthStencil.texture)->getMsaaSamples() };
|
||||
|
||||
@@ -297,7 +297,7 @@ public:
|
||||
void setBlendState(const BlendState &blend) override;
|
||||
void setPointSize(float size) override;
|
||||
void setWireframe(bool enable) override;
|
||||
bool isPixelFormatSupported(PixelFormat format, uint32 usage, bool sRGB) override;
|
||||
bool isPixelFormatSupported(PixelFormat format, uint32 usage) override;
|
||||
Renderer getRenderer() const override;
|
||||
bool usesGLSLES() const override;
|
||||
RendererInfo getRendererInfo() const override;
|
||||
|
||||
@@ -59,7 +59,7 @@ bool Texture::loadVolatile()
|
||||
if (isPixelFormatColor(format))
|
||||
imageAspect |= VK_IMAGE_ASPECT_COLOR_BIT;
|
||||
|
||||
auto vulkanFormat = Vulkan::getTextureFormat(format, sRGB);
|
||||
auto vulkanFormat = Vulkan::getTextureFormat(format);
|
||||
|
||||
VkImageUsageFlags usageFlags =
|
||||
VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
|
||||
@@ -277,7 +277,7 @@ VkImageLayout Texture::getImageLayout() const
|
||||
|
||||
void Texture::createTextureImageView()
|
||||
{
|
||||
auto vulkanFormat = Vulkan::getTextureFormat(format, sRGB);
|
||||
auto vulkanFormat = Vulkan::getTextureFormat(format);
|
||||
|
||||
VkImageViewCreateInfo viewInfo{};
|
||||
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
||||
@@ -349,7 +349,7 @@ void Texture::clear()
|
||||
|
||||
VkClearColorValue Texture::getClearValue()
|
||||
{
|
||||
auto vulkanFormat = Vulkan::getTextureFormat(format, sRGB);
|
||||
auto vulkanFormat = Vulkan::getTextureFormat(format);
|
||||
|
||||
VkClearColorValue clearColor{};
|
||||
switch (vulkanFormat.internalFormatRepresentation)
|
||||
|
||||
@@ -130,16 +130,10 @@ VkFormat Vulkan::getVulkanVertexFormat(DataFormat format)
|
||||
}
|
||||
}
|
||||
|
||||
TextureFormat Vulkan::getTextureFormat(PixelFormat format, bool sRGB)
|
||||
TextureFormat Vulkan::getTextureFormat(PixelFormat format)
|
||||
{
|
||||
TextureFormat textureFormat{};
|
||||
|
||||
if (sRGB)
|
||||
format = getSRGBPixelFormat(format);
|
||||
|
||||
if (!isPixelFormatCompressed(format) && !isPixelFormatSRGB(format))
|
||||
sRGB = false;
|
||||
|
||||
switch (format)
|
||||
{
|
||||
case PIXELFORMAT_UNKNOWN:
|
||||
@@ -231,13 +225,13 @@ TextureFormat Vulkan::getTextureFormat(PixelFormat format, bool sRGB)
|
||||
case PIXELFORMAT_RGBA8_UNORM:
|
||||
textureFormat.internalFormat = VK_FORMAT_R8G8B8A8_UNORM;
|
||||
break;
|
||||
case PIXELFORMAT_RGBA8_UNORM_sRGB:
|
||||
case PIXELFORMAT_RGBA8_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_R8G8B8A8_SRGB;
|
||||
break;
|
||||
case PIXELFORMAT_BGRA8_UNORM:
|
||||
textureFormat.internalFormat = VK_FORMAT_B8G8R8A8_UNORM;
|
||||
break;
|
||||
case PIXELFORMAT_BGRA8_UNORM_sRGB:
|
||||
case PIXELFORMAT_BGRA8_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_B8G8R8A8_SRGB;
|
||||
break;
|
||||
case PIXELFORMAT_RGBA8_INT:
|
||||
@@ -308,13 +302,22 @@ TextureFormat Vulkan::getTextureFormat(PixelFormat format, bool sRGB)
|
||||
textureFormat.internalFormat = VK_FORMAT_D32_SFLOAT_S8_UINT;
|
||||
break;
|
||||
case PIXELFORMAT_DXT1_UNORM:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_BC1_RGBA_SRGB_BLOCK : VK_FORMAT_BC1_RGBA_UNORM_BLOCK;
|
||||
textureFormat.internalFormat = VK_FORMAT_BC1_RGBA_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_DXT1_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_BC1_RGBA_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_DXT3_UNORM:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_BC2_SRGB_BLOCK : VK_FORMAT_BC2_UNORM_BLOCK;
|
||||
textureFormat.internalFormat = VK_FORMAT_BC2_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_DXT3_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_BC2_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_DXT5_UNORM:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_BC3_SRGB_BLOCK : VK_FORMAT_BC3_UNORM_BLOCK;
|
||||
textureFormat.internalFormat = VK_FORMAT_BC3_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_DXT5_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_BC3_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_BC4_UNORM:
|
||||
textureFormat.internalFormat = VK_FORMAT_BC4_UNORM_BLOCK;
|
||||
@@ -335,31 +338,55 @@ TextureFormat Vulkan::getTextureFormat(PixelFormat format, bool sRGB)
|
||||
textureFormat.internalFormat = VK_FORMAT_BC6H_SFLOAT_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_BC7_UNORM:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_BC7_SRGB_BLOCK : VK_FORMAT_BC7_UNORM_BLOCK;
|
||||
textureFormat.internalFormat = VK_FORMAT_BC7_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_BC7_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_BC7_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGB2_UNORM:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG : VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG;
|
||||
textureFormat.internalFormat = VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGB2_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGB4_UNORM:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG : VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG;
|
||||
textureFormat.internalFormat = VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGB4_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGBA2_UNORM:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG : VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG;
|
||||
textureFormat.internalFormat = VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGBA2_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGBA4_UNORM:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG : VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG;
|
||||
textureFormat.internalFormat = VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG;
|
||||
break;
|
||||
case PIXELFORMAT_PVR1_RGBA4_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG;
|
||||
break;
|
||||
case PIXELFORMAT_ETC1_UNORM:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK : VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
|
||||
textureFormat.internalFormat = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ETC2_RGB_UNORM:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK : VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
|
||||
textureFormat.internalFormat = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ETC2_RGB_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ETC2_RGBA_UNORM:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK : VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
|
||||
textureFormat.internalFormat = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ETC2_RGBA_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ETC2_RGBA1_UNORM:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK : VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK;
|
||||
textureFormat.internalFormat = VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ETC2_RGBA1_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_EAC_R_UNORM:
|
||||
textureFormat.internalFormat = VK_FORMAT_EAC_R11_UNORM_BLOCK;
|
||||
@@ -373,47 +400,89 @@ TextureFormat Vulkan::getTextureFormat(PixelFormat format, bool sRGB)
|
||||
case PIXELFORMAT_EAC_RG_SNORM:
|
||||
textureFormat.internalFormat = VK_FORMAT_EAC_R11G11_SNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_4x4:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_4x4_SRGB_BLOCK : VK_FORMAT_ASTC_4x4_UNORM_BLOCK;
|
||||
case PIXELFORMAT_ASTC_4x4_UNORM:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_4x4_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_5x4:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_5x4_SRGB_BLOCK : VK_FORMAT_ASTC_5x4_UNORM_BLOCK;
|
||||
case PIXELFORMAT_ASTC_5x4_UNORM:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_5x4_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_5x5:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_5x5_SRGB_BLOCK : VK_FORMAT_ASTC_5x5_UNORM_BLOCK;
|
||||
case PIXELFORMAT_ASTC_5x5_UNORM:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_5x5_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_6x5:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_6x5_SRGB_BLOCK : VK_FORMAT_ASTC_6x5_UNORM_BLOCK;
|
||||
case PIXELFORMAT_ASTC_6x5_UNORM:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_6x5_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_6x6:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_6x6_SRGB_BLOCK : VK_FORMAT_ASTC_6x6_UNORM_BLOCK;
|
||||
case PIXELFORMAT_ASTC_6x6_UNORM:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_6x6_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_8x5:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_8x5_SRGB_BLOCK : VK_FORMAT_ASTC_8x5_UNORM_BLOCK;
|
||||
case PIXELFORMAT_ASTC_8x5_UNORM:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_8x5_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_8x6:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_8x6_SRGB_BLOCK : VK_FORMAT_ASTC_8x6_UNORM_BLOCK;
|
||||
case PIXELFORMAT_ASTC_8x6_UNORM:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_8x6_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_8x8:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_8x8_SRGB_BLOCK : VK_FORMAT_ASTC_8x8_UNORM_BLOCK;
|
||||
case PIXELFORMAT_ASTC_8x8_UNORM:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_8x8_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x5:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_10x5_SRGB_BLOCK : VK_FORMAT_ASTC_10x5_UNORM_BLOCK;
|
||||
case PIXELFORMAT_ASTC_10x5_UNORM:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_10x5_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x6:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_10x6_SRGB_BLOCK : VK_FORMAT_ASTC_10x6_UNORM_BLOCK;
|
||||
case PIXELFORMAT_ASTC_10x6_UNORM:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_10x6_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x8:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_10x8_SRGB_BLOCK : VK_FORMAT_ASTC_10x8_UNORM_BLOCK;
|
||||
case PIXELFORMAT_ASTC_10x8_UNORM:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_10x8_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x10:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_10x10_SRGB_BLOCK : VK_FORMAT_ASTC_10x10_UNORM_BLOCK;
|
||||
case PIXELFORMAT_ASTC_10x10_UNORM:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_10x10_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_12x10:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_12x10_SRGB_BLOCK : VK_FORMAT_ASTC_12x10_UNORM_BLOCK;
|
||||
case PIXELFORMAT_ASTC_12x10_UNORM:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_12x10_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_12x12:
|
||||
textureFormat.internalFormat = sRGB ? VK_FORMAT_ASTC_12x12_SRGB_BLOCK : VK_FORMAT_ASTC_12x12_UNORM_BLOCK;
|
||||
case PIXELFORMAT_ASTC_12x12_UNORM:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_12x12_UNORM_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_4x4_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_4x4_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_5x4_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_5x4_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_5x5_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_5x5_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_6x5_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_6x5_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_6x6_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_6x6_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_8x5_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_8x5_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_8x6_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_8x6_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_8x8_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_8x8_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x5_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_10x5_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x6_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_10x6_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x8_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_10x8_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_10x10_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_10x10_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_12x10_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_12x10_SRGB_BLOCK;
|
||||
break;
|
||||
case PIXELFORMAT_ASTC_12x12_sRGB:
|
||||
textureFormat.internalFormat = VK_FORMAT_ASTC_12x12_SRGB_BLOCK;
|
||||
break;
|
||||
default:
|
||||
throw love::Exception("unknown pixel format");
|
||||
|
||||
@@ -59,7 +59,7 @@ public:
|
||||
static void resetShaderSwitches();
|
||||
|
||||
static VkFormat getVulkanVertexFormat(DataFormat format);
|
||||
static TextureFormat getTextureFormat(PixelFormat, bool sRGB);
|
||||
static TextureFormat getTextureFormat(PixelFormat format);
|
||||
static std::string getVendorName(uint32_t vendorId);
|
||||
static std::string getVulkanApiVersion(uint32_t apiVersion);
|
||||
static VkPrimitiveTopology getPrimitiveTypeTopology(graphics::PrimitiveType);
|
||||
|
||||
@@ -2783,7 +2783,6 @@ int w_getTextureFormats(lua_State *L)
|
||||
luaL_checktype(L, 1, LUA_TTABLE);
|
||||
|
||||
bool rt = luax_checkboolflag(L, 1, Texture::getConstant(Texture::SETTING_RENDER_TARGET));
|
||||
bool linear = luax_boolflag(L, 1, Texture::getConstant(Texture::SETTING_LINEAR), false);
|
||||
bool computewrite = luax_boolflag(L, 1, Texture::getConstant(Texture::SETTING_COMPUTE_WRITE), false);
|
||||
|
||||
OptionalBool readable;
|
||||
@@ -2808,8 +2807,6 @@ int w_getTextureFormats(lua_State *L)
|
||||
if (rt && isPixelFormatDepth(format))
|
||||
continue;
|
||||
|
||||
bool sRGB = isGammaCorrect() && !linear;
|
||||
|
||||
uint32 usage = PIXELFORMATUSAGEFLAGS_NONE;
|
||||
if (rt)
|
||||
usage |= PIXELFORMATUSAGEFLAGS_RENDERTARGET;
|
||||
@@ -2818,7 +2815,7 @@ int w_getTextureFormats(lua_State *L)
|
||||
if (computewrite)
|
||||
usage |= PIXELFORMATUSAGEFLAGS_COMPUTEWRITE;
|
||||
|
||||
luax_pushboolean(L, instance()->isPixelFormatSupported(format, (PixelFormatUsageFlags) usage, sRGB));
|
||||
luax_pushboolean(L, instance()->isPixelFormatSupported(format, (PixelFormatUsageFlags) usage));
|
||||
lua_setfield(L, -2, name);
|
||||
}
|
||||
|
||||
@@ -2862,14 +2859,14 @@ int w_getCanvasFormats(lua_State *L)
|
||||
supported = [](PixelFormat format) -> bool
|
||||
{
|
||||
const uint32 usage = PIXELFORMATUSAGEFLAGS_SAMPLE | PIXELFORMATUSAGEFLAGS_RENDERTARGET;
|
||||
return instance()->isPixelFormatSupported(format, (PixelFormatUsageFlags) usage, false);
|
||||
return instance()->isPixelFormatSupported(format, (PixelFormatUsageFlags) usage);
|
||||
};
|
||||
}
|
||||
else
|
||||
{
|
||||
supported = [](PixelFormat format) -> bool
|
||||
{
|
||||
return instance()->isPixelFormatSupported(format, PIXELFORMATUSAGEFLAGS_RENDERTARGET, false);
|
||||
return instance()->isPixelFormatSupported(format, PIXELFORMATUSAGEFLAGS_RENDERTARGET);
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -2881,7 +2878,7 @@ int w_getCanvasFormats(lua_State *L)
|
||||
uint32 usage = PIXELFORMATUSAGEFLAGS_RENDERTARGET;
|
||||
if (readable)
|
||||
usage |= PIXELFORMATUSAGEFLAGS_SAMPLE;
|
||||
return instance()->isPixelFormatSupported(format, (PixelFormatUsageFlags) usage, false);
|
||||
return instance()->isPixelFormatSupported(format, (PixelFormatUsageFlags) usage);
|
||||
};
|
||||
}
|
||||
|
||||
@@ -2894,7 +2891,7 @@ int w_getImageFormats(lua_State *L)
|
||||
|
||||
const auto supported = [](PixelFormat format) -> bool
|
||||
{
|
||||
return instance()->isPixelFormatSupported(format, PIXELFORMATUSAGEFLAGS_SAMPLE, false);
|
||||
return instance()->isPixelFormatSupported(format, PIXELFORMATUSAGEFLAGS_SAMPLE);
|
||||
};
|
||||
|
||||
const auto ignore = [](PixelFormat format) -> bool
|
||||
|
||||
@@ -54,33 +54,33 @@ static PixelFormat convertFormat(uint32 blockX, uint32 blockY, uint32 blockZ)
|
||||
return PIXELFORMAT_UNKNOWN;
|
||||
|
||||
if (blockX == 4 && blockY == 4)
|
||||
return PIXELFORMAT_ASTC_4x4;
|
||||
return PIXELFORMAT_ASTC_4x4_UNORM;
|
||||
else if (blockX == 5 && blockY == 4)
|
||||
return PIXELFORMAT_ASTC_5x4;
|
||||
return PIXELFORMAT_ASTC_5x4_UNORM;
|
||||
else if (blockX == 5 && blockY == 5)
|
||||
return PIXELFORMAT_ASTC_5x5;
|
||||
return PIXELFORMAT_ASTC_5x5_UNORM;
|
||||
else if (blockX == 6 && blockY == 5)
|
||||
return PIXELFORMAT_ASTC_6x5;
|
||||
return PIXELFORMAT_ASTC_6x5_UNORM;
|
||||
else if (blockX == 6 && blockY == 6)
|
||||
return PIXELFORMAT_ASTC_6x6;
|
||||
return PIXELFORMAT_ASTC_6x6_UNORM;
|
||||
else if (blockX == 8 && blockY == 5)
|
||||
return PIXELFORMAT_ASTC_8x5;
|
||||
return PIXELFORMAT_ASTC_8x5_UNORM;
|
||||
else if (blockX == 8 && blockY == 6)
|
||||
return PIXELFORMAT_ASTC_8x6;
|
||||
return PIXELFORMAT_ASTC_8x6_UNORM;
|
||||
else if (blockX == 8 && blockY == 8)
|
||||
return PIXELFORMAT_ASTC_8x8;
|
||||
return PIXELFORMAT_ASTC_8x8_UNORM;
|
||||
else if (blockX == 10 && blockY == 5)
|
||||
return PIXELFORMAT_ASTC_10x5;
|
||||
return PIXELFORMAT_ASTC_10x5_UNORM;
|
||||
else if (blockX == 10 && blockY == 6)
|
||||
return PIXELFORMAT_ASTC_10x6;
|
||||
return PIXELFORMAT_ASTC_10x6_UNORM;
|
||||
else if (blockX == 10 && blockY == 8)
|
||||
return PIXELFORMAT_ASTC_10x8;
|
||||
return PIXELFORMAT_ASTC_10x8_UNORM;
|
||||
else if (blockX == 10 && blockY == 10)
|
||||
return PIXELFORMAT_ASTC_10x10;
|
||||
return PIXELFORMAT_ASTC_10x10_UNORM;
|
||||
else if (blockX == 12 && blockY == 10)
|
||||
return PIXELFORMAT_ASTC_12x10;
|
||||
return PIXELFORMAT_ASTC_12x10_UNORM;
|
||||
else if (blockX == 12 && blockY == 12)
|
||||
return PIXELFORMAT_ASTC_12x12;
|
||||
return PIXELFORMAT_ASTC_12x12_UNORM;
|
||||
|
||||
return PIXELFORMAT_UNKNOWN;
|
||||
}
|
||||
|
||||
@@ -221,59 +221,59 @@ PixelFormat convertFormat(uint32 glformat, bool &sRGB)
|
||||
case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
|
||||
sRGB = true;
|
||||
case KTX_GL_COMPRESSED_RGBA_ASTC_4x4_KHR:
|
||||
return PIXELFORMAT_ASTC_4x4;
|
||||
return PIXELFORMAT_ASTC_4x4_UNORM;
|
||||
case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
|
||||
sRGB = true;
|
||||
case KTX_GL_COMPRESSED_RGBA_ASTC_5x4_KHR:
|
||||
return PIXELFORMAT_ASTC_5x4;
|
||||
return PIXELFORMAT_ASTC_5x4_UNORM;
|
||||
case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
|
||||
sRGB = true;
|
||||
case KTX_GL_COMPRESSED_RGBA_ASTC_5x5_KHR:
|
||||
return PIXELFORMAT_ASTC_5x5;
|
||||
return PIXELFORMAT_ASTC_5x5_UNORM;
|
||||
case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
|
||||
sRGB = true;
|
||||
case KTX_GL_COMPRESSED_RGBA_ASTC_6x5_KHR:
|
||||
return PIXELFORMAT_ASTC_6x5;
|
||||
return PIXELFORMAT_ASTC_6x5_UNORM;
|
||||
case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
|
||||
sRGB = true;
|
||||
case KTX_GL_COMPRESSED_RGBA_ASTC_6x6_KHR:
|
||||
return PIXELFORMAT_ASTC_6x6;
|
||||
return PIXELFORMAT_ASTC_6x6_UNORM;
|
||||
case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
|
||||
sRGB = true;
|
||||
case KTX_GL_COMPRESSED_RGBA_ASTC_8x5_KHR:
|
||||
return PIXELFORMAT_ASTC_8x5;
|
||||
return PIXELFORMAT_ASTC_8x5_UNORM;
|
||||
case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
|
||||
sRGB = true;
|
||||
case KTX_GL_COMPRESSED_RGBA_ASTC_8x6_KHR:
|
||||
return PIXELFORMAT_ASTC_8x6;
|
||||
return PIXELFORMAT_ASTC_8x6_UNORM;
|
||||
case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
|
||||
sRGB = true;
|
||||
case KTX_GL_COMPRESSED_RGBA_ASTC_8x8_KHR:
|
||||
return PIXELFORMAT_ASTC_8x8;
|
||||
return PIXELFORMAT_ASTC_8x8_UNORM;
|
||||
case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
|
||||
sRGB = true;
|
||||
case KTX_GL_COMPRESSED_RGBA_ASTC_10x5_KHR:
|
||||
return PIXELFORMAT_ASTC_10x5;
|
||||
return PIXELFORMAT_ASTC_10x5_UNORM;
|
||||
case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
|
||||
sRGB = true;
|
||||
case KTX_GL_COMPRESSED_RGBA_ASTC_10x6_KHR:
|
||||
return PIXELFORMAT_ASTC_10x6;
|
||||
return PIXELFORMAT_ASTC_10x6_UNORM;
|
||||
case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
|
||||
sRGB = true;
|
||||
case KTX_GL_COMPRESSED_RGBA_ASTC_10x8_KHR:
|
||||
return PIXELFORMAT_ASTC_10x8;
|
||||
return PIXELFORMAT_ASTC_10x8_UNORM;
|
||||
case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
|
||||
sRGB = true;
|
||||
case KTX_GL_COMPRESSED_RGBA_ASTC_10x10_KHR:
|
||||
return PIXELFORMAT_ASTC_10x10;
|
||||
return PIXELFORMAT_ASTC_10x10_UNORM;
|
||||
case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
|
||||
sRGB = true;
|
||||
case KTX_GL_COMPRESSED_RGBA_ASTC_12x10_KHR:
|
||||
return PIXELFORMAT_ASTC_12x10;
|
||||
return PIXELFORMAT_ASTC_12x10_UNORM;
|
||||
case KTX_GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
|
||||
sRGB = true;
|
||||
case KTX_GL_COMPRESSED_RGBA_ASTC_12x12_KHR:
|
||||
return PIXELFORMAT_ASTC_12x12;
|
||||
return PIXELFORMAT_ASTC_12x12_UNORM;
|
||||
default:
|
||||
return PIXELFORMAT_UNKNOWN;
|
||||
}
|
||||
|
||||
@@ -256,33 +256,33 @@ static PixelFormat convertFormat(PVRV3PixelFormat format, PVRV3ChannelType chann
|
||||
case ePVRTPF_EAC_RG:
|
||||
return snorm ? PIXELFORMAT_EAC_RG_SNORM : PIXELFORMAT_EAC_RG_UNORM;
|
||||
case ePVRTPF_ASTC_4x4:
|
||||
return PIXELFORMAT_ASTC_4x4;
|
||||
return PIXELFORMAT_ASTC_4x4_UNORM;
|
||||
case ePVRTPF_ASTC_5x4:
|
||||
return PIXELFORMAT_ASTC_5x4;
|
||||
return PIXELFORMAT_ASTC_5x4_UNORM;
|
||||
case ePVRTPF_ASTC_5x5:
|
||||
return PIXELFORMAT_ASTC_5x5;
|
||||
return PIXELFORMAT_ASTC_5x5_UNORM;
|
||||
case ePVRTPF_ASTC_6x5:
|
||||
return PIXELFORMAT_ASTC_6x5;
|
||||
return PIXELFORMAT_ASTC_6x5_UNORM;
|
||||
case ePVRTPF_ASTC_6x6:
|
||||
return PIXELFORMAT_ASTC_6x6;
|
||||
return PIXELFORMAT_ASTC_6x6_UNORM;
|
||||
case ePVRTPF_ASTC_8x5:
|
||||
return PIXELFORMAT_ASTC_8x5;
|
||||
return PIXELFORMAT_ASTC_8x5_UNORM;
|
||||
case ePVRTPF_ASTC_8x6:
|
||||
return PIXELFORMAT_ASTC_8x6;
|
||||
return PIXELFORMAT_ASTC_8x6_UNORM;
|
||||
case ePVRTPF_ASTC_8x8:
|
||||
return PIXELFORMAT_ASTC_8x8;
|
||||
return PIXELFORMAT_ASTC_8x8_UNORM;
|
||||
case ePVRTPF_ASTC_10x5:
|
||||
return PIXELFORMAT_ASTC_10x5;
|
||||
return PIXELFORMAT_ASTC_10x5_UNORM;
|
||||
case ePVRTPF_ASTC_10x6:
|
||||
return PIXELFORMAT_ASTC_10x6;
|
||||
return PIXELFORMAT_ASTC_10x6_UNORM;
|
||||
case ePVRTPF_ASTC_10x8:
|
||||
return PIXELFORMAT_ASTC_10x8;
|
||||
return PIXELFORMAT_ASTC_10x8_UNORM;
|
||||
case ePVRTPF_ASTC_10x10:
|
||||
return PIXELFORMAT_ASTC_10x10;
|
||||
return PIXELFORMAT_ASTC_10x10_UNORM;
|
||||
case ePVRTPF_ASTC_12x10:
|
||||
return PIXELFORMAT_ASTC_12x10;
|
||||
return PIXELFORMAT_ASTC_12x10_UNORM;
|
||||
case ePVRTPF_ASTC_12x12:
|
||||
return PIXELFORMAT_ASTC_12x12;
|
||||
return PIXELFORMAT_ASTC_12x12_UNORM;
|
||||
default:
|
||||
return PIXELFORMAT_UNKNOWN;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user