Water not visible in Realistic Water Scene Node

You are an experienced programmer and have a problem with the engine, shaders, or advanced effects? Here you'll get answers.
No questions about C++ programming or topics which are answered in the tutorials!
Post Reply
pyandrea
Posts: 11
Joined: Sun Jul 13, 2014 7:01 pm

Water not visible in Realistic Water Scene Node

Post by pyandrea »

I would like to show a terrain on ocean water, for which reason I 'merged' the code of Irrlicht's Example 12 and Elvman's Realistic Water Scene Node (http://irrlicht.sourceforge.net/forum// ... hp?t=23453). However, the result is that the terrain is visualized but water is not visible.
I suspect that the bug relies in the inizialization of the Realistic Scene Node, but I can't figure how to solve the problem:

Code: Select all

    RealisticWaterSceneNode* realwater = new RealisticWaterSceneNode(device->getSceneManager(), 640, 480);
    realwater->setPosition(core::vector3df(0, 0, 0));
    realwater->setWaterColor(video::SColor(255, 0, 0, 255));
    realwater->setWindForce(10);
    realwater->setPosition(core::vector3df(0, 0, 0));
Please, can you suggest me how to visualize the terrain on ocean water?

P.S. Here is the full code:

Code: Select all

 
/** Example 012 Terrain Rendering
 
#include <irrlicht.h>
#include "driverChoice.h"
#include "../../media/water/RealisticWater.h"
 
using namespace irr;
 
#ifdef _MSC_VER
#pragma comment(lib, "Irrlicht.lib")
#endif
 
// WATER
scene::ISceneNode* SkyBox = 0;
 
RealisticWaterSceneNode::RealisticWaterSceneNode(scene::ISceneManager* sceneManager, f32 width, f32 height,
    const irr::core::stringc& resourcePath, core::dimension2du renderTargetSize,
    scene::ISceneNode* parent, s32 id) :
    scene::ISceneNode(parent, sceneManager, id), _time(0),
    _size(width, height), _sceneManager(sceneManager), _refractionMap(NULL), _reflectionMap(NULL),
    _windForce(20.0f), _windDirection(0, 1), _waveHeight(0.3f), _waterColor(0.1f, 0.1f, 0.6f, 1.0f), _colorBlendFactor(0.2f), _camera(NULL)
{
        _videoDriver = sceneManager->getVideoDriver();
 
        //create new camera
        _camera = sceneManager->addCameraSceneNode(0, core::vector3df(0, 0, 0), core::vector3df(0, 0, 0), -1, false);
 
        _waterMesh = sceneManager->addHillPlaneMesh("RealisticWater", _size, core::dimension2d<u32>(1, 1));
 
        _waterSceneNode = sceneManager->addMeshSceneNode(_waterMesh->getMesh(0), this);
 
        video::IGPUProgrammingServices* GPUProgrammingServices = _videoDriver->getGPUProgrammingServices();
 
        core::stringc waterPixelShader;
        core::stringc waterVertexShader;
 
        if (_videoDriver->getDriverType() == video::EDT_DIRECT3D9)
        {
            waterPixelShader = "../../media/water/shaders/Water_ps.hlsl";
            waterVertexShader = "../../media/water/shaders/Water_vs.hlsl";
        }
        else if (_videoDriver->getDriverType() == video::EDT_OPENGL)
        {
            waterPixelShader = "../../media/water/shaders/Water_ps.glsl";
            waterVertexShader = "../../media/water/shaders/Water_vs.glsl";
        }
 
        _shaderMaterial = GPUProgrammingServices->addHighLevelShaderMaterialFromFiles(
            waterVertexShader.c_str(), "main", video::EVST_VS_1_1,
            waterPixelShader.c_str(), "main", video::EPST_PS_1_1,
            this);
 
        _waterSceneNode->setMaterialType((video::E_MATERIAL_TYPE)_shaderMaterial);
 
        irr::video::ITexture* bumpTexture = _videoDriver->getTexture("../../media/water/data/waterbump.png");
        _waterSceneNode->setMaterialTexture(0, bumpTexture);
 
        _refractionMap = _videoDriver->addRenderTargetTexture(renderTargetSize);
        _reflectionMap = _videoDriver->addRenderTargetTexture(renderTargetSize);
 
        _waterSceneNode->setMaterialTexture(1, _refractionMap);
        _waterSceneNode->setMaterialTexture(2, _reflectionMap);
    }
 
RealisticWaterSceneNode::~RealisticWaterSceneNode()
{
    if (_camera)
    {
        _camera->drop();
        _camera = NULL;
    }
 
    if (_refractionMap)
    {
        _refractionMap->drop();
        _refractionMap = NULL;
    }
 
    if (_reflectionMap)
    {
        _reflectionMap->drop();
        _reflectionMap = NULL;
    }
 
    if (_waterSceneNode)
    {
        _waterSceneNode->drop();
        _waterSceneNode = NULL;
    }
 
    if (_waterMesh)
    {
        _waterMesh->drop();
        _waterMesh = NULL;
    }
}
 
// frame
void RealisticWaterSceneNode::OnRegisterSceneNode()
{
    ISceneNode::OnRegisterSceneNode();
 
    if (IsVisible)
    {
        _sceneManager->registerNodeForRendering(this);
    }
}
 
void RealisticWaterSceneNode::OnAnimate(u32 timeMs)
{
    ISceneNode::OnAnimate(timeMs);
 
    _time = timeMs;
 
    //fixes glitches with incomplete refraction
    const f32 CLIP_PLANE_OFFSET_Y = 5.0f;
 
    if (IsVisible)
    {
        setVisible(false); //hide the water
 
        //refraction
        _videoDriver->setRenderTarget(_refractionMap, true, true); //render to refraction
 
        //refraction clipping plane
        core::plane3d<f32> refractionClipPlane(0, RelativeTranslation.Y + CLIP_PLANE_OFFSET_Y, 0, 0, -1, 0); //refraction clip plane
        _videoDriver->setClipPlane(0, refractionClipPlane, true);
 
        _sceneManager->drawAll(); //draw the scene
 
        //reflection
        _videoDriver->setRenderTarget(_reflectionMap, true, true); //render to reflection
 
        //get current camera
        scene::ICameraSceneNode* currentCamera = _sceneManager->getActiveCamera();
 
        //set FOV anf far value from current camera
        _camera->setFarValue(currentCamera->getFarValue());
        _camera->setFOV(currentCamera->getFOV());
 
        core::vector3df position = currentCamera->getAbsolutePosition();
        position.Y = -position.Y + 2 * RelativeTranslation.Y; //position of the water
        _camera->setPosition(position);
 
        core::vector3df target = currentCamera->getTarget();
 
        //invert Y position of current camera
        target.Y = -target.Y + 2 * RelativeTranslation.Y;
        _camera->setTarget(target);
 
        //set the reflection camera
        _sceneManager->setActiveCamera(_camera);
 
        //reflection clipping plane
        core::plane3d<f32> reflectionClipPlane(0, RelativeTranslation.Y - CLIP_PLANE_OFFSET_Y, 0, 0, 1, 0);
        _videoDriver->setClipPlane(0, reflectionClipPlane, true);
 
        _sceneManager->drawAll(); //draw the scene
 
        //disable clip plane
        _videoDriver->enableClipPlane(0, false);
 
        //set back old render target
        _videoDriver->setRenderTarget(0, false, true);
 
        //set back the active camera
        _sceneManager->setActiveCamera(currentCamera);
 
        setVisible(true); //show it again
    }
}
 
void RealisticWaterSceneNode::render()
{
    /*core::array<video::IRenderTarget> renderTargets;
    //renderTargets.push_back();
    renderTargets.push_back(_refractionMap);
 
    _videoDriver->setRenderTarget(renderTargets, true, true);*/
    //_videoDriver->draw2DImage(_reflectionMap,core::position2d<s32>(0,0));
}
 
