GxGuiFormShaderGraph.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
#if GX_DEVELOP
 
GX_CORE_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
class GxGuiFormShaderGraph : public GxGuiForm
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    class GxGraphNode;
    class GxGraphNodeConst;
    class GxGraphNodeSampler;
    class GxGraphNodeOutput;
    class GxGraphNodeMaterialInput;
    class GxGraphNodeMaterialOutput;
    class GxGraphNodeCustom;
    class GxGraphNodeSwitch;
    class GxGraphConnect;
 
    //===========================================================================
    //===========================================================================
    class GxGraph : public GxClassBase
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GX_RTTI_CLASS(GxGraph, GxClassBase)
        // ClassBase継承クラス用禁止宣言
        GX_PROHIBIT_CLASS_BASE(GxGraph)
    private:
        enum OUTPUT_TYPE
        {
            PARAMETER = (1 << 0),   
            SAMPLER = (1 << 1),     
            ALL = 0xFFFFFFFF,       
        };
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxGraph(void) : _pNodeOutput(nullptr), _pNodeMaterialInput(nullptr) { initializeDynamicElements(); }
        ~GxGraph(void) override;
        void initializeDynamicElements(void);
        void terminateDynamicElements(void);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        void outputProgram(GX_CSTR outputPath, GX_CSTR resourcePath, b32 isGlsl);
        GxString getReference(GX_CSTR outputPath, GX_CSTR resourcePath, GxArray& references, b32 isGlsl, OUTPUT_TYPE outputType) const;
        b32 findReference(GX_CSTR name, const GxArray& references) const;
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        void getNodes(GxArrayClassBase& nodes, const GxRtti& rtti);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GxArrayClassBase    _dynamicElements;       
        GxArrayClassBase    _nodes;                 
        GxArrayClassBase    _inputNodes;            
        GxGraphNode*        _pNodeOutput;           
        GxGraphNode*        _pNodeMaterialInput;    
 
    };
 
    GX_RTTI_CLASS(GxGuiFormShaderGraph, GxGuiForm)
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxGuiFormShaderGraph)
 
private:
    static const f32 ZOOM_MIN;  
    static const f32 ZOOM_MAX;  
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxGuiFormShaderGraph(b32 isFunction);
    static void initializeStaticElements(void);
    static void terminateStaticElements(void);
private:
    GxGuiFormShaderGraph(void) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    void update(void) override;
    void onDraw(void) override;
    void onMouseWheel(const GxPoint2& position, s32 rotate) override;
    void onMouseDown(const GxPoint2& position, u32 button) override;
    void onMouseUp(const GxPoint2& position, u32 button) override;
    void onDoubleClick(const GxPoint2& position, u32 button) override;
    GxGraphNode* addNode(GxShaderGraphElement* pShaderElement);
    void removeNode(GxGraphNode* pNode);
    GxGraphNode* getNode(const GxPoint2& position);
private:
    void removeSelectNode(void);
    void removeSelectConnectAll(void);
    void createMenu(const GxPropertyTable& propertyTable, b32 useSearchBar);
    static void replaceStaticElements(GxGraph& graph);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
public:
    void setGraph(GxGraph& graph, GxRenderMaterial::PASS pass = GxRenderMaterial::PASS::MODEL);
    GxGraphNode* getSelectNode(void);
private:
    void getSelectNodes(GxArrayClassBase& nodes);
    GX_FORCE_INLINE static f32 getZoom(void) { return _zoom; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    static GxPoint2         _offset;            
    static f32              _zoom;              
    static GxArrayClassBase _staticElements;    
    GxGraph*                _pGraph;            
    GxGraphNode*            _pDragNode;         
    GxGraphConnect*         _pDragConnect;      
    GxPoint2                _dragPoint;         
    GxPoint2                _dragOffset;        
    GxPoint2                _rightClickPoint;   
    b32                     _isFunction;        
 
};
 
//===========================================================================
//===========================================================================
class GxGuiFormShaderGraph::GxGraphNode : public GxClassBaseReference
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS(GxGraphNode, GxClassBaseReference)
    // ClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxGraphNode)
 
    static constexpr u32 MIN_WIDTH = 120;       
    static constexpr u32 CHAR_WIDTH = 10;       
    static constexpr u32 NAME_HEIGHT = 16;      
    static const u32 NAME_FONT_OFFSET;          
    static constexpr u32 PARAM_RADIUS = 4;      
    static constexpr u32 PARAM_HEIGHT = 16;     
    static constexpr u32 PARAM_HEIGHT_HALF = PARAM_HEIGHT / 2;  
    static const u32 PARAM_FONT_OFFSET;         
    static const GxColor& SELECT_COLOR;         
    static const GX_CSTR OUTPUT_TEXTS[];        
    static const GxColor* OUTPUT_COLORS[];      
    static const GX_CSTR OUTPUT_COLOR_TEXTS[];  
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxGraphNode(GxShaderGraphElement& shaderElement);
    void cleanup(void) override;
    virtual void initialize(void);
