虚幻4渲染编程（光线追踪篇）【第三卷：三角形求交】

最新推荐文章于 2022-05-18 21:36:13 发布
最新推荐文章于 2022-05-18 21:36:13 发布
阅读量341 收藏 2
点赞数
企鹅我认为v
本文链接：https://blog.csdn.net/cpongo11/article/details/100702544
版权

MY BLOG DIRECTORY：

小IVan：专题概述及目录​zhuanlan.zhihu.com图标

INTRODUCTION：

我们如果想要渲染其它图形的话就需要对几何模型数据进行tracing。

v2-b20891d457470b493e5d8966f8f73744_b.jpg

我这里渲染了一个正方体和体和平面，直接输出了一个灰色的diffuse。

我们想要渲染几何模型最基础的思想就是对几何模型的所有三角形求交。下面是一篇大佬写的数学推导过程：

射线和三角形的相交检测（ray triangle intersection test）​www.cnblogs.com图标

MAIN CONTENT：

我的对三角形求交代码的如下：

struct MeshFace
{
    float3 Vertex[3];
    float2 UV[3];
    float3 Normal[3];

    bool hit(float3 orig, float3 dir, out hit_record rec)
    {
        float3 v0 = Vertex[0];
        float3 v1 = Vertex[1];
        float3 v2 = Vertex[2];
        float t = 0.0f;
        float u = 0.0f;
        float v = 0.0f;

        float3 E1 = v1 - v0;
        float3 E2 = v2 - v0;
        float3 P = cross(dir, E2);

        float det = dot(E1, P);
        float3 T;
        if (det > 0)
        {
            T = orig - v0;
        }
        else
        {
            T = v0 - orig;
            det = -det;
        }

        if (det < 0.0001f)
            return false;

        u = dot(T, P);
        if (u < 0.0f || u > det)
            return false;

        float3 Q = cross(T, E1);
        v = dot(dir, Q);
        if (v < 0.0f || u + v > det)
            return false;

        t = dot(E2, Q);

        float fInvDet = 1.0f / det;
        t *= fInvDet;
        u *= fInvDet;
        v *= fInvDet;

        rec.t = t;
        rec.p = orig + t * dir;
        rec.normal = float3(0, 1, 0);

        return true;
    }
};

有了对一个三角形的求教方法之后，我们遍历所有模型的三角形对它们求交即可

v2-f7e14252df40f456c85ef09a91c7d410_b.jpg

但是这样做并不高效，我们需要使用各种加速结构来加速这个过程，如BVH。下面是一个shaderToy的BVH算法的demo

Shadertoy​www.shadertoy.com图标

因为我的整个渲染过程都是在ComputeShader中完成的所以无法直接读取模型资源来渲染于是手动敲在shader里了，先在max里建一个模型

v2-2ef914ef6978a4d31922b23c20960f16_b.jpg

然后把它导出成OBJ，导出的时候要勾选三角化

v2-97d5f85b1aca17466595541aa9e2108b_b.jpg

v代表顶点数组，vn代表顶点法线数组，vt代表顶点数组，最后的f就代表三角面的构建了。

f 1/1/1 分别是顶点，UV，法线数组的索引。然后我把这些数据塞到shader里

然后在我的Shader渲染列表里添加上我的模型数据

v2-1c3494e81462953051fb80b594c46342_b.jpg

这导致了我shader的编译时间十分长。

下面是我的shader代码

TracingCommon.ush

struct hit_record
{
    float t;
    float3 p;
    float3 normal;
};

Meshes.ush

#include "TracingCommon.ush"

struct MeshFace
{
    float3 Vertex[3];
    float2 UV[3];
    float3 Normal[3];

