DarkflameServer/resources/ugcconfig.ini

# UGC server: makes the meshes and icons of what players build and serves them to the game client.
# The master starts it when enable_ugc_server=1 (masterconfig.ini). See docs/UgcServer.md.

# HTTP port the game client downloads from (the client's UGCSERVERPORT)
port=2008

# The IP address to bind to. The game client has to reach it, so the default is every interface.
listen_ip=0.0.0.0

# UDP port for the connection to the master server (the next port is used too). It must not clash with another
# server's ports: auth uses 1500-1501, chat 2005-2006, the dashboard 2010-2011, worlds 3000 and up.
net_port=2012

# The client's UGCSERVERDIR: the path the downloads are under (the client adds /UGCC<DATACENTERID>/...)
client_path=/ugc

# Where the made files are kept (relative to the server binaries), and at most how much space they may take in MB.
# When there's more, the files used longest ago are deleted; they're made again when asked for. 0: no limit.
ugc_output_dir=ugc
ugc_max_storage_mb=2048

# Worker threads making files (0: half the CPU cores)
worker_threads=0

# How much of the machine making files may use (changes apply while running):
# max_cpu_percent: the workers together average at most this share of all CPU cores (0: no limit); they pause
#   between bits of work to stay under it, long renders included.
# worker_nice: the workers' scheduling priority on Linux, 0 (normal) to 19 (only when nothing else wants the CPU).
# max_memory_mb: jobs whose estimated memory would go past this together wait for running ones to finish; a job
#   bigger than it alone runs when nothing else does (0: no limit).
# max_model_bricks: models with more bricks fail with that reason instead of being made (0: no limit).
# pause_hours: local hours in which no new jobs start, e.g. 18-23 or 22-6 (empty: never).
max_cpu_percent=0
worker_nice=0
max_memory_mb=0
max_model_bricks=0
pause_hours=

# How often to look for models to make (milliseconds), how many to take at once, and how often a model may fail
# before it's given up on (the dashboard can try again)
poll_interval_ms=2000
poll_batch=32
max_attempts=3

# Models are made like LU Toolbox's Process Model and Bake Lighting make them; these default to its settings.
# color_palette: lu_toolbox (its LU palette, unknown colors black) or brickdb (the client's Materials.xml).
# color_variation: each brick's brightness is shifted by up to this percent (the same every time; 0: none).
# transparent_opacity: transparent bricks' opacity in percent.
# color_brightness: the models' colors in percent (not icons'; 100: as the palette has them, lower is darker).
# transparent_colors: color ids drawn transparent whatever Materials.xml says, comma separated (empty: the default, 129,
#   the transparent glitter violet, which Materials.xml has opaque; none: no colors).
color_palette=lu_toolbox
color_variation=5
transparent_opacity=58.82
color_brightness=100
transparent_colors=129

# Levels of detail made, from the client's brickprimitives (0 most detailed, 2 least), and the distances they're
# drawn at (LU Toolbox picks each level's range from these by which levels are made; lod_cull: drawn up to).
lods=0,2
lod_distance_0=0
lod_distance_1=50
lod_distance_2=100
lod_distance_3=280
lod_cull=10000

# The shapes' shader number: S<shader>_Opaque_Model (transparent shapes are S01_Alpha_Model), and whether all
# transparent bricks are one shape (1) or each its own (0, so the client can sort them)
shader_opaque=01
combine_transparent=0

# Metal, glow and glitter colors in NiLODNodes of their own, drawn with the client's metal, emissive and animated UV
# shaders (the default).
# Not how live looked: live's models were all LEGO plastic (S01), which 0 (off) keeps, byte for byte.
# shader_metal: mapShaders id for metal colors (Materials.xml types in metal_material_types and LU Toolbox's metallic
#   colors), S<id>_Metal_Model: 88 is Polished Metal.
# shader_brushed: for brushed steel colors (brushed_material_types; the client's Materials.xml has none): 89 is
#   Brushed Steel.
# shader_glow: for opaque glowing colors (LU Toolbox's glow colors), with their plain color and an emissive material:
#   46 is LEGO-Emissive. Transparent glow stays with the transparent bricks.
# glow_emissive: the glow shapes' material emissive (how far the shader goes from lit to the plain color, 1 fully).
# *_material_types: Materials.xml MaterialTypes, comma separated (empty: the default, none: no types).
# Models already made keep their look until they're made again (the dashboard's Make everything again, or Reprocess).
shader_metal=88
shader_brushed=89
shader_glow=46
glow_emissive=1
metal_material_types=shinySteel
brushed_material_types=brushedSteel,matteSteel
# brushed_colors: LEGO color ids drawn as brushed steel whatever their type, comma separated (empty: the default, the
#   drum lacquered 298,300,1002,1004; none: no colors)
brushed_colors=298,300,1002,1004
# shader_glitter: for glitter colors (glitter_material_types and glitter_colors), S<id>_Glitter_Model and, for
#   transparent ones, S<id>_GlitterAlpha_Model: 21 is LEGO-AnimUV, which lays a white fleck texture stored in the .nif
#   over the color (still: the client never updates a placed model). 0: off, glitter stays plastic.
# glitter_size: the fleck texture's tile in model units (a stud is 0.8); glitter_density: flecks in a tile;
#   glitter_fleck_size: a fleck's diameter in model units (they are cm: 0.05 is half a millimetre, as LEGO's glitter);
#   glitter_fleck_opacity: percent, the brightest flecks (each catches the light differently: most are dimmer).
# shader_glitter_sparkle: the glitter bricks' sparkles, S<id>_GlitterSparkle_Model over both glitter groups (only with
#   shader_glitter). 79 is Distortion Directional (Ocean), whose texture layers the client moves every frame on its
#   own: a sparkle flashes where two layers' sparkles meet. (Nothing else can move on a placed model: the client never
#   updates its scene graph, so texture controllers in the .nif never run.) 0: no sparkles.
# glitter_sparkle_size: a sparkle's diameter in model units; glitter_sparkle_amount: percent of each moving layer
#   covered (about its square's share of the brick sparkles at once); glitter_speed: how fast sparkles flash and go
#   out (1: about half a second each, 0.1 to 4); glitter_sparkle_tint: percent of the brick's color the sparkles take;
#   glitter_sparkle_brightness: percent.
# glitter_random: 1 places each brick's flecks its own way (turned and moved by the brick), 0 the same on every brick.
# glitter_colors: LEGO color ids that are glitter whatever their type (empty: the default, 114,117, which LEGO's color
#   data calls glitter; none: no colors)
shader_glitter=21
glitter_material_types=glitter
glitter_colors=114,117
glitter_size=1.6
glitter_density=80
glitter_fleck_size=0.05
glitter_fleck_opacity=80
shader_glitter_sparkle=79
glitter_sparkle_size=0.1
glitter_sparkle_amount=5
glitter_speed=1
glitter_sparkle_tint=30
glitter_sparkle_brightness=100
glitter_random=1
# Satin (opal) colors stay transparent plastic (the client has no satin shader) but are made milky:
# satin_colors: color ids (empty: the default, LEGO's satin colors 360,362,363,364,365,366,367,376; none: off),
# satin_opacity: their transparent bricks' opacity in percent (instead of transparent_opacity),
# satin_whiten: how far their color goes towards white, in percent.
satin_colors=360,362,363,364,365,366,367,376
satin_opacity=75
satin_whiten=20

