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 | |
Courtney Goeltzenleuchter | 97b7523 | 2015-04-07 17:13:38 -0600 | [diff] [blame^] | 49 | class XglMemoryRefManager |
| 50 | { |
| 51 | public: |
| 52 | void AddMemoryRefs(xgl_testing::Object &xglObject); |
| 53 | void AddMemoryRefs(vector<XGL_GPU_MEMORY> mem); |
| 54 | void EmitAddMemoryRefs(XGL_QUEUE queue); |
| 55 | void EmitRemoveMemoryRefs(XGL_QUEUE queue); |
| 56 | vector<XGL_GPU_MEMORY> mem_refs() const; |
| 57 | |
| 58 | protected: |
| 59 | vector<XGL_GPU_MEMORY> mem_refs_; |
| 60 | |
| 61 | }; |
| 62 | |
Tony Barbour | 1c45ce0 | 2015-03-27 17:03:18 -0600 | [diff] [blame] | 63 | class XglDepthStencilObj : public xgl_testing::Image |
| 64 | { |
| 65 | public: |
| 66 | XglDepthStencilObj(); |
| 67 | void Init(XglDevice *device, int32_t width, int32_t height); |
| 68 | bool Initialized(); |
| 69 | XGL_DEPTH_STENCIL_BIND_INFO* BindInfo(); |
| 70 | |
| 71 | protected: |
| 72 | XglDevice *m_device; |
| 73 | bool m_initialized; |
| 74 | xgl_testing::DepthStencilView m_depthStencilView; |
| 75 | XGL_FORMAT m_depth_stencil_fmt; |
| 76 | XGL_DEPTH_STENCIL_BIND_INFO m_depthStencilBindInfo; |
| 77 | }; |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 78 | |
| 79 | class XglRenderFramework : public XglTestFramework |
| 80 | { |
| 81 | public: |
| 82 | XglRenderFramework(); |
| 83 | ~XglRenderFramework(); |
| 84 | |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 85 | XGL_DEVICE device() {return m_device->device();} |
Tobin Ehlis | ca91587 | 2014-11-18 11:28:33 -0700 | [diff] [blame] | 86 | XGL_PHYSICAL_GPU gpu() {return objs[0];} |
Jon Ashburn | cdc40be | 2015-01-02 18:27:14 -0700 | [diff] [blame] | 87 | XGL_RENDER_PASS renderPass() {return m_renderPass;} |
Courtney Goeltzenleuchter | 69894b7 | 2015-04-03 15:25:24 -0600 | [diff] [blame] | 88 | XGL_FRAMEBUFFER framebuffer() {return m_framebuffer;} |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 89 | void InitViewport(float width, float height); |
Courtney Goeltzenleuchter | 02d33c1 | 2014-10-08 14:26:40 -0600 | [diff] [blame] | 90 | void InitViewport(); |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 91 | void InitRenderTarget(); |
Courtney Goeltzenleuchter | b4337c1 | 2015-03-05 16:47:18 -0700 | [diff] [blame] | 92 | void InitRenderTarget(uint32_t targets); |
Tony Barbour | 1c45ce0 | 2015-03-27 17:03:18 -0600 | [diff] [blame] | 93 | void InitRenderTarget(XGL_DEPTH_STENCIL_BIND_INFO *dsBinding); |
| 94 | void InitRenderTarget(uint32_t targets, XGL_DEPTH_STENCIL_BIND_INFO *dsBinding); |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 95 | void InitFramework(); |
Courtney Goeltzenleuchter | 53d8d89 | 2014-10-08 12:20:26 -0600 | [diff] [blame] | 96 | void ShutdownFramework(); |
| 97 | void InitState(); |
Tony Barbour | e2c58df | 2014-11-25 13:18:32 -0700 | [diff] [blame] | 98 | |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 99 | |
| 100 | protected: |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 101 | XGL_APPLICATION_INFO app_info; |
Jon Ashburn | 1e46489 | 2015-01-29 15:48:00 -0700 | [diff] [blame] | 102 | XGL_INSTANCE inst; |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 103 | XGL_PHYSICAL_GPU objs[XGL_MAX_PHYSICAL_GPUS]; |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 104 | uint32_t gpu_count; |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 105 | XglDevice *m_device; |
| 106 | XGL_CMD_BUFFER m_cmdBuffer; |
| 107 | XGL_RENDER_PASS m_renderPass; |
Courtney Goeltzenleuchter | 69894b7 | 2015-04-03 15:25:24 -0600 | [diff] [blame] | 108 | XGL_FRAMEBUFFER m_framebuffer; |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 109 | XGL_DYNAMIC_RS_STATE_OBJECT m_stateRaster; |
| 110 | XGL_DYNAMIC_CB_STATE_OBJECT m_colorBlend; |
| 111 | XGL_DYNAMIC_VP_STATE_OBJECT m_stateViewport; |
| 112 | XGL_DYNAMIC_DS_STATE_OBJECT m_stateDepthStencil; |
| 113 | vector<XglImage*> m_renderTargets; |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 114 | float m_width, m_height; |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 115 | XGL_FORMAT m_render_target_fmt; |
Courtney Goeltzenleuchter | 679bbfa | 2015-03-05 17:26:38 -0700 | [diff] [blame] | 116 | XGL_FORMAT m_depth_stencil_fmt; |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 117 | XGL_COLOR_ATTACHMENT_BIND_INFO m_colorBindings[8]; |
Courtney Goeltzenleuchter | 679bbfa | 2015-03-05 17:26:38 -0700 | [diff] [blame] | 118 | XGL_CLEAR_COLOR m_clear_color; |
| 119 | float m_depth_clear_color; |
| 120 | uint32_t m_stencil_clear_color; |
Tony Barbour | 1c45ce0 | 2015-03-27 17:03:18 -0600 | [diff] [blame] | 121 | XglDepthStencilObj *m_depthStencil; |
Courtney Goeltzenleuchter | 97b7523 | 2015-04-07 17:13:38 -0600 | [diff] [blame^] | 122 | XglMemoryRefManager m_mem_ref_mgr; |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 123 | |
| 124 | /* |
| 125 | * SetUp and TearDown are called by the Google Test framework |
| 126 | * to initialize a test framework based on this class. |
| 127 | */ |
| 128 | virtual void SetUp() { |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 129 | this->app_info.sType = XGL_STRUCTURE_TYPE_APPLICATION_INFO; |
| 130 | this->app_info.pNext = NULL; |
Chia-I Wu | f1a5a74 | 2014-12-27 15:16:07 +0800 | [diff] [blame] | 131 | this->app_info.pAppName = "base"; |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 132 | this->app_info.appVersion = 1; |
Chia-I Wu | f1a5a74 | 2014-12-27 15:16:07 +0800 | [diff] [blame] | 133 | this->app_info.pEngineName = "unittest"; |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 134 | this->app_info.engineVersion = 1; |
Courtney Goeltzenleuchter | 5adee1c | 2015-02-23 17:40:15 -0700 | [diff] [blame] | 135 | this->app_info.apiVersion = XGL_API_VERSION; |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 136 | |
Chia-I Wu | 8089cc1 | 2014-12-29 15:18:43 +0800 | [diff] [blame] | 137 | InitFramework(); |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 138 | } |
| 139 | |
| 140 | virtual void TearDown() { |
Chia-I Wu | 8089cc1 | 2014-12-29 15:18:43 +0800 | [diff] [blame] | 141 | ShutdownFramework(); |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 142 | } |
| 143 | }; |
| 144 | |
Chia-I Wu | 53f07d7 | 2015-03-28 15:23:55 +0800 | [diff] [blame] | 145 | class XglDescriptorSetObj; |
Tony Barbour | 30cc9e8 | 2014-12-17 11:53:55 -0700 | [diff] [blame] | 146 | class XglIndexBufferObj; |
| 147 | class XglConstantBufferObj; |
Courtney Goeltzenleuchter | 97b7523 | 2015-04-07 17:13:38 -0600 | [diff] [blame^] | 148 | class XglPipelineObj; |
| 149 | class XglDescriptorSetObj; |
Tony Barbour | 30cc9e8 | 2014-12-17 11:53:55 -0700 | [diff] [blame] | 150 | |
Chia-I Wu | 11078b0 | 2015-01-04 16:27:24 +0800 | [diff] [blame] | 151 | class XglCommandBufferObj : public xgl_testing::CmdBuffer |
Tony Barbour | 6d047bf | 2014-12-10 14:34:45 -0700 | [diff] [blame] | 152 | { |
| 153 | public: |
| 154 | XglCommandBufferObj(XglDevice *device); |
Tony Barbour | 471338d | 2014-12-10 17:28:39 -0700 | [diff] [blame] | 155 | XGL_CMD_BUFFER GetBufferHandle(); |
Courtney Goeltzenleuchter | 97b7523 | 2015-04-07 17:13:38 -0600 | [diff] [blame^] | 156 | XGL_RESULT BeginCommandBuffer(); |
Jon Ashburn | c4164b1 | 2014-12-31 17:10:47 -0700 | [diff] [blame] | 157 | XGL_RESULT BeginCommandBuffer(XGL_CMD_BUFFER_BEGIN_INFO *pInfo); |
Courtney Goeltzenleuchter | 69894b7 | 2015-04-03 15:25:24 -0600 | [diff] [blame] | 158 | XGL_RESULT BeginCommandBuffer(XGL_RENDER_PASS renderpass_obj, XGL_FRAMEBUFFER framebuffer_obj); |
Tony Barbour | 471338d | 2014-12-10 17:28:39 -0700 | [diff] [blame] | 159 | XGL_RESULT EndCommandBuffer(); |
Mike Stroyan | fb80d5f | 2014-12-04 11:08:39 +0000 | [diff] [blame] | 160 | void PipelineBarrier(XGL_PIPELINE_BARRIER *barrierPtr); |
Tony Barbour | 30cc9e8 | 2014-12-17 11:53:55 -0700 | [diff] [blame] | 161 | void AddRenderTarget(XglImage *renderTarget); |
| 162 | void AddDepthStencil(); |
Courtney Goeltzenleuchter | 97b7523 | 2015-04-07 17:13:38 -0600 | [diff] [blame^] | 163 | void ClearAllBuffers(XGL_CLEAR_COLOR clear_color, float depth_clear_color, uint32_t stencil_clear_color, XglDepthStencilObj *depthStencilObj); |
Jon Ashburn | cdc40be | 2015-01-02 18:27:14 -0700 | [diff] [blame] | 164 | void PrepareAttachments(); |
Courtney Goeltzenleuchter | 97b7523 | 2015-04-07 17:13:38 -0600 | [diff] [blame^] | 165 | void AddMemoryRefs(xgl_testing::Object &xglObject); |
| 166 | void AddMemoryRefs(uint32_t ref_count, const XGL_GPU_MEMORY *mem); |
| 167 | void AddMemoryRefs(vector<xgl_testing::Object *> images); |
| 168 | void BindPipeline(XglPipelineObj &pipeline); |
| 169 | void BindDescriptorSet(XglDescriptorSetObj &descriptorSet); |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 170 | void BindVertexBuffer(XglConstantBufferObj *vertexBuffer, uint32_t offset, uint32_t binding); |
| 171 | void BindIndexBuffer(XglIndexBufferObj *indexBuffer, uint32_t offset); |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 172 | void BindStateObject(XGL_STATE_BIND_POINT stateBindPoint, XGL_DYNAMIC_STATE_OBJECT stateObject); |
Courtney Goeltzenleuchter | 69894b7 | 2015-04-03 15:25:24 -0600 | [diff] [blame] | 173 | void BeginRenderPass(XGL_RENDER_PASS renderpass, XGL_FRAMEBUFFER framebuffer); |
| 174 | void EndRenderPass(XGL_RENDER_PASS renderpass); |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 175 | void Draw(uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount); |
| 176 | void DrawIndexed(uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount); |
Courtney Goeltzenleuchter | 97b7523 | 2015-04-07 17:13:38 -0600 | [diff] [blame^] | 177 | void QueueCommandBuffer(); |
| 178 | |
| 179 | XglMemoryRefManager mem_ref_mgr; |
Tony Barbour | 6d047bf | 2014-12-10 14:34:45 -0700 | [diff] [blame] | 180 | |
| 181 | protected: |
| 182 | XglDevice *m_device; |
Tony Barbour | 30cc9e8 | 2014-12-17 11:53:55 -0700 | [diff] [blame] | 183 | vector<XglImage*> m_renderTargets; |
Tony Barbour | 6d047bf | 2014-12-10 14:34:45 -0700 | [diff] [blame] | 184 | }; |
| 185 | |
Chia-I Wu | 1a28fe0 | 2015-01-01 07:55:04 +0800 | [diff] [blame] | 186 | class XglConstantBufferObj : public xgl_testing::Buffer |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 187 | { |
| 188 | public: |
Courtney Goeltzenleuchter | 3b0a815 | 2014-12-04 15:18:47 -0700 | [diff] [blame] | 189 | XglConstantBufferObj(XglDevice *device); |
Tony Barbour | ac3692c | 2014-11-20 15:06:56 -0700 | [diff] [blame] | 190 | XglConstantBufferObj(XglDevice *device, int constantCount, int constantSize, const void* data); |
Tony Barbour | 044703b | 2015-03-26 12:37:52 -0600 | [diff] [blame] | 191 | ~XglConstantBufferObj(); |
Mike Stroyan | fb80d5f | 2014-12-04 11:08:39 +0000 | [diff] [blame] | 192 | void BufferMemoryBarrier( |
| 193 | XGL_FLAGS outputMask = |
| 194 | XGL_MEMORY_OUTPUT_CPU_WRITE_BIT | |
| 195 | XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT | |
| 196 | XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT | |
| 197 | XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT | |
| 198 | XGL_MEMORY_OUTPUT_COPY_BIT, |
| 199 | XGL_FLAGS inputMask = |
| 200 | XGL_MEMORY_INPUT_CPU_READ_BIT | |
| 201 | XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT | |
| 202 | XGL_MEMORY_INPUT_INDEX_FETCH_BIT | |
| 203 | XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT | |
| 204 | XGL_MEMORY_INPUT_UNIFORM_READ_BIT | |
| 205 | XGL_MEMORY_INPUT_SHADER_READ_BIT | |
| 206 | XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT | |
| 207 | XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT | |
| 208 | XGL_MEMORY_INPUT_COPY_BIT); |
| 209 | |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 210 | 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] | 211 | |
| 212 | XGL_BUFFER_VIEW_ATTACH_INFO m_bufferViewInfo; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 213 | |
| 214 | protected: |
Tony Barbour | ac3692c | 2014-11-20 15:06:56 -0700 | [diff] [blame] | 215 | XglDevice *m_device; |
Chia-I Wu | 1a28fe0 | 2015-01-01 07:55:04 +0800 | [diff] [blame] | 216 | xgl_testing::BufferView m_bufferView; |
Tony Barbour | ac3692c | 2014-11-20 15:06:56 -0700 | [diff] [blame] | 217 | int m_numVertices; |
| 218 | int m_stride; |
Tony Barbour | 3842280 | 2014-12-10 14:36:31 -0700 | [diff] [blame] | 219 | XglCommandBufferObj *m_commandBuffer; |
Chia-I Wu | a07fee6 | 2014-12-28 15:26:08 +0800 | [diff] [blame] | 220 | xgl_testing::Fence m_fence; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 221 | }; |
Courtney Goeltzenleuchter | 8a78593 | 2014-12-04 15:24:05 -0700 | [diff] [blame] | 222 | |
| 223 | class XglIndexBufferObj : public XglConstantBufferObj |
| 224 | { |
| 225 | public: |
| 226 | XglIndexBufferObj(XglDevice *device); |
| 227 | void CreateAndInitBuffer(int numIndexes, XGL_INDEX_TYPE dataFormat, const void* data); |
| 228 | void Bind(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_SIZE offset); |
Tony Barbour | af1f919 | 2014-12-17 10:57:58 -0700 | [diff] [blame] | 229 | XGL_INDEX_TYPE GetIndexType(); |
Courtney Goeltzenleuchter | 8a78593 | 2014-12-04 15:24:05 -0700 | [diff] [blame] | 230 | |
| 231 | protected: |
| 232 | XGL_INDEX_TYPE m_indexType; |
| 233 | }; |
| 234 | |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 235 | class XglImage : public xgl_testing::Image |
| 236 | { |
| 237 | public: |
| 238 | XglImage(XglDevice *dev); |
Courtney Goeltzenleuchter | 97b7523 | 2015-04-07 17:13:38 -0600 | [diff] [blame^] | 239 | bool IsCompatible(XGL_FLAGS usage, XGL_FLAGS features); |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 240 | |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 241 | public: |
Courtney Goeltzenleuchter | 97b7523 | 2015-04-07 17:13:38 -0600 | [diff] [blame^] | 242 | void init(uint32_t w, uint32_t h, |
| 243 | XGL_FORMAT fmt, XGL_FLAGS usage, |
| 244 | XGL_IMAGE_TILING tiling=XGL_LINEAR_TILING); |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 245 | |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 246 | // void clear( CommandBuffer*, uint32_t[4] ); |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 247 | |
Mike Stroyan | fb80d5f | 2014-12-04 11:08:39 +0000 | [diff] [blame] | 248 | void layout( XGL_IMAGE_LAYOUT layout ) |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 249 | { |
Mike Stroyan | fb80d5f | 2014-12-04 11:08:39 +0000 | [diff] [blame] | 250 | m_imageInfo.layout = layout; |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 251 | } |
Courtney Goeltzenleuchter | 97b7523 | 2015-04-07 17:13:38 -0600 | [diff] [blame^] | 252 | |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 253 | XGL_GPU_MEMORY memory() const |
| 254 | { |
| 255 | const std::vector<XGL_GPU_MEMORY> mems = memories(); |
| 256 | return mems.empty() ? XGL_NULL_HANDLE : mems[0]; |
| 257 | } |
| 258 | |
Courtney Goeltzenleuchter | 97b7523 | 2015-04-07 17:13:38 -0600 | [diff] [blame^] | 259 | void ImageMemoryBarrier(XglCommandBufferObj *cmd, |
| 260 | XGL_IMAGE_ASPECT aspect, |
| 261 | XGL_FLAGS output_mask, |
| 262 | XGL_FLAGS input_mask, |
| 263 | XGL_IMAGE_LAYOUT image_layout); |
| 264 | |
| 265 | XGL_RESULT CopyImage(XglImage &src_image); |
| 266 | |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 267 | XGL_IMAGE image() const |
| 268 | { |
| 269 | return obj(); |
| 270 | } |
Courtney Goeltzenleuchter | 97b7523 | 2015-04-07 17:13:38 -0600 | [diff] [blame^] | 271 | |
Tony Barbour | 3c9a510 | 2015-04-02 11:51:17 -0600 | [diff] [blame] | 272 | XGL_COLOR_ATTACHMENT_VIEW targetView() |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 273 | { |
Tony Barbour | 3c9a510 | 2015-04-02 11:51:17 -0600 | [diff] [blame] | 274 | if (!m_targetView.initialized()) |
| 275 | { |
| 276 | XGL_COLOR_ATTACHMENT_VIEW_CREATE_INFO createView = { |
| 277 | XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO, |
| 278 | XGL_NULL_HANDLE, |
| 279 | obj(), |
| 280 | XGL_FMT_B8G8R8A8_UNORM, |
| 281 | 0, |
| 282 | 0, |
| 283 | 1 |
| 284 | }; |
| 285 | m_targetView.init(*m_device, createView); |
| 286 | } |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 287 | return m_targetView.obj(); |
| 288 | } |
| 289 | |
Courtney Goeltzenleuchter | 97b7523 | 2015-04-07 17:13:38 -0600 | [diff] [blame^] | 290 | void SetLayout(XglCommandBufferObj *cmd_buf, XGL_IMAGE_ASPECT aspect, XGL_IMAGE_LAYOUT image_layout); |
| 291 | |
Mike Stroyan | fb80d5f | 2014-12-04 11:08:39 +0000 | [diff] [blame] | 292 | XGL_IMAGE_LAYOUT layout() const |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 293 | { |
Mike Stroyan | fb80d5f | 2014-12-04 11:08:39 +0000 | [diff] [blame] | 294 | return ( XGL_IMAGE_LAYOUT )m_imageInfo.layout; |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 295 | } |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 296 | uint32_t width() const |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 297 | { |
| 298 | return extent().width; |
| 299 | } |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 300 | uint32_t height() const |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 301 | { |
| 302 | return extent().height; |
| 303 | } |
Tony Barbour | 84d448c | 2015-04-02 14:02:33 -0600 | [diff] [blame] | 304 | XglDevice* device() const |
| 305 | { |
| 306 | return m_device; |
| 307 | } |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 308 | |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 309 | XGL_RESULT MapMemory(void** ptr); |
Chia-I Wu | a6bc0ce | 2014-12-29 14:38:28 +0800 | [diff] [blame] | 310 | XGL_RESULT UnmapMemory(); |
| 311 | |
| 312 | protected: |
| 313 | XglDevice *m_device; |
| 314 | |
| 315 | xgl_testing::ColorAttachmentView m_targetView; |
| 316 | XGL_IMAGE_VIEW_ATTACH_INFO m_imageInfo; |
| 317 | }; |
| 318 | |
Tony Barbour | 5dc515d | 2015-04-01 17:47:06 -0600 | [diff] [blame] | 319 | class XglTextureObj : public XglImage |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 320 | { |
| 321 | public: |
Tony Barbour | ebc093f | 2015-04-01 16:38:10 -0600 | [diff] [blame] | 322 | XglTextureObj(XglDevice *device, uint32_t *colors = NULL); |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 323 | XGL_IMAGE_VIEW_ATTACH_INFO m_textureViewInfo; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 324 | |
Tony Barbour | ebc093f | 2015-04-01 16:38:10 -0600 | [diff] [blame] | 325 | |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 326 | protected: |
| 327 | XglDevice *m_device; |
Chia-I Wu | 13a3aa8 | 2014-12-28 15:55:09 +0800 | [diff] [blame] | 328 | xgl_testing::ImageView m_textureView; |
| 329 | XGL_GPU_SIZE m_rowPitch; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 330 | }; |
| 331 | |
Chia-I Wu | e9864b5 | 2014-12-28 16:32:24 +0800 | [diff] [blame] | 332 | class XglSamplerObj : public xgl_testing::Sampler |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 333 | { |
| 334 | public: |
| 335 | XglSamplerObj(XglDevice *device); |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 336 | |
| 337 | protected: |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 338 | XglDevice *m_device; |
| 339 | |
| 340 | }; |
| 341 | |
Chia-I Wu | 985ba16 | 2015-03-26 13:14:16 +0800 | [diff] [blame] | 342 | class XglDescriptorSetObj : public xgl_testing::DescriptorPool |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 343 | { |
| 344 | public: |
Tony Barbour | ac3692c | 2014-11-20 15:06:56 -0700 | [diff] [blame] | 345 | XglDescriptorSetObj(XglDevice *device); |
Chia-I Wu | 11078b0 | 2015-01-04 16:27:24 +0800 | [diff] [blame] | 346 | ~XglDescriptorSetObj(); |
| 347 | |
| 348 | int AppendDummy(); |
Courtney Goeltzenleuchter | 97b7523 | 2015-04-07 17:13:38 -0600 | [diff] [blame^] | 349 | int AppendBuffer(XGL_DESCRIPTOR_TYPE type, XglConstantBufferObj &constantBuffer); |
Chia-I Wu | 11078b0 | 2015-01-04 16:27:24 +0800 | [diff] [blame] | 350 | int AppendSamplerTexture(XglSamplerObj* sampler, XglTextureObj* texture); |
| 351 | void CreateXGLDescriptorSet(XglCommandBufferObj *cmdBuffer); |
| 352 | |
Chia-I Wu | 53f07d7 | 2015-03-28 15:23:55 +0800 | [diff] [blame] | 353 | XGL_DESCRIPTOR_SET GetDescriptorSetHandle() const; |
| 354 | XGL_DESCRIPTOR_SET_LAYOUT_CHAIN GetLayoutChain() const; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 355 | |
Courtney Goeltzenleuchter | 97b7523 | 2015-04-07 17:13:38 -0600 | [diff] [blame^] | 356 | XglMemoryRefManager mem_ref_mgr; |
| 357 | |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 358 | protected: |
Tony Barbour | ac3692c | 2014-11-20 15:06:56 -0700 | [diff] [blame] | 359 | XglDevice *m_device; |
Chia-I Wu | 11078b0 | 2015-01-04 16:27:24 +0800 | [diff] [blame] | 360 | vector<XGL_DESCRIPTOR_TYPE_COUNT> m_type_counts; |
Tony Barbour | ac3692c | 2014-11-20 15:06:56 -0700 | [diff] [blame] | 361 | int m_nextSlot; |
Chia-I Wu | 11078b0 | 2015-01-04 16:27:24 +0800 | [diff] [blame] | 362 | |
Chia-I Wu | 11078b0 | 2015-01-04 16:27:24 +0800 | [diff] [blame] | 363 | vector<XGL_UPDATE_BUFFERS> m_updateBuffers; |
| 364 | |
| 365 | vector<XGL_SAMPLER_IMAGE_VIEW_INFO> m_samplerTextureInfo; |
| 366 | vector<XGL_UPDATE_SAMPLER_TEXTURES> m_updateSamplerTextures; |
| 367 | |
| 368 | xgl_testing::DescriptorSetLayout m_layout; |
Chia-I Wu | 41126e5 | 2015-03-26 15:27:55 +0800 | [diff] [blame] | 369 | xgl_testing::DescriptorSetLayoutChain m_layout_chain; |
Chia-I Wu | 11078b0 | 2015-01-04 16:27:24 +0800 | [diff] [blame] | 370 | xgl_testing::DescriptorSet *m_set; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 371 | }; |
Tony Barbour | ac3692c | 2014-11-20 15:06:56 -0700 | [diff] [blame] | 372 | |
| 373 | |
Chia-I Wu | babc0fd | 2014-12-29 14:14:03 +0800 | [diff] [blame] | 374 | class XglShaderObj : public xgl_testing::Shader |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 375 | { |
| 376 | public: |
Tony Barbour | e2c58df | 2014-11-25 13:18:32 -0700 | [diff] [blame] | 377 | 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] | 378 | XGL_PIPELINE_SHADER_STAGE_CREATE_INFO* GetStageCreateInfo(); |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 379 | |
| 380 | protected: |
| 381 | XGL_PIPELINE_SHADER_STAGE_CREATE_INFO stage_info; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 382 | XGL_PIPELINE_SHADER_STAGE m_stage; |
| 383 | XglDevice *m_device; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 384 | |
| 385 | }; |
| 386 | |
Chia-I Wu | 2648d09 | 2014-12-29 14:24:14 +0800 | [diff] [blame] | 387 | class XglPipelineObj : public xgl_testing::Pipeline |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 388 | { |
| 389 | public: |
| 390 | XglPipelineObj(XglDevice *device); |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 391 | void AddShader(XglShaderObj* shaderObj); |
| 392 | void AddVertexInputAttribs(XGL_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION* vi_attrib, int count); |
| 393 | void AddVertexInputBindings(XGL_VERTEX_INPUT_BINDING_DESCRIPTION* vi_binding, int count); |
| 394 | void AddVertexDataBuffer(XglConstantBufferObj* vertexDataBuffer, int binding); |
Mark Lobodzinski | 17caf57 | 2015-01-29 08:55:56 -0600 | [diff] [blame] | 395 | void AddColorAttachment(uint32_t binding, const XGL_PIPELINE_CB_ATTACHMENT_STATE *att); |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 396 | void SetDepthStencil(XGL_PIPELINE_DS_STATE_CREATE_INFO *); |
Courtney Goeltzenleuchter | 97b7523 | 2015-04-07 17:13:38 -0600 | [diff] [blame^] | 397 | void CreateXGLPipeline(XglDescriptorSetObj &descriptorSet); |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 398 | |
| 399 | protected: |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 400 | XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO m_vi_state; |
| 401 | XGL_PIPELINE_IA_STATE_CREATE_INFO m_ia_state; |
| 402 | XGL_PIPELINE_RS_STATE_CREATE_INFO m_rs_state; |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 403 | XGL_PIPELINE_CB_STATE_CREATE_INFO m_cb_state; |
| 404 | XGL_PIPELINE_DS_STATE_CREATE_INFO m_ds_state; |
| 405 | XGL_PIPELINE_MS_STATE_CREATE_INFO m_ms_state; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 406 | XglDevice *m_device; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 407 | vector<XglShaderObj*> m_shaderObjs; |
| 408 | vector<XglConstantBufferObj*> m_vertexBufferObjs; |
| 409 | vector<int> m_vertexBufferBindings; |
Tony Barbour | f52346d | 2015-01-16 14:27:35 -0700 | [diff] [blame] | 410 | vector<XGL_PIPELINE_CB_ATTACHMENT_STATE> m_colorAttachments; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 411 | int m_vertexBufferCount; |
| 412 | |
| 413 | }; |
Tony Barbour | 9d951a0 | 2014-11-19 16:33:11 -0700 | [diff] [blame] | 414 | |
Courtney Goeltzenleuchter | a4b278b | 2014-10-08 08:50:49 -0600 | [diff] [blame] | 415 | #endif // XGLRENDERFRAMEWORK_H |