archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
91d320edc3cfb30443af4adbcb09bc3d7a609e1d
blender-archive/source/blender/gpu/intern/gpu_codegen.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1077 lines
32 KiB
C
Raw Normal View History

doxygen: prevent GPL license block from being parsed as doxygen comment.
2011-02-23 10:52:22 +00:00
/*
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
remove header text: "The Blender Foundation also sells licenses for use in proprietary software under the Blender Licens" also remove NaN references from files that have been added since blender went opensource.
2011-11-29 10:54:47 +00:00
* of the License, or (at your option) any later version.
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
correct fsf address
2010-02-12 13:34:04 +00:00
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
*
* The Original Code is Copyright (C) 2005 Blender Foundation.
* All rights reserved.
*/
doxygen: add newline after \file While \file doesn't need an argument, it can't have another doxy command after it.
2019-02-18 08:08:12 +11:00
/** \file
* \ingroup gpu
Docs: doxygen file descriptions for BLF, GPU and WM
2014-01-19 23:14:24 +11:00
*
* Convert material node-trees to GLSL.
doxygen: blender/gpu tagged.
2011-02-27 20:25:53 +00:00
*/
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
#include "MEM_guardedalloc.h"
#include "DNA_customdata_types.h"
#include "DNA_image_types.h"
#include "BLI_blenlib.h"
split BKE_utildefines.h, now it only has blender specific defines like GS() MAKE_ID, FILE_MAXDIR, moved the generic defines to BLI_utildefines.h. no functional changes.
2011-01-07 18:36:47 +00:00
#include "BLI_dynstr.h"
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
#include "BLI_ghash.h"
Cleanup: `make format` after SortedIncludes change
2020-03-19 09:33:03 +01:00
#include "BLI_hash_mm2a.h"
#include "BLI_link_utils.h"
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
#include "BLI_threads.h"
Cleanup: `make format` after SortedIncludes change
2020-03-19 09:33:03 +01:00
#include "BLI_utildefines.h"
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
#include "PIL_time.h"
Cleanup: split off code from gpu_codegen.c into smaller files
2020-02-12 12:48:44 +01:00
#include "BKE_material.h"
GPU: Rename gpu_extensions to gpu_capabilities This makes more sense as this module has more to it than just GL extensions.
2020-09-07 19:35:56 +02:00
#include "GPU_capabilities.h"
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
#include "GPU_material.h"
OpenGL: split off framebuffer, shader and texture code into separate files.
2015-12-06 21:20:19 +01:00
#include "GPU_shader.h"
GPUUniformBuf: Rename struct and change API a bit This follows the GPU module naming of other buffers. We pass name to distinguish each GPUUniformBuf in debug mode. Also remove DRW_uniform_buffer interface.
2020-08-20 23:09:37 +02:00
#include "GPU_uniform_buffer.h"
GPU: Vertex Format: ADd function for safe GLSL attrib name This remove code duplication and use base63 encoding of the hash. Use mumur hash to have more randomness.
2019-08-14 22:18:47 +02:00
#include "GPU_vertex_format.h"
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
cleanup: use spaces for alignment while studying GPU lib
2015-03-23 15:29:42 -04:00
#include "BLI_sys_types.h" /* for intptr_t support */
Fix Windows compile error. Update MSVC project files
2008-09-06 16:53:44 +00:00
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
#include "gpu_codegen.h"
GPU: add mechanism for splitting up big gpu_shader_material.glsl file Compiling this big file for every Eevee material is bad for performance, and now that we are adding more nodes it gets worse. This patch adds a simple mechanism to split up that file, and use only the parts used by shader nodes. When a function is used by GPU_link, we detect which GLSL file it came from and use it in GLSL code generation automatically. Dependencies between GLSL files are manually specified, and function names must be unique across all GLSL files. Most of the actual splitting up will be done in later commits. Differential Revision: https://developer.blender.org/D5569
2019-08-23 14:36:22 +02:00
#include "gpu_material_library.h"
Cleanup: split off code from gpu_codegen.c into smaller files
2020-02-12 12:48:44 +01:00
#include "gpu_node_graph.h"
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
#include <stdarg.h>
Cleanup: `make format` after SortedIncludes change
2020-03-19 09:33:03 +01:00
#include <string.h>
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
extern char datatoc_gpu_shader_codegen_lib_glsl[];
DRW: Refactor to support draw call batching Reviewers: brecht Differential Revision: D4997
2019-05-31 01:45:41 +02:00
extern char datatoc_gpu_shader_common_obinfos_lib_glsl[];
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
/* -------------------- GPUPass Cache ------------------ */
/**
* Internal shader cache: This prevent the shader recompilation / stall when
* using undo/redo AND also allows for GPUPass reuse if the Shader code is the
* same for 2 different Materials. Unused GPUPasses are free by Garbage collection.
Cleanup: comment blocks
2019-03-19 15:17:46 +11:00
*/
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
/* Only use one linklist that contains the GPUPasses grouped by hash. */
static GPUPass *pass_cache = NULL;
static SpinLock pass_cache_spin;
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
Cleanup: refactor GPU material attribute and texture requests
2020-02-14 10:47:20 +01:00
static uint32_t gpu_pass_hash(const char *frag_gen, const char *defs, ListBase *attributes)
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
{
BLI_HashMurmur2A hm2a;
BLI_hash_mm2a_init(&hm2a, 0);
Cleanup: use uint/uchar types in GPU
2018-09-12 12:18:35 +10:00
BLI_hash_mm2a_add(&hm2a, (uchar *)frag_gen, strlen(frag_gen));
Code Quality: Replace for loops with LISTBASE_FOREACH Note this only changes cases where the variable was declared inside the for loop. To handle it outside as well is a different challenge. Differential Revision: https://developer.blender.org/D7320
2020-04-03 19:15:01 +02:00
LISTBASE_FOREACH (GPUMaterialAttribute *, attr, attributes) {
Cleanup: refactor GPU material attribute and texture requests
2020-02-14 10:47:20 +01:00
BLI_hash_mm2a_add(&hm2a, (uchar *)attr->name, strlen(attr->name));
Commit D3494 : Compiled shader lookup fix Authored by Pavel Rudko (PavelRudko) on Thu, Jun 21, 10:41 AM. Original description: I've encounterd into a problem with blender 2.8. See the example screenshot (scene, shader setup). For some materials it's not enough to calculate hash based on fragment code and defines. In some cases attribute names may change. And if we change uv set name, for example, vertex shader is not recompiled, and another attribute name inside it is used.
2018-07-02 11:03:14 +02:00
}
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
if (defs) {
Cleanup: use uint/uchar types in GPU
2018-09-12 12:18:35 +10:00
BLI_hash_mm2a_add(&hm2a, (uchar *)defs, strlen(defs));
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
return BLI_hash_mm2a_end(&hm2a);
}
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
/* Search by hash only. Return first pass with the same hash.
* There is hash collision if (pass->next && pass->next->hash == hash) */
static GPUPass *gpu_pass_cache_lookup(uint32_t hash)
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
{
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
BLI_spin_lock(&pass_cache_spin);
/* Could be optimized with a Lookup table. */
for (GPUPass *pass = pass_cache; pass; pass = pass->next) {
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
if (pass->hash == hash) {
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
BLI_spin_unlock(&pass_cache_spin);
return pass;
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
}
}
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
BLI_spin_unlock(&pass_cache_spin);
return NULL;
}
/* Check all possible passes with the same hash. */
static GPUPass *gpu_pass_cache_resolve_collision(GPUPass *pass,
const char *vert,
const char *geom,
const char *frag,
const char *defs,
uint32_t hash)
{
BLI_spin_lock(&pass_cache_spin);
/* Collision, need to strcmp the whole shader. */
for (; pass && (pass->hash == hash); pass = pass->next) {
Clenup: use STREQ macro
2020-08-08 12:14:52 +10:00
if ((defs != NULL) && (!STREQ(pass->defines, defs))) { /* Pass */
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
}
Clenup: use STREQ macro
2020-08-08 12:14:52 +10:00
else if ((geom != NULL) && (!STREQ(pass->geometrycode, geom))) { /* Pass */
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
}
Clenup: use STREQ macro
2020-08-08 12:14:52 +10:00
else if ((!STREQ(pass->fragmentcode, frag) == 0) && (STREQ(pass->vertexcode, vert))) {
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
BLI_spin_unlock(&pass_cache_spin);
return pass;
}
}
BLI_spin_unlock(&pass_cache_spin);
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
return NULL;
}
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
/* GLSL code generation */
Enabled GCC -Wwrite-strings warning for CMake and replaced many 'char's for 'const char's,. Only one functional change where Transform orientations passed "" to BIF_createTransformOrientation() which could then have the value written into.
2010-12-03 17:05:21 +00:00
static void codegen_convert_datatype(DynStr *ds, int from, int to, const char *tmp, int id)
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
{
char name[1024];
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Fixes for snprintf usage: * replace by BLI_snprintf in various places, note _snprintf on windows does not properly null terminate the string. * fix overflow in sequencer proxy code due to buffer being smaller than specified size. * fix some usage of snprintf as strcpy, this is will go wrong if the string contains % characters. * remove BLI_dynstr_printf function in gpu module, use BLI_dynstr_appendf
2011-08-30 10:07:50 +00:00
BLI_snprintf(name, sizeof(name), "%s%d", tmp, id);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
if (from == to) {
BLI_dynstr_append(ds, name);
}
else if (to == GPU_FLOAT) {
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
if (from == GPU_VEC4) {
GPU: Split gpu_shader_material into multiple files. This patch continue the efforts to split the `gpu_shader_material` file started in D5569. Dependency resolution is now recursive. Each shading node gets its own file. Additionally, some utility files are added to be shared between files, like `math_util`, `color_util`, and `hash`. Some files are always included because they may be used in the execution function, like `world_normals`. Some glsl functions appeared to be unused, so they were removed, like `output_node`, `bits_to_01`, and `exp_blender`. Other functions have been renamed to be more general and get used as utils, like `texco_norm` which became `vector_normalize`. A lot of the opengl tests fails, but those same tests also fail in master, so this is probably unrelated to this patch. Reviewers: brecht Differential Revision: https://developer.blender.org/D5616
2019-08-30 17:23:04 +02:00
BLI_dynstr_appendf(ds, "dot(%s.rgb, vec3(0.2126, 0.7152, 0.0722))", name);
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (from == GPU_VEC3) {
Fix T44713: GLSL and BI inconsistency converting color to float node socket.
2015-05-17 18:18:04 +02:00
BLI_dynstr_appendf(ds, "(%s.r + %s.g + %s.b) / 3.0", name, name, name);
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (from == GPU_VEC2) {
Fixes for snprintf usage: * replace by BLI_snprintf in various places, note _snprintf on windows does not properly null terminate the string. * fix overflow in sequencer proxy code due to buffer being smaller than specified size. * fix some usage of snprintf as strcpy, this is will go wrong if the string contains % characters. * remove BLI_dynstr_printf function in gpu module, use BLI_dynstr_appendf
2011-08-30 10:07:50 +00:00
BLI_dynstr_appendf(ds, "%s.r", name);
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
}
else if (to == GPU_VEC2) {
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
if (from == GPU_VEC4) {
Fix T44713: GLSL and BI inconsistency converting color to float node socket.
2015-05-17 18:18:04 +02:00
BLI_dynstr_appendf(ds, "vec2((%s.r + %s.g + %s.b) / 3.0, %s.a)", name, name, name, name);
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (from == GPU_VEC3) {
Fix T44713: GLSL and BI inconsistency converting color to float node socket.
2015-05-17 18:18:04 +02:00
BLI_dynstr_appendf(ds, "vec2((%s.r + %s.g + %s.b) / 3.0, 1.0)", name, name, name);
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (from == GPU_FLOAT) {
Fixes for snprintf usage: * replace by BLI_snprintf in various places, note _snprintf on windows does not properly null terminate the string. * fix overflow in sequencer proxy code due to buffer being smaller than specified size. * fix some usage of snprintf as strcpy, this is will go wrong if the string contains % characters. * remove BLI_dynstr_printf function in gpu module, use BLI_dynstr_appendf
2011-08-30 10:07:50 +00:00
BLI_dynstr_appendf(ds, "vec2(%s, 1.0)", name);
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
}
else if (to == GPU_VEC3) {
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
if (from == GPU_VEC4) {
Fixes for snprintf usage: * replace by BLI_snprintf in various places, note _snprintf on windows does not properly null terminate the string. * fix overflow in sequencer proxy code due to buffer being smaller than specified size. * fix some usage of snprintf as strcpy, this is will go wrong if the string contains % characters. * remove BLI_dynstr_printf function in gpu module, use BLI_dynstr_appendf
2011-08-30 10:07:50 +00:00
BLI_dynstr_appendf(ds, "%s.rgb", name);
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (from == GPU_VEC2) {
Fixes for snprintf usage: * replace by BLI_snprintf in various places, note _snprintf on windows does not properly null terminate the string. * fix overflow in sequencer proxy code due to buffer being smaller than specified size. * fix some usage of snprintf as strcpy, this is will go wrong if the string contains % characters. * remove BLI_dynstr_printf function in gpu module, use BLI_dynstr_appendf
2011-08-30 10:07:50 +00:00
BLI_dynstr_appendf(ds, "vec3(%s.r, %s.r, %s.r)", name, name, name);
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (from == GPU_FLOAT) {
Fixes for snprintf usage: * replace by BLI_snprintf in various places, note _snprintf on windows does not properly null terminate the string. * fix overflow in sequencer proxy code due to buffer being smaller than specified size. * fix some usage of snprintf as strcpy, this is will go wrong if the string contains % characters. * remove BLI_dynstr_printf function in gpu module, use BLI_dynstr_appendf
2011-08-30 10:07:50 +00:00
BLI_dynstr_appendf(ds, "vec3(%s, %s, %s)", name, name, name);
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
}
Merge branch 'master' into blender2.8 This includes making Eevee match Cycles behavior of inserting an emission node when linking colors to closures.
2018-06-13 19:24:17 +02:00
else if (to == GPU_VEC4) {
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
if (from == GPU_VEC3) {
Fixes for snprintf usage: * replace by BLI_snprintf in various places, note _snprintf on windows does not properly null terminate the string. * fix overflow in sequencer proxy code due to buffer being smaller than specified size. * fix some usage of snprintf as strcpy, this is will go wrong if the string contains % characters. * remove BLI_dynstr_printf function in gpu module, use BLI_dynstr_appendf
2011-08-30 10:07:50 +00:00
BLI_dynstr_appendf(ds, "vec4(%s, 1.0)", name);
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (from == GPU_VEC2) {
Fixes for snprintf usage: * replace by BLI_snprintf in various places, note _snprintf on windows does not properly null terminate the string. * fix overflow in sequencer proxy code due to buffer being smaller than specified size. * fix some usage of snprintf as strcpy, this is will go wrong if the string contains % characters. * remove BLI_dynstr_printf function in gpu module, use BLI_dynstr_appendf
2011-08-30 10:07:50 +00:00
BLI_dynstr_appendf(ds, "vec4(%s.r, %s.r, %s.r, %s.g)", name, name, name, name);
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (from == GPU_FLOAT) {
Fixes for snprintf usage: * replace by BLI_snprintf in various places, note _snprintf on windows does not properly null terminate the string. * fix overflow in sequencer proxy code due to buffer being smaller than specified size. * fix some usage of snprintf as strcpy, this is will go wrong if the string contains % characters. * remove BLI_dynstr_printf function in gpu module, use BLI_dynstr_appendf
2011-08-30 10:07:50 +00:00
BLI_dynstr_appendf(ds, "vec4(%s, %s, %s, 1.0)", name, name, name);
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
}
Merge branch 'master' into blender2.8 This includes making Eevee match Cycles behavior of inserting an emission node when linking colors to closures.
2018-06-13 19:24:17 +02:00
else if (to == GPU_CLOSURE) {
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
if (from == GPU_VEC4) {
Merge branch 'master' into blender2.8 This includes making Eevee match Cycles behavior of inserting an emission node when linking colors to closures.
2018-06-13 19:24:17 +02:00
BLI_dynstr_appendf(ds, "closure_emission(%s.rgb)", name);
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (from == GPU_VEC3) {
Merge branch 'master' into blender2.8 This includes making Eevee match Cycles behavior of inserting an emission node when linking colors to closures.
2018-06-13 19:24:17 +02:00
BLI_dynstr_appendf(ds, "closure_emission(%s.rgb)", name);
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (from == GPU_VEC2) {
Merge branch 'master' into blender2.8 This includes making Eevee match Cycles behavior of inserting an emission node when linking colors to closures.
2018-06-13 19:24:17 +02:00
BLI_dynstr_appendf(ds, "closure_emission(%s.rrr)", name);
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (from == GPU_FLOAT) {
Merge branch 'master' into blender2.8 This includes making Eevee match Cycles behavior of inserting an emission node when linking colors to closures.
2018-06-13 19:24:17 +02:00
BLI_dynstr_appendf(ds, "closure_emission(vec3(%s, %s, %s))", name, name, name);
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Merge branch 'master' into blender2.8 This includes making Eevee match Cycles behavior of inserting an emission node when linking colors to closures.
2018-06-13 19:24:17 +02:00
}
else {
BLI_dynstr_append(ds, name);
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
}
}
Cleanup: use eGPU prefix for GPU enum types
2019-01-23 14:15:43 +11:00
static void codegen_print_datatype(DynStr *ds, const eGPUType type, float *data)
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
{
int i;
Cleanup: split off code from gpu_codegen.c into smaller files
2020-02-12 12:48:44 +01:00
BLI_dynstr_appendf(ds, "%s(", gpu_data_type_to_string(type));
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
cleanup: use spaces for alignment while studying GPU lib
2015-03-23 15:29:42 -04:00
for (i = 0; i < type; i++) {
Fix T50238: Cycles: difference in texture position between OpenGL and Cycles render
2017-03-24 12:24:14 +01:00
BLI_dynstr_appendf(ds, "%.12f", data[i]);
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
if (i == type - 1) {
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
BLI_dynstr_append(ds, ")");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else {
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
BLI_dynstr_append(ds, ", ");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
}
}
Cleanup: split off code from gpu_codegen.c into smaller files
2020-02-12 12:48:44 +01:00
static const char *gpu_builtin_name(eGPUBuiltin builtin)
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
{
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
if (builtin == GPU_VIEW_MATRIX) {
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
return "unfviewmat";
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Cleanup: GPU, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/gpu` module. No functional changes.
2020-08-07 12:39:35 +02:00
if (builtin == GPU_OBJECT_MATRIX) {
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
return "unfobmat";
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Cleanup: GPU, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/gpu` module. No functional changes.
2020-08-07 12:39:35 +02:00
if (builtin == GPU_INVERSE_VIEW_MATRIX) {
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
return "unfinvviewmat";
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Cleanup: GPU, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/gpu` module. No functional changes.
2020-08-07 12:39:35 +02:00
if (builtin == GPU_INVERSE_OBJECT_MATRIX) {
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
return "unfinvobmat";
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Cleanup: GPU, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/gpu` module. No functional changes.
2020-08-07 12:39:35 +02:00
if (builtin == GPU_LOC_TO_VIEW_MATRIX) {
Vector Transform node support for GLSL mode and the internal renderer The Vector Transform node is a useful node which is present in the Cycles renderer. {F144283} This patch implements the Vector Transform node for GLSL mode and the internal renderer. Example: {F273060} Alexander (Blend4Web Team) Reviewers: brecht, campbellbarton, sergey Reviewed By: campbellbarton, sergey Subscribers: psy-fi, duarteframos, RobM, lightbwk, sergey, AlexKowel, valentin_b4w, Evgeny_Rodygin, yurikovelenov Projects: #bf_blender:_next Differential Revision: https://developer.blender.org/D909
2016-01-23 15:27:36 +03:00
return "unflocaltoviewmat";
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Cleanup: GPU, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/gpu` module. No functional changes.
2020-08-07 12:39:35 +02:00
if (builtin == GPU_INVERSE_LOC_TO_VIEW_MATRIX) {
Vector Transform node support for GLSL mode and the internal renderer The Vector Transform node is a useful node which is present in the Cycles renderer. {F144283} This patch implements the Vector Transform node for GLSL mode and the internal renderer. Example: {F273060} Alexander (Blend4Web Team) Reviewers: brecht, campbellbarton, sergey Reviewed By: campbellbarton, sergey Subscribers: psy-fi, duarteframos, RobM, lightbwk, sergey, AlexKowel, valentin_b4w, Evgeny_Rodygin, yurikovelenov Projects: #bf_blender:_next Differential Revision: https://developer.blender.org/D909
2016-01-23 15:27:36 +03:00
return "unfinvlocaltoviewmat";
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Cleanup: GPU, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/gpu` module. No functional changes.
2020-08-07 12:39:35 +02:00
if (builtin == GPU_VIEW_POSITION) {
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
return "varposition";
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Cleanup: GPU, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/gpu` module. No functional changes.
2020-08-07 12:39:35 +02:00
if (builtin == GPU_WORLD_NORMAL) {
GPU: Remove GPU_INVERSE_NORMAL_MATRIX The end goal for this is to lower the number of needed matrices. This also cleanup some uneeded transformation.
2019-05-08 19:33:54 +02:00
return "varwnormal";
}
Cleanup: GPU, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/gpu` module. No functional changes.
2020-08-07 12:39:35 +02:00
if (builtin == GPU_VIEW_NORMAL) {
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
return "varnormal";
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Cleanup: GPU, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/gpu` module. No functional changes.
2020-08-07 12:39:35 +02:00
if (builtin == GPU_OBJECT_COLOR) {
Shading: Add object color to Object Info node. The object color property is added as an additional output in the Object Info node. Reviewers: brecht Differential Revision: https://developer.blender.org/D5554
2019-08-22 14:26:09 +02:00
return "unfobjectcolor";
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Cleanup: GPU, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/gpu` module. No functional changes.
2020-08-07 12:39:35 +02:00
if (builtin == GPU_AUTO_BUMPSCALE) {
fixes scale on derivative maps
2011-12-09 23:26:06 +00:00
return "unfobautobumpscale";
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Cleanup: GPU, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/gpu` module. No functional changes.
2020-08-07 12:39:35 +02:00
if (builtin == GPU_CAMERA_TEXCO_FACTORS) {
Adjust GLSL drawing of window coordinates from camera view (use camera bounds instead of window bounds). Fixes remaining part of T43346
2015-02-02 14:25:44 +01:00
return "unfcameratexfactors";
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Cleanup: GPU, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/gpu` module. No functional changes.
2020-08-07 12:39:35 +02:00
if (builtin == GPU_PARTICLE_SCALAR_PROPS) {
Revert particle system and point cache removal in blender2.8 branch. This reverts commit 5aa19be91263a249ffae75573e3b32f24269d890 and b4a721af694817fa921b119df83d33ede7d7fed0. Due to postponement of particle system rewrite it was decided to put particle code back into the 2.8 branch for the time being.
2016-12-28 17:30:58 +01:00
return "unfparticlescalarprops";
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Cleanup: GPU, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/gpu` module. No functional changes.
2020-08-07 12:39:35 +02:00
if (builtin == GPU_PARTICLE_LOCATION) {
Revert particle system and point cache removal in blender2.8 branch. This reverts commit 5aa19be91263a249ffae75573e3b32f24269d890 and b4a721af694817fa921b119df83d33ede7d7fed0. Due to postponement of particle system rewrite it was decided to put particle code back into the 2.8 branch for the time being.
2016-12-28 17:30:58 +01:00
return "unfparticleco";
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Cleanup: GPU, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/gpu` module. No functional changes.
2020-08-07 12:39:35 +02:00
if (builtin == GPU_PARTICLE_VELOCITY) {
Revert particle system and point cache removal in blender2.8 branch. This reverts commit 5aa19be91263a249ffae75573e3b32f24269d890 and b4a721af694817fa921b119df83d33ede7d7fed0. Due to postponement of particle system rewrite it was decided to put particle code back into the 2.8 branch for the time being.
2016-12-28 17:30:58 +01:00
return "unfparticlevel";
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Cleanup: GPU, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/gpu` module. No functional changes.
2020-08-07 12:39:35 +02:00
if (builtin == GPU_PARTICLE_ANG_VELOCITY) {
Revert particle system and point cache removal in blender2.8 branch. This reverts commit 5aa19be91263a249ffae75573e3b32f24269d890 and b4a721af694817fa921b119df83d33ede7d7fed0. Due to postponement of particle system rewrite it was decided to put particle code back into the 2.8 branch for the time being.
2016-12-28 17:30:58 +01:00
return "unfparticleangvel";
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Cleanup: GPU, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/gpu` module. No functional changes.
2020-08-07 12:39:35 +02:00
if (builtin == GPU_OBJECT_INFO) {
Object Info node support for GLSL mode and the internal render Object Info node can be useful to give some variation to a single material assigned to multiple instances. This patch adds support for Viewport and BI. {F499530} Example: {F499528} Reviewers: merwin, brecht, dfelinto Reviewed By: brecht Subscribers: duarteframos, fclem, homyachetser, Evgeny_Rodygin, AlexKowel, yurikovelenov Differential Revision: https://developer.blender.org/D2425
2017-04-14 18:13:44 +03:00
return "unfobjectinfo";
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Cleanup: GPU, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/gpu` module. No functional changes.
2020-08-07 12:39:35 +02:00
if (builtin == GPU_BARYCENTRIC_TEXCO) {
GPUMaterial: Geometry Node: Add support for parametric output This supports meshes and hairs too. Matches cycles output. This adds barycentric coords to the GPUBuiltin enum which will also be used for the wireframe node.
2018-08-20 17:59:21 +02:00
return "unfbarycentrictex";
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Cleanup: GPU, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/gpu` module. No functional changes.
2020-08-07 12:39:35 +02:00
if (builtin == GPU_BARYCENTRIC_DIST) {
Eevee: Implement Wireframe Node This implementation is a bit hacky but match cycles pretty close. If pixel size is not enabled, it will use the geom shader to compute distances between vertices. This will have a cost. Implementation is a bit hacky in gpu_codegen to make the geom shader works in an optional manner.
2018-09-20 17:41:07 +02:00
return "unfbarycentricdist";
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Cleanup: GPU, Clang-Tidy else-after-return fixes This addresses warnings from Clang-Tidy's `readability-else-after-return` rule in the `source/blender/gpu` module. No functional changes.
2020-08-07 12:39:35 +02:00
return "";
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
}
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
static void codegen_set_unique_ids(GPUNodeGraph *graph)
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
{
Cleanup: refactor GPU material attribute and texture requests
2020-02-14 10:47:20 +01:00
int id = 1;
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: GPU_codegen.c: Use LISTBASE_FOREACH macro instead of for loops
2020-07-25 18:48:57 +02:00
LISTBASE_FOREACH (GPUNode *, node, &graph->nodes) {
LISTBASE_FOREACH (GPUInput *, input, &node->inputs) {
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
/* set id for unique names of uniform variables */
input->id = id++;
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: GPU_codegen.c: Use LISTBASE_FOREACH macro instead of for loops
2020-07-25 18:48:57 +02:00
LISTBASE_FOREACH (GPUOutput *, output, &node->outputs) {
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
/* set id for unique names of tmp variables storing output */
output->id = id++;
Cleanup: GPU codegen: remove most of legacy code A lot of code in codegen was used by previous GLSL system. Now most of it is not used due to all the things being written from scratch in 2.8 and we can clean most of it. As a side not this make the system a bit less flexible (no support for cubemaps, preview image, etc...) but can be extended again.
2018-08-13 18:44:27 +02:00
}
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
}
}
Implement Uniformbuffer objects for nodetree parameters For users that means you can tweak shaders in the nodetree and things are way faster. This is a huge improvement, particularly in systems that have no shader cache. From the code perspective it means we are no longer re-compiling the shader every time a value is tweaked in the UI. We are using uniforms for those values. It would be slow to add that many uniforms for all the shaders. So instead we are using UBO (Uniform Buffer Objects). This fixes the main issue of T51467. However GWN_shaderinterface_create() still needs to be improvedi. When opening a .blend all shaders are compiled once, so optimizing it will bring a measurable impact. ======================================================================== NOTE: This breaks update of Cycles material upon nodetree nodes tweaking. It will be fixed separately by depsgraph, once tackling T51925 (Animated Eevee values slowdown). The idea is to make Depsgraph update more granular. The XXX TODO in rna_nodetree.c will be tackled at that time as well. ======================================================================== Reviewers: sergey, brecht, fclem Differential Revision: https://developer.blender.org/D2739
2017-07-14 17:40:54 +02:00
/**
* It will create an UBO for GPUMaterial if there is any GPU_DYNAMIC_UBO.
*/
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
static int codegen_process_uniforms_functions(GPUMaterial *material,
DynStr *ds,
GPUNodeGraph *graph)
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
{
Enabled GCC -Wwrite-strings warning for CMake and replaced many 'char's for 'const char's,. Only one functional change where Transform orientations passed "" to BIF_createTransformOrientation() which could then have the value written into.
2010-12-03 17:05:21 +00:00
const char *name;
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
int builtins = 0;
Implement Uniformbuffer objects for nodetree parameters For users that means you can tweak shaders in the nodetree and things are way faster. This is a huge improvement, particularly in systems that have no shader cache. From the code perspective it means we are no longer re-compiling the shader every time a value is tweaked in the UI. We are using uniforms for those values. It would be slow to add that many uniforms for all the shaders. So instead we are using UBO (Uniform Buffer Objects). This fixes the main issue of T51467. However GWN_shaderinterface_create() still needs to be improvedi. When opening a .blend all shaders are compiled once, so optimizing it will bring a measurable impact. ======================================================================== NOTE: This breaks update of Cycles material upon nodetree nodes tweaking. It will be fixed separately by depsgraph, once tackling T51925 (Animated Eevee values slowdown). The idea is to make Depsgraph update more granular. The XXX TODO in rna_nodetree.c will be tackled at that time as well. ======================================================================== Reviewers: sergey, brecht, fclem Differential Revision: https://developer.blender.org/D2739
2017-07-14 17:40:54 +02:00
ListBase ubo_inputs = {NULL, NULL};
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
/* Textures */
Code Quality: Replace for loops with LISTBASE_FOREACH Note this only changes cases where the variable was declared inside the for loop. To handle it outside as well is a different challenge. Differential Revision: https://developer.blender.org/D7320
2020-04-03 19:15:01 +02:00
LISTBASE_FOREACH (GPUMaterialTexture *, tex, &graph->textures) {
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
if (tex->colorband) {
BLI_dynstr_appendf(ds, "uniform sampler1DArray %s;\n", tex->sampler_name);
}
else if (tex->tiled_mapping_name[0]) {
BLI_dynstr_appendf(ds, "uniform sampler2DArray %s;\n", tex->sampler_name);
BLI_dynstr_appendf(ds, "uniform sampler1DArray %s;\n", tex->tiled_mapping_name);
}
else {
BLI_dynstr_appendf(ds, "uniform sampler2D %s;\n", tex->sampler_name);
}
}
Eevee: internal support for arbitrary number of volume grids This has no user visible impact yet since smoke volumes only support a fixed set of attributes, but will become important with the new volume object. For GPU shader compilation, volume grids are now handled separately from image textures. They are somewhere between a vertex attribute and an image texture, basically an attribute that is stored as a texture. Differential Revision: https://developer.blender.org/D6952
2020-03-11 14:58:19 +01:00
/* Volume Grids */
Code Quality: Replace for loops with LISTBASE_FOREACH Note this only changes cases where the variable was declared inside the for loop. To handle it outside as well is a different challenge. Differential Revision: https://developer.blender.org/D7320
2020-04-03 19:15:01 +02:00
LISTBASE_FOREACH (GPUMaterialVolumeGrid *, grid, &graph->volume_grids) {
Eevee: internal support for arbitrary number of volume grids This has no user visible impact yet since smoke volumes only support a fixed set of attributes, but will become important with the new volume object. For GPU shader compilation, volume grids are now handled separately from image textures. They are somewhere between a vertex attribute and an image texture, basically an attribute that is stored as a texture. Differential Revision: https://developer.blender.org/D6952
2020-03-11 14:58:19 +01:00
BLI_dynstr_appendf(ds, "uniform sampler3D %s;\n", grid->sampler_name);
Objects: Eevee and workbench rendering of new Volume, Hair, PointCloud Only the volume drawing part is really finished and exposed to the user. Hair plugs into the existing hair rendering code and is fairly straightforward. The pointcloud drawing is a hack using overlays rather than Eevee and workbench. The most tricky part for volume rendering is the case where each volume grid has a different transform, which requires an additional matrix in the shader and non-trivial logic in Eevee volume drawing. In the common case were all the transforms match we don't use the additional per-grid matrix in the shader. Ref T73201, T68981 Differential Revision: https://developer.blender.org/D6955
2020-03-17 16:27:08 +01:00
BLI_dynstr_appendf(ds, "uniform mat4 %s = mat4(0.0);\n", grid->transform_name);
Eevee: internal support for arbitrary number of volume grids This has no user visible impact yet since smoke volumes only support a fixed set of attributes, but will become important with the new volume object. For GPU shader compilation, volume grids are now handled separately from image textures. They are somewhere between a vertex attribute and an image texture, basically an attribute that is stored as a texture. Differential Revision: https://developer.blender.org/D6952
2020-03-11 14:58:19 +01:00
}
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
/* Print other uniforms */
Cleanup: GPU_codegen.c: Use LISTBASE_FOREACH macro instead of for loops
2020-07-25 18:48:57 +02:00
LISTBASE_FOREACH (GPUNode *, node, &graph->nodes) {
LISTBASE_FOREACH (GPUInput *, input, &node->inputs) {
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
if (input->source == GPU_SOURCE_BUILTIN) {
OpenGL: codegen formatting Formatting of generated GLSL code: - attribute/varying for version 120 - in/out for version 130+ - minor cosmetic stuff Tested working on Windows 10, GL 4.3.
2015-11-23 00:13:57 -05:00
/* only define each builtin uniform/varying once */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:38:07 +00:00
if (!(builtins & input->builtin)) {
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
builtins |= input->builtin;
Cleanup: split off code from gpu_codegen.c into smaller files
2020-02-12 12:48:44 +01:00
name = gpu_builtin_name(input->builtin);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Eevee: internal support for arbitrary number of volume grids This has no user visible impact yet since smoke volumes only support a fixed set of attributes, but will become important with the new volume object. For GPU shader compilation, volume grids are now handled separately from image textures. They are somewhere between a vertex attribute and an image texture, basically an attribute that is stored as a texture. Differential Revision: https://developer.blender.org/D6952
2020-03-11 14:58:19 +01:00
if (BLI_str_startswith(name, "unf")) {
Cleanup: split off code from gpu_codegen.c into smaller files
2020-02-12 12:48:44 +01:00
BLI_dynstr_appendf(ds, "uniform %s %s;\n", gpu_data_type_to_string(input->type), name);
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
}
else {
Cleanup: split off code from gpu_codegen.c into smaller files
2020-02-12 12:48:44 +01:00
BLI_dynstr_appendf(ds, "in %s %s;\n", gpu_data_type_to_string(input->type), name);
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
}
}
}
GPUCodegen: Add New GPU_SOURCE_STRUCT to be used for Closure Sockets This way we dont rely on the static array of chars that was causing T52385. That fixes T52385.
2017-09-14 01:02:10 +02:00
else if (input->source == GPU_SOURCE_STRUCT) {
/* Add other struct here if needed. */
BLI_dynstr_appendf(ds, "Closure strct%d = CLOSURE_DEFAULT;\n", input->id);
}
Cleanup: GPU codegen: remove most of legacy code A lot of code in codegen was used by previous GLSL system. Now most of it is not used due to all the things being written from scratch in 2.8 and we can clean most of it. As a side not this make the system a bit less flexible (no support for cubemaps, preview image, etc...) but can be extended again.
2018-08-13 18:44:27 +02:00
else if (input->source == GPU_SOURCE_UNIFORM) {
if (!input->link) {
/* We handle the UBOuniforms separately. */
BLI_addtail(&ubo_inputs, BLI_genericNodeN(input));
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
}
Cleanup: GPU codegen: remove most of legacy code A lot of code in codegen was used by previous GLSL system. Now most of it is not used due to all the things being written from scratch in 2.8 and we can clean most of it. As a side not this make the system a bit less flexible (no support for cubemaps, preview image, etc...) but can be extended again.
2018-08-13 18:44:27 +02:00
else if (input->source == GPU_SOURCE_CONSTANT) {
Cleanup: split off code from gpu_codegen.c into smaller files
2020-02-12 12:48:44 +01:00
BLI_dynstr_appendf(
ds, "const %s cons%d = ", gpu_data_type_to_string(input->type), input->id);
Cleanup: GPU codegen: remove most of legacy code A lot of code in codegen was used by previous GLSL system. Now most of it is not used due to all the things being written from scratch in 2.8 and we can clean most of it. As a side not this make the system a bit less flexible (no support for cubemaps, preview image, etc...) but can be extended again.
2018-08-13 18:44:27 +02:00
codegen_print_datatype(ds, input->type, input->vec);
BLI_dynstr_append(ds, ";\n");
}
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
}
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Implement Uniformbuffer objects for nodetree parameters For users that means you can tweak shaders in the nodetree and things are way faster. This is a huge improvement, particularly in systems that have no shader cache. From the code perspective it means we are no longer re-compiling the shader every time a value is tweaked in the UI. We are using uniforms for those values. It would be slow to add that many uniforms for all the shaders. So instead we are using UBO (Uniform Buffer Objects). This fixes the main issue of T51467. However GWN_shaderinterface_create() still needs to be improvedi. When opening a .blend all shaders are compiled once, so optimizing it will bring a measurable impact. ======================================================================== NOTE: This breaks update of Cycles material upon nodetree nodes tweaking. It will be fixed separately by depsgraph, once tackling T51925 (Animated Eevee values slowdown). The idea is to make Depsgraph update more granular. The XXX TODO in rna_nodetree.c will be tackled at that time as well. ======================================================================== Reviewers: sergey, brecht, fclem Differential Revision: https://developer.blender.org/D2739
2017-07-14 17:40:54 +02:00
/* Handle the UBO block separately. */
if ((material != NULL) && !BLI_listbase_is_empty(&ubo_inputs)) {
Rename GPU_material_create_uniform_buffer > GPU_material_uniform_buffer_create
2018-06-07 19:40:47 +02:00
GPU_material_uniform_buffer_create(material, &ubo_inputs);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Implement Uniformbuffer objects for nodetree parameters For users that means you can tweak shaders in the nodetree and things are way faster. This is a huge improvement, particularly in systems that have no shader cache. From the code perspective it means we are no longer re-compiling the shader every time a value is tweaked in the UI. We are using uniforms for those values. It would be slow to add that many uniforms for all the shaders. So instead we are using UBO (Uniform Buffer Objects). This fixes the main issue of T51467. However GWN_shaderinterface_create() still needs to be improvedi. When opening a .blend all shaders are compiled once, so optimizing it will bring a measurable impact. ======================================================================== NOTE: This breaks update of Cycles material upon nodetree nodes tweaking. It will be fixed separately by depsgraph, once tackling T51925 (Animated Eevee values slowdown). The idea is to make Depsgraph update more granular. The XXX TODO in rna_nodetree.c will be tackled at that time as well. ======================================================================== Reviewers: sergey, brecht, fclem Differential Revision: https://developer.blender.org/D2739
2017-07-14 17:40:54 +02:00
/* Inputs are sorted */
BLI_dynstr_appendf(ds, "\nlayout (std140) uniform %s {\n", GPU_UBO_BLOCK_NAME);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Code Quality: Replace for loops with LISTBASE_FOREACH Note this only changes cases where the variable was declared inside the for loop. To handle it outside as well is a different challenge. Differential Revision: https://developer.blender.org/D7320
2020-04-03 19:15:01 +02:00
LISTBASE_FOREACH (LinkData *, link, &ubo_inputs) {
Cleanup: GPU_codegen.c: Use LISTBASE_FOREACH macro instead of for loops
2020-07-25 18:48:57 +02:00
GPUInput *input = (GPUInput *)(link->data);
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_appendf(ds, " %s unf%d;\n", gpu_data_type_to_string(input->type), input->id);
Implement Uniformbuffer objects for nodetree parameters For users that means you can tweak shaders in the nodetree and things are way faster. This is a huge improvement, particularly in systems that have no shader cache. From the code perspective it means we are no longer re-compiling the shader every time a value is tweaked in the UI. We are using uniforms for those values. It would be slow to add that many uniforms for all the shaders. So instead we are using UBO (Uniform Buffer Objects). This fixes the main issue of T51467. However GWN_shaderinterface_create() still needs to be improvedi. When opening a .blend all shaders are compiled once, so optimizing it will bring a measurable impact. ======================================================================== NOTE: This breaks update of Cycles material upon nodetree nodes tweaking. It will be fixed separately by depsgraph, once tackling T51925 (Animated Eevee values slowdown). The idea is to make Depsgraph update more granular. The XXX TODO in rna_nodetree.c will be tackled at that time as well. ======================================================================== Reviewers: sergey, brecht, fclem Differential Revision: https://developer.blender.org/D2739
2017-07-14 17:40:54 +02:00
}
BLI_dynstr_append(ds, "};\n");
BLI_freelistN(&ubo_inputs);
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
BLI_dynstr_append(ds, "\n");
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Fix GLSL not showing shading properly on the backside of faces. Now it flips the normal towards the viewer, seems to give consistent results with blender internal, cycles, normal maps, etc. Started from patch #32761 by Vitor Balbio, but changed it to do normal flipping earlier so it solves all cases.
2013-06-24 13:46:34 +00:00
return builtins;
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
}
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
static void codegen_declare_tmps(DynStr *ds, GPUNodeGraph *graph)
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
{
Cleanup: GPU_codegen.c: Use LISTBASE_FOREACH macro instead of for loops
2020-07-25 18:48:57 +02:00
LISTBASE_FOREACH (GPUNode *, node, &graph->nodes) {
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
/* declare temporary variables for node output storage */
Cleanup: GPU_codegen.c: Use LISTBASE_FOREACH macro instead of for loops
2020-07-25 18:48:57 +02:00
LISTBASE_FOREACH (GPUOutput *, output, &node->outputs) {
GPUCodegen: Add New GPU_SOURCE_STRUCT to be used for Closure Sockets This way we dont rely on the static array of chars that was causing T52385. That fixes T52385.
2017-09-14 01:02:10 +02:00
if (output->type == GPU_CLOSURE) {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_appendf(ds, " Closure tmp%d;\n", output->id);
GPUCodegen: Add New GPU_SOURCE_STRUCT to be used for Closure Sockets This way we dont rely on the static array of chars that was causing T52385. That fixes T52385.
2017-09-14 01:02:10 +02:00
}
else {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_appendf(ds, " %s tmp%d;\n", gpu_data_type_to_string(output->type), output->id);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
}
GPUCodegen: Add New GPU_SOURCE_STRUCT to be used for Closure Sockets This way we dont rely on the static array of chars that was causing T52385. That fixes T52385.
2017-09-14 01:02:10 +02:00
}
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
}
BLI_dynstr_append(ds, "\n");
}
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
static void codegen_call_functions(DynStr *ds, GPUNodeGraph *graph, GPUOutput *finaloutput)
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
{
Cleanup: GPU_codegen.c: Use LISTBASE_FOREACH macro instead of for loops
2020-07-25 18:48:57 +02:00
LISTBASE_FOREACH (GPUNode *, node, &graph->nodes) {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_appendf(ds, " %s(", node->name);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: GPU_codegen.c: Use LISTBASE_FOREACH macro instead of for loops
2020-07-25 18:48:57 +02:00
LISTBASE_FOREACH (GPUInput *, input, &node->inputs) {
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
if (input->source == GPU_SOURCE_TEX) {
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
BLI_dynstr_append(ds, input->texture->sampler_name);
}
else if (input->source == GPU_SOURCE_TEX_TILED_MAPPING) {
BLI_dynstr_append(ds, input->texture->tiled_mapping_name);
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
}
Eevee: internal support for arbitrary number of volume grids This has no user visible impact yet since smoke volumes only support a fixed set of attributes, but will become important with the new volume object. For GPU shader compilation, volume grids are now handled separately from image textures. They are somewhere between a vertex attribute and an image texture, basically an attribute that is stored as a texture. Differential Revision: https://developer.blender.org/D6952
2020-03-11 14:58:19 +01:00
else if (input->source == GPU_SOURCE_VOLUME_GRID) {
BLI_dynstr_append(ds, input->volume_grid->sampler_name);
}
Objects: Eevee and workbench rendering of new Volume, Hair, PointCloud Only the volume drawing part is really finished and exposed to the user. Hair plugs into the existing hair rendering code and is fairly straightforward. The pointcloud drawing is a hack using overlays rather than Eevee and workbench. The most tricky part for volume rendering is the case where each volume grid has a different transform, which requires an additional matrix in the shader and non-trivial logic in Eevee volume drawing. In the common case were all the transforms match we don't use the additional per-grid matrix in the shader. Ref T73201, T68981 Differential Revision: https://developer.blender.org/D6955
2020-03-17 16:27:08 +01:00
else if (input->source == GPU_SOURCE_VOLUME_GRID_TRANSFORM) {
BLI_dynstr_append(ds, input->volume_grid->transform_name);
}
Cleanup: GPU codegen: remove most of legacy code A lot of code in codegen was used by previous GLSL system. Now most of it is not used due to all the things being written from scratch in 2.8 and we can clean most of it. As a side not this make the system a bit less flexible (no support for cubemaps, preview image, etc...) but can be extended again.
2018-08-13 18:44:27 +02:00
else if (input->source == GPU_SOURCE_OUTPUT) {
Cleanup: style for GPU module
2018-07-18 23:09:31 +10:00
codegen_convert_datatype(
ds, input->link->output->type, input->type, "tmp", input->link->output->id);
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
}
Fix GLSL not showing shading properly on the backside of faces. Now it flips the normal towards the viewer, seems to give consistent results with blender internal, cycles, normal maps, etc. Started from patch #32761 by Vitor Balbio, but changed it to do normal flipping earlier so it solves all cases.
2013-06-24 13:46:34 +00:00
else if (input->source == GPU_SOURCE_BUILTIN) {
Cleanup: consistent TODO/FIXME formatting for names Following the most widely used convention for including todo's in the code, that is: `TODO(name):`, `FIXME(name)` ... etc.
2020-09-19 14:32:41 +10:00
/* TODO(fclem): get rid of that. */
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
if (input->builtin == GPU_INVERSE_VIEW_MATRIX) {
GPUMaterial: Making material node tree compatible with new drawmanager. - code_generate_fragment : Making sure that shaders uses the new uniforms. - code_generate_vertex_new : create require attribute based on their names and not their id (see draw_cache_impl_mesh.c). - add support for ramp textures.
2017-05-01 18:09:50 +02:00
BLI_dynstr_append(ds, "viewinv");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (input->builtin == GPU_VIEW_MATRIX) {
GPUCodegen: fix missing ViewMatrix in new shading.
2017-06-01 13:22:30 +02:00
BLI_dynstr_append(ds, "viewmat");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (input->builtin == GPU_CAMERA_TEXCO_FACTORS) {
GPUMaterial: Fix regressions concerning background texco
2017-05-07 15:22:25 +02:00
BLI_dynstr_append(ds, "camtexfac");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (input->builtin == GPU_LOC_TO_VIEW_MATRIX) {
Eevee: Fix broken Vector Transform node The Camera to Object space matrix was not implemented in gpu_codegen.
2018-11-08 21:50:17 +01:00
BLI_dynstr_append(ds, "localtoviewmat");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (input->builtin == GPU_INVERSE_LOC_TO_VIEW_MATRIX) {
Eevee: Fix broken Vector Transform node The Camera to Object space matrix was not implemented in gpu_codegen.
2018-11-08 21:50:17 +01:00
BLI_dynstr_append(ds, "invlocaltoviewmat");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (input->builtin == GPU_BARYCENTRIC_DIST) {
Eevee: Implement Wireframe Node This implementation is a bit hacky but match cycles pretty close. If pixel size is not enabled, it will use the geom shader to compute distances between vertices. This will have a cost. Implementation is a bit hacky in gpu_codegen to make the geom shader works in an optional manner.
2018-09-20 17:41:07 +02:00
BLI_dynstr_append(ds, "barycentricDist");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (input->builtin == GPU_BARYCENTRIC_TEXCO) {
GPUMaterial: Geometry Node: Add support for parametric output This supports meshes and hairs too. Matches cycles output. This adds barycentric coords to the GPUBuiltin enum which will also be used for the wireframe node.
2018-08-20 17:59:21 +02:00
BLI_dynstr_append(ds, "barytexco");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (input->builtin == GPU_OBJECT_MATRIX) {
GPUMaterial: Add support for tangent node.
2017-05-18 14:29:57 +02:00
BLI_dynstr_append(ds, "objmat");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
DRW: Refactor to support draw call batching Reviewers: brecht Differential Revision: D4997
2019-05-31 01:45:41 +02:00
else if (input->builtin == GPU_OBJECT_INFO) {
BLI_dynstr_append(ds, "ObjectInfo");
}
else if (input->builtin == GPU_OBJECT_COLOR) {
BLI_dynstr_append(ds, "ObjectColor");
}
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
else if (input->builtin == GPU_INVERSE_OBJECT_MATRIX) {
Eevee: Draw background shader. Also fixes some remaining errors caused by some matrices not updated.
2017-05-04 17:39:50 +02:00
BLI_dynstr_append(ds, "objinv");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (input->builtin == GPU_VIEW_POSITION) {
GPUMaterial: Making material node tree compatible with new drawmanager. - code_generate_fragment : Making sure that shaders uses the new uniforms. - code_generate_vertex_new : create require attribute based on their names and not their id (see draw_cache_impl_mesh.c). - add support for ramp textures.
2017-05-01 18:09:50 +02:00
BLI_dynstr_append(ds, "viewposition");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
else if (input->builtin == GPU_VIEW_NORMAL) {
Fix GLSL not showing shading properly on the backside of faces. Now it flips the normal towards the viewer, seems to give consistent results with blender internal, cycles, normal maps, etc. Started from patch #32761 by Vitor Balbio, but changed it to do normal flipping earlier so it solves all cases.
2013-06-24 13:46:34 +00:00
BLI_dynstr_append(ds, "facingnormal");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
GPU: Remove GPU_INVERSE_NORMAL_MATRIX The end goal for this is to lower the number of needed matrices. This also cleanup some uneeded transformation.
2019-05-08 19:33:54 +02:00
else if (input->builtin == GPU_WORLD_NORMAL) {
BLI_dynstr_append(ds, "facingwnormal");
}
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
else {
Cleanup: split off code from gpu_codegen.c into smaller files
2020-02-12 12:48:44 +01:00
BLI_dynstr_append(ds, gpu_builtin_name(input->builtin));
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Fix GLSL not showing shading properly on the backside of faces. Now it flips the normal towards the viewer, seems to give consistent results with blender internal, cycles, normal maps, etc. Started from patch #32761 by Vitor Balbio, but changed it to do normal flipping earlier so it solves all cases.
2013-06-24 13:46:34 +00:00
}
GPUCodegen: Add New GPU_SOURCE_STRUCT to be used for Closure Sockets This way we dont rely on the static array of chars that was causing T52385. That fixes T52385.
2017-09-14 01:02:10 +02:00
else if (input->source == GPU_SOURCE_STRUCT) {
BLI_dynstr_appendf(ds, "strct%d", input->id);
}
Cleanup: GPU codegen: remove most of legacy code A lot of code in codegen was used by previous GLSL system. Now most of it is not used due to all the things being written from scratch in 2.8 and we can clean most of it. As a side not this make the system a bit less flexible (no support for cubemaps, preview image, etc...) but can be extended again.
2018-08-13 18:44:27 +02:00
else if (input->source == GPU_SOURCE_UNIFORM) {
BLI_dynstr_appendf(ds, "unf%d", input->id);
}
else if (input->source == GPU_SOURCE_CONSTANT) {
BLI_dynstr_appendf(ds, "cons%d", input->id);
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
}
Cleanup: replace attrib w/ attr Also rename GPUVertexAttribs to GPUVertAttrLayers, avoids confusion with GPUVertAttr which isn't closely related.
2019-01-29 07:46:25 +11:00
else if (input->source == GPU_SOURCE_ATTR) {
Materials: support true float4 attributes in the Attribute node. Add a new Alpha socket to the Attribute node that outputs the fourth component of the attribute. Currently the only such attribute is vertex color, but there may be more in the future. If the attribute has no alpha channel, the expected value is 1. The Cycles code is already refactored and committed by Brecht. Ref D2057
2020-08-04 17:56:39 +03:00
codegen_convert_datatype(ds, input->attr->gputype, input->type, "var", input->attr->id);
Refactor to recent matcap built-ins to not use the built in system. Those variables would get declared on fragment shader level and since we use reserved opengl variables, some compilers would throw an error (NVIDIA allows, some ATI compilers may break). Instead, use a separate opengl built-in category especially for them. This works on NVIDIA, and will wait for tests of this commit from ATI users.
2014-04-02 15:07:45 +03:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
BLI_dynstr_append(ds, ", ");
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: GPU_codegen.c: Use LISTBASE_FOREACH macro instead of for loops
2020-07-25 18:48:57 +02:00
LISTBASE_FOREACH (GPUOutput *, output, &node->outputs) {
Fixes for snprintf usage: * replace by BLI_snprintf in various places, note _snprintf on windows does not properly null terminate the string. * fix overflow in sequencer proxy code due to buffer being smaller than specified size. * fix some usage of snprintf as strcpy, this is will go wrong if the string contains % characters. * remove BLI_dynstr_printf function in gpu module, use BLI_dynstr_appendf
2011-08-30 10:07:50 +00:00
BLI_dynstr_appendf(ds, "tmp%d", output->id);
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
if (output->next) {
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
BLI_dynstr_append(ds, ", ");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
BLI_dynstr_append(ds, ");\n");
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_appendf(ds, "\n return tmp%d;\n", finaloutput->id);
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
}
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
static char *code_generate_fragment(GPUMaterial *material,
GPUNodeGraph *graph,
const char *interface_str)
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
{
DynStr *ds = BLI_dynstr_new();
char *code;
Fix GLSL not showing shading properly on the backside of faces. Now it flips the normal towards the viewer, seems to give consistent results with blender internal, cycles, normal maps, etc. Started from patch #32761 by Vitor Balbio, but changed it to do normal flipping earlier so it solves all cases.
2013-06-24 13:46:34 +00:00
int builtins;
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
codegen_set_unique_ids(graph);
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
/* Attributes, Shader stage interface. */
if (interface_str) {
BLI_dynstr_appendf(ds, "in codegenInterface {%s};\n\n", interface_str);
}
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
builtins = codegen_process_uniforms_functions(material, ds, graph);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
DRW: Refactor to support draw call batching Reviewers: brecht Differential Revision: D4997
2019-05-31 01:45:41 +02:00
if (builtins & (GPU_OBJECT_INFO | GPU_OBJECT_COLOR)) {
BLI_dynstr_append(ds, datatoc_gpu_shader_common_obinfos_lib_glsl);
}
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
if (builtins & GPU_BARYCENTRIC_TEXCO) {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, datatoc_gpu_shader_codegen_lib_glsl);
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPU Codegen: Add new closure socket type. This allow specialized shaders to redefine the closure interface to fit their needs. For instance, Volumetric closure needs to pass more than one vec4 (absorption vec3, scattering vec3, anisotropy float).
2017-07-03 21:39:52 +02:00
BLI_dynstr_append(ds, "Closure nodetree_exec(void)\n{\n");
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUMaterial: Geometry Node: Add support for parametric output This supports meshes and hairs too. Matches cycles output. This adds barycentric coords to the GPUBuiltin enum which will also be used for the wireframe node.
2018-08-20 17:59:21 +02:00
if (builtins & GPU_BARYCENTRIC_TEXCO) {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, " vec2 barytexco = barycentric_resolve(barycentricTexCo);\n");
GPUMaterial: Geometry Node: Add support for parametric output This supports meshes and hairs too. Matches cycles output. This adds barycentric coords to the GPUBuiltin enum which will also be used for the wireframe node.
2018-08-20 17:59:21 +02:00
}
Cleanup: consistent TODO/FIXME formatting for names Following the most widely used convention for including todo's in the code, that is: `TODO(name):`, `FIXME(name)` ... etc.
2020-09-19 14:32:41 +10:00
/* TODO(fclem): get rid of that. */
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
if (builtins & GPU_VIEW_MATRIX) {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, " #define viewmat ViewMatrix\n");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
if (builtins & GPU_CAMERA_TEXCO_FACTORS) {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, " #define camtexfac CameraTexCoFactors\n");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
if (builtins & GPU_OBJECT_MATRIX) {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, " #define objmat ModelMatrix\n");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
if (builtins & GPU_INVERSE_OBJECT_MATRIX) {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, " #define objinv ModelMatrixInverse\n");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
if (builtins & GPU_INVERSE_VIEW_MATRIX) {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, " #define viewinv ViewMatrixInverse\n");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
if (builtins & GPU_LOC_TO_VIEW_MATRIX) {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, " #define localtoviewmat (ViewMatrix * ModelMatrix)\n");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
if (builtins & GPU_INVERSE_LOC_TO_VIEW_MATRIX) {
GPU: Remove ModelViewMatrix and ModelViewMatrixInverse usage
2019-05-11 13:59:10 +02:00
BLI_dynstr_append(ds,
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
" #define invlocaltoviewmat (ModelMatrixInverse * ViewMatrixInverse)\n");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
if (builtins & GPU_VIEW_NORMAL) {
Fix T63435 Incorrect fresnel and normals for hair strands on EEVEE
2019-05-02 14:32:12 +02:00
BLI_dynstr_append(ds, "#ifdef HAIR_SHADER\n");
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, " vec3 n;\n");
BLI_dynstr_append(ds, " world_normals_get(n);\n");
BLI_dynstr_append(ds, " vec3 facingnormal = transform_direction(ViewMatrix, n);\n");
Fix T63435 Incorrect fresnel and normals for hair strands on EEVEE
2019-05-02 14:32:12 +02:00
BLI_dynstr_append(ds, "#else\n");
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, " vec3 facingnormal = gl_FrontFacing ? viewNormal: -viewNormal;\n");
Fix T63435 Incorrect fresnel and normals for hair strands on EEVEE
2019-05-02 14:32:12 +02:00
BLI_dynstr_append(ds, "#endif\n");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
GPU: Remove GPU_INVERSE_NORMAL_MATRIX The end goal for this is to lower the number of needed matrices. This also cleanup some uneeded transformation.
2019-05-08 19:33:54 +02:00
if (builtins & GPU_WORLD_NORMAL) {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, " vec3 facingwnormal;\n");
GPU: Remove GPU_INVERSE_NORMAL_MATRIX The end goal for this is to lower the number of needed matrices. This also cleanup some uneeded transformation.
2019-05-08 19:33:54 +02:00
if (builtins & GPU_VIEW_NORMAL) {
BLI_dynstr_append(ds, "#ifdef HAIR_SHADER\n");
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, " facingwnormal = n;\n");
GPU: Remove GPU_INVERSE_NORMAL_MATRIX The end goal for this is to lower the number of needed matrices. This also cleanup some uneeded transformation.
2019-05-08 19:33:54 +02:00
BLI_dynstr_append(ds, "#else\n");
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, " world_normals_get(facingwnormal);\n");
GPU: Remove GPU_INVERSE_NORMAL_MATRIX The end goal for this is to lower the number of needed matrices. This also cleanup some uneeded transformation.
2019-05-08 19:33:54 +02:00
BLI_dynstr_append(ds, "#endif\n");
}
else {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, " world_normals_get(facingwnormal);\n");
GPU: Remove GPU_INVERSE_NORMAL_MATRIX The end goal for this is to lower the number of needed matrices. This also cleanup some uneeded transformation.
2019-05-08 19:33:54 +02:00
}
}
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
if (builtins & GPU_VIEW_POSITION) {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, " #define viewposition viewPosition\n");
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
codegen_declare_tmps(ds, graph);
codegen_call_functions(ds, graph, graph->outlink->output);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
BLI_dynstr_append(ds, "}\n");
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
/* create shader */
code = BLI_dynstr_get_cstring(ds);
BLI_dynstr_free(ds);
cleanup: use spaces for alignment while studying GPU lib
2015-03-23 15:29:42 -04:00
#if 0
Cleanup: style, use braces in source/ (include disabled blocks)
2019-05-31 23:21:16 +10:00
if (G.debug & G_DEBUG) {
ClangFormat: format '#if 0' code in source/
2019-04-17 08:24:14 +02:00
printf("%s\n", code);
Cleanup: style, use braces in source/ (include disabled blocks)
2019-05-31 23:21:16 +10:00
}
cleanup: use spaces for alignment while studying GPU lib
2015-03-23 15:29:42 -04:00
#endif
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
return code;
}
Cleanup: replace attrib w/ attr Also rename GPUVertexAttribs to GPUVertAttrLayers, avoids confusion with GPUVertAttr which isn't closely related.
2019-01-29 07:46:25 +11:00
static const char *attr_prefix_get(CustomDataType type)
GPUMaterial: Making material node tree compatible with new drawmanager. - code_generate_fragment : Making sure that shaders uses the new uniforms. - code_generate_vertex_new : create require attribute based on their names and not their id (see draw_cache_impl_mesh.c). - add support for ramp textures.
2017-05-01 18:09:50 +02:00
{
switch (type) {
case CD_ORCO:
return "orco";
case CD_MTFACE:
return "u";
case CD_TANGENT:
return "t";
case CD_MCOL:
return "c";
Fix T78369: Sculpt Vertex Colors not rendering in EEVEE The vertex colors node was using the M_COL attribute type but Sculpt Vertex Colors use CD_PROP_COLOR Now the Vertex Color node also fallbacks to legacy vertex colors if Scultp Vertex Colors are not enabled as experimental. Reviewed By: brecht Maniphest Tasks: T78369 Differential Revision: https://developer.blender.org/D8185
2020-07-15 18:52:01 +02:00
case CD_PROP_COLOR:
return "c";
GPUMaterial: Making material node tree compatible with new drawmanager. - code_generate_fragment : Making sure that shaders uses the new uniforms. - code_generate_vertex_new : create require attribute based on their names and not their id (see draw_cache_impl_mesh.c). - add support for ramp textures.
2017-05-01 18:09:50 +02:00
case CD_AUTO_FROM_NAME:
return "a";
GWN: Port to GPU module: Replace GWN prefix by GPU
2018-07-18 00:12:21 +02:00
default:
BLI_assert(false && "GPUVertAttr Prefix type not found : This should not happen!");
return "";
GPUMaterial: Making material node tree compatible with new drawmanager. - code_generate_fragment : Making sure that shaders uses the new uniforms. - code_generate_vertex_new : create require attribute based on their names and not their id (see draw_cache_impl_mesh.c). - add support for ramp textures.
2017-05-01 18:09:50 +02:00
}
}
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
/* We talk about shader stage interface, not to be mistaken with GPUShaderInterface. */
static char *code_generate_interface(GPUNodeGraph *graph, int builtins)
GPUMaterial: Making material node tree compatible with new drawmanager. - code_generate_fragment : Making sure that shaders uses the new uniforms. - code_generate_vertex_new : create require attribute based on their names and not their id (see draw_cache_impl_mesh.c). - add support for ramp textures.
2017-05-01 18:09:50 +02:00
{
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
if (BLI_listbase_is_empty(&graph->attributes) &&
(builtins & (GPU_BARYCENTRIC_DIST | GPU_BARYCENTRIC_TEXCO)) == 0) {
return NULL;
}
GPUMaterial: Making material node tree compatible with new drawmanager. - code_generate_fragment : Making sure that shaders uses the new uniforms. - code_generate_vertex_new : create require attribute based on their names and not their id (see draw_cache_impl_mesh.c). - add support for ramp textures.
2017-05-01 18:09:50 +02:00
DynStr *ds = BLI_dynstr_new();
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, "\n");
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Code Quality: Replace for loops with LISTBASE_FOREACH Note this only changes cases where the variable was declared inside the for loop. To handle it outside as well is a different challenge. Differential Revision: https://developer.blender.org/D7320
2020-04-03 19:15:01 +02:00
LISTBASE_FOREACH (GPUMaterialAttribute *, attr, &graph->attributes) {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_appendf(ds, "%s var%d;\n", gpu_data_type_to_string(attr->gputype), attr->id);
}
if (builtins & GPU_BARYCENTRIC_TEXCO) {
BLI_dynstr_append(ds, "vec2 barycentricTexCo;\n");
}
if (builtins & GPU_BARYCENTRIC_DIST) {
BLI_dynstr_append(ds, "vec3 barycentricDist;\n");
}
char *code = BLI_dynstr_get_cstring(ds);
BLI_dynstr_free(ds);
return code;
}
static char *code_generate_vertex(GPUNodeGraph *graph,
const char *interface_str,
const char *vert_code,
int builtins)
{
DynStr *ds = BLI_dynstr_new();
BLI_dynstr_append(ds, datatoc_gpu_shader_codegen_lib_glsl);
/* Inputs */
LISTBASE_FOREACH (GPUMaterialAttribute *, attr, &graph->attributes) {
const char *type_str = gpu_data_type_to_string(attr->gputype);
const char *prefix = attr_prefix_get(attr->type);
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
/* XXX FIXME : see notes in mesh_render_data_create() */
/* NOTE : Replicate changes to mesh_render_data_create() in draw_cache_impl_mesh.c */
if (attr->type == CD_ORCO) {
/* OPTI : orco is computed from local positions, but only if no modifier is present. */
BLI_dynstr_append(ds, datatoc_gpu_shader_common_obinfos_lib_glsl);
BLI_dynstr_append(ds, "DEFINE_ATTR(vec4, orco);\n");
}
else if (attr->name[0] == '\0') {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_appendf(ds, "DEFINE_ATTR(%s, %s);\n", type_str, prefix);
BLI_dynstr_appendf(ds, "#define att%d %s\n", attr->id, prefix);
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
}
else {
Cleanup: use term 'attr' instead of 'attrib' This was already the case in most parts of the GPU API. Use full name for descriptive-comments.
2020-04-03 16:59:34 +11:00
char attr_safe_name[GPU_MAX_SAFE_ATTR_NAME];
GPU_vertformat_safe_attr_name(attr->name, attr_safe_name, GPU_MAX_SAFE_ATTR_NAME);
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_appendf(ds, "DEFINE_ATTR(%s, %s%s);\n", type_str, prefix, attr_safe_name);
BLI_dynstr_appendf(ds, "#define att%d %s%s\n", attr->id, prefix, attr_safe_name);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
}
}
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
/* Outputs interface */
if (interface_str) {
BLI_dynstr_appendf(ds, "out codegenInterface {%s};\n\n", interface_str);
Eevee: Implement Wireframe Node This implementation is a bit hacky but match cycles pretty close. If pixel size is not enabled, it will use the geom shader to compute distances between vertices. This will have a cost. Implementation is a bit hacky in gpu_codegen to make the geom shader works in an optional manner.
2018-09-20 17:41:07 +02:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
/* Prototype. Needed for hair functions. */
BLI_dynstr_append(ds, "void pass_attr(vec3 position, mat3 normalmat, mat4 modelmatinv);\n");
BLI_dynstr_append(ds, "#define USE_ATTR\n\n");
Cleanup: DRW: Move ModelMatrix declaration to common_view_lib
2019-05-14 00:48:17 +02:00
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, vert_code);
EEVEE: Volumetric: Fix Mesa Compiler error The compiler does not seems to understand the `const` in the function declaration and complains about non constant indexing of unsized array.
2020-09-01 00:52:57 +02:00
BLI_dynstr_append(ds, "\n\n");
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, "void pass_attr(vec3 position, mat3 normalmat, mat4 modelmatinv) {\n");
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Fix T62021: Wireframe input node doesn't work properly This fixes the general case. It is still not supported for hairs. Added a hack in the geometry node to avoid unnecessary geometry shader usage.
2019-02-28 13:56:03 +01:00
/* GPU_BARYCENTRIC_TEXCO cannot be computed based on gl_VertexID
* for MESH_SHADER because of indexed drawing. In this case a
* geometry shader is needed. */
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
if (builtins & GPU_BARYCENTRIC_TEXCO) {
BLI_dynstr_appendf(ds, " barycentricTexCo = barycentric_get();\n");
}
Eevee: Implement Wireframe Node This implementation is a bit hacky but match cycles pretty close. If pixel size is not enabled, it will use the geom shader to compute distances between vertices. This will have a cost. Implementation is a bit hacky in gpu_codegen to make the geom shader works in an optional manner.
2018-09-20 17:41:07 +02:00
if (builtins & GPU_BARYCENTRIC_DIST) {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_appendf(ds, " barycentricDist = vec3(0);\n");
Eevee: Implement Wireframe Node This implementation is a bit hacky but match cycles pretty close. If pixel size is not enabled, it will use the geom shader to compute distances between vertices. This will have a cost. Implementation is a bit hacky in gpu_codegen to make the geom shader works in an optional manner.
2018-09-20 17:41:07 +02:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Code Quality: Replace for loops with LISTBASE_FOREACH Note this only changes cases where the variable was declared inside the for loop. To handle it outside as well is a different challenge. Differential Revision: https://developer.blender.org/D7320
2020-04-03 19:15:01 +02:00
LISTBASE_FOREACH (GPUMaterialAttribute *, attr, &graph->attributes) {
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
if (attr->type == CD_TANGENT) { /* silly exception */
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_appendf(ds, " var%d = tangent_get(att%d, normalmat);\n", attr->id, attr->id);
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
}
else if (attr->type == CD_ORCO) {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_appendf(
ds, " var%d = orco_get(position, modelmatinv, OrcoTexCoFactors, orco);\n", attr->id);
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
}
else {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
const char *type_str = gpu_data_type_to_string(attr->gputype);
BLI_dynstr_appendf(ds, " var%d = GET_ATTR(%s, att%d);\n", attr->id, type_str, attr->id);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
}
}
GPUMaterial: Making material node tree compatible with new drawmanager. - code_generate_fragment : Making sure that shaders uses the new uniforms. - code_generate_vertex_new : create require attribute based on their names and not their id (see draw_cache_impl_mesh.c). - add support for ramp textures.
2017-05-01 18:09:50 +02:00
BLI_dynstr_append(ds, "}\n");
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
char *code = BLI_dynstr_get_cstring(ds);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUMaterial: Making material node tree compatible with new drawmanager. - code_generate_fragment : Making sure that shaders uses the new uniforms. - code_generate_vertex_new : create require attribute based on their names and not their id (see draw_cache_impl_mesh.c). - add support for ramp textures.
2017-05-01 18:09:50 +02:00
BLI_dynstr_free(ds);
#if 0
Cleanup: style, use braces in source/ (include disabled blocks)
2019-05-31 23:21:16 +10:00
if (G.debug & G_DEBUG) {
ClangFormat: format '#if 0' code in source/
2019-04-17 08:24:14 +02:00
printf("%s\n", code);
Cleanup: style, use braces in source/ (include disabled blocks)
2019-05-31 23:21:16 +10:00
}
GPUMaterial: Making material node tree compatible with new drawmanager. - code_generate_fragment : Making sure that shaders uses the new uniforms. - code_generate_vertex_new : create require attribute based on their names and not their id (see draw_cache_impl_mesh.c). - add support for ramp textures.
2017-05-01 18:09:50 +02:00
#endif
return code;
}
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
static char *code_generate_geometry(GPUNodeGraph *graph,
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
const char *interface_str,
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
const char *geom_code,
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
int builtins)
GPU_codegen: Add support for passing attributes through the geometry stage. Should fix some issues with missing attributes in Eevee.
2017-06-28 21:05:43 +02:00
{
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
if (!geom_code) {
return NULL;
GPU_codegen: Add support for passing attributes through the geometry stage. Should fix some issues with missing attributes in Eevee.
2017-06-28 21:05:43 +02:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
DynStr *ds = BLI_dynstr_new();
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
/* Attributes, Shader interface; */
if (interface_str) {
BLI_dynstr_appendf(ds, "in codegenInterface {%s} dataAttrIn[];\n\n", interface_str);
BLI_dynstr_appendf(ds, "out codegenInterface {%s} dataAttrOut;\n\n", interface_str);
Eevee: Implement Wireframe Node This implementation is a bit hacky but match cycles pretty close. If pixel size is not enabled, it will use the geom shader to compute distances between vertices. This will have a cost. Implementation is a bit hacky in gpu_codegen to make the geom shader works in an optional manner.
2018-09-20 17:41:07 +02:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, datatoc_gpu_shader_codegen_lib_glsl);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Eevee: Implement Wireframe Node This implementation is a bit hacky but match cycles pretty close. If pixel size is not enabled, it will use the geom shader to compute distances between vertices. This will have a cost. Implementation is a bit hacky in gpu_codegen to make the geom shader works in an optional manner.
2018-09-20 17:41:07 +02:00
if (builtins & GPU_BARYCENTRIC_DIST) {
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
/* geom_code should do something with this, but may not. */
BLI_dynstr_append(ds, "#define DO_BARYCENTRIC_DISTANCES\n");
GPU: Fix issue with multiple Geometry node.
2018-08-21 16:07:13 +02:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPU_codegen: Add support for passing attributes through the geometry stage. Should fix some issues with missing attributes in Eevee.
2017-06-28 21:05:43 +02:00
/* Generate varying assignments. */
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, "#define USE_ATTR\n");
EEVEE: Volumetric: Fix Mesa Compiler error The compiler does not seems to understand the `const` in the function declaration and complains about non constant indexing of unsized array.
2020-09-01 00:52:57 +02:00
/* This needs to be a define. Some drivers don't like variable vert index inside dataAttrIn. */
BLI_dynstr_append(ds, "#define pass_attr(vert) {\\\n");
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPU: Fix issue with multiple Geometry node.
2018-08-21 16:07:13 +02:00
if (builtins & GPU_BARYCENTRIC_TEXCO) {
EEVEE: Volumetric: Fix Mesa Compiler error The compiler does not seems to understand the `const` in the function declaration and complains about non constant indexing of unsized array.
2020-09-01 00:52:57 +02:00
BLI_dynstr_append(ds, "dataAttrOut.barycentricTexCo = calc_barycentric_co(vert);\\\n");
GPU: Fix issue with multiple Geometry node.
2018-08-21 16:07:13 +02:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Code Quality: Replace for loops with LISTBASE_FOREACH Note this only changes cases where the variable was declared inside the for loop. To handle it outside as well is a different challenge. Differential Revision: https://developer.blender.org/D7320
2020-04-03 19:15:01 +02:00
LISTBASE_FOREACH (GPUMaterialAttribute *, attr, &graph->attributes) {
Cleanup: more refactoring of GPU material attributes and textures This further separates requested attributes and textures from the actual node graph, that can be retained after the graph has been compiled and freed. It makes it easier to add volume grids as a native concept, which sits somewhere between an attribute and a texture. It also adds explicit link types for UDIM tile mapping, rather than relying on fairly hidden logic.
2020-02-27 13:55:29 +01:00
/* TODO let shader choose what to do depending on what the attribute is. */
EEVEE: Volumetric: Fix Mesa Compiler error The compiler does not seems to understand the `const` in the function declaration and complains about non constant indexing of unsized array.
2020-09-01 00:52:57 +02:00
BLI_dynstr_appendf(ds, "dataAttrOut.var%d = dataAttrIn[vert].var%d;\\\n", attr->id, attr->id);
GPU_codegen: Add support for passing attributes through the geometry stage. Should fix some issues with missing attributes in Eevee.
2017-06-28 21:05:43 +02:00
}
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, "}\n\n");
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
BLI_dynstr_append(ds, geom_code);
char *code = BLI_dynstr_get_cstring(ds);
GPU_codegen: Add support for passing attributes through the geometry stage. Should fix some issues with missing attributes in Eevee.
2017-06-28 21:05:43 +02:00
BLI_dynstr_free(ds);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPU_codegen: Add support for passing attributes through the geometry stage. Should fix some issues with missing attributes in Eevee.
2017-06-28 21:05:43 +02:00
return code;
}
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
GPUShader *GPU_pass_shader_get(GPUPass *pass)
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
{
return pass->shader;
}
/* Pass create/free */
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
static bool gpu_pass_is_valid(GPUPass *pass)
{
GPUMaterial: Fix Material appear broken when using sliders to tweak props This was likely caused by some sort of race condition where the drawing thread would request the state of the shader before the shader has been compiled.
2018-08-08 12:18:02 +02:00
/* Shader is not null if compilation is successful. */
return (pass->compiled == false || pass->shader != NULL);
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
}
Cleanup: Remove "_new" from GPU_generate_pass_new Not needed anymore since old one has been deleted.
2018-09-19 19:34:00 +02:00
GPUPass *GPU_generate_pass(GPUMaterial *material,
Cleanup: split off code from gpu_codegen.c into smaller files
2020-02-12 12:48:44 +01:00
GPUNodeGraph *graph,
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
const char *vert_code,
const char *geom_code,
const char *frag_lib,
const char *defines)
Eevee: World nodetree gpumaterial compatibility. - Unify GPUMaterial creation (world/mesh). - Support for multiple shader variations (not used for now). - Convert GPUInputs to DRWUniforms to be used with the draw manager. - Nodetree Update is not supported. The only way to refresh the shaders is to change render engine. - Cleanup in GPUPass. - Add new temporary Node Compatibility type. Compatibility types should be removed in the future.
2017-04-27 22:27:09 +02:00
{
Cleanup: don't perform some GPU shader codegen operations twice
2020-02-12 12:48:44 +01:00
/* Prune the unused nodes and extract attributes before compiling so the
* generated VBOs are ready to accept the future shader. */
Cleanup: split off code from gpu_codegen.c into smaller files
2020-02-12 12:48:44 +01:00
gpu_node_graph_prune_unused(graph);
Cleanup: refactor GPU material attribute and texture requests
2020-02-14 10:47:20 +01:00
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
int builtins = 0;
LISTBASE_FOREACH (GPUNode *, node, &graph->nodes) {
LISTBASE_FOREACH (GPUInput *, input, &node->inputs) {
if (input->source == GPU_SOURCE_BUILTIN) {
builtins |= input->builtin;
}
}
}
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
/* generate code */
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
char *interface_str = code_generate_interface(graph, builtins);
char *fragmentgen = code_generate_fragment(material, graph, interface_str);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
/* Cache lookup: Reuse shaders already compiled */
Cleanup: refactor GPU material attribute and texture requests
2020-02-14 10:47:20 +01:00
uint32_t hash = gpu_pass_hash(fragmentgen, defines, &graph->attributes);
GPUPass *pass_hash = gpu_pass_cache_lookup(hash);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
if (pass_hash && (pass_hash->next == NULL || pass_hash->next->hash != hash)) {
/* No collision, just return the pass. */
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
MEM_SAFE_FREE(interface_str);
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
MEM_freeN(fragmentgen);
if (!gpu_pass_is_valid(pass_hash)) {
/* Shader has already been created but failed to compile. */
return NULL;
}
pass_hash->refcount += 1;
return pass_hash;
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
/* Either the shader is not compiled or there is a hash collision...
* continue generating the shader strings. */
Cleanup: split off code from gpu_codegen.c into smaller files
2020-02-12 12:48:44 +01:00
GSet *used_libraries = gpu_material_used_libraries(material);
char *tmp = gpu_material_library_generate_code(used_libraries, frag_lib);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
char *geometrycode = code_generate_geometry(graph, interface_str, geom_code, builtins);
char *vertexcode = code_generate_vertex(graph, interface_str, vert_code, builtins);
Cleanup: refactor GPU material attribute and texture requests
2020-02-14 10:47:20 +01:00
char *fragmentcode = BLI_strdupcat(tmp, fragmentgen);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
EEVEE: GLSL refactor/cleanup - add the use of DRWShaderLibrary to EEVEE's glsl codebase to reduce code complexity and duplication. - split bsdf_common_lib.glsl into multiple sub library which are now shared with other engines. - the surface shader code is now more organised and have its own files. - change default world to use a material nodetree and make lookdev shader more clear. Reviewed By: jbakker Differential Revision: https://developer.blender.org/D8306
2020-07-30 13:55:13 +02:00
MEM_SAFE_FREE(interface_str);
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
MEM_freeN(fragmentgen);
Eevee: World nodetree gpumaterial compatibility. - Unify GPUMaterial creation (world/mesh). - Support for multiple shader variations (not used for now). - Convert GPUInputs to DRWUniforms to be used with the draw manager. - Nodetree Update is not supported. The only way to refresh the shaders is to change render engine. - Cleanup in GPUPass. - Add new temporary Node Compatibility type. Compatibility types should be removed in the future.
2017-04-27 22:27:09 +02:00
MEM_freeN(tmp);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: refactor GPU material attribute and texture requests
2020-02-14 10:47:20 +01:00
GPUPass *pass = NULL;
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
if (pass_hash) {
/* Cache lookup: Reuse shaders already compiled */
pass = gpu_pass_cache_resolve_collision(
pass_hash, vertexcode, geometrycode, fragmentcode, defines, hash);
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
if (pass) {
Cleanup: refactor GPU material attribute and texture requests
2020-02-14 10:47:20 +01:00
MEM_SAFE_FREE(vertexcode);
MEM_SAFE_FREE(fragmentcode);
MEM_SAFE_FREE(geometrycode);
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
/* Cache hit. Reuse the same GPUPass and GPUShader. */
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
if (!gpu_pass_is_valid(pass)) {
/* Shader has already been created but failed to compile. */
return NULL;
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
pass->refcount += 1;
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
}
else {
/* We still create a pass even if shader compilation
* fails to avoid trying to compile again and again. */
pass = MEM_callocN(sizeof(GPUPass), "GPUPass");
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
pass->shader = NULL;
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
pass->refcount = 1;
pass->hash = hash;
pass->vertexcode = vertexcode;
pass->fragmentcode = fragmentcode;
pass->geometrycode = geometrycode;
pass->defines = (defines) ? BLI_strdup(defines) : NULL;
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
pass->compiled = false;
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
BLI_spin_lock(&pass_cache_spin);
if (pass_hash != NULL) {
/* Add after the first pass having the same hash. */
pass->next = pass_hash->next;
pass_hash->next = pass;
}
else {
/* No other pass have same hash, just prepend to the list. */
BLI_LINKS_PREPEND(pass_cache, pass);
}
BLI_spin_unlock(&pass_cache_spin);
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
return pass;
}
GPUShader: Manually validate sampler count This happens on NVidia GPUs, using more textures than the maximum allowed by the gl will NOT trigger a linking issue (maybe because of bindless texture implementation?). So in this case we manually count the number of samplers per shader stage and compare it against the GL limit. We discard the shader if the sampler count is too high. This shows the user something is wrong with the shader.
2018-09-18 14:22:42 +02:00
static int count_active_texture_sampler(GPUShader *shader, char *source)
{
char *code = source;
Fix T72467: Crash when using many (>64) images in a shader Previously this limit was rather high, but with UDIMs it's fairly easy to reach this many images. Even though this exceeds the texture limit on most hardware as far as I can tell, it should at least not crash. The old code uses a fixed array which overflows eventually, this fix replaces the array with a GSet. Reviewed By: fclem Differential Revision: https://developer.blender.org/D6416
2019-12-16 15:49:19 +01:00
/* Remember this is per stage. */
GSet *sampler_ids = BLI_gset_int_new(__func__);
int num_samplers = 0;
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: style
2018-09-19 10:29:57 +10:00
while ((code = strstr(code, "uniform "))) {
GPUShader: Manually validate sampler count This happens on NVidia GPUs, using more textures than the maximum allowed by the gl will NOT trigger a linking issue (maybe because of bindless texture implementation?). So in this case we manually count the number of samplers per shader stage and compare it against the GL limit. We discard the shader if the sampler count is too high. This shows the user something is wrong with the shader.
2018-09-18 14:22:42 +02:00
/* Move past "uniform". */
code += 7;
/* Skip following spaces. */
while (*code == ' ') {
code++;
}
/* Skip "i" from potential isamplers. */
if (*code == 'i') {
code++;
}
/* Skip following spaces. */
Cleanup: split off code from gpu_codegen.c into smaller files
2020-02-12 12:48:44 +01:00
if (BLI_str_startswith(code, "sampler")) {
GPUShader: Manually validate sampler count This happens on NVidia GPUs, using more textures than the maximum allowed by the gl will NOT trigger a linking issue (maybe because of bindless texture implementation?). So in this case we manually count the number of samplers per shader stage and compare it against the GL limit. We discard the shader if the sampler count is too high. This shows the user something is wrong with the shader.
2018-09-18 14:22:42 +02:00
/* Move past "uniform". */
code += 7;
/* Skip sampler type suffix. */
while (*code != ' ' && *code != '\0') {
code++;
}
/* Skip following spaces. */
while (*code == ' ') {
code++;
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUShader: Manually validate sampler count This happens on NVidia GPUs, using more textures than the maximum allowed by the gl will NOT trigger a linking issue (maybe because of bindless texture implementation?). So in this case we manually count the number of samplers per shader stage and compare it against the GL limit. We discard the shader if the sampler count is too high. This shows the user something is wrong with the shader.
2018-09-18 14:22:42 +02:00
if (*code != '\0') {
char sampler_name[64];
code = gpu_str_skip_token(code, sampler_name, sizeof(sampler_name));
Cleanup: GPU: Remove GPU_shaderinterface_uniform_ensure
2020-06-02 12:29:20 +02:00
int id = GPU_shader_get_uniform(shader, sampler_name);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUShader: Manually validate sampler count This happens on NVidia GPUs, using more textures than the maximum allowed by the gl will NOT trigger a linking issue (maybe because of bindless texture implementation?). So in this case we manually count the number of samplers per shader stage and compare it against the GL limit. We discard the shader if the sampler count is too high. This shows the user something is wrong with the shader.
2018-09-18 14:22:42 +02:00
if (id == -1) {
continue;
}
/* Catch duplicates. */
Fix T72467: Crash when using many (>64) images in a shader Previously this limit was rather high, but with UDIMs it's fairly easy to reach this many images. Even though this exceeds the texture limit on most hardware as far as I can tell, it should at least not crash. The old code uses a fixed array which overflows eventually, this fix replaces the array with a GSet. Reviewed By: fclem Differential Revision: https://developer.blender.org/D6416
2019-12-16 15:49:19 +01:00
if (BLI_gset_add(sampler_ids, POINTER_FROM_INT(id))) {
num_samplers++;
GPUShader: Manually validate sampler count This happens on NVidia GPUs, using more textures than the maximum allowed by the gl will NOT trigger a linking issue (maybe because of bindless texture implementation?). So in this case we manually count the number of samplers per shader stage and compare it against the GL limit. We discard the shader if the sampler count is too high. This shows the user something is wrong with the shader.
2018-09-18 14:22:42 +02:00
}
}
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
}
Fix T72467: Crash when using many (>64) images in a shader Previously this limit was rather high, but with UDIMs it's fairly easy to reach this many images. Even though this exceeds the texture limit on most hardware as far as I can tell, it should at least not crash. The old code uses a fixed array which overflows eventually, this fix replaces the array with a GSet. Reviewed By: fclem Differential Revision: https://developer.blender.org/D6416
2019-12-16 15:49:19 +01:00
BLI_gset_free(sampler_ids, NULL);
return num_samplers;
GPUShader: Manually validate sampler count This happens on NVidia GPUs, using more textures than the maximum allowed by the gl will NOT trigger a linking issue (maybe because of bindless texture implementation?). So in this case we manually count the number of samplers per shader stage and compare it against the GL limit. We discard the shader if the sampler count is too high. This shows the user something is wrong with the shader.
2018-09-18 14:22:42 +02:00
}
Fix crash when editing shaders on Intel HD 4000. In the Intel HD 4000 driver a shader has to be deleted in the same context in which it is created. However, because you can't use a rendering context on different threads, to maintain the multithreaded compilation, the solution was to use the `GL_ARB_get_program_binary` and copy the binary generated for the shader and generate a shader on the main context using that binary. This solution is limited only to Intel HD 4000 and windows. Reviewers: fclem Reviewed By: fclem Differential Revision: https://developer.blender.org/D5019
2019-06-05 13:06:11 -03:00
static bool gpu_pass_shader_validate(GPUPass *pass, GPUShader *shader)
GPUShader: Manually validate sampler count This happens on NVidia GPUs, using more textures than the maximum allowed by the gl will NOT trigger a linking issue (maybe because of bindless texture implementation?). So in this case we manually count the number of samplers per shader stage and compare it against the GL limit. We discard the shader if the sampler count is too high. This shows the user something is wrong with the shader.
2018-09-18 14:22:42 +02:00
{
Fix crash when editing shaders on Intel HD 4000. In the Intel HD 4000 driver a shader has to be deleted in the same context in which it is created. However, because you can't use a rendering context on different threads, to maintain the multithreaded compilation, the solution was to use the `GL_ARB_get_program_binary` and copy the binary generated for the shader and generate a shader on the main context using that binary. This solution is limited only to Intel HD 4000 and windows. Reviewers: fclem Reviewed By: fclem Differential Revision: https://developer.blender.org/D5019
2019-06-05 13:06:11 -03:00
if (shader == NULL) {
GPUShader: Manually validate sampler count This happens on NVidia GPUs, using more textures than the maximum allowed by the gl will NOT trigger a linking issue (maybe because of bindless texture implementation?). So in this case we manually count the number of samplers per shader stage and compare it against the GL limit. We discard the shader if the sampler count is too high. This shows the user something is wrong with the shader.
2018-09-18 14:22:42 +02:00
return false;
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUShader: Manually validate sampler count This happens on NVidia GPUs, using more textures than the maximum allowed by the gl will NOT trigger a linking issue (maybe because of bindless texture implementation?). So in this case we manually count the number of samplers per shader stage and compare it against the GL limit. We discard the shader if the sampler count is too high. This shows the user something is wrong with the shader.
2018-09-18 14:22:42 +02:00
/* NOTE: The only drawback of this method is that it will count a sampler
* used in the fragment shader and only declared (but not used) in the vertex
* shader as used by both. But this corner case is not happening for now. */
Fix crash when editing shaders on Intel HD 4000. In the Intel HD 4000 driver a shader has to be deleted in the same context in which it is created. However, because you can't use a rendering context on different threads, to maintain the multithreaded compilation, the solution was to use the `GL_ARB_get_program_binary` and copy the binary generated for the shader and generate a shader on the main context using that binary. This solution is limited only to Intel HD 4000 and windows. Reviewers: fclem Reviewed By: fclem Differential Revision: https://developer.blender.org/D5019
2019-06-05 13:06:11 -03:00
int vert_samplers_len = count_active_texture_sampler(shader, pass->vertexcode);
int frag_samplers_len = count_active_texture_sampler(shader, pass->fragmentcode);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUShader: Manually validate sampler count This happens on NVidia GPUs, using more textures than the maximum allowed by the gl will NOT trigger a linking issue (maybe because of bindless texture implementation?). So in this case we manually count the number of samplers per shader stage and compare it against the GL limit. We discard the shader if the sampler count is too high. This shows the user something is wrong with the shader.
2018-09-18 14:22:42 +02:00
int total_samplers_len = vert_samplers_len + frag_samplers_len;
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUShader: Manually validate sampler count This happens on NVidia GPUs, using more textures than the maximum allowed by the gl will NOT trigger a linking issue (maybe because of bindless texture implementation?). So in this case we manually count the number of samplers per shader stage and compare it against the GL limit. We discard the shader if the sampler count is too high. This shows the user something is wrong with the shader.
2018-09-18 14:22:42 +02:00
/* Validate against opengl limit. */
if ((frag_samplers_len > GPU_max_textures_frag()) ||
GPU: Fix typo
2019-04-05 20:46:13 +02:00
(vert_samplers_len > GPU_max_textures_vert())) {
GPUShader: Manually validate sampler count This happens on NVidia GPUs, using more textures than the maximum allowed by the gl will NOT trigger a linking issue (maybe because of bindless texture implementation?). So in this case we manually count the number of samplers per shader stage and compare it against the GL limit. We discard the shader if the sampler count is too high. This shows the user something is wrong with the shader.
2018-09-18 14:22:42 +02:00
return false;
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUShader: Manually validate sampler count This happens on NVidia GPUs, using more textures than the maximum allowed by the gl will NOT trigger a linking issue (maybe because of bindless texture implementation?). So in this case we manually count the number of samplers per shader stage and compare it against the GL limit. We discard the shader if the sampler count is too high. This shows the user something is wrong with the shader.
2018-09-18 14:22:42 +02:00
if (pass->geometrycode) {
Fix crash when editing shaders on Intel HD 4000. In the Intel HD 4000 driver a shader has to be deleted in the same context in which it is created. However, because you can't use a rendering context on different threads, to maintain the multithreaded compilation, the solution was to use the `GL_ARB_get_program_binary` and copy the binary generated for the shader and generate a shader on the main context using that binary. This solution is limited only to Intel HD 4000 and windows. Reviewers: fclem Reviewed By: fclem Differential Revision: https://developer.blender.org/D5019
2019-06-05 13:06:11 -03:00
int geom_samplers_len = count_active_texture_sampler(shader, pass->geometrycode);
GPUShader: Manually validate sampler count This happens on NVidia GPUs, using more textures than the maximum allowed by the gl will NOT trigger a linking issue (maybe because of bindless texture implementation?). So in this case we manually count the number of samplers per shader stage and compare it against the GL limit. We discard the shader if the sampler count is too high. This shows the user something is wrong with the shader.
2018-09-18 14:22:42 +02:00
total_samplers_len += geom_samplers_len;
if (geom_samplers_len > GPU_max_textures_geom()) {
return false;
}
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUShader: Manually validate sampler count This happens on NVidia GPUs, using more textures than the maximum allowed by the gl will NOT trigger a linking issue (maybe because of bindless texture implementation?). So in this case we manually count the number of samplers per shader stage and compare it against the GL limit. We discard the shader if the sampler count is too high. This shows the user something is wrong with the shader.
2018-09-18 14:22:42 +02:00
return (total_samplers_len <= GPU_max_textures());
}
Fix crash when editing shaders on Intel HD 4000. In the Intel HD 4000 driver a shader has to be deleted in the same context in which it is created. However, because you can't use a rendering context on different threads, to maintain the multithreaded compilation, the solution was to use the `GL_ARB_get_program_binary` and copy the binary generated for the shader and generate a shader on the main context using that binary. This solution is limited only to Intel HD 4000 and windows. Reviewers: fclem Reviewed By: fclem Differential Revision: https://developer.blender.org/D5019
2019-06-05 13:06:11 -03:00
bool GPU_pass_compile(GPUPass *pass, const char *shname)
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
{
Cleanup: misc spelling fixes in variable names & defines T68045 by @luzpaz
2019-08-01 17:32:42 +10:00
bool success = true;
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
if (!pass->compiled) {
Fix crash when editing shaders on Intel HD 4000. In the Intel HD 4000 driver a shader has to be deleted in the same context in which it is created. However, because you can't use a rendering context on different threads, to maintain the multithreaded compilation, the solution was to use the `GL_ARB_get_program_binary` and copy the binary generated for the shader and generate a shader on the main context using that binary. This solution is limited only to Intel HD 4000 and windows. Reviewers: fclem Reviewed By: fclem Differential Revision: https://developer.blender.org/D5019
2019-06-05 13:06:11 -03:00
GPUShader *shader = GPU_shader_create(
Cleanup: style for GPU module
2018-07-18 23:09:31 +10:00
pass->vertexcode, pass->fragmentcode, pass->geometrycode, NULL, pass->defines, shname);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUShader: Manually validate sampler count This happens on NVidia GPUs, using more textures than the maximum allowed by the gl will NOT trigger a linking issue (maybe because of bindless texture implementation?). So in this case we manually count the number of samplers per shader stage and compare it against the GL limit. We discard the shader if the sampler count is too high. This shows the user something is wrong with the shader.
2018-09-18 14:22:42 +02:00
/* NOTE: Some drivers / gpu allows more active samplers than the opengl limit.
Fix/cleanup another bunch of UI messages issues. Also (mostly in comments): behaviour -> behavior (we use American English).
2018-12-24 12:31:39 +01:00
* We need to make sure to count active samplers to avoid undefined behavior. */
Fix crash when editing shaders on Intel HD 4000. In the Intel HD 4000 driver a shader has to be deleted in the same context in which it is created. However, because you can't use a rendering context on different threads, to maintain the multithreaded compilation, the solution was to use the `GL_ARB_get_program_binary` and copy the binary generated for the shader and generate a shader on the main context using that binary. This solution is limited only to Intel HD 4000 and windows. Reviewers: fclem Reviewed By: fclem Differential Revision: https://developer.blender.org/D5019
2019-06-05 13:06:11 -03:00
if (!gpu_pass_shader_validate(pass, shader)) {
Cleanup: misc spelling fixes in variable names & defines T68045 by @luzpaz
2019-08-01 17:32:42 +10:00
success = false;
Fix crash when editing shaders on Intel HD 4000. In the Intel HD 4000 driver a shader has to be deleted in the same context in which it is created. However, because you can't use a rendering context on different threads, to maintain the multithreaded compilation, the solution was to use the `GL_ARB_get_program_binary` and copy the binary generated for the shader and generate a shader on the main context using that binary. This solution is limited only to Intel HD 4000 and windows. Reviewers: fclem Reviewed By: fclem Differential Revision: https://developer.blender.org/D5019
2019-06-05 13:06:11 -03:00
if (shader != NULL) {
GPUShader: Manually validate sampler count This happens on NVidia GPUs, using more textures than the maximum allowed by the gl will NOT trigger a linking issue (maybe because of bindless texture implementation?). So in this case we manually count the number of samplers per shader stage and compare it against the GL limit. We discard the shader if the sampler count is too high. This shows the user something is wrong with the shader.
2018-09-18 14:22:42 +02:00
fprintf(stderr, "GPUShader: error: too many samplers in shader.\n");
Fix crash when editing shaders on Intel HD 4000. In the Intel HD 4000 driver a shader has to be deleted in the same context in which it is created. However, because you can't use a rendering context on different threads, to maintain the multithreaded compilation, the solution was to use the `GL_ARB_get_program_binary` and copy the binary generated for the shader and generate a shader on the main context using that binary. This solution is limited only to Intel HD 4000 and windows. Reviewers: fclem Reviewed By: fclem Differential Revision: https://developer.blender.org/D5019
2019-06-05 13:06:11 -03:00
GPU_shader_free(shader);
shader = NULL;
GPUShader: Manually validate sampler count This happens on NVidia GPUs, using more textures than the maximum allowed by the gl will NOT trigger a linking issue (maybe because of bindless texture implementation?). So in this case we manually count the number of samplers per shader stage and compare it against the GL limit. We discard the shader if the sampler count is too high. This shows the user something is wrong with the shader.
2018-09-18 14:22:42 +02:00
}
}
Fix crash when editing shaders on Intel HD 4000. In the Intel HD 4000 driver a shader has to be deleted in the same context in which it is created. However, because you can't use a rendering context on different threads, to maintain the multithreaded compilation, the solution was to use the `GL_ARB_get_program_binary` and copy the binary generated for the shader and generate a shader on the main context using that binary. This solution is limited only to Intel HD 4000 and windows. Reviewers: fclem Reviewed By: fclem Differential Revision: https://developer.blender.org/D5019
2019-06-05 13:06:11 -03:00
pass->shader = shader;
GPU: Avoid access violation while reading the `pass->shader`.
2019-03-11 20:32:00 -03:00
pass->compiled = true;
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
}
Fix crash when editing shaders on Intel HD 4000. In the Intel HD 4000 driver a shader has to be deleted in the same context in which it is created. However, because you can't use a rendering context on different threads, to maintain the multithreaded compilation, the solution was to use the `GL_ARB_get_program_binary` and copy the binary generated for the shader and generate a shader on the main context using that binary. This solution is limited only to Intel HD 4000 and windows. Reviewers: fclem Reviewed By: fclem Differential Revision: https://developer.blender.org/D5019
2019-06-05 13:06:11 -03:00
Cleanup: misc spelling fixes in variable names & defines T68045 by @luzpaz
2019-08-01 17:32:42 +10:00
return success;
Eevee: World nodetree gpumaterial compatibility. - Unify GPUMaterial creation (world/mesh). - Support for multiple shader variations (not used for now). - Convert GPUInputs to DRWUniforms to be used with the draw manager. - Nodetree Update is not supported. The only way to refresh the shaders is to change render engine. - Cleanup in GPUPass. - Add new temporary Node Compatibility type. Compatibility types should be removed in the future.
2017-04-27 22:27:09 +02:00
}
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
void GPU_pass_release(GPUPass *pass)
{
BLI_assert(pass->refcount > 0);
pass->refcount--;
}
static void gpu_pass_free(GPUPass *pass)
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
{
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
BLI_assert(pass->refcount == 0);
GPU Codegen: Fix assert caused by GC of failled shaders.
2018-04-09 12:09:51 +02:00
if (pass->shader) {
GPU_shader_free(pass->shader);
}
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
MEM_SAFE_FREE(pass->fragmentcode);
MEM_SAFE_FREE(pass->geometrycode);
MEM_SAFE_FREE(pass->vertexcode);
MEM_SAFE_FREE(pass->defines);
Merge of first part of changes from the apricot branch, especially the features that are needed to run the game. Compile tested with scons, make, but not cmake, that seems to have an issue not related to these changes. The changes include: * GLSL support in the viewport and game engine, enable in the game menu in textured draw mode. * Synced and merged part of the duplicated blender and gameengine/ gameplayer drawing code. * Further refactoring of game engine drawing code, especially mesh storage changed a lot. * Optimizations in game engine armatures to avoid recomputations. * A python function to get the framerate estimate in game. * An option take object color into account in materials. * An option to restrict shadow casters to a lamp's layers. * Increase from 10 to 18 texture slots for materials, lamps, word. An extra texture slot shows up once the last slot is used. * Memory limit for undo, not enabled by default yet because it needs the .B.blend to be changed. * Multiple undo for image painting. * An offset for dupligroups, so not all objects in a group have to be at the origin.
2008-09-04 20:51:28 +00:00
MEM_freeN(pass);
}
Fix T48829: Memory leak on Blender Exit It was possible to have missing outlink but GPUNodes in material.
2016-07-27 10:59:09 +02:00
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
void GPU_pass_cache_garbage_collect(void)
{
static int lasttime = 0;
const int shadercollectrate = 60; /* hardcoded for now. */
int ctime = (int)PIL_check_seconds_timer();
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
if (ctime < shadercollectrate + lasttime) {
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
return;
Cleanup: style, use braces for gpu
2019-04-22 09:32:37 +10:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
lasttime = ctime;
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
BLI_spin_lock(&pass_cache_spin);
GPUPass *next, **prev_pass = &pass_cache;
for (GPUPass *pass = pass_cache; pass; pass = next) {
next = pass->next;
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
if (pass->refcount == 0) {
/* Remove from list */
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
*prev_pass = next;
gpu_pass_free(pass);
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
}
else {
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
prev_pass = &pass->next;
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
}
}
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
BLI_spin_unlock(&pass_cache_spin);
}
void GPU_pass_cache_init(void)
{
BLI_spin_init(&pass_cache_spin);
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
}
void GPU_pass_cache_free(void)
{
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
BLI_spin_lock(&pass_cache_spin);
while (pass_cache) {
GPUPass *next = pass_cache->next;
gpu_pass_free(pass_cache);
pass_cache = next;
}
BLI_spin_unlock(&pass_cache_spin);
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
GPUPass: Refactor gpupass caching system to allow fast gpumaterial creation. This is part of the work needed to refactor the material parameters update. Now the gpupass cache is polled before adding the gpumaterial to the deferred compilation queue. We store gpupasses in a single linked list grouped based on their hashes. This is not the most efficient way but it can be improved upon later.
2018-06-07 11:58:15 +02:00
BLI_spin_end(&pass_cache_spin);
GPUMaterial: Add Material shader cache. This is mostly to avoid re-compilation when using undo/redo operators. This also has the benefit to reuse the same GPUShader for multiple materials using the same nodetree configuration. The cache stores GPUPasses that already contains the shader code and a hash to test for matches. We use refcounts to know when a GPUPass is not used anymore. I had to move the GPUInput list from GPUPass to GPUMaterial because it's containing references to the material nodetree and cannot be reused. A garbage collection is hardcoded to run every 60 seconds to free every unused GPUPass.
2018-03-11 23:43:09 +01:00
}
Cleanup: split off code from gpu_codegen.c into smaller files
2020-02-12 12:48:44 +01:00
/* Module */
void gpu_codegen_init(void)
{
}
void gpu_codegen_exit(void)
{
BKE_material_defaults_free_gpu();
GPU_shader_free_builtin_shaders();
}
Copy Permalink