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