blob: 9fc0786a78c0ec039f46a9f78a4d1c6cc89ba81a [file] [log] [blame]
Courtney Goeltzenleuchtera4b278b2014-10-08 08:50:49 -06001/*
2 * XGL Tests
3 *
4 * Copyright (C) 2014 LunarG, Inc.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 *
24 * Authors:
25 * Courtney Goeltzenleuchter <courtney@lunarg.com>
26 */
27
28#include "xglrenderframework.h"
Courtney Goeltzenleuchtera4b278b2014-10-08 08:50:49 -060029
Courtney Goeltzenleuchter53d8d892014-10-08 12:20:26 -060030XglRenderFramework::XglRenderFramework() :
Courtney Goeltzenleuchter53d8d892014-10-08 12:20:26 -060031 m_cmdBuffer( XGL_NULL_HANDLE ),
Chia-I Wu837f9952014-12-15 23:29:34 +080032 m_stateRaster( XGL_NULL_HANDLE ),
33 m_colorBlend( XGL_NULL_HANDLE ),
Courtney Goeltzenleuchter02d33c12014-10-08 14:26:40 -060034 m_stateViewport( XGL_NULL_HANDLE ),
Chia-I Wu837f9952014-12-15 23:29:34 +080035 m_stateDepthStencil( XGL_NULL_HANDLE ),
Courtney Goeltzenleuchter02d33c12014-10-08 14:26:40 -060036 m_width( 256.0 ), // default window width
37 m_height( 256.0 ) // default window height
Courtney Goeltzenleuchtera4b278b2014-10-08 08:50:49 -060038{
Chia-I Wuecebf752014-12-05 10:45:15 +080039 m_renderTargetCount = 1;
40
Jeremy Hayesa058eee2015-01-23 08:51:43 -070041 m_render_target_fmt = XGL_FMT_R8G8B8A8_UNORM;
Courtney Goeltzenleuchter32e486c2014-10-22 14:12:38 -060042
Courtney Goeltzenleuchter32e486c2014-10-22 14:12:38 -060043 m_depthStencilBinding.view = XGL_NULL_HANDLE;
Courtney Goeltzenleuchtera4b278b2014-10-08 08:50:49 -060044}
45
46XglRenderFramework::~XglRenderFramework()
47{
Courtney Goeltzenleuchter53d8d892014-10-08 12:20:26 -060048
49}
50
51void XglRenderFramework::InitFramework()
52{
53 XGL_RESULT err;
54
Jon Ashburn1e464892015-01-29 15:48:00 -070055 err = xglCreateInstance(&app_info, NULL, &this->inst);
56 ASSERT_XGL_SUCCESS(err);
57 err = xglEnumerateGpus(inst, XGL_MAX_PHYSICAL_GPUS, &this->gpu_count,
58 objs);
Courtney Goeltzenleuchter53d8d892014-10-08 12:20:26 -060059 ASSERT_XGL_SUCCESS(err);
Jon Ashburnbf843b22014-11-26 11:06:49 -070060 ASSERT_GE(this->gpu_count, 1) << "No GPU available";
Courtney Goeltzenleuchter53d8d892014-10-08 12:20:26 -060061
62 m_device = new XglDevice(0, objs[0]);
63 m_device->get_device_queue();
64}
65
66void XglRenderFramework::ShutdownFramework()
67{
68 if (m_colorBlend) xglDestroyObject(m_colorBlend);
Courtney Goeltzenleuchter53d8d892014-10-08 12:20:26 -060069 if (m_stateDepthStencil) xglDestroyObject(m_stateDepthStencil);
70 if (m_stateRaster) xglDestroyObject(m_stateRaster);
71 if (m_cmdBuffer) xglDestroyObject(m_cmdBuffer);
Courtney Goeltzenleuchtera4b278b2014-10-08 08:50:49 -060072
73 if (m_stateViewport) {
74 xglDestroyObject(m_stateViewport);
75 }
76
Courtney Goeltzenleuchter53d8d892014-10-08 12:20:26 -060077 // reset the driver
Chia-I Wub76e0fa2014-12-28 14:27:28 +080078 delete m_device;
Jon Ashburn1e464892015-01-29 15:48:00 -070079 xglDestroyInstance(this->inst);
Courtney Goeltzenleuchtera4b278b2014-10-08 08:50:49 -060080}
81
Courtney Goeltzenleuchter53d8d892014-10-08 12:20:26 -060082void XglRenderFramework::InitState()
Courtney Goeltzenleuchtera4b278b2014-10-08 08:50:49 -060083{
84 XGL_RESULT err;
85
Jeremy Hayesa058eee2015-01-23 08:51:43 -070086 m_render_target_fmt = XGL_FMT_R8G8B8A8_UNORM;
Courtney Goeltzenleuchtera4b278b2014-10-08 08:50:49 -060087
88 // create a raster state (solid, back-face culling)
Tony Barbourf52346d2015-01-16 14:27:35 -070089 XGL_DYNAMIC_RS_STATE_CREATE_INFO raster = {};
90 raster.sType = XGL_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO;
91 raster.pointSize = 1.0;
92
93 err = xglCreateDynamicRasterState( device(), &raster, &m_stateRaster );
Courtney Goeltzenleuchtera4b278b2014-10-08 08:50:49 -060094 ASSERT_XGL_SUCCESS(err);
95
Tony Barbourf52346d2015-01-16 14:27:35 -070096 XGL_DYNAMIC_CB_STATE_CREATE_INFO blend = {};
97 blend.sType = XGL_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO;
98 err = xglCreateDynamicColorBlendState(device(), &blend, &m_colorBlend);
Courtney Goeltzenleuchtera4b278b2014-10-08 08:50:49 -060099 ASSERT_XGL_SUCCESS( err );
100
Tony Barbourf52346d2015-01-16 14:27:35 -0700101 XGL_DYNAMIC_DS_STATE_CREATE_INFO depthStencil = {};
102 depthStencil.sType = XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO;
Courtney Goeltzenleuchtera4b278b2014-10-08 08:50:49 -0600103 depthStencil.minDepth = 0.f;
104 depthStencil.maxDepth = 1.f;
Tony Barbourf52346d2015-01-16 14:27:35 -0700105 depthStencil.stencilFrontRef = 0;
106 depthStencil.stencilBackRef = 0;
Courtney Goeltzenleuchtera4b278b2014-10-08 08:50:49 -0600107
Tony Barbourf52346d2015-01-16 14:27:35 -0700108 err = xglCreateDynamicDepthStencilState( device(), &depthStencil, &m_stateDepthStencil );
Courtney Goeltzenleuchtera4b278b2014-10-08 08:50:49 -0600109 ASSERT_XGL_SUCCESS( err );
110
111 XGL_CMD_BUFFER_CREATE_INFO cmdInfo = {};
112
113 cmdInfo.sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO;
114 cmdInfo.queueType = XGL_QUEUE_TYPE_GRAPHICS;
115 err = xglCreateCommandBuffer(device(), &cmdInfo, &m_cmdBuffer);
116 ASSERT_XGL_SUCCESS(err) << "xglCreateCommandBuffer failed";
117}
118
Courtney Goeltzenleuchtera4b278b2014-10-08 08:50:49 -0600119void XglRenderFramework::InitViewport(float width, float height)
120{
121 XGL_RESULT err;
122
Tony Barbourf52346d2015-01-16 14:27:35 -0700123 XGL_VIEWPORT viewport;
Courtney Goeltzenleuchterbbe3cc52015-02-11 14:13:34 -0700124 XGL_RECT scissor;
Courtney Goeltzenleuchtera4b278b2014-10-08 08:50:49 -0600125
Tony Barbourf52346d2015-01-16 14:27:35 -0700126 XGL_DYNAMIC_VP_STATE_CREATE_INFO viewportCreate = {};
127 viewportCreate.sType = XGL_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO;
Courtney Goeltzenleuchterbbe3cc52015-02-11 14:13:34 -0700128 viewportCreate.viewportAndScissorCount = 1;
Tony Barbourf52346d2015-01-16 14:27:35 -0700129 viewport.originX = 0;
130 viewport.originY = 0;
131 viewport.width = 1.f * width;
132 viewport.height = 1.f * height;
133 viewport.minDepth = 0.f;
134 viewport.maxDepth = 1.f;
Courtney Goeltzenleuchterbbe3cc52015-02-11 14:13:34 -0700135 scissor.extent.width = width;
136 scissor.extent.height = height;
137 scissor.offset.x = 0;
138 scissor.offset.y = 0;
Tony Barbourf52346d2015-01-16 14:27:35 -0700139 viewportCreate.pViewports = &viewport;
Courtney Goeltzenleuchterbbe3cc52015-02-11 14:13:34 -0700140 viewportCreate.pScissors = &scissor;
Tony Barbourf52346d2015-01-16 14:27:35 -0700141
142 err = xglCreateDynamicViewportState( device(), &viewportCreate, &m_stateViewport );
Courtney Goeltzenleuchtera4b278b2014-10-08 08:50:49 -0600143 ASSERT_XGL_SUCCESS( err );
144 m_width = width;
145 m_height = height;
146}
147
Courtney Goeltzenleuchter02d33c12014-10-08 14:26:40 -0600148void XglRenderFramework::InitViewport()
149{
150 InitViewport(m_width, m_height);
151}
152
Courtney Goeltzenleuchtera4b278b2014-10-08 08:50:49 -0600153void XglRenderFramework::InitRenderTarget()
154{
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600155 uint32_t i;
Chia-I Wuecebf752014-12-05 10:45:15 +0800156
157 for (i = 0; i < m_renderTargetCount; i++) {
Chia-I Wuf50ee212014-12-29 14:31:52 +0800158 XglImage *img = new XglImage(m_device);
159 img->init(m_width, m_height, m_render_target_fmt,
160 XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT |
161 XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
Tony Barbourf52346d2015-01-16 14:27:35 -0700162 m_colorBindings[i].view = img->targetView();
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000163 m_colorBindings[i].layout = XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
Tony Barbourf52346d2015-01-16 14:27:35 -0700164 m_renderTargets.push_back(img);
Chia-I Wuecebf752014-12-05 10:45:15 +0800165 }
Jeremy Hayesd65ae082015-01-14 16:17:08 -0700166 // Create Framebuffer and RenderPass with color attachments and any depth/stencil attachment
167 XGL_ATTACHMENT_LOAD_OP load_op = XGL_ATTACHMENT_LOAD_OP_LOAD;
168 XGL_ATTACHMENT_STORE_OP store_op = XGL_ATTACHMENT_STORE_OP_STORE;
169 XGL_DEPTH_STENCIL_BIND_INFO *dsBinding;
170 if (m_depthStencilBinding.view)
171 dsBinding = &m_depthStencilBinding;
172 else
173 dsBinding = NULL;
174 const XGL_FRAMEBUFFER_CREATE_INFO fb_info = {
175 .sType = XGL_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
176 .pNext = NULL,
177 .colorAttachmentCount = m_renderTargetCount,
178 .pColorAttachments = m_colorBindings,
179 .pDepthStencilAttachment = dsBinding,
180 .sampleCount = 1,
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600181 .width = (uint32_t)m_width,
182 .height = (uint32_t)m_height,
Mark Lobodzinskidffa1202015-01-27 13:24:03 -0600183 .layers = 1,
Jeremy Hayesd65ae082015-01-14 16:17:08 -0700184 };
185 XGL_RENDER_PASS_CREATE_INFO rp_info;
186 memset(&rp_info, 0 , sizeof(rp_info));
187 xglCreateFramebuffer(device(), &fb_info, &(rp_info.framebuffer));
188 rp_info.sType = XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
189 rp_info.renderArea.extent.width = m_width;
190 rp_info.renderArea.extent.height = m_height;
191 rp_info.pColorLoadOps = &load_op;
192 rp_info.pColorStoreOps = &store_op;
193 rp_info.depthLoadOp = XGL_ATTACHMENT_LOAD_OP_LOAD;
194 rp_info.depthStoreOp = XGL_ATTACHMENT_STORE_OP_STORE;
195 rp_info.stencilLoadOp = XGL_ATTACHMENT_LOAD_OP_LOAD;
196 rp_info.stencilStoreOp = XGL_ATTACHMENT_STORE_OP_STORE;
197 xglCreateRenderPass(device(), &rp_info, &m_renderPass);
Courtney Goeltzenleuchtera4b278b2014-10-08 08:50:49 -0600198}
199
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600200XglDevice::XglDevice(uint32_t id, XGL_PHYSICAL_GPU obj) :
Chia-I Wufb1459b2014-12-29 15:23:20 +0800201 xgl_testing::Device(obj), id(id)
202{
203 init();
204
205 props = gpu().properties();
206 queue_props = &gpu().queue_properties()[0];
207}
208
209void XglDevice::get_device_queue()
210{
211 ASSERT_NE(true, graphics_queues().empty());
212 m_queue = graphics_queues()[0]->obj();
213}
214
Tony Barboure2c58df2014-11-25 13:18:32 -0700215XglDescriptorSetObj::XglDescriptorSetObj(XglDevice *device)
216{
217 m_device = device;
218 m_nextSlot = 0;
219
220}
221
Chia-I Wu11078b02015-01-04 16:27:24 +0800222XglDescriptorSetObj::~XglDescriptorSetObj()
Tony Barboure2c58df2014-11-25 13:18:32 -0700223{
Chia-I Wu11078b02015-01-04 16:27:24 +0800224 delete m_set;
Tony Barboure2c58df2014-11-25 13:18:32 -0700225}
Tony Barbour82c39522014-12-04 14:33:33 -0700226
Chia-I Wu11078b02015-01-04 16:27:24 +0800227int XglDescriptorSetObj::AppendDummy()
Tony Barboure2c58df2014-11-25 13:18:32 -0700228{
Chia-I Wu11078b02015-01-04 16:27:24 +0800229 /* request a descriptor but do not update it */
230 XGL_DESCRIPTOR_TYPE_COUNT tc = {};
231 tc.type = XGL_DESCRIPTOR_TYPE_RAW_BUFFER;
232 tc.count = 1;
233 m_type_counts.push_back(tc);
Tony Barboure2c58df2014-11-25 13:18:32 -0700234
Chia-I Wu11078b02015-01-04 16:27:24 +0800235 return m_nextSlot++;
Tony Barboure2c58df2014-11-25 13:18:32 -0700236}
Tony Barbour82c39522014-12-04 14:33:33 -0700237
Chia-I Wu11078b02015-01-04 16:27:24 +0800238int XglDescriptorSetObj::AppendBuffer(XGL_DESCRIPTOR_TYPE type, XglConstantBufferObj *constantBuffer)
Tony Barboure2c58df2014-11-25 13:18:32 -0700239{
Chia-I Wu11078b02015-01-04 16:27:24 +0800240 XGL_DESCRIPTOR_TYPE_COUNT tc = {};
241 tc.type = type;
242 tc.count = 1;
243 m_type_counts.push_back(tc);
Tony Barboure2c58df2014-11-25 13:18:32 -0700244
Chia-I Wu11078b02015-01-04 16:27:24 +0800245 m_bufferInfo.push_back(&constantBuffer->m_bufferViewInfo);
246
247 m_updateBuffers.push_back(xgl_testing::DescriptorSet::update(type, m_nextSlot, 1,
248 (const XGL_BUFFER_VIEW_ATTACH_INFO **) NULL));
249
250 return m_nextSlot++;
Tony Barboure2c58df2014-11-25 13:18:32 -0700251}
Tony Barbour82c39522014-12-04 14:33:33 -0700252
Chia-I Wu11078b02015-01-04 16:27:24 +0800253int XglDescriptorSetObj::AppendSamplerTexture( XglSamplerObj* sampler, XglTextureObj* texture)
Tony Barboure2c58df2014-11-25 13:18:32 -0700254{
Chia-I Wu11078b02015-01-04 16:27:24 +0800255 XGL_DESCRIPTOR_TYPE_COUNT tc = {};
256 tc.type = XGL_DESCRIPTOR_TYPE_SAMPLER_TEXTURE;
257 tc.count = 1;
258 m_type_counts.push_back(tc);
Tony Barboure2c58df2014-11-25 13:18:32 -0700259
Chia-I Wu11078b02015-01-04 16:27:24 +0800260 XGL_SAMPLER_IMAGE_VIEW_INFO tmp = {};
261 tmp.pSampler = sampler->obj();
262 tmp.pImageView = &texture->m_textureViewInfo;
263 m_samplerTextureInfo.push_back(tmp);
Tony Barboure2c58df2014-11-25 13:18:32 -0700264
Chia-I Wu11078b02015-01-04 16:27:24 +0800265 m_updateSamplerTextures.push_back(xgl_testing::DescriptorSet::update(m_nextSlot, 1,
266 (const XGL_SAMPLER_IMAGE_VIEW_INFO *) NULL));
Tony Barboure2c58df2014-11-25 13:18:32 -0700267
Chia-I Wu11078b02015-01-04 16:27:24 +0800268 return m_nextSlot++;
Tony Barboure2c58df2014-11-25 13:18:32 -0700269}
Chia-I Wu11078b02015-01-04 16:27:24 +0800270
271XGL_DESCRIPTOR_SET_LAYOUT XglDescriptorSetObj::GetLayout()
Tony Barbourb5f4d082014-12-17 10:54:03 -0700272{
Chia-I Wu11078b02015-01-04 16:27:24 +0800273 return m_layout.obj();
Tony Barbourb5f4d082014-12-17 10:54:03 -0700274}
275
276XGL_DESCRIPTOR_SET XglDescriptorSetObj::GetDescriptorSetHandle()
277{
Chia-I Wu11078b02015-01-04 16:27:24 +0800278 return m_set->obj();
Tony Barbourb5f4d082014-12-17 10:54:03 -0700279}
Tony Barboure2c58df2014-11-25 13:18:32 -0700280
Chia-I Wu11078b02015-01-04 16:27:24 +0800281void XglDescriptorSetObj::CreateXGLDescriptorSet(XglCommandBufferObj *cmdBuffer)
Tony Barbour824b7712014-12-18 17:06:21 -0700282{
Chia-I Wu11078b02015-01-04 16:27:24 +0800283 // create XGL_DESCRIPTOR_REGION
284 XGL_DESCRIPTOR_REGION_CREATE_INFO region = {};
285 region.sType = XGL_STRUCTURE_TYPE_DESCRIPTOR_REGION_CREATE_INFO;
286 region.count = m_type_counts.size();
287 region.pTypeCount = &m_type_counts[0];
288 init(*m_device, XGL_DESCRIPTOR_REGION_USAGE_ONE_SHOT, 1, region);
Tony Barbour824b7712014-12-18 17:06:21 -0700289
Chia-I Wu11078b02015-01-04 16:27:24 +0800290 // create XGL_DESCRIPTOR_SET_LAYOUT
291 vector<XGL_DESCRIPTOR_SET_LAYOUT_CREATE_INFO> layout;
292 layout.resize(m_type_counts.size());
293 for (int i = 0; i < m_type_counts.size(); i++) {
294 layout[i].sType = XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
295 layout[i].descriptorType = m_type_counts[i].type;
296 layout[i].count = m_type_counts[i].count;
297 layout[i].stageFlags = XGL_SHADER_STAGE_FLAGS_ALL;
298 layout[i].immutableSampler = XGL_NULL_HANDLE;
Tony Barboure2c58df2014-11-25 13:18:32 -0700299
Chia-I Wu11078b02015-01-04 16:27:24 +0800300 if (i < m_type_counts.size() - 1)
301 layout[i].pNext = &layout[i + 1];
302 else
303 layout[i].pNext = NULL;
Tony Barboure2c58df2014-11-25 13:18:32 -0700304 }
Chia-I Wuac0f1e72014-12-28 22:32:36 +0800305
Chia-I Wu11078b02015-01-04 16:27:24 +0800306 m_layout.init(*m_device, 0, layout[0]);
Tony Barboure2c58df2014-11-25 13:18:32 -0700307
Chia-I Wu11078b02015-01-04 16:27:24 +0800308 // create XGL_DESCRIPTOR_SET
309 m_set = alloc_sets(XGL_DESCRIPTOR_SET_USAGE_STATIC, m_layout);
310
311 // build the update chain
312 for (int i = 0; i < m_updateBuffers.size(); i++) {
313 m_updateBuffers[i].pBufferViews = &m_bufferInfo[i];
314
315 if (i < m_updateBuffers.size() - 1)
316 m_updateBuffers[i].pNext = &m_updateBuffers[i + 1];
317 else if (m_updateSamplerTextures.empty())
318 m_updateBuffers[i].pNext = NULL;
319 else
320 m_updateBuffers[i].pNext = &m_updateSamplerTextures[0];
321 }
322 for (int i = 0; i < m_updateSamplerTextures.size(); i++) {
323 m_updateSamplerTextures[i].pSamplerImageViews = &m_samplerTextureInfo[i];
324
325 if (i < m_updateSamplerTextures.size() - 1)
326 m_updateSamplerTextures[i].pNext = &m_updateSamplerTextures[i + 1];
327 else
328 m_updateSamplerTextures[i].pNext = NULL;
329 }
330 const void *chain = (!m_updateBuffers.empty()) ? (const void *) &m_updateBuffers[0] :
331 (!m_updateSamplerTextures.empty()) ? (const void *) &m_updateSamplerTextures[0] :
332 NULL;
333
334 // do the updates
335 m_device->begin_descriptor_region_update(XGL_DESCRIPTOR_UPDATE_MODE_FASTEST);
336 clear_sets(*m_set);
337 m_set->update(chain);
338 m_device->end_descriptor_region_update(*cmdBuffer);
Tony Barbour25ef8a62014-12-03 13:59:18 -0700339}
Tony Barboure2c58df2014-11-25 13:18:32 -0700340
Chia-I Wua6bc0ce2014-12-29 14:38:28 +0800341XglImage::XglImage(XglDevice *dev)
342{
343 m_device = dev;
344 m_imageInfo.view = XGL_NULL_HANDLE;
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000345 m_imageInfo.layout = XGL_IMAGE_LAYOUT_GENERAL;
Chia-I Wua6bc0ce2014-12-29 14:38:28 +0800346}
347
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600348void XglImage::init(uint32_t w, uint32_t h,
Chia-I Wua6bc0ce2014-12-29 14:38:28 +0800349 XGL_FORMAT fmt, XGL_FLAGS usage,
350 XGL_IMAGE_TILING tiling)
351{
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600352 uint32_t mipCount;
Chia-I Wua6bc0ce2014-12-29 14:38:28 +0800353
354 mipCount = 0;
355
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600356 uint32_t _w = w;
357 uint32_t _h = h;
Chia-I Wua6bc0ce2014-12-29 14:38:28 +0800358 while( ( _w > 0 ) || ( _h > 0 ) )
359 {
360 _w >>= 1;
361 _h >>= 1;
362 mipCount++;
363 }
364
365 XGL_IMAGE_CREATE_INFO imageCreateInfo = xgl_testing::Image::create_info();
366 imageCreateInfo.imageType = XGL_IMAGE_2D;
367 imageCreateInfo.format = fmt;
368 imageCreateInfo.extent.width = w;
369 imageCreateInfo.extent.height = h;
370 imageCreateInfo.mipLevels = mipCount;
371 imageCreateInfo.tiling = tiling;
372
373 imageCreateInfo.usage = usage;
374
375 xgl_testing::Image::init(*m_device, imageCreateInfo);
376
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000377 m_imageInfo.layout = XGL_IMAGE_LAYOUT_GENERAL;
Chia-I Wua6bc0ce2014-12-29 14:38:28 +0800378
379 XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO createView = {
380 XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO,
381 XGL_NULL_HANDLE,
382 obj(),
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700383 XGL_FMT_R8G8B8A8_UNORM,
Chia-I Wua6bc0ce2014-12-29 14:38:28 +0800384 0,
385 0,
386 1
387 };
388
389 m_targetView.init(*m_device, createView);
390}
391
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600392XGL_RESULT XglImage::MapMemory(void** ptr)
Chia-I Wua6bc0ce2014-12-29 14:38:28 +0800393{
394 *ptr = map();
395 return (*ptr) ? XGL_SUCCESS : XGL_ERROR_UNKNOWN;
396}
397
398XGL_RESULT XglImage::UnmapMemory()
399{
400 unmap();
401 return XGL_SUCCESS;
402}
403
Chia-I Wu13a3aa82014-12-28 15:55:09 +0800404XglTextureObj::XglTextureObj(XglDevice *device)
Tony Barboure2c58df2014-11-25 13:18:32 -0700405{
406 m_device = device;
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700407 const XGL_FORMAT tex_format = XGL_FMT_B8G8R8A8_UNORM;
Tony Barboure2c58df2014-11-25 13:18:32 -0700408 const uint32_t tex_colors[2] = { 0xffff0000, 0xff00ff00 };
Tony Barboure2c58df2014-11-25 13:18:32 -0700409
410 memset(&m_textureViewInfo,0,sizeof(m_textureViewInfo));
411
412 m_textureViewInfo.sType = XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO;
413
414 const XGL_IMAGE_CREATE_INFO image = {
415 .sType = XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
416 .pNext = NULL,
417 .imageType = XGL_IMAGE_2D,
418 .format = tex_format,
Chia-I Wu13a3aa82014-12-28 15:55:09 +0800419 .extent = { 16, 16, 1 },
Tony Barboure2c58df2014-11-25 13:18:32 -0700420 .mipLevels = 1,
421 .arraySize = 1,
422 .samples = 1,
423 .tiling = XGL_LINEAR_TILING,
424 .usage = XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT,
425 .flags = 0,
426 };
427
Tony Barboure2c58df2014-11-25 13:18:32 -0700428 XGL_IMAGE_VIEW_CREATE_INFO view;
429 view.sType = XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
430 view.pNext = NULL;
431 view.image = XGL_NULL_HANDLE;
432 view.viewType = XGL_IMAGE_VIEW_2D;
433 view.format = image.format;
434 view.channels.r = XGL_CHANNEL_SWIZZLE_R;
435 view.channels.g = XGL_CHANNEL_SWIZZLE_G;
436 view.channels.b = XGL_CHANNEL_SWIZZLE_B;
437 view.channels.a = XGL_CHANNEL_SWIZZLE_A;
438 view.subresourceRange.aspect = XGL_IMAGE_ASPECT_COLOR;
439 view.subresourceRange.baseMipLevel = 0;
440 view.subresourceRange.mipLevels = 1;
441 view.subresourceRange.baseArraySlice = 0;
442 view.subresourceRange.arraySize = 1;
443 view.minLod = 0.0f;
444
Tony Barboure2c58df2014-11-25 13:18:32 -0700445 /* create image */
Chia-I Wu13a3aa82014-12-28 15:55:09 +0800446 init(*m_device, image);
Tony Barboure2c58df2014-11-25 13:18:32 -0700447
448 /* create image view */
Chia-I Wu13a3aa82014-12-28 15:55:09 +0800449 view.image = obj();
450 m_textureView.init(*m_device, view);
Tony Barboure2c58df2014-11-25 13:18:32 -0700451
Chia-I Wu13a3aa82014-12-28 15:55:09 +0800452 XGL_SUBRESOURCE_LAYOUT layout =
453 subresource_layout(subresource(XGL_IMAGE_ASPECT_COLOR, 0, 0));
454 m_rowPitch = layout.rowPitch;
Tony Barboure2c58df2014-11-25 13:18:32 -0700455
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600456 void *data;
457 int32_t x, y;
Tony Barboure2c58df2014-11-25 13:18:32 -0700458
Chia-I Wu13a3aa82014-12-28 15:55:09 +0800459 data = map();
Tony Barboure2c58df2014-11-25 13:18:32 -0700460
Chia-I Wu13a3aa82014-12-28 15:55:09 +0800461 for (y = 0; y < extent().height; y++) {
Tony Barboure2c58df2014-11-25 13:18:32 -0700462 uint32_t *row = (uint32_t *) ((char *) data + layout.rowPitch * y);
Chia-I Wu13a3aa82014-12-28 15:55:09 +0800463 for (x = 0; x < extent().width; x++)
Tony Barboure2c58df2014-11-25 13:18:32 -0700464 row[x] = tex_colors[(x & 1) ^ (y & 1)];
465 }
466
Chia-I Wu13a3aa82014-12-28 15:55:09 +0800467 unmap();
Tony Barboure2c58df2014-11-25 13:18:32 -0700468
Chia-I Wu13a3aa82014-12-28 15:55:09 +0800469 m_textureViewInfo.view = m_textureView.obj();
Tony Barboure2c58df2014-11-25 13:18:32 -0700470
471}
Tony Barbour82c39522014-12-04 14:33:33 -0700472
Tony Barboure2c58df2014-11-25 13:18:32 -0700473void XglTextureObj::ChangeColors(uint32_t color1, uint32_t color2)
474{
Tony Barboure2c58df2014-11-25 13:18:32 -0700475 const uint32_t tex_colors[2] = { color1, color2 };
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600476 void *data;
Tony Barboure2c58df2014-11-25 13:18:32 -0700477
Chia-I Wu13a3aa82014-12-28 15:55:09 +0800478 data = map();
Tony Barboure2c58df2014-11-25 13:18:32 -0700479
Chia-I Wu13a3aa82014-12-28 15:55:09 +0800480 for (int y = 0; y < extent().height; y++) {
Tony Barboure2c58df2014-11-25 13:18:32 -0700481 uint32_t *row = (uint32_t *) ((char *) data + m_rowPitch * y);
Chia-I Wu13a3aa82014-12-28 15:55:09 +0800482 for (int x = 0; x < extent().width; x++)
Tony Barboure2c58df2014-11-25 13:18:32 -0700483 row[x] = tex_colors[(x & 1) ^ (y & 1)];
484 }
485
Chia-I Wu13a3aa82014-12-28 15:55:09 +0800486 unmap();
Tony Barboure2c58df2014-11-25 13:18:32 -0700487}
488
489XglSamplerObj::XglSamplerObj(XglDevice *device)
490{
Tony Barboure2c58df2014-11-25 13:18:32 -0700491 m_device = device;
Tony Barboure2c58df2014-11-25 13:18:32 -0700492
Chia-I Wue9864b52014-12-28 16:32:24 +0800493 XGL_SAMPLER_CREATE_INFO samplerCreateInfo;
494 memset(&samplerCreateInfo,0,sizeof(samplerCreateInfo));
495 samplerCreateInfo.sType = XGL_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
496 samplerCreateInfo.magFilter = XGL_TEX_FILTER_NEAREST;
497 samplerCreateInfo.minFilter = XGL_TEX_FILTER_NEAREST;
498 samplerCreateInfo.mipMode = XGL_TEX_MIPMAP_BASE;
499 samplerCreateInfo.addressU = XGL_TEX_ADDRESS_WRAP;
500 samplerCreateInfo.addressV = XGL_TEX_ADDRESS_WRAP;
501 samplerCreateInfo.addressW = XGL_TEX_ADDRESS_WRAP;
502 samplerCreateInfo.mipLodBias = 0.0;
503 samplerCreateInfo.maxAnisotropy = 0.0;
504 samplerCreateInfo.compareFunc = XGL_COMPARE_NEVER;
505 samplerCreateInfo.minLod = 0.0;
506 samplerCreateInfo.maxLod = 0.0;
507 samplerCreateInfo.borderColorType = XGL_BORDER_COLOR_OPAQUE_WHITE;
Tony Barboure2c58df2014-11-25 13:18:32 -0700508
Chia-I Wue9864b52014-12-28 16:32:24 +0800509 init(*m_device, samplerCreateInfo);
Tony Barbourf325bf12014-12-03 15:59:38 -0700510}
Tony Barboure2c58df2014-11-25 13:18:32 -0700511
Courtney Goeltzenleuchter3b0a8152014-12-04 15:18:47 -0700512/*
513 * Basic ConstantBuffer constructor. Then use create methods to fill in the details.
514 */
515XglConstantBufferObj::XglConstantBufferObj(XglDevice *device)
516{
517 m_device = device;
Tony Barbour38422802014-12-10 14:36:31 -0700518 m_commandBuffer = 0;
Courtney Goeltzenleuchter3b0a8152014-12-04 15:18:47 -0700519
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800520 memset(&m_bufferViewInfo,0,sizeof(m_bufferViewInfo));
Courtney Goeltzenleuchter3b0a8152014-12-04 15:18:47 -0700521}
522
Tony Barboure2c58df2014-11-25 13:18:32 -0700523XglConstantBufferObj::XglConstantBufferObj(XglDevice *device, int constantCount, int constantSize, const void* data)
524{
Tony Barboure2c58df2014-11-25 13:18:32 -0700525 m_device = device;
Chia-I Wua07fee62014-12-28 15:26:08 +0800526 m_commandBuffer = 0;
527
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800528 memset(&m_bufferViewInfo,0,sizeof(m_bufferViewInfo));
Tony Barboure2c58df2014-11-25 13:18:32 -0700529 m_numVertices = constantCount;
530 m_stride = constantSize;
531
Chia-I Wua07fee62014-12-28 15:26:08 +0800532 const size_t allocationSize = constantCount * constantSize;
533 init(*m_device, allocationSize);
Tony Barboure2c58df2014-11-25 13:18:32 -0700534
Chia-I Wua07fee62014-12-28 15:26:08 +0800535 void *pData = map();
536 memcpy(pData, data, allocationSize);
537 unmap();
Tony Barboure2c58df2014-11-25 13:18:32 -0700538
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800539 // set up the buffer view for the constant buffer
540 XGL_BUFFER_VIEW_CREATE_INFO view_info = {};
541 view_info.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
542 view_info.buffer = obj();
Chia-I Wubb0c8d22015-01-16 22:31:25 +0800543 view_info.viewType = XGL_BUFFER_VIEW_RAW;
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800544 view_info.offset = 0;
545 view_info.range = allocationSize;
546 m_bufferView.init(*m_device, view_info);
547
548 this->m_bufferViewInfo.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO;
549 this->m_bufferViewInfo.view = m_bufferView.obj();
Tony Barboure2c58df2014-11-25 13:18:32 -0700550}
Tony Barbour82c39522014-12-04 14:33:33 -0700551
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600552void XglConstantBufferObj::Bind(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_SIZE offset, uint32_t binding)
Courtney Goeltzenleuchter37640302014-12-04 15:26:56 -0700553{
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800554 xglCmdBindVertexBuffer(cmdBuffer, obj(), offset, binding);
Courtney Goeltzenleuchter37640302014-12-04 15:26:56 -0700555}
556
557
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000558void XglConstantBufferObj::BufferMemoryBarrier(
559 XGL_FLAGS outputMask /*=
560 XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
561 XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
562 XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
563 XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
564 XGL_MEMORY_OUTPUT_COPY_BIT*/,
565 XGL_FLAGS inputMask /*=
566 XGL_MEMORY_INPUT_CPU_READ_BIT |
567 XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
568 XGL_MEMORY_INPUT_INDEX_FETCH_BIT |
569 XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
570 XGL_MEMORY_INPUT_UNIFORM_READ_BIT |
571 XGL_MEMORY_INPUT_SHADER_READ_BIT |
572 XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
573 XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
574 XGL_MEMORY_INPUT_COPY_BIT*/)
Tony Barboure2c58df2014-11-25 13:18:32 -0700575{
Tony Barbour38422802014-12-10 14:36:31 -0700576 XGL_RESULT err = XGL_SUCCESS;
Tony Barbour38422802014-12-10 14:36:31 -0700577
Tony Barbour38422802014-12-10 14:36:31 -0700578 if (!m_commandBuffer)
579 {
Chia-I Wua07fee62014-12-28 15:26:08 +0800580 m_fence.init(*m_device, xgl_testing::Fence::create_info(0));
Tony Barbour38422802014-12-10 14:36:31 -0700581
582 m_commandBuffer = new XglCommandBufferObj(m_device);
583
584 }
585 else
586 {
Chia-I Wua07fee62014-12-28 15:26:08 +0800587 m_device->wait(m_fence);
Tony Barbour38422802014-12-10 14:36:31 -0700588 }
589
Tony Barboure2c58df2014-11-25 13:18:32 -0700590 // open the command buffer
Jon Ashburnc4164b12014-12-31 17:10:47 -0700591 XGL_CMD_BUFFER_BEGIN_INFO cmd_buf_info = {
592 .sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO,
593 .pNext = NULL,
594 .flags = 0,
595 };
596 err = m_commandBuffer->BeginCommandBuffer(&cmd_buf_info);
Tony Barboure2c58df2014-11-25 13:18:32 -0700597 ASSERT_XGL_SUCCESS(err);
598
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000599 XGL_BUFFER_MEMORY_BARRIER memory_barrier =
600 buffer_memory_barrier(outputMask, inputMask, 0, m_numVertices * m_stride);
Mark Lobodzinski837ef922015-01-29 14:24:14 -0600601 XGL_BUFFER_MEMORY_BARRIER *pmemory_barrier = &memory_barrier;
Tony Barboure2c58df2014-11-25 13:18:32 -0700602
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000603 XGL_SET_EVENT set_events[] = { XGL_SET_EVENT_GPU_COMMANDS_COMPLETE };
604 XGL_PIPELINE_BARRIER pipeline_barrier = {};
605 pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
606 pipeline_barrier.eventCount = 1;
607 pipeline_barrier.pEvents = set_events;
608 pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
609 pipeline_barrier.memBarrierCount = 1;
Mark Lobodzinskid5d83ed2015-02-02 11:55:52 -0600610 pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
Mike Stroyanfb80d5f2014-12-04 11:08:39 +0000611
612 // write barrier to the command buffer
613 m_commandBuffer->PipelineBarrier(&pipeline_barrier);
Tony Barboure2c58df2014-11-25 13:18:32 -0700614
615 // finish recording the command buffer
Tony Barbour471338d2014-12-10 17:28:39 -0700616 err = m_commandBuffer->EndCommandBuffer();
Tony Barboure2c58df2014-11-25 13:18:32 -0700617 ASSERT_XGL_SUCCESS(err);
618
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600619 uint32_t numMemRefs=1;
Tony Barboure2c58df2014-11-25 13:18:32 -0700620 XGL_MEMORY_REF memRefs;
621 // this command buffer only uses the vertex buffer memory
622 memRefs.flags = 0;
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800623 memRefs.mem = memories()[0];
Tony Barboure2c58df2014-11-25 13:18:32 -0700624
625 // submit the command buffer to the universal queue
Tony Barbour471338d2014-12-10 17:28:39 -0700626 XGL_CMD_BUFFER bufferArray[1];
627 bufferArray[0] = m_commandBuffer->GetBufferHandle();
Chia-I Wua07fee62014-12-28 15:26:08 +0800628 err = xglQueueSubmit( m_device->m_queue, 1, bufferArray, numMemRefs, &memRefs, m_fence.obj() );
Tony Barboure2c58df2014-11-25 13:18:32 -0700629 ASSERT_XGL_SUCCESS(err);
630}
631
Courtney Goeltzenleuchter8a785932014-12-04 15:24:05 -0700632XglIndexBufferObj::XglIndexBufferObj(XglDevice *device)
633 : XglConstantBufferObj(device)
634{
635
636}
637
638void XglIndexBufferObj::CreateAndInitBuffer(int numIndexes, XGL_INDEX_TYPE indexType, const void* data)
639{
Courtney Goeltzenleuchter8a785932014-12-04 15:24:05 -0700640 XGL_FORMAT viewFormat;
641
642 m_numVertices = numIndexes;
643 m_indexType = indexType;
Courtney Goeltzenleuchter8a785932014-12-04 15:24:05 -0700644 switch (indexType) {
645 case XGL_INDEX_8:
646 m_stride = 1;
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700647 viewFormat = XGL_FMT_R8_UINT;
Courtney Goeltzenleuchter8a785932014-12-04 15:24:05 -0700648 break;
649 case XGL_INDEX_16:
650 m_stride = 2;
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700651 viewFormat = XGL_FMT_R16_UINT;
Courtney Goeltzenleuchter8a785932014-12-04 15:24:05 -0700652 break;
653 case XGL_INDEX_32:
654 m_stride = 4;
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700655 viewFormat = XGL_FMT_R32_UINT;
Courtney Goeltzenleuchter8a785932014-12-04 15:24:05 -0700656 break;
Chia-I Wub4c2aa42014-12-15 23:50:11 +0800657 default:
658 assert(!"unknown index type");
659 break;
Courtney Goeltzenleuchter8a785932014-12-04 15:24:05 -0700660 }
661
Chia-I Wua07fee62014-12-28 15:26:08 +0800662 const size_t allocationSize = numIndexes * m_stride;
663 init(*m_device, allocationSize);
Courtney Goeltzenleuchter8a785932014-12-04 15:24:05 -0700664
Chia-I Wua07fee62014-12-28 15:26:08 +0800665 void *pData = map();
666 memcpy(pData, data, allocationSize);
667 unmap();
Courtney Goeltzenleuchter8a785932014-12-04 15:24:05 -0700668
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800669 // set up the buffer view for the constant buffer
670 XGL_BUFFER_VIEW_CREATE_INFO view_info = {};
671 view_info.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
672 view_info.buffer = obj();
673 view_info.viewType = XGL_BUFFER_VIEW_TYPED;
674 view_info.stride = m_stride;
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700675 view_info.format = viewFormat;
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800676 view_info.channels.r = XGL_CHANNEL_SWIZZLE_R;
677 view_info.channels.g = XGL_CHANNEL_SWIZZLE_G;
678 view_info.channels.b = XGL_CHANNEL_SWIZZLE_B;
679 view_info.channels.a = XGL_CHANNEL_SWIZZLE_A;
680 view_info.offset = 0;
681 view_info.range = allocationSize;
682 m_bufferView.init(*m_device, view_info);
683
684 this->m_bufferViewInfo.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO;
685 this->m_bufferViewInfo.view = m_bufferView.obj();
Courtney Goeltzenleuchter8a785932014-12-04 15:24:05 -0700686}
687
688void XglIndexBufferObj::Bind(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_SIZE offset)
689{
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800690 xglCmdBindIndexBuffer(cmdBuffer, obj(), offset, m_indexType);
Courtney Goeltzenleuchter8a785932014-12-04 15:24:05 -0700691}
Tony Barboure2c58df2014-11-25 13:18:32 -0700692
Tony Barbouraf1f9192014-12-17 10:57:58 -0700693XGL_INDEX_TYPE XglIndexBufferObj::GetIndexType()
694{
695 return m_indexType;
696}
697
Chia-I Wu11078b02015-01-04 16:27:24 +0800698XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* XglShaderObj::GetStageCreateInfo()
Tony Barboure2c58df2014-11-25 13:18:32 -0700699{
Tony Barboure2c58df2014-11-25 13:18:32 -0700700 XGL_PIPELINE_SHADER_STAGE_CREATE_INFO *stageInfo = (XGL_PIPELINE_SHADER_STAGE_CREATE_INFO*) calloc( 1,sizeof(XGL_PIPELINE_SHADER_STAGE_CREATE_INFO) );
701 stageInfo->sType = XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
702 stageInfo->shader.stage = m_stage;
Chia-I Wubabc0fd2014-12-29 14:14:03 +0800703 stageInfo->shader.shader = obj();
Tony Barboure2c58df2014-11-25 13:18:32 -0700704 stageInfo->shader.linkConstBufferCount = 0;
705 stageInfo->shader.pLinkConstBufferInfo = XGL_NULL_HANDLE;
Tony Barboure2c58df2014-11-25 13:18:32 -0700706
Tony Barboure2c58df2014-11-25 13:18:32 -0700707 return stageInfo;
708}
709
Tony Barboure2c58df2014-11-25 13:18:32 -0700710XglShaderObj::XglShaderObj(XglDevice *device, const char * shader_code, XGL_PIPELINE_SHADER_STAGE stage, XglRenderFramework *framework)
711{
712 XGL_RESULT err = XGL_SUCCESS;
713 std::vector<unsigned int> bil;
714 XGL_SHADER_CREATE_INFO createInfo;
715 size_t shader_len;
716
717 m_stage = stage;
718 m_device = device;
719
720 createInfo.sType = XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO;
721 createInfo.pNext = NULL;
722
723 if (!framework->m_use_bil) {
724
725 shader_len = strlen(shader_code);
726 createInfo.codeSize = 3 * sizeof(uint32_t) + shader_len + 1;
727 createInfo.pCode = malloc(createInfo.codeSize);
728 createInfo.flags = 0;
729
730 /* try version 0 first: XGL_PIPELINE_SHADER_STAGE followed by GLSL */
731 ((uint32_t *) createInfo.pCode)[0] = ICD_BIL_MAGIC;
732 ((uint32_t *) createInfo.pCode)[1] = 0;
733 ((uint32_t *) createInfo.pCode)[2] = stage;
734 memcpy(((uint32_t *) createInfo.pCode + 3), shader_code, shader_len + 1);
735
Chia-I Wubabc0fd2014-12-29 14:14:03 +0800736 err = init_try(*m_device, createInfo);
Tony Barboure2c58df2014-11-25 13:18:32 -0700737 }
738
739 if (framework->m_use_bil || err) {
740 std::vector<unsigned int> bil;
741 err = XGL_SUCCESS;
742
743 // Use Reference GLSL to BIL compiler
744 framework->GLSLtoBIL(stage, shader_code, bil);
745 createInfo.pCode = bil.data();
746 createInfo.codeSize = bil.size() * sizeof(unsigned int);
747 createInfo.flags = 0;
Tony Barbour82c39522014-12-04 14:33:33 -0700748
Chia-I Wubabc0fd2014-12-29 14:14:03 +0800749 init(*m_device, createInfo);
750 }
Tony Barbourf325bf12014-12-03 15:59:38 -0700751}
Tony Barbour82c39522014-12-04 14:33:33 -0700752
Tony Barboure2c58df2014-11-25 13:18:32 -0700753XglPipelineObj::XglPipelineObj(XglDevice *device)
754{
Tony Barboure2c58df2014-11-25 13:18:32 -0700755 m_device = device;
756 m_vi_state.attributeCount = m_vi_state.bindingCount = 0;
757 m_vertexBufferCount = 0;
758
759 m_ia_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO;
760 m_ia_state.pNext = XGL_NULL_HANDLE;
761 m_ia_state.topology = XGL_TOPOLOGY_TRIANGLE_LIST;
762 m_ia_state.disableVertexReuse = XGL_FALSE;
Tony Barboure2c58df2014-11-25 13:18:32 -0700763 m_ia_state.primitiveRestartEnable = XGL_FALSE;
764 m_ia_state.primitiveRestartIndex = 0;
765
766 m_rs_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO;
767 m_rs_state.pNext = &m_ia_state;
768 m_rs_state.depthClipEnable = XGL_FALSE;
769 m_rs_state.rasterizerDiscardEnable = XGL_FALSE;
Tony Barbourf52346d2015-01-16 14:27:35 -0700770 m_rs_state.provokingVertex = XGL_PROVOKING_VERTEX_LAST;
771 m_rs_state.fillMode = XGL_FILL_SOLID;
772 m_rs_state.cullMode = XGL_CULL_NONE;
773 m_rs_state.frontFace = XGL_FRONT_FACE_CCW;
Tony Barboure2c58df2014-11-25 13:18:32 -0700774
Tony Barboure2c58df2014-11-25 13:18:32 -0700775 memset(&m_cb_state,0,sizeof(m_cb_state));
776 m_cb_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO;
777 m_cb_state.pNext = &m_rs_state;
778 m_cb_state.alphaToCoverageEnable = XGL_FALSE;
779 m_cb_state.dualSourceBlendEnable = XGL_FALSE;
780 m_cb_state.logicOp = XGL_LOGIC_OP_COPY;
781
Tony Barbourf52346d2015-01-16 14:27:35 -0700782 m_ms_state.pNext = &m_cb_state;
783 m_ms_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_MS_STATE_CREATE_INFO;
784 m_ms_state.multisampleEnable = XGL_FALSE;
785 m_ms_state.sampleMask = 1; // Do we have to specify MSAA even just to disable it?
786 m_ms_state.samples = 1;
787 m_ms_state.minSampleShading = 0;
788 m_ms_state.sampleShadingEnable = 0;
Tony Barboure2c58df2014-11-25 13:18:32 -0700789
Tony Barbourf52346d2015-01-16 14:27:35 -0700790 m_ds_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_DS_STATE_CREATE_INFO;
791 m_ds_state.pNext = &m_ms_state,
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700792 m_ds_state.format = XGL_FMT_D32_SFLOAT;
Tony Barbourf52346d2015-01-16 14:27:35 -0700793 m_ds_state.depthTestEnable = XGL_FALSE;
794 m_ds_state.depthWriteEnable = XGL_FALSE;
795 m_ds_state.depthBoundsEnable = XGL_FALSE;
796 m_ds_state.depthFunc = XGL_COMPARE_LESS_EQUAL;
797 m_ds_state.back.stencilDepthFailOp = XGL_STENCIL_OP_KEEP;
798 m_ds_state.back.stencilFailOp = XGL_STENCIL_OP_KEEP;
799 m_ds_state.back.stencilPassOp = XGL_STENCIL_OP_KEEP;
800 m_ds_state.back.stencilFunc = XGL_COMPARE_ALWAYS;
801 m_ds_state.stencilTestEnable = XGL_FALSE;
802 m_ds_state.front = m_ds_state.back;
Tony Barboure2c58df2014-11-25 13:18:32 -0700803
Tony Barbourf52346d2015-01-16 14:27:35 -0700804 XGL_PIPELINE_CB_ATTACHMENT_STATE att = {};
805 att.blendEnable = XGL_FALSE;
Jeremy Hayesa058eee2015-01-23 08:51:43 -0700806 att.format = XGL_FMT_R8G8B8A8_UNORM;
Tony Barbourf52346d2015-01-16 14:27:35 -0700807 att.channelWriteMask = 0xf;
808 AddColorAttachment(0, &att);
Tony Barboure2c58df2014-11-25 13:18:32 -0700809
810};
811
812void XglPipelineObj::AddShader(XglShaderObj* shader)
813{
814 m_shaderObjs.push_back(shader);
815}
816
817void XglPipelineObj::AddVertexInputAttribs(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* vi_attrib, int count)
818{
819 m_vi_state.pVertexAttributeDescriptions = vi_attrib;
820 m_vi_state.attributeCount = count;
821}
822
823void XglPipelineObj::AddVertexInputBindings(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* vi_binding, int count)
824{
825 m_vi_state.pVertexBindingDescriptions = vi_binding;
826 m_vi_state.bindingCount = count;
827}
828
829void XglPipelineObj::AddVertexDataBuffer(XglConstantBufferObj* vertexDataBuffer, int binding)
830{
831 m_vertexBufferObjs.push_back(vertexDataBuffer);
832 m_vertexBufferBindings.push_back(binding);
833 m_vertexBufferCount++;
834}
835
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600836void XglPipelineObj::AddColorAttachment(uint32_t binding, const XGL_PIPELINE_CB_ATTACHMENT_STATE *att)
Chia-I Wuecebf752014-12-05 10:45:15 +0800837{
Tony Barbourf52346d2015-01-16 14:27:35 -0700838 if (binding+1 > m_colorAttachments.size())
839 {
840 m_colorAttachments.resize(binding+1);
841 }
842 m_colorAttachments[binding] = *att;
843}
844
845void XglPipelineObj::SetDepthStencil(XGL_PIPELINE_DS_STATE_CREATE_INFO *ds_state)
846{
847 m_ds_state.format = ds_state->format;
848 m_ds_state.depthTestEnable = ds_state->depthTestEnable;
849 m_ds_state.depthWriteEnable = ds_state->depthWriteEnable;
850 m_ds_state.depthBoundsEnable = ds_state->depthBoundsEnable;
851 m_ds_state.depthFunc = ds_state->depthFunc;
852 m_ds_state.stencilTestEnable = ds_state->stencilTestEnable;
853 m_ds_state.back = ds_state->back;
854 m_ds_state.front = ds_state->front;
Chia-I Wuecebf752014-12-05 10:45:15 +0800855}
856
Tony Barbour976e1cf2014-12-17 11:57:31 -0700857void XglPipelineObj::CreateXGLPipeline(XglDescriptorSetObj *descriptorSet)
858{
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600859 void* head_ptr = &m_ds_state;
Tony Barbour976e1cf2014-12-17 11:57:31 -0700860 XGL_GRAPHICS_PIPELINE_CREATE_INFO info = {};
861
862 XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* shaderCreateInfo;
863
864 for (int i=0; i<m_shaderObjs.size(); i++)
865 {
Chia-I Wu11078b02015-01-04 16:27:24 +0800866 shaderCreateInfo = m_shaderObjs[i]->GetStageCreateInfo();
Tony Barbour976e1cf2014-12-17 11:57:31 -0700867 shaderCreateInfo->pNext = head_ptr;
868 head_ptr = shaderCreateInfo;
869 }
870
871 if (m_vi_state.attributeCount && m_vi_state.bindingCount)
872 {
873 m_vi_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO;
874 m_vi_state.pNext = head_ptr;
875 head_ptr = &m_vi_state;
876 }
877
878 info.sType = XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
879 info.pNext = head_ptr;
880 info.flags = 0;
Chia-I Wu11078b02015-01-04 16:27:24 +0800881 info.lastSetLayout = descriptorSet->GetLayout();
Tony Barbour976e1cf2014-12-17 11:57:31 -0700882
Tony Barbourf52346d2015-01-16 14:27:35 -0700883 m_cb_state.attachmentCount = m_colorAttachments.size();
884 m_cb_state.pAttachments = &m_colorAttachments[0];
885
Chia-I Wu2648d092014-12-29 14:24:14 +0800886 init(*m_device, info);
Tony Barbour976e1cf2014-12-17 11:57:31 -0700887}
Chia-I Wu2648d092014-12-29 14:24:14 +0800888
Tony Barbour976e1cf2014-12-17 11:57:31 -0700889XGL_PIPELINE XglPipelineObj::GetPipelineHandle()
890{
Chia-I Wu2648d092014-12-29 14:24:14 +0800891 return obj();
Tony Barbour976e1cf2014-12-17 11:57:31 -0700892}
893
Tony Barbour5420af02014-12-03 13:58:15 -0700894void XglPipelineObj::BindPipelineCommandBuffer(XGL_CMD_BUFFER m_cmdBuffer, XglDescriptorSetObj *descriptorSet)
Tony Barboure2c58df2014-11-25 13:18:32 -0700895{
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600896 void* head_ptr = &m_ds_state;
Tony Barboure2c58df2014-11-25 13:18:32 -0700897 XGL_GRAPHICS_PIPELINE_CREATE_INFO info = {};
898
899 XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* shaderCreateInfo;
Tony Barboure2c58df2014-11-25 13:18:32 -0700900
901 for (int i=0; i<m_shaderObjs.size(); i++)
902 {
Chia-I Wu11078b02015-01-04 16:27:24 +0800903 shaderCreateInfo = m_shaderObjs[i]->GetStageCreateInfo();
Tony Barboure2c58df2014-11-25 13:18:32 -0700904 shaderCreateInfo->pNext = head_ptr;
905 head_ptr = shaderCreateInfo;
906 }
907
908 if (m_vi_state.attributeCount && m_vi_state.bindingCount)
909 {
910 m_vi_state.sType = XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO;
911 m_vi_state.pNext = head_ptr;
912 head_ptr = &m_vi_state;
913 }
914
915 info.sType = XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
916 info.pNext = head_ptr;
917 info.flags = 0;
Chia-I Wu11078b02015-01-04 16:27:24 +0800918 info.lastSetLayout = descriptorSet->GetLayout();
Tony Barboure2c58df2014-11-25 13:18:32 -0700919
Chia-I Wu2648d092014-12-29 14:24:14 +0800920 init(*m_device, info);
Tony Barboure2c58df2014-11-25 13:18:32 -0700921
Chia-I Wu2648d092014-12-29 14:24:14 +0800922 xglCmdBindPipeline( m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, obj() );
Tony Barboure2c58df2014-11-25 13:18:32 -0700923
924
925 for (int i=0; i < m_vertexBufferCount; i++)
926 {
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800927 m_vertexBufferObjs[i]->Bind(m_cmdBuffer, 0, m_vertexBufferBindings[i]);
Tony Barboure2c58df2014-11-25 13:18:32 -0700928 }
Tony Barboure2c58df2014-11-25 13:18:32 -0700929}
Tony Barbour82c39522014-12-04 14:33:33 -0700930
Tony Barboure2c58df2014-11-25 13:18:32 -0700931XglMemoryRefManager::XglMemoryRefManager() {
932
933}
Tony Barbour82c39522014-12-04 14:33:33 -0700934
Tony Barboure2c58df2014-11-25 13:18:32 -0700935void XglMemoryRefManager::AddMemoryRef(XglConstantBufferObj *constantBuffer) {
Chia-I Wu1a28fe02015-01-01 07:55:04 +0800936 const std::vector<XGL_GPU_MEMORY> mems = constantBuffer->memories();
937 if (!mems.empty())
938 m_bufferObjs.push_back(mems[0]);
Tony Barboure2c58df2014-11-25 13:18:32 -0700939}
Tony Barbour82c39522014-12-04 14:33:33 -0700940
Tony Barboure2c58df2014-11-25 13:18:32 -0700941void XglMemoryRefManager::AddMemoryRef(XglTextureObj *texture) {
Chia-I Wu13a3aa82014-12-28 15:55:09 +0800942 const std::vector<XGL_GPU_MEMORY> mems = texture->memories();
943 if (!mems.empty())
944 m_bufferObjs.push_back(mems[0]);
Tony Barboure2c58df2014-11-25 13:18:32 -0700945}
Tony Barbour82c39522014-12-04 14:33:33 -0700946
Tony Barboure2c58df2014-11-25 13:18:32 -0700947XGL_MEMORY_REF* XglMemoryRefManager::GetMemoryRefList() {
948
949 XGL_MEMORY_REF *localRefs;
Mark Lobodzinski17caf572015-01-29 08:55:56 -0600950 uint32_t numRefs=m_bufferObjs.size();
Tony Barboure2c58df2014-11-25 13:18:32 -0700951
952 if (numRefs <= 0)
953 return NULL;
954
955 localRefs = (XGL_MEMORY_REF*) malloc( numRefs * sizeof(XGL_MEMORY_REF) );
956 for (int i=0; i<numRefs; i++)
957 {
958 localRefs[i].flags = 0;
Chia-I Wu283d7a62014-12-28 15:43:42 +0800959 localRefs[i].mem = m_bufferObjs[i];
Tony Barboure2c58df2014-11-25 13:18:32 -0700960 }
961 return localRefs;
962}
963int XglMemoryRefManager::GetNumRefs() {
964 return m_bufferObjs.size();
965}
Tony Barbour6d047bf2014-12-10 14:34:45 -0700966
967XglCommandBufferObj::XglCommandBufferObj(XglDevice *device)
Chia-I Wud28343c2014-12-28 15:12:48 +0800968 : xgl_testing::CmdBuffer(*device, xgl_testing::CmdBuffer::create_info(XGL_QUEUE_TYPE_GRAPHICS))
Tony Barbour6d047bf2014-12-10 14:34:45 -0700969{
Tony Barbour6d047bf2014-12-10 14:34:45 -0700970 m_device = device;
Chia-I Wud28343c2014-12-28 15:12:48 +0800971 m_renderTargetCount = 0;
Tony Barbour6d047bf2014-12-10 14:34:45 -0700972}
Tony Barbour471338d2014-12-10 17:28:39 -0700973
Tony Barbour6d047bf2014-12-10 14:34:45 -0700974XGL_CMD_BUFFER XglCommandBufferObj::GetBufferHandle()
975{
Chia-I Wud28343c2014-12-28 15:12:48 +0800976 return obj();
Tony Barbour6d047bf2014-12-10 14:34:45 -0700977}
Tony Barbour471338d2014-12-10 17:28:39 -0700978
Jon Ashburnc4164b12014-12-31 17:10:47 -0700979XGL_RESULT XglCommandBufferObj::BeginCommandBuffer(XGL_CMD_BUFFER_BEGIN_INFO *pInfo)
Tony Barbour471338d2014-12-10 17:28:39 -0700980{
Jeremy Hayesd65ae082015-01-14 16:17:08 -0700981 begin(pInfo);
982 return XGL_SUCCESS;
983}
984
985XGL_RESULT XglCommandBufferObj::BeginCommandBuffer(XGL_RENDER_PASS renderpass_obj)
986{
987 begin(renderpass_obj);
988 return XGL_SUCCESS;
989}
990
991XGL_RESULT XglCommandBufferObj::BeginCommandBuffer()
992{
993 begin();
Chia-I Wud28343c2014-12-28 15:12:48 +0800994 return XGL_SUCCESS;
Tony Barbour471338d2014-12-10 17:28:39 -0700995}
996
997XGL_RESULT XglCommandBufferObj::EndCommandBuffer()
998{
Chia-I Wud28343c2014-12-28 15:12:48 +0800999 end();
1000 return XGL_SUCCESS;
Tony Barbour471338d2014-12-10 17:28:39 -07001001}
1002
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001003void XglCommandBufferObj::PipelineBarrier(XGL_PIPELINE_BARRIER *barrierPtr)
Tony Barbour471338d2014-12-10 17:28:39 -07001004{
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001005 xglCmdPipelineBarrier(obj(), barrierPtr);
Tony Barbour471338d2014-12-10 17:28:39 -07001006}
1007
Tony Barbour30cc9e82014-12-17 11:53:55 -07001008void XglCommandBufferObj::ClearAllBuffers(XGL_DEPTH_STENCIL_BIND_INFO *depthStencilBinding, XGL_IMAGE depthStencilImage)
1009{
Mark Lobodzinski17caf572015-01-29 08:55:56 -06001010 uint32_t i;
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001011 const XGL_FLAGS output_mask =
1012 XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
1013 XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
1014 XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
1015 XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
1016 XGL_MEMORY_OUTPUT_COPY_BIT;
1017 const XGL_FLAGS input_mask = 0;
Tony Barbour30cc9e82014-12-17 11:53:55 -07001018
1019 // whatever we want to do, we do it to the whole buffer
1020 XGL_IMAGE_SUBRESOURCE_RANGE srRange = {};
1021 srRange.aspect = XGL_IMAGE_ASPECT_COLOR;
1022 srRange.baseMipLevel = 0;
1023 srRange.mipLevels = XGL_LAST_MIP_OR_SLICE;
1024 srRange.baseArraySlice = 0;
1025 srRange.arraySize = XGL_LAST_MIP_OR_SLICE;
1026
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001027 XGL_IMAGE_MEMORY_BARRIER memory_barrier = {};
1028 memory_barrier.sType = XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
1029 memory_barrier.outputMask = output_mask;
1030 memory_barrier.inputMask = input_mask;
1031 memory_barrier.newLayout = XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL;
1032 memory_barrier.subresourceRange = srRange;
Mark Lobodzinski837ef922015-01-29 14:24:14 -06001033 XGL_IMAGE_MEMORY_BARRIER *pmemory_barrier = &memory_barrier;
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001034
1035 XGL_SET_EVENT set_events[] = { XGL_SET_EVENT_GPU_COMMANDS_COMPLETE };
1036 XGL_PIPELINE_BARRIER pipeline_barrier = {};
1037 pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
1038 pipeline_barrier.eventCount = 1;
1039 pipeline_barrier.pEvents = set_events;
1040 pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
1041 pipeline_barrier.memBarrierCount = 1;
Mark Lobodzinskid5d83ed2015-02-02 11:55:52 -06001042 pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001043
Tony Barbour30cc9e82014-12-17 11:53:55 -07001044 // clear the back buffer to dark grey
Mark Lobodzinski17caf572015-01-29 08:55:56 -06001045 uint32_t clearColor[4] = {64, 64, 64, 0};
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001046
Tony Barbour30cc9e82014-12-17 11:53:55 -07001047 for (i = 0; i < m_renderTargetCount; i++) {
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001048 memory_barrier.image = m_renderTargets[i]->image();
1049 memory_barrier.oldLayout = m_renderTargets[i]->layout();
1050 xglCmdPipelineBarrier( obj(), &pipeline_barrier);
1051 m_renderTargets[i]->layout(memory_barrier.newLayout);
Tony Barbour30cc9e82014-12-17 11:53:55 -07001052
Chia-I Wud28343c2014-12-28 15:12:48 +08001053 xglCmdClearColorImageRaw( obj(), m_renderTargets[i]->image(), clearColor, 1, &srRange );
Tony Barbour30cc9e82014-12-17 11:53:55 -07001054 }
1055
1056 if (depthStencilImage)
1057 {
1058 XGL_IMAGE_SUBRESOURCE_RANGE dsRange = {};
1059 dsRange.aspect = XGL_IMAGE_ASPECT_DEPTH;
1060 dsRange.baseMipLevel = 0;
1061 dsRange.mipLevels = XGL_LAST_MIP_OR_SLICE;
1062 dsRange.baseArraySlice = 0;
1063 dsRange.arraySize = XGL_LAST_MIP_OR_SLICE;
1064
1065 // prepare the depth buffer for clear
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001066
1067 memory_barrier.oldLayout = depthStencilBinding->layout;
1068 memory_barrier.newLayout = XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL;
1069 memory_barrier.image = depthStencilImage;
1070 memory_barrier.subresourceRange = dsRange;
1071
1072 xglCmdPipelineBarrier( obj(), &pipeline_barrier);
1073 depthStencilBinding->layout = memory_barrier.newLayout;
Tony Barbour30cc9e82014-12-17 11:53:55 -07001074
Chia-I Wud28343c2014-12-28 15:12:48 +08001075 xglCmdClearDepthStencil(obj(), depthStencilImage, 1.0f, 0, 1, &dsRange);
Tony Barbour30cc9e82014-12-17 11:53:55 -07001076
1077 // prepare depth buffer for rendering
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001078 memory_barrier.image = depthStencilImage;
1079 memory_barrier.oldLayout = XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL;
1080 memory_barrier.newLayout = depthStencilBinding->layout;
1081 memory_barrier.subresourceRange = dsRange;
1082 xglCmdPipelineBarrier( obj(), &pipeline_barrier);
1083 depthStencilBinding->layout = memory_barrier.newLayout;
Tony Barbour30cc9e82014-12-17 11:53:55 -07001084 }
1085}
1086
Jon Ashburncdc40be2015-01-02 18:27:14 -07001087void XglCommandBufferObj::PrepareAttachments()
Tony Barbour30cc9e82014-12-17 11:53:55 -07001088{
Mark Lobodzinski17caf572015-01-29 08:55:56 -06001089 uint32_t i;
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001090 const XGL_FLAGS output_mask =
1091 XGL_MEMORY_OUTPUT_CPU_WRITE_BIT |
1092 XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT |
1093 XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT |
1094 XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
1095 XGL_MEMORY_OUTPUT_COPY_BIT;
1096 const XGL_FLAGS input_mask =
1097 XGL_MEMORY_INPUT_CPU_READ_BIT |
1098 XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT |
1099 XGL_MEMORY_INPUT_INDEX_FETCH_BIT |
1100 XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT |
1101 XGL_MEMORY_INPUT_UNIFORM_READ_BIT |
1102 XGL_MEMORY_INPUT_SHADER_READ_BIT |
1103 XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT |
1104 XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT |
1105 XGL_MEMORY_INPUT_COPY_BIT;
1106
Tony Barbour30cc9e82014-12-17 11:53:55 -07001107 XGL_IMAGE_SUBRESOURCE_RANGE srRange = {};
1108 srRange.aspect = XGL_IMAGE_ASPECT_COLOR;
1109 srRange.baseMipLevel = 0;
1110 srRange.mipLevels = XGL_LAST_MIP_OR_SLICE;
1111 srRange.baseArraySlice = 0;
1112 srRange.arraySize = XGL_LAST_MIP_OR_SLICE;
1113
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001114 XGL_IMAGE_MEMORY_BARRIER memory_barrier = {};
1115 memory_barrier.sType = XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
1116 memory_barrier.outputMask = output_mask;
1117 memory_barrier.inputMask = input_mask;
1118 memory_barrier.newLayout = XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
1119 memory_barrier.subresourceRange = srRange;
Mark Lobodzinski837ef922015-01-29 14:24:14 -06001120 XGL_IMAGE_MEMORY_BARRIER *pmemory_barrier = &memory_barrier;
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001121
1122 XGL_SET_EVENT set_events[] = { XGL_SET_EVENT_GPU_COMMANDS_COMPLETE };
1123 XGL_PIPELINE_BARRIER pipeline_barrier = {};
1124 pipeline_barrier.sType = XGL_STRUCTURE_TYPE_PIPELINE_BARRIER;
1125 pipeline_barrier.eventCount = 1;
1126 pipeline_barrier.pEvents = set_events;
1127 pipeline_barrier.waitEvent = XGL_WAIT_EVENT_TOP_OF_PIPE;
1128 pipeline_barrier.memBarrierCount = 1;
Mark Lobodzinskid5d83ed2015-02-02 11:55:52 -06001129 pipeline_barrier.ppMemBarriers = (const void **)&pmemory_barrier;
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001130
Tony Barbour30cc9e82014-12-17 11:53:55 -07001131 for(i=0; i<m_renderTargetCount; i++)
1132 {
Mike Stroyanfb80d5f2014-12-04 11:08:39 +00001133 memory_barrier.image = m_renderTargets[i]->image();
1134 memory_barrier.oldLayout = m_renderTargets[i]->layout();
1135 xglCmdPipelineBarrier( obj(), &pipeline_barrier);
1136 m_renderTargets[i]->layout(memory_barrier.newLayout);
Tony Barbour30cc9e82014-12-17 11:53:55 -07001137 }
Tony Barbour30cc9e82014-12-17 11:53:55 -07001138}
1139
Tony Barbourf52346d2015-01-16 14:27:35 -07001140void XglCommandBufferObj::BindStateObject(XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT stateObject)
Tony Barbour30cc9e82014-12-17 11:53:55 -07001141{
Tony Barbourf52346d2015-01-16 14:27:35 -07001142 xglCmdBindDynamicStateObject( obj(), stateBindPoint, stateObject);
Tony Barbour30cc9e82014-12-17 11:53:55 -07001143}
1144
1145void XglCommandBufferObj::AddRenderTarget(XglImage *renderTarget)
1146{
1147 m_renderTargets.push_back(renderTarget);
1148 m_renderTargetCount++;
1149}
1150
Mark Lobodzinski17caf572015-01-29 08:55:56 -06001151void XglCommandBufferObj::DrawIndexed(uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
Tony Barbour30cc9e82014-12-17 11:53:55 -07001152{
Chia-I Wud28343c2014-12-28 15:12:48 +08001153 xglCmdDrawIndexed(obj(), firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
Tony Barbour30cc9e82014-12-17 11:53:55 -07001154}
1155
Mark Lobodzinski17caf572015-01-29 08:55:56 -06001156void XglCommandBufferObj::Draw(uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
Tony Barbour30cc9e82014-12-17 11:53:55 -07001157{
Chia-I Wud28343c2014-12-28 15:12:48 +08001158 xglCmdDraw(obj(), firstVertex, vertexCount, firstInstance, instanceCount);
Tony Barbour30cc9e82014-12-17 11:53:55 -07001159}
1160
Mark Lobodzinski17caf572015-01-29 08:55:56 -06001161void XglCommandBufferObj::QueueCommandBuffer(XGL_MEMORY_REF *memRefs, uint32_t numMemRefs)
Tony Barbour30cc9e82014-12-17 11:53:55 -07001162{
1163 XGL_RESULT err = XGL_SUCCESS;
1164
1165 // submit the command buffer to the universal queue
Chia-I Wud28343c2014-12-28 15:12:48 +08001166 err = xglQueueSubmit( m_device->m_queue, 1, &obj(), numMemRefs, memRefs, NULL );
Tony Barbour30cc9e82014-12-17 11:53:55 -07001167 ASSERT_XGL_SUCCESS( err );
1168
1169 err = xglQueueWaitIdle( m_device->m_queue );
1170 ASSERT_XGL_SUCCESS( err );
1171
1172 // Wait for work to finish before cleaning up.
1173 xglDeviceWaitIdle(m_device->device());
1174
1175}
1176void XglCommandBufferObj::BindPipeline(XGL_PIPELINE pipeline)
1177{
Chia-I Wud28343c2014-12-28 15:12:48 +08001178 xglCmdBindPipeline( obj(), XGL_PIPELINE_BIND_POINT_GRAPHICS, pipeline );
Tony Barbour30cc9e82014-12-17 11:53:55 -07001179}
1180
1181void XglCommandBufferObj::BindDescriptorSet(XGL_DESCRIPTOR_SET descriptorSet)
1182{
Chia-I Wu1a28fe02015-01-01 07:55:04 +08001183 // bind pipeline, vertex buffer (descriptor set) and WVP (dynamic buffer view)
Chia-I Wu11078b02015-01-04 16:27:24 +08001184 xglCmdBindDescriptorSet(obj(), XGL_PIPELINE_BIND_POINT_GRAPHICS, descriptorSet, NULL );
Tony Barbour30cc9e82014-12-17 11:53:55 -07001185}
Mark Lobodzinski17caf572015-01-29 08:55:56 -06001186void XglCommandBufferObj::BindIndexBuffer(XglIndexBufferObj *indexBuffer, uint32_t offset)
Tony Barbour30cc9e82014-12-17 11:53:55 -07001187{
Chia-I Wu1a28fe02015-01-01 07:55:04 +08001188 xglCmdBindIndexBuffer(obj(), indexBuffer->obj(), offset, indexBuffer->GetIndexType());
Tony Barbour30cc9e82014-12-17 11:53:55 -07001189}
Mark Lobodzinski17caf572015-01-29 08:55:56 -06001190void XglCommandBufferObj::BindVertexBuffer(XglConstantBufferObj *vertexBuffer, uint32_t offset, uint32_t binding)
Tony Barbour30cc9e82014-12-17 11:53:55 -07001191{
Chia-I Wu1a28fe02015-01-01 07:55:04 +08001192 xglCmdBindVertexBuffer(obj(), vertexBuffer->obj(), offset, binding);
Tony Barbour30cc9e82014-12-17 11:53:55 -07001193}