366 lines
13 KiB
C#
366 lines
13 KiB
C#
/*******************************************************************************************
|
|
*
|
|
* raylib [models] example - skybox rendering
|
|
*
|
|
* Example complexity rating: [★★☆☆] 2/4
|
|
*
|
|
* Example originally created with raylib 1.8, last time updated with raylib 4.0
|
|
*
|
|
* 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) 2017-2025 Ramon Santamaria (@raysan5)
|
|
*
|
|
********************************************************************************************/
|
|
|
|
using System;
|
|
using System.Numerics;
|
|
using static Raylib_cs.Raylib;
|
|
|
|
namespace Examples.Models;
|
|
|
|
[ExcludeFromBrowser("cubemap generation is too memory-heavy on web (upstream note)")]
|
|
public partial class SkyboxDemo : IExample
|
|
{
|
|
private const int screenWidth = 800;
|
|
private const int screenHeight = 450;
|
|
|
|
// GLSL version used for shaders (330 desktop, 100 web/GLES)
|
|
#if BROWSER
|
|
public const int GlslVersion = 100;
|
|
#else
|
|
public const int GlslVersion = 330;
|
|
#endif
|
|
|
|
public string Name => "Models / Skybox Demo";
|
|
|
|
public string Title => "raylib [models] example - skybox rendering";
|
|
|
|
public bool CursorDisabled => true;
|
|
|
|
private Camera3D camera;
|
|
private Model skybox;
|
|
private bool useHdr;
|
|
private Shader shdrCubemap;
|
|
private string skyboxFileName;
|
|
private Texture2D panorama;
|
|
|
|
public void Init()
|
|
{
|
|
// Define the camera to look into our 3d world
|
|
camera = new();
|
|
camera.Position = new Vector3(1.0f, 1.0f, 1.0f);
|
|
camera.Target = new Vector3(4.0f, 1.0f, 4.0f);
|
|
camera.Up = new Vector3(0.0f, 1.0f, 0.0f);
|
|
camera.FovY = 45.0f;
|
|
camera.Projection = CameraProjection.Perspective;
|
|
|
|
// Load skybox model
|
|
var cube = GenMeshCube(1.0f, 1.0f, 1.0f);
|
|
skybox = LoadModelFromMesh(cube);
|
|
|
|
// Set this to true to use an HDR Texture
|
|
// NOTE: raylib must be built with HDR Support for this to work: SUPPORT_FILEFORMAT_HDR
|
|
useHdr = false;
|
|
|
|
// Load skybox shader and set required locations
|
|
// NOTE: Some locations are automatically set at shader loading
|
|
var shdrSkybox = LoadShader(
|
|
$"resources/shaders/glsl{GlslVersion}/skybox.vs",
|
|
$"resources/shaders/glsl{GlslVersion}/skybox.fs"
|
|
);
|
|
|
|
Raylib.SetShaderValue(
|
|
shdrSkybox,
|
|
GetShaderLocation(shdrSkybox, "environmentMap"),
|
|
(int)MaterialMapIndex.Cubemap,
|
|
ShaderUniformDataType.Int
|
|
);
|
|
|
|
Raylib.SetShaderValue(
|
|
shdrSkybox,
|
|
GetShaderLocation(shdrSkybox, "doGamma"),
|
|
useHdr ? 1 : 0,
|
|
ShaderUniformDataType.Int
|
|
);
|
|
|
|
Raylib.SetShaderValue(
|
|
shdrSkybox,
|
|
GetShaderLocation(shdrSkybox, "vflipped"),
|
|
useHdr ? 1 : 0,
|
|
ShaderUniformDataType.Int
|
|
);
|
|
|
|
Raylib.SetMaterialShader(ref skybox, 0, ref shdrSkybox);
|
|
|
|
// Load cubemap shader and setup required shader locations
|
|
shdrCubemap = LoadShader(
|
|
$"resources/shaders/glsl{GlslVersion}/cubemap.vs",
|
|
$"resources/shaders/glsl{GlslVersion}/cubemap.fs"
|
|
);
|
|
Raylib.SetShaderValue(
|
|
shdrCubemap,
|
|
GetShaderLocation(shdrCubemap, "equirectangularMap"),
|
|
0,
|
|
ShaderUniformDataType.Int
|
|
);
|
|
|
|
// Load skybox
|
|
skyboxFileName = "resources/dresden_square_2k.hdr";
|
|
|
|
if (useHdr)
|
|
{
|
|
panorama = LoadTexture(skyboxFileName);
|
|
var cubemap = GenTextureCubemap(
|
|
shdrCubemap,
|
|
panorama,
|
|
1024,
|
|
PixelFormat.UncompressedR8G8B8A8
|
|
);
|
|
SetMaterialTexture(ref skybox, 0, MaterialMapIndex.Cubemap, ref cubemap);
|
|
UnloadTexture(panorama);
|
|
}
|
|
else
|
|
{
|
|
// TODO: WARNING: On PLATFORM_WEB it requires a big amount of memory to process input image
|
|
// and generate the required cubemap image to be passed to rlLoadTextureCubemap()
|
|
var img = LoadImage("resources/skybox.png");
|
|
var cubemap = LoadTextureCubemap(img, CubemapLayout.AutoDetect);
|
|
SetMaterialTexture(ref skybox, 0, MaterialMapIndex.Cubemap, ref cubemap);
|
|
UnloadImage(img);
|
|
}
|
|
}
|
|
|
|
public void Update()
|
|
{
|
|
// Update
|
|
//----------------------------------------------------------------------------------
|
|
UpdateCamera(ref camera, CameraMode.FirstPerson);
|
|
|
|
// Load new cubemap texture on drag & drop
|
|
if (IsFileDropped())
|
|
{
|
|
var files = Raylib.GetDroppedFiles();
|
|
|
|
if (files.Length == 1)
|
|
{
|
|
if (IsFileExtension(files[0], ".png;.jpg;.hdr;.bmp;.tga"))
|
|
{
|
|
// Unload cubemap texture and load new one
|
|
UnloadTexture(Raylib.GetMaterialTexture(ref skybox, 0, MaterialMapIndex.Cubemap));
|
|
|
|
if (useHdr)
|
|
{
|
|
panorama = LoadTexture(files[0]);
|
|
var cubemap = GenTextureCubemap(
|
|
shdrCubemap,
|
|
panorama,
|
|
1024,
|
|
PixelFormat.UncompressedR8G8B8A8
|
|
);
|
|
SetMaterialTexture(ref skybox, 0, MaterialMapIndex.Cubemap, ref cubemap);
|
|
UnloadTexture(panorama);
|
|
}
|
|
else
|
|
{
|
|
var img = LoadImage(files[0]);
|
|
var cubemap = LoadTextureCubemap(img, CubemapLayout.AutoDetect);
|
|
SetMaterialTexture(ref skybox, 0, MaterialMapIndex.Cubemap, ref cubemap);
|
|
UnloadImage(img);
|
|
}
|
|
|
|
skyboxFileName = files[0];
|
|
}
|
|
}
|
|
}
|
|
//----------------------------------------------------------------------------------
|
|
|
|
// Draw
|
|
//----------------------------------------------------------------------------------
|
|
BeginDrawing();
|
|
ClearBackground(Color.RayWhite);
|
|
|
|
BeginMode3D(camera);
|
|
|
|
// We are inside the cube, we need to disable backface culling!
|
|
Rlgl.DisableBackfaceCulling();
|
|
Rlgl.DisableDepthMask();
|
|
DrawModel(skybox, Vector3.Zero, 1.0f, Color.White);
|
|
Rlgl.EnableBackfaceCulling();
|
|
Rlgl.EnableDepthMask();
|
|
|
|
DrawGrid(10, 1.0f);
|
|
|
|
EndMode3D();
|
|
|
|
if (useHdr)
|
|
{
|
|
DrawText(
|
|
$"Panorama image from hdrihaven.com: {skyboxFileName}",
|
|
10,
|
|
GetScreenHeight() - 20,
|
|
10,
|
|
Color.Black
|
|
);
|
|
}
|
|
else
|
|
{
|
|
DrawText($": {skyboxFileName}", 10, GetScreenHeight() - 20, 10, Color.Black);
|
|
}
|
|
|
|
DrawFPS(10, 10);
|
|
|
|
EndDrawing();
|
|
//----------------------------------------------------------------------------------
|
|
}
|
|
|
|
public void Unload()
|
|
{
|
|
UnloadShader(Raylib.GetMaterial(ref skybox, 0).Shader);
|
|
UnloadTexture(Raylib.GetMaterialTexture(ref skybox, 0, MaterialMapIndex.Cubemap));
|
|
|
|
UnloadModel(skybox);
|
|
}
|
|
|
|
public static int Main()
|
|
{
|
|
// Initialization
|
|
//--------------------------------------------------------------------------------------
|
|
InitWindow(screenWidth, screenHeight, "raylib [models] example - skybox rendering");
|
|
|
|
DisableCursor(); // Limit cursor to relative movement inside the window
|
|
|
|
SetTargetFPS(60);
|
|
//--------------------------------------------------------------------------------------
|
|
|
|
var game = new SkyboxDemo();
|
|
game.Init();
|
|
|
|
// Main game loop
|
|
while (!WindowShouldClose())
|
|
{
|
|
game.Update();
|
|
}
|
|
|
|
game.Unload();
|
|
|
|
// De-Initialization
|
|
//--------------------------------------------------------------------------------------
|
|
CloseWindow();
|
|
//--------------------------------------------------------------------------------------
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Generate cubemap texture from HDR texture
|
|
private static unsafe Texture2D GenTextureCubemap(Shader shader, Texture2D panorama, int size, PixelFormat format)
|
|
{
|
|
Texture2D cubemap;
|
|
|
|
// Disable backface culling to render inside the cube
|
|
Rlgl.DisableBackfaceCulling();
|
|
|
|
// STEP 1: Setup framebuffer
|
|
//------------------------------------------------------------------------------------------
|
|
var rbo = Rlgl.LoadTextureDepth(size, size, true);
|
|
cubemap.Id = Rlgl.LoadTextureCubemap(null, size, format, 1);
|
|
|
|
var fbo = Rlgl.LoadFramebuffer();
|
|
Rlgl.FramebufferAttach(
|
|
fbo,
|
|
rbo,
|
|
FramebufferAttachType.Depth,
|
|
FramebufferAttachTextureType.Renderbuffer,
|
|
0
|
|
);
|
|
Rlgl.FramebufferAttach(
|
|
fbo,
|
|
cubemap.Id,
|
|
FramebufferAttachType.ColorChannel0,
|
|
FramebufferAttachTextureType.CubemapPositiveX,
|
|
0
|
|
);
|
|
|
|
// Check if framebuffer is complete with attachments (valid)
|
|
if (Rlgl.FramebufferComplete(fbo) != 0)
|
|
{
|
|
Console.WriteLine($"FBO: [ID {fbo}] Framebuffer object created successfully");
|
|
}
|
|
//------------------------------------------------------------------------------------------
|
|
|
|
// STEP 2: Draw to framebuffer
|
|
//------------------------------------------------------------------------------------------
|
|
// NOTE: Shader is used to convert HDR equirectangular environment map to cubemap equivalent (6 faces)
|
|
Rlgl.EnableShader(shader.Id);
|
|
|
|
// Define projection matrix and send it to shader
|
|
var matFboProjection = Raymath.MatrixPerspective(
|
|
90.0f * DEG2RAD,
|
|
1.0f,
|
|
Rlgl.CULL_DISTANCE_NEAR,
|
|
Rlgl.CULL_DISTANCE_FAR
|
|
);
|
|
Rlgl.SetUniformMatrix(shader.Locs[(int)ShaderLocationIndex.MatrixProjection], matFboProjection);
|
|
|
|
// Define view matrix for every side of the cubemap
|
|
var fboViews = new[]
|
|
{
|
|
Raymath.MatrixLookAt(Vector3.Zero, new Vector3( 1.0f, 0.0f, 0.0f), new Vector3( 0.0f, -1.0f, 0.0f)),
|
|
Raymath.MatrixLookAt(Vector3.Zero, new Vector3(-1.0f, 0.0f, 0.0f), new Vector3( 0.0f, -1.0f, 0.0f)),
|
|
Raymath.MatrixLookAt(Vector3.Zero, new Vector3( 0.0f, 1.0f, 0.0f), new Vector3( 0.0f, 0.0f, 1.0f)),
|
|
Raymath.MatrixLookAt(Vector3.Zero, new Vector3( 0.0f, -1.0f, 0.0f), new Vector3( 0.0f, 0.0f, -1.0f)),
|
|
Raymath.MatrixLookAt(Vector3.Zero, new Vector3( 0.0f, 0.0f, 1.0f), new Vector3( 0.0f, -1.0f, 0.0f)),
|
|
Raymath.MatrixLookAt(Vector3.Zero, new Vector3( 0.0f, 0.0f, -1.0f), new Vector3( 0.0f, -1.0f, 0.0f)),
|
|
};
|
|
|
|
// Set viewport to current fbo dimensions
|
|
Rlgl.Viewport(0, 0, size, size);
|
|
|
|
// Activate and enable texture for drawing to cubemap faces
|
|
Rlgl.ActiveTextureSlot(0);
|
|
Rlgl.EnableTexture(panorama.Id);
|
|
|
|
for (var i = 0; i < 6; i++)
|
|
{
|
|
// Set the view matrix for the current cube face
|
|
Rlgl.SetUniformMatrix(shader.Locs[(int)ShaderLocationIndex.MatrixView], fboViews[i]);
|
|
|
|
// Select the current cubemap face attachment for the fbo
|
|
// WARNING: This function by default enables->attach->disables fbo!!!
|
|
Rlgl.FramebufferAttach(
|
|
fbo,
|
|
cubemap.Id,
|
|
FramebufferAttachType.ColorChannel0,
|
|
FramebufferAttachTextureType.CubemapPositiveX + i,
|
|
0
|
|
);
|
|
Rlgl.EnableFramebuffer(fbo);
|
|
|
|
// Load and draw a cube, it uses the current enabled texture
|
|
Rlgl.ClearScreenBuffers();
|
|
Rlgl.LoadDrawCube();
|
|
}
|
|
//------------------------------------------------------------------------------------------
|
|
|
|
// STEP 3: Unload framebuffer and reset state
|
|
//------------------------------------------------------------------------------------------
|
|
Rlgl.DisableShader();
|
|
Rlgl.DisableTexture();
|
|
Rlgl.DisableFramebuffer();
|
|
|
|
// Unload framebuffer (and automatically attached depth texture/renderbuffer)
|
|
Rlgl.UnloadFramebuffer(fbo);
|
|
|
|
// Reset viewport dimensions to default
|
|
Rlgl.Viewport(0, 0, Rlgl.GetFramebufferWidth(), Rlgl.GetFramebufferHeight());
|
|
Rlgl.EnableBackfaceCulling();
|
|
//------------------------------------------------------------------------------------------
|
|
|
|
cubemap.Width = size;
|
|
cubemap.Height = size;
|
|
cubemap.Mipmaps = 1;
|
|
cubemap.Format = format;
|
|
|
|
return cubemap;
|
|
}
|
|
}
|