protected:
    GxGraphNode(void) : _pShaderElement(nullptr), _isSelect(false){ _delayReleaseCount = 1; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    virtual void render(const GxPoint2& offset);
    void renderConnect(const GxPoint2& offset);
    virtual void addInputConnect(GxGraphConnect& connect);
    virtual void removeInputConnect(u32 index);
    void addOutputConnect(GxGraphConnect& connect);
    void removeOutputConnect(GxGraphConnect* pConnect);
    void removeConnectAll(void);
    GxString getProgram(const GxGraph& graph, b32 isGlsl, u32 outputIndex = 0);
    GX_FORCE_INLINE virtual void addMenuItems(GxPropertyTable& /*propertyTable*/) {}
private:
    GxString getProgram(const GxGraph& graph, b32 isGlsl, GxString* pArguments, u32 outputIndex);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr GX_CSTR getVirtualName(void) const { return _virtualName.getString(); }
    constexpr GxShaderGraphElement* getShaderElement(void) const { return _pShaderElement; }
    void setShaderElement(GxShaderGraphElement& shaderElement, b32 withRelease = true);
    GX_FORCE_INLINE const GxPoint2& getPosition(void) const { return _position; }
    GX_FORCE_INLINE void setPosition(const GxPoint2& position) { _position = position; }
    GX_FORCE_INLINE const GxSize& getSize(void) const { return _size; }
    GX_FORCE_INLINE void setSize(const GxSize& size) { _size = size; }
    GX_FORCE_INLINE b32 isIncluding(const GxPoint2& position) const { return GxRect(_position, _size).isIncluding(position); }
    b32 getConnectIndex(const GxPoint2& position, s32& outputIndex, s32& inputIndex) const;
    GxGraphConnect* getConnect(const GxPoint2& position) const;
    GxGraphConnect* getInputConnect(u32 index) const;
    GxGraphConnect* getOutputConnect(u32 index) const;
    constexpr u32 getInputConnectCount(void) const { return _inputConnects.getCount(); }
    constexpr u32 getOutputConnectCount(void) const { return _outputConnects.getCount(); }
    GxPoint2 getInputConnectPosition(u32 index) const;
    GxPoint2 getOutputConnectPosition(u32 index) const;
    GxShaderGraphElement::TYPE getInputType(u32 index) const;
    b32 isConnectNode(GxGraphNode* pNode) const;
    static b32 isConnectable(const GxGraphNode* pOutputNode, u32 outputIndex, const GxGraphNode* pInputNode, u32 inputIndex);
    GX_FORCE_INLINE b32 isSelect(void) const { return _isSelect; }
    GX_FORCE_INLINE void setSelect(b32 enable) { _isSelect = enable; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxString                _virtualName;       
    GxShaderGraphElement*   _pShaderElement;    
    GxArrayClassBase        _inputConnects;     
    GxArrayClassBase        _defaultValues;     
    GxArrayClassBase        _outputConnects;    
    GxPoint2                _position;          
    GxSize                  _size;              
    b32                     _isSelect;          
 
};
 
//===========================================================================
//===========================================================================
class GxGuiFormShaderGraph::GxGraphNodeConst : public GxGraphNode
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS(GxGraphNodeConst, GxGraphNode)
    // ClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxGraphNodeConst)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxGraphNodeConst(GxShaderGraphElement& shaderElement) : Super(shaderElement) { _value._type = shaderElement.getOutputType(); }
private:
    GxGraphNodeConst(void){}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr GX_CSTR getLabel(void) const { return _label.getString(); }
    constexpr GX_CSTR getLabel(u32 index) const { return _labels[index].getString(); }
    GX_FORCE_INLINE const GxShaderGraphElement::GxConstValue& getValue(void) const { return _value; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxString                            _label;     
    GxString                            _labels[4]; 
    GxShaderGraphElement::GxConstValue  _value;     
 
};
 
//===========================================================================
//===========================================================================
class GxGuiFormShaderGraph::GxGraphNodeSampler : public GxGraphNode
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS(GxGraphNodeSampler, GxGraphNode)
    // ClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxGraphNodeSampler)
private:
    static constexpr u32 TEXTURE_SIZE = 60; 
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxGraphNodeSampler(GxShaderGraphElement& shaderElement) : Super(shaderElement), _pResTexture(nullptr) {}
    void initialize(void) override;
    void cleanup(void) override;
private:
    GxGraphNodeSampler(void) : _pResTexture(nullptr){}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    void render(const GxPoint2& offset) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr GX_CSTR getLabel(void) const { return _label.getString(); }
    GX_FORCE_INLINE void    getPropertyTextureResource(void* const pValue) { *static_cast<GxResTexture**>(pValue) = _pResTexture; }
    GX_FORCE_INLINE void    setPropertyTextureResource(const void* const pValue) { setTextureResource(*static_cast<GxResTexture**>(const_cast<void*>(pValue))); }
    void setTextureResource(GxResTexture* pResTexture);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxString        _label;         
    GxResTexture*   _pResTexture;   
 
};
 
