Remove Blender Internal and legacy viewport from Blender 2.8.

Brecht authored this commit, but he gave me the honours to actually do it. Here it goes; Blender Internal. Bye bye, you did great! * Point density, voxel data, ocean, environment map textures were removed, as these only worked within BI rendering. Note that the ocean modifier and the Cycles point density shader node continue to work. * Dynamic paint using material shading was removed, as this only worked with BI. If we ever wanted to support this again probably it should go through the baking API. * GPU shader export through the Python API was removed. This only worked for the old BI GLSL shaders, which no longer exists. Doing something similar for Eevee would be significantly more complicated because it uses a lot of multiplass rendering and logic outside the shader, it's probably impractical. * Collada material import / export code is mostly gone, as it only worked for BI materials. We need to add Cycles / Eevee material support at some point. * The mesh noise operator was removed since it only worked with BI material texture slots. A displacement modifier can be used instead. * The delete texture paint slot operator was removed since it only worked for BI material texture slots. Could be added back with node support. * Not all legacy viewport features are supported in the new viewport, but their code was removed. If we need to bring anything back we can look at older git revisions. * There is some legacy viewport code that I could not remove yet, and some that I probably missed. * Shader node execution code was left mostly intact, even though it is not used anywhere now. We may eventually use this to replace the texture nodes with Cycles / Eevee shader nodes. * The Cycles Bake panel now includes settings for baking multires normal and displacement maps. The underlying code needs to be merged properly, and we plan to add back support for multires AO baking and add support to Cycles baking for features like vertex color, displacement, and other missing baking features. * This commit removes DNA and the Python API for BI material, lamp, world and scene settings. This breaks a lot of addons. * There is more DNA that can be removed or renamed, where Cycles or Eevee are reusing some old BI properties but the names are not really correct anymore. * Texture slots for materials, lamps and world were removed. They remain for brushes, particles and freestyle linestyles. * 'BLENDER_RENDER' remains in the COMPAT_ENGINES of UI panels. Cycles and other renderers use this to find all panels to show, minus a few panels that they have their own replacement for.
author: Ton Roosendaal <ton@blender.org> 2018-04-19 18:34:44 +0300
committer: Brecht Van Lommel <brechtvanlommel@gmail.com> 2018-04-19 18:35:25 +0300
commit: 51b796ff1528c52cc8b4079fab1003671652a4d9 (patch)
tree: 0dfc2d2dabe5e77959264f5b6667897569290a41 /source/blender/gpu
parent: 785e8a636a293941a4295e669cb5aeecfafae039 (diff)
18 files changed, 61 insertions, 5292 deletions
diff --git a/source/blender/gpu/CMakeLists.txt b/source/blender/gpu/CMakeLists.txt
index 94b27c8f916..c3ef9d18f13 100644
--- a/source/blender/gpu/CMakeLists.txt
+++ b/source/blender/gpu/CMakeLists.txt
@@ -62,7 +62,6 @@ set(SRC
 	intern/gpu_immediate.c
 	intern/gpu_immediate_util.c
 	intern/gpu_init_exit.c
-	intern/gpu_lamp.c
 	intern/gpu_material.c
 	intern/gpu_matrix.c
 	intern/gpu_select.c
@@ -105,7 +104,6 @@ set(SRC
 	GPU_immediate.h
 	GPU_immediate_util.h
 	GPU_init_exit.h
-	GPU_lamp.h
 	GPU_legacy_stubs.h
 	GPU_material.h
 	GPU_matrix.h
@@ -117,7 +115,6 @@ set(SRC
 
 	intern/gpu_codegen.h
 	intern/gpu_private.h
-	intern/gpu_lamp_private.h
 	intern/gpu_select_private.h
 	intern/gpu_shader_private.h
 )
diff --git a/source/blender/gpu/GPU_buffers.h b/source/blender/gpu/GPU_buffers.h
index 0d8a7a45ee9..f496c92f283 100644
--- a/source/blender/gpu/GPU_buffers.h
+++ b/source/blender/gpu/GPU_buffers.h
@@ -32,192 +32,19 @@
 #ifndef __GPU_BUFFERS_H__
 #define __GPU_BUFFERS_H__
 
-#ifdef DEBUG
-/*  #define DEBUG_VBO(X) printf(X)*/
-#  define DEBUG_VBO(X)
-#else
-#  define DEBUG_VBO(X)
-#endif
-
 #include <stddef.h>
 
 struct BMesh;
 struct CCGElem;
 struct CCGKey;
 struct DMFlagMat;
-struct DerivedMesh;
-struct GSet;
-struct GPUVertPointLink;
-struct GPUDrawObject;
 struct GridCommonGPUBuffer;
-struct PBVH;
-struct Gwn_Batch;
+struct GSet;
+struct MLoop;
+struct MLoopTri;
+struct MPoly;
 struct MVert;
-
-typedef struct GPUBuffer {
-	size_t size;        /* in bytes */
-	unsigned int id; /* used with vertex buffer objects */
-} GPUBuffer;
-
-typedef struct GPUBufferMaterial {
-	/* range of points used for this material */
-	unsigned int start;
-	unsigned int totelements;
-	unsigned int totloops;
-	unsigned int *polys; /* array of polygons for this material */
-	unsigned int totpolys; /* total polygons in polys */
-	unsigned int totvisiblepolys; /* total visible polygons */
-
-	/* original material index */
-	short mat_nr;
-} GPUBufferMaterial;
-
-void GPU_buffer_material_finalize(struct GPUDrawObject *gdo, GPUBufferMaterial *matinfo, int totmat);
-
-/* meshes are split up by material since changing materials requires
- * GL state changes that can't occur in the middle of drawing an
- * array.
- *
- * some simplifying assumptions are made:
- * - all quads are treated as two triangles.
- * - no vertex sharing is used; each triangle gets its own copy of the
- *   vertices it uses (this makes it easy to deal with a vertex used
- *   by faces with different properties, such as smooth/solid shading,
- *   different MCols, etc.)
- *
- * to avoid confusion between the original MVert vertices and the
- * arrays of OpenGL vertices, the latter are referred to here and in
- * the source as `points'. similarly, the OpenGL triangles generated
- * for MFaces are referred to as triangles rather than faces.
- */
-typedef struct GPUDrawObject {
-	GPUBuffer *points;
-	GPUBuffer *normals;
-	GPUBuffer *uv;
-	GPUBuffer *uv_tex;
-	GPUBuffer *colors;
-	GPUBuffer *edges;
-	GPUBuffer *uvedges;
-	GPUBuffer *triangles; /* triangle index buffer */
-
-	/* for each original vertex, the list of related points */
-	struct GPUVertPointLink *vert_points;
-
-	/* see: USE_GPU_POINT_LINK define */
-#if 0
-	/* storage for the vert_points lists */
-	struct GPUVertPointLink *vert_points_mem;
-	int vert_points_usage;
-#endif
-	
-	int colType;
-
-	GPUBufferMaterial *materials;
-	int totmaterial;
-	
-	unsigned int tot_triangle_point;
-	unsigned int tot_loose_point;
-	/* different than total loops since ngons get tesselated still */
-	unsigned int tot_loop_verts;
-	
-	/* caches of the original DerivedMesh values */
-	unsigned int totvert;
-	unsigned int totedge;
-
-	unsigned int loose_edge_offset;
-	unsigned int tot_loose_edge_drawn;
-	unsigned int tot_edge_drawn;
-
-	/* for subsurf, offset where drawing of interior edges starts */
-	unsigned int interior_offset;
-	unsigned int totinterior;
-} GPUDrawObject;
-
-/* currently unused */
-// #define USE_GPU_POINT_LINK
-
-typedef struct GPUVertPointLink {
-#ifdef USE_GPU_POINT_LINK
-	struct GPUVertPointLink *next;
-#endif
-	/* -1 means uninitialized */
-	int point_index;
-} GPUVertPointLink;
-
-
-
-/* used for GLSL materials */
-typedef struct GPUAttrib {
-	int index;
-	int info_index;
-	int size;
-	int type;
-} GPUAttrib;
-
-void GPU_global_buffer_pool_free(void);
-void GPU_global_buffer_pool_free_unused(void);
-
-GPUBuffer *GPU_buffer_alloc(size_t size);
-void GPU_buffer_free(GPUBuffer *buffer);
-
-void GPU_drawobject_free(struct DerivedMesh *dm);
-
-/* flag that controls data type to fill buffer with, a modifier will prepare. */
-typedef enum {
-	GPU_BUFFER_VERTEX = 0,
-	GPU_BUFFER_NORMAL,
-	GPU_BUFFER_COLOR,
-	GPU_BUFFER_UV,
-	GPU_BUFFER_UV_TEXPAINT,
-	GPU_BUFFER_EDGE,
-	GPU_BUFFER_UVEDGE,
-	GPU_BUFFER_TRIANGLES
-} GPUBufferType;
-
-typedef enum {
-	GPU_BINDING_ARRAY = 0,
-	GPU_BINDING_INDEX = 1,
-} GPUBindingType;
-
-typedef enum {
-	GPU_ATTR_INFO_SRGB = (1 << 0),
-} GPUAttrInfo;
-
-/* called before drawing */
-void GPU_vertex_setup(struct DerivedMesh *dm);
-void GPU_normal_setup(struct DerivedMesh *dm);
-void GPU_uv_setup(struct DerivedMesh *dm);
-void GPU_texpaint_uv_setup(struct DerivedMesh *dm);
-/* colType is the cddata MCol type to use! */
-void GPU_color_setup(struct DerivedMesh *dm, int colType);
-void GPU_buffer_bind_as_color(GPUBuffer *buffer);
-void GPU_edge_setup(struct DerivedMesh *dm); /* does not mix with other data */
-void GPU_uvedge_setup(struct DerivedMesh *dm);
-
-void GPU_triangle_setup(struct DerivedMesh *dm);
-
-int GPU_attrib_element_size(GPUAttrib data[], int numdata);
-void GPU_interleaved_attrib_setup(GPUBuffer *buffer, GPUAttrib data[], int numdata, int element_size);
-
-void GPU_buffer_bind(GPUBuffer *buffer, GPUBindingType binding);
-void GPU_buffer_unbind(GPUBuffer *buffer, GPUBindingType binding);
-
-/* can't lock more than one buffer at once */
-void *GPU_buffer_lock(GPUBuffer *buffer, GPUBindingType binding);
-void *GPU_buffer_lock_stream(GPUBuffer *buffer, GPUBindingType binding);
-void GPU_buffer_unlock(GPUBuffer *buffer, GPUBindingType binding);
-
-/* switch color rendering on=1/off=0 */
-void GPU_color_switch(int mode);
-
-/* used for drawing edges */
-void GPU_buffer_draw_elements(GPUBuffer *elements, unsigned int mode, int start, int count);
-
-/* called after drawing */
-void GPU_buffers_unbind(void);
-
-/* only unbind interleaved data */
-void GPU_interleaved_attrib_unbind(void);
+struct PBVH;
 
 /* Buffers for non-DerivedMesh drawing */
 typedef struct GPU_PBVH_Buffers GPU_PBVH_Buffers;
@@ -264,9 +91,6 @@ void GPU_pbvh_grid_buffers_update(
         const int update_flags);
 
 /* draw */
-void GPU_pbvh_buffers_draw(
-        GPU_PBVH_Buffers *buffers, DMSetMaterial setMaterial,
-        bool wireframe, bool fast);
 struct Gwn_Batch *GPU_pbvh_buffers_batch_get(GPU_PBVH_Buffers *buffers, bool fast);
 
 /* debug PBVH draw */
@@ -278,4 +102,6 @@ bool GPU_pbvh_buffers_mask_changed(GPU_PBVH_Buffers *buffers, bool show_mask);
 void GPU_pbvh_buffers_free(GPU_PBVH_Buffers *buffers);
 void GPU_pbvh_multires_buffers_free(struct GridCommonGPUBuffer **grid_common_gpu_buffer);
 
+void GPU_pbvh_fix_linking(void);
+
 #endif
diff --git a/source/blender/gpu/GPU_draw.h b/source/blender/gpu/GPU_draw.h
index 2dbb1b1e90c..e26d973142b 100644
--- a/source/blender/gpu/GPU_draw.h
+++ b/source/blender/gpu/GPU_draw.h
@@ -65,41 +65,6 @@ void GPU_state_init(void);
 void GPU_enable_program_point_size(void);
 void GPU_disable_program_point_size(void);
 
-/* Material drawing
- * - first the state is initialized by a particular object and
- *   it's materials
- * - after this, materials can be quickly enabled by their number,
- *   GPU_object_material_bind returns 0 if drawing should be skipped
- * - after drawing, the material must be disabled again */
-
-void GPU_begin_object_materials(
-        struct View3D *v3d, struct RegionView3D *rv3d,
-        struct Scene *scene, struct ViewLayer *view_layer,
-        struct Object *ob, bool glsl, bool *do_alpha_after);
-void GPU_end_object_materials(void);
-bool GPU_object_materials_check(void);
-
-int GPU_object_material_bind(int nr, void *attribs);
-void GPU_object_material_unbind(void);
-int GPU_object_material_visible(int nr, void *attribs);
-
-void GPU_begin_dupli_object(struct DupliObject *dob);
-void GPU_end_dupli_object(void);
-
-void GPU_material_diffuse_get(int nr, float diff[4]);
-bool GPU_material_use_matcaps_get(void);
-
-void GPU_set_material_alpha_blend(int alphablend);
-int GPU_get_material_alpha_blend(void);
-
-/* Lights
- * - returns how many lights were enabled
- * - this affects fixed functions materials and texface, not glsl */
-
-int GPU_default_lights(void);
-int GPU_scene_object_lights(
-        struct ViewLayer *view_layer, float viewmat[4][4], int ortho);
-
 /* Mipmap settings
  * - these will free textures on changes */
 
@@ -143,11 +108,6 @@ void GPU_create_smoke(struct SmokeModifierData *smd, int highres);
 /* Delayed free of OpenGL buffers by main thread */
 void GPU_free_unused_buffers(void);
 
-#ifdef WITH_OPENSUBDIV
-struct DerivedMesh;
-void GPU_draw_update_fvar_offset(struct DerivedMesh *dm);
-#endif
-
 /* utilities */
 void	GPU_select_index_set(int index);
 void	GPU_select_index_get(int index, int *r_col);
diff --git a/source/blender/gpu/GPU_lamp.h b/source/blender/gpu/GPU_lamp.h
deleted file mode 100644
index 87350f1ceb4..00000000000
--- a/source/blender/gpu/GPU_lamp.h
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * 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
- * of the License, or (at your option) any later version.
- *
- * 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,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2005 Blender Foundation.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): Brecht Van Lommel, Clément Foucault.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-
-/** \file GPU_lamp.h
- *  \ingroup gpu
- */
-
-#ifndef __GPU_LAMP_H__
-#define __GPU_LAMP_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct Scene;
-struct Object;
-struct RenderEngineType;
-
-typedef struct GPULamp GPULamp;
-
-#define MAX_LAMP_DATA 2
-
-typedef struct LampEngineData {
-	void *storage[MAX_LAMP_DATA];
-} LampEngineData;
-
-LampEngineData *GPU_lamp_engine_data_get(struct Scene *scene, struct Object *ob, struct Object *par, struct RenderEngineType *re);
-
-GPULamp *GPU_lamp_from_blender(struct Scene *scene, struct Object *ob, struct Object *par);
-void GPU_lamp_free(struct Object *ob);
-void GPU_lamp_engine_data_free(LampEngineData *led);
-
-bool GPU_lamp_visible(GPULamp *lamp, struct Material *ma);
-bool GPU_lamp_has_shadow_buffer(GPULamp *lamp);
-void GPU_lamp_update_buffer_mats(GPULamp *lamp);
-void GPU_lamp_shadow_buffer_bind(GPULamp *lamp, float viewmat[4][4], int *winsize, float winmat[4][4]);
-void GPU_lamp_shadow_buffer_unbind(GPULamp *lamp);
-int GPU_lamp_shadow_buffer_type(GPULamp *lamp);
-int GPU_lamp_shadow_bind_code(GPULamp *lamp);
-float *GPU_lamp_dynpersmat(GPULamp *lamp);
-
-void GPU_lamp_update(GPULamp *lamp, int lay, int hide, float obmat[4][4]);
-void GPU_lamp_update_colors(GPULamp *lamp, float r, float g, float b, float energy);
-void GPU_lamp_update_distance(GPULamp *lamp, float distance, float att1, float att2,
-                              float coeff_const, float coeff_lin, float coeff_quad);
-void GPU_lamp_update_spot(GPULamp *lamp, float spotsize, float spotblend);
-int GPU_lamp_shadow_layer(GPULamp *lamp);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  /* __GPU_LAMP_H__ */
diff --git a/source/blender/gpu/GPU_material.h b/source/blender/gpu/GPU_material.h
index 1d2b234e7f3..c9ef5ca3ae6 100644
--- a/source/blender/gpu/GPU_material.h
+++ b/source/blender/gpu/GPU_material.h
@@ -236,37 +236,23 @@ GPUNodeLink *GPU_uniformbuffer_link_out(
         struct GPUNodeStack *stack, const int index);
 
 void GPU_material_output_link(GPUMaterial *material, GPUNodeLink *link);
-void GPU_material_enable_alpha(GPUMaterial *material);
 GPUBuiltin GPU_get_material_builtins(GPUMaterial *material);
-GPUBlendMode GPU_material_alpha_blend(GPUMaterial *material, float obcol[4]);
 
 void GPU_material_sss_profile_create(GPUMaterial *material, float *radii, short *falloff_type, float *sharpness);
 struct GPUUniformBuffer *GPU_material_sss_profile_get(
         GPUMaterial *material, int sample_ct, struct GPUTexture **tex_profile);
 
 /* High level functions to create and use GPU materials */
-GPUMaterial *GPU_material_world(struct Scene *scene, struct World *wo);
 GPUMaterial *GPU_material_from_nodetree_find(
         struct ListBase *gpumaterials, const void *engine_type, int options);
 GPUMaterial *GPU_material_from_nodetree(
-        struct Scene *scene, struct bNodeTree *ntree, struct ListBase *gpumaterials, const void *engine_type, int options,
-        const char *vert_code, const char *geom_code, const char *frag_lib, const char *defines, bool deferred);
-GPUMaterial *GPU_material_from_blender(struct Scene *scene, struct Material *ma, bool use_opensubdiv);
-GPUMaterial *GPU_material_matcap(struct Scene *scene, struct Material *ma, bool use_opensubdiv);
+        struct Scene *scene, struct bNodeTree *ntree, struct ListBase *gpumaterials, const void *engine_type, int options);
 void GPU_material_generate_pass(
 		GPUMaterial *mat, const char *vert_code, const char *geom_code, const char *frag_lib, const char *defines);
 void GPU_material_free(struct ListBase *gpumaterial);
 
 void GPU_materials_free(void);
 
-void GPU_material_bind(
-        GPUMaterial *material, int oblay, int viewlay, double time, int mipmap,
-        float viewmat[4][4], float viewinv[4][4], float cameraborder[4]);
-void GPU_material_bind_uniforms(
-        GPUMaterial *material, float obmat[4][4], float viewmat[4][4], float obcol[4],
-        float autobumpscale, GPUParticleInfo *pi, float object_info[3]);
-void GPU_material_unbind(GPUMaterial *material);
-bool GPU_material_bound(GPUMaterial *material);
 struct Scene *GPU_material_scene(GPUMaterial *material);
 GPUMatType GPU_Material_get_type(GPUMaterial *material);
 struct GPUPass *GPU_material_get_pass(GPUMaterial *material);
@@ -281,103 +267,9 @@ void GPU_material_vertex_attributes(GPUMaterial *material,
 	struct GPUVertexAttribs *attrib);
 
 bool GPU_material_do_color_management(GPUMaterial *mat);
-bool GPU_material_use_new_shading_nodes(GPUMaterial *mat);
-bool GPU_material_use_world_space_shading(GPUMaterial *mat);
 bool GPU_material_use_domain_surface(GPUMaterial *mat);
 bool GPU_material_use_domain_volume(GPUMaterial *mat);
 
-/* Exported shading */
-
-typedef struct GPUShadeInput {
-	GPUMaterial *gpumat;
-	struct Material *mat;
-
-	GPUNodeLink *rgb, *specrgb, *vn, *view, *vcol, *ref;
-	GPUNodeLink *alpha, *refl, *spec, *emit, *har, *amb;
-	GPUNodeLink *spectra, *mir, *refcol;
-} GPUShadeInput;
-
-typedef struct GPUShadeResult {
-	GPUNodeLink *diff, *spec, *combined, *alpha;
-} GPUShadeResult;
-
-void GPU_shadeinput_set(GPUMaterial *mat, struct Material *ma, GPUShadeInput *shi);
-void GPU_shaderesult_set(GPUShadeInput *shi, GPUShadeResult *shr);
-
-/* Export GLSL shader */
-
-typedef enum GPUDataType {
-	GPU_DATA_NONE = 0,
-	GPU_DATA_1I = 1,   /* 1 integer */
-	GPU_DATA_1F = 2,
-	GPU_DATA_2F = 3,
-	GPU_DATA_3F = 4,
-	GPU_DATA_4F = 5,
-	GPU_DATA_9F = 6,
-	GPU_DATA_16F = 7,
-	GPU_DATA_4UB = 8,
-} GPUDataType;
-
-/* this structure gives information of each uniform found in the shader */
-typedef struct GPUInputUniform {
-	struct GPUInputUniform *next, *prev;
-	char varname[32];         /* name of uniform in shader */
-	GPUDynamicType type;      /* type of uniform, data format and calculation derive from it */
-	GPUDataType datatype;     /* type of uniform data */
-	struct Object *lamp;      /* when type=GPU_DYNAMIC_LAMP_... or GPU_DYNAMIC_SAMPLER_2DSHADOW */
-	struct Image *image;      /* when type=GPU_DYNAMIC_SAMPLER_2DIMAGE */
-	struct Material *material;/* when type=GPU_DYNAMIC_MAT_... */
-	int texnumber;            /* when type=GPU_DYNAMIC_SAMPLER, texture number: 0.. */
-	unsigned char *texpixels; /* for internally generated texture, pixel data in RGBA format */
-	int texsize;              /* size in pixel of the texture in texpixels buffer:
-	                           * for 2D textures, this is S and T size (square texture) */
-} GPUInputUniform;
-
-typedef struct GPUInputAttribute {
-	struct GPUInputAttribute *next, *prev;
-	char varname[32];     /* name of attribute in shader */
-	int type;             /* from CustomData.type, data type derives from it */
-	GPUDataType datatype; /* type of attribute data */
-	const char *name;     /* layer name */
-	int number;           /* generic attribute number */
-} GPUInputAttribute;
-
-typedef struct GPUShaderExport {
-	ListBase uniforms;
-	ListBase attributes;
-	char *vertex;
-	char *fragment;
-} GPUShaderExport;
-
-GPUShaderExport *GPU_shader_export(struct Scene *scene, struct Material *ma);
-void GPU_free_shader_export(GPUShaderExport *shader);
-
-/* Lamps */
-GPUNodeLink *GPU_lamp_get_data(
-        GPUMaterial *mat, struct GPULamp *lamp,
-        GPUNodeLink **r_col, GPUNodeLink **r_lv, GPUNodeLink **r_dist, GPUNodeLink **r_shadow, GPUNodeLink **r_energy);
-
-/* World */
-void GPU_mist_update_enable(short enable);
-void GPU_mist_update_values(int type, float start, float dist, float inten, float color[3]);
-void GPU_horizon_update_color(float color[3]);
-void GPU_ambient_update_color(float color[3]);
-void GPU_zenith_update_color(float color[3]);
-
-struct GPUParticleInfo
-{
-	float scalprops[4];
-	float location[4];
-	float velocity[3];
-	float angular_velocity[3];
-};
-
-#ifdef WITH_OPENSUBDIV
-struct DerivedMesh;
-void GPU_material_update_fvar_offset(GPUMaterial *gpu_material,
-                                     struct DerivedMesh *dm);
-#endif
-
 void GPU_pass_cache_garbage_collect(void);
 void GPU_pass_cache_free(void);
 
diff --git a/source/blender/gpu/intern/gpu_buffers.c b/source/blender/gpu/intern/gpu_buffers.c
index d2a18684e27..bbee252cd20 100644
--- a/source/blender/gpu/intern/gpu_buffers.c
+++ b/source/blender/gpu/intern/gpu_buffers.c
@@ -58,52 +58,6 @@
 
 #include "bmesh.h"
 
-/* TODO: gawain support for baseelemarray */
-// #define USE_BASE_ELEM
-
-typedef enum {
-	GPU_BUFFER_VERTEX_STATE = (1 << 0),
-	GPU_BUFFER_NORMAL_STATE = (1 << 1),
-	GPU_BUFFER_TEXCOORD_UNIT_0_STATE = (1 << 2),
-	GPU_BUFFER_TEXCOORD_UNIT_2_STATE = (1 << 3),
-	GPU_BUFFER_COLOR_STATE = (1 << 4),
-	GPU_BUFFER_ELEMENT_STATE = (1 << 5),
-} GPUBufferState;
-
-typedef struct {
-	GLenum gl_buffer_type;
-	int num_components; /* number of data components for one vertex */
-} GPUBufferTypeSettings;
-
-
-static size_t gpu_buffer_size_from_type(DerivedMesh *dm, GPUBufferType type);
-
-static const GPUBufferTypeSettings gpu_buffer_type_settings[] = {
-    /* vertex */
-    {GL_ARRAY_BUFFER, 3},
-    /* normal */
-    {GL_ARRAY_BUFFER, 4}, /* we copy 3 shorts per normal but we add a fourth for alignment */
-    /* mcol */
-    {GL_ARRAY_BUFFER, 4},
-    /* uv */
-    {GL_ARRAY_BUFFER, 2},
-    /* uv for texpaint */
-    {GL_ARRAY_BUFFER, 4},
-    /* edge */
-    {GL_ELEMENT_ARRAY_BUFFER, 2},
-    /* uv edge */
-    {GL_ELEMENT_ARRAY_BUFFER, 4},
-    /* triangles, 1 point since we are allocating from tottriangle points, which account for all points */
-    {GL_ELEMENT_ARRAY_BUFFER, 1},
-};
-
-#define MAX_GPU_ATTRIB_DATA 32
-
-#define BUFFER_OFFSET(n) ((GLubyte *)NULL + (n))
-
-static GPUBufferState GLStates = 0;
-static GPUAttrib attribData[MAX_GPU_ATTRIB_DATA] = { { -1, 0, 0 } };
-
 static ThreadMutex buffer_mutex = BLI_MUTEX_INITIALIZER;
 
 /* multires global buffer, can be used for many grids having the same grid size */
@@ -113,834 +67,6 @@ typedef struct GridCommonGPUBuffer {
 	unsigned mres_prev_totquad;
 } GridCommonGPUBuffer;
 
