我试图在我的OpenGL / C ++渲染器中实现级联阴影贴图。当从任意数字构建正交矩阵并保持在场景的原点时，我已经成功地设法实现了定向阴影映射。从我能看到的一切来看，我所遇到的问题是根据视锥体的切片决定正交矩阵的界限。
我发现了两种计算方法，两者都是相关的;第一种方法使用当前切片的近/远平面创建投影矩阵，然后将其反转。然后我在NDC空间中取一个立方体的角（每个轴的范围从[-1：+1]），将它乘以反转投影矩阵，倒置视图矩阵，然后是光空间矩阵;然后把整个事情划分为角落的＆＃39; w＆＃39;
vec4 corners[8] =
{
// Near plane
{ 1, 1, 1, 1 },
{ -1, 1, 1, 1 },
{ 1, -1, 1, 1 },
{ -1, -1, 1, 1 },
// Far plane
{ 1, 1, -1, 1 },
{ -1, 1, -1, 1 },
{ 1, -1, -1, 1 },
{ -1, -1, -1, 1 }
};
// Create a projection matrix for this cascade.
// This will transform the corner from camera space to view space.
mat4 proj = mat4::perspective(fov, aspect, near_plane, far_plane);
// B.inverted()*A.inverted() == C.inverted() == (A*B).inverted()
// This is now an inverted viewproj matrix, which transforms the corner from camera space to world space.
mat4 inv_viewproj = (proj * view_matrix).inverted();
// This is the matrix that transforms each corner from camera space to light space.
// (this_frame.view is the light-space view matrix)
mat4 matrix = this_frame.view * matrix;
float minx = FLT_MAX;
float maxx = -FLT_MAX;
float miny = FLT_MAX;
float maxy = -FLT_MAX;
float minz = FLT_MAX;
float maxz = -FLT_MAX;
// For each frustum corner...
for (uint32_t i = 0; i < 8; ++i)
{
corners[i] = matrix * corners[i];
corners[i] /= corners[i].w;
minx = min(minx, corners[i].x);
maxx = max(maxx, corners[i].x);
miny = min(miny, corners[i].y);
maxy = max(maxy, corners[i].y);
minz = min(minz, corners[i].z);
maxz = max(maxz, corners[i].z);
}
this_frame.proj = mat4::ortho(minx, maxx, miny, maxy, minz, maxz);
第二种方式类似，它从视图空间中的一组角开始，减少了除以w并保存一些矩阵反转的需要。
mat4 inv_view = view_matrix.inverted();
float tan_half_hfov = tanf(to_radians(fov * 0.5f));
float tan_half_vfov = tanf(to_radians((fov * 0.5f) / aspect));
//...
float xn = near_plane * tan_half_hfov;
float yn = near_plane * tan_half_vfov;
float xf = far_plane * tan_half_hfov;
float yf = far_plane * tan_half_vfov;
// These are the corners of the screen in view space.
// We'll be transforming these in order to get the dimensions of the view frustum.
vec4 corners[8] =
{
// Near plane
{ xn, yn, -near_plane, 1 },
{ -xn, yn, -near_plane, 1 },
{ xn, -yn, -near_plane, 1 },
{ -xn, -yn, -near_plane, 1 },
// Far plane
{ xf, yf, -far_plane, 1 },
{ -xf, yf, -far_plane, 1 },
{ xf, -yf, -far_plane, 1 },
{ -xf, -yf, -far_plane, 1 }
};
// This is the matrix that transforms each corner from camera space to light space.
mat4 matrix = this_frame.view * inv_view;
float minx = FLT_MAX;
float maxx = -FLT_MAX;
float miny = FLT_MAX;
float maxy = -FLT_MAX;
float minz = FLT_MAX;
float maxz = -FLT_MAX;
// For each frustum corner...
for (uint32_t i = 0; i < 8; ++i)
{
corners[i] = matrix * corners[i];
minx = min(minx, corners[i].x);
maxx = max(maxx, corners[i].x);
miny = min(miny, corners[i].y);
maxy = max(maxy, corners[i].y);
minz = min(minz, corners[i].z);
maxz = max(maxz, corners[i].z);
}
this_frame.proj = mat4::ortho(minx, maxx, miny, maxy, minz, maxz);
两者都会产生不正确但有点接近正确的结果。第二种方法似乎会产生一个更紧凑的方框。
有趣的是，当相机在光照空间中沿x轴移动时，两者似乎都会起作用。每当相机在光照空间中沿y / z轴移动时，您会得到一些非常错误的结果。
以下是我所谈论的一些图片。每对中的第一个是根据正常摄像机视角的场景，第二个是从光的视角（第一个级联，我甚至不会尝试第二个级联，直到第一个正常工作）。红色区域应该包含在第一个级联中，绿色区域是后来的级联，而无阴影区域位于视锥体之外。
（这些截图是使用方法＃1拍摄的）
到目前为止这么好，对吗？良好...
有一段时间我认为问题可能出在我的mat4::inverted()函数中，但我尝试了两种不同的实现，它们都给出了相同的结果。我目前使用的是：
mat4 mat4::inverted() const
{
float invdet = 1.0f / determinant();
// Note: This constructor for mat4 accepts a series of 16 floats as a row-major matrix,
// as that's simply more natural to write out,
// then converts it automatically to the correct column-major storage.
return {
(m12*m23*m31 - m13*m22*m31 + m13*m21*m32 - m11*m23*m32 - m12*m21*m33 + m11*m22*m33) * invdet,
(m03*m22*m31 - m02*m23*m31 - m03*m21*m32 + m01*m23*m32 + m02*m21*m33 - m01*m22*m33) * invdet,
(m02*m13*m31 - m03*m12*m31 + m03*m11*m32 - m01*m13*m32 - m02*m11*m33 + m01*m12*m33) * invdet,
(m03*m12*m21 - m02*m13*m21 - m03*m11*m22 + m01*m13*m22 + m02*m11*m23 - m01*m12*m23) * invdet,
(m13*m22*m30 - m12*m23*m30 - m13*m20*m32 + m10*m23*m32 + m12*m20*m33 - m10*m22*m33) * invdet,
(m02*m23*m30 - m03*m22*m30 + m03*m20*m32 - m00*m23*m32 - m02*m20*m33 + m00*m22*m33) * invdet,
(m03*m12*m30 - m02*m13*m30 - m03*m10*m32 + m00*m13*m32 + m02*m10*m33 - m00*m12*m33) * invdet,
(m02*m13*m20 - m03*m12*m20 + m03*m10*m22 - m00*m13*m22 - m02*m10*m23 + m00*m12*m23) * invdet,
(m11*m23*m30 - m13*m21*m30 + m13*m20*m31 - m10*m23*m31 - m11*m20*m33 + m10*m21*m33) * invdet,
(m03*m21*m30 - m01*m23*m30 - m03*m20*m31 + m00*m23*m31 + m01*m20*m33 - m00*m21*m33) * invdet,
(m01*m13*m30 - m03*m11*m30 + m03*m10*m31 - m00*m13*m31 - m01*m10*m33 + m00*m11*m33) * invdet,
(m03*m11*m20 - m01*m13*m20 - m03*m10*m21 + m00*m13*m21 + m01*m10*m23 - m00*m11*m23) * invdet,
(m12*m21*m30 - m11*m22*m30 - m12*m20*m31 + m10*m22*m31 + m11*m20*m32 - m10*m21*m32) * invdet,
(m01*m22*m30 - m02*m21*m30 + m02*m20*m31 - m00*m22*m31 - m01*m20*m32 + m00*m21*m32) * invdet,
(m02*m11*m30 - m01*m12*m30 - m02*m10*m31 + m00*m12*m31 + m01*m10*m32 - m00*m11*m32) * invdet,
(m01*m12*m20 - m02*m11*m20 + m02*m10*m21 - m00*m12*m21 - m01*m10*m22 + m00*m11*m22) * invdet };
}
float mat4::determinant() const
{
return
m03*m12*m21*m30 - m02*m13*m21*m30 - m03*m11*m22*m30 + m01*m13*m22*m30 +
m02*m11*m23*m30 - m01*m12*m23*m30 - m03*m12*m20*m31 + m02*m13*m20*m31 +
m03*m10*m22*m31 - m00*m13*m22*m31 - m02*m10*m23*m31 + m00*m12*m23*m31 +
m03*m11*m20*m32 - m01*m13*m20*m32 - m03*m10*m21*m32 + m00*m13*m21*m32 +
m01*m10*m23*m32 - m00*m11*m23*m32 - m02*m11*m20*m33 + m01*m12*m20*m33 +
m02*m10*m21*m33 - m00*m12*m21*m33 - m01*m10*m22*m33 + m00*m11*m22*m33;
}
我到底做错了什么？
答案 0 :(得分：0)
vec4 corners[8] =
{
// Near plane
{ 1, 1, 1, 1 },
{ -1, 1, 1, 1 },
{ 1, -1, 1, 1 },
{ -1, -1, 1, 1 },
// Far plane
{ 1, 1, -1, 1 },
{ -1, 1, -1, 1 },
{ 1, -1, -1, 1 },
{ -1, -1, -1, 1 }
};
让我告诉你为什么这里错了。您正在寻找屏幕。近处是深度0。远处是深度1。
vec4 corners[8] =
{
// Near plane
{ 1, 1, 0, 1 },
{ -1, 1, 0, 1 },
{ 1, -1, 0, 1 },
{ -1, -1, 0, 1 },
// Far plane
{ 1, 1, 1, 1 },
{ -1, 1, 1, 1 },
{ 1, -1, 1, 1 },
{ -1, -1, 1, 1 }
};
.....// somestuff
// For each frustum corner...
for (uint32_t i = 0; i < 8; ++i)
{
corners[i] = invVP * corners[i];
corners[i] /= corners[i].w;
... go on....
}
让我知道是否可行。