source/blender/gpu/GPU_shader.h

   1 /*
   2  * This program is free software; you can redistribute it and/or
   3  * modify it under the terms of the GNU General Public License
   4  * as published by the Free Software Foundation; either version 2
   5  * of the License, or (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software Foundation,
  14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  15  *
  16  * The Original Code is Copyright (C) 2005 Blender Foundation.
  17  * All rights reserved.
  18  */
  19
  20 /** \file GPU_shader.h
  21  *  \ingroup gpu
  22  */
  23
  24 #ifndef __GPU_SHADER_H__
  25 #define __GPU_SHADER_H__
  26
  27 #ifdef __cplusplus
  28 extern "C" {
  29 #endif
  30
  31 typedef struct GPUShader GPUShader;
  32 struct GPUTexture;
  33 struct GPUUniformBuffer;
  34
  35 /* GPU Shader
  36  * - only for fragment shaders now
  37  * - must call texture bind before setting a texture as uniform! */
  38
  39 typedef enum eGPUShaderTFBType {
  40         GPU_SHADER_TFB_NONE         = 0, /* Transform feedback unsupported. */
  41         GPU_SHADER_TFB_POINTS       = 1,
  42         GPU_SHADER_TFB_LINES        = 2,
  43         GPU_SHADER_TFB_TRIANGLES    = 3,
  44 } eGPUShaderTFBType;
  45
  46 GPUShader *GPU_shader_create(
  47         const char *vertexcode,
  48         const char *fragcode,
  49         const char *geocode,
  50         const char *libcode,
  51         const char *defines,
  52         const char *shader_name);
  53 GPUShader *GPU_shader_create_ex(
  54         const char *vertexcode,
  55         const char *fragcode,
  56         const char *geocode,
  57         const char *libcode,
  58         const char *defines,
  59         const eGPUShaderTFBType tf_type,
  60         const char **tf_names,
  61         const int tf_count,
  62         const char *shader_name);
  63 struct GPU_ShaderCreateFromArray_Params { const char **vert, **geom, **frag, **defs; };
  64 struct GPUShader *GPU_shader_create_from_arrays_impl(
  65         const struct GPU_ShaderCreateFromArray_Params *params);
  66 #define GPU_shader_create_from_arrays(...) \
  67         GPU_shader_create_from_arrays_impl(&(const struct GPU_ShaderCreateFromArray_Params)__VA_ARGS__)
  68
  69 void GPU_shader_free(GPUShader *shader);
  70
  71 void GPU_shader_bind(GPUShader *shader);
  72 void GPU_shader_unbind(void);
  73
  74 /* Returns true if transform feedback was successfully enabled. */
  75 bool GPU_shader_transform_feedback_enable(GPUShader *shader, unsigned int vbo_id);
  76 void GPU_shader_transform_feedback_disable(GPUShader *shader);
  77
  78 int GPU_shader_get_program(GPUShader *shader);
  79
  80 void *GPU_shader_get_interface(GPUShader *shader);
  81
  82 int GPU_shader_get_uniform(GPUShader *shader, const char *name);
  83 int GPU_shader_get_uniform_ensure(GPUShader *shader, const char *name);
  84 int GPU_shader_get_builtin_uniform(GPUShader *shader, int builtin);
  85 int GPU_shader_get_uniform_block(GPUShader *shader, const char *name);
  86 void GPU_shader_uniform_vector(
  87         GPUShader *shader, int location, int length,
  88         int arraysize, const float *value);
  89 void GPU_shader_uniform_vector_int(
  90         GPUShader *shader, int location, int length,
  91         int arraysize, const int *value);
  92
  93 void GPU_shader_uniform_buffer(GPUShader *shader, int location, struct GPUUniformBuffer *ubo);
  94 void GPU_shader_uniform_texture(GPUShader *shader, int location, struct GPUTexture *tex);
  95 void GPU_shader_uniform_float(GPUShader *shader, int location, float value);
  96 void GPU_shader_uniform_int(GPUShader *shader, int location, int value);
  97
  98 int GPU_shader_get_attribute(GPUShader *shader, const char *name);
  99
 100 /* Builtin/Non-generated shaders */
 101 typedef enum eGPUBuiltinShader {
 102         /* specialized drawing */
 103         GPU_SHADER_TEXT,
 104         GPU_SHADER_TEXT_SIMPLE,
 105         GPU_SHADER_EDGES_FRONT_BACK_PERSP,
 106         GPU_SHADER_EDGES_FRONT_BACK_ORTHO,
 107         GPU_SHADER_EDGES_OVERLAY_SIMPLE,
 108         GPU_SHADER_EDGES_OVERLAY,
 109         GPU_SHADER_KEYFRAME_DIAMOND,
 110         GPU_SHADER_SIMPLE_LIGHTING,
 111         GPU_SHADER_SIMPLE_LIGHTING_FLAT_COLOR,
 112         GPU_SHADER_SIMPLE_LIGHTING_SMOOTH_COLOR,
 113         GPU_SHADER_SIMPLE_LIGHTING_SMOOTH_COLOR_ALPHA,
 114
 115         /* for simple 2D drawing */
 116         /**
 117          * Take a single color for all the vertices and a 2D position for each vertex.
 118          *
 119          * \param color: uniform vec4
 120          * \param pos: in vec2
 121          */
 122         GPU_SHADER_2D_UNIFORM_COLOR,
 123         /**
 124          * Take a 2D position and color for each vertex without color interpolation.
 125          *
 126          * \param color: in vec4
 127          * \param pos: in vec2
 128          */
 129         GPU_SHADER_2D_FLAT_COLOR,
 130         /**
 131          * Take a 2D position and color for each vertex with linear interpolation in window space.
 132          *
 133          * \param color: in vec4
 134          * \param pos: in vec2
 135          */
 136         GPU_SHADER_2D_SMOOTH_COLOR,
 137         GPU_SHADER_2D_SMOOTH_COLOR_DITHER,
 138         GPU_SHADER_2D_IMAGE,
 139         GPU_SHADER_2D_IMAGE_COLOR,
 140         GPU_SHADER_2D_IMAGE_DESATURATE_COLOR,
 141         GPU_SHADER_2D_IMAGE_ALPHA_COLOR,
 142         GPU_SHADER_2D_IMAGE_ALPHA,
 143         GPU_SHADER_2D_IMAGE_RECT_COLOR,
 144         GPU_SHADER_2D_IMAGE_MULTI_RECT_COLOR,
 145         GPU_SHADER_2D_IMAGE_MULTISAMPLE_2,
 146         GPU_SHADER_2D_IMAGE_MULTISAMPLE_4,
 147         GPU_SHADER_2D_IMAGE_MULTISAMPLE_8,
 148         GPU_SHADER_2D_IMAGE_MULTISAMPLE_16,
 149         GPU_SHADER_2D_IMAGE_MULTISAMPLE_2_DEPTH_TEST,
 150         GPU_SHADER_2D_IMAGE_MULTISAMPLE_4_DEPTH_TEST,
 151         GPU_SHADER_2D_IMAGE_MULTISAMPLE_8_DEPTH_TEST,
 152         GPU_SHADER_2D_IMAGE_MULTISAMPLE_16_DEPTH_TEST,
 153         GPU_SHADER_2D_CHECKER,
 154         GPU_SHADER_2D_DIAG_STRIPES,
 155         /* for simple 3D drawing */
 156         /**
 157          * Take a single color for all the vertices and a 3D position for each vertex.
 158          *
 159          * \param color: uniform vec4
 160          * \param pos: in vec3
 161          */
 162         GPU_SHADER_3D_UNIFORM_COLOR,
 163         /* Sets Z-depth to 1.0 (draw onto background). */
 164         GPU_SHADER_3D_UNIFORM_COLOR_BACKGROUND,
 165         GPU_SHADER_3D_UNIFORM_COLOR_INSTANCE,
 166         /**
 167          * Take a 3D position and color for each vertex without color interpolation.
 168          *
 169          * \param color: in vec4
 170          * \param pos: in vec3
 171          */
 172         GPU_SHADER_3D_FLAT_COLOR,
 173         /**
 174          * Take a 3D position and color for each vertex with perspective correct interpolation.
 175          *
 176          * \param color: in vec4
 177          * \param pos: in vec3
 178          */
 179         GPU_SHADER_3D_SMOOTH_COLOR,
 180         /**
 181          * Take a 3D position for each vertex and output only depth.
 182          *
 183          * \param pos: in vec3
 184          */
 185         GPU_SHADER_3D_DEPTH_ONLY,
 186         GPU_SHADER_3D_CLIPPED_UNIFORM_COLOR,
 187         /* basic image drawing */
 188         GPU_SHADER_2D_IMAGE_LINEAR_TO_SRGB,
 189         GPU_SHADER_2D_IMAGE_SHUFFLE_COLOR,
 190         GPU_SHADER_2D_IMAGE_MASK_UNIFORM_COLOR,
 191         /**
 192          * Draw texture with alpha. Take a 3D position and a 2D texture coordinate for each vertex.
 193          *
 194          * \param alpha: uniform float
 195          * \param image: uniform sampler2D
 196          * \param texCoord: in vec2
 197          * \param pos: in vec3
 198          */
 199         GPU_SHADER_3D_IMAGE_MODULATE_ALPHA,
 200         /**
 201          * Draw linearized depth texture relate to near and far distances.
 202          * Take a 3D position and a 2D texture coordinate for each vertex.
 203          *
 204          * \param znear: uniform float
 205          * \param zfar: uniform float
 206          * \param image: uniform sampler2D
 207          * \param texCoord: in vec2
 208          * \param pos: in vec3
 209          */
 210         GPU_SHADER_3D_IMAGE_DEPTH,
 211         GPU_SHADER_3D_IMAGE_DEPTH_COPY,
 212         /* stereo 3d */
 213         GPU_SHADER_2D_IMAGE_INTERLACE,
 214         /* points */
 215         /**
 216          * Draw round points with a hardcoded size.
 217          * Take a single color for all the vertices and a 2D position for each vertex.
 218          *
 219          * \param color: uniform vec4
 220          * \param pos: in vec2
 221          */
 222         GPU_SHADER_2D_POINT_FIXED_SIZE_UNIFORM_COLOR,
 223         /**
 224          * Draw round points with a constant size.
 225          * Take a single color for all the vertices and a 2D position for each vertex.
 226          *
 227          * \param size: uniform float
 228          * \param color: uniform vec4
 229          * \param pos: in vec2
 230          */
 231         GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA,
 232         /**
 233          * Draw round points with a constant size and an outline.
 234          * Take a single color for all the vertices and a 2D position for each vertex.
 235          *
 236          * \param size: uniform float
 237          * \param outlineWidth: uniform float
 238          * \param color: uniform vec4
 239          * \param outlineColor: uniform vec4
 240          * \param pos: in vec2
 241          */
 242         GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA,
 243         /**
 244          * Draw round points with a constant size and an outline. Take a 2D position and a color for each vertex.
 245          *
 246          * \param size: uniform float
 247          * \param outlineWidth: uniform float
 248          * \param outlineColor: uniform vec4
 249          * \param color: in vec4
 250          * \param pos: in vec2
 251          */
 252         GPU_SHADER_2D_POINT_UNIFORM_SIZE_VARYING_COLOR_OUTLINE_AA,
 253         /**
 254          * Draw round points with a constant size and an outline. Take a 2D position and a color for each vertex.
 255          *
 256          * \param size: in float
 257          * \param color: in vec4
 258          * \param pos: in vec2
 259          */
 260         GPU_SHADER_2D_POINT_VARYING_SIZE_VARYING_COLOR,
 261         /**
 262          * Draw round points with a hardcoded size.
 263          * Take a single color for all the vertices and a 3D position for each vertex.
 264          *
 265          * \param color: uniform vec4
 266          * \param pos: in vec3
 267          */
 268         GPU_SHADER_3D_POINT_FIXED_SIZE_UNIFORM_COLOR,
 269         /**
 270          * Draw round points with a hardcoded size.
 271          * Take a single color for all the vertices and a 3D position for each vertex.
 272          *
 273          * \param color: uniform vec4
 274          * \param pos: in vec3
 275          */
 276         GPU_SHADER_3D_POINT_FIXED_SIZE_VARYING_COLOR,
 277         /**
 278          * Draw round points with a constant size.
 279          * Take a single color for all the vertices and a 3D position for each vertex.
 280          *
 281          * \param size: uniform float
 282          * \param color: uniform vec4
 283          * \param pos: in vec3
 284          */
 285         GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA,
 286         /**
 287          * Draw round points with a constant size and an outline.
 288          * Take a single color for all the vertices and a 3D position for each vertex.
 289          *
 290          * \param size: uniform float
 291          * \param outlineWidth: uniform float
 292          * \param color: uniform vec4
 293          * \param outlineColor: uniform vec4
 294          * \param pos: in vec3
 295          */
 296         GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA,
 297         /**
 298          * Draw round points with a constant size and an outline.
 299          * Take a single color for all the vertices and a 3D position for each vertex.
 300          *
 301          * \param color: uniform vec4
 302          * \param size: in float
 303          * \param pos: in vec3
 304          */
 305         GPU_SHADER_3D_POINT_VARYING_SIZE_UNIFORM_COLOR,
 306         /**
 307          * Draw round points with a constant size and an outline. Take a 3D position and a color for each vertex.
 308          *
 309          * \param size: in float
 310          * \param color: in vec4
 311          * \param pos: in vec3
 312          */
 313         GPU_SHADER_3D_POINT_VARYING_SIZE_VARYING_COLOR,
 314         /* lines */
 315         GPU_SHADER_2D_LINE_DASHED_UNIFORM_COLOR,
 316         GPU_SHADER_3D_LINE_DASHED_UNIFORM_COLOR,
 317         /* lamp drawing */
 318         GPU_SHADER_3D_GROUNDPOINT,
 319         GPU_SHADER_3D_GROUNDLINE,
 320         GPU_SHADER_3D_SCREENSPACE_VARIYING_COLOR,
 321         /* bone drawing */
 322         GPU_SHADER_3D_OBJECTSPACE_VARIYING_COLOR,
 323         GPU_SHADER_3D_OBJECTSPACE_SIMPLE_LIGHTING_VARIYING_COLOR,
 324         /* camera drawing */
 325         GPU_SHADER_CAMERA,
 326         /* distance in front of objects */
 327         GPU_SHADER_DISTANCE_LINES,
 328         /* axis name */
 329         GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED_AXIS,
 330         GPU_SHADER_3D_INSTANCE_SCREEN_ALIGNED,
 331         /* instance */
 332         GPU_SHADER_INSTANCE_UNIFORM_COLOR,
 333         GPU_SHADER_INSTANCE_VARIYING_ID_VARIYING_SIZE, /* Uniformly scaled */
 334         GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SIZE, /* Uniformly scaled */
 335         GPU_SHADER_INSTANCE_VARIYING_COLOR_VARIYING_SCALE,
 336         GPU_SHADER_INSTANCE_EDGES_VARIYING_COLOR,
 337         /* grease pencil drawing */
 338         GPU_SHADER_GPENCIL_STROKE,
 339         GPU_SHADER_GPENCIL_FILL,
 340         /* specialized for widget drawing */
 341         GPU_SHADER_2D_AREA_EDGES,
 342         GPU_SHADER_2D_WIDGET_BASE,
 343         GPU_SHADER_2D_WIDGET_BASE_INST,
 344         GPU_SHADER_2D_WIDGET_SHADOW,
 345         GPU_SHADER_2D_NODELINK,
 346         GPU_SHADER_2D_NODELINK_INST,
 347         /* specialized for edituv drawing */
 348         GPU_SHADER_2D_UV_UNIFORM_COLOR,
 349         GPU_SHADER_2D_UV_VERTS,
 350         GPU_SHADER_2D_UV_FACEDOTS,
 351         GPU_SHADER_2D_UV_EDGES,
 352         GPU_SHADER_2D_UV_EDGES_SMOOTH,
 353         GPU_SHADER_2D_UV_FACES,
 354         GPU_SHADER_2D_UV_FACES_STRETCH_AREA,
 355         GPU_SHADER_2D_UV_FACES_STRETCH_ANGLE,
 356         /* Selection */
 357         GPU_SHADER_3D_FLAT_SELECT_ID,
 358         GPU_SHADER_3D_UNIFORM_SELECT_ID,
 359 } eGPUBuiltinShader;
 360 #define GPU_SHADER_BUILTIN_LEN (GPU_SHADER_3D_UNIFORM_SELECT_ID + 1)
 361
 362 /** Support multiple configurations. */
 363 typedef enum eGPUShaderConfig {
 364         GPU_SHADER_CFG_DEFAULT     = 0,
 365         GPU_SHADER_CFG_CLIPPED     = 1,
 366 } eGPUShaderConfig;
 367 #define GPU_SHADER_CFG_LEN (GPU_SHADER_CFG_CLIPPED + 1)
 368
 369 /** Keep these in sync with:
 370  * - `gpu_shader_image_interlace_frag.glsl`
 371  * - `gpu_shader_image_rect_interlace_frag.glsl`
 372  */
 373 typedef enum eGPUInterlaceShader {
 374         GPU_SHADER_INTERLACE_ROW               = 0,
 375         GPU_SHADER_INTERLACE_COLUMN            = 1,
 376         GPU_SHADER_INTERLACE_CHECKER           = 2,
 377 } eGPUInterlaceShader;
 378
 379 GPUShader *GPU_shader_get_builtin_shader_with_config(
 380         eGPUBuiltinShader shader, eGPUShaderConfig shader_cfg);
 381 GPUShader *GPU_shader_get_builtin_shader(
 382         eGPUBuiltinShader shader);
 383
 384 void GPU_shader_get_builtin_shader_code(
 385         eGPUBuiltinShader shader,
 386         const char **r_vert, const char **r_frag,
 387         const char **r_geom, const char **r_defines);
 388
 389 void GPU_shader_free_builtin_shaders(void);
 390
 391 /* Vertex attributes for shaders */
 392
 393 #define GPU_MAX_ATTR 32
 394
 395 typedef struct GPUVertAttrLayers {
 396         struct {
 397                 int type;
 398                 int glindex;
 399                 int glinfoindoex;
 400                 int gltexco;
 401                 int attr_id;
 402                 char name[64];  /* MAX_CUSTOMDATA_LAYER_NAME */
 403         } layer[GPU_MAX_ATTR];
 404
 405         int totlayer;
 406 } GPUVertAttrLayers;
 407
 408 #ifdef __cplusplus
 409 }
 410 #endif
 411
 412 #endif  /* __GPU_SHADER_H__ */