Пример #1
0
void Base::RenderRecursive(Gwen::Skin::Base* skin, const Gwen::Rect& cliprect)
{
    Gwen::Renderer::Base* render = skin->GetRender();
    Gwen::Point pOldRenderOffset = render->GetRenderOffset();
    render->AddRenderOffset(cliprect);
    RenderUnder(skin);
    Gwen::Rect rOldRegion = render->ClipRegion();

    //
    // If this control is clipping, change the clip rect to ourselves
    // ( if not then we still clip using our parents clip rect )
    //
    if (ShouldClip())
    {
        render->AddClipRegion(cliprect);

        if (!render->ClipRegionVisible())
        {
            render->SetRenderOffset(pOldRenderOffset);
            render->SetClipRegion(rOldRegion);
            return;
        }
    }

    //
    // Render this control and children controls
    //
    render->StartClip();
    {
        Render(skin);

        if (!Children.empty())
        {
            // Now render my kids
            for (Base::List::iterator iter = Children.begin(); iter != Children.end(); ++iter)
            {
                Base* pChild = *iter;

                if (pChild->Hidden())
                    continue;

                pChild->DoRender(skin);
            }
        }
    }
    render->EndClip();
    //
    // Render overlay/focus
    //
    {
        render->SetClipRegion(rOldRegion);
        render->StartClip();
        {
            RenderOver(skin);
            RenderFocus(skin);
        }
        render->EndClip();
        render->SetRenderOffset(pOldRenderOffset);
    }
}
Пример #2
0
void Base::DoRender( Gwen::Skin::Base* skin )
{
	// If this control has a different skin, 
	// then so does its children.
	if ( m_Skin ) 
		skin = m_Skin;

	// Do think
	Think();

	Gwen::Renderer::Base* render = skin->GetRender();

	if ( render->GetCTT() && ShouldCacheToTexture() )
	{
		DoCacheRender( skin, this );
		return;
	}

	Gwen::Point pOldRenderOffset = render->GetRenderOffset();

	render->AddRenderOffset( GetBounds() );

	RenderUnder( skin );
	
	Gwen::Rect rOldRegion = render->ClipRegion();
	render->AddClipRegion( GetBounds() );

	if ( render->ClipRegionVisible() )
	{
		render->StartClip();
		
		//Render myself first
 		Render( skin );

		if ( !Children.empty() )
		{
			//Now render my kids
			for (Base::List::iterator iter = Children.begin(); iter != Children.end(); ++iter)
			{
				Base* pChild = *iter;
				if ( pChild->Hidden() ) continue;

				pChild->DoRender( skin );
			}		
		}

		render->SetClipRegion( rOldRegion );
		render->StartClip();

		RenderOver( skin );
	}
	else
	{
		render->SetClipRegion( rOldRegion );
	}

	RenderFocus( skin );

	render->SetRenderOffset( pOldRenderOffset );
}
Пример #3
0
void Base::DoCacheRender(Gwen::Skin::Base* skin, Gwen::Controls::Base* pMaster)
{
    Gwen::Renderer::Base* render = skin->GetRender();
    Gwen::Renderer::ICacheToTexture* cache = render->GetCTT();

    if (!cache)
        return;

    Gwen::Point pOldRenderOffset = render->GetRenderOffset();
    Gwen::Rect rOldRegion = render->ClipRegion();

    if (this != pMaster)
    {
        render->AddRenderOffset(GetBounds());
        render->AddClipRegion(GetBounds());
    }
    else
    {
        render->SetRenderOffset(Gwen::Point(0, 0));
        render->SetClipRegion(GetBounds());
    }

    // See if we need to update the cached texture. Dirty?
    if (m_bCacheTextureDirty && render->ClipRegionVisible())
    {
        render->StartClip();
        {
            if (IsCachedToTexture())
                cache->SetupCacheTexture(this);

            // Render myself first
            Render(skin);

            if (!Children.empty())
            {
                // Now render my kids
                for (Base::List::iterator iter = Children.begin(); iter != Children.end(); ++iter)
                {
                    Base* pChild = *iter;

                    if (!pChild->Hidden())
                    {
                        // Draw child control using normal render. If it is cached it will
                        // be handled in the same way as this one.
                        pChild->DoRender(skin);
                    }
                }
            }

            if (IsCachedToTexture())
            {
                cache->FinishCacheTexture(this);
                m_bCacheTextureDirty = false;
            }
        }
        render->EndClip();
    }

    // Draw the cached texture.
    render->SetClipRegion(rOldRegion);
    render->StartClip();
    {
        render->SetRenderOffset(pOldRenderOffset);
        cache->DrawCachedControlTexture(this);
    }
    render->EndClip();
}