playcanvas
Version:
Open-source WebGL/WebGPU 3D engine for the web
132 lines (131 loc) • 4.27 kB
JavaScript
var gsplatHybrid_default = `
attribute vertex_position: vec3f;
uniform viewport_size: vec4f;
uniform clipToViewZ: vec4f;
uniform view_index: u32;
uniform matrix_projection: mat4x4f;
uniform alphaClip: f32;
uniform alphaClipForward: f32;
var<storage, read> sortedIndices: array<u32>;
var<storage, read> projCache: array<u32>;
var<storage, read> numSplatsStorage: array<u32>;
varying gaussianUV: half2;
varying gaussianColor: half4;
varying id: f32;
varying vLinearDepth: f32;
varying @interpolate(flat) vPickId: u32;
uniform colorRampIntensity: f32;
var colorRamp: texture_2d<f32>;
var colorRampSampler: sampler;
const discardVec: vec4f = vec4f(0.0, 0.0, 2.0, 1.0);
@vertex
fn vertexMain(input: VertexInput) -> VertexOutput {
var output: VertexOutput;
let order = pcInstanceIndex * {GSPLAT_INSTANCE_SIZE}u + u32(vertex_position.z);
let numSplats = numSplatsStorage[0];
if (order >= numSplats) {
output.position = discardVec;
return output;
}
let cacheIdx = sortedIndices[order];
let base = cacheIdx * {CACHE_STRIDE}u;
let off = uniform.view_index * 2u;
let ndc = vec2f(
bitcast<f32>(projCache[base + off + 0u]),
bitcast<f32>(projCache[base + off + 1u])
);
let w = bitcast<f32>(projCache[base + 4u]);
let pz = (uniform.matrix_projection[2][2] / uniform.matrix_projection[2][3]) * w + uniform.matrix_projection[3][2];
let proj = vec4f(ndc * w, clamp(pz, 0.0, abs(w)), w);
let v1 = unpack2x16float(projCache[base + 5u]);
let v2 = unpack2x16float(projCache[base + 6u]);
let rgba = unpack4x8unorm(projCache[base + 7u]);
let alpha = half(rgba.a);
var clr: half4 = half4(half(rgba.r), half(rgba.g), half(rgba.b), alpha);
let proj = vec4f(
bitcast<f32>(projCache[base + 0u]),
bitcast<f32>(projCache[base + 1u]),
bitcast<f32>(projCache[base + 2u]),
bitcast<f32>(projCache[base + 3u])
);
let v1 = unpack2x16float(projCache[base + 4u]);
let v2 = unpack2x16float(projCache[base + 5u]);
let ba = unpack2x16float(projCache[base + 7u]);
let alpha = half(ba.y);
let pickId = projCache[base + 6u];
var clr: half4 = half4(half(0.0), half(0.0), half(0.0), alpha);
let rg = unpack2x16float(projCache[base + 6u]);
var clr: half4 = half4(half(rg.x), half(rg.y), half(ba.x), alpha);
let cornerUV = vec2f(vertex_position.xy);
let alphaClipValue = half(uniform.alphaClip);
let alphaClipValue = half(uniform.alphaClipForward);
let clip = min(half(1.0), sqrt(max(half(0.0), log(alpha / alphaClipValue))) * half(0.5));
let cornerClipped = cornerUV * f32(clip);
let c = vec2f(proj.w) * uniform.viewport_size.zw;
let pixelOffset = cornerClipped.x * v1 + cornerClipped.y * v2;
let clipOffset = pixelOffset * c;
output.position = proj + vec4f(clipOffset, 0.0, 0.0);
output.gaussianUV = half2(cornerClipped);
let viewDepth = proj.w;
let viewDepth = dot(uniform.clipToViewZ, proj);
let t: f32 = clamp(viewDepth / 20.0, 0.0, 1.0);
let rampColor: vec3f = textureSampleLevel(colorRamp, colorRampSampler, vec2f(t, 0.5), 0.0).rgb;
let outAlpha = alpha * half(1.0 / 32.0) * half(uniform.colorRampIntensity);
output.gaussianColor = half4(half3(rampColor), outAlpha);
output.gaussianColor = half4(
half3(prepareOutputFromGamma(max(vec3f(clr.xyz), vec3f(0.0)), viewDepth)),
alpha
);
output.id = f32(cacheIdx);
output.vLinearDepth = viewDepth;
output.vPickId = pickId;
return output;
}
`;
export {
gsplatHybrid_default as default
};