OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-03 17:56:21 +03:00
Code Packages Releases Activity

0027974: Visualization, ray tracing - Improve ray tracing engine

Browse Source 
* Multiple importance sampling for path tracing
* Improved light sources sampling (better handling several light sources)
* Fixed issues in light source intersection (light distance is taken into account)
* Add new TCL sample - OCCT Ball model for demonstrating physically-based materials
* Fix potential issue on NVIDIA GPUs ("Error: Failed to upload light source buffer")
* Path tracing materials reviewed; directional light source was smoother by default
This commit is contained in:
dbp 2016-10-20 12:10:47 +03:00 committed by apn
parent 0d0481c787
commit 6e728f3b5c
19 changed files with 2186 additions and 747 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1131
data/occ/Ball.brep Normal file
View File

File diff suppressed because one or more lines are too long

78
samples/tcl/pathtrace_ball.tcl Normal file
View File

@ -0,0 +1,78 @@
# Script demonstrating Global illumination materials
# using path tracing rendering engine in 3D view
#Category: Visualization
#Title: Path tracing - Ball
set aBallPath [locate_data_file occ/Ball.brep]
pload MODELING VISUALIZATION
# Setup 3D viewer
vclear
vinit name=View1 w=512 h=512
vglinfo
vvbo 0
vsetdispmode 1
# Setup view parameters
vcamera -persp
vviewparams -scale 18 -eye 44.49 -0.15 33.93 -at -14.20 -0.15 1.87 -up -0.48 0.00 0.88
# Load the model from disk
puts "Importing shape..."
restore $aBallPath ball
# Tessellate the model
incmesh ball 0.01
# Display the model and assign material
vdisplay -noupdate ball
vsetmaterial -noupdate ball glass
# Create a sphere inside the model
psphere s 8
incmesh s 0.01
vdisplay -noupdate s
vsetlocation -noupdate s 0 0 13
vsetmaterial -noupdate s plaster
# Create chessboard-style floor
box tile 10 10 0.1
eval compound [lrepeat 144 tile] tiles
explode tiles
for {set i 0} {$i < 12} {incr i} {
for {set j 1} {$j <= 12} {incr j} {
ttranslate tiles_[expr 12 * $i + $j] [expr $i * 10 - 90] [expr $j * 10 - 70] -0.15
vdisplay -noupdate tiles_[expr 12 * $i + $j]
vsetmaterial -noupdate tiles_[expr 12 * $i + $j] plaster
if {($i + $j) % 2 == 0} {
vbsdf tiles_[expr 12 * $i + $j] -kd 0.85
} else {
vbsdf tiles_[expr 12 * $i + $j] -kd 0.45
}
}
}
# Configure light sources
vlight del 1
vlight change 0 head 0
vlight change 0 direction -0.25 -1 -1
vlight change 0 sm 0.3
vlight change 0 int 10
# Load environment map
vtextureenv on 1
puts "Trying path tracing mode..."
vrenderparams -ray -gi -rayDepth 10
# Start progressive refinement mode
#vprogressive
puts "Make several path tracing iterations to refine the picture, please wait..."
vfps 100
puts "Done. To improve the image further, or after view manipulations, give command:"
puts "vfps \[nb_iteratons\]"

53
samples/tcl/pathtrace.tcl → samples/tcl/pathtrace_cube.tcl
View File

@ -2,11 +2,12 @@
# path tracing rendering engine in 3d view # path tracing rendering engine in 3d view
#Category: Visualization #Category: Visualization
#Title: Path tracing #Title: Path tracing - Cube
pload MODELING VISUALIZATION pload MODELING VISUALIZATION
# setup 3D viewer content # setup 3D viewer content
vclear
vinit name=View1 w=512 h=512 vinit name=View1 w=512 h=512
vglinfo vglinfo
@ -24,18 +25,18 @@ vcamera -persp
# setup outer box # setup outer box
box b 1 1 1 box b 1 1 1
explode b FACE explode b FACE
vdisplay b_1 b_2 b_3 b_5 b_6 vdisplay -noupdate b_1 b_2 b_3 b_5 b_6
vsetlocation b_1 1 0 0 vlocation -noupdate b_1 -setLocation 1 0 0
vsetlocation b_2 -1 0 0 vlocation -noupdate b_2 -setLocation -1 0 0
vsetlocation b_3 0 1 0 vlocation -noupdate b_3 -setLocation 0 1 0
vsetlocation b_5 0 0 1 vlocation -noupdate b_5 -setLocation 0 0 1
vsetlocation b_6 0 0 -1 vlocation -noupdate b_6 -setLocation 0 0 -1
vsetmaterial b_1 plastic vsetmaterial -noupdate b_1 plastic
vsetmaterial b_2 plastic vsetmaterial -noupdate b_2 plastic
vsetmaterial b_3 plastic vsetmaterial -noupdate b_3 plastic
vsetmaterial b_5 plastic vsetmaterial -noupdate b_5 plastic
vsetmaterial b_6 plastic vsetmaterial -noupdate b_6 plastic
vbsdf b_1 -kd 1 0.3 0.3 -ks 0 vbsdf b_1 -kd 1 0.3 0.3 -ks 0
vbsdf b_2 -kd 0.3 0.5 1 -ks 0 vbsdf b_2 -kd 0.3 0.5 1 -ks 0
vbsdf b_3 -kd 1 -ks 0 vbsdf b_3 -kd 1 -ks 0
@ -47,36 +48,36 @@ vfit
# setup first inner sphere # setup first inner sphere
psphere s 0.2 psphere s 0.2
vdisplay s vdisplay -noupdate s
vsetlocation s 0.21 0.3 0.2 vlocation -noupdate s -setLocation 0.21 0.3 0.2
vsetmaterial s glass vsetmaterial -noupdate s glass
vbsdf s -absorpcolor 0.8 0.8 1.0 vbsdf s -absorpcolor 0.8 0.8 1.0
vbsdf s -absorpcoeff 6 vbsdf s -absorpcoeff 6
# setup first inner box # setup first inner box
box c 0.3 0.3 0.2 box c 0.3 0.3 0.2
vdisplay c vdisplay -noupdate c
vsetlocation c 0.55 0.3 0.0 vlocation -noupdate c -setLocation 0.55 0.3 0.0
vlocrotate c 0 0 0 0 0 1 -30 vlocation -noupdate c -rotate 0 0 0 0 0 1 -30
vsetmaterial c plastic vsetmaterial -noupdate c plastic
vbsdf c -kd 1.0 0.8 0.2 -ks 0.3 -n vbsdf c -kd 1.0 0.8 0.2 -ks 0.3 -n
# setup second inner box # setup second inner box
box g 0.15 0.15 0.3 box g 0.15 0.15 0.3
vdisplay g vdisplay -noupdate g
vsetlocation g 0.7 0.25 0.2 vlocation -noupdate g -setLocation 0.7 0.25 0.2
vlocrotate g 0 0 0 0 0 1 10 vlocation -noupdate g -rotate 0 0 0 0 0 1 10
vsetmaterial g glass vsetmaterial -noupdate g glass
vbsdf g -absorpcolor 0.8 1.0 0.8 vbsdf g -absorpcolor 0.8 1.0 0.8
vbsdf g -absorpcoeff 6 vbsdf g -absorpcoeff 6
# setup second inner sphere # setup second inner sphere
psphere r 0.1 psphere r 0.1
vdisplay r vdisplay -noupdate r
vsetmaterial r plastic vsetmaterial -noupdate r plastic
vbsdf r -kd 0.5 0.9 0.3 -ks 0.0 -kr 0.3 -n vbsdf r -kd 0.5 0.9 0.3 -ks 0.0 -kr 0.3 -n
vbsdf r -fresnel Constant 1.0 vbsdf r -fresnel Constant 1.0
vsetlocation r 0.5 0.65 0.1 vlocation r -setLocation 0.5 0.65 0.1
puts "Trying path tracing mode..." puts "Trying path tracing mode..."
vrenderparams -ray -gi -rayDepth 8 vrenderparams -ray -gi -rayDepth 8

10
src/Graphic3d/Graphic3d_BSDF.hxx
View File

@ -82,6 +82,12 @@ public:
&& myFresnelData == theOther.myFresnelData; && myFresnelData == theOther.myFresnelData;
} }
//! Returns type of Fresnel.
Graphic3d_FresnelModel FresnelType() const
{
return myFresnelType;
}
protected: protected:
//! Creates new Fresnel reflectance factor. //! Creates new Fresnel reflectance factor.
@ -164,9 +170,9 @@ public:
public: public:
//! Creates uninitialized BSDF. //! Creates uninitialized BSDF.
Graphic3d_BSDF() Graphic3d_BSDF() : Roughness (1.f), AbsorptionCoeff (0.f)
{ {
Roughness = AbsorptionCoeff = 0.f; Fresnel = Graphic3d_Fresnel::CreateConstant (1.f);
} }
//! Normalizes BSDF components. //! Normalizes BSDF components.

86
src/Graphic3d/Graphic3d_MaterialAspect.cxx
View File

@ -66,7 +66,7 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
mySpecularColor.SetValues (1.0, 1.0, 1.0, Quantity_TOC_RGB); mySpecularColor.SetValues (1.0, 1.0, 1.0, Quantity_TOC_RGB);
myMaterialName = theName; myMaterialName = theName;
myBSDF = Graphic3d_BSDF::CreateDiffuse (Graphic3d_Vec3 (0.2f, 0.2f, 0.2f)); myBSDF = Graphic3d_BSDF::CreateDiffuse (Graphic3d_Vec3 (0.0f));
Standard_Integer index = Standard_Integer (theName); Standard_Integer index = Standard_Integer (theName);
if (index < NumberOfMaterials()) if (index < NumberOfMaterials())
@ -87,7 +87,7 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
static_cast<Standard_ShortReal> (myDiffuseColor.Blue())); static_cast<Standard_ShortReal> (myDiffuseColor.Blue()));
myBSDF.Ks = Graphic3d_Vec3 (0.00784314f, 0.00784314f, 0.00784314f); myBSDF.Ks = Graphic3d_Vec3 (0.00784314f, 0.00784314f, 0.00784314f);
myBSDF.Normalize(); myBSDF.Normalize();
myBSDF.Roughness = 32; myBSDF.Roughness = 0.25f;
break; break;
case Graphic3d_NOM_SHINY_PLASTIC: case Graphic3d_NOM_SHINY_PLASTIC:
myShininess = Standard_ShortReal (1.0); myShininess = Standard_ShortReal (1.0);
@ -98,9 +98,9 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
myBSDF.Kd = Graphic3d_Vec3 (static_cast<Standard_ShortReal> (myDiffuseColor.Red()), myBSDF.Kd = Graphic3d_Vec3 (static_cast<Standard_ShortReal> (myDiffuseColor.Red()),
static_cast<Standard_ShortReal> (myDiffuseColor.Green()), static_cast<Standard_ShortReal> (myDiffuseColor.Green()),
static_cast<Standard_ShortReal> (myDiffuseColor.Blue())); static_cast<Standard_ShortReal> (myDiffuseColor.Blue()));
myBSDF.Ks = Graphic3d_Vec3 (0.0156863f, 0.0156863f, 0.0156863f); myBSDF.Ks = Graphic3d_Vec3 (0.145f, 0.145f, 0.145f);
myBSDF.Normalize(); myBSDF.Normalize();
myBSDF.Roughness = 64.f; myBSDF.Roughness = 0.17f;
break; break;
case Graphic3d_NOM_SATIN : case Graphic3d_NOM_SATIN :
myShininess = Standard_ShortReal (0.09375); myShininess = Standard_ShortReal (0.09375);
@ -108,12 +108,10 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
myDiffuseCoef = Standard_ShortReal (0.4); myDiffuseCoef = Standard_ShortReal (0.4);
mySpecularCoef = Standard_ShortReal (0.44); mySpecularCoef = Standard_ShortReal (0.44);
myBSDF.Kd = Graphic3d_Vec3 (static_cast<Standard_ShortReal> (myDiffuseColor.Red()), myBSDF.Kd = Graphic3d_Vec3 (0.2f);
static_cast<Standard_ShortReal> (myDiffuseColor.Green()), myBSDF.Ks = Graphic3d_Vec3 (0.6f);
static_cast<Standard_ShortReal> (myDiffuseColor.Blue())); myBSDF.Roughness = 0.6f;
myBSDF.Ks = Graphic3d_Vec3 (0.0313726f, 0.0313726f, 0.0313726f);
myBSDF.Roughness = 16.f;
myBSDF.Normalize();
break; break;
case Graphic3d_NOM_NEON_GNC: case Graphic3d_NOM_NEON_GNC:
myShininess = Standard_ShortReal (0.05); myShininess = Standard_ShortReal (0.05);
@ -124,11 +122,12 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
myEmissiveActivity = Standard_True; myEmissiveActivity = Standard_True;
myAmbientActivity = Standard_False; myAmbientActivity = Standard_False;
myBSDF.Kr = Graphic3d_Vec3 (0.207843f, 0.207843f, 0.207843f); myBSDF.Kd = Graphic3d_Vec3 (0.0f);
myBSDF.Kr = Graphic3d_Vec3 (0.5f);
myBSDF.Le = Graphic3d_Vec3 (static_cast<Standard_ShortReal> (myDiffuseColor.Red()), myBSDF.Le = Graphic3d_Vec3 (static_cast<Standard_ShortReal> (myDiffuseColor.Red()),
static_cast<Standard_ShortReal> (myDiffuseColor.Green()), static_cast<Standard_ShortReal> (myDiffuseColor.Green()),
static_cast<Standard_ShortReal> (myDiffuseColor.Blue())); static_cast<Standard_ShortReal> (myDiffuseColor.Blue()));
myBSDF.Fresnel = Graphic3d_Fresnel::CreateSchlick (Graphic3d_Vec3 (0.3f, 0.3f, 0.3f)); myBSDF.Fresnel = Graphic3d_Fresnel::CreateDielectric (1.5f);
break; break;
case Graphic3d_NOM_METALIZED: case Graphic3d_NOM_METALIZED:
myShininess = Standard_ShortReal (0.13); myShininess = Standard_ShortReal (0.13);
@ -143,7 +142,7 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
static_cast<Standard_ShortReal> (myDiffuseColor.Blue())); static_cast<Standard_ShortReal> (myDiffuseColor.Blue()));
myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f), myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f),
Graphic3d_Fresnel::CreateSchlick (aColor), 1024.f); Graphic3d_Fresnel::CreateSchlick (aColor), 0.045f);
} }
break; break;
// Ascending Compatibility physical materials. The same definition is taken as in the next constructor. // Ascending Compatibility physical materials. The same definition is taken as in the next constructor.
@ -156,7 +155,7 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
mySpecularCoef = 1.00f; mySpecularCoef = 1.00f;
myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f), myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f),
Graphic3d_Fresnel::CreateSchlick (Graphic3d_Vec3 (0.58f, 0.42f, 0.20f)), 1024.f); Graphic3d_Fresnel::CreateSchlick (Graphic3d_Vec3 (0.58f, 0.42f, 0.20f)), 0.045f);
// Color resulting from ambient // Color resulting from ambient
myAmbientColor .SetValues (0.329f, 0.224f, 0.027f, Quantity_TOC_RGB); myAmbientColor .SetValues (0.329f, 0.224f, 0.027f, Quantity_TOC_RGB);
@ -174,7 +173,7 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
mySpecularCoef = 1.00f; mySpecularCoef = 1.00f;
myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f), myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f),
Graphic3d_Fresnel::CreateSchlick (Graphic3d_Vec3 (0.65f, 0.35f, 0.15f)), 1024.f); Graphic3d_Fresnel::CreateSchlick (Graphic3d_Vec3 (0.65f, 0.35f, 0.15f)), 0.045f);
// Color resulting from ambient // Color resulting from ambient
myAmbientColor .SetValues (0.213f, 0.128f, 0.054f, Quantity_TOC_RGB); myAmbientColor .SetValues (0.213f, 0.128f, 0.054f, Quantity_TOC_RGB);
@ -192,7 +191,7 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
mySpecularCoef = 1.00f; mySpecularCoef = 1.00f;
myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f), myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f),
Graphic3d_Fresnel::CreateSchlick (Graphic3d_Vec3 (0.955008f, 0.637427f, 0.538163f)), 1024.f); Graphic3d_Fresnel::CreateSchlick (Graphic3d_Vec3 (0.955008f, 0.637427f, 0.538163f)), 0.045f);
// Color resulting from ambient // Color resulting from ambient
myAmbientColor .SetValues (0.191f, 0.074f, 0.023f, Quantity_TOC_RGB); myAmbientColor .SetValues (0.191f, 0.074f, 0.023f, Quantity_TOC_RGB);
@ -210,7 +209,7 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
mySpecularCoef = 1.00f; mySpecularCoef = 1.00f;
myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f), myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f),
Graphic3d_Fresnel::CreateSchlick (Graphic3d_Vec3 (1.000000f, 0.765557f, 0.336057f)), 1024.f); Graphic3d_Fresnel::CreateSchlick (Graphic3d_Vec3 (1.000000f, 0.765557f, 0.336057f)), 0.045f);
// Color resulting from ambient // Color resulting from ambient
myAmbientColor .SetValues (0.300f, 0.230f, 0.095f, Quantity_TOC_RGB); myAmbientColor .SetValues (0.300f, 0.230f, 0.095f, Quantity_TOC_RGB);
@ -228,7 +227,7 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
mySpecularCoef = 1.00f; mySpecularCoef = 1.00f;
myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f), myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f),
Graphic3d_Fresnel::CreateConductor (1.8800f, 3.4900f), 1024.f); Graphic3d_Fresnel::CreateConductor (1.8800f, 3.4900f), 0.045f);
// Color resulting from ambient // Color resulting from ambient
myAmbientColor .SetValues (0.106f, 0.059f, 0.114f, Quantity_TOC_RGB); myAmbientColor .SetValues (0.106f, 0.059f, 0.114f, Quantity_TOC_RGB);
@ -262,7 +261,7 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
mySpecularCoef = 1.00f; mySpecularCoef = 1.00f;
myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f), myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f),
Graphic3d_Fresnel::CreateSchlick (Graphic3d_Vec3 (0.971519f, 0.959915f, 0.915324f)), 1024.f); Graphic3d_Fresnel::CreateSchlick (Graphic3d_Vec3 (0.971519f, 0.959915f, 0.915324f)), 0.045f);
// Color resulting from ambient // Color resulting from ambient
myAmbientColor .SetValues (0.275f, 0.275f, 0.250f, Quantity_TOC_RGB); myAmbientColor .SetValues (0.275f, 0.275f, 0.250f, Quantity_TOC_RGB);
@ -280,7 +279,7 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
mySpecularCoef = 1.00f; mySpecularCoef = 1.00f;
myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f), myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f),
Graphic3d_Fresnel::CreateConductor (Graphic3d_Vec3 (2.90f, 2.80f, 2.53f), Graphic3d_Vec3 (3.08f, 2.90f, 2.74f)), 1024.f); Graphic3d_Fresnel::CreateConductor (Graphic3d_Vec3 (2.90f, 2.80f, 2.53f), Graphic3d_Vec3 (3.08f, 2.90f, 2.74f)), 0.045f);
// Color resulting from ambient // Color resulting from ambient
myAmbientColor .SetValues (0.150f, 0.150f, 0.180f, Quantity_TOC_RGB); myAmbientColor .SetValues (0.150f, 0.150f, 0.180f, Quantity_TOC_RGB);
@ -318,7 +317,7 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
mySpecularCoef = 1.00f; mySpecularCoef = 1.00f;
myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f), myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f),
Graphic3d_Fresnel::CreateSchlick (Graphic3d_Vec3 (0.549585f, 0.556114f, 0.554256f)), 1024.f); Graphic3d_Fresnel::CreateSchlick (Graphic3d_Vec3 (0.549585f, 0.556114f, 0.554256f)), 0.045f);
// Color resulting from ambient // Color resulting from ambient
myAmbientColor .SetValues (0.200f, 0.200f, 0.225f, Quantity_TOC_RGB); myAmbientColor .SetValues (0.200f, 0.200f, 0.225f, Quantity_TOC_RGB);
@ -336,7 +335,7 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
mySpecularCoef = 1.00f; mySpecularCoef = 1.00f;
myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f), myBSDF = Graphic3d_BSDF::CreateMetallic (Graphic3d_Vec3 (0.985f, 0.985f, 0.985f),
Graphic3d_Fresnel::CreateSchlick (Graphic3d_Vec3 (0.913183f, 0.921494f, 0.924524f)), 1024.f); Graphic3d_Fresnel::CreateSchlick (Graphic3d_Vec3 (0.913183f, 0.921494f, 0.924524f)), 0.045f);
// Color resulting from ambient // Color resulting from ambient
myAmbientColor .SetValues (0.300f, 0.300f, 0.300f, Quantity_TOC_RGB); myAmbientColor .SetValues (0.300f, 0.300f, 0.300f, Quantity_TOC_RGB);
@ -366,9 +365,10 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
// Color resulting from specular // Color resulting from specular
myEmissiveColor.SetValues (0.0, 1.0, 0.46, Quantity_TOC_RGB); myEmissiveColor.SetValues (0.0, 1.0, 0.46, Quantity_TOC_RGB);
myBSDF.Kr = Graphic3d_Vec3 (0.207843f, 0.207843f, 0.207843f); myBSDF.Kd = Graphic3d_Vec3 (0.0f);
myBSDF.Kr = Graphic3d_Vec3 (0.5f);
myBSDF.Le = Graphic3d_Vec3 (0.0f, 1.0f, 0.46f); myBSDF.Le = Graphic3d_Vec3 (0.0f, 1.0f, 0.46f);
myBSDF.Fresnel = Graphic3d_Fresnel::CreateSchlick (Graphic3d_Vec3 (0.3f, 0.3f, 0.3f)); myBSDF.Fresnel = Graphic3d_Fresnel::CreateDielectric (1.5f);
break; break;
case Graphic3d_NOM_OBSIDIAN: case Graphic3d_NOM_OBSIDIAN:
myMaterialType = Graphic3d_MATERIAL_PHYSIC; myMaterialType = Graphic3d_MATERIAL_PHYSIC;
@ -385,9 +385,9 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
// Color resulting from specular // Color resulting from specular
mySpecularColor.SetValues (0.333f, 0.329f, 0.346f, Quantity_TOC_RGB); mySpecularColor.SetValues (0.333f, 0.329f, 0.346f, Quantity_TOC_RGB);
myBSDF.Kd = Graphic3d_Vec3 (0.0156863f, 0.f, 0.0155017f); myBSDF.Kd = Graphic3d_Vec3 (0.023f, 0.f, 0.023f);
myBSDF.Ks = Graphic3d_Vec3 (0.0156863f, 0.0156863f, 0.0156863f); myBSDF.Ks = Graphic3d_Vec3 (0.0156863f, 0.0156863f, 0.0156863f);
myBSDF.Roughness = 1024.f; myBSDF.Roughness = 0.1f;
break; break;
case Graphic3d_NOM_JADE: case Graphic3d_NOM_JADE:
myMaterialType = Graphic3d_MATERIAL_PHYSIC; myMaterialType = Graphic3d_MATERIAL_PHYSIC;
@ -407,7 +407,7 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
myBSDF.Fresnel = Graphic3d_Fresnel::CreateDielectric (1.5f); myBSDF.Fresnel = Graphic3d_Fresnel::CreateDielectric (1.5f);
myBSDF.Kd = Graphic3d_Vec3 (0.208658f, 0.415686f, 0.218401f); myBSDF.Kd = Graphic3d_Vec3 (0.208658f, 0.415686f, 0.218401f);
myBSDF.Ks = Graphic3d_Vec3 (0.611765f, 0.611765f, 0.611765f); myBSDF.Ks = Graphic3d_Vec3 (0.611765f, 0.611765f, 0.611765f);
myBSDF.Roughness = 512.f; myBSDF.Roughness = 0.06f;
break; break;
case Graphic3d_NOM_CHARCOAL: case Graphic3d_NOM_CHARCOAL:
myMaterialType = Graphic3d_MATERIAL_PHYSIC; myMaterialType = Graphic3d_MATERIAL_PHYSIC;
@ -424,9 +424,9 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
// Color resulting from specular // Color resulting from specular
mySpecularColor.SetValues (0.000f, 0.000f, 0.000f, Quantity_TOC_RGB); mySpecularColor.SetValues (0.000f, 0.000f, 0.000f, Quantity_TOC_RGB);
myBSDF.Kd = Graphic3d_Vec3 (0.0196078f, 0.0196078f, 0.0196078f); myBSDF.Kd = Graphic3d_Vec3 (0.02f, 0.02f, 0.02f);
myBSDF.Ks = Graphic3d_Vec3 (0.0196078f, 0.0196078f, 0.0196078f); myBSDF.Ks = Graphic3d_Vec3 (0.1f, 0.1f, 0.1f);
myBSDF.Roughness = 8; myBSDF.Roughness = 0.3f;
break; break;
case Graphic3d_NOM_WATER: case Graphic3d_NOM_WATER:
myMaterialType = Graphic3d_MATERIAL_PHYSIC; myMaterialType = Graphic3d_MATERIAL_PHYSIC;
@ -491,6 +491,29 @@ void Graphic3d_MaterialAspect::Init (const Graphic3d_NameOfMaterial theName)
// Color resulting from specular // Color resulting from specular
mySpecularColor.SetValues (0.970f, 0.970f, 0.970f, Quantity_TOC_RGB); mySpecularColor.SetValues (0.970f, 0.970f, 0.970f, Quantity_TOC_RGB);
break; break;
case Graphic3d_NOM_TRANSPARENT:
myMaterialType = Graphic3d_MATERIAL_PHYSIC;
myShininess = 0.90f;
myAmbientCoef = 1.00f;
myDiffuseCoef = 1.00f;
mySpecularCoef = 1.00f;
myRefractionIndex = 1.0f;
myBSDF.Kd = Graphic3d_Vec3 (0.1f);
myBSDF.Kt = Graphic3d_Vec3 (0.9f);
myBSDF.Fresnel = Graphic3d_Fresnel::CreateConstant (0.0f);
myTransparencyCoef = 0.80f;
// Color resulting from ambient
myAmbientColor.SetValues (0.550f, 0.550f, 0.550f, Quantity_TOC_RGB);
// Color resulting from dispersed
myDiffuseColor.SetValues (0.100f, 0.100f, 0.100f, Quantity_TOC_RGB);
// Color resulting from specular
mySpecularColor.SetValues (0.970f, 0.970f, 0.970f, Quantity_TOC_RGB);
break;
case Graphic3d_NOM_UserDefined: case Graphic3d_NOM_UserDefined:
myStringName = "UserDefined"; myStringName = "UserDefined";
break; break;
@ -1035,7 +1058,8 @@ namespace
{"Charcoal", Graphic3d_MATERIAL_PHYSIC}, {"Charcoal", Graphic3d_MATERIAL_PHYSIC},
{"Water", Graphic3d_MATERIAL_PHYSIC}, {"Water", Graphic3d_MATERIAL_PHYSIC},
{"Glass", Graphic3d_MATERIAL_PHYSIC}, {"Glass", Graphic3d_MATERIAL_PHYSIC},
{"Diamond", Graphic3d_MATERIAL_PHYSIC} {"Diamond", Graphic3d_MATERIAL_PHYSIC},
{"Transparent", Graphic3d_MATERIAL_PHYSIC}
}; };
} }

