griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Cycles: add location/rotate/scale and XYZ mapping options for all texture nodes,

Browse Source 
to reduce the amount of nodes needed to set up a simple texture.

These are currently editable in the texture properties tab, still need to make
them available in the node editor. Projection and color modification options will
be added later, they're not implemented yet but allocated already to avoid
version patches later.

Also an issue with the XYZ mapping is that when you set one to None, texture and
material draw mode doesn't draw the image texture well, OpenGL doesn't seem to
like the degenerate texture matrix?
This commit is contained in:
Brecht Van Lommel
2011-11-04 20:58:00 +00:00
parent 942d2fe3b7
commit 72929172dd
38 changed files with 574 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
intern/cycles/blender/addon/ui.py
View File

@@ -311,7 +311,7 @@ class CyclesObject_PT_ray_visibility(CyclesButtonsPanel, Panel):
@classmethod
def poll(cls, context):
ob = context.object
return ob and ob.type in ('MESH', 'CURVE', 'CURVE', 'SURFACE', 'FONT', 'META') # todo: 'LAMP'
return CyclesButtonsPanel.poll(context) and ob and ob.type in ('MESH', 'CURVE', 'CURVE', 'SURFACE', 'FONT', 'META') # todo: 'LAMP'
def draw(self, context):
layout = self.layout
@@ -604,23 +604,64 @@ class CyclesTexture_PT_mapping(CyclesButtonsPanel, Panel):
def draw(self, context):
layout = self.layout
layout.label("Texture coordinate mapping goes here.");
layout.label("Translate, rotate, scale, projection, XYZ.")
class CyclesTexture_PT_color(CyclesButtonsPanel, Panel):
tex = context.texture
node = context.texture_node
mapping = node.texture_mapping
row = layout.row()
row.column().prop(mapping, "location")
row.column().prop(mapping, "rotation")
row.column().prop(mapping, "scale")
layout.label(text="Projection:")
row = layout.row()
row.prop(mapping, "mapping_x", text="")
row.prop(mapping, "mapping_y", text="")
row.prop(mapping, "mapping_z", text="")
class CyclesTexture_PT_colors(CyclesButtonsPanel, Panel):
bl_label = "Color"
bl_context = "texture"
bl_options = {'DEFAULT_CLOSED'}
@classmethod
def poll(cls, context):
tex = context.texture
node = context.texture_node
return (node or (tex and tex.use_nodes)) and CyclesButtonsPanel.poll(context)
return False
#return (node or (tex and tex.use_nodes)) and CyclesButtonsPanel.poll(context)
def draw(self, context):
layout = self.layout
layout.label("Color modification options go here.");
layout.label("Ramp, brightness, contrast, saturation.")
tex = context.texture
node = context.texture_node
mapping = node.color_mapping
split = layout.split()
col = split.column()
col.label(text="Blend:")
col.prop(mapping, "blend_type", text="")
col.prop(mapping, "blend_factor", text="Factor")
col.prop(mapping, "blend_color", text="")
col = split.column()
col.label(text="Adjust:")
col.prop(mapping, "brightness")
col.prop(mapping, "contrast")
col.prop(mapping, "saturation")
layout.separator()
layout.prop(mapping, "use_color_ramp", text="Ramp")
if mapping.use_color_ramp:
layout.template_color_ramp(mapping, "color_ramp", expand=True)
def draw_device(self, context):
scene = context.scene

33
intern/cycles/blender/blender_shader.cpp
View File

