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

1872 lines
54 KiB
C
Raw Blame History

/*
* ***** 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.
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/gpu/intern/gpu_material.c
* \ingroup gpu
*/
#include <math.h>
#include <string.h>
#include "GL/glew.h"
#include "MEM_guardedalloc.h"
#include "DNA_lamp_types.h"
#include "DNA_material_types.h"
#include "DNA_object_types.h"
#include "DNA_scene_types.h"
#include "DNA_world_types.h"
#include "BLI_math.h"
#include "BLI_blenlib.h"
#include "BLI_utildefines.h"
#include "BKE_anim.h"
#include "BKE_colortools.h"
#include "BKE_DerivedMesh.h"
#include "BKE_global.h"
#include "BKE_image.h"
#include "BKE_main.h"
#include "BKE_node.h"
#include "BKE_scene.h"
#include "BKE_texture.h"
#include "IMB_imbuf_types.h"
#include "GPU_extensions.h"
#include "GPU_material.h"
#include "gpu_codegen.h"
#include <string.h>
/* Structs */
typedef enum DynMatProperty {
DYN_LAMP_CO = 1,
DYN_LAMP_VEC = 2,
DYN_LAMP_IMAT = 4,
DYN_LAMP_PERSMAT = 8,
} DynMatProperty;
struct GPUMaterial {
Scene *scene;
Material *ma;
/* for creating the material */
ListBase nodes;
GPUNodeLink *outlink;
/* for binding the material */
GPUPass *pass;
GPUVertexAttribs attribs;
int bound;
int builtins;
int alpha, obcolalpha;
int dynproperty;
/* for passing uniforms */
int viewmatloc, invviewmatloc;
int obmatloc, invobmatloc;
int obcolloc;
ListBase lamps;
};
struct GPULamp {
Scene *scene;
Object *ob;
Object *par;
Lamp *la;
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 dist, att1, att2;
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;
GPUTexture *tex;
ListBase materials;
};
/* 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;
GPUShader *shader;
GPUPass *pass;
char name[32];
int a, b;
attribs= &material->attribs;
pass= material->pass;
if(!pass) {
attribs->totlayer = 0;
return;
}
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 */
for(a=0, b=0; a<attribs->totlayer; a++) {
sprintf(name, "att%d", attribs->layer[a].attribid);
attribs->layer[a].glindex = GPU_shader_get_attribute(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)
{
if (material->outlink) {
GPUNodeLink *outlink;
GPUShader *shader;
outlink = material->outlink;
material->pass = GPU_generate_pass(&material->nodes, outlink,
&material->attribs, &material->builtins, material->ma->id.name);
if(!material->pass)
return 0;
gpu_material_set_attrib_id(material);
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_OBCOLOR)
material->obcolloc = GPU_shader_get_uniform(shader, GPU_builtin_name(GPU_OBCOLOR));
return 1;
}
return 0;
}
void GPU_material_free(Material *ma)
{
LinkData *link;
LinkData *nlink, *mlink, *next;
for(link=ma->gpumaterial.first; link; link=link->next) {
GPUMaterial *material = link->data;
if(material->pass)
GPU_pass_free(material->pass);
for(nlink=material->lamps.first; nlink; nlink=nlink->next) {
GPULamp *lamp = nlink->data;
for(mlink=lamp->materials.first; mlink; mlink=next) {
next = mlink->next;
if(mlink->data == ma)
BLI_freelinkN(&lamp->materials, mlink);
}
}
BLI_freelistN(&material->lamps);
MEM_freeN(material);
}
BLI_freelistN(&ma->gpumaterial);
}
void GPU_material_bind(GPUMaterial *material, int oblay, int viewlay, double time, int mipmap)
{
if(material->pass) {
LinkData *nlink;
GPULamp *lamp;
/* handle layer lamps */
for(nlink=material->lamps.first; nlink; nlink=nlink->next) {
lamp= nlink->data;
if(!lamp->hide && (lamp->lay & viewlay) && (!(lamp->mode & LA_LAYER) || (lamp->lay & oblay))) {
lamp->dynenergy = lamp->energy;
VECCOPY(lamp->dyncol, lamp->col);
}
else {
lamp->dynenergy = 0.0f;
lamp->dyncol[0]= lamp->dyncol[1]= lamp->dyncol[2] = 0.0f;
}
}
GPU_pass_bind(material->pass, time, mipmap);
material->bound = 1;
}
}
void GPU_material_bind_uniforms(GPUMaterial *material, float obmat[][4], float viewmat[][4], float viewinv[][4], float obcol[4])
{
if(material->pass) {
GPUShader *shader = GPU_pass_shader(material->pass);
LinkData *nlink;
GPULamp *lamp;
float invmat[4][4], col[4];
/* handle builtins */
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_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_OBCOLOR) {
copy_v4_v4(col, obcol);
CLAMP(col[3], 0.0f, 1.0f);
GPU_shader_uniform_vector(shader, material->obcolloc, 4, 1, col);
}
/* update lamps */
for(nlink=material->lamps.first; nlink; nlink=nlink->next) {
lamp= nlink->data;
if(material->dynproperty & DYN_LAMP_VEC) {
VECCOPY(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) {
VECCOPY(lamp->dynco, lamp->co);
mul_m4_v3(viewmat, lamp->dynco);
}
if(material->dynproperty & DYN_LAMP_IMAT)
mul_m4_m4m4(lamp->dynimat, viewinv, lamp->imat);
if(material->dynproperty & DYN_LAMP_PERSMAT)
mul_m4_m4m4(lamp->dynpersmat, viewinv, lamp->persmat);
}
GPU_pass_update_uniforms(material->pass);
}
}
void GPU_material_unbind(GPUMaterial *material)
{
if (material->pass) {
material->bound = 0;
GPU_pass_unbind(material->pass);
}
}
int GPU_material_bound(GPUMaterial *material)
{
return material->bound;
}
void GPU_material_vertex_attributes(GPUMaterial *material, GPUVertexAttribs *attribs)
{
*attribs = material->attribs;
}
void GPU_material_output_link(GPUMaterial *material, GPUNodeLink *link)
{
if(!material->outlink)
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);
}
/* Code generation */
static int gpu_do_color_management(GPUMaterial *mat)
{
return ((mat->scene->r.color_mgt_flag & R_COLOR_MANAGEMENT) &&
!((mat->scene->gm.flag & GAME_GLSL_NO_COLOR_MANAGEMENT)));
}
static GPUNodeLink *lamp_get_visibility(GPUMaterial *mat, GPULamp *lamp, GPUNodeLink **lv, GPUNodeLink **dist)
{
GPUNodeLink *visifac, *inpr;
/* 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_uniform(&lamp->dist), *dist, &visifac);
break;
case LA_FALLOFF_INVSQUARE:
GPU_link(mat, "lamp_falloff_invsquare", GPU_uniform(&lamp->dist), *dist, &visifac);
break;
case LA_FALLOFF_SLIDERS:
GPU_link(mat, "lamp_falloff_sliders", GPU_uniform(&lamp->dist), GPU_uniform(&lamp->att1), GPU_uniform(&lamp->att2), *dist, &visifac);
break;
case LA_FALLOFF_CURVE:
{
float *array;
int size;
curvemapping_table_RGBA(lamp->curfalloff, &array, &size);
GPU_link(mat, "lamp_falloff_curve", GPU_uniform(&lamp->dist), GPU_texture(size, array), *dist, &visifac);
}
break;
}
if(lamp->mode & LA_SPHERE)
GPU_link(mat, "lamp_visibility_sphere", GPU_uniform(&lamp->dist), *dist, visifac, &visifac);
if(lamp->type == LA_SPOT) {
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), *lv, &inpr);
}
else {
mat->dynproperty |= DYN_LAMP_VEC;
GPU_link(mat, "lamp_visibility_spot_circle", GPU_dynamic_uniform(lamp->dynvec, GPU_DYNAMIC_LAMP_DYNVEC, lamp->ob), *lv, &inpr);
}
GPU_link(mat, "lamp_visibility_spot", GPU_uniform(&lamp->spotsi), GPU_uniform(&lamp->spotbl), 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.5*lar->area_size, ysize= 0.5*lar->area_sizey, multifac;
/* make it smaller, so area light can be multisampled */
multifac= 1.0f/sqrt((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.0*xsize*ysize);
}
#endif
static void ramp_blend(GPUMaterial *mat, GPUNodeLink *fac, GPUNodeLink *col1, GPUNodeLink *col2, int type, GPUNodeLink **outcol)
{
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, outcol);
}
static void do_colorband_blend(GPUMaterial *mat, ColorBand *coba, GPUNodeLink *fac, float rampfac, int type, GPUNodeLink *incol, GPUNodeLink **outcol)
{
GPUNodeLink *tmp, *alpha, *col;
float *array;
int size;
/* do colorband */
colorband_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, outcol);
}
static void ramp_diffuse_result(GPUShadeInput *shi, GPUNodeLink **diff)
{
Material *ma= shi->mat;
GPUMaterial *mat= shi->gpumat;
GPUNodeLink *fac;
if(!(mat->scene->gm.flag & GAME_GLSL_NO_RAMPS)) {
if(ma->ramp_col) {
if(ma->rampin_col==MA_RAMP_IN_RESULT) {
GPU_link(mat, "ramp_rgbtobw", *diff, &fac);
/* colorband + blend */
do_colorband_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 **diff)
{
GPUNodeLink *fac, *tmp, *addcol;
if(!(mat->scene->gm.flag & GAME_GLSL_NO_RAMPS) &&
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 */
do_colorband_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_clamped", *diff, rgb, addcol, diff);
}
static void ramp_spec_result(GPUShadeInput *shi, GPUNodeLink **spec)
{
Material *ma= shi->mat;
GPUMaterial *mat= shi->gpumat;
GPUNodeLink *fac;
if(!(mat->scene->gm.flag & GAME_GLSL_NO_RAMPS) &&
ma->ramp_spec && ma->rampin_spec==MA_RAMP_IN_RESULT) {
GPU_link(mat, "ramp_rgbtobw", *spec, &fac);
/* colorband + blend */
do_colorband_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 */
do_colorband_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_one_light(GPUShadeInput *shi, GPUShadeResult *shr, GPULamp *lamp)
{
Material *ma= shi->mat;
GPUMaterial *mat= shi->gpumat;
GPUNodeLink *lv, *dist, *visifac, *is, *inp, *i, *vn, *view;
GPUNodeLink *outcol, *specfac, *t, *shadfac= NULL;
float one = 1.0f;
if((lamp->mode & LA_ONLYSHADOW) && !(ma->mode & MA_SHADOW))
return;
vn= shi->vn;
view= shi->view;
visifac= lamp_get_visibility(mat, lamp, &lv, &dist);
/*if(ma->mode & MA_TANGENT_V)
GPU_link(mat, "shade_tangent_v", lv, GPU_attribute(CD_TANGENT, ""), &vn);*/
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(!(mat->scene->gm.flag & GAME_GLSL_NO_SHADERS)) {
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(!(mat->scene->gm.flag & GAME_GLSL_NO_SHADERS))
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);
/*if(ma->mode & MA_TANGENT_VN)
GPU_link(mat, "shade_tangent_v_spec", GPU_attribute(CD_TANGENT, ""), &vn);*/
/* 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) && GPU_lamp_has_shadow_buffer(lamp)) {
if(!(mat->scene->gm.flag & GAME_GLSL_NO_SHADOWS)) {
mat->dynproperty |= DYN_LAMP_PERSMAT;
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) {
GPU_link(mat, "shade_only_shadow", i, shadfac,
GPU_dynamic_uniform(&lamp->dynenergy, GPU_DYNAMIC_LAMP_DYNENERGY, lamp->ob), &shadfac);
if(!(lamp->mode & LA_NO_DIFF))
GPU_link(mat, "shade_only_shadow_diffuse", shadfac, shi->rgb,
shr->diff, &shr->diff);
if(!(lamp->mode & LA_NO_SPEC))
GPU_link(mat, "shade_only_shadow_specular", shadfac, shi->specrgb,
shr->spec, &shr->spec);
add_user_list(&mat->lamps, lamp);
add_user_list(&lamp->materials, shi->gpumat->ma);
return;
}
GPU_link(mat, "math_multiply", i, shadfac, &i);
}
}
else if((mat->scene->gm.flag & GAME_GLSL_NO_SHADOWS) && (lamp->mode & LA_ONLYSHADOW)) {
add_user_list(&mat->lamps, lamp);
add_user_list(&lamp->materials, shi->gpumat->ma);
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, GPU_dynamic_uniform(lamp->dyncol, GPU_DYNAMIC_LAMP_DYNCOL, lamp->ob), &rgb);
add_to_diffuse(mat, ma, shi, is, rgb, &shr->diff);
}
}
if(mat->scene->gm.flag & GAME_GLSL_NO_SHADERS);
else 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, GPU_dynamic_uniform(lamp->dyncol, GPU_DYNAMIC_LAMP_DYNCOL, lamp->ob), 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, GPU_dynamic_uniform(lamp->dyncol, GPU_DYNAMIC_LAMP_DYNCOL, lamp->ob), spec, &outcol);
GPU_link(mat, "shade_add_clamped", shr->spec, outcol, &shr->spec);
}
else {
GPU_link(mat, "shade_add_spec", t, GPU_dynamic_uniform(lamp->dyncol, GPU_DYNAMIC_LAMP_DYNCOL, lamp->ob), shi->specrgb, &outcol);
GPU_link(mat, "shade_add_clamped", shr->spec, outcol, &shr->spec);
}
}
}
add_user_list(&mat->lamps, lamp);
add_user_list(&lamp->materials, shi->gpumat->ma);
}
static void material_lights(GPUShadeInput *shi, GPUShadeResult *shr)
{
Base *base;
Object *ob;
Scene *sce_iter;
GPULamp *lamp;
for(SETLOOPER(shi->gpumat->scene, sce_iter, base)) {
ob= base->object;
if(ob->type==OB_LAMP) {
lamp = GPU_lamp_from_blender(shi->gpumat->scene, ob, NULL);
if(lamp)
shade_one_light(shi, shr, lamp);
}
if (ob->transflag & OB_DUPLI) {
DupliObject *dob;
ListBase *lb = object_duplilist(shi->gpumat->scene, ob);
for(dob=lb->first; dob; dob=dob->next) {
Object *ob_iter = dob->ob;
if(ob_iter->type==OB_LAMP) {
copy_m4_m4(ob_iter->obmat, dob->mat);
lamp = GPU_lamp_from_blender(shi->gpumat->scene, ob_iter, ob);
if(lamp)
shade_one_light(shi, shr, lamp);
}
}
free_object_duplilist(lb);
}
}
}
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;
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;
/*char *lastuvname = NULL;*/ /*UNUSED*/
float one = 1.0f, norfac, ofs[3];
int tex_nr, rgbnor, talpha;
int init_done = 0, iBumpSpacePrev = 0; /* Not necessary, quiting gcc warning. */
GPUNodeLink *vNorg, *vNacc, *fPrevMagnitude;
int iFirstTimeNMap=1;
int found_deriv_map = 0;
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);
//GPU_link(mat, "texco_tangent", GPU_attribute(CD_TANGENT, ""), &texco_tangent);
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(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);
ofs[0] = mtex->ofs[0] + 0.5f - 0.5f*mtex->size[0];
ofs[1] = mtex->ofs[1] + 0.5f - 0.5f*mtex->size[1];
ofs[2] = 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;
rgbnor = 0;
if(tex && tex->type == TEX_IMAGE && tex->ima) {
GPU_link(mat, "mtex_image", texco, GPU_image(tex->ima, &tex->iuser), &tin, &trgb);
rgbnor= TEX_RGB;
if(tex->imaflag & TEX_USEALPHA)
talpha= 1;
}
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)) {
/* 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)
if(gpu_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(!(mat->scene->gm.flag & GAME_GLSL_NO_EXTRA_TEX) && (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(!(mat->scene->gm.flag & GAME_GLSL_NO_EXTRA_TEX) && (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), &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
newnor = tnor;
norfac = MIN2(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( (mtex->texflag & (MTEX_3TAP_BUMP|MTEX_5TAP_BUMP)) || found_deriv_map) {
/* ntap bumpmap image */
int iBumpSpace;
float ima_x, ima_y;
float hScale = 0.1f; // compatibility adjustment factor for all bumpspace types
float hScaleTex = 13.0f; // factor for scaling texspace bumps
float imag_tspace_dimension_x = 1024.0f; // only used for texture space variant
float aspect = 1.0f;
GPUNodeLink *surf_pos = GPU_builtin(GPU_VIEW_POSITION);
GPUNodeLink *vR1, *vR2;
GPUNodeLink *dBs, *dBt, *fDet;
if( mtex->texflag & MTEX_BUMP_TEXTURESPACE )
hScale = hScaleTex;
// 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.
norfac = -hScale * mtex->norfac;
tnorfac = GPU_uniform(&norfac);
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 = 1;
}
// 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 ) {
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;
}
// resolve texture resolution
if( (mtex->texflag & MTEX_BUMP_TEXTURESPACE) || found_deriv_map ) {
ImBuf *ibuf= BKE_image_get_ibuf(tex->ima, &tex->iuser);
ima_x= 512.0f; ima_y= 512.f; // prevent calling textureSize, glsl 1.3 only
if(ibuf) {
ima_x= ibuf->x;
ima_y= ibuf->y;
aspect = ((float) ima_y) / ima_x;
}
}
if(found_deriv_map) {
GPU_link( mat, "mtex_bump_deriv",
texco, GPU_image(tex->ima, &tex->iuser), 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), tnorfac,
&dBs, &dBt );
else
GPU_link( mat, "mtex_bump_tap5",
texco, GPU_image(tex->ima, &tex->iuser), 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), 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(!(mat->scene->gm.flag & GAME_GLSL_NO_EXTRA_TEX) && 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(!(mat->scene->gm.flag & GAME_GLSL_NO_EXTRA_TEX) && 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(!(mat->scene->gm.flag & GAME_GLSL_NO_EXTRA_TEX) && 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(!(mat->scene->gm.flag & GAME_GLSL_NO_EXTRA_TEX) && 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(!(mat->scene->gm.flag & GAME_GLSL_NO_EXTRA_TEX) && 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 hard = ma->har;
memset(shi, 0, sizeof(*shi));
shi->gpumat = mat;
shi->mat = ma;
GPU_link(mat, "set_rgb", GPU_uniform(&ma->r), &shi->rgb);
GPU_link(mat, "set_rgb", GPU_uniform(&ma->specr), &shi->specrgb);
GPU_link(mat, "shade_norm", GPU_builtin(GPU_VIEW_NORMAL), &shi->vn);
GPU_link(mat, "set_value", GPU_uniform(&ma->alpha), &shi->alpha);
GPU_link(mat, "set_value", GPU_uniform(&ma->ref), &shi->refl);
GPU_link(mat, "set_value", GPU_uniform(&ma->spec), &shi->spec);
GPU_link(mat, "set_value", GPU_uniform(&ma->emit), &shi->emit);
GPU_link(mat, "set_value", GPU_uniform(&hard), &shi->har);
GPU_link(mat, "set_value", GPU_uniform(&ma->amb), &shi->amb);
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_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_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, misttype;
memset(shr, 0, sizeof(*shr));
if(ma->mode & MA_VERTEXCOLP)
shi->rgb = shi->vcol;
do_material_tex(shi);
if((ma->mode & MA_TRANSP) && (ma->mode & MA_ZTRANSP))
GPU_material_enable_alpha(mat);
if((mat->scene->gm.flag & GAME_GLSL_NO_LIGHTS) || (ma->mode & MA_SHLESS)) {
shr->combined = shi->rgb;
shr->alpha = shi->alpha;
GPU_link(mat, "set_rgb", shi->rgb, &shr->diff);
GPU_link(mat, "set_rgb_zero", &shr->spec);
}
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;
shr->alpha = shi->alpha;
if(world) {
/* exposure correction */
if(world->exp!=0.0f || world->range!=1.0f) {
linfac= 1.0 + pow((2.0*world->exp + 0.5), -10);
logfac= log((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);
}
/* ambient color */
if(world->ambr!=0.0f || world->ambg!=0.0f || world->ambb!=0.0f) {
if(GPU_link_changed(shi->amb) || ma->amb != 0.0f)
GPU_link(mat, "shade_maddf", shr->combined, GPU_uniform(&ma->amb),
GPU_uniform(&world->ambr), &shr->combined);
}
}
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->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(world && (world->mode & WO_MIST) && !(ma->mode & MA_NOMIST)) {
misttype = world->mistype;
GPU_link(mat, "shade_mist_factor", GPU_builtin(GPU_VIEW_POSITION),
GPU_uniform(&world->miststa), GPU_uniform(&world->mistdist),
GPU_uniform(&misttype), GPU_uniform(&world->misi), &mistfac);
GPU_link(mat, "mix_blend", mistfac, shr->combined,
GPU_uniform(&world->horr), &shr->combined);
}
if(!((ma->mode & MA_TRANSP) && (ma->mode & MA_ZTRANSP))) {
if(world && (GPU_link_changed(shr->alpha) || ma->alpha != 1.0f))
GPU_link(mat, "shade_world_mix", GPU_uniform(&world->horr),
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;
}
GPUMaterial *GPU_material_from_blender(Scene *scene, Material *ma)
{
GPUMaterial *mat;
GPUNodeLink *outlink;
LinkData *link;
for(link=ma->gpumaterial.first; link; link=link->next)
if(((GPUMaterial*)link->data)->scene == scene)
return link->data;
mat = GPU_material_construct_begin(ma);
mat->scene = scene;
if(!(scene->gm.flag & GAME_GLSL_NO_NODES) && ma->nodetree && ma->use_nodes) {
ntreeGPUMaterialNodes(ma->nodetree, mat);
}
else {
outlink = GPU_blender_material(mat, ma);
GPU_material_output_link(mat, outlink);
}
if(gpu_do_color_management(mat))
if(mat->outlink)
GPU_link(mat, "linearrgb_to_srgb", mat->outlink, &mat->outlink);
/*if(!GPU_material_construct_end(mat)) {
GPU_material_free(mat);
mat= NULL;
return 0;
}*/
GPU_material_construct_end(mat);
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;
extern Material defmaterial;
for(ma=G.main->mat.first; ma; ma=ma->id.next)
GPU_material_free(ma);
GPU_material_free(&defmaterial);
for(ob=G.main->object.first; ob; ob=ob->id.next)
GPU_lamp_free(ob);
}
/* Lamps and shadow buffers */
void GPU_lamp_update(GPULamp *lamp, int lay, int hide, float obmat[][4])
{
float mat[4][4];
lamp->lay = lay;
lamp->hide = hide;
copy_m4_m4(mat, obmat);
normalize_m4(mat);
VECCOPY(lamp->vec, mat[2]);
VECCOPY(lamp->co, mat[3]);
copy_m4_m4(lamp->obmat, mat);
invert_m4_m4(lamp->imat, mat);
}
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->energy;
lamp->col[1]= g* lamp->energy;
lamp->col[2]= b* lamp->energy;
}
static void gpu_lamp_from_blender(Scene *scene, Object *ob, Object *par, Lamp *la, GPULamp *lamp)
{
float temp, angle, pixsize, wsize;
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->energy;
lamp->col[1]= la->g*lamp->energy;
lamp->col[2]= la->b*lamp->energy;
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 > 170.0f)
lamp->spotsi = 170.0f;
lamp->spotsi= cos(M_PI*lamp->spotsi/360.0);
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->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;
/* makeshadowbuf */
angle= saacos(lamp->spotsi);
temp= 0.5f*lamp->size*cos(angle)/sin(angle);
pixsize= (lamp->d)/temp;
wsize= pixsize*0.5f*lamp->size;
perspective_m4( lamp->winmat,-wsize, wsize, -wsize, wsize, lamp->d, lamp->clipend);
}
static void gpu_lamp_shadow_free(GPULamp *lamp)
{
if(lamp->tex) {
GPU_texture_free(lamp->tex);
lamp->tex= NULL;
}
if(lamp->fb) {
GPU_framebuffer_free(lamp->fb);
lamp->fb= NULL;
}
}
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)) {
/* opengl */
lamp->fb = GPU_framebuffer_create();
if(!lamp->fb) {
gpu_lamp_shadow_free(lamp);
return lamp;
}
lamp->tex = GPU_texture_create_depth(lamp->size, lamp->size, NULL);
if(!lamp->tex) {
gpu_lamp_shadow_free(lamp);
return lamp;
}
if(!GPU_framebuffer_texture_attach(lamp->fb, lamp->tex, NULL)) {
gpu_lamp_shadow_free(lamp);
return lamp;
}
GPU_framebuffer_restore();
}
return lamp;
}
void GPU_lamp_free(Object *ob)
{
GPULamp *lamp;
LinkData *link;
LinkData *nlink;
Material *ma;
for(link=ob->gpulamp.first; link; link=link->next) {
lamp = link->data;
while(lamp->materials.first) {
nlink = lamp->materials.first;
ma = nlink->data;
BLI_freelinkN(&lamp->materials, nlink);
if(ma->gpumaterial.first)
GPU_material_free(ma);
}
gpu_lamp_shadow_free(lamp);
MEM_freeN(lamp);
}
BLI_freelistN(&ob->gpulamp);
}
int GPU_lamp_has_shadow_buffer(GPULamp *lamp)
{
return (!(lamp->scene->gm.flag & GAME_GLSL_NO_SHADOWS) &&
!(lamp->scene->gm.flag & GAME_GLSL_NO_LIGHTS) &&
lamp->tex && lamp->fb);
}
void GPU_lamp_shadow_buffer_bind(GPULamp *lamp, float viewmat[][4], int *winsize, float winmat[][4])
{
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->viewmat, lamp->winmat);
/* 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, persmat, rangemat);
/* opengl */
glDisable(GL_SCISSOR_TEST);
GPU_framebuffer_texture_bind(lamp->fb, lamp->tex,
GPU_texture_opengl_width(lamp->tex), GPU_texture_opengl_height(lamp->tex));
/* set matrices */
copy_m4_m4(viewmat, lamp->viewmat);
copy_m4_m4(winmat, lamp->winmat);
*winsize = lamp->size;
}
void GPU_lamp_shadow_buffer_unbind(GPULamp *lamp)
{
GPU_framebuffer_texture_unbind(lamp->fb, lamp->tex);
GPU_framebuffer_restore();
glEnable(GL_SCISSOR_TEST);
}
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;
}
/* 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_OBCOLOR, GPU_DYNAMIC_OBJECT_COLOR, GPU_DATA_4F },
{ 0 }
};
GPUShaderExport *shader = NULL;
GPUPass *pass;
GPUInput *input;
GPUMaterial *mat;
GPUInputUniform *uniform;
GPUInputAttribute *attribute;
GLint lastbindcode;
int i, liblen, fraglen;
if(!GPU_glsl_support())
return NULL;
mat = GPU_material_from_blender(scene, ma);
pass = (mat)? mat->pass: NULL;
if(pass && pass->fragmentcode && pass->vertexcode) {
shader = MEM_callocN(sizeof(GPUShaderExport), "GPUShaderExport");
for(input = pass->inputs.first; input; input = input->next) {
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;
glGetIntegerv(GL_TEXTURE_BINDING_2D, &lastbindcode);
glBindTexture(GL_TEXTURE_2D, GPU_texture_opengl_bindcode(input->tex));
uniform->texsize = GPU_texture_opengl_width(input->tex) * GPU_texture_opengl_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, lastbindcode);
}
break;
}
}
else {
uniform->type = input->dynamictype;
BLI_strncpy(uniform->varname, input->shadername, sizeof(uniform->varname));
switch(input->type) {
case 1:
uniform->datatype = GPU_DATA_1F;
break;
case 2:
uniform->datatype = GPU_DATA_2F;
break;
case 3:
uniform->datatype = GPU_DATA_3F;
break;
case 4:
uniform->datatype = GPU_DATA_4F;
break;
case 9:
uniform->datatype = GPU_DATA_9F;
break;
case 16:
uniform->datatype = GPU_DATA_16F;
break;
}
if(uniform->type >= GPU_DYNAMIC_LAMP_FIRST && uniform->type <= GPU_DYNAMIC_LAMP_LAST)
uniform->lamp = input->dynamicdata;
}
if(uniform->type != GPU_DYNAMIC_NONE)
BLI_addtail(&shader->uniforms, uniform);
else
MEM_freeN(uniform);
}
/* process builtin uniform */
for(i=0; builtins[i].gputype; i++) {
if(mat->builtins & builtins[i].gputype) {
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 fragement 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(i=0; i<mat->attribs.totlayer; i++) {
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)
{
GPUInputUniform *uniform;
if(shader == NULL)
return;
for(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);
}
View Git Blame Copy Permalink