//-----------------------------------------------------------------------------
void D2DDrawContext::fillLinearGradient (CGraphicsPath* _path, const CGradient& gradient, const CPoint& startPoint, const CPoint& endPoint, bool evenOdd, CGraphicsTransform* t)
{
if (renderTarget == 0)
return;
D2DGraphicsPath* d2dPath = dynamic_cast<D2DGraphicsPath*> (_path);
if (d2dPath == 0)
return;
ID2D1PathGeometry* path = d2dPath->getPath (evenOdd ? D2D1_FILL_MODE_ALTERNATE : D2D1_FILL_MODE_WINDING);
if (path)
{
D2DApplyClip ac (this);
ID2D1Geometry* geometry = 0;
if (t)
{
ID2D1TransformedGeometry* tg = 0;
D2D1_MATRIX_3X2_F matrix;
matrix._11 = (FLOAT)t->m11;
matrix._12 = (FLOAT)t->m12;
matrix._21 = (FLOAT)t->m21;
matrix._22 = (FLOAT)t->m22;
matrix._31 = (FLOAT)t->dx;
matrix._32 = (FLOAT)t->dy;
getD2DFactory ()->CreateTransformedGeometry (path, matrix, &tg);
geometry = tg;
}
else
{
geometry = path;
geometry->AddRef ();
}
ID2D1GradientStopCollection* collection = 0;
D2D1_GRADIENT_STOP gradientStops[2];
gradientStops[0].position = (FLOAT)gradient.getColor1Start ();
gradientStops[1].position = (FLOAT)gradient.getColor2Start ();
gradientStops[0].color = D2D1::ColorF (gradient.getColor1 ().red/255.f, gradient.getColor1 ().green/255.f, gradient.getColor1 ().blue/255.f, gradient.getColor1 ().alpha/255.f * currentState.globalAlpha);
gradientStops[1].color = D2D1::ColorF (gradient.getColor2 ().red/255.f, gradient.getColor2 ().green/255.f, gradient.getColor2 ().blue/255.f, gradient.getColor2 ().alpha/255.f * currentState.globalAlpha);
if (SUCCEEDED (getRenderTarget ()->CreateGradientStopCollection (gradientStops, 2, &collection)))
{
ID2D1LinearGradientBrush* brush = 0;
D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES properties;
properties.startPoint = makeD2DPoint (startPoint);
properties.endPoint = makeD2DPoint (endPoint);
if (SUCCEEDED (getRenderTarget ()->CreateLinearGradientBrush (properties, collection, &brush)))
{
getRenderTarget ()->SetTransform (D2D1::Matrix3x2F::Translation ((FLOAT)getOffset ().x, (FLOAT)getOffset ().y));
getRenderTarget ()->FillGeometry (geometry, brush);
getRenderTarget ()->SetTransform (D2D1::Matrix3x2F::Identity ());
brush->Release ();
}
collection->Release ();
}
geometry->Release ();
}
}
//-----------------------------------------------------------------------------
void D2DDrawContext::fillLinearGradient (CGraphicsPath* _path, const CGradient& gradient, const CPoint& startPoint, const CPoint& endPoint, bool evenOdd, CGraphicsTransform* t)
{
if (renderTarget == 0)
return;
bool halfPointOffset = currentState.drawMode.integralMode () ? ((((int32_t)currentState.frameWidth) % 2) != 0) : false;
D2DApplyClip ac (this, halfPointOffset);
if (ac.isEmpty ())
return;
D2DGraphicsPath* d2dPath = dynamic_cast<D2DGraphicsPath*> (_path);
if (d2dPath == 0)
return;
ID2D1Geometry* path = d2dPath->createPath (evenOdd ? D2D1_FILL_MODE_ALTERNATE : D2D1_FILL_MODE_WINDING, this, t);
if (path)
{
ID2D1GradientStopCollection* collection = createGradientStopCollection (gradient);
if (collection)
{
ID2D1LinearGradientBrush* brush = 0;
D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES properties;
properties.startPoint = makeD2DPoint (startPoint);
properties.endPoint = makeD2DPoint (endPoint);
if (SUCCEEDED (getRenderTarget ()->CreateLinearGradientBrush (properties, collection, &brush)))
{
getRenderTarget ()->FillGeometry (path, brush);
brush->Release ();
}
collection->Release ();
}
path->Release ();
}
}
const Z3DTexture *Z3DRenderInputPort::getColorTexture(size_t idx) const
{
if (getRenderTarget(idx))
return getRenderTarget(idx)->getAttachment(GL_COLOR_ATTACHMENT0);
else
return NULL;
}
const Z3DTexture *Z3DRenderInputPort::getDepthTexture(size_t idx) const
{
if (getRenderTarget(idx))
return getRenderTarget(idx)->getAttachment(GL_DEPTH_ATTACHMENT);
else
return NULL;
}
glm::ivec2 Z3DRenderInputPort::getSize(size_t idx) const
{
if (getRenderTarget(idx))
return getRenderTarget(idx)->getSize();
else
return glm::ivec2(0);
}
void SceniXQGLSceneRendererWidget::initializeGL()
{
glewInit();
glEnable( GL_DEPTH_TEST );
getRenderTarget().inplaceCast<dp::gl::RenderTarget>()->setClearMask( dp::gl::TBM_COLOR_BUFFER | dp::gl::TBM_DEPTH_BUFFER );
if ( m_manipulator )
{
m_manipulator->setRenderTarget( getRenderTarget() );
}
}
//-----------------------------------------------------------------------------
void D2DDrawContext::fillRadialGradient (CGraphicsPath* _path, const CGradient& gradient, const CPoint& center, CCoord radius, const CPoint& originOffset, bool evenOdd, CGraphicsTransform* t)
{
if (renderTarget == 0)
return;
D2DApplyClip ac (this);
if (ac.isEmpty ())
return;
D2DGraphicsPath* d2dPath = dynamic_cast<D2DGraphicsPath*> (_path);
if (d2dPath == 0)
return;
ID2D1Geometry* path = d2dPath->createPath (evenOdd ? D2D1_FILL_MODE_ALTERNATE : D2D1_FILL_MODE_WINDING);
if (path)
{
ID2D1Geometry* geometry = 0;
if (t)
{
ID2D1TransformedGeometry* tg = 0;
getD2DFactory ()->CreateTransformedGeometry (path, convert (*t), &tg);
geometry = tg;
}
else
{
geometry = path;
geometry->AddRef ();
}
ID2D1GradientStopCollection* collection = createGradientStopCollection (gradient);
if (collection)
{
// brush properties
ID2D1RadialGradientBrush* brush = 0;
D2D1_RADIAL_GRADIENT_BRUSH_PROPERTIES properties;
properties.center = makeD2DPoint (center);
properties.gradientOriginOffset = makeD2DPoint (originOffset);
properties.radiusX = (FLOAT)radius;
properties.radiusY = (FLOAT)radius;
if (SUCCEEDED (getRenderTarget ()->CreateRadialGradientBrush (properties, collection, &brush)))
{
getRenderTarget ()->FillGeometry (geometry, brush);
brush->Release ();
}
collection->Release ();
}
geometry->Release ();
path->Release ();
}
}
Z3DTexture *Z3DRenderOutputPort::getDepthTexture()
{
if (hasRenderTarget())
return getRenderTarget()->getAttachment(GL_DEPTH_ATTACHMENT);
else
return NULL;
}
Z3DTexture *Z3DRenderOutputPort::getColorTexture()
{
if (hasRenderTarget())
return getRenderTarget()->getAttachment(GL_COLOR_ATTACHMENT0);
else
return NULL;
}
Camera* HMDScene::setupCamera(float ratio, bool left) {
auto s = Director::getInstance()->getWinSize();
auto sizeInpixels = Director::getInstance()->getWinSizeInPixels();
auto fboSize = Size(sizeInpixels.width * 1.f, sizeInpixels.height * 1.f);
auto fbo = experimental::FrameBuffer::create(1, fboSize.width, fboSize.height);
auto rt = experimental::RenderTarget::create(fboSize.width, fboSize.height);
auto rtDS = experimental::RenderTargetDepthStencil::create(fboSize.width, fboSize.height);
fbo->attachRenderTarget(rt);
fbo->attachDepthStencilTarget(rtDS);
auto sprite = Sprite::createWithTexture(fbo->getRenderTarget()->getTexture());
sprite->setPosition((left ? s.width * 0.25f : s.width * 0.75f) , s.height * 0.5f);
sprite->setRotation3D(Vec3(0.0f, 180.0f, 180.0f));
sprite->setScale(0.5f, 1.0f);
Scene::addChild(sprite);
auto cam = Camera::createPerspective(60, ratio, 0.01f, 100.0f);
cam->setPosition3D(Vec3(0.0f, 0.0f, 0.0f));
cam->setCameraFlag(left ? CameraFlag::USER7 : CameraFlag::USER8);
cam->setDepth(-1);
cam->setName( (left ? "HMD-Cam-L" : "HMD-Cam-R") );
cam->setFrameBufferObject(fbo);
// useful for debugging viewport stuff
//fbo->setClearColor(Color4F( (left ? 0.25f : 0.0f) , (left ? 0.0f : 0.25f), 0, 1));
return cam;
}
//-----------------------------------------------------------------------------
void D2DDrawContext::endDraw ()
{
if (renderTarget)
{
if (currentClip.isEmpty () == false)
{
getRenderTarget ()->PopAxisAlignedClip ();
currentClip = CRect ();
}
renderTarget->Flush ();
HRESULT result = renderTarget->EndDraw ();
if (result == D2DERR_RECREATE_TARGET)
{
releaseRenderTarget ();
createRenderTarget ();
}
else
{
vstgui_assert (result == S_OK);
}
if (bitmap)
{
D2DBitmap* d2dBitmap = dynamic_cast<D2DBitmap*> (bitmap->getPlatformBitmap ());
D2DBitmapCache::instance ()->removeBitmap (d2dBitmap);
}
}
}
glm::ivec2 Z3DRenderOutputPort::getSize() const
{
if (hasRenderTarget())
return getRenderTarget()->getSize();
else
return glm::ivec2(0);
}
GLUTMinimalCFR::GLUTMinimalCFR()
: m_trackballHIDSync(new dp::sg::ui::manipulator::TrackballCameraManipulatorHIDSync( ) )
, m_benchmarkFrames( ~0 )
, m_renderedFrames( 0 )
, m_exitCode( 0 )
, m_duration( 0.0 )
, m_engineBindless( true )
, m_attributeType( AttributeType::GENERIC )
, m_shaderManager( dp::fx::Manager::SHADERBUFFER )
{
m_trackballHIDSync->setHID( this );
m_trackballHIDSync->setRenderTarget( getRenderTarget() );
setManipulator( m_trackballHIDSync.get() );
m_globalTimer.start();
double firstFrame = 2.0;
m_paintTimes.push_back( firstFrame + 0.0 );
m_paintTimes.push_back( firstFrame + 1.0 );
m_paintTimes.push_back( firstFrame + 1.2 );
m_paintTimes.push_back( firstFrame + 1.4 );
m_paintTimes.push_back( firstFrame + 2.0 );
m_paintTimes.push_back( firstFrame + 3.0 );
file.open("c:\\temp\\output.txt");
file << "start " << m_globalTimer.getTime() << "\n";
}
bool TrackballTransformManipulator::updateFrame( float dt )
{
bool result = false;
if( m_transformPath && getViewState() && getRenderTarget() )
{
switch( m_mode )
{
case Mode::ROTATE:
result = rotate();
break;
case Mode::PAN:
result = pan();
break;
case Mode::DOLLY:
result = dolly();
break;
default:
break;
}
}
return result;
}
void SceniXQGLSceneRendererWidget::onManipulatorChanged( Manipulator *manipulator )
{
if ( manipulator )
{
manipulator->setRenderTarget( getRenderTarget() );
}
}
bool TrackballTransformManipulator::dolly()
{
int dyScreen = getLastY() - getCurrentY();
if( !dyScreen )
{
dyScreen = getWheelTicksDelta();
}
if ( dyScreen )
{
DP_ASSERT( getViewState()->getCamera().isPtrTo<FrustumCamera>() );
TransformSharedPtr transform = m_transformPath->getTail().staticCast<Transform>();
FrustumCameraSharedPtr const& camera = getViewState()->getCamera().staticCast<FrustumCamera>();
if ( camera && transform )
{
unsigned int rtWidth = getRenderTarget()->getWidth();
unsigned int rtHeight = getRenderTarget()->getHeight();
Vec2f camWinSize = camera->getWindowSize();
if ( ( 0 < rtHeight ) && ( 0 < rtWidth )
&& ( FLT_EPSILON < fabs( camWinSize[0] ) )
&& ( FLT_EPSILON < fabs( camWinSize[1] ) ) )
{
// get all the matrices needed here
Mat44f m2w, w2m, w2v, v2w;
m_transformPath->getModelToWorldMatrix(m2w, w2m); // model->world and world->model
w2v = camera->getWorldToViewMatrix(); // world->view
v2w = camera->getViewToWorldMatrix(); // view->world
// transfer mouse delta into view space
float dyView = camWinSize[1]/rtHeight * dyScreen;
// transfer the mouse delta vector into the model space
Vec4f modelDelta = Vec4f( 0.0f, 0.0f, dyView, 0.0f ) * v2w * w2m;
// minus the delta to the translation of the transform
// minus, because we want mouse down to move the object into the direction of the user
Trafo trafo = transform->getTrafo();
trafo.setTranslation( trafo.getTranslation() - Vec3f( modelDelta ) );
transform->setTrafo( trafo );
return true;
}
}
}
return false;
}
//-----------------------------------------------------------------------------
void D2DDrawContext::drawGraphicsPath (CGraphicsPath* _path, PathDrawMode mode, CGraphicsTransform* t)
{
if (renderTarget == 0)
return;
D2DGraphicsPath* d2dPath = dynamic_cast<D2DGraphicsPath*> (_path);
if (d2dPath == 0)
return;
ID2D1PathGeometry* path = d2dPath->getPath (mode == kPathFilledEvenOdd ? D2D1_FILL_MODE_ALTERNATE : D2D1_FILL_MODE_WINDING);
if (path)
{
D2DApplyClip ac (this);
ID2D1Geometry* geometry = 0;
if (t)
{
ID2D1TransformedGeometry* tg = 0;
D2D1_MATRIX_3X2_F matrix;
matrix._11 = (FLOAT)t->m11;
matrix._12 = (FLOAT)t->m12;
matrix._21 = (FLOAT)t->m21;
matrix._22 = (FLOAT)t->m22;
matrix._31 = (FLOAT)t->dx;
matrix._32 = (FLOAT)t->dy;
getD2DFactory ()->CreateTransformedGeometry (path, matrix, &tg);
geometry = tg;
}
else
{
geometry = path;
geometry->AddRef ();
}
getRenderTarget ()->SetTransform (D2D1::Matrix3x2F::Translation ((FLOAT)getOffset ().x, (FLOAT)getOffset ().y));
if (mode == kPathFilled || mode == kPathFilledEvenOdd)
getRenderTarget ()->FillGeometry (geometry, getFillBrush ());
else if (mode == kPathStroked)
getRenderTarget ()->DrawGeometry (geometry, getStrokeBrush (), (FLOAT)getLineWidth (), getStrokeStyle ());
getRenderTarget ()->SetTransform (D2D1::Matrix3x2F::Identity ());
geometry->Release ();
}
}
bool ATOM_HeatHazeEffect::render (ATOM_RenderDevice *device)
{
if( !init(device) )
return false;
_material->setActiveEffect ("default");
#if 0
ATOM_PostEffect *prevEffect = getPreviousEffect ();
ATOM_Texture *inputTexture = prevEffect ? prevEffect->getRenderTarget() : _chain->getInputTexture();
#else
ATOM_AUTOREF(ATOM_Texture) inputTexture = getSourceInputTex();
#endif
if (!inputTexture)
{
return false;
}
device->setRenderTarget (0, getRenderTarget());
device->setViewport (0, ATOM_Rect2Di(0, 0, getRenderTarget()->getWidth(), getRenderTarget()->getHeight()));
ATOM_Vector4f invScreenSize(1.0f / ATOM_RenderScheme::getCurrentRenderScheme()->getWidth (),
1.0f / ATOM_RenderScheme::getCurrentRenderScheme()->getHeight(),
0,
0 );
ATOM_Vector4f perturbFactor(_perturbScale,
1.0f / _perturbDistance,
_perturbSpeed,
_perturbTiling );
_material->getParameterTable()->setVector("invScreenSize",invScreenSize);
_material->getParameterTable()->setVector("perturbScale",perturbFactor);
_material->getParameterTable()->setTexture ("inputTexture", inputTexture.get());
_material->getParameterTable()->setTexture ("perturbTexture", _perturbationTex.get());
drawTexturedFullscreenQuad ( device,
_material.get(),
inputTexture->getWidth(),
inputTexture->getHeight() );
return true;
}
void SceniXQGLSceneRendererWidget::paintGL()
{
if (m_renderer && m_viewState)
{
dp::sg::core::SceneSharedPtr sceneHandle = m_viewState->getScene();
if (sceneHandle)
{
m_renderer->render( m_viewState, getRenderTarget() );
}
}
}
void SpriteRenderingSystem::render()
{
auto entities = getEntities();
for(auto& entity : entities)
{
auto& sprite = entity.getComponent<SpriteComponent>().sprite;
auto& transform = entity.getComponent<TransformComponent>().transform;
getRenderTarget().draw(sprite, transform.getTransform());
}
}
egl::Image *Texture::createSharedImage(GLenum target, unsigned int level)
{
egl::Image *image = getRenderTarget(target, level); // Increments reference count
if(image)
{
image->markShared();
}
return image;
}
EOSObject* G2D::createSessionObject(const char* name)
{
EOSObject *obj = NULL;
G2DRenderTarget *rt = getRenderTarget(name);
if(rt)
{
obj = new EOSObject();
obj->setType("GL_TEXTURE_HANDLE");
obj->setUserData(rt->getSharedGLTexture());
obj->setUserDataSize(sizeof(eos_imagedata));
}
return obj;
}
void ofx2DPro::setupCoreGuis(){
setupGui();
logGui.linkDataPath(getDataPath());
logGui.linkRenderTarget(&getRenderTarget());
guiAdd(logGui);
setupSystemGui();
setupRenderGui();
backgroundSet(new UIBackground());
}
void CameraFrameBufferTest::onEnter()
{
auto sizeInpixels = Director::getInstance()->getWinSizeInPixels();
auto size = Director::getInstance()->getWinSize();
auto fboSize = Size(sizeInpixels.width * 1, sizeInpixels.height * 1.5);
auto fbo = experimental::FrameBuffer::create(1, fboSize.width, fboSize.height);
CameraBaseTest::onEnter();
//auto sprite = Sprite::createWithTexture(fbo);
//sprite->setPosition(Vec2(100,100));
//std::string filename = "Sprite3DTest/girl.c3b";
//auto sprite = Sprite3D::create(filename);
//sprite->setScale(1.0);
//auto animation = Animation3D::create(filename);
//if (animation)
//{
// auto animate = Animate3D::create(animation);
// sprite->runAction(RepeatForever::create(animate));
//}
//sprite->setPosition(Vec2(100,100));
auto rt = experimental::RenderTarget::create(fboSize.width, fboSize.height);
auto rtDS = experimental::RenderTargetDepthStencil::create(fboSize.width, fboSize.height);
fbo->attachRenderTarget(rt);
fbo->attachDepthStencilTarget(rtDS);
auto sprite = Sprite::createWithTexture(fbo->getRenderTarget()->getTexture());
sprite->setScale(0.3);
sprite->runAction(RepeatForever::create(RotateBy::create(1, 90)));
sprite->setPosition(size.width/2, size.height/2);
addChild(sprite);
auto sprite2 = Sprite::create(s_pathGrossini);
sprite2->setPosition(Vec2(size.width/5,size.height/5));
addChild(sprite2);
sprite2->setCameraMask((unsigned short)CameraFlag::USER1);
auto move = MoveBy::create(1.0, Vec2(100,100));
sprite2->runAction(
RepeatForever::create(
Sequence::createWithTwoActions(
move, move->reverse())
)
);
auto camera = Camera::create();
camera->setCameraFlag(CameraFlag::USER1);
camera->setDepth(-1);
camera->setFrameBufferObject(fbo);
fbo->setClearColor(Color4F(1,1,1,1));
addChild(camera);
}
//-----------------------------------------------------------------------------
ID2D1GradientStopCollection* D2DDrawContext::createGradientStopCollection (const CGradient& d2dGradient) const
{
ID2D1GradientStopCollection* collection = 0;
D2D1_GRADIENT_STOP* gradientStops = new D2D1_GRADIENT_STOP [d2dGradient.getColorStops ().size ()];
uint32_t index = 0;
for (CGradient::ColorStopMap::const_iterator it = d2dGradient.getColorStops ().begin (); it != d2dGradient.getColorStops ().end (); ++it, ++index)
{
gradientStops[index].position = (FLOAT)it->first;
gradientStops[index].color = D2D1::ColorF (it->second.red/255.f, it->second.green/255.f, it->second.blue/255.f, it->second.alpha/255.f * currentState.globalAlpha);
}
getRenderTarget ()->CreateGradientStopCollection (gradientStops, static_cast<UINT32> (d2dGradient.getColorStops ().size ()), &collection);
delete [] gradientStops;
return collection;
}
TerrainRenderer::TerrainRenderer()
: m_trackballHIDSync(new dp::sg::ui::manipulator::TrackballCameraManipulatorHIDSync( ) )
, m_benchmarkFrames( ~0 )
, m_renderedFrames( 0 )
, m_exitCode( 0 )
, m_duration( 0.0 )
, m_engineBindless( true )
, m_attributeType( ATTRIBUTE_GENERIC )
, m_shaderManager( dp::fx::MANAGER_SHADERBUFFER )
{
m_trackballHIDSync->setHID( this );
m_trackballHIDSync->setRenderTarget( getRenderTarget() );
setManipulator( m_trackballHIDSync.get() );
}
//-----------------------------------------------------------------------------
void D2DDrawContext::drawGraphicsPath (CGraphicsPath* _path, PathDrawMode mode, CGraphicsTransform* t)
{
if (renderTarget == 0)
return;
bool halfPointOffset = (mode == kPathStroked || currentState.drawMode.integralMode ()) ? ((((int32_t)currentState.frameWidth) % 2) != 0) : false;
D2DApplyClip ac (this, halfPointOffset);
if (ac.isEmpty ())
return;
D2DGraphicsPath* d2dPath = dynamic_cast<D2DGraphicsPath*> (_path);
if (d2dPath == 0)
return;
ID2D1Geometry* path = d2dPath->createPath (mode == kPathFilledEvenOdd ? D2D1_FILL_MODE_ALTERNATE : D2D1_FILL_MODE_WINDING, currentState.drawMode.integralMode () ? this : 0, t);
if (path)
{
if (mode == kPathFilled || mode == kPathFilledEvenOdd)
getRenderTarget ()->FillGeometry (path, getFillBrush ());
else if (mode == kPathStroked)
getRenderTarget ()->DrawGeometry (path, getStrokeBrush (), (FLOAT)getLineWidth (), getStrokeStyle ());
path->Release ();
}
}
QtMinimalWidget::QtMinimalWidget( const dp::gl::RenderContextFormat &format )
: SceniXQGLSceneRendererWidget(0, format )
, m_benchmarkDuration( 0.0 )
, m_benchmarkFrameCount( 0 )
, m_benchmarkFrames( ~0 )
, m_benchmarkTime( 0.0 )
, m_frameCount( 0 )
, m_framesInSecond( ~0 )
, m_orbitRadians( 0.0f )
, m_trackballHIDSync(new dp::sg::ui::manipulator::TrackballCameraManipulatorHIDSync( ) )
, m_windowTitle( "QtMinimal" )
{
m_trackballHIDSync->setHID( this );
m_trackballHIDSync->setRenderTarget( getRenderTarget() );
setManipulator( m_trackballHIDSync.get() );
}
angle::Result EGLImageD3D::copyToLocalRendertarget(const gl::Context *context)
{
ASSERT(mState.source != nullptr);
ASSERT(mRenderTarget == nullptr);
RenderTargetD3D *curRenderTarget = nullptr;
ANGLE_TRY(getRenderTarget(context, &curRenderTarget));
// Invalidate FBOs with this Image attached. Only currently applies to D3D11.
for (egl::ImageSibling *target : mState.targets)
{
target->onStateChange(context, angle::SubjectMessage::STORAGE_CHANGED);
}
return mRenderer->createRenderTargetCopy(context, curRenderTarget, &mRenderTarget);
}
gl::Error EGLImageD3D::copyToLocalRendertarget()
{
ASSERT(mBuffer != nullptr);
ASSERT(mAttachmentBuffer != nullptr);
ASSERT(mRenderTarget == nullptr);
RenderTargetD3D *curRenderTarget = nullptr;
gl::Error error = getRenderTarget(&curRenderTarget);
if (error.isError())
{
return error;
}
// Clear the source image buffers
mBuffer = nullptr;
mAttachmentBuffer = nullptr;
return mRenderer->createRenderTargetCopy(curRenderTarget, &mRenderTarget);
}