@@ -97,6 +97,17 @@ static float get_node_output_value(BL::Node b_node, const string& name)
return sock.default_value();
}
static void get_tex_mapping(TextureMapping *mapping, BL::TexMapping b_mapping)
{
mapping->translation = get_float3(b_mapping.location());
mapping->rotation = get_float3(b_mapping.rotation())*(M_PI/180.0f); /* in degrees! */
mapping->scale = get_float3(b_mapping.scale());
mapping->x_mapping = (TextureMapping::Mapping)b_mapping.mapping_x();
mapping->y_mapping = (TextureMapping::Mapping)b_mapping.mapping_y();
mapping->z_mapping = (TextureMapping::Mapping)b_mapping.mapping_z();
}
static ShaderNode *add_node(BL::BlendData b_data, ShaderGraph *graph, BL::Node *b_group_node, BL::ShaderNode b_node)
{
ShaderNode *node = NULL;
@@ -163,10 +174,7 @@ static ShaderNode *add_node(BL::BlendData b_data, ShaderGraph *graph, BL::Node *
BL::ShaderNodeMapping b_mapping_node(b_node);
MappingNode *mapping = new MappingNode();
TextureMapping *tex_mapping = &mapping->tex_mapping;
tex_mapping->translation = get_float3(b_mapping_node.location());
tex_mapping->rotation = get_float3(b_mapping_node.rotation());
tex_mapping->scale = get_float3(b_mapping_node.scale());
get_tex_mapping(&mapping->tex_mapping, b_mapping_node.mapping());
node = mapping;
break;
@@ -293,6 +301,7 @@ static ShaderNode *add_node(BL::BlendData b_data, ShaderGraph *graph, BL::Node *
if(b_image)
image->filename = blender_absolute_path(b_data, b_image, b_image.filepath());
image->color_space = ImageTextureNode::color_space_enum[(int)b_image_node.color_space()];
get_tex_mapping(&image->tex_mapping, b_image_node.texture_mapping());
node = image;
break;
}
@@ -303,11 +312,15 @@ static ShaderNode *add_node(BL::BlendData b_data, ShaderGraph *graph, BL::Node *
if(b_image)
env->filename = blender_absolute_path(b_data, b_image, b_image.filepath());
env->color_space = EnvironmentTextureNode::color_space_enum[(int)b_env_node.color_space()];
get_tex_mapping(&env->tex_mapping, b_env_node.texture_mapping());
node = env;
break;
}
case BL::ShaderNode::type_TEX_NOISE: {
node = new NoiseTextureNode();
BL::ShaderNodeTexNoise b_noise_node(b_node);
NoiseTextureNode *noise = new NoiseTextureNode();
get_tex_mapping(&noise->tex_mapping, b_noise_node.texture_mapping());
node = noise;
break;
}
case BL::ShaderNode::type_TEX_BLEND: {
@@ -315,6 +328,7 @@ static ShaderNode *add_node(BL::BlendData b_data, ShaderGraph *graph, BL::Node *
BlendTextureNode *blend = new BlendTextureNode();
blend->progression = BlendTextureNode::progression_enum[(int)b_blend_node.progression()];
blend->axis = BlendTextureNode::axis_enum[(int)b_blend_node.axis()];
get_tex_mapping(&blend->tex_mapping, b_blend_node.texture_mapping());
node = blend;
break;
}
@@ -323,6 +337,7 @@ static ShaderNode *add_node(BL::BlendData b_data, ShaderGraph *graph, BL::Node *
VoronoiTextureNode *voronoi = new VoronoiTextureNode();
voronoi->distance_metric = VoronoiTextureNode::distance_metric_enum[(int)b_voronoi_node.distance_metric()];
voronoi->coloring = VoronoiTextureNode::coloring_enum[(int)b_voronoi_node.coloring()];
get_tex_mapping(&voronoi->tex_mapping, b_voronoi_node.texture_mapping());
node = voronoi;
break;
}
@@ -330,6 +345,7 @@ static ShaderNode *add_node(BL::BlendData b_data, ShaderGraph *graph, BL::Node *
BL::ShaderNodeTexMagic b_magic_node(b_node);
MagicTextureNode *magic = new MagicTextureNode();
magic->depth = b_magic_node.turbulence_depth();
get_tex_mapping(&magic->tex_mapping, b_magic_node.texture_mapping());
node = magic;
break;
}
@@ -341,6 +357,7 @@ static ShaderNode *add_node(BL::BlendData b_data, ShaderGraph *graph, BL::Node *
marble->type = MarbleTextureNode::type_enum[(int)b_marble_node.marble_type()];
marble->wave = MarbleTextureNode::wave_enum[(int)b_marble_node.wave_type()];
marble->hard = b_marble_node.noise_type() == BL::ShaderNodeTexMarble::noise_type_HARD;
get_tex_mapping(&marble->tex_mapping, b_marble_node.texture_mapping());
node = marble;
break;
}
@@ -350,6 +367,7 @@ static ShaderNode *add_node(BL::BlendData b_data, ShaderGraph *graph, BL::Node *
clouds->depth = b_clouds_node.turbulence_depth();
clouds->basis = CloudsTextureNode::basis_enum[(int)b_clouds_node.noise_basis()];
clouds->hard = b_clouds_node.noise_type() == BL::ShaderNodeTexClouds::noise_type_HARD;
get_tex_mapping(&clouds->tex_mapping, b_clouds_node.texture_mapping());
node = clouds;
break;
}
@@ -360,6 +378,7 @@ static ShaderNode *add_node(BL::BlendData b_data, ShaderGraph *graph, BL::Node *
wood->basis = WoodTextureNode::basis_enum[(int)b_wood_node.noise_basis()];
wood->hard = b_wood_node.noise_type() == BL::ShaderNodeTexWood::noise_type_HARD;
wood->wave = WoodTextureNode::wave_enum[(int)b_wood_node.wave_type()];
get_tex_mapping(&wood->tex_mapping, b_wood_node.texture_mapping());
node = wood;
break;
}
@@ -368,6 +387,7 @@ static ShaderNode *add_node(BL::BlendData b_data, ShaderGraph *graph, BL::Node *
MusgraveTextureNode *musgrave = new MusgraveTextureNode();
musgrave->type = MusgraveTextureNode::type_enum[(int)b_musgrave_node.musgrave_type()];
musgrave->basis = MusgraveTextureNode::basis_enum[(int)b_musgrave_node.noise_basis()];
get_tex_mapping(&musgrave->tex_mapping, b_musgrave_node.texture_mapping());
node = musgrave;
break;
}
@@ -377,6 +397,7 @@ static ShaderNode *add_node(BL::BlendData b_data, ShaderGraph *graph, BL::Node *
stucci->type = StucciTextureNode::type_enum[(int)b_stucci_node.stucci_type()];
stucci->basis = StucciTextureNode::basis_enum[(int)b_stucci_node.noise_basis()];
stucci->hard = b_stucci_node.noise_type() == BL::ShaderNodeTexStucci::noise_type_HARD;
get_tex_mapping(&stucci->tex_mapping, b_stucci_node.texture_mapping());
node = stucci;
break;
}
@@ -385,6 +406,7 @@ static ShaderNode *add_node(BL::BlendData b_data, ShaderGraph *graph, BL::Node *
DistortedNoiseTextureNode *distnoise = new DistortedNoiseTextureNode();
distnoise->basis = DistortedNoiseTextureNode::basis_enum[(int)b_distnoise_node.noise_basis()];
distnoise->distortion_basis = DistortedNoiseTextureNode::basis_enum[(int)b_distnoise_node.noise_distortion()];
get_tex_mapping(&distnoise->tex_mapping, b_distnoise_node.texture_mapping());
node = distnoise;
break;
}
@@ -397,6 +419,7 @@ static ShaderNode *add_node(BL::BlendData b_data, ShaderGraph *graph, BL::Node *
SkyTextureNode *sky = new SkyTextureNode();
sky->sun_direction = get_float3(b_sky_node.sun_direction());
sky->turbidity = b_sky_node.turbidity();
get_tex_mapping(&sky->tex_mapping, b_sky_node.texture_mapping());
node = sky;
break;
}

6
intern/cycles/render/nodes.cpp
View File

@@ -45,11 +45,11 @@ Transform TextureMapping::compute_transform()
Transform mmat = transform_scale(make_float3(0.0f, 0.0f, 0.0f));
if(x_mapping != NONE)
mmat[0][x_mapping] = 1.0f;
mmat[0][x_mapping-1] = 1.0f;
if(y_mapping != NONE)
mmat[1][y_mapping] = 1.0f;
mmat[1][y_mapping-1] = 1.0f;
if(z_mapping != NONE)
mmat[2][z_mapping] = 1.0f;
mmat[2][z_mapping-1] = 1.0f;
Transform smat = transform_scale(scale);
Transform rmat = transform_euler(rotation);

2
intern/cycles/render/nodes.h
View File

@@ -41,7 +41,7 @@ public:
float3 rotation;
float3 scale;
enum Mapping { X=0, Y=1, Z=2, NONE };
enum Mapping { NONE=0, X=1, Y=2, Z=3 };
Mapping x_mapping, y_mapping, z_mapping;
enum Projection { FLAT, CUBE, TUBE, SPHERE };

7
source/blender/blenkernel/BKE_texture.h
View File

@@ -103,9 +103,12 @@ void set_current_particle_texture(struct ParticleSettings *part, struct Tex *tex
int has_current_material_texture(struct Material *ma);
struct TexMapping *add_mapping(void);
void init_mapping(struct TexMapping *texmap);
struct TexMapping *add_tex_mapping(void);
void default_tex_mapping(struct TexMapping *texmap);
void init_tex_mapping(struct TexMapping *texmap);
struct ColorMapping *add_color_mapping(void);
void default_color_mapping(struct ColorMapping *colormap);
void BKE_free_envmapdata(struct EnvMap *env);
void BKE_free_envmap(struct EnvMap *env);

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

@@ -202,33 +202,96 @@ void free_plugin_tex(PluginTex *pit)
/* ****************** Mapping ******************* */
TexMapping *add_mapping(void)
TexMapping *add_tex_mapping(void)
{
TexMapping *texmap= MEM_callocN(sizeof(TexMapping), "Tex map");
TexMapping *texmap= MEM_callocN(sizeof(TexMapping), "TexMapping");
texmap->size[0]= texmap->size[1]= texmap->size[2]= 1.0f;
texmap->max[0]= texmap->max[1]= texmap->max[2]= 1.0f;
unit_m4(texmap->mat);
default_tex_mapping(texmap);
return texmap;
}
void init_mapping(TexMapping *texmap)
void default_tex_mapping(TexMapping *texmap)
{
float eul[3], smat[3][3], rmat[3][3], mat[3][3];
size_to_mat3( smat,texmap->size);
eul[0]= DEG2RADF(texmap->rot[0]);
eul[1]= DEG2RADF(texmap->rot[1]);
eul[2]= DEG2RADF(texmap->rot[2]);
eul_to_mat3( rmat,eul);
mul_m3_m3m3(mat, rmat, smat);
copy_m4_m3(texmap->mat, mat);
VECCOPY(texmap->mat[3], texmap->loc);
memset(texmap, 0, sizeof(TexMapping));
texmap->size[0]= texmap->size[1]= texmap->size[2]= 1.0f;
texmap->max[0]= texmap->max[1]= texmap->max[2]= 1.0f;
unit_m4(texmap->mat);
texmap->projx= PROJ_X;
texmap->projy= PROJ_Y;
texmap->projz= PROJ_Z;
texmap->mapping= MTEX_FLAT;
}
void init_tex_mapping(TexMapping *texmap)
{
float eul[3], smat[3][3], rmat[3][3], mat[3][3], proj[3][3];
if(texmap->projx == PROJ_X && texmap->projy == PROJ_Y && texmap->projz == PROJ_Z &&
is_zero_v3(texmap->loc) && is_zero_v3(texmap->rot) && is_one_v3(texmap->size)) {
unit_m4(texmap->mat);
texmap->flag |= TEXMAP_UNIT_MATRIX;
}
else {
/* axis projection */
zero_m3(proj);
if(texmap->projx != PROJ_N)
proj[texmap->projx-1][0]= 1.0f;
if(texmap->projy != PROJ_N)
proj[texmap->projy-1][1]= 1.0f;
if(texmap->projz != PROJ_N)
proj[texmap->projz-1][2]= 1.0f;
/* scale */
size_to_mat3(smat, texmap->size);
/* rotation */
eul[0]= DEG2RADF(texmap->rot[0]);
eul[1]= DEG2RADF(texmap->rot[1]);
eul[2]= DEG2RADF(texmap->rot[2]);
eul_to_mat3( rmat,eul);
/* compose it all */
mul_m3_m3m3(mat, rmat, smat);
mul_m3_m3m3(mat, proj, mat);
/* translation */
copy_m4_m3(texmap->mat, mat);
VECCOPY(texmap->mat[3], texmap->loc);
texmap->flag &= ~TEXMAP_UNIT_MATRIX;
}
}
ColorMapping *add_color_mapping(void)
{
ColorMapping *colormap= MEM_callocN(sizeof(ColorMapping), "ColorMapping");
default_color_mapping(colormap);
return colormap;
}
void default_color_mapping(ColorMapping *colormap)
{
memset(colormap, 0, sizeof(ColorMapping));
init_colorband(&colormap->coba, 1);
colormap->bright= 1.0;
colormap->contrast= 1.0;
colormap->saturation= 1.0;
colormap->blend_color[0]= 0.8f;
colormap->blend_color[1]= 0.8f;
colormap->blend_color[2]= 0.8f;
colormap->blend_type= MA_RAMP_BLEND;
colormap->blend_factor= 0.0f;
}
/* ****************** COLORBAND ******************* */

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

@@ -7212,6 +7212,40 @@ static void do_versions_nodetree_image_default_alpha_output(bNodeTree *ntree)
}
}
static void do_version_ntree_tex_mapping_260(void *UNUSED(data), ID *UNUSED(id), bNodeTree *ntree)
{
bNode *node;
for(node=ntree->nodes.first; node; node=node->next) {
TexMapping *tex_mapping= NULL;
ColorMapping *color_mapping= NULL;
if(node->type == SH_NODE_MAPPING) {
tex_mapping= node->storage;
tex_mapping->projx= PROJ_X;
tex_mapping->projy= PROJ_Y;
tex_mapping->projz= PROJ_Z;
}
else if(ELEM7(node->type, SH_NODE_TEX_IMAGE, SH_NODE_TEX_NOISE, SH_NODE_TEX_SKY,
SH_NODE_TEX_BLEND, SH_NODE_TEX_VORONOI, SH_NODE_TEX_MAGIC, SH_NODE_TEX_MARBLE) ||
ELEM6(node->type, SH_NODE_TEX_CLOUDS, SH_NODE_TEX_WOOD, SH_NODE_TEX_MUSGRAVE,
SH_NODE_TEX_STUCCI, SH_NODE_TEX_DISTNOISE, SH_NODE_TEX_ENVIRONMENT)) {
NodeTexBase *base= node->storage;
if(node->type == SH_NODE_TEX_NOISE)
node->storage= MEM_callocN(sizeof(NodeTexNoise), "NodeTexNoise");
tex_mapping= &base->tex_mapping;
color_mapping= &base->color_mapping;
if(is_zero_v3(tex_mapping->size)) {
default_tex_mapping(tex_mapping);
default_color_mapping(color_mapping);
}
}
}
}
static void do_versions(FileData *fd, Library *lib, Main *main)
{
/* WATCH IT!!!: pointers from libdata have not been converted */
@@ -12339,6 +12373,13 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
cam->sensor_y = DEFAULT_SENSOR_HEIGHT;
}
}
{
bNodeTreeType *ntreetype= ntreeGetType(NTREE_SHADER);
if(ntreetype && ntreetype->foreach_nodetree)
ntreetype->foreach_nodetree(main, NULL, do_version_ntree_tex_mapping_260);
}
}
/* put compatibility code here until next subversion bump */

