光线追踪(RayTracing)算法理论与实践(三)光照

最新推荐文章于 2025-02-22 11:13:02 发布
最新推荐文章于 2025-02-22 11:13:02 发布
阅读量1.1w 收藏 19
点赞数 2
分类专栏： 计算机图形学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/silangquan/article/details/8257240
版权
提要

经过之前的学习，我们已经可以在利用光线追踪实现一些简单的场景。今天我们要探讨的是图形学里面的三种基本光源：方向光源，点光源，聚光灯。

不同于利用现成的Api，这次会从理论到实际一步步用C++实现。


前提工作

在老师的建议下，我将图形引擎换成了SDL，最终的渲染效果比之前的好了很多，原来的GLFW虽然能够很好的兼容OpenGL，但并没提供对像素的控制，而SDL有Surface。

对与GLFW，本人觉得其终究只能算是glut的替代品，而SDL应当是一个完善的游戏引擎，而且文档和教程都非常地丰富。

有关SDL的文章，请猛击这里。


方向光源

方向光源是一组平行光。所以方向光源类只有方向和颜色两个属性。用一个向量对象来表示方向，颜色对象表示光的颜色。


阴影

回忆一下入门文章的第一幅图片，在有光的情况下，判断某一点是否是阴影，即判断是否能够从那一点看到光。

那么光线追踪的过程就是：

从摄像机产生光线->投射场景->若与物体相交，从该点产生光线，方向为光源方向的饭方向->投射场景->若与场景中的物体相交，则属于阴影区域。


方向光源的实现：

/*****************************************************************************
Copyright: 2012, ustc All rights reserved.
contact:k283228391@126.com
File name: directlight.h
Description:directlight's h doc.
Author:Silang Quan
Version: 1.0
Date: 2012.12.04
*****************************************************************************/
#ifndef DIRECTLIGHT_H
#define DIRECTLIGHT_H
#include "color.h"
#include "gvector3.h"
#include "union.h"
class DirectLight
{
    public:
        DirectLight();
        DirectLight(Color _color,GVector3 _direction,bool _isShadow);
        virtual ~DirectLight();
        Color intersect(Union &scence,IntersectResult &result);
    protected:
    private:
        bool isShadow;
        Color color;
        GVector3 direction;
};
#endif // DIRECTLIGHT_H

/*****************************************************************************
Copyright: 2012, ustc All rights reserved.
contact:k283228391@126.com
File name: directlight.cpp
Description:directlight's cpp doc.
Author:Silang Quan
Version: 1.0
Date: 2012.12.04
*****************************************************************************/
#include "directlight.h"

DirectLight::DirectLight()
{
    //ctor
}
DirectLight::DirectLight(Color _color,GVector3 _direction,bool _isShadow)
{
    color=_color;
    direction=_direction;
    isShadow=_isShadow;
}
DirectLight::~DirectLight()
{
    //dtor
}
//通过光线与场景的相交结果计算光照结果
Color DirectLight::intersect(Union &scence,IntersectResult &rayResult)
{
    //生产shadowRay的修正值
    const float k=1e-4;
    //生成与光照相反方向的shadowRay
    GVector3 shadowDir=direction.normalize().negate();
    CRay shadowRay=CRay(rayResult.position+rayResult.normal*k,shadowDir);
    //计算shadowRay是否与场景相交
    IntersectResult lightResult = scence.isIntersected(shadowRay);
    Color resultColor = Color::black();
    if(isShadow)
    {
        if(lightResult.object)
        {
        return resultColor;
        }
    }

    //计算光强
    float NdotL=rayResult.normal.dotMul(shadowDir);
    if (NdotL >= 0)
    resultColor=resultColor.add(this->color.multiply(NdotL));
    //return this->color;

    return resultColor;
}


需要注意的是intersect函数，输入的参数是场景的引用和光线和场景相交结果的引用，返回一个Color。

若shadowRay没有与场景相交，那么就要对那一点接收到的光强进行计算。

