没有递归光线追踪就不可能实现反射和折射?
我正在使用 GLSL 计算着色器编写基于 GPU 的实时光线追踪渲染器.到目前为止，它工作得非常好，但是当涉及同时具有反射和折射时，我偶然发现了一个看似无法解决的问题.
我的逻辑告诉我，为了在物体(例如玻璃)上产生反射和折射，光线必须分成两股，一条光线从表面反射，另一条光线通过表面折射.然后，这些光线的最终颜色将根据某些函数进行组合，并最终用作光线源自的像素的颜色.我遇到的问题是我无法在着色器代码中分割光线，因为我必须使用递归来这样做.据我了解，着色器中的函数不能递归，因为由于与旧 GPU 硬件的兼容性问题，所有 GLSL 函数都类似于 C++ 中的内联函数.
是否可以在着色器代码中模拟或伪造递归，或者我什至可以在完全不使用递归的情况下同时实现反射和折射?如果没有递归，我看不到它是如何发生的，但我可能错了.
解决方案我设法将 back-raytracing 转换为适合 GLSL 的迭代过程评论.它远未优化，我还没有实现所有物理东西(没有斯涅尔定律等......)，但作为概念证明，它已经起作用了.我在片段着色器和 CPU 侧代码中完成所有工作，只需发送 uniforms 常量和场景，以 32 位非钳位浮动纹理 的形式GL_LUMINANCE32F_ARB 渲染只是单个QUAD 覆盖整个屏幕.
- 经过现场
我决定将场景存储在纹理中，这样每条光线/片段都可以直接访问整个场景.纹理是 2D，但它用作 32 位浮点数的线性列表.我决定了这种格式:
枚举 _fac_type_enum{_fac_triangles=0,//r,g,b,a, n, 三角形计数, { x0,y0,z0,x1,y1,z1,x2,y2,z2 }_fac_spheres,//r,g,b,a, n, 球体计数, { x,y,z,r }};常量 GLfloat _n_glass=1.561;常量 GLfloat _n_vacuum=1.0;GL浮动数据[]={//r、g、b、a、n、类型、计数0.2,0.3,0.5,0.5,_n_glass,_fac_triangles, 4,//四面体//px, py, pz, r, g, b-0.5,-0.5,+1.0,0.0,+0.5,+1.0,+0.5,-0.5,+1.0,0.0, 0.0,+0.5,-0.5,-0.5,+1.0,0.0,+0.5,+1.0,0.0, 0.0,+0.5,0.0,+0.5,+1.0,+0.5,-0.5,+1.0,0.0, 0.0,+0.5,+0.5,-0.5,+1.0,-0.5,-0.5,+1.0,};您可以添加/更改任何类型的对象.这个例子只包含一个半透明的蓝色四面体.您还可以为材料属性等添加变换矩阵更多系数...
- 架构
顶点着色器只是初始化视图的角射线(开始位置和方向)，它被插值，因此每个片段代表反向光线追踪过程的开始光线.
迭代反向光线追踪
所以我创建了一个静态"；射线列表并使用起始射线初始化它.迭代分两步完成，首先是背面光线追踪:
- 循环遍历列表中的所有光线从第一个开始
- 找到最近的路口与场景...
将位置、表面法线和材质属性存储到射线struct
- 如果找到交集并且不是最后的递归"；层将反射/折射光线添加到最后的列表中.
还将它们的索引存储到已处理的射线struct
现在您的光线应该包含重建颜色所需的所有相交信息.为此:
- 向后循环所有递归级别
- 每条光线与实际递归层匹配
- 计算光线颜色
所以使用你想要的照明方程.如果光线包含子元素，则根据材料属性(反射和折射系数...)将其颜色添加到结果中
现在第一条光线应该包含您要输出的颜色.
使用的制服:
tm_eye查看相机矩阵
aspect查看ys/xs纵横比
n0 空白空间折射率(未使用)
focal_length 相机焦距
fac_siz 场景正方形纹理的分辨率
fac_num 场景纹理中实际使用的浮点数
fac_txr 场景纹理的纹理单元
预览:
片段着色器包含我的调试打印，因此如果使用，您还需要纹理，请参阅 QA:
这个版本解决了一些几何、精度、域问题和错误.我实现了反射和折射，如测试射线的调试图所示:
在调试视图中，只有立方体是透明的，最后没有击中任何东西的光线会被忽略.所以你可以看到光线分裂......由于全反射角，光线在立方体内结束而且我出于速度原因禁用了物体内部的所有反射.
用于交叉点检测的 32 位
floats对距离有点嘈杂，因此您可以使用 64 位doubles代替，但在这种情况下速度会大大下降.另一种选择是重写方程以使用在这种情况下更精确的相对坐标.这里是
float着色器源代码:顶点:
//------------------------------------------------------------------#版本 420 核心//------------------------------------------------------------------统一的浮动方面；统一浮动焦距；统一 mat4x4 tm_eye；vec2 位置中的布局(位置 = 0)；出平滑 vec2 txt_pos;//片段在屏幕上的位置 <-1,+1>用于调试打印出平滑 vec3 ray_pos;//光线起始位置出平滑 vec3 ray_dir；//光线起始方向//------------------------------------------------------------------无效主要(无效){vec4 p;txt_pos=位置；//透视投影p=tm_eye*vec4(pos.x/aspect,pos.y,0.0,1.0);ray_pos=p.xyz;p-=tm_eye*vec4(0.0,0.0,-focal_length,1.0);ray_dir=标准化(p.xyz)；gl_Position=vec4(pos,0.0,1.0);}//------------------------------------------------------------------片段:
//------------------------------------------------------------------#版本 420 核心//------------------------------------------------------------------//光线追踪器版本:1.000//------------------------------------------------------------------在平滑的 vec3 ray_pos 中；//光线起始位置在平滑的 vec3 ray_dir 中；//光线起始方向统一浮点数 n0；//相机原点的折射率统一的 int fac_siz;//正方形纹理 x,y 分辨率大小统一的 int fac_num;//纹理中的有效浮点数统一的sampler2D fac_txr；//场景网格数据纹理输出布局(位置 = 0)vec4 frag_col；//--------------------------------------------------------------------------//#define _debug_print#define _reflect#define _refract//--------------------------------------------------------------------------#ifdef _debug_print在 vec2 txt_pos;//碎片屏幕位置 <-1,+1>统一的 sampler2D txr_font；//ASCII 32x8 字符字体纹理单元统一浮动 txt_fxs,txt_fys;//字体/屏幕分辨率常量 int _txtsiz=64;//文本缓冲区大小int txt[_txtsiz],txtsiz;//文本缓冲区及其实际大小vec4 txt_col=vec4(0.0,0.0,0.0,1.0);//txt_print() 的颜色界面布尔 _txt_col=false；//txt_col 是否激活?无效 txt_decimal(vec2 v);//将 vec3 打印到 txt无效 txt_decimal(vec3 v);//将 vec3 打印到 txt无效 txt_decimal(vec4 v);//将 vec3 打印到 txt无效 txt_decimal(float x);//将浮点 x 打印到 txt无效 txt_decimal(int x);//将 int x 打印到 txt无效的txt_print(浮点x0，浮点y0)；//在 x0,y0 [chars] 处打印 txt#万一//--------------------------------------------------------------------------无效主要(无效){常量 vec3 light_dir=normalize(vec3(0.1,0.1,1.0));常量浮动 lig??ht_iamb=0.1;//点偏移常量浮动 lig??ht_idir=0.5;//定向光幅度常量 vec3 back_col=vec3(0.2,0.2,0.2);//背景颜色常量浮动_零=1e-6；//避免与光线起点相交常量 int _fac_triangles=0;//r,g,b, refl,refr,n, 类型, 三角形计数, { x0,y0,z0,x1,y1,z1,x2,y2,z2 }常量 int _fac_spheres =1;//r,g,b, refl,refr,n, 类型, 球体计数, { x,y,z,r }//光线场景相交结构 _ray{vec3 pos,dir,nor;vec3 col;float refl,refr;//反射，折射强度系数浮动 n0,n1,l;//折射指数 (start,end) , 光线长度国际等级，i0，i1；//递归级别，反射，折射};常量 int _lvls=5;常量 int _rays=(1<<_lvls)-1;_ray 射线[_rays];内光线；vec3 v0,v1,v2,pos;vec3 c,col;浮动参考，参考；浮动 tt,t,n1,a;int i0,ii,num,id;//fac 纹理访问vec2 st;整数 i, j;浮动 ds=1.0/float(fac_siz-1);#define fac_get 纹理(fac_txr,st).r;st.s+=ds；我++；j++;如果 (j==fac_siz) { j=0;st.s=0.0；st.t+=ds；}//入队起始光线射线[0].pos=射线位置；射线[0].dir=normalize(ray_dir);射线[0].nor=vec3(0.0,0.0,0.0);射线[0].refl=0.0;射线[0].refr=0.0；射线[0].n0=n0;射线[0].n1=1.0；射线[0].l =0.0;射线[0].lvl=0;射线[0].i0=-1;射线[0].i1=-1;射线=1；//调试打印区#ifdef _debug_print布尔 _dbg=false；浮动 dbg_x0=45.0；浮动 dbg_y0= 1.0;浮动 dbg_xs=12.0；浮动 dbg_ys=_rays+1.0;dbg_xs=40.0；dbg_ys=10；浮动 x=0.5*(1.0+txt_pos.x)/txt_fxs;x-=dbg_x0；浮动 y=0.5*(1.0-txt_pos.y)/txt_fys;y-=dbg_y0；//在bbox里面?if ((x>=0.0)&&(x<=dbg_xs)&&(y>=0.0)&&(y<=dbg_ys)){//打印_dbg=真；//预设调试光线射线[0].pos=vec3(0.0,0.0,0.0)*2.5;射线[0].dir=vec3(0.0,0.0,1.0);}#万一//循环所有入队的光线对于 (i0=0;i0<射线;i0++){//遍历所有对象//找到它们与 ray[i0] 之间最近的前向交点//将其存储到 ray[i0].(nor,col)//将其存储到 pos,n1t=tt=-1.0；ii=1；射线[i0].l=0.0;射线[i0].col=back_col;位置=射线[i0].pos;n1=n0;对于 (st=vec2(0.0,0.0),i=j=0;i代码尚未优化，但我想让物理首先正常工作.仍然没有实现菲涅耳，而是使用了材料的
refl,refr系数.你也可以忽略调试打印的东西(它们被
#define封装).我为几何纹理构建了一个小类，以便我可以轻松设置场景对象.这是为预览启动场景的方式:
ray.beg();//r g b rfl rfr nray.add_material(1.0,1.0,1.0,0.3,0.0,_n_glass);ray.add_box (0.0, 0.0, 6.0,9.0,9.0,0.1);ray.add_material(1.0,1.0,1.0,0.1,0.8,_n_glass);ray.add_sphere(0.0, 0.0, 0.5,0.5);ray.add_material(1.0,0.1,0.1,0.3,0.0,_n_glass);ray.add_sphere(+2.0, 0.0, 2.0,0.5);ray.add_material(0.1,1.0,0.1,0.3,0.0,_n_glass);ray.add_box (-2.0, 0.0, 2.0,0.5,0.5,0.5);ray.add_material(0.1,0.1,1.0,0.3,0.0,_n_glass);ray.add_tetrahedron(0.0, 0.0, 3.0,-1.0,-1.0, 4.0,+1.0,-1.0, 4.0,0.0,+1.0, 4.0);射线.end();重要的是，计算出的法线面向对象外，因为这用于检测内部/外部对象交叉.
附言
如果你有兴趣，这里是我的体积 3D 背光线追踪器:
- 如何在考虑性能的情况下最好地用 C 语言编写体素引擎
- 这里为低代表用户存档
这里是这个Mesh"的更新版本.支持半球物体的光线追踪器:
- 光线追踪半球
I am writing a GPU-based real-time raytracing renderer using a GLSL compute shader. So far, it works really well, but I have stumbled into a seemingly unsolvable problem when it comes to having both reflections and refractions simultaneously.
My logic tells me that in order to have reflections and refractions on an object, such as glass, the ray would have to split into two, one ray reflects off the surface, and the other refracts through the surface. The ultimate colours of these rays would then be combined based on some function and ultimately used as the colour of the pixel the ray originated from. The problem I have is that I can't split the rays in shader code, as I would have to use recursion to do so. From my understanding, functions in a shader cannot be recursive because all GLSL functions are like inline functions in C++ due to compatibility issues with older GPU hardware.
Is it possible to simulate or fake recursion in shader code, or can I even achieve reflection and refraction simultaneously without using recursion at all? I can't see how it can happen without recursion, but I might be wrong.
解决方案I manage to convert back-raytracing to iterative process suitable for GLSL with the method suggested in my comment. It is far from optimized and I do not have all the physical stuff implemented (no Snell's law etc ...) yet but as a proof of concept it works already. I do all the stuff in fragment shader and CPU side code just send the
uniformsconstants and scene in form of 32 bit non-clamped float textureGL_LUMINANCE32F_ARBThe rendering is just singleQUADcovering whole screen.- passing the scene
I decided to store the scene in texture so each ray/fragment has direct access to whole scene. The texture is 2D but it is used as linear list of 32 bit floats. I decided this format:
enum _fac_type_enum { _fac_triangles=0, // r,g,b,a, n, triangle count, { x0,y0,z0,x1,y1,z1,x2,y2,z2 } _fac_spheres, // r,g,b,a, n, sphere count, { x,y,z,r } }; const GLfloat _n_glass=1.561; const GLfloat _n_vacuum=1.0; GLfloat data[]= { // r, g, b, a, n, type,count 0.2,0.3,0.5,0.5,_n_glass,_fac_triangles, 4, // tetrahedron // px, py, pz, r, g, b -0.5,-0.5,+1.0, 0.0,+0.5,+1.0, +0.5,-0.5,+1.0, 0.0, 0.0,+0.5, -0.5,-0.5,+1.0, 0.0,+0.5,+1.0, 0.0, 0.0,+0.5, 0.0,+0.5,+1.0, +0.5,-0.5,+1.0, 0.0, 0.0,+0.5, +0.5,-0.5,+1.0, -0.5,-0.5,+1.0, };You can add/change any type of object. This example holds just single semi transparent bluish tetrahedron. You could also add transform matrices more coefficients for material properties etc ...
- Architecture
the Vertex shader just initialize corner Rays of the view (start position and direction) which is interpolated so each fragment represents start ray of back ray tracing process.
Iterative back ray tracing
So I created a "static" list of rays and init it with the start ray. The Iteration is done in two steps first the back ray tracing:
- Loop through all rays in a list from the first
- Find closest intersection with scene...
store the position, surface normal and material properties into ray
struct- If intersection found and not last "recursion" layer add reflect/refract rays to list at the end.
also store their indexes to the processed ray
structNow your rays should hold all the intersection info you need to reconstruct the color. To do that:
- loop through all the recursion levels backwards
- for each of the rays matching actual recursion layer
- compute ray color
so use lighting equations you want. If the ray contains children add their color to the result based on material properties (reflective and refractive coefficients ...)
Now the first ray should contain the color you want to output.
Uniforms used:
tm_eyeview camera matrix
aspectview ys/xs aspect ratio
n0empty space refraction index (unused yet)
focal_lengthcamera focal length
fac_sizresolution of the scene square texture
fac_numnumber of floats actually used in the scene texture
fac_txrtexture unit for the scene texturePreview:
The fragment shader contains my debug prints so you will need also the texture if used see the QA:
- GLSL debug prints
ToDo:
add matrices for objects, camera etc.
add material properties (shininess, reflection/refraction coefficient)
Snell's law right now the direction of new rays are wrong ...
may be separate R,G,B to 3 start rays and combine at the end
fake SSS Subsurface scattering based on ray lengths
better implement lights (right now they are constants in a code)
implement more primitives (right now only triangles are supported)[Edit1] code debug and upgrade
I removed old source code to fit inside 30KB limit. If you need it then dig it from edit history. Had some time for more advanced debugging for this and here the result:
this version got resolved some geometrical,accuracy,domain problems and bugs. I got implemented both reflections and refractions as is shown on this debug draw for test ray:
In the debug view only the cube is transparent and last ray that does not hit anything is ignored. So as you can see the ray split ... The ray ended inside cube due to total reflection angle And I disable all reflections inside objects for speed reasons.
The 32bit
floatsfor intersection detection are a bit noisy with distances so you can use 64bitdoublesinstead but the speed drops considerably in such case. Another option is to rewrite the equation to use relative coordinates which are more precise in this case of use.Here the
floatshaders source:Vertex:
//------------------------------------------------------------------ #version 420 core //------------------------------------------------------------------ uniform float aspect; uniform float focal_length; uniform mat4x4 tm_eye; layout(location=0) in vec2 pos; out smooth vec2 txt_pos; // frag position on screen <-1,+1> for debug prints out smooth vec3 ray_pos; // ray start position out smooth vec3 ray_dir; // ray start direction //------------------------------------------------------------------ void main(void) { vec4 p; txt_pos=pos; // perspective projection p=tm_eye*vec4(pos.x/aspect,pos.y,0.0,1.0); ray_pos=p.xyz; p-=tm_eye*vec4(0.0,0.0,-focal_length,1.0); ray_dir=normalize(p.xyz); gl_Position=vec4(pos,0.0,1.0); } //------------------------------------------------------------------Fragment:
//------------------------------------------------------------------ #version 420 core //------------------------------------------------------------------ // Ray tracer ver: 1.000 //------------------------------------------------------------------ in smooth vec3 ray_pos; // ray start position in smooth vec3 ray_dir; // ray start direction uniform float n0; // refractive index of camera origin uniform int fac_siz; // square texture x,y resolution size uniform int fac_num; // number of valid floats in texture uniform sampler2D fac_txr; // scene mesh data texture out layout(location=0) vec4 frag_col; //--------------------------------------------------------------------------- //#define _debug_print #define _reflect #define _refract //--------------------------------------------------------------------------- #ifdef _debug_print in vec2 txt_pos; // frag screen position <-1,+1> uniform sampler2D txr_font; // ASCII 32x8 characters font texture unit uniform float txt_fxs,txt_fys; // font/screen resolution ratio const int _txtsiz=64; // text buffer size int txt[_txtsiz],txtsiz; // text buffer and its actual size vec4 txt_col=vec4(0.0,0.0,0.0,1.0); // color interface for txt_print() bool _txt_col=false; // is txt_col active? void txt_decimal(vec2 v); // print vec3 into txt void txt_decimal(vec3 v); // print vec3 into txt void txt_decimal(vec4 v); // print vec3 into txt void txt_decimal(float x); // print float x into txt void txt_decimal(int x); // print int x into txt void txt_print(float x0,float y0); // print txt at x0,y0 [chars] #endif //--------------------------------------------------------------------------- void main(void) { const vec3 light_dir=normalize(vec3(0.1,0.1,1.0)); const float light_iamb=0.1; // dot offset const float light_idir=0.5; // directional light amplitude const vec3 back_col=vec3(0.2,0.2,0.2); // background color const float _zero=1e-6; // to avoid intrsection with start point of ray const int _fac_triangles=0; // r,g,b, refl,refr,n, type, triangle count, { x0,y0,z0,x1,y1,z1,x2,y2,z2 } const int _fac_spheres =1; // r,g,b, refl,refr,n, type, sphere count, { x,y,z,r } // ray scene intersection struct _ray { vec3 pos,dir,nor; vec3 col; float refl,refr;// reflection,refraction intensity coeficients float n0,n1,l; // refaction index (start,end) , ray length int lvl,i0,i1; // recursion level, reflect, refract }; const int _lvls=5; const int _rays=(1<<_lvls)-1; _ray ray[_rays]; int rays; vec3 v0,v1,v2,pos; vec3 c,col; float refr,refl; float tt,t,n1,a; int i0,ii,num,id; // fac texture access vec2 st; int i,j; float ds=1.0/float(fac_siz-1); #define fac_get texture(fac_txr,st).r; st.s+=ds; i++; j++; if (j==fac_siz) { j=0; st.s=0.0; st.t+=ds; } // enque start ray ray[0].pos=ray_pos; ray[0].dir=normalize(ray_dir); ray[0].nor=vec3(0.0,0.0,0.0); ray[0].refl=0.0; ray[0].refr=0.0; ray[0].n0=n0; ray[0].n1=1.0; ray[0].l =0.0; ray[0].lvl=0; ray[0].i0=-1; ray[0].i1=-1; rays=1; // debug print area #ifdef _debug_print bool _dbg=false; float dbg_x0=45.0; float dbg_y0= 1.0; float dbg_xs=12.0; float dbg_ys=_rays+1.0; dbg_xs=40.0; dbg_ys=10; float x=0.5*(1.0+txt_pos.x)/txt_fxs; x-=dbg_x0; float y=0.5*(1.0-txt_pos.y)/txt_fys; y-=dbg_y0; // inside bbox? if ((x>=0.0)&&(x<=dbg_xs) &&(y>=0.0)&&(y<=dbg_ys)) { // prints on _dbg=true; // preset debug ray ray[0].pos=vec3(0.0,0.0,0.0)*2.5; ray[0].dir=vec3(0.0,0.0,1.0); } #endif // loop all enqued rays for (i0=0;i0<rays;i0++) { // loop through all objects // find closest forward intersection between them and ray[i0] // strore it to ray[i0].(nor,col) // strore it to pos,n1 t=tt=-1.0; ii=1; ray[i0].l=0.0; ray[i0].col=back_col; pos=ray[i0].pos; n1=n0; for (st=vec2(0.0,0.0),i=j=0;i<fac_num;) { c.r=fac_get; // RGBA c.g=fac_get; c.b=fac_get; refl=fac_get; refr=fac_get; n1=fac_get; // refraction index a=fac_get; id=int(a); // object type a=fac_get; num=int(a); // face count if (id==_fac_triangles) for (;num>0;num--) { v0.x=fac_get; v0.y=fac_get; v0.z=fac_get; v1.x=fac_get; v1.y=fac_get; v1.z=fac_get; v2.x=fac_get; v2.y=fac_get; v2.z=fac_get; vec3 e1,e2,n,p,q,r; float t,u,v,det,idet; //compute ray triangle intersection e1=v1-v0; e2=v2-v0; // Calculate planes normal vector p=cross(ray[i0].dir,e2); det=dot(e1,p); // Ray is parallel to plane if (abs(det)<1e-8) continue; idet=1.0/det; r=ray[i0].pos-v0; u=dot(r,p)*idet; if ((u<0.0)||(u>1.0)) continue; q=cross(r,e1); v=dot(ray[i0].dir,q)*idet; if ((v<0.0)||(u+v>1.0)) continue; t=dot(e2,q)*idet; if ((t>_zero)&&((t<=tt)||(ii!=0))) { ii=0; tt=t; // store color,n ... ray[i0].col=c; ray[i0].refl=refl; ray[i0].refr=refr; // barycentric interpolate position t=1.0-u-v; pos=(v0*t)+(v1*u)+(v2*v); // compute normal (store as dir for now) e1=v1-v0; e2=v2-v1; ray[i0].nor=cross(e1,e2); } } if (id==_fac_spheres) for (;num>0;num--) { float r; v0.x=fac_get; v0.y=fac_get; v0.z=fac_get; r=fac_get; // compute l0 length of ray(p0,dp) to intersection with sphere(v0,r) // where rr= r^-2 float aa,bb,cc,dd,l0,l1,rr; vec3 p0,dp; p0=ray[i0].pos-v0; // set sphere center to (0,0,0) dp=ray[i0].dir; rr = 1.0/(r*r); aa=2.0*rr*dot(dp,dp); bb=2.0*rr*dot(p0,dp); cc= rr*dot(p0,p0)-1.0; dd=((bb*bb)-(2.0*aa*cc)); if (dd<0.0) continue; dd=sqrt(dd); l0=(-bb+dd)/aa; l1=(-bb-dd)/aa; if (l0<0.0) l0=l1; if (l1<0.0) l1=l0; t=min(l0,l1); if (t<=_zero) t=max(l0,l1); if ((t>_zero)&&((t<=tt)||(ii!=0))) { ii=0; tt=t; // store color,n ... ray[i0].col=c; ray[i0].refl=refl; ray[i0].refr=refr; // position,normal pos=ray[i0].pos+(ray[i0].dir*t); ray[i0].nor=pos-v0; } } } ray[i0].l=tt; ray[i0].nor=normalize(ray[i0].nor); // split ray from pos and ray[i0].nor if ((ii==0)&&(ray[i0].lvl<_lvls-1)) { t=dot(ray[i0].dir,ray[i0].nor); // reflect #ifdef _reflect if ((ray[i0].refl>_zero)&&(t<_zero)) // do not reflect inside objects { ray[i0].i0=rays; ray[rays]=ray[i0]; ray[rays].lvl++; ray[rays].i0=-1; ray[rays].i1=-1; ray[rays].pos=pos; ray[rays].dir=ray[rays].dir-(2.0*t*ray[rays].nor); ray[rays].n0=ray[i0].n0; ray[rays].n1=ray[i0].n0; rays++; } #endif // refract #ifdef _refract if (ray[i0].refr>_zero) { ray[i0].i1=rays; ray[rays]=ray[i0]; ray[rays].lvl++; ray[rays].i0=-1; ray[rays].i1=-1; ray[rays].pos=pos; t=dot(ray[i0].dir,ray[i0].nor); if (t>0.0) // exit object { ray[rays].n0=ray[i0].n0; ray[rays].n1=n0; v0=-ray[i0].nor; t=-t; } else{ // enter object ray[rays].n0=n1; ray[rays].n1=ray[i0].n0; ray[i0 ].n1=n1; v0=ray[i0].nor; } n1=ray[i0].n0/ray[i0].n1; tt=1.0-(n1*n1*(1.0-t*t)); if (tt>=0.0) { ray[rays].dir=(ray[i0].dir*n1)-(v0*((n1*t)+sqrt(tt))); rays++; } } #endif } else if (i0>0) // ignore last ray if nothing hit { ray[i0]=ray[rays-1]; rays--; i0--; } } // back track ray intersections and compute output color col // lvl is sorted ascending so backtrack from end for (i0=rays-1;i0>=0;i0--) { // directional + ambient light t=abs(dot(ray[i0].nor,light_dir)*light_idir)+light_iamb; t*=1.0-ray[i0].refl-ray[i0].refr; ray[i0].col.rgb*=t; // reflect ii=ray[i0].i0; if (ii>=0) ray[i0].col.rgb+=ray[ii].col.rgb*ray[i0].refl; // refract ii=ray[i0].i1; if (ii>=0) ray[i0].col.rgb+=ray[ii].col.rgb*ray[i0].refr; } col=ray[0].col; // debug prints #ifdef _debug_print /* if (_dbg) { txtsiz=0; txt_decimal(_lvls); txt[txtsiz]=' '; txtsiz++; txt_decimal(rays); txt[txtsiz]=' '; txtsiz++; txt_decimal(_rays); txt_print(dbg_x0,dbg_y0); for (ii=0;ii<rays;ii++) { txtsiz=0; txt_decimal(ray[ii].lvl); txt_print(dbg_x0,dbg_y0+ii+1); } for (ii=0,st=vec2(0.0,0.0),i=j=0;i<fac_num;ii++) { c.r=fac_get; // RGBA txtsiz=0; txt_decimal(c.r); txt_print(dbg_x0,dbg_y0+ii+1); } if (_txt_col) col=txt_col.rgb; } */ if (_dbg) { float x=dbg_x0,y=dbg_y0; vec3 a=vec3(1.0,2.0,3.0); vec3 b=vec3(5.0,6.0,7.0); txtsiz=0; txt_decimal(dot(a,b)); txt_print(x,y); y++; txtsiz=0; txt_decimal(cross(a,b)); txt_print(x,y); y++; if (_txt_col) col=txt_col.rgb; } #endif frag_col=vec4(col,1.0); } //--------------------------------------------------------------------------- #ifdef _debug_print //--------------------------------------------------------------------------- void txt_decimal(vec2 v) // print vec2 into txt { txt[txtsiz]='('; txtsiz++; txt_decimal(v.x); txt[txtsiz]=','; txtsiz++; txt_decimal(v.y); txt[txtsiz]=')'; txtsiz++; txt[txtsiz]=0; // string terminator } //--------------------------------------------------------------------------- void txt_decimal(vec3 v) // print vec3 into txt { txt[txtsiz]='('; txtsiz++; txt_decimal(v.x); txt[txtsiz]=','; txtsiz++; txt_decimal(v.y); txt[txtsiz]=','; txtsiz++; txt_decimal(v.z); txt[txtsiz]=')'; txtsiz++; txt[txtsiz]=0; // string terminator } //--------------------------------------------------------------------------- void txt_decimal(vec4 v) // print vec4 into txt { txt[txtsiz]='('; txtsiz++; txt_decimal(v.x); txt[txtsiz]=','; txtsiz++; txt_decimal(v.y); txt[txtsiz]=','; txtsiz++; txt_decimal(v.z); txt[txtsiz]=','; txtsiz++; txt_decimal(v.w); txt[txtsiz]=')'; txtsiz++; txt[txtsiz]=0; // string terminator } //--------------------------------------------------------------------------- void txt_decimal(float x) // print float x into txt { int i,j,c; // l is size of string float y,a; const float base=10; // handle sign if (x<0.0) { txt[txtsiz]='-'; txtsiz++; x=-x; } else { txt[txtsiz]='+'; txtsiz++; } // divide to int(x).fract(y) parts of number y=x; x=floor(x); y-=x; // handle integer part i=txtsiz; // start of integer part for (;txtsiz<_txtsiz;) { a=x; x=floor(x/base); a-=base*x; txt[txtsiz]=int(a)+'0'; txtsiz++; if (x<=0.0) break; } j=txtsiz-1; // end of integer part for (;i<j;i++,j--) // reverse integer digits { c=txt[i]; txt[i]=txt[j]; txt[j]=c; } // handle fractional part for (txt[txtsiz]='.',txtsiz++;txtsiz<_txtsiz;) { y*=base; a=floor(y); y-=a; txt[txtsiz]=int(a)+'0'; txtsiz++; if (y<=0.0) break; } txt[txtsiz]=0; // string terminator } //--------------------------------------------------------------------------- void txt_decimal(int x) // print int x into txt { int a,i,j,c; // l is size of string const int base=10; // handle sign if (x<0.0) { txt[txtsiz]='-'; txtsiz++; x=-x; } else { txt[txtsiz]='+'; txtsiz++; } // handle integer part i=txtsiz; // start of integer part for (;txtsiz<_txtsiz;) { a=x; x/=base; a-=base*x; txt[txtsiz]=int(a)+'0'; txtsiz++; if (x<=0) break; } j=txtsiz-1; // end of integer part for (;i<j;i++,j--) // reverse integer digits { c=txt[i]; txt[i]=txt[j]; txt[j]=c; } txt[txtsiz]=0; // string terminator } //--------------------------------------------------------------------------- void txt_print(float x0,float y0) // print txt at x0,y0 [chars] { int i; float x,y; // fragment position [chars] relative to x0,y0 x=0.5*(1.0+txt_pos.x)/txt_fxs; x-=x0; y=0.5*(1.0-txt_pos.y)/txt_fys; y-=y0; // inside bbox? if ((x<0.0)||(x>float(txtsiz))||(y<0.0)||(y>1.0)) return; // get font texture position for target ASCII i=int(x); // char index in txt x-=float(i); i=txt[i]; x+=float(int(i&31)); y+=float(int(i>>5)); x/=32.0; y/=8.0; // offset in char texture txt_col=texture(txr_font,vec2(x,y)); _txt_col=true; } //--------------------------------------------------------------------------- #endif //---------------------------------------------------------------------------The code is not optimized yet I wanted to have the physics working correctly first. There are still not Fresnells implemented but
refl,refrcoefficients of material are used instead.Also you can ignore the debug prints stuff (they are encapsulated by
#define).I build a small class for the geometry texture so I can easily set up scene objects. This is how the scene was initiated for the preview:
ray.beg(); // r g b rfl rfr n ray.add_material(1.0,1.0,1.0,0.3,0.0,_n_glass); ray.add_box ( 0.0, 0.0, 6.0,9.0,9.0,0.1); ray.add_material(1.0,1.0,1.0,0.1,0.8,_n_glass); ray.add_sphere( 0.0, 0.0, 0.5,0.5); ray.add_material(1.0,0.1,0.1,0.3,0.0,_n_glass); ray.add_sphere( +2.0, 0.0, 2.0,0.5); ray.add_material(0.1,1.0,0.1,0.3,0.0,_n_glass); ray.add_box ( -2.0, 0.0, 2.0,0.5,0.5,0.5); ray.add_material(0.1,0.1,1.0,0.3,0.0,_n_glass); ray.add_tetrahedron ( 0.0, 0.0, 3.0, -1.0,-1.0, 4.0, +1.0,-1.0, 4.0, 0.0,+1.0, 4.0 ); ray.end();It is important so computed normals are facing out of objects because that is used for detecting inside/outside object crossings.
P.S.
If you're interested here is my volumetric 3D back ray tracer:
- How to best write a voxel engine in C with performance in mind
- here archive for low rep users
Here newer version of this "Mesh" Raytracer supporting hemisphere objects:
- Ray tracing a Hemisphere
相关文章