OLD | NEW |
(Empty) | |
| 1 |
| 2 /* |
| 3 * Copyright 2011 Google Inc. |
| 4 * |
| 5 * Use of this source code is governed by a BSD-style license that can be |
| 6 * found in the LICENSE file. |
| 7 */ |
| 8 |
| 9 |
| 10 #ifndef GrGeometryBuffer_DEFINED |
| 11 #define GrGeometryBuffer_DEFINED |
| 12 |
| 13 #include "GrGpuResource.h" |
| 14 |
| 15 class GrGpu; |
| 16 |
| 17 /** |
| 18 * Parent class for vertex and index buffers |
| 19 */ |
| 20 class GrGeometryBuffer : public GrGpuResource { |
| 21 public: |
| 22 |
| 23 |
| 24 /** |
| 25 *Retrieves whether the buffer was created with the dynamic flag |
| 26 * |
| 27 * @return true if the buffer was created with the dynamic flag |
| 28 */ |
| 29 bool dynamic() const { return fDynamic; } |
| 30 |
| 31 /** |
| 32 * Returns true if the buffer is a wrapper around a CPU array. If true it |
| 33 * indicates that map will always succeed and will be free. |
| 34 */ |
| 35 bool isCPUBacked() const { return fCPUBacked; } |
| 36 |
| 37 /** |
| 38 * Maps the buffer to be written by the CPU. |
| 39 * |
| 40 * The previous content of the buffer is invalidated. It is an error |
| 41 * to draw from the buffer while it is mapped. It is an error to call map |
| 42 * on an already mapped buffer. It may fail if the backend doesn't support |
| 43 * mapping the buffer. If the buffer is CPU backed then it will always |
| 44 * succeed and is a free operation. Must be matched by an unmap() call. |
| 45 * Currently only one map at a time is supported (no nesting of |
| 46 * map/unmap). |
| 47 * |
| 48 * Note that buffer mapping does not go through GrContext and therefore is |
| 49 * not serialized with other operations. |
| 50 * |
| 51 * @return a pointer to the data or nullptr if the map fails. |
| 52 */ |
| 53 void* map() { return (fMapPtr = this->onMap()); } |
| 54 |
| 55 /** |
| 56 * Unmaps the buffer. |
| 57 * |
| 58 * The pointer returned by the previous map call will no longer be valid. |
| 59 */ |
| 60 void unmap() { |
| 61 SkASSERT(fMapPtr); |
| 62 this->onUnmap(); |
| 63 fMapPtr = nullptr; |
| 64 } |
| 65 |
| 66 /** |
| 67 * Returns the same ptr that map() returned at time of map or nullptr if the |
| 68 * is not mapped. |
| 69 * |
| 70 * @return ptr to mapped buffer data or nullptr if buffer is not mapped. |
| 71 */ |
| 72 void* mapPtr() const { return fMapPtr; } |
| 73 |
| 74 /** |
| 75 Queries whether the buffer has been mapped. |
| 76 |
| 77 @return true if the buffer is mapped, false otherwise. |
| 78 */ |
| 79 bool isMapped() const { return SkToBool(fMapPtr); } |
| 80 |
| 81 /** |
| 82 * Updates the buffer data. |
| 83 * |
| 84 * The size of the buffer will be preserved. The src data will be |
| 85 * placed at the beginning of the buffer and any remaining contents will |
| 86 * be undefined. srcSizeInBytes must be <= to the buffer size. |
| 87 * |
| 88 * The buffer must not be mapped. |
| 89 * |
| 90 * Note that buffer updates do not go through GrContext and therefore are |
| 91 * not serialized with other operations. |
| 92 * |
| 93 * @return returns true if the update succeeds, false otherwise. |
| 94 */ |
| 95 bool updateData(const void* src, size_t srcSizeInBytes) { |
| 96 SkASSERT(!this->isMapped()); |
| 97 SkASSERT(srcSizeInBytes <= fGpuMemorySize); |
| 98 return this->onUpdateData(src, srcSizeInBytes); |
| 99 } |
| 100 |
| 101 protected: |
| 102 GrGeometryBuffer(GrGpu* gpu, size_t gpuMemorySize, bool dynamic, bool cpuBac
ked) |
| 103 : INHERITED(gpu, kCached_LifeCycle) |
| 104 , fMapPtr(nullptr) |
| 105 , fGpuMemorySize(gpuMemorySize) |
| 106 , fDynamic(dynamic) |
| 107 , fCPUBacked(cpuBacked) {} |
| 108 |
| 109 private: |
| 110 virtual size_t onGpuMemorySize() const { return fGpuMemorySize; } |
| 111 |
| 112 virtual void* onMap() = 0; |
| 113 virtual void onUnmap() = 0; |
| 114 virtual bool onUpdateData(const void* src, size_t srcSizeInBytes) = 0; |
| 115 |
| 116 void* fMapPtr; |
| 117 size_t fGpuMemorySize; |
| 118 bool fDynamic; |
| 119 bool fCPUBacked; |
| 120 |
| 121 typedef GrGpuResource INHERITED; |
| 122 }; |
| 123 |
| 124 #endif |
OLD | NEW |