与之有关的就是平面法向量与光的方向的夹角，当这个夹角约大，接受的光强就越小，想想看，中午太阳光是不是最强，傍晚是不是比较弱一些:0).

计算夹角利用的是向量的点乘。

渲染一下：

void renderLight()
{
    Uint32 pixelColor;
    Union scene;
    PerspectiveCamera camera( GVector3(0, 10, 10),GVector3(0, 0, -1),GVector3(0, 1, 0), 90);
    Plane* plane1=new Plane(GVector3(0, 1, 0),0.0);
    Plane* plane2=new Plane(GVector3(0, 0, 1),-50);
    Plane* plane3=new Plane(GVector3(1, 0, 0),-20);
    CSphere* sphere1=new CSphere(GVector3(0, 10, -10), 10.0);
    DirectLight light1(Color::white().multiply(10), GVector3(-1.75, -2, -1.5),true);
    scene.push(plane1);
    scene.push(plane2);
    scene.push(plane3);
    scene.push(sphere1);
    long maxDepth=20;
    float dx=1.0f/WINDOW_WIDTH;
    float dy=1.0f/WINDOW_HEIGHT;
    float dD=255.0f/maxDepth;
    for (long y = 0; y < WINDOW_HEIGHT; ++y)
    {
        float sy = 1 - dy*y;
        for (long x = 0; x < WINDOW_WIDTH; ++x)
        {
            float sx =dx*x;
            CRay ray(camera.generateRay(sx, sy));
            IntersectResult result = scene.isIntersected(ray);

            if (result.isHit)
            {
                Color color=light1.intersect(scene,result);
                pixelColor=SDL_MapRGB(screen->format,std::min(color.r*255,(float)255),std::min(color.g*255,(float)255.0),std::min(color.b*255,(float)255.0));
                drawPixel(screen, x, y,pixelColor);
            }
        }
    }
}


点光源

点光源/点光灯(point light)，又称全向光源/泛光源/泛光灯(omnidirectional light/omni light)，是指一个无限小的点，向所有光向平均地散射光。最常见的点光源就是电灯泡了，需要确定光源的位置，还有就是光的颜色。


在计算光强的时候，需要乘以一个衰减系数，接收到的能量和距离的关系，是成平方反比定律的:


点光源的实现：

/*****************************************************************************
Copyright: 2012, ustc All rights reserved.
contact:k283228391@126.com
File name: pointlight.h
Description:pointlight's h doc.
Author:Silang Quan
Version: 1.0
Date: 2012.12.04
*****************************************************************************/
#ifndef POINTLIGHT_H
#define POINTLIGHT_H
#include "color.h"
#include "gvector3.h"
#include "union.h"

class PointLight
{
    public:
        PointLight();
        PointLight(Color _color,GVector3 _position,bool _isShadow);
        virtual ~PointLight();
        Color intersect(Union &scence,IntersectResult &result);
    protected:
    private:
        bool isShadow;
        Color color;
        GVector3 position;
};

#endif // POINTLIGHT_H


/*****************************************************************************
Copyright: 2012, ustc All rights reserved.
contact:k283228391@126.com
File name: pointlight.cpp
Description:pointlight's cpp doc.
Author:Silang Quan
Version: 1.0
Date: 2012.12.04
*****************************************************************************/
#include "pointlight.h"

PointLight::PointLight()
{
    //ctor
}

PointLight::~PointLight()
{
    //dtor
}
PointLight::PointLight(Color _color,GVector3 _position,bool _isShadow)
{
    color=_color;
    position=_position;
    isShadow=_isShadow;
}
//通过光线与场景的相交结果计算光照结果
Color PointLight::intersect(Union &scence,IntersectResult &rayResult)
{
    //生产shadowRay的修正值
    const float k=1e-4;
    GVector3 delta=this->position-rayResult.position;
    float distance=delta.getLength();
    //生成与光照相反方向的shadowRay
    CRay shadowRay=CRay(rayResult.position,delta.normalize());
    GVector3 shadowDir=delta.normalize();
    //计算shadowRay是否与场景相交
    IntersectResult lightResult = scence.isIntersected(shadowRay);
    Color resultColor = Color::black();
    Color returnColor=Color::black();
    //如果shadowRay与场景中的物体相交
    if(lightResult.object&&(lightResult.distance<=distance))
    {
        return resultColor;;
    }
    else
    {
        resultColor=this->color.divide(distance*distance);
        float NdotL=rayResult.normal.dotMul(shadowDir);
        if (NdotL >= 0)
        returnColor=returnColor.add(resultColor.multiply(NdotL));
         return returnColor;
    }

}