    bool hit(float3 orig, float3 dir, out hit_record rec)
    {
        float3 v0 = Vertex[0];
        float3 v1 = Vertex[1];
        float3 v2 = Vertex[2];
        float t = 0.0f;
        float u = 0.0f;
        float v = 0.0f;

        float3 E1 = v1 - v0;
        float3 E2 = v2 - v0;
        float3 P = cross(dir, E2);

        float det = dot(E1, P);
        float3 T;
        if (det > 0)
        {
            T = orig - v0;
        }
        else
        {
            T = v0 - orig;
            det = -det;
        }

        if (det < 0.0001f)
            return false;

        u = dot(T, P);
        if (u < 0.0f || u > det)
            return false;

        float3 Q = cross(T, E1);
        v = dot(dir, Q);
        if (v < 0.0f || u + v > det)
            return false;

        t = dot(E2, Q);

        float fInvDet = 1.0f / det;
        t *= fInvDet;
        u *= fInvDet;
        v *= fInvDet;

        rec.t = t;
        rec.p = orig + t * dir;
        rec.normal = float3(0, 1, 0);

        return true;
    }
};

struct Mesh_Box
{
    float3 verts[8];
    float2 uv[4];
    float3 normal[6];
    MeshFace triface[12];

	int GetMeshFaceNum()
    {
        return 12;
    }

