| // Copyright 2005, Google Inc. |
| // All rights reserved. |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| |
| // XGL tests |
| // |
| // Copyright (C) 2014 LunarG, Inc. |
| // |
| // Permission is hereby granted, free of charge, to any person obtaining a |
| // copy of this software and associated documentation files (the "Software"), |
| // to deal in the Software without restriction, including without limitation |
| // the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| // and/or sell copies of the Software, and to permit persons to whom the |
| // Software is furnished to do so, subject to the following conditions: |
| // |
| // The above copyright notice and this permission notice shall be included |
| // in all copies or substantial portions of the Software. |
| // |
| // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
| // DEALINGS IN THE SOFTWARE. |
| |
| // Basic rendering tests |
| |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <stdbool.h> |
| #include <string.h> |
| #include <iostream> |
| #include <fstream> |
| using namespace std; |
| |
| #include <xgl.h> |
| #ifdef DUMP_STATE_DOT |
| #include "../layers/draw_state.h" |
| #endif |
| #ifdef PRINT_OBJECTS |
| #include "../layers/object_track.h" |
| #endif |
| #ifdef DEBUG_CALLBACK |
| #include <xglDbg.h> |
| #endif |
| #include "gtest-1.7.0/include/gtest/gtest.h" |
| |
| #include "icd-spv.h" |
| |
| #define GLM_FORCE_RADIANS |
| #include "glm/glm.hpp" |
| #include <glm/gtc/matrix_transform.hpp> |
| |
| #include "xglrenderframework.h" |
| #ifdef DEBUG_CALLBACK |
| void XGLAPI myDbgFunc( |
| XGL_DBG_MSG_TYPE msgType, |
| XGL_VALIDATION_LEVEL validationLevel, |
| XGL_BASE_OBJECT srcObject, |
| size_t location, |
| int32_t msgCode, |
| const char* pMsg, |
| void* pUserData) |
| { |
| switch (msgType) |
| { |
| case XGL_DBG_MSG_WARNING: |
| printf("CALLBACK WARNING : %s\n", pMsg); |
| break; |
| case XGL_DBG_MSG_ERROR: |
| printf("CALLBACK ERROR : %s\n", pMsg); |
| break; |
| default: |
| printf("EATING Msg of type %u\n", msgType); |
| break; |
| } |
| } |
| #endif |
| |
| |
| #undef ASSERT_NO_FATAL_FAILURE |
| #define ASSERT_NO_FATAL_FAILURE(x) x |
| |
| //-------------------------------------------------------------------------------------- |
| // Mesh and VertexFormat Data |
| //-------------------------------------------------------------------------------------- |
| struct Vertex |
| { |
| float posX, posY, posZ, posW; // Position data |
| float r, g, b, a; // Color |
| }; |
| |
| #define XYZ1(_x_, _y_, _z_) (_x_), (_y_), (_z_), 1.f |
| |
| static const Vertex g_vbData[] = |
| { |
| { XYZ1( -1, -1, -1 ), XYZ1( 0.f, 0.f, 0.f ) }, |
| { XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) }, |
| { XYZ1( -1, 1, -1 ), XYZ1( 0.f, 1.f, 0.f ) }, |
| { XYZ1( -1, 1, -1 ), XYZ1( 0.f, 1.f, 0.f ) }, |
| { XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) }, |
| { XYZ1( 1, 1, -1 ), XYZ1( 1.f, 1.f, 0.f ) }, |
| |
| { XYZ1( -1, -1, 1 ), XYZ1( 0.f, 0.f, 1.f ) }, |
| { XYZ1( -1, 1, 1 ), XYZ1( 0.f, 1.f, 1.f ) }, |
| { XYZ1( 1, -1, 1 ), XYZ1( 1.f, 0.f, 1.f ) }, |
| { XYZ1( 1, -1, 1 ), XYZ1( 1.f, 0.f, 1.f ) }, |
| { XYZ1( -1, 1, 1 ), XYZ1( 0.f, 1.f, 1.f ) }, |
| { XYZ1( 1, 1, 1 ), XYZ1( 1.f, 1.f, 1.f ) }, |
| |
| { XYZ1( 1, 1, 1 ), XYZ1( 1.f, 1.f, 1.f ) }, |
| { XYZ1( 1, 1, -1 ), XYZ1( 1.f, 1.f, 0.f ) }, |
| { XYZ1( 1, -1, 1 ), XYZ1( 1.f, 0.f, 1.f ) }, |
| { XYZ1( 1, -1, 1 ), XYZ1( 1.f, 0.f, 1.f ) }, |
| { XYZ1( 1, 1, -1 ), XYZ1( 1.f, 1.f, 0.f ) }, |
| { XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) }, |
| |
| { XYZ1( -1, 1, 1 ), XYZ1( 0.f, 1.f, 1.f ) }, |
| { XYZ1( -1, -1, 1 ), XYZ1( 0.f, 0.f, 1.f ) }, |
| { XYZ1( -1, 1, -1 ), XYZ1( 0.f, 1.f, 0.f ) }, |
| { XYZ1( -1, 1, -1 ), XYZ1( 0.f, 1.f, 0.f ) }, |
| { XYZ1( -1, -1, 1 ), XYZ1( 0.f, 0.f, 1.f ) }, |
| { XYZ1( -1, -1, -1 ), XYZ1( 0.f, 0.f, 0.f ) }, |
| |
| { XYZ1( 1, 1, 1 ), XYZ1( 1.f, 1.f, 1.f ) }, |
| { XYZ1( -1, 1, 1 ), XYZ1( 0.f, 1.f, 1.f ) }, |
| { XYZ1( 1, 1, -1 ), XYZ1( 1.f, 1.f, 0.f ) }, |
| { XYZ1( 1, 1, -1 ), XYZ1( 1.f, 1.f, 0.f ) }, |
| { XYZ1( -1, 1, 1 ), XYZ1( 0.f, 1.f, 1.f ) }, |
| { XYZ1( -1, 1, -1 ), XYZ1( 0.f, 1.f, 0.f ) }, |
| |
| { XYZ1( 1, -1, 1 ), XYZ1( 1.f, 0.f, 1.f ) }, |
| { XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) }, |
| { XYZ1( -1, -1, 1 ), XYZ1( 0.f, 0.f, 1.f ) }, |
| { XYZ1( -1, -1, 1 ), XYZ1( 0.f, 0.f, 1.f ) }, |
| { XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) }, |
| { XYZ1( -1, -1, -1 ), XYZ1( 0.f, 0.f, 0.f ) }, |
| }; |
| |
| static const Vertex g_vb_solid_face_colors_Data[] = |
| { |
| { XYZ1( -1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) }, |
| { XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) }, |
| { XYZ1( -1, 1, -1 ), XYZ1( 1.f, 0.f, 0.f ) }, |
| { XYZ1( -1, 1, -1 ), XYZ1( 1.f, 0.f, 0.f ) }, |
| { XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) }, |
| { XYZ1( 1, 1, -1 ), XYZ1( 1.f, 0.f, 0.f ) }, |
| |
| { XYZ1( -1, -1, 1 ), XYZ1( 0.f, 1.f, 0.f ) }, |
| { XYZ1( -1, 1, 1 ), XYZ1( 0.f, 1.f, 0.f ) }, |
| { XYZ1( 1, -1, 1 ), XYZ1( 0.f, 1.f, 0.f ) }, |
| { XYZ1( 1, -1, 1 ), XYZ1( 0.f, 1.f, 0.f ) }, |
| { XYZ1( -1, 1, 1 ), XYZ1( 0.f, 1.f, 0.f ) }, |
| { XYZ1( 1, 1, 1 ), XYZ1( 0.f, 1.f, 0.f ) }, |
| |
| { XYZ1( 1, 1, 1 ), XYZ1( 0.f, 0.f, 1.f ) }, |
| { XYZ1( 1, 1, -1 ), XYZ1( 0.f, 0.f, 1.f ) }, |
| { XYZ1( 1, -1, 1 ), XYZ1( 0.f, 0.f, 1.f ) }, |
| { XYZ1( 1, -1, 1 ), XYZ1( 0.f, 0.f, 1.f ) }, |
| { XYZ1( 1, 1, -1 ), XYZ1( 0.f, 0.f, 1.f ) }, |
| { XYZ1( 1, -1, -1 ), XYZ1( 0.f, 0.f, 1.f ) }, |
| |
| { XYZ1( -1, 1, 1 ), XYZ1( 1.f, 1.f, 0.f ) }, |
| { XYZ1( -1, -1, 1 ), XYZ1( 1.f, 1.f, 0.f ) }, |
| { XYZ1( -1, 1, -1 ), XYZ1( 1.f, 1.f, 0.f ) }, |
| { XYZ1( -1, 1, -1 ), XYZ1( 1.f, 1.f, 0.f ) }, |
| { XYZ1( -1, -1, 1 ), XYZ1( 1.f, 1.f, 0.f ) }, |
| { XYZ1( -1, -1, -1 ), XYZ1( 1.f, 1.f, 0.f ) }, |
| |
| { XYZ1( 1, 1, 1 ), XYZ1( 1.f, 0.f, 1.f ) }, |
| { XYZ1( -1, 1, 1 ), XYZ1( 1.f, 0.f, 1.f ) }, |
| { XYZ1( 1, 1, -1 ), XYZ1( 1.f, 0.f, 1.f ) }, |
| { XYZ1( 1, 1, -1 ), XYZ1( 1.f, 0.f, 1.f ) }, |
| { XYZ1( -1, 1, 1 ), XYZ1( 1.f, 0.f, 1.f ) }, |
| { XYZ1( -1, 1, -1 ), XYZ1( 1.f, 0.f, 1.f ) }, |
| |
| { XYZ1( 1, -1, 1 ), XYZ1( 0.f, 1.f, 1.f ) }, |
| { XYZ1( 1, -1, -1 ), XYZ1( 0.f, 1.f, 1.f ) }, |
| { XYZ1( -1, -1, 1 ), XYZ1( 0.f, 1.f, 1.f ) }, |
| { XYZ1( -1, -1, 1 ), XYZ1( 0.f, 1.f, 1.f ) }, |
| { XYZ1( 1, -1, -1 ), XYZ1( 0.f, 1.f, 1.f ) }, |
| { XYZ1( -1, -1, -1 ), XYZ1( 0.f, 1.f, 1.f ) }, |
| }; |
| |
| class XglRenderTest : public XglRenderFramework |
| { |
| public: |
| |
| void RotateTriangleVSUniform(glm::mat4 Projection, glm::mat4 View, glm::mat4 Model, |
| XglConstantBufferObj *constantBuffer, XglCommandBufferObj *cmdBuffer); |
| void GenericDrawPreparation(XglCommandBufferObj *cmdBuffer, XglPipelineObj *pipelineobj, XglDescriptorSetObj *descriptorSet); |
| void InitDepthStencil(); |
| void XGLTriangleTest(const char *vertShaderText, const char *fragShaderText, const bool rotate); |
| |
| XGL_RESULT BeginCommandBuffer(XglCommandBufferObj &cmdBuffer); |
| XGL_RESULT EndCommandBuffer(XglCommandBufferObj &cmdBuffer); |
| |
| protected: |
| XGL_IMAGE m_texture; |
| XGL_IMAGE_VIEW m_textureView; |
| XGL_IMAGE_VIEW_ATTACH_INFO m_textureViewInfo; |
| XGL_GPU_MEMORY m_textureMem; |
| |
| XGL_SAMPLER m_sampler; |
| |
| XGL_IMAGE m_depthStencilImage; |
| uint32_t m_num_mem; |
| XGL_GPU_MEMORY *m_depthStencilMem; |
| XGL_DEPTH_STENCIL_VIEW m_depthStencilView; |
| XglMemoryRefManager m_memoryRefManager; |
| |
| |
| virtual void SetUp() { |
| |
| this->app_info.sType = XGL_STRUCTURE_TYPE_APPLICATION_INFO; |
| this->app_info.pNext = NULL; |
| this->app_info.pAppName = "render_tests"; |
| this->app_info.appVersion = 1; |
| this->app_info.pEngineName = "unittest"; |
| this->app_info.engineVersion = 1; |
| this->app_info.apiVersion = XGL_API_VERSION; |
| |
| memset(&m_textureViewInfo, 0, sizeof(m_textureViewInfo)); |
| m_textureViewInfo.sType = XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO; |
| memset(&m_depthStencilImage, 0, sizeof(m_depthStencilImage)); |
| |
| InitFramework(); |
| } |
| |
| virtual void TearDown() { |
| // Clean up resources before we reset |
| ShutdownFramework(); |
| } |
| }; |
| |
| XGL_RESULT XglRenderTest::BeginCommandBuffer(XglCommandBufferObj &cmdBuffer) |
| { |
| XGL_RESULT result; |
| |
| result = cmdBuffer.BeginCommandBuffer(); |
| |
| /* |
| * For render test all drawing happens in a single render pass |
| * on a single command buffer. |
| */ |
| if (XGL_SUCCESS == result) { |
| cmdBuffer.BeginRenderPass(renderPass(), framebuffer()); |
| } |
| |
| return result; |
| } |
| |
| XGL_RESULT XglRenderTest::EndCommandBuffer(XglCommandBufferObj &cmdBuffer) |
| { |
| XGL_RESULT result; |
| |
| cmdBuffer.EndRenderPass(renderPass()); |
| |
| result = cmdBuffer.EndCommandBuffer(); |
| |
| return result; |
| } |
| |
| |
| void XglRenderTest::GenericDrawPreparation(XglCommandBufferObj *cmdBuffer, XglPipelineObj *pipelineobj, XglDescriptorSetObj *descriptorSet) |
| { |
| cmdBuffer->ClearAllBuffers(m_clear_color, m_depth_clear_color, m_stencil_clear_color, |
| &m_depthStencilBinding, m_depthStencilImage); |
| cmdBuffer->PrepareAttachments(); |
| cmdBuffer->BindStateObject(XGL_STATE_BIND_RASTER, m_stateRaster); |
| cmdBuffer->BindStateObject(XGL_STATE_BIND_VIEWPORT, m_stateViewport); |
| cmdBuffer->BindStateObject(XGL_STATE_BIND_COLOR_BLEND, m_colorBlend); |
| cmdBuffer->BindStateObject(XGL_STATE_BIND_DEPTH_STENCIL, m_stateDepthStencil); |
| descriptorSet->CreateXGLDescriptorSet(cmdBuffer); |
| pipelineobj->CreateXGLPipeline(descriptorSet); |
| cmdBuffer->BindPipeline(pipelineobj->GetPipelineHandle()); |
| cmdBuffer->BindDescriptorSet(descriptorSet->GetDescriptorSetHandle()); |
| } |
| |
| void XglRenderTest::RotateTriangleVSUniform(glm::mat4 Projection, glm::mat4 View, glm::mat4 Model, |
| XglConstantBufferObj *constantBuffer, XglCommandBufferObj *cmdBuffer) |
| { |
| int i; |
| glm::mat4 MVP; |
| int matrixSize = sizeof(MVP); |
| XGL_RESULT err; |
| |
| for (i = 0; i < 8; i++) { |
| void *pData = constantBuffer->map(); |
| |
| Model = glm::rotate(Model, glm::radians(22.5f), glm::vec3(0.0f, 1.0f, 0.0f)); |
| MVP = Projection * View * Model; |
| memcpy(pData, (const void*) &MVP[0][0], matrixSize); |
| |
| constantBuffer->unmap(); |
| |
| // submit the command buffer to the universal queue |
| cmdBuffer->QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| err = xglQueueWaitIdle( m_device->m_queue ); |
| ASSERT_XGL_SUCCESS( err ); |
| |
| // Wait for work to finish before cleaning up. |
| xglDeviceWaitIdle(m_device->device()); |
| |
| assert(m_renderTargets.size() == 1); |
| RecordImage(m_renderTargets[0]); |
| } |
| } |
| |
| void dumpMatrix(const char *note, glm::mat4 MVP) |
| { |
| int i; |
| |
| printf("%s: \n", note); |
| for (i=0; i<4; i++) { |
| printf("%f, %f, %f, %f\n", MVP[i][0], MVP[i][1], MVP[i][2], MVP[i][3]); |
| } |
| printf("\n"); |
| fflush(stdout); |
| } |
| |
| void dumpVec4(const char *note, glm::vec4 vector) |
| { |
| printf("%s: \n", note); |
| printf("%f, %f, %f, %f\n", vector[0], vector[1], vector[2], vector[3]); |
| printf("\n"); |
| fflush(stdout); |
| } |
| |
| void XglRenderTest::InitDepthStencil() |
| { |
| XGL_RESULT err; |
| XGL_IMAGE_CREATE_INFO image; |
| XGL_MEMORY_ALLOC_INFO mem_alloc; |
| XGL_MEMORY_ALLOC_IMAGE_INFO img_alloc; |
| XGL_DEPTH_STENCIL_VIEW_CREATE_INFO view; |
| XGL_MEMORY_REQUIREMENTS *mem_reqs; |
| size_t mem_reqs_size=sizeof(XGL_MEMORY_REQUIREMENTS); |
| XGL_IMAGE_MEMORY_REQUIREMENTS img_reqs; |
| size_t img_reqs_size = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS); |
| uint32_t num_allocations = 0; |
| size_t num_alloc_size = sizeof(num_allocations); |
| |
| // Clean up default state created by framework |
| if (m_stateDepthStencil) xglDestroyObject(m_stateDepthStencil); |
| |
| m_depth_stencil_fmt = XGL_FMT_D16_UNORM; |
| |
| image.sType = XGL_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| image.pNext = NULL; |
| image.imageType = XGL_IMAGE_2D; |
| image.format = m_depth_stencil_fmt; |
| image.extent.width = m_width; |
| image.extent.height = m_height; |
| image.extent.depth = 1; |
| image.mipLevels = 1; |
| image.arraySize = 1; |
| image.samples = 1; |
| image.tiling = XGL_OPTIMAL_TILING; |
| image.usage = XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT; |
| image.flags = 0; |
| |
| img_alloc.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO; |
| img_alloc.pNext = NULL; |
| mem_alloc.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO; |
| mem_alloc.pNext = &img_alloc; |
| mem_alloc.allocationSize = 0; |
| mem_alloc.memProps = XGL_MEMORY_PROPERTY_GPU_ONLY; |
| mem_alloc.memType = XGL_MEMORY_TYPE_IMAGE; |
| mem_alloc.memPriority = XGL_MEMORY_PRIORITY_NORMAL; |
| |
| /* create image */ |
| err = xglCreateImage(device(), &image, |
| &m_depthStencilImage); |
| ASSERT_XGL_SUCCESS(err); |
| |
| err = xglGetObjectInfo(m_depthStencilImage, |
| XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT, |
| &num_alloc_size, &num_allocations); |
| ASSERT_XGL_SUCCESS(err); |
| ASSERT_EQ(num_alloc_size, sizeof(num_allocations)); |
| mem_reqs = (XGL_MEMORY_REQUIREMENTS *) malloc(num_allocations * sizeof(XGL_MEMORY_REQUIREMENTS)); |
| m_depthStencilMem = (XGL_GPU_MEMORY *) malloc(num_allocations * sizeof(XGL_GPU_MEMORY)); |
| m_num_mem = num_allocations; |
| err = xglGetObjectInfo(m_depthStencilImage, |
| XGL_INFO_TYPE_MEMORY_REQUIREMENTS, |
| &mem_reqs_size, mem_reqs); |
| ASSERT_XGL_SUCCESS(err); |
| ASSERT_EQ(mem_reqs_size, sizeof(*mem_reqs)); |
| err = xglGetObjectInfo(m_depthStencilImage, |
| XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS, |
| &img_reqs_size, &img_reqs); |
| ASSERT_XGL_SUCCESS(err); |
| ASSERT_EQ(img_reqs_size, sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS)); |
| img_alloc.usage = img_reqs.usage; |
| img_alloc.formatClass = img_reqs.formatClass; |
| img_alloc.samples = img_reqs.samples; |
| for (uint32_t i = 0; i < num_allocations; i ++) { |
| mem_alloc.allocationSize = mem_reqs[i].size; |
| |
| /* allocate memory */ |
| err = xglAllocMemory(device(), &mem_alloc, &m_depthStencilMem[i]); |
| ASSERT_XGL_SUCCESS(err); |
| |
| /* bind memory */ |
| err = xglBindObjectMemory(m_depthStencilImage, i, |
| m_depthStencilMem[i], 0); |
| ASSERT_XGL_SUCCESS(err); |
| } |
| |
| XGL_DYNAMIC_DS_STATE_CREATE_INFO depthStencil = {}; |
| depthStencil.sType = XGL_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO; |
| |
| depthStencil.minDepth = 0.f; |
| depthStencil.maxDepth = 1.f; |
| depthStencil.stencilBackRef = 0; |
| depthStencil.stencilFrontRef = 0; |
| depthStencil.stencilReadMask = 0xff; |
| depthStencil.stencilWriteMask = 0xff; |
| |
| err = xglCreateDynamicDepthStencilState( device(), &depthStencil, &m_stateDepthStencil ); |
| ASSERT_XGL_SUCCESS( err ); |
| |
| /* create image view */ |
| view.sType = XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO; |
| view.pNext = NULL; |
| view.image = XGL_NULL_HANDLE; |
| view.mipLevel = 0; |
| view.baseArraySlice = 0; |
| view.arraySize = 1; |
| view.flags = 0; |
| view.image = m_depthStencilImage; |
| err = xglCreateDepthStencilView(device(), &view, &m_depthStencilView); |
| ASSERT_XGL_SUCCESS(err); |
| |
| m_depthStencilBinding.view = m_depthStencilView; |
| m_depthStencilBinding.layout = XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; |
| } |
| |
| struct xgltriangle_vs_uniform { |
| // Must start with MVP |
| float mvp[4][4]; |
| float position[3][4]; |
| float color[3][4]; |
| }; |
| |
| void XglRenderTest::XGLTriangleTest(const char *vertShaderText, const char *fragShaderText, const bool rotate) |
| { |
| #ifdef DEBUG_CALLBACK |
| xglDbgRegisterMsgCallback(inst, myDbgFunc, NULL); |
| #endif |
| // Create identity matrix |
| int i; |
| struct xgltriangle_vs_uniform data; |
| |
| glm::mat4 Projection = glm::mat4(1.0f); |
| glm::mat4 View = glm::mat4(1.0f); |
| glm::mat4 Model = glm::mat4(1.0f); |
| glm::mat4 MVP = Projection * View * Model; |
| const int matrixSize = sizeof(MVP); |
| const int bufSize = sizeof(xgltriangle_vs_uniform) / sizeof(float); |
| memcpy(&data.mvp, &MVP[0][0], matrixSize); |
| |
| static const Vertex tri_data[] = |
| { |
| { XYZ1( -1, -1, 0 ), XYZ1( 1.f, 0.f, 0.f ) }, |
| { XYZ1( 1, -1, 0 ), XYZ1( 0.f, 1.f, 0.f ) }, |
| { XYZ1( 0, 1, 0 ), XYZ1( 0.f, 0.f, 1.f ) }, |
| }; |
| |
| for (i=0; i<3; i++) { |
| data.position[i][0] = tri_data[i].posX; |
| data.position[i][1] = tri_data[i].posY; |
| data.position[i][2] = tri_data[i].posZ; |
| data.position[i][3] = tri_data[i].posW; |
| data.color[i][0] = tri_data[i].r; |
| data.color[i][1] = tri_data[i].g; |
| data.color[i][2] = tri_data[i].b; |
| data.color[i][3] = tri_data[i].a; |
| } |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglConstantBufferObj constantBuffer(m_device, bufSize*2, sizeof(float), (const void*) &data); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &constantBuffer); |
| m_memoryRefManager.AddMemoryRef(&constantBuffer); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| |
| // render triangle |
| cmdBuffer.Draw(0, 3, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| |
| if (rotate) |
| RotateTriangleVSUniform(Projection, View, Model, &constantBuffer, &cmdBuffer); |
| |
| #ifdef PRINT_OBJECTS |
| //uint64_t objTrackGetObjectCount(XGL_OBJECT_TYPE type) |
| OBJ_TRACK_GET_OBJECT_COUNT pObjTrackGetObjectCount = (OBJ_TRACK_GET_OBJECT_COUNT)xglGetProcAddr(gpu(), (char*)"objTrackGetObjectCount"); |
| uint64_t numObjects = pObjTrackGetObjectCount(XGL_OBJECT_TYPE_ANY); |
| //OBJ_TRACK_GET_OBJECTS pGetObjsFunc = xglGetProcAddr(gpu(), (char*)"objTrackGetObjects"); |
| printf("DEBUG : Number of Objects : %lu\n", numObjects); |
| OBJ_TRACK_GET_OBJECTS pObjTrackGetObjs = (OBJ_TRACK_GET_OBJECTS)xglGetProcAddr(gpu(), (char*)"objTrackGetObjects"); |
| OBJTRACK_NODE* pObjNodeArray = (OBJTRACK_NODE*)malloc(sizeof(OBJTRACK_NODE)*numObjects); |
| pObjTrackGetObjs(XGL_OBJECT_TYPE_ANY, numObjects, pObjNodeArray); |
| for (i=0; i < numObjects; i++) { |
| printf("Object %i of type %s has objID (%p) and %lu uses\n", i, string_XGL_OBJECT_TYPE(pObjNodeArray[i].objType), pObjNodeArray[i].pObj, pObjNodeArray[i].numUses); |
| } |
| free(pObjNodeArray); |
| #endif |
| |
| } |
| |
| TEST_F(XglRenderTest, XGLTriangle_FragColor) |
| { |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "\n" |
| "layout(binding = 0) uniform buf {\n" |
| " mat4 MVP;\n" |
| " vec4 position[3];\n" |
| " vec4 color[3];\n" |
| "} ubuf;\n" |
| "\n" |
| "layout (location = 0) out vec4 outColor;\n" |
| "\n" |
| "void main() \n" |
| "{\n" |
| " outColor = ubuf.color[gl_VertexID];\n" |
| " gl_Position = ubuf.MVP * ubuf.position[gl_VertexID];\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "\n" |
| "layout (location = 0) in vec4 inColor;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_FragColor = inColor;\n" |
| "}\n"; |
| |
| TEST_DESCRIPTION("XGL-style shaders where fragment shader outputs to GLSL built-in gl_FragColor"); |
| XGLTriangleTest(vertShaderText, fragShaderText, true); |
| } |
| |
| TEST_F(XglRenderTest, XGLTriangle_OutputLocation) |
| { |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "\n" |
| "layout(binding = 0) uniform buf {\n" |
| " mat4 MVP;\n" |
| " vec4 position[3];\n" |
| " vec4 color[3];\n" |
| "} ubuf;\n" |
| "\n" |
| "layout (location = 0) out vec4 outColor;\n" |
| "\n" |
| "void main() \n" |
| "{\n" |
| " outColor = ubuf.color[gl_VertexID];\n" |
| " gl_Position = ubuf.MVP * ubuf.position[gl_VertexID];\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "\n" |
| "layout (location = 0) in vec4 inColor;\n" |
| "layout (location = 0) out vec4 outColor;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " outColor = inColor;\n" |
| "}\n"; |
| |
| TEST_DESCRIPTION("XGL-style shaders where fragment shader outputs to output location 0, which should be the same as gl_FragColor"); |
| |
| XGLTriangleTest(vertShaderText, fragShaderText, true); |
| } |
| #ifndef _WIN32 // Implicit (for now at least) in WIN32 is that we are using the Nvidia driver and it won't consume SPIRV yet |
| TEST_F(XglRenderTest, SPV_XGLTriangle) |
| { |
| bool saved_use_spv = XglTestFramework::m_use_spv; |
| |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "\n" |
| "layout(binding = 0) uniform buf {\n" |
| " mat4 MVP;\n" |
| " vec4 position[3];\n" |
| " vec4 color[3];\n" |
| "} ubuf;\n" |
| "\n" |
| "layout (location = 0) out vec4 outColor;\n" |
| "\n" |
| "void main() \n" |
| "{\n" |
| " outColor = ubuf.color[gl_VertexID];\n" |
| " gl_Position = ubuf.MVP * ubuf.position[gl_VertexID];\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "\n" |
| "layout (location = 0) in vec4 inColor;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " gl_FragColor = inColor;\n" |
| "}\n"; |
| |
| TEST_DESCRIPTION("XGL-style shaders, but force test framework to compile shader to SPV and pass SPV to driver."); |
| |
| XglTestFramework::m_use_spv = true; |
| |
| XGLTriangleTest(vertShaderText, fragShaderText, true); |
| |
| XglTestFramework::m_use_spv = saved_use_spv; |
| } |
| #endif |
| TEST_F(XglRenderTest, GreenTriangle) |
| { |
| static const char *vertShaderText = |
| "#version 130\n" |
| "vec2 vertices[3];\n" |
| "void main() {\n" |
| " vertices[0] = vec2(-1.0, -1.0);\n" |
| " vertices[1] = vec2( 1.0, -1.0);\n" |
| " vertices[2] = vec2( 0.0, 1.0);\n" |
| " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 130\n" |
| "void main() {\n" |
| " gl_FragColor = vec4(0,1,0,1);\n" |
| "}\n"; |
| |
| TEST_DESCRIPTION("Basic shader that renders a fixed Green triangle coded as part of the vertex shader."); |
| |
| XGLTriangleTest(vertShaderText, fragShaderText, false); |
| } |
| #ifndef _WIN32 // Implicit (for now at least) in WIN32 is that we are using the Nvidia driver and it won't consume SPIRV yet |
| TEST_F(XglRenderTest, SPV_GreenTriangle) |
| { |
| bool saved_use_spv = XglTestFramework::m_use_spv; |
| |
| static const char *vertShaderText = |
| "#version 130\n" |
| "vec2 vertices[3];\n" |
| "void main() {\n" |
| " vertices[0] = vec2(-1.0, -1.0);\n" |
| " vertices[1] = vec2( 1.0, -1.0);\n" |
| " vertices[2] = vec2( 0.0, 1.0);\n" |
| " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 130\n" |
| "void main() {\n" |
| " gl_FragColor = vec4(0,1,0,1);\n" |
| "}\n"; |
| |
| TEST_DESCRIPTION("Same shader as GreenTriangle, but compiles shader to SPV and gives SPV to driver."); |
| |
| XglTestFramework::m_use_spv = true; |
| XGLTriangleTest(vertShaderText, fragShaderText, false); |
| XglTestFramework::m_use_spv = saved_use_spv; |
| } |
| #endif |
| TEST_F(XglRenderTest, YellowTriangle) |
| { |
| static const char *vertShaderText = |
| "#version 130\n" |
| "void main() {\n" |
| " vec2 vertices[3];" |
| " vertices[0] = vec2(-0.5, -0.5);\n" |
| " vertices[1] = vec2( 0.5, -0.5);\n" |
| " vertices[2] = vec2( 0.5, 0.5);\n" |
| " vec4 colors[3];\n" |
| " colors[0] = vec4(1.0, 0.0, 0.0, 1.0);\n" |
| " colors[1] = vec4(0.0, 1.0, 0.0, 1.0);\n" |
| " colors[2] = vec4(0.0, 0.0, 1.0, 1.0);\n" |
| " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 130\n" |
| "void main() {\n" |
| " gl_FragColor = vec4(1.0, 1.0, 0.0, 1.0);\n" |
| "}\n"; |
| |
| XGLTriangleTest(vertShaderText, fragShaderText, false); |
| } |
| |
| TEST_F(XglRenderTest, TriangleWithVertexFetch) |
| { |
| static const char *vertShaderText = |
| "#version 130\n" |
| //XYZ1( -1, -1, -1 ) |
| "in vec4 pos;\n" |
| //XYZ1( 0.f, 0.f, 0.f ) |
| "in vec4 inColor;\n" |
| "out vec4 outColor;\n" |
| "void main() {\n" |
| " outColor = inColor;\n" |
| " gl_Position = pos;\n" |
| "}\n"; |
| |
| |
| static const char *fragShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "in vec4 color;\n" |
| "layout (location = 0) out vec4 outColor;\n" |
| "void main() {\n" |
| " outColor = color;\n" |
| "}\n"; |
| |
| |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData); |
| meshBuffer.BufferMemoryBarrier(); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer); |
| |
| m_memoryRefManager.AddMemoryRef(&meshBuffer); |
| |
| XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = { |
| sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement) |
| XGL_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented |
| }; |
| |
| XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; |
| vi_attribs[0].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex |
| vi_attribs[1].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex |
| |
| pipelineobj.AddVertexInputAttribs(vi_attribs,2); |
| pipelineobj.AddVertexInputBindings(&vi_binding,1); |
| pipelineobj.AddVertexDataBuffer(&meshBuffer,0); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0); |
| |
| // render two triangles |
| cmdBuffer.Draw(0, 6, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| } |
| |
| TEST_F(XglRenderTest, TriangleMRT) |
| { |
| static const char *vertShaderText = |
| "#version 130\n" |
| "in vec4 pos;\n" |
| "void main() {\n" |
| " gl_Position = pos;\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 130\n" |
| "void main() {\n" |
| " gl_FragData[0] = vec4(1.0, 0.0, 0.0, 1.0);\n" |
| " gl_FragData[1] = vec4(0.0, 1.0, 0.0, 1.0);\n" |
| "}\n"; |
| const float vb_data[][2] = { |
| { -1.0f, -1.0f }, |
| { 1.0f, -1.0f }, |
| { -1.0f, 1.0f } |
| }; |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglConstantBufferObj meshBuffer(m_device, sizeof(vb_data) / sizeof(vb_data[0]), sizeof(vb_data[0]), vb_data); |
| meshBuffer.BufferMemoryBarrier(); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = { |
| sizeof(vb_data[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement) |
| XGL_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented |
| }; |
| |
| XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attrib; |
| vi_attrib.binding = 0; // index into vertexBindingDescriptions |
| vi_attrib.format = XGL_FMT_R32G32_SFLOAT; // format of source data |
| vi_attrib.offsetInBytes = 0; // Offset of first element in bytes from base of vertex |
| |
| pipelineobj.AddVertexInputAttribs(&vi_attrib, 1); |
| pipelineobj.AddVertexInputBindings(&vi_binding,1); |
| pipelineobj.AddVertexDataBuffer(&meshBuffer,0); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget(2)); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| m_memoryRefManager.AddMemoryRef(&meshBuffer); |
| |
| XGL_PIPELINE_CB_ATTACHMENT_STATE att = {}; |
| att.blendEnable = XGL_FALSE; |
| att.format = m_render_target_fmt; |
| att.channelWriteMask = 0xf; |
| pipelineobj.AddColorAttachment(1, &att); |
| |
| XglCommandBufferObj cmdBuffer(m_device); |
| |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| cmdBuffer.AddRenderTarget(m_renderTargets[1]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0); |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| |
| // render triangle |
| cmdBuffer.Draw(0, 3, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| |
| } |
| |
| TEST_F(XglRenderTest, QuadWithIndexedVertexFetch) |
| { |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout(location = 0) in vec4 pos;\n" |
| "layout(location = 1) in vec4 inColor;\n" |
| "layout(location = 0) out vec4 outColor;\n" |
| "void main() {\n" |
| " outColor = inColor;\n" |
| " gl_Position = pos;\n" |
| "}\n"; |
| |
| |
| static const char *fragShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout(location = 0) in vec4 color;\n" |
| "void main() {\n" |
| " gl_FragColor = color;\n" |
| "}\n"; |
| |
| const Vertex g_vbData[] = |
| { |
| // first tri |
| { XYZ1( -1, -1, -1 ), XYZ1( 0.f, 0.f, 0.f ) }, // LL: black |
| { XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) }, // LR: red |
| { XYZ1( -1, 1, -1 ), XYZ1( 0.f, 1.f, 0.f ) }, // UL: green |
| |
| // second tri |
| { XYZ1( -1, 1, -1 ), XYZ1( 0.f, 1.f, 0.f ) }, // UL: green |
| { XYZ1( 1, -1, -1 ), XYZ1( 1.f, 0.f, 0.f ) }, // LR: red |
| { XYZ1( 1, 1, -1 ), XYZ1( 1.f, 1.f, 0.f ) }, // UR: yellow |
| }; |
| |
| const uint16_t g_idxData[6] = { |
| 0, 1, 2, |
| 3, 4, 5, |
| }; |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData); |
| meshBuffer.BufferMemoryBarrier(); |
| |
| XglIndexBufferObj indexBuffer(m_device); |
| indexBuffer.CreateAndInitBuffer(sizeof(g_idxData)/sizeof(g_idxData[0]), XGL_INDEX_16, g_idxData); |
| indexBuffer.BufferMemoryBarrier(); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &indexBuffer); |
| |
| |
| m_memoryRefManager.AddMemoryRef(&meshBuffer); |
| m_memoryRefManager.AddMemoryRef(&indexBuffer); |
| |
| XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = { |
| sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement) |
| XGL_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented |
| }; |
| |
| XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; |
| vi_attribs[0].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex |
| vi_attribs[1].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex |
| |
| pipelineobj.AddVertexInputAttribs(vi_attribs,2); |
| pipelineobj.AddVertexInputBindings(&vi_binding,1); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| |
| cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0); |
| cmdBuffer.BindIndexBuffer(&indexBuffer,0); |
| |
| // render two triangles |
| cmdBuffer.DrawIndexed(0, 6, 0, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| |
| } |
| |
| TEST_F(XglRenderTest, GreyandRedCirclesonBlue) |
| { |
| // This tests gl_FragCoord |
| |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (location = 0) in vec4 pos;\n" |
| "layout (location = 0) out vec4 outColor;\n" |
| "layout (location = 1) out vec4 outColor2;\n" |
| "void main() {\n" |
| " gl_Position = pos;\n" |
| " outColor = vec4(0.9, 0.9, 0.9, 1.0);\n" |
| " outColor2 = vec4(0.2, 0.2, 0.4, 1.0);\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| //"#version 140\n" |
| "#version 330\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| //"#extension GL_ARB_fragment_coord_conventions : enable\n" |
| //"layout (pixel_center_integer) in vec4 gl_FragCoord;\n" |
| "layout (location = 0) in vec4 color;\n" |
| "layout (location = 1) in vec4 color2;\n" |
| "void main() {\n" |
| " vec2 pos = mod(gl_FragCoord.xy, vec2(50.0)) - vec2(25.0);\n" |
| " float dist_squared = dot(pos, pos);\n" |
| " gl_FragColor = (dist_squared < 400.0)\n" |
| " ? ((gl_FragCoord.y < 100.0) ? vec4(1.0, 0.0, 0.0, 0.0) : color)\n" |
| " : color2;\n" |
| "}\n"; |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData); |
| meshBuffer.BufferMemoryBarrier(); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer); |
| |
| m_memoryRefManager.AddMemoryRef(&meshBuffer); |
| |
| XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = { |
| sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement) |
| XGL_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented |
| }; |
| |
| XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; |
| vi_attribs[0].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex |
| vi_attribs[1].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex |
| |
| pipelineobj.AddVertexInputAttribs(vi_attribs,2); |
| pipelineobj.AddVertexInputBindings(&vi_binding,1); |
| pipelineobj.AddVertexDataBuffer(&meshBuffer,0); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0); |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| |
| // render triangle |
| cmdBuffer.Draw(0, 6, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| |
| } |
| |
| TEST_F(XglRenderTest, RedCirclesonBlue) |
| { |
| // This tests that we correctly handle unread fragment inputs |
| |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (location = 0) in vec4 pos;\n" |
| "layout (location = 0) out vec4 outColor;\n" |
| "layout (location = 1) out vec4 outColor2;\n" |
| "void main() {\n" |
| " gl_Position = pos;\n" |
| " outColor = vec4(0.9, 0.9, 0.9, 1.0);\n" |
| " outColor2 = vec4(0.2, 0.2, 0.4, 1.0);\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| //"#version 140\n" |
| "#version 330\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| //"#extension GL_ARB_fragment_coord_conventions : enable\n" |
| //"layout (pixel_center_integer) in vec4 gl_FragCoord;\n" |
| "layout (location = 0) in vec4 color;\n" |
| "layout (location = 1) in vec4 color2;\n" |
| "void main() {\n" |
| " vec2 pos = mod(gl_FragCoord.xy, vec2(50.0)) - vec2(25.0);\n" |
| " float dist_squared = dot(pos, pos);\n" |
| " gl_FragColor = (dist_squared < 400.0)\n" |
| " ? vec4(1.0, 0.0, 0.0, 1.0)\n" |
| " : color2;\n" |
| "}\n"; |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData); |
| meshBuffer.BufferMemoryBarrier(); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer); |
| |
| m_memoryRefManager.AddMemoryRef(&meshBuffer); |
| |
| XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = { |
| sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement) |
| XGL_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented |
| }; |
| |
| XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; |
| vi_attribs[0].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex |
| vi_attribs[1].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex |
| |
| pipelineobj.AddVertexInputAttribs(vi_attribs,2); |
| pipelineobj.AddVertexInputBindings(&vi_binding,1); |
| pipelineobj.AddVertexDataBuffer(&meshBuffer,0); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0); |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| // render two triangles |
| cmdBuffer.Draw(0, 6, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| |
| } |
| |
| TEST_F(XglRenderTest, GreyCirclesonBlueFade) |
| { |
| // This tests reading gl_ClipDistance from FS |
| |
| static const char *vertShaderText = |
| "#version 330\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "out gl_PerVertex {\n" |
| " vec4 gl_Position;\n" |
| " float gl_ClipDistance[1];\n" |
| "};\n" |
| "layout (location = 0) in vec4 pos;\n" |
| "layout (location = 0) out vec4 outColor;\n" |
| "layout (location = 1) out vec4 outColor2;\n" |
| "void main() {\n" |
| " gl_Position = pos;\n" |
| " outColor = vec4(0.9, 0.9, 0.9, 1.0);\n" |
| " outColor2 = vec4(0.2, 0.2, 0.4, 1.0);\n" |
| " float dists[3];\n" |
| " dists[0] = 0.0;\n" |
| " dists[1] = 1.0;\n" |
| " dists[2] = 1.0;\n" |
| " gl_ClipDistance[0] = dists[gl_VertexID % 3];\n" |
| "}\n"; |
| |
| |
| static const char *fragShaderText = |
| //"#version 140\n" |
| "#version 330\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| //"#extension GL_ARB_fragment_coord_conventions : enable\n" |
| //"layout (pixel_center_integer) in vec4 gl_FragCoord;\n" |
| "layout (location = 0) in vec4 color;\n" |
| "layout (location = 1) in vec4 color2;\n" |
| "void main() {\n" |
| " vec2 pos = mod(gl_FragCoord.xy, vec2(50.0)) - vec2(25.0);\n" |
| " float dist_squared = dot(pos, pos);\n" |
| " gl_FragColor = (dist_squared < 400.0)\n" |
| " ? color * gl_ClipDistance[0]\n" |
| " : color2;\n" |
| "}\n"; |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData); |
| meshBuffer.BufferMemoryBarrier(); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer); |
| |
| m_memoryRefManager.AddMemoryRef(&meshBuffer); |
| |
| XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = { |
| sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement) |
| XGL_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented |
| }; |
| |
| XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; |
| vi_attribs[0].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex |
| vi_attribs[1].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex |
| |
| pipelineobj.AddVertexInputAttribs(vi_attribs,2); |
| pipelineobj.AddVertexInputBindings(&vi_binding,1); |
| pipelineobj.AddVertexDataBuffer(&meshBuffer,0); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0); |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| |
| // render two triangles |
| cmdBuffer.Draw(0, 6, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| } |
| |
| TEST_F(XglRenderTest, GreyCirclesonBlueDiscard) |
| { |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (location = 0) in vec4 pos;\n" |
| "layout (location = 0) out vec4 outColor;\n" |
| "layout (location = 1) out vec4 outColor2;\n" |
| "void main() {\n" |
| " gl_Position = pos;\n" |
| " outColor = vec4(0.9, 0.9, 0.9, 1.0);\n" |
| " outColor2 = vec4(0.2, 0.2, 0.4, 1.0);\n" |
| "}\n"; |
| |
| |
| static const char *fragShaderText = |
| //"#version 140\n" |
| "#version 330\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| //"#extension GL_ARB_fragment_coord_conventions : enable\n" |
| //"layout (pixel_center_integer) in vec4 gl_FragCoord;\n" |
| "layout (location = 0) in vec4 color;\n" |
| "layout (location = 1) in vec4 color2;\n" |
| "void main() {\n" |
| " vec2 pos = mod(gl_FragCoord.xy, vec2(50.0)) - vec2(25.0);\n" |
| " float dist_squared = dot(pos, pos);\n" |
| " if (dist_squared < 100.0)\n" |
| " discard;\n" |
| " gl_FragColor = (dist_squared < 400.0)\n" |
| " ? color\n" |
| " : color2;\n" |
| "}\n"; |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData); |
| meshBuffer.BufferMemoryBarrier(); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer); |
| |
| m_memoryRefManager.AddMemoryRef(&meshBuffer); |
| |
| XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = { |
| sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement) |
| XGL_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented |
| }; |
| |
| XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; |
| vi_attribs[0].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex |
| vi_attribs[1].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex |
| |
| pipelineobj.AddVertexInputAttribs(vi_attribs,2); |
| pipelineobj.AddVertexInputBindings(&vi_binding,1); |
| pipelineobj.AddVertexDataBuffer(&meshBuffer,0); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0); |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| |
| // render two triangles |
| cmdBuffer.Draw(0, 6, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| |
| } |
| |
| |
| TEST_F(XglRenderTest, TriangleVSUniform) |
| { |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "\n" |
| "layout(binding = 0) uniform buf {\n" |
| " mat4 MVP;\n" |
| "} ubuf;\n" |
| "void main() {\n" |
| " vec2 vertices[3];" |
| " vertices[0] = vec2(-0.5, -0.5);\n" |
| " vertices[1] = vec2( 0.5, -0.5);\n" |
| " vertices[2] = vec2( 0.5, 0.5);\n" |
| " gl_Position = ubuf.MVP * vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 130\n" |
| "void main() {\n" |
| " gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);\n" |
| "}\n"; |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| // Create identity matrix |
| glm::mat4 Projection = glm::mat4(1.0f); |
| glm::mat4 View = glm::mat4(1.0f); |
| glm::mat4 Model = glm::mat4(1.0f); |
| glm::mat4 MVP = Projection * View * Model; |
| const int matrixSize = sizeof(MVP) / sizeof(MVP[0]); |
| |
| XglConstantBufferObj MVPBuffer(m_device, matrixSize, sizeof(MVP[0]), (const void*) &MVP[0][0]); |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| // Create descriptor set and attach the constant buffer to it |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &MVPBuffer); |
| |
| m_memoryRefManager.AddMemoryRef(&MVPBuffer); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| // cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0); |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| |
| // render two triangles |
| cmdBuffer.Draw(0, 6, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| |
| RotateTriangleVSUniform(Projection, View, Model, &MVPBuffer, &cmdBuffer); |
| } |
| |
| TEST_F(XglRenderTest, MixTriangle) |
| { |
| // This tests location applied to varyings. Notice that we have switched foo |
| // and bar in the FS. The triangle should be blended with red, green and blue |
| // corners. |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (location=0) out vec4 bar;\n" |
| "layout (location=1) out vec4 foo;\n" |
| "layout (location=2) out float scale;\n" |
| "vec2 vertices[3];\n" |
| "void main() {\n" |
| " vertices[0] = vec2(-1.0, -1.0);\n" |
| " vertices[1] = vec2( 1.0, -1.0);\n" |
| " vertices[2] = vec2( 0.0, 1.0);\n" |
| "vec4 colors[3];\n" |
| " colors[0] = vec4(1.0, 0.0, 0.0, 1.0);\n" |
| " colors[1] = vec4(0.0, 1.0, 0.0, 1.0);\n" |
| " colors[2] = vec4(0.0, 0.0, 1.0, 1.0);\n" |
| " foo = colors[gl_VertexID % 3];\n" |
| " bar = vec4(1.0, 1.0, 1.0, 1.0);\n" |
| " scale = 1.0;\n" |
| " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (location = 1) in vec4 bar;\n" |
| "layout (location = 0) in vec4 foo;\n" |
| "layout (location = 2) in float scale;\n" |
| "void main() {\n" |
| " gl_FragColor = bar * scale + foo * (1.0-scale);\n" |
| "}\n"; |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendDummy(); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| |
| // render triangle |
| cmdBuffer.Draw(0, 3, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| } |
| |
| TEST_F(XglRenderTest, TriVertFetchAndVertID) |
| { |
| // This tests that attributes work in the presence of gl_VertexID |
| |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| //XYZ1( -1, -1, -1 ) |
| "layout (location = 0) in vec4 pos;\n" |
| //XYZ1( 0.f, 0.f, 0.f ) |
| "layout (location = 1) in vec4 inColor;\n" |
| "layout (location = 0) out vec4 outColor;\n" |
| "void main() {\n" |
| " outColor = inColor;\n" |
| " vec4 vertices[3];" |
| " vertices[gl_VertexID % 3] = pos;\n" |
| " gl_Position = vertices[(gl_VertexID + 3) % 3];\n" |
| "}\n"; |
| |
| |
| static const char *fragShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (location = 0) in vec4 color;\n" |
| "void main() {\n" |
| " gl_FragColor = color;\n" |
| "}\n"; |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData); |
| meshBuffer.BufferMemoryBarrier(); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer); |
| |
| m_memoryRefManager.AddMemoryRef(&meshBuffer); |
| |
| XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = { |
| sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement) |
| XGL_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented |
| }; |
| |
| XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; |
| vi_attribs[0].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex |
| vi_attribs[1].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex |
| |
| pipelineobj.AddVertexInputAttribs(vi_attribs,2); |
| pipelineobj.AddVertexInputBindings(&vi_binding,1); |
| pipelineobj.AddVertexDataBuffer(&meshBuffer,0); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0); |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| |
| // render two triangles |
| cmdBuffer.Draw(0, 6, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| } |
| |
| TEST_F(XglRenderTest, TriVertFetchDeadAttr) |
| { |
| // This tests that attributes work in the presence of gl_VertexID |
| // and a dead attribute in position 0. Draws a triangle with yellow, |
| // red and green corners, starting at top and going clockwise. |
| |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| //XYZ1( -1, -1, -1 ) |
| "layout (location = 0) in vec4 pos;\n" |
| //XYZ1( 0.f, 0.f, 0.f ) |
| "layout (location = 1) in vec4 inColor;\n" |
| "layout (location = 0) out vec4 outColor;\n" |
| "void main() {\n" |
| " outColor = inColor;\n" |
| " vec2 vertices[3];" |
| " vertices[0] = vec2(-1.0, -1.0);\n" |
| " vertices[1] = vec2( 1.0, -1.0);\n" |
| " vertices[2] = vec2( 0.0, 1.0);\n" |
| " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n" |
| "}\n"; |
| |
| |
| static const char *fragShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (location = 0) in vec4 color;\n" |
| "void main() {\n" |
| " gl_FragColor = color;\n" |
| "}\n"; |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglConstantBufferObj meshBuffer(m_device,sizeof(g_vbData)/sizeof(g_vbData[0]),sizeof(g_vbData[0]), g_vbData); |
| meshBuffer.BufferMemoryBarrier(); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer); |
| |
| m_memoryRefManager.AddMemoryRef(&meshBuffer); |
| |
| XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = { |
| sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement) |
| XGL_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented |
| }; |
| |
| XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; |
| vi_attribs[0].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex |
| vi_attribs[1].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex |
| |
| pipelineobj.AddVertexInputAttribs(vi_attribs,2); |
| pipelineobj.AddVertexInputBindings(&vi_binding,1); |
| pipelineobj.AddVertexDataBuffer(&meshBuffer,0); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0); |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| |
| // render two triangles |
| cmdBuffer.Draw(0, 6, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| } |
| |
| TEST_F(XglRenderTest, CubeWithVertexFetchAndMVP) |
| { |
| static const char *vertShaderText = |
| "#version 140\n" |
| "layout (std140) uniform bufferVals {\n" |
| " mat4 mvp;\n" |
| "} myBufferVals;\n" |
| "in vec4 pos;\n" |
| "in vec4 inColor;\n" |
| "out vec4 outColor;\n" |
| "void main() {\n" |
| " outColor = inColor;\n" |
| " gl_Position = myBufferVals.mvp * pos;\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 130\n" |
| "in vec4 color;\n" |
| "void main() {\n" |
| " gl_FragColor = color;\n" |
| "}\n"; |
| glm::mat4 Projection = glm::perspective(glm::radians(45.0f), 1.0f, 0.1f, 100.0f); |
| |
| glm::mat4 View = glm::lookAt( |
| glm::vec3(0,3,10), // Camera is at (0,3,10), in World Space |
| glm::vec3(0,0,0), // and looks at the origin |
| glm::vec3(0,1,0) // Head is up (set to 0,-1,0 to look upside-down) |
| ); |
| |
| glm::mat4 Model = glm::mat4(1.0f); |
| |
| glm::mat4 MVP = Projection * View * Model; |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| ASSERT_NO_FATAL_FAILURE(InitDepthStencil()); |
| |
| XglConstantBufferObj meshBuffer(m_device,sizeof(g_vb_solid_face_colors_Data)/sizeof(g_vb_solid_face_colors_Data[0]), |
| sizeof(g_vb_solid_face_colors_Data[0]), g_vb_solid_face_colors_Data); |
| |
| const int buf_size = sizeof(MVP) / sizeof(float); |
| |
| XglConstantBufferObj MVPBuffer(m_device, buf_size, sizeof(MVP[0]), (const void*) &MVP[0][0]); |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XGL_PIPELINE_DS_STATE_CREATE_INFO ds_state; |
| ds_state.depthTestEnable = XGL_TRUE; |
| ds_state.depthWriteEnable = XGL_TRUE; |
| ds_state.depthFunc = XGL_COMPARE_LESS_EQUAL; |
| ds_state.depthBoundsEnable = XGL_FALSE; |
| ds_state.stencilTestEnable = XGL_FALSE; |
| ds_state.back.stencilDepthFailOp = XGL_STENCIL_OP_KEEP; |
| ds_state.back.stencilFailOp = XGL_STENCIL_OP_KEEP; |
| ds_state.back.stencilPassOp = XGL_STENCIL_OP_KEEP; |
| ds_state.back.stencilFunc = XGL_COMPARE_ALWAYS; |
| ds_state.format = XGL_FMT_D32_SFLOAT; |
| ds_state.front = ds_state.back; |
| pipelineobj.SetDepthStencil(&ds_state); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &MVPBuffer); |
| |
| m_memoryRefManager.AddMemoryRef(&meshBuffer); |
| m_memoryRefManager.AddMemoryRef(&MVPBuffer); |
| m_memoryRefManager.AddMemoryRef(m_depthStencilMem, m_num_mem); |
| |
| XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = { |
| sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement) |
| XGL_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented |
| }; |
| |
| // this is the current description of g_vbData |
| XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; |
| vi_attribs[0].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex |
| vi_attribs[1].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex |
| |
| pipelineobj.AddVertexInputBindings(&vi_binding,1); |
| pipelineobj.AddVertexInputAttribs(vi_attribs,2); |
| pipelineobj.AddVertexDataBuffer(&meshBuffer,0); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0); |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| |
| // render triangles |
| cmdBuffer.Draw(0, 36, 0, 1); |
| |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| } |
| |
| TEST_F(XglRenderTest, VSTexture) |
| { |
| // The expected result from this test is a green and red triangle; |
| // one red vertex on the left, two green vertices on the right. |
| static const char *vertShaderText = |
| "#version 130\n" |
| "out vec4 texColor;\n" |
| "uniform sampler2D surface;\n" |
| "void main() {\n" |
| " vec2 vertices[3];" |
| " vertices[0] = vec2(-0.5, -0.5);\n" |
| " vertices[1] = vec2( 0.5, -0.5);\n" |
| " vertices[2] = vec2( 0.5, 0.5);\n" |
| " vec2 positions[3];" |
| " positions[0] = vec2( 0.0, 0.0);\n" |
| " positions[1] = vec2( 0.25, 0.1);\n" |
| " positions[2] = vec2( 0.1, 0.25);\n" |
| " vec2 samplePos = positions[gl_VertexID % 3];\n" |
| " texColor = textureLod(surface, samplePos, 0.0);\n" |
| " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 130\n" |
| "in vec4 texColor;\n" |
| "void main() {\n" |
| " gl_FragColor = texColor;\n" |
| "}\n"; |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| XglSamplerObj sampler(m_device); |
| XglTextureObj texture(m_device); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendSamplerTexture(&sampler, &texture); |
| |
| m_memoryRefManager.AddMemoryRef(&texture); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| |
| // render triangle |
| cmdBuffer.Draw(0, 3, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| } |
| TEST_F(XglRenderTest, TexturedTriangle) |
| { |
| // The expected result from this test is a red and green checkered triangle |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (location = 0) out vec2 samplePos;\n" |
| "void main() {\n" |
| " vec2 vertices[3];" |
| " vertices[0] = vec2(-0.5, -0.5);\n" |
| " vertices[1] = vec2( 0.5, -0.5);\n" |
| " vertices[2] = vec2( 0.5, 0.5);\n" |
| " vec2 positions[3];" |
| " positions[0] = vec2( 0.0, 0.0);\n" |
| " positions[1] = vec2( 1.0, 0.0);\n" |
| " positions[2] = vec2( 1.0, 1.0);\n" |
| " samplePos = positions[gl_VertexID % 3];\n" |
| " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (location = 0) in vec2 samplePos;\n" |
| "layout (binding = 0) uniform sampler2D surface;\n" |
| "layout (location=0) out vec4 outColor;\n" |
| "void main() {\n" |
| " vec4 texColor = textureLod(surface, samplePos, 0.0);\n" |
| " outColor = texColor;\n" |
| "}\n"; |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| XglSamplerObj sampler(m_device); |
| XglTextureObj texture(m_device); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendSamplerTexture(&sampler, &texture); |
| |
| m_memoryRefManager.AddMemoryRef(&texture); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| // render triangle |
| cmdBuffer.Draw(0, 3, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| } |
| TEST_F(XglRenderTest, TexturedTriangleClip) |
| { |
| // The expected result from this test is a red and green checkered triangle |
| static const char *vertShaderText = |
| "#version 330\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (location = 0) out vec2 samplePos;\n" |
| "out gl_PerVertex {\n" |
| " vec4 gl_Position;\n" |
| " float gl_ClipDistance[1];\n" |
| "};\n" |
| "void main() {\n" |
| " vec2 vertices[3];" |
| " vertices[0] = vec2(-0.5, -0.5);\n" |
| " vertices[1] = vec2( 0.5, -0.5);\n" |
| " vertices[2] = vec2( 0.5, 0.5);\n" |
| " vec2 positions[3];" |
| " positions[0] = vec2( 0.0, 0.0);\n" |
| " positions[1] = vec2( 1.0, 0.0);\n" |
| " positions[2] = vec2( 1.0, 1.0);\n" |
| " float dists[3];\n" |
| " dists[0] = 1.0;\n" |
| " dists[1] = 1.0;\n" |
| " dists[2] = -1.0;\n" |
| " gl_ClipDistance[0] = dists[gl_VertexID % 3];\n" |
| " samplePos = positions[gl_VertexID % 3];\n" |
| " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (location = 0) in vec2 samplePos;\n" |
| "layout (binding = 0) uniform sampler2D surface;\n" |
| "layout (location=0) out vec4 outColor;\n" |
| "void main() {\n" |
| //" vec4 texColor = textureLod(surface, samplePos, 0.0 + gl_ClipDistance[0]);\n" |
| " vec4 texColor = textureLod(surface, samplePos, 0.0);\n" |
| " outColor = texColor;\n" |
| "}\n"; |
| |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| XglSamplerObj sampler(m_device); |
| XglTextureObj texture(m_device); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendSamplerTexture(&sampler, &texture); |
| |
| m_memoryRefManager.AddMemoryRef(&texture); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| // render triangle |
| cmdBuffer.Draw(0, 3, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| } |
| TEST_F(XglRenderTest, FSTriangle) |
| { |
| // The expected result from this test is a red and green checkered triangle |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (location = 0) out vec2 samplePos;\n" |
| "void main() {\n" |
| " vec2 vertices[3];" |
| " vertices[0] = vec2(-0.5, -0.5);\n" |
| " vertices[1] = vec2( 0.5, -0.5);\n" |
| " vertices[2] = vec2( 0.5, 0.5);\n" |
| " vec2 positions[3];" |
| " positions[0] = vec2( 0.0, 0.0);\n" |
| " positions[1] = vec2( 1.0, 0.0);\n" |
| " positions[2] = vec2( 1.0, 1.0);\n" |
| " samplePos = positions[gl_VertexID % 3];\n" |
| " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (location = 0) in vec2 samplePos;\n" |
| "layout (binding = 0) uniform sampler2D surface;\n" |
| "layout (location=0) out vec4 outColor;\n" |
| "void main() {\n" |
| " vec4 texColor = textureLod(surface, samplePos, 0.0);\n" |
| " outColor = texColor;\n" |
| "}\n"; |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| XglSamplerObj sampler(m_device); |
| XglTextureObj texture(m_device); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendSamplerTexture(&sampler, &texture); |
| |
| m_memoryRefManager.AddMemoryRef(&texture); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| // render triangle |
| cmdBuffer.Draw(0, 3, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| } |
| TEST_F(XglRenderTest, SamplerBindingsTriangle) |
| { |
| // This test sets bindings on the samplers |
| // For now we are asserting that sampler and texture pairs |
| // march in lock step, and are set via GLSL binding. This can |
| // and will probably change. |
| // The sampler bindings should match the sampler and texture slot |
| // number set up by the application. |
| // This test will result in a blue triangle |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (location = 0) out vec4 samplePos;\n" |
| "void main() {\n" |
| " vec2 vertices[3];" |
| " vertices[0] = vec2(-0.5, -0.5);\n" |
| " vertices[1] = vec2( 0.5, -0.5);\n" |
| " vertices[2] = vec2( 0.5, 0.5);\n" |
| " vec2 positions[3];" |
| " positions[0] = vec2( 0.0, 0.0);\n" |
| " positions[1] = vec2( 1.0, 0.0);\n" |
| " positions[2] = vec2( 1.0, 1.0);\n" |
| " samplePos = vec4(positions[gl_VertexID % 3], 0.0, 0.0);\n" |
| " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (location = 0) in vec4 samplePos;\n" |
| "layout (binding = 0) uniform sampler2D surface0;\n" |
| "layout (binding = 1) uniform sampler2D surface1;\n" |
| "layout (binding = 12) uniform sampler2D surface2;\n" |
| "void main() {\n" |
| " gl_FragColor = textureLod(surface2, samplePos.xy, 0.0);\n" |
| "}\n"; |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| XglSamplerObj sampler1(m_device); |
| XglSamplerObj sampler2(m_device); |
| XglSamplerObj sampler3(m_device); |
| |
| uint32_t tex_colors[2] = { 0xffff0000, 0xffff0000 }; |
| XglTextureObj texture1(m_device, tex_colors); // Red |
| tex_colors[0] = 0xff00ff00; tex_colors[1] = 0xff00ff00; |
| XglTextureObj texture2(m_device, tex_colors); // Green |
| tex_colors[0] = 0xff0000ff; tex_colors[1] = 0xff0000ff; |
| XglTextureObj texture3(m_device, tex_colors); // Blue |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendSamplerTexture(&sampler1, &texture1); |
| descriptorSet.AppendSamplerTexture(&sampler2, &texture2); |
| for (int i = 0; i < 10; i++) |
| descriptorSet.AppendDummy(); |
| descriptorSet.AppendSamplerTexture(&sampler3, &texture3); |
| |
| m_memoryRefManager.AddMemoryRef(&texture1); |
| m_memoryRefManager.AddMemoryRef(&texture2); |
| m_memoryRefManager.AddMemoryRef(&texture3); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| // render triangle |
| cmdBuffer.Draw(0, 3, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| |
| } |
| |
| TEST_F(XglRenderTest, TriangleVSUniformBlock) |
| { |
| // The expected result from this test is a blue triangle |
| |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (location = 0) out vec4 outColor;\n" |
| "layout (std140, binding = 0) uniform bufferVals {\n" |
| " vec4 red;\n" |
| " vec4 green;\n" |
| " vec4 blue;\n" |
| " vec4 white;\n" |
| "} myBufferVals;\n" |
| "void main() {\n" |
| " vec2 vertices[3];" |
| " vertices[0] = vec2(-0.5, -0.5);\n" |
| " vertices[1] = vec2( 0.5, -0.5);\n" |
| " vertices[2] = vec2( 0.5, 0.5);\n" |
| " outColor = myBufferVals.blue;\n" |
| " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (location = 0) in vec4 inColor;\n" |
| "void main() {\n" |
| " gl_FragColor = inColor;\n" |
| "}\n"; |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| // Let's populate our buffer with the following: |
| // vec4 red; |
| // vec4 green; |
| // vec4 blue; |
| // vec4 white; |
| const int valCount = 4 * 4; |
| const float bufferVals[valCount] = { 1.0, 0.0, 0.0, 1.0, |
| 0.0, 1.0, 0.0, 1.0, |
| 0.0, 0.0, 1.0, 1.0, |
| 1.0, 1.0, 1.0, 1.0 }; |
| |
| XglConstantBufferObj colorBuffer(m_device, valCount, sizeof(bufferVals[0]), (const void*) bufferVals); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &colorBuffer); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| // render triangle |
| cmdBuffer.Draw(0, 3, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| |
| } |
| |
| TEST_F(XglRenderTest, TriangleFSUniformBlockBinding) |
| { |
| // This test allows the shader to select which buffer it is |
| // pulling from using layout binding qualifier. |
| // There are corresponding changes in the compiler stack that |
| // will select the buffer using binding directly. |
| // The binding number should match the slot number set up by |
| // the application. |
| // The expected result from this test is a purple triangle |
| |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "void main() {\n" |
| " vec2 vertices[3];" |
| " vertices[0] = vec2(-0.5, -0.5);\n" |
| " vertices[1] = vec2( 0.5, -0.5);\n" |
| " vertices[2] = vec2( 0.5, 0.5);\n" |
| " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (std140, binding = 0) uniform redVal { vec4 color; } myRedVal\n;" |
| "layout (std140, binding = 1) uniform greenVal { vec4 color; } myGreenVal\n;" |
| "layout (std140, binding = 2) uniform blueVal { vec4 color; } myBlueVal\n;" |
| "layout (std140, binding = 3) uniform whiteVal { vec4 color; } myWhiteVal\n;" |
| "void main() {\n" |
| " gl_FragColor = myBlueVal.color;\n" |
| " gl_FragColor += myRedVal.color;\n" |
| "}\n"; |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| // We're going to create a number of uniform buffers, and then allow |
| // the shader to select which it wants to read from with a binding |
| |
| // Let's populate the buffers with a single color each: |
| // layout (std140, binding = 0) uniform bufferVals { vec4 red; } myRedVal; |
| // layout (std140, binding = 1) uniform bufferVals { vec4 green; } myGreenVal; |
| // layout (std140, binding = 2) uniform bufferVals { vec4 blue; } myBlueVal; |
| // layout (std140, binding = 3) uniform bufferVals { vec4 white; } myWhiteVal; |
| |
| const float redVals[4] = { 1.0, 0.0, 0.0, 1.0 }; |
| const float greenVals[4] = { 0.0, 1.0, 0.0, 1.0 }; |
| const float blueVals[4] = { 0.0, 0.0, 1.0, 1.0 }; |
| const float whiteVals[4] = { 1.0, 1.0, 1.0, 1.0 }; |
| |
| const int redCount = sizeof(redVals) / sizeof(float); |
| const int greenCount = sizeof(greenVals) / sizeof(float); |
| const int blueCount = sizeof(blueVals) / sizeof(float); |
| const int whiteCount = sizeof(whiteVals) / sizeof(float); |
| |
| XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals); |
| |
| XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals); |
| |
| XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals); |
| |
| XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &redBuffer); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &greenBuffer); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &blueBuffer); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &whiteBuffer); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| // render triangle |
| cmdBuffer.Draw(0, 3, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| } |
| |
| TEST_F(XglRenderTest, TriangleFSAnonymousUniformBlockBinding) |
| { |
| // This test is the same as TriangleFSUniformBlockBinding, but |
| // it does not provide an instance name. |
| // The expected result from this test is a purple triangle |
| |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "void main() {\n" |
| " vec2 vertices[3];" |
| " vertices[0] = vec2(-0.5, -0.5);\n" |
| " vertices[1] = vec2( 0.5, -0.5);\n" |
| " vertices[2] = vec2( 0.5, 0.5);\n" |
| " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 430\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (std140, binding = 0) uniform redVal { vec4 red; };" |
| "layout (std140, binding = 1) uniform greenVal { vec4 green; };" |
| "layout (std140, binding = 2) uniform blueVal { vec4 blue; };" |
| "layout (std140, binding = 3) uniform whiteVal { vec4 white; };" |
| "layout (location = 0) out vec4 outColor;\n" |
| "void main() {\n" |
| " outColor = blue;\n" |
| " outColor += red;\n" |
| "}\n"; |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| // We're going to create a number of uniform buffers, and then allow |
| // the shader to select which it wants to read from with a binding |
| |
| // Let's populate the buffers with a single color each: |
| // layout (std140, binding = 0) uniform bufferVals { vec4 red; } myRedVal; |
| // layout (std140, binding = 1) uniform bufferVals { vec4 green; } myGreenVal; |
| // layout (std140, binding = 2) uniform bufferVals { vec4 blue; } myBlueVal; |
| // layout (std140, binding = 3) uniform bufferVals { vec4 white; } myWhiteVal; |
| |
| const float redVals[4] = { 1.0, 0.0, 0.0, 1.0 }; |
| const float greenVals[4] = { 0.0, 1.0, 0.0, 1.0 }; |
| const float blueVals[4] = { 0.0, 0.0, 1.0, 1.0 }; |
| const float whiteVals[4] = { 1.0, 1.0, 1.0, 1.0 }; |
| |
| const int redCount = sizeof(redVals) / sizeof(float); |
| const int greenCount = sizeof(greenVals) / sizeof(float); |
| const int blueCount = sizeof(blueVals) / sizeof(float); |
| const int whiteCount = sizeof(whiteVals) / sizeof(float); |
| |
| XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals); |
| |
| XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals); |
| |
| XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals); |
| |
| XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &redBuffer); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &greenBuffer); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &blueBuffer); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &whiteBuffer); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| // render triangle |
| cmdBuffer.Draw(0, 3, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| |
| } |
| |
| TEST_F(XglRenderTest, CubeWithVertexFetchAndMVPAndTexture) |
| { |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (std140, binding=0) uniform bufferVals {\n" |
| " mat4 mvp;\n" |
| "} myBufferVals;\n" |
| "layout (location=0) in vec4 pos;\n" |
| "layout (location=0) out vec2 UV;\n" |
| "void main() {\n" |
| " vec2 positions[3];" |
| " positions[0] = vec2( 0.0, 0.0);\n" |
| " positions[1] = vec2( 0.25, 0.1);\n" |
| " positions[2] = vec2( 0.1, 0.25);\n" |
| " UV = positions[gl_VertexID % 3];\n" |
| " gl_Position = myBufferVals.mvp * pos;\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (binding=1) uniform sampler2D surface;\n" |
| "layout (location=0) out vec4 outColor;\n" |
| "layout (location=0) in vec2 UV;\n" |
| "void main() {\n" |
| " outColor= textureLod(surface, UV, 0.0);\n" |
| "}\n"; |
| glm::mat4 Projection = glm::perspective(glm::radians(45.0f), 1.0f, 0.1f, 100.0f); |
| |
| glm::mat4 View = glm::lookAt( |
| glm::vec3(0,3,10), // Camera is at (0,3,10), in World Space |
| glm::vec3(0,0,0), // and looks at the origin |
| glm::vec3(0,1,0) // Head is up (set to 0,-1,0 to look upside-down) |
| ); |
| |
| glm::mat4 Model = glm::mat4(1.0f); |
| |
| glm::mat4 MVP = Projection * View * Model; |
| |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| ASSERT_NO_FATAL_FAILURE(InitDepthStencil()); |
| |
| XglConstantBufferObj meshBuffer(m_device,sizeof(g_vb_solid_face_colors_Data)/sizeof(g_vb_solid_face_colors_Data[0]), |
| sizeof(g_vb_solid_face_colors_Data[0]), g_vb_solid_face_colors_Data); |
| meshBuffer.BufferMemoryBarrier(); |
| |
| const int buf_size = sizeof(MVP) / sizeof(float); |
| |
| XglConstantBufferObj mvpBuffer(m_device, buf_size, sizeof(MVP[0]), (const void*) &MVP[0][0]); |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| XglSamplerObj sampler(m_device); |
| XglTextureObj texture(m_device); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| // descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &meshBuffer); // TODO: Why does this break images?? |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &mvpBuffer); |
| descriptorSet.AppendSamplerTexture(&sampler, &texture); |
| |
| m_memoryRefManager.AddMemoryRef(&meshBuffer); |
| m_memoryRefManager.AddMemoryRef(&mvpBuffer); |
| m_memoryRefManager.AddMemoryRef(&texture); |
| m_memoryRefManager.AddMemoryRef(m_depthStencilMem, m_num_mem); |
| |
| XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_binding = { |
| sizeof(g_vbData[0]), // strideInBytes; Distance between vertices in bytes (0 = no advancement) |
| XGL_VERTEX_INPUT_STEP_RATE_VERTEX // stepRate; // Rate at which binding is incremented |
| }; |
| |
| // this is the current description of g_vbData |
| XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION vi_attribs[2]; |
| vi_attribs[0].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[0].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[0].offsetInBytes = 0; // Offset of first element in bytes from base of vertex |
| vi_attribs[1].binding = 0; // index into vertexBindingDescriptions |
| vi_attribs[1].format = XGL_FMT_R32G32B32A32_SFLOAT; // format of source data |
| vi_attribs[1].offsetInBytes = 16; // Offset of first element in bytes from base of vertex |
| |
| pipelineobj.AddVertexInputBindings(&vi_binding,1); |
| pipelineobj.AddVertexInputAttribs(vi_attribs,2); |
| pipelineobj.AddVertexDataBuffer(&meshBuffer,0); |
| |
| XGL_PIPELINE_DS_STATE_CREATE_INFO ds_state; |
| ds_state.depthTestEnable = XGL_TRUE; |
| ds_state.depthWriteEnable = XGL_TRUE; |
| ds_state.depthFunc = XGL_COMPARE_LESS_EQUAL; |
| ds_state.depthBoundsEnable = XGL_FALSE; |
| ds_state.stencilTestEnable = XGL_FALSE; |
| ds_state.back.stencilDepthFailOp = XGL_STENCIL_OP_KEEP; |
| ds_state.back.stencilFailOp = XGL_STENCIL_OP_KEEP; |
| ds_state.back.stencilPassOp = XGL_STENCIL_OP_KEEP; |
| ds_state.back.stencilFunc = XGL_COMPARE_ALWAYS; |
| ds_state.format = XGL_FMT_D32_SFLOAT; |
| ds_state.front = ds_state.back; |
| pipelineobj.SetDepthStencil(&ds_state); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| cmdBuffer.BindVertexBuffer(&meshBuffer, 0, 0); |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| // render triangle |
| cmdBuffer.Draw(0, 36, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| |
| } |
| |
| TEST_F(XglRenderTest, TriangleMixedSamplerUniformBlockBinding) |
| { |
| // This test mixes binding slots of textures and buffers, ensuring |
| // that sparse and overlapping assignments work. |
| // The expected result from this test is a purple triangle, although |
| // you can modify it to move the desired result around. |
| |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "void main() {\n" |
| " vec2 vertices[3];" |
| " vertices[0] = vec2(-0.5, -0.5);\n" |
| " vertices[1] = vec2( 0.5, -0.5);\n" |
| " vertices[2] = vec2( 0.5, 0.5);\n" |
| " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 430\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (binding = 0) uniform sampler2D surface0;\n" |
| "layout (binding = 3) uniform sampler2D surface1;\n" |
| "layout (binding = 1) uniform sampler2D surface2;\n" |
| "layout (binding = 2) uniform sampler2D surface3;\n" |
| |
| |
| "layout (std140, binding = 4) uniform redVal { vec4 red; };" |
| "layout (std140, binding = 6) uniform greenVal { vec4 green; };" |
| "layout (std140, binding = 5) uniform blueVal { vec4 blue; };" |
| "layout (std140, binding = 7) uniform whiteVal { vec4 white; };" |
| "layout (location = 0) out vec4 outColor;\n" |
| "void main() {\n" |
| " outColor = red * vec4(0.00001);\n" |
| " outColor += white * vec4(0.00001);\n" |
| " outColor += textureLod(surface2, vec2(0.5), 0.0)* vec4(0.00001);\n" |
| " outColor += textureLod(surface1, vec2(0.0), 0.0);//* vec4(0.00001);\n" |
| "}\n"; |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| const float redVals[4] = { 1.0, 0.0, 0.0, 1.0 }; |
| const float greenVals[4] = { 0.0, 1.0, 0.0, 1.0 }; |
| const float blueVals[4] = { 0.0, 0.0, 1.0, 1.0 }; |
| const float whiteVals[4] = { 1.0, 1.0, 1.0, 1.0 }; |
| |
| const int redCount = sizeof(redVals) / sizeof(float); |
| const int greenCount = sizeof(greenVals) / sizeof(float); |
| const int blueCount = sizeof(blueVals) / sizeof(float); |
| const int whiteCount = sizeof(whiteVals) / sizeof(float); |
| |
| XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals); |
| XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals); |
| XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals); |
| XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals); |
| |
| uint32_t tex_colors[2] = { 0xff800000, 0xff800000 }; |
| XglSamplerObj sampler0(m_device); |
| XglTextureObj texture0(m_device, tex_colors); // Light Red |
| tex_colors[0] = 0xff000080; tex_colors[1] = 0xff000080; |
| XglSamplerObj sampler2(m_device); |
| XglTextureObj texture2(m_device, tex_colors); // Light Blue |
| tex_colors[0] = 0xff008000; tex_colors[1] = 0xff008000; |
| XglSamplerObj sampler4(m_device); |
| XglTextureObj texture4(m_device, tex_colors); // Light Green |
| |
| // NOTE: Bindings 1,3,5,7,8,9,11,12,14,16 work for this sampler, but 6 does not!!! |
| // TODO: Get back here ASAP and understand why. |
| tex_colors[0] = 0xffff00ff; tex_colors[1] = 0xffff00ff; |
| XglSamplerObj sampler7(m_device); |
| XglTextureObj texture7(m_device, tex_colors); // Red and Blue |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendSamplerTexture(&sampler0, &texture0); |
| descriptorSet.AppendSamplerTexture(&sampler2, &texture2); |
| descriptorSet.AppendSamplerTexture(&sampler4, &texture4); |
| descriptorSet.AppendSamplerTexture(&sampler7, &texture7); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &redBuffer); |
| // swap blue and green |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &blueBuffer); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &greenBuffer); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &whiteBuffer); |
| |
| m_memoryRefManager.AddMemoryRef(&texture0); |
| m_memoryRefManager.AddMemoryRef(&texture2); |
| m_memoryRefManager.AddMemoryRef(&texture4); |
| m_memoryRefManager.AddMemoryRef(&texture7); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| // render triangle |
| cmdBuffer.Draw(0, 3, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| |
| } |
| |
| TEST_F(XglRenderTest, TriangleMatchingSamplerUniformBlockBinding) |
| { |
| // This test matches binding slots of textures and buffers, requiring |
| // the driver to give them distinct number spaces. |
| // The expected result from this test is a red triangle, although |
| // you can modify it to move the desired result around. |
| |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "void main() {\n" |
| " vec2 vertices[3];" |
| " vertices[0] = vec2(-0.5, -0.5);\n" |
| " vertices[1] = vec2( 0.5, -0.5);\n" |
| " vertices[2] = vec2( 0.5, 0.5);\n" |
| " gl_Position = vec4(vertices[gl_VertexID % 3], 0.0, 1.0);\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 430\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (binding = 0) uniform sampler2D surface0;\n" |
| "layout (binding = 1) uniform sampler2D surface1;\n" |
| "layout (binding = 2) uniform sampler2D surface2;\n" |
| "layout (binding = 3) uniform sampler2D surface3;\n" |
| "layout (std140, binding = 4) uniform redVal { vec4 red; };" |
| "layout (std140, binding = 5) uniform greenVal { vec4 green; };" |
| "layout (std140, binding = 6) uniform blueVal { vec4 blue; };" |
| "layout (std140, binding = 7) uniform whiteVal { vec4 white; };" |
| "layout (location = 0) out vec4 outColor;\n" |
| "void main() {\n" |
| " outColor = red;// * vec4(0.00001);\n" |
| " outColor += white * vec4(0.00001);\n" |
| " outColor += textureLod(surface1, vec2(0.5), 0.0)* vec4(0.00001);\n" |
| " outColor += textureLod(surface3, vec2(0.0), 0.0)* vec4(0.00001);\n" |
| "}\n"; |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| const float redVals[4] = { 1.0, 0.0, 0.0, 1.0 }; |
| const float greenVals[4] = { 0.0, 1.0, 0.0, 1.0 }; |
| const float blueVals[4] = { 0.0, 0.0, 1.0, 1.0 }; |
| const float whiteVals[4] = { 1.0, 1.0, 1.0, 1.0 }; |
| |
| const int redCount = sizeof(redVals) / sizeof(float); |
| const int greenCount = sizeof(greenVals) / sizeof(float); |
| const int blueCount = sizeof(blueVals) / sizeof(float); |
| const int whiteCount = sizeof(whiteVals) / sizeof(float); |
| |
| XglConstantBufferObj redBuffer(m_device, redCount, sizeof(redVals[0]), (const void*) redVals); |
| XglConstantBufferObj greenBuffer(m_device, greenCount, sizeof(greenVals[0]), (const void*) greenVals); |
| XglConstantBufferObj blueBuffer(m_device, blueCount, sizeof(blueVals[0]), (const void*) blueVals); |
| XglConstantBufferObj whiteBuffer(m_device, whiteCount, sizeof(whiteVals[0]), (const void*) whiteVals); |
| |
| uint32_t tex_colors[2] = { 0xff800000, 0xff800000 }; |
| XglSamplerObj sampler0(m_device); |
| XglTextureObj texture0(m_device, tex_colors); // Light Red |
| tex_colors[0] = 0xff000080; tex_colors[1] = 0xff000080; |
| XglSamplerObj sampler2(m_device); |
| XglTextureObj texture2(m_device, tex_colors); // Light Blue |
| tex_colors[0] = 0xff008000; tex_colors[1] = 0xff008000; |
| XglSamplerObj sampler4(m_device); |
| XglTextureObj texture4(m_device, tex_colors); // Light Green |
| tex_colors[0] = 0xffff00ff; tex_colors[1] = 0xffff00ff; |
| XglSamplerObj sampler7(m_device); |
| XglTextureObj texture7(m_device, tex_colors); // Red and Blue |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendSamplerTexture(&sampler0, &texture0); |
| descriptorSet.AppendSamplerTexture(&sampler2, &texture2); |
| descriptorSet.AppendSamplerTexture(&sampler4, &texture4); |
| descriptorSet.AppendSamplerTexture(&sampler7, &texture7); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &redBuffer); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &greenBuffer); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &blueBuffer); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &whiteBuffer); |
| |
| m_memoryRefManager.AddMemoryRef(&texture0); |
| m_memoryRefManager.AddMemoryRef(&texture2); |
| m_memoryRefManager.AddMemoryRef(&texture4); |
| m_memoryRefManager.AddMemoryRef(&texture7); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| // render triangle |
| cmdBuffer.Draw(0, 3, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| |
| } |
| |
| TEST_F(XglRenderTest, TriangleUniformBufferLayout) |
| { |
| // This test populates a buffer with a variety of different data |
| // types, then reads them out with a shader. |
| // The expected result from this test is a green triangle |
| |
| static const char *vertShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (std140, binding = 0) uniform mixedBuffer {\n" |
| " vec4 fRed;\n" |
| " vec4 fGreen;\n" |
| " layout(row_major) mat4 worldToProj;\n" |
| " layout(row_major) mat4 projToWorld;\n" |
| " layout(row_major) mat4 worldToView;\n" |
| " layout(row_major) mat4 viewToProj;\n" |
| " layout(row_major) mat4 worldToShadow[4];\n" |
| " float fZero;\n" |
| " float fOne;\n" |
| " float fTwo;\n" |
| " float fThree;\n" |
| " vec3 fZeroZeroZero;\n" |
| " float fFour;\n" |
| " vec3 fZeroZeroOne;\n" |
| " float fFive;\n" |
| " vec3 fZeroOneZero;\n" |
| " float fSix;\n" |
| " float fSeven;\n" |
| " float fEight;\n" |
| " float fNine;\n" |
| " vec2 fZeroZero;\n" |
| " vec2 fZeroOne;\n" |
| " vec4 fBlue;\n" |
| " vec2 fOneZero;\n" |
| " vec2 fOneOne;\n" |
| " vec3 fZeroOneOne;\n" |
| " float fTen;\n" |
| " float fEleven;\n" |
| " float fTwelve;\n" |
| " vec3 fOneZeroZero;\n" |
| " vec4 uvOffsets[4];\n" |
| "};\n" |
| "layout (location = 0) out vec4 color;" |
| "void main() {\n" |
| |
| " vec4 right = vec4(0.0, 1.0, 0.0, 1.0);\n" |
| " vec4 wrong = vec4(1.0, 0.0, 0.0, 1.0);\n" |
| " \n" |
| |
| // do some exact comparisons, even though we should |
| // really have an epsilon involved. |
| " vec4 outColor = right;\n" |
| " if (fRed != vec4(1.0, 0.0, 0.0, 1.0))\n" |
| " outColor = wrong;\n" |
| " if (fGreen != vec4(0.0, 1.0, 0.0, 1.0))\n" |
| " outColor = wrong;\n" |
| " if (fBlue != vec4(0.0, 0.0, 1.0, 1.0))\n" |
| " outColor = wrong;\n" |
| |
| " color = outColor;\n" |
| |
| // generic position stuff |
| " vec2 vertices;\n" |
| " int vertexSelector = gl_VertexID;\n" |
| " if (vertexSelector == 0)\n" |
| " vertices = vec2(-0.5, -0.5);\n" |
| " else if (vertexSelector == 1)\n" |
| " vertices = vec2( 0.5, -0.5);\n" |
| " else if (vertexSelector == 2)\n" |
| " vertices = vec2( 0.5, 0.5);\n" |
| " else\n" |
| " vertices = vec2( 0.0, 0.0);\n" |
| " gl_Position = vec4(vertices, 0.0, 1.0);\n" |
| "}\n"; |
| |
| static const char *fragShaderText = |
| "#version 140\n" |
| "#extension GL_ARB_separate_shader_objects : enable\n" |
| "#extension GL_ARB_shading_language_420pack : enable\n" |
| "layout (std140, binding = 0) uniform mixedBuffer {\n" |
| " vec4 fRed;\n" |
| " vec4 fGreen;\n" |
| " layout(row_major) mat4 worldToProj;\n" |
| " layout(row_major) mat4 projToWorld;\n" |
| " layout(row_major) mat4 worldToView;\n" |
| " layout(row_major) mat4 viewToProj;\n" |
| " layout(row_major) mat4 worldToShadow[4];\n" |
| " float fZero;\n" |
| " float fOne;\n" |
| " float fTwo;\n" |
| " float fThree;\n" |
| " vec3 fZeroZeroZero;\n" |
| " float fFour;\n" |
| " vec3 fZeroZeroOne;\n" |
| " float fFive;\n" |
| " vec3 fZeroOneZero;\n" |
| " float fSix;\n" |
| " float fSeven;\n" |
| " float fEight;\n" |
| " float fNine;\n" |
| " vec2 fZeroZero;\n" |
| " vec2 fZeroOne;\n" |
| " vec4 fBlue;\n" |
| " vec2 fOneZero;\n" |
| " vec2 fOneOne;\n" |
| " vec3 fZeroOneOne;\n" |
| " float fTen;\n" |
| " float fEleven;\n" |
| " float fTwelve;\n" |
| " vec3 fOneZeroZero;\n" |
| " vec4 uvOffsets[4];\n" |
| "};\n" |
| "layout (location = 0) in vec4 color;\n" |
| "void main() {\n" |
| " vec4 right = vec4(0.0, 1.0, 0.0, 1.0);\n" |
| " vec4 wrong = vec4(1.0, 0.0, 0.0, 1.0);\n" |
| " \n" |
| |
| // start with VS value to ensure it passed |
| " vec4 outColor = color;\n" |
| |
| // do some exact comparisons, even though we should |
| // really have an epsilon involved. |
| " if (fRed != vec4(1.0, 0.0, 0.0, 1.0))\n" |
| " outColor = wrong;\n" |
| " if (fGreen != vec4(0.0, 1.0, 0.0, 1.0))\n" |
| " outColor = wrong;\n" |
| " if (projToWorld[1] != vec4(0.0, 2.0, 0.0, 0.0))\n" |
| " outColor = wrong;\n" |
| " if (worldToShadow[2][1] != vec4(0.0, 7.0, 0.0, 0.0))\n" |
| " outColor = wrong;\n" |
| " if (fTwo != 2.0)\n" |
| " outColor = wrong;\n" |
| " if (fOneOne != vec2(1.0, 1.0))\n" |
| " outColor = wrong;\n" |
| " if (fTen != 10.0)\n" |
| " outColor = wrong;\n" |
| " if (uvOffsets[2] != vec4(0.9, 1.0, 1.1, 1.2))\n" |
| " outColor = wrong;\n" |
| " \n" |
| " gl_FragColor = outColor;\n" |
| "}\n"; |
| |
| |
| const float mixedVals[196] = { 1.0, 0.0, 0.0, 1.0, // vec4 fRed; // align |
| 0.0, 1.0, 0.0, 1.0, // vec4 fGreen; // align |
| 1.0, 0.0, 0.0, 1.0, // layout(row_major) mat4 worldToProj; |
| 0.0, 1.0, 0.0, 1.0, // align |
| 0.0, 0.0, 1.0, 1.0, // align |
| 0.0, 0.0, 0.0, 1.0, // align |
| 2.0, 0.0, 0.0, 2.0, // layout(row_major) mat4 projToWorld; |
| 0.0, 2.0, 0.0, 2.0, // align |
| 0.0, 0.0, 2.0, 2.0, // align |
| 0.0, 0.0, 0.0, 2.0, // align |
| 3.0, 0.0, 0.0, 3.0, // layout(row_major) mat4 worldToView; |
| 0.0, 3.0, 0.0, 3.0, // align |
| 0.0, 0.0, 3.0, 3.0, // align |
| 0.0, 0.0, 0.0, 3.0, // align |
| 4.0, 0.0, 0.0, 4.0, // layout(row_major) mat4 viewToProj; |
| 0.0, 4.0, 0.0, 4.0, // align |
| 0.0, 0.0, 4.0, 4.0, // align |
| 0.0, 0.0, 0.0, 4.0, // align |
| 5.0, 0.0, 0.0, 5.0, // layout(row_major) mat4 worldToShadow[4]; |
| 0.0, 5.0, 0.0, 5.0, // align |
| 0.0, 0.0, 5.0, 5.0, // align |
| 0.0, 0.0, 0.0, 5.0, // align |
| 6.0, 0.0, 0.0, 6.0, // align |
| 0.0, 6.0, 0.0, 6.0, // align |
| 0.0, 0.0, 6.0, 6.0, // align |
| 0.0, 0.0, 0.0, 6.0, // align |
| 7.0, 0.0, 0.0, 7.0, // align |
| 0.0, 7.0, 0.0, 7.0, // align |
| 0.0, 0.0, 7.0, 7.0, // align |
| 0.0, 0.0, 0.0, 7.0, // align |
| 8.0, 0.0, 0.0, 8.0, // align |
| 0.0, 8.0, 0.0, 8.0, // align |
| 0.0, 0.0, 8.0, 8.0, // align |
| 0.0, 0.0, 0.0, 8.0, // align |
| 0.0, // float fZero; // align |
| 1.0, // float fOne; // pack |
| 2.0, // float fTwo; // pack |
| 3.0, // float fThree; // pack |
| 0.0, 0.0, 0.0, // vec3 fZeroZeroZero; // align |
| 4.0, // float fFour; // pack |
| 0.0, 0.0, 1.0, // vec3 fZeroZeroOne; // align |
| 5.0, // float fFive; // pack |
| 0.0, 1.0, 0.0, // vec3 fZeroOneZero; // align |
| 6.0, // float fSix; // pack |
| 7.0, // float fSeven; // align |
| 8.0, // float fEight; // pack |
| 9.0, // float fNine; // pack |
| 0.0, // BUFFER |
| 0.0, 0.0, // vec2 fZeroZero; // align |
| 0.0, 1.0, // vec2 fZeroOne; // pack |
| 0.0, 0.0, 1.0, 1.0, // vec4 fBlue; // align |
| 1.0, 0.0, // vec2 fOneZero; // align |
| 1.0, 1.0, // vec2 fOneOne; // pack |
| 0.0, 1.0, 1.0, // vec3 fZeroOneOne; // align |
| 10.0, // float fTen; // pack |
| 11.0, // float fEleven; // align |
| 12.0, // float fTwelve; // pack |
| 0.0, 0.0, // BUFFER |
| 1.0, 0.0, 0.0, // vec3 fOneZeroZero; // align |
| 0.0, // BUFFER |
| 0.1, 0.2, 0.3, 0.4, // vec4 uvOffsets[4]; |
| 0.5, 0.6, 0.7, 0.8, // align |
| 0.9, 1.0, 1.1, 1.2, // align |
| 1.3, 1.4, 1.5, 1.6, // align |
| }; |
| |
| ASSERT_NO_FATAL_FAILURE(InitState()); |
| ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| |
| const int constCount = sizeof(mixedVals) / sizeof(float); |
| |
| XglShaderObj vs(m_device,vertShaderText,XGL_SHADER_STAGE_VERTEX, this); |
| XglShaderObj ps(m_device,fragShaderText, XGL_SHADER_STAGE_FRAGMENT, this); |
| |
| XglConstantBufferObj mixedBuffer(m_device, constCount, sizeof(mixedVals[0]), (const void*) mixedVals); |
| |
| XglPipelineObj pipelineobj(m_device); |
| pipelineobj.AddShader(&vs); |
| pipelineobj.AddShader(&ps); |
| |
| XglDescriptorSetObj descriptorSet(m_device); |
| descriptorSet.AppendBuffer(XGL_DESCRIPTOR_TYPE_UNIFORM_BUFFER, &mixedBuffer); |
| |
| ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| m_memoryRefManager.AddRTMemoryRefs(m_renderTargets, m_renderTargets.size()); |
| XglCommandBufferObj cmdBuffer(m_device); |
| cmdBuffer.AddRenderTarget(m_renderTargets[0]); |
| |
| ASSERT_XGL_SUCCESS(BeginCommandBuffer(cmdBuffer)); |
| |
| GenericDrawPreparation(&cmdBuffer, &pipelineobj, &descriptorSet); |
| |
| #ifdef DUMP_STATE_DOT |
| DRAW_STATE_DUMP_DOT_FILE pDSDumpDot = (DRAW_STATE_DUMP_DOT_FILE)xglGetProcAddr(gpu(), (char*)"drawStateDumpDotFile"); |
| pDSDumpDot((char*)"triTest2.dot"); |
| #endif |
| // render triangle |
| cmdBuffer.Draw(0, 3, 0, 1); |
| |
| // finalize recording of the command buffer |
| EndCommandBuffer(cmdBuffer); |
| cmdBuffer.QueueCommandBuffer(m_memoryRefManager.GetMemoryRefList(), m_memoryRefManager.GetNumRefs()); |
| |
| for (int i = 0; i < m_renderTargets.size(); i++) |
| RecordImage(m_renderTargets[i]); |
| } |
| |
| int main(int argc, char **argv) { |
| int result; |
| |
| ::testing::InitGoogleTest(&argc, argv); |
| XglTestFramework::InitArgs(&argc, argv); |
| |
| ::testing::AddGlobalTestEnvironment(new TestEnvironment); |
| |
| result = RUN_ALL_TESTS(); |
| |
| XglTestFramework::Finish(); |
| return result; |
| } |