渲染一下：

在rendeLight函数中初始化点光源：

PointLight light2(Color::white().multiply(200), GVector3(10,20,10),true);



聚光灯

聚光灯点光源的基础上，加入圆锥形的范围，最常见的聚光灯就是手电了，或者舞台的投射灯。聚光灯可以有不同的模型，以下采用Direct3D固定功能管道(fixed-function pipeline)用的模型做示范。


聚光灯有一个主要方向s，再设置两个圆锥范围，称为内圆锥和外圆锥，两圆锥之间的范围称为半影(penumbra)。内外圆锥的内角分别为和。聚光灯可计算一个聚光灯系数，范围为[0,1]，代表某方向的放射比率。内圆锥中系数为1(最亮)，内圆锥和外圆锥之间系数由1逐渐变成0。另外，可用另一参数p代表衰减(falloff)，决定内圆锥和外圆锥之间系数变化。方程式如下：


聚光灯的实现

/*****************************************************************************
Copyright: 2012, ustc All rights reserved.
contact:k283228391@126.com
File name: spotlight.h
Description:spotlight's h doc.
Author:Silang Quan
Version: 1.0
Date: 2012.12.04
*****************************************************************************/
#ifndef SPOTLIGHT_H
#define SPOTLIGHT_H
#include "color.h"
#include "gvector3.h"
#include "union.h"
#include <math.h>

class SpotLight
{
    public:
        SpotLight();
        SpotLight(Color _color,GVector3 _position,GVector3 _direction,float _theta,float _phi,float _fallOff,bool _isShadow);
        virtual ~SpotLight();
        Color intersect(Union &scence,IntersectResult &result);
    protected:
    private:
        Color color;
        GVector3 position;
        GVector3 direction;
        bool isShadow;
        float theta;
        float phi;
        float fallOff;
        //negate the Direction
        GVector3 directionN;
        float cosTheta;
        float cosPhi;
        float baseMultiplier;
};

#endif // SPOTLIGHT_H


/*****************************************************************************
Copyright: 2012, ustc All rights reserved.
contact:k283228391@126.com
File name: pointlight.cpp
Description:pointlight's cpp doc.
Author:Silang Quan
Version: 1.0
Date: 2012.12.04
*****************************************************************************/
#include "pointlight.h"

PointLight::PointLight()
{
    //ctor
}

PointLight::~PointLight()
{
    //dtor
}
PointLight::PointLight(Color _color,GVector3 _position,bool _isShadow)
{
    color=_color;
    position=_position;
    isShadow=_isShadow;
}
//通过光线与场景的相交结果计算光照结果
Color PointLight::intersect(Union &scence,IntersectResult &rayResult)
{
    //生产shadowRay的修正值
    const float k=1e-4;
    GVector3 delta=this->position-rayResult.position;
    float distance=delta.getLength();
    //生成与光照相反方向的shadowRay
    CRay shadowRay=CRay(rayResult.position,delta.normalize());
    GVector3 shadowDir=delta.normalize();
    //计算shadowRay是否与场景相交
    IntersectResult lightResult = scence.isIntersected(shadowRay);
    Color resultColor = Color::black();
    Color returnColor=Color::black();
    //如果shadowRay与场景中的物体相交
    if(lightResult.object&&(lightResult.distance<=distance))
    {
        return resultColor;;
    }
    else
    {
        resultColor=this->color.divide(distance*distance);
        float NdotL=rayResult.normal.dotMul(shadowDir);
        if (NdotL >= 0)
        returnColor=returnColor.add(resultColor.multiply(NdotL));
         return returnColor;
    }

}

