Merge branch 'dev' into lights-fixes

This commit is contained in:
MihailRis 2026-10-11 15:25:10 +03:00
commit 3fc5a4322d
65 changed files with 1549 additions and 715 deletions

View file

@ -50,13 +50,13 @@ jobs:
- name: Run engine tests
timeout-minutes: 5
run: |
chmod +x build/VoxelEngine
chmod +x build/VoxelCore
chmod +x AppDir/usr/bin/vctest
AppDir/usr/bin/vctest -e build/VoxelEngine -d dev/tests -u build --memchecker valgrind
AppDir/usr/bin/vctest -e build/VoxelCore -d dev/tests -u build --memchecker valgrind
- name: Build AppImage
uses: AppImageCrafters/build-appimage-action@fe2205a4d6056be47051f7b1b3811106e9814910
env:
UPDATE_INFO: gh-releases-zsync|MihailRis|VoxelEngine-Cpp|latest|*x86_64.AppImage.zsync
UPDATE_INFO: gh-releases-zsync|MihailRis|voxelcore|latest|*x86_64.AppImage.zsync
with:
recipe: dev/AppImageBuilder.yml
- uses: actions/upload-artifact@v4

View file

@ -62,7 +62,7 @@ jobs:
# Build your program with the given configuration
run: |
cmake --build ${{github.workspace}}/build --config ${{inputs.build_type}}
mv ${{github.workspace}}/build/VoxelEngine VoxelEngine
mv ${{github.workspace}}/build/VoxelCore VoxelCore
- name: Run tests
if: ${{ inputs.run_tests }}
run: ctest --test-dir ${{github.workspace}}/build
@ -70,7 +70,7 @@ jobs:
if: ${{ inputs.upload_artifacts }}
uses: actions/upload-artifact@v4
with:
name: VoxelEngine
name: VoxelCore
path: |
VoxelEngine
VoxelCore
res/*

View file

@ -39,7 +39,7 @@ jobs:
run: chmod +x dev/fix_dylibs.sh
- name: Fix dylibs
run: ./dev/fix_dylibs.sh VoxelEngine Release build
run: ./dev/fix_dylibs.sh VoxelCore Release build
- name: Run tests
run: ctest --output-on-failure --test-dir build
@ -47,19 +47,19 @@ jobs:
- name: Run engine tests
timeout-minutes: 5
run: |
chmod +x build/VoxelEngine
chmod +x build/VoxelCore
chmod +x AppDir/usr/bin/vctest
AppDir/usr/bin/vctest -e build/VoxelEngine -d dev/tests -u build --output-always --debugger "lldb -batch -o 'run' -o 'thread backtrace all' -o 'quit' -- "
AppDir/usr/bin/vctest -e build/VoxelCore -d dev/tests -u build --output-always --debugger "lldb -batch -o 'run' -o 'thread backtrace all' -o 'quit' -- "
- name: Create DMG
run: |
mkdir VoxelEngineDmgContent
cp -r build/res VoxelEngineDmgContent/
cp -r build/VoxelEngine VoxelEngineDmgContent/
cp -r build/libs VoxelEngineDmgContent/libs
hdiutil create VoxelEngineMacApp.dmg -volname "VoxelEngine" -srcfolder VoxelEngineDmgContent -ov -format UDZO
mkdir VoxelCoreDmgContent
cp -r build/res VoxelCoreDmgContent/
cp -r build/VoxelCore VoxelCoreDmgContent/
cp -r build/libs VoxelCoreDmgContent/libs
hdiutil create VoxelCoreMacApp.dmg -volname "VoxelCore" -srcfolder VoxelCoreDmgContent -ov -format UDZO
- name: Upload artifacts
uses: actions/upload-artifact@v4
with:
name: VoxelEngineMacOs
path: VoxelEngineMacApp.dmg
name: VoxelCoreMacOs
path: VoxelCoreMacApp.dmg

View file

@ -48,7 +48,7 @@ jobs:
mkdir release
mv ./artifacts/AppImage/VoxelCore-latest-x86_64.AppImage \
./release/voxelcore-${RELEASE_VERSION}_x86-64.AppImage
mv ./artifacts/VoxelEngineMacOs/VoxelEngineMacApp.dmg \
mv ./artifacts/VoxelCoreMacOs/VoxelCoreMacApp.dmg \
./release/voxelcore-${RELEASE_VERSION}_macos.dmg
(cd ./artifacts/Windows-Build && zip -r ../../release/voxelcore-${RELEASE_VERSION}_win64.zip .)
ls -la ./release

View file

@ -59,11 +59,10 @@ jobs:
run: |
mkdir packaged
mkdir packaged/res
cp build/VoxelEngine.exe packaged/
cp build/VoxelCore.exe packaged/
cp build/vctest/vctest.exe packaged/
cp build/*.dll packaged/
cp -r build/res/* packaged/res/
mv packaged/VoxelEngine.exe packaged/VoxelCore.exe
- uses: actions/upload-artifact@v4
with:
name: Windows-Build

View file

@ -37,7 +37,7 @@ jobs:
run: ctest --preset default-vs-msvc-windows
- name: Run engine tests
run: |
build/vctest/RelWithDebInfo/vctest.exe -e build/RelWithDebInfo/VoxelEngine.exe -d dev/tests -u build
build/vctest/RelWithDebInfo/vctest.exe -e build/RelWithDebInfo/VoxelCore.exe -d dev/tests -u build
timeout-minutes: 5
- name: Package for Windows
run: |
@ -45,7 +45,6 @@ jobs:
cp -r build/RelWithDebInfo/* packaged/
cp build/vctest/RelWithDebInfo/vctest.exe packaged/
cp C:/Windows/System32/msvcp140.dll packaged/msvcp140.dll
mv packaged/VoxelEngine.exe packaged/VoxelCore.exe
working-directory: ${{ github.workspace }}
- uses: actions/upload-artifact@v4
with:

View file

@ -1,5 +1,5 @@
cmake_minimum_required(VERSION 3.5)
project(VoxelEngine)
project(VoxelCore)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
@ -27,23 +27,23 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
endif()
add_subdirectory(src)
add_executable(VoxelEngine src/main.cpp)
add_executable(VoxelCore src/main.cpp)
if(VOXELENGINE_BUILD_APPDIR)
include(${CMAKE_CURRENT_SOURCE_DIR}/dev/cmake/BuildAppdir.cmake)
endif()
target_link_libraries(VoxelEngine PRIVATE VoxelEngineSrc
target_link_libraries(VoxelCore PRIVATE VoxelCoreSrc
$<$<PLATFORM_ID:Windows>:winmm>)
target_link_options(VoxelEngine PRIVATE $<$<CXX_COMPILER_ID:GNU>:-no-pie>)
target_link_options(VoxelCore PRIVATE $<$<CXX_COMPILER_ID:GNU>:-no-pie>)
# Deploy res to build dir
add_custom_command(
TARGET VoxelEngine
TARGET VoxelCore
POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different
${CMAKE_CURRENT_SOURCE_DIR}/res $<TARGET_FILE_DIR:VoxelEngine>/res)
${CMAKE_CURRENT_SOURCE_DIR}/res $<TARGET_FILE_DIR:VoxelCore>/res)
if(VOXELENGINE_BUILD_TESTS)
enable_testing()

View file

@ -1,6 +1,6 @@
# Build docker container: docker build -t voxelcore .
# Build project: docker run --rm -it -v$(pwd):/project voxelcore bash -c "cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_RPATH_USE_LINK_PATH=TRUE -Bbuild && cmake --build build"
# Run project in docker: docker run --rm -it -v$(pwd):/project -v/tmp/.X11-unix:/tmp/.X11-unix -v${XAUTHORITY}:/home/user/.Xauthority:ro -eDISPLAY --network=host voxelcore ./build/VoxelEngine
# Run project in docker: docker run --rm -it -v$(pwd):/project -v/tmp/.X11-unix:/tmp/.X11-unix -v${XAUTHORITY}:/home/user/.Xauthority:ro -eDISPLAY --network=host voxelcore ./build/VoxelCore
FROM debian:bookworm-slim
LABEL Description="Docker container for building VoxelCore for Linux"

View file

@ -188,7 +188,7 @@ docker run --rm -it \
-v "$XAUTHORITY:/home/user/.Xauthority:ro" \
-e DISPLAY="$DISPLAY" \
--network=host \
voxel-engine ./build/VoxelEngine
voxel-engine ./build/VoxelCore
```
### On Windows
@ -218,5 +218,5 @@ docker run --rm -it -v "${PWD}:/project" voxel-engine bash -c "cmake -DCMAKE_BUI
#### Step 4. Run the application
```powershell
docker run --rm -it -v "${PWD}:/project" -e DISPLAY=host.docker.internal:0.0 --network=host voxel-engine ./build/VoxelEngine
docker run --rm -it -v "${PWD}:/project" -e DISPLAY=host.docker.internal:0.0 --network=host voxel-engine ./build/VoxelCore
```

View file

@ -6,7 +6,7 @@ AppDir:
name: VoxelCore
icon: VoxelCore
version: latest
exec: usr/bin/VoxelEngine
exec: usr/bin/VoxelCore
exec_args: --dir $HOME/.config/voxelcore --res $APPDIR/usr/share/VoxelCore/res $@
apt:
arch: amd64

View file

@ -3,8 +3,8 @@ Version=1.0
Type=Application
Name=VoxelCore
Comment=Minecraft-like game engine in C++ with OpenGL
TryExec=VoxelEngine
Exec=VoxelEngine
TryExec=VoxelCore
Exec=VoxelCore
Icon=VoxelCore
MimeType=image/x-foo;
Categories=Game;

View file

@ -12,4 +12,4 @@ file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/dev/VoxelCore.desktop DESTINATION ${CMAKE_
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/AppDir/usr/lib)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/AppDir/usr/lib)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/AppDir/usr/bin)
install(TARGETS VoxelEngine DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/AppDir/usr/bin)
install(TARGETS VoxelCore DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/AppDir/usr/bin)

View file

@ -1,34 +1,385 @@
local device = file.create_memory_device()
file.write(device..":test.txt", "Hello\nWorld")
file.write_bytes(device..":test.bin", Bytearray({20, 30, 100, 200, 255}))
local stream = file.open(device..":test.txt", 'r')
local function path(name) return device .. ":" .. name end
local line1 = stream:read_line()
local line2 = stream:read_line()
local function eq_list(actual, expected, msg)
asserts.equals(#actual, #expected, (msg or "list") .. " length")
for i = 1, #expected do
asserts.equals(actual[i], expected[i], (msg or "list") .. "[" .. i .. "]")
end
end
assert(line1 == "Hello")
assert(line2 == "World")
file.write(path("test.txt"), "Hello\nWorld")
file.write_bytes(path("test.bin"), Bytearray({20, 30, 100, 200, 255}))
local stream2 = file.open(device..":test.bin", 'rb')
local data = stream2:read(5)
assert(data[1] == 20)
assert(data[2] == 30)
assert(data[3] == 100)
assert(data[4] == 200)
assert(data[5] == 255)
do
local stream = file.open(path("test.txt"), 'r')
asserts.equals(stream:read_line(), "Hello")
asserts.equals(stream:read_line(), "World")
stream:close()
end
local stream3 = file.open(device..":test.txt", 'r')
assert(stream3:is_alive())
stream3:close()
assert(not stream3:is_alive())
do
local stream = file.open(path("test.bin"), 'rb')
local data = stream:read(5)
asserts.equals(data[1], 20); asserts.equals(data[2], 30); asserts.equals(data[3], 100); asserts.equals(data[4], 200); asserts
.equals(data[5], 255)
stream:close()
end
local stream4 = file.open(device..":test.txt", 'r')
stream4:seek('b', 6)
local line = stream4:read_line()
assert(line == "World")
do
local stream = file.open(path("test.txt"), 'r')
assert(stream:is_alive())
assert(not stream:is_closed())
stream:close()
assert(not stream:is_alive())
assert(stream:is_closed())
end
local stream5 = file.open(device..":test.txt", 'r')
stream5:seek('e', 0)
local pos = stream5:tell()
assert(pos == 11)
do
local stream = file.open(path("test.txt"), 'r')
stream:seek('b', 6)
asserts.equals(stream:read_line(), "World")
stream:close()
end
do
local stream = file.open(path("test.txt"), 'r')
stream:seek('e', 0)
asserts.equals(stream:tell(), 11)
stream:close()
end
-------------------------------------------------------------------------------
-- text: line endings and end of stream
-------------------------------------------------------------------------------
do
local stream = file.open(path("test.txt"), 'r')
stream:read_line(); stream:read_line()
asserts.equals(stream:read_line(), nil, "after last line")
asserts.equals(stream:read_line(), nil, "after last line, again")
stream:close()
end
do
file.write(path("empty.txt"), "")
local stream = file.open(path("empty.txt"), 'r')
asserts.equals(stream:read_line(), nil, "empty file")
stream:close()
end
do
file.write(path("crlf.txt"), "a\r\nb\rc\nd\r")
local stream = file.open(path("crlf.txt"), 'r')
asserts.equals(stream:read_line(), "a", "CRLF")
asserts.equals(stream:read_line(), "b\rc", "lone CR is kept")
asserts.equals(stream:read_line(), "d\r", "CR at end of stream")
asserts.equals(stream:read_line(), nil)
stream:close()
end
-------------------------------------------------------------------------------
-- text: read(count) and read_fully
-------------------------------------------------------------------------------
do
file.write(path("blank.txt"), "\n\nA\nB\n\n")
local stream = file.open(path("blank.txt"), 'r')
eq_list(stream:read(10), {"A", "B"}, "trimmed")
stream:close()
end
do
local stream = file.open(path("blank.txt"), 'r')
eq_list(stream:read(10, false), {"", "", "A", "B", ""}, "untrimmed")
stream:close()
end
do
file.write(path("only_blank.txt"), "\n\n\n")
local stream = file.open(path("only_blank.txt"), 'r')
eq_list(stream:read(5), {}, "only empty lines")
stream:close()
end
do
local stream = file.open(path("test.txt"), 'r')
eq_list(stream:read(5), {"Hello", "World"}, "past end of stream")
stream:close()
end
do
local stream = file.open(path("test.txt"), 'r')
assert(not pcall(stream.read, stream, -1), "negative count must fail")
stream:close()
end
do
local stream = file.open(path("test.txt"), 'r')
asserts.equals(stream:read(), "Hello")
stream:close()
end
do
local stream = file.open(path("test.txt"), 'r')
asserts.equals(stream:read_fully(), "Hello\nWorld", "read_fully as string")
stream:close()
end
do
local stream = file.open(path("test.txt"), 'r')
eq_list(stream:read_fully(true), {"Hello", "World"}, "read_fully as lines")
stream:close()
end
-------------------------------------------------------------------------------
-- text: writing
-------------------------------------------------------------------------------
do
local stream = file.open(path("out.txt"), 'w')
stream:write("one")
stream:write({"two", "three"})
stream:write_line("four")
stream:close()
asserts.equals(file.read(path("out.txt")), "one\ntwo\nthree\nfour\n", "text write")
end
do
local stream = file.open(path("out.txt"), 'w')
assert(not pcall(stream.write, stream, 42), "writing a number in text mode must fail")
stream:close()
end
-------------------------------------------------------------------------------
-- binary
-------------------------------------------------------------------------------
do
local stream = file.open(path("test.bin"), 'rb')
eq_list(stream:read(5, true), {20, 30, 100, 200, 255}, "read as table")
stream:close()
end
do
local stream = file.open(path("test.bin"), 'rb')
stream:read(3)
asserts.equals(#stream:read(10), 2, "short read")
asserts.equals(#stream:read(10), 0, "read at end of stream")
stream:close()
end
do
local stream = file.open(path("test.bin"), 'rb')
local data = stream:read_fully()
asserts.equals(#data, 5); asserts.equals(data[1], 20); asserts.equals(data[5], 255)
stream:close()
end
do
local stream = file.open(path("test.bin"), 'rb')
eq_list(stream:read_fully(true), {20, 30, 100, 200, 255}, "read_fully as table")
stream:close()
end
do
local stream = file.open(path("out.bin"), 'wb')
stream:write({1, 2, 3})
stream:write(Bytearray({4, 5}))
stream:close()
local data = file.read_bytes(path("out.bin"))
asserts.equals(#data, 5, "binary write length")
for i = 1, 5 do asserts.equals(data[i], i, "binary write byte " .. i) end
end
do
local stream = file.open(path("fmt.bin"), 'wb')
stream:write("<iH", -5, 1000)
stream:close()
stream = file.open(path("fmt.bin"), 'rb')
local a, b = stream:read("<iH")
asserts.equals(a, -5, "packed int")
asserts.equals(b, 1000, "packed ushort")
stream:close()
end
do
local stream = file.open(path("test.bin"), 'rb')
assert(not pcall(stream.read, stream), "binary read without args must fail")
assert(not pcall(stream.read, stream, true), "binary read with boolean must fail")
stream:close()
end
-------------------------------------------------------------------------------
-- settings
-------------------------------------------------------------------------------
do
local stream = file.open(path("test.txt"), 'r')
stream:set_binary_mode(true)
assert(stream:is_binary_mode())
stream:set_binary_mode(false)
assert(not stream:is_binary_mode(), "set_binary_mode(false)")
stream:close()
end
do
local stream = file.open(path("test.txt"), 'rb')
asserts.equals(stream:read_line(), "Hello")
stream:close()
end
do
local stream = file.open(path("test.txt"), 'r')
asserts.equals(stream:get_mode(), "default")
asserts.equals(stream:get_flush_mode(), "all")
assert(not pcall(stream.set_mode, stream, "nope"), "invalid mode must fail")
assert(not pcall(stream.set_flush_mode, stream, "nope"), "invalid flush mode must fail")
asserts.equals(stream:get_mode(), "default", "mode unchanged after error")
stream:close()
end
-------------------------------------------------------------------------------
-- buffered mode
-------------------------------------------------------------------------------
do
local stream = file.open(path("test.txt"), 'r')
stream:set_mode("buffered")
asserts.equals(stream:read_line(), "Hello")
asserts.equals(stream:read_line(), "World")
asserts.equals(stream:read_line(), nil)
stream:close()
end
do
local stream = file.open(path("test.txt"), 'r')
stream:set_mode("buffered")
stream:read_line()
asserts.equals(stream:available(), 5, "available")
assert(stream:available(5))
assert(not stream:available(6))
asserts.equals(stream:tell(), 6, "tell after buffered read")
stream:close()
end
do
local stream = file.open(path("test.txt"), 'r')
stream:set_mode("buffered")
stream:read_line()
stream:seek('c', 1)
asserts.equals(stream:read_line(), "orld", "seek 'c' in buffered mode")
stream:close()
end
do
local stream = file.open(path("test.txt"), 'r')
stream:set_mode("buffered")
stream:read_line()
stream:seek('b', 0)
asserts.equals(stream:read_line(), "Hello", "seek 'b' in buffered mode")
stream:close()
end
do
local stream = file.open(path("test.txt"), 'r')
stream:set_mode("buffered")
stream:set_max_buffer_size(2)
asserts.equals(stream:get_max_buffer_size(), 2)
eq_list(stream:read_fully(true), {"Hello", "World"}, "tiny buffer")
stream:close()
end
do
local stream = file.open(path("buf.bin"), 'wb')
stream:set_mode("buffered")
stream:write({1, 2, 3})
asserts.equals(stream:tell(), 3, "tell with pending writes")
stream:close()
end
do
local stream = file.open(path("buf.txt"), 'w')
stream:set_mode("buffered")
stream:write("abc")
stream:close()
asserts.equals(file.read(path("buf.txt")), "abc\n", "close flushes")
end
do
local stream = file.open(path("buf.txt"), 'w')
stream:set_mode("buffered")
stream:write("abc")
stream:set_mode("default")
stream:write("def")
stream:close()
asserts.equals(file.read(path("buf.txt")), "abc\ndef\n", "set_mode flushes")
end
do
local stream = file.open(path("big.bin"), 'wb')
stream:set_mode("buffered")
stream:set_max_buffer_size(4)
stream:write({1, 2})
stream:write({3, 4, 5, 6, 7, 8, 9, 10, 11, 12})
stream:write({13})
stream:close()
local data = file.read_bytes(path("big.bin"))
asserts.equals(#data, 13, "big write length")
for i = 1, 13 do asserts.equals(data[i], i, "big write byte " .. i) end
end
do
for _, flush_mode in ipairs({"all", "buffer"}) do
local stream = file.open(path("flush.txt"), 'w')
stream:set_mode("buffered")
stream:set_flush_mode(flush_mode)
stream:write("x")
stream:flush()
asserts.equals(file.read(path("flush.txt")), "x\n", "flush mode " .. flush_mode)
stream:close()
end
end
-------------------------------------------------------------------------------
-- yield mode
-------------------------------------------------------------------------------
do
local stream = file.open(path("test.txt"), 'r')
stream:set_mode("yield")
local co = coroutine.create(function()
return stream:read_line(), stream:read_fully()
end)
local ok, line, rest = coroutine.resume(co)
assert(ok, line)
asserts.equals(coroutine.status(co), "dead", "yield mode read_fully must not hang")
asserts.equals(line, "Hello")
asserts.equals(rest, "World")
stream:close()
end
do
local stream = file.open(path("test.bin"), 'rb')
stream:set_mode("yield")
local co = coroutine.create(function() return stream:read(100) end)
local ok, err = coroutine.resume(co)
assert(ok, err)
asserts.equals(coroutine.status(co), "suspended", "short read must yield")
stream:close()
local ok2, data = coroutine.resume(co)
assert(ok2, data)
asserts.equals(coroutine.status(co), "dead", "closed stream ends the wait")
asserts.equals(#data, 5, "bytes read before close")
end

View file

@ -41,6 +41,17 @@ assert(entries[1] == "memtest:dir/subdir/a.txt")
assert(entries[2] == "memtest:dir/subdir/b.txt")
assert(entries[3] == "memtest:dir/subdir/other")
debug.log("create sibling directory")
file.mkdir("memtest:dir/subdir/sibling")
assert(file.isfile("memtest:dir/subdir/a.txt"))
assert(file.isdir("memtest:dir/subdir/other"))
asserts.equals(4, #file.list("memtest:dir/subdir"))
debug.log("overwrite file")
file.write("memtest:dir/subdir/a.txt", "overwritten")
asserts.equals("overwritten", file.read("memtest:dir/subdir/a.txt"))
asserts.equals(4, #file.list("memtest:dir/subdir"))
debug.log("remove tree")
file.remove_tree("memtest:dir")
assert(not file.isdir("memtest:dir"))

View file

@ -1,6 +1,6 @@
local response_received = false
network.get("https://api.github.com/repos/MihailRis/VoxelEngine-Cpp/releases/latest", function (s)
network.get("https://api.github.com/repos/MihailRis/voxelcore/releases/latest", function (s)
print(json.parse(s).name)
response_received = true
end, function (code)

View file

@ -0,0 +1,33 @@
-- reload_module must run the module in its pack environment, as require does
local util = require "core:tests_util"
util.create_demo_world()
-- a pack with a module that uses pack environment (PACK_ID)
local PACK = "world:content/reload_test"
file.mkdirs(PACK .. "/modules")
file.write(PACK .. "/package.json", json.tostring({id="reload_test", title="reload_test"}))
local function write_module(version)
file.write(PACK .. "/modules/mod.lua", string.format([[
local this = {}
function this.info() return PACK_ID, %d end
return this
]], version))
end
write_module(1)
app.reconfig_packs({"reload_test"}, {})
app.tick()
local mod = require "reload_test:mod"
local packid, version = mod.info()
assert(packid == "reload_test" and version == 1)
write_module(2)
reload_module("reload_test:mod")
packid, version = mod.info()
assert(version == 2, "module is not reloaded")
assert(packid == "reload_test", "reloaded module has no pack environment")
app.close_world(true)
app.delete_world("demo")

119
dev/tests/zip_files.lua Normal file
View file

@ -0,0 +1,119 @@
local function sorted_list(path)
local entries = file.list(path)
table.sort(entries)
return entries
end
local function check_list(expected, path)
local entries = sorted_list(path)
asserts.equals(#expected, #entries)
for i, name in ipairs(expected) do
asserts.equals(name, entries[i])
end
end
local function join(root, name)
if root:sub(-1) == ":" then
return root..name
end
return root.."/"..name
end
local bytes = {0xDE, 0xAD, 0x00, 0xC0, 0xDE}
local function create_tree(root)
file.mkdirs(join(root, "sub/deep"))
file.mkdir(join(root, "empty"))
file.write(join(root, "root.txt"), "root file")
file.write(join(root, "sub/a.txt"), "example, пример")
file.write_bytes(join(root, "sub/deep/binary"), bytes)
end
local function check_tree(m)
debug.log("check directories")
assert(file.exists(m..":"))
assert(file.isdir(m..":"))
assert(file.isdir(m..":sub"))
assert(file.isdir(m..":sub/deep"))
assert(file.isdir(m..":empty"))
assert(not file.isfile(m..":sub"))
debug.log("check files")
assert(file.isfile(m..":root.txt"))
assert(file.isfile(m..":sub/a.txt"))
assert(not file.isdir(m..":sub/a.txt"))
assert(not file.exists(m..":missing.txt"))
assert(not file.exists(m..":sub/missing.txt"))
debug.log("read files")
asserts.equals("root file", file.read(m..":root.txt"))
asserts.equals("example, пример", file.read(m..":sub/a.txt"))
asserts.equals(#"root file", file.length(m..":root.txt"))
local rbytes = file.read_bytes(m..":sub/deep/binary")
asserts.equals(#bytes, #rbytes)
for i, b in ipairs(bytes) do
asserts.equals(b, rbytes[i])
end
debug.log("read file with io_stream")
local stream = file.open(m..":root.txt", "r")
asserts.equals("root file", stream:read_line())
stream:close()
debug.log("list directories")
check_list({m..":empty", m..":root.txt", m..":sub"}, m..":")
check_list({m..":sub/a.txt", m..":sub/deep"}, m..":sub")
check_list({m..":sub/deep/binary"}, m..":sub/deep")
check_list({}, m..":empty")
debug.log("check read-only")
assert(not file.is_writeable(m..":"))
assert(not pcall(file.write, m..":new.txt", "text"))
local ok, created = pcall(file.mkdir, m..":newdir")
assert(not (ok and created))
assert(not file.exists(m..":newdir"))
end
local function check_zip(src, zipfile)
debug.log("create zip "..zipfile.." from "..src)
file.create_zip(src, zipfile)
assert(file.isfile(zipfile))
debug.log("mount "..zipfile)
local m = file.mount(zipfile)
check_tree(m)
debug.log("unmount "..m)
file.unmount(m)
assert(not file.exists(m..":"))
assert(not pcall(file.read, m..":root.txt"))
assert(not pcall(file.unmount, m))
end
local mem = file.create_memory_device()
local out = file.create_memory_device()
debug.log("zip memory device root")
create_tree(mem..":")
check_zip(mem..":", out..":root.zip")
debug.log("zip memory device subdirectory")
create_tree(mem..":pack")
check_zip(mem..":pack", out..":pack.zip")
debug.log("zip nested subdirectory")
create_tree(mem..":a/b/pack")
check_zip(mem..":a/b/pack", out..":nested.zip")
debug.log("zip real filesystem directory")
if file.exists("config:ziptest") then
file.remove_tree("config:ziptest")
end
create_tree("config:ziptest/pack")
check_zip("config:ziptest/pack", "config:ziptest/pack.zip")
file.remove_tree("config:ziptest")
debug.log("mount non-zip file")
file.write(out..":text.txt", "not an archive")
assert(not pcall(file.mount, out..":text.txt"))

View file

@ -1,5 +1,9 @@
# Documentation
>![WARNING]
> This branch is used for VoxelCore 0.33 development, API is unstable.
> [Proceed to VoxelCore 0.32 documentation](https://github.com/MihailRis/voxelcore/blob/release-0.32/doc/en/main-page.md)
## Sections
- [Assets preloading](assets-preload.md)

View file

@ -41,8 +41,14 @@ skeleton:is_visible([optional] index: int) -> bool
skeleton:set_visible([optional] index: int, status: bool)
-- Returns the color of the entity
skeleton:get_color() -> vec3
skeleton:get_color() -> vec4
-- Returns the color of the bone
skeleton:get_color(index: int) -> vec4
-- Sets the color of the entity
skeleton:set_color(color: vec3)
skeleton:set_color(color: vec4)
-- Sets the color of the bone
skeleton:set_color(color: vec4, bone: int)
```

View file

@ -50,7 +50,7 @@ network.get(
)
-- Example:
network.get("https://api.github.com/repos/MihailRis/VoxelEngine-Cpp/releases/latest", function (s)
network.get("https://api.github.com/repos/MihailRis/voxelcore/releases/latest", function (s)
print(json.parse(s).name) -- will output the name of the latest engine release
end)

View file

@ -185,9 +185,11 @@ rig:index(name: str) -> int
-- or the skeleton if no index is specified
rig:is_visible([optional] index: int) -> bool
-- Sets the visibility status of the skeleton
rig:set_visible(status: bool)
-- Sets the visibility status of a bone by index
-- or the skeleton if no index is specified
rig:set_visible([optional] index: int, status: bool)
rig:set_visible(index: int, status: bool)
-- Returns the color of the entity
rig:get_color() -> vec4

View file

@ -28,6 +28,9 @@ Two kinds of curve definitions are currently available, each producing a value `
- `@scale` - scales an object/bone (multiplier)
- `@zoom` - camera zoom (multiplier)
- `@texture` - change of a dynamically assigned texture (see [skeleton:set_texture](scripting/ecs.md#skeleton))
- `@model` - bone model replacement (see [skeleton:set_model](scripting/ecs.md#skeleton))
- `@show` - visibility of a bone or the entire skeleton/object (if no bone is specified)
- `@color` - color of a bone or the entire skeleton/object (if no bone is specified) (RGBA)
## Metadata
@ -96,6 +99,23 @@ If you do not wish to limit the animation duration via `configure` but want to l
}
```
Example of using flag directives like `show`:
```vcd
# Specific bone
@show bone head period 20 {
@key frame 0 value on
@key frame 10 value off
}
# Entire skeleton
@show period 30 {
@key frame 0 value on
@key frame 10 value off
}
```
## Expression curves
The attribute describes a function `f(t) = x`, where t is time in seconds.

View file

@ -215,6 +215,9 @@ Element is a container. Does not have specific attributes.
> [!WARNING]
> Inventories position is controlled by the engine and can not be changed by attributes *pos* and *margin*
> [!WARNING]
> Slots not linked to an inventory will not be displayed. "Linked to an inventory" refers to the association between an inventory UI element and an inventory via an ID. This link can be explicitly established using `inventory_ui.inventory = inventory_id`. [(see ui.md)](scripting/ui.md#inventory)
## *slot*
Element must be in direct sub-element of *inventory*.

View file

@ -1,5 +1,9 @@
# Документация
>![WARNING]
> В этой ветке ведётся разработка VoxelCore 0.33, API нестабилен.
> [Перейти к документации VoxelCore 0.32](https://github.com/MihailRis/voxelcore/blob/release-0.32/doc/ru/main-page.md)
## Разделы
- [XML разметка интерфейса](xml-ui-layouts.md)

View file

@ -42,8 +42,14 @@ skeleton:is_visible([опционально] index: int) -> boolean
skeleton:set_visible([опционально] index: int, status: boolean)
-- Возвращает цвет сущности
skeleton:get_color() -> vec3
skeleton:get_color() -> vec4
-- Возвращает цвет кости
skeleton:get_color(index: int) -> vec4
-- Устанавливает цвет сущности
skeleton:set_color(color: vec3)
```
skeleton:set_color(color: vec4)
-- Устанавливает цвет кости
skeleton:set_color(color: vec4, index: int)
```

View file

@ -50,7 +50,7 @@ network.get(
)
-- Пример:
network.get("https://api.github.com/repos/MihailRis/VoxelEngine-Cpp/releases/latest", function (s)
network.get("https://api.github.com/repos/MihailRis/voxelcore/releases/latest", function (s)
print(json.parse(s).name) -- выведет имя последнего релиза движка
end)

View file

@ -174,9 +174,11 @@ rig:index(name: str) -> int
-- или всего скелета, если индекс не указан
rig:is_visible([optional] index: int) -> bool
-- Устанавливает статус видимости всего скелета
rig:set_visible(status: bool)
-- Устанавливает статус видимости кости по индексу
-- или всего скелета, если индекс не указан
rig:set_visible([optional] index: int, status: bool)
rig:set_visible(index: int, status: bool)
-- Возвращает цвет сущности
rig:get_color() -> vec4

View file

@ -28,6 +28,9 @@ VCA файл состоит из набора директив, порядок
- `@scale` - масштабирование объекта/кости (множитель)
- `@zoom` - масштаб камеры (множитель)
- `@texture` - смена динамически-назначаемой текстуры (см. [skeleton:set_texture](scripting/ecs.md#skeleton))
- `@model` - назначение замены модели кости (см. [skeleton:set_model](scripting/ecs.md#skeleton))
- `@show` - видимость кости или всего скелета / объекта (если не указана кость)
- `@color` - цвет кости или всего скелета / объекта (если не указана кость) (RGBA)
## Мета-информация
@ -96,6 +99,23 @@ VCA файл состоит из набора директив, порядок
}
```
Пример использования директив-флагов, таких как `show`:
```vcd
# Конкретная кость
@show bone head period 20 {
@key frame 0 value on
@key frame 10 value off
}
# Весь скелет
@show period 30 {
@key frame 0 value on
@key frame 10 value off
}
```
## Кривые через выражения
Через атрибут описывается функция `f(t) = x` где t - время в секундах.

View file

@ -216,6 +216,9 @@
> [!WARNING]
> Расположение инвентарей управляется движком и не может быть изменено свойствами pos, margin и т.д.
> [!WARNING]
> Слоты без привязки к инвентарю не будут отображаться. Под приязкой к инвентарю понимается связь UI элемента inventory с инвентарём по id. Которая может быть явно создана через `inventory_ui.inventory = inventory_id`. [(см ui.md)](scripting/ui.md#инвентарь-inventory)
## Одиночный слот - *slot*
Элемент должен находиться внутри `inventory` элемента, без посредников.

View file

@ -2,7 +2,7 @@
Format version: 1.1
This binary data format is developed for use as binary version of JSON in [VoxelEngine-Cpp](https://github.com/MihailRis/VoxelEngine-Cpp) and not compatible with [BSON](https://bsonspec.org/spec.html) due to elements/entries syntax and type codes differences
This binary data format is developed for use as binary version of JSON in [voxelcore](https://github.com/MihailRis/voxelcore) and not compatible with [BSON](https://bsonspec.org/spec.html) due to elements/entries syntax and type codes differences
## Basic types

View file

@ -56,7 +56,7 @@
installPhase = ''
mkdir -p $out/bin
cp VoxelEngine $out/bin/
cp VoxelCore $out/bin/
'';
};
in

View file

@ -1,6 +1,6 @@
{
"id": "base",
"title": "Base",
"version": "0.32",
"version": "0.33",
"description": "basic content package"
}

View file

@ -39,12 +39,15 @@ local function bezier_interpolation(k0, k1, t)
return bezier(k0.value, k0.ry + k0.value, k1.ly + k1.value, k1.value, u)
end
local this = {
local M = {
CH_TRANSLATE = 1,
CH_ROTATE = 2,
CH_SCALE = 3,
CH_ZOOM = 4,
CH_TEXTURE = 5,
CH_SHOW = 6,
CH_MODEL = 7,
CH_COLOR = 8,
INT_CONST = 1,
INT_LINEAR = 2,
@ -53,7 +56,7 @@ local this = {
MAX_DURATION = 1e9,
MAX_FRAMES = 1e9,
TRACE_CODEGEN = false,
TRACE_CODEGEN = true,
maths = {
bezier_interpolation = bezier_interpolation
@ -67,14 +70,14 @@ function internals.store_animation(name, track)
loaded_tracks[name] = track
end
function this.get_track(identifier)
function M.get_track(identifier)
return loaded_tracks[identifier]
end
local running_actions = {}
local playing_tracks = {}
function this.action(func)
function M.action(func)
table.insert(running_actions, coroutine.create(func))
end
@ -98,7 +101,7 @@ local PlayingTrack = {
}
}
function this.play(name, target)
function M.play(name, target)
if target and target.reset_pose then
target:reset_pose()
end
@ -156,4 +159,4 @@ function internals.restore_animation_backup()
loaded_tracks, backup_tracks = backup_tracks, {}
end
return this
return M

View file

@ -15,7 +15,7 @@ local exclude_patters = {
}
-- TODO: replace with actual expression -> lua translator
local function process_expression(src, memoised, mode)
local function process_expression(src, mode)
if mode == 'mul' then
src = string.format("(%s) * intensity + (1.0 - intensity)", src)
elseif mode == "add" then
@ -30,7 +30,6 @@ local function process_expression(src, memoised, mode)
for i, pattern in ipairs(patterns) do
local pattern_safe = string.pattern_safe(pattern.pattern)
if src:find(pattern_safe) then
memoised[pattern.name] = pattern.pattern
src = src:gsub(pattern_safe, pattern.name)
end
end
@ -76,7 +75,7 @@ local env = {
return keys[left].value
end
left = keys[left]
if interp == INT_CONST then
if not interp or interp == INT_CONST then
return left.value
end
right = keys[right]
@ -137,42 +136,48 @@ local is_multiplier = {
[animation.CH_ZOOM] = true,
}
local function codegen_track(raw_track, lineset, memoised, keysets, use_tsf)
local function codegen_line(raw_track, lineset, line, index, keysets)
if line.expression then
return "(" .. process_expression(line.expression,
is_multiplier[line.channel] and "mul" or "add") .. ")"
elseif line.keys then
local target_keysets = keysets[lineset.target_name]
if not target_keysets then
target_keysets = {}
keysets[lineset.target_name] = target_keysets
end
target_keysets[index] = line.keys
if line.curve_func then
local valueat = string.format("curves[%s]", string.escape(line.curve_func))
return string.format("value_at_custom(keysets['%s'][%d], t * %s %% %s, %s)",
lineset.target_name, index, raw_track.fps, line.period, valueat)
elseif line.channel == animation.CH_TEXTURE then
return string.format("string_at(keysets['%s'][%d], t * %s %% %s)",
lineset.target_name, index, raw_track.fps, line.period)
else
return string.format("value_at(keysets['%s'][%d], t * %s %% %s, %s)",
lineset.target_name, index, raw_track.fps, line.period, line.interp)
end
end
end
local function codegen_track(raw_track, lineset, keysets, use_tsf, target_type)
if lineset.target_type ~= target_type then
return ""
end
local lines = lineset.lines
local code = ""
local has_tsf = false
local translation = {false, false, false}
local rotation = {false, false, false}
local scale = {false, false, false}
local color = {false, false, false, false}
for i, line in ipairs(lines) do
if line.expression then
code = code .. "\n local l" .. i .. " = (" ..
process_expression(line.expression, memoised,
is_multiplier[line.channel] and "mul" or "add") .. ")"
elseif line.keys then
local target_keysets = keysets[lineset.target_name]
if not target_keysets then
target_keysets = {}
keysets[lineset.target_name] = target_keysets
end
target_keysets[i] = line.keys
if line.curve_func then
local valueat = string.format("curves[%s]", string.escape(line.curve_func))
code = code .. string.format(
"\n local l%d = value_at_custom(keysets['%s'][%d], t * %s %% %s, %s)",
i, lineset.target_name, i, raw_track.fps, line.period, valueat)
elseif line.channel == animation.CH_TEXTURE then
code = code .. string.format(
"\n local l%d = string_at(keysets['%s'][%d], t * %s %% %s)",
i, lineset.target_name, i, raw_track.fps, line.period)
else
code = code .. string.format(
"\n local l%d = value_at(keysets['%s'][%d], t * %s %% %s, %s)",
i, lineset.target_name, i, raw_track.fps, line.period, line.interp)
end
end
code = code .. string.format("\n local l%d = ", i)
.. codegen_line(raw_track, lineset, line, i, keysets)
if line.channel == animation.CH_TRANSLATE then
translation[line.axis] = i
@ -186,7 +191,31 @@ local function codegen_track(raw_track, lineset, memoised, keysets, use_tsf)
elseif line.channel == animation.CH_ZOOM then
code = code .. "\n zoom = l" .. i
elseif line.channel == animation.CH_TEXTURE then
code = code .. string.format("\n target:set_texture(%s, %s)", lineset.target_name:escape(), "l"..i)
code = code .. string.format("\n target:set_texture(%s, l%d)",
lineset.target_name:escape(), i)
elseif line.channel == animation.CH_MODEL then
code = code .. string.format("\n target:set_model(bone_index, l%d)", i)
elseif line.channel == animation.CH_SHOW then
if target_type == "bone" then
code = code .. string.format("\n target:set_visible(bone_index, l%d)", i)
else
code = code .. string.format("\n target:set_visible(l%d)", i)
end
elseif line.channel == animation.CH_COLOR then
color[line.axis] = i
end
end
if color[1] or color[2] or color[3] or color[4] then
local color_vector = "{" ..
(color[1] and ("l" .. color[1]) or '1').. ", " ..
(color[2] and ("l" .. color[2]) or '1').. ", " ..
(color[3] and ("l" .. color[3]) or '1').. ", " ..
(color[4] and ("l" .. color[4]) or '1').. "}"
if target_type == "bone" then
code = code .. "\n target:set_color(" .. color_vector .. ", bone_index)"
else
code = code .. "\n target:set_color(" .. color_vector .. ")"
end
end
@ -229,14 +258,15 @@ local function codegen_rig_target(raw_track, context)
if lineset.target_type ~= "bone" and lineset.target_type ~= "texture" then
goto continue
end
local lineset_code = codegen_track(
raw_track, lineset, context.memoised, context.keysets, true)
local lineset_code = codegen_track(raw_track, lineset, context.keysets, true, "bone")
code = code .. string.format("\n local bone_index = target:index(%s)", string.escape(bone))
if context.has_tsf then
code = code .. "\n local dst = target:get_matrix(bone_index)"
end
code = code
.. string.format("\n local bone_index = target:index(%s)"
.. "\n local dst = target:get_matrix(bone_index)", string.escape(bone))
.. "\n do" .. lineset_code .. "\n end\n"
if lineset.target_type == "bone" then
if lineset.target_type == "bone" and context.has_tsf then
code = code ..
" target:set_matrix(bone_index, dst)\n"
end
@ -246,17 +276,18 @@ local function codegen_rig_target(raw_track, context)
end
local function codegen_object_target(raw_track, context)
local code = "\n if target.set_pos then\n"
code = code .. " local dst = mat4.idt()\n"
local code = " local dst = mat4.idt()\n"
local lineset = raw_track.linesets[""]
if not lineset then
return ""
end
local lineset_code = codegen_track(
raw_track, lineset, context.memoised, context.keysets, true)
local lineset_code = codegen_track(raw_track, lineset, context.keysets, true)
code = code .. "\n do" .. lineset_code .. "\n end\n"
.. " set_matrix(target, dst)\n"
return code .. " end"
if context.has_tsf then
code = code .. " set_matrix(target, dst)\n"
end
return code
end
local function codegen_camera_target(raw_track, context)
@ -266,25 +297,37 @@ local function codegen_camera_target(raw_track, context)
if not lineset then
return ""
end
local lineset_code = codegen_track(
raw_track, lineset, context.memoised, context.keysets, false)
local lineset_code = codegen_track(raw_track, lineset, context.keysets, false, "camera")
code = code .. "\n do" .. lineset_code .. "\n end\n"
.. " target:set_zoom(zoom)\n"
return code .. " end"
end
local function has_transform_directive(raw_track)
for _, lineset in pairs(raw_track.linesets) do
for _, line in ipairs(lineset.lines) do
if line.channel == animation.CH_TRANSLATE or
line.channel == animation.CH_ROTATE or
line.channel == animation.CH_SCALE then
return true
end
end
end
return false
end
function internals.compile_animation_track(raw_track, track_name)
local code = ""
local context = {
memoised = {},
keysets = {},
curves = {},
has_tsf = has_transform_directive(raw_track),
}
for name, curve in pairs(raw_track.curves) do
context.curves[name] = load(string.format(
"return function(kl, kr, t) return %s end",
process_expression(curve.func, context.memoised, "curve")
process_expression(curve.func, "curve")
), "<curve>", "t", env)()
end
@ -292,17 +335,8 @@ function internals.compile_animation_track(raw_track, track_name)
code = code .. codegen_object_target(raw_track, context)
code = code .. codegen_camera_target(raw_track, context)
local memoised_code = ""
for name, expression in pairs(context.memoised) do
memoised_code = memoised_code .. "\n local " .. name .. " = "
.. expression
end
if #memoised_code > 0 then
code = memoised_code .. "\n" .. code
end
local src = "return function(target, t, intensity, m)\n m = m or 1\n intensity = intensity or 1.0\n"
local src = "return function(target, t, intensity, m)\n"
.. " m = m or 1\n intensity = intensity or 1.0\n"
.. code .. "\nend"
if animation.TRACE_CODEGEN then

View file

@ -8,6 +8,9 @@ local action_to_channel = {
scale = animation.CH_SCALE,
zoom = animation.CH_ZOOM,
texture = animation.CH_TEXTURE,
show = animation.CH_SHOW,
model = animation.CH_MODEL,
color = animation.CH_COLOR,
}
local curve_to_interp = {
@ -16,14 +19,18 @@ local curve_to_interp = {
bezier = animation.INT_BEZIER,
}
local boolean_actions = {
show = true
}
local function parse_configure(raw_track, node)
if node.fps then
raw_track.fps = node.fps
raw_track.fps = tonumber(node.fps)
end
if node.frames then
raw_track.duration = node.frames / (node.fps or DEFAULT_FPS)
raw_track.duration = tonumber(node.frames) / (tonumber(raw_track.fps) or DEFAULT_FPS)
elseif node.duration then
raw_track.duration = node.duration
raw_track.duration = tonumber(node.duration)
end
raw_track.rotation_order = string.upper(node["rotation-order"] or "XYZ")
end
@ -62,6 +69,70 @@ local function parse_simple_frames(line, node)
end
end
local function parse_boolean_frames(line, node)
line.keys = {}
for j, key_node in ipairs(node) do
local keyframe = {
frame = tonumber(key_node.frame),
value = key_node.value == "on",
}
table.insert(line.keys, keyframe)
end
end
local function parse_directive(node, raw_track)
local linesets = raw_track.linesets
local tag = node['#']
if tag == "configure" then
parse_configure(raw_track, node)
return
elseif tag == "curve" then
raw_track.curves[node.name] = node
return
end
local target_type = nil
if node.bone then
target_type = "bone"
elseif node.zoom then
target_type = "camera"
elseif tag == "texture" then
target_type = "texture"
end
local target_name = node.bone or node.name or ""
local lineset = linesets[target_name]
if not lineset then
lineset = {
lines = {},
target_type = target_type,
target_name = target_name,
flag = node.flag,
}
linesets[target_name] = lineset
end
local channel = action_to_channel[tag]
if not channel then
error("unknown directive " .. tag:escape())
end
local line = {
axis = node.by and (("xyz"):find(node.by) or ("rgba"):find(node.by)) or "",
channel = channel,
period = node.period or animation.MAX_FRAMES
}
if node.func then
line.expression = node.func
elseif node.curve then
parse_curve(line, node)
elseif boolean_actions[tag] then
parse_boolean_frames(line, node)
else
parse_simple_frames(line, node)
end
table.insert(lineset.lines, line)
end
local function parse_track(root)
local raw_track = {
duration = math.huge,
@ -69,56 +140,10 @@ local function parse_track(root)
linesets = {},
curves = {},
}
local linesets = raw_track.linesets
for i, node in ipairs(root) do
if type(node) == "string" then
goto continue
if type(node) == 'table' then
parse_directive(node, raw_track)
end
local tag = node['#']
if tag == "configure" then
parse_configure(raw_track, node)
goto continue
elseif tag == "curve" then
raw_track.curves[node.name] = node
goto continue
end
local target_type = nil
if node.bone then
target_type = "bone"
elseif tag == "texture" then
target_type = "texture"
end
local target_name = node.bone or node.name or ""
local lineset = linesets[target_name]
if not lineset then
lineset = {
lines = {},
target_type = target_type,
target_name = target_name
}
linesets[target_name] = lineset
end
local channel = action_to_channel[tag]
if not channel then
error("unknown directive " .. tag:escape())
end
local line = {
axis = node.by and ("xyz"):find(node.by) or "",
channel = channel,
period = node.period or animation.MAX_FRAMES
}
if node.func then
line.expression = node.func
elseif node.curve then
parse_curve(line, node)
else
parse_simple_frames(line, node)
end
table.insert(lineset.lines, line)
::continue::
end
return raw_track
end

View file

@ -0,0 +1,72 @@
local binary = {}
binary.__index = binary
local DEFAULT_CHUNK = 8192
function binary.new(stream)
return setmetatable({ stream = stream }, binary)
end
local function to_table(bytes)
local t = {}
for i = 1, #bytes do
t[i] = bytes[i]
end
return t
end
function binary.read_all(stream)
local result = Bytearray()
local avail = stream:available()
local chunk = avail > 0 and avail or DEFAULT_CHUNK
while true do
local part = stream:read_some(chunk)
if #part == 0 then break end
result:append(part)
end
return result
end
function binary:read(arg, as_table)
local t = type(arg)
if t == "number" then
local bytes = self.stream:read(arg)
return as_table and to_table(bytes) or bytes
elseif t == "string" then
local size = byteutil.get_size(arg)
local bytes = self.stream:read(size)
if #bytes < size then
error(string.format(
"unexpected end of stream: format %q needs %d bytes, got %d",
arg, size, #bytes), 2)
end
return byteutil.unpack(arg, bytes)
elseif t == "nil" then
error("in binary mode the first argument must be a byteutil format string"
.. " or the number of bytes to read")
else
error("unknown argument type: " .. t)
end
end
function binary:write(arg, ...)
local t = type(arg)
if t == "string" then
self.stream:write(byteutil.pack(arg, ...))
elseif t == "table" then
self.stream:write(Bytearray(arg))
else
self.stream:write(arg)
end
end
function binary:read_fully(as_table)
local bytes = binary.read_all(self.stream)
return as_table and to_table(bytes) or bytes
end
return binary

View file

@ -0,0 +1,19 @@
local wrapper = require "internal/stream/wrapper"
local blocking = wrapper.extend({})
function blocking.new(inner)
return setmetatable({ inner = inner }, blocking)
end
function blocking:read(n)
local result = self.inner:read(n)
while #result < n do
coroutine.yield()
if not self.inner:is_alive() then break end
result:append(self.inner:read(n - #result))
end
return result
end
return blocking

View file

@ -0,0 +1,90 @@
local wrapper = require "internal/stream/wrapper"
local buffered = wrapper.extend({})
buffered.DEFAULT_SIZE = 8192
function buffered.new(inner, size, flush_inner)
return setmetatable({
inner = inner,
size = size or buffered.DEFAULT_SIZE,
flush_inner = flush_inner ~= false,
rbuf = Bytearray(),
wbuf = Bytearray(),
}, buffered)
end
function buffered:_take(n)
local buf = self.rbuf
if n >= #buf then
self.rbuf = Bytearray()
return buf
end
local part = buf:slice(1, n)
buf:remove(1, n)
return part
end
function buffered:flush_buffer()
if #self.wbuf > 0 then
local data = self.wbuf
self.wbuf = Bytearray()
self.inner:write(data)
end
end
function buffered:read(n)
local have = #self.rbuf
if have < n then
if have == 0 and n >= self.size then
return self.inner:read(n)
end
self.rbuf:append(self.inner:read(self.size - have))
end
return self:_take(n)
end
buffered.read_some = buffered.read
function buffered:write(data)
if #self.wbuf + #data > self.size then
self:flush_buffer()
end
if #data >= self.size then
self.inner:write(data)
else
self.wbuf:append(data)
end
end
function buffered:flush()
self:flush_buffer()
if self.flush_inner then
self.inner:flush()
end
end
function buffered:available()
return self.inner:available() + #self.rbuf
end
function buffered:seek(mode, offset)
self:flush_buffer()
if mode == "c" then
offset = offset - #self.rbuf
end
self.rbuf = Bytearray()
self.inner:seek(mode, offset)
end
function buffered:tell()
return self.inner:tell() - #self.rbuf + #self.wbuf
end
function buffered:close()
self:flush_buffer()
self.rbuf = Bytearray()
return self.inner:close()
end
return buffered

View file

@ -0,0 +1,49 @@
local raw = {}
raw.__index = raw
function raw.new(descriptor, io_lib)
return setmetatable({ descriptor = descriptor, io_lib = io_lib }, raw)
end
function raw:read(n)
return self.io_lib.read(self.descriptor, n)
end
raw.read_some = raw.read
function raw:write(data)
self.io_lib.write(self.descriptor, data)
end
function raw:flush()
if self.io_lib.flush then
self.io_lib.flush(self.descriptor)
elseif not self:is_alive() then
error("stream is closed")
end
end
function raw:available()
local f = self.io_lib.available
return f and f(self.descriptor) or 0
end
function raw:seek(mode, offset)
if not self.io_lib.seek then error("cannot seek this stream") end
self.io_lib.seek(self.descriptor, mode, offset)
end
function raw:tell()
if not self.io_lib.tell then error("cannot tell this stream") end
return self.io_lib.tell(self.descriptor)
end
function raw:is_alive()
return self.io_lib.is_alive(self.descriptor)
end
function raw:close()
return self.io_lib.close(self.descriptor)
end
return raw

View file

@ -0,0 +1,102 @@
local binary = require "internal/stream/binary"
local text = {}
text.__index = text
local CR = string.byte('\r')
local LF = string.byte('\n')
function text.new(stream)
return setmetatable({stream = stream}, text)
end
function text:_read_byte()
return self.stream:read(1)[1]
end
function text:read_line()
local line = Bytearray()
local got_any = false
while true do
local b = self:_read_byte()
if b == nil then break end
got_any = true
if b == LF then
break
elseif b == CR then
local nb = self:_read_byte()
if nb == LF then break end
line:append(CR)
if nb == nil then break end
line:append(nb)
else
line:append(b)
end
end
if not got_any then return nil end
return utf8.tostring(line)
end
local function trim_empty(lines)
while #lines > 0 and lines[#lines] == "" do
lines[#lines] = nil
end
while #lines > 0 and lines[1] == "" do
table.remove(lines, 1)
end
end
function text:read_lines(count, trim)
if count < 0 then error("count of lines to read must be positive") end
local lines = {}
for i = 1, count do
local line = self:read_line()
if line == nil then break end
lines[i] = line
end
if trim ~= false then trim_empty(lines) end
return lines
end
function text:read(count, trim)
if count == nil then
return self:read_line()
end
return self:read_lines(count, trim)
end
function text:read_fully(as_lines)
if as_lines then
local lines = {}
for line in self.read_line, self do
lines[#lines + 1] = line
end
return lines
end
return utf8.tostring(binary.read_all(self.stream))
end
function text:write_line(str)
self.stream:write(utf8.tobytes(str .. "\n"))
end
-- write(string) | write({ lines... })
function text:write(arg)
local t = type(arg)
if t == "string" then
self:write_line(arg)
elseif t == "table" then
for i = 1, #arg do
self:write_line(arg[i])
end
else
error("unknown argument type: " .. t)
end
end
return text

View file

@ -0,0 +1,26 @@
local wrapper = {}
wrapper.__index = wrapper
function wrapper.extend(cls)
cls.__index = cls
return setmetatable(cls, { __index = wrapper })
end
function wrapper:read(n) return self.inner:read(n) end
function wrapper:read_some(n) return self.inner:read_some(n) end
function wrapper:write(data) return self.inner:write(data) end
function wrapper:flush() return self.inner:flush() end
function wrapper:available() return self.inner:available() end
function wrapper:seek(mode, off) return self.inner:seek(mode, off) end
function wrapper:tell() return self.inner:tell() end
function wrapper:is_alive() return self.inner:is_alive() end
function wrapper:close() return self.inner:close() end
return wrapper

View file

@ -1,444 +1,108 @@
local io_stream = { }
local raw = require "internal/stream/raw"
local buffered = require "internal/stream/buffered"
local blocking = require "internal/stream/blocking"
local binary = require "internal/stream/binary"
local text = require "internal/stream/text"
local io_stream = {}
io_stream.__index = io_stream
local MAX_BUFFER_SIZE = 8192
local DEFAULT_MODE = "default"
local BUFFERED_MODE = "buffered"
local YIELD_MODE = "yield"
local ALL_MODES = {
DEFAULT_MODE,
BUFFERED_MODE,
YIELD_MODE
}
local FLUSH_MODE_ALL = "all"
local FLUSH_MODE_ONLY_BUFFER = "buffer"
local ALL_FLUSH_MODES = {
FLUSH_MODE_ALL,
FLUSH_MODE_ONLY_BUFFER
}
local CR = string.byte('\r')
local LF = string.byte('\n')
local function read_fully(result, read_func)
local isTable = type(result) == "table"
local buf
repeat
buf = read_func(MAX_BUFFER_SIZE)
if isTable then
for i = 1, #buf do
result[#result + 1] = buf[i]
end
else result:append(buf) end
until #buf == 0
end
--[[
descriptor - descriptor of stream for provided I/O library
binaryMode - if enabled, most methods will expect bytes instead of strings
ioLib - I/O library. Should include the following functions:
read(descriptor: int, length: int) -> Bytearray
May return bytearray with a smaller size if bytes have not arrived yet or have run out
May throw error if descriptor isn't readable
write(descriptor: int, data: Bytearray)
May throw error if descriptor isn't writeable
[optional] seek(descriptor: int, mode: string, offset: int)
Mode may be 'b' (relative begin), 'c' (relative current), 'e' (relative end + 1)
[optional] tell(descriptor: int) -> int
[optional] flush(descriptor: int)
[optional] available(descriptor: int) -> int
is_alive(descriptor: int) -> bool
close(descriptor: int)
--]]
local MODES = { default = true, buffered = true, yield = true }
local FLUSH_MODES = { all = true, buffer = true }
function io_stream.new(descriptor, binary_mode, io_lib, mode, flush_mode)
mode = mode or DEFAULT_MODE
flush_mode = flush_mode or FLUSH_MODE_ALL
local self = setmetatable({}, io_stream)
self.descriptor = descriptor
self.binary_mode = binary_mode
self.max_buffer_size = MAX_BUFFER_SIZE
self.io_lib = io_lib
self:set_mode(mode)
self:set_flush_mode(flush_mode)
local self = setmetatable({
descriptor = descriptor,
io_lib = io_lib,
binary_mode = binary_mode and true or false,
max_buffer_size = buffered.DEFAULT_SIZE,
}, io_stream)
self:set_flush_mode(flush_mode or "all")
self:set_mode(mode or "default")
return self
end
function io_stream:is_binary_mode()
return self.binary_mode
function io_stream:_rebuild()
local old = self.stream
if old and old.flush_buffer and old:is_alive() then
old:flush_buffer()
end
local s = raw.new(self.descriptor, self.io_lib)
if self.mode == "buffered" then
s = buffered.new(s, self.max_buffer_size, self.flush_mode == "all")
elseif self.mode == "yield" then
s = blocking.new(s)
end
self.stream = s
self.text = text.new(s)
self.binary = binary.new(s)
end
function io_stream:set_binary_mode(binary_mode)
self.binary_mode = binary_mode ~= nil
function io_stream:_format()
return self.binary_mode and self.binary or self.text
end
function io_stream:get_mode()
return self.mode
end
function io_stream:is_binary_mode() return self.binary_mode end
function io_stream:set_binary_mode(v) self.binary_mode = v and true or false end
function io_stream:get_mode() return self.mode end
function io_stream:set_mode(mode)
if not table.has(ALL_MODES, mode) then
error("invalid stream mode: "..mode)
end
if self.write_buffer then
self.write_buffer:clear()
self.write_buffer = nil
end
if self.read_buffer then
self.read_buffer:clear()
self.read_buffer = nil
end
if mode == BUFFERED_MODE then
self.write_buffer = Bytearray(self.max_buffer_size)
self.read_buffer = Bytearray(self.max_buffer_size)
end
if not MODES[mode] then error("invalid stream mode: " .. tostring(mode)) end
self.mode = mode
self:_rebuild()
end
function io_stream:get_flush_mode()
return self.flush_mode
end
function io_stream:get_flush_mode() return self.flush_mode end
function io_stream:set_flush_mode(flush_mode)
if not table.has(ALL_FLUSH_MODES, flush_mode) then
error("invalid flush mode: " .. flush_mode)
if not FLUSH_MODES[flush_mode] then
error("invalid flush mode: " .. tostring(flush_mode))
end
self.flush_mode = flush_mode
if self.mode == "buffered" then
self.stream.flush_inner = flush_mode == "all"
end
end
function io_stream:get_max_buffer_size()
return self.max_buffer_size
function io_stream:get_max_buffer_size() return self.max_buffer_size end
function io_stream:set_max_buffer_size(size)
self.max_buffer_size = size
if self.mode == "buffered" then self:_rebuild() end
end
function io_stream:set_max_buffer_size(max_buffer_size)
self.max_buffer_size = max_buffer_size
function io_stream:read(arg, use_table) return self:_format():read(arg, use_table) end
self.write_buffer = Bytearray(self.max_buffer_size)
self.read_buffer = Bytearray(self.max_buffer_size)
end
function io_stream:write(arg, ...) return self:_format():write(arg, ...) end
function io_stream:read_fully(use_table) return self:_format():read_fully(use_table) end
function io_stream:read_line() return self.text:read_line() end
function io_stream:write_line(str) return self.text:write_line(str) end
function io_stream:available(length)
local available = self.io_lib.available and self.io_lib.available(self.descriptor) or 0
if self.mode == BUFFERED_MODE then
available = available + #self.read_buffer
end
if not length then
return available
else
return available >= length
end
local n = self.stream:available()
if length then return n >= length end
return n
end
function io_stream:__read(length, from_read_fully)
if self.mode == YIELD_MODE then
if from_read_fully then
return self.io_lib.read(self.descriptor, length)
end
function io_stream:seek(mode, offset) return self.stream:seek(mode, offset) end
local buffer = Bytearray()
function io_stream:tell() return self.stream:tell() end
while #buffer < length do
buffer:append(self.io_lib.read(self.descriptor, length - #buffer))
function io_stream:is_alive() return self.stream:is_alive() end
if #buffer < length then coroutine.yield() end
end
function io_stream:is_closed() return not self.stream:is_alive() end
return buffer
elseif self.mode == BUFFERED_MODE then
local buf_len = #self.read_buffer
if buf_len < length then
self.read_buffer:append(
self.io_lib.read(self.descriptor, self.max_buffer_size - buf_len)
)
end
buf_len = #self.read_buffer
length = math.min(buf_len, length)
local copy = self.read_buffer:slice(1, length)
if buf_len == length then
self.read_buffer:clear()
else
self.read_buffer:remove(1, length)
end
return copy
elseif self.mode == DEFAULT_MODE then
return self.io_lib.read(self.descriptor, length)
end
end
function io_stream:__write(data)
if self.mode == BUFFERED_MODE then
local data_length = #data
if #self.write_buffer + data_length > self.max_buffer_size then
self:flush()
end
if data_length > self.max_buffer_size then
local to_write = math.floor(data_length / self.max_buffer_size) * self.max_buffer_size
local to_save = data_length - to_write
self.io_lib.write(self.descriptor, data:slice(1, to_write))
self:flush()
self.write_buffer = data:slice(to_write + 1, to_save)
else self.write_buffer:append(data) end
elseif self.mode == DEFAULT_MODE or self.mode == YIELD_MODE then
return self.io_lib.write(self.descriptor, data)
end
end
function io_stream:read_fully(use_table)
if self.binary_mode then
local result = use_table and { } or Bytearray()
local avail = self:available()
if avail == 0 then
avail = self.max_buffer_size
end
read_fully(result, function() return self:__read(avail, true) end)
return result
else
if use_table then
local lines = { }
local line
repeat
line = self:read_line()
lines[#lines + 1] = line
until not line
return lines
else
local result = Bytearray()
read_fully(result, function() return self:__read(self.max_buffer_size) end)
return utf8.tostring(result)
end
end
end
function io_stream:read_line()
local result = Bytearray()
local first = true
while true do
local char = self:__read(1)
if #char == 0 then
if first then return else break end
end
char = char[1]
if char == LF then break
elseif char == CR then
char = self:__read(1)
if char[1] == LF then break
else
result:append(CR)
result:append(char[1])
end
else result:append(char) end
first = false
end
return utf8.tostring(result)
end
function io_stream:write_line(str)
self:__write(utf8.tobytes(str .. "\n"))
end
function io_stream:read(arg, use_table)
local arg_type = type(arg)
if self.binary_mode then
local byte_arr
if arg_type == "number" then
-- using 'arg' as length
byte_arr = self:__read(arg)
if use_table == true then
local t = { }
for i = 1, #byte_arr do
t[i] = byte_arr[i]
end
return t
else
return byte_arr
end
elseif arg_type == "string" then
return byteutil.unpack(
arg,
self:__read(byteutil.get_size(arg))
)
elseif arg_type == "nil" then
error(
"in binary mode the first argument must be a string data format"..
" for the library \"byteutil\" or the number of bytes to read"
)
else
error("unknown argument type: "..arg_type)
end
else
if not arg then
return self:read_line()
else
local lines_count = arg
local trim_last_empty_lines = use_table
if use_table == nil then
trim_last_empty_lines = true
end
if lines_count < 0 then error "count of lines to read must be positive" end
local result = { }
for i = 1, lines_count do
result[i] = self:read_line()
end
if trim_last_empty_lines then
local i = #result
while i >= 0 do
local length = utf8.length(result[i])
if length > 0 then break
else result[i] = nil end
i = i - 1
end
local i = 1
while #result > 0 do
local length = utf8.length(result[i])
if length > 0 then break
else table.remove(result, i) end
end
end
return result
end
end
end
function io_stream:write(arg, ...)
local arg_type = type(arg)
if self.binary_mode then
local byte_arr
if arg_type ~= "string" then
-- using arg as bytes table/bytearray
if arg_type == "table" then
byte_arr = Bytearray(arg)
else
byte_arr = arg
end
else
byte_arr = byteutil.pack(arg, ...)
end
self:__write(byte_arr)
else
if arg_type == "string" then
self:write_line(arg)
elseif arg_type == "table" then
for i = 1, #arg do
self:write_line(arg[i])
end
else error("unknown argument type: "..arg_type) end
end
end
function io_stream:seek(mode, offset)
if not self.io_lib.seek then
error("cannot seek this stream")
end
self.io_lib.seek(self.descriptor, mode, offset)
end
function io_stream:tell()
if not self.io_lib.tell then
error("cannot tell this stream")
end
return self.io_lib.tell(self.descriptor)
end
function io_stream:is_alive()
return self.io_lib.is_alive(self.descriptor)
end
function io_stream:is_closed()
return not self:is_alive()
end
function io_stream:close()
if self.mode == BUFFERED_MODE then
self.read_buffer:clear()
self.write_buffer:clear()
end
return self.io_lib.close(self.descriptor)
end
function io_stream:close() return self.stream:close() end
function io_stream:flush()
if self.mode == BUFFERED_MODE and #self.write_buffer > 0 then
self.io_lib.write(self.descriptor, self.write_buffer)
self.write_buffer:clear()
end
if self.flush_mode ~= FLUSH_MODE_ONLY_BUFFER then
if self.io_lib.flush then
self.io_lib.flush(self.descriptor)
elseif self:is_closed() then error("stream is closed") end
end
if self.mode ~= "buffered" and self.flush_mode == "buffer" then return end
self.stream:flush()
end
return io_stream
return io_stream

View file

@ -183,6 +183,12 @@ function on_deprecated_call(name, alternatives)
end
end
local __pack_envs = __vc__pack_envs
function __vc_internals.get_pack_env(packid)
return __pack_envs[packid]
end
__vc__pack_envs = nil
function reload_module(name)
local prefix, name = parse_path(name)
local path = prefix..":modules/"..name..".lua"
@ -196,6 +202,10 @@ function reload_module(name)
if script == nil then
error(err)
end
local env = __pack_envs[prefix]
if env then
script = setfenv(script, env)
end
local result = script()
if not result then
return
@ -270,12 +280,6 @@ function __vc_lock_internal_modules()
__internal_locked = true
end
local __pack_envs = __vc__pack_envs
function __vc_internals.get_pack_env(packid)
return __pack_envs[packid]
end
__vc__pack_envs = nil
function require(path)
if not string.find(path, ':') then
local prefix, _ = parse_path(_debug_getinfo(2).source)

17
run.sh
View file

@ -31,6 +31,17 @@ function norun {
}
function test {
echo "[RUN SCRIPT] Run tests"
cd build
rm -rf ./vctest-run
mkdir ./vctest-run
./vctest/vctest --exe ./VoxelCore --res res --user ./vctest-run --tests ../dev/tests --memchecker valgrind
cd ..
run=
}
function help {
echo "[RUN SCRIPT] Usage: ./run [ARGUMENT]..."
echo "[RUN SCRIPT] Arguments:"
@ -38,6 +49,7 @@ function help {
echo "[RUN SCRIPT] -b, --build Build project"
echo "[RUN SCRIPT] -r, --rebuild Rebuild project"
echo "[RUN SCRIPT] -R, --norun Build without run"
echo "[RUN SCRIPT] -t, --test Run tests (without run)"
echo "[RUN SCRIPT] -h, --help Print this page"
}
@ -48,6 +60,7 @@ while [ -n "$1" ]; do
-b | --build) build ;;
-r | --rebuild) rebuild ;;
-R | --norun) norun ;;
-t | --test) test ;;
-h | --help) help
norun
break ;;
@ -62,5 +75,5 @@ done
if [[ $run ]]; then
echo "[RUN SCRIPT] Run project"
./build/VoxelEngine
fi
./build/VoxelCore
fi

View file

@ -1,10 +1,10 @@
project(VoxelEngineSrc)
project(VoxelCoreSrc)
file(GLOB_RECURSE headers ${CMAKE_CURRENT_SOURCE_DIR}/*.hpp)
file(GLOB_RECURSE sources ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
list(REMOVE_ITEM sources ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp)
add_library(VoxelEngineSrc STATIC ${sources} ${headers})
add_library(VoxelCoreSrc STATIC ${sources} ${headers})
find_package(OpenGL REQUIRED)
find_package(GLEW REQUIRED)
@ -70,10 +70,10 @@ else()
add_library(luajit::luajit ALIAS PkgConfig::luajit)
endif()
target_include_directories(VoxelEngineSrc PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
target_include_directories(VoxelCoreSrc PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
target_link_libraries(
VoxelEngineSrc
VoxelCoreSrc
PRIVATE glfw
OpenGL::GL
GLEW::GLEW
@ -91,7 +91,7 @@ target_link_libraries(
)
target_compile_options(
VoxelEngineSrc
VoxelCoreSrc
PUBLIC $<$<CXX_COMPILER_ID:MSVC>:
/utf-8
/MP
@ -129,7 +129,7 @@ target_compile_options(
>)
target_link_options(
VoxelEngineSrc
VoxelCoreSrc
PUBLIC
$<$<CXX_COMPILER_ID:GNU>:
-no-pie

View file

@ -6,7 +6,7 @@
#include <string>
inline constexpr int ENGINE_VERSION_MAJOR = 0;
inline constexpr int ENGINE_VERSION_MINOR = 32;
inline constexpr int ENGINE_VERSION_MINOR = 33;
#ifdef NDEBUG
inline constexpr bool ENGINE_DEBUG_BUILD = false;
@ -14,7 +14,7 @@ inline constexpr bool ENGINE_DEBUG_BUILD = false;
inline constexpr bool ENGINE_DEBUG_BUILD = true;
#endif // NDEBUG
inline const std::string ENGINE_VERSION_STRING = "0.32";
inline const std::string ENGINE_VERSION_STRING = "0.33";
inline constexpr uint MAX_SUBPROCESSES = 1;
inline constexpr uint MAX_SUBPROCESS_DEPTH = 2;

View file

@ -8,7 +8,7 @@ using runnable = std::function<void()>;
template<class T> using supplier = std::function<T()>;
template<class T> using consumer = std::function<void(T)>;
using KeyCallback = std::function<bool()>;
using InputCallback = std::function<bool()>;
// data sources
using wstringsupplier = std::function<std::wstring()>;

View file

@ -28,7 +28,10 @@ MenuScreen::~MenuScreen() = default;
void MenuScreen::onOpen() {
engine.getContentControl().resetContent({});
auto menu = engine.getGUI().getMenu();
auto& gui = engine.getGUI();
gui.setActiveFrame(gui::GUI::CORE_MAIN);
auto menu = gui.getMenu();
menu->reset();
}

View file

@ -113,8 +113,6 @@ static inline auto shader_deleter = [](GLuint* shader) {
delete shader;
};
inline const uint GL_LOG_LEN = 512;
// shader should be deleted after shader program linking
using glshader = std::unique_ptr<GLuint, decltype(shader_deleter)>;
@ -125,12 +123,14 @@ glshader compile_shader(GLenum type, const GLchar* source, const std::string& fi
glCompileShader(shader);
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
if (!success) {
GLchar infoLog[GL_LOG_LEN];
glGetShaderInfoLog(shader, GL_LOG_LEN, nullptr, infoLog);
GLint infoLogLength;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength);
auto infoLog = std::make_unique<GLchar[]>(infoLogLength);
glGetShaderInfoLog(shader, infoLogLength, nullptr, infoLog.get());
glDeleteShader(shader);
throw std::runtime_error(
"vertex shader compilation failed (" + file + "):\n" +
std::string(infoLog)
std::string(infoLog.get(), infoLogLength)
);
}
return glshader(new GLuint(shader), shader_deleter); //-V508
@ -172,10 +172,14 @@ static GLuint compile_program(
glGetProgramiv(program, GL_LINK_STATUS, &success);
if (!success) {
GLchar infoLog[GL_LOG_LEN];
glGetProgramInfoLog(program, GL_LOG_LEN, nullptr, infoLog);
GLint infoLogLength;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength);
auto infoLog = std::make_unique<GLchar[]>(infoLogLength);
glGetProgramInfoLog(program, infoLogLength, nullptr, infoLog.get());
glDeleteProgram(program);
throw std::runtime_error(
"shader program linking failed:\n" + std::string(infoLog)
"shader program linking failed:\n" +
std::string(infoLog.get(), infoLogLength)
);
}
return program;

View file

@ -22,7 +22,7 @@ static debug::Logger logger("chunks-render");
size_t ChunksRenderer::visibleChunks = 0;
static constexpr inline size_t MAX_CHUNKS_ENQUEUED_IN_FRAME = 4;
static constexpr inline size_t MAX_CHUNKS_ENQUEUED_IN_FRAME = 64;
class RendererWorker : public util::Worker<RendererJob, RendererResult> {
BlocksRenderer renderer;
@ -197,8 +197,7 @@ void ChunksRenderer::update() {
int loadDistance = settings.chunks.loadDistance.get();
const int topN = 10;
int top = std::min<int>(meshBuildQueue.size(), topN);
int top = std::min<int>(meshBuildQueue.size(), MAX_CHUNKS_ENQUEUED_IN_FRAME);
for (int i = 0; i < top; i++) {
glm::ivec2 offset = meshBuildQueue[i];
size_t index =

View file

@ -35,8 +35,15 @@ void InlineFrame::setDocument(const std::shared_ptr<UiDocument>& document) {
root->setSize(size);
gui.postRunnable([this]() {
scripting::on_ui_open(*this->document, {});
gui.postRunnable([weak = weak_from_this(), document]() {
auto node = weak.lock();
if (node == nullptr) {
return;
}
if (static_cast<InlineFrame&>(*node).document != document) {
return;
}
scripting::on_ui_open(*document, {});
});
}

View file

@ -14,8 +14,13 @@ std::filesystem::path io::MemoryDevice::resolve(std::string_view path) {
std::unique_ptr<std::ostream> io::MemoryDevice::write(std::string_view path) {
std::string filePath = std::string(path);
auto memoryStream = std::make_unique<memory_ostream>();
memoryStream->set_sync_callback([this, filePath](std::string_view data) {
createFile(std::move(filePath), util::Buffer<char>(data.data(), data.size()));
});
return std::make_unique<finalizing_ostream>(
std::make_unique<memory_ostream>(),
std::move(memoryStream),
[this, filePath](auto ostream) {
auto& memoryStream = dynamic_cast<memory_ostream&>(*ostream);
createFile(std::move(filePath), memoryStream.release());
@ -180,6 +185,10 @@ std::unique_ptr<io::PathsGenerator> io::MemoryDevice::list(std::string_view path
}
io::MemoryDevice::Dir* io::MemoryDevice::createDir(std::string path) {
const auto& found = nodes.find(path);
if (found != nodes.end()) {
return found->second.get_if<Dir>();
}
io::path filePath = path;
io::path parent = filePath.parent();
auto parentDir = getDir(parent.string());
@ -195,6 +204,15 @@ io::MemoryDevice::Dir* io::MemoryDevice::createDir(std::string path) {
io::MemoryDevice::Node* io::MemoryDevice::createFile(
std::string path, util::Buffer<char>&& content
) {
const auto& found = nodes.find(path);
if (found != nodes.end()) {
auto& node = found->second;
if (!node.holds_alternative<File>()) {
return nullptr;
}
node.data = File {std::move(content)};
return &node;
}
io::path filePath = path;
io::path parent = filePath.parent();
auto dir = getDir(parent.string());

View file

@ -58,11 +58,20 @@ namespace {
}
uint32_t to_ms_dos_timestamp(const file_time_type& fileTime) {
// 1980-01-01 00:00, the earliest MS-DOS date
constexpr uint32_t DOS_EPOCH = (0 << 9 | 1 << 5 | 1) << 16;
if (fileTime == file_time_type::min()) {
return DOS_EPOCH;
}
auto timePoint = time_point_cast<system_clock::duration>(
fileTime - file_time_type::clock::now() + system_clock::now()
);
std::time_t timeT = system_clock::to_time_t(timePoint);
std::tm tm = *std::localtime(&timeT);
const std::tm* tmPtr = std::localtime(&timeT);
if (tmPtr == nullptr || tmPtr->tm_year < 80) {
return DOS_EPOCH;
}
const std::tm& tm = *tmPtr;
uint16_t date = (tm.tm_year - 80) << 9 | (tm.tm_mon + 1) << 5 | tm.tm_mday;
uint16_t time = (tm.tm_hour << 11) | (tm.tm_min << 5) | (tm.tm_sec / 2);
return (date << 16) | time;
@ -173,7 +182,12 @@ ZipFileDevice::ZipFileDevice(
entries[entry.fileName] = std::move(entry);
}
for (auto& [name, _] : entries) {
std::vector<std::string> names;
names.reserve(entries.size());
for (const auto& [name, _] : entries) {
names.push_back(name);
}
for (const auto& name : names) {
io::path path = name;
while (!(path = path.parent()).pathPart().empty()) {
@ -184,7 +198,6 @@ ZipFileDevice::ZipFileDevice(
entry.isDirectory = true;
entries[path.pathPart()] = entry;
}
break;
}
for (auto& [_, entry] : entries) {
@ -253,6 +266,9 @@ file_time_type ZipFileDevice::lastWriteTime(std::string_view path) {
}
bool ZipFileDevice::exists(std::string_view path) {
if (path.empty()) {
return true;
}
return entries.find(std::string(path)) != entries.end();
}
@ -441,7 +457,11 @@ static size_t write_zip(
void io::write_zip(const path& folder, const path& file) {
ByteBuilder central_dir;
auto out = io::write(file);
size_t entries = write_zip(folder.pathPart(), folder, *out, central_dir);
auto root = folder.pathPart();
if (!root.empty() && root.back() != '/') {
root += '/';
}
size_t entries = write_zip(root, folder, *out, central_dir);
size_t central_dir_offset = out->tellp();
out->write(reinterpret_cast<const char*>(central_dir.data()), central_dir.size());

View file

@ -3,6 +3,9 @@
#include <iostream>
#include <streambuf>
#include <cstring>
#include <climits>
#include <memory>
#include <functional>
#include <algorithm>
#include <string_view>
@ -13,81 +16,111 @@ public:
explicit memory_buffer(size_t initial_size = 64)
: buffer(std::make_unique<char[]>(initial_size)),
capacity(initial_size) {
setp(buffer.get(), buffer.get() + initial_size);
setp(buffer.get(), buffer.get() + capacity);
}
std::string_view view() const {
return std::string_view(pbase(), pptr() - pbase());
return std::string_view(pbase(), size());
}
util::Buffer<char> release() {
return {std::move(buffer), size()};
size_t n = size();
return {std::move(buffer), n};
}
size_t size() const {
return pptr() - pbase();
return std::max(length, position());
}
void set_sync_callback(std::function<void(std::string_view)> callback) {
on_sync = std::move(callback);
}
protected:
int_type overflow(int_type c) override {
if (c == traits_type::eof())
return traits_type::eof();
const size_t data_size = pptr() - pbase();
const size_t new_capacity = std::max(capacity * 2, data_size + 1);
auto new_buffer = std::make_unique<char[]>(new_capacity);
std::memcpy(new_buffer.get(), pbase(), data_size);
buffer = std::move(new_buffer);
capacity = new_capacity;
setp(buffer.get(), buffer.get() + new_capacity);
pbump(data_size);
reserve(position() + 1);
*pptr() = traits_type::to_char_type(c);
pbump(1);
return c;
}
std::streamsize xsputn(const char* s, std::streamsize count) override {
const std::streamsize avail = epptr() - pptr();
pos_type seekoff(
off_type off,
std::ios_base::seekdir dir,
std::ios_base::openmode which
) override {
if (!(which & std::ios_base::out)) {
return pos_type(off_type(-1));
}
length = size();
if (avail >= count) {
std::memcpy(pptr(), s, count);
pbump(count);
return count;
off_type base;
switch (dir) {
case std::ios_base::beg: base = 0; break;
case std::ios_base::cur: base = position(); break;
case std::ios_base::end: base = length; break;
default: return pos_type(off_type(-1));
}
std::streamsize written = 0;
if (avail > 0) {
std::memcpy(pptr(), s, avail);
written += avail;
s += avail;
count -= avail;
pbump(avail);
off_type target = base + off;
if (target < 0 || target > static_cast<off_type>(length)) {
return pos_type(off_type(-1));
}
set_position(target);
return pos_type(target);
}
const size_t data_size = pptr() - pbase();
const size_t required_capacity = data_size + count;
const size_t new_capacity = std::max(capacity * 2, required_capacity);
auto new_buffer = std::make_unique<char[]>(new_capacity);
std::memcpy(new_buffer.get(), pbase(), data_size);
std::memcpy(new_buffer.get() + data_size, s, count);
buffer = std::move(new_buffer);
capacity = new_capacity;
setp(buffer.get(), buffer.get() + new_capacity);
pbump(data_size + count);
written += count;
return written;
pos_type seekpos(pos_type pos, std::ios_base::openmode which) override {
return seekoff(off_type(pos), std::ios_base::beg, which);
}
private:
std::unique_ptr<char[]> buffer;
size_t capacity;
size_t length = 0;
size_t position() const {
return pptr() - pbase();
}
void advance(size_t n) {
while (n > 0) {
int step = static_cast<int>(std::min<size_t>(n, INT_MAX));
pbump(step);
n -= step;
}
}
void set_position(size_t pos) {
setp(buffer.get(), buffer.get() + capacity);
advance(pos);
}
void reserve(size_t required) {
if (required <= capacity) {
return;
}
size_t pos = position();
length = size();
size_t new_capacity = std::max(capacity * 2, required);
auto new_buffer = std::make_unique<char[]>(new_capacity);
std::memcpy(new_buffer.get(), buffer.get(), length);
buffer = std::move(new_buffer);
capacity = new_capacity;
set_position(pos);
}
int sync() override {
if (on_sync) {
on_sync(view());
}
return 0;
}
std::function<void(std::string_view)> on_sync;
};
class memory_ostream : public std::ostream {
@ -102,6 +135,10 @@ public:
util::Buffer<char> release() {
return buffer.release();
}
void set_sync_callback(std::function<void(std::string_view)> callback) {
buffer.set_sync_callback(std::move(callback));
}
private:
memory_buffer buffer;
};

View file

@ -305,13 +305,14 @@ static int l_read_descriptor(lua::State* L) {
int maxlen = lua::tointeger(L, 2);
auto& stream = io_descriptors::require_input(descriptor);
if (stream.eof()) {
stream.clear();
}
util::Buffer<char> buffer(maxlen);
stream.read(buffer.data(), maxlen);
std::streamsize read_len = stream.gcount();
std::streamsize read_len = stream.gcount();
if (stream.eof()) {
stream.clear(stream.rdstate() & std::ios::badbit);
}
return lua::create_bytearray(L, buffer.data(), read_len);
}

View file

@ -44,10 +44,13 @@ static int l_add_callback(lua::State* L) {
auto& input = engine->getInput();
if (pos != std::string::npos) {
std::string prefix = bindname.substr(0, pos);
auto prefix = std::string_view(bindname).substr(0, pos);
if (prefix == "key") {
auto key = input_util::keycode_from(bindname.substr(pos + 1));
handler = input.addKeyCallback(key, actual_callback);
} else if (prefix == "mouse") {
auto mouse = input_util::mousecode_from(bindname.substr(pos + 1));
handler = input.addMouseCallback(mouse, actual_callback);
}
}

View file

@ -263,7 +263,7 @@ runnable lua::create_runnable(State* L) {
};
}
KeyCallback lua::create_simple_handler(State* L) {
InputCallback lua::create_simple_handler(State* L) {
auto funcptr = create_lambda_handler(L);
return [=]() -> bool {
if (!get_from_registry(L, LAMBDAS_TABLE, *funcptr, false)) {

View file

@ -665,7 +665,7 @@ namespace lua {
}
runnable create_runnable(lua::State*);
KeyCallback create_simple_handler(lua::State*);
InputCallback create_simple_handler(lua::State*);
scripting::common_func create_lambda(lua::State*);
scripting::common_func create_lambda_nothrow(lua::State*);

View file

@ -99,14 +99,21 @@ template <typename T, T(tovalueFunc)(lua::State*, int)>
std::function<T()> create_supplier(
const scriptenv& env, const std::string& src, const std::string& file
) {
return [=]() {
return [=, errorLogged = false]() mutable {
lua::stackguard guard(lua::get_main_state());
if (auto L = process_callback(env, src, file)) {
if (lua::isfunction(L, -1)) {
lua::call_nothrow(L, 0);
if (lua::isfunction(L, -1) && !lua::call_nothrow(L, 0)) {
return T {};
}
try {
return tovalueFunc(L, -1);
} catch (const std::exception& err) {
if (!errorLogged) {
logger.error() << "supplier " << util::quote(src) << ": "
<< err.what();
errorLogged = true;
}
}
auto str = tovalueFunc(L, -1);
lua::pop(L);
return str;
}
return T {};
};
@ -158,16 +165,33 @@ int_array_consumer scripting::create_int_array_consumer(
vec2supplier scripting::create_vec2_supplier(
const scriptenv& env, const std::string& src, const std::string& file
) {
return [=]() {
if (auto L = process_callback(env, src, file)) {
if (lua::isfunction(L, -1)) {
lua::call_nothrow(L, 0);
return [=, errorLogged = false]() mutable {
auto L = lua::get_main_state();
lua::stackguard guard(L);
int top = lua::gettop(L);
if (process_callback(env, src, file)) {
if (lua::isfunction(L, -1) && !lua::call_nothrow(L, 0)) {
return glm::vec2(0, 0);
}
if (lua::gettop(L) - top < 2) {
if (!errorLogged) {
logger.error() << "supplier " << util::quote(src)
<< ": two numbers expected";
errorLogged = true;
}
return glm::vec2(0, 0);
}
try {
auto y = lua::tonumber(L, -1);
auto x = lua::tonumber(L, -2);
return glm::vec2(x, y);
} catch (const std::exception& err) {
if (!errorLogged) {
logger.error() << "supplier " << util::quote(src) << ": "
<< err.what();
errorLogged = true;
}
}
auto y = lua::tonumber(L, -1);
lua::pop(L);
auto x = lua::tonumber(L, -1);
lua::pop(L);
return glm::vec2(x, y);
}
return glm::vec2(0, 0);
};

View file

@ -328,14 +328,17 @@ void Entities::preparePhysics(float delta) {
auto view = registry->view<EntityId, Rigidbody>();
for (auto [entity, eid, rigidbody] : view.each()) {
auto bodyType = rigidbody.hitbox.type;
if (eid.destroyFlag || !rigidbody.enabled || bodyType == BodyType::STATIC) {
if (eid.destroyFlag || !rigidbody.enabled) {
continue;
}
rigidbody.hitbox.selectable = rigidbody.selectable;
rigidbody.hitbox.mass = bodyType == BodyType::DYNAMIC
? rigidbody.mass
: std::numeric_limits<float>::infinity();
rigidbody.hitbox.elasticity = rigidbody.elasticity;
rigidbody.hitbox.selectable = rigidbody.selectable;
if (bodyType == BodyType::STATIC) {
continue;
}
hitboxes.emplace_back(&rigidbody.hitbox);
if (!eid.def.solid) {
continue;
@ -477,15 +480,17 @@ void Entities::render(
const Frustum* frustum,
entityid_t fpsEntity
) {
auto view = registry->view<EntityId, Transform, rigging::Skeleton>();
for (auto [entity, eid, transform, skeleton] : view.each()) {
auto view = registry->view<EntityId, Transform, rigging::Skeleton, Rigidbody>();
for (auto [entity, eid, transform, skeleton, rigidbody] : view.each()) {
if (eid.uid == fpsEntity) {
continue;
}
const auto& def = eid.def;
const auto& pos = transform.pos;
const auto& size = transform.size;
if (frustum && !frustum->isBoxVisible(pos - size, pos + size)) {
const auto& halfSize = rigidbody.hitbox.getHalfSize();
// todo: more correct frustum culling
if (frustum && !frustum->isBoxVisible(pos - halfSize, pos + halfSize)) {
continue;
}

View file

@ -216,10 +216,17 @@ public:
return bindings;
}
ObserverHandler addKeyCallback(Keycode key, KeyCallback callback) override {
ObserverHandler addKeyCallback(Keycode key, InputCallback callback) override {
return keyCallbacks[key].add(std::move(callback));
}
ObserverHandler addMouseCallback(Mousecode button, InputCallback callback) override {
return addKeyCallback(
static_cast<Keycode>(MOUSE_KEYS_OFFSET + static_cast<int>(button)),
std::move(callback)
);
}
const std::vector<Keycode>& getPressedKeys() const override {
return pressedKeys;
}

View file

@ -288,12 +288,13 @@ public:
virtual const Bindings& getBindings() const = 0;
virtual ObserverHandler addKeyCallback(Keycode key, KeyCallback callback) = 0;
virtual ObserverHandler addKeyCallback(Keycode key, InputCallback callback) = 0;
virtual ObserverHandler addMouseCallback(Mousecode button, InputCallback callback) = 0;
virtual const std::vector<Keycode>& getPressedKeys() const = 0;
virtual const std::vector<uint>& getCodepoints() const = 0;
ObserverHandler addCallback(const std::string& name, KeyCallback callback) {
ObserverHandler addCallback(const std::string& name, InputCallback callback) {
return getBindings().require(name).onactived.add(callback);
}
};

View file

@ -1,22 +1,22 @@
project(VoxelEngineTest)
project(VoxelCoreTest)
file(GLOB_RECURSE sources ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
find_package(GTest)
add_executable(VoxelEngineTest ${sources})
add_executable(VoxelCoreTest ${sources})
target_link_libraries(VoxelEngineTest PRIVATE VoxelEngineSrc GTest::gtest_main)
target_link_libraries(VoxelCoreTest PRIVATE VoxelCoreSrc GTest::gtest_main)
# HACK: copy res to test/ folder for fixing problem compatibility MultiConfig
# and non MultiConfig builds. Delete in future and use only root res folder Also
# this resolve problem with ctests, because it set cwd to
# ${CMAKE_CURRENT_BINARY_DIR}
add_custom_command(
TARGET VoxelEngineTest
TARGET VoxelCoreTest
POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different
${CMAKE_SOURCE_DIR}/res ${CMAKE_CURRENT_BINARY_DIR}/res)
include(GoogleTest)
gtest_discover_tests(VoxelEngineTest)
gtest_discover_tests(VoxelCoreTest)

View file

@ -0,0 +1,22 @@
#include <gtest/gtest.h>
#include "io/memory_ostream.hpp"
TEST(io, memory_ostream) {
const char data[] = "Hello, world!";
const int n = std::strlen(data);
memory_ostream stream;
ASSERT_TRUE(stream.good());
stream.write(data, n);
ASSERT_EQ(std::string(stream.view()), std::string(data));
stream.seekp(0);
ASSERT_TRUE(stream.good());
stream.write("Remove", 6);
ASSERT_EQ(std::string(stream.view()), "Remove world!");
auto buffer = stream.release();
ASSERT_EQ(std::string(buffer.data(), buffer.size()), "Remove world!");
}

View file

@ -8,7 +8,7 @@ TEST(curltest, curltest) {
auto network = network::Network::create(settings);
network::HttpRequest request {};
request.url = "https://raw.githubusercontent.com/MihailRis/VoxelEngine-Cpp/refs/"
request.url = "https://raw.githubusercontent.com/MihailRis/voxelcore/refs/"
"heads/curl/res/content/base/blocks/lamp.json";
request.onResponse = [](network::HttpResponse response) {
if (response.body.empty()) {