Any time I use blender for more than just a poke around at updates and general bug testing, something inevitable happens.
It's what I call "Oh, there should be a script for that"- syndrome. It's not always very convenient to drop what I'm doing and
dive into writing a script, but over time a few ideas bubble up and eventually I do relent.
Array, absolute vs relative distance
Typically I will use arrays to quickly knock out repeating geometry, sometimes the relative distance option suffices. In relative mode the bounding box (absolute dimensions in x,y,z) is what determines the distance to array, but what if I want the array distance to be larger than 1 relative unit? well I could use values of more than 1 relative unit, but that isn't really practical for precise geometry Perhaps this will grow into a larger, more automated script but bpy is missing hooks like 'active modifier' to make it truly tidy (at least, not yet). This snippet gets the absolute value for whatever axis is sought.>> import bpy """ - first switch off any arrays, or set values to count:1 - (doesn't apply to all kinds of arrays, only those that contribute to the dimension that corresponds with the axis you are arraying into - apply visual transforms and scale """ >> ao = bpy.context.active_object >> ao.bound_box.data.dimensions Vector((floatx, floaty, floatz))
That doesn't really take any of the real work away from my side. So instead I end up doing something like the following, but it still forces me to do some pretty mind-numbing steps to get the raw dimensions to array on. On the up-side only a few extra lines of code are needed after this snippet
import bpy ob = bpy.context.active_object # get the values of the object without array, disable all modifier states above, and # current, not below. Disable = toggle the show_viewport option to off (if it was on) dims = ob.bound_box.data.dimensions # Then, re-enable all states. # pick your array modifier my_modifier = ob.modifiers[0] array_data = my_modifier.relative_offset_displace axis_values = [val*dims[idx] for idx, val in enumerate(array_data)] # switch off relative_array, set to constant my_modifier.use_relative_offset = False my_modifier.use_constant_offset = True # set constant array values my_modifier.constant_offset_displace = axis_values
Recommended watching for this week : CS3 lecture 25: Design in Computing
- refactor (small steps, almost mindless, check in-between)
- no duplication
- reusable
- simple
- readable
- loose /low coupling
Next video, if you are into this kind of stuff, like I am : CS3 lecture 28: Design in Computing
- no magic numbers, declare+assign variable once and use that instead
- short functions = good, narrows down what the function does - easy to name
- the overhead of a method call is very very low these days
- descriptive variable and function names = vital
- more than one dot (trainwreck) down.the.rabbit.hole - an object should know about as few objects as possible
- conditional complexity, cyclomatic (few paths through a method)
- don't have irrelevant assignments, assignments that don't perform work - check c2.com