渲染一下：

在场景中初始化一个聚光灯：

SpotLight light3(Color::white().multiply(1350),GVector3(30, 30, 20),GVector3(-1, -0.7, -1), 20, 30, 0.5,true);





渲染多个灯

这里用到了vector容器。场景中布置了很多个点光源，渲染耗时将近半分钟。

void renderLights()
{
    Uint32 pixelColor;
    Union scene;
    PerspectiveCamera camera( GVector3(0, 10, 10),GVector3(0, 0, -1),GVector3(0, 1, 0), 90);
    Plane* plane1=new Plane(GVector3(0, 1, 0),0.0);
    Plane* plane2=new Plane(GVector3(0, 0, 1),-50);
    Plane* plane3=new Plane(GVector3(1, 0, 0),-20);
    CSphere* sphere1=new CSphere(GVector3(0, 10, -10), 10.0);
    CSphere* sphere2=new CSphere(GVector3(5, 5, -7), 3.0);

    PointLight *light2;
    vector<PointLight> lights;
    for (int x = 10; x <= 30; x += 4)
        for (int z = 20; z <= 40; z += 4)
        {
            light2=new PointLight(Color::white().multiply(80),GVector3(x, 50, z),true);
            lights.push_back(*light2);
        }

    scene.push(plane1);
    scene.push(plane2);
    scene.push(plane3);
    scene.push(sphere1);
    //scene.push(sphere2);
    long maxDepth=20;
    float dx=1.0f/WINDOW_WIDTH;
    float dy=1.0f/WINDOW_HEIGHT;
    float dD=255.0f/maxDepth;
    for (long y = 0; y < WINDOW_HEIGHT; ++y)
    {
        float sy = 1 - dy*y;
        for (long x = 0; x < WINDOW_WIDTH; ++x)
        {
            float sx =dx*x;
            CRay ray(camera.generateRay(sx, sy));
            IntersectResult result = scene.isIntersected(ray);

            if (result.isHit)
            {
                Color color=Color::black();

                for(vector<PointLight>::iterator iter=lights.begin();iter!=lights.end();++iter)
                {
                    color=color.add(iter->intersect(scene,result));
                }
                pixelColor=SDL_MapRGB(screen->format,std::min(color.r*255,(float)255),std::min(color.g*255,(float)255.0),std::min(color.b*255,(float)255.0));
                drawPixel(screen, x, y,pixelColor);
            }
        }
    }
}


渲染结果：


渲染三原色

把原先场景中的球体去掉，布置3盏聚光动，发射红绿蓝，可以很清晰地看见它们融合之后的颜色。

void renderTriColor()
{
      Uint32 pixelColor;
    Union scene;
    PerspectiveCamera camera( GVector3(0, 40, 15),GVector3(0, -1.25, -1),GVector3(0, 1, 0), 60);
    Plane* plane1=new Plane(GVector3(0, 1, 0),0.0);
    Plane* plane2=new Plane(GVector3(0, 0, 1),-50);
    Plane* plane3=new Plane(GVector3(1, 0, 0),-20);

    PointLight light0(Color::white().multiply(1000), GVector3(30,40,20),true);
    SpotLight light1(Color::red().multiply(2000),GVector3(0, 30, 10),GVector3(0, -1, -1), 20, 30, 1,true);
    SpotLight light2(Color::green().multiply(2000),GVector3(6, 30, 20),GVector3(0, -1, -1), 20, 30, 1,true);
    SpotLight light3(Color::blue().multiply(2000),GVector3(-6, 30, 20),GVector3(0, -1, -1), 20, 30, 1,true);
    scene.push(plane1);
    scene.push(plane2);
    scene.push(plane3);

    long maxDepth=20;
    float dx=1.0f/WINDOW_WIDTH;
    float dy=1.0f/WINDOW_HEIGHT;
    float dD=255.0f/maxDepth;
    for (long y = 0; y < WINDOW_HEIGHT; ++y)
    {
        float sy = 1 - dy*y;
        for (long x = 0; x < WINDOW_WIDTH; ++x)
        {
            float sx =dx*x;
            CRay ray(camera.generateRay(sx, sy));
            IntersectResult result = scene.isIntersected(ray);
            if (result.isHit)
            {
                Color color=light0.intersect(scene,result);
                color=color.add(light1.intersect(scene,result));
                color=color.add(light2.intersect(scene,result));
                color=color.add(light3.intersect(scene,result));
                pixelColor=SDL_MapRGB(screen->format,std::min(color.r*255,(float)255),std::min(color.g*255,(float)255.0),std::min(color.b*255,(float)255.0));
                drawPixel(screen, x, y,pixelColor);
            }
        }
    }
}

