cables_dev/cables/src/libs/cgl/shadergraph/cgl_shadergraph.js

import { Events } from "cables-shared-client";
import { ShaderGraphProgram } from "./cgl_shadergraphprogram.js";
 
const ShaderGraph = class extends Events
{
    constructor(op, portFrag, portVert)
    {
        super();
        this._op = op;
        this._portFrag = portFrag;
        this._portVert = portVert;
 
        this.progFrag = new ShaderGraphProgram(op, portFrag, "frag");
        this.progVert = new ShaderGraphProgram(op, portVert, "vert");
 
        this.progFrag.on("compiled", () => { this.emitEvent("compiled"); });
        this.progVert.on("compiled", () => { this.emitEvent("compiled"); });
 
        portFrag.on("change", () =>
        {
            this.progFrag.compile();
        });
        portVert.on("change", this.updateVertex.bind(this));
        portVert.on("onLinkChanged", this.updateVertex.bind(this));
    }
 
    getUniforms()
    {
        const arr = [];
 
        for (let i = 0; i < this.progFrag.uniforms.length; i++) arr.push(this.progFrag.uniforms[i]);
        for (let i = 0; i < this.progVert.uniforms.length; i++) arr.push(this.progVert.uniforms[i]);
        return arr;
    }
 
    updateVertex()
    {
        console.log("update vertex", this._portVert.isLinked());
 
        if (this._portVert.isLinked()) this.progVert.compile();
        else
        {
            this.progVert.finalSrc = CGL.Shader.getDefaultVertexShader();
            this.emitEvent("compiled");
        }
    }
 
    getSrcFrag() { return this.progFrag.finalSrc; }
 
    getSrcVert() { return this.progVert.finalSrc || CGL.Shader.getDefaultVertexShader(); }
};
 
ShaderGraph.convertTypes = function (typeTo, typeFrom, paramStr)
{
    // console.log(typeFrom, " to ", typeTo);
 
    if (typeTo == "sg_genType") return paramStr;
 
 
    if (typeFrom == "sg_texture" && typeTo == "sg_vec3") return paramStr + ".xyz";
 
    if (typeFrom == "sg_vec4" && typeTo == "sg_vec3") return paramStr + ".xyz";
    if (typeFrom == "sg_vec4" && typeTo == "sg_vec2") return paramStr + ".xy";
    if (typeFrom == "sg_vec4" && typeTo == "sg_float") return paramStr + ".x";
 
    if (typeFrom == "sg_vec3" && typeTo == "sg_vec2") return paramStr + ".xy";
    if (typeFrom == "sg_vec3" && typeTo == "sg_float") return paramStr + ".x";
 
    if (typeFrom == "sg_vec2" && typeTo == "sg_float") return paramStr + ".x";
 
    if (typeFrom == "sg_vec3" && typeTo == "sg_vec4") return "vec4(" + paramStr + ", 0.)";
 
    if (typeFrom == "sg_vec2" && typeTo == "sg_vec3") return "vec3(" + paramStr + ", 0.)";
    if (typeFrom == "sg_vec2" && typeTo == "sg_vec4") return "vec4(" + paramStr + ", 0., 0.)";
 
    if (typeFrom == "sg_float" && typeTo == "sg_vec2") return "vec2(" + paramStr + "," + paramStr + ")";
    if (typeFrom == "sg_float" && typeTo == "sg_vec3") return "vec3(" + paramStr + "," + paramStr + "," + paramStr + ")";
    if (typeFrom == "sg_float" && typeTo == "sg_vec4") return "vec4(" + paramStr + "," + paramStr + "," + paramStr + ", 0.0)";
 
    return "/* conversionfail: " + typeFrom + "->" + typeTo + " */";
};
 
ShaderGraph.getDefaultParameter = function (t)
{
    if (t == "sg_vec4") return "vec4(0., 0., 0., 0.)";
    if (t == "sg_vec3") return "vec3(0., 0., 0.)";
    if (t == "sg_vec2") return "vec2(0., 0.)";
    if (t == "sg_float") return "0.";
    if (t == "sg_genType") return "0.";
    return "/* no default: " + t + "*/";
};
 
ShaderGraph.typeConv = function (sgtype)
{
    return sgtype.substr(3);
};
 
 
ShaderGraph.shaderIdCounter = ShaderGraph.shaderIdCounter || 1;
ShaderGraph.getNewId = () =>
{
    return ++ShaderGraph.shaderIdCounter;
};
 
export { ShaderGraph };