// returns the axis aligned bounding box of terrain
const core::aabbox3d<f32>& RealisticWaterSceneNode::getBoundingBox() const
{
    return _waterSceneNode->getBoundingBox();
}
 
void RealisticWaterSceneNode::OnSetConstants(video::IMaterialRendererServices* services, s32 userData)
{
    video::IVideoDriver* driver = services->getVideoDriver();
 
    core::matrix4 projection = driver->getTransform(video::ETS_PROJECTION);
    core::matrix4 view = driver->getTransform(video::ETS_VIEW);
    core::matrix4 world = driver->getTransform(video::ETS_WORLD);
 
    core::matrix4 cameraView = _camera->getViewMatrix();
 
    //vertex shader constants
    //services->setVertexShaderConstant("View", view.pointer(), 16);
 
    core::matrix4 worldViewProj = projection;
    worldViewProj *= view;
    worldViewProj *= world;
 
    core::matrix4 worldReflectionViewProj = projection;
    worldReflectionViewProj *= cameraView;
    worldReflectionViewProj *= world;
 
    f32 waveLength = 0.1f;
    f32 time = _time / 100000.0f;
    core::vector3df cameraPosition = _sceneManager->getActiveCamera()->getPosition();
 
    bool fogEnabled = getMaterial(0).getFlag(video::EMF_FOG_ENABLE);
    irr::video::SColor color;
    irr::video::E_FOG_TYPE fogType;
    f32 start;
    f32 end;
    f32 density;
    bool pixelFog;
    bool rangeFog;
    driver->getFog(color, fogType, start, end, density, pixelFog, rangeFog);
 
#if (IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR == 9)
    services->setVertexShaderConstant(services->getVertexShaderConstantID("WorldViewProj"), worldViewProj.pointer(), 16);
    services->setVertexShaderConstant(services->getVertexShaderConstantID("WorldReflectionViewProj"), worldReflectionViewProj.pointer(), 16);
    services->setVertexShaderConstant(services->getVertexShaderConstantID("WaveLength"), &waveLength, 1);
    services->setVertexShaderConstant(services->getVertexShaderConstantID("Time"), &time, 1);
    services->setVertexShaderConstant(services->getVertexShaderConstantID("WindForce"), &_windForce, 1);
    services->setVertexShaderConstant(services->getVertexShaderConstantID("WindDirection"), &_windDirection.X, 2);
    services->setPixelShaderConstant(services->getVertexShaderConstantID("CameraPosition"), &cameraPosition.X, 3);
    services->setPixelShaderConstant(services->getVertexShaderConstantID("WaveHeight"), &_waveHeight, 1);
    services->setPixelShaderConstant(services->getVertexShaderConstantID("WaterColor"), &_waterColor.r, 4);
    services->setPixelShaderConstant(services->getVertexShaderConstantID("ColorBlendFactor"), &_colorBlendFactor, 1);
#else
    services->setVertexShaderConstant("WorldViewProj", worldViewProj.pointer(), 16);
    services->setVertexShaderConstant("WorldReflectionViewProj", worldReflectionViewProj.pointer(), 16);
    services->setVertexShaderConstant("WaveLength", &waveLength, 1);
    services->setVertexShaderConstant("Time", &time, 1);
    services->setVertexShaderConstant("WindForce", &_windForce, 1);
    services->setVertexShaderConstant("WindDirection", &_windDirection.X, 2);
    services->setPixelShaderConstant("CameraPosition", &cameraPosition.X, 3);
    services->setPixelShaderConstant("WaveHeight", &_waveHeight, 1);
    services->setPixelShaderConstant("WaterColor", &_waterColor.r, 4);
    services->setPixelShaderConstant("ColorBlendFactor", &_colorBlendFactor, 1);
#endif
 
    //texture constants for GLSL
    if (driver->getDriverType() == video::EDT_OPENGL)
    {
        int var0 = 0;
        int var1 = 1;
        int var2 = 2;
 
#if (IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR == 9)
        services->setPixelShaderConstant(services->getVertexShaderConstantID("WaterBump"), &var0, 1);
        services->setPixelShaderConstant(services->getVertexShaderConstantID("RefractionMap"), &var1, 1);
        services->setPixelShaderConstant(services->getVertexShaderConstantID("ReflectionMap"), &var2, 1);
 
        services->setPixelShaderConstant(services->getVertexShaderConstantID("FogEnabled"), (int*)&fogEnabled, 1);
        services->setPixelShaderConstant(services->getVertexShaderConstantID("FogMode"), (int*)&fogType, 1);
#else
        services->setPixelShaderConstant("WaterBump", &var0, 1);
        services->setPixelShaderConstant("RefractionMap", &var1, 1);
        services->setPixelShaderConstant("ReflectionMap", &var2, 1);
 
        services->setPixelShaderConstant("FogEnabled", (int*)&fogEnabled, 1);
        services->setPixelShaderConstant("FogMode", (int*)&fogType, 1);
#endif
    }
}
 
