void NetworkObject::drawNetwork(float pnear, float pfar, bool backToFront) { if (backToFront) { if (m_Eopacity > 0.01) drawEdges(pnear, pfar); if (m_Vopacity > 0.01) drawVertices(pnear, pfar); } else { if (m_Vopacity > 0.01) drawVertices(pnear, pfar); if (m_Eopacity > 0.01) drawEdges(pnear, pfar); } }
// Draw vertices UINT STDMETHODCALLTYPE CFW1GlyphVertexDrawer::DrawVertices( ID3D11DeviceContext *pContext, IFW1GlyphAtlas *pGlyphAtlas, const FW1_VERTEXDATA *pVertexData, UINT Flags, UINT PreboundSheet ) { UINT stride; UINT offset = 0; if((Flags & FW1_NOGEOMETRYSHADER) == 0) stride = sizeof(FW1_GLYPHVERTEX); else { stride = sizeof(QuadVertex); if((Flags & FW1_BUFFERSPREPARED) == 0) pContext->IASetIndexBuffer(m_pIndexBuffer, DXGI_FORMAT_R16_UINT, 0); } if((Flags & FW1_BUFFERSPREPARED) == 0) pContext->IASetVertexBuffers(0, 1, &m_pVertexBuffer, &stride, &offset); if((Flags & FW1_NOGEOMETRYSHADER) == 0) return drawVertices(pContext, pGlyphAtlas, pVertexData, PreboundSheet); else return drawGlyphsAsQuads(pContext, pGlyphAtlas, pVertexData, PreboundSheet); }
/* override */ void apiSimpleShapeUI::draw( const MDrawRequest & request, M3dView & view ) const // // Description: // // Main (OpenGL) draw routine // // Arguments: // // request - request to be drawn // view - view to draw into // { // Get the token from the draw request. // The token specifies what needs to be drawn. // int token = request.token(); switch( token ) { case kDrawWireframe : case kDrawWireframeOnShaded : case kDrawVertices : drawVertices( request, view ); break; case kDrawSmoothShaded : break; // Not implemented, left as exercise case kDrawFlatShaded : // Not implemented, left as exercise break; } }
void WarpPosShader::drawVertices(GLenum mode, const Eigen::Vector2f *vertices, int count, const Eigen::Vector4f &color) { std::vector<Eigen::Vector4f> colors; colors.resize(count, color); drawVertices(mode, vertices, colors.data(), count); }
namespace SkRecords { bool Draw::skip(const PairedPushCull& r) { if (fCanvas->quickReject(r.base->rect)) { fIndex += r.skip; return true; } return false; } bool Draw::skip(const BoundedDrawPosTextH& r) { return fCanvas->quickRejectY(r.minY, r.maxY); } // NoOps draw nothing. template <> void Draw::draw(const NoOp&) {} #define DRAW(T, call) template <> void Draw::draw(const T& r) { fCanvas->call; } DRAW(Restore, restore()); DRAW(Save, save(r.flags)); DRAW(SaveLayer, saveLayer(r.bounds, r.paint, r.flags)); DRAW(PopCull, popCull()); DRAW(PushCull, pushCull(r.rect)); DRAW(Clear, clear(r.color)); DRAW(Concat, concat(r.matrix)); DRAW(SetMatrix, setMatrix(SkMatrix::Concat(fInitialCTM, r.matrix))); DRAW(ClipPath, clipPath(r.path, r.op, r.doAA)); DRAW(ClipRRect, clipRRect(r.rrect, r.op, r.doAA)); DRAW(ClipRect, clipRect(r.rect, r.op, r.doAA)); DRAW(ClipRegion, clipRegion(r.region, r.op)); DRAW(DrawBitmap, drawBitmap(r.bitmap, r.left, r.top, r.paint)); DRAW(DrawBitmapMatrix, drawBitmapMatrix(r.bitmap, r.matrix, r.paint)); DRAW(DrawBitmapNine, drawBitmapNine(r.bitmap, r.center, r.dst, r.paint)); DRAW(DrawBitmapRectToRect, drawBitmapRectToRect(r.bitmap, r.src, r.dst, r.paint, r.flags)); DRAW(DrawDRRect, drawDRRect(r.outer, r.inner, r.paint)); DRAW(DrawOval, drawOval(r.oval, r.paint)); DRAW(DrawPaint, drawPaint(r.paint)); DRAW(DrawPath, drawPath(r.path, r.paint)); DRAW(DrawPoints, drawPoints(r.mode, r.count, r.pts, r.paint)); DRAW(DrawPosText, drawPosText(r.text, r.byteLength, r.pos, r.paint)); DRAW(DrawPosTextH, drawPosTextH(r.text, r.byteLength, r.xpos, r.y, r.paint)); DRAW(DrawRRect, drawRRect(r.rrect, r.paint)); DRAW(DrawRect, drawRect(r.rect, r.paint)); DRAW(DrawSprite, drawSprite(r.bitmap, r.left, r.top, r.paint)); DRAW(DrawText, drawText(r.text, r.byteLength, r.x, r.y, r.paint)); DRAW(DrawTextOnPath, drawTextOnPath(r.text, r.byteLength, r.path, r.matrix, r.paint)); DRAW(DrawVertices, drawVertices(r.vmode, r.vertexCount, r.vertices, r.texs, r.colors, r.xmode.get(), r.indices, r.indexCount, r.paint)); #undef DRAW template <> void Draw::draw(const PairedPushCull& r) { this->draw(*r.base); } template <> void Draw::draw(const BoundedDrawPosTextH& r) { this->draw(*r.base); } } // namespace SkRecords
void draw(bool wireframe) { glPushMatrix(); glTranslatef(0.f,m_fHeight/2.f,0.f); if(wireframe) glBegin(GL_LINES); else glBegin(GL_TRIANGLE_FAN); drawVertices(); glEnd(); glPopMatrix(); }
void poShape3D::draw() { po::setColor(fillColor, appliedAlpha()); if(callListID != -1) glCallList(callListID); else if ( enableFill ) drawFaces(); else if ( strokeWidth != 0 ) drawWireframe(); else if ( enablePoints ) drawVertices(); }
int main() { InitGraphics(); SetWindowTitle("CS106 Pathfinder"); cout << "This masterful piece of work is a graph extravaganza!" << endl << "The main attractions include a lovely visual presentation of the graph" << endl << "along with an implementation of Dijkstra's shortest path algorithm and" << endl << "the computation of a minimal spanning tree. Enjoy!" << endl; Graph graph; Map<coordT> nodeCor; string loc1, loc2, image; image = loadGraphFile(graph, nodeCor); drawMap(graph, nodeCor); while (true) { int choice = promptForChoice(); switch (choice) { case 1: graph.clear(); nodeCor.clear(); image = loadGraphFile(graph, nodeCor); drawMap(graph, nodeCor); break; case 2: cout << endl; loc1 = getLocName("Click on starting location... ", nodeCor); loc2 = getLocName("Click on ending location... ", nodeCor); displayMinPath(graph, nodeCor, loc1, loc2); break; case 3: InitGraphics(); DrawNamedPicture(image); drawVertices(nodeCor); displayMST(graph, nodeCor); break; case 4: displayDomSet(graph, nodeCor); break; case 5: exit(0); } } return (0); }
namespace SkRecords { // FIXME: SkBitmaps are stateful, so we need to copy them to play back in multiple threads. static SkBitmap shallow_copy(const SkBitmap& bitmap) { return bitmap; } // NoOps draw nothing. template <> void Draw::draw(const NoOp&) {} #define DRAW(T, call) template <> void Draw::draw(const T& r) { fCanvas->call; } DRAW(Restore, restore()); DRAW(Save, save()); DRAW(SaveLayer, saveLayer(r.bounds, r.paint, r.flags)); DRAW(PopCull, popCull()); DRAW(PushCull, pushCull(r.rect)); DRAW(Clear, clear(r.color)); DRAW(Concat, concat(r.matrix)); DRAW(SetMatrix, setMatrix(SkMatrix::Concat(fInitialCTM, r.matrix))); DRAW(ClipPath, clipPath(r.path, r.op, r.doAA)); DRAW(ClipRRect, clipRRect(r.rrect, r.op, r.doAA)); DRAW(ClipRect, clipRect(r.rect, r.op, r.doAA)); DRAW(ClipRegion, clipRegion(r.region, r.op)); DRAW(DrawBitmap, drawBitmap(shallow_copy(r.bitmap), r.left, r.top, r.paint)); DRAW(DrawBitmapMatrix, drawBitmapMatrix(shallow_copy(r.bitmap), r.matrix, r.paint)); DRAW(DrawBitmapNine, drawBitmapNine(shallow_copy(r.bitmap), r.center, r.dst, r.paint)); DRAW(DrawBitmapRectToRect, drawBitmapRectToRect(shallow_copy(r.bitmap), r.src, r.dst, r.paint, r.flags)); DRAW(DrawDRRect, drawDRRect(r.outer, r.inner, r.paint)); DRAW(DrawOval, drawOval(r.oval, r.paint)); DRAW(DrawPaint, drawPaint(r.paint)); DRAW(DrawPath, drawPath(r.path, r.paint)); DRAW(DrawPatch, drawPatch(r.cubics, r.colors, r.texCoords, r.xmode.get(), r.paint)); DRAW(DrawPicture, drawPicture(r.picture, r.matrix, r.paint)); DRAW(DrawPoints, drawPoints(r.mode, r.count, r.pts, r.paint)); DRAW(DrawPosText, drawPosText(r.text, r.byteLength, r.pos, r.paint)); DRAW(DrawPosTextH, drawPosTextH(r.text, r.byteLength, r.xpos, r.y, r.paint)); DRAW(DrawRRect, drawRRect(r.rrect, r.paint)); DRAW(DrawRect, drawRect(r.rect, r.paint)); DRAW(DrawSprite, drawSprite(shallow_copy(r.bitmap), r.left, r.top, r.paint)); DRAW(DrawText, drawText(r.text, r.byteLength, r.x, r.y, r.paint)); DRAW(DrawTextOnPath, drawTextOnPath(r.text, r.byteLength, r.path, r.matrix, r.paint)); DRAW(DrawVertices, drawVertices(r.vmode, r.vertexCount, r.vertices, r.texs, r.colors, r.xmode.get(), r.indices, r.indexCount, r.paint)); #undef DRAW // This is an SkRecord visitor that fills an SkBBoxHierarchy. // // The interesting part here is how to calculate bounds for ops which don't // have intrinsic bounds. What is the bounds of a Save or a Translate? // // We answer this by thinking about a particular definition of bounds: if I // don't execute this op, pixels in this rectangle might draw incorrectly. So // the bounds of a Save, a Translate, a Restore, etc. are the union of the // bounds of Draw* ops that they might have an effect on. For any given // Save/Restore block, the bounds of the Save, the Restore, and any other // non-drawing ("control") ops inside are exactly the union of the bounds of // the drawing ops inside that block. // // To implement this, we keep a stack of active Save blocks. As we consume ops // inside the Save/Restore block, drawing ops are unioned with the bounds of // the block, and control ops are stashed away for later. When we finish the // block with a Restore, our bounds are complete, and we go back and fill them // in for all the control ops we stashed away. class FillBounds : SkNoncopyable { public: FillBounds(const SkRecord& record, SkBBoxHierarchy* bbh) : fBounds(record.count()) { // Calculate bounds for all ops. This won't go quite in order, so we'll need // to store the bounds separately then feed them in to the BBH later in order. fCTM.setIdentity(); for (fCurrentOp = 0; fCurrentOp < record.count(); fCurrentOp++) { record.visit<void>(fCurrentOp, *this); } // If we have any lingering unpaired Saves, simulate restores to make // sure all ops in those Save blocks have their bounds calculated. while (!fSaveStack.isEmpty()) { this->popSaveBlock(); } // Any control ops not part of any Save/Restore block draw everywhere. while (!fControlIndices.isEmpty()) { this->popControl(SkIRect::MakeLargest()); } // Finally feed all stored bounds into the BBH. They'll be returned in this order. SkASSERT(NULL != bbh); for (uintptr_t i = 0; i < record.count(); i++) { if (!fBounds[i].isEmpty()) { bbh->insert((void*)i, fBounds[i], true/*ok to defer*/); } } bbh->flushDeferredInserts(); } template <typename T> void operator()(const T& r) { this->updateCTM(r); this->trackBounds(r); } private: struct SaveBounds { int controlOps; // Number of control ops in this Save block, including the Save. SkIRect bounds; // Bounds of everything in the block. }; template <typename T> void updateCTM(const T&) { /* most ops don't change the CTM */ } void updateCTM(const Restore& r) { fCTM = r.matrix; } void updateCTM(const SetMatrix& r) { fCTM = r.matrix; } void updateCTM(const Concat& r) { fCTM.preConcat(r.matrix); } // The bounds of these ops must be calculated when we hit the Restore // from the bounds of the ops in the same Save block. void trackBounds(const Save&) { this->pushSaveBlock(); } // TODO: bounds of SaveLayer may be more complicated? void trackBounds(const SaveLayer&) { this->pushSaveBlock(); } void trackBounds(const Restore&) { fBounds[fCurrentOp] = this->popSaveBlock(); } void trackBounds(const Concat&) { this->pushControl(); } void trackBounds(const SetMatrix&) { this->pushControl(); } void trackBounds(const ClipRect&) { this->pushControl(); } void trackBounds(const ClipRRect&) { this->pushControl(); } void trackBounds(const ClipPath&) { this->pushControl(); } void trackBounds(const ClipRegion&) { this->pushControl(); } // For all other ops, we can calculate and store the bounds directly now. template <typename T> void trackBounds(const T& op) { fBounds[fCurrentOp] = this->bounds(op); this->updateSaveBounds(fBounds[fCurrentOp]); } // TODO: remove this trivially-safe default when done bounding all ops template <typename T> SkIRect bounds(const T&) { return SkIRect::MakeLargest(); } void pushSaveBlock() { // Starting a new Save block. Push a new entry to represent that. SaveBounds sb = { 0, SkIRect::MakeEmpty() }; fSaveStack.push(sb); this->pushControl(); } SkIRect popSaveBlock() { // We're done the Save block. Apply the block's bounds to all control ops inside it. SaveBounds sb; fSaveStack.pop(&sb); while (sb.controlOps --> 0) { this->popControl(sb.bounds); } // This whole Save block may be part another Save block. this->updateSaveBounds(sb.bounds); // If called from a real Restore (not a phony one for balance), it'll need the bounds. return sb.bounds; } void pushControl() { fControlIndices.push(fCurrentOp); if (!fSaveStack.isEmpty()) { fSaveStack.top().controlOps++; } } void popControl(const SkIRect& bounds) { fBounds[fControlIndices.top()] = bounds; fControlIndices.pop(); } void updateSaveBounds(const SkIRect& bounds) { // If we're in a Save block, expand its bounds to cover these bounds too. if (!fSaveStack.isEmpty()) { fSaveStack.top().bounds.join(bounds); } } SkIRect bounds(const NoOp&) { return SkIRect::MakeEmpty(); } // NoOps don't draw anywhere. SkAutoTMalloc<SkIRect> fBounds; // One for each op in the record. SkMatrix fCTM; unsigned fCurrentOp; SkTDArray<SaveBounds> fSaveStack; SkTDArray<unsigned> fControlIndices; }; } // namespace SkRecords
void Viewer::cb_redraw() { // Draw the faces with SSAO and everything else if (m_useSSAO && m_drawFaces) { CGoGNGLuint SSAOTexture = computeSSAO(); // Get and draw only SSAO results if (m_displayOnlySSAO) Utils::TextureSticker::StickTextureOnWholeScreen(SSAOTexture); // Use SSAO results with regular rendering else { // Render color and depth m_finalRenderFbo->Bind(); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); { // Simply render faces color and depth drawFaces(); } m_finalRenderFbo->Unbind(); // Merge color and SSAO m_colorAndSSAOMergeFbo->Bind(); glClear(GL_COLOR_BUFFER_BIT); { // Send textures to multiply shader m_multTexturesShader->bind(); m_multTexturesShader->setTexture1Unit(GL_TEXTURE0); m_multTexturesShader->activeTexture1(m_finalRenderFbo->GetColorTexId(0)); m_multTexturesShader->setTexture2Unit(GL_TEXTURE1); m_multTexturesShader->activeTexture2(SSAOTexture); m_multTexturesShader->unbind(); // Multiply textures together Utils::TextureSticker::DrawFullscreenQuadWithShader(m_multTexturesShader); } m_colorAndSSAOMergeFbo->Unbind(); // Get and draw color texture from merged SSAO and color Fbo into final render Fbo (we need to use the depth information to display everything else) m_finalRenderFbo->Bind(); glClear(GL_COLOR_BUFFER_BIT); { // Simply stick result texture on screen Utils::TextureSticker::StickTextureOnWholeScreen(m_colorAndSSAOMergeFbo->GetColorTexId(0)); // Now that we have depth *and* SSAO information, display everything else if(m_drawVertices) drawVertices(); if(m_drawEdges) drawEdges(); if(m_drawTopo) drawTopo(); if(m_drawNormals) drawNormals(); } m_finalRenderFbo->Unbind(); // Stick final render in main framebuffer Utils::TextureSticker::StickTextureOnWholeScreen(m_finalRenderFbo->GetColorTexId(0)); } } // Draw everything without SSAO else { if (m_drawFaces) drawFaces(); if(m_drawVertices) drawVertices(); if(m_drawEdges) drawEdges(); if(m_drawTopo) drawTopo(); if(m_drawNormals) drawNormals(); } // Check for OpenGL errors GLenum glError = glGetError(); if (glError != GL_NO_ERROR) std::cout << "GL error : " << gluErrorString(glError) << std::endl; }
namespace SkRecords { // NoOps draw nothing. template <> void Draw::draw(const NoOp&) {} #define DRAW(T, call) template <> void Draw::draw(const T& r) { fCanvas->call; } DRAW(Restore, restore()); DRAW(Save, save()); DRAW(SaveLayer, saveLayer(SkCanvas::SaveLayerRec(r.bounds, r.paint, r.backdrop.get(), r.saveLayerFlags))); DRAW(SetMatrix, setMatrix(SkMatrix::Concat(fInitialCTM, r.matrix))); DRAW(Concat, concat(r.matrix)); DRAW(Translate, translate(r.dx, r.dy)); DRAW(ClipPath, clipPath(r.path, r.opAA.op, r.opAA.aa)); DRAW(ClipRRect, clipRRect(r.rrect, r.opAA.op, r.opAA.aa)); DRAW(ClipRect, clipRect(r.rect, r.opAA.op, r.opAA.aa)); DRAW(ClipRegion, clipRegion(r.region, r.op)); #ifdef SK_EXPERIMENTAL_SHADOWING DRAW(TranslateZ, SkCanvas::translateZ(r.z)); #else template <> void Draw::draw(const TranslateZ& r) { } #endif DRAW(DrawArc, drawArc(r.oval, r.startAngle, r.sweepAngle, r.useCenter, r.paint)); DRAW(DrawDRRect, drawDRRect(r.outer, r.inner, r.paint)); DRAW(DrawImage, drawImage(r.image.get(), r.left, r.top, r.paint)); template <> void Draw::draw(const DrawImageLattice& r) { SkCanvas::Lattice lattice; lattice.fXCount = r.xCount; lattice.fXDivs = r.xDivs; lattice.fYCount = r.yCount; lattice.fYDivs = r.yDivs; lattice.fFlags = (0 == r.flagCount) ? nullptr : r.flags; lattice.fBounds = &r.src; fCanvas->drawImageLattice(r.image.get(), lattice, r.dst, r.paint); } DRAW(DrawImageRect, legacy_drawImageRect(r.image.get(), r.src, r.dst, r.paint, r.constraint)); DRAW(DrawImageNine, drawImageNine(r.image.get(), r.center, r.dst, r.paint)); DRAW(DrawOval, drawOval(r.oval, r.paint)); DRAW(DrawPaint, drawPaint(r.paint)); DRAW(DrawPath, drawPath(r.path, r.paint)); DRAW(DrawPatch, drawPatch(r.cubics, r.colors, r.texCoords, r.xmode, r.paint)); DRAW(DrawPicture, drawPicture(r.picture.get(), &r.matrix, r.paint)); #ifdef SK_EXPERIMENTAL_SHADOWING DRAW(DrawShadowedPicture, drawShadowedPicture(r.picture.get(), &r.matrix, r.paint, r.params)); #else template <> void Draw::draw(const DrawShadowedPicture& r) { } #endif DRAW(DrawPoints, drawPoints(r.mode, r.count, r.pts, r.paint)); DRAW(DrawPosText, drawPosText(r.text, r.byteLength, r.pos, r.paint)); DRAW(DrawPosTextH, drawPosTextH(r.text, r.byteLength, r.xpos, r.y, r.paint)); DRAW(DrawRRect, drawRRect(r.rrect, r.paint)); DRAW(DrawRect, drawRect(r.rect, r.paint)); DRAW(DrawRegion, drawRegion(r.region, r.paint)); DRAW(DrawText, drawText(r.text, r.byteLength, r.x, r.y, r.paint)); DRAW(DrawTextBlob, drawTextBlob(r.blob.get(), r.x, r.y, r.paint)); DRAW(DrawTextOnPath, drawTextOnPath(r.text, r.byteLength, r.path, &r.matrix, r.paint)); DRAW(DrawTextRSXform, drawTextRSXform(r.text, r.byteLength, r.xforms, r.cull, r.paint)); DRAW(DrawAtlas, drawAtlas(r.atlas.get(), r.xforms, r.texs, r.colors, r.count, r.mode, r.cull, r.paint)); DRAW(DrawVertices, drawVertices(r.vmode, r.vertexCount, r.vertices, r.texs, r.colors, r.xmode, r.indices, r.indexCount, r.paint)); DRAW(DrawAnnotation, drawAnnotation(r.rect, r.key.c_str(), r.value.get())); #undef DRAW template <> void Draw::draw(const DrawDrawable& r) { SkASSERT(r.index >= 0); SkASSERT(r.index < fDrawableCount); if (fDrawables) { SkASSERT(nullptr == fDrawablePicts); fCanvas->drawDrawable(fDrawables[r.index], r.matrix); } else { fCanvas->drawPicture(fDrawablePicts[r.index], r.matrix, nullptr); } } // This is an SkRecord visitor that fills an SkBBoxHierarchy. // // The interesting part here is how to calculate bounds for ops which don't // have intrinsic bounds. What is the bounds of a Save or a Translate? // // We answer this by thinking about a particular definition of bounds: if I // don't execute this op, pixels in this rectangle might draw incorrectly. So // the bounds of a Save, a Translate, a Restore, etc. are the union of the // bounds of Draw* ops that they might have an effect on. For any given // Save/Restore block, the bounds of the Save, the Restore, and any other // non-drawing ("control") ops inside are exactly the union of the bounds of // the drawing ops inside that block. // // To implement this, we keep a stack of active Save blocks. As we consume ops // inside the Save/Restore block, drawing ops are unioned with the bounds of // the block, and control ops are stashed away for later. When we finish the // block with a Restore, our bounds are complete, and we go back and fill them // in for all the control ops we stashed away. class FillBounds : SkNoncopyable { public: FillBounds(const SkRect& cullRect, const SkRecord& record, SkRect bounds[]) : fNumRecords(record.count()) , fCullRect(cullRect) , fBounds(bounds) { fCTM = SkMatrix::I(); fCurrentClipBounds = fCullRect; } void cleanUp() { // If we have any lingering unpaired Saves, simulate restores to make // sure all ops in those Save blocks have their bounds calculated. while (!fSaveStack.isEmpty()) { this->popSaveBlock(); } // Any control ops not part of any Save/Restore block draw everywhere. while (!fControlIndices.isEmpty()) { this->popControl(fCullRect); } } void setCurrentOp(int currentOp) { fCurrentOp = currentOp; } template <typename T> void operator()(const T& op) { this->updateCTM(op); this->updateClipBounds(op); this->trackBounds(op); } // In this file, SkRect are in local coordinates, Bounds are translated back to identity space. typedef SkRect Bounds; int currentOp() const { return fCurrentOp; } const SkMatrix& ctm() const { return fCTM; } const Bounds& getBounds(int index) const { return fBounds[index]; } // Adjust rect for all paints that may affect its geometry, then map it to identity space. Bounds adjustAndMap(SkRect rect, const SkPaint* paint) const { // Inverted rectangles really confuse our BBHs. rect.sort(); // Adjust the rect for its own paint. if (!AdjustForPaint(paint, &rect)) { // The paint could do anything to our bounds. The only safe answer is the current clip. return fCurrentClipBounds; } // Adjust rect for all the paints from the SaveLayers we're inside. if (!this->adjustForSaveLayerPaints(&rect)) { // Same deal as above. return fCurrentClipBounds; } // Map the rect back to identity space. fCTM.mapRect(&rect); // Nothing can draw outside the current clip. if (!rect.intersect(fCurrentClipBounds)) { return Bounds::MakeEmpty(); } return rect; } private: struct SaveBounds { int controlOps; // Number of control ops in this Save block, including the Save. Bounds bounds; // Bounds of everything in the block. const SkPaint* paint; // Unowned. If set, adjusts the bounds of all ops in this block. SkMatrix ctm; }; // Only Restore, SetMatrix, Concat, and Translate change the CTM. template <typename T> void updateCTM(const T&) {} void updateCTM(const Restore& op) { fCTM = op.matrix; } void updateCTM(const SetMatrix& op) { fCTM = op.matrix; } void updateCTM(const Concat& op) { fCTM.preConcat(op.matrix); } void updateCTM(const Translate& op) { fCTM.preTranslate(op.dx, op.dy); } // Most ops don't change the clip. template <typename T> void updateClipBounds(const T&) {} // Clip{Path,RRect,Rect,Region} obviously change the clip. They all know their bounds already. void updateClipBounds(const ClipPath& op) { this->updateClipBoundsForClipOp(op.devBounds); } void updateClipBounds(const ClipRRect& op) { this->updateClipBoundsForClipOp(op.devBounds); } void updateClipBounds(const ClipRect& op) { this->updateClipBoundsForClipOp(op.devBounds); } void updateClipBounds(const ClipRegion& op) { this->updateClipBoundsForClipOp(op.devBounds); } // The bounds of clip ops need to be adjusted for the paints of saveLayers they're inside. void updateClipBoundsForClipOp(const SkIRect& devBounds) { Bounds clip = SkRect::Make(devBounds); // We don't call adjustAndMap() because as its last step it would intersect the adjusted // clip bounds with the previous clip, exactly what we can't do when the clip grows. if (this->adjustForSaveLayerPaints(&clip)) { fCurrentClipBounds = clip.intersect(fCullRect) ? clip : Bounds::MakeEmpty(); } else { fCurrentClipBounds = fCullRect; } } // Restore holds the devBounds for the clip after the {save,saveLayer}/restore block completes. void updateClipBounds(const Restore& op) { // This is just like the clip ops above, but we need to skip the effects (if any) of our // paired saveLayer (if it is one); it has not yet been popped off the save stack. Our // devBounds reflect the state of the world after the saveLayer/restore block is done, // so they are not affected by the saveLayer's paint. const int kSavesToIgnore = 1; Bounds clip = SkRect::Make(op.devBounds); if (this->adjustForSaveLayerPaints(&clip, kSavesToIgnore)) { fCurrentClipBounds = clip.intersect(fCullRect) ? clip : Bounds::MakeEmpty(); } else { fCurrentClipBounds = fCullRect; } } // We also take advantage of SaveLayer bounds when present to further cut the clip down. void updateClipBounds(const SaveLayer& op) { if (op.bounds) { // adjustAndMap() intersects these layer bounds with the previous clip for us. fCurrentClipBounds = this->adjustAndMap(*op.bounds, op.paint); } } // The bounds of these ops must be calculated when we hit the Restore // from the bounds of the ops in the same Save block. void trackBounds(const Save&) { this->pushSaveBlock(nullptr); } void trackBounds(const SaveLayer& op) { this->pushSaveBlock(op.paint); } void trackBounds(const Restore&) { fBounds[fCurrentOp] = this->popSaveBlock(); } void trackBounds(const SetMatrix&) { this->pushControl(); } void trackBounds(const Concat&) { this->pushControl(); } void trackBounds(const Translate&) { this->pushControl(); } void trackBounds(const TranslateZ&) { this->pushControl(); } void trackBounds(const ClipRect&) { this->pushControl(); } void trackBounds(const ClipRRect&) { this->pushControl(); } void trackBounds(const ClipPath&) { this->pushControl(); } void trackBounds(const ClipRegion&) { this->pushControl(); } // For all other ops, we can calculate and store the bounds directly now. template <typename T> void trackBounds(const T& op) { fBounds[fCurrentOp] = this->bounds(op); this->updateSaveBounds(fBounds[fCurrentOp]); } void pushSaveBlock(const SkPaint* paint) { // Starting a new Save block. Push a new entry to represent that. SaveBounds sb; sb.controlOps = 0; // If the paint affects transparent black, the bound shouldn't be smaller // than the current clip bounds. sb.bounds = PaintMayAffectTransparentBlack(paint) ? fCurrentClipBounds : Bounds::MakeEmpty(); sb.paint = paint; sb.ctm = this->fCTM; fSaveStack.push(sb); this->pushControl(); } static bool PaintMayAffectTransparentBlack(const SkPaint* paint) { if (paint) { // FIXME: this is very conservative if (paint->getImageFilter() || paint->getColorFilter()) { return true; } // Unusual blendmodes require us to process a saved layer // even with operations outisde the clip. // For example, DstIn is used by masking layers. // https://code.google.com/p/skia/issues/detail?id=1291 // https://crbug.com/401593 switch (paint->getBlendMode()) { // For each of the following transfer modes, if the source // alpha is zero (our transparent black), the resulting // blended alpha is not necessarily equal to the original // destination alpha. case SkBlendMode::kClear: case SkBlendMode::kSrc: case SkBlendMode::kSrcIn: case SkBlendMode::kDstIn: case SkBlendMode::kSrcOut: case SkBlendMode::kDstATop: case SkBlendMode::kModulate: return true; break; default: break; } } return false; } Bounds popSaveBlock() { // We're done the Save block. Apply the block's bounds to all control ops inside it. SaveBounds sb; fSaveStack.pop(&sb); while (sb.controlOps --> 0) { this->popControl(sb.bounds); } // This whole Save block may be part another Save block. this->updateSaveBounds(sb.bounds); // If called from a real Restore (not a phony one for balance), it'll need the bounds. return sb.bounds; } void pushControl() { fControlIndices.push(fCurrentOp); if (!fSaveStack.isEmpty()) { fSaveStack.top().controlOps++; } } void popControl(const Bounds& bounds) { fBounds[fControlIndices.top()] = bounds; fControlIndices.pop(); } void updateSaveBounds(const Bounds& bounds) { // If we're in a Save block, expand its bounds to cover these bounds too. if (!fSaveStack.isEmpty()) { fSaveStack.top().bounds.join(bounds); } } // FIXME: this method could use better bounds Bounds bounds(const DrawText&) const { return fCurrentClipBounds; } Bounds bounds(const DrawPaint&) const { return fCurrentClipBounds; } Bounds bounds(const NoOp&) const { return Bounds::MakeEmpty(); } // NoOps don't draw. Bounds bounds(const DrawRect& op) const { return this->adjustAndMap(op.rect, &op.paint); } Bounds bounds(const DrawRegion& op) const { SkRect rect = SkRect::Make(op.region.getBounds()); return this->adjustAndMap(rect, &op.paint); } Bounds bounds(const DrawOval& op) const { return this->adjustAndMap(op.oval, &op.paint); } // Tighter arc bounds? Bounds bounds(const DrawArc& op) const { return this->adjustAndMap(op.oval, &op.paint); } Bounds bounds(const DrawRRect& op) const { return this->adjustAndMap(op.rrect.rect(), &op.paint); } Bounds bounds(const DrawDRRect& op) const { return this->adjustAndMap(op.outer.rect(), &op.paint); } Bounds bounds(const DrawImage& op) const { const SkImage* image = op.image.get(); SkRect rect = SkRect::MakeXYWH(op.left, op.top, image->width(), image->height()); return this->adjustAndMap(rect, op.paint); } Bounds bounds(const DrawImageLattice& op) const { return this->adjustAndMap(op.dst, op.paint); } Bounds bounds(const DrawImageRect& op) const { return this->adjustAndMap(op.dst, op.paint); } Bounds bounds(const DrawImageNine& op) const { return this->adjustAndMap(op.dst, op.paint); } Bounds bounds(const DrawPath& op) const { return op.path.isInverseFillType() ? fCurrentClipBounds : this->adjustAndMap(op.path.getBounds(), &op.paint); } Bounds bounds(const DrawPoints& op) const { SkRect dst; dst.set(op.pts, op.count); // Pad the bounding box a little to make sure hairline points' bounds aren't empty. SkScalar stroke = SkMaxScalar(op.paint.getStrokeWidth(), 0.01f); dst.outset(stroke/2, stroke/2); return this->adjustAndMap(dst, &op.paint); } Bounds bounds(const DrawPatch& op) const { SkRect dst; dst.set(op.cubics, SkPatchUtils::kNumCtrlPts); return this->adjustAndMap(dst, &op.paint); } Bounds bounds(const DrawVertices& op) const { SkRect dst; dst.set(op.vertices, op.vertexCount); return this->adjustAndMap(dst, &op.paint); } Bounds bounds(const DrawAtlas& op) const { if (op.cull) { // TODO: <reed> can we pass nullptr for the paint? Isn't cull already "correct" // for the paint (by the caller)? return this->adjustAndMap(*op.cull, op.paint); } else { return fCurrentClipBounds; } } Bounds bounds(const DrawPicture& op) const { SkRect dst = op.picture->cullRect(); op.matrix.mapRect(&dst); return this->adjustAndMap(dst, op.paint); } Bounds bounds(const DrawShadowedPicture& op) const { SkRect dst = op.picture->cullRect(); op.matrix.mapRect(&dst); return this->adjustAndMap(dst, op.paint); } Bounds bounds(const DrawPosText& op) const { const int N = op.paint.countText(op.text, op.byteLength); if (N == 0) { return Bounds::MakeEmpty(); } SkRect dst; dst.set(op.pos, N); AdjustTextForFontMetrics(&dst, op.paint); return this->adjustAndMap(dst, &op.paint); } Bounds bounds(const DrawPosTextH& op) const { const int N = op.paint.countText(op.text, op.byteLength); if (N == 0) { return Bounds::MakeEmpty(); } SkScalar left = op.xpos[0], right = op.xpos[0]; for (int i = 1; i < N; i++) { left = SkMinScalar(left, op.xpos[i]); right = SkMaxScalar(right, op.xpos[i]); } SkRect dst = { left, op.y, right, op.y }; AdjustTextForFontMetrics(&dst, op.paint); return this->adjustAndMap(dst, &op.paint); } Bounds bounds(const DrawTextOnPath& op) const { SkRect dst = op.path.getBounds(); // Pad all sides by the maximum padding in any direction we'd normally apply. SkRect pad = { 0, 0, 0, 0}; AdjustTextForFontMetrics(&pad, op.paint); // That maximum padding happens to always be the right pad today. SkASSERT(pad.fLeft == -pad.fRight); SkASSERT(pad.fTop == -pad.fBottom); SkASSERT(pad.fRight > pad.fBottom); dst.outset(pad.fRight, pad.fRight); return this->adjustAndMap(dst, &op.paint); } Bounds bounds(const DrawTextRSXform& op) const { if (op.cull) { return this->adjustAndMap(*op.cull, nullptr); } else { return fCurrentClipBounds; } } Bounds bounds(const DrawTextBlob& op) const { SkRect dst = op.blob->bounds(); dst.offset(op.x, op.y); return this->adjustAndMap(dst, &op.paint); } Bounds bounds(const DrawDrawable& op) const { return this->adjustAndMap(op.worstCaseBounds, nullptr); } Bounds bounds(const DrawAnnotation& op) const { return this->adjustAndMap(op.rect, nullptr); } static void AdjustTextForFontMetrics(SkRect* rect, const SkPaint& paint) { #ifdef SK_DEBUG SkRect correct = *rect; #endif // crbug.com/373785 ~~> xPad = 4x yPad // crbug.com/424824 ~~> bump yPad from 2x text size to 2.5x const SkScalar yPad = 2.5f * paint.getTextSize(), xPad = 4.0f * yPad; rect->outset(xPad, yPad); #ifdef SK_DEBUG SkPaint::FontMetrics metrics; paint.getFontMetrics(&metrics); correct.fLeft += metrics.fXMin; correct.fTop += metrics.fTop; correct.fRight += metrics.fXMax; correct.fBottom += metrics.fBottom; // See skia:2862 for why we ignore small text sizes. SkASSERTF(paint.getTextSize() < 0.001f || rect->contains(correct), "%f %f %f %f vs. %f %f %f %f\n", -xPad, -yPad, +xPad, +yPad, metrics.fXMin, metrics.fTop, metrics.fXMax, metrics.fBottom); #endif } // Returns true if rect was meaningfully adjusted for the effects of paint, // false if the paint could affect the rect in unknown ways. static bool AdjustForPaint(const SkPaint* paint, SkRect* rect) { if (paint) { if (paint->canComputeFastBounds()) { *rect = paint->computeFastBounds(*rect, rect); return true; } return false; } return true; } bool adjustForSaveLayerPaints(SkRect* rect, int savesToIgnore = 0) const { for (int i = fSaveStack.count() - 1 - savesToIgnore; i >= 0; i--) { SkMatrix inverse; if (!fSaveStack[i].ctm.invert(&inverse)) { return false; } inverse.mapRect(rect); if (!AdjustForPaint(fSaveStack[i].paint, rect)) { return false; } fSaveStack[i].ctm.mapRect(rect); } return true; } const int fNumRecords; // We do not guarantee anything for operations outside of the cull rect const SkRect fCullRect; // Conservative identity-space bounds for each op in the SkRecord. Bounds* fBounds; // We walk fCurrentOp through the SkRecord, as we go using updateCTM() // and updateClipBounds() to maintain the exact CTM (fCTM) and conservative // identity-space bounds of the current clip (fCurrentClipBounds). int fCurrentOp; SkMatrix fCTM; Bounds fCurrentClipBounds; // Used to track the bounds of Save/Restore blocks and the control ops inside them. SkTDArray<SaveBounds> fSaveStack; SkTDArray<int> fControlIndices; }; } // namespace SkRecords
namespace SkRecords { // FIXME: SkBitmaps are stateful, so we need to copy them to play back in multiple threads. static SkBitmap shallow_copy(const SkBitmap& bitmap) { return bitmap; } // NoOps draw nothing. template <> void Draw::draw(const NoOp&) {} #define DRAW(T, call) template <> void Draw::draw(const T& r) { fCanvas->call; } DRAW(Restore, restore()); DRAW(Save, save()); DRAW(SaveLayer, saveLayer(r.bounds, r.paint, r.flags)); DRAW(PopCull, popCull()); DRAW(PushCull, pushCull(r.rect)); DRAW(Clear, clear(r.color)); DRAW(SetMatrix, setMatrix(SkMatrix::Concat(fInitialCTM, r.matrix))); DRAW(ClipPath, clipPath(r.path, r.op, r.doAA)); DRAW(ClipRRect, clipRRect(r.rrect, r.op, r.doAA)); DRAW(ClipRect, clipRect(r.rect, r.op, r.doAA)); DRAW(ClipRegion, clipRegion(r.region, r.op)); DRAW(BeginCommentGroup, beginCommentGroup(r.description)); DRAW(AddComment, addComment(r.key, r.value)); DRAW(EndCommentGroup, endCommentGroup()); DRAW(DrawBitmap, drawBitmap(shallow_copy(r.bitmap), r.left, r.top, r.paint)); DRAW(DrawBitmapMatrix, drawBitmapMatrix(shallow_copy(r.bitmap), r.matrix, r.paint)); DRAW(DrawBitmapNine, drawBitmapNine(shallow_copy(r.bitmap), r.center, r.dst, r.paint)); DRAW(DrawBitmapRectToRect, drawBitmapRectToRect(shallow_copy(r.bitmap), r.src, r.dst, r.paint, r.flags)); DRAW(DrawDRRect, drawDRRect(r.outer, r.inner, r.paint)); DRAW(DrawImage, drawImage(r.image, r.left, r.top, r.paint)); DRAW(DrawImageRect, drawImageRect(r.image, r.src, r.dst, r.paint)); DRAW(DrawOval, drawOval(r.oval, r.paint)); DRAW(DrawPaint, drawPaint(r.paint)); DRAW(DrawPath, drawPath(r.path, r.paint)); DRAW(DrawPatch, drawPatch(r.cubics, r.colors, r.texCoords, r.xmode, r.paint)); DRAW(DrawPicture, drawPicture(r.picture, r.matrix, r.paint)); DRAW(DrawPoints, drawPoints(r.mode, r.count, r.pts, r.paint)); DRAW(DrawPosText, drawPosText(r.text, r.byteLength, r.pos, r.paint)); DRAW(DrawPosTextH, drawPosTextH(r.text, r.byteLength, r.xpos, r.y, r.paint)); DRAW(DrawRRect, drawRRect(r.rrect, r.paint)); DRAW(DrawRect, drawRect(r.rect, r.paint)); DRAW(DrawSprite, drawSprite(shallow_copy(r.bitmap), r.left, r.top, r.paint)); DRAW(DrawText, drawText(r.text, r.byteLength, r.x, r.y, r.paint)); DRAW(DrawTextBlob, drawTextBlob(r.blob, r.x, r.y, r.paint)); DRAW(DrawTextOnPath, drawTextOnPath(r.text, r.byteLength, r.path, r.matrix, r.paint)); DRAW(DrawVertices, drawVertices(r.vmode, r.vertexCount, r.vertices, r.texs, r.colors, r.xmode.get(), r.indices, r.indexCount, r.paint)); DRAW(DrawData, drawData(r.data, r.length)); #undef DRAW // This is an SkRecord visitor that fills an SkBBoxHierarchy. // // The interesting part here is how to calculate bounds for ops which don't // have intrinsic bounds. What is the bounds of a Save or a Translate? // // We answer this by thinking about a particular definition of bounds: if I // don't execute this op, pixels in this rectangle might draw incorrectly. So // the bounds of a Save, a Translate, a Restore, etc. are the union of the // bounds of Draw* ops that they might have an effect on. For any given // Save/Restore block, the bounds of the Save, the Restore, and any other // non-drawing ("control") ops inside are exactly the union of the bounds of // the drawing ops inside that block. // // To implement this, we keep a stack of active Save blocks. As we consume ops // inside the Save/Restore block, drawing ops are unioned with the bounds of // the block, and control ops are stashed away for later. When we finish the // block with a Restore, our bounds are complete, and we go back and fill them // in for all the control ops we stashed away. class FillBounds : SkNoncopyable { public: FillBounds(const SkRect& cullRect, const SkRecord& record, SkBBoxHierarchy* bbh) : fCullRect(cullRect) , fBounds(record.count()) { // Calculate bounds for all ops. This won't go quite in order, so we'll need // to store the bounds separately then feed them in to the BBH later in order. fCTM = &SkMatrix::I(); fCurrentClipBounds = fCullRect; for (fCurrentOp = 0; fCurrentOp < record.count(); fCurrentOp++) { record.visit<void>(fCurrentOp, *this); } // If we have any lingering unpaired Saves, simulate restores to make // sure all ops in those Save blocks have their bounds calculated. while (!fSaveStack.isEmpty()) { this->popSaveBlock(); } // Any control ops not part of any Save/Restore block draw everywhere. while (!fControlIndices.isEmpty()) { this->popControl(fCullRect); } // Finally feed all stored bounds into the BBH. They'll be returned in this order. SkASSERT(bbh); bbh->insert(&fBounds, record.count()); } template <typename T> void operator()(const T& op) { this->updateCTM(op); this->updateClipBounds(op); this->trackBounds(op); } private: // In this file, SkRect are in local coordinates, Bounds are translated back to identity space. typedef SkRect Bounds; struct SaveBounds { int controlOps; // Number of control ops in this Save block, including the Save. Bounds bounds; // Bounds of everything in the block. const SkPaint* paint; // Unowned. If set, adjusts the bounds of all ops in this block. }; // Only Restore and SetMatrix change the CTM. template <typename T> void updateCTM(const T&) {} void updateCTM(const Restore& op) { fCTM = &op.matrix; } void updateCTM(const SetMatrix& op) { fCTM = &op.matrix; } // Most ops don't change the clip. template <typename T> void updateClipBounds(const T&) {} // Clip{Path,RRect,Rect,Region} obviously change the clip. They all know their bounds already. void updateClipBounds(const ClipPath& op) { this->updateClipBoundsForClipOp(op.devBounds); } void updateClipBounds(const ClipRRect& op) { this->updateClipBoundsForClipOp(op.devBounds); } void updateClipBounds(const ClipRect& op) { this->updateClipBoundsForClipOp(op.devBounds); } void updateClipBounds(const ClipRegion& op) { this->updateClipBoundsForClipOp(op.devBounds); } // The bounds of clip ops need to be adjusted for the paints of saveLayers they're inside. void updateClipBoundsForClipOp(const SkIRect& devBounds) { Bounds clip = SkRect::Make(devBounds); // We don't call adjustAndMap() because as its last step it would intersect the adjusted // clip bounds with the previous clip, exactly what we can't do when the clip grows. fCurrentClipBounds = this->adjustForSaveLayerPaints(&clip) ? clip : fCullRect; } // Restore holds the devBounds for the clip after the {save,saveLayer}/restore block completes. void updateClipBounds(const Restore& op) { // This is just like the clip ops above, but we need to skip the effects (if any) of our // paired saveLayer (if it is one); it has not yet been popped off the save stack. Our // devBounds reflect the state of the world after the saveLayer/restore block is done, // so they are not affected by the saveLayer's paint. const int kSavesToIgnore = 1; Bounds clip = SkRect::Make(op.devBounds); fCurrentClipBounds = this->adjustForSaveLayerPaints(&clip, kSavesToIgnore) ? clip : fCullRect; } // We also take advantage of SaveLayer bounds when present to further cut the clip down. void updateClipBounds(const SaveLayer& op) { if (op.bounds) { // adjustAndMap() intersects these layer bounds with the previous clip for us. fCurrentClipBounds = this->adjustAndMap(*op.bounds, op.paint); } } // The bounds of these ops must be calculated when we hit the Restore // from the bounds of the ops in the same Save block. void trackBounds(const Save&) { this->pushSaveBlock(NULL); } void trackBounds(const SaveLayer& op) { this->pushSaveBlock(op.paint); } void trackBounds(const Restore&) { fBounds[fCurrentOp] = this->popSaveBlock(); } void trackBounds(const SetMatrix&) { this->pushControl(); } void trackBounds(const ClipRect&) { this->pushControl(); } void trackBounds(const ClipRRect&) { this->pushControl(); } void trackBounds(const ClipPath&) { this->pushControl(); } void trackBounds(const ClipRegion&) { this->pushControl(); } void trackBounds(const PushCull&) { this->pushControl(); } void trackBounds(const PopCull&) { this->pushControl(); } void trackBounds(const BeginCommentGroup&) { this->pushControl(); } void trackBounds(const AddComment&) { this->pushControl(); } void trackBounds(const EndCommentGroup&) { this->pushControl(); } void trackBounds(const DrawData&) { this->pushControl(); } // For all other ops, we can calculate and store the bounds directly now. template <typename T> void trackBounds(const T& op) { fBounds[fCurrentOp] = this->bounds(op); this->updateSaveBounds(fBounds[fCurrentOp]); } void pushSaveBlock(const SkPaint* paint) { // Starting a new Save block. Push a new entry to represent that. SaveBounds sb; sb.controlOps = 0; // If the paint affects transparent black, the bound shouldn't be smaller // than the current clip bounds. sb.bounds = PaintMayAffectTransparentBlack(paint) ? fCurrentClipBounds : Bounds::MakeEmpty(); sb.paint = paint; fSaveStack.push(sb); this->pushControl(); } static bool PaintMayAffectTransparentBlack(const SkPaint* paint) { if (paint) { // FIXME: this is very conservative if (paint->getImageFilter() || paint->getColorFilter()) { return true; } // Unusual Xfermodes require us to process a saved layer // even with operations outisde the clip. // For example, DstIn is used by masking layers. // https://code.google.com/p/skia/issues/detail?id=1291 // https://crbug.com/401593 SkXfermode* xfermode = paint->getXfermode(); SkXfermode::Mode mode; // SrcOver is ok, and is also the common case with a NULL xfermode. // So we should make that the fast path and bypass the mode extraction // and test. if (xfermode && xfermode->asMode(&mode)) { switch (mode) { // For each of the following transfer modes, if the source // alpha is zero (our transparent black), the resulting // blended alpha is not necessarily equal to the original // destination alpha. case SkXfermode::kClear_Mode: case SkXfermode::kSrc_Mode: case SkXfermode::kSrcIn_Mode: case SkXfermode::kDstIn_Mode: case SkXfermode::kSrcOut_Mode: case SkXfermode::kDstATop_Mode: case SkXfermode::kModulate_Mode: return true; break; default: break; } } } return false; } Bounds popSaveBlock() { // We're done the Save block. Apply the block's bounds to all control ops inside it. SaveBounds sb; fSaveStack.pop(&sb); while (sb.controlOps --> 0) { this->popControl(sb.bounds); } // This whole Save block may be part another Save block. this->updateSaveBounds(sb.bounds); // If called from a real Restore (not a phony one for balance), it'll need the bounds. return sb.bounds; } void pushControl() { fControlIndices.push(fCurrentOp); if (!fSaveStack.isEmpty()) { fSaveStack.top().controlOps++; } } void popControl(const Bounds& bounds) { fBounds[fControlIndices.top()] = bounds; fControlIndices.pop(); } void updateSaveBounds(const Bounds& bounds) { // If we're in a Save block, expand its bounds to cover these bounds too. if (!fSaveStack.isEmpty()) { fSaveStack.top().bounds.join(bounds); } } // FIXME: this method could use better bounds Bounds bounds(const DrawText&) const { return fCurrentClipBounds; } Bounds bounds(const Clear&) const { return fCullRect; } // Ignores the clip. Bounds bounds(const DrawPaint&) const { return fCurrentClipBounds; } Bounds bounds(const NoOp&) const { return Bounds::MakeEmpty(); } // NoOps don't draw. Bounds bounds(const DrawSprite& op) const { const SkBitmap& bm = op.bitmap; return Bounds::MakeXYWH(op.left, op.top, bm.width(), bm.height()); // Ignores the matrix. } Bounds bounds(const DrawRect& op) const { return this->adjustAndMap(op.rect, &op.paint); } Bounds bounds(const DrawOval& op) const { return this->adjustAndMap(op.oval, &op.paint); } Bounds bounds(const DrawRRect& op) const { return this->adjustAndMap(op.rrect.rect(), &op.paint); } Bounds bounds(const DrawDRRect& op) const { return this->adjustAndMap(op.outer.rect(), &op.paint); } Bounds bounds(const DrawImage& op) const { const SkImage* image = op.image; SkRect rect = SkRect::MakeXYWH(op.left, op.top, image->width(), image->height()); return this->adjustAndMap(rect, op.paint); } Bounds bounds(const DrawImageRect& op) const { return this->adjustAndMap(op.dst, op.paint); } Bounds bounds(const DrawBitmapRectToRect& op) const { return this->adjustAndMap(op.dst, op.paint); } Bounds bounds(const DrawBitmapNine& op) const { return this->adjustAndMap(op.dst, op.paint); } Bounds bounds(const DrawBitmap& op) const { const SkBitmap& bm = op.bitmap; return this->adjustAndMap(SkRect::MakeXYWH(op.left, op.top, bm.width(), bm.height()), op.paint); } Bounds bounds(const DrawBitmapMatrix& op) const { const SkBitmap& bm = op.bitmap; SkRect dst = SkRect::MakeWH(bm.width(), bm.height()); op.matrix.mapRect(&dst); return this->adjustAndMap(dst, op.paint); } Bounds bounds(const DrawPath& op) const { return op.path.isInverseFillType() ? fCurrentClipBounds : this->adjustAndMap(op.path.getBounds(), &op.paint); } Bounds bounds(const DrawPoints& op) const { SkRect dst; dst.set(op.pts, op.count); // Pad the bounding box a little to make sure hairline points' bounds aren't empty. SkScalar stroke = SkMaxScalar(op.paint.getStrokeWidth(), 0.01f); dst.outset(stroke/2, stroke/2); return this->adjustAndMap(dst, &op.paint); } Bounds bounds(const DrawPatch& op) const { SkRect dst; dst.set(op.cubics, SkPatchUtils::kNumCtrlPts); return this->adjustAndMap(dst, &op.paint); } Bounds bounds(const DrawVertices& op) const { SkRect dst; dst.set(op.vertices, op.vertexCount); return this->adjustAndMap(dst, &op.paint); } Bounds bounds(const DrawPicture& op) const { SkRect dst = op.picture->cullRect(); if (op.matrix) { op.matrix->mapRect(&dst); } return this->adjustAndMap(dst, op.paint); } Bounds bounds(const DrawPosText& op) const { const int N = op.paint.countText(op.text, op.byteLength); if (N == 0) { return Bounds::MakeEmpty(); } SkRect dst; dst.set(op.pos, N); AdjustTextForFontMetrics(&dst, op.paint); return this->adjustAndMap(dst, &op.paint); } Bounds bounds(const DrawPosTextH& op) const { const int N = op.paint.countText(op.text, op.byteLength); if (N == 0) { return Bounds::MakeEmpty(); } SkScalar left = op.xpos[0], right = op.xpos[0]; for (int i = 1; i < N; i++) { left = SkMinScalar(left, op.xpos[i]); right = SkMaxScalar(right, op.xpos[i]); } SkRect dst = { left, op.y, right, op.y }; AdjustTextForFontMetrics(&dst, op.paint); return this->adjustAndMap(dst, &op.paint); } Bounds bounds(const DrawTextOnPath& op) const { SkRect dst = op.path.getBounds(); // Pad all sides by the maximum padding in any direction we'd normally apply. SkRect pad = { 0, 0, 0, 0}; AdjustTextForFontMetrics(&pad, op.paint); // That maximum padding happens to always be the right pad today. SkASSERT(pad.fLeft == -pad.fRight); SkASSERT(pad.fTop == -pad.fBottom); SkASSERT(pad.fRight > pad.fBottom); dst.outset(pad.fRight, pad.fRight); return this->adjustAndMap(dst, &op.paint); } Bounds bounds(const DrawTextBlob& op) const { SkRect dst = op.blob->bounds(); dst.offset(op.x, op.y); return this->adjustAndMap(dst, &op.paint); } static void AdjustTextForFontMetrics(SkRect* rect, const SkPaint& paint) { #ifdef SK_DEBUG SkRect correct = *rect; #endif // crbug.com/373785 ~~> xPad = 4x yPad // crbug.com/424824 ~~> bump yPad from 2x text size to 2.5x const SkScalar yPad = 2.5f * paint.getTextSize(), xPad = 4.0f * yPad; rect->outset(xPad, yPad); #ifdef SK_DEBUG SkPaint::FontMetrics metrics; paint.getFontMetrics(&metrics); correct.fLeft += metrics.fXMin; correct.fTop += metrics.fTop; correct.fRight += metrics.fXMax; correct.fBottom += metrics.fBottom; // See skia:2862 for why we ignore small text sizes. SkASSERTF(paint.getTextSize() < 0.001f || rect->contains(correct), "%f %f %f %f vs. %f %f %f %f\n", -xPad, -yPad, +xPad, +yPad, metrics.fXMin, metrics.fTop, metrics.fXMax, metrics.fBottom); #endif } // Returns true if rect was meaningfully adjusted for the effects of paint, // false if the paint could affect the rect in unknown ways. static bool AdjustForPaint(const SkPaint* paint, SkRect* rect) { if (paint) { if (paint->canComputeFastBounds()) { *rect = paint->computeFastBounds(*rect, rect); return true; } return false; } return true; } bool adjustForSaveLayerPaints(SkRect* rect, int savesToIgnore = 0) const { for (int i = fSaveStack.count() - 1 - savesToIgnore; i >= 0; i--) { if (!AdjustForPaint(fSaveStack[i].paint, rect)) { return false; } } return true; } // Adjust rect for all paints that may affect its geometry, then map it to identity space. Bounds adjustAndMap(SkRect rect, const SkPaint* paint) const { // Inverted rectangles really confuse our BBHs. rect.sort(); // Adjust the rect for its own paint. if (!AdjustForPaint(paint, &rect)) { // The paint could do anything to our bounds. The only safe answer is the current clip. return fCurrentClipBounds; } // Adjust rect for all the paints from the SaveLayers we're inside. if (!this->adjustForSaveLayerPaints(&rect)) { // Same deal as above. return fCurrentClipBounds; } // Map the rect back to identity space. fCTM->mapRect(&rect); // Nothing can draw outside the current clip. // (Only bounded ops call into this method, so oddballs like Clear don't matter here.) rect.intersect(fCurrentClipBounds); return rect; } // We do not guarantee anything for operations outside of the cull rect const SkRect fCullRect; // Conservative identity-space bounds for each op in the SkRecord. SkAutoTMalloc<Bounds> fBounds; // We walk fCurrentOp through the SkRecord, as we go using updateCTM() // and updateClipBounds() to maintain the exact CTM (fCTM) and conservative // identity-space bounds of the current clip (fCurrentClipBounds). unsigned fCurrentOp; const SkMatrix* fCTM; Bounds fCurrentClipBounds; // Used to track the bounds of Save/Restore blocks and the control ops inside them. SkTDArray<SaveBounds> fSaveStack; SkTDArray<unsigned> fControlIndices; }; } // namespace SkRecords
//---------- void Device::drawWorld() { auto colorSource = this->getColorSource(); auto depthSource = this->getDepthSource(); auto bodySource = this->getBodySource(); if (!depthSource) { ofLogError("ofxKinectForWindows2::Device::drawPrettyMesh") << "No depth source initialised"; return; } //point cloud { //setup some point cloud properties for kicks bool usePointSize = true; #if OF_VERSION_MAJOR > 0 || OF_VERSION_MINOR >= 10 auto mainWindow = std::static_pointer_cast<ofAppGLFWWindow>(ofGetCurrentWindow()); usePointSize = mainWindow ? mainWindow->getSettings().glVersionMajor <= 2 : false; #endif usePointSize = false; if (usePointSize) { glPushAttrib(GL_POINT_BIT); glPointSize(5.0f); glEnable(GL_POINT_SMOOTH); } ofPushStyle(); bool useColor = colorSource.get(); if (useColor) { useColor &= colorSource->getTexture().isAllocated(); } if (useColor) { //bind kinect color camera texture and draw mesh from depth (which has texture coordinates) colorSource->getTexture().bind(); } auto opts = Source::Depth::PointCloudOptions(true, Source::Depth::PointCloudOptions::TextureCoordinates::ColorCamera); auto mesh = depthSource->getMesh(opts); //draw point cloud mesh.drawVertices(); //draw triangles ofSetColor(255, 150); mesh.drawWireframe(); //draw fills faded ofSetColor(255, 50); mesh.drawFaces(); if (useColor) { //unbind colour camera colorSource->getTexture().unbind(); } ofPopStyle(); //clear the point cloud drawing attributes if (usePointSize) { glPopAttrib(); } } //bodies and floor if (bodySource) { bodySource->drawWorld(); ofPushMatrix(); ofRotateDeg(90, 0, 0, 1); ofMultMatrix(bodySource->getFloorTransform()); ofDrawGridPlane(5.0f); ofPopMatrix(); } //draw the view cones of depth and colour cameras ofPushStyle(); ofNoFill(); ofSetLineWidth(2.0f); ofSetColor(100, 200, 100); depthSource->drawFrustum(); if (colorSource) { ofSetColor(200, 100, 100); colorSource->drawFrustum(); } ofPopStyle(); }
void MeshPainter::drawMesh(Viewport3dSettings *viewportSettings, GSProductMesh *meshProduct, PaintLayer layer, bool background, int reflectionCount) { MMesh *mesh = &( meshProduct->getMMeshForDisplay() ); if ( mesh->getVertices().size() == 0 ) { return; } ViewSettings *viewSettings = viewportSettings->getViewSettings(); bool verticesFlag = viewportSettings->bForegroundVertices; bool cullFlag = viewSettings->bBackfaceCull; bool multilayerFlag = viewSettings->bMultilayer; bool markedfacesFlag = viewportSettings->bForegroundMarkedFaces; MeshLiveSubdWireframeMode liveSubdWireMode = background ? meshLiveSubdivisionWireframeMode : viewSettings->meshLiveSubdivisionWireframeMode; bool bLiveSubdivision = background ? bMeshLiveSubdivisionEnabled : viewSettings->bMeshLiveSubdivisionEnabled; bool bBackgroundTransparent = viewportSettings->bBackgroundTransparent; bool wireframeFlag, solidFlag, smoothFlag, texturedFlag; if ( background ) { wireframeFlag = viewportSettings->bBackgroundWireframe; solidFlag = viewportSettings->bBackgroundSolid; smoothFlag = viewportSettings->bBackgroundSmooth; texturedFlag = viewportSettings->bBackgroundMaterial; } else { wireframeFlag = viewportSettings->bForegroundWireframe; solidFlag = viewportSettings->bForegroundSolid; smoothFlag = viewportSettings->bForegroundSmooth; texturedFlag = viewportSettings->bForegroundMaterial; } MMesh *subdMesh = NULL; if ( bLiveSubdivision ) { int subdIterations = background ? meshLiveSubdivisionIterations : viewSettings->meshLiveSubdivisionIterations; int subdMaxFaces = background ? meshLiveSubdivisionMaxFaces : viewSettings->meshLiveSubdivisionMaxFaces; MPreserveNormalSharpness normalSharpness = background ? meshLiveSubdivisionNormalSharpness : viewSettings->meshLiveSubdivisionNormalSharpness; subdMesh = mesh->getLiveSubdivisionMesh( subdIterations, subdMaxFaces, normalSharpness ); } if ( background && bBackgroundTransparent ) { if ( reflectionCount & 0x1 ) { glCullFace( GL_FRONT ); } else { glCullFace( GL_BACK ); } glEnable( GL_CULL_FACE ); if ( bLiveSubdivision ) { if ( solidFlag && ( layer == PAINTLAYER_OVERLAY_BLEND || layer == PAINTLAYER_OVERLAY_BLEND_NODEPTH ) ) { beginSolidRendering(); drawSolidTransparent( subdMesh, smoothFlag ); endSolidRendering(); } } else { if ( solidFlag && ( layer == PAINTLAYER_OVERLAY_BLEND || layer == PAINTLAYER_OVERLAY_BLEND_NODEPTH ) ) { beginSolidRendering(); drawSolidTransparent( mesh, smoothFlag ); endSolidRendering(); } } if ( wireframeFlag ) { if ( layer == PAINTLAYER_OVERLAY_BLEND || layer == PAINTLAYER_OVERLAY_BLEND_NODEPTH ) { drawWireframe( mesh, background, layer == PAINTLAYER_OVERLAY_BLEND_NODEPTH, reflectionCount != 0, true ); } } glDisable( GL_CULL_FACE ); } else { if ( cullFlag ) { if ( reflectionCount & 0x1 ) { glCullFace( GL_FRONT ); } else { glCullFace( GL_BACK ); } glEnable( GL_CULL_FACE ); } if ( bLiveSubdivision ) { if ( solidFlag && layer == PAINTLAYER_OBJECTS ) { beginSolidRendering(); drawSolidUntextured( subdMesh, background, false, true, true ); endSolidRendering(); } } else { if ( solidFlag && layer == PAINTLAYER_OBJECTS ) { beginSolidRendering(); drawSolid( viewportSettings, mesh, background, texturedFlag, reflectionCount != 0, smoothFlag ); endSolidRendering(); } } if ( bLiveSubdivision && liveSubdWireMode != MESHLIVESUBDWIRE_NONE && !background ) { if ( layer == PAINTLAYER_WIREFRAME || ( layer == PAINTLAYER_TRANSPARENCY && multilayerFlag ) ) { drawSubdividedWireframe( subdMesh, layer == PAINTLAYER_TRANSPARENCY, liveSubdWireMode ); } } if ( wireframeFlag ) { if ( layer == PAINTLAYER_WIREFRAME || ( layer == PAINTLAYER_TRANSPARENCY && multilayerFlag ) ) { drawWireframe( mesh, background, layer == PAINTLAYER_TRANSPARENCY, reflectionCount != 0, false ); } } if ( verticesFlag && !background ) { if ( layer == PAINTLAYER_WIREFRAME || ( layer == PAINTLAYER_TRANSPARENCY && multilayerFlag ) ) { drawVertices( mesh, layer == PAINTLAYER_TRANSPARENCY, reflectionCount != 0 ); } } if ( cullFlag ) { glDisable( GL_CULL_FACE ); } if ( markedfacesFlag && layer == PAINTLAYER_OVERLAY_BLEND && !background && reflectionCount == 0 ) { drawMarkedFacesPass( mesh ); } } }
void drawMap(Graph &graph, Map<coordT> &m) { drawVertices(m); drawEdges(graph, m); }