-void GPU_buffer_material_finalize(GPUDrawObject *gdo, GPUBufferMaterial *matinfo, int totmat)
-{
-	int i, curmat, curelement;
-
-	/* count the number of materials used by this DerivedMesh */
-	for (i = 0; i < totmat; i++) {
-		if (matinfo[i].totelements > 0)
-			gdo->totmaterial++;
-	}
-
-	/* allocate an array of materials used by this DerivedMesh */
-	gdo->materials = MEM_mallocN(sizeof(GPUBufferMaterial) * gdo->totmaterial,
-	                             "GPUDrawObject.materials");
-
-	/* initialize the materials array */
-	for (i = 0, curmat = 0, curelement = 0; i < totmat; i++) {
-		if (matinfo[i].totelements > 0) {
-			gdo->materials[curmat] = matinfo[i];
-			gdo->materials[curmat].start = curelement;
-			gdo->materials[curmat].mat_nr = i;
-			gdo->materials[curmat].polys = MEM_mallocN(sizeof(int) * matinfo[i].totpolys, "GPUBufferMaterial.polys");
-
-			curelement += matinfo[i].totelements;
-			curmat++;
-		}
-	}
-
-	MEM_freeN(matinfo);
-}
-
-
-/* stores recently-deleted buffers so that new buffers won't have to
- * be recreated as often
- *
- * only one instance of this pool is created, stored in
- * gpu_buffer_pool
- *
- * note that the number of buffers in the pool is usually limited to
- * MAX_FREE_GPU_BUFFERS, but this limit may be exceeded temporarily
- * when a GPUBuffer is released outside the main thread; due to OpenGL
- * restrictions it cannot be immediately released
- */
-typedef struct GPUBufferPool {
-	/* number of allocated buffers stored */
-	int totbuf;
-	/* actual allocated length of the arrays */
-	int maxsize;
-	GPUBuffer **buffers;
-} GPUBufferPool;
-#define MAX_FREE_GPU_BUFFERS 8
-
-/* create a new GPUBufferPool */
-static GPUBufferPool *gpu_buffer_pool_new(void)
-{
-	GPUBufferPool *pool;
-
-	pool = MEM_callocN(sizeof(GPUBufferPool), "GPUBuffer_Pool");
-
-	pool->maxsize = MAX_FREE_GPU_BUFFERS;
-	pool->buffers = MEM_mallocN(sizeof(*pool->buffers) * pool->maxsize,
-	                            "GPUBufferPool.buffers");
-	return pool;
-}
-
-/* remove a GPUBuffer from the pool (does not free the GPUBuffer) */
-static void gpu_buffer_pool_remove_index(GPUBufferPool *pool, int index)
-{
-	int i;
-
-	if (!pool || index < 0 || index >= pool->totbuf)
-		return;
-
-	/* shift entries down, overwriting the buffer at `index' */
-	for (i = index; i < pool->totbuf - 1; i++)
-		pool->buffers[i] = pool->buffers[i + 1];
-
-	/* clear the last entry */
-	if (pool->totbuf > 0)
-		pool->buffers[pool->totbuf - 1] = NULL;
-
-	pool->totbuf--;
-}
-
-/* delete the last entry in the pool */
-static void gpu_buffer_pool_delete_last(GPUBufferPool *pool)
-{
-	GPUBuffer *last;
-
-	if (pool->totbuf <= 0)
-		return;
-
-	/* get the last entry */
-	if (!(last = pool->buffers[pool->totbuf - 1]))
-		return;
-
-	/* delete the buffer's data */
-	glDeleteBuffers(1, &last->id);
-
-	/* delete the buffer and remove from pool */
-	MEM_freeN(last);
-	pool->totbuf--;
-	pool->buffers[pool->totbuf] = NULL;
-}
-
-/* free a GPUBufferPool; also frees the data in the pool's
- * GPUBuffers */
-static void gpu_buffer_pool_free(GPUBufferPool *pool)
-{
-	if (!pool)
-		return;
-	
-	while (pool->totbuf)
-		gpu_buffer_pool_delete_last(pool);
-
-	MEM_freeN(pool->buffers);
-	MEM_freeN(pool);
-}
-
-static void gpu_buffer_pool_free_unused(GPUBufferPool *pool)
-{
-	if (!pool)
-		return;
-
-	BLI_mutex_lock(&buffer_mutex);
-	
-	while (pool->totbuf)
-		gpu_buffer_pool_delete_last(pool);
-
-	BLI_mutex_unlock(&buffer_mutex);
-}
-
-static GPUBufferPool *gpu_buffer_pool = NULL;
-static GPUBufferPool *gpu_get_global_buffer_pool(void)
-{
-	/* initialize the pool */
-	if (!gpu_buffer_pool)
-		gpu_buffer_pool = gpu_buffer_pool_new();
-
-	return gpu_buffer_pool;
-}
-
-void GPU_global_buffer_pool_free(void)
-{
-	gpu_buffer_pool_free(gpu_buffer_pool);
-	gpu_buffer_pool = NULL;
-}
-
-void GPU_global_buffer_pool_free_unused(void)
-{
-	gpu_buffer_pool_free_unused(gpu_buffer_pool);
-}
-
-/* get a GPUBuffer of at least `size' bytes; uses one from the buffer
- * pool if possible, otherwise creates a new one
- *
- * Thread-unsafe version for internal usage only.
- */
-static GPUBuffer *gpu_buffer_alloc_intern(size_t size)
-{
-	GPUBufferPool *pool;
-	GPUBuffer *buf;
-	int i, bestfit = -1;
-	size_t bufsize;
-
-	/* bad case, leads to leak of buf since buf->pointer will allocate
-	 * NULL, leading to return without cleanup. In any case better detect early
-	 * psy-fi */
-	if (size == 0)
-		return NULL;
-
-	pool = gpu_get_global_buffer_pool();
-
-	/* not sure if this buffer pool code has been profiled much,
-	 * seems to me that the graphics driver and system memory
-	 * management might do this stuff anyway. --nicholas
-	 */
-
-	/* check the global buffer pool for a recently-deleted buffer
-	 * that is at least as big as the request, but not more than
-	 * twice as big */
-	for (i = 0; i < pool->totbuf; i++) {
-		bufsize = pool->buffers[i]->size;
-		
-		/* check for an exact size match */
-		if (bufsize == size) {
-			bestfit = i;
-			break;
-		}
-		/* smaller buffers won't fit data and buffers at least
-		 * twice as big are a waste of memory */
-		else if (bufsize > size && size > (bufsize / 2)) {
-			/* is it closer to the required size than the
-			 * last appropriate buffer found. try to save
-			 * memory */
-			if (bestfit == -1 || pool->buffers[bestfit]->size > bufsize) {
-				bestfit = i;
-			}
-		}
-	}
-
-	/* if an acceptable buffer was found in the pool, remove it
-	 * from the pool and return it */
-	if (bestfit != -1) {
-		buf = pool->buffers[bestfit];
-		gpu_buffer_pool_remove_index(pool, bestfit);
-		return buf;
-	}
-
-	/* no acceptable buffer found in the pool, create a new one */
-	buf = MEM_callocN(sizeof(GPUBuffer), "GPUBuffer");
-	buf->size = size;
-
-	glGenBuffers(1, &buf->id);
-	glBindBuffer(GL_ARRAY_BUFFER, buf->id);
-	glBufferData(GL_ARRAY_BUFFER, size, NULL, GL_STATIC_DRAW);
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-
-	return buf;
-}
-
-/* Same as above, but safe for threading. */
-GPUBuffer *GPU_buffer_alloc(size_t size)
-{
-	GPUBuffer *buffer;
-
-	if (size == 0) {
-		/* Early out, no lock needed in this case. */
-		return NULL;
-	}
-
-	BLI_mutex_lock(&buffer_mutex);
-	buffer = gpu_buffer_alloc_intern(size);
-	BLI_mutex_unlock(&buffer_mutex);
-
-	return buffer;
-}
-
-/* release a GPUBuffer; does not free the actual buffer or its data,
- * but rather moves it to the pool of recently-freed buffers for
- * possible re-use
- *
- * Thread-unsafe version for internal usage only.
- */
-static void gpu_buffer_free_intern(GPUBuffer *buffer)
-{
-	GPUBufferPool *pool;
-	int i;
-
-	if (!buffer)
-		return;
-
-	pool = gpu_get_global_buffer_pool();
-
-	/* free the last used buffer in the queue if no more space, but only
-	 * if we are in the main thread. for e.g. rendering or baking it can
-	 * happen that we are in other thread and can't call OpenGL, in that
-	 * case cleanup will be done GPU_buffer_pool_free_unused */
-	if (BLI_thread_is_main()) {
-		/* in main thread, safe to decrease size of pool back
-		 * down to MAX_FREE_GPU_BUFFERS */
-		while (pool->totbuf >= MAX_FREE_GPU_BUFFERS)
-			gpu_buffer_pool_delete_last(pool);
-	}
-	else {
-		/* outside of main thread, can't safely delete the
-		 * buffer, so increase pool size */
-		if (pool->maxsize == pool->totbuf) {
-			pool->maxsize += MAX_FREE_GPU_BUFFERS;
-			pool->buffers = MEM_reallocN(pool->buffers,
-			                             sizeof(GPUBuffer *) * pool->maxsize);
-		}
-	}
-
-	/* shift pool entries up by one */
-	for (i = pool->totbuf; i > 0; i--)
-		pool->buffers[i] = pool->buffers[i - 1];
-
-	/* insert the buffer into the beginning of the pool */
-	pool->buffers[0] = buffer;
-	pool->totbuf++;
-}
-
-/* Same as above, but safe for threading. */
-void GPU_buffer_free(GPUBuffer *buffer)
-{
-	if (!buffer) {
-		/* Early output, no need to lock in this case, */
-		return;
-	}
-
-	BLI_mutex_lock(&buffer_mutex);
-	gpu_buffer_free_intern(buffer);
-	BLI_mutex_unlock(&buffer_mutex);
-}
-
-void GPU_drawobject_free(DerivedMesh *dm)
-{
-	GPUDrawObject *gdo;
-	int i;
-
-	if (!dm || !(gdo = dm->drawObject))
-		return;
-
-	for (i = 0; i < gdo->totmaterial; i++) {
-		if (gdo->materials[i].polys)
-			MEM_freeN(gdo->materials[i].polys);
-	}
-
-	MEM_freeN(gdo->materials);
-	if (gdo->vert_points)
-		MEM_freeN(gdo->vert_points);
-#ifdef USE_GPU_POINT_LINK
-	MEM_freeN(gdo->vert_points_mem);
-#endif
-	GPU_buffer_free(gdo->points);
-	GPU_buffer_free(gdo->normals);
-	GPU_buffer_free(gdo->uv);
-	GPU_buffer_free(gdo->uv_tex);
-	GPU_buffer_free(gdo->colors);
-	GPU_buffer_free(gdo->edges);
-	GPU_buffer_free(gdo->uvedges);
-	GPU_buffer_free(gdo->triangles);
-
-	MEM_freeN(gdo);
-	dm->drawObject = NULL;
-}
-
-static GPUBuffer *gpu_try_realloc(GPUBufferPool *pool, GPUBuffer *buffer, size_t size)
-{
-	/* try freeing an entry from the pool
-	 * and reallocating the buffer */
-	gpu_buffer_free_intern(buffer);
-
-	buffer = NULL;
-
-	while (pool->totbuf && !buffer) {
-		gpu_buffer_pool_delete_last(pool);
-		buffer = gpu_buffer_alloc_intern(size);
-	}
-
-	return buffer;
-}
-
-static GPUBuffer *gpu_buffer_setup(DerivedMesh *dm, GPUDrawObject *object,
-                                   int type, void *user, GPUBuffer *buffer)
-{
-	GPUBufferPool *pool;
-	float *varray;
-	int *mat_orig_to_new;
-	int i;
-	const GPUBufferTypeSettings *ts = &gpu_buffer_type_settings[type];
-	GLenum target = ts->gl_buffer_type;
-	size_t size = gpu_buffer_size_from_type(dm, type);
-	GLboolean uploaded;
-
-	pool = gpu_get_global_buffer_pool();
-
-	BLI_mutex_lock(&buffer_mutex);
-
-	/* alloc a GPUBuffer; fall back to legacy mode on failure */
-	if (!buffer) {
-		if (!(buffer = gpu_buffer_alloc_intern(size))) {
-			BLI_mutex_unlock(&buffer_mutex);
-			return NULL;
-		}
-	}
-
-	mat_orig_to_new = MEM_mallocN(sizeof(*mat_orig_to_new) * dm->totmat,
-	                              "GPU_buffer_setup.mat_orig_to_new");
-	for (i = 0; i < object->totmaterial; i++) {
-		/* map from original material index to new
-		 * GPUBufferMaterial index */
-		mat_orig_to_new[object->materials[i].mat_nr] = i;
-	}
-
-	/* bind the buffer and discard previous data,
-	 * avoids stalling gpu */
-	glBindBuffer(target, buffer->id);
-	glBufferData(target, buffer->size, NULL, GL_STATIC_DRAW);
-
-	/* attempt to map the buffer */
-	if (!(varray = glMapBuffer(target, GL_WRITE_ONLY))) {
-		buffer = gpu_try_realloc(pool, buffer, size);
-
-		/* allocation still failed; unfortunately we need to exit */
-		if (!(buffer && (varray = glMapBuffer(target, GL_WRITE_ONLY)))) {
-			if (buffer)
-				gpu_buffer_free_intern(buffer);
-			BLI_mutex_unlock(&buffer_mutex);
-			return NULL;
-		}
-	}
-
-	uploaded = GL_FALSE;
-
-	/* attempt to upload the data to the VBO */
-	while (uploaded == GL_FALSE) {
-		dm->copy_gpu_data(dm, type, varray, mat_orig_to_new, user);
-		/* glUnmapBuffer returns GL_FALSE if
-		 * the data store is corrupted; retry
-		 * in that case */
-		uploaded = glUnmapBuffer(target);
-	}
-	glBindBuffer(target, 0);
-
-	MEM_freeN(mat_orig_to_new);
-
-	BLI_mutex_unlock(&buffer_mutex);
-
-	return buffer;
-}
-
-/* get the GPUDrawObject buffer associated with a type */
-static GPUBuffer **gpu_drawobject_buffer_from_type(GPUDrawObject *gdo, GPUBufferType type)
-{
-	switch (type) {
-		case GPU_BUFFER_VERTEX:
-			return &gdo->points;
-		case GPU_BUFFER_NORMAL:
-			return &gdo->normals;
-		case GPU_BUFFER_COLOR:
-			return &gdo->colors;
-		case GPU_BUFFER_UV:
-			return &gdo->uv;
-		case GPU_BUFFER_UV_TEXPAINT:
-			return &gdo->uv_tex;
-		case GPU_BUFFER_EDGE:
-			return &gdo->edges;
-		case GPU_BUFFER_UVEDGE:
-			return &gdo->uvedges;
-		case GPU_BUFFER_TRIANGLES:
-			return &gdo->triangles;
-		default:
-			return NULL;
-	}
-}
-
-/* get the amount of space to allocate for a buffer of a particular type */
-static size_t gpu_buffer_size_from_type(DerivedMesh *dm, GPUBufferType type)
-{
-	const int components = gpu_buffer_type_settings[type].num_components;
-	switch (type) {
-		case GPU_BUFFER_VERTEX:
-			return sizeof(float) * components * (dm->drawObject->tot_loop_verts + dm->drawObject->tot_loose_point);
-		case GPU_BUFFER_NORMAL:
-			return sizeof(short) * components * dm->drawObject->tot_loop_verts;
-		case GPU_BUFFER_COLOR:
-			return sizeof(char) * components * dm->drawObject->tot_loop_verts;
-		case GPU_BUFFER_UV:
-			return sizeof(float) * components * dm->drawObject->tot_loop_verts;
-		case GPU_BUFFER_UV_TEXPAINT:
-			return sizeof(float) * components * dm->drawObject->tot_loop_verts;
-		case GPU_BUFFER_EDGE:
-			return sizeof(int) * components * dm->drawObject->totedge;
-		case GPU_BUFFER_UVEDGE:
-			return sizeof(int) * components * dm->drawObject->tot_loop_verts;
-		case GPU_BUFFER_TRIANGLES:
-			return sizeof(int) * components * dm->drawObject->tot_triangle_point;
-		default:
-			return -1;
-	}
-}
-
-/* call gpu_buffer_setup with settings for a particular type of buffer */
-static GPUBuffer *gpu_buffer_setup_type(DerivedMesh *dm, GPUBufferType type, GPUBuffer *buf)
-{
-	void *user_data = NULL;
-
-	/* special handling for MCol and UV buffers */
-	if (type == GPU_BUFFER_COLOR) {
-		if (!(user_data = DM_get_loop_data_layer(dm, dm->drawObject->colType)))
-			return NULL;
-	}
-	else if (ELEM(type, GPU_BUFFER_UV, GPU_BUFFER_UV_TEXPAINT)) {
-		if (!DM_get_loop_data_layer(dm, CD_MLOOPUV))
-			return NULL;
-	}
-
-	buf = gpu_buffer_setup(dm, dm->drawObject, type, user_data, buf);
-
-	return buf;
-}
-
-/* get the buffer of `type', initializing the GPUDrawObject and
- * buffer if needed */
-static GPUBuffer *gpu_buffer_setup_common(DerivedMesh *dm, GPUBufferType type, bool update)
-{
-	GPUBuffer **buf;
-
-	if (!dm->drawObject)
-		dm->drawObject = dm->gpuObjectNew(dm);
-
-	buf = gpu_drawobject_buffer_from_type(dm->drawObject, type);
-	if (!(*buf))
-		*buf = gpu_buffer_setup_type(dm, type, NULL);
-	else if (update)
-		*buf = gpu_buffer_setup_type(dm, type, *buf);
-
-	return *buf;
-}
-
-void GPU_vertex_setup(DerivedMesh *dm)
-{
-	if (!gpu_buffer_setup_common(dm, GPU_BUFFER_VERTEX, false))
-		return;
-
-	glEnableClientState(GL_VERTEX_ARRAY);
-	glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->points->id);
-	glVertexPointer(3, GL_FLOAT, 0, 0);
-	
-	GLStates |= GPU_BUFFER_VERTEX_STATE;
-}
-
-void GPU_normal_setup(DerivedMesh *dm)
-{
-	if (!gpu_buffer_setup_common(dm, GPU_BUFFER_NORMAL, false))
-		return;
-
-	glEnableClientState(GL_NORMAL_ARRAY);
-	glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->normals->id);
-	glNormalPointer(GL_SHORT, 4 * sizeof(short), 0);
-
-	GLStates |= GPU_BUFFER_NORMAL_STATE;
-}
-
-void GPU_uv_setup(DerivedMesh *dm)
-{
-	if (!gpu_buffer_setup_common(dm, GPU_BUFFER_UV, false))
-		return;
-
-	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-	glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->uv->id);
-	glTexCoordPointer(2, GL_FLOAT, 0, 0);
-
-	GLStates |= GPU_BUFFER_TEXCOORD_UNIT_0_STATE;
-}
-
-void GPU_texpaint_uv_setup(DerivedMesh *dm)
-{
-	if (!gpu_buffer_setup_common(dm, GPU_BUFFER_UV_TEXPAINT, false))
-		return;
-
-	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-	glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->uv_tex->id);
-	glTexCoordPointer(2, GL_FLOAT, 4 * sizeof(float), 0);
-	glClientActiveTexture(GL_TEXTURE2);
-	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-	glTexCoordPointer(2, GL_FLOAT, 4 * sizeof(float), BUFFER_OFFSET(2 * sizeof(float)));
-	glClientActiveTexture(GL_TEXTURE0);
-
-	GLStates |= GPU_BUFFER_TEXCOORD_UNIT_0_STATE | GPU_BUFFER_TEXCOORD_UNIT_2_STATE;
-}
-
-
-void GPU_color_setup(DerivedMesh *dm, int colType)
-{
-	bool update = false;
-
-	if (!dm->drawObject) {
-		/* XXX Not really nice, but we need a valid gpu draw object to set the colType...
-		 *     Else we would have to add a new param to gpu_buffer_setup_common. */
-		dm->drawObject = dm->gpuObjectNew(dm);
-		dm->dirty &= ~DM_DIRTY_MCOL_UPDATE_DRAW;
-		dm->drawObject->colType = colType;
-	}
-	/* In paint mode, dm may stay the same during stroke, however we still want to update colors!
-	 * Also check in case we changed color type (i.e. which MCol cdlayer we use). */
-	else if ((dm->dirty & DM_DIRTY_MCOL_UPDATE_DRAW) || (colType != dm->drawObject->colType)) {
-		update = true;
-		dm->dirty &= ~DM_DIRTY_MCOL_UPDATE_DRAW;
-		dm->drawObject->colType = colType;
-	}
-
-	if (!gpu_buffer_setup_common(dm, GPU_BUFFER_COLOR, update))
-		return;
-
-	glEnableClientState(GL_COLOR_ARRAY);
-	glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->colors->id);
-	glColorPointer(4, GL_UNSIGNED_BYTE, 0, 0);
-
-	GLStates |= GPU_BUFFER_COLOR_STATE;
-}
-
-void GPU_buffer_bind_as_color(GPUBuffer *buffer)
-{
-	glEnableClientState(GL_COLOR_ARRAY);
-	glBindBuffer(GL_ARRAY_BUFFER, buffer->id);
-	glColorPointer(4, GL_UNSIGNED_BYTE, 0, 0);
-
-	GLStates |= GPU_BUFFER_COLOR_STATE;
-}
-
-
-void GPU_edge_setup(DerivedMesh *dm)
-{
-	if (!gpu_buffer_setup_common(dm, GPU_BUFFER_EDGE, false))
-		return;
-
-	if (!gpu_buffer_setup_common(dm, GPU_BUFFER_VERTEX, false))
-		return;
-
-	glEnableClientState(GL_VERTEX_ARRAY);
-	glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->points->id);
-	glVertexPointer(3, GL_FLOAT, 0, 0);
-	
-	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, dm->drawObject->edges->id);
-
-	GLStates |= (GPU_BUFFER_VERTEX_STATE | GPU_BUFFER_ELEMENT_STATE);
-}
-
-void GPU_uvedge_setup(DerivedMesh *dm)
-{
-	if (!gpu_buffer_setup_common(dm, GPU_BUFFER_UVEDGE, false))
-		return;
-
-	glEnableClientState(GL_VERTEX_ARRAY);
-	glBindBuffer(GL_ARRAY_BUFFER, dm->drawObject->uvedges->id);
-	glVertexPointer(2, GL_FLOAT, 0, 0);
-	
-	GLStates |= GPU_BUFFER_VERTEX_STATE;
-}
-
-void GPU_triangle_setup(struct DerivedMesh *dm)
-{
-	if (!gpu_buffer_setup_common(dm, GPU_BUFFER_TRIANGLES, false))
-		return;
-
-	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, dm->drawObject->triangles->id);
-	GLStates |= GPU_BUFFER_ELEMENT_STATE;
-}
-
-static int gpu_typesize(int type)
-{
-	switch (type) {
-		case GL_FLOAT:
-			return sizeof(float);
-		case GL_INT:
-			return sizeof(int);
-		case GL_UNSIGNED_INT:
-			return sizeof(unsigned int);
-		case GL_BYTE:
-			return sizeof(char);
-		case GL_UNSIGNED_BYTE:
-			return sizeof(unsigned char);
-		default:
-			return 0;
-	}
-}
-
-int GPU_attrib_element_size(GPUAttrib data[], int numdata)
-{
-	int i, elementsize = 0;
-
-	for (i = 0; i < numdata; i++) {
-		int typesize = gpu_typesize(data[i].type);
-		if (typesize != 0)
-			elementsize += typesize * data[i].size;
-	}
-	return elementsize;
-}
-
-void GPU_interleaved_attrib_setup(GPUBuffer *buffer, GPUAttrib data[], int numdata, int element_size)
-{
-	int i;
-	int elementsize;
-	size_t offset = 0;
-
-	for (i = 0; i < MAX_GPU_ATTRIB_DATA; i++) {
-		if (attribData[i].index != -1) {
-			glDisableVertexAttribArray(attribData[i].index);
-		}
-		else
-			break;
-	}
-	if (element_size == 0)
-		elementsize = GPU_attrib_element_size(data, numdata);
-	else
-		elementsize = element_size;
-
-	glBindBuffer(GL_ARRAY_BUFFER, buffer->id);
-	
-	for (i = 0; i < numdata; i++) {
-		glEnableVertexAttribArray(data[i].index);
-		int info = 0;
-		if (data[i].type == GL_UNSIGNED_BYTE) {
-			info |= GPU_ATTR_INFO_SRGB;
-		}
-		glUniform1i(data[i].info_index, info);
-
-		glVertexAttribPointer(data[i].index, data[i].size, data[i].type,
-		                         GL_TRUE, elementsize, BUFFER_OFFSET(offset));
-		offset += data[i].size * gpu_typesize(data[i].type);
-		
-		attribData[i].index = data[i].index;
-		attribData[i].size = data[i].size;
-		attribData[i].type = data[i].type;
-	}
-	
-	attribData[numdata].index = -1;	
-}
-
-void GPU_interleaved_attrib_unbind(void)
-{
-	int i;
-	for (i = 0; i < MAX_GPU_ATTRIB_DATA; i++) {
-		if (attribData[i].index != -1) {
-			glDisableVertexAttribArray(attribData[i].index);
-		}
-		else
-			break;
-	}
-	attribData[0].index = -1;
-}
-
-void GPU_buffers_unbind(void)
-{
-	int i;
-
-	if (GLStates & GPU_BUFFER_VERTEX_STATE)
-		glDisableClientState(GL_VERTEX_ARRAY);
-	if (GLStates & GPU_BUFFER_NORMAL_STATE)
-		glDisableClientState(GL_NORMAL_ARRAY);
-	if (GLStates & GPU_BUFFER_TEXCOORD_UNIT_0_STATE)
-		glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-	if (GLStates & GPU_BUFFER_TEXCOORD_UNIT_2_STATE) {
-		glClientActiveTexture(GL_TEXTURE2);
-		glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-		glClientActiveTexture(GL_TEXTURE0);
-	}
-	if (GLStates & GPU_BUFFER_COLOR_STATE)
-		glDisableClientState(GL_COLOR_ARRAY);
-	if (GLStates & GPU_BUFFER_ELEMENT_STATE)
-		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-
-	GLStates &= ~(GPU_BUFFER_VERTEX_STATE | GPU_BUFFER_NORMAL_STATE |
-	              GPU_BUFFER_TEXCOORD_UNIT_0_STATE | GPU_BUFFER_TEXCOORD_UNIT_2_STATE |
-	              GPU_BUFFER_COLOR_STATE | GPU_BUFFER_ELEMENT_STATE);
-
-	for (i = 0; i < MAX_GPU_ATTRIB_DATA; i++) {
-		if (attribData[i].index != -1) {
-			glDisableVertexAttribArray(attribData[i].index);
-		}
-		else
-			break;
-	}
-	attribData[0].index = -1;
-
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-}
-
-void GPU_color_switch(int mode)
-{
-	if (mode) {
-		if (!(GLStates & GPU_BUFFER_COLOR_STATE))
-			glEnableClientState(GL_COLOR_ARRAY);
-		GLStates |= GPU_BUFFER_COLOR_STATE;
-	}
-	else {
-		if (GLStates & GPU_BUFFER_COLOR_STATE)
-			glDisableClientState(GL_COLOR_ARRAY);
-		GLStates &= ~GPU_BUFFER_COLOR_STATE;
-	}
-}
-
-static int gpu_binding_type_gl[] =
-{
-	GL_ARRAY_BUFFER,
-	GL_ELEMENT_ARRAY_BUFFER
-};
-
-void *GPU_buffer_lock(GPUBuffer *buffer, GPUBindingType binding)
-{
-	float *varray;
-	int bindtypegl;
-
-	if (!buffer)
-		return 0;
-
-	bindtypegl = gpu_binding_type_gl[binding];
-	glBindBuffer(bindtypegl, buffer->id);
-	varray = glMapBuffer(bindtypegl, GL_WRITE_ONLY);
-	return varray;
-}
-
-void *GPU_buffer_lock_stream(GPUBuffer *buffer, GPUBindingType binding)
-{
-	float *varray;
-	int bindtypegl;
-
-	if (!buffer)
-		return 0;
-
-	bindtypegl = gpu_binding_type_gl[binding];
-	glBindBuffer(bindtypegl, buffer->id);
-	/* discard previous data, avoid stalling gpu */
-	glBufferData(bindtypegl, buffer->size, 0, GL_STREAM_DRAW);
-	varray = glMapBuffer(bindtypegl, GL_WRITE_ONLY);
-	return varray;
-}
-
-void GPU_buffer_unlock(GPUBuffer *UNUSED(buffer), GPUBindingType binding)
-{
-	int bindtypegl = gpu_binding_type_gl[binding];
-	/* note: this operation can fail, could return
-	 * an error code from this function? */
-	glUnmapBuffer(bindtypegl);
-	glBindBuffer(bindtypegl, 0);
-}
-
-void GPU_buffer_bind(GPUBuffer *buffer, GPUBindingType binding)
-{
-	int bindtypegl = gpu_binding_type_gl[binding];
-	glBindBuffer(bindtypegl, buffer->id);
-}
-
-void GPU_buffer_unbind(GPUBuffer *UNUSED(buffer), GPUBindingType binding)
-{
-	int bindtypegl = gpu_binding_type_gl[binding];
-	glBindBuffer(bindtypegl, 0);
-}
-
-/* used for drawing edges */
-void GPU_buffer_draw_elements(GPUBuffer *UNUSED(elements), unsigned int mode, int start, int count)
-{
-	glDrawElements(mode, count, GL_UNSIGNED_INT, BUFFER_OFFSET(start * sizeof(unsigned int)));
-}
-
-
 /* XXX: the rest of the code in this file is used for optimized PBVH
  * drawing and doesn't interact at all with the buffer code above */
 
@@ -982,7 +108,6 @@ struct GPU_PBVH_Buffers {
 	bool show_diffuse_color;
 	bool show_mask;
 
-	bool use_matcaps;
 	float diffuse_color[4];
 };
 
@@ -990,6 +115,15 @@ static struct {
 	uint pos, nor, col;
 } g_vbo_id = {0};
 
+static void gpu_material_diffuse_get(int UNUSED(nr), float diff[4])
+{
+	/* TODO: sculpt diffuse color option not supported in 2.8 yet. */
+	diff[0] = 0.8f;
+	diff[1] = 0.8f;
+	diff[2] = 0.8f;
+	diff[3] = 1.0f;
+}
+
 /* Allocates a non-initialized buffer to be sent to GPU.
  * Return is false it indicates that the memory map failed. */
 static bool gpu_pbvh_vert_buf_data_set(GPU_PBVH_Buffers *buffers, unsigned int vert_ct)
