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