def c_repr(self, name, parent_name, offset, resources):
if 'material' not in self.yaml_obj:
self.yaml_obj['material'] = {}
if 'transform' not in self.yaml_obj:
self.yaml_obj['transform'] = []
material = Material.from_yaml(self.yaml_obj['material'])
transform = Transform.from_yaml(self.yaml_obj['transform'])
buf = """
{1}
{2}
Point shape_{0}_p1 = point({3:.10f}, {4:.10f}, {5:.10f});
Point shape_{0}_p2 = point({6:.10f}, {7:.10f}, {8:.10f});
Point shape_{0}_p3 = point({9:.10f}, {10:.10f}, {11:.10f});
Shape shape_{0} = {12} + {13};
triangle(shape_{0}, shape_{0}_p1->arr, shape_{0}_p2->arr, shape_{0}_p3->arr);
shape_set_material(shape_{0}, material_{0});
shape_set_transform(shape_{0}, transform_{0});
point_free(shape_{0}_p3);
point_free(shape_{0}_p2);
point_free(shape_{0}_p1);
""".format(name, material.c_repr(name, resources), transform.c_repr(name),
self.yaml_obj['p1'][0], self.yaml_obj['p1'][1],
self.yaml_obj['p1'][2], self.yaml_obj['p2'][0],
self.yaml_obj['p2'][1], self.yaml_obj['p2'][2],
self.yaml_obj['p3'][0], self.yaml_obj['p3'][1],
self.yaml_obj['p3'][2], parent_name, offset)
return buf
def c_repr(self, name, parent_name, offset, resources):
material = Material.from_yaml(self.yaml_obj['material'])
transform = Transform.from_yaml(self.yaml_obj['transform'])
buf = """
{2}
{3}
Shape shape_{0} = {1} + {4};
cylinder(shape_{0});
shape_set_material(shape_{0}, material_{0});
shape_set_transform(shape_{0}, transform_{0});
""".format(name, parent_name, material.c_repr(name, resources),
transform.c_repr(name), offset)
if 'min' in self.yaml_obj:
buf += " shape_{0}->fields.cylinder.minimum = {1:.10f};\n".format(
name, self.yaml_obj['min'])
if 'max' in self.yaml_obj:
buf += " shape_{0}->fields.cylinder.maximum = {1:.10f};\n".format(
name, self.yaml_obj['max'])
if 'closed' in self.yaml_obj:
bool_str = 'false'
if self.yaml_obj['closed']:
bool_str = 'true'
buf += " shape_{0}->fields.cylinder.closed = {1};\n".format(
name, bool_str)
return buf
def c_repr(self, name, parent_name, offset, resources):
if 'transform' not in self.yaml_obj:
yaml_obj['transform'] = []
transform = Transform.from_yaml(self.yaml_obj['transform'])
children = []
for child in self.yaml_obj['children']:
children.append(Shape.from_yaml(child, self.defines))
buf = """
/* children for {0} */
Shape shape_{0}_children = array_of_shapes({1});
""".format(name, len(children))
for i, child in enumerate(children):
buf += """
{0}
""".format(
child.c_repr('{0}_child_{1}'.format(name, i),
'shape_{0}_children'.format(name), i, resources))
file_name = child.get_file_name()
if file_name is not None:
resources[file_name] = 'shape_{0}_child_{1}'.format(name, i)
buf += """ /* end children for {0} */
{2}
Shape shape_{0} = {1} + {4};
group(shape_{0}, shape_{0}_children, {3});
//shape_free(shape_{0}_children);
shape_set_transform(shape_{0}, transform_{0});
""".format(name, parent_name, transform.c_repr(name), len(children), offset)
return buf
def c_repr(self, name, parent_name, offset, resources):
transform = Transform.from_yaml(self.yaml_obj['transform'])
left = Shape.from_yaml(self.yaml_obj['left'], self.defines)
right = Shape.from_yaml(self.yaml_obj['right'], self.defines)
if 'op' in self.yaml_obj:
op = self.yaml_obj['op']
else:
op = self.yaml_obj['operation']
if op == 'difference':
op_str = 'CSG_DIFFERENCE'
elif op == 'intersection':
op_str = 'CSG_INTERSECT'
elif op == 'union':
op_str = 'CSG_UNION'
else:
raise ValueError("Unknown CSG operation: {}".format(op))
buf = """
/* children for {0} */
Shape shape_{0}_children = array_of_shapes({1});
""".format(name, 2)
buf += """ {0}""".format(
left.c_repr('{}_left'.format(name),
'shape_{0}_children'.format(name), 0, resources))
file_name = left.get_file_name()
if file_name is not None:
resources[file_name] = 'shape_{}_left'.format(name)
buf += """ {0}""".format(
right.c_repr('{}_right'.format(name),
'shape_{0}_children'.format(name), 1, resources))
file_name = right.get_file_name()
if file_name is not None:
resources[file_name] = 'shape_{}_right'.format(name)
buf += """
/* end children for {0} */
{2}
Shape shape_{0} = {1} + {4};
csg(shape_{0}, {3}, shape_{0}_left, shape_{0}_right);
shape_set_transform(shape_{0}, transform_{0});
""".format(name, parent_name, transform.c_repr(name), op_str, offset)
return buf
def c_repr(self, name, parent_name, offset, resources):
material = Material.from_yaml(self.yaml_obj['material'])
transform = Transform.from_yaml(self.yaml_obj['transform'])
buf = """
{2}
{3}
Shape shape_{0} = {1} + {4};
cube(shape_{0});
shape_set_material(shape_{0}, material_{0});
shape_set_transform(shape_{0}, transform_{0});
""".format(name, parent_name, material.c_repr(name, resources),
transform.c_repr(name), offset)
return buf
def c_repr(self, name, parent_name, offset, resources):
material = Material.from_yaml(self.yaml_obj['material'])
transform = Transform.from_yaml(self.yaml_obj['transform'])
buf = """
{2}
{3}
Shape shape_{0} = {1} + {4};
toroid(shape_{0});
shape_{0}->fields.toroid.r1 = {5};
shape_{0}->fields.toroid.r2 = {6};
shape_set_material(shape_{0}, material_{0});
shape_set_transform(shape_{0}, transform_{0});
""".format(name, parent_name, material.c_repr(name, resources),
transform.c_repr(name), offset, self.yaml_obj['r1'],
self.yaml_obj['r2'])
return buf
def c_repr(self, name, parent_name, offset, resources):
if 'material' not in self.yaml_obj:
self.yaml_obj['material'] = {}
if 'transform' not in self.yaml_obj:
self.yaml_obj['transform'] = []
material = Material.from_yaml(self.yaml_obj['material'])
transform = Transform.from_yaml(self.yaml_obj['transform'])
buf = """
{1}
{2}
Point shape_{0}_p1 = point({3:.10f}, {4:.10f}, {5:.10f});
Point shape_{0}_p2 = point({6:.10f}, {7:.10f}, {8:.10f});
Point shape_{0}_p3 = point({9:.10f}, {10:.10f}, {11:.10f});
Vector shape_{0}_n1 = vector({12:.10f}, {13:.10f}, {14:.10f});
Vector shape_{0}_n2 = vector({15:.10f}, {16:.10f}, {17:.10f});
Vector shape_{0}_n3 = vector({18:.10f}, {19:.10f}, {20:.10f});
Shape shape_{0} = {21} + {22};
smooth_triangle(shape_{0}, shape_{0}_p1->arr, shape_{0}_p2->arr, shape_{0}_p3->arr, shape_{0}_n1->arr, shape_{0}_n2->arr, shape_{0}_n3->arr);
shape_set_material(shape_{0}, material_{0});
shape_set_transform(shape_{0}, transform_{0});
vector_free(shape_{0}_n3);
vector_free(shape_{0}_n2);
vector_free(shape_{0}_n1);
point_free(shape_{0}_p3);
point_free(shape_{0}_p2);
point_free(shape_{0}_p1);
""".format(name, material.c_repr(name, resources), transform.c_repr(name),
self.yaml_obj['p1'][0], self.yaml_obj['p1'][1],
self.yaml_obj['p1'][2], self.yaml_obj['p2'][0],
self.yaml_obj['p2'][1], self.yaml_obj['p2'][2],
self.yaml_obj['p3'][0], self.yaml_obj['p3'][1],
self.yaml_obj['p3'][2], self.yaml_obj['n1'][0],
self.yaml_obj['n1'][1], self.yaml_obj['n1'][2],
self.yaml_obj['n2'][0], self.yaml_obj['n2'][1],
self.yaml_obj['n2'][2], self.yaml_obj['n3'][0],
self.yaml_obj['n3'][1], self.yaml_obj['n3'][2], parent_name, offset)
return buf
def c_repr(self, name, resources):
if len(self.yaml_obj) == 0:
return " Pattern pattern_{0} = NULL;\n".format(name)
if 'transform' not in self.yaml_obj:
self.yaml_obj['transform'] = []
transform = Transform.from_yaml(self.yaml_obj['transform'])
buf = "{}\n".format(transform.c_repr("pattern_{0}".format(name)))
typ = self.yaml_obj['type']
# base patterns
if typ in ['checker', 'checkers', 'gradient', 'radial-gradient', 'rings', 'ring', 'stripe', 'stripes']:
if typ == 'rings':
typ = 'ring'
if typ == 'checkers':
typ = 'checker'
if typ == 'stripes':
typ = 'stripe'
buf += """ Color pattern_{0}_color_0_raw = color({2:.10f}, {3:.10f}, {4:.10f});
Color pattern_{0}_color_1_raw = color({5:.10f}, {6:.10f}, {7:.10f});
Color pattern_{0}_color_0;
Color pattern_{0}_color_1;
color_space_fn(pattern_{0}_color_0_raw, pattern_{0}_color_0);
color_space_fn(pattern_{0}_color_1_raw, pattern_{0}_color_1);
Pattern pattern_{0} = {1}_pattern_alloc(pattern_{0}_color_0, pattern_{0}_color_1);
""".format(name, typ,
self.yaml_obj['colors'][0][0], self.yaml_obj['colors'][0][1], self.yaml_obj['colors'][0][2],
self.yaml_obj['colors'][1][0], self.yaml_obj['colors'][1][1], self.yaml_obj['colors'][1][2])
# nested patterns
elif typ == 'blended':
pattern1 = Pattern.from_yaml(self.yaml_obj['left'])
pattern2 = Pattern.from_yaml(self.yaml_obj['right'])
buf += """ {1}
{2}
Pattern pattern_{0} = blended_pattern_alloc(pattern_blended_{0}_0, pattern_blended_{0}_1);
""".format(name, pattern1.c_repr("blended_{0}_0".format(name), resources), pattern2.c_repr("blended_{0}_1".format(name), resources))
elif typ == 'nested':
pattern1 = Pattern.from_yaml(self.yaml_obj['primary'])
pattern2 = Pattern.from_yaml(self.yaml_obj['left'])
pattern3 = Pattern.from_yaml(self.yaml_obj['right'])
buf += """ {1}
{2}
{3}
Pattern pattern_{0} = nested_pattern_alloc(pattern_nested_{0}_0, pattern_nested_{0}_1, pattern_nested_{0}_2);
""".format(name, pattern1.c_repr("nested_{0}_0".format(name), resources), pattern2.c_repr("nested_{0}_1".format(name), resources), pattern1.c_repr("nested_{0}_2".format(name), resources))
elif typ == 'perturbed':
freq = 1.0
scale_factor = 0.01
persistence = 0.7
octaves = 1
seed = 0
if 'frequency' in self.yaml_obj:
freq = self.yaml_obj['frequency']
if 'scale-factor' in self.yaml_obj:
scale_factor = self.yaml_obj['scale-factor']
if 'octaves' in self.yaml_obj:
octaves = self.yaml_obj['octaves']
if 'persistence' in self.yaml_obj:
persistence = self.yaml_obj['persistence']
if 'seed' in self.yaml_obj:
seed = self.yaml_obj['seed']
pattern1 = Pattern.from_yaml(self.yaml_obj['primary'])
buf += """ {1}
Pattern pattern_{0} = perturbed_pattern_alloc(pattern_perturbed_{0}_0, {2:.10f}, {3:.10f}, {4:.10f}, {5}, {6});
""".format(name, pattern1.c_repr("perturbed_{0}_0".format(name), resources), freq, scale_factor, persistence, octaves, seed)
# uv mapped patterns
elif typ == 'map':
mapping = self.yaml_obj['mapping']
if mapping in ['cube', 'cubic']:
uv_left = UVPattern.uv_from_yaml(self.yaml_obj['left'])
uv_front = UVPattern.uv_from_yaml(self.yaml_obj['front'])
uv_right = UVPattern.uv_from_yaml(self.yaml_obj['right'])
uv_back = UVPattern.uv_from_yaml(self.yaml_obj['back'])
uv_up = UVPattern.uv_from_yaml(self.yaml_obj['up'])
uv_down = UVPattern.uv_from_yaml(self.yaml_obj['down'])
buf += """ Pattern pattern_{0} = array_of_patterns(7);
Pattern pattern_{0}_right = pattern_{0} + 1;
Pattern pattern_{0}_left = pattern_{0} + 2;
Pattern pattern_{0}_up = pattern_{0} + 3;
Pattern pattern_{0}_down = pattern_{0} + 4;
Pattern pattern_{0}_front = pattern_{0} + 5;
Pattern pattern_{0}_back = pattern_{0} + 6;
{1}
{2}
{3}
{4}
{5}
{6}
texture_map_pattern(pattern_{0}_right, CUBE_UV_MAP, pattern_{0});
""".format(name,
uv_right.c_repr('pattern_{0}_right'.format(name), resources),
uv_left.c_repr('pattern_{0}_left'.format(name), resources),
uv_up.c_repr('pattern_{0}_up'.format(name), resources),
uv_down.c_repr('pattern_{0}_down'.format(name), resources),
uv_front.c_repr('pattern_{0}_front'.format(name), resources),
uv_back.c_repr('pattern_{0}_back'.format(name), resources))
elif mapping in ['cylindrical', 'cylinder']:
# handle single pattern and three patterns for cylinder
if 'uv_pattern' in self.yaml_obj:
uv_top = UVPattern.uv_from_yaml(self.yaml_obj['uv_pattern'])
uv_bottom = uv_top
uv_body = uv_top
else:
uv_top = UVPattern.uv_from_yaml(self.yaml_obj['top'])
uv_bottom = UVPattern.uv_from_yaml(self.yaml_obj['bottom'])
uv_body = UVPattern.uv_from_yaml(self.yaml_obj['front'])
buf += """ Pattern pattern_{0} = array_of_patterns(4);
Pattern pattern_{0}_body = pattern_{0} + 1;
Pattern pattern_{0}_top = pattern_{0} + 2;
Pattern pattern_{0}_bottom = pattern_{0} + 3;
""".format(name)
buf += """{1}
{2}
{3}
texture_map_pattern(pattern_{0}_body, CYLINDER_UV_MAP, pattern_{0});
""".format(name,
uv_body.c_repr('pattern_{0}_body'.format(name), resources),
uv_top.c_repr('pattern_{0}_top'.format(name), resources),
uv_bottom.c_repr('pattern_{0}_bottom'.format(name), resources))
elif mapping in ['triangular', 'triangle']:
uv_pattern = UVPattern.uv_from_yaml(self.yaml_obj['uv_pattern'])
buf += """ Pattern pattern_{0} = array_of_patterns(2);
Pattern pattern_{0}_body = pattern_{0} + 1;
{1}
texture_map_pattern(pattern_{0}_body, TRIANGLE_UV_MAP, pattern_{0});
""".format(name, uv_pattern.c_repr('pattern_{0}_body'.format(name), resources))
elif mapping in ['planar', 'plane']:
uv_pattern = UVPattern.uv_from_yaml(self.yaml_obj['uv_pattern'])
buf += """ Pattern pattern_{0} = array_of_patterns(2);
Pattern pattern_{0}_body = pattern_{0} + 1;
{1}
texture_map_pattern(pattern_{0}_body, PLANE_UV_MAP, pattern_{0});
""".format(name, uv_pattern.c_repr('pattern_{0}_body'.format(name), resources))
elif mapping in ['spherical', 'sphere']:
uv_pattern = UVPattern.uv_from_yaml(self.yaml_obj['uv_pattern'])
buf += """ Pattern pattern_{0} = array_of_patterns(2);
Pattern pattern_{0}_body = pattern_{0} + 1;
{1}
texture_map_pattern(pattern_{0}_body, SPHERE_UV_MAP, pattern_{0});
""".format(name, uv_pattern.c_repr('pattern_{0}_body'.format(name), resources))
elif mapping in ['toroidal', 'toroid', 'torus']:
uv_pattern = UVPattern.uv_from_yaml(self.yaml_obj['uv_pattern'])
buf += """ Pattern pattern_{0} = array_of_patterns(2);
Pattern pattern_{0}_body = pattern_{0} + 1;
{1}
texture_map_pattern(pattern_{0}_body, TOROID_UV_MAP, pattern_{0});
""".format(name, uv_pattern.c_repr('pattern_{0}_body'.format(name), resources))
else:
raise ValueError('Unable to parse pattern type: {}'.format(typ))
buf += " pattern_set_transform(pattern_{0}, transform_pattern_{0});\n".format(name)
return buf