//===========================================================================
//===========================================================================
class GxGuiFormShaderGraph::GxGraphNodeOutput : public GxGraphNode
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS(GxGraphNodeOutput, GxGraphNode)
    // ClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxGraphNodeOutput)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxGraphNodeOutput(GxShaderGraphElement& shaderElement);
    void cleanup(void) override;
    void initialize(void) override;
protected:
    GxGraphNodeOutput(void) : _ppFunctionLabels(nullptr), _functionLabelCount(0), _outputType(GxShaderGraphElement::TYPE::UNKNOWN){}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    void addInputConnect(GxGraphConnect& connect) override;
    void removeInputConnect(u32 index) override;
    void addMenuItems(GxPropertyTable& propList) override;
private:
    void addFunction(void);
    void removeFunction(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr GX_CSTR getLabel(void) const { return _label.getString(); }
    GX_FORCE_INLINE GX_CSTR getFunctionLabel(u32 index) const { return static_cast<GxString*>(_ppFunctionLabels[index])->getString(); }
    void setOutputType(GxShaderGraphElement::TYPE type);
    constexpr u32 getFunctionLabelCount(void) const { return _functionLabelCount; }
    void setFunctionLabelCount(u32 count);
private:
    GX_FORCE_INLINE void getPropertyFunctionLabel(void* pValue, u32 index) const { *static_cast<GxString**>(pValue) = (index >= _functionLabelCount) ? nullptr : _ppFunctionLabels[index]; }
    void setPropertyFunctionLabel(const void* pValue, u32 index);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxString                    _label;                 
    GxString**                  _ppFunctionLabels;      
    u32                         _functionLabelCount;    
    GxShaderGraphElement::TYPE  _outputType;            
 
};
 
//===========================================================================
//===========================================================================
class GxGuiFormShaderGraph::GxGraphNodeMaterialInput : public GxGraphNode
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS(GxGraphNodeMaterialInput, GxGraphNode)
    // ClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxGraphNodeMaterialInput)
 
    static const GX_CSTR OUTPUT_MATERIAL_INPUT_TEXTS[]; 
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxGraphNodeMaterialInput(GxShaderGraphElement& shaderElement);
    void cleanup(void) override;
protected:
    GxGraphNodeMaterialInput(void) {}
 
};
 
//===========================================================================
//===========================================================================
class GxGuiFormShaderGraph::GxGraphNodeMaterialOutput : public GxGraphNode
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS(GxGraphNodeMaterialOutput, GxGraphNode)
    // ClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxGraphNodeMaterialOutput)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxGraphNodeMaterialOutput(GxShaderGraphElement& shaderElement);
    void cleanup(void) override;
protected:
    GxGraphNodeMaterialOutput(void) {}
 
};
 
//===========================================================================
//===========================================================================
class GxGuiFormShaderGraph::GxGraphNodeCustom : public GxGraphNode
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS(GxGraphNodeCustom, GxGraphNode)
    // ClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxGraphNodeCustom)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxGraphNodeCustom(GxShaderGraphElement& shaderElement, GX_CSTR guid);
    void cleanup(void) override;
    void initialize(void) override;
protected:
    GxGraphNodeCustom(void) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr GX_CSTR getMaterialFunctionGuid(void) const { return _materialFunctionGuid.getString(); }
    constexpr void setOutputType(GxShaderGraphElement::TYPE type) { _outputType = type; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxString                    _materialFunctionGuid;  
    GxShaderGraphElement::TYPE  _outputType;            
 
};
 
//===========================================================================
//===========================================================================
class GxGuiFormShaderGraph::GxGraphConnect : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_RTTI_CLASS(GxGraphConnect, GxClassBase)
    // ClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxGraphConnect)
 
    static constexpr u32 LINE_WIDTH = 2;        
    static constexpr u32 CURVE_THRESHOLD = 5;   
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxGraphConnect(GxGraphNode* pOutputNode, u32 outputIndex, GxGraphNode* pInputNode, u32 inputIndex)
        : _pOutputNode(pOutputNode), _pInputNode(pInputNode), _outputIndex(outputIndex), _inputIndex(inputIndex){}
    ~GxGraphConnect(void) override;
private:
    GxGraphConnect(void) : _pOutputNode(nullptr), _pInputNode(nullptr), _outputIndex(U32_MAX), _inputIndex(U32_MAX){}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr GxGraphNode* getOutputNode(void) const { return _pOutputNode; }
    constexpr void setOutputNode(GxGraphNode* pNode) { _pOutputNode = pNode; }
    constexpr GxGraphNode* getInputNode(void) const { return _pInputNode; }
    constexpr void setInputNode(GxGraphNode* pNode) { _pInputNode = pNode; }
    constexpr u32 getOutputIndex(void) const { return _outputIndex; }
    constexpr void setOutputIndex(u32 index) { _outputIndex = index; }
    constexpr u32 getInputIndex(void) const { return _inputIndex; }
    constexpr void setInputIndex(u32 index) { _inputIndex = index; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxGraphNode*    _pOutputNode;   
    GxGraphNode*    _pInputNode;    
    u32             _outputIndex;   
    u32             _inputIndex;    
 
};
 
GX_CORE_NAMESPACE_END()
 
#endif // GX_DEVELOP