使用几何裁剪图进行地形渲染

GLubyte *pv = vertices;

// Block
for (unsigned int z = 0; z < size; z++)
{
for (unsigned int x = 0; x < size; x++)
{
pv[0] = x;
pv[1] = z;
pv += 2;
}
}

static GLushort *generate_block_indices(GLushort *pi, unsigned int vertex_buffer_offset,
unsigned int width, unsigned int height)
{
// Stamp out triangle strips back and forth.
int pos = vertex_buffer_offset;
unsigned int strips = height - 1;

// After even indices in a strip, always step to next strip.
// After odd indices in a strip, step back again and one to the right or left.
// Which direction we take depends on which strip we're generating.
// This creates a zig-zag pattern.
for (unsigned int z = 0; z < strips; z++)
{
int step_even = width;
int step_odd = ((z & 1) ? -1 : 1) - step_even;

// We don't need the last odd index.
// The first index of the next strip will complete this strip.
for (unsigned int x = 0; x < 2 * width - 1; x++)
{
*pi++ = pos;
pos += (x & 1) ? step_odd : step_even;
}
}
// There is no new strip, so complete the block here.
*pi++ = pos;

// Return updated index buffer pointer.
// More explicit than taking reference to pointer.
return pi;
}

// The clipmap levels only move in steps of texture coordinates.
// Computes top-left world position for the levels.
vec2 GroundMesh::get_offset_level(const vec2& camera_pos, unsigned int level)
{
if (level == 0) // Must follow level 1 as trim region is fixed.
return get_offset_level(camera_pos, 1) + vec2(size << 1);
else
{
vec2 scaled_pos = camera_pos / vec2(clipmap_scale); // Snap to grid in the appropriate space.

// Snap to grid of next level. I.e. we move the clipmap level in steps of two.
vec2 snapped_pos = vec_floor(scaled_pos / vec2(1 << (level + 1))) * vec2(1 << (level + 1));

// Apply offset so all levels align up neatly.
// If snapped_pos is equal for all levels,
// this causes top-left vertex of level N to always align up perfectly with top-left interior corner of level N + 1.
// This gives us a bottom-right trim region.

// Due to the flooring, snapped_pos might not always be equal for all levels.
// The flooring has the property that snapped_pos for level N + 1 is less-or-equal snapped_pos for level N.
// If less, the final position of level N + 1 will be offset by -2 ^ N, which can be compensated for with changing trim-region to top-left.
vec2 pos = snapped_pos - vec2((2 * (size - 1)) << level);
return pos;
}
}

GL_CHECK(glGenTextures(1, &texture));
GL_CHECK(glBindTexture(GL_TEXTURE_2D_ARRAY, texture));

// Use half-float as we don't need full float precision.
// GL_RG16UI would work as well as we don't need texture filtering.
// 8-bit does not give sufficient precision except for low-detail heightmaps.
// Use two components to allow storing current level's height as well as the height of the next level.
GL_CHECK(glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RG16F, size, size, levels));

GL_CHECK(glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST));
GL_CHECK(glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST));

// The repeat is crucial here. This allows us to update small sections of the texture when moving the camera.
GL_CHECK(glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_REPEAT));
GL_CHECK(glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_REPEAT));

GL_CHECK(glBindTexture(GL_TEXTURE_2D_ARRAY, 0));

void Heightmap::update_region(vec2 *buffer, unsigned int& pixel_offset, int tex_x, int tex_y,
int width, int height,
int start_x, int start_y,
int level)
{
if (width == 0 || height == 0)
return;

// Here we could either stream a "real" heightmap, or generate it procedurally on the GPU by rendering to these regions.

buffer += pixel_offset;
for (int y = 0; y < height; y++)
for (int x = 0; x < width; x++)
buffer[y * width + x] = compute_heightmap(start_x + x, start_y + y, level);

UploadInfo info;
info.x = tex_x;
info.y = tex_y;
info.width = width;
info.height = height;
info.level = level;
info.offset = pixel_offset * sizeof(vec2);
upload_info.push_back(info);

pixel_offset += width * height;
}

// Compute the height at texel (x, y) for cliplevel.
// Also compute the sample for the lower resolution (with simple bilinear).
// This avoids an extra texture lookup in vertex shader, avoids complex offseting and having to use GL_LINEAR.
vec2 Heightmap::compute_heightmap(int x, int y, int level)
{
float height = sample_heightmap(x << level, y << level);
float heights[2][2];
for (int j = 0; j < 2; j++)
for (int i = 0; i < 2; i++)
heights[j][i] = sample_heightmap(((x + i) & ~1) << level, ((y + j) & ~1) << level);

return vec2(
height,
(heights[0][0] + heights[0][1] + heights[1][0] + heights[1][1]) * 0.25f);
}

