liblog \
libm \
libc \
- libpng \
libz \
libdl
+LOCAL_STATIC_LIBRARIES := \
+ libpng_ndk \
+
LOCAL_CFLAGS += \
$(deqp_compile_flags) \
- -Wno-date-time
+ -Wno-error=date-time
LOCAL_SDK_VERSION := 9
LOCAL_CPPFLAGS += -Wno-non-virtual-dtor
}
// Construct command line.
- string cmdLine = de::FilePath(name).isAbsolutePath() ? name : de::FilePath::join(workingDir, name).normalize().getPath();
+ string cmdLine = de::FilePath(name).isAbsolutePath() ? name : de::FilePath::join(workingDir, name).getPath();
cmdLine += string(" --deqp-log-filename=") + logFilePath.getBaseName();
if (hasCaseList)
self.postExtract(dstPath)
class GitRepo (Source):
- def __init__(self, url, revision, baseDir, extractDir = "src", postCheckout = None):
+ def __init__(self, url, revision, baseDir, extractDir = "src"):
Source.__init__(self, baseDir, extractDir)
- self.url = url
- self.revision = revision
- self.postCheckout = postCheckout
+ self.url = url
+ self.revision = revision
def update (self):
fullDstPath = os.path.join(EXTERNAL_DIR, self.baseDir, self.extractDir)
try:
execute(["git", "fetch", self.url, "+refs/heads/*:refs/remotes/origin/*"])
execute(["git", "checkout", self.revision])
-
- if self.postCheckout:
- self.postCheckout(fullDstPath)
finally:
popWorkingDir()
shutil.copy(os.path.join(path, "scripts", "pnglibconf.h.prebuilt"),
os.path.join(path, "pnglibconf.h"))
-def postCheckoutGlslang (path):
- srcPath = os.path.join(path, "SPIRV", "SpvBuilder.cpp");
- origSrc = readFile(srcPath)
- patched = origSrc.replace("exit(1)", "throw std::runtime_error(fun)")
- writeFile(srcPath, patched)
-
PACKAGES = [
SourcePackage(
"http://zlib.net/zlib-1.2.8.tar.gz",
"spirv-tools"),
GitRepo(
"git@gitlab.khronos.org:GLSL/glslang.git",
- "41daec718f4868d956ca7d339a15aebe65879442",
- "glslang",
- postCheckout = postCheckoutGlslang),
+ "cafd6cc2f1b9987a0948c1653363f2e76a5fa6b1",
+ "glslang"),
]
def parseArgs ():
--- /dev/null
+# -*- coding: utf-8 -*-
+
+#-------------------------------------------------------------------------
+# Vulkan CTS
+# ----------
+#
+# Copyright (c) 2016 Google Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and/or associated documentation files (the
+# "Materials"), to deal in the Materials without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Materials, and to
+# permit persons to whom the Materials are furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice(s) and this permission notice shall be
+# included in all copies or substantial portions of the Materials.
+#
+# The Materials are Confidential Information as defined by the
+# Khronos Membership Agreement until designated non-confidential by
+# Khronos, at which point this condition clause shall be removed.
+#
+# THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+#
+#-------------------------------------------------------------------------
+
+import os
+import sys
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", "..", "scripts"))
+
+from build.common import DEQP_DIR
+from build.config import ANY_GENERATOR
+from build_caselists import Module, getModuleByName, getBuildConfig, DEFAULT_BUILD_DIR, DEFAULT_TARGET
+from mustpass import Project, Package, Mustpass, Configuration, include, exclude, genMustpassLists
+
+COPYRIGHT_DECLARATION = """
+ Permission is hereby granted, free of charge, to any person obtaining a
+ copy of this software and/or associated documentation files (the
+ "Materials"), to deal in the Materials without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Materials, and to
+ permit persons to whom the Materials are furnished to do so, subject to
+ the following conditions:
+
+ The above copyright notice(s) and this permission notice shall be
+ included in all copies or substantial portions of the Materials.
+
+ The Materials are Confidential Information as defined by the
+ Khronos Membership Agreement until designated non-confidential by
+ Khronos, at which point this condition clause shall be removed.
+
+ THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ """
+
+MUSTPASS_PATH = os.path.join(DEQP_DIR, "external", "vulkancts", "mustpass")
+PROJECT = Project(path = MUSTPASS_PATH, copyright = COPYRIGHT_DECLARATION)
+VULKAN_MODULE = getModuleByName("dEQP-VK")
+BUILD_CONFIG = getBuildConfig(DEFAULT_BUILD_DIR, DEFAULT_TARGET, "Debug")
+
+# 1.0.0
+
+VULKAN_1_0_0_PKG = Package(module = VULKAN_MODULE, configurations = [
+ # Master
+ Configuration(name = "default",
+ filters = [include("master.txt"),
+ exclude("test-issues.txt"),
+ exclude("excluded-tests.txt")]),
+ ])
+
+MUSTPASS_LISTS = [
+ Mustpass(project = PROJECT, version = "1.0.0", packages = [VULKAN_1_0_0_PKG])
+ ]
+
+if __name__ == "__main__":
+ genMustpassLists(MUSTPASS_LISTS, ANY_GENERATOR, BUILD_CONFIG)
fragment ""
#version 310 es
precision mediump float;
- in mediump float var;
+ layout(location = 0) in mediump float var;
${FRAGMENT_DECLARATIONS}
void main()
{
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out mediump float var;
+ layout(location = 0) out mediump float var;
void main()
{
${VERTEX_OUTPUT}
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out mediump float var;
+ layout(location = 0) out mediump float var;
void main()
{
${VERTEX_OUTPUT}
""
fragment ""
#version 310 es
- in mediump float var;
+ layout(location = 0) in mediump float var;
${FRAGMENT_DECLARATIONS}
void main()
{
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out mediump float var;
+ layout(location = 0) out mediump float var;
void main()
{
${VERTEX_OUTPUT}
""
fragment ""
#version 310 es
- in mediump float var;
+ layout(location = 0) in mediump float var;
${FRAGMENT_DECLARATIONS}
void main()
{
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out mediump float var;
+ layout(location = 0) out mediump float var;
void main()
{
if (u_false)
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out mediump float var;
+ layout(location = 0) out mediump float var;
void main()
{
if (u_false)
""
fragment ""
#version 310 es
- in mediump float var;
+ layout(location = 0) in mediump float var;
${FRAGMENT_DECLARATIONS}
void main()
{
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out mediump float var;
+ layout(location = 0) out mediump float var;
void main()
{
if (u_false)
fragment ""
#version 310 es
${FRAGMENT_DECLARATIONS}
- in mediump float var;
+ layout(location = 0) in mediump float var;
void main()
{
if (u_false)
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out highp float var;
+ layout(location = 0) out highp float var;
void main()
{
var = in0;
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- in mediump float var;
+ layout(location = 0) in mediump float var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out highp vec2 var;
+ layout(location = 0) out highp vec2 var;
void main()
{
var = vec2(in0, 2.0*in0);
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- in lowp vec2 var;
+ layout(location = 0) in lowp vec2 var;
void main()
{
out0 = var.y - var.x;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out lowp vec4 var;
+ layout(location = 0) out lowp vec4 var;
void main()
{
var = vec4(in0, 2.0*in0, -in0, -in0);
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- in mediump vec4 var;
+ layout(location = 0) in mediump vec4 var;
void main()
{
out0 = var.x + var.y + var.z + var.w;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- smooth out mediump float var;
+ layout(location = 0) smooth out mediump float var;
void main()
{
var = in0;
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- centroid in mediump float var;
+ layout(location = 0) centroid in mediump float var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out mediump float var;
+ layout(location = 0) out mediump float var;
void main()
{
var = in0;
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- in float var;
+ layout(location = 0) in float var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out mediump vec2 var;
+ layout(location = 0) out mediump vec2 var;
void main()
{
var = in0;
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- in vec2 var;
+ layout(location = 0) in vec2 var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out mediump vec3 var;
+ layout(location = 0) out mediump vec3 var;
void main()
{
var = in0;
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- in vec3 var;
+ layout(location = 0) in vec3 var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out mediump vec4 var;
+ layout(location = 0) out mediump vec4 var;
void main()
{
var = in0;
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- in vec4 var;
+ layout(location = 0) in vec4 var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out mediump mat2 var;
+ layout(location = 0) out mediump mat2 var;
void main()
{
var = in0;
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- in mat2 var;
+ layout(location = 0) in mat2 var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out mediump mat2x3 var;
+ layout(location = 0) out mediump mat2x3 var;
void main()
{
var = in0;
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- in mat2x3 var;
+ layout(location = 0) in mat2x3 var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out mediump mat2x4 var;
+ layout(location = 0) out mediump mat2x4 var;
void main()
{
var = in0;
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- in mat2x4 var;
+ layout(location = 0) in mat2x4 var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out mediump mat3x2 var;
+ layout(location = 0) out mediump mat3x2 var;
void main()
{
var = in0;
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- in mat3x2 var;
+ layout(location = 0) in mat3x2 var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out mediump mat3 var;
+ layout(location = 0) out mediump mat3 var;
void main()
{
var = in0;
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- in mat3 var;
+ layout(location = 0) in mat3 var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out mediump mat3x4 var;
+ layout(location = 0) out mediump mat3x4 var;
void main()
{
var = in0;
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- in mat3x4 var;
+ layout(location = 0) in mat3x4 var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out mediump mat4x2 var;
+ layout(location = 0) out mediump mat4x2 var;
void main()
{
var = in0;
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- in mat4x2 var;
+ layout(location = 0) in mat4x2 var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out mediump mat4x3 var;
+ layout(location = 0) out mediump mat4x3 var;
void main()
{
var = in0;
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- in mat4x3 var;
+ layout(location = 0) in mat4x3 var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- out mediump mat4 var;
+ layout(location = 0) out mediump mat4 var;
void main()
{
var = in0;
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- in mat4 var;
+ layout(location = 0) in mat4 var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- flat out mediump int var;
+ layout(location = 0) flat out mediump int var;
void main()
{
${VERTEX_SETUP}
fragment ""
#version 310 es
${FRAGMENT_DECLARATIONS}
- flat in int var;
+ layout(location = 0) flat in int var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- flat out mediump ivec2 var;
+ layout(location = 0) flat out mediump ivec2 var;
void main()
{
${VERTEX_SETUP}
fragment ""
#version 310 es
${FRAGMENT_DECLARATIONS}
- flat in ivec2 var;
+ layout(location = 0) flat in ivec2 var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- flat out mediump ivec3 var;
+ layout(location = 0) flat out mediump ivec3 var;
void main()
{
${VERTEX_SETUP}
fragment ""
#version 310 es
${FRAGMENT_DECLARATIONS}
- flat in ivec3 var;
+ layout(location = 0) flat in ivec3 var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- flat out mediump ivec4 var;
+ layout(location = 0) flat out mediump ivec4 var;
void main()
{
${VERTEX_SETUP}
fragment ""
#version 310 es
${FRAGMENT_DECLARATIONS}
- flat in ivec4 var;
+ layout(location = 0) flat in ivec4 var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- flat out mediump uint var;
+ layout(location = 0) flat out mediump uint var;
void main()
{
${VERTEX_SETUP}
fragment ""
#version 310 es
${FRAGMENT_DECLARATIONS}
- flat in uint var;
+ layout(location = 0) flat in uint var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- flat out mediump uvec2 var;
+ layout(location = 0) flat out mediump uvec2 var;
void main()
{
${VERTEX_SETUP}
fragment ""
#version 310 es
${FRAGMENT_DECLARATIONS}
- flat in uvec2 var;
+ layout(location = 0) flat in uvec2 var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- flat out mediump uvec3 var;
+ layout(location = 0) flat out mediump uvec3 var;
void main()
{
${VERTEX_SETUP}
fragment ""
#version 310 es
${FRAGMENT_DECLARATIONS}
- flat in uvec3 var;
+ layout(location = 0) flat in uvec3 var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- flat out mediump uvec4 var;
+ layout(location = 0) flat out mediump uvec4 var;
void main()
{
${VERTEX_SETUP}
fragment ""
#version 310 es
${FRAGMENT_DECLARATIONS}
- flat in uvec4 var;
+ layout(location = 0) flat in uvec4 var;
void main()
{
out0 = var;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump float a; };
- out S var;
+ layout(location = 0) out S var;
void main()
{
var.a = in0;
precision mediump float;
${FRAGMENT_DECLARATIONS}
struct S { mediump float a; };
- in S var;
+ layout(location = 0) in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump vec2 a; };
- out S var;
+ layout(location = 0) out S var;
void main()
{
var.a = in0;
precision mediump float;
${FRAGMENT_DECLARATIONS}
struct S { mediump vec2 a; };
- in S var;
+ layout(location = 0) in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump vec3 a; };
- out S var;
+ layout(location = 0) out S var;
void main()
{
var.a = in0;
precision mediump float;
${FRAGMENT_DECLARATIONS}
struct S { mediump vec3 a; };
- in S var;
+ layout(location = 0) in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump vec4 a; };
- out S var;
+ layout(location = 0) out S var;
void main()
{
var.a = in0;
precision mediump float;
${FRAGMENT_DECLARATIONS}
struct S { mediump vec4 a; };
- in S var;
+ layout(location = 0) in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump mat2 a; };
- out S var;
+ layout(location = 0) out S var;
void main()
{
var.a = in0;
precision mediump float;
${FRAGMENT_DECLARATIONS}
struct S { mediump mat2 a; };
- in S var;
+ layout(location = 0) in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump mat2x3 a; };
- out S var;
+ layout(location = 0) out S var;
void main()
{
var.a = in0;
precision mediump float;
${FRAGMENT_DECLARATIONS}
struct S { mediump mat2x3 a; };
- in S var;
+ layout(location = 0) in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump mat2x4 a; };
- out S var;
+ layout(location = 0) out S var;
void main()
{
var.a = in0;
precision mediump float;
${FRAGMENT_DECLARATIONS}
struct S { mediump mat2x4 a; };
- in S var;
+ layout(location = 0) in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump mat3x2 a; };
- out S var;
+ layout(location = 0) out S var;
void main()
{
var.a = in0;
precision mediump float;
${FRAGMENT_DECLARATIONS}
struct S { mediump mat3x2 a; };
- in S var;
+ layout(location = 0) in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump mat3 a; };
- out S var;
+ layout(location = 0) out S var;
void main()
{
var.a = in0;
precision mediump float;
${FRAGMENT_DECLARATIONS}
struct S { mediump mat3 a; };
- in S var;
+ layout(location = 0) in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump mat3x4 a; };
- out S var;
+ layout(location = 0) out S var;
void main()
{
var.a = in0;
precision mediump float;
${FRAGMENT_DECLARATIONS}
struct S { mediump mat3x4 a; };
- in S var;
+ layout(location = 0) in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump mat4x2 a; };
- out S var;
+ layout(location = 0) out S var;
void main()
{
var.a = in0;
precision mediump float;
${FRAGMENT_DECLARATIONS}
struct S { mediump mat4x2 a; };
- in S var;
+ layout(location = 0) in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump mat4x3 a; };
- out S var;
+ layout(location = 0) out S var;
void main()
{
var.a = in0;
precision mediump float;
${FRAGMENT_DECLARATIONS}
struct S { mediump mat4x3 a; };
- in S var;
+ layout(location = 0) in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump mat4 a; };
- out S var;
+ layout(location = 0) out S var;
void main()
{
var.a = in0;
precision mediump float;
${FRAGMENT_DECLARATIONS}
struct S { mediump mat4 a; };
- in S var;
+ layout(location = 0) in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump int a; };
- flat out S var;
+ layout(location = 0) flat out S var;
void main()
{
${VERTEX_SETUP}
#version 310 es
${FRAGMENT_DECLARATIONS}
struct S { mediump int a; };
- flat in S var;
+ layout(location = 0) flat in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump ivec2 a; };
- flat out S var;
+ layout(location = 0) flat out S var;
void main()
{
${VERTEX_SETUP}
#version 310 es
${FRAGMENT_DECLARATIONS}
struct S { mediump ivec2 a; };
- flat in S var;
+ layout(location = 0) flat in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump ivec3 a; };
- flat out S var;
+ layout(location = 0) flat out S var;
void main()
{
${VERTEX_SETUP}
#version 310 es
${FRAGMENT_DECLARATIONS}
struct S { mediump ivec3 a; };
- flat in S var;
+ layout(location = 0) flat in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump ivec4 a; };
- flat out S var;
+ layout(location = 0) flat out S var;
void main()
{
${VERTEX_SETUP}
#version 310 es
${FRAGMENT_DECLARATIONS}
struct S { mediump ivec4 a; };
- flat in S var;
+ layout(location = 0) flat in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump uint a; };
- flat out S var;
+ layout(location = 0) flat out S var;
void main()
{
${VERTEX_SETUP}
#version 310 es
${FRAGMENT_DECLARATIONS}
struct S { mediump uint a; };
- flat in S var;
+ layout(location = 0) flat in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump uvec2 a; };
- flat out S var;
+ layout(location = 0) flat out S var;
void main()
{
${VERTEX_SETUP}
#version 310 es
${FRAGMENT_DECLARATIONS}
struct S { mediump uvec2 a; };
- flat in S var;
+ layout(location = 0) flat in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump uvec3 a; };
- flat out S var;
+ layout(location = 0) flat out S var;
void main()
{
${VERTEX_SETUP}
#version 310 es
${FRAGMENT_DECLARATIONS}
struct S { mediump uvec3 a; };
- flat in S var;
+ layout(location = 0) flat in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump uvec4 a; };
- flat out S var;
+ layout(location = 0) flat out S var;
void main()
{
${VERTEX_SETUP}
#version 310 es
${FRAGMENT_DECLARATIONS}
struct S { mediump uvec4 a; };
- flat in S var;
+ layout(location = 0) flat in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump float a; highp vec3 b; };
- out S var;
+ layout(location = 0) out S var;
void main()
{
var.a = in0;
precision mediump float;
${FRAGMENT_DECLARATIONS}
struct S { mediump float a; highp vec3 b; };
- in S var;
+ layout(location = 0) in S var;
void main()
{
out0 = var.a;
#version 310 es
${VERTEX_DECLARATIONS}
struct S { mediump float a; highp uvec2 b; highp vec3 c; };
- flat out S var;
+ layout(location = 0) flat out S var;
void main()
{
${VERTEX_SETUP}
precision mediump float;
${FRAGMENT_DECLARATIONS}
struct S { mediump float a; highp uvec2 b; highp vec3 c; };
- flat in S var;
+ layout(location = 0) flat in S var;
void main()
{
out0 = var.a;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- smooth out mediump vec4 var;
+ layout(location = 0) smooth out mediump vec4 var;
void main()
{
var = in0;
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- smooth in vec4 var;
+ layout(location = 0) smooth in vec4 var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- centroid out mediump vec4 var;
+ layout(location = 0) centroid out mediump vec4 var;
void main()
{
var = in0;
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- centroid in vec4 var;
+ layout(location = 0) centroid in vec4 var;
void main()
{
out0 = var;
vertex ""
#version 310 es
${VERTEX_DECLARATIONS}
- flat out mediump vec4 var;
+ layout(location = 0) flat out mediump vec4 var;
void main()
{
var = in0;
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- flat in vec4 var;
+ layout(location = 0) flat in vec4 var;
void main()
{
out0 = var;
#version 310 es
precision mediump float;
${VERTEX_DECLARATIONS}
- out float var1;
- out float var2;
+ layout(location = 0) out float var1;
+ layout(location = 1) out float var2;
void main()
{
#version 310 es
precision mediump float;
${FRAGMENT_DECLARATIONS}
- in float var1;
- in float var2;
+ layout(location = 0) in float var1;
+ layout(location = 1) in float var2;
void main()
{
size_t* const totalAllocSizePtr = &results->internalAllocationTotal[record.data.internalAllocation.type][record.data.internalAllocation.scope];
const size_t size = record.data.internalAllocation.size;
- if (record.type == AllocationCallbackRecord::TYPE_FREE)
+ if (record.type == AllocationCallbackRecord::TYPE_INTERNAL_FREE)
{
if (*totalAllocSizePtr < size)
{
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-enum { VK_API_VERSION = VK_MAKE_VERSION(0, 210, 1) };
-enum { VK_MAX_PHYSICAL_DEVICE_NAME_SIZE = 256 };
-enum { VK_MAX_EXTENSION_NAME_SIZE = 256 };
-enum { VK_UUID_SIZE = 16 };
-enum { VK_MAX_MEMORY_TYPES = 32 };
-enum { VK_MAX_MEMORY_HEAPS = 16 };
-enum { VK_MAX_DESCRIPTION_SIZE = 256 };
-enum { VK_ATTACHMENT_UNUSED = (~0U) };
+enum { VK_API_VERSION = VK_MAKE_VERSION(1, 0, 0) };
+enum { VK_MAX_PHYSICAL_DEVICE_NAME_SIZE = 256 };
+enum { VK_MAX_EXTENSION_NAME_SIZE = 256 };
+enum { VK_UUID_SIZE = 16 };
+enum { VK_MAX_MEMORY_TYPES = 32 };
+enum { VK_MAX_MEMORY_HEAPS = 16 };
+enum { VK_MAX_DESCRIPTION_SIZE = 256 };
+enum { VK_ATTACHMENT_UNUSED = (~0U) };
VK_DEFINE_HANDLE (VkInstance, HANDLE_TYPE_INSTANCE);
VK_DEFINE_HANDLE (VkPhysicalDevice, HANDLE_TYPE_PHYSICAL_DEVICE);
VK_DEFINE_NON_DISPATCHABLE_HANDLE (VkDisplayKHR, HANDLE_TYPE_DISPLAY_KHR);
VK_DEFINE_NON_DISPATCHABLE_HANDLE (VkDisplayModeKHR, HANDLE_TYPE_DISPLAY_MODE_KHR);
+enum VkPipelineCacheHeaderVersion
+{
+ VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
+};
+
enum VkResult
{
VK_SUCCESS = 0,
VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000008000,
+ VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
};
enum VkStructureType
VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
- VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 41,
- VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 42,
- VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 43,
- VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 44,
- VK_STRUCTURE_TYPE_MEMORY_BARRIER = 45,
- VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 46,
- VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 47,
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
+ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
+ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
+ VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
+ VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
+ VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
+ VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
+ VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
+ VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
+ VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
+ VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
+ VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
+ VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = 1000011000,
};
enum VkSystemAllocationScope
enum VkSamplerMipmapMode
{
- VK_SAMPLER_MIPMAP_MODE_BASE = 0,
- VK_SAMPLER_MIPMAP_MODE_NEAREST = 1,
- VK_SAMPLER_MIPMAP_MODE_LINEAR = 2,
+ VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
+ VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
VK_SAMPLER_MIPMAP_MODE_LAST
};
};
typedef deUint32 VkMemoryHeapFlags;
+enum VkPipelineStageFlagBits
+{
+ VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
+ VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
+ VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
+ VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
+ VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,
+ VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,
+ VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
+ VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
+ VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
+ VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
+ VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
+ VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
+ VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
+ VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,
+ VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
+ VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
+ VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
+};
+typedef deUint32 VkPipelineStageFlags;
+
enum VkImageAspectFlagBits
{
VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
enum VkQueryResultFlagBits
{
- VK_QUERY_RESULT_DEFAULT = 0,
VK_QUERY_RESULT_64_BIT = 0x00000001,
VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
};
typedef deUint32 VkAttachmentDescriptionFlags;
-enum VkPipelineStageFlagBits
-{
- VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
- VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
- VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
- VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
- VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,
- VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,
- VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
- VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
- VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
- VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
- VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
- VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
- VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
- VK_PIPELINE_STAGE_HOST_BIT = 0x00002000,
- VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00004000,
- VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00008000,
-};
-typedef deUint32 VkPipelineStageFlags;
-
enum VkAccessFlagBits
{
VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
enum VkStencilFaceFlagBits
{
- VK_STENCIL_FACE_NONE = 0,
VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
VK_STENCIL_FACE_BACK_BIT = 0x00000002,
VK_STENCIL_FRONT_AND_BACK = 0x3,
enum VkSurfaceTransformFlagBitsKHR
{
- VK_SURFACE_TRANSFORM_NONE_BIT_KHR = 0x00000001,
+ VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001,
VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002,
VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004,
VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008,
typedef deUint32 VkPipelineInputAssemblyStateCreateFlags;
-typedef deUint32 VkPipelineTesselationStateCreateFlags;
+typedef deUint32 VkPipelineTessellationStateCreateFlags;
typedef deUint32 VkPipelineViewportStateCreateFlags;
typedef deUint32 VkDisplaySurfaceCreateFlagsKHR;
+typedef deUint32 VkXlibSurfaceCreateFlagsKHR;
+
+typedef deUint32 VkXcbSurfaceCreateFlagsKHR;
+
+typedef deUint32 VkWaylandSurfaceCreateFlagsKHR;
+
+typedef deUint32 VkMirSurfaceCreateFlagsKHR;
+
+typedef deUint32 VkAndroidSurfaceCreateFlagsKHR;
+
+typedef deUint32 VkWin32SurfaceCreateFlagsKHR;
+
VkShaderStageFlags stageFlags,
const VkSampler* pImmutableSamplers)
{
+ if (pImmutableSamplers)
+ {
+ const ImmutableSamplerInfo immutableSamplerInfo =
+ {
+ (deUint32)m_bindings.size(),
+ (deUint32)m_immutableSamplers.size()
+ };
+
+ m_immutableSamplerInfos.push_back(immutableSamplerInfo);
+
+ for (size_t descriptorNdx = 0; descriptorNdx < descriptorCount; descriptorNdx++)
+ m_immutableSamplers.push_back(pImmutableSamplers[descriptorNdx]);
+ }
+
+ // pImmutableSamplers will be updated at build time
const VkDescriptorSetLayoutBinding binding =
{
(deUint32)m_bindings.size(), // binding
descriptorType, // descriptorType
descriptorCount, // descriptorCount
stageFlags, // stageFlags
- pImmutableSamplers, // pImmutableSamplers
+ DE_NULL, // pImmutableSamplers
};
m_bindings.push_back(binding);
return *this;
Move<VkDescriptorSetLayout> DescriptorSetLayoutBuilder::build (const DeviceInterface& vk, VkDevice device) const
{
- const VkDescriptorSetLayoutBinding* const bindingPtr = (m_bindings.empty()) ? (DE_NULL) : (&m_bindings[0]);
+ // Create new layout bindings with pImmutableSamplers updated
+ std::vector<VkDescriptorSetLayoutBinding> bindings = m_bindings;
+
+ for (size_t samplerInfoNdx = 0; samplerInfoNdx < m_immutableSamplerInfos.size(); samplerInfoNdx++)
+ {
+ const ImmutableSamplerInfo& samplerInfo = m_immutableSamplerInfos[samplerInfoNdx];
+
+ bindings[samplerInfo.bindingIndex].pImmutableSamplers = &m_immutableSamplers[samplerInfo.samplerBaseIndex];
+ }
+
const VkDescriptorSetLayoutCreateInfo createInfo =
{
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
DE_NULL,
- (VkDescriptorSetLayoutCreateFlags)0, // flags
- (deUint32)m_bindings.size(), // bindingCount
- bindingPtr, // pBinding
+ (VkDescriptorSetLayoutCreateFlags)0, // flags
+ (deUint32)bindings.size(), // bindingCount
+ (bindings.empty()) ? (DE_NULL) : (bindings.data()), // pBinding
};
return createDescriptorSetLayout(vk, device, &createInfo);
const VkDescriptorBufferInfo* pBufferInfo,
const VkBufferView* pTexelBufferView)
{
+ // pImageInfo, pBufferInfo and pTexelBufferView will be updated when calling update()
const VkWriteDescriptorSet writeParams =
{
VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
destArrayElement, //!< destArrayElement
count, //!< count
descriptorType, //!< descriptorType
- pImageInfo,
- pBufferInfo,
- pTexelBufferView
+ DE_NULL,
+ DE_NULL,
+ DE_NULL
};
+
m_writes.push_back(writeParams);
+
+ // Store a copy of pImageInfo, pBufferInfo and pTexelBufferView
+ WriteDescriptorInfo writeInfo;
+
+ if (pImageInfo)
+ writeInfo.imageInfos.insert(writeInfo.imageInfos.end(), pImageInfo, pImageInfo + count);
+
+ if (pBufferInfo)
+ writeInfo.bufferInfos.insert(writeInfo.bufferInfos.end(), pBufferInfo, pBufferInfo + count);
+
+ if (pTexelBufferView)
+ writeInfo.texelBufferViews.insert(writeInfo.texelBufferViews.end(), pTexelBufferView, pTexelBufferView + count);
+
+ m_writeDescriptorInfos.push_back(writeInfo);
+
return *this;
}
void DescriptorSetUpdateBuilder::update (const DeviceInterface& vk, VkDevice device) const
{
- const VkWriteDescriptorSet* const writePtr = (m_writes.empty()) ? (DE_NULL) : (&m_writes[0]);
+ // Update VkWriteDescriptorSet structures with stored info
+ std::vector<VkWriteDescriptorSet> writes = m_writes;
+
+ for (size_t writeNdx = 0; writeNdx < m_writes.size(); writeNdx++)
+ {
+ const WriteDescriptorInfo& writeInfo = m_writeDescriptorInfos[writeNdx];
+
+ if (!writeInfo.imageInfos.empty())
+ writes[writeNdx].pImageInfo = &writeInfo.imageInfos[0];
+
+ if (!writeInfo.bufferInfos.empty())
+ writes[writeNdx].pBufferInfo = &writeInfo.bufferInfos[0];
+
+ if (!writeInfo.texelBufferViews.empty())
+ writes[writeNdx].pTexelBufferView = &writeInfo.texelBufferViews[0];
+ }
+
+ const VkWriteDescriptorSet* const writePtr = (m_writes.empty()) ? (DE_NULL) : (&writes[0]);
const VkCopyDescriptorSet* const copyPtr = (m_copies.empty()) ? (DE_NULL) : (&m_copies[0]);
- vk.updateDescriptorSets(device, (deUint32)m_writes.size(), writePtr, (deUint32)m_copies.size(), copyPtr);
+ vk.updateDescriptorSets(device, (deUint32)writes.size(), writePtr, (deUint32)m_copies.size(), copyPtr);
}
} // vk
DescriptorSetLayoutBuilder& operator= (const DescriptorSetLayoutBuilder&); // delete
std::vector<VkDescriptorSetLayoutBinding> m_bindings;
+
+ struct ImmutableSamplerInfo
+ {
+ deUint32 bindingIndex;
+ deUint32 samplerBaseIndex;
+ };
+
+ std::vector<ImmutableSamplerInfo> m_immutableSamplerInfos;
+ std::vector<VkSampler> m_immutableSamplers;
};
class DescriptorPoolBuilder
DescriptorSetUpdateBuilder (const DescriptorSetUpdateBuilder&); // delete
DescriptorSetUpdateBuilder& operator= (const DescriptorSetUpdateBuilder&); // delete
- std::vector<VkDescriptorImageInfo> m_imageInfos;
- std::vector<VkDescriptorBufferInfo> m_bufferInfos;
- std::vector<VkBufferView> m_texelBufferViews;
+ struct WriteDescriptorInfo
+ {
+ std::vector<VkDescriptorImageInfo> imageInfos;
+ std::vector<VkDescriptorBufferInfo> bufferInfos;
+ std::vector<VkBufferView> texelBufferViews;
+ };
+
+ std::vector<WriteDescriptorInfo> m_writeDescriptorInfos;
std::vector<VkWriteDescriptorSet> m_writes;
std::vector<VkCopyDescriptorSet> m_copies;
virtual VkResult resetEvent (VkDevice device, VkEvent event) const;
virtual VkResult createQueryPool (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) const;
virtual void destroyQueryPool (VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) const;
-virtual VkResult getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) const;
+virtual VkResult getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, deUintptr dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) const;
virtual VkResult createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) const;
virtual void destroyBuffer (VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) const;
virtual VkResult createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) const;
virtual VkResult endCommandBuffer (VkCommandBuffer commandBuffer) const;
virtual VkResult resetCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) const;
virtual void cmdBindPipeline (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const;
-virtual void cmdSetViewport (VkCommandBuffer commandBuffer, deUint32 viewportCount, const VkViewport* pViewports) const;
-virtual void cmdSetScissor (VkCommandBuffer commandBuffer, deUint32 scissorCount, const VkRect2D* pScissors) const;
+virtual void cmdSetViewport (VkCommandBuffer commandBuffer, deUint32 firstViewport, deUint32 viewportCount, const VkViewport* pViewports) const;
+virtual void cmdSetScissor (VkCommandBuffer commandBuffer, deUint32 firstScissor, deUint32 scissorCount, const VkRect2D* pScissors) const;
virtual void cmdSetLineWidth (VkCommandBuffer commandBuffer, float lineWidth) const;
virtual void cmdSetDepthBias (VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) const;
virtual void cmdSetBlendConstants (VkCommandBuffer commandBuffer, const float blendConstants[4]) const;
virtual void cmdSetStencilReference (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, deUint32 reference) const;
virtual void cmdBindDescriptorSets (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 firstSet, deUint32 descriptorSetCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets) const;
virtual void cmdBindIndexBuffer (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const;
-virtual void cmdBindVertexBuffers (VkCommandBuffer commandBuffer, deUint32 startBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) const;
+virtual void cmdBindVertexBuffers (VkCommandBuffer commandBuffer, deUint32 firstBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) const;
virtual void cmdDraw (VkCommandBuffer commandBuffer, deUint32 vertexCount, deUint32 instanceCount, deUint32 firstVertex, deUint32 firstInstance) const;
virtual void cmdDrawIndexed (VkCommandBuffer commandBuffer, deUint32 indexCount, deUint32 instanceCount, deUint32 firstIndex, deInt32 vertexOffset, deUint32 firstInstance) const;
virtual void cmdDrawIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 drawCount, deUint32 stride) const;
virtual void cmdResolveImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkImageResolve* pRegions) const;
virtual void cmdSetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const;
virtual void cmdResetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const;
-virtual void cmdWaitEvents (VkCommandBuffer commandBuffer, deUint32 eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, deUint32 memoryBarrierCount, const void* const* ppMemoryBarriers) const;
-virtual void cmdPipelineBarrier (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, deUint32 memoryBarrierCount, const void* const* ppMemoryBarriers) const;
-virtual void cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 entry, VkQueryControlFlags flags) const;
-virtual void cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 entry) const;
-virtual void cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount) const;
-virtual void cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, deUint32 entry) const;
-virtual void cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) const;
+virtual void cmdWaitEvents (VkCommandBuffer commandBuffer, deUint32 eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, deUint32 memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, deUint32 bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, deUint32 imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) const;
+virtual void cmdPipelineBarrier (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, deUint32 memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, deUint32 bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, deUint32 imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) const;
+virtual void cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query, VkQueryControlFlags flags) const;
+virtual void cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query) const;
+virtual void cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount) const;
+virtual void cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, deUint32 query) const;
+virtual void cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) const;
virtual void cmdPushConstants (VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, deUint32 offset, deUint32 size, const void* pValues) const;
virtual void cmdBeginRenderPass (VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) const;
virtual void cmdNextSubpass (VkCommandBuffer commandBuffer, VkSubpassContents contents) const;
virtual void cmdEndRenderPass (VkCommandBuffer commandBuffer) const;
-virtual void cmdExecuteCommands (VkCommandBuffer commandBuffer, deUint32 commandBuffersCount, const VkCommandBuffer* pCommandBuffers) const;
+virtual void cmdExecuteCommands (VkCommandBuffer commandBuffer, deUint32 commandBufferCount, const VkCommandBuffer* pCommandBuffers) const;
m_vk.destroyQueryPool(device, queryPool, pAllocator);
}
-VkResult DeviceDriver::getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) const
+VkResult DeviceDriver::getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, deUintptr dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) const
{
- return m_vk.getQueryPoolResults(device, queryPool, startQuery, queryCount, dataSize, pData, stride, flags);
+ return m_vk.getQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
}
VkResult DeviceDriver::createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) const
m_vk.cmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
}
-void DeviceDriver::cmdSetViewport (VkCommandBuffer commandBuffer, deUint32 viewportCount, const VkViewport* pViewports) const
+void DeviceDriver::cmdSetViewport (VkCommandBuffer commandBuffer, deUint32 firstViewport, deUint32 viewportCount, const VkViewport* pViewports) const
{
- m_vk.cmdSetViewport(commandBuffer, viewportCount, pViewports);
+ m_vk.cmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
}
-void DeviceDriver::cmdSetScissor (VkCommandBuffer commandBuffer, deUint32 scissorCount, const VkRect2D* pScissors) const
+void DeviceDriver::cmdSetScissor (VkCommandBuffer commandBuffer, deUint32 firstScissor, deUint32 scissorCount, const VkRect2D* pScissors) const
{
- m_vk.cmdSetScissor(commandBuffer, scissorCount, pScissors);
+ m_vk.cmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
}
void DeviceDriver::cmdSetLineWidth (VkCommandBuffer commandBuffer, float lineWidth) const
m_vk.cmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
}
-void DeviceDriver::cmdBindVertexBuffers (VkCommandBuffer commandBuffer, deUint32 startBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) const
+void DeviceDriver::cmdBindVertexBuffers (VkCommandBuffer commandBuffer, deUint32 firstBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) const
{
- m_vk.cmdBindVertexBuffers(commandBuffer, startBinding, bindingCount, pBuffers, pOffsets);
+ m_vk.cmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
}
void DeviceDriver::cmdDraw (VkCommandBuffer commandBuffer, deUint32 vertexCount, deUint32 instanceCount, deUint32 firstVertex, deUint32 firstInstance) const
m_vk.cmdResetEvent(commandBuffer, event, stageMask);
}
-void DeviceDriver::cmdWaitEvents (VkCommandBuffer commandBuffer, deUint32 eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, deUint32 memoryBarrierCount, const void* const* ppMemoryBarriers) const
+void DeviceDriver::cmdWaitEvents (VkCommandBuffer commandBuffer, deUint32 eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, deUint32 memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, deUint32 bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, deUint32 imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) const
{
- m_vk.cmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, ppMemoryBarriers);
+ m_vk.cmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
}
-void DeviceDriver::cmdPipelineBarrier (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, deUint32 memoryBarrierCount, const void* const* ppMemoryBarriers) const
+void DeviceDriver::cmdPipelineBarrier (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, deUint32 memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, deUint32 bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, deUint32 imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) const
{
- m_vk.cmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, ppMemoryBarriers);
+ m_vk.cmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
}
-void DeviceDriver::cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 entry, VkQueryControlFlags flags) const
+void DeviceDriver::cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query, VkQueryControlFlags flags) const
{
- m_vk.cmdBeginQuery(commandBuffer, queryPool, entry, flags);
+ m_vk.cmdBeginQuery(commandBuffer, queryPool, query, flags);
}
-void DeviceDriver::cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 entry) const
+void DeviceDriver::cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query) const
{
- m_vk.cmdEndQuery(commandBuffer, queryPool, entry);
+ m_vk.cmdEndQuery(commandBuffer, queryPool, query);
}
-void DeviceDriver::cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount) const
+void DeviceDriver::cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount) const
{
- m_vk.cmdResetQueryPool(commandBuffer, queryPool, startQuery, queryCount);
+ m_vk.cmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
}
-void DeviceDriver::cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, deUint32 entry) const
+void DeviceDriver::cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, deUint32 query) const
{
- m_vk.cmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, entry);
+ m_vk.cmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
}
-void DeviceDriver::cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) const
+void DeviceDriver::cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) const
{
- m_vk.cmdCopyQueryPoolResults(commandBuffer, queryPool, startQuery, queryCount, dstBuffer, dstOffset, stride, flags);
+ m_vk.cmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
}
void DeviceDriver::cmdPushConstants (VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, deUint32 offset, deUint32 size, const void* pValues) const
m_vk.cmdEndRenderPass(commandBuffer);
}
-void DeviceDriver::cmdExecuteCommands (VkCommandBuffer commandBuffer, deUint32 commandBuffersCount, const VkCommandBuffer* pCommandBuffers) const
+void DeviceDriver::cmdExecuteCommands (VkCommandBuffer commandBuffer, deUint32 commandBufferCount, const VkCommandBuffer* pCommandBuffers) const
{
- m_vk.cmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers);
+ m_vk.cmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
}
typedef VKAPI_ATTR VkResult (VKAPI_CALL* ResetEventFunc) (VkDevice device, VkEvent event);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* CreateQueryPoolFunc) (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
typedef VKAPI_ATTR void (VKAPI_CALL* DestroyQueryPoolFunc) (VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
-typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetQueryPoolResultsFunc) (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
+typedef VKAPI_ATTR VkResult (VKAPI_CALL* GetQueryPoolResultsFunc) (VkDevice device, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, deUintptr dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* CreateBufferFunc) (VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
typedef VKAPI_ATTR void (VKAPI_CALL* DestroyBufferFunc) (VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* CreateBufferViewFunc) (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* EndCommandBufferFunc) (VkCommandBuffer commandBuffer);
typedef VKAPI_ATTR VkResult (VKAPI_CALL* ResetCommandBufferFunc) (VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdBindPipelineFunc) (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
-typedef VKAPI_ATTR void (VKAPI_CALL* CmdSetViewportFunc) (VkCommandBuffer commandBuffer, deUint32 viewportCount, const VkViewport* pViewports);
-typedef VKAPI_ATTR void (VKAPI_CALL* CmdSetScissorFunc) (VkCommandBuffer commandBuffer, deUint32 scissorCount, const VkRect2D* pScissors);
+typedef VKAPI_ATTR void (VKAPI_CALL* CmdSetViewportFunc) (VkCommandBuffer commandBuffer, deUint32 firstViewport, deUint32 viewportCount, const VkViewport* pViewports);
+typedef VKAPI_ATTR void (VKAPI_CALL* CmdSetScissorFunc) (VkCommandBuffer commandBuffer, deUint32 firstScissor, deUint32 scissorCount, const VkRect2D* pScissors);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdSetLineWidthFunc) (VkCommandBuffer commandBuffer, float lineWidth);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdSetDepthBiasFunc) (VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdSetBlendConstantsFunc) (VkCommandBuffer commandBuffer, const float blendConstants[4]);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdSetStencilReferenceFunc) (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, deUint32 reference);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdBindDescriptorSetsFunc) (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 firstSet, deUint32 descriptorSetCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdBindIndexBufferFunc) (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
-typedef VKAPI_ATTR void (VKAPI_CALL* CmdBindVertexBuffersFunc) (VkCommandBuffer commandBuffer, deUint32 startBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
+typedef VKAPI_ATTR void (VKAPI_CALL* CmdBindVertexBuffersFunc) (VkCommandBuffer commandBuffer, deUint32 firstBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdDrawFunc) (VkCommandBuffer commandBuffer, deUint32 vertexCount, deUint32 instanceCount, deUint32 firstVertex, deUint32 firstInstance);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdDrawIndexedFunc) (VkCommandBuffer commandBuffer, deUint32 indexCount, deUint32 instanceCount, deUint32 firstIndex, deInt32 vertexOffset, deUint32 firstInstance);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdDrawIndirectFunc) (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 drawCount, deUint32 stride);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdResolveImageFunc) (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkImageResolve* pRegions);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdSetEventFunc) (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdResetEventFunc) (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
-typedef VKAPI_ATTR void (VKAPI_CALL* CmdWaitEventsFunc) (VkCommandBuffer commandBuffer, deUint32 eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, deUint32 memoryBarrierCount, const void* const* ppMemoryBarriers);
-typedef VKAPI_ATTR void (VKAPI_CALL* CmdPipelineBarrierFunc) (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, deUint32 memoryBarrierCount, const void* const* ppMemoryBarriers);
-typedef VKAPI_ATTR void (VKAPI_CALL* CmdBeginQueryFunc) (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 entry, VkQueryControlFlags flags);
-typedef VKAPI_ATTR void (VKAPI_CALL* CmdEndQueryFunc) (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 entry);
-typedef VKAPI_ATTR void (VKAPI_CALL* CmdResetQueryPoolFunc) (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount);
-typedef VKAPI_ATTR void (VKAPI_CALL* CmdWriteTimestampFunc) (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, deUint32 entry);
-typedef VKAPI_ATTR void (VKAPI_CALL* CmdCopyQueryPoolResultsFunc) (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
+typedef VKAPI_ATTR void (VKAPI_CALL* CmdWaitEventsFunc) (VkCommandBuffer commandBuffer, deUint32 eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, deUint32 memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, deUint32 bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, deUint32 imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
+typedef VKAPI_ATTR void (VKAPI_CALL* CmdPipelineBarrierFunc) (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, deUint32 memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, deUint32 bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, deUint32 imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
+typedef VKAPI_ATTR void (VKAPI_CALL* CmdBeginQueryFunc) (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query, VkQueryControlFlags flags);
+typedef VKAPI_ATTR void (VKAPI_CALL* CmdEndQueryFunc) (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query);
+typedef VKAPI_ATTR void (VKAPI_CALL* CmdResetQueryPoolFunc) (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount);
+typedef VKAPI_ATTR void (VKAPI_CALL* CmdWriteTimestampFunc) (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, deUint32 query);
+typedef VKAPI_ATTR void (VKAPI_CALL* CmdCopyQueryPoolResultsFunc) (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdPushConstantsFunc) (VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, deUint32 offset, deUint32 size, const void* pValues);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdBeginRenderPassFunc) (VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdNextSubpassFunc) (VkCommandBuffer commandBuffer, VkSubpassContents contents);
typedef VKAPI_ATTR void (VKAPI_CALL* CmdEndRenderPassFunc) (VkCommandBuffer commandBuffer);
-typedef VKAPI_ATTR void (VKAPI_CALL* CmdExecuteCommandsFunc) (VkCommandBuffer commandBuffer, deUint32 commandBuffersCount, const VkCommandBuffer* pCommandBuffers);
+typedef VKAPI_ATTR void (VKAPI_CALL* CmdExecuteCommandsFunc) (VkCommandBuffer commandBuffer, deUint32 commandBufferCount, const VkCommandBuffer* pCommandBuffers);
case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_RGBA;
case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_SRGB8_ALPHA8;
case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_RGBA;
- case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_SRGB8_ALPHA8;
+ case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_SRGB8_ALPHA8;
case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_RGBA;
case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_SRGB8_ALPHA8;
case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_6x5_RGBA;
case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_RGBA;
case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_SRGB8_ALPHA8;
case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_RGBA;
- case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_SRGB8_ALPHA8;
+ case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_SRGB8_ALPHA8;
case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_RGBA;
case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_SRGB8_ALPHA8;
case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x8_RGBA;
{
DE_STATIC_ASSERT(tcu::Sampler::FILTERMODE_LAST == 6);
- switch(filterMode)
+ switch (filterMode)
{
case tcu::Sampler::NEAREST: return VK_FILTER_NEAREST;
case tcu::Sampler::LINEAR: return VK_FILTER_LINEAR;
{
DE_STATIC_ASSERT(tcu::Sampler::FILTERMODE_LAST == 6);
- switch(filterMode)
+ // \note VkSamplerCreateInfo doesn't have a flag for disabling mipmapping. Instead
+ // minLod = 0 and maxLod = 0.25 should be used to match OpenGL NEAREST and LINEAR
+ // filtering mode behavior.
+
+ switch (filterMode)
{
- case tcu::Sampler::NEAREST: return VK_SAMPLER_MIPMAP_MODE_BASE;
- case tcu::Sampler::LINEAR: return VK_SAMPLER_MIPMAP_MODE_BASE;
+ case tcu::Sampler::NEAREST: return VK_SAMPLER_MIPMAP_MODE_NEAREST;
+ case tcu::Sampler::LINEAR: return VK_SAMPLER_MIPMAP_MODE_NEAREST;
case tcu::Sampler::NEAREST_MIPMAP_NEAREST: return VK_SAMPLER_MIPMAP_MODE_NEAREST;
case tcu::Sampler::NEAREST_MIPMAP_LINEAR: return VK_SAMPLER_MIPMAP_MODE_LINEAR;
case tcu::Sampler::LINEAR_MIPMAP_NEAREST: return VK_SAMPLER_MIPMAP_MODE_NEAREST;
VkSamplerAddressMode mapWrapMode (tcu::Sampler::WrapMode wrapMode)
{
- switch(wrapMode)
+ switch (wrapMode)
{
case tcu::Sampler::CLAMP_TO_EDGE: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
case tcu::Sampler::CLAMP_TO_BORDER: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
vk::VkCompareOp mapCompareMode (tcu::Sampler::CompareMode mode)
{
- switch(mode)
+ switch (mode)
{
case tcu::Sampler::COMPAREMODE_NONE: return vk::VK_COMPARE_OP_NEVER;
case tcu::Sampler::COMPAREMODE_LESS: return vk::VK_COMPARE_OP_LESS;
}
}
+static VkBorderColor mapBorderColor (tcu::TextureChannelClass channelClass, const rr::GenericVec4& color)
+{
+ if (channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER)
+ {
+ const tcu::UVec4 uColor = color.get<deUint32>();
+
+ if (uColor == tcu::UVec4(0, 0, 0, 0)) return VK_BORDER_COLOR_INT_TRANSPARENT_BLACK;
+ else if (uColor == tcu::UVec4(0, 0, 0, 1)) return VK_BORDER_COLOR_INT_OPAQUE_BLACK;
+ else if (uColor == tcu::UVec4(1, 1, 1, 1)) return VK_BORDER_COLOR_INT_OPAQUE_WHITE;
+ }
+ else if (channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER)
+ {
+ const tcu::IVec4 sColor = color.get<deInt32>();
+
+ if (sColor == tcu::IVec4(0, 0, 0, 0)) return VK_BORDER_COLOR_INT_TRANSPARENT_BLACK;
+ else if (sColor == tcu::IVec4(0, 0, 0, 1)) return VK_BORDER_COLOR_INT_OPAQUE_BLACK;
+ else if (sColor == tcu::IVec4(1, 1, 1, 1)) return VK_BORDER_COLOR_INT_OPAQUE_WHITE;
+ }
+ else
+ {
+ const tcu::Vec4 fColor = color.get<float>();
+
+ if (fColor == tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f)) return VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
+ else if (fColor == tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f)) return VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK;
+ else if (fColor == tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f)) return VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
+ }
+
+ DE_FATAL("Unsupported border color");
+ return VK_BORDER_COLOR_LAST;
+}
+
+VkSamplerCreateInfo mapSampler (const tcu::Sampler& sampler, const tcu::TextureFormat& format)
+{
+ const bool compareEnabled = (sampler.compare != tcu::Sampler::COMPAREMODE_NONE);
+ const VkCompareOp compareOp = (compareEnabled) ? (mapCompareMode(sampler.compare)) : (VK_COMPARE_OP_ALWAYS);
+ const VkBorderColor borderColor = mapBorderColor(getTextureChannelClass(format.type), sampler.borderColor);
+ const bool isMipmapEnabled = (sampler.minFilter != tcu::Sampler::NEAREST && sampler.minFilter != tcu::Sampler::LINEAR);
+
+ const VkSamplerCreateInfo createInfo =
+ {
+ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
+ DE_NULL,
+ (VkSamplerCreateFlags)0,
+ mapFilterMode(sampler.magFilter), // magFilter
+ mapFilterMode(sampler.minFilter), // minFilter
+ mapMipmapMode(sampler.minFilter), // mipMode
+ mapWrapMode(sampler.wrapS), // addressU
+ mapWrapMode(sampler.wrapT), // addressV
+ mapWrapMode(sampler.wrapR), // addressW
+ 0.0f, // mipLodBias
+ VK_FALSE, // anisotropyEnable
+ 1.0f, // maxAnisotropy
+ (VkBool32)(compareEnabled ? VK_TRUE : VK_FALSE), // compareEnable
+ compareOp, // compareOp
+ 0.0f, // minLod
+ (isMipmapEnabled ? 1000.0f : 0.25f), // maxLod
+ borderColor, // borderColor
+ (VkBool32)(sampler.normalizedCoords ? VK_FALSE : VK_TRUE), // unnormalizedCoords
+ };
+
+ return createInfo;
+}
+
tcu::Sampler mapVkSampler (const VkSamplerCreateInfo& samplerCreateInfo)
{
+ // \note minLod & maxLod are not supported by tcu::Sampler. LOD must be clamped
+ // before passing it to tcu::Texture*::sample*()
+
tcu::Sampler sampler(mapVkSamplerAddressMode(samplerCreateInfo.addressModeU),
mapVkSamplerAddressMode(samplerCreateInfo.addressModeV),
mapVkSamplerAddressMode(samplerCreateInfo.addressModeW),
tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f),
true);
+ if (samplerCreateInfo.anisotropyEnable)
+ TCU_THROW(InternalError, "Anisotropic filtering is not supported by tcu::Sampler");
+
switch (samplerCreateInfo.borderColor)
{
- case VK_BORDER_COLOR_INT_OPAQUE_BLACK:
- sampler.borderColor = tcu::UVec4(0,0,0,1);
- break;
- case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK:
- sampler.borderColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f);
- break;
- case VK_BORDER_COLOR_INT_OPAQUE_WHITE:
- sampler.borderColor = tcu::UVec4(1, 1, 1, 1);
- break;
- case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE:
- sampler.borderColor = tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f);
- break;
- case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK:
- sampler.borderColor = tcu::UVec4(0,0,0,0);
- break;
- case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK:
- sampler.borderColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f);
- break;
-
- default:
- DE_ASSERT(false);
- break;
+ case VK_BORDER_COLOR_INT_OPAQUE_BLACK:
+ sampler.borderColor = tcu::UVec4(0,0,0,1);
+ break;
+ case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK:
+ sampler.borderColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f);
+ break;
+ case VK_BORDER_COLOR_INT_OPAQUE_WHITE:
+ sampler.borderColor = tcu::UVec4(1, 1, 1, 1);
+ break;
+ case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE:
+ sampler.borderColor = tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f);
+ break;
+ case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK:
+ sampler.borderColor = tcu::UVec4(0,0,0,0);
+ break;
+ case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK:
+ sampler.borderColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f);
+ break;
+
+ default:
+ DE_ASSERT(false);
+ break;
}
return sampler;
case VK_FILTER_LINEAR:
switch (mipMode)
{
- case VK_SAMPLER_MIPMAP_MODE_BASE: return tcu::Sampler::LINEAR;
case VK_SAMPLER_MIPMAP_MODE_LINEAR: return tcu::Sampler::LINEAR_MIPMAP_LINEAR;
case VK_SAMPLER_MIPMAP_MODE_NEAREST: return tcu::Sampler::LINEAR_MIPMAP_NEAREST;
default:
case VK_FILTER_NEAREST:
switch (mipMode)
{
- case VK_SAMPLER_MIPMAP_MODE_BASE: return tcu::Sampler::NEAREST;
case VK_SAMPLER_MIPMAP_MODE_LINEAR: return tcu::Sampler::NEAREST_MIPMAP_LINEAR;
case VK_SAMPLER_MIPMAP_MODE_NEAREST: return tcu::Sampler::NEAREST_MIPMAP_NEAREST;
default:
VkSamplerAddressMode mapWrapMode (tcu::Sampler::WrapMode wrapMode);
VkCompareOp mapCompareMode (tcu::Sampler::CompareMode mode);
VkFormat mapTextureFormat (const tcu::TextureFormat& format);
+VkSamplerCreateInfo mapSampler (const tcu::Sampler& sampler, const tcu::TextureFormat& format);
void imageUtilSelfTest (void);
{
DescriptorPool* const poolImpl = reinterpret_cast<DescriptorPool*>((deUintptr)pAllocateInfo->descriptorPool.getInternal());
- for (deUint32 ndx = 0; ndx < pAllocateInfo->setLayoutCount; ++ndx)
+ for (deUint32 ndx = 0; ndx < pAllocateInfo->descriptorSetCount; ++ndx)
{
try
{
{
if (pAllocateInfo && pCommandBuffers)
{
- for (deUint32 ndx = 0; ndx < pAllocateInfo->bufferCount; ++ndx)
+ for (deUint32 ndx = 0; ndx < pAllocateInfo->commandBufferCount; ++ndx)
{
pCommandBuffers[ndx] = reinterpret_cast<VkCommandBuffer>(new CommandBuffer(device, pAllocateInfo->commandPool, pAllocateInfo->level));
}
return VK_SUCCESS;
}
-VKAPI_ATTR VkResult VKAPI_CALL getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
+VKAPI_ATTR VkResult VKAPI_CALL getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, deUintptr dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
{
DE_UNREF(device);
DE_UNREF(queryPool);
- DE_UNREF(startQuery);
+ DE_UNREF(firstQuery);
DE_UNREF(queryCount);
DE_UNREF(dataSize);
DE_UNREF(pData);
DE_UNREF(pipeline);
}
-VKAPI_ATTR void VKAPI_CALL cmdSetViewport (VkCommandBuffer commandBuffer, deUint32 viewportCount, const VkViewport* pViewports)
+VKAPI_ATTR void VKAPI_CALL cmdSetViewport (VkCommandBuffer commandBuffer, deUint32 firstViewport, deUint32 viewportCount, const VkViewport* pViewports)
{
DE_UNREF(commandBuffer);
+ DE_UNREF(firstViewport);
DE_UNREF(viewportCount);
DE_UNREF(pViewports);
}
-VKAPI_ATTR void VKAPI_CALL cmdSetScissor (VkCommandBuffer commandBuffer, deUint32 scissorCount, const VkRect2D* pScissors)
+VKAPI_ATTR void VKAPI_CALL cmdSetScissor (VkCommandBuffer commandBuffer, deUint32 firstScissor, deUint32 scissorCount, const VkRect2D* pScissors)
{
DE_UNREF(commandBuffer);
+ DE_UNREF(firstScissor);
DE_UNREF(scissorCount);
DE_UNREF(pScissors);
}
DE_UNREF(indexType);
}
-VKAPI_ATTR void VKAPI_CALL cmdBindVertexBuffers (VkCommandBuffer commandBuffer, deUint32 startBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
+VKAPI_ATTR void VKAPI_CALL cmdBindVertexBuffers (VkCommandBuffer commandBuffer, deUint32 firstBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
{
DE_UNREF(commandBuffer);
- DE_UNREF(startBinding);
+ DE_UNREF(firstBinding);
DE_UNREF(bindingCount);
DE_UNREF(pBuffers);
DE_UNREF(pOffsets);
DE_UNREF(stageMask);
}
-VKAPI_ATTR void VKAPI_CALL cmdWaitEvents (VkCommandBuffer commandBuffer, deUint32 eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, deUint32 memoryBarrierCount, const void* const* ppMemoryBarriers)
+VKAPI_ATTR void VKAPI_CALL cmdWaitEvents (VkCommandBuffer commandBuffer, deUint32 eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, deUint32 memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, deUint32 bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, deUint32 imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
{
DE_UNREF(commandBuffer);
DE_UNREF(eventCount);
DE_UNREF(srcStageMask);
DE_UNREF(dstStageMask);
DE_UNREF(memoryBarrierCount);
- DE_UNREF(ppMemoryBarriers);
+ DE_UNREF(pMemoryBarriers);
+ DE_UNREF(bufferMemoryBarrierCount);
+ DE_UNREF(pBufferMemoryBarriers);
+ DE_UNREF(imageMemoryBarrierCount);
+ DE_UNREF(pImageMemoryBarriers);
}
-VKAPI_ATTR void VKAPI_CALL cmdPipelineBarrier (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, deUint32 memoryBarrierCount, const void* const* ppMemoryBarriers)
+VKAPI_ATTR void VKAPI_CALL cmdPipelineBarrier (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, deUint32 memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, deUint32 bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, deUint32 imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
{
DE_UNREF(commandBuffer);
DE_UNREF(srcStageMask);
DE_UNREF(dstStageMask);
DE_UNREF(dependencyFlags);
DE_UNREF(memoryBarrierCount);
- DE_UNREF(ppMemoryBarriers);
+ DE_UNREF(pMemoryBarriers);
+ DE_UNREF(bufferMemoryBarrierCount);
+ DE_UNREF(pBufferMemoryBarriers);
+ DE_UNREF(imageMemoryBarrierCount);
+ DE_UNREF(pImageMemoryBarriers);
}
-VKAPI_ATTR void VKAPI_CALL cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 entry, VkQueryControlFlags flags)
+VKAPI_ATTR void VKAPI_CALL cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query, VkQueryControlFlags flags)
{
DE_UNREF(commandBuffer);
DE_UNREF(queryPool);
- DE_UNREF(entry);
+ DE_UNREF(query);
DE_UNREF(flags);
}
-VKAPI_ATTR void VKAPI_CALL cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 entry)
+VKAPI_ATTR void VKAPI_CALL cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query)
{
DE_UNREF(commandBuffer);
DE_UNREF(queryPool);
- DE_UNREF(entry);
+ DE_UNREF(query);
}
-VKAPI_ATTR void VKAPI_CALL cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount)
+VKAPI_ATTR void VKAPI_CALL cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount)
{
DE_UNREF(commandBuffer);
DE_UNREF(queryPool);
- DE_UNREF(startQuery);
+ DE_UNREF(firstQuery);
DE_UNREF(queryCount);
}
-VKAPI_ATTR void VKAPI_CALL cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, deUint32 entry)
+VKAPI_ATTR void VKAPI_CALL cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, deUint32 query)
{
DE_UNREF(commandBuffer);
DE_UNREF(pipelineStage);
DE_UNREF(queryPool);
- DE_UNREF(entry);
+ DE_UNREF(query);
}
-VKAPI_ATTR void VKAPI_CALL cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
+VKAPI_ATTR void VKAPI_CALL cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
{
DE_UNREF(commandBuffer);
DE_UNREF(queryPool);
- DE_UNREF(startQuery);
+ DE_UNREF(firstQuery);
DE_UNREF(queryCount);
DE_UNREF(dstBuffer);
DE_UNREF(dstOffset);
DE_UNREF(commandBuffer);
}
-VKAPI_ATTR void VKAPI_CALL cmdExecuteCommands (VkCommandBuffer commandBuffer, deUint32 commandBuffersCount, const VkCommandBuffer* pCommandBuffers)
+VKAPI_ATTR void VKAPI_CALL cmdExecuteCommands (VkCommandBuffer commandBuffer, deUint32 commandBufferCount, const VkCommandBuffer* pCommandBuffers)
{
DE_UNREF(commandBuffer);
- DE_UNREF(commandBuffersCount);
+ DE_UNREF(commandBufferCount);
DE_UNREF(pCommandBuffers);
}
Move<VkCommandBuffer> allocateCommandBuffer (const DeviceInterface& vk, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo)
{
VkCommandBuffer object = 0;
- DE_ASSERT(pAllocateInfo->bufferCount == 1u);
+ DE_ASSERT(pAllocateInfo->commandBufferCount == 1u);
VK_CHECK(vk.allocateCommandBuffers(device, pAllocateInfo, &object));
return Move<VkCommandBuffer>(check<VkCommandBuffer>(object), Deleter<VkCommandBuffer>(vk, device, pAllocateInfo->commandPool));
}
Move<VkDescriptorSet> allocateDescriptorSet (const DeviceInterface& vk, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo)
{
VkDescriptorSet object = 0;
- DE_ASSERT(pAllocateInfo->setLayoutCount == 1u);
+ DE_ASSERT(pAllocateInfo->descriptorSetCount == 1u);
VK_CHECK(vk.allocateDescriptorSets(device, pAllocateInfo, &object));
return Move<VkDescriptorSet>(check<VkDescriptorSet>(object), Deleter<VkDescriptorSet>(vk, device, pAllocateInfo->descriptorPool));
}
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-const char* getResultName (VkResult value);
-const char* getStructureTypeName (VkStructureType value);
-const char* getSystemAllocationScopeName (VkSystemAllocationScope value);
-const char* getInternalAllocationTypeName (VkInternalAllocationType value);
-const char* getFormatName (VkFormat value);
-const char* getImageTypeName (VkImageType value);
-const char* getImageTilingName (VkImageTiling value);
-const char* getPhysicalDeviceTypeName (VkPhysicalDeviceType value);
-const char* getQueryTypeName (VkQueryType value);
-const char* getSharingModeName (VkSharingMode value);
-const char* getImageLayoutName (VkImageLayout value);
-const char* getImageViewTypeName (VkImageViewType value);
-const char* getComponentSwizzleName (VkComponentSwizzle value);
-const char* getVertexInputRateName (VkVertexInputRate value);
-const char* getPrimitiveTopologyName (VkPrimitiveTopology value);
-const char* getPolygonModeName (VkPolygonMode value);
-const char* getFrontFaceName (VkFrontFace value);
-const char* getCompareOpName (VkCompareOp value);
-const char* getStencilOpName (VkStencilOp value);
-const char* getLogicOpName (VkLogicOp value);
-const char* getBlendFactorName (VkBlendFactor value);
-const char* getBlendOpName (VkBlendOp value);
-const char* getDynamicStateName (VkDynamicState value);
-const char* getFilterName (VkFilter value);
-const char* getSamplerMipmapModeName (VkSamplerMipmapMode value);
-const char* getSamplerAddressModeName (VkSamplerAddressMode value);
-const char* getBorderColorName (VkBorderColor value);
-const char* getDescriptorTypeName (VkDescriptorType value);
-const char* getAttachmentLoadOpName (VkAttachmentLoadOp value);
-const char* getAttachmentStoreOpName (VkAttachmentStoreOp value);
-const char* getPipelineBindPointName (VkPipelineBindPoint value);
-const char* getCommandBufferLevelName (VkCommandBufferLevel value);
-const char* getIndexTypeName (VkIndexType value);
-const char* getSubpassContentsName (VkSubpassContents value);
-const char* getColorSpaceKHRName (VkColorSpaceKHR value);
-const char* getPresentModeKHRName (VkPresentModeKHR value);
+const char* getPipelineCacheHeaderVersionName (VkPipelineCacheHeaderVersion value);
+const char* getResultName (VkResult value);
+const char* getStructureTypeName (VkStructureType value);
+const char* getSystemAllocationScopeName (VkSystemAllocationScope value);
+const char* getInternalAllocationTypeName (VkInternalAllocationType value);
+const char* getFormatName (VkFormat value);
+const char* getImageTypeName (VkImageType value);
+const char* getImageTilingName (VkImageTiling value);
+const char* getPhysicalDeviceTypeName (VkPhysicalDeviceType value);
+const char* getQueryTypeName (VkQueryType value);
+const char* getSharingModeName (VkSharingMode value);
+const char* getImageLayoutName (VkImageLayout value);
+const char* getImageViewTypeName (VkImageViewType value);
+const char* getComponentSwizzleName (VkComponentSwizzle value);
+const char* getVertexInputRateName (VkVertexInputRate value);
+const char* getPrimitiveTopologyName (VkPrimitiveTopology value);
+const char* getPolygonModeName (VkPolygonMode value);
+const char* getFrontFaceName (VkFrontFace value);
+const char* getCompareOpName (VkCompareOp value);
+const char* getStencilOpName (VkStencilOp value);
+const char* getLogicOpName (VkLogicOp value);
+const char* getBlendFactorName (VkBlendFactor value);
+const char* getBlendOpName (VkBlendOp value);
+const char* getDynamicStateName (VkDynamicState value);
+const char* getFilterName (VkFilter value);
+const char* getSamplerMipmapModeName (VkSamplerMipmapMode value);
+const char* getSamplerAddressModeName (VkSamplerAddressMode value);
+const char* getBorderColorName (VkBorderColor value);
+const char* getDescriptorTypeName (VkDescriptorType value);
+const char* getAttachmentLoadOpName (VkAttachmentLoadOp value);
+const char* getAttachmentStoreOpName (VkAttachmentStoreOp value);
+const char* getPipelineBindPointName (VkPipelineBindPoint value);
+const char* getCommandBufferLevelName (VkCommandBufferLevel value);
+const char* getIndexTypeName (VkIndexType value);
+const char* getSubpassContentsName (VkSubpassContents value);
+const char* getColorSpaceKHRName (VkColorSpaceKHR value);
+const char* getPresentModeKHRName (VkPresentModeKHR value);
-inline tcu::Format::Enum<VkResult> getResultStr (VkResult value) { return tcu::Format::Enum<VkResult>(getResultName, value); }
-inline tcu::Format::Enum<VkStructureType> getStructureTypeStr (VkStructureType value) { return tcu::Format::Enum<VkStructureType>(getStructureTypeName, value); }
-inline tcu::Format::Enum<VkSystemAllocationScope> getSystemAllocationScopeStr (VkSystemAllocationScope value) { return tcu::Format::Enum<VkSystemAllocationScope>(getSystemAllocationScopeName, value); }
-inline tcu::Format::Enum<VkInternalAllocationType> getInternalAllocationTypeStr (VkInternalAllocationType value) { return tcu::Format::Enum<VkInternalAllocationType>(getInternalAllocationTypeName, value); }
-inline tcu::Format::Enum<VkFormat> getFormatStr (VkFormat value) { return tcu::Format::Enum<VkFormat>(getFormatName, value); }
-inline tcu::Format::Enum<VkImageType> getImageTypeStr (VkImageType value) { return tcu::Format::Enum<VkImageType>(getImageTypeName, value); }
-inline tcu::Format::Enum<VkImageTiling> getImageTilingStr (VkImageTiling value) { return tcu::Format::Enum<VkImageTiling>(getImageTilingName, value); }
-inline tcu::Format::Enum<VkPhysicalDeviceType> getPhysicalDeviceTypeStr (VkPhysicalDeviceType value) { return tcu::Format::Enum<VkPhysicalDeviceType>(getPhysicalDeviceTypeName, value); }
-inline tcu::Format::Enum<VkQueryType> getQueryTypeStr (VkQueryType value) { return tcu::Format::Enum<VkQueryType>(getQueryTypeName, value); }
-inline tcu::Format::Enum<VkSharingMode> getSharingModeStr (VkSharingMode value) { return tcu::Format::Enum<VkSharingMode>(getSharingModeName, value); }
-inline tcu::Format::Enum<VkImageLayout> getImageLayoutStr (VkImageLayout value) { return tcu::Format::Enum<VkImageLayout>(getImageLayoutName, value); }
-inline tcu::Format::Enum<VkImageViewType> getImageViewTypeStr (VkImageViewType value) { return tcu::Format::Enum<VkImageViewType>(getImageViewTypeName, value); }
-inline tcu::Format::Enum<VkComponentSwizzle> getComponentSwizzleStr (VkComponentSwizzle value) { return tcu::Format::Enum<VkComponentSwizzle>(getComponentSwizzleName, value); }
-inline tcu::Format::Enum<VkVertexInputRate> getVertexInputRateStr (VkVertexInputRate value) { return tcu::Format::Enum<VkVertexInputRate>(getVertexInputRateName, value); }
-inline tcu::Format::Enum<VkPrimitiveTopology> getPrimitiveTopologyStr (VkPrimitiveTopology value) { return tcu::Format::Enum<VkPrimitiveTopology>(getPrimitiveTopologyName, value); }
-inline tcu::Format::Enum<VkPolygonMode> getPolygonModeStr (VkPolygonMode value) { return tcu::Format::Enum<VkPolygonMode>(getPolygonModeName, value); }
-inline tcu::Format::Enum<VkFrontFace> getFrontFaceStr (VkFrontFace value) { return tcu::Format::Enum<VkFrontFace>(getFrontFaceName, value); }
-inline tcu::Format::Enum<VkCompareOp> getCompareOpStr (VkCompareOp value) { return tcu::Format::Enum<VkCompareOp>(getCompareOpName, value); }
-inline tcu::Format::Enum<VkStencilOp> getStencilOpStr (VkStencilOp value) { return tcu::Format::Enum<VkStencilOp>(getStencilOpName, value); }
-inline tcu::Format::Enum<VkLogicOp> getLogicOpStr (VkLogicOp value) { return tcu::Format::Enum<VkLogicOp>(getLogicOpName, value); }
-inline tcu::Format::Enum<VkBlendFactor> getBlendFactorStr (VkBlendFactor value) { return tcu::Format::Enum<VkBlendFactor>(getBlendFactorName, value); }
-inline tcu::Format::Enum<VkBlendOp> getBlendOpStr (VkBlendOp value) { return tcu::Format::Enum<VkBlendOp>(getBlendOpName, value); }
-inline tcu::Format::Enum<VkDynamicState> getDynamicStateStr (VkDynamicState value) { return tcu::Format::Enum<VkDynamicState>(getDynamicStateName, value); }
-inline tcu::Format::Enum<VkFilter> getFilterStr (VkFilter value) { return tcu::Format::Enum<VkFilter>(getFilterName, value); }
-inline tcu::Format::Enum<VkSamplerMipmapMode> getSamplerMipmapModeStr (VkSamplerMipmapMode value) { return tcu::Format::Enum<VkSamplerMipmapMode>(getSamplerMipmapModeName, value); }
-inline tcu::Format::Enum<VkSamplerAddressMode> getSamplerAddressModeStr (VkSamplerAddressMode value) { return tcu::Format::Enum<VkSamplerAddressMode>(getSamplerAddressModeName, value); }
-inline tcu::Format::Enum<VkBorderColor> getBorderColorStr (VkBorderColor value) { return tcu::Format::Enum<VkBorderColor>(getBorderColorName, value); }
-inline tcu::Format::Enum<VkDescriptorType> getDescriptorTypeStr (VkDescriptorType value) { return tcu::Format::Enum<VkDescriptorType>(getDescriptorTypeName, value); }
-inline tcu::Format::Enum<VkAttachmentLoadOp> getAttachmentLoadOpStr (VkAttachmentLoadOp value) { return tcu::Format::Enum<VkAttachmentLoadOp>(getAttachmentLoadOpName, value); }
-inline tcu::Format::Enum<VkAttachmentStoreOp> getAttachmentStoreOpStr (VkAttachmentStoreOp value) { return tcu::Format::Enum<VkAttachmentStoreOp>(getAttachmentStoreOpName, value); }
-inline tcu::Format::Enum<VkPipelineBindPoint> getPipelineBindPointStr (VkPipelineBindPoint value) { return tcu::Format::Enum<VkPipelineBindPoint>(getPipelineBindPointName, value); }
-inline tcu::Format::Enum<VkCommandBufferLevel> getCommandBufferLevelStr (VkCommandBufferLevel value) { return tcu::Format::Enum<VkCommandBufferLevel>(getCommandBufferLevelName, value); }
-inline tcu::Format::Enum<VkIndexType> getIndexTypeStr (VkIndexType value) { return tcu::Format::Enum<VkIndexType>(getIndexTypeName, value); }
-inline tcu::Format::Enum<VkSubpassContents> getSubpassContentsStr (VkSubpassContents value) { return tcu::Format::Enum<VkSubpassContents>(getSubpassContentsName, value); }
-inline tcu::Format::Enum<VkColorSpaceKHR> getColorSpaceKHRStr (VkColorSpaceKHR value) { return tcu::Format::Enum<VkColorSpaceKHR>(getColorSpaceKHRName, value); }
-inline tcu::Format::Enum<VkPresentModeKHR> getPresentModeKHRStr (VkPresentModeKHR value) { return tcu::Format::Enum<VkPresentModeKHR>(getPresentModeKHRName, value); }
+inline tcu::Format::Enum<VkPipelineCacheHeaderVersion> getPipelineCacheHeaderVersionStr (VkPipelineCacheHeaderVersion value) { return tcu::Format::Enum<VkPipelineCacheHeaderVersion>(getPipelineCacheHeaderVersionName, value); }
+inline tcu::Format::Enum<VkResult> getResultStr (VkResult value) { return tcu::Format::Enum<VkResult>(getResultName, value); }
+inline tcu::Format::Enum<VkStructureType> getStructureTypeStr (VkStructureType value) { return tcu::Format::Enum<VkStructureType>(getStructureTypeName, value); }
+inline tcu::Format::Enum<VkSystemAllocationScope> getSystemAllocationScopeStr (VkSystemAllocationScope value) { return tcu::Format::Enum<VkSystemAllocationScope>(getSystemAllocationScopeName, value); }
+inline tcu::Format::Enum<VkInternalAllocationType> getInternalAllocationTypeStr (VkInternalAllocationType value) { return tcu::Format::Enum<VkInternalAllocationType>(getInternalAllocationTypeName, value); }
+inline tcu::Format::Enum<VkFormat> getFormatStr (VkFormat value) { return tcu::Format::Enum<VkFormat>(getFormatName, value); }
+inline tcu::Format::Enum<VkImageType> getImageTypeStr (VkImageType value) { return tcu::Format::Enum<VkImageType>(getImageTypeName, value); }
+inline tcu::Format::Enum<VkImageTiling> getImageTilingStr (VkImageTiling value) { return tcu::Format::Enum<VkImageTiling>(getImageTilingName, value); }
+inline tcu::Format::Enum<VkPhysicalDeviceType> getPhysicalDeviceTypeStr (VkPhysicalDeviceType value) { return tcu::Format::Enum<VkPhysicalDeviceType>(getPhysicalDeviceTypeName, value); }
+inline tcu::Format::Enum<VkQueryType> getQueryTypeStr (VkQueryType value) { return tcu::Format::Enum<VkQueryType>(getQueryTypeName, value); }
+inline tcu::Format::Enum<VkSharingMode> getSharingModeStr (VkSharingMode value) { return tcu::Format::Enum<VkSharingMode>(getSharingModeName, value); }
+inline tcu::Format::Enum<VkImageLayout> getImageLayoutStr (VkImageLayout value) { return tcu::Format::Enum<VkImageLayout>(getImageLayoutName, value); }
+inline tcu::Format::Enum<VkImageViewType> getImageViewTypeStr (VkImageViewType value) { return tcu::Format::Enum<VkImageViewType>(getImageViewTypeName, value); }
+inline tcu::Format::Enum<VkComponentSwizzle> getComponentSwizzleStr (VkComponentSwizzle value) { return tcu::Format::Enum<VkComponentSwizzle>(getComponentSwizzleName, value); }
+inline tcu::Format::Enum<VkVertexInputRate> getVertexInputRateStr (VkVertexInputRate value) { return tcu::Format::Enum<VkVertexInputRate>(getVertexInputRateName, value); }
+inline tcu::Format::Enum<VkPrimitiveTopology> getPrimitiveTopologyStr (VkPrimitiveTopology value) { return tcu::Format::Enum<VkPrimitiveTopology>(getPrimitiveTopologyName, value); }
+inline tcu::Format::Enum<VkPolygonMode> getPolygonModeStr (VkPolygonMode value) { return tcu::Format::Enum<VkPolygonMode>(getPolygonModeName, value); }
+inline tcu::Format::Enum<VkFrontFace> getFrontFaceStr (VkFrontFace value) { return tcu::Format::Enum<VkFrontFace>(getFrontFaceName, value); }
+inline tcu::Format::Enum<VkCompareOp> getCompareOpStr (VkCompareOp value) { return tcu::Format::Enum<VkCompareOp>(getCompareOpName, value); }
+inline tcu::Format::Enum<VkStencilOp> getStencilOpStr (VkStencilOp value) { return tcu::Format::Enum<VkStencilOp>(getStencilOpName, value); }
+inline tcu::Format::Enum<VkLogicOp> getLogicOpStr (VkLogicOp value) { return tcu::Format::Enum<VkLogicOp>(getLogicOpName, value); }
+inline tcu::Format::Enum<VkBlendFactor> getBlendFactorStr (VkBlendFactor value) { return tcu::Format::Enum<VkBlendFactor>(getBlendFactorName, value); }
+inline tcu::Format::Enum<VkBlendOp> getBlendOpStr (VkBlendOp value) { return tcu::Format::Enum<VkBlendOp>(getBlendOpName, value); }
+inline tcu::Format::Enum<VkDynamicState> getDynamicStateStr (VkDynamicState value) { return tcu::Format::Enum<VkDynamicState>(getDynamicStateName, value); }
+inline tcu::Format::Enum<VkFilter> getFilterStr (VkFilter value) { return tcu::Format::Enum<VkFilter>(getFilterName, value); }
+inline tcu::Format::Enum<VkSamplerMipmapMode> getSamplerMipmapModeStr (VkSamplerMipmapMode value) { return tcu::Format::Enum<VkSamplerMipmapMode>(getSamplerMipmapModeName, value); }
+inline tcu::Format::Enum<VkSamplerAddressMode> getSamplerAddressModeStr (VkSamplerAddressMode value) { return tcu::Format::Enum<VkSamplerAddressMode>(getSamplerAddressModeName, value); }
+inline tcu::Format::Enum<VkBorderColor> getBorderColorStr (VkBorderColor value) { return tcu::Format::Enum<VkBorderColor>(getBorderColorName, value); }
+inline tcu::Format::Enum<VkDescriptorType> getDescriptorTypeStr (VkDescriptorType value) { return tcu::Format::Enum<VkDescriptorType>(getDescriptorTypeName, value); }
+inline tcu::Format::Enum<VkAttachmentLoadOp> getAttachmentLoadOpStr (VkAttachmentLoadOp value) { return tcu::Format::Enum<VkAttachmentLoadOp>(getAttachmentLoadOpName, value); }
+inline tcu::Format::Enum<VkAttachmentStoreOp> getAttachmentStoreOpStr (VkAttachmentStoreOp value) { return tcu::Format::Enum<VkAttachmentStoreOp>(getAttachmentStoreOpName, value); }
+inline tcu::Format::Enum<VkPipelineBindPoint> getPipelineBindPointStr (VkPipelineBindPoint value) { return tcu::Format::Enum<VkPipelineBindPoint>(getPipelineBindPointName, value); }
+inline tcu::Format::Enum<VkCommandBufferLevel> getCommandBufferLevelStr (VkCommandBufferLevel value) { return tcu::Format::Enum<VkCommandBufferLevel>(getCommandBufferLevelName, value); }
+inline tcu::Format::Enum<VkIndexType> getIndexTypeStr (VkIndexType value) { return tcu::Format::Enum<VkIndexType>(getIndexTypeName, value); }
+inline tcu::Format::Enum<VkSubpassContents> getSubpassContentsStr (VkSubpassContents value) { return tcu::Format::Enum<VkSubpassContents>(getSubpassContentsName, value); }
+inline tcu::Format::Enum<VkColorSpaceKHR> getColorSpaceKHRStr (VkColorSpaceKHR value) { return tcu::Format::Enum<VkColorSpaceKHR>(getColorSpaceKHRName, value); }
+inline tcu::Format::Enum<VkPresentModeKHR> getPresentModeKHRStr (VkPresentModeKHR value) { return tcu::Format::Enum<VkPresentModeKHR>(getPresentModeKHRName, value); }
-inline std::ostream& operator<< (std::ostream& s, VkResult value) { return s << getResultStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkStructureType value) { return s << getStructureTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkSystemAllocationScope value) { return s << getSystemAllocationScopeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkInternalAllocationType value) { return s << getInternalAllocationTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkFormat value) { return s << getFormatStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkImageType value) { return s << getImageTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkImageTiling value) { return s << getImageTilingStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkPhysicalDeviceType value) { return s << getPhysicalDeviceTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkQueryType value) { return s << getQueryTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkSharingMode value) { return s << getSharingModeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkImageLayout value) { return s << getImageLayoutStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkImageViewType value) { return s << getImageViewTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkComponentSwizzle value) { return s << getComponentSwizzleStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkVertexInputRate value) { return s << getVertexInputRateStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkPrimitiveTopology value) { return s << getPrimitiveTopologyStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkPolygonMode value) { return s << getPolygonModeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkFrontFace value) { return s << getFrontFaceStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkCompareOp value) { return s << getCompareOpStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkStencilOp value) { return s << getStencilOpStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkLogicOp value) { return s << getLogicOpStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkBlendFactor value) { return s << getBlendFactorStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkBlendOp value) { return s << getBlendOpStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkDynamicState value) { return s << getDynamicStateStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkFilter value) { return s << getFilterStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkSamplerMipmapMode value) { return s << getSamplerMipmapModeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkSamplerAddressMode value) { return s << getSamplerAddressModeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkBorderColor value) { return s << getBorderColorStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkDescriptorType value) { return s << getDescriptorTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkAttachmentLoadOp value) { return s << getAttachmentLoadOpStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkAttachmentStoreOp value) { return s << getAttachmentStoreOpStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkPipelineBindPoint value) { return s << getPipelineBindPointStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkCommandBufferLevel value) { return s << getCommandBufferLevelStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkIndexType value) { return s << getIndexTypeStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkSubpassContents value) { return s << getSubpassContentsStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkColorSpaceKHR value) { return s << getColorSpaceKHRStr(value); }
-inline std::ostream& operator<< (std::ostream& s, VkPresentModeKHR value) { return s << getPresentModeKHRStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkPipelineCacheHeaderVersion value) { return s << getPipelineCacheHeaderVersionStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkResult value) { return s << getResultStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkStructureType value) { return s << getStructureTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkSystemAllocationScope value) { return s << getSystemAllocationScopeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkInternalAllocationType value) { return s << getInternalAllocationTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkFormat value) { return s << getFormatStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkImageType value) { return s << getImageTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkImageTiling value) { return s << getImageTilingStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkPhysicalDeviceType value) { return s << getPhysicalDeviceTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkQueryType value) { return s << getQueryTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkSharingMode value) { return s << getSharingModeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkImageLayout value) { return s << getImageLayoutStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkImageViewType value) { return s << getImageViewTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkComponentSwizzle value) { return s << getComponentSwizzleStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkVertexInputRate value) { return s << getVertexInputRateStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkPrimitiveTopology value) { return s << getPrimitiveTopologyStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkPolygonMode value) { return s << getPolygonModeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkFrontFace value) { return s << getFrontFaceStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkCompareOp value) { return s << getCompareOpStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkStencilOp value) { return s << getStencilOpStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkLogicOp value) { return s << getLogicOpStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkBlendFactor value) { return s << getBlendFactorStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkBlendOp value) { return s << getBlendOpStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkDynamicState value) { return s << getDynamicStateStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkFilter value) { return s << getFilterStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkSamplerMipmapMode value) { return s << getSamplerMipmapModeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkSamplerAddressMode value) { return s << getSamplerAddressModeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkBorderColor value) { return s << getBorderColorStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkDescriptorType value) { return s << getDescriptorTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkAttachmentLoadOp value) { return s << getAttachmentLoadOpStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkAttachmentStoreOp value) { return s << getAttachmentStoreOpStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkPipelineBindPoint value) { return s << getPipelineBindPointStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkCommandBufferLevel value) { return s << getCommandBufferLevelStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkIndexType value) { return s << getIndexTypeStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkSubpassContents value) { return s << getSubpassContentsStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkColorSpaceKHR value) { return s << getColorSpaceKHRStr(value); }
+inline std::ostream& operator<< (std::ostream& s, VkPresentModeKHR value) { return s << getPresentModeKHRStr(value); }
tcu::Format::Bitfield<32> getFormatFeatureFlagsStr (VkFormatFeatureFlags value);
tcu::Format::Bitfield<32> getImageUsageFlagsStr (VkImageUsageFlags value);
tcu::Format::Bitfield<32> getQueueFlagsStr (VkQueueFlags value);
tcu::Format::Bitfield<32> getMemoryPropertyFlagsStr (VkMemoryPropertyFlags value);
tcu::Format::Bitfield<32> getMemoryHeapFlagsStr (VkMemoryHeapFlags value);
+tcu::Format::Bitfield<32> getPipelineStageFlagsStr (VkPipelineStageFlags value);
tcu::Format::Bitfield<32> getImageAspectFlagsStr (VkImageAspectFlags value);
tcu::Format::Bitfield<32> getSparseImageFormatFlagsStr (VkSparseImageFormatFlags value);
tcu::Format::Bitfield<32> getSparseMemoryBindFlagsStr (VkSparseMemoryBindFlags value);
tcu::Format::Bitfield<32> getColorComponentFlagsStr (VkColorComponentFlags value);
tcu::Format::Bitfield<32> getDescriptorPoolCreateFlagsStr (VkDescriptorPoolCreateFlags value);
tcu::Format::Bitfield<32> getAttachmentDescriptionFlagsStr (VkAttachmentDescriptionFlags value);
-tcu::Format::Bitfield<32> getPipelineStageFlagsStr (VkPipelineStageFlags value);
tcu::Format::Bitfield<32> getAccessFlagsStr (VkAccessFlags value);
tcu::Format::Bitfield<32> getDependencyFlagsStr (VkDependencyFlags value);
tcu::Format::Bitfield<32> getCommandPoolCreateFlagsStr (VkCommandPoolCreateFlags value);
tcu::Format::Bitfield<32> getPipelineShaderStageCreateFlagsStr (VkPipelineShaderStageCreateFlags value);
tcu::Format::Bitfield<32> getPipelineVertexInputStateCreateFlagsStr (VkPipelineVertexInputStateCreateFlags value);
tcu::Format::Bitfield<32> getPipelineInputAssemblyStateCreateFlagsStr (VkPipelineInputAssemblyStateCreateFlags value);
-tcu::Format::Bitfield<32> getPipelineTesselationStateCreateFlagsStr (VkPipelineTesselationStateCreateFlags value);
+tcu::Format::Bitfield<32> getPipelineTessellationStateCreateFlagsStr (VkPipelineTessellationStateCreateFlags value);
tcu::Format::Bitfield<32> getPipelineViewportStateCreateFlagsStr (VkPipelineViewportStateCreateFlags value);
tcu::Format::Bitfield<32> getPipelineRasterizationStateCreateFlagsStr (VkPipelineRasterizationStateCreateFlags value);
tcu::Format::Bitfield<32> getPipelineMultisampleStateCreateFlagsStr (VkPipelineMultisampleStateCreateFlags value);
tcu::Format::Bitfield<32> getSwapchainCreateFlagsKHRStr (VkSwapchainCreateFlagsKHR value);
tcu::Format::Bitfield<32> getDisplayModeCreateFlagsKHRStr (VkDisplayModeCreateFlagsKHR value);
tcu::Format::Bitfield<32> getDisplaySurfaceCreateFlagsKHRStr (VkDisplaySurfaceCreateFlagsKHR value);
+tcu::Format::Bitfield<32> getXlibSurfaceCreateFlagsKHRStr (VkXlibSurfaceCreateFlagsKHR value);
+tcu::Format::Bitfield<32> getXcbSurfaceCreateFlagsKHRStr (VkXcbSurfaceCreateFlagsKHR value);
+tcu::Format::Bitfield<32> getWaylandSurfaceCreateFlagsKHRStr (VkWaylandSurfaceCreateFlagsKHR value);
+tcu::Format::Bitfield<32> getMirSurfaceCreateFlagsKHRStr (VkMirSurfaceCreateFlagsKHR value);
+tcu::Format::Bitfield<32> getAndroidSurfaceCreateFlagsKHRStr (VkAndroidSurfaceCreateFlagsKHR value);
+tcu::Format::Bitfield<32> getWin32SurfaceCreateFlagsKHRStr (VkWin32SurfaceCreateFlagsKHR value);
std::ostream& operator<< (std::ostream& s, const VkApplicationInfo& value);
std::ostream& operator<< (std::ostream& s, const VkInstanceCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkRenderPassCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkCommandPoolCreateInfo& value);
std::ostream& operator<< (std::ostream& s, const VkCommandBufferAllocateInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkCommandBufferInheritanceInfo& value);
std::ostream& operator<< (std::ostream& s, const VkCommandBufferBeginInfo& value);
std::ostream& operator<< (std::ostream& s, const VkBufferCopy& value);
std::ostream& operator<< (std::ostream& s, const VkImageSubresourceLayers& value);
std::ostream& operator<< (std::ostream& s, const VkClearAttachment& value);
std::ostream& operator<< (std::ostream& s, const VkClearRect& value);
std::ostream& operator<< (std::ostream& s, const VkImageResolve& value);
-std::ostream& operator<< (std::ostream& s, const VkRenderPassBeginInfo& value);
+std::ostream& operator<< (std::ostream& s, const VkMemoryBarrier& value);
std::ostream& operator<< (std::ostream& s, const VkBufferMemoryBarrier& value);
+std::ostream& operator<< (std::ostream& s, const VkImageMemoryBarrier& value);
+std::ostream& operator<< (std::ostream& s, const VkRenderPassBeginInfo& value);
std::ostream& operator<< (std::ostream& s, const VkDispatchIndirectCommand& value);
std::ostream& operator<< (std::ostream& s, const VkDrawIndexedIndirectCommand& value);
std::ostream& operator<< (std::ostream& s, const VkDrawIndirectCommand& value);
-std::ostream& operator<< (std::ostream& s, const VkImageMemoryBarrier& value);
-std::ostream& operator<< (std::ostream& s, const VkMemoryBarrier& value);
-std::ostream& operator<< (std::ostream& s, const VkSurfaceCapabilitiesKHR& value);
-std::ostream& operator<< (std::ostream& s, const VkSurfaceFormatKHR& value);
-std::ostream& operator<< (std::ostream& s, const VkSwapchainCreateInfoKHR& value);
-std::ostream& operator<< (std::ostream& s, const VkPresentInfoKHR& value);
-std::ostream& operator<< (std::ostream& s, const VkDisplayPropertiesKHR& value);
-std::ostream& operator<< (std::ostream& s, const VkDisplayModeParametersKHR& value);
-std::ostream& operator<< (std::ostream& s, const VkDisplayModePropertiesKHR& value);
-std::ostream& operator<< (std::ostream& s, const VkDisplayModeCreateInfoKHR& value);
-std::ostream& operator<< (std::ostream& s, const VkDisplayPlaneCapabilitiesKHR& value);
-std::ostream& operator<< (std::ostream& s, const VkDisplayPlanePropertiesKHR& value);
-std::ostream& operator<< (std::ostream& s, const VkDisplaySurfaceCreateInfoKHR& value);
-std::ostream& operator<< (std::ostream& s, const VkDisplayPresentInfoKHR& value);
template<> const char* getTypeName<VkDisplayKHR> (void) { return "VkDisplayKHR"; }
template<> const char* getTypeName<VkDisplayModeKHR> (void) { return "VkDisplayModeKHR"; }
+const char* getPipelineCacheHeaderVersionName (VkPipelineCacheHeaderVersion value)
+{
+ switch (value)
+ {
+ case VK_PIPELINE_CACHE_HEADER_VERSION_ONE: return "VK_PIPELINE_CACHE_HEADER_VERSION_ONE";
+ default: return DE_NULL;
+ }
+}
+
const char* getResultName (VkResult value)
{
switch (value)
case VK_ERROR_OUT_OF_DATE_KHR: return "VK_ERROR_OUT_OF_DATE_KHR";
case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR";
case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";
+ case VK_ERROR_VALIDATION_FAILED_EXT: return "VK_ERROR_VALIDATION_FAILED_EXT";
default: return DE_NULL;
}
}
case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: return "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO";
case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO";
+ case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO";
case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO";
case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: return "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO";
case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR";
case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR";
case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: return "VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR";
+ case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR";
+ case VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT";
default: return DE_NULL;
}
}
{
switch (value)
{
- case VK_SAMPLER_MIPMAP_MODE_BASE: return "VK_SAMPLER_MIPMAP_MODE_BASE";
case VK_SAMPLER_MIPMAP_MODE_NEAREST: return "VK_SAMPLER_MIPMAP_MODE_NEAREST";
case VK_SAMPLER_MIPMAP_MODE_LINEAR: return "VK_SAMPLER_MIPMAP_MODE_LINEAR";
default: return DE_NULL;
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
+tcu::Format::Bitfield<32> getPipelineStageFlagsStr (VkPipelineStageFlags value)
+{
+ static const tcu::Format::BitDesc s_desc[] =
+ {
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, "VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, "VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, "VK_PIPELINE_STAGE_VERTEX_INPUT_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, "VK_PIPELINE_STAGE_VERTEX_SHADER_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, "VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, "VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, "VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, "VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, "VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, "VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, "VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, "VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_TRANSFER_BIT, "VK_PIPELINE_STAGE_TRANSFER_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, "VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_HOST_BIT, "VK_PIPELINE_STAGE_HOST_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, "VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT"),
+ tcu::Format::BitDesc(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, "VK_PIPELINE_STAGE_ALL_COMMANDS_BIT"),
+ };
+ return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
tcu::Format::Bitfield<32> getImageAspectFlagsStr (VkImageAspectFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_QUERY_RESULT_DEFAULT, "VK_QUERY_RESULT_DEFAULT"),
tcu::Format::BitDesc(VK_QUERY_RESULT_64_BIT, "VK_QUERY_RESULT_64_BIT"),
tcu::Format::BitDesc(VK_QUERY_RESULT_WAIT_BIT, "VK_QUERY_RESULT_WAIT_BIT"),
tcu::Format::BitDesc(VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, "VK_QUERY_RESULT_WITH_AVAILABILITY_BIT"),
return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
}
-tcu::Format::Bitfield<32> getPipelineStageFlagsStr (VkPipelineStageFlags value)
-{
- static const tcu::Format::BitDesc s_desc[] =
- {
- tcu::Format::BitDesc(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, "VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, "VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, "VK_PIPELINE_STAGE_VERTEX_INPUT_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, "VK_PIPELINE_STAGE_VERTEX_SHADER_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, "VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, "VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, "VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, "VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, "VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, "VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, "VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, "VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_STAGE_TRANSFER_BIT, "VK_PIPELINE_STAGE_TRANSFER_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_STAGE_HOST_BIT, "VK_PIPELINE_STAGE_HOST_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, "VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT"),
- tcu::Format::BitDesc(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, "VK_PIPELINE_STAGE_ALL_COMMANDS_BIT"),
- };
- return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
-}
-
tcu::Format::Bitfield<32> getAccessFlagsStr (VkAccessFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_STENCIL_FACE_NONE, "VK_STENCIL_FACE_NONE"),
tcu::Format::BitDesc(VK_STENCIL_FACE_FRONT_BIT, "VK_STENCIL_FACE_FRONT_BIT"),
tcu::Format::BitDesc(VK_STENCIL_FACE_BACK_BIT, "VK_STENCIL_FACE_BACK_BIT"),
tcu::Format::BitDesc(VK_STENCIL_FRONT_AND_BACK, "VK_STENCIL_FRONT_AND_BACK"),
{
static const tcu::Format::BitDesc s_desc[] =
{
- tcu::Format::BitDesc(VK_SURFACE_TRANSFORM_NONE_BIT_KHR, "VK_SURFACE_TRANSFORM_NONE_BIT_KHR"),
+ tcu::Format::BitDesc(VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, "VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR"),
tcu::Format::BitDesc(VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR, "VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR"),
tcu::Format::BitDesc(VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR, "VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR"),
tcu::Format::BitDesc(VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR, "VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR"),
return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
}
-tcu::Format::Bitfield<32> getPipelineTesselationStateCreateFlagsStr (VkPipelineTesselationStateCreateFlags value)
+tcu::Format::Bitfield<32> getPipelineTessellationStateCreateFlagsStr (VkPipelineTessellationStateCreateFlags value)
{
return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
}
return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
}
+tcu::Format::Bitfield<32> getXlibSurfaceCreateFlagsKHRStr (VkXlibSurfaceCreateFlagsKHR value)
+{
+ return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
+}
+
+tcu::Format::Bitfield<32> getXcbSurfaceCreateFlagsKHRStr (VkXcbSurfaceCreateFlagsKHR value)
+{
+ return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
+}
+
+tcu::Format::Bitfield<32> getWaylandSurfaceCreateFlagsKHRStr (VkWaylandSurfaceCreateFlagsKHR value)
+{
+ return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
+}
+
+tcu::Format::Bitfield<32> getMirSurfaceCreateFlagsKHRStr (VkMirSurfaceCreateFlagsKHR value)
+{
+ return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
+}
+
+tcu::Format::Bitfield<32> getAndroidSurfaceCreateFlagsKHRStr (VkAndroidSurfaceCreateFlagsKHR value)
+{
+ return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
+}
+
+tcu::Format::Bitfield<32> getWin32SurfaceCreateFlagsKHRStr (VkWin32SurfaceCreateFlagsKHR value)
+{
+ return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
+}
+
std::ostream& operator<< (std::ostream& s, const VkApplicationInfo& value)
{
s << "VkApplicationInfo = {\n";
s << "\tpNext = " << value.pNext << '\n';
s << "\tflags = " << getInstanceCreateFlagsStr(value.flags) << '\n';
s << "\tpApplicationInfo = " << value.pApplicationInfo << '\n';
- s << "\tenabledLayerNameCount = " << value.enabledLayerNameCount << '\n';
+ s << "\tenabledLayerCount = " << value.enabledLayerCount << '\n';
s << "\tppEnabledLayerNames = " << value.ppEnabledLayerNames << '\n';
- s << "\tenabledExtensionNameCount = " << value.enabledExtensionNameCount << '\n';
+ s << "\tenabledExtensionCount = " << value.enabledExtensionCount << '\n';
s << "\tppEnabledExtensionNames = " << value.ppEnabledExtensionNames << '\n';
s << '}';
return s;
s << "\tdualSrcBlend = " << value.dualSrcBlend << '\n';
s << "\tlogicOp = " << value.logicOp << '\n';
s << "\tmultiDrawIndirect = " << value.multiDrawIndirect << '\n';
+ s << "\tdrawIndirectFirstInstance = " << value.drawIndirectFirstInstance << '\n';
s << "\tdepthClamp = " << value.depthClamp << '\n';
s << "\tdepthBiasClamp = " << value.depthBiasClamp << '\n';
s << "\tfillModeNonSolid = " << value.fillModeNonSolid << '\n';
s << "\tsparseResidency16Samples = " << value.sparseResidency16Samples << '\n';
s << "\tsparseResidencyAliased = " << value.sparseResidencyAliased << '\n';
s << "\tvariableMultisampleRate = " << value.variableMultisampleRate << '\n';
+ s << "\tinheritedQueries = " << value.inheritedQueries << '\n';
s << '}';
return s;
}
s << "\tsampledImageStencilSampleCounts = " << getSampleCountFlagsStr(value.sampledImageStencilSampleCounts) << '\n';
s << "\tstorageImageSampleCounts = " << getSampleCountFlagsStr(value.storageImageSampleCounts) << '\n';
s << "\tmaxSampleMaskWords = " << value.maxSampleMaskWords << '\n';
+ s << "\ttimestampComputeAndGraphics = " << value.timestampComputeAndGraphics << '\n';
s << "\ttimestampPeriod = " << value.timestampPeriod << '\n';
s << "\tmaxClipDistances = " << value.maxClipDistances << '\n';
s << "\tmaxCullDistances = " << value.maxCullDistances << '\n';
s << "\tflags = " << getDeviceCreateFlagsStr(value.flags) << '\n';
s << "\tqueueCreateInfoCount = " << value.queueCreateInfoCount << '\n';
s << "\tpQueueCreateInfos = " << value.pQueueCreateInfos << '\n';
- s << "\tenabledLayerNameCount = " << value.enabledLayerNameCount << '\n';
+ s << "\tenabledLayerCount = " << value.enabledLayerCount << '\n';
s << "\tppEnabledLayerNames = " << value.ppEnabledLayerNames << '\n';
- s << "\tenabledExtensionNameCount = " << value.enabledExtensionNameCount << '\n';
+ s << "\tenabledExtensionCount = " << value.enabledExtensionCount << '\n';
s << "\tppEnabledExtensionNames = " << value.ppEnabledExtensionNames << '\n';
s << "\tpEnabledFeatures = " << value.pEnabledFeatures << '\n';
s << '}';
s << "\tpNext = " << value.pNext << '\n';
s << "\twaitSemaphoreCount = " << value.waitSemaphoreCount << '\n';
s << "\tpWaitSemaphores = " << value.pWaitSemaphores << '\n';
+ s << "\tpWaitDstStageMask = " << value.pWaitDstStageMask << '\n';
s << "\tcommandBufferCount = " << value.commandBufferCount << '\n';
s << "\tpCommandBuffers = " << value.pCommandBuffers << '\n';
s << "\tsignalSemaphoreCount = " << value.signalSemaphoreCount << '\n';
{
s << "VkSparseImageMemoryRequirements = {\n";
s << "\tformatProperties = " << value.formatProperties << '\n';
- s << "\timageMipTailStartLod = " << value.imageMipTailStartLod << '\n';
+ s << "\timageMipTailFirstLod = " << value.imageMipTailFirstLod << '\n';
s << "\timageMipTailSize = " << value.imageMipTailSize << '\n';
s << "\timageMipTailOffset = " << value.imageMipTailOffset << '\n';
s << "\timageMipTailStride = " << value.imageMipTailStride << '\n';
s << "\tpNext = " << value.pNext << '\n';
s << "\tflags = " << getQueryPoolCreateFlagsStr(value.flags) << '\n';
s << "\tqueryType = " << value.queryType << '\n';
- s << "\tentryCount = " << value.entryCount << '\n';
+ s << "\tqueryCount = " << value.queryCount << '\n';
s << "\tpipelineStatistics = " << getQueryPipelineStatisticFlagsStr(value.pipelineStatistics) << '\n';
s << '}';
return s;
s << "\toffset = " << value.offset << '\n';
s << "\tsize = " << value.size << '\n';
s << "\trowPitch = " << value.rowPitch << '\n';
+ s << "\tarrayPitch = " << value.arrayPitch << '\n';
s << "\tdepthPitch = " << value.depthPitch << '\n';
s << '}';
return s;
s << "VkPipelineTessellationStateCreateInfo = {\n";
s << "\tsType = " << value.sType << '\n';
s << "\tpNext = " << value.pNext << '\n';
- s << "\tflags = " << getPipelineTesselationStateCreateFlagsStr(value.flags) << '\n';
+ s << "\tflags = " << getPipelineTessellationStateCreateFlagsStr(value.flags) << '\n';
s << "\tpatchControlPoints = " << value.patchControlPoints << '\n';
s << '}';
return s;
s << "\taddressModeV = " << value.addressModeV << '\n';
s << "\taddressModeW = " << value.addressModeW << '\n';
s << "\tmipLodBias = " << value.mipLodBias << '\n';
+ s << "\tanisotropyEnable = " << value.anisotropyEnable << '\n';
s << "\tmaxAnisotropy = " << value.maxAnisotropy << '\n';
s << "\tcompareEnable = " << value.compareEnable << '\n';
s << "\tcompareOp = " << value.compareOp << '\n';
s << "\tpNext = " << value.pNext << '\n';
s << "\tflags = " << getDescriptorSetLayoutCreateFlagsStr(value.flags) << '\n';
s << "\tbindingCount = " << value.bindingCount << '\n';
- s << "\tpBinding = " << value.pBinding << '\n';
+ s << "\tpBindings = " << value.pBindings << '\n';
s << '}';
return s;
}
s << "\tsType = " << value.sType << '\n';
s << "\tpNext = " << value.pNext << '\n';
s << "\tdescriptorPool = " << value.descriptorPool << '\n';
- s << "\tsetLayoutCount = " << value.setLayoutCount << '\n';
+ s << "\tdescriptorSetCount = " << value.descriptorSetCount << '\n';
s << "\tpSetLayouts = " << value.pSetLayouts << '\n';
s << '}';
return s;
s << "\tpNext = " << value.pNext << '\n';
s << "\tcommandPool = " << value.commandPool << '\n';
s << "\tlevel = " << value.level << '\n';
- s << "\tbufferCount = " << value.bufferCount << '\n';
+ s << "\tcommandBufferCount = " << value.commandBufferCount << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkCommandBufferBeginInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkCommandBufferInheritanceInfo& value)
{
- s << "VkCommandBufferBeginInfo = {\n";
+ s << "VkCommandBufferInheritanceInfo = {\n";
s << "\tsType = " << value.sType << '\n';
s << "\tpNext = " << value.pNext << '\n';
- s << "\tflags = " << getCommandBufferUsageFlagsStr(value.flags) << '\n';
s << "\trenderPass = " << value.renderPass << '\n';
s << "\tsubpass = " << value.subpass << '\n';
s << "\tframebuffer = " << value.framebuffer << '\n';
return s;
}
+std::ostream& operator<< (std::ostream& s, const VkCommandBufferBeginInfo& value)
+{
+ s << "VkCommandBufferBeginInfo = {\n";
+ s << "\tsType = " << value.sType << '\n';
+ s << "\tpNext = " << value.pNext << '\n';
+ s << "\tflags = " << getCommandBufferUsageFlagsStr(value.flags) << '\n';
+ s << "\tpInheritanceInfo = " << value.pInheritanceInfo << '\n';
+ s << '}';
+ return s;
+}
+
std::ostream& operator<< (std::ostream& s, const VkBufferCopy& value)
{
s << "VkBufferCopy = {\n";
{
s << "VkImageBlit = {\n";
s << "\tsrcSubresource = " << value.srcSubresource << '\n';
- s << "\tsrcOffset = " << value.srcOffset << '\n';
- s << "\tsrcExtent = " << value.srcExtent << '\n';
+ s << "\tsrcOffsets = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.srcOffsets), DE_ARRAY_END(value.srcOffsets)) << '\n';
s << "\tdstSubresource = " << value.dstSubresource << '\n';
- s << "\tdstOffset = " << value.dstOffset << '\n';
- s << "\tdstExtent = " << value.dstExtent << '\n';
+ s << "\tdstOffsets = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.dstOffsets), DE_ARRAY_END(value.dstOffsets)) << '\n';
s << '}';
return s;
}
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkRenderPassBeginInfo& value)
+std::ostream& operator<< (std::ostream& s, const VkMemoryBarrier& value)
{
- s << "VkRenderPassBeginInfo = {\n";
+ s << "VkMemoryBarrier = {\n";
s << "\tsType = " << value.sType << '\n';
s << "\tpNext = " << value.pNext << '\n';
- s << "\trenderPass = " << value.renderPass << '\n';
- s << "\tframebuffer = " << value.framebuffer << '\n';
- s << "\trenderArea = " << value.renderArea << '\n';
- s << "\tclearValueCount = " << value.clearValueCount << '\n';
- s << "\tpClearValues = " << value.pClearValues << '\n';
+ s << "\tsrcAccessMask = " << getAccessFlagsStr(value.srcAccessMask) << '\n';
+ s << "\tdstAccessMask = " << getAccessFlagsStr(value.dstAccessMask) << '\n';
s << '}';
return s;
}
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkDispatchIndirectCommand& value)
-{
- s << "VkDispatchIndirectCommand = {\n";
- s << "\tx = " << value.x << '\n';
- s << "\ty = " << value.y << '\n';
- s << "\tz = " << value.z << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkDrawIndexedIndirectCommand& value)
-{
- s << "VkDrawIndexedIndirectCommand = {\n";
- s << "\tindexCount = " << value.indexCount << '\n';
- s << "\tinstanceCount = " << value.instanceCount << '\n';
- s << "\tfirstIndex = " << value.firstIndex << '\n';
- s << "\tvertexOffset = " << value.vertexOffset << '\n';
- s << "\tfirstInstance = " << value.firstInstance << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkDrawIndirectCommand& value)
-{
- s << "VkDrawIndirectCommand = {\n";
- s << "\tvertexCount = " << value.vertexCount << '\n';
- s << "\tinstanceCount = " << value.instanceCount << '\n';
- s << "\tfirstVertex = " << value.firstVertex << '\n';
- s << "\tfirstInstance = " << value.firstInstance << '\n';
- s << '}';
- return s;
-}
-
std::ostream& operator<< (std::ostream& s, const VkImageMemoryBarrier& value)
{
s << "VkImageMemoryBarrier = {\n";
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkMemoryBarrier& value)
-{
- s << "VkMemoryBarrier = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tsrcAccessMask = " << getAccessFlagsStr(value.srcAccessMask) << '\n';
- s << "\tdstAccessMask = " << getAccessFlagsStr(value.dstAccessMask) << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkSurfaceCapabilitiesKHR& value)
-{
- s << "VkSurfaceCapabilitiesKHR = {\n";
- s << "\tminImageCount = " << value.minImageCount << '\n';
- s << "\tmaxImageCount = " << value.maxImageCount << '\n';
- s << "\tcurrentExtent = " << value.currentExtent << '\n';
- s << "\tminImageExtent = " << value.minImageExtent << '\n';
- s << "\tmaxImageExtent = " << value.maxImageExtent << '\n';
- s << "\tmaxImageArrayLayers = " << value.maxImageArrayLayers << '\n';
- s << "\tsupportedTransforms = " << getSurfaceTransformFlagsKHRStr(value.supportedTransforms) << '\n';
- s << "\tcurrentTransform = " << value.currentTransform << '\n';
- s << "\tsupportedCompositeAlpha = " << getCompositeAlphaFlagsKHRStr(value.supportedCompositeAlpha) << '\n';
- s << "\tsupportedUsageFlags = " << getImageUsageFlagsStr(value.supportedUsageFlags) << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkSurfaceFormatKHR& value)
-{
- s << "VkSurfaceFormatKHR = {\n";
- s << "\tformat = " << value.format << '\n';
- s << "\tcolorSpace = " << value.colorSpace << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkSwapchainCreateInfoKHR& value)
-{
- s << "VkSwapchainCreateInfoKHR = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tflags = " << getSwapchainCreateFlagsKHRStr(value.flags) << '\n';
- s << "\tsurface = " << value.surface << '\n';
- s << "\tminImageCount = " << value.minImageCount << '\n';
- s << "\timageFormat = " << value.imageFormat << '\n';
- s << "\timageColorSpace = " << value.imageColorSpace << '\n';
- s << "\timageExtent = " << value.imageExtent << '\n';
- s << "\timageArrayLayers = " << value.imageArrayLayers << '\n';
- s << "\timageUsage = " << getImageUsageFlagsStr(value.imageUsage) << '\n';
- s << "\timageSharingMode = " << value.imageSharingMode << '\n';
- s << "\tqueueFamilyIndexCount = " << value.queueFamilyIndexCount << '\n';
- s << "\tpQueueFamilyIndices = " << value.pQueueFamilyIndices << '\n';
- s << "\tpreTransform = " << value.preTransform << '\n';
- s << "\tcompositeAlpha = " << value.compositeAlpha << '\n';
- s << "\tpresentMode = " << value.presentMode << '\n';
- s << "\tclipped = " << value.clipped << '\n';
- s << "\toldSwapchain = " << value.oldSwapchain << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkPresentInfoKHR& value)
-{
- s << "VkPresentInfoKHR = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\twaitSemaphoreCount = " << value.waitSemaphoreCount << '\n';
- s << "\tpWaitSemaphores = " << value.pWaitSemaphores << '\n';
- s << "\tswapchainCount = " << value.swapchainCount << '\n';
- s << "\tpSwapchains = " << value.pSwapchains << '\n';
- s << "\tpImageIndices = " << value.pImageIndices << '\n';
- s << "\tpResults = " << value.pResults << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkDisplayPropertiesKHR& value)
-{
- s << "VkDisplayPropertiesKHR = {\n";
- s << "\tdisplay = " << value.display << '\n';
- s << "\tdisplayName = " << getCharPtrStr(value.displayName) << '\n';
- s << "\tphysicalDimensions = " << value.physicalDimensions << '\n';
- s << "\tphysicalResolution = " << value.physicalResolution << '\n';
- s << "\tsupportedTransforms = " << getSurfaceTransformFlagsKHRStr(value.supportedTransforms) << '\n';
- s << "\tplaneReorderPossible = " << value.planeReorderPossible << '\n';
- s << "\tpersistentContent = " << value.persistentContent << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkDisplayModeParametersKHR& value)
-{
- s << "VkDisplayModeParametersKHR = {\n";
- s << "\tvisibleRegion = " << value.visibleRegion << '\n';
- s << "\trefreshRate = " << value.refreshRate << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkDisplayModePropertiesKHR& value)
-{
- s << "VkDisplayModePropertiesKHR = {\n";
- s << "\tdisplayMode = " << value.displayMode << '\n';
- s << "\tparameters = " << value.parameters << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkDisplayModeCreateInfoKHR& value)
+std::ostream& operator<< (std::ostream& s, const VkRenderPassBeginInfo& value)
{
- s << "VkDisplayModeCreateInfoKHR = {\n";
+ s << "VkRenderPassBeginInfo = {\n";
s << "\tsType = " << value.sType << '\n';
s << "\tpNext = " << value.pNext << '\n';
- s << "\tflags = " << getDisplayModeCreateFlagsKHRStr(value.flags) << '\n';
- s << "\tparameters = " << value.parameters << '\n';
- s << '}';
- return s;
-}
-
-std::ostream& operator<< (std::ostream& s, const VkDisplayPlaneCapabilitiesKHR& value)
-{
- s << "VkDisplayPlaneCapabilitiesKHR = {\n";
- s << "\tsupportedAlpha = " << getDisplayPlaneAlphaFlagsKHRStr(value.supportedAlpha) << '\n';
- s << "\tminSrcPosition = " << value.minSrcPosition << '\n';
- s << "\tmaxSrcPosition = " << value.maxSrcPosition << '\n';
- s << "\tminSrcExtent = " << value.minSrcExtent << '\n';
- s << "\tmaxSrcExtent = " << value.maxSrcExtent << '\n';
- s << "\tminDstPosition = " << value.minDstPosition << '\n';
- s << "\tmaxDstPosition = " << value.maxDstPosition << '\n';
- s << "\tminDstExtent = " << value.minDstExtent << '\n';
- s << "\tmaxDstExtent = " << value.maxDstExtent << '\n';
+ s << "\trenderPass = " << value.renderPass << '\n';
+ s << "\tframebuffer = " << value.framebuffer << '\n';
+ s << "\trenderArea = " << value.renderArea << '\n';
+ s << "\tclearValueCount = " << value.clearValueCount << '\n';
+ s << "\tpClearValues = " << value.pClearValues << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkDisplayPlanePropertiesKHR& value)
+std::ostream& operator<< (std::ostream& s, const VkDispatchIndirectCommand& value)
{
- s << "VkDisplayPlanePropertiesKHR = {\n";
- s << "\tcurrentDisplay = " << value.currentDisplay << '\n';
- s << "\tcurrentStackIndex = " << value.currentStackIndex << '\n';
+ s << "VkDispatchIndirectCommand = {\n";
+ s << "\tx = " << value.x << '\n';
+ s << "\ty = " << value.y << '\n';
+ s << "\tz = " << value.z << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkDisplaySurfaceCreateInfoKHR& value)
+std::ostream& operator<< (std::ostream& s, const VkDrawIndexedIndirectCommand& value)
{
- s << "VkDisplaySurfaceCreateInfoKHR = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tflags = " << getDisplaySurfaceCreateFlagsKHRStr(value.flags) << '\n';
- s << "\tdisplayMode = " << value.displayMode << '\n';
- s << "\tplaneIndex = " << value.planeIndex << '\n';
- s << "\tplaneStackIndex = " << value.planeStackIndex << '\n';
- s << "\ttransform = " << value.transform << '\n';
- s << "\tglobalAlpha = " << value.globalAlpha << '\n';
- s << "\talphaMode = " << value.alphaMode << '\n';
- s << "\timageExtent = " << value.imageExtent << '\n';
+ s << "VkDrawIndexedIndirectCommand = {\n";
+ s << "\tindexCount = " << value.indexCount << '\n';
+ s << "\tinstanceCount = " << value.instanceCount << '\n';
+ s << "\tfirstIndex = " << value.firstIndex << '\n';
+ s << "\tvertexOffset = " << value.vertexOffset << '\n';
+ s << "\tfirstInstance = " << value.firstInstance << '\n';
s << '}';
return s;
}
-std::ostream& operator<< (std::ostream& s, const VkDisplayPresentInfoKHR& value)
+std::ostream& operator<< (std::ostream& s, const VkDrawIndirectCommand& value)
{
- s << "VkDisplayPresentInfoKHR = {\n";
- s << "\tsType = " << value.sType << '\n';
- s << "\tpNext = " << value.pNext << '\n';
- s << "\tsrcRect = " << value.srcRect << '\n';
- s << "\tdstRect = " << value.dstRect << '\n';
- s << "\tpersistent = " << value.persistent << '\n';
+ s << "VkDrawIndirectCommand = {\n";
+ s << "\tvertexCount = " << value.vertexCount << '\n';
+ s << "\tinstanceCount = " << value.instanceCount << '\n';
+ s << "\tfirstVertex = " << value.firstVertex << '\n';
+ s << "\tfirstInstance = " << value.firstInstance << '\n';
s << '}';
return s;
}
const void* pNext;
VkInstanceCreateFlags flags;
const VkApplicationInfo* pApplicationInfo;
- deUint32 enabledLayerNameCount;
+ deUint32 enabledLayerCount;
const char* const* ppEnabledLayerNames;
- deUint32 enabledExtensionNameCount;
+ deUint32 enabledExtensionCount;
const char* const* ppEnabledExtensionNames;
};
VkBool32 dualSrcBlend;
VkBool32 logicOp;
VkBool32 multiDrawIndirect;
+ VkBool32 drawIndirectFirstInstance;
VkBool32 depthClamp;
VkBool32 depthBiasClamp;
VkBool32 fillModeNonSolid;
VkBool32 sparseResidency16Samples;
VkBool32 sparseResidencyAliased;
VkBool32 variableMultisampleRate;
+ VkBool32 inheritedQueries;
};
struct VkFormatProperties
struct VkExtent3D
{
- deInt32 width;
- deInt32 height;
- deInt32 depth;
+ deUint32 width;
+ deUint32 height;
+ deUint32 depth;
};
struct VkImageFormatProperties
VkSampleCountFlags sampledImageStencilSampleCounts;
VkSampleCountFlags storageImageSampleCounts;
deUint32 maxSampleMaskWords;
+ VkBool32 timestampComputeAndGraphics;
float timestampPeriod;
deUint32 maxClipDistances;
deUint32 maxCullDistances;
VkDeviceCreateFlags flags;
deUint32 queueCreateInfoCount;
const VkDeviceQueueCreateInfo* pQueueCreateInfos;
- deUint32 enabledLayerNameCount;
+ deUint32 enabledLayerCount;
const char* const* ppEnabledLayerNames;
- deUint32 enabledExtensionNameCount;
+ deUint32 enabledExtensionCount;
const char* const* ppEnabledExtensionNames;
const VkPhysicalDeviceFeatures* pEnabledFeatures;
};
struct VkSubmitInfo
{
- VkStructureType sType;
- const void* pNext;
- deUint32 waitSemaphoreCount;
- const VkSemaphore* pWaitSemaphores;
- deUint32 commandBufferCount;
- const VkCommandBuffer* pCommandBuffers;
- deUint32 signalSemaphoreCount;
- const VkSemaphore* pSignalSemaphores;
+ VkStructureType sType;
+ const void* pNext;
+ deUint32 waitSemaphoreCount;
+ const VkSemaphore* pWaitSemaphores;
+ const VkPipelineStageFlags* pWaitDstStageMask;
+ deUint32 commandBufferCount;
+ const VkCommandBuffer* pCommandBuffers;
+ deUint32 signalSemaphoreCount;
+ const VkSemaphore* pSignalSemaphores;
};
struct VkMemoryAllocateInfo
struct VkSparseImageMemoryRequirements
{
VkSparseImageFormatProperties formatProperties;
- deUint32 imageMipTailStartLod;
+ deUint32 imageMipTailFirstLod;
VkDeviceSize imageMipTailSize;
VkDeviceSize imageMipTailOffset;
VkDeviceSize imageMipTailStride;
const void* pNext;
VkQueryPoolCreateFlags flags;
VkQueryType queryType;
- deUint32 entryCount;
+ deUint32 queryCount;
VkQueryPipelineStatisticFlags pipelineStatistics;
};
VkDeviceSize offset;
VkDeviceSize size;
VkDeviceSize rowPitch;
+ VkDeviceSize arrayPitch;
VkDeviceSize depthPitch;
};
{
VkStructureType sType;
const void* pNext;
- VkPipelineTesselationStateCreateFlags flags;
+ VkPipelineTessellationStateCreateFlags flags;
deUint32 patchControlPoints;
};
struct VkExtent2D
{
- deInt32 width;
- deInt32 height;
+ deUint32 width;
+ deUint32 height;
};
struct VkRect2D
VkSamplerAddressMode addressModeV;
VkSamplerAddressMode addressModeW;
float mipLodBias;
+ VkBool32 anisotropyEnable;
float maxAnisotropy;
VkBool32 compareEnable;
VkCompareOp compareOp;
const void* pNext;
VkDescriptorSetLayoutCreateFlags flags;
deUint32 bindingCount;
- const VkDescriptorSetLayoutBinding* pBinding;
+ const VkDescriptorSetLayoutBinding* pBindings;
};
struct VkDescriptorPoolSize
VkStructureType sType;
const void* pNext;
VkDescriptorPool descriptorPool;
- deUint32 setLayoutCount;
+ deUint32 descriptorSetCount;
const VkDescriptorSetLayout* pSetLayouts;
};
const VkAttachmentReference* pResolveAttachments;
const VkAttachmentReference* pDepthStencilAttachment;
deUint32 preserveAttachmentCount;
- const VkAttachmentReference* pPreserveAttachments;
+ const deUint32* pPreserveAttachments;
};
struct VkSubpassDependency
const void* pNext;
VkCommandPool commandPool;
VkCommandBufferLevel level;
- deUint32 bufferCount;
+ deUint32 commandBufferCount;
};
-struct VkCommandBufferBeginInfo
+struct VkCommandBufferInheritanceInfo
{
VkStructureType sType;
const void* pNext;
- VkCommandBufferUsageFlags flags;
VkRenderPass renderPass;
deUint32 subpass;
VkFramebuffer framebuffer;
VkQueryPipelineStatisticFlags pipelineStatistics;
};
+struct VkCommandBufferBeginInfo
+{
+ VkStructureType sType;
+ const void* pNext;
+ VkCommandBufferUsageFlags flags;
+ const VkCommandBufferInheritanceInfo* pInheritanceInfo;
+};
+
struct VkBufferCopy
{
VkDeviceSize srcOffset;
struct VkImageBlit
{
VkImageSubresourceLayers srcSubresource;
- VkOffset3D srcOffset;
- VkExtent3D srcExtent;
+ VkOffset3D srcOffsets[2];
VkImageSubresourceLayers dstSubresource;
- VkOffset3D dstOffset;
- VkExtent3D dstExtent;
+ VkOffset3D dstOffsets[2];
};
struct VkBufferImageCopy
VkExtent3D extent;
};
-struct VkRenderPassBeginInfo
+struct VkMemoryBarrier
{
- VkStructureType sType;
- const void* pNext;
- VkRenderPass renderPass;
- VkFramebuffer framebuffer;
- VkRect2D renderArea;
- deUint32 clearValueCount;
- const VkClearValue* pClearValues;
+ VkStructureType sType;
+ const void* pNext;
+ VkAccessFlags srcAccessMask;
+ VkAccessFlags dstAccessMask;
};
struct VkBufferMemoryBarrier
VkDeviceSize size;
};
-struct VkDispatchIndirectCommand
-{
- deUint32 x;
- deUint32 y;
- deUint32 z;
-};
-
-struct VkDrawIndexedIndirectCommand
-{
- deUint32 indexCount;
- deUint32 instanceCount;
- deUint32 firstIndex;
- deInt32 vertexOffset;
- deUint32 firstInstance;
-};
-
-struct VkDrawIndirectCommand
-{
- deUint32 vertexCount;
- deUint32 instanceCount;
- deUint32 firstVertex;
- deUint32 firstInstance;
-};
-
struct VkImageMemoryBarrier
{
VkStructureType sType;
VkImageSubresourceRange subresourceRange;
};
-struct VkMemoryBarrier
-{
- VkStructureType sType;
- const void* pNext;
- VkAccessFlags srcAccessMask;
- VkAccessFlags dstAccessMask;
-};
-
-struct VkSurfaceCapabilitiesKHR
-{
- deUint32 minImageCount;
- deUint32 maxImageCount;
- VkExtent2D currentExtent;
- VkExtent2D minImageExtent;
- VkExtent2D maxImageExtent;
- deUint32 maxImageArrayLayers;
- VkSurfaceTransformFlagsKHR supportedTransforms;
- VkSurfaceTransformFlagBitsKHR currentTransform;
- VkCompositeAlphaFlagsKHR supportedCompositeAlpha;
- VkImageUsageFlags supportedUsageFlags;
-};
-
-struct VkSurfaceFormatKHR
-{
- VkFormat format;
- VkColorSpaceKHR colorSpace;
-};
-
-struct VkSwapchainCreateInfoKHR
-{
- VkStructureType sType;
- const void* pNext;
- VkSwapchainCreateFlagsKHR flags;
- VkSurfaceKHR surface;
- deUint32 minImageCount;
- VkFormat imageFormat;
- VkColorSpaceKHR imageColorSpace;
- VkExtent2D imageExtent;
- deUint32 imageArrayLayers;
- VkImageUsageFlags imageUsage;
- VkSharingMode imageSharingMode;
- deUint32 queueFamilyIndexCount;
- const deUint32* pQueueFamilyIndices;
- VkSurfaceTransformFlagBitsKHR preTransform;
- VkCompositeAlphaFlagBitsKHR compositeAlpha;
- VkPresentModeKHR presentMode;
- VkBool32 clipped;
- VkSwapchainKHR oldSwapchain;
-};
-
-struct VkPresentInfoKHR
-{
- VkStructureType sType;
- const void* pNext;
- deUint32 waitSemaphoreCount;
- const VkSemaphore* pWaitSemaphores;
- deUint32 swapchainCount;
- const VkSwapchainKHR* pSwapchains;
- const deUint32* pImageIndices;
- VkResult* pResults;
-};
-
-struct VkDisplayPropertiesKHR
-{
- VkDisplayKHR display;
- const char* displayName;
- VkExtent2D physicalDimensions;
- VkExtent2D physicalResolution;
- VkSurfaceTransformFlagsKHR supportedTransforms;
- VkBool32 planeReorderPossible;
- VkBool32 persistentContent;
-};
-
-struct VkDisplayModeParametersKHR
-{
- VkExtent2D visibleRegion;
- deUint32 refreshRate;
-};
-
-struct VkDisplayModePropertiesKHR
-{
- VkDisplayModeKHR displayMode;
- VkDisplayModeParametersKHR parameters;
-};
-
-struct VkDisplayModeCreateInfoKHR
-{
- VkStructureType sType;
- const void* pNext;
- VkDisplayModeCreateFlagsKHR flags;
- VkDisplayModeParametersKHR parameters;
-};
-
-struct VkDisplayPlaneCapabilitiesKHR
+struct VkRenderPassBeginInfo
{
- VkDisplayPlaneAlphaFlagsKHR supportedAlpha;
- VkOffset2D minSrcPosition;
- VkOffset2D maxSrcPosition;
- VkExtent2D minSrcExtent;
- VkExtent2D maxSrcExtent;
- VkOffset2D minDstPosition;
- VkOffset2D maxDstPosition;
- VkExtent2D minDstExtent;
- VkExtent2D maxDstExtent;
+ VkStructureType sType;
+ const void* pNext;
+ VkRenderPass renderPass;
+ VkFramebuffer framebuffer;
+ VkRect2D renderArea;
+ deUint32 clearValueCount;
+ const VkClearValue* pClearValues;
};
-struct VkDisplayPlanePropertiesKHR
+struct VkDispatchIndirectCommand
{
- VkDisplayKHR currentDisplay;
- deUint32 currentStackIndex;
+ deUint32 x;
+ deUint32 y;
+ deUint32 z;
};
-struct VkDisplaySurfaceCreateInfoKHR
+struct VkDrawIndexedIndirectCommand
{
- VkStructureType sType;
- const void* pNext;
- VkDisplaySurfaceCreateFlagsKHR flags;
- VkDisplayModeKHR displayMode;
- deUint32 planeIndex;
- deUint32 planeStackIndex;
- VkSurfaceTransformFlagBitsKHR transform;
- float globalAlpha;
- VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
- VkExtent2D imageExtent;
+ deUint32 indexCount;
+ deUint32 instanceCount;
+ deUint32 firstIndex;
+ deInt32 vertexOffset;
+ deUint32 firstInstance;
};
-struct VkDisplayPresentInfoKHR
+struct VkDrawIndirectCommand
{
- VkStructureType sType;
- const void* pNext;
- VkRect2D srcRect;
- VkRect2D dstRect;
- VkBool32 persistent;
+ deUint32 vertexCount;
+ deUint32 instanceCount;
+ deUint32 firstVertex;
+ deUint32 firstInstance;
};
return res;
}
-inline VkExtent3D makeExtent3D (deInt32 width, deInt32 height, deInt32 depth)
+inline VkExtent3D makeExtent3D (deUint32 width, deUint32 height, deUint32 depth)
{
VkExtent3D res;
res.width = width;
return res;
}
-inline VkSubresourceLayout makeSubresourceLayout (VkDeviceSize offset, VkDeviceSize size, VkDeviceSize rowPitch, VkDeviceSize depthPitch)
+inline VkSubresourceLayout makeSubresourceLayout (VkDeviceSize offset, VkDeviceSize size, VkDeviceSize rowPitch, VkDeviceSize arrayPitch, VkDeviceSize depthPitch)
{
VkSubresourceLayout res;
res.offset = offset;
res.size = size;
res.rowPitch = rowPitch;
+ res.arrayPitch = arrayPitch;
res.depthPitch = depthPitch;
return res;
}
return res;
}
-inline VkExtent2D makeExtent2D (deInt32 width, deInt32 height)
+inline VkExtent2D makeExtent2D (deUint32 width, deUint32 height)
{
VkExtent2D res;
res.width = width;
return res;
}
-inline VkSubpassDescription makeSubpassDescription (VkSubpassDescriptionFlags flags, VkPipelineBindPoint pipelineBindPoint, deUint32 inputAttachmentCount, const VkAttachmentReference* pInputAttachments, deUint32 colorAttachmentCount, const VkAttachmentReference* pColorAttachments, const VkAttachmentReference* pResolveAttachments, const VkAttachmentReference* pDepthStencilAttachment, deUint32 preserveAttachmentCount, const VkAttachmentReference* pPreserveAttachments)
+inline VkSubpassDescription makeSubpassDescription (VkSubpassDescriptionFlags flags, VkPipelineBindPoint pipelineBindPoint, deUint32 inputAttachmentCount, const VkAttachmentReference* pInputAttachments, deUint32 colorAttachmentCount, const VkAttachmentReference* pColorAttachments, const VkAttachmentReference* pResolveAttachments, const VkAttachmentReference* pDepthStencilAttachment, deUint32 preserveAttachmentCount, const deUint32* pPreserveAttachments)
{
VkSubpassDescription res;
res.flags = flags;
res.firstInstance = firstInstance;
return res;
}
-
-inline VkSurfaceFormatKHR makeSurfaceFormatKHR (VkFormat format, VkColorSpaceKHR colorSpace)
-{
- VkSurfaceFormatKHR res;
- res.format = format;
- res.colorSpace = colorSpace;
- return res;
-}
-
-inline VkDisplayPlanePropertiesKHR makeDisplayPlanePropertiesKHR (VkDisplayKHR currentDisplay, deUint32 currentStackIndex)
-{
- VkDisplayPlanePropertiesKHR res;
- res.currentDisplay = currentDisplay;
- res.currentStackIndex = currentStackIndex;
- return res;
-}
virtual VkResult resetEvent (VkDevice device, VkEvent event) const = 0;
virtual VkResult createQueryPool (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) const = 0;
virtual void destroyQueryPool (VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) const = 0;
-virtual VkResult getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, deUintptr dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) const = 0;
+virtual VkResult getQueryPoolResults (VkDevice device, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, deUintptr dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) const = 0;
virtual VkResult createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) const = 0;
virtual void destroyBuffer (VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) const = 0;
virtual VkResult createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) const = 0;
virtual VkResult endCommandBuffer (VkCommandBuffer commandBuffer) const = 0;
virtual VkResult resetCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) const = 0;
virtual void cmdBindPipeline (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const = 0;
-virtual void cmdSetViewport (VkCommandBuffer commandBuffer, deUint32 viewportCount, const VkViewport* pViewports) const = 0;
-virtual void cmdSetScissor (VkCommandBuffer commandBuffer, deUint32 scissorCount, const VkRect2D* pScissors) const = 0;
+virtual void cmdSetViewport (VkCommandBuffer commandBuffer, deUint32 firstViewport, deUint32 viewportCount, const VkViewport* pViewports) const = 0;
+virtual void cmdSetScissor (VkCommandBuffer commandBuffer, deUint32 firstScissor, deUint32 scissorCount, const VkRect2D* pScissors) const = 0;
virtual void cmdSetLineWidth (VkCommandBuffer commandBuffer, float lineWidth) const = 0;
virtual void cmdSetDepthBias (VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) const = 0;
virtual void cmdSetBlendConstants (VkCommandBuffer commandBuffer, const float blendConstants[4]) const = 0;
virtual void cmdSetStencilReference (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, deUint32 reference) const = 0;
virtual void cmdBindDescriptorSets (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 firstSet, deUint32 descriptorSetCount, const VkDescriptorSet* pDescriptorSets, deUint32 dynamicOffsetCount, const deUint32* pDynamicOffsets) const = 0;
virtual void cmdBindIndexBuffer (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const = 0;
-virtual void cmdBindVertexBuffers (VkCommandBuffer commandBuffer, deUint32 startBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) const = 0;
+virtual void cmdBindVertexBuffers (VkCommandBuffer commandBuffer, deUint32 firstBinding, deUint32 bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) const = 0;
virtual void cmdDraw (VkCommandBuffer commandBuffer, deUint32 vertexCount, deUint32 instanceCount, deUint32 firstVertex, deUint32 firstInstance) const = 0;
virtual void cmdDrawIndexed (VkCommandBuffer commandBuffer, deUint32 indexCount, deUint32 instanceCount, deUint32 firstIndex, deInt32 vertexOffset, deUint32 firstInstance) const = 0;
virtual void cmdDrawIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, deUint32 drawCount, deUint32 stride) const = 0;
virtual void cmdResolveImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, deUint32 regionCount, const VkImageResolve* pRegions) const = 0;
virtual void cmdSetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const = 0;
virtual void cmdResetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const = 0;
-virtual void cmdWaitEvents (VkCommandBuffer commandBuffer, deUint32 eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, deUint32 memoryBarrierCount, const void* const* ppMemoryBarriers) const = 0;
-virtual void cmdPipelineBarrier (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, deUint32 memoryBarrierCount, const void* const* ppMemoryBarriers) const = 0;
-virtual void cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 entry, VkQueryControlFlags flags) const = 0;
-virtual void cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 entry) const = 0;
-virtual void cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount) const = 0;
-virtual void cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, deUint32 entry) const = 0;
-virtual void cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 startQuery, deUint32 queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) const = 0;
+virtual void cmdWaitEvents (VkCommandBuffer commandBuffer, deUint32 eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, deUint32 memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, deUint32 bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, deUint32 imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) const = 0;
+virtual void cmdPipelineBarrier (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, deUint32 memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, deUint32 bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, deUint32 imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) const = 0;
+virtual void cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query, VkQueryControlFlags flags) const = 0;
+virtual void cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 query) const = 0;
+virtual void cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount) const = 0;
+virtual void cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, deUint32 query) const = 0;
+virtual void cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, deUint32 firstQuery, deUint32 queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) const = 0;
virtual void cmdPushConstants (VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, deUint32 offset, deUint32 size, const void* pValues) const = 0;
virtual void cmdBeginRenderPass (VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) const = 0;
virtual void cmdNextSubpass (VkCommandBuffer commandBuffer, VkSubpassContents contents) const = 0;
virtual void cmdEndRenderPass (VkCommandBuffer commandBuffer) const = 0;
-virtual void cmdExecuteCommands (VkCommandBuffer commandBuffer, deUint32 commandBuffersCount, const VkCommandBuffer* pCommandBuffers) const = 0;
+virtual void cmdExecuteCommands (VkCommandBuffer commandBuffer, deUint32 commandBufferCount, const VkCommandBuffer* pCommandBuffers) const = 0;
types = []
for type, structname, contents, typename in matches:
+ if typename[-3:] == "KHR":
+ continue # \todo [2016-01-05 pyry] Figure out how to handle platform-specific types
+
types.append(parseCompositeType(typeMap[type], typename, contents))
return types
#include "gluVarType.hpp"
#include "tcuTestLog.hpp"
#include "vkPrograms.hpp"
+#include "vkQueryUtil.hpp"
#include "vktTestCase.hpp"
namespace vkt
tcu::TestStatus BufferTestInstance::bufferCreateAndAllocTest (VkDeviceSize size)
{
- const VkDevice vkDevice = m_context.getDevice();
- const DeviceInterface& vk = m_context.getDeviceInterface();
+ const VkDevice vkDevice = m_context.getDevice();
+ const DeviceInterface& vk = m_context.getDeviceInterface();
VkBuffer testBuffer;
VkMemoryRequirements memReqs;
VkDeviceMemory memory;
+ const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
// Create buffer
{
- const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
const VkBufferCreateInfo bufferParams =
{
VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
if (vk.allocateMemory(vkDevice, &memAlloc, (const VkAllocationCallbacks*)DE_NULL, &memory) != VK_SUCCESS)
return tcu::TestStatus::fail("Alloc memory failed! (requested memory size: " + de::toString(size) + ")");
- if (vk.bindBufferMemory(vkDevice, testBuffer, memory, 0) != VK_SUCCESS)
- return tcu::TestStatus::fail("Bind buffer memory failed! (requested memory size: " + de::toString(size) + ")");
+
+ if ((m_testCase.flags & VK_BUFFER_CREATE_SPARSE_BINDING_BIT) ||
+ (m_testCase.flags & VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT) ||
+ (m_testCase.flags & VK_BUFFER_CREATE_SPARSE_ALIASED_BIT))
+ {
+ VkQueue queue = 0;
+
+ vk.getDeviceQueue(vkDevice, queueFamilyIndex, 0, &queue);
+
+ const VkSparseMemoryBind sparseMemoryBind =
+ {
+ 0, // VkDeviceSize resourceOffset;
+ memReqs.size, // VkDeviceSize size;
+ memory, // VkDeviceMemory memory;
+ 0, // VkDeviceSize memoryOffset;
+ 0 // VkSparseMemoryBindFlags flags;
+ };
+
+ const VkSparseBufferMemoryBindInfo sparseBufferMemoryBindInfo =
+ {
+ testBuffer, // VkBuffer buffer;
+ 1u, // deUint32 bindCount;
+ &sparseMemoryBind // const VkSparseMemoryBind* pBinds;
+ };
+
+ const VkBindSparseInfo bindSparseInfo =
+ {
+ VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0, // deUint32 waitSemaphoreCount;
+ DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ 1u, // deUint32 bufferBindCount;
+ &sparseBufferMemoryBindInfo, // const VkSparseBufferMemoryBindInfo* pBufferBinds;
+ 0, // deUint32 imageOpaqueBindCount;
+ DE_NULL, // const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
+ 0, // deUint32 imageBindCount;
+ DE_NULL, // const VkSparseImageMemoryBindInfo* pImageBinds;
+ 0, // deUint32 signalSemaphoreCount;
+ DE_NULL, // const VkSemaphore* pSignalSemaphores;
+ };
+
+ if (vk.queueBindSparse(queue, 1, &bindSparseInfo, DE_NULL) != VK_SUCCESS)
+ return tcu::TestStatus::fail("Bind sparse buffer memory failed! (requested memory size: " + de::toString(size) + ")");
+ } else
+ if (vk.bindBufferMemory(vkDevice, testBuffer, memory, 0) != VK_SUCCESS)
+ return tcu::TestStatus::fail("Bind buffer memory failed! (requested memory size: " + de::toString(size) + ")");
}
vk.freeMemory(vkDevice, memory, (const VkAllocationCallbacks*)DE_NULL);
tcu::TestStatus BufferTestInstance::iterate (void)
{
+ const VkPhysicalDeviceFeatures& physicalDeviceFeatures = m_context.getDeviceFeatures();
+
+ if ((m_testCase.flags & VK_BUFFER_CREATE_SPARSE_BINDING_BIT ) && !physicalDeviceFeatures.sparseBinding)
+ TCU_THROW(NotSupportedError, "Sparse bindings feature is not supported");
+
+ if ((m_testCase.flags & VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT ) && !physicalDeviceFeatures.sparseResidencyBuffer)
+ TCU_THROW(NotSupportedError, "Sparse buffer residency feature is not supported");
+
+ if ((m_testCase.flags & VK_BUFFER_CREATE_SPARSE_ALIASED_BIT ) && !physicalDeviceFeatures.sparseResidencyAliased)
+ TCU_THROW(NotSupportedError, "Sparse aliased residency feature is not supported");
+
const VkDeviceSize testSizes[] =
{
1,
15991,
16384
};
- tcu::TestStatus testStatus = tcu::TestStatus::pass("Buffer test");
+ tcu::TestStatus testStatus = tcu::TestStatus::pass("Buffer test");
for (int i = 0; i < DE_LENGTH_OF_ARRAY(testSizes); i++)
{
if (m_testCase.usage & (VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT))
{
- const VkPhysicalDevice vkPhysicalDevice = m_context.getPhysicalDevice();
- const InstanceInterface& vkInstance = m_context.getInstanceInterface();
+ const VkPhysicalDevice vkPhysicalDevice = m_context.getPhysicalDevice();
+ const InstanceInterface& vkInstance = m_context.getInstanceInterface();
+ const VkPhysicalDeviceMemoryProperties memoryProperties = getPhysicalDeviceMemoryProperties(vkInstance, vkPhysicalDevice);
VkPhysicalDeviceProperties props;
vkInstance.getPhysicalDeviceProperties(vkPhysicalDevice, &props);
- testStatus = bufferCreateAndAllocTest(props.limits.maxTexelBufferElements);
+ const VkDeviceSize maxTestBufferSize = de::min((VkDeviceSize) props.limits.maxTexelBufferElements, memoryProperties.memoryHeaps[memoryProperties.memoryTypes[0].heapIndex].size / 16);
+
+ testStatus = bufferCreateAndAllocTest(maxTestBufferSize);
}
return testStatus;
0u, // VkImageCreateFlags flags;
VK_IMAGE_TYPE_2D, // VkImageType imageType;
m_colorFormat, // VkFormat format;
- { m_renderSize.x(), m_renderSize.y(), 1u }, // VkExtent3D extent;
+ { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y(), 1u }, // VkExtent3D extent;
1u, // deUint32 mipLevels;
1u, // deUint32 arraySize;
VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
};
const VkRect2D scissor =
{
- { 0, 0 }, // VkOffset2D offset;
- { m_renderSize.x(), m_renderSize.y() } // VkExtent2D extent;
+ { 0, 0 }, // VkOffset2D offset;
+ { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y() } // VkExtent2D extent;
};
const VkPipelineViewportStateCreateInfo viewportStateParams =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCmdBufferOptimizeFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- VK_FALSE,
- (VkQueryControlFlags)0,
- (VkQueryPipelineStatisticFlags)0,
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const VkClearValue clearValue = makeClearValueColorF32(0.0, 0.0, 0.0, 0.0);
DE_NULL, // const void* pNext;
*m_renderPass, // VkRenderPass renderPass;
*m_framebuffer, // VkFramebuffer framebuffer;
- { { 0, 0 }, { m_renderSize.x(), m_renderSize.y() } }, // VkRect2D renderArea;
+ {
+ { 0, 0 },
+ { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y() }
+ }, // VkRect2D renderArea;
1u, // deUint32 clearValueCount;
attachmentClearValues // const VkClearValue* pClearValues;
};
1u // deUint32 arraySize;
}
};
- const void* const initialImageBarrierPtr = &initialImageBarrier;
- vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_FALSE, 1, &initialImageBarrierPtr);
+ vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &initialImageBarrier);
vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
vk.cmdBindDescriptorSets(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipelineLayout, 0u, 1, &*m_descriptorSet, 0u, DE_NULL);
vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &m_vertexBuffer.get(), vertexBufferOffset);
vk.cmdDraw(*m_cmdBuffer, (deUint32)m_vertices.size(), 1, 0, 0);
+ vk.cmdEndRenderPass(*m_cmdBuffer);
const VkImageMemoryBarrier imageBarrier =
{
(deUint32)m_renderSize.y(), // deUint32 bufferImageHeight;
{ VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u }, // VkImageSubresourceCopy imageSubresource;
{ 0, 0, 0 }, // VkOffset3D imageOffset;
- { m_renderSize.x(), m_renderSize.y(), 1 } // VkExtent3D imageExtent;
+ {
+ (deUint32)m_renderSize.x(),
+ (deUint32)m_renderSize.y(),
+ 1u
+ } // VkExtent3D imageExtent;
};
- const void* const imageBarrierPtr = &imageBarrier;
- const void* const bufferBarrierPtr = &bufferBarrier;
-
- vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_FALSE, 1, &imageBarrierPtr);
+ vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrier);
vk.cmdCopyImageToBuffer(*m_cmdBuffer, *m_colorImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *m_resultBuffer, 1, ©Region);
- vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_FALSE, 1, &bufferBarrierPtr);
+ vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
- vk.cmdEndRenderPass(*m_cmdBuffer);
VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
}
DE_NULL,
0u,
(const VkSemaphore*)DE_NULL,
+ (const VkPipelineStageFlags*)DE_NULL,
1u,
&m_cmdBuffer.get(),
0u,
const VkDevice vkDevice = m_context.getDevice();
const DeviceInterface& vk = m_context.getDeviceInterface();
const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
- const VkDeviceSize size = 16 * 1024;
+ const VkDeviceSize size = 3 * 5 * 7 * 64;
VkBuffer testBuffer;
VkMemoryRequirements memReqs;
VkFormatProperties properties;
{
de::MovePtr<tcu::TestCaseGroup> bufferViewTests (new tcu::TestCaseGroup(testCtx, "create", "BufferView Construction Tests"));
- const VkDeviceSize range = 96;
+ const VkDeviceSize range = VK_WHOLE_SIZE;
for (deUint32 format = VK_FORMAT_UNDEFINED + 1; format < VK_FORMAT_LAST; format++)
{
std::ostringstream testName;
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
0, // flags
- (VkRenderPass)0u, // renderPass
- 0u, // subpass
- (VkFramebuffer)0u, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
// Fill create info struct for event
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1, // commandBufferCount
&primCmdBuf.get(), // pCommandBuffers
0u, // signalSemaphoreCount
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
0, // flags
- (VkRenderPass)0u, // renderPass
- 0u, // subpass
- (VkFramebuffer)0u, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
// Fill create info struct for event
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1, // commandBufferCount
&primCmdBuf.get(), // pCommandBuffers
0u, // signalSemaphoreCount
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // sType
DE_NULL, // pNext
0u, // flags
- DE_NULL, // renderPass
- 0u, // subpass
- DE_NULL, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const VkEventCreateInfo eventCreateInfo =
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1u, // commandBufferCount
&cmdBuf.get(), // pCommandBuffers
0u, // signalSemaphoreCount
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
0, // flags
- (VkRenderPass)0u, // renderPass
- 0u, // subpass
- (VkFramebuffer)0u, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
// Fill create info struct for event
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
0, // flags
- (VkRenderPass)0u, // renderPass
- 0u, // subpass
- (VkFramebuffer)0u, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
// Fill create info struct for event
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1, // commandBufferCount
&primCmdBuf.get(), // pCommandBuffers
0u, // signalSemaphoreCount
};
const Unique<VkCommandBuffer> secCmdBuf (allocateCommandBuffer(vk, vkDevice, &cmdBufParams));
- const VkCommandBufferBeginInfo secCmdBufBeginInfo =
+ const VkCommandBufferInheritanceInfo secCmdBufInheritInfo =
{
- VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
DE_NULL,
- 0, // flags
(VkRenderPass)0u, // renderPass
0u, // subpass
(VkFramebuffer)0u, // framebuffer
(VkQueryControlFlags)0u, // queryFlags
(VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
};
+ const VkCommandBufferBeginInfo secCmdBufBeginInfo =
+ {
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+ DE_NULL,
+ 0, // flags
+ &secCmdBufInheritInfo,
+ };
// Fill create info struct for event
const VkEventCreateInfo eventCreateInfo =
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
0, // flags
- (VkRenderPass)0u, // renderPass
- 0u, // subpass
- (VkFramebuffer)0u, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
// Fill create info struct for event
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1, // commandBufferCount
&primCmdBuf.get(), // pCommandBuffers
0u, // signalSemaphoreCount
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
0, // flags
- (VkRenderPass)0u, // renderPass
- 0u, // subpass
- (VkFramebuffer)0u, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
// Fill create info struct for event
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1, // commandBufferCount
&primCmdBuf.get(), // pCommandBuffers
0u, // signalSemaphoreCount
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
0, // flags
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
+ };
+
+ const VkCommandBufferInheritanceInfo secCmdBufInheritInfo =
+ {
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
+ DE_NULL,
(VkRenderPass)0u, // renderPass
0u, // subpass
(VkFramebuffer)0u, // framebuffer
(VkQueryControlFlags)0u, // queryFlags
(VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
};
-
const VkCommandBufferBeginInfo secCmdBufBeginInfo =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
0u, // flags
- (VkRenderPass)0u, // renderPass
- 0u, // subpass
- (VkFramebuffer)0u, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ &secCmdBufInheritInfo,
};
// Fill create info struct for event
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1, // commandBufferCount
&primCmdBuf1.get(), // pCommandBuffers
0u, // signalSemaphoreCount
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1, // commandBufferCount
&primCmdBuf2.get(), // pCommandBuffers
0u, // signalSemaphoreCount
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // flags
- (VkRenderPass)0u, // renderPass
- 0u, // subpass
- (VkFramebuffer)0u, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
// Fill create info struct for event
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1, // commandBufferCount
&primCmdBuf.get(), // pCommandBuffers
0u, // signalSemaphoreCount
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
0, // flags
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
+ };
+
+ const VkCommandBufferInheritanceInfo secCmdBufInheritInfo =
+ {
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
+ DE_NULL,
(VkRenderPass)0u, // renderPass
0u, // subpass
(VkFramebuffer)0u, // framebuffer
(VkQueryControlFlags)0u, // queryFlags
(VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
};
-
const VkCommandBufferBeginInfo secCmdBufBeginInfo =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // flags
- (VkRenderPass)0u, // renderPass
- 0u, // subpass
- (VkFramebuffer)0u, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ &secCmdBufInheritInfo,
};
// Fill create info struct for event
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1, // commandBufferCount
&primCmdBuf1.get(), // pCommandBuffers
0u, // signalSemaphoreCount
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1, // commandBufferCount
&primCmdBuf2.get(), // pCommandBuffers
0u, // signalSemaphoreCount
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, // flags
- (VkRenderPass)0u, // renderPass
- 0u, // subpass
- (VkFramebuffer)0u, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
// Fill create info struct for event
VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
// wait for event
- vk.cmdWaitEvents(*primCmdBuf, 1u, &eventOne.get(), stageMask, stageMask, 0u, DE_NULL);
+ vk.cmdWaitEvents(*primCmdBuf, 1u, &eventOne.get(), stageMask, stageMask, 0u, DE_NULL, 0u, DE_NULL, 0u, DE_NULL);
// Set the second event
vk.cmdSetEvent(*primCmdBuf, eventTwo.get(), stageMask);
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1, // commandBufferCount
&primCmdBuf.get(), // pCommandBuffers
0u, // signalSemaphoreCount
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
0, // flags
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
+ };
+
+ const VkCommandBufferInheritanceInfo secCmdBufInheritInfo =
+ {
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
+ DE_NULL,
(VkRenderPass)0u, // renderPass
0u, // subpass
(VkFramebuffer)0u, // framebuffer
(VkQueryControlFlags)0u, // queryFlags
(VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
};
-
const VkCommandBufferBeginInfo secCmdBufBeginInfo =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, // flags
- (VkRenderPass)0u, // renderPass
- 0u, // subpass
- (VkFramebuffer)0u, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ &secCmdBufInheritInfo,
};
// Fill create info struct for event
VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
// wait for event
- vk.cmdWaitEvents(*secCmdBuf, 1, &eventOne.get(), stageMask, stageMask, 0, DE_NULL);
+ vk.cmdWaitEvents(*secCmdBuf, 1, &eventOne.get(), stageMask, stageMask, 0, DE_NULL, 0u, DE_NULL, 0u, DE_NULL);
// reset event
vk.cmdSetEvent(*secCmdBuf, *eventTwo, stageMask);
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1, // commandBufferCount
&primCmdBuf.get(), // pCommandBuffers
0u, // signalSemaphoreCount
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // sType
DE_NULL, // pNext
0u, // flags
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
+ };
+
+ const VkCommandBufferInheritanceInfo secBufferInheritInfo =
+ {
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
+ DE_NULL,
0u, // renderPass
0u, // subpass
0u, // framebuffer
- DE_FALSE, // occlusionQueryEnable
- 0u, // queryFlags
+ VK_TRUE, // occlusionQueryEnable
+ VK_QUERY_CONTROL_PRECISE_BIT, // queryFlags
(VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
};
-
const VkCommandBufferBeginInfo secBufferBeginInfo =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // sType
DE_NULL, // pNext
0u, // flags
- 0u, // renderPass
- 0u, // subpass
- 0u, // framebuffer
- VK_TRUE, // occlusionQueryEnable
- VK_QUERY_CONTROL_PRECISE_BIT, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ &secBufferInheritInfo,
};
// Create an occlusion query with VK_QUERY_CONTROL_PRECISE_BIT set
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // sType
DE_NULL, // pNext
0u, // flags
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
+ };
+
+ const VkCommandBufferInheritanceInfo secBufferInheritInfo =
+ {
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
+ DE_NULL,
0u, // renderPass
0u, // subpass
0u, // framebuffer
- DE_FALSE, // occlusionQueryEnable
- 0u, // queryFlags
+ VK_TRUE, // occlusionQueryEnable
+ VK_QUERY_CONTROL_PRECISE_BIT, // queryFlags
(VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
};
-
const VkCommandBufferBeginInfo secBufferBeginInfo =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // sType
DE_NULL, // pNext
0u, // flags
- 0u, // renderPass
- 0u, // subpass
- 0u, // framebuffer
- VK_TRUE, // occlusionQueryEnable
- VK_QUERY_CONTROL_PRECISE_BIT, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ &secBufferInheritInfo,
};
// Create an occlusion query with VK_QUERY_CONTROL_PRECISE_BIT set
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // sType
DE_NULL, // pNext
0u, // flags
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
+ };
+
+ const VkCommandBufferInheritanceInfo secBufferInheritInfo =
+ {
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
+ DE_NULL,
0u, // renderPass
0u, // subpass
0u, // framebuffer
0u, // queryFlags
(VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
};
-
const VkCommandBufferBeginInfo secBufferBeginInfo =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // sType
DE_NULL, // pNext
0u, // flags
- 0u, // renderPass
- 0u, // subpass
- 0u, // framebuffer
- VK_TRUE, // occlusionQueryEnable
- 0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ &secBufferInheritInfo,
};
// Create an occlusion query with VK_QUERY_CONTROL_PRECISE_BIT set
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // sType
DE_NULL, // pNext
0u, // flags
- DE_NULL, // renderPass
- 0u, // subpass
- DE_NULL, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const VkEventCreateInfo eventCreateInfo =
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
BUFFER_COUNT, // commandBufferCount
cmdBuffers, // pCommandBuffers
0u, // signalSemaphoreCount
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // sType
DE_NULL, // pNext
0u, // flags
- DE_NULL, // renderPass
- 0u, // subpass
- DE_NULL, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const VkEventCreateInfo eventCreateInfo =
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1u, // commandBufferCount
&cmdBuffers[0], // pCommandBuffers
0u, // signalSemaphoreCount
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1u, // commandBufferCount
&cmdBuffers[1], // pCommandBuffers
0u, // signalSemaphoreCount
VK_CHECK(vk.queueSubmit(queue, 0, &submitInfoCountZero, fenceZero.get()));
VK_CHECK(vk.queueSubmit(queue, 1, &submitInfoCountOne, fenceOne.get()));
- const VkFence fences[] =
+ const VkFence fences[] =
{
fenceZero.get(),
fenceOne.get(),
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // sType
DE_NULL, // pNext
0u, // flags
- DE_NULL, // renderPass
- 0u, // subpass
- DE_NULL, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const VkEventCreateInfo eventCreateInfo =
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1u, // commandBufferCount
&cmdBuffers[0], // pCommandBuffers
0u, // signalSemaphoreCount
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1u, // commandBufferCount
&cmdBuffers[1], // pCommandBuffers
0u, // signalSemaphoreCount
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // sType
DE_NULL, // pNext
0u, // flags
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
+ };
+
+ const VkCommandBufferInheritanceInfo secCmdBufInheritInfo =
+ {
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
+ DE_NULL,
DE_NULL, // renderPass
0u, // subpass
DE_NULL, // framebuffer
(VkQueryControlFlags)0u, // queryFlags
(VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
};
-
const VkCommandBufferBeginInfo secCmdBufBeginInfo =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // sType
DE_NULL, // pNext
0u, // flags
- DE_NULL, // renderPass
- 0u, // subpass
- DE_NULL, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ &secCmdBufInheritInfo,
};
// Fill create info struct for event
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1u, // commandBufferCount
&primCmdBuf.get(), // pCommandBuffers
0u, // signalSemaphoreCount
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
0, // flags
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
+ };
+
+ const VkCommandBufferInheritanceInfo secCmdBufInheritInfo =
+ {
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
+ DE_NULL,
(VkRenderPass)0u, // renderPass
0u, // subpass
(VkFramebuffer)0u, // framebuffer
(VkQueryControlFlags)0u, // queryFlags
(VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
};
-
const VkCommandBufferBeginInfo secCmdBufBeginInfo =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, // flags
- (VkRenderPass)0u, // renderPass
- 0u, // subpass
- (VkFramebuffer)0u, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ &secCmdBufInheritInfo,
};
// Fill create info struct for event
VkPipelineStageFlags stageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
// wait for event
- vk.cmdWaitEvents(cmdBuffers[ndx], 1, &eventOne.get(), stageMask, stageMask, 0, DE_NULL);
+ vk.cmdWaitEvents(cmdBuffers[ndx], 1, &eventOne.get(), stageMask, stageMask, 0, DE_NULL, 0u, DE_NULL, 0u, DE_NULL);
}
// end recording of secondary buffers
VK_CHECK(vk.endCommandBuffer(cmdBuffers[ndx]));
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1, // commandBufferCount
&primCmdBufOne.get(), // pCommandBuffers
0u, // signalSemaphoreCount
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1, // commandBufferCount
&primCmdBufTwo.get(), // pCommandBuffers
0u, // signalSemaphoreCount
const Unique<VkPipeline> pipelineBad (createComputePipeline(vk, device, (VkPipelineCache)0u, &createInfoBad));
const VkAccessFlags inputBit = (VK_ACCESS_UNIFORM_READ_BIT);
- const VkBufferMemoryBarrier bufferBarrierA =
+ const VkBufferMemoryBarrier bufferBarriers[] =
{
- VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
- DE_NULL,
- VK_ACCESS_HOST_WRITE_BIT, // outputMask
- inputBit, // inputMask
- VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex
- VK_QUEUE_FAMILY_IGNORED, // destQueueFamilyIndex
- *bufferA, // buffer
- (VkDeviceSize)0u, // offset
- (VkDeviceSize)bufferSizeA, // size
- };
-
- const VkBufferMemoryBarrier bufferBarrierB =
- {
- VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
- DE_NULL,
- VK_ACCESS_HOST_WRITE_BIT, // outputMask
- inputBit, // inputMask
- VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex
- VK_QUEUE_FAMILY_IGNORED, // destQueueFamilyIndex
- *bufferB, // buffer
- (VkDeviceSize)0u, // offset
- (VkDeviceSize)bufferSizeB, // size
+ {
+ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+ DE_NULL,
+ VK_ACCESS_HOST_WRITE_BIT, // outputMask
+ inputBit, // inputMask
+ VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex
+ VK_QUEUE_FAMILY_IGNORED, // destQueueFamilyIndex
+ *bufferA, // buffer
+ (VkDeviceSize)0u, // offset
+ (VkDeviceSize)bufferSizeA, // size
+ },
+ {
+ VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+ DE_NULL,
+ VK_ACCESS_HOST_WRITE_BIT, // outputMask
+ inputBit, // inputMask
+ VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex
+ VK_QUEUE_FAMILY_IGNORED, // destQueueFamilyIndex
+ *bufferB, // buffer
+ (VkDeviceSize)0u, // offset
+ (VkDeviceSize)bufferSizeB, // size
+ }
};
const deUint32 numSrcBuffers = 1u;
const deUint32* const dynamicOffsets = (DE_NULL);
const deUint32 numDynamicOffsets = (0);
- const void* const preBarriers[] = { &bufferBarrierA, &bufferBarrierB };
const int numPreBarriers = numSrcBuffers;
- const void* const postBarriers[] = { result.getResultReadBarrier() };
- const int numPostBarriers = DE_LENGTH_OF_ARRAY(postBarriers);
+ const vk::VkBufferMemoryBarrier* const postBarriers = result.getResultReadBarrier();
+ const int numPostBarriers = 1;
const tcu::Vec4 refQuadrantValue14 = (colorA2);
const tcu::Vec4 refQuadrantValue23 = (colorA1);
const tcu::Vec4 references[4] =
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // sType
DE_NULL, // pNext
0u, // flags
- DE_NULL, // renderPass
- 0u, // subpass
- DE_NULL, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const Unique<VkFence> cmdCompleteFence (createFence(vk, device, &fenceCreateInfo));
vk.cmdBindDescriptorSets(*cmd, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0, numDescriptorSets, descriptorSets, numDynamicOffsets, dynamicOffsets);
if (numPreBarriers)
- vk.cmdPipelineBarrier(*cmd, 0u, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_FALSE, numPreBarriers, preBarriers);
+ vk.cmdPipelineBarrier(*cmd, 0u, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0,
+ 0, (const VkMemoryBarrier*)DE_NULL,
+ numPreBarriers, bufferBarriers,
+ 0, (const VkImageMemoryBarrier*)DE_NULL);
vk.cmdDispatch(*cmd, numWorkGroups.x(), numWorkGroups.y(), numWorkGroups.z());
- vk.cmdPipelineBarrier(*cmd, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_FALSE, numPostBarriers, postBarriers);
+ vk.cmdPipelineBarrier(*cmd, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0,
+ 0, (const VkMemoryBarrier*)DE_NULL,
+ numPostBarriers, postBarriers,
+ 0, (const VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(vk.endCommandBuffer(*cmd));
// run
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
- // TODO: The following field is in api spec 1.0 37bedec32143807010323f126ad685ab5e9d98de
- // TODO: but not in the header Loader and Tools 69d4893b673bd552e445ba999ad0e73463d35007
- // DE_NULL, // pWaitDstStageMask
+ (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
1, // commandBufferCount
&cmd.get(), // pCommandBuffers
0u, // signalSemaphoreCount
inline vk::VkBuffer getBuffer(void) const { return *m_buffer; }
- inline const void * getResultReadBarrier(void) const { return &m_bufferBarrier; }
+ inline const vk::VkBufferMemoryBarrier* getResultReadBarrier(void) const { return &m_bufferBarrier; }
private:
static vk::Move<vk::VkBuffer> createResultBuffer(const vk::DeviceInterface &vki,
}
};
- const void* preCopyBarriers[2] =
- {
- &preBufferBarrier,
- &preImageBarrier
- };
- const void* const postCopyBarrier = &postImageBarrier;
-
const VkBufferImageCopy copyRegion =
{
0u, // VkDeviceSize bufferOffset;
1u, // deUint32 layerCount;
},
{ 0, 0, 0 }, // VkOffset3D imageOffset;
- { imageAccess.getWidth(), imageAccess.getHeight(), 1u } // VkExtent3D imageExtent;
+ {
+ (deUint32)imageAccess.getWidth(),
+ (deUint32)imageAccess.getHeight(),
+ 1u
+ } // VkExtent3D imageExtent;
};
// Write buffer data
flushMappedMemoryRange(vk, vkDevice, bufferAlloc->getMemory(), bufferAlloc->getOffset(), bufferSize);
// Copy buffer to image
- VkCommandBufferBeginInfo cmdBufferBeginInfo =
+ const VkCommandBufferBeginInfo cmdBufferBeginInfo =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- false, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo));
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_FALSE, 2u, preCopyBarriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &preBufferBarrier, 1, &preImageBarrier);
vk.cmdCopyBufferToImage(*cmdBuffer, *buffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, ©Region);
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_FALSE, 1u, &postCopyBarrier);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &postImageBarrier);
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
const VkSubmitInfo submitInfo =
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // deUint32 commandBufferCount;
&cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
pixelDataSize // VkDeviceSize size;
};
- const void* const imageBarrierPtr = &imageBarrier;
- const void* const bufferBarrierPtr = &bufferBarrier;
-
// Copy image to buffer
const VkBufferImageCopy copyRegion =
imageSize // VkExtent3D imageExtent;
};
- VkCommandBufferBeginInfo cmdBufferBeginInfo =
+ const VkCommandBufferBeginInfo cmdBufferBeginInfo =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- false, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo));
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_FALSE, 1, &imageBarrierPtr);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrier);
vk.cmdCopyImageToBuffer(*cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, 1, ©Region);
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_FALSE, 1, &bufferBarrierPtr);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
const VkSubmitInfo submitInfo =
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // deUint32 commandBufferCount;
&cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
SimpleAllocator memAlloc (vk, vkDevice, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice()));
+ VkImageFormatProperties properties;
+ if ((context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
+ m_params.src.image.format,
+ VK_IMAGE_TYPE_2D,
+ VK_IMAGE_TILING_OPTIMAL,
+ VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 0,
+ &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED) ||
+ (context.getInstanceInterface().getPhysicalDeviceImageFormatProperties (context.getPhysicalDevice(),
+ m_params.dst.image.format,
+ VK_IMAGE_TYPE_2D,
+ VK_IMAGE_TILING_OPTIMAL,
+ VK_FORMAT_FEATURE_BLIT_DST_BIT, 0,
+ &properties) == VK_ERROR_FORMAT_NOT_SUPPORTED))
+ {
+ TCU_THROW(NotSupportedError, "Format not supported");
+ }
+
// Create source image
{
const VkImageCreateInfo sourceImageParams =
m_params.src.image.extent.width,
m_params.src.image.extent.height,
m_params.src.image.extent.depth));
- generateBuffer(m_sourceTextureLevel->getAccess(), m_params.src.image.extent.width, m_params.src.image.extent.height, m_params.src.image.extent.depth);
+ generateBuffer(m_sourceTextureLevel->getAccess(), m_params.src.image.extent.width, m_params.src.image.extent.height, m_params.src.image.extent.depth, FILL_MODE_WHITE);
m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(dstTcuFormat,
(int)m_params.dst.image.extent.width,
(int)m_params.dst.image.extent.height,
(int)m_params.dst.image.extent.depth));
- generateBuffer(m_destinationTextureLevel->getAccess(), m_params.dst.image.extent.width, m_params.dst.image.extent.height, m_params.dst.image.extent.depth);
+ generateBuffer(m_destinationTextureLevel->getAccess(), m_params.dst.image.extent.width, m_params.dst.image.extent.height, m_params.dst.image.extent.depth, FILL_MODE_SEQUENTIAL);
generateExpectedResult();
uploadImage(m_sourceTextureLevel->getAccess(), m_source.get());
}
};
- const void* const srcImageBarrierPtr = &srcImageBarrier;
- const void* const dstImageBarrierPtr = &dstImageBarrier;
-
- VkCommandBufferBeginInfo cmdBufferBeginInfo =
+ const VkCommandBufferBeginInfo cmdBufferBeginInfo =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- false, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
- vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_FALSE, 1, &srcImageBarrierPtr);
+ vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &srcImageBarrier);
vk.cmdCopyImage(*m_cmdBuffer, m_source.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, m_destination.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)m_params.regions.size(), imageCopies);
- vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_FALSE, 1, &dstImageBarrierPtr);
+ vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &dstImageBarrier);
VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
const VkSubmitInfo submitInfo =
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
tcu::TestStatus CopyBufferToBuffer::iterate()
{
- m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), (int)m_params.src.buffer.size, 1));
- generateBuffer(m_sourceTextureLevel->getAccess(), (int)m_params.src.buffer.size, 1, 1, FILL_MODE_RED);
- m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), (int)m_params.dst.buffer.size, 1));
- generateBuffer(m_destinationTextureLevel->getAccess(), (int)m_params.dst.buffer.size, 1, 1, FILL_MODE_WHITE);
+ const int srcLevelWidth = (int)(m_params.src.buffer.size/4); // Here the format is VK_FORMAT_R32_UINT, we need to divide the buffer size by 4
+ m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), srcLevelWidth, 1));
+ generateBuffer(m_sourceTextureLevel->getAccess(), srcLevelWidth, 1, 1, FILL_MODE_RED);
+
+ const int dstLevelWidth = (int)(m_params.dst.buffer.size/4);
+ m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), dstLevelWidth, 1));
+ generateBuffer(m_destinationTextureLevel->getAccess(), dstLevelWidth, 1, 1, FILL_MODE_WHITE);
generateExpectedResult();
m_params.dst.buffer.size // VkDeviceSize size;
};
- const void* const srcBufferBarrierPtr = &srcBufferBarrier;
- const void* const dstBufferBarrierPtr = &dstBufferBarrier;
-
VkBufferCopy* bufferCopies = ((VkBufferCopy*)deMalloc(m_params.regions.size() * sizeof(VkBufferCopy)));
for (deUint32 i = 0; i < m_params.regions.size(); i++)
bufferCopies[i] = m_params.regions[i].bufferCopy;
- VkCommandBufferBeginInfo cmdBufferBeginInfo =
+ const VkCommandBufferBeginInfo cmdBufferBeginInfo =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- false, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
- vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_FALSE, 1, &srcBufferBarrierPtr);
+ vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &srcBufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
vk.cmdCopyBuffer(*m_cmdBuffer, m_source.get(), m_destination.get(), (deUint32)m_params.regions.size(), bufferCopies);
- vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_FALSE, 1, &dstBufferBarrierPtr);
+ vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &dstBufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
const VkSubmitInfo submitInfo =
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
// Read buffer data
- de::MovePtr<tcu::TextureLevel> resultLevel (new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), (int)m_params.dst.buffer.size, 1));
+ de::MovePtr<tcu::TextureLevel> resultLevel (new tcu::TextureLevel(mapVkFormat(VK_FORMAT_R32_UINT), dstLevelWidth, 1));
invalidateMappedMemoryRange(vk, vkDevice, m_destinationBufferAlloc->getMemory(), m_destinationBufferAlloc->getOffset(), m_params.dst.buffer.size);
tcu::copy(*resultLevel, tcu::ConstPixelBufferAccess(resultLevel->getFormat(), resultLevel->getSize(), m_destinationBufferAlloc->getHostPtr()));
deFree(bufferCopies);
m_bufferSize // VkDeviceSize size;
};
- const void* const imageBarrierPtr = &imageBarrier;
- const void* const bufferBarrierPtr = &bufferBarrier;
-
// Copy from image to buffer
VkBufferImageCopy* bufferImageCopies = ((VkBufferImageCopy*)deMalloc(m_params.regions.size() * sizeof(VkBufferImageCopy)));
for (deUint32 i = 0; i < m_params.regions.size(); i++)
bufferImageCopies[i] = m_params.regions[i].bufferImageCopy;
- VkCommandBufferBeginInfo cmdBufferBeginInfo =
+ const VkCommandBufferBeginInfo cmdBufferBeginInfo =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- false, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
- vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_FALSE, 1, &imageBarrierPtr);
+ vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrier);
vk.cmdCopyImageToBuffer(*m_cmdBuffer, m_source.get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, m_destination.get(), (deUint32)m_params.regions.size(), bufferImageCopies);
- vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_FALSE, 1, &bufferBarrierPtr);
+ vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
const VkSubmitInfo submitInfo =
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
const VkOffset3D srcOffset = region.bufferImageCopy.imageOffset;
const int texelOffset = (int) region.bufferImageCopy.bufferOffset / texelSize;
- for (int z = 0; z < extent.depth; z++)
+ for (deUint32 z = 0; z < extent.depth; z++)
{
- for (int y = 0; y < extent.height; y++)
+ for (deUint32 y = 0; y < extent.height; y++)
{
int texelIndex = texelOffset + (z * imageHeight + y) * rowLength;
const tcu::ConstPixelBufferAccess srcSubRegion = tcu::getSubregion(src, srcOffset.x, srcOffset.y + y, srcOffset.z + z,
tcu::TestStatus CopyBufferToImage::iterate()
{
m_sourceTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat, (int)m_params.src.buffer.size, 1));
- generateBuffer(m_sourceTextureLevel->getAccess(), m_params.src.image.extent.width, m_params.src.image.extent.height, m_params.src.image.extent.depth);
+ generateBuffer(m_sourceTextureLevel->getAccess(), m_params.src.image.extent.width, m_params.src.image.extent.height, m_params.src.image.extent.depth, FILL_MODE_WHITE);
m_destinationTextureLevel = de::MovePtr<tcu::TextureLevel>(new tcu::TextureLevel(m_textureFormat,
m_params.dst.image.extent.width,
m_params.dst.image.extent.height,
m_params.dst.image.extent.depth));
- generateBuffer(m_destinationTextureLevel->getAccess(), (int)m_params.dst.buffer.size, 1, 1);
+ generateBuffer(m_destinationTextureLevel->getAccess(), (int)m_params.dst.buffer.size, 1, 1, FILL_MODE_SEQUENTIAL);
generateExpectedResult();
}
};
- const void* const bufferBarrierPtr = &bufferBarrier;
- const void* const imageBarrierPtr = &imageBarrier;
-
// Copy from buffer to image
VkBufferImageCopy* bufferImageCopies = ((VkBufferImageCopy*)deMalloc(m_params.regions.size() * sizeof(VkBufferImageCopy)));
for (deUint32 i = 0; i < m_params.regions.size(); i++)
bufferImageCopies[i] = m_params.regions[i].bufferImageCopy;
- VkCommandBufferBeginInfo cmdBufferBeginInfo =
+ const VkCommandBufferBeginInfo cmdBufferBeginInfo =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- false, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
- vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_FALSE, 1, &bufferBarrierPtr);
+ vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
vk.cmdCopyBufferToImage(*m_cmdBuffer, m_source.get(), m_destination.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)m_params.regions.size(), bufferImageCopies);
- vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_FALSE, 1, &imageBarrierPtr);
+ vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrier);
VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
const VkSubmitInfo submitInfo =
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
const VkOffset3D dstOffset = region.bufferImageCopy.imageOffset;
const int texelOffset = (int) region.bufferImageCopy.bufferOffset / texelSize;
- for (int z = 0; z < extent.depth; z++)
+ for (deUint32 z = 0; z < extent.depth; z++)
{
- for (int y = 0; y < extent.height; y++)
+ for (deUint32 y = 0; y < extent.height; y++)
{
int texelIndex = texelOffset + (z * imageHeight + y) * rowLength;
const tcu::ConstPixelBufferAccess srcSubRegion = tcu::getSubregion(src, texelIndex, 0, region.bufferImageCopy.imageExtent.width, 1);
deUint32 limitToCheck = featureLimitTable[ndx].uintVal;
if (featureLimitTable[ndx].unsuppTableNdx != -1)
{
- if (*((VkBool32*)((char*)features+unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].featureOffset)))
+ if (*((VkBool32*)((char*)features+unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].featureOffset)) == VK_FALSE)
limitToCheck = unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].uintVal;
}
float limitToCheck = featureLimitTable[ndx].floatVal;
if (featureLimitTable[ndx].unsuppTableNdx != -1)
{
- if (*((VkBool32*)((char*)features+unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].featureOffset)))
+ if (*((VkBool32*)((char*)features+unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].featureOffset)) == VK_FALSE)
limitToCheck = unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].floatVal;
}
deInt32 limitToCheck = featureLimitTable[ndx].intVal;
if (featureLimitTable[ndx].unsuppTableNdx != -1)
{
- if (*((VkBool32*)((char*)features+unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].featureOffset)))
+ if (*((VkBool32*)((char*)features+unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].featureOffset)) == VK_FALSE)
limitToCheck = unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].intVal;
}
if (featureLimitTable[ndx].type == LIMIT_TYPE_MIN)
deUint64 limitToCheck = featureLimitTable[ndx].deviceSizeVal;
if (featureLimitTable[ndx].unsuppTableNdx != -1)
{
- if (*((VkBool32*)((char*)features+unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].featureOffset)))
+ if (*((VkBool32*)((char*)features+unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].featureOffset)) == VK_FALSE)
limitToCheck = unsupportedFeatureTable[featureLimitTable[ndx].unsuppTableNdx].deviceSizeVal;
}
{
typedef VkInstance Type;
- enum { MAX_CONCURRENT = 32 };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return 32;
+ }
struct Parameters
{
{
typedef VkDevice Type;
- enum { MAX_CONCURRENT = 32 };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return 32;
+ }
struct Parameters
{
{
typedef VkDeviceMemory Type;
- enum { MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_OBJECTS };
+ static deUint32 getMaxConcurrent (Context& context)
+ {
+ return context.getDeviceProperties().limits.maxMemoryAllocationCount;
+ }
struct Parameters
{
{
typedef VkBuffer Type;
- enum { MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_OBJECTS };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return DEFAULT_MAX_CONCURRENT_OBJECTS;
+ }
struct Parameters
{
{
typedef VkBufferView Type;
- enum { MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_OBJECTS };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return DEFAULT_MAX_CONCURRENT_OBJECTS;
+ }
struct Parameters
{
{
typedef VkImage Type;
- enum { MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_OBJECTS };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return DEFAULT_MAX_CONCURRENT_OBJECTS;
+ }
struct Parameters
{
{
typedef VkImageView Type;
- enum { MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_OBJECTS };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return DEFAULT_MAX_CONCURRENT_OBJECTS;
+ }
struct Parameters
{
{
typedef VkSemaphore Type;
- enum { MAX_CONCURRENT = 100 };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return 100;
+ }
struct Parameters
{
{
typedef VkFence Type;
- enum { MAX_CONCURRENT = 100 };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return 100;
+ }
struct Parameters
{
{
typedef VkEvent Type;
- enum { MAX_CONCURRENT = 100 };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return 100;
+ }
struct Parameters
{
{
typedef VkQueryPool Type;
- enum { MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_OBJECTS };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return DEFAULT_MAX_CONCURRENT_OBJECTS;
+ }
struct Parameters
{
{
typedef VkShaderModule Type;
- enum { MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_OBJECTS };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return DEFAULT_MAX_CONCURRENT_OBJECTS;
+ }
struct Parameters
{
{
typedef VkPipelineCache Type;
- enum { MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_OBJECTS };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return DEFAULT_MAX_CONCURRENT_OBJECTS;
+ }
struct Parameters
{
{
typedef VkSampler Type;
- enum { MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_OBJECTS };
+ static deUint32 getMaxConcurrent (Context& context)
+ {
+ return context.getDeviceProperties().limits.maxSamplerAllocationCount;
+ }
struct Parameters
{
VkSamplerAddressMode addressModeV;
VkSamplerAddressMode addressModeW;
float mipLodBias;
+ VkBool32 anisotropyEnable;
float maxAnisotropy;
VkBool32 compareEnable;
VkCompareOp compareOp;
Parameters (void)
: magFilter (VK_FILTER_NEAREST)
, minFilter (VK_FILTER_NEAREST)
- , mipmapMode (VK_SAMPLER_MIPMAP_MODE_BASE)
+ , mipmapMode (VK_SAMPLER_MIPMAP_MODE_NEAREST)
, addressModeU (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE)
, addressModeV (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE)
, addressModeW (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE)
, mipLodBias (0.0f)
+ , anisotropyEnable (VK_FALSE)
, maxAnisotropy (1.0f)
, compareEnable (VK_FALSE)
, compareOp (VK_COMPARE_OP_ALWAYS)
params.addressModeV,
params.addressModeW,
params.mipLodBias,
+ params.anisotropyEnable,
params.maxAnisotropy,
params.compareEnable,
params.compareOp,
{
typedef VkDescriptorSetLayout Type;
- enum { MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_OBJECTS };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return DEFAULT_MAX_CONCURRENT_OBJECTS;
+ }
struct Parameters
{
{
typedef VkPipelineLayout Type;
- enum { MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_OBJECTS };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return DEFAULT_MAX_CONCURRENT_OBJECTS;
+ }
struct Parameters
{
{
typedef VkRenderPass Type;
- enum { MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_OBJECTS };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return DEFAULT_MAX_CONCURRENT_OBJECTS;
+ }
// \todo [2015-09-17 pyry] More interesting configurations
struct Parameters
{
typedef VkPipeline Type;
- enum { MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_OBJECTS };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return DEFAULT_MAX_CONCURRENT_OBJECTS;
+ }
// \todo [2015-09-17 pyry] More interesting configurations
struct Parameters
{
typedef VkPipeline Type;
- enum { MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_OBJECTS };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return DEFAULT_MAX_CONCURRENT_OBJECTS;
+ }
// \todo [2015-09-17 pyry] More interesting configurations
struct Parameters
{
typedef VkDescriptorPool Type;
- enum { MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_OBJECTS };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return DEFAULT_MAX_CONCURRENT_OBJECTS;
+ }
struct Parameters
{
{
typedef VkDescriptorSet Type;
- enum { MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_OBJECTS };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return DEFAULT_MAX_CONCURRENT_OBJECTS;
+ }
struct Parameters
{
{
typedef VkFramebuffer Type;
- enum { MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_OBJECTS };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return DEFAULT_MAX_CONCURRENT_OBJECTS;
+ }
struct Parameters
{
{
typedef VkCommandPool Type;
- enum { MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_OBJECTS };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return DEFAULT_MAX_CONCURRENT_OBJECTS;
+ }
struct Parameters
{
{
typedef VkCommandBuffer Type;
- enum { MAX_CONCURRENT = DEFAULT_MAX_CONCURRENT_OBJECTS };
+ static deUint32 getMaxConcurrent (Context&)
+ {
+ return DEFAULT_MAX_CONCURRENT_OBJECTS;
+ }
struct Parameters
{
typedef Unique<typename Object::Type> UniqueObject;
typedef SharedPtr<UniqueObject> ObjectPtr;
- const deUint32 numObjects = Object::MAX_CONCURRENT;
+ const deUint32 numObjects = Object::getMaxConcurrent(context);
const Environment env (context, numObjects);
const typename Object::Resources res (env, params);
vector<ObjectPtr> objects (numObjects);
template<typename Object>
tcu::TestStatus createSingleAllocCallbacksTest (Context& context, typename Object::Parameters params)
{
- const deUint32 noCmdScope = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE
- | VK_SYSTEM_ALLOCATION_SCOPE_DEVICE
- | VK_SYSTEM_ALLOCATION_SCOPE_CACHE
- | VK_SYSTEM_ALLOCATION_SCOPE_OBJECT;
+ const deUint32 noCmdScope = (1u << VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE)
+ | (1u << VK_SYSTEM_ALLOCATION_SCOPE_DEVICE)
+ | (1u << VK_SYSTEM_ALLOCATION_SCOPE_CACHE)
+ | (1u << VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
// Callbacks used by resources
AllocationCallbackRecorder resCallbacks (getSystemAllocator(), 128);
0u, // flags
VK_FILTER_NEAREST, // magFilter
VK_FILTER_NEAREST, // minFilter
- VK_SAMPLER_MIPMAP_MODE_BASE, // mipmapMode
+ VK_SAMPLER_MIPMAP_MODE_NEAREST, // mipmapMode
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // addressModeU
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // addressModeV
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // addressModeW
0.0f, // mipLodBias
+ VK_FALSE, // anisotropyEnable
1.0f, // maxAnisotropy
DE_FALSE, // compareEnable
VK_COMPARE_OP_ALWAYS, // compareOp
" OpName %4 \"main\"\n"
" OpName %10 \"gl_Position\"\n"
" OpName %12 \"a_position\"\n"
- " OpName %16 \"gl_VertexID\"\n"
- " OpName %17 \"gl_InstanceID\"\n"
+ " OpName %16 \"gl_VertexIndex\"\n"
+ " OpName %17 \"gl_InstanceIndex\"\n"
" OpDecorate %10 BuiltIn Position\n"
" OpDecorate %12 Location 0\n"
- " OpDecorate %16 BuiltIn VertexId\n"
- " OpDecorate %17 BuiltIn InstanceId\n"
+ " OpDecorate %16 BuiltIn VertexIndex\n"
+ " OpDecorate %17 BuiltIn InstanceIndex\n"
"%2 = OpTypeVoid\n"
"%3 = OpTypeFunction %2\n"
"%7 = OpTypeFloat 32\n"
0u, // flags
VK_IMAGE_TYPE_2D, // imageType
VK_FORMAT_R8G8B8A8_UNORM, // format
- { renderSize.x(), renderSize.y(), 1 }, // extent
+ { (deUint32)renderSize.x(), (deUint32)renderSize.y(), 1 }, // extent
1u, // mipLevels
1u, // arraySize
VK_SAMPLE_COUNT_1_BIT, // samples
0u, // y
}, // offset
{
- renderSize.x(), // width
- renderSize.y(), // height
+ (deUint32)renderSize.x(), // width
+ (deUint32)renderSize.y(), // height
}, // extent;
};
const VkPipelineViewportStateCreateInfo viewportParams =
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // sType
DE_NULL, // pNext
0u, // flags
- DE_NULL, // renderPass
- 0u, // subpass
- DE_NULL, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0u, // queryFlags
- (VkQueryPipelineStatisticFlags)0u, // pipelineStatistics
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
// Record commands
1u, // layerCount
} // subresourceRange
};
- const void* barriers[] = { &vertFlushBarrier, &colorAttBarrier };
- vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, DE_FALSE, (deUint32)DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, (VkDependencyFlags)0, 1, &vertFlushBarrier, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &colorAttBarrier);
}
{
DE_NULL, // pNext
*renderPass, // renderPass
*framebuffer, // framebuffer
- { { 0, 0 }, { renderSize.x(), renderSize.y() } }, // renderArea
+ {
+ { 0, 0 },
+ { (deUint32)renderSize.x(), (deUint32)renderSize.y() }
+ }, // renderArea
1u, // clearValueCount
&clearValue, // pClearValues
};
1u, // arraySize
} // subresourceRange
};
- const void* barriers[] = { &renderFinishBarrier };
- vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, DE_FALSE, (deUint32)DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &renderFinishBarrier);
}
{
1u, // layerCount
}, // imageSubresource
{ 0u, 0u, 0u }, // imageOffset
- { renderSize.x(), renderSize.y(), 1u } // imageExtent
+ {
+ (deUint32)renderSize.x(),
+ (deUint32)renderSize.y(),
+ 1u
+ } // imageExtent
};
vk.cmdCopyImageToBuffer(*cmdBuf, *image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *readImageBuffer, 1u, ©Params);
}
0u, // offset
imageSizeBytes // size
};
- const void* barriers[] = { ©FinishBarrier };
- vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, (deUint32)DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, ©FinishBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
}
VK_CHECK(vk.endCommandBuffer(*cmdBuf));
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // commandBufferCount
&cmdBuf.get(), // pCommandBuffers
0u, // signalSemaphoreCount
RESOURCE_FLAG_LAST = (1u << 1u)
};
-static const char* const s_quadrantGenVertexPosSource = " highp int quadPhase = gl_VertexID % 6;\n"
+static const char* const s_quadrantGenVertexPosSource = " highp int quadPhase = gl_VertexIndex % 6;\n"
" highp int quadXcoord = int(quadPhase == 1 || quadPhase == 4 || quadPhase == 5);\n"
" highp int quadYcoord = int(quadPhase == 2 || quadPhase == 3 || quadPhase == 5);\n"
- " highp int quadOriginX = (gl_VertexID / 6) % 2;\n"
- " highp int quadOriginY = (gl_VertexID / 6) / 2;\n"
- " quadrant_id = gl_VertexID / 6;\n"
+ " highp int quadOriginX = (gl_VertexIndex / 6) % 2;\n"
+ " highp int quadOriginY = (gl_VertexIndex / 6) / 2;\n"
+ " quadrant_id = gl_VertexIndex / 6;\n"
" result_position = vec4(float(quadOriginX + quadXcoord - 1), float(quadOriginY + quadYcoord - 1), 0.0, 1.0);\n";
bool isUniformDescriptorType (vk::VkDescriptorType type)
}
}
+vk::VkImageLayout getImageLayoutForDescriptorType (vk::VkDescriptorType descType)
+{
+ if (descType == vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
+ return vk::VK_IMAGE_LAYOUT_GENERAL;
+ else
+ return vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+}
+
deUint32 getTextureLevelPyramidDataSize (const tcu::TextureLevelPyramid& srcImage)
{
deUint32 dataSize = 0;
0,
}, // imageOffset
{
- sliceSize.x(),
- sliceSize.y(),
- sliceSize.z(),
+ (deUint32)sliceSize.x(),
+ (deUint32)sliceSize.y(),
+ (deUint32)sliceSize.z(),
} // imageExtent
};
copySlices->push_back(copySlice);
(vk::VkImageCreateFlags)0,
vk::VK_IMAGE_TYPE_2D, // imageType
vk::mapTextureFormat(format), // format
- { (deInt32)size.x(), (deInt32)size.y(), 1 }, // extent
+ { size.x(), size.y(), 1u }, // extent
1, // mipLevels
1, // arraySize
vk::VK_SAMPLE_COUNT_1_BIT, // samples
vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
vk::VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // flags
- (vk::VkRenderPass)0u, // renderPass
- 0u, // subpass
- (vk::VkFramebuffer)0u, // framebuffer
- vk::VK_FALSE, // occlusionQueryEnable
- (vk::VkQueryControlFlags)0,
- (vk::VkQueryPipelineStatisticFlags)0,
+ (const vk::VkCommandBufferInheritanceInfo*)DE_NULL,
};
const vk::VkImageSubresourceLayers firstSlice =
{
m_targetSize.y(), // bufferImageHeight
firstSlice, // imageSubresource
{ 0, 0, 0 }, // imageOffset
- { (deInt32)m_targetSize.x(), (deInt32)m_targetSize.y(), 1 } // imageExtent
+ { m_targetSize.x(), m_targetSize.y(), 1u } // imageExtent
};
const de::MovePtr<vk::Allocation> bufferMemory = allocateAndBindObjectMemory(m_vki, m_device, m_allocator, *buffer, vk::MemoryRequirement::HostVisible);
const vk::Unique<vk::VkCommandBuffer> cmd (vk::allocateCommandBuffer(m_vki, m_device, &cmdBufAllocInfo));
const vk::Unique<vk::VkFence> cmdCompleteFence (vk::createFence(m_vki, m_device, &fenceCreateInfo));
- const void* const imageBarrierPtr = &imageBarrier;
- const void* const bufferBarrierPtr = &memoryBarrier;
const deUint64 infiniteTimeout = ~(deUint64)0u;
// copy content to buffer
VK_CHECK(m_vki.beginCommandBuffer(*cmd, &cmdBufBeginInfo));
- m_vki.cmdPipelineBarrier(*cmd, vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_FALSE, 1, &imageBarrierPtr);
+ m_vki.cmdPipelineBarrier(*cmd, vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &imageBarrier);
m_vki.cmdCopyImageToBuffer(*cmd, *m_colorAttachmentImage, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, 1, ©Region);
- m_vki.cmdPipelineBarrier(*cmd, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, vk::VK_FALSE, 1, &bufferBarrierPtr);
+ m_vki.cmdPipelineBarrier(*cmd, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 1, &memoryBarrier,
+ 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(m_vki.endCommandBuffer(*cmd));
// wait for transfer to complete
DE_NULL,
0u,
(const vk::VkSemaphore*)0,
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1u,
&cmd.get(),
0u,
vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
vk::VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // flags
- (vk::VkRenderPass)0u, // renderPass
- 0u, // subpass
- (vk::VkFramebuffer)0u, // framebuffer
- vk::VK_FALSE, // occlusionQueryEnable
- (vk::VkQueryControlFlags)0,
- (vk::VkQueryPipelineStatisticFlags)0,
+ (const vk::VkCommandBufferInheritanceInfo*)DE_NULL,
};
const vk::Unique<vk::VkCommandBuffer> cmd (vk::allocateCommandBuffer(m_vki, m_device, &cmdBufAllocInfo));
- const void* const imageBarrierPtr = &imageBarrier;
VK_CHECK(m_vki.beginCommandBuffer(*cmd, &cmdBufBeginInfo));
- m_vki.cmdPipelineBarrier(*cmd, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, vk::VK_FALSE, 1, &imageBarrierPtr);
+ m_vki.cmdPipelineBarrier(*cmd, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &imageBarrier);
VK_CHECK(m_vki.endCommandBuffer(*cmd));
{
DE_NULL,
0u,
(const vk::VkSemaphore*)0,
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1u,
&cmd.get(),
0u,
{
vk::VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO,
DE_NULL,
- (vk::VkPipelineTesselationStateCreateFlags)0,
+ (vk::VkPipelineTessellationStateCreateFlags)0,
3u, // patchControlPoints
};
const vk::VkViewport viewport =
};
const vk::VkRect2D renderArea =
{
- { 0, 0 }, // offset
- { (deInt32)m_targetSize.x(), (deInt32)m_targetSize.y() }, // extent
+ { 0, 0 }, // offset
+ { m_targetSize.x(), m_targetSize.y() }, // extent
};
const vk::VkPipelineViewportStateCreateInfo vpState =
{
{
const vk::VkRect2D renderArea =
{
- { 0, 0 }, // offset
- { (deInt32)m_targetSize.x(), (deInt32)m_targetSize.y() }, // extent
+ { 0, 0 }, // offset
+ { m_targetSize.x(), m_targetSize.y() }, // extent
};
const vk::VkCommandBufferAllocateInfo mainCmdBufCreateInfo =
{
vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
vk::VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // flags
- (vk::VkRenderPass)0u, // renderPass
- 0u, // subpass
- (vk::VkFramebuffer)0u, // framebuffer
- vk::VK_FALSE, // occlusionQueryEnable
- (vk::VkQueryControlFlags)0,
- (vk::VkQueryPipelineStatisticFlags)0,
+ (const vk::VkCommandBufferInheritanceInfo*)DE_NULL,
};
const vk::VkCommandBufferAllocateInfo passCmdBufCreateInfo =
{
vk::VK_COMMAND_BUFFER_LEVEL_SECONDARY, // level
1u, // count
};
- const vk::VkCommandBufferBeginInfo passCmdBufBeginInfo =
+ const vk::VkCommandBufferInheritanceInfo passCmdBufInheritInfo =
{
- vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+ vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
DE_NULL,
- vk::VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT |
- vk::VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, // flags
(vk::VkRenderPass)*m_renderPass, // renderPass
0u, // subpass
(vk::VkFramebuffer)*m_framebuffer, // framebuffer
(vk::VkQueryControlFlags)0,
(vk::VkQueryPipelineStatisticFlags)0,
};
+ const vk::VkCommandBufferBeginInfo passCmdBufBeginInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+ DE_NULL,
+ vk::VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT |
+ vk::VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, // flags
+ &passCmdBufInheritInfo,
+ };
const vk::VkFenceCreateInfo fenceCreateInfo =
{
vk::VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
DE_NULL,
0u,
(const vk::VkSemaphore*)0,
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1u,
&mainCmd.get(),
0u,
// make host writes device-visible
const vk::VkAccessFlags inputBit = (isUniformBuffer) ? (vk::VK_ACCESS_UNIFORM_READ_BIT) : (vk::VK_ACCESS_SHADER_READ_BIT);
- const vk::VkBufferMemoryBarrier memoryBarrierA =
- {
- vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
- DE_NULL,
- vk::VK_ACCESS_HOST_WRITE_BIT, // outputMask
- inputBit, // inputMask
- vk::VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex
- vk::VK_QUEUE_FAMILY_IGNORED, // destQueueFamilyIndex
- *m_sourceBufferA, // buffer
- 0u, // offset
- (vk::VkDeviceSize)m_bufferSizeA, // size
- };
- const vk::VkBufferMemoryBarrier memoryBarrierB =
+ const vk::VkBufferMemoryBarrier memoryBarriers[] =
{
- vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
- DE_NULL,
- vk::VK_ACCESS_HOST_WRITE_BIT, // outputMask
- inputBit, // inputMask
- vk::VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex
- vk::VK_QUEUE_FAMILY_IGNORED, // destQueueFamilyIndex
- *m_sourceBufferB, // buffer
- 0u, // offset
- (vk::VkDeviceSize)m_bufferSizeB, // size
- };
- const void* const memoryBarriers[2] =
- {
- &memoryBarrierA,
- &memoryBarrierB,
+ {
+ vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+ DE_NULL,
+ vk::VK_ACCESS_HOST_WRITE_BIT, // outputMask
+ inputBit, // inputMask
+ vk::VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex
+ vk::VK_QUEUE_FAMILY_IGNORED, // destQueueFamilyIndex
+ *m_sourceBufferA, // buffer
+ 0u, // offset
+ (vk::VkDeviceSize)m_bufferSizeA, // size
+ },
+ {
+ vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+ DE_NULL,
+ vk::VK_ACCESS_HOST_WRITE_BIT, // outputMask
+ inputBit, // inputMask
+ vk::VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex
+ vk::VK_QUEUE_FAMILY_IGNORED, // destQueueFamilyIndex
+ *m_sourceBufferB, // buffer
+ 0u, // offset
+ (vk::VkDeviceSize)m_bufferSizeB, // size
+ }
};
const deUint32 numMemoryBarriers = getInterfaceNumResources(m_shaderInterface);
m_vki.cmdBindDescriptorSets(cmd, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, getPipelineLayout(), 0, 1, &m_descriptorSet.get(), numOffsets, dynamicOffsetPtr);
- m_vki.cmdPipelineBarrier(cmd, 0u, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_FALSE, numMemoryBarriers, memoryBarriers);
+ m_vki.cmdPipelineBarrier(cmd, 0u, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ numMemoryBarriers, memoryBarriers,
+ 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
m_vki.cmdDraw(cmd, 6 * 4, 1, 0, 0); // render four quads (two separate triangles)
}
void readResultContentsTo (tcu::Vec4 (*results)[4]) const;
inline vk::VkBuffer getBuffer (void) const { return *m_buffer; }
- inline const void* getResultReadBarrier (void) const { return &m_bufferBarrier; }
+ inline const vk::VkBufferMemoryBarrier* getResultReadBarrier (void) const { return &m_bufferBarrier; }
private:
static vk::Move<vk::VkBuffer> createResultBuffer (const vk::DeviceInterface& vki,
class ComputeCommand
{
public:
- ComputeCommand (const vk::DeviceInterface& vki,
- vk::VkDevice device,
- vk::VkPipeline pipeline,
- vk::VkPipelineLayout pipelineLayout,
- const tcu::UVec3& numWorkGroups,
- int numDescriptorSets,
- const vk::VkDescriptorSet* descriptorSets,
- int numDynamicOffsets,
- const deUint32* dynamicOffsets,
- int numPreBarriers,
- const void* const* preBarriers,
- int numPostBarriers,
- const void* const* postBarriers);
-
- void submitAndWait (deUint32 queueFamilyIndex, vk::VkQueue queue) const;
+ ComputeCommand (const vk::DeviceInterface& vki,
+ vk::VkDevice device,
+ vk::VkPipeline pipeline,
+ vk::VkPipelineLayout pipelineLayout,
+ const tcu::UVec3& numWorkGroups,
+ int numDescriptorSets,
+ const vk::VkDescriptorSet* descriptorSets,
+ int numDynamicOffsets,
+ const deUint32* dynamicOffsets,
+ int numPreBarriers,
+ const vk::VkBufferMemoryBarrier* preBarriers,
+ int numPostBarriers,
+ const vk::VkBufferMemoryBarrier* postBarriers);
+
+ void submitAndWait (deUint32 queueFamilyIndex, vk::VkQueue queue) const;
private:
- const vk::DeviceInterface& m_vki;
- const vk::VkDevice m_device;
- const vk::VkPipeline m_pipeline;
- const vk::VkPipelineLayout m_pipelineLayout;
- const tcu::UVec3 m_numWorkGroups;
- const int m_numDescriptorSets;
- const vk::VkDescriptorSet* const m_descriptorSets;
- const int m_numDynamicOffsets;
- const deUint32* const m_dynamicOffsets;
- const int m_numPreBarriers;
- const void* const* const m_preBarriers;
- const int m_numPostBarriers;
- const void* const* const m_postBarriers;
+ const vk::DeviceInterface& m_vki;
+ const vk::VkDevice m_device;
+ const vk::VkPipeline m_pipeline;
+ const vk::VkPipelineLayout m_pipelineLayout;
+ const tcu::UVec3 m_numWorkGroups;
+ const int m_numDescriptorSets;
+ const vk::VkDescriptorSet* const m_descriptorSets;
+ const int m_numDynamicOffsets;
+ const deUint32* const m_dynamicOffsets;
+ const int m_numPreBarriers;
+ const vk::VkBufferMemoryBarrier* const m_preBarriers;
+ const int m_numPostBarriers;
+ const vk::VkBufferMemoryBarrier* const m_postBarriers;
};
-ComputeCommand::ComputeCommand (const vk::DeviceInterface& vki,
- vk::VkDevice device,
- vk::VkPipeline pipeline,
- vk::VkPipelineLayout pipelineLayout,
- const tcu::UVec3& numWorkGroups,
- int numDescriptorSets,
- const vk::VkDescriptorSet* descriptorSets,
- int numDynamicOffsets,
- const deUint32* dynamicOffsets,
- int numPreBarriers,
- const void* const* preBarriers,
- int numPostBarriers,
- const void* const* postBarriers)
+ComputeCommand::ComputeCommand (const vk::DeviceInterface& vki,
+ vk::VkDevice device,
+ vk::VkPipeline pipeline,
+ vk::VkPipelineLayout pipelineLayout,
+ const tcu::UVec3& numWorkGroups,
+ int numDescriptorSets,
+ const vk::VkDescriptorSet* descriptorSets,
+ int numDynamicOffsets,
+ const deUint32* dynamicOffsets,
+ int numPreBarriers,
+ const vk::VkBufferMemoryBarrier* preBarriers,
+ int numPostBarriers,
+ const vk::VkBufferMemoryBarrier* postBarriers)
: m_vki (vki)
, m_device (device)
, m_pipeline (pipeline)
vk::VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
DE_NULL,
vk::VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, // flags
- queueFamilyIndex, // queueFamilyIndex
+ queueFamilyIndex, // queueFamilyIndex
};
const vk::Unique<vk::VkCommandPool> cmdPool (vk::createCommandPool(m_vki, m_device, &cmdPoolCreateInfo));
vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
vk::VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // flags
- (vk::VkRenderPass)0u, // renderPass
- 0u, // subpass
- (vk::VkFramebuffer)0u, // framebuffer
- vk::VK_FALSE, // occlusionQueryEnable
- (vk::VkQueryControlFlags)0,
- (vk::VkQueryPipelineStatisticFlags)0,
+ (const vk::VkCommandBufferInheritanceInfo*)DE_NULL,
};
const vk::Unique<vk::VkFence> cmdCompleteFence (vk::createFence(m_vki, m_device, &fenceCreateInfo));
m_vki.cmdBindDescriptorSets(*cmd, vk::VK_PIPELINE_BIND_POINT_COMPUTE, m_pipelineLayout, 0, m_numDescriptorSets, m_descriptorSets, m_numDynamicOffsets, m_dynamicOffsets);
if (m_numPreBarriers)
- m_vki.cmdPipelineBarrier(*cmd, 0u, vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, vk::VK_FALSE, m_numPreBarriers, m_preBarriers);
+ m_vki.cmdPipelineBarrier(*cmd, 0u, vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ m_numPreBarriers, m_preBarriers,
+ 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
m_vki.cmdDispatch(*cmd, m_numWorkGroups.x(), m_numWorkGroups.y(), m_numWorkGroups.z());
- m_vki.cmdPipelineBarrier(*cmd, vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, vk::VK_FALSE, m_numPostBarriers, m_postBarriers);
+ m_vki.cmdPipelineBarrier(*cmd, vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ m_numPostBarriers, m_postBarriers,
+ 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(m_vki.endCommandBuffer(*cmd));
// run
DE_NULL,
0u,
(const vk::VkSemaphore*)0,
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1u,
&cmd.get(),
0u,
const ComputePipeline pipeline (m_vki, m_device, m_context.getBinaryCollection(), 1, &descriptorSetLayout.get());
const vk::VkAccessFlags inputBit = (isUniformBuffer) ? (vk::VK_ACCESS_UNIFORM_READ_BIT) : (vk::VK_ACCESS_SHADER_READ_BIT);
- const vk::VkBufferMemoryBarrier bufferBarrierA =
+ const vk::VkBufferMemoryBarrier bufferBarriers[] =
{
- vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
- DE_NULL,
- vk::VK_ACCESS_HOST_WRITE_BIT, // outputMask
- inputBit, // inputMask
- vk::VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex
- vk::VK_QUEUE_FAMILY_IGNORED, // destQueueFamilyIndex
- *bufferA, // buffer
- (vk::VkDeviceSize)0u, // offset
- (vk::VkDeviceSize)bufferSizeA, // size
- };
- const vk::VkBufferMemoryBarrier bufferBarrierB =
- {
- vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
- DE_NULL,
- vk::VK_ACCESS_HOST_WRITE_BIT, // outputMask
- inputBit, // inputMask
- vk::VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex
- vk::VK_QUEUE_FAMILY_IGNORED, // destQueueFamilyIndex
- *bufferB, // buffer
- (vk::VkDeviceSize)0u, // offset
- (vk::VkDeviceSize)bufferSizeB, // size
+ {
+ vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+ DE_NULL,
+ vk::VK_ACCESS_HOST_WRITE_BIT, // outputMask
+ inputBit, // inputMask
+ vk::VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex
+ vk::VK_QUEUE_FAMILY_IGNORED, // destQueueFamilyIndex
+ *bufferA, // buffer
+ (vk::VkDeviceSize)0u, // offset
+ (vk::VkDeviceSize)bufferSizeA, // size
+ },
+ {
+ vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+ DE_NULL,
+ vk::VK_ACCESS_HOST_WRITE_BIT, // outputMask
+ inputBit, // inputMask
+ vk::VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex
+ vk::VK_QUEUE_FAMILY_IGNORED, // destQueueFamilyIndex
+ *bufferB, // buffer
+ (vk::VkDeviceSize)0u, // offset
+ (vk::VkDeviceSize)bufferSizeB, // size
+ }
};
const deUint32 numSrcBuffers = getInterfaceNumResources(m_shaderInterface);
const int numDescriptorSets = DE_LENGTH_OF_ARRAY(descriptorSets);
const deUint32* const dynamicOffsets = (m_setDynamicOffset) ? (bindTimeOffsets) : (DE_NULL);
const deUint32 numDynamicOffsets = (m_setDynamicOffset) ? (numSrcBuffers) : (0);
- const void* const preBarriers[] = { &bufferBarrierA, &bufferBarrierB };
+ const vk::VkBufferMemoryBarrier* const preBarriers = bufferBarriers;
const int numPreBarriers = numSrcBuffers;
- const void* const postBarriers[] = { m_result.getResultReadBarrier() };
- const int numPostBarriers = DE_LENGTH_OF_ARRAY(postBarriers);
+ const vk::VkBufferMemoryBarrier* const postBarriers = m_result.getResultReadBarrier();
+ const int numPostBarriers = 1;
const ComputeCommand compute (m_vki,
m_device,
vk::VkQueue queue,
vk::Allocator& allocator,
vk::VkImage image,
+ vk::VkImageLayout layout,
const tcu::TextureLevelPyramid& data);
protected:
, m_imageViewA (vk::Move<vk::VkImageView>())
, m_imageViewB (vk::Move<vk::VkImageView>())
{
+ const vk::VkImageLayout layout = getImageLayoutForDescriptorType(descriptorType);
+
DE_ASSERT(numImages == 1 || numImages == 2);
populateSourceImage(&m_sourceImageA, true);
m_imageA = createImage(vki, device, allocator, descriptorType, viewType, m_sourceImageA, &m_imageMemoryA);
m_imageViewA = createImageView(vki, device, viewType, m_sourceImageA, *m_imageA, m_baseMipLevel, m_baseArraySlice);
- uploadImage(vki, device, queueFamilyIndex, queue, allocator, *m_imageA, m_sourceImageA);
+ uploadImage(vki, device, queueFamilyIndex, queue, allocator, *m_imageA, layout, m_sourceImageA);
if (numImages == 2)
{
populateSourceImage(&m_sourceImageB, false);
m_imageB = createImage(vki, device, allocator, descriptorType, viewType, m_sourceImageB, &m_imageMemoryB);
m_imageViewB = createImageView(vki, device, viewType, m_sourceImageB, *m_imageB, m_baseMipLevel, m_baseArraySlice);
- uploadImage(vki, device, queueFamilyIndex, queue, allocator, *m_imageB, m_sourceImageB);
+ uploadImage(vki, device, queueFamilyIndex, queue, allocator, *m_imageB, layout, m_sourceImageB);
}
}
const vk::VkExtent3D extent =
{
// x
- (deInt32)baseLevel.getWidth(),
+ (deUint32)baseLevel.getWidth(),
// y
- (viewType == vk::VK_IMAGE_VIEW_TYPE_1D || viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY) ? (1) : (deInt32)baseLevel.getHeight(),
+ (viewType == vk::VK_IMAGE_VIEW_TYPE_1D || viewType == vk::VK_IMAGE_VIEW_TYPE_1D_ARRAY) ? (1u) : (deUint32)baseLevel.getHeight(),
// z
- (viewType == vk::VK_IMAGE_VIEW_TYPE_3D) ? ((deInt32)baseLevel.getDepth()) : (1),
+ (viewType == vk::VK_IMAGE_VIEW_TYPE_3D) ? ((deUint32)baseLevel.getDepth()) : (1u),
};
const vk::VkImageCreateInfo createInfo =
{
vk::VkQueue queue,
vk::Allocator& allocator,
vk::VkImage image,
+ vk::VkImageLayout layout,
const tcu::TextureLevelPyramid& data)
{
const deUint32 arraySize = (m_viewType == vk::VK_IMAGE_VIEW_TYPE_3D) ? (1) :
vk::VK_ACCESS_TRANSFER_WRITE_BIT, // outputMask
vk::VK_ACCESS_SHADER_READ_BIT, // inputMask
vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // oldLayout
- vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, // newLayout
+ layout, // newLayout
vk::VK_QUEUE_FAMILY_IGNORED, // srcQueueFamilyIndex
vk::VK_QUEUE_FAMILY_IGNORED, // destQueueFamilyIndex
image, // image
vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
vk::VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // flags
- (vk::VkRenderPass)0u, // renderPass
- 0u, // subpass
- (vk::VkFramebuffer)0u, // framebuffer
- vk::VK_FALSE, // occlusionQueryEnable
- (vk::VkQueryControlFlags)0,
- (vk::VkQueryPipelineStatisticFlags)0,
+ (const vk::VkCommandBufferInheritanceInfo*)DE_NULL,
};
const vk::Unique<vk::VkCommandBuffer> cmd (vk::allocateCommandBuffer(vki, device, &cmdBufCreateInfo));
- const void* const preBarriers[2] = { &preMemoryBarrier, &preImageBarrier };
- const void* const postBarriers[1] = { &postImageBarrier };
const vk::Unique<vk::VkFence> cmdCompleteFence (vk::createFence(vki, device, &fenceCreateInfo));
const deUint64 infiniteTimeout = ~(deUint64)0u;
std::vector<vk::VkBufferImageCopy> copySlices;
// record command buffer
VK_CHECK(vki.beginCommandBuffer(*cmd, &cmdBufBeginInfo));
- vki.cmdPipelineBarrier(*cmd, 0u, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_FALSE, DE_LENGTH_OF_ARRAY(preBarriers), preBarriers);
+ vki.cmdPipelineBarrier(*cmd, 0u, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 1, &preMemoryBarrier,
+ 1, &preImageBarrier);
vki.cmdCopyBufferToImage(*cmd, *dataBuffer, image, vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)copySlices.size(), ©Slices[0]);
- vki.cmdPipelineBarrier(*cmd, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, vk::VK_FALSE, DE_LENGTH_OF_ARRAY(postBarriers), postBarriers);
+ vki.cmdPipelineBarrier(*cmd, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &postImageBarrier);
VK_CHECK(vki.endCommandBuffer(*cmd));
// submit and wait for command buffer to complete before killing it
DE_NULL,
0u,
(const vk::VkSemaphore*)0,
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1u,
&cmd.get(),
0u,
vk::VkImageView viewA,
vk::VkImageView viewB)
{
+ const vk::VkImageLayout imageLayout = getImageLayoutForDescriptorType(descriptorType);
const vk::VkDescriptorImageInfo imageInfos[2] =
{
- makeDescriptorImageInfo(viewA, vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL),
- makeDescriptorImageInfo(viewB, vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL),
+ makeDescriptorImageInfo(viewA, imageLayout),
+ makeDescriptorImageInfo(viewB, imageLayout),
};
const vk::VkDescriptorSetAllocateInfo allocInfo =
{
vk::Move<vk::VkDescriptorSet> ImageFetchComputeInstance::createDescriptorSet (vk::VkDescriptorPool pool, vk::VkDescriptorSetLayout layout) const
{
const vk::VkDescriptorBufferInfo resultInfo = vk::makeDescriptorBufferInfo(m_result.getBuffer(), 0u, (vk::VkDeviceSize)ComputeInstanceResultBuffer::DATA_SIZE);
+ const vk::VkImageLayout imageLayout = getImageLayoutForDescriptorType(m_descriptorType);
const vk::VkDescriptorImageInfo imageInfos[2] =
{
- makeDescriptorImageInfo(m_images.getImageViewA(), vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL),
- makeDescriptorImageInfo(m_images.getImageViewB(), vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL),
+ makeDescriptorImageInfo(m_images.getImageViewA(), imageLayout),
+ makeDescriptorImageInfo(m_images.getImageViewB(), imageLayout),
};
const vk::VkDescriptorSetAllocateInfo allocInfo =
{
const int numDescriptorSets = DE_LENGTH_OF_ARRAY(descriptorSets);
const deUint32* const dynamicOffsets = DE_NULL;
const int numDynamicOffsets = 0;
- const void* const* preBarriers = DE_NULL;
+ const vk::VkBufferMemoryBarrier* const preBarriers = DE_NULL;
const int numPreBarriers = 0;
- const void* const postBarriers[] = { m_result.getResultReadBarrier() };
- const int numPostBarriers = DE_LENGTH_OF_ARRAY(postBarriers);
+ const vk::VkBufferMemoryBarrier* const postBarriers = m_result.getResultReadBarrier();
+ const int numPostBarriers = 1;
const ComputeCommand compute (m_vki,
m_device,
vk::Move<vk::VkSampler> ImageSampleInstanceImages::createSampler (const vk::DeviceInterface& vki, vk::VkDevice device, const tcu::Sampler& sampler, const tcu::TextureFormat& format)
{
- const bool compareEnabled = (sampler.compare != tcu::Sampler::COMPAREMODE_NONE);
- const vk::VkCompareOp compareOp = (compareEnabled) ? (vk::mapCompareMode(sampler.compare)) : (vk::VK_COMPARE_OP_ALWAYS);
- const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(format.type);
- const bool isIntTexture = channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER || channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
- const vk::VkBorderColor borderColor = (isIntTexture) ? (vk::VK_BORDER_COLOR_INT_OPAQUE_WHITE) : (vk::VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE);
- const vk::VkSamplerCreateInfo createInfo =
- {
- vk::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
- DE_NULL,
- (vk::VkSamplerCreateFlags)0,
- vk::mapFilterMode(sampler.magFilter), // magFilter
- vk::mapFilterMode(sampler.minFilter), // minFilter
- vk::mapMipmapMode(sampler.minFilter), // mipMode
- vk::mapWrapMode(sampler.wrapS), // addressU
- vk::mapWrapMode(sampler.wrapT), // addressV
- vk::mapWrapMode(sampler.wrapR), // addressW
- 0.0f, // mipLodBias
- 1, // maxAnisotropy
- (vk::VkBool32)(compareEnabled ? vk::VK_TRUE : vk::VK_FALSE), // compareEnable
- compareOp, // compareOp
- 0.0f, // minLod
- 0.0f, // maxLod
- borderColor, // borderColor
- vk::VK_FALSE, // unnormalizedCoords
- };
+ const vk::VkSamplerCreateInfo createInfo = vk::mapSampler(sampler, format);
+
return vk::createSampler(vki, device, &createInfo);
}
static vk::Move<vk::VkDescriptorPool> createDescriptorPool (const vk::DeviceInterface& vki,
vk::VkDevice device,
vk::VkDescriptorType descriptorType,
- ShaderInputInterface shaderInterface,
- bool isImmutable);
+ ShaderInputInterface shaderInterface);
static vk::Move<vk::VkDescriptorSet> createDescriptorSet (const vk::DeviceInterface& vki,
vk::VkDevice device,
, m_images (m_vki, m_device, m_queueFamilyIndex, m_queue, m_allocator, m_descriptorType, m_shaderInterface, m_viewType, m_baseMipLevel, m_baseArraySlice, isImmutable)
, m_descriptorSetLayout (createDescriptorSetLayout(m_vki, m_device, m_descriptorType, m_shaderInterface, m_stageFlags, m_images))
, m_pipelineLayout (createPipelineLayout(m_vki, m_device, *m_descriptorSetLayout))
- , m_descriptorPool (createDescriptorPool(m_vki, m_device, m_descriptorType, m_shaderInterface, isImmutable))
+ , m_descriptorPool (createDescriptorPool(m_vki, m_device, m_descriptorType, m_shaderInterface))
, m_descriptorSet (createDescriptorSet(m_vki, m_device, m_descriptorType, m_shaderInterface, *m_descriptorSetLayout, *m_descriptorPool, isImmutable, m_images))
{
}
vk::Move<vk::VkDescriptorPool> ImageSampleRenderInstance::createDescriptorPool (const vk::DeviceInterface& vki,
vk::VkDevice device,
vk::VkDescriptorType descriptorType,
- ShaderInputInterface shaderInterface,
- bool isImmutable)
+ ShaderInputInterface shaderInterface)
{
vk::DescriptorPoolBuilder builder;
// separate samplers need image to sample
builder.addType(vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
- // samplers needed only if they are specified in the descriptor set
- if (!isImmutable)
- builder.addType(vk::VK_DESCRIPTOR_TYPE_SAMPLER, getInterfaceNumResources(shaderInterface));
+ // also need sample to use, indifferent of whether immutable or not
+ builder.addType(vk::VK_DESCRIPTOR_TYPE_SAMPLER, getInterfaceNumResources(shaderInterface));
}
else if (descriptorType == vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
{
const int numDescriptorSets = DE_LENGTH_OF_ARRAY(descriptorSets);
const deUint32* const dynamicOffsets = DE_NULL;
const int numDynamicOffsets = 0;
- const void* const* preBarriers = DE_NULL;
+ const vk::VkBufferMemoryBarrier* const preBarriers = DE_NULL;
const int numPreBarriers = 0;
- const void* const postBarriers[] = { m_result.getResultReadBarrier() };
- const int numPostBarriers = DE_LENGTH_OF_ARRAY(postBarriers);
+ const vk::VkBufferMemoryBarrier* const postBarriers = m_result.getResultReadBarrier();
+ const int numPostBarriers = 1;
const ComputeCommand compute (m_vki,
m_device,
class TexelBufferInstanceBuffers
{
public:
- TexelBufferInstanceBuffers (const vk::DeviceInterface& vki,
- vk::VkDevice device,
- vk::Allocator& allocator,
- vk::VkDescriptorType descriptorType,
- int numTexelBuffers,
- bool hasViewOffset);
+ TexelBufferInstanceBuffers (const vk::DeviceInterface& vki,
+ vk::VkDevice device,
+ vk::Allocator& allocator,
+ vk::VkDescriptorType descriptorType,
+ int numTexelBuffers,
+ bool hasViewOffset);
private:
- static vk::Move<vk::VkBuffer> createBuffer (const vk::DeviceInterface& vki,
- vk::VkDevice device,
- vk::Allocator& allocator,
- vk::VkDescriptorType descriptorType,
- de::MovePtr<vk::Allocation> *outAllocation);
+ static vk::Move<vk::VkBuffer> createBuffer (const vk::DeviceInterface& vki,
+ vk::VkDevice device,
+ vk::Allocator& allocator,
+ vk::VkDescriptorType descriptorType,
+ de::MovePtr<vk::Allocation> *outAllocation);
- static vk::Move<vk::VkBufferView> createBufferView (const vk::DeviceInterface& vki,
- vk::VkDevice device,
- const tcu::TextureFormat& textureFormat,
- deUint32 offset,
- vk::VkBuffer buffer);
+ static vk::Move<vk::VkBufferView> createBufferView (const vk::DeviceInterface& vki,
+ vk::VkDevice device,
+ const tcu::TextureFormat& textureFormat,
+ deUint32 offset,
+ vk::VkBuffer buffer);
- static vk::VkBufferMemoryBarrier createBarrier (vk::VkDescriptorType descriptorType, vk::VkBuffer buffer);
+ static vk::VkBufferMemoryBarrier createBarrier (vk::VkDescriptorType descriptorType, vk::VkBuffer buffer);
- void populateSourceBuffer (const tcu::PixelBufferAccess& access);
- void uploadData (const vk::DeviceInterface& vki, vk::VkDevice device, const vk::Allocation& memory, const de::ArrayBuffer<deUint8>& data);
+ void populateSourceBuffer (const tcu::PixelBufferAccess& access);
+ void uploadData (const vk::DeviceInterface& vki, vk::VkDevice device, const vk::Allocation& memory, const de::ArrayBuffer<deUint8>& data);
public:
- static int getFetchPos (int fetchPosNdx);
- tcu::Vec4 fetchTexelValue (int fetchPosNdx) const;
+ static int getFetchPos (int fetchPosNdx);
+ tcu::Vec4 fetchTexelValue (int fetchPosNdx) const;
- inline int getNumTexelBuffers (void) const { return m_numTexelBuffers; }
- const tcu::TextureFormat& getTextureFormat (void) const { return m_imageFormat; }
- inline vk::VkBufferView getBufferViewA (void) const { return *m_bufferViewA; }
- inline vk::VkBufferView getBufferViewB (void) const { return *m_bufferViewB; }
- inline const void* getBufferInitBarrierA (void) const { return &m_bufferBarrierA; }
- inline const void* getBufferInitBarrierB (void) const { return &m_bufferBarrierB; }
+ inline int getNumTexelBuffers (void) const { return m_numTexelBuffers; }
+ const tcu::TextureFormat& getTextureFormat (void) const { return m_imageFormat; }
+ inline vk::VkBufferView getBufferViewA (void) const { return *m_bufferViewA; }
+ inline vk::VkBufferView getBufferViewB (void) const { return *m_bufferViewB; }
+ inline const vk::VkBufferMemoryBarrier* getBufferInitBarriers (void) const { return m_bufferBarriers; }
private:
enum
SAMPLE_POINT_3 = 25,
};
- const deUint32 m_numTexelBuffers;
- const tcu::TextureFormat m_imageFormat;
- const deUint32 m_viewOffset;
-
- de::ArrayBuffer<deUint8> m_sourceBufferA;
- de::ArrayBuffer<deUint8> m_sourceBufferB;
- const tcu::ConstPixelBufferAccess m_sourceViewA;
- const tcu::ConstPixelBufferAccess m_sourceViewB;
-
- de::MovePtr<vk::Allocation> m_bufferMemoryA;
- de::MovePtr<vk::Allocation> m_bufferMemoryB;
- const vk::Unique<vk::VkBuffer> m_bufferA;
- const vk::Unique<vk::VkBuffer> m_bufferB;
- const vk::Unique<vk::VkBufferView> m_bufferViewA;
- const vk::Unique<vk::VkBufferView> m_bufferViewB;
- const vk::VkBufferMemoryBarrier m_bufferBarrierA;
- const vk::VkBufferMemoryBarrier m_bufferBarrierB;
+ const deUint32 m_numTexelBuffers;
+ const tcu::TextureFormat m_imageFormat;
+ const deUint32 m_viewOffset;
+
+ de::ArrayBuffer<deUint8> m_sourceBufferA;
+ de::ArrayBuffer<deUint8> m_sourceBufferB;
+ const tcu::ConstPixelBufferAccess m_sourceViewA;
+ const tcu::ConstPixelBufferAccess m_sourceViewB;
+
+ de::MovePtr<vk::Allocation> m_bufferMemoryA;
+ de::MovePtr<vk::Allocation> m_bufferMemoryB;
+ const vk::Unique<vk::VkBuffer> m_bufferA;
+ const vk::Unique<vk::VkBuffer> m_bufferB;
+ const vk::Unique<vk::VkBufferView> m_bufferViewA;
+ const vk::Unique<vk::VkBufferView> m_bufferViewB;
+ vk::VkBufferMemoryBarrier m_bufferBarriers[2];
};
TexelBufferInstanceBuffers::TexelBufferInstanceBuffers (const vk::DeviceInterface& vki,
, m_bufferViewB ((numTexelBuffers == 1)
? vk::Move<vk::VkBufferView>()
: createBufferView(vki, device, m_imageFormat, m_viewOffset, *m_bufferB))
- , m_bufferBarrierA (createBarrier(descriptorType, *m_bufferA))
- , m_bufferBarrierB (createBarrier(descriptorType, *m_bufferB))
{
DE_ASSERT(numTexelBuffers == 1 || numTexelBuffers == 2);
DE_ASSERT(VIEW_WIDTH * m_imageFormat.getPixelSize() == VIEW_DATA_SIZE);
populateSourceBuffer(tcu::PixelBufferAccess(m_imageFormat, tcu::IVec3(BUFFER_SIZE / m_imageFormat.getPixelSize(), 1, 1), m_sourceBufferB.getPtr()));
uploadData(vki, device, *m_bufferMemoryB, m_sourceBufferB);
}
+
+ m_bufferBarriers[0] = createBarrier(descriptorType, *m_bufferA);
+ m_bufferBarriers[1] = createBarrier(descriptorType, *m_bufferB);
}
vk::Move<vk::VkBuffer> TexelBufferInstanceBuffers::createBuffer (const vk::DeviceInterface& vki,
const int numDescriptorSets = DE_LENGTH_OF_ARRAY(descriptorSets);
const deUint32* const dynamicOffsets = DE_NULL;
const int numDynamicOffsets = 0;
- const void* const preBarriers[] = { m_texelBuffers.getBufferInitBarrierA(), m_texelBuffers.getBufferInitBarrierB() };
+ const vk::VkBufferMemoryBarrier* const preBarriers = m_texelBuffers.getBufferInitBarriers();
const int numPreBarriers = m_texelBuffers.getNumTexelBuffers();
- const void* const postBarriers[] = { m_result.getResultReadBarrier() };
- const int numPostBarriers = DE_LENGTH_OF_ARRAY(postBarriers);
+ const vk::VkBufferMemoryBarrier* const postBarriers = m_result.getResultReadBarrier();
+ const int numPostBarriers = 1;
const ComputeCommand compute (m_vki,
m_device,
const Unique<VkPipeline> pipeline(makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));
const VkBufferMemoryBarrier computeFinishBarrier = makeBufferMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *buffer, 0ull, bufferSizeBytes);
- const void* barriers[] = { &computeFinishBarrier };
const Unique<VkCommandPool> cmdPool(makeCommandPool(vk, device, queueFamilyIndex));
const Unique<VkCommandBuffer> cmdBuffer(makeCommandBuffer(vk, device, *cmdPool));
vk.cmdDispatch(*cmdBuffer, m_workSize.x(), m_workSize.y(), m_workSize.z());
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &computeFinishBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
endCommandBuffer(vk, *cmdBuffer);
const Unique<VkPipeline> pipeline(makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));
const VkBufferMemoryBarrier computeFinishBarrier = makeBufferMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *buffer, 0ull, bufferSizeBytes);
- const void* barriers[] = { &computeFinishBarrier };
const Unique<VkCommandPool> cmdPool(makeCommandPool(vk, device, queueFamilyIndex));
const Unique<VkCommandBuffer> cmdBuffer(makeCommandBuffer(vk, device, *cmdPool));
vk.cmdDispatch(*cmdBuffer, m_workSize.x(), m_workSize.y(), m_workSize.z());
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &computeFinishBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
endCommandBuffer(vk, *cmdBuffer);
const Unique<VkPipeline> pipeline(makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));
const VkBufferMemoryBarrier computeFinishBarrier = makeBufferMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *buffer, 0ull, bufferSizeBytes);
- const void* barriers[] = { &computeFinishBarrier };
const Unique<VkCommandPool> cmdPool(makeCommandPool(vk, device, queueFamilyIndex));
const Unique<VkCommandBuffer> cmdBuffer(makeCommandBuffer(vk, device, *cmdPool));
vk.cmdDispatch(*cmdBuffer, m_workSize.x(), m_workSize.y(), m_workSize.z());
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &computeFinishBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
endCommandBuffer(vk, *cmdBuffer);
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
*image, subresourceRange);
- const void* preCopyBarriers[] = { &stagingBufferPostHostWriteBarrier, &imagePreCopyBarrier };
- const void* postCopyBarriers[] = { &imagePostCopyBarrier };
-
const VkBufferMemoryBarrier computeFinishBarrier = makeBufferMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *outputBuffer, 0ull, bufferSizeBytes);
- const void* postComputeBarriers[] = { &computeFinishBarrier };
const VkBufferImageCopy copyParams = makeBufferImageCopy(m_imageSize);
const tcu::IVec2 workSize = m_imageSize / m_localSize;
vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
- vk.cmdPipelineBarrier(*cmdBuffer, 0u, VK_PIPELINE_STAGE_TRANSFER_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(preCopyBarriers), preCopyBarriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, 0u, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &stagingBufferPostHostWriteBarrier, 1, &imagePreCopyBarrier);
vk.cmdCopyBufferToImage(*cmdBuffer, *stagingBuffer, *image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, ©Params);
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(postCopyBarriers), postCopyBarriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &imagePostCopyBarrier);
vk.cmdDispatch(*cmdBuffer, workSize.x(), workSize.y(), 1u);
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(postComputeBarriers), postComputeBarriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &computeFinishBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
endCommandBuffer(vk, *cmdBuffer);
const VkBufferMemoryBarrier outputBufferPostCopyBarrier = makeBufferMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *outputBuffer, 0ull, bufferSizeBytes);
- const void* preComputeBarriers[] = { &inputBufferPostHostWriteBarrier, &imageLayoutBarrier };
- const void* preCopyBarriers[] = { &imagePreCopyBarrier };
- const void* postCopyBarriers[] = { &outputBufferPostCopyBarrier };
-
const VkBufferImageCopy copyParams = makeBufferImageCopy(m_imageSize);
const tcu::IVec2 workSize = m_imageSize / m_localSize;
vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(preComputeBarriers), preComputeBarriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &inputBufferPostHostWriteBarrier, 1, &imageLayoutBarrier);
vk.cmdDispatch(*cmdBuffer, workSize.x(), workSize.y(), 1u);
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(preCopyBarriers), preCopyBarriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &imagePreCopyBarrier);
vk.cmdCopyImageToBuffer(*cmdBuffer, *image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *outputBuffer, 1u, ©Params);
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(postCopyBarriers), postCopyBarriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &outputBufferPostCopyBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
endCommandBuffer(vk, *cmdBuffer);
<< "layout(binding = 0) readonly uniform Input {\n"
<< " uint values[" << m_numValues << "];\n"
<< "} ub_in;\n"
- << "layout(binding = 1) writeonly buffer Output {\n"
+ << "layout(binding = 1, std140) writeonly buffer Output {\n"
<< " uint values[" << m_numValues << "];\n"
<< "} sb_out;\n"
<< "void main (void) {\n"
{
src << "#version 310 es\n"
<< "layout (local_size_x = " << m_localSize.x() << ", local_size_y = " << m_localSize.y() << ", local_size_z = " << m_localSize.z() << ") in;\n"
- << "layout(binding = 0) readonly buffer Input {\n"
+ << "layout(binding = 0, std140) readonly buffer Input {\n"
<< " uint values[" << m_numValues << "];\n"
<< "} sb_in;\n"
- << "layout (binding = 1) writeonly buffer Output {\n"
+ << "layout (binding = 1, std140) writeonly buffer Output {\n"
<< " uint values[" << m_numValues << "];\n"
<< "} sb_out;\n"
<< "void main (void) {\n"
// Create an input buffer
- const VkDeviceSize bufferSizeBytes = sizeof(deUint32) * m_numValues;
+ const VkDeviceSize bufferSizeBytes = sizeof(tcu::UVec4) * m_numValues;
const Buffer inputBuffer(vk, device, allocator, makeBufferCreateInfo(bufferSizeBytes, inputBufferUsageFlags), MemoryRequirement::HostVisible);
// Fill the input buffer with data
{
de::Random rnd(randomSeed);
const Allocation& inputBufferAllocation = inputBuffer.getAllocation();
- deUint32* bufferPtr = static_cast<deUint32*>(inputBufferAllocation.getHostPtr());
+ tcu::UVec4* bufferPtr = static_cast<tcu::UVec4*>(inputBufferAllocation.getHostPtr());
for (deUint32 i = 0; i < m_numValues; ++i)
- *bufferPtr++ = rnd.getUint32();
+ bufferPtr[i].x() = rnd.getUint32();
flushMappedMemoryRange(vk, device, inputBufferAllocation.getMemory(), inputBufferAllocation.getOffset(), bufferSizeBytes);
}
const Unique<VkPipeline> pipeline(makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));
const VkBufferMemoryBarrier hostWriteBarrier = makeBufferMemoryBarrier(VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, *inputBuffer, 0ull, bufferSizeBytes);
- const void* preComputeBarriers[] = { &hostWriteBarrier };
const VkBufferMemoryBarrier shaderWriteBarrier = makeBufferMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *outputBuffer, 0ull, bufferSizeBytes);
- const void* postComputeBarriers[] = { &shaderWriteBarrier };
const Unique<VkCommandPool> cmdPool(makeCommandPool(vk, device, queueFamilyIndex));
const Unique<VkCommandBuffer> cmdBuffer(makeCommandBuffer(vk, device, *cmdPool));
vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(preComputeBarriers), preComputeBarriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &hostWriteBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
vk.cmdDispatch(*cmdBuffer, m_workSize.x(), m_workSize.y(), m_workSize.z());
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(postComputeBarriers), postComputeBarriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &shaderWriteBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
endCommandBuffer(vk, *cmdBuffer);
const Allocation& outputBufferAllocation = outputBuffer.getAllocation();
invalidateMappedMemoryRange(vk, device, outputBufferAllocation.getMemory(), outputBufferAllocation.getOffset(), bufferSizeBytes);
- const deUint32* bufferPtr = static_cast<deUint32*>(outputBufferAllocation.getHostPtr());
- const deUint32* refBufferPtr = static_cast<deUint32*>(inputBuffer.getAllocation().getHostPtr());
+ const tcu::UVec4* bufferPtr = static_cast<tcu::UVec4*>(outputBufferAllocation.getHostPtr());
+ const tcu::UVec4* refBufferPtr = static_cast<tcu::UVec4*>(inputBuffer.getAllocation().getHostPtr());
for (deUint32 ndx = 0; ndx < m_numValues; ++ndx)
{
- const deUint32 res = bufferPtr[ndx];
- const deUint32 ref = ~refBufferPtr[ndx];
+ const deUint32 res = bufferPtr[ndx].x();
+ const deUint32 ref = ~refBufferPtr[ndx].x();
if (res != ref)
{
const Unique<VkPipeline> pipeline(makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));
const VkBufferMemoryBarrier hostWriteBarrier = makeBufferMemoryBarrier(VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, *buffer, 0ull, bufferSizeBytes);
- const void* preComputeBarriers[] = { &hostWriteBarrier };
const VkBufferMemoryBarrier shaderWriteBarrier = makeBufferMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *buffer, 0ull, bufferSizeBytes);
- const void* postComputeBarriers[] = { &shaderWriteBarrier };
const Unique<VkCommandPool> cmdPool(makeCommandPool(vk, device, queueFamilyIndex));
const Unique<VkCommandBuffer> cmdBuffer(makeCommandBuffer(vk, device, *cmdPool));
vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(preComputeBarriers), preComputeBarriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &hostWriteBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
vk.cmdDispatch(*cmdBuffer, m_workSize.x(), m_workSize.y(), m_workSize.z());
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(postComputeBarriers), postComputeBarriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &shaderWriteBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
endCommandBuffer(vk, *cmdBuffer);
const Unique<VkPipelineLayout> pipelineLayout(makePipelineLayout(vk, device, *descriptorSetLayout));
const Unique<VkPipeline> pipeline(makeComputePipeline(vk, device, *pipelineLayout, *shaderModule));
- const VkBufferMemoryBarrier shaderWriteBarrier0 = makeBufferMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *buffer0, 0ull, bufferSizeBytes);
- const VkBufferMemoryBarrier shaderWriteBarrier1 = makeBufferMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *buffer1, 0ull, bufferSizeBytes);
- const void* postComputeBarriers[] = { &shaderWriteBarrier0, &shaderWriteBarrier1 };
+ const VkBufferMemoryBarrier shaderWriteBarriers[] =
+ {
+ makeBufferMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *buffer0, 0ull, bufferSizeBytes),
+ makeBufferMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *buffer1, 0ull, bufferSizeBytes)
+ };
const Unique<VkCommandPool> cmdPool(makeCommandPool(vk, device, queueFamilyIndex));
const Unique<VkCommandBuffer> cmdBuffer(makeCommandBuffer(vk, device, *cmdPool));
vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
vk.cmdDispatch(*cmdBuffer, m_workSize.x(), m_workSize.y(), m_workSize.z());
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(postComputeBarriers), postComputeBarriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, DE_LENGTH_OF_ARRAY(shaderWriteBarriers), shaderWriteBarriers, 0, (const VkImageMemoryBarrier*)DE_NULL);
endCommandBuffer(vk, *cmdBuffer);
const Unique<VkPipeline> pipeline1(makeComputePipeline(vk, device, *pipelineLayout, *shaderModule1));
const VkBufferMemoryBarrier writeUniformConstantsBarrier = makeBufferMemoryBarrier(VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_UNIFORM_READ_BIT, *uniformBuffer, 0ull, uniformBufferSizeBytes);
- const void* barriersBeforeCompute[] = { &writeUniformConstantsBarrier };
const VkBufferMemoryBarrier betweenShadersBarrier = makeBufferMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, *workBuffer, 0ull, workBufferSizeBytes);
- const void* barriersAfterFirstShader[] = { &betweenShadersBarrier };
const VkBufferMemoryBarrier afterComputeBarrier = makeBufferMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *outputBuffer, 0ull, outputBufferSizeBytes);
- const void* barriersAfterCompute[] = { &afterComputeBarrier };
const Unique<VkCommandPool> cmdPool(makeCommandPool(vk, device, queueFamilyIndex));
const Unique<VkCommandBuffer> cmdBuffer(makeCommandBuffer(vk, device, *cmdPool));
vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline0);
vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(barriersBeforeCompute), barriersBeforeCompute);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &writeUniformConstantsBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
vk.cmdDispatch(*cmdBuffer, m_workSize.x(), m_workSize.y(), m_workSize.z());
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(barriersAfterFirstShader), barriersAfterFirstShader);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &betweenShadersBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
// Switch to the second shader program
vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline1);
vk.cmdDispatch(*cmdBuffer, m_workSize.x(), m_workSize.y(), m_workSize.z());
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(barriersAfterCompute), barriersAfterCompute);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &afterComputeBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
endCommandBuffer(vk, *cmdBuffer);
const VkBufferMemoryBarrier outputBufferPostCopyBarrier = makeBufferMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *outputBuffer, 0ull, outputBufferSizeBytes);
- const void* preComputeBarriers[] = { &inputBufferPostHostWriteBarrier };
- const void* preCopyBarriers[] = { &imagePreCopyBarrier };
- const void* postCopyBarriers[] = { &outputBufferPostCopyBarrier };
-
const VkBufferImageCopy copyParams = makeBufferImageCopy(m_imageSize);
// Prepare the command buffer
vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(preComputeBarriers), preComputeBarriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &inputBufferPostHostWriteBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
vk.cmdDispatch(*cmdBuffer, m_imageSize.x(), m_imageSize.y(), 1u);
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(preCopyBarriers), preCopyBarriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &imagePreCopyBarrier);
vk.cmdCopyImageToBuffer(*cmdBuffer, *image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *outputBuffer, 1u, ©Params);
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(postCopyBarriers), postCopyBarriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &outputBufferPostCopyBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
endCommandBuffer(vk, *cmdBuffer);
const VkDeviceSize outputBufferSizeBytes = sizeof(deUint32);
const Buffer outputBuffer(vk, device, allocator, makeBufferCreateInfo(outputBufferSizeBytes, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), MemoryRequirement::HostVisible);
+ // Initialize atomic counter value to zero
+ const Allocation& outputBufferAllocation = outputBuffer.getAllocation();
+ deUint32* outputBufferPtr = static_cast<deUint32*>(outputBufferAllocation.getHostPtr());
+ *outputBufferPtr = 0;
+ flushMappedMemoryRange(vk, device, outputBufferAllocation.getMemory(), outputBufferAllocation.getOffset(), outputBufferSizeBytes);
+
// Create a uniform buffer (to pass uniform constants)
const VkDeviceSize uniformBufferSizeBytes = sizeof(deUint32);
VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
*image, subresourceRange);
- const void* barriersBeforeCompute[] = { &writeUniformConstantsBarrier, &imageLayoutBarrier };
-
const VkImageMemoryBarrier imageBarrierBetweenShaders = makeImageMemoryBarrier(
VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
*image, subresourceRange);
- const void* barriersAfterFirstShader[] = { &imageBarrierBetweenShaders };
-
const VkBufferMemoryBarrier afterComputeBarrier = makeBufferMemoryBarrier(VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *outputBuffer, 0ull, outputBufferSizeBytes);
- const void* barriersAfterCompute[] = { &afterComputeBarrier };
const Unique<VkCommandPool> cmdPool(makeCommandPool(vk, device, queueFamilyIndex));
const Unique<VkCommandBuffer> cmdBuffer(makeCommandBuffer(vk, device, *cmdPool));
vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline0);
vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(barriersBeforeCompute), barriersBeforeCompute);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &writeUniformConstantsBarrier, 1, &imageLayoutBarrier);
vk.cmdDispatch(*cmdBuffer, m_imageSize.x(), m_imageSize.y(), 1u);
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(barriersAfterFirstShader), barriersAfterFirstShader);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrierBetweenShaders);
// Switch to the second shader program
vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline1);
vk.cmdDispatch(*cmdBuffer, m_imageSize.x(), m_imageSize.y(), 1u);
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(barriersAfterCompute), barriersAfterCompute);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &afterComputeBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
endCommandBuffer(vk, *cmdBuffer);
// Validate the results
- const Allocation& outputBufferAllocation = outputBuffer.getAllocation();
invalidateMappedMemoryRange(vk, device, outputBufferAllocation.getMemory(), outputBufferAllocation.getOffset(), outputBufferSizeBytes);
const int numValues = multiplyComponents(m_imageSize);
// Create descriptor pool
const vk::Unique<vk::VkDescriptorPool> descriptorPool(
vk::DescriptorPoolBuilder()
- .addType(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
+ .addType(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, (deUint32)m_dispatchCommands.size())
.build(m_device_interface, m_device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, static_cast<deUint32>(m_dispatchCommands.size())));
const vk::VkBufferMemoryBarrier ssboPostBarrier = makeBufferMemoryBarrier(
vk::VK_ACCESS_SHADER_WRITE_BIT, vk::VK_ACCESS_HOST_READ_BIT, *resultBuffer, 0ull, resultBufferSize);
- const void* const postBarriers[] = { &ssboPostBarrier };
// Create command buffer
const vk::Unique<vk::VkCommandPool> cmdPool(makeCommandPool(m_device_interface, m_device, m_queueFamilyIndex));
}
// Insert memory barrier
- m_device_interface.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, vk::VK_FALSE, DE_LENGTH_OF_ARRAY(postBarriers), postBarriers);
+ m_device_interface.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 1, &ssboPostBarrier,
+ 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
// End recording commands
endCommandBuffer(m_device_interface, *cmdBuffer);
const vk::VkBufferMemoryBarrier bufferBarrier = makeBufferMemoryBarrier(
vk::VK_ACCESS_SHADER_WRITE_BIT, vk::VK_ACCESS_INDIRECT_COMMAND_READ_BIT, *indirectBuffer, 0ull, m_bufferSize);
- const void* const postBarriers[] = { &bufferBarrier };
-
// Bind compute pipeline
m_device_interface.cmdBindPipeline(commandBuffer, vk::VK_PIPELINE_BIND_POINT_COMPUTE, *m_computePipeline);
m_device_interface.cmdDispatch(commandBuffer, 1u, 1u, 1u);
// Insert memory barrier
- m_device_interface.cmdPipelineBarrier(commandBuffer, vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, vk::VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, vk::VK_FALSE, DE_LENGTH_OF_ARRAY(postBarriers), postBarriers);
+ m_device_interface.cmdPipelineBarrier(commandBuffer, vk::VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, vk::VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 1, &bufferBarrier,
+ 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
}
class IndirectDispatchCaseBufferGenerate : public IndirectDispatchCaseBufferUpload
const VkBufferMemoryBarrier bufferBarrier = makeBufferMemoryBarrier(
VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT, *resultBuffer, 0ull, resultBufferSize);
- const void* const postBarrier[] = { &bufferBarrier };
-
const Unique<VkCommandPool> cmdPool(makeCommandPool(m_vki, m_device, m_queueFamilyIndex));
const Unique<VkCommandBuffer> cmdBuffer(makeCommandBuffer(m_vki, m_device, *cmdPool));
// Dispatch indirect compute command
m_vki.cmdDispatch(*cmdBuffer, subCase.numWorkGroups()[0], subCase.numWorkGroups()[1], subCase.numWorkGroups()[2]);
- m_vki.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, VK_FALSE, 1, postBarrier);
+ m_vki.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0,
+ 0, (const VkMemoryBarrier*)DE_NULL,
+ 1, &bufferBarrier,
+ 0, (const VkImageMemoryBarrier*)DE_NULL);
// End recording commands
endCommandBuffer(m_vki, *cmdBuffer);
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- DE_FALSE, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u, // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
VK_CHECK(vk.beginCommandBuffer(commandBuffer, &commandBufBeginParams));
}
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // deUint32 commandBufferCount;
&commandBuffer, // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
const vk::VkAttachmentReference* _resolveAttachments,
vk::VkAttachmentReference depthStencilAttachment,
deUint32 _preserveAttachmentCount,
- const vk::VkAttachmentReference* _preserveAttachments)
+ const deUint32* _preserveAttachments)
{
m_inputAttachments = std::vector<vk::VkAttachmentReference>(_inputAttachments, _inputAttachments + _inputAttachmentCount);
m_colorAttachments = std::vector<vk::VkAttachmentReference>(_colorAttachments, _colorAttachments + _colorAttachmentCount);
if (_resolveAttachments)
- {
m_resolveAttachments = std::vector<vk::VkAttachmentReference>(_resolveAttachments, _resolveAttachments + _colorAttachmentCount);
- }
- m_preserveAttachments = std::vector<vk::VkAttachmentReference>(_preserveAttachments, _preserveAttachments + _preserveAttachmentCount);
+ m_preserveAttachments = std::vector<deUint32>(_preserveAttachments, _preserveAttachments + _preserveAttachmentCount);
m_depthStencilAttachment = depthStencilAttachment;
- flags = _flags;
+ flags = _flags;
pipelineBindPoint = _pipelineBindPoint;
inputAttachmentCount = _inputAttachmentCount;
pInputAttachments = DE_NULL;
pPreserveAttachments = DE_NULL;
preserveAttachmentCount = _preserveAttachmentCount;
- if (m_inputAttachments.size()) {
+ if (!m_inputAttachments.empty())
pInputAttachments = &m_inputAttachments[0];
- }
- if (m_colorAttachments.size()) {
+ if (!m_colorAttachments.empty())
pColorAttachments = &m_colorAttachments[0];
- }
- if (m_resolveAttachments.size()) {
+ if (!m_resolveAttachments.empty())
pResolveAttachments = &m_resolveAttachments[0];
- }
- if (m_preserveAttachments.size()) {
+ if (!m_preserveAttachments.empty())
pPreserveAttachments = &m_preserveAttachments[0];
- }
}
SubpassDescription::SubpassDescription (const vk::VkSubpassDescription& rhs)
m_colorAttachments = std::vector<vk::VkAttachmentReference>(
rhs.pColorAttachments, rhs.pColorAttachments + rhs.colorAttachmentCount);
- if (rhs.pResolveAttachments) {
+ if (rhs.pResolveAttachments)
m_resolveAttachments = std::vector<vk::VkAttachmentReference>(
rhs.pResolveAttachments, rhs.pResolveAttachments + rhs.colorAttachmentCount);
- }
- m_preserveAttachments = std::vector<vk::VkAttachmentReference>(
+
+ m_preserveAttachments = std::vector<deUint32>(
rhs.pPreserveAttachments, rhs.pPreserveAttachments + rhs.preserveAttachmentCount);
if (rhs.pDepthStencilAttachment)
- {
m_depthStencilAttachment = *rhs.pDepthStencilAttachment;
- }
- if (m_inputAttachments.size()) {
+ if (!m_inputAttachments.empty())
pInputAttachments = &m_inputAttachments[0];
- }
- if (m_colorAttachments.size()) {
+
+ if (!m_colorAttachments.empty())
pColorAttachments = &m_colorAttachments[0];
- }
- if (m_resolveAttachments.size()) {
+ if (!m_resolveAttachments.empty())
pResolveAttachments = &m_resolveAttachments[0];
- }
pDepthStencilAttachment = &m_depthStencilAttachment;
- if (m_preserveAttachments.size()) {
+ if (!m_preserveAttachments.empty())
pPreserveAttachments = &m_preserveAttachments[0];
- }
}
SubpassDescription::SubpassDescription (const SubpassDescription& rhs) {
m_preserveAttachments = rhs.m_preserveAttachments;
m_depthStencilAttachment = rhs.m_depthStencilAttachment;
- if (m_inputAttachments.size()) {
+ if (!m_inputAttachments.empty())
pInputAttachments = &m_inputAttachments[0];
- }
- if (m_colorAttachments.size()) {
+
+ if (!m_colorAttachments.empty())
pColorAttachments = &m_colorAttachments[0];
- }
- if (m_resolveAttachments.size()) {
+ if (!m_resolveAttachments.empty())
pResolveAttachments = &m_resolveAttachments[0];
- }
pDepthStencilAttachment = &m_depthStencilAttachment;
- if (m_preserveAttachments.size()) {
+ if (!m_preserveAttachments.empty())
pPreserveAttachments = &m_preserveAttachments[0];
- }
return *this;
}
CmdBufferBeginInfo::CmdBufferBeginInfo (vk::VkCommandBufferUsageFlags _flags)
{
- sType = vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
- pNext = DE_NULL;
- renderPass = DE_NULL;
- subpass = 0;
- framebuffer = DE_NULL;
- flags = _flags;
- occlusionQueryEnable = false;
- queryFlags = 0u;
- pipelineStatistics = 0u;
-}
-
-CmdBufferBeginInfo::CmdBufferBeginInfo (vk::VkRenderPass _renderPass,
- deUint32 _subpass,
- vk::VkFramebuffer _framebuffer,
- vk::VkCommandBufferUsageFlags _flags,
- bool _occlusionQueryEnable,\r
- vk::VkQueryControlFlags _queryFlags,\r
- vk::VkQueryPipelineStatisticFlags _pipelineStatistics)
-{
-
- sType = vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
- pNext = DE_NULL;
- renderPass = _renderPass;
- subpass = _subpass;
- framebuffer = _framebuffer;
- flags = _flags;
- occlusionQueryEnable = _occlusionQueryEnable;
- queryFlags = _queryFlags;
- pipelineStatistics = _pipelineStatistics;
+ sType = vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+ pNext = DE_NULL;
+ flags = _flags;
+ pInheritanceInfo = DE_NULL;
}
DescriptorPoolCreateInfo::DescriptorPoolCreateInfo (const std::vector<vk::VkDescriptorPoolSize>& poolSizeCounts,
pNext = DE_NULL;
flags = 0;
bindingCount = _bindingCount;
- pBinding = _pBindings;
+ pBindings = _pBindings;
}
PipelineLayoutCreateInfo::PipelineLayoutCreateInfo (deUint32 _descriptorSetCount,
primitiveRestartEnable = _primitiveRestartEnable;
}
-PipelineCreateInfo::TesselationState::TesselationState (deUint32 _patchControlPoints)
+PipelineCreateInfo::TessellationState::TessellationState (deUint32 _patchControlPoints)
{
sType = vk::VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
pNext = DE_NULL;
vk::VkSamplerAddressMode _addressModeV,
vk::VkSamplerAddressMode _addressModeW,
float _mipLodBias,
+ vk::VkBool32 _anisotropyEnable,
float _maxAnisotropy,
vk::VkBool32 _compareEnable,
vk::VkCompareOp _compareOp,
addressModeV = _addressModeV;
addressModeW = _addressModeW;
mipLodBias = _mipLodBias;
+ anisotropyEnable = _anisotropyEnable;
maxAnisotropy = _maxAnisotropy;
compareEnable = _compareEnable;
compareOp = _compareOp;
const vk::VkAttachmentReference* resolveAttachments,
vk::VkAttachmentReference depthStencilAttachment,
deUint32 preserveAttachmentCount,
- const vk::VkAttachmentReference* preserveAttachments);
+ const deUint32* preserveAttachments);
SubpassDescription (const vk::VkSubpassDescription& other);
SubpassDescription (const SubpassDescription& other);
std::vector<vk::VkAttachmentReference> m_inputAttachments;
std::vector<vk::VkAttachmentReference> m_colorAttachments;
std::vector<vk::VkAttachmentReference> m_resolveAttachments;
- std::vector<vk::VkAttachmentReference> m_preserveAttachments;
+ std::vector<deUint32> m_preserveAttachments;
vk::VkAttachmentReference m_depthStencilAttachment;
};
{
public:
CmdBufferBeginInfo (vk::VkCommandBufferUsageFlags flags = 0);
- CmdBufferBeginInfo (vk::VkRenderPass renderPass,
- deUint32 subpass,
- vk::VkFramebuffer framebuffer,
- vk::VkCommandBufferUsageFlags flags = 0,
- bool occlusionQueryEnable = false,
- vk::VkQueryControlFlags queryFlags = 0u,
- vk::VkQueryPipelineStatisticFlags pipelineStatistics = 0u);
};
class DescriptorPoolSize : public vk::VkDescriptorPoolSize
InputAssemblerState (vk::VkPrimitiveTopology topology, vk::VkBool32 primitiveRestartEnable = false);
};
- class TesselationState : public vk::VkPipelineTessellationStateCreateInfo
+ class TessellationState : public vk::VkPipelineTessellationStateCreateInfo
{
public:
- TesselationState (deUint32 patchControlPoints = 0);
+ TessellationState (deUint32 patchControlPoints = 0);
};
class ViewportState : public vk::VkPipelineViewportStateCreateInfo
vk::VkSamplerAddressMode addressV = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
vk::VkSamplerAddressMode addressW = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
float mipLodBias = 0.0f,
+ vk::VkBool32 anisotropyEnable = vk::VK_FALSE,
float maxAnisotropy = 1.0f,
vk::VkBool32 compareEnable = false,
vk::VkCompareOp compareOp = vk::VK_COMPARE_OP_ALWAYS,
barrier.subresourceRange.baseArrayLayer = 0;
barrier.subresourceRange.layerCount = m_layerCount;
- void* barriers[] = { &barrier };
-
- m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
- false, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &barrier);
}
vk::VkBufferImageCopy region =
0, 0, 0,
{ aspect, mipLevel, arrayElement, 1 },
offset,
- { width, height, depth }
+ { (deUint32)width, (deUint32)height, (deUint32)depth }
};
m_vk.cmdCopyImageToBuffer(*copyCmdBuffer, object(), layout, stagingResource->object(), 1, ®ion);
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
{
de::SharedPtr<Image> stagingResource;
{
- vk::VkExtent3D stagingExtent = {width, height, depth};
+ vk::VkExtent3D stagingExtent = {(deUint32)width, (deUint32)height, (deUint32)depth};
ImageCreateInfo stagingResourceCreateInfo(type, m_format, stagingExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT,
vk::VK_IMAGE_TILING_LINEAR, vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT);
transition2DImage(m_vk, *copyCmdBuffer, stagingResource->object(), aspect, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_GENERAL);
const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
- vk::VkImageCopy region = { {aspect, mipLevel, arrayElement, 1}, offset, {aspect, 0, 0, 1}, zeroOffset, {width, height, depth} };
+ vk::VkImageCopy region = { {aspect, mipLevel, arrayElement, 1}, offset, {aspect, 0, 0, 1}, zeroOffset, {(deUint32)width, (deUint32)height, (deUint32)depth} };
m_vk.cmdCopyImage(*copyCmdBuffer, object(), layout, stagingResource->object(), vk::VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
VK_CHECK(m_vk.endCommandBuffer(*copyCmdBuffer));
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
DE_ASSERT(layout == vk::VK_IMAGE_LAYOUT_GENERAL || layout == vk::VK_IMAGE_LAYOUT_UNDEFINED || layout == vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
de::SharedPtr<Image> stagingResource;
- vk::VkExtent3D extent = {width, height, depth};
+ vk::VkExtent3D extent = {(deUint32)width, (deUint32)height, (deUint32)depth};
ImageCreateInfo stagingResourceCreateInfo(
type, m_format, extent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT,
vk::VK_IMAGE_TILING_LINEAR, vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
barrier.subresourceRange.baseArrayLayer = 0;
barrier.subresourceRange.layerCount = m_layerCount;
- void* barriers[] = { &barrier };
-
- m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &barrier);
}
transition2DImage(m_vk, *copyCmdBuffer, stagingResource->object(), aspect, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_GENERAL);
zeroOffset,
{aspect, mipLevel, arrayElement, 1},
offset,
- {width, height, depth}};
+ {(deUint32)width, (deUint32)height, (deUint32)depth}};
m_vk.cmdCopyImage(*copyCmdBuffer, stagingResource->object(),
vk::VK_IMAGE_LAYOUT_GENERAL, object(), layout, 1, ®ion);
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
barrier.subresourceRange.baseArrayLayer = 0;
barrier.subresourceRange.layerCount = m_layerCount;
- void* barriers[] = { &barrier };
-
- m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &barrier);
}
vk::VkBufferImageCopy region = {
0, 0, 0,
{ aspect, mipLevel, arrayElement, 1 },
offset,
- { width, height, depth }
+ { (deUint32)width, (deUint32)height, (deUint32)depth }
};
m_vk.cmdCopyBufferToImage(*copyCmdBuffer, stagingResource->object(),
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
vk::VkImageLayout newLayout)
{
vk::VkImageMemoryBarrier barrier;
- barrier.sType = vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
- barrier.pNext = DE_NULL;
- barrier.srcAccessMask = 0;
- barrier.dstAccessMask = 0;
- barrier.oldLayout = oldLayout;
- barrier.newLayout = newLayout;
- barrier.srcQueueFamilyIndex = vk::VK_QUEUE_FAMILY_IGNORED;
- barrier.dstQueueFamilyIndex = vk::VK_QUEUE_FAMILY_IGNORED;
- barrier.image = image;
+ barrier.sType = vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+ barrier.pNext = DE_NULL;
+ barrier.srcAccessMask = 0;
+ barrier.dstAccessMask = 0;
+ barrier.oldLayout = oldLayout;
+ barrier.newLayout = newLayout;
+ barrier.srcQueueFamilyIndex = vk::VK_QUEUE_FAMILY_IGNORED;
+ barrier.dstQueueFamilyIndex = vk::VK_QUEUE_FAMILY_IGNORED;
+ barrier.image = image;
barrier.subresourceRange.aspectMask = aspectMask;
barrier.subresourceRange.baseMipLevel = 0;
barrier.subresourceRange.levelCount = 1;
barrier.subresourceRange.baseArrayLayer = 0;
barrier.subresourceRange.layerCount = 1;
- void* barriers[] = { &barrier };
-
- vk.cmdPipelineBarrier(cmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(cmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &barrier);
}
void initialTransitionColor2DImage (const vk::DeviceInterface &vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout)
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
viewport.minDepth = 0.0f;
viewport.maxDepth = 1.0f;
- m_vk.cmdSetViewport(*m_cmdBuffer, 1, &viewport);
+ m_vk.cmdSetViewport(*m_cmdBuffer, 0, 1, &viewport);
vk::VkRect2D scissor;
scissor.offset.x = 0;
scissor.offset.y = 0;
scissor.extent.width = width;
scissor.extent.height = height;
- m_vk.cmdSetScissor(*m_cmdBuffer, 1, &scissor);
+ m_vk.cmdSetScissor(*m_cmdBuffer, 0, 1, &scissor);
}
void DynamicStateBaseClass::setDynamicViewportState (deUint32 viewportCount, const vk::VkViewport* pViewports, const vk::VkRect2D* pScissors)
{
- m_vk.cmdSetViewport(*m_cmdBuffer, viewportCount, pViewports);
- m_vk.cmdSetScissor(*m_cmdBuffer, viewportCount, pScissors);
+ m_vk.cmdSetViewport(*m_cmdBuffer, 0, viewportCount, pViewports);
+ m_vk.cmdSetScissor(*m_cmdBuffer, 0, viewportCount, pScissors);
}
void DynamicStateBaseClass::setDynamicRasterizationState (const float lineWidth,
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
const vk::VkAttachmentReference* _resolveAttachments,
vk::VkAttachmentReference depthStencilAttachment,
deUint32 _preserveAttachmentCount,
- const vk::VkAttachmentReference* _preserveAttachments)
+ const deUint32* _preserveAttachments)
{
m_inputAttachments = std::vector<vk::VkAttachmentReference>(_inputAttachments, _inputAttachments + _inputAttachmentCount);
m_colorAttachments = std::vector<vk::VkAttachmentReference>(_colorAttachments, _colorAttachments + _colorAttachmentCount);
if (_resolveAttachments)
- {
m_resolveAttachments = std::vector<vk::VkAttachmentReference>(_resolveAttachments, _resolveAttachments + _colorAttachmentCount);
- }
- m_preserveAttachments = std::vector<vk::VkAttachmentReference>(_preserveAttachments, _preserveAttachments + _preserveAttachmentCount);
+ m_preserveAttachments = std::vector<deUint32>(_preserveAttachments, _preserveAttachments + _preserveAttachmentCount);
m_depthStencilAttachment = depthStencilAttachment;
- flags = _flags;
+ flags = _flags;
pipelineBindPoint = _pipelineBindPoint;
inputAttachmentCount = _inputAttachmentCount;
pInputAttachments = DE_NULL;
pPreserveAttachments = DE_NULL;
preserveAttachmentCount = _preserveAttachmentCount;
- if (m_inputAttachments.size()) {
+ if (!m_inputAttachments.empty())
pInputAttachments = &m_inputAttachments[0];
- }
- if (m_colorAttachments.size()) {
+ if (!m_colorAttachments.empty())
pColorAttachments = &m_colorAttachments[0];
- }
- if (m_resolveAttachments.size()) {
+ if (!m_resolveAttachments.empty())
pResolveAttachments = &m_resolveAttachments[0];
- }
- if (m_preserveAttachments.size()) {
+ if (!m_preserveAttachments.empty())
pPreserveAttachments = &m_preserveAttachments[0];
- }
}
SubpassDescription::SubpassDescription (const vk::VkSubpassDescription& rhs)
m_colorAttachments = std::vector<vk::VkAttachmentReference>(
rhs.pColorAttachments, rhs.pColorAttachments + rhs.colorAttachmentCount);
- if (rhs.pResolveAttachments) {
+ if (rhs.pResolveAttachments)
m_resolveAttachments = std::vector<vk::VkAttachmentReference>(
rhs.pResolveAttachments, rhs.pResolveAttachments + rhs.colorAttachmentCount);
- }
- m_preserveAttachments = std::vector<vk::VkAttachmentReference>(
+
+ m_preserveAttachments = std::vector<deUint32>(
rhs.pPreserveAttachments, rhs.pPreserveAttachments + rhs.preserveAttachmentCount);
if (rhs.pDepthStencilAttachment)
- {
m_depthStencilAttachment = *rhs.pDepthStencilAttachment;
- }
- if (m_inputAttachments.size()) {
+ if (!m_inputAttachments.empty())
pInputAttachments = &m_inputAttachments[0];
- }
- if (m_colorAttachments.size()) {
+
+ if (!m_colorAttachments.empty())
pColorAttachments = &m_colorAttachments[0];
- }
- if (m_resolveAttachments.size()) {
+ if (!m_resolveAttachments.empty())
pResolveAttachments = &m_resolveAttachments[0];
- }
pDepthStencilAttachment = &m_depthStencilAttachment;
- if (m_preserveAttachments.size()) {
+ if (!m_preserveAttachments.empty())
pPreserveAttachments = &m_preserveAttachments[0];
- }
}
SubpassDescription::SubpassDescription (const SubpassDescription& rhs) {
m_preserveAttachments = rhs.m_preserveAttachments;
m_depthStencilAttachment = rhs.m_depthStencilAttachment;
- if (m_inputAttachments.size()) {
+ if (!m_inputAttachments.empty())
pInputAttachments = &m_inputAttachments[0];
- }
- if (m_colorAttachments.size()) {
+
+ if (!m_colorAttachments.empty())
pColorAttachments = &m_colorAttachments[0];
- }
- if (m_resolveAttachments.size()) {
+ if (!m_resolveAttachments.empty())
pResolveAttachments = &m_resolveAttachments[0];
- }
pDepthStencilAttachment = &m_depthStencilAttachment;
- if (m_preserveAttachments.size()) {
+ if (!m_preserveAttachments.empty())
pPreserveAttachments = &m_preserveAttachments[0];
- }
return *this;
}
CmdBufferBeginInfo::CmdBufferBeginInfo (vk::VkCommandBufferUsageFlags _flags)
{
- sType = vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
- pNext = DE_NULL;
- renderPass = DE_NULL;
- subpass = 0;
- framebuffer = DE_NULL;
- flags = _flags;
- occlusionQueryEnable = false;
- queryFlags = 0u;
- pipelineStatistics = 0u;
-}
-
-CmdBufferBeginInfo::CmdBufferBeginInfo (vk::VkRenderPass _renderPass,
- deUint32 _subpass,
- vk::VkFramebuffer _framebuffer,
- vk::VkCommandBufferUsageFlags _flags,
- bool _occlusionQueryEnable,
- vk::VkQueryControlFlags _queryFlags,
- vk::VkQueryPipelineStatisticFlags _pipelineStatistics)
-{
-
- sType = vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
- pNext = DE_NULL;
- renderPass = _renderPass;
- subpass = _subpass;
- framebuffer = _framebuffer;
- flags = _flags;
- occlusionQueryEnable = _occlusionQueryEnable;
- queryFlags = _queryFlags;
- pipelineStatistics = _pipelineStatistics;
+ sType = vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+ pNext = DE_NULL;
+ flags = _flags;
+ pInheritanceInfo = DE_NULL;
}
DescriptorPoolCreateInfo::DescriptorPoolCreateInfo (const std::vector<vk::VkDescriptorPoolSize>& poolSizeCounts,
pNext = DE_NULL;
flags = 0;
bindingCount = _bindingCount;
- pBinding = _pBindings;
+ pBindings = _pBindings;
}
PipelineLayoutCreateInfo::PipelineLayoutCreateInfo (deUint32 _descriptorSetCount,
primitiveRestartEnable = _primitiveRestartEnable;
}
-PipelineCreateInfo::TesselationState::TesselationState (deUint32 _patchControlPoints)
+PipelineCreateInfo::TessellationState::TessellationState (deUint32 _patchControlPoints)
{
sType = vk::VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
pNext = DE_NULL;
vk::VkSamplerAddressMode _addressModeV,
vk::VkSamplerAddressMode _addressModeW,
float _mipLodBias,
+ vk::VkBool32 _anisotropyEnable,
float _maxAnisotropy,
vk::VkBool32 _compareEnable,
vk::VkCompareOp _compareOp,
addressModeV = _addressModeV;
addressModeW = _addressModeW;
mipLodBias = _mipLodBias;
+ anisotropyEnable = _anisotropyEnable;
maxAnisotropy = _maxAnisotropy;
compareEnable = _compareEnable;
compareOp = _compareOp;
const vk::VkAttachmentReference* resolveAttachments,
vk::VkAttachmentReference depthStencilAttachment,
deUint32 preserveAttachmentCount,
- const vk::VkAttachmentReference* preserveAttachments);
+ const deUint32* preserveAttachments);
SubpassDescription (const vk::VkSubpassDescription& other);
SubpassDescription (const SubpassDescription& other);
std::vector<vk::VkAttachmentReference> m_inputAttachments;
std::vector<vk::VkAttachmentReference> m_colorAttachments;
std::vector<vk::VkAttachmentReference> m_resolveAttachments;
- std::vector<vk::VkAttachmentReference> m_preserveAttachments;
+ std::vector<deUint32> m_preserveAttachments;
vk::VkAttachmentReference m_depthStencilAttachment;
};
{
public:
CmdBufferBeginInfo (vk::VkCommandBufferUsageFlags flags = 0);
- CmdBufferBeginInfo (vk::VkRenderPass renderPass,
- deUint32 subpass,
- vk::VkFramebuffer framebuffer,
- vk::VkCommandBufferUsageFlags flags = 0,
- bool occlusionQueryEnable = false,
- vk::VkQueryControlFlags queryFlags = 0u,
- vk::VkQueryPipelineStatisticFlags pipelineStatistics = 0u);
};
class DescriptorPoolSize : public vk::VkDescriptorPoolSize
InputAssemblerState (vk::VkPrimitiveTopology topology, vk::VkBool32 primitiveRestartEnable = false);
};
- class TesselationState : public vk::VkPipelineTessellationStateCreateInfo
+ class TessellationState : public vk::VkPipelineTessellationStateCreateInfo
{
public:
- TesselationState (deUint32 patchControlPoints = 0);
+ TessellationState (deUint32 patchControlPoints = 0);
};
class ViewportState : public vk::VkPipelineViewportStateCreateInfo
vk::VkSamplerAddressMode addressV = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
vk::VkSamplerAddressMode addressW = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
float mipLodBias = 0.0f,
+ vk::VkBool32 anisotropyEnable = vk::VK_FALSE,
float maxAnisotropy = 1.0f,
vk::VkBool32 compareEnable = false,
vk::VkCompareOp compareOp = vk::VK_COMPARE_OP_ALWAYS,
DepthStencilBaseCase (Context& context, const char* vertexShaderName, const char* fragmentShaderName)
: TestInstance (context)
, m_colorAttachmentFormat (vk::VK_FORMAT_R8G8B8A8_UNORM)
- , m_depthStencilAttachmentFormat (vk::VK_FORMAT_D24_UNORM_S8_UINT)
, m_topology (vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP)
, m_vk (context.getDeviceInterface())
, m_vertexShaderName (vertexShaderName)
{
const vk::VkDevice device = m_context.getDevice();
+ vk::VkFormatProperties formatProperties;
+ // check for VK_FORMAT_D24_UNORM_S8_UINT support
+ m_context.getInstanceInterface().getPhysicalDeviceFormatProperties(m_context.getPhysicalDevice(), vk::VK_FORMAT_D24_UNORM_S8_UINT, &formatProperties);
+ if (formatProperties.optimalTilingFeatures & vk::VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
+ {
+ m_depthStencilAttachmentFormat = vk::VK_FORMAT_D24_UNORM_S8_UINT;
+ }
+ else
+ {
+ // check for VK_FORMAT_D32_SFLOAT_S8_UINT support
+ m_context.getInstanceInterface().getPhysicalDeviceFormatProperties(m_context.getPhysicalDevice(), vk::VK_FORMAT_D32_SFLOAT_S8_UINT, &formatProperties);
+ if (formatProperties.optimalTilingFeatures & vk::VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
+ {
+ m_depthStencilAttachmentFormat = vk::VK_FORMAT_D32_SFLOAT_S8_UINT;
+ }
+ else
+ throw tcu::NotSupportedError("No valid depth stencil attachment available");
+ }
+
const PipelineLayoutCreateInfo pipelineLayoutCreateInfo;
m_pipelineLayout = vk::createPipelineLayout(m_vk, device, &pipelineLayoutCreateInfo);
viewport.minDepth = 0.0f;
viewport.maxDepth = 1.0f;
- m_vk.cmdSetViewport(*m_cmdBuffer, 1, &viewport);
+ m_vk.cmdSetViewport(*m_cmdBuffer, 0, 1, &viewport);
vk::VkRect2D scissor;
scissor.offset.x = 0;
scissor.offset.y = 0;
scissor.extent.width = width;
scissor.extent.height = height;
- m_vk.cmdSetScissor(*m_cmdBuffer, 1, &scissor);
+ m_vk.cmdSetScissor(*m_cmdBuffer, 0, 1, &scissor);
}
void setDynamicViewportState(const deUint32 viewportCount, const vk::VkViewport* pViewports, const vk::VkRect2D* pScissors)
{
- m_vk.cmdSetViewport(*m_cmdBuffer, viewportCount, pViewports);
- m_vk.cmdSetScissor(*m_cmdBuffer, viewportCount, pScissors);
+ m_vk.cmdSetViewport(*m_cmdBuffer, 0, viewportCount, pViewports);
+ m_vk.cmdSetScissor(*m_cmdBuffer, 0, viewportCount, pScissors);
}
void setDynamicRasterizationState(const float lineWidth = 1.0f,
DepthBoundsParamTestInstance (Context &context, ShaderMap shaders)
: DepthStencilBaseCase (context, shaders[glu::SHADERTYPE_VERTEX], shaders[glu::SHADERTYPE_FRAGMENT])
{
+ // Check if depth bounds test is supported
+ {
+ const vk::VkPhysicalDeviceFeatures& deviceFeatures = m_context.getDeviceFeatures();
+
+ if (!deviceFeatures.depthBounds)
+ throw tcu::NotSupportedError("Depth bounds test is unsupported");
+ }
+
m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 1.0f, 0.375f, 1.0f), tcu::RGBA::green().toVec()));
m_data.push_back(PositionColorVertex(tcu::Vec4(0.0f, 1.0f, 0.375f, 1.0f), tcu::RGBA::green().toVec()));
m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, -1.0f, 0.375f, 1.0f), tcu::RGBA::green().toVec()));
m_depthStencilState_1 = PipelineCreateInfo::DepthStencilState(
vk::VK_TRUE, vk::VK_TRUE, vk::VK_COMPARE_OP_ALWAYS, vk::VK_FALSE);
-
- // Check if depth bounds test is supported
- {
- const vk::VkPhysicalDeviceFeatures& deviceFeatures = m_context.getDeviceFeatures();
-
- if (!deviceFeatures.depthBounds)
- throw tcu::NotSupportedError("Depth bounds test is unsupported");
- }
-
// enable depth bounds test
m_depthStencilState_2 = PipelineCreateInfo::DepthStencilState(
vk::VK_FALSE, vk::VK_FALSE, vk::VK_COMPARE_OP_NEVER, vk::VK_TRUE);
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
barrier.subresourceRange.baseArrayLayer = 0;
barrier.subresourceRange.layerCount = m_layerCount;
- void* barriers[] = { &barrier };
-
- m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
- false, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &barrier);
}
vk::VkBufferImageCopy region =
0, 0, 0,
{ aspect, mipLevel, arrayElement, 1 },
offset,
- { width, height, depth }
+ { (deUint32)width, (deUint32)height, (deUint32)depth }
};
m_vk.cmdCopyImageToBuffer(*copyCmdBuffer, object(), layout, stagingResource->object(), 1, ®ion);
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
{
de::SharedPtr<Image> stagingResource;
{
- vk::VkExtent3D stagingExtent = {width, height, depth};
+ vk::VkExtent3D stagingExtent = {(deUint32)width, (deUint32)height, (deUint32)depth};
ImageCreateInfo stagingResourceCreateInfo(type, m_format, stagingExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT,
vk::VK_IMAGE_TILING_LINEAR, vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT);
transition2DImage(m_vk, *copyCmdBuffer, stagingResource->object(), aspect, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_GENERAL);
const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
- vk::VkImageCopy region = { {aspect, mipLevel, arrayElement, 1}, offset, {aspect, 0, 0, 1}, zeroOffset, {width, height, depth} };
+ vk::VkImageCopy region = { {aspect, mipLevel, arrayElement, 1}, offset, {aspect, 0, 0, 1}, zeroOffset, {(deUint32)width, (deUint32)height, (deUint32)depth} };
m_vk.cmdCopyImage(*copyCmdBuffer, object(), layout, stagingResource->object(), vk::VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
VK_CHECK(m_vk.endCommandBuffer(*copyCmdBuffer));
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
DE_ASSERT(layout == vk::VK_IMAGE_LAYOUT_GENERAL || layout == vk::VK_IMAGE_LAYOUT_UNDEFINED || layout == vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
de::SharedPtr<Image> stagingResource;
- vk::VkExtent3D extent = {width, height, depth};
+ vk::VkExtent3D extent = {(deUint32)width, (deUint32)height, (deUint32)depth};
ImageCreateInfo stagingResourceCreateInfo(
type, m_format, extent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT,
vk::VK_IMAGE_TILING_LINEAR, vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
barrier.subresourceRange.baseArrayLayer = 0;
barrier.subresourceRange.layerCount = m_layerCount;
- void* barriers[] = { &barrier };
-
- m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &barrier);
}
transition2DImage(m_vk, *copyCmdBuffer, stagingResource->object(), aspect, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_GENERAL);
zeroOffset,
{aspect, mipLevel, arrayElement, 1},
offset,
- {width, height, depth}};
+ {(deUint32)width, (deUint32)height, (deUint32)depth}};
m_vk.cmdCopyImage(*copyCmdBuffer, stagingResource->object(),
vk::VK_IMAGE_LAYOUT_GENERAL, object(), layout, 1, ®ion);
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
barrier.subresourceRange.baseArrayLayer = 0;
barrier.subresourceRange.layerCount = m_layerCount;
- void* barriers[] = { &barrier };
-
- m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &barrier);
}
vk::VkBufferImageCopy region = {
0, 0, 0,
{ aspect, mipLevel, arrayElement, 1 },
offset,
- { width, height, depth }
+ { (deUint32)width, (deUint32)height, (deUint32)depth }
};
m_vk.cmdCopyBufferToImage(*copyCmdBuffer, stagingResource->object(),
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
barrier.subresourceRange.baseArrayLayer = 0;
barrier.subresourceRange.layerCount = 1;
- void* barriers[] = { &barrier };
-
- vk.cmdPipelineBarrier(cmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(cmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &barrier);
}
void initialTransitionColor2DImage (const vk::DeviceInterface &vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout)
DepthBiasBaseCase (Context& context, const char* vertexShaderName, const char* fragmentShaderName)
: TestInstance (context)
, m_colorAttachmentFormat (vk::VK_FORMAT_R8G8B8A8_UNORM)
- , m_depthStencilAttachmentFormat (vk::VK_FORMAT_D24_UNORM_S8_UINT)
, m_topology (vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP)
, m_vk (context.getDeviceInterface())
, m_vertexShaderName (vertexShaderName)
{
const vk::VkDevice device = m_context.getDevice();
+ vk::VkFormatProperties formatProperties;
+ // check for VK_FORMAT_D24_UNORM_S8_UINT support
+ m_context.getInstanceInterface().getPhysicalDeviceFormatProperties(m_context.getPhysicalDevice(), vk::VK_FORMAT_D24_UNORM_S8_UINT, &formatProperties);
+ if (formatProperties.optimalTilingFeatures & vk::VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
+ {
+ m_depthStencilAttachmentFormat = vk::VK_FORMAT_D24_UNORM_S8_UINT;
+ }
+ else
+ {
+ // check for VK_FORMAT_D32_SFLOAT_S8_UINT support
+ m_context.getInstanceInterface().getPhysicalDeviceFormatProperties(m_context.getPhysicalDevice(), vk::VK_FORMAT_D32_SFLOAT_S8_UINT, &formatProperties);
+ if (formatProperties.optimalTilingFeatures & vk::VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
+ {
+ m_depthStencilAttachmentFormat = vk::VK_FORMAT_D32_SFLOAT_S8_UINT;
+ }
+ else
+ throw tcu::NotSupportedError("No valid depth stencil attachment available");
+ }
+
const PipelineLayoutCreateInfo pipelineLayoutCreateInfo;
m_pipelineLayout = vk::createPipelineLayout(m_vk, device, &pipelineLayoutCreateInfo);
viewport.minDepth = 0.0f;
viewport.maxDepth = 1.0f;
- m_vk.cmdSetViewport(*m_cmdBuffer, 1, &viewport);
+ m_vk.cmdSetViewport(*m_cmdBuffer, 0, 1, &viewport);
vk::VkRect2D scissor;
scissor.offset.x = 0;
scissor.offset.y = 0;
scissor.extent.width = width;
scissor.extent.height = height;
- m_vk.cmdSetScissor(*m_cmdBuffer, 1, &scissor);
+ m_vk.cmdSetScissor(*m_cmdBuffer, 0, 1, &scissor);
}
void setDynamicViewportState (const deUint32 viewportCount, const vk::VkViewport* pViewports, const vk::VkRect2D* pScissors)
{
- m_vk.cmdSetViewport(*m_cmdBuffer, viewportCount, pViewports);
- m_vk.cmdSetScissor(*m_cmdBuffer, viewportCount, pScissors);
+ m_vk.cmdSetViewport(*m_cmdBuffer, 0, viewportCount, pViewports);
+ m_vk.cmdSetScissor(*m_cmdBuffer, 0, viewportCount, pScissors);
}
void setDynamicRasterizationState (const float lineWidth = 1.0f,
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
LineWidthParamTestInstance (Context& context, ShaderMap shaders)
: DynamicStateBaseClass (context, shaders[glu::SHADERTYPE_VERTEX], shaders[glu::SHADERTYPE_FRAGMENT])
{
+ // Check if line width test is supported
+ {
+ const vk::VkPhysicalDeviceFeatures& deviceFeatures = m_context.getDeviceFeatures();
+
+ if (!deviceFeatures.wideLines)
+ throw tcu::NotSupportedError("Line width test is unsupported");
+ }
+
m_topology = vk::VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 0.0f, 0.0f, 1.0f), tcu::RGBA::green().toVec()));
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
: DynamicStateBaseClass (context, shaders[glu::SHADERTYPE_VERTEX], shaders[glu::SHADERTYPE_FRAGMENT])
, m_geometryShaderName (shaders[glu::SHADERTYPE_GEOMETRY])
{
+ // Check geometry shader support
+ {
+ const vk::VkPhysicalDeviceFeatures& deviceFeatures = m_context.getDeviceFeatures();
+
+ if (!deviceFeatures.multiViewport)
+ throw tcu::NotSupportedError("Multi-viewport is not supported");
+
+ if (!deviceFeatures.geometryShader)
+ throw tcu::NotSupportedError("Geometry shaders are not supported");
+ }
+
for (int i = 0; i < 4; i++)
{
m_data.push_back(PositionColorVertex(tcu::Vec4(-1.0f, 1.0f, (float)i / 3.0f, 1.0f), tcu::RGBA::green().toVec()));
virtual void initPipeline (const vk::VkDevice device)
{
- // Check geometry shader support
- {
- const vk::VkPhysicalDeviceFeatures& deviceFeatures = m_context.getDeviceFeatures();
-
- if (!deviceFeatures.multiViewport)
- throw tcu::NotSupportedError("Multi-viewport is not supported");
-
- if (!deviceFeatures.geometryShader)
- throw tcu::NotSupportedError("Geometry shaders are not supported");
- }
-
const vk::Unique<vk::VkShaderModule> vs(createShaderModule(m_vk, device, m_context.getBinaryCollection().get(m_vertexShaderName), 0));
const vk::Unique<vk::VkShaderModule> gs(createShaderModule(m_vk, device, m_context.getBinaryCollection().get(m_geometryShaderName), 0));
const vk::Unique<vk::VkShaderModule> fs(createShaderModule(m_vk, device, m_context.getBinaryCollection().get(m_fragmentShaderName), 0));
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
namespace
{
-inline VkImageCreateInfo makeImageCreateInfo (const Texture& texture, const VkFormat format, const VkImageUsageFlags usage)
+inline VkImageCreateInfo makeImageCreateInfo (const Texture& texture, const VkFormat format, const VkImageUsageFlags usage, const VkImageCreateFlags flags)
{
const VkImageCreateInfo imageParams =
{
- VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- (isCube(texture) ? (VkImageCreateFlags)VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT : 0u), // VkImageCreateFlags flags;
- mapImageType(texture.type()), // VkImageType imageType;
- format, // VkFormat format;
- makeExtent3D(texture.layerSize()), // VkExtent3D extent;
- 1u, // deUint32 mipLevels;
- (deUint32)texture.numLayers(), // deUint32 arrayLayers;
- VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
- VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
- usage, // VkImageUsageFlags usage;
- VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
- 0u, // deUint32 queueFamilyIndexCount;
- DE_NULL, // const deUint32* pQueueFamilyIndices;
- VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
+ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ (isCube(texture) ? (VkImageCreateFlags)VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT : 0u) | flags, // VkImageCreateFlags flags;
+ mapImageType(texture.type()), // VkImageType imageType;
+ format, // VkFormat format;
+ makeExtent3D(texture.layerSize()), // VkExtent3D extent;
+ 1u, // deUint32 mipLevels;
+ (deUint32)texture.numLayers(), // deUint32 arrayLayers;
+ VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
+ VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
+ usage, // VkImageUsageFlags usage;
+ VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
+ 0u, // deUint32 queueFamilyIndexCount;
+ DE_NULL, // const deUint32* pQueueFamilyIndices;
+ VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
};
return imageParams;
}
{
const tcu::IVec4 color(access.getPixelInt(x, y, z));
tcu::IVec4 newColor = color;
-
+
for (int i = 0; i < 4; ++i)
{
const deInt32 oldColor(color[i]);
if (oldColor == -128) newColor[i] = -127;
}
-
+
if (newColor != color)
access.setPixel(newColor, x, y, z);
}
VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
image, fullImageSubresourceRange);
- const void* const barriers[] = { &shaderWriteBarrier };
-
- vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &shaderWriteBarrier);
}
void commandBufferWriteBarrierBeforeHostRead (Context& context, const VkCommandBuffer cmdBuffer, const VkBuffer buffer, const VkDeviceSize bufferSizeBytes)
VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
buffer, 0ull, bufferSizeBytes);
- const void* const barriers[] = { &shaderWriteBarrier };
-
- vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &shaderWriteBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
}
//! Copy all layers of an image to a buffer.
VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
image, fullImageSubresourceRange);
- const void* const barriersBeforeCopy[] = { &prepareForTransferBarrier };
-
const VkBufferImageCopy copyRegion = makeBufferImageCopy(texture);
const VkBufferMemoryBarrier copyBarrier = makeBufferMemoryBarrier(
VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
buffer, 0ull, bufferSizeBytes);
- const void* const barriersAfterCopy[] = { ©Barrier };
-
- vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(barriersBeforeCopy), barriersBeforeCopy);
+ vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &prepareForTransferBarrier);
vk.cmdCopyImageToBuffer(cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, buffer, 1u, ©Region);
- vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(barriersAfterCopy), barriersAfterCopy);
+ vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, ©Barrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
}
//! Minimum chunk size is determined by the offset alignment requirements.
m_image = de::MovePtr<Image>(new Image(
vk, device, allocator,
- makeImageCreateInfo(m_texture, m_format, VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT),
+ makeImageCreateInfo(m_texture, m_format, VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, 0u),
MemoryRequirement::Any));
// This buffer will be used to pass constants to the shader
VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
m_constantsBuffer->get(), 0ull, constantsBufferSize);
- const void* const barriersBefore[] = { &writeConstantsBarrier, &setImageLayoutBarrier };
-
- vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(barriersBefore), barriersBefore);
+ vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &writeConstantsBarrier, 1, &setImageLayoutBarrier);
}
void ImageStoreTestInstance::commandBetweenShaderInvocations (const VkCommandBuffer cmdBuffer)
: LoadStoreTestInstance (context, texture, format, imageFormat, singleLayerBind)
, m_perLayerData (texture.numLayers())
{
- const DeviceInterface& vk = m_context.getDeviceInterface();
- const VkDevice device = m_context.getDevice();
- Allocator& allocator = m_context.getDefaultAllocator();
+ const DeviceInterface& vk = m_context.getDeviceInterface();
+ const VkDevice device = m_context.getDevice();
+ Allocator& allocator = m_context.getDefaultAllocator();
+ const VkImageCreateFlags imageFlags = (m_format == m_imageFormat ? 0u : (VkImageCreateFlags)VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT);
m_imageSrc = de::MovePtr<Image>(new Image(
vk, device, allocator,
- makeImageCreateInfo(m_texture, m_imageFormat, VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT),
+ makeImageCreateInfo(m_texture, m_imageFormat, VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, imageFlags),
MemoryRequirement::Any));
m_imageDst = de::MovePtr<Image>(new Image(
vk, device, allocator,
- makeImageCreateInfo(m_texture, m_imageFormat, VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT),
+ makeImageCreateInfo(m_texture, m_imageFormat, VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT, imageFlags),
MemoryRequirement::Any));
}
const VkImageSubresourceRange fullImageSubresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, m_texture.numLayers());
{
- const VkImageMemoryBarrier barrierSetSrcImageLayout = makeImageMemoryBarrier(
- 0u, 0u,
- VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
- m_imageSrc->get(), fullImageSubresourceRange);
-
- const VkImageMemoryBarrier barrierSetDstImageLayout = makeImageMemoryBarrier(
- 0u, 0u,
- VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
- m_imageDst->get(), fullImageSubresourceRange);
+ const VkImageMemoryBarrier preCopyImageBarriers[] =
+ {
+ makeImageMemoryBarrier(
+ 0u, 0u,
+ VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+ m_imageSrc->get(), fullImageSubresourceRange),
+ makeImageMemoryBarrier(
+ 0u, 0u,
+ VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
+ m_imageDst->get(), fullImageSubresourceRange)
+ };
const VkBufferMemoryBarrier barrierFlushHostWriteBeforeCopy = makeBufferMemoryBarrier(
VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
m_imageBuffer->get(), 0ull, m_imageSizeBytes);
- const void* const barriers[] = { &barrierSetSrcImageLayout, &barrierSetDstImageLayout, &barrierFlushHostWriteBeforeCopy };
-
vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT | VK_PIPELINE_STAGE_TRANSFER_BIT,
- DE_FALSE, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &barrierFlushHostWriteBeforeCopy, DE_LENGTH_OF_ARRAY(preCopyImageBarriers), preCopyImageBarriers);
}
{
const VkImageMemoryBarrier barrierAfterCopy = makeImageMemoryBarrier(
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
m_imageSrc->get(), fullImageSubresourceRange);
- const void* const barriers[] = { &barrierAfterCopy };
-
const VkBufferImageCopy copyRegion = makeBufferImageCopy(m_texture);
vk.cmdCopyBufferToImage(cmdBuffer, m_imageBuffer->get(), m_imageSrc->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, ©Region);
- vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &barrierAfterCopy);
}
}
m_image->get(),
subresourceRange);
- const void* preComputeBarriers[] = { &imageLayoutBarrier };
- deviceInterface.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(preComputeBarriers), preComputeBarriers);
+ deviceInterface.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &imageLayoutBarrier);
}
void MemoryQualifierInstanceImage::commandsAfterCompute (const VkCommandBuffer cmdBuffer, const VkDeviceSize bufferSizeInBytes) const
m_image->get(),
subresourceRange);
- const void* preCopyBarriers[] = { &imagePreCopyBarrier };
- deviceInterface.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(preCopyBarriers), preCopyBarriers);
+ deviceInterface.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &imagePreCopyBarrier);
const VkBufferImageCopy copyParams = makeBufferImageCopy(vk::makeExtent3D(m_imageSize.x(), m_imageSize.y(), m_imageSize.z()), m_imageSize.w());
deviceInterface.cmdCopyImageToBuffer(cmdBuffer, m_image->get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, m_buffer->get(), 1u, ©Params);
0ull,
bufferSizeInBytes);
- const void* postCopyBarriers[] = { &bufferPostCopyBarrier };
- deviceInterface.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(postCopyBarriers), postCopyBarriers);
+ deviceInterface.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &bufferPostCopyBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
}
class MemoryQualifierInstanceBuffer : public MemoryQualifierInstanceBase
0ull,
bufferSizeInBytes);
- const void* barriers[] = { &shaderWriteBarrier };
- deviceInterface.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ deviceInterface.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &shaderWriteBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
}
TestInstance* MemoryQualifierTestCase::createInstance (Context& context) const
VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
m_resultBuffer->get(), 0ull, m_resultBufferSizeBytes);
- const void* const barriersAfter[] = { &shaderWriteBarrier };
-
// Create the pipeline.
const Unique<VkShaderModule> shaderModule(createShaderModule(vk, device, m_context.getBinaryCollection().get("comp"), 0));
commandBeforeCompute(*cmdBuffer);
vk.cmdDispatch(*cmdBuffer, 1, 1, 1);
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(barriersAfter), barriersAfter);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &shaderWriteBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
endCommandBuffer(vk, *cmdBuffer);
VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL,
m_image->get(), subresourceRange);
- const void* const barriers[] = { &barrierSetImageLayout };
-
- vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &barrierSetImageLayout);
}
class BufferSizeTestInstance : public SizeTestInstance
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- DE_FALSE, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u, // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
VK_CHECK(vk.beginCommandBuffer(commandBuffer, &commandBufBeginParams));
}
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // deUint32 commandBufferCount;
&commandBuffer, // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
if (m_memoryTypeIndex == 0)
{
log << TestLog::Message << "Memory allocation count: " << m_config.memoryAllocationCount << TestLog::EndMessage;
- log << TestLog::Message << "Single allocation size: " << (m_config.memorySize ? de::toString(*m_config.memorySize) : de::toString(100.0f * (*m_config.memoryPercentage)) + " of heap size.D") << TestLog::EndMessage;
+ log << TestLog::Message << "Single allocation size: " << (m_config.memorySize ? de::toString(*m_config.memorySize) : de::toString(100.0f * (*m_config.memoryPercentage)) + " percent of the heap size.") << TestLog::EndMessage;
if (m_config.order == TestConfig::ALLOC_REVERSE_FREE)
log << TestLog::Message << "Memory is freed in reversed order. " << TestLog::EndMessage;
{ "1MiB", 1*MiB }
};
- const float allocationPercents[] =
+ const int allocationPercents[] =
{
- 0.01f
+ 1
};
const int allocationCounts[] =
for (size_t allocationPercentNdx = 0; allocationPercentNdx < DE_LENGTH_OF_ARRAY(allocationPercents); allocationPercentNdx++)
{
- const float allocationPercent = allocationPercents[allocationPercentNdx];
- de::MovePtr<tcu::TestCaseGroup> percentGroup (new tcu::TestCaseGroup(testCtx, ("percent_" + de::toString((int)(100.0f * allocationPercent))).c_str(), ("Test different allocation percents " + de::toString(allocationPercent * 100.0f)).c_str()));
+ const int allocationPercent = allocationPercents[allocationPercentNdx];
+ de::MovePtr<tcu::TestCaseGroup> percentGroup (new tcu::TestCaseGroup(testCtx, ("percent_" + de::toString(allocationPercent)).c_str(), ("Test different allocation percents " + de::toString(allocationPercent)).c_str()));
for (size_t orderNdx = 0; orderNdx < DE_LENGTH_OF_ARRAY(orders); orderNdx++)
{
{
const int allocationCount = allocationCounts[allocationCountNdx];
- if ((allocationCount != -1) && ((float)allocationCount * allocationPercent >= 1.00f / 8.00f))
+ if ((allocationCount != -1) && ((float)allocationCount * (float)allocationPercent >= 1.00f / 8.00f))
continue;
TestConfig config;
- config.memoryPercentage = allocationPercent;
+ config.memoryPercentage = (float)allocationPercent / 100.0f;
config.order = order;
if (allocationCount == -1)
{
- config.memoryAllocationCount = (int)((1.00f / 8.00f) / allocationPercent);
+ config.memoryAllocationCount = (int)((1.00f / 8.00f) / ((float)allocationPercent / 100.0f));
if (config.memoryAllocationCount == 0
|| config.memoryAllocationCount == 1
enum
{
ALL_PIPELINE_STAGES = vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT
+ | vk::VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT
| vk::VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT
| vk::VK_PIPELINE_STAGE_VERTEX_INPUT_BIT
| vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT
enum PipelineStage
{
PIPELINESTAGE_TOP_OF_PIPE_BIT = 0,
+ PIPELINESTAGE_BOTTOM_OF_PIPE_BIT,
PIPELINESTAGE_DRAW_INDIRECT_BIT,
PIPELINESTAGE_VERTEX_INPUT_BIT,
PIPELINESTAGE_VERTEX_SHADER_BIT,
switch (flags)
{
case vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT: return PIPELINESTAGE_TOP_OF_PIPE_BIT;
+ case vk::VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT: return PIPELINESTAGE_BOTTOM_OF_PIPE_BIT;
case vk::VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT: return PIPELINESTAGE_DRAW_INDIRECT_BIT;
case vk::VK_PIPELINE_STAGE_VERTEX_INPUT_BIT: return PIPELINESTAGE_VERTEX_INPUT_BIT;
case vk::VK_PIPELINE_STAGE_VERTEX_SHADER_BIT: return PIPELINESTAGE_VERTEX_SHADER_BIT;
vk::VkCommandPool pool,
vk::VkCommandBufferLevel level)
{
- const vk::VkCommandBufferBeginInfo beginInfo =
+ const vk::VkCommandBufferInheritanceInfo inheritInfo =
{
- vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+ vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
DE_NULL,
- 0u,
0,
0,
0,
0u,
0u
};
+ const vk::VkCommandBufferBeginInfo beginInfo =
+ {
+ vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+ DE_NULL,
+ 0u,
+ (level == vk::VK_COMMAND_BUFFER_LEVEL_SECONDARY ? &inheritInfo : (const vk::VkCommandBufferInheritanceInfo*)DE_NULL),
+ };
vk::Move<vk::VkCommandBuffer> commandBuffer (createCommandBuffer(vkd, device, pool, level));
0,
DE_NULL,
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1,
&commandBuffer,
IVec2 findMaxRGBA8ImageSize (const vk::DeviceInterface& vkd,
vk::VkDevice device,
- vk::VkBufferUsageFlags usage,
+ vk::VkImageUsageFlags usage,
vk::VkSharingMode sharingMode,
const vector<deUint32>& queueFamilies,
vk::VK_IMAGE_TYPE_2D,
vk::VK_FORMAT_R8G8B8A8_UNORM,
{
- currentSize[0],
- currentSize[1],
- 1,
+ (deUint32)currentSize[0],
+ (deUint32)currentSize[1],
+ 1u,
},
1u, 1u,
vk::VK_SAMPLE_COUNT_1_BIT,
vk::VK_IMAGE_TYPE_2D,
vk::VK_FORMAT_R8G8B8A8_UNORM,
{
- m_imageWidth,
- m_imageHeight,
- 1,
+ (deUint32)m_imageWidth,
+ (deUint32)m_imageHeight,
+ 1u,
},
1u, 1u,
vk::VK_SAMPLE_COUNT_1_BIT,
0,
DE_NULL,
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1,
&cmd,
const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface();
const vk::VkCommandBuffer cmd = context.getCommandBuffer();
+ // \todo [2016-01-08 pyry] This could be cleaned up thanks to latest API changes
+
switch (m_type)
{
case TYPE_GLOBAL:
m_srcAccesses,
m_dstAccesses
};
- const void* const barriers[] =
- {
- &barrier
- };
- vkd.cmdPipelineBarrier(cmd, m_srcStages, m_dstStages, 0, 1, &barriers[0]);
+ vkd.cmdPipelineBarrier(cmd, m_srcStages, m_dstStages, (vk::VkDependencyFlags)0, 1, &barrier, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
break;
}
0,
vk::VK_WHOLE_SIZE
};
- const void* const barriers[] =
- {
- &barrier
- };
- vkd.cmdPipelineBarrier(cmd, m_srcStages, m_dstStages, 0, 1, &barriers[0]);
+ vkd.cmdPipelineBarrier(cmd, m_srcStages, m_dstStages, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 1, &barrier, 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
break;
}
{
const vk::VkImageMemoryBarrier barrier =
{
- vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+ vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
DE_NULL,
m_srcAccesses,
0, 1
}
};
- const void* const barriers[] =
- {
- &barrier
- };
- vkd.cmdPipelineBarrier(cmd, m_srcStages, m_dstStages, 0, 1, &barriers[0]);
+ vkd.cmdPipelineBarrier(cmd, m_srcStages, m_dstStages, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &barrier);
break;
}
~ImageTransition (void) {}
const char* getName (void) const { return "ImageTransition"; }
+ void prepare (PrepareContext& context);
void logSubmit (TestLog& log, size_t commandIndex) const;
void submit (SubmitContext& context);
};
log << TestLog::Message << commandIndex << ":" << getName() << " Use pipeline barrier to trasition to VK_IMAGE_LAYOUT_GENERAL." << TestLog::EndMessage;
}
+void ImageTransition::prepare (PrepareContext& context)
+{
+ context.setImageLayout(vk::VK_IMAGE_LAYOUT_GENERAL);
+}
+
void ImageTransition::submit (SubmitContext& context)
{
const vk::DeviceInterface& vkd = context.getContext().getDeviceInterface();
0u, 1u
}
};
- const void* const barriers[] =
- {
- &barrier
- };
- vkd.cmdPipelineBarrier(cmd, ALL_PIPELINE_STAGES, ALL_PIPELINE_STAGES, 0, 1, &barriers[0]);
+ vkd.cmdPipelineBarrier(cmd, ALL_PIPELINE_STAGES, ALL_PIPELINE_STAGES, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &barrier);
}
class FillBuffer : public CmdCommand
vk::VK_WHOLE_SIZE
};
- const void* barriers[] =
- {
- &barrier
- };
-
- vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &barriers[0]);
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 1, &barrier, 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
queueRun(vkd, queue, *commandBuffer);
vk::VK_IMAGE_TYPE_2D,
vk::VK_FORMAT_R8G8B8A8_UNORM,
{
- m_imageWidth,
- m_imageHeight,
- 1,
+ (deUint32)m_imageWidth,
+ (deUint32)m_imageHeight,
+ 1u,
},
1, 1, // mipLevels, arrayLayers
vk::VK_SAMPLE_COUNT_1_BIT,
1 // Layer count
}
};
- const void* barriers[] =
- {
- &barrier
- };
- vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &barriers[0]);
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &barrier);
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
queueRun(vkd, queue, *commandBuffer);
},
{ 0, 0, 0 },
{
- m_imageWidth,
- m_imageHeight,
- 1
+ (deUint32)m_imageWidth,
+ (deUint32)m_imageHeight,
+ 1u
}
};
vk::VK_WHOLE_SIZE
};
- const void* preBarriers[] =
- {
- &imageBarrier
- };
const vk::VkBufferImageCopy region =
{
0,
},
{ 0, 0, 0 },
{
- m_imageWidth,
- m_imageHeight,
- 1
+ (deUint32)m_imageWidth,
+ (deUint32)m_imageHeight,
+ 1u
}
};
- const void* postBarriers[] =
- {
- &bufferBarrier
- };
- vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &preBarriers[0]);
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrier);
vkd.cmdCopyImageToBuffer(*commandBuffer, *m_dstImage, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *dstBuffer, 1, ®ion);
- vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &postBarriers[0]);
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
}
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
vk::VK_IMAGE_TYPE_2D,
vk::VK_FORMAT_R8G8B8A8_UNORM,
{
- m_imageWidth,
- m_imageHeight,
- 1,
+ (deUint32)m_imageWidth,
+ (deUint32)m_imageHeight,
+ 1u,
},
1, 1, // mipLevels, arrayLayers
vk::VK_SAMPLE_COUNT_1_BIT,
m_memory = bindImageMemory(vki, vkd, physicalDevice, device, *m_srcImage, 0);
{
- const vk::Unique<vk::VkBuffer> srcBuffer (createBuffer(vkd, device, 4 * m_imageWidth * m_imageHeight, vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT, vk::VK_SHARING_MODE_EXCLUSIVE, queueFamilies));
+ const vk::Unique<vk::VkBuffer> srcBuffer (createBuffer(vkd, device, 4 * m_imageWidth * m_imageHeight, vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT, vk::VK_SHARING_MODE_EXCLUSIVE, queueFamilies));
const vk::Unique<vk::VkDeviceMemory> memory (bindBufferMemory(vki, vkd, physicalDevice, device, *srcBuffer, vk::VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT));
const vk::Unique<vk::VkCommandBuffer> commandBuffer (createBeginCommandBuffer(vkd, device, commandPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY));
const vk::VkImageMemoryBarrier preImageBarrier =
1 // Layer count
}
};
- const void* preBarriers[] =
- {
- &preImageBarrier
- };
- const void* postBarriers[] =
- {
- &postImageBarrier
- };
const vk::VkBufferImageCopy region =
{
0,
},
{ 0, 0, 0 },
{
- m_imageWidth,
- m_imageHeight,
- 1
+ (deUint32)m_imageWidth,
+ (deUint32)m_imageHeight,
+ 1u
}
};
vkd.unmapMemory(device, *memory);
}
- vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &preBarriers[0]);
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &preImageBarrier);
vkd.cmdCopyBufferToImage(*commandBuffer, *srcBuffer, *m_srcImage, vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion);
- vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &postBarriers[0]);
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &postImageBarrier);
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
queueRun(vkd, queue, *commandBuffer);
},
{ 0, 0, 0 },
{
- m_imageWidth,
- m_imageHeight,
- 1
+ (deUint32)m_imageWidth,
+ (deUint32)m_imageHeight,
+ 1u
}
};
},
{ 0, 0, 0 },
{
- m_imageWidth,
- m_imageHeight,
- 1
+ (deUint32)m_imageWidth,
+ (deUint32)m_imageHeight,
+ 1u
}
};
vk::VK_WHOLE_SIZE
};
- const void* barriers[] =
- {
- &barrier
- };
-
- vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &barriers[0]);
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 1, &barrier, 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
queueRun(vkd, queue, *commandBuffer);
},
{ 0, 0, 0 },
{
- m_imageWidth,
- m_imageHeight,
- 1
+ (deUint32)m_imageWidth,
+ (deUint32)m_imageHeight,
+ 1u
}
};
vk::VK_IMAGE_TYPE_2D,
vk::VK_FORMAT_R8G8B8A8_UNORM,
{
- m_imageWidth,
- m_imageHeight,
- 1,
+ (deUint32)m_imageWidth,
+ (deUint32)m_imageHeight,
+ 1u,
},
1, 1, // mipLevels, arrayLayers
vk::VK_SAMPLE_COUNT_1_BIT,
m_memory = bindImageMemory(vki, vkd, physicalDevice, device, *m_srcImage, 0);
{
- const vk::Unique<vk::VkBuffer> srcBuffer (createBuffer(vkd, device, 4 * m_imageWidth * m_imageHeight, vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT, vk::VK_SHARING_MODE_EXCLUSIVE, queueFamilies));
+ const vk::Unique<vk::VkBuffer> srcBuffer (createBuffer(vkd, device, 4 * m_imageWidth * m_imageHeight, vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT, vk::VK_SHARING_MODE_EXCLUSIVE, queueFamilies));
const vk::Unique<vk::VkDeviceMemory> memory (bindBufferMemory(vki, vkd, physicalDevice, device, *srcBuffer, vk::VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT));
const vk::Unique<vk::VkCommandBuffer> commandBuffer (createBeginCommandBuffer(vkd, device, commandPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY));
const vk::VkImageMemoryBarrier preImageBarrier =
1 // Layer count
}
};
- const void* preBarriers[] =
- {
- &preImageBarrier
- };
- const void* postBarriers[] =
- {
- &postImageBarrier
- };
const vk::VkBufferImageCopy region =
{
0,
},
{ 0, 0, 0 },
{
- m_imageWidth,
- m_imageHeight,
- 1
+ (deUint32)m_imageWidth,
+ (deUint32)m_imageHeight,
+ 1u
}
};
vkd.unmapMemory(device, *memory);
}
- vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &preBarriers[0]);
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &preImageBarrier);
vkd.cmdCopyBufferToImage(*commandBuffer, *srcBuffer, *m_srcImage, vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion);
- vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &postBarriers[0]);
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &postImageBarrier);
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
queueRun(vkd, queue, *commandBuffer);
},
{ 0, 0, 0 },
{
- m_imageWidth,
- m_imageHeight,
- 1
+ (deUint32)m_imageWidth,
+ (deUint32)m_imageHeight,
+ 1u
}
};
vk::VK_IMAGE_TYPE_2D,
vk::VK_FORMAT_R8G8B8A8_UNORM,
{
- m_imageWidth,
- m_imageHeight,
- 1,
+ (deUint32)m_imageWidth,
+ (deUint32)m_imageHeight,
+ 1u,
},
1, 1, // mipLevels, arrayLayers
vk::VK_SAMPLE_COUNT_1_BIT,
1 // Layer count
}
};
- const void* barriers[] =
- {
- &barrier
- };
- vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &barriers[0]);
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &barrier);
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
queueRun(vkd, queue, *commandBuffer);
},
{ 0, 0, 0 },
{
- m_imageWidth,
- m_imageHeight,
- 1
+ (deUint32)m_imageWidth,
+ (deUint32)m_imageHeight,
+ 1u
}
};
0,
vk::VK_WHOLE_SIZE
};
-
- const void* preBarriers[] =
- {
- &imageBarrier
- };
const vk::VkBufferImageCopy region =
{
0,
},
{ 0, 0, 0 },
{
- m_imageWidth,
- m_imageHeight,
- 1
+ (deUint32)m_imageWidth,
+ (deUint32)m_imageHeight,
+ 1u
}
};
- const void* postBarriers[] =
- {
- &bufferBarrier
- };
- vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &preBarriers[0]);
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrier);
vkd.cmdCopyImageToBuffer(*commandBuffer, *m_dstImage, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *dstBuffer, 1, ®ion);
- vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &postBarriers[0]);
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
}
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
vk::VK_IMAGE_TYPE_2D,
vk::VK_FORMAT_R8G8B8A8_UNORM,
{
- m_srcImageWidth,
- m_srcImageHeight,
- 1,
+ (deUint32)m_srcImageWidth,
+ (deUint32)m_srcImageHeight,
+ 1u,
},
1, 1, // mipLevels, arrayLayers
vk::VK_SAMPLE_COUNT_1_BIT,
1 // Layer count
}
};
- const void* preBarriers[] =
- {
- &preImageBarrier
- };
- const void* postBarriers[] =
- {
- &postImageBarrier
- };
const vk::VkBufferImageCopy region =
{
0,
},
{ 0, 0, 0 },
{
- m_srcImageWidth,
- m_srcImageHeight,
- 1
+ (deUint32)m_srcImageWidth,
+ (deUint32)m_srcImageHeight,
+ 1u
}
};
vkd.unmapMemory(device, *memory);
}
- vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &preBarriers[0]);
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &preImageBarrier);
vkd.cmdCopyBufferToImage(*commandBuffer, *srcBuffer, *m_srcImage, vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion);
- vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &postBarriers[0]);
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &postImageBarrier);
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
queueRun(vkd, queue, *commandBuffer);
0, // arrayLayer
1 // layerCount
},
- { 0, 0, 0 },
{
- m_srcImageWidth,
- m_srcImageHeight,
- 1
+ { 0, 0, 0 },
+ {
+ m_srcImageWidth,
+ m_srcImageHeight,
+ 1
+ },
},
// Dst
0, // arrayLayer
1 // layerCount
},
- { 0, 0, 0 },
{
- m_imageWidth,
- m_imageHeight,
- 1
+ { 0, 0, 0 },
+ {
+ m_imageWidth,
+ m_imageHeight,
+ 1u
+ }
}
};
vkd.cmdBlitImage(commandBuffer, *m_srcImage, vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, context.getImage(), context.getImageLayout(), 1, ®ion, vk::VK_FILTER_NEAREST);
vk::VK_IMAGE_TYPE_2D,
vk::VK_FORMAT_R8G8B8A8_UNORM,
{
- m_dstImageWidth,
- m_dstImageHeight,
- 1,
+ (deUint32)m_dstImageWidth,
+ (deUint32)m_dstImageHeight,
+ 1u,
},
1, 1, // mipLevels, arrayLayers
vk::VK_SAMPLE_COUNT_1_BIT,
1 // Layer count
}
};
- const void* barriers[] =
- {
- &barrier
- };
- vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &barriers[0]);
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &barrier);
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
queueRun(vkd, queue, *commandBuffer);
0, // arrayLayer
1 // layerCount
},
- { 0, 0, 0 },
{
- m_imageWidth,
- m_imageHeight,
- 1
+ { 0, 0, 0 },
+ {
+ m_imageWidth,
+ m_imageHeight,
+ 1
+ },
},
// Dst
0, // arrayLayer
1 // layerCount
},
- { 0, 0, 0 },
{
- m_dstImageWidth,
- m_dstImageHeight,
- 1
+ { 0, 0, 0 },
+ {
+ m_dstImageWidth,
+ m_dstImageHeight,
+ 1u
+ }
}
};
vkd.cmdBlitImage(commandBuffer, context.getImage(), context.getImageLayout(), *m_dstImage, vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion, vk::VK_FILTER_NEAREST);
0,
vk::VK_WHOLE_SIZE
};
-
- const void* preBarriers[] =
- {
- &imageBarrier
- };
const vk::VkBufferImageCopy region =
{
0,
},
{ 0, 0, 0 },
{
- m_dstImageWidth,
- m_dstImageHeight,
+ (deUint32)m_dstImageWidth,
+ (deUint32)m_dstImageHeight,
1
}
};
- const void* postBarriers[] =
- {
- &bufferBarrier
- };
- vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &preBarriers[0]);
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrier);
vkd.cmdCopyImageToBuffer(*commandBuffer, *m_dstImage, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *dstBuffer, 1, ®ion);
- vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &postBarriers[0]);
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
}
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
vk::VK_IMAGE_TYPE_2D,
vk::VK_FORMAT_R8G8B8A8_UNORM,
- { m_targetWidth, m_targetHeight, 1 },
+ { (deUint32)m_targetWidth, (deUint32)m_targetHeight, 1u },
1u,
1u,
vk::VK_SAMPLE_COUNT_1_BIT,
*m_renderPass,
*m_framebuffer,
- { { 0, 0 }, { m_targetWidth, m_targetHeight } },
+ { { 0, 0 }, { (deUint32)m_targetWidth, (deUint32)m_targetHeight } },
1u,
&clearValue
};
0,
vk::VK_WHOLE_SIZE
};
-
- const void* preBarriers[] =
- {
- &imageBarrier
- };
const vk::VkBufferImageCopy region =
{
0,
},
{ 0, 0, 0 },
{
- m_targetWidth,
- m_targetHeight,
- 1
+ (deUint32)m_targetWidth,
+ (deUint32)m_targetHeight,
+ 1u
}
};
- const void* postBarriers[] =
- {
- &bufferBarrier
- };
- vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &preBarriers[0]);
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrier);
vkd.cmdCopyImageToBuffer(*commandBuffer, *m_colorTarget, vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *dstBuffer, 1, ®ion);
- vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &postBarriers[0]);
+ vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
}
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
};
const vk::VkRect2D scissors[] =
{
- { { 0, 0 }, { context.getTargetWidth(), context.getTargetHeight() } }
+ { { 0, 0 }, { (deUint32)context.getTargetWidth(), (deUint32)context.getTargetHeight() } }
};
const vk::VkPipelineViewportStateCreateInfo viewportState =
{
&& usage & USAGE_HOST_WRITE
&& state.memoryDefined
&& state.hostInvalidated
+ && state.queueIdle
&& state.cache.isValid(vk::VK_PIPELINE_STAGE_HOST_BIT, vk::VK_ACCESS_HOST_WRITE_BIT)
&& state.cache.isValid(vk::VK_PIPELINE_STAGE_HOST_BIT, vk::VK_ACCESS_HOST_READ_BIT))
{
if (usage & USAGE_HOST_READ
&& state.memoryDefined
&& state.hostInvalidated
+ && state.queueIdle
&& state.cache.isValid(vk::VK_PIPELINE_STAGE_HOST_BIT, vk::VK_ACCESS_HOST_READ_BIT))
{
ops.push_back(OP_MAP_READ);
if (usage & USAGE_HOST_WRITE
&& state.hostInvalidated
+ && state.queueIdle
&& state.cache.isValid(vk::VK_PIPELINE_STAGE_HOST_BIT, vk::VK_ACCESS_HOST_WRITE_BIT))
{
ops.push_back(OP_MAP_WRITE);
log << TestLog::Message << "Max buffer size: " << maxBufferSize << TestLog::EndMessage;
log << TestLog::Message << "Max RGBA8 image size: " << maxImageSize << TestLog::EndMessage;
- testCommand(log, m_resultCollector, m_context.getBinaryCollection(), vki, vkd, physicalDevice, device, m_config.size, m_memoryTypeNdx, m_config.usage, m_config.sharing, queue, queueFamilyIndex, queues, maxBufferSize, maxImageSize);
+
+ // Skip tests if there are no supported operations
+ if (maxBufferSize == 0
+ && maxImageSize[0] == 0
+ && (m_config.usage & (USAGE_HOST_READ|USAGE_HOST_WRITE)) == 0)
+ {
+ log << TestLog::Message << "Skipping memory type. None of the usages are supported." << TestLog::EndMessage;
+ }
+ else
+ {
+ testCommand(log, m_resultCollector, m_context.getBinaryCollection(), vki, vkd, physicalDevice, device, m_config.size, m_memoryTypeNdx, m_config.usage, m_config.sharing, queue, queueFamilyIndex, queues, maxBufferSize, maxImageSize);
+ }
}
catch (const tcu::TestError& e)
{
"highp float;\n"
"void main (void) {\n"
"\tgl_PointSize = 1.0;\n"
- "\thighp vec2 pos = vec2(gl_VertexID % 256, gl_VertexID / 256) / vec2(255.0);\n"
+ "\thighp vec2 pos = vec2(gl_VertexIndex % 256, gl_VertexIndex / 256) / vec2(255.0);\n"
"\tgl_Position = vec4(1.999 * pos - vec2(0.999), 0.0, 1.0);\n"
"}\n";
de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "pipeline_barrier", "Pipeline barrier tests."));
const vk::VkDeviceSize sizes[] =
{
- 1024,
- 1024*1024,
+ 1024, // 1K
+ 8*1024, // 8K
+ 64*1024, // 64K
+ 1024*1024, // 1M
};
const Usage usages[] =
{
VkPipelineColorBlendAttachmentState m_blendStates[BlendTest::QUAD_COUNT];
- const tcu::IVec2 m_renderSize;
+ const tcu::UVec2 m_renderSize;
const VkFormat m_colorFormat;
VkImageCreateInfo m_colorImageCreateInfo;
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- false, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const VkClearValue attachmentClearValue = defaultClearValue(m_colorFormat);
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
private:
VkCompareOp m_depthCompareOps[DepthTest::QUAD_COUNT];
- const tcu::IVec2 m_renderSize;
+ const tcu::UVec2 m_renderSize;
const VkFormat m_colorFormat;
const VkFormat m_depthFormat;
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- false, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const VkClearValue attachmentClearValues[2] =
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
} // anonymous
ImageSamplingInstance::ImageSamplingInstance (Context& context,
- const tcu::IVec2& renderSize,
+ const tcu::UVec2& renderSize,
VkImageViewType imageViewType,
VkFormat imageFormat,
const tcu::IVec3& imageSize,
getCompatibleImageType(m_imageViewType), // VkImageType imageType;
imageFormat, // VkFormat format;
{ // VkExtent3D extent;
- m_imageSize.x(),
- m_imageSize.y(),
- m_imageSize.z()
+ (deUint32)m_imageSize.x(),
+ (deUint32)m_imageSize.y(),
+ (deUint32)m_imageSize.z()
},
(deUint32)m_texture->getNumLevels(), // deUint32 mipLevels;
(deUint32)m_layerCount, // deUint32 arrayLayers;
0u, // VkImageCreateFlags flags;
VK_IMAGE_TYPE_2D, // VkImageType imageType;
m_colorFormat, // VkFormat format;
- { m_renderSize.x(), m_renderSize.y(), 1u }, // VkExtent3D extent;
+ { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y(), 1u }, // VkExtent3D extent;
1u, // deUint32 mipLevels;
1u, // deUint32 arrayLayers;
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1.0f // float maxDepth;
};
- const VkRect2D scissor = { { 0, 0 }, { m_renderSize.x(), m_renderSize.y() } };
+ const VkRect2D scissor = { { 0, 0 }, { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y() } };
const VkPipelineViewportStateCreateInfo viewportStateParams =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- false, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const VkClearValue attachmentClearValue = defaultClearValue(m_colorFormat);
DE_NULL, // const void* pNext;
*m_renderPass, // VkRenderPass renderPass;
*m_framebuffer, // VkFramebuffer framebuffer;
- { { 0, 0 }, { m_renderSize.x(), m_renderSize.y() } }, // VkRect2D renderArea;
+ {
+ { 0, 0 },
+ { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y() }
+ }, // VkRect2D renderArea;
1, // deUint32 clearValueCount;
&attachmentClearValue // const VkClearValue* pClearValues;
};
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ DE_NULL,
1u, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
{
public:
ImageSamplingInstance (Context& context,
- const tcu::IVec2& renderSize,
+ const tcu::UVec2& renderSize,
vk::VkImageViewType imageViewType,
vk::VkFormat imageFormat,
const tcu::IVec3& imageSize,
vk::Move<vk::VkSampler> m_sampler;
de::MovePtr<TestTexture> m_texture;
- const tcu::IVec2 m_renderSize;
+ const tcu::UVec2 m_renderSize;
const vk::VkFormat m_colorFormat;
vk::Move<vk::VkDescriptorPool> m_descriptorPool;
TestInstance* ImageTest::createInstance (Context& context) const
{
- tcu::IVec2 renderSize;
+ tcu::UVec2 renderSize;
if (m_imageViewType == VK_IMAGE_VIEW_TYPE_1D || m_imageViewType == VK_IMAGE_VIEW_TYPE_2D)
{
- renderSize = tcu::IVec2(m_imageSize.x(), m_imageSize.y());
+ renderSize = tcu::UVec2((deUint32)m_imageSize.x(), (deUint32)m_imageSize.y());
}
else
{
// Draw a 3x2 grid of texture layers
- renderSize = tcu::IVec2(m_imageSize.x() * 3, m_imageSize.y() * 2);
+ renderSize = tcu::UVec2((deUint32)m_imageSize.x() * 3, (deUint32)m_imageSize.y() * 2);
}
const std::vector<Vertex4Tex4> vertices = createTestQuadMosaic(m_imageViewType);
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeV;
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeW;
0.0f, // float mipLodBias;
+ VK_FALSE, // VkBool32 anisotropyEnable;
1.0f, // float maxAnisotropy;
false, // VkBool32 compareEnable;
VK_COMPARE_OP_NEVER, // VkCompareOp compareOp;
using namespace vk;
-/*! Gets the next multiple of M */
-template<deUint32 M>
-static int getNextMultiple(deUint32 value)
+/*! Gets the next multiple of a given divisor */
+static deUint32 getNextMultiple (deUint32 divisor, deUint32 value)
{
- if (value % M == 0)
+ if (value % divisor == 0)
{
return value;
}
- return value + M - (value % M);
+ return value + divisor - (value % divisor);
}
-static int getNextMultiple (deUint32 M, deUint32 value)
+/*! Gets the next value that is multiple of all given divisors */
+static deUint32 getNextMultiple (const std::vector<deUint32>& divisors, deUint32 value)
{
- if (value % M == 0)
+ deUint32 nextMultiple = value;
+ bool nextMultipleFound = false;
+
+ while (true)
{
- return value;
+ nextMultipleFound = true;
+
+ for (size_t divNdx = 0; divNdx < divisors.size(); divNdx++)
+ nextMultipleFound = nextMultipleFound && (nextMultiple % divisors[divNdx] == 0);
+
+ if (nextMultipleFound)
+ break;
+
+ DE_ASSERT(nextMultiple < ~((deUint32)0u));
+ nextMultiple = getNextMultiple(divisors[0], nextMultiple + 1);
}
- return value + M - (value % M);
-}
+ return nextMultiple;
+}
bool isSupportedSamplableFormat (const InstanceInterface& instanceInterface, VkPhysicalDevice device, VkFormat format)
{
vk::Allocator& allocator,
vk::VkImage image,
vk::VkFormat format,
- const tcu::IVec2& renderSize)
+ const tcu::UVec2& renderSize)
{
Move<VkBuffer> buffer;
de::MovePtr<Allocation> bufferAlloc;
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- false, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
- const void* const imageBarrierPtr = &imageBarrier;
- const void* const bufferBarrierPtr = &bufferBarrier;
-
// Copy image to buffer
const VkBufferImageCopy copyRegion =
{
- 0u, // VkDeviceSize bufferOffset;
- (deUint32)renderSize.x(), // deUint32 bufferRowLength;
- (deUint32)renderSize.y(), // deUint32 bufferImageHeight;
- { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u }, // VkImageSubresourceLayers imageSubresource;
- { 0, 0, 0 }, // VkOffset3D imageOffset;
- { renderSize.x(), renderSize.y(), 1 } // VkExtent3D imageExtent;
+ 0u, // VkDeviceSize bufferOffset;
+ (deUint32)renderSize.x(), // deUint32 bufferRowLength;
+ (deUint32)renderSize.y(), // deUint32 bufferImageHeight;
+ { VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u }, // VkImageSubresourceLayers imageSubresource;
+ { 0, 0, 0 }, // VkOffset3D imageOffset;
+ { renderSize.x(), renderSize.y(), 1u } // VkExtent3D imageExtent;
};
VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo));
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_FALSE, 1, &imageBarrierPtr);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &imageBarrier);
vk.cmdCopyImageToBuffer(*cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, 1, ©Region);
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_FALSE, 1, &bufferBarrierPtr);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
const VkSubmitInfo submitInfo =
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ DE_NULL,
1u, // deUint32 commandBufferCount;
&cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- false, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
- const void* preCopyBarriers[2] =
- {
- &preBufferBarrier,
- &preImageBarrier
- };
-
- const void* const postCopyBarrier = &postImageBarrier;
const std::vector<VkBufferImageCopy> copyRegions = srcTexture.getBufferCopyRegions();
// Write buffer data
// Copy buffer to image
VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo));
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_FALSE, 2, preCopyBarriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &preBufferBarrier, 1, &preImageBarrier);
vk.cmdCopyBufferToImage(*cmdBuffer, *buffer, destImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)copyRegions.size(), copyRegions.data());
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_FALSE, 1, &postCopyBarrier);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &postImageBarrier);
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ DE_NULL,
1u, // deUint32 commandBufferCount;
&cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
deUint32 TestTexture::getSize (void) const
{
- deUint32 textureSize = 0;
+ std::vector<deUint32> offsetMultiples;
+ deUint32 textureSize = 0;
+
+ offsetMultiples.push_back(4);
+ offsetMultiples.push_back(getLevel(0, 0).getFormat().getPixelSize());
for (int levelNdx = 0; levelNdx < getNumLevels(); levelNdx++)
{
for (int layerNdx = 0; layerNdx < getArraySize(); layerNdx++)
{
const tcu::ConstPixelBufferAccess level = getLevel(levelNdx, layerNdx);
- textureSize = getNextMultiple<4>(textureSize);
+ textureSize = getNextMultiple(offsetMultiples, textureSize);
textureSize += level.getWidth() * level.getHeight() * level.getDepth() * level.getFormat().getPixelSize();
}
}
if (!isCompressed())
throw tcu::InternalError("Texture is not compressed");
- deUint32 textureSize = 0;
+ std::vector<deUint32> offsetMultiples;
+ deUint32 textureSize = 0;
+
+ offsetMultiples.push_back(4);
+ offsetMultiples.push_back(tcu::getBlockSize(getCompressedLevel(0, 0).getFormat()));
for (int levelNdx = 0; levelNdx < getNumLevels(); levelNdx++)
{
for (int layerNdx = 0; layerNdx < getArraySize(); layerNdx++)
{
- textureSize = getNextMultiple<4>(textureSize);
+ textureSize = getNextMultiple(offsetMultiples, textureSize);
textureSize += getCompressedLevel(levelNdx, layerNdx).getDataSize();
}
}
std::vector<VkBufferImageCopy> TestTexture::getBufferCopyRegions (void) const
{
+ std::vector<deUint32> offsetMultiples;
std::vector<VkBufferImageCopy> regions;
deUint32 layerDataOffset = 0;
+ offsetMultiples.push_back(4);
+
if (isCompressed())
{
+ offsetMultiples.push_back(tcu::getBlockSize(getCompressedLevel(0, 0).getFormat()));
+
for (int levelNdx = 0; levelNdx < getNumLevels(); levelNdx++)
{
for (int layerNdx = 0; layerNdx < getArraySize(); layerNdx++)
{
const tcu::CompressedTexture& level = getCompressedLevel(levelNdx, layerNdx);
tcu::IVec3 blockPixelSize = getBlockPixelSize(level.getFormat());
- layerDataOffset = getNextMultiple<4>(layerDataOffset);
+ layerDataOffset = getNextMultiple(offsetMultiples, layerDataOffset);
const VkBufferImageCopy layerRegion =
{
},
{ 0u, 0u, 0u }, // VkOffset3D imageOffset;
{ // VkExtent3D imageExtent;
- level.getWidth(),
- level.getHeight(),
- level.getDepth()
+ (deUint32)level.getWidth(),
+ (deUint32)level.getHeight(),
+ (deUint32)level.getDepth()
}
};
}
else
{
+ offsetMultiples.push_back(getLevel(0, 0).getFormat().getPixelSize());
+
for (int levelNdx = 0; levelNdx < getNumLevels(); levelNdx++)
{
for (int layerNdx = 0; layerNdx < getArraySize(); layerNdx++)
{
const tcu::ConstPixelBufferAccess level = getLevel(levelNdx, layerNdx);
- layerDataOffset = getNextMultiple<4>(layerDataOffset);
+ layerDataOffset = getNextMultiple(offsetMultiples, layerDataOffset);
const VkBufferImageCopy layerRegion =
{
},
{ 0u, 0u, 0u }, // VkOffset3D imageOffset;
{ // VkExtent3D imageExtent;
- level.getWidth(),
- level.getHeight(),
- level.getDepth()
+ (deUint32)level.getWidth(),
+ (deUint32)level.getHeight(),
+ (deUint32)level.getDepth()
}
};
void TestTexture::write (deUint8* destPtr) const
{
- deUint32 levelOffset = 0;
+ std::vector<deUint32> offsetMultiples;
+ deUint32 levelOffset = 0;
+
+ offsetMultiples.push_back(4);
if (isCompressed())
{
+ offsetMultiples.push_back(tcu::getBlockSize(getCompressedLevel(0, 0).getFormat()));
+
for (int levelNdx = 0; levelNdx < getNumLevels(); levelNdx++)
{
for (int layerNdx = 0; layerNdx < getArraySize(); layerNdx++)
{
- levelOffset = getNextMultiple<4>(levelOffset);
+ levelOffset = getNextMultiple(offsetMultiples, levelOffset);
const tcu::CompressedTexture& compressedTex = getCompressedLevel(levelNdx, layerNdx);
}
else
{
+ offsetMultiples.push_back(getLevel(0, 0).getFormat().getPixelSize());
+
for (int levelNdx = 0; levelNdx < getNumLevels(); levelNdx++)
{
for (int layerNdx = 0; layerNdx < getArraySize(); layerNdx++)
{
- levelOffset = getNextMultiple<4>(levelOffset);
+ levelOffset = getNextMultiple(offsetMultiples, levelOffset);
const tcu::ConstPixelBufferAccess srcAccess = getLevel(levelNdx, layerNdx);
const tcu::PixelBufferAccess destAccess (srcAccess.getFormat(), srcAccess.getSize(), srcAccess.getPitch(), destPtr + levelOffset);
m_compressedLevels.push_back(compressedLevel);
// Store decompressed data
- compressedLevel->decompress(level);
+ compressedLevel->decompress(level, tcu::TexDecompressionParams::ASTCMODE_LDR);
}
}
vk::Allocator& allocator,
vk::VkImage image,
vk::VkFormat format,
- const tcu::IVec2& renderSize);
+ const tcu::UVec2& renderSize);
/*--------------------------------------------------------------------*//*!
* Uploads data from a test texture to a destination VK image.
virtual void initPrograms (SourceCollections& sourceCollections) const;
virtual TestInstance* createInstance (Context& context) const;
- static std::string getGlslSamplerType (const tcu::TextureFormat& format,
+ static std::string getGlslSamplerType (const tcu::TextureFormat& format,
VkImageViewType type);
- static tcu::IVec2 getRenderSize (VkImageViewType viewType);
+ static tcu::UVec2 getRenderSize (VkImageViewType viewType);
static tcu::IVec3 getImageSize (VkImageViewType viewType);
static int getArraySize (VkImageViewType viewType);
static int getNumLevels (VkImageViewType viewType);
- static tcu::Vec4 swizzle (tcu::Vec4 inputData,
+ static tcu::Vec4 swizzle (tcu::Vec4 inputData,
VkComponentMapping componentMapping);
private:
VkImageViewType m_imageViewType;
tcu::Vec4 swizzledScale = swizzle(formatInfo.lookupScale, m_componentMapping);
tcu::Vec4 swizzledBias = swizzle(formatInfo.lookupBias, m_componentMapping);
-
+
switch (m_imageViewType)
{
case VK_IMAGE_VIEW_TYPE_1D:
TestInstance* ImageViewTest::createInstance (Context& context) const
{
- tcu::IVec2 renderSize = getRenderSize(m_imageViewType);
+ const tcu::UVec2 renderSize = getRenderSize(m_imageViewType);
const tcu::IVec3 imageSize = getImageSize(m_imageViewType);
const int arraySize = getArraySize(m_imageViewType);
const std::vector<Vertex4Tex4> vertices = createTestQuadMosaic(m_imageViewType);
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeV;
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeW;
0.0f, // float mipLodBias;
+ VK_FALSE, // VkBool32 anisotropyEnable;
1.0f, // float maxAnisotropy;
false, // VkBool32 compareEnable;
VK_COMPARE_OP_NEVER, // VkCompareOp compareOp;
return samplerType.str();
}
-tcu::IVec2 ImageViewTest::getRenderSize (VkImageViewType viewType)
+tcu::UVec2 ImageViewTest::getRenderSize (VkImageViewType viewType)
{
if (viewType == VK_IMAGE_VIEW_TYPE_1D || viewType == VK_IMAGE_VIEW_TYPE_2D)
- return tcu::IVec2(16, 16);
+ return tcu::UVec2(16u, 16u);
else
- return tcu::IVec2(16 * 3, 16 * 2);
+ return tcu::UVec2(16u * 3u, 16u * 2u);
}
tcu::IVec3 ImageViewTest::getImageSize (VkImageViewType viewType)
std::vector<deUint32> m_indices;
de::MovePtr<Allocation> m_indexBufferAlloc;
- const tcu::IVec2 m_renderSize;
+ const tcu::UVec2 m_renderSize;
const VkFormat m_colorFormat;
VkImageCreateInfo m_colorImageCreateInfo;
, m_indexType (indexType)
, m_vertices (vertexBufferData)
, m_indices (indexBufferData)
- , m_renderSize ((primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN) ? tcu::IVec2(32, 32) : tcu::IVec2(64, 16))
+ , m_renderSize ((primitiveTopology == VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN) ? tcu::UVec2(32, 32) : tcu::UVec2(64, 16))
, m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM)
{
const DeviceInterface& vk = context.getDeviceInterface();
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- false, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const VkClearValue attachmentClearValue = defaultClearValue(m_colorFormat);
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
const std::vector<Vertex4RGBA> m_vertices;
const VkPipelineMultisampleStateCreateInfo m_multisampleStateParams;
const VkPipelineColorBlendAttachmentState m_colorBlendState;
- const GeometryType m_geometryType;
+ const GeometryType m_geometryType;
};
0u, // VkImageCreateFlags flags;
VK_IMAGE_TYPE_2D, // VkImageType imageType;
m_colorFormat, // VkFormat format;
- { m_renderSize.x(), m_renderSize.y(), 1u }, // VkExtent3D extent;
+ { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y(), 1u }, // VkExtent3D extent;
1u, // deUint32 mipLevels;
1u, // deUint32 arrayLayers;
m_multisampleStateParams.rasterizationSamples, // VkSampleCountFlagBits samples;
0u, // VkImageCreateFlags flags;
VK_IMAGE_TYPE_2D, // VkImageType imageType;
m_colorFormat, // VkFormat format;
- { m_renderSize.x(), m_renderSize.y(), 1u }, // VkExtent3D extent;
+ { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y(), 1u }, // VkExtent3D extent;
1u, // deUint32 mipLevels;
1u, // deUint32 arrayLayers;
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
const VkRect2D scissor =
{
- { 0, 0 }, // VkOffset2D offset;
- { m_renderSize.x(), m_renderSize.y() } // VkExtent2D extent;
+ { 0, 0 }, // VkOffset2D offset;
+ { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y() } // VkExtent2D extent;
};
const VkPipelineViewportStateCreateInfo viewportStateParams =
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- false, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
VkClearValue colorClearValue;
DE_NULL, // const void* pNext;
*m_renderPass, // VkRenderPass renderPass;
*m_framebuffer, // VkFramebuffer framebuffer;
- { { 0, 0 }, { m_renderSize.x(), m_renderSize.y() } }, // VkRect2D renderArea;
+ {
+ { 0, 0 },
+ { (deUint32)m_renderSize.x(), (deUint32)m_renderSize.y() }
+ }, // VkRect2D renderArea;
2, // deUint32 clearValueCount;
clearValues // const VkClearValue* pClearValues;
};
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity*/));
- return readColorAttachment(vk, vkDevice, queue, queueFamilyIndex, allocator, *m_resolveImage, m_colorFormat, m_renderSize);
+ return readColorAttachment(vk, vkDevice, queue, queueFamilyIndex, allocator, *m_resolveImage, m_colorFormat, m_renderSize.cast<deUint32>());
}
} // anonymous
tcu::TestStatus verifyImage (void);
private:
- const tcu::IVec2 m_renderSize;
+ const tcu::UVec2 m_renderSize;
const VkFormat m_colorFormat;
const deUint32 m_rangeCount;
PushConstantData m_pushConstantRange[MAX_RANGE_COUNT];
case SIZE_CASE_16:
vertexSrc << "vec4 color;\n"
<< "} matInst;\n"
- << "layout(location = 0) uniform UniformBuf {\n"
+ << "layout(std140, binding = 0) uniform UniformBuf {\n"
<< "vec4 element;\n"
<< "} uniformBuf;\n";
break;
{
VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
- 0u, // VkPipelineTesselationStateCreateFlags flags;
+ 0u, // VkPipelineTessellationStateCreateFlags flags;
3u, // uint32_t patchControlPoints;
};
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- false, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const VkClearValue attachmentClearValues[] =
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- false, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
const tcu::Vec4 swizColor = swizzle(texColor, m_swizzle);
const tcu::Vec4 normColor = swizColor * swizzle(m_textureFormatInfo.lookupScale, m_swizzle) + swizzle(m_textureFormatInfo.lookupBias, m_swizzle);
const tcu::Vec4 color = (normColor - m_colorFormatInfo.lookupBias) / m_colorFormatInfo.lookupScale;
- rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
+ rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
}
}
}
virtual void initPrograms (SourceCollections& sourceCollections) const;
virtual TestInstance* createInstance (Context& context) const;
- virtual tcu::IVec2 getRenderSize (VkImageViewType viewType) const;
+ virtual tcu::UVec2 getRenderSize (VkImageViewType viewType) const;
virtual std::vector<Vertex4Tex4> createVertices (void) const;
virtual VkSamplerCreateInfo getSamplerCreateInfo (void) const;
VkSamplerAddressMode addressW,
VkBorderColor borderColor);
virtual ~SamplerAddressModesTest (void) {}
- virtual tcu::IVec2 getRenderSize (VkImageViewType viewType) const;
+ virtual tcu::UVec2 getRenderSize (VkImageViewType viewType) const;
virtual std::vector<Vertex4Tex4> createVertices (void) const;
virtual VkSamplerCreateInfo getSamplerCreateInfo (void) const;
TestInstance* SamplerTest::createInstance (Context& context) const
{
- const tcu::IVec2 renderSize = getRenderSize(m_imageViewType);
+ const tcu::UVec2 renderSize = getRenderSize(m_imageViewType);
const std::vector<Vertex4Tex4> vertices = createVertices();
const VkSamplerCreateInfo samplerParams = getSamplerCreateInfo();
const VkComponentMapping componentMapping = getFormatComponentMapping(m_imageFormat);
samplerParams, m_samplerLod,vertices);
}
-tcu::IVec2 SamplerTest::getRenderSize (VkImageViewType viewType) const
+tcu::UVec2 SamplerTest::getRenderSize (VkImageViewType viewType) const
{
if (viewType == VK_IMAGE_VIEW_TYPE_1D || viewType == VK_IMAGE_VIEW_TYPE_2D)
{
- return tcu::IVec2(16, 16);
+ return tcu::UVec2(16u, 16u);
}
else
{
- return tcu::IVec2(16 * 3, 16 * 2);
+ return tcu::UVec2(16u * 3u, 16u * 2u);
}
}
0u, // VkSamplerCreateFlags flags;
VK_FILTER_NEAREST, // VkFilter magFilter;
VK_FILTER_NEAREST, // VkFilter minFilter;
- VK_SAMPLER_MIPMAP_MODE_BASE, // VkSamplerMipmapMode mipmapMode;
+ VK_SAMPLER_MIPMAP_MODE_NEAREST, // VkSamplerMipmapMode mipmapMode;
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeU;
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeV;
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // VkSamplerAddressMode addressModeW;
0.0f, // float mipLodBias;
+ VK_FALSE, // VkBool32 anisotropyEnable;
1.0f, // float maxAnisotropy;
false, // VkBool32 compareEnable;
VK_COMPARE_OP_NEVER, // VkCompareOp compareOp;
0.0f, // float minLod;
- (float)deLog2Floor32(m_imageSize) + 1, // float maxLod;
+ 0.25f, // float maxLod;
getFormatBorderColor(BORDER_COLOR_TRANSPARENT_BLACK, m_imageFormat), // VkBorderColor borderColor;
false // VkBool32 unnormalizedCoordinates;
};
{
}
-tcu::IVec2 SamplerAddressModesTest::getRenderSize (VkImageViewType viewType) const
+tcu::UVec2 SamplerAddressModesTest::getRenderSize (VkImageViewType viewType) const
{
- return 4 * SamplerTest::getRenderSize(viewType);
+ return 4u * SamplerTest::getRenderSize(viewType);
}
std::vector<Vertex4Tex4> SamplerAddressModesTest::createVertices (void) const
VkStencilOpState m_stencilOpStateFront;
VkStencilOpState m_stencilOpStateBack;
- const tcu::IVec2 m_renderSize;
+ const tcu::UVec2 m_renderSize;
const VkFormat m_colorFormat;
const VkFormat m_stencilFormat;
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- false, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const VkClearValue attachmentClearValues[2] =
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
const char* source_name,
const char* entry_name);
void enableTessellationStage (deUint32 patchControlPoints);
- Move<VkPipeline> buildPipeline (tcu::IVec2 renderSize,
+ Move<VkPipeline> buildPipeline (tcu::UVec2 renderSize,
VkRenderPass renderPass);
protected:
enum
m_shaderStageCount++;
}
-Move<VkPipeline> SimpleGraphicsPipelineBuilder::buildPipeline(tcu::IVec2 renderSize, VkRenderPass renderPass)
+Move<VkPipeline> SimpleGraphicsPipelineBuilder::buildPipeline(tcu::UVec2 renderSize, VkRenderPass renderPass)
{
const DeviceInterface& vk = m_context.getDeviceInterface();
const VkDevice vkDevice = m_context.getDevice();
{
VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
- 0u, // VkPipelineTesselationStateCreateFlags flags;
+ 0u, // VkPipelineTessellationStateCreateFlags flags;
m_patchControlPoints, // deUint32 patchControlPoints;
};
VkBufferUsageFlags usage,
de::MovePtr<Allocation>* pAlloc);
Move<VkImage> createImage2DAndBindMemory (VkFormat format,
- deInt32 width,
- deInt32 height,
+ deUint32 width,
+ deUint32 height,
VkBufferUsageFlags usage,
VkSampleCountFlagBits sampleCount,
de::MovePtr<Allocation>* pAlloc);
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- VK_FALSE, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u, // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
}
Move<VkImage> TimestampTestInstance::createImage2DAndBindMemory(VkFormat format,
- deInt32 width,
- deInt32 height,
- VkBufferUsageFlags usage,
- VkSampleCountFlagBits sampleCount,
-
de::details::MovePtr<Allocation>* pAlloc)
+ deUint32 width,
+ deUint32 height,
+ VkBufferUsageFlags usage,
+ VkSampleCountFlagBits sampleCount,
+ de::details::MovePtr<Allocation>* pAlloc)
{
const DeviceInterface& vk = m_context.getDeviceInterface();
const VkDevice vkDevice = m_context.getDevice();
virtual void buildVertexBuffer (void);
virtual void buildRenderPass (VkFormat colorFormat,
VkFormat depthFormat);
- virtual void buildFrameBuffer (tcu::IVec2 renderSize,
+ virtual void buildFrameBuffer (tcu::UVec2 renderSize,
VkFormat colorFormat,
VkFormat depthFormat);
protected:
- const tcu::IVec2 m_renderSize;
+ const tcu::UVec2 m_renderSize;
const VkFormat m_colorFormat;
const VkFormat m_depthFormat;
}
-void BasicGraphicsTestInstance::buildFrameBuffer(tcu::IVec2 renderSize, VkFormat colorFormat, VkFormat depthFormat)
+void BasicGraphicsTestInstance::buildFrameBuffer(tcu::UVec2 renderSize, VkFormat colorFormat, VkFormat depthFormat)
{
const DeviceInterface& vk = m_context.getDeviceInterface();
const VkDevice vkDevice = m_context.getDevice();
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- VK_FALSE, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u, // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const VkClearValue attachmentClearValues[2] =
VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
- deUint32 stage_count = (deUint32)m_stages.size();
-
- vk.cmdResetQueryPool(*m_cmdBuffer, *m_queryPool, 0u, stage_count);
+ vk.cmdResetQueryPool(*m_cmdBuffer, *m_queryPool, 0u, TimestampTest::ENTRY_COUNT);
vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- VK_FALSE, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u, // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const VkClearValue attachmentClearValues[2] =
VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
- deUint32 stage_count = (deUint32)m_stages.size();
-
- vk.cmdResetQueryPool(*m_cmdBuffer, *m_queryPool, 0u, stage_count);
+ vk.cmdResetQueryPool(*m_cmdBuffer, *m_queryPool, 0u, TimestampTest::ENTRY_COUNT);
vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
}
}
flushMappedMemoryRange(vk, vkDevice, bufferAlloc->getMemory(), bufferAlloc->getOffset(), size);
-
+
de::MovePtr<Allocation> dummyAlloc;
m_outputBuf = createBufferAndBindMemory(size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, &dummyAlloc);
-
+
std::vector<VkDescriptorBufferInfo> descriptorInfos;
descriptorInfos.push_back(makeDescriptorBufferInfo(*m_inputBuf, 0u, sizeof(tcu::Vec4) * 128u));
descriptorInfos.push_back(makeDescriptorBufferInfo(*m_outputBuf, 0u, sizeof(tcu::Vec4) * 128u));
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCmdBufferOptimizeFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- VK_FALSE, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u, // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
- vk.cmdResetQueryPool(*m_cmdBuffer, *m_queryPool, 0u, 1u);
+ vk.cmdResetQueryPool(*m_cmdBuffer, *m_queryPool, 0u, TimestampTest::ENTRY_COUNT);
vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *m_computePipelines);
vk.cmdBindDescriptorSets(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *m_pipelineLayout, 0u, 1u, &m_descriptorSet.get(), 0u, DE_NULL);
Move<VkBuffer> m_dstBuffer;
VkFormat m_imageFormat;
- deInt32 m_imageWidth;
- deInt32 m_imageHeight;
+ deUint32 m_imageWidth;
+ deUint32 m_imageHeight;
VkDeviceSize m_imageSize;
Move<VkImage> m_srcImage;
Move<VkImage> m_dstImage;
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCmdBufferOptimizeFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- VK_FALSE, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u, // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
VK_CHECK(vk.beginCommandBuffer(*m_cmdBuffer, &cmdBufferBeginInfo));
vk.cmdClearColorImage(*m_cmdBuffer, *m_dstImage, VK_IMAGE_LAYOUT_GENERAL, &dstClearValue, 1u, &subRange);
- vk.cmdResetQueryPool(*m_cmdBuffer, *m_queryPool, 0u, 1u);
+ vk.cmdResetQueryPool(*m_cmdBuffer, *m_queryPool, 0u, TimestampTest::ENTRY_COUNT);
// Copy Operations
const VkImageSubresourceLayers imgSubResCopy =
const VkOffset3D nullOffset = {0u, 0u, 0u};
const VkExtent3D imageExtent = {m_imageWidth, m_imageHeight, 1u};
+ const VkOffset3D imageOffset = {(int)m_imageWidth, (int)m_imageHeight, 1};
switch(m_method)
{
case TRANSFER_METHOD_COPY_BUFFER:
const VkImageBlit imageBlt =
{
imgSubResCopy, // VkImageSubresourceCopy srcSubresource;
- nullOffset, // VkOffset3D srcOffset;
- imageExtent, // VkExtent3D srcExtent;
+ {
+ nullOffset,
+ imageOffset,
+ },
imgSubResCopy, // VkImageSubresourceCopy destSubresource;
- nullOffset, // VkOffset3D destOffset;
- imageExtent, // VkExtent3D destExtent;
+ {
+ nullOffset,
+ imageOffset,
+ }
};
vk.cmdBlitImage(*m_cmdBuffer, *m_srcImage, VK_IMAGE_LAYOUT_GENERAL, *m_dstImage, VK_IMAGE_LAYOUT_GENERAL, 1u, &imageBlt, VK_FILTER_NEAREST);
break;
{
vk.cmdWriteTimestamp(*m_cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, *m_queryPool, 0u);
vk.cmdCopyQueryPoolResults(*m_cmdBuffer, *m_queryPool, 0u, 1u, *m_dstBuffer, 0u, 8u, VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT);
+ vk.cmdResetQueryPool(*m_cmdBuffer, *m_queryPool, 0u, 1u);
break;
}
case TRANSFER_METHOD_RESOLVE_IMAGE:
std::vector<VkBuffer> m_vertexBuffers;
std::vector<Allocation*> m_vertexBufferAllocs;
- const tcu::IVec2 m_renderSize;
+ const tcu::UVec2 m_renderSize;
const VkFormat m_colorFormat;
Move<VkImage> m_colorImage;
glslCode <<
" if (okCount == " << totalInputComponentCount << ")\n"
" {\n"
- " if (gl_InstanceID == 0)\n"
+ " if (gl_InstanceIndex == 0)\n"
" vtxColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
" else\n"
" vtxColor = vec4(0.0, 0.0, 1.0, 1.0);\n"
" {\n"
" vtxColor = vec4(okCount / float(" << totalInputComponentCount << "), 0.0f, 0.0f, 1.0);\n" <<
" }\n\n"
- " if (gl_InstanceID == 0)\n"
+ " if (gl_InstanceIndex == 0)\n"
" {\n"
- " if (gl_VertexID == 0) gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n"
- " else if (gl_VertexID == 1) gl_Position = vec4(0.0, -1.0, 0.0, 1.0);\n"
- " else if (gl_VertexID == 2) gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
- " else if (gl_VertexID == 3) gl_Position = vec4(0.0, 1.0, 0.0, 1.0);\n"
+ " if (gl_VertexIndex == 0) gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n"
+ " else if (gl_VertexIndex == 1) gl_Position = vec4(0.0, -1.0, 0.0, 1.0);\n"
+ " else if (gl_VertexIndex == 2) gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
+ " else if (gl_VertexIndex == 3) gl_Position = vec4(0.0, 1.0, 0.0, 1.0);\n"
" else gl_Position = vec4(0.0);\n"
" }\n"
" else\n"
" {\n"
- " if (gl_VertexID == 0) gl_Position = vec4(0.0, -1.0, 0.0, 1.0);\n"
- " else if (gl_VertexID == 1) gl_Position = vec4(1.0, -1.0, 0.0, 1.0);\n"
- " else if (gl_VertexID == 2) gl_Position = vec4(0.0, 1.0, 0.0, 1.0);\n"
- " else if (gl_VertexID == 3) gl_Position = vec4(1.0, 1.0, 0.0, 1.0);\n"
+ " if (gl_VertexIndex == 0) gl_Position = vec4(0.0, -1.0, 0.0, 1.0);\n"
+ " else if (gl_VertexIndex == 1) gl_Position = vec4(1.0, -1.0, 0.0, 1.0);\n"
+ " else if (gl_VertexIndex == 2) gl_Position = vec4(0.0, 1.0, 0.0, 1.0);\n"
+ " else if (gl_VertexIndex == 3) gl_Position = vec4(1.0, 1.0, 0.0, 1.0);\n"
" else gl_Position = vec4(0.0);\n"
" }\n";
{
std::ostringstream glslCode;
std::ostringstream attributeVar;
- const std::string indexId = (attributeInfo.inputRate == VK_VERTEX_INPUT_RATE_VERTEX) ? "gl_VertexID" : "gl_InstanceID";
+ const std::string indexId = (attributeInfo.inputRate == VK_VERTEX_INPUT_RATE_VERTEX) ? "gl_VertexIndex" : "gl_InstanceIndex";
const int componentCount = VertexInputTest::s_glslTypeDescriptions[attributeInfo.glslType].vertexInputComponentCount;
const int vertexInputCount = VertexInputTest::s_glslTypeDescriptions[attributeInfo.glslType].vertexInputCount;
const deUint32 totalComponentCount = componentCount * vertexInputCount;
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- false, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const VkClearValue attachmentClearValue = defaultClearValue(m_colorFormat);
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // deUint32 commandBufferCount;
&m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
sType = vk::VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
pNext = DE_NULL;
+ flags = 0u;
buffer = _buffer;
format = _format;
offset = _offset;
const vk::VkAttachmentReference* _resolveAttachments,
vk::VkAttachmentReference depthStencilAttachment,
deUint32 _preserveAttachmentCount,
- const vk::VkAttachmentReference* _preserveAttachments)
+ const deUint32* _preserveAttachments)
{
m_inputAttachments = std::vector<vk::VkAttachmentReference>(_inputAttachments, _inputAttachments + _inputAttachmentCount);
m_colorAttachments = std::vector<vk::VkAttachmentReference>(_colorAttachments, _colorAttachments + _colorAttachmentCount);
if (_resolveAttachments)
- {
m_resolveAttachments = std::vector<vk::VkAttachmentReference>(_resolveAttachments, _resolveAttachments + _colorAttachmentCount);
- }
- m_preserveAttachments = std::vector<vk::VkAttachmentReference>(_preserveAttachments, _preserveAttachments + _preserveAttachmentCount);
+ m_preserveAttachments = std::vector<deUint32>(_preserveAttachments, _preserveAttachments + _preserveAttachmentCount);
m_depthStencilAttachment = depthStencilAttachment;
- flags = _flags;
+ flags = _flags;
pipelineBindPoint = _pipelineBindPoint;
inputAttachmentCount = _inputAttachmentCount;
pInputAttachments = DE_NULL;
pPreserveAttachments = DE_NULL;
preserveAttachmentCount = _preserveAttachmentCount;
- if (m_inputAttachments.size())
- {
+ if (!m_inputAttachments.empty())
pInputAttachments = &m_inputAttachments[0];
- }
- if (m_colorAttachments.size())
- {
+ if (!m_colorAttachments.empty())
pColorAttachments = &m_colorAttachments[0];
- }
- if (m_resolveAttachments.size())
- {
+ if (!m_resolveAttachments.empty())
pResolveAttachments = &m_resolveAttachments[0];
- }
- if (m_preserveAttachments.size())
- {
+ if (!m_preserveAttachments.empty())
pPreserveAttachments = &m_preserveAttachments[0];
- }
}
SubpassDescription::SubpassDescription (const vk::VkSubpassDescription& rhs)
rhs.pColorAttachments, rhs.pColorAttachments + rhs.colorAttachmentCount);
if (rhs.pResolveAttachments)
- {
m_resolveAttachments = std::vector<vk::VkAttachmentReference>(
rhs.pResolveAttachments, rhs.pResolveAttachments + rhs.colorAttachmentCount);
- }
- m_preserveAttachments = std::vector<vk::VkAttachmentReference>(
+
+ m_preserveAttachments = std::vector<deUint32>(
rhs.pPreserveAttachments, rhs.pPreserveAttachments + rhs.preserveAttachmentCount);
if (rhs.pDepthStencilAttachment)
- {
m_depthStencilAttachment = *rhs.pDepthStencilAttachment;
- }
- if (m_inputAttachments.size())
- {
+ if (!m_inputAttachments.empty())
pInputAttachments = &m_inputAttachments[0];
- }
- if (m_colorAttachments.size())
- {
+
+ if (!m_colorAttachments.empty())
pColorAttachments = &m_colorAttachments[0];
- }
- if (m_resolveAttachments.size())
- {
+ if (!m_resolveAttachments.empty())
pResolveAttachments = &m_resolveAttachments[0];
- }
pDepthStencilAttachment = &m_depthStencilAttachment;
- if (m_preserveAttachments.size())
- {
+ if (!m_preserveAttachments.empty())
pPreserveAttachments = &m_preserveAttachments[0];
- }
}
-SubpassDescription::SubpassDescription (const SubpassDescription& rhs)
-{
+SubpassDescription::SubpassDescription (const SubpassDescription& rhs) {
*this = rhs;
}
m_preserveAttachments = rhs.m_preserveAttachments;
m_depthStencilAttachment = rhs.m_depthStencilAttachment;
- if (m_inputAttachments.size())
- {
+ if (!m_inputAttachments.empty())
pInputAttachments = &m_inputAttachments[0];
- }
- if (m_colorAttachments.size())
- {
+
+ if (!m_colorAttachments.empty())
pColorAttachments = &m_colorAttachments[0];
- }
- if (m_resolveAttachments.size())
- {
+ if (!m_resolveAttachments.empty())
pResolveAttachments = &m_resolveAttachments[0];
- }
pDepthStencilAttachment = &m_depthStencilAttachment;
- if (m_preserveAttachments.size())
- {
+ if (!m_preserveAttachments.empty())
pPreserveAttachments = &m_preserveAttachments[0];
- }
return *this;
}
CmdBufferBeginInfo::CmdBufferBeginInfo (vk::VkCommandBufferUsageFlags _flags)
{
- sType = vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
- pNext = DE_NULL;
- renderPass = DE_NULL;
- subpass = 0;
- framebuffer = DE_NULL;
- flags = _flags;
- occlusionQueryEnable = false;
- queryFlags = 0u;
- pipelineStatistics = 0u;
-}
-
-CmdBufferBeginInfo::CmdBufferBeginInfo (vk::VkRenderPass _renderPass,
- deUint32 _subpass,
- vk::VkFramebuffer _framebuffer,
- vk::VkCommandBufferUsageFlags _flags,
- bool _occlusionQueryEnable,\r
- vk::VkQueryControlFlags _queryFlags,\r
- vk::VkQueryPipelineStatisticFlags _pipelineStatistics)
-{
-
- sType = vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
- pNext = DE_NULL;
- renderPass = _renderPass;
- subpass = _subpass;
- framebuffer = _framebuffer;
- flags = _flags;
- occlusionQueryEnable = _occlusionQueryEnable;
- queryFlags = _queryFlags;
- pipelineStatistics = _pipelineStatistics;
+ sType = vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+ pNext = DE_NULL;
+ flags = _flags;
+ pInheritanceInfo = DE_NULL;
}
DescriptorPoolCreateInfo::DescriptorPoolCreateInfo (const std::vector<vk::VkDescriptorPoolSize>& poolSizeCounts,
pNext = DE_NULL;
flags = 0;
bindingCount = _bindingCount;
- pBinding = _pBindings;
+ pBindings = _pBindings;
}
PipelineLayoutCreateInfo::PipelineLayoutCreateInfo (deUint32 _descriptorSetCount,
sType = vk::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pNext = DE_NULL;
+
+ flags = 0u;
setLayoutCount = static_cast<deUint32>(m_setLayouts.size());
pSetLayouts = setLayoutCount > 0 ? &m_setLayouts[0] : DE_NULL;
pushConstantRangeCount = static_cast<deUint32>(m_pushConstantRanges.size());
sType = vk::VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pNext = DE_NULL;
- setLayoutCount = static_cast<deUint32>(m_setLayouts.size());
+ flags = 0u;
+ setLayoutCount = static_cast<deUint32>(m_setLayouts.size());
if (setLayoutCount)
{
primitiveRestartEnable = _primitiveRestartEnable;
}
-PipelineCreateInfo::TesselationState::TesselationState (deUint32 _patchControlPoints)
+PipelineCreateInfo::TessellationState::TessellationState (deUint32 _patchControlPoints)
{
sType = vk::VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
pNext = DE_NULL;
- patchControlPoints = _patchControlPoints;
+ flags = 0u;
+ patchControlPoints = _patchControlPoints;
}
PipelineCreateInfo::ViewportState::ViewportState (deUint32 _viewportCount,
{
sType = other.sType;
pNext = other.pNext;
+ flags = other.flags;
viewportCount = other.viewportCount;
scissorCount = other.scissorCount;
{
sType = other.sType;
pNext = other.pNext;
+ flags = other.flags;
viewportCount = other.viewportCount;
scissorCount = other.scissorCount;
{
sType = other.sType;
pNext = other.pNext;
+ flags = other.flags;
rasterizationSamples = other.rasterizationSamples;
sampleShadingEnable = other.sampleShadingEnable;
minSampleShading = other.minSampleShading;
{
sType = other.sType;
pNext = other.pNext;
+ flags = other.flags;
rasterizationSamples = other.rasterizationSamples;
sampleShadingEnable = other.sampleShadingEnable;
minSampleShading = other.minSampleShading;
{
sType = vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
pNext = DE_NULL;
+ flags = 0u;
logicOpEnable = _logicOpEnable;
logicOp = _logicOp;
attachmentCount = static_cast<deUint32>(m_attachments.size());
{
sType = createInfo.sType;
pNext = createInfo.pNext;
+ flags = createInfo.flags;
logicOpEnable = createInfo.logicOpEnable;
logicOp = createInfo.logicOp;
attachmentCount = static_cast<deUint32>(m_attachments.size());
{
sType = createInfo.sType;
pNext = createInfo.pNext;
+ flags = createInfo.flags;
logicOpEnable = createInfo.logicOpEnable;
logicOp = createInfo.logicOp;
attachmentCount = static_cast<deUint32>(m_attachments.size());
{
sType = vk::VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
pNext = DE_NULL;
+ flags = 0u;
if (!_dynamicStates.size())
{
{
sType = other.sType;
pNext = other.pNext;
+ flags = other.flags;
dynamicStateCount = other.dynamicStateCount;
{
sType = other.sType;
pNext = other.pNext;
+ flags = other.flags;
dynamicStateCount = other.dynamicStateCount;
vk::VkSamplerAddressMode _addressModeV,
vk::VkSamplerAddressMode _addressModeW,
float _mipLodBias,
+ vk::VkBool32 _anisotropyEnable,
float _maxAnisotropy,
vk::VkBool32 _compareEnable,
vk::VkCompareOp _compareOp,
addressModeV = _addressModeV;
addressModeW = _addressModeW;
mipLodBias = _mipLodBias;
+ anisotropyEnable = _anisotropyEnable;
maxAnisotropy = _maxAnisotropy;
compareEnable = _compareEnable;
compareOp = _compareOp;
const vk::VkAttachmentReference* resolveAttachments,
vk::VkAttachmentReference depthStencilAttachment,
deUint32 preserveAttachmentCount,
- const vk::VkAttachmentReference* preserveAttachments);
+ const deUint32* preserveAttachments);
SubpassDescription (const vk::VkSubpassDescription& other);
SubpassDescription (const SubpassDescription& other);
std::vector<vk::VkAttachmentReference> m_inputAttachments;
std::vector<vk::VkAttachmentReference> m_colorAttachments;
std::vector<vk::VkAttachmentReference> m_resolveAttachments;
- std::vector<vk::VkAttachmentReference> m_preserveAttachments;
+ std::vector<deUint32> m_preserveAttachments;
vk::VkAttachmentReference m_depthStencilAttachment;
};
{
public:
CmdBufferBeginInfo (vk::VkCommandBufferUsageFlags flags = 0);
- CmdBufferBeginInfo (vk::VkRenderPass renderPass,
- deUint32 subpass,
- vk::VkFramebuffer framebuffer,
- vk::VkCommandBufferUsageFlags flags = 0,
- bool occlusionQueryEnable = false,
- vk::VkQueryControlFlags queryFlags = 0u,
- vk::VkQueryPipelineStatisticFlags pipelineStatistics = 0u);
};
class DescriptorPoolSize : public vk::VkDescriptorPoolSize
InputAssemblerState (vk::VkPrimitiveTopology topology, vk::VkBool32 primitiveRestartEnable = false);
};
- class TesselationState : public vk::VkPipelineTessellationStateCreateInfo
+ class TessellationState : public vk::VkPipelineTessellationStateCreateInfo
{
public:
- TesselationState (deUint32 patchControlPoints = 0);
+ TessellationState (deUint32 patchControlPoints = 0);
};
class ViewportState : public vk::VkPipelineViewportStateCreateInfo
vk::VkSamplerAddressMode addressV = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
vk::VkSamplerAddressMode addressW = vk::VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
float mipLodBias = 0.0f,
+ vk::VkBool32 anisotropyEnable = vk::VK_FALSE,
float maxAnisotropy = 1.0f,
vk::VkBool32 compareEnable = false,
vk::VkCompareOp compareOp = vk::VK_COMPARE_OP_ALWAYS,
barrier.subresourceRange.baseArrayLayer = 0;
barrier.subresourceRange.layerCount = m_layerCount;
- void* barriers[] = { &barrier };
-
- m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
- false, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &barrier);
}
const vk::VkBufferImageCopy region =
0, 0, 0,
{ aspect, mipLevel, arrayElement, 1 },
offset,
- { width, height, depth }
+ { (deUint32)width, (deUint32)height, (deUint32)depth }
};
m_vk.cmdCopyImageToBuffer(*copyCmdBuffer, object(), layout, stagingResource->object(), 1, ®ion);
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
{
de::SharedPtr<Image> stagingResource;
{
- vk::VkExtent3D stagingExtent = {width, height, depth};
+ vk::VkExtent3D stagingExtent = {(deUint32)width, (deUint32)height, (deUint32)depth};
ImageCreateInfo stagingResourceCreateInfo(type, m_format, stagingExtent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT,
vk::VK_IMAGE_TILING_LINEAR, vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT);
transition2DImage(m_vk, *copyCmdBuffer, stagingResource->object(), aspect, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_GENERAL);
const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
- vk::VkImageCopy region = { {aspect, mipLevel, arrayElement, 1}, offset, {aspect, 0, 0, 1}, zeroOffset, {width, height, depth} };
+ vk::VkImageCopy region = { {aspect, mipLevel, arrayElement, 1}, offset, {aspect, 0, 0, 1}, zeroOffset, {(deUint32)width, (deUint32)height, (deUint32)depth} };
m_vk.cmdCopyImage(*copyCmdBuffer, object(), layout, stagingResource->object(), vk::VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
VK_CHECK(m_vk.endCommandBuffer(*copyCmdBuffer));
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
DE_ASSERT(layout == vk::VK_IMAGE_LAYOUT_GENERAL || layout == vk::VK_IMAGE_LAYOUT_UNDEFINED || layout == vk::VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
de::SharedPtr<Image> stagingResource;
- vk::VkExtent3D extent = {width, height, depth};
+ vk::VkExtent3D extent = {(deUint32)width, (deUint32)height, (deUint32)depth};
ImageCreateInfo stagingResourceCreateInfo(
type, m_format, extent, 1, 1, vk::VK_SAMPLE_COUNT_1_BIT,
vk::VK_IMAGE_TILING_LINEAR, vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
barrier.subresourceRange.baseArrayLayer = 0;
barrier.subresourceRange.layerCount = m_layerCount;
- void* barriers[] = { &barrier };
-
- m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &barrier);
}
transition2DImage(m_vk, *copyCmdBuffer, stagingResource->object(), aspect, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_GENERAL);
zeroOffset,
{aspect, mipLevel, arrayElement, 1},
offset,
- {width, height, depth}};
+ {(deUint32)width, (deUint32)height, (deUint32)depth}};
m_vk.cmdCopyImage(*copyCmdBuffer, stagingResource->object(),
vk::VK_IMAGE_LAYOUT_GENERAL, object(), layout, 1, ®ion);
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
barrier.subresourceRange.baseArrayLayer = 0;
barrier.subresourceRange.layerCount = m_layerCount;
- void* barriers[] = { &barrier };
-
- m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ m_vk.cmdPipelineBarrier(*copyCmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &barrier);
}
vk::VkBufferImageCopy region =
0, 0, 0,
{ aspect, mipLevel, arrayElement, 1 },
offset,
- { width, height, depth }
+ { (deUint32)width, (deUint32)height, (deUint32)depth }
};
m_vk.cmdCopyBufferToImage(*copyCmdBuffer, stagingResource->object(),
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
barrier.subresourceRange.baseArrayLayer = 0;
barrier.subresourceRange.layerCount = 1;
- void* barriers[] = { &barrier };
-
- vk.cmdPipelineBarrier(cmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(cmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &barrier);
}
void initialTransitionColor2DImage (const vk::DeviceInterface &vk, vk::VkCommandBuffer cmdBuffer, vk::VkImage image, vk::VkImageLayout layout)
1u, // deUint32 bufferCount;
};
vk::Unique<vk::VkCommandBuffer> cmdBuffer (vk::allocateCommandBuffer(vk, device, &cmdBufferAllocateInfo));
- const CmdBufferBeginInfo beginInfo (DE_NULL, 0, DE_NULL, 0u, true, m_testVector.queryControlFlags);
+ const CmdBufferBeginInfo beginInfo (0u);
vk.beginCommandBuffer(*cmdBuffer, &beginInfo);
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_renderCommandBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
DE_NULL, // const void* pNext;
0, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1, // deUint32 commandBufferCount;
&m_copyResultsCommandBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0, // deUint32 signalSemaphoreCount;
1u, // deUint32 bufferCount;
};
vk::Move<vk::VkCommandBuffer> cmdBuffer (vk::allocateCommandBuffer(vk, device, &cmdBufferAllocateInfo));
- CmdBufferBeginInfo beginInfo (DE_NULL, 0, DE_NULL, 0u, true, m_testVector.queryControlFlags);
+ CmdBufferBeginInfo beginInfo (0u);
vk.beginCommandBuffer(*cmdBuffer, &beginInfo);
1u, // deUint32 bufferCount;
};
vk::Move<vk::VkCommandBuffer> cmdBuffer (vk::allocateCommandBuffer(vk, device, &cmdBufferAllocateInfo));
- const CmdBufferBeginInfo beginInfo (DE_NULL, 0, DE_NULL, 0u, true, m_testVector.queryControlFlags);
+ const CmdBufferBeginInfo beginInfo (0u);
vk.beginCommandBuffer(*cmdBuffer, &beginInfo);
vk.cmdCopyQueryPoolResults(*cmdBuffer, m_queryPool, 0, NUM_QUERIES_IN_POOL, m_queryPoolResultsBuffer->object(), /*dstOffset*/ 0, m_testVector.queryResultsStride, m_queryResultFlags);
vktShaderExecutor.hpp
vktShaderBuiltinTests.cpp
vktShaderBuiltinTests.hpp
- vktShaderBuiltinConstantTests.cpp
- vktShaderBuiltinConstantTests.hpp
vktShaderCommonFunctionTests.cpp
vktShaderCommonFunctionTests.hpp
vktShaderIntegerFunctionTests.cpp
std::vector<deUint32> outValues (numInvocations*numOps);
deUint32 bindingLocation = getFirstFreeBindingLocation(m_shaderType);
+
+ const deUint32 atomicCounterLocation = bindingLocation++;
+
{
DE_ASSERT(numCounters <= 4);
// Add the atomic counters' base value, all zero.
- m_uniformSetup->addData(new UniformData<tcu::Mat4>(bindingLocation++, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, tcu::Mat4(0.0)));
+ m_uniformSetup->addData(new UniformData<tcu::Mat4>(atomicCounterLocation, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, tcu::Mat4(0.0)));
if (m_indexExprType == INDEX_EXPR_TYPE_DYNAMIC_UNIFORM)
{
for (int opNdx = 0; opNdx < numOps; opNdx++)
numHits[m_opIndices[opNdx]] += 1;
+ // Read counter values
+ {
+ const void* mapPtr = m_executor.getBufferPtr(atomicCounterLocation);
+ DE_ASSERT(mapPtr != DE_NULL);
+ std::copy((const deUint32*)mapPtr, (const deUint32*)mapPtr + numCounters, &counterValues[0]);
+ }
+
// Verify counter values
for (int counterNdx = 0; counterNdx < numCounters; counterNdx++)
{
+++ /dev/null
-/*------------------------------------------------------------------------
- * Vulkan Conformance Tests
- * ------------------------
- *
- * Copyright (c) 2015 The Khronos Group Inc.
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and/or associated documentation files (the
- * "Materials"), to deal in the Materials without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Materials, and to
- * permit persons to whom the Materials are furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice(s) and this permission notice shall be included
- * in all copies or substantial portions of the Materials.
- *
- * The Materials are Confidential Information as defined by the
- * Khronos Membership Agreement until designated non-confidential by Khronos,
- * at which point this condition clause shall be removed.
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
- *
- *//*!
- * \file
- * \brief Shader built-in constant tests.
- *//*--------------------------------------------------------------------*/
-
-#include "vktShaderBuiltinConstantTests.hpp"
-#include "vktShaderExecutor.hpp"
-#include "deUniquePtr.hpp"
-#include "deStringUtil.hpp"
-#include "tcuTestLog.hpp"
-
-using std::string;
-using std::vector;
-using tcu::TestLog;
-using namespace vk;
-
-namespace vkt
-{
-namespace shaderexecutor
-{
-
-namespace
-{
-
-static deUint32 getUint32 (deUint32 VkPhysicalDeviceLimits::* ptr, Context &ctx)
-{
- VkPhysicalDeviceProperties properties;
- ctx.getInstanceInterface().getPhysicalDeviceProperties(ctx.getPhysicalDevice(), &properties);
- return properties.limits.*ptr;
-}
-
-template<deUint32 VkPhysicalDeviceLimits::* ptr>
-static deUint32 getUint32 (Context &ctx)
-{
- return getUint32(ptr, ctx);
-}
-
-#define GET_UINT32(name) getUint32<&VkPhysicalDeviceLimits::name>
-
-static deInt32 getInt32 (deInt32 VkPhysicalDeviceLimits::* ptr, Context &ctx)
-{
- VkPhysicalDeviceProperties properties;
- ctx.getInstanceInterface().getPhysicalDeviceProperties(ctx.getPhysicalDevice(), &properties);
- return properties.limits.*ptr;
-}
-
-template<deInt32 VkPhysicalDeviceLimits::* ptr>
-static deInt32 getInt32 (Context &ctx)
-{
- return getInt32(ptr, ctx);
-}
-
-#define GET_INT32(name) getInt32<&VkPhysicalDeviceLimits::name>
-
-static tcu::UVec3 getUVec3 (deUint32 (VkPhysicalDeviceLimits::*ptr)[3], Context &ctx)
-{
- VkPhysicalDeviceProperties properties;
- ctx.getInstanceInterface().getPhysicalDeviceProperties(ctx.getPhysicalDevice(), &properties);
- return tcu::UVec3((properties.limits.*ptr)[0], (properties.limits.*ptr)[1], (properties.limits.*ptr)[2]);
-}
-
-template<deUint32 (VkPhysicalDeviceLimits::*ptr)[3]>
-static tcu::UVec3 getUVec3 (Context &ctx)
-{
- return getUVec3(ptr, ctx);
-}
-
-#define GET_UVEC3(name) getUVec3<&VkPhysicalDeviceLimits::name>
-
-static std::string makeCaseName (const std::string& varName, glu::ShaderType shaderType)
-{
- DE_ASSERT(varName.length() > 3);
- DE_ASSERT(varName.substr(0,3) == "gl_");
-
- std::ostringstream name;
- name << de::toLower(char(varName[3]));
-
- for (size_t ndx = 4; ndx < varName.length(); ndx++)
- {
- const char c = char(varName[ndx]);
- if (de::isUpper(c))
- name << '_' << de::toLower(c);
- else
- name << c;
- }
- name << '_' << glu::getShaderTypeName(glu::ShaderType(shaderType));
- return name.str();
-}
-
-enum
-{
- VS = (1<<glu::SHADERTYPE_VERTEX),
- TC = (1<<glu::SHADERTYPE_TESSELLATION_CONTROL),
- TE = (1<<glu::SHADERTYPE_TESSELLATION_EVALUATION),
- GS = (1<<glu::SHADERTYPE_GEOMETRY),
- FS = (1<<glu::SHADERTYPE_FRAGMENT),
- CS = (1<<glu::SHADERTYPE_COMPUTE),
-
- SHADER_TYPES = VS|TC|TE|GS|FS|CS
-};
-
-template<typename DataType>
-class ShaderBuiltinConstantTestInstance;
-
-template<typename DataType>
-class ShaderBuiltinConstantCase : public TestCase
-{
-public:
- typedef DataType (*GetConstantValueFunc) (Context &);
-
- ShaderBuiltinConstantCase (tcu::TestContext& testCtx, const char* varName, glu::ShaderType shaderType, GetConstantValueFunc getValue, const char* requiredExt);
- virtual ~ShaderBuiltinConstantCase (void) {};
-
- virtual void initPrograms (vk::SourceCollections& programCollection) const
- {
- m_executor->setShaderSources(programCollection);
- }
-
- virtual TestInstance* createInstance (Context& context) const { return new ShaderBuiltinConstantTestInstance<DataType>(context, m_getValue, *m_executor, m_varName); };
-
-private:
- const std::string m_varName;
- const GetConstantValueFunc m_getValue;
- const std::string m_requiredExt;
- ShaderExecutor* m_executor;
- glu::ShaderType m_shaderType;
- ShaderSpec m_spec;
-};
-
-template<typename T>
-struct GLConstantTypeForVKType {};
-
-template<>
-struct GLConstantTypeForVKType<tcu::UVec3>
-{
- typedef tcu::IVec3 GLConstantType;
-};
-
-template<>
-struct GLConstantTypeForVKType<deUint32>
-{
- typedef deInt32 GLConstantType;
-};
-
-template<>
-struct GLConstantTypeForVKType<deInt32>
-{
- typedef deInt32 GLConstantType;
-};
-
-template<typename DataType>
-ShaderBuiltinConstantCase<DataType>::ShaderBuiltinConstantCase (tcu::TestContext& testCtx, const char* varName, glu::ShaderType shaderType, GetConstantValueFunc getValue, const char* requiredExt)
- : TestCase (testCtx, makeCaseName(varName, shaderType).c_str(), varName)
- , m_varName (varName)
- , m_getValue (getValue)
- , m_requiredExt (requiredExt ? requiredExt : "")
- , m_shaderType (shaderType)
-{
- DE_ASSERT(!requiredExt == m_requiredExt.empty());
-
- ShaderSpec shaderSpec;
- shaderSpec.source = string("result = ") + m_varName + ";\n";
- shaderSpec.outputs.push_back(Symbol("result", glu::VarType(glu::dataTypeOf<typename GLConstantTypeForVKType<DataType>::GLConstantType>(), glu::PRECISION_HIGHP)));
-
- if (!m_requiredExt.empty())
- shaderSpec.globalDeclarations = "#extension " + m_requiredExt + " : require\n";
-
- m_executor = createExecutor(shaderType, shaderSpec);
-}
-
-template<typename DataType>
-static void logVarValue (tcu::TestLog& log, const std::string& varName, DataType value)
-{
- log << TestLog::Message << varName << " = " << value << TestLog::EndMessage;
-}
-
-template<>
-void logVarValue<int> (tcu::TestLog& log, const std::string& varName, int value)
-{
- log << TestLog::Integer(varName, varName, "", QP_KEY_TAG_NONE, value);
-}
-
-// ShaderBuiltinConstantTestInstance
-
-template<typename DataType>
-class ShaderBuiltinConstantTestInstance : public TestInstance
-{
-public:
- ShaderBuiltinConstantTestInstance (Context& ctx, typename ShaderBuiltinConstantCase<DataType>::GetConstantValueFunc getValue, ShaderExecutor& executor, const std::string varName )
- : TestInstance (ctx)
- , m_getValue (getValue)
- , m_testCtx (ctx.getTestContext())
- , m_executor (executor)
- , m_varName (varName)
- {}
- virtual tcu::TestStatus iterate (void);
-
-private:
- const typename ShaderBuiltinConstantCase<DataType>::GetConstantValueFunc m_getValue;
- tcu::TestContext& m_testCtx;
- ShaderExecutor& m_executor;
- const std::string m_varName;
-
- typedef typename GLConstantTypeForVKType<DataType>::GLConstantType GLConstantType;
- GLConstantType getReference (void);
-};
-
-template<typename DataType>
-typename ShaderBuiltinConstantTestInstance<DataType>::GLConstantType ShaderBuiltinConstantTestInstance<DataType>::getReference (void)
-{
- return m_getValue(m_context);
-}
-
-template<>
-typename ShaderBuiltinConstantTestInstance<tcu::UVec3>::GLConstantType ShaderBuiltinConstantTestInstance<tcu::UVec3>::getReference (void)
-{
- return m_getValue(m_context).asInt();
-}
-
-template<typename DataType>
-tcu::TestStatus ShaderBuiltinConstantTestInstance<DataType>::iterate (void)
-{
- GLConstantType reference = getReference();
- GLConstantType result = GLConstantType(-1);
- void* const outputs = &result;
-
- m_executor.execute(m_context, 1, DE_NULL, &outputs);
- logVarValue(m_testCtx.getLog(), m_varName, result);
-
- if (result != reference)
- {
- m_testCtx.getLog() << TestLog::Message << "ERROR: Expected " << m_varName << " = " << reference << TestLog::EndMessage;
- return tcu::TestStatus::fail("Invalid builtin constant value");
- }
- else
- return tcu::TestStatus::pass("Pass");
-}
-
-// createShaderBuiltinConstantCase
-
-template<typename DataType>
-void createShaderBuiltinConstantCase(tcu::TestCaseGroup* group, tcu::TestContext& testCtx, const char* varName, typename ShaderBuiltinConstantCase<DataType>::GetConstantValueFunc getValue, const char* requiredExt)
-{
- for (int shaderType = 0; shaderType < glu::SHADERTYPE_LAST; shaderType++)
- {
- if ((SHADER_TYPES & (1<<shaderType)) != 0)
- group->addChild(new ShaderBuiltinConstantCase<DataType>(testCtx, varName, static_cast<glu::ShaderType>(shaderType), getValue, requiredExt));
- }
-}
-
-} // anonymous
-
-ShaderBuiltinConstantTests::ShaderBuiltinConstantTests (tcu::TestContext& testCtx)
- : TestCaseGroup(testCtx, "constant", "Built-in Constant Tests")
-{
-}
-
-ShaderBuiltinConstantTests::~ShaderBuiltinConstantTests (void)
-{
-}
-
-void ShaderBuiltinConstantTests::init (void)
-{
- // Core builtin constants
- {
- static const struct
- {
- const char* varName;
- ShaderBuiltinConstantCase<deUint32>::GetConstantValueFunc getValue;
- } uintConstants[] =
- {
- { "gl_MaxVertexAttribs", GET_UINT32(maxVertexInputAttributes) },
- { "gl_MaxVertexOutputVectors", GET_UINT32(maxVertexOutputComponents) },
- { "gl_MaxFragmentInputVectors", GET_UINT32(maxFragmentInputComponents) },
- { "gl_MaxDrawBuffers", GET_UINT32(maxColorAttachments) },
- { "gl_MaxProgramTexelOffset", GET_UINT32(maxTexelOffset) },
- };
-
- static const struct
- {
- const char* varName;
- ShaderBuiltinConstantCase<tcu::UVec3>::GetConstantValueFunc getValue;
- } uvec3Constants[] =
- {
- { "gl_MaxComputeWorkGroupCount", GET_UVEC3(maxComputeWorkGroupCount) },
- { "gl_MaxComputeWorkGroupSize", GET_UVEC3(maxComputeWorkGroupSize) },
- };
-
- tcu::TestCaseGroup* const coreGroup = new tcu::TestCaseGroup(m_testCtx, "core", "Core Specification");
- addChild(coreGroup);
-
- for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(uintConstants); ndx++)
- createShaderBuiltinConstantCase<deUint32>(coreGroup, m_testCtx, uintConstants[ndx].varName, uintConstants[ndx].getValue, DE_NULL);
-
- createShaderBuiltinConstantCase<deInt32>(coreGroup, m_testCtx, "gl_MinProgramTexelOffset", GET_INT32(minTexelOffset), DE_NULL);
-
- for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(uvec3Constants); ndx++)
- createShaderBuiltinConstantCase<tcu::UVec3>(coreGroup, m_testCtx, uvec3Constants[ndx].varName, uvec3Constants[ndx].getValue, DE_NULL);
- }
-
- // EXT_geometry_shader
- {
- static const struct
- {
- const char* varName;
- ShaderBuiltinConstantCase<deUint32>::GetConstantValueFunc getValue;
- } uintConstants[] =
- {
- { "gl_MaxGeometryInputComponents", GET_UINT32(maxGeometryInputComponents) },
- { "gl_MaxGeometryOutputComponents", GET_UINT32(maxGeometryOutputComponents) },
- { "gl_MaxGeometryOutputVertices", GET_UINT32(maxGeometryOutputVertices) },
- { "gl_MaxGeometryTotalOutputComponents", GET_UINT32(maxGeometryTotalOutputComponents) },
- };
-
- tcu::TestCaseGroup* const geomGroup = new tcu::TestCaseGroup(m_testCtx, "geometry_shader", "GL_EXT_geometry_shader");
- addChild(geomGroup);
-
- for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(uintConstants); ndx++)
- createShaderBuiltinConstantCase<deUint32>(geomGroup, m_testCtx, uintConstants[ndx].varName, uintConstants[ndx].getValue, "GL_EXT_geometry_shader");
- }
-
- // EXT_tessellation_shader
- {
- static const struct
- {
- const char* varName;
- ShaderBuiltinConstantCase<deUint32>::GetConstantValueFunc getValue;
- } uintConstants[] =
- {
- { "gl_MaxTessControlInputComponents", GET_UINT32(maxTessellationControlPerVertexInputComponents) },
- { "gl_MaxTessControlOutputComponents", GET_UINT32(maxTessellationControlPerVertexOutputComponents) },
- { "gl_MaxTessControlTotalOutputComponents", GET_UINT32(maxTessellationControlTotalOutputComponents) },
-
- { "gl_MaxTessEvaluationInputComponents", GET_UINT32(maxTessellationEvaluationInputComponents) },
- { "gl_MaxTessEvaluationOutputComponents", GET_UINT32(maxTessellationEvaluationOutputComponents) },
-
- { "gl_MaxTessPatchComponents", GET_UINT32(maxTessellationControlPerPatchOutputComponents) },
-
- { "gl_MaxPatchVertices", GET_UINT32(maxTessellationPatchSize) },
- { "gl_MaxTessGenLevel", GET_UINT32(maxTessellationGenerationLevel) },
- };
-
- tcu::TestCaseGroup* const tessGroup = new tcu::TestCaseGroup(m_testCtx, "tessellation_shader", "GL_EXT_tessellation_shader");
- addChild(tessGroup);
-
- for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(uintConstants); ndx++)
- createShaderBuiltinConstantCase<deUint32>(tessGroup, m_testCtx, uintConstants[ndx].varName, uintConstants[ndx].getValue, "GL_EXT_tessellation_shader");
- }
-}
-
-} // shaderexecutor
-} // vkt
+++ /dev/null
-#ifndef _VKTSHADERBUILTINCONSTANTTESTS_HPP
-#define _VKTSHADERBUILTINCONSTANTTESTS_HPP
-/*------------------------------------------------------------------------
- * Vulkan Conformance Tests
- * ------------------------
- *
- * Copyright (c) 2015 The Khronos Group Inc.
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and/or associated documentation files (the
- * "Materials"), to deal in the Materials without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Materials, and to
- * permit persons to whom the Materials are furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice(s) and this permission notice shall be included
- * in all copies or substantial portions of the Materials.
- *
- * The Materials are Confidential Information as defined by the
- * Khronos Membership Agreement until designated non-confidential by Khronos,
- * at which point this condition clause shall be removed.
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
- *
- *//*!
- * \file
- * \brief Shader built-in constant tests.
- *//*--------------------------------------------------------------------*/
-
-#include "tcuTestCase.hpp"
-
-namespace vkt
-{
-namespace shaderexecutor
-{
-
-class ShaderBuiltinConstantTests : public tcu::TestCaseGroup
-{
-public:
- ShaderBuiltinConstantTests (tcu::TestContext& testCtx);
- virtual ~ShaderBuiltinConstantTests (void);
-
- virtual void init (void);
-
-private:
- ShaderBuiltinConstantTests (const ShaderBuiltinConstantTests&);
- ShaderBuiltinConstantTests& operator= (const ShaderBuiltinConstantTests&);
-};
-
-} // shaderexecutor
-} // vkt
-
-#endif // _VKTSHADERBUILTINCONSTANTTESTS_HPP
#include "deUniquePtr.hpp"
#include "vktShaderBuiltinPrecisionTests.hpp"
-#include "vktShaderBuiltinConstantTests.hpp"
#include "vktShaderCommonFunctionTests.hpp"
#include "vktShaderIntegerFunctionTests.hpp"
#include "vktShaderPackingFunctionTests.hpp"
builtinFunctionTests->addChild(new ShaderPackingFunctionTests(testCtx));
builtinTests->addChild(builtinFunctionTests.release());
- builtinTests->addChild(new ShaderBuiltinConstantTests(testCtx));
builtinTests->addChild(new BuiltinPrecisionTests(testCtx));
return builtinTests.release();
const deUint32 queueFamilyIndex = ctx.getUniversalQueueFamilyIndex();
Allocator& memAlloc = ctx.getDefaultAllocator();
- const deInt32 renderSizeX = de::min(static_cast<int>(DEFAULT_RENDER_WIDTH), numValues);
- const deInt32 renderSizeY = (numValues / renderSizeX) + ((numValues % renderSizeX != 0) ? 1 : 0);
- const tcu::IVec2 renderSize (renderSizeX, renderSizeY);
+ const deUint32 renderSizeX = de::min(static_cast<deUint32>(DEFAULT_RENDER_WIDTH), (deUint32)numValues);
+ const deUint32 renderSizeY = ((deUint32)numValues / renderSizeX) + (((deUint32)numValues % renderSizeX != 0) ? 1u : 0u);
+ const tcu::UVec2 renderSize (renderSizeX, renderSizeY);
std::vector<tcu::Vec2> positions;
VkFormat colorFormat = VK_FORMAT_R32G32B32A32_SFLOAT;
clearRenderData();
// Compute positions - 1px points are used to drive fragment shading.
- positions = computeVertexPositions(numValues, renderSize);
+ positions = computeVertexPositions(numValues, renderSize.cast<int>());
// Bind attributes
addAttribute(ctx, memAlloc, 0u, VK_FORMAT_R32G32_SFLOAT, sizeof(tcu::Vec2), (deUint32)positions.size(), &positions[0]);
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCmdBufferOptimizeFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- VK_FALSE, // VkBool32 occlusionQueryEnable;
- (VkQueryControlFlags)0u, //VkQueryControlFlags queryFlags;
- (VkQueryPipelineStatisticFlags)0u //VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const VkRenderPassBeginInfo renderPassBeginInfo =
VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo));
- {
- std::vector<const void*> barriers(colorImagePreRenderBarriers.size());
- if (!barriers.empty())
- {
- for (size_t i = 0; i < barriers.size(); ++i)
- barriers[i] = &colorImagePreRenderBarriers[i];
- vk.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_FALSE, (deUint32)barriers.size(), &barriers[0]);
- }
- }
-
+
+ vk.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0,
+ 0, (const VkMemoryBarrier*)DE_NULL,
+ 0, (const VkBufferMemoryBarrier*)DE_NULL,
+ (deUint32)colorImagePreRenderBarriers.size(), colorImagePreRenderBarriers.empty() ? DE_NULL : &colorImagePreRenderBarriers[0]);
vk.cmdBeginRenderPass(*cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *graphicsPipeline);
vk.cmdDraw(*cmdBuffer, (deUint32)positions.size(), 1u, 0u, 0u);
vk.cmdEndRenderPass(*cmdBuffer);
+ vk.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0,
+ 0, (const VkMemoryBarrier*)DE_NULL,
+ 0, (const VkBufferMemoryBarrier*)DE_NULL,
+ (deUint32)colorImagePostRenderBarriers.size(), colorImagePostRenderBarriers.empty() ? DE_NULL : &colorImagePostRenderBarriers[0]);
- {
- std::vector<const void*> barriers(colorImagePostRenderBarriers.size());
- if (!barriers.empty())
- {
- for (size_t i = 0; i < barriers.size(); ++i)
- barriers[i] = &colorImagePostRenderBarriers[i];
- vk.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_FALSE, (deUint32)barriers.size(), &barriers[0]);
- }
- }
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
}
DE_NULL, // pNext
0u, // waitSemaphoreCount
DE_NULL, // pWaitSemaphores
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // commandBufferCount
&cmdBuffer.get(), // pCommandBuffers
0u, // signalSemaphoreCount
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCmdBufferOptimizeFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- VK_FALSE, // VkBool32 occlusionQueryEnable;
- (VkQueryControlFlags)0, // VkQueryControlFlags queryFlags;
- (VkQueryPipelineStatisticFlags)0 // VkQueryPipelineStatisticFlags pipelineStatistics;
-
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const VkBufferImageCopy copyParams =
DE_NULL,
0u,
(const VkSemaphore*)DE_NULL,
+ (const VkPipelineStageFlags*)DE_NULL,
1u,
©CmdBuffer.get(),
0u,
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCmdBufferOptimizeFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- VK_FALSE, // VkBool32 occlusionQueryEnable;
- (VkQueryControlFlags)0, // VkQueryControlFlags queryFlags;
- (VkQueryPipelineStatisticFlags)0 // VkQueryPipelineStatisticFlags pipelineStatistics;
-
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
m_descriptorSetLayoutBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT);
DE_NULL,
0u,
(const VkSemaphore*)DE_NULL,
+ (const VkPipelineStageFlags*)DE_NULL,
1u,
&cmdBuffer.get(),
0u,
std::ostringstream src;
src << "#version 310 es\n"
<< "void main (void)\n{\n"
- << " gl_Position = vec4(gl_VertexID/2, gl_VertexID%2, 0.0, 1.0);\n"
+ << " gl_Position = vec4(gl_VertexIndex/2, gl_VertexIndex%2, 0.0, 1.0);\n"
<< "}\n";
return src.str();
const deUint32 queueFamilyIndex = ctx.getUniversalQueueFamilyIndex();
Allocator& memAlloc = ctx.getDefaultAllocator();
- const tcu::IVec2 renderSize (DEFAULT_RENDER_WIDTH, DEFAULT_RENDER_HEIGHT);
+ const tcu::UVec2 renderSize (DEFAULT_RENDER_WIDTH, DEFAULT_RENDER_HEIGHT);
Move<VkImage> colorImage;
de::MovePtr<Allocation> colorImageAlloc;
{
VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
- (VkPipelineTesselationStateCreateFlags)0, // VkPipelineTessellationStateCreateFlags flags;
+ (VkPipelineTessellationStateCreateFlags)0, // VkPipelineTessellationStateCreateFlags flags;
1 // uint32_t patchControlPoints;
};
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCmdBufferOptimizeFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- VK_FALSE, //VkBool32 occlusionQueryEnable;
- (VkQueryControlFlags)0u, // VkQueryControlFlags queryFlags;
- (VkQueryPipelineStatisticFlags)0u // VkQueryPipelineStatisticFlags pipelineStatistics;
-
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const VkClearValue clearValues[1] =
DE_NULL,
0u,
(const VkSemaphore*)0,
+ (const VkPipelineStageFlags*)DE_NULL,
1u,
&cmdBuffer.get(),
0u,
m_uniformInfos.push_back(UniformInfoSp(new de::UniquePtr<UniformInfo>(samplers)));
}
+const void* ShaderExecutor::getBufferPtr (const deUint32 bindingLocation) const
+{
+ std::vector<UniformInfoSp>::const_iterator it = m_uniformInfos.begin();
+ for (; it != m_uniformInfos.end(); it++)
+ {
+ const UniformInfo* uniformInfo = it->get()->get();
+ if (uniformInfo->isBufferUniform() && uniformInfo->location == bindingLocation)
+ {
+ const BufferUniform* bufferUniform = static_cast<const BufferUniform*>(uniformInfo);
+ return bufferUniform->alloc->getHostPtr();
+ }
+ }
+
+ return DE_NULL;
+}
+
void ShaderExecutor::addUniforms (const VkDevice& vkDevice, const DeviceInterface& vk, const deUint32 queueFamilyIndex, Allocator& memAlloc)
{
if (!m_uniformSetup)
const VkImageCreateInfo imageCreateInfo =
{
- VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pnext;
- flags, // VkImageCreateFlags flags;
- imageType, // VkImageType imageType;
- format, // VkFormat format;
- { texSize.x(), texSize.y(), texSize.z() }, // VkExtend3D extent;
- 1u, // deUint32 mipLevels;
- arraySize, // deUint32 arraySize;
- VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
- tiling, // VkImageTiling tiling;
- usage, // VkImageUsageFlags usage;
- VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
- 1u, // deuint32 queueFamilyCount;
- &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
- VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
+ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
+ DE_NULL, // const void* pnext;
+ flags, // VkImageCreateFlags flags;
+ imageType, // VkImageType imageType;
+ format, // VkFormat format;
+ { (deUint32)texSize.x(), (deUint32)texSize.y(), (deUint32)texSize.z() }, // VkExtend3D extent;
+ 1u, // deUint32 mipLevels;
+ arraySize, // deUint32 arraySize;
+ VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
+ tiling, // VkImageTiling tiling;
+ usage, // VkImageUsageFlags usage;
+ VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
+ 1u, // deuint32 queueFamilyCount;
+ &queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
+ VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
};
Move<VkImage> vkTexture = createImage(vk, vkDevice, &imageCreateInfo);
allocation = uploadImage(vkDevice, vk, memAlloc, texFormat, texSize, data, *vkTexture, aspectMask);
// Create sampler
- const bool compareEnabled = (refSampler.compare != tcu::Sampler::COMPAREMODE_NONE);
- const VkSamplerCreateInfo samplerParams =
- {
- VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- VkSamplerCreateFlags(0u), // VkSamplerCreateFlags flags;
- mapFilterMode(refSampler.magFilter), // VkTexFilter magFilter;
- mapFilterMode(refSampler.minFilter), // VkTexFilter minFilter;
- mapMipmapMode(refSampler.minFilter), // VkTexMipmapMode mipMode;
- mapWrapMode(refSampler.wrapS), // VkTexAddressMode addressModeU;
- mapWrapMode(refSampler.wrapT), // VkTexAddressMode addressModeV;
- mapWrapMode(refSampler.wrapR), // VkTexAddressMode addressModeW;
- refSampler.lodThreshold, // float mipLodBias;
- 1, // float maxAnisotropy;
- compareEnabled, // VkBool32 compareEnable;
- mapCompareMode(refSampler.compare), // VkCompareOp compareOp;
- 0.0f, // float minLod;
- 0.0f, // float maxLod;
- VK_BORDER_COLOR_INT_OPAQUE_WHITE, // VkBorderColor boderColor;
- VK_FALSE, // VkBool32 unnormalizerdCoordinates;
- };
-
+ const VkSamplerCreateInfo samplerParams = mapSampler(refSampler, texFormat);
Move<VkSampler> sampler = createSampler(vk, vkDevice, &samplerParams);
const VkImageViewCreateInfo viewParams =
VkImageViewType imageViewType,
const void* data);
+ const void* getBufferPtr (const deUint32 bindingLocation) const;
+
protected:
ShaderExecutor (const ShaderSpec& shaderSpec, glu::ShaderType shaderType);
namespace
{
-static const int s_gridSize = 2;
-static const int s_maxRenderWidth = 128;
-static const int s_maxRenderHeight = 128;
-static const tcu::Vec4 s_defaultClearColor = tcu::Vec4(0.125f, 0.25f, 0.5f, 1.0f);
+static const int GRID_SIZE = 2;
+static const deUint32 MAX_RENDER_WIDTH = 128;
+static const deUint32 MAX_RENDER_HEIGHT = 128;
+static const tcu::Vec4 DEFAULT_CLEAR_COLOR = tcu::Vec4(0.125f, 0.25f, 0.5f, 1.0f);
static bool isSupportedLinearTilingFormat (const InstanceInterface& instanceInterface, VkPhysicalDevice device, VkFormat format)
{
const UniformSetup& uniformSetup,
const AttributeSetupFunc attribFunc)
: vkt::TestInstance (context)
- , m_clearColor (s_defaultClearColor)
+ , m_clearColor (DEFAULT_CLEAR_COLOR)
, m_memAlloc (context.getDefaultAllocator())
, m_isVertexCase (isVertexCase)
, m_evaluator (evaluator)
setup();
// Create quad grid.
- const tcu::IVec2 viewportSize = getViewportSize();
+ const tcu::UVec2 viewportSize = getViewportSize();
const int width = viewportSize.x();
const int height = viewportSize.y();
- QuadGrid quadGrid (m_isVertexCase ? s_gridSize : 4, width, height, tcu::Vec4(0.125f, 0.25f, 0.5f, 1.0f), m_userAttribTransforms, m_textures);
+ QuadGrid quadGrid (m_isVertexCase ? GRID_SIZE : 4, width, height, tcu::Vec4(0.125f, 0.25f, 0.5f, 1.0f), m_userAttribTransforms, m_textures);
// Render result.
tcu::Surface resImage (width, height);
#undef UNIFORM_CASE
}
-const tcu::IVec2 ShaderRenderCaseInstance::getViewportSize (void) const
+const tcu::UVec2 ShaderRenderCaseInstance::getViewportSize (void) const
{
- return tcu::IVec2(de::min(m_renderSize.x(), s_maxRenderWidth),
- de::min(m_renderSize.y(), s_maxRenderHeight));
+ return tcu::UVec2(de::min(m_renderSize.x(), MAX_RENDER_WIDTH),
+ de::min(m_renderSize.y(), MAX_RENDER_HEIGHT));
}
Move<VkImage> ShaderRenderCaseInstance::createImage2D (const tcu::Texture2D& texture,
0, // VkImageCreateFlags flags;
VK_IMAGE_TYPE_2D, // VkImageType imageType;
format, // VkFormat format;
- { texture.getWidth(), texture.getHeight(), 1 }, // VkExtend3D extent;
+ {
+ (deUint32)texture.getWidth(),
+ (deUint32)texture.getHeight(),
+ 1u
+ }, // VkExtend3D extent;
1u, // deUint32 mipLevels;
1u, // deUint32 arraySize;
VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
void ShaderRenderCaseInstance::copyTilingImageToOptimal (const vk::VkImage& srcImage,
const vk::VkImage& dstImage,
- deInt32 width,
- deInt32 height)
+ deUint32 width,
+ deUint32 height)
{
const VkDevice vkDevice = m_context.getDevice();
const DeviceInterface& vk = m_context.getDeviceInterface();
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
usageFlags, // VkCommandBufferUsageFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- VK_FALSE, // VkBool32 occlusionQueryEnable;
- (VkQueryControlFlags)0,
- (VkQueryPipelineStatisticFlags)0,
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, vkDevice, &cmdBufferParams);
createImageMemoryBarrier(dstImage, (VkAccessFlags)0u, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL)
};
- for (deUint32 barrierNdx = 0; barrierNdx < DE_LENGTH_OF_ARRAY(layoutBarriers); barrierNdx++)
- {
- const VkImageMemoryBarrier* memoryBarrier = &layoutBarriers[barrierNdx];
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, (const void * const*)&memoryBarrier);
- }
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0,
+ 0, (const VkMemoryBarrier*)DE_NULL,
+ 0, (const VkBufferMemoryBarrier*)DE_NULL,
+ DE_LENGTH_OF_ARRAY(layoutBarriers), layoutBarriers);
// Add image copy
const VkImageCopy imageCopy =
const VkImageMemoryBarrier dstBarrier =
createImageMemoryBarrier(dstImage, VK_ACCESS_HOST_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT, 0u, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
- const void* const* barrier = (const void* const*)&dstBarrier;
- vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, (const void* const*)&barrier);
+ vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0,
+ 0, (const VkMemoryBarrier*)DE_NULL,
+ 0, (const VkBufferMemoryBarrier*)DE_NULL,
+ 1, &dstBarrier);
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
DE_NULL,
0u,
(const VkSemaphore*)DE_NULL,
+ (const VkPipelineStageFlags*)DE_NULL,
1u,
&cmdBuffer.get(),
0u,
}
// Create sampler
- const bool compareEnabled = (refSampler.compare != tcu::Sampler::COMPAREMODE_NONE);
- const VkSamplerCreateInfo samplerParams =
- {
- VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- (VkSamplerCreateFlags)0,
- mapFilterMode(refSampler.magFilter), // VkTexFilter magFilter;
- mapFilterMode(refSampler.minFilter), // VkTexFilter minFilter;
- mapMipmapMode(refSampler.minFilter), // VkTexMipmapMode mipMode;
- mapWrapMode(refSampler.wrapS), // VkTexAddressMode addressModeU;
- mapWrapMode(refSampler.wrapT), // VkTexAddressMode addressModeV;
- mapWrapMode(refSampler.wrapR), // VkTexAddressMode addressModeW;
- refSampler.lodThreshold, // float mipLodBias;
- 1, // float maxAnisotropy;
- compareEnabled, // VkBool32 compareEnable;
- mapCompareMode(refSampler.compare), // VkCompareOp compareOp;
- 0.0f, // float minLod;
- 0.0f, // float maxLod;
- VK_BORDER_COLOR_INT_OPAQUE_WHITE, // VkBorderColor boderColor;
- VK_FALSE, // VkBool32 unnormalizerdCoordinates;
- };
-
+ const VkSamplerCreateInfo samplerParams = mapSampler(refSampler, refTexture.getFormat());
Move<VkSampler> sampler = createSampler(vk, vkDevice, &samplerParams);
const VkImageViewCreateInfo viewParams =
setupUniforms(quadGrid.getConstCoords());
m_descriptorSetLayout = m_descriptorSetLayoutBuilder.build(vk, vkDevice);
- m_descriptorPool = m_descriptorPoolBuilder.build(vk, vkDevice, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
-
+ if (!m_uniformInfos.empty())
{
+ m_descriptorPool = m_descriptorPoolBuilder.build(vk, vkDevice, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
const VkDescriptorSetAllocateInfo allocInfo =
{
VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCmdBufferOptimizeFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- VK_FALSE,
- (VkQueryControlFlags)0,
- (VkQueryPipelineStatisticFlags)0,
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const VkClearValue clearValues = makeClearValueColorF32(m_clearColor.x(),
// Add texture barriers
std::vector<VkImageMemoryBarrier> barriers;
- std::vector<void*> barrierPtrs;
for(deUint32 i = 0; i < m_uniformInfos.size(); i++)
{
const VkImageMemoryBarrier textureBarrier = createImageMemoryBarrier(sampler->image->get(), outputMask, 0u, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
barriers.push_back(textureBarrier);
- barrierPtrs.push_back((void*)&barriers.back());
}
- vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, (deUint32)barrierPtrs.size(), (barrierPtrs.size() ? (const void * const*)&barrierPtrs[0] : DE_NULL));
+ vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0,
+ 0, (const VkMemoryBarrier*)DE_NULL,
+ 0, (const VkBufferMemoryBarrier*)DE_NULL,
+ (deUint32)barriers.size(), (barriers.empty() ? (const VkImageMemoryBarrier*)DE_NULL : &barriers[0]));
vk.cmdBeginRenderPass(*m_cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_graphicsPipeline);
- vk.cmdBindDescriptorSets(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipelineLayout, 0u, 1, &*m_descriptorSet, 0u, DE_NULL);
+ if (!m_uniformInfos.empty())
+ vk.cmdBindDescriptorSets(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipelineLayout, 0u, 1, &*m_descriptorSet, 0u, DE_NULL);
vk.cmdBindIndexBuffer(*m_cmdBuffer, *m_indiceBuffer, 0, VK_INDEX_TYPE_UINT16);
const deUint32 numberOfVertexAttributes = (deUint32)m_vertexBuffers.size();
DE_NULL,
0u,
(const VkSemaphore*)DE_NULL,
+ (const VkPipelineStageFlags*)DE_NULL,
1u,
&m_cmdBuffer.get(),
0u,
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCmdBufferOptimizeFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- VK_FALSE,
- (VkQueryControlFlags)0,
- (VkQueryPipelineStatisticFlags)0,
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, vkDevice, &cmdBufferParams);
DE_NULL,
0u,
(const VkSemaphore*)DE_NULL,
+ (const VkPipelineStageFlags*)DE_NULL,
1u,
&cmdBuffer.get(),
0u,
virtual void setup (void);
virtual void setupUniforms (const tcu::Vec4& constCoords);
- const tcu::IVec2 getViewportSize (void) const;
+ const tcu::UVec2 getViewportSize (void) const;
std::vector<tcu::Mat4> m_userAttribTransforms;
const tcu::Vec4 m_clearColor;
const vk::VkImageTiling tiling);
void copyTilingImageToOptimal (const vk::VkImage& srcImage,
const vk::VkImage& dstImage,
- deInt32 width,
- deInt32 height);
+ deUint32 width,
+ deUint32 height);
void setupUniformData (deUint32 bindingLocation, size_t size, const void* dataPtr);
void setupDefaultInputs (const QuadGrid& quadGrid);
};
std::vector<EnabledBaseAttribute> m_enabledBaseAttributes;
- const tcu::IVec2 m_renderSize;
+ const tcu::UVec2 m_renderSize;
const vk::VkFormat m_colorFormat;
vk::Move<vk::VkImage> m_colorImage;
{
m_fragShaderSource = shaderSource;
m_vertShaderSource =
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(location=0) in highp vec4 a_position;\n"
static const char* getTemplate (DiscardTemplate variant)
{
#define GLSL_SHADER_TEMPLATE_HEADER \
- "#version 140\n" \
+ "#version 310 es\n" \
"#extension GL_ARB_separate_shader_objects : enable\n" \
"#extension GL_ARB_shading_language_420pack : enable\n" \
"layout(location = 0) in mediump vec4 v_color;\n" \
IndexAccessType fragAccess)
{
std::ostringstream vtx;
- vtx << "#version 140\n";
+ vtx << "#version 310 es\n";
vtx << "#extension GL_ARB_separate_shader_objects : enable\n";
vtx << "#extension GL_ARB_shading_language_420pack : enable\n";
vtx << "layout(location = 0) in highp vec4 a_position;\n";
vtx << "}\n";
std::ostringstream frag;
- frag << "#version 140\n";
+ frag << "#version 310 es\n";
frag << "#extension GL_ARB_separate_shader_objects : enable\n";
frag << "#extension GL_ARB_shading_language_420pack : enable\n";
frag << "precision mediump int;\n";
std::ostringstream frag;
std::ostringstream& op = isVertexCase ? vtx : frag;
- vtx << "#version 140\n";
+ vtx << "#version 310 es\n";
vtx << "#extension GL_ARB_separate_shader_objects : enable\n";
vtx << "#extension GL_ARB_shading_language_420pack : enable\n";
- frag << "#version 140\n";
+ frag << "#version 310 es\n";
frag << "#extension GL_ARB_separate_shader_objects : enable\n";
frag << "#extension GL_ARB_shading_language_420pack : enable\n";
std::ostringstream frag;
std::ostringstream& op = isVertexCase ? vtx : frag;
- vtx << "#version 140\n";
+ vtx << "#version 310 es\n";
vtx << "#extension GL_ARB_separate_shader_objects : enable\n";
vtx << "#extension GL_ARB_shading_language_420pack : enable\n";
- frag << "#version 140\n";
+ frag << "#version 310 es\n";
frag << "#extension GL_ARB_separate_shader_objects : enable\n";
frag << "#extension GL_ARB_shading_language_420pack : enable\n";
int vecLen = getDataTypeScalarSize(varType);
const char* vecLenName = getIntUniformName(vecLen);
- vtx << "#version 140\n";
+ vtx << "#version 310 es\n";
vtx << "#extension GL_ARB_separate_shader_objects : enable\n";
vtx << "#extension GL_ARB_shading_language_420pack : enable\n";
- frag << "#version 140\n";
+ frag << "#version 310 es\n";
frag << "#extension GL_ARB_separate_shader_objects : enable\n";
frag << "#extension GL_ARB_shading_language_420pack : enable\n";
const char* matSizeName = getIntUniformName(numCols);
DataType vecType = getDataTypeFloatVec(numRows);
- vtx << "#version 140\n";
+ vtx << "#version 310 es\n";
vtx << "#extension GL_ARB_separate_shader_objects : enable\n";
vtx << "#extension GL_ARB_shading_language_420pack : enable\n";
- frag << "#version 140\n";
+ frag << "#version 310 es\n";
frag << "#extension GL_ARB_separate_shader_objects : enable\n";
frag << "#extension GL_ARB_shading_language_420pack : enable\n";
std::ostringstream frag;
std::ostringstream& op = isVertexCase ? vtx : frag;
- vtx << "#version 140\n";
+ vtx << "#version 310 es\n";
vtx << "#extension GL_ARB_separate_shader_objects : enable\n";
vtx << "#extension GL_ARB_shading_language_420pack : enable\n";
- frag << "#version 140\n";
+ frag << "#version 310 es\n";
frag << "#extension GL_ARB_separate_shader_objects : enable\n";
frag << "#extension GL_ARB_shading_language_420pack : enable\n";
std::vector<BaseUniformType> uniformInformations;
deUint32 locationCounter = 0;
- vtx << "#version 140\n";
+ vtx << "#version 310 es\n";
vtx << "#extension GL_ARB_separate_shader_objects : enable\n";
vtx << "#extension GL_ARB_shading_language_420pack : enable\n";
- frag << "#version 140\n";
+ frag << "#version 310 es\n";
frag << "#extension GL_ARB_separate_shader_objects : enable\n";
frag << "#extension GL_ARB_shading_language_420pack : enable\n";
std::ostringstream& op = m_isVertexCase ? vtx : frag;
std::string header =
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n";
{
m_vertShaderSource = shaderSource;
m_fragShaderSource =
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(location = 0) in mediump vec4 v_color;\n"
{
m_fragShaderSource = shaderSource;
m_vertShaderSource =
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(location = 0) in highp vec4 a_position;\n"
de::MovePtr<ShaderReturnCase> makeConditionalReturnInFuncCase (tcu::TestContext& context, const std::string& name, const std::string& description, ReturnMode returnMode, bool isVertex)
{
tcu::StringTemplate tmpl(
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(location = ${COORDLOC}) in ${COORDPREC} vec4 ${COORDS};\n"
tcu::StringTemplate tmpl(
inFunction
?
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(location = ${COORDLOC}) in ${COORDPREC} vec4 ${COORDS};\n"
" myfunc();\n"
"}\n"
:
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(location = ${COORDLOC}) in ${COORDPREC} vec4 ${COORDS};\n"
de::MovePtr<ShaderReturnCase> makeReturnInLoopCase (tcu::TestContext& context, const std::string& name, const std::string& description, bool isDynamicLoop, ReturnMode returnMode, bool isVertex)
{
tcu::StringTemplate tmpl(
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(location = ${COORDLOC}) in ${COORDPREC} vec4 ${COORDS};\n"
void ShaderReturnTests::init (void)
{
addChild(new ShaderReturnCase(m_testCtx, "single_return_vertex", "Single return statement in function", true,
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(location = 0) in highp vec4 a_position;\n"
" v_color = getColor();\n"
"}\n", evalReturnAlways, DE_NULL));
addChild(new ShaderReturnCase(m_testCtx, "single_return_fragment", "Single return statement in function", false,
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(location = 0) in mediump vec4 v_coords;\n"
// Unconditional double return in function.
addChild(new ShaderReturnCase(m_testCtx, "double_return_vertex", "Unconditional double return in function", true,
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(location = 0) in highp vec4 a_position;\n"
" v_color = getColor();\n"
"}\n", evalReturnAlways, DE_NULL));
addChild(new ShaderReturnCase(m_testCtx, "double_return_fragment", "Unconditional double return in function", false,
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(location = 0) in mediump vec4 v_coords;\n"
// Last statement in main.
addChild(new ShaderReturnCase(m_testCtx, "last_statement_in_main_vertex", "Return as a final statement in main()", true,
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(location = 0) in highp vec4 a_position;\n"
" return;\n"
"}\n", evalReturnAlways, DE_NULL));
addChild(new ShaderReturnCase(m_testCtx, "last_statement_in_main_fragment", "Return as a final statement in main()", false,
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(location = 0) in mediump vec4 v_coords;\n"
// Unconditional return in infinite loop.
addChild(new ShaderReturnCase(m_testCtx, "return_in_infinite_loop_vertex", "Return in infinite loop", true,
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(location = 0) in highp vec4 a_position;\n"
" return;\n"
"}\n", evalReturnAlways, new ReturnTestUniformSetup(UI_ZERO)));
addChild(new ShaderReturnCase(m_testCtx, "return_in_infinite_loop_fragment", "Return in infinite loop", false,
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(location = 0) in mediump vec4 v_coords;\n"
static de::MovePtr<ShaderStructCase> createStructCase (tcu::TestContext& testCtx, const std::string& name, const std::string& description, bool isVertexCase, ShaderEvalFunc evalFunc, UniformSetupFunc uniformFunc, const LineStream& shaderSrc)
{
static std::string defaultVertSrc =
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(location = 0) in highp vec4 a_position;\n"
" gl_Position = a_position;\n"
"}\n";
static std::string defaultFragSrc =
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(location = 0) in mediump vec4 v_color;\n"
if (isVertexCase)
{
spParams["HEADER"] =
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(location = 0) in highp vec4 a_position;\n"
else
{
spParams["HEADER"] =
- "#version 140\n"
+ "#version 310 es\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout(location = 0) in mediump vec4 v_coords;\n"
std::ostringstream frag;
std::ostringstream& op = isVertex ? vtx : frag;
- vtx << "#version 140\n"
+ vtx << "#version 310 es\n"
<< "#extension GL_ARB_separate_shader_objects : enable\n"
<< "#extension GL_ARB_shading_language_420pack : enable\n"
<< "layout(location = 0) in highp vec4 a_position;\n"
<< "layout(location = 1) in highp vec4 a_coords;\n\n";
- frag << "#version 140\n"
+ frag << "#version 310 es\n"
<< "#extension GL_ARB_separate_shader_objects : enable\n"
<< "#extension GL_ARB_shading_language_420pack : enable\n"
<< "layout(location = 0) out mediump vec4 o_color;\n";
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // sType
DE_NULL, // pNext
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
- (VkRenderPass)0u, // renderPass
- 0u, // subpass
- (VkFramebuffer)0u, // framebuffer
- VK_FALSE, // occlusionQueryEnable
- (VkQueryControlFlags)0,
- (VkQueryPipelineStatisticFlags)0,
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
const tcu::IVec3& numWorkGroups = m_shaderSpec.numWorkGroups;
DE_NULL,
0u,
(const VkSemaphore*)DE_NULL,
+ (const VkPipelineStageFlags*)DE_NULL,
1u,
&cmdBuffer.get(),
0u,
"%i32 = OpTypeInt 32 1\n"
"%f32 = OpTypeFloat 32\n"
"%uvec3 = OpTypeVector %u32 3\n"
+ "%fvec3 = OpTypeVector %f32 3\n"
"%uvec3ptr = OpTypePointer Input %uvec3\n"
"%f32ptr = OpTypePointer Uniform %f32\n"
"%f32arr = OpTypeRuntimeArray %f32\n";
"OpName %id \"gl_GlobalInvocationID\"\n"
"OpDecorate %id BuiltIn GlobalInvocationId\n"
+ "OpDecorate %vec4arr ArrayStride 16\n"
+ string(s_InputOutputBufferTraits) + string(s_CommonTypes) +
"OpName %id \"gl_GlobalInvocationID\"\n"
"OpDecorate %id BuiltIn GlobalInvocationId\n"
+ "OpDecorate %f32arr100 ArrayStride 4\n"
+ string(s_InputOutputBufferTraits) + string(s_CommonTypes) +
fillRandomScalars(rnd, -200.f, 200.f, &inputFloats3[0], 16);
for (size_t ndx = 0; ndx < 16; ++ndx)
- outputFloats3[ndx] = -inputFloats3[ndx];
+ outputFloats3[ndx] = inputFloats3[ndx];
spec3.assembly =
string(s_ShaderPreamble) +
"OpName %id \"gl_GlobalInvocationID\"\n"
"OpDecorate %id BuiltIn GlobalInvocationId\n"
+ "OpMemberDecorate %inbuf 0 Offset 0\n"
+ "OpMemberDecorate %inbuf 1 Offset 16\n"
+ "OpMemberDecorate %inbuf 2 Offset 32\n"
+ "OpMemberDecorate %inbuf 3 Offset 48\n"
+ "OpMemberDecorate %outbuf 0 Offset 0\n"
+ "OpMemberDecorate %outbuf 1 Offset 16\n"
+ "OpMemberDecorate %outbuf 2 Offset 32\n"
+ "OpMemberDecorate %outbuf 3 Offset 48\n"
+ string(s_InputOutputBufferTraits) + string(s_CommonTypes) +
+ string(s_InputOutputBufferTraits) + string(s_CommonTypes) +
- "%fvec3 = OpTypeVector %f32 3\n"
"%fmat = OpTypeMatrix %fvec3 3\n"
"%three = OpConstant %u32 3\n"
"%farr = OpTypeArray %f32 %three\n"
"%inval = OpLoad %f32 %inloc\n"
"%outloc = OpAccessChain %f32ptr %outdata %zero %x\n"
"%ret_const5 = OpFunctionCall %u32 %func_const5\n"
- "%ret_modulo4 = OpFunctionCall %u32 %func_modulo4 %thousand\n"
+ "%v_thousand = OpVariable %u32ptr Function %thousand\n"
+ "%ret_modulo4 = OpFunctionCall %u32 %func_modulo4 %v_thousand\n"
"%cmp_gt = OpUGreaterThan %bool %ret_const5 %ret_modulo4\n"
" OpSelectionMerge %if_end None\n"
" OpBranchConditional %cmp_gt %if_true %if_false\n"
"OpDecorate %id BuiltIn GlobalInvocationId\n"
"OpDecorate %sc_0 SpecId 0\n"
"OpDecorate %sc_1 SpecId 1\n"
+ "OpDecorate %i32arr ArrayStride 4\n"
+ string(s_InputOutputBufferTraits) + string(s_CommonTypes) +
"OpDecorate %sc_0 SpecId 0\n"
"OpDecorate %sc_1 SpecId 1\n"
"OpDecorate %sc_2 SpecId 2\n"
+ "OpDecorate %i32arr ArrayStride 4\n"
+ string(s_InputOutputBufferTraits) + string(s_CommonTypes) +
"OpEntryPoint GLCompute %comp_main1 \"entrypoint1\" %id\n"
"OpEntryPoint GLCompute %comp_main2 \"entrypoint2\" %id\n"
// A module cannot have two OpEntryPoint instructions with the same Execution Model and the same Name string.
- "OpEntryPoint Vertex %vert_main \"entrypoint2\" %vert_builtins %vertexID %instanceID\n"
- "OpExecutionMode %vert_main LocalSize 1 1 1\n"
+ "OpEntryPoint Vertex %vert_main \"entrypoint2\" %vert_builtins %vertexIndex %instanceIndex\n"
+ "OpExecutionMode %comp_main1 LocalSize 1 1 1\n"
+ "OpExecutionMode %comp_main2 LocalSize 1 1 1\n"
"OpName %comp_main1 \"entrypoint1\"\n"
"OpName %comp_main2 \"entrypoint2\"\n"
"OpName %vert_main \"entrypoint2\"\n"
"OpName %id \"gl_GlobalInvocationID\"\n"
"OpName %vert_builtin_st \"gl_PerVertex\"\n"
- "OpName %vertexID \"gl_VertexID\"\n"
- "OpName %instanceID \"gl_InstanceID\"\n"
+ "OpName %vertexIndex \"gl_VertexIndex\"\n"
+ "OpName %instanceIndex \"gl_InstanceIndex\"\n"
"OpMemberName %vert_builtin_st 0 \"gl_Position\"\n"
"OpMemberName %vert_builtin_st 1 \"gl_PointSize\"\n"
"OpMemberName %vert_builtin_st 2 \"gl_ClipDistance\"\n"
"OpDecorate %id BuiltIn GlobalInvocationId\n"
- "OpDecorate %vertexID BuiltIn VertexId\n"
- "OpDecorate %instanceID BuiltIn InstanceId\n"
+ "OpDecorate %vertexIndex BuiltIn VertexIndex\n"
+ "OpDecorate %instanceIndex BuiltIn InstanceIndex\n"
"OpDecorate %vert_builtin_st Block\n"
"OpMemberDecorate %vert_builtin_st 0 BuiltIn Position\n"
"OpMemberDecorate %vert_builtin_st 1 BuiltIn PointSize\n"
+ string(s_InputOutputBufferTraits) + string(s_CommonTypes) + string(s_InputOutputBuffer) +
+ "%zero = OpConstant %i32 0\n"
+ "%one = OpConstant %u32 1\n"
+ "%c_f32_1 = OpConstant %f32 1\n"
+
"%i32ptr = OpTypePointer Input %i32\n"
"%vec4 = OpTypeVector %f32 4\n"
"%vec4ptr = OpTypePointer Output %vec4\n"
"%vert_builtins = OpVariable %vert_builtin_st_ptr Output\n"
"%id = OpVariable %uvec3ptr Input\n"
- "%vertexID = OpVariable %i32ptr Input\n"
- "%instanceID = OpVariable %i32ptr Input\n"
- "%zero = OpConstant %i32 0\n"
- "%one = OpConstant %u32 1\n"
- "%c_f32_1 = OpConstant %f32 1\n"
+ "%vertexIndex = OpVariable %i32ptr Input\n"
+ "%instanceIndex = OpVariable %i32ptr Input\n"
"%c_vec4_1 = OpConstantComposite %vec4 %c_f32_1 %c_f32_1 %c_f32_1 %c_f32_1\n"
// gl_Position = vec4(1.);
cases.push_back(CaseParameter("vec4float32", "%type = OpTypeVector %f32 4"));
cases.push_back(CaseParameter("vec3bool", "%type = OpTypeVector %bool 3"));
cases.push_back(CaseParameter("vec2uint32", "%type = OpTypeVector %u32 2"));
- cases.push_back(CaseParameter("matrix", "%type = OpTypeMatrix %uvec3 3"));
+ cases.push_back(CaseParameter("matrix", "%type = OpTypeMatrix %fvec3 3"));
cases.push_back(CaseParameter("array", "%100 = OpConstant %u32 100\n"
"%type = OpTypeArray %i32 %100"));
- cases.push_back(CaseParameter("runtimearray", "%type = OpTypeRuntimeArray %f32"));
cases.push_back(CaseParameter("struct", "%type = OpTypeStruct %f32 %i32 %u32"));
cases.push_back(CaseParameter("pointer", "%type = OpTypePointer Function %i32"));
cases.push_back(CaseParameter("vector", "%five = OpConstant %u32 5\n"
"%const = OpConstantComposite %uvec3 %five %zero %five"));
- cases.push_back(CaseParameter("matrix", "%m3uvec3 = OpTypeMatrix %uvec3 3\n"
+ cases.push_back(CaseParameter("matrix", "%m3uvec3 = OpTypeMatrix %fvec3 3\n"
"%ten = OpConstant %u32 10\n"
"%vec = OpConstantComposite %uvec3 %ten %zero %ten\n"
"%mat = OpConstantComposite %m3uvec3 %vec %vec %vec"));
- cases.push_back(CaseParameter("struct", "%m2vec3 = OpTypeMatrix %uvec3 2\n"
+ cases.push_back(CaseParameter("struct", "%m2vec3 = OpTypeMatrix %fvec3 2\n"
"%struct = OpTypeStruct %u32 %f32 %uvec3 %m2vec3\n"
"%one = OpConstant %u32 1\n"
"%point5 = OpConstant %f32 0.5\n"
for (deInt32 idx = 0; idx < 23; ++idx)
{
- f += ((significand & 0x800000) == 0) ? 0.f : std::ldexp(1.0f, -idx);
+ f += ((significand & 0x800000) == 0) ? 0.f : std::ldexp(1.0f, -(idx + 1));
significand <<= 1;
}
}
}
+ spec.assembly = shader;
spec.inputs.push_back(BufferSp(new Float32Buffer(infinities)));
spec.outputs.push_back(BufferSp(new Float32Buffer(results)));
spec.numWorkGroups = IVec3(numElements, 1, 1);
}
}
+ spec.assembly = shader;
spec.inputs.push_back(BufferSp(new Float32Buffer(nans)));
spec.outputs.push_back(BufferSp(new Float32Buffer(nans)));
spec.numWorkGroups = IVec3(numElements, 1, 1);
}
}
+ spec.assembly = shader;
spec.inputs.push_back(BufferSp(new Float32Buffer(small)));
spec.outputs.push_back(BufferSp(new Float32Buffer(zeros)));
spec.numWorkGroups = IVec3(numElements, 1, 1);
for (size_t idx = 0; idx < numElements; ++idx)
exact.push_back(static_cast<float>(idx - 100));
+ spec.assembly = shader;
spec.inputs.push_back(BufferSp(new Float32Buffer(exact)));
spec.outputs.push_back(BufferSp(new Float32Buffer(exact)));
spec.numWorkGroups = IVec3(numElements, 1, 1);
inputs.push_back(constructNormalizedFloat(2, 0x01E000));
inputs.push_back(constructNormalizedFloat(1, 0xFFE000));
+ spec.assembly = shader;
spec.verifyIO = &compareOpQuantizeF16ComputeExactCase;
spec.inputs.push_back(BufferSp(new Float32Buffer(inputs)));
spec.outputs.push_back(BufferSp(new Float32Buffer(inputs)));
+ string(s_InputOutputBufferTraits) + string(s_CommonTypes) +
- "%fvec3 = OpTypeVector %f32 3\n"
"%fmat = OpTypeMatrix %fvec3 3\n"
"%ten = OpConstant %u32 10\n"
"%f32arr10 = OpTypeArray %f32 %ten\n"
cases.push_back(CaseParameter("float32", "%type = OpTypeFloat 32"));
cases.push_back(CaseParameter("vec4float32", "%type = OpTypeVector %f32 4"));
cases.push_back(CaseParameter("vec2uint32", "%type = OpTypeVector %u32 2"));
- cases.push_back(CaseParameter("matrix", "%type = OpTypeMatrix %uvec3 3"));
+ cases.push_back(CaseParameter("matrix", "%type = OpTypeMatrix %fvec3 3"));
cases.push_back(CaseParameter("image", "%type = OpTypeImage %f32 2D 0 0 0 0 Unknown"));
cases.push_back(CaseParameter("sampler", "%type = OpTypeSampler"));
cases.push_back(CaseParameter("sampledimage", "%img = OpTypeImage %f32 2D 0 0 0 0 Unknown\n"
static const char vertexShaderBoilerplate[] =
"OpCapability Shader\n"
"OpMemoryModel Logical GLSL450\n"
- "OpEntryPoint Vertex %main \"main\" %BP_stream %BP_position %BP_vtx_color %BP_color %BP_gl_VertexID %BP_gl_InstanceID\n"
+ "OpEntryPoint Vertex %main \"main\" %BP_stream %BP_position %BP_vtx_color %BP_color %BP_gl_VertexIndex %BP_gl_InstanceIndex\n"
"${debug:opt}\n"
"OpName %main \"main\"\n"
"OpName %BP_gl_PerVertex \"gl_PerVertex\"\n"
"OpName %BP_position \"position\"\n"
"OpName %BP_vtx_color \"vtxColor\"\n"
"OpName %BP_color \"color\"\n"
- "OpName %BP_gl_VertexID \"gl_VertexID\"\n"
- "OpName %BP_gl_InstanceID \"gl_InstanceID\"\n"
+ "OpName %BP_gl_VertexIndex \"gl_VertexIndex\"\n"
+ "OpName %BP_gl_InstanceIndex \"gl_InstanceIndex\"\n"
"OpMemberDecorate %BP_gl_PerVertex 0 BuiltIn Position\n"
"OpMemberDecorate %BP_gl_PerVertex 1 BuiltIn PointSize\n"
"OpMemberDecorate %BP_gl_PerVertex 2 BuiltIn ClipDistance\n"
"OpDecorate %BP_position Location 0\n"
"OpDecorate %BP_vtx_color Location 1\n"
"OpDecorate %BP_color Location 1\n"
- "OpDecorate %BP_gl_VertexID BuiltIn VertexId\n"
- "OpDecorate %BP_gl_InstanceID BuiltIn InstanceId\n"
+ "OpDecorate %BP_gl_VertexIndex BuiltIn VertexIndex\n"
+ "OpDecorate %BP_gl_InstanceIndex BuiltIn InstanceIndex\n"
"${decoration:opt}\n"
SPIRV_ASSEMBLY_TYPES
SPIRV_ASSEMBLY_CONSTANTS
"%BP_position = OpVariable %ip_v4f32 Input\n"
"%BP_vtx_color = OpVariable %op_v4f32 Output\n"
"%BP_color = OpVariable %ip_v4f32 Input\n"
- "%BP_gl_VertexID = OpVariable %ip_i32 Input\n"
- "%BP_gl_InstanceID = OpVariable %ip_i32 Input\n"
+ "%BP_gl_VertexIndex = OpVariable %ip_i32 Input\n"
+ "%BP_gl_InstanceIndex = OpVariable %ip_i32 Input\n"
"${pre_main:opt}\n"
"%main = OpFunction %void None %fun\n"
"%BP_label = OpLabel\n"
"OpName %vert_Position \"position\"\n"
"OpName %vert_vtxColor \"vtxColor\"\n"
"OpName %vert_color \"color\"\n"
- "OpName %vert_vertex_id \"gl_VertexID\"\n"
- "OpName %vert_instance_id \"gl_InstanceID\"\n"
+ "OpName %vert_vertex_id \"gl_VertexIndex\"\n"
+ "OpName %vert_instance_id \"gl_InstanceIndex\"\n"
"OpDecorate %vert_vtxPosition Location 2\n"
"OpDecorate %vert_Position Location 0\n"
"OpDecorate %vert_vtxColor Location 1\n"
"OpDecorate %vert_color Location 1\n"
- "OpDecorate %vert_vertex_id BuiltIn VertexId\n"
- "OpDecorate %vert_instance_id BuiltIn InstanceId\n"
+ "OpDecorate %vert_vertex_id BuiltIn VertexIndex\n"
+ "OpDecorate %vert_instance_id BuiltIn InstanceIndex\n"
"; Geometry decorations\n"
"OpName %geom_main \"main\"\n"
"OpEntryPoint Vertex %main \"vert1\" %Position %vtxColor %color %vtxPosition %vertex_id %instance_id\n"
"OpEntryPoint Vertex %main2 \"vert2\" %Position %vtxColor %color %vtxPosition %vertex_id %instance_id\n"
- "OpName %main \"frag1\"\n"
- "OpName %main2 \"frag2\"\n"
+ "OpName %main \"vert1\"\n"
+ "OpName %main2 \"vert2\"\n"
"OpName %vtxPosition \"vtxPosition\"\n"
"OpName %Position \"position\"\n"
"OpName %vtxColor \"vtxColor\"\n"
"OpName %color \"color\"\n"
- "OpName %vertex_id \"gl_VertexID\"\n"
- "OpName %instance_id \"gl_InstanceID\"\n"
+ "OpName %vertex_id \"gl_VertexIndex\"\n"
+ "OpName %instance_id \"gl_InstanceIndex\"\n"
"OpDecorate %vtxPosition Location 2\n"
"OpDecorate %Position Location 0\n"
"OpDecorate %vtxColor Location 1\n"
"OpDecorate %color Location 1\n"
- "OpDecorate %vertex_id BuiltIn VertexId\n"
- "OpDecorate %instance_id BuiltIn InstanceId\n"
+ "OpDecorate %vertex_id BuiltIn VertexIndex\n"
+ "OpDecorate %instance_id BuiltIn InstanceIndex\n"
SPIRV_ASSEMBLY_TYPES
SPIRV_ASSEMBLY_CONSTANTS
SPIRV_ASSEMBLY_ARRAYS
const DeviceInterface& vk = context.getDeviceInterface();
const VkQueue queue = context.getUniversalQueue();
const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
- const tcu::IVec2 renderSize (256, 256);
+ const tcu::UVec2 renderSize (256, 256);
vector<ModuleHandleSp> modules;
map<VkShaderStageFlagBits, VkShaderModule> moduleByStage;
const int testSpecificSeed = 31354125;
bool hasTessellation = false;
const VkPhysicalDeviceFeatures& features = context.getDeviceFeatures();
- supportsGeometry = features.geometryShader;
- supportsTessellation = features.tessellationShader;
+ supportsGeometry = features.geometryShader == VK_TRUE;
+ supportsTessellation = features.tessellationShader == VK_TRUE;
hasTessellation = (instance.requiredStages & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) ||
(instance.requiredStages & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT);
{
VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO,
DE_NULL,
- (VkPipelineTesselationStateCreateFlags)0,
+ (VkPipelineTessellationStateCreateFlags)0,
3u
};
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkCommandBufferUsageFlags)0,
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- VK_FALSE, // VkBool32 occlusionQueryEnable;
- (VkQueryControlFlags)0,
- (VkQueryPipelineStatisticFlags)0,
+ (const VkCommandBufferInheritanceInfo*)DE_NULL,
};
// Record commands
1u, // deUint32 arraySize;
} // VkImageSubresourceRange subresourceRange;
};
- const void* barriers[] = { &vertFlushBarrier, &colorAttBarrier };
- vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, DE_FALSE, (deUint32)DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, (VkDependencyFlags)0, 1, &vertFlushBarrier, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &colorAttBarrier);
}
{
1u, // deUint32 arraySize;
} // VkImageSubresourceRange subresourceRange;
};
- const void* barriers[] = { &renderFinishBarrier };
- vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, DE_FALSE, (deUint32)DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &renderFinishBarrier);
}
{
0u, // VkDeviceSize offset;
imageSizeBytes // VkDeviceSize size;
};
- const void* barriers[] = { ©FinishBarrier };
- vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, (deUint32)DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(*cmdBuf, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, ©FinishBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
}
VK_CHECK(vk.endCommandBuffer(*cmdBuf));
DE_NULL,
0u,
(const VkSemaphore*)DE_NULL,
+ (const VkPipelineStageFlags*)DE_NULL,
1u,
&cmdBuf.get(),
0u,
"%v = OpVariable %fp_stype Function %cval\n"
"%vec_ptr = OpAccessChain %fp_v4f32 %v %c_u32_0\n"
- "%f32_ptr = OpAccessChain %fp_v4f32 %v %c_u32_1\n"
+ "%f32_ptr = OpAccessChain %fp_f32 %v %c_u32_1\n"
"%vec_val = OpLoad %v4f32 %vec_ptr\n"
- "%f32_val = OpLoad %v4f32 %f32_ptr\n"
+ "%f32_val = OpLoad %f32 %f32_ptr\n"
"%tmp1 = OpVectorTimesScalar %v4f32 %c_v4f32_1_1_1_1 %f32_val\n" // vec4(-1)
"%tmp2 = OpFAdd %v4f32 %tmp1 %param1\n" // param1 + vec4(-1)
"%transformed_param = OpFAdd %v4f32 %tmp2 %vec_val\n" // param1 + vec4(-1) + vec4(1.5, 1.5, 1.5, 1.0)
cases.push_back(SpecConstantTwoIntGraphicsCase("umod", " %i32 0", " %i32 0", "%i32", "UMod %sc_0 %sc_1", 1001, 500, addZeroToSc, outputColors2));
cases.push_back(SpecConstantTwoIntGraphicsCase("bitwiseand", " %i32 0", " %i32 0", "%i32", "BitwiseAnd %sc_0 %sc_1", 0x33, 0x0d, addZeroToSc, outputColors2));
cases.push_back(SpecConstantTwoIntGraphicsCase("bitwiseor", " %i32 0", " %i32 0", "%i32", "BitwiseOr %sc_0 %sc_1", 0, 1, addZeroToSc, outputColors2));
- cases.push_back(SpecConstantTwoIntGraphicsCase("bitwisexor", " %i32 0", " %i32 0", "%i32", "BitwiseAnd %sc_0 %sc_1", 0x2e, 0x2f, addZeroToSc, outputColors2));
+ cases.push_back(SpecConstantTwoIntGraphicsCase("bitwisexor", " %i32 0", " %i32 0", "%i32", "BitwiseXor %sc_0 %sc_1", 0x2e, 0x2f, addZeroToSc, outputColors2));
cases.push_back(SpecConstantTwoIntGraphicsCase("shiftrightlogical", " %i32 0", " %i32 0", "%i32", "ShiftRightLogical %sc_0 %sc_1", 2, 1, addZeroToSc, outputColors2));
cases.push_back(SpecConstantTwoIntGraphicsCase("shiftrightarithmetic", " %i32 0", " %i32 0", "%i32", "ShiftRightArithmetic %sc_0 %sc_1", -4, 2, addZeroToSc, outputColors0));
cases.push_back(SpecConstantTwoIntGraphicsCase("shiftleftlogical", " %i32 0", " %i32 0", "%i32", "ShiftLeftLogical %sc_0 %sc_1", 1, 0, addZeroToSc, outputColors2));
{
"negative_round_up_or_round_down",
"-0x1.6008p-7",
- -constructNormalizedFloat(8, 0x600800),
+ -constructNormalizedFloat(-7, 0x600800),
"-0x1.6p-7",
"-0x1.604p-7"
},
{
"carry_bit",
"0x1.01ep2",
- constructNormalizedFloat(8, 0x01e000),
+ constructNormalizedFloat(2, 0x01e000),
"0x1.01cp2",
"0x1.02p2"
},
{
"carry_to_exponent",
- "0x1.feep1",
- constructNormalizedFloat(8, 0xfee000),
+ "0x1.ffep1",
+ constructNormalizedFloat(1, 0xffe000),
"0x1.ffcp1",
"0x1.0p2"
},
ShaderElement("vert", "main", VK_SHADER_STAGE_VERTEX_BIT),
ShaderElement("tessc", "main", VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT),
ShaderElement("tesse", "main", VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT),
- ShaderElement("geom", "main", VK_SHADER_STAGE_GEOMETRY_BIT),
ShaderElement("frag", "main", VK_SHADER_STAGE_FRAGMENT_BIT),
};
vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCmdBufferOptimizeFlags flags;
- DE_NULL, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- DE_NULL, // VkFramebuffer framebuffer;
- vk::VK_FALSE,
- (vk::VkQueryControlFlags)0,
- (vk::VkQueryPipelineStatisticFlags)0,
+ (const vk::VkCommandBufferInheritanceInfo*)DE_NULL,
};
VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufBeginParams));
DE_NULL,
0u,
(const vk::VkSemaphore*)DE_NULL,
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1u,
&cmdBuffer.get(),
0u,
return vk::createBuffer(vk, vkDevice, &bufferInfo);
}
-Move<vk::VkImage> createImage2D (Context& context, int width, int height, vk::VkFormat format, vk::VkImageTiling tiling, vk::VkImageUsageFlags usageFlags)
+Move<vk::VkImage> createImage2D (Context& context, deUint32 width, deUint32 height, vk::VkFormat format, vk::VkImageTiling tiling, vk::VkImageUsageFlags usageFlags)
{
const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
const vk::VkImageCreateInfo params =
0u, // VkImageCreateFlags flags
vk::VK_IMAGE_TYPE_2D, // VkImageType imageType
format, // VkFormat format
- { width, height, 1 }, // VkExtent3D extent
+ { width, height, 1u }, // VkExtent3D extent
1u, // deUint32 mipLevels
1u, // deUint32 arrayLayers
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples
vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkCommandBufferUsageFlags flags;
- (vk::VkRenderPass)0, // VkRenderPass renderPass;
- 0u, // deUint32 subpass;
- (vk::VkFramebuffer)0, // VkFramebuffer framebuffer;
- false, // VkBool32 occlusionQueryEnable;
- 0u, // VkQueryControlFlags queryFlags;
- 0u // VkQueryPipelineStatisticFlags pipelineStatistics;
+ (const vk::VkCommandBufferInheritanceInfo*)DE_NULL,
};
VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &beginInfo));
1u, // deUint32 arraySize;
} // VkImageSubresourceRange subresourceRange
};
- const void* const barriers[] = { &renderFinishBarrier };
- vk.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, DE_FALSE, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &renderFinishBarrier);
}
// Add Image->Buffer copy command
0u, // VkDeviceSize offset;
(vk::VkDeviceSize)(RENDER_WIDTH * RENDER_HEIGHT * 4)// VkDeviceSize size;
};
- const void* const barriers[] = { ©FinishBarrier };
- vk.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, DE_FALSE, (deUint32)DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vk.cmdPipelineBarrier(*cmdBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 1, ©FinishBarrier,
+ 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
}
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
DE_NULL, // const void* pNext;
0u, // deUint32 waitSemaphoreCount;
DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL,
1u, // deUint32 commandBufferCount;
&cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
void beginCommandBuffer (const DeviceInterface& vk,
VkCommandBuffer cmdBuffer,
VkCommandBufferUsageFlags pBeginInfo_flags,
- VkRenderPass pBeginInfo_renderPass,
- deUint32 pBeginInfo_subpass,
- VkFramebuffer pBeginInfo_framebuffer,
- VkBool32 pBeginInfo_occlusionQueryEnable,
- VkQueryControlFlags pBeginInfo_queryFlags,
- VkQueryPipelineStatisticFlags pBeginInfo_pipelineStatistics)
+ VkRenderPass pInheritanceInfo_renderPass,
+ deUint32 pInheritanceInfo_subpass,
+ VkFramebuffer pInheritanceInfo_framebuffer,
+ VkBool32 pInheritanceInfo_occlusionQueryEnable,
+ VkQueryControlFlags pInheritanceInfo_queryFlags,
+ VkQueryPipelineStatisticFlags pInheritanceInfo_pipelineStatistics)
{
- const VkCommandBufferBeginInfo pBeginInfo =
+ const VkCommandBufferInheritanceInfo pInheritanceInfo =
+ {
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
+ DE_NULL,
+ pInheritanceInfo_renderPass,
+ pInheritanceInfo_subpass,
+ pInheritanceInfo_framebuffer,
+ pInheritanceInfo_occlusionQueryEnable,
+ pInheritanceInfo_queryFlags,
+ pInheritanceInfo_pipelineStatistics,
+ };
+ const VkCommandBufferBeginInfo pBeginInfo =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
DE_NULL,
pBeginInfo_flags,
- pBeginInfo_renderPass,
- pBeginInfo_subpass,
- pBeginInfo_framebuffer,
- pBeginInfo_occlusionQueryEnable,
- pBeginInfo_queryFlags,
- pBeginInfo_pipelineStatistics,
+ &pInheritanceInfo,
};
VK_CHECK(vk.beginCommandBuffer(cmdBuffer, &pBeginInfo));
}
DE_NULL,
0u, // waitSemaphoreCount
(const VkSemaphore*)DE_NULL, // pWaitSemaphores
+ (const VkPipelineStageFlags*)DE_NULL,
cmdBufferCount, // commandBufferCount
pCmdBuffers,
0u, // signalSemaphoreCount
}
VkSubpassDescription createSubpassDescription (const Subpass& subpass,
- vector<VkAttachmentReference>* attachmentReferenceLists)
+ vector<VkAttachmentReference>* attachmentReferenceLists,
+ vector<deUint32>* preserveAttachmentReferences)
{
vector<VkAttachmentReference>& inputAttachmentReferences = attachmentReferenceLists[0];
vector<VkAttachmentReference>& colorAttachmentReferences = attachmentReferenceLists[1];
vector<VkAttachmentReference>& resolveAttachmentReferences = attachmentReferenceLists[2];
vector<VkAttachmentReference>& depthStencilAttachmentReferences = attachmentReferenceLists[3];
- vector<VkAttachmentReference>& preserveAttachmentReferences = attachmentReferenceLists[4];
for (size_t attachmentNdx = 0; attachmentNdx < subpass.getColorAttachments().size(); attachmentNdx++)
colorAttachmentReferences.push_back(createAttachmentReference(subpass.getColorAttachments()[attachmentNdx]));
depthStencilAttachmentReferences.push_back(createAttachmentReference(subpass.getDepthStencilAttachment()));
for (size_t attachmentNdx = 0; attachmentNdx < subpass.getPreserveAttachments().size(); attachmentNdx++)
- preserveAttachmentReferences.push_back(createAttachmentReference(subpass.getPreserveAttachments()[attachmentNdx]));
+ preserveAttachmentReferences->push_back(subpass.getPreserveAttachments()[attachmentNdx].getAttachment());
DE_ASSERT(resolveAttachmentReferences.empty() || colorAttachmentReferences.size() == resolveAttachmentReferences.size());
{
const VkSubpassDescription subpassDescription =
{
- subpass.getFlags(), // flags;
- subpass.getPipelineBindPoint(), // pipelineBindPoint;
+ subpass.getFlags(), // flags;
+ subpass.getPipelineBindPoint(), // pipelineBindPoint;
- (deUint32)inputAttachmentReferences.size(), // inputCount;
- inputAttachmentReferences.empty() ? DE_NULL : &inputAttachmentReferences[0], // inputAttachments;
+ (deUint32)inputAttachmentReferences.size(), // inputCount;
+ inputAttachmentReferences.empty() ? DE_NULL : &inputAttachmentReferences[0], // inputAttachments;
- (deUint32)colorAttachmentReferences.size(), // colorCount;
- colorAttachmentReferences.empty() ? DE_NULL : &colorAttachmentReferences[0], // colorAttachments;
- resolveAttachmentReferences.empty() ? DE_NULL : &resolveAttachmentReferences[0], // resolveAttachments;
+ (deUint32)colorAttachmentReferences.size(), // colorCount;
+ colorAttachmentReferences.empty() ? DE_NULL : &colorAttachmentReferences[0], // colorAttachments;
+ resolveAttachmentReferences.empty() ? DE_NULL : &resolveAttachmentReferences[0], // resolveAttachments;
- &depthStencilAttachmentReferences[0], // pDepthStencilAttachment;
- (deUint32)preserveAttachmentReferences.size(), // preserveCount;
- preserveAttachmentReferences.empty() ? DE_NULL : &preserveAttachmentReferences[0] // preserveAttachments;
+ &depthStencilAttachmentReferences[0], // pDepthStencilAttachment;
+ (deUint32)preserveAttachmentReferences->size(), // preserveCount;
+ preserveAttachmentReferences->empty() ? DE_NULL : &(*preserveAttachmentReferences)[0] // preserveAttachments;
};
return subpassDescription;
VkDevice device,
const RenderPass& renderPassInfo)
{
- const size_t perSubpassAttachmentReferenceLists = 5;
+ const size_t perSubpassAttachmentReferenceLists = 4;
vector<VkAttachmentDescription> attachments;
vector<VkSubpassDescription> subpasses;
vector<VkSubpassDependency> dependencies;
vector<vector<VkAttachmentReference> > attachmentReferenceLists(renderPassInfo.getSubpasses().size() * perSubpassAttachmentReferenceLists);
+ vector<vector<deUint32> > preserveAttachments(renderPassInfo.getSubpasses().size());
for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
attachments.push_back(createAttachmentDescription(renderPassInfo.getAttachments()[attachmentNdx]));
for (size_t subpassNdx = 0; subpassNdx < renderPassInfo.getSubpasses().size(); subpassNdx++)
- subpasses.push_back(createSubpassDescription(renderPassInfo.getSubpasses()[subpassNdx], &(attachmentReferenceLists[subpassNdx * perSubpassAttachmentReferenceLists])));
+ subpasses.push_back(createSubpassDescription(renderPassInfo.getSubpasses()[subpassNdx], &(attachmentReferenceLists[subpassNdx * perSubpassAttachmentReferenceLists]), &preserveAttachments[subpassNdx]));
for (size_t depNdx = 0; depNdx < renderPassInfo.getDependencies().size(); depNdx++)
dependencies.push_back(createSubpassDependency(renderPassInfo.getDependencies()[depNdx]));
VkImageUsageFlags usageFlags,
VkImageLayout layout)
{
- const VkExtent3D size_ = { (deInt32)size.x(), (deInt32)size.y(), 1 };
+ const VkExtent3D size_ = { size.x(), size.y(), 1u };
VkImageUsageFlags targetUsageFlags = 0;
const tcu::TextureFormat textureFormat = mapVkFormat(format);
const VkRect2D scissor =
{
{ (deInt32)renderInfo.getViewportOffset().x(), (deInt32)renderInfo.getViewportOffset().y() },
- { (deInt32)renderInfo.getViewportSize().x(), (deInt32)renderInfo.getViewportSize().y() }
+ { renderInfo.getViewportSize().x(), renderInfo.getViewportSize().y() }
};
const VkPipelineViewportStateCreateInfo viewportState =
{
{
{
{ (deInt32)colorClear.getOffset().x(), (deInt32)colorClear.getOffset().y() },
- { (deInt32)colorClear.getSize().x(), (deInt32)colorClear.getSize().y() }
+ { colorClear.getSize().x(), colorClear.getSize().y() }
}, // rect
0u, // baseArrayLayer
1u, // layerCount
{
{
{ (deInt32)depthStencilClear.getOffset().x(), (deInt32)depthStencilClear.getOffset().y() },
- { (deInt32)depthStencilClear.getSize().x(), (deInt32)depthStencilClear.getSize().y() }
+ { depthStencilClear.getSize().x(), depthStencilClear.getSize().y() }
}, // rect
0u, // baseArrayLayer
1u, // layerCount
}
if (!initializeLayouts.empty())
- {
- vector<VkImageMemoryBarrier*> initializeLayoutPtrs;
-
- for (size_t ndx = 0; ndx < initializeLayouts.size(); ndx++)
- initializeLayoutPtrs.push_back(&initializeLayouts[ndx]);
-
- vk.cmdPipelineBarrier(commandBuffer, 0, 0, VK_FALSE, (deUint32)initializeLayouts.size(), (const void* const*)&initializeLayoutPtrs[0]);
- }
+ vk.cmdPipelineBarrier(commandBuffer, (VkPipelineStageFlags)0, (VkPipelineStageFlags)0, (VkDependencyFlags)0,
+ 0, (const VkMemoryBarrier*)DE_NULL,
+ 0, (const VkBufferMemoryBarrier*)DE_NULL,
+ (deUint32)initializeLayouts.size(), &initializeLayouts[0]);
}
for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
}
if (!renderPassLayouts.empty())
- {
- vector<VkImageMemoryBarrier*> renderPassLayoutPtrs;
-
- for (size_t ndx = 0; ndx < renderPassLayouts.size(); ndx++)
- renderPassLayoutPtrs.push_back(&renderPassLayouts[ndx]);
-
- vk.cmdPipelineBarrier(commandBuffer, 0, 0, VK_FALSE, (deUint32)renderPassLayouts.size(), (const void* const*)&renderPassLayoutPtrs[0]);
- }
+ vk.cmdPipelineBarrier(commandBuffer, 0, 0, (VkDependencyFlags)0,
+ 0, (const VkMemoryBarrier*)DE_NULL,
+ 0, (const VkBufferMemoryBarrier*)DE_NULL,
+ (deUint32)renderPassLayouts.size(), &renderPassLayouts[0]);
}
}
{
const VkRect2D renderArea =
{
- { (deInt32)renderPos.x(), (deInt32)renderPos.y() },
- { (deInt32)renderSize.x(), (deInt32)renderSize.y() }
+ { (deInt32)renderPos.x(), (deInt32)renderPos.y() },
+ { renderSize.x(), renderSize.y() }
};
for (size_t subpassNdx = 0; subpassNdx < subpassRenderers.size(); subpassNdx++)
}
if (!imageBarriers.empty())
- {
- vector<VkImageMemoryBarrier*> clearLayoutPtrs;
-
- for (size_t ndx = 0; ndx < imageBarriers.size(); ndx++)
- clearLayoutPtrs.push_back(&imageBarriers[ndx]);
-
- vk.cmdPipelineBarrier(commandBuffer, getAllPipelineStageFlags(),
- getAllPipelineStageFlags(),
- VK_FALSE, (deUint32)imageBarriers.size(), (const void* const*)&clearLayoutPtrs[0]);
- }
+ vk.cmdPipelineBarrier(commandBuffer,
+ getAllPipelineStageFlags(),
+ getAllPipelineStageFlags(),
+ (VkDependencyFlags)0,
+ 0, (const VkMemoryBarrier*)DE_NULL,
+ 0, (const VkBufferMemoryBarrier*)DE_NULL,
+ (deUint32)imageBarriers.size(), &imageBarriers[0]);
}
for (size_t attachmentNdx = 0; attachmentNdx < attachmentInfo.size(); attachmentNdx++)
1 // arraySize
},
{ 0, 0, 0 }, // imageOffset
- { (deInt32)targetSize.x(), (deInt32)targetSize.y(), 1 } // imageExtent
+ { targetSize.x(), targetSize.y(), 1u } // imageExtent
};
vk.cmdCopyImageToBuffer(commandBuffer, attachmentResources[attachmentNdx]->getImage(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, attachmentResources[attachmentNdx]->getBuffer(), 1, &rect);
1 // arraySize
},
{ 0, 0, 0 }, // imageOffset
- { (deInt32)targetSize.x(), (deInt32)targetSize.y(), 1 } // imageExtent
+ { targetSize.x(), targetSize.y(), 1u } // imageExtent
};
vk.cmdCopyImageToBuffer(commandBuffer, attachmentResources[attachmentNdx]->getImage(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, attachmentResources[attachmentNdx]->getSecondaryBuffer(), 1, &stencilRect);
}
if (!bufferBarriers.empty())
- {
- vector<VkBufferMemoryBarrier*> clearLayoutPtrs;
-
- for (size_t ndx = 0; ndx < bufferBarriers.size(); ndx++)
- clearLayoutPtrs.push_back(&bufferBarriers[ndx]);
-
- vk.cmdPipelineBarrier(commandBuffer, getAllPipelineStageFlags(),
- getAllPipelineStageFlags(),
- VK_FALSE, (deUint32)bufferBarriers.size(), (const void* const*)&clearLayoutPtrs[0]);
- }
+ vk.cmdPipelineBarrier(commandBuffer,
+ getAllPipelineStageFlags(),
+ getAllPipelineStageFlags(),
+ (VkDependencyFlags)0,
+ 0, (const VkMemoryBarrier*)DE_NULL,
+ (deUint32)bufferBarriers.size(), &bufferBarriers[0],
+ 0, (const VkImageMemoryBarrier*)DE_NULL);
}
}
if (pixelStatus.getColorStatus() == PixelStatus::STATUS_UNDEFINED)
{
+ const Vec4 minDiff = Vec4(1.0f) / (IVec4(1) << tcu::getTextureFormatMantissaBitDepth(format)).cast<float>();
const Vec4 minUvs = computeUvs(posA, posB, IVec2(x-1, y-1));
const Vec4 maxUvs = computeUvs(posA, posB, IVec2(x+1, y+1));
const bool softCheck = std::abs(x - posA.x()) <= 1 || std::abs(x - posB.x()) <= 1
const Vec4 resColor (result.getPixel(x, y));
- const Vec4 minRefColor = srgb ? tcu::linearToSRGB(valueMax * minUvs + valueMin * (Vec4(1.0f) - minUvs))
- : valueMax * minUvs + valueMin * (Vec4(1.0f) - minUvs) - threshold;
- const Vec4 maxRefColor = srgb ? tcu::linearToSRGB(valueMax * maxUvs + valueMin * (Vec4(1.0f) - maxUvs))
- : valueMax * maxUvs + valueMin * (Vec4(1.0f) - maxUvs) + threshold;
+ Vec4 minRefColor = srgb ? tcu::linearToSRGB(valueMax * minUvs + valueMin * (Vec4(1.0f) - minUvs))
+ : valueMax * minUvs + valueMin * (Vec4(1.0f) - minUvs) - threshold;
+ Vec4 maxRefColor = srgb ? tcu::linearToSRGB(valueMax * maxUvs + valueMin * (Vec4(1.0f) - maxUvs))
+ : valueMax * maxUvs + valueMin * (Vec4(1.0f) - maxUvs) + threshold;
+
+ // Take into account rounding and quantization
+ if (channelClass == tcu::TEXTURECHANNELCLASS_FLOATING_POINT)
+ {
+ minRefColor = tcu::min(minRefColor * (Vec4(1.0f) - minDiff), minRefColor * (Vec4(1.0f) + minDiff));
+ maxRefColor = tcu::max(maxRefColor * (Vec4(1.0f) - minDiff), maxRefColor * (Vec4(1.0f) + minDiff));
+ }
+ else
+ {
+ minRefColor = minRefColor - minDiff;
+ maxRefColor = maxRefColor + minDiff;
+ }
DE_ASSERT(minRefColor[0] <= maxRefColor[0]);
DE_ASSERT(minRefColor[1] <= maxRefColor[1]);
checkTextureFormatSupport(log, context.getInstanceInterface(), context.getPhysicalDevice(), config.renderPass.getAttachments());
{
+ const vk::VkPhysicalDeviceProperties properties = vk::getPhysicalDeviceProperties(context.getInstanceInterface(), context.getPhysicalDevice());
+
+ log << TestLog::Message << "Max color attachments: " << properties.limits.maxColorAttachments << TestLog::EndMessage;
+
+ for (size_t subpassNdx = 0; subpassNdx < renderPassInfo.getSubpasses().size(); subpassNdx++)
+ {
+ if (renderPassInfo.getSubpasses()[subpassNdx].getColorAttachments().size() > (size_t)properties.limits.maxColorAttachments)
+ TCU_THROW(NotSupportedError, "Subpass uses more than maxColorAttachments.");
+ }
+ }
+
+ {
const VkDevice device = context.getDevice();
const DeviceInterface& vk = context.getDeviceInterface();
const VkQueue queue = context.getUniversalQueue();
de::MovePtr<tcu::TestCaseGroup> createAttachmentTestCaseGroup (tcu::TestContext& testCtx)
{
- const deUint32 attachmentCounts[] = { 1, 3, 8 };
+ const deUint32 attachmentCounts[] = { 1, 3, 4, 8 };
const VkAttachmentLoadOp loadOps[] =
{
VK_ATTACHMENT_LOAD_OP_LOAD,
VK_ATTACHMENT_STORE_OP_DONT_CARE
};
- const VkImageLayout initialAndFinalLayouts[] =
+ const VkImageLayout initialAndFinalColorLayouts[] =
{
VK_IMAGE_LAYOUT_GENERAL,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
- VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
- VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
const VkAttachmentLoadOp loadOp = rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
const VkAttachmentStoreOp storeOp = rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
- const VkImageLayout initialLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalLayouts), DE_ARRAY_END(initialAndFinalLayouts));
- const VkImageLayout finalizeLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalLayouts), DE_ARRAY_END(initialAndFinalLayouts));
+ const VkImageLayout initialLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayouts), DE_ARRAY_END(initialAndFinalColorLayouts));
+ const VkImageLayout finalizeLayout = rng.choose<VkImageLayout>(DE_ARRAY_BEGIN(initialAndFinalColorLayouts), DE_ARRAY_END(initialAndFinalColorLayouts));
const VkAttachmentLoadOp stencilLoadOp = rng.choose<VkAttachmentLoadOp>(DE_ARRAY_BEGIN(loadOps), DE_ARRAY_END(loadOps));
const VkAttachmentStoreOp stencilStoreOp = rng.choose<VkAttachmentStoreOp>(DE_ARRAY_BEGIN(storeOps), DE_ARRAY_END(storeOps));
return vk::createBuffer(context.getDeviceInterface(), context.getDevice(), ¶ms);
}
-Move<vk::VkImage> createImage2D (Context& context, int width, int height, vk::VkFormat format, vk::VkImageTiling tiling, vk::VkImageUsageFlags usageFlags)
+Move<vk::VkImage> createImage2D (Context& context, deUint32 width, deUint32 height, vk::VkFormat format, vk::VkImageTiling tiling, vk::VkImageUsageFlags usageFlags)
{
const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
const vk::VkImageCreateInfo params =
0u, // flags
vk::VK_IMAGE_TYPE_2D, // imageType
format, // format
- { width, height, 1 }, // extent
+ { width, height, 1u }, // extent
1u, // mipLevels
1u, // arraySize
vk::VK_SAMPLE_COUNT_1_BIT, // samples
const PipelineProgram& program,
vk::VkRenderPass renderPass,
vk::VkPipelineLayout pipelineLayout,
- tcu::IVec2 renderSize)
+ tcu::UVec2 renderSize)
{
const vector<vk::VkPipelineShaderStageCreateInfo> shaderStageParams (getPipelineShaderStageCreateInfo(program));
const vector<vk::VkVertexInputAttributeDescription> vertexAttribParams (getVertexAttributeDescriptions(inputValues, inputLayout));
, m_program (context, spec)
, m_descriptorSetLayout (createDescriptorSetLayout(context, m_program.getStages()))
, m_pipelineLayout (createPipelineLayout(context, *m_descriptorSetLayout))
- , m_pipeline (createPipeline(context, spec.values.inputs, m_inputLayout, m_program, *m_renderPass, *m_pipelineLayout, tcu::IVec2(RENDER_WIDTH, RENDER_HEIGHT)))
+ , m_pipeline (createPipeline(context, spec.values.inputs, m_inputLayout, m_program, *m_renderPass, *m_pipelineLayout, tcu::UVec2(RENDER_WIDTH, RENDER_HEIGHT)))
, m_descriptorPool (createDescriptorPool(context))
, m_descriptorSet (allocateDescriptorSet(context, *m_descriptorPool, *m_descriptorSetLayout))
vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // sType
DE_NULL, // pNext
0u, // flags
- (vk::VkRenderPass)0, // renderPass
- 0u, // subpass
- (vk::VkFramebuffer)0, // framebuffer
- vk::VK_FALSE, // occlusionQueryEnable
- (vk::VkQueryControlFlags)0,
- (vk::VkQueryPipelineStatisticFlags)0
+ (const vk::VkCommandBufferInheritanceInfo*)DE_NULL,
};
VK_CHECK(vkd.beginCommandBuffer(*m_cmdBuffer, &beginInfo));
1u, // arraySize
} // subresourceRange
};
- const void* const barriers[] = { &vertFlushBarrier, &colorAttBarrier };
- vkd.cmdPipelineBarrier(*m_cmdBuffer, vk::VK_PIPELINE_STAGE_HOST_BIT, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
- DE_FALSE, (deUint32)DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vkd.cmdPipelineBarrier(*m_cmdBuffer, vk::VK_PIPELINE_STAGE_HOST_BIT, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, (vk::VkDependencyFlags)0,
+ 1, &vertFlushBarrier,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &colorAttBarrier);
}
{
1u, // arraySize
} // subresourceRange
};
- const void* const barriers[] = { &renderFinishBarrier };
- vkd.cmdPipelineBarrier(*m_cmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT,
- DE_FALSE, DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vkd.cmdPipelineBarrier(*m_cmdBuffer, vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 0, (const vk::VkBufferMemoryBarrier*)DE_NULL,
+ 1, &renderFinishBarrier);
}
{
0u, // offset
(vk::VkDeviceSize)(RENDER_WIDTH*RENDER_HEIGHT*4) // size
};
- const void* const barriers[] = { ©FinishBarrier };
- vkd.cmdPipelineBarrier(*m_cmdBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT,
- DE_FALSE, (deUint32)DE_LENGTH_OF_ARRAY(barriers), barriers);
+ vkd.cmdPipelineBarrier(*m_cmdBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, (vk::VkDependencyFlags)0,
+ 0, (const vk::VkMemoryBarrier*)DE_NULL,
+ 1, ©FinishBarrier,
+ 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
}
VK_CHECK(vkd.endCommandBuffer(*m_cmdBuffer));
DE_NULL,
0u, // waitSemaphoreCount
(const vk::VkSemaphore*)0, // pWaitSemaphores
+ (const vk::VkPipelineStageFlags*)DE_NULL,
1u,
&m_cmdBuffer.get(),
0u, // signalSemaphoreCount
deviceInfo.pNext = DE_NULL;
deviceInfo.queueCreateInfoCount = 1u;
deviceInfo.pQueueCreateInfos = &queueInfo;
- deviceInfo.enabledExtensionNameCount = 0u;
+ deviceInfo.enabledExtensionCount = 0u;
deviceInfo.ppEnabledExtensionNames = DE_NULL;
- deviceInfo.enabledLayerNameCount = 0u;
+ deviceInfo.enabledLayerCount = 0u;
deviceInfo.ppEnabledLayerNames = DE_NULL;
deviceInfo.pEnabledFeatures = &enabledFeatures;
class DefaultDevice
{
public:
- DefaultDevice (const PlatformInterface& vkPlatform, const tcu::CommandLine& cmdLine);
- ~DefaultDevice (void);
+ DefaultDevice (const PlatformInterface& vkPlatform, const tcu::CommandLine& cmdLine);
+ ~DefaultDevice (void);
- VkInstance getInstance (void) const { return *m_instance; }
- const InstanceInterface& getInstanceInterface (void) const { return m_instanceInterface; }
+ VkInstance getInstance (void) const { return *m_instance; }
+ const InstanceInterface& getInstanceInterface (void) const { return m_instanceInterface; }
- VkPhysicalDevice getPhysicalDevice (void) const { return m_physicalDevice; }
- const VkPhysicalDeviceFeatures& getDeviceFeatures (void) const { return m_deviceFeatures; }
- VkDevice getDevice (void) const { return *m_device; }
- const DeviceInterface& getDeviceInterface (void) const { return m_deviceInterface; }
- const VkPhysicalDeviceProperties& getDeviceProperties (void) const { return m_deviceProperties; }
+ VkPhysicalDevice getPhysicalDevice (void) const { return m_physicalDevice; }
+ const VkPhysicalDeviceFeatures& getDeviceFeatures (void) const { return m_deviceFeatures; }
+ VkDevice getDevice (void) const { return *m_device; }
+ const DeviceInterface& getDeviceInterface (void) const { return m_deviceInterface; }
+ const VkPhysicalDeviceProperties& getDeviceProperties (void) const { return m_deviceProperties; }
- deUint32 getUniversalQueueFamilyIndex (void) const { return m_universalQueueFamilyIndex; }
- VkQueue getUniversalQueue (void) const;
+ deUint32 getUniversalQueueFamilyIndex (void) const { return m_universalQueueFamilyIndex; }
+ VkQueue getUniversalQueue (void) const;
private:
- const Unique<VkInstance> m_instance;
- const InstanceDriver m_instanceInterface;
+ const Unique<VkInstance> m_instance;
+ const InstanceDriver m_instanceInterface;
- const VkPhysicalDevice m_physicalDevice;
+ const VkPhysicalDevice m_physicalDevice;
- const deUint32 m_universalQueueFamilyIndex;
- const VkPhysicalDeviceFeatures m_deviceFeatures;
+ const deUint32 m_universalQueueFamilyIndex;
+ const VkPhysicalDeviceFeatures m_deviceFeatures;
const VkPhysicalDeviceProperties m_deviceProperties;
- const Unique<VkDevice> m_device;
- const DeviceDriver m_deviceInterface;
+ const Unique<VkDevice> m_device;
+ const DeviceDriver m_deviceInterface;
};
DefaultDevice::DefaultDevice (const PlatformInterface& vkPlatform, const tcu::CommandLine& cmdLine)
--- /dev/null
+vk-default.txt
+com.drawelements.deqp.vk.xml
+mustpass.xml
{
public:
VulkanLibrary (void)
- : m_library ("vulkan-0.dll")
+ : m_library ("vulkan-1.dll")
, m_driver (m_library)
{
}
}
// Compare images
- const float threshold = 0.02f;
+ const float threshold = 0.03f;
bool imagesOk = tcu::fuzzyCompare(log, "ComparisonResult", "Image comparison result", refFrame, gles2Frame, threshold, tcu::COMPARE_LOG_RESULT);
if (!imagesOk && !failReason)
#
#-------------------------------------------------------------------------
-from build.common import *
+from build.common import DEQP_DIR
from build.config import ANY_GENERATOR
-from build.build import build
-from build_caselists import Module, getBuildConfig, genCaseList, getCaseListPath, DEFAULT_BUILD_DIR, DEFAULT_TARGET
-from fnmatch import fnmatch
-from copy import copy
+from build_caselists import Module, getModuleByName, getBuildConfig, DEFAULT_BUILD_DIR, DEFAULT_TARGET
+from mustpass import Project, Package, Mustpass, Configuration, include, exclude, genMustpassLists
-import xml.etree.cElementTree as ElementTree
-import xml.dom.minidom as minidom
-
-CTS_DATA_DIR = os.path.join(DEQP_DIR, "android", "cts")
-APK_NAME = "com.drawelements.deqp.apk"
+import os
COPYRIGHT_DECLARATION = """
Copyright (C) 2015 The Android Open Source Project
limitations under the License.
"""
-GENERATED_FILE_WARNING = """
- This file has been automatically generated. Edit with caution.
- """
-
-class Configuration:
- def __init__ (self, name, glconfig, rotation, surfacetype, filters):
- self.name = name
- self.glconfig = glconfig
- self.rotation = rotation
- self.surfacetype = surfacetype
- self.filters = filters
-
-class Package:
- def __init__ (self, module, configurations):
- self.module = module
- self.configurations = configurations
-
-class Mustpass:
- def __init__ (self, version, packages):
- self.version = version
- self.packages = packages
-
-class Filter:
- TYPE_INCLUDE = 0
- TYPE_EXCLUDE = 1
-
- def __init__ (self, type, filename):
- self.type = type
- self.filename = filename
-
-class TestRoot:
- def __init__ (self):
- self.children = []
-
-class TestGroup:
- def __init__ (self, name):
- self.name = name
- self.children = []
-
-class TestCase:
- def __init__ (self, name):
- self.name = name
- self.configurations = []
-
-class GLESVersion:
- def __init__(self, major, minor):
- self.major = major
- self.minor = minor
-
- def encode (self):
- return (self.major << 16) | (self.minor)
-
-def getModuleGLESVersion (module):
- versions = {
- 'dEQP-EGL': GLESVersion(2,0),
- 'dEQP-GLES2': GLESVersion(2,0),
- 'dEQP-GLES3': GLESVersion(3,0),
- 'dEQP-GLES31': GLESVersion(3,1)
- }
- return versions[module.name]
-
-def getSrcDir (mustpass):
- return os.path.join(CTS_DATA_DIR, mustpass.version, "src")
-
-def getTmpDir (mustpass):
- return os.path.join(CTS_DATA_DIR, mustpass.version, "tmp")
-
-def getModuleShorthand (module):
- assert module.name[:5] == "dEQP-"
- return module.name[5:].lower()
-
-def getCaseListFileName (package, configuration):
- return "%s-%s.txt" % (getModuleShorthand(package.module), configuration.name)
-
-def getDstCaseListPath (mustpass, package, configuration):
- return os.path.join(CTS_DATA_DIR, mustpass.version, getCaseListFileName(package, configuration))
-
-def getCTSPackageName (package):
- return "com.drawelements.deqp." + getModuleShorthand(package.module)
-
-def getCommandLine (config):
- return "--deqp-gl-config-name=%s --deqp-screen-rotation=%s --deqp-surface-type=%s --deqp-watchdog=enable" % (config.glconfig, config.rotation, config.surfacetype)
-
-def readCaseList (filename):
- cases = []
- with open(filename, 'rb') as f:
- for line in f:
- if line[:6] == "TEST: ":
- cases.append(line[6:].strip())
- return cases
-
-def getCaseList (buildCfg, generator, module):
- build(buildCfg, generator, [module.binName])
- genCaseList(buildCfg, generator, module, "txt")
- return readCaseList(getCaseListPath(buildCfg, module, "txt"))
-
-def readPatternList (filename):
- ptrns = []
- with open(filename, 'rb') as f:
- for line in f:
- line = line.strip()
- if len(line) > 0 and line[0] != '#':
- ptrns.append(line)
- return ptrns
-
-def applyPatterns (caseList, patterns, filename, op):
- matched = set()
- errors = []
- curList = copy(caseList)
- trivialPtrns = [p for p in patterns if p.find('*') < 0]
- regularPtrns = [p for p in patterns if p.find('*') >= 0]
-
- # Apply trivial (just case paths)
- allCasesSet = set(caseList)
- for path in trivialPtrns:
- if path in allCasesSet:
- if path in matched:
- errors.append((path, "Same case specified more than once"))
- matched.add(path)
- else:
- errors.append((path, "Test case not found"))
-
- curList = [c for c in curList if c not in matched]
-
- for pattern in regularPtrns:
- matchedThisPtrn = set()
-
- for case in curList:
- if fnmatch(case, pattern):
- matchedThisPtrn.add(case)
-
- if len(matchedThisPtrn) == 0:
- errors.append((pattern, "Pattern didn't match any cases"))
-
- matched = matched | matchedThisPtrn
- curList = [c for c in curList if c not in matched]
-
- for pattern, reason in errors:
- print "ERROR: %s: %s" % (reason, pattern)
-
- if len(errors) > 0:
- die("Found %s invalid patterns while processing file %s" % (len(errors), filename))
-
- return [c for c in caseList if op(c in matched)]
-
-def applyInclude (caseList, patterns, filename):
- return applyPatterns(caseList, patterns, filename, lambda b: b)
-
-def applyExclude (caseList, patterns, filename):
- return applyPatterns(caseList, patterns, filename, lambda b: not b)
-
-def readPatternLists (mustpass):
- lists = {}
- for package in mustpass.packages:
- for cfg in package.configurations:
- for filter in cfg.filters:
- if not filter.filename in lists:
- lists[filter.filename] = readPatternList(os.path.join(getSrcDir(mustpass), filter.filename))
- return lists
-
-def applyFilters (caseList, patternLists, filters):
- res = copy(caseList)
- for filter in filters:
- ptrnList = patternLists[filter.filename]
- if filter.type == Filter.TYPE_INCLUDE:
- res = applyInclude(res, ptrnList, filter.filename)
- else:
- assert filter.type == Filter.TYPE_EXCLUDE
- res = applyExclude(res, ptrnList, filter.filename)
- return res
-
-def appendToHierarchy (root, casePath):
- def findChild (node, name):
- for child in node.children:
- if child.name == name:
- return child
- return None
-
- curNode = root
- components = casePath.split('.')
-
- for component in components[:-1]:
- nextNode = findChild(curNode, component)
- if not nextNode:
- nextNode = TestGroup(component)
- curNode.children.append(nextNode)
- curNode = nextNode
-
- if not findChild(curNode, components[-1]):
- curNode.children.append(TestCase(components[-1]))
-
-def buildTestHierachy (caseList):
- root = TestRoot()
- for case in caseList:
- appendToHierarchy(root, case)
- return root
-
-def buildTestCaseMap (root):
- caseMap = {}
-
- def recursiveBuild (curNode, prefix):
- curPath = prefix + curNode.name
- if isinstance(curNode, TestCase):
- caseMap[curPath] = curNode
- else:
- for child in curNode.children:
- recursiveBuild(child, curPath + '.')
-
- for child in root.children:
- recursiveBuild(child, '')
-
- return caseMap
-
-def include (filename):
- return Filter(Filter.TYPE_INCLUDE, filename)
-
-def exclude (filename):
- return Filter(Filter.TYPE_EXCLUDE, filename)
-
-def prettifyXML (doc):
- doc.insert(0, ElementTree.Comment(COPYRIGHT_DECLARATION))
- doc.insert(1, ElementTree.Comment(GENERATED_FILE_WARNING))
- uglyString = ElementTree.tostring(doc, 'utf-8')
- reparsed = minidom.parseString(uglyString)
- return reparsed.toprettyxml(indent='\t', encoding='utf-8')
-
-def genCTSPackageXML (package, root):
- def isLeafGroup (testGroup):
- numGroups = 0
- numTests = 0
-
- for child in testGroup.children:
- if isinstance(child, TestCase):
- numTests += 1
- else:
- numGroups += 1
-
- assert numGroups + numTests > 0
-
- if numGroups > 0 and numTests > 0:
- die("Mixed groups and cases in %s" % testGroup.name)
-
- return numGroups == 0
-
- def makeConfiguration (parentElem, configuration):
- return ElementTree.SubElement(parentElem, "TestInstance", glconfig=configuration.glconfig, rotation=configuration.rotation, surfacetype=configuration.surfacetype)
-
- def makeTestCase (parentElem, testCase):
- caseElem = ElementTree.SubElement(parentElem, "Test", name=testCase.name)
- for config in testCase.configurations:
- makeConfiguration(caseElem, config)
- return caseElem
-
- def makeTestGroup (parentElem, testGroup):
- groupElem = ElementTree.SubElement(parentElem, "TestCase" if isLeafGroup(testGroup) else "TestSuite", name=testGroup.name)
- for child in testGroup.children:
- if isinstance(child, TestCase):
- makeTestCase(groupElem, child)
- else:
- makeTestGroup(groupElem, child)
- return groupElem
-
- pkgElem = ElementTree.Element("TestPackage",
- name = package.module.name,
- appPackageName = getCTSPackageName(package),
- testType = "deqpTest")
-
- pkgElem.set("xmlns:deqp", "http://drawelements.com/deqp")
- pkgElem.set("deqp:glesVersion", str(getModuleGLESVersion(package.module).encode()))
-
- for child in root.children:
- makeTestGroup(pkgElem, child)
-
- return pkgElem
-
-def genSpecXML (mustpass):
- mustpassElem = ElementTree.Element("Mustpass", version = mustpass.version)
-
- for package in mustpass.packages:
- packageElem = ElementTree.SubElement(mustpassElem, "TestPackage", name = package.module.name)
-
- for config in package.configurations:
- configElem = ElementTree.SubElement(packageElem, "Configuration",
- name = config.name,
- caseListFile = getCaseListFileName(package, config),
- commandLine = getCommandLine(config))
-
- return mustpassElem
-
-def addOptionElement (parent, optionName, optionValue):
- ElementTree.SubElement(parent, "option", name=optionName, value=optionValue)
-
-def genAndroidTestXml (mustpass):
- INSTALLER_CLASS = "com.android.compatibility.common.tradefed.targetprep.ApkInstaller"
- RUNNER_CLASS = "com.drawelements.deqp.runner.DeqpTestRunner"
- configElement = ElementTree.Element("configuration")
- preparerElement = ElementTree.SubElement(configElement, "target_preparer")
- preparerElement.set("class", INSTALLER_CLASS)
- addOptionElement(preparerElement, "cleanup-apks", "true")
- addOptionElement(preparerElement, "test-file-name", APK_NAME)
-
- for package in mustpass.packages:
- for config in package.configurations:
- testElement = ElementTree.SubElement(configElement, "test")
- testElement.set("class", RUNNER_CLASS)
- addOptionElement(testElement, "deqp-package", package.module.name)
- addOptionElement(testElement, "deqp-caselist-file", getCaseListFileName(package,config))
- # \todo [2015-10-16 kalle]: Replace with just command line? - requires simplifications in the runner/tests as well.
- addOptionElement(testElement, "deqp-gl-config-name", config.glconfig)
- addOptionElement(testElement, "deqp-surface-type", config.surfacetype)
- addOptionElement(testElement, "deqp-screen-rotation", config.rotation)
-
- return configElement
-
-
-def genMustpass (mustpass, moduleCaseLists):
- print "Generating mustpass '%s'" % mustpass.version
-
- patternLists = readPatternLists(mustpass)
-
- for package in mustpass.packages:
- allCasesInPkg = moduleCaseLists[package.module]
- matchingByConfig = {}
- allMatchingSet = set()
+CTS_DATA_DIR = os.path.join(DEQP_DIR, "android", "cts")
- for config in package.configurations:
- filtered = applyFilters(allCasesInPkg, patternLists, config.filters)
- dstFile = getDstCaseListPath(mustpass, package, config)
+CTS_PROJECT = Project(path = CTS_DATA_DIR, copyright = COPYRIGHT_DECLARATION)
- print " Writing deqp caselist: " + dstFile
- writeFile(dstFile, "\n".join(filtered) + "\n")
-
- matchingByConfig[config] = filtered
- allMatchingSet = allMatchingSet | set(filtered)
-
- allMatchingCases = [c for c in allCasesInPkg if c in allMatchingSet] # To preserve ordering
- root = buildTestHierachy(allMatchingCases)
- testCaseMap = buildTestCaseMap(root)
-
- for config in package.configurations:
- for case in matchingByConfig[config]:
- testCaseMap[case].configurations.append(config)
-
- # NOTE: CTS v2 does not need package XML files. Remove when transition is complete.
- packageXml = genCTSPackageXML(package, root)
- xmlFilename = os.path.join(CTS_DATA_DIR, mustpass.version, getCTSPackageName(package) + ".xml")
-
- print " Writing CTS caselist: " + xmlFilename
- writeFile(xmlFilename, prettifyXML(packageXml))
-
- specXML = genSpecXML(mustpass)
- specFilename = os.path.join(CTS_DATA_DIR, mustpass.version, "mustpass.xml")
-
- print " Writing spec: " + specFilename
- writeFile(specFilename, prettifyXML(specXML))
-
- # TODO: Which is the best selector mechanism?
- if (mustpass.version == "mnc"):
- androidTestXML = genAndroidTestXml(mustpass)
- androidTestFilename = os.path.join(CTS_DATA_DIR, "AndroidTest.xml")
-
- print " Writing AndroidTest.xml: " + androidTestFilename
- writeFile(androidTestFilename, prettifyXML(androidTestXML))
-
- print "Done!"
-
-def genMustpassLists (mustpassLists, generator, buildCfg):
- moduleCaseLists = {}
-
- # Getting case lists involves invoking build, so we want to cache the results
- for mustpass in mustpassLists:
- for package in mustpass.packages:
- if not package.module in moduleCaseLists:
- moduleCaseLists[package.module] = getCaseList(buildCfg, generator, package.module)
-
- for mustpass in mustpassLists:
- genMustpass(mustpass, moduleCaseLists)
-
-EGL_MODULE = Module(name = "dEQP-EGL", dirName = "egl", binName = "deqp-egl")
-GLES2_MODULE = Module(name = "dEQP-GLES2", dirName = "gles2", binName = "deqp-gles2")
-GLES3_MODULE = Module(name = "dEQP-GLES3", dirName = "gles3", binName = "deqp-gles3")
-GLES31_MODULE = Module(name = "dEQP-GLES31", dirName = "gles31", binName = "deqp-gles31")
+EGL_MODULE = getModuleByName("dEQP-EGL")
+GLES2_MODULE = getModuleByName("dEQP-GLES2")
+GLES3_MODULE = getModuleByName("dEQP-GLES3")
+GLES31_MODULE = getModuleByName("dEQP-GLES31")
+VULKAN_MODULE = getModuleByName("dEQP-VK")
# Lollipop
])
MUSTPASS_LISTS = [
- Mustpass(version = "lmp", packages = [LMP_GLES3_PKG, LMP_GLES31_PKG]),
- Mustpass(version = "lmp-mr1", packages = [LMP_MR1_GLES3_PKG, LMP_MR1_GLES31_PKG]),
- Mustpass(version = "mnc", packages = [MNC_EGL_PKG, MNC_GLES2_PKG, MNC_GLES3_PKG, MNC_GLES31_PKG]),
- Mustpass(version = "master", packages = [MASTER_EGL_PKG, MASTER_GLES2_PKG, MASTER_GLES3_PKG, MASTER_GLES31_PKG])
+ Mustpass(project = CTS_PROJECT, version = "lmp", packages = [LMP_GLES3_PKG, LMP_GLES31_PKG]),
+ Mustpass(project = CTS_PROJECT, version = "lmp-mr1", packages = [LMP_MR1_GLES3_PKG, LMP_MR1_GLES31_PKG]),
+ Mustpass(project = CTS_PROJECT, version = "mnc", packages = [MNC_EGL_PKG, MNC_GLES2_PKG, MNC_GLES3_PKG, MNC_GLES31_PKG]),
+ Mustpass(project = CTS_PROJECT, version = "master", packages = [MASTER_EGL_PKG, MASTER_GLES2_PKG, MASTER_GLES3_PKG, MASTER_GLES31_PKG])
]
+BUILD_CONFIG = getBuildConfig(DEFAULT_BUILD_DIR, DEFAULT_TARGET, "Debug")
+
if __name__ == "__main__":
- genMustpassLists(MUSTPASS_LISTS, ANY_GENERATOR, getBuildConfig(DEFAULT_BUILD_DIR, DEFAULT_TARGET, "Debug"))
+ genMustpassLists(MUSTPASS_LISTS, ANY_GENERATOR, BUILD_CONFIG)
--- /dev/null
+# -*- coding: utf-8 -*-
+
+#-------------------------------------------------------------------------
+# drawElements Quality Program utilities
+# --------------------------------------
+#
+# Copyright 2016 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+#-------------------------------------------------------------------------
+
+from build.common import *
+from build.config import ANY_GENERATOR
+from build.build import build
+from build_caselists import Module, getModuleByName, getBuildConfig, genCaseList, getCaseListPath, DEFAULT_BUILD_DIR, DEFAULT_TARGET
+from fnmatch import fnmatch
+from copy import copy
+
+import xml.etree.cElementTree as ElementTree
+import xml.dom.minidom as minidom
+
+APK_NAME = "com.drawelements.deqp.apk"
+
+GENERATED_FILE_WARNING = """
+ This file has been automatically generated. Edit with caution.
+ """
+
+class Project:
+ def __init__ (self, path, copyright = None):
+ self.path = path
+ self.copyright = copyright
+
+class Configuration:
+ def __init__ (self, name, filters, glconfig = None, rotation = None, surfacetype = None):
+ self.name = name
+ self.glconfig = glconfig
+ self.rotation = rotation
+ self.surfacetype = surfacetype
+ self.filters = filters
+
+class Package:
+ def __init__ (self, module, configurations):
+ self.module = module
+ self.configurations = configurations
+
+class Mustpass:
+ def __init__ (self, project, version, packages):
+ self.project = project
+ self.version = version
+ self.packages = packages
+
+class Filter:
+ TYPE_INCLUDE = 0
+ TYPE_EXCLUDE = 1
+
+ def __init__ (self, type, filename):
+ self.type = type
+ self.filename = filename
+
+class TestRoot:
+ def __init__ (self):
+ self.children = []
+
+class TestGroup:
+ def __init__ (self, name):
+ self.name = name
+ self.children = []
+
+class TestCase:
+ def __init__ (self, name):
+ self.name = name
+ self.configurations = []
+
+class GLESVersion:
+ def __init__(self, major, minor):
+ self.major = major
+ self.minor = minor
+
+ def encode (self):
+ return (self.major << 16) | (self.minor)
+
+def getModuleGLESVersion (module):
+ versions = {
+ 'dEQP-EGL': GLESVersion(2,0),
+ 'dEQP-GLES2': GLESVersion(2,0),
+ 'dEQP-GLES3': GLESVersion(3,0),
+ 'dEQP-GLES31': GLESVersion(3,1)
+ }
+ return versions[module.name] if module.name in versions else None
+
+def getSrcDir (mustpass):
+ return os.path.join(mustpass.project.path, mustpass.version, "src")
+
+def getTmpDir (mustpass):
+ return os.path.join(mustpass.project.path, mustpass.version, "tmp")
+
+def getModuleShorthand (module):
+ assert module.name[:5] == "dEQP-"
+ return module.name[5:].lower()
+
+def getCaseListFileName (package, configuration):
+ return "%s-%s.txt" % (getModuleShorthand(package.module), configuration.name)
+
+def getDstCaseListPath (mustpass, package, configuration):
+ return os.path.join(mustpass.project.path, mustpass.version, getCaseListFileName(package, configuration))
+
+def getCTSPackageName (package):
+ return "com.drawelements.deqp." + getModuleShorthand(package.module)
+
+def getCommandLine (config):
+ cmdLine = ""
+
+ if config.glconfig != None:
+ cmdLine += "--deqp-gl-config-name=%s " % config.glconfig
+
+ if config.rotation != None:
+ cmdLine += "--deqp-screen-rotation=%s " % config.rotation
+
+ if config.surfacetype != None:
+ cmdLine += "--deqp-surface-type=%s " % config.surfacetype
+
+ cmdLine += "--deqp-watchdog=enable"
+
+ return cmdLine
+
+def readCaseList (filename):
+ cases = []
+ with open(filename, 'rb') as f:
+ for line in f:
+ if line[:6] == "TEST: ":
+ cases.append(line[6:].strip())
+ return cases
+
+def getCaseList (buildCfg, generator, module):
+ build(buildCfg, generator, [module.binName])
+ genCaseList(buildCfg, generator, module, "txt")
+ return readCaseList(getCaseListPath(buildCfg, module, "txt"))
+
+def readPatternList (filename):
+ ptrns = []
+ with open(filename, 'rb') as f:
+ for line in f:
+ line = line.strip()
+ if len(line) > 0 and line[0] != '#':
+ ptrns.append(line)
+ return ptrns
+
+def applyPatterns (caseList, patterns, filename, op):
+ matched = set()
+ errors = []
+ curList = copy(caseList)
+ trivialPtrns = [p for p in patterns if p.find('*') < 0]
+ regularPtrns = [p for p in patterns if p.find('*') >= 0]
+
+ # Apply trivial (just case paths)
+ allCasesSet = set(caseList)
+ for path in trivialPtrns:
+ if path in allCasesSet:
+ if path in matched:
+ errors.append((path, "Same case specified more than once"))
+ matched.add(path)
+ else:
+ errors.append((path, "Test case not found"))
+
+ curList = [c for c in curList if c not in matched]
+
+ for pattern in regularPtrns:
+ matchedThisPtrn = set()
+
+ for case in curList:
+ if fnmatch(case, pattern):
+ matchedThisPtrn.add(case)
+
+ if len(matchedThisPtrn) == 0:
+ errors.append((pattern, "Pattern didn't match any cases"))
+
+ matched = matched | matchedThisPtrn
+ curList = [c for c in curList if c not in matched]
+
+ for pattern, reason in errors:
+ print "ERROR: %s: %s" % (reason, pattern)
+
+ if len(errors) > 0:
+ die("Found %s invalid patterns while processing file %s" % (len(errors), filename))
+
+ return [c for c in caseList if op(c in matched)]
+
+def applyInclude (caseList, patterns, filename):
+ return applyPatterns(caseList, patterns, filename, lambda b: b)
+
+def applyExclude (caseList, patterns, filename):
+ return applyPatterns(caseList, patterns, filename, lambda b: not b)
+
+def readPatternLists (mustpass):
+ lists = {}
+ for package in mustpass.packages:
+ for cfg in package.configurations:
+ for filter in cfg.filters:
+ if not filter.filename in lists:
+ lists[filter.filename] = readPatternList(os.path.join(getSrcDir(mustpass), filter.filename))
+ return lists
+
+def applyFilters (caseList, patternLists, filters):
+ res = copy(caseList)
+ for filter in filters:
+ ptrnList = patternLists[filter.filename]
+ if filter.type == Filter.TYPE_INCLUDE:
+ res = applyInclude(res, ptrnList, filter.filename)
+ else:
+ assert filter.type == Filter.TYPE_EXCLUDE
+ res = applyExclude(res, ptrnList, filter.filename)
+ return res
+
+def appendToHierarchy (root, casePath):
+ def findChild (node, name):
+ for child in node.children:
+ if child.name == name:
+ return child
+ return None
+
+ curNode = root
+ components = casePath.split('.')
+
+ for component in components[:-1]:
+ nextNode = findChild(curNode, component)
+ if not nextNode:
+ nextNode = TestGroup(component)
+ curNode.children.append(nextNode)
+ curNode = nextNode
+
+ if not findChild(curNode, components[-1]):
+ curNode.children.append(TestCase(components[-1]))
+
+def buildTestHierachy (caseList):
+ root = TestRoot()
+ for case in caseList:
+ appendToHierarchy(root, case)
+ return root
+
+def buildTestCaseMap (root):
+ caseMap = {}
+
+ def recursiveBuild (curNode, prefix):
+ curPath = prefix + curNode.name
+ if isinstance(curNode, TestCase):
+ caseMap[curPath] = curNode
+ else:
+ for child in curNode.children:
+ recursiveBuild(child, curPath + '.')
+
+ for child in root.children:
+ recursiveBuild(child, '')
+
+ return caseMap
+
+def include (filename):
+ return Filter(Filter.TYPE_INCLUDE, filename)
+
+def exclude (filename):
+ return Filter(Filter.TYPE_EXCLUDE, filename)
+
+def insertXMLHeaders (mustpass, doc):
+ if mustpass.project.copyright != None:
+ doc.insert(0, ElementTree.Comment(mustpass.project.copyright))
+ doc.insert(1, ElementTree.Comment(GENERATED_FILE_WARNING))
+
+def prettifyXML (doc):
+ uglyString = ElementTree.tostring(doc, 'utf-8')
+ reparsed = minidom.parseString(uglyString)
+ return reparsed.toprettyxml(indent='\t', encoding='utf-8')
+
+def genCTSPackageXML (mustpass, package, root):
+ def isLeafGroup (testGroup):
+ numGroups = 0
+ numTests = 0
+
+ for child in testGroup.children:
+ if isinstance(child, TestCase):
+ numTests += 1
+ else:
+ numGroups += 1
+
+ assert numGroups + numTests > 0
+
+ if numGroups > 0 and numTests > 0:
+ die("Mixed groups and cases in %s" % testGroup.name)
+
+ return numGroups == 0
+
+ def makeConfiguration (parentElem, config):
+ attributes = {}
+
+ if config.glconfig != None:
+ attributes['glconfig'] = config.glconfig
+
+ if config.rotation != None:
+ attributes['rotation'] = config.rotation
+
+ if config.surfacetype != None:
+ attributes['surfacetype'] = config.surfacetype
+
+ return ElementTree.SubElement(parentElem, "TestInstance", attributes)
+
+ def makeTestCase (parentElem, testCase):
+ caseElem = ElementTree.SubElement(parentElem, "Test", name=testCase.name)
+ for config in testCase.configurations:
+ makeConfiguration(caseElem, config)
+ return caseElem
+
+ def makeTestGroup (parentElem, testGroup):
+ groupElem = ElementTree.SubElement(parentElem, "TestCase" if isLeafGroup(testGroup) else "TestSuite", name=testGroup.name)
+ for child in testGroup.children:
+ if isinstance(child, TestCase):
+ makeTestCase(groupElem, child)
+ else:
+ makeTestGroup(groupElem, child)
+ return groupElem
+
+ pkgElem = ElementTree.Element("TestPackage",
+ name = package.module.name,
+ appPackageName = getCTSPackageName(package),
+ testType = "deqpTest")
+
+ pkgElem.set("xmlns:deqp", "http://drawelements.com/deqp")
+ insertXMLHeaders(mustpass, pkgElem)
+
+ glesVersion = getModuleGLESVersion(package.module)
+
+ if glesVersion != None:
+ pkgElem.set("deqp:glesVersion", str(glesVersion.encode()))
+
+ for child in root.children:
+ makeTestGroup(pkgElem, child)
+
+ return pkgElem
+
+def genSpecXML (mustpass):
+ mustpassElem = ElementTree.Element("Mustpass", version = mustpass.version)
+ insertXMLHeaders(mustpass, mustpassElem)
+
+ for package in mustpass.packages:
+ packageElem = ElementTree.SubElement(mustpassElem, "TestPackage", name = package.module.name)
+
+ for config in package.configurations:
+ configElem = ElementTree.SubElement(packageElem, "Configuration",
+ name = config.name,
+ caseListFile = getCaseListFileName(package, config),
+ commandLine = getCommandLine(config))
+
+ return mustpassElem
+
+def addOptionElement (parent, optionName, optionValue):
+ ElementTree.SubElement(parent, "option", name=optionName, value=optionValue)
+
+def genAndroidTestXml (mustpass):
+ INSTALLER_CLASS = "com.android.compatibility.common.tradefed.targetprep.ApkInstaller"
+ RUNNER_CLASS = "com.drawelements.deqp.runner.DeqpTestRunner"
+ configElement = ElementTree.Element("configuration")
+ preparerElement = ElementTree.SubElement(configElement, "target_preparer")
+ preparerElement.set("class", INSTALLER_CLASS)
+ addOptionElement(preparerElement, "cleanup-apks", "true")
+ addOptionElement(preparerElement, "test-file-name", APK_NAME)
+
+ for package in mustpass.packages:
+ for config in package.configurations:
+ testElement = ElementTree.SubElement(configElement, "test")
+ testElement.set("class", RUNNER_CLASS)
+ addOptionElement(testElement, "deqp-package", package.module.name)
+ addOptionElement(testElement, "deqp-caselist-file", getCaseListFileName(package,config))
+ # \todo [2015-10-16 kalle]: Replace with just command line? - requires simplifications in the runner/tests as well.
+ if config.glconfig != None:
+ addOptionElement(testElement, "deqp-gl-config-name", config.glconfig)
+
+ if config.surfacetype != None:
+ addOptionElement(testElement, "deqp-surface-type", config.surfacetype)
+
+ if config.rotation != None:
+ addOptionElement(testElement, "deqp-screen-rotation", config.rotation)
+
+ insertXMLHeaders(mustpass, configElement)
+
+ return configElement
+
+def genMustpass (mustpass, moduleCaseLists):
+ print "Generating mustpass '%s'" % mustpass.version
+
+ patternLists = readPatternLists(mustpass)
+
+ for package in mustpass.packages:
+ allCasesInPkg = moduleCaseLists[package.module]
+ matchingByConfig = {}
+ allMatchingSet = set()
+
+ for config in package.configurations:
+ filtered = applyFilters(allCasesInPkg, patternLists, config.filters)
+ dstFile = getDstCaseListPath(mustpass, package, config)
+
+ print " Writing deqp caselist: " + dstFile
+ writeFile(dstFile, "\n".join(filtered) + "\n")
+
+ matchingByConfig[config] = filtered
+ allMatchingSet = allMatchingSet | set(filtered)
+
+ allMatchingCases = [c for c in allCasesInPkg if c in allMatchingSet] # To preserve ordering
+ root = buildTestHierachy(allMatchingCases)
+ testCaseMap = buildTestCaseMap(root)
+
+ for config in package.configurations:
+ for case in matchingByConfig[config]:
+ testCaseMap[case].configurations.append(config)
+
+ # NOTE: CTS v2 does not need package XML files. Remove when transition is complete.
+ packageXml = genCTSPackageXML(mustpass, package, root)
+ xmlFilename = os.path.join(mustpass.project.path, mustpass.version, getCTSPackageName(package) + ".xml")
+
+ print " Writing CTS caselist: " + xmlFilename
+ writeFile(xmlFilename, prettifyXML(packageXml))
+
+ specXML = genSpecXML(mustpass)
+ specFilename = os.path.join(mustpass.project.path, mustpass.version, "mustpass.xml")
+
+ print " Writing spec: " + specFilename
+ writeFile(specFilename, prettifyXML(specXML))
+
+ # TODO: Which is the best selector mechanism?
+ if (mustpass.version == "mnc"):
+ androidTestXML = genAndroidTestXml(mustpass)
+ androidTestFilename = os.path.join(mustpass.project.path, "AndroidTest.xml")
+
+ print " Writing AndroidTest.xml: " + androidTestFilename
+ writeFile(androidTestFilename, prettifyXML(androidTestXML))
+
+ print "Done!"
+
+def genMustpassLists (mustpassLists, generator, buildCfg):
+ moduleCaseLists = {}
+
+ # Getting case lists involves invoking build, so we want to cache the results
+ for mustpass in mustpassLists:
+ for package in mustpass.packages:
+ if not package.module in moduleCaseLists:
+ moduleCaseLists[package.module] = getCaseList(buildCfg, generator, package.module)
+
+ for mustpass in mustpassLists:
+ genMustpass(mustpass, moduleCaseLists)
projects / platform / upstream / VK-GL-CTS.git / commitdiff