Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 1 | /* |
| 2 | * XGL Tests |
| 3 | * |
| 4 | * Copyright (C) 2014 LunarG, Inc. |
| 5 | * |
| 6 | * Permission is hereby granted, free of charge, to any person obtaining a |
| 7 | * copy of this software and associated documentation files (the "Software"), |
| 8 | * to deal in the Software without restriction, including without limitation |
| 9 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 10 | * and/or sell copies of the Software, and to permit persons to whom the |
| 11 | * Software is furnished to do so, subject to the following conditions: |
| 12 | * |
| 13 | * The above copyright notice and this permission notice shall be included |
| 14 | * in all copies or substantial portions of the Software. |
| 15 | * |
| 16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| 21 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
| 22 | * DEALINGS IN THE SOFTWARE. |
| 23 | * |
| 24 | * Authors: |
| 25 | * Courtney Goeltzenleuchter <courtney@lunarg.com> |
| 26 | */ |
| 27 | |
| 28 | #ifndef XGLRENDERFRAMEWORK_H |
| 29 | #define XGLRENDERFRAMEWORK_H |
| 30 | |
| 31 | #include "xgltestframework.h" |
Chia-I Wu | fb1459b | 2014-12-29 15:23:20 +0800 | [diff] [blame] | 32 | |
Tony Barbour | 1c45ce0 | 2015-03-27 17:03:18 -0600 | [diff] [blame] | 33 | |
Chia-I Wu | fb1459b | 2014-12-29 15:23:20 +0800 | [diff] [blame] | 34 | class XglDevice : public xgl_testing::Device |
| 35 | { |
| 36 | public: |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 37 | XglDevice(uint32_t id, XGL_PHYSICAL_GPU obj); |
Chia-I Wu | fb1459b | 2014-12-29 15:23:20 +0800 | [diff] [blame] | 38 | |
| 39 | XGL_DEVICE device() { return obj(); } |
| 40 | void get_device_queue(); |
| 41 | |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 42 | uint32_t id; |
Chia-I Wu | fb1459b | 2014-12-29 15:23:20 +0800 | [diff] [blame] | 43 | XGL_PHYSICAL_GPU_PROPERTIES props; |
| 44 | const XGL_PHYSICAL_GPU_QUEUE_PROPERTIES *queue_props; |
| 45 | |
| 46 | XGL_QUEUE m_queue; |
| 47 | }; |
| 48 | |
Tony Barbour | 1c45ce0 | 2015-03-27 17:03:18 -0600 | [diff] [blame] | 49 | class XglDepthStencilObj : public xgl_testing::Image |
| 50 | { |
| 51 | public: |
| 52 | XglDepthStencilObj(); |
| 53 | void Init(XglDevice *device, int32_t width, int32_t height); |
| 54 | bool Initialized(); |
| 55 | XGL_DEPTH_STENCIL_BIND_INFO* BindInfo(); |
| 56 | |
| 57 | protected: |
| 58 | XglDevice *m_device; |
| 59 | bool m_initialized; |
| 60 | xgl_testing::DepthStencilView m_depthStencilView; |
| 61 | XGL_FORMAT m_depth_stencil_fmt; |
| 62 | XGL_DEPTH_STENCIL_BIND_INFO m_depthStencilBindInfo; |
| 63 | }; |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 64 | |
| 65 | class XglRenderFramework : public XglTestFramework |
| 66 | { |
| 67 | public: |
| 68 | XglRenderFramework(); |
| 69 | ~XglRenderFramework(); |
| 70 | |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 71 | XGL_DEVICE device() {return m_device->device();} |
Tobin Ehlis | ca91587 | 2014-11-18 11:28:33 -0700 | [diff] [blame] | 72 | XGL_PHYSICAL_GPU gpu() {return objs[0];} |
Jon Ashburn | cdc40be | 2015-01-02 18:27:14 -0700 | [diff] [blame] | 73 | XGL_RENDER_PASS renderPass() {return m_renderPass;} |
Courtney Goeltzenleuchter | 69894b7 | 2015-04-03 15:25:24 -0600 | [diff] [blame] | 74 | XGL_FRAMEBUFFER framebuffer() {return m_framebuffer;} |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 75 | void InitViewport(float width, float height); |
Courtney Goeltzenleuchter | 02d33c1 | 2014-10-08 14:26:40 -0600 | [diff] [blame] | 76 | void InitViewport(); |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 77 | void InitRenderTarget(); |
Courtney Goeltzenleuchter | b4337c1 | 2015-03-05 16:47:18 -0700 | [diff] [blame] | 78 | void InitRenderTarget(uint32_t targets); |
Tony Barbour | 1c45ce0 | 2015-03-27 17:03:18 -0600 | [diff] [blame] | 79 | void InitRenderTarget(XGL_DEPTH_STENCIL_BIND_INFO *dsBinding); |
| 80 | void InitRenderTarget(uint32_t targets, XGL_DEPTH_STENCIL_BIND_INFO *dsBinding); |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 81 | void InitFramework(); |
Courtney Goeltzenleuchter | 53d8d89 | 2014-10-08 12:20:26 -0600 | [diff] [blame] | 82 | void ShutdownFramework(); |
| 83 | void InitState(); |
Tony Barbour | e2c58df | 2014-11-25 13:18:32 -0700 | [diff] [blame] | 84 | |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 85 | |
| 86 | protected: |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 87 | XGL_APPLICATION_INFO app_info; |
Jon Ashburn | 1e46489 | 2015-01-29 15:48:00 -0700 | [diff] [blame] | 88 | XGL_INSTANCE inst; |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 89 | XGL_PHYSICAL_GPU objs[XGL_MAX_PHYSICAL_GPUS]; |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 90 | uint32_t gpu_count; |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 91 | XglDevice *m_device; |
| 92 | XGL_CMD_BUFFER m_cmdBuffer; |
| 93 | XGL_RENDER_PASS m_renderPass; |
Courtney Goeltzenleuchter | 69894b7 | 2015-04-03 15:25:24 -0600 | [diff] [blame] | 94 | XGL_FRAMEBUFFER m_framebuffer; |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 95 | XGL_MEMORY_REF m_memRefs[5]; |
| 96 | XGL_DYNAMIC_RS_STATE_OBJECT m_stateRaster; |
| 97 | XGL_DYNAMIC_CB_STATE_OBJECT m_colorBlend; |
| 98 | XGL_DYNAMIC_VP_STATE_OBJECT m_stateViewport; |
| 99 | XGL_DYNAMIC_DS_STATE_OBJECT m_stateDepthStencil; |
| 100 | vector<XglImage*> m_renderTargets; |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 101 | float m_width, m_height; |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 102 | XGL_FORMAT m_render_target_fmt; |
Courtney Goeltzenleuchter | 679bbfa | 2015-03-05 17:26:38 -0700 | [diff] [blame] | 103 | XGL_FORMAT m_depth_stencil_fmt; |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 104 | XGL_COLOR_ATTACHMENT_BIND_INFO m_colorBindings[8]; |
Courtney Goeltzenleuchter | 679bbfa | 2015-03-05 17:26:38 -0700 | [diff] [blame] | 105 | XGL_CLEAR_COLOR m_clear_color; |
| 106 | float m_depth_clear_color; |
| 107 | uint32_t m_stencil_clear_color; |
Tony Barbour | 1c45ce0 | 2015-03-27 17:03:18 -0600 | [diff] [blame] | 108 | XglDepthStencilObj *m_depthStencil; |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 109 | |
| 110 | /* |
| 111 | * SetUp and TearDown are called by the Google Test framework |
| 112 | * to initialize a test framework based on this class. |
| 113 | */ |
| 114 | virtual void SetUp() { |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 115 | this->app_info.sType = XGL_STRUCTURE_TYPE_APPLICATION_INFO; |
| 116 | this->app_info.pNext = NULL; |
Chia-I Wu | f1a5a74 | 2014-12-27 15:16:07 +0800 | [diff] [blame] | 117 | this->app_info.pAppName = "base"; |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 118 | this->app_info.appVersion = 1; |
Chia-I Wu | f1a5a74 | 2014-12-27 15:16:07 +0800 | [diff] [blame] | 119 | this->app_info.pEngineName = "unittest"; |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 120 | this->app_info.engineVersion = 1; |
Courtney Goeltzenleuchter | 5adee1c | 2015-02-23 17:40:15 -0700 | [diff] [blame] | 121 | this->app_info.apiVersion = XGL_API_VERSION; |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 122 | |
Chia-I Wu | 8089cc1 | 2014-12-29 15:18:43 +0800 | [diff] [blame] | 123 | InitFramework(); |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 124 | } |
| 125 | |
| 126 | virtual void TearDown() { |
Chia-I Wu | 8089cc1 | 2014-12-29 15:18:43 +0800 | [diff] [blame] | 127 | ShutdownFramework(); |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 128 | } |
| 129 | }; |
| 130 | |
Tony Barbour | 30cc9e8 | 2014-12-17 11:53:55 -0700 | [diff] [blame] | 131 | class XglIndexBufferObj; |
| 132 | class XglConstantBufferObj; |
| 133 | |
Chia-I Wu | 11078b0 | 2015-01-04 16:27:24 +0800 | [diff] [blame] | 134 | class XglCommandBufferObj : public xgl_testing::CmdBuffer |
Tony Barbour | 6d047bf | 2014-12-10 14:34:45 -0700 | [diff] [blame] | 135 | { |
| 136 | public: |
| 137 | XglCommandBufferObj(XglDevice *device); |
Tony Barbour | 471338d | 2014-12-10 17:28:39 -0700 | [diff] [blame] | 138 | XGL_CMD_BUFFER GetBufferHandle(); |
Jon Ashburn | c4164b1 | 2014-12-31 17:10:47 -0700 | [diff] [blame] | 139 | XGL_RESULT BeginCommandBuffer(XGL_CMD_BUFFER_BEGIN_INFO *pInfo); |
Courtney Goeltzenleuchter | 69894b7 | 2015-04-03 15:25:24 -0600 | [diff] [blame] | 140 | XGL_RESULT BeginCommandBuffer(XGL_RENDER_PASS renderpass_obj, XGL_FRAMEBUFFER framebuffer_obj); |
Jeremy Hayes | d65ae08 | 2015-01-14 16:17:08 -0700 | [diff] [blame] | 141 | XGL_RESULT BeginCommandBuffer(); |
Tony Barbour | 471338d | 2014-12-10 17:28:39 -0700 | [diff] [blame] | 142 | XGL_RESULT EndCommandBuffer(); |
Mike Stroyan | fb80d5f | 2014-12-04 11:08:39 +0000 | [diff] [blame] | 143 | void PipelineBarrier(XGL_PIPELINE_BARRIER *barrierPtr); |
Tony Barbour | 30cc9e8 | 2014-12-17 11:53:55 -0700 | [diff] [blame] | 144 | void AddRenderTarget(XglImage *renderTarget); |
| 145 | void AddDepthStencil(); |
Courtney Goeltzenleuchter | 679bbfa | 2015-03-05 17:26:38 -0700 | [diff] [blame] | 146 | void ClearAllBuffers(XGL_CLEAR_COLOR clear_color, float depth_clear_color, uint32_t stencil_clear_color, XGL_DEPTH_STENCIL_BIND_INFO *depthStencilBinding, XGL_IMAGE depthStencilImage); |
Jon Ashburn | cdc40be | 2015-01-02 18:27:14 -0700 | [diff] [blame] | 147 | void PrepareAttachments(); |
Tony Barbour | 30cc9e8 | 2014-12-17 11:53:55 -0700 | [diff] [blame] | 148 | void BindPipeline(XGL_PIPELINE pipeline); |
| 149 | void BindDescriptorSet(XGL_DESCRIPTOR_SET descriptorSet); |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 150 | void BindVertexBuffer(XglConstantBufferObj *vertexBuffer, uint32_t offset, uint32_t binding); |
| 151 | void BindIndexBuffer(XglIndexBufferObj *indexBuffer, uint32_t offset); |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 152 | void BindStateObject(XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT stateObject); |
Courtney Goeltzenleuchter | 69894b7 | 2015-04-03 15:25:24 -0600 | [diff] [blame] | 153 | void BeginRenderPass(XGL_RENDER_PASS renderpass, XGL_FRAMEBUFFER framebuffer); |
| 154 | void EndRenderPass(XGL_RENDER_PASS renderpass); |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 155 | void Draw(uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount); |
| 156 | void DrawIndexed(uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount); |
| 157 | void QueueCommandBuffer(XGL_MEMORY_REF *memRefs, uint32_t numMemRefs); |
Tony Barbour | 6d047bf | 2014-12-10 14:34:45 -0700 | [diff] [blame] | 158 | |
| 159 | protected: |
| 160 | XglDevice *m_device; |
Tony Barbour | 30cc9e8 | 2014-12-17 11:53:55 -0700 | [diff] [blame] | 161 | vector<XglImage*> m_renderTargets; |
Tony Barbour | 6d047bf | 2014-12-10 14:34:45 -0700 | [diff] [blame] | 162 | |
| 163 | }; |
| 164 | |
Chia-I Wu | 1a28fe0 | 2015-01-01 07:55:04 +0800 | [diff] [blame] | 165 | class XglConstantBufferObj : public xgl_testing::Buffer |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 166 | { |
| 167 | public: |
Courtney Goeltzenleuchter | 3b0a815 | 2014-12-04 15:18:47 -0700 | [diff] [blame] | 168 | XglConstantBufferObj(XglDevice *device); |
Tony Barbour | ac3692c | 2014-11-20 15:06:56 -0700 | [diff] [blame] | 169 | XglConstantBufferObj(XglDevice *device, int constantCount, int constantSize, const void* data); |
Tony Barbour | 044703b | 2015-03-26 12:37:52 -0600 | [diff] [blame] | 170 | ~XglConstantBufferObj(); |
Mike Stroyan | fb80d5f | 2014-12-04 11:08:39 +0000 | [diff] [blame] | 171 | void BufferMemoryBarrier( |
| 172 | XGL_FLAGS outputMask = |
| 173 | XGL_MEMORY_OUTPUT_CPU_WRITE_BIT | |
| 174 | XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT | |
| 175 | XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT | |
| 176 | XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT | |
| 177 | XGL_MEMORY_OUTPUT_COPY_BIT, |
| 178 | XGL_FLAGS inputMask = |
| 179 | XGL_MEMORY_INPUT_CPU_READ_BIT | |
| 180 | XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT | |
| 181 | XGL_MEMORY_INPUT_INDEX_FETCH_BIT | |
| 182 | XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT | |
| 183 | XGL_MEMORY_INPUT_UNIFORM_READ_BIT | |
| 184 | XGL_MEMORY_INPUT_SHADER_READ_BIT | |
| 185 | XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT | |
| 186 | XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT | |
| 187 | XGL_MEMORY_INPUT_COPY_BIT); |
| 188 | |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 189 | void Bind(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_SIZE offset, uint32_t binding); |
Chia-I Wu | 1a28fe0 | 2015-01-01 07:55:04 +0800 | [diff] [blame] | 190 | |
| 191 | XGL_BUFFER_VIEW_ATTACH_INFO m_bufferViewInfo; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 192 | |
| 193 | protected: |
Tony Barbour | ac3692c | 2014-11-20 15:06:56 -0700 | [diff] [blame] | 194 | XglDevice *m_device; |
Chia-I Wu | 1a28fe0 | 2015-01-01 07:55:04 +0800 | [diff] [blame] | 195 | xgl_testing::BufferView m_bufferView; |
Tony Barbour | ac3692c | 2014-11-20 15:06:56 -0700 | [diff] [blame] | 196 | int m_numVertices; |
| 197 | int m_stride; |
Tony Barbour | 3842280 | 2014-12-10 14:36:31 -0700 | [diff] [blame] | 198 | XglCommandBufferObj *m_commandBuffer; |
Chia-I Wu | a07fee6 | 2014-12-28 15:26:08 +0800 | [diff] [blame] | 199 | xgl_testing::Fence m_fence; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 200 | }; |
Courtney Goeltzenleuchter | 8a78593 | 2014-12-04 15:24:05 -0700 | [diff] [blame] | 201 | |
| 202 | class XglIndexBufferObj : public XglConstantBufferObj |
| 203 | { |
| 204 | public: |
| 205 | XglIndexBufferObj(XglDevice *device); |
| 206 | void CreateAndInitBuffer(int numIndexes, XGL_INDEX_TYPE dataFormat, const void* data); |
| 207 | void Bind(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_SIZE offset); |
Tony Barbour | af1f919 | 2014-12-17 10:57:58 -0700 | [diff] [blame] | 208 | XGL_INDEX_TYPE GetIndexType(); |
Courtney Goeltzenleuchter | 8a78593 | 2014-12-04 15:24:05 -0700 | [diff] [blame] | 209 | |
| 210 | protected: |
| 211 | XGL_INDEX_TYPE m_indexType; |
| 212 | }; |
| 213 | |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 214 | class XglImage : public xgl_testing::Image |
| 215 | { |
| 216 | public: |
| 217 | XglImage(XglDevice *dev); |
| 218 | |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 219 | public: |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 220 | void init( uint32_t w, uint32_t h, |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 221 | XGL_FORMAT fmt, XGL_FLAGS usage, |
| 222 | XGL_IMAGE_TILING tiling=XGL_LINEAR_TILING); |
| 223 | |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 224 | // void clear( CommandBuffer*, uint32_t[4] ); |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 225 | // void prepare( CommandBuffer*, XGL_IMAGE_STATE ); |
| 226 | |
Mike Stroyan | fb80d5f | 2014-12-04 11:08:39 +0000 | [diff] [blame] | 227 | void layout( XGL_IMAGE_LAYOUT layout ) |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 228 | { |
Mike Stroyan | fb80d5f | 2014-12-04 11:08:39 +0000 | [diff] [blame] | 229 | m_imageInfo.layout = layout; |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 230 | } |
| 231 | XGL_GPU_MEMORY memory() const |
| 232 | { |
| 233 | const std::vector<XGL_GPU_MEMORY> mems = memories(); |
| 234 | return mems.empty() ? XGL_NULL_HANDLE : mems[0]; |
| 235 | } |
| 236 | |
Tony Barbour | 5dc515d | 2015-04-01 17:47:06 -0600 | [diff] [blame] | 237 | XGL_RESULT CopyImage(XglImage &fromImage); |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 238 | XGL_IMAGE image() const |
| 239 | { |
| 240 | return obj(); |
| 241 | } |
Tony Barbour | 3c9a510 | 2015-04-02 11:51:17 -0600 | [diff] [blame] | 242 | XGL_COLOR_ATTACHMENT_VIEW targetView() |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 243 | { |
Tony Barbour | 3c9a510 | 2015-04-02 11:51:17 -0600 | [diff] [blame] | 244 | if (!m_targetView.initialized()) |
| 245 | { |
| 246 | XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO createView = { |
| 247 | XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO, |
| 248 | XGL_NULL_HANDLE, |
| 249 | obj(), |
| 250 | XGL_FMT_B8G8R8A8_UNORM, |
| 251 | 0, |
| 252 | 0, |
| 253 | 1 |
| 254 | }; |
| 255 | m_targetView.init(*m_device, createView); |
| 256 | } |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 257 | return m_targetView.obj(); |
| 258 | } |
| 259 | |
Mike Stroyan | fb80d5f | 2014-12-04 11:08:39 +0000 | [diff] [blame] | 260 | XGL_IMAGE_LAYOUT layout() const |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 261 | { |
Mike Stroyan | fb80d5f | 2014-12-04 11:08:39 +0000 | [diff] [blame] | 262 | return ( XGL_IMAGE_LAYOUT )m_imageInfo.layout; |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 263 | } |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 264 | uint32_t width() const |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 265 | { |
| 266 | return extent().width; |
| 267 | } |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 268 | uint32_t height() const |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 269 | { |
| 270 | return extent().height; |
| 271 | } |
Tony Barbour | 84d448c | 2015-04-02 14:02:33 -0600 | [diff] [blame] | 272 | XglDevice* device() const |
| 273 | { |
| 274 | return m_device; |
| 275 | } |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 276 | |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 277 | XGL_RESULT MapMemory(void** ptr); |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 278 | XGL_RESULT UnmapMemory(); |
| 279 | |
| 280 | protected: |
| 281 | XglDevice *m_device; |
| 282 | |
| 283 | xgl_testing::ColorAttachmentView m_targetView; |
| 284 | XGL_IMAGE_VIEW_ATTACH_INFO m_imageInfo; |
| 285 | }; |
| 286 | |
Tony Barbour | 5dc515d | 2015-04-01 17:47:06 -0600 | [diff] [blame] | 287 | class XglTextureObj : public XglImage |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 288 | { |
| 289 | public: |
Tony Barbour | ebc093f | 2015-04-01 16:38:10 -0600 | [diff] [blame] | 290 | XglTextureObj(XglDevice *device, uint32_t *colors = NULL); |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 291 | XGL_IMAGE_VIEW_ATTACH_INFO m_textureViewInfo; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 292 | |
Tony Barbour | ebc093f | 2015-04-01 16:38:10 -0600 | [diff] [blame] | 293 | |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 294 | protected: |
| 295 | XglDevice *m_device; |
Chia-I Wu | 13a3aa8 | 2014-12-28 15:55:09 +0800 | [diff] [blame] | 296 | xgl_testing::ImageView m_textureView; |
| 297 | XGL_GPU_SIZE m_rowPitch; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 298 | }; |
| 299 | |
Chia-I Wu | e9864b5 | 2014-12-28 16:32:24 +0800 | [diff] [blame] | 300 | class XglSamplerObj : public xgl_testing::Sampler |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 301 | { |
| 302 | public: |
| 303 | XglSamplerObj(XglDevice *device); |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 304 | |
| 305 | protected: |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 306 | XglDevice *m_device; |
| 307 | |
| 308 | }; |
| 309 | |
Chia-I Wu | 985ba16 | 2015-03-26 13:14:16 +0800 | [diff] [blame] | 310 | class XglDescriptorSetObj : public xgl_testing::DescriptorPool |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 311 | { |
| 312 | public: |
Tony Barbour | ac3692c | 2014-11-20 15:06:56 -0700 | [diff] [blame] | 313 | XglDescriptorSetObj(XglDevice *device); |
Chia-I Wu | 11078b0 | 2015-01-04 16:27:24 +0800 | [diff] [blame] | 314 | ~XglDescriptorSetObj(); |
| 315 | |
| 316 | int AppendDummy(); |
| 317 | int AppendBuffer(XGL_DESCRIPTOR_TYPE type, XglConstantBufferObj* constantBuffer); |
| 318 | int AppendSamplerTexture(XglSamplerObj* sampler, XglTextureObj* texture); |
| 319 | void CreateXGLDescriptorSet(XglCommandBufferObj *cmdBuffer); |
| 320 | |
Tony Barbour | b5f4d08 | 2014-12-17 10:54:03 -0700 | [diff] [blame] | 321 | XGL_DESCRIPTOR_SET GetDescriptorSetHandle(); |
Chia-I Wu | 41126e5 | 2015-03-26 15:27:55 +0800 | [diff] [blame^] | 322 | XGL_DESCRIPTOR_SET_LAYOUT_CHAIN GetLayoutChain(); |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 323 | |
| 324 | protected: |
Tony Barbour | ac3692c | 2014-11-20 15:06:56 -0700 | [diff] [blame] | 325 | XglDevice *m_device; |
Chia-I Wu | 11078b0 | 2015-01-04 16:27:24 +0800 | [diff] [blame] | 326 | vector<XGL_DESCRIPTOR_TYPE_COUNT> m_type_counts; |
Tony Barbour | ac3692c | 2014-11-20 15:06:56 -0700 | [diff] [blame] | 327 | int m_nextSlot; |
Chia-I Wu | 11078b0 | 2015-01-04 16:27:24 +0800 | [diff] [blame] | 328 | |
Chia-I Wu | 11078b0 | 2015-01-04 16:27:24 +0800 | [diff] [blame] | 329 | vector<XGL_UPDATE_BUFFERS> m_updateBuffers; |
| 330 | |
| 331 | vector<XGL_SAMPLER_IMAGE_VIEW_INFO> m_samplerTextureInfo; |
| 332 | vector<XGL_UPDATE_SAMPLER_TEXTURES> m_updateSamplerTextures; |
| 333 | |
| 334 | xgl_testing::DescriptorSetLayout m_layout; |
Chia-I Wu | 41126e5 | 2015-03-26 15:27:55 +0800 | [diff] [blame^] | 335 | xgl_testing::DescriptorSetLayoutChain m_layout_chain; |
Chia-I Wu | 11078b0 | 2015-01-04 16:27:24 +0800 | [diff] [blame] | 336 | xgl_testing::DescriptorSet *m_set; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 337 | }; |
Tony Barbour | ac3692c | 2014-11-20 15:06:56 -0700 | [diff] [blame] | 338 | |
| 339 | |
Chia-I Wu | babc0fd | 2014-12-29 14:14:03 +0800 | [diff] [blame] | 340 | class XglShaderObj : public xgl_testing::Shader |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 341 | { |
| 342 | public: |
Tony Barbour | e2c58df | 2014-11-25 13:18:32 -0700 | [diff] [blame] | 343 | XglShaderObj(XglDevice *device, const char * shaderText, XGL_PIPELINE_SHADER_STAGE stage, XglRenderFramework *framework); |
Chia-I Wu | 11078b0 | 2015-01-04 16:27:24 +0800 | [diff] [blame] | 344 | XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* GetStageCreateInfo(); |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 345 | |
| 346 | protected: |
| 347 | XGL_PIPELINE_SHADER_STAGE_CREATE_INFO stage_info; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 348 | XGL_PIPELINE_SHADER_STAGE m_stage; |
| 349 | XglDevice *m_device; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 350 | |
| 351 | }; |
| 352 | |
Chia-I Wu | 2648d09 | 2014-12-29 14:24:14 +0800 | [diff] [blame] | 353 | class XglPipelineObj : public xgl_testing::Pipeline |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 354 | { |
| 355 | public: |
| 356 | XglPipelineObj(XglDevice *device); |
Tony Barbour | 5420af0 | 2014-12-03 13:58:15 -0700 | [diff] [blame] | 357 | void BindPipelineCommandBuffer(XGL_CMD_BUFFER m_cmdBuffer, XglDescriptorSetObj *descriptorSet); |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 358 | void AddShader(XglShaderObj* shaderObj); |
| 359 | void AddVertexInputAttribs(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* vi_attrib, int count); |
| 360 | void AddVertexInputBindings(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* vi_binding, int count); |
| 361 | void AddVertexDataBuffer(XglConstantBufferObj* vertexDataBuffer, int binding); |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 362 | void AddColorAttachment(uint32_t binding, const XGL_PIPELINE_CB_ATTACHMENT_STATE *att); |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 363 | void SetDepthStencil(XGL_PIPELINE_DS_STATE_CREATE_INFO *); |
Tony Barbour | 976e1cf | 2014-12-17 11:57:31 -0700 | [diff] [blame] | 364 | void CreateXGLPipeline(XglDescriptorSetObj *descriptorSet); |
| 365 | XGL_PIPELINE GetPipelineHandle(); |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 366 | |
| 367 | protected: |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 368 | XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO m_vi_state; |
| 369 | XGL_PIPELINE_IA_STATE_CREATE_INFO m_ia_state; |
| 370 | XGL_PIPELINE_RS_STATE_CREATE_INFO m_rs_state; |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 371 | XGL_PIPELINE_CB_STATE_CREATE_INFO m_cb_state; |
| 372 | XGL_PIPELINE_DS_STATE_CREATE_INFO m_ds_state; |
| 373 | XGL_PIPELINE_MS_STATE_CREATE_INFO m_ms_state; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 374 | XglDevice *m_device; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 375 | vector<XglShaderObj*> m_shaderObjs; |
| 376 | vector<XglConstantBufferObj*> m_vertexBufferObjs; |
| 377 | vector<int> m_vertexBufferBindings; |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 378 | vector<XGL_PIPELINE_CB_ATTACHMENT_STATE> m_colorAttachments; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 379 | int m_vertexBufferCount; |
| 380 | |
| 381 | }; |
| 382 | class XglMemoryRefManager{ |
| 383 | public: |
| 384 | XglMemoryRefManager(); |
Tony Barbour | 1c45ce0 | 2015-03-27 17:03:18 -0600 | [diff] [blame] | 385 | void AddMemoryRef(xgl_testing::Object *xglObject); |
Mark Lobodzinski | c52b775 | 2015-02-18 16:38:17 -0600 | [diff] [blame] | 386 | void AddMemoryRef(XGL_GPU_MEMORY *mem, uint32_t refCount); |
| 387 | void AddRTMemoryRefs(vector<XglImage *>images, uint32_t rtCount); |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 388 | XGL_MEMORY_REF* GetMemoryRefList(); |
| 389 | int GetNumRefs(); |
| 390 | |
| 391 | protected: |
| 392 | int m_numRefs; |
Chia-I Wu | 283d7a6 | 2014-12-28 15:43:42 +0800 | [diff] [blame] | 393 | vector<XGL_GPU_MEMORY> m_bufferObjs; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 394 | |
| 395 | }; |
| 396 | |
| 397 | |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 398 | #endif // XGLRENDERFRAMEWORK_H |