bool Frustum::intersects_aabb(const AABB& aabb) const
{
// If all corners of an axis-aligned bounding box are on the "wrong side" (negative distance)
// of at least one of the frustum planes, we can safely cull the mesh.
vec4 corners[8];
for (unsigned int c = 0; c < 8; c++)
{
// Require 4-dimensional coordinates for plane equations.
corners[c] = vec4(aabb.corner(c), 1.0f);
}

for (unsigned int p = 0; p < 6; p++)
{
bool inside_plane = false;
for (unsigned int c = 0; c < 8; c++)
{
// If dot product > 0, we're "inside" the frustum plane,
// otherwise, outside.
if (vec_dot(corners[c], planes[p]) > 0.0f)
{
inside_plane = true;
break;
}
}

if (!inside_plane)
return false;
}

return true;
}

Frustum::Frustum(const mat4& view_projection)
{
// Frustum planes are in world space.
mat4 inv = mat_inverse(view_projection);

// Get world-space coordinates for clip-space bounds.
vec4 lbn = inv * vec4(-1, -1, -1, 1);
vec4 ltn = inv * vec4(-1, 1, -1, 1);
vec4 lbf = inv * vec4(-1, -1, 1, 1);
vec4 rbn = inv * vec4( 1, -1, -1, 1);
vec4 rtn = inv * vec4( 1, 1, -1, 1);
vec4 rbf = inv * vec4( 1, -1, 1, 1);
vec4 rtf = inv * vec4( 1, 1, 1, 1);

// Divide by w.
vec3 lbn_pos = vec_project(lbn);
vec3 ltn_pos = vec_project(ltn);
vec3 lbf_pos = vec_project(lbf);
vec3 rbn_pos = vec_project(rbn);
vec3 rtn_pos = vec_project(rtn);
vec3 rbf_pos = vec_project(rbf);
vec3 rtf_pos = vec_project(rtf);

// Get plane normals for all sides of frustum.
vec3 left_normal = vec_normalize(vec_cross(lbf_pos - lbn_pos, ltn_pos - lbn_pos));
vec3 right_normal = vec_normalize(vec_cross(rtn_pos - rbn_pos, rbf_pos - rbn_pos));
vec3 top_normal = vec_normalize(vec_cross(ltn_pos - rtn_pos, rtf_pos - rtn_pos));
vec3 bottom_normal = vec_normalize(vec_cross(rbf_pos - rbn_pos, lbn_pos - rbn_pos));
vec3 near_normal = vec_normalize(vec_cross(ltn_pos - lbn_pos, rbn_pos - lbn_pos));
vec3 far_normal = vec_normalize(vec_cross(rtf_pos - rbf_pos, lbf_pos - rbf_pos));

// Plane equations compactly represent a plane in 3D space.
// We want a way to compute the distance to the plane while preserving the sign to know which side we're on.
// Let:
// O: an arbitrary point on the plane
// N: the normal vector for the plane, pointing in the direction
// we want to be "positive".
// X: Position we want to check.
//
// Distance D to the plane can now be expressed as a simple operation:
// D = dot((X - O), N) = dot(X, N) - dot(O, N)
//
// We can reduce this to one dot product by assuming that X is four-dimensional (4th component = 1.0).
// The normal can be extended to four dimensions as well:
// X' = vec4(X, 1.0)
// N' = vec4(N, -dot(O, N))
//
// The expression now reduces to: D = dot(X', N')
planes[0] = vec4(near_normal, -vec_dot(near_normal, lbn_pos)); // Near
planes[1] = vec4(far_normal, -vec_dot(far_normal, lbf_pos)); // Far
planes[2] = vec4(left_normal, -vec_dot(left_normal, lbn_pos)); // Left
planes[3] = vec4(right_normal, -vec_dot(right_normal, rbn_pos)); // Right
planes[4] = vec4(top_normal, -vec_dot(top_normal, ltn_pos)); // Top
planes[5] = vec4(bottom_normal, -vec_dot(bottom_normal, lbn_pos)); // Bottom
}

#version 300 es
layout(std140) uniform; // Use std140 packing rules for uniform blocks.
in vec4 aVertex;
uniform VertexData
{
mat4 viewProjection; // Let the view-projection matrix be backed a buffer object.
} vertex;

void main()
{
gl_Position = vertex.viewProjection * aVertex;
}

GLuint block = glGetUniformBlockIndex(program, "VertexData"); // Note the use of VertexData and not vertex.

glUniformBlockBinding(program, block, 0);

glBindBufferBase(GL_UNIFORM_BUFFER, 0, buffer_object); // Binds the entire object.
glBindBufferRange(GL_UNIFORM_BUFFER, 0, buffer_object, offset, size); // Binds a range of the object.