# SPDX-FileCopyrightText: 2009-2023 Blender Authors # # SPDX-License-Identifier: GPL-2.0-or-later # Authors : Tamito Kajiyama # Date : 26/07/2010 # Purpose : Interactive manipulation of stylization parameters from freestyle.types import ( BinaryPredicate1D, IntegrationType, Interface0DIterator, Nature, Noise, Operators, StrokeAttribute, UnaryPredicate0D, UnaryPredicate1D, TVertex, Material, ViewEdge, ) from freestyle.chainingiterators import ( ChainPredicateIterator, ChainSilhouetteIterator, pySketchyChainSilhouetteIterator, pySketchyChainingIterator, ) from freestyle.functions import ( Curvature2DAngleF0D, Normal2DF0D, QuantitativeInvisibilityF1D, VertexOrientation2DF0D, CurveMaterialF0D, ) from freestyle.predicates import ( AndUP1D, ContourUP1D, ExternalContourUP1D, FalseBP1D, FalseUP1D, Length2DBP1D, NotBP1D, NotUP1D, OrUP1D, QuantitativeInvisibilityUP1D, TrueBP1D, TrueUP1D, WithinImageBoundaryUP1D, pyNFirstUP1D, pyNatureUP1D, pyProjectedXBP1D, pyProjectedYBP1D, pyZBP1D, ) from freestyle.shaders import ( BackboneStretcherShader, BezierCurveShader, BlenderTextureShader, ConstantColorShader, GuidingLinesShader, PolygonalizationShader, pyBluePrintCirclesShader, pyBluePrintEllipsesShader, pyBluePrintSquaresShader, RoundCapShader, SamplingShader, SpatialNoiseShader, SquareCapShader, StrokeShader, StrokeTextureStepShader, ThicknessNoiseShader as thickness_noise, TipRemoverShader, ) from freestyle.utils import ( angle_x_normal, bound, BoundedProperty, ContextFunctions, curvature_from_stroke_vertex, getCurrentScene, iter_distance_along_stroke, iter_distance_from_camera, iter_distance_from_object, iter_material_value, iter_t2d_along_stroke, normal_at_I0D, pairwise, simplify, stroke_normal, ) from _freestyle import ( blendRamp, evaluateColorRamp, evaluateCurveMappingF, ) import time import bpy from mathutils import Vector from math import pi, sin, cos, acos, radians from itertools import cycle # WARNING: highly experimental, not a stable API # lists of callback functions # used by the render_freestyle_svg addon callbacks_lineset_pre = [] callbacks_modifiers_post = [] callbacks_lineset_post = [] class ColorRampModifier(StrokeShader): """Primitive for the color modifiers.""" def __init__(self, blend, influence, ramp): StrokeShader.__init__(self) self.blend = blend self.influence = influence self.ramp = ramp def evaluate(self, t): col = evaluateColorRamp(self.ramp, t) return col.xyz # omit alpha def blend_ramp(self, a, b): return blendRamp(self.blend, a, self.influence, b) class ScalarBlendModifier(StrokeShader): """Primitive for alpha and thickness modifiers.""" def __init__(self, blend_type, influence): StrokeShader.__init__(self) self.blend_type = blend_type self.influence = influence def blend(self, v1, v2): fac = self.influence facm = 1.0 - fac if self.blend_type == 'MIX': v1 = facm * v1 + fac * v2 elif self.blend_type == 'ADD': v1 += fac * v2 elif self.blend_type == 'MULTIPLY': v1 *= facm + fac * v2 elif self.blend_type == 'SUBTRACT': v1 -= fac * v2 elif self.blend_type == 'DIVIDE': v1 = facm * v1 + fac * v1 / v2 if v2 != 0.0 else v1 elif self.blend_type == 'DIFFERENCE': v1 = facm * v1 + fac * abs(v1 - v2) elif self.blend_type == 'MINIMUM': v1 = min(fac * v2, v1) elif self.blend_type == 'MAXIMUM': v1 = max(fac * v2, v1) else: raise ValueError("unknown curve blend type: " + self.blend_type) return v1 class CurveMappingModifier(ScalarBlendModifier): def __init__(self, blend, influence, mapping, invert, curve): ScalarBlendModifier.__init__(self, blend, influence) assert mapping in {'LINEAR', 'CURVE'} self.evaluate = getattr(self, mapping) self.invert = invert self.curve = curve def LINEAR(self, t): return (1.0 - t) if self.invert else t def CURVE(self, t): # deprecated: return evaluateCurveMappingF(self.curve, 0, t) curve = self.curve curve.initialize() result = curve.evaluate(curve=curve.curves[0], position=t) # float precision errors in t can give a very weird result for evaluate. # therefore, bound the result by the curve's min and max values return bound(curve.clip_min_y, result, curve.clip_max_y) class ThicknessModifierMixIn: def __init__(self): scene = getCurrentScene() self.persp_camera = (scene.camera.data.type == 'PERSP') def set_thickness(self, sv, outer, inner): fe = sv.fedge nature = fe.nature if (nature & Nature.BORDER): if self.persp_camera: point = -sv.point_3d.normalized() dir = point.dot(fe.normal_left) else: dir = fe.normal_left.z if dir < 0.0: # the back side is visible outer, inner = inner, outer elif (nature & Nature.SILHOUETTE): if fe.is_smooth: # TODO more tests needed outer, inner = inner, outer else: outer = inner = (outer + inner) / 2 sv.attribute.thickness = (outer, inner) class ThicknessBlenderMixIn(ThicknessModifierMixIn): def __init__(self, position, ratio): ThicknessModifierMixIn.__init__(self) self.position = position self.ratio = ratio def blend_thickness(self, svert, thickness, asymmetric=False): """Blends and sets the thickness with respect to the position, blend mode and symmetry.""" if asymmetric: right, left = thickness self.blend_thickness_asymmetric(svert, right, left) else: if type(thickness) not in {int, float}: thickness = sum(thickness) self.blend_thickness_symmetric(svert, thickness) def blend_thickness_symmetric(self, svert, v): """Blends and sets the thickness. Thickness is equal on each side of the backbone""" outer, inner = svert.attribute.thickness v = self.blend(outer + inner, v) # Part 1: blend if self.position == 'CENTER': outer = inner = v * 0.5 elif self.position == 'INSIDE': outer, inner = 0, v elif self.position == 'OUTSIDE': outer, inner = v, 0 elif self.position == 'RELATIVE': outer, inner = v * self.ratio, v - (v * self.ratio) else: raise ValueError("unknown thickness position: " + position) self.set_thickness(svert, outer, inner) def blend_thickness_asymmetric(self, svert, right, left): """Blends and sets the thickness. Thickness may be unequal on each side of the backbone""" # blend the thickness values for both sides. This way, the blend mode is supported. old = svert.attribute.thickness new = (right, left) right, left = (self.blend(*val) for val in zip(old, new)) fe = svert.fedge nature = fe.nature if (nature & Nature.BORDER): if self.persp_camera: point = -svert.point_3d.normalized() dir = point.dot(fe.normal_left) else: dir = fe.normal_left.z if dir < 0.0: # the back side is visible right, left = left, right elif (nature & Nature.SILHOUETTE): if fe.is_smooth: # TODO more tests needed right, left = left, right svert.attribute.thickness = (right, left) class BaseThicknessShader(StrokeShader, ThicknessModifierMixIn): def __init__(self, thickness, position, ratio): StrokeShader.__init__(self) ThicknessModifierMixIn.__init__(self) if position == 'CENTER': self.outer = thickness * 0.5 self.inner = thickness - self.outer elif position == 'INSIDE': self.outer = 0 self.inner = thickness elif position == 'OUTSIDE': self.outer = thickness self.inner = 0 elif position == 'RELATIVE': self.outer = thickness * ratio self.inner = thickness - self.outer else: raise ValueError("unknown thickness position: " + position) def shade(self, stroke): for svert in stroke: self.set_thickness(svert, self.outer, self.inner) # Along Stroke modifiers class ColorAlongStrokeShader(ColorRampModifier): """Maps a ramp to the color of the stroke, using the curvilinear abscissa (t).""" def shade(self, stroke): for svert, t in zip(stroke, iter_t2d_along_stroke(stroke)): a = svert.attribute.color b = self.evaluate(t) svert.attribute.color = self.blend_ramp(a, b) class AlphaAlongStrokeShader(CurveMappingModifier): """Maps a curve to the alpha/transparency of the stroke, using the curvilinear abscissa (t).""" def shade(self, stroke): for svert, t in zip(stroke, iter_t2d_along_stroke(stroke)): a = svert.attribute.alpha b = self.evaluate(t) svert.attribute.alpha = self.blend(a, b) class ThicknessAlongStrokeShader(ThicknessBlenderMixIn, CurveMappingModifier): """Maps a curve to the thickness of the stroke, using the curvilinear abscissa (t).""" def __init__(self, thickness_position, thickness_ratio, blend, influence, mapping, invert, curve, value_min, value_max): ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio) CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) self.value = BoundedProperty(value_min, value_max) def shade(self, stroke): for svert, t in zip(stroke, iter_t2d_along_stroke(stroke)): b = self.value.min + self.evaluate(t) * self.value.delta self.blend_thickness(svert, b) # -- Distance from Camera modifiers -- # class ColorDistanceFromCameraShader(ColorRampModifier): """Picks a color value from a ramp based on the vertex' distance from the camera.""" def __init__(self, blend, influence, ramp, range_min, range_max): ColorRampModifier.__init__(self, blend, influence, ramp) self.range = BoundedProperty(range_min, range_max) def shade(self, stroke): it = iter_distance_from_camera(stroke, *self.range) for svert, t in it: a = svert.attribute.color b = self.evaluate(t) svert.attribute.color = self.blend_ramp(a, b) class AlphaDistanceFromCameraShader(CurveMappingModifier): """Picks an alpha value from a curve based on the vertex' distance from the camera""" def __init__(self, blend, influence, mapping, invert, curve, range_min, range_max): CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) self.range = BoundedProperty(range_min, range_max) def shade(self, stroke): it = iter_distance_from_camera(stroke, *self.range) for svert, t in it: a = svert.attribute.alpha b = self.evaluate(t) svert.attribute.alpha = self.blend(a, b) class ThicknessDistanceFromCameraShader(ThicknessBlenderMixIn, CurveMappingModifier): """Picks a thickness value from a curve based on the vertex' distance from the camera.""" def __init__(self, thickness_position, thickness_ratio, blend, influence, mapping, invert, curve, range_min, range_max, value_min, value_max): ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio) CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) self.range = BoundedProperty(range_min, range_max) self.value = BoundedProperty(value_min, value_max) def shade(self, stroke): for (svert, t) in iter_distance_from_camera(stroke, *self.range): b = self.value.min + self.evaluate(t) * self.value.delta self.blend_thickness(svert, b) # Distance from Object modifiers class ColorDistanceFromObjectShader(ColorRampModifier): """Picks a color value from a ramp based on the vertex' distance from a given object.""" def __init__(self, blend, influence, ramp, target, range_min, range_max): ColorRampModifier.__init__(self, blend, influence, ramp) if target is None: raise ValueError("ColorDistanceFromObjectShader: target can't be None ") self.range = BoundedProperty(range_min, range_max) # construct a model-view matrix matrix = getCurrentScene().camera.matrix_world.inverted() # get the object location in the camera coordinate self.loc = matrix @ target.location def shade(self, stroke): it = iter_distance_from_object(stroke, self.loc, *self.range) for svert, t in it: a = svert.attribute.color b = self.evaluate(t) svert.attribute.color = self.blend_ramp(a, b) class AlphaDistanceFromObjectShader(CurveMappingModifier): """Picks an alpha value from a curve based on the vertex' distance from a given object.""" def __init__(self, blend, influence, mapping, invert, curve, target, range_min, range_max): CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) if target is None: raise ValueError("AlphaDistanceFromObjectShader: target can't be None ") self.range = BoundedProperty(range_min, range_max) # construct a model-view matrix matrix = getCurrentScene().camera.matrix_world.inverted() # get the object location in the camera coordinate self.loc = matrix @ target.location def shade(self, stroke): it = iter_distance_from_object(stroke, self.loc, *self.range) for svert, t in it: a = svert.attribute.alpha b = self.evaluate(t) svert.attribute.alpha = self.blend(a, b) class ThicknessDistanceFromObjectShader(ThicknessBlenderMixIn, CurveMappingModifier): """Picks a thickness value from a curve based on the vertex' distance from a given object.""" def __init__(self, thickness_position, thickness_ratio, blend, influence, mapping, invert, curve, target, range_min, range_max, value_min, value_max): ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio) CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) if target is None: raise ValueError("ThicknessDistanceFromObjectShader: target can't be None ") self.range = BoundedProperty(range_min, range_max) self.value = BoundedProperty(value_min, value_max) # construct a model-view matrix matrix = getCurrentScene().camera.matrix_world.inverted() # get the object location in the camera coordinate self.loc = matrix @ target.location def shade(self, stroke): it = iter_distance_from_object(stroke, self.loc, *self.range) for svert, t in it: b = self.value.min + self.evaluate(t) * self.value.delta self.blend_thickness(svert, b) # Material modifiers class ColorMaterialShader(ColorRampModifier): """Assigns a color to the vertices based on their underlying material.""" def __init__(self, blend, influence, ramp, material_attribute, use_ramp): ColorRampModifier.__init__(self, blend, influence, ramp) self.attribute = material_attribute self.use_ramp = use_ramp self.func = CurveMaterialF0D() def shade(self, stroke, attributes={'DIFF', 'SPEC', 'LINE'}): it = Interface0DIterator(stroke) if not self.use_ramp and self.attribute in attributes: for svert in it: material = self.func(it) if self.attribute == 'LINE': b = material.line[0:3] elif self.attribute == 'DIFF': b = material.diffuse[0:3] else: b = material.specular[0:3] a = svert.attribute.color svert.attribute.color = self.blend_ramp(a, b) else: for svert, value in iter_material_value(stroke, self.func, self.attribute): a = svert.attribute.color b = self.evaluate(value) svert.attribute.color = self.blend_ramp(a, b) class AlphaMaterialShader(CurveMappingModifier): """Assigns an alpha value to the vertices based on their underlying material.""" def __init__(self, blend, influence, mapping, invert, curve, material_attribute): CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) self.attribute = material_attribute self.func = CurveMaterialF0D() def shade(self, stroke): for svert, value in iter_material_value(stroke, self.func, self.attribute): a = svert.attribute.alpha b = self.evaluate(value) svert.attribute.alpha = self.blend(a, b) class ThicknessMaterialShader(ThicknessBlenderMixIn, CurveMappingModifier): """Assigns a thickness value to the vertices based on their underlying material.""" def __init__(self, thickness_position, thickness_ratio, blend, influence, mapping, invert, curve, material_attribute, value_min, value_max): ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio) CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) self.attribute = material_attribute self.value = BoundedProperty(value_min, value_max) self.func = CurveMaterialF0D() def shade(self, stroke): for svert, value in iter_material_value(stroke, self.func, self.attribute): b = self.value.min + self.evaluate(value) * self.value.delta self.blend_thickness(svert, b) # Calligraphic thickness modifier class CalligraphicThicknessShader(ThicknessBlenderMixIn, ScalarBlendModifier): """Thickness modifier for achieving a calligraphy-like effect.""" def __init__(self, thickness_position, thickness_ratio, blend_type, influence, orientation, thickness_min, thickness_max): ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio) ScalarBlendModifier.__init__(self, blend_type, influence) self.orientation = Vector((cos(orientation), sin(orientation))) self.thickness = BoundedProperty(thickness_min, thickness_max) self.func = VertexOrientation2DF0D() def shade(self, stroke): it = Interface0DIterator(stroke) for svert in it: dir = self.func(it) if dir.length != 0.0: dir.normalize() fac = abs(dir.orthogonal() @ self.orientation) b = self.thickness.min + fac * self.thickness.delta else: b = self.thickness.min self.blend_thickness(svert, b) # - Tangent Modifiers - # class TangentColorShader(ColorRampModifier): """Color based on the direction of the stroke""" def shade(self, stroke): it = Interface0DIterator(stroke) for svert in it: angle = angle_x_normal(it) fac = self.evaluate(angle / pi) a = svert.attribute.color svert.attribute.color = self.blend_ramp(a, fac) class TangentAlphaShader(CurveMappingModifier): """Alpha transparency based on the direction of the stroke""" def shade(self, stroke): it = Interface0DIterator(stroke) for svert in it: angle = angle_x_normal(it) fac = self.evaluate(angle / pi) a = svert.attribute.alpha svert.attribute.alpha = self.blend(a, fac) class TangentThicknessShader(ThicknessBlenderMixIn, CurveMappingModifier): """Thickness based on the direction of the stroke""" def __init__(self, thickness_position, thickness_ratio, blend, influence, mapping, invert, curve, thickness_min, thickness_max): ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio) CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) self.thickness = BoundedProperty(thickness_min, thickness_max) def shade(self, stroke): it = Interface0DIterator(stroke) for svert in it: angle = angle_x_normal(it) thickness = self.thickness.min + self.evaluate(angle / pi) * self.thickness.delta self.blend_thickness(svert, thickness) # - Noise Modifiers - # class NoiseShader: """Base class for noise shaders""" def __init__(self, amplitude, period, seed=512): self.amplitude = amplitude self.scale = 1 / period / seed self.seed = seed def noisegen(self, stroke, n1=Noise(), n2=Noise()): """Produces two noise values per StrokeVertex for every vertex in the stroke""" initU1 = stroke.length_2d * self.seed + n1.rand(512) * self.seed initU2 = stroke.length_2d * self.seed + n2.rand() * self.seed for svert in stroke: a = n1.turbulence_smooth(self.scale * svert.curvilinear_abscissa + initU1, 2) b = n2.turbulence_smooth(self.scale * svert.curvilinear_abscissa + initU2, 2) yield (svert, a, b) class ThicknessNoiseShader(ThicknessBlenderMixIn, ScalarBlendModifier, NoiseShader): """Thickness based on pseudo-noise""" def __init__(self, thickness_position, thickness_ratio, blend_type, influence, amplitude, period, seed=512, asymmetric=True): ScalarBlendModifier.__init__(self, blend_type, influence) ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio) NoiseShader.__init__(self, amplitude, period, seed) self.asymmetric = asymmetric def shade(self, stroke): for svert, noiseval1, noiseval2 in self.noisegen(stroke): (r, l) = svert.attribute.thickness l += noiseval1 * self.amplitude r += noiseval2 * self.amplitude self.blend_thickness(svert, (r, l), self.asymmetric) class ColorNoiseShader(ColorRampModifier, NoiseShader): """Color based on pseudo-noise""" def __init__(self, blend, influence, ramp, amplitude, period, seed=512): ColorRampModifier.__init__(self, blend, influence, ramp) NoiseShader.__init__(self, amplitude, period, seed) def shade(self, stroke): for svert, noiseval1, noiseval2 in self.noisegen(stroke): position = abs(noiseval1 + noiseval2) svert.attribute.color = self.blend_ramp(svert.attribute.color, self.evaluate(position)) class AlphaNoiseShader(CurveMappingModifier, NoiseShader): """Alpha transparency on based pseudo-noise""" def __init__(self, blend, influence, mapping, invert, curve, amplitude, period, seed=512): CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) NoiseShader.__init__(self, amplitude, period, seed) def shade(self, stroke, n1=Noise(), n2=Noise()): for svert, noiseval1, noiseval2 in self.noisegen(stroke): position = abs(noiseval1 + noiseval2) svert.attribute.alpha = self.blend(svert.attribute.alpha, self.evaluate(position)) # - Crease Angle Modifiers - # def crease_angle(svert): """Returns the crease angle between the StrokeVertex' two adjacent faces (in radians)""" fe = svert.fedge if not fe or fe.is_smooth or not (fe.nature & Nature.CREASE): return None # make sure that the input is within the domain of the acos function product = bound(-1.0, -fe.normal_left.dot(fe.normal_right), 1.0) return acos(product) class CreaseAngleColorShader(ColorRampModifier): """Color based on the crease angle between two adjacent faces on the underlying geometry""" def __init__(self, blend, influence, ramp, angle_min, angle_max): ColorRampModifier.__init__(self, blend, influence, ramp) # angles are (already) in radians self.angle = BoundedProperty(angle_min, angle_max) def shade(self, stroke): for svert in stroke: angle = crease_angle(svert) if angle is None: continue t = self.angle.interpolate(angle) svert.attribute.color = self.blend_ramp(svert.attribute.color, self.evaluate(t)) class CreaseAngleAlphaShader(CurveMappingModifier): """Alpha transparency based on the crease angle between two adjacent faces on the underlying geometry""" def __init__(self, blend, influence, mapping, invert, curve, angle_min, angle_max): CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) # angles are (already) in radians self.angle = BoundedProperty(angle_min, angle_max) def shade(self, stroke): for svert in stroke: angle = crease_angle(svert) if angle is None: continue t = self.angle.interpolate(angle) svert.attribute.alpha = self.blend(svert.attribute.alpha, self.evaluate(t)) class CreaseAngleThicknessShader(ThicknessBlenderMixIn, CurveMappingModifier): """Thickness based on the crease angle between two adjacent faces on the underlying geometry""" def __init__(self, thickness_position, thickness_ratio, blend, influence, mapping, invert, curve, angle_min, angle_max, thickness_min, thickness_max): ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio) CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) # angles are (already) in radians self.angle = BoundedProperty(angle_min, angle_max) self.thickness = BoundedProperty(thickness_min, thickness_max) def shade(self, stroke): for svert in stroke: angle = crease_angle(svert) if angle is None: continue t = self.angle.interpolate(angle) thickness = self.thickness.min + self.evaluate(t) * self.thickness.delta self.blend_thickness(svert, thickness) # - Curvature3D Modifiers - # def normalized_absolute_curvature(svert, bounded_curvature): """ Gives the absolute curvature in range [0, 1]. The actual curvature (Kr) value can be anywhere in the range [-inf, inf], where convex curvature yields a positive value, and concave a negative one. These shaders only look for the magnitude of the 3D curvature, hence the abs() """ curvature = curvature_from_stroke_vertex(svert) if curvature is None: return 0.0 return bounded_curvature.interpolate(abs(curvature)) class Curvature3DColorShader(ColorRampModifier): """Color based on the 3D curvature of the underlying geometry""" def __init__(self, blend, influence, ramp, curvature_min, curvature_max): ColorRampModifier.__init__(self, blend, influence, ramp) self.curvature = BoundedProperty(curvature_min, curvature_max) def shade(self, stroke): for svert in stroke: t = normalized_absolute_curvature(svert, self.curvature) a = svert.attribute.color b = self.evaluate(t) svert.attribute.color = self.blend_ramp(a, b) class Curvature3DAlphaShader(CurveMappingModifier): """Alpha based on the 3D curvature of the underlying geometry""" def __init__(self, blend, influence, mapping, invert, curve, curvature_min, curvature_max): CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) self.curvature = BoundedProperty(curvature_min, curvature_max) def shade(self, stroke): for svert in stroke: t = normalized_absolute_curvature(svert, self.curvature) a = svert.attribute.alpha b = self.evaluate(t) svert.attribute.alpha = self.blend(a, b) class Curvature3DThicknessShader(ThicknessBlenderMixIn, CurveMappingModifier): """Alpha based on the 3D curvature of the underlying geometry""" def __init__(self, thickness_position, thickness_ratio, blend, influence, mapping, invert, curve, curvature_min, curvature_max, thickness_min, thickness_max): ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio) CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) self.curvature = BoundedProperty(curvature_min, curvature_max) self.thickness = BoundedProperty(thickness_min, thickness_max) def shade(self, stroke): for svert in stroke: t = normalized_absolute_curvature(svert, self.curvature) thickness = self.thickness.min + self.evaluate(t) * self.thickness.delta self.blend_thickness(svert, thickness) # Geometry modifiers class SimplificationShader(StrokeShader): """Simplifies a stroke by merging points together""" def __init__(self, tolerance): StrokeShader.__init__(self) self.tolerance = tolerance def shade(self, stroke): points = tuple(svert.point for svert in stroke) points_simplified = simplify(points, tolerance=self.tolerance) it = iter(stroke) for svert, point in zip(it, points_simplified): svert.point = point for svert in tuple(it): stroke.remove_vertex(svert) class SinusDisplacementShader(StrokeShader): """Displaces the stroke in a sine wave-like shape.""" def __init__(self, wavelength, amplitude, phase): StrokeShader.__init__(self) self.wavelength = wavelength self.amplitude = amplitude self.phase = phase / wavelength * 2 * pi def shade(self, stroke): # normals are stored in a tuple, so they don't update when we reposition vertices. normals = tuple(stroke_normal(stroke)) distances = iter_distance_along_stroke(stroke) coeff = 1 / self.wavelength * 2 * pi for svert, distance, normal in zip(stroke, distances, normals): n = normal * self.amplitude * cos(distance * coeff + self.phase) svert.point += n stroke.update_length() class PerlinNoise1DShader(StrokeShader): """ Displaces the stroke using the curvilinear abscissa. This means that lines with the same length and sampling interval will be identically distorted. """ def __init__(self, freq=10, amp=10, oct=4, angle=radians(45), seed=-1): StrokeShader.__init__(self) self.noise = Noise(seed) self.freq = freq self.amp = amp self.oct = oct self.dir = Vector((cos(angle), sin(angle))) def shade(self, stroke): length = stroke.length_2d for svert in stroke: nres = self.noise.turbulence1(length * svert.u, self.freq, self.amp, self.oct) svert.point += nres * self.dir stroke.update_length() class PerlinNoise2DShader(StrokeShader): """ Displaces the stroke using the strokes coordinates. This means that in a scene no strokes will be distorted identically. More information on the noise shaders can be found at: https://freestyleintegration.wordpress.com/2011/09/25/development-updates-on-september-25/ """ def __init__(self, freq=10, amp=10, oct=4, angle=radians(45), seed=-1): StrokeShader.__init__(self) self.noise = Noise(seed) self.freq = freq self.amp = amp self.oct = oct self.dir = Vector((cos(angle), sin(angle))) def shade(self, stroke): for svert in stroke: projected = Vector((svert.projected_x, svert.projected_y)) nres = self.noise.turbulence2(projected, self.freq, self.amp, self.oct) svert.point += nres * self.dir stroke.update_length() class Offset2DShader(StrokeShader): """Offsets the stroke by a given amount.""" def __init__(self, start, end, x, y): StrokeShader.__init__(self) self.start = start self.end = end self.xy = Vector((x, y)) def shade(self, stroke): # normals are stored in a tuple, so they don't update when we reposition vertices. normals = tuple(stroke_normal(stroke)) for svert, normal in zip(stroke, normals): a = self.start + svert.u * (self.end - self.start) svert.point += (normal * a) + self.xy stroke.update_length() class Transform2DShader(StrokeShader): """Transforms the stroke (scale, rotation, location) around a given pivot point """ def __init__(self, pivot, scale_x, scale_y, angle, pivot_u, pivot_x, pivot_y): StrokeShader.__init__(self) self.pivot = pivot self.scale = Vector((scale_x, scale_y)) self.cos_theta = cos(angle) self.sin_theta = sin(angle) self.pivot_u = pivot_u self.pivot_x = pivot_x self.pivot_y = pivot_y if pivot not in {'START', 'END', 'CENTER', 'ABSOLUTE', 'PARAM'}: raise ValueError("expected pivot in {'START', 'END', 'CENTER', 'ABSOLUTE', 'PARAM'}, not" + pivot) def shade(self, stroke): # determine the pivot of scaling and rotation operations if self.pivot == 'START': pivot = stroke[0].point elif self.pivot == 'END': pivot = stroke[-1].point elif self.pivot == 'CENTER': # minor rounding errors here, because # given v = Vector(a, b), then (v / n) != Vector(v.x / n, v.y / n) pivot = (1 / len(stroke)) * sum((svert.point for svert in stroke), Vector((0.0, 0.0))) elif self.pivot == 'ABSOLUTE': pivot = Vector((self.pivot_x, self.pivot_y)) elif self.pivot == 'PARAM': if self.pivot_u < stroke[0].u: pivot = stroke[0].point else: for prev, svert in pairwise(stroke): if self.pivot_u < svert.u: break pivot = svert.point + (svert.u - self.pivot_u) * (prev.point - svert.point) # apply scaling and rotation operations for svert in stroke: p = (svert.point - pivot) x = p.x * self.scale.x y = p.y * self.scale.y p.x = x * self.cos_theta - y * self.sin_theta p.y = x * self.sin_theta + y * self.cos_theta svert.point = p + pivot stroke.update_length() # Predicates and helper functions class QuantitativeInvisibilityRangeUP1D(UnaryPredicate1D): def __init__(self, qi_start, qi_end): UnaryPredicate1D.__init__(self) self.getQI = QuantitativeInvisibilityF1D() self.qi_start = qi_start self.qi_end = qi_end def __call__(self, inter): qi = self.getQI(inter) return self.qi_start <= qi <= self.qi_end def getQualifiedObjectName(ob): if ob.library is not None: return ob.library.filepath + '/' + ob.name return ob.name class ObjectNamesUP1D(UnaryPredicate1D): def __init__(self, names, negative): UnaryPredicate1D.__init__(self) self.names = names self.negative = negative def getViewShapeName(self, vs): if vs.library_path is not None and len(vs.library_path): return vs.library_path + '/' + vs.name return vs.name def __call__(self, viewEdge): found = self.getViewShapeName(viewEdge.viewshape) in self.names if self.negative: return not found return found # -- Split by dashed line pattern -- # class SplitPatternStartingUP0D(UnaryPredicate0D): def __init__(self, controller): UnaryPredicate0D.__init__(self) self.controller = controller def __call__(self, inter): return self.controller.start() class SplitPatternStoppingUP0D(UnaryPredicate0D): def __init__(self, controller): UnaryPredicate0D.__init__(self) self.controller = controller def __call__(self, inter): return self.controller.stop() class SplitPatternController: def __init__(self, pattern, sampling): self.sampling = float(sampling) k = len(pattern) // 2 n = k * 2 self.start_pos = [pattern[i] + pattern[i + 1] for i in range(0, n, 2)] self.stop_pos = [pattern[i] for i in range(0, n, 2)] self.init() def init(self): self.start_len = 0.0 self.start_idx = 0 self.stop_len = self.sampling self.stop_idx = 0 def start(self): self.start_len += self.sampling if abs(self.start_len - self.start_pos[self.start_idx]) < self.sampling / 2.0: self.start_len = 0.0 self.start_idx = (self.start_idx + 1) % len(self.start_pos) return True return False def stop(self): if self.start_len > 0.0: self.init() self.stop_len += self.sampling if abs(self.stop_len - self.stop_pos[self.stop_idx]) < self.sampling / 2.0: self.stop_len = self.sampling self.stop_idx = (self.stop_idx + 1) % len(self.stop_pos) return True return False # Dashed line class DashedLineShader(StrokeShader): def __init__(self, pattern): StrokeShader.__init__(self) self.pattern = pattern def shade(self, stroke): start = 0.0 # 2D curvilinear length visible = True # The extra 'sampling' term is added below, because the # visibility attribute of the i-th vertex refers to the # visibility of the stroke segment between the i-th and # (i+1)-th vertices. sampling = 1.0 it = stroke.stroke_vertices_begin(sampling) pattern_cycle = cycle(self.pattern) pattern = next(pattern_cycle) for _svert in it: pos = it.t # curvilinear abscissa if pos - start + sampling > pattern: start = pos pattern = next(pattern_cycle) visible = not visible if not visible: it.object.attribute.visible = False # predicates for chaining class AngleLargerThanBP1D(BinaryPredicate1D): def __init__(self, angle): BinaryPredicate1D.__init__(self) self.angle = angle def __call__(self, i1, i2): sv1a = i1.first_fedge.first_svertex.point_2d sv1b = i1.last_fedge.second_svertex.point_2d sv2a = i2.first_fedge.first_svertex.point_2d sv2b = i2.last_fedge.second_svertex.point_2d if (sv1a - sv2a).length < 1e-6: dir1 = sv1a - sv1b dir2 = sv2b - sv2a elif (sv1b - sv2b).length < 1e-6: dir1 = sv1b - sv1a dir2 = sv2a - sv2b elif (sv1a - sv2b).length < 1e-6: dir1 = sv1a - sv1b dir2 = sv2a - sv2b elif (sv1b - sv2a).length < 1e-6: dir1 = sv1b - sv1a dir2 = sv2b - sv2a else: return False denom = dir1.length * dir2.length if denom < 1e-6: return False x = (dir1 * dir2) / denom return acos(bound(-1.0, x, 1.0)) > self.angle # predicates for selection class LengthThresholdUP1D(UnaryPredicate1D): def __init__(self, length_min=None, length_max=None): UnaryPredicate1D.__init__(self) self.length_min = length_min self.length_max = length_max def __call__(self, inter): length = inter.length_2d if self.length_min is not None and length < self.length_min: return False if self.length_max is not None and length > self.length_max: return False return True class FaceMarkBothUP1D(UnaryPredicate1D): def __call__(self, inter: ViewEdge): fe = inter.first_fedge while fe is not None: if fe.is_smooth: if fe.face_mark: return True elif (fe.nature & Nature.BORDER): if fe.face_mark_left: return True else: if fe.face_mark_right and fe.face_mark_left: return True fe = fe.next_fedge return False class FaceMarkOneUP1D(UnaryPredicate1D): def __call__(self, inter: ViewEdge): fe = inter.first_fedge while fe is not None: if fe.is_smooth: if fe.face_mark: return True elif (fe.nature & Nature.BORDER): if fe.face_mark_left: return True else: if fe.face_mark_right or fe.face_mark_left: return True fe = fe.next_fedge return False # predicates for splitting class MaterialBoundaryUP0D(UnaryPredicate0D): def __call__(self, it): # can't use only it.is_end here, see commit rBeb8964fb7f19 if it.is_begin or it.at_last or it.is_end: return False it.decrement() prev, v, succ = next(it), next(it), next(it) fe = v.get_fedge(prev) idx1 = fe.material_index if fe.is_smooth else fe.material_index_left fe = v.get_fedge(succ) idx2 = fe.material_index if fe.is_smooth else fe.material_index_left return idx1 != idx2 class Curvature2DAngleThresholdUP0D(UnaryPredicate0D): def __init__(self, angle_min=None, angle_max=None): UnaryPredicate0D.__init__(self) self.angle_min = angle_min self.angle_max = angle_max self.func = Curvature2DAngleF0D() def __call__(self, inter): angle = pi - self.func(inter) if self.angle_min is not None and angle < self.angle_min: return True if self.angle_max is not None and angle > self.angle_max: return True return False class Length2DThresholdUP0D(UnaryPredicate0D): def __init__(self, length_limit): UnaryPredicate0D.__init__(self) self.length_limit = length_limit self.t = 0.0 def __call__(self, inter): t = inter.t # curvilinear abscissa if t < self.t: self.t = 0.0 return False if t - self.t < self.length_limit: return False self.t = t return True # Seed for random number generation class Seed: def __init__(self): self.t_max = 2 ** 15 self.t = int(time.time()) % self.t_max def get(self, seed): if seed < 0: self.t = (self.t + 1) % self.t_max return self.t return seed _seed = Seed() def get_dashed_pattern(linestyle): """Extracts the dashed pattern from the various UI options """ pattern = [] if linestyle.dash1 > 0 and linestyle.gap1 > 0: pattern.append(linestyle.dash1) pattern.append(linestyle.gap1) if linestyle.dash2 > 0 and linestyle.gap2 > 0: pattern.append(linestyle.dash2) pattern.append(linestyle.gap2) if linestyle.dash3 > 0 and linestyle.gap3 > 0: pattern.append(linestyle.dash3) pattern.append(linestyle.gap3) return pattern def get_grouped_objects(group): for ob in group.objects: if ob.instance_type == 'COLLECTION' and ob.instance_collection is not None: for dupli in get_grouped_objects(ob.instance_collection): yield dupli else: yield ob integration_types = { 'MEAN': IntegrationType.MEAN, 'MIN': IntegrationType.MIN, 'MAX': IntegrationType.MAX, 'FIRST': IntegrationType.FIRST, 'LAST': IntegrationType.LAST} # main function for parameter processing def process(layer_name, lineset_name): scene = getCurrentScene() layer = scene.view_layers[layer_name] lineset = layer.freestyle_settings.linesets[lineset_name] linestyle = lineset.linestyle # execute line set pre-processing callback functions for fn in callbacks_lineset_pre: fn(scene, layer, lineset) selection_criteria = [] # prepare selection criteria by visibility if lineset.select_by_visibility: if lineset.visibility == 'VISIBLE': selection_criteria.append( QuantitativeInvisibilityUP1D(0)) elif lineset.visibility == 'HIDDEN': selection_criteria.append( NotUP1D(QuantitativeInvisibilityUP1D(0))) elif lineset.visibility == 'RANGE': selection_criteria.append( QuantitativeInvisibilityRangeUP1D(lineset.qi_start, lineset.qi_end)) # prepare selection criteria by edge types if lineset.select_by_edge_types: edge_type_criteria = [] if lineset.select_silhouette: upred = pyNatureUP1D(Nature.SILHOUETTE) edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_silhouette else upred) if lineset.select_border: upred = pyNatureUP1D(Nature.BORDER) edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_border else upred) if lineset.select_crease: upred = pyNatureUP1D(Nature.CREASE) edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_crease else upred) if lineset.select_ridge_valley: upred = pyNatureUP1D(Nature.RIDGE) edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_ridge_valley else upred) if lineset.select_suggestive_contour: upred = pyNatureUP1D(Nature.SUGGESTIVE_CONTOUR) edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_suggestive_contour else upred) if lineset.select_material_boundary: upred = pyNatureUP1D(Nature.MATERIAL_BOUNDARY) edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_material_boundary else upred) if lineset.select_edge_mark: upred = pyNatureUP1D(Nature.EDGE_MARK) edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_edge_mark else upred) if lineset.select_contour: upred = ContourUP1D() edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_contour else upred) if lineset.select_external_contour: upred = ExternalContourUP1D() edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_external_contour else upred) if edge_type_criteria: if lineset.edge_type_combination == 'OR': upred = OrUP1D(*edge_type_criteria) else: upred = AndUP1D(*edge_type_criteria) if lineset.edge_type_negation == 'EXCLUSIVE': upred = NotUP1D(upred) selection_criteria.append(upred) # prepare selection criteria by face marks if lineset.select_by_face_marks: if lineset.face_mark_condition == 'BOTH': upred = FaceMarkBothUP1D() else: upred = FaceMarkOneUP1D() if lineset.face_mark_negation == 'EXCLUSIVE': upred = NotUP1D(upred) selection_criteria.append(upred) # prepare selection criteria by group of objects if lineset.select_by_collection: if lineset.collection is not None: names = {getQualifiedObjectName(ob): True for ob in get_grouped_objects(lineset.collection)} upred = ObjectNamesUP1D(names, lineset.collection_negation == 'EXCLUSIVE') selection_criteria.append(upred) # prepare selection criteria by image border if lineset.select_by_image_border: upred = WithinImageBoundaryUP1D(*ContextFunctions.get_border()) selection_criteria.append(upred) # select feature edges if selection_criteria: upred = AndUP1D(*selection_criteria) else: upred = TrueUP1D() Operators.select(upred) # join feature edges to form chains if linestyle.use_chaining: if linestyle.chaining == 'PLAIN': if linestyle.use_same_object: Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred)) else: Operators.bidirectional_chain(ChainPredicateIterator(upred, TrueBP1D()), NotUP1D(upred)) elif linestyle.chaining == 'SKETCHY': if linestyle.use_same_object: Operators.bidirectional_chain(pySketchyChainSilhouetteIterator(linestyle.rounds)) else: Operators.bidirectional_chain(pySketchyChainingIterator(linestyle.rounds)) else: Operators.chain(ChainPredicateIterator(FalseUP1D(), FalseBP1D()), NotUP1D(upred)) # split chains if linestyle.material_boundary: Operators.sequential_split(MaterialBoundaryUP0D()) if linestyle.use_angle_min or linestyle.use_angle_max: angle_min = linestyle.angle_min if linestyle.use_angle_min else None angle_max = linestyle.angle_max if linestyle.use_angle_max else None Operators.sequential_split(Curvature2DAngleThresholdUP0D(angle_min, angle_max)) if linestyle.use_split_length: Operators.sequential_split(Length2DThresholdUP0D(linestyle.split_length), 1.0) if linestyle.use_split_pattern: pattern = [] if linestyle.split_dash1 > 0 and linestyle.split_gap1 > 0: pattern.append(linestyle.split_dash1) pattern.append(linestyle.split_gap1) if linestyle.split_dash2 > 0 and linestyle.split_gap2 > 0: pattern.append(linestyle.split_dash2) pattern.append(linestyle.split_gap2) if linestyle.split_dash3 > 0 and linestyle.split_gap3 > 0: pattern.append(linestyle.split_dash3) pattern.append(linestyle.split_gap3) if len(pattern) > 0: sampling = 1.0 controller = SplitPatternController(pattern, sampling) Operators.sequential_split(SplitPatternStartingUP0D(controller), SplitPatternStoppingUP0D(controller), sampling) # sort selected chains if linestyle.use_sorting: integration = integration_types.get(linestyle.integration_type, IntegrationType.MEAN) if linestyle.sort_key == 'DISTANCE_FROM_CAMERA': bpred = pyZBP1D(integration) elif linestyle.sort_key == '2D_LENGTH': bpred = Length2DBP1D() elif linestyle.sort_key == 'PROJECTED_X': bpred = pyProjectedXBP1D(integration) elif linestyle.sort_key == 'PROJECTED_Y': bpred = pyProjectedYBP1D(integration) if linestyle.sort_order == 'REVERSE': bpred = NotBP1D(bpred) Operators.sort(bpred) # select chains if linestyle.use_length_min or linestyle.use_length_max: length_min = linestyle.length_min if linestyle.use_length_min else None length_max = linestyle.length_max if linestyle.use_length_max else None Operators.select(LengthThresholdUP1D(length_min, length_max)) if linestyle.use_chain_count: Operators.select(pyNFirstUP1D(linestyle.chain_count)) # prepare a list of stroke shaders shaders_list = [] for m in linestyle.geometry_modifiers: if not m.use: continue if m.type == 'SAMPLING': shaders_list.append(SamplingShader( m.sampling)) elif m.type == 'BEZIER_CURVE': shaders_list.append(BezierCurveShader( m.error)) elif m.type == 'SIMPLIFICATION': shaders_list.append(SimplificationShader(m.tolerance)) elif m.type == 'SINUS_DISPLACEMENT': shaders_list.append(SinusDisplacementShader( m.wavelength, m.amplitude, m.phase)) elif m.type == 'SPATIAL_NOISE': shaders_list.append(SpatialNoiseShader( m.amplitude, m.scale, m.octaves, m.smooth, m.use_pure_random)) elif m.type == 'PERLIN_NOISE_1D': shaders_list.append(PerlinNoise1DShader( m.frequency, m.amplitude, m.octaves, m.angle, _seed.get(m.seed))) elif m.type == 'PERLIN_NOISE_2D': shaders_list.append(PerlinNoise2DShader( m.frequency, m.amplitude, m.octaves, m.angle, _seed.get(m.seed))) elif m.type == 'BACKBONE_STRETCHER': shaders_list.append(BackboneStretcherShader( m.backbone_length)) elif m.type == 'TIP_REMOVER': shaders_list.append(TipRemoverShader( m.tip_length)) elif m.type == 'POLYGONIZATION': shaders_list.append(PolygonalizationShader( m.error)) elif m.type == 'GUIDING_LINES': shaders_list.append(GuidingLinesShader( m.offset)) elif m.type == 'BLUEPRINT': if m.shape == 'CIRCLES': shaders_list.append(pyBluePrintCirclesShader( m.rounds, m.random_radius, m.random_center)) elif m.shape == 'ELLIPSES': shaders_list.append(pyBluePrintEllipsesShader( m.rounds, m.random_radius, m.random_center)) elif m.shape == 'SQUARES': shaders_list.append(pyBluePrintSquaresShader( m.rounds, m.backbone_length, m.random_backbone)) elif m.type == '2D_OFFSET': shaders_list.append(Offset2DShader( m.start, m.end, m.x, m.y)) elif m.type == '2D_TRANSFORM': shaders_list.append(Transform2DShader( m.pivot, m.scale_x, m.scale_y, m.angle, m.pivot_u, m.pivot_x, m.pivot_y)) # -- Base color, alpha and thickness -- # if (not linestyle.use_chaining) or (linestyle.chaining == 'PLAIN' and linestyle.use_same_object): thickness_position = linestyle.thickness_position else: thickness_position = 'CENTER' import bpy if bpy.app.debug_freestyle: print("Warning: Thickness position options are applied when chaining is disabled\n" " or the Plain chaining is used with the Same Object option enabled.") shaders_list.append(ConstantColorShader(*(linestyle.color), alpha=linestyle.alpha)) shaders_list.append(BaseThicknessShader(linestyle.thickness, thickness_position, linestyle.thickness_ratio)) # -- Modifiers -- # for m in linestyle.color_modifiers: if not m.use: continue if m.type == 'ALONG_STROKE': shaders_list.append(ColorAlongStrokeShader( m.blend, m.influence, m.color_ramp)) elif m.type == 'DISTANCE_FROM_CAMERA': shaders_list.append(ColorDistanceFromCameraShader( m.blend, m.influence, m.color_ramp, m.range_min, m.range_max)) elif m.type == 'DISTANCE_FROM_OBJECT': if m.target is not None: shaders_list.append(ColorDistanceFromObjectShader( m.blend, m.influence, m.color_ramp, m.target, m.range_min, m.range_max)) elif m.type == 'MATERIAL': shaders_list.append(ColorMaterialShader( m.blend, m.influence, m.color_ramp, m.material_attribute, m.use_ramp)) elif m.type == 'TANGENT': shaders_list.append(TangentColorShader( m.blend, m.influence, m.color_ramp)) elif m.type == 'CREASE_ANGLE': shaders_list.append(CreaseAngleColorShader( m.blend, m.influence, m.color_ramp, m.angle_min, m.angle_max)) elif m.type == 'CURVATURE_3D': shaders_list.append(Curvature3DColorShader( m.blend, m.influence, m.color_ramp, m.curvature_min, m.curvature_max)) elif m.type == 'NOISE': shaders_list.append(ColorNoiseShader( m.blend, m.influence, m.color_ramp, m.amplitude, m.period, m.seed)) for m in linestyle.alpha_modifiers: if not m.use: continue if m.type == 'ALONG_STROKE': shaders_list.append(AlphaAlongStrokeShader( m.blend, m.influence, m.mapping, m.invert, m.curve)) elif m.type == 'DISTANCE_FROM_CAMERA': shaders_list.append(AlphaDistanceFromCameraShader( m.blend, m.influence, m.mapping, m.invert, m.curve, m.range_min, m.range_max)) elif m.type == 'DISTANCE_FROM_OBJECT': if m.target is not None: shaders_list.append(AlphaDistanceFromObjectShader( m.blend, m.influence, m.mapping, m.invert, m.curve, m.target, m.range_min, m.range_max)) elif m.type == 'MATERIAL': shaders_list.append(AlphaMaterialShader( m.blend, m.influence, m.mapping, m.invert, m.curve, m.material_attribute)) elif m.type == 'TANGENT': shaders_list.append(TangentAlphaShader( m.blend, m.influence, m.mapping, m.invert, m.curve,)) elif m.type == 'CREASE_ANGLE': shaders_list.append(CreaseAngleAlphaShader( m.blend, m.influence, m.mapping, m.invert, m.curve, m.angle_min, m.angle_max)) elif m.type == 'CURVATURE_3D': shaders_list.append(Curvature3DAlphaShader( m.blend, m.influence, m.mapping, m.invert, m.curve, m.curvature_min, m.curvature_max)) elif m.type == 'NOISE': shaders_list.append(AlphaNoiseShader( m.blend, m.influence, m.mapping, m.invert, m.curve, m.amplitude, m.period, m.seed)) for m in linestyle.thickness_modifiers: if not m.use: continue if m.type == 'ALONG_STROKE': shaders_list.append(ThicknessAlongStrokeShader( thickness_position, linestyle.thickness_ratio, m.blend, m.influence, m.mapping, m.invert, m.curve, m.value_min, m.value_max)) elif m.type == 'DISTANCE_FROM_CAMERA': shaders_list.append(ThicknessDistanceFromCameraShader( thickness_position, linestyle.thickness_ratio, m.blend, m.influence, m.mapping, m.invert, m.curve, m.range_min, m.range_max, m.value_min, m.value_max)) elif m.type == 'DISTANCE_FROM_OBJECT': if m.target is not None: shaders_list.append(ThicknessDistanceFromObjectShader( thickness_position, linestyle.thickness_ratio, m.blend, m.influence, m.mapping, m.invert, m.curve, m.target, m.range_min, m.range_max, m.value_min, m.value_max)) elif m.type == 'MATERIAL': shaders_list.append(ThicknessMaterialShader( thickness_position, linestyle.thickness_ratio, m.blend, m.influence, m.mapping, m.invert, m.curve, m.material_attribute, m.value_min, m.value_max)) elif m.type == 'CALLIGRAPHY': shaders_list.append(CalligraphicThicknessShader( thickness_position, linestyle.thickness_ratio, m.blend, m.influence, m.orientation, m.thickness_min, m.thickness_max)) elif m.type == 'TANGENT': shaders_list.append(TangentThicknessShader( thickness_position, linestyle.thickness_ratio, m.blend, m.influence, m.mapping, m.invert, m.curve, m.thickness_min, m.thickness_max)) elif m.type == 'NOISE': shaders_list.append(ThicknessNoiseShader( thickness_position, linestyle.thickness_ratio, m.blend, m.influence, m.amplitude, m.period, m.seed, m.use_asymmetric)) elif m.type == 'CREASE_ANGLE': shaders_list.append(CreaseAngleThicknessShader( thickness_position, linestyle.thickness_ratio, m.blend, m.influence, m.mapping, m.invert, m.curve, m.angle_min, m.angle_max, m.thickness_min, m.thickness_max)) elif m.type == 'CURVATURE_3D': shaders_list.append(Curvature3DThicknessShader( thickness_position, linestyle.thickness_ratio, m.blend, m.influence, m.mapping, m.invert, m.curve, m.curvature_min, m.curvature_max, m.thickness_min, m.thickness_max)) else: raise RuntimeError("No Thickness modifier with type", type(m), m) # -- Textures -- # has_tex = False if linestyle.use_nodes and linestyle.node_tree: shaders_list.append(BlenderTextureShader(linestyle.node_tree)) has_tex = True if has_tex: shaders_list.append(StrokeTextureStepShader(linestyle.texture_spacing)) # execute post-base stylization callbacks for fn in callbacks_modifiers_post: shaders_list.extend(fn(scene, layer, lineset)) # -- Stroke caps -- # if linestyle.caps == 'ROUND': shaders_list.append(RoundCapShader()) elif linestyle.caps == 'SQUARE': shaders_list.append(SquareCapShader()) # -- Dashed line -- # if linestyle.use_dashed_line: pattern = get_dashed_pattern(linestyle) if len(pattern) > 0: shaders_list.append(DashedLineShader(pattern)) # create strokes using the shaders list Operators.create(TrueUP1D(), shaders_list) # execute line set post-processing callback functions for fn in callbacks_lineset_post: fn(scene, layer, lineset)