Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 1 | /* |
| 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" |
| 29 | #include "xglIntelExt.h" |
| 30 | |
Courtney Goeltzenleuchter | 53d8d89 | 2014-10-08 12:20:26 -0600 | [diff] [blame] | 31 | XglRenderFramework::XglRenderFramework() : |
| 32 | m_colorBlend( XGL_NULL_HANDLE ), |
| 33 | m_stateMsaa( XGL_NULL_HANDLE ), |
| 34 | m_stateDepthStencil( XGL_NULL_HANDLE ), |
| 35 | m_stateRaster( XGL_NULL_HANDLE ), |
| 36 | m_cmdBuffer( XGL_NULL_HANDLE ), |
Courtney Goeltzenleuchter | 02d33c1 | 2014-10-08 14:26:40 -0600 | [diff] [blame] | 37 | m_stateViewport( XGL_NULL_HANDLE ), |
| 38 | m_width( 256.0 ), // default window width |
| 39 | m_height( 256.0 ) // default window height |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 40 | { |
| 41 | m_render_target_fmt.channelFormat = XGL_CH_FMT_R8G8B8A8; |
| 42 | m_render_target_fmt.numericFormat = XGL_NUM_FMT_UNORM; |
| 43 | } |
| 44 | |
| 45 | XglRenderFramework::~XglRenderFramework() |
| 46 | { |
Courtney Goeltzenleuchter | 53d8d89 | 2014-10-08 12:20:26 -0600 | [diff] [blame] | 47 | |
| 48 | } |
| 49 | |
| 50 | void XglRenderFramework::InitFramework() |
| 51 | { |
| 52 | XGL_RESULT err; |
| 53 | |
| 54 | memset(&m_vtxBufferView, 0, sizeof(m_vtxBufferView)); |
| 55 | m_vtxBufferView.sType = XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO; |
| 56 | |
| 57 | memset(&m_constantBufferView, 0, sizeof(m_constantBufferView)); |
| 58 | m_constantBufferView.sType = XGL_STRUCTURE_TYPE_MEMORY_VIEW_ATTACH_INFO; |
| 59 | |
| 60 | err = xglInitAndEnumerateGpus(&app_info, NULL, |
| 61 | MAX_GPUS, &this->gpu_count, objs); |
| 62 | ASSERT_XGL_SUCCESS(err); |
| 63 | ASSERT_GE(1, this->gpu_count) << "No GPU available"; |
| 64 | |
| 65 | m_device = new XglDevice(0, objs[0]); |
| 66 | m_device->get_device_queue(); |
| 67 | } |
| 68 | |
| 69 | void XglRenderFramework::ShutdownFramework() |
| 70 | { |
| 71 | if (m_colorBlend) xglDestroyObject(m_colorBlend); |
| 72 | if (m_stateMsaa) xglDestroyObject(m_stateMsaa); |
| 73 | if (m_stateDepthStencil) xglDestroyObject(m_stateDepthStencil); |
| 74 | if (m_stateRaster) xglDestroyObject(m_stateRaster); |
| 75 | if (m_cmdBuffer) xglDestroyObject(m_cmdBuffer); |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 76 | |
| 77 | if (m_stateViewport) { |
| 78 | xglDestroyObject(m_stateViewport); |
| 79 | } |
| 80 | |
| 81 | if (m_renderTarget) { |
| 82 | // TODO: XglImage should be able to destroy itself |
| 83 | // m_renderTarget-> |
| 84 | // xglDestroyObject(*m_renderTarget); |
| 85 | } |
Courtney Goeltzenleuchter | 53d8d89 | 2014-10-08 12:20:26 -0600 | [diff] [blame] | 86 | |
| 87 | // reset the driver |
| 88 | xglInitAndEnumerateGpus(&this->app_info, XGL_NULL_HANDLE, 0, &gpu_count, XGL_NULL_HANDLE); |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 89 | } |
| 90 | |
Courtney Goeltzenleuchter | 53d8d89 | 2014-10-08 12:20:26 -0600 | [diff] [blame] | 91 | void XglRenderFramework::InitState() |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 92 | { |
| 93 | XGL_RESULT err; |
| 94 | |
| 95 | m_render_target_fmt.channelFormat = XGL_CH_FMT_R8G8B8A8; |
| 96 | m_render_target_fmt.numericFormat = XGL_NUM_FMT_UNORM; |
| 97 | |
| 98 | // create a raster state (solid, back-face culling) |
| 99 | XGL_RASTER_STATE_CREATE_INFO raster = {}; |
| 100 | raster.sType = XGL_STRUCTURE_TYPE_RASTER_STATE_CREATE_INFO; |
| 101 | raster.fillMode = XGL_FILL_SOLID; |
| 102 | raster.cullMode = XGL_CULL_NONE; |
| 103 | raster.frontFace = XGL_FRONT_FACE_CCW; |
| 104 | err = xglCreateRasterState( device(), &raster, &m_stateRaster ); |
| 105 | ASSERT_XGL_SUCCESS(err); |
| 106 | |
| 107 | XGL_COLOR_BLEND_STATE_CREATE_INFO blend = {}; |
| 108 | blend.sType = XGL_STRUCTURE_TYPE_COLOR_BLEND_STATE_CREATE_INFO; |
| 109 | err = xglCreateColorBlendState(device(), &blend, &m_colorBlend); |
| 110 | ASSERT_XGL_SUCCESS( err ); |
| 111 | |
| 112 | XGL_DEPTH_STENCIL_STATE_CREATE_INFO depthStencil = {}; |
| 113 | depthStencil.sType = XGL_STRUCTURE_TYPE_DEPTH_STENCIL_STATE_CREATE_INFO; |
| 114 | depthStencil.depthTestEnable = XGL_FALSE; |
| 115 | depthStencil.depthWriteEnable = XGL_FALSE; |
| 116 | depthStencil.depthFunc = XGL_COMPARE_LESS_EQUAL; |
| 117 | depthStencil.depthBoundsEnable = XGL_FALSE; |
| 118 | depthStencil.minDepth = 0.f; |
| 119 | depthStencil.maxDepth = 1.f; |
| 120 | depthStencil.back.stencilDepthFailOp = XGL_STENCIL_OP_KEEP; |
| 121 | depthStencil.back.stencilFailOp = XGL_STENCIL_OP_KEEP; |
| 122 | depthStencil.back.stencilPassOp = XGL_STENCIL_OP_KEEP; |
| 123 | depthStencil.back.stencilRef = 0x00; |
| 124 | depthStencil.back.stencilFunc = XGL_COMPARE_ALWAYS; |
| 125 | depthStencil.front = depthStencil.back; |
| 126 | |
| 127 | err = xglCreateDepthStencilState( device(), &depthStencil, &m_stateDepthStencil ); |
| 128 | ASSERT_XGL_SUCCESS( err ); |
| 129 | |
| 130 | XGL_MSAA_STATE_CREATE_INFO msaa = {}; |
| 131 | msaa.sType = XGL_STRUCTURE_TYPE_MSAA_STATE_CREATE_INFO; |
| 132 | msaa.sampleMask = 1; |
| 133 | msaa.samples = 1; |
| 134 | |
| 135 | err = xglCreateMsaaState( device(), &msaa, &m_stateMsaa ); |
| 136 | ASSERT_XGL_SUCCESS( err ); |
| 137 | |
| 138 | XGL_CMD_BUFFER_CREATE_INFO cmdInfo = {}; |
| 139 | |
| 140 | cmdInfo.sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO; |
| 141 | cmdInfo.queueType = XGL_QUEUE_TYPE_GRAPHICS; |
| 142 | err = xglCreateCommandBuffer(device(), &cmdInfo, &m_cmdBuffer); |
| 143 | ASSERT_XGL_SUCCESS(err) << "xglCreateCommandBuffer failed"; |
| 144 | } |
| 145 | |
| 146 | void XglRenderFramework::InitConstantBuffer(int constantCount, int constantSize, |
| 147 | const void* data) |
| 148 | { |
| 149 | XGL_RESULT err = XGL_SUCCESS; |
| 150 | |
| 151 | XGL_MEMORY_ALLOC_INFO alloc_info = {}; |
| 152 | XGL_UINT8 *pData; |
| 153 | |
| 154 | alloc_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO; |
| 155 | alloc_info.allocationSize = constantCount * constantSize; |
| 156 | alloc_info.alignment = 0; |
| 157 | alloc_info.heapCount = 1; |
| 158 | alloc_info.heaps[0] = 0; // TODO: Use known existing heap |
| 159 | |
| 160 | alloc_info.flags = XGL_MEMORY_HEAP_CPU_VISIBLE_BIT; |
| 161 | alloc_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL; |
| 162 | |
| 163 | err = xglAllocMemory(device(), &alloc_info, &m_constantBufferMem); |
| 164 | ASSERT_XGL_SUCCESS(err); |
| 165 | |
| 166 | err = xglMapMemory(m_constantBufferMem, 0, (XGL_VOID **) &pData); |
| 167 | ASSERT_XGL_SUCCESS(err); |
| 168 | |
| 169 | memcpy(pData, data, alloc_info.allocationSize); |
| 170 | |
| 171 | err = xglUnmapMemory(m_constantBufferMem); |
| 172 | ASSERT_XGL_SUCCESS(err); |
| 173 | |
| 174 | // set up the memory view for the constant buffer |
| 175 | this->m_constantBufferView.stride = 1; |
Cody Northrop | ee6586d | 2014-10-09 19:55:56 -0600 | [diff] [blame^] | 176 | this->m_constantBufferView.range = constantCount * constantSize; |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 177 | this->m_constantBufferView.offset = 0; |
| 178 | this->m_constantBufferView.mem = m_constantBufferMem; |
| 179 | this->m_constantBufferView.format.channelFormat = XGL_CH_FMT_R32G32B32A32; |
| 180 | this->m_constantBufferView.format.numericFormat = XGL_NUM_FMT_FLOAT; |
| 181 | } |
| 182 | |
| 183 | void XglRenderFramework::CreateQueryPool(XGL_QUERY_TYPE type, XGL_UINT slots, |
| 184 | XGL_QUERY_POOL *pPool, XGL_GPU_MEMORY *pMem) |
| 185 | { |
| 186 | XGL_RESULT err; |
| 187 | |
| 188 | XGL_QUERY_POOL_CREATE_INFO poolCreateInfo = {}; |
| 189 | poolCreateInfo.sType = XGL_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO; |
| 190 | poolCreateInfo.pNext = NULL; |
| 191 | poolCreateInfo.queryType = type; |
| 192 | poolCreateInfo.slots = slots; |
| 193 | |
| 194 | err = xglCreateQueryPool(device(), &poolCreateInfo, pPool); |
| 195 | ASSERT_XGL_SUCCESS(err); |
| 196 | |
| 197 | XGL_MEMORY_REQUIREMENTS mem_req; |
| 198 | XGL_UINT data_size = sizeof(mem_req); |
| 199 | err = xglGetObjectInfo(*pPool, XGL_INFO_TYPE_MEMORY_REQUIREMENTS, |
| 200 | &data_size, &mem_req); |
| 201 | ASSERT_XGL_SUCCESS(err); |
| 202 | ASSERT_EQ(data_size, sizeof(mem_req)); |
| 203 | |
| 204 | if (!mem_req.size) { |
| 205 | *pMem = XGL_NULL_HANDLE; |
| 206 | return; |
| 207 | } |
| 208 | |
| 209 | XGL_MEMORY_ALLOC_INFO mem_info; |
| 210 | |
| 211 | memset(&mem_info, 0, sizeof(mem_info)); |
| 212 | mem_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO; |
| 213 | mem_info.allocationSize = mem_req.size; |
| 214 | mem_info.alignment = mem_req.alignment; |
| 215 | mem_info.heapCount = mem_req.heapCount; |
| 216 | memcpy(mem_info.heaps, mem_req.heaps, sizeof(XGL_UINT)*XGL_MAX_MEMORY_HEAPS); |
| 217 | mem_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL; |
| 218 | mem_info.flags = XGL_MEMORY_ALLOC_SHAREABLE_BIT; |
| 219 | err = xglAllocMemory(device(), &mem_info, pMem); |
| 220 | ASSERT_XGL_SUCCESS(err); |
| 221 | |
| 222 | err = xglBindObjectMemory(*pPool, *pMem, 0); |
| 223 | ASSERT_XGL_SUCCESS(err); |
| 224 | } |
| 225 | |
| 226 | void XglRenderFramework::DestroyQueryPool(XGL_QUERY_POOL pool, XGL_GPU_MEMORY mem) |
| 227 | { |
| 228 | ASSERT_XGL_SUCCESS(xglBindObjectMemory(pool, XGL_NULL_HANDLE, 0)); |
| 229 | ASSERT_XGL_SUCCESS(xglFreeMemory(mem)); |
| 230 | ASSERT_XGL_SUCCESS(xglDestroyObject(pool)); |
| 231 | } |
| 232 | |
| 233 | void XglRenderFramework::CreateShader(XGL_PIPELINE_SHADER_STAGE stage, |
| 234 | const char *shader_code, |
| 235 | XGL_SHADER *pshader) |
| 236 | { |
| 237 | XGL_RESULT err; |
| 238 | std::vector<unsigned int> bil; |
| 239 | XGL_SHADER_CREATE_INFO createInfo; |
| 240 | XGL_SHADER shader; |
| 241 | |
| 242 | createInfo.sType = XGL_STRUCTURE_TYPE_SHADER_CREATE_INFO; |
| 243 | createInfo.pNext = NULL; |
| 244 | |
Courtney Goeltzenleuchter | b666dc6 | 2014-10-09 09:13:56 -0600 | [diff] [blame] | 245 | if (!this->m_use_bil && this->m_device->extension_exist("XGL_COMPILE_GLSL")) { |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 246 | XGL_INTEL_COMPILE_GLSL glsl_header; |
| 247 | |
| 248 | glsl_header.stage = stage; |
| 249 | glsl_header.pCode = shader_code; |
| 250 | // Driver has extended CreateShader to process GLSL |
| 251 | createInfo.sType = (XGL_STRUCTURE_TYPE) XGL_INTEL_STRUCTURE_TYPE_SHADER_CREATE_INFO; |
| 252 | createInfo.pCode = &glsl_header; |
| 253 | createInfo.codeSize = strlen(shader_code); |
| 254 | createInfo.flags = 0; |
| 255 | } else { |
| 256 | // Use Reference GLSL to BIL compiler |
| 257 | GLSLtoBIL(stage, shader_code, bil); |
| 258 | createInfo.pCode = bil.data(); |
| 259 | createInfo.codeSize = bil.size() * sizeof(unsigned int); |
| 260 | createInfo.flags = 0; |
| 261 | } |
| 262 | |
| 263 | err = xglCreateShader(device(), &createInfo, &shader); |
| 264 | ASSERT_XGL_SUCCESS(err); |
| 265 | |
| 266 | *pshader = shader; |
| 267 | } |
| 268 | |
| 269 | void XglRenderFramework::InitViewport(float width, float height) |
| 270 | { |
| 271 | XGL_RESULT err; |
| 272 | |
| 273 | XGL_VIEWPORT_STATE_CREATE_INFO viewport = {}; |
| 274 | viewport.viewportCount = 1; |
| 275 | viewport.scissorEnable = XGL_FALSE; |
| 276 | viewport.viewports[0].originX = 0; |
| 277 | viewport.viewports[0].originY = 0; |
| 278 | viewport.viewports[0].width = 1.f * width; |
| 279 | viewport.viewports[0].height = 1.f * height; |
| 280 | viewport.viewports[0].minDepth = 0.f; |
| 281 | viewport.viewports[0].maxDepth = 1.f; |
| 282 | |
| 283 | err = xglCreateViewportState( device(), &viewport, &m_stateViewport ); |
| 284 | ASSERT_XGL_SUCCESS( err ); |
| 285 | m_width = width; |
| 286 | m_height = height; |
| 287 | } |
| 288 | |
Courtney Goeltzenleuchter | 02d33c1 | 2014-10-08 14:26:40 -0600 | [diff] [blame] | 289 | void XglRenderFramework::InitViewport() |
| 290 | { |
| 291 | InitViewport(m_width, m_height); |
| 292 | } |
| 293 | |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 294 | void XglRenderFramework::InitRenderTarget() |
| 295 | { |
| 296 | m_device->CreateImage(m_width, m_height, m_render_target_fmt, |
| 297 | XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT | |
| 298 | XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, |
| 299 | &m_renderTarget); |
| 300 | } |
| 301 | |
Courtney Goeltzenleuchter | 02d33c1 | 2014-10-08 14:26:40 -0600 | [diff] [blame] | 302 | void XglRenderFramework::CreateDefaultPipeline(XGL_PIPELINE* pipeline, XGL_SHADER vs, XGL_SHADER ps) |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 303 | { |
| 304 | XGL_RESULT err; |
| 305 | XGL_GRAPHICS_PIPELINE_CREATE_INFO info = {}; |
| 306 | XGL_PIPELINE_SHADER_STAGE_CREATE_INFO vs_stage; |
| 307 | XGL_PIPELINE_SHADER_STAGE_CREATE_INFO ps_stage; |
| 308 | |
| 309 | #if 0 |
| 310 | // Create descriptor set for our one resource |
| 311 | XGL_DESCRIPTOR_SET_CREATE_INFO descriptorInfo = {}; |
| 312 | descriptorInfo.sType = XGL_STRUCTURE_TYPE_DESCRIPTOR_SET_CREATE_INFO; |
| 313 | descriptorInfo.slots = 1; // Vertex buffer only |
| 314 | |
| 315 | // create a descriptor set with a single slot |
| 316 | err = xglCreateDescriptorSet( device(), &descriptorInfo, &m_rsrcDescSet ); |
| 317 | ASSERT_XGL_SUCCESS(err) << "xglCreateDescriptorSet failed"; |
| 318 | |
| 319 | // bind memory to the descriptor set |
| 320 | err = m_device->AllocAndBindGpuMemory(m_rsrcDescSet, "DescriptorSet", &m_descriptor_set_mem); |
| 321 | |
| 322 | // set up the memory view for the vertex buffer |
| 323 | this->m_vtxBufferView.stride = vbStride; |
| 324 | this->m_vtxBufferView.range = numVertices * vbStride; |
| 325 | this->m_vtxBufferView.offset = 0; |
| 326 | this->m_vtxBufferView.mem = m_vtxBufferMem; |
| 327 | this->m_vtxBufferView.format.channelFormat = XGL_CH_FMT_UNDEFINED; |
| 328 | this->m_vtxBufferView.format.numericFormat = XGL_NUM_FMT_UNDEFINED; |
| 329 | // write the vertex buffer view to the descriptor set |
| 330 | xglBeginDescriptorSetUpdate( m_rsrcDescSet ); |
| 331 | xglAttachMemoryViewDescriptors( m_rsrcDescSet, 0, 1, &m_vtxBufferView ); |
| 332 | xglEndDescriptorSetUpdate( m_rsrcDescSet ); |
| 333 | #endif |
| 334 | |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 335 | vs_stage.sType = XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; |
| 336 | vs_stage.pNext = XGL_NULL_HANDLE; |
| 337 | vs_stage.shader.stage = XGL_SHADER_STAGE_VERTEX; |
Courtney Goeltzenleuchter | 02d33c1 | 2014-10-08 14:26:40 -0600 | [diff] [blame] | 338 | vs_stage.shader.shader = vs; |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 339 | vs_stage.shader.descriptorSetMapping[0].descriptorCount = 0; |
| 340 | vs_stage.shader.linkConstBufferCount = 0; |
| 341 | vs_stage.shader.pLinkConstBufferInfo = XGL_NULL_HANDLE; |
| 342 | vs_stage.shader.dynamicMemoryViewMapping.slotObjectType = XGL_SLOT_UNUSED; |
| 343 | vs_stage.shader.dynamicMemoryViewMapping.shaderEntityIndex = 0; |
| 344 | |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 345 | ps_stage.sType = XGL_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; |
| 346 | ps_stage.pNext = &vs_stage; |
| 347 | ps_stage.shader.stage = XGL_SHADER_STAGE_FRAGMENT; |
Courtney Goeltzenleuchter | 02d33c1 | 2014-10-08 14:26:40 -0600 | [diff] [blame] | 348 | ps_stage.shader.shader = ps; |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 349 | |
| 350 | const int slots = 1; |
| 351 | XGL_DESCRIPTOR_SLOT_INFO *slotInfo = (XGL_DESCRIPTOR_SLOT_INFO*) malloc( slots * sizeof(XGL_DESCRIPTOR_SLOT_INFO) ); |
| 352 | slotInfo[0].shaderEntityIndex = 0; |
| 353 | slotInfo[0].slotObjectType = XGL_SLOT_SHADER_RESOURCE; |
| 354 | |
| 355 | ps_stage.shader.descriptorSetMapping[0].pDescriptorInfo = (const XGL_DESCRIPTOR_SLOT_INFO*) slotInfo; |
| 356 | ps_stage.shader.descriptorSetMapping[0].descriptorCount = 1; |
| 357 | |
| 358 | ps_stage.shader.linkConstBufferCount = 0; |
| 359 | ps_stage.shader.pLinkConstBufferInfo = XGL_NULL_HANDLE; |
| 360 | ps_stage.shader.dynamicMemoryViewMapping.slotObjectType = XGL_SLOT_UNUSED; |
| 361 | ps_stage.shader.dynamicMemoryViewMapping.shaderEntityIndex = 0; |
| 362 | |
| 363 | XGL_PIPELINE_IA_STATE_CREATE_INFO ia_state = { |
| 364 | XGL_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO, // sType |
| 365 | &ps_stage, // pNext |
| 366 | XGL_TOPOLOGY_TRIANGLE_LIST, // XGL_PRIMITIVE_TOPOLOGY |
| 367 | XGL_FALSE, // disableVertexReuse |
| 368 | XGL_PROVOKING_VERTEX_LAST, // XGL_PROVOKING_VERTEX_CONVENTION |
| 369 | XGL_FALSE, // primitiveRestartEnable |
| 370 | 0 // primitiveRestartIndex |
| 371 | }; |
| 372 | |
| 373 | XGL_PIPELINE_RS_STATE_CREATE_INFO rs_state = { |
| 374 | XGL_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO, |
| 375 | &ia_state, |
| 376 | XGL_FALSE, // depthClipEnable |
| 377 | XGL_FALSE, // rasterizerDiscardEnable |
| 378 | 1.0 // pointSize |
| 379 | }; |
| 380 | |
| 381 | XGL_PIPELINE_CB_STATE cb_state = { |
| 382 | XGL_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO, |
| 383 | &rs_state, |
| 384 | XGL_FALSE, // alphaToCoverageEnable |
| 385 | XGL_FALSE, // dualSourceBlendEnable |
| 386 | XGL_LOGIC_OP_COPY, // XGL_LOGIC_OP |
| 387 | { // XGL_PIPELINE_CB_ATTACHMENT_STATE |
| 388 | { |
| 389 | XGL_FALSE, // blendEnable |
| 390 | m_render_target_fmt, // XGL_FORMAT |
| 391 | 0xF // channelWriteMask |
| 392 | } |
| 393 | } |
| 394 | }; |
| 395 | |
| 396 | // TODO: Should take depth buffer format from queried formats |
| 397 | XGL_PIPELINE_DB_STATE_CREATE_INFO db_state = { |
| 398 | XGL_STRUCTURE_TYPE_PIPELINE_DB_STATE_CREATE_INFO, |
| 399 | &cb_state, |
| 400 | {XGL_CH_FMT_R32, XGL_NUM_FMT_DS} // XGL_FORMAT |
| 401 | }; |
| 402 | |
| 403 | info.sType = XGL_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; |
| 404 | info.pNext = &db_state; |
| 405 | info.flags = 0; |
| 406 | err = xglCreateGraphicsPipeline(device(), &info, pipeline); |
| 407 | ASSERT_XGL_SUCCESS(err); |
| 408 | |
| 409 | err = m_device->AllocAndBindGpuMemory(*pipeline, "Pipeline", &m_pipe_mem); |
| 410 | ASSERT_XGL_SUCCESS(err); |
| 411 | } |
| 412 | |
Courtney Goeltzenleuchter | 02d33c1 | 2014-10-08 14:26:40 -0600 | [diff] [blame] | 413 | void XglRenderFramework::GenerateBindRenderTargetCmd() |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 414 | { |
| 415 | // bind render target |
| 416 | XGL_COLOR_ATTACHMENT_BIND_INFO colorBind = {}; |
Courtney Goeltzenleuchter | 02d33c1 | 2014-10-08 14:26:40 -0600 | [diff] [blame] | 417 | colorBind.view = m_renderTarget->targetView(); |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 418 | colorBind.colorAttachmentState = XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL; |
| 419 | xglCmdBindAttachments(m_cmdBuffer, 1, &colorBind, NULL ); |
| 420 | } |
| 421 | |
| 422 | void XglRenderFramework::GenerateBindStateAndPipelineCmds(XGL_PIPELINE* pipeline) |
| 423 | { |
| 424 | // set all states |
| 425 | xglCmdBindStateObject( m_cmdBuffer, XGL_STATE_BIND_RASTER, m_stateRaster ); |
| 426 | xglCmdBindStateObject( m_cmdBuffer, XGL_STATE_BIND_VIEWPORT, m_stateViewport ); |
| 427 | xglCmdBindStateObject( m_cmdBuffer, XGL_STATE_BIND_COLOR_BLEND, m_colorBlend); |
| 428 | xglCmdBindStateObject( m_cmdBuffer, XGL_STATE_BIND_DEPTH_STENCIL, m_stateDepthStencil ); |
| 429 | xglCmdBindStateObject( m_cmdBuffer, XGL_STATE_BIND_MSAA, m_stateMsaa ); |
| 430 | |
| 431 | // bind pipeline, vertex buffer (descriptor set) and WVP (dynamic memory view) |
| 432 | xglCmdBindPipeline( m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, *pipeline ); |
Courtney Goeltzenleuchter | 02d33c1 | 2014-10-08 14:26:40 -0600 | [diff] [blame] | 433 | |
| 434 | // bind pipeline, vertex buffer (descriptor set) and WVP (dynamic memory view) |
| 435 | xglCmdBindDescriptorSet(m_cmdBuffer, XGL_PIPELINE_BIND_POINT_GRAPHICS, 0, m_rsrcDescSet, 0 ); |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 436 | } |
| 437 | |
Courtney Goeltzenleuchter | 02d33c1 | 2014-10-08 14:26:40 -0600 | [diff] [blame] | 438 | void XglRenderFramework::GenerateClearAndPrepareBufferCmds() |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 439 | { |
| 440 | // whatever we want to do, we do it to the whole buffer |
| 441 | XGL_IMAGE_SUBRESOURCE_RANGE srRange = {}; |
| 442 | srRange.aspect = XGL_IMAGE_ASPECT_COLOR; |
| 443 | srRange.baseMipLevel = 0; |
| 444 | srRange.mipLevels = XGL_LAST_MIP_OR_SLICE; |
| 445 | srRange.baseArraySlice = 0; |
| 446 | srRange.arraySize = XGL_LAST_MIP_OR_SLICE; |
| 447 | |
| 448 | // prepare the whole back buffer for clear |
| 449 | XGL_IMAGE_STATE_TRANSITION transitionToClear = {}; |
| 450 | transitionToClear.image = m_renderTarget->image(); |
| 451 | transitionToClear.oldState = m_renderTarget->state(); |
| 452 | transitionToClear.newState = XGL_IMAGE_STATE_CLEAR; |
| 453 | transitionToClear.subresourceRange = srRange; |
| 454 | xglCmdPrepareImages( m_cmdBuffer, 1, &transitionToClear ); |
| 455 | m_renderTarget->state(( XGL_IMAGE_STATE ) transitionToClear.newState); |
| 456 | |
| 457 | // clear the back buffer to dark grey |
| 458 | XGL_UINT clearColor[4] = {64, 64, 64, 0}; |
| 459 | xglCmdClearColorImageRaw( m_cmdBuffer, m_renderTarget->image(), clearColor, 1, &srRange ); |
| 460 | |
| 461 | // prepare back buffer for rendering |
| 462 | XGL_IMAGE_STATE_TRANSITION transitionToRender = {}; |
| 463 | transitionToRender.image = m_renderTarget->image(); |
| 464 | transitionToRender.oldState = m_renderTarget->state(); |
| 465 | transitionToRender.newState = XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL; |
| 466 | transitionToRender.subresourceRange = srRange; |
| 467 | xglCmdPrepareImages( m_cmdBuffer, 1, &transitionToRender ); |
| 468 | m_renderTarget->state(( XGL_IMAGE_STATE ) transitionToClear.newState); |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 469 | } |