void RealisticWaterSceneNode::setWindForce(const f32 windForce)
{
    _windForce = windForce;
}
 
void RealisticWaterSceneNode::setWindDirection(const core::vector2df& windDirection)
{
    _windDirection = windDirection;
    _windDirection.normalize();
}
 
void RealisticWaterSceneNode::setWaveHeight(const f32 waveHeight)
{
    _waveHeight = waveHeight;
}
 
void RealisticWaterSceneNode::setWaterColor(const video::SColorf& waterColor)
{
    _waterColor = waterColor;
}
 
void RealisticWaterSceneNode::setColorBlendFactor(const f32 colorBlendFactor)
{
    _colorBlendFactor = colorBlendFactor;
}
 
 
// mostly code below is from Example 12
 
class MyEventReceiver : public IEventReceiver
{
public:
 
    MyEventReceiver(scene::ISceneNode* terrain, scene::ISceneNode* skybox, scene::ISceneNode* skydome) :
        Terrain(terrain), Skybox(skybox), Skydome(skydome), showBox(true), showDebug(false)
    {
        Skybox->setVisible(showBox);
        Skydome->setVisible(!showBox);
    }
 
    bool OnEvent(const SEvent& event)
    {
        // check if user presses the key 'W' or 'D'
        if (event.EventType == irr::EET_KEY_INPUT_EVENT && !event.KeyInput.PressedDown)
        {
            switch (event.KeyInput.Key)
            {
            case irr::KEY_KEY_W: // switch wire frame mode
                Terrain->setMaterialFlag(video::EMF_WIREFRAME,
                    !Terrain->getMaterial(0).Wireframe);
                Terrain->setMaterialFlag(video::EMF_POINTCLOUD, false);
                return true;
            case irr::KEY_KEY_P: // switch wire frame mode
                Terrain->setMaterialFlag(video::EMF_POINTCLOUD,
                    !Terrain->getMaterial(0).PointCloud);
                Terrain->setMaterialFlag(video::EMF_WIREFRAME, false);
                return true;
            case irr::KEY_KEY_D: // toggle detail map
                Terrain->setMaterialType(
                    Terrain->getMaterial(0).MaterialType == video::EMT_SOLID ?
                    video::EMT_DETAIL_MAP : video::EMT_SOLID);
                return true;
            case irr::KEY_KEY_S: // toggle skies
                showBox = !showBox;
                Skybox->setVisible(showBox);
                Skydome->setVisible(!showBox);
                return true;
            case irr::KEY_KEY_X: // toggle debug information
                showDebug = !showDebug;
                Terrain->setDebugDataVisible(showDebug ? scene::EDS_BBOX_ALL : scene::EDS_OFF);
                return true;
            default:
                break;
            }
        }
 
        return false;
    }
 
private:
    scene::ISceneNode* Terrain;
    scene::ISceneNode* Skybox;
    scene::ISceneNode* Skydome;
    bool showBox;
    bool showDebug;
};
 
 
/*
The start of the main function starts like in most other example. We ask the
user for the desired renderer and start it up. This time with the advanced
parameter handling.
*/
int main()
{
    // ask user for driver
    video::E_DRIVER_TYPE driverType = driverChoiceConsole();
    if (driverType == video::EDT_COUNT)
        return 1;
 
    // create device with full flexibility over creation parameters
    // you can add more parameters if desired, check irr::SIrrlichtCreationParameters
    irr::SIrrlichtCreationParameters params;
    params.DriverType = driverType;
    params.WindowSize = core::dimension2d<u32>(640, 480);
    IrrlichtDevice* device = createDeviceEx(params);
 
    if (device == 0)
        return 1; // could not create selected driver.
 
 
    /*
    First, we add standard stuff to the scene: A nice irrlicht engine
    logo, a small help text, a user controlled camera, and we disable
    the mouse cursor.
    */
 
    video::IVideoDriver* driver = device->getVideoDriver();
    scene::ISceneManager* smgr = device->getSceneManager();
    gui::IGUIEnvironment* env = device->getGUIEnvironment();
 
    driver->setTextureCreationFlag(video::ETCF_ALWAYS_32_BIT, true);
 
    // add irrlicht logo
    env->addImage(driver->getTexture("../../media/irrlichtlogo2.png"),
        core::position2d<s32>(10, 10));
 
    //set other font
    env->getSkin()->setFont(env->getFont("../../media/fontlucida.png"));
 
    // add some help text
    env->addStaticText(
        L"Press 'W' to change wireframe mode\nPress 'D' to toggle detail map\nPress 'S' to toggle skybox/skydome",
        core::rect<s32>(10, 421, 250, 475), true, true, 0, -1, true);
 
    // add camera
    
    scene::ICameraSceneNode* camera =
    smgr->addCameraSceneNodeFPS();
 
    camera->setPosition(core::vector3df(0, 10000, 1000));
    camera->setTarget(core::vector3df(2397 * 2, 343 * 2, 2700 * 2));
    camera->setFarValue(42000.0f);
 
    // disable mouse cursor
    device->getCursorControl()->setVisible(false);
    
 
    /*
    Here comes the terrain renderer scene node: We add it just like any
    other scene node to the scene using
    ISceneManager::addTerrainSceneNode(). The only parameter we use is a
    file name to the heightmap we use. A heightmap is simply a gray scale
    texture. The terrain renderer loads it and creates the 3D terrain from
    it.
 
    To make the terrain look more big, we change the scale factor of
    it to (40, 4.4, 40). Because we don't have any dynamic lights in the
    scene, we switch off the lighting, and we set the file
    terrain-texture.jpg as texture for the terrain and detailmap3.jpg as
    second texture, called detail map. At last, we set the scale values for
    the texture: The first texture will be repeated only one time over the
    whole terrain, and the second one (detail map) 20 times.
    */
 
    // add terrain scene node
    scene::ITerrainSceneNode* terrain = smgr->addTerrainSceneNode(
        "../../media/terrain-heightmap.bmp",
        0,                  // parent node
        -1,                 // node id
        core::vector3df(0, 0, 0),       // position
        core::vector3df(0.f, 0.f, 0.f),     // rotation
        core::vector3df(40.f, 4.4f, 40.f),  // scale
        video::SColor(255, 255, 255, 255),  // vertexColor
        5,                  // maxLOD
        scene::ETPS_17,             // patchSize
        4                   // smoothFactor
        );
 
    terrain->setMaterialFlag(video::EMF_LIGHTING, false);
 
    terrain->setMaterialTexture(0,
        driver->getTexture("../../media/terrain-texture.jpg"));
    terrain->setMaterialTexture(1,
        driver->getTexture("../../media/detailmap3.jpg"));
 
    terrain->setMaterialType(video::EMT_DETAIL_MAP);
 
    terrain->scaleTexture(1.0f, 20.0f);
 
    /*
    To be able to do collision with the terrain, we create a triangle selector.
    If you want to know what triangle selectors do, just take a look into the
    collision tutorial. The terrain triangle selector works together with the
    terrain. To demonstrate this, we create a collision response animator
    and attach it to the camera, so that the camera will not be able to fly
    through the terrain.
    */
 
    // create triangle selector for the terrain 
    scene::ITriangleSelector* selector
        = smgr->createTerrainTriangleSelector(terrain, 0);
    terrain->setTriangleSelector(selector);
 
    // create collision response animator and attach it to the camera
    scene::ISceneNodeAnimator* anim = smgr->createCollisionResponseAnimator(
        selector, camera, core::vector3df(60, 100, 60),
        core::vector3df(0, 0, 0),
        core::vector3df(0, 50, 0));
    selector->drop();
    camera->addAnimator(anim);
    anim->drop();
 
    /* If you need access to the terrain data you can also do this directly via the following code fragment.
    */
    scene::CDynamicMeshBuffer* buffer = new scene::CDynamicMeshBuffer(video::EVT_2TCOORDS, video::EIT_16BIT);
    terrain->getMeshBufferForLOD(*buffer, 0);
    video::S3DVertex2TCoords* data = (video::S3DVertex2TCoords*)buffer->getVertexBuffer().getData();
    // Work on data or get the IndexBuffer with a similar call.
    buffer->drop(); // When done drop the buffer again.
 
    /*
    To make the user be able to switch between normal and wireframe mode,
    we create an instance of the event receiver from above and let Irrlicht
    know about it. In addition, we add the skybox which we already used in
    lots of Irrlicht examples and a skydome, which is shown mutually
    exclusive with the skybox by pressing 'S'.
    */
 
    // create skybox and skydome
    driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, false);
 
    scene::ISceneNode* skybox = smgr->addSkyBoxSceneNode(
        driver->getTexture("../../media/irrlicht2_up.jpg"),
        driver->getTexture("../../media/irrlicht2_dn.jpg"),
        driver->getTexture("../../media/irrlicht2_lf.jpg"),
        driver->getTexture("../../media/irrlicht2_rt.jpg"),
        driver->getTexture("../../media/irrlicht2_ft.jpg"),
        driver->getTexture("../../media/irrlicht2_bk.jpg"));
    scene::ISceneNode* skydome = smgr->addSkyDomeSceneNode(driver->getTexture("../../media/skydome.jpg"), 16, 8, 0.95f, 2.0f);
 
    driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, true);
 
 
    //water, but it does not work
 
    RealisticWaterSceneNode* realwater = new RealisticWaterSceneNode(device->getSceneManager(), 640, 480);
    
    realwater->setPosition(core::vector3df(0, 0, 0));
    realwater->setWaterColor(video::SColor(255, 0, 0, 255));
    realwater->setWindForce(10);
    realwater->setPosition(core::vector3df(0, 0, 0));
    
 
 
    // create event receiver
    MyEventReceiver receiver(terrain, skybox, skydome);
    device->setEventReceiver(&receiver);
 
    /*
    That's it, draw everything.
    */
 
    int lastFPS = -1;
 
    while (device->run())
    if (device->isWindowActive())
    {
        driver->beginScene(true, true, 0);
 
        smgr->drawAll();
        env->drawAll();
 
        driver->endScene();
 
        // display frames per second in window title
        int fps = driver->getFPS();
        if (lastFPS != fps)
        {
            core::stringw str = L"Terrain Renderer - Irrlicht Engine [";
            str += driver->getName();
            str += "] FPS:";
            str += fps;
            // Also print terrain height of current camera position
            // We can use camera position because terrain is located at coordinate origin
            str += " Height: ";
            str += terrain->getHeight(camera->getAbsolutePosition().X,
                camera->getAbsolutePosition().Z);
 
            device->setWindowCaption(str.c_str());
            lastFPS = fps;
        }
    }
 
    device->drop();
 
    return 0;
}
 
/*
Now you know how to use terrain in Irrlicht.
**/
 
christianclavet
Posts: 1638
Joined: Mon Apr 30, 2007 3:24 am
Location: Montreal, CANADA
Contact:

Re: Water not visible in Realistic Water Scene Node

Post by christianclavet »

Can you take the information output from the console when you are using the debug application? Perhaps your shader fail to compile. I see that you commented off a lot of the realistic scene node, perhaps it could explain why it don't render.
Post Reply