void GoodNightMorningApp::drawTweets() { gl::color( ColorA( 1, 1, 1, mMorningTweetAlpha ) ); if( mMorningTweetTex ) gl::draw( mMorningTweetTex, Vec2f( 0.1f, mMorningTweetPos ) * mDrawBounds.getSize() + mDrawBounds.getUpperLeft() ); gl::color( ColorA( 1, 1, 1, mNightTweetAlpha ) ); if( mNightTweetTex ) gl::draw( mNightTweetTex, Vec2f( 0.6f, mNightTweetPos ) * mDrawBounds.getSize() + mDrawBounds.getUpperLeft() ); gl::color( Color::white() ); // restore for future drawing }
//----------------------------------------------------------------------------// void IrrlichtTexture::blitFromMemory(const void* sourceData, const Rectf& area) { if (!d_texture) return; const size_t pitch = d_texture->getPitch(); const std::uint32_t* src = static_cast<const std::uint32_t*>(sourceData); std::uint32_t* dst = static_cast<std::uint32_t*>(d_texture->lock()); if (!dst) throw RendererException( "[IrrlichtRenderer] ITexture::lock failed."); dst += static_cast<size_t>(area.top()) * (pitch / 4) + static_cast<size_t>(area.left()); const Sizef sz(area.getSize()); for (int j = 0; j < sz.d_height; ++j) { for (int i = 0; i < sz.d_width; ++i) { dst[i] = src[i]; } src += static_cast<int>(sz.d_width); dst += pitch / 4; } d_texture->unlock(); }
vec2 Control::getHitPercent( const vec2 &pt ) { vec2 hp; Rectf r = mHitRect; r.offset( getOrigin() ); hp = ( pt - r.getUpperLeft() ) / r.getSize(); return hp; }
vec2 View::getHitPercent( const vec2 &pt ) { vec2 hp; Rectf r; r.set( 0, 0, getWidth(), getHeight() ); r.offset( getOrigin() ); hp = ( pt - r.getUpperLeft() ) / r.getSize(); return hp; }
//----------------------------------------------------------------------------// void BasicImage::setArea(const Rectf& pixel_area) { d_area = pixel_area; d_pixelSize = pixel_area.getSize(); if (d_autoScaled != ASM_Disabled) notifyDisplaySizeChanged( System::getSingleton().getRenderer()->getDisplaySize()); }
//----------------------------------------------------------------------------// void OpenGLESTexture::loadCompressedTextureBuffer(const Rectf& dest_area, const GLvoid* buffer) const { const GLsizei image_size = getCompressedTextureSize(dest_area.getSize()); glCompressedTexImage2D(GL_TEXTURE_2D, 0, d_format, static_cast<GLsizei>(dest_area.getWidth()), static_cast<GLsizei>(dest_area.getHeight()), 0, image_size, buffer); }
ShapeProxy(nvg::Context& vg, shared_ptr<Shape> shape) : mShape{ shape } { mBounds = mShape->getBounds(); // Grow the bounds a little to preserve nice anti-aliasing at the edges. mBounds.inflate(vec2(2)); auto fboSize = mBounds.getSize() * getWindow()->getContentScale(); auto fbo = gl::Fbo::create(fboSize.x, fboSize.y, gl::Fbo::Format().stencilBuffer()); gl::ScopedFramebuffer fboScp(fbo); gl::viewport(fboSize); gl::clear(ColorAf::zero()); gl::clear(GL_STENCIL_BUFFER_BIT); vg.beginFrame(mBounds.getSize(), getWindow()->getContentScale()); vg.translate(-mBounds.getUpperLeft()); mShape->draw(vg); vg.endFrame(); mTexture = fbo->getColorTexture(); }
vec2 DialerT<T>::getHitPercent( const vec2 &pt ) { vec2 hp; Rectf r = mHitRect; r.offset( getOrigin() ); r.x1 += mPadding.mLeft; r.x2 -= mPadding.mRight; r.y1 += mPadding.mTop; r.y2 -= mPadding.mBottom; hp = ( pt - r.getUpperLeft() ) / r.getSize(); return hp; }
//----------------------------------------------------------------------------// BasicImage::BasicImage(const String& name, Texture* texture, const Rectf& pixel_area, const Vector2f& pixel_offset, const AutoScaledMode autoscaled, const Sizef& native_res) : d_name(name), d_texture(texture), d_pixelSize(pixel_area.getSize()), d_area(pixel_area), d_pixelOffset(pixel_offset), d_autoScaled(autoscaled), d_nativeResolution(native_res) { // force initialisation of the autoscaling fields. notifyDisplaySizeChanged( System::getSingleton().getRenderer()->getDisplaySize()); }
//----------------------------------------------------------------------------// void Direct3D10Texture::blitFromMemory(const void* sourceData, const Rectf& area) { if (!d_texture) return; uint32* buff = new uint32[static_cast<size_t>(area.getWidth()) * static_cast<size_t>(area.getHeight())]; blitFromSurface(static_cast<const uint32*>(sourceData), buff, area.getSize(), static_cast<size_t>(area.getWidth()) * 4); D3D10_BOX dst_box = {static_cast<UINT>(area.left()), static_cast<UINT>(area.top()), 0, static_cast<UINT>(area.right()), static_cast<UINT>(area.bottom()), 1}; d_device.UpdateSubresource(d_texture, 0, &dst_box, buff, static_cast<UINT>(area.getWidth()) * 4, 0); delete[] buff; }
//----------------------------------------------------------------------------// void OpenGLESTexture::blitFromMemory(void* sourceData, const Rectf& area) { // store size of original data we are loading d_dataSize = area.getSize(); setTextureSize(d_dataSize); // update scale values updateCachedScaleValues(); // save old texture binding GLuint old_tex; glGetIntegerv(GL_TEXTURE_BINDING_2D, reinterpret_cast<GLint*>(&old_tex)); // do the real work of getting the data into the texture glBindTexture(GL_TEXTURE_2D, d_ogltexture); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, static_cast<GLsizei>(d_dataSize.d_width), static_cast<GLsizei>(d_dataSize.d_height), GL_RGBA, GL_UNSIGNED_BYTE, sourceData); // restore previous texture binding. glBindTexture(GL_TEXTURE_2D, old_tex); }
void TextComponent::render_impl(Window& srcWindow, Rectf& destRect, const CEGUI::ColourRect* modColours, const Rectf* clipper, bool /*clipToDisplay*/) const { updateFormatting(srcWindow, destRect.getSize()); // Get total formatted height. const float textHeight = d_formattedRenderedString->getVerticalExtent(&srcWindow); // handle dest area adjustments for vertical formatting. const VerticalTextFormatting vertFormatting = d_vertFormatting.get(srcWindow); switch(vertFormatting) { case VTF_CENTRE_ALIGNED: destRect.d_min.y += (destRect.getHeight() - textHeight) * 0.5f; break; case VTF_BOTTOM_ALIGNED: destRect.d_min.y = destRect.d_max.y - textHeight; break; default: // default is VTF_TOP_ALIGNED, for which we take no action. break; } // calculate final colours to be used ColourRect finalColours; initColoursRect(srcWindow, modColours, finalColours); // add geometry for text to the target window. d_formattedRenderedString->draw(&srcWindow, srcWindow.getGeometryBuffers(), destRect.getPosition(), &finalColours, clipper); }
std::map<int, TimelineContentInfo> GridLayoutTimeline::getRenderContent(//SceneContentProvider *contentProvider, bool shouldTransition) { std::map< int, TimelineContentInfo > returnContent; vector<ScreenRegion> transitionRegions; vector<ScreenRegion> compareRegions; vector<ScreenRegion> returnRegions; float curTransitionScale = shouldTransition ? mTransitionAmt : 1.0f; if (shouldTransition && mTransitionAmt < 1.0 && mIdxPrevLayout != -1) { // If there's a previous region, they each get 1/2 of the // allotted transition time. float prevTransitionScale = 1.0 - std::min(mTransitionAmt / 0.5f, 1.0f); float nextTransitionScale = std::max((mTransitionAmt - 0.5f) / 0.5f, 0.0f); if (nextTransitionScale > 0.0) { // Next layout is transitioning. transitionRegions = mGridLayouts[mIdxCurrentLayout].getRegions(); compareRegions = mGridLayouts[mIdxPrevLayout].getRegions(); curTransitionScale = nextTransitionScale; } else { // Previous layout is transitioning. transitionRegions = mGridLayouts[mIdxPrevLayout].getRegions(); compareRegions = mGridLayouts[mIdxCurrentLayout].getRegions(); curTransitionScale = prevTransitionScale; } } else { // Next layout is transitioning. There are no previous regions. transitionRegions = mGridLayouts[mIdxCurrentLayout].getRegions(); } int numRegions = transitionRegions.size(); int numCompareRegions = compareRegions.size(); for (int i = 0; i < numRegions; ++i) { ScreenRegion transitionReg = transitionRegions[i]; Rectf rA = transitionReg.rect; float rectScale = curTransitionScale; for (int j = 0; j < numCompareRegions; ++j) { ScreenRegion compareReg = compareRegions[j]; /* Rectf rB = compareReg.rect; if (compareReg.isActive && rectCompare(rA, rB)) { */ if (compareReg.timelineID == transitionReg.timelineID) { // No transition. Just draw at full blast. rectScale = 1.0f; break; } } //std::pair<ci::Rectf, RenderableContentRef> returnItem; TimelineContentInfo returnItem; returnItem.layoutIndex = i; // Now, create the new rect. Vec2f rectCenter = rA.getCenter(); Vec2f rectHalfSize = rA.getSize() * 0.5f * rectScale; Rectf transitionRect(rectCenter - rectHalfSize, rectCenter + rectHalfSize); // returnItem.first = transitionRect; returnItem.rect = transitionRect; // Append content. SceneContentProviderRef contentProvider = SceneContentProvider::sharedContentProvider(); if (contentProvider) { returnItem.contentKey = transitionReg.contentKey; returnItem.contentRef = contentProvider->contentForKey(transitionReg.contentKey); returnContent[transitionReg.timelineID] = returnItem; } else { ci::app::console() << "ERROR: No content provider.\n"; } } return returnContent; }