mirror of
https://git.davidovski.xyz/dot.git
synced 2026-09-14 00:35:24 +00:00
266 lines
8.8 KiB
GLSL
266 lines
8.8 KiB
GLSL
#version 330
|
|
#define PI 3.14159265
|
|
|
|
// These shaders work by using a pinhole camera and raycasting
|
|
// The window 3d objects will always be (somewhat) centered at (0, 0, 0)
|
|
struct pinhole_camera
|
|
{
|
|
float focal_offset; // Distance along the Z axis between the camera
|
|
// center and the focal point. Use negative values
|
|
// so the image doesn't flip
|
|
// This kinda works like FOV in games
|
|
|
|
// Transformations
|
|
// Use these to modify the coordinate system of the camera plane
|
|
vec3 rotations; // Rotations in radians around each axis
|
|
// The camera plane rotates around
|
|
// its center point, not the origin
|
|
|
|
vec3 translations; // Translations in pixels along each axis
|
|
|
|
vec3 deformations; // Deforms the camera. Higher values on each axis
|
|
// means the window will be squashed in that axis
|
|
|
|
// ---------------------------------------------------------------//
|
|
|
|
// "Aftervalues"
|
|
// These will be set later with setup_camera(), leave them as 0
|
|
vec3 base_x;
|
|
vec3 base_y;
|
|
vec3 base_z;
|
|
vec3 center_point;
|
|
vec3 focal_point;
|
|
};
|
|
|
|
in vec2 texcoord; // texture coordinate of the fragment
|
|
|
|
uniform sampler2D tex; // texture of the window
|
|
|
|
|
|
uniform float time; // Time in miliseconds.
|
|
|
|
float time_cyclic = mod(time/10000,2); // Like time, but in seconds and resets to
|
|
// 0 when it hits 2. Useful for using it in
|
|
// periodic functions like cos and sine
|
|
// Time variables can be used to change transformations over time
|
|
|
|
|
|
ivec2 window_size = textureSize(tex, 0); // Size of the window
|
|
|
|
float window_diagonal = length(window_size); // Diagonal of the window
|
|
// Try to keep focal offset and translations proportional to window_size components
|
|
// or window_diagonal as you see fit
|
|
|
|
pinhole_camera camera =
|
|
pinhole_camera(-window_size.y/2, // Focal offset
|
|
vec3(0,0,0), // Rotations
|
|
vec3(0), // Translations
|
|
vec3(1,1,1), // Deformations
|
|
// Leave the rest as 0
|
|
vec3(0),
|
|
vec3(0),
|
|
vec3(0),
|
|
vec3(0),
|
|
vec3(0));
|
|
|
|
// Here are some presets you can use
|
|
|
|
// Moves the camera up and down
|
|
pinhole_camera bobbing =
|
|
pinhole_camera(-window_size.y/2,
|
|
vec3(0,0,0),
|
|
vec3(0,cos(time_cyclic*PI)*window_size.y/16,-window_size.y/4),
|
|
vec3(1,1,1),
|
|
vec3(0),
|
|
vec3(0),
|
|
vec3(0),
|
|
vec3(0),
|
|
vec3(0));
|
|
|
|
// Rotates camera around the origin
|
|
// Makes the window rotate around the Y axis from the camera's POV
|
|
// (if the window is centered)
|
|
pinhole_camera rotate_around_origin =
|
|
pinhole_camera(-window_diagonal,
|
|
vec3(0,-time_cyclic*PI-PI/2,0),
|
|
vec3(cos(time_cyclic*PI)*window_diagonal,
|
|
0,
|
|
sin(time_cyclic*PI)*window_diagonal),
|
|
vec3(1,1,1),
|
|
vec3(0),
|
|
vec3(0),
|
|
vec3(0),
|
|
vec3(0),
|
|
vec3(0));
|
|
|
|
// Rotate camera around its center
|
|
pinhole_camera rotate_around_itself =
|
|
pinhole_camera(-window_diagonal,
|
|
vec3(0,-time_cyclic*PI-PI/2,0),
|
|
vec3(0,0,-window_diagonal),
|
|
vec3(1,1,1),
|
|
vec3(0),
|
|
vec3(0),
|
|
vec3(0),
|
|
vec3(0),
|
|
vec3(0));
|
|
|
|
// Here you can select the preset to use
|
|
pinhole_camera window_cam = rotate_around_origin;
|
|
|
|
|
|
|
|
ivec2 window_center = ivec2(window_size.x/2, window_size.y/2);
|
|
|
|
// Default window post-processing:
|
|
// 1) invert color
|
|
// 2) opacity / transparency
|
|
// 3) max-brightness clamping
|
|
// 4) rounded corners
|
|
vec4 default_post_processing(vec4 c);
|
|
|
|
// Sets up a camera by applying transformations and
|
|
// calculating xyz vector basis
|
|
pinhole_camera setup_camera(pinhole_camera camera)
|
|
{
|
|
// Apply translations
|
|
camera.center_point += camera.translations;
|
|
|
|
// Apply rotations
|
|
// We initialize our vector basis as normalized vectors
|
|
// in each axis * our deformations vector
|
|
camera.base_x = vec3(camera.deformations.x, 0, 0);
|
|
camera.base_y = vec3(0, camera.deformations.y, 0);
|
|
camera.base_z = vec3(0, 0, camera.deformations.z);
|
|
|
|
|
|
// Then we rotate them around following our rotations vector:
|
|
// First save these values to avoid redundancy
|
|
float cosx = cos(camera.rotations.x);
|
|
float cosy = cos(camera.rotations.y);
|
|
float cosz = cos(camera.rotations.z);
|
|
float sinx = sin(camera.rotations.x);
|
|
float siny = sin(camera.rotations.y);
|
|
float sinz = sin(camera.rotations.z);
|
|
|
|
// Declare a buffer vector we will use to apply multiple changes at once
|
|
vec3 tmp = vec3(0);
|
|
|
|
// Rotations for base_x:
|
|
tmp = camera.base_x;
|
|
// X axis:
|
|
tmp.y = camera.base_x.y * cosx - camera.base_x.z * sinx;
|
|
tmp.z = camera.base_x.y * sinx + camera.base_x.z * cosx;
|
|
camera.base_x = tmp;
|
|
// Y axis:
|
|
tmp.x = camera.base_x.x * cosy + camera.base_x.z * siny;
|
|
tmp.z = -camera.base_x.x * siny + camera.base_x.z * cosy;
|
|
camera.base_x = tmp;
|
|
// Z axis:
|
|
tmp.x = camera.base_x.x * cosz - camera.base_x.y * sinz;
|
|
tmp.y = camera.base_x.x * sinz + camera.base_x.y * cosz;
|
|
camera.base_x = tmp;
|
|
|
|
// Rotations for base_y:
|
|
tmp = camera.base_y;
|
|
// X axis:
|
|
tmp.y = camera.base_y.y * cosx - camera.base_y.z * sinx;
|
|
tmp.z = camera.base_y.y * sinx + camera.base_y.z * cosx;
|
|
camera.base_y = tmp;
|
|
// Y axis:
|
|
tmp.x = camera.base_y.x * cosy + camera.base_y.z * siny;
|
|
tmp.z = -camera.base_y.x * siny + camera.base_y.z * cosy;
|
|
camera.base_y = tmp;
|
|
// Z axis:
|
|
tmp.x = camera.base_y.x * cosz - camera.base_y.y * sinz;
|
|
tmp.y = camera.base_y.x * sinz + camera.base_y.y * cosz;
|
|
camera.base_y = tmp;
|
|
|
|
// Rotations for base_z:
|
|
tmp = camera.base_z;
|
|
// X axis:
|
|
tmp.y = camera.base_z.y * cosx - camera.base_z.z * sinx;
|
|
tmp.z = camera.base_z.y * sinx + camera.base_z.z * cosx;
|
|
camera.base_z = tmp;
|
|
// Y axis:
|
|
tmp.x = camera.base_z.x * cosy + camera.base_z.z * siny;
|
|
tmp.z = -camera.base_z.x * siny + camera.base_z.z * cosy;
|
|
camera.base_z = tmp;
|
|
// Z axis:
|
|
tmp.x = camera.base_z.x * cosz - camera.base_z.y * sinz;
|
|
tmp.y = camera.base_z.x * sinz + camera.base_z.y * cosz;
|
|
camera.base_z = tmp;
|
|
|
|
// Now that we have our transformed 3d orthonormal base
|
|
// we can calculate our focal point
|
|
camera.focal_point = camera.center_point + camera.base_z * camera.focal_offset;
|
|
|
|
// Return our set up camera
|
|
return camera;
|
|
}
|
|
|
|
vec4 get_pixel_through_camera(vec2 coords, pinhole_camera camera)
|
|
{
|
|
// Offset coords
|
|
coords -= window_center;
|
|
|
|
// Find the pixel 3d position using the camera vector basis
|
|
vec3 pixel_3dposition = camera.center_point
|
|
+ coords.x * camera.base_x
|
|
+ coords.y * camera.base_y;
|
|
|
|
// Get the vector going from the focal point to the pixel in 3d sapace
|
|
vec3 focal_vector = pixel_3dposition - camera.focal_point;
|
|
|
|
// Let's say we have a plane for our window following the plane equation
|
|
// ax + by + cz = d
|
|
float a = 0;
|
|
float b = 0;
|
|
float c = 1;
|
|
float d = 0;
|
|
// Then there's a line going from our focal point to the plane
|
|
// which we can describe as:
|
|
// x(t) = focal_point.x + focal_vector.x * t
|
|
// y(t) = focal_point.y + focal_vector.y * t
|
|
// z(t) = focal_point.z + focal_vector.z * t
|
|
// We substitute x, y and z with x(t), y(t) and z(t) in our plane EQ
|
|
// Solving for t we get:
|
|
float t = (d
|
|
- a*camera.focal_point.x
|
|
- b*camera.focal_point.y
|
|
- c*camera.focal_point.z)
|
|
/ (a*focal_vector.x
|
|
+ b*focal_vector.y
|
|
+ c*focal_vector.z);
|
|
|
|
// If the point we end up in is behind our camera, don't "render" it
|
|
if (t < 1)
|
|
{
|
|
return vec4(0);
|
|
}
|
|
|
|
// Then we multiply our focal vector by t and add our focal point to it
|
|
// to end up in a point inside the window plane
|
|
vec3 intersection = focal_vector * t + camera.focal_point;
|
|
|
|
// Save x and y coordinates and add back our initial offset
|
|
vec2 cam_coords = intersection.xy + window_center;
|
|
|
|
// If pixel is outside of our window region
|
|
// return a completely transparent color
|
|
if (cam_coords.x >=window_size.x-1 ||
|
|
cam_coords.y >=window_size.y-1 ||
|
|
cam_coords.x <=0 || cam_coords.y <=0)
|
|
{
|
|
return vec4(0);
|
|
}
|
|
|
|
// Fetch the pixel
|
|
vec4 pixel = texelFetch(tex, ivec2(cam_coords), 0);
|
|
return pixel;
|
|
}
|
|
|
|
vec4 window_shader() {
|
|
pinhole_camera transformed_cam = setup_camera(window_cam);
|
|
return(get_pixel_through_camera(texcoord, transformed_cam));
|
|
}
|