@@ -1086,19 +220,16 @@ void GPU_pbvh_mesh_buffers_update(
 	buffers->vmask = vmask;
 	buffers->show_diffuse_color = show_diffuse_color;
 	buffers->show_mask = show_mask;
-	buffers->use_matcaps = GPU_material_use_matcaps_get();
 
 	{
 		int totelem = (buffers->smooth ? totvert : (buffers->tot_tri * 3));
 		float diffuse_color[4] = {0.8f, 0.8f, 0.8f, 0.8f};
 
-		if (buffers->use_matcaps)
-			diffuse_color[0] = diffuse_color[1] = diffuse_color[2] = 1.0;
-		else if (show_diffuse_color) {
+		if (show_diffuse_color) {
 			const MLoopTri *lt = &buffers->looptri[buffers->face_indices[0]];
 			const MPoly *mp = &buffers->mpoly[lt->poly];
 
-			GPU_material_diffuse_get(mp->mat_nr + 1, diffuse_color);
+			gpu_material_diffuse_get(mp->mat_nr + 1, diffuse_color);
 		}
 
 		copy_v4_v4(buffers->diffuse_color, diffuse_color);
@@ -1210,7 +341,6 @@ GPU_PBVH_Buffers *GPU_pbvh_mesh_buffers_build(
 
 	buffers->show_diffuse_color = false;
 	buffers->show_mask = true;
-	buffers->use_matcaps = false;
 
 	/* Count the number of visible triangles */
 	for (i = 0, tottri = 0; i < face_indices_len; ++i) {
@@ -1283,7 +413,6 @@ void GPU_pbvh_grid_buffers_update(
 
 	buffers->show_diffuse_color = show_diffuse_color;
 	buffers->show_mask = show_mask;
-	buffers->use_matcaps = GPU_material_use_matcaps_get();
 	buffers->smooth = grid_flag_mats[grid_indices[0]].flag & ME_SMOOTH;
 
 	/* Build VBO */
@@ -1291,13 +420,10 @@ void GPU_pbvh_grid_buffers_update(
 		const int has_mask = key->has_mask;
 		float diffuse_color[4] = {0.8f, 0.8f, 0.8f, 1.0f};
 
-		if (buffers->use_matcaps) {
-			diffuse_color[0] = diffuse_color[1] = diffuse_color[2] = 1.0;
-		}
-		else if (show_diffuse_color) {
+		if (show_diffuse_color) {
 			const DMFlagMat *flags = &grid_flag_mats[grid_indices[0]];
 
-			GPU_material_diffuse_get(flags->mat_nr + 1, diffuse_color);
+			gpu_material_diffuse_get(flags->mat_nr + 1, diffuse_color);
 		}
 
 		copy_v4_v4(buffers->diffuse_color, diffuse_color);
@@ -1504,7 +630,6 @@ GPU_PBVH_Buffers *GPU_pbvh_grid_buffers_build(
 
 	buffers->show_diffuse_color = false;
 	buffers->show_mask = true;
-	buffers->use_matcaps = false;
 
 	/* Count the number of quads */
 	totquad = BKE_pbvh_count_grid_quads(grid_hidden, grid_indices, totgrid, gridsize);
@@ -1661,7 +786,6 @@ void GPU_pbvh_bmesh_buffers_update(
 
 	buffers->show_diffuse_color = show_diffuse_color;
 	buffers->show_mask = show_mask;
-	buffers->use_matcaps = GPU_material_use_matcaps_get();
 
 	/* Count visible triangles */
 	tottri = gpu_bmesh_face_visible_count(bm_faces);
@@ -1678,15 +802,13 @@ void GPU_pbvh_bmesh_buffers_update(
 		return;
 	}
 
-	if (buffers->use_matcaps)
-		diffuse_color[0] = diffuse_color[1] = diffuse_color[2] = 1.0;
-	else if (show_diffuse_color) {
+	if (show_diffuse_color) {
 		/* due to dynamic nature of dyntopo, only get first material */
 		GSetIterator gs_iter;
 		BMFace *f;
 		BLI_gsetIterator_init(&gs_iter, bm_faces);
 		f = BLI_gsetIterator_getKey(&gs_iter);
-		GPU_material_diffuse_get(f->mat_nr + 1, diffuse_color);
+		gpu_material_diffuse_get(f->mat_nr + 1, diffuse_color);
 	}
 
 	copy_v4_v4(buffers->diffuse_color, diffuse_color);
@@ -1823,44 +945,10 @@ GPU_PBVH_Buffers *GPU_pbvh_bmesh_buffers_build(bool smooth_shading)
 	buffers->smooth = smooth_shading;
 	buffers->show_diffuse_color = false;
 	buffers->show_mask = true;
-	buffers->use_matcaps = false;
 
 	return buffers;
 }
 
-void GPU_pbvh_buffers_draw(
-        GPU_PBVH_Buffers *buffers, DMSetMaterial setMaterial,
-        bool wireframe, bool fast)
-{
-	UNUSED_VARS(wireframe, fast, setMaterial);
-	bool do_fast = fast && buffers->triangles_fast;
-	Gwn_Batch *triangles = do_fast ? buffers->triangles_fast : buffers->triangles;
-
-	if (triangles) {
-
-		/* Simple Shader: use when drawing without the draw-manager (old 2.7x viewport) */
-		if (triangles->interface == NULL) {
-			GPUBuiltinShader shader_id =
-			        buffers->smooth ? GPU_SHADER_SIMPLE_LIGHTING_SMOOTH_COLOR : GPU_SHADER_SIMPLE_LIGHTING_FLAT_COLOR;
-			GPUShader *shader = GPU_shader_get_builtin_shader(shader_id);
-
-			GWN_batch_program_set(
-			        triangles,
-			        GPU_shader_get_program(shader), GPU_shader_get_interface(shader));
-
-			static float light[3] = {-0.3f, 0.5f, 1.0f};
-			static float alpha = 1.0f;
-			static float world_light = 1.0f;
-
-			GPU_shader_uniform_vector(shader, GPU_shader_get_uniform(shader, "light"), 3, 1, light);
-			GPU_shader_uniform_vector(shader, GPU_shader_get_uniform(shader, "alpha"), 1, 1, &alpha);
-			GPU_shader_uniform_vector(shader, GPU_shader_get_uniform(shader, "global"), 1, 1, &world_light);
-
-		}
-		GWN_batch_draw(triangles);
-	}
-}
-
 Gwn_Batch *GPU_pbvh_buffers_batch_get(GPU_PBVH_Buffers *buffers, bool fast)
 {
 	return (fast && buffers->triangles_fast) ?
@@ -1870,22 +958,18 @@ Gwn_Batch *GPU_pbvh_buffers_batch_get(GPU_PBVH_Buffers *buffers, bool fast)
 bool GPU_pbvh_buffers_diffuse_changed(GPU_PBVH_Buffers *buffers, GSet *bm_faces, bool show_diffuse_color)
 {
 	float diffuse_color[4];
-	bool use_matcaps = GPU_material_use_matcaps_get();
 
 	if (buffers->show_diffuse_color != show_diffuse_color)
 		return true;
 
-	if (buffers->use_matcaps != use_matcaps)
-		return true;
-
-	if ((buffers->show_diffuse_color == false) || use_matcaps)
+	if (buffers->show_diffuse_color == false)
 		return false;
 
 	if (buffers->looptri) {
 		const MLoopTri *lt = &buffers->looptri[buffers->face_indices[0]];
 		const MPoly *mp = &buffers->mpoly[lt->poly];
 
-		GPU_material_diffuse_get(mp->mat_nr + 1, diffuse_color);
+		gpu_material_diffuse_get(mp->mat_nr + 1, diffuse_color);
 	}
 	else if (buffers->use_bmesh) {
 		/* due to dynamic nature of dyntopo, only get first material */
@@ -1895,7 +979,7 @@ bool GPU_pbvh_buffers_diffuse_changed(GPU_PBVH_Buffers *buffers, GSet *bm_faces,
 
 			BLI_gsetIterator_init(&gs_iter, bm_faces);
 			f = BLI_gsetIterator_getKey(&gs_iter);
-			GPU_material_diffuse_get(f->mat_nr + 1, diffuse_color);
+			gpu_material_diffuse_get(f->mat_nr + 1, diffuse_color);
 		}
 		else {
 			return false;
@@ -1904,7 +988,7 @@ bool GPU_pbvh_buffers_diffuse_changed(GPU_PBVH_Buffers *buffers, GSet *bm_faces,
 	else {
 		const DMFlagMat *flags = &buffers->grid_flag_mats[buffers->grid_indices[0]];
 
-		GPU_material_diffuse_get(flags->mat_nr + 1, diffuse_color);
+		gpu_material_diffuse_get(flags->mat_nr + 1, diffuse_color);
 	}
 
 	return !equals_v3v3(diffuse_color, buffers->diffuse_color);
@@ -2007,3 +1091,7 @@ void GPU_pbvh_BB_draw(float min[3], float max[3], bool leaf, unsigned int pos)
 
 	immEnd();
 }
+
+void GPU_pbvh_fix_linking()
+{
+}
diff --git a/source/blender/gpu/intern/gpu_codegen.c b/source/blender/gpu/intern/gpu_codegen.c
index b245c9a161f..da69d9cdb16 100644
--- a/source/blender/gpu/intern/gpu_codegen.c
+++ b/source/blender/gpu/intern/gpu_codegen.c
@@ -780,7 +780,7 @@ static void codegen_call_functions(DynStr *ds, ListBase *nodes, GPUOutput *final
 	BLI_dynstr_append(ds, ";\n");
 }
 
-static char *code_generate_fragment(GPUMaterial *material, ListBase *nodes, GPUOutput *output, bool use_new_shading)
+static char *code_generate_fragment(GPUMaterial *material, ListBase *nodes, GPUOutput *output)
 {
 	DynStr *ds = BLI_dynstr_new();
 	char *code;
@@ -806,38 +806,20 @@ static char *code_generate_fragment(GPUMaterial *material, ListBase *nodes, GPUO
 
 	BLI_dynstr_append(ds, "Closure nodetree_exec(void)\n{\n");
 
-	if (use_new_shading) {
-		if (builtins & GPU_VIEW_MATRIX)
-			BLI_dynstr_append(ds, "\tmat4 viewmat = ViewMatrix;\n");
-		if (builtins & GPU_CAMERA_TEXCO_FACTORS)
-			BLI_dynstr_append(ds, "\tvec4 camtexfac = CameraTexCoFactors;\n");
-		if (builtins & GPU_OBJECT_MATRIX)
-			BLI_dynstr_append(ds, "\tmat4 objmat = ModelMatrix;\n");
-		if (builtins & GPU_INVERSE_OBJECT_MATRIX)
-			BLI_dynstr_append(ds, "\tmat4 objinv = ModelMatrixInverse;\n");
-		if (builtins & GPU_INVERSE_VIEW_MATRIX)
-			BLI_dynstr_append(ds, "\tmat4 viewinv = ViewMatrixInverse;\n");
-		if (builtins & GPU_VIEW_NORMAL)
-			BLI_dynstr_append(ds, "\tvec3 facingnormal = gl_FrontFacing? viewNormal: -viewNormal;\n");
-		if (builtins & GPU_VIEW_POSITION)
-			BLI_dynstr_append(ds, "\tvec3 viewposition = viewPosition;\n");
-	}
-	else {
-		if (builtins & GPU_VIEW_MATRIX)
-			BLI_dynstr_append(ds, "\tmat4 viewmat = unfviewmat;\n");
-		if (builtins & GPU_CAMERA_TEXCO_FACTORS)
-			BLI_dynstr_append(ds, "\tvec4 camtexfac = unfcameratexfactors;\n");
-		if (builtins & GPU_OBJECT_MATRIX)
-			BLI_dynstr_append(ds, "\tmat4 objmat = unfobmat;\n");
-		if (builtins & GPU_INVERSE_OBJECT_MATRIX)
-			BLI_dynstr_append(ds, "\tmat4 objinv = unfinvobmat;\n");
-		if (builtins & GPU_INVERSE_VIEW_MATRIX)
-			BLI_dynstr_append(ds, "\tmat4 viewinv = unfinvviewmat;\n");
-		if (builtins & GPU_VIEW_NORMAL)
-			BLI_dynstr_append(ds, "\tvec3 facingnormal = gl_FrontFacing? varnormal: -varnormal;\n");
-		if (builtins & GPU_VIEW_POSITION)
-			BLI_dynstr_append(ds, "\tvec3 viewposition = varposition;\n");
-	}
+	if (builtins & GPU_VIEW_MATRIX)
+		BLI_dynstr_append(ds, "\tmat4 viewmat = ViewMatrix;\n");
+	if (builtins & GPU_CAMERA_TEXCO_FACTORS)
+		BLI_dynstr_append(ds, "\tvec4 camtexfac = CameraTexCoFactors;\n");
+	if (builtins & GPU_OBJECT_MATRIX)
+		BLI_dynstr_append(ds, "\tmat4 objmat = ModelMatrix;\n");
+	if (builtins & GPU_INVERSE_OBJECT_MATRIX)
+		BLI_dynstr_append(ds, "\tmat4 objinv = ModelMatrixInverse;\n");
+	if (builtins & GPU_INVERSE_VIEW_MATRIX)
+		BLI_dynstr_append(ds, "\tmat4 viewinv = ViewMatrixInverse;\n");
+	if (builtins & GPU_VIEW_NORMAL)
+		BLI_dynstr_append(ds, "\tvec3 facingnormal = gl_FrontFacing? viewNormal: -viewNormal;\n");
+	if (builtins & GPU_VIEW_POSITION)
+		BLI_dynstr_append(ds, "\tvec3 viewposition = viewPosition;\n");
 
 	/* Calculate tangent space. */
 #ifdef WITH_OPENSUBDIV
@@ -906,7 +888,7 @@ static const char *attrib_prefix_get(CustomDataType type)
 	}
 }
 
-static char *code_generate_vertex_new(ListBase *nodes, const char *vert_code, bool use_geom)
+static char *code_generate_vertex(ListBase *nodes, const char *vert_code, bool use_geom)
 {
 	DynStr *ds = BLI_dynstr_new();
 	GPUNode *node;
@@ -983,115 +965,7 @@ static char *code_generate_vertex_new(ListBase *nodes, const char *vert_code, bo
 	return code;
 }
 
-static char *code_generate_vertex(ListBase *nodes, const GPUMatType type)
-{
-	DynStr *ds = BLI_dynstr_new();
-	GPUNode *node;
-	GPUInput *input;
-	char *code;
-	char *vertcode = NULL;
-	
-	for (node = nodes->first; node; node = node->next) {
-		for (input = node->inputs.first; input; input = input->next) {
-			if (input->source == GPU_SOURCE_ATTRIB && input->attribfirst) {
-#ifdef WITH_OPENSUBDIV
-				bool skip_opensubdiv = ELEM(input->attribtype, CD_MTFACE, CD_TANGENT);
-				if (skip_opensubdiv) {
-					BLI_dynstr_appendf(ds, "#ifndef USE_OPENSUBDIV\n");
-				}
-#endif
-				BLI_dynstr_appendf(ds, "%s %s att%d;\n",
-					GLEW_VERSION_3_0 ? "in" : "attribute",
-					GPU_DATATYPE_STR[input->type], input->attribid);
-				BLI_dynstr_appendf(ds, "uniform int att%d_info;\n",  input->attribid);
-				BLI_dynstr_appendf(ds, "%s %s var%d;\n",
-					GLEW_VERSION_3_0 ? "out" : "varying",
-					GPU_DATATYPE_STR[input->type], input->attribid);
-#ifdef WITH_OPENSUBDIV
-				if (skip_opensubdiv) {
-					BLI_dynstr_appendf(ds, "#endif\n");
-				}
-#endif
-			}
-		}
-	}
-
-	BLI_dynstr_append(ds, "\n");
-
-	switch (type) {
-		case GPU_MATERIAL_TYPE_MESH:
-			vertcode = datatoc_gpu_shader_vertex_glsl;
-			break;
-		case GPU_MATERIAL_TYPE_WORLD:
-			vertcode = datatoc_gpu_shader_vertex_world_glsl;
-			break;
-		default:
-			fprintf(stderr, "invalid material type, set one after GPU_material_construct_begin\n");
-			break;
-	}
-
-	BLI_dynstr_append(ds, vertcode);
-	
-	for (node = nodes->first; node; node = node->next)
-		for (input = node->inputs.first; input; input = input->next)
-			if (input->source == GPU_SOURCE_ATTRIB && input->attribfirst) {
-				if (input->attribtype == CD_TANGENT) { /* silly exception */
-#ifdef WITH_OPENSUBDIV
-					BLI_dynstr_appendf(ds, "#ifndef USE_OPENSUBDIV\n");
-#endif
-					BLI_dynstr_appendf(
-					        ds, "\tvar%d.xyz = normalize(NormalMatrix * att%d.xyz);\n",
-					        input->attribid, input->attribid);
-					BLI_dynstr_appendf(
-					        ds, "\tvar%d.w = att%d.w;\n",
-					        input->attribid, input->attribid);
-#ifdef WITH_OPENSUBDIV
-					BLI_dynstr_appendf(ds, "#endif\n");
-#endif
-				}
-				else {
-#ifdef WITH_OPENSUBDIV
-					bool is_mtface = input->attribtype == CD_MTFACE;
-					if (is_mtface) {
-						BLI_dynstr_appendf(ds, "#ifndef USE_OPENSUBDIV\n");
-					}
-#endif
-					BLI_dynstr_appendf(ds, "\tset_var_from_attr(att%d, att%d_info, var%d);\n",
-					                   input->attribid, input->attribid, input->attribid);
-#ifdef WITH_OPENSUBDIV
-					if (is_mtface) {
-						BLI_dynstr_appendf(ds, "#endif\n");
-					}
-#endif
-				}
-			}
-			/* unfortunately special handling is needed here because we abuse gl_Color/gl_SecondaryColor flat shading */
-			else if (input->source == GPU_SOURCE_OPENGL_BUILTIN) {
-				if (input->oglbuiltin == GPU_MATCAP_NORMAL) {
-					/* remap to 0.0 - 1.0 range. This is done because OpenGL 2.0 clamps colors
-					 * between shader stages and we want the full range of the normal */
-					BLI_dynstr_appendf(ds, "\tvec3 matcapcol = vec3(0.5) * varnormal + vec3(0.5);\n");
-					BLI_dynstr_appendf(ds, "\tgl_FrontSecondaryColor = vec4(matcapcol, 1.0);\n");
-				}
-				else if (input->oglbuiltin == GPU_COLOR) {
-					BLI_dynstr_appendf(ds, "\tgl_FrontColor = gl_Color;\n");
-				}
-			}
-
-	BLI_dynstr_append(ds, "}\n");
-
-	code = BLI_dynstr_get_cstring(ds);
-
-	BLI_dynstr_free(ds);
-
-#if 0
-	if (G.debug & G_DEBUG) printf("%s\n", code);
-#endif
-
-	return code;
-}
-
-static char *code_generate_geometry_new(ListBase *nodes, const char *geom_code)
+static char *code_generate_geometry(ListBase *nodes, const char *geom_code)
 {
 	DynStr *ds = BLI_dynstr_new();
 	GPUNode *node;
@@ -1136,67 +1010,6 @@ static char *code_generate_geometry_new(ListBase *nodes, const char *geom_code)
 	return code;
 }
 
-static char *code_generate_geometry(ListBase *nodes, bool use_opensubdiv)
-{
-#ifdef WITH_OPENSUBDIV
-	if (use_opensubdiv) {
-		DynStr *ds = BLI_dynstr_new();
-		GPUNode *node;
-		GPUInput *input;
-		char *code;
-
-		/* Generate varying declarations. */
-		for (node = nodes->first; node; node = node->next) {
-			for (input = node->inputs.first; input; input = input->next) {
-				if (input->source == GPU_SOURCE_ATTRIB && input->attribfirst) {
-					if (input->attribtype == CD_MTFACE) {
-						/* NOTE: For now we are using varying on purpose,
-						 * otherwise we are not able to write to the varying.
-						 */
-						BLI_dynstr_appendf(ds, "%s %s var%d%s;\n",
-						                   "varying",
-						                   GPU_DATATYPE_STR[input->type],
-						                   input->attribid,
-						                   "");
-						BLI_dynstr_appendf(ds, "uniform int fvar%d_offset;\n",
-						                   input->attribid);
-					}
-				}
-			}
-		}
-
-		BLI_dynstr_append(ds, datatoc_gpu_shader_geometry_glsl);
-
-		/* Generate varying assignments. */
-		for (node = nodes->first; node; node = node->next) {
-			for (input = node->inputs.first; input; input = input->next) {
-				if (input->source == GPU_SOURCE_ATTRIB && input->attribfirst) {
-					if (input->attribtype == CD_MTFACE) {
-						BLI_dynstr_appendf(
-						        ds,
-						        "\tINTERP_FACE_VARYING_ATT_2(var%d, "
-						        "int(texelFetch(FVarDataOffsetBuffer, fvar%d_offset).r), st);\n",
-						        input->attribid,
-						        input->attribid);
-					}
-				}
-			}
-		}
-
-		BLI_dynstr_append(ds, "}\n");
-		code = BLI_dynstr_get_cstring(ds);
-		BLI_dynstr_free(ds);
-
-		//if (G.debug & G_DEBUG) printf("%s\n", code);
-
-		return code;
-	}
-#else
-	UNUSED_VARS(nodes, use_opensubdiv);
-#endif
-	return NULL;
-}
-
 void GPU_code_generate_glsl_lib(void)
 {
 	DynStr *ds;
@@ -1223,65 +1036,6 @@ GPUShader *GPU_pass_shader(GPUPass *pass)
 	return pass->shader;
 }
 
-static void gpu_nodes_extract_dynamic_inputs_new(GPUShader *shader, ListBase *inputs, ListBase *nodes)
-{
-	GPUNode *node;
-	GPUInput *next, *input;
-	int extract, z;
-
-	BLI_listbase_clear(inputs);
-
-	if (!shader)
-		return;
-
-	GPU_shader_bind(shader);
-
-	for (node = nodes->first; node; node = node->next) {
-		z = 0;
-		for (input = node->inputs.first; input; input = next, z++) {
-			next = input->next;
-
-			/* attributes don't need to be bound, they already have
-			 * an id that the drawing functions will use */
-			if (input->source == GPU_SOURCE_ATTRIB) {
-				continue;
-			}
-
-			if (input->source == GPU_SOURCE_BUILTIN ||
-			    input->source == GPU_SOURCE_OPENGL_BUILTIN)
-			{
-				continue;
-			}
-
-			if (input->ima || input->tex || input->prv)
-				BLI_snprintf(input->shadername, sizeof(input->shadername), "samp%d", input->texid);
-			else
-				BLI_snprintf(input->shadername, sizeof(input->shadername), "unf%d", input->id);
-
-			/* pass non-dynamic uniforms to opengl */
-			extract = 0;
-
-			if (input->ima || input->tex || input->prv) {
-				if (input->bindtex)
-					extract = 1;
-			}
-			else if (input->dynamicvec)
-				extract = 1;
-
-			if (extract)
-				input->shaderloc = GPU_shader_get_uniform(shader, input->shadername);
-
-			/* extract nodes */
-			if (extract) {
-				BLI_remlink(&node->inputs, input);
-				BLI_addtail(inputs, input);
-			}
-		}
-	}
-
-	GPU_shader_unbind();
-}
-
 static void gpu_nodes_extract_dynamic_inputs(GPUShader *shader, ListBase *inputs, ListBase *nodes)
 {
 	GPUNode *node;
@@ -1303,26 +1057,9 @@ static void gpu_nodes_extract_dynamic_inputs(GPUShader *shader, ListBase *inputs
 			/* attributes don't need to be bound, they already have
 			 * an id that the drawing functions will use */
 			if (input->source == GPU_SOURCE_ATTRIB) {
-#ifdef WITH_OPENSUBDIV
-				/* We do need mtface attributes for later, so we can
-				 * update face-varuing variables offset in the texture
-				 * buffer for proper sampling from the shader.
-				 *
-				 * We don't do anything about attribute itself, we
-				 * only use it to learn which uniform name is to be
-				 * updated.
-				 *
-				 * TODO(sergey): We can add ad extra uniform input
-				 * for the offset, which will be purely internal and
-				 * which would avoid having such an exceptions.
-				 */
-				if (input->attribtype != CD_MTFACE) {
-					continue;
-				}
-#else
 				continue;
-#endif
 			}
+
 			if (input->source == GPU_SOURCE_BUILTIN ||
 			    input->source == GPU_SOURCE_OPENGL_BUILTIN)
 			{
@@ -1347,14 +1084,6 @@ static void gpu_nodes_extract_dynamic_inputs(GPUShader *shader, ListBase *inputs
 			if (extract)
 				input->shaderloc = GPU_shader_get_uniform(shader, input->shadername);
 
-#ifdef WITH_OPENSUBDIV
-			if (input->source == GPU_SOURCE_ATTRIB &&
-			    input->attribtype == CD_MTFACE)
-			{
-				extract = 1;
-			}
-#endif
-
 			/* extract nodes */
 			if (extract) {
 				BLI_remlink(&node->inputs, input);
@@ -1802,19 +1531,6 @@ void GPU_nodes_get_vertex_attributes(ListBase *nodes, GPUVertexAttribs *attribs)
 	}
 }
 
-static void gpu_nodes_get_builtin_flag(ListBase *nodes, int *builtin)
-{
-	GPUNode *node;
-	GPUInput *input;
-	
-	*builtin = 0;
-
-	for (node = nodes->first; node; node = node->next)
-		for (input = node->inputs.first; input; input = input->next)
-			if (input->source == GPU_SOURCE_BUILTIN)
-				*builtin |= input->builtin;
-}
-
 /* varargs linking  */
 
 GPUNodeLink *GPU_attribute(const CustomDataType type, const char *name)
@@ -2129,11 +1845,11 @@ GPUPass *GPU_generate_pass_new(
 	GPU_nodes_get_vertex_attributes(nodes, attribs);
 
 	/* generate code */
-	char *fragmentgen = code_generate_fragment(material, nodes, frag_outlink->output, true);
+	char *fragmentgen = code_generate_fragment(material, nodes, frag_outlink->output);
 	char *tmp = BLI_strdupcat(frag_lib, glsl_material_library);
 
-	vertexcode = code_generate_vertex_new(nodes, vert_code, (geom_code != NULL));
-	geometrycode = (geom_code) ? code_generate_geometry_new(nodes, geom_code) : NULL;
+	vertexcode = code_generate_vertex(nodes, vert_code, (geom_code != NULL));
+	geometrycode = (geom_code) ? code_generate_geometry(nodes, geom_code) : NULL;
 	fragmentcode = BLI_strdupcat(tmp, fragmentgen);
 
 	MEM_freeN(fragmentgen);
@@ -2182,85 +1898,11 @@ GPUPass *GPU_generate_pass_new(
 		return NULL;
 	}
 	else {
-		gpu_nodes_extract_dynamic_inputs_new(shader, inputs, nodes);
+		gpu_nodes_extract_dynamic_inputs(shader, inputs, nodes);
 		return pass;
 	}
 }
 
-/* TODO(fclem) Remove for 2.8 */
-GPUPass *GPU_generate_pass(
-        ListBase *nodes, ListBase *inputs, GPUNodeLink *outlink,
-        GPUVertexAttribs *attribs, int *builtins,
-        const GPUMatType type, const char *UNUSED(name),
-        const bool use_opensubdiv,
-        const bool use_new_shading)
-{
-	GPUShader *shader;
-	GPUPass *pass;
-	char *vertexcode, *geometrycode, *fragmentcode;
-
-#if 0
-	if (!FUNCTION_LIB) {
-		GPU_nodes_free(nodes);
-		return NULL;
-	}
-#endif
-
-	/* prune unused nodes */
-	GPU_nodes_prune(nodes, outlink);
-
-	GPU_nodes_get_vertex_attributes(nodes, attribs);
-	gpu_nodes_get_builtin_flag(nodes, builtins);
-
-	/* generate code and compile with opengl */
-	fragmentcode = code_generate_fragment(NULL, nodes, outlink->output, false);
-	vertexcode = code_generate_vertex(nodes, type);
-	geometrycode = code_generate_geometry(nodes, use_opensubdiv);
-
-	int flags = GPU_SHADER_FLAGS_NONE;
-	if (use_opensubdiv) {
-		flags |= GPU_SHADER_FLAGS_SPECIAL_OPENSUBDIV;
-	}
-	if (use_new_shading) {
-		flags |= GPU_SHADER_FLAGS_NEW_SHADING;
-	}
-	shader = GPU_shader_create_ex(vertexcode,
-	                              fragmentcode,
-	                              geometrycode,
-	                              glsl_material_library,
-	                              NULL,
-	                              flags);
-
-	/* failed? */
-	if (!shader) {
-		if (fragmentcode)
-			MEM_freeN(fragmentcode);
-		if (vertexcode)
-			MEM_freeN(vertexcode);
-		memset(attribs, 0, sizeof(*attribs));
-		memset(builtins, 0, sizeof(*builtins));
-		gpu_nodes_free(nodes);
-		return NULL;
-	}
-	
-	/* create pass */
-	pass = MEM_callocN(sizeof(GPUPass), "GPUPass");
-	pass->refcount = 1;
-	pass->shader = shader;
-	pass->fragmentcode = fragmentcode;
-	pass->geometrycode = geometrycode;
-	pass->vertexcode = vertexcode;
-	pass->libcode = glsl_material_library;
-
-	BLI_linklist_prepend(&pass_cache, pass);
-
-	/* extract dynamic inputs and throw away nodes */
-	gpu_nodes_extract_dynamic_inputs(shader, inputs, nodes);
-	gpu_nodes_free(nodes);
-
-	return pass;
-}
-
 void GPU_pass_release(GPUPass *pass)
 {
 	BLI_assert(pass->refcount > 0);
diff --git a/source/blender/gpu/intern/gpu_codegen.h b/source/blender/gpu/intern/gpu_codegen.h
index dab0bc3f8b1..328da36c3de 100644
--- a/source/blender/gpu/intern/gpu_codegen.h
+++ b/source/blender/gpu/intern/gpu_codegen.h
@@ -180,8 +180,7 @@ GPUPass *GPU_generate_pass(
         ListBase *nodes, ListBase *inputs, struct GPUNodeLink *outlink,
         struct GPUVertexAttribs *attribs, int *builtin,
         const GPUMatType type, const char *name,
-        const bool use_opensubdiv,
-        const bool use_new_shading);
+        const bool use_opensubdiv);
 
 struct GPUShader *GPU_pass_shader(GPUPass *pass);
 
diff --git a/source/blender/gpu/intern/gpu_draw.c b/source/blender/gpu/intern/gpu_draw.c
index 5d9270223ab..6b768d4bdd6 100644
--- a/source/blender/gpu/intern/gpu_draw.c
+++ b/source/blender/gpu/intern/gpu_draw.c
@@ -72,7 +72,6 @@
 #include "BKE_DerivedMesh.h"
 
 #include "GPU_basic_shader.h"
-#include "GPU_buffers.h"
 #include "GPU_draw.h"
 #include "GPU_extensions.h"
 #include "GPU_material.h"
@@ -240,38 +239,6 @@ static unsigned int *gpu_get_image_bindcode(Image *ima, GLenum textarget)
 	return bind;
 }
 
-static void gpu_set_alpha_blend(GPUBlendMode alphablend)
-{
-	if (alphablend == GPU_BLEND_SOLID) {
-		glDisable(GL_BLEND);
-		glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
-		glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
-	}
-	else if (alphablend == GPU_BLEND_ADD) {
-		glEnable(GL_BLEND);
-		glBlendFunc(GL_ONE, GL_ONE);
-		glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
-	}
-	else if (ELEM(alphablend, GPU_BLEND_ALPHA, GPU_BLEND_ALPHA_SORT)) {
-		glEnable(GL_BLEND);
-		glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
-
-		/* for OpenGL render we use the alpha channel, this makes alpha blend correct */
-		glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
-
-		/* if U.glalphaclip == 1.0, some cards go bonkers...
-		 * turn off alpha test in this case */
-
-	}
-	else if (alphablend == GPU_BLEND_CLIP) {
-		glDisable(GL_BLEND);
-		glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
-	}
-	else if (alphablend == GPU_BLEND_ALPHA_TO_COVERAGE) {
-		glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE);
-	}
-}
-
 typedef struct VerifyThreadData {
 	ImBuf *ibuf;
 	float *srgb_frect;
@@ -1038,9 +1005,6 @@ void GPU_free_unused_buffers(void)
 	BLI_linklist_free(image_free_queue, NULL);
 	image_free_queue = NULL;
 
-	/* vbo buffers */
-	GPU_global_buffer_pool_free_unused();
-
 	BLI_thread_unlock(LOCK_OPENGL);
 }
 
@@ -1120,652 +1084,6 @@ void GPU_free_images_old(void)
 	}
 }
 
-
-/* OpenGL Materials */
-
-#define FIXEDMAT 8
-
-/* OpenGL state caching for materials */
-
-typedef struct GPUMaterialFixed {
-	float diff[3];
-	float spec[3];
-	int hard;
-	float alpha;
-} GPUMaterialFixed;
-
-static struct GPUMaterialState {
-	GPUMaterialFixed (*matbuf);
-	GPUMaterialFixed matbuf_fixed[FIXEDMAT];
-	int totmat;
-
-	/* set when called inside GPU_begin_object_materials / GPU_end_object_materials
-	 * otherwise calling GPU_object_material_bind returns zero */
-	bool is_enabled;
-
-	Material **gmatbuf;
-	Material *gmatbuf_fixed[FIXEDMAT];
-	Material *gboundmat;
-	Object *gob;
-	DupliObject *dob;
-	Scene *gscene;
-	int glay;
-	float (*gviewmat)[4];
-	float (*gviewinv)[4];
-	float (*gviewcamtexcofac);
-
-	bool backface_culling;
-	bool two_sided_lighting;
-
-	GPUBlendMode *alphablend;
-	GPUBlendMode alphablend_fixed[FIXEDMAT];
-	bool use_alpha_pass, is_alpha_pass;
-	bool use_matcaps;
-
-	int lastmatnr, lastretval;
-	GPUBlendMode lastalphablend;
-	bool is_opensubdiv;
-} GMS = {NULL};
-
-/* fixed function material, alpha handed by caller */
-static void gpu_material_to_fixed(
-        GPUMaterialFixed *smat, const Material *bmat, const int gamma, const Object *ob,
-        const int new_shading_nodes, const bool dimdown)
-{
-	if (bmat->mode & MA_SHLESS) {
-		copy_v3_v3(smat->diff, &bmat->r);
-
-		if (gamma)
-			linearrgb_to_srgb_v3_v3(smat->diff, smat->diff);
-
-		zero_v3(smat->spec);
-		smat->alpha = 1.0f;
-		smat->hard = 0;
-	}
-	else if (new_shading_nodes) {
-		copy_v3_v3(smat->diff, &bmat->r);
-		copy_v3_v3(smat->spec, &bmat->specr);
-		smat->alpha = 1.0f;
-		smat->hard = CLAMPIS(bmat->har, 0, 128);
-
-		if (dimdown) {
-			mul_v3_fl(smat->diff, 0.8f);
-			mul_v3_fl(smat->spec, 0.5f);
-		}
-
-		if (gamma) {
-			linearrgb_to_srgb_v3_v3(smat->diff, smat->diff);
-			linearrgb_to_srgb_v3_v3(smat->spec, smat->spec);
-		}
-	}
-	else {
-		mul_v3_v3fl(smat->diff, &bmat->r, bmat->ref + bmat->emit);
-
-		if (bmat->shade_flag & MA_OBCOLOR)
-			mul_v3_v3(smat->diff, ob->col);
-
-		mul_v3_v3fl(smat->spec, &bmat->specr, bmat->spec);
-		smat->hard = CLAMPIS(bmat->har, 1, 128);
-		smat->alpha = 1.0f;
-
-		if (gamma) {
-			linearrgb_to_srgb_v3_v3(smat->diff, smat->diff);
-			linearrgb_to_srgb_v3_v3(smat->spec, smat->spec);
-		}
-	}
-}
-
-static Material *gpu_active_node_material(Material *ma)
-{
-	if (ma && ma->use_nodes && ma->nodetree) {
-		bNode *node = nodeGetActiveID(ma->nodetree, ID_MA);
-
-		if (node)
-			return (Material *)node->id;
-		else
-			return NULL;
-	}
-
-	return ma;
-}
-
-void GPU_begin_dupli_object(DupliObject *dob)
-{
-	GMS.dob = dob;
-}
-
-void GPU_end_dupli_object(void)
-{
-	GMS.dob = NULL;
-}
-
-void GPU_begin_object_materials(
-        View3D *v3d, RegionView3D *rv3d, Scene *scene, ViewLayer *UNUSED(view_layer), Object *ob,
-        bool glsl, bool *do_alpha_after)
-{
-	Material *ma;
-	GPUMaterial *gpumat;
-	GPUBlendMode alphablend;
-	DupliObject *dob;
-	int a;
-	const bool gamma = BKE_scene_check_color_management_enabled(scene);
-	const bool new_shading_nodes = BKE_scene_use_new_shading_nodes(scene);
-	const bool use_matcap = (v3d->flag2 & V3D_SHOW_SOLID_MATCAP) != 0;  /* assumes v3d->defmaterial->preview is set */
-	bool use_opensubdiv = false;
-
-#ifdef WITH_OPENSUBDIV
-	{
-		DerivedMesh *derivedFinal = NULL;
-		if (ob->type == OB_MESH) {
-			Mesh *me = ob->data;
-			BMEditMesh *em = me->edit_btmesh;
-			if (em != NULL) {
-				derivedFinal = em->derivedFinal;
-			}
-			else {
-				derivedFinal = ob->derivedFinal;
-			}
-		}
-		else {
-			derivedFinal = ob->derivedFinal;
-		}
-
-		if (derivedFinal != NULL && derivedFinal->type == DM_TYPE_CCGDM) {
-			CCGDerivedMesh *ccgdm = (CCGDerivedMesh *) derivedFinal;
-			use_opensubdiv = ccgdm->useGpuBackend;
-		}
-	}
-#endif
-
-	/* initialize state */
-	/* DupliObject must be restored */
-	dob = GMS.dob;
-	memset(&GMS, 0, sizeof(GMS));
-	GMS.is_enabled = true;
-	GMS.dob = dob;
-	GMS.lastmatnr = -1;
-	GMS.lastretval = -1;
-	GMS.lastalphablend = GPU_BLEND_SOLID;
-	GMS.use_matcaps = use_matcap;
-
-	GMS.backface_culling = (v3d->flag2 & V3D_BACKFACE_CULLING) != 0;
-
-	GMS.two_sided_lighting = false;
-	if (ob && ob->type == OB_MESH)
-		GMS.two_sided_lighting = (((Mesh *)ob->data)->flag & ME_TWOSIDED) != 0;
-
-	GMS.gob = ob;
-	GMS.gscene = scene;
-	GMS.is_opensubdiv = use_opensubdiv;
-	GMS.totmat = use_matcap ? 1 : ob->totcol + 1;  /* materials start from 1, default material is 0 */
-	GMS.glay = (v3d->localvd) ? v3d->localvd->lay : v3d->lay; /* keep lamps visible in local view */
-	GMS.gviewmat = rv3d->viewmat;
-	GMS.gviewinv = rv3d->viewinv;
-	GMS.gviewcamtexcofac = rv3d->viewcamtexcofac;
-
-	/* alpha pass setup. there's various cases to handle here:
-	 * - object transparency on: only solid materials draw in the first pass,
-	 * and only transparent in the second 'alpha' pass.
-	 * - object transparency off: for glsl we draw both in a single pass, and
-	 * for solid we don't use transparency at all. */
-	GMS.use_alpha_pass = (do_alpha_after != NULL);
-	GMS.is_alpha_pass = (v3d->transp != false);
-	if (GMS.use_alpha_pass)
-		*do_alpha_after = false;
-
-	if (GMS.totmat > FIXEDMAT) {
-		GMS.matbuf = MEM_callocN(sizeof(GPUMaterialFixed) * GMS.totmat, "GMS.matbuf");
-		GMS.gmatbuf = MEM_callocN(sizeof(*GMS.gmatbuf) * GMS.totmat, "GMS.matbuf");
-		GMS.alphablend = MEM_callocN(sizeof(*GMS.alphablend) * GMS.totmat, "GMS.matbuf");
-	}
-	else {
-		GMS.matbuf = GMS.matbuf_fixed;
-		GMS.gmatbuf = GMS.gmatbuf_fixed;
-		GMS.alphablend = GMS.alphablend_fixed;
-	}
-
-	/* viewport material, setup in space_view3d, defaults to matcap using ma->preview now */
-	if (use_matcap) {
-		GMS.gmatbuf[0] = v3d->defmaterial;
-		GPU_material_matcap(scene, v3d->defmaterial, use_opensubdiv);
-
-		/* do material 1 too, for displists! */
-		memcpy(&GMS.matbuf[1], &GMS.matbuf[0], sizeof(GPUMaterialFixed));
-
-		GMS.alphablend[0] = GPU_BLEND_SOLID;
-	}
-	else {
-
-		/* no materials assigned? */
-		if (ob->totcol == 0) {
-			gpu_material_to_fixed(&GMS.matbuf[0], &defmaterial, 0, ob, new_shading_nodes, true);
-
-			/* do material 1 too, for displists! */
-			memcpy(&GMS.matbuf[1], &GMS.matbuf[0], sizeof(GPUMaterialFixed));
-
-			if (glsl) {
-				GMS.gmatbuf[0] = &defmaterial;
-				GPU_material_from_blender(GMS.gscene, &defmaterial, GMS.is_opensubdiv);
-			}
-
-			GMS.alphablend[0] = GPU_BLEND_SOLID;
-		}
-
-		/* setup materials */
-		for (a = 1; a <= ob->totcol; a++) {
-			/* find a suitable material */
-			ma = give_current_material(ob, a);
-			if (!glsl && !new_shading_nodes) ma = gpu_active_node_material(ma);
-			if (ma == NULL) ma = &defmaterial;
-
-			/* create glsl material if requested */
-			gpumat = glsl ? GPU_material_from_blender(GMS.gscene, ma, GMS.is_opensubdiv) : NULL;
-
-			if (gpumat) {
-				/* do glsl only if creating it succeed, else fallback */
-				GMS.gmatbuf[a] = ma;
-				alphablend = GPU_material_alpha_blend(gpumat, ob->col);
-			}
-			else {
-				/* fixed function opengl materials */
-				gpu_material_to_fixed(&GMS.matbuf[a], ma, gamma, ob, new_shading_nodes, false);
-
-				if (GMS.use_alpha_pass && ((ma->mode & MA_TRANSP) || (new_shading_nodes && ma->alpha != 1.0f))) {
-					GMS.matbuf[a].alpha = ma->alpha;
-					alphablend = (ma->alpha == 1.0f) ? GPU_BLEND_SOLID: GPU_BLEND_ALPHA;
-				}
-				else {
-					GMS.matbuf[a].alpha = 1.0f;
-					alphablend = GPU_BLEND_SOLID;
-				}
-			}
-
-			/* setting 'do_alpha_after = true' indicates this object needs to be
-			 * drawn in a second alpha pass for improved blending */
-			if (do_alpha_after && !GMS.is_alpha_pass)
-				if (ELEM(alphablend, GPU_BLEND_ALPHA, GPU_BLEND_ADD, GPU_BLEND_ALPHA_SORT))
-					*do_alpha_after = true;
-
-			GMS.alphablend[a] = alphablend;
-		}
-	}
-
-	/* let's start with a clean state */
-	GPU_object_material_unbind();
-}
-
-static int gpu_get_particle_info(GPUParticleInfo *pi)
-{
-	DupliObject *dob = GMS.dob;
-	if (dob->particle_system) {
-		int ind;
-		if (dob->persistent_id[0] < dob->particle_system->totpart)
-			ind = dob->persistent_id[0];
-		else {
-			ind = dob->particle_system->child[dob->persistent_id[0] - dob->particle_system->totpart].parent;
-		}
-		if (ind >= 0) {
-			ParticleData *p = &dob->particle_system->particles[ind];
-
-			pi->scalprops[0] = ind;
-			pi->scalprops[1] = GMS.gscene->r.cfra - p->time;
-			pi->scalprops[2] = p->lifetime;
-			pi->scalprops[3] = p->size;
-
-			copy_v3_v3(pi->location, p->state.co);
-			pi->location[3] = BLI_hash_int_01(ind);
-
-			copy_v3_v3(pi->velocity, p->state.vel);
-			copy_v3_v3(pi->angular_velocity, p->state.ave);
-			return 1;
-		}
-		else return 0;
-	}
-	else
-		return 0;
-}
-
-static void GPU_get_object_info(float oi[3], Material *mat)
-{
-	Object *ob = GMS.gob;
-	oi[0] = ob->index;
-	oi[1] = mat->index;
-	unsigned int random;
-	if (GMS.dob) {
-		random = GMS.dob->random_id;
-	}
-	else {
-		random = BLI_hash_int_2d(BLI_hash_string(GMS.gob->id.name + 2), 0);
-	}
-	oi[2] = random * (1.0f / (float)0xFFFFFFFF);
-}
-
-int GPU_object_material_bind(int nr, void *attribs)
-{
-	GPUVertexAttribs *gattribs = attribs;
-
-	/* no GPU_begin_object_materials, use default material */
-	if (!GMS.matbuf) {
-		memset(&GMS, 0, sizeof(GMS));
-
-		float diffuse[3], specular[3];
-		mul_v3_v3fl(diffuse, &defmaterial.r, defmaterial.ref + defmaterial.emit);
-		mul_v3_v3fl(specular, &defmaterial.specr, defmaterial.spec);
-		GPU_basic_shader_colors(diffuse, specular, 35, 1.0f);
-
-		if (GMS.two_sided_lighting)
-			GPU_basic_shader_bind(GPU_SHADER_LIGHTING | GPU_SHADER_TWO_SIDED);
-		else
-			GPU_basic_shader_bind(GPU_SHADER_LIGHTING);
-
-		return 0;
-	}
-
-	/* prevent index to use un-initialized array items */
-	if (nr >= GMS.totmat)
-		nr = 0;
-
-	if (gattribs)
-		memset(gattribs, 0, sizeof(*gattribs));
-
-	/* keep current material */
-	if (nr == GMS.lastmatnr)
-		return GMS.lastretval;
-
-	/* unbind glsl material */
-	if (GMS.gboundmat) {
-		if (GMS.is_alpha_pass) glDepthMask(0);
-		GPU_material_unbind(GPU_material_from_blender(GMS.gscene, GMS.gboundmat, GMS.is_opensubdiv));
-		GMS.gboundmat = NULL;
-	}
-
-	/* draw materials with alpha in alpha pass */
-	GMS.lastmatnr = nr;
-	GMS.lastretval = 1;
-
-	if (GMS.use_alpha_pass) {
-		GMS.lastretval = ELEM(GMS.alphablend[nr], GPU_BLEND_SOLID, GPU_BLEND_CLIP);
-		if (GMS.is_alpha_pass)
-			GMS.lastretval = !GMS.lastretval;
-	}
-	else
-		GMS.lastretval = !GMS.is_alpha_pass;
-
-	if (GMS.lastretval) {
-		/* for alpha pass, use alpha blend */
-		GPUBlendMode alphablend = GMS.alphablend[nr];
-
-		if (gattribs && GMS.gmatbuf[nr]) {
-			/* bind glsl material and get attributes */
-			Material *mat = GMS.gmatbuf[nr];
-			GPUParticleInfo partile_info;
-			float object_info[3] = {0};
-
-			float auto_bump_scale;
-
-			GPUMaterial *gpumat = GPU_material_from_blender(GMS.gscene, mat, GMS.is_opensubdiv);
-			GPU_material_vertex_attributes(gpumat, gattribs);
-
-			if (GMS.dob) {
-				gpu_get_particle_info(&partile_info);
-			}
-			
-			if ((GPU_get_material_builtins(gpumat) & GPU_OBJECT_INFO) != 0) {
-				GPU_get_object_info(object_info, mat);
-			}
-
-			GPU_material_bind(
-			        gpumat, GMS.gob->lay, GMS.glay, 1.0, !(GMS.gob->mode & OB_MODE_TEXTURE_PAINT),
-			        GMS.gviewmat, GMS.gviewinv, GMS.gviewcamtexcofac);
-
-			auto_bump_scale = GMS.gob->derivedFinal != NULL ? GMS.gob->derivedFinal->auto_bump_scale : 1.0f;
-			GPU_material_bind_uniforms(gpumat, GMS.gob->obmat, GMS.gviewmat, GMS.gob->col, auto_bump_scale, &partile_info, object_info);
-			GMS.gboundmat = mat;
-
-			if (GMS.is_alpha_pass) glDepthMask(1);
-
-			if (GMS.backface_culling) {
-				glDisable(GL_CULL_FACE);
-			}
-
-			if (GMS.use_matcaps)
-				glColor3f(1.0f, 1.0f, 1.0f);
-		}
-		else {
-			/* or do fixed function opengl material */
-			GPU_basic_shader_colors(
-			        GMS.matbuf[nr].diff,
-			        GMS.matbuf[nr].spec, GMS.matbuf[nr].hard, GMS.matbuf[nr].alpha);
-
-			if (GMS.two_sided_lighting)
-				GPU_basic_shader_bind(GPU_SHADER_LIGHTING | GPU_SHADER_TWO_SIDED);
-			else
-				GPU_basic_shader_bind(GPU_SHADER_LIGHTING);
-		}
-
-		/* set (alpha) blending mode */
-		GPU_set_material_alpha_blend(alphablend);
-	}
-
-	return GMS.lastretval;
-}
-
-int GPU_object_material_visible(int nr, void *attribs)
-{
-	GPUVertexAttribs *gattribs = attribs;
-	int visible;
-
-	if (!GMS.matbuf)
-		return 0;
-
-	if (gattribs)
-		memset(gattribs, 0, sizeof(*gattribs));
-
-	if (nr >= GMS.totmat)
-		nr = 0;
-
-	if (GMS.use_alpha_pass) {
-		visible = ELEM(GMS.alphablend[nr], GPU_BLEND_SOLID, GPU_BLEND_CLIP);
-		if (GMS.is_alpha_pass)
-			visible = !visible;
-	}
-	else
-		visible = !GMS.is_alpha_pass;
-
-	return visible;
-}
-
-void GPU_set_material_alpha_blend(int alphablend)
-{
-	if (GMS.lastalphablend == alphablend)
-		return;
-
-	gpu_set_alpha_blend(alphablend);
-	GMS.lastalphablend = alphablend;
-}
-
-int GPU_get_material_alpha_blend(void)
-{
-	return GMS.lastalphablend;
-}
-
-void GPU_object_material_unbind(void)
-{
-	GMS.lastmatnr = -1;
-	GMS.lastretval = 1;
-
-	if (GMS.gboundmat) {
-		if (GMS.backface_culling)
-			glDisable(GL_CULL_FACE);
-
-		if (GMS.is_alpha_pass) glDepthMask(0);
-		GPU_material_unbind(GPU_material_from_blender(GMS.gscene, GMS.gboundmat, GMS.is_opensubdiv));
-		GMS.gboundmat = NULL;
-	}
-	else
-		GPU_basic_shader_bind(GPU_SHADER_USE_COLOR);
-
-	GPU_set_material_alpha_blend(GPU_BLEND_SOLID);
-}
-
-void GPU_material_diffuse_get(int nr, float diff[4])
-{
-	/* prevent index to use un-initialized array items */
-	if (nr >= GMS.totmat)
-		nr = 0;
-
-	/* no GPU_begin_object_materials, use default material */
-	if (!GMS.matbuf) {
-		mul_v3_v3fl(diff, &defmaterial.r, defmaterial.ref + defmaterial.emit);
-	}
-	else {
-		copy_v3_v3(diff, GMS.matbuf[nr].diff);
-		diff[3] = GMS.matbuf[nr].alpha;
-	}
-}
-
-bool GPU_material_use_matcaps_get(void)
-{
-	return GMS.use_matcaps;
-}
-
-bool GPU_object_materials_check(void)
-{
-	return GMS.is_enabled;
-}
-
-void GPU_end_object_materials(void)
-{
-	GPU_object_material_unbind();
-
-	GMS.is_enabled = false;
-
-	if (GMS.matbuf && GMS.matbuf != GMS.matbuf_fixed) {
-		MEM_freeN(GMS.matbuf);
-		MEM_freeN(GMS.gmatbuf);
-		MEM_freeN(GMS.alphablend);
-	}
-
-	GMS.matbuf = NULL;
-	GMS.gmatbuf = NULL;
-	GMS.alphablend = NULL;
-	GMS.two_sided_lighting = false;
-}
-
-/* Lights */
-
-int GPU_default_lights(void)
-{
-	/* initialize */
-	if (U.light[0].flag == 0 && U.light[1].flag == 0 && U.light[2].flag == 0) {
-		U.light[0].flag = 1;
-		U.light[0].vec[0] = -0.3; U.light[0].vec[1] = 0.3; U.light[0].vec[2] = 0.9;
-		U.light[0].col[0] = 0.8; U.light[0].col[1] = 0.8; U.light[0].col[2] = 0.8;
-		U.light[0].spec[0] = 0.5; U.light[0].spec[1] = 0.5; U.light[0].spec[2] = 0.5;
-		U.light[0].spec[3] = 1.0;
-
-		U.light[1].flag = 0;
-		U.light[1].vec[0] = 0.5; U.light[1].vec[1] = 0.5; U.light[1].vec[2] = 0.1;
-		U.light[1].col[0] = 0.4; U.light[1].col[1] = 0.4; U.light[1].col[2] = 0.8;
-		U.light[1].spec[0] = 0.3; U.light[1].spec[1] = 0.3; U.light[1].spec[2] = 0.5;
-		U.light[1].spec[3] = 1.0;
-
-		U.light[2].flag = 0;
-		U.light[2].vec[0] = 0.3; U.light[2].vec[1] = -0.3; U.light[2].vec[2] = -0.2;
-		U.light[2].col[0] = 0.8; U.light[2].col[1] = 0.5; U.light[2].col[2] = 0.4;
-		U.light[2].spec[0] = 0.5; U.light[2].spec[1] = 0.4; U.light[2].spec[2] = 0.3;
-		U.light[2].spec[3] = 1.0;
-	}
-
-	GPU_basic_shader_light_set_viewer(false);
-
-	int count = 0;
-
-	for (int a = 0; a < 8; a++) {
-		if (a < 3 && U.light[a].flag) {
-			GPULightData light = {0};
-
-			light.type = GPU_LIGHT_SUN;
-
-			normalize_v3_v3(light.direction, U.light[a].vec);
-			copy_v3_v3(light.diffuse, U.light[a].col);
-			copy_v3_v3(light.specular, U.light[a].spec);
-
-			GPU_basic_shader_light_set(a, &light);
-
-			count++;
-		}
-		else
-			GPU_basic_shader_light_set(a, NULL);
-	}
-
-	return count;
-}
-
-int GPU_scene_object_lights(ViewLayer *view_layer, float viewmat[4][4], int ortho)
-{
-	/* disable all lights */
-	for (int count = 0; count < 8; count++)
-		GPU_basic_shader_light_set(count, NULL);
-
-	/* view direction for specular is not computed correct by default in
-	 * opengl, so we set the settings ourselves */
-	GPU_basic_shader_light_set_viewer(!ortho);
-
-	int count = 0;
-
-	for (Base *base = FIRSTBASE(view_layer); base; base = base->next) {
-		if (base->object->type != OB_LAMP)
-			continue;
-
-		Lamp *la = base->object->data;
-
-		/* setup lamp transform */
-		gpuPushMatrix();
-		gpuLoadMatrix(viewmat);
-
-		/* setup light */
-		GPULightData light = {0};
-
-		mul_v3_v3fl(light.diffuse, &la->r, la->energy);
-		mul_v3_v3fl(light.specular, &la->r, la->energy);
-
-		if (la->type == LA_SUN) {
-			/* directional sun light */
-			light.type = GPU_LIGHT_SUN;
-			normalize_v3_v3(light.direction, base->object->obmat[2]);
-		}
-		else {
-			/* other lamps with position attenuation */
-			copy_v3_v3(light.position, base->object->obmat[3]);
-
-			light.constant_attenuation = 1.0f;
-			light.linear_attenuation = la->att1 / la->dist;
-			light.quadratic_attenuation = la->att2 / (la->dist * la->dist);
-
-			if (la->type == LA_SPOT) {
-				light.type = GPU_LIGHT_SPOT;
-				negate_v3_v3(light.direction, base->object->obmat[2]);
-				normalize_v3(light.direction);
-				light.spot_cutoff = RAD2DEGF(la->spotsize * 0.5f);
-				light.spot_exponent = 128.0f * la->spotblend;
-			}
-			else
-				light.type = GPU_LIGHT_POINT;
-		}
-
-		GPU_basic_shader_light_set(count, &light);
-
-		gpuPopMatrix();
-
-		count++;
-		if (count == 8)
-			break;
-	}
-
-	return count;
-}
-
 static void gpu_disable_multisample(void)
 {
 #ifdef __linux__
@@ -1798,8 +1116,6 @@ static void gpu_disable_multisample(void)
 
 void GPU_state_init(void)
 {
-	GPU_default_lights();
-
 	GPU_disable_program_point_size();
 
 	glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
@@ -1830,34 +1146,6 @@ void GPU_disable_program_point_size(void)
 	glDisable(GL_PROGRAM_POINT_SIZE);
 }
 
-#ifdef WITH_OPENSUBDIV
-/* Update face-varying variables offset which might be
- * different from mesh to mesh sharing the same material.
- */
-void GPU_draw_update_fvar_offset(DerivedMesh *dm)
-{
-	/* Sanity check to be sure we only do this for OpenSubdiv draw. */
-	BLI_assert(dm->type == DM_TYPE_CCGDM);
-	BLI_assert(GMS.is_opensubdiv);
-
-	for (int i = 0; i < GMS.totmat; ++i) {
-		Material *material = GMS.gmatbuf[i];
-		GPUMaterial *gpu_material;
-
-		if (material == NULL) {
-			continue;
-		}
-
-		gpu_material = GPU_material_from_blender(GMS.gscene,
-		                                         material,
-		                                         GMS.is_opensubdiv);
-
-		GPU_material_update_fvar_offset(gpu_material, dm);
-	}
-}
-#endif
-
-
 /** \name Framebuffer color depth, for selection codes
  * \{ */
 
diff --git a/source/blender/gpu/intern/gpu_init_exit.c b/source/blender/gpu/intern/gpu_init_exit.c
index 7a6b1ff6c70..5015d7c2372 100644
--- a/source/blender/gpu/intern/gpu_init_exit.c
+++ b/source/blender/gpu/intern/gpu_init_exit.c
@@ -30,6 +30,7 @@
  */
 
 #include "BLI_sys_types.h"
+#include "GPU_buffers.h"
 #include "GPU_init_exit.h"  /* interface */
 #include "GPU_immediate.h"
 #include "GPU_batch.h"
@@ -63,6 +64,8 @@ void GPU_init(void)
 	gpu_batch_init();
 
 	immInit();
+
+	GPU_pbvh_fix_linking();
 }
 
 
diff --git a/source/blender/gpu/intern/gpu_lamp.c b/source/blender/gpu/intern/gpu_lamp.c
deleted file mode 100644
index f8ca11782a5..00000000000
--- a/source/blender/gpu/intern/gpu_lamp.c
+++ /dev/null
@@ -1,458 +0,0 @@
-/*
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * 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
- * of the License, or (at your option) any later version.
- *
- * 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,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2006 Blender Foundation.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): Brecht Van Lommel, Clément Foucault.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-
-/** \file blender/gpu/intern/gpu_lamp.c
- *  \ingroup gpu
- *
- * Manages Opengl lights.
- */
-
-#include "MEM_guardedalloc.h"
-
-#include "DNA_lamp_types.h"
-#include "DNA_object_types.h"
-#include "DNA_scene_types.h"
-
-#include "BLI_listbase.h"
-#include "BLI_math.h"
-#include "BLI_utildefines.h"
-
-#include "BKE_group.h"
-
-#include "GPU_framebuffer.h"
-#include "GPU_glew.h"
-#include "GPU_lamp.h"
-#include "GPU_material.h"
-#include "GPU_shader.h"
-#include "GPU_texture.h"
-#include "GPU_batch.h"
-
-#include "gpu_lamp_private.h"
-
-bool GPU_lamp_visible(GPULamp *lamp, Material *ma)
-{
-	if (lamp->hide)
-		return false;
-	else if (ma && ma->group)
-		return BKE_group_object_exists(ma->group, lamp->ob);
-	else
-		return true;
-}
-
-static void gpu_lamp_calc_winmat(GPULamp *lamp)
-{
-	float temp, angle, pixsize, wsize;
-
-	if (lamp->type == LA_SUN) {
-		wsize = lamp->la->shadow_frustum_size;
-		orthographic_m4(lamp->winmat, -wsize, wsize, -wsize, wsize, lamp->d, lamp->clipend);
-	}
-	else if (lamp->type == LA_SPOT) {
-		angle = saacos(lamp->spotsi);
-		temp = 0.5f * lamp->size * cosf(angle) / sinf(angle);
-		pixsize = lamp->d / temp;
-		wsize = pixsize * 0.5f * lamp->size;
-		/* compute shadows according to X and Y scaling factors */
-		perspective_m4(
-		        lamp->winmat,
-		        -wsize * lamp->spotvec[0], wsize * lamp->spotvec[0],
-		        -wsize * lamp->spotvec[1], wsize * lamp->spotvec[1],
-		        lamp->d, lamp->clipend);
-	}
-}
-
-void GPU_lamp_update(GPULamp *lamp, int lay, int hide, float obmat[4][4])
-{
-	float mat[4][4];
-	float obmat_scale[3];
-
-	lamp->lay = lay;
-	lamp->hide = hide;
-
-	normalize_m4_m4_ex(mat, obmat, obmat_scale);
-
-	copy_v3_v3(lamp->vec, mat[2]);
-	copy_v3_v3(lamp->co, mat[3]);
-	copy_m4_m4(lamp->obmat, mat);
-	invert_m4_m4(lamp->imat, mat);
-
-	if (lamp->type == LA_SPOT) {
-		/* update spotlamp scale on X and Y axis */
-		lamp->spotvec[0] = obmat_scale[0] / obmat_scale[2];
-		lamp->spotvec[1] = obmat_scale[1] / obmat_scale[2];
-	}
-
-	if (GPU_lamp_has_shadow_buffer(lamp)) {
-		/* makeshadowbuf */
-		gpu_lamp_calc_winmat(lamp);
-	}
-}
-
-void GPU_lamp_update_colors(GPULamp *lamp, float r, float g, float b, float energy)
-{
-	lamp->energy = energy;
-	if (lamp->mode & LA_NEG) lamp->energy = -lamp->energy;
-
-	lamp->col[0] = r;
-	lamp->col[1] = g;
-	lamp->col[2] = b;
-}
-
-void GPU_lamp_update_distance(GPULamp *lamp, float distance, float att1, float att2,
-                              float coeff_const, float coeff_lin, float coeff_quad)
-{
-	lamp->dist = distance;
-	lamp->att1 = att1;
-	lamp->att2 = att2;
-	lamp->coeff_const = coeff_const;
-	lamp->coeff_lin = coeff_lin;
-	lamp->coeff_quad = coeff_quad;
-}
-
-void GPU_lamp_update_spot(GPULamp *lamp, float spotsize, float spotblend)
-{
-	lamp->spotsi = cosf(spotsize * 0.5f);
-	lamp->spotbl = (1.0f - lamp->spotsi) * spotblend;
-}
-
-static void gpu_lamp_from_blender(Scene *scene, Object *ob, Object *par, Lamp *la, GPULamp *lamp)
-{
-	lamp->scene = scene;
-	lamp->ob = ob;
-	lamp->par = par;
-	lamp->la = la;
-
-	/* add_render_lamp */
-	lamp->mode = la->mode;
-	lamp->type = la->type;
-
-	lamp->energy = la->energy;
-	if (lamp->mode & LA_NEG) lamp->energy = -lamp->energy;
-
-	lamp->col[0] = la->r;
-	lamp->col[1] = la->g;
-	lamp->col[2] = la->b;
-
-	GPU_lamp_update(lamp, ob->lay, (ob->restrictflag & OB_RESTRICT_RENDER), ob->obmat);
-
-	lamp->spotsi = la->spotsize;
-	if (lamp->mode & LA_HALO)
-		if (lamp->spotsi > DEG2RADF(170.0f))
-			lamp->spotsi = DEG2RADF(170.0f);
-	lamp->spotsi = cosf(lamp->spotsi * 0.5f);
-	lamp->spotbl = (1.0f - lamp->spotsi) * la->spotblend;
-	lamp->k = la->k;
-
-	lamp->dist = la->dist;
-	lamp->falloff_type = la->falloff_type;
-	lamp->att1 = la->att1;
-	lamp->att2 = la->att2;
-	lamp->coeff_const = la->coeff_const;
-	lamp->coeff_lin = la->coeff_lin;
-	lamp->coeff_quad = la->coeff_quad;
-	lamp->curfalloff = la->curfalloff;
-
-	/* initshadowbuf */
-	lamp->bias = 0.02f * la->bias;
-	lamp->size = la->bufsize;
-	lamp->d = la->clipsta;
-	lamp->clipend = la->clipend;
-
-	/* arbitrary correction for the fact we do no soft transition */
-	lamp->bias *= 0.25f;
-}
-
-static void gpu_lamp_shadow_free(GPULamp *lamp)
-{
-	if (lamp->tex) {
-		GPU_texture_free(lamp->tex);
-		lamp->tex = NULL;
-	}
-	if (lamp->depthtex) {
-		GPU_texture_free(lamp->depthtex);
-		lamp->depthtex = NULL;
-	}
-	if (lamp->fb) {
-		GPU_framebuffer_free(lamp->fb);
-		lamp->fb = NULL;
-	}
-	if (lamp->blurtex) {
-		GPU_texture_free(lamp->blurtex);
-		lamp->blurtex = NULL;
-	}
-	if (lamp->blurfb) {
-		GPU_framebuffer_free(lamp->blurfb);
-		lamp->blurfb = NULL;
-	}
-}
-
-static GPUTexture *gpu_lamp_create_vsm_shadow_map(int size)
-{
-	return GPU_texture_create_2D_custom(size, size, 2, GPU_RG32F, NULL, NULL);
-}
-
-LampEngineData *GPU_lamp_engine_data_get(Scene *scene, Object *ob, Object *par, struct RenderEngineType *re)
-{
-	GPULamp *lamp;
-	LinkData *link;
-
-	for (link = ob->gpulamp.first; link; link = link->next) {
-		lamp = (GPULamp *)link->data;
-
-		if ((lamp->par == par) && (lamp->scene == scene) && (lamp->re == re))
-			return &lamp->data;
-	}
-
-	lamp = MEM_callocN(sizeof(GPULamp), "GPULamp");
-
-	link = MEM_callocN(sizeof(LinkData), "GPULampLink");
-	link->data = lamp;
-	BLI_addtail(&ob->gpulamp, link);
-
-	lamp->scene = scene;
-	lamp->ob = ob;
-	lamp->par = par;
-	lamp->la = ob->data;
-	lamp->re = re;
-
-	return &lamp->data;
-}
-
-GPULamp *GPU_lamp_from_blender(Scene *scene, Object *ob, Object *par)
-{
-	Lamp *la;
-	GPULamp *lamp;
-	LinkData *link;
-
-	for (link = ob->gpulamp.first; link; link = link->next) {
-		lamp = (GPULamp *)link->data;
-
-		if (lamp->par == par && lamp->scene == scene)
-			return link->data;
-	}
-
-	lamp = MEM_callocN(sizeof(GPULamp), "GPULamp");
-
-	link = MEM_callocN(sizeof(LinkData), "GPULampLink");
-	link->data = lamp;
-	BLI_addtail(&ob->gpulamp, link);
-
-	la = ob->data;
-	gpu_lamp_from_blender(scene, ob, par, la, lamp);
-
-	if ((la->type == LA_SPOT && (la->mode & (LA_SHAD_BUF | LA_SHAD_RAY))) ||
-	    (la->type == LA_SUN && (la->mode & LA_SHAD_RAY)))
-	{
-		if (lamp->la->shadowmap_type == LA_SHADMAP_VARIANCE) {
-			lamp->depthtex = GPU_texture_create_depth(lamp->size, lamp->size, NULL);
-			lamp->tex = gpu_lamp_create_vsm_shadow_map(lamp->size);
-			lamp->blurtex = gpu_lamp_create_vsm_shadow_map(lamp->size * 0.5);
-
-			lamp->fb = GPU_framebuffer_create();
-			GPU_framebuffer_texture_attach(lamp->fb, lamp->depthtex, 0, 0);
-			GPU_framebuffer_texture_attach(lamp->fb, lamp->tex, 0, 0);
-
-			lamp->blurfb = GPU_framebuffer_create();
-			GPU_framebuffer_texture_attach(lamp->blurfb, lamp->blurtex, 0, 0);
-
-			if (!GPU_framebuffer_check_valid(lamp->fb, NULL) ||
-			    !GPU_framebuffer_check_valid(lamp->blurfb, NULL))
-			{
-				gpu_lamp_shadow_free(lamp);
-				return lamp;
-			}
-		}
-		else {
-			lamp->tex = GPU_texture_create_depth(lamp->size, lamp->size, NULL);
-
-			GPU_texture_bind(lamp->tex, 0);
-			GPU_texture_compare_mode(lamp->tex, true);
-			GPU_texture_filter_mode(lamp->tex, true);
-			GPU_texture_unbind(lamp->tex);
-
-			lamp->fb = GPU_framebuffer_create();
-			GPU_framebuffer_texture_attach(lamp->fb, lamp->tex, 0, 0);
-
-			if (!GPU_framebuffer_check_valid(lamp->fb, NULL)) {
-				gpu_lamp_shadow_free(lamp);
-				return lamp;
-			}
-		}
-
-		GPU_framebuffer_restore();
-
-		lamp->shadow_color[0] = la->shdwr;
-		lamp->shadow_color[1] = la->shdwg;
-		lamp->shadow_color[2] = la->shdwb;
-	}
-	else {
-		lamp->shadow_color[0] = 1.0;
-		lamp->shadow_color[1] = 1.0;
-		lamp->shadow_color[2] = 1.0;
-	}
-
-	return lamp;
-}
-
-void GPU_lamp_engine_data_free(LampEngineData *led)
-{
-	for (int i = 0; i < MAX_LAMP_DATA; ++i) {
-		if (led->storage[i]) {
-			MEM_freeN(led->storage[i]);
-			led->storage[i] = NULL;
-		}
-	}
-}
-
-void GPU_lamp_free(Object *ob)
-{
-	GPULamp *lamp;
-	LinkData *link;
-
-	for (link = ob->gpulamp.first; link; link = link->next) {
-		lamp = link->data;
-
-		gpu_lamp_shadow_free(lamp);
-		GPU_lamp_engine_data_free(&lamp->data);
-
-		MEM_freeN(lamp);
-	}
-
-	BLI_freelistN(&ob->gpulamp);
-}
-
-bool GPU_lamp_has_shadow_buffer(GPULamp *UNUSED(lamp))
-{
-	return false;
-}
-
-void GPU_lamp_update_buffer_mats(GPULamp *lamp)
-{
-	float rangemat[4][4], persmat[4][4];
-
-	/* initshadowbuf */
-	invert_m4_m4(lamp->viewmat, lamp->obmat);
-	normalize_v3(lamp->viewmat[0]);
-	normalize_v3(lamp->viewmat[1]);
-	normalize_v3(lamp->viewmat[2]);
-
-	/* makeshadowbuf */
-	mul_m4_m4m4(persmat, lamp->winmat, lamp->viewmat);
-
-	/* opengl depth buffer is range 0.0..1.0 instead of -1.0..1.0 in blender */
-	unit_m4(rangemat);
-	rangemat[0][0] = 0.5f;
-	rangemat[1][1] = 0.5f;
-	rangemat[2][2] = 0.5f;
-	rangemat[3][0] = 0.5f;
-	rangemat[3][1] = 0.5f;
-	rangemat[3][2] = 0.5f;
-
-	mul_m4_m4m4(lamp->persmat, rangemat, persmat);
-}
-
-void GPU_lamp_shadow_buffer_bind(GPULamp *lamp, float viewmat[4][4], int *winsize, float winmat[4][4])
-{
-	GPU_lamp_update_buffer_mats(lamp);
-
-	/* opengl */
-	glDisable(GL_SCISSOR_TEST);
-	GPU_framebuffer_bind(lamp->fb);
-	if (lamp->la->shadowmap_type == LA_SHADMAP_VARIANCE)
-		GPU_shader_bind(GPU_shader_get_builtin_shader(GPU_SHADER_VSM_STORE));
-
-	/* set matrices */
-	copy_m4_m4(viewmat, lamp->viewmat);
-	copy_m4_m4(winmat, lamp->winmat);
-	*winsize = lamp->size;
-}
-
-static void gpu_lamp_shadow_blur(GPULamp *lamp)
-{
-	const float scaleh[2] = {1.0f / GPU_texture_width(lamp->blurtex), 0.0f};
-	const float scalev[2] = {0.0f, 1.0f / GPU_texture_height(lamp->tex)};
-
-	GPUShader *blur_shader = GPU_shader_get_builtin_shader(GPU_SHADER_SEP_GAUSSIAN_BLUR);
-
-	if (!blur_shader)
-		return;
-
-	int tex_loc = GPU_shader_get_uniform(blur_shader, "textureSource");
-	int scale_loc = GPU_shader_get_uniform(blur_shader, "ScaleU");
-
-	glDisable(GL_DEPTH_TEST);
-
-	GPU_shader_bind(blur_shader);
-
-	/* Blurring horizontally */
-	GPU_framebuffer_bind(lamp->blurfb);
-	GPU_texture_bind(lamp->tex, 0);
-	GPU_shader_uniform_vector(blur_shader, scale_loc, 2, 1, scaleh);
-	GPU_shader_uniform_texture(blur_shader, tex_loc, lamp->tex);
-	GWN_draw_primitive(GL_TRIANGLES, 3);
-
-	/* Blurring vertically */
-	GPU_framebuffer_bind(lamp->fb);
-	GPU_texture_bind(lamp->blurtex, 0);
-	GPU_shader_uniform_vector(blur_shader, scale_loc, 2, 1, scalev);
-	GPU_shader_uniform_texture(blur_shader, tex_loc, lamp->blurtex);
-	GWN_draw_primitive(GL_TRIANGLES, 3);
-}
-
-void GPU_lamp_shadow_buffer_unbind(GPULamp *lamp)
-{
-	if (lamp->la->shadowmap_type == LA_SHADMAP_VARIANCE) {
-		GPU_shader_unbind();
-		gpu_lamp_shadow_blur(lamp);
-	}
-
-	GPU_framebuffer_restore();
-	glEnable(GL_SCISSOR_TEST);
-}
-
-int GPU_lamp_shadow_buffer_type(GPULamp *lamp)
-{
-	return lamp->la->shadowmap_type;
-}
-
-int GPU_lamp_shadow_bind_code(GPULamp *lamp)
-{
-	return lamp->tex ? GPU_texture_opengl_bindcode(lamp->tex) : -1;
-}
-
-float *GPU_lamp_dynpersmat(GPULamp *lamp)
-{
-	return &lamp->dynpersmat[0][0];
-}
-
-int GPU_lamp_shadow_layer(GPULamp *lamp)
-{
-	if (lamp->fb && lamp->tex && (lamp->mode & (LA_LAYER | LA_LAYER_SHADOW)))
-		return lamp->lay;
-	else
-		return -1;
-}
diff --git a/source/blender/gpu/intern/gpu_lamp_private.h b/source/blender/gpu/intern/gpu_lamp_private.h
deleted file mode 100644
index f227ce74e7e..00000000000
--- a/source/blender/gpu/intern/gpu_lamp_private.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * ***** BEGIN GPL LICENSE BLOCK *****
- *
- * 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
- * of the License, or (at your option) any later version.
- *
- * 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,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * The Original Code is Copyright (C) 2005 Blender Foundation.
- * All rights reserved.
- *
- * The Original Code is: all of this file.
- *
- * Contributor(s): Brecht Van Lommel, Clément Foucault.
- *
- * ***** END GPL LICENSE BLOCK *****
- */
-
-/** \file gpu_lamp_private.h
- *  \ingroup gpu
- */
-
-#ifndef __GPU_LAMP_PRIVATE_H__
-#define __GPU_LAMP_PRIVATE_H__
-
-#include "BLI_sys_types.h" /* for bool */
-
-struct GPULamp {
-	Scene *scene;
-	Object *ob;
-	Object *par;
-	Lamp *la;
-	struct RenderEngineType *re;
-
-	/* Old Viewport (pre-2.8) */
-	int type, mode, lay, hide;
-
-	float dynenergy, dyncol[3];
-	float energy, col[3];
-
-	float co[3], vec[3];
-	float dynco[3], dynvec[3];
-	float obmat[4][4];
-	float imat[4][4];
-	float dynimat[4][4];
-
-	float spotsi, spotbl, k;
-	float spotvec[2];
-	float dyndist, dynatt1, dynatt2;
-	float dist, att1, att2;
-	float coeff_const, coeff_lin, coeff_quad;
-	float shadow_color[3];
-
-	float bias, d, clipend;
-	int size;
-
-	int falloff_type;
-	struct CurveMapping *curfalloff;
-
-	float winmat[4][4];
-	float viewmat[4][4];
-	float persmat[4][4];
-	float dynpersmat[4][4];
-
-	GPUFrameBuffer *fb;
-	GPUFrameBuffer *blurfb;
-	GPUTexture *tex;
-	GPUTexture *depthtex;
-	GPUTexture *blurtex;
-
-	/* New viewport */
-	struct LampEngineData data;
-};
-
-#endif  /* __GPU_LAMP_PRIVATE_H__ */
diff --git a/source/blender/gpu/intern/gpu_material.c b/source/blender/gpu/intern/gpu_material.c
index eddd2b85829..d5f4f3269ed 100644
--- a/source/blender/gpu/intern/gpu_material.c
+++ b/source/blender/gpu/intern/gpu_material.c
@@ -62,7 +62,6 @@
 
 #include "GPU_extensions.h"
 #include "GPU_framebuffer.h"
-#include "GPU_lamp.h"
 #include "GPU_material.h"
 #include "GPU_shader.h"
 #include "GPU_texture.h"
@@ -71,7 +70,6 @@
 #include "DRW_engine.h"
 
 #include "gpu_codegen.h"
-#include "gpu_lamp_private.h"
 
 #ifdef WITH_OPENSUBDIV
 #  include "BKE_DerivedMesh.h"
@@ -79,25 +77,6 @@
 
 /* Structs */
 
-typedef enum DynMatProperty {
-	DYN_LAMP_CO = 1,
-	DYN_LAMP_VEC = 2,
-	DYN_LAMP_IMAT = 4,
-	DYN_LAMP_PERSMAT = 8,
-} DynMatProperty;
-
-static struct GPUWorld {
-	float mistenabled;
-	float mistype;
-	float miststart;
-	float mistdistance;
-	float mistintensity;
-	float mistcol[4];
-	float horicol[3];
-	float ambcol[4];
-	float zencol[3];
-} GPUWorld;
-
 struct GPUMaterial {
 	Scene *scene; /* DEPRECATED was only usefull for lamps */
 	Material *ma;
@@ -136,9 +115,6 @@ struct GPUMaterial {
 
 	int objectinfoloc;
 
-	ListBase lamps;
-	bool bound;
-
 	bool is_opensubdiv;
 
 	/* XXX: Should be in Material. But it depends on the output node
@@ -165,115 +141,8 @@ enum {
 	GPU_DOMAIN_SSS        = (1 << 2)
 };
 
-/* Forward declaration so shade_light_textures() can use this, while still keeping the code somewhat organized */
-static void texture_rgb_blend(
-        GPUMaterial *mat, GPUNodeLink *tex, GPUNodeLink *out, GPUNodeLink *fact, GPUNodeLink *facg,
-        int blendtype, GPUNodeLink **in);
-
 /* Functions */
 
-static GPUMaterial *GPU_material_construct_begin(Material *ma)
-{
-	GPUMaterial *material = MEM_callocN(sizeof(GPUMaterial), "GPUMaterial");
-
-	material->ma = ma;
-
-	return material;
-}
-
-static void gpu_material_set_attrib_id(GPUMaterial *material)
-{
-	GPUVertexAttribs *attribs = &material->attribs;
-	GPUPass *pass = material->pass;
-	if (!pass) {
-		attribs->totlayer = 0;
-		return;
-	}
-	
-	GPUShader *shader = GPU_pass_shader(pass);
-	if (!shader) {
-		attribs->totlayer = 0;
-		return;
-	}
-
-	/* convert from attribute number to the actual id assigned by opengl,
-	 * in case the attrib does not get a valid index back, it was probably
-	 * removed by the glsl compiler by dead code elimination */
-
-	int b = 0;
-	for (int a = 0; a < attribs->totlayer; a++) {
-		char name[32];
-		BLI_snprintf(name, sizeof(name), "att%d", attribs->layer[a].attribid);
-		attribs->layer[a].glindex = GPU_shader_get_attribute(shader, name);
-
-		BLI_snprintf(name, sizeof(name), "att%d_info", attribs->layer[a].attribid);
-		attribs->layer[a].glinfoindoex = GPU_shader_get_uniform(shader, name);
-
-		if (attribs->layer[a].glindex >= 0) {
-			attribs->layer[b] = attribs->layer[a];
-			b++;
-		}
-	}
-
-	attribs->totlayer = b;
-}
-
-static int gpu_material_construct_end(GPUMaterial *material, const char *passname)
-{
-	if (material->outlink) {
-		GPUNodeLink *outlink = material->outlink;
-		material->pass = GPU_generate_pass(&material->nodes, &material->inputs, outlink,
-			&material->attribs, &material->builtins, material->type,
-			passname,
-			material->is_opensubdiv,
-			GPU_material_use_new_shading_nodes(material));
-
-		material->status = (material->pass) ? GPU_MAT_SUCCESS : GPU_MAT_FAILED;
-
-		if (!material->pass)
-			return 0;
-
-		gpu_material_set_attrib_id(material);
-		
-		GPUShader *shader = GPU_pass_shader(material->pass);
-
-		if (material->builtins & GPU_VIEW_MATRIX)
-			material->viewmatloc = GPU_shader_get_uniform(shader, GPU_builtin_name(GPU_VIEW_MATRIX));
-		if (material->builtins & GPU_INVERSE_VIEW_MATRIX)
-			material->invviewmatloc = GPU_shader_get_uniform(shader, GPU_builtin_name(GPU_INVERSE_VIEW_MATRIX));
-		if (material->builtins & GPU_OBJECT_MATRIX)
-			material->obmatloc = GPU_shader_get_uniform(shader, GPU_builtin_name(GPU_OBJECT_MATRIX));
-		if (material->builtins & GPU_INVERSE_OBJECT_MATRIX)
-			material->invobmatloc = GPU_shader_get_uniform(shader, GPU_builtin_name(GPU_INVERSE_OBJECT_MATRIX));
-		if (material->builtins & GPU_LOC_TO_VIEW_MATRIX)
-			material->localtoviewmatloc = GPU_shader_get_uniform(shader, GPU_builtin_name(GPU_LOC_TO_VIEW_MATRIX));
-		if (material->builtins & GPU_INVERSE_LOC_TO_VIEW_MATRIX)
-			material->invlocaltoviewmatloc = GPU_shader_get_uniform(shader, GPU_builtin_name(GPU_INVERSE_LOC_TO_VIEW_MATRIX));
-		if (material->builtins & GPU_OBCOLOR)
-			material->obcolloc = GPU_shader_get_uniform(shader, GPU_builtin_name(GPU_OBCOLOR));
-		if (material->builtins & GPU_AUTO_BUMPSCALE)
-			material->obautobumpscaleloc = GPU_shader_get_uniform(shader, GPU_builtin_name(GPU_AUTO_BUMPSCALE));
-		if (material->builtins & GPU_CAMERA_TEXCO_FACTORS)
-			material->cameratexcofacloc = GPU_shader_get_uniform(shader, GPU_builtin_name(GPU_CAMERA_TEXCO_FACTORS));
-		if (material->builtins & GPU_PARTICLE_SCALAR_PROPS)
-			material->partscalarpropsloc = GPU_shader_get_uniform(shader, GPU_builtin_name(GPU_PARTICLE_SCALAR_PROPS));
-		if (material->builtins & GPU_PARTICLE_LOCATION)
-			material->partcoloc = GPU_shader_get_uniform(shader, GPU_builtin_name(GPU_PARTICLE_LOCATION));
-		if (material->builtins & GPU_PARTICLE_VELOCITY)
-			material->partvel = GPU_shader_get_uniform(shader, GPU_builtin_name(GPU_PARTICLE_VELOCITY));
-		if (material->builtins & GPU_PARTICLE_ANG_VELOCITY)
-			material->partangvel = GPU_shader_get_uniform(shader, GPU_builtin_name(GPU_PARTICLE_ANG_VELOCITY));
-		if (material->builtins & GPU_OBJECT_INFO)
-			material->objectinfoloc = GPU_shader_get_uniform(shader, GPU_builtin_name(GPU_OBJECT_INFO));
-		return 1;
-	}
-	else {
-		GPU_pass_free_nodes(&material->nodes);
-	}
-
-	return 0;
-}
-
 void GPU_material_free(ListBase *gpumaterial)
 {
 	for (LinkData *link = gpumaterial->first; link; link = link->next) {
@@ -300,166 +169,17 @@ void GPU_material_free(ListBase *gpumaterial)
 			GPU_uniformbuffer_free(material->sss_profile);
 		}
 
-		BLI_freelistN(&material->lamps);
-
 		MEM_freeN(material);
 	}
 
 	BLI_freelistN(gpumaterial);
 }
 
-void GPU_material_bind(
-        GPUMaterial *material, int oblay, int viewlay, double time, int mipmap,
-        float viewmat[4][4], float viewinv[4][4], float camerafactors[4])
-{
-	if (material->pass) {
-		GPUShader *shader = GPU_pass_shader(material->pass);
-
-		/* handle layer lamps */
-		if (material->type == GPU_MATERIAL_TYPE_MESH) {
-			for (LinkData *nlink = material->lamps.first; nlink; nlink = nlink->next) {
-				GPULamp *lamp = nlink->data;
-				
-				if ((lamp->lay & viewlay) && (!(lamp->mode & LA_LAYER) || (lamp->lay & oblay)) &&
-				    GPU_lamp_visible(lamp, material->ma))
-				{
-					lamp->dynenergy = lamp->energy;
-					copy_v3_v3(lamp->dyncol, lamp->col);
-				}
-				else {
-					lamp->dynenergy = 0.0f;
-					lamp->dyncol[0] = lamp->dyncol[1] = lamp->dyncol[2] = 0.0f;
-				}
-				
-				if (material->dynproperty & DYN_LAMP_VEC) {
-					copy_v3_v3(lamp->dynvec, lamp->vec);
-					normalize_v3(lamp->dynvec);
-					negate_v3(lamp->dynvec);
-					mul_mat3_m4_v3(viewmat, lamp->dynvec);
-				}
-				
-				if (material->dynproperty & DYN_LAMP_CO) {
-					copy_v3_v3(lamp->dynco, lamp->co);
-					mul_m4_v3(viewmat, lamp->dynco);
-				}
-				
-				if (material->dynproperty & DYN_LAMP_IMAT) {
-					mul_m4_m4m4(lamp->dynimat, lamp->imat, viewinv);
-				}
-				
-				if (material->dynproperty & DYN_LAMP_PERSMAT) {
-					/* The lamp matrices are already updated if we're using shadow buffers */
-					if (!GPU_lamp_has_shadow_buffer(lamp)) {
-						GPU_lamp_update_buffer_mats(lamp);
-					}
-					mul_m4_m4m4(lamp->dynpersmat, lamp->persmat, viewinv);
-				}
-			}
-		}
-		
-		/* note material must be bound before setting uniforms */
-		GPU_pass_bind(material->pass, &material->inputs, time, mipmap);
-
-		/* handle per material built-ins */
-		if (material->builtins & GPU_VIEW_MATRIX) {
-			GPU_shader_uniform_vector(shader, material->viewmatloc, 16, 1, (float *)viewmat);
-		}
-		if (material->builtins & GPU_INVERSE_VIEW_MATRIX) {
-			GPU_shader_uniform_vector(shader, material->invviewmatloc, 16, 1, (float *)viewinv);
-		}
-		if (material->builtins & GPU_CAMERA_TEXCO_FACTORS) {
-			if (camerafactors) {
-				GPU_shader_uniform_vector(shader, material->cameratexcofacloc, 4, 1, (float *)camerafactors);
-			}
-			else {
-				/* use default, no scaling no offset */
-				float borders[4] = {1.0f, 1.0f, 0.0f, 0.0f};
-				GPU_shader_uniform_vector(shader, material->cameratexcofacloc, 4, 1, (float *)borders);
-			}
-		}
-
-		GPU_pass_update_uniforms(material->pass, &material->inputs);
-
-		material->bound = 1;
-	}
-}
-
 GPUBuiltin GPU_get_material_builtins(GPUMaterial *material)
 {
 	return material->builtins;
 }
 
-void GPU_material_bind_uniforms(
-        GPUMaterial *material, float obmat[4][4], float viewmat[4][4], float obcol[4],
-        float autobumpscale, GPUParticleInfo *pi, float object_info[3])
-{
-	if (material->pass) {
-		GPUShader *shader = GPU_pass_shader(material->pass);
-		float invmat[4][4], col[4];
-		float localtoviewmat[4][4];
-		float invlocaltoviewmat[4][4];
-
-		/* handle per object builtins */
-		if (material->builtins & GPU_OBJECT_MATRIX) {
-			GPU_shader_uniform_vector(shader, material->obmatloc, 16, 1, (float *)obmat);
-		}
-		if (material->builtins & GPU_INVERSE_OBJECT_MATRIX) {
-			invert_m4_m4(invmat, obmat);
-			GPU_shader_uniform_vector(shader, material->invobmatloc, 16, 1, (float *)invmat);
-		}
-		if (material->builtins & GPU_LOC_TO_VIEW_MATRIX) {
-			if (viewmat) {
-				mul_m4_m4m4(localtoviewmat, viewmat, obmat);
-				GPU_shader_uniform_vector(shader, material->localtoviewmatloc, 16, 1, (float *)localtoviewmat);
-			}
-		}
-		if (material->builtins & GPU_INVERSE_LOC_TO_VIEW_MATRIX) {
-			if (viewmat) {
-				mul_m4_m4m4(localtoviewmat, viewmat, obmat);
-				invert_m4_m4(invlocaltoviewmat, localtoviewmat);
-				GPU_shader_uniform_vector(shader, material->invlocaltoviewmatloc, 16, 1, (float *)invlocaltoviewmat);
-			}
-		}
-		if (material->builtins & GPU_OBCOLOR) {
-			copy_v4_v4(col, obcol);
-			CLAMP(col[3], 0.0f, 1.0f);
-			GPU_shader_uniform_vector(shader, material->obcolloc, 4, 1, col);
-		}
-		if (material->builtins & GPU_AUTO_BUMPSCALE) {
-			GPU_shader_uniform_vector(shader, material->obautobumpscaleloc, 1, 1, &autobumpscale);
-		}
-		if (material->builtins & GPU_PARTICLE_SCALAR_PROPS) {
-			GPU_shader_uniform_vector(shader, material->partscalarpropsloc, 4, 1, pi->scalprops);
-		}
-		if (material->builtins & GPU_PARTICLE_LOCATION) {
-			GPU_shader_uniform_vector(shader, material->partcoloc, 4, 1, pi->location);
-		}
-		if (material->builtins & GPU_PARTICLE_VELOCITY) {
-			GPU_shader_uniform_vector(shader, material->partvel, 3, 1, pi->velocity);
-		}
-		if (material->builtins & GPU_PARTICLE_ANG_VELOCITY) {
-			GPU_shader_uniform_vector(shader, material->partangvel, 3, 1, pi->angular_velocity);
-		}
-		if (material->builtins & GPU_OBJECT_INFO) {
-			GPU_shader_uniform_vector(shader, material->objectinfoloc, 3, 1, object_info);
-		}
-
-	}
-}
-
-void GPU_material_unbind(GPUMaterial *material)
-{
-	if (material->pass) {
-		material->bound = 0;
-		GPU_pass_unbind(material->pass, &material->inputs);
-	}
-}
-
-bool GPU_material_bound(GPUMaterial *material)
-{
-	return material->bound;
-}
-
 Scene *GPU_material_scene(GPUMaterial *material)
 {
 	return material->scene;
@@ -831,19 +551,6 @@ void GPU_material_output_link(GPUMaterial *material, GPUNodeLink *link)
 		material->outlink = link;
 }
 
-void GPU_material_enable_alpha(GPUMaterial *material)
-{
-	material->alpha = 1;
-}
-
-GPUBlendMode GPU_material_alpha_blend(GPUMaterial *material, float obcol[4])
-{
-	if (material->alpha || (material->obcolalpha && obcol[3] < 1.0f))
-		return GPU_BLEND_ALPHA;
-	else
-		return GPU_BLEND_SOLID;
-}
-
 void gpu_material_add_node(GPUMaterial *material, GPUNode *node)
 {
 	BLI_addtail(&material->nodes, node);
@@ -865,16 +572,6 @@ bool GPU_material_do_color_management(GPUMaterial *mat)
 	return true;
 }
 
-bool GPU_material_use_new_shading_nodes(GPUMaterial *mat)
-{
-	return BKE_scene_use_new_shading_nodes(mat->scene);
-}
-
-bool GPU_material_use_world_space_shading(GPUMaterial *mat)
-{
-	return BKE_scene_use_world_space_shading(mat->scene);
-}
-
 bool GPU_material_use_domain_surface(GPUMaterial *mat)
 {
 	return (mat->domain & GPU_DOMAIN_SURFACE);
@@ -885,1607 +582,6 @@ bool GPU_material_use_domain_volume(GPUMaterial *mat)
 	return (mat->domain & GPU_DOMAIN_VOLUME);
 }
 
-static GPUNodeLink *lamp_get_visibility(GPUMaterial *mat, GPULamp *lamp, GPUNodeLink **lv, GPUNodeLink **dist)
-{
-	GPUNodeLink *visifac;
-
-	/* from get_lamp_visibility */
-	if (lamp->type == LA_SUN || lamp->type == LA_HEMI) {
-		mat->dynproperty |= DYN_LAMP_VEC;
-		GPU_link(mat, "lamp_visibility_sun_hemi",
-		         GPU_dynamic_uniform(lamp->dynvec, GPU_DYNAMIC_LAMP_DYNVEC, lamp->ob), lv, dist, &visifac);
-		return visifac;
-	}
-	else {
-		mat->dynproperty |= DYN_LAMP_CO;
-		GPU_link(mat, "lamp_visibility_other",
-		         GPU_builtin(GPU_VIEW_POSITION),
-		         GPU_dynamic_uniform(lamp->dynco, GPU_DYNAMIC_LAMP_DYNCO, lamp->ob), lv, dist, &visifac);
-
-		if (lamp->type == LA_AREA)
-			return visifac;
-
-		switch (lamp->falloff_type) {
-			case LA_FALLOFF_CONSTANT:
-				break;
-			case LA_FALLOFF_INVLINEAR:
-				GPU_link(mat, "lamp_falloff_invlinear",
-				         GPU_dynamic_uniform(&lamp->dist, GPU_DYNAMIC_LAMP_DISTANCE, lamp->ob), *dist, &visifac);
-				break;
-			case LA_FALLOFF_INVSQUARE:
-				GPU_link(mat, "lamp_falloff_invsquare",
-				         GPU_dynamic_uniform(&lamp->dist, GPU_DYNAMIC_LAMP_DISTANCE, lamp->ob), *dist, &visifac);
-				break;
-			case LA_FALLOFF_SLIDERS:
-				GPU_link(mat, "lamp_falloff_sliders",
-				         GPU_dynamic_uniform(&lamp->dist, GPU_DYNAMIC_LAMP_DISTANCE, lamp->ob),
-				         GPU_dynamic_uniform(&lamp->att1, GPU_DYNAMIC_LAMP_ATT1, lamp->ob),
-				         GPU_dynamic_uniform(&lamp->att2, GPU_DYNAMIC_LAMP_ATT2, lamp->ob), *dist, &visifac);
-				break;
-			case LA_FALLOFF_INVCOEFFICIENTS:
-				GPU_link(mat, "lamp_falloff_invcoefficients",
-					     GPU_dynamic_uniform(&lamp->coeff_const, GPU_DYNAMIC_LAMP_COEFFCONST, lamp->ob),
-					     GPU_dynamic_uniform(&lamp->coeff_lin, GPU_DYNAMIC_LAMP_COEFFLIN, lamp->ob),
-					     GPU_dynamic_uniform(&lamp->coeff_quad, GPU_DYNAMIC_LAMP_COEFFQUAD, lamp->ob), *dist, &visifac);
-				break;
-			case LA_FALLOFF_CURVE:
-			{
-				float *array;
-				int size;
-
-				curvemapping_initialize(lamp->curfalloff);
-				curvemapping_table_RGBA(lamp->curfalloff, &array, &size);
-				GPU_link(mat, "lamp_falloff_curve",
-				         GPU_dynamic_uniform(&lamp->dist, GPU_DYNAMIC_LAMP_DISTANCE, lamp->ob),
-				         GPU_texture(size, array), *dist, &visifac);
-
-				break;
-			}
-		}
-
-		if (lamp->mode & LA_SPHERE)
-			GPU_link(mat, "lamp_visibility_sphere",
-			         GPU_dynamic_uniform(&lamp->dist, GPU_DYNAMIC_LAMP_DISTANCE, lamp->ob),
-			         *dist, visifac, &visifac);
-
-		if (lamp->type == LA_SPOT) {
-			GPUNodeLink *inpr;
-
-			if (lamp->mode & LA_SQUARE) {
-				mat->dynproperty |= DYN_LAMP_VEC | DYN_LAMP_IMAT;
-				GPU_link(mat, "lamp_visibility_spot_square",
-				         GPU_dynamic_uniform(lamp->dynvec, GPU_DYNAMIC_LAMP_DYNVEC, lamp->ob),
-				         GPU_dynamic_uniform((float *)lamp->dynimat, GPU_DYNAMIC_LAMP_DYNIMAT, lamp->ob),
-				GPU_dynamic_uniform((float *)lamp->spotvec, GPU_DYNAMIC_LAMP_SPOTSCALE, lamp->ob), *lv, &inpr);
-			}
-			else {
-				mat->dynproperty |= DYN_LAMP_VEC | DYN_LAMP_IMAT;
-				GPU_link(mat, "lamp_visibility_spot_circle",
-				         GPU_dynamic_uniform(lamp->dynvec, GPU_DYNAMIC_LAMP_DYNVEC, lamp->ob),
-				GPU_dynamic_uniform((float *)lamp->dynimat, GPU_DYNAMIC_LAMP_DYNIMAT, lamp->ob),
-				GPU_dynamic_uniform((float *)lamp->spotvec, GPU_DYNAMIC_LAMP_SPOTSCALE, lamp->ob), *lv, &inpr);
-			}
-			
-			GPU_link(mat, "lamp_visibility_spot",
-			         GPU_dynamic_uniform(&lamp->spotsi, GPU_DYNAMIC_LAMP_SPOTSIZE, lamp->ob),
-			         GPU_dynamic_uniform(&lamp->spotbl, GPU_DYNAMIC_LAMP_SPOTBLEND, lamp->ob),
-			         inpr, visifac, &visifac);
-		}
-
-		GPU_link(mat, "lamp_visibility_clamp", visifac, &visifac);
-
-		return visifac;
-	}
-}
-
-#if 0
-static void area_lamp_vectors(LampRen *lar)
-{
-	float xsize = 0.5f * lar->area_size, ysize = 0.5f * lar->area_sizey;
-
-	/* make it smaller, so area light can be multisampled */
-	float multifac = 1.0f / sqrtf((float)lar->ray_totsamp);
-	xsize *= multifac;
-	ysize *= multifac;
-
-	/* corner vectors */
-	lar->area[0][0] = lar->co[0] - xsize * lar->mat[0][0] - ysize * lar->mat[1][0];
-	lar->area[0][1] = lar->co[1] - xsize * lar->mat[0][1] - ysize * lar->mat[1][1];
-	lar->area[0][2] = lar->co[2] - xsize * lar->mat[0][2] - ysize * lar->mat[1][2];
-
-	/* corner vectors */
-	lar->area[1][0] = lar->co[0] - xsize * lar->mat[0][0] + ysize * lar->mat[1][0];
-	lar->area[1][1] = lar->co[1] - xsize * lar->mat[0][1] + ysize * lar->mat[1][1];
-	lar->area[1][2] = lar->co[2] - xsize * lar->mat[0][2] + ysize * lar->mat[1][2];
-
-	/* corner vectors */
-	lar->area[2][0] = lar->co[0] + xsize * lar->mat[0][0] + ysize * lar->mat[1][0];
-	lar->area[2][1] = lar->co[1] + xsize * lar->mat[0][1] + ysize * lar->mat[1][1];
-	lar->area[2][2] = lar->co[2] + xsize * lar->mat[0][2] + ysize * lar->mat[1][2];
-
-	/* corner vectors */
-	lar->area[3][0] = lar->co[0] + xsize * lar->mat[0][0] - ysize * lar->mat[1][0];
-	lar->area[3][1] = lar->co[1] + xsize * lar->mat[0][1] - ysize * lar->mat[1][1];
-	lar->area[3][2] = lar->co[2] + xsize * lar->mat[0][2] - ysize * lar->mat[1][2];
-	/* only for correction button size, matrix size works on energy */
-	lar->areasize = lar->dist * lar->dist / (4.0f * xsize * ysize);
-}
-#endif
-
-static void ramp_blend(
-        GPUMaterial *mat, GPUNodeLink *fac, GPUNodeLink *col1, GPUNodeLink *col2, int type,
-        GPUNodeLink **r_col)
-{
-	static const char *names[] = {"mix_blend", "mix_add", "mix_mult", "mix_sub",
-		"mix_screen", "mix_div", "mix_diff", "mix_dark", "mix_light",
-		"mix_overlay", "mix_dodge", "mix_burn", "mix_hue", "mix_sat",
-		"mix_val", "mix_color", "mix_soft", "mix_linear"};
-
-	GPU_link(mat, names[type], fac, col1, col2, r_col);
-}
-
-static void BKE_colorband_eval_blend(
-        GPUMaterial *mat, ColorBand *coba, GPUNodeLink *fac, float rampfac, int type,
-        GPUNodeLink *incol, GPUNodeLink **r_col)
-{
-	GPUNodeLink *tmp, *alpha, *col;
-	float *array;
-	int size;
-
-	/* do colorband */
-	BKE_colorband_evaluate_table_rgba(coba, &array, &size);
-	GPU_link(mat, "valtorgb", fac, GPU_texture(size, array), &col, &tmp);
-
-	/* use alpha in fac */
-	GPU_link(mat, "mtex_alpha_from_col", col, &alpha);
-	GPU_link(mat, "math_multiply", alpha, GPU_uniform(&rampfac), &fac);
-
-	/* blending method */
-	ramp_blend(mat, fac, incol, col, type, r_col);
-}
-
-static void ramp_diffuse_result(GPUShadeInput *shi, GPUNodeLink **diff)
-{
-	Material *ma = shi->mat;
-	GPUMaterial *mat = shi->gpumat;
-
-	{
-		if (ma->ramp_col) {
-			if (ma->rampin_col == MA_RAMP_IN_RESULT) {
-				GPUNodeLink *fac;
-				GPU_link(mat, "ramp_rgbtobw", *diff, &fac);
-				
-				/* colorband + blend */
-				BKE_colorband_eval_blend(mat, ma->ramp_col, fac, ma->rampfac_col, ma->rampblend_col, *diff, diff);
-			}
-		}
-	}
-}
-
-static void add_to_diffuse(
-        GPUMaterial *mat, Material *ma, GPUShadeInput *shi, GPUNodeLink *is, GPUNodeLink *rgb,
-        GPUNodeLink **r_diff)
-{
-	GPUNodeLink *fac, *tmp, *addcol;
-	
-	if (ma->ramp_col && (ma->mode & MA_RAMP_COL)) {
-		/* MA_RAMP_IN_RESULT is exceptional */
-		if (ma->rampin_col == MA_RAMP_IN_RESULT) {
-			addcol = shi->rgb;
-		}
-		else {
-			/* input */
-			switch (ma->rampin_col) {
-				case MA_RAMP_IN_ENERGY:
-					GPU_link(mat, "ramp_rgbtobw", rgb, &fac);
-					break;
-				case MA_RAMP_IN_SHADER:
-					fac = is;
-					break;
-				case MA_RAMP_IN_NOR:
-					GPU_link(mat, "vec_math_dot", shi->view, shi->vn, &tmp, &fac);
-					break;
-				default:
-					GPU_link(mat, "set_value_zero", &fac);
-					break;
-			}
-
-			/* colorband + blend */
-			BKE_colorband_eval_blend(mat, ma->ramp_col, fac, ma->rampfac_col, ma->rampblend_col, shi->rgb, &addcol);
-		}
-	}
-	else
-		addcol = shi->rgb;
-
-	/* output to */
-	GPU_link(mat, "shade_madd", *r_diff, rgb, addcol, r_diff);
-}
-
-static void ramp_spec_result(GPUShadeInput *shi, GPUNodeLink **spec)
-{
-	Material *ma = shi->mat;
-	GPUMaterial *mat = shi->gpumat;
-
-	if (ma->ramp_spec && ma->rampin_spec == MA_RAMP_IN_RESULT) {
-		GPUNodeLink *fac;
-		GPU_link(mat, "ramp_rgbtobw", *spec, &fac);
-		
-		/* colorband + blend */
-		BKE_colorband_eval_blend(mat, ma->ramp_spec, fac, ma->rampfac_spec, ma->rampblend_spec, *spec, spec);
-	}
-}
-
-static void do_specular_ramp(GPUShadeInput *shi, GPUNodeLink *is, GPUNodeLink *t, GPUNodeLink **spec)
-{
-	Material *ma = shi->mat;
-	GPUMaterial *mat = shi->gpumat;
-	GPUNodeLink *fac, *tmp;
-
-	*spec = shi->specrgb;
-
-	/* MA_RAMP_IN_RESULT is exception */
-	if (ma->ramp_spec && (ma->rampin_spec != MA_RAMP_IN_RESULT)) {
-		
-		/* input */
-		switch (ma->rampin_spec) {
-			case MA_RAMP_IN_ENERGY:
-				fac = t;
-				break;
-			case MA_RAMP_IN_SHADER:
-				fac = is;
-				break;
-			case MA_RAMP_IN_NOR:
-				GPU_link(mat, "vec_math_dot", shi->view, shi->vn, &tmp, &fac);
-				break;
-			default:
-				GPU_link(mat, "set_value_zero", &fac);
-				break;
-		}
-		
-		/* colorband + blend */
-		BKE_colorband_eval_blend(mat, ma->ramp_spec, fac, ma->rampfac_spec, ma->rampblend_spec, *spec, spec);
-	}
-}
-
-static void add_user_list(ListBase *list, void *data)
-{
-	LinkData *link = MEM_callocN(sizeof(LinkData), "GPULinkData");
-	link->data = data;
-	BLI_addtail(list, link);
-}
-
-static void shade_light_textures(GPUMaterial *mat, GPULamp *lamp, GPUNodeLink **rgb)
-{
-	for (int i = 0; i < MAX_MTEX; ++i) {
-		MTex *mtex = lamp->la->mtex[i];
-
-		if (mtex && mtex->tex && (mtex->tex->type & TEX_IMAGE) && mtex->tex->ima) {
-			mat->dynproperty |= DYN_LAMP_PERSMAT;
-
-			float one = 1.0f;
-			GPUNodeLink *tex_rgb;
-
-			GPU_link(mat, "shade_light_texture",
-			         GPU_builtin(GPU_VIEW_POSITION),
-			         GPU_image(mtex->tex->ima, &mtex->tex->iuser, false),
-			         GPU_dynamic_uniform((float *)lamp->dynpersmat, GPU_DYNAMIC_LAMP_DYNPERSMAT, lamp->ob),
-			         &tex_rgb);
-			texture_rgb_blend(mat, tex_rgb, *rgb, GPU_uniform(&one), GPU_uniform(&mtex->colfac), mtex->blendtype, rgb);
-		}
-	}
-}
-
-static void shade_one_light(GPUShadeInput *shi, GPUShadeResult *shr, GPULamp *lamp)
-{
-	Material *ma = shi->mat;
-	GPUMaterial *mat = shi->gpumat;
-	GPUNodeLink *lv, *dist, *is, *inp, *i;
-	GPUNodeLink *outcol, *specfac, *t, *shadfac = NULL, *lcol;
-	float one = 1.0f;
-
-	if ((lamp->mode & LA_ONLYSHADOW) && !(ma->mode & MA_SHADOW))
-		return;
-	
-	GPUNodeLink *vn = shi->vn;
-	GPUNodeLink *view = shi->view;
-
-	GPUNodeLink *visifac = lamp_get_visibility(mat, lamp, &lv, &dist);
-
-#if 0
-	if (ma->mode & MA_TANGENT_V)
-		GPU_link(mat, "shade_tangent_v", lv, GPU_attribute(CD_TANGENT, ""), &vn);
-#endif
-	
-	GPU_link(mat, "shade_inp", vn, lv, &inp);
-
-	if (lamp->mode & LA_NO_DIFF) {
-		GPU_link(mat, "shade_is_no_diffuse", &is);
-	}
-	else if (lamp->type == LA_HEMI) {
-		GPU_link(mat, "shade_is_hemi", inp, &is);
-	}
-	else {
-		if (lamp->type == LA_AREA) {
-			float area[4][4] = {{0.0f}}, areasize = 0.0f;
-
-			mat->dynproperty |= DYN_LAMP_VEC | DYN_LAMP_CO;
-			GPU_link(mat, "shade_inp_area",
-			         GPU_builtin(GPU_VIEW_POSITION),
-			         GPU_dynamic_uniform(lamp->dynco, GPU_DYNAMIC_LAMP_DYNCO, lamp->ob),
-			         GPU_dynamic_uniform(lamp->dynvec, GPU_DYNAMIC_LAMP_DYNVEC, lamp->ob), vn,
-			         GPU_uniform((float *)area),
-			         GPU_uniform(&areasize),
-			         GPU_uniform(&lamp->k), &inp);
-		}
-
-		is = inp; /* Lambert */
-
-		{
-			if (ma->diff_shader == MA_DIFF_ORENNAYAR)
-				GPU_link(mat, "shade_diffuse_oren_nayer", inp, vn, lv, view,
-				         GPU_uniform(&ma->roughness), &is);
-			else if (ma->diff_shader == MA_DIFF_TOON)
-				GPU_link(mat, "shade_diffuse_toon", vn, lv, view,
-				         GPU_uniform(&ma->param[0]), GPU_uniform(&ma->param[1]), &is);
-			else if (ma->diff_shader == MA_DIFF_MINNAERT)
-				GPU_link(mat, "shade_diffuse_minnaert", inp, vn, view,
-				         GPU_uniform(&ma->darkness), &is);
-			else if (ma->diff_shader == MA_DIFF_FRESNEL)
-				GPU_link(mat, "shade_diffuse_fresnel", vn, lv, view,
-				         GPU_uniform(&ma->param[0]), GPU_uniform(&ma->param[1]), &is);
-		}
-	}
-
-	if (ma->shade_flag & MA_CUBIC)
-		GPU_link(mat, "shade_cubic", is, &is);
-
-	i = is;
-	GPU_link(mat, "shade_visifac", i, visifac, shi->refl, &i);
-	
-	GPU_link(mat, "set_rgb", GPU_dynamic_uniform(lamp->dyncol, GPU_DYNAMIC_LAMP_DYNCOL, lamp->ob), &lcol);
-	shade_light_textures(mat, lamp, &lcol);
-	GPU_link(mat, "shade_mul_value_v3",
-	         GPU_dynamic_uniform(&lamp->dynenergy, GPU_DYNAMIC_LAMP_DYNENERGY, lamp->ob), lcol, &lcol);
-
-#if 0
-	if (ma->mode & MA_TANGENT_VN)
-		GPU_link(mat, "shade_tangent_v_spec", GPU_attribute(CD_TANGENT, ""), &vn);
-#endif
-
-	/* this replaces if (i > 0.0) conditional until that is supported */
-	/* done in shade_visifac now, GPU_link(mat, "mtex_value_clamp_positive", i, &i); */
-
-	if (ma->mode & MA_SHADOW) {
-		{
-			mat->dynproperty |= DYN_LAMP_PERSMAT;
-			
-			if (lamp->la->shadowmap_type == LA_SHADMAP_VARIANCE) {
-				GPU_link(mat, "test_shadowbuf_vsm",
-				         GPU_builtin(GPU_VIEW_POSITION),
-				         GPU_dynamic_texture(lamp->tex, GPU_DYNAMIC_SAMPLER_2DSHADOW, lamp->ob),
-				         GPU_dynamic_uniform((float *)lamp->dynpersmat, GPU_DYNAMIC_LAMP_DYNPERSMAT, lamp->ob),
-				         GPU_uniform(&lamp->bias), GPU_uniform(&lamp->la->bleedbias), inp, &shadfac);
-			}
-			else {
-				GPU_link(mat, "test_shadowbuf",
-				         GPU_builtin(GPU_VIEW_POSITION),
-				         GPU_dynamic_texture(lamp->tex, GPU_DYNAMIC_SAMPLER_2DSHADOW, lamp->ob),
-				         GPU_dynamic_uniform((float *)lamp->dynpersmat, GPU_DYNAMIC_LAMP_DYNPERSMAT, lamp->ob),
-				         GPU_uniform(&lamp->bias), inp, &shadfac);
-			}
-			
-			if (lamp->mode & LA_ONLYSHADOW) {
-				GPUNodeLink *shadrgb;
-				GPU_link(mat, "shade_only_shadow", i, shadfac,
-					GPU_dynamic_uniform(&lamp->dynenergy, GPU_DYNAMIC_LAMP_DYNENERGY, lamp->ob),
-					GPU_uniform(lamp->shadow_color), &shadrgb);
-				
-				if (!(lamp->mode & LA_NO_DIFF)) {
-					GPU_link(mat, "shade_only_shadow_diffuse", shadrgb, shi->rgb,
-					         shr->diff, &shr->diff);
-				}
-
-				if (!(lamp->mode & LA_NO_SPEC)) {
-					GPU_link(mat, "shade_only_shadow_specular", shadrgb, shi->specrgb,
-					         shr->spec, &shr->spec);
-				}
-				
-				add_user_list(&mat->lamps, lamp);
-				return;
-			}
-		}
-	}
-	else if (lamp->mode & LA_ONLYSHADOW) {
-		add_user_list(&mat->lamps, lamp);
-		return;
-	}
-	else
-		GPU_link(mat, "set_value", GPU_uniform(&one), &shadfac);
-
-	if (GPU_link_changed(shi->refl) || ma->ref != 0.0f) {
-		if (!(lamp->mode & LA_NO_DIFF)) {
-			GPUNodeLink *rgb;
-			GPU_link(mat, "shade_mul_value", i, lcol, &rgb);
-			GPU_link(mat, "mtex_value_invert", shadfac, &shadfac);
-			GPU_link(mat, "mix_mult",  shadfac, rgb, GPU_uniform(lamp->shadow_color), &rgb);
-			GPU_link(mat, "mtex_value_invert", shadfac, &shadfac);
-			add_to_diffuse(mat, ma, shi, is, rgb, &shr->diff);
-		}
-	}
-
-	if (!(lamp->mode & LA_NO_SPEC) && !(lamp->mode & LA_ONLYSHADOW) &&
-	         (GPU_link_changed(shi->spec) || ma->spec != 0.0f))
-	{
-		if (lamp->type == LA_HEMI) {
-			GPU_link(mat, "shade_hemi_spec", vn, lv, view, GPU_uniform(&ma->spec), shi->har, visifac, &t);
-			GPU_link(mat, "shade_add_spec", t, lcol, shi->specrgb, &outcol);
-			GPU_link(mat, "shade_add_clamped", shr->spec, outcol, &shr->spec);
-		}
-		else {
-			if (ma->spec_shader == MA_SPEC_PHONG) {
-				GPU_link(mat, "shade_phong_spec", vn, lv, view, shi->har, &specfac);
-			}
-			else if (ma->spec_shader == MA_SPEC_COOKTORR) {
-				GPU_link(mat, "shade_cooktorr_spec", vn, lv, view, shi->har, &specfac);
-			}
-			else if (ma->spec_shader == MA_SPEC_BLINN) {
-				GPU_link(mat, "shade_blinn_spec", vn, lv, view,
-				         GPU_uniform(&ma->refrac), shi->har, &specfac);
-			}
-			else if (ma->spec_shader == MA_SPEC_WARDISO) {
-				GPU_link(mat, "shade_wardiso_spec", vn, lv, view,
-				         GPU_uniform(&ma->rms), &specfac);
-			}
-			else {
-				GPU_link(mat, "shade_toon_spec", vn, lv, view,
-				         GPU_uniform(&ma->param[2]), GPU_uniform(&ma->param[3]), &specfac);
-			}
-
-			if (lamp->type == LA_AREA)
-				GPU_link(mat, "shade_spec_area_inp", specfac, inp, &specfac);
-
-			GPU_link(mat, "shade_spec_t", shadfac, shi->spec, visifac, specfac, &t); 
-
-			if (ma->mode & MA_RAMP_SPEC) {
-				GPUNodeLink *spec;
-				do_specular_ramp(shi, specfac, t, &spec);
-				GPU_link(mat, "shade_add_spec", t, lcol, spec, &outcol);
-				GPU_link(mat, "shade_add_clamped", shr->spec, outcol, &shr->spec);
-			}
-			else {
-				GPU_link(mat, "shade_add_spec", t, lcol, shi->specrgb, &outcol);
-				GPU_link(mat, "shade_add_clamped", shr->spec, outcol, &shr->spec);
-			}
-		}
-	}
-
-	add_user_list(&mat->lamps, lamp);
-}
-
-static void material_lights(GPUShadeInput *shi, GPUShadeResult *shr)
-{
-	Base *base;
-	Scene *sce_iter;
-	
-	for (SETLOOPER(shi->gpumat->scene, sce_iter, base)) {
-		Object *ob = base->object;
-
-		if (ob->type == OB_LAMP) {
-			GPULamp *lamp = GPU_lamp_from_blender(shi->gpumat->scene, ob, NULL);
-			if (lamp)
-				shade_one_light(shi, shr, lamp);
-		}
-
-		/* TODO: won't fix because will be removed. */
-#if 0
-		if (ob->transflag & OB_DUPLI) {
-			ListBase *lb = object_duplilist(G.main->depsgraph, shi->gpumat->scene, ob);
-			
-			for (DupliObject *dob = lb->first; dob; dob = dob->next) {
-				Object *ob_iter = dob->ob;
-
-				if (ob_iter->type == OB_LAMP) {
-					float omat[4][4];
-					copy_m4_m4(omat, ob_iter->obmat);
-					copy_m4_m4(ob_iter->obmat, dob->mat);
-
-					GPULamp *lamp = GPU_lamp_from_blender(shi->gpumat->scene, ob_iter, ob);
-					if (lamp)
-						shade_one_light(shi, shr, lamp);
-
-					copy_m4_m4(ob_iter->obmat, omat);
-				}
-			}
-			
-			free_object_duplilist(lb);
-		}
-#endif
-	}
-
-	/* prevent only shadow lamps from producing negative colors.*/
-	GPU_link(shi->gpumat, "shade_clamp_positive", shr->spec, &shr->spec);
-	GPU_link(shi->gpumat, "shade_clamp_positive", shr->diff, &shr->diff);
-}
-
-static void texture_rgb_blend(
-        GPUMaterial *mat, GPUNodeLink *tex, GPUNodeLink *out, GPUNodeLink *fact, GPUNodeLink *facg,
-        int blendtype, GPUNodeLink **in)
-{
-	switch (blendtype) {
-		case MTEX_BLEND:
-			GPU_link(mat, "mtex_rgb_blend", out, tex, fact, facg, in);
-			break;
-		case MTEX_MUL:
-			GPU_link(mat, "mtex_rgb_mul", out, tex, fact, facg, in);
-			break;
-		case MTEX_SCREEN:
-			GPU_link(mat, "mtex_rgb_screen", out, tex, fact, facg, in);
-			break;
-		case MTEX_OVERLAY:
-			GPU_link(mat, "mtex_rgb_overlay", out, tex, fact, facg, in);
-			break;
-		case MTEX_SUB:
-			GPU_link(mat, "mtex_rgb_sub", out, tex, fact, facg, in);
-			break;
-		case MTEX_ADD:
-			GPU_link(mat, "mtex_rgb_add", out, tex, fact, facg, in);
-			break;
-		case MTEX_DIV:
-			GPU_link(mat, "mtex_rgb_div", out, tex, fact, facg, in);
-			break;
-		case MTEX_DIFF:
-			GPU_link(mat, "mtex_rgb_diff", out, tex, fact, facg, in);
-			break;
-		case MTEX_DARK:
-			GPU_link(mat, "mtex_rgb_dark", out, tex, fact, facg, in);
-			break;
-		case MTEX_LIGHT:
-			GPU_link(mat, "mtex_rgb_light", out, tex, fact, facg, in);
-			break;
-		case MTEX_BLEND_HUE:
-			GPU_link(mat, "mtex_rgb_hue", out, tex, fact, facg, in);
-			break;
-		case MTEX_BLEND_SAT:
-			GPU_link(mat, "mtex_rgb_sat", out, tex, fact, facg, in);
-			break;
-		case MTEX_BLEND_VAL:
-			GPU_link(mat, "mtex_rgb_val", out, tex, fact, facg, in);
-			break;
-		case MTEX_BLEND_COLOR:
-			GPU_link(mat, "mtex_rgb_color", out, tex, fact, facg, in);
-			break;
-		case MTEX_SOFT_LIGHT:
-			GPU_link(mat, "mtex_rgb_soft", out, tex, fact, facg, in);
-			break;
-		case MTEX_LIN_LIGHT:
-			GPU_link(mat, "mtex_rgb_linear", out, tex, fact, facg, in);
-			break;
-		default:
-			GPU_link(mat, "set_rgb_zero", &in);
-			break;
-	}
-}
-
-static void texture_value_blend(
-        GPUMaterial *mat, GPUNodeLink *tex, GPUNodeLink *out, GPUNodeLink *fact, GPUNodeLink *facg,
-        int blendtype, GPUNodeLink **in)
-{
-	switch (blendtype) {
-		case MTEX_BLEND:
-			GPU_link(mat, "mtex_value_blend", out, tex, fact, facg, in);
-			break;
-		case MTEX_MUL:
-			GPU_link(mat, "mtex_value_mul", out, tex, fact, facg, in);
-			break;
-		case MTEX_SCREEN:
-			GPU_link(mat, "mtex_value_screen", out, tex, fact, facg, in);
-			break;
-		case MTEX_SUB:
-			GPU_link(mat, "mtex_value_sub", out, tex, fact, facg, in);
-			break;
-		case MTEX_ADD:
-			GPU_link(mat, "mtex_value_add", out, tex, fact, facg, in);
-			break;
-		case MTEX_DIV:
-			GPU_link(mat, "mtex_value_div", out, tex, fact, facg, in);
-			break;
-		case MTEX_DIFF:
-			GPU_link(mat, "mtex_value_diff", out, tex, fact, facg, in);
-			break;
-		case MTEX_DARK:
-			GPU_link(mat, "mtex_value_dark", out, tex, fact, facg, in);
-			break;
-		case MTEX_LIGHT:
-			GPU_link(mat, "mtex_value_light", out, tex, fact, facg, in);
-			break;
-		default:
-			GPU_link(mat, "set_value_zero", &in);
-			break;
-	}
-}
-
-static void do_material_tex(GPUShadeInput *shi)
-{
-	Material *ma = shi->mat;
-	GPUMaterial *mat = shi->gpumat;
-	MTex *mtex;
-	Tex *tex;
-	GPUNodeLink *texco, *tin, *trgb, *tnor, *tcol, *stencil, *tnorfac;
-	GPUNodeLink *texco_norm, *texco_orco, *texco_object;
-	GPUNodeLink *texco_global, *texco_uv = NULL;
-	GPUNodeLink *newnor, *orn;
-	float one = 1.0f;
-	int rgbnor, talpha;
-	bool init_done = false;
-	int iBumpSpacePrev = 0; /* Not necessary, quieting gcc warning. */
-	GPUNodeLink *vNorg, *vNacc, *fPrevMagnitude;
-	int iFirstTimeNMap = 1;
-	bool found_deriv_map = false;
-
-	GPU_link(mat, "set_value", GPU_uniform(&one), &stencil);
-
-	GPU_link(mat, "texco_norm", GPU_builtin(GPU_VIEW_NORMAL), &texco_norm);
-	GPU_link(mat, "texco_orco", GPU_attribute(CD_ORCO, ""), &texco_orco);
-	GPU_link(mat, "texco_object", GPU_builtin(GPU_INVERSE_VIEW_MATRIX),
-		GPU_builtin(GPU_INVERSE_OBJECT_MATRIX),
-		GPU_builtin(GPU_VIEW_POSITION), &texco_object);
-#if 0
-	GPU_link(mat, "texco_tangent", GPU_attribute(CD_TANGENT, ""), &texco_tangent);
-#endif
-	GPU_link(mat, "texco_global", GPU_builtin(GPU_INVERSE_VIEW_MATRIX),
-		GPU_builtin(GPU_VIEW_POSITION), &texco_global);
-
-	orn = texco_norm;
-
-	/* go over texture slots */
-	for (int tex_nr = 0; tex_nr < MAX_MTEX; tex_nr++) {
-		/* separate tex switching */
-		if (ma->septex & (1 << tex_nr)) continue;
-		
-		if (ma->mtex[tex_nr]) {
-			mtex = ma->mtex[tex_nr];
-			
-			tex = mtex->tex;
-			if (tex == NULL) continue;
-
-			/* which coords */
-			if (mtex->texco == TEXCO_ORCO)
-				texco = texco_orco;
-			else if (mtex->texco == TEXCO_OBJECT)
-				texco = texco_object;
-			else if (mtex->texco == TEXCO_NORM)
-				texco = orn;
-			else if (mtex->texco == TEXCO_TANGENT)
-				texco = texco_object;
-			else if (mtex->texco == TEXCO_GLOB)
-				texco = texco_global;
-			else if (mtex->texco == TEXCO_REFL) {
-				GPU_link(mat, "texco_refl", shi->vn, shi->view, &shi->ref);
-				texco = shi->ref;
-			}
-			else if (mtex->texco == TEXCO_UV) {
-				if (1) { //!(texco_uv && strcmp(mtex->uvname, lastuvname) == 0)) {
-					GPU_link(mat, "texco_uv", GPU_attribute(CD_MTFACE, mtex->uvname), &texco_uv);
-					/*lastuvname = mtex->uvname;*/ /*UNUSED*/
-				}
-				texco = texco_uv;
-			}
-			else
-				continue;
-
-			/* in case of uv, this would just undo a multiplication in texco_uv */
-			if (mtex->texco != TEXCO_UV)
-				GPU_link(mat, "mtex_2d_mapping", texco, &texco);
-
-			if (mtex->size[0] != 1.0f || mtex->size[1] != 1.0f || mtex->size[2] != 1.0f)
-				GPU_link(mat, "mtex_mapping_size", texco, GPU_uniform(mtex->size), &texco);
-
-			float ofs[3] = {
-				mtex->ofs[0] + 0.5f - 0.5f * mtex->size[0],
-				mtex->ofs[1] + 0.5f - 0.5f * mtex->size[1],
-				0.0f
-			};
-
-			if (ofs[0] != 0.0f || ofs[1] != 0.0f || ofs[2] != 0.0f)
-				GPU_link(mat, "mtex_mapping_ofs", texco, GPU_uniform(ofs), &texco);
-
-			talpha = 0;
-
-			if (tex && tex->ima &&
-			    ((tex->type == TEX_IMAGE) ||
-			     ((tex->type == TEX_ENVMAP) && (mtex->texco == TEXCO_REFL))))
-			{
-				if (tex->type == TEX_IMAGE) {
-					GPU_link(mat, "mtex_image", texco, GPU_image(tex->ima, &tex->iuser, false), &tin, &trgb);
-				}
-				else {
-					GPU_link(mat, "mtex_cube_map_refl",
-					         GPU_cube_map(tex->ima, &tex->iuser, false), shi->view, shi->vn,
-					         GPU_builtin(GPU_INVERSE_VIEW_MATRIX),
-					         GPU_builtin(GPU_VIEW_MATRIX), &tin, &trgb);
-				}
-				rgbnor = TEX_RGB;
-
-				talpha = ((tex->imaflag & TEX_USEALPHA) && tex->ima && (tex->ima->flag & IMA_IGNORE_ALPHA) == 0);
-			}
-			else {
-				continue;
-			}
-
-			/* texture output */
-			if ((rgbnor & TEX_RGB) && (mtex->texflag & MTEX_RGBTOINT)) {
-				GPU_link(mat, "mtex_rgbtoint", trgb, &tin);
-				rgbnor -= TEX_RGB;
-			}
-
-			if (mtex->texflag & MTEX_NEGATIVE) {
-				if (rgbnor & TEX_RGB)
-					GPU_link(mat, "mtex_rgb_invert", trgb, &trgb);
-				else
-					GPU_link(mat, "mtex_value_invert", tin, &tin);
-			}
-
-			if (mtex->texflag & MTEX_STENCIL) {
-				if (rgbnor & TEX_RGB)
-					GPU_link(mat, "mtex_rgb_stencil", stencil, trgb, &stencil, &trgb);
-				else
-					GPU_link(mat, "mtex_value_stencil", stencil, tin, &stencil, &tin);
-			}
-
-			/* mapping */
-			if (mtex->mapto & (MAP_COL | MAP_COLSPEC | MAP_COLMIR)) {
-				/* stencil maps on the texture control slider, not texture intensity value */
-				if ((rgbnor & TEX_RGB) == 0) {
-					GPU_link(mat, "set_rgb", GPU_uniform(&mtex->r), &tcol);
-				}
-				else {
-					GPU_link(mat, "set_rgba", trgb, &tcol);
-
-					if (mtex->mapto & MAP_ALPHA)
-						GPU_link(mat, "set_value", stencil, &tin);
-					else if (talpha)
-						GPU_link(mat, "mtex_alpha_from_col", trgb, &tin);
-					else
-						GPU_link(mat, "set_value_one", &tin);
-				}
-
-				if ((tex->type == TEX_IMAGE) ||
-				    ((tex->type == TEX_ENVMAP) && (mtex->texco == TEXCO_REFL)))
-				{
-					if (GPU_material_do_color_management(mat)) {
-						GPU_link(mat, "srgb_to_linearrgb", tcol, &tcol);
-					}
-				}
-				
-				if (mtex->mapto & MAP_COL) {
-					GPUNodeLink *colfac;
-
-					if (mtex->colfac == 1.0f) colfac = stencil;
-					else GPU_link(mat, "math_multiply", GPU_uniform(&mtex->colfac), stencil, &colfac);
-
-					texture_rgb_blend(mat, tcol, shi->rgb, tin, colfac, mtex->blendtype, &shi->rgb);
-				}
-				
-				if (mtex->mapto & MAP_COLSPEC) {
-					GPUNodeLink *colspecfac;
-
-					if (mtex->colspecfac == 1.0f) colspecfac = stencil;
-					else GPU_link(mat, "math_multiply", GPU_uniform(&mtex->colspecfac), stencil, &colspecfac);
-
-					texture_rgb_blend(mat, tcol, shi->specrgb, tin, colspecfac, mtex->blendtype, &shi->specrgb);
-				}
-
-				if (mtex->mapto & MAP_COLMIR) {
-					GPUNodeLink *colmirfac;
-
-					if (mtex->mirrfac == 1.0f) colmirfac = stencil;
-					else GPU_link(mat, "math_multiply", GPU_uniform(&mtex->mirrfac), stencil, &colmirfac);
-
-					/* exception for envmap only */
-					if (tex->type == TEX_ENVMAP && mtex->blendtype == MTEX_BLEND) {
-						GPU_link(mat, "mtex_mirror", tcol, shi->refcol, tin, colmirfac, &shi->refcol);
-					}
-					else
-						texture_rgb_blend(mat, tcol, shi->mir, tin, colmirfac, mtex->blendtype, &shi->mir);
-				}
-			}
-
-			if (mtex->mapto & MAP_NORM) {
-				if (tex->type == TEX_IMAGE) {
-					found_deriv_map = tex->imaflag & TEX_DERIVATIVEMAP;
-
-					if (tex->imaflag & TEX_NORMALMAP) {
-						/* normalmap image */
-						GPU_link(mat, "mtex_normal", texco, GPU_image(tex->ima, &tex->iuser, true), &tnor);
-						
-						if (mtex->norfac < 0.0f)
-							GPU_link(mat, "mtex_negate_texnormal", tnor, &tnor);
-
-						if (mtex->normapspace == MTEX_NSPACE_TANGENT) {
-							if (iFirstTimeNMap != 0) {
-								// use unnormalized normal (this is how we bake it - closer to gamedev)
-								GPUNodeLink *vNegNorm;
-								GPU_link(mat, "vec_math_negate",
-								         GPU_builtin(GPU_VIEW_NORMAL), &vNegNorm);
-								GPU_link(mat, "mtex_nspace_tangent",
-								         GPU_attribute(CD_TANGENT, ""), vNegNorm, tnor, &newnor);
-								iFirstTimeNMap = 0;
-							}
-							else { /* otherwise use accumulated perturbations */
-								GPU_link(mat, "mtex_nspace_tangent",
-								         GPU_attribute(CD_TANGENT, ""), shi->vn, tnor, &newnor);
-							}
-						}
-						else if (mtex->normapspace == MTEX_NSPACE_OBJECT) {
-							/* transform normal by object then view matrix */
-							GPU_link(mat, "mtex_nspace_object", tnor, &newnor);
-						}
-						else if (mtex->normapspace == MTEX_NSPACE_WORLD) {
-							/* transform normal by view matrix */
-							GPU_link(mat, "mtex_nspace_world", GPU_builtin(GPU_VIEW_MATRIX), tnor, &newnor);
-						}
-						else {
-							/* no transform, normal in camera space */
-							newnor = tnor;
-						}
-						
-						float norfac = min_ff(fabsf(mtex->norfac), 1.0f);
-						
-						if (norfac == 1.0f && !GPU_link_changed(stencil)) {
-							shi->vn = newnor;
-						}
-						else {
-							tnorfac = GPU_uniform(&norfac);
-	
-							if (GPU_link_changed(stencil))
-								GPU_link(mat, "math_multiply", tnorfac, stencil, &tnorfac);
-	
-							GPU_link(mat, "mtex_blend_normal", tnorfac, shi->vn, newnor, &shi->vn);
-						}
-						
-					}
-					else if (found_deriv_map ||
-					         (mtex->texflag & (MTEX_3TAP_BUMP | MTEX_5TAP_BUMP | MTEX_BICUBIC_BUMP)))
-					{
-						/* ntap bumpmap image */
-						int iBumpSpace;
-						float ima_x, ima_y;
-
-						float imag_tspace_dimension_x = 1024.0f; /* only used for texture space variant */
-						float aspect = 1.0f;
-						
-						GPUNodeLink *vR1, *vR2;
-						GPUNodeLink *dBs, *dBt, *fDet;
-
-						float hScale = 0.1f; /* compatibility adjustment factor for all bumpspace types */
-						if (mtex->texflag & MTEX_BUMP_TEXTURESPACE)
-							hScale = 13.0f; /* factor for scaling texspace bumps */
-						else if (found_deriv_map)
-							hScale = 1.0f;
-
-						/* resolve texture resolution */
-						if ((mtex->texflag & MTEX_BUMP_TEXTURESPACE) || found_deriv_map) {
-							ImBuf *ibuf = BKE_image_acquire_ibuf(tex->ima, &tex->iuser, NULL);
-							ima_x = 512.0f; ima_y = 512.0f; /* prevent calling textureSize, glsl 1.3 only */
-							if (ibuf) {
-								ima_x = ibuf->x;
-								ima_y = ibuf->y;
-								aspect = (float)ima_y / ima_x;
-							}
-							BKE_image_release_ibuf(tex->ima, ibuf, NULL);
-						}
-
-						/* The negate on norfac is done because the
-						 * normal in the renderer points inward which corresponds
-						 * to inverting the bump map. Should this ever change
-						 * this negate must be removed. */
-						float norfac = -hScale * mtex->norfac;
-						if (found_deriv_map) {
-							float fVirtDim = sqrtf(fabsf(ima_x * mtex->size[0] * ima_y * mtex->size[1]));
-							norfac /= MAX2(fVirtDim, FLT_EPSILON);
-						}
-
-						tnorfac = GPU_uniform(&norfac);
-
-						if (found_deriv_map)
-							GPU_link(mat, "math_multiply", tnorfac, GPU_builtin(GPU_AUTO_BUMPSCALE), &tnorfac);
-						
-						if (GPU_link_changed(stencil))
-							GPU_link(mat, "math_multiply", tnorfac, stencil, &tnorfac);
-						
-						if (!init_done) {
-							/* copy shi->vn to vNorg and vNacc, set magnitude to 1 */
-							GPU_link(mat, "mtex_bump_normals_init", shi->vn, &vNorg, &vNacc, &fPrevMagnitude);
-							iBumpSpacePrev = 0;
-							init_done = true;
-						}
-						
-						// find current bump space
-						if (mtex->texflag & MTEX_BUMP_OBJECTSPACE)
-							iBumpSpace = 1;
-						else if (mtex->texflag & MTEX_BUMP_TEXTURESPACE)
-							iBumpSpace = 2;
-						else
-							iBumpSpace = 4; /* ViewSpace */
-						
-						/* re-initialize if bump space changed */
-						if (iBumpSpacePrev != iBumpSpace) {
-							GPUNodeLink *surf_pos = GPU_builtin(GPU_VIEW_POSITION);
-
-							if (mtex->texflag & MTEX_BUMP_OBJECTSPACE)
-								GPU_link(mat, "mtex_bump_init_objspace",
-								         surf_pos, vNorg,
-								         GPU_builtin(GPU_VIEW_MATRIX),
-								         GPU_builtin(GPU_INVERSE_VIEW_MATRIX),
-								         GPU_builtin(GPU_OBJECT_MATRIX),
-								         GPU_builtin(GPU_INVERSE_OBJECT_MATRIX),
-								         fPrevMagnitude, vNacc,
-								         &fPrevMagnitude, &vNacc,
-								         &vR1, &vR2, &fDet);
-								
-							else if (mtex->texflag & MTEX_BUMP_TEXTURESPACE)
-								GPU_link(mat, "mtex_bump_init_texturespace",
-								         surf_pos, vNorg,
-								         fPrevMagnitude, vNacc,
-								         &fPrevMagnitude, &vNacc,
-								         &vR1, &vR2, &fDet);
-								
-							else
-								GPU_link(mat, "mtex_bump_init_viewspace",
-								         surf_pos, vNorg,
-								         fPrevMagnitude, vNacc,
-								         &fPrevMagnitude, &vNacc,
-								         &vR1, &vR2, &fDet);
-							
-							iBumpSpacePrev = iBumpSpace;
-						}
-						
-						
-						if (found_deriv_map) {
-							GPU_link(mat, "mtex_bump_deriv",
-							         texco, GPU_image(tex->ima, &tex->iuser, true),
-							         GPU_uniform(&ima_x), GPU_uniform(&ima_y), tnorfac,
-							         &dBs, &dBt);
-						}
-						else if (mtex->texflag & MTEX_3TAP_BUMP)
-							GPU_link(mat, "mtex_bump_tap3",
-							         texco, GPU_image(tex->ima, &tex->iuser, true), tnorfac,
-							         &dBs, &dBt);
-						else if (mtex->texflag & MTEX_5TAP_BUMP)
-							GPU_link(mat, "mtex_bump_tap5",
-							         texco, GPU_image(tex->ima, &tex->iuser, true), tnorfac,
-							         &dBs, &dBt);
-						else if (mtex->texflag & MTEX_BICUBIC_BUMP) {
-							if (GPU_bicubic_bump_support()) {
-								GPU_link(mat, "mtex_bump_bicubic",
-								         texco, GPU_image(tex->ima, &tex->iuser, true), tnorfac,
-								         &dBs, &dBt);
-							}
-							else {
-								GPU_link(mat, "mtex_bump_tap5",
-								         texco, GPU_image(tex->ima, &tex->iuser, true), tnorfac,
-								         &dBs, &dBt);
-							}
-						}
-						
-						
-						if (mtex->texflag & MTEX_BUMP_TEXTURESPACE) {
-							float imag_tspace_dimension_y = aspect * imag_tspace_dimension_x;
-							GPU_link(mat, "mtex_bump_apply_texspace",
-							         fDet, dBs, dBt, vR1, vR2,
-							         GPU_image(tex->ima, &tex->iuser, true), texco,
-							         GPU_uniform(&imag_tspace_dimension_x),
-							         GPU_uniform(&imag_tspace_dimension_y), vNacc,
-							         &vNacc, &shi->vn);
-						}
-						else
-							GPU_link(mat, "mtex_bump_apply",
-							         fDet, dBs, dBt, vR1, vR2, vNacc,
-							         &vNacc, &shi->vn);
-						
-					}
-				}
-				
-				GPU_link(mat, "vec_math_negate", shi->vn, &orn);
-			}
-
-			if ((mtex->mapto & MAP_VARS)) {
-				if (rgbnor & TEX_RGB) {
-					if (talpha)
-						GPU_link(mat, "mtex_alpha_from_col", trgb, &tin);
-					else
-						GPU_link(mat, "mtex_rgbtoint", trgb, &tin);
-				}
-
-				if (mtex->mapto & MAP_REF) {
-					GPUNodeLink *difffac;
-
-					if (mtex->difffac == 1.0f) difffac = stencil;
-					else GPU_link(mat, "math_multiply", GPU_uniform(&mtex->difffac), stencil, &difffac);
-
-					texture_value_blend(
-					        mat, GPU_uniform(&mtex->def_var), shi->refl, tin, difffac,
-					        mtex->blendtype, &shi->refl);
-					GPU_link(mat, "mtex_value_clamp_positive", shi->refl, &shi->refl);
-				}
-				if (mtex->mapto & MAP_SPEC) {
-					GPUNodeLink *specfac;
-
-					if (mtex->specfac == 1.0f) specfac = stencil;
-					else GPU_link(mat, "math_multiply", GPU_uniform(&mtex->specfac), stencil, &specfac);
-
-					texture_value_blend(
-					        mat, GPU_uniform(&mtex->def_var), shi->spec, tin, specfac,
-					        mtex->blendtype, &shi->spec);
-					GPU_link(mat, "mtex_value_clamp_positive", shi->spec, &shi->spec);
-				}
-				if (mtex->mapto & MAP_EMIT) {
-					GPUNodeLink *emitfac;
-
-					if (mtex->emitfac == 1.0f) emitfac = stencil;
-					else GPU_link(mat, "math_multiply", GPU_uniform(&mtex->emitfac), stencil, &emitfac);
-
-					texture_value_blend(
-					        mat, GPU_uniform(&mtex->def_var), shi->emit, tin, emitfac,
-					        mtex->blendtype, &shi->emit);
-					GPU_link(mat, "mtex_value_clamp_positive", shi->emit, &shi->emit);
-				}
-				if (mtex->mapto & MAP_HAR) {
-					GPUNodeLink *hardfac;
-
-					if (mtex->hardfac == 1.0f) hardfac = stencil;
-					else GPU_link(mat, "math_multiply", GPU_uniform(&mtex->hardfac), stencil, &hardfac);
-
-					GPU_link(mat, "mtex_har_divide", shi->har, &shi->har);
-					texture_value_blend(
-					        mat, GPU_uniform(&mtex->def_var), shi->har, tin, hardfac,
-					        mtex->blendtype, &shi->har);
-					GPU_link(mat, "mtex_har_multiply_clamp", shi->har, &shi->har);
-				}
-				if (mtex->mapto & MAP_ALPHA) {
-					GPUNodeLink *alphafac;
-
-					if (mtex->alphafac == 1.0f) alphafac = stencil;
-					else GPU_link(mat, "math_multiply", GPU_uniform(&mtex->alphafac), stencil, &alphafac);
-
-					texture_value_blend(
-					        mat, GPU_uniform(&mtex->def_var), shi->alpha, tin, alphafac,
-					        mtex->blendtype, &shi->alpha);
-					GPU_link(mat, "mtex_value_clamp", shi->alpha, &shi->alpha);
-				}
-				if (mtex->mapto & MAP_AMB) {
-					GPUNodeLink *ambfac;
-
-					if (mtex->ambfac == 1.0f) ambfac = stencil;
-					else GPU_link(mat, "math_multiply", GPU_uniform(&mtex->ambfac), stencil, &ambfac);
-
-					texture_value_blend(
-					        mat, GPU_uniform(&mtex->def_var), shi->amb, tin, ambfac,
-					        mtex->blendtype, &shi->amb);
-					GPU_link(mat, "mtex_value_clamp", shi->amb, &shi->amb);
-				}
-			}
-		}
-	}
-}
-
-void GPU_shadeinput_set(GPUMaterial *mat, Material *ma, GPUShadeInput *shi)
-{
-	float one = 1.0f;
-
-	memset(shi, 0, sizeof(*shi));
-
-	shi->gpumat = mat;
-	shi->mat = ma;
-
-	GPU_link(mat, "set_rgb", GPU_dynamic_uniform(&ma->r, GPU_DYNAMIC_MAT_DIFFRGB, ma), &shi->rgb);
-	GPU_link(mat, "set_rgb", GPU_dynamic_uniform(&ma->specr, GPU_DYNAMIC_MAT_SPECRGB, ma), &shi->specrgb);
-	GPU_link(mat, "set_rgb", GPU_dynamic_uniform(&ma->mirr, GPU_DYNAMIC_MAT_MIR, ma), &shi->mir);
-	GPU_link(mat, "set_rgba_zero", &shi->refcol);
-	GPU_link(mat, "shade_norm", GPU_builtin(GPU_VIEW_NORMAL), &shi->vn);
-
-	if (mat->alpha)
-		GPU_link(mat, "set_value", GPU_dynamic_uniform(&ma->alpha, GPU_DYNAMIC_MAT_ALPHA, ma), &shi->alpha);
-	else
-		GPU_link(mat, "set_value", GPU_uniform(&one), &shi->alpha);
-
-	GPU_link(mat, "set_value", GPU_dynamic_uniform(&ma->ref, GPU_DYNAMIC_MAT_REF, ma), &shi->refl);
-	GPU_link(mat, "set_value", GPU_dynamic_uniform(&ma->spec, GPU_DYNAMIC_MAT_SPEC, ma), &shi->spec);
-	GPU_link(mat, "set_value", GPU_dynamic_uniform(&ma->emit, GPU_DYNAMIC_MAT_EMIT, ma), &shi->emit);
-	GPU_link(mat, "set_value", GPU_dynamic_uniform((float *)&ma->har, GPU_DYNAMIC_MAT_HARD, ma), &shi->har);
-	GPU_link(mat, "set_value", GPU_dynamic_uniform(&ma->amb, GPU_DYNAMIC_MAT_AMB, ma), &shi->amb);
-	GPU_link(mat, "set_value", GPU_uniform(&ma->spectra), &shi->spectra);
-	GPU_link(mat, "shade_view", GPU_builtin(GPU_VIEW_POSITION), &shi->view);
-	GPU_link(mat, "vcol_attribute", GPU_attribute(CD_MCOL, ""), &shi->vcol);
-	if (GPU_material_do_color_management(mat))
-		GPU_link(mat, "srgb_to_linearrgb", shi->vcol, &shi->vcol);
-	GPU_link(mat, "texco_refl", shi->vn, shi->view, &shi->ref);
-}
-
-void GPU_mist_update_enable(short enable)
-{
-	GPUWorld.mistenabled = (float)enable;
-}
-
-void GPU_mist_update_values(int type, float start, float dist, float inten, float color[3])
-{
-	GPUWorld.mistype = (float)type;
-	GPUWorld.miststart = start;
-	GPUWorld.mistdistance = dist;
-	GPUWorld.mistintensity = inten;
-	copy_v3_v3(GPUWorld.mistcol, color);
-	GPUWorld.mistcol[3] = 1.0f;
-}
-
-void GPU_horizon_update_color(float color[3])
-{
-	copy_v3_v3(GPUWorld.horicol, color);
-}
-
-void GPU_ambient_update_color(float color[3])
-{
-	copy_v3_v3(GPUWorld.ambcol, color);
-	GPUWorld.ambcol[3] = 1.0f;
-}
-
-void GPU_zenith_update_color(float color[3])
-{
-	copy_v3_v3(GPUWorld.zencol, color);
-}
-
-void GPU_shaderesult_set(GPUShadeInput *shi, GPUShadeResult *shr)
-{
-	GPUMaterial *mat = shi->gpumat;
-	GPUNodeLink *emit, *ulinfac, *ulogfac, *mistfac;
-	Material *ma = shi->mat;
-	World *world = mat->scene->world;
-	float linfac, logfac;
-
-	memset(shr, 0, sizeof(*shr));
-
-	if (ma->mode & MA_VERTEXCOLP)
-		shi->rgb = shi->vcol;
-
-	do_material_tex(shi);
-
-	if (ma->mode & MA_SHLESS) {
-		GPU_link(mat, "set_rgb", shi->rgb, &shr->diff);
-		GPU_link(mat, "set_rgb_zero", &shr->spec);
-		GPU_link(mat, "set_value", shi->alpha, &shr->alpha);
-		shr->combined = shr->diff;
-	}
-	else {
-		if (GPU_link_changed(shi->emit) || ma->emit != 0.0f) {
-			if ((ma->mode & (MA_VERTEXCOL | MA_VERTEXCOLP)) == MA_VERTEXCOL) {
-				GPU_link(mat, "shade_add", shi->emit, shi->vcol, &emit);
-				GPU_link(mat, "shade_mul", emit, shi->rgb, &shr->diff);
-			}
-			else
-				GPU_link(mat, "shade_mul_value", shi->emit, shi->rgb, &shr->diff);
-		}
-		else
-			GPU_link(mat, "set_rgb_zero", &shr->diff);
-
-		GPU_link(mat, "set_rgb_zero", &shr->spec);
-
-		material_lights(shi, shr);
-
-		shr->combined = shr->diff;
-
-		GPU_link(mat, "set_value", shi->alpha, &shr->alpha);
-
-		if (world) {
-			/* exposure correction */
-			if (world->exp != 0.0f || world->range != 1.0f) {
-				linfac = 1.0f + powf((2.0f * world->exp + 0.5f), -10);
-				logfac = logf((linfac - 1.0f) / linfac) / world->range;
-
-				GPU_link(mat, "set_value", GPU_uniform(&linfac), &ulinfac);
-				GPU_link(mat, "set_value", GPU_uniform(&logfac), &ulogfac);
-
-				GPU_link(mat, "shade_exposure_correct", shr->combined,
-					ulinfac, ulogfac, &shr->combined);
-				GPU_link(mat, "shade_exposure_correct", shr->spec,
-					ulinfac, ulogfac, &shr->spec);
-			}
-
-			/* environment lighting */
-			if ((world->mode & WO_ENV_LIGHT) &&
-			    (mat->scene->r.mode & R_SHADOW) &&
-			    !BKE_scene_use_new_shading_nodes(mat->scene))
-			{
-				if ((world->ao_env_energy != 0.0f) && (GPU_link_changed(shi->amb) || ma->amb != 0.0f) &&
-				    (GPU_link_changed(shi->refl) || ma->ref != 0.0f))
-				{
-					if (world->aocolor != WO_AOPLAIN) {
-						if (!(is_zero_v3(&world->horr) & is_zero_v3(&world->zenr))) {
-							GPUNodeLink *fcol, *f;
-							GPU_link(mat, "math_multiply", shi->amb, shi->refl, &f);
-							GPU_link(mat, "math_multiply", f, GPU_uniform(&world->ao_env_energy), &f);
-							GPU_link(mat, "shade_mul_value", f, shi->rgb, &fcol);
-							GPU_link(mat, "env_apply", shr->combined,
-							         GPU_dynamic_uniform(GPUWorld.horicol, GPU_DYNAMIC_HORIZON_COLOR, NULL),
-							         GPU_dynamic_uniform(GPUWorld.zencol, GPU_DYNAMIC_ZENITH_COLOR, NULL), fcol,
-							         GPU_builtin(GPU_VIEW_MATRIX), shi->vn, &shr->combined);
-						}
-					}
-					else {
-						GPUNodeLink *f;
-						GPU_link(mat, "math_multiply", shi->amb, shi->refl, &f);
-						GPU_link(mat, "math_multiply", f, GPU_uniform(&world->ao_env_energy), &f);
-						GPU_link(mat, "shade_maddf", shr->combined, f, shi->rgb, &shr->combined);
-					}
-				}
-			}
-
-			/* ambient color */
-			if (GPU_link_changed(shi->amb) || ma->amb != 0.0f) {
-				GPU_link(mat, "shade_maddf", shr->combined, GPU_uniform(&ma->amb),
-				         GPU_dynamic_uniform(GPUWorld.ambcol, GPU_DYNAMIC_AMBIENT_COLOR, NULL),
-				         &shr->combined);
-			}
-		}
-
-		if (ma->mode & MA_TRANSP && (ma->mode & (MA_ZTRANSP | MA_RAYTRANSP))) {
-			if (GPU_link_changed(shi->spectra) || ma->spectra != 0.0f) {
-				GPU_link(mat, "alpha_spec_correction", shr->spec, shi->spectra,
-				         shi->alpha, &shr->alpha);
-			}
-		}
-
-		if (ma->mode & MA_RAMP_COL) ramp_diffuse_result(shi, &shr->combined);
-		if (ma->mode & MA_RAMP_SPEC) ramp_spec_result(shi, &shr->spec);
-
-		if (GPU_link_changed(shi->refcol))
-			GPU_link(mat, "shade_add_mirror", shi->mir, shi->refcol, shr->combined, &shr->combined);
-
-		if (GPU_link_changed(shi->spec) || ma->spec != 0.0f)
-			GPU_link(mat, "shade_add", shr->combined, shr->spec, &shr->combined);
-	}
-
-	GPU_link(mat, "mtex_alpha_to_col", shr->combined, shr->alpha, &shr->combined);
-
-	if (ma->shade_flag & MA_OBCOLOR)
-		GPU_link(mat, "shade_obcolor", shr->combined, GPU_builtin(GPU_OBCOLOR), &shr->combined);
-
-	if (!(ma->mode & MA_NOMIST)) {
-		GPU_link(mat, "shade_mist_factor", GPU_builtin(GPU_VIEW_POSITION),
-		         GPU_dynamic_uniform(&GPUWorld.mistenabled, GPU_DYNAMIC_MIST_ENABLE, NULL),
-		         GPU_dynamic_uniform(&GPUWorld.miststart, GPU_DYNAMIC_MIST_START, NULL),
-		         GPU_dynamic_uniform(&GPUWorld.mistdistance, GPU_DYNAMIC_MIST_DISTANCE, NULL),
-		         GPU_dynamic_uniform(&GPUWorld.mistype, GPU_DYNAMIC_MIST_TYPE, NULL),
-		         GPU_dynamic_uniform(&GPUWorld.mistintensity, GPU_DYNAMIC_MIST_INTENSITY, NULL), &mistfac);
-
-		GPU_link(mat, "mix_blend", mistfac, shr->combined,
-		         GPU_dynamic_uniform(GPUWorld.mistcol, GPU_DYNAMIC_MIST_COLOR, NULL), &shr->combined);
-	}
-
-	if (!mat->alpha) {
-		if (world && (GPU_link_changed(shr->alpha) || ma->alpha != 1.0f))
-			GPU_link(mat, "shade_world_mix", GPU_dynamic_uniform(GPUWorld.horicol, GPU_DYNAMIC_HORIZON_COLOR, NULL),
-			         shr->combined, &shr->combined);
-
-		GPU_link(mat, "shade_alpha_opaque", shr->combined, &shr->combined);
-	}
-
-	if (ma->shade_flag & MA_OBCOLOR) {
-		mat->obcolalpha = 1;
-		GPU_link(mat, "shade_alpha_obcolor", shr->combined, GPU_builtin(GPU_OBCOLOR), &shr->combined);
-	}
-}
-
-static GPUNodeLink *GPU_blender_material(GPUMaterial *mat, Material *ma)
-{
-	GPUShadeInput shi;
-	GPUShadeResult shr;
-
-	GPU_shadeinput_set(mat, ma, &shi);
-	GPU_shaderesult_set(&shi, &shr);
-
-	return shr.combined;
-}
-
-static GPUNodeLink *gpu_material_diffuse_bsdf(GPUMaterial *mat, Material *ma)
-{
-	static float roughness = 0.0f;
-	GPUNodeLink *outlink;
-
-	GPU_link(mat, "node_bsdf_diffuse",
-	         GPU_uniform(&ma->r), GPU_uniform(&roughness), GPU_builtin(GPU_VIEW_NORMAL), &outlink);
-
-	return outlink;
-}
-
-static GPUNodeLink *gpu_material_preview_matcap(GPUMaterial *mat, Material *ma)
-{
-	GPUNodeLink *outlink;
-	
-	/* some explanations here:
-	 * matcap normal holds the normal remapped to the 0.0 - 1.0 range. To take advantage of flat shading, we abuse
-	 * the built in secondary color of opengl. Color is just the regular color, which should include mask value too.
-	 * This also needs flat shading so we use the primary opengl color built-in */
-	GPU_link(mat, "material_preview_matcap", GPU_uniform(&ma->r), GPU_image_preview(ma->preview),
-	         GPU_opengl_builtin(GPU_MATCAP_NORMAL), GPU_opengl_builtin(GPU_COLOR), &outlink);
-	
-	return outlink;
-}
-
-/* new solid draw mode with glsl matcaps */
-GPUMaterial *GPU_material_matcap(Scene *scene, Material *ma, bool use_opensubdiv)
-{
-	GPUMaterial *mat;
-	GPUNodeLink *outlink;
-	LinkData *link;
-	
-	for (link = ma->gpumaterial.first; link; link = link->next) {
-		GPUMaterial *current_material = (GPUMaterial *)link->data;
-		if (current_material->scene == scene &&
-		    current_material->is_opensubdiv == use_opensubdiv)
-		{
-			return current_material;
-		}
-	}
-	
-	/* allocate material */
-	mat = GPU_material_construct_begin(ma);
-	mat->scene = scene;
-	mat->type = GPU_MATERIAL_TYPE_MESH;
-	mat->is_opensubdiv = use_opensubdiv;
-
-	if (ma->preview && ma->preview->rect[0]) {
-		outlink = gpu_material_preview_matcap(mat, ma);
-	}
-	else {
-		outlink = gpu_material_diffuse_bsdf(mat, ma);
-	}
-		
-	GPU_material_output_link(mat, outlink);
-
-	gpu_material_construct_end(mat, "matcap_pass");
-	
-	/* note that even if building the shader fails in some way, we still keep
-	 * it to avoid trying to compile again and again, and simple do not use
-	 * the actual shader on drawing */
-	
-	link = MEM_callocN(sizeof(LinkData), "GPUMaterialLink");
-	link->data = mat;
-	BLI_addtail(&ma->gpumaterial, link);
-	
-	return mat;
-}
-
-static void do_world_tex(GPUShadeInput *shi, struct World *wo, GPUNodeLink **hor, GPUNodeLink **zen, GPUNodeLink **blend)
-{
-	GPUMaterial *mat = shi->gpumat;
-	GPUNodeLink *texco, *tin, *trgb, *stencil, *tcol, *zenfac;
-	MTex *mtex;
-	Tex *tex;
-	float ofs[3], zero = 0.0f;
-	int tex_nr, rgbnor;
-
-	GPU_link(mat, "set_value_one", &stencil);
-	/* go over texture slots */
-	for (tex_nr = 0; tex_nr < MAX_MTEX; tex_nr++) {
-		if (wo->mtex[tex_nr]) {
-			mtex = wo->mtex[tex_nr];
-			tex = mtex->tex;
-			if (tex == NULL || !tex->ima || (tex->type != TEX_IMAGE && tex->type != TEX_ENVMAP))
-				continue;
-			/* which coords */
-			if (mtex->texco == TEXCO_VIEW || mtex->texco == TEXCO_GLOB) {
-				if (tex->type == TEX_IMAGE)
-					texco = GPU_builtin(GPU_VIEW_POSITION);
-				else if (tex->type == TEX_ENVMAP)
-					GPU_link(mat, "background_transform_to_world", GPU_builtin(GPU_VIEW_POSITION), &texco);
-			}
-			else if (mtex->texco == TEXCO_EQUIRECTMAP || mtex->texco == TEXCO_ANGMAP) {
-				if ((tex->type == TEX_IMAGE && wo->skytype & WO_SKYREAL) || tex->type == TEX_ENVMAP)
-					GPU_link(mat, "background_transform_to_world", GPU_builtin(GPU_VIEW_POSITION), &texco);
-				else
-					texco = GPU_builtin(GPU_VIEW_POSITION);
-			}
-			else
-				continue;
-			GPU_link(mat, "texco_norm", texco, &texco);
-			if (tex->type == TEX_IMAGE && !(wo->skytype & WO_SKYREAL)) {
-				GPU_link(mat, "mtex_2d_mapping", texco, &texco);
-			}
-			if (mtex->size[0] != 1.0f || mtex->size[1] != 1.0f || mtex->size[2] != 1.0f) {
-				float size[3] = { mtex->size[0], mtex->size[1], mtex->size[2] };
-				if (tex->type == TEX_ENVMAP) {
-					size[1] = mtex->size[2];
-					size[2] = mtex->size[1];
-				}
-				GPU_link(mat, "mtex_mapping_size", texco, GPU_uniform(size), &texco);
-			}
-			ofs[0] = mtex->ofs[0] + 0.5f - 0.5f * mtex->size[0];
-			if (tex->type == TEX_ENVMAP) {
-				ofs[1] = -mtex->ofs[2] + 0.5f - 0.5f * mtex->size[2];
-				ofs[2] = mtex->ofs[1] + 0.5f - 0.5f * mtex->size[1];
-			}
-			else {
-				ofs[1] = mtex->ofs[1] + 0.5f - 0.5f * mtex->size[1];
-				ofs[2] = 0.0;
-			}
-			if (ofs[0] != 0.0f || ofs[1] != 0.0f || ofs[2] != 0.0f)
-				GPU_link(mat, "mtex_mapping_ofs", texco, GPU_uniform(ofs), &texco);
-			if (mtex->texco == TEXCO_EQUIRECTMAP) {
-				GPU_link(mat, "node_tex_environment_equirectangular", texco, GPU_image(tex->ima, &tex->iuser, false), &trgb);
-			}
-			else if (mtex->texco == TEXCO_ANGMAP) {
-				GPU_link(mat, "node_tex_environment_mirror_ball", texco, GPU_image(tex->ima, &tex->iuser, false), &trgb);
-			}
-			else {
-				if (tex->type == TEX_ENVMAP)
-					GPU_link(mat, "mtex_cube_map", texco, GPU_cube_map(tex->ima, &tex->iuser, false), &tin, &trgb);
-				else if (tex->type == TEX_IMAGE)
-					GPU_link(mat, "mtex_image", texco, GPU_image(tex->ima, &tex->iuser, false), &tin, &trgb);
-			}
-			rgbnor = TEX_RGB;
-			if (tex->type == TEX_IMAGE || tex->type == TEX_ENVMAP)
-				if (GPU_material_do_color_management(mat))
-					GPU_link(mat, "srgb_to_linearrgb", trgb, &trgb);
-			/* texture output */
-			if ((rgbnor & TEX_RGB) && (mtex->texflag & MTEX_RGBTOINT)) {
-				GPU_link(mat, "mtex_rgbtoint", trgb, &tin);
-				rgbnor -= TEX_RGB;
-			}
-			if (mtex->texflag & MTEX_NEGATIVE) {
-				if (rgbnor & TEX_RGB)
-					GPU_link(mat, "mtex_rgb_invert", trgb, &trgb);
-				else
-					GPU_link(mat, "mtex_value_invert", tin, &tin);
-			}
-			if (mtex->texflag & MTEX_STENCIL) {
-				if (rgbnor & TEX_RGB)
-					GPU_link(mat, "mtex_rgb_stencil", stencil, trgb, &stencil, &trgb);
-				else
-					GPU_link(mat, "mtex_value_stencil", stencil, tin, &stencil, &tin);
-			}
-			else {
-				if (rgbnor & TEX_RGB)
-					GPU_link(mat, "mtex_alpha_multiply_value", trgb, stencil, &trgb);
-				else
-					GPU_link(mat, "math_multiply", stencil, tin, &tin);
-			}
-			/* color mapping */
-			if (mtex->mapto & (WOMAP_HORIZ + WOMAP_ZENUP + WOMAP_ZENDOWN)) {
-				if ((rgbnor & TEX_RGB) == 0)
-					GPU_link(mat, "set_rgb", GPU_uniform(&mtex->r), &trgb);
-				else
-					GPU_link(mat, "mtex_alpha_from_col", trgb, &tin);
-				GPU_link(mat, "set_rgb", trgb, &tcol);
-				if (mtex->mapto & WOMAP_HORIZ) {
-					texture_rgb_blend(mat, tcol, *hor, tin, GPU_uniform(&mtex->colfac), mtex->blendtype, hor);
-				}
-				if (mtex->mapto & (WOMAP_ZENUP + WOMAP_ZENDOWN)) {
-					GPU_link(mat, "set_value_zero", &zenfac);
-					if (wo->skytype & WO_SKYREAL) {
-						if (mtex->mapto & WOMAP_ZENUP) {
-							if (mtex->mapto & WOMAP_ZENDOWN) {
-								GPU_link(mat, "world_zen_mapping", shi->view, GPU_uniform(&mtex->zenupfac),
-								         GPU_uniform(&mtex->zendownfac), &zenfac);
-							}
-							else {
-								GPU_link(mat, "world_zen_mapping", shi->view, GPU_uniform(&mtex->zenupfac),
-								         GPU_uniform(&zero), &zenfac);
-							}
-						}
-						else if (mtex->mapto & WOMAP_ZENDOWN) {
-							GPU_link(mat, "world_zen_mapping", shi->view, GPU_uniform(&zero),
-							         GPU_uniform(&mtex->zendownfac), &zenfac);
-						}
-					}
-					else {
-						if (mtex->mapto & WOMAP_ZENUP)
-							GPU_link(mat, "set_value", GPU_uniform(&mtex->zenupfac), &zenfac);
-						else if (mtex->mapto & WOMAP_ZENDOWN)
-							GPU_link(mat, "set_value", GPU_uniform(&mtex->zendownfac), &zenfac);
-					}
-					texture_rgb_blend(mat, tcol, *zen, tin, zenfac, mtex->blendtype, zen);
-				}
-			}
-			if (mtex->mapto & WOMAP_BLEND && wo->skytype & WO_SKYBLEND) {
-				if (rgbnor & TEX_RGB)
-					GPU_link(mat, "mtex_rgbtoint", trgb, &tin);
-				texture_value_blend(mat, GPU_uniform(&mtex->def_var), *blend, tin, GPU_uniform(&mtex->blendfac), mtex->blendtype, blend);
-			}
-		}
-	}
-}
-
-static void gpu_material_old_world(struct GPUMaterial *mat, struct World *wo)
-{
-	GPUShadeInput shi;
-	GPUShadeResult shr;
-	GPUNodeLink *hor, *zen, *ray, *blend;
-
-	shi.gpumat = mat;
-
-	for (int i = 0; i < MAX_MTEX; i++) {
-		if (wo->mtex[i] && wo->mtex[i]->tex) {
-			wo->skytype |= WO_SKYTEX;
-			break;
-		}
-	}
-	if ((wo->skytype & (WO_SKYBLEND + WO_SKYTEX)) == 0) {
-		GPU_link(mat, "set_rgb", GPU_dynamic_uniform(&wo->horr, GPU_DYNAMIC_HORIZON_COLOR, NULL), &shr.combined);
-	}
-	else {
-		GPU_link(mat, "set_rgb_zero", &shi.rgb);
-		GPU_link(mat, "background_transform_to_world", GPU_builtin(GPU_VIEW_POSITION), &ray);
-		if (wo->skytype & WO_SKYPAPER)
-			GPU_link(mat, "world_paper_view", GPU_builtin(GPU_VIEW_POSITION), &shi.view);
-		else
-			GPU_link(mat, "shade_view", ray, &shi.view);
-		if (wo->skytype & WO_SKYBLEND) {
-			if (wo->skytype & WO_SKYPAPER) {
-				if (wo->skytype & WO_SKYREAL)
-					GPU_link(mat, "world_blend_paper_real", GPU_builtin(GPU_VIEW_POSITION), &blend);
-				else
-					GPU_link(mat, "world_blend_paper", GPU_builtin(GPU_VIEW_POSITION), &blend);
-			}
-			else {
-				if (wo->skytype & WO_SKYREAL)
-					GPU_link(mat, "world_blend_real", ray, &blend);
-				else
-					GPU_link(mat, "world_blend", ray, &blend);
-			}
-		}
-		else {
-			GPU_link(mat, "set_value_zero", &blend);
-		}
-		GPU_link(mat, "set_rgb", GPU_dynamic_uniform(&wo->horr, GPU_DYNAMIC_HORIZON_COLOR, NULL), &hor);
-		GPU_link(mat, "set_rgb", GPU_dynamic_uniform(&wo->zenr, GPU_DYNAMIC_ZENITH_COLOR, NULL), &zen);
-		do_world_tex(&shi, wo, &hor, &zen, &blend);
-		if (wo->skytype & WO_SKYBLEND)
-			GPU_link(mat, "node_mix_shader", blend, hor, zen, &shi.rgb);
-		else
-			GPU_link(mat, "set_rgb", hor, &shi.rgb);
-		GPU_link(mat, "set_rgb", shi.rgb, &shr.combined);
-	}
-	GPU_material_output_link(mat, shr.combined);
-}
-
-GPUMaterial *GPU_material_world(struct Scene *scene, struct World *wo)
-{
-	LinkData *link;
-	GPUMaterial *mat;
-
-	for (link = wo->gpumaterial.first; link; link = link->next)
-		if (((GPUMaterial *)link->data)->scene == scene)
-			return link->data;
-
-	/* allocate material */
-	mat = GPU_material_construct_begin(NULL);
-	mat->scene = scene;
-	mat->type = GPU_MATERIAL_TYPE_WORLD;
-	
-	/* create nodes */
-	if (BKE_scene_use_new_shading_nodes(scene) && wo->nodetree && wo->use_nodes) {
-		ntreeGPUMaterialNodes(wo->nodetree, mat, NODE_NEW_SHADING);
-	}
-	else {
-		gpu_material_old_world(mat, wo);
-	}
-
-	if (GPU_material_do_color_management(mat))
-		if (mat->outlink)
-			GPU_link(mat, "linearrgb_to_srgb", mat->outlink, &mat->outlink);
-
-	gpu_material_construct_end(mat, wo->id.name);
-	
-	/* note that even if building the shader fails in some way, we still keep
-	 * it to avoid trying to compile again and again, and simple do not use
-	 * the actual shader on drawing */
-
-	link = MEM_callocN(sizeof(LinkData), "GPUMaterialLink");
-	link->data = mat;
-	BLI_addtail(&wo->gpumaterial, link);
-
-	return mat;
-}
-
 GPUMaterial *GPU_material_from_nodetree_find(
         ListBase *gpumaterials, const void *engine_type, int options)
 {
@@ -2502,15 +598,12 @@ GPUMaterial *GPU_material_from_nodetree_find(
 }
 
 /**
- * TODO: This is supposed to replace GPU_material_from_blender/_world in the future
- *
  * \note Caller must use #GPU_material_from_nodetree_find to re-use existing materials,
  * This is enforced since constructing other arguments to this function may be expensive
  * so only do this when they are needed.
  */
 GPUMaterial *GPU_material_from_nodetree(
-        Scene *scene, struct bNodeTree *ntree, ListBase *gpumaterials, const void *engine_type, int options,
-        const char *vert_code, const char *geom_code, const char *frag_lib, const char *defines, bool deferred)
+        Scene *scene, struct bNodeTree *ntree, ListBase *gpumaterials, const void *engine_type, int options)
 {
 	LinkData *link;
 	bool has_volume_output, has_surface_output;
@@ -2534,10 +627,7 @@ GPUMaterial *GPU_material_from_nodetree(
 		mat->domain |= GPU_DOMAIN_VOLUME;
 	}
 
-	if (!deferred) {
-		GPU_material_generate_pass(mat, vert_code, geom_code, frag_lib, defines);
-	}
-	else if (mat->outlink) {
+	if (mat->outlink) {
 		/* Prune the unused nodes and extract attribs before compiling so the
 		 * generated VBOs are ready to accept the future shader. */
 		GPU_nodes_prune(&mat->nodes, mat->outlink);
@@ -2556,7 +646,6 @@ GPUMaterial *GPU_material_from_nodetree(
 	return mat;
 }
 
-/* Calls this function if /a mat was created with deferred compilation.  */
 void GPU_material_generate_pass(
         GPUMaterial *mat, const char *vert_code, const char *geom_code, const char *frag_lib, const char *defines)
 {
@@ -2571,74 +660,8 @@ void GPU_material_generate_pass(
 	}
 }
 
-GPUMaterial *GPU_material_from_blender(Scene *scene, Material *ma, bool use_opensubdiv)
-{
-	GPUMaterial *mat;
-	GPUNodeLink *outlink;
-	LinkData *link;
-
-	for (link = ma->gpumaterial.first; link; link = link->next) {
-		GPUMaterial *current_material = (GPUMaterial *)link->data;
-		if (current_material->scene == scene &&
-		    current_material->is_opensubdiv == use_opensubdiv)
-		{
-			return current_material;
-		}
-	}
-
-	/* allocate material */
-	mat = GPU_material_construct_begin(ma);
-	mat->scene = scene;
-	mat->type = GPU_MATERIAL_TYPE_MESH;
-	mat->is_opensubdiv = use_opensubdiv;
-
-	/* render pipeline option */
-	bool new_shading_nodes = BKE_scene_use_new_shading_nodes(scene);
-	if (!new_shading_nodes && (ma->mode & MA_TRANSP))
-		GPU_material_enable_alpha(mat);
-	else if (new_shading_nodes && ma->alpha < 1.0f)
-		GPU_material_enable_alpha(mat);
-
-	if (ma->nodetree && ma->use_nodes) {
-		/* create nodes */
-		if (new_shading_nodes)
-			ntreeGPUMaterialNodes(ma->nodetree, mat, NODE_NEW_SHADING);
-		else
-			ntreeGPUMaterialNodes(ma->nodetree, mat, NODE_OLD_SHADING);
-	}
-	else {
-		if (new_shading_nodes) {
-			/* create simple diffuse material instead of nodes */
-			outlink = gpu_material_diffuse_bsdf(mat, ma);
-		}
-		else {
-			/* create blender material */
-			outlink = GPU_blender_material(mat, ma);
-		}
-
-		GPU_material_output_link(mat, outlink);
-	}
-
-	if (GPU_material_do_color_management(mat))
-		if (mat->outlink)
-			GPU_link(mat, "linearrgb_to_srgb", mat->outlink, &mat->outlink);
-
-	gpu_material_construct_end(mat, ma->id.name);
-
-	/* note that even if building the shader fails in some way, we still keep
-	 * it to avoid trying to compile again and again, and simple do not use
-	 * the actual shader on drawing */
-
-	link = MEM_callocN(sizeof(LinkData), "GPUMaterialLink");
-	link->data = mat;
-	BLI_addtail(&ma->gpumaterial, link);
-
-	return mat;
-}
-
 void GPU_materials_free(void)
 {
-	Object *ob;
 	Material *ma;
 	World *wo;
 	extern Material defmaterial;
@@ -2650,307 +673,4 @@ void GPU_materials_free(void)
 		GPU_material_free(&wo->gpumaterial);
 	
 	GPU_material_free(&defmaterial.gpumaterial);
-
-	for (ob = G.main->object.first; ob; ob = ob->id.next)
-		GPU_lamp_free(ob);
-}
-
-/* Lamps and shadow buffers */
-
-GPUNodeLink *GPU_lamp_get_data(
-        GPUMaterial *mat, GPULamp *lamp,
-        GPUNodeLink **r_col, GPUNodeLink **r_lv, GPUNodeLink **r_dist, GPUNodeLink **r_shadow, GPUNodeLink **r_energy)
-{
-	GPUNodeLink *visifac;
-
-	*r_col = GPU_dynamic_uniform(lamp->dyncol, GPU_DYNAMIC_LAMP_DYNCOL, lamp->ob);
-	*r_energy = GPU_dynamic_uniform(&lamp->dynenergy, GPU_DYNAMIC_LAMP_DYNENERGY, lamp->ob);
-	visifac = lamp_get_visibility(mat, lamp, r_lv, r_dist);
-
-	shade_light_textures(mat, lamp, r_col);
-
-	if (GPU_lamp_has_shadow_buffer(lamp)) {
-		GPUNodeLink *vn, *inp;
-
-		GPU_link(mat, "shade_norm", GPU_builtin(GPU_VIEW_NORMAL), &vn);
-		GPU_link(mat, "shade_inp", vn, *r_lv, &inp);
-		mat->dynproperty |= DYN_LAMP_PERSMAT;
-
-		if (lamp->la->shadowmap_type == LA_SHADMAP_VARIANCE) {
-			GPU_link(mat, "shadows_only_vsm",
-			         GPU_builtin(GPU_VIEW_POSITION),
-			         GPU_dynamic_texture(lamp->tex, GPU_DYNAMIC_SAMPLER_2DSHADOW, lamp->ob),
-			         GPU_dynamic_uniform((float *)lamp->dynpersmat, GPU_DYNAMIC_LAMP_DYNPERSMAT, lamp->ob),
-			         GPU_uniform(&lamp->bias), GPU_uniform(&lamp->la->bleedbias),
-			         GPU_uniform(lamp->shadow_color), inp, r_shadow);
-		}
-		else {
-			GPU_link(mat, "shadows_only",
-			         GPU_builtin(GPU_VIEW_POSITION),
-			         GPU_dynamic_texture(lamp->tex, GPU_DYNAMIC_SAMPLER_2DSHADOW, lamp->ob),
-			         GPU_dynamic_uniform((float *)lamp->dynpersmat, GPU_DYNAMIC_LAMP_DYNPERSMAT, lamp->ob),
-			         GPU_uniform(&lamp->bias), GPU_uniform(lamp->shadow_color), inp, r_shadow);
-		}
-	}
-	else {
-		GPU_link(mat, "set_rgb_one", r_shadow);
-	}
-
-	/* ensure shadow buffer and lamp textures will be updated */
-	add_user_list(&mat->lamps, lamp);
-
-	return visifac;
-}
-
-/* export the GLSL shader */
-
-GPUShaderExport *GPU_shader_export(struct Scene *scene, struct Material *ma)
-{
-	static struct {
-		GPUBuiltin gputype;
-		GPUDynamicType dynamictype;
-		GPUDataType datatype;
-	} builtins[] = {
-		{ GPU_VIEW_MATRIX, GPU_DYNAMIC_OBJECT_VIEWMAT, GPU_DATA_16F },
-		{ GPU_INVERSE_VIEW_MATRIX, GPU_DYNAMIC_OBJECT_VIEWIMAT, GPU_DATA_16F },
-		{ GPU_OBJECT_MATRIX, GPU_DYNAMIC_OBJECT_MAT, GPU_DATA_16F },
-		{ GPU_INVERSE_OBJECT_MATRIX, GPU_DYNAMIC_OBJECT_IMAT, GPU_DATA_16F },
-		{ GPU_LOC_TO_VIEW_MATRIX, GPU_DYNAMIC_OBJECT_LOCTOVIEWMAT, GPU_DATA_16F },
-		{ GPU_INVERSE_LOC_TO_VIEW_MATRIX, GPU_DYNAMIC_OBJECT_LOCTOVIEWIMAT, GPU_DATA_16F },
-		{ GPU_OBCOLOR, GPU_DYNAMIC_OBJECT_COLOR, GPU_DATA_4F },
-		{ GPU_AUTO_BUMPSCALE, GPU_DYNAMIC_OBJECT_AUTOBUMPSCALE, GPU_DATA_1F },
-		{ 0 }
-	};
-
-	GPUShaderExport *shader = NULL;
-	GPUInput *input;
-	int liblen, fraglen;
-
-	/* TODO(sergey): How to determine whether we need OSD or not here? */
-	GPUMaterial *mat = GPU_material_from_blender(scene, ma, false);
-	GPUPass *pass = (mat) ? mat->pass : NULL;
-
-	if (pass && pass->fragmentcode && pass->vertexcode) {
-		shader = MEM_callocN(sizeof(GPUShaderExport), "GPUShaderExport");
-
-		for (input = mat->inputs.first; input; input = input->next) {
-			GPUInputUniform *uniform = MEM_callocN(sizeof(GPUInputUniform), "GPUInputUniform");
-
-			if (input->ima) {
-				/* image sampler uniform */
-				uniform->type = GPU_DYNAMIC_SAMPLER_2DIMAGE;
-				uniform->datatype = GPU_DATA_1I;
-				uniform->image = input->ima;
-				uniform->texnumber = input->texid;
-				BLI_strncpy(uniform->varname, input->shadername, sizeof(uniform->varname));
-			}
-			else if (input->tex) {
-				/* generated buffer */
-				uniform->texnumber = input->texid;
-				uniform->datatype = GPU_DATA_1I;
-				BLI_strncpy(uniform->varname, input->shadername, sizeof(uniform->varname));
-
-				switch (input->textype) {
-					case GPU_SHADOW2D:
-						uniform->type = GPU_DYNAMIC_SAMPLER_2DSHADOW;
-						uniform->lamp = input->dynamicdata;
-						break;
-					case GPU_TEX2D:
-						if (GPU_texture_opengl_bindcode(input->tex)) {
-							uniform->type = GPU_DYNAMIC_SAMPLER_2DBUFFER;
-							glBindTexture(GL_TEXTURE_2D, GPU_texture_opengl_bindcode(input->tex));
-							uniform->texsize = GPU_texture_width(input->tex) * GPU_texture_height(input->tex);
-							uniform->texpixels = MEM_mallocN(uniform->texsize * 4, "RGBApixels");
-							glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, uniform->texpixels);
-							glBindTexture(GL_TEXTURE_2D, 0);
-						}
-						break;
-
-					case GPU_NONE:
-					case GPU_TEX3D:
-					case GPU_TEXCUBE:
-					case GPU_FLOAT:
-					case GPU_VEC2:
-					case GPU_VEC3:
-					case GPU_VEC4:
-					case GPU_MAT3:
-					case GPU_MAT4:
-					case GPU_CLOSURE:
-					case GPU_ATTRIB:
-						break;
-				}
-			}
-			else {
-				uniform->type = input->dynamictype;
-				BLI_strncpy(uniform->varname, input->shadername, sizeof(uniform->varname));
-				switch (input->type) {
-					case GPU_FLOAT:
-						uniform->datatype = GPU_DATA_1F;
-						break;
-					case GPU_VEC2:
-						uniform->datatype = GPU_DATA_2F;
-						break;
-					case GPU_VEC3:
-						uniform->datatype = GPU_DATA_3F;
-						break;
-					case GPU_VEC4:
-						uniform->datatype = GPU_DATA_4F;
-						break;
-					case GPU_MAT3:
-						uniform->datatype = GPU_DATA_9F;
-						break;
-					case GPU_MAT4:
-						uniform->datatype = GPU_DATA_16F;
-						break;
-
-					case GPU_NONE:
-					case GPU_CLOSURE:
-					case GPU_TEX2D:
-					case GPU_TEX3D:
-					case GPU_TEXCUBE:
-					case GPU_SHADOW2D:
-					case GPU_ATTRIB:
-						break;
-				}
-
-				if (GPU_DYNAMIC_GROUP_FROM_TYPE(uniform->type) == GPU_DYNAMIC_GROUP_LAMP)
-					uniform->lamp = input->dynamicdata;
-
-				if (GPU_DYNAMIC_GROUP_FROM_TYPE(uniform->type) == GPU_DYNAMIC_GROUP_MAT)
-					uniform->material = input->dynamicdata;
-			}
-
-			if (uniform->type != GPU_DYNAMIC_NONE)
-				BLI_addtail(&shader->uniforms, uniform);
-			else
-				MEM_freeN(uniform);
-		}
-
-		/* process builtin uniform */
-		for (int i = 0; builtins[i].gputype; i++) {
-			if (mat->builtins & builtins[i].gputype) {
-				GPUInputUniform *uniform = MEM_callocN(sizeof(GPUInputUniform), "GPUInputUniform");
-				uniform->type = builtins[i].dynamictype;
-				uniform->datatype = builtins[i].datatype;
-				BLI_strncpy(uniform->varname, GPU_builtin_name(builtins[i].gputype), sizeof(uniform->varname));
-				BLI_addtail(&shader->uniforms, uniform);
-			}
-		}
-
-		/* now link fragment shader with library shader */
-		/* TBD: remove the function that are not used in the main function */
-		liblen = (pass->libcode) ? strlen(pass->libcode) : 0;
-		fraglen = strlen(pass->fragmentcode);
-		shader->fragment = (char *)MEM_mallocN(liblen + fraglen + 1, "GPUFragShader");
-		if (pass->libcode)
-			memcpy(shader->fragment, pass->libcode, liblen);
-		memcpy(&shader->fragment[liblen], pass->fragmentcode, fraglen);
-		shader->fragment[liblen + fraglen] = 0;
-
-		// export the attribute
-		for (int i = 0; i < mat->attribs.totlayer; i++) {
-			GPUInputAttribute *attribute = MEM_callocN(sizeof(GPUInputAttribute), "GPUInputAttribute");
-			attribute->type = mat->attribs.layer[i].type;
-			attribute->number = mat->attribs.layer[i].glindex;
-			BLI_snprintf(attribute->varname, sizeof(attribute->varname), "att%d", mat->attribs.layer[i].attribid);
-
-			switch (attribute->type) {
-				case CD_TANGENT:
-					attribute->datatype = GPU_DATA_4F;
-					break;
-				case CD_MTFACE:
-					attribute->datatype = GPU_DATA_2F;
-					attribute->name = mat->attribs.layer[i].name;
-					break;
-				case CD_MCOL:
-					attribute->datatype = GPU_DATA_4UB;
-					attribute->name = mat->attribs.layer[i].name;
-					break;
-				case CD_ORCO:
-					attribute->datatype = GPU_DATA_3F;
-					break;
-			}
-
-			if (attribute->datatype != GPU_DATA_NONE)
-				BLI_addtail(&shader->attributes, attribute);
-			else
-				MEM_freeN(attribute);
-		}
-
-		/* export the vertex shader */
-		shader->vertex = BLI_strdup(pass->vertexcode);
-	}
-
-	return shader;
-}
-
-void GPU_free_shader_export(GPUShaderExport *shader)
-{
-	if (shader == NULL)
-		return;
-
-	for (GPUInputUniform *uniform = shader->uniforms.first; uniform; uniform = uniform->next)
-		if (uniform->texpixels)
-			MEM_freeN(uniform->texpixels);
-
-	BLI_freelistN(&shader->uniforms);
-	BLI_freelistN(&shader->attributes);
-
-	if (shader->vertex)
-		MEM_freeN(shader->vertex);
-	if (shader->fragment)
-		MEM_freeN(shader->fragment);
-
-	MEM_freeN(shader);
 }
-
-#ifdef WITH_OPENSUBDIV
-void GPU_material_update_fvar_offset(GPUMaterial *gpu_material,
-                                     DerivedMesh *dm)
-{
-	GPUPass *pass = gpu_material->pass;
-	GPUShader *shader = (pass != NULL ? pass->shader : NULL);
-	ListBase *inputs = (pass != NULL ? &gpu_material->inputs : NULL);
-	GPUInput *input;
-
-	if (shader == NULL) {
-		return;
-	}
-
-	GPU_shader_bind(shader);
-
-	for (input = inputs->first;
-	     input != NULL;
-	     input = input->next)
-	{
-		if (input->source == GPU_SOURCE_ATTRIB &&
-		    input->attribtype == CD_MTFACE)
-		{
-			char name[64];
-			/* TODO(sergey): This will work for until names are
-			 * consistent, we'll need to solve this somehow in the future.
-			 */
-			int layer_index;
-			int location;
-
-			if (input->attribname[0] != '\0') {
-				layer_index = CustomData_get_named_layer(&dm->loopData,
-				                                         CD_MLOOPUV,
-				                                         input->attribname);
-			}
-			else {
-				layer_index = CustomData_get_active_layer(&dm->loopData,
-				                                          CD_MLOOPUV);
-			}
-
-			BLI_snprintf(name, sizeof(name),
-			             "fvar%d_offset",
-			             input->attribid);
-			location = GPU_shader_get_uniform(shader, name);
-			GPU_shader_uniform_int(shader, location, layer_index);
-		}
-	}
-
-	GPU_shader_unbind();
-}
-#endif
diff --git a/source/blender/gpu/intern/gpu_shader.c b/source/blender/gpu/intern/gpu_shader.c
index 319305fc02b..f88b00dfb93 100644
--- a/source/blender/gpu/intern/gpu_shader.c
+++ b/source/blender/gpu/intern/gpu_shader.c
@@ -213,8 +213,7 @@ static void gpu_shader_standard_extensions(char defines[MAX_EXT_DEFINE_LENGTH])
 }
 
 static void gpu_shader_standard_defines(char defines[MAX_DEFINE_LENGTH],
-                                        bool use_opensubdiv,
-                                        bool use_new_shading)
+                                        bool use_opensubdiv)
 {
 	/* some useful defines to detect GPU type */
 	if (GPU_type_matches(GPU_DEVICE_ATI, GPU_OS_ANY, GPU_DRIVER_ANY)) {
@@ -253,10 +252,6 @@ static void gpu_shader_standard_defines(char defines[MAX_DEFINE_LENGTH],
 	UNUSED_VARS(use_opensubdiv);
 #endif
 
-	if (use_new_shading) {
-		strcat(defines, "#define USE_NEW_SHADING\n");
-	}
-
 	return;
 }
 
@@ -364,8 +359,7 @@ GPUShader *GPU_shader_create_ex(const char *vertexcode,
 	}
 
 	gpu_shader_standard_defines(standard_defines,
-	                            use_opensubdiv,
-	                            (flags & GPU_SHADER_FLAGS_NEW_SHADING) != 0);
+	                            use_opensubdiv);
 	gpu_shader_standard_extensions(standard_extensions);
 
 	if (vertexcode) {
diff --git a/source/blender/gpu/shaders/gpu_shader_geometry.glsl b/source/blender/gpu/shaders/gpu_shader_geometry.glsl
index 7586050b258..705b79cbf56 100644
--- a/source/blender/gpu/shaders/gpu_shader_geometry.glsl
+++ b/source/blender/gpu/shaders/gpu_shader_geometry.glsl
@@ -32,17 +32,12 @@ uniform int osd_fvar_count;
 		             tessCoord.t); \
 	}
 
-#ifdef USE_NEW_SHADING
 #  define INTERP_FACE_VARYING_ATT_2(result, fvarOffset, tessCoord) \
 	{ \
 		vec2 tmp; \
 		INTERP_FACE_VARYING_2(tmp, fvarOffset, tessCoord); \
 		result = vec3(tmp, 0); \
 	}
-#else
-#  define INTERP_FACE_VARYING_ATT_2(result, fvarOffset, tessCoord) \
-	INTERP_FACE_VARYING_2(result, fvarOffset, tessCoord)
-#endif
 
 uniform samplerBuffer FVarDataBuffer;
 uniform isamplerBuffer FVarDataOffsetBuffer;
diff --git a/source/blender/gpu/shaders/gpu_shader_material.glsl b/source/blender/gpu/shaders/gpu_shader_material.glsl
index d3bc1f0ef8e..5eac8ca8f51 100644
--- a/source/blender/gpu/shaders/gpu_shader_material.glsl
+++ b/source/blender/gpu/shaders/gpu_shader_material.glsl
@@ -41,11 +41,7 @@ Closure nodetree_exec(void); /* Prototype */
 
 float convert_rgba_to_float(vec4 color)
 {
-#ifdef USE_NEW_SHADING
 	return dot(color.rgb, vec3(0.2126, 0.7152, 0.0722));
-#else
-	return (color.r + color.g + color.b) * 0.333333;
-#endif
 }
 
 float exp_blender(float f)
@@ -866,11 +862,7 @@ void valtorgb(float fac, sampler2D colormap, out vec4 outcol, out float outalpha
 
 void rgbtobw(vec4 color, out float outval)
 {
-#ifdef USE_NEW_SHADING
 	vec3 factors = vec3(0.2126, 0.7152, 0.0722);
-#else
-	vec3 factors = vec3(0.35, 0.45, 0.2); /* keep these factors in sync with texture.h:RGBTOBW */
-#endif
 	outval = dot(color.rgb, factors);
 }
 
diff --git a/source/blender/gpu/shaders/gpu_shader_vertex.glsl b/source/blender/gpu/shaders/gpu_shader_vertex.glsl
index 4ebd10d514f..2a6c137e195 100644
--- a/source/blender/gpu/shaders/gpu_shader_vertex.glsl
+++ b/source/blender/gpu/shaders/gpu_shader_vertex.glsl
@@ -47,11 +47,7 @@ void srgb_to_linearrgb(vec4 col_from, out vec4 col_to)
 
 bool is_srgb(int info)
 {
-#ifdef USE_NEW_SHADING
 	return (info == 1)? true: false;
-#else
-	return false;
-#endif
 }
 
 void set_var_from_attr(float attr, int info, out float var)
diff --git a/source/blender/gpu/shaders/gpu_shader_vertex_world.glsl b/source/blender/gpu/shaders/gpu_shader_vertex_world.glsl
index 89a2f391a12..af2e4ba19a2 100644
--- a/source/blender/gpu/shaders/gpu_shader_vertex_world.glsl
+++ b/source/blender/gpu/shaders/gpu_shader_vertex_world.glsl
@@ -29,11 +29,7 @@ void srgb_to_linearrgb(vec4 col_from, out vec4 col_to)
 
 bool is_srgb(int info)
 {
-#ifdef USE_NEW_SHADING
 	return (info == 1)? true: false;
-#else
-	return false;
-#endif
 }
 
 void set_var_from_attr(float attr, int info, out float var)
author	Ton Roosendaal <ton@blender.org>	2018-04-19 18:34:44 +0300
committer	Brecht Van Lommel <brechtvanlommel@gmail.com>	2018-04-19 18:35:25 +0300
commit	51b796ff1528c52cc8b4079fab1003671652a4d9 (patch)
tree	0dfc2d2dabe5e77959264f5b6667897569290a41 /source/blender/gpu
parent	785e8a636a293941a4295e669cb5aeecfafae039 (diff)