luboslenco
602 lines
20 KiB
TypeScript
602 lines
20 KiB
TypeScript
|
|
class RenderPathBase {
|
|
|
|
static taaFrame = 0;
|
|
static path: RenderPath;
|
|
static superSample = 1.0;
|
|
static lastX = -1.0;
|
|
static lastY = -1.0;
|
|
static bloomMipmaps: RenderTarget[];
|
|
static bloomCurrentMip = 0;
|
|
static bloomSampleScale: f32;
|
|
///if arm_voxels
|
|
static voxelsRes = 256;
|
|
static voxelsCreated = false;
|
|
///end
|
|
|
|
static init = (_path: RenderPath) => {
|
|
RenderPathBase.path = _path;
|
|
RenderPathBase.superSample = Config.raw.rp_supersample;
|
|
}
|
|
|
|
///if arm_voxels
|
|
static initVoxels = (targetName = "voxels") => {
|
|
if (Config.raw.rp_gi != true || RenderPathBase.voxelsCreated) return;
|
|
RenderPathBase.voxelsCreated = true;
|
|
|
|
{
|
|
let t = new RenderTargetRaw();
|
|
t.name = targetName;
|
|
t.format = "R8";
|
|
t.width = RenderPathBase.voxelsRes;
|
|
t.height = RenderPathBase.voxelsRes;
|
|
t.depth = RenderPathBase.voxelsRes;
|
|
t.is_image = true;
|
|
t.mipmaps = true;
|
|
RenderPathBase.path.createRenderTarget(t);
|
|
}
|
|
}
|
|
///end
|
|
|
|
static applyConfig = () => {
|
|
if (RenderPathBase.superSample != Config.raw.rp_supersample) {
|
|
RenderPathBase.superSample = Config.raw.rp_supersample;
|
|
for (let rt of RenderPathBase.path.renderTargets.values()) {
|
|
if (rt.raw.width == 0 && rt.raw.scale != null) {
|
|
rt.raw.scale = RenderPathBase.superSample;
|
|
}
|
|
}
|
|
RenderPathBase.path.resize();
|
|
}
|
|
///if arm_voxels
|
|
if (!RenderPathBase.voxelsCreated) RenderPathBase.initVoxels();
|
|
///end
|
|
}
|
|
|
|
static getSuperSampling = (): f32 => {
|
|
return RenderPathBase.superSample;
|
|
}
|
|
|
|
static drawCompass = (currentG: Graphics4) => {
|
|
if (Context.raw.showCompass) {
|
|
let scene = Scene.active;
|
|
let cam = scene.camera;
|
|
let compass: MeshObject = scene.getChild(".Compass") as MeshObject;
|
|
|
|
let _visible = compass.visible;
|
|
let _parent = compass.parent;
|
|
let _loc = compass.transform.loc;
|
|
let _rot = compass.transform.rot;
|
|
let crot = cam.transform.rot;
|
|
let ratio = App.w() / App.h();
|
|
let _P = cam.P;
|
|
cam.P = Mat4.ortho(-8 * ratio, 8 * ratio, -8, 8, -2, 2);
|
|
compass.visible = true;
|
|
compass.parent = cam;
|
|
compass.transform.loc = new Vec4(7.4 * ratio, 7.0, -1);
|
|
compass.transform.rot = new Quat(-crot.x, -crot.y, -crot.z, crot.w);
|
|
compass.transform.scale.set(0.4, 0.4, 0.4);
|
|
compass.transform.buildMatrix();
|
|
compass.frustumCulling = false;
|
|
compass.render(currentG, "overlay", []);
|
|
|
|
cam.P = _P;
|
|
compass.visible = _visible;
|
|
compass.parent = _parent;
|
|
compass.transform.loc = _loc;
|
|
compass.transform.rot = _rot;
|
|
compass.transform.buildMatrix();
|
|
}
|
|
}
|
|
|
|
static begin = () => {
|
|
// Begin split
|
|
if (Context.raw.splitView && !Context.raw.paint2dView) {
|
|
if (Context.raw.viewIndexLast == -1 && Context.raw.viewIndex == -1) {
|
|
// Begin split, draw right viewport first
|
|
Context.raw.viewIndex = 1;
|
|
}
|
|
else {
|
|
// Set current viewport
|
|
Context.raw.viewIndex = Input.getMouse().viewX > Base.w() / 2 ? 1 : 0;
|
|
}
|
|
|
|
let cam = Scene.active.camera;
|
|
if (Context.raw.viewIndexLast > -1) {
|
|
// Save current viewport camera
|
|
Camera.inst.views[Context.raw.viewIndexLast].setFrom(cam.transform.local);
|
|
}
|
|
|
|
let decal = Context.raw.tool == WorkspaceTool.ToolDecal || Context.raw.tool == WorkspaceTool.ToolText;
|
|
|
|
if (Context.raw.viewIndexLast != Context.raw.viewIndex || decal || !Config.raw.brush_3d) {
|
|
// Redraw on current viewport change
|
|
Context.raw.ddirty = 1;
|
|
}
|
|
|
|
cam.transform.setMatrix(Camera.inst.views[Context.raw.viewIndex]);
|
|
cam.buildMatrix();
|
|
cam.buildProjection();
|
|
}
|
|
|
|
// Match projection matrix jitter
|
|
let skipTaa = Context.raw.splitView || ((Context.raw.tool == WorkspaceTool.ToolClone || Context.raw.tool == WorkspaceTool.ToolBlur || Context.raw.tool == WorkspaceTool.ToolSmudge) && Context.raw.pdirty > 0);
|
|
Scene.active.camera.frame = skipTaa ? 0 : RenderPathBase.taaFrame;
|
|
Scene.active.camera.projectionJitter();
|
|
Scene.active.camera.buildMatrix();
|
|
}
|
|
|
|
static end = () => {
|
|
// End split
|
|
Context.raw.viewIndexLast = Context.raw.viewIndex;
|
|
Context.raw.viewIndex = -1;
|
|
|
|
if (Context.raw.foregroundEvent && !Input.getMouse().down()) {
|
|
Context.raw.foregroundEvent = false;
|
|
Context.raw.pdirty = 0;
|
|
}
|
|
|
|
RenderPathBase.taaFrame++;
|
|
}
|
|
|
|
static ssaa4 = (): bool => {
|
|
return Config.raw.rp_supersample == 4;
|
|
}
|
|
|
|
static isCached = (): bool => {
|
|
if (System.width == 0 || System.height == 0) return true;
|
|
|
|
let mouse = Input.getMouse();
|
|
let mx = RenderPathBase.lastX;
|
|
let my = RenderPathBase.lastY;
|
|
RenderPathBase.lastX = mouse.viewX;
|
|
RenderPathBase.lastY = mouse.viewY;
|
|
|
|
if (Context.raw.ddirty <= 0 && Context.raw.rdirty <= 0 && Context.raw.pdirty <= 0) {
|
|
if (mx != RenderPathBase.lastX || my != RenderPathBase.lastY || mouse.locked) Context.raw.ddirty = 0;
|
|
///if (krom_metal || krom_android)
|
|
if (Context.raw.ddirty > -6) {
|
|
///else
|
|
if (Context.raw.ddirty > -2) {
|
|
///end
|
|
RenderPathBase.path.setTarget("");
|
|
RenderPathBase.path.bindTarget("taa", "tex");
|
|
RenderPathBase.ssaa4() ?
|
|
RenderPathBase.path.drawShader("shader_datas/supersample_resolve/supersample_resolve") :
|
|
RenderPathBase.path.drawShader("shader_datas/copy_pass/copy_pass");
|
|
RenderPathPaint.commandsCursor();
|
|
if (Context.raw.ddirty <= 0) Context.raw.ddirty--;
|
|
}
|
|
RenderPathBase.end();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static commands = (drawCommands: ()=>void) => {
|
|
if (RenderPathBase.isCached()) return;
|
|
RenderPathBase.begin();
|
|
|
|
RenderPathPaint.begin();
|
|
RenderPathBase.drawSplit(drawCommands);
|
|
RenderPathBase.drawGbuffer();
|
|
RenderPathPaint.draw();
|
|
|
|
///if (krom_direct3d12 || krom_vulkan || krom_metal)
|
|
if (Context.raw.viewportMode == ViewportMode.ViewPathTrace) {
|
|
///if is_paint
|
|
let useLiveLayer = Context.raw.tool == WorkspaceTool.ToolMaterial;
|
|
///else
|
|
let useLiveLayer = false;
|
|
///end
|
|
RenderPathRaytrace.draw(useLiveLayer);
|
|
return;
|
|
}
|
|
///end
|
|
|
|
drawCommands();
|
|
RenderPathPaint.end();
|
|
RenderPathBase.end();
|
|
}
|
|
|
|
static drawBloom = (tex = "tex") => {
|
|
if (Config.raw.rp_bloom != false) {
|
|
if (RenderPathBase.bloomMipmaps == null) {
|
|
RenderPathBase.bloomMipmaps = [];
|
|
|
|
let prevScale = 1.0;
|
|
for (let i = 0; i < 10; ++i) {
|
|
let t = new RenderTargetRaw();
|
|
t.name = "bloom_mip_" + i;
|
|
t.width = 0;
|
|
t.height = 0;
|
|
t.scale = (prevScale *= 0.5);
|
|
t.format = "RGBA64";
|
|
RenderPathBase.bloomMipmaps.push(RenderPathBase.path.createRenderTarget(t));
|
|
}
|
|
|
|
RenderPathBase.path.loadShader("shader_datas/bloom_pass/bloom_downsample_pass");
|
|
RenderPathBase.path.loadShader("shader_datas/bloom_pass/bloom_upsample_pass");
|
|
|
|
Uniforms.externalIntLinks.push((_: any, __: any, link: string) => {
|
|
if (link == "_bloomCurrentMip") return RenderPathBase.bloomCurrentMip;
|
|
return null;
|
|
});
|
|
Uniforms.externalFloatLinks.push((_: any, __: any, link: string) => {
|
|
if (link == "_bloomSampleScale") return RenderPathBase.bloomSampleScale;
|
|
return null;
|
|
});
|
|
}
|
|
|
|
let bloomRadius = 6.5;
|
|
let minDim = Math.min(RenderPathBase.path.currentW, RenderPathBase.path.currentH);
|
|
let logMinDim = Math.max(1.0, Math.log2(minDim) + (bloomRadius - 8.0));
|
|
let numMips = Math.floor(logMinDim);
|
|
RenderPathBase.bloomSampleScale = 0.5 + logMinDim - numMips;
|
|
|
|
for (let i = 0; i < numMips; ++i) {
|
|
RenderPathBase.bloomCurrentMip = i;
|
|
RenderPathBase.path.setTarget(RenderPathBase.bloomMipmaps[i].raw.name);
|
|
RenderPathBase.path.clearTarget();
|
|
RenderPathBase.path.bindTarget(i == 0 ? tex : RenderPathBase.bloomMipmaps[i - 1].raw.name, "tex");
|
|
RenderPathBase.path.drawShader("shader_datas/bloom_pass/bloom_downsample_pass");
|
|
}
|
|
for (let i = 0; i < numMips; ++i) {
|
|
let mipLevel = numMips - 1 - i;
|
|
RenderPathBase.bloomCurrentMip = mipLevel;
|
|
RenderPathBase.path.setTarget(mipLevel == 0 ? tex : RenderPathBase.bloomMipmaps[mipLevel - 1].raw.name);
|
|
RenderPathBase.path.bindTarget(RenderPathBase.bloomMipmaps[mipLevel].raw.name, "tex");
|
|
RenderPathBase.path.drawShader("shader_datas/bloom_pass/bloom_upsample_pass");
|
|
}
|
|
}
|
|
}
|
|
|
|
static drawSplit = (drawCommands: ()=>void) => {
|
|
if (Context.raw.splitView && !Context.raw.paint2dView) {
|
|
Context.raw.ddirty = 2;
|
|
let cam = Scene.active.camera;
|
|
|
|
Context.raw.viewIndex = Context.raw.viewIndex == 0 ? 1 : 0;
|
|
cam.transform.setMatrix(Camera.inst.views[Context.raw.viewIndex]);
|
|
cam.buildMatrix();
|
|
cam.buildProjection();
|
|
|
|
RenderPathBase.drawGbuffer();
|
|
|
|
///if (krom_direct3d12 || krom_vulkan || krom_metal)
|
|
///if is_paint
|
|
let useLiveLayer = Context.raw.tool == WorkspaceTool.ToolMaterial;
|
|
///else
|
|
let useLiveLayer = false;
|
|
///end
|
|
Context.raw.viewportMode == ViewportMode.ViewPathTrace ? RenderPathRaytrace.draw(useLiveLayer) : drawCommands();
|
|
///else
|
|
drawCommands();
|
|
///end
|
|
|
|
Context.raw.viewIndex = Context.raw.viewIndex == 0 ? 1 : 0;
|
|
cam.transform.setMatrix(Camera.inst.views[Context.raw.viewIndex]);
|
|
cam.buildMatrix();
|
|
cam.buildProjection();
|
|
}
|
|
}
|
|
|
|
///if arm_voxels
|
|
static drawVoxels = () => {
|
|
if (Config.raw.rp_gi != false) {
|
|
let voxelize = Context.raw.ddirty > 0 && RenderPathBase.taaFrame > 0;
|
|
if (voxelize) {
|
|
RenderPathBase.path.clearImage("voxels", 0x00000000);
|
|
RenderPathBase.path.setTarget("");
|
|
RenderPathBase.path.setViewport(RenderPathBase.voxelsRes, RenderPathBase.voxelsRes);
|
|
RenderPathBase.path.bindTarget("voxels", "voxels");
|
|
if (MakeMaterial.heightUsed) {
|
|
let tid = 0; // Project.layers[0].id;
|
|
RenderPathBase.path.bindTarget("texpaint_pack" + tid, "texpaint_pack");
|
|
}
|
|
RenderPathBase.path.drawMeshes("voxel");
|
|
RenderPathBase.path.generateMipmaps("voxels");
|
|
}
|
|
}
|
|
}
|
|
///end
|
|
|
|
static initSSAO = () => {
|
|
{
|
|
let t = new RenderTargetRaw();
|
|
t.name = "singlea";
|
|
t.width = 0;
|
|
t.height = 0;
|
|
t.format = "R8";
|
|
t.scale = RenderPathBase.getSuperSampling();
|
|
RenderPathBase.path.createRenderTarget(t);
|
|
}
|
|
{
|
|
let t = new RenderTargetRaw();
|
|
t.name = "singleb";
|
|
t.width = 0;
|
|
t.height = 0;
|
|
t.format = "R8";
|
|
t.scale = RenderPathBase.getSuperSampling();
|
|
RenderPathBase.path.createRenderTarget(t);
|
|
}
|
|
RenderPathBase.path.loadShader("shader_datas/ssao_pass/ssao_pass");
|
|
RenderPathBase.path.loadShader("shader_datas/ssao_blur_pass/ssao_blur_pass_x");
|
|
RenderPathBase.path.loadShader("shader_datas/ssao_blur_pass/ssao_blur_pass_y");
|
|
}
|
|
|
|
static drawSSAO = () => {
|
|
let ssao = Config.raw.rp_ssao != false && Context.raw.cameraType == CameraType.CameraPerspective;
|
|
if (ssao && Context.raw.ddirty > 0 && RenderPathBase.taaFrame > 0) {
|
|
if (RenderPathBase.path.renderTargets.get("singlea") == null) {
|
|
RenderPathBase.initSSAO();
|
|
}
|
|
|
|
RenderPathBase.path.setTarget("singlea");
|
|
RenderPathBase.path.bindTarget("_main", "gbufferD");
|
|
RenderPathBase.path.bindTarget("gbuffer0", "gbuffer0");
|
|
RenderPathBase.path.drawShader("shader_datas/ssao_pass/ssao_pass");
|
|
|
|
RenderPathBase.path.setTarget("singleb");
|
|
RenderPathBase.path.bindTarget("singlea", "tex");
|
|
RenderPathBase.path.bindTarget("gbuffer0", "gbuffer0");
|
|
RenderPathBase.path.drawShader("shader_datas/ssao_blur_pass/ssao_blur_pass_x");
|
|
|
|
RenderPathBase.path.setTarget("singlea");
|
|
RenderPathBase.path.bindTarget("singleb", "tex");
|
|
RenderPathBase.path.bindTarget("gbuffer0", "gbuffer0");
|
|
RenderPathBase.path.drawShader("shader_datas/ssao_blur_pass/ssao_blur_pass_y");
|
|
}
|
|
}
|
|
|
|
static drawDeferredLight = () => {
|
|
RenderPathBase.path.setTarget("tex");
|
|
RenderPathBase.path.bindTarget("_main", "gbufferD");
|
|
RenderPathBase.path.bindTarget("gbuffer0", "gbuffer0");
|
|
RenderPathBase.path.bindTarget("gbuffer1", "gbuffer1");
|
|
let ssao = Config.raw.rp_ssao != false && Context.raw.cameraType == CameraType.CameraPerspective;
|
|
if (ssao && RenderPathBase.taaFrame > 0) {
|
|
RenderPathBase.path.bindTarget("singlea", "ssaotex");
|
|
}
|
|
else {
|
|
RenderPathBase.path.bindTarget("empty_white", "ssaotex");
|
|
}
|
|
|
|
let voxelao_pass = false;
|
|
///if arm_voxels
|
|
if (Config.raw.rp_gi != false) {
|
|
voxelao_pass = true;
|
|
RenderPathBase.path.bindTarget("voxels", "voxels");
|
|
}
|
|
///end
|
|
|
|
voxelao_pass ?
|
|
RenderPathBase.path.drawShader("shader_datas/deferred_light/deferred_light_voxel") :
|
|
RenderPathBase.path.drawShader("shader_datas/deferred_light/deferred_light");
|
|
|
|
///if (krom_direct3d11 || krom_direct3d12 || krom_metal || krom_vulkan)
|
|
RenderPathBase.path.setDepthFrom("tex", "gbuffer0"); // Bind depth for world pass
|
|
///end
|
|
|
|
RenderPathBase.path.setTarget("tex");
|
|
RenderPathBase.path.drawSkydome("shader_datas/world_pass/world_pass");
|
|
|
|
///if (krom_direct3d11 || krom_direct3d12 || krom_metal || krom_vulkan)
|
|
RenderPathBase.path.setDepthFrom("tex", "gbuffer1"); // Unbind depth
|
|
///end
|
|
}
|
|
|
|
static drawSSR = () => {
|
|
if (Config.raw.rp_ssr != false) {
|
|
if (RenderPathBase.path.cachedShaderContexts.get("shader_datas/ssr_pass/ssr_pass") == null) {
|
|
{
|
|
let t = new RenderTargetRaw();
|
|
t.name = "bufb";
|
|
t.width = 0;
|
|
t.height = 0;
|
|
t.format = "RGBA64";
|
|
RenderPathBase.path.createRenderTarget(t);
|
|
}
|
|
RenderPathBase.path.loadShader("shader_datas/ssr_pass/ssr_pass");
|
|
RenderPathBase.path.loadShader("shader_datas/ssr_blur_pass/ssr_blur_pass_x");
|
|
RenderPathBase.path.loadShader("shader_datas/ssr_blur_pass/ssr_blur_pass_y3_blend");
|
|
}
|
|
let targeta = "bufb";
|
|
let targetb = "gbuffer1";
|
|
|
|
RenderPathBase.path.setTarget(targeta);
|
|
RenderPathBase.path.bindTarget("tex", "tex");
|
|
RenderPathBase.path.bindTarget("_main", "gbufferD");
|
|
RenderPathBase.path.bindTarget("gbuffer0", "gbuffer0");
|
|
RenderPathBase.path.bindTarget("gbuffer1", "gbuffer1");
|
|
RenderPathBase.path.drawShader("shader_datas/ssr_pass/ssr_pass");
|
|
|
|
RenderPathBase.path.setTarget(targetb);
|
|
RenderPathBase.path.bindTarget(targeta, "tex");
|
|
RenderPathBase.path.bindTarget("gbuffer0", "gbuffer0");
|
|
RenderPathBase.path.drawShader("shader_datas/ssr_blur_pass/ssr_blur_pass_x");
|
|
|
|
RenderPathBase.path.setTarget("tex");
|
|
RenderPathBase.path.bindTarget(targetb, "tex");
|
|
RenderPathBase.path.bindTarget("gbuffer0", "gbuffer0");
|
|
RenderPathBase.path.drawShader("shader_datas/ssr_blur_pass/ssr_blur_pass_y3_blend");
|
|
}
|
|
}
|
|
|
|
// static drawMotionBlur = () => {
|
|
// if (Config.raw.rp_motionblur != false) {
|
|
// RenderPathBase.path.setTarget("buf");
|
|
// RenderPathBase.path.bindTarget("tex", "tex");
|
|
// RenderPathBase.path.bindTarget("gbuffer0", "gbuffer0");
|
|
// ///if (rp_motionblur == "Camera")
|
|
// {
|
|
// RenderPathBase.path.bindTarget("_main", "gbufferD");
|
|
// RenderPathBase.path.drawShader("shader_datas/motion_blur_pass/motion_blur_pass");
|
|
// }
|
|
// ///else
|
|
// {
|
|
// RenderPathBase.path.bindTarget("gbuffer2", "sveloc");
|
|
// RenderPathBase.path.drawShader("shader_datas/motion_blur_veloc_pass/motion_blur_veloc_pass");
|
|
// }
|
|
// ///end
|
|
// RenderPathBase.path.setTarget("tex");
|
|
// RenderPathBase.path.bindTarget("buf", "tex");
|
|
// RenderPathBase.path.drawShader("shader_datas/copy_pass/copy_pass");
|
|
// }
|
|
// }
|
|
|
|
// static drawHistogram = () => {
|
|
// {
|
|
// let t = new RenderTargetRaw();
|
|
// t.name = "histogram";
|
|
// t.width = 1;
|
|
// t.height = 1;
|
|
// t.format = "RGBA64";
|
|
// RenderPathBase.path.createRenderTarget(t);
|
|
|
|
// RenderPathBase.path.loadShader("shader_datas/histogram_pass/histogram_pass");
|
|
// }
|
|
|
|
// RenderPathBase.path.setTarget("histogram");
|
|
// RenderPathBase.path.bindTarget("taa", "tex");
|
|
// RenderPathBase.path.drawShader("shader_datas/histogram_pass/histogram_pass");
|
|
// }
|
|
|
|
static drawTAA = () => {
|
|
let current = RenderPathBase.taaFrame % 2 == 0 ? "buf2" : "taa2";
|
|
let last = RenderPathBase.taaFrame % 2 == 0 ? "taa2" : "buf2";
|
|
|
|
RenderPathBase.path.setTarget(current);
|
|
RenderPathBase.path.clearTarget(0x00000000);
|
|
RenderPathBase.path.bindTarget("buf", "colorTex");
|
|
RenderPathBase.path.drawShader("shader_datas/smaa_edge_detect/smaa_edge_detect");
|
|
|
|
RenderPathBase.path.setTarget("taa");
|
|
RenderPathBase.path.clearTarget(0x00000000);
|
|
RenderPathBase.path.bindTarget(current, "edgesTex");
|
|
RenderPathBase.path.drawShader("shader_datas/smaa_blend_weight/smaa_blend_weight");
|
|
|
|
RenderPathBase.path.setTarget(current);
|
|
RenderPathBase.path.bindTarget("buf", "colorTex");
|
|
RenderPathBase.path.bindTarget("taa", "blendTex");
|
|
RenderPathBase.path.bindTarget("gbuffer2", "sveloc");
|
|
RenderPathBase.path.drawShader("shader_datas/smaa_neighborhood_blend/smaa_neighborhood_blend");
|
|
|
|
let skipTaa = Context.raw.splitView;
|
|
if (skipTaa) {
|
|
RenderPathBase.path.setTarget("taa");
|
|
RenderPathBase.path.bindTarget(current, "tex");
|
|
RenderPathBase.path.drawShader("shader_datas/copy_pass/copy_pass");
|
|
}
|
|
else {
|
|
RenderPathBase.path.setTarget("taa");
|
|
RenderPathBase.path.bindTarget(current, "tex");
|
|
RenderPathBase.path.bindTarget(last, "tex2");
|
|
RenderPathBase.path.bindTarget("gbuffer2", "sveloc");
|
|
RenderPathBase.path.drawShader("shader_datas/taa_pass/taa_pass");
|
|
}
|
|
|
|
if (RenderPathBase.ssaa4()) {
|
|
RenderPathBase.path.setTarget("");
|
|
RenderPathBase.path.bindTarget(RenderPathBase.taaFrame % 2 == 0 ? "taa2" : "taa", "tex");
|
|
RenderPathBase.path.drawShader("shader_datas/supersample_resolve/supersample_resolve");
|
|
}
|
|
else {
|
|
RenderPathBase.path.setTarget("");
|
|
RenderPathBase.path.bindTarget(RenderPathBase.taaFrame == 0 ? current : "taa", "tex");
|
|
RenderPathBase.path.drawShader("shader_datas/copy_pass/copy_pass");
|
|
}
|
|
}
|
|
|
|
static drawGbuffer = () => {
|
|
RenderPathBase.path.setTarget("gbuffer0"); // Only clear gbuffer0
|
|
///if krom_metal
|
|
RenderPathBase.path.clearTarget(0x00000000, 1.0);
|
|
///else
|
|
RenderPathBase.path.clearTarget(null, 1.0);
|
|
///end
|
|
if (MakeMesh.layerPassCount == 1) {
|
|
RenderPathBase.path.setTarget("gbuffer2");
|
|
RenderPathBase.path.clearTarget(0xff000000);
|
|
}
|
|
RenderPathBase.path.setTarget("gbuffer0", ["gbuffer1", "gbuffer2"]);
|
|
let currentG = RenderPathBase.path.currentG;
|
|
RenderPathPaint.bindLayers();
|
|
RenderPathBase.path.drawMeshes("mesh");
|
|
RenderPathPaint.unbindLayers();
|
|
if (MakeMesh.layerPassCount > 1) {
|
|
RenderPathBase.makeGbufferCopyTextures();
|
|
for (let i = 1; i < MakeMesh.layerPassCount; ++i) {
|
|
let ping = i % 2 == 1 ? "_copy" : "";
|
|
let pong = i % 2 == 1 ? "" : "_copy";
|
|
if (i == MakeMesh.layerPassCount - 1) {
|
|
RenderPathBase.path.setTarget("gbuffer2" + ping);
|
|
RenderPathBase.path.clearTarget(0xff000000);
|
|
}
|
|
RenderPathBase.path.setTarget("gbuffer0" + ping, ["gbuffer1" + ping, "gbuffer2" + ping]);
|
|
RenderPathBase.path.bindTarget("gbuffer0" + pong, "gbuffer0");
|
|
RenderPathBase.path.bindTarget("gbuffer1" + pong, "gbuffer1");
|
|
RenderPathBase.path.bindTarget("gbuffer2" + pong, "gbuffer2");
|
|
RenderPathPaint.bindLayers();
|
|
RenderPathBase.path.drawMeshes("mesh" + i);
|
|
RenderPathPaint.unbindLayers();
|
|
}
|
|
if (MakeMesh.layerPassCount % 2 == 0) {
|
|
RenderPathBase.copyToGbuffer();
|
|
}
|
|
}
|
|
|
|
let hide = Operator.shortcut(Config.keymap.stencil_hide, ShortcutType.ShortcutDown) || Input.getKeyboard().down("control");
|
|
let isDecal = Base.isDecalLayer();
|
|
if (isDecal && !hide) LineDraw.render(currentG, Context.raw.layer.decalMat);
|
|
}
|
|
|
|
static makeGbufferCopyTextures = () => {
|
|
let copy = RenderPathBase.path.renderTargets.get("gbuffer0_copy");
|
|
if (copy == null || copy.image.width != RenderPathBase.path.renderTargets.get("gbuffer0").image.width || copy.image.height != RenderPathBase.path.renderTargets.get("gbuffer0").image.height) {
|
|
{
|
|
let t = new RenderTargetRaw();
|
|
t.name = "gbuffer0_copy";
|
|
t.width = 0;
|
|
t.height = 0;
|
|
t.format = "RGBA64";
|
|
t.scale = RenderPathBase.getSuperSampling();
|
|
t.depth_buffer = "main";
|
|
RenderPathBase.path.createRenderTarget(t);
|
|
}
|
|
{
|
|
let t = new RenderTargetRaw();
|
|
t.name = "gbuffer1_copy";
|
|
t.width = 0;
|
|
t.height = 0;
|
|
t.format = "RGBA64";
|
|
t.scale = RenderPathBase.getSuperSampling();
|
|
RenderPathBase.path.createRenderTarget(t);
|
|
}
|
|
{
|
|
let t = new RenderTargetRaw();
|
|
t.name = "gbuffer2_copy";
|
|
t.width = 0;
|
|
t.height = 0;
|
|
t.format = "RGBA64";
|
|
t.scale = RenderPathBase.getSuperSampling();
|
|
RenderPathBase.path.createRenderTarget(t);
|
|
}
|
|
|
|
///if krom_metal
|
|
// TODO: Fix depth attach for gbuffer0_copy on metal
|
|
// Use resize to re-create buffers from scratch for now
|
|
RenderPathBase.path.resize();
|
|
///end
|
|
}
|
|
}
|
|
|
|
static copyToGbuffer = () => {
|
|
RenderPathBase.path.setTarget("gbuffer0", ["gbuffer1", "gbuffer2"]);
|
|
RenderPathBase.path.bindTarget("gbuffer0_copy", "tex0");
|
|
RenderPathBase.path.bindTarget("gbuffer1_copy", "tex1");
|
|
RenderPathBase.path.bindTarget("gbuffer2_copy", "tex2");
|
|
RenderPathBase.path.drawShader("shader_datas/copy_mrt3_pass/copy_mrt3RGBA64_pass");
|
|
}
|
|
}
|