std::vector<T> readInterleavedData (const int count, const void* memory, const int offset, const int stride)
{
std::vector<T> results(count);
const deUint8* pData = static_cast<const deUint8*>(memory) + offset;
for (int i = 0; i < count; ++i)
{
deMemcpy(&results[i], pData, sizeof(T));
pData += stride;
}
return results;
}
GLW_APICALL void GLW_APIENTRY glGetInternalformativ (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params)
{
static const int s_sampleCounts[] = { 16, 8, 4, 2, 1 };
DE_UNREF(internalformat);
DE_UNREF(target);
switch (pname)
{
case GL_NUM_SAMPLE_COUNTS:
if (bufSize >= 1)
*params = DE_LENGTH_OF_ARRAY(s_sampleCounts);
break;
case GL_SAMPLES:
deMemcpy(params, s_sampleCounts, de::min(bufSize, DE_LENGTH_OF_ARRAY(s_sampleCounts)));
break;
default:
break;
}
}
void ArrayBuffer_selfTest (void)
{
// default constructor
{
de::ArrayBuffer<int> buf;
DE_TEST_ASSERT(buf.size() == 0);
DE_TEST_ASSERT(buf.getPtr() == DE_NULL);
}
// sized constructor
{
de::ArrayBuffer<int> buf(4);
DE_TEST_ASSERT(buf.size() == 4);
DE_TEST_ASSERT(buf.getPtr() != DE_NULL);
}
// copy constructor
{
de::ArrayBuffer<int> originalBuf(4);
*originalBuf.getElementPtr(0) = 1;
*originalBuf.getElementPtr(1) = 2;
*originalBuf.getElementPtr(2) = 3;
*originalBuf.getElementPtr(3) = 4;
de::ArrayBuffer<int> targetBuf(originalBuf);
DE_TEST_ASSERT(*originalBuf.getElementPtr(0) == 1);
DE_TEST_ASSERT(*originalBuf.getElementPtr(1) == 2);
DE_TEST_ASSERT(*originalBuf.getElementPtr(2) == 3);
DE_TEST_ASSERT(*originalBuf.getElementPtr(3) == 4);
DE_TEST_ASSERT(*targetBuf.getElementPtr(0) == 1);
DE_TEST_ASSERT(*targetBuf.getElementPtr(1) == 2);
DE_TEST_ASSERT(*targetBuf.getElementPtr(2) == 3);
DE_TEST_ASSERT(*targetBuf.getElementPtr(3) == 4);
}
// assignment
{
de::ArrayBuffer<int> originalBuf(4);
*originalBuf.getElementPtr(0) = 1;
*originalBuf.getElementPtr(1) = 2;
*originalBuf.getElementPtr(2) = 3;
*originalBuf.getElementPtr(3) = 4;
de::ArrayBuffer<int> targetBuf(1);
targetBuf = originalBuf;
DE_TEST_ASSERT(*originalBuf.getElementPtr(0) == 1);
DE_TEST_ASSERT(*originalBuf.getElementPtr(1) == 2);
DE_TEST_ASSERT(*originalBuf.getElementPtr(2) == 3);
DE_TEST_ASSERT(*originalBuf.getElementPtr(3) == 4);
DE_TEST_ASSERT(*targetBuf.getElementPtr(0) == 1);
DE_TEST_ASSERT(*targetBuf.getElementPtr(1) == 2);
DE_TEST_ASSERT(*targetBuf.getElementPtr(2) == 3);
DE_TEST_ASSERT(*targetBuf.getElementPtr(3) == 4);
}
// clear
{
de::ArrayBuffer<int> buf(4);
buf.clear();
DE_TEST_ASSERT(buf.size() == 0);
DE_TEST_ASSERT(buf.getPtr() == DE_NULL);
}
// setStorage
{
de::ArrayBuffer<int> buf(4);
buf.setStorage(12);
DE_TEST_ASSERT(buf.size() == 12);
DE_TEST_ASSERT(buf.getPtr() != DE_NULL);
}
// setStorage, too large
{
de::ArrayBuffer<int> buf(4);
*buf.getElementPtr(0) = 1;
*buf.getElementPtr(1) = 2;
*buf.getElementPtr(2) = 3;
*buf.getElementPtr(3) = 4;
try
{
buf.setStorage((size_t)-1);
// setStorage succeeded, all ok
}
catch (std::bad_alloc&)
{
// alloc failed, check storage not changed
DE_TEST_ASSERT(buf.size() == 4);
DE_TEST_ASSERT(*buf.getElementPtr(0) == 1);
DE_TEST_ASSERT(*buf.getElementPtr(1) == 2);
DE_TEST_ASSERT(*buf.getElementPtr(2) == 3);
DE_TEST_ASSERT(*buf.getElementPtr(3) == 4);
}
}
// swap
{
de::ArrayBuffer<int> buf;
de::ArrayBuffer<int> source(4);
*source.getElementPtr(0) = 1;
*source.getElementPtr(1) = 2;
*source.getElementPtr(2) = 3;
*source.getElementPtr(3) = 4;
buf.swap(source);
DE_TEST_ASSERT(source.size() == 0);
DE_TEST_ASSERT(buf.size() == 4);
DE_TEST_ASSERT(*buf.getElementPtr(0) == 1);
DE_TEST_ASSERT(*buf.getElementPtr(1) == 2);
DE_TEST_ASSERT(*buf.getElementPtr(2) == 3);
DE_TEST_ASSERT(*buf.getElementPtr(3) == 4);
}
// default
{
de::ArrayBuffer<int> source(4);
int dst;
*source.getElementPtr(1) = 2;
deMemcpy(&dst, (int*)source.getPtr() + 1, sizeof(int));
DE_TEST_ASSERT(dst == 2);
}
// Aligned
{
de::ArrayBuffer<int, 64, sizeof(int)> source(4);
int dst;
*source.getElementPtr(1) = 2;
deMemcpy(&dst, (int*)source.getPtr() + 1, sizeof(int));
DE_TEST_ASSERT(dst == 2);
}
// Strided
{
de::ArrayBuffer<int, 4, 64> source(4);
int dst;
*source.getElementPtr(1) = 2;
deMemcpy(&dst, (deUint8*)source.getPtr() + 64, sizeof(int));
DE_TEST_ASSERT(dst == 2);
}
// Aligned, Strided
{
de::ArrayBuffer<int, 32, 64> source(4);
int dst;
*source.getElementPtr(1) = 2;
deMemcpy(&dst, (deUint8*)source.getPtr() + 64, sizeof(int));
DE_TEST_ASSERT(dst == 2);
}
}
/** Render polygon with anisotropic filtering.
*
* @param gl OpenGL functions wrapper
* @param target Texture target
* @param anisoDegree Degree of anisotropy
*
* @return Returns true if no error occured, false otherwise.
*/
bool TextureFilterAnisotropicDrawingTestCase::drawTexture(const glw::Functions& gl, GLenum target, GLfloat anisoDegree)
{
const GLfloat vertices2[] = { -1.0f, 0.0f, -0.5f, 0.0f, 0.0f, -4.0f, 4.0f, -2.0f, 0.0f, 1.0f,
1.0f, 0.0f, -0.5f, 1.0f, 0.0f, -2.0f, 4.0f, -2.0f, 1.0f, 1.0f };
const GLfloat vertices3[] = { -1.0f, 0.0f, -0.5f, 0.0f, 0.0f, 0.0f, -4.0f, 4.0f, -2.0f, 0.0f, 1.0f, 0.0f,
1.0f, 0.0f, -0.5f, 1.0f, 0.0f, 0.0f, -2.0f, 4.0f, -2.0f, 1.0f, 1.0f, 0.0f };
// Projection values.
const GLfloat projectionMatrix[] = { 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f,
0.0f, 0.0f, -2.5f / 1.5f, -2.0f / 1.5f, 0.0f, 0.0f, -1.0f, 0.0f };
gl.viewport(0, 0, 32, 32);
std::string vertexShader = m_vertex;
std::string fragmentShader = m_fragment;
std::string texCoordType;
std::string samplerType;
TextureFilterAnisotropicUtils::generateTokens(target, texCoordType, samplerType);
TextureFilterAnisotropicUtils::replaceToken("<TEXCOORD_TYPE>", texCoordType.c_str(), vertexShader);
TextureFilterAnisotropicUtils::replaceToken("<TEXCOORD_TYPE>", texCoordType.c_str(), fragmentShader);
TextureFilterAnisotropicUtils::replaceToken("<SAMPLER_TYPE>", samplerType.c_str(), vertexShader);
TextureFilterAnisotropicUtils::replaceToken("<SAMPLER_TYPE>", samplerType.c_str(), fragmentShader);
if (glu::isContextTypeGLCore(m_context.getRenderContext().getType()))
{
TextureFilterAnisotropicUtils::replaceToken("<VERSION>", "130", vertexShader);
TextureFilterAnisotropicUtils::replaceToken("<VERSION>", "130", fragmentShader);
}
else
{
TextureFilterAnisotropicUtils::replaceToken("<VERSION>", "300 es", vertexShader);
TextureFilterAnisotropicUtils::replaceToken("<VERSION>", "300 es", fragmentShader);
}
ProgramSources sources = makeVtxFragSources(vertexShader, fragmentShader);
ShaderProgram program(gl, sources);
if (!program.isOk())
{
m_testCtx.getLog() << tcu::TestLog::Message << "Shader build failed.\n"
<< "Vertex: " << program.getShaderInfo(SHADERTYPE_VERTEX).infoLog << "\n"
<< vertexShader << "\n"
<< "Fragment: " << program.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog << "\n"
<< fragmentShader << "\n"
<< "Program: " << program.getProgramInfo().infoLog << tcu::TestLog::EndMessage;
return false;
}
GLuint vao;
gl.genVertexArrays(1, &vao);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays");
gl.bindVertexArray(vao);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray");
GLuint vbo;
gl.genBuffers(1, &vbo);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers");
gl.bindBuffer(GL_ARRAY_BUFFER, vbo);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer");
std::vector<GLfloat> vboData;
vboData.resize(24);
GLuint texCoordDim;
if (texCoordType == "vec2")
{
texCoordDim = 2;
deMemcpy((void*)vboData.data(), (void*)vertices2, sizeof(vertices2));
}
else
{
texCoordDim = 3;
deMemcpy((void*)vboData.data(), (void*)vertices3, sizeof(vertices3));
}
gl.bufferData(GL_ARRAY_BUFFER, vboData.size() * sizeof(GLfloat), (GLvoid*)vboData.data(), GL_DYNAMIC_DRAW);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData");
gl.useProgram(program.getProgram());
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram");
GLuint matrixLocation = gl.getUniformLocation(program.getProgram(), "projectionMatrix");
GLuint texLocation = gl.getUniformLocation(program.getProgram(), "tex");
gl.activeTexture(GL_TEXTURE0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture");
gl.bindTexture(target, m_texture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture");
gl.uniformMatrix4fv(matrixLocation, 1, GL_FALSE, projectionMatrix);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformMatrix4fv");
gl.uniform1i(texLocation, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i");
gl.texParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisoDegree);
GLU_EXPECT_NO_ERROR(gl.getError(), "texParameterfv");
gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
GLU_EXPECT_NO_ERROR(gl.getError(), "glClearColor");
gl.clear(GL_COLOR_BUFFER_BIT);
GLU_EXPECT_NO_ERROR(gl.getError(), "glClear");
gl.enableVertexAttribArray(0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray");
gl.enableVertexAttribArray(1);
GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray");
GLint attrLocationVertex = gl.getAttribLocation(program.getProgram(), "vertex");
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation");
GLint attrLocationInTexCoord = gl.getAttribLocation(program.getProgram(), "inTexCoord");
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation");
GLuint strideSize = (3 + texCoordDim) * sizeof(GLfloat);
gl.vertexAttribPointer(attrLocationVertex, 3, GL_FLOAT, GL_FALSE, strideSize, DE_NULL);
GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer");
gl.vertexAttribPointer(attrLocationInTexCoord, texCoordDim, GL_FLOAT, GL_FALSE, strideSize,
(GLvoid*)(3 * sizeof(GLfloat)));
GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer");
gl.drawArrays(GL_TRIANGLE_STRIP, 0, 4);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArray");
gl.disableVertexAttribArray(0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDisableVertexAttribArray");
gl.disableVertexAttribArray(1);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDisableVertexAttribArray");
if (vbo)
{
gl.deleteBuffers(1, &vbo);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers");
}
if (vao)
{
gl.deleteVertexArrays(1, &vao);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteVertexArrays");
}
return true;
}
void DrawTestsBaseClass::initialize (void)
{
const vk::VkDevice device = m_context.getDevice();
const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
const PipelineLayoutCreateInfo pipelineLayoutCreateInfo;
m_pipelineLayout = vk::createPipelineLayout(m_vk, device, &pipelineLayoutCreateInfo);
const vk::VkExtent3D targetImageExtent = { WIDTH, HEIGHT, 1 };
const ImageCreateInfo targetImageCreateInfo(vk::VK_IMAGE_TYPE_2D, m_colorAttachmentFormat, targetImageExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT,
vk::VK_IMAGE_TILING_OPTIMAL, vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT | vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT);
m_colorTargetImage = Image::createAndAlloc(m_vk, device, targetImageCreateInfo, m_context.getDefaultAllocator(), m_context.getUniversalQueueFamilyIndex());
const ImageViewCreateInfo colorTargetViewInfo(m_colorTargetImage->object(), vk::VK_IMAGE_VIEW_TYPE_2D, m_colorAttachmentFormat);
m_colorTargetView = vk::createImageView(m_vk, device, &colorTargetViewInfo);
RenderPassCreateInfo renderPassCreateInfo;
renderPassCreateInfo.addAttachment(AttachmentDescription(m_colorAttachmentFormat,
vk::VK_SAMPLE_COUNT_1_BIT,
vk::VK_ATTACHMENT_LOAD_OP_LOAD,
vk::VK_ATTACHMENT_STORE_OP_STORE,
vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE,
vk::VK_ATTACHMENT_STORE_OP_STORE,
vk::VK_IMAGE_LAYOUT_GENERAL,
vk::VK_IMAGE_LAYOUT_GENERAL));
const vk::VkAttachmentReference colorAttachmentReference =
{
0,
vk::VK_IMAGE_LAYOUT_GENERAL
};
renderPassCreateInfo.addSubpass(SubpassDescription(vk::VK_PIPELINE_BIND_POINT_GRAPHICS,
0,
0,
DE_NULL,
1,
&colorAttachmentReference,
DE_NULL,
AttachmentReference(),
0,
DE_NULL));
m_renderPass = vk::createRenderPass(m_vk, device, &renderPassCreateInfo);
std::vector<vk::VkImageView> colorAttachments(1);
colorAttachments[0] = *m_colorTargetView;
const FramebufferCreateInfo framebufferCreateInfo(*m_renderPass, colorAttachments, WIDTH, HEIGHT, 1);
m_framebuffer = vk::createFramebuffer(m_vk, device, &framebufferCreateInfo);
const vk::VkVertexInputBindingDescription vertexInputBindingDescription =
{
0,
sizeof(VertexElementData),
vk::VK_VERTEX_INPUT_RATE_VERTEX,
};
const vk::VkVertexInputAttributeDescription vertexInputAttributeDescriptions[] =
{
{
0u,
0u,
vk::VK_FORMAT_R32G32B32A32_SFLOAT,
0u
}, // VertexElementData::position
{
1u,
0u,
vk::VK_FORMAT_R32G32B32A32_SFLOAT,
static_cast<deUint32>(sizeof(tcu::Vec4))
}, // VertexElementData::color
{
2u,
0u,
vk::VK_FORMAT_R32_SINT,
static_cast<deUint32>(sizeof(tcu::Vec4)) * 2
} // VertexElementData::refVertexIndex
};
m_vertexInputState = PipelineCreateInfo::VertexInputState(1,
&vertexInputBindingDescription,
DE_LENGTH_OF_ARRAY(vertexInputAttributeDescriptions),
vertexInputAttributeDescriptions);
const vk::VkDeviceSize dataSize = m_data.size() * sizeof(VertexElementData);
m_vertexBuffer = Buffer::createAndAlloc(m_vk, device, BufferCreateInfo(dataSize,
vk::VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), m_context.getDefaultAllocator(), vk::MemoryRequirement::HostVisible);
deUint8* ptr = reinterpret_cast<deUint8*>(m_vertexBuffer->getBoundMemory().getHostPtr());
deMemcpy(ptr, &m_data[0], static_cast<size_t>(dataSize));
vk::flushMappedMemoryRange(m_vk,
device,
m_vertexBuffer->getBoundMemory().getMemory(),
m_vertexBuffer->getBoundMemory().getOffset(),
dataSize);
const CmdPoolCreateInfo cmdPoolCreateInfo(queueFamilyIndex);
m_cmdPool = vk::createCommandPool(m_vk, device, &cmdPoolCreateInfo);
m_cmdBuffer = vk::allocateCommandBuffer(m_vk, device, *m_cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY);
initPipeline(device);
}
void SparseShaderIntrinsicsInstanceSampledBase::recordCommands (const VkCommandBuffer commandBuffer,
const VkImageCreateInfo& imageSparseInfo,
const VkImage imageSparse,
const VkImage imageTexels,
const VkImage imageResidency)
{
const InstanceInterface& instance = m_context.getInstanceInterface();
const DeviceInterface& deviceInterface = getDeviceInterface();
const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
const VkPhysicalDeviceProperties deviceProperties = getPhysicalDeviceProperties(instance, physicalDevice);
if (imageSparseInfo.extent.width > deviceProperties.limits.maxFramebufferWidth ||
imageSparseInfo.extent.height > deviceProperties.limits.maxFramebufferHeight ||
imageSparseInfo.arrayLayers > deviceProperties.limits.maxFramebufferLayers)
{
TCU_THROW(NotSupportedError, "Image size exceeds allowed framebuffer dimensions");
}
// Check if device supports image format for sampled images
if (!checkImageFormatFeatureSupport(instance, physicalDevice, imageSparseInfo.format, VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT))
TCU_THROW(NotSupportedError, "Device does not support image format for sampled images");
// Check if device supports image format for color attachment
if (!checkImageFormatFeatureSupport(instance, physicalDevice, imageSparseInfo.format, VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT))
TCU_THROW(NotSupportedError, "Device does not support image format for color attachment");
// Make sure device supports VK_FORMAT_R32_UINT format for color attachment
if (!checkImageFormatFeatureSupport(instance, physicalDevice, mapTextureFormat(m_residencyFormat), VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT))
TCU_THROW(TestError, "Device does not support VK_FORMAT_R32_UINT format for color attachment");
// Create buffer storing vertex data
std::vector<tcu::Vec2> vertexData;
vertexData.push_back(tcu::Vec2(-1.0f,-1.0f));
vertexData.push_back(tcu::Vec2( 0.0f, 0.0f));
vertexData.push_back(tcu::Vec2(-1.0f, 1.0f));
vertexData.push_back(tcu::Vec2( 0.0f, 1.0f));
vertexData.push_back(tcu::Vec2( 1.0f,-1.0f));
vertexData.push_back(tcu::Vec2( 1.0f, 0.0f));
vertexData.push_back(tcu::Vec2( 1.0f, 1.0f));
vertexData.push_back(tcu::Vec2( 1.0f, 1.0f));
const VkDeviceSize vertexDataSizeInBytes = sizeInBytes(vertexData);
const VkBufferCreateInfo vertexBufferCreateInfo = makeBufferCreateInfo(vertexDataSizeInBytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
m_vertexBuffer = createBuffer(deviceInterface, getDevice(), &vertexBufferCreateInfo);
m_vertexBufferAlloc = bindBuffer(deviceInterface, getDevice(), getAllocator(), *m_vertexBuffer, MemoryRequirement::HostVisible);
deMemcpy(m_vertexBufferAlloc->getHostPtr(), &vertexData[0], static_cast<std::size_t>(vertexDataSizeInBytes));
flushMappedMemoryRange(deviceInterface, getDevice(), m_vertexBufferAlloc->getMemory(), m_vertexBufferAlloc->getOffset(), vertexDataSizeInBytes);
// Create render pass
const VkAttachmentDescription texelsAttachmentDescription =
{
(VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags;
imageSparseInfo.format, // VkFormat format;
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
};
const VkAttachmentDescription residencyAttachmentDescription =
{
(VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags;
mapTextureFormat(m_residencyFormat), // VkFormat format;
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
};
const VkAttachmentDescription colorAttachmentsDescription[] = { texelsAttachmentDescription, residencyAttachmentDescription };
const VkAttachmentReference texelsAttachmentReference =
{
0u, // deUint32 attachment;
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
};
const VkAttachmentReference residencyAttachmentReference =
{
1u, // deUint32 attachment;
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
};
const VkAttachmentReference colorAttachmentsReference[] = { texelsAttachmentReference, residencyAttachmentReference };
const VkAttachmentReference depthAttachmentReference =
{
VK_ATTACHMENT_UNUSED, // deUint32 attachment;
VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout layout;
};
const VkSubpassDescription subpassDescription =
{
(VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags;
VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
0u, // deUint32 inputAttachmentCount;
DE_NULL, // const VkAttachmentReference* pInputAttachments;
2u, // deUint32 colorAttachmentCount;
colorAttachmentsReference, // const VkAttachmentReference* pColorAttachments;
DE_NULL, // const VkAttachmentReference* pResolveAttachments;
&depthAttachmentReference, // const VkAttachmentReference* pDepthStencilAttachment;
0u, // deUint32 preserveAttachmentCount;
DE_NULL // const deUint32* pPreserveAttachments;
};
const VkRenderPassCreateInfo renderPassInfo =
{
VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags;
2u, // deUint32 attachmentCount;
colorAttachmentsDescription, // const VkAttachmentDescription* pAttachments;
1u, // deUint32 subpassCount;
&subpassDescription, // const VkSubpassDescription* pSubpasses;
0u, // deUint32 dependencyCount;
DE_NULL // const VkSubpassDependency* pDependencies;
};
m_renderPass = createRenderPass(deviceInterface, getDevice(), &renderPassInfo);
// Create descriptor set layout
DescriptorSetLayoutBuilder descriptorLayerBuilder;
descriptorLayerBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT);
const Unique<VkDescriptorSetLayout> descriptorSetLayout(descriptorLayerBuilder.build(deviceInterface, getDevice()));
// Create descriptor pool
DescriptorPoolBuilder descriptorPoolBuilder;
descriptorPoolBuilder.addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, imageSparseInfo.mipLevels);
descriptorPool = descriptorPoolBuilder.build(deviceInterface, getDevice(), VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, imageSparseInfo.mipLevels);
// Create sampler object
const tcu::Sampler samplerObject(tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, tcu::Sampler::NEAREST_MIPMAP_NEAREST, tcu::Sampler::NEAREST);
const VkSamplerCreateInfo samplerCreateInfo = mapSampler(samplerObject, m_format);
m_sampler = createSampler(deviceInterface, getDevice(), &samplerCreateInfo);
struct PushConstants
{
deUint32 lod;
deUint32 padding; // padding needed to satisfy std430 rules
float lodWidth;
float lodHeight;
};
// Create pipeline layout
const VkPushConstantRange lodConstantRange =
{
VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlags stageFlags;
0u, // deUint32 offset;
sizeof(PushConstants), // deUint32 size;
};
const VkPipelineLayoutCreateInfo pipelineLayoutParams =
{
VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkPipelineLayoutCreateFlags flags;
1u, // deUint32 setLayoutCount;
&descriptorSetLayout.get(), // const VkDescriptorSetLayout* pSetLayouts;
1u, // deUint32 pushConstantRangeCount;
&lodConstantRange, // const VkPushConstantRange* pPushConstantRanges;
};
const Unique<VkPipelineLayout> pipelineLayout(createPipelineLayout(deviceInterface, getDevice(), &pipelineLayoutParams));
// Create graphics pipeline
{
Move<VkShaderModule> vertexModule = createShaderModule(deviceInterface, getDevice(), m_context.getBinaryCollection().get("vertex_shader"), (VkShaderModuleCreateFlags)0);
Move<VkShaderModule> fragmentModule = createShaderModule(deviceInterface, getDevice(), m_context.getBinaryCollection().get("fragment_shader"), (VkShaderModuleCreateFlags)0);
Move<VkShaderModule> geometryModule;
if (imageSparseInfo.arrayLayers > 1u)
{
requireFeatures(instance, physicalDevice, FEATURE_GEOMETRY_SHADER);
geometryModule = createShaderModule(deviceInterface, getDevice(), m_context.getBinaryCollection().get("geometry_shader"), (VkShaderModuleCreateFlags)0);
}
pipelines.push_back(makeVkSharedPtr(makeGraphicsPipeline(
deviceInterface, getDevice(), *pipelineLayout, *m_renderPass, *vertexModule, *fragmentModule, *geometryModule)));
}
const VkPipeline graphicsPipeline = **pipelines[0];
{
const VkImageSubresourceRange fullImageSubresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers);
VkImageMemoryBarrier imageShaderAccessBarriers[3];
imageShaderAccessBarriers[0] = makeImageMemoryBarrier
(
VK_ACCESS_TRANSFER_WRITE_BIT,
VK_ACCESS_SHADER_READ_BIT,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
imageSparse,
fullImageSubresourceRange
);
imageShaderAccessBarriers[1] = makeImageMemoryBarrier
(
0u,
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
imageTexels,
fullImageSubresourceRange
);
imageShaderAccessBarriers[2] = makeImageMemoryBarrier
(
0u,
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
imageResidency,
fullImageSubresourceRange
);
deviceInterface.cmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 3u, imageShaderAccessBarriers);
}
imageSparseViews.resize(imageSparseInfo.mipLevels);
imageTexelsViews.resize(imageSparseInfo.mipLevels);
imageResidencyViews.resize(imageSparseInfo.mipLevels);
m_framebuffers.resize(imageSparseInfo.mipLevels);
descriptorSets.resize(imageSparseInfo.mipLevels);
std::vector<VkClearValue> clearValues;
clearValues.push_back(makeClearValueColor(tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f)));
clearValues.push_back(makeClearValueColor(tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f)));
for (deUint32 mipLevelNdx = 0u; mipLevelNdx < imageSparseInfo.mipLevels; ++mipLevelNdx)
{
const vk::VkExtent3D mipLevelSize = mipLevelExtents(imageSparseInfo.extent, mipLevelNdx);
const vk::VkRect2D renderArea = makeRect2D(mipLevelSize);
const VkViewport viewport = makeViewport(mipLevelSize);
const VkImageSubresourceRange mipLevelRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, mipLevelNdx, 1u, 0u, imageSparseInfo.arrayLayers);
// Create color attachments image views
imageTexelsViews[mipLevelNdx] = makeVkSharedPtr(makeImageView(deviceInterface, getDevice(), imageTexels, mapImageViewType(m_imageType), imageSparseInfo.format, mipLevelRange));
imageResidencyViews[mipLevelNdx] = makeVkSharedPtr(makeImageView(deviceInterface, getDevice(), imageResidency, mapImageViewType(m_imageType), mapTextureFormat(m_residencyFormat), mipLevelRange));
const VkImageView attachmentsViews[] = { **imageTexelsViews[mipLevelNdx], **imageResidencyViews[mipLevelNdx] };
// Create framebuffer
const VkFramebufferCreateInfo framebufferInfo =
{
VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkFramebufferCreateFlags)0, // VkFramebufferCreateFlags flags;
*m_renderPass, // VkRenderPass renderPass;
2u, // uint32_t attachmentCount;
attachmentsViews, // const VkImageView* pAttachments;
mipLevelSize.width, // uint32_t width;
mipLevelSize.height, // uint32_t height;
imageSparseInfo.arrayLayers, // uint32_t layers;
};
m_framebuffers[mipLevelNdx] = makeVkSharedPtr(createFramebuffer(deviceInterface, getDevice(), &framebufferInfo));
// Create descriptor set
descriptorSets[mipLevelNdx] = makeVkSharedPtr(makeDescriptorSet(deviceInterface, getDevice(), *descriptorPool, *descriptorSetLayout));
const VkDescriptorSet descriptorSet = **descriptorSets[mipLevelNdx];
// Update descriptor set
const VkImageSubresourceRange sparseImageSubresourceRange = sampledImageRangeToBind(imageSparseInfo, mipLevelNdx);
imageSparseViews[mipLevelNdx] = makeVkSharedPtr(makeImageView(deviceInterface, getDevice(), imageSparse, mapImageViewType(m_imageType), imageSparseInfo.format, sparseImageSubresourceRange));
const VkDescriptorImageInfo imageSparseDescInfo = makeDescriptorImageInfo(*m_sampler, **imageSparseViews[mipLevelNdx], VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
DescriptorSetUpdateBuilder descriptorUpdateBuilder;
descriptorUpdateBuilder.writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(BINDING_IMAGE_SPARSE), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &imageSparseDescInfo);
descriptorUpdateBuilder.update(deviceInterface, getDevice());
// Begin render pass
beginRenderPass(deviceInterface, commandBuffer, *m_renderPass, **m_framebuffers[mipLevelNdx], renderArea, (deUint32)clearValues.size(), &clearValues[0]);
// Bind graphics pipeline
deviceInterface.cmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline);
// Bind descriptor set
deviceInterface.cmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet, 0u, DE_NULL);
// Bind vertex buffer
{
const VkDeviceSize offset = 0ull;
deviceInterface.cmdBindVertexBuffers(commandBuffer, 0u, 1u, &m_vertexBuffer.get(), &offset);
}
// Bind Viewport
deviceInterface.cmdSetViewport(commandBuffer, 0u, 1u, &viewport);
// Bind Scissor Rectangle
deviceInterface.cmdSetScissor(commandBuffer, 0u, 1u, &renderArea);
const PushConstants pushConstants =
{
mipLevelNdx,
0u, // padding
static_cast<float>(mipLevelSize.width),
static_cast<float>(mipLevelSize.height)
};
// Update push constants
deviceInterface.cmdPushConstants(commandBuffer, *pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0u, sizeof(PushConstants), &pushConstants);
// Draw full screen quad
deviceInterface.cmdDraw(commandBuffer, 4u, 1u, 0u, 0u);
// End render pass
endRenderPass(deviceInterface, commandBuffer);
}
{
const VkImageSubresourceRange fullImageSubresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers);
VkImageMemoryBarrier imageOutputTransferSrcBarriers[2];
imageOutputTransferSrcBarriers[0] = makeImageMemoryBarrier
(
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
VK_ACCESS_TRANSFER_READ_BIT,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
imageTexels,
fullImageSubresourceRange
);
imageOutputTransferSrcBarriers[1] = makeImageMemoryBarrier
(
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
VK_ACCESS_TRANSFER_READ_BIT,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
imageResidency,
fullImageSubresourceRange
);
deviceInterface.cmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 2u, imageOutputTransferSrcBarriers);
}
}
void DataBlock::setData (size_t size, const void* data)
{
m_data = std::vector<deUint8>(size);
deMemcpy(&(m_data[0]), data, (int)size);
}
GLW_APICALL void GLW_APIENTRY glGetIntegerv (GLenum pname, GLint* params)
{
Context* const ctx = getCurrentContext();
switch (pname)
{
case GL_NUM_EXTENSIONS:
*params = (int)ctx->extensionList.size();
break;
case GL_MAX_VERTEX_ATTRIBS:
*params = 32;
break;
case GL_MAX_DRAW_BUFFERS:
case GL_MAX_COLOR_ATTACHMENTS:
*params = 8;
break;
case GL_MAX_TEXTURE_IMAGE_UNITS:
case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
case GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS:
case GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS:
case GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS:
*params = 32;
break;
case GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS:
case GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS:
case GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS:
case GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS:
case GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS:
case GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS:
*params = 8;
break;
case GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS:
case GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS:
case GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS:
case GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS:
case GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS:
case GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS:
*params = 8;
break;
case GL_MAX_SHADER_STORAGE_BLOCK_SIZE:
*params = 1u << 25;
break;
case GL_MAX_GEOMETRY_OUTPUT_VERTICES:
*params = 256;
break;
case GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:
*params = 2048;
break;
case GL_MAX_GEOMETRY_SHADER_INVOCATIONS:
*params = 4;
break;
case GL_MAX_COLOR_TEXTURE_SAMPLES:
*params = 8;
break;
case GL_MAX_TEXTURE_SIZE:
case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
case GL_MAX_3D_TEXTURE_SIZE:
case GL_MAX_RENDERBUFFER_SIZE:
case GL_MAX_TEXTURE_BUFFER_SIZE:
*params = 2048;
break;
case GL_MAX_ARRAY_TEXTURE_LAYERS:
*params = 128;
break;
case GL_NUM_SHADER_BINARY_FORMATS:
*params = 0;
break;
case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
*params = (int)ctx->compressedTextureList.size();
break;
case GL_COMPRESSED_TEXTURE_FORMATS:
deMemcpy(params, &ctx->compressedTextureList[0], ctx->compressedTextureList.size()*sizeof(deUint32));
break;
case GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
*params = 16;
break;
case GL_MAX_UNIFORM_BUFFER_BINDINGS:
*params = 32;
break;
case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
*params = 16;
break;
case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
*params = GL_RGBA;
break;
case GL_IMPLEMENTATION_COLOR_READ_TYPE:
*params = GL_UNSIGNED_BYTE;
break;
case GL_SAMPLE_BUFFERS:
*params = 0;
break;
default:
break;
}
}
