gpu_node_graph.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2005 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "DNA_customdata_types.h"
#include "DNA_listBase.h"
 
#include "BLI_ghash.h"
 
#include "GPU_material.hh"
#include "GPU_shader.hh"
 
struct GPUNode;
struct GPUOutput;
struct ListBase;
 
enum eGPUDataSource {
  GPU_SOURCE_OUTPUT,
  GPU_SOURCE_CONSTANT,
  GPU_SOURCE_UNIFORM,
  GPU_SOURCE_ATTR,
  GPU_SOURCE_UNIFORM_ATTR,
  GPU_SOURCE_LAYER_ATTR,
  GPU_SOURCE_STRUCT,
  GPU_SOURCE_TEX,
  GPU_SOURCE_TEX_TILED_MAPPING,
  GPU_SOURCE_FUNCTION_CALL,
  GPU_SOURCE_CRYPTOMATTE,
};
 
enum GPUNodeLinkType {
  GPU_NODE_LINK_NONE = 0,
  GPU_NODE_LINK_ATTR,
  GPU_NODE_LINK_UNIFORM_ATTR,
  GPU_NODE_LINK_LAYER_ATTR,
  GPU_NODE_LINK_COLORBAND,
  GPU_NODE_LINK_CONSTANT,
  GPU_NODE_LINK_IMAGE,
  GPU_NODE_LINK_IMAGE_TILED,
  GPU_NODE_LINK_IMAGE_TILED_MAPPING,
  GPU_NODE_LINK_IMAGE_SKY,
  GPU_NODE_LINK_OUTPUT,
  GPU_NODE_LINK_UNIFORM,
  GPU_NODE_LINK_DIFFERENTIATE_FLOAT_FN,
};
 
enum eGPUNodeTag {
  GPU_NODE_TAG_NONE = 0,
  GPU_NODE_TAG_SURFACE = (1 << 0),
  GPU_NODE_TAG_VOLUME = (1 << 1),
  GPU_NODE_TAG_DISPLACEMENT = (1 << 2),
  GPU_NODE_TAG_THICKNESS = (1 << 3),
  GPU_NODE_TAG_AOV = (1 << 4),
  GPU_NODE_TAG_FUNCTION = (1 << 5),
  GPU_NODE_TAG_COMPOSITOR = (1 << 6),
};
 
ENUM_OPERATORS(eGPUNodeTag, GPU_NODE_TAG_COMPOSITOR)
 
struct GPUNode {
  GPUNode *next, *prev;
 
  const char *name;
 
  /* Internal flag to mark nodes during pruning */
  eGPUNodeTag tag;
 
  ListBase inputs;
  ListBase outputs;
};
 
struct GPUNodeLink {
  GPUNodeStack *socket;
 
  GPUNodeLinkType link_type;
  int users; /* Refcount */
 
  union {
    /* GPU_NODE_LINK_CONSTANT | GPU_NODE_LINK_UNIFORM */
    const float *data;
    /* GPU_NODE_LINK_COLORBAND */
    GPUTexture **colorband;
    /* GPU_NODE_LINK_OUTPUT */
    GPUOutput *output;
    /* GPU_NODE_LINK_ATTR */
    GPUMaterialAttribute *attr;
    /* GPU_NODE_LINK_UNIFORM_ATTR */
    GPUUniformAttr *uniform_attr;
    /* GPU_NODE_LINK_LAYER_ATTR */
    GPULayerAttr *layer_attr;
    /* GPU_NODE_LINK_IMAGE_BLENDER */
    GPUMaterialTexture *texture;
    /* GPU_NODE_LINK_DIFFERENTIATE_FLOAT_FN */
    const char *function_name;
  };
};
 
struct GPUOutput {
  GPUOutput *next, *prev;
 
  GPUNode *node;
  eGPUType type;     /* data type = length of vector/matrix */
  GPUNodeLink *link; /* output link */
  int id;            /* unique id as created by code generator */
};
 
struct GPUInput {
  GPUInput *next, *prev;
 
  GPUNode *node;
  eGPUType type; /* data-type. */
  GPUNodeLink *link;
  int id; /* unique id as created by code generator */
 
  eGPUDataSource source; /* data source */
 
  /* Content based on eGPUDataSource */
  union {
    /* GPU_SOURCE_CONSTANT | GPU_SOURCE_UNIFORM */
    float vec[16]; /* vector data */
                   /* GPU_SOURCE_TEX | GPU_SOURCE_TEX_TILED_MAPPING */
    GPUMaterialTexture *texture;
    /* GPU_SOURCE_ATTR */
    GPUMaterialAttribute *attr;
    /* GPU_SOURCE_UNIFORM_ATTR */
    GPUUniformAttr *uniform_attr;
    /* GPU_SOURCE_LAYER_ATTR */
    GPULayerAttr *layer_attr;
    /* GPU_SOURCE_FUNCTION_CALL */
    char function_call[64];
  };
};
 
struct GPUNodeGraphOutputLink {
  GPUNodeGraphOutputLink *next, *prev;
  int hash;
  GPUNodeLink *outlink;
};
 
struct GPUNodeGraphFunctionLink {
  GPUNodeGraphFunctionLink *next, *prev;
  char name[16];
  GPUNodeLink *outlink;
};
 
struct GPUNodeGraph {
  /* Nodes */
  ListBase nodes;
 
  /* Main Outputs. */
  GPUNodeLink *outlink_surface;
  GPUNodeLink *outlink_volume;
  GPUNodeLink *outlink_displacement;
  GPUNodeLink *outlink_thickness;
  /* List of GPUNodeGraphOutputLink */
  ListBase outlink_aovs;
  /* List of GPUNodeGraphFunctionLink */
  ListBase material_functions;
  /* List of GPUNodeGraphOutputLink */
  ListBase outlink_compositor;
 
  /* Requested attributes and textures. */
  ListBase attributes;
  ListBase textures;
 
  /* The list of uniform attributes. */
  GPUUniformAttrList uniform_attrs;
 
  /* The list of layer attributes. */
  ListBase layer_attrs;
 
  GSet *used_libraries;
};
 
/* Node Graph */
 
void gpu_nodes_tag(GPUNodeLink *link, eGPUNodeTag tag);
void gpu_node_graph_prune_unused(GPUNodeGraph *graph);
void gpu_node_graph_finalize_uniform_attrs(GPUNodeGraph *graph);
 
void gpu_node_graph_optimize(GPUNodeGraph *graph);
 
void gpu_node_graph_free_nodes(GPUNodeGraph *graph);
void gpu_node_graph_free(GPUNodeGraph *graph);
 
/* Material calls */
 
GPUNodeGraph *gpu_material_node_graph(GPUMaterial *material);
GPUTexture **gpu_material_ramp_texture_row_set(GPUMaterial *mat,
                                               int size,
                                               const float *pixels,
                                               float *r_row);
GPUTexture **gpu_material_sky_texture_layer_set(
    GPUMaterial *mat, int width, int height, const float *pixels, float *row);