LUX

LUX is a mod specifically made and developed for use in Source 2013 Singleplayer and Source 2013 Multiplayer.
The Project is to entirely rewrite all existing "SDK_" Shaders, that come with the SDK and all those available in Mapbase.

Goals

• Overhauled/Cleaned materialsystem\stdshaders\ Folder

Warning:Pretty much everything except existing shader-compile functionality is pretty much "nuked".

Note:SDK_ Shaders will fall back to LUX_ Shaders, that way LUX can easily be used on Mapbase mods without much work.

Note: Implementing LUX Shaders would entail replacing the existing stdshaders\ with the one from LUX. Effectively 'nuking' SDK_ Shaders. LUX Shaders should be able to do everything SDK_ Shaders in and can do.

• Drastically decreased compile-times for all Shaders

Why?: Valves Shaders take forever to compile //, especially using the stock Shader-Compiler. This disincentives modding Shaders.

Note:Even on a good CPU it can take half a day, 'or more. As an example for LUX. Compiling the entirety of LUX_LightMappedGeneric takes around 30 seconds on 4 cores @4.1GHz

• SM3.0 Shaders Only

Why?: ps20b and below is too limiting. The lack of available constant registers causes extreme branching and a lot of 'combos'. Making the code terrible to read and complicated. This disincentives Modders.

Note:Linux is not officially supported. MacOS is also not officially supported. Users of said systems will have to either patch togl to work with SM3.0 or use DxVK.

Note:

• SM3.0 released in 2004, and Valve considered ps2.0b low end hardware in ~2008. See slide 8
• This means that older hardware not capable of SM3.0 will not be able to use the new Shaders.

• Totally rewritten .h, .cpp, .fxc files

• More Documentation for Shaders, their parameters, how they work and any possible caveats

Note:You might have noticed Articles like $lightwarptexture, $detail, UnlitTwoTexture and $envmapmask getting major updates from ShiroDkxtro2,

where new information about Caveats and bugs were added for . This was a direct result of LUX development, although the focus was mainly on as their code is publicly available.

Note:The current lack of documentation on how Shaders work in Source, disincentives learning how to mod Shaders or make their own. The barrier of entry is very high as a lot of very specific knowledge is required too.

• Implementing features that aren't available in

See also:  Planned Features. This includes old features such as $selfillumtexture and newer features like $phongalbedoboost(only in ).

• Fixing most Parameter "bugs:" and other caveats

See also:  Stock Shaders VS LUX

• Easy way of disabling features

Important:A custom Pre-Processor program has been made. It automatically sets // STATIC:'s to predefined values depending on #define's in an included header file.

Note:Mods that don't require specific features (lightwarptexture/distancealpha/phong/envmaps/etc), can easily disable them and further increase Shader compilation speed. Most parameters have been #ifdef'd in the c++ code!

• Mapbase compatibility

Note:Replacing SDK_ Shaders in SDK mods, SDK2013CE or Mapbase mods should be as simple as replacing the stdshaders\ Folder.

Note:It is assumed that no custom Shaders apart from SDK_ ones were added. If they were added, developers should be capable of adding them back/recreating them.

Planned Features

This is a list of new features that are being implemented or features that will be ported/recreated from newer branches such as

Note:Ported in this case usually means /, however in most of these cases, the code for this will be heavily adapted to simplify or overhaul it.

Important: LUX does not use any leaked code. Features like $phongalbedoboost(only in csgo) are not rocket-science. They can safely be recreated without the use of leaked code.

Warning:For more complicated features, there might be visual disparity when compared to official implementations.

Features required for Mapbase compatibility

• $phongdisablehalflambert from +
• Radial Fog for all "Geometry" Shaders
• Spline-Ropes
• Parallax Corrected Cubemaps ( PCC )

Note:Just like Mapbase, this requires custom compilers to work.

Important:The parameters are the same for LUX and . This means that Mapbase compilers can be used for this to work.

• $envmapmask + $bumpmap on VertexLitGeneric
• Replacement for the "Postprocessing" Controller Shader
• Replacement for the "Engine_post" Shader from
• Hammer $blendmodulatetexture previewing fix.
• Brush $phong
• Treesway

Todo: Is the implementation ported from ?

$bumpmask and related

New Features

• In Models utilizing Model Lightmapping can use $bumpmap. Additionally, all Model shaders will be able to utilize this feature. Except they have $phong.

Important:The Lightmap does not do bumped-lighting using the bumpmap. Only named lights/projected textures will be able to do so.

Note: Lightmapped models will not be able to receive $phong. This is not planned at the moment but should be possible for named-lights/projected textures!

• In Models can utilize Lightmap UV's.

Warning:The way this is currently implemented requires a custom written tool, two SMDs ( one with lightmap uv ), and also has a lot of precision loss for the Lightmap UVs. Additionally, this requires a custom compiler!

Todo: Investigate code, supposedly the Studiomdl code is there. Maybe it can be packed via Blendweights or alternatively, the precision loss might be decreased.