    void InitMesh()
    {
        verts[0] = float3(-0.5000, 0.0000, 0.5000);
        verts[1] = float3(-0.5000, 0.0000, -0.5000);
        verts[2] = float3(0.5000, 0.0000, -0.5000);
        verts[3] = float3(0.5000, 0.0000, 0.5000);
        verts[4] = float3(-0.5000, 1.0000, 0.5000);
        verts[5] = float3(0.5000, 1.0000, 0.5000);
        verts[6] = float3(0.5000, 1.0000, -0.5000);
        verts[7] = float3(-0.5000, 1.0000, -0.5000);

        uv[0] = float2(1.0000, 0.0000);
        uv[1] = float2(1.0000, 1.0000);
        uv[2] = float2(0.0000, 1.0000);
        uv[3] = float2(0.0000, 0.0000);

        normal[0] = float3(0.0000, -1.0000, -0.0000);
        normal[1] = float3(0.0000, 1.0000, -0.0000);
        normal[2] = float3(0.0000, 0.0000, 1.0000);
        normal[3] = float3(1.0000, 0.0000, -0.0000);
        normal[4] = float3(0.0000, 0.0000, -1.0000);
        normal[5] = float3(-1.0000, 0.0000, -0.0000);

        triface[0].Vertex[0] = verts[0];
        triface[0].Vertex[1] = verts[1];
        triface[0].Vertex[2] = verts[2];
        triface[0].UV[0] = uv[0];
        triface[0].UV[1] = uv[1];
        triface[0].UV[2] = uv[2];
        triface[0].Normal[0] = normal[0];
        triface[0].Normal[1] = normal[0];
        triface[0].Normal[2] = normal[0];

        triface[1].Vertex[0] = verts[2];
        triface[1].Vertex[1] = verts[3];
        triface[1].Vertex[2] = verts[0];
        triface[1].UV[0] = uv[2];
        triface[1].UV[1] = uv[3];
        triface[1].UV[2] = uv[0];
        triface[1].Normal[0] = normal[0];
        triface[1].Normal[1] = normal[0];
        triface[1].Normal[2] = normal[0];

        triface[2].Vertex[0] = verts[4];
        triface[2].Vertex[1] = verts[5];
        triface[2].Vertex[2] = verts[6];
        triface[2].UV[0] = uv[3];
        triface[2].UV[1] = uv[0];
        triface[2].UV[2] = uv[1];
        triface[2].Normal[0] = normal[1];
        triface[2].Normal[1] = normal[1];
        triface[2].Normal[2] = normal[1];

        triface[3].Vertex[0] = verts[6];
        triface[3].Vertex[1] = verts[7];
        triface[3].Vertex[2] = verts[4];
        triface[3].UV[0] = uv[1];
        triface[3].UV[1] = uv[2];
        triface[3].UV[2] = uv[3];
        triface[3].Normal[0] = normal[1];
        triface[3].Normal[1] = normal[1];
        triface[3].Normal[2] = normal[1];

        triface[4].Vertex[0] = verts[0];
        triface[4].Vertex[1] = verts[3];
        triface[4].Vertex[2] = verts[5];
        triface[4].UV[0] = uv[3];
        triface[4].UV[1] = uv[0];
        triface[4].UV[2] = uv[1];
        triface[4].Normal[0] = normal[2];
        triface[4].Normal[1] = normal[2];
        triface[4].Normal[2] = normal[2];

        triface[5].Vertex[0] = verts[5];
        triface[5].Vertex[1] = verts[4];
        triface[5].Vertex[2] = verts[0];
        triface[5].UV[0] = uv[1];
        triface[5].UV[1] = uv[2];
        triface[5].UV[2] = uv[3];
        triface[5].Normal[0] = normal[2];
        triface[5].Normal[1] = normal[2];
        triface[5].Normal[2] = normal[2];

        triface[6].Vertex[0] = verts[3];
        triface[6].Vertex[1] = verts[2];
        triface[6].Vertex[2] = verts[6];
        triface[6].UV[0] = uv[3];
        triface[6].UV[1] = uv[0];
        triface[6].UV[2] = uv[1];
        triface[6].Normal[0] = normal[3];
        triface[6].Normal[1] = normal[3];
        triface[6].Normal[2] = normal[3];

        triface[7].Vertex[0] = verts[6];
        triface[7].Vertex[1] = verts[5];
        triface[7].Vertex[2] = verts[3];
        triface[7].UV[0] = uv[1];
        triface[7].UV[1] = uv[2];
        triface[7].UV[2] = uv[3];
        triface[7].Normal[0] = normal[3];
        triface[7].Normal[1] = normal[3];
        triface[7].Normal[2] = normal[3];

        triface[8].Vertex[0] = verts[2];
        triface[8].Vertex[1] = verts[1];
        triface[8].Vertex[2] = verts[7];
        triface[8].UV[0] = uv[3];
        triface[8].UV[1] = uv[0];
        triface[8].UV[2] = uv[1];
        triface[8].Normal[0] = normal[4];
        triface[8].Normal[1] = normal[4];
        triface[8].Normal[2] = normal[4];

        triface[9].Vertex[0] = verts[7];
        triface[9].Vertex[1] = verts[6];
        triface[9].Vertex[2] = verts[2];
        triface[9].UV[0] = uv[1];
        triface[9].UV[1] = uv[2];
        triface[9].UV[2] = uv[3];
        triface[9].Normal[0] = normal[4];
        triface[9].Normal[1] = normal[4];
        triface[9].Normal[2] = normal[4];

        triface[10].Vertex[0] = verts[1];
        triface[10].Vertex[1] = verts[0];
        triface[10].Vertex[2] = verts[4];
        triface[10].UV[0] = uv[3];
        triface[10].UV[1] = uv[0];
        triface[10].UV[2] = uv[1];
        triface[10].Normal[0] = normal[5];
        triface[10].Normal[1] = normal[5];
        triface[10].Normal[2] = normal[5];

        triface[11].Vertex[0] = verts[4];
        triface[11].Vertex[1] = verts[7];
        triface[11].Vertex[2] = verts[1];
        triface[11].UV[0] = uv[1];
        triface[11].UV[1] = uv[2];
        triface[11].UV[2] = uv[3];
        triface[11].Normal[0] = normal[5];
        triface[11].Normal[1] = normal[5];
        triface[11].Normal[2] = normal[5];
    }
};

RayTracing.usf

#include "/Engine/Private/Common.ush"
#include "Meshes.ush"

RWTexture2D<float4> OutputSurface;

float3 RandomInUintSphere(uint2 ID)
{
    float3 p;
    for (int i = 0; i < 128; i++)
    {
        float rand = RandFast(ID, 3571 + (float)i);
        float3 p = 2.0 * float3(rand, rand, rand) - float3(1, 1, 1);
        if (length(p) < 1.0)
        {
            return p;
        }
    }
    return p;
}

struct Ray
{
    float3 origin;
    float3 direction;
    float3 point_at_paramerter(float t)
    {
        return origin + t * direction;
    }
};

