Archivist
/
raylib-src
mirror of https://github.com/raysan5/raylib


								/*******************************************************************************************

								*

								*   raylib [shaders] example - Shadowmap

								*

								*   Example originally created with raylib 5.0, last time updated with raylib 5.0

								*

								*   Example contributed by @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

								*

								********************************************************************************************/


								#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            120

								#endif


								#define SHADOWMAP_RESOLUTION 1024


								RenderTexture2D LoadShadowmapRenderTexture(int width, int height);

								void UnloadShadowmapRenderTexture(RenderTexture2D target);

								void DrawScene(Model cube, Model robot);


								//------------------------------------------------------------------------------------

								// Program main entry point

								//------------------------------------------------------------------------------------

								int main(void)

								{

								    // Initialization

								    //--------------------------------------------------------------------------------------

								    const int screenWidth = 800;

								    const int screenHeight = 450;


								    SetConfigFlags(FLAG_MSAA_4X_HINT);

								    // 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.

								    InitWindow(screenWidth, screenHeight, "raylib [shaders] example - shadowmap");


								    Camera3D cam = (Camera3D){ 0 };

								    cam.position = (Vector3){ 10.0f, 10.0f, 10.0f };

								    cam.target = Vector3Zero();

								    cam.projection = CAMERA_PERSPECTIVE;

								    cam.up = (Vector3){ 0.0f, 1.0f, 0.0f };

								    cam.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 lightCam = (Camera3D){ 0 };

								    lightCam.position = Vector3Scale(lightDir, -15.0f);

								    lightCam.target = Vector3Zero();

								    // Use an orthographic projection for directional lights

								    lightCam.projection = CAMERA_ORTHOGRAPHIC;

								    lightCam.up = (Vector3){ 0.0f, 1.0f, 0.0f };

								    lightCam.fovy = 20.0f;


								    SetTargetFPS(60);

								    //--------------------------------------------------------------------------------------

								    int fc = 0;


								    // Main game loop

								    while (!WindowShouldClose())    // Detect window close button or ESC key

								    {

								        // Update

								        //----------------------------------------------------------------------------------

								        float dt = GetFrameTime();


								        Vector3 cameraPos = cam.position;

								        SetShaderValue(shadowShader, shadowShader.locs[SHADER_LOC_VECTOR_VIEW], &cameraPos, SHADER_UNIFORM_VEC3);

								        UpdateCamera(&cam, CAMERA_ORBITAL);


								        fc++;

								        fc %= (robotAnimations[0].frameCount);

								        UpdateModelAnimation(robot, robotAnimations[0], fc);


								        const float cameraSpeed = 0.05f;

								        if (IsKeyDown(KEY_LEFT))

								        {

								            if (lightDir.x < 0.6f)

								                lightDir.x += cameraSpeed * 60.0f * dt;

								        }

								        if (IsKeyDown(KEY_RIGHT))

								        {

								            if (lightDir.x > -0.6f)

								                lightDir.x -= cameraSpeed * 60.0f * dt;

								        }

								        if (IsKeyDown(KEY_UP))

								        {

								            if (lightDir.z < 0.6f)

								                lightDir.z += cameraSpeed * 60.0f * dt;

								        }

								        if (IsKeyDown(KEY_DOWN))

								        {

								            if (lightDir.z > -0.6f)

								                lightDir.z -= cameraSpeed * 60.0f * dt;

								        }

								        lightDir = Vector3Normalize(lightDir);

								        lightCam.position = Vector3Scale(lightDir, -15.0f);

								        SetShaderValue(shadowShader, lightDirLoc, &lightDir, SHADER_UNIFORM_VEC3);


								        // Draw

								        //----------------------------------------------------------------------------------

								        BeginDrawing();


								        // First, render all objects into the shadowmap

								        // The idea is, 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


								        // Record the light matrices for future use!

								        Matrix lightView;

								        Matrix lightProj;

								        BeginTextureMode(shadowMap);

								        ClearBackground(WHITE);

								        BeginMode3D(lightCam);

								            lightView = rlGetMatrixModelview();

								            lightProj = rlGetMatrixProjection();

								            DrawScene(cube, robot);

								        EndMode3D();

								        EndTextureMode();

								        Matrix lightViewProj = MatrixMultiply(lightView, lightProj);


								        ClearBackground(RAYWHITE);


								        SetShaderValueMatrix(shadowShader, lightVPLoc, lightViewProj);


								        rlEnableShader(shadowShader.id);

								        int slot = 10; // Can be anything 0 to 15, but 0 will probably be taken up

								        rlActiveTextureSlot(10);

								        rlEnableTexture(shadowMap.depth.id);

								        rlSetUniform(shadowMapLoc, &slot, SHADER_UNIFORM_INT, 1);


								        BeginMode3D(cam);


								            // Draw the same exact things as we drew in the shadowmap!

								            DrawScene(cube, robot);


								        EndMode3D();


								        DrawText("Shadows in raylib using the shadowmapping algorithm!", screenWidth - 320, screenHeight - 20, 10, GRAY);

								        DrawText("Use the arrow keys to rotate the light!", 10, 10, 30, RED);


								        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;

								}


								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

								        // We don't need a color texture 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)

								void UnloadShadowmapRenderTexture(RenderTexture2D target)

								{

								    if (target.id > 0)

								    {

								        // NOTE: Depth texture/renderbuffer is automatically

								        // queried and deleted before deleting framebuffer

								        rlUnloadFramebuffer(target.id);

								    }

								}


								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);

								}