26b3dfa30e
The hiding code uses the SOCK_IN_USE flags already present. These were only temporarily set by the shader node code for determining needed texture coordinate types. Now they are used persistently and updated along with the sock->link pointers.
389 lines
12 KiB
C
389 lines
12 KiB
C
/*
|
||
* ***** 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): none yet.
|
||
*
|
||
* ***** END GPL LICENSE BLOCK *****
|
||
*/
|
||
|
||
/** \file blender/nodes/shader/node_shader_util.c
|
||
* \ingroup nodes
|
||
*/
|
||
|
||
|
||
#include "DNA_node_types.h"
|
||
|
||
#include "node_shader_util.h"
|
||
|
||
#include "node_exec.h"
|
||
|
||
/* ****** */
|
||
|
||
void nodestack_get_vec(float *in, short type_in, bNodeStack *ns)
|
||
{
|
||
float *from= ns->vec;
|
||
|
||
if(type_in==SOCK_FLOAT) {
|
||
if(ns->sockettype==SOCK_FLOAT)
|
||
*in= *from;
|
||
else
|
||
*in= 0.333333f*(from[0]+from[1]+from[2]);
|
||
}
|
||
else if(type_in==SOCK_VECTOR) {
|
||
if(ns->sockettype==SOCK_FLOAT) {
|
||
in[0]= from[0];
|
||
in[1]= from[0];
|
||
in[2]= from[0];
|
||
}
|
||
else {
|
||
copy_v3_v3(in, from);
|
||
}
|
||
}
|
||
else { /* type_in==SOCK_RGBA */
|
||
if(ns->sockettype==SOCK_RGBA) {
|
||
copy_v4_v4(in, from);
|
||
}
|
||
else if(ns->sockettype==SOCK_FLOAT) {
|
||
in[0]= from[0];
|
||
in[1]= from[0];
|
||
in[2]= from[0];
|
||
in[3]= 1.0f;
|
||
}
|
||
else {
|
||
copy_v3_v3(in, from);
|
||
in[3]= 1.0f;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/* ******************* execute and parse ************ */
|
||
|
||
/* Used for muted nodes, just copy the vec data from input to output… */
|
||
void node_shader_pass_on(void *UNUSED(data), int UNUSED(thread), struct bNode *node, void *UNUSED(nodedata),
|
||
struct bNodeStack **in, struct bNodeStack **out)
|
||
{
|
||
ListBase links;
|
||
LinkInOutsMuteNode *lnk;
|
||
int i;
|
||
|
||
if(node->typeinfo->mutelinksfunc == NULL)
|
||
return;
|
||
|
||
/* Get default muting links (as bNodeStack pointers). */
|
||
links = node->typeinfo->mutelinksfunc(NULL, node, in, out, NULL, NULL);
|
||
|
||
for(lnk = links.first; lnk; lnk = lnk->next) {
|
||
for(i = 0; i < lnk->num_outs; i++) {
|
||
copy_v4_v4((((bNodeStack*)(lnk->outs))+i)->vec, ((bNodeStack*)(lnk->in))->vec);
|
||
}
|
||
/* If num_outs > 1, lnk->outs was an allocated table of pointers... */
|
||
if(i > 1)
|
||
MEM_freeN(lnk->outs);
|
||
}
|
||
BLI_freelistN(&links);
|
||
}
|
||
|
||
int gpu_shader_pass_on(struct GPUMaterial *mat, struct bNode *node, void *UNUSED(nodedata),
|
||
struct GPUNodeStack *in, struct GPUNodeStack *out)
|
||
{
|
||
ListBase links;
|
||
LinkInOutsMuteNode *lnk;
|
||
|
||
if(node->typeinfo->mutelinksfunc == NULL)
|
||
return 0;
|
||
|
||
/* Get default muting links (as GPUNodeStack pointers). */
|
||
links = node->typeinfo->mutelinksfunc(NULL, node, NULL, NULL, in, out);
|
||
|
||
for(lnk = links.first; lnk; lnk = lnk->next) {
|
||
GPU_stack_link_mute(mat, "copy_raw", lnk);
|
||
/* If num_outs > 1, lnk->outs was an allocated table of pointers... */
|
||
if(lnk->num_outs > 1)
|
||
MEM_freeN(lnk->outs);
|
||
}
|
||
|
||
BLI_freelistN(&links);
|
||
return 1;
|
||
}
|
||
|
||
/* go over all used Geometry and Texture nodes, and return a texco flag */
|
||
/* no group inside needed, this function is called for groups too */
|
||
void ntreeShaderGetTexcoMode(bNodeTree *ntree, int r_mode, short *texco, int *mode)
|
||
{
|
||
bNode *node;
|
||
bNodeSocket *sock;
|
||
int a;
|
||
|
||
for(node= ntree->nodes.first; node; node= node->next) {
|
||
if(node->type==SH_NODE_TEXTURE) {
|
||
if((r_mode & R_OSA) && node->id) {
|
||
Tex *tex= (Tex *)node->id;
|
||
if ELEM3(tex->type, TEX_IMAGE, TEX_PLUGIN, TEX_ENVMAP)
|
||
*texco |= TEXCO_OSA|NEED_UV;
|
||
}
|
||
/* usability exception... without input we still give the node orcos */
|
||
sock= node->inputs.first;
|
||
if(sock==NULL || sock->link==NULL)
|
||
*texco |= TEXCO_ORCO|NEED_UV;
|
||
}
|
||
else if(node->type==SH_NODE_GEOMETRY) {
|
||
/* note; sockets always exist for the given type! */
|
||
for(a=0, sock= node->outputs.first; sock; sock= sock->next, a++) {
|
||
if(sock->flag & SOCK_IN_USE) {
|
||
switch(a) {
|
||
case GEOM_OUT_GLOB:
|
||
*texco |= TEXCO_GLOB|NEED_UV; break;
|
||
case GEOM_OUT_VIEW:
|
||
*texco |= TEXCO_VIEW|NEED_UV; break;
|
||
case GEOM_OUT_ORCO:
|
||
*texco |= TEXCO_ORCO|NEED_UV; break;
|
||
case GEOM_OUT_UV:
|
||
*texco |= TEXCO_UV|NEED_UV; break;
|
||
case GEOM_OUT_NORMAL:
|
||
*texco |= TEXCO_NORM|NEED_UV; break;
|
||
case GEOM_OUT_VCOL:
|
||
*texco |= NEED_UV; *mode |= MA_VERTEXCOL; break;
|
||
case GEOM_OUT_VCOL_ALPHA:
|
||
*texco |= NEED_UV; *mode |= MA_VERTEXCOL; break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/* nodes that use ID data get synced with local data */
|
||
void nodeShaderSynchronizeID(bNode *node, int copyto)
|
||
{
|
||
if(node->id==NULL) return;
|
||
|
||
if(ELEM(node->type, SH_NODE_MATERIAL, SH_NODE_MATERIAL_EXT)) {
|
||
bNodeSocket *sock;
|
||
Material *ma= (Material *)node->id;
|
||
int a;
|
||
|
||
/* hrmf, case in loop isnt super fast, but we dont edit 100s of material at same time either! */
|
||
for(a=0, sock= node->inputs.first; sock; sock= sock->next, a++) {
|
||
if(!(sock->flag & SOCK_HIDDEN)) {
|
||
if(copyto) {
|
||
switch(a) {
|
||
case MAT_IN_COLOR:
|
||
copy_v3_v3(&ma->r, ((bNodeSocketValueRGBA*)sock->default_value)->value); break;
|
||
case MAT_IN_SPEC:
|
||
copy_v3_v3(&ma->specr, ((bNodeSocketValueRGBA*)sock->default_value)->value); break;
|
||
case MAT_IN_REFL:
|
||
ma->ref= ((bNodeSocketValueFloat*)sock->default_value)->value; break;
|
||
case MAT_IN_MIR:
|
||
copy_v3_v3(&ma->mirr, ((bNodeSocketValueRGBA*)sock->default_value)->value); break;
|
||
case MAT_IN_AMB:
|
||
ma->amb= ((bNodeSocketValueFloat*)sock->default_value)->value; break;
|
||
case MAT_IN_EMIT:
|
||
ma->emit= ((bNodeSocketValueFloat*)sock->default_value)->value; break;
|
||
case MAT_IN_SPECTRA:
|
||
ma->spectra= ((bNodeSocketValueFloat*)sock->default_value)->value; break;
|
||
case MAT_IN_RAY_MIRROR:
|
||
ma->ray_mirror= ((bNodeSocketValueFloat*)sock->default_value)->value; break;
|
||
case MAT_IN_ALPHA:
|
||
ma->alpha= ((bNodeSocketValueFloat*)sock->default_value)->value; break;
|
||
case MAT_IN_TRANSLUCENCY:
|
||
ma->translucency= ((bNodeSocketValueFloat*)sock->default_value)->value; break;
|
||
}
|
||
}
|
||
else {
|
||
switch(a) {
|
||
case MAT_IN_COLOR:
|
||
copy_v3_v3(((bNodeSocketValueRGBA*)sock->default_value)->value, &ma->r); break;
|
||
case MAT_IN_SPEC:
|
||
copy_v3_v3(((bNodeSocketValueRGBA*)sock->default_value)->value, &ma->specr); break;
|
||
case MAT_IN_REFL:
|
||
((bNodeSocketValueFloat*)sock->default_value)->value= ma->ref; break;
|
||
case MAT_IN_MIR:
|
||
copy_v3_v3(((bNodeSocketValueRGBA*)sock->default_value)->value, &ma->mirr); break;
|
||
case MAT_IN_AMB:
|
||
((bNodeSocketValueFloat*)sock->default_value)->value= ma->amb; break;
|
||
case MAT_IN_EMIT:
|
||
((bNodeSocketValueFloat*)sock->default_value)->value= ma->emit; break;
|
||
case MAT_IN_SPECTRA:
|
||
((bNodeSocketValueFloat*)sock->default_value)->value= ma->spectra; break;
|
||
case MAT_IN_RAY_MIRROR:
|
||
((bNodeSocketValueFloat*)sock->default_value)->value= ma->ray_mirror; break;
|
||
case MAT_IN_ALPHA:
|
||
((bNodeSocketValueFloat*)sock->default_value)->value= ma->alpha; break;
|
||
case MAT_IN_TRANSLUCENCY:
|
||
((bNodeSocketValueFloat*)sock->default_value)->value= ma->translucency; break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
|
||
void node_gpu_stack_from_data(struct GPUNodeStack *gs, int type, bNodeStack *ns)
|
||
{
|
||
memset(gs, 0, sizeof(*gs));
|
||
|
||
copy_v4_v4(gs->vec, ns->vec);
|
||
gs->link= ns->data;
|
||
|
||
if (type == SOCK_FLOAT)
|
||
gs->type= GPU_FLOAT;
|
||
else if (type == SOCK_VECTOR)
|
||
gs->type= GPU_VEC3;
|
||
else if (type == SOCK_RGBA)
|
||
gs->type= GPU_VEC4;
|
||
else if (type == SOCK_SHADER)
|
||
gs->type= GPU_VEC4;
|
||
else
|
||
gs->type= GPU_NONE;
|
||
|
||
gs->name = "";
|
||
gs->hasinput= ns->hasinput && ns->data;
|
||
/* XXX Commented out the ns->data check here, as it seems it’s not alwas set,
|
||
* even though there *is* a valid connection/output... But that might need
|
||
* further investigation.
|
||
*/
|
||
gs->hasoutput= ns->hasoutput /*&& ns->data*/;
|
||
gs->sockettype= ns->sockettype;
|
||
}
|
||
|
||
void node_data_from_gpu_stack(bNodeStack *ns, GPUNodeStack *gs)
|
||
{
|
||
ns->data= gs->link;
|
||
ns->sockettype= gs->sockettype;
|
||
}
|
||
|
||
static void gpu_stack_from_data_list(GPUNodeStack *gs, ListBase *sockets, bNodeStack **ns)
|
||
{
|
||
bNodeSocket *sock;
|
||
int i;
|
||
|
||
for (sock=sockets->first, i=0; sock; sock=sock->next, i++)
|
||
node_gpu_stack_from_data(&gs[i], sock->type, ns[i]);
|
||
|
||
gs[i].type= GPU_NONE;
|
||
}
|
||
|
||
static void data_from_gpu_stack_list(ListBase *sockets, bNodeStack **ns, GPUNodeStack *gs)
|
||
{
|
||
bNodeSocket *sock;
|
||
int i;
|
||
|
||
for (sock=sockets->first, i=0; sock; sock=sock->next, i++)
|
||
node_data_from_gpu_stack(ns[i], &gs[i]);
|
||
}
|
||
|
||
bNode *nodeGetActiveTexture(bNodeTree *ntree)
|
||
{
|
||
/* this is the node we texture paint and draw in textured draw */
|
||
bNode *node;
|
||
|
||
if(!ntree)
|
||
return NULL;
|
||
|
||
/* check for group edit */
|
||
for(node= ntree->nodes.first; node; node= node->next)
|
||
if(node->flag & NODE_GROUP_EDIT)
|
||
break;
|
||
|
||
if(node)
|
||
ntree= (bNodeTree*)node->id;
|
||
|
||
for(node= ntree->nodes.first; node; node= node->next)
|
||
if(node->flag & NODE_ACTIVE_TEXTURE)
|
||
return node;
|
||
|
||
return NULL;
|
||
}
|
||
|
||
void ntreeExecGPUNodes(bNodeTreeExec *exec, GPUMaterial *mat, int do_outputs)
|
||
{
|
||
bNodeExec *nodeexec;
|
||
bNode *node;
|
||
int n;
|
||
bNodeStack *stack;
|
||
bNodeStack *nsin[MAX_SOCKET]; /* arbitrary... watch this */
|
||
bNodeStack *nsout[MAX_SOCKET]; /* arbitrary... watch this */
|
||
GPUNodeStack gpuin[MAX_SOCKET+1], gpuout[MAX_SOCKET+1];
|
||
int doit;
|
||
|
||
stack= exec->stack;
|
||
|
||
for(n=0, nodeexec= exec->nodeexec; n < exec->totnodes; ++n, ++nodeexec) {
|
||
node = nodeexec->node;
|
||
|
||
doit = 0;
|
||
/* for groups, only execute outputs for edited group */
|
||
if(node->typeinfo->nclass==NODE_CLASS_OUTPUT) {
|
||
if(do_outputs && (node->flag & NODE_DO_OUTPUT))
|
||
doit = 1;
|
||
}
|
||
else
|
||
doit = 1;
|
||
|
||
if (doit) {
|
||
if((node->flag & NODE_MUTED) && node->typeinfo->gpumutefunc) {
|
||
node_get_stack(node, stack, nsin, nsout);
|
||
gpu_stack_from_data_list(gpuin, &node->inputs, nsin);
|
||
gpu_stack_from_data_list(gpuout, &node->outputs, nsout);
|
||
if(node->typeinfo->gpumutefunc(mat, node, nodeexec->data, gpuin, gpuout))
|
||
data_from_gpu_stack_list(&node->outputs, nsout, gpuout);
|
||
}
|
||
else if(node->typeinfo->gpufunc) {
|
||
node_get_stack(node, stack, nsin, nsout);
|
||
gpu_stack_from_data_list(gpuin, &node->inputs, nsin);
|
||
gpu_stack_from_data_list(gpuout, &node->outputs, nsout);
|
||
if(node->typeinfo->gpufunc(mat, node, gpuin, gpuout))
|
||
data_from_gpu_stack_list(&node->outputs, nsout, gpuout);
|
||
}
|
||
else if(node->typeinfo->gpuextfunc) {
|
||
node_get_stack(node, stack, nsin, nsout);
|
||
gpu_stack_from_data_list(gpuin, &node->inputs, nsin);
|
||
gpu_stack_from_data_list(gpuout, &node->outputs, nsout);
|
||
if(node->typeinfo->gpuextfunc(mat, node, nodeexec->data, gpuin, gpuout))
|
||
data_from_gpu_stack_list(&node->outputs, nsout, gpuout);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void node_shader_gpu_tex_mapping(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *UNUSED(out))
|
||
{
|
||
NodeTexBase *base= node->storage;
|
||
TexMapping *texmap= &base->tex_mapping;
|
||
float domin= (texmap->flag & TEXMAP_CLIP_MIN) != 0;
|
||
float domax= (texmap->flag & TEXMAP_CLIP_MAX) != 0;
|
||
|
||
if(domin || domax || !(texmap->flag & TEXMAP_UNIT_MATRIX)) {
|
||
GPUNodeLink *tmat = GPU_uniform((float*)texmap->mat);
|
||
GPUNodeLink *tmin = GPU_uniform(texmap->min);
|
||
GPUNodeLink *tmax = GPU_uniform(texmap->max);
|
||
GPUNodeLink *tdomin = GPU_uniform(&domin);
|
||
GPUNodeLink *tdomax = GPU_uniform(&domax);
|
||
|
||
GPU_link(mat, "mapping", in[0].link, tmat, tmin, tmax, tdomin, tdomax, &in[0].link);
|
||
}
|
||
}
|
||
|