forked from bartvdbraak/blender
rna attribute consistency edits, use common prefix for booleans.
This commit is contained in:
parent
511451c8b8
commit
53917c4e3a
@ -59,24 +59,24 @@ class ScalarBlendModifier(StrokeShader):
|
||||
def blend(self, v1, v2):
|
||||
fac = self.__influence
|
||||
facm = 1.0 - fac
|
||||
if self.__blend == "MIX":
|
||||
if self.__blend == 'MIX':
|
||||
v1 = facm * v1 + fac * v2
|
||||
elif self.__blend == "ADD":
|
||||
elif self.__blend == 'ADD':
|
||||
v1 += fac * v2
|
||||
elif self.__blend == "MULTIPLY":
|
||||
elif self.__blend == 'MULTIPLY':
|
||||
v1 *= facm + fac * v2;
|
||||
elif self.__blend == "SUBTRACT":
|
||||
elif self.__blend == 'SUBTRACT':
|
||||
v1 -= fac * v2
|
||||
elif self.__blend == "DIVIDE":
|
||||
elif self.__blend == 'DIVIDE':
|
||||
if v2 != 0.0:
|
||||
v1 = facm * v1 + fac * v1 / v2
|
||||
elif self.__blend == "DIFFERENCE":
|
||||
elif self.__blend == 'DIFFERENCE':
|
||||
v1 = facm * v1 + fac * abs(v1 - v2)
|
||||
elif self.__blend == "MININUM":
|
||||
elif self.__blend == 'MININUM':
|
||||
tmp = fac * v1
|
||||
if v1 > tmp:
|
||||
v1 = tmp
|
||||
elif self.__blend == "MAXIMUM":
|
||||
elif self.__blend == 'MAXIMUM':
|
||||
tmp = fac * v1
|
||||
if v1 < tmp:
|
||||
v1 = tmp
|
||||
@ -87,7 +87,7 @@ class ScalarBlendModifier(StrokeShader):
|
||||
class CurveMappingModifier(ScalarBlendModifier):
|
||||
def __init__(self, blend, influence, mapping, invert, curve):
|
||||
ScalarBlendModifier.__init__(self, blend, influence)
|
||||
assert mapping in ("LINEAR", "CURVE")
|
||||
assert mapping in {'LINEAR', 'CURVE'}
|
||||
self.__mapping = getattr(self, mapping)
|
||||
self.__invert = invert
|
||||
self.__curve = curve
|
||||
@ -103,7 +103,7 @@ class CurveMappingModifier(ScalarBlendModifier):
|
||||
class ThicknessModifierMixIn:
|
||||
def __init__(self):
|
||||
scene = freestyle.getCurrentScene()
|
||||
self.__persp_camera = (scene.camera.data.type == "PERSP")
|
||||
self.__persp_camera = (scene.camera.data.type == 'PERSP')
|
||||
def set_thickness(self, sv, outer, inner):
|
||||
fe = sv.first_svertex.get_fedge(sv.second_svertex)
|
||||
nature = fe.nature
|
||||
@ -129,16 +129,16 @@ class ThicknessBlenderMixIn(ThicknessModifierMixIn):
|
||||
self.__position = position
|
||||
self.__ratio = ratio
|
||||
def blend_thickness(self, outer, inner, v):
|
||||
if self.__position == "CENTER":
|
||||
if self.__position == 'CENTER':
|
||||
outer = self.blend(outer, v / 2)
|
||||
inner = self.blend(inner, v / 2)
|
||||
elif self.__position == "INSIDE":
|
||||
elif self.__position == 'INSIDE':
|
||||
outer = self.blend(outer, 0)
|
||||
inner = self.blend(inner, v)
|
||||
elif self.__position == "OUTSIDE":
|
||||
elif self.__position == 'OUTSIDE':
|
||||
outer = self.blend(outer, v)
|
||||
inner = self.blend(inner, 0)
|
||||
elif self.__position == "RELATIVE":
|
||||
elif self.__position == 'RELATIVE':
|
||||
outer = self.blend(outer, v * self.__ratio)
|
||||
inner = self.blend(inner, v * (1 - self.__ratio))
|
||||
else:
|
||||
@ -152,16 +152,16 @@ class BaseThicknessShader(StrokeShader, ThicknessModifierMixIn):
|
||||
def __init__(self, thickness, position, ratio):
|
||||
StrokeShader.__init__(self)
|
||||
ThicknessModifierMixIn.__init__(self)
|
||||
if position == "CENTER":
|
||||
if position == 'CENTER':
|
||||
self.__outer = thickness / 2
|
||||
self.__inner = thickness / 2
|
||||
elif position == "INSIDE":
|
||||
elif position == 'INSIDE':
|
||||
self.__outer = 0
|
||||
self.__inner = thickness
|
||||
elif position == "OUTSIDE":
|
||||
elif position == 'OUTSIDE':
|
||||
self.__outer = thickness
|
||||
self.__inner = 0
|
||||
elif position == "RELATIVE":
|
||||
elif position == 'RELATIVE':
|
||||
self.__outer = thickness * ratio
|
||||
self.__inner = thickness * (1 - ratio)
|
||||
else:
|
||||
@ -350,84 +350,76 @@ class ThicknessDistanceFromObjectShader(ThicknessBlenderMixIn, CurveMappingModif
|
||||
|
||||
# Material modifiers
|
||||
|
||||
def iter_material_color(stroke, material_attr):
|
||||
def iter_material_color(stroke, material_attribute):
|
||||
func = CurveMaterialF0D()
|
||||
it = stroke.stroke_vertices_begin()
|
||||
while not it.is_end:
|
||||
material = func(Interface0DIterator(it))
|
||||
if material_attr == "DIFF":
|
||||
color = (material.diffuse[0],
|
||||
material.diffuse[1],
|
||||
material.diffuse[2])
|
||||
elif material_attr == "SPEC":
|
||||
color = (material.specular[0],
|
||||
material.specular[1],
|
||||
material.specular[2])
|
||||
if material_attribute == 'DIFF':
|
||||
color = material.diffuse[:]
|
||||
elif material_attribute == 'SPEC':
|
||||
color = material.specular[:]
|
||||
else:
|
||||
raise ValueError("unexpected material attribute: " + material_attr)
|
||||
raise ValueError("unexpected material attribute: " + material_attribute)
|
||||
yield it, color
|
||||
it.increment()
|
||||
|
||||
def iter_material_value(stroke, material_attr):
|
||||
def iter_material_value(stroke, material_attribute):
|
||||
func = CurveMaterialF0D()
|
||||
it = stroke.stroke_vertices_begin()
|
||||
while not it.is_end:
|
||||
material = func(Interface0DIterator(it))
|
||||
if material_attr == "DIFF":
|
||||
r = material.diffuse[0]
|
||||
g = material.diffuse[1]
|
||||
b = material.diffuse[2]
|
||||
if material_attribute == 'DIFF':
|
||||
r, g, b = material.diffuse
|
||||
t = 0.35 * r + 0.45 * r + 0.2 * b
|
||||
elif material_attr == "DIFF_R":
|
||||
elif material_attribute == 'DIFF_R':
|
||||
t = material.diffuse[0]
|
||||
elif material_attr == "DIFF_G":
|
||||
elif material_attribute == 'DIFF_G':
|
||||
t = material.diffuse[1]
|
||||
elif material_attr == "DIFF_B":
|
||||
elif material_attribute == 'DIFF_B':
|
||||
t = material.diffuse[2]
|
||||
elif material_attr == "SPEC":
|
||||
r = material.specular[0]
|
||||
g = material.specular[1]
|
||||
b = material.specular[2]
|
||||
elif material_attribute == 'SPEC':
|
||||
r, g, b = material.specular
|
||||
t = 0.35 * r + 0.45 * r + 0.2 * b
|
||||
elif material_attr == "SPEC_R":
|
||||
elif material_attribute == 'SPEC_R':
|
||||
t = material.specular[0]
|
||||
elif material_attr == "SPEC_G":
|
||||
elif material_attribute == 'SPEC_G':
|
||||
t = material.specular[1]
|
||||
elif material_attr == "SPEC_B":
|
||||
elif material_attribute == 'SPEC_B':
|
||||
t = material.specular[2]
|
||||
elif material_attr == "SPEC_HARDNESS":
|
||||
elif material_attribute == 'SPEC_HARDNESS':
|
||||
t = material.shininess
|
||||
elif material_attr == "ALPHA":
|
||||
elif material_attribute == 'ALPHA':
|
||||
t = material.diffuse[3]
|
||||
else:
|
||||
raise ValueError("unexpected material attribute: " + material_attr)
|
||||
raise ValueError("unexpected material attribute: " + material_attribute)
|
||||
yield it, t
|
||||
it.increment()
|
||||
|
||||
class ColorMaterialShader(ColorRampModifier):
|
||||
def __init__(self, blend, influence, ramp, material_attr, use_ramp):
|
||||
def __init__(self, blend, influence, ramp, material_attribute, use_ramp):
|
||||
ColorRampModifier.__init__(self, blend, influence, ramp)
|
||||
self.__material_attr = material_attr
|
||||
self.__material_attribute = material_attribute
|
||||
self.__use_ramp = use_ramp
|
||||
def shade(self, stroke):
|
||||
if self.__material_attr in ["DIFF", "SPEC"] and not self.__use_ramp:
|
||||
for it, b in iter_material_color(stroke, self.__material_attr):
|
||||
if self.__material_attribute in {'DIFF', 'SPEC'} and not self.__use_ramp:
|
||||
for it, b in iter_material_color(stroke, self.__material_attribute):
|
||||
sv = it.object
|
||||
a = sv.attribute.color
|
||||
sv.attribute.color = self.blend_ramp(a, b)
|
||||
else:
|
||||
for it, t in iter_material_value(stroke, self.__material_attr):
|
||||
for it, t in iter_material_value(stroke, self.__material_attribute):
|
||||
sv = it.object
|
||||
a = sv.attribute.color
|
||||
b = self.evaluate(t)
|
||||
sv.attribute.color = self.blend_ramp(a, b)
|
||||
|
||||
class AlphaMaterialShader(CurveMappingModifier):
|
||||
def __init__(self, blend, influence, mapping, invert, curve, material_attr):
|
||||
def __init__(self, blend, influence, mapping, invert, curve, material_attribute):
|
||||
CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve)
|
||||
self.__material_attr = material_attr
|
||||
self.__material_attribute = material_attribute
|
||||
def shade(self, stroke):
|
||||
for it, t in iter_material_value(stroke, self.__material_attr):
|
||||
for it, t in iter_material_value(stroke, self.__material_attribute):
|
||||
sv = it.object
|
||||
a = sv.attribute.alpha
|
||||
b = self.evaluate(t)
|
||||
@ -435,14 +427,14 @@ class AlphaMaterialShader(CurveMappingModifier):
|
||||
|
||||
class ThicknessMaterialShader(ThicknessBlenderMixIn, CurveMappingModifier):
|
||||
def __init__(self, thickness_position, thickness_ratio,
|
||||
blend, influence, mapping, invert, curve, material_attr, value_min, value_max):
|
||||
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.__material_attr = material_attr
|
||||
self.__material_attribute = material_attribute
|
||||
self.__value_min = value_min
|
||||
self.__value_max = value_max
|
||||
def shade(self, stroke):
|
||||
for it, t in iter_material_value(stroke, self.__material_attr):
|
||||
for it, t in iter_material_value(stroke, self.__material_attribute):
|
||||
sv = it.object
|
||||
a = sv.attribute.thickness
|
||||
b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min)
|
||||
@ -453,12 +445,12 @@ class ThicknessMaterialShader(ThicknessBlenderMixIn, CurveMappingModifier):
|
||||
|
||||
class CalligraphicThicknessShader(ThicknessBlenderMixIn, ScalarBlendModifier):
|
||||
def __init__(self, thickness_position, thickness_ratio,
|
||||
blend, influence, orientation, min_thickness, max_thickness):
|
||||
blend, influence, orientation, thickness_min, thickness_max):
|
||||
ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio)
|
||||
ScalarBlendModifier.__init__(self, blend, influence)
|
||||
self.__orientation = mathutils.Vector((math.cos(orientation), math.sin(orientation)))
|
||||
self.__min_thickness = min_thickness
|
||||
self.__max_thickness = max_thickness
|
||||
self.__thickness_min = thickness_min
|
||||
self.__thickness_max = thickness_max
|
||||
def shade(self, stroke):
|
||||
func = VertexOrientation2DF0D()
|
||||
it = stroke.stroke_vertices_begin()
|
||||
@ -469,7 +461,7 @@ class CalligraphicThicknessShader(ThicknessBlenderMixIn, ScalarBlendModifier):
|
||||
fac = abs(orthDir * self.__orientation)
|
||||
sv = it.object
|
||||
a = sv.attribute.thickness
|
||||
b = self.__min_thickness + fac * (self.__max_thickness - self.__min_thickness)
|
||||
b = self.__thickness_min + fac * (self.__thickness_max - self.__thickness_min)
|
||||
b = max(b, 0.0)
|
||||
c = self.blend_thickness(a[0], a[1], b)
|
||||
self.set_thickness(sv, c[0], c[1])
|
||||
@ -570,14 +562,14 @@ class Transform2DShader(StrokeShader):
|
||||
self.__pivot_y = pivot_y
|
||||
def shade(self, stroke):
|
||||
# determine the pivot of scaling and rotation operations
|
||||
if self.__pivot == "START":
|
||||
if self.__pivot == 'START':
|
||||
it = stroke.stroke_vertices_begin()
|
||||
pivot = it.object.point
|
||||
elif self.__pivot == "END":
|
||||
elif self.__pivot == 'END':
|
||||
it = stroke.stroke_vertices_end()
|
||||
it.decrement()
|
||||
pivot = it.object.point
|
||||
elif self.__pivot == "PARAM":
|
||||
elif self.__pivot == 'PARAM':
|
||||
p = None
|
||||
it = stroke.stroke_vertices_begin()
|
||||
while not it.is_end:
|
||||
@ -593,7 +585,7 @@ class Transform2DShader(StrokeShader):
|
||||
else:
|
||||
delta = u - self.__pivot_u
|
||||
pivot = p + delta * (prev - p)
|
||||
elif self.__pivot == "CENTER":
|
||||
elif self.__pivot == 'CENTER':
|
||||
pivot = mathutils.Vector([0.0, 0.0])
|
||||
n = 0
|
||||
it = stroke.stroke_vertices_begin()
|
||||
@ -604,7 +596,7 @@ class Transform2DShader(StrokeShader):
|
||||
it.increment()
|
||||
pivot.x = pivot.x / n
|
||||
pivot.y = pivot.y / n
|
||||
elif self.__pivot == "ABSOLUTE":
|
||||
elif self.__pivot == 'ABSOLUTE':
|
||||
pivot = mathutils.Vector([self.__pivot_x, self.__pivot_y])
|
||||
# apply scaling and rotation operations
|
||||
cos_theta = math.cos(self.__angle)
|
||||
@ -874,15 +866,15 @@ class AndBP1D(BinaryPredicate1D):
|
||||
# predicates for selection
|
||||
|
||||
class LengthThresholdUP1D(UnaryPredicate1D):
|
||||
def __init__(self, min_length=None, max_length=None):
|
||||
def __init__(self, length_min=None, length_max=None):
|
||||
UnaryPredicate1D.__init__(self)
|
||||
self._min_length = min_length
|
||||
self._max_length = max_length
|
||||
self._length_min = length_min
|
||||
self._length_max = length_max
|
||||
def __call__(self, inter):
|
||||
length = inter.length_2d
|
||||
if self._min_length is not None and length < self._min_length:
|
||||
if self._length_min is not None and length < self._length_min:
|
||||
return False
|
||||
if self._max_length is not None and length > self._max_length:
|
||||
if self._length_max is not None and length > self._length_max:
|
||||
return False
|
||||
return True
|
||||
|
||||
@ -931,16 +923,16 @@ class MaterialBoundaryUP0D(UnaryPredicate0D):
|
||||
return idx1 != idx2
|
||||
|
||||
class Curvature2DAngleThresholdUP0D(UnaryPredicate0D):
|
||||
def __init__(self, min_angle=None, max_angle=None):
|
||||
def __init__(self, angle_min=None, angle_max=None):
|
||||
UnaryPredicate0D.__init__(self)
|
||||
self._min_angle = min_angle
|
||||
self._max_angle = max_angle
|
||||
self._angle_min = angle_min
|
||||
self._angle_max = angle_max
|
||||
self._func = Curvature2DAngleF0D()
|
||||
def __call__(self, inter):
|
||||
angle = math.pi - self._func(inter)
|
||||
if self._min_angle is not None and angle < self._min_angle:
|
||||
if self._angle_min is not None and angle < self._angle_min:
|
||||
return True
|
||||
if self._max_angle is not None and angle > self._max_angle:
|
||||
if self._angle_max is not None and angle > self._angle_max:
|
||||
return True
|
||||
return False
|
||||
|
||||
@ -984,13 +976,13 @@ def process(layer_name, lineset_name):
|
||||
selection_criteria = []
|
||||
# prepare selection criteria by visibility
|
||||
if lineset.select_by_visibility:
|
||||
if lineset.visibility == "VISIBLE":
|
||||
if lineset.visibility == 'VISIBLE':
|
||||
selection_criteria.append(
|
||||
QuantitativeInvisibilityUP1D(0))
|
||||
elif lineset.visibility == "HIDDEN":
|
||||
elif lineset.visibility == 'HIDDEN':
|
||||
selection_criteria.append(
|
||||
NotUP1D(QuantitativeInvisibilityUP1D(0)))
|
||||
elif lineset.visibility == "RANGE":
|
||||
elif lineset.visibility == 'RANGE':
|
||||
selection_criteria.append(
|
||||
QuantitativeInvisibilityRangeUP1D(lineset.qi_start, lineset.qi_end))
|
||||
# prepare selection criteria by edge types
|
||||
@ -1023,21 +1015,21 @@ def process(layer_name, lineset_name):
|
||||
if lineset.select_external_contour:
|
||||
upred = ExternalContourUP1D()
|
||||
edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_external_contour else upred)
|
||||
if lineset.edge_type_combination == "OR":
|
||||
if lineset.edge_type_combination == 'OR':
|
||||
upred = join_unary_predicates(edge_type_criteria, OrUP1D)
|
||||
else:
|
||||
upred = join_unary_predicates(edge_type_criteria, AndUP1D)
|
||||
if upred is not None:
|
||||
if lineset.edge_type_negation == "EXCLUSIVE":
|
||||
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":
|
||||
if lineset.face_mark_condition == 'BOTH':
|
||||
upred = FaceMarkBothUP1D()
|
||||
else:
|
||||
upred = FaceMarkOneUP1D()
|
||||
if lineset.face_mark_negation == "EXCLUSIVE":
|
||||
if lineset.face_mark_negation == 'EXCLUSIVE':
|
||||
upred = NotUP1D(upred)
|
||||
selection_criteria.append(upred)
|
||||
# prepare selection criteria by group of objects
|
||||
@ -1068,13 +1060,13 @@ def process(layer_name, lineset_name):
|
||||
Operators.select(upred)
|
||||
# join feature edges to form chains
|
||||
if linestyle.use_chaining:
|
||||
if linestyle.chaining == "PLAIN":
|
||||
if linestyle.same_object:
|
||||
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.same_object:
|
||||
elif linestyle.chaining == 'SKETCHY':
|
||||
if linestyle.use_same_object:
|
||||
Operators.bidirectional_chain(pySketchyChainSilhouetteIterator(linestyle.rounds))
|
||||
else:
|
||||
Operators.bidirectional_chain(pySketchyChainingIterator(linestyle.rounds))
|
||||
@ -1083,10 +1075,10 @@ def process(layer_name, lineset_name):
|
||||
# split chains
|
||||
if linestyle.material_boundary:
|
||||
Operators.sequential_split(MaterialBoundaryUP0D())
|
||||
if linestyle.use_min_angle or linestyle.use_max_angle:
|
||||
min_angle = linestyle.min_angle if linestyle.use_min_angle else None
|
||||
max_angle = linestyle.max_angle if linestyle.use_max_angle else None
|
||||
Operators.sequential_split(Curvature2DAngleThresholdUP0D(min_angle, max_angle))
|
||||
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:
|
||||
@ -1107,140 +1099,140 @@ def process(layer_name, lineset_name):
|
||||
SplitPatternStoppingUP0D(controller),
|
||||
sampling)
|
||||
# select chains
|
||||
if linestyle.use_min_length or linestyle.use_max_length:
|
||||
min_length = linestyle.min_length if linestyle.use_min_length else None
|
||||
max_length = linestyle.max_length if linestyle.use_max_length else None
|
||||
Operators.select(LengthThresholdUP1D(min_length, max_length))
|
||||
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))
|
||||
# prepare a list of stroke shaders
|
||||
shaders_list = []
|
||||
for m in linestyle.geometry_modifiers:
|
||||
if not m.use:
|
||||
continue
|
||||
if m.type == "SAMPLING":
|
||||
if m.type == 'SAMPLING':
|
||||
shaders_list.append(SamplingShader(
|
||||
m.sampling))
|
||||
elif m.type == "BEZIER_CURVE":
|
||||
elif m.type == 'BEZIER_CURVE':
|
||||
shaders_list.append(BezierCurveShader(
|
||||
m.error))
|
||||
elif m.type == "SINUS_DISPLACEMENT":
|
||||
elif m.type == 'SINUS_DISPLACEMENT':
|
||||
shaders_list.append(SinusDisplacementShader(
|
||||
m.wavelength, m.amplitude, m.phase))
|
||||
elif m.type == "SPATIAL_NOISE":
|
||||
elif m.type == 'SPATIAL_NOISE':
|
||||
shaders_list.append(SpatialNoiseShader(
|
||||
m.amplitude, m.scale, m.octaves, m.smooth, m.pure_random))
|
||||
elif m.type == "PERLIN_NOISE_1D":
|
||||
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":
|
||||
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":
|
||||
elif m.type == 'BACKBONE_STRETCHER':
|
||||
shaders_list.append(BackboneStretcherShader(
|
||||
m.backbone_length))
|
||||
elif m.type == "TIP_REMOVER":
|
||||
elif m.type == 'TIP_REMOVER':
|
||||
shaders_list.append(TipRemoverShader(
|
||||
m.tip_length))
|
||||
elif m.type == "POLYGONIZATION":
|
||||
elif m.type == 'POLYGONIZATION':
|
||||
shaders_list.append(PolygonalizationShader(
|
||||
m.error))
|
||||
elif m.type == "GUIDING_LINES":
|
||||
elif m.type == 'GUIDING_LINES':
|
||||
shaders_list.append(GuidingLinesShader(
|
||||
m.offset))
|
||||
elif m.type == "BLUEPRINT":
|
||||
if m.shape == "CIRCLES":
|
||||
elif m.type == 'BLUEPRINT':
|
||||
if m.shape == 'CIRCLES':
|
||||
shaders_list.append(pyBluePrintCirclesShader(
|
||||
m.rounds, m.random_radius, m.random_center))
|
||||
elif m.shape == "ELLIPSES":
|
||||
elif m.shape == 'ELLIPSES':
|
||||
shaders_list.append(pyBluePrintEllipsesShader(
|
||||
m.rounds, m.random_radius, m.random_center))
|
||||
elif m.shape == "SQUARES":
|
||||
elif m.shape == 'SQUARES':
|
||||
shaders_list.append(pyBluePrintSquaresShader(
|
||||
m.rounds, m.backbone_length, m.random_backbone))
|
||||
elif m.type == "2D_OFFSET":
|
||||
elif m.type == '2D_OFFSET':
|
||||
shaders_list.append(Offset2DShader(
|
||||
m.start, m.end, m.x, m.y))
|
||||
elif m.type == "2D_TRANSFORM":
|
||||
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))
|
||||
color = linestyle.color
|
||||
if (not linestyle.use_chaining) or (linestyle.chaining == "PLAIN" and linestyle.same_object):
|
||||
if (not linestyle.use_chaining) or (linestyle.chaining == 'PLAIN' and linestyle.use_same_object):
|
||||
thickness_position = linestyle.thickness_position
|
||||
else:
|
||||
thickness_position = "CENTER"
|
||||
thickness_position = 'CENTER'
|
||||
import bpy
|
||||
if bpy.app.debug_freestyle:
|
||||
print("Warning: Thickness position options are applied when chaining is disabled")
|
||||
print(" or the Plain chaining is used with the Same Object option enabled.")
|
||||
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(BaseColorShader(color.r, color.g, color.b, linestyle.alpha))
|
||||
shaders_list.append(BaseThicknessShader(linestyle.thickness, thickness_position,
|
||||
linestyle.thickness_ratio))
|
||||
for m in linestyle.color_modifiers:
|
||||
if not m.use:
|
||||
continue
|
||||
if m.type == "ALONG_STROKE":
|
||||
if m.type == 'ALONG_STROKE':
|
||||
shaders_list.append(ColorAlongStrokeShader(
|
||||
m.blend, m.influence, m.color_ramp))
|
||||
elif m.type == "DISTANCE_FROM_CAMERA":
|
||||
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":
|
||||
elif m.type == 'DISTANCE_FROM_OBJECT':
|
||||
shaders_list.append(ColorDistanceFromObjectShader(
|
||||
m.blend, m.influence, m.color_ramp, m.target,
|
||||
m.range_min, m.range_max))
|
||||
elif m.type == "MATERIAL":
|
||||
elif m.type == 'MATERIAL':
|
||||
shaders_list.append(ColorMaterialShader(
|
||||
m.blend, m.influence, m.color_ramp, m.material_attr,
|
||||
m.blend, m.influence, m.color_ramp, m.material_attribute,
|
||||
m.use_ramp))
|
||||
for m in linestyle.alpha_modifiers:
|
||||
if not m.use:
|
||||
continue
|
||||
if m.type == "ALONG_STROKE":
|
||||
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":
|
||||
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":
|
||||
elif m.type == 'DISTANCE_FROM_OBJECT':
|
||||
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":
|
||||
elif m.type == 'MATERIAL':
|
||||
shaders_list.append(AlphaMaterialShader(
|
||||
m.blend, m.influence, m.mapping, m.invert, m.curve,
|
||||
m.material_attr))
|
||||
m.material_attribute))
|
||||
for m in linestyle.thickness_modifiers:
|
||||
if not m.use:
|
||||
continue
|
||||
if m.type == "ALONG_STROKE":
|
||||
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":
|
||||
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":
|
||||
elif m.type == 'DISTANCE_FROM_OBJECT':
|
||||
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":
|
||||
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_attr, m.value_min, m.value_max))
|
||||
elif m.type == "CALLIGRAPHY":
|
||||
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.min_thickness, m.max_thickness))
|
||||
if linestyle.caps == "ROUND":
|
||||
m.orientation, m.thickness_min, m.thickness_max))
|
||||
if linestyle.caps == 'ROUND':
|
||||
shaders_list.append(RoundCapShader())
|
||||
elif linestyle.caps == "SQUARE":
|
||||
elif linestyle.caps == 'SQUARE':
|
||||
shaders_list.append(SquareCapShader())
|
||||
if linestyle.use_dashed_line:
|
||||
pattern = []
|
||||
|
@ -40,7 +40,7 @@ class CopyRigidbodySettings(Operator):
|
||||
"friction",
|
||||
"restitution",
|
||||
"use_deactivation",
|
||||
"start_deactivated",
|
||||
"use_start_deactivated",
|
||||
"deactivate_linear_velocity",
|
||||
"deactivate_angular_velocity",
|
||||
"linear_damping",
|
||||
|
@ -936,9 +936,9 @@ class DATA_PT_modifiers(ModifierButtonsPanel, Panel):
|
||||
layout.prop(md, "sharpness")
|
||||
|
||||
layout.prop(md, "use_smooth_shade")
|
||||
layout.prop(md, "remove_disconnected_pieces")
|
||||
layout.prop(md, "use_remove_disconnected")
|
||||
row = layout.row()
|
||||
row.active = md.remove_disconnected_pieces
|
||||
row.active = md.use_remove_disconnected
|
||||
row.prop(md, "threshold")
|
||||
|
||||
@staticmethod
|
||||
|
@ -409,14 +409,14 @@ class RENDERLAYER_PT_freestyle_linestyle(RenderLayerFreestyleEditorButtonsPanel,
|
||||
prop.name = modifier.name
|
||||
|
||||
elif modifier.type == 'MATERIAL':
|
||||
box.prop(modifier, "material_attr", text="")
|
||||
box.prop(modifier, "material_attribute", text="")
|
||||
self.draw_modifier_curve_common(box, modifier, False, True)
|
||||
|
||||
elif modifier.type == 'CALLIGRAPHY':
|
||||
box.prop(modifier, "orientation")
|
||||
row = box.row(align=True)
|
||||
row.prop(modifier, "min_thickness")
|
||||
row.prop(modifier, "max_thickness")
|
||||
row.prop(modifier, "thickness_min")
|
||||
row.prop(modifier, "thickness_max")
|
||||
|
||||
def draw_geometry_modifier(self, context, modifier):
|
||||
layout = self.layout
|
||||
@ -448,7 +448,7 @@ class RENDERLAYER_PT_freestyle_linestyle(RenderLayerFreestyleEditorButtonsPanel,
|
||||
col.prop(modifier, "octaves")
|
||||
col = split.column()
|
||||
col.prop(modifier, "smooth")
|
||||
col.prop(modifier, "pure_random")
|
||||
col.prop(modifier, "use_pure_random")
|
||||
|
||||
elif modifier.type == 'PERLIN_NOISE_1D':
|
||||
split = box.split()
|
||||
@ -540,7 +540,7 @@ class RENDERLAYER_PT_freestyle_linestyle(RenderLayerFreestyleEditorButtonsPanel,
|
||||
col.prop(linestyle, "use_chaining", text="Enable Chaining")
|
||||
sub = col.row()
|
||||
sub.active = linestyle.use_chaining
|
||||
sub.prop(linestyle, "same_object")
|
||||
sub.prop(linestyle, "use_same_object")
|
||||
# Second column
|
||||
col = split.column()
|
||||
col.active = linestyle.use_chaining
|
||||
@ -554,15 +554,15 @@ class RENDERLAYER_PT_freestyle_linestyle(RenderLayerFreestyleEditorButtonsPanel,
|
||||
# First column
|
||||
col = split.column()
|
||||
row = col.row(align=True)
|
||||
row.prop(linestyle, "use_min_angle", text="")
|
||||
row.prop(linestyle, "use_angle_min", text="")
|
||||
sub = row.row()
|
||||
sub.active = linestyle.use_min_angle
|
||||
sub.prop(linestyle, "min_angle")
|
||||
sub.active = linestyle.use_angle_min
|
||||
sub.prop(linestyle, "angle_min")
|
||||
row = col.row(align=True)
|
||||
row.prop(linestyle, "use_max_angle", text="")
|
||||
row.prop(linestyle, "use_angle_max", text="")
|
||||
sub = row.row()
|
||||
sub.active = linestyle.use_max_angle
|
||||
sub.prop(linestyle, "max_angle")
|
||||
sub.active = linestyle.use_angle_max
|
||||
sub.prop(linestyle, "angle_max")
|
||||
# Second column
|
||||
col = split.column()
|
||||
row = col.row(align=True)
|
||||
@ -590,17 +590,17 @@ class RENDERLAYER_PT_freestyle_linestyle(RenderLayerFreestyleEditorButtonsPanel,
|
||||
# First column
|
||||
col = split.column()
|
||||
row = col.row(align=True)
|
||||
row.prop(linestyle, "use_min_length", text="")
|
||||
row.prop(linestyle, "use_length_min", text="")
|
||||
sub = row.row()
|
||||
sub.active = linestyle.use_min_length
|
||||
sub.prop(linestyle, "min_length")
|
||||
sub.active = linestyle.use_length_min
|
||||
sub.prop(linestyle, "length_min")
|
||||
# Second column
|
||||
col = split.column()
|
||||
row = col.row(align=True)
|
||||
row.prop(linestyle, "use_max_length", text="")
|
||||
row.prop(linestyle, "use_length_max", text="")
|
||||
sub = row.row()
|
||||
sub.active = linestyle.use_max_length
|
||||
sub.prop(linestyle, "max_length")
|
||||
sub.active = linestyle.use_length_max
|
||||
sub.prop(linestyle, "length_max")
|
||||
|
||||
## Caps
|
||||
layout.label(text="Caps:")
|
||||
|
@ -407,7 +407,7 @@ class RENDER_PT_game_system(RenderButtonsPanel, Panel):
|
||||
row = col.row()
|
||||
col = row.column()
|
||||
col.prop(gs, "use_frame_rate")
|
||||
col.prop(gs, "restrict_animation_updates")
|
||||
col.prop(gs, "use_restrict_animation_updates")
|
||||
col.prop(gs, "use_material_caching")
|
||||
col = row.column()
|
||||
col.prop(gs, "use_display_lists")
|
||||
|
@ -297,8 +297,8 @@ class OBJECT_PT_relations_extras(ObjectButtonsPanel, Panel):
|
||||
row.active = ((ob.parent is not None) and (ob.use_slow_parent))
|
||||
row.prop(ob, "slow_parent_offset", text="Offset")
|
||||
|
||||
layout.prop(ob, "extra_recalc_object")
|
||||
layout.prop(ob, "extra_recalc_data")
|
||||
layout.prop(ob, "use_extra_recalc_object")
|
||||
layout.prop(ob, "use_extra_recalc_data")
|
||||
|
||||
|
||||
from bl_ui.properties_animviz import (MotionPathButtonsPanel,
|
||||
|
@ -496,8 +496,8 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
|
||||
supports_courant = part.physics_type == 'FLUID'
|
||||
subsub = sub.row()
|
||||
subsub.enabled = supports_courant
|
||||
subsub.prop(part, "adaptive_subframes", text="")
|
||||
if supports_courant and part.adaptive_subframes:
|
||||
subsub.prop(part, "use_adaptive_subframes", text="")
|
||||
if supports_courant and part.use_adaptive_subframes:
|
||||
col.prop(part, "courant_target", text="Threshold")
|
||||
|
||||
row = layout.row()
|
||||
@ -524,20 +524,20 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
|
||||
|
||||
if fluid.solver == 'DDR':
|
||||
sub = col.row()
|
||||
sub.prop(fluid, "repulsion", slider=fluid.factor_repulsion)
|
||||
sub.prop(fluid, "factor_repulsion", text="")
|
||||
sub.prop(fluid, "repulsion", slider=fluid.use_factor_repulsion)
|
||||
sub.prop(fluid, "use_factor_repulsion", text="")
|
||||
|
||||
sub = col.row()
|
||||
sub.prop(fluid, "stiff_viscosity", slider=fluid.factor_stiff_viscosity)
|
||||
sub.prop(fluid, "factor_stiff_viscosity", text="")
|
||||
sub.prop(fluid, "stiff_viscosity", slider=fluid.use_factor_stiff_viscosity)
|
||||
sub.prop(fluid, "use_factor_stiff_viscosity", text="")
|
||||
|
||||
sub = col.row()
|
||||
sub.prop(fluid, "fluid_radius", slider=fluid.factor_radius)
|
||||
sub.prop(fluid, "factor_radius", text="")
|
||||
sub.prop(fluid, "fluid_radius", slider=fluid.use_factor_radius)
|
||||
sub.prop(fluid, "use_factor_radius", text="")
|
||||
|
||||
sub = col.row()
|
||||
sub.prop(fluid, "rest_density", slider=fluid.factor_density)
|
||||
sub.prop(fluid, "factor_density", text="")
|
||||
sub.prop(fluid, "rest_density", slider=fluid.use_factor_density)
|
||||
sub.prop(fluid, "use_factor_density", text="")
|
||||
|
||||
if fluid.solver == 'CLASSICAL':
|
||||
# With the classical solver, it is possible to calculate the
|
||||
@ -563,8 +563,8 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, Panel):
|
||||
col = split.column()
|
||||
col.label(text="Advanced:")
|
||||
sub = col.row()
|
||||
sub.prop(fluid, "rest_length", slider=fluid.factor_rest_length)
|
||||
sub.prop(fluid, "factor_rest_length", text="")
|
||||
sub.prop(fluid, "rest_length", slider=fluid.use_factor_rest_length)
|
||||
sub.prop(fluid, "use_factor_rest_length", text="")
|
||||
col.label(text="")
|
||||
sub = col.column()
|
||||
sub.active = fluid.use_viscoelastic_springs
|
||||
|
@ -274,7 +274,7 @@ class PHYSICS_PT_domain_boundary(PhysicButtonsPanel, Panel):
|
||||
col.prop(fluid, "slip_type", text="")
|
||||
if fluid.slip_type == 'PARTIALSLIP':
|
||||
col.prop(fluid, "partial_slip_factor", slider=True, text="Amount")
|
||||
col.prop(fluid, "surface_noobs")
|
||||
col.prop(fluid, "use_surface_noobs")
|
||||
|
||||
col = split.column()
|
||||
col.label(text="Surface:")
|
||||
|
@ -118,7 +118,7 @@ class PHYSICS_PT_rigid_body_dynamics(PHYSICS_PT_rigidbody_panel, Panel):
|
||||
col.prop(rbo, "use_deactivation")
|
||||
sub = col.column()
|
||||
sub.active = rbo.use_deactivation
|
||||
sub.prop(rbo, "start_deactivated")
|
||||
sub.prop(rbo, "use_start_deactivated")
|
||||
sub.prop(rbo, "deactivate_linear_velocity", text="Linear Vel")
|
||||
sub.prop(rbo, "deactivate_angular_velocity", text="Angular Vel")
|
||||
# TODO: other params such as time?
|
||||
|
@ -59,10 +59,10 @@ class PHYSICS_PT_rigid_body_constraint(PHYSICS_PT_rigidbody_constraint_panel, Pa
|
||||
sub.prop(rbc, "breaking_threshold", text="Threshold")
|
||||
|
||||
row = layout.row()
|
||||
row.prop(rbc, "override_solver_iterations", text="Override Iterations")
|
||||
row.prop(rbc, "use_override_solver_iterations", text="Override Iterations")
|
||||
sub = row.row()
|
||||
sub.active = rbc.override_solver_iterations
|
||||
sub.prop(rbc, "num_solver_iterations", text="Iterations")
|
||||
sub.active = rbc.use_override_solver_iterations
|
||||
sub.prop(rbc, "solver_iterations", text="Iterations")
|
||||
|
||||
if rbc.type == 'HINGE':
|
||||
col = layout.column(align=True)
|
||||
|
@ -93,9 +93,9 @@ class PHYSICS_PT_smoke(PhysicButtonsPanel, Panel):
|
||||
|
||||
sub = col.column(align=True)
|
||||
|
||||
sub.prop(flow, "initial_velocity")
|
||||
sub.prop(flow, "use_initial_velocity")
|
||||
sub = sub.column()
|
||||
sub.active = flow.initial_velocity
|
||||
sub.active = flow.use_initial_velocity
|
||||
sub.prop(flow, "velocity_factor")
|
||||
if flow.smoke_flow_source == "MESH":
|
||||
sub.prop(flow, "velocity_normal")
|
||||
@ -244,7 +244,7 @@ class PHYSICS_PT_smoke_highres(PhysicButtonsPanel, Panel):
|
||||
col = split.column()
|
||||
col.label(text="Resolution:")
|
||||
col.prop(md, "amplify", text="Divisions")
|
||||
col.prop(md, "smooth_emitter")
|
||||
col.prop(md, "use_smooth_emitter")
|
||||
|
||||
col = split.column()
|
||||
col.label(text="Noise Method:")
|
||||
|
@ -290,7 +290,7 @@ class SCENE_PT_rigid_body_world(SceneButtonsPanel, Panel):
|
||||
|
||||
col = split.column()
|
||||
col.prop(rbw, "steps_per_second", text="Steps Per Second")
|
||||
col.prop(rbw, "num_solver_iterations", text="Solver Iterations")
|
||||
col.prop(rbw, "solver_iterations", text="Solver Iterations")
|
||||
|
||||
|
||||
class SCENE_PT_rigid_body_cache(SceneButtonsPanel, Panel):
|
||||
|
@ -744,7 +744,7 @@ class IMAGE_PT_tools_brush_texture(BrushButtonsPanel, Panel):
|
||||
row.prop(brush, "use_primary_overlay", toggle=True, text="", icon='RESTRICT_VIEW_ON')
|
||||
sub = row.row()
|
||||
sub.prop(brush, "texture_overlay_alpha", text="Alpha")
|
||||
sub.prop(brush, "cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
|
||||
sub.prop(brush, "use_cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
|
||||
|
||||
|
||||
|
||||
@ -771,7 +771,7 @@ class IMAGE_PT_tools_mask_texture(BrushButtonsPanel, Panel):
|
||||
|
||||
sub = row.row()
|
||||
sub.prop(brush, "texture_overlay_alpha", text="Alpha")
|
||||
sub.prop(brush, "cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
|
||||
sub.prop(brush, "use_cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
|
||||
|
||||
|
||||
class IMAGE_PT_tools_brush_tool(BrushButtonsPanel, Panel):
|
||||
|
@ -283,7 +283,7 @@ class NODE_PT_quality(bpy.types.Panel):
|
||||
col = layout.column()
|
||||
col.prop(tree, "use_opencl")
|
||||
col.prop(tree, "use_groupnode_buffer")
|
||||
col.prop(tree, "two_pass")
|
||||
col.prop(tree, "use_two_pass")
|
||||
col.prop(tree, "use_viewer_border")
|
||||
col.prop(snode, "show_highlight")
|
||||
col.prop(snode, "use_hidden_preview")
|
||||
|
@ -98,7 +98,7 @@ class SEQUENCER_HT_header(Header):
|
||||
row.prop(ed, "show_overlay", text="", icon='GHOST_ENABLED')
|
||||
if ed.show_overlay:
|
||||
row.prop(ed, "overlay_frame", text="")
|
||||
row.prop(ed, "overlay_lock", text="", icon='LOCKED')
|
||||
row.prop(ed, "use_overlay_lock", text="", icon='LOCKED')
|
||||
|
||||
row = layout.row()
|
||||
row.prop(st, "overlay_type", text="")
|
||||
|
@ -681,7 +681,7 @@ class VIEW3D_PT_tools_brush(Panel, View3DPaintPanel):
|
||||
|
||||
sub = row.row()
|
||||
sub.prop(brush, "cursor_overlay_alpha", text="Alpha")
|
||||
sub.prop(brush, "cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
|
||||
sub.prop(brush, "use_cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
|
||||
|
||||
# Texture Paint Mode #
|
||||
|
||||
@ -717,7 +717,7 @@ class VIEW3D_PT_tools_brush(Panel, View3DPaintPanel):
|
||||
|
||||
sub = row.row()
|
||||
sub.prop(brush, "cursor_overlay_alpha", text="Alpha")
|
||||
sub.prop(brush, "cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
|
||||
sub.prop(brush, "use_cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
|
||||
|
||||
|
||||
# Weight Paint Mode #
|
||||
@ -774,7 +774,7 @@ class VIEW3D_PT_tools_brush(Panel, View3DPaintPanel):
|
||||
|
||||
sub = row.row()
|
||||
sub.prop(brush, "cursor_overlay_alpha", text="Alpha")
|
||||
sub.prop(brush, "cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
|
||||
sub.prop(brush, "use_cursor_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
|
||||
|
||||
|
||||
class VIEW3D_PT_tools_brush_texture(Panel, View3DPaintPanel):
|
||||
@ -814,7 +814,7 @@ class VIEW3D_PT_tools_brush_texture(Panel, View3DPaintPanel):
|
||||
|
||||
sub = row.row()
|
||||
sub.prop(brush, "texture_overlay_alpha", text="Alpha")
|
||||
sub.prop(brush, "primary_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
|
||||
sub.prop(brush, "use_primary_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
|
||||
|
||||
|
||||
class VIEW3D_PT_tools_mask_texture(View3DPanel, Panel):
|
||||
@ -852,7 +852,7 @@ class VIEW3D_PT_tools_mask_texture(View3DPanel, Panel):
|
||||
|
||||
sub = row.row()
|
||||
sub.prop(brush, "mask_overlay_alpha", text="Alpha")
|
||||
sub.prop(brush, "secondary_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
|
||||
sub.prop(brush, "use_secondary_overlay_override", toggle=True, text="", icon='BRUSH_DATA')
|
||||
|
||||
|
||||
class VIEW3D_PT_tools_brush_stroke(Panel, View3DPaintPanel):
|
||||
|
@ -673,7 +673,7 @@ void uiTemplateImage(uiLayout *layout, bContext *C, PointerRNA *ptr, const char
|
||||
|
||||
col = uiLayoutColumn(layout, FALSE);
|
||||
uiTemplateColorspaceSettings(col, &imaptr, "colorspace_settings");
|
||||
uiItemR(col, &imaptr, "view_as_render", 0, NULL, ICON_NONE);
|
||||
uiItemR(col, &imaptr, "use_view_as_render", 0, NULL, ICON_NONE);
|
||||
|
||||
if (ima->source != IMA_SRC_GENERATED) {
|
||||
if (compact == 0) { /* background image view doesnt need these */
|
||||
|
@ -1027,17 +1027,17 @@ static void rna_def_brush(BlenderRNA *brna)
|
||||
RNA_def_property_ui_text(prop, "Use Cursor Overlay", "Show cursor in viewport");
|
||||
RNA_def_property_update(prop, 0, "rna_Brush_update");
|
||||
|
||||
prop = RNA_def_property(srna, "cursor_overlay_override", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_cursor_overlay_override", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_CURSOR_OVERRIDE_ON_STROKE);
|
||||
RNA_def_property_ui_text(prop, "Override Overlay", "Don't show overlay during a stroke");
|
||||
RNA_def_property_update(prop, 0, "rna_Brush_update");
|
||||
|
||||
prop = RNA_def_property(srna, "primary_overlay_override", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_primary_overlay_override", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_PRIMARY_OVERRIDE_ON_STROKE);
|
||||
RNA_def_property_ui_text(prop, "Override Overlay", "Don't show overlay during a stroke");
|
||||
RNA_def_property_update(prop, 0, "rna_Brush_update");
|
||||
|
||||
prop = RNA_def_property(srna, "secondary_overlay_override", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_secondary_overlay_override", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "overlay_flags", BRUSH_OVERLAY_SECONDARY_OVERRIDE_ON_STROKE);
|
||||
RNA_def_property_ui_text(prop, "Override Overlay", "Don't show overlay during a stroke");
|
||||
RNA_def_property_update(prop, 0, "rna_Brush_update");
|
||||
|
@ -416,7 +416,7 @@ static void rna_def_fluidsim_domain(BlenderRNA *brna)
|
||||
RNA_def_property_ui_text(prop, "Generate Speed Vectors", "Generate speed vectors for vector blur");
|
||||
|
||||
/* no collision object surface */
|
||||
prop = RNA_def_property(srna, "surface_noobs", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_surface_noobs", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "typeFlags", OB_FSSG_NOOBS);
|
||||
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
|
||||
RNA_def_property_ui_text(prop, "Remove air bubbles",
|
||||
|
@ -559,7 +559,7 @@ static void rna_def_image(BlenderRNA *brna)
|
||||
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
|
||||
|
||||
|
||||
prop = RNA_def_property(srna, "view_as_render", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_view_as_render", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_VIEW_AS_RENDER);
|
||||
RNA_def_property_ui_text(prop, "View as Render", "Apply render part of display transformation when displaying this image on the screen");
|
||||
RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
|
||||
|
@ -412,7 +412,7 @@ static void rna_def_modifier_material_common(StructRNA *srna)
|
||||
{0, NULL, 0, NULL, NULL}
|
||||
};
|
||||
|
||||
prop = RNA_def_property(srna, "material_attr", PROP_ENUM, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "material_attribute", PROP_ENUM, PROP_NONE);
|
||||
RNA_def_property_enum_sdna(prop, NULL, "mat_attr");
|
||||
RNA_def_property_enum_items(prop, mat_attr_items);
|
||||
RNA_def_property_ui_text(prop, "Material Attribute", "Specify which material attribute is used");
|
||||
@ -569,14 +569,14 @@ static void rna_def_linestyle_modifiers(BlenderRNA *brna)
|
||||
RNA_def_property_ui_text(prop, "Orientation", "Angle of the main direction");
|
||||
RNA_def_property_update(prop, NC_LINESTYLE, NULL);
|
||||
|
||||
prop = RNA_def_property(srna, "min_thickness", PROP_FLOAT, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "thickness_min", PROP_FLOAT, PROP_NONE);
|
||||
RNA_def_property_float_sdna(prop, NULL, "min_thickness");
|
||||
RNA_def_property_range(prop, 0.0f, 10000.0f);
|
||||
RNA_def_property_ui_text(prop, "Min Thickness",
|
||||
"Minimum thickness in the direction perpendicular to the main direction");
|
||||
RNA_def_property_update(prop, NC_LINESTYLE, NULL);
|
||||
|
||||
prop = RNA_def_property(srna, "max_thickness", PROP_FLOAT, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "thickness_max", PROP_FLOAT, PROP_NONE);
|
||||
RNA_def_property_float_sdna(prop, NULL, "max_thickness");
|
||||
RNA_def_property_range(prop, 0.0f, 10000.0f);
|
||||
RNA_def_property_ui_text(prop, "Max Thickness", "Maximum thickness in the main direction");
|
||||
@ -657,7 +657,7 @@ static void rna_def_linestyle_modifiers(BlenderRNA *brna)
|
||||
RNA_def_property_ui_text(prop, "Smooth", "If true, the spatial noise is smooth");
|
||||
RNA_def_property_update(prop, NC_LINESTYLE, NULL);
|
||||
|
||||
prop = RNA_def_property(srna, "pure_random", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_pure_random", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flags", LS_MODIFIER_SPATIAL_NOISE_PURERANDOM);
|
||||
RNA_def_property_ui_text(prop, "Pure Random", "If true, the spatial noise does not show any coherence");
|
||||
RNA_def_property_update(prop, NC_LINESTYLE, NULL);
|
||||
@ -982,7 +982,7 @@ static void rna_def_linestyle(BlenderRNA *brna)
|
||||
RNA_def_property_struct_type(prop, "LineStyleGeometryModifier");
|
||||
RNA_def_property_ui_text(prop, "Geometry Modifiers", "List of stroke geometry modifiers");
|
||||
|
||||
prop = RNA_def_property(srna, "same_object", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_same_object", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_SAME_OBJECT);
|
||||
RNA_def_property_ui_text(prop, "Same Object", "If true, only feature edges of the same object are joined");
|
||||
RNA_def_property_update(prop, NC_LINESTYLE, NULL);
|
||||
@ -998,47 +998,47 @@ static void rna_def_linestyle(BlenderRNA *brna)
|
||||
RNA_def_property_ui_text(prop, "Split Length", "Curvilinear 2D length for chain splitting");
|
||||
RNA_def_property_update(prop, NC_LINESTYLE, NULL);
|
||||
|
||||
prop = RNA_def_property(srna, "use_min_angle", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_angle_min", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_MIN_2D_ANGLE);
|
||||
RNA_def_property_ui_text(prop, "Use Min 2D Angle",
|
||||
"Split chains at points with angles smaller than the minimum 2D angle");
|
||||
RNA_def_property_update(prop, NC_LINESTYLE, NULL);
|
||||
|
||||
prop = RNA_def_property(srna, "min_angle", PROP_FLOAT, PROP_ANGLE);
|
||||
prop = RNA_def_property(srna, "angle_min", PROP_FLOAT, PROP_ANGLE);
|
||||
RNA_def_property_float_sdna(prop, NULL, "min_angle");
|
||||
RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
|
||||
RNA_def_property_ui_text(prop, "Min 2D Angle", "Minimum 2D angle for splitting chains");
|
||||
RNA_def_property_update(prop, NC_LINESTYLE, NULL);
|
||||
|
||||
prop = RNA_def_property(srna, "use_max_angle", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_angle_max", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_MAX_2D_ANGLE);
|
||||
RNA_def_property_ui_text(prop, "Use Max 2D Angle",
|
||||
"Split chains at points with angles larger than the maximum 2D angle");
|
||||
RNA_def_property_update(prop, NC_LINESTYLE, NULL);
|
||||
|
||||
prop = RNA_def_property(srna, "max_angle", PROP_FLOAT, PROP_ANGLE);
|
||||
prop = RNA_def_property(srna, "angle_max", PROP_FLOAT, PROP_ANGLE);
|
||||
RNA_def_property_float_sdna(prop, NULL, "max_angle");
|
||||
RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
|
||||
RNA_def_property_ui_text(prop, "Max 2D Angle", "Maximum 2D angle for splitting chains");
|
||||
RNA_def_property_update(prop, NC_LINESTYLE, NULL);
|
||||
|
||||
prop = RNA_def_property(srna, "use_min_length", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_length_min", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_MIN_2D_LENGTH);
|
||||
RNA_def_property_ui_text(prop, "Use Min 2D Length", "Enable the selection of chains by a minimum 2D length");
|
||||
RNA_def_property_update(prop, NC_LINESTYLE, NULL);
|
||||
|
||||
prop = RNA_def_property(srna, "min_length", PROP_FLOAT, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "length_min", PROP_FLOAT, PROP_NONE);
|
||||
RNA_def_property_float_sdna(prop, NULL, "min_length");
|
||||
RNA_def_property_range(prop, 0.0f, 10000.0f);
|
||||
RNA_def_property_ui_text(prop, "Min 2D Length", "Minimum curvilinear 2D length for the selection of chains");
|
||||
RNA_def_property_update(prop, NC_LINESTYLE, NULL);
|
||||
|
||||
prop = RNA_def_property(srna, "use_max_length", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_length_max", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", LS_MAX_2D_LENGTH);
|
||||
RNA_def_property_ui_text(prop, "Use Max 2D Length", "Enable the selection of chains by a maximum 2D length");
|
||||
RNA_def_property_update(prop, NC_LINESTYLE, NULL);
|
||||
|
||||
prop = RNA_def_property(srna, "max_length", PROP_FLOAT, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "length_max", PROP_FLOAT, PROP_NONE);
|
||||
RNA_def_property_float_sdna(prop, NULL, "max_length");
|
||||
RNA_def_property_range(prop, 0.0f, 10000.0f);
|
||||
RNA_def_property_ui_text(prop, "Max 2D Length", "Maximum curvilinear 2D length for the selection of chains");
|
||||
|
@ -3249,7 +3249,7 @@ static void rna_def_modifier_remesh(BlenderRNA *brna)
|
||||
"edges closer to the input");
|
||||
RNA_def_property_update(prop, 0, "rna_Modifier_update");
|
||||
|
||||
prop = RNA_def_property(srna, "remove_disconnected_pieces", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_remove_disconnected", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_REMESH_FLOOD_FILL);
|
||||
RNA_def_property_ui_text(prop, "Remove Disconnected Pieces", "");
|
||||
RNA_def_property_update(prop, 0, "rna_Modifier_update");
|
||||
|
@ -6878,7 +6878,7 @@ static void rna_def_composite_nodetree(BlenderRNA *brna)
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", NTREE_COM_GROUPNODE_BUFFER);
|
||||
RNA_def_property_ui_text(prop, "Buffer Groups", "Enable buffering of group nodes");
|
||||
|
||||
prop = RNA_def_property(srna, "two_pass", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_two_pass", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", NTREE_TWO_PASS);
|
||||
RNA_def_property_ui_text(prop, "Two Pass", "Use two pass execution during editing: first calculate fast nodes, "
|
||||
"second pass calculate all nodes");
|
||||
|
@ -2479,11 +2479,11 @@ static void rna_def_object(BlenderRNA *brna)
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
|
||||
|
||||
/* depsgraph hack */
|
||||
prop = RNA_def_property(srna, "extra_recalc_object", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_extra_recalc_object", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "depsflag", OB_DEPS_EXTRA_OB_RECALC);
|
||||
RNA_def_property_ui_text(prop, "Extra Object Update", "Refresh this object again on frame changes, dependency graph hack");
|
||||
|
||||
prop = RNA_def_property(srna, "extra_recalc_data", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_extra_recalc_data", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "depsflag", OB_DEPS_EXTRA_DATA_RECALC);
|
||||
RNA_def_property_ui_text(prop, "Extra Data Update", "Refresh this object's data again on frame changes, dependency graph hack");
|
||||
|
||||
|
@ -1623,7 +1623,7 @@ static void rna_def_fluid_settings(BlenderRNA *brna)
|
||||
RNA_def_property_ui_text(prop, "Factor Repulsion", "Repulsion is a factor of stiffness");
|
||||
RNA_def_property_update(prop, 0, "rna_Particle_reset");
|
||||
|
||||
prop = RNA_def_property(srna, "factor_density", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_factor_density", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", SPH_FAC_DENSITY);
|
||||
RNA_def_property_ui_text(prop, "Factor Density",
|
||||
"Density is calculated as a factor of default density (depends on particle size)");
|
||||
@ -2499,7 +2499,7 @@ static void rna_def_particle_settings(BlenderRNA *brna)
|
||||
RNA_def_property_ui_text(prop, "Timestep", "The simulation timestep per frame (seconds per frame)");
|
||||
RNA_def_property_update(prop, 0, "rna_Particle_reset");
|
||||
|
||||
prop = RNA_def_property(srna, "adaptive_subframes", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_adaptive_subframes", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "time_flag", PART_TIME_AUTOSF);
|
||||
RNA_def_property_ui_text(prop, "Automatic Subframes", "Automatically set the number of subframes");
|
||||
RNA_def_property_update(prop, 0, "rna_Particle_reset");
|
||||
|
@ -794,7 +794,7 @@ static void rna_def_rigidbody_object(BlenderRNA *brna)
|
||||
"but can cause glitches)");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
|
||||
|
||||
prop = RNA_def_property(srna, "start_deactivated", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_start_deactivated", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_START_DEACTIVATED);
|
||||
RNA_def_property_ui_text(prop, "Start Deactivated", "Deactivate rigid body at the start of the simulation");
|
||||
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
|
||||
@ -949,14 +949,14 @@ static void rna_def_rigidbody_constraint(BlenderRNA *brna)
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
|
||||
|
||||
/* Solver Iterations */
|
||||
prop = RNA_def_property(srna, "override_solver_iterations", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_override_solver_iterations", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS);
|
||||
RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_override_solver_iterations_set");
|
||||
RNA_def_property_ui_text(prop, "Override Solver Iterations",
|
||||
"Override the number of solver iterations for this constraint");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
|
||||
|
||||
prop = RNA_def_property(srna, "num_solver_iterations", PROP_INT, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "solver_iterations", PROP_INT, PROP_NONE);
|
||||
RNA_def_property_int_sdna(prop, NULL, "num_solver_iterations");
|
||||
RNA_def_property_range(prop, 1, 1000);
|
||||
RNA_def_property_ui_range(prop, 1, 100, 1, -1);
|
||||
|
@ -3364,7 +3364,7 @@ static void rna_def_scene_game_data(BlenderRNA *brna)
|
||||
RNA_def_property_boolean_funcs(prop, "rna_GameSettings_auto_start_get", "rna_GameSettings_auto_start_set");
|
||||
RNA_def_property_ui_text(prop, "Auto Start", "Automatically start game at load time");
|
||||
|
||||
prop = RNA_def_property(srna, "restrict_animation_updates", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_restrict_animation_updates", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flag", GAME_RESTRICT_ANIM_UPDATES);
|
||||
RNA_def_property_ui_text(prop, "Restrict Animation Updates",
|
||||
"Restrict the number of animation updates to the animation FPS (this is "
|
||||
|
@ -1534,7 +1534,7 @@ static void rna_def_editor(BlenderRNA *brna)
|
||||
RNA_def_property_ui_text(prop, "Draw Axes", "Partial overlay on top of the sequencer");
|
||||
RNA_def_property_update(prop, NC_SPACE | ND_SPACE_SEQUENCER, NULL);
|
||||
|
||||
prop = RNA_def_property(srna, "overlay_lock", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_overlay_lock", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "over_flag", SEQ_EDIT_OVERLAY_ABS);
|
||||
RNA_def_property_ui_text(prop, "Overlay Lock", "");
|
||||
RNA_def_property_boolean_funcs(prop, NULL, "rna_SequenceEditor_overlay_lock_set");
|
||||
|
@ -324,7 +324,7 @@ static void rna_def_smoke_domain_settings(BlenderRNA *brna)
|
||||
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
|
||||
RNA_def_property_ui_text(prop, "Effector Weights", "");
|
||||
|
||||
prop = RNA_def_property(srna, "smooth_emitter", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_smooth_emitter", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_SMOKE_HIGH_SMOOTH);
|
||||
RNA_def_property_ui_text(prop, "Smooth Emitter", "Smooth emitted smoke to avoid blockiness");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_resetCache");
|
||||
@ -508,7 +508,7 @@ static void rna_def_smoke_flow_settings(BlenderRNA *brna)
|
||||
RNA_def_property_ui_text(prop, "Absolute Density", "Only allow given density value in emitter area");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset");
|
||||
|
||||
prop = RNA_def_property(srna, "initial_velocity", PROP_BOOLEAN, PROP_NONE);
|
||||
prop = RNA_def_property(srna, "use_initial_velocity", PROP_BOOLEAN, PROP_NONE);
|
||||
RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_SMOKE_FLOW_INITVELOCITY);
|
||||
RNA_def_property_ui_text(prop, "Initial Velocity", "Smoke has some initial velocity when it is emitted");
|
||||
RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, "rna_Smoke_reset");
|
||||
|
Loading…
Reference in New Issue
Block a user