3
source/blender/editors/include/ED_uvedit.h
View File

@@ -40,6 +40,7 @@ struct Object;
struct Scene;
struct SpaceImage;
struct bContext;
struct bNode;
struct wmKeyConfig;
/* uvedit_ops.c */
@@ -49,7 +50,7 @@ void ED_keymap_uvedit(struct wmKeyConfig *keyconf);
void ED_uvedit_assign_image(struct Main *bmain, struct Scene *scene, struct Object *obedit, struct Image *ima, struct Image *previma);
int ED_uvedit_minmax(struct Scene *scene, struct Image *ima, struct Object *obedit, float *min, float *max);
int ED_object_get_active_image(struct Object *ob, int mat_nr, struct Image **ima, struct ImageUser **iuser);
int ED_object_get_active_image(struct Object *ob, int mat_nr, struct Image **ima, struct ImageUser **iuser, struct bNode **node);
void ED_object_assign_active_image(struct Main *bmain, struct Object *ob, int mat_nr, struct Image *ima);
int ED_uvedit_test_silent(struct Object *obedit);

5
source/blender/editors/interface/interface_node.c
View File

@@ -252,6 +252,11 @@ static void ui_node_link(bContext *C, void *arg_p, void *event_p)
}
}
/* also preserve mapping for texture nodes */
if(node_from->typeinfo->nclass == NODE_CLASS_TEXTURE &&
node_prev->typeinfo->nclass == NODE_CLASS_TEXTURE)
memcpy(node_from->storage, node_prev->storage, sizeof(NodeTexBase));
/* remove node */
ui_node_remove_linked(ntree, node_prev);
}

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

