Du kan inte välja fler än 25 ämnen
Ämnen måste starta med en bokstav eller siffra, kan innehålla bindestreck ('-') och vara max 35 tecken långa.
256 rader
11 KiB
256 rader
11 KiB
/*******************************************************************************************
|
|
*
|
|
* raylib [shaders] example - shadowmap rendering
|
|
*
|
|
* Example complexity rating: [★★★★] 4/4
|
|
*
|
|
* Example originally created with raylib 5.0, last time updated with raylib 5.0
|
|
*
|
|
* Example contributed by TheManTheMythTheGameDev (@TheManTheMythTheGameDev) and reviewed by Ramon Santamaria (@raysan5)
|
|
*
|
|
* Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
|
|
* BSD-like license that allows static linking with closed source software
|
|
*
|
|
* Copyright (c) 2023-2025 TheManTheMythTheGameDev (@TheManTheMythTheGameDev)
|
|
*
|
|
********************************************************************************************/
|
|
|
|
#include "raylib.h"
|
|
|
|
#include "raymath.h"
|
|
#include "rlgl.h"
|
|
|
|
#if defined(PLATFORM_DESKTOP)
|
|
#define GLSL_VERSION 330
|
|
#else // PLATFORM_ANDROID, PLATFORM_WEB
|
|
#define GLSL_VERSION 100
|
|
#endif
|
|
|
|
#define SHADOWMAP_RESOLUTION 1024
|
|
|
|
static RenderTexture2D LoadShadowmapRenderTexture(int width, int height);
|
|
static void UnloadShadowmapRenderTexture(RenderTexture2D target);
|
|
static void DrawScene(Model cube, Model robot);
|
|
|
|
//------------------------------------------------------------------------------------
|
|
// Program main entry point
|
|
//------------------------------------------------------------------------------------
|
|
int main(void)
|
|
{
|
|
// Initialization
|
|
//--------------------------------------------------------------------------------------
|
|
const int screenWidth = 800;
|
|
const int screenHeight = 450;
|
|
|
|
// Shadows are a HUGE topic, and this example shows an extremely simple implementation of the shadowmapping algorithm,
|
|
// which is the industry standard for shadows. This algorithm can be extended in a ridiculous number of ways to improve
|
|
// realism and also adapt it for different scenes. This is pretty much the simplest possible implementation
|
|
|
|
SetConfigFlags(FLAG_MSAA_4X_HINT);
|
|
InitWindow(screenWidth, screenHeight, "raylib [shaders] example - shadowmap rendering");
|
|
|
|
Camera3D camera = (Camera3D){ 0 };
|
|
camera.position = (Vector3){ 10.0f, 10.0f, 10.0f };
|
|
camera.target = Vector3Zero();
|
|
camera.projection = CAMERA_PERSPECTIVE;
|
|
camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
|
|
camera.fovy = 45.0f;
|
|
|
|
Shader shadowShader = LoadShader(TextFormat("resources/shaders/glsl%i/shadowmap.vs", GLSL_VERSION),
|
|
TextFormat("resources/shaders/glsl%i/shadowmap.fs", GLSL_VERSION));
|
|
shadowShader.locs[SHADER_LOC_VECTOR_VIEW] = GetShaderLocation(shadowShader, "viewPos");
|
|
|
|
Vector3 lightDir = Vector3Normalize((Vector3){ 0.35f, -1.0f, -0.35f });
|
|
Color lightColor = WHITE;
|
|
Vector4 lightColorNormalized = ColorNormalize(lightColor);
|
|
int lightDirLoc = GetShaderLocation(shadowShader, "lightDir");
|
|
int lightColLoc = GetShaderLocation(shadowShader, "lightColor");
|
|
SetShaderValue(shadowShader, lightDirLoc, &lightDir, SHADER_UNIFORM_VEC3);
|
|
SetShaderValue(shadowShader, lightColLoc, &lightColorNormalized, SHADER_UNIFORM_VEC4);
|
|
int ambientLoc = GetShaderLocation(shadowShader, "ambient");
|
|
float ambient[4] = {0.1f, 0.1f, 0.1f, 1.0f};
|
|
SetShaderValue(shadowShader, ambientLoc, ambient, SHADER_UNIFORM_VEC4);
|
|
int lightVPLoc = GetShaderLocation(shadowShader, "lightVP");
|
|
int shadowMapLoc = GetShaderLocation(shadowShader, "shadowMap");
|
|
int shadowMapResolution = SHADOWMAP_RESOLUTION;
|
|
SetShaderValue(shadowShader, GetShaderLocation(shadowShader, "shadowMapResolution"), &shadowMapResolution, SHADER_UNIFORM_INT);
|
|
|
|
Model cube = LoadModelFromMesh(GenMeshCube(1.0f, 1.0f, 1.0f));
|
|
cube.materials[0].shader = shadowShader;
|
|
Model robot = LoadModel("resources/models/robot.glb");
|
|
for (int i = 0; i < robot.materialCount; i++) robot.materials[i].shader = shadowShader;
|
|
int animCount = 0;
|
|
ModelAnimation *robotAnimations = LoadModelAnimations("resources/models/robot.glb", &animCount);
|
|
|
|
RenderTexture2D shadowMap = LoadShadowmapRenderTexture(SHADOWMAP_RESOLUTION, SHADOWMAP_RESOLUTION);
|
|
|
|
// For the shadowmapping algorithm, we will be rendering everything from the light's point of view
|
|
Camera3D lightCamera = { 0 };
|
|
lightCamera.position = Vector3Scale(lightDir, -15.0f);
|
|
lightCamera.target = Vector3Zero();
|
|
lightCamera.projection = CAMERA_ORTHOGRAPHIC; // Use an orthographic projection for directional lights
|
|
lightCamera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
|
|
lightCamera.fovy = 20.0f;
|
|
|
|
int frameCounter = 0;
|
|
|
|
// Store the light matrices
|
|
Matrix lightView = { 0 };
|
|
Matrix lightProj = { 0 };
|
|
Matrix lightViewProj = { 0 };
|
|
int textureActiveSlot = 10; // Can be anything 0 to 15, but 0 will probably be taken up
|
|
|
|
SetTargetFPS(60);
|
|
//--------------------------------------------------------------------------------------
|
|
|
|
// Main game loop
|
|
while (!WindowShouldClose()) // Detect window close button or ESC key
|
|
{
|
|
// Update
|
|
//----------------------------------------------------------------------------------
|
|
float deltaTime = GetFrameTime();
|
|
|
|
Vector3 cameraPos = camera.position;
|
|
SetShaderValue(shadowShader, shadowShader.locs[SHADER_LOC_VECTOR_VIEW], &cameraPos, SHADER_UNIFORM_VEC3);
|
|
UpdateCamera(&camera, CAMERA_ORBITAL);
|
|
|
|
frameCounter++;
|
|
frameCounter %= (robotAnimations[0].frameCount);
|
|
UpdateModelAnimation(robot, robotAnimations[0], frameCounter);
|
|
|
|
// Move light with arrow keys
|
|
const float cameraSpeed = 0.05f;
|
|
if (IsKeyDown(KEY_LEFT))
|
|
{
|
|
if (lightDir.x < 0.6f) lightDir.x += cameraSpeed*60.0f*deltaTime;
|
|
}
|
|
if (IsKeyDown(KEY_RIGHT))
|
|
{
|
|
if (lightDir.x > -0.6f) lightDir.x -= cameraSpeed*60.0f*deltaTime;
|
|
}
|
|
if (IsKeyDown(KEY_UP))
|
|
{
|
|
if (lightDir.z < 0.6f) lightDir.z += cameraSpeed*60.0f*deltaTime;
|
|
}
|
|
if (IsKeyDown(KEY_DOWN))
|
|
{
|
|
if (lightDir.z > -0.6f) lightDir.z -= cameraSpeed*60.0f*deltaTime;
|
|
}
|
|
|
|
lightDir = Vector3Normalize(lightDir);
|
|
lightCamera.position = Vector3Scale(lightDir, -15.0f);
|
|
SetShaderValue(shadowShader, lightDirLoc, &lightDir, SHADER_UNIFORM_VEC3);
|
|
//----------------------------------------------------------------------------------
|
|
|
|
// Draw
|
|
//----------------------------------------------------------------------------------
|
|
// PASS 01: Render all objects into the shadowmap render texture
|
|
// We record all the objects' depths (as rendered from the light source's point of view) in a buffer
|
|
// Anything that is "visible" to the light is in light, anything that isn't is in shadow
|
|
// We can later use the depth buffer when rendering everything from the player's point of view
|
|
// to determine whether a given point is "visible" to the light
|
|
BeginTextureMode(shadowMap);
|
|
ClearBackground(WHITE);
|
|
|
|
BeginMode3D(lightCamera);
|
|
lightView = rlGetMatrixModelview();
|
|
lightProj = rlGetMatrixProjection();
|
|
DrawScene(cube, robot);
|
|
EndMode3D();
|
|
|
|
EndTextureMode();
|
|
lightViewProj = MatrixMultiply(lightView, lightProj);
|
|
|
|
// PASS 02: Draw the scene into main framebuffer, using the generated shadowmap
|
|
BeginDrawing();
|
|
ClearBackground(RAYWHITE);
|
|
|
|
SetShaderValueMatrix(shadowShader, lightVPLoc, lightViewProj);
|
|
rlEnableShader(shadowShader.id);
|
|
|
|
rlActiveTextureSlot(textureActiveSlot);
|
|
rlEnableTexture(shadowMap.depth.id);
|
|
rlSetUniform(shadowMapLoc, &textureActiveSlot, SHADER_UNIFORM_INT, 1);
|
|
|
|
BeginMode3D(camera);
|
|
DrawScene(cube, robot); // Draw the same exact things as we drew in the shadowmap!
|
|
EndMode3D();
|
|
|
|
DrawText("Use the arrow keys to rotate the light!", 10, 10, 30, RED);
|
|
DrawText("Shadows in raylib using the shadowmapping algorithm!", screenWidth - 280, screenHeight - 20, 10, GRAY);
|
|
|
|
EndDrawing();
|
|
|
|
if (IsKeyPressed(KEY_F)) TakeScreenshot("shaders_shadowmap.png");
|
|
//----------------------------------------------------------------------------------
|
|
}
|
|
|
|
// De-Initialization
|
|
//--------------------------------------------------------------------------------------
|
|
UnloadShader(shadowShader);
|
|
UnloadModel(cube);
|
|
UnloadModel(robot);
|
|
UnloadModelAnimations(robotAnimations, animCount);
|
|
UnloadShadowmapRenderTexture(shadowMap);
|
|
|
|
CloseWindow(); // Close window and OpenGL context
|
|
//--------------------------------------------------------------------------------------
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Load render texture for shadowmap projection
|
|
// NOTE: Load framebuffer with only a texture depth attachment,
|
|
// no color attachment required for shadowmap
|
|
static RenderTexture2D LoadShadowmapRenderTexture(int width, int height)
|
|
{
|
|
RenderTexture2D target = { 0 };
|
|
|
|
target.id = rlLoadFramebuffer(); // Load an empty framebuffer
|
|
target.texture.width = width;
|
|
target.texture.height = height;
|
|
|
|
if (target.id > 0)
|
|
{
|
|
rlEnableFramebuffer(target.id);
|
|
|
|
// Create depth texture
|
|
// NOTE: No need a color texture attachment for the shadowmap
|
|
target.depth.id = rlLoadTextureDepth(width, height, false);
|
|
target.depth.width = width;
|
|
target.depth.height = height;
|
|
target.depth.format = 19; // DEPTH_COMPONENT_24BIT?
|
|
target.depth.mipmaps = 1;
|
|
|
|
// Attach depth texture to FBO
|
|
rlFramebufferAttach(target.id, target.depth.id, RL_ATTACHMENT_DEPTH, RL_ATTACHMENT_TEXTURE2D, 0);
|
|
|
|
// Check if fbo is complete with attachments (valid)
|
|
if (rlFramebufferComplete(target.id)) TRACELOG(LOG_INFO, "FBO: [ID %i] Framebuffer object created successfully", target.id);
|
|
|
|
rlDisableFramebuffer();
|
|
}
|
|
else TRACELOG(LOG_WARNING, "FBO: Framebuffer object can not be created");
|
|
|
|
return target;
|
|
}
|
|
|
|
// Unload shadowmap render texture from GPU memory (VRAM)
|
|
static void UnloadShadowmapRenderTexture(RenderTexture2D target)
|
|
{
|
|
if (target.id > 0)
|
|
{
|
|
// NOTE: Depth texture/renderbuffer is automatically
|
|
// queried and deleted before deleting framebuffer
|
|
rlUnloadFramebuffer(target.id);
|
|
}
|
|
}
|
|
|
|
// Draw full scene projecting shadows
|
|
// NOTE: Required to be called several time to generate shadowmap
|
|
static void DrawScene(Model cube, Model robot)
|
|
{
|
|
DrawModelEx(cube, Vector3Zero(), (Vector3) { 0.0f, 1.0f, 0.0f }, 0.0f, (Vector3) { 10.0f, 1.0f, 10.0f }, BLUE);
|
|
DrawModelEx(cube, (Vector3) { 1.5f, 1.0f, -1.5f }, (Vector3) { 0.0f, 1.0f, 0.0f }, 0.0f, Vector3One(), WHITE);
|
|
DrawModelEx(robot, (Vector3) { 0.0f, 0.5f, 0.0f }, (Vector3) { 0.0f, 1.0f, 0.0f }, 0.0f, (Vector3) { 1.0f, 1.0f, 1.0f }, RED);
|
|
}
|