渲染结果



结语

花了大概一周的时间来实现这个光照效果，虽然网上有相关文章，但亲自动手来实现又是另外一回事了。

当然，这都没有结束，期待后续。

蒙特卡洛光线追踪
sunacmer的专栏
04-11 2万+
转自http://www.diybl.com/course/3_program/c++/cppjs/20101116/547650.html http://www.cnblogs.com/leoo2sk/archive/2009/05/29/1491526.html 光线追踪原理  　　光的基本传递模型  　　1 在一个要渲染的场景中，我们认为光能由预先指定的光源发出，然后我们
光线追踪(RayTracing)算法理论与实践(一)入门
03-09 801
提要 本文先介绍光线追踪的理论,然后着重一步一步来搭建渲染场景,从最基本的向量类开始.采用的语言是c++,利用面向对象的思想,一些基础的线性代数和空间几何的知识也会用到，编程的框架用的是GLFW，渲染用到的是OpenGL。 原理 光线追踪，简单地说，就是从摄影机的位置，通过影像平面上的像素位置(比较正确的说法是取样(sampling)位置)，发射一束光线到场景，求光线和几
四种常见图形库GLUT，SDL，SFML和GLFW简介
最新发布
追赶时代的博客
02-22 707
图形库介绍
光线追踪(RayTracing)算法理论与实践(二)平面、材质、联合光线与物体求交
weixin_34221276的博客
11-17 235
提要 经过上次的学习，我们已经可以建立一个简单的光线追踪的场景，接下来，我们继续我们的征程。 今天要得到的最终效果如下： 光线与物体求交 在光线追踪算法中，最重要的就是求光线与物体的相交，也就是实现IntersectResult Object::isIntersected(CRay _ray)方法。 因为我求得交点之后就可以对该点的像素进行计算，然后...
计算机图形学：光线追踪原理（ray tracing）
星空_MAX
08-05 1690
大致介绍光线追踪原理
蒙特卡洛应用：RTX 光线追踪算法 ReSTIR 原理
加载中...
08-23 1531
ReSTIR 算法全称为 GIalgorithm based on Spatiotemporal Reservoir Resampling，是一种在实时路径追踪渲染算法，用于提高间接光照的采样率，来达到降低路径追踪噪点的目的，它非常适用于计算 GI，目前 UE5.4 的 Lumen 就已实现了基于 ReSTIR 的 Gather……
光线追踪(RayTracing)算法OpenGL实现
06-23
光线追踪（RayTracing）是一种高级的计算机图形学技术，用于模拟光的物理行为，以创建高度逼真的图像。在本项目中，我们将探讨如何使用C++语言和OpenGL库来实现这一复杂的算法。 首先，光线追踪的核心思想是通过...
ray-tracing_射线追踪_raytracing_无线射线追踪_参数估计_射线追踪算法
08-09
射线追踪的基本原理是：从观察者的眼睛出发，向场景中的物体发射虚拟光线，然后追踪这些光线与场景交互的过程，包括反射、折射、散射等现象，最终计算出像素的颜色值。这种技术尤其适用于模拟光影效果，如阴影、镜面...
Raytracing.rar_RayTracing_光线追踪_反射折射_反射模型
07-14
在"Reflections and Refractions in Raytracing.pdf"这个文档中，可能会详细阐述如何在实际的光线追踪算法中实现这些模型。包括如何有效地计算反射路径，如何处理折射的边界条件，以及如何优化光照计算以提高渲染...
光线追踪算法理论与VS2008实现代码解读
1. **Raytracing.pdf**：该PDF文件应该是对光线追踪技术理论的详细介绍，包括数学原理、算法流程、应用场景等，是理解光线追踪技术的重要参考文档。 2. **RayTracer.rar**：这是一个压缩文件，里面包含了实际的光线...
光线追踪（Ray Tracing）算法
qq_40844444的博客
11-29 1758
其核心原理是从虚拟摄像机（观察点）发射出大量光线，这些光线会与场景中的物体（如球体、平面等几何物体）发生相交测试，计算出光线与物体的交点、交点处的光照效果（包括反射、折射、阴影等），然后根据这些信息确定最终像素的颜色，通过追踪众多光线来构建出整个图像。：实现两个向量的减法运算，用第一个向量的各分量减去第二个向量的对应分量，得到新的相减后的向量并返回，新向量各分量按相应减法规则计算得出。分量分别与给定的标量相乘，生成新的数乘后的向量并返回，新向量各分量值为原向量对应分量与标量的乘积。
GAMES101笔记-光线追踪
Xerxes2222的博客
09-05 248
GAMES101笔记-光线追踪
通俗傻瓜式理清光栅化渲染和光线追踪渲染的原理
热门推荐
qq_37366618的博客
12-14 1万+
用通俗语言傻瓜式的讲清楚光栅渲染和光线追踪渲染的原理，方便没有相关理论基础的朋友理解入门。
RayTracking 光线跟踪算法 集总
klzhang的专栏
12-23 1万+
转自 http://www.cnblogs.com/daniagger/archive/2012/05/28/2521318.html   详细请看这位师兄的博客  1. Irradiance(辐照度) total amount of energy received per unit area of a surface   2. Illuminance(照明度)
14、计算机图形学——whited-style光线追踪
Master Cui的博客
08-15 576
一、为啥需要光线追踪 以往的Blinn-Phong光照模型在渲染场景时，对于光的漫反射和镜面反射都只会计算一次，但是实际上在一个场景里面，光有可能既存在反射也存在折射，而且，反射次数和折射次数并不只是一次 因此，Blinn-Phong在精确计算光照强度的时候是不太准确的，而光线追踪渲染方式，就是为了解决Blinn-Phong光照模型存在的问题 二、光线追踪的三个假设 在光线追踪渲染模型中，光是沿着直线传播，光线和光线之间不会产生碰撞，所有的光路都是可逆的 三、光线追踪的过程 首先
《A non-contact eye-gaze tracking system for human computer interaction》论文阅读
大饼子
03-24 2029
题目：A non-contact eye-gaze tracking system for human computer interaction 作者：YING QI, ZHI-LIANG WANG, YING HUANG 来源：Proceedings of the 2007 International Conference on Wavelet Analysis and Pattern Rec...
Eye Tracking for Everyone 译文版
weixin_46034990的博客
08-04 2962
从科学研究到商业应用，眼动跟踪是许多领域的重要工具。尽管眼动跟踪器的应用范围很广，但它还没有成为一种普遍的技术。我们相信，通过构建可在手机和平板电脑等商品硬件上运行的眼动跟踪软件，我们可以将眼动跟踪的力量放在每个人的手掌上，而不需要额外的传感器或设备。我们通过引入来解决这个问题，这是第一个大规模的眼球追踪数据集，包含了来自 1450 多人的数据，包括近 250 万帧。利用 GazeCapture，我们训练了iTracker，一个用于眼球追踪的卷积神经网络。.........
关于 GLFW、SDL2、Win32、GLUT 和 macOS（OSX）平台的介绍
scoone的博客
10-12 1600
GLFW 是一个轻量级的、开源的库，用于在多种操作系统上创建和管理 OpenGL、OpenGL ES 和 Vulkan 窗口。它提供了创建窗口、上下文、接收输入和事件处理的基本功能。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值