Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / vulkan-validation-layers / 2ebc234580f41270585dfbbe2925358dd41b125e / . / tests / render_tests.cpp
blob: a4aad3f4bd764447993f6d9d167e38e3bcaf3e7c [file] [log] [blame]
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]1// Copyright 2005, Google Inc.
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are
6// met:
7//
8// * Redistributions of source code must retain the above copyright
9// notice, this list of conditions and the following disclaimer.
10// * Redistributions in binary form must reproduce the above
11// copyright notice, this list of conditions and the following disclaimer
12// in the documentation and/or other materials provided with the
13// distribution.
14// * Neither the name of Google Inc. nor the names of its
15// contributors may be used to endorse or promote products derived from
16// this software without specific prior written permission.
17//
18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]31// VK tests
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]32//
33// Copyright (C) 2014 LunarG, Inc.
34//
35// Permission is hereby granted, free of charge, to any person obtaining a
36// copy of this software and associated documentation files (the "Software"),
37// to deal in the Software without restriction, including without limitation
38// the rights to use, copy, modify, merge, publish, distribute, sublicense,
39// and/or sell copies of the Software, and to permit persons to whom the
40// Software is furnished to do so, subject to the following conditions:
41//
42// The above copyright notice and this permission notice shall be included
43// in all copies or substantial portions of the Software.
44//
45// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
46// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
47// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
48// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
49// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
50// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
51// DEALINGS IN THE SOFTWARE.
52
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]53// Basic rendering tests
54
55#include <stdlib.h>
56#include <stdio.h>
57#include <stdbool.h>
58#include <string.h>
Courtney Goeltzenleuchter76a643b2014-08-21 17:34:22 -0600[diff] [blame]59#include <iostream>
60#include <fstream>
61using namespace std;
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]62
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]63#include <vulkan.h>
Tobin Ehlis31446e52014-11-28 11:17:19 -0700[diff] [blame]64#ifdef DUMP_STATE_DOT
65#include "../layers/draw_state.h"
66#endif
Tobin Ehlis3c26a542014-11-18 11:28:33 -0700[diff] [blame]67#ifdef PRINT_OBJECTS
68#include "../layers/object_track.h"
69#endif
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700[diff] [blame]70#ifdef DEBUG_CALLBACK
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600[diff] [blame]71#include <vk_debug_report_lunarg.h>
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700[diff] [blame]72#endif
Courtney Goeltzenleuchter0abdb662015-10-07 13:28:58 -0600[diff] [blame]73#include "test_common.h"
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]74
Cody Northropd4e020a2015-03-17 14:54:35 -0600[diff] [blame]75#include "icd-spv.h"
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]76
Courtney Goeltzenleuchter34b81772014-10-10 18:04:39 -0600[diff] [blame]77#define GLM_FORCE_RADIANS
78#include "glm/glm.hpp"
79#include <glm/gtc/matrix_transform.hpp>
80
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]81#include "vkrenderframework.h"
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700[diff] [blame]82#ifdef DEBUG_CALLBACK
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]83void VKAPI myDbgFunc(
84 VK_DBG_MSG_TYPE msgType,
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]85 VkValidationLevel validationLevel,
Mike Stroyan230e6252015-04-17 12:36:38 -0600[diff] [blame]86 VkObject srcObject,
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]87 size_t location,
88 int32_t msgCode,
89 const char* pMsg,
90 void* pUserData)
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700[diff] [blame]91{
Tobin Ehlis3c26a542014-11-18 11:28:33 -0700[diff] [blame]92 switch (msgType)
93 {
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]94 case VK_DBG_MSG_WARNING:
Tobin Ehlis3c26a542014-11-18 11:28:33 -0700[diff] [blame]95 printf("CALLBACK WARNING : %s\n", pMsg);
96 break;
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600[diff] [blame]97 case VK_DBG_REPORT_ERROR_BIT:
Tobin Ehlis3c26a542014-11-18 11:28:33 -0700[diff] [blame]98 printf("CALLBACK ERROR : %s\n", pMsg);
99 break;
100 default:
101 printf("EATING Msg of type %u\n", msgType);
102 break;
103 }
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700[diff] [blame]104}
105#endif
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]106
107
108#undef ASSERT_NO_FATAL_FAILURE
109#define ASSERT_NO_FATAL_FAILURE(x) x
110
Courtney Goeltzenleuchtera948d842014-08-22 16:27:58 -0600[diff] [blame]111//--------------------------------------------------------------------------------------
112// Mesh and VertexFormat Data
113//--------------------------------------------------------------------------------------
114struct Vertex
115{
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]116 float posX, posY, posZ, posW; // Position data
117 float r, g, b, a; // Color
Courtney Goeltzenleuchtera948d842014-08-22 16:27:58 -0600[diff] [blame]118};
119
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]120struct VertexUV
121{
122 float posX, posY, posZ, posW; // Position data
123 float u, v; // texture u,v
124};
125
Courtney Goeltzenleuchtera948d842014-08-22 16:27:58 -0600[diff] [blame]126#define XYZ1(_x_, _y_, _z_) (_x_), (_y_), (_z_), 1.f
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]127#define UV(_u_, _v_) (_u_), (_v_)
Courtney Goeltzenleuchtera948d842014-08-22 16:27:58 -0600[diff] [blame]128
129static const Vertex g_vbData[] =
130{
131 { XYZ1( -1, -1, -1 ), XYZ1( 0.f, 0.f, 0.f ) },
132 { XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) },
133 { XYZ1( -1, 1, -1 ), XYZ1( 0.f, 1.f, 0.f ) },
134 { XYZ1( -1, 1, -1 ), XYZ1( 0.f, 1.f, 0.f ) },
135 { XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) },
136 { XYZ1( 1, 1, -1 ), XYZ1( 1.f, 1.f, 0.f ) },
137
138 { XYZ1( -1, -1, 1 ), XYZ1( 0.f, 0.f, 1.f ) },
139 { XYZ1( -1, 1, 1 ), XYZ1( 0.f, 1.f, 1.f ) },
140 { XYZ1( 1, -1, 1 ), XYZ1( 1.f, 0.f, 1.f ) },
141 { XYZ1( 1, -1, 1 ), XYZ1( 1.f, 0.f, 1.f ) },
142 { XYZ1( -1, 1, 1 ), XYZ1( 0.f, 1.f, 1.f ) },
143 { XYZ1( 1, 1, 1 ), XYZ1( 1.f, 1.f, 1.f ) },
144
145 { XYZ1( 1, 1, 1 ), XYZ1( 1.f, 1.f, 1.f ) },
146 { XYZ1( 1, 1, -1 ), XYZ1( 1.f, 1.f, 0.f ) },
147 { XYZ1( 1, -1, 1 ), XYZ1( 1.f, 0.f, 1.f ) },
148 { XYZ1( 1, -1, 1 ), XYZ1( 1.f, 0.f, 1.f ) },
149 { XYZ1( 1, 1, -1 ), XYZ1( 1.f, 1.f, 0.f ) },
150 { XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) },
151
152 { XYZ1( -1, 1, 1 ), XYZ1( 0.f, 1.f, 1.f ) },
153 { XYZ1( -1, -1, 1 ), XYZ1( 0.f, 0.f, 1.f ) },
154 { XYZ1( -1, 1, -1 ), XYZ1( 0.f, 1.f, 0.f ) },
155 { XYZ1( -1, 1, -1 ), XYZ1( 0.f, 1.f, 0.f ) },
156 { XYZ1( -1, -1, 1 ), XYZ1( 0.f, 0.f, 1.f ) },
157 { XYZ1( -1, -1, -1 ), XYZ1( 0.f, 0.f, 0.f ) },
158
159 { XYZ1( 1, 1, 1 ), XYZ1( 1.f, 1.f, 1.f ) },
160 { XYZ1( -1, 1, 1 ), XYZ1( 0.f, 1.f, 1.f ) },
161 { XYZ1( 1, 1, -1 ), XYZ1( 1.f, 1.f, 0.f ) },
162 { XYZ1( 1, 1, -1 ), XYZ1( 1.f, 1.f, 0.f ) },
163 { XYZ1( -1, 1, 1 ), XYZ1( 0.f, 1.f, 1.f ) },
164 { XYZ1( -1, 1, -1 ), XYZ1( 0.f, 1.f, 0.f ) },
165
166 { XYZ1( 1, -1, 1 ), XYZ1( 1.f, 0.f, 1.f ) },
167 { XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) },
168 { XYZ1( -1, -1, 1 ), XYZ1( 0.f, 0.f, 1.f ) },
169 { XYZ1( -1, -1, 1 ), XYZ1( 0.f, 0.f, 1.f ) },
170 { XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) },
171 { XYZ1( -1, -1, -1 ), XYZ1( 0.f, 0.f, 0.f ) },
172};
173
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]174static const Vertex g_vb_solid_face_colors_Data[] =
175{
176 { XYZ1( -1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) },
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]177 { XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) },
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]178 { XYZ1( -1, 1, -1 ), XYZ1( 1.f, 0.f, 0.f ) },
179 { XYZ1( -1, 1, -1 ), XYZ1( 1.f, 0.f, 0.f ) },
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]180 { XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) },
181 { XYZ1( 1, 1, -1 ), XYZ1( 1.f, 0.f, 0.f ) },
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]182
183 { XYZ1( -1, -1, 1 ), XYZ1( 0.f, 1.f, 0.f ) },
184 { XYZ1( -1, 1, 1 ), XYZ1( 0.f, 1.f, 0.f ) },
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]185 { XYZ1( 1, -1, 1 ), XYZ1( 0.f, 1.f, 0.f ) },
186 { XYZ1( 1, -1, 1 ), XYZ1( 0.f, 1.f, 0.f ) },
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]187 { XYZ1( -1, 1, 1 ), XYZ1( 0.f, 1.f, 0.f ) },
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]188 { XYZ1( 1, 1, 1 ), XYZ1( 0.f, 1.f, 0.f ) },
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]189
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]190 { XYZ1( 1, 1, 1 ), XYZ1( 0.f, 0.f, 1.f ) },
191 { XYZ1( 1, 1, -1 ), XYZ1( 0.f, 0.f, 1.f ) },
192 { XYZ1( 1, -1, 1 ), XYZ1( 0.f, 0.f, 1.f ) },
193 { XYZ1( 1, -1, 1 ), XYZ1( 0.f, 0.f, 1.f ) },
194 { XYZ1( 1, 1, -1 ), XYZ1( 0.f, 0.f, 1.f ) },
195 { XYZ1( 1, -1, -1 ), XYZ1( 0.f, 0.f, 1.f ) },
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]196
197 { XYZ1( -1, 1, 1 ), XYZ1( 1.f, 1.f, 0.f ) },
198 { XYZ1( -1, -1, 1 ), XYZ1( 1.f, 1.f, 0.f ) },
199 { XYZ1( -1, 1, -1 ), XYZ1( 1.f, 1.f, 0.f ) },
200 { XYZ1( -1, 1, -1 ), XYZ1( 1.f, 1.f, 0.f ) },
201 { XYZ1( -1, -1, 1 ), XYZ1( 1.f, 1.f, 0.f ) },
202 { XYZ1( -1, -1, -1 ), XYZ1( 1.f, 1.f, 0.f ) },
203
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]204 { XYZ1( 1, 1, 1 ), XYZ1( 1.f, 0.f, 1.f ) },
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]205 { XYZ1( -1, 1, 1 ), XYZ1( 1.f, 0.f, 1.f ) },
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]206 { XYZ1( 1, 1, -1 ), XYZ1( 1.f, 0.f, 1.f ) },
207 { XYZ1( 1, 1, -1 ), XYZ1( 1.f, 0.f, 1.f ) },
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]208 { XYZ1( -1, 1, 1 ), XYZ1( 1.f, 0.f, 1.f ) },
209 { XYZ1( -1, 1, -1 ), XYZ1( 1.f, 0.f, 1.f ) },
210
211 { XYZ1( 1, -1, 1 ), XYZ1( 0.f, 1.f, 1.f ) },
212 { XYZ1( 1, -1, -1 ), XYZ1( 0.f, 1.f, 1.f ) },
213 { XYZ1( -1, -1, 1 ), XYZ1( 0.f, 1.f, 1.f ) },
214 { XYZ1( -1, -1, 1 ), XYZ1( 0.f, 1.f, 1.f ) },
215 { XYZ1( 1, -1, -1 ), XYZ1( 0.f, 1.f, 1.f ) },
216 { XYZ1( -1, -1, -1 ), XYZ1( 0.f, 1.f, 1.f ) },
217};
218
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]219static const VertexUV g_vb_texture_Data[] =
220{
221 { XYZ1( -1, -1, -1 ), UV( 0.f, 0.f ) },
222 { XYZ1( -1, 1, 1 ), UV( 1.f, 1.f ) },
223 { XYZ1( -1, -1, 1 ), UV( 1.f, 0.f ) },
224 { XYZ1( -1, 1, 1 ), UV( 1.f, 1.f ) },
225 { XYZ1( -1, -1, -1 ), UV( 0.f, 0.f ) },
226 { XYZ1( -1, 1, -1 ), UV( 0.f, 1.f ) },
227
228 { XYZ1( -1, -1, -1 ), UV( 1.f, 0.f ) },
229 { XYZ1( 1, -1, -1 ), UV( 0.f, 0.f ) },
230 { XYZ1( 1, 1, -1 ), UV( 0.f, 1.f ) },
231 { XYZ1( -1, -1, -1 ), UV( 1.f, 0.f ) },
232 { XYZ1( 1, 1, -1 ), UV( 0.f, 1.f ) },
233 { XYZ1( -1, 1, -1 ), UV( 1.f, 1.f ) },
234
235 { XYZ1( -1, -1, -1 ), UV( 1.f, 1.f ) },
236 { XYZ1( 1, -1, 1 ), UV( 0.f, 0.f ) },
237 { XYZ1( 1, -1, -1 ), UV( 1.f, 0.f ) },
238 { XYZ1( -1, -1, -1 ), UV( 1.f, 1.f ) },
239 { XYZ1( -1, -1, 1 ), UV( 0.f, 1.f ) },
240 { XYZ1( 1, -1, 1 ), UV( 0.f, 0.f ) },
241
242 { XYZ1( -1, 1, -1 ), UV( 1.f, 1.f ) },
243 { XYZ1( 1, 1, 1 ), UV( 0.f, 0.f ) },
244 { XYZ1( -1, 1, 1 ), UV( 0.f, 1.f ) },
245 { XYZ1( -1, 1, -1 ), UV( 1.f, 1.f ) },
246 { XYZ1( 1, 1, -1 ), UV( 1.f, 0.f ) },
247 { XYZ1( 1, 1, 1 ), UV( 0.f, 0.f ) },
248
249 { XYZ1( 1, 1, -1 ), UV( 1.f, 1.f ) },
250 { XYZ1( 1, -1, 1 ), UV( 0.f, 0.f ) },
251 { XYZ1( 1, 1, 1 ), UV( 0.f, 1.f ) },
252 { XYZ1( 1, -1, 1 ), UV( 0.f, 0.f ) },
253 { XYZ1( 1, 1, -1 ), UV( 1.f, 1.f ) },
254 { XYZ1( 1, -1, -1 ), UV( 1.f, 0.f ) },
255
256 { XYZ1( -1, 1, 1 ), UV( 0.f, 1.f ) },
257 { XYZ1( 1, 1, 1 ), UV( 1.f, 1.f ) },
258 { XYZ1( -1, -1, 1 ), UV( 0.f, 0.f ) },
259 { XYZ1( -1, -1, 1 ), UV( 0.f, 0.f ) },
260 { XYZ1( 1, 1, 1 ), UV( 1.f, 1.f ) },
261 { XYZ1( 1, -1, 1 ), UV( 1.f, 0.f ) },
262};
263
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]264class VkRenderTest : public VkRenderFramework
Courtney Goeltzenleuchter28029792014-09-04 16:26:02 -0600[diff] [blame]265{
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]266public:
Cody Northrop4e6b4762014-10-09 21:25:22 -0600[diff] [blame]267
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]268 void RotateTriangleVSUniform(glm::mat4 Projection, glm::mat4 View, glm::mat4 Model,
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]269 VkConstantBufferObj *constantBuffer, VkCommandBufferObj *cmdBuffer);
270 void GenericDrawPreparation(VkCommandBufferObj *cmdBuffer, VkPipelineObj &pipelineobj, VkDescriptorSetObj &descriptorSet);
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]271 void GenericDrawPreparation(VkPipelineObj &pipelineobj, VkDescriptorSetObj &descriptorSet)
272 { GenericDrawPreparation(m_cmdBuffer, pipelineobj, descriptorSet); }
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]273 void InitDepthStencil();
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]274 void VKTriangleTest(const char *vertShaderText, const char *fragShaderText, const bool rotate);
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]275
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]276 VkResult BeginCommandBuffer(VkCommandBufferObj &cmdBuffer);
Tobin Ehlis7f7b4422015-08-18 14:24:32 -0600[diff] [blame]277 VkResult BeginCommandBuffer(VkCommandBufferObj &cmdBuffer, VkCmdBufferBeginInfo *beginInfo);
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]278 VkResult EndCommandBuffer(VkCommandBufferObj &cmdBuffer);
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]279 /* Convenience functions that use built-in command buffer */
280 VkResult BeginCommandBuffer() { return BeginCommandBuffer(*m_cmdBuffer); }
Tobin Ehlis7f7b4422015-08-18 14:24:32 -0600[diff] [blame]281 VkResult BeginCommandBuffer(VkCmdBufferBeginInfo *beginInfo) { return BeginCommandBuffer(*m_cmdBuffer, beginInfo); }
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]282 VkResult EndCommandBuffer() { return EndCommandBuffer(*m_cmdBuffer); }
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]283 void Draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
284 { m_cmdBuffer->Draw(vertexCount, instanceCount, firstVertex, firstInstance); }
285 void DrawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
286 { m_cmdBuffer->DrawIndexed(indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); }
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]287 void QueueCommandBuffer() { m_cmdBuffer->QueueCommandBuffer(); }
288 void RotateTriangleVSUniform(glm::mat4 Projection, glm::mat4 View, glm::mat4 Model,
289 VkConstantBufferObj *constantBuffer)
290 {RotateTriangleVSUniform(Projection, View, Model, constantBuffer, m_cmdBuffer); }
291 void BindVertexBuffer(VkConstantBufferObj *vertexBuffer, VkDeviceSize offset, uint32_t binding)
292 { m_cmdBuffer->BindVertexBuffer(vertexBuffer, offset, binding); }
293 void BindIndexBuffer(VkIndexBufferObj *indexBuffer, VkDeviceSize offset)
294 { m_cmdBuffer->BindIndexBuffer(indexBuffer, offset); }
295
296
Cody Northrop0dbe84f2014-10-09 19:55:56 -0600[diff] [blame]297
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]298protected:
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]299 VkImage m_texture;
300 VkImageView m_textureView;
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800[diff] [blame]301 VkDescriptorInfo m_descriptorInfo;
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]302 VkDeviceMemory m_textureMem;
Cody Northrop350727b2014-10-06 15:42:00 -0600[diff] [blame]303
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]304 VkSampler m_sampler;
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]305
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]306
307 virtual void SetUp() {
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]308
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]309 this->app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]310 this->app_info.pNext = NULL;
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]311 this->app_info.pAppName = "render_tests";
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]312 this->app_info.appVersion = 1;
Chia-I Wu7461fcf2014-12-27 15:16:07 +0800[diff] [blame]313 this->app_info.pEngineName = "unittest";
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]314 this->app_info.engineVersion = 1;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]315 this->app_info.apiVersion = VK_API_VERSION;
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]316
Chia-I Wu8cd8ecd2015-05-25 16:27:55 +0800[diff] [blame]317 memset(&m_descriptorInfo, 0, sizeof(m_descriptorInfo));
Cody Northrop350727b2014-10-06 15:42:00 -0600[diff] [blame]318
Courtney Goeltzenleuchtercb5a89c2014-10-08 12:20:26 -0600[diff] [blame]319 InitFramework();
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]320 }
321
322 virtual void TearDown() {
Courtney Goeltzenleuchtercb5a89c2014-10-08 12:20:26 -0600[diff] [blame]323 // Clean up resources before we reset
324 ShutdownFramework();
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]325 }
326};
327
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]328VkResult VkRenderTest::BeginCommandBuffer(VkCommandBufferObj &cmdBuffer)
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]329{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]330 VkResult result;
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]331
332 result = cmdBuffer.BeginCommandBuffer();
333
334 /*
335 * For render test all drawing happens in a single render pass
336 * on a single command buffer.
337 */
Chris Forbesfe133ef2015-06-16 14:05:59 +1200[diff] [blame]338 if (VK_SUCCESS == result && renderPass()) {
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]339 cmdBuffer.BeginRenderPass(renderPassBeginInfo());
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]340 }
341
342 return result;
343}
344
Tobin Ehlis7f7b4422015-08-18 14:24:32 -0600[diff] [blame]345VkResult VkRenderTest::BeginCommandBuffer(VkCommandBufferObj &cmdBuffer, VkCmdBufferBeginInfo *beginInfo)
346{
347 VkResult result;
348
349 result = cmdBuffer.BeginCommandBuffer(beginInfo);
350
351 /*
352 * For render test all drawing happens in a single render pass
353 * on a single command buffer.
354 */
355 if (VK_SUCCESS == result && renderPass()) {
356 cmdBuffer.BeginRenderPass(renderPassBeginInfo());
357 }
358
359 return result;
360}
361
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]362VkResult VkRenderTest::EndCommandBuffer(VkCommandBufferObj &cmdBuffer)
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]363{
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]364 VkResult result;
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]365
Chris Forbesfe133ef2015-06-16 14:05:59 +1200[diff] [blame]366 if (renderPass()) {
Chia-I Wu88eaa3b2015-06-26 15:34:39 +0800[diff] [blame]367 cmdBuffer.EndRenderPass();
Chris Forbesfe133ef2015-06-16 14:05:59 +1200[diff] [blame]368 }
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]369
370 result = cmdBuffer.EndCommandBuffer();
371
372 return result;
373}
374
375
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]376void VkRenderTest::GenericDrawPreparation(VkCommandBufferObj *cmdBuffer, VkPipelineObj &pipelineobj, VkDescriptorSetObj &descriptorSet)
Tony Barbour02472db2015-01-08 17:08:28 -0700[diff] [blame]377{
Tony Barbour6d841032015-07-21 17:00:26 -0600[diff] [blame]378 if (!m_clear_via_load_op) {
379 if (m_depthStencil->Initialized()) {
380 cmdBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, m_depthStencil);
381 } else {
382 cmdBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, NULL);
383 }
Tony Barbour17c6ab12015-03-27 17:03:18 -0600[diff] [blame]384 }
385
Jeremy Hayese0c3b222015-01-14 16:17:08 -0700[diff] [blame]386 cmdBuffer->PrepareAttachments();
Courtney Goeltzenleuchter932cdb52015-09-21 11:44:06 -0600[diff] [blame]387 cmdBuffer->SetViewport(m_viewports.size(), m_viewports.data());
388 cmdBuffer->SetScissor(m_scissors.size(), m_scissors.data());
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -0600[diff] [blame]389
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]390 descriptorSet.CreateVKDescriptorSet(cmdBuffer);
Cody Northropccfa96d2015-08-27 10:20:35 -0600[diff] [blame]391 VkResult err = pipelineobj.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass());
392 ASSERT_VK_SUCCESS(err);
Courtney Goeltzenleuchter8d49dbd2015-04-07 17:13:38 -0600[diff] [blame]393 cmdBuffer->BindPipeline(pipelineobj);
Chia-I Wu862c5572015-03-28 15:23:55 +0800[diff] [blame]394 cmdBuffer->BindDescriptorSet(descriptorSet);
Tony Barbour02472db2015-01-08 17:08:28 -0700[diff] [blame]395}
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]396
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]397void VkRenderTest::RotateTriangleVSUniform(glm::mat4 Projection, glm::mat4 View, glm::mat4 Model,
398 VkConstantBufferObj *constantBuffer, VkCommandBufferObj *cmdBuffer)
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]399{
400 int i;
401 glm::mat4 MVP;
402 int matrixSize = sizeof(MVP);
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]403 VkResult err;
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]404
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]405 /* Only do 3 positions to avoid back face cull */
406 for (i = 0; i < 3; i++) {
Chia-I Wuf4aed6c2015-07-03 13:44:34 +0800[diff] [blame]407 void *pData = constantBuffer->memory().map();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]408
409 Model = glm::rotate(Model, glm::radians(22.5f), glm::vec3(0.0f, 1.0f, 0.0f));
410 MVP = Projection * View * Model;
411 memcpy(pData, (const void*) &MVP[0][0], matrixSize);
412
Chia-I Wuf4aed6c2015-07-03 13:44:34 +0800[diff] [blame]413 constantBuffer->memory().unmap();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]414
415 // submit the command buffer to the universal queue
Courtney Goeltzenleuchter8d49dbd2015-04-07 17:13:38 -0600[diff] [blame]416 cmdBuffer->QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]417
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]418 err = vkQueueWaitIdle( m_device->m_queue );
419 ASSERT_VK_SUCCESS( err );
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]420
421 // Wait for work to finish before cleaning up.
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]422 vkDeviceWaitIdle(m_device->device());
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]423
Courtney Goeltzenleuchterdd745fd2015-03-05 16:47:18 -0700[diff] [blame]424 assert(m_renderTargets.size() == 1);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]425 RecordImage(m_renderTargets[0]);
426 }
427}
Courtney Goeltzenleuchter3c601d82014-10-13 13:03:31 -0600[diff] [blame]428
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]429void dumpMatrix(const char *note, glm::mat4 MVP)
430{
Chia-I Wu7133fdc2014-12-15 23:57:34 +0800[diff] [blame]431 int i;
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]432
433 printf("%s: \n", note);
434 for (i=0; i<4; i++) {
435 printf("%f, %f, %f, %f\n", MVP[i][0], MVP[i][1], MVP[i][2], MVP[i][3]);
436 }
437 printf("\n");
438 fflush(stdout);
439}
440
441void dumpVec4(const char *note, glm::vec4 vector)
442{
443 printf("%s: \n", note);
444 printf("%f, %f, %f, %f\n", vector[0], vector[1], vector[2], vector[3]);
445 printf("\n");
446 fflush(stdout);
447}
448
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]449struct vktriangle_vs_uniform {
Courtney Goeltzenleuchter7bbb4202014-10-24 16:26:12 -0600[diff] [blame]450 // Must start with MVP
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]451 float mvp[4][4];
452 float position[3][4];
453 float color[3][4];
Courtney Goeltzenleuchter7bbb4202014-10-24 16:26:12 -0600[diff] [blame]454};
455
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]456void VkRenderTest::VKTriangleTest(const char *vertShaderText, const char *fragShaderText, const bool rotate)
Courtney Goeltzenleuchter7bbb4202014-10-24 16:26:12 -0600[diff] [blame]457{
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700[diff] [blame]458#ifdef DEBUG_CALLBACK
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]459 vkDbgRegisterMsgCallback(inst, myDbgFunc, NULL);
Tobin Ehlis791a49c2014-11-10 12:29:12 -0700[diff] [blame]460#endif
Courtney Goeltzenleuchter7bbb4202014-10-24 16:26:12 -0600[diff] [blame]461 // Create identity matrix
462 int i;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]463 struct vktriangle_vs_uniform data;
Courtney Goeltzenleuchter7bbb4202014-10-24 16:26:12 -0600[diff] [blame]464
465 glm::mat4 Projection = glm::mat4(1.0f);
466 glm::mat4 View = glm::mat4(1.0f);
467 glm::mat4 Model = glm::mat4(1.0f);
468 glm::mat4 MVP = Projection * View * Model;
469 const int matrixSize = sizeof(MVP);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]470 const int bufSize = sizeof(vktriangle_vs_uniform) / sizeof(float);
Courtney Goeltzenleuchter7bbb4202014-10-24 16:26:12 -0600[diff] [blame]471 memcpy(&data.mvp, &MVP[0][0], matrixSize);
472
473 static const Vertex tri_data[] =
474 {
475 { XYZ1( -1, -1, 0 ), XYZ1( 1.f, 0.f, 0.f ) },
476 { XYZ1( 1, -1, 0 ), XYZ1( 0.f, 1.f, 0.f ) },
477 { XYZ1( 0, 1, 0 ), XYZ1( 0.f, 0.f, 1.f ) },
478 };
479
480 for (i=0; i<3; i++) {
481 data.position[i][0] = tri_data[i].posX;
482 data.position[i][1] = tri_data[i].posY;
483 data.position[i][2] = tri_data[i].posZ;
484 data.position[i][3] = tri_data[i].posW;
485 data.color[i][0] = tri_data[i].r;
486 data.color[i][1] = tri_data[i].g;
487 data.color[i][2] = tri_data[i].b;
488 data.color[i][3] = tri_data[i].a;
489 }
490
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]491 ASSERT_NO_FATAL_FAILURE(InitState());
492 ASSERT_NO_FATAL_FAILURE(InitViewport());
493
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]494 VkConstantBufferObj constantBuffer(m_device, bufSize*2, sizeof(float), (const void*) &data);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]495
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]496 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
497 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]498
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]499 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]500 pipelineobj.AddColorAttachment();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]501 pipelineobj.AddShader(&vs);
502 pipelineobj.AddShader(&ps);
503
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]504 VkDescriptorSetObj descriptorSet(m_device);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]505 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, constantBuffer);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]506
Tony Barbour71ba3612015-01-09 16:12:35 -0700[diff] [blame]507 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tobin Ehlis7f7b4422015-08-18 14:24:32 -0600[diff] [blame]508
509 VkCmdBufferBeginInfo cbBeginInfo;
510 memset(&cbBeginInfo, 0, sizeof(VkCmdBufferBeginInfo));
511 cbBeginInfo.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
512 cbBeginInfo.flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT;
513 ASSERT_VK_SUCCESS(BeginCommandBuffer(&cbBeginInfo));
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]514
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]515 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbour71ba3612015-01-09 16:12:35 -0700[diff] [blame]516#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]517 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbour71ba3612015-01-09 16:12:35 -0700[diff] [blame]518 pDSDumpDot((char*)"triTest2.dot");
519#endif
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]520
Tony Barbour71ba3612015-01-09 16:12:35 -0700[diff] [blame]521 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]522 Draw(3, 1, 0, 0);
Tony Barbour71ba3612015-01-09 16:12:35 -0700[diff] [blame]523
524 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]525 ASSERT_VK_SUCCESS(EndCommandBuffer());
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]526
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]527 QueueCommandBuffer();
Tony Barbour71ba3612015-01-09 16:12:35 -0700[diff] [blame]528
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]529 RecordImages(m_renderTargets);
Tony Barbour71ba3612015-01-09 16:12:35 -0700[diff] [blame]530
531 if (rotate)
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]532 RotateTriangleVSUniform(Projection, View, Model, &constantBuffer);
Tony Barbour71ba3612015-01-09 16:12:35 -0700[diff] [blame]533
Tobin Ehlis3c26a542014-11-18 11:28:33 -0700[diff] [blame]534#ifdef PRINT_OBJECTS
Mark Lobodzinski4e5016f2015-05-05 15:01:37 -0500[diff] [blame]535 OBJ_TRACK_GET_OBJECTS_COUNT pObjTrackGetObjectsCount = (OBJ_TRACK_GET_OBJECTS_COUNT)vkGetProcAddr(gpu(), (char*)"objTrackGetObjectsCount");
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600[diff] [blame]536 uint64_t numObjects = pObjTrackGetObjectsCount(m_device);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]537 //OBJ_TRACK_GET_OBJECTS pGetObjsFunc = vkGetProcAddr(gpu(), (char*)"objTrackGetObjects");
Tobin Ehlis3c26a542014-11-18 11:28:33 -0700[diff] [blame]538 printf("DEBUG : Number of Objects : %lu\n", numObjects);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]539 OBJ_TRACK_GET_OBJECTS pObjTrackGetObjs = (OBJ_TRACK_GET_OBJECTS)vkGetProcAddr(gpu(), (char*)"objTrackGetObjects");
Tobin Ehlis3c26a542014-11-18 11:28:33 -0700[diff] [blame]540 OBJTRACK_NODE* pObjNodeArray = (OBJTRACK_NODE*)malloc(sizeof(OBJTRACK_NODE)*numObjects);
Mark Lobodzinski14305ad2015-06-23 11:35:12 -0600[diff] [blame]541 pObjTrackGetObjs(m_device, numObjects, pObjNodeArray);
Tobin Ehlis3c26a542014-11-18 11:28:33 -0700[diff] [blame]542 for (i=0; i < numObjects; i++) {
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600[diff] [blame]543 printf("Object %i of type %s has objID (%p) and %lu uses\n", i, string_VkObjectType(pObjNodeArray[i].objType), pObjNodeArray[i].pObj, pObjNodeArray[i].numUses);
Tobin Ehlis3c26a542014-11-18 11:28:33 -0700[diff] [blame]544 }
545 free(pObjNodeArray);
546#endif
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]547
Courtney Goeltzenleuchter7bbb4202014-10-24 16:26:12 -0600[diff] [blame]548}
549
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]550TEST_F(VkRenderTest, VKTriangle_FragColor)
Courtney Goeltzenleuchter6acb8022014-10-27 13:08:55 -0600[diff] [blame]551{
552 static const char *vertShaderText =
553 "#version 140\n"
554 "#extension GL_ARB_separate_shader_objects : enable\n"
555 "#extension GL_ARB_shading_language_420pack : enable\n"
556 "\n"
557 "layout(binding = 0) uniform buf {\n"
558 " mat4 MVP;\n"
559 " vec4 position[3];\n"
560 " vec4 color[3];\n"
561 "} ubuf;\n"
562 "\n"
563 "layout (location = 0) out vec4 outColor;\n"
564 "\n"
565 "void main() \n"
566 "{\n"
567 " outColor = ubuf.color[gl_VertexID];\n"
568 " gl_Position = ubuf.MVP * ubuf.position[gl_VertexID];\n"
569 "}\n";
570
571 static const char *fragShaderText =
572 "#version 140\n"
573 "#extension GL_ARB_separate_shader_objects : enable\n"
574 "#extension GL_ARB_shading_language_420pack : enable\n"
575 "\n"
576 "layout (location = 0) in vec4 inColor;\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]577 "layout (location = 0) out vec4 uFragColor;\n"
Courtney Goeltzenleuchter6acb8022014-10-27 13:08:55 -0600[diff] [blame]578 "\n"
579 "void main()\n"
580 "{\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]581 " uFragColor = inColor;\n"
Courtney Goeltzenleuchter6acb8022014-10-27 13:08:55 -0600[diff] [blame]582 "}\n";
583
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]584 TEST_DESCRIPTION("VK-style shaders where fragment shader outputs to GLSL built-in gl_FragColor");
585 VKTriangleTest(vertShaderText, fragShaderText, true);
Courtney Goeltzenleuchter6acb8022014-10-27 13:08:55 -0600[diff] [blame]586}
587
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]588TEST_F(VkRenderTest, VKTriangle_OutputLocation)
Courtney Goeltzenleuchter6acb8022014-10-27 13:08:55 -0600[diff] [blame]589{
590 static const char *vertShaderText =
591 "#version 140\n"
592 "#extension GL_ARB_separate_shader_objects : enable\n"
593 "#extension GL_ARB_shading_language_420pack : enable\n"
594 "\n"
595 "layout(binding = 0) uniform buf {\n"
596 " mat4 MVP;\n"
597 " vec4 position[3];\n"
598 " vec4 color[3];\n"
599 "} ubuf;\n"
600 "\n"
601 "layout (location = 0) out vec4 outColor;\n"
602 "\n"
603 "void main() \n"
604 "{\n"
605 " outColor = ubuf.color[gl_VertexID];\n"
606 " gl_Position = ubuf.MVP * ubuf.position[gl_VertexID];\n"
607 "}\n";
608
609 static const char *fragShaderText =
610 "#version 140\n"
611 "#extension GL_ARB_separate_shader_objects : enable\n"
612 "#extension GL_ARB_shading_language_420pack : enable\n"
613 "\n"
614 "layout (location = 0) in vec4 inColor;\n"
615 "layout (location = 0) out vec4 outColor;\n"
616 "\n"
617 "void main()\n"
618 "{\n"
619 " outColor = inColor;\n"
620 "}\n";
621
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]622 TEST_DESCRIPTION("VK-style shaders where fragment shader outputs to output location 0, which should be the same as gl_FragColor");
Courtney Goeltzenleuchter6acb8022014-10-27 13:08:55 -0600[diff] [blame]623
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]624 VKTriangleTest(vertShaderText, fragShaderText, true);
Courtney Goeltzenleuchter6acb8022014-10-27 13:08:55 -0600[diff] [blame]625}
Cody Northrop71727d22015-06-23 13:25:51 -0600[diff] [blame]626
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]627TEST_F(VkRenderTest, SPV_VKTriangle)
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]628{
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]629 static const char *vertShaderText =
630 "#version 140\n"
631 "#extension GL_ARB_separate_shader_objects : enable\n"
632 "#extension GL_ARB_shading_language_420pack : enable\n"
633 "\n"
634 "layout(binding = 0) uniform buf {\n"
635 " mat4 MVP;\n"
636 " vec4 position[3];\n"
637 " vec4 color[3];\n"
638 "} ubuf;\n"
639 "\n"
640 "layout (location = 0) out vec4 outColor;\n"
641 "\n"
642 "void main() \n"
643 "{\n"
644 " outColor = ubuf.color[gl_VertexID];\n"
645 " gl_Position = ubuf.MVP * ubuf.position[gl_VertexID];\n"
646 "}\n";
647
648 static const char *fragShaderText =
649 "#version 140\n"
650 "#extension GL_ARB_separate_shader_objects : enable\n"
651 "#extension GL_ARB_shading_language_420pack : enable\n"
652 "\n"
653 "layout (location = 0) in vec4 inColor;\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]654 "layout (location = 0) out vec4 outColor;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]655 "\n"
656 "void main()\n"
657 "{\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]658 " outColor = inColor;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]659 "}\n";
660
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]661 TEST_DESCRIPTION("VK-style shaders, but force test framework to compile shader to SPV and pass SPV to driver.");
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]662
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]663 VKTriangleTest(vertShaderText, fragShaderText, true);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]664}
Courtney Goeltzenleuchter98e49432014-10-09 15:40:19 -0600[diff] [blame]665
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]666TEST_F(VkRenderTest, SPV_GreenTriangle)
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]667{
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]668 static const char *vertShaderText =
669 "#version 130\n"
670 "vec2 vertices[3];\n"
671 "void main() {\n"
672 " vertices[0] = vec2(-1.0, -1.0);\n"
673 " vertices[1] = vec2( 1.0, -1.0);\n"
674 " vertices[2] = vec2( 0.0, 1.0);\n"
675 " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
676 "}\n";
677
678 static const char *fragShaderText =
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]679 "#version 140\n"
680 "#extension GL_ARB_separate_shader_objects : enable\n"
681 "#extension GL_ARB_shading_language_420pack : enable\n"
682 "layout (location = 0) out vec4 outColor;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]683 "void main() {\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]684 " outColor = vec4(0,1,0,1);\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]685 "}\n";
686
Cody Northropacfb0492015-03-17 15:55:58 -0600[diff] [blame]687 TEST_DESCRIPTION("Same shader as GreenTriangle, but compiles shader to SPV and gives SPV to driver.");
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]688
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]689 VKTriangleTest(vertShaderText, fragShaderText, false);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]690}
Cody Northrop71727d22015-06-23 13:25:51 -0600[diff] [blame]691
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]692TEST_F(VkRenderTest, YellowTriangle)
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]693{
694 static const char *vertShaderText =
695 "#version 130\n"
696 "void main() {\n"
697 " vec2 vertices[3];"
698 " vertices[0] = vec2(-0.5, -0.5);\n"
699 " vertices[1] = vec2( 0.5, -0.5);\n"
700 " vertices[2] = vec2( 0.5, 0.5);\n"
701 " vec4 colors[3];\n"
702 " colors[0] = vec4(1.0, 0.0, 0.0, 1.0);\n"
703 " colors[1] = vec4(0.0, 1.0, 0.0, 1.0);\n"
704 " colors[2] = vec4(0.0, 0.0, 1.0, 1.0);\n"
705 " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
706 "}\n";
707
708 static const char *fragShaderText =
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]709 "#version 140\n"
710 "#extension GL_ARB_separate_shader_objects : enable\n"
711 "#extension GL_ARB_shading_language_420pack : enable\n"
712 "layout (location = 0) out vec4 outColor;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]713 "void main() {\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]714 " outColor = vec4(1.0, 1.0, 0.0, 1.0);\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]715 "}\n";
716
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]717 VKTriangleTest(vertShaderText, fragShaderText, false);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]718}
719
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]720TEST_F(VkRenderTest, QuadWithVertexFetch)
Cody Northrop0dbe84f2014-10-09 19:55:56 -0600[diff] [blame]721{
Courtney Goeltzenleuchtere5409342014-10-08 14:26:40 -0600[diff] [blame]722 static const char *vertShaderText =
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]723 "#version 140\n"
724 "#extension GL_ARB_separate_shader_objects : enable\n"
725 "#extension GL_ARB_shading_language_420pack : enable\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]726 //XYZ1( -1, -1, -1 )
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]727 "layout (location = 0) in vec4 pos;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]728 //XYZ1( 0.f, 0.f, 0.f )
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]729 "layout (location = 1) in vec4 inColor;\n"
730 "layout (location = 0) out vec4 outColor;\n"
Courtney Goeltzenleuchter9b4ab892014-10-09 15:37:21 -0600[diff] [blame]731 "void main() {\n"
Cody Northrop7a1f0462014-10-10 14:49:36 -0600[diff] [blame]732 " outColor = inColor;\n"
Cody Northrop4e6b4762014-10-09 21:25:22 -0600[diff] [blame]733 " gl_Position = pos;\n"
Courtney Goeltzenleuchter9b4ab892014-10-09 15:37:21 -0600[diff] [blame]734 "}\n";
735
Cody Northrop0dbe84f2014-10-09 19:55:56 -0600[diff] [blame]736
Courtney Goeltzenleuchter9b4ab892014-10-09 15:37:21 -0600[diff] [blame]737 static const char *fragShaderText =
Cody Northrop68a10f62014-12-05 15:44:14 -0700[diff] [blame]738 "#version 140\n"
739 "#extension GL_ARB_separate_shader_objects : enable\n"
740 "#extension GL_ARB_shading_language_420pack : enable\n"
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]741 "layout (location = 0) in vec4 color;\n"
Cody Northrop68a10f62014-12-05 15:44:14 -0700[diff] [blame]742 "layout (location = 0) out vec4 outColor;\n"
Courtney Goeltzenleuchter9b4ab892014-10-09 15:37:21 -0600[diff] [blame]743 "void main() {\n"
Cody Northrop68a10f62014-12-05 15:44:14 -0700[diff] [blame]744 " outColor = color;\n"
Courtney Goeltzenleuchter9b4ab892014-10-09 15:37:21 -0600[diff] [blame]745 "}\n";
Courtney Goeltzenleuchter9b4ab892014-10-09 15:37:21 -0600[diff] [blame]746
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]747
748
749 ASSERT_NO_FATAL_FAILURE(InitState());
750 ASSERT_NO_FATAL_FAILURE(InitViewport());
751
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]752 VkConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
Mike Stroyan55658c22014-12-04 11:08:39 +0000[diff] [blame]753 meshBuffer.BufferMemoryBarrier();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]754
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]755 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
756 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]757
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]758 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]759 pipelineobj.AddColorAttachment();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]760 pipelineobj.AddShader(&vs);
761 pipelineobj.AddShader(&ps);
762
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]763 VkDescriptorSetObj descriptorSet(m_device);
Mark Lobodzinski15427102015-02-18 16:38:17 -0600[diff] [blame]764
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]765#define MESH_BIND_ID 0
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]766 VkVertexInputBindingDescription vi_binding = {
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]767 MESH_BIND_ID, // binding ID
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]768 sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]769 VK_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]770 };
771
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]772 VkVertexInputAttributeDescription vi_attribs[2];
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]773 vi_attribs[0].binding = MESH_BIND_ID; // Binding ID
774 vi_attribs[0].location = 0; // location, position
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]775 vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]776 vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
777 vi_attribs[1].binding = MESH_BIND_ID; // Binding ID
778 vi_attribs[1].location = 1; // location, color
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]779 vi_attribs[1].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]780 vi_attribs[1].offsetInBytes = 1*sizeof(float)*4; // Offset of first element in bytes from base of vertex
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]781
782 pipelineobj.AddVertexInputAttribs(vi_attribs,2);
783 pipelineobj.AddVertexInputBindings(&vi_binding,1);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]784
Tony Barboure4ed9942015-01-09 10:06:53 -0700[diff] [blame]785 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]786 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]787
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]788 GenericDrawPreparation(pipelineobj, descriptorSet);
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]789
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]790 BindVertexBuffer(&meshBuffer, 0, 0);
Tony Barboure4ed9942015-01-09 10:06:53 -0700[diff] [blame]791
792 // render two triangles
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]793 Draw(6, 1, 0, 0);
Tony Barboure4ed9942015-01-09 10:06:53 -0700[diff] [blame]794
795 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]796 ASSERT_VK_SUCCESS(EndCommandBuffer());
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]797
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]798 QueueCommandBuffer();
Tony Barboure4ed9942015-01-09 10:06:53 -0700[diff] [blame]799
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]800 RecordImages(m_renderTargets);
Tobin Ehlis34e0e442014-10-07 14:41:29 -0600[diff] [blame]801}
802
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]803TEST_F(VkRenderTest, TriangleMRT)
Chia-I Wue09d1a72014-12-05 10:32:23 +0800[diff] [blame]804{
805 static const char *vertShaderText =
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]806 "#version 140\n"
807 "#extension GL_ARB_separate_shader_objects : enable\n"
808 "#extension GL_ARB_shading_language_420pack : enable\n"
809 "layout (location = 0) in vec4 pos;\n"
Chia-I Wue09d1a72014-12-05 10:32:23 +0800[diff] [blame]810 "void main() {\n"
811 " gl_Position = pos;\n"
812 "}\n";
813
814 static const char *fragShaderText =
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]815 "#version 140\n"
816 "#extension GL_ARB_separate_shader_objects : enable\n"
817 "#extension GL_ARB_shading_language_420pack : enable\n"
818 "layout (location = 0) out vec4 uFragData0;\n"
819 "layout (location = 1) out vec4 uFragData1;\n"
Chia-I Wue09d1a72014-12-05 10:32:23 +0800[diff] [blame]820 "void main() {\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]821 " uFragData0 = vec4(1.0, 0.0, 0.0, 1.0);\n"
822 " uFragData1 = vec4(0.0, 1.0, 0.0, 1.0);\n"
Chia-I Wue09d1a72014-12-05 10:32:23 +0800[diff] [blame]823 "}\n";
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]824 const float vb_data[][2] = {
Chia-I Wue09d1a72014-12-05 10:32:23 +0800[diff] [blame]825 { -1.0f, -1.0f },
826 { 1.0f, -1.0f },
827 { -1.0f, 1.0f }
828 };
829
830 ASSERT_NO_FATAL_FAILURE(InitState());
831 ASSERT_NO_FATAL_FAILURE(InitViewport());
832
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]833 VkConstantBufferObj meshBuffer(m_device, sizeof(vb_data) / sizeof(vb_data[0]), sizeof(vb_data[0]), vb_data);
Mike Stroyan55658c22014-12-04 11:08:39 +0000[diff] [blame]834 meshBuffer.BufferMemoryBarrier();
Chia-I Wue09d1a72014-12-05 10:32:23 +0800[diff] [blame]835
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]836 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
837 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Chia-I Wue09d1a72014-12-05 10:32:23 +0800[diff] [blame]838
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]839 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]840 pipelineobj.AddColorAttachment();
Chia-I Wue09d1a72014-12-05 10:32:23 +0800[diff] [blame]841 pipelineobj.AddShader(&vs);
842 pipelineobj.AddShader(&ps);
843
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]844#define MESH_BUF_ID 0
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]845 VkVertexInputBindingDescription vi_binding = {
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]846 MESH_BUF_ID, // Binding ID
847 sizeof(vb_data[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]848 VK_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented
Chia-I Wue09d1a72014-12-05 10:32:23 +0800[diff] [blame]849 };
850
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]851 VkVertexInputAttributeDescription vi_attrib;
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]852 vi_attrib.binding = MESH_BUF_ID; // index into vertexBindingDescriptions
853 vi_attrib.location = 0;
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]854 vi_attrib.format = VK_FORMAT_R32G32_SFLOAT; // format of source data
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]855 vi_attrib.offsetInBytes = 0; // Offset of first element in bytes from base of vertex
Chia-I Wue09d1a72014-12-05 10:32:23 +0800[diff] [blame]856
857 pipelineobj.AddVertexInputAttribs(&vi_attrib, 1);
858 pipelineobj.AddVertexInputBindings(&vi_binding,1);
Chia-I Wue09d1a72014-12-05 10:32:23 +0800[diff] [blame]859
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]860 VkDescriptorSetObj descriptorSet(m_device);
Chia-I Wue09d1a72014-12-05 10:32:23 +0800[diff] [blame]861
Courtney Goeltzenleuchterdd745fd2015-03-05 16:47:18 -0700[diff] [blame]862 ASSERT_NO_FATAL_FAILURE(InitRenderTarget(2));
Chia-I Wue09d1a72014-12-05 10:32:23 +0800[diff] [blame]863
Tony Barboure307f582015-07-10 15:29:03 -0600[diff] [blame]864 VkPipelineColorBlendAttachmentState att = {};
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]865 att.blendEnable = VK_FALSE;
Chia-I Wue09d1a72014-12-05 10:32:23 +0800[diff] [blame]866 att.channelWriteMask = 0xf;
Tony Barbourfa6cac72015-01-16 14:27:35 -0700[diff] [blame]867 pipelineobj.AddColorAttachment(1, &att);
Chia-I Wue09d1a72014-12-05 10:32:23 +0800[diff] [blame]868
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]869 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Tony Barboure4ed9942015-01-09 10:06:53 -0700[diff] [blame]870
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]871 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barboure4ed9942015-01-09 10:06:53 -0700[diff] [blame]872
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]873 BindVertexBuffer(&meshBuffer, 0, 0);
Tony Barbour5ed79702015-01-07 14:31:52 -0700[diff] [blame]874#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]875 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbour5ed79702015-01-07 14:31:52 -0700[diff] [blame]876 pDSDumpDot((char*)"triTest2.dot");
877#endif
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]878
Tony Barbour5ed79702015-01-07 14:31:52 -0700[diff] [blame]879 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]880 Draw(3, 1, 0, 0);
Tony Barbour5ed79702015-01-07 14:31:52 -0700[diff] [blame]881
882 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]883 ASSERT_VK_SUCCESS(EndCommandBuffer());
884 QueueCommandBuffer();
Tony Barbour5ed79702015-01-07 14:31:52 -0700[diff] [blame]885
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]886 RecordImages(m_renderTargets);
Chia-I Wue09d1a72014-12-05 10:32:23 +0800[diff] [blame]887}
888
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]889TEST_F(VkRenderTest, QuadWithIndexedVertexFetch)
Courtney Goeltzenleuchter4d6fbeb2014-12-04 15:45:16 -0700[diff] [blame]890{
891 static const char *vertShaderText =
892 "#version 140\n"
893 "#extension GL_ARB_separate_shader_objects : enable\n"
894 "#extension GL_ARB_shading_language_420pack : enable\n"
895 "layout(location = 0) in vec4 pos;\n"
896 "layout(location = 1) in vec4 inColor;\n"
897 "layout(location = 0) out vec4 outColor;\n"
898 "void main() {\n"
899 " outColor = inColor;\n"
900 " gl_Position = pos;\n"
901 "}\n";
902
903
904 static const char *fragShaderText =
905 "#version 140\n"
906 "#extension GL_ARB_separate_shader_objects : enable\n"
907 "#extension GL_ARB_shading_language_420pack : enable\n"
908 "layout(location = 0) in vec4 color;\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]909 "layout (location = 0) out vec4 outColor;\n"
Courtney Goeltzenleuchter4d6fbeb2014-12-04 15:45:16 -0700[diff] [blame]910 "void main() {\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]911 " outColor = color;\n"
Courtney Goeltzenleuchter4d6fbeb2014-12-04 15:45:16 -0700[diff] [blame]912 "}\n";
913
914 const Vertex g_vbData[] =
915 {
916 // first tri
917 { XYZ1( -1, -1, -1 ), XYZ1( 0.f, 0.f, 0.f ) }, // LL: black
918 { XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) }, // LR: red
919 { XYZ1( -1, 1, -1 ), XYZ1( 0.f, 1.f, 0.f ) }, // UL: green
920
921 // second tri
922 { XYZ1( -1, 1, -1 ), XYZ1( 0.f, 1.f, 0.f ) }, // UL: green
923 { XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) }, // LR: red
924 { XYZ1( 1, 1, -1 ), XYZ1( 1.f, 1.f, 0.f ) }, // UR: yellow
925 };
926
927 const uint16_t g_idxData[6] = {
928 0, 1, 2,
929 3, 4, 5,
930 };
931
932 ASSERT_NO_FATAL_FAILURE(InitState());
933 ASSERT_NO_FATAL_FAILURE(InitViewport());
934
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]935 VkConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
Mike Stroyan55658c22014-12-04 11:08:39 +0000[diff] [blame]936 meshBuffer.BufferMemoryBarrier();
Courtney Goeltzenleuchter4d6fbeb2014-12-04 15:45:16 -0700[diff] [blame]937
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]938 VkIndexBufferObj indexBuffer(m_device);
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]939 indexBuffer.CreateAndInitBuffer(sizeof(g_idxData)/sizeof(g_idxData[0]), VK_INDEX_TYPE_UINT16, g_idxData);
Mark Lobodzinskid30f82a2015-02-16 14:24:23 -0600[diff] [blame]940 indexBuffer.BufferMemoryBarrier();
Courtney Goeltzenleuchter4d6fbeb2014-12-04 15:45:16 -0700[diff] [blame]941
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]942 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
943 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Courtney Goeltzenleuchter4d6fbeb2014-12-04 15:45:16 -0700[diff] [blame]944
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]945 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]946 pipelineobj.AddColorAttachment();
Courtney Goeltzenleuchter4d6fbeb2014-12-04 15:45:16 -0700[diff] [blame]947 pipelineobj.AddShader(&vs);
948 pipelineobj.AddShader(&ps);
949
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]950 VkDescriptorSetObj descriptorSet(m_device);
Tony Barbour83a83802015-04-02 15:43:15 -0600[diff] [blame]951
Courtney Goeltzenleuchter4d6fbeb2014-12-04 15:45:16 -0700[diff] [blame]952
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]953#define MESH_BIND_ID 0
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]954 VkVertexInputBindingDescription vi_binding = {
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]955 MESH_BIND_ID, // binding ID
956 sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]957 VK_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented
Courtney Goeltzenleuchter4d6fbeb2014-12-04 15:45:16 -0700[diff] [blame]958 };
959
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]960 VkVertexInputAttributeDescription vi_attribs[2];
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]961 vi_attribs[0].binding = MESH_BIND_ID; // binding ID from BINDING_DESCRIPTION array to use for this attribute
962 vi_attribs[0].location = 0; // layout location of vertex attribute
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]963 vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]964 vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
965 vi_attribs[1].binding = MESH_BIND_ID; // binding ID from BINDING_DESCRIPTION array to use for this attribute
966 vi_attribs[1].location = 1; // layout location of vertex attribute
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]967 vi_attribs[1].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]968 vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex
Courtney Goeltzenleuchter4d6fbeb2014-12-04 15:45:16 -0700[diff] [blame]969
970 pipelineobj.AddVertexInputAttribs(vi_attribs,2);
971 pipelineobj.AddVertexInputBindings(&vi_binding,1);
Courtney Goeltzenleuchter4d6fbeb2014-12-04 15:45:16 -0700[diff] [blame]972
973 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]974 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Tony Barboure4ed9942015-01-09 10:06:53 -0700[diff] [blame]975
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]976 GenericDrawPreparation(pipelineobj, descriptorSet);
Courtney Goeltzenleuchter4d6fbeb2014-12-04 15:45:16 -0700[diff] [blame]977
Courtney Goeltzenleuchter4d6fbeb2014-12-04 15:45:16 -0700[diff] [blame]978#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]979 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tobin Ehlis266473d2014-12-16 17:34:50 -0700[diff] [blame]980 pDSDumpDot((char*)"triTest2.dot");
Courtney Goeltzenleuchter4d6fbeb2014-12-04 15:45:16 -0700[diff] [blame]981#endif
Tony Barbour02472db2015-01-08 17:08:28 -0700[diff] [blame]982
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]983 BindVertexBuffer(&meshBuffer, 0, MESH_BIND_ID);
984 BindIndexBuffer(&indexBuffer, 0);
Courtney Goeltzenleuchter4d6fbeb2014-12-04 15:45:16 -0700[diff] [blame]985
986 // render two triangles
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]987 DrawIndexed(6, 1, 0, 0, 0);
Courtney Goeltzenleuchter4d6fbeb2014-12-04 15:45:16 -0700[diff] [blame]988
989 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]990 ASSERT_VK_SUCCESS(EndCommandBuffer());
991 QueueCommandBuffer();
Courtney Goeltzenleuchter4d6fbeb2014-12-04 15:45:16 -0700[diff] [blame]992
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]993 RecordImages(m_renderTargets);
Courtney Goeltzenleuchter4d6fbeb2014-12-04 15:45:16 -0700[diff] [blame]994}
995
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]996TEST_F(VkRenderTest, GreyandRedCirclesonBlue)
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]997{
998 // This tests gl_FragCoord
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]999
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1000 static const char *vertShaderText =
1001 "#version 140\n"
1002 "#extension GL_ARB_separate_shader_objects : enable\n"
1003 "#extension GL_ARB_shading_language_420pack : enable\n"
1004 "layout (location = 0) in vec4 pos;\n"
1005 "layout (location = 0) out vec4 outColor;\n"
1006 "layout (location = 1) out vec4 outColor2;\n"
1007 "void main() {\n"
1008 " gl_Position = pos;\n"
1009 " outColor = vec4(0.9, 0.9, 0.9, 1.0);\n"
1010 " outColor2 = vec4(0.2, 0.2, 0.4, 1.0);\n"
1011 "}\n";
1012
1013 static const char *fragShaderText =
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1014 "#version 330\n"
1015 "#extension GL_ARB_separate_shader_objects : enable\n"
1016 "#extension GL_ARB_shading_language_420pack : enable\n"
1017 //"#extension GL_ARB_fragment_coord_conventions : enable\n"
1018 //"layout (pixel_center_integer) in vec4 gl_FragCoord;\n"
1019 "layout (location = 0) in vec4 color;\n"
1020 "layout (location = 1) in vec4 color2;\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1021 "layout (location = 0) out vec4 outColor;\n"
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1022 "void main() {\n"
1023 " vec2 pos = mod(gl_FragCoord.xy, vec2(50.0)) - vec2(25.0);\n"
1024 " float dist_squared = dot(pos, pos);\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1025 " outColor = (dist_squared < 400.0)\n"
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1026 " ? ((gl_FragCoord.y < 100.0) ? vec4(1.0, 0.0, 0.0, 0.0) : color)\n"
1027 " : color2;\n"
1028 "}\n";
1029
1030 ASSERT_NO_FATAL_FAILURE(InitState());
1031 ASSERT_NO_FATAL_FAILURE(InitViewport());
1032
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1033 VkConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
Mike Stroyan55658c22014-12-04 11:08:39 +0000[diff] [blame]1034 meshBuffer.BufferMemoryBarrier();
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1035
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]1036 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
1037 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1038
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1039 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]1040 pipelineobj.AddColorAttachment();
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1041 pipelineobj.AddShader(&vs);
1042 pipelineobj.AddShader(&ps);
1043
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1044 VkDescriptorSetObj descriptorSet(m_device);
Mark Lobodzinski15427102015-02-18 16:38:17 -0600[diff] [blame]1045
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1046#define MESH_BIND_ID 0
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]1047 VkVertexInputBindingDescription vi_binding = {
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1048 MESH_BIND_ID, // binding ID
1049 sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1050 VK_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1051 };
1052
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]1053 VkVertexInputAttributeDescription vi_attribs[1];
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1054 vi_attribs[0].binding = MESH_BIND_ID; // binding ID
1055 vi_attribs[0].location = 0;
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]1056 vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1057 vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1058
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1059 pipelineobj.AddVertexInputAttribs(vi_attribs,1);
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1060 pipelineobj.AddVertexInputBindings(&vi_binding,1);
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1061
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1062 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1063
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1064 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1065
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1066 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1067
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1068 BindVertexBuffer(&meshBuffer, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1069#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1070 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1071 pDSDumpDot((char*)"triTest2.dot");
1072#endif
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]1073
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1074 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]1075 Draw(6, 1, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1076
1077 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1078 EndCommandBuffer();
1079 QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1080
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]1081 RecordImages(m_renderTargets);
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1082}
1083
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1084TEST_F(VkRenderTest, RedCirclesonBlue)
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1085{
1086 // This tests that we correctly handle unread fragment inputs
1087
1088 static const char *vertShaderText =
1089 "#version 140\n"
1090 "#extension GL_ARB_separate_shader_objects : enable\n"
1091 "#extension GL_ARB_shading_language_420pack : enable\n"
1092 "layout (location = 0) in vec4 pos;\n"
1093 "layout (location = 0) out vec4 outColor;\n"
1094 "layout (location = 1) out vec4 outColor2;\n"
1095 "void main() {\n"
1096 " gl_Position = pos;\n"
1097 " outColor = vec4(0.9, 0.9, 0.9, 1.0);\n"
1098 " outColor2 = vec4(0.2, 0.2, 0.4, 1.0);\n"
1099 "}\n";
1100
1101 static const char *fragShaderText =
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1102 "#version 330\n"
1103 "#extension GL_ARB_separate_shader_objects : enable\n"
1104 "#extension GL_ARB_shading_language_420pack : enable\n"
1105 //"#extension GL_ARB_fragment_coord_conventions : enable\n"
1106 //"layout (pixel_center_integer) in vec4 gl_FragCoord;\n"
1107 "layout (location = 0) in vec4 color;\n"
1108 "layout (location = 1) in vec4 color2;\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1109 "layout (location = 0) out vec4 outColor;\n"
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1110 "void main() {\n"
1111 " vec2 pos = mod(gl_FragCoord.xy, vec2(50.0)) - vec2(25.0);\n"
1112 " float dist_squared = dot(pos, pos);\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1113 " outColor = (dist_squared < 400.0)\n"
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1114 " ? vec4(1.0, 0.0, 0.0, 1.0)\n"
1115 " : color2;\n"
1116 "}\n";
1117
1118 ASSERT_NO_FATAL_FAILURE(InitState());
1119 ASSERT_NO_FATAL_FAILURE(InitViewport());
1120
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1121 VkConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
Mike Stroyan55658c22014-12-04 11:08:39 +0000[diff] [blame]1122 meshBuffer.BufferMemoryBarrier();
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1123
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]1124 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
1125 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1126
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1127 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]1128 pipelineobj.AddColorAttachment();
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1129 pipelineobj.AddShader(&vs);
1130 pipelineobj.AddShader(&ps);
1131
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1132 VkDescriptorSetObj descriptorSet(m_device);
Mark Lobodzinski15427102015-02-18 16:38:17 -0600[diff] [blame]1133
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1134#define MESH_BIND_ID 0
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]1135 VkVertexInputBindingDescription vi_binding = {
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1136 MESH_BIND_ID, // binding ID
1137 sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1138 VK_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1139 };
1140
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]1141 VkVertexInputAttributeDescription vi_attribs[1];
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1142 vi_attribs[0].binding = MESH_BIND_ID; // binding ID
1143 vi_attribs[0].location = 0;
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]1144 vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1145 vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1146
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1147 pipelineobj.AddVertexInputAttribs(vi_attribs,1);
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1148 pipelineobj.AddVertexInputBindings(&vi_binding,1);
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1149
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1150 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1151 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1152
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1153 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1154
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1155 BindVertexBuffer(&meshBuffer, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1156#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1157 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1158 pDSDumpDot((char*)"triTest2.dot");
1159#endif
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]1160 // render two triangles
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]1161 Draw(6, 1, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1162
1163 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1164 EndCommandBuffer();
1165 QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1166
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]1167 RecordImages(m_renderTargets);
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1168}
1169
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1170TEST_F(VkRenderTest, GreyCirclesonBlueFade)
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1171{
1172 // This tests reading gl_ClipDistance from FS
1173
1174 static const char *vertShaderText =
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1175 //"#version 140\n"
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1176 "#version 330\n"
1177 "#extension GL_ARB_separate_shader_objects : enable\n"
1178 "#extension GL_ARB_shading_language_420pack : enable\n"
1179 "out gl_PerVertex {\n"
1180 " vec4 gl_Position;\n"
1181 " float gl_ClipDistance[1];\n"
1182 "};\n"
1183 "layout (location = 0) in vec4 pos;\n"
1184 "layout (location = 0) out vec4 outColor;\n"
1185 "layout (location = 1) out vec4 outColor2;\n"
1186 "void main() {\n"
1187 " gl_Position = pos;\n"
1188 " outColor = vec4(0.9, 0.9, 0.9, 1.0);\n"
1189 " outColor2 = vec4(0.2, 0.2, 0.4, 1.0);\n"
1190 " float dists[3];\n"
1191 " dists[0] = 0.0;\n"
1192 " dists[1] = 1.0;\n"
1193 " dists[2] = 1.0;\n"
1194 " gl_ClipDistance[0] = dists[gl_VertexID % 3];\n"
1195 "}\n";
1196
1197
1198 static const char *fragShaderText =
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1199 "#version 140\n"
1200 //"#version 330\n"
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1201 "#extension GL_ARB_separate_shader_objects : enable\n"
1202 "#extension GL_ARB_shading_language_420pack : enable\n"
1203 //"#extension GL_ARB_fragment_coord_conventions : enable\n"
1204 //"layout (pixel_center_integer) in vec4 gl_FragCoord;\n"
1205 "layout (location = 0) in vec4 color;\n"
1206 "layout (location = 1) in vec4 color2;\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1207 "layout (location = 0) out vec4 uFragColor;\n"
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1208 "void main() {\n"
1209 " vec2 pos = mod(gl_FragCoord.xy, vec2(50.0)) - vec2(25.0);\n"
1210 " float dist_squared = dot(pos, pos);\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1211 " uFragColor = (dist_squared < 400.0)\n"
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1212 " ? color * gl_ClipDistance[0]\n"
1213 " : color2;\n"
1214 "}\n";
1215
1216 ASSERT_NO_FATAL_FAILURE(InitState());
1217 ASSERT_NO_FATAL_FAILURE(InitViewport());
1218
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1219 VkConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
Mike Stroyan55658c22014-12-04 11:08:39 +0000[diff] [blame]1220 meshBuffer.BufferMemoryBarrier();
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1221
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]1222 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
1223 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1224
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1225 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]1226 pipelineobj.AddColorAttachment();
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1227 pipelineobj.AddShader(&vs);
1228 pipelineobj.AddShader(&ps);
1229
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1230 VkDescriptorSetObj descriptorSet(m_device);
Mark Lobodzinski15427102015-02-18 16:38:17 -0600[diff] [blame]1231
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1232#define MESH_BIND_ID 0
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]1233 VkVertexInputBindingDescription vi_binding = {
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1234 MESH_BIND_ID, // binding ID
1235 sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1236 VK_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1237 };
1238
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]1239 VkVertexInputAttributeDescription vi_attribs[1];
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1240 vi_attribs[0].binding = MESH_BIND_ID; // binding ID
1241 vi_attribs[0].location = 0;
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]1242 vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1243 vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1244
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1245 pipelineobj.AddVertexInputAttribs(vi_attribs,1);
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1246 pipelineobj.AddVertexInputBindings(&vi_binding,1);
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1247
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1248 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1249
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1250 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1251
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1252 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1253
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1254 BindVertexBuffer(&meshBuffer, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1255#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1256 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1257 pDSDumpDot((char*)"triTest2.dot");
1258#endif
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]1259
1260 // render two triangles
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]1261 Draw(6, 1, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1262
1263 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1264 EndCommandBuffer();
1265 QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1266
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]1267 RecordImages(m_renderTargets);
GregF6bef1212014-12-02 15:41:44 -0700[diff] [blame]1268}
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1269
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1270TEST_F(VkRenderTest, GreyCirclesonBlueDiscard)
GregF7a23c792014-12-02 17:19:34 -0700[diff] [blame]1271{
1272 static const char *vertShaderText =
1273 "#version 140\n"
1274 "#extension GL_ARB_separate_shader_objects : enable\n"
1275 "#extension GL_ARB_shading_language_420pack : enable\n"
1276 "layout (location = 0) in vec4 pos;\n"
1277 "layout (location = 0) out vec4 outColor;\n"
1278 "layout (location = 1) out vec4 outColor2;\n"
1279 "void main() {\n"
1280 " gl_Position = pos;\n"
1281 " outColor = vec4(0.9, 0.9, 0.9, 1.0);\n"
1282 " outColor2 = vec4(0.2, 0.2, 0.4, 1.0);\n"
1283 "}\n";
1284
1285
1286 static const char *fragShaderText =
GregF7a23c792014-12-02 17:19:34 -0700[diff] [blame]1287 "#version 330\n"
1288 "#extension GL_ARB_separate_shader_objects : enable\n"
1289 "#extension GL_ARB_shading_language_420pack : enable\n"
1290 //"#extension GL_ARB_fragment_coord_conventions : enable\n"
1291 //"layout (pixel_center_integer) in vec4 gl_FragCoord;\n"
1292 "layout (location = 0) in vec4 color;\n"
1293 "layout (location = 1) in vec4 color2;\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1294 "layout (location = 0) out vec4 outColor;\n"
GregF7a23c792014-12-02 17:19:34 -0700[diff] [blame]1295 "void main() {\n"
1296 " vec2 pos = mod(gl_FragCoord.xy, vec2(50.0)) - vec2(25.0);\n"
1297 " float dist_squared = dot(pos, pos);\n"
1298 " if (dist_squared < 100.0)\n"
1299 " discard;\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1300 " outColor = (dist_squared < 400.0)\n"
GregF7a23c792014-12-02 17:19:34 -0700[diff] [blame]1301 " ? color\n"
1302 " : color2;\n"
1303 "}\n";
1304
1305 ASSERT_NO_FATAL_FAILURE(InitState());
1306 ASSERT_NO_FATAL_FAILURE(InitViewport());
1307
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1308 VkConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
Mike Stroyan55658c22014-12-04 11:08:39 +0000[diff] [blame]1309 meshBuffer.BufferMemoryBarrier();
GregF7a23c792014-12-02 17:19:34 -0700[diff] [blame]1310
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]1311 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
1312 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
GregF7a23c792014-12-02 17:19:34 -0700[diff] [blame]1313
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1314 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]1315 pipelineobj.AddColorAttachment();
GregF7a23c792014-12-02 17:19:34 -0700[diff] [blame]1316 pipelineobj.AddShader(&vs);
1317 pipelineobj.AddShader(&ps);
1318
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1319 VkDescriptorSetObj descriptorSet(m_device);
Mark Lobodzinski15427102015-02-18 16:38:17 -0600[diff] [blame]1320
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1321#define MESH_BIND_ID 0
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]1322 VkVertexInputBindingDescription vi_binding = {
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1323 MESH_BIND_ID, // binding ID
1324 sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1325 VK_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented
GregF7a23c792014-12-02 17:19:34 -0700[diff] [blame]1326 };
1327
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]1328 VkVertexInputAttributeDescription vi_attribs[1];
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1329 vi_attribs[0].binding = MESH_BIND_ID; // binding ID
1330 vi_attribs[0].location = 0;
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]1331 vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1332 vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
GregF7a23c792014-12-02 17:19:34 -0700[diff] [blame]1333
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1334 pipelineobj.AddVertexInputAttribs(vi_attribs,1);
GregF7a23c792014-12-02 17:19:34 -0700[diff] [blame]1335 pipelineobj.AddVertexInputBindings(&vi_binding,1);
GregF7a23c792014-12-02 17:19:34 -0700[diff] [blame]1336
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1337 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1338
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1339 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1340
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1341 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1342
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1343 BindVertexBuffer(&meshBuffer, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1344#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1345 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1346 pDSDumpDot((char*)"triTest2.dot");
1347#endif
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]1348
1349 // render two triangles
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]1350 Draw(6, 1, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1351
1352 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1353 EndCommandBuffer();
1354 QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1355
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]1356 RecordImages(m_renderTargets);
GregF7a23c792014-12-02 17:19:34 -0700[diff] [blame]1357}
1358
1359
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1360TEST_F(VkRenderTest, TriangleVSUniform)
Cody Northrop7a1f0462014-10-10 14:49:36 -0600[diff] [blame]1361{
1362 static const char *vertShaderText =
Courtney Goeltzenleuchterc3f4ac82014-10-27 09:48:52 -0600[diff] [blame]1363 "#version 140\n"
1364 "#extension GL_ARB_separate_shader_objects : enable\n"
1365 "#extension GL_ARB_shading_language_420pack : enable\n"
1366 "\n"
1367 "layout(binding = 0) uniform buf {\n"
1368 " mat4 MVP;\n"
1369 "} ubuf;\n"
Cody Northrop7a1f0462014-10-10 14:49:36 -0600[diff] [blame]1370 "void main() {\n"
1371 " vec2 vertices[3];"
1372 " vertices[0] = vec2(-0.5, -0.5);\n"
1373 " vertices[1] = vec2( 0.5, -0.5);\n"
1374 " vertices[2] = vec2( 0.5, 0.5);\n"
Courtney Goeltzenleuchterc3f4ac82014-10-27 09:48:52 -0600[diff] [blame]1375 " gl_Position = ubuf.MVP * vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
Cody Northrop7a1f0462014-10-10 14:49:36 -0600[diff] [blame]1376 "}\n";
1377
1378 static const char *fragShaderText =
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1379 "#version 140\n"
1380 "#extension GL_ARB_separate_shader_objects : enable\n"
1381 "#extension GL_ARB_shading_language_420pack : enable\n"
1382 "layout (location = 0) out vec4 outColor;\n"
Cody Northrop7a1f0462014-10-10 14:49:36 -0600[diff] [blame]1383 "void main() {\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1384 " outColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
Cody Northrop7a1f0462014-10-10 14:49:36 -0600[diff] [blame]1385 "}\n";
1386
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1387 ASSERT_NO_FATAL_FAILURE(InitState());
1388 ASSERT_NO_FATAL_FAILURE(InitViewport());
1389
Courtney Goeltzenleuchter34b81772014-10-10 18:04:39 -0600[diff] [blame]1390 // Create identity matrix
Courtney Goeltzenleuchterc3f4ac82014-10-27 09:48:52 -0600[diff] [blame]1391 glm::mat4 Projection = glm::mat4(1.0f);
1392 glm::mat4 View = glm::mat4(1.0f);
1393 glm::mat4 Model = glm::mat4(1.0f);
1394 glm::mat4 MVP = Projection * View * Model;
1395 const int matrixSize = sizeof(MVP) / sizeof(MVP[0]);
1396
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1397 VkConstantBufferObj MVPBuffer(m_device, matrixSize, sizeof(MVP[0]), (const void*) &MVP[0][0]);
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]1398 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
1399 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Courtney Goeltzenleuchterc3f4ac82014-10-27 09:48:52 -0600[diff] [blame]1400
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1401 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]1402 pipelineobj.AddColorAttachment();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1403 pipelineobj.AddShader(&vs);
1404 pipelineobj.AddShader(&ps);
1405
1406 // Create descriptor set and attach the constant buffer to it
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1407 VkDescriptorSetObj descriptorSet(m_device);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1408 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, MVPBuffer);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1409
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1410 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tobin Ehlis7f7b4422015-08-18 14:24:32 -0600[diff] [blame]1411
1412 VkCmdBufferBeginInfo cbBeginInfo;
1413 memset(&cbBeginInfo, 0, sizeof(VkCmdBufferBeginInfo));
1414 cbBeginInfo.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
1415 cbBeginInfo.flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT;
1416 ASSERT_VK_SUCCESS(BeginCommandBuffer(&cbBeginInfo));
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1417
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1418 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1419
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1420#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1421 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1422 pDSDumpDot((char*)"triTest2.dot");
1423#endif
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]1424
1425 // render two triangles
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]1426 Draw(6, 1, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1427
1428 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1429 EndCommandBuffer();
1430 QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1431
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]1432 RecordImages(m_renderTargets);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1433
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1434 RotateTriangleVSUniform(Projection, View, Model, &MVPBuffer);
Courtney Goeltzenleuchterc3f4ac82014-10-27 09:48:52 -0600[diff] [blame]1435}
1436
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1437TEST_F(VkRenderTest, MixTriangle)
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1438{
1439 // This tests location applied to varyings. Notice that we have switched foo
1440 // and bar in the FS. The triangle should be blended with red, green and blue
1441 // corners.
1442 static const char *vertShaderText =
1443 "#version 140\n"
1444 "#extension GL_ARB_separate_shader_objects : enable\n"
1445 "#extension GL_ARB_shading_language_420pack : enable\n"
1446 "layout (location=0) out vec4 bar;\n"
1447 "layout (location=1) out vec4 foo;\n"
1448 "layout (location=2) out float scale;\n"
1449 "vec2 vertices[3];\n"
1450 "void main() {\n"
1451 " vertices[0] = vec2(-1.0, -1.0);\n"
1452 " vertices[1] = vec2( 1.0, -1.0);\n"
1453 " vertices[2] = vec2( 0.0, 1.0);\n"
1454 "vec4 colors[3];\n"
1455 " colors[0] = vec4(1.0, 0.0, 0.0, 1.0);\n"
1456 " colors[1] = vec4(0.0, 1.0, 0.0, 1.0);\n"
1457 " colors[2] = vec4(0.0, 0.0, 1.0, 1.0);\n"
1458 " foo = colors[gl_VertexID % 3];\n"
1459 " bar = vec4(1.0, 1.0, 1.0, 1.0);\n"
1460 " scale = 1.0;\n"
1461 " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
1462 "}\n";
1463
1464 static const char *fragShaderText =
1465 "#version 140\n"
1466 "#extension GL_ARB_separate_shader_objects : enable\n"
1467 "#extension GL_ARB_shading_language_420pack : enable\n"
1468 "layout (location = 1) in vec4 bar;\n"
1469 "layout (location = 0) in vec4 foo;\n"
1470 "layout (location = 2) in float scale;\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1471 "layout (location = 0) out vec4 outColor;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1472 "void main() {\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1473 " outColor = bar * scale + foo * (1.0-scale);\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1474 "}\n";
1475
1476 ASSERT_NO_FATAL_FAILURE(InitState());
1477 ASSERT_NO_FATAL_FAILURE(InitViewport());
1478
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]1479 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
1480 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1481
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1482 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]1483 pipelineobj.AddColorAttachment();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1484 pipelineobj.AddShader(&vs);
1485 pipelineobj.AddShader(&ps);
1486
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1487 VkDescriptorSetObj descriptorSet(m_device);
Tony Barbour83a83802015-04-02 15:43:15 -0600[diff] [blame]1488 descriptorSet.AppendDummy();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1489
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1490 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1491
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1492 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1493
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1494 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1495
1496#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1497 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1498 pDSDumpDot((char*)"triTest2.dot");
1499#endif
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]1500
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1501 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]1502 Draw(3, 1, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1503
1504 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1505 EndCommandBuffer();
1506 QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1507
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]1508 RecordImages(m_renderTargets);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1509}
1510
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1511TEST_F(VkRenderTest, QuadVertFetchAndVertID)
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1512{
1513 // This tests that attributes work in the presence of gl_VertexID
1514
1515 static const char *vertShaderText =
1516 "#version 140\n"
1517 "#extension GL_ARB_separate_shader_objects : enable\n"
1518 "#extension GL_ARB_shading_language_420pack : enable\n"
1519 //XYZ1( -1, -1, -1 )
1520 "layout (location = 0) in vec4 pos;\n"
1521 //XYZ1( 0.f, 0.f, 0.f )
1522 "layout (location = 1) in vec4 inColor;\n"
1523 "layout (location = 0) out vec4 outColor;\n"
1524 "void main() {\n"
1525 " outColor = inColor;\n"
1526 " vec4 vertices[3];"
1527 " vertices[gl_VertexID % 3] = pos;\n"
1528 " gl_Position = vertices[(gl_VertexID + 3) % 3];\n"
1529 "}\n";
1530
1531
1532 static const char *fragShaderText =
1533 "#version 140\n"
1534 "#extension GL_ARB_separate_shader_objects : enable\n"
1535 "#extension GL_ARB_shading_language_420pack : enable\n"
1536 "layout (location = 0) in vec4 color;\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1537 "layout (location = 0) out vec4 outColor;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1538 "void main() {\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1539 " outColor = color;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1540 "}\n";
1541
1542 ASSERT_NO_FATAL_FAILURE(InitState());
1543 ASSERT_NO_FATAL_FAILURE(InitViewport());
1544
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1545 VkConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
Mike Stroyan55658c22014-12-04 11:08:39 +0000[diff] [blame]1546 meshBuffer.BufferMemoryBarrier();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1547
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]1548 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
1549 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1550
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1551 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]1552 pipelineobj.AddColorAttachment();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1553 pipelineobj.AddShader(&vs);
1554 pipelineobj.AddShader(&ps);
1555
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1556 VkDescriptorSetObj descriptorSet(m_device);
Mark Lobodzinski15427102015-02-18 16:38:17 -0600[diff] [blame]1557
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1558#define MESH_BUF_ID 0
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]1559 VkVertexInputBindingDescription vi_binding = {
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1560 MESH_BUF_ID, // Binding ID
1561 sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1562 VK_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1563 };
1564
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]1565 VkVertexInputAttributeDescription vi_attribs[2];
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1566 vi_attribs[0].binding = MESH_BUF_ID; // binding ID
1567 vi_attribs[0].location = 0;
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]1568 vi_attribs[0].format = VK_FORMAT_R32G32_SFLOAT; // format of source data
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1569 vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
1570 vi_attribs[1].binding = MESH_BUF_ID; // binding ID
1571 vi_attribs[1].location = 1;
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]1572 vi_attribs[1].format = VK_FORMAT_R32G32_SFLOAT; // format of source data
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1573 vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1574
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1575 pipelineobj.AddVertexInputAttribs(vi_attribs, 2);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1576 pipelineobj.AddVertexInputBindings(&vi_binding,1);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1577
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1578 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1579
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1580 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1581
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1582 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1583
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1584 BindVertexBuffer(&meshBuffer, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1585#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1586 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1587 pDSDumpDot((char*)"triTest2.dot");
1588#endif
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]1589
1590 // render two triangles
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]1591 Draw(6, 1, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1592
1593 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1594 EndCommandBuffer();
1595 QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1596
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]1597 RecordImages(m_renderTargets);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1598}
1599
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1600TEST_F(VkRenderTest, QuadSparseVertFetch)
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1601{
1602 // This tests that attributes work in the presence of gl_VertexID
1603
1604 static const char *vertShaderText =
1605 "#version 140\n"
1606 "#extension GL_ARB_separate_shader_objects : enable\n"
1607 "#extension GL_ARB_shading_language_420pack : enable\n"
1608 //XYZ1( -1, -1, -1 )
1609 "layout (location = 1) in vec4 pos;\n"
1610 "layout (location = 4) in vec4 inColor;\n"
1611 //XYZ1( 0.f, 0.f, 0.f )
1612 "layout (location = 0) out vec4 outColor;\n"
1613 "void main() {\n"
1614 " outColor = inColor;\n"
1615 " gl_Position = pos;\n"
1616 "}\n";
1617
1618
1619 static const char *fragShaderText =
1620 "#version 140\n"
1621 "#extension GL_ARB_separate_shader_objects : enable\n"
1622 "#extension GL_ARB_shading_language_420pack : enable\n"
1623 "layout (location = 0) in vec4 color;\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1624 "layout (location = 0) out vec4 outColor;\n"
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1625 "void main() {\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1626 " outColor = color;\n"
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1627 "}\n";
1628
1629 ASSERT_NO_FATAL_FAILURE(InitState());
1630 ASSERT_NO_FATAL_FAILURE(InitViewport());
1631
1632 struct VDATA
1633 {
1634 float t1, t2, t3, t4; // filler data
1635 float posX, posY, posZ, posW; // Position data
1636 float r, g, b, a; // Color
1637 };
1638 const struct VDATA vData[] =
1639 {
1640 { XYZ1(0, 0, 0), XYZ1( -1, -1, -1 ), XYZ1( 0.f, 0.f, 0.f ) },
1641 { XYZ1(0, 0, 0), XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) },
1642 { XYZ1(0, 0, 0), XYZ1( -1, 1, -1 ), XYZ1( 0.f, 1.f, 0.f ) },
1643 { XYZ1(0, 0, 0), XYZ1( -1, 1, -1 ), XYZ1( 0.f, 1.f, 0.f ) },
1644 { XYZ1(0, 0, 0), XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) },
1645 { XYZ1(0, 0, 0), XYZ1( 1, 1, -1 ), XYZ1( 1.f, 1.f, 0.f ) },
1646 };
1647
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1648 VkConstantBufferObj meshBuffer(m_device,sizeof(vData)/sizeof(vData[0]),sizeof(vData[0]), vData);
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1649 meshBuffer.BufferMemoryBarrier();
1650
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]1651 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
1652 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1653
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1654 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]1655 pipelineobj.AddColorAttachment();
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1656 pipelineobj.AddShader(&vs);
1657 pipelineobj.AddShader(&ps);
1658
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1659 VkDescriptorSetObj descriptorSet(m_device);
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1660
1661#define MESH_BUF_ID 0
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]1662 VkVertexInputBindingDescription vi_binding = {
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1663 MESH_BUF_ID, // Binding ID
1664 sizeof(vData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1665 VK_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1666 };
1667
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]1668 VkVertexInputAttributeDescription vi_attribs[2];
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1669 vi_attribs[0].binding = MESH_BUF_ID; // binding ID
1670 vi_attribs[0].location = 4;
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]1671 vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1672 vi_attribs[0].offsetInBytes = sizeof(float) * 4 * 2; // Offset of first element in bytes from base of vertex
1673 vi_attribs[1].binding = MESH_BUF_ID; // binding ID
1674 vi_attribs[1].location = 1;
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]1675 vi_attribs[1].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1676 vi_attribs[1].offsetInBytes = sizeof(float) * 4 * 1; // Offset of first element in bytes from base of vertex
1677
1678 pipelineobj.AddVertexInputAttribs(vi_attribs, 2);
1679 pipelineobj.AddVertexInputBindings(&vi_binding, 1);
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1680
1681 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1682
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1683 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1684
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1685 GenericDrawPreparation(pipelineobj, descriptorSet);
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1686
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1687 BindVertexBuffer(&meshBuffer, 0, MESH_BUF_ID);
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1688#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1689 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1690 pDSDumpDot((char*)"triTest2.dot");
1691#endif
1692
1693 // render two triangles
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]1694 Draw(6, 1, 0, 0);
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1695
1696 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1697 EndCommandBuffer();
1698 QueueCommandBuffer();
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1699
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]1700 RecordImages(m_renderTargets);
Courtney Goeltzenleuchter3bf666d2015-03-31 16:39:32 -0600[diff] [blame]1701}
1702
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1703TEST_F(VkRenderTest, TriVertFetchDeadAttr)
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1704{
1705 // This tests that attributes work in the presence of gl_VertexID
1706 // and a dead attribute in position 0. Draws a triangle with yellow,
1707 // red and green corners, starting at top and going clockwise.
1708
1709 static const char *vertShaderText =
1710 "#version 140\n"
1711 "#extension GL_ARB_separate_shader_objects : enable\n"
1712 "#extension GL_ARB_shading_language_420pack : enable\n"
1713 //XYZ1( -1, -1, -1 )
1714 "layout (location = 0) in vec4 pos;\n"
1715 //XYZ1( 0.f, 0.f, 0.f )
1716 "layout (location = 1) in vec4 inColor;\n"
1717 "layout (location = 0) out vec4 outColor;\n"
1718 "void main() {\n"
1719 " outColor = inColor;\n"
1720 " vec2 vertices[3];"
1721 " vertices[0] = vec2(-1.0, -1.0);\n"
1722 " vertices[1] = vec2( 1.0, -1.0);\n"
1723 " vertices[2] = vec2( 0.0, 1.0);\n"
1724 " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
1725 "}\n";
1726
1727
1728 static const char *fragShaderText =
1729 "#version 140\n"
1730 "#extension GL_ARB_separate_shader_objects : enable\n"
1731 "#extension GL_ARB_shading_language_420pack : enable\n"
1732 "layout (location = 0) in vec4 color;\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1733 "layout (location = 0) out vec4 outColor;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1734 "void main() {\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1735 " outColor = color;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1736 "}\n";
1737
1738 ASSERT_NO_FATAL_FAILURE(InitState());
1739 ASSERT_NO_FATAL_FAILURE(InitViewport());
1740
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1741 VkConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData);
Mike Stroyan55658c22014-12-04 11:08:39 +0000[diff] [blame]1742 meshBuffer.BufferMemoryBarrier();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1743
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]1744 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
1745 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1746
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1747 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]1748 pipelineobj.AddColorAttachment();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1749 pipelineobj.AddShader(&vs);
1750 pipelineobj.AddShader(&ps);
1751
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1752 VkDescriptorSetObj descriptorSet(m_device);
Mark Lobodzinski15427102015-02-18 16:38:17 -0600[diff] [blame]1753
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1754#define MESH_BUF_ID 0
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]1755 VkVertexInputBindingDescription vi_binding = {
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1756 MESH_BUF_ID, // Binding ID
1757 sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1758 VK_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1759 };
1760
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]1761 VkVertexInputAttributeDescription vi_attribs[2];
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1762 vi_attribs[0].binding = MESH_BUF_ID; // binding ID
1763 vi_attribs[0].location = 0;
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]1764 vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1765 vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
1766 vi_attribs[1].binding = MESH_BUF_ID; // binding ID
1767 vi_attribs[1].location = 1;
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]1768 vi_attribs[1].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1769 vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1770
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1771 pipelineobj.AddVertexInputAttribs(vi_attribs, 2);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1772 pipelineobj.AddVertexInputBindings(&vi_binding,1);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1773
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1774 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1775
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1776 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1777
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1778 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1779
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1780 BindVertexBuffer(&meshBuffer, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1781#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1782 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1783 pDSDumpDot((char*)"triTest2.dot");
1784#endif
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]1785
1786 // render two triangles
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]1787 Draw(6, 1, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1788
1789 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1790 EndCommandBuffer();
1791 QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1792
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]1793 RecordImages(m_renderTargets);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1794}
1795
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1796TEST_F(VkRenderTest, CubeWithVertexFetchAndMVP)
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]1797{
1798 static const char *vertShaderText =
1799 "#version 140\n"
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1800 "#extension GL_ARB_separate_shader_objects : enable\n"
1801 "#extension GL_ARB_shading_language_420pack : enable\n"
Tony Barbour6baf4402015-09-29 14:56:09 -0600[diff] [blame]1802 "layout (binding = 0) uniform bufferVals {\n"
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]1803 " mat4 mvp;\n"
1804 "} myBufferVals;\n"
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1805 "layout (location = 0) in vec4 pos;\n"
1806 "layout (location = 1) in vec4 inColor;\n"
Cody Northrop74a2d2c2015-06-16 17:32:04 -0600[diff] [blame]1807 "layout (location = 0) out vec4 outColor;\n"
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]1808 "void main() {\n"
1809 " outColor = inColor;\n"
1810 " gl_Position = myBufferVals.mvp * pos;\n"
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]1811 " gl_Position.y = -gl_Position.y;\n"
1812 " gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0;\n"
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]1813 "}\n";
1814
1815 static const char *fragShaderText =
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1816 "#version 140\n"
1817 "#extension GL_ARB_separate_shader_objects : enable\n"
1818 "#extension GL_ARB_shading_language_420pack : enable\n"
1819 "layout (location = 0) in vec4 color;\n"
1820 "layout (location = 0) out vec4 outColor;\n"
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]1821 "void main() {\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1822 " outColor = color;\n"
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]1823 "}\n";
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1824 glm::mat4 Projection = glm::perspective(glm::radians(45.0f), 1.0f, 0.1f, 100.0f);
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]1825
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1826 glm::mat4 View = glm::lookAt(
1827 glm::vec3(0,3,10), // Camera is at (0,3,10), in World Space
1828 glm::vec3(0,0,0), // and looks at the origin
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]1829 glm::vec3(0,-1,0) // Head is up (set to 0,-1,0 to look upside-down)
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1830 );
1831
1832 glm::mat4 Model = glm::mat4(1.0f);
1833
1834 glm::mat4 MVP = Projection * View * Model;
1835
1836 ASSERT_NO_FATAL_FAILURE(InitState());
1837 ASSERT_NO_FATAL_FAILURE(InitViewport());
Chia-I Wu9e81ebb2015-07-09 10:16:34 +0800[diff] [blame]1838 m_depth_stencil_fmt = VK_FORMAT_D16_UNORM;
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]1839 m_depthStencil->Init(m_device, (int32_t)m_width, (int32_t)m_height, m_depth_stencil_fmt);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1840
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1841 VkConstantBufferObj meshBuffer(m_device,sizeof(g_vb_solid_face_colors_Data)/sizeof(g_vb_solid_face_colors_Data[0]),
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1842 sizeof(g_vb_solid_face_colors_Data[0]), g_vb_solid_face_colors_Data);
1843
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]1844 const int buf_size = sizeof(MVP) / sizeof(float);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1845
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1846 VkConstantBufferObj MVPBuffer(m_device, buf_size, sizeof(MVP[0]), (const void*) &MVP[0][0]);
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]1847 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
1848 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1849
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1850 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]1851 pipelineobj.AddColorAttachment();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1852 pipelineobj.AddShader(&vs);
1853 pipelineobj.AddShader(&ps);
1854
Tony Barboure307f582015-07-10 15:29:03 -0600[diff] [blame]1855 VkPipelineDepthStencilStateCreateInfo ds_state;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1856 ds_state.depthTestEnable = VK_TRUE;
1857 ds_state.depthWriteEnable = VK_TRUE;
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]1858 ds_state.depthCompareOp = VK_COMPARE_OP_LESS_EQUAL;
Cody Northrope4bc6942015-08-26 10:01:32 -0600[diff] [blame]1859 ds_state.depthBoundsTestEnable = VK_FALSE;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1860 ds_state.stencilTestEnable = VK_FALSE;
1861 ds_state.back.stencilDepthFailOp = VK_STENCIL_OP_KEEP;
1862 ds_state.back.stencilFailOp = VK_STENCIL_OP_KEEP;
1863 ds_state.back.stencilPassOp = VK_STENCIL_OP_KEEP;
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]1864 ds_state.back.stencilCompareOp = VK_COMPARE_OP_ALWAYS;
Tony Barbourfa6cac72015-01-16 14:27:35 -0700[diff] [blame]1865 ds_state.front = ds_state.back;
1866 pipelineobj.SetDepthStencil(&ds_state);
1867
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1868 VkDescriptorSetObj descriptorSet(m_device);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1869 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, MVPBuffer);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1870
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1871#define MESH_BUF_ID 0
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]1872 VkVertexInputBindingDescription vi_binding = {
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1873 MESH_BUF_ID, // Binding ID
1874 sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1875 VK_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1876 };
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1877
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]1878 VkVertexInputAttributeDescription vi_attribs[2];
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1879 vi_attribs[0].binding = MESH_BUF_ID; // binding ID
1880 vi_attribs[0].location = 0;
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]1881 vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1882 vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
1883 vi_attribs[1].binding = MESH_BUF_ID; // binding ID
1884 vi_attribs[1].location = 1;
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]1885 vi_attribs[1].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1886 vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1887
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]1888 pipelineobj.AddVertexInputAttribs(vi_attribs, 2);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1889 pipelineobj.AddVertexInputBindings(&vi_binding,1);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1890
Tony Barbour17c6ab12015-03-27 17:03:18 -0600[diff] [blame]1891 ASSERT_NO_FATAL_FAILURE(InitRenderTarget(m_depthStencil->BindInfo()));
Tony Barbour17c6ab12015-03-27 17:03:18 -0600[diff] [blame]1892
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1893 ASSERT_VK_SUCCESS(BeginCommandBuffer());
1894 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1895
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1896 BindVertexBuffer(&meshBuffer, 0, 0);
Tony Barboure4ed9942015-01-09 10:06:53 -0700[diff] [blame]1897#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1898 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barboure4ed9942015-01-09 10:06:53 -0700[diff] [blame]1899 pDSDumpDot((char*)"triTest2.dot");
1900#endif
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]1901
1902 // render triangles
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]1903 Draw(36, 1, 0, 0);
Tony Barboure4ed9942015-01-09 10:06:53 -0700[diff] [blame]1904
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]1905
Tony Barboure4ed9942015-01-09 10:06:53 -0700[diff] [blame]1906 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1907 EndCommandBuffer();
1908 QueueCommandBuffer();
Tony Barboure4ed9942015-01-09 10:06:53 -0700[diff] [blame]1909
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]1910 RecordImages(m_renderTargets);
Courtney Goeltzenleuchterd0556292014-10-20 16:33:15 -0600[diff] [blame]1911}
1912
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1913TEST_F(VkRenderTest, VSTexture)
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1914{
1915 // The expected result from this test is a green and red triangle;
1916 // one red vertex on the left, two green vertices on the right.
1917 static const char *vertShaderText =
Cody Northrop74a2d2c2015-06-16 17:32:04 -0600[diff] [blame]1918 "#version 140\n"
1919 "#extension GL_ARB_separate_shader_objects : enable\n"
1920 "#extension GL_ARB_shading_language_420pack : enable\n"
1921 "layout (location = 0) out vec4 texColor;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1922 "uniform sampler2D surface;\n"
1923 "void main() {\n"
1924 " vec2 vertices[3];"
1925 " vertices[0] = vec2(-0.5, -0.5);\n"
1926 " vertices[1] = vec2( 0.5, -0.5);\n"
1927 " vertices[2] = vec2( 0.5, 0.5);\n"
1928 " vec2 positions[3];"
1929 " positions[0] = vec2( 0.0, 0.0);\n"
1930 " positions[1] = vec2( 0.25, 0.1);\n"
1931 " positions[2] = vec2( 0.1, 0.25);\n"
1932 " vec2 samplePos = positions[gl_VertexID % 3];\n"
1933 " texColor = textureLod(surface, samplePos, 0.0);\n"
1934 " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
1935 "}\n";
1936
1937 static const char *fragShaderText =
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1938 "#version 140\n"
1939 "#extension GL_ARB_separate_shader_objects : enable\n"
1940 "#extension GL_ARB_shading_language_420pack : enable\n"
1941 "layout (location = 0) in vec4 texColor;\n"
1942 "layout (location = 0) out vec4 outColor;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1943 "void main() {\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1944 " outColor = texColor;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1945 "}\n";
1946
1947 ASSERT_NO_FATAL_FAILURE(InitState());
1948 ASSERT_NO_FATAL_FAILURE(InitViewport());
1949
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]1950 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
1951 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1952 VkSamplerObj sampler(m_device);
1953 VkTextureObj texture(m_device);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1954
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1955 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]1956 pipelineobj.AddColorAttachment();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1957 pipelineobj.AddShader(&vs);
1958 pipelineobj.AddShader(&ps);
1959
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1960 VkDescriptorSetObj descriptorSet(m_device);
Chia-I Wuf8385062015-01-04 16:27:24 +0800[diff] [blame]1961 descriptorSet.AppendSamplerTexture(&sampler, &texture);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1962
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1963 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1964 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1965
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1966 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1967
1968#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]1969 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1970 pDSDumpDot((char*)"triTest2.dot");
1971#endif
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]1972
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1973 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]1974 Draw(3, 1, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1975
1976 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]1977 EndCommandBuffer();
1978 QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]1979
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]1980 RecordImages(m_renderTargets);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1981}
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]1982
1983
1984
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]1985TEST_F(VkRenderTest, TexturedTriangle)
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]1986{
1987 // The expected result from this test is a red and green checkered triangle
1988 static const char *vertShaderText =
1989 "#version 140\n"
1990 "#extension GL_ARB_separate_shader_objects : enable\n"
1991 "#extension GL_ARB_shading_language_420pack : enable\n"
1992 "layout (location = 0) out vec2 samplePos;\n"
1993 "void main() {\n"
1994 " vec2 vertices[3];"
1995 " vertices[0] = vec2(-0.5, -0.5);\n"
1996 " vertices[1] = vec2( 0.5, -0.5);\n"
1997 " vertices[2] = vec2( 0.5, 0.5);\n"
1998 " vec2 positions[3];"
1999 " positions[0] = vec2( 0.0, 0.0);\n"
2000 " positions[1] = vec2( 1.0, 0.0);\n"
2001 " positions[2] = vec2( 1.0, 1.0);\n"
2002 " samplePos = positions[gl_VertexID % 3];\n"
2003 " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
2004 "}\n";
2005
2006 static const char *fragShaderText =
2007 "#version 140\n"
2008 "#extension GL_ARB_separate_shader_objects : enable\n"
2009 "#extension GL_ARB_shading_language_420pack : enable\n"
2010 "layout (location = 0) in vec2 samplePos;\n"
2011 "layout (binding = 0) uniform sampler2D surface;\n"
2012 "layout (location=0) out vec4 outColor;\n"
2013 "void main() {\n"
2014 " vec4 texColor = textureLod(surface, samplePos, 0.0);\n"
2015 " outColor = texColor;\n"
2016 "}\n";
2017
2018 ASSERT_NO_FATAL_FAILURE(InitState());
2019 ASSERT_NO_FATAL_FAILURE(InitViewport());
2020
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]2021 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
2022 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2023 VkSamplerObj sampler(m_device);
2024 VkTextureObj texture(m_device);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2025
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2026 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]2027 pipelineobj.AddColorAttachment();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2028 pipelineobj.AddShader(&vs);
2029 pipelineobj.AddShader(&ps);
2030
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2031 VkDescriptorSetObj descriptorSet(m_device);
Chia-I Wuf8385062015-01-04 16:27:24 +0800[diff] [blame]2032 descriptorSet.AppendSamplerTexture(&sampler, &texture);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2033
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2034 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2035 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2036
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2037 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2038
2039#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2040 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2041 pDSDumpDot((char*)"triTest2.dot");
2042#endif
2043 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]2044 Draw(3, 1, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2045
2046 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2047 EndCommandBuffer();
2048 QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2049
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]2050 RecordImages(m_renderTargets);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2051}
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2052TEST_F(VkRenderTest, TexturedTriangleClip)
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2053{
2054 // The expected result from this test is a red and green checkered triangle
2055 static const char *vertShaderText =
2056 "#version 330\n"
2057 "#extension GL_ARB_separate_shader_objects : enable\n"
2058 "#extension GL_ARB_shading_language_420pack : enable\n"
2059 "layout (location = 0) out vec2 samplePos;\n"
2060 "out gl_PerVertex {\n"
2061 " vec4 gl_Position;\n"
2062 " float gl_ClipDistance[1];\n"
2063 "};\n"
2064 "void main() {\n"
2065 " vec2 vertices[3];"
2066 " vertices[0] = vec2(-0.5, -0.5);\n"
2067 " vertices[1] = vec2( 0.5, -0.5);\n"
2068 " vertices[2] = vec2( 0.5, 0.5);\n"
2069 " vec2 positions[3];"
2070 " positions[0] = vec2( 0.0, 0.0);\n"
2071 " positions[1] = vec2( 1.0, 0.0);\n"
2072 " positions[2] = vec2( 1.0, 1.0);\n"
2073 " float dists[3];\n"
2074 " dists[0] = 1.0;\n"
2075 " dists[1] = 1.0;\n"
2076 " dists[2] = -1.0;\n"
2077 " gl_ClipDistance[0] = dists[gl_VertexID % 3];\n"
2078 " samplePos = positions[gl_VertexID % 3];\n"
2079 " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
2080 "}\n";
2081
2082 static const char *fragShaderText =
2083 "#version 140\n"
2084 "#extension GL_ARB_separate_shader_objects : enable\n"
2085 "#extension GL_ARB_shading_language_420pack : enable\n"
2086 "layout (location = 0) in vec2 samplePos;\n"
2087 "layout (binding = 0) uniform sampler2D surface;\n"
2088 "layout (location=0) out vec4 outColor;\n"
2089 "void main() {\n"
2090 //" vec4 texColor = textureLod(surface, samplePos, 0.0 + gl_ClipDistance[0]);\n"
2091 " vec4 texColor = textureLod(surface, samplePos, 0.0);\n"
2092 " outColor = texColor;\n"
2093 "}\n";
2094
2095
2096 ASSERT_NO_FATAL_FAILURE(InitState());
2097 ASSERT_NO_FATAL_FAILURE(InitViewport());
2098
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]2099 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
2100 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2101 VkSamplerObj sampler(m_device);
2102 VkTextureObj texture(m_device);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2103
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2104 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]2105 pipelineobj.AddColorAttachment();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2106 pipelineobj.AddShader(&vs);
2107 pipelineobj.AddShader(&ps);
2108
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2109 VkDescriptorSetObj descriptorSet(m_device);
Chia-I Wuf8385062015-01-04 16:27:24 +0800[diff] [blame]2110 descriptorSet.AppendSamplerTexture(&sampler, &texture);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2111
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2112 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2113 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2114
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2115 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2116
2117#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2118 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2119 pDSDumpDot((char*)"triTest2.dot");
2120#endif
2121 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]2122 Draw(3, 1, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2123
2124 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2125 EndCommandBuffer();
2126 QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2127
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]2128 RecordImages(m_renderTargets);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2129}
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]2130
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2131TEST_F(VkRenderTest, FSTriangle)
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2132{
2133 // The expected result from this test is a red and green checkered triangle
2134 static const char *vertShaderText =
2135 "#version 140\n"
2136 "#extension GL_ARB_separate_shader_objects : enable\n"
2137 "#extension GL_ARB_shading_language_420pack : enable\n"
2138 "layout (location = 0) out vec2 samplePos;\n"
2139 "void main() {\n"
2140 " vec2 vertices[3];"
2141 " vertices[0] = vec2(-0.5, -0.5);\n"
2142 " vertices[1] = vec2( 0.5, -0.5);\n"
2143 " vertices[2] = vec2( 0.5, 0.5);\n"
2144 " vec2 positions[3];"
2145 " positions[0] = vec2( 0.0, 0.0);\n"
2146 " positions[1] = vec2( 1.0, 0.0);\n"
2147 " positions[2] = vec2( 1.0, 1.0);\n"
2148 " samplePos = positions[gl_VertexID % 3];\n"
2149 " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
2150 "}\n";
2151
2152 static const char *fragShaderText =
2153 "#version 140\n"
2154 "#extension GL_ARB_separate_shader_objects : enable\n"
2155 "#extension GL_ARB_shading_language_420pack : enable\n"
2156 "layout (location = 0) in vec2 samplePos;\n"
2157 "layout (binding = 0) uniform sampler2D surface;\n"
2158 "layout (location=0) out vec4 outColor;\n"
2159 "void main() {\n"
2160 " vec4 texColor = textureLod(surface, samplePos, 0.0);\n"
2161 " outColor = texColor;\n"
2162 "}\n";
2163
2164 ASSERT_NO_FATAL_FAILURE(InitState());
2165 ASSERT_NO_FATAL_FAILURE(InitViewport());
2166
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]2167 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
2168 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2169 VkSamplerObj sampler(m_device);
2170 VkTextureObj texture(m_device);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2171
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2172 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]2173 pipelineobj.AddColorAttachment();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2174 pipelineobj.AddShader(&vs);
2175 pipelineobj.AddShader(&ps);
2176
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2177 VkDescriptorSetObj descriptorSet(m_device);
Chia-I Wuf8385062015-01-04 16:27:24 +0800[diff] [blame]2178 descriptorSet.AppendSamplerTexture(&sampler, &texture);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2179
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2180 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2181 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2182
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2183 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2184
2185#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2186 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2187 pDSDumpDot((char*)"triTest2.dot");
2188#endif
2189 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]2190 Draw(3, 1, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2191
2192 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2193 EndCommandBuffer();
2194 QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2195
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]2196 RecordImages(m_renderTargets);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2197}
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2198TEST_F(VkRenderTest, SamplerBindingsTriangle)
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2199{
2200 // This test sets bindings on the samplers
2201 // For now we are asserting that sampler and texture pairs
2202 // march in lock step, and are set via GLSL binding. This can
2203 // and will probably change.
2204 // The sampler bindings should match the sampler and texture slot
2205 // number set up by the application.
2206 // This test will result in a blue triangle
2207 static const char *vertShaderText =
2208 "#version 140\n"
2209 "#extension GL_ARB_separate_shader_objects : enable\n"
2210 "#extension GL_ARB_shading_language_420pack : enable\n"
2211 "layout (location = 0) out vec4 samplePos;\n"
2212 "void main() {\n"
2213 " vec2 vertices[3];"
2214 " vertices[0] = vec2(-0.5, -0.5);\n"
2215 " vertices[1] = vec2( 0.5, -0.5);\n"
2216 " vertices[2] = vec2( 0.5, 0.5);\n"
2217 " vec2 positions[3];"
2218 " positions[0] = vec2( 0.0, 0.0);\n"
2219 " positions[1] = vec2( 1.0, 0.0);\n"
2220 " positions[2] = vec2( 1.0, 1.0);\n"
2221 " samplePos = vec4(positions[gl_VertexID % 3], 0.0, 0.0);\n"
2222 " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
2223 "}\n";
2224
2225 static const char *fragShaderText =
2226 "#version 140\n"
2227 "#extension GL_ARB_separate_shader_objects : enable\n"
2228 "#extension GL_ARB_shading_language_420pack : enable\n"
2229 "layout (location = 0) in vec4 samplePos;\n"
2230 "layout (binding = 0) uniform sampler2D surface0;\n"
2231 "layout (binding = 1) uniform sampler2D surface1;\n"
2232 "layout (binding = 12) uniform sampler2D surface2;\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]2233 "layout (location = 0) out vec4 outColor;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2234 "void main() {\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]2235 " outColor = textureLod(surface2, samplePos.xy, 0.0);\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2236 "}\n";
2237
2238 ASSERT_NO_FATAL_FAILURE(InitState());
2239 ASSERT_NO_FATAL_FAILURE(InitViewport());
2240
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]2241 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
2242 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2243
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2244 VkSamplerObj sampler1(m_device);
2245 VkSamplerObj sampler2(m_device);
2246 VkSamplerObj sampler3(m_device);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2247
Tony Barbour2f421a02015-04-01 16:38:10 -0600[diff] [blame]2248 uint32_t tex_colors[2] = { 0xffff0000, 0xffff0000 };
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2249 VkTextureObj texture1(m_device, tex_colors); // Red
Tony Barbour2f421a02015-04-01 16:38:10 -0600[diff] [blame]2250 tex_colors[0] = 0xff00ff00; tex_colors[1] = 0xff00ff00;
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2251 VkTextureObj texture2(m_device, tex_colors); // Green
Tony Barbour2f421a02015-04-01 16:38:10 -0600[diff] [blame]2252 tex_colors[0] = 0xff0000ff; tex_colors[1] = 0xff0000ff;
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2253 VkTextureObj texture3(m_device, tex_colors); // Blue
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2254
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2255 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]2256 pipelineobj.AddColorAttachment();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2257 pipelineobj.AddShader(&vs);
2258 pipelineobj.AddShader(&ps);
2259
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2260 VkDescriptorSetObj descriptorSet(m_device);
Chia-I Wuf8385062015-01-04 16:27:24 +0800[diff] [blame]2261 descriptorSet.AppendSamplerTexture(&sampler1, &texture1);
2262 descriptorSet.AppendSamplerTexture(&sampler2, &texture2);
2263 for (int i = 0; i < 10; i++)
2264 descriptorSet.AppendDummy();
2265 descriptorSet.AppendSamplerTexture(&sampler3, &texture3);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2266
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2267 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2268 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2269
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2270 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2271
2272#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2273 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2274 pDSDumpDot((char*)"triTest2.dot");
2275#endif
2276 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]2277 Draw(3, 1, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2278
2279 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2280 EndCommandBuffer();
2281 QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2282
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]2283 RecordImages(m_renderTargets);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2284}
2285
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2286TEST_F(VkRenderTest, TriangleVSUniformBlock)
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2287{
2288 // The expected result from this test is a blue triangle
2289
2290 static const char *vertShaderText =
2291 "#version 140\n"
2292 "#extension GL_ARB_separate_shader_objects : enable\n"
2293 "#extension GL_ARB_shading_language_420pack : enable\n"
2294 "layout (location = 0) out vec4 outColor;\n"
Tony Barbour6baf4402015-09-29 14:56:09 -0600[diff] [blame]2295 "layout (binding = 0) uniform bufferVals {\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2296 " vec4 red;\n"
2297 " vec4 green;\n"
2298 " vec4 blue;\n"
2299 " vec4 white;\n"
2300 "} myBufferVals;\n"
2301 "void main() {\n"
2302 " vec2 vertices[3];"
2303 " vertices[0] = vec2(-0.5, -0.5);\n"
2304 " vertices[1] = vec2( 0.5, -0.5);\n"
2305 " vertices[2] = vec2( 0.5, 0.5);\n"
2306 " outColor = myBufferVals.blue;\n"
2307 " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
2308 "}\n";
2309
2310 static const char *fragShaderText =
2311 "#version 140\n"
2312 "#extension GL_ARB_separate_shader_objects : enable\n"
2313 "#extension GL_ARB_shading_language_420pack : enable\n"
2314 "layout (location = 0) in vec4 inColor;\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]2315 "layout (location = 0) out vec4 outColor;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2316 "void main() {\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]2317 " outColor = inColor;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2318 "}\n";
2319
2320 ASSERT_NO_FATAL_FAILURE(InitState());
2321 ASSERT_NO_FATAL_FAILURE(InitViewport());
2322
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]2323 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
2324 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2325
2326 // Let's populate our buffer with the following:
2327 // vec4 red;
2328 // vec4 green;
2329 // vec4 blue;
2330 // vec4 white;
2331 const int valCount = 4 * 4;
2332 const float bufferVals[valCount] = { 1.0, 0.0, 0.0, 1.0,
2333 0.0, 1.0, 0.0, 1.0,
2334 0.0, 0.0, 1.0, 1.0,
2335 1.0, 1.0, 1.0, 1.0 };
2336
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2337 VkConstantBufferObj colorBuffer(m_device, valCount, sizeof(bufferVals[0]), (const void*) bufferVals);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2338
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2339 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]2340 pipelineobj.AddColorAttachment();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2341 pipelineobj.AddShader(&vs);
2342 pipelineobj.AddShader(&ps);
2343
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2344 VkDescriptorSetObj descriptorSet(m_device);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2345 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, colorBuffer);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2346
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2347 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2348 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2349
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2350 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2351
2352#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2353 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2354 pDSDumpDot((char*)"triTest2.dot");
2355#endif
2356 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]2357 Draw(3, 1, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2358
2359 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2360 EndCommandBuffer();
2361 QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2362
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]2363 RecordImages(m_renderTargets);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2364}
2365
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2366TEST_F(VkRenderTest, TriangleFSUniformBlockBinding)
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2367{
2368 // This test allows the shader to select which buffer it is
2369 // pulling from using layout binding qualifier.
2370 // There are corresponding changes in the compiler stack that
2371 // will select the buffer using binding directly.
2372 // The binding number should match the slot number set up by
2373 // the application.
2374 // The expected result from this test is a purple triangle
2375
2376 static const char *vertShaderText =
2377 "#version 140\n"
2378 "#extension GL_ARB_separate_shader_objects : enable\n"
2379 "#extension GL_ARB_shading_language_420pack : enable\n"
2380 "void main() {\n"
2381 " vec2 vertices[3];"
2382 " vertices[0] = vec2(-0.5, -0.5);\n"
2383 " vertices[1] = vec2( 0.5, -0.5);\n"
2384 " vertices[2] = vec2( 0.5, 0.5);\n"
2385 " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
2386 "}\n";
2387
2388 static const char *fragShaderText =
2389 "#version 140\n"
2390 "#extension GL_ARB_separate_shader_objects : enable\n"
2391 "#extension GL_ARB_shading_language_420pack : enable\n"
Tony Barbour6baf4402015-09-29 14:56:09 -0600[diff] [blame]2392 "layout (binding = 0) uniform redVal { vec4 color; } myRedVal\n;"
2393 "layout (binding = 1) uniform greenVal { vec4 color; } myGreenVal\n;"
2394 "layout (binding = 2) uniform blueVal { vec4 color; } myBlueVal\n;"
2395 "layout (binding = 3) uniform whiteVal { vec4 color; } myWhiteVal\n;"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]2396 "layout (location = 0) out vec4 outColor;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2397 "void main() {\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]2398 " outColor = myBlueVal.color;\n"
2399 " outColor += myRedVal.color;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2400 "}\n";
2401
2402 ASSERT_NO_FATAL_FAILURE(InitState());
2403 ASSERT_NO_FATAL_FAILURE(InitViewport());
2404
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]2405 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
2406 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2407
2408 // We're going to create a number of uniform buffers, and then allow
2409 // the shader to select which it wants to read from with a binding
2410
2411 // Let's populate the buffers with a single color each:
Tony Barbour6baf4402015-09-29 14:56:09 -0600[diff] [blame]2412 // layout (binding = 0) uniform bufferVals { vec4 red; } myRedVal;
2413 // layout (binding = 1) uniform bufferVals { vec4 green; } myGreenVal;
2414 // layout (binding = 2) uniform bufferVals { vec4 blue; } myBlueVal;
2415 // layout (binding = 3) uniform bufferVals { vec4 white; } myWhiteVal;
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2416
2417 const float redVals[4] = { 1.0, 0.0, 0.0, 1.0 };
2418 const float greenVals[4] = { 0.0, 1.0, 0.0, 1.0 };
2419 const float blueVals[4] = { 0.0, 0.0, 1.0, 1.0 };
2420 const float whiteVals[4] = { 1.0, 1.0, 1.0, 1.0 };
2421
2422 const int redCount = sizeof(redVals) / sizeof(float);
2423 const int greenCount = sizeof(greenVals) / sizeof(float);
2424 const int blueCount = sizeof(blueVals) / sizeof(float);
2425 const int whiteCount = sizeof(whiteVals) / sizeof(float);
2426
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2427 VkConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2428
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2429 VkConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2430
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2431 VkConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2432
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2433 VkConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2434
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2435 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]2436 pipelineobj.AddColorAttachment();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2437 pipelineobj.AddShader(&vs);
2438 pipelineobj.AddShader(&ps);
2439
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2440 VkDescriptorSetObj descriptorSet(m_device);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2441 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, redBuffer);
2442 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, greenBuffer);
2443 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, blueBuffer);
2444 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2445
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2446 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2447 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2448
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2449 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2450
2451#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2452 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2453 pDSDumpDot((char*)"triTest2.dot");
2454#endif
2455 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]2456 Draw(3, 1, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2457
2458 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2459 EndCommandBuffer();
2460 QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2461
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]2462 RecordImages(m_renderTargets);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2463}
2464
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2465TEST_F(VkRenderTest, TriangleFSAnonymousUniformBlockBinding)
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2466{
2467 // This test is the same as TriangleFSUniformBlockBinding, but
2468 // it does not provide an instance name.
2469 // The expected result from this test is a purple triangle
2470
2471 static const char *vertShaderText =
2472 "#version 140\n"
2473 "#extension GL_ARB_separate_shader_objects : enable\n"
2474 "#extension GL_ARB_shading_language_420pack : enable\n"
2475 "void main() {\n"
2476 " vec2 vertices[3];"
2477 " vertices[0] = vec2(-0.5, -0.5);\n"
2478 " vertices[1] = vec2( 0.5, -0.5);\n"
2479 " vertices[2] = vec2( 0.5, 0.5);\n"
2480 " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
2481 "}\n";
2482
2483 static const char *fragShaderText =
2484 "#version 430\n"
2485 "#extension GL_ARB_separate_shader_objects : enable\n"
2486 "#extension GL_ARB_shading_language_420pack : enable\n"
Tony Barbour6baf4402015-09-29 14:56:09 -0600[diff] [blame]2487 "layout (binding = 0) uniform redVal { vec4 red; };"
2488 "layout (binding = 1) uniform greenVal { vec4 green; };"
2489 "layout (binding = 2) uniform blueVal { vec4 blue; };"
2490 "layout (binding = 3) uniform whiteVal { vec4 white; };"
Cody Northrop68a10f62014-12-05 15:44:14 -0700[diff] [blame]2491 "layout (location = 0) out vec4 outColor;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2492 "void main() {\n"
Cody Northrop68a10f62014-12-05 15:44:14 -0700[diff] [blame]2493 " outColor = blue;\n"
2494 " outColor += red;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2495 "}\n";
2496 ASSERT_NO_FATAL_FAILURE(InitState());
2497 ASSERT_NO_FATAL_FAILURE(InitViewport());
2498
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]2499 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
2500 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2501
2502 // We're going to create a number of uniform buffers, and then allow
2503 // the shader to select which it wants to read from with a binding
2504
2505 // Let's populate the buffers with a single color each:
Tony Barbour6baf4402015-09-29 14:56:09 -0600[diff] [blame]2506 // layout (binding = 0) uniform bufferVals { vec4 red; } myRedVal;
2507 // layout (binding = 1) uniform bufferVals { vec4 green; } myGreenVal;
2508 // layout (binding = 2) uniform bufferVals { vec4 blue; } myBlueVal;
2509 // layout (binding = 3) uniform bufferVals { vec4 white; } myWhiteVal;
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2510
2511 const float redVals[4] = { 1.0, 0.0, 0.0, 1.0 };
2512 const float greenVals[4] = { 0.0, 1.0, 0.0, 1.0 };
2513 const float blueVals[4] = { 0.0, 0.0, 1.0, 1.0 };
2514 const float whiteVals[4] = { 1.0, 1.0, 1.0, 1.0 };
2515
2516 const int redCount = sizeof(redVals) / sizeof(float);
2517 const int greenCount = sizeof(greenVals) / sizeof(float);
2518 const int blueCount = sizeof(blueVals) / sizeof(float);
2519 const int whiteCount = sizeof(whiteVals) / sizeof(float);
2520
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2521 VkConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2522
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2523 VkConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2524
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2525 VkConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2526
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2527 VkConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2528
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2529 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]2530 pipelineobj.AddColorAttachment();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2531 pipelineobj.AddShader(&vs);
2532 pipelineobj.AddShader(&ps);
2533
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2534 VkDescriptorSetObj descriptorSet(m_device);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2535 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, redBuffer);
2536 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, greenBuffer);
2537 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, blueBuffer);
2538 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2539
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2540 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2541 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2542
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2543 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2544
2545#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2546 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2547 pDSDumpDot((char*)"triTest2.dot");
2548#endif
2549 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]2550 Draw(3, 1, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2551
2552 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2553 EndCommandBuffer();
2554 QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2555
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]2556 RecordImages(m_renderTargets);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2557}
2558
GregF54a32172015-07-01 16:11:09 -0600[diff] [blame]2559TEST_F(VkRenderTest, TriangleFSAnonymousUniformBlockBindingWithStruct)
2560{
2561 // This test is the same as TriangleFSUniformBlockBinding, but
2562 // it does not provide an instance name.
2563 // The expected result from this test is a purple triangle
2564
2565 static const char *vertShaderText =
2566 "#version 140\n"
2567 "#extension GL_ARB_separate_shader_objects : enable\n"
2568 "#extension GL_ARB_shading_language_420pack : enable\n"
2569 "void main() {\n"
2570 " vec2 vertices[3];"
2571 " vertices[0] = vec2(-0.5, -0.5);\n"
2572 " vertices[1] = vec2( 0.5, -0.5);\n"
2573 " vertices[2] = vec2( 0.5, 0.5);\n"
2574 " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
2575 "}\n";
2576
2577 static const char *fragShaderText =
2578 "#version 430\n"
2579 "#extension GL_ARB_separate_shader_objects : enable\n"
2580 "#extension GL_ARB_shading_language_420pack : enable\n"
2581 "\n"
2582 " struct PS_INPUT {\n"
2583 " vec2 member0;\n"
2584 " vec4 member1;\n"
2585 " vec4 member2;\n"
2586 " vec4 member3;\n"
2587 " vec4 member4;\n"
2588 " vec4 member5;\n"
2589 " vec4 member6;\n"
2590 " vec4 member7;\n"
2591 " vec4 member8;\n"
2592 " vec4 member9;\n"
2593 " };\n"
2594 "\n"
Tony Barbour6baf4402015-09-29 14:56:09 -0600[diff] [blame]2595 "layout (binding = 0) uniform redVal { vec4 red; };"
2596 "layout (binding = 1) uniform greenVal { vec4 green; };"
2597 "layout (binding = 2) uniform blueVal { vec4 blue; };"
2598 "layout (binding = 3) uniform whiteVal { vec4 white; };"
GregF54a32172015-07-01 16:11:09 -0600[diff] [blame]2599 "layout (location = 0) out vec4 outColor;\n"
2600 "PS_INPUT MainFs()\n"
2601 "{\n"
2602 " PS_INPUT o;\n"
2603 " o.member9 = red;\n"
2604 " return o;\n"
2605 "}\n"
2606 "\n"
2607 "void main()\n"
2608 "{\n"
2609 " PS_INPUT o;\n"
2610 " o = MainFs();\n"
2611 " outColor = blue;"
2612 " outColor += o.member9;\n"
2613 "}\n";;
2614 ASSERT_NO_FATAL_FAILURE(InitState());
2615 ASSERT_NO_FATAL_FAILURE(InitViewport());
2616
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]2617 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
2618 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
GregF54a32172015-07-01 16:11:09 -0600[diff] [blame]2619
2620 // We're going to create a number of uniform buffers, and then allow
2621 // the shader to select which it wants to read from with a binding
2622
2623 // Let's populate the buffers with a single color each:
Tony Barbour6baf4402015-09-29 14:56:09 -0600[diff] [blame]2624 // layout (binding = 0) uniform bufferVals { vec4 red; } myRedVal;
2625 // layout (binding = 1) uniform bufferVals { vec4 green; } myGreenVal;
2626 // layout (binding = 2) uniform bufferVals { vec4 blue; } myBlueVal;
2627 // layout (binding = 3) uniform bufferVals { vec4 white; } myWhiteVal;
GregF54a32172015-07-01 16:11:09 -0600[diff] [blame]2628
2629 const float redVals[4] = { 1.0, 0.0, 0.0, 1.0 };
2630 const float greenVals[4] = { 0.0, 1.0, 0.0, 1.0 };
2631 const float blueVals[4] = { 0.0, 0.0, 1.0, 1.0 };
2632 const float whiteVals[4] = { 1.0, 1.0, 1.0, 1.0 };
2633
2634 const int redCount = sizeof(redVals) / sizeof(float);
2635 const int greenCount = sizeof(greenVals) / sizeof(float);
2636 const int blueCount = sizeof(blueVals) / sizeof(float);
2637 const int whiteCount = sizeof(whiteVals) / sizeof(float);
2638
2639 VkConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
2640
2641 VkConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
2642
2643 VkConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
2644
2645 VkConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
2646
2647 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]2648 pipelineobj.AddColorAttachment();
GregF54a32172015-07-01 16:11:09 -0600[diff] [blame]2649 pipelineobj.AddShader(&vs);
2650 pipelineobj.AddShader(&ps);
2651
2652 VkDescriptorSetObj descriptorSet(m_device);
2653 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, redBuffer);
2654 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, greenBuffer);
2655 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, blueBuffer);
2656 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
2657
2658 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2659 ASSERT_VK_SUCCESS(BeginCommandBuffer());
GregF54a32172015-07-01 16:11:09 -0600[diff] [blame]2660
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2661 GenericDrawPreparation(pipelineobj, descriptorSet);
GregF54a32172015-07-01 16:11:09 -0600[diff] [blame]2662
2663#ifdef DUMP_STATE_DOT
2664 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
2665 pDSDumpDot((char*)"triTest2.dot");
2666#endif
2667 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]2668 Draw(3, 1, 0, 0);
GregF54a32172015-07-01 16:11:09 -0600[diff] [blame]2669
2670 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2671 EndCommandBuffer();
2672 QueueCommandBuffer();
GregF54a32172015-07-01 16:11:09 -0600[diff] [blame]2673
2674 RecordImages(m_renderTargets);
2675}
2676
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2677TEST_F(VkRenderTest, CubeWithVertexFetchAndMVPAndTexture)
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2678{
2679 static const char *vertShaderText =
2680 "#version 140\n"
2681 "#extension GL_ARB_separate_shader_objects : enable\n"
2682 "#extension GL_ARB_shading_language_420pack : enable\n"
Tony Barbour6baf4402015-09-29 14:56:09 -0600[diff] [blame]2683 "layout (binding=0) uniform bufferVals {\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2684 " mat4 mvp;\n"
2685 "} myBufferVals;\n"
2686 "layout (location=0) in vec4 pos;\n"
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]2687 "layout (location=1) in vec2 input_uv;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2688 "layout (location=0) out vec2 UV;\n"
2689 "void main() {\n"
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]2690 " UV = input_uv;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2691 " gl_Position = myBufferVals.mvp * pos;\n"
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]2692 " gl_Position.y = -gl_Position.y;\n"
2693 " gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2694 "}\n";
2695
2696 static const char *fragShaderText =
2697 "#version 140\n"
2698 "#extension GL_ARB_separate_shader_objects : enable\n"
2699 "#extension GL_ARB_shading_language_420pack : enable\n"
Chia-I Wuf8385062015-01-04 16:27:24 +0800[diff] [blame]2700 "layout (binding=1) uniform sampler2D surface;\n"
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2701 "layout (location=0) out vec4 outColor;\n"
2702 "layout (location=0) in vec2 UV;\n"
2703 "void main() {\n"
2704 " outColor= textureLod(surface, UV, 0.0);\n"
2705 "}\n";
2706 glm::mat4 Projection = glm::perspective(glm::radians(45.0f), 1.0f, 0.1f, 100.0f);
2707
2708 glm::mat4 View = glm::lookAt(
2709 glm::vec3(0,3,10), // Camera is at (0,3,10), in World Space
2710 glm::vec3(0,0,0), // and looks at the origin
2711 glm::vec3(0,1,0) // Head is up (set to 0,-1,0 to look upside-down)
2712 );
2713
2714 glm::mat4 Model = glm::mat4(1.0f);
2715
2716 glm::mat4 MVP = Projection * View * Model;
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]2717 int num_verts = sizeof(g_vb_texture_Data) / sizeof(g_vb_texture_Data[0]);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2718
2719
2720 ASSERT_NO_FATAL_FAILURE(InitState());
2721 ASSERT_NO_FATAL_FAILURE(InitViewport());
Chia-I Wu9e81ebb2015-07-09 10:16:34 +0800[diff] [blame]2722 m_depth_stencil_fmt = VK_FORMAT_D16_UNORM;
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]2723 m_depthStencil->Init(m_device, (int32_t)m_width, (int32_t)m_height, m_depth_stencil_fmt);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2724
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]2725 VkConstantBufferObj meshBuffer(m_device, num_verts,
2726 sizeof(g_vb_texture_Data[0]), g_vb_texture_Data);
Mike Stroyan55658c22014-12-04 11:08:39 +0000[diff] [blame]2727 meshBuffer.BufferMemoryBarrier();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2728
Mark Lobodzinskie2d07a52015-01-29 08:55:56 -0600[diff] [blame]2729 const int buf_size = sizeof(MVP) / sizeof(float);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2730
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2731 VkConstantBufferObj mvpBuffer(m_device, buf_size, sizeof(MVP[0]), (const void*) &MVP[0][0]);
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]2732 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
2733 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2734 VkSamplerObj sampler(m_device);
2735 VkTextureObj texture(m_device);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2736
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2737 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]2738 pipelineobj.AddColorAttachment();
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2739 pipelineobj.AddShader(&vs);
2740 pipelineobj.AddShader(&ps);
2741
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2742 VkDescriptorSetObj descriptorSet(m_device);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2743 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, mvpBuffer);
Chia-I Wuf8385062015-01-04 16:27:24 +0800[diff] [blame]2744 descriptorSet.AppendSamplerTexture(&sampler, &texture);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2745
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]2746#define MESH_BIND_ID 0
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]2747 VkVertexInputBindingDescription vi_binding = {
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]2748 MESH_BIND_ID, // binding ID
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]2749 sizeof(g_vb_texture_Data[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement)
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2750 VK_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]2751 };
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2752
Courtney Goeltzenleuchter382489d2015-04-10 08:34:15 -0600[diff] [blame]2753 VkVertexInputAttributeDescription vi_attribs[2];
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]2754 vi_attribs[0].binding = MESH_BIND_ID; // Binding ID
2755 vi_attribs[0].location = 0; // location
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]2756 vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT; // format of source data
Courtney Goeltzenleuchter28846ae2015-04-30 17:44:12 -0600[diff] [blame]2757 vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex
2758 vi_attribs[1].binding = MESH_BIND_ID; // Binding ID
2759 vi_attribs[1].location = 1; // location
2760 vi_attribs[1].format = VK_FORMAT_R32G32_SFLOAT; // format of source data
2761 vi_attribs[1].offsetInBytes = 16; // Offset of uv components
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2762
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2763 pipelineobj.AddVertexInputAttribs(vi_attribs,2);
Courtney Goeltzenleuchterf5cdad02015-03-31 16:36:30 -0600[diff] [blame]2764 pipelineobj.AddVertexInputBindings(&vi_binding,1);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2765
Tony Barboure307f582015-07-10 15:29:03 -0600[diff] [blame]2766 VkPipelineDepthStencilStateCreateInfo ds_state;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2767 ds_state.depthTestEnable = VK_TRUE;
2768 ds_state.depthWriteEnable = VK_TRUE;
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]2769 ds_state.depthCompareOp = VK_COMPARE_OP_LESS_EQUAL;
Cody Northrope4bc6942015-08-26 10:01:32 -0600[diff] [blame]2770 ds_state.depthBoundsTestEnable = VK_FALSE;
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2771 ds_state.stencilTestEnable = VK_FALSE;
2772 ds_state.back.stencilDepthFailOp = VK_STENCIL_OP_KEEP;
2773 ds_state.back.stencilFailOp = VK_STENCIL_OP_KEEP;
2774 ds_state.back.stencilPassOp = VK_STENCIL_OP_KEEP;
Tony Barbour8205d902015-04-16 15:59:00 -0600[diff] [blame]2775 ds_state.back.stencilCompareOp = VK_COMPARE_OP_ALWAYS;
Tony Barbourfa6cac72015-01-16 14:27:35 -0700[diff] [blame]2776 ds_state.front = ds_state.back;
2777 pipelineobj.SetDepthStencil(&ds_state);
2778
Tony Barbour17c6ab12015-03-27 17:03:18 -0600[diff] [blame]2779 ASSERT_NO_FATAL_FAILURE(InitRenderTarget(m_depthStencil->BindInfo()));
Tobin Ehlis7f7b4422015-08-18 14:24:32 -0600[diff] [blame]2780
2781 VkCmdBufferBeginInfo cbBeginInfo;
2782 memset(&cbBeginInfo, 0, sizeof(VkCmdBufferBeginInfo));
2783 cbBeginInfo.sType = VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO;
2784 cbBeginInfo.flags = VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT;
2785 ASSERT_VK_SUCCESS(BeginCommandBuffer(&cbBeginInfo));
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2786
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2787 GenericDrawPreparation(pipelineobj, descriptorSet);
Courtney Goeltzenleuchtere3b0f3a2015-04-03 15:25:24 -0600[diff] [blame]2788
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2789 BindVertexBuffer(&meshBuffer, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2790#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2791 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2792 pDSDumpDot((char*)"triTest2.dot");
2793#endif
2794 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]2795 Draw(num_verts, 1, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2796
2797 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2798 EndCommandBuffer();
2799 QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2800
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]2801 RecordImages(m_renderTargets);
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2802 RotateTriangleVSUniform(Projection, View, Model, &mvpBuffer);
Tony Barbourf43b6982014-11-25 13:18:32 -0700[diff] [blame]2803}
Cody Northropd1ce7842014-12-09 11:17:01 -0700[diff] [blame]2804
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2805TEST_F(VkRenderTest, TriangleMixedSamplerUniformBlockBinding)
Cody Northropd1ce7842014-12-09 11:17:01 -0700[diff] [blame]2806{
2807 // This test mixes binding slots of textures and buffers, ensuring
2808 // that sparse and overlapping assignments work.
Cody Northropa0410942014-12-09 13:59:39 -0700[diff] [blame]2809 // The expected result from this test is a purple triangle, although
Cody Northropd1ce7842014-12-09 11:17:01 -0700[diff] [blame]2810 // you can modify it to move the desired result around.
2811
2812 static const char *vertShaderText =
2813 "#version 140\n"
2814 "#extension GL_ARB_separate_shader_objects : enable\n"
2815 "#extension GL_ARB_shading_language_420pack : enable\n"
2816 "void main() {\n"
2817 " vec2 vertices[3];"
2818 " vertices[0] = vec2(-0.5, -0.5);\n"
2819 " vertices[1] = vec2( 0.5, -0.5);\n"
2820 " vertices[2] = vec2( 0.5, 0.5);\n"
2821 " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
2822 "}\n";
2823
2824 static const char *fragShaderText =
2825 "#version 430\n"
2826 "#extension GL_ARB_separate_shader_objects : enable\n"
2827 "#extension GL_ARB_shading_language_420pack : enable\n"
2828 "layout (binding = 0) uniform sampler2D surface0;\n"
Chia-I Wuf8385062015-01-04 16:27:24 +0800[diff] [blame]2829 "layout (binding = 3) uniform sampler2D surface1;\n"
2830 "layout (binding = 1) uniform sampler2D surface2;\n"
2831 "layout (binding = 2) uniform sampler2D surface3;\n"
Cody Northropd1ce7842014-12-09 11:17:01 -0700[diff] [blame]2832
Cody Northropa0410942014-12-09 13:59:39 -0700[diff] [blame]2833
Tony Barbour6baf4402015-09-29 14:56:09 -0600[diff] [blame]2834 "layout (binding = 4) uniform redVal { vec4 red; };"
2835 "layout (binding = 6) uniform greenVal { vec4 green; };"
2836 "layout (binding = 5) uniform blueVal { vec4 blue; };"
2837 "layout (binding = 7) uniform whiteVal { vec4 white; };"
Cody Northropd1ce7842014-12-09 11:17:01 -0700[diff] [blame]2838 "layout (location = 0) out vec4 outColor;\n"
2839 "void main() {\n"
Cody Northropa0410942014-12-09 13:59:39 -0700[diff] [blame]2840 " outColor = red * vec4(0.00001);\n"
Cody Northropd1ce7842014-12-09 11:17:01 -0700[diff] [blame]2841 " outColor += white * vec4(0.00001);\n"
2842 " outColor += textureLod(surface2, vec2(0.5), 0.0)* vec4(0.00001);\n"
Cody Northropa0410942014-12-09 13:59:39 -0700[diff] [blame]2843 " outColor += textureLod(surface1, vec2(0.0), 0.0);//* vec4(0.00001);\n"
Cody Northropd1ce7842014-12-09 11:17:01 -0700[diff] [blame]2844 "}\n";
2845 ASSERT_NO_FATAL_FAILURE(InitState());
2846 ASSERT_NO_FATAL_FAILURE(InitViewport());
2847
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]2848 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
2849 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Cody Northropd1ce7842014-12-09 11:17:01 -0700[diff] [blame]2850
Cody Northropd1ce7842014-12-09 11:17:01 -0700[diff] [blame]2851 const float redVals[4] = { 1.0, 0.0, 0.0, 1.0 };
2852 const float greenVals[4] = { 0.0, 1.0, 0.0, 1.0 };
2853 const float blueVals[4] = { 0.0, 0.0, 1.0, 1.0 };
2854 const float whiteVals[4] = { 1.0, 1.0, 1.0, 1.0 };
2855
2856 const int redCount = sizeof(redVals) / sizeof(float);
2857 const int greenCount = sizeof(greenVals) / sizeof(float);
2858 const int blueCount = sizeof(blueVals) / sizeof(float);
2859 const int whiteCount = sizeof(whiteVals) / sizeof(float);
2860
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2861 VkConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
2862 VkConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
2863 VkConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
2864 VkConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
Cody Northropd1ce7842014-12-09 11:17:01 -0700[diff] [blame]2865
Tony Barbour2f421a02015-04-01 16:38:10 -0600[diff] [blame]2866 uint32_t tex_colors[2] = { 0xff800000, 0xff800000 };
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2867 VkSamplerObj sampler0(m_device);
2868 VkTextureObj texture0(m_device, tex_colors); // Light Red
Tony Barbour2f421a02015-04-01 16:38:10 -0600[diff] [blame]2869 tex_colors[0] = 0xff000080; tex_colors[1] = 0xff000080;
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2870 VkSamplerObj sampler2(m_device);
2871 VkTextureObj texture2(m_device, tex_colors); // Light Blue
Tony Barbour2f421a02015-04-01 16:38:10 -0600[diff] [blame]2872 tex_colors[0] = 0xff008000; tex_colors[1] = 0xff008000;
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2873 VkSamplerObj sampler4(m_device);
2874 VkTextureObj texture4(m_device, tex_colors); // Light Green
Cody Northropa0410942014-12-09 13:59:39 -0700[diff] [blame]2875
2876 // NOTE: Bindings 1,3,5,7,8,9,11,12,14,16 work for this sampler, but 6 does not!!!
2877 // TODO: Get back here ASAP and understand why.
Tony Barbour2f421a02015-04-01 16:38:10 -0600[diff] [blame]2878 tex_colors[0] = 0xffff00ff; tex_colors[1] = 0xffff00ff;
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2879 VkSamplerObj sampler7(m_device);
2880 VkTextureObj texture7(m_device, tex_colors); // Red and Blue
Cody Northropd1ce7842014-12-09 11:17:01 -0700[diff] [blame]2881
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2882 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]2883 pipelineobj.AddColorAttachment();
Cody Northropd1ce7842014-12-09 11:17:01 -0700[diff] [blame]2884 pipelineobj.AddShader(&vs);
2885 pipelineobj.AddShader(&ps);
2886
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2887 VkDescriptorSetObj descriptorSet(m_device);
Chia-I Wuf8385062015-01-04 16:27:24 +0800[diff] [blame]2888 descriptorSet.AppendSamplerTexture(&sampler0, &texture0);
2889 descriptorSet.AppendSamplerTexture(&sampler2, &texture2);
2890 descriptorSet.AppendSamplerTexture(&sampler4, &texture4);
2891 descriptorSet.AppendSamplerTexture(&sampler7, &texture7);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2892 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, redBuffer);
Chia-I Wuf8385062015-01-04 16:27:24 +0800[diff] [blame]2893 // swap blue and green
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2894 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, blueBuffer);
2895 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, greenBuffer);
2896 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
Cody Northropd1ce7842014-12-09 11:17:01 -0700[diff] [blame]2897
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2898 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2899 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Cody Northropd1ce7842014-12-09 11:17:01 -0700[diff] [blame]2900
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2901 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2902
2903#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2904 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2905 pDSDumpDot((char*)"triTest2.dot");
2906#endif
2907 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]2908 Draw(3, 1, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2909
2910 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]2911 EndCommandBuffer();
2912 QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]2913
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]2914 RecordImages(m_renderTargets);
Cody Northropd1ce7842014-12-09 11:17:01 -0700[diff] [blame]2915}
2916
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2917TEST_F(VkRenderTest, TriangleMatchingSamplerUniformBlockBinding)
Cody Northrop5fcacbc2014-12-09 19:08:54 -0700[diff] [blame]2918{
2919 // This test matches binding slots of textures and buffers, requiring
2920 // the driver to give them distinct number spaces.
2921 // The expected result from this test is a red triangle, although
2922 // you can modify it to move the desired result around.
2923
2924 static const char *vertShaderText =
2925 "#version 140\n"
2926 "#extension GL_ARB_separate_shader_objects : enable\n"
2927 "#extension GL_ARB_shading_language_420pack : enable\n"
2928 "void main() {\n"
2929 " vec2 vertices[3];"
2930 " vertices[0] = vec2(-0.5, -0.5);\n"
2931 " vertices[1] = vec2( 0.5, -0.5);\n"
2932 " vertices[2] = vec2( 0.5, 0.5);\n"
2933 " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
2934 "}\n";
2935
2936 static const char *fragShaderText =
2937 "#version 430\n"
2938 "#extension GL_ARB_separate_shader_objects : enable\n"
2939 "#extension GL_ARB_shading_language_420pack : enable\n"
2940 "layout (binding = 0) uniform sampler2D surface0;\n"
2941 "layout (binding = 1) uniform sampler2D surface1;\n"
2942 "layout (binding = 2) uniform sampler2D surface2;\n"
2943 "layout (binding = 3) uniform sampler2D surface3;\n"
Tony Barbour6baf4402015-09-29 14:56:09 -0600[diff] [blame]2944 "layout (binding = 4) uniform redVal { vec4 red; };"
2945 "layout (binding = 5) uniform greenVal { vec4 green; };"
2946 "layout (binding = 6) uniform blueVal { vec4 blue; };"
2947 "layout (binding = 7) uniform whiteVal { vec4 white; };"
Cody Northrop5fcacbc2014-12-09 19:08:54 -0700[diff] [blame]2948 "layout (location = 0) out vec4 outColor;\n"
2949 "void main() {\n"
2950 " outColor = red;// * vec4(0.00001);\n"
2951 " outColor += white * vec4(0.00001);\n"
2952 " outColor += textureLod(surface1, vec2(0.5), 0.0)* vec4(0.00001);\n"
2953 " outColor += textureLod(surface3, vec2(0.0), 0.0)* vec4(0.00001);\n"
2954 "}\n";
2955 ASSERT_NO_FATAL_FAILURE(InitState());
2956 ASSERT_NO_FATAL_FAILURE(InitViewport());
2957
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]2958 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
2959 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Cody Northrop5fcacbc2014-12-09 19:08:54 -0700[diff] [blame]2960
2961 const float redVals[4] = { 1.0, 0.0, 0.0, 1.0 };
2962 const float greenVals[4] = { 0.0, 1.0, 0.0, 1.0 };
2963 const float blueVals[4] = { 0.0, 0.0, 1.0, 1.0 };
2964 const float whiteVals[4] = { 1.0, 1.0, 1.0, 1.0 };
2965
2966 const int redCount = sizeof(redVals) / sizeof(float);
2967 const int greenCount = sizeof(greenVals) / sizeof(float);
2968 const int blueCount = sizeof(blueVals) / sizeof(float);
2969 const int whiteCount = sizeof(whiteVals) / sizeof(float);
2970
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2971 VkConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals);
2972 VkConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals);
2973 VkConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals);
2974 VkConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals);
Cody Northrop5fcacbc2014-12-09 19:08:54 -0700[diff] [blame]2975
Tony Barbour2f421a02015-04-01 16:38:10 -0600[diff] [blame]2976 uint32_t tex_colors[2] = { 0xff800000, 0xff800000 };
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2977 VkSamplerObj sampler0(m_device);
2978 VkTextureObj texture0(m_device, tex_colors); // Light Red
Tony Barbour2f421a02015-04-01 16:38:10 -0600[diff] [blame]2979 tex_colors[0] = 0xff000080; tex_colors[1] = 0xff000080;
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2980 VkSamplerObj sampler2(m_device);
2981 VkTextureObj texture2(m_device, tex_colors); // Light Blue
Tony Barbour2f421a02015-04-01 16:38:10 -0600[diff] [blame]2982 tex_colors[0] = 0xff008000; tex_colors[1] = 0xff008000;
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2983 VkSamplerObj sampler4(m_device);
2984 VkTextureObj texture4(m_device, tex_colors); // Light Green
Tony Barbour2f421a02015-04-01 16:38:10 -0600[diff] [blame]2985 tex_colors[0] = 0xffff00ff; tex_colors[1] = 0xffff00ff;
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2986 VkSamplerObj sampler7(m_device);
2987 VkTextureObj texture7(m_device, tex_colors); // Red and Blue
Cody Northrop5fcacbc2014-12-09 19:08:54 -0700[diff] [blame]2988
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2989 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]2990 pipelineobj.AddColorAttachment();
Cody Northrop5fcacbc2014-12-09 19:08:54 -0700[diff] [blame]2991 pipelineobj.AddShader(&vs);
2992 pipelineobj.AddShader(&ps);
2993
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]2994 VkDescriptorSetObj descriptorSet(m_device);
Chia-I Wuf8385062015-01-04 16:27:24 +0800[diff] [blame]2995 descriptorSet.AppendSamplerTexture(&sampler0, &texture0);
2996 descriptorSet.AppendSamplerTexture(&sampler2, &texture2);
2997 descriptorSet.AppendSamplerTexture(&sampler4, &texture4);
2998 descriptorSet.AppendSamplerTexture(&sampler7, &texture7);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]2999 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, redBuffer);
3000 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, greenBuffer);
3001 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, blueBuffer);
3002 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, whiteBuffer);
Cody Northrop5fcacbc2014-12-09 19:08:54 -0700[diff] [blame]3003
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]3004 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]3005 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Cody Northrop5fcacbc2014-12-09 19:08:54 -0700[diff] [blame]3006
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]3007 GenericDrawPreparation(pipelineobj, descriptorSet);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]3008
3009#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]3010 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]3011 pDSDumpDot((char*)"triTest2.dot");
3012#endif
3013 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]3014 Draw(3, 1, 0, 0);
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]3015
3016 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]3017 EndCommandBuffer();
3018 QueueCommandBuffer();
Tony Barbourdd4c9642015-01-09 12:55:14 -0700[diff] [blame]3019
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]3020 RecordImages(m_renderTargets);
Cody Northrop5fcacbc2014-12-09 19:08:54 -0700[diff] [blame]3021}
3022
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]3023TEST_F(VkRenderTest, TriangleUniformBufferLayout)
Cody Northrop02690bd2014-12-17 15:26:33 -0700[diff] [blame]3024{
3025 // This test populates a buffer with a variety of different data
3026 // types, then reads them out with a shader.
3027 // The expected result from this test is a green triangle
3028
3029 static const char *vertShaderText =
3030 "#version 140\n"
3031 "#extension GL_ARB_separate_shader_objects : enable\n"
3032 "#extension GL_ARB_shading_language_420pack : enable\n"
Tony Barbour6baf4402015-09-29 14:56:09 -0600[diff] [blame]3033 "layout (binding = 0) uniform mixedBuffer {\n"
Cody Northrop02690bd2014-12-17 15:26:33 -0700[diff] [blame]3034 " vec4 fRed;\n"
3035 " vec4 fGreen;\n"
3036 " layout(row_major) mat4 worldToProj;\n"
3037 " layout(row_major) mat4 projToWorld;\n"
3038 " layout(row_major) mat4 worldToView;\n"
3039 " layout(row_major) mat4 viewToProj;\n"
3040 " layout(row_major) mat4 worldToShadow[4];\n"
3041 " float fZero;\n"
3042 " float fOne;\n"
3043 " float fTwo;\n"
3044 " float fThree;\n"
3045 " vec3 fZeroZeroZero;\n"
3046 " float fFour;\n"
3047 " vec3 fZeroZeroOne;\n"
3048 " float fFive;\n"
3049 " vec3 fZeroOneZero;\n"
3050 " float fSix;\n"
3051 " float fSeven;\n"
3052 " float fEight;\n"
3053 " float fNine;\n"
3054 " vec2 fZeroZero;\n"
3055 " vec2 fZeroOne;\n"
3056 " vec4 fBlue;\n"
3057 " vec2 fOneZero;\n"
3058 " vec2 fOneOne;\n"
3059 " vec3 fZeroOneOne;\n"
3060 " float fTen;\n"
3061 " float fEleven;\n"
3062 " float fTwelve;\n"
3063 " vec3 fOneZeroZero;\n"
3064 " vec4 uvOffsets[4];\n"
3065 "};\n"
3066 "layout (location = 0) out vec4 color;"
3067 "void main() {\n"
3068
3069 " vec4 right = vec4(0.0, 1.0, 0.0, 1.0);\n"
3070 " vec4 wrong = vec4(1.0, 0.0, 0.0, 1.0);\n"
3071 " \n"
3072
3073 // do some exact comparisons, even though we should
3074 // really have an epsilon involved.
3075 " vec4 outColor = right;\n"
3076 " if (fRed != vec4(1.0, 0.0, 0.0, 1.0))\n"
3077 " outColor = wrong;\n"
3078 " if (fGreen != vec4(0.0, 1.0, 0.0, 1.0))\n"
3079 " outColor = wrong;\n"
3080 " if (fBlue != vec4(0.0, 0.0, 1.0, 1.0))\n"
3081 " outColor = wrong;\n"
3082
3083 " color = outColor;\n"
3084
3085 // generic position stuff
3086 " vec2 vertices;\n"
3087 " int vertexSelector = gl_VertexID;\n"
3088 " if (vertexSelector == 0)\n"
3089 " vertices = vec2(-0.5, -0.5);\n"
3090 " else if (vertexSelector == 1)\n"
3091 " vertices = vec2( 0.5, -0.5);\n"
3092 " else if (vertexSelector == 2)\n"
3093 " vertices = vec2( 0.5, 0.5);\n"
3094 " else\n"
3095 " vertices = vec2( 0.0, 0.0);\n"
3096 " gl_Position = vec4(vertices, 0.0, 1.0);\n"
3097 "}\n";
3098
3099 static const char *fragShaderText =
3100 "#version 140\n"
3101 "#extension GL_ARB_separate_shader_objects : enable\n"
3102 "#extension GL_ARB_shading_language_420pack : enable\n"
Tony Barbour6baf4402015-09-29 14:56:09 -0600[diff] [blame]3103 "layout (binding = 0) uniform mixedBuffer {\n"
Cody Northrop02690bd2014-12-17 15:26:33 -0700[diff] [blame]3104 " vec4 fRed;\n"
3105 " vec4 fGreen;\n"
3106 " layout(row_major) mat4 worldToProj;\n"
3107 " layout(row_major) mat4 projToWorld;\n"
3108 " layout(row_major) mat4 worldToView;\n"
3109 " layout(row_major) mat4 viewToProj;\n"
3110 " layout(row_major) mat4 worldToShadow[4];\n"
3111 " float fZero;\n"
3112 " float fOne;\n"
3113 " float fTwo;\n"
3114 " float fThree;\n"
3115 " vec3 fZeroZeroZero;\n"
3116 " float fFour;\n"
3117 " vec3 fZeroZeroOne;\n"
3118 " float fFive;\n"
3119 " vec3 fZeroOneZero;\n"
3120 " float fSix;\n"
3121 " float fSeven;\n"
3122 " float fEight;\n"
3123 " float fNine;\n"
3124 " vec2 fZeroZero;\n"
3125 " vec2 fZeroOne;\n"
3126 " vec4 fBlue;\n"
3127 " vec2 fOneZero;\n"
3128 " vec2 fOneOne;\n"
3129 " vec3 fZeroOneOne;\n"
3130 " float fTen;\n"
3131 " float fEleven;\n"
3132 " float fTwelve;\n"
3133 " vec3 fOneZeroZero;\n"
3134 " vec4 uvOffsets[4];\n"
3135 "};\n"
3136 "layout (location = 0) in vec4 color;\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]3137 "layout (location = 0) out vec4 uFragColor;\n"
Cody Northrop02690bd2014-12-17 15:26:33 -0700[diff] [blame]3138 "void main() {\n"
3139 " vec4 right = vec4(0.0, 1.0, 0.0, 1.0);\n"
3140 " vec4 wrong = vec4(1.0, 0.0, 0.0, 1.0);\n"
3141 " \n"
3142
3143 // start with VS value to ensure it passed
3144 " vec4 outColor = color;\n"
3145
3146 // do some exact comparisons, even though we should
3147 // really have an epsilon involved.
3148 " if (fRed != vec4(1.0, 0.0, 0.0, 1.0))\n"
3149 " outColor = wrong;\n"
3150 " if (fGreen != vec4(0.0, 1.0, 0.0, 1.0))\n"
3151 " outColor = wrong;\n"
3152 " if (projToWorld[1] != vec4(0.0, 2.0, 0.0, 0.0))\n"
3153 " outColor = wrong;\n"
3154 " if (worldToShadow[2][1] != vec4(0.0, 7.0, 0.0, 0.0))\n"
3155 " outColor = wrong;\n"
3156 " if (fTwo != 2.0)\n"
3157 " outColor = wrong;\n"
3158 " if (fOneOne != vec2(1.0, 1.0))\n"
3159 " outColor = wrong;\n"
3160 " if (fTen != 10.0)\n"
3161 " outColor = wrong;\n"
3162 " if (uvOffsets[2] != vec4(0.9, 1.0, 1.1, 1.2))\n"
3163 " outColor = wrong;\n"
3164 " \n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]3165 " uFragColor = outColor;\n"
Cody Northrop02690bd2014-12-17 15:26:33 -0700[diff] [blame]3166 "}\n";
3167
3168
Cody Northrop1684adb2015-08-05 11:15:02 -0600[diff] [blame]3169 const float mixedVals[196] = { 1.0f, 0.0f, 0.0f, 1.0f, // vec4 fRed; // align
3170 0.0f, 1.0f, 0.0f, 1.0f, // vec4 fGreen; // align
3171 1.0f, 0.0f, 0.0f, 1.0f, // layout(row_major) mat4 worldToProj;
3172 0.0f, 1.0f, 0.0f, 1.0f, // align
3173 0.0f, 0.0f, 1.0f, 1.0f, // align
3174 0.0f, 0.0f, 0.0f, 1.0f, // align
3175 2.0f, 0.0f, 0.0f, 2.0f, // layout(row_major) mat4 projToWorld;
3176 0.0f, 2.0f, 0.0f, 2.0f, // align
3177 0.0f, 0.0f, 2.0f, 2.0f, // align
3178 0.0f, 0.0f, 0.0f, 2.0f, // align
3179 3.0f, 0.0f, 0.0f, 3.0f, // layout(row_major) mat4 worldToView;
3180 0.0f, 3.0f, 0.0f, 3.0f, // align
3181 0.0f, 0.0f, 3.0f, 3.0f, // align
3182 0.0f, 0.0f, 0.0f, 3.0f, // align
3183 4.0f, 0.0f, 0.0f, 4.0f, // layout(row_major) mat4 viewToProj;
3184 0.0f, 4.0f, 0.0f, 4.0f, // align
3185 0.0f, 0.0f, 4.0f, 4.0f, // align
3186 0.0f, 0.0f, 0.0f, 4.0f, // align
3187 5.0f, 0.0f, 0.0f, 5.0f, // layout(row_major) mat4 worldToShadow[4];
3188 0.0f, 5.0f, 0.0f, 5.0f, // align
3189 0.0f, 0.0f, 5.0f, 5.0f, // align
3190 0.0f, 0.0f, 0.0f, 5.0f, // align
3191 6.0f, 0.0f, 0.0f, 6.0f, // align
3192 0.0f, 6.0f, 0.0f, 6.0f, // align
3193 0.0f, 0.0f, 6.0f, 6.0f, // align
3194 0.0f, 0.0f, 0.0f, 6.0f, // align
3195 7.0f, 0.0f, 0.0f, 7.0f, // align
3196 0.0f, 7.0f, 0.0f, 7.0f, // align
3197 0.0f, 0.0f, 7.0f, 7.0f, // align
3198 0.0f, 0.0f, 0.0f, 7.0f, // align
3199 8.0f, 0.0f, 0.0f, 8.0f, // align
3200 0.0f, 8.0f, 0.0f, 8.0f, // align
3201 0.0f, 0.0f, 8.0f, 8.0f, // align
3202 0.0f, 0.0f, 0.0f, 8.0f, // align
3203 0.0f, // float fZero; // align
3204 1.0f, // float fOne; // pack
3205 2.0f, // float fTwo; // pack
3206 3.0f, // float fThree; // pack
3207 0.0f, 0.0f, 0.0f, // vec3 fZeroZeroZero; // align
3208 4.0f, // float fFour; // pack
3209 0.0f, 0.0f, 1.0f, // vec3 fZeroZeroOne; // align
3210 5.0f, // float fFive; // pack
3211 0.0f, 1.0f, 0.0f, // vec3 fZeroOneZero; // align
3212 6.0f, // float fSix; // pack
3213 7.0f, // float fSeven; // align
3214 8.0f, // float fEight; // pack
3215 9.0f, // float fNine; // pack
3216 0.0f, // BUFFER
3217 0.0f, 0.0f, // vec2 fZeroZero; // align
3218 0.0f, 1.0f, // vec2 fZeroOne; // pack
3219 0.0f, 0.0f, 1.0f, 1.0f, // vec4 fBlue; // align
3220 1.0f, 0.0f, // vec2 fOneZero; // align
3221 1.0f, 1.0f, // vec2 fOneOne; // pack
3222 0.0f, 1.0f, 1.0f, // vec3 fZeroOneOne; // align
3223 10.0f, // float fTen; // pack
3224 11.0f, // float fEleven; // align
3225 12.0f, // float fTwelve; // pack
3226 0.0f, 0.0f, // BUFFER
3227 1.0f, 0.0f, 0.0f, // vec3 fOneZeroZero; // align
3228 0.0f, // BUFFER
3229 0.1f, 0.2f, 0.3f, 0.4f, // vec4 uvOffsets[4];
3230 0.5f, 0.6f, 0.7f, 0.8f, // align
3231 0.9f, 1.0f, 1.1f, 1.2f, // align
3232 1.3f, 1.4f, 1.5f, 1.6f, // align
Cody Northrop02690bd2014-12-17 15:26:33 -0700[diff] [blame]3233 };
3234
3235 ASSERT_NO_FATAL_FAILURE(InitState());
3236 ASSERT_NO_FATAL_FAILURE(InitViewport());
3237
3238 const int constCount = sizeof(mixedVals) / sizeof(float);
3239
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]3240 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
3241 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Cody Northrop02690bd2014-12-17 15:26:33 -0700[diff] [blame]3242
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]3243 VkConstantBufferObj mixedBuffer(m_device, constCount, sizeof(mixedVals[0]), (const void*) mixedVals);
Cody Northrop02690bd2014-12-17 15:26:33 -0700[diff] [blame]3244
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]3245 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]3246 pipelineobj.AddColorAttachment();
Cody Northrop02690bd2014-12-17 15:26:33 -0700[diff] [blame]3247 pipelineobj.AddShader(&vs);
3248 pipelineobj.AddShader(&ps);
3249
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]3250 VkDescriptorSetObj descriptorSet(m_device);
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]3251 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, mixedBuffer);
Cody Northrop02690bd2014-12-17 15:26:33 -0700[diff] [blame]3252
3253 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]3254 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Cody Northrop02690bd2014-12-17 15:26:33 -0700[diff] [blame]3255
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]3256 GenericDrawPreparation(pipelineobj, descriptorSet);
Cody Northrop02690bd2014-12-17 15:26:33 -0700[diff] [blame]3257
3258#ifdef DUMP_STATE_DOT
Courtney Goeltzenleuchter9cc421e2015-04-08 15:36:08 -0600[diff] [blame]3259 DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)vkGetProcAddr(gpu(), (char*)"drawStateDumpDotFile");
Cody Northrop02690bd2014-12-17 15:26:33 -0700[diff] [blame]3260 pDSDumpDot((char*)"triTest2.dot");
3261#endif
3262 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]3263 Draw(3, 1, 0, 0);
Cody Northrop02690bd2014-12-17 15:26:33 -0700[diff] [blame]3264
3265 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]3266 EndCommandBuffer();
3267 QueueCommandBuffer();
Cody Northrop02690bd2014-12-17 15:26:33 -0700[diff] [blame]3268
Courtney Goeltzenleuchtercd5ed1e2015-04-02 14:17:44 -0600[diff] [blame]3269 RecordImages(m_renderTargets);
Cody Northrop02690bd2014-12-17 15:26:33 -0700[diff] [blame]3270}
3271
Cody Northrop5fd1a7c2015-05-07 14:39:12 -0600[diff] [blame]3272TEST_F(VkRenderTest, TextureGather)
3273{
3274 // This test introduces textureGather and textureGatherOffset
3275 // Each call is compared against an expected inline color result
3276 // Green triangle means everything worked as expected
3277 // Red means something went wrong
3278
Cody Northropbe701ac2015-08-06 13:18:13 -0600[diff] [blame]3279 // disable SPV until texture gather is turned on in glsl->SPV
3280 if (!m_use_glsl) {
3281 printf("Skipping test that requires GLSL path (TextureGather)\n");
3282 return;
3283 }
3284
Cody Northrop5fd1a7c2015-05-07 14:39:12 -0600[diff] [blame]3285 static const char *vertShaderText =
3286 "#version 140\n"
3287 "#extension GL_ARB_separate_shader_objects : enable\n"
3288 "#extension GL_ARB_shading_language_420pack : enable\n"
3289 "void main() {\n"
3290 " vec2 vertices[3];"
3291 " vertices[0] = vec2(-0.5, -0.5);\n"
3292 " vertices[1] = vec2( 0.5, -0.5);\n"
3293 " vertices[2] = vec2( 0.5, 0.5);\n"
3294 " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n"
3295 "}\n";
3296
3297 static const char *fragShaderText =
3298 "#version 430\n"
3299 "#extension GL_ARB_separate_shader_objects : enable\n"
3300 "#extension GL_ARB_shading_language_420pack : enable\n"
3301 "layout (binding = 0) uniform sampler2D surface0;\n"
3302 "layout (binding = 1) uniform sampler2D surface1;\n"
3303 "layout (binding = 2) uniform sampler2D surface2;\n"
3304 "layout (binding = 3) uniform sampler2D surface3;\n"
3305 "layout (location = 0) out vec4 outColor;\n"
3306 "void main() {\n"
3307
3308 " vec4 right = vec4(0.0, 1.0, 0.0, 1.0);\n"
3309 " vec4 wrong = vec4(1.0, 0.0, 0.0, 1.0);\n"
3310
3311 " vec4 color = right;\n"
3312
3313 // Grab a normal texture sample to ensure it can work in conjuntion
3314 // with textureGather (there are some intracacies in the backend)
3315 " vec4 sampledColor = textureLod(surface2, vec2(0.5), 0.0);\n"
3316 " if (sampledColor != vec4(0.0, 0.0, 1.0, 1.0))\n"
3317 " color = wrong;\n"
3318
3319 " vec4 gatheredColor = textureGather(surface0, vec2(0.5), 0);\n"
3320 // This just grabbed four red components from a red surface
3321 " if (gatheredColor != vec4(1.0, 1.0, 1.0, 1.0))\n"
3322 " color = wrong;\n"
3323
3324 // Yes, this is using an offset of 0, we don't have enough fine grained
3325 // control of the texture contents here.
3326 " gatheredColor = textureGatherOffset(surface1, vec2(0.5), ivec2(0, 0), 1);\n"
3327 " if (gatheredColor != vec4(1.0, 1.0, 1.0, 1.0))\n"
3328 " color = wrong;\n"
3329
3330 " outColor = color;\n"
3331
3332 "}\n";
3333
3334 ASSERT_NO_FATAL_FAILURE(InitState());
3335 ASSERT_NO_FATAL_FAILURE(InitViewport());
3336
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]3337 VkShaderObj vs(m_device,vertShaderText,VK_SHADER_STAGE_VERTEX_BIT, this);
3338 VkShaderObj ps(m_device,fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Cody Northrop5fd1a7c2015-05-07 14:39:12 -0600[diff] [blame]3339
3340 uint32_t tex_colors[2] = { 0xffff0000, 0xffff0000 };
3341 VkSamplerObj sampler0(m_device);
3342 VkTextureObj texture0(m_device, tex_colors); // Red
3343 tex_colors[0] = 0xff00ff00; tex_colors[1] = 0xff00ff00;
3344 VkSamplerObj sampler1(m_device);
3345 VkTextureObj texture1(m_device, tex_colors); // Green
3346 tex_colors[0] = 0xff0000ff; tex_colors[1] = 0xff0000ff;
3347 VkSamplerObj sampler2(m_device);
3348 VkTextureObj texture2(m_device, tex_colors); // Blue
3349 tex_colors[0] = 0xffff00ff; tex_colors[1] = 0xffff00ff;
3350 VkSamplerObj sampler3(m_device);
3351 VkTextureObj texture3(m_device, tex_colors); // Red and Blue
3352
3353 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]3354 pipelineobj.AddColorAttachment();
Cody Northrop5fd1a7c2015-05-07 14:39:12 -0600[diff] [blame]3355 pipelineobj.AddShader(&vs);
3356 pipelineobj.AddShader(&ps);
3357
3358 VkDescriptorSetObj descriptorSet(m_device);
3359 descriptorSet.AppendSamplerTexture(&sampler0, &texture0);
3360 descriptorSet.AppendSamplerTexture(&sampler1, &texture1);
3361 descriptorSet.AppendSamplerTexture(&sampler2, &texture2);
3362 descriptorSet.AppendSamplerTexture(&sampler3, &texture3);
3363
3364 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]3365 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Cody Northrop5fd1a7c2015-05-07 14:39:12 -0600[diff] [blame]3366
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]3367 GenericDrawPreparation(pipelineobj, descriptorSet);
Cody Northrop5fd1a7c2015-05-07 14:39:12 -0600[diff] [blame]3368
3369 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]3370 Draw(3, 1, 0, 0);
Cody Northrop5fd1a7c2015-05-07 14:39:12 -0600[diff] [blame]3371
3372 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]3373 EndCommandBuffer();
3374 QueueCommandBuffer();
Cody Northrop5fd1a7c2015-05-07 14:39:12 -0600[diff] [blame]3375
3376 RecordImages(m_renderTargets);
Cody Northrop5fd1a7c2015-05-07 14:39:12 -0600[diff] [blame]3377}
3378
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3379TEST_F(VkRenderTest, GeometryShaderHelloWorld)
3380{
3381 // This test introduces a geometry shader that simply
3382 // changes the color of each vertex to red, green, blue
3383
3384 static const char *vertShaderText =
3385 "#version 140\n"
3386 "#extension GL_ARB_separate_shader_objects : enable\n"
3387 "#extension GL_ARB_shading_language_420pack : enable\n"
3388 "layout (location = 0) out vec4 color;"
3389 "void main() {\n"
3390
3391 // VS writes out red
3392 " color = vec4(1.0, 0.0, 0.0, 1.0);\n"
3393
3394 // generic position stuff
3395 " vec2 vertices;\n"
3396 " int vertexSelector = gl_VertexID;\n"
3397 " if (vertexSelector == 0)\n"
3398 " vertices = vec2(-0.5, -0.5);\n"
3399 " else if (vertexSelector == 1)\n"
3400 " vertices = vec2( 0.5, -0.5);\n"
3401 " else if (vertexSelector == 2)\n"
3402 " vertices = vec2( 0.5, 0.5);\n"
3403 " else\n"
3404 " vertices = vec2( 0.0, 0.0);\n"
3405 " gl_Position = vec4(vertices, 0.0, 1.0);\n"
3406
3407 "}\n";
3408
3409 static const char *geomShaderText =
3410 "#version 330\n"
3411 "#extension GL_ARB_separate_shader_objects : enable\n"
3412 "#extension GL_ARB_shading_language_420pack : enable\n"
3413 "layout( triangles ) in;\n"
3414 "layout( triangle_strip, max_vertices = 3 ) out;\n"
3415 "layout( location = 0 ) in vec4 inColor[3];\n"
3416 "layout( location = 0 ) out vec4 outColor;\n"
3417 "void main()\n"
3418 "{\n"
3419
3420 // first vertex, pass through red
3421 " gl_Position = gl_in[0].gl_Position;\n"
3422 " outColor = inColor[0];\n"
3423 " EmitVertex();\n"
3424
3425 // second vertex, green
3426 " gl_Position = gl_in[1].gl_Position;\n"
3427 " outColor = vec4(0.0, 1.0, 0.0, 1.0);\n"
3428 " EmitVertex();\n"
3429
3430 // third vertex, blue
3431 " gl_Position = gl_in[2].gl_Position;\n"
3432 " outColor = vec4(0.0, 0.0, 1.0, 1.0);\n"
3433 " EmitVertex();\n"
3434
3435 // done
3436 " EndPrimitive();\n"
3437 "}\n";
3438
3439
3440 static const char *fragShaderText =
3441 "#version 140\n"
3442 "#extension GL_ARB_separate_shader_objects : enable\n"
3443 "#extension GL_ARB_shading_language_420pack : enable\n"
3444 "layout (location = 0) in vec4 color;\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]3445 "layout (location = 0) out vec4 outColor;\n"
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3446 "void main() {\n"
3447 // pass through
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]3448 " outColor = color;\n"
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3449 "}\n";
3450
3451
3452
3453 ASSERT_NO_FATAL_FAILURE(InitState());
3454 ASSERT_NO_FATAL_FAILURE(InitViewport());
3455
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]3456 VkShaderObj vs(m_device, vertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
3457 VkShaderObj gs(m_device, geomShaderText, VK_SHADER_STAGE_GEOMETRY_BIT, this);
3458 VkShaderObj ps(m_device, fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3459
3460 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]3461 pipelineobj.AddColorAttachment();
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3462 pipelineobj.AddShader(&vs);
3463 pipelineobj.AddShader(&gs);
3464 pipelineobj.AddShader(&ps);
3465
3466 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]3467 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3468
3469 VkDescriptorSetObj descriptorSet(m_device);
3470
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]3471 GenericDrawPreparation(pipelineobj, descriptorSet);
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3472
3473 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]3474 Draw(3, 1, 0, 0);
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3475
3476 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]3477 EndCommandBuffer();
3478 QueueCommandBuffer();
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3479
3480 RecordImages(m_renderTargets);
3481}
3482
3483TEST_F(VkRenderTest, GSUniformBufferLayout)
3484{
3485 // This test is just like TriangleUniformBufferLayout but adds
3486 // geometry as a stage that also does UBO lookups
3487 // The expected result from this test is a green triangle
3488
3489 static const char *vertShaderText =
3490 "#version 140\n"
3491 "#extension GL_ARB_separate_shader_objects : enable\n"
3492 "#extension GL_ARB_shading_language_420pack : enable\n"
Tony Barbour6baf4402015-09-29 14:56:09 -0600[diff] [blame]3493 "layout (binding = 0) uniform mixedBuffer {\n"
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3494 " vec4 fRed;\n"
3495 " vec4 fGreen;\n"
3496 " layout(row_major) mat4 worldToProj;\n"
3497 " layout(row_major) mat4 projToWorld;\n"
3498 " layout(row_major) mat4 worldToView;\n"
3499 " layout(row_major) mat4 viewToProj;\n"
3500 " layout(row_major) mat4 worldToShadow[4];\n"
3501 " float fZero;\n"
3502 " float fOne;\n"
3503 " float fTwo;\n"
3504 " float fThree;\n"
3505 " vec3 fZeroZeroZero;\n"
3506 " float fFour;\n"
3507 " vec3 fZeroZeroOne;\n"
3508 " float fFive;\n"
3509 " vec3 fZeroOneZero;\n"
3510 " float fSix;\n"
3511 " float fSeven;\n"
3512 " float fEight;\n"
3513 " float fNine;\n"
3514 " vec2 fZeroZero;\n"
3515 " vec2 fZeroOne;\n"
3516 " vec4 fBlue;\n"
3517 " vec2 fOneZero;\n"
3518 " vec2 fOneOne;\n"
3519 " vec3 fZeroOneOne;\n"
3520 " float fTen;\n"
3521 " float fEleven;\n"
3522 " float fTwelve;\n"
3523 " vec3 fOneZeroZero;\n"
3524 " vec4 uvOffsets[4];\n"
3525 "};\n"
3526 "layout (location = 0) out vec4 color;"
3527 "void main() {\n"
3528
3529 " vec4 right = vec4(0.0, 1.0, 0.0, 1.0);\n"
3530 " vec4 wrong = vec4(1.0, 0.0, 0.0, 1.0);\n"
3531 " \n"
3532
3533 // do some exact comparisons, even though we should
3534 // really have an epsilon involved.
3535 " vec4 outColor = right;\n"
3536 " if (fRed != vec4(1.0, 0.0, 0.0, 1.0))\n"
3537 " outColor = wrong;\n"
3538 " if (fGreen != vec4(0.0, 1.0, 0.0, 1.0))\n"
3539 " outColor = wrong;\n"
3540 " if (fBlue != vec4(0.0, 0.0, 1.0, 1.0))\n"
3541 " outColor = wrong;\n"
3542
3543 " color = outColor;\n"
3544
3545 // generic position stuff
3546 " vec2 vertices;\n"
3547 " int vertexSelector = gl_VertexID;\n"
3548 " if (vertexSelector == 0)\n"
3549 " vertices = vec2(-0.5, -0.5);\n"
3550 " else if (vertexSelector == 1)\n"
3551 " vertices = vec2( 0.5, -0.5);\n"
3552 " else if (vertexSelector == 2)\n"
3553 " vertices = vec2( 0.5, 0.5);\n"
3554 " else\n"
3555 " vertices = vec2( 0.0, 0.0);\n"
3556 " gl_Position = vec4(vertices, 0.0, 1.0);\n"
3557 "}\n";
3558
3559 static const char *geomShaderText =
3560 "#version 330\n"
3561 "#extension GL_ARB_separate_shader_objects : enable\n"
3562 "#extension GL_ARB_shading_language_420pack : enable\n"
3563
3564 // GS layout stuff
3565 "layout( triangles ) in;\n"
3566 "layout( triangle_strip, max_vertices = 3 ) out;\n"
3567
3568 // Between stage IO
3569 "layout( location = 0 ) in vec4 inColor[3];\n"
3570 "layout( location = 0 ) out vec4 color;\n"
3571
Tony Barbour6baf4402015-09-29 14:56:09 -0600[diff] [blame]3572 "layout (binding = 0) uniform mixedBuffer {\n"
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3573 " vec4 fRed;\n"
3574 " vec4 fGreen;\n"
3575 " layout(row_major) mat4 worldToProj;\n"
3576 " layout(row_major) mat4 projToWorld;\n"
3577 " layout(row_major) mat4 worldToView;\n"
3578 " layout(row_major) mat4 viewToProj;\n"
3579 " layout(row_major) mat4 worldToShadow[4];\n"
3580 " float fZero;\n"
3581 " float fOne;\n"
3582 " float fTwo;\n"
3583 " float fThree;\n"
3584 " vec3 fZeroZeroZero;\n"
3585 " float fFour;\n"
3586 " vec3 fZeroZeroOne;\n"
3587 " float fFive;\n"
3588 " vec3 fZeroOneZero;\n"
3589 " float fSix;\n"
3590 " float fSeven;\n"
3591 " float fEight;\n"
3592 " float fNine;\n"
3593 " vec2 fZeroZero;\n"
3594 " vec2 fZeroOne;\n"
3595 " vec4 fBlue;\n"
3596 " vec2 fOneZero;\n"
3597 " vec2 fOneOne;\n"
3598 " vec3 fZeroOneOne;\n"
3599 " float fTen;\n"
3600 " float fEleven;\n"
3601 " float fTwelve;\n"
3602 " vec3 fOneZeroZero;\n"
3603 " vec4 uvOffsets[4];\n"
3604 "};\n"
3605
3606 "void main()\n"
3607 "{\n"
3608
3609 " vec4 right = vec4(0.0, 1.0, 0.0, 1.0);\n"
3610 " vec4 wrong = vec4(1.0, 0.0, 0.0, 1.0);\n"
3611
3612 // Each vertex will validate it can read VS output
3613 // then check a few values from the UBO
3614
3615 // first vertex
3616 " vec4 outColor = inColor[0];\n"
3617
3618 " if (fRed != vec4(1.0, 0.0, 0.0, 1.0))\n"
3619 " outColor = wrong;\n"
3620 " if (fGreen != vec4(0.0, 1.0, 0.0, 1.0))\n"
3621 " outColor = wrong;\n"
3622 " if (fBlue != vec4(0.0, 0.0, 1.0, 1.0))\n"
3623 " outColor = wrong;\n"
3624 " if (projToWorld[1] != vec4(0.0, 2.0, 0.0, 0.0))\n"
3625 " outColor = wrong;\n"
3626
3627 " gl_Position = gl_in[0].gl_Position;\n"
3628 " color = outColor;\n"
3629 " EmitVertex();\n"
3630
3631 // second vertex
3632 " outColor = inColor[1];\n"
3633
3634 " if (worldToShadow[2][1] != vec4(0.0, 7.0, 0.0, 0.0))\n"
3635 " outColor = wrong;\n"
3636 " if (fSix != 6.0)\n"
3637 " outColor = wrong;\n"
3638 " if (fOneOne != vec2(1.0, 1.0))\n"
3639 " outColor = wrong;\n"
3640
3641 " gl_Position = gl_in[1].gl_Position;\n"
3642 " color = outColor;\n"
3643 " EmitVertex();\n"
3644
3645 // third vertex
3646 " outColor = inColor[2];\n"
3647
3648 " if (fSeven != 7.0)\n"
3649 " outColor = wrong;\n"
3650 " if (uvOffsets[2] != vec4(0.9, 1.0, 1.1, 1.2))\n"
3651 " outColor = wrong;\n"
3652
3653 " gl_Position = gl_in[2].gl_Position;\n"
3654 " color = outColor;\n"
3655 " EmitVertex();\n"
3656
3657 // done
3658 " EndPrimitive();\n"
3659 "}\n";
3660
3661 static const char *fragShaderText =
3662 "#version 140\n"
3663 "#extension GL_ARB_separate_shader_objects : enable\n"
3664 "#extension GL_ARB_shading_language_420pack : enable\n"
Tony Barbour6baf4402015-09-29 14:56:09 -0600[diff] [blame]3665 "layout (binding = 0) uniform mixedBuffer {\n"
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3666 " vec4 fRed;\n"
3667 " vec4 fGreen;\n"
3668 " layout(row_major) mat4 worldToProj;\n"
3669 " layout(row_major) mat4 projToWorld;\n"
3670 " layout(row_major) mat4 worldToView;\n"
3671 " layout(row_major) mat4 viewToProj;\n"
3672 " layout(row_major) mat4 worldToShadow[4];\n"
3673 " float fZero;\n"
3674 " float fOne;\n"
3675 " float fTwo;\n"
3676 " float fThree;\n"
3677 " vec3 fZeroZeroZero;\n"
3678 " float fFour;\n"
3679 " vec3 fZeroZeroOne;\n"
3680 " float fFive;\n"
3681 " vec3 fZeroOneZero;\n"
3682 " float fSix;\n"
3683 " float fSeven;\n"
3684 " float fEight;\n"
3685 " float fNine;\n"
3686 " vec2 fZeroZero;\n"
3687 " vec2 fZeroOne;\n"
3688 " vec4 fBlue;\n"
3689 " vec2 fOneZero;\n"
3690 " vec2 fOneOne;\n"
3691 " vec3 fZeroOneOne;\n"
3692 " float fTen;\n"
3693 " float fEleven;\n"
3694 " float fTwelve;\n"
3695 " vec3 fOneZeroZero;\n"
3696 " vec4 uvOffsets[4];\n"
3697 "};\n"
3698 "layout (location = 0) in vec4 color;\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]3699 "layout (location = 0) out vec4 uFragColor;\n"
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3700 "void main() {\n"
3701 " vec4 right = vec4(0.0, 1.0, 0.0, 1.0);\n"
3702 " vec4 wrong = vec4(1.0, 0.0, 0.0, 1.0);\n"
3703 " \n"
3704
3705 // start with GS value to ensure it passed
3706 " vec4 outColor = color;\n"
3707
3708 // do some exact comparisons, even though we should
3709 // really have an epsilon involved.
3710 " if (fRed != vec4(1.0, 0.0, 0.0, 1.0))\n"
3711 " outColor = wrong;\n"
3712 " if (fGreen != vec4(0.0, 1.0, 0.0, 1.0))\n"
3713 " outColor = wrong;\n"
3714 " if (projToWorld[1] != vec4(0.0, 2.0, 0.0, 0.0))\n"
3715 " outColor = wrong;\n"
3716 " if (worldToShadow[2][1] != vec4(0.0, 7.0, 0.0, 0.0))\n"
3717 " outColor = wrong;\n"
3718 " if (fTwo != 2.0)\n"
3719 " outColor = wrong;\n"
3720 " if (fOneOne != vec2(1.0, 1.0))\n"
3721 " outColor = wrong;\n"
3722 " if (fTen != 10.0)\n"
3723 " outColor = wrong;\n"
3724 " if (uvOffsets[2] != vec4(0.9, 1.0, 1.1, 1.2))\n"
3725 " outColor = wrong;\n"
3726 " \n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]3727 " uFragColor = outColor;\n"
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3728 "}\n";
3729
3730
Cody Northrop1684adb2015-08-05 11:15:02 -0600[diff] [blame]3731 const float mixedVals[196] = { 1.0f, 0.0f, 0.0f, 1.0f, // vec4 fRed; // align
3732 0.0f, 1.0f, 0.0f, 1.0f, // vec4 fGreen; // align
3733 1.0f, 0.0f, 0.0f, 1.0f, // layout(row_major) mat4 worldToProj;
3734 0.0f, 1.0f, 0.0f, 1.0f, // align
3735 0.0f, 0.0f, 1.0f, 1.0f, // align
3736 0.0f, 0.0f, 0.0f, 1.0f, // align
3737 2.0f, 0.0f, 0.0f, 2.0f, // layout(row_major) mat4 projToWorld;
3738 0.0f, 2.0f, 0.0f, 2.0f, // align
3739 0.0f, 0.0f, 2.0f, 2.0f, // align
3740 0.0f, 0.0f, 0.0f, 2.0f, // align
3741 3.0f, 0.0f, 0.0f, 3.0f, // layout(row_major) mat4 worldToView;
3742 0.0f, 3.0f, 0.0f, 3.0f, // align
3743 0.0f, 0.0f, 3.0f, 3.0f, // align
3744 0.0f, 0.0f, 0.0f, 3.0f, // align
3745 4.0f, 0.0f, 0.0f, 4.0f, // layout(row_major) mat4 viewToProj;
3746 0.0f, 4.0f, 0.0f, 4.0f, // align
3747 0.0f, 0.0f, 4.0f, 4.0f, // align
3748 0.0f, 0.0f, 0.0f, 4.0f, // align
3749 5.0f, 0.0f, 0.0f, 5.0f, // layout(row_major) mat4 worldToShadow[4];
3750 0.0f, 5.0f, 0.0f, 5.0f, // align
3751 0.0f, 0.0f, 5.0f, 5.0f, // align
3752 0.0f, 0.0f, 0.0f, 5.0f, // align
3753 6.0f, 0.0f, 0.0f, 6.0f, // align
3754 0.0f, 6.0f, 0.0f, 6.0f, // align
3755 0.0f, 0.0f, 6.0f, 6.0f, // align
3756 0.0f, 0.0f, 0.0f, 6.0f, // align
3757 7.0f, 0.0f, 0.0f, 7.0f, // align
3758 0.0f, 7.0f, 0.0f, 7.0f, // align
3759 0.0f, 0.0f, 7.0f, 7.0f, // align
3760 0.0f, 0.0f, 0.0f, 7.0f, // align
3761 8.0f, 0.0f, 0.0f, 8.0f, // align
3762 0.0f, 8.0f, 0.0f, 8.0f, // align
3763 0.0f, 0.0f, 8.0f, 8.0f, // align
3764 0.0f, 0.0f, 0.0f, 8.0f, // align
3765 0.0f, // float fZero; // align
3766 1.0f, // float fOne; // pack
3767 2.0f, // float fTwo; // pack
3768 3.0f, // float fThree; // pack
3769 0.0f, 0.0f, 0.0f, // vec3 fZeroZeroZero; // align
3770 4.0f, // float fFour; // pack
3771 0.0f, 0.0f, 1.0f, // vec3 fZeroZeroOne; // align
3772 5.0f, // float fFive; // pack
3773 0.0f, 1.0f, 0.0f, // vec3 fZeroOneZero; // align
3774 6.0f, // float fSix; // pack
3775 7.0f, // float fSeven; // align
3776 8.0f, // float fEight; // pack
3777 9.0f, // float fNine; // pack
3778 0.0f, // BUFFER
3779 0.0f, 0.0f, // vec2 fZeroZero; // align
3780 0.0f, 1.0f, // vec2 fZeroOne; // pack
3781 0.0f, 0.0f, 1.0f, 1.0f, // vec4 fBlue; // align
3782 1.0f, 0.0f, // vec2 fOneZero; // align
3783 1.0f, 1.0f, // vec2 fOneOne; // pack
3784 0.0f, 1.0f, 1.0f, // vec3 fZeroOneOne; // align
3785 10.0f, // float fTen; // pack
3786 11.0f, // float fEleven; // align
3787 12.0f, // float fTwelve; // pack
3788 0.0f, 0.0f, // BUFFER
3789 1.0f, 0.0f, 0.0f, // vec3 fOneZeroZero; // align
3790 0.0f, // BUFFER
3791 0.1f, 0.2f, 0.3f, 0.4f, // vec4 uvOffsets[4];
3792 0.5f, 0.6f, 0.7f, 0.8f, // align
3793 0.9f, 1.0f, 1.1f, 1.2f, // align
3794 1.3f, 1.4f, 1.5f, 1.6f, // align
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3795 };
3796
3797
3798
3799 ASSERT_NO_FATAL_FAILURE(InitState());
3800 ASSERT_NO_FATAL_FAILURE(InitViewport());
3801
3802 const int constCount = sizeof(mixedVals) / sizeof(float);
3803
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]3804 VkShaderObj vs(m_device, vertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
3805 VkShaderObj gs(m_device, geomShaderText, VK_SHADER_STAGE_GEOMETRY_BIT, this);
3806 VkShaderObj ps(m_device, fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3807
3808 VkConstantBufferObj mixedBuffer(m_device, constCount, sizeof(mixedVals[0]), (const void*) mixedVals);
3809
3810 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]3811 pipelineobj.AddColorAttachment();
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3812 pipelineobj.AddShader(&vs);
3813 pipelineobj.AddShader(&gs);
3814 pipelineobj.AddShader(&ps);
3815
3816 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]3817 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3818
3819 VkDescriptorSetObj descriptorSet(m_device);
3820 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, mixedBuffer);
3821
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]3822 GenericDrawPreparation(pipelineobj, descriptorSet);
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3823
3824 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]3825 Draw(3, 1, 0, 0);
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3826
3827 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]3828 EndCommandBuffer();
3829 QueueCommandBuffer();
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3830
3831 RecordImages(m_renderTargets);
3832}
3833
3834TEST_F(VkRenderTest, GSPositions)
3835{
3836 // This test adds more inputs from the vertex shader and perturbs positions
3837 // Expected result is white triangle with weird positions
3838
3839 static const char *vertShaderText =
3840 "#version 140\n"
3841 "#extension GL_ARB_separate_shader_objects : enable\n"
3842 "#extension GL_ARB_shading_language_420pack : enable\n"
3843
3844 "layout(location = 0) out vec3 out_a;\n"
3845 "layout(location = 1) out vec3 out_b;\n"
3846 "layout(location = 2) out vec3 out_c;\n"
3847
3848 "void main() {\n"
3849
3850 // write a solid color to each
3851 " out_a = vec3(1.0, 0.0, 0.0);\n"
3852 " out_b = vec3(0.0, 1.0, 0.0);\n"
3853 " out_c = vec3(0.0, 0.0, 1.0);\n"
3854
3855 // generic position stuff
3856 " vec2 vertices;\n"
3857 " int vertexSelector = gl_VertexID;\n"
3858 " if (vertexSelector == 0)\n"
3859 " vertices = vec2(-0.5, -0.5);\n"
3860 " else if (vertexSelector == 1)\n"
3861 " vertices = vec2( 0.5, -0.5);\n"
3862 " else if (vertexSelector == 2)\n"
3863 " vertices = vec2( 0.5, 0.5);\n"
3864 " else\n"
3865 " vertices = vec2( 0.0, 0.0);\n"
3866 " gl_Position = vec4(vertices, 0.0, 1.0);\n"
3867
3868 "}\n";
3869
3870 static const char *geomShaderText =
3871 "#version 330\n"
3872 "#extension GL_ARB_separate_shader_objects : enable\n"
3873 "#extension GL_ARB_shading_language_420pack : enable\n"
3874 "layout( triangles ) in;\n"
3875 "layout( triangle_strip, max_vertices = 3 ) out;\n"
3876
3877 "layout(location = 0) in vec3 in_a[3];\n"
3878 "layout(location = 1) in vec3 in_b[3];\n"
3879 "layout(location = 2) in vec3 in_c[3];\n"
3880
3881 "layout(location = 0) out vec3 out_a;\n"
3882 "layout(location = 1) out vec3 out_b;\n"
3883 "layout(location = 2) out vec3 out_c;\n"
3884
3885 "void main()\n"
3886 "{\n"
3887
3888 " gl_Position = gl_in[0].gl_Position;\n"
3889 " gl_Position.xy *= vec2(0.75);\n"
3890 " out_a = in_a[0];\n"
3891 " out_b = in_b[0];\n"
3892 " out_c = in_c[0];\n"
3893 " EmitVertex();\n"
3894
3895 " gl_Position = gl_in[1].gl_Position;\n"
3896 " gl_Position.xy *= vec2(1.5);\n"
3897 " out_a = in_a[1];\n"
3898 " out_b = in_b[1];\n"
3899 " out_c = in_c[1];\n"
3900 " EmitVertex();\n"
3901
3902 " gl_Position = gl_in[2].gl_Position;\n"
3903 " gl_Position.xy *= vec2(-0.1);\n"
3904 " out_a = in_a[2];\n"
3905 " out_b = in_b[2];\n"
3906 " out_c = in_c[2];\n"
3907 " EmitVertex();\n"
3908
3909 " EndPrimitive();\n"
3910 "}\n";
3911
3912
3913 static const char *fragShaderText =
3914 "#version 140\n"
3915 "#extension GL_ARB_separate_shader_objects : enable\n"
3916 "#extension GL_ARB_shading_language_420pack : enable\n"
3917
3918 "layout(location = 0) in vec3 in_a;\n"
3919 "layout(location = 1) in vec3 in_b;\n"
3920 "layout(location = 2) in vec3 in_c;\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]3921 "layout (location = 0) out vec4 outColor;\n"
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3922
3923 "void main() {\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]3924 " outColor = vec4(in_a.x, in_b.y, in_c.z, 1.0);\n"
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3925 "}\n";
3926
3927
3928
3929 ASSERT_NO_FATAL_FAILURE(InitState());
3930 ASSERT_NO_FATAL_FAILURE(InitViewport());
3931
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]3932 VkShaderObj vs(m_device, vertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
3933 VkShaderObj gs(m_device, geomShaderText, VK_SHADER_STAGE_GEOMETRY_BIT, this);
3934 VkShaderObj ps(m_device, fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3935
3936 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]3937 pipelineobj.AddColorAttachment();
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3938 pipelineobj.AddShader(&vs);
3939 pipelineobj.AddShader(&gs);
3940 pipelineobj.AddShader(&ps);
3941
3942 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]3943 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3944
3945 VkDescriptorSetObj descriptorSet(m_device);
3946
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]3947 GenericDrawPreparation(pipelineobj, descriptorSet);
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3948
3949 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]3950 Draw(3, 1, 0, 0);
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3951
3952 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]3953 EndCommandBuffer();
3954 QueueCommandBuffer();
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]3955
3956 RecordImages(m_renderTargets);
3957}
3958
3959TEST_F(VkRenderTest, GSTriStrip)
3960{
3961 // This test emits multiple multiple triangles using a GS
3962 // Correct result is an multicolor circle
3963
3964 static const char *vertShaderText =
3965 "#version 140\n"
3966 "#extension GL_ARB_separate_shader_objects : enable\n"
3967 "#extension GL_ARB_shading_language_420pack : enable\n"
3968
3969 "void main() {\n"
3970
3971 // generic position stuff
3972 " vec2 vertices;\n"
3973 " int vertexSelector = gl_VertexID;\n"
3974 " if (vertexSelector == 0)\n"
3975 " vertices = vec2(-0.5, -0.5);\n"
3976 " else if (vertexSelector == 1)\n"
3977 " vertices = vec2( 0.5, -0.5);\n"
3978 " else if (vertexSelector == 2)\n"
3979 " vertices = vec2( 0.5, 0.5);\n"
3980 " else\n"
3981 " vertices = vec2( 0.0, 0.0);\n"
3982 " gl_Position = vec4(vertices, 0.0, 1.0);\n"
3983
3984 "}\n";
3985
3986 static const char *geomShaderText =
3987 "#version 330\n"
3988 "#extension GL_ARB_separate_shader_objects : enable\n"
3989 "#extension GL_ARB_shading_language_420pack : enable\n"
3990 "layout( triangles ) in;\n"
3991 "layout( triangle_strip, max_vertices = 18 ) out;\n"
3992
3993 "layout(location = 0) out vec4 outColor;\n"
3994
3995 "void main()\n"
3996 "{\n"
3997 // init with first position to get zw
3998 " gl_Position = gl_in[0].gl_Position;\n"
3999
4000 " vec4 red = vec4(1.0, 0.0, 0.0, 1.0);\n"
4001 " vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);\n"
4002 " vec4 blue = vec4(0.0, 0.0, 1.0, 1.0);\n"
4003 " vec4 white = vec4(1.0, 1.0, 1.0, 1.0);\n"
4004
4005 // different color per tri
4006 " vec4[6] colors = { red, white, \n"
4007 " yellow, white, \n"
4008 " blue, white }; \n"
4009
4010 // fan out the triangles
4011 " vec2[18] positions = { vec2(0.0, 0.0), vec2(-0.5, 0.0), vec2(-0.25, -0.5), \n"
4012 " vec2(0.0, 0.0), vec2(-0.25, -0.5), vec2( 0.25, -0.5), \n"
4013 " vec2(0.0, 0.0), vec2( 0.25, -0.5), vec2( 0.5, 0.0), \n"
4014 " vec2(0.0, 0.0), vec2( 0.5, 0.0), vec2( 0.25, 0.5), \n"
4015 " vec2(0.0, 0.0), vec2( 0.25, 0.5), vec2(-0.25, 0.5), \n"
4016 " vec2(0.0, 0.0), vec2(-0.25, 0.5), vec2(-0.5, 0.0) }; \n"
4017
4018 // make a triangle list of 6
4019 " for (int i = 0; i < 6; ++i) { \n"
4020 " outColor = colors[i]; \n"
4021 " for (int j = 0; j < 3; ++j) { \n"
4022 " gl_Position.xy = positions[i * 3 + j]; \n"
4023 " EmitVertex(); \n"
4024 " } \n"
4025 " EndPrimitive();\n"
4026 " } \n"
4027
4028 "}\n";
4029
4030
4031 static const char *fragShaderText =
4032 "#version 150\n"
4033 "#extension GL_ARB_separate_shader_objects : enable\n"
4034 "#extension GL_ARB_shading_language_420pack : enable\n"
4035
4036
4037 "layout(binding = 0) uniform windowDimensions {\n"
4038 " vec4 dimensions;\n"
4039 "};\n"
4040
4041 "layout(location = 0) in vec4 inColor;\n"
4042 "layout(origin_upper_left) in vec4 gl_FragCoord;\n"
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]4043 "layout (location = 0) out vec4 outColor;\n"
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]4044
4045 "void main() {\n"
4046
4047 // discard to make a nice circle
4048 " vec2 pos = abs(gl_FragCoord.xy) - vec2(dimensions.x, dimensions.y) / 2;\n"
4049 " float dist = sqrt(dot(pos, pos));\n"
4050 " if (dist > 50.0)\n"
4051 " discard;\n"
4052
GregFd6ebdb32015-06-03 18:40:50 -0600[diff] [blame]4053 " outColor = inColor;\n"
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]4054
4055 "}\n";
4056
4057
4058
4059 ASSERT_NO_FATAL_FAILURE(InitState());
4060 ASSERT_NO_FATAL_FAILURE(InitViewport());
4061
Courtney Goeltzenleuchter8e2f0972015-10-21 17:08:06 -0600[diff] [blame]4062 VkShaderObj vs(m_device, vertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
4063 VkShaderObj gs(m_device, geomShaderText, VK_SHADER_STAGE_GEOMETRY_BIT, this);
4064 VkShaderObj ps(m_device, fragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]4065
4066 VkPipelineObj pipelineobj(m_device);
Chia-I Wuc278df82015-07-07 11:50:03 +0800[diff] [blame]4067 pipelineobj.AddColorAttachment();
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]4068 pipelineobj.AddShader(&vs);
4069 pipelineobj.AddShader(&gs);
4070 pipelineobj.AddShader(&ps);
4071
4072 const float dimensions[4] = { VkRenderFramework::m_width, VkRenderFramework::m_height , 0.0, 0.0};
4073
4074 VkConstantBufferObj windowDimensions(m_device, sizeof(dimensions) / sizeof(dimensions[0]), sizeof(dimensions[0]), (const void*) dimensions);
4075
4076 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]4077 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]4078
4079 VkDescriptorSetObj descriptorSet(m_device);
4080 descriptorSet.AppendBuffer(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, windowDimensions);
4081
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]4082 GenericDrawPreparation(pipelineobj, descriptorSet);
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]4083
4084 // render triangle
Courtney Goeltzenleuchter4ff11cc2015-09-23 12:31:50 -0600[diff] [blame]4085 Draw(3, 1, 0, 0);
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]4086
4087 // finalize recording of the command buffer
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]4088 EndCommandBuffer();
4089 QueueCommandBuffer();
Cody Northropa44c2ff2015-04-15 11:19:06 -0600[diff] [blame]4090
4091 RecordImages(m_renderTargets);
4092}
4093
Chris Forbes23e6db62015-06-15 09:32:35 +1200[diff] [blame]4094TEST_F(VkRenderTest, RenderPassLoadOpClear)
4095{
4096 ASSERT_NO_FATAL_FAILURE(InitState());
4097 ASSERT_NO_FATAL_FAILURE(InitViewport());
4098
4099 /* clear via load op to full green */
4100 m_clear_via_load_op = true;
Cody Northrop2563a032015-08-25 15:26:38 -0600[diff] [blame]4101 m_clear_color.float32[0] = 0;
4102 m_clear_color.float32[1] = 1;
4103 m_clear_color.float32[2] = 0;
4104 m_clear_color.float32[3] = 0;
Chris Forbes23e6db62015-06-15 09:32:35 +1200[diff] [blame]4105 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]4106 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Chris Forbes23e6db62015-06-15 09:32:35 +1200[diff] [blame]4107 /* This command buffer contains ONLY the load op! */
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]4108 EndCommandBuffer();
4109 QueueCommandBuffer();
Chris Forbes23e6db62015-06-15 09:32:35 +1200[diff] [blame]4110
4111 RecordImages(m_renderTargets);
4112}
4113
Chris Forbes1e16cb82015-06-24 12:05:30 +1200[diff] [blame]4114TEST_F(VkRenderTest, RenderPassAttachmentClear)
4115{
4116 ASSERT_NO_FATAL_FAILURE(InitState());
4117 ASSERT_NO_FATAL_FAILURE(InitViewport());
4118
4119 /* clear via load op to full red */
4120 m_clear_via_load_op = true;
Cody Northrop2563a032015-08-25 15:26:38 -0600[diff] [blame]4121 m_clear_color.float32[0] = 1;
4122 m_clear_color.float32[1] = 0;
4123 m_clear_color.float32[2] = 0;
4124 m_clear_color.float32[3] = 0;
Chris Forbes1e16cb82015-06-24 12:05:30 +1200[diff] [blame]4125 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]4126 ASSERT_VK_SUCCESS(BeginCommandBuffer());
Chris Forbes1e16cb82015-06-24 12:05:30 +1200[diff] [blame]4127
4128 /* Load op has cleared to red */
4129
4130 /* Draw, draw, draw... */
4131
4132 /* Now, partway through this renderpass we want to clear the color
4133 * attachment again, this time to green.
4134 */
Courtney Goeltzenleuchter9feb0732015-10-15 16:51:05 -0600[diff] [blame]4135 VkClearAttachment color_attachment;
4136 color_attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
4137 color_attachment.clearValue.color.float32[0] = 0;
4138 color_attachment.clearValue.color.float32[1] = 1;
4139 color_attachment.clearValue.color.float32[2] = 0;
4140 color_attachment.clearValue.color.float32[3] = 0;
4141 color_attachment.colorAttachment = 0;
Courtney Goeltzenleuchter2ebc2342015-10-21 17:57:31 -0600[diff] [blame^]4142 VkClearRect clear_rect = { { { 0, 0 }, { (int)m_width, (int)m_height } } };
Courtney Goeltzenleuchter9feb0732015-10-15 16:51:05 -0600[diff] [blame]4143 vkCmdClearAttachments(m_cmdBuffer->handle(), 1, &color_attachment,
4144 1, &clear_rect);
Chris Forbes1e16cb82015-06-24 12:05:30 +1200[diff] [blame]4145
Tony Barbour1490c912015-07-28 10:17:20 -0600[diff] [blame]4146 EndCommandBuffer();
4147 QueueCommandBuffer();
Chris Forbes1e16cb82015-06-24 12:05:30 +1200[diff] [blame]4148
4149 RecordImages(m_renderTargets);
4150}
4151
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]4152int main(int argc, char **argv) {
Courtney Goeltzenleuchter28029792014-09-04 16:26:02 -0600[diff] [blame]4153 int result;
4154
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]4155 ::testing::InitGoogleTest(&argc, argv);
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]4156 VkTestFramework::InitArgs(&argc, argv);
Courtney Goeltzenleuchter28029792014-09-04 16:26:02 -0600[diff] [blame]4157
Chia-I Wu7133fdc2014-12-15 23:57:34 +0800[diff] [blame]4158 ::testing::AddGlobalTestEnvironment(new TestEnvironment);
Courtney Goeltzenleuchterf12c7762014-10-08 08:46:51 -0600[diff] [blame]4159
Courtney Goeltzenleuchter28029792014-09-04 16:26:02 -0600[diff] [blame]4160 result = RUN_ALL_TESTS();
4161
Tony Barbour01999182015-04-09 12:58:51 -0600[diff] [blame]4162 VkTestFramework::Finish();
Courtney Goeltzenleuchter28029792014-09-04 16:26:02 -0600[diff] [blame]4163 return result;
Courtney Goeltzenleuchterb85c5812014-08-19 18:35:50 -0600[diff] [blame]4164}