Hay*_*ach 13 c++ opengl matrix shadow
我正在尝试在我的OpenGL/C++渲染器中实现级联阴影贴图.当从任意数字构建正交矩阵并保持在场景的原点时,我已经成功地实现了定向阴影贴图.从我能看到的一切,我遇到的问题是根据视锥体的切片决定正交矩阵的界限.
我找到了两种计算方法,两者都是相关的; 第一种方法使用当前切片的近/远平面创建投影矩阵,然后将其反转.然后我在NDC空间中取一个立方体的角(每个轴的范围从[-1:+1]),将它乘以反转投影矩阵,倒置视图矩阵,然后是光空间矩阵; 然后将整个事物划分为角落的'w'.
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;
}
我到底做错了什么？
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....
}
让我知道是否有效。