@@ -489,7 +489,7 @@ static Image *imapaint_face_image(const ImagePaintState *s, int face_index)
if(scene_use_new_shading_nodes(s->scene)) {
MFace *mf = s->me->mface+face_index;
ED_object_get_active_image(s->ob, mf->mat_nr, &ima, NULL);
ED_object_get_active_image(s->ob, mf->mat_nr, &ima, NULL, NULL);
}
else {
MTFace *tf = s->me->mtface+face_index;
@@ -505,7 +505,7 @@ static Image *project_paint_face_image(const ProjPaintState *ps, int face_index)
if(scene_use_new_shading_nodes(ps->scene)) {
MFace *mf = ps->dm_mface+face_index;
ED_object_get_active_image(ps->ob, mf->mat_nr, &ima, NULL);
ED_object_get_active_image(ps->ob, mf->mat_nr, &ima, NULL, NULL);
}
else {
MTFace *tf = ps->dm_mtface+face_index;

2
source/blender/editors/space_image/space_image.c
View File

@@ -597,7 +597,7 @@ static void image_refresh(const bContext *C, ScrArea *UNUSED(sa))
EditFace *efa= EM_get_actFace(em, sloppy);
if(efa)
ED_object_get_active_image(obedit, efa->mat_nr, &sima->image, NULL);
ED_object_get_active_image(obedit, efa->mat_nr, &sima->image, NULL, NULL);
}
else {
/* old shading system, we set texface */

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

@@ -946,28 +946,29 @@ static void node_shader_buts_material(uiLayout *layout, bContext *C, PointerRNA
static void node_shader_buts_mapping(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
{
PointerRNA mappingptr = RNA_pointer_get(ptr, "mapping");
uiLayout *row;
uiItemL(layout, "Translation:", ICON_NONE);
row= uiLayoutRow(layout, 1);
uiItemR(row, ptr, "location", 0, "", ICON_NONE);
uiItemR(row, &mappingptr, "location", 0, "", ICON_NONE);
uiItemL(layout, "Rotation:", ICON_NONE);
row= uiLayoutRow(layout, 1);
uiItemR(row, ptr, "rotation", 0, "", ICON_NONE);
uiItemR(row, &mappingptr, "rotation", 0, "", ICON_NONE);
uiItemL(layout, "Scale:", ICON_NONE);
row= uiLayoutRow(layout, 1);
uiItemR(row, ptr, "scale", 0, "", ICON_NONE);
uiItemR(row, &mappingptr, "scale", 0, "", ICON_NONE);
#if 0
row= uiLayoutRow(layout, 1);
uiItemR(row, ptr, "use_min", 0, "Min", ICON_NONE);
uiItemR(row, ptr, "min", 0, "", ICON_NONE);
uiItemR(row, &mappingptr, "use_min", 0, "Min", ICON_NONE);
uiItemR(row, &mappingptr, "min", 0, "", ICON_NONE);
row= uiLayoutRow(layout, 1);
uiItemR(row, ptr, "use_max", 0, "Max", ICON_NONE);
uiItemR(row, ptr, "max", 0, "", ICON_NONE);
uiItemR(row, &mappingptr, "use_max", 0, "Max", ICON_NONE);
uiItemR(row, &mappingptr, "max", 0, "", ICON_NONE);
#endif
}

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

@@ -108,7 +108,8 @@ void ED_node_changed_update(ID *id, bNode *node)
WM_main_add_notifier(NC_WORLD|ND_WORLD_DRAW, id);
}
else if(treetype==NTREE_COMPOSIT) {
nodeUpdate(edittree, node);
if(node)
nodeUpdate(edittree, node);
/* don't use NodeTagIDChanged, it gives far too many recomposites for image, scene layers, ... */
node= node_tree_get_editgroup(nodetree);

20
source/blender/editors/space_view3d/drawmesh.c
View File

@@ -40,11 +40,12 @@
#include "DNA_material_types.h"
#include "DNA_meshdata_types.h"
#include "DNA_node_types.h"
#include "DNA_object_types.h"
#include "DNA_property_types.h"
#include "DNA_scene_types.h"
#include "DNA_screen_types.h"
#include "DNA_view3d_types.h"
#include "DNA_object_types.h"
#include "BKE_DerivedMesh.h"
#include "BKE_effect.h"
@@ -703,16 +704,19 @@ static void tex_mat_set_texture_cb(void *userData, int mat_nr, void *attribs)
GPUVertexAttribs *gattribs = attribs;
Image *ima;
ImageUser *iuser;
bNode *node;
int texture_set= 0;
/* draw image texture if we find one */
if(ED_object_get_active_image(data->ob, mat_nr, &ima, &iuser)) {
if(ED_object_get_active_image(data->ob, mat_nr, &ima, &iuser, &node)) {
/* get openl texture */
int mipmap= 1;
int bindcode= (ima)? GPU_verify_image(ima, iuser, 0, 0, mipmap): 0;
float zero[4] = {0.0f, 0.0f, 0.0f, 0.0f};
if(bindcode) {
NodeTexBase *texbase= node->storage;
/* disable existing material */
GPU_disable_material();
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, zero);
@@ -726,6 +730,10 @@ static void tex_mat_set_texture_cb(void *userData, int mat_nr, void *attribs)
glBindTexture(GL_TEXTURE_2D, ima->bindcode);
glColor3f(1.0f, 1.0f, 1.0f);
glMatrixMode(GL_TEXTURE);
glLoadMatrixf(texbase->tex_mapping.mat);
glMatrixMode(GL_MODELVIEW);
/* use active UV texture layer */
memset(gattribs, 0, sizeof(*gattribs));
@@ -739,6 +747,10 @@ static void tex_mat_set_texture_cb(void *userData, int mat_nr, void *attribs)
}
if(!texture_set) {
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
/* disable texture */
glDisable(GL_TEXTURE_2D);
glDisable(GL_COLOR_MATERIAL);
@@ -834,6 +846,10 @@ void draw_mesh_textured(Scene *scene, View3D *v3d, RegionView3D *rv3d, Object *o
glBindTexture(GL_TEXTURE_2D, 0);
glFrontFace(GL_CCW);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
/* faceselect mode drawing over textured mesh */
if(!(ob == scene->obedit) && faceselect)
draw_mesh_face_select(rv3d, ob->data, dm);

4
source/blender/editors/uvedit/uvedit_ops.c
View File

@@ -101,7 +101,7 @@ static int is_image_texture_node(bNode *node)
return ELEM(node->type, SH_NODE_TEX_IMAGE, SH_NODE_TEX_ENVIRONMENT);
}
int ED_object_get_active_image(Object *ob, int mat_nr, Image **ima, ImageUser **iuser)
int ED_object_get_active_image(Object *ob, int mat_nr, Image **ima, ImageUser **iuser, bNode **node_r)
{
Material *ma= give_current_material(ob, mat_nr);
bNode *node= (ma && ma->use_nodes)? nodeGetActiveTexture(ma->nodetree): NULL;
@@ -109,11 +109,13 @@ int ED_object_get_active_image(Object *ob, int mat_nr, Image **ima, ImageUser **
if(node && is_image_texture_node(node)) {
if(ima) *ima= (Image*)node->id;
if(iuser) *iuser= NULL;
if(node_r) *node_r= node;
return TRUE;
}
if(ima) *ima= NULL;
if(iuser) *iuser= NULL;
if(node_r) *node_r= node;
return FALSE;
}

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

@@ -35,6 +35,7 @@
#include "DNA_ID.h"
#include "DNA_vec_types.h"
#include "DNA_listBase.h"
#include "DNA_texture_types.h"
struct ID;
struct ListBase;
@@ -426,25 +427,39 @@ typedef struct NodeColorspill {
float uspillr, uspillg, uspillb;
}NodeColorspill;
typedef struct NodeTexBase {
TexMapping tex_mapping;
ColorMapping color_mapping;
} NodeTexBase;
typedef struct NodeTexNoise {
NodeTexBase base;
} NodeTexNoise;
typedef struct NodeTexSky {
NodeTexBase base;
float sun_direction[3];
float turbidity;
} NodeTexSky;
typedef struct NodeTexImage {
NodeTexBase base;
int color_space;
} NodeTexImage;
typedef struct NodeTexEnvironment {
NodeTexBase base;
int color_space;
} NodeTexEnvironment;
typedef struct NodeTexBlend {
NodeTexBase base;
int progression;
int axis;
} NodeTexBlend;
typedef struct NodeTexClouds {
NodeTexBase base;
int hard;
int depth;
int basis;
@@ -452,16 +467,19 @@ typedef struct NodeTexClouds {
} NodeTexClouds;
typedef struct NodeTexVoronoi {
NodeTexBase base;
int distance_metric;
int coloring;
} NodeTexVoronoi;
typedef struct NodeTexMusgrave {
NodeTexBase base;
int type;
int basis;
} NodeTexMusgrave;
typedef struct NodeTexMarble {
NodeTexBase base;
int type;
int wave;
int basis;
@@ -471,11 +489,13 @@ typedef struct NodeTexMarble {
} NodeTexMarble;
typedef struct NodeTexMagic {
NodeTexBase base;
int depth;
int pad;
} NodeTexMagic;
typedef struct NodeTexStucci {
NodeTexBase base;
int type;
int basis;
int hard;
@@ -483,11 +503,13 @@ typedef struct NodeTexStucci {
} NodeTexStucci;
typedef struct NodeTexDistortedNoise {
NodeTexBase base;
int basis;
int distortion_basis;
} NodeTexDistortedNoise;
typedef struct NodeTexWood {
NodeTexBase base;
int type;
int wave;
int basis;

24
source/blender/makesdna/DNA_texture_types.h
View File

@@ -267,11 +267,13 @@ typedef struct Tex {
} Tex;
/* used for mapping node. note: rot is in degrees */
/* used for mapping and texture nodes. note: rot is in degrees */
typedef struct TexMapping {
float loc[3], rot[3], size[3];
int flag;
char projx, projy, projz, mapping;
int pad;
float mat[4][4];
float min[3], max[3];
@@ -279,10 +281,24 @@ typedef struct TexMapping {
} TexMapping;
/* texmap->flag */
#define TEXMAP_CLIP_MIN 1
#define TEXMAP_CLIP_MAX 2
typedef struct ColorMapping {
struct ColorBand coba;
float bright, contrast, saturation;
int flag;
float blend_color[3];
float blend_factor;
int blend_type, pad[3];
} ColorMapping;
/* texmap->flag */
#define TEXMAP_CLIP_MIN 1
#define TEXMAP_CLIP_MAX 2
#define TEXMAP_UNIT_MATRIX 4
/* colormap->flag */
#define COLORMAP_USE_RAMP 1
/* **************** TEX ********************* */

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

@@ -446,15 +446,6 @@ static void rna_NodeSocketVector_range(PointerRNA *ptr, float *min, float *max)
*max = val->max;
}
static void rna_Node_mapping_update(Main *bmain, Scene *scene, PointerRNA *ptr)
{
bNode *node= (bNode*)ptr->data;
init_mapping((TexMapping *)node->storage);
rna_Node_update(bmain, scene, ptr);
}
static void rna_Node_image_layer_update(Main *bmain, Scene *scene, PointerRNA *ptr)
{
bNode *node= (bNode*)ptr->data;
@@ -1104,48 +1095,12 @@ static void def_sh_material(StructRNA *srna)
static void def_sh_mapping(StructRNA *srna)
{
PropertyRNA *prop;
RNA_def_struct_sdna_from(srna, "TexMapping", "storage");
prop= RNA_def_property(srna, "location", PROP_FLOAT, PROP_TRANSLATION);
RNA_def_property_float_sdna(prop, NULL, "loc");
RNA_def_property_ui_text(prop, "Location", "Location offset for the input coordinate");
RNA_def_property_ui_range(prop, -10.f, 10.f, 0.1f, 2);
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_mapping_update");
prop= RNA_def_property(srna, "rotation", PROP_FLOAT, PROP_XYZ); /* Not PROP_EUL, this is already in degrees, not radians */
RNA_def_property_float_sdna(prop, NULL, "rot");
RNA_def_property_ui_text(prop, "Rotation", "Rotation offset for the input coordinate");
RNA_def_property_ui_range(prop, -360.f, 360.f, 1.f, 2);
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_mapping_update");
prop= RNA_def_property(srna, "scale", PROP_FLOAT, PROP_XYZ);
RNA_def_property_float_sdna(prop, NULL, "size");
RNA_def_property_ui_text(prop, "Scale", "Scale adjustment for the input coordinate");
RNA_def_property_ui_range(prop, -10.f, 10.f, 0.1f, 2);
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_mapping_update");
prop = RNA_def_property(srna, "use_min", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MIN);
RNA_def_property_ui_text(prop, "Clamp Minimum", "Clamp the output coordinate to a minimum value");
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
prop= RNA_def_property(srna, "min", PROP_FLOAT, PROP_XYZ);
RNA_def_property_float_sdna(prop, NULL, "min");
RNA_def_property_ui_text(prop, "Minimum", "Minimum value to clamp coordinate to");
RNA_def_property_ui_range(prop, -10.f, 10.f, 0.1f, 2);
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
prop = RNA_def_property(srna, "use_max", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MAX);
RNA_def_property_ui_text(prop, "Clamp Maximum", "Clamp the output coordinate to a maximum value");
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
prop= RNA_def_property(srna, "max", PROP_FLOAT, PROP_XYZ);
RNA_def_property_float_sdna(prop, NULL, "max");
RNA_def_property_ui_text(prop, "Maximum", "Maximum value to clamp coordinate to");
RNA_def_property_ui_range(prop, -10.f, 10.f, 0.1f, 2);
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
prop= RNA_def_property(srna, "mapping", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_sdna(prop, NULL, "storage");
RNA_def_property_struct_type(prop, "TexMapping");
RNA_def_property_flag(prop, PROP_NEVER_NULL);
RNA_def_property_ui_text(prop, "Mapping", "Texture coordinate mapping settings");
}
static void def_sh_geometry(StructRNA *srna)
@@ -1177,11 +1132,33 @@ static void def_sh_attribute(StructRNA *srna)
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
}
static void def_sh_tex(StructRNA *srna)
{
PropertyRNA *prop;
prop= RNA_def_property(srna, "texture_mapping", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_sdna(prop, NULL, "base.tex_mapping");
RNA_def_property_flag(prop, PROP_NEVER_NULL);
RNA_def_property_ui_text(prop, "Texture Mapping", "Texture coordinate mapping settings");
prop= RNA_def_property(srna, "color_mapping", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_sdna(prop, NULL, "base.color_mapping");
RNA_def_property_flag(prop, PROP_NEVER_NULL);
RNA_def_property_ui_text(prop, "Color Mapping", "Color mapping settings");
}
static void def_sh_tex_noise(StructRNA *srna)
{
RNA_def_struct_sdna_from(srna, "NodeTexNoise", "storage");
def_sh_tex(srna);
}
static void def_sh_tex_sky(StructRNA *srna)
{
PropertyRNA *prop;
RNA_def_struct_sdna_from(srna, "NodeTexSky", "storage");
def_sh_tex(srna);
prop = RNA_def_property(srna, "sun_direction", PROP_FLOAT, PROP_DIRECTION);
RNA_def_property_ui_text(prop, "Sun Direction", "Direction from where the sun is shining");
@@ -1209,6 +1186,7 @@ static void def_sh_tex_environment(StructRNA *srna)
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
RNA_def_struct_sdna_from(srna, "NodeTexImage", "storage");
def_sh_tex(srna);
prop= RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_items(prop, prop_color_space_items);
@@ -1233,6 +1211,7 @@ static void def_sh_tex_image(StructRNA *srna)
RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
RNA_def_struct_sdna_from(srna, "NodeTexImage", "storage");
def_sh_tex(srna);
prop= RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_items(prop, prop_color_space_items);
@@ -1260,6 +1239,7 @@ static void def_sh_tex_blend(StructRNA *srna)
PropertyRNA *prop;
RNA_def_struct_sdna_from(srna, "NodeTexBlend", "storage");
def_sh_tex(srna);
prop= RNA_def_property(srna, "progression", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "progression");
@@ -1279,6 +1259,7 @@ static void def_sh_tex_clouds(StructRNA *srna)
PropertyRNA *prop;
RNA_def_struct_sdna_from(srna, "NodeTexClouds", "storage");
def_sh_tex(srna);
prop= RNA_def_property(srna, "noise_basis", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "basis");
@@ -1304,6 +1285,7 @@ static void def_sh_tex_distnoise(StructRNA *srna)
PropertyRNA *prop;
RNA_def_struct_sdna_from(srna, "NodeTexDistortedNoise", "storage");
def_sh_tex(srna);
prop= RNA_def_property(srna, "noise_basis", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "basis");
@@ -1323,6 +1305,7 @@ static void def_sh_tex_magic(StructRNA *srna)
PropertyRNA *prop;
RNA_def_struct_sdna_from(srna, "NodeTexMagic", "storage");
def_sh_tex(srna);
prop= RNA_def_property(srna, "turbulence_depth", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, NULL, "depth");
@@ -1342,6 +1325,7 @@ static void def_sh_tex_marble(StructRNA *srna)
PropertyRNA *prop;
RNA_def_struct_sdna_from(srna, "NodeTexMarble", "storage");
def_sh_tex(srna);
prop= RNA_def_property(srna, "marble_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "type");
@@ -1387,6 +1371,7 @@ static void def_sh_tex_musgrave(StructRNA *srna)
PropertyRNA *prop;
RNA_def_struct_sdna_from(srna, "NodeTexMusgrave", "storage");
def_sh_tex(srna);
prop= RNA_def_property(srna, "musgrave_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "type");
@@ -1412,6 +1397,7 @@ static void def_sh_tex_stucci(StructRNA *srna)
PropertyRNA *prop;
RNA_def_struct_sdna_from(srna, "NodeTexStucci", "storage");
def_sh_tex(srna);
prop= RNA_def_property(srna, "stucci_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "type");
@@ -1454,6 +1440,7 @@ static void def_sh_tex_voronoi(StructRNA *srna)
PropertyRNA *prop;
RNA_def_struct_sdna_from(srna, "NodeTexVoronoi", "storage");
def_sh_tex(srna);
prop= RNA_def_property(srna, "distance_metric", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "distance_metric");
@@ -1480,6 +1467,7 @@ static void def_sh_tex_wood(StructRNA *srna)
PropertyRNA *prop;
RNA_def_struct_sdna_from(srna, "NodeTexWood", "storage");
def_sh_tex(srna);
prop= RNA_def_property(srna, "noise_basis", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "basis");

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

@@ -79,7 +79,7 @@ DefNode( ShaderNode, SH_NODE_GEOMETRY, 0, "GE
DefNode( ShaderNode, SH_NODE_LIGHT_PATH, 0, "LIGHT_PATH", Light_path, "Light_path", "")
DefNode( ShaderNode, SH_NODE_TEX_IMAGE, def_sh_tex_image, "TEX_IMAGE", TexImage, "Image Texture", "")
DefNode( ShaderNode, SH_NODE_TEX_ENVIRONMENT, def_sh_tex_environment, "TEX_ENVIRONMENT", TexEnvironment, "Environment Texture", "")
DefNode( ShaderNode, SH_NODE_TEX_NOISE, 0, "TEX_NOISE", TexNoise, "Noise Texture", "")
DefNode( ShaderNode, SH_NODE_TEX_NOISE, def_sh_tex_noise, "TEX_NOISE", TexNoise, "Noise Texture", "")
DefNode( ShaderNode, SH_NODE_TEX_SKY, def_sh_tex_sky, "TEX_SKY", TexSky, "Sky Texture", "")
DefNode( ShaderNode, SH_NODE_TEX_BLEND, def_sh_tex_blend, "TEX_BLEND", TexBlend, "Blend Texture", "")
DefNode( ShaderNode, SH_NODE_TEX_CLOUDS, def_sh_tex_clouds, "TEX_CLOUDS", TexClouds, "Clouds Texture", "")

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

@@ -114,13 +114,14 @@ EnumPropertyItem viewport_shade_items[] = {
#include "BLI_math.h"
#include "BKE_screen.h"
#include "BKE_animsys.h"
#include "BKE_brush.h"
#include "BKE_colortools.h"
#include "BKE_context.h"
#include "BKE_depsgraph.h"
#include "BKE_paint.h"
#include "BKE_scene.h"
#include "BKE_screen.h"
#include "ED_image.h"
#include "ED_node.h"
@@ -458,11 +459,12 @@ static EnumPropertyItem *rna_SpaceView3D_viewport_shade_itemf(bContext *UNUSED(C
RNA_enum_items_add_value(&item, &totitem, viewport_shade_items, OB_WIRE);
RNA_enum_items_add_value(&item, &totitem, viewport_shade_items, OB_SOLID);
RNA_enum_items_add_value(&item, &totitem, viewport_shade_items, OB_TEXTURE);
RNA_enum_items_add_value(&item, &totitem, viewport_shade_items, OB_MATERIAL);
if(scene_use_new_shading_nodes(scene))
RNA_enum_items_add_value(&item, &totitem, viewport_shade_items, OB_MATERIAL);
if(type->view_draw) {
if(type->view_draw)
RNA_enum_items_add_value(&item, &totitem, viewport_shade_items, OB_RENDER);
}
RNA_enum_item_end(&item, &totitem);
*free= 1;

176
source/blender/makesrna/intern/rna_texture.c
View File

@@ -75,6 +75,25 @@ EnumPropertyItem texture_type_items[] = {
{TEX_WOOD, "WOOD", ICON_TEXTURE, "Wood", "Procedural - Wave generated bands or rings, with optional noise"},
{0, NULL, 0, NULL, NULL}};
EnumPropertyItem blend_type_items[] = {
{MTEX_BLEND, "MIX", 0, "Mix", ""},
{MTEX_ADD, "ADD", 0, "Add", ""},
{MTEX_SUB, "SUBTRACT", 0, "Subtract", ""},
{MTEX_MUL, "MULTIPLY", 0, "Multiply", ""},
{MTEX_SCREEN, "SCREEN", 0, "Screen", ""},
{MTEX_OVERLAY, "OVERLAY", 0, "Overlay", ""},
{MTEX_DIFF, "DIFFERENCE", 0, "Difference", ""},
{MTEX_DIV, "DIVIDE", 0, "Divide", ""},
{MTEX_DARK, "DARKEN", 0, "Darken", ""},
{MTEX_LIGHT, "LIGHTEN", 0, "Lighten", ""},
{MTEX_BLEND_HUE, "HUE", 0, "Hue", ""},
{MTEX_BLEND_SAT, "SATURATION", 0, "Saturation", ""},
{MTEX_BLEND_VAL, "VALUE", 0, "Value", ""},
{MTEX_BLEND_COLOR, "COLOR", 0, "Color", ""},
{MTEX_SOFT_LIGHT, "SOFT_LIGHT", 0, "Soft Light", ""},
{MTEX_LIN_LIGHT , "LINEAR_LIGHT", 0, "Linear Light", ""},
{0, NULL, 0, NULL, NULL}};
#ifdef RNA_RUNTIME
#include "MEM_guardedalloc.h"
@@ -131,13 +150,33 @@ static StructRNA *rna_Texture_refine(struct PointerRNA *ptr)
}
}
static void rna_Texture_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
static void rna_Texture_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
{
Tex *tex= ptr->id.data;
ID *id= ptr->id.data;
DAG_id_tag_update(&tex->id, 0);
WM_main_add_notifier(NC_TEXTURE, tex);
WM_main_add_notifier(NC_MATERIAL|ND_SHADING_DRAW, NULL);
if(GS(id->name) == ID_TE) {
Tex *tex= ptr->id.data;
DAG_id_tag_update(&tex->id, 0);
WM_main_add_notifier(NC_TEXTURE, tex);
WM_main_add_notifier(NC_MATERIAL|ND_SHADING_DRAW, NULL);
}
else if(GS(id->name) == ID_NT) {
bNodeTree *ntree= ptr->id.data;
ED_node_generic_update(bmain, ntree, NULL);
}
}
static void rna_Texture_mapping_update(Main *bmain, Scene *scene, PointerRNA *ptr)
{
TexMapping *texmap = ptr->data;
init_tex_mapping(texmap);
rna_Texture_update(bmain, scene, ptr);
}
static void rna_Color_mapping_update(Main *bmain, Scene *scene, PointerRNA *ptr)
{
/* nothing to do */
}
static void rna_Texture_voxeldata_update(Main *bmain, Scene *scene, PointerRNA *ptr)
@@ -400,46 +439,133 @@ static char *rna_VoxelData_path(PointerRNA *UNUSED(ptr))
static void rna_def_texmapping(BlenderRNA *brna)
{
static EnumPropertyItem prop_mapping_items[] = {
{MTEX_FLAT, "FLAT", 0, "Flat", "Map X and Y coordinates directly"},
{MTEX_CUBE, "CUBE", 0, "Cube", "Map using the normal vector"},
{MTEX_TUBE, "TUBE", 0, "Tube", "Map with Z as central axis"},
{MTEX_SPHERE, "SPHERE", 0, "Sphere", "Map with Z as central axis"},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_xyz_mapping_items[] = {
{0, "NONE", 0, "None", ""},
{1, "X", 0, "X", ""},
{2, "Y", 0, "Y", ""},
{3, "Z", 0, "Z", ""},
{0, NULL, 0, NULL, NULL}};
StructRNA *srna;
PropertyRNA *prop;
srna= RNA_def_struct(brna, "TexMapping", NULL);
RNA_def_struct_ui_text(srna, "Texture Mapping", "Mapping settings");
RNA_def_struct_ui_text(srna, "Texture Mapping", "Texture coordinate mapping settings");
prop= RNA_def_property(srna, "location", PROP_FLOAT, PROP_TRANSLATION);
RNA_def_property_float_sdna(prop, NULL, "loc");
RNA_def_property_ui_text(prop, "Location", "");
RNA_def_property_update(prop, 0, "rna_Texture_update");
RNA_def_property_update(prop, 0, "rna_Texture_mapping_update");
prop= RNA_def_property(srna, "rotation", PROP_FLOAT, PROP_EULER);
prop= RNA_def_property(srna, "rotation", PROP_FLOAT, PROP_XYZ); /* Not PROP_EUL, this is already in degrees, not radians */
RNA_def_property_float_sdna(prop, NULL, "rot");
RNA_def_property_ui_text(prop, "Rotation", "");
RNA_def_property_update(prop, 0, "rna_Texture_update");
RNA_def_property_update(prop, 0, "rna_Texture_mapping_update");
prop= RNA_def_property(srna, "scale", PROP_FLOAT, PROP_XYZ);
RNA_def_property_float_sdna(prop, NULL, "size");
RNA_def_property_ui_text(prop, "Scale", "");
RNA_def_property_update(prop, 0, "rna_Texture_update");
RNA_def_property_update(prop, 0, "rna_Texture_mapping_update");
prop= RNA_def_property(srna, "min", PROP_FLOAT, PROP_XYZ);
RNA_def_property_float_sdna(prop, NULL, "min");
RNA_def_property_ui_text(prop, "Minimum", "Minimum value for clipping");
RNA_def_property_update(prop, 0, "rna_Texture_update");
RNA_def_property_update(prop, 0, "rna_Texture_mapping_update");
prop= RNA_def_property(srna, "max", PROP_FLOAT, PROP_XYZ);
RNA_def_property_float_sdna(prop, NULL, "max");
RNA_def_property_ui_text(prop, "Maximum", "Maximum value for clipping");
RNA_def_property_update(prop, 0, "rna_Texture_update");
RNA_def_property_update(prop, 0, "rna_Texture_mapping_update");
prop= RNA_def_property(srna, "use_min", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MIN);
RNA_def_property_ui_text(prop, "Has Minimum", "Whether to use minimum clipping value");
RNA_def_property_update(prop, 0, "rna_Texture_update");
RNA_def_property_update(prop, 0, "rna_Texture_mapping_update");
prop= RNA_def_property(srna, "use_max", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", TEXMAP_CLIP_MAX);
RNA_def_property_ui_text(prop, "Has Maximum", "Whether to use maximum clipping value");
RNA_def_property_update(prop, 0, "rna_Texture_update");
RNA_def_property_update(prop, 0, "rna_Texture_mapping_update");
prop= RNA_def_property(srna, "mapping_x", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "projx");
RNA_def_property_enum_items(prop, prop_xyz_mapping_items);
RNA_def_property_ui_text(prop, "X Mapping", "");
RNA_def_property_update(prop, 0, "rna_Texture_mapping_update");
prop= RNA_def_property(srna, "mapping_y", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "projy");
RNA_def_property_enum_items(prop, prop_xyz_mapping_items);
RNA_def_property_ui_text(prop, "Y Mapping", "");
RNA_def_property_update(prop, 0, "rna_Texture_mapping_update");
prop= RNA_def_property(srna, "mapping_z", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "projz");
RNA_def_property_enum_items(prop, prop_xyz_mapping_items);
RNA_def_property_ui_text(prop, "Z Mapping", "");
RNA_def_property_update(prop, 0, "rna_Texture_mapping_update");
prop= RNA_def_property(srna, "mapping", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_items(prop, prop_mapping_items);
RNA_def_property_ui_text(prop, "Mapping", "");
RNA_def_property_update(prop, 0, "rna_Texture_mapping_update");
}
static void rna_def_colormapping(BlenderRNA *brna)
{
StructRNA *srna;
PropertyRNA *prop;
srna= RNA_def_struct(brna, "ColorMapping", NULL);
RNA_def_struct_ui_text(srna, "Color Mapping", "Color mapping settings");
prop= RNA_def_property(srna, "use_color_ramp", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", COLORMAP_USE_RAMP);
RNA_def_property_ui_text(prop, "Use Color Ramp", "Toggle color ramp operations");
RNA_def_property_update(prop, 0, "rna_Color_mapping_update");
prop= RNA_def_property(srna, "color_ramp", PROP_POINTER, PROP_NEVER_NULL);
RNA_def_property_pointer_sdna(prop, NULL, "coba");
RNA_def_property_struct_type(prop, "ColorRamp");
RNA_def_property_ui_text(prop, "Color Ramp", "");
RNA_def_property_update(prop, 0, "rna_Color_mapping_update");
prop= RNA_def_property(srna, "brightness", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "bright");
RNA_def_property_range(prop, 0, 2);
RNA_def_property_ui_text(prop, "Brightness", "Adjust the brightness of the texture");
RNA_def_property_update(prop, 0, "rna_Color_mapping_update");
prop= RNA_def_property(srna, "contrast", PROP_FLOAT, PROP_NONE);
RNA_def_property_range(prop, 0.01, 5);
RNA_def_property_ui_text(prop, "Contrast", "Adjust the contrast of the texture");
RNA_def_property_update(prop, 0, "rna_Color_mapping_update");
prop= RNA_def_property(srna, "saturation", PROP_FLOAT, PROP_NONE);
RNA_def_property_range(prop, 0, 2);
RNA_def_property_ui_text(prop, "Saturation", "Adjust the saturation of colors in the texture");
RNA_def_property_update(prop, 0, "rna_Color_mapping_update");
prop= RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_items(prop, blend_type_items);
RNA_def_property_ui_text(prop, "Blend Type", "Mode used to mix with texture output color");
RNA_def_property_update(prop, 0, "rna_Color_mapping_update");
prop= RNA_def_property(srna, "blend_color", PROP_FLOAT, PROP_COLOR);
RNA_def_property_array(prop, 3);
RNA_def_property_ui_text(prop, "Color", "Blend color to mix with texture output color");
RNA_def_property_update(prop, 0, "rna_Color_mapping_update");
prop= RNA_def_property(srna, "blend_factor", PROP_FLOAT, PROP_NONE);
RNA_def_property_ui_text(prop, "Blend Factor", "");
RNA_def_property_update(prop, 0, "rna_Color_mapping_update");
}
static void rna_def_mtex(BlenderRNA *brna)
@@ -447,25 +573,6 @@ static void rna_def_mtex(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem prop_blend_type_items[] = {
{MTEX_BLEND, "MIX", 0, "Mix", ""},
{MTEX_ADD, "ADD", 0, "Add", ""},
{MTEX_SUB, "SUBTRACT", 0, "Subtract", ""},
{MTEX_MUL, "MULTIPLY", 0, "Multiply", ""},
{MTEX_SCREEN, "SCREEN", 0, "Screen", ""},
{MTEX_OVERLAY, "OVERLAY", 0, "Overlay", ""},
{MTEX_DIFF, "DIFFERENCE", 0, "Difference", ""},
{MTEX_DIV, "DIVIDE", 0, "Divide", ""},
{MTEX_DARK, "DARKEN", 0, "Darken", ""},
{MTEX_LIGHT, "LIGHTEN", 0, "Lighten", ""},
{MTEX_BLEND_HUE, "HUE", 0, "Hue", ""},
{MTEX_BLEND_SAT, "SATURATION", 0, "Saturation", ""},
{MTEX_BLEND_VAL, "VALUE", 0, "Value", ""},
{MTEX_BLEND_COLOR, "COLOR", 0, "Color", ""},
{MTEX_SOFT_LIGHT, "SOFT_LIGHT", 0, "Soft Light", ""},
{MTEX_LIN_LIGHT , "LINEAR_LIGHT", 0, "Linear Light", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem output_node_items[] = {
{0, "DUMMY", 0, "Dummy", ""},
{0, NULL, 0, NULL, NULL}};
@@ -512,7 +619,7 @@ static void rna_def_mtex(BlenderRNA *brna)
prop= RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "blendtype");
RNA_def_property_enum_items(prop, prop_blend_type_items);
RNA_def_property_enum_items(prop, blend_type_items);
RNA_def_property_ui_text(prop, "Blend Type", "Mode used to apply the texture");
RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
@@ -1866,6 +1973,7 @@ void RNA_def_texture(BlenderRNA *brna)
rna_def_mtex(brna);
rna_def_environment_map(brna);
rna_def_texmapping(brna);
rna_def_colormapping(brna);
}
#endif

2
source/blender/nodes/composite/nodes/node_composite_mapValue.c
View File

@@ -79,7 +79,7 @@ static void node_composit_exec_map_value(void *UNUSED(data), bNode *node, bNodeS
static void node_composit_init_map_value(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
node->storage= add_mapping();
node->storage= add_tex_mapping();
}
void register_node_type_cmp_map_value(ListBase *lb)

21
source/blender/nodes/shader/node_shader_util.c
View File

@@ -308,3 +308,24 @@ void ntreeExecGPUNodes(bNodeTreeExec *exec, GPUMaterial *mat, int do_outputs)
}
}
}
void node_shader_gpu_tex_mapping(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *UNUSED(out))
{
NodeTexBase *base= node->storage;
TexMapping *texmap= &base->tex_mapping;
float domin= (texmap->flag & TEXMAP_CLIP_MIN) != 0;
float domax= (texmap->flag & TEXMAP_CLIP_MAX) != 0;
if(domin || domax || !(texmap->flag & TEXMAP_UNIT_MATRIX)) {
GPUNodeLink *tmat = GPU_uniform((float*)texmap->mat);
GPUNodeLink *tmin = GPU_uniform(texmap->min);
GPUNodeLink *tmax = GPU_uniform(texmap->max);
GPUNodeLink *tdomin = GPU_uniform(&domin);
GPUNodeLink *tdomax = GPU_uniform(&domax);
GPU_link(mat, "mapping", in[0].link, tmat, tmin, tmax, tdomin, tdomax, &in[0].link);
}
else
printf("skip mapping!\n");
}

1
source/blender/nodes/shader/node_shader_util.h
View File

@@ -128,6 +128,7 @@ void nodestack_get_vec(float *in, short type_in, bNodeStack *ns);
void node_gpu_stack_from_data(struct GPUNodeStack *gs, int type, struct bNodeStack *ns);
void node_data_from_gpu_stack(struct bNodeStack *ns, struct GPUNodeStack *gs);
void node_shader_gpu_tex_mapping(struct GPUMaterial *mat, struct bNode *node, struct GPUNodeStack *in, struct GPUNodeStack *out);
void ntreeExecGPUNodes(struct bNodeTreeExec *exec, struct GPUMaterial *mat, int do_outputs);

6
source/blender/nodes/shader/nodes/node_shader_mapping.c
View File

@@ -67,9 +67,9 @@ static void node_shader_exec_mapping(void *UNUSED(data), bNode *node, bNodeStack
}
static void node_shader_init_mapping(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
static void node_shader_default_mapping(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
node->storage= add_mapping();
node->storage= add_tex_mapping();
}
static int gpu_shader_mapping(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out)
@@ -94,7 +94,7 @@ void register_node_type_sh_mapping(ListBase *lb)
node_type_compatibility(&ntype, NODE_OLD_SHADING|NODE_NEW_SHADING);
node_type_socket_templates(&ntype, sh_node_mapping_in, sh_node_mapping_out);
node_type_size(&ntype, 240, 160, 320);
node_type_init(&ntype, node_shader_init_mapping);
node_type_init(&ntype, node_shader_default_mapping);
node_type_storage(&ntype, "TexMapping", node_free_standard_storage, node_copy_standard_storage);
node_type_exec(&ntype, node_shader_exec_mapping);
node_type_gpu(&ntype, gpu_shader_mapping);

6
source/blender/nodes/shader/nodes/node_shader_tex_blend.c
View File

@@ -88,6 +88,8 @@ static bNodeSocketTemplate sh_node_tex_blend_out[]= {
static void node_shader_init_tex_blend(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeTexBlend *tex = MEM_callocN(sizeof(NodeTexBlend), "NodeTexBlend");
default_tex_mapping(&tex->base.tex_mapping);
default_color_mapping(&tex->base.color_mapping);
tex->progression = SHD_BLEND_LINEAR;
tex->axis = SHD_BLEND_HORIZONTAL;
@@ -109,11 +111,13 @@ static void node_shader_exec_tex_blend(void *data, bNode *node, bNodeStack **in,
out[0]->vec[0]= blend(vec, tex->progression, tex->axis);
}
static int node_shader_gpu_tex_blend(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out)
static int node_shader_gpu_tex_blend(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out)
{
if(!in[0].link)
in[0].link = GPU_attribute(CD_ORCO, "");
node_shader_gpu_tex_mapping(mat, node, in, out);
return GPU_stack_link(mat, "node_tex_blend", in, out);
}

6
source/blender/nodes/shader/nodes/node_shader_tex_clouds.c
View File

@@ -68,6 +68,8 @@ static bNodeSocketTemplate sh_node_tex_clouds_out[]= {
static void node_shader_init_tex_clouds(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeTexClouds *tex = MEM_callocN(sizeof(NodeTexClouds), "NodeTexClouds");
default_tex_mapping(&tex->base.tex_mapping);
default_color_mapping(&tex->base.color_mapping);
tex->basis = SHD_NOISE_PERLIN;
tex->hard = 0;
tex->depth = 2;
@@ -92,11 +94,13 @@ static void node_shader_exec_tex_clouds(void *data, bNode *node, bNodeStack **in
out[1]->vec[0]= clouds(tex->basis, tex->hard, tex->depth, size, vec, out[0]->vec);
}
static int node_shader_gpu_tex_clouds(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out)
static int node_shader_gpu_tex_clouds(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out)
{
if(!in[0].link)
in[0].link = GPU_attribute(CD_ORCO, "");
node_shader_gpu_tex_mapping(mat, node, in, out);
return GPU_stack_link(mat, "node_tex_clouds", in, out);
}

6
source/blender/nodes/shader/nodes/node_shader_tex_distnoise.c
View File

@@ -65,6 +65,8 @@ static bNodeSocketTemplate sh_node_tex_distnoise_out[]= {
static void node_shader_init_tex_distorted_noise(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeTexDistortedNoise *tex = MEM_callocN(sizeof(NodeTexDistortedNoise), "NodeTexDistortedNoise");
default_tex_mapping(&tex->base.tex_mapping);
default_color_mapping(&tex->base.color_mapping);
tex->basis = SHD_NOISE_PERLIN;
tex->distortion_basis = SHD_NOISE_PERLIN;
@@ -89,11 +91,13 @@ static void node_shader_exec_tex_distnoise(void *data, bNode *node, bNodeStack *
out[0]->vec[0]= distorted_noise(vec, size, tex->basis, tex->distortion_basis, distortion);
}
static int node_shader_gpu_tex_distnoise(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out)
static int node_shader_gpu_tex_distnoise(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out)
{
if(!in[0].link)
in[0].link = GPU_attribute(CD_ORCO, "");
node_shader_gpu_tex_mapping(mat, node, in, out);
return GPU_stack_link(mat, "node_tex_distnoise", in, out);
}

4
source/blender/nodes/shader/nodes/node_shader_tex_environment.c
View File

@@ -44,6 +44,8 @@ static bNodeSocketTemplate sh_node_tex_environment_out[]= {
static void node_shader_init_tex_environment(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeTexEnvironment *tex = MEM_callocN(sizeof(NodeTexEnvironment), "NodeTexEnvironment");
default_tex_mapping(&tex->base.tex_mapping);
default_color_mapping(&tex->base.color_mapping);
tex->color_space = SHD_COLORSPACE_SRGB;
node->storage = tex;
@@ -94,6 +96,8 @@ static int node_shader_gpu_tex_environment(GPUMaterial *mat, bNode *node, GPUNod
if(!in[0].link)
in[0].link = GPU_builtin(GPU_VIEW_POSITION);
node_shader_gpu_tex_mapping(mat, node, in, out);
return GPU_stack_link(mat, "node_tex_environment", in, out, GPU_image(ima, iuser));
}

4
source/blender/nodes/shader/nodes/node_shader_tex_image.c
View File

@@ -44,6 +44,8 @@ static bNodeSocketTemplate sh_node_tex_image_out[]= {
static void node_shader_init_tex_image(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeTexImage *tex = MEM_callocN(sizeof(NodeTexImage), "NodeTexImage");
default_tex_mapping(&tex->base.tex_mapping);
default_color_mapping(&tex->base.color_mapping);
tex->color_space = SHD_COLORSPACE_SRGB;
node->storage = tex;
@@ -92,6 +94,8 @@ static int node_shader_gpu_tex_image(GPUMaterial *mat, bNode *node, GPUNodeStack
if(!in[0].link)
in[0].link = GPU_attribute(CD_MTFACE, "");
node_shader_gpu_tex_mapping(mat, node, in, out);
return GPU_stack_link(mat, "node_tex_image", in, out, GPU_image(ima, iuser));
}

4
source/blender/nodes/shader/nodes/node_shader_tex_magic.c
View File

@@ -118,6 +118,8 @@ static bNodeSocketTemplate sh_node_tex_magic_out[]= {
static void node_shader_init_tex_magic(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeTexMagic *tex = MEM_callocN(sizeof(NodeTexMagic), "NodeTexMagic");
default_tex_mapping(&tex->base.tex_mapping);
default_color_mapping(&tex->base.color_mapping);
tex->depth = 2;
node->storage = tex;
@@ -148,6 +150,8 @@ static int node_shader_gpu_tex_magic(GPUMaterial *mat, bNode *node, GPUNodeStack
if(!in[0].link)
in[0].link = GPU_attribute(CD_ORCO, "");
node_shader_gpu_tex_mapping(mat, node, in, out);
return GPU_stack_link(mat, "node_tex_magic", in, out, GPU_uniform(&depth));
}

6
source/blender/nodes/shader/nodes/node_shader_tex_marble.c
View File

@@ -70,6 +70,8 @@ static bNodeSocketTemplate sh_node_tex_marble_out[]= {
static void node_shader_init_tex_marble(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeTexMarble *tex = MEM_callocN(sizeof(NodeTexMarble), "NodeTexMarble");
default_tex_mapping(&tex->base.tex_mapping);
default_color_mapping(&tex->base.color_mapping);
tex->type = SHD_MARBLE_SOFT;
tex->wave = SHD_WAVE_SINE;
tex->basis = SHD_NOISE_PERLIN;
@@ -97,11 +99,13 @@ static void node_shader_exec_tex_marble(void *data, bNode *node, bNodeStack **in
out[0]->vec[0]= marble(vec, size, tex->type, tex->wave, tex->basis, tex->hard, turbulence, tex->depth);
}
static int node_shader_gpu_tex_marble(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out)
static int node_shader_gpu_tex_marble(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out)
{
if(!in[0].link)
in[0].link = GPU_attribute(CD_ORCO, "");
node_shader_gpu_tex_mapping(mat, node, in, out);
return GPU_stack_link(mat, "node_tex_marble", in, out);
}

6
source/blender/nodes/shader/nodes/node_shader_tex_musgrave.c
View File

@@ -234,6 +234,8 @@ static bNodeSocketTemplate sh_node_tex_musgrave_out[]= {
static void node_shader_init_tex_musgrave(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeTexMusgrave *tex = MEM_callocN(sizeof(NodeTexMusgrave), "NodeTexMusgrave");
default_tex_mapping(&tex->base.tex_mapping);
default_color_mapping(&tex->base.color_mapping);
tex->type = SHD_MUSGRAVE_FBM;
tex->basis = SHD_NOISE_PERLIN;
@@ -262,11 +264,13 @@ static void node_shader_exec_tex_musgrave(void *data, bNode *node, bNodeStack **
out[0]->vec[0]= musgrave(tex->type, tex->basis, dimension, lacunarity, octaves, offset, 1.0f, gain, size, vec);
}
static int node_shader_gpu_tex_musgrave(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out)
static int node_shader_gpu_tex_musgrave(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out)
{
if(!in[0].link)
in[0].link = GPU_attribute(CD_ORCO, "");
node_shader_gpu_tex_mapping(mat, node, in, out);
return GPU_stack_link(mat, "node_tex_musgrave", in, out);
}

15
source/blender/nodes/shader/nodes/node_shader_tex_noise.c
View File

@@ -59,6 +59,15 @@ static bNodeSocketTemplate sh_node_tex_noise_out[]= {
{ -1, 0, "" }
};
static void node_shader_init_tex_noise(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeTexNoise *tex = MEM_callocN(sizeof(NodeTexNoise), "NodeTexNoise");
default_tex_mapping(&tex->base.tex_mapping);
default_color_mapping(&tex->base.color_mapping);
node->storage = tex;
}
static void node_shader_exec_tex_noise(void *data, bNode *node, bNodeStack **in, bNodeStack **out)
{
ShaderCallData *scd= (ShaderCallData*)data;
@@ -74,11 +83,13 @@ static void node_shader_exec_tex_noise(void *data, bNode *node, bNodeStack **in,
out[1]->vec[0]= noise_texture_value(vec);
}
static int node_shader_gpu_tex_noise(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out)
static int node_shader_gpu_tex_noise(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out)
{
if(!in[0].link)
in[0].link = GPU_attribute(CD_ORCO, "");
node_shader_gpu_tex_mapping(mat, node, in, out);
return GPU_stack_link(mat, "node_tex_noise", in, out);
}
@@ -91,7 +102,7 @@ void register_node_type_sh_tex_noise(ListBase *lb)
node_type_compatibility(&ntype, NODE_NEW_SHADING);
node_type_socket_templates(&ntype, sh_node_tex_noise_in, sh_node_tex_noise_out);
node_type_size(&ntype, 150, 60, 200);
node_type_init(&ntype, NULL);
node_type_init(&ntype, node_shader_init_tex_noise);
node_type_storage(&ntype, "", NULL, NULL);
node_type_exec(&ntype, node_shader_exec_tex_noise);
node_type_gpu(&ntype, node_shader_gpu_tex_noise);

6
source/blender/nodes/shader/nodes/node_shader_tex_sky.c
View File

@@ -44,6 +44,8 @@ static bNodeSocketTemplate sh_node_tex_sky_out[]= {
static void node_shader_init_tex_sky(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeTexSky *tex = MEM_callocN(sizeof(NodeTexSky), "NodeTexSky");
default_tex_mapping(&tex->base.tex_mapping);
default_color_mapping(&tex->base.color_mapping);
tex->sun_direction[0] = 0.0f;
tex->sun_direction[1] = 0.0f;
tex->sun_direction[2] = 1.0f;
@@ -56,11 +58,13 @@ static void node_shader_exec_tex_sky(void *UNUSED(data), bNode *UNUSED(node), bN
{
}
static int node_shader_gpu_tex_sky(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out)
static int node_shader_gpu_tex_sky(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out)
{
if(!in[0].link)
in[0].link = GPU_attribute(CD_ORCO, "");
node_shader_gpu_tex_mapping(mat, node, in, out);
return GPU_stack_link(mat, "node_tex_sky", in, out);
}

6
source/blender/nodes/shader/nodes/node_shader_tex_stucci.c
View File

@@ -67,6 +67,8 @@ static bNodeSocketTemplate sh_node_tex_stucci_out[]= {
static void node_shader_init_tex_stucci(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeTexStucci *tex = MEM_callocN(sizeof(NodeTexStucci), "NodeTexStucci");
default_tex_mapping(&tex->base.tex_mapping);
default_color_mapping(&tex->base.color_mapping);
tex->type = SHD_STUCCI_PLASTIC;
tex->basis = SHD_NOISE_PERLIN;
tex->hard = 0;
@@ -92,11 +94,13 @@ static void node_shader_exec_tex_stucci(void *data, bNode *node, bNodeStack **in
out[0]->vec[0]= stucci(tex->type, tex->basis, tex->hard, turbulence, size, vec);
}
static int node_shader_gpu_tex_stucci(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out)
static int node_shader_gpu_tex_stucci(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out)
{
if(!in[0].link)
in[0].link = GPU_attribute(CD_ORCO, "");
node_shader_gpu_tex_mapping(mat, node, in, out);
return GPU_stack_link(mat, "node_tex_stucci", in, out);
}

6
source/blender/nodes/shader/nodes/node_shader_tex_voronoi.c
View File

@@ -109,6 +109,8 @@ static bNodeSocketTemplate sh_node_tex_voronoi_out[]= {
static void node_shader_init_tex_voronoi(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeTexVoronoi *tex = MEM_callocN(sizeof(NodeTexVoronoi), "NodeTexVoronoi");
default_tex_mapping(&tex->base.tex_mapping);
default_color_mapping(&tex->base.color_mapping);
tex->distance_metric = SHD_VORONOI_ACTUAL_DISTANCE;
tex->coloring = SHD_VORONOI_INTENSITY;
@@ -138,11 +140,13 @@ static void node_shader_exec_tex_voronoi(void *data, bNode *node, bNodeStack **i
exponent, 1.0f, size, vec, out[0]->vec);
}
static int node_shader_gpu_tex_voronoi(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out)
static int node_shader_gpu_tex_voronoi(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out)
{
if(!in[0].link)
in[0].link = GPU_attribute(CD_ORCO, "");
node_shader_gpu_tex_mapping(mat, node, in, out);
return GPU_stack_link(mat, "node_tex_voronoi", in, out);
}

6
source/blender/nodes/shader/nodes/node_shader_tex_wood.c
View File

@@ -73,6 +73,8 @@ static bNodeSocketTemplate sh_node_tex_wood_out[]= {
static void node_shader_init_tex_wood(bNodeTree *UNUSED(ntree), bNode* node, bNodeTemplate *UNUSED(ntemp))
{
NodeTexWood *tex = MEM_callocN(sizeof(NodeTexWood), "NodeTexWood");
default_tex_mapping(&tex->base.tex_mapping);
default_color_mapping(&tex->base.color_mapping);
tex->type = SHD_WOOD_BANDS;
tex->wave = SHD_WAVE_SINE;
tex->basis = SHD_NOISE_PERLIN;
@@ -99,11 +101,13 @@ static void node_shader_exec_tex_wood(void *data, bNode *node, bNodeStack **in,
out[0]->vec[0]= wood(vec, size, tex->type, tex->wave, tex->basis, tex->hard, turbulence);
}
static int node_shader_gpu_tex_wood(GPUMaterial *mat, bNode *UNUSED(node), GPUNodeStack *in, GPUNodeStack *out)
static int node_shader_gpu_tex_wood(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *out)
{
if(!in[0].link)
in[0].link = GPU_attribute(CD_ORCO, "");
node_shader_gpu_tex_mapping(mat, node, in, out);
return GPU_stack_link(mat, "node_tex_wood", in, out);
}