124 lines
4.8 KiB
GLSL
124 lines
4.8 KiB
GLSL
/**
|
|
*
|
|
* RenderPipeline
|
|
*
|
|
* Copyright (c) 2014-2016 tobspr <tobias.springer1@gmail.com>
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
uniform mat4 trans_clip_of_mainCam_to_mainRender;
|
|
uniform mat4 trans_mainRender_to_view_of_mainCam;
|
|
uniform mat4 trans_mainRender_to_clip_of_mainCam;
|
|
|
|
// Computes linear Z from a given Z value, and near and far plane
|
|
float get_linear_z_from_z(float z, float near, float far) {
|
|
return 2.0 * near * far / (far + near - (z * 2.0 - 1) * (far - near));
|
|
}
|
|
|
|
// Computes linear Z from a given Z value
|
|
float get_linear_z_from_z(float z) {
|
|
return get_linear_z_from_z(z, CAMERA_NEAR, CAMERA_FAR);
|
|
}
|
|
|
|
// Computes the Z component from a position in NDC space
|
|
float get_z_from_ndc(vec3 ndc_pos) {
|
|
return get_linear_z_from_z(ndc_pos.z);
|
|
}
|
|
|
|
// Computes linear Z from a given Z value, and near and far plane, for orthographic projections
|
|
float get_linear_z_from_z_ortographic(float z, float near, float far) {
|
|
return 2.0 / (far + near - fma(z, 2.0, -1.0) * (far - near));
|
|
}
|
|
|
|
// Computes the surface position based on a given Z, a texcoord, and the Inverse MVP matrix
|
|
vec3 calculate_surface_pos(float z, vec2 tcoord, mat4 inverse_mvp) {
|
|
vec3 ndc_pos = fma(vec3(tcoord.xy, z), vec3(2.0), vec3(-1.0));
|
|
float clip_w = get_z_from_ndc(ndc_pos);
|
|
|
|
vec4 proj = inverse_mvp * vec4(ndc_pos * clip_w, clip_w);
|
|
return proj.xyz / proj.w;
|
|
}
|
|
|
|
// Computes the surface position based on a given Z and a texcoord
|
|
vec3 calculate_surface_pos(float z, vec2 tcoord) {
|
|
#if 0
|
|
return calculate_surface_pos(z, tcoord, trans_clip_of_mainCam_to_mainRender);
|
|
#else
|
|
float linz = get_linear_z_from_z(z);
|
|
return mix(
|
|
mix(MainSceneData.ws_frustum_directions[0],
|
|
MainSceneData.ws_frustum_directions[1], tcoord.x),
|
|
mix(MainSceneData.ws_frustum_directions[2],
|
|
MainSceneData.ws_frustum_directions[3], tcoord.x),
|
|
tcoord.y
|
|
).xyz * linz + MainSceneData.camera_pos;
|
|
#endif
|
|
}
|
|
|
|
// Computes the surface position based on a given Z and a texcoord, aswell as a
|
|
// custom near and far plane, and the inverse MVP. This is for orthographic projections
|
|
vec3 calculate_surface_pos_ortho(float z, vec2 tcoord, float near, float far, mat4 inverse_mvp) {
|
|
vec3 ndc_pos = fma(vec3(tcoord.xy, z), vec3(2.0), vec3(-1.0));
|
|
float clip_w = get_linear_z_from_z_ortographic(z, near, far);
|
|
vec4 result = inverse_mvp * vec4(ndc_pos * clip_w, clip_w);
|
|
return result.xyz / result.w;
|
|
}
|
|
|
|
// Computes the view position from a given Z value and texcoord
|
|
vec3 calculate_view_pos(float z, vec2 tcoord) {
|
|
vec4 view_pos = MainSceneData.inv_proj_mat *
|
|
vec4(fma(tcoord.xy, vec2(2.0), vec2(-1.0)), z, 1.0);
|
|
return view_pos.xyz / view_pos.w;
|
|
}
|
|
|
|
// Computes the NDC position from a given view position
|
|
vec3 view_to_screen(vec3 view_pos) {
|
|
vec4 projected = MainSceneData.proj_mat * vec4(view_pos, 1);
|
|
projected.xyz /= projected.w;
|
|
projected.xy = fma(projected.xy, vec2(0.5), vec2(0.5));
|
|
return projected.xyz;
|
|
}
|
|
|
|
// Converts a view space normal to world space
|
|
vec3 view_normal_to_world(vec3 view_normal) {
|
|
// We need to transform the coordinate system, should not be required,
|
|
// seems to be some panda bug?
|
|
view_normal = view_normal.xzy * vec3(1, -1, 1);
|
|
return normalize((vec4(view_normal, 0) * trans_mainRender_to_view_of_mainCam).xyz);
|
|
}
|
|
|
|
// Converts a world space position to screen space position (NDC)
|
|
vec3 world_to_screen(vec3 world_pos) {
|
|
vec4 proj = trans_mainRender_to_clip_of_mainCam * vec4(world_pos, 1);
|
|
proj.xyz /= proj.w;
|
|
proj.xyz = fma(proj.xyz, vec3(0.5), vec3(0.5));
|
|
return proj.xyz;
|
|
}
|
|
|
|
// Converts a world space normal to view space
|
|
vec3 world_normal_to_view(vec3 world_normal) {
|
|
vec4 proj = trans_mainRender_to_view_of_mainCam * vec4(world_normal, 0);
|
|
proj.xyz *= vec3(1, -1, 1);
|
|
return normalize(proj.xzy);
|
|
}
|