CustomShaderNode()

CustomShaderNode::CustomShaderNode	(	GLSLHandler *	handler,
		std::string	shader
	)

Definition at line 255 of file CustomShaderNode.cpp.

    :SNENode(handler)
{
    name = "Custom Shader";
    headerColor = ImColor(SHADER_VALUE_NODE_COLOR);
    shader = s;
    // Parse the shader
    std::stringstream ss(shader);
    std::string line;
    std::string codeStr = "";
    std::string metaStr = "";
    bool isCodeActive = false;
    bool isMetaActive = false;
 
    while(std::getline(ss, line))
    {
        if(line[0] == '#')
        {
            continue;
        }
 
        else if(line == "[META]")
        {
            isMetaActive = true;
        }
 
        else if(line == "[CODE]")
        {
            isCodeActive = true;
        }
 
        else if(line == "[/META]")
        {
            isMetaActive = false;
        }
 
        else if(line == "[/CODE]")
        {
            isCodeActive = false;
        }
 
        else if(isMetaActive)
        {
            metaStr += line + "\n";
        }
 
        else if(isCodeActive)
        {
            codeStr += line + "\n";
        }
    }
 
    // Load the meta data
    if(metaStr.size() > 0)
    {
        meta = nlohmann::json::parse(metaStr);
    }
 
    else
    {
        throw std::runtime_error("No meta data found in shader");
    }
 
    // Load the code
    if(codeStr.size() > 0)
    {
        code = codeStr;
    }
 
    else
    {
        throw std::runtime_error("No code found in shader");
    }
 
    // Load the data
    name = meta["name"];
    std::cout << "Loading Node : " << name << "\n";
    std::string paramsStr = "";
    int j = 0;
    
    if(meta.find("param_count") != meta.end())
    {
        paramCount = meta["param_count"];
        useArrayParams = true;
    }
    else
    {
        paramCount = 1;
        useArrayParams = false; 
    }
    int pss = meta["params"].size();
 
    for(std::string param : meta["params"])
    {
        std::string pType = param.substr(0, param.find(":"));
        std::string pName = param.substr(param.find(":") + 1);
        params.push_back(std::make_pair(pType, pName));
        if(useArrayParams)
            paramsStr += pType + " " + pName + "[" + STR(paramCount) + "]" + (j < pss - 1 ? ", " : "");
        else
            paramsStr += pType + " " + pName + (j < pss - 1 ? ", " : "");
        j++;
    }
 
    paramsStr += (params.size() == 0 ? "" : ", ") + std::string("int callerPin");
 
    func = new GLSLFunction(meta["fname"], paramsStr, meta["returns"]);
    func->name += STR(id);
    sharedDataTemplate.clear();
    int i = 0;
 
    for(auto it = meta["sharedData"].begin() ; it != meta["sharedData"].end() ; it++)
    {
        std::string alias = ReplaceString(it.key(), " ", "");
        if(it.value().find("alias") != it.value().end())
            alias = it.value()["alias"];
        sharedDataTemplate.push_back(SharedDataRep(it.key(), it.value()["type"], alias));
 
        if(it.value()["type"] == "float")
        {
            fData[i] = it.value()["default"].get<float>();
        }
 
        else if(it.value()["type"] == "bool")
        {
            bData[i] = it.value()["default"].get<bool>();
        }
 
        i++;
    }
 
    if(meta.find("output_pins") != meta.end())
    {
        std::string returns = meta["returns"];
        useMultipleOpins = true;
        for(std::string oPin : meta["output_pins"])
        {
            oPinStrs.push_back(oPin);
            if(meta["returns"] == "float")
            {
                outputPins.push_back(new SNEPin(NodeEditorPinType::Output, SNEPinType::SNEPinType_Float));
            }
            else if(meta["returns"] == "vec3")
            {
                outputPins.push_back(new SNEPin(NodeEditorPinType::Output, SNEPinType::SNEPinType_Float3));
            }
        }
    }
    else
    {
        if(meta["returns"] == "float")
        {
            outputPins.push_back(new SNEPin(NodeEditorPinType::Output, SNEPinType::SNEPinType_Float));
        }
        else if(meta["returns"] == "vec3")
        {
            outputPins.push_back(new SNEPin(NodeEditorPinType::Output, SNEPinType::SNEPinType_Float3));
        }
        else
        {
            std::string t = meta["returns"];
            throw std::runtime_error("Custom shader node does not support return type " + t);
        }
    }
 
 
    for(int k = 0 ; k < paramCount ; k++)   
    {
        for(auto &it : params)
        {
            if(it.first == "float")
            {
                inputPins.push_back(new SNEPin(NodeEditorPinType::Input, SNEPinType::SNEPinType_Float));
            }
    
            else if(it.first == "vec3")
            {
                inputPins.push_back(new SNEPin(NodeEditorPinType::Input, SNEPinType::SNEPinType_Float3));
            }
    
            else
            {
                throw std::runtime_error("Custom shader node does not support parameter type " + it.first);
            }
        }
    }
    headerColor = ImColor(meta["color"]["r"].get<int>(), meta["color"]["r"].get<int>(), meta["color"]["b"].get<int>());
}