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