WIP changelog since the fork

[sprunk]

NOTE 1: this changelog has been written on the fly so some entries might be obsoleted later

NOTE 2: the running changelog since the last version is at https://beyond-all-reason.github.io/spring/changelogs/running-changelog

In general, changelogs are now available at https://beyond-all-reason.github.io/spring/changelogs

WIP changelog for BAR105 branch

== Misc ==

• building the engine now requires GCC 7.0
• add /endGraph 2 to bring the player back to the menu (1 still quits)
• keybinds: same action with different arguments now differentiated
• math.random() now correctly accepts arguments when parsing defs
• command cache increased 1024 → 2048 (FIXME: why? does BAR reach this? sanely designed commands shouldn't!)
• wupget:GameProgress interval 10 → 5 seconds
• basecontent now provides the treetype0 to treetype15 features with a model and some customparams
• spring-dedicated now correctly shows output on Windows when not redirected (spring-headless already worked correctly)
• added a Load Game button to the raw spring.exe menu
• fix height bounds calculation, it now reflects the actual heights rather than the historical min/max (for example if the highest point went 100 -> 90 -> 110 -> 100, previously Spring.GetGroundExtremes would return 100 -> 100 -> 110 -> 110)
• enabling globallos reveals unseen terrain changes
• buildings can be placed inside other buildings' open yardmap gaps
• fix a crash when trying to add enemy units to a control group (e.g. selected via /godmode)
• allow nil as the first arg to Spring.SetCameraState
• Spring.{Add,Get,Remove}Grass now works even if grass rendering is disabled (also fixes desync)
• Spring.AddGrass now has a 3rd param, grass intensity (returned by Get; putting 0 equivalent to using Remove)
• native AI interface: add Feature_getResurrectDef and Feature_getBuildingFacing
• native AI interface: add spherical param to Get{Friendly,Enemy,Neutral,}{Units,Features}{In,}
• Spring.SetWMIcon new 2nd arg, bool force: ignores the 32x32 icon restriction on Windows
• allow empty argument for Spring.GetKeyBindings to return all keybindings
• fix a desync caused by locale-dependent string sorting (in some languages the order is ABab, in others AaBb)
• fix a crash trying to load a save done on a map with LuaGaia when currently playing on a map without it (LuaGaia shared C functions with LuaRules and they took precedence when saving due to alphabetical sorting)
• fix resources sometimes getting into the negative (on the order of 1e-15) due to float inaccuracies; in particular this caused units that cost 0 resources to shoot to be unable to fire due to insufficient resources
• Spring.SpawnExplosion works inside Projectile{Created,Destroyed} and no longer crashes on some valid data
• fix "zombie torpedoes" bouncing under the map
• seaplanes can now be built on water if either they can submerge or float (previously floating blocked buildability)
• add Spring.{Set,Get}UnitBuildParams(unitID, "buildDistance"/"buildRange3D", valueToSet) about unit build range (number) and whether it's spherical (bool)
• add /setSpeed x to set game speed directly, still obeys min/max
• allow shallow recursion (up to 16) for: CreateUnit/DestroyUnit/CreateFeature/DestroyFeature/GiveOrder

== TKPFS ==

• new pathfinder, TKPFS (id 0) - set as default in engine (HAPFS, the original, is now id 2)
• uses the same HA* algorithm as the original pathfinder, but multi-threads pathing requests
• to make multi-threading possible, any request made to units to path are recorded and defered to a later point in the same sim frame: a single point in the sim frame processes all the required path requests in that given sim frame.
• in addition, pathing vertex cost recalculations that occur when the terrain changes (terraform, explosions and so on) are also multi-threaded
• however, direct calls for path solutions using Lua or AI APIs are not multi-threaded. These APIs calls are expected to return a pathing solution and thus have to resolve the request as part of the call.

== Radar icons stuff ==

• new springsetting UnitIconsAsUI and an ingame /iconsAsUI command (all below have a /command variant without the "Unit"). Set to 1 to make radar icons behave like UI elements instead of in-world objects (e.g. no obscuring by terrain, distance fog, blurring or reflection in the water etc. FIXME: some other important effects? different relationships with DrawFoo lua callins?)
• new springsetting UnitIconScaleUI. Scaling for the above
• new springsetting UnitIconsHideWithUI. Whether icons get hidden via F5.
• new springsettings UnitIconFadeStart and UnitIconFadeVanish, for making icons fade smoothly (FIXME: how does this interact with /disticon? override, both apply independently?)

== GL Texture Atlases ==

• add gl.CreateTextureAtlas(number x, number y, number? allocType, string? atlasName) -> string texName.
  x and y have to be between 256 and the value of the (FIXME: new?) springsetting MaxTextureAtlasSizeX (Y respectively).
  allocType is a number between 0 and (FIXME), defaults to 0 if not specified, the meanings are (FIXME).
  atlasName is an optional name for the atlas, defaults to (FIXME).
• add gl.FinalizeTextureAtlas(string id) -> bool success. FIXME: is this ID the same as texName above? the atlasName? different?
• add gl.DeleteTextureAtlas(string id) -> bool success.
• add gl.AddAtlasTexture(string id, string luaTex, string? subAtlasTexName). Adds texture luaTexStr to sub-atlas subAtlasTextureName (defaulting to same name as luaTex if not specified) of atlas id. (FIXME: describe sub-atlases) The lua tex has to be a regular 2D RGBA/UNORM texture. DDS textures can also be put into the atlas.
• add gl.GetAtlasTexture(string texName, string luaTex) -> (number s, number p, number t, number q). Query an atlas texture for the UV coordinates (minU, maxU, minV, maxV) of a texture saved with AddAtlasTexture

== Particles ==

• CEGs from allied projectiles now visible in the fog
• add /softParticles toggle and SoftParticles springsetting to make particles (esp. groundflashes) clipping into the ground fade a bit instead of having a jagged edge
• add Spring.SetNanoProjectileParams(r, v, a, randR, randV, randA). All params are numbers, and default to 0 when not given. The first three are starting rotation in deg, rotation speed in deg/s, and rotation acceleration in des/s^2. The other three are the same but multiplied with a random (-1; +1) before being added to the former (rolled once per particle at the start of its lifetime) and the appopriate Get (FIXME: theres rotation but no speed? that's the more important part)
• add /drawOrderParticles command which makes particles obey draw order, supplied in CEG definition under the drawOrder key
• add rotParams key to CSimpleParticleSystem and CBitmapMuzzleFlame CEGs, a vector of 3 floats: rotation speed, rotation acceleration, starting rotation, in degrees per second ^1/^2/^0 respectively (FIXME: looks like american timestamps, why isn't it start/speed/accel or accel/speed/start? the starting value probably doesnt matter so it makes sense though)
• weapons: add bool smokeTrailCastShadow, number smokePeriod (default 8), number smokeTime (default 60), number smokeSize (default 7), and number smokeColor (default 0.7, single value for all three RGB channels tint) to things with smoke trails (FIXME: just missile and starburst? do torpedoes count for bubble trails?)
• weapons: add bool castShadow, for the projectile itself (FIXME: only missiles too? does it work with say cannons that use a model?)

== shaders, VAO, GL4 and other advanced graphics stuff ==

• add gl.GetVAO which returns an object with a bunch of methods (FIXME: link to some wiki with a list and descriptions, ideally also examples)
• add gl.GetVBO (FIXME: ditto)
• add Spring.GetSelectedUnitsCount to the shader container (use case: F2 pathmap replacement)
• add Platform.glHave{AMD,NVidia,Intel,GLSL,GL4} bools
• remove Platform.glSupport24bitDepthBuffer and add Platform.glSupportDepthBufferBitDepth instead (FIXME: any neat usage examples, probably from some bar widget?)
• add gl.{Unit,Feature}{,Shape}GL4 temporary functions
• added a ton of uniforms for shaders (FIXME: I'm not competent enough to say much about this, probably should at least be listed, this is the most major change actually!!)
• add the following constants to GL: LINE_STRIP_ADJACENCY, LINES_ADJACENCY, TRIANGLE_STRIP_ADJACENCY, TRIANGLES_ADJACENCY, PATCHES (FIXME: for VAO?)
• add the following constants to GL: [UNSINGED_]BYTE, [UNSINGED_]SHORT, [UNSINGED_]INT[_VEC4], FLOAT[_VEC4], FLOAT_MAT4
• add the following constants to GL: ELEMENT_ARRAY_BUFFER, ARRAY_BUFFER, UNIFORM_BUFFER, SHADER_STORAGE_BUFFER
• add the following constants to GL: READ_ONLY, WRITE_ONLY, READ_WRITE
• add a fuckton of image type specifiers (RGBA32 etc) to GL (FIXME: wiki link probably? also for the above too i guess)
• add a fuckton of barrier bit constants to GL (FIXME: ditto)

== general rendering-adjacent stuff ==

• fix sky reflections on the ground (skyReflectModTex)
• smoother area-command circle, vertices 20 → 100
• add Spring.{Set,Get}{Unit,Feature}AlwaysUpdateMatrix which makes the unit "always update matrix" (FIXME: what does that mean, what matrix? when to use this?)
• add /reloadTextures [lua, smf, s3o, ceg] to reload textures, all groups if none specified. (FIXME: any groups not contained here?)
• filling the nano wireframe works on the current model heights (meaning units with pieces hidden high above but moved downward work correctly)
• add gl.GetFixedState that returns a shitton of various GL constants and tables (FIXME: it does a lot, document here? probably link to wiki. maybe returning 5-element tables is also bad and should be done on the stack?)
• DeprecatedGLWarnLevel springsetting default value 2 → 0 (to reduce spam)
• add gl.AlphaToCoverage(bool enable, bool? force) -> nil, defined only if GLEW_ARB_multisample is supported by the platform, and otherwise the func itself is nil; force makes it apply even if MSAA level is under 4 (FIXME: what does that mean, what are the practical effects of setting it for msaa 3 or less?)
• improve AMD gfx card detection (looks for more strings, eg. "radeon", and in more places)
• add gl.ClipDistance(number clipID, bool enabled) -> nil, clipID is 1 or 2 (FIXME: what does either of those numbers mean?)
• change TextureMemPoolSize springsetting default value 256 → 512 MB
• expose windSpeed to Spring.{Get,Set}WaterParams
• new bumpwater params: waveOffsetFactor (0.0), waveLength (0.15), waveFoamDistortion (0.05), waveFoamIntensity (0.5), causticsResolution (75.0), causticsStrength (0.08)

[badosu]

There's this one as well: #95

[lhog]

TODO:

• C++17
• Github build
• LuaTex lodBias/cmpFunc
• Fix s3o tangents/bitangents calculation
• Fix minimap incorrect frustum lines
• Sync debug dumpstate works in release mode too
• Files that get read failure errors are reread 1000 times before giving up
• Actual CEG counts is calculated in a better way
• Most(?) CEGs and Weapons visuals are tested for texture validity such that pieces with invalid textures are not displayed. No more need for 1x1 empty texture
• Fix Cob crash
• Demos are saved with UTC clock
• fix to smooth height mesh (aka airmesh)
• /grabinput was reverted to how it is in vanilla
• fix skybox stretching and seams (in case it's represented by a cubemap)
• Compute shaders
• OpenGL Images (not textures)

[lhog]

• Docker based builder by @verybadsoldier
• Spring.ForceTesselationUpdate() for ROAM
• Update GetUnitFlanking to also return the amount of flankingbonusmobility the unit has collected
• Started work to replace old glBegin/glEnd and client side vertex arrays with modern counterparts. Due to various valid reasons it can't be done with GL4, but it can be and is done with RenderBuffers that allow for almost direct porting from develop and future upgrade to GL4 when the time will come.
• Expose globalRenderingInfo.availableVideoModes
• Expose LuaSyncedRead::GetUnitInBuildStance()
• Implement the AllowUnitCaptureStep callin
• Lua callins to enable GL4 custom unit shading
• LuaShaders::SetUnitBufferUniforms / LuaShaders::SetFeatureBufferUniforms for GPU side per unit/feature "uniforms" (SSBO in fact).
• Unsynced projectiles update is now multithreaded
• Expand the default number of threads in threadpool
• LuaUnsyncedRead::GetUnitsInScreenRectangle
• Multiple fixes for save/load ordering of calls
• New yardmap options for "stacked" buildings
• gl.Uniform/gl.UniformInt/etc don't require location as a first param, name is fine too.

[lhog]

• Made the implementation more robust to resolution/window position/window mode setting changes. Added Spring.SetWindowGeometry for easy window positioning. Exposed window border information to Lua.
• Fix "unload dead unit" synced crash
• Allow unitdef.name selection filter with IdMatches
• Win/CrashHandler fixes
• Handle cursor premature destruction that led to visual lockup of game/menu rendering.
• Moved Unit Icons to RenderBuffers
• Optimized transformation matrices upload to use ARB_buffer_storage (if available) and only upload matrices that got changed compared to prev. render frame.
• Enabled SSE2
• Fixed font substitution on MInGW build.

[marcushutchings]

• Unit positions in quadtree are updated every frame rather than every 0.5 second. This resolves the problem with projectiles seemly flying through units on occassion.
• Fixed SmoothHeightMesh to follow terrain even when the terrain goes underwater. This means the SmoothHeightMesh will be correct if the waterlevel is changed with the mod option map_waterlevel.
• Fixed sea/vtol aircraft handling so that they fly over water correctly, regardless of whether or not the waterlevel has been changed.
• Correctly detect core/thread cound on AMD processors, which fixes a performance problem on some AMD processors that used SMT.
• SaveLoad working again
• Behe's unsynced interpolation smoothness fixes for units movement and camera interpolation (need enabling via commands),
• spring probably works on Linux Wayland (implementation doesn't support hardware cursor yet)
• Multiple fixes to the order hardware cursors are instantiated, destroyed and swapped
• Optimized some of the drawing stuff: construction blueprints are GL4-ed (with fallback). Icons drawing got a round of optimization pass (still a bit messy).
• Minor bugfixing and minor changes

[Beherith]

• New config int: SmoothTimeOffset. This attempts to smooth out the TimeOffset parameter that is used to calculated the tweened draw frames. Default 0, old behaviour. Recommended value of 2, this attempts to keep the actualy timeoffset within 90% of the true time. Best with vsync on.
• New config bool: CamFrameTimeCorrection: camera frame time was also incorrectly calculated, causing jittery cam movement on high sim load. Default false value uses old method, true switches to a better interpolation.

[marcushutchings]

Engine 861 released. Changes made to the engine after this release, should go after this comment.

[sprunk]

e8bf8a9

[sprunk]

• Add config bool RotOverheadClampMap, default true, disabling it allows the rot over head camera to move outside of map boundaries // FIXME: what about regular overhead?
• selection keys: add new filter Guarding (first command in the queue is guard) and new count SelectClosestToCursor (always a single unit, doesn't work with SelectNum_X) // FIXME: or does it? i only looked at the code, it sounds like it would be useful if it did
• area-reclaim: always ignore wrecks being rezzed (now the CTRL modifier is only for features with autoreclaimable = false in their def; use single-target reclaim for things being rezzed)
• basecontent setupdefs.lua fills UnitDefs[x].hasShield correctly
• add Spring.MakeGLDBQuery(bool forced) -> bool ok to create a query to the OpenGL drivers database. There's generally only one query at a time allowed, forcing rewrites it // FIXME: is the query over the internet? any hint why would you ever force it instead of waiting for it to finish?
• add Spring.GetGLDBQuery(bool blocking) to receive the results of the query. Blocking means it will wait for the answer so probably only use it in the lobby and not the game // FIXME: is that right?
  Possible returns: nil if there was no query or the query failed completely
  false if it's not ready yet (and call isn't blocking)
  true, false if it finished and drivers don't have issues
  true, true, number glMajor, number glMinor, string URL, string driver // FIXME: what do these mean?

[lhog]

• engine can load HDR textures (.hdr format/extension) with automatic upcasting to FLOAT internal storage format (takes 4x more memory). No user side changes are needed. CBitmap class got reworked to be pixel format aware. Report the bitmap bugs if any.
• Fix unitdef.useFootPrintCollisionVolume. Now the useFootPrintCollisionVolume tag takes precedence over the default sphere that appears when collisionVolumeScales are zero.

[marcushutchings]

• Fixed issue where /debug showed too many threads running.
• Improved engine spinlocks by reducing their impact on the CPU.
• Chopped engine trees (removed engine tree generators and renderers). Trees have models/textures donated by 0. A.D. so these have outlived their utility.
• Fixed Spring.TraceScreenRay() fails to hit terrain due to bugs in synced terrain notification code and incorrect copying of visible parts from synced to unsynced.
• Improved pr-downloader performance by skipping double repo updates and downloading/scanning of unused repos.
• LegacyAtlas now produces mipmaps. Previously it never did.
• s3o textures reload fix for Assimp models
• Can declare defaultMin/defaultMax flanking damage in mod rules

[badosu]

• Hardware Cursor support is dropped when environment is wayland due to xwayland issue with leaking open files. This makes the SDL video driver default to wayland

[marcushutchings]

Engine 902 released. Changes made to the engine after this release, should go after this comment.

[sprunk]

34d2eb7

[marcushutchings]

• Added a new 'b' designator for yardmaps to declare an area that is buildable, but is not walkable. This allows for the current method of upgradable buildings to create a locking pattern that won't break pathing.
• Reserved MaxParticles *2 for unsynced projectile-container vector to avoid a re-alloc during the multi-threaded section. This prevents a race condition while processing unsynced particles.
• Added new versions of GetRenderUnits and GetRenderFeatures callins to support GL4 CUS.

[sprunk]

• Enable 3D and cubemaps for luatextures // FIXME: i think this doesn't require anything from the user, just that if you pass those they will now work, but somebody could double-check
• Add new Spring.GetTimerMicros() -> number, which gets timers in usec precision
• Spring.DiffTimers now takes a fourth arg, if you want usec precision in millisecond numbers, and passed in microsec level timers // FIXME: confusing wording from commit msg, should be clarified
• Skirmish AI: call PostLoad() after load event and only if loadSupported != yes // FIXME: looks backwards? shouldn't it be if load supported == yes?
• add Spring.Clear{Units,Features}PreviousDrawFlag() -> nil
• add Spring.GetRender{Units,Features}DrawFlagChanged(???) -> ??? // FIXME: args and retval?

[badosu]

• Accept an integer quality argument in screenshot action, as in screenshot [format] [quality].
• Add group [subcommand] n action handlers where subcommand is one of [add,set,selecttoggle,selectadd,selectclear]. This allows for more granular group binding control than groupn (which checks for keyboard modifiers in the action). When subcommand is not present, select group n.

cc @Svalorzen

[marcushutchings]

Engine 941 released. Changes made to the engine after this release, should go after this comment.

[sprunk]

941148f

[marcushutchings]

• Lua can now modify the original height map. This is the height map that determines the correct height values if the map has not been damaged or terraformed. BAR's lua interface Wiki has been updated with the call ins. See: https://github.com/beyond-all-reason/spring/wiki/Lua_SyncedControl
• /crash command now uses C++ standards compliant approach (thanks to Svalorzen)
• Hover units are no longer forced to be upright regardless on the terrain slope they are travelling over. It keep this behaviour with hover units, set upright = true in the appropriate Unit Defs. (thanks to lhog)
• The Smooth Height Mesh will now respond to changes in the height map and recalculate itself over the impacted area. This means aircraft using the smooth mesh will continue to be able to navigate appropriately after extended battles have modified the terrain significantly.
• The Smooth Height Mesh can now be disabled with a mod rule system.enableSmoothMesh = false

[sprunk]

• "$explosions" and "$groundfx" accepted by gl.GetEngineAtlasTextures // FIXME: and other funcs?
• removed LOD unit rendering (far 2d billboards) including /distdraw command and UnitLodDist springconfig entry

[Beherith]

• Atlasses now have a deterministic order given an identical alphabetical ordering of identicallally sized textures. This allows Lua construction of pairs of atlasses, e.g. pairs of diffuse and normal maps for multiple decals.

[badosu]

• Deprecate DISALLOW_RELEASE_BINDINGS, it has not been in effect since
  2006. Up+ modifier is also deprecated, a warning is displayed if
  attempted to bind. No change in behavior
• KeyPress and KeyRelease callins receive an additional scanCode
  parameter
• sc_ keysets are introduced for scancodes and handled in conjunction
  with keycode bindings preserving the order on which the actions where
  bound. Any+ order is preserved (Any+ bindings are at the bottom)
• /keysave and /keyprint now preserves the binding order, providing a better output
• Extend GetKeyBindings to receive an additional keyset string to retrieve scancode actions
• Add GetScanSymbol callout in a similar fashion to GetKeySymbol
• widget, gadget and action Lua handlers are modified to support
  scancodes in cont/. Games that wish to support lua actions via scancodes
  are recommended to adopt these changes, otherwise behavior should be
  identical to before.
• Fix issue where keysets could be bound to duplicate actions when the action line contained different comments
• Fix issue where name retrieval for keycodes would never return a non hex value, this affected the label parameter of KeyPress and KeyRelease callins
• Fix issue where GetKeyBindings would return incorrect actions when keychains were bound, e.g. if actions bound to m,n and b,n both would be returned on GetKeyBindings('n') regardless of the previous pressed key

[badosu]

• add Spring.AddUnitExperience(unitID, delta_xp). Can subtract, but the result cannot be negative.

[marcushutchings]

Engine 1354 released. Changes made to the engine after this release, should go after this comment.

[marcushutchings]

• Fixed issue causing path finding behaviour change when only a single core is used.
• Added system.pfForceSingleThreaded to force pathing requests to be sent single threaded.
• Added system.pfForceUpdateSingleThreaded to force pathing vertex updates to be processed single threaded.
• Added movement.forceCollisionsSingleThreaded to force collisions system to use only a single thread.
• Added movement.forceCollisionAvoidanceSingleThreaded to force collision avoidance system to use only a single thread.
• Added spring settings boolean flag DumpGameStateOnDesync. When set to true on the server, the server will request all clients to produce a local copy of the current game state (effectively calling /dumpstate.)
• Fixed issue where desyncs could not be detected before the 300th sim frame (10 seconds)
• Main thread is now allowed to move between cores when hyperthreading is unavailable. This helps when a server is running multiple headless or opengl instances.
• Fixed corner case issue where units could start moving on their own if they haven't moved yet and collide with something.
• Fixed unit movement performance issue where pathfind results return an effective raw move result over a long distance.
• Fixed issue where units could, in rare situations, change their direction of walking and go in the wrong direction.
• Reduce memory used for paths by TKPFS::PathManager.
• Updated logging around CPU affinity to provide better information.
• Pathing-related changes means the pathing version has been increased.
• Lamer fixed issue where save games could crash after load in matches involving the Barbarian AI.

[sprunk]

• WeaponDefs indexed from 1 instead of 0 (UnitDefs and FeatureDefs already worked that way)
  (reverted for now)

[p2004a]

• pr-downloader:
  • Fix resolving of dependent rapid archives
  • Fix compilation issues under MSVC making some parts of codebase more platform agnostic
  • Implement concurrent fetching of multiple mods and maps with single tool invocation
  • Replace potentially racy If-Modified-Since caching with ETags.
  • Harden downloading rapid packages by saving sdp file only after full successful download
  • Implement writing md5sum files for assets downloaded from springfiles to allow future full game
    files validation.
  • Drop lsl from the repo and separate RapidTools into separate repo

[sprunk]

• add Spring.GetModelPieceMap(modelName) -> { body = 0, turret = 1, ... }. Unlike similar existing functions it doesn't require a unit/feature instance to exist.
• add Spring.GetModelPieceList(modelName) -> { "body", "turret", ... }, ditto.
• add Spring.Yield() -> hintShouldKeepCallingYield to give back OpenGL context from game-loading thread back to main thread to process events and draw with LuaIntro, in practice this means it should be called from unsynced LuaRules and LuaUI gadget/widget initilizer periodically (the common implementation is to call it after a widget/gadget is loaded) as long as the returned hint value is true. If you call this without LoadingMT enabled then it's a slightly expensive (because of lua-engine-lua marshalling) NOOP. See ZeroK-RTS/Zero-K@6a9a03c as a good implementation example. (FIXME: that commit doesn't update the value after each call, shouldn't it do that?)
• add /debug reset to reset the collected debug stats
• LoadingMT springsetting now defaults to 1 (was 0) reverted
• LoadingMT springsetting no longer accepts -1 for autodetect (which meant 0 for Intel/Mesa graphics drivers and 1 for others)
• add wupget:DrawPreDecals() callin
• add AlwaysSendDrawGroundEvents boolean springsetting (default false) to always send DrawGround{Pre,Post}{Forward,Deferred} events, otherwise/previously they are skipped when non-Lua rendering pipeline was in use.
• added the /desync command for non-debug builds
• add /drawSky which toggles drawing of the sky (mostly for performance measurements now)
• Spring.GetConfig{Int,Float,String} second parameter can now be nil, which means it will return nil if the requested setting is not set. Formerly returned 0, 0, or "" respectively. Note that for settings used by the engine the value is never nil (so this is only for custom ones). To get back previous behaviour:

local originalGetConfigInt = Spring.GetConfigInt
Spring.GetConfigInt = function (key, def)
 return originalGetConfigInt(key, def) or 0
end
-- ditto for Float and String

[sprunk]

• when scanning archives (at early loading), the window should no longer be considered frozen/unresponsive by the OS
• add Game.metalMapSquareSize for use with API like Spring.GetMetalAmount etc
• add mirrored looping of animated CEG sprites (animates backwards until it reaches the start and then bounces again), enabled by making the animation speed parameter negative (e.g. animParams = "4,4,-30")
• add Spring.GiveOrderArrayToUnit, accepts a single unitID and an order array and otherwise works the same as the existing GiveOrderXYZ family of functions
• add more filters to selectkeys:
  • Buildoptions - for units that have a non-zero number of build options (meaning constructors and factories)
  • Resurrect - for units that can resurrect
  • Cloaked - for units that are currently cloaked
  • Cloak - for units of a type that can cloak (regardless of current cloak state)
  • Stealth - for units of a type that is stealth by default (regardless of current stealth state)
  • (note that there is no filter for "currently stealthed" like there is for cloak)

[lhog]

• Settled the new name for the fork - Recoil. Branding will follow in next releases.
• Started adding API documentation here https://beyond-all-reason.github.io/spring/ Kudos to @badosu !
• Maps with missing/invalid details texture no longer get tint with red. Improved reporting of missing map textures.
• Shadows color buffer can be made greyscale with springsettings ShadowColorMode = 0 or /shadows switches.
• Fix a few LoadingMT related issues
• PreloadModels = 0 (non-default) should work correctly now, though it comes with its own set of compromises.
• Fix Bumpwater rendering on non-NVIDIA drivers
• Misc fixes and improvements

[badosu]

• Fix Spring.GetSelectionBox not returning nil when there's an active mouse owner (activeReceiver)

[marcushutchings]

Engine 1544 released. Changes made to the engine after this release, should go after this comment.

[sprunk]

058c8ea

[badosu]

• Add 7th param to Spring.MarkerErasePosition so that spectators can remove player markers locally. Like /clearmapmarks but targeted

[marcushutchings]

• CPU usage reserved for drawing and minimum frames draw by second are now configurable in springsettings. MinSimDrawBalance=0.15 and MinDrawFPS=2
• Time needed to draw MinDrawFPS is no longer automatically factored into sim load in all cases (for lag protection) - is factored in if sim cpu usage starts to get close to interferring with the time needed for drawing the minimum number of frames.
• Fixed a pathfinding bug where the unit may try to force it's way through obstacles rather than walk around them.
• Improved performance of long-range path finding requests.
• Path data updates faster in response to map changes and can increase the rate dynamically as the number of map changes becomes larger.
• Path data update scaling rate can be adjusted by the new modrule system.pathFinderUpdateRateScale (default: 1.0)
• Path data updates per sim frame loading is better balanced to reduce impact on jitter caused by sim frame time variations.
• Reduced number of pathing blocks updated on map changes.
• Improve performance of path data updates by only updating the pathing block-to-block links that are impacted by map changes (previously all links were updated.)
• Set default min sim speed for commands to 0.1 (previous limit was 0.3.)
• Increase the rate at which the traversability map is updated by x4 (the F2 overlay.)
• Fixed issue where Unit Weapon aiming angle checks would recalculate cos(20) every call - it is now a constant expression.
• Fixed TestMoveSquareRange so that it only runs the required tests
• Fixed issue where units standing still would recalculate their facing direction every frame even though they are not moving.
• Improved unit formation movement so that the units move to the nearest logical point, whereas before, in some cases, units could try to move across each other moving to points that were the farthest from them. This means groups of units are able to assume new formations faster. Engine-driven formation move commands now try to match units to nearest appropriate move targets so as to have units adopt formations without having to run across each other.
• The old default path finder has been removed and its multi-threaded successor, TKPFS, has been renamed to HAPFS.
• Fixed issue where unit skidding could cause the unit to walk off in the wrong direction.

[p2004a]

pr-downloader:

• (Dec 2022) Improved performance of verifying if there is an update needed: it now takes ~0.25s on all OSes.
• (Dec 2022) Fix sdp downloading behavior when all files are already present
• Updated vendored dependencies and entirely refactored build system of pr-downloader to use modern CMake
• Fix progress bar in presence of redirects and when total download size is >2GiB

[sprunk]

• fixed piece projectiles (debris flying off from exploding units), and weapon projectiles with collideFireBase set to true and no other collisionX set to false, failing to collide with units.

[sprunk]

• added DrawShadowPassTransparent and DrawWaterPost callins
• add weaponAimAdjustPriority to weapon (note, NOT weapon def! This is the table inside a unit def). This is a multiplier for the importance of picking targets in the direction the weapon is already aiming at (FIXME: does this work correctly if the unit is retreating and shooting backwards? Comments say "in front of the unit" but hopefully that's just bad wording). Defaults to 1.
• and fastAutoRetargeting (called fastAutoRetargetingEnabled until version <FIXME>) to weapon. Makes the unit acquire a new target if its current ones dies (FIXME: does this trigger if something else kills it?), but is somewhat less performant. Defaults to false (target acquisition check every 0.5s).
• added Tracy support for debugging (FIXME: how to use?)
• pathing: default and TKPFS are now combined to be HAPFS (FIXME: does that affect modrules entries?)
• allow instanced rendering without instance VBO attached. gl_InstanceID can be used to index into an SSBO or used to produce instance attributes algorithmically (FIXME: guide or link to existing bar example?)
• changed how unit rotation works. This should make cases like spiders pathing across near-vertical peaks preserve heading better
• add Spring.Set{Unit,Feature}HeadingAndUpDir(thingID, heading, x, y, z) -> nil, note that the previously existing Spring.SetUnitDirection only receives one vector so does not allow setting an object's rotation unambiguously.
• Spring.GetSelectedUnits{Sorted,Counts} no longer returns the n inside the table, it's now the 2nd return value from the function
• Lua states that don't have full read access (LuaUI, LuaRules under CallAsTeam etc) can receive attacker info in UnitDamaged and similar, when appropriate
• added skinning and bones. Not supported for .s3o or .3do, only .dae (FIXME: what about the others? engine supports .3ds and .obj, do they support bones?). To use them, (FIXME: does a modeller need to do anything specific, or does an "industry standard" boner tool (blender?) produce proper results?).
• changed how models are passed to shaders such that (FIXME: describe the actual format change.) This requires updates of code that calls vbo:ModelsVBO() such that you'd replace:

layout (location = 5) in uint pieceIndex;

with

layout (location = 5) in uvec2 bonesInfo; //boneIDs, boneWeights
#define pieceIndex (bonesInfo.x & 0x000000FFu)

in shaders unless you want to support skinning, in which case you also need to do (FIXME, do what).

• remove the deprecated Game.allowTeamColors entry that was always true
• add Spring.GetFreaturesInScreenRectangle, similar to the existing one for units
• bump model pool from 2560 to 3840
• change default MaxTextureAtlasSizeX and Y from 2048 to 4096.
• Deprecate FFP terrain rendering, /advmapshading 0 is not emulated inside the terrain shader.
• Rewritten terrain mesh generators. Now they use mostly modern OpenGL. The implementation should cause less stuttering upon camera movement / zoom. BasicMeshDrawer (ss.cfg ROAM=0) is specifically good at avoiding terrain related micro-stutters.
• fixed Spring.SetProjectileCEG, now accepts numerical cegID correctly (in addition to CEG name)
• add a system.LuaAllocLimit modrule to control global Lua alloc limit, defalt 1536 (in megabytes)
• add --list-[un]synced-commands flag to dump the command list

[sprunk]

• add /DebugShadowFrustum to draw the shadow frustum on the minimap (beware, doesn't exactly correspond to the actual camera frustum so probably doesn't have much use outside shadows specifically due to minor bugs)
• add /debugvisibility for debugging the visible quadfield quads (for engine devs, mostly useless otherwise)
• Spring.GetPlayerInfo returns a 12th value, boolean isDesynced. Keep in mind the 11th will be nil if you opt out of the customkeys table (i.e. the new 12th value does NOT get "pushed back" to fill the "missing" spot)
• allow shallow recursion in Spring.TransferUnit (16 levels deep, same as for other callouts)

[p2004a]

pr-downloader:

• Fixed progress bar on Windows for file size >2GiB
• [Yarbiz] Fixed --disable-logging not actually disabling all logging
• Fix handling of unicode environment variables on Windows
• Introduce custom X-Prd-Retry-Num to inform server at which retry are we when fetching files

[badosu]

• Fix an issue where visibility checks would fail at certain camera angles and positions

[sprunk]

• Spring.SetActiveCommand(nil) now cancels the command (previous method of -1 still works)
• add Game.footprintScale, the footprint multiplier compared to defs
• add Game.buildSquareSize, the building alignment grid size
• add InGroup_N filter for selections. For example: Visible+_InGroup_1+_ClearSelection_SelectAll
• add MinDrawFPS, never go this many draw FPS, default 2. Partially for catching-up (reconnection etc), but also if the value is lower it will start engaging the "slow the game for laggers" feature.
• add MinSimDrawBalance springsetting, defaults to 0.15. The fraction of time to allocate exclusively for drawing. The way it interacts with the above is (FIXME).
• add group select and group focus group subactions. Note that the previous bind X group N is equivalent to bind X group select N + bing X,X group focus N. The old group N still works.
• add StoreDefaultSettings springsetting, default false. If enabled, settings equal to their defaults will still be saved. This means that Spring.GetConfigInt et al does not need to do a nil check for the defaults, but also the defaults won't get automatically updated if they change since they already have a concrete value.

[lhog]

1554 - 1755

• Multiple improvements to the engine documentation https://beyond-all-reason.github.io/spring/
• PNG is now a default /screenshot format
• fix overview camera not being centered in 2nd and subsequent games (fix overview camera not being centered in 2nd and subsequent games #660)
• Log the models pool exhaustion (helps debugging missing models)
• Fix missing footprint details
• Deal with a few more AMD & DisplayLists shenanigans
• Mess with the way shadow frustum is calculated. Expect improvements in quality and occasional missing shadows.
• Bump up 3do atlas size (4k^2)
• Allow setting Lua allocation limit. See 34d8c44
• LuaMemPool reimplementation. it should take care of small Lua allocations much better than the system default allocator. Causes additional 128MB static memory allocation and should improve Lua performance. Use ss.cfg UseLuaMemPools = 1 to enable.
• Recoil icons and loadscreen
• Fix invalid asset checksums
• Save live,dead ghost buildings, don't leak unit status with iconsasui
• Improvements to AABB in View code
• Fix 3do shattered pieces rendering (no texture)
• Fix AMD / Windows issues with invalid "under-construction" model rendering
• Infotexture shaders are more tolerant to potato drivers
• Fix bump water and terrain rendering on Intel
• Lua game.demoPlayName shows the played demo filename

[lhog]

https://github.com/beyond-all-reason/spring/releases/tag/spring_bar_%7BBAR105%7D105.1.1-1775-g441af87 is released
Changes made to the engine after this release, should go after this comment.

[sprunk]

For unit def changes, see below #171 (reply in thread)

Removals:

• remove gl.GetMatrix and functions accessible thence (apparently unused, so no replacement guide)
• removed spairs, sipairs and snext. These have been equivalent to the regular pairs, ipairs and next for years now, use the regular versions instead.
• removed VFS.MapArchive and VFS.UnmapArchive. Hopefully they will be back at some point, but no timeline is available yet. Use VFS.UseArchive in the meantime.

Changes:

• /ally no longer announces this to unrelated players via a console message
• failure to load a model now results in a crash instead of a potential desync down the road
• the movement.allowGroundUnitGravity mod rule now defaults to false (all known games have an explicit value set, so this should only affect new games)
• nanoturret (immobile builder) build-range now only needs to reach the edge of the buildee's radius instead of its center. Mobile builders already worked this way.
• screenshots are postfixed with UTC timestamp instead of number
• it's now possible to play fixed and random start positions with more teams than the map specifies. The extras are considered to start in the (0, 0) corner and it is up to the game to handle this case correctly.
• add SMFTextureStreaming boolean springsetting, defaults to false. If true, dynamically load and unload SMF Diffuse textures, which saves VRAM, but worse performance and image quality. Previous behaviour was equivalent to true so if you get VRAM issues try changing it.

Major QTPFS rework:

• major improvements in both quality (units getting stuck, cutting corners etc) and performance (processing speed, memory use, even disk usage). Every facet of QTPFS should generally work better. See changelog.txt in the repo for the specifics
• debug path drawer now draws into the minimap, showing the map damage updates waiting to be processed. The more intense the colour, the more layers (MoveTypes) that still need to process the change.
• added modrule:, system.pfRepathDelayInFrames, which controls how many frames at least must pass between checks for whether a unit is making enough progress to its current waypoint or whether a new path should be requested. Defaults to 60 (2 seconds). Adjust to find the right balance between how quickly units can get unstuck and how much CPU power is used. Smaller intervals increase the chance of slow units triggering unnecessary re-pathing requests, but reduces the chance that players may believe a unit is getting stuck and is not handling itself well.
• added modrule, system.pfRepathMaxRateInFrames, which controls the minimum amount of frames that must pass before a unit is allowed to request a new path. By default, it is 150 frames (5 seconds). This is mostly for rate limiting and prevent excessive CPU wastage, because processing path requests are not cheap.
• added modrule, system.pfRawMoveSpeedThreshold. Controls the speed modifier (which includes typemap boosts and up/down hill modifiers) under which units will never do raw move, regardless of distance etc. Defaults to 0, which means units will not try to raw-move into unpathable terrain (e.g. typemapped lava, cliffs, water). You can set it to some positive value to make them avoid pathable but very slow terrain (for example if you set it to 0.2 then they will not raw-move across terrain where they move at 20% speed or less and will use normal pathing instead - which may still end up taking them through that path).
• removed modrules: system.pfForce[Update]SingleThreaded. MT has shown itself stable.
• removed modrule: system.pathFinderUpdateRate. A different modrule serves a similar purpose, but uses different values, see: system.pfUpdateRateScale.

New features:

• add Spring.GetUnitSeismicSignature(unitID) -> number
• add Spring.SetUnitSeismicSignature(unitID, number newSignature) -> nil
• add Spring.DeselectUnit(unitID) -> nil
• add Spring.SelectUnit(unitID, bool append = false) -> nil, a single-unit version of SelectUnit{Array,Map} that doesn't require a table
• add Spring.GetUnitWorkerTask(unitID) -> cmdID, targetID. Similar to GetUnitCurrentCommand, but shows what the unit is actually doing, so will differ when the unit is guarding or out of range. Also resolves Build vs Repair. Only shows worker tasks (i.e. things related to nanolathing).
• add wupget:Unit{Entered,Left}Underwater(unitID, unitDefID, teamID) -> nil, similar to existing UnitEnteredWater. Note that EnteredWater happens when the unit dips its toes into the water while EnteredUnderwater is when it becomes completely submerged.
• add Spring.SetUnitShieldRechargeDelay(unitID, [weaponNum], [seconds]) -> nil. Resets a unit's shield regeneration delay. The weapon number is optional if the unit has a single shield. The timer value is also optional, if you leave it nil it will emulate a weapon hit. Note that a weapon hit (both via nil here, and "real" hits) will never decrease the remaining timer, though it can increase it. An explicit numerical value always sets the timer to that many seconds.
• add Spring.{Set,Get}PlayerRulesParam(s), similar to other rules params. There's currently two visibility levels, public and private. A notable difference is that the private level is only visible to that player, not his allyteam, and not even his (comsharing) team; this is partially for technical reasons and can be changed if need be. Synced and specs see everything.
• add Spring.GetUnitIsBeingBuilt(unitID) -> bool beingBuilt, number buildProgress. Note that this doesn't bring new capability because buildProgress was already available from the 5th return of Spring.GetUnitHealth, and beingBuilt from the 3rd return of Spring.GetUnitIsStunned, but as you can see it wasn't terribly convenient/intuitive.
• add system.allowEnginePlayerlist modrule, defaults to true. If false, the built-in /info playerlist won't display. Use for "anonymous players" modes in conjunction with Spring.GetPlayerInfo poisoning, or just to prevent ugliness.
• add a fourth boolean parameter to VFS.DirList and VFS.SubDirs, defaults to false. If set to true, the search is recursive.
• added new startscript entry: FixedRNGSeed. Defaults to 0 which means to generate a random seed for synced RNG (current behaviour). Otherwise, given value is used as the seed. Use for reproducible runs (benchmarks, mission cutscenes...).
• add Script.DelayByFrames(frameDelay, function, args...). Runs function(args...) after a delay of the specified number of frames (at least 1). Multiple functions can be queued onto the same frame and run in the order they were added, just before that frame's GameFrame call-in.
• rules params (of all kinds: unit, team etc.) accept boolean values. Skirmish AI and the rules param selection filter can read them via existing numerical interface by using 0 and 1.
• add fastQueryPointUpdate to weapon (note, NOT weapon def!). When enabled, the QueryWeapon family of functions is called every frame (instead of every 15 in slow update). This fixes friendly fire for rapid-fire multi-barrel weapons.
• add GL constants: DEPTH_COMPONENT{16,24,32,32F}. Use for <FIXME>.
• gadget:AllowUnitCreation now has two returns values. The first one is still a boolean on whether to allow creating the unit (no change here). The new second value is a boolean, if the creation was not allowed, whether to drop the order (defaults to true, which is the previous behaviour). If set to false, the builder or factory will keep retrying.
• add Spring.GetUnitEffectiveBuildRange(unitID[, buildeeDefID]) -> number. Returns the effective build range for given builder towards the center of the prospective buildee (i.e. what the engine uses). Returns just the build range if buildeeDefID is nil. Useful for setting the goal radius for raw move orders. Keep in mind this doesn't solve all known cases yet (doesn't handle features, or terraform) which are pending a solution.
• add Spring.SetAllyTeamStartBox(allyTeamID, xMin, zMin, xMax, zMax) -> nil, sets that allyteam's startbox edges in elmos.
• add Spring.GetWindowDisplayMode() -> number width, number height, number bitsPerPixel, number refreshRateHz, string pixelFormatName. The pixel format name is something like "SDL_PIXELFORMAT_RGB565".
• add an inline colour code \254, followed by 8 bytes: RGBARGBA, where the first four describe the following text colour and the next four the text's outline.
• add new /remove cheat-only command, it removes selected units similar to /destroy except the units are just removed (no wreck, no death explosion).
• add Spring.GetFacingFromHeading(number heading) -> number facing and Spring.GetHeadingFromFacing(number facing) -> number heading for unit conversion.
• add Spring.GetModelRootPiece(modelName) -> number pieceID and Spring.Get{Unit,Feature}RootPiece(thingID) -> number pieceID which return the root piece.
• add SMFTextureLodBias numerical springsetting, defaults to 0. In case SMFTextureStreaming = false, this parameter controls the sampling lod bias applied to diffuse texture. The tradeoff is that <FIXME>.
• add a 5th integer param to Spring.GetMapSquareTexture(x, y, lodMin, texName[, lodMax = lodMin]). It controls the max lod (<FIXME> what does that actually mean?) and defaults to the 3rd parameter, which is now the minimum (instead of the final value).

Fixes:

• fix shadow behaviour if you pass a vector to Spring.SetSunDirection without normalizing it (now it is normalized automatically)
• fix Cannon type weapons aiming at the (0, 0) corner of the world if they can't find a physical firing solution due to target leading
• fix Cannon type weapons being too lenient in friendly-fire avoidance when firing over allies
• fix MissileLauncher weapons with high trajectoryHeight not performing ground and ally avoidance correctly
• fix MissileLauncher weapons with high trajectoryHeight, zero turnRate and high wobble having an unstable trajectory and prematurely falling down when firing onto higher elevations
• fix VFS.SubDirs applying the passed pattern to the whole paths instead of just the individual folder names in VFS.RAW mode
• fix builders not placing nanoframes from their maximum range
• fix DGun weapon type projectile direction (previously shot at an angle that would be valid from the AimFromWeapon piece and not the QueryWeapon piece)
• fix being unable to drag-select units with /specfullview 0
• fix COB SetMaxReloadTime receiving a value 10% smaller than it should
• fix screenshots saved as PNG having an inflated file size via a redundant fully-opaque alpha channel

[marcushutchings]

• Fixed issue where some move commands would fail to give a suitable path if the goal was in an unreachable area.

[sprunk]

The following unit def keys now accept the same spelling as the ones exposed via UnitDefs.
The old spelling still works (old → new).

• metalUse → metalUpkeep
• energyUse → energyUpkeep
• buildCostMetal → metalCost
• buildCostEnergy → energyCost
• unitRestricted → maxThisUnit
• name → humanName

These two also accept a new spelling, and both the old and new spellings are in elmo/frame.
However, migrate to the new spellings ASAP because the original spellings will be changed
to use elmo/s sometime in the future.

• acceleration → maxAcc
• brakeRate → maxDec

The following unit def keys now accept a spelling and measurement unit
as the one exposed via UnitDefs (old → new). The old spelling still works,
and is still in the old unit.

• maxVelocity (elmo/frame) → speed (elmo/second)
• maxReverseVelocity (elmo/frame) → rSpeed (elmo/second)

The following UnitDefs keys now accept the same spelling as the ones
accepted for unit def files. The old spelling still works (old → new).

• tooltip → description
• wreckName → corpse
• buildpicname → buildPic
• canSelfD → canSelfDestruct
• selfDCountdown → selfDestructCountdown
• losRadius → sightDistance
• airLosRadius → airSightDistance
• radarRadius → radarDistance
• jammerRadius → radarDistanceJam
• sonarRadius → sonarDistance
• sonarJamRadius → sonarDistanceJam
• seismicRadius → seismicDistance
• kamikazeDist → kamikazeDistance
• targfac → isTargetingUpgrade

The following keys receive a new unified spelling for both unit defs
and UnitDefs (unit def, UnitDefs → unified). Old spellings still work.

• losEmitHeight, losHeight → sightEmitHeight
• cruiseAlt, wantedHeight → cruiseAltitude

Added the missing 'radarEmitHeight' to UnitDefs.
The unit def file key was also already 'radarEmitHeight'.

Changes to unit def validity checks:

• negative values for health, (reverse) speed, and metal/energy/buildtime
  now cause the unit def to be rejected, previously each was clamped to 0.1
• negative values for acceleration and brake rate now cause the unit def to
  be rejected, previously the absolute value was taken
• values (0; 0.1) now allowed for health and buildtime (0 still prohibited)
• values [0; 0.1) now allowed for metal cost (0 now allowed)
• undefined metal cost now defaults to 0 instead of 1
• undefined health and buildtime now each default to 100 instead of 0.1
• weapon edgeEffectiveness can now be 1 (previously capped at 0.999)
• unit armor multiplier (aka damageModifier) can now be 0 (previously capped at 0.0001)
• damage in weapon defs can now be 0 (previously capped at 0.0001)
• damage and armor can also be negative again (like in 0.76b1, so that the target is healed), but keep in mind weapons will still always target enemies and never allies, so avoid using it outside of manually-triggered contexts

All deprecated UnitDefs keys have been removed, listed below:

• techLevel
• harvestStorage
• extractSquare
• minx
• canHover
• drag
• isAirBase
• cloakTimeout
• miny
• minz
• maxx
• maxy
• maxz
• midx
• midy
• midz

[KyleAnthonyShepherd]

• Dgun projectile emit direction is now determined from the weaponMuzzlePos, like other weapons, instead of the wantedDir from the AimFromPos.
• Add fastQueryPointUpdate to weapon (note, NOT weapon def!). When enabled, UpdateWeaponPieces and UpdateWeaponVectors is called before the TryTarget check. Mostly useful for weapons that swap QueryWeaponX faster than the 15 frame SlowUpdate in unit script, to ensure friendly fire and other pre-fire collision checks are performed from the correct emit point, from the correct weaponMuzzlePos.
• Prevent CCannon::CalcWantedDir from returning a zero vector when the calculation fails, and instead return a vector with the x and z values of targetVec.
• Rework HaveFreeLineOfFire and TestTrajectoryConeHelper, to reduce instances of cannon weapon friendly-fire. Pre-fire collision checks for parabolic weapons now:
  a. Uses the proper trajectory linear and quadratic coefficients.
  b. Uses a conservative ray DetectHit check along the chord of the trajectory, instead of a single point check, to catch cases of corners of large colvols intersecting the trajectory.
  c. Trajectory checks vs units with individual piece collision are properly handled.
  This change was benchmarked to be performance neutral compared to the previous method.