Caffeine

🔧 Material & Shader Editor

Planned Milestone: M4 — Advanced Tools & Polish Namespace: `Caffeine::Editor` Arquivos: `src/editor/ShaderEditor.hpp`, `src/editor/ShaderEditor.cpp` RF: RF6.3 Last updated:

Visão Geral#

O Material & Shader Editor é a ferramenta de criação visual e técnica para a aparência dos objetos no Caffeine Studio. Ele oferece um equilíbrio entre a facilidade de uso de um editor de grafos (nodos) e o controlo total de um editor de código HLSL/GLSL. Os utilizadores podem criar materiais complexos ligando texturas, cores e operações matemáticas que determinam como a luz interage com a superfície.

A característica principal é a pré-visualização em tempo real. Qualquer alteração no grafo ou no código é compilada instantaneamente em background, refletindo-se num objeto de teste (esfera, cubo ou malha personalizada) dentro do editor. Este feedback imediato é crucial para o processo iterativo de artistas técnicos.


Implementação#

O editor de shaders gere dois modos principais: o Visual Graph e o Text Editor. Ambos resultam num recurso de Material que é consumido pelo Renderer.

Estrutura do Grafo de Shaders#

cpp
namespace Caffeine::Editor {

enum class NodeType {
    TextureSample,
    ColorConstant,
    FloatConstant,
    Multiply,
    Add,
    Lerp,
    Time,
    VertexPosition,
    OutputPBR
};

struct NodePin {
    std::string name;
    std::string type; // ex: "vec3", "float"
    int connectionID = -1;
};

class ShaderNode {
public:
    uint32_t ID;
    std::string title;
    NodeType type;
    std::vector<NodePin> inputs;
    std::vector<NodePin> outputs;
    
    virtual std::string GenerateCode() = 0;
};

class ShaderGraph {
public:
    std::vector<Ref<ShaderNode>> m_nodes;
    std::vector<std::pair<int, int>> m_connections;

    std::string CompileToGLSL();
    std::string CompileToHLSL();
};

class MaterialEditorPanel : public EditorPanel {
public:
    MaterialEditorPanel();
    void OnImGuiRender() override;

private:
    void RenderGraphCanvas();
    void RenderInspector(); // Propriedades expostas (sliders, etc)
    void RenderPreviewWindow();
    void RecompileShader();

    Ref<Material> m_currentMaterial;
    ShaderGraph m_activeGraph;
    char m_codeBuffer[1024 * 16]; // Para modo texto
};

} // namespace Caffeine::Editor

Exemplo de Geração de Código a partir de Nodos#

cpp
std::string ShaderNode_Multiply::GenerateCode() {
    std::string inA = inputs[0].connectionID != -1 ? GetConnectedVar(0) : "1.0";
    std::string inB = inputs[1].connectionID != -1 ? GetConnectedVar(1) : "1.0";
    return fmt::format("vec4 var_{} = {} * {};", ID, inA, inB);
}

Diagrama da Interface Visual (ASCII)#

text
┌─────────────────────────────────────────────────────────────┐
│ Material: "M_Player_Armor"        [Compile] [Save] [Mode:💠] │
├───────────────────────────────┬─────────────────────────────┤
│ Shader Graph (Canvas)         │ Preview (3D Viewport)      │
│                               │                             │
│  ┌────────────┐               │      .--------.             │
│  │ Texture    │               │    .'          '.           │
│  ├────────────┤               │   /   PREVIEW    \          │
│  │ [RGB] ───○─┼─────┐         │  |    SPHERE      |         │
│  └────────────┘     │         │   \              /          │
│               ┌─────▼──────┐  │    '.          .'           │
│  ┌────────────┤ Multiply   │  │      '--------'             │
│  │ Color      ├────────────┤  ├─────────────────────────────┤
│  ├────────────┤ [Out] ───○─┼──┤ Inspector                   │
│  │ [RGB] ───○─┼────────────┘  │  - Albedo: [🎨]             │
│  └────────────┘               │  - Metallic: [---o---] 0.8  │
│                               │  - Roughness: [---o--] 0.2  │
└───────────────────────────────┴─────────────────────────────┘

Decisões de Design#

Decisão Justificativa
Abstração por Grafo Permite que artistas criem shaders complexos sem conhecimentos de programação de baixo nível.
Geração de Código Multi-API O grafo é compilado para uma representação intermédia que gera GLSL ou HLSL conforme o backend (Vulkan/DX12).
Compilação em Background Evita "freezes" no UI enquanto o compilador do driver de vídeo está a processar.
Materiais Instanciados O editor permite criar "Material Instances" que partilham o mesmo shader mas têm parâmetros diferentes, poupando memória.

Critério de Aceitação#

  • [ ] Criação de shaders via interface de nodos com suporte a ligações de tipos compatíveis.
  • [ ] Editor de texto com syntax highlighting para edição direta de código.
  • [ ] Janela de pré-visualização 3D/2D que atualiza instantaneamente.
  • [ ] Lista de propriedades expostas editáveis via sliders e color pickers.
  • [ ] Deteção e exibição de erros de compilação com indicação da linha ou nodo problemático.

Dependências#

  • Upstream: docs/rendering/rhi.md (necessário para a gestão de pipelines e shaders)
  • Downstream: docs/editor/scene-editor.md (materiais são aplicados a entidades na cena)

🔗 Tópicos Relacionados#

Tópico Descrição
RHI (Rendering Hardware Interface) Como o motor lida com os shaders compilados no hardware.
Asset Pipeline Conversão de texturas e shaders em formatos binários .caf.
Post-Processing Shaders especiais que correm em ecran total.

Referências#

  • Documentação da biblioteca ImNodes para ImGui.
  • Padrões de shading PBR (Physically Based Rendering).
  • Especificações do compilador de shaders glslang.