# Remove faces that can't be seen: the opaque bricks are rendered from 42 directions around the model (hsr_resolution
# pixels square) and the triangles that show in none are removed. hsr_ground_plane: 1 also removes what can only be
# seen from below the model.
remove_hidden_faces=1
hsr_ground_plane=0
hsr_resolution=1024

# What traces the occlusion rays: embree (Intel Embree on the CPU), hiprt (AMD or NVIDIA GPUs, when built with
# DLU_HIPRT) or embree-gpu (Intel Arc or Xe GPUs, when built with DLU_EMBREE_SYCL); without the build or the GPU,
# embree. hiprt_device and embree_gpu_device: which GPU (0: the first; restart to change).
ray_backend=embree
hiprt_device=0
embree_gpu_device=0

# denoise: off, or oidn (when built with DLU_OIDN; else off): a model's icon is drawn from its colors before the
# occlusion bake with its occlusion traced per pixel (denoise_samples rays from each pixel of the supersampled image)
# and denoised by Intel Open Image Denoise. The model keeps its baked occlusion.
denoise=off
denoise_samples=4

# What makes the models: native (the UGC server's own pipeline) or toolbox-blender (LU Toolbox itself in a headless
# Blender, an external program the UGC server starts and keeps running; far slower, one model at a time). Staff can pick
# either for one make. Without Blender, LU Toolbox or niftools (the settings below) toolbox-blender can't be used: models
# are made natively and the UGC server logs why (docs/UgcServer.md, "LU Toolbox in Blender").
# toolbox_blender: the Blender executable (LU Toolbox is made for Blender 3.1).
# toolbox_standalone_dir: the LU-Toolbox-Standalone folder (lu_batch_driver.py).
# toolbox_scripts_dir: a Blender scripts folder whose addons/ has lu_toolbox and io_scene_niftools (empty: the add-ons
#   installed in Blender's own user folder).
# toolbox_brickdb_dir, toolbox_work_dir: LU Toolbox's brick folder (made from the client's res the first time) and the
#   folder of the model being made and Blender's log, relative to the server binaries.
# toolbox_device: what Cycles bakes on: cpu, cuda, optix, hip or auto. toolbox_threads: Blender's CPU threads (its CPU
#   time counts against max_cpu_percent, which pauses it; worker_nice applies to it). toolbox_timeout_seconds: a model
#   taking longer fails and Blender is started again.
processor=native
toolbox_blender=
toolbox_standalone_dir=
toolbox_scripts_dir=
toolbox_brickdb_dir=toolbox-brickdb
toolbox_work_dir=toolbox-work
toolbox_device=cpu
toolbox_threads=4
toolbox_timeout_seconds=1800

# Bake ambient occlusion into the vertex colors: rays per vertex, how far they look, strength 0 (none) to 1, and how
# much glowing colors add
bake_ao=1
ao_samples=64
ao_distance=5
ao_strength=1
glow_strength=6

# Icons: size in pixels. A player model's icon is drawn from its finished .nif (LOD 0), a car or rocket's from its
# modules' meshes put together.
icon_size=128

# How icons are framed and lit: icon_yaw, icon_pitch, icon_fov, icon_margin, icon_offset_x, icon_offset_y,
# icon_model_yaw, icon_model_pitch, icon_model_roll,
# icon_sun_yaw, icon_sun_pitch, icon_sun_light, icon_world_light, icon_fill, icon_specular, icon_shininess,
# icon_exposure, icon_contrast, icon_shadow_strength, icon_ao_strength. Their defaults (the framing from LU Toolbox's icon
# renderer, the light matched to the game's own model icons) and ranges are listed once in the server
# (UgcIconParams) and on the dashboard's settings page; set one here only to change it. The dashboard's icon editor
# also keeps presets for player models and each car or rocket type, and overrides for single items, in the database.