struct hitable_Triangle
{
	
    bool hit(float3 orig, float3 dir, float3 v0, float3 v1, float3 v2,  float t,  float u,  float v, out hit_record rec)
    {
        float3 E1 = v1 - v0;
        float3 E2 = v2 - v0;
        float3 P = cross(dir, E2);

        float det = dot(E1, P);
        float3 T;
        if (det > 0)
        {
            T = orig - v0;
        }
        else
        {
            T = v0 - orig;
            det = -det;
        }

        if (det < 0.0001f)
            return false;

        u = dot(T, P);
        if (u < 0.0f || u > det)
            return false;

        float3 Q = cross(T, E1);
        v = dot(dir, Q);
        if (v < 0.0f || u + v > det)
            return false;

        t = dot(E2, Q);

        float fInvDet = 1.0f / det;
        t *= fInvDet;
        u *= fInvDet;
        v *= fInvDet;

        rec.t = t;
        rec.p = orig + t * dir;
        rec.normal = float3(0, 1, 0);

        return true;
    }
};

struct hitable_Sphere
{
    float3 center;
    float radius;
	void InitHitableObject(float3 centerlocation, float radiusvalue)
    {
        center = centerlocation;
        radius = radiusvalue;
    }
    bool hit(in Ray r, in float t_min, float t_max, out hit_record rec)
    {
        float3 oc = r.origin - center;
        float a = dot(r.direction, r.direction);
        float b = 2 * dot(oc, r.direction);
        float c = dot(oc, oc) - radius * radius;
        float discrimninant = b * b - 4 * a * c;
	
        if (discrimninant >= 0)
        {
            float temp = (-b - sqrt(discrimninant)) / (2.0f * a);
            if (temp < t_max && temp > t_min)
            {
                rec.t = temp;
                rec.p = r.point_at_paramerter(rec.t);
                rec.normal = (rec.p - center) / radius;
                return true;
            }
            temp = (-b + sqrt(discrimninant)) / (2.0f * a);
            if (temp < t_max && temp > t_min)
            {
                rec.t = temp;
                rec.p = r.point_at_paramerter(rec.t);
                rec.normal = (rec.p - center) / radius;
                return true;
            }
        }
        return false;
    }
};

struct hitablelist
{
    //hitable_Sphere Sphere_001;
    //hitable_Sphere Sphere_002;
	
    hitable_Triangle Triangle_001;
    hitable_Triangle Triangle_002;

    Mesh_Box meshbox;

	bool hit(in Ray rayline, in float t_min, in float t_max, out hit_record rec)
    {
        hit_record temp_rec;
        bool hit_anything = false;
        float closest_so_far = t_max;
		
        //Sphere_001.InitHitableObject(float3(0, -1.0f, 0), 0.5f);
        //if (Sphere_001.hit(rayline, t_min, closest_so_far, temp_rec))
        //{
        //    hit_anything = true;
        //    closest_so_far = temp_rec.t;
        //    rec = temp_rec;
        //}
		
        //Sphere_002.InitHitableObject(float3(0, -1.0f, 20.5f), 20.0f);
        //if (Sphere_002.hit(rayline, t_min, closest_so_far, temp_rec))
        //{
        //    hit_anything = true;
        //    closest_so_far = temp_rec.t;
        //    rec = temp_rec;
        //}

        if (Triangle_001.hit(rayline.origin, rayline.direction, float3(0, -1, 0), float3(1, -1, 0), float3(0, -1, 1), 0, 0, 0, temp_rec))
        {
            hit_anything = true;
            closest_so_far = temp_rec.t;
            rec = temp_rec;
        }
        if (Triangle_002.hit(rayline.origin, rayline.direction, float3(1, -1, 1), float3(1, -1, 0), float3(0, -1, 1), 0, 0, 0, temp_rec))
        {
            hit_anything = true;
            closest_so_far = temp_rec.t;
            rec = temp_rec;
        }

        meshbox.InitMesh();
        for (int face = 0; face < meshbox.GetMeshFaceNum(); face++)
        {
            if (meshbox.triface[face].hit(rayline.origin, rayline.direction, temp_rec))
            {
                hit_anything = true;
                closest_so_far = temp_rec.t;
                rec = temp_rec;
            }
        }

        return hit_anything;
    }
};

