zaki
/
irrlicht
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

- Removed old IVideoDriver::setRenderTarget method. 

- Fixed OpenGL RTT.
- Fixed compilation issues in some unit tests.

git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@5072 dfc29bdd-3216-0410-991c-e03cc46cb475
master
nadro 2015-03-31 19:07:17 +00:00
parent 9fd80a50ee
commit ed12a085f3
8 changed files with 104 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
include/IVideoDriver.h
View File

@ -525,42 +525,6 @@ namespace video
information is multiplied.*/
virtual void makeNormalMapTexture(video::ITexture* texture, f32 amplitude=1.0f) const =0;
//! Set a new render target.
/** This will only work if the driver supports the
EVDF_RENDER_TO_TARGET feature, which can be queried with
queryFeature(). Usually, rendering to textures is done in this
way:
\code
// create render target
ITexture* target = driver->addRenderTargetTexture(core::dimension2d<u32>(128,128), "rtt1");
// ...
driver->setRenderTarget(target); // set render target
// .. draw stuff here
driver->setRenderTarget(0); // set previous render target
\endcode
Please note that you cannot render 3D or 2D geometry with a
render target as texture on it when you are rendering the scene
into this render target at the same time. It is usually only
possible to render into a texture between the
IVideoDriver::beginScene() and endScene() method calls.
\param texture New render target. Must be a texture created with
IVideoDriver::addRenderTargetTexture(). If set to 0, it sets
the previous render target which was set before the last
setRenderTarget() call.
\param clearBackBuffer Clears the backbuffer of the render
target with the color parameter
\param clearZBuffer Clears the zBuffer of the rendertarget.
Note that because the frame buffer may share the zbuffer with
the rendertarget, its zbuffer might be partially cleared too
by this.
\param color The background color for the render target.
\return True if sucessful and false if not. */
virtual bool setRenderTarget(video::ITexture* texture,
bool clearBackBuffer=true, bool clearZBuffer=true,
SColor color=video::SColor(0,0,0,0)) =0;
//! Set a render target.
/** This will only work if the driver supports the
EVDF_RENDER_TO_TARGET feature, which can be queried with
@ -580,11 +544,11 @@ namespace video
\param clearColor The clear color for the render target.
\return True if sucessful and false if not. */
virtual bool setRenderTarget(IRenderTarget* target, core::array<u32> activeTextureID, bool clearBackBuffer,
bool clearDepthBuffer, bool clearStencilBuffer, SColor clearColor) = 0;
bool clearDepthBuffer, bool clearStencilBuffer, SColor clearColor = video::SColor(255,0,0,0)) = 0;
//! Set a render target.
bool setRenderTarget(IRenderTarget* target, u32 activeTextureID, bool clearBackBuffer, bool clearDepthBuffer,
bool clearStencilBuffer, SColor clearColor)
bool clearStencilBuffer, SColor clearColor = video::SColor(255,0,0,0))
{
core::array<u32> idArray(1);
idArray.push_back(activeTextureID);

7
source/Irrlicht/CNullDriver.cpp
View File

@ -617,13 +617,6 @@ ITexture* CNullDriver::createDeviceDependentTexture(IImage* surface, const io::p
}
//! set a render target
bool CNullDriver::setRenderTarget(video::ITexture* texture, bool clearBackBuffer, bool clearZBuffer, SColor color)
{
return false;
}
//! set a render target
bool CNullDriver::setRenderTarget(IRenderTarget* target, core::array<u32> activeTextureID, bool clearBackBuffer,
bool clearDepthBuffer, bool clearStencilBuffer, SColor clearColor)

3
source/Irrlicht/CNullDriver.h
View File

@ -100,9 +100,6 @@ namespace video
//! creates a Texture
virtual ITexture* addTexture(const core::dimension2d<u32>& size, const io::path& name, ECOLOR_FORMAT format = ECF_A8R8G8B8) _IRR_OVERRIDE_;
//! set a render target
virtual bool setRenderTarget(ITexture* texture, bool clearBackBuffer, bool clearZBuffer, SColor color) _IRR_OVERRIDE_;
//! set a render target
virtual bool setRenderTarget(IRenderTarget* target, core::array<u32> activeTextureID, bool clearBackBuffer,
bool clearDepthBuffer, bool clearStencilBuffer, SColor clearColor) _IRR_OVERRIDE_;

4
source/Irrlicht/COpenGLRenderTarget.cpp
View File

@ -147,7 +147,7 @@ void COpenGLRenderTarget::setTexture(const core::array<ITexture*>& texture, ITex
for (u32 i = 0; i < Texture.size(); ++i)
{
GLuint textureID = (texture[i] && texture[i]->getDriverType() == EDT_OPENGL) ? static_cast<COpenGLTexture*>(depthStencil)->getOpenGLTextureName() : 0;
GLuint textureID = (texture[i] && texture[i]->getDriverType() == EDT_OPENGL) ? static_cast<COpenGLTexture*>(texture[i])->getOpenGLTextureName() : 0;
if (textureID != 0)
{
@ -296,7 +296,7 @@ void COpenGLRenderTarget::update(const core::array<u32>& id)
const u32 mrtSize = core::min_(size, static_cast<u32>(Driver->MaxMultipleRenderTargets));
for (u32 i = 0; i < mrtSize; ++i)
target[i + id[i]] = GL_COLOR_ATTACHMENT0 + id[i];
target[id[i]] = GL_COLOR_ATTACHMENT0 + id[i];
Driver->extGlDrawBuffers(mrtSize, target);

31
tests/draw2DImage.cpp
View File

@ -28,20 +28,26 @@ bool testWithRenderTarget(video::E_DRIVER_TYPE driverType)
logTestString("Testing driver %ls\n", driver->getName());
video::ITexture* RenderTarget=driver->addRenderTargetTexture(core::dimension2d<u32>(64,64), "BASEMAP");
video::ITexture* renderTargetTex = driver->addRenderTargetTexture(core::dimension2d<u32>(64, 64), "BASEMAP");
video::ITexture* renderTargetDepth = driver->addRenderTargetTexture(core::dimension2d<u32>(64, 64), "rtd", video::ECF_D16);
video::ITexture *tex=driver->getTexture("../media/water.jpg");
video::IRenderTarget* renderTarget = driver->addRenderTarget();
renderTarget->setTexture(renderTargetTex, renderTargetDepth);
video::ITexture* tex=driver->getTexture("../media/water.jpg");
driver->beginScene(true, true, video::SColor(255,255,0,255));//Backbuffer background is pink
//draw the 256x256 water image on the rendertarget:
driver->setRenderTarget(RenderTarget,true,true,video::SColor(255,0,0,255));//Rendertarget background is blue
driver->setRenderTarget(renderTarget,0,true,true,false,video::SColor(255,0,0,255));//Rendertarget background is blue
driver->draw2DImage(tex, core::position2d<s32>(0,0), core::recti(0,0,32,32));
driver->setRenderTarget(0, false);
driver->setRenderTarget(0, 0, false, false, false);
//draw the rendertarget on screen:
//this should normally draw a 64x64 image containing a 32x32 image in the top left corner
driver->draw2DImage(RenderTarget, core::position2d<s32>(0,0));
driver->draw2DImage(renderTargetTex, core::position2d<s32>(0,0));
driver->endScene();
bool result = takeScreenshotAndCompareAgainstReference(driver, "-draw2DImageRTT.png");
@ -150,16 +156,21 @@ bool testExactPlacement(video::E_DRIVER_TYPE driverType)
logTestString("Testing driver %ls\n", driver->getName());
video::ITexture* rt=driver->addRenderTargetTexture(core::dimension2d<u32>(32,32), "rt1");
video::ITexture *tex=driver->getTexture("../media/fireball.bmp");
video::ITexture* renderTargetTex = driver->addRenderTargetTexture(core::dimension2d<u32>(32, 32), "rt1");
video::ITexture* renderTargetDepth = driver->addRenderTargetTexture(core::dimension2d<u32>(32, 32), "rtd", video::ECF_D16);
video::IRenderTarget* renderTarget = driver->addRenderTarget();
renderTarget->setTexture(renderTargetTex, renderTargetDepth);
video::ITexture* tex=driver->getTexture("../media/fireball.bmp");
driver->beginScene(true, true, video::SColor(255,40,40,255));//Backbuffer background is blue
driver->setRenderTarget(rt);
driver->setRenderTarget(renderTarget, 0, true, true, true);
driver->draw2DImage(tex, core::recti(0,0,32,32), core::recti(0,0,64,64));
driver->setRenderTarget(0);
driver->setRenderTarget(0, 0, false, false, false);
driver->endScene();
video::IImage* img = driver->createImage(rt, core::vector2di(), rt->getSize());
video::IImage* img = driver->createImage(renderTargetTex, core::vector2di(), renderTargetTex->getSize());
driver->writeImageToFile(img, "results/fireball.png");
img->drop();
bool result = fuzzyCompareImages(driver, "media/fireball.png", "results/fireball.png")>98.25f;

2
tests/makeColorKeyTexture.cpp
View File

@ -49,7 +49,7 @@ static bool doTestWith(E_DRIVER_TYPE driverType,
driver->endScene();
char screenshotName[256];
(void)snprintf(screenshotName, 256, "-makeColorKeyTexture-%s.png",
(void)snprintf_irr(screenshotName, 256, "-makeColorKeyTexture-%s.png",
zeroTexels? "old" : "new");
bool result = takeScreenshotAndCompareAgainstReference(driver, screenshotName);

51
tests/mrt.cpp
View File

@ -25,20 +25,31 @@ static bool testWithDriver(video::E_DRIVER_TYPE driverType)
const char* const ps2="void main(void)\n {\n gl_FragData[0] = vec4(1.0,1.0,1.0,1.0);\n gl_FragData[1] = vec4(0.0,1.0,0.0,1.0);\n gl_FragData[2] = vec4(0.0,0.0,1.0,1.0);\n }";
// variable
video::ITexture* gbuffer[3];
core::array<video::IRenderTarget> gbufferlist;
video::IRenderTarget* renderTarget = 0;
core::array<video::ITexture*> renderTargetTex;
video::ITexture* renderTargetDepth = 0;
core::array<u32> renderTargetID;
const core::dimension2du texsize(64,64);
bool result=true;
s32 newMaterialType = -1;
if (device->getVideoDriver()->getDriverAttributes().getAttributeAsInt("MaxMultipleRenderTargets") > 2)
{
// allocate buffer
gbuffer[0] = driver->addRenderTargetTexture(texsize, "rta", video::ECF_A8R8G8B8);
gbuffer[1] = driver->addRenderTargetTexture(texsize, "rtb", video::ECF_A8R8G8B8);
gbuffer[2] = driver->addRenderTargetTexture(texsize, "rtc", video::ECF_A8R8G8B8);
for( u32 i = 0; i < 3; ++i )
gbufferlist.push_back( video::IRenderTarget(gbuffer[i]) );
renderTargetTex.set_used(3);
renderTargetTex[0] = driver->addRenderTargetTexture(texsize, "rta", video::ECF_A8R8G8B8);
renderTargetTex[1] = driver->addRenderTargetTexture(texsize, "rtb", video::ECF_A8R8G8B8);
renderTargetTex[2] = driver->addRenderTargetTexture(texsize, "rtc", video::ECF_A8R8G8B8);
renderTargetDepth = driver->addRenderTargetTexture(texsize, "rtd", video::ECF_D16);
renderTargetID.set_used(3);
renderTargetID[0] = 0;
renderTargetID[1] = 1;
renderTargetID[2] = 2;
renderTarget = driver->addRenderTarget();
renderTarget->setTexture(renderTargetTex, renderTargetDepth);
video::IGPUProgrammingServices* gpu = driver->getGPUProgrammingServices();
@ -57,32 +68,32 @@ static bool testWithDriver(video::E_DRIVER_TYPE driverType)
node->setMaterialType((video::E_MATERIAL_TYPE)newMaterialType);
device->getSceneManager()->addCameraSceneNode(0, core::vector3df(0,0,-10));
driver->beginScene (true, true, video::SColor (255, 200, 200, 200));
driver->beginScene(true, false, video::SColor(255, 0, 0, 0));
// render
driver->setRenderTarget( gbufferlist );
driver->setRenderTarget(renderTarget, renderTargetID, true, true, false, video::SColor(255, 0, 0, 0));
device->getSceneManager()->drawAll();
driver->setRenderTarget(0);
driver->setRenderTarget(0, renderTargetID, false, false, false, video::SColor(255, 0, 0, 0));
// draw debug rt
driver->draw2DImage(gbuffer[0], core::position2d<s32>(0,0));
driver->draw2DImage(gbuffer[1], core::position2d<s32>(64,0));
driver->draw2DImage(gbuffer[2], core::position2d<s32>(128,0));
driver->draw2DImage(renderTargetTex[0], core::position2d<s32>(0,0));
driver->draw2DImage(renderTargetTex[1], core::position2d<s32>(64,0));
driver->draw2DImage(renderTargetTex[2], core::position2d<s32>(128,0));
driver->endScene();
result = takeScreenshotAndCompareAgainstReference(driver, "-mrt.png");
driver->beginScene (true, true, video::SColor (255, 200, 200, 200));
driver->beginScene(true, false, video::SColor(255, 0, 0, 0));
// render
device->getSceneManager()->getActiveCamera()->setPosition(core::vector3df(0,0,-15));
driver->setRenderTarget( gbufferlist );
driver->setRenderTarget(renderTarget, renderTargetID, true, true, false, video::SColor(255, 0, 0, 0));
device->getSceneManager()->drawAll();
driver->setRenderTarget(0);
driver->setRenderTarget(0, renderTargetID, false, false, false, video::SColor(255, 0, 0, 0));
// draw debug rt
driver->draw2DImage(gbuffer[0], core::position2d<s32>(0,0));
driver->draw2DImage(gbuffer[1], core::position2d<s32>(64,0));
driver->draw2DImage(gbuffer[2], core::position2d<s32>(128,0));
driver->draw2DImage(renderTargetTex[0], core::position2d<s32>(0,0));
driver->draw2DImage(renderTargetTex[1], core::position2d<s32>(64,0));
driver->draw2DImage(renderTargetTex[2], core::position2d<s32>(128,0));
driver->endScene();

79
tests/renderTargetTexture.cpp
View File

@ -137,7 +137,12 @@ bool rttAndZBuffer(video::E_DRIVER_TYPE driverType)
logTestString("Testing driver %ls\n", vd->getName());
video::ITexture* rt = vd->addRenderTargetTexture(cp.WindowSize, "rt", video::ECF_A32B32G32R32F);
video::ITexture* renderTargetTex = vd->addRenderTargetTexture(cp.WindowSize, "rt", video::ECF_A32B32G32R32F);
video::ITexture* renderTargetDepth = vd->addRenderTargetTexture(cp.WindowSize, "rtd", video::ECF_D16);
video::IRenderTarget* renderTarget = vd->addRenderTarget();
renderTarget->setTexture(renderTargetTex, renderTargetDepth);
video::S3DVertex vertices[4];
vertices[0].Pos.Z = vertices[1].Pos.Z = vertices[2].Pos.Z = vertices[3].Pos.Z = 1.0f;
vertices[0].Pos.Y = vertices[1].Pos.Y = 1.0f;
@ -185,13 +190,13 @@ bool rttAndZBuffer(video::E_DRIVER_TYPE driverType)
{
vd->beginScene(true, true, video::SColor(255, 0, 0, 0));
vd->setRenderTarget(rt);
vd->setRenderTarget(renderTarget, 0, true, true, false);
sm->drawAll();
vd->setRenderTarget(NULL);
vd->setRenderTarget(0, 0, false, false, false);
vd->setTransform(video::ETS_WORLD, core::IdentityMatrix);
vd->setTransform(video::ETS_VIEW, core::IdentityMatrix);
vd->setTransform(video::ETS_PROJECTION, core::IdentityMatrix);
rtMat.setTexture(0, rt);
rtMat.setTexture(0, renderTargetTex);
vd->setMaterial(rtMat);
vd->drawIndexedTriangleList(vertices, 4, indices, 2);
vd->endScene();
@ -228,29 +233,26 @@ bool rttAndText(video::E_DRIVER_TYPE driverType)
logTestString("Testing driver %ls\n", driver->getName());
//RTT
video::ITexture* rt = driver->addRenderTargetTexture(core::dimension2d<u32>(256, 256), "rt");
if (!rt)
{
device->closeDevice();
device->run();
device->drop();
return false;
}
video::ITexture* renderTargetTex = driver->addRenderTargetTexture(core::dimension2d<u32>(256, 256), "rt");
video::ITexture* renderTargetDepth = driver->addRenderTargetTexture(core::dimension2d<u32>(256, 256), "rtd", video::ECF_D16);
video::IRenderTarget* renderTarget = driver->addRenderTarget();
renderTarget->setTexture(renderTargetTex, renderTargetDepth);
stabilizeScreenBackground(driver);
driver->beginScene(true, true, video::SColor(255,255, 255, 255));
driver->setRenderTarget(rt, true, true, video::SColor(255,255,0,255));
driver->draw2DImage(driver->getTexture("../media/fireball.bmp"), core::recti(0, 0,rt->getSize().Width,rt->getSize().Height), core::recti(0,0,64,64));
driver->setRenderTarget(renderTarget, 0, true, true, false, video::SColor(255,255,0,255));
driver->draw2DImage(driver->getTexture("../media/fireball.bmp"), core::recti(0, 0, renderTargetTex->getSize().Width, renderTargetTex->getSize().Height), core::recti(0, 0, 64, 64));
guienv->getBuiltInFont()->draw(L"OMGGG =!", core::rect<s32>(120, 100, 256, 256), video::SColor(255, 0, 0, 255));
driver->setRenderTarget(0);
driver->setRenderTarget(0, 0, false, false, false);
driver->endScene();
scene::ISceneManager* smgr = device->getSceneManager();
scene::ISceneNode* cube = smgr->addCubeSceneNode(20);
cube->setMaterialFlag(video::EMF_LIGHTING, false);
cube->setMaterialTexture(0, rt); // set material of cube to render target
cube->setMaterialTexture(0, renderTargetTex); // set material of cube to render target
smgr->addCameraSceneNode(0, core::vector3df(0, 0, -30));
@ -280,11 +282,11 @@ bool rttAndText(video::E_DRIVER_TYPE driverType)
return result;
}
static void Render(IrrlichtDevice* device, video::ITexture* rt, core::vector3df& pos1,
static void Render(IrrlichtDevice* device, video::IRenderTarget* rt, core::vector3df& pos1,
core::vector3df& pos2, scene::IAnimatedMesh* sphereMesh, core::vector3df& pos3, core::vector3df& pos4)
{
video::IVideoDriver* driver = device->getVideoDriver();
driver->setRenderTarget(rt);
driver->setRenderTarget(rt, 0, true, true, false);
device->getSceneManager()->drawAll();
video::SMaterial mat;
@ -369,25 +371,38 @@ bool rttAndAntiAliasing(video::E_DRIVER_TYPE driverType)
core::dimension2du dim_txt = core::dimension2du(160/2, 120/2);
video::ITexture* rt1 = device->getVideoDriver()->addRenderTargetTexture(dim_txt, "rt1", device->getColorFormat());
video::ITexture* rt2 = device->getVideoDriver()->addRenderTargetTexture(dim_txt, "rt2", device->getColorFormat());
video::ITexture* rt3 = device->getVideoDriver()->addRenderTargetTexture(dim_txt, "rt3", video::ECF_A8R8G8B8);
video::ITexture* rt4 = device->getVideoDriver()->addRenderTargetTexture(dim_txt, "rt4", device->getColorFormat());
video::ITexture* renderTargetTex1 = driver->addRenderTargetTexture(dim_txt, "rt1", device->getColorFormat());
video::ITexture* renderTargetTex2 = driver->addRenderTargetTexture(dim_txt, "rt2", device->getColorFormat());
video::ITexture* renderTargetTex3 = driver->addRenderTargetTexture(dim_txt, "rt3", video::ECF_A8R8G8B8);
video::ITexture* renderTargetTex4 = driver->addRenderTargetTexture(dim_txt, "rt4", device->getColorFormat());
video::ITexture* renderTargetDepth = driver->addRenderTargetTexture(dim_txt, "rtd", video::ECF_D16);
video::IRenderTarget* renderTarget1 = driver->addRenderTarget();
renderTarget1->setTexture(renderTargetTex1, renderTargetDepth);
video::IRenderTarget* renderTarget2 = driver->addRenderTarget();
renderTarget2->setTexture(renderTargetTex2, renderTargetDepth);
video::IRenderTarget* renderTarget3 = driver->addRenderTarget();
renderTarget3->setTexture(renderTargetTex3, renderTargetDepth);
video::IRenderTarget* renderTarget4 = driver->addRenderTarget();
renderTarget4->setTexture(renderTargetTex4, renderTargetDepth);
device->getSceneManager()->setActiveCamera(cam);
device->getVideoDriver()->beginScene();
#if 1
st->setText(L"Texture Rendering");
Render(device, rt1, pos1, pos2, sphereMesh, pos3, pos4);
Render(device, rt2, pos1, pos2, sphereMesh, pos3, pos4);
Render(device, rt3, pos1, pos2, sphereMesh, pos3, pos4);
Render(device, rt4, pos1, pos2, sphereMesh, pos3, pos4);
Render(device, renderTarget1, pos1, pos2, sphereMesh, pos3, pos4);
Render(device, renderTarget2, pos1, pos2, sphereMesh, pos3, pos4);
Render(device, renderTarget3, pos1, pos2, sphereMesh, pos3, pos4);
Render(device, renderTarget4, pos1, pos2, sphereMesh, pos3, pos4);
device->getVideoDriver()->setRenderTarget(0);
device->getVideoDriver()->draw2DImage(rt1, core::position2di(0,0));
device->getVideoDriver()->draw2DImage(rt2, core::position2di(80,0));
device->getVideoDriver()->draw2DImage(rt3, core::position2di(0,60));
device->getVideoDriver()->draw2DImage(rt4, core::position2di(80,60));
device->getVideoDriver()->setRenderTarget(0, 0, false, false, false);
device->getVideoDriver()->draw2DImage(renderTargetTex1, core::position2di(0, 0));
device->getVideoDriver()->draw2DImage(renderTargetTex2, core::position2di(80, 0));
device->getVideoDriver()->draw2DImage(renderTargetTex3, core::position2di(0, 60));
device->getVideoDriver()->draw2DImage(renderTargetTex4, core::position2di(80, 60));
#else
ITexture* rt0 = NULL;
Render(device, rt0, pos1, pos2, sphereMesh, pos3, pos4);
@ -395,7 +410,7 @@ bool rttAndAntiAliasing(video::E_DRIVER_TYPE driverType)
st->draw();
device->getVideoDriver()->endScene();
bool result = takeScreenshotAndCompareAgainstReference(driver, "-rttAndAntiAlias.png");
bool result = takeScreenshotAndCompareAgainstReference(driver, "-rttAndAntiAlias.png", 98.25f);
device->closeDevice();
device->run();