diff options
Diffstat (limited to 'gpu/src/GrDrawTarget.cpp')
-rw-r--r-- | gpu/src/GrDrawTarget.cpp | 296 |
1 files changed, 296 insertions, 0 deletions
diff --git a/gpu/src/GrDrawTarget.cpp b/gpu/src/GrDrawTarget.cpp new file mode 100644 index 0000000000..82f94a35df --- /dev/null +++ b/gpu/src/GrDrawTarget.cpp @@ -0,0 +1,296 @@ +/* + Copyright 2010 Google Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + */ + + +#include "GrDrawTarget.h" +#include "GrGpuVertex.h" + +#define VERTEX_LAYOUT_ASSERTS \ + GrAssert(!(vertexLayout & kTextFormat_VertexLayoutBit) || \ + vertexLayout == kTextFormat_VertexLayoutBit); \ + GrAssert(!(vertexLayout & kSeparateTexCoord_VertexLayoutBit) || \ + !(vertexLayout & kPositionAsTexCoord_VertexLayoutBit)); + +size_t GrDrawTarget::VertexSize(GrVertexLayout vertexLayout) { + VERTEX_LAYOUT_ASSERTS + if ((vertexLayout & kTextFormat_VertexLayoutBit)) { + return 2 * sizeof(GrGpuTextVertex); + } else { + size_t size = sizeof(GrPoint); + if (vertexLayout & kSeparateTexCoord_VertexLayoutBit) { + size += sizeof(GrPoint); + } + if (vertexLayout & kColor_VertexLayoutBit) { + size += sizeof(GrColor); + } + return size; + } +} + +int GrDrawTarget::VertexTexCoordOffset(GrVertexLayout vertexLayout) { + VERTEX_LAYOUT_ASSERTS + if ((vertexLayout & kTextFormat_VertexLayoutBit)) { + return sizeof(GrGpuTextVertex); + } else if (vertexLayout & kSeparateTexCoord_VertexLayoutBit) { + return sizeof(GrPoint); + } else if (vertexLayout & kPositionAsTexCoord_VertexLayoutBit) { + return 0; + } + return -1; +} + +int GrDrawTarget::VertexColorOffset(GrVertexLayout vertexLayout) { + VERTEX_LAYOUT_ASSERTS + if (vertexLayout & kColor_VertexLayoutBit) { + if (vertexLayout & kSeparateTexCoord_VertexLayoutBit) { + return 2 * sizeof(GrPoint); + } else { + return sizeof(GrPoint); + } + } + return -1; +} + +int GrDrawTarget::VertexSizeAndOffsets(GrVertexLayout vertexLayout, + int* texCoordOffset, + int* colorOffset) { + VERTEX_LAYOUT_ASSERTS + + GrAssert(NULL != texCoordOffset); + GrAssert(NULL != colorOffset); + + if ((vertexLayout & kTextFormat_VertexLayoutBit)) { + *texCoordOffset = sizeof(GrGpuTextVertex); + *colorOffset = 0; + return 2 * sizeof(GrGpuTextVertex); + } else { + size_t size = sizeof(GrPoint); + if (vertexLayout & kSeparateTexCoord_VertexLayoutBit) { + *texCoordOffset = sizeof(GrPoint); + size += sizeof(GrPoint); + } else if (vertexLayout & kPositionAsTexCoord_VertexLayoutBit) { + *texCoordOffset = 0; + } else { + *texCoordOffset = -1; + } + if (vertexLayout & kColor_VertexLayoutBit) { + *colorOffset = size; + size += sizeof(GrColor); + } else { + *colorOffset = -1; + } + return size; + } +} + +bool GrDrawTarget::VertexHasTexCoords(GrVertexLayout vertexLayout) { + return !!(vertexLayout & (kSeparateTexCoord_VertexLayoutBit | + kPositionAsTexCoord_VertexLayoutBit | + kTextFormat_VertexLayoutBit)); +} + +//////////////////////////////////////////////////////////////////////////////// + +GrDrawTarget::GrDrawTarget() { + fReservedGeometry.fLocked = false; +#if GR_DEBUG + fReservedGeometry.fVertexCount = ~0; + fReservedGeometry.fIndexCount = ~0; +#endif + fGeometrySrc.fVertexSrc = kReserved_GeometrySrcType; + fGeometrySrc.fIndexSrc = kReserved_GeometrySrcType; +} + +void GrDrawTarget::setClip(const GrClip& clip) { + clipWillChange(clip); + fClip = clip; +} + +const GrClip& GrDrawTarget::getClip() const { + return fClip; +} + +void GrDrawTarget::setTexture(GrTexture* tex) { + fCurrDrawState.fTexture = tex; +} + +GrTexture* GrDrawTarget::currentTexture() const { + return fCurrDrawState.fTexture; +} + +void GrDrawTarget::setRenderTarget(GrRenderTarget* target) { + fCurrDrawState.fRenderTarget = target; +} + +GrRenderTarget* GrDrawTarget::currentRenderTarget() const { + return fCurrDrawState.fRenderTarget; +} + +void GrDrawTarget::concatViewMatrix(const GrMatrix& matrix) { + GrMatrix mv; + mv.setConcat(fCurrDrawState.fMatrixModeCache[kModelView_MatrixMode], matrix); + this->loadMatrix(mv, kModelView_MatrixMode); +} + +void GrDrawTarget::getViewMatrix(GrMatrix* matrix) const { + *matrix = fCurrDrawState.fMatrixModeCache[kModelView_MatrixMode]; +} + +bool GrDrawTarget::getViewInverse(GrMatrix* matrix) const { + // Can we cache this somewhere? + + GrMatrix inverse; + if (fCurrDrawState.fMatrixModeCache[kModelView_MatrixMode].invert(&inverse)) { + if (matrix) { + *matrix = inverse; + } + return true; + } + return false; +} + +void GrDrawTarget::setSamplerState(const GrSamplerState& state) { + fCurrDrawState.fSamplerState = state; +} + +void GrDrawTarget::setStencilPass(StencilPass pass) { + fCurrDrawState.fStencilPass = pass; +} + +void GrDrawTarget::setReverseFill(bool reverse) { + fCurrDrawState.fReverseFill = reverse; +} + +void GrDrawTarget::enableState(uint32_t bits) { + fCurrDrawState.fFlagBits |= bits; +} + +void GrDrawTarget::disableState(uint32_t bits) { + fCurrDrawState.fFlagBits &= ~(bits); +} + +void GrDrawTarget::loadMatrix(const GrMatrix& matrix, MatrixMode m) { + fCurrDrawState.fMatrixModeCache[m] = matrix; +} + +void GrDrawTarget::setPointSize(float size) { + fCurrDrawState.fPointSize = size; +} + +void GrDrawTarget::setBlendFunc(BlendCoeff srcCoef, + BlendCoeff dstCoef) { + fCurrDrawState.fSrcBlend = srcCoef; + fCurrDrawState.fDstBlend = dstCoef; +} + +void GrDrawTarget::setColor(GrColor c) { + fCurrDrawState.fColor = c; +} + +void GrDrawTarget::setAlpha(uint8_t a) { + this->setColor((a << 24) | (a << 16) | (a << 8) | a); +} + +void GrDrawTarget::saveCurrentDrawState(SavedDrawState* state) const { + state->fState = fCurrDrawState; +} + +void GrDrawTarget::restoreDrawState(const SavedDrawState& state) { + fCurrDrawState = state.fState; +} + +void GrDrawTarget::copyDrawState(const GrDrawTarget& srcTarget) { + fCurrDrawState = srcTarget.fCurrDrawState; +} + + +bool GrDrawTarget::reserveAndLockGeometry(GrVertexLayout vertexLayout, + uint32_t vertexCount, + uint32_t indexCount, + void** vertices, + void** indices) { + GrAssert(!fReservedGeometry.fLocked); + fReservedGeometry.fVertexCount = vertexCount; + fReservedGeometry.fIndexCount = indexCount; + + fReservedGeometry.fLocked = acquireGeometryHelper(vertexLayout, + vertices, + indices); + if (fReservedGeometry.fLocked) { + if (vertexCount) { + fGeometrySrc.fVertexSrc = kReserved_GeometrySrcType; + fGeometrySrc.fVertexLayout = vertexLayout; + } + if (indexCount) { + fGeometrySrc.fIndexSrc = kReserved_GeometrySrcType; + } + } + return fReservedGeometry.fLocked; +} + +bool GrDrawTarget::geometryHints(GrVertexLayout vertexLayout, + int32_t* vertexCount, + int32_t* indexCount) const { + GrAssert(!fReservedGeometry.fLocked); + if (NULL != vertexCount) { + *vertexCount = -1; + } + if (NULL != indexCount) { + *indexCount = -1; + } + return false; +} + +void GrDrawTarget::releaseReservedGeometry() { + GrAssert(fReservedGeometry.fLocked); + releaseGeometryHelper(); + fReservedGeometry.fLocked = false; +} + +void GrDrawTarget::setVertexSourceToArray(const void* array, + GrVertexLayout vertexLayout) { + fGeometrySrc.fVertexSrc = kArray_GeometrySrcType; + fGeometrySrc.fVertexArray = array; + fGeometrySrc.fVertexLayout = vertexLayout; +} + +void GrDrawTarget::setIndexSourceToArray(const void* array) { + fGeometrySrc.fIndexSrc = kArray_GeometrySrcType; + fGeometrySrc.fIndexArray = array; +} + +void GrDrawTarget::setVertexSourceToBuffer(const GrVertexBuffer* buffer, + GrVertexLayout vertexLayout) { + fGeometrySrc.fVertexSrc = kBuffer_GeometrySrcType; + fGeometrySrc.fVertexBuffer = buffer; + fGeometrySrc.fVertexLayout = vertexLayout; +} + +void GrDrawTarget::setIndexSourceToBuffer(const GrIndexBuffer* buffer) { + fGeometrySrc.fIndexSrc = kBuffer_GeometrySrcType; + fGeometrySrc.fIndexBuffer = buffer; +} + +//////////////////////////////////////////////////////////////////////////////// + +GrDrawTarget::AutoStateRestore::AutoStateRestore(GrDrawTarget* target) { + fDrawTarget = target; + fDrawTarget->saveCurrentDrawState(&fDrawState); +} + +GrDrawTarget::AutoStateRestore::~AutoStateRestore() { + fDrawTarget->restoreDrawState(fDrawState); +} |