diff --git a/src/Mara/Gui/MainWindow.cpp b/src/Mara/Gui/MainWindow.cpp
index bef5538ffb9b5393568950bbe296550866324d4d..630690ba1f3b0f2cb94b3d6edcfd0d47e29eaf85 100644
--- a/src/Mara/Gui/MainWindow.cpp
+++ b/src/Mara/Gui/MainWindow.cpp
@@ -126,7 +126,6 @@ Viewer* MainWindow::getViewer() {
void MainWindow::onFrameComplete() {}
-
void MainWindow::activateCamera( const std::string& sceneName ) {
// If a camera is in the given scene, use it, else, use default
std::string loadedEntityName = Ra::Core::Utils::getBaseName( sceneName, false );
@@ -211,7 +210,7 @@ void MainWindow::loadFile() {
emit fileLoading( file );
}
- auto romgr = Ra::Engine::RadiumEngine::getInstance()->getRenderObjectManager();
+ auto romgr = Ra::Engine::RadiumEngine::getInstance()->getRenderObjectManager();
auto polyCount = romgr->getNumFaces();
auto vertexCount = romgr->getNumVertices();
auto objectCount = romgr->getRenderObjectsCount();
@@ -219,7 +218,6 @@ void MainWindow::loadFile() {
m_controlWindow->setFileInfo( pathList.first().toStdString(), sceneStats );
activateCamera( pathList.first().toStdString() );
}
-
}
void MainWindow::setROVisible( Ra::Core::Utils::Index roIndex, bool visible ) {
diff --git a/src/Mara/Gui/MainWindow.hpp b/src/Mara/Gui/MainWindow.hpp
index c47fa859f45ed36b6674caefcc03380ff7e8e764..276dbfd4f6cf1dfc434412b2d38252fe715f20b3 100644
--- a/src/Mara/Gui/MainWindow.hpp
+++ b/src/Mara/Gui/MainWindow.hpp
@@ -161,6 +161,6 @@ class MainWindow : public Ra::Gui::MainWindowInterface, private Ui::MainWindow
/// QTreeview of the scene
QTreeView* m_sceneTreeView;
#endif
- Ra::Engine::Scene::Camera* m_initialCamera{ nullptr };
+ Ra::Engine::Scene::Camera* m_initialCamera{nullptr};
};
} // namespace Mara
diff --git a/src/Mara/Gui/RendererControl.hpp b/src/Mara/Gui/RendererControl.hpp
index 7981480799734527c05384208b7db564df23ab34..d358e0444ec1650722f8d4bed8d462a33f16b9df 100644
--- a/src/Mara/Gui/RendererControl.hpp
+++ b/src/Mara/Gui/RendererControl.hpp
@@ -76,7 +76,7 @@ class RendererControl : public QFrame, private Ui::RendererControler
/// The association between a renderer and its activation function
using RendererInfo = std::pair<Ra::Engine::Rendering::Renderer* const, std::function<bool()>>;
/// The active renderer
- int m_currentRenderer{ -1 };
+ int m_currentRenderer{-1};
/// The Renderers/callbacks managed by the gui
std::vector<RendererInfo> m_renderersCallbacks;
@@ -84,6 +84,6 @@ class RendererControl : public QFrame, private Ui::RendererControler
std::vector<RadiumNBR::Gui::RendererPanel*> m_renderersPanels;
/// combo bos to select one renderer output for display
- QComboBox* m_textureList{ nullptr };
+ QComboBox* m_textureList{nullptr};
};
} // namespace Mara
diff --git a/src/Mara/RadiumPlayer.hpp b/src/Mara/RadiumPlayer.hpp
index 103ca4bd4aef0fe801d5504093a23b878cc98949..f562e679702ea630ee9d6e0e1cdf51d8b6c5b6a9 100644
--- a/src/Mara/RadiumPlayer.hpp
+++ b/src/Mara/RadiumPlayer.hpp
@@ -41,6 +41,6 @@ class RadiumPlayer : public Ra::Gui::BaseApplication
void addConnections();
/// Current file. First indicate that the file (second) must be loaded at startup
- std::optional<QStringList> m_fileOption{ std::nullopt };
+ std::optional<QStringList> m_fileOption{std::nullopt};
};
} // namespace Mara
diff --git a/src/Mara/main.cpp b/src/Mara/main.cpp
index 2cee6e8ac464002993fd27c000e490f03201c3ea..34bacf60e37e39ed6d24ae568e8780ec04f25b66 100644
--- a/src/Mara/main.cpp
+++ b/src/Mara/main.cpp
@@ -48,7 +48,7 @@ int main( int argc, char** argv ) {
// To take the color from vertices but need to be clearer on the Material description
torus.addAttrib(
"in_color",
- Ra::Core::Vector4Array{ torus.vertices().size(), Ra::Core::Utils::Color::Green() } );
+ Ra::Core::Vector4Array{torus.vertices().size(), Ra::Core::Utils::Color::Green()} );
/* The appearance of the mesh
* Note that only blinn phong could be used as the TriangleMeshComponent constructor only uses
* MaterialData from asset
diff --git a/src/Plugin/NodeRendererPlugin.cpp b/src/Plugin/NodeRendererPlugin.cpp
index c9f37601fb2255f88049c73bf60607f078e0b795..28861b01a130de0c5fa8b5e80acb14f417627a09 100644
--- a/src/Plugin/NodeRendererPlugin.cpp
+++ b/src/Plugin/NodeRendererPlugin.cpp
@@ -48,4 +48,4 @@ void NodeRendererPlugin::addRenderers(
rds->push_back( m_renderer );
}
-} // namespace Mara
+} // namespace RadiumNBRPlugin
diff --git a/src/libRender/CMakeLists.txt b/src/libRender/CMakeLists.txt
index ce0a3beaa3f4c353a164f27acace879ae09f1afd..fc67a725de76a240e4916d051754d3e3d9a5eecf 100644
--- a/src/libRender/CMakeLists.txt
+++ b/src/libRender/CMakeLists.txt
@@ -34,12 +34,14 @@ set(sources
RadiumNBR/FullFeatureRenderer.cpp
RadiumNBR/SphereSampler.cpp
RadiumNBR/Passes/ClearPass.cpp
+ RadiumNBR/Passes/DebugPass.cpp
RadiumNBR/Passes/GeomPrepass.cpp
RadiumNBR/Passes/AccessibilityBufferPass.cpp
RadiumNBR/Passes/EnvLightPass.cpp
RadiumNBR/Passes/EmissivityPass.cpp
RadiumNBR/Passes/LocalLightPass.cpp
RadiumNBR/Passes/TransparencyPass.cpp
+ RadiumNBR/Passes/UiPass.cpp
RadiumNBR/Passes/VolumePass.cpp
RadiumNBR/Passes/WireframePass.cpp
)
@@ -51,12 +53,14 @@ set(public_headers
RadiumNBR/RenderPass.hpp
RadiumNBR/SphereSampler.hpp
RadiumNBR/Passes/ClearPass.hpp
+ RadiumNBR/Passes/DebugPass.hpp
RadiumNBR/Passes/GeomPrepass.hpp
RadiumNBR/Passes/AccessibilityBufferPass.hpp
RadiumNBR/Passes/EmissivityPass.hpp
RadiumNBR/Passes/EnvLightPass.hpp
RadiumNBR/Passes/LocalLightPass.hpp
RadiumNBR/Passes/TransparencyPass.hpp
+ RadiumNBR/Passes/UiPass.hpp
RadiumNBR/Passes/VolumePass.hpp
RadiumNBR/Passes/WireframePass.hpp
)
diff --git a/src/libRender/RadiumNBR/EnvMap.cpp b/src/libRender/RadiumNBR/EnvMap.cpp
index 1ceeaaaa8f84322da74888ecebca3dedd4f515c8..748cd8cb75cb32f18ec5890e4222194ed68d14a1 100644
--- a/src/libRender/RadiumNBR/EnvMap.cpp
+++ b/src/libRender/RadiumNBR/EnvMap.cpp
@@ -155,70 +155,70 @@ using namespace Ra::Core;
static Geometry::TriangleMesh makeSkyBox( const Aabb& aabb ) {
Geometry::TriangleMesh result;
- result.setVertices( { // Z- face
- aabb.corner( Aabb::BottomLeftFloor ),
- aabb.corner( Aabb::TopLeftFloor ),
- aabb.corner( Aabb::TopRightFloor ),
- aabb.corner( Aabb::BottomRightFloor ),
- // Z+ face
- aabb.corner( Aabb::BottomLeftCeil ),
- aabb.corner( Aabb::BottomRightCeil ),
- aabb.corner( Aabb::TopRightCeil ),
- aabb.corner( Aabb::TopLeftCeil ),
- // X- Face
- aabb.corner( Aabb::TopLeftFloor ),
- aabb.corner( Aabb::BottomLeftFloor ),
- aabb.corner( Aabb::BottomLeftCeil ),
- aabb.corner( Aabb::TopLeftCeil ),
-
- // X+ Face
- aabb.corner( Aabb::BottomRightFloor ),
- aabb.corner( Aabb::TopRightFloor ),
- aabb.corner( Aabb::TopRightCeil ),
- aabb.corner( Aabb::BottomRightCeil ),
-
- // Y- Face
- aabb.corner( Aabb::BottomLeftFloor ),
- aabb.corner( Aabb::BottomRightFloor ),
- aabb.corner( Aabb::BottomRightCeil ),
- aabb.corner( Aabb::BottomLeftCeil ),
-
- // Y+ face
- aabb.corner( Aabb::TopLeftFloor ),
- aabb.corner( Aabb::TopLeftCeil ),
- aabb.corner( Aabb::TopRightCeil ),
- aabb.corner( Aabb::TopRightFloor ) } );
-
- result.setNormals( { // Floor face
- Vector3( 0, 0, -1 ),
- Vector3( 0, 0, -1 ),
- Vector3( 0, 0, -1 ),
- Vector3( 0, 0, -1 ),
- // Ceil Face
- Vector3( 0, 0, +1 ),
- Vector3( 0, 0, +1 ),
- Vector3( 0, 0, +1 ),
- Vector3( 0, 0, +1 ),
- // Left Face
- Vector3( -1, 0, 0 ),
- Vector3( -1, 0, 0 ),
- Vector3( -1, 0, 0 ),
- Vector3( -1, 0, 0 ),
- // Right Face
- Vector3( +1, 0, 0 ),
- Vector3( +1, 0, 0 ),
- Vector3( +1, 0, 0 ),
- Vector3( +1, 0, 0 ),
- // Bottom Face
- Vector3( 0, -1, 0 ),
- Vector3( 0, -1, 0 ),
- Vector3( 0, -1, 0 ),
- Vector3( 0, -1, 0 ),
- // Top Face
- Vector3( 0, +1, 0 ),
- Vector3( 0, +1, 0 ),
- Vector3( 0, +1, 0 ),
- Vector3( 0, +1, 0 ) } );
+ result.setVertices( {// Z- face
+ aabb.corner( Aabb::BottomLeftFloor ),
+ aabb.corner( Aabb::TopLeftFloor ),
+ aabb.corner( Aabb::TopRightFloor ),
+ aabb.corner( Aabb::BottomRightFloor ),
+ // Z+ face
+ aabb.corner( Aabb::BottomLeftCeil ),
+ aabb.corner( Aabb::BottomRightCeil ),
+ aabb.corner( Aabb::TopRightCeil ),
+ aabb.corner( Aabb::TopLeftCeil ),
+ // X- Face
+ aabb.corner( Aabb::TopLeftFloor ),
+ aabb.corner( Aabb::BottomLeftFloor ),
+ aabb.corner( Aabb::BottomLeftCeil ),
+ aabb.corner( Aabb::TopLeftCeil ),
+
+ // X+ Face
+ aabb.corner( Aabb::BottomRightFloor ),
+ aabb.corner( Aabb::TopRightFloor ),
+ aabb.corner( Aabb::TopRightCeil ),
+ aabb.corner( Aabb::BottomRightCeil ),
+
+ // Y- Face
+ aabb.corner( Aabb::BottomLeftFloor ),
+ aabb.corner( Aabb::BottomRightFloor ),
+ aabb.corner( Aabb::BottomRightCeil ),
+ aabb.corner( Aabb::BottomLeftCeil ),
+
+ // Y+ face
+ aabb.corner( Aabb::TopLeftFloor ),
+ aabb.corner( Aabb::TopLeftCeil ),
+ aabb.corner( Aabb::TopRightCeil ),
+ aabb.corner( Aabb::TopRightFloor )} );
+
+ result.setNormals( {// Floor face
+ Vector3( 0, 0, -1 ),
+ Vector3( 0, 0, -1 ),
+ Vector3( 0, 0, -1 ),
+ Vector3( 0, 0, -1 ),
+ // Ceil Face
+ Vector3( 0, 0, +1 ),
+ Vector3( 0, 0, +1 ),
+ Vector3( 0, 0, +1 ),
+ Vector3( 0, 0, +1 ),
+ // Left Face
+ Vector3( -1, 0, 0 ),
+ Vector3( -1, 0, 0 ),
+ Vector3( -1, 0, 0 ),
+ Vector3( -1, 0, 0 ),
+ // Right Face
+ Vector3( +1, 0, 0 ),
+ Vector3( +1, 0, 0 ),
+ Vector3( +1, 0, 0 ),
+ Vector3( +1, 0, 0 ),
+ // Bottom Face
+ Vector3( 0, -1, 0 ),
+ Vector3( 0, -1, 0 ),
+ Vector3( 0, -1, 0 ),
+ Vector3( 0, -1, 0 ),
+ // Top Face
+ Vector3( 0, +1, 0 ),
+ Vector3( 0, +1, 0 ),
+ Vector3( 0, +1, 0 ),
+ Vector3( 0, +1, 0 )} );
result.setIndices( {
Vector3ui( 0, 1, 2 ),
@@ -235,36 +235,36 @@ static Geometry::TriangleMesh makeSkyBox( const Aabb& aabb ) {
Vector3ui( 20, 22, 23 ) // Top
} );
- Vector3Array texcoord = { // Floor Face (Z-)
- Vector3( 0_ra, 0_ra, 0_ra ),
- Vector3( 0_ra, 1_ra, 0_ra ),
- Vector3( 1_ra, 1_ra, 0_ra ),
- Vector3( 1_ra, 0_ra, 0_ra ),
- // Ceil Face (Z+)
- Vector3( 0_ra, 0_ra, 0_ra ),
- Vector3( 0_ra, 1_ra, 0_ra ),
- Vector3( 1_ra, 1_ra, 0_ra ),
- Vector3( 1_ra, 0_ra, 0_ra ),
- // Left Face (Y-)
- Vector3( 0_ra, 0_ra, 0_ra ),
- Vector3( 0_ra, 1_ra, 0_ra ),
- Vector3( 1_ra, 1_ra, 0_ra ),
- Vector3( 1_ra, 0_ra, 0_ra ),
- // Right Face (Y+)
- Vector3( 0_ra, 0_ra, 0_ra ),
- Vector3( 0_ra, 1_ra, 0_ra ),
- Vector3( 1_ra, 1_ra, 0_ra ),
- Vector3( 1_ra, 0_ra, 0_ra ),
- // Bottom Face (X-)
- Vector3( 0_ra, 0_ra, 0_ra ),
- Vector3( 0_ra, 1_ra, 0_ra ),
- Vector3( 1_ra, 1_ra, 0_ra ),
- Vector3( 1_ra, 0_ra, 0_ra ),
- // Top Face (X+)
- Vector3( 0_ra, 0_ra, 0_ra ),
- Vector3( 0_ra, 1_ra, 0_ra ),
- Vector3( 1_ra, 1_ra, 0_ra ),
- Vector3( 1_ra, 0_ra, 0_ra ) };
+ Vector3Array texcoord = {// Floor Face (Z-)
+ Vector3( 0_ra, 0_ra, 0_ra ),
+ Vector3( 0_ra, 1_ra, 0_ra ),
+ Vector3( 1_ra, 1_ra, 0_ra ),
+ Vector3( 1_ra, 0_ra, 0_ra ),
+ // Ceil Face (Z+)
+ Vector3( 0_ra, 0_ra, 0_ra ),
+ Vector3( 0_ra, 1_ra, 0_ra ),
+ Vector3( 1_ra, 1_ra, 0_ra ),
+ Vector3( 1_ra, 0_ra, 0_ra ),
+ // Left Face (Y-)
+ Vector3( 0_ra, 0_ra, 0_ra ),
+ Vector3( 0_ra, 1_ra, 0_ra ),
+ Vector3( 1_ra, 1_ra, 0_ra ),
+ Vector3( 1_ra, 0_ra, 0_ra ),
+ // Right Face (Y+)
+ Vector3( 0_ra, 0_ra, 0_ra ),
+ Vector3( 0_ra, 1_ra, 0_ra ),
+ Vector3( 1_ra, 1_ra, 0_ra ),
+ Vector3( 1_ra, 0_ra, 0_ra ),
+ // Bottom Face (X-)
+ Vector3( 0_ra, 0_ra, 0_ra ),
+ Vector3( 0_ra, 1_ra, 0_ra ),
+ Vector3( 1_ra, 1_ra, 0_ra ),
+ Vector3( 1_ra, 0_ra, 0_ra ),
+ // Top Face (X+)
+ Vector3( 0_ra, 0_ra, 0_ra ),
+ Vector3( 0_ra, 1_ra, 0_ra ),
+ Vector3( 1_ra, 1_ra, 0_ra ),
+ Vector3( 1_ra, 0_ra, 0_ra )};
result.addAttrib( "in_texcoord", texcoord );
@@ -277,8 +277,8 @@ static Geometry::TriangleMesh makeSkyBox( const Aabb& aabb ) {
EnvMap::EnvMap( const std::string& mapName, EnvMap::EnvMapType type, bool isSkybox ) :
m_name( mapName ),
m_type( type ),
- m_skyData{ nullptr, nullptr, nullptr, nullptr, nullptr, nullptr },
- m_isSkyBox{ isSkybox } {
+ m_skyData{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr},
+ m_isSkyBox{isSkybox} {
switch ( m_type )
{
case EnvMapType::ENVMAP_PFM:
@@ -293,27 +293,27 @@ EnvMap::EnvMap( const std::string& mapName, EnvMap::EnvMapType type, bool isSkyb
}
computeSHMatrices();
// make the envmap cube texture
- Ra::Engine::Data::TextureParameters params{ "envmap",
- GL_TEXTURE_CUBE_MAP,
- m_width,
- m_height,
- 1,
- GL_RGBA,
- GL_RGBA,
- GL_FLOAT,
- GL_CLAMP_TO_EDGE,
- GL_CLAMP_TO_EDGE,
- GL_CLAMP_TO_EDGE,
- GL_LINEAR_MIPMAP_LINEAR,
- GL_LINEAR,
- (void**)( m_skyData ) };
+ Ra::Engine::Data::TextureParameters params{"envmap",
+ GL_TEXTURE_CUBE_MAP,
+ m_width,
+ m_height,
+ 1,
+ GL_RGBA,
+ GL_RGBA,
+ GL_FLOAT,
+ GL_CLAMP_TO_EDGE,
+ GL_CLAMP_TO_EDGE,
+ GL_CLAMP_TO_EDGE,
+ GL_LINEAR_MIPMAP_LINEAR,
+ GL_LINEAR,
+ (void**)( m_skyData )};
m_skyTexture = std::make_unique<Ra::Engine::Data::Texture>( params );
if ( m_isSkyBox )
{
// make the skybox geometry
/// Todo, port this to new attrib management
- Aabb aabb( Vector3{ -1_ra, -1_ra, -1_ra }, Vector3{ 1_ra, 1_ra, 1_ra } );
+ Aabb aabb( Vector3{-1_ra, -1_ra, -1_ra}, Vector3{1_ra, 1_ra, 1_ra} );
Geometry::TriangleMesh skyMesh = makeSkyBox( aabb );
m_displayMesh = std::make_unique<Ra::Engine::Data::Mesh>( "skyBox" );
m_displayMesh->loadGeometry( std::move( skyMesh ) );
@@ -428,9 +428,9 @@ void EnvMap::setupTexturesFromCube() {
std::string imgname;
while ( getline( imgs, imgname, ';' ) )
{
- int imgIdx{ -1 };
- bool flipV{ false };
- bool flipH{ false };
+ int imgIdx{-1};
+ bool flipV{false};
+ bool flipH{false};
// is it a +X face ?
if ( ( imgname.find( "posx" ) != imgname.npos ) ||
( imgname.find( "-X-plux" ) != imgname.npos ) )
@@ -488,11 +488,11 @@ void EnvMap::setupTexturesFromCube() {
void EnvMap::setupTexturesFromSphericalEquiRectangular() {
auto ext = m_name.substr( m_name.size() - 3 );
- float* latlonPix{ nullptr };
+ float* latlonPix{nullptr};
int n, w, h;
if ( ext == "exr" )
{
- const char* err{ nullptr };
+ const char* err{nullptr};
int ret = LoadEXR( &latlonPix, &w, &h, m_name.c_str(), &err );
n = 4;
if ( ret != TINYEXR_SUCCESS )
@@ -511,17 +511,19 @@ void EnvMap::setupTexturesFromSphericalEquiRectangular() {
}
int textureSize = 1;
while ( textureSize < h )
- { textureSize <<= 1; }
+ {
+ textureSize <<= 1;
+ }
textureSize >>= 1;
// Bases to use to convert sphericalequirectangular images to cube faces
// These bases allow to convert (u, v) cordinates of each faces to (x, y, z) in the frame of the
// equirectangular map. : (x, y, z) = u*A[0] + v*A[1] + A[2]
- Vector3 bases[6][3] = { { { -1, 0, 0 }, { 0, 1, 0 }, { 0, 0, -1 } },
- { { 1, 0, 0 }, { 0, -1, 0 }, { 0, 0, -1 } },
- { { 0, 0, 1 }, { 1, 0, 0 }, { 0, 1, 0 } },
- { { 0, 0, -1 }, { 1, 0, 0 }, { 0, -1, 0 } },
- { { 0, 1, 0 }, { 1, 0, 0 }, { 0, 0, -1 } },
- { { 0, -1, 0 }, { -1, 0, 0 }, { 0, 0, -1 } } };
+ Vector3 bases[6][3] = {{{-1, 0, 0}, {0, 1, 0}, {0, 0, -1}},
+ {{1, 0, 0}, {0, -1, 0}, {0, 0, -1}},
+ {{0, 0, 1}, {1, 0, 0}, {0, 1, 0}},
+ {{0, 0, -1}, {1, 0, 0}, {0, -1, 0}},
+ {{0, 1, 0}, {1, 0, 0}, {0, 0, -1}},
+ {{0, -1, 0}, {-1, 0, 0}, {0, 0, -1}}};
auto sphericalPhi = []( const Vector3& d ) {
Scalar p = std::atan2( d.x(), d.y() );
return ( p < 0 ) ? ( p + 2 * M_PI ) : p;
@@ -539,7 +541,7 @@ void EnvMap::setupTexturesFromSphericalEquiRectangular() {
{
Vector3 d = bases[imgIdx][0] + u * bases[imgIdx][1] + v * bases[imgIdx][2];
d = d.normalized();
- Vector2 st{ w * sphericalPhi( d ) / ( 2 * M_PI ), h * sphericalTheta( d ) / M_PI };
+ Vector2 st{w * sphericalPhi( d ) / ( 2 * M_PI ), h * sphericalTheta( d ) / M_PI};
// TODO : use st to access and filter the original envmap
// for now, no filtering is done. (eq to GL_NEAREST)
int s = int( st.x() );
@@ -762,20 +764,20 @@ Ra::Engine::Data::Texture* EnvMap::getSHImage() {
thepixels[4 * ( j * ambientWidth + i ) + 3] = 255;
}
}
- Ra::Engine::Data::TextureParameters params{ "shImage",
- GL_TEXTURE_2D,
- ambientWidth,
- ambientWidth,
- 1,
- GL_RGBA,
- GL_RGBA,
- GL_UNSIGNED_BYTE,
- GL_CLAMP_TO_EDGE,
- GL_CLAMP_TO_EDGE,
- GL_CLAMP_TO_EDGE,
- GL_LINEAR,
- GL_LINEAR,
- thepixels };
+ Ra::Engine::Data::TextureParameters params{"shImage",
+ GL_TEXTURE_2D,
+ ambientWidth,
+ ambientWidth,
+ 1,
+ GL_RGBA,
+ GL_RGBA,
+ GL_UNSIGNED_BYTE,
+ GL_CLAMP_TO_EDGE,
+ GL_CLAMP_TO_EDGE,
+ GL_CLAMP_TO_EDGE,
+ GL_LINEAR,
+ GL_LINEAR,
+ thepixels};
m_shtexture = std::make_unique<Ra::Engine::Data::Texture>( params );
return m_shtexture.get();
}
@@ -806,7 +808,7 @@ void EnvMap::updateGL() {
" mat4 mvp = transform.proj * transform.view;\n"
" gl_Position = mvp*vec4(in_position.xyz, 1.0);\n"
" var_texcoord = vec3(in_position.x, in_position.y, in_position.z);\n"
- "}\n" };
+ "}\n"};
const std::string fragmentShadersource{
"layout (location = 0) out vec4 out_color;\n"
"in vec3 var_texcoord;\n"
@@ -815,8 +817,8 @@ void EnvMap::updateGL() {
"{\n"
" vec3 envColor = texture(skytexture, normalize(var_texcoord)).rgb;\n"
" out_color =0.9*vec4(envColor, 0);\n"
- "}\n" };
- Ra::Engine::Data::ShaderConfiguration config{ "Built In SkyBox" };
+ "}\n"};
+ Ra::Engine::Data::ShaderConfiguration config{"Built In SkyBox"};
config.addShaderSource( Ra::Engine::Data::ShaderType::ShaderType_VERTEX,
vertexShaderSource );
config.addShaderSource( Ra::Engine::Data::ShaderType::ShaderType_FRAGMENT,
@@ -842,9 +844,9 @@ void EnvMap::render( const Ra::Engine::Data::ViewingParameters& viewParams ) {
// put this in a initializeGL method ?
if ( !m_glReady ) { updateGL(); }
auto skyparams = viewParams;
- auto t = Ra::Core::Transform{ skyparams.viewMatrix }.rotation();
+ auto t = Ra::Core::Transform{skyparams.viewMatrix}.rotation();
skyparams.viewMatrix.topLeftCorner<3, 3>() = t;
- skyparams.viewMatrix.rightCols<1>() = Ra::Core::Vector4{ 0_ra, 0_ra, 0_ra, 1_ra };
+ skyparams.viewMatrix.rightCols<1>() = Ra::Core::Vector4{0_ra, 0_ra, 0_ra, 1_ra};
m_skyShader->bind();
m_skyShader->setUniform( "transform.proj", skyparams.projMatrix );
m_skyShader->setUniform( "transform.view", skyparams.viewMatrix );
diff --git a/src/libRender/RadiumNBR/EnvMap.hpp b/src/libRender/RadiumNBR/EnvMap.hpp
index d94910183caf92554006393473f75c7b4c74fb5a..ecce4a83c1c93baf970dfece58ac20e77e096493 100644
--- a/src/libRender/RadiumNBR/EnvMap.hpp
+++ b/src/libRender/RadiumNBR/EnvMap.hpp
@@ -118,21 +118,21 @@ class NodeBasedRenderer_LIBRARY_API EnvMap
// The raw pixel values of the envmap
float* m_skyData[6];
- size_t m_width{ 0 };
- size_t m_height{ 0 };
+ size_t m_width{0};
+ size_t m_height{0};
float m_shcoefs[9][3];
Ra::Core::Matrix4 m_shMatrices[3];
- std::unique_ptr<Ra::Engine::Data::Texture> m_shtexture{ nullptr };
+ std::unique_ptr<Ra::Engine::Data::Texture> m_shtexture{nullptr};
/// Is the envmap a Skybox ?
- bool m_isSkyBox{ false };
+ bool m_isSkyBox{false};
/// The mesh of the skybox
- std::unique_ptr<Ra::Engine::Data::Mesh> m_displayMesh{ nullptr };
+ std::unique_ptr<Ra::Engine::Data::Mesh> m_displayMesh{nullptr};
/// The texture of the skybox
- std::unique_ptr<Ra::Engine::Data::Texture> m_skyTexture{ nullptr };
+ std::unique_ptr<Ra::Engine::Data::Texture> m_skyTexture{nullptr};
/// The Lod to use for the skybox
- float m_envStrength{ 1 };
+ float m_envStrength{1};
/// The shader for the skybox
- const Ra::Engine::Data::ShaderProgram* m_skyShader{ nullptr };
- bool m_glReady{ false };
+ const Ra::Engine::Data::ShaderProgram* m_skyShader{nullptr};
+ bool m_glReady{false};
};
} // namespace RadiumNBR
diff --git a/src/libRender/RadiumNBR/FullFeatureRenderer.cpp b/src/libRender/RadiumNBR/FullFeatureRenderer.cpp
index a891d6ad45ff4b64fb04b3760e62bc301ac1bd0f..03a0c24c40364e172802a27eb6ceaec209ac43bf 100644
--- a/src/libRender/RadiumNBR/FullFeatureRenderer.cpp
+++ b/src/libRender/RadiumNBR/FullFeatureRenderer.cpp
@@ -36,37 +36,37 @@ using namespace gl;
static int FullFeaturedRendererMagic = 0x0F0F0F0F;
-static const GLenum buffers[] = { GL_COLOR_ATTACHMENT0,
- GL_COLOR_ATTACHMENT1,
- GL_COLOR_ATTACHMENT2,
- GL_COLOR_ATTACHMENT3,
- GL_COLOR_ATTACHMENT4,
- GL_COLOR_ATTACHMENT5,
- GL_COLOR_ATTACHMENT6,
- GL_COLOR_ATTACHMENT7 };
+static const GLenum buffers[] = {GL_COLOR_ATTACHMENT0,
+ GL_COLOR_ATTACHMENT1,
+ GL_COLOR_ATTACHMENT2,
+ GL_COLOR_ATTACHMENT3,
+ GL_COLOR_ATTACHMENT4,
+ GL_COLOR_ATTACHMENT5,
+ GL_COLOR_ATTACHMENT6,
+ GL_COLOR_ATTACHMENT7};
FullFeatureRenderer::FullFeatureRenderer() : NodeBasedRenderer() {}
FullFeatureRenderer::~FullFeatureRenderer() = default;
-
-
void FullFeatureRenderer::initializeInternal() {
NodeBasedRenderer::initializeInternal();
initPasses();
for ( const auto& t : sharedTextures() )
- { m_secondaryTextures.insert( { t.first, t.second.get() } ); }
+ {
+ m_secondaryTextures.insert( {t.first, t.second.get()} );
+ }
}
void FullFeatureRenderer::initPasses() {
auto resourcesCheck = Ra::Core::Resources::getResourcesPath(
- reinterpret_cast<void*>( &FullFeaturedRendererMagic ), { "Resources/RadiumNBR" } );
+ reinterpret_cast<void*>( &FullFeaturedRendererMagic ), {"Resources/RadiumNBR"} );
if ( !resourcesCheck )
{
LOG( Ra::Core::Utils::logERROR ) << "Unable to find resources for NodeBasedRenderer!";
return;
}
- auto resourcesPath{ *resourcesCheck };
+ auto resourcesPath{*resourcesCheck};
auto depthTexture = sharedTextures().find( "Depth (RadiumNBR)" );
auto colorTexture = sharedTextures().find( "Linear RGB (RadiumNBR)" );
@@ -75,7 +75,8 @@ void FullFeatureRenderer::initPasses() {
* Set the background color either to the global background color or to the env-map
*/
{
- m_clearPass = std::make_shared<ClearPass>( nullptr, FullFeaturedRendererPasses::CLEAR_PASS );
+ m_clearPass =
+ std::make_shared<ClearPass>( nullptr, FullFeaturedRendererPasses::CLEAR_PASS );
m_clearPass->setOutput( *colorTexture );
m_clearPass->setBackground( getBackgroundColor() );
m_clearPass->initializePass( m_width, m_height, m_shaderProgramManager );
@@ -88,8 +89,8 @@ void FullFeatureRenderer::initPasses() {
{
// Zprepass takes all objects but transparent objects are expected to render only their
// opaque fragments.
- m_zPrePass = std::make_shared<GeomPrePass>( allRenderObjects(),
- FullFeaturedRendererPasses::Z_PASS );
+ m_zPrePass =
+ std::make_shared<GeomPrePass>( allRenderObjects(), FullFeaturedRendererPasses::Z_PASS );
// Add the shared depth texture
m_zPrePass->setOutput( *depthTexture );
// configure acces to shader files
@@ -204,11 +205,10 @@ void FullFeatureRenderer::initPasses() {
m_wireframePass->initializePass( m_width, m_height, m_shaderProgramManager );
}
-
// Build the sequence of active passes
- addPass(m_clearPass, m_clearPass->index());
+ addPass( m_clearPass, m_clearPass->index() );
m_clearPass->activate();
- addPass(m_zPrePass, m_zPrePass->index());
+ addPass( m_zPrePass, m_zPrePass->index() );
m_zPrePass->activate();
addPass( m_aoPass, m_aoPass->index() );
m_aoPass->activate();
@@ -238,7 +238,6 @@ void FullFeatureRenderer::initPasses() {
}
}
-
// Todo : verify if the ro partition is the good one and that the passes use the right part.
void FullFeatureRenderer::updateStepInternal( const ViewingParameters& renderData ) {
// Split objects into opaque and transparent
@@ -246,7 +245,8 @@ void FullFeatureRenderer::updateStepInternal( const ViewingParameters& renderDat
m_volumetricRenderObjects.clear();
auto objectsToRender = allRenderObjects();
- for( auto it = objectsToRender->begin(); it != objectsToRender->end(); ) {
+ for ( auto it = objectsToRender->begin(); it != objectsToRender->end(); )
+ {
if ( ( *it )->isTransparent() )
{
m_transparentRenderObjects.push_back( *it );
@@ -256,7 +256,7 @@ void FullFeatureRenderer::updateStepInternal( const ViewingParameters& renderDat
{
auto material = ( *it )->getMaterial();
if ( material &&
- material->getMaterialAspect() == Material::MaterialAspect::MAT_DENSITY )
+ material->getMaterialAspect() == Material::MaterialAspect::MAT_DENSITY )
{
m_volumetricRenderObjects.push_back( *it );
it = objectsToRender->erase( it );
@@ -331,7 +331,8 @@ void FullFeatureRenderer::setAoSamplingDensity( int d ) {
void FullFeatureRenderer::wireframeMode( bool status ) {
enableWireframe( status );
- if ( m_wireframe ) {
+ if ( m_wireframe )
+ {
m_wireframePass->activate();
m_aoPass->deactivate();
@@ -340,8 +341,9 @@ void FullFeatureRenderer::wireframeMode( bool status ) {
m_locallightPass->deactivate();
m_transparencyPass->deactivate();
m_volumelightPass->deactivate();
-
- } else {
+ }
+ else
+ {
m_wireframePass->deactivate();
m_aoPass->activate();
@@ -350,7 +352,6 @@ void FullFeatureRenderer::wireframeMode( bool status ) {
m_locallightPass->activate();
m_transparencyPass->activate();
m_volumelightPass->activate();
-
}
}
} // namespace RadiumNBR
diff --git a/src/libRender/RadiumNBR/FullFeatureRenderer.hpp b/src/libRender/RadiumNBR/FullFeatureRenderer.hpp
index 852011bd45e690243344c054e10893032357813c..f1e567655676b3a01203d7d53cf20c9b720b598d 100644
--- a/src/libRender/RadiumNBR/FullFeatureRenderer.hpp
+++ b/src/libRender/RadiumNBR/FullFeatureRenderer.hpp
@@ -72,8 +72,8 @@ class NodeBasedRenderer_LIBRARY_API FullFeatureRenderer final : public NodeBased
NUM_PASSES,
DEFAULT_PASS = LIGHTING_OPAQUE_PASS
};
- protected:
+ protected:
/// Subset of the objects that are transparent and need special rendering
std::vector<RenderObjectPtr> m_transparentRenderObjects;
@@ -83,9 +83,9 @@ class NodeBasedRenderer_LIBRARY_API FullFeatureRenderer final : public NodeBased
/// The ambiant occlusion pass
std::shared_ptr<AccessibilityBufferPass> m_aoPass;
// The sampling method of the sphere sampler
- SphereSampler::SamplingMethod m_aoSamplingMethod{ SphereSampler::SamplingMethod::HAMMERSLEY };
+ SphereSampler::SamplingMethod m_aoSamplingMethod{SphereSampler::SamplingMethod::HAMMERSLEY};
// The number of points for the sampler
- int m_aoSamplingPoints{ 64 };
+ int m_aoSamplingPoints{64};
/// clear the final ouput image
std::shared_ptr<ClearPass> m_clearPass;
@@ -112,8 +112,7 @@ class NodeBasedRenderer_LIBRARY_API FullFeatureRenderer final : public NodeBased
std::shared_ptr<WireframePass> m_wireframePass;
/// Is an envmap attached to the renderer
- bool m_hasEnvMap{ false };
-
+ bool m_hasEnvMap{false};
};
} // namespace RadiumNBR
diff --git a/src/libRender/RadiumNBR/Gui/FullFeaturedRendererGui.cpp b/src/libRender/RadiumNBR/Gui/FullFeaturedRendererGui.cpp
index 625125ae8a3717bbcb564ad90fc5c8a7326b23ff..900728206dff8ca663b9f8b7a08cbe9473998705 100644
--- a/src/libRender/RadiumNBR/Gui/FullFeaturedRendererGui.cpp
+++ b/src/libRender/RadiumNBR/Gui/FullFeaturedRendererGui.cpp
@@ -8,6 +8,22 @@ RadiumNBR::Gui::RendererPanel* buildRadiumNBRGui( FullFeatureRenderer* renderer,
const std::function<void()>& appUpdateCallback ) {
auto controlPanel = new RendererPanel( renderer->getRendererName() );
+ controlPanel->addOption(
+ " Show Debug ",
+ [renderer, appUpdateCallback]( bool b ) {
+ renderer->showDebug( b );
+ appUpdateCallback();
+ },
+ false );
+
+ controlPanel->addOption(
+ " Show UI ",
+ [renderer, appUpdateCallback]( bool b ) {
+ renderer->showUI( b );
+ appUpdateCallback();
+ },
+ false );
+
auto defColor = Ra::Core::Utils::Color::linearRGBTosRGB( renderer->getBackgroundColor() );
auto clrClbck = [renderer, appUpdateCallback]( const Ra::Core::Utils::Color& clr ) {
// set the background color for all passes that need it
diff --git a/src/libRender/RadiumNBR/Gui/RendererPanel.cpp b/src/libRender/RadiumNBR/Gui/RendererPanel.cpp
index 28d17983d10f3db1a67be8234ff5b76e6c9bfe0f..9f7d40e247230a3946c6668de3b356ff0fc13e1c 100644
--- a/src/libRender/RadiumNBR/Gui/RendererPanel.cpp
+++ b/src/libRender/RadiumNBR/Gui/RendererPanel.cpp
@@ -115,7 +115,8 @@ void RendererPanel::addFileInput( const std::string& name,
std::string fileList;
for ( const auto& file : pathList )
{
- fileList += file.toStdString() + ";"; }
+ fileList += file.toStdString() + ";";
+ }
fileList.erase( fileList.size() - 1 );
callback( fileList );
}
diff --git a/src/libRender/RadiumNBR/Gui/RendererPanel.hpp b/src/libRender/RadiumNBR/Gui/RendererPanel.hpp
index 4a51a4777060f1fd4c624df4bf052a327fdf4fb3..0e7c1df3908e9521237a5b124fb621703537eea5 100644
--- a/src/libRender/RadiumNBR/Gui/RendererPanel.hpp
+++ b/src/libRender/RadiumNBR/Gui/RendererPanel.hpp
@@ -15,6 +15,8 @@ namespace Gui {
* Renderer specific gui.
* A renderer panel will expose all configurable options of a renderer to allow the user to
* interact with the renderer.
+ * @todo, allow to open layout to arrange client elements instead of putting them always in the main
+ * layout
*/
class NodeBasedRenderer_LIBRARY_API RendererPanel : public QFrame
{
diff --git a/src/libRender/RadiumNBR/NodeBasedRenderer.cpp b/src/libRender/RadiumNBR/NodeBasedRenderer.cpp
index 46106db91393abef25fd84d14ba16972047cbf34..c8bd4614c2f084272d80e01db25205c1a96115bd 100644
--- a/src/libRender/RadiumNBR/NodeBasedRenderer.cpp
+++ b/src/libRender/RadiumNBR/NodeBasedRenderer.cpp
@@ -15,6 +15,9 @@ using namespace Ra::Core::Utils; // log
#include <globjects/Framebuffer.h>
+#include <RadiumNBR/Passes/DebugPass.hpp>
+#include <RadiumNBR/Passes/UiPass.hpp>
+
using namespace Ra::Engine;
using namespace Ra::Engine::Scene;
using namespace Ra::Engine::Data;
@@ -24,15 +27,14 @@ using namespace gl;
int NodeBasedRendererMagic = 0xFF0F00F0;
-static const GLenum buffers[] = { GL_COLOR_ATTACHMENT0 };
+static const GLenum buffers[] = {GL_COLOR_ATTACHMENT0};
-static RenderControlFunctor noOpController;
+static RenderControlFunctor noOpController;
NodeBasedRenderer::NodeBasedRenderer() : Renderer(), m_controller{noOpController} {}
-NodeBasedRenderer::NodeBasedRenderer( RenderControlFunctor & controller ) :
- Renderer(),
- m_controller{controller} {}
+NodeBasedRenderer::NodeBasedRenderer( RenderControlFunctor& controller ) :
+ Renderer(), m_controller{controller} {}
NodeBasedRenderer::~NodeBasedRenderer() = default;
@@ -49,12 +51,11 @@ bool NodeBasedRenderer::buildRenderTechnique( RenderObject* ro ) const {
void NodeBasedRenderer::initResources() {
// uses several resources from the Radium engine
- auto resourcesRootDir{ RadiumEngine::getInstance()->getResourcesDir() + "Shaders/" };
+ auto resourcesRootDir{RadiumEngine::getInstance()->getResourcesDir() + "Shaders/"};
- m_shaderProgramManager->addShaderProgram(
- { { "Hdr2Ldr" },
- resourcesRootDir + "2DShaders/Basic2D.vert.glsl",
- resourcesRootDir + "2DShaders/Hdr2Ldr.frag.glsl" } );
+ m_shaderProgramManager->addShaderProgram( {{"Hdr2Ldr"},
+ resourcesRootDir + "2DShaders/Basic2D.vert.glsl",
+ resourcesRootDir + "2DShaders/Hdr2Ldr.frag.glsl"} );
m_postprocessFbo = std::make_unique<globjects::Framebuffer>();
@@ -73,7 +74,7 @@ void NodeBasedRenderer::initResources() {
texparams.format = GL_DEPTH_COMPONENT;
texparams.type = GL_UNSIGNED_INT;
texparams.name = "Depth (RadiumNBR)";
- m_sharedTextures.insert( { texparams.name, std::make_shared<Texture>( texparams ) } );
+ m_sharedTextures.insert( {texparams.name, std::make_shared<Texture>( texparams )} );
// Linear (and HDR) RGBA Color texture
texparams.internalFormat = GL_RGBA32F;
@@ -82,7 +83,7 @@ void NodeBasedRenderer::initResources() {
texparams.minFilter = GL_LINEAR;
texparams.magFilter = GL_LINEAR;
texparams.name = "Linear RGB (RadiumNBR)";
- m_sharedTextures.insert( { texparams.name, std::make_shared<Texture>( texparams ) } );
+ m_sharedTextures.insert( {texparams.name, std::make_shared<Texture>( texparams )} );
}
void NodeBasedRenderer::initializeInternal() {
@@ -106,9 +107,40 @@ void NodeBasedRenderer::initializeInternal() {
// Initialize renderer resources
initResources();
for ( const auto& t : m_sharedTextures )
- { m_secondaryTextures.insert( { t.first, t.second.get() } ); }
+ {
+ m_secondaryTextures.insert( {t.first, t.second.get()} );
+ }
m_controller.configure( this, m_width, m_height );
+
+ // Todo cache this in an attribute ?
+ auto resourcesCheck = Ra::Core::Resources::getResourcesPath(
+ reinterpret_cast<void*>( &RadiumNBR::NodeBasedRendererMagic ), {"Resources/RadiumNBR"} );
+ if ( !resourcesCheck )
+ {
+ LOG( Ra::Core::Utils::logERROR ) << "Unable to find resources for NodeBasedRenderer!";
+ return;
+ }
+ else
+ { LOG( Ra::Core::Utils::logINFO ) << "NodeBasedRenderer Resources are at " << *resourcesCheck; }
+ auto resourcesPath{*resourcesCheck};
+
+ // TODO, do we really need to setup an index for the two following passes
+ // build the Ui pass
+ // todo find a way to replace the "31" by another id
+ m_uiPass = std::make_unique<UIPass>( &m_uiRenderObjects, 31 );
+ m_uiPass->setResourcesDir( resourcesPath );
+ // configure the pass
+ m_uiPass->deactivate();
+
+ // build the Debug pass
+ m_debugPass = std::make_unique<DebugPass>( &m_debugRenderObjects );
+ m_debugPass->setResourcesDir( resourcesPath );
+ m_debugPass->setInputs( *( sharedTextures().find( "Depth (RadiumNBR)" ) ) );
+ m_debugPass->setOutput( m_fancyTexture.get() );
+ m_debugPass->initializePass( m_width, m_height, m_shaderProgramManager );
+ // configure the pass
+ m_debugPass->deactivate();
}
void NodeBasedRenderer::resizeInternal() {
@@ -132,20 +164,21 @@ void NodeBasedRenderer::resizeInternal() {
#endif
// finished with fbo, undbind to bind default
globjects::Framebuffer::unbind();
+ m_uiPass->resize( m_width, m_height );
+ m_debugPass->resize( m_width, m_height );
}
void NodeBasedRenderer::renderInternal( const ViewingParameters& renderData ) {
// Run each pass, in order.
for ( const auto& rp : m_renderPasses )
{
- if (rp.second->isActive()) {
- rp.second->execute( renderData );
- }
+ if ( rp.second->isActive() ) { rp.second->execute( renderData ); }
}
}
// Draw debug stuff, do not overwrite depth map but do depth testing
void NodeBasedRenderer::debugInternal( const ViewingParameters& renderData ) {
+ if ( m_debugPass->isActive() ) { m_debugPass->execute( renderData ); }
#if 0
if ( m_drawDebug )
{
@@ -203,6 +236,7 @@ void NodeBasedRenderer::debugInternal( const ViewingParameters& renderData ) {
// Draw UI stuff, always drawn on top of everything else + clear ZMask
void NodeBasedRenderer::uiInternal( const ViewingParameters& renderData ) {
+ if ( m_uiPass->isActive() ) { m_uiPass->execute( renderData ); }
#if 0
const ShaderProgram* shader;
@@ -279,13 +313,26 @@ void NodeBasedRenderer::updateStepInternal( const ViewingParameters& renderData
}
}
-
-bool NodeBasedRenderer::addPass( std::shared_ptr<RadiumNBR::RenderPass> pass, int rank, bool defaultPass ) {
+bool NodeBasedRenderer::addPass( std::shared_ptr<RadiumNBR::RenderPass> pass,
+ int rank,
+ bool defaultPass ) {
const auto [itPass, success] = m_renderPasses.insert( {rank, pass} );
- if ( defaultPass && success ) {
- m_defaultPass = rank;
- }
+ if ( defaultPass && success ) { m_defaultPass = rank; }
return success;
}
+void NodeBasedRenderer::showUI( bool b ) {
+ m_showUi = b;
+ if ( m_showUi ) { m_uiPass->activate(); }
+ else
+ { m_uiPass->deactivate(); }
}
+
+void NodeBasedRenderer::showDebug( bool b ) {
+ m_showDebug = b;
+ if ( m_showDebug ) { m_debugPass->activate(); }
+ else
+ { m_debugPass->deactivate(); }
+}
+
+} // namespace RadiumNBR
diff --git a/src/libRender/RadiumNBR/NodeBasedRenderer.hpp b/src/libRender/RadiumNBR/NodeBasedRenderer.hpp
index 20a69dd828b25c1b0e004d05492a8256f24e43a2..b7dfb138142516a2aa6f3ffef6d651d9244c59c1 100644
--- a/src/libRender/RadiumNBR/NodeBasedRenderer.hpp
+++ b/src/libRender/RadiumNBR/NodeBasedRenderer.hpp
@@ -15,7 +15,8 @@ namespace RadiumNBR {
extern int NodeBasedRendererMagic;
class NodeBasedRenderer;
-
+class UIPass;
+class DebugPass;
/**
* Rendering functor prototype
* @todo make this a concept
@@ -25,18 +26,17 @@ struct RenderControlFunctor {
virtual ~RenderControlFunctor() = default;
/// Configuration function.
/// Called once at the configuration of the renderer
- virtual void configure(NodeBasedRenderer *renderer, int w, int h) {};
+ virtual void configure( NodeBasedRenderer* renderer, int w, int h ){};
/// Resize function
/// Called each time the renderer is resized
- virtual void resize(int w, int h) {};
+ virtual void resize( int w, int h ){};
/// Update function
/// Called once before each frame to update the internal state of the renderer
- virtual void update(const Ra::Engine::Data::ViewingParameters& renderData) {};
+ virtual void update( const Ra::Engine::Data::ViewingParameters& renderData ){};
};
-
/** Node based for the Radium Engine
* This Renderer is fully configurable, either dynammically or programatically.
* It implements the Ra::Engine::Rendering/Renderer interface and can be configured by adding
@@ -55,7 +55,6 @@ class NodeBasedRenderer_LIBRARY_API NodeBasedRenderer : public Ra::Engine::Rende
{
public:
-
//
NodeBasedRenderer();
// TODO : instead of an std::function, restrict to a ref to a functor (class with () operator
@@ -77,11 +76,18 @@ class NodeBasedRenderer_LIBRARY_API NodeBasedRenderer : public Ra::Engine::Rende
*
* The default pass (rank 0) might be used for specific render operations.
*
- * If a pass with the same rank already exists in the Renderer, the given pass is not added nor is changed the default)
+ * If a pass with the same rank already exists in the Renderer, the given pass is not added nor
+ * is changed the default)
* @return true if the pass is insserted, false if not
- */
+ */
bool addPass( std::shared_ptr<RadiumNBR::RenderPass> pass, int rank, bool defaultPass = false );
+ /// Hide or show the UI
+ void showUI( bool b );
+
+ /// Hide or show the Debug objects
+ void showDebug( bool b );
+
protected:
void initializeInternal() override;
void resizeInternal() override;
@@ -100,30 +106,21 @@ class NodeBasedRenderer_LIBRARY_API NodeBasedRenderer : public Ra::Engine::Rende
virtual void initResources();
public:
- inline std::map<std::string, std::shared_ptr<Ra::Engine::Data::Texture>> &sharedTextures() {
+ inline std::map<std::string, std::shared_ptr<Ra::Engine::Data::Texture>>& sharedTextures() {
return m_sharedTextures;
}
- inline globjects::Framebuffer *postprocessFbo() {
- return m_postprocessFbo.get();
- }
+ inline globjects::Framebuffer* postprocessFbo() { return m_postprocessFbo.get(); }
- inline std::map< int, std::shared_ptr<RenderPass> >& renderPasses() {
- return m_renderPasses;
- }
+ inline std::map<int, std::shared_ptr<RenderPass>>& renderPasses() { return m_renderPasses; }
- inline const std::map< int, std::shared_ptr<RenderPass> >& renderPasses() const {
+ inline const std::map<int, std::shared_ptr<RenderPass>>& renderPasses() const {
return m_renderPasses;
}
- inline std::vector<RenderObjectPtr> *allRenderObjects() {
- //return &m_allRenderObjects;
- return &m_fancyRenderObjects;
- }
+ inline std::vector<RenderObjectPtr>* allRenderObjects() { return &m_fancyRenderObjects; }
- inline int defaultPass() const {
- return m_defaultPass;
- }
+ inline int defaultPass() const { return m_defaultPass; }
private:
/// textures own by the Renderer but shared across passes
@@ -133,16 +130,21 @@ class NodeBasedRenderer_LIBRARY_API NodeBasedRenderer : public Ra::Engine::Rende
std::unique_ptr<globjects::Framebuffer> m_postprocessFbo;
/// vector of this renderer render passes, sorted by precedence (first pass is at index 0)
- std::map< int, std::shared_ptr<RenderPass> > m_renderPasses;
-
- /// Backup of all objects so that global passses can execute
- //std::vector<RenderObjectPtr> m_allRenderObjects;
+ std::map<int, std::shared_ptr<RenderPass>> m_renderPasses;
/// The default pass
int m_defaultPass{-1};
/// The configurator functor to use
RenderControlFunctor& m_controller;
+
+ /// The pass to draw UI object
+ std::unique_ptr<UIPass> m_uiPass;
+ bool m_showUi{false};
+
+ /// The pass to draw UI object
+ std::unique_ptr<DebugPass> m_debugPass;
+ bool m_showDebug{false};
};
-}
+} // namespace RadiumNBR
diff --git a/src/libRender/RadiumNBR/Passes/AccessibilityBufferPass.cpp b/src/libRender/RadiumNBR/Passes/AccessibilityBufferPass.cpp
index c322b18739178b87139e7150c2ed337bbe050843..1d073551e1224bc6e0506d6cae7d22747645fae9 100644
--- a/src/libRender/RadiumNBR/Passes/AccessibilityBufferPass.cpp
+++ b/src/libRender/RadiumNBR/Passes/AccessibilityBufferPass.cpp
@@ -18,7 +18,7 @@ using namespace Ra::Core::Utils; // log
namespace RadiumNBR {
using namespace gl;
-static const GLenum buffer = { GL_COLOR_ATTACHMENT0 };
+static const GLenum buffer = {GL_COLOR_ATTACHMENT0};
AccessibilityBufferPass::AccessibilityBufferPass(
const std::vector<RenderObjectPtr>* objectsToRender,
@@ -47,7 +47,7 @@ bool AccessibilityBufferPass::initializePass( size_t width,
texparams.type = GL_FLOAT;
texparams.name = "SSDO::AOBuffer";
m_sharedTextures.insert(
- { texparams.name, std::make_shared<Ra::Engine::Data::Texture>( texparams ) } );
+ {texparams.name, std::make_shared<Ra::Engine::Data::Texture>( texparams )} );
texparams.minFilter = GL_LINEAR;
texparams.magFilter = GL_LINEAR;
@@ -65,17 +65,17 @@ bool AccessibilityBufferPass::initializePass( size_t width,
// The shader
std::string resourcesRootDir = getResourcesDir();
auto added = shaderMngr->addShaderProgram(
- { { "SSDO" },
- resourcesRootDir + "Shaders/AccessibilityPass/ssao.vert.glsl",
- resourcesRootDir + "Shaders/AccessibilityPass/ssao.frag.glsl" } );
+ {{"SSDO"},
+ resourcesRootDir + "Shaders/AccessibilityPass/ssao.vert.glsl",
+ resourcesRootDir + "Shaders/AccessibilityPass/ssao.frag.glsl"} );
if ( added ) { m_shader = added.value(); }
else
{ return false; }
added = shaderMngr->addShaderProgram(
- { { "blurSSDO" },
- resourcesRootDir + "Shaders/AccessibilityPass/ssao.vert.glsl",
- resourcesRootDir + "Shaders/AccessibilityPass/blurao.frag.glsl" } );
+ {{"blurSSDO"},
+ resourcesRootDir + "Shaders/AccessibilityPass/ssao.vert.glsl",
+ resourcesRootDir + "Shaders/AccessibilityPass/blurao.frag.glsl"} );
if ( added )
{
m_blurShader = added.value();
@@ -175,8 +175,9 @@ void AccessibilityBufferPass::setSampler( std::unique_ptr<SphereSampler> sampler
}
// Nothing to do, this pass is screen space
-bool AccessibilityBufferPass::buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
- Ra::Engine::Rendering::RenderTechnique& rt ) {
+bool AccessibilityBufferPass::buildRenderTechnique(
+ const Ra::Engine::Rendering::RenderObject* ro,
+ Ra::Engine::Rendering::RenderTechnique& rt ) const {
return true;
};
} // namespace RadiumNBR
diff --git a/src/libRender/RadiumNBR/Passes/AccessibilityBufferPass.hpp b/src/libRender/RadiumNBR/Passes/AccessibilityBufferPass.hpp
index 1a8f00853df73ffeee4c28daa82bf845a49b4ae1..84591884b87241c8f041580c6d7bd3434ca998b7 100644
--- a/src/libRender/RadiumNBR/Passes/AccessibilityBufferPass.hpp
+++ b/src/libRender/RadiumNBR/Passes/AccessibilityBufferPass.hpp
@@ -24,7 +24,7 @@ class AccessibilityBufferPass : public RenderPass
~AccessibilityBufferPass() override;
bool buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
- Ra::Engine::Rendering::RenderTechnique& rt ) override;
+ Ra::Engine::Rendering::RenderTechnique& rt ) const override;
bool initializePass( size_t width,
size_t height,
Ra::Engine::Data::ShaderProgramManager* shaderMngr ) override;
@@ -47,28 +47,28 @@ class AccessibilityBufferPass : public RenderPass
private:
/// The framebuffer used to render this pass
- std::unique_ptr<globjects::Framebuffer> m_fbo{ nullptr };
+ std::unique_ptr<globjects::Framebuffer> m_fbo{nullptr};
/// The quad to be drawn for shader invocation
- std::unique_ptr<Ra::Engine::Data::Displayable> m_quadMesh{ nullptr };
+ std::unique_ptr<Ra::Engine::Data::Displayable> m_quadMesh{nullptr};
/// The shader that computes ssdo (the Radium shader manager has ownership)
- const Ra::Engine::Data::ShaderProgram* m_shader{ nullptr };
+ const Ra::Engine::Data::ShaderProgram* m_shader{nullptr};
/// The shader that blurs ssdo (the Radium shader manager has ownership)
- const Ra::Engine::Data::ShaderProgram* m_blurShader{ nullptr };
+ const Ra::Engine::Data::ShaderProgram* m_blurShader{nullptr};
std::unique_ptr<SphereSampler> m_sphereSampler;
/// Ambiant occlusion Radius, in % of the scene bbox
- Scalar m_aoRadius{ 5 };
+ Scalar m_aoRadius{5};
/// Dimension of the scene. Used to adapt the aoRadius to the scene dimensions.
- Scalar m_sceneDiag{ 1 };
+ Scalar m_sceneDiag{1};
/// Temporary texture for raw AO computation
std::unique_ptr<Ra::Engine::Data::Texture> m_rawAO;
/// The framebuffer used to blur the AO
- std::unique_ptr<globjects::Framebuffer> m_blurfbo{ nullptr };
+ std::unique_ptr<globjects::Framebuffer> m_blurfbo{nullptr};
};
} // namespace RadiumNBR
diff --git a/src/libRender/RadiumNBR/Passes/ClearPass.cpp b/src/libRender/RadiumNBR/Passes/ClearPass.cpp
index d19fdb762ac504a2abc55d8cdfa1731ee6206941..5b09749ea0abd88fc60086f5c19db734e3089151 100644
--- a/src/libRender/RadiumNBR/Passes/ClearPass.cpp
+++ b/src/libRender/RadiumNBR/Passes/ClearPass.cpp
@@ -9,7 +9,7 @@
namespace RadiumNBR {
using namespace gl;
-static const GLenum buffers[] = { GL_COLOR_ATTACHMENT0 };
+static const GLenum buffers[] = {GL_COLOR_ATTACHMENT0};
ClearPass::ClearPass( const std::vector<RenderObjectPtr>* objectsToRender,
const Ra::Core::Utils::Index& idx ) :
@@ -64,7 +64,7 @@ void ClearPass::execute( const Ra::Engine::Data::ViewingParameters& viewParams )
}
bool ClearPass::buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
- Ra::Engine::Rendering::RenderTechnique& rt ) {
+ Ra::Engine::Rendering::RenderTechnique& rt ) const {
return true;
}
diff --git a/src/libRender/RadiumNBR/Passes/ClearPass.hpp b/src/libRender/RadiumNBR/Passes/ClearPass.hpp
index 862a7fea1418af2fa1f7e99a0c2761e9b390cce6..39b8d245a965359b7a3374998e047be5042e043b 100644
--- a/src/libRender/RadiumNBR/Passes/ClearPass.hpp
+++ b/src/libRender/RadiumNBR/Passes/ClearPass.hpp
@@ -21,7 +21,7 @@ class ClearPass : public RenderPass
~ClearPass() override;
bool buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
- Ra::Engine::Rendering::RenderTechnique& rt ) override;
+ Ra::Engine::Rendering::RenderTechnique& rt ) const override;
bool initializePass( size_t width,
size_t height,
Ra::Engine::Data::ShaderProgramManager* shaderMngr ) override;
@@ -43,10 +43,10 @@ class ClearPass : public RenderPass
private:
/// The framebuffer used to render this pass
- std::unique_ptr<globjects::Framebuffer> m_fbo{ nullptr };
+ std::unique_ptr<globjects::Framebuffer> m_fbo{nullptr};
/// The Shader manager to use when building shaders
- Ra::Engine::Data::ShaderProgramManager* m_shaderMngr{ nullptr };
+ Ra::Engine::Data::ShaderProgramManager* m_shaderMngr{nullptr};
/// The color texture for output.Stored here for easy access.
SharedTextures m_outputTexture;
@@ -55,11 +55,11 @@ class ClearPass : public RenderPass
Ra::Core::Utils::Color m_bgkColor;
/// The Environment to used for skybox display
- std::shared_ptr<EnvMap> m_envmap{ nullptr };
+ std::shared_ptr<EnvMap> m_envmap{nullptr};
/// Is the environment drawn ?
- bool m_showEnvMap{ true };
+ bool m_showEnvMap{true};
- int m_skyLod{ 0 };
+ int m_skyLod{0};
};
} // namespace RadiumNBR
diff --git a/src/libRender/RadiumNBR/Passes/DebugPass.cpp b/src/libRender/RadiumNBR/Passes/DebugPass.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5bfe18296f84ed94b4c6200cae7e4b316c73b915
--- /dev/null
+++ b/src/libRender/RadiumNBR/Passes/DebugPass.cpp
@@ -0,0 +1,100 @@
+#include <RadiumNBR/Passes/DebugPass.hpp>
+
+//#ifdef PASSES_LOG
+#include <Core/Utils/Log.hpp>
+using namespace Ra::Core::Utils; // log
+//#endif
+
+#include <Engine/Data/Material.hpp>
+#include <Engine/Data/ShaderConfigFactory.hpp>
+#include <Engine/Data/ShaderProgramManager.hpp>
+#include <Engine/Data/Texture.hpp>
+#include <Engine/Rendering/RenderObject.hpp>
+
+#include <globjects/Framebuffer.h>
+
+namespace RadiumNBR {
+using namespace gl;
+static const GLenum buffers[] = {GL_COLOR_ATTACHMENT0};
+#define DEBUG_PASS_ID 30
+DebugPass::DebugPass( const std::vector<RenderObjectPtr>* objectsToRender ) :
+ RenderPass( "User Interface pass", DEBUG_PASS_ID, objectsToRender ) {}
+
+DebugPass::~DebugPass() = default;
+
+bool DebugPass::buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
+ Ra::Engine::Rendering::RenderTechnique& rt ) const {
+ // This method is never called for DebugObject.
+ // Rendering use the Default Radium pass
+ return true;
+}
+
+bool DebugPass::initializePass( size_t width,
+ size_t height,
+ Ra::Engine::Data::ShaderProgramManager* shaderMngr ) {
+ m_shaderMngr = shaderMngr;
+ m_fbo = std::make_unique<globjects::Framebuffer>();
+ return true;
+}
+
+bool DebugPass::update() {
+ return false;
+}
+
+void DebugPass::resize( size_t width, size_t height ) {
+ // Only resize the owned textures. Imported one are resized by their owner
+ for ( auto& t : m_localTextures )
+ {
+ t.second->resize( width, height );
+ }
+
+ for ( auto& t : m_sharedTextures )
+ {
+ t.second->resize( width, height );
+ }
+
+ m_fbo->bind();
+ m_fbo->attachTexture( GL_DEPTH_ATTACHMENT, m_importedTextures["Debug::Depth"]->texture() );
+ // no need to resize the output texture, it belongs to the Ra::Engine::Rendering::Renderer and
+ // is already resized
+ m_fbo->attachTexture( GL_COLOR_ATTACHMENT0, m_outputTexture->texture() );
+#ifdef PASSES_LOG
+ if ( m_fbo->checkStatus() != GL_FRAMEBUFFER_COMPLETE )
+ { LOG( logERROR ) << "FBO Error (EmissivityPass::resize): " << m_fbo->checkStatus(); }
+#endif
+ // finished with fbo, undbind to bind default
+ globjects::Framebuffer::unbind();
+}
+
+void DebugPass::execute( const Ra::Engine::Data::ViewingParameters& viewParams ) const {
+
+ m_fbo->bind();
+ GL_ASSERT( glDisable( GL_BLEND ) );
+ GL_ASSERT( glEnable( GL_DEPTH_TEST ) );
+ GL_ASSERT( glDepthMask( GL_FALSE ) );
+ GL_ASSERT( glDepthFunc( GL_LESS ) );
+
+ glDrawBuffers( 1, buffers );
+
+ for ( const auto& ro : *m_objectsToRender )
+ {
+ ro->render( {}, viewParams );
+ }
+
+ // DebugRender::getInstance()->render( renderData.viewMatrix, renderData.projMatrix );
+
+ m_fbo->unbind();
+}
+
+/// Add the output colorBuffer
+void DebugPass::setOutput( const Ra::Engine::Data::Texture* colorBuffer ) {
+ m_outputTexture = colorBuffer;
+}
+
+/// These inputs must be computed before executing this pass
+/// depth buffer ? // TODO verify we need this
+void DebugPass::setInputs( const SharedTextures& depthBuffer ) {
+ addImportedTextures( {"Debug::Depth", depthBuffer.second} );
+}
+
+} // namespace RadiumNBR
diff --git a/src/libRender/RadiumNBR/Passes/DebugPass.hpp b/src/libRender/RadiumNBR/Passes/DebugPass.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..bbed642cdc08fd40d5cb2dee7312dbdc92ea1116
--- /dev/null
+++ b/src/libRender/RadiumNBR/Passes/DebugPass.hpp
@@ -0,0 +1,50 @@
+#pragma once
+#include <RadiumNBR/RenderPass.hpp>
+
+#include <Core/Utils/Color.hpp>
+
+namespace Ra::Engine::Data {
+class ShaderProgram;
+} // namespace Ra::Engine::Data
+
+namespace globjects {
+class Framebuffer;
+}
+
+namespace RadiumNBR {
+/** Render pass that draws the objects as UI elements
+ * This pass does not define its own rendertechnique.
+ * It draws debug object directly in the final picture by using the Radium default technique.
+ */
+class DebugPass : public RenderPass
+{
+ public:
+ explicit DebugPass( const std::vector<RenderObjectPtr>* objectsToRender );
+ ~DebugPass() override;
+
+ bool buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
+ Ra::Engine::Rendering::RenderTechnique& rt ) const override;
+ bool initializePass( size_t width,
+ size_t height,
+ Ra::Engine::Data::ShaderProgramManager* shaderMngr ) override;
+ bool update() override;
+ void resize( size_t width, size_t height ) override;
+ void execute( const Ra::Engine::Data::ViewingParameters& viewParams ) const override;
+
+ /// Add the output colorBuffer
+ void setOutput( const Ra::Engine::Data::Texture* colorBuffer );
+
+ /// These inputs must be computed before executing this pass
+ void setInputs( const SharedTextures& depthBuffer );
+
+ private:
+ /// The framebuffer used to render this pass
+ std::unique_ptr<globjects::Framebuffer> m_fbo{nullptr};
+
+ /// The Shader manager to use when building shaders
+ Ra::Engine::Data::ShaderProgramManager* m_shaderMngr{nullptr};
+
+ /// The color texture for output.Stored here for easy access.
+ const Ra::Engine::Data::Texture* m_outputTexture;
+};
+} // namespace RadiumNBR
diff --git a/src/libRender/RadiumNBR/Passes/EmissivityPass.cpp b/src/libRender/RadiumNBR/Passes/EmissivityPass.cpp
index 3d50643066972def69425da5eedd28269e3b4951..89e62b1c43f2c41b2ae808bb5a5e45fd7a395e8c 100644
--- a/src/libRender/RadiumNBR/Passes/EmissivityPass.cpp
+++ b/src/libRender/RadiumNBR/Passes/EmissivityPass.cpp
@@ -16,7 +16,7 @@ using namespace Ra::Core::Utils; // log
namespace RadiumNBR {
using namespace gl;
-static const GLenum buffers[] = { GL_COLOR_ATTACHMENT0 };
+static const GLenum buffers[] = {GL_COLOR_ATTACHMENT0};
EmissivityPass::EmissivityPass( const std::vector<RenderObjectPtr>* objectsToRender,
const Ra::Core::Utils::Index& idx ) :
@@ -35,8 +35,8 @@ bool EmissivityPass::initializePass( size_t /* width */,
void EmissivityPass::setInputs( const SharedTextures& depthBuffer,
const SharedTextures& ambientOcclusion ) {
- addImportedTextures( { "Emissivity::Depth", depthBuffer.second } );
- addImportedTextures( { "Emissivity::AmbOcc", ambientOcclusion.second } );
+ addImportedTextures( {"Emissivity::Depth", depthBuffer.second} );
+ addImportedTextures( {"Emissivity::AmbOcc", ambientOcclusion.second} );
m_passParams.addParameter( "amb_occ_sampler", ambientOcclusion.second.get() );
}
@@ -85,26 +85,28 @@ void EmissivityPass::execute( const Ra::Engine::Data::ViewingParameters& viewPar
GL_ASSERT( glDisable( GL_BLEND ) );
for ( const auto& ro : *m_objectsToRender )
- { ro->render( m_passParams, viewParams, passIndex() ); }
+ {
+ ro->render( m_passParams, viewParams, passIndex() );
+ }
}
bool EmissivityPass::buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
- Ra::Engine::Rendering::RenderTechnique& rt ) {
+ Ra::Engine::Rendering::RenderTechnique& rt ) const {
std::string resourcesRootDir = getResourcesDir();
auto mat = const_cast<Ra::Engine::Rendering::RenderObject*>( ro )->getMaterial();
// Volumes are not used in EmissivityPass
if ( mat->getMaterialAspect() == Ra::Engine::Data::Material::MaterialAspect::MAT_DENSITY )
{ return false; }
if ( auto cfg = Ra::Engine::Data::ShaderConfigurationFactory::getConfiguration(
- { "EmissivityPass::" + mat->getMaterialName() } ) )
+ {"EmissivityPass::" + mat->getMaterialName()} ) )
{ rt.setConfiguration( *cfg, passIndex() ); }
else
{
// Build the shader configuration
Ra::Engine::Data::ShaderConfiguration theConfig{
- { "EmissivityPass::" + mat->getMaterialName() },
+ {"EmissivityPass::" + mat->getMaterialName()},
resourcesRootDir + "Shaders/EmissivityPass/emissivitypass.vert.glsl",
- resourcesRootDir + "Shaders/EmissivityPass/emissivitypass.frag.glsl" };
+ resourcesRootDir + "Shaders/EmissivityPass/emissivitypass.frag.glsl"};
// add the material interface to the fragment shader
theConfig.addInclude( "\"" + mat->getMaterialName() + ".glsl\"",
Ra::Engine::Data::ShaderType::ShaderType_FRAGMENT );
diff --git a/src/libRender/RadiumNBR/Passes/EmissivityPass.hpp b/src/libRender/RadiumNBR/Passes/EmissivityPass.hpp
index fefca26a1f6d207d528ff57fe56a3185f33748f8..f229f5ce31b0c2b2804a1c802311006f5f8e554e 100644
--- a/src/libRender/RadiumNBR/Passes/EmissivityPass.hpp
+++ b/src/libRender/RadiumNBR/Passes/EmissivityPass.hpp
@@ -22,7 +22,7 @@ class EmissivityPass : public RenderPass
~EmissivityPass() override;
bool buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
- Ra::Engine::Rendering::RenderTechnique& rt ) override;
+ Ra::Engine::Rendering::RenderTechnique& rt ) const override;
bool initializePass( size_t width,
size_t height,
Ra::Engine::Data::ShaderProgramManager* shaderMngr ) override;
@@ -42,10 +42,10 @@ class EmissivityPass : public RenderPass
private:
/// The framebuffer used to render this pass
- std::unique_ptr<globjects::Framebuffer> m_fbo{ nullptr };
+ std::unique_ptr<globjects::Framebuffer> m_fbo{nullptr};
/// The Shader manager to use when building shaders
- Ra::Engine::Data::ShaderProgramManager* m_shaderMngr{ nullptr };
+ Ra::Engine::Data::ShaderProgramManager* m_shaderMngr{nullptr};
/// The color texture for output.Stored here for easy access.
SharedTextures m_outputTexture;
diff --git a/src/libRender/RadiumNBR/Passes/EnvLightPass.cpp b/src/libRender/RadiumNBR/Passes/EnvLightPass.cpp
index b2cfa5c69b929d81d1bf64a97ffdd1d92b1bf5ce..d91e6f15181baa5289204ba43a97190d580a7ada 100644
--- a/src/libRender/RadiumNBR/Passes/EnvLightPass.cpp
+++ b/src/libRender/RadiumNBR/Passes/EnvLightPass.cpp
@@ -16,7 +16,7 @@ using namespace Ra::Core::Utils; // log
namespace RadiumNBR {
using namespace gl;
-static const GLenum buffers[] = { GL_COLOR_ATTACHMENT0 };
+static const GLenum buffers[] = {GL_COLOR_ATTACHMENT0};
EnvLightPass::EnvLightPass( const std::vector<RenderObjectPtr>* objectsToRender,
const Ra::Core::Utils::Index& idx ) :
@@ -37,27 +37,27 @@ bool EnvLightPass::initializePass( size_t /* width */,
neutralEnv[imgIdx][0] = neutralEnv[imgIdx][1] = neutralEnv[imgIdx][2] = 0.f;
neutralEnv[imgIdx][3] = 0.f;
}
- Ra::Engine::Data::TextureParameters params{ "neutralEnv",
- GL_TEXTURE_CUBE_MAP,
- 1,
- 1,
- 1,
- GL_RGBA,
- GL_RGBA,
- GL_FLOAT,
- GL_CLAMP_TO_EDGE,
- GL_CLAMP_TO_EDGE,
- GL_CLAMP_TO_EDGE,
- GL_LINEAR,
- GL_LINEAR,
- (void**)( neutralEnv ) };
+ Ra::Engine::Data::TextureParameters params{"neutralEnv",
+ GL_TEXTURE_CUBE_MAP,
+ 1,
+ 1,
+ 1,
+ GL_RGBA,
+ GL_RGBA,
+ GL_FLOAT,
+ GL_CLAMP_TO_EDGE,
+ GL_CLAMP_TO_EDGE,
+ GL_CLAMP_TO_EDGE,
+ GL_LINEAR,
+ GL_LINEAR,
+ (void**)( neutralEnv )};
return true;
}
void EnvLightPass::setInputs( const SharedTextures& depthBuffer,
const SharedTextures& ambientOcclusion ) {
- addImportedTextures( { "EnvLight::Depth", depthBuffer.second } );
- addImportedTextures( { "EnvLight::AmbOcc", ambientOcclusion.second } );
+ addImportedTextures( {"EnvLight::Depth", depthBuffer.second} );
+ addImportedTextures( {"EnvLight::AmbOcc", ambientOcclusion.second} );
m_passParams.addParameter( "amb_occ_sampler", ambientOcclusion.second.get() );
}
@@ -109,29 +109,31 @@ void EnvLightPass::execute( const Ra::Engine::Data::ViewingParameters& viewParam
m_passParams.addParameter( "envStrength", m_envmap->getEnvStrength() );
for ( const auto& ro : *m_objectsToRender )
- { ro->render( m_passParams, viewParams, passIndex() ); }
+ {
+ ro->render( m_passParams, viewParams, passIndex() );
+ }
// Beware of the state left by the pass
GL_ASSERT( glDisable( GL_BLEND ) );
}
bool EnvLightPass::buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
- Ra::Engine::Rendering::RenderTechnique& rt ) {
+ Ra::Engine::Rendering::RenderTechnique& rt ) const {
std::string resourcesRootDir = getResourcesDir();
auto mat = const_cast<Ra::Engine::Rendering::RenderObject*>( ro )->getMaterial();
// Volumes are not used in EnvLightPass
if ( mat->getMaterialAspect() == Ra::Engine::Data::Material::MaterialAspect::MAT_DENSITY )
{ return false; }
if ( auto cfg = Ra::Engine::Data::ShaderConfigurationFactory::getConfiguration(
- { "EnvLightPass::" + mat->getMaterialName() } ) )
+ {"EnvLightPass::" + mat->getMaterialName()} ) )
{ rt.setConfiguration( *cfg, passIndex() ); }
else
{
// Build the shader configuration
Ra::Engine::Data::ShaderConfiguration theConfig{
- { "EnvLightPass::" + mat->getMaterialName() },
+ {"EnvLightPass::" + mat->getMaterialName()},
resourcesRootDir + "Shaders/EnvLightPass/envlightpass.vert.glsl",
- resourcesRootDir + "Shaders/EnvLightPass/envlightpass.frag.glsl" };
+ resourcesRootDir + "Shaders/EnvLightPass/envlightpass.frag.glsl"};
// add the material interface to the fragment shader
theConfig.addInclude( "\"" + mat->getMaterialName() + ".glsl\"",
Ra::Engine::Data::ShaderType::ShaderType_FRAGMENT );
diff --git a/src/libRender/RadiumNBR/Passes/EnvLightPass.hpp b/src/libRender/RadiumNBR/Passes/EnvLightPass.hpp
index 737a447c700ce45d790d4d9f1cc71f3b31ed1f47..bd6b0d7c313be8bbb34620e798e0b49a6236db01 100644
--- a/src/libRender/RadiumNBR/Passes/EnvLightPass.hpp
+++ b/src/libRender/RadiumNBR/Passes/EnvLightPass.hpp
@@ -26,7 +26,7 @@ class EnvLightPass : public RenderPass
~EnvLightPass() override;
bool buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
- Ra::Engine::Rendering::RenderTechnique& rt ) override;
+ Ra::Engine::Rendering::RenderTechnique& rt ) const override;
bool initializePass( size_t width,
size_t height,
Ra::Engine::Data::ShaderProgramManager* shaderMngr ) override;
@@ -58,16 +58,16 @@ class EnvLightPass : public RenderPass
private:
/// The framebuffer used to render this pass
- std::unique_ptr<globjects::Framebuffer> m_fbo{ nullptr };
+ std::unique_ptr<globjects::Framebuffer> m_fbo{nullptr};
/// The Shader manager to use when building shaders
- Ra::Engine::Data::ShaderProgramManager* m_shaderMngr{ nullptr };
+ Ra::Engine::Data::ShaderProgramManager* m_shaderMngr{nullptr};
/// The color texture for output.Stored here for easy access.
SharedTextures m_outputTexture;
/// The Environment to used for envmap lighting
- std::shared_ptr<EnvMap> m_envmap{ nullptr };
+ std::shared_ptr<EnvMap> m_envmap{nullptr};
/// The strength of the envmap
float m_envStrength;
diff --git a/src/libRender/RadiumNBR/Passes/GeomPrepass.cpp b/src/libRender/RadiumNBR/Passes/GeomPrepass.cpp
index 6ac1716c685cd3716a75787456a88c6e1f433f0c..3b86d7a8a2f7ebfb72f746deee43a99bfc7ed4ed 100644
--- a/src/libRender/RadiumNBR/Passes/GeomPrepass.cpp
+++ b/src/libRender/RadiumNBR/Passes/GeomPrepass.cpp
@@ -16,14 +16,14 @@ using namespace Ra::Core::Utils; // log
namespace RadiumNBR {
using namespace gl;
-static const GLenum buffers[] = { GL_COLOR_ATTACHMENT0,
- GL_COLOR_ATTACHMENT1,
- GL_COLOR_ATTACHMENT2,
- GL_COLOR_ATTACHMENT3,
- GL_COLOR_ATTACHMENT4,
- GL_COLOR_ATTACHMENT5,
- GL_COLOR_ATTACHMENT6,
- GL_COLOR_ATTACHMENT7 };
+static const GLenum buffers[] = {GL_COLOR_ATTACHMENT0,
+ GL_COLOR_ATTACHMENT1,
+ GL_COLOR_ATTACHMENT2,
+ GL_COLOR_ATTACHMENT3,
+ GL_COLOR_ATTACHMENT4,
+ GL_COLOR_ATTACHMENT5,
+ GL_COLOR_ATTACHMENT6,
+ GL_COLOR_ATTACHMENT7};
GeomPrePass::GeomPrePass( const std::vector<RenderObjectPtr>* objectsToRender,
const Ra::Core::Utils::Index& idx ) :
@@ -48,19 +48,19 @@ bool GeomPrePass::initializePass( size_t width,
texparams.type = GL_FLOAT;
texparams.name = "GeomPrePass::PosInWorld";
m_sharedTextures.insert(
- { texparams.name, std::make_shared<Ra::Engine::Data::Texture>( texparams ) } );
+ {texparams.name, std::make_shared<Ra::Engine::Data::Texture>( texparams )} );
texparams.minFilter = GL_LINEAR;
texparams.magFilter = GL_LINEAR;
texparams.name = "GeomPrePass::NormalInWorld";
m_sharedTextures.insert(
- { texparams.name, std::make_shared<Ra::Engine::Data::Texture>( texparams ) } );
+ {texparams.name, std::make_shared<Ra::Engine::Data::Texture>( texparams )} );
return true;
}
void GeomPrePass::setOutput( const SharedTextures& depthTexture ) {
- addImportedTextures( { "GeomPrePass::Depth", depthTexture.second } );
+ addImportedTextures( {"GeomPrePass::Depth", depthTexture.second} );
}
bool GeomPrePass::update() {
@@ -95,7 +95,7 @@ void GeomPrePass::resize( size_t width, size_t height ) {
void GeomPrePass::execute( const Ra::Engine::Data::ViewingParameters& viewParams ) const {
using ClearColor = Ra::Core::Utils::Color;
- static const float clearDepth{ 1.0f };
+ static const float clearDepth{1.0f};
m_fbo->bind();
@@ -104,7 +104,7 @@ void GeomPrePass::execute( const Ra::Engine::Data::ViewingParameters& viewParams
GL_ASSERT( glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE ) );
// only draw into 2 buffers (Normal, Worldpos)
GL_ASSERT( glDrawBuffers( 2, buffers ) );
- float pblck[4] = { 0, 0, 0, 0 };
+ float pblck[4] = {0, 0, 0, 0};
GL_ASSERT( glClearBufferfv( GL_COLOR, 0, pblck ) ); // Clear World pos
GL_ASSERT( glClearBufferfv( GL_COLOR, 1, pblck ) ); // Clear Normals
GL_ASSERT( glClearBufferfv( GL_DEPTH, 0, &clearDepth ) );
@@ -114,28 +114,31 @@ void GeomPrePass::execute( const Ra::Engine::Data::ViewingParameters& viewParams
glPolygonOffset( 1.1f, 1.f );
glEnable( GL_POLYGON_OFFSET_FILL );
for ( const auto& ro : *m_objectsToRender )
- { ro->render( m_passParams, viewParams, passIndex() ); }
+ {
+ ro->render( m_passParams, viewParams, passIndex() );
+ }
- // Beware of the state left by the pass : Polygon offset must be enable after this for rendering coherency
+ // Beware of the state left by the pass : Polygon offset must be enable after this for rendering
+ // coherency
}
bool GeomPrePass::buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
- Ra::Engine::Rendering::RenderTechnique& rt ) {
+ Ra::Engine::Rendering::RenderTechnique& rt ) const {
std::string resourcesRootDir = getResourcesDir();
auto mat = const_cast<Ra::Engine::Rendering::RenderObject*>( ro )->getMaterial();
// Volumes are not used in geomPrepass
if ( mat->getMaterialAspect() == Ra::Engine::Data::Material::MaterialAspect::MAT_DENSITY )
{ return false; }
if ( auto cfg = Ra::Engine::Data::ShaderConfigurationFactory::getConfiguration(
- { "GeomPrePass::" + mat->getMaterialName() } ) )
+ {"GeomPrePass::" + mat->getMaterialName()} ) )
{ rt.setConfiguration( *cfg, passIndex() ); }
else
{
// Build the shader configuration
Ra::Engine::Data::ShaderConfiguration theConfig{
- { "GeomPrePass::" + mat->getMaterialName() },
+ {"GeomPrePass::" + mat->getMaterialName()},
resourcesRootDir + "Shaders/ZPrepass/zprepass.vert.glsl",
- resourcesRootDir + "Shaders/ZPrepass/zprepass.frag.glsl" };
+ resourcesRootDir + "Shaders/ZPrepass/zprepass.frag.glsl"};
// add the material interface to the fragment shader
theConfig.addInclude( "\"" + mat->getMaterialName() + ".glsl\"",
Ra::Engine::Data::ShaderType::ShaderType_FRAGMENT );
diff --git a/src/libRender/RadiumNBR/Passes/GeomPrepass.hpp b/src/libRender/RadiumNBR/Passes/GeomPrepass.hpp
index 77a11e04a1cc1e1e5611d0eb39dad72781f93369..e5433ac4514826a30a2f3e73a3412a22277564ca 100644
--- a/src/libRender/RadiumNBR/Passes/GeomPrepass.hpp
+++ b/src/libRender/RadiumNBR/Passes/GeomPrepass.hpp
@@ -19,7 +19,7 @@ class NodeBasedRenderer_LIBRARY_API GeomPrePass : public RenderPass
~GeomPrePass() override;
bool buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
- Ra::Engine::Rendering::RenderTechnique& rt ) override;
+ Ra::Engine::Rendering::RenderTechnique& rt ) const override;
bool initializePass( size_t width,
size_t height,
Ra::Engine::Data::ShaderProgramManager* shaderMngr ) override;
@@ -32,9 +32,9 @@ class NodeBasedRenderer_LIBRARY_API GeomPrePass : public RenderPass
private:
/// The framebuffer used to render this pass
- std::unique_ptr<globjects::Framebuffer> m_fbo{ nullptr };
+ std::unique_ptr<globjects::Framebuffer> m_fbo{nullptr};
/// The Shader manager to use when building shaders
- Ra::Engine::Data::ShaderProgramManager* m_shaderMngr{ nullptr };
+ Ra::Engine::Data::ShaderProgramManager* m_shaderMngr{nullptr};
};
} // namespace RadiumNBR
diff --git a/src/libRender/RadiumNBR/Passes/LocalLightPass.cpp b/src/libRender/RadiumNBR/Passes/LocalLightPass.cpp
index ce0d10285f1814753ecacdd6fe9313f216e1080e..92864dc52fd34b45d9f4301be3e35c81caa98880 100644
--- a/src/libRender/RadiumNBR/Passes/LocalLightPass.cpp
+++ b/src/libRender/RadiumNBR/Passes/LocalLightPass.cpp
@@ -18,7 +18,7 @@ using namespace Ra::Core::Utils; // log
namespace RadiumNBR {
using namespace gl;
-static const GLenum buffers[] = { GL_COLOR_ATTACHMENT0 };
+static const GLenum buffers[] = {GL_COLOR_ATTACHMENT0};
LocalLightPass::LocalLightPass( const std::vector<RenderObjectPtr>* objectsToRender,
const Ra::Core::Utils::Index& idx ) :
@@ -37,8 +37,8 @@ bool LocalLightPass::initializePass( size_t /* width */,
void LocalLightPass::setInputs( const SharedTextures& depthBuffer,
const SharedTextures& ambientOcclusion ) {
- addImportedTextures( { "LocalLight::Depth", depthBuffer.second } );
- addImportedTextures( { "LocalLight::AmbOcc", ambientOcclusion.second } );
+ addImportedTextures( {"LocalLight::Depth", depthBuffer.second} );
+ addImportedTextures( {"LocalLight::AmbOcc", ambientOcclusion.second} );
m_passParams.addParameter( "amb_occ_sampler", ambientOcclusion.second.get() );
}
@@ -114,23 +114,23 @@ void LocalLightPass::execute( const Ra::Engine::Data::ViewingParameters& viewPar
}
bool LocalLightPass::buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
- Ra::Engine::Rendering::RenderTechnique& rt ) {
+ Ra::Engine::Rendering::RenderTechnique& rt ) const {
auto mat = const_cast<Ra::Engine::Rendering::RenderObject*>( ro )->getMaterial();
// Volumes are not used in EnvLightPass
if ( mat->getMaterialAspect() == Ra::Engine::Data::Material::MaterialAspect::MAT_DENSITY )
{ return false; }
if ( auto cfg = Ra::Engine::Data::ShaderConfigurationFactory::getConfiguration(
- { "LocalLightPass::" + mat->getMaterialName() } ) )
+ {"LocalLightPass::" + mat->getMaterialName()} ) )
{ rt.setConfiguration( *cfg, passIndex() ); }
else
{
std::string resourcesRootDir = getResourcesDir();
// Build the shader configuration
Ra::Engine::Data::ShaderConfiguration theConfig{
- { "LocalLightPass::" + mat->getMaterialName() },
+ {"LocalLightPass::" + mat->getMaterialName()},
resourcesRootDir + "Shaders/LocalLightPass/lightpass.vert.glsl",
- resourcesRootDir + "Shaders/LocalLightPass/lightpass.frag.glsl" };
+ resourcesRootDir + "Shaders/LocalLightPass/lightpass.frag.glsl"};
// add the material interface to the fragment shader
theConfig.addInclude( "\"" + mat->getMaterialName() + ".glsl\"",
Ra::Engine::Data::ShaderType::ShaderType_FRAGMENT );
diff --git a/src/libRender/RadiumNBR/Passes/LocalLightPass.hpp b/src/libRender/RadiumNBR/Passes/LocalLightPass.hpp
index a4f982c3711692c59ef500ef408a963de62e37d4..bf16f277f0833918c0e8220f83ab62160f7a7763 100644
--- a/src/libRender/RadiumNBR/Passes/LocalLightPass.hpp
+++ b/src/libRender/RadiumNBR/Passes/LocalLightPass.hpp
@@ -25,7 +25,7 @@ class LocalLightPass : public RenderPass
~LocalLightPass() override;
bool buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
- Ra::Engine::Rendering::RenderTechnique& rt ) override;
+ Ra::Engine::Rendering::RenderTechnique& rt ) const override;
bool initializePass( size_t width,
size_t height,
Ra::Engine::Data::ShaderProgramManager* shaderMngr ) override;
@@ -45,10 +45,10 @@ class LocalLightPass : public RenderPass
private:
/// The framebuffer used to render this pass
- std::unique_ptr<globjects::Framebuffer> m_fbo{ nullptr };
+ std::unique_ptr<globjects::Framebuffer> m_fbo{nullptr};
/// The Shader manager to use when building shaders
- Ra::Engine::Data::ShaderProgramManager* m_shaderMngr{ nullptr };
+ Ra::Engine::Data::ShaderProgramManager* m_shaderMngr{nullptr};
/// The color texture for output.Stored here for easy access.
SharedTextures m_outputTexture;
diff --git a/src/libRender/RadiumNBR/Passes/TransparencyPass.cpp b/src/libRender/RadiumNBR/Passes/TransparencyPass.cpp
index d28871cedae97787df8ba84e537e4fe945a148da..e90bd2e400634af8adc27a3102731b77323c6071 100644
--- a/src/libRender/RadiumNBR/Passes/TransparencyPass.cpp
+++ b/src/libRender/RadiumNBR/Passes/TransparencyPass.cpp
@@ -20,7 +20,7 @@ using namespace Ra::Core::Utils; // log
namespace RadiumNBR {
using namespace gl;
-static const GLenum buffers[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 };
+static const GLenum buffers[] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1};
TransparencyPass::TransparencyPass( const std::vector<RenderObjectPtr>* objectsToRender,
const Ra::Core::Utils::Index& idx ) :
@@ -46,10 +46,10 @@ bool TransparencyPass::initializePass( size_t width,
texparams.type = GL_FLOAT;
texparams.name = "Transparency::Accum";
m_sharedTextures.insert(
- { texparams.name, std::make_shared<Ra::Engine::Data::Texture>( texparams ) } );
+ {texparams.name, std::make_shared<Ra::Engine::Data::Texture>( texparams )} );
texparams.name = "Transparency::Revealage";
m_sharedTextures.insert(
- { texparams.name, std::make_shared<Ra::Engine::Data::Texture>( texparams ) } );
+ {texparams.name, std::make_shared<Ra::Engine::Data::Texture>( texparams )} );
// The compositer caller
Ra::Core::Geometry::TriangleMesh mesh =
@@ -59,13 +59,13 @@ bool TransparencyPass::initializePass( size_t width,
m_quadMesh = std::move( qm );
m_quadMesh->updateGL();
- const std::string composeVertexShader{ "layout (location = 0) in vec3 in_position;\n"
- "out vec2 varTexcoord;\n"
- "void main()\n"
- "{\n"
- " gl_Position = vec4(in_position, 1.0);\n"
- " varTexcoord = (in_position.xy + 1.0) * 0.5;\n"
- "}\n" };
+ const std::string composeVertexShader{"layout (location = 0) in vec3 in_position;\n"
+ "out vec2 varTexcoord;\n"
+ "void main()\n"
+ "{\n"
+ " gl_Position = vec4(in_position, 1.0);\n"
+ " varTexcoord = (in_position.xy + 1.0) * 0.5;\n"
+ "}\n"};
const std::string composeFragmentShader{
"in vec2 varTexcoord;\n"
"out vec4 f_Color;\n"
@@ -77,8 +77,8 @@ bool TransparencyPass::initializePass( size_t width,
" vec4 accum = texture( u_OITSumColor, varTexcoord );\n"
" vec3 avg_color = accum.rgb / max( accum.a, 0.00001 );\n"
" f_Color = vec4( avg_color, r );\n"
- "}" };
- Ra::Engine::Data::ShaderConfiguration config{ "ComposeTransparency" };
+ "}"};
+ Ra::Engine::Data::ShaderConfiguration config{"ComposeTransparency"};
config.addShaderSource( Ra::Engine::Data::ShaderType::ShaderType_VERTEX, composeVertexShader );
config.addShaderSource( Ra::Engine::Data::ShaderType::ShaderType_FRAGMENT,
composeFragmentShader );
@@ -92,8 +92,8 @@ bool TransparencyPass::initializePass( size_t width,
void TransparencyPass::setInputs( const SharedTextures& depthBuffer,
const SharedTextures& ambientOcclusion ) {
- addImportedTextures( { "Transparency::Depth", depthBuffer.second } );
- addImportedTextures( { "Transparency::AmbOcc", ambientOcclusion.second } );
+ addImportedTextures( {"Transparency::Depth", depthBuffer.second} );
+ addImportedTextures( {"Transparency::AmbOcc", ambientOcclusion.second} );
}
void TransparencyPass::setOutput( const SharedTextures& colorBuffer ) {
@@ -202,23 +202,23 @@ void TransparencyPass::execute( const Ra::Engine::Data::ViewingParameters& viewP
}
bool TransparencyPass::buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
- Ra::Engine::Rendering::RenderTechnique& rt ) {
+ Ra::Engine::Rendering::RenderTechnique& rt ) const {
// Only transparent objects matters
if ( !ro->isTransparent() ) { return false; }
auto mat = const_cast<Ra::Engine::Rendering::RenderObject*>( ro )->getMaterial();
if ( auto cfg = Ra::Engine::Data::ShaderConfigurationFactory::getConfiguration(
- { "TransparencyPass::" + mat->getMaterialName() } ) )
+ {"TransparencyPass::" + mat->getMaterialName()} ) )
{ rt.setConfiguration( *cfg, passIndex() ); }
else
{
std::string resourcesRootDir = getResourcesDir();
// Build the shader configuration
Ra::Engine::Data::ShaderConfiguration theConfig{
- { "TransparencyPass::" + mat->getMaterialName() },
+ {"TransparencyPass::" + mat->getMaterialName()},
resourcesRootDir + "Shaders/TransparencyPass/oitpass.vert.glsl",
- resourcesRootDir + "Shaders/TransparencyPass/oitpass.frag.glsl" };
+ resourcesRootDir + "Shaders/TransparencyPass/oitpass.frag.glsl"};
// add the material interface to the fragment shader
theConfig.addInclude( "\"" + mat->getMaterialName() + ".glsl\"",
Ra::Engine::Data::ShaderType::ShaderType_FRAGMENT );
diff --git a/src/libRender/RadiumNBR/Passes/TransparencyPass.hpp b/src/libRender/RadiumNBR/Passes/TransparencyPass.hpp
index 2de755a6c11b37d1034cadeccfd4c4b0ac2e9e11..ad972405cfe762b55f8846928a944ef04eba475e 100644
--- a/src/libRender/RadiumNBR/Passes/TransparencyPass.hpp
+++ b/src/libRender/RadiumNBR/Passes/TransparencyPass.hpp
@@ -27,7 +27,7 @@ class TransparencyPass : public RenderPass
~TransparencyPass() override;
bool buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
- Ra::Engine::Rendering::RenderTechnique& rt ) override;
+ Ra::Engine::Rendering::RenderTechnique& rt ) const override;
bool initializePass( size_t width,
size_t height,
Ra::Engine::Data::ShaderProgramManager* shaderMngr ) override;
@@ -47,20 +47,20 @@ class TransparencyPass : public RenderPass
private:
/// The framebuffer used to render this pass
- std::unique_ptr<globjects::Framebuffer> m_fbo{ nullptr };
+ std::unique_ptr<globjects::Framebuffer> m_fbo{nullptr};
/// The framebuffer to render the Transparent objects
- std::unique_ptr<globjects::Framebuffer> m_oitFbo{ nullptr };
+ std::unique_ptr<globjects::Framebuffer> m_oitFbo{nullptr};
/// The quad to be drawn for shader invocation
- std::unique_ptr<Ra::Engine::Data::Displayable> m_quadMesh{ nullptr };
+ std::unique_ptr<Ra::Engine::Data::Displayable> m_quadMesh{nullptr};
/// The shader that compose the volume onto the color picture (the Radium shader manager has
/// ownership)
- const Ra::Engine::Data::ShaderProgram* m_shader{ nullptr };
+ const Ra::Engine::Data::ShaderProgram* m_shader{nullptr};
/// The Shader manager to use when building shaders
- Ra::Engine::Data::ShaderProgramManager* m_shaderMngr{ nullptr };
+ Ra::Engine::Data::ShaderProgramManager* m_shaderMngr{nullptr};
/// The color texture for output.Stored here for easy access.
SharedTextures m_outputTexture;
diff --git a/src/libRender/RadiumNBR/Passes/UiPass.cpp b/src/libRender/RadiumNBR/Passes/UiPass.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..141dfbebcd92b1c56da8e34147c11e70b213e3f1
--- /dev/null
+++ b/src/libRender/RadiumNBR/Passes/UiPass.cpp
@@ -0,0 +1,54 @@
+#include <RadiumNBR/Passes/UiPass.hpp>
+
+//#ifdef PASSES_LOG
+#include <Core/Utils/Log.hpp>
+using namespace Ra::Core::Utils; // log
+//#endif
+
+#include <Engine/Data/Material.hpp>
+#include <Engine/Data/ShaderConfigFactory.hpp>
+#include <Engine/Data/ShaderProgramManager.hpp>
+#include <Engine/Data/Texture.hpp>
+#include <Engine/Rendering/RenderObject.hpp>
+
+#include <globjects/Framebuffer.h>
+
+namespace RadiumNBR {
+using namespace gl;
+
+UIPass::UIPass( const std::vector<RenderObjectPtr>* objectsToRender,
+ const Ra::Core::Utils::Index& idx ) :
+ RenderPass( "User Interface pass", idx, objectsToRender ) {}
+
+UIPass::~UIPass() = default;
+
+bool UIPass::buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
+ Ra::Engine::Rendering::RenderTechnique& rt ) const {
+ return false;
+}
+
+bool UIPass::initializePass( size_t width,
+ size_t height,
+ Ra::Engine::Data::ShaderProgramManager* shaderMngr ) {
+ return false;
+}
+
+bool UIPass::update() {
+ return false;
+}
+
+void UIPass::resize( size_t width, size_t height ) {}
+
+void UIPass::execute( const Ra::Engine::Data::ViewingParameters& viewParams ) const {
+ LOG( Ra::Core::Utils::logINFO )
+ << " requested to render " << m_objectsToRender->size() << " UI objects";
+}
+
+/// Add the output colorBuffer
+void UIPass::setOutput( const SharedTextures& colorBuffer ) {}
+
+/// These inputs must be computed before executing this pass
+/// depth buffer ? // TODO verify we need this
+void UIPass::setInputs( const SharedTextures& depthBuffer ) {}
+
+} // namespace RadiumNBR
diff --git a/src/libRender/RadiumNBR/Passes/UiPass.hpp b/src/libRender/RadiumNBR/Passes/UiPass.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..4e92a4bebe51aee6e8ac719fa1b51ed06de7dd54
--- /dev/null
+++ b/src/libRender/RadiumNBR/Passes/UiPass.hpp
@@ -0,0 +1,49 @@
+#pragma once
+#include <RadiumNBR/RenderPass.hpp>
+
+#include <Core/Utils/Color.hpp>
+
+namespace Ra::Engine::Data {
+class ShaderProgram;
+} // namespace Ra::Engine::Data
+
+namespace globjects {
+class Framebuffer;
+}
+
+namespace RadiumNBR {
+/// Render pass that draws the objects as UI elements
+class UIPass : public RenderPass
+{
+ public:
+ UIPass( const std::vector<RenderObjectPtr>* objectsToRender,
+ const Ra::Core::Utils::Index& idx );
+ ~UIPass() override;
+
+ bool buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
+ Ra::Engine::Rendering::RenderTechnique& rt ) const override;
+ bool initializePass( size_t width,
+ size_t height,
+ Ra::Engine::Data::ShaderProgramManager* shaderMngr ) override;
+ bool update() override;
+ void resize( size_t width, size_t height ) override;
+ void execute( const Ra::Engine::Data::ViewingParameters& viewParams ) const override;
+
+ /// Add the output colorBuffer
+ void setOutput( const SharedTextures& colorBuffer );
+
+ /// These inputs must be computed before executing this pass
+ /// depth buffer ? // TODO verify we need this
+ void setInputs( const SharedTextures& depthBuffer );
+
+ private:
+ /// The framebuffer used to render this pass
+ std::unique_ptr<globjects::Framebuffer> m_fbo{nullptr};
+
+ /// The Shader manager to use when building shaders
+ Ra::Engine::Data::ShaderProgramManager* m_shaderMngr{nullptr};
+
+ /// The color texture for output.Stored here for easy access.
+ SharedTextures m_outputTexture;
+};
+} // namespace RadiumNBR
diff --git a/src/libRender/RadiumNBR/Passes/VolumePass.cpp b/src/libRender/RadiumNBR/Passes/VolumePass.cpp
index a7782fde57d03a90880026571c77b50d0d92c3ee..d6d1e7855a48fb390e4c9effd643030669126ae1 100644
--- a/src/libRender/RadiumNBR/Passes/VolumePass.cpp
+++ b/src/libRender/RadiumNBR/Passes/VolumePass.cpp
@@ -20,7 +20,7 @@ using namespace Ra::Core::Utils; // log
namespace RadiumNBR {
using namespace gl;
-static const GLenum buffers[] = { GL_COLOR_ATTACHMENT0 };
+static const GLenum buffers[] = {GL_COLOR_ATTACHMENT0};
VolumeLightingPass::VolumeLightingPass( const std::vector<RenderObjectPtr>* objectsToRender,
const Ra::Core::Utils::Index& idx ) :
@@ -46,7 +46,7 @@ bool VolumeLightingPass::initializePass( size_t width,
texparams.type = GL_FLOAT;
texparams.name = "VolumeLighting::RawVolume";
m_sharedTextures.insert(
- { texparams.name, std::make_shared<Ra::Engine::Data::Texture>( texparams ) } );
+ {texparams.name, std::make_shared<Ra::Engine::Data::Texture>( texparams )} );
// The shader caller
Ra::Core::Geometry::TriangleMesh mesh =
@@ -57,13 +57,13 @@ bool VolumeLightingPass::initializePass( size_t width,
m_quadMesh->updateGL();
// The shader
- const std::string vrtxSrc{ "layout (location = 0) in vec3 in_position;\n"
- "out vec2 varTexcoord;\n"
- "void main()\n"
- "{\n"
- " gl_Position = vec4(in_position, 1.0);\n"
- " varTexcoord = (in_position.xy + 1.0) / 2.0;\n"
- "}\n" };
+ const std::string vrtxSrc{"layout (location = 0) in vec3 in_position;\n"
+ "out vec2 varTexcoord;\n"
+ "void main()\n"
+ "{\n"
+ " gl_Position = vec4(in_position, 1.0);\n"
+ " varTexcoord = (in_position.xy + 1.0) / 2.0;\n"
+ "}\n"};
const std::string frgSrc{
"out vec4 fragColor;\n"
"in vec2 varTexcoord;\n"
@@ -75,8 +75,8 @@ bool VolumeLightingPass::initializePass( size_t width,
" if (volColor.a < 1)\n"
" discard;\n"
" fragColor = vec4(volColor.rgb, 0);\n"
- "}\n" };
- Ra::Engine::Data::ShaderConfiguration config{ "ComposeVolume" };
+ "}\n"};
+ Ra::Engine::Data::ShaderConfiguration config{"ComposeVolume"};
config.addShaderSource( Ra::Engine::Data::ShaderType::ShaderType_VERTEX, vrtxSrc );
config.addShaderSource( Ra::Engine::Data::ShaderType::ShaderType_FRAGMENT, frgSrc );
auto added = shaderMngr->addShaderProgram( config );
@@ -89,8 +89,8 @@ bool VolumeLightingPass::initializePass( size_t width,
void VolumeLightingPass::setInputs( const SharedTextures& depthBuffer,
const SharedTextures& colorBuffer ) {
- addImportedTextures( { "VolumeLighting::Depth", depthBuffer.second } );
- addImportedTextures( { "VolumeLighting::ColorInput", colorBuffer.second } );
+ addImportedTextures( {"VolumeLighting::Depth", depthBuffer.second} );
+ addImportedTextures( {"VolumeLighting::ColorInput", colorBuffer.second} );
}
void VolumeLightingPass::setOutput( const SharedTextures& colorBuffer ) {
@@ -179,22 +179,22 @@ void VolumeLightingPass::execute( const Ra::Engine::Data::ViewingParameters& vie
}
bool VolumeLightingPass::buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
- Ra::Engine::Rendering::RenderTechnique& rt ) {
+ Ra::Engine::Rendering::RenderTechnique& rt ) const {
std::string resourcesRootDir = getResourcesDir();
auto mat = const_cast<Ra::Engine::Rendering::RenderObject*>( ro )->getMaterial();
// Only volumes are used by this pass
if ( mat->getMaterialAspect() != Ra::Engine::Data::Material::MaterialAspect::MAT_DENSITY )
{ return false; }
if ( auto cfg = Ra::Engine::Data::ShaderConfigurationFactory::getConfiguration(
- { "VolumeLightingPass::" + mat->getMaterialName() } ) )
+ {"VolumeLightingPass::" + mat->getMaterialName()} ) )
{ rt.setConfiguration( *cfg, passIndex() ); }
else
{
// Build the shader configuration
Ra::Engine::Data::ShaderConfiguration theConfig{
- { "VolumeLightingPass::" + mat->getMaterialName() },
+ {"VolumeLightingPass::" + mat->getMaterialName()},
resourcesRootDir + "Shaders/VolumeLightingPass/volume.vert.glsl",
- resourcesRootDir + "Shaders/VolumeLightingPass/volume.frag.glsl" };
+ resourcesRootDir + "Shaders/VolumeLightingPass/volume.frag.glsl"};
/*
// add the material interface to the fragment shader
theConfig.addInclude( "\"" + mat->getMaterialName() + ".glsl\"",
diff --git a/src/libRender/RadiumNBR/Passes/VolumePass.hpp b/src/libRender/RadiumNBR/Passes/VolumePass.hpp
index cb71d8606987e49ad86f599b639e110b8ce70525..584ff5a518d24cae1a450c44470f3de32c5c4071 100644
--- a/src/libRender/RadiumNBR/Passes/VolumePass.hpp
+++ b/src/libRender/RadiumNBR/Passes/VolumePass.hpp
@@ -33,7 +33,7 @@ class VolumeLightingPass : public RenderPass
~VolumeLightingPass() override;
bool buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
- Ra::Engine::Rendering::RenderTechnique& rt ) override;
+ Ra::Engine::Rendering::RenderTechnique& rt ) const override;
bool initializePass( size_t width,
size_t height,
Ra::Engine::Data::ShaderProgramManager* shaderMngr ) override;
@@ -57,20 +57,20 @@ class VolumeLightingPass : public RenderPass
private:
/// The framebuffer used to render this pass
- std::unique_ptr<globjects::Framebuffer> m_fbo{ nullptr };
+ std::unique_ptr<globjects::Framebuffer> m_fbo{nullptr};
/// The framebuffer to render the volume
- std::unique_ptr<globjects::Framebuffer> m_volumeFbo{ nullptr };
+ std::unique_ptr<globjects::Framebuffer> m_volumeFbo{nullptr};
/// The quad to be drawn for shader invocation
- std::unique_ptr<Ra::Engine::Data::Displayable> m_quadMesh{ nullptr };
+ std::unique_ptr<Ra::Engine::Data::Displayable> m_quadMesh{nullptr};
/// The shader that compose the volume onto the color picture (the Radium shader manager has
/// ownership)
- const Ra::Engine::Data::ShaderProgram* m_shader{ nullptr };
+ const Ra::Engine::Data::ShaderProgram* m_shader{nullptr};
/// The Shader manager to use when building shaders
- Ra::Engine::Data::ShaderProgramManager* m_shaderMngr{ nullptr };
+ Ra::Engine::Data::ShaderProgramManager* m_shaderMngr{nullptr};
/// The color texture for output.Stored here for easy access.
SharedTextures m_outputTexture;
@@ -79,6 +79,6 @@ class VolumeLightingPass : public RenderPass
const Ra::Engine::Scene::LightManager* m_lightmanager;
/// The Environment to used for envmap lighting
- std::shared_ptr<EnvMap> m_envmap{ nullptr };
+ std::shared_ptr<EnvMap> m_envmap{nullptr};
};
} // namespace RadiumNBR
diff --git a/src/libRender/RadiumNBR/Passes/WireframePass.cpp b/src/libRender/RadiumNBR/Passes/WireframePass.cpp
index ce32ad5c9928bd4f8aa56f7731b8d65b88ebb8f4..295ccb0dd0150aa0177fce81b174b6b239eecfbf 100644
--- a/src/libRender/RadiumNBR/Passes/WireframePass.cpp
+++ b/src/libRender/RadiumNBR/Passes/WireframePass.cpp
@@ -14,24 +14,24 @@ using namespace Ra::Core::Utils; // log
#include <globjects/Framebuffer.h>
#ifdef ADVANCED_WIREFRAME
-#include <Engine/Data/Mesh.hpp>
-#include <Engine/Data/ViewingParameters.hpp>
+# include <Engine/Data/Mesh.hpp>
+# include <Engine/Data/ViewingParameters.hpp>
#endif
namespace RadiumNBR {
using namespace gl;
-static const GLenum buffers[] = { GL_COLOR_ATTACHMENT0 };
+static const GLenum buffers[] = {GL_COLOR_ATTACHMENT0};
WireframePass::WireframePass( const std::vector<RenderObjectPtr>* objectsToRender,
- const Ra::Core::Utils::Index& idx ) :
+ const Ra::Core::Utils::Index& idx ) :
RenderPass( "Wireframe pass", idx, objectsToRender ) {}
WireframePass::~WireframePass() = default;
bool WireframePass::initializePass( size_t /* width */,
- size_t /* height */,
- Ra::Engine::Data::ShaderProgramManager* shaderMngr ) {
+ size_t /* height */,
+ Ra::Engine::Data::ShaderProgramManager* shaderMngr ) {
m_shaderMngr = shaderMngr;
m_fbo = std::make_unique<globjects::Framebuffer>();
@@ -39,7 +39,7 @@ bool WireframePass::initializePass( size_t /* width */,
}
void WireframePass::setInputs( const SharedTextures& depthBuffer ) {
- addImportedTextures( { "WireframePass::Depth", depthBuffer.second } );
+ addImportedTextures( {"WireframePass::Depth", depthBuffer.second} );
}
void WireframePass::setOutput( const SharedTextures& colorBuffer ) {
@@ -90,7 +90,7 @@ bool WireframePass::update() {
if ( drawable )
{
drawable = tp->getRenderMode() ==
- Ra::Engine::Data::AttribArrayDisplayable::MeshRenderMode::RM_TRIANGLES;
+ Ra::Engine::Data::AttribArrayDisplayable::MeshRenderMode::RM_TRIANGLES;
lines.setVertices( tp->getCoreGeometry().vertices() );
for ( const auto& index : tp->getCoreGeometry().getIndices() )
{
@@ -118,14 +118,14 @@ bool WireframePass::update() {
lines.setIndices( std::move( indices ) );
disp = std::make_shared<Ra::Engine::Data::LineMesh>( std::string( "wireframe" ),
- std::move( lines ) );
+ std::move( lines ) );
disp->updateGL();
m_wireframes[ro.get()] = disp;
}
else
{
disp.reset();
- m_wireframes[ro.get()] = { nullptr };
+ m_wireframes[ro.get()] = {nullptr};
}
}
#endif
@@ -134,7 +134,7 @@ bool WireframePass::update() {
void WireframePass::resize( size_t width, size_t height ) {
#ifdef ADVANCED_WIREFRAME
- m_width = width;
+ m_width = width;
m_height = height;
#endif
// Only resize the owned textures. Imported one are resized by their owner
@@ -149,7 +149,8 @@ void WireframePass::resize( size_t width, size_t height ) {
}
m_fbo->bind();
- m_fbo->attachTexture( GL_DEPTH_ATTACHMENT, m_importedTextures["WireframePass::Depth"]->texture() );
+ m_fbo->attachTexture( GL_DEPTH_ATTACHMENT,
+ m_importedTextures["WireframePass::Depth"]->texture() );
m_fbo->attachTexture( GL_COLOR_ATTACHMENT0, m_outputTexture.second->texture() );
#ifdef PASSES_LOG
if ( m_fbo->checkStatus() != GL_FRAMEBUFFER_COMPLETE )
@@ -185,26 +186,31 @@ void WireframePass::execute( const Ra::Engine::Data::ViewingParameters& viewPara
for ( const auto& ro : *m_objectsToRender )
{
+ if ( ro->isVisible() )
+ {
#ifdef ADVANCED_WIREFRAME
- auto it = m_wireframes.find( ro.get() );
- if ( it != m_wireframes.end() ) {
- auto wro = it->second;
- auto shader = m_shaderMngr->getShaderProgram( "WireframePass::WireframeProgram" );
- if ( wro && shader ) {
- shader->bind();
- Ra::Core::Matrix4 modelMatrix = ro->getTransformAsMatrix();
- shader->setUniform( "transform.proj", viewParams.projMatrix );
- shader->setUniform( "transform.view", viewParams.viewMatrix );
- shader->setUniform( "transform.model", modelMatrix );
- shader->setUniform( "viewport", Ra::Core::Vector2 {m_width, m_height} );
- wro->render( shader );
- GL_CHECK_ERROR;
+ auto it = m_wireframes.find( ro.get() );
+ if ( it != m_wireframes.end() )
+ {
+ auto wro = it->second;
+ auto shader = m_shaderMngr->getShaderProgram( "WireframePass::WireframeProgram" );
+ if ( wro && shader )
+ {
+ shader->bind();
+ Ra::Core::Matrix4 modelMatrix = ro->getTransformAsMatrix();
+ shader->setUniform( "transform.proj", viewParams.projMatrix );
+ shader->setUniform( "transform.view", viewParams.viewMatrix );
+ shader->setUniform( "transform.model", modelMatrix );
+ shader->setUniform( "viewport", Ra::Core::Vector2{m_width, m_height} );
+ wro->render( shader );
+ GL_CHECK_ERROR;
+ }
}
- }
#else
- ro->render( m_passParams, viewParams, passIndex() );
+ ro->render( m_passParams, viewParams, passIndex() );
#endif
+ }
}
#ifdef ADVANCED_WIREFRAME_SHADER
// need to maintain global state invariant
@@ -218,30 +224,31 @@ void WireframePass::execute( const Ra::Engine::Data::ViewingParameters& viewPara
}
bool WireframePass::buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
- Ra::Engine::Rendering::RenderTechnique& rt ) {
+ Ra::Engine::Rendering::RenderTechnique& rt ) const {
std::string resourcesRootDir = getResourcesDir();
auto mat = const_cast<Ra::Engine::Rendering::RenderObject*>( ro )->getMaterial();
// Volumes are not used in WireframePass
if ( mat->getMaterialAspect() == Ra::Engine::Data::Material::MaterialAspect::MAT_DENSITY )
{ return false; }
if ( auto cfg = Ra::Engine::Data::ShaderConfigurationFactory::getConfiguration(
- { "WireframePass::WireframeProgram" } ) )
+ {"WireframePass::WireframeProgram"} ) )
{ rt.setConfiguration( *cfg, passIndex() ); }
else
{
#ifdef ADVANCED_WIREFRAME_SHADER
Ra::Engine::Data::ShaderConfiguration theConfig{
- { "WireframePass::WireframeProgram" },
+ {"WireframePass::WireframeProgram"},
resourcesRootDir + "Shaders/WireframePass/Advanced/wireframe.vert.glsl",
- resourcesRootDir + "Shaders/WireframePass/Advanced/wireframe.frag.glsl" };
- theConfig.addShader(Ra::Engine::Data::ShaderType_GEOMETRY,
- resourcesRootDir + "Shaders/WireframePass/Advanced/wireframe.geom.glsl");
+ resourcesRootDir + "Shaders/WireframePass/Advanced/wireframe.frag.glsl"};
+ theConfig.addShader( Ra::Engine::Data::ShaderType_GEOMETRY,
+ resourcesRootDir +
+ "Shaders/WireframePass/Advanced/wireframe.geom.glsl" );
#else
// Build the shader configuration
Ra::Engine::Data::ShaderConfiguration theConfig{
- { "WireframePass::WireframeProgram" },
+ {"WireframePass::WireframeProgram"},
resourcesRootDir + "Shaders/WireframePass/Basic/wireframepass.vert.glsl",
- resourcesRootDir + "Shaders/WireframePass/Basic/wireframepass.frag.glsl" };
+ resourcesRootDir + "Shaders/WireframePass/Basic/wireframepass.frag.glsl"};
#endif
// Add to the ShaderConfigManager
Ra::Engine::Data::ShaderConfigurationFactory::addConfiguration( theConfig );
diff --git a/src/libRender/RadiumNBR/Passes/WireframePass.hpp b/src/libRender/RadiumNBR/Passes/WireframePass.hpp
index df0ca9b46e03c563e606f405ac9eee7a7a45b714..919b6fa852061b30c8e744b0134d03d34e14cd44 100644
--- a/src/libRender/RadiumNBR/Passes/WireframePass.hpp
+++ b/src/libRender/RadiumNBR/Passes/WireframePass.hpp
@@ -7,7 +7,7 @@
#define ADVANCED_WIREFRAME
#define ADVANCED_WIREFRAME_SHADER
#ifdef ADVANCED_WIREFRAME
-#include <Engine/Data/DisplayableObject.hpp>
+# include <Engine/Data/DisplayableObject.hpp>
#endif
namespace Ra::Engine::Data {
@@ -24,11 +24,11 @@ class WireframePass : public RenderPass
{
public:
WireframePass( const std::vector<RenderObjectPtr>* objectsToRender,
- const Ra::Core::Utils::Index& idx );
+ const Ra::Core::Utils::Index& idx );
~WireframePass() override;
bool buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
- Ra::Engine::Rendering::RenderTechnique& rt ) override;
+ Ra::Engine::Rendering::RenderTechnique& rt ) const override;
bool initializePass( size_t width,
size_t height,
Ra::Engine::Data::ShaderProgramManager* shaderMngr ) override;
@@ -44,22 +44,23 @@ class WireframePass : public RenderPass
private:
/// The framebuffer used to render this pass
- std::unique_ptr<globjects::Framebuffer> m_fbo{ nullptr };
+ std::unique_ptr<globjects::Framebuffer> m_fbo{nullptr};
/// The Shader manager to use when building shaders
- Ra::Engine::Data::ShaderProgramManager* m_shaderMngr{ nullptr };
+ Ra::Engine::Data::ShaderProgramManager* m_shaderMngr{nullptr};
/// The color texture for output.Stored here for easy access.
SharedTextures m_outputTexture;
#ifdef ADVANCED_WIREFRAME
- using WireMap = std::map<Ra::Engine::Rendering::RenderObject*, std::shared_ptr<Ra::Engine::Data::Displayable>>;
+ using WireMap = std::map<Ra::Engine::Rendering::RenderObject*,
+ std::shared_ptr<Ra::Engine::Data::Displayable>>;
WireMap m_wireframes;
- bool m_wireframeAa {true};
- Ra::Core::Utils::Color m_wireframeColor {Ra::Core::Utils::Color::White()};
+ bool m_wireframeAa{true};
+ Ra::Core::Utils::Color m_wireframeColor{Ra::Core::Utils::Color::White()};
- uint m_width {0};
- uint m_height {0};
+ uint m_width{0};
+ uint m_height{0};
#endif
};
} // namespace RadiumNBR
diff --git a/src/libRender/RadiumNBR/RenderPass.hpp b/src/libRender/RadiumNBR/RenderPass.hpp
index 8e07a08cb629bbe1cecf9df455ba045ca3d9c63a..b83d286cb133d4acf6f310fd759a5c44c7638b0a 100644
--- a/src/libRender/RadiumNBR/RenderPass.hpp
+++ b/src/libRender/RadiumNBR/RenderPass.hpp
@@ -27,6 +27,8 @@ namespace RadiumNBR {
/// @todo Define a protected interface to access and manipulate common attributes. For now,
/// protected attributes are used but this is a bad design (@see
/// https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c133-avoid-protected-data)
+/// @todo as RenderTechnique has a predefined maximum number of passes, ensure that there will not
+/// be more passes than this limit (32 as defined in RenterTechnique.hpp)
class NodeBasedRenderer_LIBRARY_API RenderPass
{
protected:
@@ -42,7 +44,7 @@ class NodeBasedRenderer_LIBRARY_API RenderPass
RenderPass( std::string name,
const Ra::Core::Utils::Index& idx,
const std::vector<RenderObjectPtr>* objectsToRender ) :
- m_objectsToRender{ objectsToRender }, m_passName{ std::move( name ) }, m_idx{ idx } {}
+ m_objectsToRender{objectsToRender}, m_passName{std::move( name )}, m_idx{idx} {}
RenderPass( const RenderPass& ) = delete;
RenderPass& operator=( const RenderPass& ) = delete;
RenderPass( RenderPass&& ) = delete;
@@ -81,7 +83,7 @@ class NodeBasedRenderer_LIBRARY_API RenderPass
/// Fill the RenderTechnique to be associated with the renderObject.
virtual bool buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
- Ra::Engine::Rendering::RenderTechnique& rt ) = 0;
+ Ra::Engine::Rendering::RenderTechnique& rt ) const = 0;
/// Update, if needed, the set of shaders and resources used for this pass.
/// WARNING : this method is called once per frame on all passes. Keep it efficient
@@ -124,7 +126,7 @@ class NodeBasedRenderer_LIBRARY_API RenderPass
// is the pass active ?
[[nodiscard]] inline bool isActive() { return m_active; }
- [[nodiscard]] inline int index() const { return int(m_idx); }
+ [[nodiscard]] inline int index() const { return int( m_idx ); }
/// @todo : Having protected member is a bad idea
/// @see https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c133-avoid-protected-data
@@ -152,7 +154,7 @@ class NodeBasedRenderer_LIBRARY_API RenderPass
const Ra::Core::Utils::Index m_idx;
/// The base resources directory
- std::string resourceDir{ "./" };
+ std::string resourceDir{"./"};
bool m_active{false};
};
diff --git a/src/libRender/RadiumNBR/SphereSampler.hpp b/src/libRender/RadiumNBR/SphereSampler.hpp
index 4d4221df62fd0c90f6798bb4704565fbf2947165..aa07fa63956cf630aacf2794eff84fc4246c1b76 100644
--- a/src/libRender/RadiumNBR/SphereSampler.hpp
+++ b/src/libRender/RadiumNBR/SphereSampler.hpp
@@ -18,7 +18,7 @@ class NodeBasedRenderer_LIBRARY_API FibonacciSequence
int n;
public:
- explicit FibonacciSequence( int number ) : n{ std::max( 5, number ) } {};
+ explicit FibonacciSequence( int number ) : n{std::max( 5, number )} {};
// copyable
FibonacciSequence( const FibonacciSequence& ) = default;
FibonacciSequence& operator=( const FibonacciSequence& ) = default;
@@ -62,7 +62,7 @@ class NodeBasedRenderer_LIBRARY_API FibonacciPointSet
int range() { return seq.range(); }
Ra::Core::Vector2 operator()( unsigned int i ) {
- return { seq( i ), Scalar( i ) / Scalar( range() ) };
+ return {seq( i ), Scalar( i ) / Scalar( range() )};
}
};
@@ -84,7 +84,7 @@ class NodeBasedRenderer_LIBRARY_API HammersleyPointSet
int range() { return n; }
Ra::Core::Vector2 operator()( unsigned int i ) {
- return { Scalar( i ) / Scalar( range() ), seq( i ) };
+ return {Scalar( i ) / Scalar( range() ), seq( i )};
}
};
@@ -106,7 +106,7 @@ class NodeBasedRenderer_LIBRARY_API MersenneTwisterPointSet
virtual ~MersenneTwisterPointSet() = default;
int range() { return n; }
- Ra::Core::Vector2 operator()( unsigned int i ) { return { seq( gen ), seq( gen ) }; }
+ Ra::Core::Vector2 operator()( unsigned int i ) { return {seq( gen ), seq( gen )}; }
};
// https://observablehq.com/@mbostock/spherical-fibonacci-lattice
@@ -119,9 +119,9 @@ class NodeBasedRenderer_LIBRARY_API SphericalPointSet
Ra::Core::Vector3 projectOnSphere( const Ra::Core::Vector2&& pt ) {
Scalar theta = std::acos( 2 * pt[1] - 1 ); // 0 <= tetha <= pi
Scalar phi = 2_ra * Scalar( M_PI ) * pt[0];
- return { std::sin( theta ) * std::cos( phi ),
- std::sin( theta ) * std::sin( phi ),
- std::cos( theta ) };
+ return {std::sin( theta ) * std::cos( phi ),
+ std::sin( theta ) * std::sin( phi ),
+ std::cos( theta )};
}
public:
@@ -168,7 +168,7 @@ class NodeBasedRenderer_LIBRARY_API SphereSampler
private:
/// Texture generated on demand to be used with an OpenGL shader
- std::unique_ptr<Ra::Engine::Data::Texture> m_texture{ nullptr };
+ std::unique_ptr<Ra::Engine::Data::Texture> m_texture{nullptr};
/// Final number of points
int m_nbPoints;
/// The points on the sphere