Features ported/recreated/revived

• $phongdisablehalflambert From + - Also needed for
• $phongexponentfactor From , with LUX also on
• $phongalbedoboost From - Its just BaseTexture * $PhongAlbedoBoost... No leaked code!
• $basemapluminancephongmask From +

Note:

• LUX allows the use of Rec. 709 HDTV Luminance Weights. float3(0.2126f, 0.7152f, 0.0722f).
• Previously SDK_ Shaders would use the NTSC Analog Television standard of float3(0.2990f, 0.5870f, 0.1140f)

• $selfillumtexture Deprecated since - This used to be obsolete

Note: Yes, there is a use for this! $detailblendmode 5 is commonly used for glowing textures. This parameter allows for not wasting your $detail. Additionally no $emissiveblend is required.

See also:  PBR Shaders in the community commonly have a $emissiontexture parameter that does EXACTLY what $selfillumtexture does in LUX.

• Water Shader with $flowmap Support - From
• $envmaplightscale From for brushes+ AND models (only in )+

Important:

• On brushes this will use the Lightmap
• On models with $bumpmap, this will use bumped lighting.
• On models without $bumpmap, this will use Vertex Lighting.
• In Models utilizing Model Lightmapping, will use the Lightmap. Regardless of whether or not $bumpmap is used.

Features that are being discarded

• $envmapsphere and related - These features have been removed since and are obsolete.

Note:This is very easy to re-implement. The 7th face of a cubemap is still being built in and therefore this feature is still operational given that the code has been implemented!

Features that won't be ported/recreated/revived

• $basealphaenvmapmaskminmaxexp from - This parameter is not yet documented on the VDC, it is also unclear what exactly it does...
• $EnvMapLightScaleMinMax from

Not functional - FOR NOW

• $distancealpha - Non-Functional. Planned for later.

Stock Shaders VS LUX

Todo: Move This to their own pages or something like that. Also, update.

LightmappedGeneric

Stock Shaders Bug: $detailblendmode 2-9 Don't work. $detailblendmode 6 Doesn't work. $detailblendmode 1-6, 8 Don't work. 9 Does not work with $bumpmap, $envmap or $selfillum $bumpmap + $envmapmask Doesn't work, except in Counter-Strike: Global Offensive $lightwarptexture + $detail Doesn't work. $basealphaenvmapmask + bumpmap Doesn't work  [todo tested in ?] Note: $selfillummask Missing $selfillum_envmapmask_alpha Missing $selfillumfresnel Missing $blendtintbybasealpha Missing $detailtexturetransform Missing $lightwarptexture Missing $envmapfresnelminmaxexp(only in +) $envmaplightscale(only in +) Note:$basealphaenvmapmask requires inverted masks

LUX_LightMappedGeneric Note: $detailblendmode 1-9 works. $detailblendmode 10-11 planned. $bumpmap + $envmapmask works, used to be (only in .) $lightwarptexture + $detail works ( does not work in ). $basealphaenvmapmask + $bumpmap works. $selfillummask Exists now. $blendtintbybasealpha Exists now. $selfillum_envmapmask_alpha Exists now. $envmaplightscale Exists now. $detailtexturetransform Exists now. Note:Caveat - Has higher priority than $selfillum/$selfillummask. Note:Caveat - $selfillumtexture has higher priority than both. Important:$basealphaenvmapmask does no longer require a flipped mask. Workaround:There is a new parameter which can flip the envmap mask. It also works with $envmapmask and $normalmapalphaenvmapmask.

VertexLitGeneric

Stock Shaders Always $envmaplightscale(only in ). Without $Bumpmap Bug:$detailblendmode 10-11 Don't work. $selfillumfresnel missing. $lightwarptexture missing.  [todo tested in ?] Note:$lightwarptexture forces bumpmapping by binding a default one, unless one is manually specified. With $Bumpmap Bug: $detailblendmode 5-11 Don't work. $detailblendmode 5-6 & 8-11 Don't work.  [todo tested in ?] Note: $envmapmask missing. Except . $selfillummask missing. Confirm:Only in ? $selfillum_envmapmask_alpha missing. $selfillumfresnel disables $normalmapalphaenvmapmask. Todo: Also on other branches than ? With $Phong Bug:$detailblendmode 8-11 Don't work. $invertphongmask In the shadercode, only flips the mask used for $envmap. Confirm:Also on newer branches? $phongalbedotint cannot be used without $phongexponenttexture. $phongwarptexture does not work. $phongalbedoboost(only in ) + $detail does not work. $phongtint disables $phongalbedotint. $envmap always masked by something. {{Only in + $envmap masked by $basetexture luminance when $normalmapalphaenvmapmask and $basemapluminancephongmask is used. $envmap masked by $basetexture alpha when $normalmapalphaenvmapmask and $basemapalphaphongmask is used. $basemapalphaphongmask makes $phong ignore the $bumpmap. $selfillumfresnel + $normalmapalphaenvmapmask will cause the $envmap to be multiplied by 0.0f regardless of whether $invertphongmask is used. $selfillumfresnel will cause $envmap to be masked using the $basetexture alpha channel.}}  [todo tested in ?] Note:$phongdisablehalflambert only in + $phongexponentfactor only in $basemapluminancephongmask only in + $phongalbedoboost only in +

