sandey/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity

Merged the particles-2010 branch with node improvements into trunk.

Browse Source 
This branch adds mostly organizational improvements to the node system by renaming the node folders and files. A couple of internal features have been added too.
Detailed information can be found on the wiki page:

http://wiki.blender.org/index.php/User:Phonybone/Particles2010
This commit is contained in:
Lukas Toenne 2011-09-05 21:01:50 +00:00
parent 6e9ff495eb
commit 8e0fe8bff7
166 changed files with 9403 additions and 5416 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/blenkernel/BKE_blender.h
View File

@ -44,7 +44,7 @@ extern "C" {
* and keep comment above the defines.
* Use STRINGIFY() rather than defining with quotes */
#define BLENDER_VERSION 259
#define BLENDER_SUBVERSION 1
#define BLENDER_SUBVERSION 2
#define BLENDER_MINVERSION 250
#define BLENDER_MINSUBVERSION 0

312
source/blender/blenkernel/BKE_node.h
View File

@ -37,6 +37,10 @@
* \ingroup bke
*/
#include "DNA_listBase.h"
#include "RNA_types.h"
/* not very important, but the stack solver likes to know a maximum */
#define MAX_SOCKET 64
@ -46,63 +50,151 @@ struct bNodeLink;
struct bNodeSocket;
struct bNodeStack;
struct bNodeTree;
struct bNodeTreeExec;
struct GPUMaterial;
struct GPUNode;
struct GPUNodeStack;
struct ID;
struct ListBase;
struct Main;
struct uiBlock;
struct uiLayout;
struct MTex;
struct PointerRNA;
struct rctf;
struct RenderData;
struct Scene;
struct Tex;
struct uiLayout;
struct SpaceNode;
struct ARegion;
struct Object;
/* ************** NODE TYPE DEFINITIONS ***** */
typedef struct bNodeSocketType {
/** Compact definition of a node socket.
* Can be used to quickly define a list of static sockets for a node,
* which are added to each new node of that type.
*
* \deprecated New nodes should add default sockets in the initialization
* function instead. This struct is mostly kept for old nodes and should
* be removed some time.
*/
typedef struct bNodeSocketTemplate {
int type, limit;
const char *name;
char name[32];
float val1, val2, val3, val4; /* default alloc value for inputs */
float min, max; /* default range for inputs */
float min, max;
PropertySubType subtype;
/* after this line is used internal only */
struct bNodeSocket *sock; /* used during verify_types */
struct bNodeSocket *sock; /* used to hold verified socket */
} bNodeSocketTemplate;
typedef void (*NodeSocketButtonFunction)(const struct bContext *C, struct uiBlock *block,
struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock,
const char *name, int x, int y, int width);
/** Defines a socket type.
* Defines the appearance and behavior of a socket in the UI.
*/
typedef struct bNodeSocketType {
int type;
char ui_name[32];
char ui_description[128];
int ui_icon;
char ui_color[4];
const char *value_structname;
int value_structsize;
NodeSocketButtonFunction buttonfunc;
} bNodeSocketType;
/** Template for creating a node.
* Stored required parameters to make a new node of a specific type.
*/
typedef struct bNodeTemplate {
int type;
/* group tree */
struct bNodeTree *ngroup;
} bNodeTemplate;
/** Defines a node type.
* Initial attributes and constants for a node as well as callback functions
* implementing the node behavior.
*/
typedef struct bNodeType {
void *next,*prev;
short needs_free; /* set for allocated types that need to be freed */
int type;
const char *name; /* can be allocated too */
char name[32];
float width, minwidth, maxwidth;
float height, minheight, maxheight;
short nclass, flag;
bNodeSocketType *inputs, *outputs;
/* templates for static sockets */
bNodeSocketTemplate *inputs, *outputs;
char storagename[64]; /* struct name for DNA */
void (*execfunc)(void *data, struct bNode *, struct bNodeStack **, struct bNodeStack **);
/* this line is set on startup of blender */
/// Main draw function for the node.
void (*drawfunc)(const struct bContext *C, struct ARegion *ar, struct SpaceNode *snode, struct bNodeTree *ntree, struct bNode *node);
/// Updates the node geometry attributes according to internal state before actual drawing.
void (*drawupdatefunc)(const struct bContext *C, struct bNodeTree *ntree, struct bNode *node);
/// Draw the option buttons on the node.
void (*uifunc)(struct uiLayout *, struct bContext *C, struct PointerRNA *ptr);
/// Additional parameters in the side panel.
void (*uifuncbut)(struct uiLayout *, struct bContext *C, struct PointerRNA *ptr);
/// Optional custom label function for the node header.
const char *(*labelfunc)(struct bNode *);
/// Optional custom resize handle polling.
int (*resize_area_func)(struct bNode *node, int x, int y);
void (*initfunc)(struct bNode *);
void (*freestoragefunc)(struct bNode *);
void (*copystoragefunc)(struct bNode *, struct bNode *);
/// Called when the node is updated in the editor.
void (*updatefunc)(struct bNodeTree *ntree, struct bNode *node);
/// Check and update if internal ID data has changed.
void (*verifyfunc)(struct bNodeTree *ntree, struct bNode *node, struct ID *id);
/* for use with dynamic typedefs */
ID *id;
void *pynode; /* holds pointer to python script */
void *pydict; /* holds pointer to python script dictionary (scope)*/
/// Initialize a new node instance of this type after creation.
void (*initfunc)(struct bNodeTree *ntree, struct bNode *node, struct bNodeTemplate *ntemp);
/// Free the custom storage data.
void (*freestoragefunc)(struct bNode *node);
/// Make a copy of the custom storage data.
void (*copystoragefunc)(struct bNode *node, struct bNode *target);
/// Create a template from an existing node.
struct bNodeTemplate (*templatefunc)(struct bNode *);
/** If a node can be made from the template in the given node tree.
* \example Node groups can not be created inside their own node tree.
*/
int (*validfunc)(struct bNodeTree *ntree, struct bNodeTemplate *ntemp);
/// Initialize a node tree associated to this node type.
void (*inittreefunc)(struct bNodeTree *ntree);
/// Update a node tree associated to this node type.
void (*updatetreefunc)(struct bNodeTree *ntree);
/* group edit callbacks for operators */
/* XXX this is going to be changed as required by the UI */
struct bNodeTree *(*group_edit_get)(struct bNode *node);
struct bNodeTree *(*group_edit_set)(struct bNode *node, int edit);
void (*group_edit_clear)(struct bNode *node);
/* **** execution callbacks **** */
void *(*initexecfunc)(struct bNode *node);
void (*freeexecfunc)(struct bNode *node, void *nodedata);
void (*execfunc)(void *data, struct bNode *, struct bNodeStack **, struct bNodeStack **);
/* XXX this alternative exec function has been added to avoid changing all node types.
* when a final generic version of execution code is defined, this will be changed anyway
*/
void (*newexecfunc)(void *data, int thread, struct bNode *, void *nodedata, struct bNodeStack **, struct bNodeStack **);
/* gpu */
int (*gpufunc)(struct GPUMaterial *mat, struct bNode *node, struct GPUNodeStack *in, struct GPUNodeStack *out);
/* extended gpu function */
int (*gpuextfunc)(struct GPUMaterial *mat, struct bNode *node, void *nodedata, struct GPUNodeStack *in, struct GPUNodeStack *out);
} bNodeType;
/* node->exec, now in use for composites (#define for break is same as ready yes) */
@ -113,6 +205,10 @@ typedef struct bNodeType {
#define NODE_FREEBUFS 8
#define NODE_SKIPPED 16
/* sim_exec return value */
#define NODE_EXEC_FINISHED 0
#define NODE_EXEC_SUSPEND 1
/* nodetype->nclass, for add-menu and themes */
#define NODE_CLASS_INPUT 0
#define NODE_CLASS_OUTPUT 1
@ -127,58 +223,106 @@ typedef struct bNodeType {
#define NODE_CLASS_OP_DYNAMIC 11
#define NODE_CLASS_PATTERN 12
#define NODE_CLASS_TEXTURE 13
#define NODE_CLASS_EXECUTION 14
#define NODE_CLASS_GETDATA 15
#define NODE_CLASS_SETDATA 16
#define NODE_CLASS_MATH 17
#define NODE_CLASS_MATH_VECTOR 18
#define NODE_CLASS_MATH_ROTATION 19
#define NODE_CLASS_PARTICLES 25
#define NODE_CLASS_TRANSFORM 30
#define NODE_CLASS_COMBINE 31
#define NODE_CLASS_LAYOUT 100
/* enum values for input/output */
#define SOCK_IN 1
#define SOCK_OUT 2
struct bNodeTreeExec;
typedef void (*bNodeTreeCallback)(void *calldata, struct ID *owner_id, struct bNodeTree *ntree);
typedef struct bNodeTreeType
{
int type; /* type identifier */
char idname[64]; /* id name for RNA identification */
ListBase node_types; /* type definitions */
/* callbacks */
void (*free_cache)(struct bNodeTree *ntree);
void (*free_node_cache)(struct bNodeTree *ntree, struct bNode *node);
void (*foreach_nodetree)(struct Main *main, void *calldata, bNodeTreeCallback func); /* iteration over all node trees */
/* calls allowing threaded composite */
void (*localize)(struct bNodeTree *localtree, struct bNodeTree *ntree);
void (*local_sync)(struct bNodeTree *localtree, struct bNodeTree *ntree);
void (*local_merge)(struct bNodeTree *localtree, struct bNodeTree *ntree);
/* Tree update. Overrides nodetype->updatetreefunc! */
void (*update)(struct bNodeTree *ntree);
/* Node update. Overrides nodetype->updatefunc! */
void (*update_node)(struct bNodeTree *ntree, struct bNode *node);
int (*validate_link)(struct bNodeTree *ntree, struct bNodeLink *link);
} bNodeTreeType;
/* ************** GENERIC API, TREES *************** */
void ntreeVerifyTypes(struct bNodeTree *ntree);
struct bNodeTreeType *ntreeGetType(int type);
struct bNodeType *ntreeGetNodeType(struct bNodeTree *ntree);
struct bNodeSocketType *ntreeGetSocketType(int type);
struct bNodeTree *ntreeAddTree(const char *name, int type, const short is_group);
struct bNodeTree *ntreeAddTree(const char *name, int type, int nodetype);
void ntreeInitTypes(struct bNodeTree *ntree);
//void ntreeMakeGroupSockets(struct bNodeTree *ntree);
void ntreeUpdateType(struct bNodeTree *ntree, struct bNodeType *ntype);
void ntreeFreeTree(struct bNodeTree *ntree);
struct bNodeTree *ntreeCopyTree(struct bNodeTree *ntree);
void ntreeSwitchID(struct bNodeTree *ntree, struct ID *sce_from, struct ID *sce_to);
void ntreeMakeLocal(struct bNodeTree *ntree);
int ntreeHasType(struct bNodeTree *ntree, int type);
void ntreeSocketUseFlags(struct bNodeTree *ntree);
void ntreeSolveOrder(struct bNodeTree *ntree);
void ntreeUpdateTree(struct bNodeTree *ntree);
/* XXX Currently each tree update call does call to ntreeVerifyNodes too.
* Some day this should be replaced by a decent depsgraph automatism!
*/
void ntreeVerifyNodes(struct Main *main, struct ID *id);
void ntreeBeginExecTree(struct bNodeTree *ntree);
void ntreeExecTree(struct bNodeTree *ntree, void *callerdata, int thread);
void ntreeCompositExecTree(struct bNodeTree *ntree, struct RenderData *rd, int do_previews);
void ntreeEndExecTree(struct bNodeTree *ntree);
void ntreeGetDependencyList(struct bNodeTree *ntree, struct bNode ***deplist, int *totnodes);
/* XXX old trees handle output flags automatically based on special output node types and last active selection.
* new tree types have a per-output socket flag to indicate the final output to use explicitly.
*/
void ntreeSetOutput(struct bNodeTree *ntree);
void ntreeInitPreview(struct bNodeTree *, int xsize, int ysize);
void ntreeClearPreview(struct bNodeTree *ntree);
void ntreeFreeCache(struct bNodeTree *ntree);
/* calls allowing threaded composite */
int ntreeNodeExists(struct bNodeTree *ntree, struct bNode *testnode);
int ntreeOutputExists(struct bNode *node, struct bNodeSocket *testsock);
struct bNodeTree *ntreeLocalize(struct bNodeTree *ntree);
void ntreeLocalSync(struct bNodeTree *localtree, struct bNodeTree *ntree);
void ntreeLocalMerge(struct bNodeTree *localtree, struct bNodeTree *ntree);
/* ************** GENERIC API, NODES *************** */
void nodeVerifyType(struct bNodeTree *ntree, struct bNode *node);
struct bNodeSocket *nodeAddSocket(struct bNodeTree *ntree, struct bNode *node, int in_out, const char *name, int type);
struct bNodeSocket *nodeInsertSocket(struct bNodeTree *ntree, struct bNode *node, int in_out, struct bNodeSocket *next_sock, const char *name, int type);
void nodeRemoveSocket(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocket *sock);
void nodeRemoveAllSockets(struct bNodeTree *ntree, struct bNode *node);
void nodeAddToPreview(struct bNode *, float *, int, int, int);
struct bNode *nodeAddNode(struct bNodeTree *ntree, struct bNodeTemplate *ntemp);
void nodeUnlinkNode(struct bNodeTree *ntree, struct bNode *node);
void nodeUniqueName(struct bNodeTree *ntree, struct bNode *node);
void nodeAddSockets(struct bNode *node, struct bNodeType *ntype);
struct bNode *nodeAddNodeType(struct bNodeTree *ntree, int type, struct bNodeTree *ngroup, struct ID *id);
void nodeRegisterType(struct ListBase *typelist, const struct bNodeType *ntype) ;
void nodeUpdateType(struct bNodeTree *ntree, struct bNode* node, struct bNodeType *ntype);
void nodeRegisterType(struct ListBase *typelist, struct bNodeType *ntype) ;
void nodeMakeDynamicType(struct bNode *node);
int nodeDynamicUnlinkText(struct ID *txtid);
void nodeFreeNode(struct bNodeTree *ntree, struct bNode *node);
struct bNode *nodeCopyNode(struct bNodeTree *ntree, struct bNode *node);
@ -186,6 +330,10 @@ struct bNodeLink *nodeAddLink(struct bNodeTree *ntree, struct bNode *fromnode, s
void nodeRemLink(struct bNodeTree *ntree, struct bNodeLink *link);
void nodeRemSocketLinks(struct bNodeTree *ntree, struct bNodeSocket *sock);
void nodeSpaceCoords(struct bNode *node, float *locx, float *locy);
void nodeAttachNode(struct bNode *node, struct bNode *parent);
void nodeDetachNode(struct bNode *node);
struct bNode *nodeFindNodebyName(struct bNodeTree *ntree, const char *name);
int nodeFindNode(struct bNodeTree *ntree, struct bNodeSocket *sock, struct bNode **nodep, int *sockindex, int *in_out);
@ -202,41 +350,71 @@ void NodeTagChanged(struct bNodeTree *ntree, struct bNode *node);
int NodeTagIDChanged(struct bNodeTree *ntree, struct ID *id);
void ntreeClearTags(struct bNodeTree *ntree);
/* ************** Groups ****************** */
void nodeFreePreview(struct bNode *node);
struct bNode *nodeMakeGroupFromSelected(struct bNodeTree *ntree);
int nodeGroupUnGroup(struct bNodeTree *ntree, struct bNode *gnode);
/* ************** NODE TYPE ACCESS *************** */
void nodeGroupVerify(struct bNodeTree *ngroup);
void nodeGroupSocketUseFlags(struct bNodeTree *ngroup);
void nodeGroupCopy(struct bNode *gnode);
struct bNodeSocket *nodeGroupAddSocket(struct bNodeTree *ngroup, const char *name, int type, int in_out);
struct bNodeSocket *nodeGroupExposeSocket(struct bNodeTree *ngroup, struct bNodeSocket *sock, int in_out);
void nodeGroupExposeAllSockets(struct bNodeTree *ngroup);
void nodeGroupRemoveSocket(struct bNodeTree *ngroup, struct bNodeSocket *gsock, int in_out);
/* ************** COMMON NODES *************** */
struct bNodeTemplate nodeMakeTemplate(struct bNode *node);
int nodeValid(struct bNodeTree *ntree, struct bNodeTemplate *ntemp);
const char* nodeLabel(struct bNode *node);
struct bNodeTree *nodeGroupEditGet(struct bNode *node);
struct bNodeTree *nodeGroupEditSet(struct bNode *node, int edit);
void nodeGroupEditClear(struct bNode *node);
/* Init a new node type struct with default values and callbacks */
void node_type_base(struct bNodeType *ntype, int type, const char *name, short nclass, short flag,
struct bNodeSocketType *inputs, struct bNodeSocketType *outputs);
void node_type_base(struct bNodeType *ntype, int type, const char *name, short nclass, short flag);
void node_type_socket_templates(struct bNodeType *ntype, struct bNodeSocketTemplate *inputs, struct bNodeSocketTemplate *outputs);
void node_type_size(struct bNodeType *ntype, int width, int minwidth, int maxwidth);
void node_type_init(struct bNodeType *ntype, void (*initfunc)(struct bNode *));
void node_type_init(struct bNodeType *ntype, void (*initfunc)(struct bNodeTree *ntree, struct bNode *node, struct bNodeTemplate *ntemp));
void node_type_valid(struct bNodeType *ntype, int (*validfunc)(struct bNodeTree *ntree, struct bNodeTemplate *ntemp));
void node_type_storage(struct bNodeType *ntype,
const char *storagename,
void (*freestoragefunc)(struct bNode *),
void (*copystoragefunc)(struct bNode *, struct bNode *));
void node_type_exec(struct bNodeType *ntype, void (*execfunc)(void *data, struct bNode *, struct bNodeStack **, struct bNodeStack **));
void node_type_gpu(struct bNodeType *ntype, int (*gpufunc)(struct GPUMaterial *mat, struct bNode *node, struct GPUNodeStack *in, struct GPUNodeStack *out));
void node_type_label(struct bNodeType *ntype, const char *(*labelfunc)(struct bNode *));
void node_type_template(struct bNodeType *ntype, struct bNodeTemplate (*templatefunc)(struct bNode *));
void node_type_update(struct bNodeType *ntype,
void (*updatefunc)(struct bNodeTree *ntree, struct bNode *node),
void (*verifyfunc)(struct bNodeTree *ntree, struct bNode *node, struct ID *id));
void node_type_tree(struct bNodeType *ntype,
void (*inittreefunc)(struct bNodeTree *),
void (*updatetreefunc)(struct bNodeTree *));
void node_type_group_edit(struct bNodeType *ntype,
struct bNodeTree *(*group_edit_get)(struct bNode *node),
struct bNodeTree *(*group_edit_set)(struct bNode *node, int edit),
void (*group_edit_clear)(struct bNode *node));
void node_type_exec(struct bNodeType *ntype, void (*execfunc)(void *data, struct bNode *, struct bNodeStack **, struct bNodeStack **));
void node_type_exec_new(struct bNodeType *ntype,
void *(*initexecfunc)(struct bNode *node),
void (*freeexecfunc)(struct bNode *node, void *nodedata),
void (*newexecfunc)(void *data, int thread, struct bNode *, void *nodedata, struct bNodeStack **, struct bNodeStack **));
void node_type_gpu(struct bNodeType *ntype, int (*gpufunc)(struct GPUMaterial *mat, struct bNode *node, struct GPUNodeStack *in, struct GPUNodeStack *out));
void node_type_gpu_ext(struct bNodeType *ntype, int (*gpuextfunc)(struct GPUMaterial *mat, struct bNode *node, void *nodedata, struct GPUNodeStack *in, struct GPUNodeStack *out));
/* ************** COMMON NODES *************** */
#define NODE_GROUP 2
#define NODE_GROUP_MENU 1000
#define NODE_DYNAMIC_MENU 4000
#define NODE_FORLOOP 3
#define NODE_WHILELOOP 4
#define NODE_FRAME 5
#define NODE_GROUP_MENU 10000
#define NODE_DYNAMIC_MENU 20000
void register_node_type_group(ListBase *lb);
/* look up a socket on a group node by the internal group socket */
struct bNodeSocket *node_group_find_input(struct bNode *gnode, struct bNodeSocket *gsock);
struct bNodeSocket *node_group_find_output(struct bNode *gnode, struct bNodeSocket *gsock);
struct bNodeSocket *node_group_add_socket(struct bNodeTree *ngroup, const char *name, int type, int in_out);
struct bNodeSocket *node_group_expose_socket(struct bNodeTree *ngroup, struct bNodeSocket *sock, int in_out);
void node_group_expose_all_sockets(struct bNodeTree *ngroup);
void node_group_remove_socket(struct bNodeTree *ngroup, struct bNodeSocket *gsock, int in_out);
struct bNode *node_group_make_from_selected(struct bNodeTree *ntree);
int node_group_ungroup(struct bNodeTree *ntree, struct bNode *gnode);
/* in node_common.c */
void register_node_type_frame(ListBase *lb);
/* ************** SHADER NODES *************** */
@ -286,11 +464,10 @@ struct ShadeResult;
#define NODE_DYNAMIC_REPARSE 6 /* 64 */
#define NODE_DYNAMIC_SET 15 /* sign */
/* the type definitions array */
extern struct ListBase node_all_shaders;
/* API */
struct bNodeTreeExec *ntreeShaderBeginExecTree(struct bNodeTree *ntree);
void ntreeShaderEndExecTree(struct bNodeTreeExec *exec);
void ntreeShaderExecTree(struct bNodeTree *ntree, struct ShadeInput *shi, struct ShadeResult *shr);
void ntreeShaderGetTexcoMode(struct bNodeTree *ntree, int osa, short *texco, int *mode);
void nodeShaderSynchronizeID(struct bNode *node, int copyto);
@ -415,11 +592,11 @@ void ntreeGPUMaterialNodes(struct bNodeTree *ntree, struct GPUMaterial *mat);
#define CMP_SCALE_RENDERPERCENT 3
/* the type definitions array */
extern struct ListBase node_all_composit;
/* API */
struct CompBuf;
struct bNodeTreeExec *ntreeCompositBeginExecTree(struct bNodeTree *ntree);
void ntreeCompositEndExecTree(struct bNodeTreeExec *exec);
void ntreeCompositExecTree(struct bNodeTree *ntree, struct RenderData *rd, int do_previews);
void ntreeCompositTagRender(struct Scene *sce);
int ntreeCompositTagAnimated(struct bNodeTree *ntree);
void ntreeCompositTagGenerators(struct bNodeTree *ntree);
@ -459,23 +636,22 @@ struct TexResult;
#define TEX_NODE_PROC 500
#define TEX_NODE_PROC_MAX 600
extern struct ListBase node_all_textures;
/* API */
int ntreeTexTagAnimated(struct bNodeTree *ntree);
void ntreeTexSetPreviewFlag(int);
int ntreeTexExecTree(struct bNodeTree *ntree, struct TexResult *target, float *coord, float *dxt, float *dyt, int osatex, short thread, struct Tex *tex, short which_output, int cfra, int preview, struct ShadeInput *shi, struct MTex *mtex);
void ntreeTexCheckCyclics(struct bNodeTree *ntree);
char* ntreeTexOutputMenu(struct bNodeTree *ntree);
struct bNodeTreeExec *ntreeTexBeginExecTree(struct bNodeTree *ntree);
void ntreeTexEndExecTree(struct bNodeTreeExec *exec);
int ntreeTexExecTree(struct bNodeTree *ntree, struct TexResult *target, float *coord, float *dxt, float *dyt, int osatex, short thread, struct Tex *tex, short which_output, int cfra, int preview, struct ShadeInput *shi, struct MTex *mtex);
/**/
/*************************************************/
void init_nodesystem(void);
void free_nodesystem(void);
/**/
void clear_scene_in_nodes(struct Main *bmain, struct Scene *sce);
#endif

9
source/blender/blenkernel/intern/material.c
View File

@ -925,7 +925,8 @@ void init_render_material(Material *mat, int r_mode, float *amb)
if(mat->nodetree && mat->use_nodes) {
init_render_nodetree(mat->nodetree, mat, r_mode, amb);
ntreeBeginExecTree(mat->nodetree); /* has internal flag to detect it only does it once */
if (!mat->nodetree->execdata)
mat->nodetree->execdata = ntreeShaderBeginExecTree(mat->nodetree);
}
}
@ -957,8 +958,10 @@ void init_render_materials(Main *bmain, int r_mode, float *amb)
/* only needed for nodes now */
void end_render_material(Material *mat)
{
if(mat && mat->nodetree && mat->use_nodes)
ntreeEndExecTree(mat->nodetree); /* has internal flag to detect it only does it once */
if(mat && mat->nodetree && mat->use_nodes) {
if (mat->nodetree->execdata)
ntreeShaderEndExecTree(mat->nodetree->execdata);
}
}
void end_render_materials(Main *bmain)

3313
source/blender/blenkernel/intern/node.c
View File

File diff suppressed because it is too large Load Diff

4
source/blender/blenkernel/intern/texture.c
View File

@ -766,7 +766,9 @@ Tex *copy_texture(Tex *tex)
if(tex->preview) texn->preview = BKE_previewimg_copy(tex->preview);
if(tex->nodetree) {
ntreeEndExecTree(tex->nodetree);
if (tex->nodetree->execdata) {
ntreeTexEndExecTree(tex->nodetree->execdata);
}
texn->nodetree= ntreeCopyTree(tex->nodetree);
}

3
source/blender/blenlib/BLI_math_matrix.h
View File

@ -66,6 +66,9 @@ void swap_m4m4(float A[4][4], float B[4][4]);
void add_m3_m3m3(float R[3][3], float A[3][3], float B[3][3]);
void add_m4_m4m4(float R[4][4], float A[4][4], float B[4][4]);
void sub_m3_m3m3(float R[3][3], float A[3][3], float B[3][3]);
void sub_m4_m4m4(float R[4][4], float A[4][4], float B[4][4]);
void mul_m3_m3m3(float R[3][3], float A[3][3], float B[3][3]);
void mul_m4_m4m4(float R[4][4], float A[4][4], float B[4][4]);
void mul_m4_m3m4(float R[4][4], float A[3][3], float B[4][4]);

1
source/blender/blenlib/BLI_math_vector.h
View File

@ -124,6 +124,7 @@ void interp_v3_v3v3v3(float p[3], const float v1[3], const float v2[3], const fl
void interp_v3_v3v3v3v3(float p[3], const float v1[3], const float v2[3], const float v3[3], const float v4[3], const float w[4]);
void interp_v4_v4v4(float r[4], const float a[4], const float b[4], const float t);
void interp_v4_v4v4v4(float p[4], const float v1[4], const float v2[4], const float v3[4], const float w[3]);
void interp_v4_v4v4v4v4(float p[4], const float v1[4], const float v2[4], const float v3[4], const float v4[4], const float w[4]);
void mid_v3_v3v3(float r[3], const float a[3], const float b[3]);

18
source/blender/blenlib/intern/math_matrix.c
View File

@ -451,6 +451,24 @@ void add_m4_m4m4(float m1[][4], float m2[][4], float m3[][4])
m1[i][j]= m2[i][j] + m3[i][j];
}
void sub_m3_m3m3(float m1[][3], float m2[][3], float m3[][3])
{
int i, j;
for(i=0;i<3;i++)
for(j=0;j<3;j++)
m1[i][j]= m2[i][j] - m3[i][j];
}
void sub_m4_m4m4(float m1[][4], float m2[][4], float m3[][4])
{
int i, j;
for(i=0;i<4;i++)
for(j=0;j<4;j++)
m1[i][j]= m2[i][j] - m3[i][j];
}
int invert_m3(float m[3][3])
{
float tmp[3][3];

8
source/blender/blenlib/intern/math_vector.c
View File

@ -96,6 +96,14 @@ void interp_v4_v4v4v4(float p[4], const float v1[4], const float v2[4], const fl
p[3] = v1[3]*w[0] + v2[3]*w[1] + v3[3]*w[2];
}
void interp_v4_v4v4v4v4(float p[4], const float v1[4], const float v2[4], const float v3[4], const float v4[4], const float w[4])
{
p[0] = v1[0]*w[0] + v2[0]*w[1] + v3[0]*w[2] + v4[0]*w[3];
p[1] = v1[1]*w[0] + v2[1]*w[1] + v3[1]*w[2] + v4[1]*w[3];
p[2] = v1[2]*w[0] + v2[2]*w[1] + v3[2]*w[2] + v4[2]*w[3];
p[3] = v1[3]*w[0] + v2[3]*w[1] + v3[3]*w[2] + v4[3]*w[3];
}
void mid_v3_v3v3(float v[3], const float v1[3], const float v2[3])
{
v[0]= 0.5f*(v1[0] + v2[0]);

1
source/blender/blenloader/CMakeLists.txt
View File

@ -30,6 +30,7 @@ set(INC
../blenlib
../makesdna
../makesrna
../nodes
../render/extern/include
../../../intern/guardedalloc
)

2
source/blender/blenloader/SConscript
View File

@ -5,7 +5,7 @@ sources = env.Glob('intern/*.c')
incs = '. #/intern/guardedalloc ../blenlib ../blenkernel'
incs += ' ../makesdna ../editors/include'
incs += ' ../render/extern/include ../makesrna'
incs += ' ../render/extern/include ../makesrna ../nodes'
incs += ' ' + env['BF_ZLIB_INC']

217
source/blender/blenloader/intern/readfile.c
View File

@ -134,6 +134,8 @@
#include "BKE_utildefines.h" // SWITCH_INT DATA ENDB DNA1 O_BINARY GLOB USER TEST REND
#include "BKE_sound.h"
#include "NOD_socket.h"
//XXX #include "BIF_butspace.h" // badlevel, for do_versions, patching event codes
//XXX #include "BIF_filelist.h" // badlevel too, where to move this? - elubie
//XXX #include "BIF_previewrender.h" // bedlelvel, for struct RenderInfo
@ -2052,10 +2054,21 @@ static void lib_link_nodetree(FileData *fd, Main *main)
}
}
static void lib_nodetree_init_types_cb(void *UNUSED(data), ID *UNUSED(id), bNodeTree *ntree)
{
bNode *node;
ntreeInitTypes(ntree);
/* XXX could be replaced by do_versions for new nodes */
for (node=ntree->nodes.first; node; node=node->next)
node_verify_socket_templates(ntree, node);
}
/* updates group node socket own_index so that
* external links to/from the group node are preserved.
*/
static void lib_node_do_versions_group(bNode *gnode)
static void lib_node_do_versions_group_indices(bNode *gnode)
{
bNodeTree *ngroup= (bNodeTree*)gnode->id;
bNode *intnode;
@ -2088,92 +2101,101 @@ static void lib_node_do_versions_group(bNode *gnode)
}
/* updates external links for all group nodes in a tree */
static void lib_nodetree_do_versions_group(bNodeTree *ntree)
static void lib_nodetree_do_versions_group_indices_cb(void *UNUSED(data), ID *UNUSED(id), bNodeTree *ntree)
{
bNode *node;
for (node=ntree->nodes.first; node; node=node->next) {
if (node->type==NODE_GROUP) {
bNodeTree *ngroup= (bNodeTree*)node->id;
if (ngroup && (ngroup->flag & NTREE_DO_VERSIONS))
lib_node_do_versions_group(node);
if (ngroup && (ngroup->flag & NTREE_DO_VERSIONS_GROUP_EXPOSE))
lib_node_do_versions_group_indices(node);
}
}
}
/* make an update call for the tree */
static void lib_nodetree_do_versions_update_cb(void *UNUSED(data), ID *UNUSED(id), bNodeTree *ntree)
{
if (ntree->update)
ntreeUpdateTree(ntree);
}
/* verify types for nodes and groups, all data has to be read */
/* open = 0: appending/linking, open = 1: open new file (need to clean out dynamic
* typedefs*/
static void lib_verify_nodetree(Main *main, int UNUSED(open))
{
Scene *sce;
Material *ma;
Tex *tx;
bNodeTree *ntree;
int i;
bNodeTreeType *ntreetype;
/* this crashes blender on undo/redo
if(open==1) {
reinit_nodesystem();
}*/
/* now create the own typeinfo structs an verify nodes */
/* here we still assume no groups in groups */
for(ntree= main->nodetree.first; ntree; ntree= ntree->id.next) {
ntreeVerifyTypes(ntree); /* internal nodes, no groups! */
/* set node->typeinfo pointers */
for (i=0; i < NUM_NTREE_TYPES; ++i) {
ntreetype= ntreeGetType(i);
if (ntreetype && ntreetype->foreach_nodetree)
ntreetype->foreach_nodetree(main, NULL, lib_nodetree_init_types_cb);
}
for(ntree= main->nodetree.first; ntree; ntree= ntree->id.next)
ntreeInitTypes(ntree);
{
/*int has_old_groups=0;*/ /*UNUSED*/
int has_old_groups=0;
/* XXX this should actually be part of do_versions, but since we need
* finished library linking, it is not possible there. Instead in do_versions
* we have set the NTREE_DO_VERSIONS flag, so at this point we can do the
* actual group node updates.
*/
for(ntree= main->nodetree.first; ntree; ntree= ntree->id.next) {
if (ntree->flag & NTREE_DO_VERSIONS) {
if (ntree->flag & NTREE_DO_VERSIONS_GROUP_EXPOSE) {
/* this adds copies and links from all unlinked internal sockets to group inputs/outputs. */
nodeGroupExposeAllSockets(ntree);
/*has_old_groups = 1;*/ /*UNUSED*/
node_group_expose_all_sockets(ntree);
has_old_groups = 1;
}
}
/* now verify all types in material trees, groups are set OK now */
for(ma= main->mat.first; ma; ma= ma->id.next) {
if(ma->nodetree)
lib_nodetree_do_versions_group(ma->nodetree);
if (has_old_groups) {
for (i=0; i < NUM_NTREE_TYPES; ++i) {
ntreetype= ntreeGetType(i);
if (ntreetype && ntreetype->foreach_nodetree)
ntreetype->foreach_nodetree(main, NULL, lib_nodetree_do_versions_group_indices_cb);
}
/* and scene trees */
for(sce= main->scene.first; sce; sce= sce->id.next) {
if(sce->nodetree)
lib_nodetree_do_versions_group(sce->nodetree);
}
/* and texture trees */
for(tx= main->tex.first; tx; tx= tx->id.next) {
if(tx->nodetree)
lib_nodetree_do_versions_group(tx->nodetree);
}
for(ntree= main->nodetree.first; ntree; ntree= ntree->id.next)
ntree->flag &= ~NTREE_DO_VERSIONS;
ntree->flag &= ~NTREE_DO_VERSIONS_GROUP_EXPOSE;
}
/* now verify all types in material trees, groups are set OK now */
for(ma= main->mat.first; ma; ma= ma->id.next) {
if(ma->nodetree)
ntreeVerifyTypes(ma->nodetree);
/* verify all group user nodes */
for(ntree= main->nodetree.first; ntree; ntree= ntree->id.next) {
ntreeVerifyNodes(main, &ntree->id);
}
/* and scene trees */
for(sce= main->scene.first; sce; sce= sce->id.next) {
if(sce->nodetree)
ntreeVerifyTypes(sce->nodetree);
/* make update calls where necessary */
{
for(ntree= main->nodetree.first; ntree; ntree= ntree->id.next)
if (ntree->update)
ntreeUpdateTree(ntree);
for (i=0; i < NUM_NTREE_TYPES; ++i) {
ntreetype= ntreeGetType(i);
if (ntreetype && ntreetype->foreach_nodetree)
ntreetype->foreach_nodetree(main, NULL, lib_nodetree_do_versions_update_cb);
}
/* and texture trees */
for(tx= main->tex.first; tx; tx= tx->id.next) {
if(tx->nodetree)
ntreeVerifyTypes(tx->nodetree);
}
}
static void direct_link_node_socket(FileData *fd, bNodeSocket *sock)
{
sock->link= newdataadr(fd, sock->link);
sock->storage= newdataadr(fd, sock->storage);
sock->default_value= newdataadr(fd, sock->default_value);
sock->cache= NULL;
}
/* ntree itself has been read! */
static void direct_link_nodetree(FileData *fd, bNodeTree *ntree)
@ -2185,6 +2207,7 @@ static void direct_link_nodetree(FileData *fd, bNodeTree *ntree)
ntree->init= 0; /* to set callbacks and force setting types */
ntree->progress= NULL;
ntree->execdata= NULL;
ntree->adt= newdataadr(fd, ntree->adt);
direct_link_animdata(fd, ntree->adt);
@ -2197,9 +2220,11 @@ static void direct_link_nodetree(FileData *fd, bNodeTree *ntree)
node->typeinfo= NULL;
}
link_list(fd, &node->inputs);
link_list(fd, &node->outputs);
node->storage= newdataadr(fd, node->storage);
if(node->storage) {
/* could be handlerized at some point */
if(ntree->type==NTREE_SHADER && (node->type==SH_NODE_CURVE_VEC || node->type==SH_NODE_CURVE_RGB))
direct_link_curvemapping(fd, node->storage);
@ -2216,8 +2241,6 @@ static void direct_link_nodetree(FileData *fd, bNodeTree *ntree)
((ImageUser *)node->storage)->ok= 1;
}
}
link_list(fd, &node->inputs);
link_list(fd, &node->outputs);
}
link_list(fd, &ntree->links);
@ -2227,15 +2250,19 @@ static void direct_link_nodetree(FileData *fd, bNodeTree *ntree)
/* and we connect the rest */
for(node= ntree->nodes.first; node; node= node->next) {
node->parent = newdataadr(fd, node->parent);
node->preview= newimaadr(fd, node->preview);
node->lasty= 0;
for(sock= node->inputs.first; sock; sock= sock->next)
sock->link= newdataadr(fd, sock->link);
direct_link_node_socket(fd, sock);
for(sock= node->outputs.first; sock; sock= sock->next)
sock->ns.data= NULL;
direct_link_node_socket(fd, sock);
}
for(sock= ntree->inputs.first; sock; sock= sock->next)
direct_link_node_socket(fd, sock);
for(sock= ntree->outputs.first; sock; sock= sock->next)
sock->link= newdataadr(fd, sock->link);
direct_link_node_socket(fd, sock);
for(link= ntree->links.first; link; link= link->next) {
link->fromnode= newdataadr(fd, link->fromnode);
@ -4957,8 +4984,11 @@ static void lib_link_screen(FileData *fd, Main *main)
SpaceNode *snode= (SpaceNode *)sl;
snode->id= newlibadr(fd, sc->id.lib, snode->id);
snode->edittree= NULL;
if (ELEM3(snode->treetype, NTREE_COMPOSIT, NTREE_SHADER, NTREE_TEXTURE)) {
/* internal data, a bit patchy */
snode->nodetree= NULL;
if(snode->id) {
if(GS(snode->id->name)==ID_MA)
snode->nodetree= ((Material *)snode->id)->nodetree;
@ -4967,6 +4997,10 @@ static void lib_link_screen(FileData *fd, Main *main)
else if(GS(snode->id->name)==ID_TE)
snode->nodetree= ((Tex *)snode->id)->nodetree;
}
}
else {
snode->nodetree= newlibadr_us(fd, sc->id.lib, snode->nodetree);
}
snode->linkdrag.first = snode->linkdrag.last = NULL;
}
@ -5185,9 +5219,9 @@ void lib_link_screen_restore(Main *newmain, bScreen *curscreen, Scene *curscene)
snode->id= restore_pointer_by_name(newmain, snode->id, 1);
snode->edittree= NULL;
if(snode->id==NULL)
if (ELEM3(snode->treetype, NTREE_COMPOSIT, NTREE_SHADER, NTREE_TEXTURE)) {
snode->nodetree= NULL;
else {
if(snode->id) {
if(GS(snode->id->name)==ID_MA)
snode->nodetree= ((Material *)snode->id)->nodetree;
else if(GS(snode->id->name)==ID_SCE)
@ -5196,6 +5230,10 @@ void lib_link_screen_restore(Main *newmain, bScreen *curscreen, Scene *curscene)
snode->nodetree= ((Tex *)snode->id)->nodetree;
}
}
else {
snode->nodetree= restore_pointer_by_name(newmain, &snode->nodetree->id, 1);
}
}
}
sa= sa->next;
}
@ -5422,7 +5460,6 @@ static void direct_link_screen(FileData *fd, bScreen *sc)
snode->gpd= newdataadr(fd, snode->gpd);
direct_link_gpencil(fd, snode->gpd);
}
snode->nodetree= snode->edittree= NULL;
}
else if(sl->spacetype==SPACE_TIME) {
SpaceTime *stime= (SpaceTime *)sl;
@ -6931,6 +6968,53 @@ static void do_version_bone_roll_256(Bone *bone)
do_version_bone_roll_256(child);
}
static void do_versions_socket_default_value(bNodeSocket *sock)
{
bNodeSocketValueFloat *valfloat;
bNodeSocketValueVector *valvector;
bNodeSocketValueRGBA *valrgba;
if (sock->default_value)
return;
switch (sock->type) {
case SOCK_FLOAT:
valfloat = sock->default_value = MEM_callocN(sizeof(bNodeSocketValueFloat), "default socket value");
valfloat->value = sock->ns.vec[0];
valfloat->min = sock->ns.min;
valfloat->max = sock->ns.max;
valfloat->subtype = PROP_NONE;
break;
case SOCK_VECTOR:
valvector = sock->default_value = MEM_callocN(sizeof(bNodeSocketValueVector), "default socket value");
copy_v3_v3(valvector->value, sock->ns.vec);
valvector->min = sock->ns.min;
valvector->max = sock->ns.max;
valvector->subtype = PROP_NONE;
break;
case SOCK_RGBA:
valrgba = sock->default_value = MEM_callocN(sizeof(bNodeSocketValueRGBA), "default socket value");
copy_v4_v4(valrgba->value, sock->ns.vec);
break;
}
}
static void do_versions_nodetree_default_value(bNodeTree *ntree)
{
bNode *node;
bNodeSocket *sock;
for (node=ntree->nodes.first; node; node=node->next) {
for (sock=node->inputs.first; sock; sock=sock->next)
do_versions_socket_default_value(sock);
for (sock=node->outputs.first; sock; sock=sock->next)
do_versions_socket_default_value(sock);
}
for (sock=ntree->inputs.first; sock; sock=sock->next)
do_versions_socket_default_value(sock);
for (sock=ntree->outputs.first; sock; sock=sock->next)
do_versions_socket_default_value(sock);
}
static void do_versions(FileData *fd, Library *lib, Main *main)
{
/* WATCH IT!!!: pointers from libdata have not been converted */
@ -11582,7 +11666,7 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
* is done in lib_verify_nodetree, because at this point the internal
* nodes may not be up-to-date! (missing lib-link)
*/
ntree->flag |= NTREE_DO_VERSIONS;
ntree->flag |= NTREE_DO_VERSIONS_GROUP_EXPOSE;
}
}
@ -11861,6 +11945,35 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
}
}
if (main->versionfile < 259 || (main->versionfile == 259 && main->subversionfile < 2)){
{
/* Convert default socket values from bNodeStack */
Scene *sce;
Material *mat;
Tex *tex;
bNodeTree *ntree;
for (ntree=main->nodetree.first; ntree; ntree=ntree->id.next) {
do_versions_nodetree_default_value(ntree);
ntree->update |= NTREE_UPDATE;
}
for (sce=main->scene.first; sce; sce=sce->id.next)
if (sce->nodetree) {
do_versions_nodetree_default_value(sce->nodetree);
sce->nodetree->update |= NTREE_UPDATE;
}
for (mat=main->mat.first; mat; mat=mat->id.next)
if (mat->nodetree) {
do_versions_nodetree_default_value(mat->nodetree);
mat->nodetree->update |= NTREE_UPDATE;
}
for (tex=main->tex.first; tex; tex=tex->id.next)
if (tex->nodetree) {
do_versions_nodetree_default_value(tex->nodetree);
tex->nodetree->update |= NTREE_UPDATE;
}
}
}
/* put compatibility code here until next subversion bump */
{

22
source/blender/blenloader/intern/writefile.c
View File

@ -642,6 +642,14 @@ static void write_curvemapping(WriteData *wd, CurveMapping *cumap)
writestruct(wd, DATA, "CurveMapPoint", cumap->cm[a].totpoint, cumap->cm[a].curve);
}
static void write_node_socket(WriteData *wd, bNodeSocket *sock)
{
bNodeSocketType *stype= ntreeGetSocketType(sock->type);
writestruct(wd, DATA, "bNodeSocket", 1, sock);
if (sock->default_value)
writestruct(wd, DATA, stype->value_structname, 1, sock->default_value);
}
/* this is only direct data, tree itself should have been written */
static void write_nodetree(WriteData *wd, bNodeTree *ntree)
{
@ -657,6 +665,12 @@ static void write_nodetree(WriteData *wd, bNodeTree *ntree)
writestruct(wd, DATA, "bNode", 1, node);
for(node= ntree->nodes.first; node; node= node->next) {
for(sock= node->inputs.first; sock; sock= sock->next)
write_node_socket(wd, sock);
for(sock= node->outputs.first; sock; sock= sock->next)
write_node_socket(wd, sock);
if(node->storage && node->type!=NODE_DYNAMIC) {
/* could be handlerized at some point, now only 1 exception still */
if(ntree->type==NTREE_SHADER && (node->type==SH_NODE_CURVE_VEC || node->type==SH_NODE_CURVE_RGB))
@ -668,10 +682,6 @@ static void write_nodetree(WriteData *wd, bNodeTree *ntree)
else
writestruct(wd, DATA, node->typeinfo->storagename, 1, node->storage);
}
for(sock= node->inputs.first; sock; sock= sock->next)
writestruct(wd, DATA, "bNodeSocket", 1, sock);
for(sock= node->outputs.first; sock; sock= sock->next)
writestruct(wd, DATA, "bNodeSocket", 1, sock);
}
for(link= ntree->links.first; link; link= link->next)
@ -679,9 +689,9 @@ static void write_nodetree(WriteData *wd, bNodeTree *ntree)
/* external sockets */
for(sock= ntree->inputs.first; sock; sock= sock->next)
writestruct(wd, DATA, "bNodeSocket", 1, sock);
write_node_socket(wd, sock);
for(sock= ntree->outputs.first; sock; sock= sock->next)
writestruct(wd, DATA, "bNodeSocket", 1, sock);
write_node_socket(wd, sock);
}
static void current_screen_compat(Main *mainvar, bScreen **screen)

5
source/blender/editors/include/ED_node.h
View File

@ -39,6 +39,7 @@ struct Material;
struct Scene;
struct Tex;
struct bContext;
struct bNodeTree;
struct bNode;
struct bNodeTree;
struct ScrArea;
@ -47,6 +48,7 @@ struct ScrArea;
void ED_init_node_butfuncs(void);
/* node_draw.c */
void ED_node_tree_update(struct SpaceNode *snode, struct Scene *scene);
void ED_node_changed_update(struct ID *id, struct bNode *node);
void ED_node_generic_update(struct Main *bmain, struct bNodeTree *ntree, struct bNode *node);
@ -57,8 +59,9 @@ void ED_node_texture_default(struct Tex *tex);
void ED_node_link_intersect_test(struct ScrArea *sa, int test);
void ED_node_link_insert(struct ScrArea *sa);
void ED_node_set_active(struct Main *bmain, struct bNodeTree *ntree, struct bNode *node);
void ED_node_update_hierarchy(struct bContext *C, struct bNodeTree *ntree);
void ED_node_set_active(struct Main *bmain, struct bNodeTree *ntree, struct bNode *node);
/* node ops.c */
void ED_operatormacros_node(void);

5
source/blender/editors/sculpt_paint/paint_image.c
View File

@ -60,6 +60,7 @@
#include "DNA_brush_types.h"
#include "DNA_mesh_types.h"
#include "DNA_meshdata_types.h"
#include "DNA_node_types.h"
#include "DNA_object_types.h"
#include "DNA_scene_types.h"
#include "DNA_texture_types.h"
@ -4663,7 +4664,7 @@ static void paint_brush_init_tex(Brush *brush)
if(brush) {
MTex *mtex= &brush->mtex;
if(mtex->tex && mtex->tex->nodetree)
ntreeBeginExecTree(mtex->tex->nodetree); /* has internal flag to detect it only does it once */
ntreeTexBeginExecTree(mtex->tex->nodetree); /* has internal flag to detect it only does it once */
}
}
@ -4805,7 +4806,7 @@ static void paint_brush_exit_tex(Brush *brush)
if(brush) {
MTex *mtex= &brush->mtex;
if(mtex->tex && mtex->tex->nodetree)
ntreeEndExecTree(mtex->tex->nodetree);
ntreeTexEndExecTree(mtex->tex->nodetree->execdata);
}
}

5
source/blender/editors/sculpt_paint/sculpt.c
View File

@ -48,6 +48,7 @@
#include "BLI_rand.h"
#include "DNA_meshdata_types.h"
#include "DNA_node_types.h"
#include "DNA_object_types.h"
#include "DNA_scene_types.h"
#include "DNA_brush_types.h"
@ -3273,7 +3274,7 @@ static void sculpt_brush_init_tex(Sculpt *sd, SculptSession *ss)
/* init mtex nodes */
if(mtex->tex && mtex->tex->nodetree)
ntreeBeginExecTree(mtex->tex->nodetree); /* has internal flag to detect it only does it once */
ntreeTexBeginExecTree(mtex->tex->nodetree); /* has internal flag to detect it only does it once */
/* TODO: Shouldn't really have to do this at the start of every
stroke, but sculpt would need some sort of notification when
@ -3454,7 +3455,7 @@ static void sculpt_brush_exit_tex(Sculpt *sd)
MTex *mtex= &brush->mtex;
if(mtex->tex && mtex->tex->nodetree)
ntreeEndExecTree(mtex->tex->nodetree);
ntreeTexEndExecTree(mtex->tex->nodetree->execdata);
}
static void sculpt_stroke_done(bContext *C, struct PaintStroke *UNUSED(stroke))

746
source/blender/editors/space_node/drawnode.c
View File

@ -53,9 +53,10 @@
#include "BKE_image.h"
#include "BKE_library.h"
#include "BKE_main.h"
#include "BKE_node.h"
#include "CMP_node.h"
#include "SHD_node.h"
#include "NOD_composite.h"
#include "NOD_shader.h"
#include "BIF_gl.h"
#include "BIF_glutil.h"
@ -81,6 +82,141 @@
#include "node_intern.h"
// XXX interface.h
extern void ui_dropshadow(rctf *rct, float radius, float aspect, int select);
/* ****************** SOCKET BUTTON DRAW FUNCTIONS ***************** */
static void node_sync_cb(bContext *UNUSED(C), void *snode_v, void *node_v)
{
SpaceNode *snode= snode_v;
if(snode->treetype==NTREE_SHADER) {
nodeShaderSynchronizeID(node_v, 1);
// allqueue(REDRAWBUTSSHADING, 0);
}
}
void node_socket_button_default(const bContext *C, uiBlock *block,
bNodeTree *ntree, bNode *node, bNodeSocket *sock,
const char *name, int x, int y, int width)
{
PointerRNA ptr;
uiBut *bt;
RNA_pointer_create(&ntree->id, &RNA_NodeSocket, sock, &ptr);
bt = uiDefButR(block, NUM, B_NODE_EXEC, name,
x, y+1, width, NODE_DY-2,
&ptr, "default_value", 0, 0, 0, -1, -1, NULL);
if (node)
uiButSetFunc(bt, node_sync_cb, CTX_wm_space_node(C), node);
}
typedef struct SocketComponentMenuArgs {
PointerRNA ptr;
int x, y, width;
uiButHandleFunc cb;
void *arg1, *arg2;
} SocketComponentMenuArgs;
/* NOTE: this is a block-menu, needs 0 events, otherwise the menu closes */
static uiBlock *socket_component_menu(bContext *C, ARegion *ar, void *args_v)
{
SocketComponentMenuArgs *args= (SocketComponentMenuArgs*)args_v;
uiBlock *block;
uiLayout *layout;
block= uiBeginBlock(C, ar, "socket menu", UI_EMBOSS);
uiBlockSetFlag(block, UI_BLOCK_KEEP_OPEN);
layout= uiLayoutColumn(uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, args->x, args->y+2, args->width, NODE_DY, U.uistyles.first), 0);
uiItemR(layout, &args->ptr, "default_value", UI_ITEM_R_EXPAND, "", ICON_NONE);
return block;
}
void node_socket_button_components(const bContext *C, uiBlock *block,
bNodeTree *ntree, bNode *node, bNodeSocket *sock,
const char *name, int x, int y, int width)
{
PointerRNA ptr;
SocketComponentMenuArgs *args;
RNA_pointer_create(&ntree->id, &RNA_NodeSocket, sock, &ptr);
args= MEM_callocN(sizeof(SocketComponentMenuArgs), "SocketComponentMenuArgs");
args->ptr = ptr;
args->x = x;
args->y = y;
args->width = width;
args->cb = node_sync_cb;
args->arg1 = CTX_wm_space_node(C);
args->arg2 = node;
uiDefBlockButN(block, socket_component_menu, args, name, x, y+1, width, NODE_DY-2, "");
}
void node_socket_button_color(const bContext *C, uiBlock *block,
bNodeTree *ntree, bNode *node, bNodeSocket *sock,
const char *name, int x, int y, int width)
{
PointerRNA ptr;
uiBut *bt;
int labelw= width - 40;
RNA_pointer_create(&ntree->id, &RNA_NodeSocket, sock, &ptr);
bt=uiDefButR(block, COL, B_NODE_EXEC, "",
x, y+2, (labelw>0 ? 40 : width), NODE_DY-2,
&ptr, "default_value", 0, 0, 0, -1, -1, NULL);
if (node)
uiButSetFunc(bt, node_sync_cb, CTX_wm_space_node(C), node);
if (name[0]!='\0' && labelw>0)
uiDefBut(block, LABEL, 0, name, x + 40, y+2, labelw, NODE_DY-2, NULL, 0, 0, 0, 0, "");
}
/* ****************** BASE DRAW FUNCTIONS FOR NEW OPERATOR NODES ***************** */
void node_draw_socket_new(bNodeSocket *sock, float size)
{
float x=sock->locx, y=sock->locy;
/* 16 values of sin function */
static float si[16] = {
0.00000000f, 0.39435585f,0.72479278f,0.93775213f,
0.99871650f,0.89780453f,0.65137248f,0.29936312f,
-0.10116832f,-0.48530196f,-0.79077573f,-0.96807711f,
-0.98846832f,-0.84864425f,-0.57126821f,-0.20129852f
};
/* 16 values of cos function */
static float co[16] ={
1.00000000f,0.91895781f,0.68896691f,0.34730525f,
-0.05064916f,-0.44039415f,-0.75875812f,-0.95413925f,
-0.99486932f,-0.87434661f,-0.61210598f,-0.25065253f,
0.15142777f,0.52896401f,0.82076344f,0.97952994f,
};
int a;
glColor3ub(180, 180, 180);
glBegin(GL_POLYGON);
for(a=0; a<16; a++)
glVertex2f(x+size*si[a], y+size*co[a]);
glEnd();
glColor4ub(0, 0, 0, 150);
glEnable(GL_BLEND);
glEnable( GL_LINE_SMOOTH );
glBegin(GL_LINE_LOOP);
for(a=0; a<16; a++)
glVertex2f(x+size*si[a], y+size*co[a]);
glEnd();
glDisable( GL_LINE_SMOOTH );
glDisable(GL_BLEND);
}
/* ****************** BUTTON CALLBACKS FOR ALL TREES ***************** */
static void node_buts_value(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
@ -192,11 +328,12 @@ static void node_buts_normal(uiLayout *layout, bContext *UNUSED(C), PointerRNA *
bNode *node= ptr->data;
rctf *butr= &node->butr;
bNodeSocket *sock= node->outputs.first; /* first socket stores normal */
float *nor= ((bNodeSocketValueVector*)sock->default_value)->value;
uiBut *bt;
bt= uiDefButF(block, BUT_NORMAL, B_NODE_EXEC, "",
(short)butr->xmin, (short)butr->xmin, butr->xmax-butr->xmin, butr->xmax-butr->xmin,
sock->ns.vec, 0.0f, 1.0f, 0, 0, "");
nor, 0.0f, 1.0f, 0, 0, "");
uiButSetFunc(bt, node_normal_cb, ntree, node);
}
#if 0 // not used in 2.5x yet
@ -287,6 +424,470 @@ static void node_buts_math(uiLayout *layout, bContext *UNUSED(C), PointerRNA *pt
uiItemR(layout, ptr, "operation", 0, "", ICON_NONE);
}
static int node_resize_area_default(bNode *node, int x, int y)
{
if (node->flag & NODE_HIDDEN) {
rctf totr= node->totr;
/* right part of node */
totr.xmin= node->totr.xmax-20.0f;
return BLI_in_rctf(&totr, x, y);
}
else {
/* rect we're interested in is just the bottom right corner */
rctf totr= node->totr;
/* bottom right corner */
totr.xmin= totr.xmax-10.0f;
totr.ymax= totr.ymin+10.0f;
return BLI_in_rctf(&totr, x, y);
}
}
/* ****************** BUTTON CALLBACKS FOR COMMON NODES ***************** */
/* width of socket columns in group display */
#define NODE_GROUP_FRAME 120
/* based on settings in node, sets drawing rect info. each redraw! */
/* note: this assumes only 1 group at a time is drawn (linked data) */
/* in node->totr the entire boundbox for the group is stored */
static void node_update_group(const bContext *C, bNodeTree *ntree, bNode *gnode)
{
if (!(gnode->flag & NODE_GROUP_EDIT)) {
node_update_default(C, ntree, gnode);
}
else {
bNodeTree *ngroup= (bNodeTree *)gnode->id;
bNode *node;
bNodeSocket *sock, *gsock;
float locx, locy;
rctf *rect= &gnode->totr;
float node_group_frame= U.dpi*NODE_GROUP_FRAME/72;
int counter;
int dy;
/* get "global" coords */
nodeSpaceCoords(gnode, &locx, &locy);
/* center them, is a bit of abuse of locx and locy though */
node_update_nodetree(C, ngroup, locx, locy);
rect->xmin = rect->xmax = locx;
rect->ymin = rect->ymax = locy;
counter= 1;
for(node= ngroup->nodes.first; node; node= node->next) {
if(counter) {
*rect= node->totr;
counter= 0;
}
else
BLI_union_rctf(rect, &node->totr);
}
/* add some room for links to group sockets */
rect->xmin -= 4*NODE_DY;
rect->xmax += 4*NODE_DY;
rect->ymin-= NODE_DY;
rect->ymax+= NODE_DY;
/* input sockets */
dy = 0.5f*(rect->ymin+rect->ymax) + NODE_DY*(BLI_countlist(&gnode->inputs)-1);
gsock=ngroup->inputs.first;
sock=gnode->inputs.first;
while (gsock || sock) {
while (sock && !sock->groupsock) {
sock->locx = rect->xmin - node_group_frame;
sock->locy = dy;
/* prevent long socket lists from growing out of the group box */
if (dy-3*NODE_DYS < rect->ymin)
rect->ymin = dy-3*NODE_DYS;
if (dy+3*NODE_DYS > rect->ymax)
rect->ymax = dy+3*NODE_DYS;
dy -= 2*NODE_DY;
sock = sock->next;
}
while (gsock && (!sock || sock->groupsock!=gsock)) {
gsock->locx = rect->xmin;
gsock->locy = dy;
/* prevent long socket lists from growing out of the group box */
if (dy-3*NODE_DYS < rect->ymin)
rect->ymin = dy-3*NODE_DYS;
if (dy+3*NODE_DYS > rect->ymax)
rect->ymax = dy+3*NODE_DYS;
dy -= 2*NODE_DY;
gsock = gsock->next;
}
while (sock && gsock && sock->groupsock==gsock) {
gsock->locx = rect->xmin;
sock->locx = rect->xmin - node_group_frame;
sock->locy = gsock->locy = dy;
/* prevent long socket lists from growing out of the group box */
if (dy-3*NODE_DYS < rect->ymin)
rect->ymin = dy-3*NODE_DYS;
if (dy+3*NODE_DYS > rect->ymax)
rect->ymax = dy+3*NODE_DYS;
dy -= 2*NODE_DY;
sock = sock->next;
gsock = gsock->next;
}
}
/* output sockets */
dy = 0.5f*(rect->ymin+rect->ymax) + NODE_DY*(BLI_countlist(&gnode->outputs)-1);
gsock=ngroup->outputs.first;
sock=gnode->outputs.first;
while (gsock || sock) {
while (sock && !sock->groupsock) {
sock->locx = rect->xmax + node_group_frame;
sock->locy = dy - NODE_DYS;
/* prevent long socket lists from growing out of the group box */
if (dy-3*NODE_DYS < rect->ymin)
rect->ymin = dy-3*NODE_DYS;
if (dy+3*NODE_DYS > rect->ymax)
rect->ymax = dy+3*NODE_DYS;
dy -= 2*NODE_DY;
sock = sock->next;
}
while (gsock && (!sock || sock->groupsock!=gsock)) {
gsock->locx = rect->xmax;
gsock->locy = dy - NODE_DYS;
/* prevent long socket lists from growing out of the group box */
if (dy-3*NODE_DYS < rect->ymin)
rect->ymin = dy-3*NODE_DYS;
if (dy+3*NODE_DYS > rect->ymax)
rect->ymax = dy+3*NODE_DYS;
dy -= 2*NODE_DY;
gsock = gsock->next;
}
while (sock && gsock && sock->groupsock==gsock) {
gsock->locx = rect->xmax;
sock->locx = rect->xmax + node_group_frame;
sock->locy = gsock->locy = dy - NODE_DYS;
/* prevent long socket lists from growing out of the group box */
if (dy-3*NODE_DYS < rect->ymin)
rect->ymin = dy-3*NODE_DYS;
if (dy+3*NODE_DYS > rect->ymax)
rect->ymax = dy+3*NODE_DYS;
dy -= 2*NODE_DY;
sock = sock->next;
gsock = gsock->next;
}
}
}
}
static void update_group_input_cb(bContext *UNUSED(C), void *UNUSED(snode_v), void *ngroup_v)
{
bNodeTree *ngroup= (bNodeTree*)ngroup_v;
ngroup->update |= NTREE_UPDATE_GROUP_IN;
ntreeUpdateTree(ngroup);
}
static void update_group_output_cb(bContext *UNUSED(C), void *UNUSED(snode_v), void *ngroup_v)
{
bNodeTree *ngroup= (bNodeTree*)ngroup_v;
ngroup->update |= NTREE_UPDATE_GROUP_OUT;
ntreeUpdateTree(ngroup);
}
static void draw_group_socket_name(SpaceNode *snode, bNode *gnode, bNodeSocket *sock, int in_out, float xoffset, float yoffset)
{
bNodeTree *ngroup= (bNodeTree*)gnode->id;
uiBut *bt;
if (sock->flag & SOCK_DYNAMIC) {
bt = uiDefBut(gnode->block, TEX, 0, "",
sock->locx+xoffset, sock->locy+1+yoffset, 72, NODE_DY,
sock->name, 0, 31, 0, 0, "");
if (in_out==SOCK_IN)
uiButSetFunc(bt, update_group_input_cb, snode, ngroup);
else
uiButSetFunc(bt, update_group_output_cb, snode, ngroup);
}
else {
uiDefBut(gnode->block, LABEL, 0, sock->name,
sock->locx+xoffset, sock->locy+1+yoffset, 72, NODE_DY,
NULL, 0, 31, 0, 0, "");
}
}
static void draw_group_socket(const bContext *C, SpaceNode *snode, bNodeTree *ntree, bNode *gnode, bNodeSocket *sock, bNodeSocket *gsock, int index, int in_out)
{
bNodeTree *ngroup= (bNodeTree*)gnode->id;
bNodeSocketType *stype= ntreeGetSocketType(gsock ? gsock->type : sock->type);
uiBut *bt;
float offset;
int draw_value;
float node_group_frame= U.dpi*NODE_GROUP_FRAME/72;
float socket_size= NODE_SOCKSIZE*U.dpi/72;
float arrowbutw= 0.8f*UI_UNIT_X;
/* layout stuff for buttons on group left frame */
float colw= 0.6f*node_group_frame;
float col1= 6;
float col2= col1 + colw+6;
float col3= node_group_frame - arrowbutw - 6;
/* layout stuff for buttons on group right frame */
float cor1= 6;
float cor2= cor1 + arrowbutw + 6;
float cor3= cor2 + arrowbutw + 6;
/* node and group socket circles */
if (sock)
node_socket_circle_draw(ntree, sock, socket_size);
if (gsock)
node_socket_circle_draw(ngroup, gsock, socket_size);
/* socket name */
offset = (in_out==SOCK_IN ? col1 : cor3);
if (!gsock)
offset += (in_out==SOCK_IN ? node_group_frame : -node_group_frame);
/* draw both name and value button if:
* 1) input: not internal
* 2) output: (node type uses const outputs) and (group output is unlinked)
*/
switch (in_out) {
case SOCK_IN:
draw_value = !(gsock && (gsock->flag & SOCK_INTERNAL));
break;
case SOCK_OUT:
if (gnode->typeinfo->flag & NODE_CONST_OUTPUT)
draw_value = !(gsock && gsock->link);
else
draw_value = 0;
break;
}
if (draw_value) {
/* both name and value buttons */
if (gsock) {
draw_group_socket_name(snode, gnode, gsock, in_out, offset, 0);
if (stype->buttonfunc)
stype->buttonfunc(C, gnode->block, ngroup, NULL, gsock, "", gsock->locx+offset, gsock->locy-NODE_DY, colw);
}
else {
draw_group_socket_name(snode, gnode, sock, in_out, offset, 0);
if (stype->buttonfunc)
stype->buttonfunc(C, gnode->block, ngroup, NULL, sock, "", sock->locx+offset, sock->locy-NODE_DY, colw);
}
}
else {
/* only name, no value button */
if (gsock)
draw_group_socket_name(snode, gnode, gsock, in_out, offset, -NODE_DYS);
else
draw_group_socket_name(snode, gnode, sock, in_out, offset, -NODE_DYS);
}
if (gsock && (gsock->flag & SOCK_DYNAMIC)) {
/* up/down buttons */
offset = (in_out==SOCK_IN ? col2 : cor2);
uiBlockSetDirection(gnode->block, UI_TOP);
uiBlockBeginAlign(gnode->block);
bt = uiDefIconButO(gnode->block, BUT, "NODE_OT_group_socket_move_up", 0, ICON_TRIA_UP,
gsock->locx+offset, gsock->locy, arrowbutw, arrowbutw, "");
if (!gsock->prev || !(gsock->prev->flag & SOCK_DYNAMIC))
uiButSetFlag(bt, UI_BUT_DISABLED);
RNA_int_set(uiButGetOperatorPtrRNA(bt), "index", index);
RNA_enum_set(uiButGetOperatorPtrRNA(bt), "in_out", in_out);
bt = uiDefIconButO(gnode->block, BUT, "NODE_OT_group_socket_move_down", 0, ICON_TRIA_DOWN,
gsock->locx+offset, gsock->locy-arrowbutw, arrowbutw, arrowbutw, "");
if (!gsock->next || !(gsock->next->flag & SOCK_DYNAMIC))
uiButSetFlag(bt, UI_BUT_DISABLED);
RNA_int_set(uiButGetOperatorPtrRNA(bt), "index", index);
RNA_enum_set(uiButGetOperatorPtrRNA(bt), "in_out", in_out);
uiBlockEndAlign(gnode->block);
uiBlockSetDirection(gnode->block, 0);
/* remove button */
offset = (in_out==SOCK_IN ? col3 : col1);
uiBlockSetEmboss(gnode->block, UI_EMBOSSN);
bt = uiDefIconButO(gnode->block, BUT, "NODE_OT_group_socket_remove", 0, ICON_X,
gsock->locx+offset, gsock->locy-0.5f*arrowbutw, arrowbutw, arrowbutw, "");
RNA_int_set(uiButGetOperatorPtrRNA(bt), "index", index);
RNA_enum_set(uiButGetOperatorPtrRNA(bt), "in_out", in_out);
uiBlockSetEmboss(gnode->block, UI_EMBOSS);
}
}
/* groups are, on creation, centered around 0,0 */
static void node_draw_group(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNode *gnode)
{
if (!(gnode->flag & NODE_GROUP_EDIT)) {
node_draw_default(C, ar, snode, ntree, gnode);
}
else {
bNodeTree *ngroup= (bNodeTree *)gnode->id;
bNodeSocket *sock, *gsock;
uiLayout *layout;
PointerRNA ptr;
rctf rect= gnode->totr;
float node_group_frame= U.dpi*NODE_GROUP_FRAME/72;
float group_header= 26*U.dpi/72;
int index;
/* backdrop header */
glEnable(GL_BLEND);
uiSetRoundBox(3);
UI_ThemeColorShadeAlpha(TH_NODE_GROUP, 0, -70);
uiDrawBox(GL_POLYGON, rect.xmin-node_group_frame, rect.ymax, rect.xmax+node_group_frame, rect.ymax+group_header, BASIS_RAD);
/* backdrop body */
UI_ThemeColorShadeAlpha(TH_BACK, -8, -70);
uiSetRoundBox(0);
uiDrawBox(GL_POLYGON, rect.xmin, rect.ymin, rect.xmax, rect.ymax, BASIS_RAD);
/* input column */
UI_ThemeColorShadeAlpha(TH_BACK, 10, -50);
uiSetRoundBox(8);
uiDrawBox(GL_POLYGON, rect.xmin-node_group_frame, rect.ymin, rect.xmin, rect.ymax, BASIS_RAD);
/* output column */
UI_ThemeColorShadeAlpha(TH_BACK, 10, -50);
uiSetRoundBox(4);
uiDrawBox(GL_POLYGON, rect.xmax, rect.ymin, rect.xmax+node_group_frame, rect.ymax, BASIS_RAD);
/* input column separator */
glColor4ub(200, 200, 200, 140);
glBegin(GL_LINES);
glVertex2f(rect.xmin, rect.ymin);
glVertex2f(rect.xmin, rect.ymax);
glEnd();
/* output column separator */
glColor4ub(200, 200, 200, 140);
glBegin(GL_LINES);
glVertex2f(rect.xmax, rect.ymin);
glVertex2f(rect.xmax, rect.ymax);
glEnd();
/* group node outline */
uiSetRoundBox(15);
glColor4ub(200, 200, 200, 140);
glEnable( GL_LINE_SMOOTH );
uiDrawBox(GL_LINE_LOOP, rect.xmin-node_group_frame, rect.ymin, rect.xmax+node_group_frame, rect.ymax+group_header, BASIS_RAD);
glDisable( GL_LINE_SMOOTH );
glDisable(GL_BLEND);
/* backdrop title */
UI_ThemeColor(TH_TEXT_HI);
layout = uiBlockLayout(gnode->block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, (short)(rect.xmin+15), (short)(rect.ymax+group_header),
MIN2((int)(rect.xmax - rect.xmin-18.0f), node_group_frame+20), group_header, U.uistyles.first);
RNA_pointer_create(&ntree->id, &RNA_Node, gnode, &ptr);
uiTemplateIDBrowse(layout, (bContext*)C, &ptr, "node_tree", NULL, NULL, NULL);
uiBlockLayoutResolve(gnode->block, NULL, NULL);
/* draw the internal tree nodes and links */
node_draw_nodetree(C, ar, snode, ngroup);
/* group sockets */
gsock=ngroup->inputs.first;
sock=gnode->inputs.first;
index = 0;
while (gsock || sock) {
while (sock && !sock->groupsock) {
draw_group_socket(C, snode, ntree, gnode, sock, NULL, index, SOCK_IN);
sock = sock->next;
}
while (gsock && (!sock || sock->groupsock!=gsock)) {
draw_group_socket(C, snode, ntree, gnode, NULL, gsock, index, SOCK_IN);
gsock = gsock->next;
++index;
}
while (sock && gsock && sock->groupsock==gsock) {
draw_group_socket(C, snode, ntree, gnode, sock, gsock, index, SOCK_IN);
sock = sock->next;
gsock = gsock->next;
++index;
}
}
gsock=ngroup->outputs.first;
sock=gnode->outputs.first;
index = 0;
while (gsock || sock) {
while (sock && !sock->groupsock) {
draw_group_socket(C, snode, ntree, gnode, sock, NULL, index, SOCK_OUT);
sock = sock->next;
}
while (gsock && (!sock || sock->groupsock!=gsock)) {
draw_group_socket(C, snode, ntree, gnode, NULL, gsock, index, SOCK_OUT);
gsock = gsock->next;
++index;
}
while (sock && gsock && sock->groupsock==gsock) {
draw_group_socket(C, snode, ntree, gnode, sock, gsock, index, SOCK_OUT);
sock = sock->next;
gsock = gsock->next;
++index;
}
}
uiEndBlock(C, gnode->block);
uiDrawBlock(C, gnode->block);
gnode->block= NULL;
}
}
static void node_common_buts_whileloop(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
{
uiItemR(layout, ptr, "max_iterations", 0, NULL, 0);
}
static void node_update_frame(const bContext *UNUSED(C), bNodeTree *UNUSED(ntree), bNode *node)
{
float locx, locy;
/* get "global" coords */
nodeSpaceCoords(node, &locx, &locy);
node->prvr.xmin= locx + NODE_DYS;
node->prvr.xmax= locx + node->width- NODE_DYS;
node->totr.xmin= locx;
node->totr.xmax= locx + node->width;
node->totr.ymax= locy;
node->totr.ymin= locy - node->height;
}
static void node_common_set_butfunc(bNodeType *ntype)
{
switch(ntype->type) {
case NODE_GROUP:
// ntype->uifunc= node_common_buts_group;
ntype->drawfunc= node_draw_group;
ntype->drawupdatefunc= node_update_group;
break;
case NODE_FORLOOP:
// ntype->uifunc= node_common_buts_group;
ntype->drawfunc= node_draw_group;
ntype->drawupdatefunc= node_update_group;
break;
case NODE_WHILELOOP:
ntype->uifunc= node_common_buts_whileloop;
ntype->drawfunc= node_draw_group;
ntype->drawupdatefunc= node_update_group;
break;
case NODE_FRAME:
ntype->drawupdatefunc= node_update_frame;
break;
}
}
/* ****************** BUTTON CALLBACKS FOR SHADER NODES ***************** */
static void node_browse_text_cb(bContext *C, void *ntree_v, void *node_v)
@ -470,8 +1071,6 @@ static void node_shader_set_butfunc(bNodeType *ntype)
case NODE_DYNAMIC:
ntype->uifunc= node_shader_buts_dynamic;
break;
default:
ntype->uifunc= NULL;
}
if (ntype->uifuncbut == NULL) ntype->uifuncbut = ntype->uifunc;
}
@ -1225,8 +1824,6 @@ static void node_composit_set_butfunc(bNodeType *ntype)
case CMP_NODE_SEPYCCA:
ntype->uifunc=node_composit_buts_ycc;
break;
default:
ntype->uifunc= NULL;
}
if (ntype->uifuncbut == NULL) ntype->uifuncbut = ntype->uifunc;
@ -1381,9 +1978,6 @@ static void node_texture_set_butfunc(bNodeType *ntype)
case TEX_NODE_OUTPUT:
ntype->uifunc = node_texture_buts_output;
break;
default:
ntype->uifunc= NULL;
}
if (ntype->uifuncbut == NULL) ntype->uifuncbut = ntype->uifunc;
}
@ -1392,24 +1986,60 @@ static void node_texture_set_butfunc(bNodeType *ntype)
void ED_init_node_butfuncs(void)
{
bNodeTreeType *treetype;
bNodeType *ntype;
bNodeSocketType *stype;
int i;
/* shader nodes */
ntype= node_all_shaders.first;
while(ntype) {
node_shader_set_butfunc(ntype);
ntype= ntype->next;
}
/* composit nodes */
ntype= node_all_composit.first;
while(ntype) {
/* node type ui functions */
for (i=0; i < NUM_NTREE_TYPES; ++i) {
treetype = ntreeGetType(i);
if (treetype) {
for (ntype= treetype->node_types.first; ntype; ntype= ntype->next) {
/* default ui functions */
ntype->drawfunc = node_draw_default;
ntype->drawupdatefunc = node_update_default;
ntype->uifunc = NULL;
ntype->uifuncbut = NULL;
ntype->resize_area_func = node_resize_area_default;
node_common_set_butfunc(ntype);
switch (i) {
case NTREE_COMPOSIT:
node_composit_set_butfunc(ntype);
ntype= ntype->next;
}
ntype = node_all_textures.first;
while(ntype) {
break;
case NTREE_SHADER:
node_shader_set_butfunc(ntype);
break;
case NTREE_TEXTURE:
node_texture_set_butfunc(ntype);
ntype= ntype->next;
break;
}
}
}
}
/* socket type ui functions */
for (i=0; i < NUM_SOCKET_TYPES; ++i) {
stype = ntreeGetSocketType(i);
if (stype) {
switch(stype->type) {
case SOCK_FLOAT:
case SOCK_INT:
case SOCK_BOOLEAN:
stype->buttonfunc = node_socket_button_default;
break;
case SOCK_VECTOR:
stype->buttonfunc = node_socket_button_components;
break;
case SOCK_RGBA:
stype->buttonfunc = node_socket_button_color;
break;
default:
stype->buttonfunc = NULL;
}
}
}
}
@ -1840,6 +2470,69 @@ void node_draw_link_bezier(View2D *v2d, SpaceNode *snode, bNodeLink *link, int t
}
}
static void node_link_straight_points(View2D *UNUSED(v2d), SpaceNode *snode, bNodeLink *link, float coord_array[][2])
{
if(link->fromsock) {
coord_array[0][0]= link->fromsock->locx;
coord_array[0][1]= link->fromsock->locy;
}
else {
if(snode==NULL) return;
coord_array[0][0]= snode->mx;
coord_array[0][1]= snode->my;
}
if(link->tosock) {
coord_array[1][0]= link->tosock->locx;
coord_array[1][1]= link->tosock->locy;
}
else {
if(snode==NULL) return;
coord_array[1][0]= snode->mx;
coord_array[1][1]= snode->my;
}
}
void node_draw_link_straight(View2D *v2d, SpaceNode *snode, bNodeLink *link, int th_col1, int do_shaded, int th_col2, int do_triple, int th_col3 )
{
float coord_array[2][2];
float linew;
int i;
node_link_straight_points(v2d, snode, link, coord_array);
/* store current linewidth */
glGetFloatv(GL_LINE_WIDTH, &linew);
glEnable(GL_LINE_SMOOTH);
if(do_triple) {
UI_ThemeColorShadeAlpha(th_col3, -80, -120);
glLineWidth(4.0f);
glBegin(GL_LINES);
glVertex2fv(coord_array[0]);
glVertex2fv(coord_array[1]);
glEnd();
}
UI_ThemeColor(th_col1);
glLineWidth(1.5f);
glBegin(GL_LINE_STRIP);
for (i=0; i < LINK_RESOL; ++i) {
float t= (float)i/(float)(LINK_RESOL-1);
if(do_shaded)
UI_ThemeColorBlend(th_col1, th_col2, t);
glVertex2f((1.0f-t)*coord_array[0][0]+t*coord_array[1][0], (1.0f-t)*coord_array[0][1]+t*coord_array[1][1]);
}
glEnd();
glDisable(GL_LINE_SMOOTH);
/* restore previuos linewidth */
glLineWidth(linew);
}
/* note; this is used for fake links in groups too */
void node_draw_link(View2D *v2d, SpaceNode *snode, bNodeLink *link)
{
@ -1868,7 +2561,7 @@ void node_draw_link(View2D *v2d, SpaceNode *snode, bNodeLink *link)
}
else {
/* check cyclic */
if(link->fromnode->level >= link->tonode->level && link->tonode->level!=0xFFF) {
if((link->fromnode->level >= link->tonode->level && link->tonode->level!=0xFFF) && (link->flag & NODE_LINK_VALID)) {
/* special indicated link, on drop-node */
if(link->flag & NODE_LINKFLAG_HILITE) {
th_col1= th_col2= TH_ACTIVE;
@ -1890,6 +2583,5 @@ void node_draw_link(View2D *v2d, SpaceNode *snode, bNodeLink *link)
}
node_draw_link_bezier(v2d, snode, link, th_col1, do_shaded, th_col2, do_triple, th_col3);
// node_draw_link_straight(v2d, snode, link, th_col1, do_shaded, th_col2, do_triple, th_col3);
}

2
source/blender/editors/space_node/node_buttons.c
View File

@ -120,6 +120,8 @@ static void active_node_panel(const bContext *C, Panel *pa)
/* draw this node's settings */
if (node->typeinfo && node->typeinfo->uifuncbut)
node->typeinfo->uifuncbut(layout, (bContext *)C, &ptr);
else if (node->typeinfo && node->typeinfo->uifunc)
node->typeinfo->uifunc(layout, (bContext *)C, &ptr);
}
/* ******************* node buttons registration ************** */

637
source/blender/editors/space_node/node_draw.c
View File

@ -70,8 +70,8 @@
#include "RNA_access.h"
#include "CMP_node.h"
#include "SHD_node.h"
#include "NOD_composite.h"
#include "NOD_shader.h"
#include "node_intern.h"
@ -81,6 +81,15 @@
// XXX interface.h
extern void ui_dropshadow(rctf *rct, float radius, float aspect, int select);
/* XXX update functions for node editor are a mess, needs a clear concept */
void ED_node_tree_update(SpaceNode *snode, Scene *scene)
{
snode_set_context(snode, scene);
if(snode->nodetree && snode->nodetree->id.us==0)
snode->nodetree->id.us= 1;
}
void ED_node_changed_update(ID *id, bNode *node)
{
bNodeTree *nodetree, *edittree;
@ -123,24 +132,25 @@ static int has_nodetree(bNodeTree *ntree, bNodeTree *lookup)
return 0;
}
typedef struct NodeUpdateCalldata {
bNodeTree *ntree;
bNode *node;
} NodeUpdateCalldata;
static void node_generic_update_cb(void *calldata, ID *owner_id, bNodeTree *ntree)
{
NodeUpdateCalldata *cd= (NodeUpdateCalldata*)calldata;
/* check if nodetree uses the group stored in calldata */
if (has_nodetree(ntree, cd->ntree))
ED_node_changed_update(owner_id, cd->node);
}
void ED_node_generic_update(Main *bmain, bNodeTree *ntree, bNode *node)
{
Material *ma;
Tex *tex;
Scene *sce;
bNodeTreeType *tti= ntreeGetType(ntree->type);
NodeUpdateCalldata cd;
cd.ntree = ntree;
cd.node = node;
/* look through all datablocks, to support groups */
for(ma=bmain->mat.first; ma; ma=ma->id.next)
if(ma->nodetree && ma->use_nodes && has_nodetree(ma->nodetree, ntree))
ED_node_changed_update(&ma->id, node);
for(tex=bmain->tex.first; tex; tex=tex->id.next)
if(tex->nodetree && tex->use_nodes && has_nodetree(tex->nodetree, ntree))
ED_node_changed_update(&tex->id, node);
for(sce=bmain->scene.first; sce; sce=sce->id.next)
if(sce->nodetree && sce->use_nodes && has_nodetree(sce->nodetree, ntree))
ED_node_changed_update(&sce->id, node);
tti->foreach_nodetree(bmain, &cd, node_generic_update_cb);
if(ntree->type == NTREE_TEXTURE)
ntreeTexCheckCyclics(ntree);
@ -204,14 +214,19 @@ static void node_uiblocks_init(const bContext *C, bNodeTree *ntree)
}
/* based on settings in node, sets drawing rect info. each redraw! */
static void node_update(const bContext *C, bNodeTree *ntree, bNode *node)
static void node_update_basis(const bContext *C, bNodeTree *ntree, bNode *node)
{
uiLayout *layout;
PointerRNA ptr;
bNodeSocket *nsock;
float dy= node->locy;
float locx, locy;
float dy= locy;
int buty;
/* get "global" coords */
nodeSpaceCoords(node, &locx, &locy);
dy= locy;
/* header */
dy-= NODE_DY;
@ -222,14 +237,14 @@ static void node_update(const bContext *C, bNodeTree *ntree, bNode *node)
/* output sockets */
for(nsock= node->outputs.first; nsock; nsock= nsock->next) {
if(!(nsock->flag & (SOCK_HIDDEN|SOCK_UNAVAIL))) {
nsock->locx= node->locx + node->width;
nsock->locx= locx + node->width;
nsock->locy= dy - NODE_DYS;
dy-= NODE_DY;
}
}
node->prvr.xmin= node->locx + NODE_DYS;
node->prvr.xmax= node->locx + node->width- NODE_DYS;
node->prvr.xmin= locx + NODE_DYS;
node->prvr.xmax= locx + node->width- NODE_DYS;
/* preview rect? */
if(node->flag & NODE_PREVIEW) {
@ -288,9 +303,10 @@ static void node_update(const bContext *C, bNodeTree *ntree, bNode *node)
RNA_pointer_create(&ntree->id, &RNA_Node, node, &ptr);
layout= uiBlockLayout(node->block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL,
node->locx+NODE_DYS, dy, node->butr.xmax, NODE_DY, U.uistyles.first);
locx+NODE_DYS, dy, node->butr.xmax, NODE_DY, U.uistyles.first);
node->typeinfo->uifunc(layout, (bContext *)C, &ptr);
uiBlockEndAlign(node->block);
uiBlockLayoutResolve(node->block, NULL, &buty);
@ -300,7 +316,7 @@ static void node_update(const bContext *C, bNodeTree *ntree, bNode *node)
/* input sockets */
for(nsock= node->inputs.first; nsock; nsock= nsock->next) {
if(!(nsock->flag & (SOCK_HIDDEN|SOCK_UNAVAIL))) {
nsock->locx= node->locx;
nsock->locx= locx;
nsock->locy= dy - NODE_DYS;
dy-= NODE_DY;
}
@ -310,19 +326,23 @@ static void node_update(const bContext *C, bNodeTree *ntree, bNode *node)
if(node->inputs.first || (node->flag & (NODE_OPTIONS|NODE_PREVIEW))==0 )
dy-= NODE_DYS/2;
node->totr.xmin= node->locx;
node->totr.xmax= node->locx + node->width;
node->totr.ymax= node->locy;
node->totr.ymin= MIN2(dy, node->locy-2*NODE_DY);
node->totr.xmin= locx;
node->totr.xmax= locx + node->width;
node->totr.ymax= locy;
node->totr.ymin= MIN2(dy, locy-2*NODE_DY);
}
/* based on settings in node, sets drawing rect info. each redraw! */
static void node_update_hidden(bNode *node)
{
bNodeSocket *nsock;
float locx, locy;
float rad, drad, hiddenrad= HIDDEN_RAD;
int totin=0, totout=0, tot;
/* get "global" coords */
nodeSpaceCoords(node, &locx, &locy);
/* calculate minimal radius */
for(nsock= node->inputs.first; nsock; nsock= nsock->next)
if(!(nsock->flag & (SOCK_HIDDEN|SOCK_UNAVAIL)))
@ -336,9 +356,9 @@ static void node_update_hidden(bNode *node)
hiddenrad += 5.0f*(float)(tot-4);
}
node->totr.xmin= node->locx;
node->totr.xmax= node->locx + 3*hiddenrad + node->miniwidth;
node->totr.ymax= node->locy + (hiddenrad - 0.5f*NODE_DY);
node->totr.xmin= locx;
node->totr.xmax= locx + 3*hiddenrad + node->miniwidth;
node->totr.ymax= locy + (hiddenrad - 0.5f*NODE_DY);
node->totr.ymin= node->totr.ymax - 2*hiddenrad;
/* output sockets */
@ -364,6 +384,14 @@ static void node_update_hidden(bNode *node)
}
}
void node_update_default(const bContext *C, bNodeTree *ntree, bNode *node)
{
if(node->flag & NODE_HIDDEN)
node_update_hidden(node);
else
node_update_basis(C, ntree, node);
}
static int node_get_colorid(bNode *node)
{
if(node->typeinfo->nclass==NODE_CLASS_INPUT)
@ -383,138 +411,42 @@ static int node_get_colorid(bNode *node)
return TH_NODE;
}
/* based on settings in node, sets drawing rect info. each redraw! */
/* note: this assumes only 1 group at a time is drawn (linked data) */
/* in node->totr the entire boundbox for the group is stored */
static void node_update_group(const bContext *C, bNodeTree *UNUSED(ntree), bNode *gnode)
{
bNodeTree *ngroup= (bNodeTree *)gnode->id;
bNode *node;
bNodeSocket *sock, *gsock;
rctf *rect= &gnode->totr;
float node_group_frame= U.dpi*NODE_GROUP_FRAME/72;
int counter;
int dy;
rect->xmin = rect->xmax = gnode->locx;
rect->ymin = rect->ymax = gnode->locy;
/* center them, is a bit of abuse of locx and locy though */
for(node= ngroup->nodes.first; node; node= node->next) {
node->locx+= gnode->locx;
node->locy+= gnode->locy;
if(node->flag & NODE_HIDDEN)
node_update_hidden(node);
else
node_update(C, ngroup, node);
node->locx-= gnode->locx;
node->locy-= gnode->locy;
}
counter= 1;
for(node= ngroup->nodes.first; node; node= node->next) {
if(counter) {
*rect= node->totr;
counter= 0;
}
else
BLI_union_rctf(rect, &node->totr);
}
/* add some room for links to group sockets */
rect->xmin -= 4*NODE_DY;
rect->xmax += 4*NODE_DY;
rect->ymin-= NODE_DY;
rect->ymax+= NODE_DY;
/* input sockets */
dy = 0.5f*(rect->ymin+rect->ymax) + NODE_DY*(BLI_countlist(&gnode->inputs)-1);
for(gsock=ngroup->inputs.first, sock=gnode->inputs.first; gsock; gsock=gsock->next, sock=sock->next) {
gsock->locx = rect->xmin;
sock->locx = rect->xmin - node_group_frame;
sock->locy = gsock->locy = dy;
/* prevent long socket lists from growing out of the group box */
if (dy-3*NODE_DYS < rect->ymin)
rect->ymin = dy-3*NODE_DYS;
if (dy+3*NODE_DYS > rect->ymax)
rect->ymax = dy+3*NODE_DYS;
dy -= 2*NODE_DY;
}
/* output sockets */
dy = 0.5f*(rect->ymin+rect->ymax) + NODE_DY*(BLI_countlist(&gnode->outputs)-1);
for(gsock=ngroup->outputs.first, sock=gnode->outputs.first; gsock; gsock=gsock->next, sock=sock->next) {
gsock->locx = rect->xmax;
sock->locx = rect->xmax + node_group_frame;
sock->locy = gsock->locy = dy - NODE_DYS;
/* prevent long socket lists from growing out of the group box */
if (dy-3*NODE_DYS < rect->ymin)
rect->ymin = dy-3*NODE_DYS;
if (dy+3*NODE_DYS > rect->ymax)
rect->ymax = dy+3*NODE_DYS;
dy -= 2*NODE_DY;
}
}
/* note: in cmp_util.c is similar code, for node_compo_pass_on() */
/* note: in node_edit.c is similar code, for untangle node */
static void node_draw_mute_line(View2D *v2d, SpaceNode *snode, bNode *node)
{
bNodeSocket *valsock= NULL, *colsock= NULL, *vecsock= NULL;
bNodeSocket *sock;
static int types[]= { SOCK_FLOAT, SOCK_VECTOR, SOCK_RGBA };
bNodeLink link= {NULL};
int a;
int i;
/* connect the first value buffer in with first value out */
/* connect the first RGBA buffer in with first RGBA out */
/* connect the first input of each type with first output of the same type */
/* test the inputs */
for(a=0, sock= node->inputs.first; sock; sock= sock->next, a++) {
if(nodeCountSocketLinks(snode->edittree, sock)) {
if(sock->type==SOCK_VALUE && valsock==NULL) valsock= sock;
if(sock->type==SOCK_VECTOR && vecsock==NULL) vecsock= sock;
if(sock->type==SOCK_RGBA && colsock==NULL) colsock= sock;
}
}
/* outputs, draw lines */
glEnable(GL_BLEND);
glEnable( GL_LINE_SMOOTH );
if(valsock || colsock || vecsock) {
for(a=0, sock= node->outputs.first; sock; sock= sock->next, a++) {
if(nodeCountSocketLinks(snode->edittree, sock)) {
link.tosock= sock;
link.fromnode = link.tonode = node;
for (i=0; i < 3; ++i) {
/* find input socket */
for (link.fromsock=node->inputs.first; link.fromsock; link.fromsock=link.fromsock->next)
if (link.fromsock->type==types[i] && nodeCountSocketLinks(snode->edittree, link.fromsock))
break;
if (link.fromsock) {
for (link.tosock=node->outputs.first; link.tosock; link.tosock=link.tosock->next)
if (link.tosock->type==types[i] && nodeCountSocketLinks(snode->edittree, link.tosock))
break;
if(sock->type==SOCK_VALUE && valsock) {
link.fromsock= valsock;
if (link.tosock) {
node_draw_link_bezier(v2d, snode, &link, TH_REDALERT, 0, TH_WIRE, 0, TH_WIRE);
valsock= NULL;
}
if(sock->type==SOCK_VECTOR && vecsock) {
link.fromsock= vecsock;
node_draw_link_bezier(v2d, snode, &link, TH_REDALERT, 0, TH_WIRE, 0, TH_WIRE);
vecsock= NULL;
}
if(sock->type==SOCK_RGBA && colsock) {
link.fromsock= colsock;
node_draw_link_bezier(v2d, snode, &link, TH_REDALERT, 0, TH_WIRE, 0, TH_WIRE);
colsock= NULL;
}
}
}
}
glDisable(GL_BLEND);
glDisable( GL_LINE_SMOOTH );
}
/* nice AA filled circle */
/* this might have some more generic use */
static void circle_draw(float x, float y, float size, int col[3])
static void node_circle_draw(float x, float y, float size, char *col)
{
/* 16 values of sin function */
static float si[16] = {
@ -550,37 +482,10 @@ static void circle_draw(float x, float y, float size, int col[3])
glDisable(GL_BLEND);
}
static void socket_circle_draw(bNodeSocket *sock, float size)
void node_socket_circle_draw(bNodeTree *UNUSED(ntree), bNodeSocket *sock, float size)
{
int col[3];
if(sock->type==-1) {
col[0]= 0; col[1]= 0; col[2]= 0;
}
else if(sock->type==SOCK_VALUE) {
col[0]= 160; col[1]= 160; col[2]= 160;
}
else if(sock->type==SOCK_VECTOR) {
col[0]= 100; col[1]= 100; col[2]= 200;
}
else if(sock->type==SOCK_RGBA) {
col[0]= 200; col[1]= 200; col[2]= 40;
}
else {
col[0]= 100; col[1]= 200; col[2]= 100;
}
circle_draw(sock->locx, sock->locy, size, col);
}
static void node_sync_cb(bContext *UNUSED(C), void *snode_v, void *node_v)
{
SpaceNode *snode= snode_v;
if(snode->treetype==NTREE_SHADER) {
nodeShaderSynchronizeID(node_v, 1);
// allqueue(REDRAWBUTSSHADING, 0);
}
bNodeSocketType *stype = ntreeGetSocketType(sock->type);
node_circle_draw(sock->locx, sock->locy, size, stype->ui_color);
}
/* ************** Socket callbacks *********** */
@ -639,83 +544,6 @@ static void node_draw_preview(bNodePreview *preview, rctf *prv)
}
typedef struct SocketVectorMenuArgs {
PointerRNA ptr;
int x, y, width;
uiButHandleFunc cb;
void *arg1, *arg2;
} SocketVectorMenuArgs;
/* NOTE: this is a block-menu, needs 0 events, otherwise the menu closes */
static uiBlock *socket_vector_menu(bContext *C, ARegion *ar, void *args_v)
{
SocketVectorMenuArgs *args= (SocketVectorMenuArgs*)args_v;
uiBlock *block;
uiLayout *layout;
block= uiBeginBlock(C, ar, "socket menu", UI_EMBOSS);
uiBlockSetFlag(block, UI_BLOCK_KEEP_OPEN);
layout= uiLayoutColumn(uiBlockLayout(block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, args->x, args->y+2, args->width, NODE_DY, U.uistyles.first), 0);
uiItemR(layout, &args->ptr, "default_value", UI_ITEM_R_EXPAND, "", ICON_NONE);
return block;
}
static void node_draw_socket_button(bNodeTree *ntree, bNodeSocket *sock, const char *name,
uiBlock *block, int x, int y, int width,
uiButHandleFunc cb, void *arg1, void *arg2)
{
uiBut *bt= NULL;
PointerRNA ptr;
int labelw;
SocketVectorMenuArgs *args;
RNA_pointer_create(&ntree->id, &RNA_NodeSocket, sock, &ptr);
switch (sock->type) {
case SOCK_VALUE:
bt=uiDefButR(block, NUM, B_NODE_EXEC, name,
x, y+1, width, NODE_DY-2,
&ptr, "default_value", 0, sock->ns.min, sock->ns.max, -1, -1, NULL);
if (cb)
uiButSetFunc(bt, cb, arg1, arg2);
break;
case SOCK_VECTOR:
args= MEM_callocN(sizeof(SocketVectorMenuArgs), "SocketVectorMenuArgs");
args->ptr = ptr;
args->x = x;
args->y = y;
args->width = width;
args->cb = cb;
args->arg1 = arg1;
args->arg2 = arg2;
uiDefBlockButN(block, socket_vector_menu, args, name,
x, y+1, width, NODE_DY-2,
"");
break;
case SOCK_RGBA:
labelw= width - 40;
bt=uiDefButR(block, COL, B_NODE_EXEC, "",
x, y+2, (labelw>0 ? 40 : width), NODE_DY-2,
&ptr, "default_value", 0, sock->ns.min, sock->ns.max, -1, -1, NULL);
if (cb)
uiButSetFunc(bt, cb, arg1, arg2);
if (name[0]!='\0' && labelw>0)
uiDefBut(block, LABEL, 0, name,
x + 40, y+2, labelw, NODE_DY-2,
NULL, 0, 0, 0, 0, "");
break;
}
}
static void node_draw_basis(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNode *node)
{
bNodeSocket *sock;
@ -809,12 +637,7 @@ static void node_draw_basis(const bContext *C, ARegion *ar, SpaceNode *snode, bN
else
UI_ThemeColor(TH_TEXT); */
if (node->label[0]!='\0')
BLI_strncpy(showname, node->label, sizeof(showname));
else if (node->typeinfo->labelfunc)
BLI_strncpy(showname, node->typeinfo->labelfunc(node), sizeof(showname));
else
BLI_strncpy(showname, node->typeinfo->name, sizeof(showname));
BLI_strncpy(showname, nodeLabel(node), sizeof(showname));
//if(node->flag & NODE_MUTED)
// sprintf(showname, "[%s]", showname);
@ -855,38 +678,46 @@ static void node_draw_basis(const bContext *C, ARegion *ar, SpaceNode *snode, bN
/* socket inputs, buttons */
for(sock= node->inputs.first; sock; sock= sock->next) {
if(!(sock->flag & (SOCK_HIDDEN|SOCK_UNAVAIL))) {
socket_circle_draw(sock, socket_size);
bNodeSocketType *stype= ntreeGetSocketType(sock->type);
if(node->block && sock->link==NULL) {
node_draw_socket_button(ntree, sock, sock->name, node->block, sock->locx+NODE_DYS, sock->locy-NODE_DYS, node->width-NODE_DY, node_sync_cb, snode, node);
if(sock->flag & (SOCK_HIDDEN|SOCK_UNAVAIL))
continue;
node_socket_circle_draw(ntree, sock, NODE_SOCKSIZE);
if (sock->link) {
uiDefBut(node->block, LABEL, 0, sock->name, sock->locx+NODE_DYS, sock->locy-NODE_DYS, node->width-NODE_DY, NODE_DY,
NULL, 0, 0, 0, 0, "");
}
else {
uiDefBut(node->block, LABEL, 0, sock->name, (short)(sock->locx+7), (short)(sock->locy-9.0f),
(short)(node->width-NODE_DY), NODE_DY, NULL, 0, 0, 0, 0, "");
}
if (stype->buttonfunc)
stype->buttonfunc(C, node->block, ntree, node, sock, sock->name, sock->locx+NODE_DYS, sock->locy-NODE_DYS, node->width-NODE_DY);
}
}
/* socket outputs */
for(sock= node->outputs.first; sock; sock= sock->next) {
if(!(sock->flag & (SOCK_HIDDEN|SOCK_UNAVAIL))) {
PointerRNA sockptr;
float slen;
int ofs= 0;
int ofs;
socket_circle_draw(sock, socket_size);
RNA_pointer_create((ID*)ntree, &RNA_NodeSocket, sock, &sockptr);
if(sock->flag & (SOCK_HIDDEN|SOCK_UNAVAIL))
continue;
node_socket_circle_draw(ntree, sock, NODE_SOCKSIZE);
ofs= 0;
UI_ThemeColor(TH_TEXT);
slen= snode->aspect*UI_GetStringWidth(sock->name);
while(slen > node->width) {
ofs++;
slen= snode->aspect*UI_GetStringWidth(sock->name+ofs);
}
uiDefBut(node->block, LABEL, 0, sock->name+ofs, (short)(sock->locx-15.0f-slen), (short)(sock->locy-9.0f),
(short)(node->width-NODE_DY), NODE_DY, NULL, 0, 0, 0, 0, "");
}
}
/* preview */
if(node->flag & NODE_PREVIEW) {
@ -956,12 +787,7 @@ static void node_draw_hidden(const bContext *C, ARegion *ar, SpaceNode *snode, b
UI_ThemeColor(TH_TEXT);
if(node->miniwidth>0.0f) {
if (node->label[0]!='\0')
BLI_strncpy(showname, node->label, sizeof(showname));
else if (node->typeinfo->labelfunc)
BLI_strncpy(showname, node->typeinfo->labelfunc(node), sizeof(showname));
else
BLI_strncpy(showname, node->typeinfo->name, sizeof(showname));
BLI_strncpy(showname, nodeLabel(node), sizeof(showname));
//if(node->flag & NODE_MUTED)
// sprintf(showname, "[%s]", showname);
@ -984,12 +810,12 @@ static void node_draw_hidden(const bContext *C, ARegion *ar, SpaceNode *snode, b
/* sockets */
for(sock= node->inputs.first; sock; sock= sock->next) {
if(!(sock->flag & (SOCK_HIDDEN|SOCK_UNAVAIL)))
socket_circle_draw(sock, socket_size);
node_socket_circle_draw(snode->nodetree, sock, socket_size);
}
for(sock= node->outputs.first; sock; sock= sock->next) {
if(!(sock->flag & (SOCK_HIDDEN|SOCK_UNAVAIL)))
socket_circle_draw(sock, socket_size);
node_socket_circle_draw(snode->nodetree, sock, socket_size);
}
uiEndBlock(C, node->block);
@ -997,7 +823,43 @@ static void node_draw_hidden(const bContext *C, ARegion *ar, SpaceNode *snode, b
node->block= NULL;
}
static void node_draw_nodetree(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree)
void node_draw_default(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNode *node)
{
if(node->flag & NODE_HIDDEN)
node_draw_hidden(C, ar, snode, node);
else
node_draw_basis(C, ar, snode, ntree, node);
}
static void node_update(const bContext *C, bNodeTree *ntree, bNode *node)
{
if (node->typeinfo->drawupdatefunc)
node->typeinfo->drawupdatefunc(C, ntree, node);
}
void node_update_nodetree(const bContext *C, bNodeTree *ntree, float offsetx, float offsety)
{
bNode *node;
for(node= ntree->nodes.first; node; node= node->next) {
/* XXX little hack */
node->locx += offsetx;
node->locy += offsety;
node_update(C, ntree, node);
node->locx -= offsetx;
node->locy -= offsety;
}
}
static void node_draw(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNode *node)
{
if (node->typeinfo->drawfunc)
node->typeinfo->drawfunc(C, ar, snode, ntree, node);
}
void node_draw_nodetree(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree)
{
bNode *node;
bNodeLink *link;
@ -1013,212 +875,11 @@ static void node_draw_nodetree(const bContext *C, ARegion *ar, SpaceNode *snode,
glDisable(GL_LINE_SMOOTH);
glDisable(GL_BLEND);
/* not selected first */
for(a=0, node= ntree->nodes.first; node; node= node->next, a++) {
/* draw nodes, last nodes in front */
for(a=0, node= ntree->nodes.first; node; node=node->next, a++) {
node->nr= a; /* index of node in list, used for exec event code */
if(!(node->flag & SELECT)) {
if(node->flag & NODE_GROUP_EDIT);
else if(node->flag & NODE_HIDDEN)
node_draw_hidden(C, ar, snode, node);
else
node_draw_basis(C, ar, snode, ntree, node);
node_draw(C, ar, snode, ntree, node);
}
}
/* selected */
for(node= ntree->nodes.first; node; node= node->next) {
if(node->flag & SELECT) {
if(node->flag & NODE_GROUP_EDIT);
else if(node->flag & NODE_HIDDEN)
node_draw_hidden(C, ar, snode, node);
else
node_draw_basis(C, ar, snode, ntree, node);
}
}
}
static void group_verify_cb(bContext *UNUSED(C), void *UNUSED(snode_v), void *ngroup_v)
{
bNodeTree *ngroup= (bNodeTree*)ngroup_v;
nodeGroupVerify(ngroup);
}
/* groups are, on creation, centered around 0,0 */
static void node_draw_group(const bContext *C, ARegion *ar, SpaceNode *snode, bNodeTree *ntree, bNode *gnode)
{
bNodeTree *ngroup= (bNodeTree *)gnode->id;
bNodeSocket *sock;
uiLayout *layout;
PointerRNA ptr;
uiBut *bt;
rctf rect= gnode->totr;
float socket_size= NODE_SOCKSIZE*U.dpi/72;
float node_group_frame= U.dpi*NODE_GROUP_FRAME/72;
float group_header= 26*U.dpi/72;
float arrowbutw= 0.8f*UI_UNIT_X;
/* layout stuff for buttons on group left frame */
float col1= 6, colw1= 0.6f*node_group_frame;
float col2= col1 + colw1+6;
float col3= node_group_frame - arrowbutw - 6;
/* layout stuff for buttons on group right frame */
float cor1= 6;
float cor2= cor1 + arrowbutw + 6;
float cor3= cor2 + arrowbutw + 6, corw3= node_group_frame - cor3-6;
int index;
/* backdrop header */
glEnable(GL_BLEND);
uiSetRoundBox(3);
UI_ThemeColorShadeAlpha(TH_NODE_GROUP, 0, -70);
uiDrawBox(GL_POLYGON, rect.xmin-node_group_frame, rect.ymax, rect.xmax+node_group_frame, rect.ymax+group_header, BASIS_RAD);
/* backdrop body */
UI_ThemeColorShadeAlpha(TH_BACK, -8, -70);
uiSetRoundBox(0);
uiDrawBox(GL_POLYGON, rect.xmin, rect.ymin, rect.xmax, rect.ymax, BASIS_RAD);
/* input column */
UI_ThemeColorShadeAlpha(TH_BACK, 10, -50);
uiSetRoundBox(8);
uiDrawBox(GL_POLYGON, rect.xmin-node_group_frame, rect.ymin, rect.xmin, rect.ymax, BASIS_RAD);
/* output column */
UI_ThemeColorShadeAlpha(TH_BACK, 10, -50);
uiSetRoundBox(4);
uiDrawBox(GL_POLYGON, rect.xmax, rect.ymin, rect.xmax+node_group_frame, rect.ymax, BASIS_RAD);
/* input column separator */
glColor4ub(200, 200, 200, 140);
glBegin(GL_LINES);
glVertex2f(rect.xmin, rect.ymin);
glVertex2f(rect.xmin, rect.ymax);
glEnd();
/* output column separator */
glColor4ub(200, 200, 200, 140);
glBegin(GL_LINES);
glVertex2f(rect.xmax, rect.ymin);
glVertex2f(rect.xmax, rect.ymax);
glEnd();
/* group node outline */
uiSetRoundBox(15);
glColor4ub(200, 200, 200, 140);
glEnable( GL_LINE_SMOOTH );
uiDrawBox(GL_LINE_LOOP, rect.xmin-node_group_frame, rect.ymin, rect.xmax+node_group_frame, rect.ymax+group_header, BASIS_RAD);
glDisable( GL_LINE_SMOOTH );
glDisable(GL_BLEND);
/* backdrop title */
UI_ThemeColor(TH_TEXT_HI);
layout = uiBlockLayout(gnode->block, UI_LAYOUT_VERTICAL, UI_LAYOUT_PANEL, (short)(rect.xmin+15), (short)(rect.ymax+group_header),
MIN2((int)(rect.xmax - rect.xmin-18.0f), node_group_frame+20), group_header, U.uistyles.first);
RNA_pointer_create(&ntree->id, &RNA_Node, gnode, &ptr);
uiTemplateIDBrowse(layout, (bContext*)C, &ptr, "node_tree", NULL, NULL, NULL);
uiBlockLayoutResolve(gnode->block, NULL, NULL);
/* draw the internal tree nodes and links */
node_draw_nodetree(C, ar, snode, ngroup);
/* group sockets */
for(sock=ngroup->inputs.first, index=0; sock; sock=sock->next, ++index) {
float locx= sock->locx - node_group_frame;
socket_circle_draw(sock, socket_size);
/* small hack to use socket_circle_draw function with offset */
sock->locx -= node_group_frame;
socket_circle_draw(sock, socket_size);
sock->locx += node_group_frame;
bt = uiDefBut(gnode->block, TEX, 0, "",
locx+col1, sock->locy+1, colw1, NODE_DY,
sock->name, 0, 31, 0, 0, "");
uiButSetFunc(bt, group_verify_cb, snode, ngroup);
node_draw_socket_button(ngroup, sock, "", gnode->block,
locx+col1, sock->locy-NODE_DY, colw1,
NULL, NULL, NULL);
uiBlockSetDirection(gnode->block, UI_TOP);
uiBlockBeginAlign(gnode->block);
bt = uiDefIconButO(gnode->block, BUT, "NODE_OT_group_socket_move_up", 0, ICON_TRIA_UP,
locx+col2, sock->locy, arrowbutw, arrowbutw, "");
if (!sock->prev)
uiButSetFlag(bt, UI_BUT_DISABLED);
RNA_int_set(uiButGetOperatorPtrRNA(bt), "index", index);
RNA_enum_set(uiButGetOperatorPtrRNA(bt), "in_out", SOCK_IN);
bt = uiDefIconButO(gnode->block, BUT, "NODE_OT_group_socket_move_down", 0, ICON_TRIA_DOWN,
locx+col2, sock->locy-arrowbutw, arrowbutw, arrowbutw, "");
if (!sock->next)
uiButSetFlag(bt, UI_BUT_DISABLED);
RNA_int_set(uiButGetOperatorPtrRNA(bt), "index", index);
RNA_enum_set(uiButGetOperatorPtrRNA(bt), "in_out", SOCK_IN);
uiBlockEndAlign(gnode->block);
uiBlockSetDirection(gnode->block, 0);
uiBlockSetEmboss(gnode->block, UI_EMBOSSN);
bt = uiDefIconButO(gnode->block, BUT, "NODE_OT_group_socket_remove", 0, ICON_X,
locx+col3, sock->locy-0.5f*arrowbutw, arrowbutw, arrowbutw, "");
RNA_int_set(uiButGetOperatorPtrRNA(bt), "index", index);
RNA_enum_set(uiButGetOperatorPtrRNA(bt), "in_out", SOCK_IN);
uiBlockSetEmboss(gnode->block, UI_EMBOSS);
}
for(sock=ngroup->outputs.first, index=0; sock; sock=sock->next, ++index) {
float locx= sock->locx;
socket_circle_draw(sock, socket_size);
/* small hack to use socket_circle_draw function with offset */
sock->locx += node_group_frame;
socket_circle_draw(sock, socket_size);
sock->locx -= node_group_frame;
uiBlockSetEmboss(gnode->block, UI_EMBOSSN);
bt = uiDefIconButO(gnode->block, BUT, "NODE_OT_group_socket_remove", 0, ICON_X,
locx+col1, sock->locy-0.5f*arrowbutw, arrowbutw, arrowbutw, "");
RNA_int_set(uiButGetOperatorPtrRNA(bt), "index", index);
RNA_enum_set(uiButGetOperatorPtrRNA(bt), "in_out", SOCK_OUT);
uiBlockSetEmboss(gnode->block, UI_EMBOSS);
uiBlockSetDirection(gnode->block, UI_TOP);
uiBlockBeginAlign(gnode->block);
bt = uiDefIconButO(gnode->block, BUT, "NODE_OT_group_socket_move_up", 0, ICON_TRIA_UP,
locx+cor2, sock->locy, arrowbutw, arrowbutw, "");
if (!sock->prev)
uiButSetFlag(bt, UI_BUT_DISABLED);
RNA_int_set(uiButGetOperatorPtrRNA(bt), "index", index);
RNA_enum_set(uiButGetOperatorPtrRNA(bt), "in_out", SOCK_OUT);
bt = uiDefIconButO(gnode->block, BUT, "NODE_OT_group_socket_move_down", 0, ICON_TRIA_DOWN,
locx+cor2, sock->locy-arrowbutw, arrowbutw, arrowbutw, "");
if (!sock->next)
uiButSetFlag(bt, UI_BUT_DISABLED);
RNA_int_set(uiButGetOperatorPtrRNA(bt), "index", index);
RNA_enum_set(uiButGetOperatorPtrRNA(bt), "in_out", SOCK_OUT);
uiBlockEndAlign(gnode->block);
uiBlockSetDirection(gnode->block, 0);
if (sock->link) {
bt = uiDefBut(gnode->block, TEX, 0, "",
locx+cor3, sock->locy-NODE_DYS+1, corw3, NODE_DY,
sock->name, 0, 31, 0, 0, "");
uiButSetFunc(bt, group_verify_cb, snode, ngroup);
}
else {
bt = uiDefBut(gnode->block, TEX, 0, "",
locx+cor3, sock->locy+1, corw3, NODE_DY,
sock->name, 0, 31, 0, 0, "");
uiButSetFunc(bt, group_verify_cb, snode, ngroup);
node_draw_socket_button(ngroup, sock, "", gnode->block, locx+cor3, sock->locy-NODE_DY, corw3, NULL, NULL, NULL);
}
}
uiEndBlock(C, gnode->block);
uiDrawBlock(C, gnode->block);
gnode->block= NULL;
}
void drawnodespace(const bContext *C, ARegion *ar, View2D *v2d)
@ -1263,24 +924,16 @@ void drawnodespace(const bContext *C, ARegion *ar, View2D *v2d)
node_uiblocks_init(C, snode->nodetree);
/* for now, we set drawing coordinates on each redraw */
for(node= snode->nodetree->nodes.first; node; node= node->next) {
if(node->flag & NODE_GROUP_EDIT)
node_update_group(C, snode->nodetree, node);
else if(node->flag & NODE_HIDDEN)
node_update_hidden(node);
else
node_update(C, snode->nodetree, node);
}
node_update_nodetree(C, snode->nodetree, 0.0f, 0.0f);
node_draw_nodetree(C, ar, snode, snode->nodetree);
#if 0
/* active group */
for(node= snode->nodetree->nodes.first; node; node= node->next) {
if(node->flag & NODE_GROUP_EDIT)
node_draw_group(C, ar, snode, snode->nodetree, node);
}
#endif
}
/* temporary links */

596
source/blender/editors/space_node/node_edit.c
View File

File diff suppressed because it is too large Load Diff

182
source/blender/editors/space_node/node_header.c
View File

@ -45,24 +45,26 @@
#include "BLI_utildefines.h"
#include "BKE_context.h"
#include "BKE_global.h"
#include "BKE_screen.h"
#include "BKE_node.h"
#include "BKE_main.h"
#include "RNA_access.h"
#include "WM_api.h"
#include "WM_types.h"
#include "UI_interface.h"
#include "UI_resources.h"
#include "UI_interface_icons.h"
#include "UI_resources.h"
#include "UI_view2d.h"
#include "node_intern.h"
/* ************************ add menu *********************** */
static void do_node_add(bContext *C, void *UNUSED(arg), int event)
static void do_node_add(bContext *C, bNodeTemplate *ntemp)
{
Main *bmain= CTX_data_main(C);
Scene *scene= CTX_data_scene(C);
@ -89,7 +91,7 @@ static void do_node_add(bContext *C, void *UNUSED(arg), int event)
else node->flag &= ~NODE_TEST;
}
node= node_add_node(snode, bmain, scene, event, snode->mx, snode->my);
node= node_add_node(snode, bmain, scene, ntemp, snode->mx, snode->my);
/* select previous selection before autoconnect */
for(node= snode->edittree->nodes.first; node; node= node->next) {
@ -105,13 +107,71 @@ static void do_node_add(bContext *C, void *UNUSED(arg), int event)
snode_dag_update(C, snode);
}
static void node_auto_add_menu(bContext *C, uiLayout *layout, void *arg_nodeclass)
static void do_node_add_static(bContext *C, void *UNUSED(arg), int event)
{
bNodeTemplate ntemp;
ntemp.type = event;
do_node_add(C, &ntemp);
}
static void do_node_add_group(bContext *C, void *UNUSED(arg), int event)
{
SpaceNode *snode= CTX_wm_space_node(C);
bNodeTemplate ntemp;
if (event>=0) {
ntemp.ngroup= BLI_findlink(&G.main->nodetree, event);
ntemp.type = ntemp.ngroup->nodetype;
}
else {
ntemp.type = -event;
switch (ntemp.type) {
case NODE_GROUP:
ntemp.ngroup = ntreeAddTree("Group", snode->treetype, ntemp.type);
break;
case NODE_FORLOOP:
ntemp.ngroup = ntreeAddTree("For Loop", snode->treetype, ntemp.type);
break;
case NODE_WHILELOOP:
ntemp.ngroup = ntreeAddTree("While Loop", snode->treetype, ntemp.type);
break;
default:
ntemp.ngroup = NULL;
}
}
if (!ntemp.ngroup)
return;
do_node_add(C, &ntemp);
}
#if 0 /* disabled */
static void do_node_add_dynamic(bContext *C, void *UNUSED(arg), int event)
{
bNodeTemplate ntemp;
ntemp.type = NODE_DYNAMIC;
do_node_add(C, &ntemp);
}
#endif
static int node_tree_has_type(int treetype, int nodetype)
{
bNodeTreeType *ttype= ntreeGetType(treetype);
bNodeType *ntype;
for (ntype=ttype->node_types.first; ntype; ntype=ntype->next) {
if (ntype->type==nodetype)
return 1;
}
return 0;
}
static void node_add_menu(bContext *C, uiLayout *layout, void *arg_nodeclass)
{
Main *bmain= CTX_data_main(C);
SpaceNode *snode= CTX_wm_space_node(C);
bNodeTree *ntree;
int nodeclass= GET_INT_FROM_POINTER(arg_nodeclass);
int tot= 0, a;
int event;
ntree = snode->nodetree;
@ -120,54 +180,38 @@ static void node_auto_add_menu(bContext *C, uiLayout *layout, void *arg_nodeclas
return;
}
/* mostly taken from toolbox.c, node_add_sublevel() */
if(nodeclass==NODE_CLASS_GROUP) {
bNodeTree *ngroup= bmain->nodetree.first;
for(; ngroup; ngroup= ngroup->id.next)
if(ngroup->type==ntree->type)
tot++;
}
else {
bNodeType *type = ntree->alltypes.first;
while(type) {
if(type->nclass == nodeclass)
tot++;
type= type->next;
}
}
if (nodeclass==NODE_CLASS_GROUP) {
bNodeTree *ngroup;
if(tot==0) {
uiLayoutSetFunc(layout, do_node_add_group, NULL);
/* XXX hack: negative numbers used for empty group types */
if (node_tree_has_type(ntree->type, NODE_GROUP))
uiItemV(layout, "New Group", 0, -NODE_GROUP);
if (node_tree_has_type(ntree->type, NODE_FORLOOP))
uiItemV(layout, "New For Loop", 0, -NODE_FORLOOP);
if (node_tree_has_type(ntree->type, NODE_WHILELOOP))
uiItemV(layout, "New While Loop", 0, -NODE_WHILELOOP);
uiItemS(layout);
return;
}
uiLayoutSetFunc(layout, do_node_add, NULL);
if(nodeclass==NODE_CLASS_GROUP) {
bNodeTree *ngroup= bmain->nodetree.first;
for(tot=0, a=0; ngroup; ngroup= ngroup->id.next, tot++) {
if(ngroup->type==ntree->type) {
uiItemV(layout, ngroup->id.name+2, ICON_NONE, NODE_GROUP_MENU+tot);
a++;
for(ngroup=bmain->nodetree.first, event=0; ngroup; ngroup= ngroup->id.next, ++event) {
/* only use group trees */
if (ngroup->type==ntree->type && ELEM3(ngroup->nodetype, NODE_GROUP, NODE_FORLOOP, NODE_WHILELOOP)) {
uiItemV(layout, ngroup->id.name+2, 0, event);
}
}
}
else if (nodeclass==NODE_DYNAMIC) {
/* disabled */
}
else {
bNodeType *type;
int script=0;
bNodeType *ntype;
for(a=0, type= ntree->alltypes.first; type; type=type->next) {
if(type->nclass == nodeclass && type->name) {
if(type->type == NODE_DYNAMIC) {
uiItemV(layout, type->name, ICON_NONE, NODE_DYNAMIC_MENU+script);
script++;
}
else
uiItemV(layout, type->name, ICON_NONE, type->type);
uiLayoutSetFunc(layout, do_node_add_static, NULL);
a++;
}
for (ntype=ntreeGetType(ntree->type)->node_types.first; ntype; ntype=ntype->next) {
if(ntype->nclass==nodeclass && ntype->name)
uiItemV(layout, ntype->name, 0, ntype->type);
}
}
}
@ -181,34 +225,34 @@ static void node_menu_add(const bContext *C, Menu *menu)
uiLayoutSetActive(layout, 0);
if(snode->treetype==NTREE_SHADER) {
uiItemMenuF(layout, "Input", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_INPUT));
uiItemMenuF(layout, "Output", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OUTPUT));
uiItemMenuF(layout, "Color", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_COLOR));
uiItemMenuF(layout, "Vector", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_VECTOR));
uiItemMenuF(layout, "Convertor", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_CONVERTOR));
uiItemMenuF(layout, "Group", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_GROUP));
uiItemMenuF(layout, "Dynamic", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_DYNAMIC));
uiItemMenuF(layout, "Input", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_INPUT));
uiItemMenuF(layout, "Output", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OUTPUT));
uiItemMenuF(layout, "Color", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_COLOR));
uiItemMenuF(layout, "Vector", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_VECTOR));
uiItemMenuF(layout, "Convertor", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_CONVERTOR));
uiItemMenuF(layout, "Group", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_GROUP));
uiItemMenuF(layout, "Dynamic", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_DYNAMIC));
}
else if(snode->treetype==NTREE_COMPOSIT) {
uiItemMenuF(layout, "Input", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_INPUT));
uiItemMenuF(layout, "Output", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OUTPUT));
uiItemMenuF(layout, "Color", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_COLOR));
uiItemMenuF(layout, "Vector", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_VECTOR));
uiItemMenuF(layout, "Filter", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_FILTER));
uiItemMenuF(layout, "Convertor", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_CONVERTOR));
uiItemMenuF(layout, "Matte", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_MATTE));
uiItemMenuF(layout, "Distort", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_DISTORT));
uiItemMenuF(layout, "Group", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_GROUP));
uiItemMenuF(layout, "Input", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_INPUT));
uiItemMenuF(layout, "Output", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OUTPUT));
uiItemMenuF(layout, "Color", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_COLOR));
uiItemMenuF(layout, "Vector", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_VECTOR));
uiItemMenuF(layout, "Filter", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_FILTER));
uiItemMenuF(layout, "Convertor", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_CONVERTOR));
uiItemMenuF(layout, "Matte", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_MATTE));
uiItemMenuF(layout, "Distort", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_DISTORT));
uiItemMenuF(layout, "Group", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_GROUP));
}
else if(snode->treetype==NTREE_TEXTURE) {
uiItemMenuF(layout, "Input", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_INPUT));
uiItemMenuF(layout, "Output", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OUTPUT));
uiItemMenuF(layout, "Color", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_COLOR));
uiItemMenuF(layout, "Patterns", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_PATTERN));
uiItemMenuF(layout, "Textures", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_TEXTURE));
uiItemMenuF(layout, "Convertor", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_CONVERTOR));
uiItemMenuF(layout, "Distort", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_DISTORT));
uiItemMenuF(layout, "Group", 0, node_auto_add_menu, SET_INT_IN_POINTER(NODE_CLASS_GROUP));
uiItemMenuF(layout, "Input", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_INPUT));
uiItemMenuF(layout, "Output", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OUTPUT));
uiItemMenuF(layout, "Color", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_OP_COLOR));
uiItemMenuF(layout, "Patterns", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_PATTERN));
uiItemMenuF(layout, "Textures", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_TEXTURE));
uiItemMenuF(layout, "Convertor", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_CONVERTOR));
uiItemMenuF(layout, "Distort", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_DISTORT));
uiItemMenuF(layout, "Group", 0, node_add_menu, SET_INT_IN_POINTER(NODE_CLASS_GROUP));
}
}

15
source/blender/editors/space_node/node_intern.h
View File

@ -33,6 +33,8 @@
#ifndef ED_NODE_INTERN_H
#define ED_NODE_INTERN_H
#include "UI_interface.h"
/* internal exports only */
struct ARegion;
@ -40,6 +42,7 @@ struct ARegionType;
struct View2D;
struct bContext;
struct wmWindowManager;
struct bNodeTemplate;
struct bNode;
struct bNodeSocket;
struct bNodeLink;
@ -64,6 +67,11 @@ void node_header_buttons(const bContext *C, ARegion *ar);
void node_menus_register(void);
/* node_draw.c */
void node_socket_circle_draw(struct bNodeTree *ntree, struct bNodeSocket *sock, float size);
void node_draw_default(const struct bContext *C, struct ARegion *ar, struct SpaceNode *snode, struct bNodeTree *ntree, struct bNode *node);
void node_update_default(const struct bContext *C, struct bNodeTree *ntree, struct bNode *node);
void node_update_nodetree(const struct bContext *C, struct bNodeTree *ntree, float offsetx, float offsety);
void node_draw_nodetree(const struct bContext *C, struct ARegion *ar, struct SpaceNode *snode, struct bNodeTree *ntree);
void drawnodespace(const bContext *C, ARegion *ar, View2D *v2d);
/* node_buttons.c */
@ -90,6 +98,7 @@ void NODE_OT_select_same_type_prev(wmOperatorType *ot);
void node_draw_link(View2D *v2d, SpaceNode *snode, bNodeLink *link);
void node_draw_link_bezier(View2D *v2d, SpaceNode *snode, bNodeLink *link, int th_col1, int do_shaded, int th_col2, int do_triple, int th_col3 );
int node_link_bezier_points(View2D *v2d, SpaceNode *snode, bNodeLink *link, float coord_array[][2], int resol);
void node_draw_link_straight(View2D *v2d, SpaceNode *snode, bNodeLink *link, int th_col1, int do_shaded, int th_col2, int do_triple, int th_col3 );
void draw_nodespace_back_pix(ARegion *ar, SpaceNode *snode, int color_manage);
void draw_nodespace_color_info(struct ARegion *ar, int color_manage, int channels, int x, int y, char *cp, float *fp);
@ -97,10 +106,10 @@ void draw_nodespace_color_info(struct ARegion *ar, int color_manage, int channel
void node_tree_from_ID(ID *id, bNodeTree **ntree, bNodeTree **edittree, int *treetype);
void snode_notify(bContext *C, SpaceNode *snode);
void snode_dag_update(bContext *C, SpaceNode *snode);
bNode *next_node(bNodeTree *ntree);
bNode *node_add_node(SpaceNode *snode, struct Main *bmain, Scene *scene, int type, float locx, float locy);
bNode *node_add_node(struct SpaceNode *snode, struct Main *bmain, struct Scene *scene, struct bNodeTemplate *ntemp, float locx, float locy);
void snode_set_context(SpaceNode *snode, Scene *scene);
void snode_make_group_editable(SpaceNode *snode, bNode *gnode);
void node_sort(struct bNodeTree *ntree);
void node_deselectall(SpaceNode *snode);
int node_select_same_type(SpaceNode *snode);
int node_select_same_type_np(SpaceNode *snode, int dir);
@ -146,6 +155,8 @@ void NODE_OT_backimage_sample(wmOperatorType *ot);
void NODE_OT_add_file(struct wmOperatorType *ot);
void NODE_OT_new_node_tree(struct wmOperatorType *ot);
extern const char *node_context_dir[];
// XXXXXX

3
source/blender/editors/space_node/node_ops.c
View File

@ -96,6 +96,8 @@ void node_operatortypes(void)
WM_operatortype_append(NODE_OT_backimage_sample);
WM_operatortype_append(NODE_OT_add_file);
WM_operatortype_append(NODE_OT_new_node_tree);
}
void ED_operatormacros_node(void)
@ -193,6 +195,5 @@ void node_keymap(struct wmKeyConfig *keyconf)
WM_keymap_add_item(keymap, "NODE_OT_read_fullsamplelayers", RKEY, KM_PRESS, KM_SHIFT, 0);
WM_keymap_add_item(keymap, "NODE_OT_render_changed", ZKEY, KM_PRESS, 0, 0);
transform_keymap_for_space(keyconf, keymap, SPACE_NODE);
}

22
source/blender/editors/space_node/node_select.c
View File

@ -62,7 +62,7 @@ static bNode *node_under_mouse(bNodeTree *ntree, int mx, int my)
{
bNode *node;
for(next_node(ntree); (node=next_node(NULL));) {
for(node=ntree->nodes.last; node; node=node->prev) {
/* node body (header and scale are in other operators) */
if (BLI_in_rctf(&node->totr, mx, my))
return node;
@ -95,6 +95,8 @@ static bNode *node_mouse_select(Main *bmain, SpaceNode *snode, ARegion *ar, cons
node->flag ^= SELECT;
ED_node_set_active(bmain, snode->edittree, node);
node_sort(snode->edittree);
}
return node;
@ -182,6 +184,8 @@ static int node_borderselect_exec(bContext *C, wmOperator *op)
}
}
node_sort(snode->edittree);
WM_event_add_notifier(C, NC_NODE|NA_SELECTED, NULL);
return OPERATOR_FINISHED;
@ -252,6 +256,8 @@ static int node_select_all_exec(bContext *C, wmOperator *UNUSED(op))
node->flag |= NODE_SELECT;
}
node_sort(snode->edittree);
WM_event_add_notifier(C, NC_NODE|NA_SELECTED, NULL);
return OPERATOR_FINISHED;
}
@ -292,6 +298,8 @@ static int node_select_linked_to_exec(bContext *C, wmOperator *UNUSED(op))
node->flag |= NODE_SELECT;
}
node_sort(snode->edittree);
WM_event_add_notifier(C, NC_NODE|NA_SELECTED, NULL);
return OPERATOR_FINISHED;
}
@ -332,6 +340,8 @@ static int node_select_linked_from_exec(bContext *C, wmOperator *UNUSED(op))
node->flag |= NODE_SELECT;
}
node_sort(snode->edittree);
WM_event_add_notifier(C, NC_NODE|NA_SELECTED, NULL);
return OPERATOR_FINISHED;
}
@ -358,6 +368,9 @@ static int node_select_same_type_exec(bContext *C, wmOperator *UNUSED(op))
SpaceNode *snode = CTX_wm_space_node(C);
node_select_same_type(snode);
node_sort(snode->edittree);
WM_event_add_notifier(C, NC_NODE|NA_SELECTED, NULL);
return OPERATOR_FINISHED;
}
@ -384,7 +397,11 @@ static int node_select_same_type_next_exec(bContext *C, wmOperator *UNUSED(op))
SpaceNode *snode = CTX_wm_space_node(C);
node_select_same_type_np(snode, 0);
node_sort(snode->edittree);
WM_event_add_notifier(C, NC_NODE|NA_SELECTED, NULL);
return OPERATOR_FINISHED;
}
@ -408,6 +425,9 @@ static int node_select_same_type_prev_exec(bContext *C, wmOperator *UNUSED(op))
SpaceNode *snode = CTX_wm_space_node(C);
node_select_same_type_np(snode, 1);
node_sort(snode->edittree);
WM_event_add_notifier(C, NC_NODE|NA_SELECTED, NULL);
return OPERATOR_FINISHED;
}

20
source/blender/editors/space_node/node_state.c
View File

@ -68,21 +68,6 @@ void node_set_hidden_sockets(SpaceNode *snode, bNode *node, int set)
for(sock= node->outputs.first; sock; sock= sock->next)
sock->flag &= ~SOCK_HIDDEN;
}
else {
bNode *gnode= node_tree_get_editgroup(snode->nodetree);
/* hiding inside group should not break links in other group users */
if(gnode) {
nodeGroupSocketUseFlags((bNodeTree *)gnode->id);
for(sock= node->inputs.first; sock; sock= sock->next)
if(!(sock->flag & SOCK_IN_USE))
if(sock->link==NULL)
sock->flag |= SOCK_HIDDEN;
for(sock= node->outputs.first; sock; sock= sock->next)
if(!(sock->flag & SOCK_IN_USE))
if(nodeCountSocketLinks(snode->edittree, sock)==0)
sock->flag |= SOCK_HIDDEN;
}
else {
/* hide unused sockets */
for(sock= node->inputs.first; sock; sock= sock->next) {
@ -94,13 +79,12 @@ void node_set_hidden_sockets(SpaceNode *snode, bNode *node, int set)
sock->flag |= SOCK_HIDDEN;
}
}
}
}
static void node_hide_unhide_sockets(SpaceNode *snode, bNode *node)
{
node_set_hidden_sockets(snode, node, !node_has_hidden_sockets(node));
node_tree_verify_groups(snode->nodetree);
ntreeUpdateTree(snode->edittree);
}
static int do_header_node(SpaceNode *snode, bNode *node, float mx, float my)
@ -168,7 +152,7 @@ static int node_toggle_visibility(SpaceNode *snode, ARegion *ar, const int mval[
UI_view2d_region_to_view(&ar->v2d, mval[0], mval[1], &mx, &my);
for(next_node(snode->edittree); (node=next_node(NULL));) {
for(node=snode->edittree->nodes.last; node; node=node->prev) {
if(node->flag & NODE_HIDDEN) {
if(do_header_hidden_node(node, mx, my)) {
ED_region_tag_redraw(ar);

18
source/blender/editors/space_node/space_node.c
View File

@ -439,14 +439,30 @@ static int node_context(const bContext *C, const char *member, bContextDataResul
else if(CTX_data_equals(member, "selected_nodes")) {
bNode *node;
for(next_node(snode->edittree); (node=next_node(NULL));) {
if(snode->edittree) {
for(node=snode->edittree->nodes.last; node; node=node->prev) {
if(node->flag & NODE_SELECT) {
CTX_data_list_add(result, &snode->edittree->id, &RNA_Node, node);
}
}
}
CTX_data_type_set(result, CTX_DATA_TYPE_COLLECTION);
return 1;
}
else if(CTX_data_equals(member, "active_node")) {
bNode *node;
if(snode->edittree) {
for(node=snode->edittree->nodes.last; node; node=node->prev) {
if(node->flag & NODE_ACTIVE) {
CTX_data_pointer_set(result, &snode->edittree->id, &RNA_Node, node);
break;
}
}
}
CTX_data_type_set(result, CTX_DATA_TYPE_POINTER);
return 1;
}
return 0;
}

19
source/blender/editors/transform/transform_conversions.c
View File

@ -4771,12 +4771,14 @@ void special_aftertrans_update(bContext *C, TransInfo *t)
}
else if (t->spacetype == SPACE_NODE) {
SpaceNode *snode= (SpaceNode *)t->sa->spacedata.first;
ED_node_update_hierarchy(C, snode->edittree);
if(cancelled == 0)
ED_node_link_insert(t->sa);
/* clear link line */
ED_node_link_intersect_test(t->sa, 0);
}
else if (t->spacetype == SPACE_ACTION) {
SpaceAction *saction= (SpaceAction *)t->sa->spacedata.first;
@ -5194,6 +5196,11 @@ static void NodeToTransData(TransData *td, TransData2D *td2d, bNode *node)
td2d->loc2d = &node->locx; /* current location */
td->flag = 0;
/* exclude nodes whose parent is also transformed */
if (node->parent && (node->parent->flag & NODE_TRANSFORM)) {
td->flag |= TD_SKIP;
}
td->loc = td2d->loc;
VECCOPY(td->center, td->loc);
VECCOPY(td->iloc, td->loc);
@ -5214,6 +5221,16 @@ static void createTransNodeData(bContext *C, TransInfo *t)
{
TransData *td;
TransData2D *td2d;
SpaceNode *snode= t->sa->spacedata.first;
bNode *node;
/* set transform flags on nodes */
for (node=snode->edittree->nodes.first; node; node=node->next) {
if ((node->flag & NODE_SELECT) || (node->parent && (node->parent->flag & NODE_TRANSFORM)))
node->flag |= NODE_TRANSFORM;
else
node->flag &= ~NODE_TRANSFORM;
}
t->total= CTX_DATA_COUNT(C, selected_nodes);

2
source/blender/gpu/SConscript
View File

@ -5,7 +5,7 @@ sources = env.Glob('intern/*.c')
defs = [ 'GLEW_STATIC' ]
incs = '../blenlib ../blenkernel ../makesdna ../include ../blenloader'
incs = '../blenlib ../blenkernel ../makesdna ../makesrna ../include ../blenloader'
incs += ' #/extern/glew/include #intern/guardedalloc #intern/smoke/extern ../imbuf .'
if env['OURPLATFORM'] in ('win32-vc', 'win32-mingw', 'linuxcross', 'win64-vc'):

145
source/blender/makesdna/DNA_node_types.h
View File

@ -38,26 +38,29 @@
#include "DNA_vec_types.h"
#include "DNA_listBase.h"
struct ID;
struct ListBase;
struct SpaceNode;
struct bNodeLink;
struct bNodeType;
struct bNodeGroup;
struct bNodeTreeExec;
struct AnimData;
struct bGPdata;
struct uiBlock;
#define NODE_MAXSTR 32
typedef struct bNodeStack {
float vec[4];
float min, max; /* min/max for values (UI writes it, execute might use it) */
float min, max;
void *data;
short hasinput; /* when input has link, tagged before executing */
short hasoutput; /* when output is linked, tagged before executing */
short datatype; /* type of data pointer */
short sockettype; /* type of socket stack comes from, to remap linking different sockets */
short is_copy; /* data is a copy of external data (no freeing) */
short external; /* data is used by external nodes (no freeing) */
short pad[2];
} bNodeStack;
/* ns->datatype, shadetree only */
@ -68,50 +71,58 @@ typedef struct bNodeSocket {
struct bNodeSocket *next, *prev, *new_sock;
char name[32];
bNodeStack ns; /* custom data for inputs, only UI writes in this */
void *storage; /* custom storage */
short type, flag;
short limit; /* max. number of links */
/* stack data info (only during execution!) */
short stack_type; /* type of stack reference */
/* XXX only one of stack_ptr or stack_index is used (depending on stack_type).
* could store the index in the pointer with SET_INT_IN_POINTER (a bit ugly).
* (union won't work here, not supported by DNA)
*/
struct bNodeStack *stack_ptr; /* constant input value */
short stack_index; /* local stack index or external input number */
short pad1;
float locx, locy;
void *default_value; /* default input value used for unlinked sockets */
/* execution data */
short stack_index; /* local stack index */
short pad2;
int pad3;
void *cache; /* cached data from execution */
/* internal data to retrieve relations and groups */
int own_index; /* group socket identifiers, to find matching pairs after reading files */
struct bNodeSocket *groupsock;
int to_index; /* XXX deprecated, only used for restoring old group node links */
int pad2;
struct bNodeSocket *groupsock;
struct bNodeLink *link; /* a link pointer, set in nodeSolveOrder() */
struct bNodeLink *link; /* a link pointer, set in ntreeUpdateTree */
/* DEPRECATED only needed for do_versions */
bNodeStack ns; /* custom data for inputs, only UI writes in this */
} bNodeSocket;
/* sock->type */
#define SOCK_VALUE 0
#define SOCK_FLOAT 0
#define SOCK_VECTOR 1
#define SOCK_RGBA 2
#define SOCK_INT 3
#define SOCK_BOOLEAN 4
#define SOCK_MESH 5
#define NUM_SOCKET_TYPES 6 /* must be last! */
/* socket side (input/output) */
#define SOCK_IN 1
#define SOCK_OUT 2
/* sock->flag, first bit is select */
/* hidden is user defined, to hide unused */
#define SOCK_HIDDEN 2
/* only used now for groups... */
#define SOCK_IN_USE 4
#define SOCK_IN_USE 4 /* XXX deprecated */
/* unavailable is for dynamic sockets */
#define SOCK_UNAVAIL 8
/* sock->stack_type */
#define SOCK_STACK_LOCAL 1 /* part of the local tree stack */
#define SOCK_STACK_EXTERN 2 /* use input stack pointer */
#define SOCK_STACK_CONST 3 /* use pointer to constant input value */
/* dynamic socket (can be modified by user) */
#define SOCK_DYNAMIC 16
/* group socket should not be exposed */
#define SOCK_INTERNAL 32
typedef struct bNodePreview {
unsigned char *rect;
@ -119,7 +130,6 @@ typedef struct bNodePreview {
int pad;
} bNodePreview;
/* limit data in bNode to what we want to see saved? */
typedef struct bNode {
struct bNode *next, *prev, *new_node;
@ -132,11 +142,14 @@ typedef struct bNode {
short nr; /* number of this node in list, used for UI exec events */
ListBase inputs, outputs;
struct bNode *parent; /* parent node */
struct ID *id; /* optional link to libdata */
void *storage; /* custom data, must be struct, for storage in file */
float locx, locy; /* root offset for drawing */
float width, miniwidth;
float width, height; /* node custom width and height */
float miniwidth; /* node width if hidden */
int pad;
char label[32]; /* custom user-defined label */
short custom1, custom2; /* to be abused for buttons */
float custom3, custom4;
@ -151,7 +164,6 @@ typedef struct bNode {
struct uiBlock *block; /* runtime during drawing */
struct bNodeType *typeinfo; /* lookup of callbacks and defaults */
} bNode;
/* node->flag */
@ -168,6 +180,12 @@ typedef struct bNode {
/* composite: don't do node but pass on buffer(s) */
#define NODE_MUTED 512
#define NODE_CUSTOM_NAME 1024 /* deprecated! */
/* group node types: use const outputs by default */
#define NODE_CONST_OUTPUT (1<<11)
/* node is always behind others */
#define NODE_BACKGROUND (1<<12)
/* automatic flag for nodes included in transforms */
#define NODE_TRANSFORM (1<<13)
typedef struct bNodeLink {
struct bNodeLink *next, *prev;
@ -175,13 +193,13 @@ typedef struct bNodeLink {
bNode *fromnode, *tonode;
bNodeSocket *fromsock, *tosock;
int flag, pad;
int flag;
int pad;
} bNodeLink;
/* link->flag */
#define NODE_LINKFLAG_HILITE 1
#define NODE_LINK_VALID 1 /* link has been successfully validated */
#define NODE_LINKFLAG_HILITE 2
/* the basis for a Node tree, all links and nodes reside internal here */
/* only re-usable node trees are in the library though, materials and textures allocate own tree struct */
@ -193,19 +211,24 @@ typedef struct bNodeTree {
ListBase nodes, links;
bNodeStack *stack; /* stack is only while executing, no read/write in file */
struct ListBase *threadstack; /* same as above */
int type, init; /* set init on fileread */
int stacksize; /* amount of elements in stack */
int cur_index; /* sockets in groups have unique identifiers, adding new sockets always
will increase this counter */
int flag, pad;
int flag;
int update; /* update flags */
int nodetype; /* specific node type this tree is used for */
ListBase alltypes; /* type definitions */
ListBase inputs, outputs; /* external sockets for group nodes */
int pad2[2];
/* execution data */
/* XXX It would be preferable to completely move this data out of the underlying node tree,
* so node tree execution could finally run independent of the tree itself. This would allow node trees
* to be merely linked by other data (materials, textures, etc.), as ID data is supposed to.
* Execution data is generated from the tree once at execution start and can then be used
* as long as necessary, even while the tree is being modified.
*/
struct bNodeTreeExec *execdata;
/* callbacks */
void (*progress)(void *, float progress);
@ -219,17 +242,56 @@ typedef struct bNodeTree {
#define NTREE_SHADER 0
#define NTREE_COMPOSIT 1
#define NTREE_TEXTURE 2
#define NUM_NTREE_TYPES 3
/* ntree->init, flag */
#define NTREE_TYPE_INIT 1
#define NTREE_EXEC_INIT 2
/* ntree->flag */
#define NTREE_DS_EXPAND 1 /* for animation editors */
/* XXX not nice, but needed as a temporary flag
/* XXX not nice, but needed as a temporary flags
* for group updates after library linking.
*/
#define NTREE_DO_VERSIONS 1024
#define NTREE_DO_VERSIONS_GROUP_EXPOSE 1024
/* ntree->update */
#define NTREE_UPDATE 0xFFFF /* generic update flag (includes all others) */
#define NTREE_UPDATE_LINKS 1 /* links have been added or removed */
#define NTREE_UPDATE_NODES 2 /* nodes or sockets have been added or removed */
#define NTREE_UPDATE_GROUP_IN 16 /* group inputs have changed */
#define NTREE_UPDATE_GROUP_OUT 32 /* group outputs have changed */
#define NTREE_UPDATE_GROUP 48 /* group has changed (generic flag including all other group flags) */
/* socket value structs for input buttons */
typedef struct bNodeSocketValueInt {
int subtype; /* RNA subtype */
int value;
int min, max;
} bNodeSocketValueInt;
typedef struct bNodeSocketValueFloat {
int subtype; /* RNA subtype */
float value;
float min, max;
} bNodeSocketValueFloat;
typedef struct bNodeSocketValueBoolean {
char value;
char pad[3];
} bNodeSocketValueBoolean;
typedef struct bNodeSocketValueVector {
int subtype; /* RNA subtype */
float value[3];
float min, max;
} bNodeSocketValueVector;
typedef struct bNodeSocketValueRGBA {
float value[4];
} bNodeSocketValueRGBA;
/* data structs, for node->storage */
@ -354,7 +416,6 @@ typedef struct TexNodeOutput {
char name[32];
} TexNodeOutput;
/* comp channel matte */
#define CMP_NODE_CHANNEL_MATTE_CS_RGB 1
#define CMP_NODE_CHANNEL_MATTE_CS_HSV 2

8
source/blender/makesrna/RNA_access.h
View File

@ -327,10 +327,13 @@ extern StructRNA RNA_NearSensor;
extern StructRNA RNA_NlaStrip;
extern StructRNA RNA_NlaTrack;
extern StructRNA RNA_Node;
extern StructRNA RNA_NodeForLoop;
extern StructRNA RNA_NodeGroup;
extern StructRNA RNA_NodeLink;
extern StructRNA RNA_NodeSocket;
extern StructRNA RNA_NodeSocketPanel;
extern StructRNA RNA_NodeTree;
extern StructRNA RNA_NodeWhileLoop;
extern StructRNA RNA_NoiseTexture;
extern StructRNA RNA_NorController;
extern StructRNA RNA_Object;
@ -376,7 +379,6 @@ extern StructRNA RNA_PropertyGroupItem;
extern StructRNA RNA_PropertySensor;
extern StructRNA RNA_PythonConstraint;
extern StructRNA RNA_PythonController;
extern StructRNA RNA_RGBANodeSocket;
extern StructRNA RNA_RadarSensor;
extern StructRNA RNA_RandomSensor;
extern StructRNA RNA_RaySensor;
@ -553,9 +555,7 @@ extern StructRNA RNA_UserPreferencesFilePaths;
extern StructRNA RNA_UserPreferencesSystem;
extern StructRNA RNA_UserPreferencesView;
extern StructRNA RNA_UserSolidLight;
extern StructRNA RNA_ValueNodeSocket;
extern StructRNA RNA_VectorFont;
extern StructRNA RNA_VectorNodeSocket;
extern StructRNA RNA_VertexGroup;
extern StructRNA RNA_VertexGroupElement;
extern StructRNA RNA_VertexPaint;
@ -599,6 +599,8 @@ extern const PointerRNA PointerRNA_NULL;
/* Structs */
StructRNA *RNA_struct_find(const char *identifier);
const char *RNA_struct_identifier(StructRNA *type);
const char *RNA_struct_ui_name(StructRNA *type);
const char *RNA_struct_ui_description(StructRNA *type);

2
source/blender/makesrna/RNA_enum_types.h
View File

@ -102,10 +102,12 @@ extern EnumPropertyItem transform_mode_types[];
extern EnumPropertyItem posebone_rotmode_items[];
extern EnumPropertyItem property_type_items[];
extern EnumPropertyItem property_subtype_items[];
extern EnumPropertyItem property_unit_items[];
extern EnumPropertyItem viewport_shade_items[];
extern EnumPropertyItem nodetree_type_items[];
extern EnumPropertyItem node_socket_type_items[];
extern EnumPropertyItem node_math_items[];

5
source/blender/makesrna/RNA_types.h
View File

@ -99,7 +99,10 @@ typedef enum PropertyUnit {
#define RNA_ENUM_BITFLAG_SIZE 32
/* also update enums in bpy_props.c when adding items here */
/* also update enums in bpy_props.c when adding items here
* watch it: these values are written to files as part of
* node socket button subtypes!
*/
typedef enum PropertySubType {
PROP_NONE = 0,

1
source/blender/makesrna/SConscript
View File

@ -9,6 +9,7 @@ objs += o
incs = '#/intern/guardedalloc #/intern/memutil #/intern/audaspace/intern ../blenkernel ../blenlib ../makesdna intern .'
incs += ' ../windowmanager ../editors/include ../gpu ../imbuf ../ikplugin ../blenfont ../blenloader'
incs += ' ../render/extern/include'
incs += ' ../nodes'
incs += ' #/extern/glew/include'
defs = []

11
source/blender/makesrna/intern/rna_access.c
View File

@ -475,6 +475,17 @@ static const char *rna_ensure_property_name(PropertyRNA *prop)
/* Structs */
StructRNA *RNA_struct_find(const char *identifier)
{
StructRNA *type;
if (identifier) {
for (type = BLENDER_RNA.structs.first; type; type = type->cont.next)
if (strcmp(type->identifier, identifier)==0)
return type;
}
return NULL;
}
const char *RNA_struct_identifier(StructRNA *type)
{
return type->identifier;

4
source/blender/makesrna/intern/rna_main_api.c
View File

@ -214,9 +214,7 @@ void rna_Main_materials_remove(Main *bmain, ReportList *reports, struct Material
struct bNodeTree *rna_Main_nodetree_new(Main *UNUSED(bmain), const char *name, int type)
{
bNodeTree *tree = ntreeAddTree(name, type, TRUE);
// ntreeMakeGroupSockets(tree);
bNodeTree *tree = ntreeAddTree(name, type, NODE_GROUP);
id_us_min(&tree->id);
return tree;

413
source/blender/makesrna/intern/rna_nodetree.c
View File

@ -30,13 +30,17 @@
#include <stdlib.h>
#include <string.h>
#include "RNA_access.h"
#include "RNA_define.h"
#include "RNA_enum_types.h"
#include "rna_internal.h"
#include "rna_internal_types.h"
#include "DNA_material_types.h"
#include "DNA_mesh_types.h"
#include "DNA_node_types.h"
#include "DNA_object_types.h"
#include "DNA_scene_types.h"
#include "DNA_texture_types.h"
@ -53,9 +57,16 @@
#include "MEM_guardedalloc.h"
EnumPropertyItem nodetree_type_items[] = {
{NTREE_SHADER, "MATERIAL", ICON_MATERIAL, "Material", "Material nodes" },
{NTREE_TEXTURE, "TEXTURE", ICON_TEXTURE, "Texture", "Texture nodes" },
{NTREE_COMPOSIT, "COMPOSITING", ICON_RENDERLAYERS, "Compositing", "Compositing nodes" },
{0, NULL, 0, NULL, NULL}
};
EnumPropertyItem node_socket_type_items[] = {
{SOCK_VALUE, "VALUE", 0, "Value", ""},
{SOCK_FLOAT, "VALUE", 0, "Value", ""},
{SOCK_VECTOR, "VECTOR", 0, "Vector", ""},
{SOCK_RGBA, "RGBA", 0, "RGBA", ""},
{0, NULL, 0, NULL, NULL}};
@ -99,6 +110,41 @@ EnumPropertyItem node_filter_items[] = {
{6, "SHADOW", 0, "Shadow", ""},
{0, NULL, 0, NULL, NULL}};
/* Add any new socket value subtype here.
* When adding a new subtype here, make sure you also add it
* to the subtype definitions in DNA_node_types.h.
* This macro is used by the RNA and the internal converter functions
* to define all socket subtypes. The SUBTYPE macro must be defined
* before using this macro, and undefined afterwards.
*/
#define NODE_DEFINE_SUBTYPES_INT \
SUBTYPE(INT, Int, NONE, None) \
SUBTYPE(INT, Int, UNSIGNED, Unsigned)
#define NODE_DEFINE_SUBTYPES_FLOAT \
SUBTYPE(FLOAT, Float, NONE, None) \
SUBTYPE(FLOAT, Float, UNSIGNED, Unsigned) \
SUBTYPE(FLOAT, Float, PERCENTAGE, Percentage) \
SUBTYPE(FLOAT, Float, FACTOR, Factor) \
SUBTYPE(FLOAT, Float, ANGLE, Angle) \
SUBTYPE(FLOAT, Float, TIME, Time) \
SUBTYPE(FLOAT, Float, DISTANCE, Distance)
#define NODE_DEFINE_SUBTYPES_VECTOR \
SUBTYPE(VECTOR, Vector, NONE, None) \
SUBTYPE(VECTOR, Vector, TRANSLATION, Translation) \
SUBTYPE(VECTOR, Vector, DIRECTION, Direction) \
SUBTYPE(VECTOR, Vector, VELOCITY, Velocity) \
SUBTYPE(VECTOR, Vector, ACCELERATION, Acceleration) \
SUBTYPE(VECTOR, Vector, EULER, Euler) \
SUBTYPE(VECTOR, Vector, XYZ, XYZ)
#define NODE_DEFINE_SUBTYPES \
NODE_DEFINE_SUBTYPES_INT \
NODE_DEFINE_SUBTYPES_FLOAT \
NODE_DEFINE_SUBTYPES_VECTOR
#ifdef RNA_RUNTIME
#include "BLI_linklist.h"
@ -121,32 +167,18 @@ static StructRNA *rna_Node_refine(struct PointerRNA *ptr)
#include "rna_nodetree_types.h"
#undef DefNode
case NODE_GROUP:
return &RNA_NodeGroup;
case NODE_FORLOOP:
return &RNA_NodeForLoop;
case NODE_WHILELOOP:
return &RNA_NodeWhileLoop;
default:
return &RNA_Node;
}
}
static StructRNA *rna_NodeSocketType_refine(struct PointerRNA *ptr)
{
bNodeSocket *ns= (bNodeSocket*)ptr->data;
switch(ns->type) {
case SOCK_VALUE:
return &RNA_ValueNodeSocket;
case SOCK_VECTOR:
return &RNA_VectorNodeSocket;
case SOCK_RGBA:
return &RNA_RGBANodeSocket;
default:
return &RNA_UnknownType;
}
}
static StructRNA *rna_NodeTree_refine(struct PointerRNA *ptr)
{
bNodeTree *ntree= (bNodeTree*)ptr->data;
@ -170,6 +202,46 @@ static char *rna_Node_path(PointerRNA *ptr)
return BLI_sprintfN("nodes[\"%s\"]", node->name);
}
static StructRNA *rna_NodeSocket_refine(PointerRNA *ptr)
{
bNodeSocket *sock= (bNodeSocket*)ptr->data;
if (sock->default_value) {
/* This returns the refined socket type with the full definition
* of the default input value with type and subtype.
*/
#define SUBTYPE(socktype, stypename, id, idname) \
{ \
bNodeSocketValue##stypename *value= (bNodeSocketValue##stypename*)sock->default_value; \
if (value->subtype==PROP_##id) \
return &RNA_NodeSocket##stypename##idname; \
}
switch (sock->type) {
case SOCK_FLOAT:
NODE_DEFINE_SUBTYPES_FLOAT
break;
case SOCK_INT:
NODE_DEFINE_SUBTYPES_INT
break;
case SOCK_BOOLEAN:
return &RNA_NodeSocketBoolean;
break;
case SOCK_VECTOR:
NODE_DEFINE_SUBTYPES_VECTOR
break;
case SOCK_RGBA:
return &RNA_NodeSocketRGBA;
break;
}
#undef SUBTYPE
}
return &RNA_NodeSocket;
}
static char *rna_NodeSocket_path(PointerRNA *ptr)
{
bNodeTree *ntree= (bNodeTree*)ptr->id.data;
@ -275,7 +347,7 @@ static void rna_NodeGroup_update(Main *bmain, Scene *scene, PointerRNA *ptr)
bNodeTree *ntree= (bNodeTree*)ptr->id.data;
bNode *node= (bNode*)ptr->data;
nodeGroupVerify((bNodeTree *)node->id);
ntreeUpdateTree((bNodeTree *)node->id);
node_update(bmain, scene, ntree, node);
}
@ -313,18 +385,42 @@ static void rna_NodeGroupSocket_update(Main *bmain, Scene *scene, PointerRNA *pt
bNodeSocket *sock= (bNodeSocket*)ptr->data;
bNode *node;
nodeGroupVerify(ntree);
ntreeUpdateTree(ntree);
if (nodeFindNode(ntree, sock, &node, NULL, NULL))
node_update(bmain, scene, ntree, node);
}
static void rna_NodeSocket_defvalue_range(PointerRNA *ptr, float *min, float *max)
static void rna_NodeLink_update(Main *bmain, Scene *scene, PointerRNA *ptr)
{
bNodeTree *ntree= (bNodeTree*)ptr->id.data;
ntree->update |= NTREE_UPDATE_LINKS;
ntreeUpdateTree(ntree);
}
static void rna_NodeSocketInt_range(PointerRNA *ptr, int *min, int *max)
{
bNodeSocket *sock= (bNodeSocket*)ptr->data;
bNodeSocketValueInt *val= (bNodeSocketValueInt*)sock->default_value;
*min = val->min;
*max = val->max;
}
*min = sock->ns.min;
*max = sock->ns.max;
static void rna_NodeSocketFloat_range(PointerRNA *ptr, float *min, float *max)
{
bNodeSocket *sock= (bNodeSocket*)ptr->data;
bNodeSocketValueFloat *val= (bNodeSocketValueFloat*)sock->default_value;
*min = val->min;
*max = val->max;
}
static void rna_NodeSocketVector_range(PointerRNA *ptr, float *min, float *max)
{
bNodeSocket *sock= (bNodeSocket*)ptr->data;
bNodeSocketValueVector *val= (bNodeSocketValueVector*)sock->default_value;
*min = val->min;
*max = val->max;
}
static void rna_Node_mapping_update(Main *bmain, Scene *scene, PointerRNA *ptr)
@ -454,18 +550,22 @@ static EnumPropertyItem *rna_Node_channel_itemf(bContext *UNUSED(C), PointerRNA
static bNode *rna_NodeTree_node_new(bNodeTree *ntree, bContext *UNUSED(C), ReportList *reports, int type, bNodeTree *group)
{
bNode *node;
bNodeTemplate ntemp;
if (type == NODE_GROUP && group == NULL) {
BKE_reportf(reports, RPT_ERROR, "node type \'GROUP\' missing group argument");
return NULL;
}
node = nodeAddNodeType(ntree, type, group, NULL);
ntemp.type = type;
ntemp.ngroup = group;
node = nodeAddNode(ntree, &ntemp);
if (node == NULL) {
BKE_reportf(reports, RPT_ERROR, "Unable to create node");
}
else {
nodeGroupVerify(ntree); /* update group node socket links*/
ntreeUpdateTree(ntree); /* update group node socket links*/
NodeTagChanged(ntree, node);
WM_main_add_notifier(NC_NODE|NA_EDITED, ntree);
@ -495,7 +595,7 @@ static bNode *rna_NodeTree_node_composite_new(bNodeTree *ntree, bContext *C, Rep
}
ntreeCompositForceHidden(ntree, CTX_data_scene(C));
ntreeSolveOrder(ntree);
ntreeUpdateTree(ntree);
}
return node;
@ -523,7 +623,7 @@ static void rna_NodeTree_node_remove(bNodeTree *ntree, ReportList *reports, bNod
id_us_min(node->id);
nodeFreeNode(ntree, node);
nodeGroupVerify(ntree); /* update group node socket links*/
ntreeUpdateTree(ntree); /* update group node socket links*/
WM_main_add_notifier(NC_NODE|NA_EDITED, ntree);
}
@ -551,9 +651,7 @@ static bNodeLink *rna_NodeTree_link_new(bNodeTree *ntree, ReportList *reports, b
if(ret) {
NodeTagChanged(ntree, tonode);
nodeGroupVerify(ntree); /* update group node socket links*/
ntreeSolveOrder(ntree);
ntreeUpdateTree(ntree);
WM_main_add_notifier(NC_NODE|NA_EDITED, ntree);
}
@ -567,8 +665,7 @@ static void rna_NodeTree_link_remove(bNodeTree *ntree, ReportList *reports, bNod
}
else {
nodeRemLink(ntree, link);
ntreeSolveOrder(ntree);
nodeGroupVerify(ntree); /* update group node socket links*/
ntreeUpdateTree(ntree);
WM_main_add_notifier(NC_NODE|NA_EDITED, ntree);
}
@ -577,9 +674,10 @@ static void rna_NodeTree_link_remove(bNodeTree *ntree, ReportList *reports, bNod
static bNodeSocket *rna_NodeTree_input_new(bNodeTree *ntree, ReportList *UNUSED(reports), const char *name, int type)
{
/* XXX should check if tree is a group here! no good way to do this currently. */
bNodeSocket *gsock= nodeGroupAddSocket(ntree, name, type, SOCK_IN);
bNodeSocket *gsock= node_group_add_socket(ntree, name, type, SOCK_IN);
nodeGroupVerify(ntree); /* update group node socket links*/
ntree->update |= NTREE_UPDATE_GROUP_IN;
ntreeUpdateTree(ntree);
WM_main_add_notifier(NC_NODE|NA_EDITED, ntree);
return gsock;
}
@ -587,9 +685,10 @@ static bNodeSocket *rna_NodeTree_input_new(bNodeTree *ntree, ReportList *UNUSED(
static bNodeSocket *rna_NodeTree_output_new(bNodeTree *ntree, ReportList *UNUSED(reports), const char *name, int type)
{
/* XXX should check if tree is a group here! no good way to do this currently. */
bNodeSocket *gsock= nodeGroupAddSocket(ntree, name, type, SOCK_OUT);
bNodeSocket *gsock= node_group_add_socket(ntree, name, type, SOCK_OUT);
nodeGroupVerify(ntree); /* update group node socket links*/
ntree->update |= NTREE_UPDATE_GROUP_OUT;
ntreeUpdateTree(ntree);
WM_main_add_notifier(NC_NODE|NA_EDITED, ntree);
return gsock;
}
@ -606,11 +705,12 @@ static bNodeSocket *rna_NodeTree_input_expose(bNodeTree *ntree, ReportList *repo
BKE_reportf(reports, RPT_ERROR, "Socket is not an input");
else {
/* XXX should check if tree is a group here! no good way to do this currently. */
gsock = nodeGroupAddSocket(ntree, sock->name, sock->type, SOCK_IN);
gsock = node_group_add_socket(ntree, sock->name, sock->type, SOCK_IN);
if (add_link)
nodeAddLink(ntree, NULL, gsock, node, sock);
nodeGroupVerify(ntree); /* update group node socket links*/
ntree->update |= NTREE_UPDATE_GROUP_IN;
ntreeUpdateTree(ntree);
WM_main_add_notifier(NC_NODE|NA_EDITED, ntree);
return gsock;
}
@ -629,11 +729,12 @@ static bNodeSocket *rna_NodeTree_output_expose(bNodeTree *ntree, ReportList *rep
BKE_reportf(reports, RPT_ERROR, "Socket is not an output");
else {
/* XXX should check if tree is a group here! no good way to do this currently. */
gsock = nodeGroupAddSocket(ntree, sock->name, sock->type, SOCK_OUT);
gsock = node_group_add_socket(ntree, sock->name, sock->type, SOCK_OUT);
if (add_link)
nodeAddLink(ntree, node, sock, NULL, gsock);
nodeGroupVerify(ntree); /* update group node socket links*/
ntree->update |= NTREE_UPDATE_GROUP_OUT;
ntreeUpdateTree(ntree);
WM_main_add_notifier(NC_NODE|NA_EDITED, ntree);
return gsock;
}
@ -668,14 +769,16 @@ static EnumPropertyItem node_ycc_items[] = {
{ 2, "JFIF", 0, "Jpeg", ""},
{0, NULL, 0, NULL, NULL}};
#define MaxNodes 1000
#define MaxNodes 50000
enum
{
Category_GroupNode,
Category_LoopNode,
Category_LayoutNode,
Category_ShaderNode,
Category_CompositorNode,
Category_TextureNode
Category_TextureNode,
};
typedef struct NodeInfo
@ -715,9 +818,10 @@ static void init(void)
#include "rna_nodetree_types.h"
#undef DefNode
reg_node(NODE_GROUP, Category_GroupNode, "GROUP", "NodeGroup", "Node", "Group", "");
reg_node(NODE_FORLOOP, Category_LoopNode, "FORLOOP", "NodeForLoop", "Node", "ForLoop", "");
reg_node(NODE_WHILELOOP, Category_LoopNode, "WHILELOOP", "NodeWhileLoop", "Node", "WhileLoop", "");
reg_node(NODE_FRAME, Category_LayoutNode, "FRAME", "NodeFrame", "Node", "Frame", "");
}
static StructRNA* def_node(BlenderRNA *brna, int node_id)
@ -793,6 +897,41 @@ static void def_group(StructRNA *srna)
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeGroup_update");
}
static void def_forloop(StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_sdna(prop, NULL, "id");
RNA_def_property_struct_type(prop, "NodeTree");
RNA_def_property_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Node Tree", "");
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeGroup_update");
}
static void def_whileloop(StructRNA *srna)
{
PropertyRNA *prop;
prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_sdna(prop, NULL, "id");
RNA_def_property_struct_type(prop, "NodeTree");
RNA_def_property_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Node Tree", "");
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeGroup_update");
prop = RNA_def_property(srna, "max_iterations", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, NULL, "custom1");
RNA_def_property_range(prop, 0.0f, 10000000.0f);
RNA_def_property_ui_text(prop, "Max. Iterations", "Limit for number of iterations");
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeGroup_update");
}
static void def_frame(StructRNA *srna)
{
// PropertyRNA *prop;
}
static void def_math(StructRNA *srna)
{
@ -2510,94 +2649,112 @@ static void rna_def_node_socket(BlenderRNA *brna)
srna = RNA_def_struct(brna, "NodeSocket", NULL);
RNA_def_struct_ui_text(srna, "Node Socket", "Input or output socket of a node");
RNA_def_struct_refine_func(srna, "rna_NodeSocketType_refine");
RNA_def_struct_sdna(srna, "bNodeSocket");
RNA_def_struct_refine_func(srna, "rna_NodeSocket_refine");
RNA_def_struct_ui_icon(srna, ICON_PLUG);
RNA_def_struct_path_func(srna, "rna_NodeSocket_path");
prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "type");
RNA_def_property_enum_items(prop, node_socket_type_items);
RNA_def_property_enum_default(prop, 0);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Type", "Node Socket type");
prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
/* XXX must be editable for group sockets. if necessary use a special rna definition for these */
// RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Name", "Socket name");
RNA_def_struct_name_property(srna, prop);
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeGroupSocket_update");
/* can add back if there is any use in reading them */
#if 0
prop = RNA_def_property(srna, "min", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "ns.min");
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Minimum Value", "");
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeSocket_update");
prop = RNA_def_property(srna, "max", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "ns.max");
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Maximum Value", "");
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeSocket_update");
#endif
prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_enum_items(prop, node_socket_type_items);
RNA_def_property_ui_text(prop, "Type", "Node Socket type");
}
static void rna_def_node_socket_value(BlenderRNA *brna)
static void rna_def_node_socket_subtype(BlenderRNA *brna, int type, int subtype, const char *name, const char *ui_name)
{
StructRNA *srna;
PropertyRNA *prop;
PropertyRNA *prop=NULL;
PropertySubType propsubtype= PROP_NONE;
srna = RNA_def_struct(brna, "ValueNodeSocket", "NodeSocket");
RNA_def_struct_ui_text(srna, "Value Node Socket", "Input or output socket of a node");
#define SUBTYPE(socktype, stypename, id, idname) { PROP_##id, #id, 0, #idname, ""},
static EnumPropertyItem subtype_items[] = {
NODE_DEFINE_SUBTYPES
{0, NULL, 0, NULL, NULL}
};
#undef SUBTYPE
#define SUBTYPE(socktype, stypename, id, idname) if (subtype==PROP_##id) propsubtype = PROP_##id;
NODE_DEFINE_SUBTYPES
#undef SUBTYPE
srna = RNA_def_struct(brna, name, "NodeSocket");
RNA_def_struct_ui_text(srna, ui_name, "Input or output socket of a node");
RNA_def_struct_sdna(srna, "bNodeSocket");
RNA_def_struct_ui_icon(srna, ICON_PLUG);
RNA_def_struct_path_func(srna, "rna_NodeSocket_path");
prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "ns.vec");
RNA_def_property_array(prop, 1);
RNA_def_property_ui_text(prop, "Default Value", "Default value of the socket when no link is attached");
switch (type) {
case SOCK_INT:
RNA_def_struct_sdna_from(srna, "bNodeSocketValueInt", "default_value");
prop = RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "subtype");
RNA_def_property_enum_items(prop, subtype_items);
RNA_def_property_ui_text(prop, "Subtype", "Subtype defining the socket value details");
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeSocket_update");
RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocket_defvalue_range");
}
static void rna_def_node_socket_vector(BlenderRNA *brna)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, "VectorNodeSocket", "NodeSocket");
RNA_def_struct_ui_text(srna, "Vector Node Socket", "Input or output socket of a node");
RNA_def_struct_sdna(srna, "bNodeSocket");
RNA_def_struct_ui_icon(srna, ICON_PLUG);
RNA_def_struct_path_func(srna, "rna_NodeSocket_path");
prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_XYZ);
RNA_def_property_float_sdna(prop, NULL, "ns.vec");
RNA_def_property_array(prop, 3);
RNA_def_property_ui_text(prop, "Default Value", "Default value of the socket when no link is attached");
prop = RNA_def_property(srna, "default_value", PROP_INT, propsubtype);
RNA_def_property_int_sdna(prop, NULL, "value");
RNA_def_property_int_funcs(prop, NULL, NULL, "rna_NodeSocketInt_range");
RNA_def_property_ui_text(prop, "Default Value", "");
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeSocket_update");
RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocket_defvalue_range");
}
break;
case SOCK_FLOAT:
RNA_def_struct_sdna_from(srna, "bNodeSocketValueFloat", "default_value");
static void rna_def_node_socket_rgba(BlenderRNA *brna)
{
StructRNA *srna;
PropertyRNA *prop;
prop = RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "subtype");
RNA_def_property_enum_items(prop, subtype_items);
RNA_def_property_ui_text(prop, "Subtype", "Subtype defining the socket value details");
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeSocket_update");
srna = RNA_def_struct(brna, "RGBANodeSocket", "NodeSocket");
RNA_def_struct_ui_text(srna, "RGBA Node Socket", "Input or output socket of a node");
RNA_def_struct_sdna(srna, "bNodeSocket");
RNA_def_struct_ui_icon(srna, ICON_PLUG);
RNA_def_struct_path_func(srna, "rna_NodeSocket_path");
prop = RNA_def_property(srna, "default_value", PROP_FLOAT, propsubtype);
RNA_def_property_float_sdna(prop, NULL, "value");
RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketFloat_range");
RNA_def_property_ui_text(prop, "Default Value", "");
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeSocket_update");
break;
case SOCK_BOOLEAN:
RNA_def_struct_sdna_from(srna, "bNodeSocketValueBoolean", "default_value");
prop = RNA_def_property(srna, "default_value", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "value", 1);
RNA_def_property_ui_text(prop, "Default Value", "");
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeSocket_update");
break;
case SOCK_VECTOR:
RNA_def_struct_sdna_from(srna, "bNodeSocketValueVector", "default_value");
prop = RNA_def_property(srna, "subtype", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "subtype");
RNA_def_property_enum_items(prop, subtype_items);
RNA_def_property_ui_text(prop, "Subtype", "Subtype defining the socket value details");
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeSocket_update");
prop = RNA_def_property(srna, "default_value", PROP_FLOAT, propsubtype);
RNA_def_property_float_sdna(prop, NULL, "value");
RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocketVector_range");
RNA_def_property_ui_text(prop, "Default Value", "");
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeSocket_update");
break;
case SOCK_RGBA:
RNA_def_struct_sdna_from(srna, "bNodeSocketValueRGBA", "default_value");
prop = RNA_def_property(srna, "default_value", PROP_FLOAT, PROP_COLOR);
RNA_def_property_float_sdna(prop, NULL, "ns.vec");
RNA_def_property_array(prop, 4);
RNA_def_property_ui_text(prop, "Default Value", "Default value of the socket when no link is attached");
RNA_def_property_float_sdna(prop, NULL, "value");
RNA_def_property_ui_text(prop, "Default Value", "");
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_NodeSocket_update");
RNA_def_property_float_funcs(prop, NULL, NULL, "rna_NodeSocket_defvalue_range");
break;
}
}
static void rna_def_node(BlenderRNA *brna)
@ -2625,6 +2782,11 @@ static void rna_def_node(BlenderRNA *brna)
RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Node_name_set");
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "label", PROP_STRING, PROP_NONE);
RNA_def_property_string_sdna(prop, NULL, "label");
RNA_def_property_ui_text(prop, "Label", "Optional custom node label");
RNA_def_property_update(prop, NC_NODE, "rna_Node_update");
prop = RNA_def_property(srna, "inputs", PROP_COLLECTION, PROP_NONE);
RNA_def_property_collection_sdna(prop, NULL, "inputs", NULL);
RNA_def_property_struct_type(prop, "NodeSocket");
@ -2635,10 +2797,11 @@ static void rna_def_node(BlenderRNA *brna)
RNA_def_property_struct_type(prop, "NodeSocket");
RNA_def_property_ui_text(prop, "Outputs", "");
prop = RNA_def_property(srna, "label", PROP_STRING, PROP_NONE);
RNA_def_property_string_sdna(prop, NULL, "label");
RNA_def_property_ui_text(prop, "Label", "Optional custom node label");
RNA_def_property_update(prop, NC_NODE, "rna_Node_update");
prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_sdna(prop, NULL, "parent");
RNA_def_property_struct_type(prop, "Node");
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Parent", "Parent this node is attached to");
}
static void rna_def_node_link(BlenderRNA *brna)
@ -2687,7 +2850,7 @@ static void rna_def_group_sockets_api(BlenderRNA *brna, PropertyRNA *cprop, int
RNA_def_function_ui_description(func, "Add a socket to the group tree.");
RNA_def_function_flag(func, FUNC_USE_REPORTS);
RNA_def_string(func, "name", "Socket", 32, "Name", "Name of the socket");
RNA_def_enum(func, "type", node_socket_type_items, SOCK_VALUE, "Type", "Type of socket");
RNA_def_enum(func, "type", node_socket_type_items, SOCK_FLOAT, "Type", "Type of socket");
/* return value */
parm= RNA_def_pointer(func, "socket", "NodeSocket", "", "New socket.");
RNA_def_function_return(func, parm);
@ -2708,12 +2871,6 @@ static void rna_def_nodetree(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem nodetree_type_items[] = {
{NTREE_SHADER, "SHADER", 0, "Shader", ""},
{NTREE_COMPOSIT, "COMPOSITE", 0, "Composite", ""},
{NTREE_TEXTURE, "TEXTURE", 0, "Texture", ""},
{0, NULL, 0, NULL, NULL}};
srna = RNA_def_struct(brna, "NodeTree", "ID");
RNA_def_struct_ui_text(srna, "Node Tree", "Node tree consisting of linked nodes used for materials, textures and compositing");
RNA_def_struct_sdna(srna, "bNodeTree");
@ -2826,15 +2983,23 @@ void RNA_def_nodetree(BlenderRNA *brna)
{
init();
rna_def_nodetree(brna);
rna_def_node_socket(brna);
rna_def_node_socket_value(brna);
rna_def_node_socket_vector(brna);
rna_def_node_socket_rgba(brna);
/* Generate RNA definitions for all socket subtypes */
#define SUBTYPE(socktype, stypename, id, idname) \
rna_def_node_socket_subtype(brna, SOCK_##socktype, PROP_##id, "NodeSocket"#stypename#idname, #idname" "#stypename" Node Socket");
NODE_DEFINE_SUBTYPES
#undef SUBTYPE
rna_def_node_socket_subtype(brna, SOCK_BOOLEAN, 0, "NodeSocketBoolean", "Boolean Node Socket");
rna_def_node_socket_subtype(brna, SOCK_RGBA, 0, "NodeSocketRGBA", "RGBA Node Socket");
rna_def_node(brna);
rna_def_node_link(brna);
rna_def_shader_node(brna);
rna_def_compositor_node(brna);
rna_def_texture_node(brna);
rna_def_composite_nodetree(brna);
rna_def_shader_nodetree(brna);
rna_def_texture_nodetree(brna);
@ -2843,10 +3008,14 @@ void RNA_def_nodetree(BlenderRNA *brna)
#include "rna_nodetree_types.h"
#undef DefNode
define_specific_node(brna, NODE_GROUP, def_group);
define_specific_node(brna, NODE_FORLOOP, def_forloop);
define_specific_node(brna, NODE_WHILELOOP, def_whileloop);
define_specific_node(brna, NODE_FRAME, def_frame);
}
/* clean up macro definition */
#undef NODE_DEFINE_SUBTYPES
#endif

8
source/blender/makesrna/intern/rna_nodetree_types.h
View File

@ -27,6 +27,11 @@
*/
/* Empty definitions for undefined macros to avoid warnings */
#ifndef DefNode
#define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc)
#endif
/* Tree type Node ID RNA def function Enum name Struct name UI Name UI Description */
DefNode( ShaderNode, SH_NODE_OUTPUT, 0, "OUTPUT", Output, "Output", "" )
DefNode( ShaderNode, SH_NODE_MATERIAL, def_sh_material, "MATERIAL", Material, "Material", "" )
@ -138,3 +143,6 @@ DefNode( TextureNode, TEX_NODE_DECOMPOSE, 0, "DECOM
DefNode( TextureNode, TEX_NODE_VALTONOR, 0, "VALTONOR", ValToNor, "Val to Nor", "" )
DefNode( TextureNode, TEX_NODE_SCALE, 0, "SCALE", Scale, "Scale", "" )
/* undefine macros */
#undef DefNode

14
source/blender/makesrna/intern/rna_object.c
View File

@ -132,6 +132,7 @@ EnumPropertyItem object_type_curve_items[] = {
#include "DNA_key_types.h"
#include "DNA_constraint_types.h"
#include "DNA_lattice_types.h"
#include "DNA_node_types.h"
#include "BKE_armature.h"
#include "BKE_bullet.h"
@ -2035,18 +2036,19 @@ static void rna_def_object(BlenderRNA *brna)
RNA_def_property_ui_text(prop, "Matrix", "Inverse of object's parent matrix at time of parenting");
RNA_def_property_update(prop, NC_OBJECT|ND_TRANSFORM, "rna_Object_internal_update");
/* collections */
/* modifiers */
prop= RNA_def_property(srna, "modifiers", PROP_COLLECTION, PROP_NONE);
RNA_def_property_struct_type(prop, "Modifier");
RNA_def_property_ui_text(prop, "Modifiers", "Modifiers affecting the geometric data of the object");
rna_def_object_modifiers(brna, prop);
/* constraints */
prop= RNA_def_property(srna, "constraints", PROP_COLLECTION, PROP_NONE);
RNA_def_property_struct_type(prop, "Constraint");
RNA_def_property_ui_text(prop, "Constraints", "Constraints affecting the transformation of the object");
// RNA_def_property_collection_funcs(prop, 0, 0, 0, 0, 0, 0, 0, "constraints__add", "constraints__remove");
rna_def_object_constraints(brna, prop);
prop= RNA_def_property(srna, "modifiers", PROP_COLLECTION, PROP_NONE);
RNA_def_property_struct_type(prop, "Modifier");
RNA_def_property_ui_text(prop, "Modifiers", "Modifiers affecting the geometric data of the object");
rna_def_object_modifiers(brna, prop);
/* game engine */
prop= RNA_def_property(srna, "game", PROP_POINTER, PROP_NONE);
RNA_def_property_flag(prop, PROP_NEVER_NULL);

36
source/blender/makesrna/intern/rna_rna.c
View File

@ -46,6 +46,42 @@ EnumPropertyItem property_type_items[] = {
{PROP_COLLECTION, "COLLECTION", 0, "Collection", ""},
{0, NULL, 0, NULL, NULL}};
EnumPropertyItem property_subtype_items[] = {
{PROP_NONE, "NONE", 0, "None", ""},
/* strings */
{PROP_FILEPATH, "FILEPATH", 0, "File Path", ""},
{PROP_DIRPATH, "DIRPATH", 0, "Directory Path", ""},
{PROP_FILENAME, "FILENAME", 0, "File Name", ""},
/* numbers */
{PROP_UNSIGNED, "UNSIGNED", 0, "Unsigned", ""},
{PROP_PERCENTAGE, "PERCENTAGE", 0, "Percentage", ""},
{PROP_FACTOR, "FACTOR", 0, "Factor", ""},
{PROP_ANGLE, "ANGLE", 0, "Angle", ""},
{PROP_TIME, "TIME", 0, "Time", ""},
{PROP_DISTANCE, "DISTANCE", 0, "Distance", ""},
/* number arrays */
{PROP_COLOR, "COLOR", 0, "Color", ""},
{PROP_TRANSLATION, "TRANSLATION", 0, "Translation", ""},
{PROP_DIRECTION, "DIRECTION", 0, "Direction", ""},
{PROP_VELOCITY, "VELOCITY", 0, "Velocity", ""},
{PROP_ACCELERATION, "ACCELERATION", 0, "Acceleration", ""},
{PROP_MATRIX, "MATRIX", 0, "Matrix", ""},
{PROP_EULER, "EULER", 0, "Euler Angles", ""},
{PROP_QUATERNION, "QUATERNION", 0, "Quaternion", ""},
{PROP_AXISANGLE, "AXISANGLE", 0, "Axis-Angle", ""},
{PROP_XYZ, "XYZ", 0, "XYZ", ""},
{PROP_XYZ_LENGTH, "XYZ_LENGTH", 0, "XYZ Length", ""},
{PROP_COLOR_GAMMA, "COLOR_GAMMA", 0, "Color", ""},
{PROP_COORDS, "COORDS", 0, "Coordinates", ""},
/* booleans */
{PROP_LAYER, "LAYER", 0, "Layer", ""},
{PROP_LAYER_MEMBER, "LAYER_MEMBER", 0, "Layer Member", ""},
{0, NULL, 0, NULL, NULL}};
EnumPropertyItem property_unit_items[] = {
{PROP_UNIT_NONE, "NONE", 0, "None", ""},
{PROP_UNIT_LENGTH, "LENGTH", 0, "Length", ""},

33
source/blender/makesrna/intern/rna_space.c
View File

@ -48,6 +48,8 @@
#include "WM_api.h"
#include "WM_types.h"
#include "RNA_enum_types.h"
EnumPropertyItem space_type_items[] = {
{SPACE_EMPTY, "EMPTY", 0, "Empty", ""},
{SPACE_VIEW3D, "VIEW_3D", 0, "3D View", ""},
@ -119,6 +121,7 @@ EnumPropertyItem viewport_shade_items[] = {
#include "BKE_paint.h"
#include "ED_image.h"
#include "ED_node.h"
#include "ED_screen.h"
#include "ED_view3d.h"
#include "ED_sequencer.h"
@ -839,6 +842,24 @@ static void rna_BackgroundImage_opacity_set(PointerRNA *ptr, float value)
bgpic->blend = 1.0f - value;
}
/* Space Node Editor */
static int rna_SpaceNodeEditor_node_tree_poll(PointerRNA *ptr, PointerRNA value)
{
SpaceNode *snode= (SpaceNode*)ptr->data;
bNodeTree *ntree= (bNodeTree*)value.data;
/* exclude group trees, only trees of the active type */
return (ntree->nodetype==0 && ntree->type == snode->treetype);
}
static void rna_SpaceNodeEditor_node_tree_update(Main *bmain, Scene *scene, PointerRNA *ptr)
{
SpaceNode *snode= (SpaceNode*)ptr->data;
ED_node_tree_update(snode, scene);
}
static EnumPropertyItem *rna_SpaceProperties_texture_context_itemf(bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), int *free)
{
Scene *scene = CTX_data_scene(C);
@ -2414,12 +2435,6 @@ static void rna_def_space_node(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem tree_type_items[] = {
{NTREE_SHADER, "MATERIAL", ICON_MATERIAL, "Material", "Material nodes"},
{NTREE_TEXTURE, "TEXTURE", ICON_TEXTURE, "Texture", "Texture nodes"},
{NTREE_COMPOSIT, "COMPOSITING", ICON_RENDERLAYERS, "Compositing", "Compositing nodes"},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem texture_type_items[] = {
{SNODE_TEX_OBJECT, "OBJECT", ICON_OBJECT_DATA, "Object", "Edit texture nodes from Object"},
{SNODE_TEX_WORLD, "WORLD", ICON_WORLD_DATA, "World", "Edit texture nodes from World"},
@ -2438,7 +2453,7 @@ static void rna_def_space_node(BlenderRNA *brna)
prop= RNA_def_property(srna, "tree_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "treetype");
RNA_def_property_enum_items(prop, tree_type_items);
RNA_def_property_enum_items(prop, nodetree_type_items);
RNA_def_property_ui_text(prop, "Tree Type", "Node tree type to display and edit");
RNA_def_property_update(prop, NC_SPACE|ND_SPACE_NODE, NULL);
@ -2459,8 +2474,10 @@ static void rna_def_space_node(BlenderRNA *brna)
prop= RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_sdna(prop, NULL, "nodetree");
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_SpaceNodeEditor_node_tree_poll");
RNA_def_property_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Node Tree", "Node tree being displayed and edited");
RNA_def_property_update(prop, NC_SPACE|ND_SPACE_NODE, "rna_SpaceNodeEditor_node_tree_update");
prop= RNA_def_property(srna, "show_backdrop", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", SNODE_BACKDRAW);

1
source/blender/modifiers/CMakeLists.txt
View File

@ -32,6 +32,7 @@ set(INC
../blenlib
../blenloader
../makesdna
../makesrna
../render/extern/include
../../../intern/elbeem/extern
../../../intern/guardedalloc

2
source/blender/modifiers/SConscript
View File

@ -6,7 +6,7 @@ sources = env.Glob('intern/*.c')
incs = '. ./intern'
incs += ' #/intern/guardedalloc #/intern/decimation/extern #/intern/bsp/extern #/intern/elbeem/extern'
incs += ' ../render/extern/include ../blenloader'
incs += ' ../include ../blenlib ../makesdna ../blenkernel ../blenkernel/intern'
incs += ' ../include ../blenlib ../makesdna ../makesrna ../blenkernel ../blenkernel/intern'
incs += ' ' + env['BF_ZLIB_INC']

232
source/blender/nodes/CMakeLists.txt
View File

@ -38,117 +38,137 @@ set(INC
set(INC_SYS
${GLEW_INCLUDE_PATH}
intern
composite
shader
texture
)
set(SRC
intern/CMP_nodes/CMP_alphaOver.c
intern/CMP_nodes/CMP_bilateralblur.c
intern/CMP_nodes/CMP_blur.c
intern/CMP_nodes/CMP_brightness.c
intern/CMP_nodes/CMP_channelMatte.c
intern/CMP_nodes/CMP_chromaMatte.c
intern/CMP_nodes/CMP_colorMatte.c
intern/CMP_nodes/CMP_colorSpill.c
intern/CMP_nodes/CMP_colorbalance.c
intern/CMP_nodes/CMP_composite.c
intern/CMP_nodes/CMP_crop.c
intern/CMP_nodes/CMP_curves.c
intern/CMP_nodes/CMP_defocus.c
intern/CMP_nodes/CMP_diffMatte.c
intern/CMP_nodes/CMP_dilate.c
intern/CMP_nodes/CMP_directionalblur.c
intern/CMP_nodes/CMP_displace.c
intern/CMP_nodes/CMP_distanceMatte.c
intern/CMP_nodes/CMP_filter.c
intern/CMP_nodes/CMP_flip.c
intern/CMP_nodes/CMP_gamma.c
intern/CMP_nodes/CMP_glare.c
intern/CMP_nodes/CMP_hueSatVal.c
intern/CMP_nodes/CMP_huecorrect.c
intern/CMP_nodes/CMP_idMask.c
intern/CMP_nodes/CMP_image.c
intern/CMP_nodes/CMP_invert.c
intern/CMP_nodes/CMP_lensdist.c
intern/CMP_nodes/CMP_levels.c
intern/CMP_nodes/CMP_lummaMatte.c
intern/CMP_nodes/CMP_mapUV.c
intern/CMP_nodes/CMP_mapValue.c
intern/CMP_nodes/CMP_math.c
intern/CMP_nodes/CMP_mixrgb.c
intern/CMP_nodes/CMP_normal.c
intern/CMP_nodes/CMP_normalize.c
intern/CMP_nodes/CMP_outputFile.c
intern/CMP_nodes/CMP_premulkey.c
intern/CMP_nodes/CMP_rgb.c
intern/CMP_nodes/CMP_rotate.c
intern/CMP_nodes/CMP_scale.c
intern/CMP_nodes/CMP_sepcombHSVA.c
intern/CMP_nodes/CMP_sepcombRGBA.c
intern/CMP_nodes/CMP_sepcombYCCA.c
intern/CMP_nodes/CMP_sepcombYUVA.c
intern/CMP_nodes/CMP_setalpha.c
intern/CMP_nodes/CMP_splitViewer.c
intern/CMP_nodes/CMP_texture.c
intern/CMP_nodes/CMP_tonemap.c
intern/CMP_nodes/CMP_translate.c
intern/CMP_nodes/CMP_valToRgb.c
intern/CMP_nodes/CMP_value.c
intern/CMP_nodes/CMP_vecBlur.c
intern/CMP_nodes/CMP_viewer.c
intern/CMP_nodes/CMP_zcombine.c
intern/CMP_util.c
intern/SHD_nodes/SHD_camera.c
intern/SHD_nodes/SHD_curves.c
intern/SHD_nodes/SHD_dynamic.c
intern/SHD_nodes/SHD_geom.c
intern/SHD_nodes/SHD_hueSatVal.c
intern/SHD_nodes/SHD_invert.c
intern/SHD_nodes/SHD_mapping.c
intern/SHD_nodes/SHD_material.c
intern/SHD_nodes/SHD_math.c
intern/SHD_nodes/SHD_mixRgb.c
intern/SHD_nodes/SHD_normal.c
intern/SHD_nodes/SHD_output.c
intern/SHD_nodes/SHD_rgb.c
intern/SHD_nodes/SHD_sepcombRGB.c
intern/SHD_nodes/SHD_squeeze.c
intern/SHD_nodes/SHD_texture.c
intern/SHD_nodes/SHD_valToRgb.c
intern/SHD_nodes/SHD_value.c
intern/SHD_nodes/SHD_vectMath.c
intern/SHD_util.c
intern/TEX_nodes/TEX_at.c
intern/TEX_nodes/TEX_bricks.c
intern/TEX_nodes/TEX_checker.c
intern/TEX_nodes/TEX_compose.c
intern/TEX_nodes/TEX_coord.c
intern/TEX_nodes/TEX_curves.c
intern/TEX_nodes/TEX_decompose.c
intern/TEX_nodes/TEX_distance.c
intern/TEX_nodes/TEX_hueSatVal.c
intern/TEX_nodes/TEX_image.c
intern/TEX_nodes/TEX_invert.c
intern/TEX_nodes/TEX_math.c
intern/TEX_nodes/TEX_mixRgb.c
intern/TEX_nodes/TEX_output.c
intern/TEX_nodes/TEX_proc.c
intern/TEX_nodes/TEX_rotate.c
intern/TEX_nodes/TEX_scale.c
intern/TEX_nodes/TEX_texture.c
intern/TEX_nodes/TEX_translate.c
intern/TEX_nodes/TEX_valToNor.c
intern/TEX_nodes/TEX_valToRgb.c
intern/TEX_nodes/TEX_viewer.c
intern/TEX_util.c
intern/node_util.c
composite/nodes/node_composite_alphaOver.c
composite/nodes/node_composite_bilateralblur.c
composite/nodes/node_composite_blur.c
composite/nodes/node_composite_brightness.c
composite/nodes/node_composite_channelMatte.c
composite/nodes/node_composite_chromaMatte.c
composite/nodes/node_composite_colorMatte.c
composite/nodes/node_composite_colorSpill.c
composite/nodes/node_composite_colorbalance.c
composite/nodes/node_composite_common.c
composite/nodes/node_composite_composite.c
composite/nodes/node_composite_crop.c
composite/nodes/node_composite_curves.c
composite/nodes/node_composite_defocus.c
composite/nodes/node_composite_diffMatte.c
composite/nodes/node_composite_dilate.c
composite/nodes/node_composite_directionalblur.c
composite/nodes/node_composite_displace.c
composite/nodes/node_composite_distanceMatte.c
composite/nodes/node_composite_filter.c
composite/nodes/node_composite_flip.c
composite/nodes/node_composite_gamma.c
composite/nodes/node_composite_glare.c
composite/nodes/node_composite_hueSatVal.c
composite/nodes/node_composite_huecorrect.c
composite/nodes/node_composite_idMask.c
composite/nodes/node_composite_image.c
composite/nodes/node_composite_invert.c
composite/nodes/node_composite_lensdist.c
composite/nodes/node_composite_levels.c
composite/nodes/node_composite_lummaMatte.c
composite/nodes/node_composite_mapUV.c
composite/nodes/node_composite_mapValue.c
composite/nodes/node_composite_math.c
composite/nodes/node_composite_mixrgb.c
composite/nodes/node_composite_normal.c
composite/nodes/node_composite_normalize.c
composite/nodes/node_composite_outputFile.c
composite/nodes/node_composite_premulkey.c
composite/nodes/node_composite_rgb.c
composite/nodes/node_composite_rotate.c
composite/nodes/node_composite_scale.c
composite/nodes/node_composite_sepcombHSVA.c
composite/nodes/node_composite_sepcombRGBA.c
composite/nodes/node_composite_sepcombYCCA.c
composite/nodes/node_composite_sepcombYUVA.c
composite/nodes/node_composite_setalpha.c
composite/nodes/node_composite_splitViewer.c
composite/nodes/node_composite_texture.c
composite/nodes/node_composite_tonemap.c
composite/nodes/node_composite_translate.c
composite/nodes/node_composite_valToRgb.c
composite/nodes/node_composite_value.c
composite/nodes/node_composite_vecBlur.c
composite/nodes/node_composite_viewer.c
composite/nodes/node_composite_zcombine.c
composite/node_composite_tree.c
composite/node_composite_util.c
CMP_node.h
SHD_node.h
TEX_node.h
intern/CMP_util.h
intern/SHD_util.h
intern/TEX_util.h
shader/nodes/node_shader_camera.c
shader/nodes/node_shader_common.c
shader/nodes/node_shader_curves.c
shader/nodes/node_shader_dynamic.c
shader/nodes/node_shader_geom.c
shader/nodes/node_shader_hueSatVal.c
shader/nodes/node_shader_invert.c
shader/nodes/node_shader_mapping.c
shader/nodes/node_shader_material.c
shader/nodes/node_shader_math.c
shader/nodes/node_shader_mixRgb.c
shader/nodes/node_shader_normal.c
shader/nodes/node_shader_output.c
shader/nodes/node_shader_rgb.c
shader/nodes/node_shader_sepcombRGB.c
shader/nodes/node_shader_squeeze.c
shader/nodes/node_shader_texture.c
shader/nodes/node_shader_valToRgb.c
shader/nodes/node_shader_value.c
shader/nodes/node_shader_vectMath.c
shader/node_shader_tree.c
shader/node_shader_util.c
texture/nodes/node_texture_at.c
texture/nodes/node_texture_bricks.c
texture/nodes/node_texture_checker.c
texture/nodes/node_texture_common.c
texture/nodes/node_texture_compose.c
texture/nodes/node_texture_coord.c
texture/nodes/node_texture_curves.c
texture/nodes/node_texture_decompose.c
texture/nodes/node_texture_distance.c
texture/nodes/node_texture_hueSatVal.c
texture/nodes/node_texture_image.c
texture/nodes/node_texture_invert.c
texture/nodes/node_texture_math.c
texture/nodes/node_texture_mixRgb.c
texture/nodes/node_texture_output.c
texture/nodes/node_texture_proc.c
texture/nodes/node_texture_rotate.c
texture/nodes/node_texture_scale.c
texture/nodes/node_texture_texture.c
texture/nodes/node_texture_translate.c
texture/nodes/node_texture_valToNor.c
texture/nodes/node_texture_valToRgb.c
texture/nodes/node_texture_viewer.c
texture/node_texture_tree.c
texture/node_texture_util.c
intern/node_util.c
intern/node_exec.c
intern/node_common.c
intern/node_socket.c
composite/node_composite_util.h
shader/node_shader_util.h
texture/node_texture_util.h
NOD_composite.h
NOD_shader.h
NOD_texture.h
NOD_socket.h
intern/node_util.h
intern/node_exec.h
intern/node_common.h
)
if(WITH_PYTHON)

14
source/blender/nodes/CMP_node.h → source/blender/nodes/NOD_composite.h
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_node.h 36550 2011-05-08 16:08:08Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -30,18 +30,24 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file CMP_node.h
/** \file NOD_composite.h
* \ingroup nodes
*/
#ifndef CMP_NODE_H
#define CMP_NODE_H
#ifndef NOD_composite_H
#define NOD_composite_H
#include "BKE_node.h"
extern bNodeTreeType ntreeType_Composite;
/* ****************** types array for all composite nodes ****************** */
void register_node_type_cmp_group(ListBase *lb);
void register_node_type_cmp_forloop(ListBase *lb);
void register_node_type_cmp_whileloop(ListBase *lb);
void register_node_type_cmp_rlayers(ListBase *lb);
void register_node_type_cmp_image(ListBase *lb);
void register_node_type_cmp_texture(ListBase *lb);

14
source/blender/nodes/SHD_node.h → source/blender/nodes/NOD_shader.h
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: SHD_node.h 36550 2011-05-08 16:08:08Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -30,19 +30,25 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file SHD_node.h
/** \file NOD_shader.h
* \ingroup nodes
*/
#ifndef SHD_NODE_H
#define SHD_NODE_H
#ifndef NOD_SHADER_H
#define NOD_SHADER_H
#include "BKE_node.h"
extern struct bNodeTreeType ntreeType_Shader;
/* the type definitions array */
/* ****************** types array for all shaders ****************** */
void register_node_type_sh_group(ListBase *lb);
void register_node_type_sh_forloop(ListBase *lb);
void register_node_type_sh_whileloop(ListBase *lb);
void register_node_type_sh_output(ListBase *lb);
void register_node_type_sh_material(ListBase *lb);
void register_node_type_sh_camera(ListBase *lb);

89
source/blender/nodes/NOD_socket.h Normal file
View File

@ -0,0 +1,89 @@
/**
*
* ***** 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) 2007 Blender Foundation.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): Lukas Toenne
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file NOD_socket.h
* \ingroup nodes
*/
#ifndef NOD_SOCKET_H_
#define NOD_SOCKET_H_
#include "DNA_listBase.h"
#include "BLI_utildefines.h"
#include "BKE_node.h"
#include "RNA_types.h"
struct bNodeTree;
struct bNode;
struct bNodeStack;
void node_socket_type_init(struct bNodeSocketType *types[]);
struct bNodeSocket *nodeAddInputInt(struct bNodeTree *ntree, struct bNode *node, const char *name, PropertySubType subtype, int value, int min, int max);
struct bNodeSocket *nodeAddOutputInt(struct bNodeTree *ntree, struct bNode *node, const char *name);
struct bNodeSocket *nodeAddInputFloat(struct bNodeTree *ntree, struct bNode *node, const char *name, PropertySubType subtype, float value, float min, float max);
struct bNodeSocket *nodeAddOutputFloat(struct bNodeTree *ntree, struct bNode *node, const char *name);
struct bNodeSocket *nodeAddInputBoolean(struct bNodeTree *ntree, struct bNode *node, const char *name, char value);
struct bNodeSocket *nodeAddOutputBoolean(struct bNodeTree *ntree, struct bNode *node, const char *name);
struct bNodeSocket *nodeAddInputVector(struct bNodeTree *ntree, struct bNode *node, const char *name, PropertySubType subtype, float x, float y, float z, float min, float max);
struct bNodeSocket *nodeAddOutputVector(struct bNodeTree *ntree, struct bNode *node, const char *name);
struct bNodeSocket *nodeAddInputRGBA(struct bNodeTree *ntree, struct bNode *node, const char *name, float r, float g, float b, float a);
struct bNodeSocket *nodeAddOutputRGBA(struct bNodeTree *ntree, struct bNode *node, const char *name);
struct bNodeSocket *nodeAddInputMesh(struct bNodeTree *ntree, struct bNode *node, const char *name);
struct bNodeSocket *nodeAddOutputMesh(struct bNodeTree *ntree, struct bNode *node, const char *name);
struct bNodeSocket *node_add_input_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp);
struct bNodeSocket *node_add_output_from_template(struct bNodeTree *ntree, struct bNode *node, struct bNodeSocketTemplate *stemp);
void node_verify_socket_templates(struct bNodeTree *ntree, struct bNode *node);
/* Socket Converters */
#define SOCK_VECTOR_X 1
#define SOCK_VECTOR_Y 2
#define SOCK_VECTOR_Z 3
#define SOCK_RGBA_R 1
#define SOCK_RGBA_G 2
#define SOCK_RGBA_B 3
#define SOCK_RGBA_A 4
#define SOCK_MESH_VERT_CO 1
#define SOCK_MESH_VERT_NO 2
#endif

14
source/blender/nodes/TEX_node.h → source/blender/nodes/NOD_texture.h
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: TEX_node.h 36550 2011-05-08 16:08:08Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -30,18 +30,24 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file TEX_node.h
/** \file NOD_texture.h
* \ingroup nodes
*/
#ifndef TEX_NODE_H
#define TEX_NODE_H
#ifndef NOD_TEXTURE_H
#define NOD_TEXTURE_H
#include "BKE_node.h"
extern bNodeTreeType ntreeType_Texture;
/* ****************** types array for all texture nodes ****************** */
void register_node_type_tex_group(ListBase *lb);
void register_node_type_tex_forloop(ListBase *lb);
void register_node_type_tex_whileloop(ListBase *lb);
void register_node_type_tex_math(ListBase *lb);
void register_node_type_tex_mix_rgb(ListBase *lb);
void register_node_type_tex_valtorgb(ListBase *lb);

8
source/blender/nodes/SConscript
View File

@ -2,11 +2,11 @@
Import ('env')
sources = env.Glob('intern/*.c')
cmpsources = env.Glob('intern/CMP_nodes/*.c')
shdsources = env.Glob('intern/SHD_nodes/*.c')
texsources = env.Glob('intern/TEX_nodes/*.c')
cmpsources = env.Glob('composite/*.c') + env.Glob('composite/nodes/*.c')
shdsources = env.Glob('shader/*.c') + env.Glob('shader/nodes/*.c')
texsources = env.Glob('texture/*.c') + env.Glob('texture/nodes/*.c')
incs = '. ./intern '
incs += './composite ./shader ./texture '
incs += '#/intern/guardedalloc ../editors/include ../blenlib ../makesdna'
incs += ' ../render/extern/include ../makesrna '
incs += ' ../imbuf ../avi '

811
source/blender/nodes/composite/node_composite_tree.c Normal file
View File

@ -0,0 +1,811 @@
/**
* ***** 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) 2007 Blender Foundation.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s):
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/composite/node_composite_tree.c
* \ingroup nodes
*/
#include <stdio.h>
#include "DNA_anim_types.h"
#include "DNA_scene_types.h"
#include "DNA_node_types.h"
#include "BLI_listbase.h"
#include "BLI_threads.h"
#include "BKE_animsys.h"
#include "BKE_colortools.h"
#include "BKE_fcurve.h"
#include "BKE_global.h"
#include "BKE_main.h"
#include "BKE_node.h"
#include "BKE_utildefines.h"
#include "node_exec.h"
#include "node_util.h"
#include "PIL_time.h"
#include "RNA_access.h"
#include "NOD_composite.h"
#include "node_composite_util.h"
static void foreach_nodetree(Main *main, void *calldata, bNodeTreeCallback func)
{
Scene *sce;
for(sce= main->scene.first; sce; sce= sce->id.next) {
if(sce->nodetree) {
func(calldata, &sce->id, sce->nodetree);
}
}
}
static void free_node_cache(bNodeTree *UNUSED(ntree), bNode *node)
{
bNodeSocket *sock;
for(sock= node->outputs.first; sock; sock= sock->next) {
if(sock->cache) {
free_compbuf(sock->cache);
sock->cache= NULL;
}
}
}
static void free_cache(bNodeTree *ntree)
{
bNode *node;
for(node= ntree->nodes.first; node; node= node->next)
free_node_cache(ntree, node);
}
static void update_node(bNodeTree *ntree, bNode *node)
{
bNodeSocket *sock;
for(sock= node->outputs.first; sock; sock= sock->next) {
if(sock->cache) {
//free_compbuf(sock->cache);
//sock->cache= NULL;
}
}
node->need_exec= 1;
/* individual node update call */
if (node->typeinfo->updatefunc)
node->typeinfo->updatefunc(ntree, node);
}
/* local tree then owns all compbufs */
static void localize(bNodeTree *UNUSED(localtree), bNodeTree *ntree)
{
bNode *node;
bNodeSocket *sock;
for(node= ntree->nodes.first; node; node= node->next) {
/* ensure new user input gets handled ok */
node->need_exec= 0;
/* move over the compbufs */
/* right after ntreeCopyTree() oldsock pointers are valid */
if(ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER)) {
if(node->id) {
if(node->flag & NODE_DO_OUTPUT)
node->new_node->id= (ID *)copy_image((Image *)node->id);
else
node->new_node->id= NULL;
}
}
for(sock= node->outputs.first; sock; sock= sock->next) {
sock->new_sock->cache= sock->cache;
compbuf_set_node(sock->new_sock->cache, node->new_node);
sock->cache= NULL;
sock->new_sock->new_sock= sock;
}
}
}
static void local_sync(bNodeTree *localtree, bNodeTree *ntree)
{
bNode *lnode;
/* move over the compbufs and previews */
for(lnode= localtree->nodes.first; lnode; lnode= lnode->next) {
if( (lnode->exec & NODE_READY) && !(lnode->exec & NODE_SKIPPED) ) {
if(ntreeNodeExists(ntree, lnode->new_node)) {
if(lnode->preview && lnode->preview->rect) {
nodeFreePreview(lnode->new_node);
lnode->new_node->preview= lnode->preview;
lnode->preview= NULL;
}
}
}
}
}
static void local_merge(bNodeTree *localtree, bNodeTree *ntree)
{
bNode *lnode;
bNodeSocket *lsock;
/* move over the compbufs and previews */
for(lnode= localtree->nodes.first; lnode; lnode= lnode->next) {
if(ntreeNodeExists(ntree, lnode->new_node)) {
if(ELEM(lnode->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER)) {
if(lnode->id && (lnode->flag & NODE_DO_OUTPUT)) {
/* image_merge does sanity check for pointers */
BKE_image_merge((Image *)lnode->new_node->id, (Image *)lnode->id);
}
}
for(lsock= lnode->outputs.first; lsock; lsock= lsock->next) {
if(ntreeOutputExists(lnode->new_node, lsock->new_sock)) {
lsock->new_sock->cache= lsock->cache;
compbuf_set_node(lsock->new_sock->cache, lnode->new_node);
lsock->cache= NULL;
lsock->new_sock= NULL;
}
}
}
}
}
bNodeTreeType ntreeType_Composite = {
/* type */ NTREE_COMPOSIT,
/* idname */ "NTCompositing Nodetree",
/* node_types */ { NULL, NULL },
/* free_cache */ free_cache,
/* free_node_cache */ free_node_cache,
/* foreach_nodetree */ foreach_nodetree,
/* localize */ localize,
/* local_sync */ local_sync,
/* local_merge */ local_merge,
/* update */ NULL,
/* update_node */ update_node
};
struct bNodeTreeExec *ntreeCompositBeginExecTree(bNodeTree *ntree)
{
bNodeTreeExec *exec;
bNode *node;
bNodeSocket *sock;
/* XXX hack: prevent exec data from being generated twice.
* this should be handled by the renderer!
*/
if (ntree->execdata)
return ntree->execdata;
/* ensures only a single output node is enabled */
ntreeSetOutput(ntree);
exec = ntree_exec_begin(ntree);
for(node= exec->nodetree->nodes.first; node; node= node->next) {
/* initialize needed for groups */
node->exec= 0;
for(sock= node->outputs.first; sock; sock= sock->next) {
bNodeStack *ns= node_get_socket_stack(exec->stack, sock);
if(ns && sock->cache) {
ns->data= sock->cache;
sock->cache= NULL;
}
}
/* cannot initialize them while using in threads */
if(ELEM4(node->type, CMP_NODE_TIME, CMP_NODE_CURVE_VEC, CMP_NODE_CURVE_RGB, CMP_NODE_HUECORRECT)) {
curvemapping_initialize(node->storage);
if(node->type==CMP_NODE_CURVE_RGB)
curvemapping_premultiply(node->storage, 0);
}
}
/* XXX this should not be necessary, but is still used for cmp/sha/tex nodes,
* which only store the ntree pointer. Should be fixed at some point!
*/
ntree->execdata = exec;
return exec;
}
void ntreeCompositEndExecTree(bNodeTreeExec *exec)
{
if(exec) {
bNodeTree *ntree= exec->nodetree;
bNode *node;
bNodeStack *ns;
for(node= exec->nodetree->nodes.first; node; node= node->next) {
bNodeSocket *sock;
for(sock= node->outputs.first; sock; sock= sock->next) {
ns = node_get_socket_stack(exec->stack, sock);
if(ns && ns->data) {
sock->cache= ns->data;
ns->data= NULL;
}
}
if(node->type==CMP_NODE_CURVE_RGB)
curvemapping_premultiply(node->storage, 1);
node->need_exec= 0;
}
ntree_exec_end(exec);
/* XXX clear nodetree backpointer to exec data, same problem as noted in ntreeBeginExecTree */
ntree->execdata = NULL;
}
}
/* ***************************** threaded version for execute composite nodes ************* */
/* these are nodes without input, only giving values */
/* or nodes with only value inputs */
static int node_only_value(bNode *node)
{
bNodeSocket *sock;
if(ELEM3(node->type, CMP_NODE_TIME, CMP_NODE_VALUE, CMP_NODE_RGB))
return 1;
/* doing this for all node types goes wrong. memory free errors */
if(node->inputs.first && node->type==CMP_NODE_MAP_VALUE) {
int retval= 1;
for(sock= node->inputs.first; sock; sock= sock->next) {
if(sock->link)
retval &= node_only_value(sock->link->fromnode);
}
return retval;
}
return 0;
}
/* not changing info, for thread callback */
typedef struct ThreadData {
bNodeStack *stack;
RenderData *rd;
} ThreadData;
static void *exec_composite_node(void *nodeexec_v)
{
bNodeStack *nsin[MAX_SOCKET]; /* arbitrary... watch this */
bNodeStack *nsout[MAX_SOCKET]; /* arbitrary... watch this */
bNodeExec *nodeexec= nodeexec_v;
bNode *node= nodeexec->node;
ThreadData *thd= (ThreadData *)node->threaddata;
node_get_stack(node, thd->stack, nsin, nsout);
if((node->flag & NODE_MUTED) && (!node_only_value(node))) {
/* viewers we execute, for feedback to user */
if(ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER))
node->typeinfo->execfunc(thd->rd, node, nsin, nsout);
else
node_compo_pass_on(node, nsin, nsout);
}
else if(node->typeinfo->execfunc)
node->typeinfo->execfunc(thd->rd, node, nsin, nsout);
else if (node->typeinfo->newexecfunc)
node->typeinfo->newexecfunc(thd->rd, 0, node, nodeexec->data, nsin, nsout);
node->exec |= NODE_READY;
return 0;
}
/* return total of executable nodes, for timecursor */
static int setExecutableNodes(bNodeTree *ntree, ThreadData *thd)
{
bNodeStack *nsin[MAX_SOCKET]; /* arbitrary... watch this */
bNodeStack *nsout[MAX_SOCKET]; /* arbitrary... watch this */
bNode *node;
bNodeSocket *sock;
int totnode= 0, group_edit= 0;
/* note; do not add a dependency sort here, the stack was created already */
/* if we are in group edit, viewer nodes get skipped when group has viewer */
for(node= ntree->nodes.first; node; node= node->next)
if(node->type==NODE_GROUP && (node->flag & NODE_GROUP_EDIT))
if(ntreeHasType((bNodeTree *)node->id, CMP_NODE_VIEWER))
group_edit= 1;
for(node= ntree->nodes.first; node; node= node->next) {
int a;
node_get_stack(node, thd->stack, nsin, nsout);
/* test the outputs */
/* skip value-only nodes (should be in type!) */
if(!node_only_value(node)) {
for(a=0, sock= node->outputs.first; sock; sock= sock->next, a++) {
if(nsout[a]->data==NULL && nsout[a]->hasoutput) {
node->need_exec= 1;
break;
}
}
}
/* test the inputs */
for(a=0, sock= node->inputs.first; sock; sock= sock->next, a++) {
/* skip viewer nodes in bg render or group edit */
if( ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER) && (G.background || group_edit))
node->need_exec= 0;
/* is sock in use? */
else if(sock->link) {
bNodeLink *link= sock->link;
/* this is the test for a cyclic case */
if(link->fromnode==NULL || link->tonode==NULL);
else if(link->fromnode->level >= link->tonode->level && link->tonode->level!=0xFFF) {
if(link->fromnode->need_exec) {
node->need_exec= 1;
break;
}
}
else {
node->need_exec= 0;
printf("Node %s skipped, cyclic dependency\n", node->name);
}
}
}
if(node->need_exec) {
/* free output buffers */
for(a=0, sock= node->outputs.first; sock; sock= sock->next, a++) {
if(nsout[a]->data) {
free_compbuf(nsout[a]->data);
nsout[a]->data= NULL;
}
}
totnode++;
/* printf("node needs exec %s\n", node->name); */
/* tag for getExecutableNode() */
node->exec= 0;
}
else {
/* tag for getExecutableNode() */
node->exec= NODE_READY|NODE_FINISHED|NODE_SKIPPED;
}
}
/* last step: set the stack values for only-value nodes */
/* just does all now, compared to a full buffer exec this is nothing */
if(totnode) {
for(node= ntree->nodes.first; node; node= node->next) {
if(node->need_exec==0 && node_only_value(node)) {
if(node->typeinfo->execfunc) {
node_get_stack(node, thd->stack, nsin, nsout);
node->typeinfo->execfunc(thd->rd, node, nsin, nsout);
}
}
}
}
return totnode;
}
/* while executing tree, free buffers from nodes that are not needed anymore */
static void freeExecutableNode(bNodeTree *ntree, bNodeTreeExec *exec)
{
/* node outputs can be freed when:
- not a render result or image node
- when node outputs go to nodes all being set NODE_FINISHED
*/
bNode *node;
bNodeSocket *sock;
/* set exec flag for finished nodes that might need freed */
for(node= ntree->nodes.first; node; node= node->next) {
if(node->type!=CMP_NODE_R_LAYERS)
if(node->exec & NODE_FINISHED)
node->exec |= NODE_FREEBUFS;
}
/* clear this flag for input links that are not done yet */
for(node= ntree->nodes.first; node; node= node->next) {
if((node->exec & NODE_FINISHED)==0) {
for(sock= node->inputs.first; sock; sock= sock->next)
if(sock->link)
sock->link->fromnode->exec &= ~NODE_FREEBUFS;
}
}
/* now we can free buffers */
for(node= ntree->nodes.first; node; node= node->next) {
if(node->exec & NODE_FREEBUFS) {
for(sock= node->outputs.first; sock; sock= sock->next) {
bNodeStack *ns= node_get_socket_stack(exec->stack, sock);
if(ns && ns->data) {
free_compbuf(ns->data);
ns->data= NULL;
// printf("freed buf node %s \n", node->name);
}
}
}
}
}
static bNodeExec *getExecutableNode(bNodeTreeExec *exec)
{
bNodeExec *nodeexec;
bNodeSocket *sock;
int n;
for(n=0, nodeexec=exec->nodeexec; n < exec->totnodes; ++n, ++nodeexec) {
if(nodeexec->node->exec==0) {
/* input sockets should be ready */
for(sock= nodeexec->node->inputs.first; sock; sock= sock->next) {
if(sock->link && sock->link->fromnode)
if((sock->link->fromnode->exec & NODE_READY)==0)
break;
}
if(sock==NULL)
return nodeexec;
}
}
return NULL;
}
/* check if texture nodes need exec or end */
static void ntree_composite_texnode(bNodeTree *ntree, int init)
{
bNode *node;
for(node= ntree->nodes.first; node; node= node->next) {
if(node->type==CMP_NODE_TEXTURE && node->id) {
Tex *tex= (Tex *)node->id;
if(tex->nodetree && tex->use_nodes) {
/* has internal flag to detect it only does it once */
if(init) {
if (!tex->nodetree->execdata)
tex->nodetree->execdata = ntreeTexBeginExecTree(tex->nodetree);
}
else
ntreeTexEndExecTree(tex->nodetree->execdata);
tex->nodetree->execdata = NULL;
}
}
}
}
/* optimized tree execute test for compositing */
void ntreeCompositExecTree(bNodeTree *ntree, RenderData *rd, int do_preview)
{
bNodeExec *nodeexec;
bNode *node;
ListBase threads;
ThreadData thdata;
int totnode, curnode, rendering= 1, n;
bNodeTreeExec *exec= NULL;
if(ntree==NULL) return;
if(do_preview)
ntreeInitPreview(ntree, 0, 0);
if (!ntree->execdata)
exec = ntreeCompositBeginExecTree(ntree);
ntree_composite_texnode(ntree, 1);
/* prevent unlucky accidents */
if(G.background)
rd->scemode &= ~R_COMP_CROP;
/* setup callerdata for thread callback */
thdata.rd= rd;
thdata.stack= exec->stack;
/* fixed seed, for example noise texture */
BLI_srandom(rd->cfra);
/* sets need_exec tags in nodes */
curnode = totnode= setExecutableNodes(ntree, &thdata);
BLI_init_threads(&threads, exec_composite_node, rd->threads);
while(rendering) {
if(BLI_available_threads(&threads)) {
nodeexec= getExecutableNode(exec);
if(nodeexec) {
node = nodeexec->node;
if(ntree->progress && totnode)
ntree->progress(ntree->prh, (1.0 - curnode/(float)totnode));
if(ntree->stats_draw) {
char str[64];
sprintf(str, "Compositing %d %s", curnode, node->name);
ntree->stats_draw(ntree->sdh, str);
}
curnode--;
node->threaddata = &thdata;
node->exec= NODE_PROCESSING;
BLI_insert_thread(&threads, nodeexec);
}
else
PIL_sleep_ms(50);
}
else
PIL_sleep_ms(50);
rendering= 0;
/* test for ESC */
if(ntree->test_break && ntree->test_break(ntree->tbh)) {
for(node= ntree->nodes.first; node; node= node->next)
node->exec |= NODE_READY;
}
/* check for ready ones, and if we need to continue */
for(n=0, nodeexec=exec->nodeexec; n < exec->totnodes; ++n, ++nodeexec) {
node = nodeexec->node;
if(node->exec & NODE_READY) {
if((node->exec & NODE_FINISHED)==0) {
BLI_remove_thread(&threads, nodeexec); /* this waits for running thread to finish btw */
node->exec |= NODE_FINISHED;
/* freeing unused buffers */
if(rd->scemode & R_COMP_FREE)
freeExecutableNode(ntree, exec);
}
}
else rendering= 1;
}
}
BLI_end_threads(&threads);
ntreeCompositEndExecTree(exec);
}
/* *********************************************** */
/* clumsy checking... should do dynamic outputs once */
static void force_hidden_passes(bNode *node, int passflag)
{
bNodeSocket *sock;
for(sock= node->outputs.first; sock; sock= sock->next)
sock->flag &= ~SOCK_UNAVAIL;
sock= BLI_findlink(&node->outputs, RRES_OUT_Z);
if(!(passflag & SCE_PASS_Z)) sock->flag |= SOCK_UNAVAIL;
sock= BLI_findlink(&node->outputs, RRES_OUT_NORMAL);
if(!(passflag & SCE_PASS_NORMAL)) sock->flag |= SOCK_UNAVAIL;
sock= BLI_findlink(&node->outputs, RRES_OUT_VEC);
if(!(passflag & SCE_PASS_VECTOR)) sock->flag |= SOCK_UNAVAIL;
sock= BLI_findlink(&node->outputs, RRES_OUT_UV);
if(!(passflag & SCE_PASS_UV)) sock->flag |= SOCK_UNAVAIL;
sock= BLI_findlink(&node->outputs, RRES_OUT_RGBA);
if(!(passflag & SCE_PASS_RGBA)) sock->flag |= SOCK_UNAVAIL;
sock= BLI_findlink(&node->outputs, RRES_OUT_DIFF);
if(!(passflag & SCE_PASS_DIFFUSE)) sock->flag |= SOCK_UNAVAIL;
sock= BLI_findlink(&node->outputs, RRES_OUT_SPEC);
if(!(passflag & SCE_PASS_SPEC)) sock->flag |= SOCK_UNAVAIL;
sock= BLI_findlink(&node->outputs, RRES_OUT_SHADOW);
if(!(passflag & SCE_PASS_SHADOW)) sock->flag |= SOCK_UNAVAIL;
sock= BLI_findlink(&node->outputs, RRES_OUT_AO);
if(!(passflag & SCE_PASS_AO)) sock->flag |= SOCK_UNAVAIL;
sock= BLI_findlink(&node->outputs, RRES_OUT_REFLECT);
if(!(passflag & SCE_PASS_REFLECT)) sock->flag |= SOCK_UNAVAIL;
sock= BLI_findlink(&node->outputs, RRES_OUT_REFRACT);
if(!(passflag & SCE_PASS_REFRACT)) sock->flag |= SOCK_UNAVAIL;
sock= BLI_findlink(&node->outputs, RRES_OUT_INDIRECT);
if(!(passflag & SCE_PASS_INDIRECT)) sock->flag |= SOCK_UNAVAIL;
sock= BLI_findlink(&node->outputs, RRES_OUT_INDEXOB);
if(!(passflag & SCE_PASS_INDEXOB)) sock->flag |= SOCK_UNAVAIL;
sock= BLI_findlink(&node->outputs, RRES_OUT_INDEXMA);
if(!(passflag & SCE_PASS_INDEXMA)) sock->flag |= SOCK_UNAVAIL;
sock= BLI_findlink(&node->outputs, RRES_OUT_MIST);
if(!(passflag & SCE_PASS_MIST)) sock->flag |= SOCK_UNAVAIL;
sock= BLI_findlink(&node->outputs, RRES_OUT_EMIT);
if(!(passflag & SCE_PASS_EMIT)) sock->flag |= SOCK_UNAVAIL;
sock= BLI_findlink(&node->outputs, RRES_OUT_ENV);
if(!(passflag & SCE_PASS_ENVIRONMENT)) sock->flag |= SOCK_UNAVAIL;
}
/* based on rules, force sockets hidden always */
void ntreeCompositForceHidden(bNodeTree *ntree, Scene *curscene)
{
bNode *node;
if(ntree==NULL) return;
for(node= ntree->nodes.first; node; node= node->next) {
if( node->type==CMP_NODE_R_LAYERS) {
Scene *sce= node->id?(Scene *)node->id:curscene;
SceneRenderLayer *srl= BLI_findlink(&sce->r.layers, node->custom1);
if(srl)
force_hidden_passes(node, srl->passflag);
}
else if( node->type==CMP_NODE_IMAGE) {
Image *ima= (Image *)node->id;
if(ima) {
if(ima->rr) {
ImageUser *iuser= node->storage;
RenderLayer *rl= BLI_findlink(&ima->rr->layers, iuser->layer);
if(rl)
force_hidden_passes(node, rl->passflag);
else
force_hidden_passes(node, 0);
}
else if(ima->type!=IMA_TYPE_MULTILAYER) { /* if ->rr not yet read we keep inputs */
force_hidden_passes(node, RRES_OUT_Z);
}
else
force_hidden_passes(node, 0);
}
else
force_hidden_passes(node, 0);
}
}
}
/* called from render pipeline, to tag render input and output */
/* need to do all scenes, to prevent errors when you re-render 1 scene */
void ntreeCompositTagRender(Scene *curscene)
{
Scene *sce;
for(sce= G.main->scene.first; sce; sce= sce->id.next) {
if(sce->nodetree) {
bNode *node;
for(node= sce->nodetree->nodes.first; node; node= node->next) {
if(node->id==(ID *)curscene || node->type==CMP_NODE_COMPOSITE)
NodeTagChanged(sce->nodetree, node);
else if(node->type==CMP_NODE_TEXTURE) /* uses scene sizex/sizey */
NodeTagChanged(sce->nodetree, node);
}
}
}
}
static int node_animation_properties(bNodeTree *ntree, bNode *node)
{
bNodeSocket *sock;
const ListBase *lb;
Link *link;
PointerRNA ptr;
PropertyRNA *prop;
/* check to see if any of the node's properties have fcurves */
RNA_pointer_create((ID *)ntree, &RNA_Node, node, &ptr);
lb = RNA_struct_type_properties(ptr.type);
for (link=lb->first; link; link=link->next) {
int driven, len=1, index;
prop = (PropertyRNA *)link;
if (RNA_property_array_check(prop))
len = RNA_property_array_length(&ptr, prop);
for (index=0; index<len; index++) {
if (rna_get_fcurve(&ptr, prop, index, NULL, &driven)) {
NodeTagChanged(ntree, node);
return 1;
}
}
}
/* now check node sockets */
for (sock = node->inputs.first; sock; sock=sock->next) {
int driven, len=1, index;
RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, sock, &ptr);
prop = RNA_struct_find_property(&ptr, "default_value");
if (prop) {
if (RNA_property_array_check(prop))
len = RNA_property_array_length(&ptr, prop);
for (index=0; index<len; index++) {
if (rna_get_fcurve(&ptr, prop, index, NULL, &driven)) {
NodeTagChanged(ntree, node);
return 1;
}
}
}
}
return 0;
}
/* tags nodes that have animation capabilities */
int ntreeCompositTagAnimated(bNodeTree *ntree)
{
bNode *node;
int tagged= 0;
if(ntree==NULL) return 0;
for(node= ntree->nodes.first; node; node= node->next) {
tagged = node_animation_properties(ntree, node);
/* otherwise always tag these node types */
if(node->type==CMP_NODE_IMAGE) {
Image *ima= (Image *)node->id;
if(ima && ELEM(ima->source, IMA_SRC_MOVIE, IMA_SRC_SEQUENCE)) {
NodeTagChanged(ntree, node);
tagged= 1;
}
}
else if(node->type==CMP_NODE_TIME) {
NodeTagChanged(ntree, node);
tagged= 1;
}
/* here was tag render layer, but this is called after a render, so re-composites fail */
else if(node->type==NODE_GROUP) {
if( ntreeCompositTagAnimated((bNodeTree *)node->id) ) {
NodeTagChanged(ntree, node);
}
}
}
return tagged;
}
/* called from image window preview */
void ntreeCompositTagGenerators(bNodeTree *ntree)
{
bNode *node;
if(ntree==NULL) return;
for(node= ntree->nodes.first; node; node= node->next) {
if( ELEM(node->type, CMP_NODE_R_LAYERS, CMP_NODE_IMAGE))
NodeTagChanged(ntree, node);
}
}
/* XXX after render animation system gets a refresh, this call allows composite to end clean */
void ntreeClearTags(bNodeTree *ntree)
{
bNode *node;
if(ntree==NULL) return;
for(node= ntree->nodes.first; node; node= node->next) {
node->need_exec= 0;
if(node->type==NODE_GROUP)
ntreeClearTags((bNodeTree *)node->id);
}
}

10
source/blender/nodes/intern/CMP_util.c → source/blender/nodes/composite/node_composite_util.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_util.c 36536 2011-05-07 13:27:27Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,12 +27,12 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_util.c
/** \file blender/nodes/composite/node_composite_util.c
* \ingroup nodes
*/
#include "CMP_util.h"
#include "node_composite_util.h"
CompBuf *alloc_compbuf(int sizex, int sizey, int type, int alloc)
{
@ -67,7 +67,7 @@ CompBuf *dupalloc_compbuf(CompBuf *cbuf)
{
CompBuf *dupbuf= alloc_compbuf(cbuf->x, cbuf->y, cbuf->type, 1);
if(dupbuf) {
memmove(dupbuf->rect, cbuf->rect, cbuf->type*sizeof(float)*cbuf->x*cbuf->y);
memcpy(dupbuf->rect, cbuf->rect, cbuf->type*sizeof(float)*cbuf->x*cbuf->y);
dupbuf->xof= cbuf->xof;
dupbuf->yof= cbuf->yof;
@ -156,7 +156,7 @@ void node_compo_pass_on(bNode *node, bNodeStack **nsin, bNodeStack **nsout)
if(valbuf || colbuf || vecbuf) {
for(a=0, sock= node->outputs.first; sock; sock= sock->next, a++) {
if(nsout[a]->hasoutput) {
if(sock->type==SOCK_VALUE && valbuf) {
if(sock->type==SOCK_FLOAT && valbuf) {
nsout[a]->data= pass_on_compbuf(valbuf);
valbuf= NULL;
}

9
source/blender/nodes/intern/CMP_util.h → source/blender/nodes/composite/node_composite_util.h
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_util.h 35562 2011-03-15 20:10:32Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,13 +27,13 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_util.h
/** \file blender/nodes/composite/node_composite_util.h
* \ingroup nodes
*/
#ifndef CMP_NODE_UTILS_H_
#define CMP_NODE_UTILS_H_
#ifndef NODE_COMPOSITE_UTIL_H_
#define NODE_COMPOSITE_UTIL_H_
#include <stdlib.h>
#include <string.h>
@ -70,7 +70,6 @@
#include "BKE_library.h"
#include "BKE_object.h"
#include "../CMP_node.h"
#include "node_util.h"
#include "IMB_imbuf_types.h"

24
source/blender/nodes/intern/CMP_nodes/CMP_alphaOver.c → source/blender/nodes/composite/nodes/node_composite_alphaOver.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_alphaOver.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,22 +27,22 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_alphaOver.c
/** \file blender/nodes/composite/nodes/node_composite_alphaOver.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** ALPHAOVER ******************** */
static bNodeSocketType cmp_node_alphaover_in[]= {
{ SOCK_VALUE, 1, "Fac", 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_alphaover_in[]= {
{ SOCK_FLOAT, 1, "Fac", 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, PROP_FACTOR},
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_alphaover_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_alphaover_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -140,7 +140,7 @@ static void node_composit_exec_alphaover(void *UNUSED(data), bNode *node, bNodeS
}
}
static void node_alphaover_init(bNode* node)
static void node_alphaover_init(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
node->storage= MEM_callocN(sizeof(NodeTwoFloats), "NodeTwoFloats");
}
@ -149,8 +149,8 @@ void register_node_type_cmp_alphaover(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_ALPHAOVER, "AlphaOver", NODE_CLASS_OP_COLOR, NODE_OPTIONS,
cmp_node_alphaover_in, cmp_node_alphaover_out);
node_type_base(&ntype, CMP_NODE_ALPHAOVER, "AlphaOver", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_alphaover_in, cmp_node_alphaover_out);
node_type_size(&ntype, 80, 40, 120);
node_type_init(&ntype, node_alphaover_init);
node_type_storage(&ntype, "NodeTwoFloats", node_free_standard_storage, node_copy_standard_storage);

20
source/blender/nodes/intern/CMP_nodes/CMP_bilateralblur.c → source/blender/nodes/composite/nodes/node_composite_bilateralblur.c
View File

@ -27,21 +27,21 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_bilateralblur.c
/** \file blender/nodes/composite/nodes/node_composite_bilateralblur.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** BILATERALBLUR ******************** */
static bNodeSocketType cmp_node_bilateralblur_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{ SOCK_RGBA, 1, "Determinator", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_bilateralblur_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ SOCK_RGBA, 1, "Determinator", 0.8f, 0.8f, 0.8f, 1.0f},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_bilateralblur_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_bilateralblur_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -247,7 +247,7 @@ static void node_composit_exec_bilateralblur(void *UNUSED(data), bNode *node, bN
free_compbuf(new);
}
static void node_composit_init_bilateralblur(bNode* node)
static void node_composit_init_bilateralblur(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeBilateralBlurData *nbbd= MEM_callocN(sizeof(NodeBilateralBlurData), "node bilateral blur data");
node->storage= nbbd;
@ -259,8 +259,8 @@ void register_node_type_cmp_bilateralblur(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_BILATERALBLUR, "Bilateral Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS,
cmp_node_bilateralblur_in, cmp_node_bilateralblur_out);
node_type_base(&ntype, CMP_NODE_BILATERALBLUR, "Bilateral Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_bilateralblur_in, cmp_node_bilateralblur_out);
node_type_size(&ntype, 150, 120, 200);
node_type_init(&ntype, node_composit_init_bilateralblur);
node_type_storage(&ntype, "NodeBilateralBlurData", node_free_standard_storage, node_copy_standard_storage);

22
source/blender/nodes/intern/CMP_nodes/CMP_blur.c → source/blender/nodes/composite/nodes/node_composite_blur.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_blur.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -28,21 +28,21 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_blur.c
/** \file blender/nodes/composite/nodes/node_composite_blur.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** BLUR ******************** */
static bNodeSocketType cmp_node_blur_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "Size", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_blur_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ SOCK_FLOAT, 1, "Size", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_blur_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_blur_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -713,7 +713,7 @@ static void node_composit_exec_blur(void *data, bNode *node, bNodeStack **in, bN
generate_preview(data, node, out[0]->data);
}
static void node_composit_init_blur(bNode* node)
static void node_composit_init_blur(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
node->storage= MEM_callocN(sizeof(NodeBlurData), "node blur data");
}
@ -722,8 +722,8 @@ void register_node_type_cmp_blur(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_BLUR, "Blur", NODE_CLASS_OP_FILTER, NODE_PREVIEW|NODE_OPTIONS,
cmp_node_blur_in, cmp_node_blur_out);
node_type_base(&ntype, CMP_NODE_BLUR, "Blur", NODE_CLASS_OP_FILTER, NODE_PREVIEW|NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_blur_in, cmp_node_blur_out);
node_type_size(&ntype, 120, 80, 200);
node_type_init(&ntype, node_composit_init_blur);
node_type_storage(&ntype, "NodeBlurData", node_free_standard_storage, node_copy_standard_storage);

22
source/blender/nodes/intern/CMP_nodes/CMP_brightness.c → source/blender/nodes/composite/nodes/node_composite_brightness.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_brightness.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -28,24 +28,24 @@
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_brightness.c
/** \file blender/nodes/composite/nodes/node_composite_brightness.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** Brigh and contrsast ******************** */
static bNodeSocketType cmp_node_brightcontrast_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "Bright", 0.0f, 0.0f, 0.0f, 0.0f, -100.0f, 100.0f},
{ SOCK_VALUE, 1, "Contrast", 0.0f, 0.0f, 0.0f, 0.0f, -100.0f, 100.0f},
static bNodeSocketTemplate cmp_node_brightcontrast_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ SOCK_FLOAT, 1, "Bright", 0.0f, 0.0f, 0.0f, 0.0f, -100.0f, 100.0f, PROP_NONE},
{ SOCK_FLOAT, 1, "Contrast", 0.0f, 0.0f, 0.0f, 0.0f, -100.0f, 100.0f, PROP_NONE},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_brightcontrast_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_brightcontrast_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -100,8 +100,8 @@ void register_node_type_cmp_brightcontrast(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_BRIGHTCONTRAST, "Bright/Contrast", NODE_CLASS_OP_COLOR, NODE_OPTIONS,
cmp_node_brightcontrast_in, cmp_node_brightcontrast_out);
node_type_base(&ntype, CMP_NODE_BRIGHTCONTRAST, "Bright/Contrast", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_brightcontrast_in, cmp_node_brightcontrast_out);
node_type_size(&ntype, 140, 100, 320);
node_type_exec(&ntype, node_composit_exec_brightcontrast);

22
source/blender/nodes/intern/CMP_nodes/CMP_channelMatte.c → source/blender/nodes/composite/nodes/node_composite_channelMatte.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_channelMatte.c 36536 2011-05-07 13:27:27Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,23 +27,23 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_channelMatte.c
/** \file blender/nodes/composite/nodes/node_composite_channelMatte.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* ******************* Channel Matte Node ********************************* */
static bNodeSocketType cmp_node_channel_matte_in[]={
{SOCK_RGBA,1,"Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_channel_matte_in[]={
{SOCK_RGBA,1,"Image", 0.8f, 0.8f, 0.8f, 1.0f},
{-1,0,""}
};
static bNodeSocketType cmp_node_channel_matte_out[]={
{SOCK_RGBA,0,"Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_VALUE,0,"Matte",0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_channel_matte_out[]={
{SOCK_RGBA,0,"Image"},
{SOCK_FLOAT,0,"Matte"},
{-1,0,""}
};
@ -187,7 +187,7 @@ static void node_composit_exec_channel_matte(void *data, bNode *node, bNodeStack
}
static void node_composit_init_channel_matte(bNode *node)
static void node_composit_init_channel_matte(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeChroma *c= MEM_callocN(sizeof(NodeChroma), "node chroma");
node->storage=c;
@ -206,8 +206,8 @@ void register_node_type_cmp_channel_matte(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_CHANNEL_MATTE, "Channel Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS,
cmp_node_channel_matte_in, cmp_node_channel_matte_out);
node_type_base(&ntype, CMP_NODE_CHANNEL_MATTE, "Channel Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_channel_matte_in, cmp_node_channel_matte_out);
node_type_size(&ntype, 200, 80, 250);
node_type_init(&ntype, node_composit_init_channel_matte);
node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage);

24
source/blender/nodes/intern/CMP_nodes/CMP_chromaMatte.c → source/blender/nodes/composite/nodes/node_composite_chromaMatte.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_chromaMatte.c 36536 2011-05-07 13:27:27Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,23 +27,23 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_chromaMatte.c
/** \file blender/nodes/composite/nodes/node_composite_chromaMatte.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* ******************* Chroma Key ********************************************************** */
static bNodeSocketType cmp_node_chroma_in[]={
{SOCK_RGBA,1,"Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_RGBA,1,"Key Color", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_chroma_in[]={
{SOCK_RGBA,1,"Image", 0.8f, 0.8f, 0.8f, 1.0f},
{SOCK_RGBA,1,"Key Color", 0.8f, 0.8f, 0.8f, 1.0f},
{-1,0,""}
};
static bNodeSocketType cmp_node_chroma_out[]={
{SOCK_RGBA,0,"Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_VALUE,0,"Matte",0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_chroma_out[]={
{SOCK_RGBA,0,"Image"},
{SOCK_FLOAT,0,"Matte"},
{-1,0,""}
};
@ -178,7 +178,7 @@ static void node_composit_exec_chroma_matte(void *data, bNode *node, bNodeStack
}
static void node_composit_init_chroma_matte(bNode *node)
static void node_composit_init_chroma_matte(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeChroma *c= MEM_callocN(sizeof(NodeChroma), "node chroma");
node->storage= c;
@ -193,8 +193,8 @@ void register_node_type_cmp_chroma_matte(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_CHROMA_MATTE, "Chroma Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS,
cmp_node_chroma_in, cmp_node_chroma_out);
node_type_base(&ntype, CMP_NODE_CHROMA_MATTE, "Chroma Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_chroma_in, cmp_node_chroma_out);
node_type_size(&ntype, 200, 80, 300);
node_type_init(&ntype, node_composit_init_chroma_matte);
node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage);

24
source/blender/nodes/intern/CMP_nodes/CMP_colorMatte.c → source/blender/nodes/composite/nodes/node_composite_colorMatte.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_colorMatte.c 36536 2011-05-07 13:27:27Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,23 +27,23 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_colorMatte.c
/** \file blender/nodes/composite/nodes/node_composite_colorMatte.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* ******************* Color Key ********************************************************** */
static bNodeSocketType cmp_node_color_in[]={
{SOCK_RGBA,1,"Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_RGBA,1,"Key Color", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_color_in[]={
{SOCK_RGBA,1,"Image", 0.8f, 0.8f, 0.8f, 1.0f},
{SOCK_RGBA,1,"Key Color", 0.8f, 0.8f, 0.8f, 1.0f},
{-1,0,""}
};
static bNodeSocketType cmp_node_color_out[]={
{SOCK_RGBA,0,"Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_VALUE,0,"Matte",0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_color_out[]={
{SOCK_RGBA,0,"Image"},
{SOCK_FLOAT,0,"Matte"},
{-1,0,""}
};
@ -114,7 +114,7 @@ static void node_composit_exec_color_matte(void *data, bNode *node, bNodeStack *
free_compbuf(cbuf);
}
static void node_composit_init_color_matte(bNode *node)
static void node_composit_init_color_matte(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeChroma *c= MEM_callocN(sizeof(NodeChroma), "node color");
node->storage= c;
@ -129,8 +129,8 @@ void register_node_type_cmp_color_matte(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_COLOR_MATTE, "Color Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS,
cmp_node_color_in, cmp_node_color_out);
node_type_base(&ntype, CMP_NODE_COLOR_MATTE, "Color Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_color_in, cmp_node_color_out);
node_type_size(&ntype, 200, 80, 300);
node_type_init(&ntype, node_composit_init_color_matte);
node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage);

22
source/blender/nodes/intern/CMP_nodes/CMP_colorSpill.c → source/blender/nodes/composite/nodes/node_composite_colorSpill.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_colorSpill.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,25 +27,25 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_colorSpill.c
/** \file blender/nodes/composite/nodes/node_composite_colorSpill.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
#define avg(a,b) ((a+b)/2)
/* ******************* Color Spill Supression ********************************* */
static bNodeSocketType cmp_node_color_spill_in[]={
{SOCK_RGBA,1,"Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_VALUE, 1, "Fac", 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_color_spill_in[]={
{SOCK_RGBA,1,"Image", 0.8f, 0.8f, 0.8f, 1.0f},
{SOCK_FLOAT, 1, "Fac", 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_FACTOR},
{-1,0,""}
};
static bNodeSocketType cmp_node_color_spill_out[]={
{SOCK_RGBA,0,"Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_color_spill_out[]={
{SOCK_RGBA,0,"Image"},
{-1,0,""}
};
@ -315,7 +315,7 @@ static void node_composit_exec_color_spill(void *UNUSED(data), bNode *node, bNod
free_compbuf(spillmap);
}
static void node_composit_init_color_spill(bNode *node)
static void node_composit_init_color_spill(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeColorspill *ncs= MEM_callocN(sizeof(NodeColorspill), "node colorspill");
node->storage=ncs;
@ -330,8 +330,8 @@ void register_node_type_cmp_color_spill(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_COLOR_SPILL, "Color Spill", NODE_CLASS_MATTE, NODE_OPTIONS,
cmp_node_color_spill_in, cmp_node_color_spill_out);
node_type_base(&ntype, CMP_NODE_COLOR_SPILL, "Color Spill", NODE_CLASS_MATTE, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_color_spill_in, cmp_node_color_spill_out);
node_type_size(&ntype, 140, 80, 200);
node_type_init(&ntype, node_composit_init_color_spill);
node_type_storage(&ntype, "NodeColorspill", node_free_standard_storage, node_copy_standard_storage);

20
source/blender/nodes/intern/CMP_nodes/CMP_colorbalance.c → source/blender/nodes/composite/nodes/node_composite_colorbalance.c
View File

@ -27,24 +27,24 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_colorbalance.c
/** \file blender/nodes/composite/nodes/node_composite_colorbalance.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* ******************* Color Balance ********************************* */
static bNodeSocketType cmp_node_colorbalance_in[]={
{SOCK_VALUE, 1, "Fac", 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{SOCK_RGBA,1,"Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_colorbalance_in[]={
{SOCK_FLOAT, 1, "Fac", 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_FACTOR},
{SOCK_RGBA,1,"Image", 0.8f, 0.8f, 0.8f, 1.0f},
{-1,0,""}
};
static bNodeSocketType cmp_node_colorbalance_out[]={
{SOCK_RGBA,0,"Image", 0.0f, 0.0f, 1.0f, 1.0f, -1.0f, 1.0f},
static bNodeSocketTemplate cmp_node_colorbalance_out[]={
{SOCK_RGBA,0,"Image"},
{-1,0,""}
};
@ -175,7 +175,7 @@ static void node_composit_exec_colorbalance(void *UNUSED(data), bNode *node, bNo
}
}
static void node_composit_init_colorbalance(bNode *node)
static void node_composit_init_colorbalance(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeColorBalance *n= node->storage= MEM_callocN(sizeof(NodeColorBalance), "node colorbalance");
@ -188,8 +188,8 @@ void register_node_type_cmp_colorbalance(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_COLORBALANCE, "Color Balance", NODE_CLASS_OP_COLOR, NODE_OPTIONS,
cmp_node_colorbalance_in, cmp_node_colorbalance_out);
node_type_base(&ntype, CMP_NODE_COLORBALANCE, "Color Balance", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_colorbalance_in, cmp_node_colorbalance_out);
node_type_size(&ntype, 400, 200, 400);
node_type_init(&ntype, node_composit_init_colorbalance);
node_type_storage(&ntype, "NodeColorBalance", node_free_standard_storage, node_copy_standard_storage);

373
source/blender/nodes/composite/nodes/node_composite_common.c Normal file
View File

@ -0,0 +1,373 @@
/*
* $Id: CMP_blur.c 35562 2011-03-15 20:10:32Z lukastoenne $
*
* ***** 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): Campbell Barton, Alfredo de Greef, David Millan Escriva,
* Juho Vepsäläinen
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/composite/nodes/node_composite_common.c
* \ingroup cmpnodes
*/
#include "DNA_node_types.h"
#include "BKE_node.h"
#include "node_composite_util.h"
#include "node_common.h"
#include "node_exec.h"
#if 0
static void PRINT_BUFFERS(bNodeTreeExec *exec)
{
bNodeTree *ntree= exec->nodetree;
bNode *node;
bNodeSocket *sock;
bNodeStack *ns;
int i;
printf("-------------- DEBUG --------------\n");
for (sock=ntree->inputs.first, i=0; sock; sock=sock->next, ++i) {
ns = node_get_socket_stack(exec->stack, sock);
printf("%d. Tree Input %s", i, sock->name);
if (ns->external)
printf(" (external)");
printf(": data=%p\n", ns->data);
}
for (sock=ntree->outputs.first, i=0; sock; sock=sock->next, ++i) {
ns = node_get_socket_stack(exec->stack, sock);
printf("%d. Tree Output %s", i, sock->name);
if (ns->external)
printf(" (external)");
printf(": data=%p\n", ns->data);
}
for (node=ntree->nodes.first; node; node=node->next) {
printf("Node %s:\n", node->name);
for (sock=node->inputs.first, i=0; sock; sock=sock->next, ++i) {
ns = node_get_socket_stack(exec->stack, sock);
printf("\t%d. Input %s", i, sock->name);
if (ns->external)
printf(" (external)");
printf(": data=%p\n", ns->data);
}
for (sock=node->outputs.first, i=0; sock; sock=sock->next, ++i) {
ns = node_get_socket_stack(exec->stack, sock);
printf("\t%d. Output %s", i, sock->name);
if (ns->external)
printf(" (external)");
printf(": data=%p\n", ns->data);
}
}
}
#endif
static void copy_stack(bNodeStack *to, bNodeStack *from)
{
if (to != from) {
copy_v4_v4(to->vec, from->vec);
to->data = from->data;
to->datatype = from->datatype;
/* tag as copy to prevent freeing */
to->is_copy = 1;
}
}
static void move_stack(bNodeStack *to, bNodeStack *from)
{
if (to != from) {
copy_v4_v4(to->vec, from->vec);
to->data = from->data;
to->datatype = from->datatype;
to->is_copy = from->is_copy;
zero_v4(from->vec);
from->data = NULL;
from->datatype = 0;
from->is_copy = 0;
}
}
/**** GROUP ****/
static void *group_initexec(bNode *node)
{
bNodeTree *ngroup= (bNodeTree*)node->id;
bNodeTreeExec *exec;
bNodeSocket *sock;
bNodeStack *ns;
/* initialize the internal node tree execution */
exec = ntreeCompositBeginExecTree(ngroup);
/* tag group outputs as external to prevent freeing */
for (sock=ngroup->outputs.first; sock; sock=sock->next) {
if (!(sock->flag & SOCK_INTERNAL)) {
ns = node_get_socket_stack(exec->stack, sock);
ns->external = 1;
}
}
return exec;
}
static void group_freeexec(bNode *UNUSED(node), void *nodedata)
{
bNodeTreeExec *gexec= (bNodeTreeExec*)nodedata;
ntreeCompositEndExecTree(gexec);
}
/* Copy inputs to the internal stack.
* This is a shallow copy, no buffers are duplicated here!
*/
static void group_copy_inputs(bNode *node, bNodeStack **in, bNodeStack *gstack)
{
bNodeSocket *sock;
bNodeStack *ns;
int a;
for (sock=node->inputs.first, a=0; sock; sock=sock->next, ++a) {
if (sock->groupsock) {
ns = node_get_socket_stack(gstack, sock->groupsock);
copy_stack(ns, in[a]);
}
}
}
/* Copy internal results to the external outputs.
*/
static void group_move_outputs(bNode *node, bNodeStack **out, bNodeStack *gstack)
{
bNodeSocket *sock;
bNodeStack *ns;
int a;
for (sock=node->outputs.first, a=0; sock; sock=sock->next, ++a) {
if (sock->groupsock) {
ns = node_get_socket_stack(gstack, sock->groupsock);
move_stack(out[a], ns);
}
}
}
/* Free internal buffers */
static void group_free_internal(bNodeTreeExec *gexec) {
bNodeStack *ns;
int i;
for (i=0, ns=gexec->stack; i < gexec->stacksize; ++i, ++ns) {
if (!ns->external && !ns->is_copy) {
if (ns->data) {
free_compbuf(ns->data);
ns->data = NULL;
}
}
}
}
static void group_execute(void *data, int thread, struct bNode *node, void *nodedata, struct bNodeStack **in, struct bNodeStack **out)
{
bNodeTreeExec *exec= (bNodeTreeExec*)nodedata;
/* XXX same behavior as trunk: all nodes inside group are executed.
* it's stupid, but just makes it work. compo redesign will do this better.
*/
{
bNode *inode;
for (inode=exec->nodetree->nodes.first; inode; inode=inode->next)
inode->need_exec = 1;
}
group_copy_inputs(node, in, exec->stack);
ntreeExecNodes(exec, data, thread);
group_free_internal(exec);
group_move_outputs(node, out, exec->stack);
}
void register_node_type_cmp_group(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, NODE_GROUP, "Group", NODE_CLASS_GROUP, NODE_OPTIONS|NODE_CONST_OUTPUT);
node_type_socket_templates(&ntype, NULL, NULL);
node_type_size(&ntype, 120, 60, 200);
node_type_label(&ntype, node_group_label);
node_type_init(&ntype, node_group_init);
node_type_valid(&ntype, node_group_valid);
node_type_template(&ntype, node_group_template);
node_type_update(&ntype, NULL, node_group_verify);
node_type_group_edit(&ntype, node_group_edit_get, node_group_edit_set, node_group_edit_clear);
node_type_exec_new(&ntype, group_initexec, group_freeexec, group_execute);
nodeRegisterType(lb, &ntype);
}
/**** FOR LOOP ****/
#if 0 /* XXX loop nodes don't work nicely with current trees */
/* Move the results from the previous iteration back to the input sockets. */
static void loop_iteration_reset(bNodeTree *ngroup, bNodeStack *gstack)
{
bNodeSocket *gin, *gout;
bNodeStack *nsin, *nsout;
gin = ngroup->inputs.first;
gout = ngroup->outputs.first;
while (gin && gout) {
/* skip static (non-looping) sockets */
while (gin && !(gin->flag & SOCK_DYNAMIC))
gin=gin->next;
while (gout && !(gout->flag & SOCK_DYNAMIC))
gout=gout->next;
if (gin && gout) {
nsin = node_get_socket_stack(gstack, gin);
nsout = node_get_socket_stack(gstack, gout);
move_stack(nsin, nsout);
gin=gin->next;
gout=gout->next;
}
}
}
static void forloop_execute(void *data, int thread, struct bNode *node, void *nodedata, struct bNodeStack **in, struct bNodeStack **out)
{
bNodeTreeExec *exec= (bNodeTreeExec*)nodedata;
int totiterations= (int)in[0]->vec[0];
bNodeSocket *sock;
bNodeStack *ns;
int iteration;
/* XXX same behavior as trunk: all nodes inside group are executed.
* it's stupid, but just makes it work. compo redesign will do this better.
*/
{
bNode *inode;
for (inode=exec->nodetree->nodes.first; inode; inode=inode->next)
inode->need_exec = 1;
}
/* "Iteration" socket */
sock = exec->nodetree->inputs.first;
ns = node_get_socket_stack(exec->stack, sock);
group_copy_inputs(node, in, exec->stack);
for (iteration=0; iteration < totiterations; ++iteration) {
/* first input contains current iteration counter */
ns->vec[0] = (float)iteration;
if (iteration > 0)
loop_iteration_reset(exec->nodetree, exec->stack);
ntreeExecNodes(exec, data, thread);
group_free_internal(exec);
}
group_move_outputs(node, out, exec->stack);
}
void register_node_type_cmp_forloop(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, NODE_FORLOOP, "For", NODE_CLASS_GROUP, NODE_OPTIONS);
node_type_socket_templates(&ntype, NULL, NULL);
node_type_size(&ntype, 120, 60, 200);
node_type_label(&ntype, node_group_label);
node_type_init(&ntype, node_forloop_init);
node_type_valid(&ntype, node_group_valid);
node_type_template(&ntype, node_forloop_template);
node_type_update(&ntype, NULL, node_group_verify);
node_type_tree(&ntype, node_forloop_init_tree, node_loop_update_tree);
node_type_group_edit(&ntype, node_group_edit_get, node_group_edit_set, node_group_edit_clear);
node_type_exec_new(&ntype, group_initexec, group_freeexec, forloop_execute);
nodeRegisterType(lb, &ntype);
}
#endif
/**** WHILE LOOP ****/
#if 0 /* XXX loop nodes don't work nicely with current trees */
static void whileloop_execute(void *data, int thread, struct bNode *node, void *nodedata, struct bNodeStack **in, struct bNodeStack **out)
{
bNodeTreeExec *exec= (bNodeTreeExec*)nodedata;
int condition= (in[0]->vec[0] > 0.0f);
bNodeSocket *sock;
bNodeStack *ns;
int iteration;
/* XXX same behavior as trunk: all nodes inside group are executed.
* it's stupid, but just makes it work. compo redesign will do this better.
*/
{
bNode *inode;
for (inode=exec->nodetree->nodes.first; inode; inode=inode->next)
inode->need_exec = 1;
}
/* "Condition" socket */
sock = exec->nodetree->outputs.first;
ns = node_get_socket_stack(exec->stack, sock);
iteration = 0;
group_copy_inputs(node, in, exec->stack);
while (condition && iteration < node->custom1) {
if (iteration > 0)
loop_iteration_reset(exec->nodetree, exec->stack);
ntreeExecNodes(exec, data, thread);
group_free_internal(exec);
// PRINT_BUFFERS(exec);
condition = (ns->vec[0] > 0.0f);
++iteration;
}
group_move_outputs(node, out, exec->stack);
}
void register_node_type_cmp_whileloop(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, NODE_WHILELOOP, "While", NODE_CLASS_GROUP, NODE_OPTIONS);
node_type_socket_templates(&ntype, NULL, NULL);
node_type_size(&ntype, 120, 60, 200);
node_type_label(&ntype, node_group_label);
node_type_init(&ntype, node_whileloop_init);
node_type_valid(&ntype, node_group_valid);
node_type_template(&ntype, node_whileloop_template);
node_type_update(&ntype, NULL, node_group_verify);
node_type_tree(&ntype, node_whileloop_init_tree, node_loop_update_tree);
node_type_group_edit(&ntype, node_group_edit_get, node_group_edit_set, node_group_edit_clear);
node_type_exec_new(&ntype, group_initexec, group_freeexec, whileloop_execute);
nodeRegisterType(lb, &ntype);
}
#endif

18
source/blender/nodes/intern/CMP_nodes/CMP_composite.c → source/blender/nodes/composite/nodes/node_composite_composite.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_composite.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,20 +27,20 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_composite.c
/** \file blender/nodes/composite/nodes/node_composite_composite.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** COMPOSITE ******************** */
static bNodeSocketType cmp_node_composite_in[]= {
{ SOCK_RGBA, 1, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "Alpha", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "Z", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_composite_in[]= {
{ SOCK_RGBA, 1, "Image", 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_FLOAT, 1, "Alpha", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
{ SOCK_FLOAT, 1, "Z", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
{ -1, 0, "" }
};
@ -103,8 +103,8 @@ void register_node_type_cmp_composite(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_COMPOSITE, "Composite", NODE_CLASS_OUTPUT, NODE_PREVIEW,
cmp_node_composite_in, NULL);
node_type_base(&ntype, CMP_NODE_COMPOSITE, "Composite", NODE_CLASS_OUTPUT, NODE_PREVIEW);
node_type_socket_templates(&ntype, cmp_node_composite_in, NULL);
node_type_size(&ntype, 80, 60, 200);
node_type_exec(&ntype, node_composit_exec_composite);

18
source/blender/nodes/intern/CMP_nodes/CMP_crop.c → source/blender/nodes/composite/nodes/node_composite_crop.c
View File

@ -27,21 +27,21 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_crop.c
/** \file blender/nodes/composite/nodes/node_composite_crop.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** Crop ******************** */
static bNodeSocketType cmp_node_crop_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_crop_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_crop_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_crop_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -103,7 +103,7 @@ static void node_composit_exec_crop(void *UNUSED(data), bNode *node, bNodeStack
}
}
static void node_composit_init_crop(bNode* node)
static void node_composit_init_crop(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeTwoXYs *nxy= MEM_callocN(sizeof(NodeTwoXYs), "node xy data");
node->storage= nxy;
@ -117,8 +117,8 @@ void register_node_type_cmp_crop(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_CROP, "Crop", NODE_CLASS_DISTORT, NODE_OPTIONS,
cmp_node_crop_in, cmp_node_crop_out);
node_type_base(&ntype, CMP_NODE_CROP, "Crop", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_crop_in, cmp_node_crop_out);
node_type_size(&ntype, 140, 100, 320);
node_type_init(&ntype, node_composit_init_crop);
node_type_storage(&ntype, "NodeTwoXYs", node_free_standard_storage, node_copy_standard_storage);

50
source/blender/nodes/intern/CMP_nodes/CMP_curves.c → source/blender/nodes/composite/nodes/node_composite_curves.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_curves.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,19 +27,19 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_curves.c
/** \file blender/nodes/composite/nodes/node_composite_curves.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** CURVE Time ******************** */
/* custom1 = sfra, custom2 = efra */
static bNodeSocketType cmp_node_time_out[]= {
{ SOCK_VALUE, 0, "Fac", 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_time_out[]= {
{ SOCK_FLOAT, 0, "Fac"},
{ -1, 0, "" }
};
@ -57,7 +57,7 @@ static void node_composit_exec_curves_time(void *data, bNode *node, bNodeStack *
}
static void node_composit_init_curves_time(bNode* node)
static void node_composit_init_curves_time(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
node->custom1= 1;
node->custom2= 250;
@ -68,8 +68,8 @@ void register_node_type_cmp_curve_time(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_TIME, "Time", NODE_CLASS_INPUT, NODE_OPTIONS,
NULL, cmp_node_time_out);
node_type_base(&ntype, CMP_NODE_TIME, "Time", NODE_CLASS_INPUT, NODE_OPTIONS);
node_type_socket_templates(&ntype, NULL, cmp_node_time_out);
node_type_size(&ntype, 140, 100, 320);
node_type_init(&ntype, node_composit_init_curves_time);
node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves);
@ -82,13 +82,13 @@ void register_node_type_cmp_curve_time(ListBase *lb)
/* **************** CURVE VEC ******************** */
static bNodeSocketType cmp_node_curve_vec_in[]= {
{ SOCK_VECTOR, 1, "Vector", 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f},
static bNodeSocketTemplate cmp_node_curve_vec_in[]= {
{ SOCK_VECTOR, 1, "Vector", 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_NONE},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_curve_vec_out[]= {
{ SOCK_VECTOR, 0, "Vector", 0.0f, 0.0f, 1.0f, 1.0f, -1.0f, 1.0f},
static bNodeSocketTemplate cmp_node_curve_vec_out[]= {
{ SOCK_VECTOR, 0, "Vector"},
{ -1, 0, "" }
};
@ -100,7 +100,7 @@ static void node_composit_exec_curve_vec(void *UNUSED(data), bNode *node, bNodeS
curvemapping_evaluate_premulRGBF(node->storage, out[0]->vec, in[0]->vec);
}
static void node_composit_init_curve_vec(bNode* node)
static void node_composit_init_curve_vec(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
node->storage= curvemapping_add(3, -1.0f, -1.0f, 1.0f, 1.0f);
}
@ -109,8 +109,8 @@ void register_node_type_cmp_curve_vec(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_CURVE_VEC, "Vector Curves", NODE_CLASS_OP_VECTOR, NODE_OPTIONS,
cmp_node_curve_vec_in, cmp_node_curve_vec_out);
node_type_base(&ntype, CMP_NODE_CURVE_VEC, "Vector Curves", NODE_CLASS_OP_VECTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_curve_vec_in, cmp_node_curve_vec_out);
node_type_size(&ntype, 200, 140, 320);
node_type_init(&ntype, node_composit_init_curve_vec);
node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves);
@ -121,16 +121,16 @@ void register_node_type_cmp_curve_vec(ListBase *lb)
/* **************** CURVE RGB ******************** */
static bNodeSocketType cmp_node_curve_rgb_in[]= {
{ SOCK_VALUE, 1, "Fac", 1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f},
{ SOCK_RGBA, 1, "Image", 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f},
{ SOCK_RGBA, 1, "Black Level", 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f},
{ SOCK_RGBA, 1, "White Level", 1.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f},
static bNodeSocketTemplate cmp_node_curve_rgb_in[]= {
{ SOCK_FLOAT, 1, "Fac", 1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_FACTOR},
{ SOCK_RGBA, 1, "Image", 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_RGBA, 1, "Black Level", 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_RGBA, 1, "White Level", 1.0f, 1.0f, 1.0f, 1.0f},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_curve_rgb_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 1.0f, 1.0f, -1.0f, 1.0f},
static bNodeSocketTemplate cmp_node_curve_rgb_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -187,7 +187,7 @@ static void node_composit_exec_curve_rgb(void *UNUSED(data), bNode *node, bNodeS
}
static void node_composit_init_curve_rgb(bNode* node)
static void node_composit_init_curve_rgb(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
node->storage= curvemapping_add(4, 0.0f, 0.0f, 1.0f, 1.0f);
}
@ -196,8 +196,8 @@ void register_node_type_cmp_curve_rgb(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, NODE_OPTIONS,
cmp_node_curve_rgb_in, cmp_node_curve_rgb_out);
node_type_base(&ntype, CMP_NODE_CURVE_RGB, "RGB Curves", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_curve_rgb_in, cmp_node_curve_rgb_out);
node_type_size(&ntype, 200, 140, 320);
node_type_init(&ntype, node_composit_init_curve_rgb);
node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves);

22
source/blender/nodes/intern/CMP_nodes/CMP_defocus.c → source/blender/nodes/composite/nodes/node_composite_defocus.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_defocus.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,21 +27,21 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_defocus.c
/** \file blender/nodes/composite/nodes/node_composite_defocus.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* ************ qdn: Defocus node ****************** */
static bNodeSocketType cmp_node_defocus_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "Z", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_defocus_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ SOCK_FLOAT, 1, "Z", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f, PROP_FACTOR},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_defocus_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_defocus_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -857,7 +857,7 @@ static void node_composit_exec_defocus(void *UNUSED(data), bNode *node, bNodeSta
if (zbuf_use && (zbuf_use != zbuf)) free_compbuf(zbuf_use);
}
static void node_composit_init_defocus(bNode* node)
static void node_composit_init_defocus(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
/* qdn: defocus node */
NodeDefocus *nbd = MEM_callocN(sizeof(NodeDefocus), "node defocus data");
@ -878,8 +878,8 @@ void register_node_type_cmp_defocus(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_DEFOCUS, "Defocus", NODE_CLASS_OP_FILTER, NODE_OPTIONS,
cmp_node_defocus_in, cmp_node_defocus_out);
node_type_base(&ntype, CMP_NODE_DEFOCUS, "Defocus", NODE_CLASS_OP_FILTER, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_defocus_in, cmp_node_defocus_out);
node_type_size(&ntype, 150, 120, 200);
node_type_init(&ntype, node_composit_init_defocus);
node_type_storage(&ntype, "NodeDefocus", node_free_standard_storage, node_copy_standard_storage);

24
source/blender/nodes/intern/CMP_nodes/CMP_diffMatte.c → source/blender/nodes/composite/nodes/node_composite_diffMatte.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_diffMatte.c 36536 2011-05-07 13:27:27Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,23 +27,23 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_diffMatte.c
/** \file blender/nodes/composite/nodes/node_composite_diffMatte.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* ******************* channel Difference Matte ********************************* */
static bNodeSocketType cmp_node_diff_matte_in[]={
{SOCK_RGBA,1,"Image 1", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_RGBA,1,"Image 2", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_diff_matte_in[]={
{SOCK_RGBA,1,"Image 1", 0.8f, 0.8f, 0.8f, 1.0f},
{SOCK_RGBA,1,"Image 2", 0.8f, 0.8f, 0.8f, 1.0f},
{-1,0,""}
};
static bNodeSocketType cmp_node_diff_matte_out[]={
{SOCK_RGBA,0,"Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_VALUE,0,"Matte",0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_diff_matte_out[]={
{SOCK_RGBA,0,"Image"},
{SOCK_FLOAT,0,"Matte"},
{-1,0,""}
};
@ -125,7 +125,7 @@ static void node_composit_exec_diff_matte(void *data, bNode *node, bNodeStack **
free_compbuf(imbuf2);
}
static void node_composit_init_diff_matte(bNode *node)
static void node_composit_init_diff_matte(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeChroma *c= MEM_callocN(sizeof(NodeChroma), "node chroma");
node->storage= c;
@ -137,8 +137,8 @@ void register_node_type_cmp_diff_matte(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_DIFF_MATTE, "Difference Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS,
cmp_node_diff_matte_in, cmp_node_diff_matte_out);
node_type_base(&ntype, CMP_NODE_DIFF_MATTE, "Difference Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_diff_matte_in, cmp_node_diff_matte_out);
node_type_size(&ntype, 200, 80, 250);
node_type_init(&ntype, node_composit_init_diff_matte);
node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage);

18
source/blender/nodes/intern/CMP_nodes/CMP_dilate.c → source/blender/nodes/composite/nodes/node_composite_dilate.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_dilate.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,22 +27,22 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_dilate.c
/** \file blender/nodes/composite/nodes/node_composite_dilate.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** Dilate/Erode ******************** */
static bNodeSocketType cmp_node_dilateerode_in[]= {
{ SOCK_VALUE, 1, "Mask", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_dilateerode_in[]= {
{ SOCK_FLOAT, 1, "Mask", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_FACTOR},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_dilateerode_out[]= {
{ SOCK_VALUE, 0, "Mask", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_dilateerode_out[]= {
{ SOCK_FLOAT, 0, "Mask"},
{ -1, 0, "" }
};
@ -152,8 +152,8 @@ void register_node_type_cmp_dilateerode(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_DILATEERODE, "Dilate/Erode", NODE_CLASS_OP_FILTER, NODE_OPTIONS,
cmp_node_dilateerode_in, cmp_node_dilateerode_out);
node_type_base(&ntype, CMP_NODE_DILATEERODE, "Dilate/Erode", NODE_CLASS_OP_FILTER, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_dilateerode_in, cmp_node_dilateerode_out);
node_type_size(&ntype, 130, 100, 320);
node_type_exec(&ntype, node_composit_exec_dilateerode);

18
source/blender/nodes/intern/CMP_nodes/CMP_directionalblur.c → source/blender/nodes/composite/nodes/node_composite_directionalblur.c
View File

@ -26,20 +26,20 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_directionalblur.c
/** \file blender/nodes/composite/nodes/node_composite_directionalblur.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
static bNodeSocketType cmp_node_dblur_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.f, 0.f, 1.f},
static bNodeSocketTemplate cmp_node_dblur_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.f},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_dblur_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_dblur_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -122,7 +122,7 @@ static void node_composit_exec_dblur(void *UNUSED(data), bNode *node, bNodeStack
out[0]->data= dblur(node, new, ndbd->iter, ndbd->wrap, ndbd->center_x, ndbd->center_y, ndbd->distance, ndbd->angle, ndbd->spin, ndbd->zoom);
}
static void node_composit_init_dblur(bNode* node)
static void node_composit_init_dblur(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeDBlurData *ndbd= MEM_callocN(sizeof(NodeDBlurData), "node dblur data");
node->storage= ndbd;
@ -134,8 +134,8 @@ void register_node_type_cmp_dblur(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_DBLUR, "Directional Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS,
cmp_node_dblur_in, cmp_node_dblur_out);
node_type_base(&ntype, CMP_NODE_DBLUR, "Directional Blur", NODE_CLASS_OP_FILTER, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_dblur_in, cmp_node_dblur_out);
node_type_size(&ntype, 150, 120, 200);
node_type_init(&ntype, node_composit_init_dblur);
node_type_storage(&ntype, "NodeDBlurData", node_free_standard_storage, node_copy_standard_storage);

24
source/blender/nodes/intern/CMP_nodes/CMP_displace.c → source/blender/nodes/composite/nodes/node_composite_displace.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_displace.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,25 +27,25 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_displace.c
/** \file blender/nodes/composite/nodes/node_composite_displace.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** Displace ******************** */
static bNodeSocketType cmp_node_displace_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{ SOCK_VECTOR, 1, "Vector", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "X Scale", 0.0f, 0.0f, 0.0f, 0.0f, -1000.0f, 1000.0f},
{ SOCK_VALUE, 1, "Y Scale", 0.0f, 0.0f, 0.0f, 0.0f, -1000.0f, 1000.0f},
static bNodeSocketTemplate cmp_node_displace_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ SOCK_VECTOR, 1, "Vector", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_TRANSLATION},
{ SOCK_FLOAT, 1, "X Scale", 0.0f, 0.0f, 0.0f, 0.0f, -1000.0f, 1000.0f, PROP_FACTOR},
{ SOCK_FLOAT, 1, "Y Scale", 0.0f, 0.0f, 0.0f, 0.0f, -1000.0f, 1000.0f, PROP_FACTOR},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_displace_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_displace_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -188,8 +188,8 @@ void register_node_type_cmp_displace(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_DISPLACE, "Displace", NODE_CLASS_DISTORT, NODE_OPTIONS,
cmp_node_displace_in, cmp_node_displace_out);
node_type_base(&ntype, CMP_NODE_DISPLACE, "Displace", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_displace_in, cmp_node_displace_out);
node_type_size(&ntype, 140, 100, 320);
node_type_exec(&ntype, node_composit_exec_displace);

24
source/blender/nodes/intern/CMP_nodes/CMP_distanceMatte.c → source/blender/nodes/composite/nodes/node_composite_distanceMatte.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_distanceMatte.c 36536 2011-05-07 13:27:27Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,23 +27,23 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_distanceMatte.c
/** \file blender/nodes/composite/nodes/node_composite_distanceMatte.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* ******************* channel Distance Matte ********************************* */
static bNodeSocketType cmp_node_distance_matte_in[]={
{SOCK_RGBA,1,"Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_RGBA,1,"Key Color", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_distance_matte_in[]={
{SOCK_RGBA,1,"Image", 0.8f, 0.8f, 0.8f, 1.0f},
{SOCK_RGBA,1,"Key Color", 0.8f, 0.8f, 0.8f, 1.0f},
{-1,0,""}
};
static bNodeSocketType cmp_node_distance_matte_out[]={
{SOCK_RGBA,0,"Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_VALUE,0,"Matte",0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_distance_matte_out[]={
{SOCK_RGBA,0,"Image"},
{SOCK_FLOAT,0,"Matte"},
{-1,0,""}
};
@ -122,7 +122,7 @@ static void node_composit_exec_distance_matte(void *data, bNode *node, bNodeStac
free_compbuf(inbuf);
}
static void node_composit_init_distance_matte(bNode *node)
static void node_composit_init_distance_matte(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeChroma *c= MEM_callocN(sizeof(NodeChroma), "node chroma");
node->storage= c;
@ -134,8 +134,8 @@ void register_node_type_cmp_distance_matte(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_DIST_MATTE, "Distance Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS,
cmp_node_distance_matte_in, cmp_node_distance_matte_out);
node_type_base(&ntype, CMP_NODE_DIST_MATTE, "Distance Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_distance_matte_in, cmp_node_distance_matte_out);
node_type_size(&ntype, 200, 80, 250);
node_type_init(&ntype, node_composit_init_distance_matte);
node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage);

20
source/blender/nodes/intern/CMP_nodes/CMP_filter.c → source/blender/nodes/composite/nodes/node_composite_filter.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_filter.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,21 +27,21 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_filter.c
/** \file blender/nodes/composite/nodes/node_composite_filter.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** FILTER ******************** */
static bNodeSocketType cmp_node_filter_in[]= {
{ SOCK_VALUE, 1, "Fac", 1.0f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_filter_in[]= {
{ SOCK_FLOAT, 1, "Fac", 1.0f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f, PROP_FACTOR},
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_filter_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_filter_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -226,8 +226,8 @@ void register_node_type_cmp_filter(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_FILTER, "Filter", NODE_CLASS_OP_FILTER, NODE_PREVIEW|NODE_OPTIONS,
cmp_node_filter_in, cmp_node_filter_out);
node_type_base(&ntype, CMP_NODE_FILTER, "Filter", NODE_CLASS_OP_FILTER, NODE_PREVIEW|NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_filter_in, cmp_node_filter_out);
node_type_size(&ntype, 80, 40, 120);
node_type_label(&ntype, node_filter_label);
node_type_exec(&ntype, node_composit_exec_filter);

18
source/blender/nodes/intern/CMP_nodes/CMP_flip.c → source/blender/nodes/composite/nodes/node_composite_flip.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_flip.c 36333 2011-04-26 09:27:43Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,21 +27,21 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_flip.c
/** \file blender/nodes/composite/nodes/node_composite_flip.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** Flip ******************** */
static bNodeSocketType cmp_node_flip_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_flip_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_flip_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_flip_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -94,8 +94,8 @@ void register_node_type_cmp_flip(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_FLIP, "Flip", NODE_CLASS_DISTORT, NODE_OPTIONS,
cmp_node_flip_in, cmp_node_flip_out);
node_type_base(&ntype, CMP_NODE_FLIP, "Flip", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_flip_in, cmp_node_flip_out);
node_type_size(&ntype, 140, 100, 320);
node_type_exec(&ntype, node_composit_exec_flip);

20
source/blender/nodes/intern/CMP_nodes/CMP_gamma.c → source/blender/nodes/composite/nodes/node_composite_gamma.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_gamma.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -28,22 +28,22 @@
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_gamma.c
/** \file blender/nodes/composite/nodes/node_composite_gamma.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** Gamma Tools ******************** */
static bNodeSocketType cmp_node_gamma_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "Gamma", 1.0f, 0.0f, 0.0f, 0.0f, 0.001f, 10.0f},
static bNodeSocketTemplate cmp_node_gamma_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ SOCK_FLOAT, 1, "Gamma", 1.0f, 0.0f, 0.0f, 0.0f, 0.001f, 10.0f, PROP_UNSIGNED},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_gamma_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_gamma_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -81,8 +81,8 @@ void register_node_type_cmp_gamma(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_GAMMA, "Gamma", NODE_CLASS_OP_COLOR, NODE_OPTIONS,
cmp_node_gamma_in, cmp_node_gamma_out);
node_type_base(&ntype, CMP_NODE_GAMMA, "Gamma", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_gamma_in, cmp_node_gamma_out);
node_type_size(&ntype, 140, 100, 320);
node_type_exec(&ntype, node_composit_exec_gamma);

18
source/blender/nodes/intern/CMP_nodes/CMP_glare.c → source/blender/nodes/composite/nodes/node_composite_glare.c
View File

@ -26,19 +26,19 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_glare.c
/** \file blender/nodes/composite/nodes/node_composite_glare.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
static bNodeSocketType cmp_node_glare_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_glare_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_glare_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_glare_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -474,7 +474,7 @@ static void node_composit_exec_glare(void *UNUSED(data), bNode *node, bNodeStack
out[0]->data = new;
}
static void node_composit_init_glare(bNode* node)
static void node_composit_init_glare(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeGlare *ndg = MEM_callocN(sizeof(NodeGlare), "node glare data");
ndg->quality = 1;
@ -494,8 +494,8 @@ void register_node_type_cmp_glare(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_GLARE, "Glare", NODE_CLASS_OP_FILTER, NODE_OPTIONS,
cmp_node_glare_in, cmp_node_glare_out);
node_type_base(&ntype, CMP_NODE_GLARE, "Glare", NODE_CLASS_OP_FILTER, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_glare_in, cmp_node_glare_out);
node_type_size(&ntype, 150, 120, 200);
node_type_init(&ntype, node_composit_init_glare);
node_type_storage(&ntype, "NodeGlare", node_free_standard_storage, node_copy_standard_storage);

22
source/blender/nodes/intern/CMP_nodes/CMP_hueSatVal.c → source/blender/nodes/composite/nodes/node_composite_hueSatVal.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_hueSatVal.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,22 +27,22 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_hueSatVal.c
/** \file blender/nodes/composite/nodes/node_composite_hueSatVal.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** Hue Saturation ******************** */
static bNodeSocketType cmp_node_hue_sat_in[]= {
{ SOCK_VALUE, 1, "Fac", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_hue_sat_in[]= {
{ SOCK_FLOAT, 1, "Fac", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_hue_sat_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_hue_sat_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -95,7 +95,7 @@ static void node_composit_exec_hue_sat(void *UNUSED(data), bNode *node, bNodeSta
}
}
static void node_composit_init_hue_sat(bNode* node)
static void node_composit_init_hue_sat(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeHueSat *nhs= MEM_callocN(sizeof(NodeHueSat), "node hue sat");
node->storage= nhs;
@ -108,8 +108,8 @@ void register_node_type_cmp_hue_sat(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS,
cmp_node_hue_sat_in, cmp_node_hue_sat_out);
node_type_base(&ntype, CMP_NODE_HUE_SAT, "Hue Saturation Value", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_hue_sat_in, cmp_node_hue_sat_out);
node_type_size(&ntype, 150, 80, 250);
node_type_init(&ntype, node_composit_init_hue_sat);
node_type_storage(&ntype, "NodeHueSat", node_free_standard_storage, node_copy_standard_storage);

22
source/blender/nodes/intern/CMP_nodes/CMP_huecorrect.c → source/blender/nodes/composite/nodes/node_composite_huecorrect.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_huecorrect.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,21 +27,21 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_huecorrect.c
/** \file blender/nodes/composite/nodes/node_composite_huecorrect.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
static bNodeSocketType cmp_node_huecorrect_in[]= {
{ SOCK_VALUE, 1, "Fac", 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_RGBA, 1, "Image", 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f},
static bNodeSocketTemplate cmp_node_huecorrect_in[]= {
{ SOCK_FLOAT, 1, "Fac", 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_FACTOR},
{ SOCK_RGBA, 1, "Image", 0.0f, 0.0f, 0.0f, 1.0f},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_huecorrect_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 1.0f, 1.0f, -1.0f, 1.0f},
static bNodeSocketTemplate cmp_node_huecorrect_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -137,7 +137,7 @@ static void node_composit_exec_huecorrect(void *UNUSED(data), bNode *node, bNode
}
static void node_composit_init_huecorrect(bNode* node)
static void node_composit_init_huecorrect(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
CurveMapping *cumapping = node->storage= curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
int c;
@ -157,8 +157,8 @@ void register_node_type_cmp_huecorrect(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_HUECORRECT, "Hue Correct", NODE_CLASS_OP_COLOR, NODE_OPTIONS,
cmp_node_huecorrect_in, cmp_node_huecorrect_out);
node_type_base(&ntype, CMP_NODE_HUECORRECT, "Hue Correct", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_huecorrect_in, cmp_node_huecorrect_out);
node_type_size(&ntype, 320, 140, 400);
node_type_init(&ntype, node_composit_init_huecorrect);
node_type_storage(&ntype, "CurveMapping", node_free_curves, node_copy_curves);

18
source/blender/nodes/intern/CMP_nodes/CMP_idMask.c → source/blender/nodes/composite/nodes/node_composite_idMask.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_idMask.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,22 +27,22 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_idMask.c
/** \file blender/nodes/composite/nodes/node_composite_idMask.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** ID Mask ******************** */
static bNodeSocketType cmp_node_idmask_in[]= {
{ SOCK_VALUE, 1, "ID value", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_idmask_in[]= {
{ SOCK_FLOAT, 1, "ID value", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_idmask_out[]= {
{ SOCK_VALUE, 0, "Alpha", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_idmask_out[]= {
{ SOCK_FLOAT, 0, "Alpha"},
{ -1, 0, "" }
};
@ -113,8 +113,8 @@ void register_node_type_cmp_idmask(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_ID_MASK, "ID Mask", NODE_CLASS_CONVERTOR, NODE_OPTIONS,
cmp_node_idmask_in, cmp_node_idmask_out);
node_type_base(&ntype, CMP_NODE_ID_MASK, "ID Mask", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_idmask_in, cmp_node_idmask_out);
node_type_size(&ntype, 140, 100, 320);
node_type_exec(&ntype, node_composit_exec_idmask);

28
source/blender/nodes/intern/CMP_nodes/CMP_image.c → source/blender/nodes/composite/nodes/node_composite_image.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_image.c 36536 2011-05-07 13:27:27Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,20 +27,20 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_image.c
/** \file blender/nodes/composite/nodes/node_composite_image.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** IMAGE (and RenderResult, multilayer image) ******************** */
static bNodeSocketType cmp_node_rlayers_out[]= {
static bNodeSocketTemplate cmp_node_rlayers_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 0, "Alpha", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 0, "Z", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_FLOAT, 0, "Alpha", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_FLOAT, 0, "Z", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_VECTOR, 0, "Normal", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_VECTOR, 0, "UV", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_VECTOR, 0, "Speed", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
@ -52,9 +52,9 @@ static bNodeSocketType cmp_node_rlayers_out[]= {
{ SOCK_RGBA, 0, "Reflect", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_RGBA, 0, "Refract", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_RGBA, 0, "Indirect", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 0, "IndexOB", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 0, "IndexMA", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 0, "Mist", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_FLOAT, 0, "IndexOB", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_FLOAT, 0, "IndexMA", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_FLOAT, 0, "Mist", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_RGBA, 0, "Emit", 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_RGBA, 0, "Environment",0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ -1, 0, "" }
@ -295,7 +295,7 @@ static void node_composit_exec_image(void *data, bNode *node, bNodeStack **UNUSE
}
}
static void node_composit_init_image(bNode* node)
static void node_composit_init_image(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
ImageUser *iuser= MEM_callocN(sizeof(ImageUser), "node image user");
node->storage= iuser;
@ -309,8 +309,8 @@ void register_node_type_cmp_image(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_IMAGE, "Image", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS,
NULL, cmp_node_rlayers_out);
node_type_base(&ntype, CMP_NODE_IMAGE, "Image", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS);
node_type_socket_templates(&ntype, NULL, cmp_node_rlayers_out);
node_type_size(&ntype, 120, 80, 300);
node_type_init(&ntype, node_composit_init_image);
node_type_storage(&ntype, "ImageUser", node_free_standard_storage, node_copy_standard_storage);
@ -440,8 +440,8 @@ void register_node_type_cmp_rlayers(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_R_LAYERS, "Render Layers", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS,
NULL, cmp_node_rlayers_out);
node_type_base(&ntype, CMP_NODE_R_LAYERS, "Render Layers", NODE_CLASS_INPUT, NODE_PREVIEW|NODE_OPTIONS);
node_type_socket_templates(&ntype, NULL, cmp_node_rlayers_out);
node_type_size(&ntype, 150, 100, 300);
node_type_exec(&ntype, node_composit_exec_rlayers);

22
source/blender/nodes/intern/CMP_nodes/CMP_invert.c → source/blender/nodes/composite/nodes/node_composite_invert.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_invert.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,21 +27,21 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_invert.c
/** \file blender/nodes/composite/nodes/node_composite_invert.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** INVERT ******************** */
static bNodeSocketType cmp_node_invert_in[]= {
{ SOCK_VALUE, 1, "Fac", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_RGBA, 1, "Color", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_invert_in[]= {
{ SOCK_FLOAT, 1, "Fac", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_FACTOR},
{ SOCK_RGBA, 1, "Color", 0.0f, 0.0f, 0.0f, 1.0f},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_invert_out[]= {
{ SOCK_RGBA, 0, "Color", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_invert_out[]= {
{ SOCK_RGBA, 0, "Color"},
{ -1, 0, "" }
};
@ -114,7 +114,7 @@ static void node_composit_exec_invert(void *UNUSED(data), bNode *node, bNodeStac
}
}
static void node_composit_init_invert(bNode *node)
static void node_composit_init_invert(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
node->custom1 |= CMP_CHAN_RGB;
}
@ -124,8 +124,8 @@ void register_node_type_cmp_invert(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS,
cmp_node_invert_in, cmp_node_invert_out);
node_type_base(&ntype, CMP_NODE_INVERT, "Invert", NODE_CLASS_OP_COLOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_invert_in, cmp_node_invert_out);
node_type_size(&ntype, 120, 120, 140);
node_type_init(&ntype, node_composit_init_invert);
node_type_exec(&ntype, node_composit_exec_invert);

22
source/blender/nodes/intern/CMP_nodes/CMP_lensdist.c → source/blender/nodes/composite/nodes/node_composite_lensdist.c
View File

@ -26,21 +26,21 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_lensdist.c
/** \file blender/nodes/composite/nodes/node_composite_lensdist.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
static bNodeSocketType cmp_node_lensdist_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "Distort", 0.f, 0.f, 0.f, 0.f, -0.999f, 1.f},
{ SOCK_VALUE, 1, "Dispersion", 0.f, 0.f, 0.f, 0.f, 0.f, 1.f},
static bNodeSocketTemplate cmp_node_lensdist_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ SOCK_FLOAT, 1, "Distort", 0.f, 0.f, 0.f, 0.f, -0.999f, 1.f, PROP_NONE},
{ SOCK_FLOAT, 1, "Dispersion", 0.f, 0.f, 0.f, 0.f, 0.f, 1.f, PROP_NONE},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_lensdist_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_lensdist_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -183,7 +183,7 @@ static void node_composit_exec_lensdist(void *UNUSED(data), bNode *node, bNodeSt
}
static void node_composit_init_lensdist(bNode* node)
static void node_composit_init_lensdist(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeLensDist *nld = MEM_callocN(sizeof(NodeLensDist), "node lensdist data");
nld->jit = nld->proj = nld->fit = 0;
@ -195,8 +195,8 @@ void register_node_type_cmp_lensdist(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_LENSDIST, "Lens Distortion", NODE_CLASS_DISTORT, NODE_OPTIONS,
cmp_node_lensdist_in, cmp_node_lensdist_out);
node_type_base(&ntype, CMP_NODE_LENSDIST, "Lens Distortion", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_lensdist_in, cmp_node_lensdist_out);
node_type_size(&ntype, 150, 120, 200);
node_type_init(&ntype, node_composit_init_lensdist);
node_type_storage(&ntype, "NodeLensDist", node_free_standard_storage, node_copy_standard_storage);

37
source/blender/nodes/intern/CMP_nodes/CMP_levels.c → source/blender/nodes/composite/nodes/node_composite_levels.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_levels.c 36536 2011-05-07 13:27:27Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,23 +27,23 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_levels.c
/** \file blender/nodes/composite/nodes/node_composite_levels.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** LEVELS ******************** */
static bNodeSocketType cmp_node_view_levels_in[]= {
{ SOCK_RGBA, 1, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_view_levels_in[]= {
{ SOCK_RGBA, 1, "Image", 0.0f, 0.0f, 0.0f, 1.0f},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_view_levels_out[]={
{SOCK_VALUE, 0,"Mean",0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{SOCK_VALUE, 0,"Std Dev",0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_view_levels_out[]={
{SOCK_FLOAT, 0,"Mean"},
{SOCK_FLOAT, 0,"Std Dev"},
{-1,0,""}
};
@ -52,7 +52,7 @@ static void rgb_tobw(float r, float g, float b, float* out)
*out= r*0.35f + g*0.45f + b*0.2f;
}
static void fill_bins(bNode* node, CompBuf* in, int* bins, int colorcor)
static void fill_bins(bNode* node, CompBuf* in, int* bins)
{
float value[4];
int ivalue=0;
@ -68,39 +68,29 @@ static void fill_bins(bNode* node, CompBuf* in, int* bins, int colorcor)
if(value[3] > 0.0) { /* don't count transparent pixels */
switch(node->custom1) {
case 1: { /* all colors */
if(colorcor)
linearrgb_to_srgb_v3_v3(&value[0],&value[0]);
rgb_tobw(value[0],value[1],value[2], &value[0]);
value[0]=value[0]*255; /* scale to 0-255 range */
ivalue=(int)value[0];
break;
}
case 2: { /* red channel */
if(colorcor)
value[0]=linearrgb_to_srgb(value[0]);
value[0]=value[0]*255; /* scale to 0-255 range */
ivalue=(int)value[0];
break;
}
case 3: { /* green channel */
if(colorcor)
value[1]=linearrgb_to_srgb(value[1]);
value[1]=value[1]*255; /* scale to 0-255 range */
ivalue=(int)value[1];
break;
}
case 4: /*blue channel */
{
if(colorcor)
value[2]=linearrgb_to_srgb(value[2]);
value[2]=value[2]*255; /* scale to 0-255 range */
ivalue=(int)value[2];
break;
}
case 5: /* luminence */
{
if(colorcor)
linearrgb_to_srgb_v3_v3(&value[0],&value[0]);
rgb_to_yuv(value[0],value[1],value[2], &value[0], &value[1], &value[2]);
value[0]=value[0]*255; /* scale to 0-255 range */
ivalue=(int)value[0];
@ -285,7 +275,6 @@ static void node_composit_exec_view_levels(void *data, bNode *node, bNodeStack *
{
CompBuf* cbuf;
CompBuf* histogram;
RenderData *rd=data;
float mean, std_dev;
int bins[256];
int x;
@ -302,7 +291,7 @@ static void node_composit_exec_view_levels(void *data, bNode *node, bNodeStack *
}
/*fill bins */
fill_bins(node, in[0]->data, bins, rd->color_mgt_flag & R_COLOR_MANAGEMENT);
fill_bins(node, in[0]->data, bins);
/* draw the histogram chart */
draw_histogram(node, histogram, bins);
@ -328,7 +317,7 @@ static void node_composit_exec_view_levels(void *data, bNode *node, bNodeStack *
free_compbuf(histogram);
}
static void node_composit_init_view_levels(bNode* node)
static void node_composit_init_view_levels(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
node->custom1=1; /*All channels*/
}
@ -337,8 +326,8 @@ void register_node_type_cmp_view_levels(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_VIEW_LEVELS, "Levels", NODE_CLASS_OUTPUT, NODE_OPTIONS|NODE_PREVIEW,
cmp_node_view_levels_in, cmp_node_view_levels_out);
node_type_base(&ntype, CMP_NODE_VIEW_LEVELS, "Levels", NODE_CLASS_OUTPUT, NODE_OPTIONS|NODE_PREVIEW);
node_type_socket_templates(&ntype, cmp_node_view_levels_in, cmp_node_view_levels_out);
node_type_size(&ntype, 140, 100, 320);
node_type_init(&ntype, node_composit_init_view_levels);
node_type_storage(&ntype, "ImageUser", NULL, NULL);

22
source/blender/nodes/intern/CMP_nodes/CMP_lummaMatte.c → source/blender/nodes/composite/nodes/node_composite_lummaMatte.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_lummaMatte.c 36536 2011-05-07 13:27:27Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,23 +27,23 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_lummaMatte.c
/** \file blender/nodes/composite/nodes/node_composite_lummaMatte.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* ******************* Luma Matte Node ********************************* */
static bNodeSocketType cmp_node_luma_matte_in[]={
{SOCK_RGBA,1,"Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_luma_matte_in[]={
{SOCK_RGBA,1,"Image", 0.8f, 0.8f, 0.8f, 1.0f},
{-1,0,""}
};
static bNodeSocketType cmp_node_luma_matte_out[]={
{SOCK_RGBA,0,"Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{SOCK_VALUE,0,"Matte",0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_luma_matte_out[]={
{SOCK_RGBA,0,"Image"},
{SOCK_FLOAT,0,"Matte"},
{-1,0,""}
};
@ -100,7 +100,7 @@ static void node_composit_exec_luma_matte(void *data, bNode *node, bNodeStack **
free_compbuf(cbuf);
}
static void node_composit_init_luma_matte(bNode *node)
static void node_composit_init_luma_matte(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeChroma *c= MEM_callocN(sizeof(NodeChroma), "node chroma");
node->storage=c;
@ -112,8 +112,8 @@ void register_node_type_cmp_luma_matte(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_LUMA_MATTE, "Luminance Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS,
cmp_node_luma_matte_in, cmp_node_luma_matte_out);
node_type_base(&ntype, CMP_NODE_LUMA_MATTE, "Luminance Key", NODE_CLASS_MATTE, NODE_PREVIEW|NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_luma_matte_in, cmp_node_luma_matte_out);
node_type_size(&ntype, 200, 80, 250);
node_type_init(&ntype, node_composit_init_luma_matte);
node_type_storage(&ntype, "NodeChroma", node_free_standard_storage, node_copy_standard_storage);

20
source/blender/nodes/intern/CMP_nodes/CMP_mapUV.c → source/blender/nodes/composite/nodes/node_composite_mapUV.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_mapUV.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,22 +27,22 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_mapUV.c
/** \file blender/nodes/composite/nodes/node_composite_mapUV.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** Map UV ******************** */
static bNodeSocketType cmp_node_mapuv_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{ SOCK_VECTOR, 1, "UV", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_mapuv_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ SOCK_VECTOR, 1, "UV", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_NONE},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_mapuv_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_mapuv_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -168,8 +168,8 @@ void register_node_type_cmp_mapuv(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_MAP_UV, "Map UV", NODE_CLASS_DISTORT, NODE_OPTIONS,
cmp_node_mapuv_in, cmp_node_mapuv_out);
node_type_base(&ntype, CMP_NODE_MAP_UV, "Map UV", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_mapuv_in, cmp_node_mapuv_out);
node_type_size(&ntype, 140, 100, 320);
node_type_exec(&ntype, node_composit_exec_mapuv);

20
source/blender/nodes/intern/CMP_nodes/CMP_mapValue.c → source/blender/nodes/composite/nodes/node_composite_mapValue.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_mapValue.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,20 +27,20 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_mapValue.c
/** \file blender/nodes/composite/nodes/node_composite_mapValue.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** MAP VALUE ******************** */
static bNodeSocketType cmp_node_map_value_in[]= {
{ SOCK_VALUE, 1, "Value", 1.0f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_map_value_in[]= {
{ SOCK_FLOAT, 1, "Value", 1.0f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_map_value_out[]= {
{ SOCK_VALUE, 0, "Value", 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_map_value_out[]= {
{ SOCK_FLOAT, 0, "Value"},
{ -1, 0, "" }
};
@ -79,7 +79,7 @@ static void node_composit_exec_map_value(void *UNUSED(data), bNode *node, bNodeS
}
static void node_composit_init_map_value(bNode* node)
static void node_composit_init_map_value(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
node->storage= add_mapping();
}
@ -88,8 +88,8 @@ void register_node_type_cmp_map_value(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_MAP_VALUE, "Map Value", NODE_CLASS_OP_VECTOR, NODE_OPTIONS,
cmp_node_map_value_in, cmp_node_map_value_out);
node_type_base(&ntype, CMP_NODE_MAP_VALUE, "Map Value", NODE_CLASS_OP_VECTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_map_value_in, cmp_node_map_value_out);
node_type_size(&ntype, 100, 60, 150);
node_type_init(&ntype, node_composit_init_map_value);
node_type_storage(&ntype, "TexMapping", node_free_standard_storage, node_copy_standard_storage);

21
source/blender/nodes/intern/CMP_nodes/CMP_math.c → source/blender/nodes/composite/nodes/node_composite_math.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_math.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,22 +27,22 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_math.c
/** \file blender/nodes/composite/nodes/node_composite_math.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** SCALAR MATH ******************** */
static bNodeSocketType cmp_node_math_in[]= {
{ SOCK_VALUE, 1, "Value", 0.5f, 0.5f, 0.5f, 1.0f, -10000.0f, 10000.0f},
{ SOCK_VALUE, 1, "Value", 0.5f, 0.5f, 0.5f, 1.0f, -10000.0f, 10000.0f},
static bNodeSocketTemplate cmp_node_math_in[]= {
{ SOCK_FLOAT, 1, "Value", 0.5f, 0.5f, 0.5f, 1.0f, -10000.0f, 10000.0f, PROP_NONE},
{ SOCK_FLOAT, 1, "Value", 0.5f, 0.5f, 0.5f, 1.0f, -10000.0f, 10000.0f, PROP_NONE},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_math_out[]= {
{ SOCK_VALUE, 0, "Value", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_math_out[]= {
{ SOCK_FLOAT, 0, "Value"},
{ -1, 0, "" }
};
@ -145,7 +145,6 @@ static void do_math(bNode *node, float *out, float *in, float *in2)
out[0]= floorf(in[0] / in2[0] + 0.5f) * in2[0];
else
out[0]= floorf(in[0] + 0.5f);
}
break;
case 15: /* Less Than */
@ -201,8 +200,8 @@ void register_node_type_cmp_math(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS,
cmp_node_math_in, cmp_node_math_out);
node_type_base(&ntype, CMP_NODE_MATH, "Math", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_math_in, cmp_node_math_out);
node_type_size(&ntype, 120, 110, 160);
node_type_label(&ntype, node_math_label);
node_type_exec(&ntype, node_composit_exec_math);

22
source/blender/nodes/intern/CMP_nodes/CMP_mixrgb.c → source/blender/nodes/composite/nodes/node_composite_mixrgb.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_mixrgb.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,21 +27,21 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_mixrgb.c
/** \file blender/nodes/composite/nodes/node_composite_mixrgb.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** MIX RGB ******************** */
static bNodeSocketType cmp_node_mix_rgb_in[]= {
{ SOCK_VALUE, 1, "Fac", 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f},
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_mix_rgb_in[]= {
{ SOCK_FLOAT, 1, "Fac", 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 5.0f, PROP_FACTOR},
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_mix_rgb_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_mix_rgb_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -88,8 +88,8 @@ void register_node_type_cmp_mix_rgb(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, NODE_PREVIEW|NODE_OPTIONS,
cmp_node_mix_rgb_in, cmp_node_mix_rgb_out);
node_type_base(&ntype, CMP_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, NODE_PREVIEW|NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_mix_rgb_in, cmp_node_mix_rgb_out);
node_type_size(&ntype, 110, 60, 120);
node_type_label(&ntype, node_blend_label);
node_type_exec(&ntype, node_composit_exec_mix_rgb);

36
source/blender/nodes/intern/CMP_nodes/CMP_normal.c → source/blender/nodes/composite/nodes/node_composite_normal.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_normal.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,30 +27,30 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_normal.c
/** \file blender/nodes/composite/nodes/node_composite_normal.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** NORMAL ******************** */
static bNodeSocketType cmp_node_normal_in[]= {
{ SOCK_VECTOR, 1, "Normal", 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f},
static bNodeSocketTemplate cmp_node_normal_in[]= {
{ SOCK_VECTOR, 1, "Normal", 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, PROP_DIRECTION},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_normal_out[]= {
{ SOCK_VECTOR, 0, "Normal", 0.0f, 0.0f, 1.0f, 1.0f, -1.0f, 1.0f},
{ SOCK_VALUE, 0, "Dot", 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_normal_out[]= {
{ SOCK_VECTOR, 0, "Normal"},
{ SOCK_FLOAT, 0, "Dot"},
{ -1, 0, "" }
};
static void do_normal(bNode *node, float *out, float *in)
{
bNodeSocket *sock= node->outputs.first;
float *nor= sock->ns.vec;
float *nor= ((bNodeSocketValueVector*)sock->default_value)->value;
/* render normals point inside... the widget points outside */
out[0]= -INPR(nor, in);
@ -60,12 +60,13 @@ static void do_normal(bNode *node, float *out, float *in)
static void node_composit_exec_normal(void *UNUSED(data), bNode *node, bNodeStack **in, bNodeStack **out)
{
bNodeSocket *sock= node->outputs.first;
float *nor= ((bNodeSocketValueVector*)sock->default_value)->value;
/* stack order input: normal */
/* stack order output: normal, value */
/* input no image? then only vector op */
if(in[0]->data==NULL) {
VECCOPY(out[0]->vec, sock->ns.vec);
VECCOPY(out[0]->vec, nor);
/* render normals point inside... the widget points outside */
out[1]->vec[0]= -INPR(out[0]->vec, in[0]->vec);
}
@ -82,12 +83,23 @@ static void node_composit_exec_normal(void *UNUSED(data), bNode *node, bNodeStac
}
static void init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp))
{
bNodeSocket *sock= node->outputs.first;
float *nor= ((bNodeSocketValueVector*)sock->default_value)->value;
nor[0] = 0.0f;
nor[1] = 0.0f;
nor[2] = 1.0f;
}
void register_node_type_cmp_normal(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_NORMAL, "Normal", NODE_CLASS_OP_VECTOR, NODE_OPTIONS,
cmp_node_normal_in, cmp_node_normal_out);
node_type_base(&ntype, CMP_NODE_NORMAL, "Normal", NODE_CLASS_OP_VECTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_normal_in, cmp_node_normal_out);
node_type_init(&ntype, init);
node_type_size(&ntype, 100, 60, 200);
node_type_exec(&ntype, node_composit_exec_normal);

18
source/blender/nodes/intern/CMP_nodes/CMP_normalize.c → source/blender/nodes/composite/nodes/node_composite_normalize.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_normalize.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,21 +27,21 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_normalize.c
/** \file blender/nodes/composite/nodes/node_composite_normalize.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** NORMALIZE single channel, useful for Z buffer ******************** */
static bNodeSocketType cmp_node_normalize_in[]= {
{ SOCK_VALUE, 1, "Value", 1.0f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_normalize_in[]= {
{ SOCK_FLOAT, 1, "Value", 1.0f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_normalize_out[]= {
{ SOCK_VALUE, 0, "Value", 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_normalize_out[]= {
{ SOCK_FLOAT, 0, "Value"},
{ -1, 0, "" }
};
@ -107,8 +107,8 @@ void register_node_type_cmp_normalize(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_NORMALIZE, "Normalize", NODE_CLASS_OP_VECTOR, NODE_OPTIONS,
cmp_node_normalize_in, cmp_node_normalize_out);
node_type_base(&ntype, CMP_NODE_NORMALIZE, "Normalize", NODE_CLASS_OP_VECTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_normalize_in, cmp_node_normalize_out);
node_type_size(&ntype, 100, 60, 150);
node_type_exec(&ntype, node_composit_exec_normalize);
node_type_storage(&ntype, "TexMapping", NULL, NULL);

18
source/blender/nodes/intern/CMP_nodes/CMP_outputFile.c → source/blender/nodes/composite/nodes/node_composite_outputFile.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_outputFile.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,17 +27,17 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_outputFile.c
/** \file blender/nodes/composite/nodes/node_composite_outputFile.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** OUTPUT FILE ******************** */
static bNodeSocketType cmp_node_output_file_in[]= {
{ SOCK_RGBA, 1, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "Z", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_output_file_in[]= {
{ SOCK_RGBA, 1, "Image", 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_FLOAT, 1, "Z", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ -1, 0, "" }
};
@ -93,7 +93,7 @@ static void node_composit_exec_output_file(void *data, bNode *node, bNodeStack *
}
}
static void node_composit_init_output_file(bNode *node)
static void node_composit_init_output_file(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
Scene *scene= (Scene *)node->id;
NodeImageFile *nif= MEM_callocN(sizeof(NodeImageFile), "node image file");
@ -113,8 +113,8 @@ void register_node_type_cmp_output_file(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_OUTPUT_FILE, "File Output", NODE_CLASS_OUTPUT, NODE_PREVIEW|NODE_OPTIONS,
cmp_node_output_file_in, NULL);
node_type_base(&ntype, CMP_NODE_OUTPUT_FILE, "File Output", NODE_CLASS_OUTPUT, NODE_PREVIEW|NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_output_file_in, NULL);
node_type_size(&ntype, 140, 80, 300);
node_type_init(&ntype, node_composit_init_output_file);
node_type_storage(&ntype, "NodeImageFile", node_free_standard_storage, node_copy_standard_storage);

18
source/blender/nodes/intern/CMP_nodes/CMP_premulkey.c → source/blender/nodes/composite/nodes/node_composite_premulkey.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_premulkey.c 36333 2011-04-26 09:27:43Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -28,21 +28,21 @@
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_premulkey.c
/** \file blender/nodes/composite/nodes/node_composite_premulkey.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** Premul and Key Alpha Convert ******************** */
static bNodeSocketType cmp_node_premulkey_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_premulkey_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_premulkey_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_premulkey_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -67,8 +67,8 @@ void register_node_type_cmp_premulkey(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_PREMULKEY, "Alpha Convert", NODE_CLASS_CONVERTOR, NODE_OPTIONS,
cmp_node_premulkey_in, cmp_node_premulkey_out);
node_type_base(&ntype, CMP_NODE_PREMULKEY, "Alpha Convert", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_premulkey_in, cmp_node_premulkey_out);
node_type_size(&ntype, 140, 100, 320);
node_type_exec(&ntype, node_composit_exec_premulkey);

29
source/blender/nodes/intern/CMP_nodes/CMP_rgb.c → source/blender/nodes/composite/nodes/node_composite_rgb.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_rgb.c 36333 2011-04-26 09:27:43Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,33 +27,46 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_rgb.c
/** \file blender/nodes/composite/nodes/node_composite_rgb.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** RGB ******************** */
static bNodeSocketType cmp_node_rgb_out[]= {
{ SOCK_RGBA, 0, "RGBA", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_rgb_out[]= {
{ SOCK_RGBA, 0, "RGBA", 0.8f, 0.8f, 0.8f, 1.0f},
{ -1, 0, "" }
};
static void node_composit_init_rgb(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp))
{
bNodeSocket *sock= node->outputs.first;
float *col= ((bNodeSocketValueRGBA*)sock->default_value)->value;
/* uses the default value of the output socket, must be initialized here */
col[0] = 0.5f;
col[1] = 0.5f;
col[2] = 0.5f;
col[3] = 1.0f;
}
static void node_composit_exec_rgb(void *UNUSED(data), bNode *node, bNodeStack **UNUSED(in), bNodeStack **out)
{
bNodeSocket *sock= node->outputs.first;
float *col= ((bNodeSocketValueRGBA*)sock->default_value)->value;
QUATCOPY(out[0]->vec, sock->ns.vec);
QUATCOPY(out[0]->vec, col);
}
void register_node_type_cmp_rgb(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_RGB, "RGB", NODE_CLASS_INPUT, NODE_OPTIONS,
NULL, cmp_node_rgb_out);
node_type_base(&ntype, CMP_NODE_RGB, "RGB", NODE_CLASS_INPUT, NODE_OPTIONS);
node_type_socket_templates(&ntype, NULL, cmp_node_rgb_out);
node_type_init(&ntype, node_composit_init_rgb);
node_type_size(&ntype, 140, 80, 140);
node_type_exec(&ntype, node_composit_exec_rgb);

22
source/blender/nodes/intern/CMP_nodes/CMP_rotate.c → source/blender/nodes/composite/nodes/node_composite_rotate.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_rotate.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,22 +27,22 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_rotate.c
/** \file blender/nodes/composite/nodes/node_composite_rotate.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** Rotate ******************** */
static bNodeSocketType cmp_node_rotate_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "Degr", 0.0f, 0.0f, 0.0f, 0.0f, -10000.0f, 10000.0f},
static bNodeSocketTemplate cmp_node_rotate_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ SOCK_FLOAT, 1, "Degr", 0.0f, 0.0f, 0.0f, 0.0f, -10000.0f, 10000.0f, PROP_ANGLE},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_rotate_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_rotate_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -122,7 +122,7 @@ static void node_composit_exec_rotate(void *UNUSED(data), bNode *node, bNodeStac
}
}
static void node_composit_init_rotate(bNode *node)
static void node_composit_init_rotate(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
node->custom1= 1; /* Bilinear Filter*/
}
@ -131,8 +131,8 @@ void register_node_type_cmp_rotate(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_ROTATE, "Rotate", NODE_CLASS_DISTORT, NODE_OPTIONS,
cmp_node_rotate_in, cmp_node_rotate_out);
node_type_base(&ntype, CMP_NODE_ROTATE, "Rotate", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_rotate_in, cmp_node_rotate_out);
node_type_size(&ntype, 140, 100, 320);
node_type_init(&ntype, node_composit_init_rotate);
node_type_exec(&ntype, node_composit_exec_rotate);

22
source/blender/nodes/intern/CMP_nodes/CMP_scale.c → source/blender/nodes/composite/nodes/node_composite_scale.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_scale.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,25 +27,25 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_scale.c
/** \file blender/nodes/composite/nodes/node_composite_scale.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** Scale ******************** */
#define CMP_SCALE_MAX 12000
static bNodeSocketType cmp_node_scale_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "X", 1.0f, 0.0f, 0.0f, 0.0f, 0.0001f, CMP_SCALE_MAX},
{ SOCK_VALUE, 1, "Y", 1.0f, 0.0f, 0.0f, 0.0f, 0.0001f, CMP_SCALE_MAX},
static bNodeSocketTemplate cmp_node_scale_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ SOCK_FLOAT, 1, "X", 1.0f, 0.0f, 0.0f, 0.0f, 0.0001f, CMP_SCALE_MAX, PROP_FACTOR},
{ SOCK_FLOAT, 1, "Y", 1.0f, 0.0f, 0.0f, 0.0f, 0.0001f, CMP_SCALE_MAX, PROP_FACTOR},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_scale_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_scale_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -118,8 +118,8 @@ void register_node_type_cmp_scale(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_SCALE, "Scale", NODE_CLASS_DISTORT, NODE_OPTIONS,
cmp_node_scale_in, cmp_node_scale_out);
node_type_base(&ntype, CMP_NODE_SCALE, "Scale", NODE_CLASS_DISTORT, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_scale_in, cmp_node_scale_out);
node_type_size(&ntype, 140, 100, 320);
node_type_exec(&ntype, node_composit_exec_scale);

42
source/blender/nodes/intern/CMP_nodes/CMP_sepcombHSVA.c → source/blender/nodes/composite/nodes/node_composite_sepcombHSVA.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_sepcombHSVA.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,24 +27,24 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_sepcombHSVA.c
/** \file blender/nodes/composite/nodes/node_composite_sepcombHSVA.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** SEPARATE HSVA ******************** */
static bNodeSocketType cmp_node_sephsva_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_sephsva_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_sephsva_out[]= {
{ SOCK_VALUE, 0, "H", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 0, "S", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 0, "V", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 0, "A", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_sephsva_out[]= {
{ SOCK_FLOAT, 0, "H"},
{ SOCK_FLOAT, 0, "S"},
{ SOCK_FLOAT, 0, "V"},
{ SOCK_FLOAT, 0, "A"},
{ -1, 0, "" }
};
@ -105,8 +105,8 @@ void register_node_type_cmp_sephsva(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_SEPHSVA, "Separate HSVA", NODE_CLASS_CONVERTOR, 0,
cmp_node_sephsva_in, cmp_node_sephsva_out);
node_type_base(&ntype, CMP_NODE_SEPHSVA, "Separate HSVA", NODE_CLASS_CONVERTOR, 0);
node_type_socket_templates(&ntype, cmp_node_sephsva_in, cmp_node_sephsva_out);
node_type_size(&ntype, 80, 40, 140);
node_type_exec(&ntype, node_composit_exec_sephsva);
@ -115,15 +115,15 @@ void register_node_type_cmp_sephsva(ListBase *lb)
/* **************** COMBINE HSVA ******************** */
static bNodeSocketType cmp_node_combhsva_in[]= {
{ SOCK_VALUE, 1, "H", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "S", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "V", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "A", 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_combhsva_in[]= {
{ SOCK_FLOAT, 1, "H", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ SOCK_FLOAT, 1, "S", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ SOCK_FLOAT, 1, "V", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ SOCK_FLOAT, 1, "A", 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_combhsva_out[]= {
{ SOCK_RGBA, 0, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_combhsva_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -175,8 +175,8 @@ void register_node_type_cmp_combhsva(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_COMBHSVA, "Combine HSVA", NODE_CLASS_CONVERTOR, NODE_OPTIONS,
cmp_node_combhsva_in, cmp_node_combhsva_out);
node_type_base(&ntype, CMP_NODE_COMBHSVA, "Combine HSVA", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_combhsva_in, cmp_node_combhsva_out);
node_type_size(&ntype, 80, 40, 140);
node_type_exec(&ntype, node_composit_exec_combhsva);

42
source/blender/nodes/intern/CMP_nodes/CMP_sepcombRGBA.c → source/blender/nodes/composite/nodes/node_composite_sepcombRGBA.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_sepcombRGBA.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,23 +27,23 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_sepcombRGBA.c
/** \file blender/nodes/composite/nodes/node_composite_sepcombRGBA.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** SEPARATE RGBA ******************** */
static bNodeSocketType cmp_node_seprgba_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_seprgba_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_seprgba_out[]= {
{ SOCK_VALUE, 0, "R", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 0, "G", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 0, "B", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 0, "A", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_seprgba_out[]= {
{ SOCK_FLOAT, 0, "R"},
{ SOCK_FLOAT, 0, "G"},
{ SOCK_FLOAT, 0, "B"},
{ SOCK_FLOAT, 0, "A"},
{ -1, 0, "" }
};
@ -83,8 +83,8 @@ void register_node_type_cmp_seprgba(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_SEPRGBA, "Separate RGBA", NODE_CLASS_CONVERTOR, 0,
cmp_node_seprgba_in, cmp_node_seprgba_out);
node_type_base(&ntype, CMP_NODE_SEPRGBA, "Separate RGBA", NODE_CLASS_CONVERTOR, 0);
node_type_socket_templates(&ntype, cmp_node_seprgba_in, cmp_node_seprgba_out);
node_type_size(&ntype, 80, 40, 140);
node_type_exec(&ntype, node_composit_exec_seprgba);
@ -94,15 +94,15 @@ void register_node_type_cmp_seprgba(ListBase *lb)
/* **************** COMBINE RGBA ******************** */
static bNodeSocketType cmp_node_combrgba_in[]= {
{ SOCK_VALUE, 1, "R", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "G", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "B", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "A", 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_combrgba_in[]= {
{ SOCK_FLOAT, 1, "R", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ SOCK_FLOAT, 1, "G", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ SOCK_FLOAT, 1, "B", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ SOCK_FLOAT, 1, "A", 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_combrgba_out[]= {
{ SOCK_RGBA, 0, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_combrgba_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -151,8 +151,8 @@ void register_node_type_cmp_combrgba(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_COMBRGBA, "Combine RGBA", NODE_CLASS_CONVERTOR, NODE_OPTIONS,
cmp_node_combrgba_in, cmp_node_combrgba_out);
node_type_base(&ntype, CMP_NODE_COMBRGBA, "Combine RGBA", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_combrgba_in, cmp_node_combrgba_out);
node_type_size(&ntype, 80, 40, 140);
node_type_exec(&ntype, node_composit_exec_combrgba);

42
source/blender/nodes/intern/CMP_nodes/CMP_sepcombYCCA.c → source/blender/nodes/composite/nodes/node_composite_sepcombYCCA.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_sepcombYCCA.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,24 +27,24 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_sepcombYCCA.c
/** \file blender/nodes/composite/nodes/node_composite_sepcombYCCA.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** SEPARATE YCCA ******************** */
static bNodeSocketType cmp_node_sepycca_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_sepycca_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_sepycca_out[]= {
{ SOCK_VALUE, 0, "Y", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 0, "Cb", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 0, "Cr", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 0, "A", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_sepycca_out[]= {
{ SOCK_FLOAT, 0, "Y"},
{ SOCK_FLOAT, 0, "Cb"},
{ SOCK_FLOAT, 0, "Cr"},
{ SOCK_FLOAT, 0, "A"},
{ -1, 0, "" }
};
@ -154,8 +154,8 @@ void register_node_type_cmp_sepycca(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_SEPYCCA, "Separate YCbCrA", NODE_CLASS_CONVERTOR, NODE_OPTIONS,
cmp_node_sepycca_in, cmp_node_sepycca_out);
node_type_base(&ntype, CMP_NODE_SEPYCCA, "Separate YCbCrA", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_sepycca_in, cmp_node_sepycca_out);
node_type_size(&ntype, 80, 40, 140);
node_type_exec(&ntype, node_composit_exec_sepycca);
@ -165,15 +165,15 @@ void register_node_type_cmp_sepycca(ListBase *lb)
/* **************** COMBINE YCCA ******************** */
static bNodeSocketType cmp_node_combycca_in[]= {
{ SOCK_VALUE, 1, "Y", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "Cb", 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "Cr", 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "A", 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_combycca_in[]= {
{ SOCK_FLOAT, 1, "Y", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ SOCK_FLOAT, 1, "Cb", 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ SOCK_FLOAT, 1, "Cr", 0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ SOCK_FLOAT, 1, "A", 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_combycca_out[]= {
{ SOCK_RGBA, 0, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_combycca_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -301,8 +301,8 @@ void register_node_type_cmp_combycca(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_COMBYCCA, "Combine YCbCrA", NODE_CLASS_CONVERTOR, NODE_OPTIONS,
cmp_node_combycca_in, cmp_node_combycca_out);
node_type_base(&ntype, CMP_NODE_COMBYCCA, "Combine YCbCrA", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_combycca_in, cmp_node_combycca_out);
node_type_size(&ntype, 80, 40, 140);
node_type_exec(&ntype, node_composit_exec_combycca);

42
source/blender/nodes/intern/CMP_nodes/CMP_sepcombYUVA.c → source/blender/nodes/composite/nodes/node_composite_sepcombYUVA.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_sepcombYUVA.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,24 +27,24 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_sepcombYUVA.c
/** \file blender/nodes/composite/nodes/node_composite_sepcombYUVA.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** SEPARATE YUVA ******************** */
static bNodeSocketType cmp_node_sepyuva_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_sepyuva_in[]= {
{ SOCK_RGBA, 1, "Image", 0.8f, 0.8f, 0.8f, 1.0f},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_sepyuva_out[]= {
{ SOCK_VALUE, 0, "Y", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 0, "U", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 0, "V", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 0, "A", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_sepyuva_out[]= {
{ SOCK_FLOAT, 0, "Y"},
{ SOCK_FLOAT, 0, "U"},
{ SOCK_FLOAT, 0, "V"},
{ SOCK_FLOAT, 0, "A"},
{ -1, 0, "" }
};
@ -105,8 +105,8 @@ void register_node_type_cmp_sepyuva(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_SEPYUVA, "Separate YUVA", NODE_CLASS_CONVERTOR, 0,
cmp_node_sepyuva_in, cmp_node_sepyuva_out);
node_type_base(&ntype, CMP_NODE_SEPYUVA, "Separate YUVA", NODE_CLASS_CONVERTOR, 0);
node_type_socket_templates(&ntype, cmp_node_sepyuva_in, cmp_node_sepyuva_out);
node_type_size(&ntype, 80, 40, 140);
node_type_exec(&ntype, node_composit_exec_sepyuva);
@ -116,15 +116,15 @@ void register_node_type_cmp_sepyuva(ListBase *lb)
/* **************** COMBINE YUVA ******************** */
static bNodeSocketType cmp_node_combyuva_in[]= {
{ SOCK_VALUE, 1, "Y", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "U", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "V", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "A", 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_combyuva_in[]= {
{ SOCK_FLOAT, 1, "Y", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ SOCK_FLOAT, 1, "U", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ SOCK_FLOAT, 1, "V", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ SOCK_FLOAT, 1, "A", 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, PROP_NONE},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_combyuva_out[]= {
{ SOCK_RGBA, 0, "Image", 0.8f, 0.8f, 0.8f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_combyuva_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -176,8 +176,8 @@ void register_node_type_cmp_combyuva(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_COMBYUVA, "Combine YUVA", NODE_CLASS_CONVERTOR, NODE_OPTIONS,
cmp_node_combyuva_in, cmp_node_combyuva_out);
node_type_base(&ntype, CMP_NODE_COMBYUVA, "Combine YUVA", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_combyuva_in, cmp_node_combyuva_out);
node_type_size(&ntype, 80, 40, 140);
node_type_exec(&ntype, node_composit_exec_combyuva);

20
source/blender/nodes/intern/CMP_nodes/CMP_setalpha.c → source/blender/nodes/composite/nodes/node_composite_setalpha.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_setalpha.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,21 +27,21 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_setalpha.c
/** \file blender/nodes/composite/nodes/node_composite_setalpha.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** SET ALPHA ******************** */
static bNodeSocketType cmp_node_setalpha_in[]= {
{ SOCK_RGBA, 1, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_VALUE, 1, "Alpha", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_setalpha_in[]= {
{ SOCK_RGBA, 1, "Image", 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_FLOAT, 1, "Alpha", 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, PROP_NONE},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_setalpha_out[]= {
{ SOCK_RGBA, 0, "Image", 0.0f, 0.0f, 1.0f, 1.0f, -1.0f, 1.0f},
static bNodeSocketTemplate cmp_node_setalpha_out[]= {
{ SOCK_RGBA, 0, "Image"},
{ -1, 0, "" }
};
@ -79,8 +79,8 @@ void register_node_type_cmp_setalpha(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_SETALPHA, "Set Alpha", NODE_CLASS_CONVERTOR, NODE_OPTIONS,
cmp_node_setalpha_in, cmp_node_setalpha_out);
node_type_base(&ntype, CMP_NODE_SETALPHA, "Set Alpha", NODE_CLASS_CONVERTOR, NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_setalpha_in, cmp_node_setalpha_out);
node_type_size(&ntype, 120, 40, 140);
node_type_exec(&ntype, node_composit_exec_setalpha);

18
source/blender/nodes/intern/CMP_nodes/CMP_splitViewer.c → source/blender/nodes/composite/nodes/node_composite_splitViewer.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_splitViewer.c 36340 2011-04-26 13:24:20Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,17 +27,17 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_splitViewer.c
/** \file blender/nodes/composite/nodes/node_composite_splitViewer.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** SPLIT VIEWER ******************** */
static bNodeSocketType cmp_node_splitviewer_in[]= {
{ SOCK_RGBA, 1, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_RGBA, 1, "Image", 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_splitviewer_in[]= {
{ SOCK_RGBA, 1, "Image", 0.0f, 0.0f, 0.0f, 1.0f},
{ SOCK_RGBA, 1, "Image", 0.0f, 0.0f, 0.0f, 1.0f},
{ -1, 0, "" }
};
@ -141,7 +141,7 @@ static void node_composit_exec_splitviewer(void *data, bNode *node, bNodeStack *
}
}
static void node_composit_init_splitviewer(bNode* node)
static void node_composit_init_splitviewer(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
ImageUser *iuser= MEM_callocN(sizeof(ImageUser), "node image user");
node->storage= iuser;
@ -155,8 +155,8 @@ void register_node_type_cmp_splitviewer(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_SPLITVIEWER, "SplitViewer", NODE_CLASS_OUTPUT, NODE_PREVIEW|NODE_OPTIONS,
cmp_node_splitviewer_in, NULL);
node_type_base(&ntype, CMP_NODE_SPLITVIEWER, "SplitViewer", NODE_CLASS_OUTPUT, NODE_PREVIEW|NODE_OPTIONS);
node_type_socket_templates(&ntype, cmp_node_splitviewer_in, NULL);
node_type_size(&ntype, 140, 100, 320);
node_type_init(&ntype, node_composit_init_splitviewer);
node_type_storage(&ntype, "ImageUser", node_free_standard_storage, node_copy_standard_storage);

22
source/blender/nodes/intern/CMP_nodes/CMP_texture.c → source/blender/nodes/composite/nodes/node_composite_texture.c
View File

@ -1,5 +1,5 @@
/*
* $Id$
* $Id: CMP_texture.c 36593 2011-05-10 11:19:26Z lukastoenne $
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
@ -27,22 +27,22 @@
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/nodes/intern/CMP_nodes/CMP_texture.c
/** \file blender/nodes/composite/nodes/node_composite_texture.c
* \ingroup cmpnodes
*/
#include "../CMP_util.h"
#include "node_composite_util.h"
/* **************** TEXTURE ******************** */
static bNodeSocketType cmp_node_texture_in[]= {
{ SOCK_VECTOR, 1, "Offset", 0.0f, 0.0f, 0.0f, 0.0f, -2.0f, 2.0f},
{ SOCK_VECTOR, 1, "Scale", 1.0f, 1.0f, 1.0f, 1.0f, -10.0f, 10.0f},
static bNodeSocketTemplate cmp_node_texture_in[]= {
{ SOCK_VECTOR, 1, "Offset", 0.0f, 0.0f, 0.0f, 0.0f, -2.0f, 2.0f, PROP_TRANSLATION},
{ SOCK_VECTOR, 1, "Scale", 1.0f, 1.0f, 1.0f, 1.0f, -10.0f, 10.0f, PROP_XYZ},
{ -1, 0, "" }
};
static bNodeSocketType cmp_node_texture_out[]= {
{ SOCK_VALUE, 0, "Value", 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
{ SOCK_RGBA , 0, "Color", 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f},
static bNodeSocketTemplate cmp_node_texture_out[]= {
{ SOCK_FLOAT, 0, "Value"},
{ SOCK_RGBA , 0, "Color"},
{ -1, 0, "" }
};
@ -148,8 +148,8 @@ void register_node_type_cmp_texture(ListBase *lb)
{
static bNodeType ntype;
node_type_base(&ntype, CMP_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW,
cmp_node_texture_in, cmp_node_texture_out);
node_type_base(&ntype, CMP_NODE_TEXTURE, "Texture", NODE_CLASS_INPUT, NODE_OPTIONS|NODE_PREVIEW);
node_type_socket_templates(&ntype, cmp_node_texture_in, cmp_node_texture_out);
node_type_size(&ntype, 120, 80, 240);
node_type_exec(&ntype, node_composit_exec_texture);

Some files were not shown because too many files have changed in this diff Show More