struct Camera
{
    float3 lower_left_corner;
    float3 horizontal;
    float3 vertical;
    float3 origin;

	void InitCamera(float3 lowerleftcorner, float3 horizon, float3 vertic, float3 orig)
    {
        lower_left_corner = lowerleftcorner;
        horizontal = horizon;
        vertical = vertic;
        origin = orig;
    }
	void CameraInit(float3 camerapos, float3 lookat, float3 vup, float vfov, float aspect)
    {
        float3 u = float3(0, 0, 0);
        float3 v = float3(0, 0, 0);
        float3 w = float3(0, 0, 0);

        float theta = vfov * 3.14 / 180.0;
        float halfheight = tan(theta / 2);
        float halfwidth = aspect * halfheight;
        origin = camerapos;
        w = normalize(camerapos - lookat);
        u = normalize(cross(vup, w));
        v = cross(w, u);

        lower_left_corner = float3(-halfwidth, -halfheight, -1.0f);
        lower_left_corner = origin - halfwidth * u - halfheight * v - w;

        horizontal = 2 * halfwidth * u;
        vertical = 2 * halfheight * v;

    }
	void GetRay(float u, float v, out Ray r)
    {
        r.origin = origin;
        r.direction = lower_left_corner + u * horizontal + v * vertical;
    }
};

float3 RenderSceneColor(Ray r, uint2 ID)
{
    hitablelist renderlist;
    hit_record record;
    int shaodowns = 64;
    if (renderlist.hit(r, 0.001, 10000, record))
    {
        float3 Target = record.p + record.normal + RandomInUintSphere(ID);
			//return 0.5 * float3(record.normal.x + 1, record.normal.y + 1, record.normal.z + 1);
        r.direction = Target - record.p;
        r.origin = record.p;
        if (renderlist.hit(r, 0.001, 10000, record))
        {
            if (renderlist.hit(r, 0.001, 10000, record))
            {
                Target = record.p + record.normal + RandomInUintSphere(ID);
                r.direction = Target - record.p;
                r.origin = record.p;
                if (renderlist.hit(r, 0.001, 10000, record))
                {
                    return 0.125f;
                }
            }
            return 0.25f;
        }
        return 0.5f;
    }
    float3 uint_direction = normalize(r.direction);
    float skyalpha = 0.5 * (uint_direction.z + 1);
    return lerp(float3(0.5, 0.7, 1.0), float3(1, 1, 1), skyalpha);
}

[numthreads(32, 32, 1)]
void MainCS(uint3 ThreadId : SV_DispatchThreadID)
{
	//Set up some variables we are going to need
    float sizeX, sizeY;
    OutputSurface.GetDimensions(sizeX, sizeY);

    float2 iResolution = float2(sizeX, sizeY);
    float2 uv = (ThreadId.xy / iResolution.xy);
    int ns = 2048;

    Ray rayline;
    Camera cam;
    //cam.InitCamera(float3(-2.0f, -1.0f, -1.0f), float3(4.0, 0.0f, 0.0f), float3(0.0f, 0.0f, 2.0f), float3(0.0f, 3.0f, 0.0f));
    cam.CameraInit(float3(1.0f, 3.0f, 1.0f), float3(0, 0, 0), float3(0, 0, 1), 90, sizeX / sizeY);
    float3 color = float3(0, 0, 0);
    for (int s = 0; s < ns; s++)
    {
        float offset = RandFast(ThreadId.xy, 3571 + (float)s);
        float u = uv.x + 1 / sizeX * offset;
        float v = uv.y + 1 / sizeY * offset;
        cam.GetRay(u, v, rayline);
        color += RenderSceneColor(rayline, ThreadId.xy);
    }
    color = color / float(ns);

	
    OutputSurface[ThreadId.xy] = float4(color, 1);
}

