Cr8-xyz/blender
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Cleanup: simplify Cycles primitive attribute map storage

Browse Source
This commit is contained in:
Brecht Van Lommel
2020-02-03 21:40:58 +01:00
parent d9c5f0d25f
commit d809853513
9 changed files with 88 additions and 205 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
intern/cycles/kernel/geom/geom_attribute.h
View File

@@ -29,17 +29,11 @@ ccl_device_inline uint subd_triangle_patch(KernelGlobals *kg, const ShaderData *
ccl_device_inline uint attribute_primitive_type(KernelGlobals *kg, const ShaderData *sd) ccl_device_inline uint attribute_primitive_type(KernelGlobals *kg, const ShaderData *sd)
{ {
#ifdef __HAIR__ if ((sd->type & PRIMITIVE_ALL_TRIANGLE) && subd_triangle_patch(kg, sd) != ~0) {
if (sd->type & PRIMITIVE_ALL_CURVE) {
return ATTR_PRIM_CURVE;
}
else
#endif
if (subd_triangle_patch(kg, sd) != ~0) {
return ATTR_PRIM_SUBD; return ATTR_PRIM_SUBD;
} }
else { else {
return ATTR_PRIM_TRIANGLE; return ATTR_PRIM_GEOMETRY;
} }
} }

2
intern/cycles/kernel/geom/geom_motion_curve.h
View File

