forked from LeenkxTeam/LNXSDK
Update Files
This commit is contained in:
677
leenkx/Sources/iron/object/LightObject.hx
Normal file
677
leenkx/Sources/iron/object/LightObject.hx
Normal file
@ -0,0 +1,677 @@
|
||||
package iron.object;
|
||||
|
||||
import kha.arrays.Float32Array;
|
||||
import kha.graphics4.TextureFormat;
|
||||
import kha.graphics4.Usage;
|
||||
import iron.math.Mat4;
|
||||
import iron.math.Vec4;
|
||||
import iron.data.LightData;
|
||||
import iron.object.CameraObject;
|
||||
|
||||
class LightObject extends Object {
|
||||
|
||||
public var data: LightData;
|
||||
|
||||
#if rp_shadowmap
|
||||
#if lnx_shadowmap_atlas
|
||||
public var tileNotifyOnRemove: Void -> Void;
|
||||
public var lightInAtlas = false;
|
||||
public var lightInAtlasTransparent = false;
|
||||
public var culledLight = false;
|
||||
public static var pointLightsData: kha.arrays.Float32Array = null;
|
||||
public var shadowMapScale = 1.0; // When in forward if this defaults to 0.0, the atlas are not drawn before being bound.
|
||||
// Data used in uniforms
|
||||
public var tileOffsetX: Array<Float> = [0.0];
|
||||
public var tileOffsetY: Array<Float> = [0.0];
|
||||
public var tileScale: Array<Float> = [1.0];
|
||||
#end
|
||||
// Cascades
|
||||
public static var cascadeCount = 1;
|
||||
public static var cascadeSplitFactor = 0.8;
|
||||
public static var cascadeBounds = 1.0;
|
||||
#if lnx_csm
|
||||
var cascadeData: Float32Array = null;
|
||||
var cascadeVP: Array<Mat4>;
|
||||
var camSlicedP: Array<Mat4> = null;
|
||||
var cascadeSplit: Array<kha.FastFloat>;
|
||||
var bias = Mat4.identity();
|
||||
#else
|
||||
var camSlicedP: Mat4 = null;
|
||||
#end
|
||||
#end // rp_shadowmap
|
||||
|
||||
#if (lnx_csm || lnx_clusters)
|
||||
static var helpMat = Mat4.identity();
|
||||
#end
|
||||
|
||||
// Clusters
|
||||
#if lnx_clusters
|
||||
static var slicesX = 16;
|
||||
static var slicesY = 16;
|
||||
static var slicesZ = 16;
|
||||
static inline var maxLights = getMaxLights();
|
||||
public static inline var maxLightsCluster = getMaxLightsCluster(); // Mirror shader constant
|
||||
static inline var clusterNear = 3.0;
|
||||
public static var lightsArray: Float32Array = null;
|
||||
#if lnx_spot
|
||||
public static var lightsArraySpot: Float32Array = null;
|
||||
#end
|
||||
public static var clustersData: kha.Image = null;
|
||||
static var lpos = new Vec4();
|
||||
public static var LWVPMatrixArray: Float32Array = null;
|
||||
#end // lnx_clusters
|
||||
|
||||
public var V: Mat4 = Mat4.identity();
|
||||
public var P: Mat4 = null;
|
||||
public var VP: Mat4 = Mat4.identity();
|
||||
|
||||
public var frustumPlanes: Array<FrustumPlane> = null;
|
||||
static var m = Mat4.identity();
|
||||
static var eye = new Vec4();
|
||||
#if rp_shadowmap
|
||||
static var corners: Array<Vec4> = null;
|
||||
#end
|
||||
|
||||
public function new(data: LightData) {
|
||||
super();
|
||||
|
||||
this.data = data;
|
||||
|
||||
var type = data.raw.type;
|
||||
var fov = data.raw.fov;
|
||||
|
||||
if (type == "sun") {
|
||||
#if rp_shadowmap
|
||||
if (corners == null) {
|
||||
corners = [];
|
||||
for (i in 0...8) corners.push(new Vec4());
|
||||
}
|
||||
P = Mat4.identity();
|
||||
#else
|
||||
P = Mat4.ortho(-1, 1, -1, 1, data.raw.near_plane, data.raw.far_plane);
|
||||
#end
|
||||
#if lnx_shadowmap_atlas
|
||||
this.shadowMapScale = 1.0;
|
||||
#end
|
||||
}
|
||||
else if (type == "point" || type == "area") {
|
||||
P = Mat4.persp(fov, 1, data.raw.near_plane, data.raw.far_plane);
|
||||
}
|
||||
else if (type == "spot") {
|
||||
P = Mat4.persp(fov, 1, data.raw.near_plane, data.raw.far_plane);
|
||||
}
|
||||
|
||||
Scene.active.lights.push(this);
|
||||
}
|
||||
|
||||
override public function remove() {
|
||||
if (Scene.active != null) Scene.active.lights.remove(this);
|
||||
final rp = RenderPath.active;
|
||||
if (rp.light == this) { rp.light = null; }
|
||||
if (rp.point == this) { rp.point = null; }
|
||||
else if (rp.sun == this) { rp.sun = null; }
|
||||
#if rp_shadowmap
|
||||
#if lnx_shadowmap_atlas
|
||||
if (tileNotifyOnRemove != null) {
|
||||
tileNotifyOnRemove();
|
||||
tileNotifyOnRemove = null;
|
||||
}
|
||||
#end
|
||||
#end
|
||||
super.remove();
|
||||
}
|
||||
|
||||
public function buildMatrix(camera: CameraObject) {
|
||||
transform.buildMatrix();
|
||||
if (data.raw.type == "sun") { // Cover camera frustum
|
||||
#if (rp_shadowmap && !lnx_csm) // Otherwise set cascades on mesh draw
|
||||
setCascade(camera, 0);
|
||||
#else
|
||||
V.getInverse(transform.world);
|
||||
updateViewFrustum(camera);
|
||||
#end
|
||||
}
|
||||
else { // Point, spot, area
|
||||
V.getInverse(transform.world);
|
||||
updateViewFrustum(camera);
|
||||
}
|
||||
}
|
||||
|
||||
#if rp_shadowmap
|
||||
|
||||
static inline function setCorners() {
|
||||
corners[0].set(-1.0, -1.0, 1.0);
|
||||
corners[1].set(-1.0, -1.0, -1.0);
|
||||
corners[2].set(-1.0, 1.0, 1.0);
|
||||
corners[3].set(-1.0, 1.0, -1.0);
|
||||
corners[4].set(1.0, -1.0, 1.0);
|
||||
corners[5].set(1.0, -1.0, -1.0);
|
||||
corners[6].set(1.0, 1.0, 1.0);
|
||||
corners[7].set(1.0, 1.0, -1.0);
|
||||
}
|
||||
|
||||
static inline function mix(a: Float, b: Float, f: Float): Float {
|
||||
return a * (1 - f) + b * f;
|
||||
}
|
||||
|
||||
public function setCascade(camera: CameraObject, cascade: Int) {
|
||||
m.setFrom(camera.V);
|
||||
|
||||
#if lnx_csm
|
||||
if (camSlicedP == null) {
|
||||
camSlicedP = [];
|
||||
cascadeSplit = [];
|
||||
var ortho = camera.data.raw.ortho;
|
||||
if (ortho == null) {
|
||||
var aspect = camera.data.raw.aspect != null ? camera.data.raw.aspect : iron.App.w() / iron.App.h();
|
||||
var fov = camera.data.raw.fov;
|
||||
var near = camera.data.raw.near_plane;
|
||||
var far = camera.data.raw.far_plane;
|
||||
var factor = cascadeCount > 2 ? cascadeSplitFactor : cascadeSplitFactor * 0.25;
|
||||
for (i in 0...cascadeCount) {
|
||||
var f = i + 1.0;
|
||||
var cfar = mix(
|
||||
near + (f / cascadeCount) * (far - near),
|
||||
near * Math.pow(far / near, f / cascadeCount),
|
||||
factor);
|
||||
cascadeSplit.push(cfar);
|
||||
camSlicedP.push(Mat4.persp(fov, aspect, near, cfar));
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (i in 0...cascadeCount) {
|
||||
cascadeSplit.push(data.raw.far_plane);
|
||||
camSlicedP.push(Mat4.ortho(ortho[0], ortho[1], ortho[2], ortho[3], data.raw.near_plane, data.raw.far_plane));
|
||||
}
|
||||
}
|
||||
}
|
||||
m.multmat(camSlicedP[cascade]);
|
||||
#else
|
||||
if (camSlicedP == null) { // Fit to light far plane
|
||||
var ortho = camera.data.raw.ortho;
|
||||
if (ortho == null) {
|
||||
var fov = camera.data.raw.fov;
|
||||
var near = data.raw.near_plane;
|
||||
var far = data.raw.far_plane;
|
||||
var aspect = camera.data.raw.aspect != null ? camera.data.raw.aspect : iron.App.w() / iron.App.h();
|
||||
camSlicedP = Mat4.persp(fov, aspect, near, far);
|
||||
}
|
||||
else {
|
||||
// camSlicedP = camera.P;
|
||||
camSlicedP = Mat4.ortho(ortho[0], ortho[1], ortho[2], ortho[3], data.raw.near_plane, data.raw.far_plane);
|
||||
}
|
||||
}
|
||||
m.multmat(camSlicedP);
|
||||
#end
|
||||
|
||||
m.getInverse(m);
|
||||
V.getInverse(transform.world);
|
||||
V.toRotation();
|
||||
m.multmat(V);
|
||||
setCorners();
|
||||
for (v in corners) {
|
||||
v.applymat4(m);
|
||||
v.set(v.x / v.w, v.y / v.w, v.z / v.w);
|
||||
}
|
||||
|
||||
var minx = corners[0].x;
|
||||
var miny = corners[0].y;
|
||||
var minz = corners[0].z;
|
||||
var maxx = corners[0].x;
|
||||
var maxy = corners[0].y;
|
||||
var maxz = corners[0].z;
|
||||
for (v in corners) {
|
||||
if (v.x < minx) minx = v.x;
|
||||
if (v.x > maxx) maxx = v.x;
|
||||
if (v.y < miny) miny = v.y;
|
||||
if (v.y > maxy) maxy = v.y;
|
||||
if (v.z < minz) minz = v.z;
|
||||
if (v.z > maxz) maxz = v.z;
|
||||
}
|
||||
|
||||
// Adjust frustum size by longest diagonal - fix rotation swim
|
||||
var diag0 = Vec4.distance(corners[0], corners[7]);
|
||||
var offx = (diag0 - (maxx - minx)) * 0.5;
|
||||
var offy = (diag0 - (maxy - miny)) * 0.5;
|
||||
minx -= offx;
|
||||
maxx += offx;
|
||||
miny -= offy;
|
||||
maxy += offy;
|
||||
|
||||
// Snap to texel coords - fix translation swim
|
||||
var smsize = data.raw.shadowmap_size;
|
||||
#if lnx_csm // Cascades
|
||||
smsize = Std.int(smsize / 4);
|
||||
#end
|
||||
var worldPerTexelX = (maxx - minx) / smsize;
|
||||
var worldPerTexelY = (maxy - miny) / smsize;
|
||||
var worldPerTexelZ = (maxz - minz) / smsize;
|
||||
minx = Math.floor(minx / worldPerTexelX) * worldPerTexelX;
|
||||
miny = Math.floor(miny / worldPerTexelY) * worldPerTexelY;
|
||||
minz = Math.floor(minz / worldPerTexelZ) * worldPerTexelZ;
|
||||
maxx = Math.floor(maxx / worldPerTexelX) * worldPerTexelX;
|
||||
maxy = Math.floor(maxy / worldPerTexelY) * worldPerTexelY;
|
||||
maxz = Math.floor(maxz / worldPerTexelZ) * worldPerTexelZ;
|
||||
|
||||
var hx = (maxx - minx) / 2;
|
||||
var hy = (maxy - miny) / 2;
|
||||
var hz = (maxz - minz) / 2;
|
||||
V._30 = -(minx + hx);
|
||||
V._31 = -(miny + hy);
|
||||
V._32 = -(minz + hz);
|
||||
|
||||
// (-hz * 4 * cascadeBounds) - include shadow casters out of view frustum
|
||||
m = Mat4.ortho(-hx, hx, -hy, hy, -hz * 4 * cascadeBounds, hz);
|
||||
P.setFrom(m);
|
||||
|
||||
updateViewFrustum(camera);
|
||||
|
||||
#if lnx_csm
|
||||
if (cascadeVP == null) {
|
||||
cascadeVP = [];
|
||||
for (i in 0...cascadeCount) {
|
||||
cascadeVP.push(Mat4.identity());
|
||||
}
|
||||
}
|
||||
cascadeVP[cascade].setFrom(VP);
|
||||
#end
|
||||
}
|
||||
#end // rp_shadowmap
|
||||
|
||||
function updateViewFrustum(camera: CameraObject) {
|
||||
VP.multmats(P, V);
|
||||
|
||||
// Frustum culling enabled
|
||||
if (camera.data.raw.frustum_culling) {
|
||||
if (frustumPlanes == null) {
|
||||
frustumPlanes = [];
|
||||
for (i in 0...6) frustumPlanes.push(new FrustumPlane());
|
||||
}
|
||||
CameraObject.buildViewFrustum(VP, frustumPlanes);
|
||||
}
|
||||
}
|
||||
|
||||
public function setCubeFace(face: Int, camera: CameraObject) {
|
||||
// Set matrix to match cubemap face
|
||||
eye.set(transform.worldx(), transform.worldy(), transform.worldz());
|
||||
#if (!kha_opengl && !kha_webgl && !lnx_shadowmap_atlas)
|
||||
var flip = (face == 2 || face == 3) ? true : false; // Flip +Y, -Y
|
||||
#else
|
||||
var flip = false;
|
||||
#end
|
||||
CameraObject.setCubeFace(V, eye, face, flip);
|
||||
updateViewFrustum(camera);
|
||||
}
|
||||
|
||||
#if lnx_csm
|
||||
public function getCascadeData(): Float32Array {
|
||||
// Cascade mats + split distances
|
||||
if (cascadeData == null) {
|
||||
cascadeData = new Float32Array(cascadeCount * 16 + 4);
|
||||
}
|
||||
if (cascadeVP == null) return cascadeData;
|
||||
|
||||
// 4 cascade mats + split distances
|
||||
for (i in 0...cascadeCount) {
|
||||
m.setFrom(cascadeVP[i]);
|
||||
bias.setFrom(Uniforms.biasMat);
|
||||
#if (!lnx_shadowmap_atlas)
|
||||
bias._00 /= cascadeCount; // Atlas offset
|
||||
bias._30 /= cascadeCount;
|
||||
bias._30 += i * (1 / cascadeCount);
|
||||
#else
|
||||
// tile matrix
|
||||
helpMat.setIdentity();
|
||||
// scale [0-1] coords to [0-tilescale]
|
||||
helpMat._00 = this.tileScale[i];
|
||||
helpMat._11 = this.tileScale[i];
|
||||
// offset coordinate start from [0, 0] to [tile-start-x, tile-start-y]
|
||||
helpMat._30 = this.tileOffsetX[i];
|
||||
helpMat._31 = this.tileOffsetY[i];
|
||||
bias.multmat(helpMat);
|
||||
#if (!kha_opengl)
|
||||
helpMat.setIdentity();
|
||||
helpMat._11 = -1.0;
|
||||
helpMat._31 = 1.0;
|
||||
bias.multmat(helpMat);
|
||||
#end
|
||||
#end
|
||||
m.multmat(bias);
|
||||
cascadeData[i * 16] = m._00;
|
||||
cascadeData[i * 16 + 1] = m._01;
|
||||
cascadeData[i * 16 + 2] = m._02;
|
||||
cascadeData[i * 16 + 3] = m._03;
|
||||
cascadeData[i * 16 + 4] = m._10;
|
||||
cascadeData[i * 16 + 5] = m._11;
|
||||
cascadeData[i * 16 + 6] = m._12;
|
||||
cascadeData[i * 16 + 7] = m._13;
|
||||
cascadeData[i * 16 + 8] = m._20;
|
||||
cascadeData[i * 16 + 9] = m._21;
|
||||
cascadeData[i * 16 + 10] = m._22;
|
||||
cascadeData[i * 16 + 11] = m._23;
|
||||
cascadeData[i * 16 + 12] = m._30;
|
||||
cascadeData[i * 16 + 13] = m._31;
|
||||
cascadeData[i * 16 + 14] = m._32;
|
||||
cascadeData[i * 16 + 15] = m._33;
|
||||
}
|
||||
cascadeData[cascadeCount * 16 ] = cascadeSplit[0];
|
||||
cascadeData[cascadeCount * 16 + 1] = cascadeSplit[1];
|
||||
cascadeData[cascadeCount * 16 + 2] = cascadeSplit[2];
|
||||
cascadeData[cascadeCount * 16 + 3] = cascadeSplit[3];
|
||||
return cascadeData;
|
||||
}
|
||||
#end // lnx_csm
|
||||
|
||||
#if lnx_clusters
|
||||
|
||||
// Centralize discarding conditions when iterating over lights
|
||||
// Important to avoid issues later with "misaligned" data in uniforms (lightsArray, clusterData, LWVPSpotArray)
|
||||
public inline static function discardLight(light: LightObject) {
|
||||
return !light.visible || light.data.raw.strength == 0.0 || light.data.raw.type == "sun";
|
||||
}
|
||||
// Discarding conditions but with culling included
|
||||
public inline static function discardLightCulled(light: LightObject) {
|
||||
return #if lnx_shadowmap_atlas light.culledLight || #end discardLight(light);
|
||||
}
|
||||
|
||||
#if (lnx_shadowmap_atlas && lnx_shadowmap_atlas_lod)
|
||||
// Arbitrary function to map from [0-16] to [1.0-0.0]
|
||||
public inline static function zToShadowMapScale(z: Int, max: Int): Float {
|
||||
return 0.25 * Math.sqrt(-z + max);
|
||||
}
|
||||
#end
|
||||
|
||||
static function getRadius(strength: kha.FastFloat): kha.FastFloat {
|
||||
// (1.0 / (dist * dist)) * strength = 0.01
|
||||
return Math.sqrt(strength / 0.004);
|
||||
}
|
||||
|
||||
inline static function distSliceX(f: Float, lpos: Vec4): Float {
|
||||
return (lpos.x - f * lpos.z) / Math.sqrt(1.0 + f * f);
|
||||
}
|
||||
|
||||
inline static function distSliceY(f: Float, lpos: Vec4): Float {
|
||||
return (lpos.y - f * lpos.z) / Math.sqrt(1.0 + f * f);
|
||||
}
|
||||
|
||||
static function sliceToDist(camera: CameraObject, z: Int): Float {
|
||||
var cnear = clusterNear + camera.data.raw.near_plane;
|
||||
switch (z) {
|
||||
case 0:
|
||||
return camera.data.raw.near_plane;
|
||||
case 1:
|
||||
return cnear;
|
||||
default: {
|
||||
var depthl = (z - 1) / (slicesZ - 1);
|
||||
return Math.exp(depthl * Math.log(camera.data.raw.far_plane - cnear + 1.0)) + cnear - 1.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static function updateClusters(camera: CameraObject) {
|
||||
// Reference: https://newq.net/publications/more/s2015-many-lights-course
|
||||
var lights = Scene.active.lights;
|
||||
|
||||
#if lnx_spot // Point lamps first
|
||||
lights.sort(function(a, b): Int {
|
||||
return a.data.raw.type >= b.data.raw.type ? 1 : -1;
|
||||
});
|
||||
#end
|
||||
|
||||
if (clustersData == null) {
|
||||
var lines = #if (lnx_spot) 2 #else 1 #end;
|
||||
clustersData = kha.Image.create(slicesX * slicesY * slicesZ, lines + maxLightsCluster, TextureFormat.L8, Usage.DynamicUsage);
|
||||
}
|
||||
|
||||
var bytes = clustersData.lock();
|
||||
|
||||
var stride = slicesX * slicesY * slicesZ;
|
||||
for (i in 0...stride) {
|
||||
bytes.set(i, 0);
|
||||
#if lnx_spot
|
||||
bytes.set(i + stride * (maxLightsCluster + 1), 0);
|
||||
#end
|
||||
}
|
||||
|
||||
var fovtan = Math.tan(camera.data.raw.fov * 0.5);
|
||||
var stepY = (2.0 * fovtan) / slicesY;
|
||||
var aspect = RenderPath.active.currentW / RenderPath.active.currentH;
|
||||
var stepX = (2.0 * fovtan * aspect) / slicesX;
|
||||
|
||||
var n = lights.length > maxLights ? maxLights : lights.length;
|
||||
var i = 0;
|
||||
for (l in lights) {
|
||||
if (discardLight(l)) continue;
|
||||
if (i >= n) break;
|
||||
// Light bounds
|
||||
lpos.set(l.transform.worldx(), l.transform.worldy(), l.transform.worldz());
|
||||
lpos.applymat4(camera.V);
|
||||
lpos.z *= -1.0;
|
||||
var radius = getRadius(l.data.raw.strength);
|
||||
var minX = 0;
|
||||
var minY = 0;
|
||||
var minZ = 0;
|
||||
var maxX = slicesX;
|
||||
var maxY = slicesY;
|
||||
var maxZ = slicesZ;
|
||||
while (minX <= slicesX) {
|
||||
if (distSliceX(stepX * (minX + 1 - slicesX * 0.5), lpos) <= radius) break;
|
||||
minX++;
|
||||
}
|
||||
while (maxX >= minX) {
|
||||
if (-distSliceX(stepX * (maxX - 1 - slicesX * 0.5), lpos) <= radius) { maxX--; break; }
|
||||
maxX--;
|
||||
}
|
||||
while (minY <= slicesY) {
|
||||
if (distSliceY(stepY * (minY + 1 - slicesY * 0.5), lpos) <= radius) break;
|
||||
minY++;
|
||||
}
|
||||
while (maxY >= minY) {
|
||||
if (-distSliceY(stepY * (maxY - 1 - slicesY * 0.5), lpos) <= radius) { maxY--; break; }
|
||||
maxY--;
|
||||
}
|
||||
while (minZ <= slicesZ) {
|
||||
if (sliceToDist(camera, minZ + 1) >= lpos.z - radius) break;
|
||||
minZ++;
|
||||
}
|
||||
while (maxZ >= minZ) {
|
||||
if (sliceToDist(camera, maxZ - 1) <= lpos.z + radius) break;
|
||||
maxZ--;
|
||||
}
|
||||
#if lnx_shadowmap_atlas
|
||||
l.culledLight = maxZ < 0 || minX > maxX || minY > maxY;
|
||||
l.shadowMapScale = l.culledLight ? 0.0 : #if lnx_shadowmap_atlas_lod zToShadowMapScale(minZ, slicesZ) #else 1.0 #end;
|
||||
// Discard lights that are outside of the view
|
||||
if (l.culledLight) {
|
||||
continue;
|
||||
}
|
||||
#end
|
||||
// Mark affected clusters
|
||||
for (z in minZ...maxZ + 1) {
|
||||
for (y in minY...maxY + 1) {
|
||||
for (x in minX...maxX + 1) {
|
||||
var cluster = x + y * slicesX + z * slicesX * slicesY;
|
||||
var numLights = bytes.get(cluster);
|
||||
if (numLights < maxLightsCluster) {
|
||||
numLights++;
|
||||
bytes.set(cluster, numLights);
|
||||
bytes.set(cluster + stride * numLights, i);
|
||||
#if lnx_spot
|
||||
if (l.data.raw.type == "spot") {
|
||||
// Last line
|
||||
var numSpots = bytes.get(cluster + stride * (maxLightsCluster + 1)) + 1;
|
||||
bytes.set(cluster + stride * (maxLightsCluster + 1), numSpots);
|
||||
}
|
||||
#end
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
i++;
|
||||
}
|
||||
clustersData.unlock();
|
||||
|
||||
updateLightsArray(); // TODO: only update on light change
|
||||
}
|
||||
|
||||
static function updateLightsArray() {
|
||||
if (lightsArray == null) { // vec4x3 - 1: pos, a, color, b, 2: dir, c
|
||||
lightsArray = new Float32Array(maxLights * 4 * 3);
|
||||
#if lnx_spot
|
||||
lightsArraySpot = new Float32Array(maxLights * 4 * 2);
|
||||
#end
|
||||
}
|
||||
var lights = Scene.active.lights;
|
||||
var n = lights.length > maxLights ? maxLights : lights.length;
|
||||
var i = 0;
|
||||
for (l in lights) {
|
||||
if (discardLightCulled(l)) continue;
|
||||
if (i >= n) break;
|
||||
|
||||
// light position
|
||||
lightsArray[i * 12 ] = l.transform.worldx();
|
||||
lightsArray[i * 12 + 1] = l.transform.worldy();
|
||||
lightsArray[i * 12 + 2] = l.transform.worldz();
|
||||
lightsArray[i * 12 + 3] = 0.0; // padding or spot scale x
|
||||
|
||||
// light color
|
||||
var f = l.data.raw.strength;
|
||||
lightsArray[i * 12 + 4] = l.data.raw.color[0] * f;
|
||||
lightsArray[i * 12 + 5] = l.data.raw.color[1] * f;
|
||||
lightsArray[i * 12 + 6] = l.data.raw.color[2] * f;
|
||||
lightsArray[i * 12 + 7] = 0.0; // padding or spot scale y
|
||||
|
||||
// other data
|
||||
lightsArray[i * 12 + 8] = l.data.raw.shadows_bias; // bias
|
||||
lightsArray[i * 12 + 9] = 0.0; // cutoff for detecting spot
|
||||
lightsArray[i * 12 + 10] = l.data.raw.cast_shadow ? 1.0 : 0.0; // hasShadows
|
||||
lightsArray[i * 12 + 11] = 0.0; // padding
|
||||
|
||||
#if lnx_spot
|
||||
if (l.data.raw.type == "spot") {
|
||||
lightsArray[i * 12 + 9] = l.data.raw.spot_size;
|
||||
|
||||
var dir = l.look().normalize();
|
||||
lightsArraySpot[i * 8 ] = dir.x;
|
||||
lightsArraySpot[i * 8 + 1] = dir.y;
|
||||
lightsArraySpot[i * 8 + 2] = dir.z;
|
||||
lightsArraySpot[i * 8 + 3] = l.data.raw.spot_blend;
|
||||
|
||||
// Premultiply scale with z component
|
||||
var scale = l.transform.scale;
|
||||
lightsArray[i * 12 + 3] = scale.z == 0.0 ? 0.0 : scale.x / scale.z;
|
||||
lightsArray[i * 12 + 7] = scale.z == 0.0 ? 0.0 : scale.y / scale.z;
|
||||
|
||||
final right = l.right().normalize();
|
||||
lightsArraySpot[i * 8 + 4] = right.x;
|
||||
lightsArraySpot[i * 8 + 5] = right.y;
|
||||
lightsArraySpot[i * 8 + 6] = right.z;
|
||||
lightsArraySpot[i * 8 + 7] = 0.0; // padding
|
||||
}
|
||||
#end
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
public static function updateLWVPMatrixArray(object: Object, type: String) {
|
||||
if (LWVPMatrixArray == null) {
|
||||
LWVPMatrixArray = new Float32Array(maxLightsCluster * 16);
|
||||
}
|
||||
|
||||
var lights = Scene.active.lights;
|
||||
var n = lights.length > maxLightsCluster ? maxLightsCluster : lights.length;
|
||||
var i = 0;
|
||||
|
||||
for (light in lights) {
|
||||
if (i >= n) {
|
||||
break;
|
||||
}
|
||||
if (discardLightCulled(light)) continue;
|
||||
if (light.data.raw.type == type) {
|
||||
m.setFrom(light.VP);
|
||||
m.multmat(Uniforms.biasMat);
|
||||
#if lnx_shadowmap_atlas
|
||||
// tile matrix
|
||||
helpMat.setIdentity();
|
||||
// scale [0-1] coords to [0-tilescale]
|
||||
helpMat._00 = light.tileScale[0];
|
||||
helpMat._11 = light.tileScale[0];
|
||||
// offset coordinate start from [0, 0] to [tile-start-x, tile-start-y]
|
||||
helpMat._30 = light.tileOffsetX[0];
|
||||
helpMat._31 = light.tileOffsetY[0];
|
||||
m.multmat(helpMat);
|
||||
#if (!kha_opengl)
|
||||
helpMat.setIdentity();
|
||||
helpMat._11 = -1.0;
|
||||
helpMat._31 = 1.0;
|
||||
m.multmat(helpMat);
|
||||
#end
|
||||
#end
|
||||
|
||||
LWVPMatrixArray[i * 16 ] = m._00;
|
||||
LWVPMatrixArray[i * 16 + 1] = m._01;
|
||||
LWVPMatrixArray[i * 16 + 2] = m._02;
|
||||
LWVPMatrixArray[i * 16 + 3] = m._03;
|
||||
LWVPMatrixArray[i * 16 + 4] = m._10;
|
||||
LWVPMatrixArray[i * 16 + 5] = m._11;
|
||||
LWVPMatrixArray[i * 16 + 6] = m._12;
|
||||
LWVPMatrixArray[i * 16 + 7] = m._13;
|
||||
LWVPMatrixArray[i * 16 + 8] = m._20;
|
||||
LWVPMatrixArray[i * 16 + 9] = m._21;
|
||||
LWVPMatrixArray[i * 16 + 10] = m._22;
|
||||
LWVPMatrixArray[i * 16 + 11] = m._23;
|
||||
LWVPMatrixArray[i * 16 + 12] = m._30;
|
||||
LWVPMatrixArray[i * 16 + 13] = m._31;
|
||||
LWVPMatrixArray[i * 16 + 14] = m._32;
|
||||
LWVPMatrixArray[i * 16 + 15] = m._33;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
return LWVPMatrixArray;
|
||||
}
|
||||
|
||||
public static inline function getMaxLights(): Int {
|
||||
#if (rp_max_lights == 8)
|
||||
return 8;
|
||||
#elseif (rp_max_lights == 16)
|
||||
return 16;
|
||||
#elseif (rp_max_lights == 24)
|
||||
return 24;
|
||||
#elseif (rp_max_lights == 32)
|
||||
return 32;
|
||||
#elseif (rp_max_lights == 64)
|
||||
return 64;
|
||||
#else
|
||||
return 4;
|
||||
#end
|
||||
}
|
||||
|
||||
public static inline function getMaxLightsCluster(): Int {
|
||||
#if (rp_max_lights_cluster == 8)
|
||||
return 8;
|
||||
#elseif (rp_max_lights_cluster == 16)
|
||||
return 16;
|
||||
#elseif (rp_max_lights_cluster == 24)
|
||||
return 24;
|
||||
#elseif (rp_max_lights_cluster == 32)
|
||||
return 32;
|
||||
#elseif (rp_max_lights_cluster == 64)
|
||||
return 64;
|
||||
#else
|
||||
return 4;
|
||||
#end
|
||||
}
|
||||
#end // lnx_clusters
|
||||
|
||||
public inline function right(): Vec4 {
|
||||
return new Vec4(V._00, V._10, V._20);
|
||||
}
|
||||
|
||||
public inline function up(): Vec4 {
|
||||
return new Vec4(V._01, V._11, V._21);
|
||||
}
|
||||
|
||||
public inline function look(): Vec4 {
|
||||
return new Vec4(V._02, V._12, V._22);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user