/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "GrVkCaps.h"
#include "GrVkUtil.h"
#include "glsl/GrGLSLCaps.h"
#include "vk/GrVkInterface.h"
GrVkCaps::GrVkCaps(const GrContextOptions& contextOptions, const GrVkInterface* vkInterface,
VkPhysicalDevice physDev) : INHERITED(contextOptions) {
/**************************************************************************
* GrDrawTargetCaps fields
**************************************************************************/
fMipMapSupport = false; //TODO: figure this out
fNPOTTextureTileSupport = false; //TODO: figure this out
fTwoSidedStencilSupport = false; //TODO: figure this out
fStencilWrapOpsSupport = false; //TODO: figure this out
fDiscardRenderTargetSupport = false; //TODO: figure this out
fReuseScratchTextures = true; //TODO: figure this out
fGpuTracingSupport = false; //TODO: figure this out
fCompressedTexSubImageSupport = false; //TODO: figure this out
fOversizedStencilSupport = false; //TODO: figure this out
fUseDrawInsteadOfClear = false; //TODO: figure this out
fMapBufferFlags = kNone_MapFlags; //TODO: figure this out
fGeometryBufferMapThreshold = SK_MaxS32; //TODO: figure this out
fMaxRenderTargetSize = 4096; // minimum required by spec
fMaxTextureSize = 4096; // minimum required by spec
fMaxColorSampleCount = 4; // minimum required by spec
fMaxStencilSampleCount = 4; // minimum required by spec
fShaderCaps.reset(new GrGLSLCaps(contextOptions));
/**************************************************************************
* GrVkCaps fields
**************************************************************************/
fMaxSampledTextures = 16; // Spec requires a minimum of 16 sampled textures per stage
this->init(contextOptions, vkInterface, physDev);
}
void GrVkCaps::init(const GrContextOptions& contextOptions, const GrVkInterface* vkInterface,
VkPhysicalDevice physDev) {
this->initGLSLCaps(vkInterface, physDev);
this->initConfigTexturableTable(vkInterface, physDev);
this->initConfigRenderableTable(vkInterface, physDev);
this->initStencilFormats(vkInterface, physDev);
VkPhysicalDeviceProperties properties;
GR_VK_CALL(vkInterface, GetPhysicalDeviceProperties(physDev, &properties));
// We could actually querey and get a max size for each config, however maxImageDimension2D will
// give the minimum max size across all configs. So for simplicity we will use that for now.
fMaxRenderTargetSize = properties.limits.maxImageDimension2D;
fMaxTextureSize = properties.limits.maxImageDimension2D;
this->initSampleCount(properties);
fMaxSampledTextures = SkTMin(properties.limits.maxPerStageDescriptorSampledImages,
properties.limits.maxPerStageDescriptorSamplers);
this->applyOptionsOverrides(contextOptions);
// need to friend GrVkCaps in GrGLSLCaps.h
// GrGLSLCaps* glslCaps = static_cast<GrGLSLCaps*>(fShaderCaps.get());
// glslCaps->applyOptionsOverrides(contextOptions);
}
int get_max_sample_count(VkSampleCountFlags flags) {
SkASSERT(flags & VK_SAMPLE_COUNT_1_BIT);
if (!(flags & VK_SAMPLE_COUNT_2_BIT)) {
return 0;
}
if (!(flags & VK_SAMPLE_COUNT_4_BIT)) {
return 2;
}
if (!(flags & VK_SAMPLE_COUNT_8_BIT)) {
return 4;
}
if (!(flags & VK_SAMPLE_COUNT_16_BIT)) {
return 8;
}
if (!(flags & VK_SAMPLE_COUNT_32_BIT)) {
return 16;
}
if (!(flags & VK_SAMPLE_COUNT_64_BIT)) {
return 32;
}
return 64;
}
void GrVkCaps::initSampleCount(const VkPhysicalDeviceProperties& properties) {
VkSampleCountFlags colorSamples = properties.limits.framebufferColorSampleCounts;
VkSampleCountFlags stencilSamples = properties.limits.framebufferStencilSampleCounts;
fMaxColorSampleCount = get_max_sample_count(colorSamples);
fMaxStencilSampleCount = get_max_sample_count(stencilSamples);
}
void GrVkCaps::initGLSLCaps(const GrVkInterface* interface, VkPhysicalDevice physDev) {
GrGLSLCaps* glslCaps = static_cast<GrGLSLCaps*>(fShaderCaps.get());
// TODO: actually figure out a correct version here
glslCaps->fVersionDeclString = "#version 140\n";
// fConfigOutputSwizzle will default to RGBA so we only need to set it for alpha only config.
for (int i = 0; i < kGrPixelConfigCnt; ++i) {
GrPixelConfig config = static_cast<GrPixelConfig>(i);
if (GrPixelConfigIsAlphaOnly(config)) {
glslCaps->fConfigTextureSwizzle[i] = GrSwizzle::RRRR();
glslCaps->fConfigOutputSwizzle[i] = GrSwizzle::AAAA();
} else {
glslCaps->fConfigTextureSwizzle[i] = GrSwizzle::RGBA();
}
}
}
static void format_supported_for_feature(const GrVkInterface* interface,
VkPhysicalDevice physDev,
VkFormat format,
VkFormatFeatureFlagBits featureBit,
bool* linearSupport,
bool* optimalSupport) {
VkFormatProperties props;
memset(&props, 0, sizeof(VkFormatProperties));
GR_VK_CALL(interface, GetPhysicalDeviceFormatProperties(physDev, format, &props));
*linearSupport = SkToBool(props.linearTilingFeatures & featureBit);
*optimalSupport = SkToBool(props.optimalTilingFeatures & featureBit);
}
static void config_supported_for_feature(const GrVkInterface* interface,
VkPhysicalDevice physDev,
GrPixelConfig config,
VkFormatFeatureFlagBits featureBit,
bool* linearSupport,
bool* optimalSupport) {
VkFormat format;
if (!GrPixelConfigToVkFormat(config, &format)) {
*linearSupport = false;
*optimalSupport = false;
return;
}
format_supported_for_feature(interface, physDev, format, featureBit,
linearSupport, optimalSupport);
}
// Currently just assumeing if something can be rendered to without MSAA it also works for MSAAA
#define SET_CONFIG_IS_RENDERABLE(config) \
config_supported_for_feature(interface, \
physDev, \
config, \
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, \
&fConfigLinearRenderSupport[config][kNo_MSAA], \
&fConfigRenderSupport[config][kNo_MSAA] ); \
fConfigRenderSupport[config][kYes_MSAA] = fConfigRenderSupport[config][kNo_MSAA]; \
fConfigLinearRenderSupport[config][kYes_MSAA] = fConfigLinearRenderSupport[config][kNo_MSAA];
void GrVkCaps::initConfigRenderableTable(const GrVkInterface* interface, VkPhysicalDevice physDev) {
enum {
kNo_MSAA = 0,
kYes_MSAA = 1,
};
// Base render support
SET_CONFIG_IS_RENDERABLE(kAlpha_8_GrPixelConfig);
SET_CONFIG_IS_RENDERABLE(kRGB_565_GrPixelConfig);
SET_CONFIG_IS_RENDERABLE(kRGBA_4444_GrPixelConfig);
SET_CONFIG_IS_RENDERABLE(kRGBA_8888_GrPixelConfig);
SET_CONFIG_IS_RENDERABLE(kBGRA_8888_GrPixelConfig);
SET_CONFIG_IS_RENDERABLE(kSRGBA_8888_GrPixelConfig);
// Float render support
SET_CONFIG_IS_RENDERABLE(kRGBA_float_GrPixelConfig);
SET_CONFIG_IS_RENDERABLE(kRGBA_half_GrPixelConfig);
SET_CONFIG_IS_RENDERABLE(kAlpha_half_GrPixelConfig);
}
#define SET_CONFIG_IS_TEXTURABLE(config) \
config_supported_for_feature(interface, \
physDev, \
config, \
VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, \
&fConfigLinearTextureSupport[config], \
&fConfigTextureSupport[config]);
void GrVkCaps::initConfigTexturableTable(const GrVkInterface* interface, VkPhysicalDevice physDev) {
// Base texture support
SET_CONFIG_IS_TEXTURABLE(kAlpha_8_GrPixelConfig);
SET_CONFIG_IS_TEXTURABLE(kRGB_565_GrPixelConfig);
SET_CONFIG_IS_TEXTURABLE(kRGBA_4444_GrPixelConfig);
SET_CONFIG_IS_TEXTURABLE(kRGBA_8888_GrPixelConfig);
SET_CONFIG_IS_TEXTURABLE(kBGRA_8888_GrPixelConfig);
SET_CONFIG_IS_TEXTURABLE(kIndex_8_GrPixelConfig);
SET_CONFIG_IS_TEXTURABLE(kSRGBA_8888_GrPixelConfig);
// Compressed texture support
SET_CONFIG_IS_TEXTURABLE(kETC1_GrPixelConfig);
SET_CONFIG_IS_TEXTURABLE(kLATC_GrPixelConfig);
SET_CONFIG_IS_TEXTURABLE(kR11_EAC_GrPixelConfig);
SET_CONFIG_IS_TEXTURABLE(kASTC_12x12_GrPixelConfig);
// Float texture support
SET_CONFIG_IS_TEXTURABLE(kRGBA_float_GrPixelConfig);
SET_CONFIG_IS_TEXTURABLE(kRGBA_half_GrPixelConfig);
SET_CONFIG_IS_TEXTURABLE(kAlpha_half_GrPixelConfig);
}
#define SET_CONFIG_CAN_STENCIL(config) \
bool SK_MACRO_APPEND_LINE(linearSupported); \
bool SK_MACRO_APPEND_LINE(optimalSupported); \
format_supported_for_feature(interface, \
physDev, \
config.fInternalFormat, \
VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, \
&SK_MACRO_APPEND_LINE(linearSupported), \
&SK_MACRO_APPEND_LINE(optimalSupported)); \
if (SK_MACRO_APPEND_LINE(linearSupported)) fLinearStencilFormats.push_back(config); \
if (SK_MACRO_APPEND_LINE(optimalSupported)) fStencilFormats.push_back(config);
void GrVkCaps::initStencilFormats(const GrVkInterface* interface, VkPhysicalDevice physDev) {
// Build up list of legal stencil formats (though perhaps not supported on
// the particular gpu/driver) from most preferred to least.
static const StencilFormat
// internal Format stencil bits total bits packed?
gS8 = { VK_FORMAT_S8_UINT, 8, 8, false },
gD24S8 = { VK_FORMAT_D24_UNORM_S8_UINT, 8, 32, true };
// I'm simply assuming that these two will be supported since they are used in example code.
// TODO: Actaully figure this out
SET_CONFIG_CAN_STENCIL(gS8);
SET_CONFIG_CAN_STENCIL(gD24S8);
}