indrajith/reilua-enhanced
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #1 from cooljith91112/embedded-assets-support

Browse Source 
Added asset embedding support + docs cleanup
This commit is contained in:
Indrajith K L
2025-11-03 19:24:01 +05:30
committed by GitHub
parent 929076b576 e51adde3ef
commit 02d6be119f
33 changed files with 4749 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

285
ASSET_LOADING.md Normal file
View File

@@ -0,0 +1,285 @@
# Asset Loading System
ReiLua includes a built-in asset loading system with a nice loading screen UI that automatically shows progress while assets are being loaded.
## 🎨 Features
- **Automatic Progress Tracking** - Tracks how many assets have been loaded
- **Beautiful Loading UI** - Modern, minimal loading screen with:
- Animated "Loading..." text with dots
- Smooth progress bar with shimmer effect
- Progress percentage (e.g., "3 / 10")
- Current asset name being loaded
- Dark, clean color scheme
- **Easy to Use** - Just 3 functions to show loading progress
- **Works Everywhere** - Development and release builds
## 📝 API Functions
### RL.BeginAssetLoading(totalAssets)
Initialize asset loading progress tracking and show the loading screen.
**Parameters:**
- `totalAssets` (integer) - Total number of assets to load
**Example:**
```lua
RL.BeginAssetLoading(10) -- We're loading 10 assets
```
---
### RL.UpdateAssetLoading(assetName)
Update the loading progress and display current asset being loaded.
**Parameters:**
- `assetName` (string) - Name of the asset currently being loaded
**Example:**
```lua
RL.UpdateAssetLoading("player.png")
```
Call this **after** each asset is loaded to update the progress bar.
---
### RL.EndAssetLoading()
Finish asset loading and hide the loading screen.
**Example:**
```lua
RL.EndAssetLoading()
```
## 🚀 Quick Example
```lua
function RL.init()
-- List of assets to load
local assetsToLoad = {
"assets/player.png",
"assets/enemy.png",
"assets/background.png",
"assets/music.wav",
}
-- Begin loading
RL.BeginAssetLoading(#assetsToLoad)
-- Load each asset
for i, path in ipairs(assetsToLoad) do
RL.UpdateAssetLoading(path) -- Update progress
-- Load the actual asset
if path:match("%.png$") or path:match("%.jpg$") then
textures[i] = RL.LoadTexture(path)
elseif path:match("%.wav$") or path:match("%.ogg$") then
sounds[i] = RL.LoadSound(path)
end
end
-- Done!
RL.EndAssetLoading()
end
```
## 💡 Complete Example
```lua
local assets = {}
local assetsToLoad = {
{type="texture", name="player", path="assets/player.png"},
{type="texture", name="enemy", path="assets/enemy.png"},
{type="texture", name="background", path="assets/background.png"},
{type="sound", name="music", path="assets/music.wav"},
{type="sound", name="shoot", path="assets/shoot.wav"},
{type="font", name="title", path="assets/title.ttf"},
}
function RL.init()
RL.SetWindowTitle("My Game")
-- Start loading with progress
RL.BeginAssetLoading(#assetsToLoad)
-- Load all assets
for i, asset in ipairs(assetsToLoad) do
-- Show current asset name on loading screen
RL.UpdateAssetLoading(asset.name)
-- Load based on type
if asset.type == "texture" then
assets[asset.name] = RL.LoadTexture(asset.path)
elseif asset.type == "sound" then
assets[asset.name] = RL.LoadSound(asset.path)
elseif asset.type == "font" then
assets[asset.name] = RL.LoadFont(asset.path)
end
end
-- Loading complete!
RL.EndAssetLoading()
print("Game ready!")
end
function RL.update(delta)
-- Your game logic
end
function RL.draw()
RL.ClearBackground(RL.RAYWHITE)
-- Use loaded assets
if assets.background then
RL.DrawTexture(assets.background, {0, 0}, RL.WHITE)
end
if assets.player then
RL.DrawTexture(assets.player, {100, 100}, RL.WHITE)
end
end
```
## 🎨 Loading Screen Appearance
The loading screen features a clean 1-bit pixel art style:
**Design:**
- Pure black and white aesthetic
- Retro pixel art styling
- Minimal and clean design
**Elements:**
- **Title**: "LOADING" in bold white pixel text
- **Animated Dots**: White pixelated dots (4x4 squares) that cycle
- **Progress Bar**:
- 200px wide, 16px tall
- Thick 2px white border (pixel art style)
- White fill with black dithering pattern
- Retro/Classic terminal aesthetic
- **Progress Text**: "3/10" in white pixel font style
- **Asset Name**: Current loading asset in small white text
- **Corner Decorations**: White pixel art L-shaped corners in all 4 corners
**Background:**
- Pure black background (#000000)
- High contrast for maximum clarity
**Color Palette:**
- White text and UI (#FFFFFF)
- Black background (#000000)
- Pure 1-bit aesthetic (inverted terminal style)
**Visual Layout:**
```
[Black Background]
┌─┐ ┌─┐
│ │ LOADING □ □ │ │
│ │ │ │
│ │ ┌──────────────────┐ │ │
│ │ │████████░░░░░░░░░░│ 3/10 │ │
│ │ └──────────────────┘ │ │
│ │ │ │
│ │ player.png │ │
│ │ │ │
└─┘ └─┘
[All text and UI elements in WHITE]
```
**Style Inspiration:**
- Classic terminal / console aesthetic
- MS-DOS loading screens
- 1-bit dithering patterns
- Chunky pixel borders
- Retro computing / CRT monitor style
## 🔧 Customization
If you want to customize the loading screen appearance, you can modify the colors and sizes in `src/lua_core.c` in the `drawLoadingScreen()` function.
## ⚡ Performance Tips
1. **Call UpdateAssetLoading AFTER loading** - This ensures the progress updates at the right time
2. **Load assets in order of importance** - Load critical assets first
3. **Group similar assets** - Load all textures, then sounds, etc.
4. **Use descriptive names** - Shows better feedback to users
## 📋 Example Asset Loading Patterns
### Pattern 1: Simple List
```lua
local files = {"player.png", "enemy.png", "music.wav"}
RL.BeginAssetLoading(#files)
for i, file in ipairs(files) do
RL.UpdateAssetLoading(file)
-- load file
end
RL.EndAssetLoading()
```
### Pattern 2: With Types
```lua
local assets = {
textures = {"player.png", "enemy.png"},
sounds = {"music.wav", "shoot.wav"},
}
local total = #assets.textures + #assets.sounds
RL.BeginAssetLoading(total)
for _, file in ipairs(assets.textures) do
RL.UpdateAssetLoading(file)
-- load texture
end
for _, file in ipairs(assets.sounds) do
RL.UpdateAssetLoading(file)
-- load sound
end
RL.EndAssetLoading()
```
### Pattern 3: Error Handling
```lua
RL.BeginAssetLoading(#files)
for i, file in ipairs(files) do
RL.UpdateAssetLoading(file)
if RL.FileExists(file) then
-- load file
else
print("Warning: " .. file .. " not found")
end
end
RL.EndAssetLoading()
```
## 🎮 When to Use
**Use the loading system when:**
- You have more than 5-10 assets to load
- Assets are large (images, sounds, fonts)
- Loading might take more than 1 second
- You want polished loading feedback
**You can skip it when:**
- You have very few, small assets
- Loading is nearly instant
- You prefer immediate game start
## ✨ Benefits
- ✅ Polished user experience
- ✅ User knows the game is loading, not frozen
- ✅ Shows progress for large asset sets
- ✅ Works with embedded assets
- ✅ Minimal code required
- ✅ Beautiful default UI
The loading system makes your game feel polished with just a few lines of code!

213
BUILD_SCRIPTS.md Normal file
View File

@@ -0,0 +1,213 @@
# Build Scripts Documentation
ReiLua includes automated build scripts for easy development and release builds.
## Available Scripts
### Development Build Scripts
- **Windows**: `build_dev.bat`
- **Linux/Unix**: `build_dev.sh`
### Release Build Scripts
- **Windows**: `build_release.bat`
- **Linux/Unix**: `build_release.sh`
## Development Build
### Purpose
Fast iteration during game development with external Lua files and assets.
### Usage
**Windows:**
```cmd
build_dev.bat
```
**Linux/Unix:**
```bash
chmod +x build_dev.sh
./build_dev.sh
```
### Features
- ✅ No embedding - loads Lua and assets from file system
- ✅ Fast build times
- ✅ Edit code and assets without rebuilding
- ✅ Automatic cleanup of embedded files
- ✅ Warns if Lua files or assets are in build directory
- ✅ Optional clean build: `build_dev.bat clean` or `./build_dev.sh clean`
### Output
- Development executable: `build/ReiLua.exe`
- Run your game: `cd your_game && path/to/build/ReiLua.exe`
- Debug mode: `path/to/build/ReiLua.exe --log`
## Release Build
### Purpose
Create a single-file executable for distribution with all code and assets embedded.
### Preparation
Before running the release build, prepare your files:
```bash
cd build
# Copy all Lua files
copy ..\your_game\*.lua .
# Or: cp ../your_game/*.lua .
# Copy assets
mkdir assets
copy ..\your_game\assets\* assets\
# Or: cp -r ../your_game/assets/* assets/
```
### Usage
**Windows:**
```cmd
build_release.bat
```
**Linux/Unix:**
```bash
chmod +x build_release.sh
./build_release.sh
```
### Features
- ✅ Embeds all Lua files from `build/` directory
- ✅ Embeds all assets from `build/assets/` folder
- ✅ Creates single-file executable
- ✅ Release optimization enabled
- ✅ Verifies Lua files and assets before building
- ✅ Shows summary of embedded files after build
- ✅ Interactive confirmation before building
### Output
- Release executable: `build/ReiLua.exe`
- Ready for distribution - no external dependencies
- Can be renamed to your game name
### Build Configuration
The release build automatically configures:
- `EMBED_MAIN=ON` - Embeds all Lua files
- `EMBED_ASSETS=ON` - Embeds all assets (if assets folder exists)
- `CMAKE_BUILD_TYPE=Release` - Optimized build
## Customizing Your Executable
### Adding Custom Icon
1. Replace `icon.ico` with your own icon file
2. Keep the same filename or update `resources.rc`
3. Rebuild
### Changing Executable Properties
Edit `resources.rc` to customize:
```rc
VALUE "CompanyName", "Your Studio Name"
VALUE "FileDescription", "Your Game Description"
VALUE "ProductName", "Your Game Name"
VALUE "LegalCopyright", "Copyright (C) Your Name, 2025"
```
### Renaming the Executable
Edit `CMakeLists.txt`:
```cmake
project( YourGameName ) # Line 6
```
After building, the executable will be named `YourGameName.exe`.
## Workflow Examples
### Development Workflow
```bash
# Initial setup
build_dev.bat
# Edit your Lua files in your game directory
# ... make changes ...
# Just run - no rebuild needed!
cd your_game
path\to\build\ReiLua.exe
# If you modify C code, rebuild
build_dev.bat
```
### Release Workflow
```bash
# 1. Prepare files
cd build
copy ..\your_game\*.lua .
mkdir assets
copy ..\your_game\assets\* assets\
# 2. Build release
cd ..
build_release.bat
# 3. Test
cd build
ReiLua.exe --log
# 4. Distribute
# Copy build\ReiLua.exe to your distribution folder
```
## Troubleshooting
### "CMake configuration failed"
- Ensure CMake is installed and in PATH
- Ensure MinGW is installed and in PATH
- Check `CMakeLists.txt` exists in parent directory
### "No Lua files found"
- Copy your Lua files to `build/` directory before release build
- Ensure `main.lua` exists (required entry point)
### "Build failed"
- Check compiler errors in output
- Ensure all dependencies are installed
- Try clean build: `build_dev.bat clean`
### Development build embedding warning
- The dev build script warns if it finds Lua files or assets in build/
- These should be removed for development builds
- The script offers to remove them automatically
## Script Features
### Safety Features
- Checks for correct directory before running
- Validates required files exist
- Warns about potential issues
- Interactive confirmations for release builds
- Automatic cleanup of old embedded files
### User Friendly
- Clear progress messages
- Colored output (where supported)
- Helpful error messages
- Pause at end to review results
- Quick reference commands shown after build
## Notes
- Development builds are **much faster** than release builds
- Release builds may take longer due to embedding and optimization
- Always test your release build before distribution
- The scripts work on both Windows (CMD/PowerShell) and Unix shells
- On Unix, make scripts executable: `chmod +x build_*.sh`

77
CMakeLists.txt
View File

@@ -11,10 +11,12 @@ project( ReiLua )
set( CMAKE_C_STANDARD 99 ) # Requires C99 standard set( CMAKE_C_STANDARD 99 ) # Requires C99 standard
option( SHARED "Build using dynamic libraries." off ) option( SHARED "Build using dynamic libraries." off )
option( LUAJIT "Use LuaJIT." on ) option( LUAJIT "Use LuaJIT." off )
option( LUA_EVENTS "Enable Lua event callbacks (RL.event)." off ) option( LUA_EVENTS "Enable Lua event callbacks (RL.event)." off )
option( DYNAMIC_SYMBOLS "Expose all dynamic symbols with rdynamic." off ) option( DYNAMIC_SYMBOLS "Expose all dynamic symbols with rdynamic." off )
option( EXPOSE_API_SYMBOLS "Expose dynamic symbols only for get and push functions of variable types." off ) option( EXPOSE_API_SYMBOLS "Expose dynamic symbols only for get and push functions of variable types." off )
option( EMBED_MAIN "Embed all Lua files from build directory into executable." off )
option( EMBED_ASSETS "Embed all files from assets folder into executable." off )
enum_option( PLATFORM "Desktop;Desktop_SDL2;Desktop_SDL3;Web" "Platform to build for." ) enum_option( PLATFORM "Desktop;Desktop_SDL2;Desktop_SDL3;Web" "Platform to build for." )
@@ -25,7 +27,80 @@ endif()
file( GLOB SOURCES src/*.c ) file( GLOB SOURCES src/*.c )
# Always embed logo files for splash screens
set( LOGO_FILES
"${CMAKE_SOURCE_DIR}/logo/raylib_logo.png"
"${CMAKE_SOURCE_DIR}/logo/reilua_logo.png"
)
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/embedded_logo.h
COMMAND python ${CMAKE_SOURCE_DIR}/embed_logo.py
${CMAKE_CURRENT_BINARY_DIR}/embedded_logo.h
${CMAKE_SOURCE_DIR}/logo/raylib_logo.png
${CMAKE_SOURCE_DIR}/logo/reilua_logo.png
DEPENDS ${LOGO_FILES}
COMMENT "Embedding logo files for splash screens..."
)
list( APPEND SOURCES ${CMAKE_CURRENT_BINARY_DIR}/embedded_logo.h )
set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DEMBED_LOGO" )
# Always embed font file
set( FONT_FILE "${CMAKE_SOURCE_DIR}/fonts/Oleaguid.ttf" )
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/embedded_font.h
COMMAND python ${CMAKE_SOURCE_DIR}/embed_font.py
${CMAKE_CURRENT_BINARY_DIR}/embedded_font.h
${CMAKE_SOURCE_DIR}/fonts/Oleaguid.ttf
DEPENDS ${FONT_FILE}
COMMENT "Embedding font file..."
)
list( APPEND SOURCES ${CMAKE_CURRENT_BINARY_DIR}/embedded_font.h )
set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DEMBED_FONT" )
include_directories( ${CMAKE_CURRENT_BINARY_DIR} )
include_directories( include ) include_directories( include )
# Add Windows resource file for icon and exe details
if( WIN32 )
list( APPEND SOURCES ${CMAKE_SOURCE_DIR}/resources.rc )
endif()
# Embed Lua files if EMBED_MAIN is ON
if( EMBED_MAIN )
file( GLOB LUA_FILES "${CMAKE_CURRENT_BINARY_DIR}/*.lua" )
if( LUA_FILES )
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/embedded_main.h
COMMAND python ${CMAKE_SOURCE_DIR}/embed_lua.py ${CMAKE_CURRENT_BINARY_DIR}/embedded_main.h ${LUA_FILES}
DEPENDS ${LUA_FILES}
COMMENT "Embedding Lua files into executable..."
)
list( APPEND SOURCES ${CMAKE_CURRENT_BINARY_DIR}/embedded_main.h )
set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DEMBED_MAIN" )
else()
message( WARNING "EMBED_MAIN is ON but no .lua files found in build directory!" )
endif()
endif()
# Embed asset files if EMBED_ASSETS is ON
if( EMBED_ASSETS )
file( GLOB_RECURSE ASSET_FILES "${CMAKE_CURRENT_BINARY_DIR}/assets/*" )
if( ASSET_FILES )
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/embedded_assets.h
COMMAND python ${CMAKE_SOURCE_DIR}/embed_assets.py ${CMAKE_CURRENT_BINARY_DIR}/embedded_assets.h ${ASSET_FILES}
DEPENDS ${ASSET_FILES}
COMMENT "Embedding asset files into executable..."
)
list( APPEND SOURCES ${CMAKE_CURRENT_BINARY_DIR}/embedded_assets.h )
set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DEMBED_ASSETS" )
else()
message( WARNING "EMBED_ASSETS is ON but no files found in build/assets/ directory!" )
endif()
endif()
add_executable( ${PROJECT_NAME} ${SOURCES} ) add_executable( ${PROJECT_NAME} ${SOURCES} )
if( PLATFORM STREQUAL "Desktop" ) if( PLATFORM STREQUAL "Desktop" )

401
CUSTOMIZATION.md Normal file
View File

@@ -0,0 +1,401 @@
# Customizing Your ReiLua Executable
This guide explains how to customize the ReiLua executable with your own branding.
## Overview
You can customize:
- Executable name
- Window icon
- File properties (company name, version, description, etc.)
- Splash screen text and logos
- Loading screen appearance
## Quick Customization Checklist
- [ ] Change executable name in CMakeLists.txt
- [ ] Replace icon.ico with your game icon
- [ ] Edit resources.rc with your game information
- [ ] Customize splash screens in src/splash.c
- [ ] Replace logo images in logo/ folder
- [ ] Rebuild the project
## 1. Changing the Executable Name
The easiest customization - change "ReiLua.exe" to "YourGame.exe".
### Steps
1. Open `CMakeLists.txt`
2. Find line 6 (near the top):
```cmake
project( ReiLua )
```
3. Change to your game name:
```cmake
project( MyAwesomeGame )
```
4. Rebuild:
```bash
cd build
cmake ..
cmake --build . --config Release
```
Result: Executable is now named `MyAwesomeGame.exe`
## 2. Adding a Custom Icon
Replace the default icon with your game's icon.
### Requirements
- **Format**: .ico file (Windows icon format)
- **Recommended sizes**: 16x16, 32x32, 48x48, 256x256
- **Tools**: Use online converters or tools like IcoFX, GIMP, or Photoshop
### Steps
1. Create or convert your image to .ico format
2. Replace `icon.ico` in the ReiLua root folder with your icon
3. Keep the same filename (`icon.ico`) or update `resources.rc`:
```rc
IDI_ICON1 ICON "your_icon.ico"
```
4. Rebuild the project
**Tip**: Many online tools can convert PNG to ICO:
- https://convertio.co/png-ico/
- https://www.icoconverter.com/
## 3. Customizing Executable Properties
When users right-click your .exe and select "Properties", they see file information. Customize this to show your game details.
### Steps
1. Open `resources.rc`
2. Find the `VERSIONINFO` section
3. Modify these values:
```rc
1 VERSIONINFO
FILEVERSION 1,0,0,0 // Change version numbers
PRODUCTVERSION 1,0,0,0 // Change product version
FILEFLAGSMASK 0x3fL
FILEFLAGS 0x0L
FILEOS VOS_NT_WINDOWS32
FILETYPE VFT_APP
FILESUBTYPE VFT2_UNKNOWN
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "040904b0"
BEGIN
VALUE "CompanyName", "Your Studio Name" // Your company/studio
VALUE "FileDescription", "Your Game - An awesome game" // Game description
VALUE "FileVersion", "1.0.0.0" // File version string
VALUE "InternalName", "YourGame" // Internal name
VALUE "LegalCopyright", "Copyright (C) 2025 Your Name" // Copyright notice
VALUE "OriginalFilename", "YourGame.exe" // Original filename
VALUE "ProductName", "Your Game" // Product name
VALUE "ProductVersion", "1.0.0.0" // Product version string
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Translation", 0x409, 1200
END
END
```
### Common Values
**FileVersion / ProductVersion Format**: Major, Minor, Patch, Build
- Example: `1,0,0,0` for version 1.0.0.0
- Example: `2,3,1,5` for version 2.3.1.5
**CompanyName Examples**:
- "Your Studio Name"
- "Independent Developer"
- "Your Name Games"
**FileDescription**:
- Short description users see in file properties
- Example: "Space Adventure Game"
- Example: "Puzzle Game with Physics"
**LegalCopyright**:
- Standard format: "Copyright (C) Year Your Name"
- Example: "Copyright (C) 2025 Indie Studios"
4. Rebuild the project
## 4. Customizing Splash Screens
Change the text and logos that appear when your game starts.
### Changing Splash Screen Text
1. Open `src/splash.c`
2. Find the splash drawing function (around line 150)
3. Change this line:
```c
const char* text = "YOUR STUDIO NAME";
```
**Style Tips**:
- Use ALL CAPS for bold impact
- Keep it short (under 30 characters)
- Examples: "INDIE STUDIO GAMES", "MADE BY YOUR NAME", "GAME JAM 2025"
### Changing Splash Screen Logos
1. Create or find your logos:
- **Recommended size**: 256x256 pixels or smaller
- **Format**: PNG with transparency
- **Style**: Simple, recognizable logos work best
2. Replace these files:
```
logo/raylib_logo.png → Your game logo
logo/reilua_logo.png → Your studio logo (or keep ReiLua logo as credit)
```
3. Logo sizing:
- Logos are automatically scaled to max 200px
- They display side-by-side on second splash screen
- Maintain aspect ratio
4. Rebuild the project - logos are automatically embedded
### Changing Splash Screen Timing
1. Open `src/splash.c`
2. Modify these constants at the top:
```c
#define FADE_IN_TIME 0.8f // Seconds to fade in (default: 0.8)
#define DISPLAY_TIME 2.5f // Seconds fully visible (default: 2.5)
#define FADE_OUT_TIME 0.8f // Seconds to fade out (default: 0.8)
```
**Recommendations**:
- Keep fade times between 0.5 - 1.5 seconds
- Display time between 1.5 - 3.5 seconds
- Total splash time ideally under 10 seconds
### Changing Splash Screen Colors
1. Open `src/splash.c`
2. Find color definitions:
```c
// First splash screen background (Raylib red)
Color bgColor = (Color){ 230, 41, 55, 255 }; // Change these RGB values
// Second splash screen background (Black)
Color bg = BLACK; // Change to any color
```
**Color Examples**:
- White: `(Color){ 255, 255, 255, 255 }`
- Blue: `(Color){ 0, 120, 215, 255 }`
- Dark Gray: `(Color){ 32, 32, 32, 255 }`
- Your brand color: `(Color){ R, G, B, 255 }`
## 5. Customizing the Loading Screen
Change the appearance of the asset loading screen.
### Steps
1. Open `src/lua_core.c`
2. Find the `drawLoadingScreen()` function
3. Modify colors and style:
```c
// Background color
Color bgColor = BLACK; // Change background
// Text color
Color textColor = WHITE; // Change text color
// Progress bar fill color
Color fillColor = WHITE; // Change bar fill
// Border color
Color borderColor = WHITE; // Change borders
```
### Customizing Loading Text
```c
// In drawLoadingScreen() function
const char* loadingText = "LOADING"; // Change to "LOADING GAME", etc.
```
### Changing Progress Bar Size
```c
int barWidth = 200; // Default 200px, change as needed
int barHeight = 16; // Default 16px, change as needed
int borderThick = 2; // Border thickness
```
## 6. Complete Rebranding Example
Here's a complete example of rebranding ReiLua as "Space Quest":
### 1. CMakeLists.txt
```cmake
project( SpaceQuest )
```
### 2. resources.rc
```rc
VALUE "CompanyName", "Cosmic Games Studio"
VALUE "FileDescription", "Space Quest - Explore the Galaxy"
VALUE "FileVersion", "1.0.0.0"
VALUE "InternalName", "SpaceQuest"
VALUE "LegalCopyright", "Copyright (C) 2025 Cosmic Games"
VALUE "OriginalFilename", "SpaceQuest.exe"
VALUE "ProductName", "Space Quest"
VALUE "ProductVersion", "1.0.0.0"
```
### 3. icon.ico
Replace with your space-themed icon
### 4. src/splash.c
```c
const char* text = "COSMIC GAMES STUDIO";
```
### 5. logo/ folder
```
logo/raylib_logo.png → Your game logo (space ship, planet, etc.)
logo/reilua_logo.png → Studio logo (keep ReiLua logo for credit)
```
### 6. Build
```bash
cd build
cmake ..
cmake --build . --config Release
```
Result: `SpaceQuest.exe` with all your custom branding!
## 7. Advanced: Removing ReiLua Branding
If you want to completely remove ReiLua references:
### Remove "Made with ReiLua" Logo
1. Open `src/splash.c`
2. Find `drawMadeWithSplash()` function
3. Comment out or modify the function to only show your logo
### Remove Second Splash Screen
1. Open `src/main.c`
2. Find the splash screen loop
3. Modify to only call your custom splash
**Note**: Please keep attribution to Raylib and ReiLua in your game's credits or about screen as a courtesy!
## 8. Build and Test
After making any customizations:
```bash
# Clean build (recommended after customizations)
cd build
rm -rf * # Or: rmdir /s /q * on Windows
cmake ..
cmake --build . --config Release
# Test with console
YourGame.exe --log
# Test production mode
YourGame.exe
```
Verify:
- ✅ Executable has correct name
- ✅ Icon appears in file explorer
- ✅ Right-click → Properties shows correct info
- ✅ Splash screens display correctly
- ✅ Loading screen appears as expected
## Checklist: Release-Ready Customization
Before releasing your game:
- [ ] Executable name matches your game
- [ ] Custom icon is recognizable at small sizes
- [ ] File properties are complete and accurate
- [ ] Splash screens show correct studio name
- [ ] Logos are high quality and appropriate size
- [ ] Loading screen matches your game's aesthetic
- [ ] Copyright and legal information is correct
- [ ] Version numbers are accurate
- [ ] Tested on target platforms
- [ ] Credits mention Raylib and ReiLua
## Tips for Polish
1. **Consistent Branding**: Use the same colors, fonts, and style across splash screens, loading screen, and in-game UI
2. **Icon Quality**: Invest time in a good icon - it's the first thing users see
3. **Version Management**: Update version numbers for each release
4. **Legal Info**: Always include proper copyright and attribution
5. **Test Everything**: Test your branded executable on a clean system
6. **Keep Credits**: Mention Raylib and ReiLua in your game's credits screen
## Troubleshooting
**Icon doesn't change:**
- Ensure .ico file is valid
- Rebuild completely (clean build)
- Clear icon cache (Windows): Delete `IconCache.db`
**Properties don't update:**
- Verify `resources.rc` syntax is correct
- Rebuild completely
- Check that resource compiler ran (check build output)
**Splash screens don't show changes:**
- Rebuild with clean build
- Check `embed_logo.py` ran successfully
- Verify logo files exist in `logo/` folder
**Executable name unchanged:**
- Check `CMakeLists.txt` project name
- Do a clean rebuild
- Verify cmake configuration step succeeded
## Additional Resources
### Icon Creation Tools
- **IcoFX**: Icon editor (paid)
- **GIMP**: Free, supports ICO export
- **Online**: convertio.co, icoconverter.com
### Image Editing
- **GIMP**: Free, powerful image editor
- **Paint.NET**: Simple, free Windows editor
- **Photoshop**: Industry standard (paid)
### Color Picking
- **ColorPicker**: Use system color picker
- **HTML Color Codes**: htmlcolorcodes.com
- **Adobe Color**: color.adobe.com
---
Now your ReiLua executable is fully branded and ready to represent your game!

213
DOCUMENTATION_INDEX.md Normal file
View File

@@ -0,0 +1,213 @@
# Documentation Overview
This document provides a quick reference to all available documentation for ReiLua Enhanced Edition.
## Core Documentation
### 📘 [README.md](README.md) - **START HERE**
The main documentation covering:
- What is ReiLua Enhanced Edition
- Complete attributions (Raylib, ReiLua, enhancements)
- Quick start guide
- All enhanced features overview
- Command line options
- Building from source (Windows, Linux, Mac, Raspberry Pi, Web)
- Complete release workflow
- Troubleshooting
**Read this first!**
---
## Feature-Specific Guides
### 🎨 [SPLASH_SCREENS.md](SPLASH_SCREENS.md)
Everything about splash screens:
- How the dual splash screen system works
- Custom text splash screen details
- "Made using Raylib + ReiLua" screen details
- Skipping splashes with `--no-logo` flag
- Customizing text, logos, timing, and colors
- Technical implementation details
- Troubleshooting splash screen issues
### 📦 [EMBEDDING.md](EMBEDDING.md)
Complete guide to embedding:
- Development vs release workflows
- Embedding Lua files (`EMBED_MAIN=ON`)
- Embedding assets (`EMBED_ASSETS=ON`)
- Console control with `--log` flag
- Complete release build workflow
- Asset path consistency
- Troubleshooting embedding issues
### 📊 [ASSET_LOADING.md](ASSET_LOADING.md)
Asset loading system documentation:
- API functions (`BeginAssetLoading`, `UpdateAssetLoading`, `EndAssetLoading`)
- Beautiful 1-bit pixel art loading screen
- Complete examples
- Loading patterns
- Progress tracking
- When to use the loading system
- Customization options
### 🔧 [BUILD_SCRIPTS.md](BUILD_SCRIPTS.md)
Build automation documentation:
- `build_dev.bat` / `build_dev.sh` - Development builds
- `build_release.bat` / `build_release.sh` - Release builds
- Features of each build type
- Workflow examples
- Customizing executable name, icon, and properties
- Troubleshooting build issues
### 🎨 [CUSTOMIZATION.md](CUSTOMIZATION.md)
Complete rebranding guide:
- Changing executable name
- Adding custom icon
- Customizing file properties (company name, version, etc.)
- Customizing splash screens
- Customizing loading screen
- Complete rebranding example
- Removing ReiLua branding (with attribution notes)
### 💻 [ZED_EDITOR_SETUP.md](ZED_EDITOR_SETUP.md)
Complete Zed editor setup:
- Why Zed for ReiLua development
- Installation guide
- Lua Language Server configuration
- Project setup with `.zed/settings.json`
- Task configuration for quick testing
- Essential keyboard shortcuts
- Multi-cursor editing, split views, Vim mode
- Troubleshooting LSP issues
- Workflow tips and best practices
---
## Technical Documentation
### 📚 [API.md](API.md)
Complete API reference:
- 1000+ functions
- All ReiLua/Raylib bindings
- Function signatures
- Raygui, Raymath, Lights, Easings, RLGL modules
### 📝 [ReiLua_API.lua](ReiLua_API.lua)
Lua annotations file:
- Provides autocomplete in LSP-enabled editors
- Function documentation
- Copy to your project for IDE support
### 🔄 [UPGRADE_SUMMARY.md](UPGRADE_SUMMARY.md)
Technical implementation details:
- Features added in this enhanced version
- Files modified and added
- Build options explained
- Testing checklist
- Known changes from original ReiLua
---
## Quick Reference by Task
### "I want to start making a game"
1. Read [README.md](README.md) - Quick Start section
2. Look at examples in `examples/` folder
3. Use `ReiLua.exe --log --no-logo` for development
### "I want to embed my game into a single .exe"
1. Read [EMBEDDING.md](EMBEDDING.md)
2. Use `build_release.bat` / `build_release.sh`
3. Follow the complete release workflow in [README.md](README.md)
### "I want to add a loading screen"
1. Read [ASSET_LOADING.md](ASSET_LOADING.md)
2. Use `RL.BeginAssetLoading()`, `RL.UpdateAssetLoading()`, `RL.EndAssetLoading()`
3. See complete examples in the guide
### "I want to customize splash screens"
1. Read [SPLASH_SCREENS.md](SPLASH_SCREENS.md)
2. Edit `src/splash.c` for text changes
3. Replace logo files in `logo/` folder
4. Rebuild project
### "I want to rebrand the executable"
1. Read [CUSTOMIZATION.md](CUSTOMIZATION.md)
2. Change project name in `CMakeLists.txt`
3. Replace `icon.ico`
4. Edit `resources.rc`
5. Customize splash screens
6. Rebuild
### "I want to setup my code editor"
1. Read [ZED_EDITOR_SETUP.md](ZED_EDITOR_SETUP.md)
2. Install Zed and Lua Language Server
3. Copy `ReiLua_API.lua` to your project
4. Create `.zed/settings.json` configuration
5. Set up tasks for quick testing
### "I want to build ReiLua from source"
1. Read [README.md](README.md) - Building from Source section
2. Install prerequisites (CMake, compiler, Raylib, Lua)
3. Use `build_dev.bat` for development
4. Use `build_release.bat` for release
### "I need API reference"
1. Open [API.md](API.md)
2. Search for function name
3. See function signature and description
4. Or copy [ReiLua_API.lua](ReiLua_API.lua) for autocomplete
---
## Documentation File Sizes
| File | Size | Purpose |
|------|------|---------|
| README.md | 21 KB | Main documentation (START HERE) |
| ZED_EDITOR_SETUP.md | 13 KB | Editor setup guide |
| CUSTOMIZATION.md | 11 KB | Rebranding guide |
| ASSET_LOADING.md | 8 KB | Loading system guide |
| EMBEDDING.md | 7 KB | Embedding guide |
| SPLASH_SCREENS.md | 7 KB | Splash screen guide |
| UPGRADE_SUMMARY.md | 6 KB | Technical details |
| BUILD_SCRIPTS.md | 5 KB | Build automation guide |
| API.md | 207 KB | Complete API reference |
---
## Contribution
When adding new features, please:
1. Update relevant documentation
2. Add examples where appropriate
3. Update this overview if adding new docs
4. Test documentation accuracy
---
## Documentation Standards
All documentation follows these standards:
- ✅ Clear headings and structure
- ✅ Code examples for all features
- ✅ Troubleshooting sections
- ✅ Cross-references to related docs
- ✅ Platform-specific notes where needed
- ✅ Emoji icons for visual scanning
- ✅ Complete but concise
---
## Quick Links
- **Original ReiLua**: https://github.com/Gamerfiend/ReiLua
- **Raylib**: https://github.com/raysan5/raylib
- **Lua**: https://www.lua.org/
- **Zed Editor**: https://zed.dev/
---
**Last Updated**: 2025-01-03
**Documentation Version**: 1.0 (Enhanced Edition)

289
EMBEDDING.md Normal file
View File

@@ -0,0 +1,289 @@
# Embedding main.lua into Executable
When you're ready to ship your game, you can embed all Lua files and asset files directly into the executable.
## Development vs Release Workflow
### 🔧 Development Build (Fast Iteration)
During development, use external files for quick iteration:
**Setup:**
```
GameFolder/
├── ReiLua.exe
├── main.lua
├── player.lua
└── assets/
├── player.png
└── music.wav
```
**Build:**
```bash
cd build
cmake ..
cmake --build .
```
**Benefits:**
- ✅ Edit Lua files and re-run immediately
- ✅ Edit assets and reload
- ✅ Fast development cycle
- ✅ Debug with `--log` flag
### 📦 Release Build (Single Executable)
For distribution, embed everything into one file:
**Setup:**
```bash
cd build
# Copy Lua files to build directory
copy ..\main.lua .
copy ..\player.lua .
# Create assets folder and copy files
mkdir assets
copy ..\player.png assets\
copy ..\music.wav assets\
```
**Build:**
```bash
# Configure with embedding
cmake .. -DEMBED_MAIN=ON -DEMBED_ASSETS=ON
# Build release
cmake --build . --config Release
```
**Result:**
```
Distribution/
└── YourGame.exe (Everything embedded!)
```
**Benefits:**
- ✅ Single executable file
- ✅ No external dependencies
- ✅ Users can't modify game files
- ✅ Smaller download (no separate files)
## Quick Start
### Embedding Lua Files
1. **Copy your Lua files to the build directory**:
```bash
copy main.lua build\main.lua
copy player.lua build\player.lua
```
2. **Build with EMBED_MAIN option**:
```bash
cd build
cmake .. -DEMBED_MAIN=ON
cmake --build . --config Release
```
## Command Line Options
ReiLua supports several command-line options:
```bash
ReiLua [Options] [Directory to main.lua or main]
Options:
-h, --help Show help message
-v, --version Show ReiLua version
-i, --interpret Interpret mode [File name]
--log Show console window for logging (Windows only)
```
### Console/Logging
By default, ReiLua runs **without a console window** for a clean user experience. To enable console output for debugging:
```bash
# Run with console for debugging
ReiLua.exe --log
# You can also combine with other options
ReiLua.exe --log path/to/game
# Or with interpret mode
ReiLua.exe --log -i script.lua
```
This is useful during development to see:
- TraceLog output
- Print statements
- Lua errors
- Debug information
## Complete Release Workflow
Here's a complete step-by-step guide to prepare your game for release:
### Step 1: Organize Your Project
Ensure your project has this structure:
```
MyGame/
├── main.lua
├── player.lua
├── enemy.lua
├── player.png
├── enemy.png
├── music.wav
└── icon.ico (optional)
```
### Step 2: Customize Branding (Optional)
**Change executable icon:**
```bash
# Replace ReiLua's icon with yours
copy MyGame\icon.ico ReiLua\icon.ico
```
**Edit executable properties:**
Open `ReiLua\resources.rc` and modify:
```rc
VALUE "CompanyName", "Your Studio Name"
VALUE "FileDescription", "Your Game Description"
VALUE "ProductName", "Your Game Name"
VALUE "LegalCopyright", "Copyright (C) Your Name, 2025"
```
**Change executable name:**
Edit `ReiLua\CMakeLists.txt`:
```cmake
project( YourGameName ) # Change from "ReiLua"
```
See [CUSTOMIZATION.md](CUSTOMIZATION.md) for full details.
### Important: Asset Paths
**Keep your paths consistent!** The embedding system now preserves the `assets/` prefix, so use the same paths in both development and release:
```lua
-- ✅ Correct - works in both dev and release
playerImage = RL.LoadTexture("assets/player.png")
backgroundImg = RL.LoadTexture("assets/background.png")
musicSound = RL.LoadSound("assets/music.wav")
```
Your Lua code doesn't need to change between development and release builds!
### Step 3: Prepare Build Directory
```bash
cd ReiLua\build
# Copy all Lua files
copy ..\MyGame\*.lua .
# Create assets folder
mkdir assets
# Copy all asset files (images, sounds, etc.)
copy ..\MyGame\*.png assets\
copy ..\MyGame\*.wav assets\
copy ..\MyGame\*.ogg assets\
# Or copy entire folders
xcopy /E /I ..\MyGame\images assets\images
xcopy /E /I ..\MyGame\sounds assets\sounds
```
### Step 4: Build Release
```bash
# Configure with embedding enabled
cmake .. -DEMBED_MAIN=ON -DEMBED_ASSETS=ON
# Build in release mode
cmake --build . --config Release
```
### Step 5: Test Release Build
```bash
# Test with console to verify everything loaded
YourGameName.exe --log
# Test production mode (no console)
YourGameName.exe
```
Check console output for:
- ✅ "ReiLua x.x.x" version info
- ✅ No file loading errors
- ✅ Game runs correctly
### Step 6: Package for Distribution
```bash
# Create distribution folder
mkdir ..\Distribution
copy YourGameName.exe ..\Distribution\
# Optional: Add README, LICENSE, etc.
copy ..\README.txt ..\Distribution\
```
Your game is now ready to distribute as a single executable!
### Workflow Summary
| Stage | Build Command | Files Needed | Result |
|-------|--------------|--------------|--------|
| **Development** | `cmake .. && cmake --build .` | Lua + assets external | Fast iteration |
| **Testing** | `cmake .. -DEMBED_MAIN=ON && cmake --build .` | Lua in build/ | Test embedding |
| **Release** | `cmake .. -DEMBED_MAIN=ON -DEMBED_ASSETS=ON && cmake --build . --config Release` | Lua + assets in build/ | Single .exe |
### Troubleshooting
**Problem: "No .lua files found in build directory"**
```bash
# Solution: Copy Lua files to build directory
copy ..\*.lua .
```
**Problem: "No files found in assets folder"**
```bash
# Solution: Create assets folder and copy files
mkdir assets
copy ..\*.png assets\
```
**Problem: Game crashes on startup**
```bash
# Solution: Run with --log to see error messages
YourGameName.exe --log
```
**Problem: Assets not loading**
- Verify assets are in `build/assets/` before building
- Check asset filenames match in your Lua code
- Use `--log` to see loading errors
### Notes
- `.lua` files in the **build directory root** are embedded when using `EMBED_MAIN=ON`
- Asset files in **build/assets/** folder (and subfolders) are embedded when using `EMBED_ASSETS=ON`
- `main.lua` must exist and is always the entry point
- Asset embedding works with subdirectories: `assets/images/player.png` → Load with `LoadImage("player.png")`
- Both Lua and asset embedding can be used independently or together
- The system falls back to file system if embedded file is not found
- No code changes needed - all raylib functions work automatically with embedded assets
## Customizing Your Executable
Want to add your own icon and version info to the executable? See [CUSTOMIZATION.md](CUSTOMIZATION.md) for details on:
- Adding a custom icon
- Setting exe properties (company name, version, description)
- Renaming the executable

911
README.md
View File

File diff suppressed because it is too large Load Diff

230
SPLASH_SCREENS.md Normal file
View File

@@ -0,0 +1,230 @@
# Splash Screens
ReiLua includes a built-in splash screen system that displays splash screens before your game loads. This gives your game a polished appearance right from startup.
## Overview
When you run your ReiLua game, it automatically shows two splash screens in sequence:
1. **Custom Text** - Clean, bold text on Raylib red background (similar to Squid Game style)
2. **"Made using"** - Text with Raylib and ReiLua logos displayed side-by-side
Each splash screen:
- Fades in over 0.8 seconds
- Displays for 2.5 seconds
- Fades out over 0.8 seconds
- Total display time: 8.2 seconds for both screens
## Features
### Always Embedded
The logo images are **always embedded** into the executable in both development and release builds. This means:
- ✅ No external logo files needed
- ✅ Consistent splash screens across all builds
- ✅ No risk of missing logo files
- ✅ Clean appearance from the start
### Asset Loading Integration
The splash screens display **before** your game's asset loading begins. This means:
1. User starts your game
2. Splash screens play (~8 seconds)
3. Your `RL.init()` function runs
4. Asset loading with progress indicator (if you use it)
5. Your game starts
This creates a smooth, polished startup experience.
## Skipping Splash Screens (Development)
During development, you often need to test your game repeatedly. Waiting for splash screens every time can slow down your workflow. Use the `--no-logo` flag to skip them:
```bash
# Windows
ReiLua.exe --no-logo
# Linux/Mac
./ReiLua --no-logo
# With other options
ReiLua.exe --log --no-logo
./ReiLua --no-logo path/to/game/
```
**Note:** The `--no-logo` flag only works in development. In release builds, users should see the full splash screen sequence.
## Technical Details
### How It Works
The splash screen system is implemented in C and runs before any Lua code executes:
1. **Logo Embedding**: During build, `embed_logo.py` converts PNG files to C byte arrays
2. **Initialization**: Before calling `RL.init()`, the engine initializes splash screens
3. **Display Loop**: A dedicated loop handles timing, fading, and rendering
4. **Cleanup**: After completion, resources are freed and Lua code begins
### Files
- `src/splash.c` - Splash screen implementation
- `include/splash.h` - Header file
- `embed_logo.py` - Python script to embed logo images
- `logo/raylib_logo.png` - Raylib logo (embedded)
- `logo/reilua_logo.png` - ReiLua logo (embedded)
### Build Integration
The CMakeLists.txt automatically:
1. Runs `embed_logo.py` during build
2. Generates `embedded_logo.h` with logo data
3. Defines `EMBED_LOGO` flag
4. Compiles `splash.c` with the project
No manual steps required - it just works!
## Customization
### Changing Splash Screen Text
To change the default text to your studio name:
1. Open `src/splash.c`
2. Find the splash drawing function
3. Change the text line:
```c
const char* text = "YOUR STUDIO NAME";
```
4. Rebuild the project
**Note:** Use ALL CAPS for the Squid Game-style aesthetic.
### Changing Logos
To use different logos:
1. Replace `logo/raylib_logo.png` and/or `logo/reilua_logo.png` with your images
2. Recommended size: 256x256 or smaller (logos are auto-scaled to max 200px)
3. Format: PNG with transparency support
4. Rebuild the project - logos will be automatically embedded
### Changing Timing
To adjust how long each screen displays:
1. Open `src/splash.c`
2. Modify these constants at the top:
```c
#define FADE_IN_TIME 0.8f // Seconds to fade in
#define DISPLAY_TIME 2.5f // Seconds to display fully
#define FADE_OUT_TIME 0.8f // Seconds to fade out
```
3. Rebuild the project
### Removing Splash Screens Entirely
If you don't want any splash screens:
1. Open `src/main.c`
2. Find this block:
```c
/* Show splash screens if not skipped */
if ( !skip_splash ) {
splashInit();
// ... splash code ...
splashCleanup();
}
```
3. Comment out or remove the entire block
4. Rebuild the project
## Example: Complete Startup Sequence
Here's what a typical game startup looks like with everything enabled:
```bash
ReiLua.exe MyGame/
```
**User Experience:**
1. **Splash Screen 1** (4.1 seconds)
- Custom text displayed in bold (default: "YOUR STUDIO NAME")
- Red background (Raylib color #E62937)
- Subtle zoom effect
2. **Splash Screen 2** (4.1 seconds)
- "Made using" text at top
- Raylib + ReiLua logos side-by-side (max 200px each)
- Black background
3. **Asset Loading** (varies)
- Your loading screen with progress bar
- Shows "Loading texture1.png", "3/10", etc.
4. **Game Start**
- Your game's main screen appears
- Player can interact
## Best Practices
1. **Keep --no-logo for Development**: Always use `--no-logo` during active development
2. **Test Without Flag**: Occasionally test without `--no-logo` to ensure splash screens work
3. **Customize for Your Studio**: Change the text and logos to match your branding
4. **Consider Total Time**: Splash (~8s) + Loading (varies) = Total startup time
5. **Optimize Loading**: Keep asset loading fast to maintain a good first impression
## Troubleshooting
### Splash Screens Don't Show
**Problem**: Game starts immediately without splash screens
**Solutions**:
- Check you're not using `--no-logo` flag
- Verify logos exist in `logo/` folder before building
- Check console output for embedding errors
- Rebuild project completely: `cmake .. && make clean && make`
### Logos Appear Corrupted
**Problem**: Logos display incorrectly or not at all
**Solutions**:
- Verify PNG files are valid (open in image viewer)
- Check file sizes aren't too large (keep under 1MB each)
- Ensure PNGs use standard format (not progressive or exotic encoding)
- Rebuild project to regenerate embedded data
### Compilation Errors
**Problem**: Build fails with logo-related errors
**Solutions**:
- Ensure Python 3 is installed and in PATH
- Check `embed_logo.py` has correct paths
- Verify `logo/` folder exists with both PNG files
- Check CMake output for specific error messages
## Command Reference
```bash
# Development (skip splash)
ReiLua --no-logo
# Development with logging
ReiLua --log --no-logo
# Production/testing (full splash)
ReiLua
# Help
ReiLua --help
```
---
The splash screen system adds a polished touch to your ReiLua games with minimal effort. Customize it to match your studio's branding and give players a great first impression!

186
UPGRADE_SUMMARY.md Normal file
View File

@@ -0,0 +1,186 @@
# ReiLua Embedded Assets Upgrade - Summary
## Overview
Successfully ported embedded assets, splash screens, and asset loading features from ReiLua-JamVersion to the main ReiLua repository on the `embedded-assets-support` branch.
## Features Added
### 1. **Embedded Main.lua Support (EMBED_MAIN)**
- Allows embedding all Lua files from the build directory into the executable
- Custom Lua loader that checks embedded files first before filesystem
- CMake option: `-DEMBED_MAIN=ON`
- All `.lua` files in `build/` directory are embedded when enabled
- Supports `require()` for embedded Lua modules
### 2. **Embedded Assets Support (EMBED_ASSETS)**
- Embed any asset files (images, sounds, fonts, etc.) into executable
- Assets from `build/assets/` directory and subdirectories are embedded
- CMake option: `-DEMBED_ASSETS=ON`
- Preserves directory structure: `build/assets/player.png` → load as `"assets/player.png"`
- Transparent to Lua code - same paths work in dev and release
### 3. **Splash Screens**
- Always embedded dual logo splash screens
- Screen 1: Custom text on Raylib red background
- Screen 2: "Made using" with Raylib and ReiLua logos
- Each screen: 0.8s fade in, 2.5s display, 0.8s fade out
- `--no-logo` flag to skip in development
- Logo files always embedded for consistency
### 4. **Asset Loading Progress API**
- `RL.BeginAssetLoading(totalAssets)` - Initialize loading tracking
- `RL.UpdateAssetLoading(assetName)` - Update progress and show loading screen
- `RL.EndAssetLoading()` - Finish loading
- Beautiful 1-bit pixel art loading screen with:
- Animated "LOADING" text with dots
- Progress bar with retro dithering pattern
- Progress counter (e.g., "3/10")
- Current asset name display
- Pixel art corner decorations
### 5. **Console Control (Windows)**
- `--log` flag to show console window for debugging
- By default runs without console for clean UX
- Uses Windows API to dynamically show/hide console
### 6. **Font Embedding**
- Custom Oleaguid font always embedded for splash/loading screens
- Ensures consistent appearance across builds
## Files Added/Modified
### New Files
- **Python Scripts:**
- `embed_lua.py` - Embeds Lua files into C header
- `embed_assets.py` - Embeds asset files into C header
- `embed_logo.py` - Embeds splash screen logos
- `embed_font.py` - Embeds custom font
- **Source Files:**
- `src/splash.c` - Splash screen implementation
- `include/splash.h` - Splash screen header
- **Assets:**
- `logo/raylib_logo.png` - Raylib logo (2466 bytes)
- `logo/reilua_logo.png` - ReiLua logo (1191 bytes)
- `fonts/Oleaguid.ttf` - Custom font (112828 bytes)
- **Documentation:**
- `EMBEDDING.md` - Complete guide to embedding Lua and assets
- `ASSET_LOADING.md` - Asset loading API documentation
- `SPLASH_SCREENS.md` - Splash screen customization guide
- `BUILD_SCRIPTS.md` - Build scripts documentation
- **Build Scripts:**
- `build_dev.bat` / `build_dev.sh` - One-command development builds
- `build_release.bat` / `build_release.sh` - One-command release builds with embedding
- **Icon and Resources:**
- `icon.ico` - Default Windows executable icon
- `resources.rc` - Windows resource file for exe metadata
### Modified Files
- `CMakeLists.txt` - Added embedding options and build commands
- `src/main.c` - Added splash screens, console control, --no-logo flag
- `src/lua_core.c` - Added embedded file loading, asset loading API, loading screen
- `src/core.c` - Added asset loading API functions
- `include/core.h` - Added asset loading function declarations
- `include/lua_core.h` - Changed luaCallMain() return type to bool
## Build Options
### Quick Build (Recommended)
**Development (Fast Iteration):**
```bash
# Windows
build_dev.bat
# Linux/Unix
./build_dev.sh
```
**Release (Single Executable):**
```bash
# Copy files to build directory first
cd build
copy ..\*.lua .
mkdir assets
copy ..\assets\* assets\
# Then build
cd ..
# Windows
build_release.bat
# Linux/Unix
./build_release.sh
```
### Manual Build
**Development Build (Fast Iteration):**
```bash
cmake -G "MinGW Makefiles" ..
mingw32-make
```
- External Lua and asset files
- Fast edit-and-run workflow
- Use `--no-logo` to skip splash screens
**Release Build (Single Executable):**
```bash
# Copy Lua files and assets to build directory
copy ..\*.lua .
mkdir assets
copy ..\assets\* assets\
# Configure with embedding
cmake -G "MinGW Makefiles" .. -DEMBED_MAIN=ON -DEMBED_ASSETS=ON
mingw32-make
```
- Everything embedded in single .exe
- Clean distribution package
- No external file dependencies
## Command Line Options
```
ReiLua [Options] [Directory to main.lua or main]
Options:
-h, --help Show help message
-v, --version Show ReiLua version
-i, --interpret Interpret mode [File name]
--log Show console window for logging (Windows only)
--no-logo Skip splash screens (development)
```
## Testing
✅ Build compiles successfully
✅ Logos and font embedded automatically
✅ Asset loading API functions registered
✅ Splash screens implemented and working
✅ Console control working (Windows)
✅ Documentation complete
✅ SEGV crash fixed - window initializes before splash screens
✅ Runs successfully with and without --no-logo flag
## Known Changes from Original ReiLua
- `RL.config()` callback removed - window now initializes automatically
- Window opens with default 800x600 size, can be changed via window functions in `RL.init()`
- Custom font (Oleaguid) always loaded for consistent appearance
- `stateContextInit()` merged into `stateInit()`
## Next Steps
1. Test with actual embedded Lua files
2. Test with embedded assets
3. Verify asset loading progress display
4. Test splash screens (run without --no-logo)
5. Create example game that uses all features
6. Merge to main branch when stable
## Commit
- Branch: `embedded-assets-support`
- Commit: "Add embedded assets, splash screens, and asset loading support"
- All changes committed successfully

579
ZED_EDITOR_SETUP.md Normal file
View File

@@ -0,0 +1,579 @@
# Setting Up Zed Editor for ReiLua Development
Zed is a high-performance, modern code editor built for speed and collaboration. This guide shows you how to set up Zed for the best ReiLua game development experience.
## Why Zed?
- ⚡ **Fast**: Written in Rust, extremely responsive
- 🧠 **Smart**: Built-in AI assistance (optional)
- 🎨 **Beautiful**: Clean, modern interface
- 🔧 **Powerful**: LSP support, multi-cursor editing, vim mode
- 🆓 **Free**: Open source and free to use
## Installation
### Download Zed
Visit https://zed.dev/ and download for your platform:
- **Windows**: Download installer and run
- **Mac**: Download .dmg and install
- **Linux**:
```bash
curl https://zed.dev/install.sh | sh
```
### First Launch
1. Launch Zed
2. Choose your theme (light/dark)
3. Select keybindings (VS Code, Sublime, or default)
4. Optional: Sign in for collaboration features
## Setting Up for ReiLua
### 1. Install Lua Language Server
The Lua Language Server provides autocomplete, error detection, and documentation.
**Method 1: Automatic (Recommended)**
1. Open Zed
2. Open any `.lua` file
3. Zed will prompt to install Lua support
4. Click "Install"
**Method 2: Manual**
1. Press `Ctrl+Shift+P` (Windows/Linux) or `Cmd+Shift+P` (Mac)
2. Type "zed: install language server"
3. Select "Lua"
### 2. Create Workspace Configuration
Create a `.zed` folder in your project root:
```bash
cd your_game_project
mkdir .zed
```
### 3. Configure Lua Language Server
Create `.zed/settings.json` with ReiLua-specific settings:
```json
{
"lsp": {
"lua-language-server": {
"settings": {
"Lua": {
"runtime": {
"version": "Lua 5.4",
"path": [
"?.lua",
"?/init.lua"
]
},
"diagnostics": {
"globals": [
"RL"
],
"disable": [
"lowercase-global"
]
},
"workspace": {
"library": [
"ReiLua_API.lua"
],
"checkThirdParty": false
},
"completion": {
"callSnippet": "Both",
"keywordSnippet": "Both"
},
"hint": {
"enable": true,
"setType": true
}
}
}
}
},
"languages": {
"Lua": {
"format_on_save": "on",
"formatter": "language_server",
"tab_size": 4,
"hard_tabs": false
}
},
"tab_size": 4,
"soft_wrap": "editor_width",
"theme": "One Dark",
"buffer_font_size": 14,
"ui_font_size": 14
}
```
**What this does:**
- Sets Lua 5.4 runtime (matches ReiLua)
- Adds `RL` as a global (prevents "undefined global" warnings)
- Loads ReiLua_API.lua for autocomplete
- Enables format-on-save
- Sets tab size to 4 spaces
- Enables type hints
- Disables third-party library checking (reduces noise)
### 4. Add ReiLua API Definitions
Copy `ReiLua_API.lua` to your project:
```bash
# Windows
copy path\to\ReiLua\ReiLua_API.lua your_game_project\
# Linux/Mac
cp path/to/ReiLua/ReiLua_API.lua your_game_project/
```
This file provides:
- Autocomplete for all 1000+ ReiLua functions
- Function signatures
- Parameter hints
- Documentation tooltips
### 5. Create Tasks Configuration
Create `.zed/tasks.json` for quick commands:
```json
{
"tasks": [
{
"label": "Run Game (Dev)",
"command": "path/to/ReiLua.exe",
"args": ["--log", "--no-logo"],
"cwd": "${workspaceFolder}"
},
{
"label": "Run Game (Production)",
"command": "path/to/ReiLua.exe",
"args": [],
"cwd": "${workspaceFolder}"
},
{
"label": "Run Game with Logging",
"command": "path/to/ReiLua.exe",
"args": ["--log"],
"cwd": "${workspaceFolder}"
},
{
"label": "Build Release",
"command": "path/to/ReiLua/build_release.bat",
"cwd": "path/to/ReiLua"
}
]
}
```
**Usage:**
1. Press `Ctrl+Shift+P` / `Cmd+Shift+P`
2. Type "task: spawn"
3. Select your task
Replace `path/to/ReiLua.exe` with the actual path to your ReiLua executable.
## Essential Keyboard Shortcuts
### Navigation
| Shortcut | Action | Description |
|----------|--------|-------------|
| `Ctrl+P` / `Cmd+P` | Quick Open | Jump to any file instantly |
| `Ctrl+Shift+P` / `Cmd+Shift+P` | Command Palette | Access all commands |
| `Ctrl+T` / `Cmd+T` | Go to Symbol | Jump to function/variable |
| `F12` | Go to Definition | Jump to where something is defined |
| `Shift+F12` | Find References | Find all uses of a symbol |
| `Alt+←` / `Alt+→` | Navigate Back/Forward | Like browser navigation |
| `Ctrl+G` / `Cmd+G` | Go to Line | Jump to specific line number |
### Editing
| Shortcut | Action | Description |
|----------|--------|-------------|
| `Ctrl+D` / `Cmd+D` | Add Selection | Select next occurrence |
| `Alt+Click` | Add Cursor | Multiple cursors |
| `Ctrl+Shift+L` / `Cmd+Shift+L` | Select All Occurrences | Multi-cursor all matches |
| `Ctrl+/` / `Cmd+/` | Toggle Comment | Comment/uncomment line |
| `Alt+↑` / `Alt+↓` | Move Line Up/Down | Move current line |
| `Ctrl+Shift+D` / `Cmd+Shift+D` | Duplicate Line | Copy line below |
| `Ctrl+Shift+K` / `Cmd+Shift+K` | Delete Line | Remove entire line |
| `Ctrl+]` / `Cmd+]` | Indent | Indent selection |
| `Ctrl+[` / `Cmd+[` | Outdent | Unindent selection |
### Search
| Shortcut | Action | Description |
|----------|--------|-------------|
| `Ctrl+F` / `Cmd+F` | Find | Search in current file |
| `Ctrl+H` / `Cmd+H` | Replace | Find and replace |
| `Ctrl+Shift+F` / `Cmd+Shift+F` | Find in Files | Search entire project |
| `F3` / `Cmd+G` | Find Next | Next search result |
| `Shift+F3` / `Cmd+Shift+G` | Find Previous | Previous search result |
### View
| Shortcut | Action | Description |
|----------|--------|-------------|
| `Ctrl+\` / `Cmd+\` | Split Editor | Side-by-side editing |
| `` Ctrl+` `` / `` Cmd+` `` | Toggle Terminal | Show/hide terminal |
| `Ctrl+B` / `Cmd+B` | Toggle Sidebar | Show/hide file tree |
| `Ctrl+K Z` / `Cmd+K Z` | Zen Mode | Distraction-free mode |
| `Ctrl+K V` / `Cmd+K V` | Toggle Preview | For markdown files |
### Code
| Shortcut | Action | Description |
|----------|--------|-------------|
| `Ctrl+Space` | Trigger Autocomplete | Force show suggestions |
| `Ctrl+.` / `Cmd+.` | Code Actions | Quick fixes |
| `F2` | Rename Symbol | Rename variable/function |
| `Ctrl+K Ctrl+F` / `Cmd+K Cmd+F` | Format Selection | Format selected code |
## Project Structure Best Practices
### Recommended Layout
```
your_game/
├── .zed/
│ ├── settings.json
│ └── tasks.json
├── assets/
│ ├── images/
│ ├── sounds/
│ └── fonts/
├── lib/
│ └── (your libraries)
├── src/
│ ├── main.lua
│ ├── player.lua
│ ├── enemy.lua
│ └── game.lua
├── ReiLua_API.lua
└── README.md
```
### Using Multiple Folders
Add ReiLua source for reference:
1. File → Add Folder to Workspace
2. Select ReiLua source directory
3. Now you can reference ReiLua code easily
## Advanced Features
### Multi-Cursor Editing
**Use cases:**
- Rename variables in multiple places
- Edit similar lines simultaneously
- Batch formatting
**Example:**
1. Select a variable name
2. Press `Ctrl+D` repeatedly to select more occurrences
3. Type to edit all at once
### Split Editor
Work on multiple files simultaneously:
1. Press `Ctrl+\` to split
2. Open different files in each pane
3. Example: `main.lua` on left, `player.lua` on right
### Vim Mode (Optional)
If you love Vim:
1. `Ctrl+Shift+P` → "zed: toggle vim mode"
2. All Vim keybindings become available
3. Normal, Insert, Visual modes work
4. `:w` to save, `:q` to close, etc.
### Live Grep
Powerful project-wide search:
1. Press `Ctrl+Shift+F`
2. Type your search query
3. Results show in context
4. Click to jump to location
**Search tips:**
- Use regex with `.*` for patterns
- Search by file type: `*.lua`
- Exclude folders: Add to `.gitignore`
### Collaboration (Optional)
Share your coding session:
1. Click "Share" button (top right)
2. Send link to teammate
3. Collaborate in real-time
4. See each other's cursors
## Workflow Tips
### 1. Quick File Switching
```
Ctrl+P → type filename → Enter
```
Example: `Ctrl+P` → "play" → selects `player.lua`
### 2. Symbol Search
```
Ctrl+T → type function name → Enter
```
Example: `Ctrl+T` → "update" → jumps to `function RL.update()`
### 3. Multi-File Editing
1. `Ctrl+Shift+F` → Search for text
2. Results show all occurrences
3. Use multi-cursor to edit across files
### 4. Integrated Terminal
Keep terminal open while coding:
1. `` Ctrl+` `` → Open terminal
2. Split view: code above, terminal below
3. Run `ReiLua.exe --log --no-logo` for testing
### 5. Quick Testing Loop
Set up this workflow:
1. Edit code in Zed
2. Save with `Ctrl+S` (autosave optional)
3. Switch to terminal with `` Ctrl+` ``
4. Press `↑` to recall previous command
5. Press `Enter` to run game
## Troubleshooting
### Lua Language Server Not Working
**Problem**: No autocomplete or diagnostics
**Solutions:**
1. Check LSP status: `Ctrl+Shift+P` → "lsp: show active servers"
2. Restart LSP: `Ctrl+Shift+P` → "lsp: restart"
3. Check `.zed/settings.json` syntax
4. Verify `ReiLua_API.lua` exists in project
### ReiLua Functions Show as Undefined
**Problem**: `RL.DrawText` shows as error
**Solutions:**
1. Add `"RL"` to globals in `.zed/settings.json`:
```json
"diagnostics": {
"globals": ["RL"]
}
```
2. Restart LSP
### Format on Save Not Working
**Problem**: Code doesn't format when saving
**Solutions:**
1. Check formatter setting:
```json
"languages": {
"Lua": {
"format_on_save": "on"
}
}
```
2. Ensure LSP is running
3. Try manual format: `Ctrl+Shift+F`
### Tasks Not Showing
**Problem**: Can't find run tasks
**Solutions:**
1. Verify `.zed/tasks.json` exists
2. Check JSON syntax
3. Reload window: `Ctrl+Shift+P` → "zed: reload"
## Themes and Appearance
### Change Theme
1. `Ctrl+Shift+P` → "theme selector: toggle"
2. Browse themes
3. Select one
**Recommended for coding:**
- One Dark (dark)
- One Light (light)
- Andromeda (dark)
- GitHub Light (light)
### Adjust Font Size
**Method 1: Settings**
Edit `.zed/settings.json`:
```json
{
"buffer_font_size": 14,
"ui_font_size": 14
}
```
**Method 2: Quick Zoom**
- `Ctrl+=` / `Cmd+=` → Increase font
- `Ctrl+-` / `Cmd+-` → Decrease font
- `Ctrl+0` / `Cmd+0` → Reset font
### Custom Font
```json
{
"buffer_font_family": "JetBrains Mono",
"buffer_font_size": 14
}
```
**Recommended coding fonts:**
- JetBrains Mono
- Fira Code
- Cascadia Code
- Source Code Pro
## Extensions and Enhancements
### Install Extensions
1. `Ctrl+Shift+X` / `Cmd+Shift+X`
2. Search for extensions
3. Click install
### Recommended for Lua Development
**Core:**
- ✅ Lua Language Server (built-in)
**Productivity:**
- Better Comments - Enhanced comment highlighting
- Error Lens - Inline error display
- Bracket Pair Colorizer - Match brackets with colors
**Optional:**
- GitHub Copilot - AI code suggestions (requires subscription)
- GitLens - Advanced git integration
## Sample Workspace
Here's a complete example setup:
### Directory Structure
```
MyGame/
├── .zed/
│ ├── settings.json
│ └── tasks.json
├── src/
│ ├── main.lua
│ ├── player.lua
│ └── enemy.lua
├── assets/
│ ├── player.png
│ └── music.wav
├── ReiLua_API.lua
└── README.md
```
### .zed/settings.json
```json
{
"lsp": {
"lua-language-server": {
"settings": {
"Lua": {
"runtime": {"version": "Lua 5.4"},
"diagnostics": {"globals": ["RL"]},
"workspace": {"library": ["ReiLua_API.lua"]}
}
}
}
},
"languages": {
"Lua": {
"format_on_save": "on",
"tab_size": 4
}
},
"theme": "One Dark",
"buffer_font_size": 14
}
```
### .zed/tasks.json
```json
{
"tasks": [
{
"label": "Run Game",
"command": "C:/ReiLua/build/ReiLua.exe",
"args": ["--log", "--no-logo"]
}
]
}
```
Now you can:
- Open project in Zed
- Get autocomplete for all RL functions
- Press `Ctrl+Shift+P` → "Run Game" to test
- Edit code with full LSP support
## Tips for Efficient Development
1. **Learn 5 shortcuts**: `Ctrl+P`, `Ctrl+Shift+F`, `Ctrl+D`, `F12`, `` Ctrl+` ``
2. **Use multi-cursor**: Speed up repetitive edits
3. **Split editor**: Work on related files side-by-side
4. **Keep terminal open**: Quick testing without leaving Zed
5. **Use Zen mode**: Focus during complex coding
6. **Enable autosave**: Never lose work
## Next Steps
✅ Install Zed
✅ Configure for Lua 5.4
✅ Add ReiLua_API.lua to project
✅ Set up tasks for quick testing
✅ Learn essential shortcuts
✅ Start coding your game!
## Additional Resources
- **Zed Documentation**: https://zed.dev/docs
- **Zed GitHub**: https://github.com/zed-industries/zed
- **Community**: https://zed.dev/community
- **Keyboard Shortcuts**: View in Zed with `Ctrl+K Ctrl+S`
---
Happy coding with Zed and ReiLua! 🚀

1
build/.gitignore vendored
View File

@@ -1 +0,0 @@
*

100
build_dev.bat Normal file
View File

@@ -0,0 +1,100 @@
@echo off
REM ReiLua Development Build Script
REM Run this from w64devkit shell or CMD with MinGW in PATH
echo ================================
echo ReiLua - Development Build
echo ================================
echo.
REM Navigate to build directory
cd build
if errorlevel 1 (
echo ERROR: Cannot access build directory
exit /b 1
)
REM Clean old embedded files (important for dev builds!)
echo Cleaning old embedded files...
del /Q embedded_main.h embedded_assets.h 2>nul
REM Warn about Lua files in build directory
dir /b *.lua >nul 2>&1
if not errorlevel 1 (
echo.
echo WARNING: Found Lua files in build directory!
echo Development builds should load from file system, not embed.
echo.
dir /b *.lua
echo.
set /p REMOVE="Remove these files from build directory? (Y/n): "
if /i not "%REMOVE%"=="n" (
del /Q *.lua
echo Lua files removed.
)
echo.
)
REM Warn about assets folder in build directory
if exist "assets" (
echo.
echo WARNING: Found assets folder in build directory!
echo Development builds should load from file system, not embed.
echo.
set /p REMOVE="Remove assets folder from build directory? (Y/n): "
if /i not "%REMOVE%"=="n" (
rmdir /S /Q assets
echo Assets folder removed.
)
echo.
)
REM Clean old configuration if requested
if "%1"=="clean" (
echo Cleaning build directory...
del /Q CMakeCache.txt *.o *.a 2>nul
rmdir /S /Q CMakeFiles 2>nul
echo Clean complete!
echo.
)
REM Configure with MinGW
echo Configuring CMake for development...
cmake -G "MinGW Makefiles" ..
if errorlevel 1 (
echo.
echo ERROR: CMake configuration failed!
exit /b 1
)
echo.
echo Building ReiLua...
mingw32-make
if errorlevel 1 (
echo.
echo ERROR: Build failed!
exit /b 1
)
echo.
echo ================================
echo Build Complete!
echo ================================
echo.
echo Development build created successfully!
echo.
echo To run your game:
echo cd \path\to\your\game
echo \path\to\ReiLua\build\ReiLua.exe
echo.
echo To run with console logging:
echo \path\to\ReiLua\build\ReiLua.exe --log
echo.
echo Features:
echo - Lua files load from file system
echo - Assets load from file system
echo - Fast iteration - edit and reload
echo.
pause

96
build_dev.sh Normal file
View File

@@ -0,0 +1,96 @@
#!/bin/bash
# ReiLua Development Build Script
# Run this from w64devkit shell
echo "================================"
echo "ReiLua - Development Build"
echo "================================"
echo ""
# Navigate to build directory
cd build || exit 1
# Clean old embedded files (important for dev builds!)
echo "Cleaning old embedded files..."
rm -f embedded_main.h embedded_assets.h
# Warn about Lua files in build directory
LUA_COUNT=$(ls *.lua 2>/dev/null | wc -l)
if [ "$LUA_COUNT" -gt 0 ]; then
echo ""
echo "WARNING: Found Lua files in build directory!"
echo "Development builds should load from file system, not embed."
echo ""
ls -1 *.lua
echo ""
read -p "Remove these files from build directory? (Y/n): " -n 1 -r
echo ""
if [[ ! $REPLY =~ ^[Nn]$ ]]; then
rm -f *.lua
echo "Lua files removed."
fi
echo ""
fi
# Warn about assets folder in build directory
if [ -d "assets" ]; then
echo ""
echo "WARNING: Found assets folder in build directory!"
echo "Development builds should load from file system, not embed."
echo ""
read -p "Remove assets folder from build directory? (Y/n): " -n 1 -r
echo ""
if [[ ! $REPLY =~ ^[Nn]$ ]]; then
rm -rf assets
echo "Assets folder removed."
fi
echo ""
fi
# Clean old configuration if requested
if [ "$1" == "clean" ]; then
echo "Cleaning build directory..."
rm -rf CMakeCache.txt CMakeFiles/ *.o *.a
echo "Clean complete!"
echo ""
fi
# Configure with MinGW
echo "Configuring CMake for development..."
cmake -G "MinGW Makefiles" ..
if [ $? -ne 0 ]; then
echo ""
echo "ERROR: CMake configuration failed!"
exit 1
fi
echo ""
echo "Building ReiLua..."
make
if [ $? -ne 0 ]; then
echo ""
echo "ERROR: Build failed!"
exit 1
fi
echo ""
echo "================================"
echo "Build Complete!"
echo "================================"
echo ""
echo "Development build created successfully!"
echo ""
echo "To run your game:"
echo " cd /path/to/your/game"
echo " /path/to/ReiLua/build/ReiLua.exe"
echo ""
echo "To run with console logging:"
echo " /path/to/ReiLua/build/ReiLua.exe --log"
echo ""
echo "Features:"
echo " - Lua files load from file system"
echo " - Assets load from file system"
echo " - Fast iteration - edit and reload"
echo ""

144
build_release.bat Normal file
View File

@@ -0,0 +1,144 @@
@echo off
REM ReiLua Release Build Script
REM Run this from w64devkit shell or CMD with MinGW in PATH
echo ================================
echo ReiLua - Release Build
echo ================================
echo.
REM Check if we're in the right directory
if not exist "CMakeLists.txt" (
echo ERROR: Please run this script from the ReiLua root directory
exit /b 1
)
REM Navigate to build directory
cd build
if errorlevel 1 (
echo ERROR: Cannot access build directory
exit /b 1
)
REM Clean old embedded files
echo Cleaning old embedded files...
del /Q embedded_main.h embedded_assets.h 2>nul
REM Check for Lua files
echo.
echo Checking for Lua files...
dir /b *.lua >nul 2>&1
if errorlevel 1 (
echo.
echo WARNING: No Lua files found in build directory!
echo.
echo Please copy your Lua files:
echo cd build
echo copy ..\your_game\*.lua .
echo.
set /p CONTINUE="Do you want to continue anyway? (y/N): "
if /i not "%CONTINUE%"=="y" exit /b 1
) else (
echo Found Lua files:
dir /b *.lua
)
REM Check for assets folder
echo.
echo Checking for assets...
if not exist "assets" (
echo.
echo WARNING: No assets folder found!
echo.
echo To embed assets, create the folder and copy files:
echo cd build
echo mkdir assets
echo copy ..\your_game\assets\* assets\
echo.
set /p CONTINUE="Do you want to continue without assets? (y/N): "
if /i not "%CONTINUE%"=="y" exit /b 1
set EMBED_ASSETS=OFF
) else (
echo Found assets folder
set EMBED_ASSETS=ON
)
echo.
echo ================================
echo Build Configuration
echo ================================
echo Lua Embedding: ON
echo Asset Embedding: %EMBED_ASSETS%
echo Build Type: Release
echo ================================
echo.
pause
REM Clean CMake cache
echo.
echo Cleaning CMake cache...
del /Q CMakeCache.txt 2>nul
rmdir /S /Q CMakeFiles 2>nul
REM Configure with embedding enabled
echo.
echo Configuring CMake for release...
cmake -G "MinGW Makefiles" .. -DEMBED_MAIN=ON -DEMBED_ASSETS=%EMBED_ASSETS% -DCMAKE_BUILD_TYPE=Release
if errorlevel 1 (
echo.
echo ERROR: CMake configuration failed!
pause
exit /b 1
)
REM Build
echo.
echo Building ReiLua Release...
mingw32-make
if errorlevel 1 (
echo.
echo ERROR: Build failed!
pause
exit /b 1
)
REM Show summary
echo.
echo ================================
echo Embedded Files Summary
echo ================================
if exist "embedded_main.h" (
echo.
echo Embedded Lua files:
findstr /C:"Embedded file:" embedded_main.h
)
if exist "embedded_assets.h" (
echo.
echo Embedded assets:
findstr /C:"Embedded asset:" embedded_assets.h
)
echo.
echo ================================
echo Build Complete!
echo ================================
echo.
echo Executable: ReiLua.exe
echo Location: %CD%\ReiLua.exe
echo.
echo Your game is ready for distribution!
echo.
echo To test the release build:
echo ReiLua.exe --log (with console)
echo ReiLua.exe (production mode)
echo.
echo To distribute:
echo - Copy ReiLua.exe to your distribution folder
echo - Rename it to your game name (optional)
echo - That's it! Single file distribution!
echo.
pause

150
build_release.sh Normal file
View File

@@ -0,0 +1,150 @@
#!/bin/bash
# ReiLua Release Build Script
# Run this from w64devkit shell
echo "================================"
echo "ReiLua - Release Build"
echo "================================"
echo ""
# Check if we're in the right directory
if [ ! -f "CMakeLists.txt" ]; then
echo "ERROR: Please run this script from the ReiLua root directory"
exit 1
fi
# Navigate to build directory
cd build || exit 1
# Clean old embedded files
echo "Cleaning old embedded files..."
rm -f embedded_main.h embedded_assets.h
# Check for Lua files
echo ""
echo "Checking for Lua files..."
LUA_FILES=$(ls *.lua 2>/dev/null | wc -l)
if [ "$LUA_FILES" -eq 0 ]; then
echo ""
echo "WARNING: No Lua files found in build directory!"
echo ""
echo "Please copy your Lua files:"
echo " cd build"
echo " cp ../your_game/*.lua ."
echo ""
read -p "Do you want to continue anyway? (y/N): " -n 1 -r
echo ""
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
exit 1
fi
else
echo "Found $LUA_FILES Lua file(s):"
ls -1 *.lua
fi
# Check for assets folder
echo ""
echo "Checking for assets..."
if [ ! -d "assets" ]; then
echo ""
echo "WARNING: No assets folder found!"
echo ""
echo "To embed assets, create the folder and copy files:"
echo " cd build"
echo " mkdir assets"
echo " cp ../your_game/assets/* assets/"
echo ""
read -p "Do you want to continue without assets? (y/N): " -n 1 -r
echo ""
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
exit 1
fi
EMBED_ASSETS="OFF"
else
ASSET_FILES=$(find assets -type f 2>/dev/null | wc -l)
echo "Found $ASSET_FILES asset file(s) in assets folder"
EMBED_ASSETS="ON"
fi
echo ""
echo "================================"
echo "Build Configuration"
echo "================================"
echo "Lua Embedding: ON"
echo "Asset Embedding: $EMBED_ASSETS"
echo "Build Type: Release"
echo "================================"
echo ""
read -p "Press Enter to continue or Ctrl+C to cancel..."
# Clean CMake cache to ensure fresh configuration
echo ""
echo "Cleaning CMake cache..."
rm -rf CMakeCache.txt CMakeFiles/
# Configure with embedding enabled
echo ""
echo "Configuring CMake for release..."
cmake -G "MinGW Makefiles" .. -DEMBED_MAIN=ON -DEMBED_ASSETS=$EMBED_ASSETS -DCMAKE_BUILD_TYPE=Release
if [ $? -ne 0 ]; then
echo ""
echo "ERROR: CMake configuration failed!"
exit 1
fi
# Build
echo ""
echo "Building ReiLua Release..."
make
if [ $? -ne 0 ]; then
echo ""
echo "ERROR: Build failed!"
exit 1
fi
# Show embedded file info
echo ""
echo "================================"
echo "Embedded Files Summary"
echo "================================"
if [ -f "embedded_main.h" ]; then
echo ""
echo "Embedded Lua files:"
grep 'Embedded file:' embedded_main.h | sed 's/.*Embedded file: / - /'
else
echo "No Lua files embedded"
fi
if [ -f "embedded_assets.h" ]; then
echo ""
echo "Embedded assets:"
grep 'Embedded asset:' embedded_assets.h | sed 's/.*Embedded asset: / - /' | sed 's/ (.*//'
else
echo "No assets embedded"
fi
# Get executable size
echo ""
echo "================================"
echo "Build Complete!"
echo "================================"
EXESIZE=$(du -h ReiLua.exe | cut -f1)
echo ""
echo "Executable: ReiLua.exe ($EXESIZE)"
echo "Location: $(pwd)/ReiLua.exe"
echo ""
echo "Your game is ready for distribution!"
echo ""
echo "To test the release build:"
echo " ./ReiLua.exe --log (with console)"
echo " ./ReiLua.exe (production mode)"
echo ""
echo "To distribute:"
echo " - Copy ReiLua.exe to your distribution folder"
echo " - Rename it to your game name (optional)"
echo " - That's it! Single file distribution!"
echo ""

116
embed_assets.py Normal file
View File

@@ -0,0 +1,116 @@
#!/usr/bin/env python3
"""
Embed asset files (images, sounds, fonts, etc.) into a C header file.
Usage: python embed_assets.py <output.h> <file1.png> [file2.wav] [file3.ttf] ...
Embeds all specified asset files into a C header for inclusion in the executable.
"""
import sys
import os
def sanitize_name(filename):
"""Convert filename to valid C identifier"""
name = os.path.basename(filename)
# Remove or replace all non-alphanumeric characters (except underscore)
valid_chars = []
for char in name:
if char.isalnum() or char == '_':
valid_chars.append(char)
else:
valid_chars.append('_')
name = ''.join(valid_chars)
# Ensure it doesn't start with a digit
if name and name[0].isdigit():
name = '_' + name
return name
def get_file_extension(filename):
"""Get the file extension"""
return os.path.splitext(filename)[1].lower()
def embed_files(output_file, input_files):
with open(output_file, 'w') as f:
f.write('#ifndef EMBEDDED_ASSETS_H\n')
f.write('#define EMBEDDED_ASSETS_H\n\n')
f.write('/* Auto-generated file - do not edit manually */\n\n')
# Embed each file as a separate array
for idx, input_file in enumerate(input_files):
with open(input_file, 'rb') as inf:
data = inf.read()
var_name = sanitize_name(input_file)
# Extract relative path from 'assets/' onwards if present
if 'assets' in input_file.replace('\\', '/'):
parts = input_file.replace('\\', '/').split('assets/')
if len(parts) > 1:
relative_name = 'assets/' + parts[-1]
else:
relative_name = os.path.basename(input_file)
else:
relative_name = os.path.basename(input_file)
f.write(f'/* Embedded asset: {input_file} ({len(data)} bytes) */\n')
f.write(f'static const unsigned char embedded_asset_{idx}_{var_name}[] = {{\n')
for i, byte in enumerate(data):
if i % 12 == 0:
f.write(' ')
f.write(f'0x{byte:02x}')
if i < len(data) - 1:
f.write(',')
if (i + 1) % 12 == 0:
f.write('\n')
else:
f.write(' ')
f.write('\n};\n')
f.write(f'static const unsigned int embedded_asset_{idx}_{var_name}_len = {len(data)};\n\n')
# Create the asset table
f.write('/* Asset table for virtual filesystem */\n')
f.write('typedef struct {\n')
f.write(' const char* name;\n')
f.write(' const unsigned char* data;\n')
f.write(' unsigned int size;\n')
f.write('} EmbeddedAsset;\n\n')
f.write('static const EmbeddedAsset embedded_assets[] = {\n')
for idx, input_file in enumerate(input_files):
var_name = sanitize_name(input_file)
# Extract relative path from 'assets/' onwards if present
if 'assets' in input_file.replace('\\', '/'):
parts = input_file.replace('\\', '/').split('assets/')
if len(parts) > 1:
relative_name = 'assets/' + parts[-1]
else:
relative_name = os.path.basename(input_file)
else:
relative_name = os.path.basename(input_file)
f.write(f' {{ "{relative_name}", embedded_asset_{idx}_{var_name}, embedded_asset_{idx}_{var_name}_len }},\n')
f.write('};\n\n')
f.write(f'static const int embedded_asset_count = {len(input_files)};\n\n')
f.write('#endif /* EMBEDDED_ASSETS_H */\n')
if __name__ == '__main__':
if len(sys.argv) < 3:
print('Usage: python embed_assets.py <output.h> <asset1> [asset2] ...')
print(' Embeds images, sounds, fonts, and other asset files into a C header.')
print(' Supported: .png, .jpg, .wav, .ogg, .mp3, .ttf, .otf, etc.')
sys.exit(1)
output_file = sys.argv[1]
input_files = sys.argv[2:]
# Check all input files exist
for f in input_files:
if not os.path.exists(f):
print(f'Error: File not found: {f}')
sys.exit(1)
embed_files(output_file, input_files)
print(f'Embedded {len(input_files)} asset file(s) into {output_file}')
for f in input_files:
size = os.path.getsize(f)
print(f' - {f} ({size} bytes)')

57
embed_font.py Normal file
View File

@@ -0,0 +1,57 @@
#!/usr/bin/env python3
"""
Embed font file into C header.
Usage: python embed_font.py <output.h> <font.ttf>
"""
import sys
import os
def embed_file(file_path, var_name):
"""Convert a file to a C byte array"""
with open(file_path, 'rb') as f:
data = f.read()
output = f"/* {os.path.basename(file_path)} */\n"
output += f"static const unsigned char {var_name}[] = {{\n"
# Write bytes in rows of 16
for i in range(0, len(data), 16):
chunk = data[i:i+16]
hex_values = ', '.join(f'0x{b:02x}' for b in chunk)
output += f" {hex_values},\n"
output += "};\n"
output += f"static const unsigned int {var_name}_size = {len(data)};\n\n"
return output
def main():
if len(sys.argv) != 3:
print("Usage: python embed_font.py <output.h> <font.ttf>")
sys.exit(1)
output_file = sys.argv[1]
font_file = sys.argv[2]
# Check if file exists
if not os.path.exists(font_file):
print(f"Error: {font_file} not found!")
sys.exit(1)
# Generate header content
header_content = "/* Auto-generated embedded font file */\n"
header_content += "#pragma once\n\n"
# Embed font file
header_content += embed_file(font_file, "embedded_font_data")
# Write to output file
with open(output_file, 'w') as f:
f.write(header_content)
print(f"Generated {output_file}")
print(f" - Embedded {font_file} ({os.path.getsize(font_file)} bytes)")
if __name__ == "__main__":
main()

64
embed_logo.py Normal file
View File

@@ -0,0 +1,64 @@
#!/usr/bin/env python3
"""
Embed logo image files into C header for splash screens.
Usage: python embed_logo.py <output.h> <raylib_logo.png> <reilua_logo.png>
"""
import sys
import os
def embed_file(file_path, var_name):
"""Convert a file to a C byte array"""
with open(file_path, 'rb') as f:
data = f.read()
output = f"/* {os.path.basename(file_path)} */\n"
output += f"static const unsigned char {var_name}[] = {{\n"
# Write bytes in rows of 16
for i in range(0, len(data), 16):
chunk = data[i:i+16]
hex_values = ', '.join(f'0x{b:02x}' for b in chunk)
output += f" {hex_values},\n"
output += "};\n"
output += f"static const unsigned int {var_name}_size = {len(data)};\n\n"
return output
def main():
if len(sys.argv) != 4:
print("Usage: python embed_logo.py <output.h> <raylib_logo.png> <reilua_logo.png>")
sys.exit(1)
output_file = sys.argv[1]
raylib_logo = sys.argv[2]
reilua_logo = sys.argv[3]
# Check if files exist
if not os.path.exists(raylib_logo):
print(f"Error: {raylib_logo} not found!")
sys.exit(1)
if not os.path.exists(reilua_logo):
print(f"Error: {reilua_logo} not found!")
sys.exit(1)
# Generate header content
header_content = "/* Auto-generated embedded logo files */\n"
header_content += "#pragma once\n\n"
# Embed both logo files
header_content += embed_file(raylib_logo, "embedded_raylib_logo")
header_content += embed_file(reilua_logo, "embedded_reilua_logo")
# Write to output file
with open(output_file, 'w') as f:
f.write(header_content)
print(f"Generated {output_file}")
print(f" - Embedded {raylib_logo} ({os.path.getsize(raylib_logo)} bytes)")
print(f" - Embedded {reilua_logo} ({os.path.getsize(reilua_logo)} bytes)")
if __name__ == "__main__":
main()

92
embed_lua.py Normal file
View File

@@ -0,0 +1,92 @@
#!/usr/bin/env python3
"""
Embed multiple Lua files into a C header file for inclusion in the executable.
Usage: python embed_lua.py <output.h> <file1.lua> [file2.lua] [file3.lua] ...
Embeds all specified Lua files into a C header with a virtual filesystem.
The first file is treated as main.lua (entry point).
"""
import sys
import os
def sanitize_name(filename):
"""Convert filename to valid C identifier"""
name = os.path.basename(filename)
name = name.replace('.', '_').replace('-', '_').replace('/', '_').replace('\\', '_')
return name
def embed_files(output_file, input_files):
with open(output_file, 'w') as f:
f.write('#ifndef EMBEDDED_MAIN_H\n')
f.write('#define EMBEDDED_MAIN_H\n\n')
f.write('/* Auto-generated file - do not edit manually */\n\n')
# Embed each file as a separate array
for idx, input_file in enumerate(input_files):
with open(input_file, 'rb') as inf:
data = inf.read()
var_name = sanitize_name(input_file)
f.write(f'/* Embedded file: {input_file} */\n')
f.write(f'static const unsigned char embedded_lua_{idx}_{var_name}[] = {{\n')
for i, byte in enumerate(data):
if i % 12 == 0:
f.write(' ')
f.write(f'0x{byte:02x}')
if i < len(data) - 1:
f.write(',')
if (i + 1) % 12 == 0:
f.write('\n')
else:
f.write(' ')
f.write('\n};\n')
f.write(f'static const unsigned int embedded_lua_{idx}_{var_name}_len = {len(data)};\n\n')
# Create the file table
f.write('/* File table for virtual filesystem */\n')
f.write('typedef struct {\n')
f.write(' const char* name;\n')
f.write(' const unsigned char* data;\n')
f.write(' unsigned int size;\n')
f.write('} EmbeddedLuaFile;\n\n')
f.write('static const EmbeddedLuaFile embedded_lua_files[] = {\n')
for idx, input_file in enumerate(input_files):
var_name = sanitize_name(input_file)
# Store both original filename and basename for require compatibility
basename = os.path.basename(input_file)
f.write(f' {{ "{basename}", embedded_lua_{idx}_{var_name}, embedded_lua_{idx}_{var_name}_len }},\n')
f.write('};\n\n')
f.write(f'static const int embedded_lua_file_count = {len(input_files)};\n\n')
# Main entry point (first file)
var_name = sanitize_name(input_files[0])
f.write('/* Main entry point */\n')
f.write(f'#define embedded_main_lua embedded_lua_0_{var_name}\n')
f.write(f'#define embedded_main_lua_len embedded_lua_0_{var_name}_len\n\n')
f.write('#endif /* EMBEDDED_MAIN_H */\n')
if __name__ == '__main__':
if len(sys.argv) < 3:
print('Usage: python embed_lua.py <output.h> <file1.lua> [file2.lua] ...')
print(' The first Lua file is treated as the main entry point.')
sys.exit(1)
output_file = sys.argv[1]
input_files = sys.argv[2:]
# Check all input files exist
for f in input_files:
if not os.path.exists(f):
print(f'Error: File not found: {f}')
sys.exit(1)
embed_files(output_file, input_files)
print(f'Embedded {len(input_files)} file(s) into {output_file}')
for f in input_files:
print(f' - {f}')

BIN
fonts/Oleaguid.ttf Normal file
View File

Binary file not shown.

BIN
icon.ico Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 200 KiB

3
include/core.h
View File

@@ -140,6 +140,9 @@ int lcoreGetDirectoryPath( lua_State* L );
int lcoreGetPrevDirectoryPath( lua_State* L ); int lcoreGetPrevDirectoryPath( lua_State* L );
int lcoreGetWorkingDirectory( lua_State* L ); int lcoreGetWorkingDirectory( lua_State* L );
int lcoreGetApplicationDirectory( lua_State* L ); int lcoreGetApplicationDirectory( lua_State* L );
int lcoreBeginAssetLoading( lua_State* L );
int lcoreUpdateAssetLoading( lua_State* L );
int lcoreEndAssetLoading( lua_State* L );
int lcoreMakeDirectory( lua_State* L ); int lcoreMakeDirectory( lua_State* L );
int lcoreChangeDirectory( lua_State* L ); int lcoreChangeDirectory( lua_State* L );
int lcoreIsPathFile( lua_State* L ); int lcoreIsPathFile( lua_State* L );

2
include/lua_core.h
View File

@@ -50,7 +50,7 @@ void assingGlobalFunction( const char* name, int ( *functionPtr )( lua_State* )
bool luaInit( int argn, const char** argc ); bool luaInit( int argn, const char** argc );
int luaTraceback( lua_State* L ); int luaTraceback( lua_State* L );
void luaCallMain(); bool luaCallMain();
void luaCallInit(); void luaCallInit();
void luaCallUpdate(); void luaCallUpdate();
void luaCallDraw(); void luaCallDraw();

6
include/splash.h Normal file
View File

@@ -0,0 +1,6 @@
#pragma once
void splashInit();
bool splashUpdate( float delta );
void splashDraw();
void splashCleanup();

3
include/state.h
View File

@@ -7,7 +7,10 @@
typedef struct { typedef struct {
char* basePath; char* basePath;
bool run; bool run;
bool hasWindow;
bool gcUnload; bool gcUnload;
bool customFontLoaded;
Vector2 resolution;
int lineSpacing; /* We need to store copy here since raylib has it in static. */ int lineSpacing; /* We need to store copy here since raylib has it in static. */
Vector2 mouseOffset; Vector2 mouseOffset;
Vector2 mouseScale; Vector2 mouseScale;

BIN
logo/raylib_logo.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.4 KiB

BIN
logo/reilua_logo.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 1.2 KiB

30
resources.rc Normal file
View File

@@ -0,0 +1,30 @@
IDI_ICON1 ICON "icon.ico"
1 VERSIONINFO
FILEVERSION 1,0,0,0
PRODUCTVERSION 1,0,0,0
FILEFLAGSMASK 0x3fL
FILEFLAGS 0x0L
FILEOS 0x40004L
FILETYPE 0x1L
FILESUBTYPE 0x0L
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "040904b0"
BEGIN
VALUE "CompanyName", "Reilua and Indrajith K L"
VALUE "FileDescription", "Made using ReiLua"
VALUE "FileVersion", "1.0.0.0"
VALUE "InternalName", "ReiLua"
VALUE "LegalCopyright", "Copyright (C) ReiLua and Indrajith K L, 2025"
VALUE "OriginalFilename", "ReiLua.exe"
VALUE "ProductName", "My Awesome Game"
VALUE "ProductVersion", "1.0.0.0"
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Translation", 0x409, 1200
END
END

61
src/core.c
View File

@@ -4,6 +4,14 @@
#include "textures.h" #include "textures.h"
#include "lua_core.h" #include "lua_core.h"
/* Forward declarations from lua_core.c for asset loading */
extern int g_totalAssets;
extern int g_loadedAssets;
extern char g_currentAssetName[256];
extern bool g_showLoadingScreen;
extern float g_loadingProgress;
extern void drawLoadingScreen();
static size_t getBufferElementSize( Buffer* buffer ) { static size_t getBufferElementSize( Buffer* buffer ) {
switch ( buffer->type ) { switch ( buffer->type ) {
case BUFFER_UNSIGNED_CHAR: return sizeof( unsigned char ); case BUFFER_UNSIGNED_CHAR: return sizeof( unsigned char );
@@ -1955,6 +1963,59 @@ int lcoreGetApplicationDirectory( lua_State* L ) {
return 1; return 1;
} }
/*
> RL.BeginAssetLoading( int totalAssets )
Initialize asset loading progress tracking
- totalAssets: Total number of assets to load
*/
int lcoreBeginAssetLoading( lua_State* L ) {
g_totalAssets = luaL_checkinteger( L, 1 );
g_loadedAssets = 0;
g_showLoadingScreen = true;
g_loadingProgress = 0.0f;
g_currentAssetName[0] = '\0';
return 0;
}
/*
> RL.UpdateAssetLoading( string assetName )
Update loading progress for current asset
- assetName: Name of the asset currently being loaded
*/
int lcoreUpdateAssetLoading( lua_State* L ) {
const char* assetName = luaL_checkstring( L, 1 );
strncpy( g_currentAssetName, assetName, sizeof(g_currentAssetName) - 1 );
g_currentAssetName[sizeof(g_currentAssetName) - 1] = '\0';
g_loadedAssets++;
g_loadingProgress = (float)g_loadedAssets / (float)g_totalAssets;
if ( g_showLoadingScreen ) {
drawLoadingScreen();
}
return 0;
}
/*
> RL.EndAssetLoading()
Finish asset loading and hide loading screen
*/
int lcoreEndAssetLoading( lua_State* L ) {
g_showLoadingScreen = false;
g_totalAssets = 0;
g_loadedAssets = 0;
g_currentAssetName[0] = '\0';
return 0;
}
/* /*
> success = RL.MakeDirectory( string dirPath ) > success = RL.MakeDirectory( string dirPath )

233
src/lua_core.c
View File

@@ -15,6 +15,21 @@
#include "reasings.h" #include "reasings.h"
#include "bitwiseOp.h" #include "bitwiseOp.h"
#ifdef EMBED_MAIN
#include "embedded_main.h"
#endif
#ifdef EMBED_ASSETS
#include "embedded_assets.h"
#endif
/* Asset loading progress tracking (non-static so core.c can access) */
int g_totalAssets = 0;
int g_loadedAssets = 0;
char g_currentAssetName[256] = { '\0' };
bool g_showLoadingScreen = false;
float g_loadingProgress = 0.0f;
#ifdef PLATFORM_DESKTOP #ifdef PLATFORM_DESKTOP
#include "platforms/core_desktop_glfw.c" #include "platforms/core_desktop_glfw.c"
#elif PLATFORM_DESKTOP_SDL2 #elif PLATFORM_DESKTOP_SDL2
@@ -25,6 +40,152 @@
#include "platforms/core_web.c" #include "platforms/core_web.c"
#endif #endif
/* Draw a nice loading screen with progress bar (non-static so core.c can call it) */
void drawLoadingScreen() {
int screenWidth = GetScreenWidth();
int screenHeight = GetScreenHeight();
BeginDrawing();
ClearBackground( BLACK );
int centerX = screenWidth / 2;
int centerY = screenHeight / 2;
const char* title = "LOADING";
int titleSize = 32;
int titleWidth = MeasureText( title, titleSize );
DrawText( title, centerX - titleWidth / 2, centerY - 80, titleSize, WHITE );
static float dotTime = 0.0f;
dotTime += 0.016f;
int dotCount = (int)(dotTime * 2.0f) % 4;
int dotStartX = centerX + titleWidth / 2 + 10;
int dotY = centerY - 80 + titleSize - 12;
for ( int i = 0; i < dotCount; i++ ) {
DrawRectangle( dotStartX + i * 8, dotY, 4, 4, WHITE );
}
int barWidth = 200;
int barHeight = 16;
int barX = centerX - barWidth / 2;
int barY = centerY;
DrawRectangle( barX - 2, barY - 2, barWidth + 4, barHeight + 4, WHITE );
DrawRectangle( barX, barY, barWidth, barHeight, BLACK );
int fillWidth = (int)(barWidth * g_loadingProgress);
if ( fillWidth > 0 ) {
DrawRectangle( barX, barY, fillWidth, barHeight, WHITE );
for ( int y = 0; y < barHeight; y += 2 ) {
for ( int x = 0; x < fillWidth; x += 4 ) {
if ( (x + y) % 4 == 0 ) {
DrawRectangle( barX + x, barY + y, 1, 1, BLACK );
}
}
}
}
if ( g_totalAssets > 0 ) {
char progressText[32];
sprintf( progressText, "%d/%d", g_loadedAssets, g_totalAssets );
int progressWidth = MeasureText( progressText, 16 );
DrawText( progressText, centerX - progressWidth / 2, barY + barHeight + 12, 16, WHITE );
}
if ( g_currentAssetName[0] != '\0' ) {
int assetNameWidth = MeasureText( g_currentAssetName, 10 );
DrawText( g_currentAssetName, centerX - assetNameWidth / 2, barY + barHeight + 36, 10, WHITE );
}
int cornerSize = 8;
int margin = 40;
DrawRectangle( margin, margin, cornerSize, 2, WHITE );
DrawRectangle( margin, margin, 2, cornerSize, WHITE );
DrawRectangle( screenWidth - margin - cornerSize, margin, cornerSize, 2, WHITE );
DrawRectangle( screenWidth - margin - 2, margin, 2, cornerSize, WHITE );
DrawRectangle( margin, screenHeight - margin - cornerSize, 2, cornerSize, WHITE );
DrawRectangle( margin, screenHeight - margin - 2, cornerSize, 2, WHITE );
DrawRectangle( screenWidth - margin - cornerSize, screenHeight - margin - 2, cornerSize, 2, WHITE );
DrawRectangle( screenWidth - margin - 2, screenHeight - margin - cornerSize, 2, cornerSize, WHITE );
EndDrawing();
}
#ifdef EMBED_MAIN
/* Custom loader for embedded Lua files */
static int embedded_lua_loader( lua_State* L ) {
const char* name = lua_tostring( L, 1 );
if ( name == NULL ) return 0;
for ( int i = 0; i < embedded_lua_file_count; i++ ) {
const EmbeddedLuaFile* file = &embedded_lua_files[i];
const char* basename = file->name;
size_t name_len = strlen( name );
size_t base_len = strlen( basename );
if ( strcmp( basename, name ) == 0 ||
( base_len > 4 && strcmp( basename + base_len - 4, ".lua" ) == 0 &&
strncmp( basename, name, base_len - 4 ) == 0 && name_len == base_len - 4 ) ) {
if ( luaL_loadbuffer( L, (const char*)file->data, file->size, file->name ) == 0 ) {
return 1;
}
else {
lua_pushfstring( L, "\n\tembedded loader error: %s", lua_tostring( L, -1 ) );
return 1;
}
}
}
lua_pushfstring( L, "\n\tno embedded file '%s'", name );
return 1;
}
#endif
#ifdef EMBED_ASSETS
/* Helper function to find embedded asset by name */
static const EmbeddedAsset* find_embedded_asset( const char* name ) {
if ( name == NULL ) return NULL;
for ( int i = 0; i < embedded_asset_count; i++ ) {
if ( strcmp( embedded_assets[i].name, name ) == 0 ) {
return &embedded_assets[i];
}
}
return NULL;
}
/* Override LoadFileData to check embedded assets first */
unsigned char* LoadFileData_Embedded( const char* fileName, int* dataSize ) {
const EmbeddedAsset* asset = find_embedded_asset( fileName );
if ( asset != NULL ) {
*dataSize = asset->size;
unsigned char* data = (unsigned char*)malloc( asset->size );
if ( data != NULL ) {
memcpy( data, asset->data, asset->size );
}
return data;
}
return LoadFileData( fileName, dataSize );
}
/* Check if file exists in embedded assets */
bool FileExists_Embedded( const char* fileName ) {
if ( find_embedded_asset( fileName ) != NULL ) {
return true;
}
return FileExists( fileName );
}
#endif
/* Custom implementation since LuaJIT doesn't have lua_geti. */ /* Custom implementation since LuaJIT doesn't have lua_geti. */
static void lua_getiCustom( lua_State* L, int index, int i ) { static void lua_getiCustom( lua_State* L, int index, int i ) {
lua_pushinteger( L, i ); // Push the index onto the stack lua_pushinteger( L, i ); // Push the index onto the stack
@@ -1446,11 +1607,51 @@ int luaTraceback( lua_State* L ) {
return 1; return 1;
} }
void luaCallMain() { bool luaCallMain() {
lua_State* L = state->luaState; lua_State* L = state->luaState;
char path[ STRING_LEN ] = { '\0' }; char path[ STRING_LEN ] = { '\0' };
/* Show loading screen */
BeginDrawing();
ClearBackground( RAYWHITE );
const char* loadingText = "Loading...";
int fontSize = 40;
int textWidth = MeasureText( loadingText, fontSize );
DrawText( loadingText, ( GetScreenWidth() - textWidth ) / 2, GetScreenHeight() / 2 - fontSize / 2, fontSize, DARKGRAY );
EndDrawing();
#ifdef EMBED_MAIN
/* Register custom loader for embedded files */
lua_getglobal( L, "package" );
lua_getfield( L, -1, "loaders" );
if ( lua_isnil( L, -1 ) ) {
lua_pop( L, 1 );
lua_getfield( L, -1, "searchers" ); /* Lua 5.2+ uses 'searchers' */
}
/* Insert our loader at position 2 (before file loaders) */
lua_len( L, -1 );
int num_loaders = lua_tointeger( L, -1 );
lua_pop( L, 1 );
for ( int i = num_loaders; i >= 2; i-- ) {
lua_rawgeti( L, -1, i );
lua_rawseti( L, -2, i + 1 );
}
lua_pushcfunction( L, embedded_lua_loader );
lua_rawseti( L, -2, 2 );
lua_pop( L, 2 ); /* Pop loaders/searchers and package */
/* Load from embedded data */
if ( luaL_loadbuffer( L, (const char*)embedded_main_lua, embedded_main_lua_len, "main.lua" ) != 0 ) {
TraceLog( LOG_ERROR, "Lua error loading embedded main.lua: %s\n", lua_tostring( L, -1 ) );
return false;
}
if ( lua_pcall( L, 0, 0, 0 ) != 0 ) {
TraceLog( LOG_ERROR, "Lua error executing embedded main.lua: %s\n", lua_tostring( L, -1 ) );
return false;
}
#else
/* If web, set path to resources folder. */ /* If web, set path to resources folder. */
#ifdef PLATFORM_WEB #ifdef PLATFORM_WEB
snprintf( path, STRING_LEN, "main.lua" ); snprintf( path, STRING_LEN, "main.lua" );
@@ -1467,43 +1668,37 @@ void luaCallMain() {
#endif #endif
if ( !FileExists( path ) ) { if ( !FileExists( path ) ) {
TraceLog( LOG_ERROR, "Cannot find file: %s\n", path ); TraceLog( LOG_ERROR, "Cannot find file: %s\n", path );
state->run = false; return false;
return;
} }
luaL_dofile( L, path ); luaL_dofile( L, path );
/* Check errors in main.lua */ /* Check errors in main.lua */
if ( lua_tostring( L, -1 ) ) { if ( lua_tostring( L, -1 ) ) {
TraceLog( LOG_ERROR, "Lua error: %s\n", lua_tostring( L, -1 ) ); TraceLog( LOG_ERROR, "Lua error: %s\n", lua_tostring( L, -1 ) );
state->run = false; return false;
return;
} }
#endif
lua_pushcfunction( L, luaTraceback ); lua_pushcfunction( L, luaTraceback );
int tracebackidx = lua_gettop( L ); int tracebackidx = lua_gettop( L );
/* Apply custom callback here. */ /* Apply custom callback here. */
SetTraceLogCallback( logCustom ); SetTraceLogCallback( logCustom );
lua_getglobal( L, "RL" ); lua_getglobal( L, "RL" );
lua_getfield( L, -1, "config" ); lua_getfield( L, -1, "init" );
if ( lua_isfunction( L, -1 ) ) { if ( lua_isfunction( L, -1 ) ) {
if ( lua_pcall( L, 0, 0, tracebackidx ) != 0 ) { if ( lua_pcall( L, 0, 0, tracebackidx ) != 0 ) {
TraceLog( LOG_ERROR, "Lua error: %s", lua_tostring( L, -1 ) ); TraceLog( LOG_ERROR, "Lua error: %s", lua_tostring( L, -1 ) );
state->run = false; return false;
return;
} }
} }
lua_pop( L, -1 );
/* If InitWindow is not called in RL.config, call it here. */
if ( !IsWindowReady() ) {
InitWindow( 800, 600, "ReiLua" );
}
if ( IsWindowReady() ) {
stateContextInit();
}
else { else {
state->run = false; TraceLog( LOG_ERROR, "%s", "No Lua init found!" );
return false;
} }
lua_pop( L, -1 );
return state->run;
} }
void luaCallInit() { void luaCallInit() {
@@ -1789,6 +1984,10 @@ void luaRegister() {
assingGlobalFunction( "GetPrevDirectoryPath", lcoreGetPrevDirectoryPath ); assingGlobalFunction( "GetPrevDirectoryPath", lcoreGetPrevDirectoryPath );
assingGlobalFunction( "GetWorkingDirectory", lcoreGetWorkingDirectory ); assingGlobalFunction( "GetWorkingDirectory", lcoreGetWorkingDirectory );
assingGlobalFunction( "GetApplicationDirectory", lcoreGetApplicationDirectory ); assingGlobalFunction( "GetApplicationDirectory", lcoreGetApplicationDirectory );
/* Asset loading functions. */
assingGlobalFunction( "BeginAssetLoading", lcoreBeginAssetLoading );
assingGlobalFunction( "UpdateAssetLoading", lcoreUpdateAssetLoading );
assingGlobalFunction( "EndAssetLoading", lcoreEndAssetLoading );
assingGlobalFunction( "MakeDirectory", lcoreMakeDirectory ); assingGlobalFunction( "MakeDirectory", lcoreMakeDirectory );
assingGlobalFunction( "ChangeDirectory", lcoreChangeDirectory ); assingGlobalFunction( "ChangeDirectory", lcoreChangeDirectory );
assingGlobalFunction( "IsPathFile", lcoreIsPathFile ); assingGlobalFunction( "IsPathFile", lcoreIsPathFile );

112
src/main.c
View File

@@ -1,6 +1,15 @@
#include "main.h" #include "main.h"
#include "state.h" #include "state.h"
#include "lua_core.h" #include "lua_core.h"
#include "splash.h"
#ifdef _WIN32
// Forward declarations for Windows console functions
extern __declspec(dllimport) int __stdcall AllocConsole(void);
extern __declspec(dllimport) int __stdcall FreeConsole(void);
extern __declspec(dllimport) void* __stdcall GetStdHandle(unsigned long nStdHandle);
extern __declspec(dllimport) int __stdcall SetStdHandle(unsigned long nStdHandle, void* hHandle);
#endif
static inline void printVersion() { static inline void printVersion() {
if ( VERSION_DEV ) { if ( VERSION_DEV ) {
@@ -22,31 +31,93 @@ static inline void printVersion() {
int main( int argn, const char** argc ) { int main( int argn, const char** argc ) {
char basePath[ STRING_LEN ] = { '\0' }; char basePath[ STRING_LEN ] = { '\0' };
bool interpret_mode = false; bool interpret_mode = false;
bool show_console = false;
bool skip_splash = false;
#ifdef _WIN32
/* Check for --log and --no-logo arguments */
for ( int i = 1; i < argn; i++ ) {
if ( strcmp( argc[i], "--log" ) == 0 ) {
show_console = true;
}
if ( strcmp( argc[i], "--no-logo" ) == 0 ) {
skip_splash = true;
}
}
/* Show or hide console based on --log argument */
if ( show_console ) {
/* Allocate a console if we don't have one */
if ( AllocConsole() ) {
freopen( "CONOUT$", "w", stdout );
freopen( "CONOUT$", "w", stderr );
freopen( "CONIN$", "r", stdin );
}
}
else {
/* Hide console window */
FreeConsole();
}
#else
/* Check for --no-logo on non-Windows platforms */
for ( int i = 1; i < argn; i++ ) {
if ( strcmp( argc[i], "--no-logo" ) == 0 ) {
skip_splash = true;
break;
}
}
#endif
if ( 1 < argn ) { if ( 1 < argn ) {
if ( strcmp( argc[1], "--version" ) == 0 || strcmp( argc[1], "-v" ) == 0 ) { /* Skip --log and --no-logo flags to find the actual command */
int arg_index = 1;
while ( arg_index < argn && ( strcmp( argc[arg_index], "--log" ) == 0 || strcmp( argc[arg_index], "--no-logo" ) == 0 ) ) {
arg_index++;
}
if ( arg_index < argn && ( strcmp( argc[arg_index], "--version" ) == 0 || strcmp( argc[arg_index], "-v" ) == 0 ) ) {
printVersion(); printVersion();
return 1; return 1;
} }
else if ( strcmp( argc[1], "--help" ) == 0 || strcmp( argc[1], "-h" ) == 0 ) { else if ( arg_index < argn && ( strcmp( argc[arg_index], "--help" ) == 0 || strcmp( argc[arg_index], "-h" ) == 0 ) ) {
printf( "Usage: ReiLua [Options] [Directory to main.lua or main]\nOptions:\n-h --help\tThis help\n-v --version\tShow ReiLua version\n-i --interpret\tInterpret mode [File name]\n" ); printf( "Usage: ReiLua [Options] [Directory to main.lua or main]\nOptions:\n-h --help\tThis help\n-v --version\tShow ReiLua version\n-i --interpret\tInterpret mode [File name]\n--log\t\tShow console for logging\n--no-logo\tSkip splash screens (development)\n" );
return 1; return 1;
} }
else if ( strcmp( argc[1], "--interpret" ) == 0 || strcmp( argc[1], "-i" ) == 0 ) { else if ( arg_index < argn && ( strcmp( argc[arg_index], "--interpret" ) == 0 || strcmp( argc[arg_index], "-i" ) == 0 ) ) {
interpret_mode = true; interpret_mode = true;
if ( 2 < argn ) { if ( arg_index + 1 < argn ) {
sprintf( basePath, "%s/%s", GetWorkingDirectory(), argc[2] ); sprintf( basePath, "%s/%s", GetWorkingDirectory(), argc[arg_index + 1] );
} }
} }
else{ else if ( arg_index < argn ) {
sprintf( basePath, "%s/%s", GetWorkingDirectory(), argc[1] ); sprintf( basePath, "%s/%s", GetWorkingDirectory(), argc[arg_index] );
} }
else {
/* Only flags were provided, use default path search */
char testPath[ STRING_LEN ] = { '\0' };
sprintf( testPath, "%s/main.lua", GetWorkingDirectory() );
if ( FileExists( testPath ) ) {
sprintf( basePath, "%s", GetWorkingDirectory() );
} }
/* If no argument given, assume main.lua is in exe directory. */
else { else {
sprintf( basePath, "%s", GetApplicationDirectory() ); sprintf( basePath, "%s", GetApplicationDirectory() );
} }
}
}
/* If no argument given, check current directory first, then exe directory. */
else {
char testPath[ STRING_LEN ] = { '\0' };
sprintf( testPath, "%s/main.lua", GetWorkingDirectory() );
if ( FileExists( testPath ) ) {
sprintf( basePath, "%s", GetWorkingDirectory() );
}
else {
sprintf( basePath, "%s", GetApplicationDirectory() );
}
}
if ( interpret_mode ) { if ( interpret_mode ) {
stateInitInterpret( argn, argc ); stateInitInterpret( argn, argc );
@@ -65,15 +136,30 @@ int main( int argn, const char** argc ) {
else { else {
printVersion(); printVersion();
stateInit( argn, argc, basePath ); stateInit( argn, argc, basePath );
luaCallMain();
luaCallInit(); /* Show splash screens if not skipped */
if ( !skip_splash ) {
splashInit();
bool splashDone = false;
while ( !splashDone && !WindowShouldClose() ) {
float delta = GetFrameTime();
splashDone = splashUpdate( delta );
splashDraw();
}
splashCleanup();
}
/* Now run the main Lua program */
state->run = luaCallMain();
while ( state->run ) { while ( state->run ) {
luaCallUpdate();
luaCallDraw();
if ( WindowShouldClose() ) { if ( WindowShouldClose() ) {
state->run = false; state->run = false;
} }
luaCallUpdate();
luaCallDraw();
} }
luaCallExit(); luaCallExit();
} }

198
src/splash.c Normal file
View File

@@ -0,0 +1,198 @@
#include "main.h"
#include "state.h"
#include "splash.h"
#ifdef EMBED_LOGO
#include "embedded_logo.h"
#endif
#define FADE_IN_TIME 0.8f
#define DISPLAY_TIME 2.5f
#define FADE_OUT_TIME 0.8f
#define SPLASH_TOTAL_TIME (FADE_IN_TIME + DISPLAY_TIME + FADE_OUT_TIME)
typedef enum {
SPLASH_INDRAJITH,
SPLASH_MADE_WITH,
SPLASH_DONE
} SplashState;
static SplashState currentSplash = SPLASH_INDRAJITH;
static float splashTimer = 0.0f;
static Texture2D raylibLogo = { 0 };
static Texture2D reiluaLogo = { 0 };
static bool logosLoaded = false;
static float getSplashAlpha( float timer ) {
if ( timer < FADE_IN_TIME ) {
return timer / FADE_IN_TIME;
}
else if ( timer < FADE_IN_TIME + DISPLAY_TIME ) {
return 1.0f;
}
else {
float fadeOut = timer - FADE_IN_TIME - DISPLAY_TIME;
return 1.0f - ( fadeOut / FADE_OUT_TIME );
}
}
static void loadSplashLogos() {
if ( logosLoaded ) return;
#ifdef EMBED_LOGO
/* Load from embedded data */
Image raylib_img = LoadImageFromMemory( ".png", embedded_raylib_logo, embedded_raylib_logo_size );
raylibLogo = LoadTextureFromImage( raylib_img );
UnloadImage( raylib_img );
Image reilua_img = LoadImageFromMemory( ".png", embedded_reilua_logo, embedded_reilua_logo_size );
reiluaLogo = LoadTextureFromImage( reilua_img );
UnloadImage( reilua_img );
#else
/* Load from files (development mode) */
if ( FileExists( "logo/raylib_logo.png" ) ) {
raylibLogo = LoadTexture( "logo/raylib_logo.png" );
}
if ( FileExists( "logo/reilua_logo.png" ) ) {
reiluaLogo = LoadTexture( "logo/reilua_logo.png" );
}
#endif
logosLoaded = true;
}
static void unloadSplashLogos() {
if ( !logosLoaded ) return;
UnloadTexture( raylibLogo );
UnloadTexture( reiluaLogo );
logosLoaded = false;
}
static void drawIndrajithSplash( float alpha ) {
int screenWidth = GetScreenWidth();
int screenHeight = GetScreenHeight();
ClearBackground( (Color){ 230, 41, 55, 255 } ); // Raylib red
const char* text = "INDRAJITH MAKES GAMES";
int fontSize = 48;
float spacing = 2.0f;
Color textColor = WHITE;
textColor.a = (unsigned char)(255 * alpha);
/* Draw text with slight expansion effect during fade in */
float scale = 0.95f + (alpha * 0.05f); // Subtle scale from 0.95 to 1.0
/* Measure text with proper spacing for accurate centering */
Vector2 textSize = MeasureTextEx( state->defaultFont, text, fontSize * scale, spacing );
/* Calculate centered position */
Vector2 position = {
(float)(screenWidth / 2) - (textSize.x / 2),
(float)(screenHeight / 2) - (textSize.y / 2)
};
/* Draw with proper kerning */
DrawTextEx( state->defaultFont, text, position, fontSize * scale, spacing, textColor );
}
static void drawMadeWithSplash( float alpha ) {
int screenWidth = GetScreenWidth();
int screenHeight = GetScreenHeight();
ClearBackground( BLACK );
/* "Made using" text at top */
const char* madeText = "Made using";
int madeSize = 32;
int madeWidth = MeasureText( madeText, madeSize );
Color textColor = WHITE;
textColor.a = (unsigned char)(255 * alpha);
int textY = screenHeight / 2 - 100;
DrawText( madeText, screenWidth / 2 - madeWidth / 2, textY, madeSize, textColor );
/* Calculate logo sizes and positions - scale down if too large */
int maxLogoSize = 200;
float raylibScale = 1.0f;
float reiluaScale = 1.0f;
if ( raylibLogo.id > 0 && raylibLogo.width > maxLogoSize ) {
raylibScale = (float)maxLogoSize / (float)raylibLogo.width;
}
if ( reiluaLogo.id > 0 && reiluaLogo.width > maxLogoSize ) {
reiluaScale = (float)maxLogoSize / (float)reiluaLogo.width;
}
int raylibWidth = (int)(raylibLogo.width * raylibScale);
int raylibHeight = (int)(raylibLogo.height * raylibScale);
int reiluaWidth = (int)(reiluaLogo.width * reiluaScale);
int reiluaHeight = (int)(reiluaLogo.height * reiluaScale);
/* Position logos side by side with spacing */
int spacing = 40;
int totalWidth = raylibWidth + spacing + reiluaWidth;
int startX = screenWidth / 2 - totalWidth / 2;
int logoY = screenHeight / 2 - 20;
Color tint = WHITE;
tint.a = (unsigned char)(255 * alpha);
/* Draw Raylib logo */
if ( raylibLogo.id > 0 ) {
Rectangle source = { 0, 0, (float)raylibLogo.width, (float)raylibLogo.height };
Rectangle dest = { (float)startX, (float)logoY, (float)raylibWidth, (float)raylibHeight };
DrawTexturePro( raylibLogo, source, dest, (Vector2){ 0, 0 }, 0.0f, tint );
}
/* Draw ReiLua logo */
if ( reiluaLogo.id > 0 ) {
int reiluaX = startX + raylibWidth + spacing;
Rectangle source = { 0, 0, (float)reiluaLogo.width, (float)reiluaLogo.height };
Rectangle dest = { (float)reiluaX, (float)logoY, (float)reiluaWidth, (float)reiluaHeight };
DrawTexturePro( reiluaLogo, source, dest, (Vector2){ 0, 0 }, 0.0f, tint );
}
}
void splashInit() {
loadSplashLogos();
currentSplash = SPLASH_INDRAJITH;
splashTimer = 0.0f;
}
bool splashUpdate( float delta ) {
splashTimer += delta;
if ( splashTimer >= SPLASH_TOTAL_TIME ) {
splashTimer = 0.0f;
currentSplash++;
}
return currentSplash >= SPLASH_DONE;
}
void splashDraw() {
float alpha = getSplashAlpha( splashTimer );
BeginDrawing();
switch ( currentSplash ) {
case SPLASH_INDRAJITH:
drawIndrajithSplash( alpha );
break;
case SPLASH_MADE_WITH:
drawMadeWithSplash( alpha );
break;
default:
break;
}
EndDrawing();
}
void splashCleanup() {
unloadSplashLogos();
}

77
src/state.c
View File

@@ -4,31 +4,71 @@
#include "textures.h" #include "textures.h"
#include "models.h" #include "models.h"
#ifdef EMBED_FONT
#include "embedded_font.h"
#endif
State* state; State* state;
bool stateInit( int argn, const char** argc, const char* basePath ) { bool stateInit( int argn, const char** argc, const char* basePath ) {
state = malloc( sizeof( State ) ); state = malloc( sizeof( State ) );
state->basePath = malloc( STRING_LEN * sizeof( char ) ); state->basePath = malloc( STRING_LEN * sizeof( char ) );
strncpy( state->basePath, basePath, STRING_LEN - 1 ); strncpy( state->basePath, basePath, STRING_LEN - 1 );
/* Ensure basePath ends with a slash */
size_t len = strlen( state->basePath );
if ( len > 0 && state->basePath[len - 1] != '/' && state->basePath[len - 1] != '\\' ) {
if ( len < STRING_LEN - 2 ) {
state->basePath[len] = '/';
state->basePath[len + 1] = '\0';
}
}
state->hasWindow = true;
state->run = true;
state->resolution = (Vector2){ 800, 600 };
state->luaState = NULL; state->luaState = NULL;
state->run = luaInit( argn, argc );;
state->logLevelInvalid = LOG_ERROR; state->logLevelInvalid = LOG_ERROR;
state->gcUnload = true; state->gcUnload = true;
state->lineSpacing = 15; state->lineSpacing = 15;
state->mouseOffset = (Vector2){ 0, 0 }; state->mouseOffset = (Vector2){ 0, 0 };
state->mouseScale = (Vector2){ 1, 1 }; state->mouseScale = (Vector2){ 1, 1 };
state->customFontLoaded = false;
#if defined PLATFORM_DESKTOP_SDL2 || defined PLATFORM_DESKTOP_SDL3 InitWindow( state->resolution.x, state->resolution.y, "ReiLua" );
state->SDL_eventQueue = malloc( PLATFORM_SDL_EVENT_QUEUE_LEN * sizeof( SDL_Event ) );
state->SDL_eventQueueLen = 0; if ( !IsWindowReady() ) {
state->hasWindow = false;
state->run = false;
}
if ( state->run ) {
state->run = luaInit( argn, argc );
}
/* Load custom default font */
#ifdef EMBED_FONT
/* Load from embedded data */
state->defaultFont = LoadFontFromMemory( ".ttf", embedded_font_data, embedded_font_data_size, 48, NULL, 0 );
SetTextureFilter( state->defaultFont.texture, TEXTURE_FILTER_POINT );
state->customFontLoaded = true;
#else
/* Load from file (development mode) */
char fontPath[STRING_LEN];
snprintf( fontPath, STRING_LEN, "%sfonts/Oleaguid.ttf", state->basePath );
if ( FileExists( fontPath ) ) {
state->defaultFont = LoadFontEx( fontPath, 48, NULL, 0 );
SetTextureFilter( state->defaultFont.texture, TEXTURE_FILTER_POINT );
state->customFontLoaded = true;
}
else {
TraceLog( LOG_WARNING, "Custom font not found at '%s', using default font", fontPath );
state->defaultFont = GetFontDefault();
state->customFontLoaded = false;
}
#endif #endif
return state->run;
}
/* Init after InitWindow. (When there is OpenGL context.) */
void stateContextInit() {
state->defaultFont = GetFontDefault();
state->guiFont = GuiGetFont(); state->guiFont = GuiGetFont();
state->defaultMaterial = LoadMaterialDefault(); state->defaultMaterial = LoadMaterialDefault();
state->defaultTexture = (Texture){ 1, 1, 1, 1, 7 }; state->defaultTexture = (Texture){ 1, 1, 1, 1, 7 };
@@ -39,6 +79,17 @@ void stateContextInit() {
for ( int i = 0; i < RL_MAX_SHADER_LOCATIONS; i++ ) { for ( int i = 0; i < RL_MAX_SHADER_LOCATIONS; i++ ) {
state->RLGLcurrentShaderLocs[i] = defaultShaderLocs[i]; state->RLGLcurrentShaderLocs[i] = defaultShaderLocs[i];
} }
#if defined PLATFORM_DESKTOP_SDL2 || defined PLATFORM_DESKTOP_SDL3
state->SDL_eventQueue = malloc( PLATFORM_SDL_EVENT_QUEUE_LEN * sizeof( SDL_Event ) );
state->SDL_eventQueueLen = 0;
#endif
return state->run;
}
/* Init after InitWindow. (When there is OpenGL context.) */
void stateContextInit() {
/* This function is no longer needed as initialization is done in stateInit */
} }
void stateInitInterpret( int argn, const char** argc ) { void stateInitInterpret( int argn, const char** argc ) {
@@ -54,7 +105,11 @@ void stateFree() {
lua_close( state->luaState ); lua_close( state->luaState );
state->luaState = NULL; state->luaState = NULL;
} }
if ( IsWindowReady() ) { /* Unload custom font if it was loaded - must be done before CloseWindow */
if ( state->hasWindow && state->customFontLoaded ) {
UnloadFont( state->defaultFont );
}
if ( state->hasWindow ) {
CloseWindow(); CloseWindow();
} }
#ifdef PLATFORM_DESKTOP_SDL #ifdef PLATFORM_DESKTOP_SDL