[Bf-blender-cvs] SVN commit: /data/svn/bf-blender [45463] branches/soc-2008-mxcurioni: New options in the Parameter Editor mode for controling the position of stroke thickness .
Tamito Kajiyama
rd6t-kjym at asahi-net.or.jp
Sat Apr 7 19:28:09 CEST 2012
Revision: 45463
http://projects.blender.org/scm/viewvc.php?view=rev&root=bf-blender&revision=45463
Author: kjym3
Date: 2012-04-07 17:28:09 +0000 (Sat, 07 Apr 2012)
Log Message:
-----------
New options in the Parameter Editor mode for controling the position of stroke thickness.
The new options enable a better control on the position of stroke thickness with
respect to stroke backbone geometry. Three predefined positions are:
* center: thickness is evenly split to the left and right side of the stroke geometry.
* inside: strokes are drawn within object boundary.
* outside: strokes are drawn outside the object boundary.
Another option called "relative" allows users to specify the relative position by a
number between 0 (inside) and 1 (outside).
The thickness position options are applied only to strokes of the edge types SILHOUETTE
and BORDER, since these are the only edge types defined in terms of object boundary.
Strokes of other edge types are always using the "center" option.
Modified Paths:
--------------
branches/soc-2008-mxcurioni/release/scripts/freestyle/style_modules/parameter_editor.py
branches/soc-2008-mxcurioni/release/scripts/startup/bl_ui/properties_render.py
branches/soc-2008-mxcurioni/source/blender/blenkernel/intern/linestyle.c
branches/soc-2008-mxcurioni/source/blender/blenloader/intern/readfile.c
branches/soc-2008-mxcurioni/source/blender/makesdna/DNA_linestyle_types.h
branches/soc-2008-mxcurioni/source/blender/makesrna/intern/rna_linestyle.c
Modified: branches/soc-2008-mxcurioni/release/scripts/freestyle/style_modules/parameter_editor.py
===================================================================
--- branches/soc-2008-mxcurioni/release/scripts/freestyle/style_modules/parameter_editor.py 2012-04-07 16:59:06 UTC (rev 45462)
+++ branches/soc-2008-mxcurioni/release/scripts/freestyle/style_modules/parameter_editor.py 2012-04-07 17:28:09 UTC (rev 45463)
@@ -88,6 +88,80 @@
def evaluate(self, t):
return self.__mapping(t)
+class ThicknessModifierMixIn:
+ def __init__(self):
+ scene = Freestyle.getCurrentScene()
+ self.__persp_camera = (scene.camera.data.type == "PERSP")
+ def set_thickness(self, sv, outer, inner):
+ fe = sv.A().getFEdge(sv.B())
+ nature = fe.getNature()
+ if (nature & Nature.BORDER):
+ if self.__persp_camera:
+ point = -sv.getPoint3D()
+ point.normalize()
+ dir = point.dot(fe.normalB())
+ else:
+ dir = fe.normalB().z
+ if dir < 0.0: # the back side is visible
+ outer, inner = inner, outer
+ elif (nature & Nature.SILHOUETTE):
+ if fe.isSmooth(): # TODO more tests needed
+ outer, inner = inner, outer
+ else:
+ outer = inner = (outer + inner) / 2
+ sv.attribute().setThickness(outer, inner)
+
+class ThicknessBlenderMixIn(ThicknessModifierMixIn):
+ def __init__(self, position, ratio):
+ ThicknessModifierMixIn.__init__(self)
+ self.__position = position
+ self.__ratio = ratio
+ def blend_thickness(self, outer, inner, v):
+ if self.__position == "CENTER":
+ outer = self.__modifier.blend(outer, v / 2)
+ inner = self.__modifier.blend(inner, v / 2)
+ elif self.__position == "INSIDE":
+ inner = self.__modifier.blend(inner, v)
+ elif self.__position == "OUTSIDE":
+ outer = self.__modifier.blend(outer, v)
+ elif self.__position == "RELATIVE":
+ outer = self.__modifier.blend(outer, v * self.ratio)
+ inner = self.__modifier.blend(inner, v * (1 - self.ratio))
+ else:
+ raise ValueError("unknown thickness position: " + self.__position)
+ return outer, inner
+
+class BaseColorShader(ConstantColorShader):
+ def getName(self):
+ return "BaseColorShader"
+
+class BaseThicknessShader(StrokeShader, ThicknessModifierMixIn):
+ def __init__(self, thickness, position, ratio):
+ StrokeShader.__init__(self)
+ ThicknessModifierMixIn.__init__(self)
+ if position == "CENTER":
+ self.__outer = thickness / 2
+ self.__inner = thickness / 2
+ 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 * (1 - ratio)
+ else:
+ raise ValueError("unknown thickness position: " + self.position)
+ def getName(self):
+ return "BaseThicknessShader"
+ def shade(self, stroke):
+ it = stroke.strokeVerticesBegin()
+ while it.isEnd() == 0:
+ sv = it.getObject()
+ self.set_thickness(sv, self.__outer, self.__inner)
+ it.increment()
+
# Along Stroke modifiers
def iter_t2d_along_stroke(stroke):
@@ -125,8 +199,10 @@
c = self.blend(a, b)
attr.setAlpha(c)
-class ThicknessAlongStrokeShader(CurveMappingModifier):
- def __init__(self, blend, influence, mapping, invert, curve, value_min, value_max):
+class ThicknessAlongStrokeShader(ThicknessBlenderMixIn, CurveMappingModifier):
+ 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_min = value_min
self.__value_max = value_max
@@ -134,12 +210,11 @@
return "ThicknessAlongStrokeShader"
def shade(self, stroke):
for it, t in iter_t2d_along_stroke(stroke):
- attr = it.getObject().attribute()
- a = attr.getThicknessRL()
- a = a[0] + a[1]
+ sv = it.getObject()
+ a = sv.attribute().getThicknessRL()
b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min)
- c = self.blend(a, b)
- attr.setThickness(c/2, c/2)
+ c = self.blend_thickness(a[0], a[1], b)
+ self.set_thickness(sv, c[0], c[1])
# Distance from Camera modifiers
@@ -188,8 +263,10 @@
c = self.blend(a, b)
attr.setAlpha(c)
-class ThicknessDistanceFromCameraShader(CurveMappingModifier):
- def __init__(self, blend, influence, mapping, invert, curve, range_min, range_max, value_min, value_max):
+class ThicknessDistanceFromCameraShader(ThicknessBlenderMixIn, CurveMappingModifier):
+ 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_min = range_min
self.__range_max = range_max
@@ -199,12 +276,11 @@
return "ThicknessDistanceFromCameraShader"
def shade(self, stroke):
for it, t in iter_distance_from_camera(stroke, self.__range_min, self.__range_max):
- attr = it.getObject().attribute()
- a = attr.getThicknessRL()
- a = a[0] + a[1]
+ sv = it.getObject()
+ a = sv.attribute().getThicknessRL()
b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min)
- c = self.blend(a, b)
- attr.setThickness(c/2, c/2)
+ c = self.blend_thickness(a[0], a[1], b)
+ self.set_thickness(sv, c[0], c[1])
# Distance from Object modifiers
@@ -263,8 +339,10 @@
c = self.blend(a, b)
attr.setAlpha(c)
-class ThicknessDistanceFromObjectShader(CurveMappingModifier):
- def __init__(self, blend, influence, mapping, invert, curve, target, range_min, range_max, value_min, value_max):
+class ThicknessDistanceFromObjectShader(ThicknessBlenderMixIn, CurveMappingModifier):
+ 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)
self.__target = target
self.__range_min = range_min
@@ -277,12 +355,11 @@
if self.__target is None:
return
for it, t in iter_distance_from_object(stroke, self.__target, self.__range_min, self.__range_max):
- attr = it.getObject().attribute()
- a = attr.getThicknessRL()
- a = a[0] + a[1]
+ sv = it.getObject()
+ a = sv.attribute().getThicknessRL()
b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min)
- c = self.blend(a, b)
- attr.setThickness(c/2, c/2)
+ c = self.blend_thickness(a[0], a[1], b)
+ self.set_thickness(sv, c[0], c[1])
# Material modifiers
@@ -376,8 +453,10 @@
c = self.blend(a, b)
attr.setAlpha(c)
-class ThicknessMaterialShader(CurveMappingModifier):
- def __init__(self, blend, influence, mapping, invert, curve, material_attr, value_min, value_max):
+class ThicknessMaterialShader(ThicknessBlenderMixIn, CurveMappingModifier):
+ def __init__(self, thickness_position, thickness_ratio,
+ blend, influence, mapping, invert, curve, material_attr, value_min, value_max):
+ ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio)
CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve)
self.__material_attr = material_attr
self.__value_min = value_min
@@ -386,17 +465,18 @@
return "ThicknessMaterialShader"
def shade(self, stroke):
for it, t in iter_material_value(stroke, self.__material_attr):
- attr = it.getObject().attribute()
- a = attr.getThicknessRL()
- a = a[0] + a[1]
+ sv = it.getObject()
+ a = sv.attribute().getThicknessRL()
b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min)
- c = self.blend(a, b)
- attr.setThickness(c/2, c/2)
+ c = self.blend_thickness(a[0], a[1], b)
+ self.set_thickness(sv, c[0], c[1])
# Calligraphic thickness modifier
-class CalligraphicThicknessShader(ScalarBlendModifier):
- def __init__(self, blend, influence, orientation, min_thickness, max_thickness):
+class CalligraphicThicknessShader(ThicknessBlenderMixIn, ScalarBlendModifier):
+ def __init__(self, thickness_position, thickness_ratio,
+ blend, influence, orientation, min_thickness, max_thickness):
+ ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio)
ScalarBlendModifier.__init__(self, blend, influence)
rad = orientation / 180.0 * math.pi
self.__orientation = mathutils.Vector((math.cos(rad), math.sin(rad)))
@@ -410,13 +490,12 @@
orthDir = mathutils.Vector((-dir.y, dir.x))
orthDir.normalize()
fac = abs(orthDir * self.__orientation)
- attr = it.getObject().attribute()
- a = attr.getThicknessRL()
- a = a[0] + a[1]
+ sv = it.getObject()
+ a = sv.attribute().getThicknessRL()
b = self.__min_thickness + fac * (self.__max_thickness - self.__min_thickness)
b = max(b, 0.0)
- c = self.blend(a, b)
- attr.setThickness(c/2, c/2)
+ c = self.blend_thickness(a[0], a[1], b)
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list