LUX_VertexLitGeneric Without $Bumpmap $detailblendmode 10-11 planned. If possible. $selfillumfresnel Exists now. $lightwarptexture Exists now. Todo: Make a parameter that allows its usage. Right now default behavior is replicated and a default bumpmap is bound. With $Bumpmap $detailblendmode 5-9 work. $detailblendmode 10-11 planned. If possible. $envmapmask Exists now. $selfillummask Exists now. $selfillum_envmapmask_alpha Exists now. $selfillumfresnel + $normalmapalphaenvmapmask Works now. With $Phong $detailblendmode 8-9 work now. $detailblendmode 10-11 planned. If possible. Note:$invertphongmask Now only flips the mask used for phong. It will no longer touch the envmapmask at all. $phongalbedotint can now be used without $phongexponenttexture. Note:Will use entirety of $basetexture, without being masked. $phongwarptexture works. ( does not work in ). $phongalbedoboost Exists now. Used to be (only in .) $phongalbedoboost + $detail Works. Does not work in Counter-Strike: Global Offensive. Note:$phongtint does no longer disable $phongalbedotint. It will do ($baseTexture * Mask) * $PhongTint Note:When no $phongexponenttexture is specified, Mask will be 1.0f! $envmap Can now be not-masked by using a new parameter ($phongenvmapnomask) Important:By default the original masking for the $envmap will be replicated to not have disparity. However, it can now be overriden using two new parameters. $phongforcebasealphaenvmapmask and $phongforcenormalmapalphaenvmapmask $basemapalphaphongmask no longer makes $phong ignore the $bumpmap. Note:This will make materials that previously used this intentionally, look different. $selfillumfresnel + $normalmapalphaenvmapmask will no longer multiply the $envmap by 0.0f $phongdisablehalflambert Exists now. ( Used to be (only in +) $phongexponentfactor Exists now for . ( Used to be (only in ) $basemapluminancephongmask Exists now. ( Used to be (only in +) $phongalbedoboost Exists now. ( Used to be (only in +)

History

LUX started development on January 20th, 2023, but it was planned and thought around January 14th, when the lead developer ShiroDkxtro2 was in a hospital stay.
Even before 2023, the idea of rewriting Valve's shaders was being considered. Various people asked ShiroDkxtro2 if certain modifications could be implemented for default shaders, such as cascaded shadow mapping.
These requests would usually result in a simple "no", as modifying the default shaders was not considered feasible for various reasons, most of which are indirectly mentioned in LUX's Goals.
The project's inception was supposed to be a means to make the existing shaders more moddable, with new features in mind and laid out so that implementing new things would be easier.

Credits

• LUX uses SCell555's ShaderCompiler
  

However, it is only used to compile the Shaders. Include files ( .inc ) are intended to be made using Perl.

• LUX copies various code from thexa4's PBR header
  

• Tottery ( Also known as TotteryNine )

TotteryNine was crucial to ShiroDkxtro2 for learning the basics and more complicated aspects of making and compiling Shaders.

• Sitkinator

Aiding with the initial logo and adding a screen-reflection effect to it.

• Mr.Kleiner

For writing various tools. Including a VTF Flagging tool for Cubemaps inside a .bsp file, a tool for packing lightmap UV's into .smd files

• roman_memes

Various logical checks and ideas. Also helped with prototyping new features and finding siggraph or other papers regarding modern and oldschool graphical implementations.

• Alivebyte!

For doing modifications to the ShaderCompiler, which so far have not been implemented into the repo.

• Ficool2

For enlightening us about the Constant Register Hack.
Which allows for the use of more than 32 float constant registers on sm3.0
This Project would be nearly impossible without it.

• ChatGPT

Help with programming and undocumented graphical features of the Source Engine. It knows things and can make new things to a degree. Various code used in LUX has been partially written by the AI.

• Mapbase

Since one of the goals of this project is to be compatible with it, various code from it has been adapted. This means that all Shader-related things should also be inherited with the credits of LUX. You can find Mapbase's credits HERE.

• Source++ code might be included with LUX.

One example would be the NvidiaPCF5x5Gaussian Shadow Filter

Note:What else from S++ is used in LUX?

ShiroDkxtro2 would also like to thank Joshua Ashton personally for his various open-source work related to the source engine.

See also

• LUX Discord Server

Development can be followed here, Bug-Reports & suggestions made.

It is also intended as a general place for discussing Source 2013 related Shader-Modding.

• LUX GitHub page

Todo: Make a new category for LUX_ Shaders and document them and their parameters there, instead of here. Preferably after they were released on the GitHub.