Page MenuHome
Differential D9961 Diff 32342 intern/cycles/app/cycles_xml.cpp

Changeset View

Standalone View

View Options

intern/cycles/app/cycles_xml.cpp

Show First 20 Lines • Show All 184 Lines • ▼ Show 20 Lines
} }
/* Camera */ /* Camera */
static void xml_read_camera(XMLReadState &state, xml_node node) static void xml_read_camera(XMLReadState &state, xml_node node)
{ {
Camera *cam = state.scene->camera; Camera *cam = state.scene->camera;
xml_read_int(&cam->width, node, "width"); int width = -1, height = -1;
xml_read_int(&cam->height, node, "height"); xml_read_int(&width, node, "width");
xml_read_int(&height, node, "height");
cam->set_screen_size_and_resolution(width, height, 1);
cam->full_width = cam->width; cam->set_full_width(cam->screen_width());
cam->full_height = cam->height; cam->set_full_height(cam->screen_height());
xml_read_node(state, cam, node); xml_read_node(state, cam, node);
cam->matrix = state.tfm; cam->set_matrix(state.tfm);
cam->need_update = true; cam->need_flags_update = true;
cam->update(state.scene); cam->update(state.scene);
} }
/* Shader */ /* Shader */
static void xml_read_shader_graph(XMLReadState &state, Shader *shader, xml_node graph_node) static void xml_read_shader_graph(XMLReadState &state, Shader *shader, xml_node graph_node)
{ {
xml_read_node(state, shader, graph_node); xml_read_node(state, shader, graph_node);
▲ Show 20 Lines • Show All 121 Lines • ▼ Show 20 Lines#endif
snode = (ShaderNode *)node_type->create(node_type); snode = (ShaderNode *)node_type->create(node_type);
} }
xml_read_node(graph_reader, snode, node); xml_read_node(graph_reader, snode, node);
if (node_name == "image_texture") { if (node_name == "image_texture") {
ImageTextureNode *img = (ImageTextureNode *)snode; ImageTextureNode *img = (ImageTextureNode *)snode;
img->filename = path_join(state.base, img->filename.string()); ustring filename(path_join(state.base, img->get_filename().string()));
img->set_filename(filename);
} }
else if (node_name == "environment_texture") { else if (node_name == "environment_texture") {
EnvironmentTextureNode *env = (EnvironmentTextureNode *)snode; EnvironmentTextureNode *env = (EnvironmentTextureNode *)snode;
env->filename = path_join(state.base, env->filename.string()); ustring filename(path_join(state.base, env->get_filename().string()));
env->set_filename(filename);
} }
if (snode) { if (snode) {
/* add to graph */ /* add to graph */
graph->add(snode); graph->add(snode);
} }
} }
Show All 25 Lines
static Mesh *xml_add_mesh(Scene *scene, const Transform &tfm) static Mesh *xml_add_mesh(Scene *scene, const Transform &tfm)
{ {
/* create mesh */ /* create mesh */
Mesh *mesh = new Mesh(); Mesh *mesh = new Mesh();
scene->geometry.push_back(mesh); scene->geometry.push_back(mesh);
/* create object*/ /* create object*/
Object *object = new Object(); Object *object = new Object();
object->geometry = mesh; object->set_geometry(mesh);
object->tfm = tfm; object->set_tfm(tfm);
scene->objects.push_back(object); scene->objects.push_back(object);
return mesh; return mesh;
} }
static void xml_read_mesh(const XMLReadState &state, xml_node node) static void xml_read_mesh(const XMLReadState &state, xml_node node)
{ {
/* add mesh */ /* add mesh */
Mesh *mesh = xml_add_mesh(state.scene, state.tfm); Mesh *mesh = xml_add_mesh(state.scene, state.tfm);
mesh->used_shaders.push_back(state.shader); array<Node *> used_shaders = mesh->get_used_shaders();
used_shaders.push_back_slow(state.shader);
mesh->set_used_shaders(used_shaders);
/* read state */ /* read state */
int shader = 0; int shader = 0;
bool smooth = state.smooth; bool smooth = state.smooth;
/* read vertices and polygons */ /* read vertices and polygons */
vector<float3> P; vector<float3> P;
vector<float> UV; vector<float> UV;
vector<int> verts, nverts; vector<int> verts, nverts;
xml_read_float3_array(P, node, "P"); xml_read_float3_array(P, node, "P");
xml_read_int_array(verts, node, "verts"); xml_read_int_array(verts, node, "verts");
xml_read_int_array(nverts, node, "nverts"); xml_read_int_array(nverts, node, "nverts");
if (xml_equal_string(node, "subdivision", "catmull-clark")) { if (xml_equal_string(node, "subdivision", "catmull-clark")) {
mesh->subdivision_type = Mesh::SUBDIVISION_CATMULL_CLARK; mesh->set_subdivision_type(Mesh::SUBDIVISION_CATMULL_CLARK);
} }
else if (xml_equal_string(node, "subdivision", "linear")) { else if (xml_equal_string(node, "subdivision", "linear")) {
mesh->subdivision_type = Mesh::SUBDIVISION_LINEAR; mesh->set_subdivision_type(Mesh::SUBDIVISION_LINEAR);
} }
if (mesh->subdivision_type == Mesh::SUBDIVISION_NONE) { array<float3> P_array;
P_array = P;
bareyaUnsubmitted
Not Done
Inline Actions

Hey I had a look into the code of array and this one copies the vector. The unnecessary copy can be removed with little effort of changing xml_read* functions

bareya: Hey I had a look into the code of `array` and this one copies the vector. The unnecessary copy…
kevindietrichUnsubmitted
Not Done
Inline Actions

It could be good to avoid this copy, but such a change would be a bit involved for this compilation fix I think. Then, if performance was a problem, I would blame using XML over this copy.

kevindietrich: It could be good to avoid this copy, but such a change would be a bit involved for this…
if (mesh->get_subdivision_type() == Mesh::SUBDIVISION_NONE) {
/* create vertices */ /* create vertices */
mesh->verts = P;
mesh->set_verts(P_array);
size_t num_triangles = 0; size_t num_triangles = 0;
for (size_t i = 0; i < nverts.size(); i++) for (size_t i = 0; i < nverts.size(); i++)
num_triangles += nverts[i] - 2; num_triangles += nverts[i] - 2;
mesh->reserve_mesh(mesh->verts.size(), num_triangles); mesh->reserve_mesh(mesh->get_verts().size(), num_triangles);
/* create triangles */ /* create triangles */
int index_offset = 0; int index_offset = 0;
for (size_t i = 0; i < nverts.size(); i++) { for (size_t i = 0; i < nverts.size(); i++) {
for (int j = 0; j < nverts[i] - 2; j++) { for (int j = 0; j < nverts[i] - 2; j++) {
int v0 = verts[index_offset]; int v0 = verts[index_offset];
int v1 = verts[index_offset + j + 1]; int v1 = verts[index_offset + j + 1];
Show All 33 Lines if (xml_read_float_array(UV, node, "UV")) {
} }
index_offset += nverts[i]; index_offset += nverts[i];
} }
} }
} }
else { else {
/* create vertices */ /* create vertices */
mesh->verts = P; mesh->set_verts(P_array);
size_t num_ngons = 0; size_t num_ngons = 0;
size_t num_corners = 0; size_t num_corners = 0;
for (size_t i = 0; i < nverts.size(); i++) { for (size_t i = 0; i < nverts.size(); i++) {
num_ngons += (nverts[i] == 4) ? 0 : 1; num_ngons += (nverts[i] == 4) ? 0 : 1;
num_corners += nverts[i]; num_corners += nverts[i];
} }
mesh->reserve_subd_faces(nverts.size(), num_ngons, num_corners); mesh->reserve_subd_faces(nverts.size(), num_ngons, num_corners);
Show All 22 Lines#endif
for (size_t i = 0; i < nverts.size(); i++) { for (size_t i = 0; i < nverts.size(); i++) {
for (int j = 0; j < nverts[i]; j++) { for (int j = 0; j < nverts[i]; j++) {
*(fdata++) = make_float3(UV[index_offset++]); *(fdata++) = make_float3(UV[index_offset++]);
} }
} }
} }
/* setup subd params */ /* setup subd params */
if (!mesh->subd_params) { SubdParams &sdparams = *mesh->get_subd_params();
mesh->subd_params = new SubdParams(mesh);
}
SubdParams &sdparams = *mesh->subd_params;
sdparams.dicing_rate = state.dicing_rate; sdparams.dicing_rate = state.dicing_rate;
xml_read_float(&sdparams.dicing_rate, node, "dicing_rate"); xml_read_float(&sdparams.dicing_rate, node, "dicing_rate");
sdparams.dicing_rate = std::max(0.1f, sdparams.dicing_rate); sdparams.dicing_rate = std::max(0.1f, sdparams.dicing_rate);
sdparams.objecttoworld = state.tfm; sdparams.objecttoworld = state.tfm;
} }
/* we don't yet support arbitrary attributes, for now add vertex /* we don't yet support arbitrary attributes, for now add vertex
* coordinates as generated coordinates if requested */ * coordinates as generated coordinates if requested */
if (mesh->need_attribute(state.scene, ATTR_STD_GENERATED)) { if (mesh->need_attribute(state.scene, ATTR_STD_GENERATED)) {
Attribute *attr = mesh->attributes.add(ATTR_STD_GENERATED); Attribute *attr = mesh->attributes.add(ATTR_STD_GENERATED);
memcpy(attr->data_float3(), mesh->verts.data(), sizeof(float3) * mesh->verts.size()); memcpy(attr->data_float3(), mesh->get_verts().data(), sizeof(float3) * mesh->get_verts().size());
} }
} }
/* Light */ /* Light */
static void xml_read_light(XMLReadState &state, xml_node node) static void xml_read_light(XMLReadState &state, xml_node node)
{ {
Light *light = new Light(); Light *light = new Light();
light->shader = state.shader; light->set_shader(state.shader);
xml_read_node(state, light, node); xml_read_node(state, light, node);
state.scene->lights.push_back(light); state.scene->lights.push_back(light);
} }
/* Transform */ /* Transform */
static void xml_read_transform(xml_node node, Transform &tfm) static void xml_read_transform(xml_node node, Transform &tfm)
▲ Show 20 Lines • Show All 153 Lines • Show Last 20 Lines