1
src/Graphic3d/Graphic3d_NameOfMaterial.hxx
View File

@ -43,6 +43,7 @@ Graphic3d_NOM_CHARCOAL,
Graphic3d_NOM_WATER, Graphic3d_NOM_WATER,
Graphic3d_NOM_GLASS, Graphic3d_NOM_GLASS,
Graphic3d_NOM_DIAMOND, Graphic3d_NOM_DIAMOND,
Graphic3d_NOM_TRANSPARENT,
Graphic3d_NOM_DEFAULT, Graphic3d_NOM_DEFAULT,
Graphic3d_NOM_UserDefined Graphic3d_NOM_UserDefined
}; };

6
src/OpenGl/OpenGl_SceneGeometry.cxx
View File

@ -109,9 +109,9 @@ OpenGl_RaytraceMaterial::OpenGl_RaytraceMaterial (const BVH_Vec4f& theAmbient,
// function : OpenGl_LightSource // function : OpenGl_LightSource
// purpose : Creates new light source // purpose : Creates new light source
// ======================================================================= // =======================================================================
OpenGl_RaytraceLight::OpenGl_RaytraceLight (const BVH_Vec4f& theDiffuse, OpenGl_RaytraceLight::OpenGl_RaytraceLight (const BVH_Vec4f& theEmission,
const BVH_Vec4f& thePosition) const BVH_Vec4f& thePosition)
: Diffuse (theDiffuse), : Emission (theEmission),
Position (thePosition) Position (thePosition)
{ {
// //
@ -207,7 +207,7 @@ OpenGl_TriangleSet::OpenGl_TriangleSet (const Standard_Size theArrayID)
myArrayID (theArrayID) myArrayID (theArrayID)
{ {
myBuilder = new BVH_BinnedBuilder<Standard_ShortReal, 3 /* dim */, 48 /* bins */> myBuilder = new BVH_BinnedBuilder<Standard_ShortReal, 3 /* dim */, 48 /* bins */>
(5 /* leaf size */, 32 /* max height */, Standard_False, OSD_Parallel::NbLogicalProcessors() + 1 /* threads */); (4 /* leaf size */, 32 /* max height */, Standard_False, OSD_Parallel::NbLogicalProcessors() + 1 /* threads */);
} }
// ======================================================================= // =======================================================================

7
src/OpenGl/OpenGl_SceneGeometry.hxx
View File

@ -136,7 +136,7 @@ class OpenGl_RaytraceLight
public: public:
//! Diffuse intensity (in terms of OpenGL). //! Diffuse intensity (in terms of OpenGL).
BVH_Vec4f Diffuse; BVH_Vec4f Emission;
//! Position of light source (in terms of OpenGL). //! Position of light source (in terms of OpenGL).
BVH_Vec4f Position; BVH_Vec4f Position;
@ -144,7 +144,10 @@ public:
public: public:
//! Creates new light source. //! Creates new light source.
OpenGl_RaytraceLight (const BVH_Vec4f& theDiffuse, OpenGl_RaytraceLight() { }
//! Creates new light source.
OpenGl_RaytraceLight (const BVH_Vec4f& theEmission,
const BVH_Vec4f& thePosition); const BVH_Vec4f& thePosition);
//! Returns packed (serialized) representation of light source. //! Returns packed (serialized) representation of light source.

21
src/OpenGl/OpenGl_View.hxx
View File

@ -591,17 +591,17 @@ protected: //! @name data types related to ray-tracing
//! Defines OpenGL texture samplers. //! Defines OpenGL texture samplers.
enum ShaderSamplerNames enum ShaderSamplerNames
{ {
OpenGl_RT_SceneNodeInfoTexture = 0, OpenGl_RT_EnvironmentMapTexture = 0,
OpenGl_RT_SceneMinPointTexture = 1,
OpenGl_RT_SceneMaxPointTexture = 2,
OpenGl_RT_SceneTransformTexture = 3,
OpenGl_RT_GeometryVertexTexture = 4, OpenGl_RT_SceneNodeInfoTexture = 1,
OpenGl_RT_GeometryNormalTexture = 5, OpenGl_RT_SceneMinPointTexture = 2,
OpenGl_RT_GeometryTexCrdTexture = 6, OpenGl_RT_SceneMaxPointTexture = 3,
OpenGl_RT_GeometryTriangTexture = 7, OpenGl_RT_SceneTransformTexture = 4,
OpenGl_RT_EnvironmentMapTexture = 8, OpenGl_RT_GeometryVertexTexture = 5,
OpenGl_RT_GeometryNormalTexture = 6,
OpenGl_RT_GeometryTexCrdTexture = 7,
OpenGl_RT_GeometryTriangTexture = 8,
OpenGl_RT_RaytraceMaterialTexture = 9, OpenGl_RT_RaytraceMaterialTexture = 9,
OpenGl_RT_RaytraceLightSrcTexture = 10, OpenGl_RT_RaytraceLightSrcTexture = 10,
@ -747,9 +747,6 @@ protected: //! @name methods related to ray-tracing
//! Updates 3D scene light sources for ray-tracing. //! Updates 3D scene light sources for ray-tracing.
Standard_Boolean updateRaytraceLightSources (const OpenGl_Mat4& theInvModelView, const Handle(OpenGl_Context)& theGlContext); Standard_Boolean updateRaytraceLightSources (const OpenGl_Mat4& theInvModelView, const Handle(OpenGl_Context)& theGlContext);
//! Updates environment map for ray-tracing.
Standard_Boolean updateRaytraceEnvironmentMap (const Handle(OpenGl_Context)& theGlContext);
//! Checks to see if the OpenGL structure is modified. //! Checks to see if the OpenGL structure is modified.
Standard_Boolean toUpdateStructure (const OpenGl_Structure* theStructure); Standard_Boolean toUpdateStructure (const OpenGl_Structure* theStructure);

177
src/OpenGl/OpenGl_View_Raytrace.cxx
View File

@ -42,6 +42,24 @@ namespace
{ {
static const OpenGl_Vec4 THE_WHITE_COLOR (1.0f, 1.0f, 1.0f, 1.0f); static const OpenGl_Vec4 THE_WHITE_COLOR (1.0f, 1.0f, 1.0f, 1.0f);
static const OpenGl_Vec4 THE_BLACK_COLOR (0.0f, 0.0f, 0.0f, 1.0f); static const OpenGl_Vec4 THE_BLACK_COLOR (0.0f, 0.0f, 0.0f, 1.0f);
//! Operator returning TRUE for positional light sources.
struct IsLightPositional
{
bool operator() (const OpenGl_Light& theLight)
{
return theLight.Type != Graphic3d_TOLS_DIRECTIONAL;
}
};
//! Operator returning TRUE for any non-ambient light sources.
struct IsNotAmbient
{
bool operator() (const OpenGl_Light& theLight)
{
return theLight.Type != Graphic3d_TOLS_AMBIENT;
}
};
} }
// ======================================================================= // =======================================================================
@ -1402,10 +1420,20 @@ Standard_Boolean OpenGl_View::initRaytraceResources (const Handle(OpenGl_Context
return safeFailBack ("Failed to load source into ray-tracing fragment shaders", theGlContext); return safeFailBack ("Failed to load source into ray-tracing fragment shaders", theGlContext);
} }
TCollection_AsciiString aLog;
if (!myRaytraceShader->Compile (theGlContext) if (!myRaytraceShader->Compile (theGlContext)
|| !myPostFSAAShader->Compile (theGlContext) || !myPostFSAAShader->Compile (theGlContext)
|| !myOutImageShader->Compile (theGlContext)) || !myOutImageShader->Compile (theGlContext))
{ {
#ifdef RAY_TRACE_PRINT_INFO
myRaytraceShader->FetchInfoLog (theGlContext, aLog);
if (!aLog.IsEmpty())
{
std::cout << "Failed to compile ray-tracing shader: " << aLog << "\n";
}
#endif
return safeFailBack ("Failed to compile ray-tracing fragment shaders", theGlContext); return safeFailBack ("Failed to compile ray-tracing fragment shaders", theGlContext);
} }
@ -1417,6 +1445,14 @@ Standard_Boolean OpenGl_View::initRaytraceResources (const Handle(OpenGl_Context
|| !myPostFSAAProgram->Link (theGlContext) || !myPostFSAAProgram->Link (theGlContext)
|| !myOutImageProgram->Link (theGlContext)) || !myOutImageProgram->Link (theGlContext))
{ {
#ifdef RAY_TRACE_PRINT_INFO
myRaytraceProgram->FetchInfoLog (theGlContext, aLog);
if (!aLog.IsEmpty())
{
std::cout << "Failed to compile ray-tracing shader: " << aLog << "\n";
}
#endif
return safeFailBack ("Failed to initialize vertex attributes for ray-tracing program", theGlContext); return safeFailBack ("Failed to initialize vertex attributes for ray-tracing program", theGlContext);
} }
} }
@ -1424,7 +1460,7 @@ Standard_Boolean OpenGl_View::initRaytraceResources (const Handle(OpenGl_Context
if (myRaytraceInitStatus == OpenGl_RT_NONE) if (myRaytraceInitStatus == OpenGl_RT_NONE)
{ {
myAccumFrames = 0; // reject accumulated frames myAccumFrames = 0; // accumulation should be restarted
if (!theGlContext->IsGlGreaterEqual (3, 1)) if (!theGlContext->IsGlGreaterEqual (3, 1))
{ {
@ -2266,14 +2302,31 @@ Standard_Boolean OpenGl_View::uploadRaytraceData (const Handle(OpenGl_Context)&
// ======================================================================= // =======================================================================
Standard_Boolean OpenGl_View::updateRaytraceLightSources (const OpenGl_Mat4& theInvModelView, const Handle(OpenGl_Context)& theGlContext) Standard_Boolean OpenGl_View::updateRaytraceLightSources (const OpenGl_Mat4& theInvModelView, const Handle(OpenGl_Context)& theGlContext)
{ {
myRaytraceGeometry.Sources.clear(); std::vector<OpenGl_Light> aLightSources;
myRaytraceGeometry.Ambient = BVH_Vec4f (0.0f, 0.0f, 0.0f, 0.0f); if (myShadingModel != Graphic3d_TOSM_NONE)
OpenGl_ListOfLight::Iterator aLightIter (myShadingModel == Graphic3d_TOSM_NONE ? myNoShadingLight : myLights);
for (; aLightIter.More(); aLightIter.Next())
{ {
const OpenGl_Light& aLight = aLightIter.Value(); aLightSources.assign (myLights.begin(), myLights.end());
// move positional light sources at the front of the list
std::partition (aLightSources.begin(), aLightSources.end(), IsLightPositional());
}
// get number of 'real' (not ambient) light sources
const size_t aNbLights = std::count_if (aLightSources.begin(), aLightSources.end(), IsNotAmbient());
Standard_Boolean wasUpdated = myRaytraceGeometry.Sources.size () != aNbLights;
if (wasUpdated)
{
myRaytraceGeometry.Sources.resize (aNbLights);
}
myRaytraceGeometry.Ambient = BVH_Vec4f (0.f, 0.f, 0.f, 0.f);
for (size_t aLightIdx = 0, aRealIdx = 0; aLightIdx < aLightSources.size(); ++aLightIdx)
{
const OpenGl_Light& aLight = aLightSources[aLightIdx];
if (aLight.Type == Graphic3d_TOLS_AMBIENT) if (aLight.Type == Graphic3d_TOLS_AMBIENT)
{ {
@ -2284,10 +2337,10 @@ Standard_Boolean OpenGl_View::updateRaytraceLightSources (const OpenGl_Mat4& the
continue; continue;
} }
BVH_Vec4f aDiffuse (aLight.Color.r() * aLight.Intensity, BVH_Vec4f aEmission (aLight.Color.r() * aLight.Intensity,
aLight.Color.g() * aLight.Intensity, aLight.Color.g() * aLight.Intensity,
aLight.Color.b() * aLight.Intensity, aLight.Color.b() * aLight.Intensity,
1.0f); 1.0f);
BVH_Vec4f aPosition (-aLight.Direction.x(), BVH_Vec4f aPosition (-aLight.Direction.x(),
-aLight.Direction.y(), -aLight.Direction.y(),
@ -2301,13 +2354,13 @@ Standard_Boolean OpenGl_View::updateRaytraceLightSources (const OpenGl_Mat4& the
static_cast<float>(aLight.Position.z()), static_cast<float>(aLight.Position.z()),
1.0f); 1.0f);
// store smoothing radius in w-component // store smoothing radius in W-component
aDiffuse.w() = Max (aLight.Smoothness, 0.f); aEmission.w() = Max (aLight.Smoothness, 0.f);
} }
else else
{ {
// store cosine of smoothing angle in w-component // store cosine of smoothing angle in W-component
aDiffuse.w() = cosf (Min (Max (aLight.Smoothness, 0.f), static_cast<Standard_ShortReal> (M_PI / 2.0))); aEmission.w() = cosf (Min (Max (aLight.Smoothness, 0.f), static_cast<Standard_ShortReal> (M_PI / 2.0)));
} }
if (aLight.IsHeadlight) if (aLight.IsHeadlight)
@ -2315,23 +2368,26 @@ Standard_Boolean OpenGl_View::updateRaytraceLightSources (const OpenGl_Mat4& the
aPosition = theInvModelView * aPosition; aPosition = theInvModelView * aPosition;
} }
myRaytraceGeometry.Sources.push_back (OpenGl_RaytraceLight (aDiffuse, aPosition)); for (int aK = 0; aK < 4; ++aK)
{
wasUpdated |= (aEmission[aK] != myRaytraceGeometry.Sources[aRealIdx].Emission[aK])
|| (aPosition[aK] != myRaytraceGeometry.Sources[aRealIdx].Position[aK]);
}
if (wasUpdated)
{
myRaytraceGeometry.Sources[aRealIdx] = OpenGl_RaytraceLight (aEmission, aPosition);
}
++aRealIdx;
} }
if (myRaytraceLightSrcTexture.IsNull()) // create light source buffer if (myRaytraceLightSrcTexture.IsNull()) // create light source buffer
{ {
myRaytraceLightSrcTexture = new OpenGl_TextureBufferArb; myRaytraceLightSrcTexture = new OpenGl_TextureBufferArb;
if (!myRaytraceLightSrcTexture->Create (theGlContext))
{
#ifdef RAY_TRACE_PRINT_INFO
std::cout << "Error: Failed to create light source buffer" << std::endl;
#endif
return Standard_False;
}
} }
if (myRaytraceGeometry.Sources.size() != 0) if (myRaytraceGeometry.Sources.size() != 0 && wasUpdated)
{ {
const GLfloat* aDataPtr = myRaytraceGeometry.Sources.front().Packed(); const GLfloat* aDataPtr = myRaytraceGeometry.Sources.front().Packed();
if (!myRaytraceLightSrcTexture->Init (theGlContext, 4, GLsizei (myRaytraceGeometry.Sources.size() * 2), aDataPtr)) if (!myRaytraceLightSrcTexture->Init (theGlContext, 4, GLsizei (myRaytraceGeometry.Sources.size() * 2), aDataPtr))
@ -2341,56 +2397,13 @@ Standard_Boolean OpenGl_View::updateRaytraceLightSources (const OpenGl_Mat4& the
#endif #endif
return Standard_False; return Standard_False;
} }
myAccumFrames = 0; // accumulation should be restarted
} }
return Standard_True; return Standard_True;
} }
// =======================================================================
// function : updateRaytraceEnvironmentMap
// purpose : Updates environment map for ray-tracing
// =======================================================================
Standard_Boolean OpenGl_View::updateRaytraceEnvironmentMap (const Handle(OpenGl_Context)& theGlContext)
{
Standard_Boolean aResult = Standard_True;
if (!myToUpdateEnvironmentMap)
{
return aResult;
}
Handle(OpenGl_ShaderProgram) aPrograms[] = { myRaytraceProgram,
myPostFSAAProgram };
for (Standard_Integer anIdx = 0; anIdx < 2; ++anIdx)
{
if (!aPrograms[anIdx].IsNull())
{
aResult &= theGlContext->BindProgram (aPrograms[anIdx]);
if (!myTextureEnv.IsNull())
{
myTextureEnv->Bind (theGlContext,
GL_TEXTURE0 + OpenGl_RT_EnvironmentMapTexture);
aResult &= aPrograms[anIdx]->SetUniform (theGlContext,
myUniformLocations[anIdx][OpenGl_RT_uSphereMapEnabled], 1);
}
else
{
aResult &= aPrograms[anIdx]->SetUniform (theGlContext,
myUniformLocations[anIdx][OpenGl_RT_uSphereMapEnabled], 0);
}
}
}
myToUpdateEnvironmentMap = Standard_False;
theGlContext->BindProgram (NULL);
return aResult;
}
// ======================================================================= // =======================================================================
// function : setUniformState // function : setUniformState
// purpose : Sets uniform state for the given ray-tracing shader program // purpose : Sets uniform state for the given ray-tracing shader program
@ -2461,7 +2474,7 @@ Standard_Boolean OpenGl_View::setUniformState (const Standard_Integer the
theProgram->SetUniform (theGlContext, theProgram->SetUniform (theGlContext,
myUniformLocations[theProgramId][OpenGl_RT_uLightAmbnt], myRaytraceGeometry.Ambient); myUniformLocations[theProgramId][OpenGl_RT_uLightAmbnt], myRaytraceGeometry.Ambient);
// Enable/disable run time rendering effects // Enable/disable run-time rendering effects
theProgram->SetUniform (theGlContext, theProgram->SetUniform (theGlContext,
myUniformLocations[theProgramId][OpenGl_RT_uShadowsEnabled], myRenderParams.IsShadowEnabled ? 1 : 0); myUniformLocations[theProgramId][OpenGl_RT_uShadowsEnabled], myRenderParams.IsShadowEnabled ? 1 : 0);
theProgram->SetUniform (theGlContext, theProgram->SetUniform (theGlContext,
@ -2506,6 +2519,11 @@ Standard_Boolean OpenGl_View::setUniformState (const Standard_Integer the
myUniformLocations[theProgramId][OpenGl_RT_uBackColorBot], aBackColor); myUniformLocations[theProgramId][OpenGl_RT_uBackColorBot], aBackColor);
} }
const Standard_Boolean toDisableEnvironmentMap = myTextureEnv.IsNull() || !myTextureEnv->IsValid();
theProgram->SetUniform (theGlContext,
myUniformLocations[theProgramId][OpenGl_RT_uSphereMapEnabled], toDisableEnvironmentMap ? 0 : 1);
theProgram->SetUniform (theGlContext, theProgram->SetUniform (theGlContext,
myUniformLocations[theProgramId][OpenGl_RT_uSphereMapForBack], myRenderParams.UseEnvironmentMapBackground ? 1 : 0); myUniformLocations[theProgramId][OpenGl_RT_uSphereMapForBack], myRenderParams.UseEnvironmentMapBackground ? 1 : 0);
@ -2533,6 +2551,11 @@ void OpenGl_View::bindRaytraceTextures (const Handle(OpenGl_Context)& theGlConte
#endif #endif
} }
if (!myTextureEnv.IsNull() && myTextureEnv->IsValid())
{
myTextureEnv->Bind (theGlContext, GL_TEXTURE0 + OpenGl_RT_EnvironmentMapTexture);
}
mySceneMinPointTexture->BindTexture (theGlContext, GL_TEXTURE0 + OpenGl_RT_SceneMinPointTexture); mySceneMinPointTexture->BindTexture (theGlContext, GL_TEXTURE0 + OpenGl_RT_SceneMinPointTexture);
mySceneMaxPointTexture->BindTexture (theGlContext, GL_TEXTURE0 + OpenGl_RT_SceneMaxPointTexture); mySceneMaxPointTexture->BindTexture (theGlContext, GL_TEXTURE0 + OpenGl_RT_SceneMaxPointTexture);
mySceneNodeInfoTexture->BindTexture (theGlContext, GL_TEXTURE0 + OpenGl_RT_SceneNodeInfoTexture); mySceneNodeInfoTexture->BindTexture (theGlContext, GL_TEXTURE0 + OpenGl_RT_SceneNodeInfoTexture);
@ -2731,6 +2754,11 @@ Standard_Boolean OpenGl_View::runPathtrace (const Graphic3d_Camera::Projection
{ {
Standard_Boolean aResult = Standard_True; Standard_Boolean aResult = Standard_True;
if (myToUpdateEnvironmentMap) // check whether the map was changed
{
myAccumFrames = myToUpdateEnvironmentMap = 0;
}
if (myRaytraceParameters.AdaptiveScreenSampling) if (myRaytraceParameters.AdaptiveScreenSampling)
{ {
if (myAccumFrames == 0) if (myAccumFrames == 0)
@ -2875,11 +2903,6 @@ Standard_Boolean OpenGl_View::raytrace (const Standard_Integer theSizeX,
return Standard_False; return Standard_False;
} }
if (!updateRaytraceEnvironmentMap (theGlContext))
{
return Standard_False;
}
OpenGl_Mat4 aLightSourceMatrix; OpenGl_Mat4 aLightSourceMatrix;
// Get inversed model-view matrix for transforming lights // Get inversed model-view matrix for transforming lights

660
src/Shaders/PathtraceBase.fs
View File

@ -1,3 +1,15 @@
#ifdef _MSC_VER
#define PATH_TRACING // just for editing in MS VS
#define in
#define out
#define inout
typedef struct { float x; float y; } vec2;
typedef struct { float x; float y; float z; } vec3;
typedef struct { float x; float y; float z; float w; } vec4;
#endif
#ifdef PATH_TRACING #ifdef PATH_TRACING
/////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////
@ -42,13 +54,13 @@ struct SMaterial
// Support subroutines // Support subroutines
//======================================================================= //=======================================================================
// function : LocalSpace // function : buildLocalSpace
// purpose : Generates local space for the given normal // purpose : Generates local space for the given normal
//======================================================================= //=======================================================================
SLocalSpace LocalSpace (in vec3 theNormal) SLocalSpace buildLocalSpace (in vec3 theNormal)
{ {
vec3 anAxisX = cross (vec3 (0.f, 1.f, 0.f), theNormal); vec3 anAxisX = vec3 (theNormal.z, 0.f, -theNormal.x);
vec3 anAxisY = cross (vec3 (1.f, 0.f, 0.f), theNormal); vec3 anAxisY = vec3 (0.f, -theNormal.z, theNormal.y);
float aSqrLenX = dot (anAxisX, anAxisX); float aSqrLenX = dot (anAxisX, anAxisX);
float aSqrLenY = dot (anAxisY, anAxisY); float aSqrLenY = dot (anAxisY, anAxisY);
@ -98,19 +110,6 @@ float convolve (in vec3 theVector, in vec3 theFactor)
return dot (theVector, theFactor) * (1.f / max (theFactor.x + theFactor.y + theFactor.z, 1e-15f)); return dot (theVector, theFactor) * (1.f / max (theFactor.x + theFactor.y + theFactor.z, 1e-15f));
} }
//=======================================================================
// function : sphericalDirection
// purpose : Constructs vector from spherical coordinates
//=======================================================================
vec3 sphericalDirection (in float theCosTheta, in float thePhi)
{
float aSinTheta = sqrt (1.f - theCosTheta * theCosTheta);
return vec3 (aSinTheta * cos (thePhi),
aSinTheta * sin (thePhi),
theCosTheta);
}
//======================================================================= //=======================================================================
// function : fresnelSchlick // function : fresnelSchlick
// purpose : Computes the Fresnel reflection formula using // purpose : Computes the Fresnel reflection formula using
@ -196,24 +195,24 @@ float fresnelConductor (in float theCosI, in float theEta, in float theK)
// purpose : Computes the Fresnel reflection formula for general medium // purpose : Computes the Fresnel reflection formula for general medium
// in case of circularly polarized light. // in case of circularly polarized light.
//======================================================================= //=======================================================================
vec3 fresnelMedia (in float theCosI, in vec3 theFresnelCoeffs) vec3 fresnelMedia (in float theCosI, in vec3 theFresnel)
{ {
if (theFresnelCoeffs.x > FRESNEL_SCHLICK) if (theFresnel.x > FRESNEL_SCHLICK)
{ {
return fresnelSchlick (abs (theCosI), theFresnelCoeffs); return fresnelSchlick (abs (theCosI), theFresnel);
} }
if (theFresnelCoeffs.x > FRESNEL_CONSTANT) if (theFresnel.x > FRESNEL_CONSTANT)
{ {
return vec3 (theFresnelCoeffs.z); return vec3 (theFresnel.z);
} }
if (theFresnelCoeffs.x > FRESNEL_CONDUCTOR) if (theFresnel.x > FRESNEL_CONDUCTOR)
{ {
return vec3 (fresnelConductor (abs (theCosI), theFresnelCoeffs.y, theFresnelCoeffs.z)); return vec3 (fresnelConductor (abs (theCosI), theFresnel.y, theFresnel.z));
} }
return vec3 (fresnelDielectric (theCosI, theFresnelCoeffs.y)); return vec3 (fresnelDielectric (theCosI, theFresnel.y));
} }
//======================================================================= //=======================================================================
@ -226,11 +225,11 @@ void transmitted (in float theIndex, in vec3 theIncident, out vec3 theTransmit)
// Compute relative index of refraction // Compute relative index of refraction
float anEta = (theIncident.z > 0.f) ? 1.f / theIndex : theIndex; float anEta = (theIncident.z > 0.f) ? 1.f / theIndex : theIndex;
// Handle total internal reflection for transmission // Handle total internal reflection (TIR)
float aSinT2 = anEta * anEta * (1.f - theIncident.z * theIncident.z); float aSinT2 = anEta * anEta * (1.f - theIncident.z * theIncident.z);
// Compute transmitted ray direction // Compute direction of transmitted ray
float aCosT = sqrt (1.f - min (aSinT2, 1.f)) * (theIncident.z > 0.f ? -1.f : 1.f); float aCosT = sqrt (1.f - min (aSinT2, 1.f)) * sign (-theIncident.z);
theTransmit = normalize (vec3 (-anEta * theIncident.x, theTransmit = normalize (vec3 (-anEta * theIncident.x,
-anEta * theIncident.y, -anEta * theIncident.y,
@ -242,145 +241,101 @@ void transmitted (in float theIndex, in vec3 theIncident, out vec3 theTransmit)
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
//======================================================================= //=======================================================================
// function : handleLambertianReflection // function : HandleLambertianReflection
// purpose : Handles Lambertian BRDF, with cos(N, PSI) // purpose : Handles Lambertian BRDF, with cos(N, PSI)
//======================================================================= //=======================================================================
float handleLambertianReflection (in vec3 theInput, in vec3 theOutput) float HandleLambertianReflection (in vec3 theInput, in vec3 theOutput)
{ {
return max (0.f, theInput.z) * (1.f / M_PI); return (theInput.z <= 0.f || theOutput.z <= 0.f) ? 0.f : theInput.z * (1.f / M_PI);
} }
//======================================================================= //=======================================================================
// function : handleBlinnReflection // function : SmithG1
// purpose :
//=======================================================================
float SmithG1 (in vec3 theDirection, in vec3 theM, in float theRoughness)
{
if (dot (theDirection, theM) * theDirection.z <= 0.f)
{
return 0.f;
}
float aTanThetaM = sqrt (1.f - theDirection.z * theDirection.z) / theDirection.z;
if (aTanThetaM == 0.0f)
{
return 1.f;
}
float aVal = 1.f / (theRoughness * aTanThetaM);
if (aVal >= 1.6f)
{
return 1.f;
}
// Use fast and accurate rational approximation to the
// shadowing-masking function (from Mitsuba renderer)
float aSqr = aVal * aVal;
return (3.535f * aVal + 2.181f * aSqr) / (1.f + 2.276f * aVal + 2.577f * aSqr);
}
//=======================================================================
// function : HandleBlinnReflection
// purpose : Handles Blinn glossy BRDF, with cos(N, PSI) // purpose : Handles Blinn glossy BRDF, with cos(N, PSI)
//======================================================================= //=======================================================================
vec3 handleBlinnReflection (in vec3 theInput, in vec3 theOutput, in vec3 theFresnelCoeffs, in float theExponent) vec3 HandleBlinnReflection (in vec3 theInput, in vec3 theOutput, in vec3 theFresnel, in float theRoughness)
{ {
vec3 aWeight = ZERO; // calculate the reflection half-vec
vec3 aH = normalize (theInput + theOutput);
// Compute half-angle vector // roughness value -> Blinn exponent
vec3 aHalf = theInput + theOutput; float aPower = max (2.f / (theRoughness * theRoughness) - 2.f, 0.f);
if (aHalf.z < 0.f) // calculate microfacet distribution
aHalf = -aHalf; float aD = (aPower + 2.f) * (1.f / M_2_PI) * pow (aH.z, aPower);
float aLength = dot (aHalf, aHalf); // calculate shadow-masking function
float aG = SmithG1 (theOutput, aH, theRoughness) * SmithG1 (theInput, aH, theRoughness);
if (aLength <= 0.f) // return total amount of reflection
return ZERO; return (theInput.z <= 0.f || theOutput.z <= 0.f) ? ZERO :
aD * aG / (4.f * theOutput.z) * fresnelMedia (dot (theOutput, aH), theFresnel);
aHalf *= inversesqrt (aLength);
// Compute Fresnel reflectance
float aCosDelta = dot (theOutput, aHalf);
vec3 aFresnel = fresnelMedia (aCosDelta, theFresnelCoeffs);
// Compute fraction of microfacets that reflect light
float aCosThetaH = max (0.f, aHalf.z);
float aFraction = (theExponent + 2.f) * (M_PI / 2.f) * pow (aCosThetaH, theExponent);
// Compute geometry attenuation term (already includes cos)
float aCosThetaI = max (0.f, theInput.z);
float aCosThetaO = max (0.f, theOutput.z);
float aGeom = min (1.f, 2.f * aCosThetaH / max (0.f, aCosDelta) * min (aCosThetaO, aCosThetaI));
return aCosThetaO < 1.0e-3f ? ZERO :
aFraction * aGeom / (4.f * aCosThetaO) * aFresnel;
} }
//======================================================================= //=======================================================================
// function : handleMaterial // function : HandleMaterial
// purpose : Returns BSDF value for specified material, with cos(N, PSI) // purpose : Returns BSDF value for specified material, with cos(N, PSI)
//======================================================================= //=======================================================================
vec3 handleMaterial (in SMaterial theMaterial, in vec3 theInput, in vec3 theOutput) vec3 HandleMaterial (in SMaterial theBSDF, in vec3 theInput, in vec3 theOutput)
{ {
return theMaterial.Kd.rgb * handleLambertianReflection (theInput, theOutput) + return theBSDF.Kd.rgb * HandleLambertianReflection (theInput, theOutput) +
theMaterial.Ks.rgb * handleBlinnReflection (theInput, theOutput, theMaterial.Fresnel, theMaterial.Ks.w); theBSDF.Ks.rgb * HandleBlinnReflection (theInput, theOutput, theBSDF.Fresnel, theBSDF.Ks.w);
} }
//======================================================================= //=======================================================================
// function : sampleLambertianReflection // function : SampleLambertianReflection
// purpose : Samples Lambertian BRDF, W = BRDF * cos(N, PSI) / PDF(PSI) // purpose : Samples Lambertian BRDF, W = BRDF * cos(N, PSI) / PDF(PSI)
//======================================================================= //=======================================================================
void sampleLambertianReflection (in vec3 theOutput, out vec3 theInput) vec3 SampleLambertianReflection (in vec3 theOutput, out vec3 theInput, inout float thePDF)
{ {
float aKsi1 = RandFloat(); float aKsi1 = RandFloat();
float aKsi2 = RandFloat(); float aKsi2 = RandFloat();
float aTemp = sqrt (aKsi2); float aTemp = sqrt (aKsi2);
theInput = vec3 (aTemp * cos (2.f * M_PI * aKsi1), theInput = vec3 (aTemp * cos (M_2_PI * aKsi1),
aTemp * sin (2.f * M_PI * aKsi1), aTemp * sin (M_2_PI * aKsi1),
sqrt (1.f - aKsi2)); sqrt (1.f - aKsi2));
theInput.z = mix (-theInput.z, theInput.z, step (0.f, theOutput.z)); thePDF *= abs (theInput.z) * (1.f / M_PI);
}
// Types of bounces return (theInput.z <= 0.f || theOutput.z <= 0.f) ? ZERO : UNIT;
#define NON_SPECULAR_BOUNCE 0
#define SPEC_REFLECT_BOUNCE 1
#define SPEC_REFRACT_BOUNCE 2
#define IS_NON_SPEC_BOUNCE(theBounce) (theBounce == 0)
#define IS_ANY_SPEC_BOUNCE(theBounce) (theBounce != 0)
#define IS_REFL_SPEC_BOUNCE(theBounce) (theBounce == 1)
#define IS_REFR_SPEC_BOUNCE(theBounce) (theBounce == 2)
//=======================================================================
// function : sampleSpecularTransmission
// purpose : Samples specular BTDF, W = BRDF * cos(N, PSI) / PDF(PSI)
//=======================================================================
vec3 sampleSpecularTransmission (in vec3 theOutput, out vec3 theInput,
out int theBounce, in vec3 theWeight, in vec3 theFresnelCoeffs)
{
vec3 aFresnel = fresnelMedia (theOutput.z, theFresnelCoeffs);
float aProbability = convolve (aFresnel, theWeight);
// Check if transmission takes place
theBounce = RandFloat() <= aProbability ?
SPEC_REFLECT_BOUNCE : SPEC_REFRACT_BOUNCE;
// Sample input direction
if (theBounce == SPEC_REFLECT_BOUNCE)
{
theInput = vec3 (-theOutput.x,
-theOutput.y,
theOutput.z);
theWeight = aFresnel * (1.f / aProbability);
}
else
{
transmitted (theFresnelCoeffs.y, theOutput, theInput);
theWeight = (UNIT - aFresnel) * (1.f / (1.f - aProbability));
}
return theWeight;
} }
//======================================================================= //=======================================================================
// function : sampleSpecularReflection // function : SampleBlinnReflection
// purpose : Samples specular BRDF, W = BRDF * cos(N, PSI) / PDF(PSI)
//=======================================================================
vec3 sampleSpecularReflection (in vec3 theOutput, out vec3 theInput, in vec3 theFresnelCoeffs)
{
// Sample input direction
theInput = vec3 (-theOutput.x,
-theOutput.y,
theOutput.z);
return fresnelMedia (theOutput.z, theFresnelCoeffs);
}
#define MIN_COS 1.0e-20f
//=======================================================================
// function : sampleBlinnReflection
// purpose : Samples Blinn BRDF, W = BRDF * cos(N, PSI) / PDF(PSI) // purpose : Samples Blinn BRDF, W = BRDF * cos(N, PSI) / PDF(PSI)
// The BRDF is a product of three main terms, D, G, and F, // The BRDF is a product of three main terms, D, G, and F,
// which is then divided by two cosine terms. Here we perform // which is then divided by two cosine terms. Here we perform
@ -389,155 +344,191 @@ vec3 sampleSpecularReflection (in vec3 theOutput, out vec3 theInput, in vec3 the
// terms would be complex, and it is the D term that accounts // terms would be complex, and it is the D term that accounts
// for most of the variation. // for most of the variation.
//======================================================================= //=======================================================================
vec3 sampleBlinnReflection (in vec3 theOutput, out vec3 theInput, in vec3 theFresnelCoeffs, in float theExponent) vec3 SampleBlinnReflection (in vec3 theOutput, out vec3 theInput, in vec3 theFresnel, in float theRoughness, inout float thePDF)
{ {
vec3 aWeight = ZERO;
// Generate two random variables
float aKsi1 = RandFloat(); float aKsi1 = RandFloat();
float aKsi2 = RandFloat(); float aKsi2 = RandFloat();
// Compute sampled half-angle vector for Blinn distribution // roughness value --> Blinn exponent
float aCosThetaH = pow (aKsi1, 1.f / (theExponent + 1.f)); float aPower = max (2.f / (theRoughness * theRoughness) - 2.f, 0.f);
vec3 aHalf = sphericalDirection (aCosThetaH, aKsi2 * 2.f * M_PI); // normal from microface distribution
float aCosThetaM = pow (aKsi1, 1.f / (aPower + 2.f));
if (aHalf.z < 0) vec3 aM = vec3 (cos (M_2_PI * aKsi2),
{ sin (M_2_PI * aKsi2),
aHalf = -aHalf; aCosThetaM);
}
// Compute incident direction by reflecting about half-vector aM.xy *= sqrt (1.f - aCosThetaM * aCosThetaM);
float aCosDelta = dot (theOutput, aHalf);
vec3 anInput = 2.f * aCosDelta * aHalf - theOutput; // calculate PDF of sampled direction
thePDF *= (aPower + 2.f) * (1.f / M_2_PI) * pow (aCosThetaM, aPower + 1.f);
if (theOutput.z * anInput.z <= 0.f) float aCosDelta = dot (theOutput, aM);
// pick input based on half direction
theInput = -theOutput + 2.f * aCosDelta * aM;
if (theInput.z <= 0.f || theOutput.z <= 0.f)
{ {
return ZERO; return ZERO;
} }
theInput = anInput; // Jacobian of half-direction mapping
thePDF /= 4.f * dot (theInput, aM);
// Compute Fresnel reflectance // compute shadow-masking coefficient
vec3 aFresnel = fresnelMedia (aCosDelta, theFresnelCoeffs); float aG = SmithG1 (theOutput, aM, theRoughness) * SmithG1 (theInput, aM, theRoughness);
// Compute geometry attenuation term return aG * aCosDelta / (theOutput.z * aM.z) * fresnelMedia (aCosDelta, theFresnel);
float aCosThetaI = max (MIN_COS, theInput.z);
float aCosThetaO = max (MIN_COS, theOutput.z);
float aGeom = min (max (MIN_COS, aCosDelta), 2.f * aCosThetaH * min (aCosThetaO, aCosThetaI));
// Compute weight of the ray sample
return aFresnel * ((theExponent + 2.f) / (theExponent + 1.f) * aGeom / aCosThetaO);
} }
//======================================================================= //=======================================================================
// function : sampleMaterial // function : SampleSpecularReflection
// purpose : Samples specified composite material (BSDF) // purpose : Samples specular BRDF, W = BRDF * cos(N, PSI) / PDF(PSI)
//======================================================================= //=======================================================================
void sampleMaterial (in SMaterial theMaterial, vec3 SampleSpecularReflection (in vec3 theOutput, out vec3 theInput, in vec3 theFresnel)
in vec3 theOutput,
out vec3 theInput,
inout vec3 theWeight,
inout int theBounce)
{ {
// Compute the probability of ray reflection // Sample input direction
float aPd = convolve (theMaterial.Kd.rgb, theWeight); theInput = vec3 (-theOutput.x,
float aPs = convolve (theMaterial.Ks.rgb, theWeight); -theOutput.y,
float aPr = convolve (theMaterial.Kr.rgb, theWeight); theOutput.z);
float aPt = convolve (theMaterial.Kt.rgb, theWeight);
return fresnelMedia (theOutput.z, theFresnel);
}
//=======================================================================
// function : SampleSpecularTransmission
// purpose : Samples specular BTDF, W = BRDF * cos(N, PSI) / PDF(PSI)
//=======================================================================
vec3 SampleSpecularTransmission (in vec3 theOutput,
out vec3 theInput, in vec3 theWeight, in vec3 theFresnel, inout bool theInside)
{
vec3 aFactor = fresnelMedia (theOutput.z, theFresnel);
float aReflection = convolve (aFactor, theWeight);
// sample specular BRDF/BTDF
if (RandFloat() <= aReflection)
{
theInput = vec3 (-theOutput.x,
-theOutput.y,
theOutput.z);
theWeight = aFactor * (1.f / aReflection);
}
else
{
theInside = !theInside;
transmitted (theFresnel.y, theOutput, theInput);
theWeight = (UNIT - aFactor) * (1.f / (1.f - aReflection));
}
return theWeight;
}
#define FLT_EPSILON 1.0e-5F
//=======================================================================
// function : BsdfPdf
// purpose : Calculates BSDF of sampling input knowing output
//=======================================================================
float BsdfPdf (in SMaterial theBSDF,
in vec3 theOutput,
in vec3 theInput,
in vec3 theWeight)
{
float aPd = convolve (theBSDF.Kd.rgb, theWeight);
float aPs = convolve (theBSDF.Ks.rgb, theWeight);
float aPr = convolve (theBSDF.Kr.rgb, theWeight);
float aPt = convolve (theBSDF.Kt.rgb, theWeight);
float aReflection = aPd + aPs + aPr + aPt; float aReflection = aPd + aPs + aPr + aPt;
// Choose BSDF component to sample float aPDF = 0.f; // PDF of sampling input direction
if (theInput.z * theOutput.z > 0.f)
{
vec3 aHalf = normalize (theInput + theOutput);
// roughness value --> Blinn exponent
float aPower = max (2.f / (theBSDF.Ks.w * theBSDF.Ks.w) - 2.f, 0.f);
aPDF = aPd * abs (theInput.z / M_PI) +
aPs * (aPower + 2.f) * (1.f / M_2_PI) * pow (aHalf.z, aPower + 1.f) / (4.f * dot (theInput, aHalf));
}
return aPDF / aReflection;
}
//! Tool macro to handle sampling of particular BxDF
#define PICK_BXDF(p, k) aPDF = p / aReflection; theWeight *= k / aPDF;
//=======================================================================
// function : SampleBsdf
// purpose : Samples specified composite material (BSDF)
//=======================================================================
float SampleBsdf (in SMaterial theBSDF,
in vec3 theOutput,
out vec3 theInput,
inout vec3 theWeight,
inout bool theInside)
{
// compute probability of each reflection type (BxDF)
float aPd = convolve (theBSDF.Kd.rgb, theWeight);
float aPs = convolve (theBSDF.Ks.rgb, theWeight);
float aPr = convolve (theBSDF.Kr.rgb, theWeight);
float aPt = convolve (theBSDF.Kt.rgb, theWeight);
float aReflection = aPd + aPs + aPr + aPt;
// choose BxDF component to sample
float aKsi = aReflection * RandFloat(); float aKsi = aReflection * RandFloat();
theBounce = NON_SPECULAR_BOUNCE; // BxDF's PDF of sampled direction
float aPDF = 0.f;
if (aKsi < aPd) // diffuse reflection if (aKsi < aPd) // diffuse reflection
{ {
sampleLambertianReflection (theOutput, theInput); PICK_BXDF (aPd, theBSDF.Kd.rgb);
theWeight *= theMaterial.Kd.rgb * (aReflection / aPd); theWeight *= SampleLambertianReflection (theOutput, theInput, aPDF);
} }
else if (aKsi < aPd + aPs) // glossy reflection else if (aKsi < aPd + aPs) // glossy reflection
{ {
theWeight *= theMaterial.Ks.rgb * (aReflection / aPs) * PICK_BXDF (aPs, theBSDF.Ks.rgb);
sampleBlinnReflection (theOutput, theInput, theMaterial.Fresnel, theMaterial.Ks.w);
}
else if (aKsi < aPd + aPs + aPr) // specular reflection
{
theWeight *= theMaterial.Kr.rgb * (aReflection / aPr) *
sampleSpecularReflection (theOutput, theInput, theMaterial.Fresnel);
theBounce = SPEC_REFLECT_BOUNCE; // specular bounce theWeight *= SampleBlinnReflection (theOutput, theInput, theBSDF.Fresnel, theBSDF.Ks.w, aPDF);
} }
else // specular transmission else if (aKsi < aPd + aPs + aPr) // specular reflection
{ {
theWeight *= theMaterial.Kt.rgb * (aReflection / aPt) * PICK_BXDF (aPr, theBSDF.Kr.rgb);
sampleSpecularTransmission (theOutput, theInput, theBounce, theWeight, theMaterial.Fresnel);
aPDF = MAXFLOAT;
theWeight *= SampleSpecularReflection (theOutput, theInput, theBSDF.Fresnel);
}
else if (aKsi < aReflection) // specular transmission
{
PICK_BXDF (aPt, theBSDF.Kt.rgb);
aPDF = MAXFLOAT;
theWeight *= SampleSpecularTransmission (theOutput, theInput, theWeight, theBSDF.Fresnel, theInside);
} }
// path termination for extra small weights // path termination for extra small weights
theWeight = mix (theWeight, ZERO, float (aReflection < 1e-3f)); theWeight = mix (ZERO, theWeight, step (FLT_EPSILON, aReflection));
return aPDF;
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
// Handlers and samplers for light sources // Handlers and samplers for light sources
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
//=======================================================================
// function : handlePointLight
// purpose :
//=======================================================================
float handlePointLight (in vec3 theInput, in vec3 theToLight, in float theRadius, in float theDistance)
{
float aDistance = dot (theToLight, theToLight);
float aCosMax = inversesqrt (1.f + theRadius * theRadius / aDistance);
return float (aDistance < theDistance * theDistance) *
step (aCosMax, dot (theToLight, theInput) * inversesqrt (aDistance));
}
//=======================================================================
// function : handleDirectLight
// purpose :
//=======================================================================
float handleDirectLight (in vec3 theInput, in vec3 theToLight, in float theCosMax)
{
return step (theCosMax, dot (theInput, theToLight));
}
//=======================================================================
// function : sampleLight
// purpose : General sampling function for directional and point lights
//=======================================================================
vec3 sampleLight (in vec3 theToLight, inout float theDistance, in bool isInfinite, in float theSmoothness, inout float thePDF)
{
SLocalSpace aSpace = LocalSpace (theToLight * (1.f / theDistance));
// for point lights smoothness defines radius
float aCosMax = isInfinite ? theSmoothness :
inversesqrt (1.f + theSmoothness * theSmoothness / (theDistance * theDistance));
float aKsi1 = RandFloat();
float aKsi2 = RandFloat();
float aTmp = 1.f - aKsi2 * (1.f - aCosMax);
vec3 anInput = vec3 (cos (2.f * M_PI * aKsi1),
sin (2.f * M_PI * aKsi1),
aTmp);
anInput.xy *= sqrt (1.f - aTmp * aTmp);
thePDF *= (aCosMax < 1.f) ? 1.f / (2.f * M_PI) / (1.f - aCosMax) : 1.f;
return normalize (fromLocalSpace (anInput, aSpace));
}
// ======================================================================= // =======================================================================
// function : Latlong // function : Latlong
// purpose : Converts world direction to environment texture coordinates // purpose : Converts world direction to environment texture coordinates
@ -552,49 +543,128 @@ vec2 Latlong (in vec3 thePoint)
aPsi * 0.3183098f); aPsi * 0.3183098f);
} }
//=======================================================================
// function : SampleLight
// purpose : General sampling function for directional and point lights
//=======================================================================
vec3 SampleLight (in vec3 theToLight, inout float theDistance, in bool isInfinite, in float theSmoothness, inout float thePDF)
{
SLocalSpace aSpace = buildLocalSpace (theToLight * (1.f / theDistance));
// for point lights smoothness defines radius
float aCosMax = isInfinite ? theSmoothness :
inversesqrt (1.f + theSmoothness * theSmoothness / (theDistance * theDistance));
float aKsi1 = RandFloat();
float aKsi2 = RandFloat();
float aTmp = 1.f - aKsi2 * (1.f - aCosMax);
vec3 anInput = vec3 (cos (M_2_PI * aKsi1),
sin (M_2_PI * aKsi1),
aTmp);
anInput.xy *= sqrt (1.f - aTmp * aTmp);
thePDF = (aCosMax < 1.f) ? (thePDF / M_2_PI) / (1.f - aCosMax) : MAXFLOAT;
return normalize (fromLocalSpace (anInput, aSpace));
}
//=======================================================================
// function : HandlePointLight
// purpose :
//=======================================================================
float HandlePointLight (in vec3 theInput, in vec3 theToLight, in float theRadius, in float theDistance, inout float thePDF)
{
float aCosMax = inversesqrt (1.f + theRadius * theRadius / (theDistance * theDistance));
float aVisibility = step (aCosMax, dot (theInput, theToLight));
thePDF *= step (-1.f, -aCosMax) * aVisibility * (1.f / M_2_PI) / (1.f - aCosMax);
return aVisibility;
}
//=======================================================================
// function : HandleDistantLight
// purpose :
//=======================================================================
float HandleDistantLight (in vec3 theInput, in vec3 theToLight, in float theCosMax, inout float thePDF)
{
float aVisibility = step (theCosMax, dot (theInput, theToLight));
thePDF *= step (-1.f, -theCosMax) * aVisibility * (1.f / M_2_PI) / (1.f - theCosMax);
return aVisibility;
}
// ======================================================================= // =======================================================================
// function: intersectLight // function: IntersectLight
// purpose : Checks intersections with light sources // purpose : Checks intersections with light sources
// ======================================================================= // =======================================================================
vec3 intersectLight (in SRay theRay, in bool isViewRay, in int theBounce, in float theDistance) vec3 IntersectLight (in SRay theRay, in int theDepth, in float theHitDistance, out float thePDF)
{ {
vec3 aRadiance = ZERO; vec3 aTotalRadiance = ZERO;
if ((isViewRay || IS_REFR_SPEC_BOUNCE(theBounce)) && uSphereMapForBack == 0) thePDF = 0.f; // PDF of sampling light sources
{
aRadiance = BackgroundColor().xyz;
}
else
{
aRadiance = FetchEnvironment (Latlong (theRay.Direct)).xyz;
}
// Apply gamma correction (gamma is 2) for (int aLightIdx = 0; aLightIdx < uLightCount; ++aLightIdx)
aRadiance = aRadiance * aRadiance * float (theDistance == MAXFLOAT);
for (int aLightIdx = 0; aLightIdx < uLightCount && (isViewRay || IS_ANY_SPEC_BOUNCE(theBounce)); ++aLightIdx)
{ {
vec4 aLight = texelFetch ( vec4 aLight = texelFetch (
uRaytraceLightSrcTexture, LIGHT_POS (aLightIdx)); uRaytraceLightSrcTexture, LIGHT_POS (aLightIdx));
vec4 aParam = texelFetch ( vec4 aParam = texelFetch (
uRaytraceLightSrcTexture, LIGHT_PWR (aLightIdx)); uRaytraceLightSrcTexture, LIGHT_PWR (aLightIdx));
// W component: 0 for infinite light and 1 for point light
aLight.xyz -= mix (ZERO, theRay.Origin, aLight.w);
float aPDF = 1.f / uLightCount;
if (aLight.w != 0.f) // point light source if (aLight.w != 0.f) // point light source
{ {
aRadiance += aParam.rgb * handlePointLight ( float aCenterDst = length (aLight.xyz);
theRay.Direct, aLight.xyz - theRay.Origin, aParam.w /* radius */, theDistance);
if (aCenterDst < theHitDistance)
{
float aVisibility = HandlePointLight (
theRay.Direct, normalize (aLight.xyz), aParam.w /* radius */, aCenterDst, aPDF);
if (aVisibility > 0.f)
{
theHitDistance = aCenterDst;
aTotalRadiance = aParam.rgb;
thePDF = aPDF;
}
}
} }
else if (theDistance == MAXFLOAT) // directional light source else if (theHitDistance == MAXFLOAT) // directional light source
{ {
aRadiance += aParam.rgb * handleDirectLight (theRay.Direct, aLight.xyz, aParam.w /* angle cosine */); aTotalRadiance += aParam.rgb * HandleDistantLight (
theRay.Direct, aLight.xyz, aParam.w /* angle cosine */, aPDF);
thePDF += aPDF;
} }
} }
return aRadiance; if (thePDF == 0.f && theHitDistance == MAXFLOAT) // light source not found
{
if (theDepth + uSphereMapForBack == 0) // view ray and map is hidden
{
aTotalRadiance = pow (BackgroundColor().rgb, vec3 (2.f));
}
else
{
aTotalRadiance = pow (FetchEnvironment (Latlong (theRay.Direct)).rgb, vec3 (2.f));
}
}
return aTotalRadiance;
} }
#define MIN_THROUGHPUT vec3 (0.02f) #define MIN_THROUGHPUT vec3 (1.0e-3f)
#define MIN_CONTRIBUTION vec3 (0.01f) #define MIN_CONTRIBUTION vec3 (1.0e-2f)
#define MATERIAL_KD(index) (18 * index + 11) #define MATERIAL_KD(index) (18 * index + 11)
#define MATERIAL_KR(index) (18 * index + 12) #define MATERIAL_KR(index) (18 * index + 12)
@ -618,29 +688,32 @@ vec4 PathTrace (in SRay theRay, in vec3 theInverse)
vec3 aRadiance = ZERO; vec3 aRadiance = ZERO;
vec3 aThroughput = UNIT; vec3 aThroughput = UNIT;
int aBounce = 0; // type of previous hit point int aTransfID = 0; // ID of object transformation
int aTrsfId = 0; // offset of object transform bool aInMedium = false; // is the ray inside an object
bool isInMedium = false; float aExpPDF = 1.f;
float aImpPDF = 1.f;
for (int aDepth = 0; aDepth < NB_BOUNCES; ++aDepth) for (int aDepth = 0; aDepth < NB_BOUNCES; ++aDepth)
{ {
SIntersect aHit = SIntersect (MAXFLOAT, vec2 (ZERO), ZERO); SIntersect aHit = SIntersect (MAXFLOAT, vec2 (ZERO), ZERO);
ivec4 aTriIndex = SceneNearestHit (theRay, theInverse, aHit, aTrsfId); ivec4 aTriIndex = SceneNearestHit (theRay, theInverse, aHit, aTransfID);
// check implicit path // check implicit path
vec3 aLe = intersectLight (theRay, vec3 aLe = IntersectLight (theRay, aDepth, aHit.Time, aExpPDF);
aDepth == 0 /* is view ray */, aBounce, aHit.Time);
if (any (greaterThan (aLe, ZERO)) || aTriIndex.x == -1) if (any (greaterThan (aLe, ZERO)) || aTriIndex.x == -1)
{ {
aRadiance += aThroughput * aLe; break; // terminate path float aMIS = (aDepth == 0 || aImpPDF == MAXFLOAT) ? 1.f :
aImpPDF * aImpPDF / (aExpPDF * aExpPDF + aImpPDF * aImpPDF);
aRadiance += aThroughput * aLe * aMIS; break; // terminate path
} }
vec3 aInvTransf0 = texelFetch (uSceneTransformTexture, aTrsfId + 0).xyz; vec3 aInvTransf0 = texelFetch (uSceneTransformTexture, aTransfID + 0).xyz;
vec3 aInvTransf1 = texelFetch (uSceneTransformTexture, aTrsfId + 1).xyz; vec3 aInvTransf1 = texelFetch (uSceneTransformTexture, aTransfID + 1).xyz;
vec3 aInvTransf2 = texelFetch (uSceneTransformTexture, aTrsfId + 2).xyz; vec3 aInvTransf2 = texelFetch (uSceneTransformTexture, aTransfID + 2).xyz;
// compute geometrical normal // compute geometrical normal
aHit.Normal = normalize (vec3 (dot (aInvTransf0, aHit.Normal), aHit.Normal = normalize (vec3 (dot (aInvTransf0, aHit.Normal),
@ -649,7 +722,7 @@ vec4 PathTrace (in SRay theRay, in vec3 theInverse)
theRay.Origin += theRay.Direct * aHit.Time; // get new intersection point theRay.Origin += theRay.Direct * aHit.Time; // get new intersection point
// Evaluate depth on first hit // evaluate depth on first hit
if (aDepth == 0) if (aDepth == 0)
{ {
vec4 aNDCPoint = uViewMat * vec4 (theRay.Origin, 1.f); vec4 aNDCPoint = uViewMat * vec4 (theRay.Origin, 1.f);
@ -694,7 +767,7 @@ vec4 PathTrace (in SRay theRay, in vec3 theInverse)
dot (aInvTransf1, aNormal), dot (aInvTransf1, aNormal),
dot (aInvTransf2, aNormal))); dot (aInvTransf2, aNormal)));
SLocalSpace aSpace = LocalSpace (aNormal); SLocalSpace aSpace = buildLocalSpace (aNormal);
// account for self-emission (not stored in the material) // account for self-emission (not stored in the material)
aRadiance += aThroughput * texelFetch ( aRadiance += aThroughput * texelFetch (
@ -702,6 +775,8 @@ vec4 PathTrace (in SRay theRay, in vec3 theInverse)
if (uLightCount > 0 && convolve (aMaterial.Kd.rgb + aMaterial.Ks.rgb, aThroughput) > 0.f) if (uLightCount > 0 && convolve (aMaterial.Kd.rgb + aMaterial.Ks.rgb, aThroughput) > 0.f)
{ {
aExpPDF = 1.f / uLightCount;
int aLightIdx = min (int (floor (RandFloat() * uLightCount)), uLightCount - 1); int aLightIdx = min (int (floor (RandFloat() * uLightCount)), uLightCount - 1);
vec4 aLight = texelFetch ( vec4 aLight = texelFetch (
@ -712,15 +787,21 @@ vec4 PathTrace (in SRay theRay, in vec3 theInverse)
// 'w' component is 0 for infinite light and 1 for point light // 'w' component is 0 for infinite light and 1 for point light
aLight.xyz -= mix (ZERO, theRay.Origin, aLight.w); aLight.xyz -= mix (ZERO, theRay.Origin, aLight.w);
float aPDF = 1.f / uLightCount, aDistance = length (aLight.xyz); float aDistance = length (aLight.xyz);
aLight.xyz = sampleLight (aLight.xyz, aDistance, aLight.xyz = SampleLight (aLight.xyz, aDistance,
aLight.w == 0.f /* is infinite */, aParam.w /* max cos or radius */, aPDF); aLight.w == 0.f /* is infinite */, aParam.w /* max cos or radius */, aExpPDF);
vec3 aContrib = (1.f / aPDF) * aParam.rgb /* Le */ * handleMaterial ( aImpPDF = BsdfPdf (aMaterial,
toLocalSpace (-theRay.Direct, aSpace), toLocalSpace (aLight.xyz, aSpace), aThroughput);
// MIS weight including division by explicit PDF
float aMIS = (aExpPDF == MAXFLOAT) ? 1.f : aExpPDF / (aExpPDF * aExpPDF + aImpPDF * aImpPDF);
vec3 aContrib = aMIS * aParam.rgb /* Le */ * HandleMaterial (
aMaterial, toLocalSpace (aLight.xyz, aSpace), toLocalSpace (-theRay.Direct, aSpace)); aMaterial, toLocalSpace (aLight.xyz, aSpace), toLocalSpace (-theRay.Direct, aSpace));
if (any (greaterThan (aContrib, MIN_CONTRIBUTION))) // first check if light source is important if (any (greaterThan (aContrib, MIN_CONTRIBUTION))) // check if light source is important
{ {
SRay aShadow = SRay (theRay.Origin + aLight.xyz * uSceneEpsilon, aLight.xyz); SRay aShadow = SRay (theRay.Origin + aLight.xyz * uSceneEpsilon, aLight.xyz);
@ -734,32 +815,29 @@ vec4 PathTrace (in SRay theRay, in vec3 theInverse)
} }
} }
vec3 anInput; if (aInMedium) // handle attenuation
sampleMaterial (aMaterial,
toLocalSpace (-theRay.Direct, aSpace), anInput, aThroughput, aBounce);
if (isInMedium)
{ {
aThroughput *= exp (-aHit.Time * aThroughput *= exp (-aHit.Time *
aMaterial.Absorption.w * (UNIT - aMaterial.Absorption.rgb)); aMaterial.Absorption.w * (UNIT - aMaterial.Absorption.rgb));
} }
isInMedium = IS_REFR_SPEC_BOUNCE(aBounce) ? !isInMedium : isInMedium; vec3 anInput = UNIT; // sampled input direction
#ifndef RUSSIAN_ROULETTE aImpPDF = SampleBsdf (aMaterial,
if (all (lessThan (aThroughput, MIN_THROUGHPUT))) toLocalSpace (-theRay.Direct, aSpace), anInput, aThroughput, aInMedium);
{
aDepth = INVALID_BOUNCES; // terminate path
}
#else
float aSurvive = aDepth < 3 ? 1.f : min (dot (LUMA, aThroughput), 0.95f);
if (RandFloat() > aSurvive) float aSurvive = 1.f;
#ifdef RUSSIAN_ROULETTE
aSurvive = aDepth < 3 ? 1.f : min (dot (LUMA, aThroughput), 0.95f);
#endif
if (RandFloat() > aSurvive || all (lessThanEqual (aThroughput, MIN_THROUGHPUT)))
{ {
aDepth = INVALID_BOUNCES; // terminate path aDepth = INVALID_BOUNCES; // terminate path
} }
#ifdef RUSSIAN_ROULETTE
aThroughput /= aSurvive; aThroughput /= aSurvive;
#endif #endif

12
src/Shaders/RaytraceBase.fs
View File

@ -143,7 +143,9 @@ struct SIntersect
#define AXIS_Y vec3 (0.0f, 1.0f, 0.0f) #define AXIS_Y vec3 (0.0f, 1.0f, 0.0f)
#define AXIS_Z vec3 (0.0f, 0.0f, 1.0f) #define AXIS_Z vec3 (0.0f, 0.0f, 1.0f)
#define M_PI 3.14159265f #define M_PI 3.141592653f
#define M_2_PI 6.283185307f
#define M_PI_2 1.570796327f
#define LUMA vec3 (0.2126f, 0.7152f, 0.0722f) #define LUMA vec3 (0.2126f, 0.7152f, 0.0722f)
@ -835,8 +837,8 @@ vec2 SmoothUV (in vec2 theUV, in ivec4 theTriangle)
// ======================================================================= // =======================================================================
vec4 FetchEnvironment (in vec2 theTexCoord) vec4 FetchEnvironment (in vec2 theTexCoord)
{ {
return mix (vec4 (0.0f, 0.0f, 0.0f, 1.0f), return uSphereMapEnabled == 0 ?
textureLod (uEnvironmentMapTexture, theTexCoord, 0.0f), float (uSphereMapEnabled)); vec4 (0.f, 0.f, 0.f, 1.f) : textureLod (uEnvironmentMapTexture, theTexCoord, 0.f);
} }
// ======================================================================= // =======================================================================
@ -1020,8 +1022,8 @@ vec4 Radiance (in SRay theRay, in vec3 theInverse)
if (aVisibility > 0.0f) if (aVisibility > 0.0f)
{ {
vec3 aIntensity = vec3 (texelFetch ( vec3 aIntensity = min (UNIT, vec3 (texelFetch (
uRaytraceLightSrcTexture, LIGHT_PWR (aLightIdx))); uRaytraceLightSrcTexture, LIGHT_PWR (aLightIdx))));
float aRdotV = dot (reflect (aLight.xyz, aSidedNormal), theRay.Direct); float aRdotV = dot (reflect (aLight.xyz, aSidedNormal), theRay.Direct);

2
src/Shaders/RaytraceRender.fs
View File

@ -18,7 +18,7 @@ uniform int uBlockedRngEnabled;
//! Maximum radiance that can be added to the pixel. Decreases noise //! Maximum radiance that can be added to the pixel. Decreases noise
//! level, but introduces some bias. //! level, but introduces some bias.
#define MAX_RADIANCE vec3 (25.f) #define MAX_RADIANCE vec3 (50.f)
// ======================================================================= // =======================================================================
// function : main // function : main

660
src/Shaders/Shaders_PathtraceBase_fs.pxx
View File

@ -1,6 +1,18 @@
// This file has been automatically generated from resource file src/Shaders/PathtraceBase.fs // This file has been automatically generated from resource file src/Shaders/PathtraceBase.fs
static const char Shaders_PathtraceBase_fs[] = static const char Shaders_PathtraceBase_fs[] =
"#ifdef _MSC_VER\n"
" #define PATH_TRACING // just for editing in MS VS\n"
"\n"
" #define in\n"
" #define out\n"
" #define inout\n"
"\n"
" typedef struct { float x; float y; } vec2;\n"
" typedef struct { float x; float y; float z; } vec3;\n"
" typedef struct { float x; float y; float z; float w; } vec4;\n"
"#endif\n"
"\n"
"#ifdef PATH_TRACING\n" "#ifdef PATH_TRACING\n"
"\n" "\n"
"///////////////////////////////////////////////////////////////////////////////////////\n" "///////////////////////////////////////////////////////////////////////////////////////\n"
@ -45,13 +57,13 @@ static const char Shaders_PathtraceBase_fs[] =
"// Support subroutines\n" "// Support subroutines\n"
"\n" "\n"
"//=======================================================================\n" "//=======================================================================\n"
"// function : LocalSpace\n" "// function : buildLocalSpace\n"
"// purpose : Generates local space for the given normal\n" "// purpose : Generates local space for the given normal\n"
"//=======================================================================\n" "//=======================================================================\n"
"SLocalSpace LocalSpace (in vec3 theNormal)\n" "SLocalSpace buildLocalSpace (in vec3 theNormal)\n"
"{\n" "{\n"
" vec3 anAxisX = cross (vec3 (0.f, 1.f, 0.f), theNormal);\n" " vec3 anAxisX = vec3 (theNormal.z, 0.f, -theNormal.x);\n"
" vec3 anAxisY = cross (vec3 (1.f, 0.f, 0.f), theNormal);\n" " vec3 anAxisY = vec3 (0.f, -theNormal.z, theNormal.y);\n"
"\n" "\n"
" float aSqrLenX = dot (anAxisX, anAxisX);\n" " float aSqrLenX = dot (anAxisX, anAxisX);\n"
" float aSqrLenY = dot (anAxisY, anAxisY);\n" " float aSqrLenY = dot (anAxisY, anAxisY);\n"
@ -102,19 +114,6 @@ static const char Shaders_PathtraceBase_fs[] =
"}\n" "}\n"
"\n" "\n"
"//=======================================================================\n" "//=======================================================================\n"
"// function : sphericalDirection\n"
"// purpose : Constructs vector from spherical coordinates\n"
"//=======================================================================\n"
"vec3 sphericalDirection (in float theCosTheta, in float thePhi)\n"
"{\n"
" float aSinTheta = sqrt (1.f - theCosTheta * theCosTheta);\n"
"\n"
" return vec3 (aSinTheta * cos (thePhi),\n"
" aSinTheta * sin (thePhi),\n"
" theCosTheta);\n"
"}\n"
"\n"
"//=======================================================================\n"
"// function : fresnelSchlick\n" "// function : fresnelSchlick\n"
"// purpose : Computes the Fresnel reflection formula using\n" "// purpose : Computes the Fresnel reflection formula using\n"
"// Schlick's approximation.\n" "// Schlick's approximation.\n"
@ -199,24 +198,24 @@ static const char Shaders_PathtraceBase_fs[] =
"// purpose : Computes the Fresnel reflection formula for general medium\n" "// purpose : Computes the Fresnel reflection formula for general medium\n"
"// in case of circularly polarized light.\n" "// in case of circularly polarized light.\n"
"//=======================================================================\n" "//=======================================================================\n"
"vec3 fresnelMedia (in float theCosI, in vec3 theFresnelCoeffs)\n" "vec3 fresnelMedia (in float theCosI, in vec3 theFresnel)\n"
"{\n" "{\n"
" if (theFresnelCoeffs.x > FRESNEL_SCHLICK)\n" " if (theFresnel.x > FRESNEL_SCHLICK)\n"
" {\n" " {\n"
" return fresnelSchlick (abs (theCosI), theFresnelCoeffs);\n" " return fresnelSchlick (abs (theCosI), theFresnel);\n"
" }\n" " }\n"
"\n" "\n"
" if (theFresnelCoeffs.x > FRESNEL_CONSTANT)\n" " if (theFresnel.x > FRESNEL_CONSTANT)\n"
" {\n" " {\n"
" return vec3 (theFresnelCoeffs.z);\n" " return vec3 (theFresnel.z);\n"
" }\n" " }\n"
"\n" "\n"
" if (theFresnelCoeffs.x > FRESNEL_CONDUCTOR)\n" " if (theFresnel.x > FRESNEL_CONDUCTOR)\n"
" {\n" " {\n"
" return vec3 (fresnelConductor (abs (theCosI), theFresnelCoeffs.y, theFresnelCoeffs.z));\n" " return vec3 (fresnelConductor (abs (theCosI), theFresnel.y, theFresnel.z));\n"
" }\n" " }\n"
"\n" "\n"
" return vec3 (fresnelDielectric (theCosI, theFresnelCoeffs.y));\n" " return vec3 (fresnelDielectric (theCosI, theFresnel.y));\n"
"}\n" "}\n"
"\n" "\n"
"//=======================================================================\n" "//=======================================================================\n"
@ -229,11 +228,11 @@ static const char Shaders_PathtraceBase_fs[] =
" // Compute relative index of refraction\n" " // Compute relative index of refraction\n"
" float anEta = (theIncident.z > 0.f) ? 1.f / theIndex : theIndex;\n" " float anEta = (theIncident.z > 0.f) ? 1.f / theIndex : theIndex;\n"
"\n" "\n"
" // Handle total internal reflection for transmission\n" " // Handle total internal reflection (TIR)\n"
" float aSinT2 = anEta * anEta * (1.f - theIncident.z * theIncident.z);\n" " float aSinT2 = anEta * anEta * (1.f - theIncident.z * theIncident.z);\n"
"\n" "\n"
" // Compute transmitted ray direction\n" " // Compute direction of transmitted ray\n"
" float aCosT = sqrt (1.f - min (aSinT2, 1.f)) * (theIncident.z > 0.f ? -1.f : 1.f);\n" " float aCosT = sqrt (1.f - min (aSinT2, 1.f)) * sign (-theIncident.z);\n"
"\n" "\n"
" theTransmit = normalize (vec3 (-anEta * theIncident.x,\n" " theTransmit = normalize (vec3 (-anEta * theIncident.x,\n"
" -anEta * theIncident.y,\n" " -anEta * theIncident.y,\n"
@ -245,145 +244,101 @@ static const char Shaders_PathtraceBase_fs[] =
"//////////////////////////////////////////////////////////////////////////////////////////////\n" "//////////////////////////////////////////////////////////////////////////////////////////////\n"
"\n" "\n"
"//=======================================================================\n" "//=======================================================================\n"
"// function : handleLambertianReflection\n" "// function : HandleLambertianReflection\n"
"// purpose : Handles Lambertian BRDF, with cos(N, PSI)\n" "// purpose : Handles Lambertian BRDF, with cos(N, PSI)\n"
"//=======================================================================\n" "//=======================================================================\n"
"float handleLambertianReflection (in vec3 theInput, in vec3 theOutput)\n" "float HandleLambertianReflection (in vec3 theInput, in vec3 theOutput)\n"
"{\n" "{\n"
" return max (0.f, theInput.z) * (1.f / M_PI);\n" " return (theInput.z <= 0.f || theOutput.z <= 0.f) ? 0.f : theInput.z * (1.f / M_PI);\n"
"}\n" "}\n"
"\n" "\n"
"//=======================================================================\n" "//=======================================================================\n"
"// function : handleBlinnReflection\n" "// function : SmithG1\n"
"// purpose :\n"
"//=======================================================================\n"
"float SmithG1 (in vec3 theDirection, in vec3 theM, in float theRoughness)\n"
"{\n"
" if (dot (theDirection, theM) * theDirection.z <= 0.f)\n"
" {\n"
" return 0.f;\n"
" }\n"
"\n"
" float aTanThetaM = sqrt (1.f - theDirection.z * theDirection.z) / theDirection.z;\n"
"\n"
" if (aTanThetaM == 0.0f)\n"
" {\n"
" return 1.f;\n"
" }\n"
"\n"
" float aVal = 1.f / (theRoughness * aTanThetaM);\n"
"\n"
" if (aVal >= 1.6f)\n"
" {\n"
" return 1.f;\n"
" }\n"
"\n"
" // Use fast and accurate rational approximation to the\n"
" // shadowing-masking function (from Mitsuba renderer)\n"
" float aSqr = aVal * aVal;\n"
"\n"
" return (3.535f * aVal + 2.181f * aSqr) / (1.f + 2.276f * aVal + 2.577f * aSqr);\n"
"}\n"
"\n"
"//=======================================================================\n"
"// function : HandleBlinnReflection\n"
"// purpose : Handles Blinn glossy BRDF, with cos(N, PSI)\n" "// purpose : Handles Blinn glossy BRDF, with cos(N, PSI)\n"
"//=======================================================================\n" "//=======================================================================\n"
"vec3 handleBlinnReflection (in vec3 theInput, in vec3 theOutput, in vec3 theFresnelCoeffs, in float theExponent)\n" "vec3 HandleBlinnReflection (in vec3 theInput, in vec3 theOutput, in vec3 theFresnel, in float theRoughness)\n"
"{\n" "{\n"
" vec3 aWeight = ZERO;\n" " // calculate the reflection half-vec\n"
" vec3 aH = normalize (theInput + theOutput);\n"
"\n" "\n"
" // Compute half-angle vector\n" " // roughness value -> Blinn exponent\n"
" vec3 aHalf = theInput + theOutput;\n" " float aPower = max (2.f / (theRoughness * theRoughness) - 2.f, 0.f);\n"
"\n" "\n"
" if (aHalf.z < 0.f)\n" " // calculate microfacet distribution\n"
" aHalf = -aHalf;\n" " float aD = (aPower + 2.f) * (1.f / M_2_PI) * pow (aH.z, aPower);\n"
"\n" "\n"
" float aLength = dot (aHalf, aHalf);\n" " // calculate shadow-masking function\n"
" float aG = SmithG1 (theOutput, aH, theRoughness) * SmithG1 (theInput, aH, theRoughness);\n"
"\n" "\n"
" if (aLength <= 0.f)\n" " // return total amount of reflection\n"
" return ZERO;\n" " return (theInput.z <= 0.f || theOutput.z <= 0.f) ? ZERO :\n"
"\n" " aD * aG / (4.f * theOutput.z) * fresnelMedia (dot (theOutput, aH), theFresnel);\n"
" aHalf *= inversesqrt (aLength);\n"
"\n"
" // Compute Fresnel reflectance\n"
" float aCosDelta = dot (theOutput, aHalf);\n"
"\n"
" vec3 aFresnel = fresnelMedia (aCosDelta, theFresnelCoeffs);\n"
"\n"
" // Compute fraction of microfacets that reflect light\n"
" float aCosThetaH = max (0.f, aHalf.z);\n"
"\n"
" float aFraction = (theExponent + 2.f) * (M_PI / 2.f) * pow (aCosThetaH, theExponent);\n"
"\n"
" // Compute geometry attenuation term (already includes cos)\n"
" float aCosThetaI = max (0.f, theInput.z);\n"
" float aCosThetaO = max (0.f, theOutput.z);\n"
"\n"
" float aGeom = min (1.f, 2.f * aCosThetaH / max (0.f, aCosDelta) * min (aCosThetaO, aCosThetaI));\n"
"\n"
" return aCosThetaO < 1.0e-3f ? ZERO :\n"
" aFraction * aGeom / (4.f * aCosThetaO) * aFresnel;\n"
"}\n" "}\n"
"\n" "\n"
"//=======================================================================\n" "//=======================================================================\n"
"// function : handleMaterial\n" "// function : HandleMaterial\n"
"// purpose : Returns BSDF value for specified material, with cos(N, PSI)\n" "// purpose : Returns BSDF value for specified material, with cos(N, PSI)\n"
"//=======================================================================\n" "//=======================================================================\n"
"vec3 handleMaterial (in SMaterial theMaterial, in vec3 theInput, in vec3 theOutput)\n" "vec3 HandleMaterial (in SMaterial theBSDF, in vec3 theInput, in vec3 theOutput)\n"
"{\n" "{\n"
" return theMaterial.Kd.rgb * handleLambertianReflection (theInput, theOutput) +\n" " return theBSDF.Kd.rgb * HandleLambertianReflection (theInput, theOutput) +\n"
" theMaterial.Ks.rgb * handleBlinnReflection (theInput, theOutput, theMaterial.Fresnel, theMaterial.Ks.w);\n" " theBSDF.Ks.rgb * HandleBlinnReflection (theInput, theOutput, theBSDF.Fresnel, theBSDF.Ks.w);\n"
"}\n" "}\n"
"\n" "\n"
"//=======================================================================\n" "//=======================================================================\n"
"// function : sampleLambertianReflection\n" "// function : SampleLambertianReflection\n"
"// purpose : Samples Lambertian BRDF, W = BRDF * cos(N, PSI) / PDF(PSI)\n" "// purpose : Samples Lambertian BRDF, W = BRDF * cos(N, PSI) / PDF(PSI)\n"
"//=======================================================================\n" "//=======================================================================\n"
"void sampleLambertianReflection (in vec3 theOutput, out vec3 theInput)\n" "vec3 SampleLambertianReflection (in vec3 theOutput, out vec3 theInput, inout float thePDF)\n"
"{\n" "{\n"
" float aKsi1 = RandFloat();\n" " float aKsi1 = RandFloat();\n"
" float aKsi2 = RandFloat();\n" " float aKsi2 = RandFloat();\n"
"\n" "\n"
" float aTemp = sqrt (aKsi2);\n" " float aTemp = sqrt (aKsi2);\n"
"\n" "\n"
" theInput = vec3 (aTemp * cos (2.f * M_PI * aKsi1),\n" " theInput = vec3 (aTemp * cos (M_2_PI * aKsi1),\n"
" aTemp * sin (2.f * M_PI * aKsi1),\n" " aTemp * sin (M_2_PI * aKsi1),\n"
" sqrt (1.f - aKsi2));\n" " sqrt (1.f - aKsi2));\n"
"\n" "\n"
" theInput.z = mix (-theInput.z, theInput.z, step (0.f, theOutput.z));\n" " thePDF *= abs (theInput.z) * (1.f / M_PI);\n"
"}\n"
"\n" "\n"
"// Types of bounces\n" " return (theInput.z <= 0.f || theOutput.z <= 0.f) ? ZERO : UNIT;\n"
"#define NON_SPECULAR_BOUNCE 0\n"
"#define SPEC_REFLECT_BOUNCE 1\n"
"#define SPEC_REFRACT_BOUNCE 2\n"
"\n"
"#define IS_NON_SPEC_BOUNCE(theBounce) (theBounce == 0)\n"
"#define IS_ANY_SPEC_BOUNCE(theBounce) (theBounce != 0)\n"
"#define IS_REFL_SPEC_BOUNCE(theBounce) (theBounce == 1)\n"
"#define IS_REFR_SPEC_BOUNCE(theBounce) (theBounce == 2)\n"
"\n"
"//=======================================================================\n"
"// function : sampleSpecularTransmission\n"
"// purpose : Samples specular BTDF, W = BRDF * cos(N, PSI) / PDF(PSI)\n"
"//=======================================================================\n"
"vec3 sampleSpecularTransmission (in vec3 theOutput, out vec3 theInput,\n"
" out int theBounce, in vec3 theWeight, in vec3 theFresnelCoeffs)\n"
"{\n"
" vec3 aFresnel = fresnelMedia (theOutput.z, theFresnelCoeffs);\n"
"\n"
" float aProbability = convolve (aFresnel, theWeight);\n"
"\n"
" // Check if transmission takes place\n"
" theBounce = RandFloat() <= aProbability ?\n"
" SPEC_REFLECT_BOUNCE : SPEC_REFRACT_BOUNCE;\n"
"\n"
" // Sample input direction\n"
" if (theBounce == SPEC_REFLECT_BOUNCE)\n"
" {\n"
" theInput = vec3 (-theOutput.x,\n"
" -theOutput.y,\n"
" theOutput.z);\n"
"\n"
" theWeight = aFresnel * (1.f / aProbability);\n"
" }\n"
" else\n"
" {\n"
" transmitted (theFresnelCoeffs.y, theOutput, theInput);\n"
"\n"
" theWeight = (UNIT - aFresnel) * (1.f / (1.f - aProbability));\n"
" }\n"
"\n"
" return theWeight;\n"
"}\n" "}\n"
"\n" "\n"
"//=======================================================================\n" "//=======================================================================\n"
"// function : sampleSpecularReflection\n" "// function : SampleBlinnReflection\n"
"// purpose : Samples specular BRDF, W = BRDF * cos(N, PSI) / PDF(PSI)\n"
"//=======================================================================\n"
"vec3 sampleSpecularReflection (in vec3 theOutput, out vec3 theInput, in vec3 theFresnelCoeffs)\n"
"{\n"
" // Sample input direction\n"
" theInput = vec3 (-theOutput.x,\n"
" -theOutput.y,\n"
" theOutput.z);\n"
"\n"
" return fresnelMedia (theOutput.z, theFresnelCoeffs);\n"
"}\n"
"\n"
"#define MIN_COS 1.0e-20f\n"
"\n"
"//=======================================================================\n"
"// function : sampleBlinnReflection\n"
"// purpose : Samples Blinn BRDF, W = BRDF * cos(N, PSI) / PDF(PSI)\n" "// purpose : Samples Blinn BRDF, W = BRDF * cos(N, PSI) / PDF(PSI)\n"
"// The BRDF is a product of three main terms, D, G, and F,\n" "// The BRDF is a product of three main terms, D, G, and F,\n"
"// which is then divided by two cosine terms. Here we perform\n" "// which is then divided by two cosine terms. Here we perform\n"
@ -392,155 +347,191 @@ static const char Shaders_PathtraceBase_fs[] =
"// terms would be complex, and it is the D term that accounts\n" "// terms would be complex, and it is the D term that accounts\n"
"// for most of the variation.\n" "// for most of the variation.\n"
"//=======================================================================\n" "//=======================================================================\n"
"vec3 sampleBlinnReflection (in vec3 theOutput, out vec3 theInput, in vec3 theFresnelCoeffs, in float theExponent)\n" "vec3 SampleBlinnReflection (in vec3 theOutput, out vec3 theInput, in vec3 theFresnel, in float theRoughness, inout float thePDF)\n"
"{\n" "{\n"
" vec3 aWeight = ZERO;\n"
"\n"
" // Generate two random variables\n"
" float aKsi1 = RandFloat();\n" " float aKsi1 = RandFloat();\n"
" float aKsi2 = RandFloat();\n" " float aKsi2 = RandFloat();\n"
"\n" "\n"
" // Compute sampled half-angle vector for Blinn distribution\n" " // roughness value --> Blinn exponent\n"
" float aCosThetaH = pow (aKsi1, 1.f / (theExponent + 1.f));\n" " float aPower = max (2.f / (theRoughness * theRoughness) - 2.f, 0.f);\n"
"\n" "\n"
" vec3 aHalf = sphericalDirection (aCosThetaH, aKsi2 * 2.f * M_PI);\n" " // normal from microface distribution\n"
" float aCosThetaM = pow (aKsi1, 1.f / (aPower + 2.f));\n"
"\n" "\n"
" if (aHalf.z < 0)\n" " vec3 aM = vec3 (cos (M_2_PI * aKsi2),\n"
" {\n" " sin (M_2_PI * aKsi2),\n"
" aHalf = -aHalf;\n" " aCosThetaM);\n"
" }\n"
"\n" "\n"
" // Compute incident direction by reflecting about half-vector\n" " aM.xy *= sqrt (1.f - aCosThetaM * aCosThetaM);\n"
" float aCosDelta = dot (theOutput, aHalf);\n"
"\n" "\n"
" vec3 anInput = 2.f * aCosDelta * aHalf - theOutput;\n" " // calculate PDF of sampled direction\n"
" thePDF *= (aPower + 2.f) * (1.f / M_2_PI) * pow (aCosThetaM, aPower + 1.f);\n"
"\n" "\n"
" if (theOutput.z * anInput.z <= 0.f)\n" " float aCosDelta = dot (theOutput, aM);\n"
"\n"
" // pick input based on half direction\n"
" theInput = -theOutput + 2.f * aCosDelta * aM;\n"
"\n"
" if (theInput.z <= 0.f || theOutput.z <= 0.f)\n"
" {\n" " {\n"
" return ZERO;\n" " return ZERO;\n"
" }\n" " }\n"
"\n" "\n"
" theInput = anInput;\n" " // Jacobian of half-direction mapping\n"
" thePDF /= 4.f * dot (theInput, aM);\n"
"\n" "\n"
" // Compute Fresnel reflectance\n" " // compute shadow-masking coefficient\n"
" vec3 aFresnel = fresnelMedia (aCosDelta, theFresnelCoeffs);\n" " float aG = SmithG1 (theOutput, aM, theRoughness) * SmithG1 (theInput, aM, theRoughness);\n"
"\n" "\n"
" // Compute geometry attenuation term\n" " return aG * aCosDelta / (theOutput.z * aM.z) * fresnelMedia (aCosDelta, theFresnel);\n"
" float aCosThetaI = max (MIN_COS, theInput.z);\n"
" float aCosThetaO = max (MIN_COS, theOutput.z);\n"
"\n"
" float aGeom = min (max (MIN_COS, aCosDelta), 2.f * aCosThetaH * min (aCosThetaO, aCosThetaI));\n"
"\n"
" // Compute weight of the ray sample\n"
" return aFresnel * ((theExponent + 2.f) / (theExponent + 1.f) * aGeom / aCosThetaO);\n"
"}\n" "}\n"
"\n" "\n"
"//=======================================================================\n" "//=======================================================================\n"
"// function : sampleMaterial\n" "// function : SampleSpecularReflection\n"
"// purpose : Samples specified composite material (BSDF)\n" "// purpose : Samples specular BRDF, W = BRDF * cos(N, PSI) / PDF(PSI)\n"
"//=======================================================================\n" "//=======================================================================\n"
"void sampleMaterial (in SMaterial theMaterial,\n" "vec3 SampleSpecularReflection (in vec3 theOutput, out vec3 theInput, in vec3 theFresnel)\n"
" in vec3 theOutput,\n"
" out vec3 theInput,\n"
" inout vec3 theWeight,\n"
" inout int theBounce)\n"
"{\n" "{\n"
" // Compute the probability of ray reflection\n" " // Sample input direction\n"
" float aPd = convolve (theMaterial.Kd.rgb, theWeight);\n" " theInput = vec3 (-theOutput.x,\n"
" float aPs = convolve (theMaterial.Ks.rgb, theWeight);\n" " -theOutput.y,\n"
" float aPr = convolve (theMaterial.Kr.rgb, theWeight);\n" " theOutput.z);\n"
" float aPt = convolve (theMaterial.Kt.rgb, theWeight);\n" "\n"
" return fresnelMedia (theOutput.z, theFresnel);\n"
"}\n"
"\n"
"//=======================================================================\n"
"// function : SampleSpecularTransmission\n"
"// purpose : Samples specular BTDF, W = BRDF * cos(N, PSI) / PDF(PSI)\n"
"//=======================================================================\n"
"vec3 SampleSpecularTransmission (in vec3 theOutput,\n"
" out vec3 theInput, in vec3 theWeight, in vec3 theFresnel, inout bool theInside)\n"
"{\n"
" vec3 aFactor = fresnelMedia (theOutput.z, theFresnel);\n"
"\n"
" float aReflection = convolve (aFactor, theWeight);\n"
"\n"
" // sample specular BRDF/BTDF\n"
" if (RandFloat() <= aReflection)\n"
" {\n"
" theInput = vec3 (-theOutput.x,\n"
" -theOutput.y,\n"
" theOutput.z);\n"
"\n"
" theWeight = aFactor * (1.f / aReflection);\n"
" }\n"
" else\n"
" {\n"
" theInside = !theInside;\n"
"\n"
" transmitted (theFresnel.y, theOutput, theInput);\n"
"\n"
" theWeight = (UNIT - aFactor) * (1.f / (1.f - aReflection));\n"
" }\n"
"\n"
" return theWeight;\n"
"}\n"
"\n"
"#define FLT_EPSILON 1.0e-5F\n"
"\n"
"//=======================================================================\n"
"// function : BsdfPdf\n"
"// purpose : Calculates BSDF of sampling input knowing output\n"
"//=======================================================================\n"
"float BsdfPdf (in SMaterial theBSDF,\n"
" in vec3 theOutput,\n"
" in vec3 theInput,\n"
" in vec3 theWeight)\n"
"{\n"
" float aPd = convolve (theBSDF.Kd.rgb, theWeight);\n"
" float aPs = convolve (theBSDF.Ks.rgb, theWeight);\n"
" float aPr = convolve (theBSDF.Kr.rgb, theWeight);\n"
" float aPt = convolve (theBSDF.Kt.rgb, theWeight);\n"
"\n" "\n"
" float aReflection = aPd + aPs + aPr + aPt;\n" " float aReflection = aPd + aPs + aPr + aPt;\n"
"\n" "\n"
" // Choose BSDF component to sample\n" " float aPDF = 0.f; // PDF of sampling input direction\n"
"\n"
" if (theInput.z * theOutput.z > 0.f)\n"
" {\n"
" vec3 aHalf = normalize (theInput + theOutput);\n"
"\n"
" // roughness value --> Blinn exponent\n"
" float aPower = max (2.f / (theBSDF.Ks.w * theBSDF.Ks.w) - 2.f, 0.f);\n"
"\n"
" aPDF = aPd * abs (theInput.z / M_PI) +\n"
" aPs * (aPower + 2.f) * (1.f / M_2_PI) * pow (aHalf.z, aPower + 1.f) / (4.f * dot (theInput, aHalf));\n"
" }\n"
"\n"
" return aPDF / aReflection;\n"
"}\n"
"\n"
"//! Tool macro to handle sampling of particular BxDF\n"
"#define PICK_BXDF(p, k) aPDF = p / aReflection; theWeight *= k / aPDF;\n"
"\n"
"//=======================================================================\n"
"// function : SampleBsdf\n"
"// purpose : Samples specified composite material (BSDF)\n"
"//=======================================================================\n"
"float SampleBsdf (in SMaterial theBSDF,\n"
" in vec3 theOutput,\n"
" out vec3 theInput,\n"
" inout vec3 theWeight,\n"
" inout bool theInside)\n"
"{\n"
" // compute probability of each reflection type (BxDF)\n"
" float aPd = convolve (theBSDF.Kd.rgb, theWeight);\n"
" float aPs = convolve (theBSDF.Ks.rgb, theWeight);\n"
" float aPr = convolve (theBSDF.Kr.rgb, theWeight);\n"
" float aPt = convolve (theBSDF.Kt.rgb, theWeight);\n"
"\n"
" float aReflection = aPd + aPs + aPr + aPt;\n"
"\n"
" // choose BxDF component to sample\n"
" float aKsi = aReflection * RandFloat();\n" " float aKsi = aReflection * RandFloat();\n"
"\n" "\n"
" theBounce = NON_SPECULAR_BOUNCE;\n" " // BxDF's PDF of sampled direction\n"
" float aPDF = 0.f;\n"
"\n" "\n"
" if (aKsi < aPd) // diffuse reflection\n" " if (aKsi < aPd) // diffuse reflection\n"
" {\n" " {\n"
" sampleLambertianReflection (theOutput, theInput);\n" " PICK_BXDF (aPd, theBSDF.Kd.rgb);\n"
"\n" "\n"
" theWeight *= theMaterial.Kd.rgb * (aReflection / aPd);\n" " theWeight *= SampleLambertianReflection (theOutput, theInput, aPDF);\n"
" }\n" " }\n"
" else if (aKsi < aPd + aPs) // glossy reflection\n" " else if (aKsi < aPd + aPs) // glossy reflection\n"
" {\n" " {\n"
" theWeight *= theMaterial.Ks.rgb * (aReflection / aPs) *\n" " PICK_BXDF (aPs, theBSDF.Ks.rgb);\n"
" sampleBlinnReflection (theOutput, theInput, theMaterial.Fresnel, theMaterial.Ks.w);\n"
" }\n"
" else if (aKsi < aPd + aPs + aPr) // specular reflection\n"
" {\n"
" theWeight *= theMaterial.Kr.rgb * (aReflection / aPr) *\n"
" sampleSpecularReflection (theOutput, theInput, theMaterial.Fresnel);\n"
"\n" "\n"
" theBounce = SPEC_REFLECT_BOUNCE; // specular bounce\n" " theWeight *= SampleBlinnReflection (theOutput, theInput, theBSDF.Fresnel, theBSDF.Ks.w, aPDF);\n"
" }\n" " }\n"
" else // specular transmission\n" " else if (aKsi < aPd + aPs + aPr) // specular reflection\n"
" {\n" " {\n"
" theWeight *= theMaterial.Kt.rgb * (aReflection / aPt) *\n" " PICK_BXDF (aPr, theBSDF.Kr.rgb);\n"
" sampleSpecularTransmission (theOutput, theInput, theBounce, theWeight, theMaterial.Fresnel);\n" "\n"
" aPDF = MAXFLOAT;\n"
"\n"
" theWeight *= SampleSpecularReflection (theOutput, theInput, theBSDF.Fresnel);\n"
" }\n"
" else if (aKsi < aReflection) // specular transmission\n"
" {\n"
" PICK_BXDF (aPt, theBSDF.Kt.rgb);\n"
"\n"
" aPDF = MAXFLOAT;\n"
"\n"
" theWeight *= SampleSpecularTransmission (theOutput, theInput, theWeight, theBSDF.Fresnel, theInside);\n"
" }\n" " }\n"
"\n" "\n"
" // path termination for extra small weights\n" " // path termination for extra small weights\n"
" theWeight = mix (theWeight, ZERO, float (aReflection < 1e-3f));\n" " theWeight = mix (ZERO, theWeight, step (FLT_EPSILON, aReflection));\n"
"\n"
" return aPDF;\n"
"}\n" "}\n"
"\n" "\n"
"//////////////////////////////////////////////////////////////////////////////////////////////\n" "//////////////////////////////////////////////////////////////////////////////////////////////\n"
"// Handlers and samplers for light sources\n" "// Handlers and samplers for light sources\n"
"//////////////////////////////////////////////////////////////////////////////////////////////\n" "//////////////////////////////////////////////////////////////////////////////////////////////\n"
"\n" "\n"
"//=======================================================================\n"
"// function : handlePointLight\n"
"// purpose :\n"
"//=======================================================================\n"
"float handlePointLight (in vec3 theInput, in vec3 theToLight, in float theRadius, in float theDistance)\n"
"{\n"
" float aDistance = dot (theToLight, theToLight);\n"
"\n"
" float aCosMax = inversesqrt (1.f + theRadius * theRadius / aDistance);\n"
"\n"
" return float (aDistance < theDistance * theDistance) *\n"
" step (aCosMax, dot (theToLight, theInput) * inversesqrt (aDistance));\n"
"}\n"
"\n"
"//=======================================================================\n"
"// function : handleDirectLight\n"
"// purpose :\n"
"//=======================================================================\n"
"float handleDirectLight (in vec3 theInput, in vec3 theToLight, in float theCosMax)\n"
"{\n"
" return step (theCosMax, dot (theInput, theToLight));\n"
"}\n"
"\n"
"//=======================================================================\n"
"// function : sampleLight\n"
"// purpose : General sampling function for directional and point lights\n"
"//=======================================================================\n"
"vec3 sampleLight (in vec3 theToLight, inout float theDistance, in bool isInfinite, in float theSmoothness, inout float thePDF)\n"
"{\n"
" SLocalSpace aSpace = LocalSpace (theToLight * (1.f / theDistance));\n"
"\n"
" // for point lights smoothness defines radius\n"
" float aCosMax = isInfinite ? theSmoothness :\n"
" inversesqrt (1.f + theSmoothness * theSmoothness / (theDistance * theDistance));\n"
"\n"
" float aKsi1 = RandFloat();\n"
" float aKsi2 = RandFloat();\n"
"\n"
" float aTmp = 1.f - aKsi2 * (1.f - aCosMax);\n"
"\n"
" vec3 anInput = vec3 (cos (2.f * M_PI * aKsi1),\n"
" sin (2.f * M_PI * aKsi1),\n"
" aTmp);\n"
"\n"
" anInput.xy *= sqrt (1.f - aTmp * aTmp);\n"
"\n"
" thePDF *= (aCosMax < 1.f) ? 1.f / (2.f * M_PI) / (1.f - aCosMax) : 1.f;\n"
"\n"
" return normalize (fromLocalSpace (anInput, aSpace));\n"
"}\n"
"\n"
"// =======================================================================\n" "// =======================================================================\n"
"// function : Latlong\n" "// function : Latlong\n"
"// purpose : Converts world direction to environment texture coordinates\n" "// purpose : Converts world direction to environment texture coordinates\n"
@ -555,49 +546,128 @@ static const char Shaders_PathtraceBase_fs[] =
" aPsi * 0.3183098f);\n" " aPsi * 0.3183098f);\n"
"}\n" "}\n"
"\n" "\n"
"//=======================================================================\n"
"// function : SampleLight\n"
"// purpose : General sampling function for directional and point lights\n"
"//=======================================================================\n"
"vec3 SampleLight (in vec3 theToLight, inout float theDistance, in bool isInfinite, in float theSmoothness, inout float thePDF)\n"
"{\n"
" SLocalSpace aSpace = buildLocalSpace (theToLight * (1.f / theDistance));\n"
"\n"
" // for point lights smoothness defines radius\n"
" float aCosMax = isInfinite ? theSmoothness :\n"
" inversesqrt (1.f + theSmoothness * theSmoothness / (theDistance * theDistance));\n"
"\n"
" float aKsi1 = RandFloat();\n"
" float aKsi2 = RandFloat();\n"
"\n"
" float aTmp = 1.f - aKsi2 * (1.f - aCosMax);\n"
"\n"
" vec3 anInput = vec3 (cos (M_2_PI * aKsi1),\n"
" sin (M_2_PI * aKsi1),\n"
" aTmp);\n"
"\n"
" anInput.xy *= sqrt (1.f - aTmp * aTmp);\n"
"\n"
" thePDF = (aCosMax < 1.f) ? (thePDF / M_2_PI) / (1.f - aCosMax) : MAXFLOAT;\n"
"\n"
" return normalize (fromLocalSpace (anInput, aSpace));\n"
"}\n"
"\n"
"//=======================================================================\n"
"// function : HandlePointLight\n"
"// purpose :\n"
"//=======================================================================\n"
"float HandlePointLight (in vec3 theInput, in vec3 theToLight, in float theRadius, in float theDistance, inout float thePDF)\n"
"{\n"
" float aCosMax = inversesqrt (1.f + theRadius * theRadius / (theDistance * theDistance));\n"
"\n"
" float aVisibility = step (aCosMax, dot (theInput, theToLight));\n"
"\n"
" thePDF *= step (-1.f, -aCosMax) * aVisibility * (1.f / M_2_PI) / (1.f - aCosMax);\n"
"\n"
" return aVisibility;\n"
"}\n"
"\n"
"//=======================================================================\n"
"// function : HandleDistantLight\n"
"// purpose :\n"
"//=======================================================================\n"
"float HandleDistantLight (in vec3 theInput, in vec3 theToLight, in float theCosMax, inout float thePDF)\n"
"{\n"
" float aVisibility = step (theCosMax, dot (theInput, theToLight));\n"
"\n"
" thePDF *= step (-1.f, -theCosMax) * aVisibility * (1.f / M_2_PI) / (1.f - theCosMax);\n"
"\n"
" return aVisibility;\n"
"}\n"
"\n"
"// =======================================================================\n" "// =======================================================================\n"
"// function: intersectLight\n" "// function: IntersectLight\n"
"// purpose : Checks intersections with light sources\n" "// purpose : Checks intersections with light sources\n"
"// =======================================================================\n" "// =======================================================================\n"
"vec3 intersectLight (in SRay theRay, in bool isViewRay, in int theBounce, in float theDistance)\n" "vec3 IntersectLight (in SRay theRay, in int theDepth, in float theHitDistance, out float thePDF)\n"
"{\n" "{\n"
" vec3 aRadiance = ZERO;\n" " vec3 aTotalRadiance = ZERO;\n"
"\n" "\n"
" if ((isViewRay || IS_REFR_SPEC_BOUNCE(theBounce)) && uSphereMapForBack == 0)\n" " thePDF = 0.f; // PDF of sampling light sources\n"
" {\n"
" aRadiance = BackgroundColor().xyz;\n"
" }\n"
" else\n"
" {\n"
" aRadiance = FetchEnvironment (Latlong (theRay.Direct)).xyz;\n"
" }\n"
"\n" "\n"
" // Apply gamma correction (gamma is 2)\n" " for (int aLightIdx = 0; aLightIdx < uLightCount; ++aLightIdx)\n"
" aRadiance = aRadiance * aRadiance * float (theDistance == MAXFLOAT);\n"
"\n"
" for (int aLightIdx = 0; aLightIdx < uLightCount && (isViewRay || IS_ANY_SPEC_BOUNCE(theBounce)); ++aLightIdx)\n"
" {\n" " {\n"
" vec4 aLight = texelFetch (\n" " vec4 aLight = texelFetch (\n"
" uRaytraceLightSrcTexture, LIGHT_POS (aLightIdx));\n" " uRaytraceLightSrcTexture, LIGHT_POS (aLightIdx));\n"
" vec4 aParam = texelFetch (\n" " vec4 aParam = texelFetch (\n"
" uRaytraceLightSrcTexture, LIGHT_PWR (aLightIdx));\n" " uRaytraceLightSrcTexture, LIGHT_PWR (aLightIdx));\n"
"\n" "\n"
" // W component: 0 for infinite light and 1 for point light\n"
" aLight.xyz -= mix (ZERO, theRay.Origin, aLight.w);\n"
"\n"
" float aPDF = 1.f / uLightCount;\n"
"\n"
" if (aLight.w != 0.f) // point light source\n" " if (aLight.w != 0.f) // point light source\n"
" {\n" " {\n"
" aRadiance += aParam.rgb * handlePointLight (\n" " float aCenterDst = length (aLight.xyz);\n"
" theRay.Direct, aLight.xyz - theRay.Origin, aParam.w /* radius */, theDistance);\n" "\n"
" if (aCenterDst < theHitDistance)\n"
" {\n"
" float aVisibility = HandlePointLight (\n"
" theRay.Direct, normalize (aLight.xyz), aParam.w /* radius */, aCenterDst, aPDF);\n"
"\n"
" if (aVisibility > 0.f)\n"
" {\n"
" theHitDistance = aCenterDst;\n"
" aTotalRadiance = aParam.rgb;\n"
"\n"
" thePDF = aPDF;\n"
" }\n"
" }\n"
" }\n" " }\n"
" else if (theDistance == MAXFLOAT) // directional light source\n" " else if (theHitDistance == MAXFLOAT) // directional light source\n"
" {\n" " {\n"
" aRadiance += aParam.rgb * handleDirectLight (theRay.Direct, aLight.xyz, aParam.w /* angle cosine */);\n" " aTotalRadiance += aParam.rgb * HandleDistantLight (\n"
" theRay.Direct, aLight.xyz, aParam.w /* angle cosine */, aPDF);\n"
"\n"
" thePDF += aPDF;\n"
" }\n" " }\n"
" }\n" " }\n"
"\n" "\n"
" return aRadiance;\n" " if (thePDF == 0.f && theHitDistance == MAXFLOAT) // light source not found\n"
" {\n"
" if (theDepth + uSphereMapForBack == 0) // view ray and map is hidden\n"
" {\n"
" aTotalRadiance = pow (BackgroundColor().rgb, vec3 (2.f));\n"
" }\n"
" else\n"
" {\n"
" aTotalRadiance = pow (FetchEnvironment (Latlong (theRay.Direct)).rgb, vec3 (2.f));\n"
" }\n"
" }\n"
" \n"
" return aTotalRadiance;\n"
"}\n" "}\n"
"\n" "\n"
"#define MIN_THROUGHPUT vec3 (0.02f)\n" "#define MIN_THROUGHPUT vec3 (1.0e-3f)\n"
"#define MIN_CONTRIBUTION vec3 (0.01f)\n" "#define MIN_CONTRIBUTION vec3 (1.0e-2f)\n"
"\n" "\n"
"#define MATERIAL_KD(index) (18 * index + 11)\n" "#define MATERIAL_KD(index) (18 * index + 11)\n"
"#define MATERIAL_KR(index) (18 * index + 12)\n" "#define MATERIAL_KR(index) (18 * index + 12)\n"
@ -621,29 +691,32 @@ static const char Shaders_PathtraceBase_fs[] =
" vec3 aRadiance = ZERO;\n" " vec3 aRadiance = ZERO;\n"
" vec3 aThroughput = UNIT;\n" " vec3 aThroughput = UNIT;\n"
"\n" "\n"
" int aBounce = 0; // type of previous hit point\n" " int aTransfID = 0; // ID of object transformation\n"
" int aTrsfId = 0; // offset of object transform\n" " bool aInMedium = false; // is the ray inside an object\n"
"\n" "\n"
" bool isInMedium = false;\n" " float aExpPDF = 1.f;\n"
" float aImpPDF = 1.f;\n"
"\n" "\n"
" for (int aDepth = 0; aDepth < NB_BOUNCES; ++aDepth)\n" " for (int aDepth = 0; aDepth < NB_BOUNCES; ++aDepth)\n"
" {\n" " {\n"
" SIntersect aHit = SIntersect (MAXFLOAT, vec2 (ZERO), ZERO);\n" " SIntersect aHit = SIntersect (MAXFLOAT, vec2 (ZERO), ZERO);\n"
"\n" "\n"
" ivec4 aTriIndex = SceneNearestHit (theRay, theInverse, aHit, aTrsfId);\n" " ivec4 aTriIndex = SceneNearestHit (theRay, theInverse, aHit, aTransfID);\n"
"\n" "\n"
" // check implicit path\n" " // check implicit path\n"
" vec3 aLe = intersectLight (theRay,\n" " vec3 aLe = IntersectLight (theRay, aDepth, aHit.Time, aExpPDF);\n"
" aDepth == 0 /* is view ray */, aBounce, aHit.Time);\n"
"\n" "\n"
" if (any (greaterThan (aLe, ZERO)) || aTriIndex.x == -1)\n" " if (any (greaterThan (aLe, ZERO)) || aTriIndex.x == -1)\n"
" {\n" " {\n"
" aRadiance += aThroughput * aLe; break; // terminate path\n" " float aMIS = (aDepth == 0 || aImpPDF == MAXFLOAT) ? 1.f :\n"
" aImpPDF * aImpPDF / (aExpPDF * aExpPDF + aImpPDF * aImpPDF);\n"
"\n"
" aRadiance += aThroughput * aLe * aMIS; break; // terminate path\n"
" }\n" " }\n"
"\n" "\n"
" vec3 aInvTransf0 = texelFetch (uSceneTransformTexture, aTrsfId + 0).xyz;\n" " vec3 aInvTransf0 = texelFetch (uSceneTransformTexture, aTransfID + 0).xyz;\n"
" vec3 aInvTransf1 = texelFetch (uSceneTransformTexture, aTrsfId + 1).xyz;\n" " vec3 aInvTransf1 = texelFetch (uSceneTransformTexture, aTransfID + 1).xyz;\n"
" vec3 aInvTransf2 = texelFetch (uSceneTransformTexture, aTrsfId + 2).xyz;\n" " vec3 aInvTransf2 = texelFetch (uSceneTransformTexture, aTransfID + 2).xyz;\n"
"\n" "\n"
" // compute geometrical normal\n" " // compute geometrical normal\n"
" aHit.Normal = normalize (vec3 (dot (aInvTransf0, aHit.Normal),\n" " aHit.Normal = normalize (vec3 (dot (aInvTransf0, aHit.Normal),\n"
@ -652,7 +725,7 @@ static const char Shaders_PathtraceBase_fs[] =
"\n" "\n"
" theRay.Origin += theRay.Direct * aHit.Time; // get new intersection point\n" " theRay.Origin += theRay.Direct * aHit.Time; // get new intersection point\n"
"\n" "\n"
" // Evaluate depth on first hit\n" " // evaluate depth on first hit\n"
" if (aDepth == 0)\n" " if (aDepth == 0)\n"
" {\n" " {\n"
" vec4 aNDCPoint = uViewMat * vec4 (theRay.Origin, 1.f);\n" " vec4 aNDCPoint = uViewMat * vec4 (theRay.Origin, 1.f);\n"
@ -697,7 +770,7 @@ static const char Shaders_PathtraceBase_fs[] =
" dot (aInvTransf1, aNormal),\n" " dot (aInvTransf1, aNormal),\n"
" dot (aInvTransf2, aNormal)));\n" " dot (aInvTransf2, aNormal)));\n"
"\n" "\n"
" SLocalSpace aSpace = LocalSpace (aNormal);\n" " SLocalSpace aSpace = buildLocalSpace (aNormal);\n"
"\n" "\n"
" // account for self-emission (not stored in the material)\n" " // account for self-emission (not stored in the material)\n"
" aRadiance += aThroughput * texelFetch (\n" " aRadiance += aThroughput * texelFetch (\n"
@ -705,6 +778,8 @@ static const char Shaders_PathtraceBase_fs[] =
"\n" "\n"
" if (uLightCount > 0 && convolve (aMaterial.Kd.rgb + aMaterial.Ks.rgb, aThroughput) > 0.f)\n" " if (uLightCount > 0 && convolve (aMaterial.Kd.rgb + aMaterial.Ks.rgb, aThroughput) > 0.f)\n"
" {\n" " {\n"
" aExpPDF = 1.f / uLightCount;\n"
"\n"
" int aLightIdx = min (int (floor (RandFloat() * uLightCount)), uLightCount - 1);\n" " int aLightIdx = min (int (floor (RandFloat() * uLightCount)), uLightCount - 1);\n"
"\n" "\n"
" vec4 aLight = texelFetch (\n" " vec4 aLight = texelFetch (\n"
@ -715,15 +790,21 @@ static const char Shaders_PathtraceBase_fs[] =
" // 'w' component is 0 for infinite light and 1 for point light\n" " // 'w' component is 0 for infinite light and 1 for point light\n"
" aLight.xyz -= mix (ZERO, theRay.Origin, aLight.w);\n" " aLight.xyz -= mix (ZERO, theRay.Origin, aLight.w);\n"
"\n" "\n"
" float aPDF = 1.f / uLightCount, aDistance = length (aLight.xyz);\n" " float aDistance = length (aLight.xyz);\n"
"\n" "\n"
" aLight.xyz = sampleLight (aLight.xyz, aDistance,\n" " aLight.xyz = SampleLight (aLight.xyz, aDistance,\n"
" aLight.w == 0.f /* is infinite */, aParam.w /* max cos or radius */, aPDF);\n" " aLight.w == 0.f /* is infinite */, aParam.w /* max cos or radius */, aExpPDF);\n"
"\n" "\n"
" vec3 aContrib = (1.f / aPDF) * aParam.rgb /* Le */ * handleMaterial (\n" " aImpPDF = BsdfPdf (aMaterial,\n"
" toLocalSpace (-theRay.Direct, aSpace), toLocalSpace (aLight.xyz, aSpace), aThroughput);\n"
"\n"
" // MIS weight including division by explicit PDF\n"
" float aMIS = (aExpPDF == MAXFLOAT) ? 1.f : aExpPDF / (aExpPDF * aExpPDF + aImpPDF * aImpPDF);\n"
"\n"
" vec3 aContrib = aMIS * aParam.rgb /* Le */ * HandleMaterial (\n"
" aMaterial, toLocalSpace (aLight.xyz, aSpace), toLocalSpace (-theRay.Direct, aSpace));\n" " aMaterial, toLocalSpace (aLight.xyz, aSpace), toLocalSpace (-theRay.Direct, aSpace));\n"
"\n" "\n"
" if (any (greaterThan (aContrib, MIN_CONTRIBUTION))) // first check if light source is important\n" " if (any (greaterThan (aContrib, MIN_CONTRIBUTION))) // check if light source is important\n"
" {\n" " {\n"
" SRay aShadow = SRay (theRay.Origin + aLight.xyz * uSceneEpsilon, aLight.xyz);\n" " SRay aShadow = SRay (theRay.Origin + aLight.xyz * uSceneEpsilon, aLight.xyz);\n"
"\n" "\n"
@ -737,32 +818,29 @@ static const char Shaders_PathtraceBase_fs[] =
" }\n" " }\n"
" }\n" " }\n"
"\n" "\n"
" vec3 anInput;\n" " if (aInMedium) // handle attenuation\n"
"\n"
" sampleMaterial (aMaterial,\n"
" toLocalSpace (-theRay.Direct, aSpace), anInput, aThroughput, aBounce);\n"
"\n"
" if (isInMedium)\n"
" {\n" " {\n"
" aThroughput *= exp (-aHit.Time *\n" " aThroughput *= exp (-aHit.Time *\n"
" aMaterial.Absorption.w * (UNIT - aMaterial.Absorption.rgb));\n" " aMaterial.Absorption.w * (UNIT - aMaterial.Absorption.rgb));\n"
" }\n" " }\n"
"\n" "\n"
" isInMedium = IS_REFR_SPEC_BOUNCE(aBounce) ? !isInMedium : isInMedium;\n" " vec3 anInput = UNIT; // sampled input direction\n"
"\n" "\n"
"#ifndef RUSSIAN_ROULETTE\n" " aImpPDF = SampleBsdf (aMaterial,\n"
" if (all (lessThan (aThroughput, MIN_THROUGHPUT)))\n" " toLocalSpace (-theRay.Direct, aSpace), anInput, aThroughput, aInMedium);\n"
" {\n"
" aDepth = INVALID_BOUNCES; // terminate path\n"
" }\n"
"#else\n"
" float aSurvive = aDepth < 3 ? 1.f : min (dot (LUMA, aThroughput), 0.95f);\n"
"\n" "\n"
" if (RandFloat() > aSurvive)\n" " float aSurvive = 1.f;\n"
"\n"
"#ifdef RUSSIAN_ROULETTE\n"
" aSurvive = aDepth < 3 ? 1.f : min (dot (LUMA, aThroughput), 0.95f);\n"
"#endif\n"
"\n"
" if (RandFloat() > aSurvive || all (lessThanEqual (aThroughput, MIN_THROUGHPUT)))\n"
" {\n" " {\n"
" aDepth = INVALID_BOUNCES; // terminate path\n" " aDepth = INVALID_BOUNCES; // terminate path\n"
" }\n" " }\n"
"\n" "\n"
"#ifdef RUSSIAN_ROULETTE\n"
" aThroughput /= aSurvive;\n" " aThroughput /= aSurvive;\n"
"#endif\n" "#endif\n"
"\n" "\n"

12
src/Shaders/Shaders_RaytraceBase_fs.pxx
View File

@ -146,7 +146,9 @@ static const char Shaders_RaytraceBase_fs[] =
"#define AXIS_Y vec3 (0.0f, 1.0f, 0.0f)\n" "#define AXIS_Y vec3 (0.0f, 1.0f, 0.0f)\n"
"#define AXIS_Z vec3 (0.0f, 0.0f, 1.0f)\n" "#define AXIS_Z vec3 (0.0f, 0.0f, 1.0f)\n"
"\n" "\n"
"#define M_PI 3.14159265f\n" "#define M_PI 3.141592653f\n"
"#define M_2_PI 6.283185307f\n"
"#define M_PI_2 1.570796327f\n"
"\n" "\n"
"#define LUMA vec3 (0.2126f, 0.7152f, 0.0722f)\n" "#define LUMA vec3 (0.2126f, 0.7152f, 0.0722f)\n"
"\n" "\n"
@ -838,8 +840,8 @@ static const char Shaders_RaytraceBase_fs[] =
"// =======================================================================\n" "// =======================================================================\n"
"vec4 FetchEnvironment (in vec2 theTexCoord)\n" "vec4 FetchEnvironment (in vec2 theTexCoord)\n"
"{\n" "{\n"
" return mix (vec4 (0.0f, 0.0f, 0.0f, 1.0f),\n" " return uSphereMapEnabled == 0 ?\n"
" textureLod (uEnvironmentMapTexture, theTexCoord, 0.0f), float (uSphereMapEnabled));\n" " vec4 (0.f, 0.f, 0.f, 1.f) : textureLod (uEnvironmentMapTexture, theTexCoord, 0.f);\n"
"}\n" "}\n"
"\n" "\n"
"// =======================================================================\n" "// =======================================================================\n"
@ -1023,8 +1025,8 @@ static const char Shaders_RaytraceBase_fs[] =
"\n" "\n"
" if (aVisibility > 0.0f)\n" " if (aVisibility > 0.0f)\n"
" {\n" " {\n"
" vec3 aIntensity = vec3 (texelFetch (\n" " vec3 aIntensity = min (UNIT, vec3 (texelFetch (\n"
" uRaytraceLightSrcTexture, LIGHT_PWR (aLightIdx)));\n" " uRaytraceLightSrcTexture, LIGHT_PWR (aLightIdx))));\n"
"\n" "\n"
" float aRdotV = dot (reflect (aLight.xyz, aSidedNormal), theRay.Direct);\n" " float aRdotV = dot (reflect (aLight.xyz, aSidedNormal), theRay.Direct);\n"
"\n" "\n"

2
src/Shaders/Shaders_RaytraceRender_fs.pxx
View File

@ -21,7 +21,7 @@ static const char Shaders_RaytraceRender_fs[] =
"\n" "\n"
"//! Maximum radiance that can be added to the pixel. Decreases noise\n" "//! Maximum radiance that can be added to the pixel. Decreases noise\n"
"//! level, but introduces some bias.\n" "//! level, but introduces some bias.\n"
"#define MAX_RADIANCE vec3 (25.f)\n" "#define MAX_RADIANCE vec3 (50.f)\n"
"\n" "\n"
"// =======================================================================\n" "// =======================================================================\n"
"// function : main\n" "// function : main\n"

2
src/V3d/V3d_DirectionalLight.cxx
View File

@ -70,6 +70,8 @@ V3d_DirectionalLight::V3d_DirectionalLight (const Handle(V3d_Viewer)& theViewer,
SetHeadlight (theIsHeadlight); SetHeadlight (theIsHeadlight);
SetTarget (0., 0., 0.); SetTarget (0., 0., 0.);
SetPosition (-aV.X(), -aV.Y(), -aV.Z()); SetPosition (-aV.X(), -aV.Y(), -aV.Z());
SetSmoothAngle (0.2);
SetIntensity (20.0);
} }
// ======================================================================= // =======================================================================

7
tests/v3d/raytrace/sample_ball Normal file
View File

@ -0,0 +1,7 @@
puts "============"
puts "Visualization - Path Tracing, Ball sample"
puts "============"
puts ""
source $env(CSF_OCCTSamplesPath)/tcl/pathtrace_ball.tcl
vdump $imagedir/${casename}_zoom.png

6
tests/v3d/raytrace/sample_cube Normal file
View File

@ -0,0 +1,6 @@
puts "============"
puts "Visualization - Path Tracing, Cube sample"
puts "============"
puts ""
source $env(CSF_OCCTSamplesPath)/tcl/pathtrace_cube.tcl