b3dSetShaderFloat4

Sets 4-component vector parameter (float4/vec4 uniform) for custom screen shader (RGBA color, full vectors, quaternions). Takes shader (shader handle from b3dLoadScreenShader, positive integer), name (parameter name, string matching HLSL uniform variable), x (first component, float), y (second component, float), z (third component, float), w (fourth component, float). Returns nothing. Stores components in shader.floatParams map as name.x, name.y, name.z, name.w (four separate float entries, persists until changed). Use to pass RGBA colors (tint color with alpha, fog color with density), full vectors (quaternion rotation, plane equation, rect bounds), or 4D parameters (color+strength, position+radius, min/max ranges). Storage behavior: components stored separately (name.x stores x, name.y stores y, name.z stores z, name.w stores w in floatParams map), shader reads as float4 (HLSL shader accesses as single vec4, engine packs components automatically), persists until changed (call again with same name to update, survives across frames), independent of apply (set before or after b3dApplyScreenShader, takes effect next frame). Use cases: (1) RGBA tint (b3dSetShaderFloat4(shader, "tintColor", 1.0, 0.5, 0.2, 0.8) orange tint with 80% opacity), (2) Fog parameters (b3dSetShaderFloat4(shader, "fog", r, g, b, density) color+density in one vector), (3) Screen rect (b3dSetShaderFloat4(shader, "rect", left, top, right, bottom) bounds for masking), (4) Color+intensity (b3dSetShaderFloat4(shader, "light", r, g, b, intensity) light color and strength), (5) Position+radius (b3dSetShaderFloat4(shader, "sphere", x, y, z, radius) sphere for distance field effects). Common patterns: set = b3dSetShaderFloat4(shader, "paramName", x, y, z, w) configure vector; rgba = b3dSetShaderFloat4(shader, "color", r/255.0, g/255.0, b/255.0, a/255.0) RGBA normalized 0-1. Typical workflow: load shader (shader = b3dLoadScreenShader("effect.hlsl")), set vector (this function for 4D values), apply shader (b3dApplyScreenShader(shader) activate), render (b3dRenderWorld applies shader, reads vector), update vector (call SetShaderFloat4 again to animate). HLSL shader access: declare uniform (cbuffer ShaderParams { float4 tintColor; float4 fog; float4 rect; }), read in pixel shader (finalColor *= tintColor; float4 fogParams = fog; float fogDensity = fog.w;), match parameter name (C++ "tintColor" must match HLSL "tintColor" exactly, case-sensitive), access components (tintColor.x/y/z/w or tintColor.rgba or tintColor.xyzw for swizzling). Common parameter names: "tintColor" or "color" (RGBA tint with alpha, 0.0-1.0 normalized), "fog" (RGB fog color + W density/distance), "rect" or "bounds" (screen-space rectangle x1,y1,x2,y2), "light" (RGB light color + W intensity/range), "sphere" or "circle" (XYZ center + W radius for masking), "colorCorrect" (RGBA adjustment multipliers), "plane" (plane equation Ax+By+Cz+D=0 for clipping). Typical values: RGBA color 0.0-1.0 (normalized, 1.0=full intensity, 0.0=none, for tint/fog/light), RGBA color 0-255 divide by 255 (convert from integer RGBA to float 0-1), fog density 0.0-1.0 (fog.w, higher=denser, exponential falloff typical), rect screen-space 0.0-1.0 (normalized coordinates, 0,0=top-left, 1,1=bottom-right) or pixels (actual pixel coordinates, depends on shader), position+radius world or screen-space (XYZ center position + W radius, large values OK for world space), plane equation (A,B,C=normal vector, D=distance from origin). Performance: set cost zero (four map insertions/updates, trivial CPU operation), parameter read cost zero (constant buffer upload once per frame, GPU reads efficiently), vector packing automatic (engine combines name.x/y/z/w into float4 for shader), no performance difference vs four SetShaderFloat calls (same storage, just convenience function). Component storage: x component stored as "name.x" key (floatParams["color.x"] = 1.0), y component stored as "name.y" key (floatParams["color.y"] = 0.5), z component stored as "name.z" key (floatParams["color.z"] = 0.2), w component stored as "name.w" key (floatParams["color.w"] = 0.8), shader reads combined (HLSL sees float4 color = {1.0, 0.5, 0.2, 0.8}), can mix with SetShaderFloat (can overwrite individual components with SetShaderFloat, components independent). Validation: ignores if shader <= 0 (invalid handle, silent no-op), ignores if name null (null pointer, early return), ignores if shader not found (not in g_screenShaders3D map, silent no-op), accepts any values (no range validation, user responsible for sensible values). No return value: void function (doesn't indicate success/failure), assumes success (parameters set if shader valid, nothing if invalid), silent operation (no error messages, no confirmation prints). Parameter lifetime: persists until changed (call SetShaderFloat4 again with same name overwrites all components), survives apply/clear (clearing active shader doesn't erase parameters, reapply uses same values), freed on shader free (b3dFreeScreenShader removes entire shader including all parameters), individual components persist (name.x/y/z/w stored separately, can overwrite with SetShaderFloat if needed). Multiple shaders: each shader has independent parameters (shader1.floatParams separate from shader2.floatParams), same parameter name OK (different shaders can use "tintColor" with different values), switch shaders instantly (no parameter copying, each shader remembers own values). RGBA color conversion: integer RGBA to float (r/255.0, g/255.0, b/255.0, a/255.0 for 0-255 -> 0.0-1.0), HDR colors allowed (RGB values > 1.0 for bloom/glow effects, alpha typically 0-1), premultiplied alpha shader responsibility (pass straight or premultiplied as needed, shader handles blending). Common uses: RGBA tint (multiply scene color by tint, alpha for blend amount), fog parameters (RGB color + W density, single vector for all fog params), light parameters (RGB color + W intensity, convenient packaging), masking/clipping (rect bounds or sphere for selective effects, W for feather/falloff). Related: b3dSetShaderFloat sets single float (for scalar values, strength, time), b3dSetShaderInt sets integer parameter (for discrete values, flags, indices), b3dSetShaderFloat2 sets 2-component vector (vec2 in HLSL, UV offsets, screen size), b3dSetShaderFloat3 sets 3-component vector (vec3 in HLSL, RGB color without alpha), b3dLoadScreenShader loads shader (creates shader configured by this function), b3dApplyScreenShader applies shader (activates shader that uses parameters set here).