mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-10 20:07:37 +00:00
Brues
4509da0966
Each embedded file was its own gzipped RCDATA resource, 175 in all.
Every stream started with an empty deflate window, so no file could
match text it shares with its neighbours, and 97 of the files are under
4 KB, where that costs the most. Each resource also cost about 50 bytes
of resource directory and padding.
cmake/pack_files.cmake, which replaces gzip_file.cmake, now joins each
addon's files at build time into one gzip stream. It holds an index,
each file's size as a decimal line and then an empty line, followed by
the files' bytes in path order. `cmake -E cat` joins them byte for
byte, in batches of 100 so the Windows command-line limit cannot fail
the build. The index goes through file(CONFIGURE NEWLINE_STYLE UNIX)
because file(WRITE) writes \r\n on Windows. The resources are now three:
Bindings.xml as a pack of one, !!!ClassicAPI, and ClassicAPI_DebugTools.
The manifest entries become {path, resourceId, index}, and
Embed::Resource(id) becomes Embed::File(id, index). On first use it
inflates the whole pack with the engine's zlib, splits it into views,
and keeps it for the life of the DLL, as before. A pack whose sizes do
not cover its bytes exactly is rejected. The load-on-demand DebugTools
pack is still inflated only when it loads.
Embedded data 323,947 -> 272,825 bytes; .rsrc 334,336 -> 274,432;
DLL 1,632,768 -> 1,573,888 bytes.
51 lines
1.8 KiB
CMake
51 lines
1.8 KiB
CMake
# pack_files.cmake — join files into one gzipped pack at build time, for
|
|
# embed_resources.cmake.
|
|
#
|
|
# cmake -DLIST=<list.cmake> -DOUT=<pack.gz> -P pack_files.cmake
|
|
#
|
|
# LIST sets FILES to the paths to join, in order. The pack is one gzip
|
|
# stream, so each file compresses against the files before it: the addon
|
|
# text packs about 16% smaller than when each file is gzipped alone. Inside
|
|
# the stream is an index, each file's size as a decimal line and then an
|
|
# empty line, followed by the files' bytes in FILES order. The DLL splits
|
|
# it in src/embed/Resource.cpp.
|
|
|
|
include("${LIST}")
|
|
|
|
set(index "")
|
|
foreach(file IN LISTS FILES)
|
|
file(SIZE "${file}" size)
|
|
string(APPEND index "${size}\n")
|
|
endforeach()
|
|
# Not file(WRITE): on Windows it writes each \n as \r\n.
|
|
file(CONFIGURE OUTPUT "${OUT}.index" CONTENT "${index}\n" @ONLY NEWLINE_STYLE UNIX)
|
|
|
|
# Join `ARGN` byte for byte into `out`.
|
|
function(cat out)
|
|
execute_process(COMMAND "${CMAKE_COMMAND}" -E cat ${ARGN}
|
|
OUTPUT_FILE "${out}" RESULT_VARIABLE rc)
|
|
if(NOT rc EQUAL 0)
|
|
message(FATAL_ERROR "pack_files.cmake: cannot join into ${out}: ${rc}")
|
|
endif()
|
|
endfunction()
|
|
|
|
# `cmake -E cat` takes its files on the command line, which Windows limits
|
|
# to 32767 characters: join in batches of 100, then join the batches.
|
|
set(parts "${OUT}.index")
|
|
list(LENGTH FILES count)
|
|
set(first 0)
|
|
while(first LESS count)
|
|
list(SUBLIST FILES ${first} 100 batch)
|
|
set(part "${OUT}.part${first}")
|
|
cat("${part}" ${batch})
|
|
list(APPEND parts "${part}")
|
|
math(EXPR first "${first} + 100")
|
|
endwhile()
|
|
cat("${OUT}.raw" ${parts})
|
|
|
|
# The raw format holds the one file's bytes with no archive entry around
|
|
# them, so OUT is a plain gzip stream.
|
|
file(ARCHIVE_CREATE OUTPUT "${OUT}" PATHS "${OUT}.raw" FORMAT raw
|
|
COMPRESSION GZip COMPRESSION_LEVEL 9)
|
|
file(REMOVE ${parts} "${OUT}.raw")
|