@@ -36,7 +36,7 @@ ccl_device_inline int find_attribute_curve_motion(KernelGlobals *kg,
* zero iterations and rendering is really slow with motion curves. For until other * zero iterations and rendering is really slow with motion curves. For until other
* areas are speed up it's probably not so crucial to optimize this out. * areas are speed up it's probably not so crucial to optimize this out.
*/ */
uint attr_offset = object_attribute_map_offset(kg, object) + ATTR_PRIM_CURVE; uint attr_offset = object_attribute_map_offset(kg, object) + ATTR_PRIM_GEOMETRY;
uint4 attr_map = kernel_tex_fetch(__attributes_map, attr_offset); uint4 attr_map = kernel_tex_fetch(__attributes_map, attr_offset);
while (attr_map.x != id) { while (attr_map.x != id) {

3
intern/cycles/kernel/kernel_types.h
View File

@@ -725,9 +725,8 @@ typedef enum PrimitiveType {
/* Attributes */ /* Attributes */
typedef enum AttributePrimitive { typedef enum AttributePrimitive {
ATTR_PRIM_TRIANGLE = 0, ATTR_PRIM_GEOMETRY = 0,
ATTR_PRIM_SUBD, ATTR_PRIM_SUBD,
ATTR_PRIM_CURVE,
ATTR_PRIM_TYPES ATTR_PRIM_TYPES
} AttributePrimitive; } AttributePrimitive;

4
intern/cycles/kernel/osl/osl_shader.cpp
View File

@@ -382,10 +382,6 @@ int OSLShader::find_attribute(KernelGlobals *kg,
{ {
/* for OSL, a hash map is used to lookup the attribute by name. */ /* for OSL, a hash map is used to lookup the attribute by name. */
int object = sd->object * ATTR_PRIM_TYPES; int object = sd->object * ATTR_PRIM_TYPES;
#ifdef __HAIR__
if (sd->type & PRIMITIVE_ALL_CURVE)
object += ATTR_PRIM_CURVE;
#endif
OSLGlobals::AttributeMap &attr_map = kg->osl->attribute_map[object]; OSLGlobals::AttributeMap &attr_map = kg->osl->attribute_map[object];
ustring stdname(std::string("geom:") + ustring stdname(std::string("geom:") +

54
intern/cycles/render/attribute.cpp
View File

@@ -193,7 +193,7 @@ size_t Attribute::element_size(Geometry *geom, AttributePrimitive prim) const
case ATTR_ELEMENT_FACE: case ATTR_ELEMENT_FACE:
if (geom->type == Geometry::MESH) { if (geom->type == Geometry::MESH) {
Mesh *mesh = static_cast<Mesh *>(geom); Mesh *mesh = static_cast<Mesh *>(geom);
if (prim == ATTR_PRIM_TRIANGLE) { if (prim == ATTR_PRIM_GEOMETRY) {
size = mesh->num_triangles(); size = mesh->num_triangles();
} }
else { else {
@@ -205,7 +205,7 @@ size_t Attribute::element_size(Geometry *geom, AttributePrimitive prim) const
case ATTR_ELEMENT_CORNER_BYTE: case ATTR_ELEMENT_CORNER_BYTE:
if (geom->type == Geometry::MESH) { if (geom->type == Geometry::MESH) {
Mesh *mesh = static_cast<Mesh *>(geom); Mesh *mesh = static_cast<Mesh *>(geom);
if (prim == ATTR_PRIM_TRIANGLE) { if (prim == ATTR_PRIM_GEOMETRY) {
size = mesh->num_triangles() * 3; size = mesh->num_triangles() * 3;
} }
else { else {
@@ -390,11 +390,9 @@ void Attribute::get_uv_tiles(Geometry *geom,
/* Attribute Set */ /* Attribute Set */
AttributeSet::AttributeSet() AttributeSet::AttributeSet(Geometry *geometry, AttributePrimitive prim)
: geometry(geometry), prim(prim)
{ {
triangle_mesh = NULL;
subd_mesh = NULL;
hair = NULL;
} }
AttributeSet::~AttributeSet() AttributeSet::~AttributeSet()
@@ -428,12 +426,7 @@ Attribute *AttributeSet::add(ustring name, TypeDesc type, AttributeElement eleme
#endif #endif
/* this is weak .. */ /* this is weak .. */
if (triangle_mesh) attr->resize(geometry, prim, false);
attr->resize(triangle_mesh, ATTR_PRIM_TRIANGLE, false);
if (subd_mesh)
attr->resize(subd_mesh, ATTR_PRIM_SUBD, false);
if (hair)
attr->resize(hair, ATTR_PRIM_CURVE, false);
return attr; return attr;
} }
@@ -470,7 +463,7 @@ Attribute *AttributeSet::add(AttributeStandard std, ustring name)
if (name == ustring()) if (name == ustring())
name = Attribute::standard_name(std); name = Attribute::standard_name(std);
if (triangle_mesh || subd_mesh) { if (geometry->type == Geometry::MESH) {
switch (std) { switch (std) {
case ATTR_STD_VERTEX_NORMAL: case ATTR_STD_VERTEX_NORMAL:
attr = add(name, TypeDesc::TypeNormal, ATTR_ELEMENT_VERTEX); attr = add(name, TypeDesc::TypeNormal, ATTR_ELEMENT_VERTEX);
@@ -530,7 +523,7 @@ Attribute *AttributeSet::add(AttributeStandard std, ustring name)
break; break;
} }
} }
else if (hair) { else if (geometry->type == Geometry::HAIR) {
switch (std) { switch (std) {
case ATTR_STD_UV: case ATTR_STD_UV:
attr = add(name, TypeFloat2, ATTR_ELEMENT_CURVE); attr = add(name, TypeFloat2, ATTR_ELEMENT_CURVE);
@@ -613,12 +606,7 @@ void AttributeSet::remove(Attribute *attribute)
void AttributeSet::resize(bool reserve_only) void AttributeSet::resize(bool reserve_only)
{ {
foreach (Attribute &attr, attributes) { foreach (Attribute &attr, attributes) {
if (triangle_mesh) attr.resize(geometry, prim, reserve_only);
attr.resize(triangle_mesh, ATTR_PRIM_TRIANGLE, reserve_only);
if (subd_mesh)
attr.resize(subd_mesh, ATTR_PRIM_SUBD, reserve_only);
if (hair)
attr.resize(hair, ATTR_PRIM_CURVE, reserve_only);
} }
} }
@@ -648,15 +636,10 @@ AttributeRequest::AttributeRequest(ustring name_)
name = name_; name = name_;
std = ATTR_STD_NONE; std = ATTR_STD_NONE;
triangle_type = TypeDesc::TypeFloat; type = TypeDesc::TypeFloat;
triangle_desc.element = ATTR_ELEMENT_NONE; desc.element = ATTR_ELEMENT_NONE;
triangle_desc.offset = 0; desc.offset = 0;
triangle_desc.type = NODE_ATTR_FLOAT; desc.type = NODE_ATTR_FLOAT;
curve_type = TypeDesc::TypeFloat;
curve_desc.element = ATTR_ELEMENT_NONE;
curve_desc.offset = 0;
curve_desc.type = NODE_ATTR_FLOAT;
subd_type = TypeDesc::TypeFloat; subd_type = TypeDesc::TypeFloat;
subd_desc.element = ATTR_ELEMENT_NONE; subd_desc.element = ATTR_ELEMENT_NONE;
@@ -669,15 +652,10 @@ AttributeRequest::AttributeRequest(AttributeStandard std_)
name = ustring(); name = ustring();
std = std_; std = std_;
triangle_type = TypeDesc::TypeFloat; type = TypeDesc::TypeFloat;
triangle_desc.element = ATTR_ELEMENT_NONE; desc.element = ATTR_ELEMENT_NONE;
triangle_desc.offset = 0; desc.offset = 0;
triangle_desc.type = NODE_ATTR_FLOAT; desc.type = NODE_ATTR_FLOAT;
curve_type = TypeDesc::TypeFloat;
curve_desc.element = ATTR_ELEMENT_NONE;
curve_desc.offset = 0;
curve_desc.type = NODE_ATTR_FLOAT;
subd_type = TypeDesc::TypeFloat; subd_type = TypeDesc::TypeFloat;
subd_desc.element = ATTR_ELEMENT_NONE; subd_desc.element = ATTR_ELEMENT_NONE;

11
intern/cycles/render/attribute.h
View File

@@ -170,12 +170,11 @@ class Attribute {
class AttributeSet { class AttributeSet {
public: public:
Mesh *triangle_mesh; Geometry *geometry;
Mesh *subd_mesh; AttributePrimitive prim;
Hair *hair;
list<Attribute> attributes; list<Attribute> attributes;
AttributeSet(); AttributeSet(Geometry *geometry, AttributePrimitive prim);
~AttributeSet(); ~AttributeSet();
Attribute *add(ustring name, TypeDesc type, AttributeElement element); Attribute *add(ustring name, TypeDesc type, AttributeElement element);
@@ -206,8 +205,8 @@ class AttributeRequest {
AttributeStandard std; AttributeStandard std;
/* temporary variables used by GeometryManager */ /* temporary variables used by GeometryManager */
TypeDesc triangle_type, curve_type, subd_type; TypeDesc type, subd_type;
AttributeDescriptor triangle_desc, curve_desc, subd_desc; AttributeDescriptor desc, subd_desc;
explicit AttributeRequest(ustring name_); explicit AttributeRequest(ustring name_);
explicit AttributeRequest(AttributeStandard std); explicit AttributeRequest(AttributeStandard std);

193
intern/cycles/render/geometry.cpp
View File

@@ -56,7 +56,8 @@ NODE_ABSTRACT_DEFINE(Geometry)
return type; return type;
} }
Geometry::Geometry(const NodeType *node_type, const Type type) : Node(node_type), type(type) Geometry::Geometry(const NodeType *node_type, const Type type)
: Node(node_type), type(type), attributes(this, ATTR_PRIM_GEOMETRY)
{ {
need_update = true; need_update = true;
need_update_rebuild = false; need_update_rebuild = false;
@@ -300,9 +301,8 @@ void GeometryManager::update_osl_attributes(Device *device,
osl_attr.desc.offset = 0; osl_attr.desc.offset = 0;
osl_attr.desc.flags = 0; osl_attr.desc.flags = 0;
og->attribute_map[i * ATTR_PRIM_TYPES + ATTR_PRIM_TRIANGLE][attr.name()] = osl_attr; og->attribute_map[i * ATTR_PRIM_TYPES + ATTR_PRIM_GEOMETRY][attr.name()] = osl_attr;
og->attribute_map[i * ATTR_PRIM_TYPES + ATTR_PRIM_SUBD][attr.name()] = osl_attr; og->attribute_map[i * ATTR_PRIM_TYPES + ATTR_PRIM_SUBD][attr.name()] = osl_attr;
og->attribute_map[i * ATTR_PRIM_TYPES + ATTR_PRIM_CURVE][attr.name()] = osl_attr;
} }
/* find geometry attributes */ /* find geometry attributes */
@@ -318,16 +318,16 @@ void GeometryManager::update_osl_attributes(Device *device,
foreach (AttributeRequest &req, attributes.requests) { foreach (AttributeRequest &req, attributes.requests) {
OSLGlobals::Attribute osl_attr; OSLGlobals::Attribute osl_attr;
if (req.triangle_desc.element != ATTR_ELEMENT_NONE) { if (req.desc.element != ATTR_ELEMENT_NONE) {
osl_attr.desc = req.triangle_desc; osl_attr.desc = req.desc;
if (req.triangle_type == TypeDesc::TypeFloat) if (req.type == TypeDesc::TypeFloat)
osl_attr.type = TypeDesc::TypeFloat; osl_attr.type = TypeDesc::TypeFloat;
else if (req.triangle_type == TypeDesc::TypeMatrix) else if (req.type == TypeDesc::TypeMatrix)
osl_attr.type = TypeDesc::TypeMatrix; osl_attr.type = TypeDesc::TypeMatrix;
else if (req.triangle_type == TypeFloat2) else if (req.type == TypeFloat2)
osl_attr.type = TypeFloat2; osl_attr.type = TypeFloat2;
else if (req.triangle_type == TypeRGBA) else if (req.type == TypeRGBA)
osl_attr.type = TypeRGBA; osl_attr.type = TypeRGBA;
else else
osl_attr.type = TypeDesc::TypeColor; osl_attr.type = TypeDesc::TypeColor;
@@ -335,36 +335,11 @@ void GeometryManager::update_osl_attributes(Device *device,
if (req.std != ATTR_STD_NONE) { if (req.std != ATTR_STD_NONE) {
/* if standard attribute, add lookup by geom: name convention */ /* if standard attribute, add lookup by geom: name convention */
ustring stdname(string("geom:") + string(Attribute::standard_name(req.std))); ustring stdname(string("geom:") + string(Attribute::standard_name(req.std)));
og->attribute_map[i * ATTR_PRIM_TYPES + ATTR_PRIM_TRIANGLE][stdname] = osl_attr; og->attribute_map[i * ATTR_PRIM_TYPES + ATTR_PRIM_GEOMETRY][stdname] = osl_attr;
} }
else if (req.name != ustring()) { else if (req.name != ustring()) {
/* add lookup by geometry attribute name */ /* add lookup by geometry attribute name */
og->attribute_map[i * ATTR_PRIM_TYPES + ATTR_PRIM_TRIANGLE][req.name] = osl_attr; og->attribute_map[i * ATTR_PRIM_TYPES + ATTR_PRIM_GEOMETRY][req.name] = osl_attr;
}
}
if (req.curve_desc.element != ATTR_ELEMENT_NONE) {
osl_attr.desc = req.curve_desc;
if (req.curve_type == TypeDesc::TypeFloat)
osl_attr.type = TypeDesc::TypeFloat;
else if (req.curve_type == TypeDesc::TypeMatrix)
osl_attr.type = TypeDesc::TypeMatrix;
else if (req.curve_type == TypeFloat2)
osl_attr.type = TypeFloat2;
else if (req.curve_type == TypeRGBA)
osl_attr.type = TypeRGBA;
else
osl_attr.type = TypeDesc::TypeColor;
if (req.std != ATTR_STD_NONE) {
/* if standard attribute, add lookup by geom: name convention */
ustring stdname(string("geom:") + string(Attribute::standard_name(req.std)));
og->attribute_map[i * ATTR_PRIM_TYPES + ATTR_PRIM_CURVE][stdname] = osl_attr;
}
else if (req.name != ustring()) {
/* add lookup by geometry attribute name */
og->attribute_map[i * ATTR_PRIM_TYPES + ATTR_PRIM_CURVE][req.name] = osl_attr;
} }
} }
@@ -440,27 +415,22 @@ void GeometryManager::update_svm_attributes(Device *,
else else
id = scene->shader_manager->get_attribute_id(req.std); id = scene->shader_manager->get_attribute_id(req.std);
if (geom->type == Geometry::MESH) { attr_map[index].x = id;
Mesh *mesh = static_cast<Mesh *>(geom); attr_map[index].y = req.desc.element;
if (mesh->num_triangles()) { attr_map[index].z = as_uint(req.desc.offset);
attr_map[index].x = id;
attr_map[index].y = req.triangle_desc.element;
attr_map[index].z = as_uint(req.triangle_desc.offset);
if (req.triangle_type == TypeDesc::TypeFloat) if (req.type == TypeDesc::TypeFloat)
attr_map[index].w = NODE_ATTR_FLOAT; attr_map[index].w = NODE_ATTR_FLOAT;
else if (req.triangle_type == TypeDesc::TypeMatrix) else if (req.type == TypeDesc::TypeMatrix)
attr_map[index].w = NODE_ATTR_MATRIX; attr_map[index].w = NODE_ATTR_MATRIX;
else if (req.triangle_type == TypeFloat2) else if (req.type == TypeFloat2)
attr_map[index].w = NODE_ATTR_FLOAT2; attr_map[index].w = NODE_ATTR_FLOAT2;
else if (req.triangle_type == TypeRGBA) else if (req.type == TypeRGBA)
attr_map[index].w = NODE_ATTR_RGBA; attr_map[index].w = NODE_ATTR_RGBA;
else else
attr_map[index].w = NODE_ATTR_FLOAT3; attr_map[index].w = NODE_ATTR_FLOAT3;
attr_map[index].w |= req.triangle_desc.flags << 8; attr_map[index].w |= req.desc.flags << 8;
}
}
index++; index++;
@@ -477,7 +447,7 @@ void GeometryManager::update_svm_attributes(Device *,
attr_map[index].w = NODE_ATTR_MATRIX; attr_map[index].w = NODE_ATTR_MATRIX;
else if (req.subd_type == TypeFloat2) else if (req.subd_type == TypeFloat2)
attr_map[index].w = NODE_ATTR_FLOAT2; attr_map[index].w = NODE_ATTR_FLOAT2;
else if (req.triangle_type == TypeRGBA) else if (req.subd_type == TypeRGBA)
attr_map[index].w = NODE_ATTR_RGBA; attr_map[index].w = NODE_ATTR_RGBA;
else else
attr_map[index].w = NODE_ATTR_FLOAT3; attr_map[index].w = NODE_ATTR_FLOAT3;
@@ -487,28 +457,6 @@ void GeometryManager::update_svm_attributes(Device *,
} }
index++; index++;
if (geom->type == Geometry::HAIR) {
Hair *hair = static_cast<Hair *>(geom);
if (hair->num_curves()) {
attr_map[index].x = id;
attr_map[index].y = req.curve_desc.element;
attr_map[index].z = as_uint(req.curve_desc.offset);
if (req.curve_type == TypeDesc::TypeFloat)
attr_map[index].w = NODE_ATTR_FLOAT;
else if (req.curve_type == TypeDesc::TypeMatrix)
attr_map[index].w = NODE_ATTR_MATRIX;
else if (req.curve_type == TypeFloat2)
attr_map[index].w = NODE_ATTR_FLOAT2;
else
attr_map[index].w = NODE_ATTR_FLOAT3;
attr_map[index].w |= req.curve_desc.flags << 8;
}
}
index++;
} }
/* terminator */ /* terminator */
@@ -654,13 +602,13 @@ static void update_attribute_element_offset(Geometry *geom,
else if (element == ATTR_ELEMENT_VERTEX_MOTION) else if (element == ATTR_ELEMENT_VERTEX_MOTION)
offset -= mesh->vert_offset; offset -= mesh->vert_offset;
else if (element == ATTR_ELEMENT_FACE) { else if (element == ATTR_ELEMENT_FACE) {
if (prim == ATTR_PRIM_TRIANGLE) if (prim == ATTR_PRIM_GEOMETRY)
offset -= mesh->prim_offset; offset -= mesh->prim_offset;
else else
offset -= mesh->face_offset; offset -= mesh->face_offset;
} }
else if (element == ATTR_ELEMENT_CORNER || element == ATTR_ELEMENT_CORNER_BYTE) { else if (element == ATTR_ELEMENT_CORNER || element == ATTR_ELEMENT_CORNER_BYTE) {
if (prim == ATTR_PRIM_TRIANGLE) if (prim == ATTR_PRIM_GEOMETRY)
offset -= 3 * mesh->prim_offset; offset -= 3 * mesh->prim_offset;
else else
offset -= mesh->corner_offset; offset -= mesh->corner_offset;
@@ -720,38 +668,28 @@ void GeometryManager::device_update_attributes(Device *device,
Geometry *geom = scene->geometry[i]; Geometry *geom = scene->geometry[i];
AttributeRequestSet &attributes = geom_attributes[i]; AttributeRequestSet &attributes = geom_attributes[i];
foreach (AttributeRequest &req, attributes.requests) { foreach (AttributeRequest &req, attributes.requests) {
Attribute *attr = geom->attributes.find(req);
update_attribute_element_size(geom,
attr,
ATTR_PRIM_GEOMETRY,
&attr_float_size,
&attr_float2_size,
&attr_float3_size,
&attr_uchar4_size);
if (geom->type == Geometry::MESH) { if (geom->type == Geometry::MESH) {
Mesh *mesh = static_cast<Mesh *>(geom); Mesh *mesh = static_cast<Mesh *>(geom);
Attribute *triangle_mattr = mesh->attributes.find(req); Attribute *subd_attr = mesh->subd_attributes.find(req);
Attribute *subd_mattr = mesh->subd_attributes.find(req);
update_attribute_element_size(mesh, update_attribute_element_size(mesh,
triangle_mattr, subd_attr,
ATTR_PRIM_TRIANGLE,
&attr_float_size,
&attr_float2_size,
&attr_float3_size,
&attr_uchar4_size);
update_attribute_element_size(mesh,
subd_mattr,
ATTR_PRIM_SUBD, ATTR_PRIM_SUBD,
&attr_float_size, &attr_float_size,
&attr_float2_size, &attr_float2_size,
&attr_float3_size, &attr_float3_size,
&attr_uchar4_size); &attr_uchar4_size);
} }
else if (geom->type == Geometry::HAIR) {
Hair *hair = static_cast<Hair *>(geom);
Attribute *curve_mattr = hair->attributes.find(req);
update_attribute_element_size(hair,
curve_mattr,
ATTR_PRIM_CURVE,
&attr_float_size,
&attr_float2_size,
&attr_float3_size,
&attr_uchar4_size);
}
} }
} }
@@ -773,10 +711,24 @@ void GeometryManager::device_update_attributes(Device *device,
/* todo: we now store std and name attributes from requests even if /* todo: we now store std and name attributes from requests even if
* they actually refer to the same mesh attributes, optimize */ * they actually refer to the same mesh attributes, optimize */
foreach (AttributeRequest &req, attributes.requests) { foreach (AttributeRequest &req, attributes.requests) {
Attribute *attr = geom->attributes.find(req);
update_attribute_element_offset(geom,
dscene->attributes_float,
attr_float_offset,
dscene->attributes_float2,
attr_float2_offset,
dscene->attributes_float3,
attr_float3_offset,
dscene->attributes_uchar4,
attr_uchar4_offset,
attr,
ATTR_PRIM_GEOMETRY,
req.type,
req.desc);
if (geom->type == Geometry::MESH) { if (geom->type == Geometry::MESH) {
Mesh *mesh = static_cast<Mesh *>(geom); Mesh *mesh = static_cast<Mesh *>(geom);
Attribute *triangle_mattr = mesh->attributes.find(req); Attribute *subd_attr = mesh->subd_attributes.find(req);
Attribute *subd_mattr = mesh->subd_attributes.find(req);
update_attribute_element_offset(mesh, update_attribute_element_offset(mesh,
dscene->attributes_float, dscene->attributes_float,
@@ -787,42 +739,11 @@ void GeometryManager::device_update_attributes(Device *device,
attr_float3_offset, attr_float3_offset,
dscene->attributes_uchar4, dscene->attributes_uchar4,
attr_uchar4_offset, attr_uchar4_offset,
triangle_mattr, subd_attr,
ATTR_PRIM_TRIANGLE,
req.triangle_type,
req.triangle_desc);
update_attribute_element_offset(mesh,
dscene->attributes_float,
attr_float_offset,
dscene->attributes_float2,
attr_float2_offset,
dscene->attributes_float3,
attr_float3_offset,
dscene->attributes_uchar4,
attr_uchar4_offset,
subd_mattr,
ATTR_PRIM_SUBD, ATTR_PRIM_SUBD,
req.subd_type, req.subd_type,
req.subd_desc); req.subd_desc);
} }
else if (geom->type == Geometry::HAIR) {
Hair *hair = static_cast<Hair *>(geom);
Attribute *curve_mattr = hair->attributes.find(req);
update_attribute_element_offset(hair,
dscene->attributes_float,
attr_float_offset,
dscene->attributes_float2,
attr_float2_offset,
dscene->attributes_float3,
attr_float3_offset,
dscene->attributes_uchar4,
attr_uchar4_offset,
curve_mattr,
ATTR_PRIM_CURVE,
req.curve_type,
req.curve_desc);
}
if (progress.get_cancel()) if (progress.get_cancel())
return; return;

4
intern/cycles/render/hair.cpp
View File

@@ -294,8 +294,6 @@ NODE_DEFINE(Hair)
Hair::Hair() : Geometry(node_type, Geometry::HAIR) Hair::Hair() : Geometry(node_type, Geometry::HAIR)
{ {
curvekey_offset = 0; curvekey_offset = 0;
attributes.hair = this;
} }
Hair::~Hair() Hair::~Hair()
@@ -368,7 +366,7 @@ void Hair::get_uv_tiles(ustring map, unordered_set<int> &tiles)
} }
if (attr) { if (attr) {
attr->get_uv_tiles(this, ATTR_PRIM_CURVE, tiles); attr->get_uv_tiles(this, ATTR_PRIM_GEOMETRY, tiles);
} }
} }

12
intern/cycles/render/mesh.cpp
View File

@@ -135,7 +135,7 @@ NODE_DEFINE(Mesh)
return type; return type;
} }
Mesh::Mesh() : Geometry(node_type, Geometry::MESH) Mesh::Mesh() : Geometry(node_type, Geometry::MESH), subd_attributes(this, ATTR_PRIM_SUBD)
{ {
vert_offset = 0; vert_offset = 0;
@@ -145,9 +145,6 @@ Mesh::Mesh() : Geometry(node_type, Geometry::MESH)
num_subd_verts = 0; num_subd_verts = 0;
attributes.triangle_mesh = this;
subd_attributes.subd_mesh = this;
volume_isovalue = 0.001f; volume_isovalue = 0.001f;
num_ngons = 0; num_ngons = 0;
@@ -329,7 +326,9 @@ void Mesh::get_uv_tiles(ustring map, unordered_set<int> &tiles)
} }
if (attr) { if (attr) {
attr->get_uv_tiles(this, ATTR_PRIM_TRIANGLE, tiles); attr->get_uv_tiles(this, ATTR_PRIM_GEOMETRY, tiles);
}
if (subd_attr) {
subd_attr->get_uv_tiles(this, ATTR_PRIM_SUBD, tiles); subd_attr->get_uv_tiles(this, ATTR_PRIM_SUBD, tiles);
} }
} }
@@ -546,8 +545,7 @@ void Mesh::add_undisplaced()
float3 *data = attr->data_float3(); float3 *data = attr->data_float3();
/* copy verts */ /* copy verts */
size_t size = attr->buffer_size( size_t size = attr->buffer_size(this, attrs.prim);
this, (subdivision_type == SUBDIVISION_NONE) ? ATTR_PRIM_TRIANGLE : ATTR_PRIM_SUBD);
/* Center points for ngons aren't stored in Mesh::verts but are included in size since they will /* Center points for ngons aren't stored in Mesh::verts but are included in size since they will
* be calculated later, we subtract them from size here so we don't have an overflow while * be calculated later, we subtract them from size here so we don't have an overflow while