SUMMARY AND OUTLOOK：

全依赖一个computeshader来做光线追踪肯定不现实的，前面几卷主要是为了理解光纤追踪的原理，后面将开启RTX的研究。

Enjoy it ！

NEXT：

YivanLee：虚幻4渲染编程（光线追踪篇）【第四卷：Realtime Raytracing In UE4】

cpongo11
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
优化的三角网格曲面求交算法
06-28
针对当前三角网格曲面求交算法存在计算效率不高、交线追踪困难的问题.提出了一种优化的三角网格曲面求交算法,通过建立层次包围盒、改进三角形对求交方法提高曲面求交效率,并利用拓扑关系优化交线生成的追踪过程.研究结果表明:在保证精度的前提下,该算法能够提高三角网格曲面的求交效率.
BluePrintRenderer:Javascript虚幻引擎4蓝图渲染器
05-02
《JavaScript虚幻引擎4蓝图渲染器详解》 在IT领域，虚幻引擎4（Unreal Engine 4，简称UE4）是一款广泛应用于游戏开发、视觉特效制作和虚拟现实的高级实时3D引擎。其强大的图形渲染能力和灵活的蓝图系统使得非编程...
games101-Assignment05光线追踪-光线与三角形相交
weixin_46525412的博客
05-18 502
要求： 修改Render()和rayTriangleIntersect()： Renderer.cpp 中的 Render()：这里你需要为每个像素生成一条对应的光线，然后调用函数 castRay() 来得到颜色，最后将颜色存储在帧缓冲区的相应像素中。 Triangle.hpp 中的 rayTriangleIntersect(): v0, v1, v2 是三角形的三个顶点，orig 是光线的起点，dir 是光线单位化的方向向量。tnear, u, v 是你需要使用我们课上推导的 Moller-Trumbo
学习光线追踪(10)---三角形
ARTELE的博客
05-17 804
0.简介 在OpenGL或者D3D中，都有一个最基本的图元，就是三角形，三角形可以组成任意形状，并且计算起来也容易，为了能让我们绘制出更多的形状，这次来实现一个三角形类。 1.三角形判断 三角形在空间中形成了一个平面，所以，三角形一定在某个平面上，所以先判断光线是否能打到扫三角形所在平面，如果光线打到了三角形所在平面，那么再计算打在平面上的点是否在三角形内。判断光线是否打在平面上已经在上一节...
三维空间中射线与三角形求交
闪电彬彬的博客
12-27 1400
空间中直线与三角形求交
Unity/C# 求三维空间中两个三角形相交的算法
LanQ的博客
01-31 3619
原理在这里：https://web.stanford.edu/class/cs277/resources/papers/Moller1997b.pdf 这里有一个老哥写的中文笔记： https://blog.csdn.net/shenyi0_0/article/details/107831862 这篇论文也有对这个算法的一定解释： 三维网格模型实体布尔运算方法的研究与实现 杨兰 代码如下： // Tomas Moller 快速三角形求交算法 var T1 = targetMesh.trian
pizzapushUnrealEngineGame：虚幻引擎4-第三人称平台游戏
02-06
虚幻引擎4（Unreal Engine 4，简称UE4）是由Epic Games开发的一款强大、功能全面的游戏开发引擎，被广泛应用于制作各种类型的游戏，包括第一人称、第三人称、平台跳跃等多种游戏模式。"pizzapushUnrealEngineGame...
第三人称射击：我的虚幻引擎4项目之一的代码示例
02-06
在本项目"第三人称射击：我的虚幻引擎4项目之一的代码示例"中，我们将深入探讨如何利用C++和Unreal Engine C++ API构建一个完整的第三人称射击游戏。 1. **基础架构**： - **Actor类**：所有在UE4中的实体都继承自...
基于虚幻4引擎的三维游戏开发实践
02-25
虚幻4引擎是Epic Games开发的一款强大的实时三维创作工具，广泛应用于游戏开发、影视制作、建筑设计等多个领域。本实践教程旨在深入探讨如何利用虚幻4进行三维游戏的开发，结合相关参考文献，帮助读者从基础到进阶，...
房燕良-虚幻4渲染系统架构解析
09-25
该文档来自MDCC 2016中国移动开发者大会。房燕良发表了题为“虚幻4渲染系统架构解析”的主题演讲，欢迎下载！
光线追踪算法
10-15
光线追踪算法应用的一个小场景，图形学的朋友结业作业可以进来看看
光线追踪算法实现C++实现
09-03
课程作业写的光线追踪算法 包含说明文档C++代码编写场景文件包含 球体 三角形 平面 光源 材料质 镜面 漫反射
如何将虚幻导出的三角面模型转换为四边面
热门推荐
小星的博客
05-24 1万+
将导出的FBX文件在3dmax中打开如图即可
Unity3D ShaderLab 物体相交
qq_37340753的博客
10-15 1704
物体相交物体相交思路实现效果 物体相交 利用深度图来做效果，不提供数学原理，只提供Shader脚本实现。 思路 已知需要渲染物体的深度信息，通过与_CameraDepthTexture纹理中的深度值进行一些计算或者判定即可完成相交的效果。 计算方式：在视图(View)坐标系下，假设物体深度值为eyeZeyeZeyeZ，深度缓存中的深度值为sceneZsceneZsceneZ，相交宽度为IntersectionWidthIntersectionWidthIntersectionWidth；通过abs(eyeZ
光线追踪学习：GPU端光线追踪学习
wqdqwass的博客
02-15 1940
文章目录原文学习前言一、前置条件1.内容2.难点二、前置代码（sheder和三角形等设置）1.画面渲染2.Shader的使用3.材质信息4.在 shader 中进行三角形求交5.相机配置三、使用线性化的BVH树进行优化1. 构建BVH2. BVH 数据传送到 shader3. 和 AABB 盒子求交4. 非递归遍历 BVH 树四、开始光线追踪1. 原理总结 原文学习 GPU加速光线追踪 前言 之前跟着上文作者的博客学习了蒙卡罗特路径追踪，在CPU端模拟实现光追效果图片。但是渲染消耗过大，如果想要实现的更
线段与三角形求交
ziren235的专栏
08-19 3380
最近需要用到这个求交计算，开始看了《计算机图形学几何工具算法详解》，里面的讲解很详细，但是给出的代码有点问题，而且用到的类/结构体的定义并没有给出，所以只能自己猜测，后来发现有的时候求出的结果有误，所以又在网上搜了一下，自己再整理如下，大家可以直接拷贝粘贴过去使用。该算法主要思想是先求出线段与三角形所在平面的交点，然后判断该交点是否位于三角形内部。利用三角形(顶点为V0, V1, V2)内
图形学之光线与三角形求交
他的博客
04-16 1510
三角形平面内任意点P可由三角形三个顶点表示： P=wA+uB+vCP = wA + uB + vCP=wA+uB+vC 根据重心坐标性质w + u + v = 1： P=(1−u−v)A+uB+vCP = (1 - u - v)A + uB + vCP=(1−u−v)A+uB+vC P=A−uA−vA+uB+vC=A+u(B−A)+v(C−A)P=A - uA - vA + uB + vC = A + u(B - A) + v(C - A)P=A−uA−vA+uB+vC=A+u(B−A)+v(C−A) 光线
学习光线追踪(13)---改进一下三角形碰撞光线的算法
ARTELE的博客
05-17 745
0.简介 之前绘制了一面墙之后，发现墙的斜对角有缝隙，找到了原因后，更换了其算法。这里借鉴下面这篇博客中介绍的随后一种方法。 参考文章 具体原理就不在重复了。 1.修改 为了方便对比，我把原来的算法和新的算法都整理成了一个新的函数，这样编码也规则很多。 光线碰撞代码做了一些修改，将判断点在三角形内部换成了一个函数，而不是原来的一堆代码. Ray Triangle::intersec...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

cpongo11

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值