ImpostorBox::ImpostorBox(GFXDevice& context,
ResourceCache& parentCache,
size_t descriptorHash,
const stringImpl& name,
const vec3<F32>& size)
: Box3D(context, parentCache, descriptorHash, name, size)
{
renderState().setDrawState(false);
renderState().addToDrawExclusionMask(RenderStage::SHADOW);
}
ImpostorSphere::ImpostorSphere(GFXDevice& context,
ResourceCache& parentCache,
size_t descriptorHash,
const stringImpl& name,
F32 radius)
: Sphere3D(context, parentCache, descriptorHash, name, radius, 8)
{
renderState().setDrawState(false);
renderState().addToDrawExclusionMask(RenderStage::SHADOW);
}
void WFileUpload::getDomChanges(std::vector<DomElement *>& result)
{
if (renderState() == RenderUpdate) {
if (!methodIframe_) {
DomElement *e = DomElement::getForUpdate(this, DomElement::INPUT);
updateDom(*e, false);
result.push_back(e);
} else {
DomElement *e = DomElement::getForUpdate(this, DomElement::FORM);
updateDom(*e, false);
if (doUpload_) {
iframe_ = wApp->useIframe();
e->setAttribute("target", iframe_->formName());
e->callMethod("submit()");
doUpload_ = false;
}
result.push_back(e);
}
}
}
void WComboBox::getDomChanges(std::vector<DomElement *>& result)
{
if (renderState() == RenderUpdate) {
DomElement *e = DomElement::getForUpdate(this, DomElement::SELECT);
updateDom(*e, false);
result.push_back(e);
}
}
void WPushButton::getDomChanges(std::vector<DomElement *>& result)
{
if (renderState() == RenderUpdate) {
DomElement *e = DomElement::getForUpdate(this, DomElement::INPUT);
updateDom(*e, false);
result.push_back(e);
}
}
void VRMLViewer::display(GLContextData& contextData) const
{
/* Create the VRML render state: */
VRMLRenderState renderState(contextData,Point(Vrui::getHeadPosition()),Vector(Vrui::getUpDirection()));
/* Render the root node: */
root->glRenderAction(renderState);
}
RenderState StackedTileLoader::renderState() const
{
RenderState renderState( "Stacked Tiles" );
QHash<TileId, StackedTile*>::const_iterator it = d->m_tilesOnDisplay.constBegin();
QHash<TileId, StackedTile*>::const_iterator const end = d->m_tilesOnDisplay.constEnd();
for (; it != end; ++it ) {
renderState.addChild( d->m_layerDecorator->renderState( it.key() ) );
}
return renderState;
}
PRBool
PaintFrameCallback::operator()(gfxContext* aContext,
const gfxRect& aFillRect,
const gfxPattern::GraphicsFilter& aFilter,
const gfxMatrix& aTransform)
{
if (mFrame->GetStateBits() & NS_FRAME_DRAWING_AS_PAINTSERVER)
return PR_FALSE;
mFrame->AddStateBits(NS_FRAME_DRAWING_AS_PAINTSERVER);
nsSVGRenderState renderState(aContext);
aContext->Save();
// Clip to aFillRect so that we don't paint outside.
aContext->NewPath();
aContext->Rectangle(aFillRect);
aContext->Clip();
gfxMatrix savedMatrix(aContext->CurrentMatrix());
aContext->Multiply(gfxMatrix(aTransform).Invert());
// nsLayoutUtils::PaintFrame will anchor its painting at mFrame. But we want
// to have it anchored at the top left corner of the bounding box of all of
// mFrame's continuations. So we add a translation transform.
nsRect bbox = nsSVGIntegrationUtils::GetNonSVGUserSpace(mFrame);
PRInt32 appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();
gfxPoint offset = gfxPoint(bbox.x, bbox.y) / appUnitsPerDevPixel;
aContext->Multiply(gfxMatrix().Translate(-offset));
gfxSize paintServerSize =
gfxSize(mPaintServerSize.width, mPaintServerSize.height) /
mFrame->PresContext()->AppUnitsPerDevPixel();
// nsLayoutUtils::PaintFrame wants to render with paintServerSize, but we
// want it to render with mRenderSize, so we need to set up a scale transform.
gfxFloat scaleX = mRenderSize.width / paintServerSize.width;
gfxFloat scaleY = mRenderSize.height / paintServerSize.height;
gfxMatrix scaleMatrix = gfxMatrix().Scale(scaleX, scaleY);
aContext->Multiply(scaleMatrix);
// Draw.
nsRect dirty(bbox.x, bbox.y, mPaintServerSize.width, mPaintServerSize.height);
nsLayoutUtils::PaintFrame(renderState.GetRenderingContext(mTarget), mFrame,
dirty, NS_RGBA(0, 0, 0, 0),
nsLayoutUtils::PAINT_IN_TRANSFORM |
nsLayoutUtils::PAINT_ALL_CONTINUATIONS);
aContext->SetMatrix(savedMatrix);
aContext->Restore();
mFrame->RemoveStateBits(NS_FRAME_DRAWING_AS_PAINTSERVER);
return PR_TRUE;
}
void WContainerWidget::getDomChanges(std::vector<DomElement *>& result)
{
if (renderState() == RenderUpdate) {
DomElement *e
= DomElement::getForUpdate(this, isInline() ? DomElement::SPAN
: DomElement::DIV);
updateDom(*e, false);
result.push_back(e);
}
renderOk();
}
void WScrollArea::getDomChanges(std::vector<DomElement *>& result)
{
if (renderState() == RenderUpdate) {
DomElement *e = DomElement::getForUpdate(this, DomElement::DIV);
updateDom(*e, false);
result.push_back(e);
}
/*
if (widget_)
widget_->webWidget()->getSDomChanges(result);
*/
}
void RenderButton::draw(PainterInfo & pi, int x, int y) const
{
// Draw it as a box with the LaTeX text
FontInfo font = sane_font;
font.setColor(Color_command);
font.decSize();
if (editable_) {
pi.pain.buttonText(x + 1, y, text_, font, renderState());
} else {
pi.pain.rectText(x + 1, y, text_, font,
Color_commandbg, Color_commandframe);
}
}
void WTable::getDomChanges(std::vector<DomElement *>& result)
{
if (renderState() == RenderUpdate) {
DomElement *e = DomElement::getForUpdate(this, DomElement::TABLE);
if (gridChanged_) {
DomElement *newE = createDomElement();
e->replaceWith(newE);
} else {
updateDom(*e, false);
}
result.push_back(e);
}
}
bool Console::cmdSetRenderState(int argc, const char **argv) {
if (argc != 2) {
debugPrintf("Use %s <RenderState: panorama, tilt, flat> to change the current render state\n", argv[0]);
return true;
}
Common::String renderState(argv[1]);
if (renderState.matchString("panorama", true))
_engine->getRenderManager()->getRenderTable()->setRenderState(RenderTable::PANORAMA);
else if (renderState.matchString("tilt", true))
_engine->getRenderManager()->getRenderTable()->setRenderState(RenderTable::TILT);
else if (renderState.matchString("flat", true))
_engine->getRenderManager()->getRenderTable()->setRenderState(RenderTable::FLAT);
else
debugPrintf("Use %s <RenderState: panorama, tilt, flat> to change the current render state\n", argv[0]);
return true;
}
void SceneGraphViewer::display(GLContextData& contextData) const
{
/* Save OpenGL state: */
glPushAttrib(GL_ENABLE_BIT|GL_LIGHTING_BIT|GL_TEXTURE_BIT);
/* Go to navigational coordinates: */
glPushMatrix();
glLoadIdentity();
glMultMatrix(getDisplayState(contextData).modelviewNavigational);
/* Create a render state to traverse the scene graph: */
SceneGraph::GLRenderState renderState(contextData,getHeadPosition(),getNavigationTransformation().inverseTransform(getUpDirection()));
/* Traverse the scene graph: */
root->glRenderAction(renderState);
/* Restore OpenGL state: */
glPopMatrix();
glPopAttrib();
}
void SceneManager::renderScene( ScenePassType passType, U32 objectMask )
{
SceneCameraState cameraState = SceneCameraState::fromGFX();
// Handle frustum locking.
const bool lockedFrustum = ( smLockDiffuseFrustum && passType == SPT_Diffuse );
if( lockedFrustum )
cameraState = smLockedDiffuseCamera;
else if( passType == SPT_Diffuse )
{
// Store the camera state so if we lock, this will become the
// locked state.
if( passType == SPT_Diffuse )
smLockedDiffuseCamera = cameraState;
}
// Create the render state.
SceneRenderState renderState( this, passType, cameraState );
// If we have locked the frustum, reset the view transform
// on the render pass which the render state has just set
// to the view matrix corresponding to the locked frustum. For
// rendering, however, we need the true view matrix from the
// GFX state.
if( lockedFrustum )
{
RenderPassManager* rpm = renderState.getRenderPass();
rpm->assignSharedXform( RenderPassManager::View, GFX->getWorldMatrix() );
}
// Render.
renderScene( &renderState, objectMask );
}
status_t LayerRenderer::prepareDirty(float left, float top, float right, float bottom,
bool opaque) {
LAYER_RENDERER_LOGD("Rendering into layer %p, fbo %d, alpha %d", mLayer, mLayer->getFbo(), mLayer->getAlpha());
renderState().bindFramebuffer(mLayer->getFbo());
const float width = mLayer->layer.getWidth();
const float height = mLayer->layer.getHeight();
Rect dirty(left, top, right, bottom);
if (dirty.isEmpty() || (dirty.left <= 0 && dirty.top <= 0 &&
dirty.right >= width && dirty.bottom >= height)) {
mLayer->region.clear();
dirty.set(0.0f, 0.0f, width, height);
} else {
dirty.intersect(0.0f, 0.0f, width, height);
android::Rect r(dirty.left, dirty.top, dirty.right, dirty.bottom);
mLayer->region.subtractSelf(r);
}
mLayer->clipRect.set(dirty);
return OpenGLRenderer::prepareDirty(dirty.left, dirty.top, dirty.right, dirty.bottom, opaque);
}
