471 lines
16 KiB
C++
471 lines
16 KiB
C++
#include <iostream>
|
|
#include <Ogre.h>
|
|
#include <OgreColourValue.h>
|
|
#include <OgreShaderSubRenderState.h>
|
|
#include <OgreShaderGenerator.h>
|
|
#include <OgreRTShaderSystem.h>
|
|
#include <BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h>
|
|
#include <BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h>
|
|
#include <BulletCollision/NarrowPhaseCollision/btPointCollector.h>
|
|
#include "GameData.h"
|
|
#include "Components.h"
|
|
#include "WaterModule.h"
|
|
#include <tracy/Tracy.hpp>
|
|
namespace ECS
|
|
{
|
|
#if 0
|
|
class WaterPhysicsAction : public btActionInterface {
|
|
btPairCachingGhostObject *mWaterBody;
|
|
btManifoldArray mManifoldArray;
|
|
|
|
public:
|
|
btVector3 mShapeAabbMin, mShapeAabbMax;
|
|
btGjkEpaPenetrationDepthSolver *gjk_epa_pen_solver;
|
|
btVoronoiSimplexSolver *gjk_simplex_solver;
|
|
struct contact {
|
|
const btCollisionObject *body;
|
|
float mDistance;
|
|
btVector3 mNormal;
|
|
btVector3 mPoint;
|
|
bool mHasResult;
|
|
};
|
|
std::vector<struct contact> mContacts;
|
|
std::set<const btCollisionObject *> mInWater;
|
|
WaterPhysicsAction(btPairCachingGhostObject *waterBody)
|
|
: btActionInterface()
|
|
, mWaterBody(waterBody)
|
|
, mShapeAabbMin(0, 0, 0)
|
|
, mShapeAabbMax(0, 0, 0)
|
|
, gjk_epa_pen_solver(OGRE_NEW btGjkEpaPenetrationDepthSolver)
|
|
, gjk_simplex_solver(OGRE_NEW btVoronoiSimplexSolver)
|
|
{
|
|
mManifoldArray.reserve(160);
|
|
mManifoldArray.resize(0);
|
|
setupBody();
|
|
}
|
|
~WaterPhysicsAction()
|
|
{
|
|
}
|
|
void updateAction(btCollisionWorld *collisionWorld,
|
|
btScalar deltaTimeStep) override;
|
|
void debugDraw(btIDebugDraw *debugDrawer) override;
|
|
void setupBody();
|
|
bool isInWater(const btCollisionObject *body) const
|
|
{
|
|
return (mInWater.find(body) != mInWater.end());
|
|
}
|
|
};
|
|
#endif
|
|
static const uint32_t WATER_MASK = 0xF00;
|
|
static bool debugEnabled = false;
|
|
WaterModule::WaterModule(flecs::world &ecs)
|
|
{
|
|
ecs.module<WaterModule>();
|
|
ecs.component<InWater>();
|
|
ecs.component<WaterReady>().add(flecs::Singleton);
|
|
ecs.component<WaterAlmostReady>().add(flecs::Singleton);
|
|
ecs.component<GroundCheckReady>().add(flecs::Singleton);
|
|
ecs.component<WaterSurface>()
|
|
.on_add([](flecs::entity e, WaterSurface &water) {
|
|
water.mAbove = false;
|
|
water.mDepthMaterial = nullptr;
|
|
water.mDepthTech = nullptr;
|
|
water.mInRefTexUpdate = false;
|
|
water.mReflectionCamera = nullptr;
|
|
water.mReflectionCameraNode = nullptr;
|
|
water.mReflectionDepthCamera = nullptr;
|
|
water.mReflectionTexture = nullptr;
|
|
water.mRefractionCamera = nullptr;
|
|
water.mRefractionCameraNode = nullptr;
|
|
water.mRefractionDepthCamera = nullptr;
|
|
water.mWaterEnt = nullptr;
|
|
water.mWaterNode = nullptr;
|
|
|
|
const EngineData &eng = ECS::get<EngineData>();
|
|
const Camera &camera = ECS::get<Camera>();
|
|
|
|
std::cout << "Water setup\n";
|
|
water.mDepthMaterial =
|
|
Ogre::MaterialManager::getSingleton().getByName(
|
|
"Water/Depth");
|
|
OgreAssert(water.mDepthMaterial,
|
|
"Water Depth material not found.");
|
|
water.mDepthMaterial->load();
|
|
water.mDepthTech =
|
|
water.mDepthMaterial->getBestTechnique();
|
|
OgreAssert(water.mDepthTech, "Bad material technique");
|
|
water.mAbove = false;
|
|
water.mInRefTexUpdate = false;
|
|
water.mRenderTargetListener.mSurface = &water;
|
|
const Ogre::String renderTargetName =
|
|
"ReflectionRefractionTexture";
|
|
water.mWaterPlane =
|
|
Ogre::Plane(Ogre::Vector3::UNIT_Y, 0);
|
|
water.mReflectionPlane =
|
|
Ogre::Plane(Ogre::Vector3(0.0, 1.0, 0.0),
|
|
0.5f /* water height */);
|
|
float h = 0.0f;
|
|
water.mReflectionClipPlaneAbove =
|
|
Ogre::Plane(Ogre::Vector3(0.0, 1.0, 0.0), -h);
|
|
water.mReflectionClipPlaneBelow =
|
|
Ogre::Plane(Ogre::Vector3(0.0, -1.0, 0.0), h);
|
|
water.mRefractionClipPlaneAbove =
|
|
Ogre::Plane(Ogre::Vector3(0.0, -1.0, 0.0), h);
|
|
water.mRefractionClipPlaneBelow =
|
|
Ogre::Plane(Ogre::Vector3(0.0, 1.0, 0.0), -h);
|
|
Ogre::TexturePtr reflectionTexture =
|
|
Ogre::TextureManager::getSingleton().createManual(
|
|
renderTargetName,
|
|
Ogre::ResourceGroupManager::
|
|
DEFAULT_RESOURCE_GROUP_NAME,
|
|
Ogre::TEX_TYPE_2D, 512, 512, 0,
|
|
Ogre::PF_R8G8B8A8,
|
|
Ogre::TU_RENDERTARGET);
|
|
Ogre::MaterialPtr debug_mat =
|
|
Ogre::MaterialManager::getSingleton().getByName(
|
|
"Water/Debug", "Water");
|
|
if (!debug_mat) {
|
|
debug_mat =
|
|
Ogre::MaterialManager::getSingleton()
|
|
.create("Water/Debug", "Water");
|
|
Ogre::Technique *tech =
|
|
debug_mat->getTechnique(0);
|
|
Ogre::Pass *pass = tech->getPass(0);
|
|
pass->setLightingEnabled(false);
|
|
pass->setAmbient(Ogre::ColourValue(1, 1, 1, 1));
|
|
pass->setDiffuse(Ogre::ColourValue(0.0f, 0.2f,
|
|
0.5f, 1.0f));
|
|
pass->setDepthCheckEnabled(false);
|
|
pass->setDepthWriteEnabled(false);
|
|
pass->setAlphaRejectFunction(
|
|
Ogre::CMPF_ALWAYS_PASS);
|
|
pass->setCullingMode(Ogre::CULL_NONE);
|
|
pass->setManualCullingMode(
|
|
Ogre::MANUAL_CULL_NONE);
|
|
Ogre::TextureUnitState *texture_unit =
|
|
pass->createTextureUnitState();
|
|
texture_unit->setTextureName(
|
|
"ReflectionRefractionTexture");
|
|
Ogre::Sampler::UVWAddressingMode uvw;
|
|
uvw.u = Ogre::TextureUnitState::TAM_MIRROR;
|
|
uvw.v = Ogre::TextureUnitState::TAM_MIRROR;
|
|
uvw.w = Ogre::TextureUnitState::TAM_MIRROR;
|
|
texture_unit->setTextureAddressingMode(uvw);
|
|
texture_unit->setTextureFiltering(
|
|
Ogre::FT_MIN, Ogre::FO_LINEAR);
|
|
texture_unit->setTextureFiltering(
|
|
Ogre::FT_MAG, Ogre::FO_LINEAR);
|
|
texture_unit->setTextureFiltering(
|
|
Ogre::FT_MIP, Ogre::FO_LINEAR);
|
|
}
|
|
// create a frosted screen in front of the camera, using our dynamic texture to "thaw" certain areas
|
|
if (debugEnabled) {
|
|
Ogre::Entity *ent = eng.mScnMgr->createEntity(
|
|
"WaterDebugPlane",
|
|
Ogre::SceneManager::PT_PLANE);
|
|
ent->setMaterialName("Water/Debug", "Water");
|
|
ent->setVisibilityFlags(WATER_MASK);
|
|
Ogre::SceneNode *node =
|
|
camera.mCameraNode
|
|
->createChildSceneNode();
|
|
node->setPosition(-150, 60, -400);
|
|
node->attachObject(ent);
|
|
}
|
|
|
|
water.mReflectionTexture =
|
|
reflectionTexture->getBuffer()
|
|
->getRenderTarget();
|
|
water.mReflectionTexture->setAutoUpdated(false);
|
|
water.mWaterNode =
|
|
eng.mScnMgr->getRootSceneNode()
|
|
->createChildSceneNode("Water");
|
|
Ogre::MaterialPtr mat =
|
|
Ogre::MaterialManager::getSingleton().getByName(
|
|
"Water/Above", "Water");
|
|
if (!mat) {
|
|
mat = Ogre::MaterialManager::getSingleton()
|
|
.create("Water/Above", "Water");
|
|
Ogre::Technique *tech = mat->getTechnique(0);
|
|
Ogre::Pass *pass = tech->getPass(0);
|
|
pass->setLightingEnabled(true);
|
|
pass->setAmbient(Ogre::ColourValue(1, 1, 1, 1));
|
|
pass->setDiffuse(Ogre::ColourValue(0.0f, 0.2f,
|
|
0.5f, 1.0f));
|
|
pass->setCullingMode(Ogre::CULL_NONE);
|
|
pass->setManualCullingMode(
|
|
Ogre::MANUAL_CULL_NONE);
|
|
pass->setVertexProgram("Water/water_vp");
|
|
pass->setFragmentProgram("Water/water_fp");
|
|
Ogre::TextureUnitState *texture_unit =
|
|
pass->createTextureUnitState();
|
|
texture_unit->setTextureName(
|
|
"ReflectionRefractionTexture");
|
|
Ogre::Sampler::UVWAddressingMode uvw;
|
|
uvw.u = Ogre::TextureUnitState::TAM_MIRROR;
|
|
uvw.v = Ogre::TextureUnitState::TAM_MIRROR;
|
|
uvw.w = Ogre::TextureUnitState::TAM_MIRROR;
|
|
texture_unit->setTextureAddressingMode(uvw);
|
|
texture_unit->setTextureFiltering(
|
|
Ogre::FT_MIN, Ogre::FO_LINEAR);
|
|
texture_unit->setTextureFiltering(
|
|
Ogre::FT_MAG, Ogre::FO_LINEAR);
|
|
texture_unit->setTextureFiltering(
|
|
Ogre::FT_MIP, Ogre::FO_LINEAR);
|
|
Ogre::TextureUnitState *texture_unit2 =
|
|
pass->createTextureUnitState();
|
|
texture_unit2->setTextureName("waves2.png");
|
|
texture_unit2->setTextureAddressingMode(uvw);
|
|
texture_unit2->setTextureFiltering(
|
|
Ogre::FT_MIN, Ogre::FO_LINEAR);
|
|
texture_unit2->setTextureFiltering(
|
|
Ogre::FT_MAG, Ogre::FO_LINEAR);
|
|
texture_unit2->setTextureFiltering(
|
|
Ogre::FT_MIP, Ogre::FO_LINEAR);
|
|
}
|
|
mat->load();
|
|
mat->setReceiveShadows(false);
|
|
/*
|
|
auto mat2 =
|
|
Ogre::MaterialManager::getSingleton()
|
|
.getByName("Water/Below");
|
|
mat2->load();
|
|
mat2->setReceiveShadows(false);
|
|
*/
|
|
Ogre::Vector3 cameraPosition =
|
|
camera.mCameraNode->getPosition();
|
|
water.mWaterEnt =
|
|
eng.mScnMgr->createEntity("Ocean", "sea.glb");
|
|
water.mWaterEnt->setVisibilityFlags(WATER_MASK);
|
|
water.mWaterEnt->setCastShadows(true);
|
|
// water.mWaterEnt->setMaterialName("Water/Above");
|
|
water.mWaterEnt->setMaterial(mat);
|
|
water.mWaterNode->attachObject(water.mWaterEnt);
|
|
// mDynWorld->attachCollisionObject(
|
|
// mWaterBody, water_ent, 1, 0x7FFFFFFF);
|
|
water.mReflectionTexture->addListener(
|
|
&water.mRenderTargetListener);
|
|
water.mReflectionCamera =
|
|
eng.mScnMgr->createCamera("ReflectionCamera");
|
|
water.mReflectionDepthCamera =
|
|
eng.mScnMgr->createCamera(
|
|
"ReflectionDepthCamera");
|
|
water.mReflectionCameraNode =
|
|
camera.mCamera->getParentSceneNode()
|
|
->createChildSceneNode(
|
|
"ReflectionCameraNode");
|
|
water.mReflectionCameraNode->setPosition(
|
|
Ogre::Vector3(0, 1.0f, 0));
|
|
water.mReflectionCameraNode->attachObject(
|
|
water.mReflectionCamera);
|
|
water.mReflectionCameraNode->attachObject(
|
|
water.mReflectionDepthCamera);
|
|
water.mReflectionCamera->setAspectRatio(
|
|
camera.mCamera->getAspectRatio());
|
|
water.mReflectionCamera->setNearClipDistance(
|
|
camera.mCamera->getNearClipDistance());
|
|
water.mReflectionCamera->setFarClipDistance(
|
|
Ogre::Math::Clamp(
|
|
camera.mCamera->getFarClipDistance(),
|
|
10.0f, 10.0f));
|
|
water.mReflectionCamera->enableCustomNearClipPlane(
|
|
water.mReflectionClipPlaneAbove);
|
|
water.mReflectionCamera->enableReflection(
|
|
water.mReflectionPlane);
|
|
|
|
water.mReflectionDepthCamera->setAspectRatio(
|
|
camera.mCamera->getAspectRatio());
|
|
water.mReflectionDepthCamera->setNearClipDistance(
|
|
camera.mCamera->getNearClipDistance());
|
|
water.mReflectionDepthCamera->setFarClipDistance(
|
|
camera.mCamera->getFarClipDistance());
|
|
water.mReflectionDepthCamera->enableCustomNearClipPlane(
|
|
water.mReflectionClipPlaneAbove);
|
|
water.mReflectionDepthCamera->enableReflection(
|
|
water.mReflectionPlane);
|
|
|
|
Ogre::Viewport *reflectionViewport =
|
|
water.mReflectionTexture->addViewport(
|
|
water.mReflectionCamera, 0, 0, 0, 0.5f,
|
|
0.5f);
|
|
reflectionViewport->setClearEveryFrame(true);
|
|
reflectionViewport->setBackgroundColour(
|
|
Ogre::ColourValue(0.0, 0.0, 1.0, 1.0));
|
|
reflectionViewport->setOverlaysEnabled(false);
|
|
reflectionViewport->setSkiesEnabled(true);
|
|
reflectionViewport->setAutoUpdated(false);
|
|
reflectionViewport->setVisibilityMask(~WATER_MASK);
|
|
water.mViewports[0] = reflectionViewport;
|
|
|
|
Ogre::Viewport *reflectionDepthViewport =
|
|
water.mReflectionTexture->addViewport(
|
|
water.mReflectionDepthCamera, 2, 0,
|
|
0.5f, 0.5f, 0.5f);
|
|
reflectionDepthViewport->setClearEveryFrame(true);
|
|
reflectionDepthViewport->setBackgroundColour(
|
|
Ogre::ColourValue(0.0, 0.0, 0.0, 0.0));
|
|
reflectionDepthViewport->setOverlaysEnabled(false);
|
|
reflectionDepthViewport->setSkiesEnabled(true);
|
|
reflectionDepthViewport->setAutoUpdated(false);
|
|
reflectionDepthViewport->setVisibilityMask(~WATER_MASK);
|
|
water.mViewports[2] = reflectionDepthViewport;
|
|
|
|
water.mRefractionCamera =
|
|
eng.mScnMgr->createCamera("RefractionCamera");
|
|
water.mRefractionDepthCamera =
|
|
eng.mScnMgr->createCamera(
|
|
"RefractionDepthCamera");
|
|
water.mRefractionCameraNode =
|
|
camera.mCamera->getParentSceneNode()
|
|
->createChildSceneNode(
|
|
"RefractionCameraNode");
|
|
water.mRefractionCameraNode->attachObject(
|
|
water.mRefractionCamera);
|
|
water.mRefractionCameraNode->attachObject(
|
|
water.mRefractionDepthCamera);
|
|
water.mRefractionCamera->setAspectRatio(
|
|
camera.mCamera->getAspectRatio());
|
|
water.mRefractionCamera->setNearClipDistance(
|
|
camera.mCamera->getNearClipDistance());
|
|
water.mRefractionCamera->setFarClipDistance(
|
|
Ogre::Math::Clamp(
|
|
camera.mCamera->getFarClipDistance(),
|
|
1.0f, 10.0f));
|
|
water.mRefractionCamera->enableCustomNearClipPlane(
|
|
water.mRefractionClipPlaneAbove);
|
|
|
|
water.mRefractionDepthCamera->setAspectRatio(
|
|
camera.mCamera->getAspectRatio());
|
|
water.mRefractionDepthCamera->setNearClipDistance(
|
|
camera.mCamera->getNearClipDistance());
|
|
water.mRefractionDepthCamera->setFarClipDistance(
|
|
camera.mCamera->getFarClipDistance());
|
|
water.mRefractionDepthCamera->enableCustomNearClipPlane(
|
|
water.mRefractionClipPlaneAbove);
|
|
|
|
Ogre::Viewport *refractionViewport =
|
|
water.mReflectionTexture->addViewport(
|
|
water.mRefractionCamera, 1, 0.5, 0,
|
|
0.5f, 0.5f);
|
|
refractionViewport->setClearEveryFrame(true);
|
|
refractionViewport->setBackgroundColour(
|
|
Ogre::ColourValue(0.0, 0.5, 1.0, 1.0));
|
|
refractionViewport->setOverlaysEnabled(false);
|
|
refractionViewport->setSkiesEnabled(false);
|
|
refractionViewport->setAutoUpdated(false);
|
|
refractionViewport->setVisibilityMask(~WATER_MASK);
|
|
water.mViewports[1] = refractionViewport;
|
|
|
|
Ogre::Viewport *refractionDepthViewport =
|
|
water.mReflectionTexture->addViewport(
|
|
water.mRefractionDepthCamera, 3, 0.5,
|
|
0.5, 0.5f, 0.5f);
|
|
refractionDepthViewport->setClearEveryFrame(true);
|
|
refractionDepthViewport->setBackgroundColour(
|
|
Ogre::ColourValue(0.0, 0.0, 0.0, 0.0));
|
|
refractionDepthViewport->setOverlaysEnabled(false);
|
|
refractionDepthViewport->setSkiesEnabled(false);
|
|
refractionDepthViewport->setAutoUpdated(false);
|
|
refractionDepthViewport->setVisibilityMask(~WATER_MASK);
|
|
water.mViewports[3] = refractionDepthViewport;
|
|
|
|
water.mRenderTargetListener.mInDepth = false;
|
|
eng.mScnMgr->getRenderQueue()->setRenderableListener(
|
|
&water.mRenderTargetListener);
|
|
std::cout << "Water setup done\n";
|
|
ECS::get().add<WaterAlmostReady>();
|
|
})
|
|
.on_remove([](flecs::entity e, WaterSurface &water) {
|
|
const Ogre::String renderTargetName =
|
|
"ReflectionRefractionTexture";
|
|
ECS::get<EngineData>()
|
|
.mScnMgr->getRenderQueue()
|
|
->setRenderableListener(nullptr);
|
|
water.mReflectionTexture->removeAllViewports();
|
|
ECS::get<EngineData>().mScnMgr->destroyCamera(
|
|
water.mRefractionCamera);
|
|
ECS::get<EngineData>().mScnMgr->destroyCamera(
|
|
water.mRefractionDepthCamera);
|
|
ECS::get<EngineData>().mScnMgr->destroyCamera(
|
|
water.mReflectionCamera);
|
|
ECS::get<EngineData>().mScnMgr->destroyCamera(
|
|
water.mReflectionDepthCamera);
|
|
Ogre::TextureManager::getSingleton().remove(
|
|
renderTargetName);
|
|
water.mWaterNode->destroyAllChildrenAndObjects();
|
|
ECS::get<EngineData>().mScnMgr->destroySceneNode(
|
|
water.mWaterNode);
|
|
Ogre::MaterialManager::getSingleton().remove(
|
|
"Water/Depth");
|
|
Ogre::MaterialManager::getSingleton().remove(
|
|
"Water/Above");
|
|
})
|
|
.add(flecs::Singleton);
|
|
ecs.system<const EngineData, const Camera, WaterSurface>(
|
|
"UpdateWaterPosition")
|
|
.kind(flecs::OnUpdate)
|
|
.with<WaterReady>()
|
|
.interval(0.3f)
|
|
.each([](const EngineData &eng, const Camera &camera,
|
|
WaterSurface &water) {
|
|
ZoneScopedN("UpdateWaterPosition");
|
|
float delta = eng.delta;
|
|
Ogre::Vector3 mCameraPos =
|
|
camera.mCameraNode->_getDerivedPosition();
|
|
Ogre::Vector3 waterPos =
|
|
water.mWaterNode->_getDerivedPosition();
|
|
mCameraPos.y = 0;
|
|
waterPos.y = 0;
|
|
Ogre::Vector3 d = mCameraPos - waterPos;
|
|
if (d.squaredLength() < 100.0f * 100.0f)
|
|
water.mWaterNode->translate(d * 3.0f * delta);
|
|
else
|
|
water.mWaterNode->translate(d);
|
|
});
|
|
ecs.system<WaterSurface>("UpdateWater")
|
|
.kind(flecs::OnUpdate)
|
|
.with<WaterReady>()
|
|
.each([](WaterSurface &water) {
|
|
static int updateViewport = 0;
|
|
ZoneScopedN("UpdateWaterRender");
|
|
water.mViewports[updateViewport++]->update();
|
|
if (updateViewport > 1)
|
|
updateViewport = 0;
|
|
});
|
|
}
|
|
struct shapeParams {
|
|
float offsetX, offsetY, offsetZ;
|
|
float boxX, boxY, boxZ;
|
|
};
|
|
static struct shapeParams childShapes[] = {
|
|
{ 0.0f, 0.0f, 0.0f, 100.0f, 100.0f, 100.0f },
|
|
};
|
|
void WaterSurface::RenderTextureListener::preRenderTargetUpdate(
|
|
const Ogre::RenderTargetEvent &evt)
|
|
{
|
|
int i;
|
|
if (evt.source == mSurface->mReflectionTexture) {
|
|
mSurface->mWaterEnt->setVisible(false);
|
|
if (evt.source == mSurface->mReflectionTexture)
|
|
mSurface->mInRefTexUpdate = true;
|
|
} else {
|
|
mSurface->mWaterEnt->setVisible(true);
|
|
mSurface->mInRefTexUpdate = false;
|
|
}
|
|
}
|
|
void WaterSurface::RenderTextureListener::postRenderTargetUpdate(
|
|
const Ogre::RenderTargetEvent &evt)
|
|
{
|
|
int i;
|
|
mSurface->mWaterEnt->setVisible(true);
|
|
mSurface->mInRefTexUpdate = false;
|
|
}
|
|
bool WaterSurface::RenderTextureListener::renderableQueued(
|
|
Ogre::Renderable *rend, Ogre::uint8 groupID, ushort priority,
|
|
Ogre::Technique **ppTech, Ogre::RenderQueue *pQueue)
|
|
{
|
|
if (mInDepth)
|
|
*ppTech = mSurface->mDepthTech;
|
|
return true;
|
|
}
|
|
}
|