Copy Uvs from one mesh to multiple instances of that mesh in animation nodes

You loaded UVs to a mesh and then you created a new mesh based on the vertices, edges, and polygons of the source mesh and forgot about the UV Maps. Currently, Animation Nodes doesn't provide access to UV data through nodes, so you will have to use some python expressions.

You can get a list of UV Maps in a mesh using the getUVMaps() method, each element in the output list is a tuple of two elements, the name of the map and a 2D vector list representing the locations of the UVs. To set a UV to a mesh you can use the insertUVMap(name, uvs) method, which takes the name of the map and a 2D vector list.

So, in conclusion, to transfer the UV maps from some mesh sourceMesh to another mesh targetMesh, we can use the following expression:

([targetMesh.insertUVMap(*map) for map in sourceMesh.getUVMaps()], targetMesh)[1]


You define the type when you create the socket with new() Looking at the list on the bpy.types page there are several starting with NodeSocket that can be used.

The variations of each type alter the visual display - eg. FloatPercent shows % with the value.

NodeSocketBool
NodeSocketColor
NodeSocketFloat
NodeSocketFloatAngle
NodeSocketFloatFactor
NodeSocketFloatPercentage
NodeSocketFloatTime
NodeSocketFloatUnsigned
NodeSocketInt
NodeSocketIntFactor
NodeSocketIntPercentage
NodeSocketIntUnsigned
NodeSocketShader
NodeSocketString
NodeSocketVector
NodeSocketVectorAcceleration
NodeSocketVectorDirection
NodeSocketVectorEuler
NodeSocketVectorTranslation
NodeSocketVectorVelocity
NodeSocketVectorXYZ


How to revolve flat object by twisting it 360 to make it 3D?

Right of the bat, using an .svg for this purpose is not a good idea, because you're creating a lot of unnecessary topology. You should rather create a circle/cylinder and work your way from there.

But since you asked, I recommend the spin tool in Edit Mode:


Yes, blender is the software you are looking for blender can do almost everything you imagine, also the big advantage of using blender is that you will get a million of tutorials about how to use it on YouTube , also it is open source so you will not even have to spend a coin on it, the only thing is you will have to be patient in order to create something as you want because there are many users who find it hard and leave it in the middle, so start from basic and one day you will achieve the results you want.


How do I get the deformed coordinate of a vertex with Python?

Vertex Parenting

Among other ways can be done with vertex parenting.

Test script, run with mesh in edit mode, adds a vertex parented empty for each selected vert and prints  vertex's global location to the console.

import bpy
import bmesh

context = bpy.context
scene = context.scene
obj = context.edit_object
mesh = obj.data
bm = bmesh.from_edit_mesh(mesh)
empties = []
# selected verts
for v in [v for v in bm.verts if v.select]:
    empty = bpy.data.objects.new("Empty", None)
    empty.parent = obj
    empty.parent_type = 'VERTEX'
    empty.parent_vertices = [v.index] * 3
    scene.objects.link(empty)
    empty.matrix_parent_inverse.identity()
    empties.append((v.index, empty))

# update the scene
scene.update()
for index, empty in empties:
    print("Vert %d location: " % index, empty.matrix_world.to_translation())
    scene.objects.unlink(empty)
    bpy.data.objects.remove(empty)

Test result on default cube with subsurf (cat-clark) 3 subdivisions.

Vert 0 location:  <Vector (0.5015, 0.5015, -0.5015)>
Vert 1 location:  <Vector (0.5015, -0.5015, -0.5015)>
Vert 2 location:  <Vector (-0.5015, -0.5015, -0.5015)>
Vert 3 location:  <Vector (-0.5015, 0.5015, -0.5015)>
Vert 4 location:  <Vector (0.5015, 0.5015, 0.5015)>
Vert 5 location:  <Vector (0.5015, -0.5015, 0.5015)>
Vert 6 location:  <Vector (-0.5015, -0.5015, 0.5015)>
Vert 7 location:  <Vector (-0.5015, 0.5015, 0.5015)>


How to get a clean Ambient Occlusion map with Cycles with low samples?

You can use a normal map to blur the images without touching the edges to keep sharp details.

For that use a bilateral blur attach your ambient occlusion map and the normal map in the slot Determinator. You can play with the settings, i suggest you to lower the "Sigma" setting which is too high by default by something like 1.
You can also apply a small blur at the normal map to avoid getting edges too aliased and be closer to an anti-aliasing filter.


How to create a floating flag that isnt pinned/hooked?

One way out is combination of shape keys and proportional editing applied to a subdivided plane. Subdivide a plane and make each proportional edit a separate shape key to animate later. It takes time but the wave may be regular if realism is not your goal.


how to add a pixelated and unpixelated effect to object

You can do this using Pixelate node in compositor.

As official documentation notes, to create this effect you should put Pixelate node between 2 Scale nodes. And I add value and math node for manipulating this effect easily


AttributeError: ,_io.TextIOWrapper' object has no attribute 'next'

Blender 2.6x comes with its own Python in Version 3.3.x, and in Py3k it's __next__().

You can do simpler, however:

for line in file:
    print(line)


Why does my model render shady / half-black?

You have custom split normals data on your model, You should to delete it, then blender will recalculate normals properly.

Removing custom norlals in Geometry data section:

Then select all faces and press Ctrl+N


Imported SVG does not fully show up in rendered view

OK, so I experimented some more and found something that seemed to work. What I did was open that logo in Illustrator and then export it using the asset export. For some reason, doing that instead of doing the Save As actions, fixed my issue. Maybe I had screwed something up in the original SVG export settings. So while I'm not sure this is the reason, it may help you if you come across this.


Live unwrap does not work with some objects

In order for live unwrap to work on the above island it should be divided into two islands or more, live unwrap can not work on the whole island of the object at once.

You can choose part of the island and hide the rest (Shift + H ) with the 'UV and edit mode selection sync' on


(Answer copied from Self Collision - Blender Cloth Sim shrinks mesh as can't flag as duplicate since it has no upvotes...)
Most likely your cloth vertices are self-colliding with their neighbours due to the Self Collision Distance being too large.
Firstly, when running a simulation always ensure the meshes are created at 'real world' scales - eg, for a bedsheet you might assume 2 metres a side (or 2 Blender Units). Ensure you Ctrl+A and 'Apply Scale' following any changes to scale - to ensure the simulation is using the correct scale.
Secondly, reduce the Self Collisions 'Distance' property. At Blender 2.83.2 this defaults to 0.015 metres (1.5cm). If your vertices are closer together you may want to reduce that value.


How to make a sword appear from behind a tree in 2D Animation

If you press TAB to go to object mode, then duplicate the tree with SHIFT+D, then extrude (E), and fill (F):

between the vertices at the edges, to make an object that will cover the sword (or anything else), then make the material of this object just filled white (or whatever colour* your background is):

*I'm British so I spell it properly

then that should cover the sword perfectly behind the tree. If the sword is still in front the tree, then check that it is behind the tree in 3D space.


problem with the roll of camera tracking an object

The Trackto constraint defines what axis points towards the target and which axis is considered "up". As the camera passes under the target, moving from being on one side to being on the other, the camera is being flipped to maintain the correct "up" orientation.

The solution is to change the constraint to use local space, this will change the initial orientation so you will also want to change the up axis to X


I don't think that's possible.

What you can do, however, is scale your entire animation to create more frames in between the existing ones.

Enter the graph view and move the time cursor to 0. Then select everything and press . (to scale relative to the cursor) followed by S X 2 to scale by a factor of 2 in the X direction (i.e., along the time axis).

You can then adjust the project's frame rate, modify the frame steps (in this case double it) and etc. to get it playing at the right speed.


To get the frames to update when previewing in the 3D viewport, you need to enable Auto Refresh on the image texture. In final render, this is not needed.

This is not documented in the online manual's section on the Image Texture node, and the only references I've found to it are on the various help sites for Blender. Therefore I can't say for sure why this is so, but I'm assuming that in the 3D viewport speed is given priority over accuracy, while renders give priority to accuracy over speed.

In this answer to a related question, it is mentioned by Ray Mairlot. I've seen this mentioned in other places as well, but this was the first one a quick search turned up.

You may also want to try using the Alpha socket of the image texture as input for the Fac socket of the mix node, though that will depend on how the dynamic paint was set up.


How Do I Make A Trace Effect Similar to Tron: Legacy Light Cycle Scene

Edit: Cegaton already answered a very similar question here.

You'll find a lot of tutorials on Youtube about light streak effects, there are a lot of ways, it really depends on how it is supposed to look like and how sophisticated you want it to be... I guess in the Tron movie they use several combined effects so even if I knew it would be hard to sum it up in few words. One of the most basic way to make a light streak could be this one:

Create a curve, create a second one that will be its Taper Object (its profile from its start to its end).

In the Properties panel > Data, play with the parameters to give your curve its thickness and its profile. The taper allows you to make the streak slightly disappear at its end.

Play with the End value (and also maybe its Start value) and give it some keyframes to animate.

Now in the Node Editor > Compositing mode, give a blur effect or else to give the glow effect.


The animal armatures aren't showing up as options. How do I fix this?

Wrong version. Updated from 2.7 to 2.8 and that fixed it.


How can I add a subdivision surface modifier to smooth the rounding of an object?

You can solve this by using supporting geometry. In the case of your object, adding edge loops at the places I've highlighted will give a clean look with a subdivision surface. Be careful positioning the large rectangle loop, because It seemed to cause artifacts in the bottom left area if not placed just right.

Hope this helps.


Python Implementation of Track-to/aim constraint

I can't explain the math to do it manually, but you can use python to create a constraint that will do the rotation for you. You can then apply the visual transform and delete the constraint if you don't want to leave it there.

targetobj = bpy.data.objects['Sphere']
pointyobj = bpy.data.objects['Cone']

ttc = pointyobj.constraints.new(type='TRACK_TO')
ttc.target = targetobj
ttc.track_axis = 'TRACK_Z'
# we don't care about the up_axis
# but default is Z and it needs to be different that track_axis
ttc.up_axis = 'UP_X'

bpy.ops.object.select_all(action='DESELECT')
pointyobj.select = True
bpy.ops.object.visual_transform_apply()

pointyobj.constraints.remove(ttc)

Not sure if it will help but I believe the trackto_evaluate function currently on line 965 of constraint.c is the math behind the constraint.


You can duplicate a vertex group from the drop down menu underneath the delete (-) button.


Transform a Location “Constrained” Object?

I've created a work around for my problem by removing the main control empty (along with my ability to move everything from a dynamic center) and replace its functionality with a driver that outputs half of the array's distance.

This will allow me to use that drivers value to offset the start empty manually (though for my use case, I can still semi automate this if the desired location for the center of the array is located in the center of two points which have location values I can reference for use with the start empty).

While this does not achieve the functionality I had laid out, this will do as a passable workaround for now.


The only light in your scene is behind the object, in other words the face and front of the object is in the shadow. Move your light so that it shines where you need it.

Other thing that might help you is adding some environmental lighting so that the shadows are not as dark.


How to set the path for userpref.blend file?

Setting the environmental variable BLENDER_USER_CONFIG would do the job. So Blender assumes the path to the userpref.blend file would be BLENDER_USER_CONFIG/userpref.blend


Make sure you select (with Left Click) another frame in the timeline before pasting the keyframe.
You can also duplicate the keyframe(s) with SHIFT + D (or Right Click > Duplicate) and move your mouse to the desired position or type the number of frames you want to move.


How to make it so that your object doesn't move when you resize it

Looks like the origin of your cube is still at the world origin, but your cube object itself is above the surface.
You can reset the object origin: Select the cube, go to Object menu, select Set Origin, then select Origin to Geometry.
Should solve your problem.
HTH


UV Map and Texture An Irregular, Very High Poly Object

Ok, I found out how to fix my issue...

I connected 'Texture Coordinates' 'Object' to 'Vector', then changed Image Texture to 'Box'. Worked like a charm. See image for node settings.


why did my fluid change into multi colored spheres?

The spheres are the particles of the fluid simulation and their size can be controlled via the Viewport Display properties in the Liquid particle settings.

Changing the Size to 0 will result in point particles instead of spheres.
Alternatively, you can hide them completely by disabling the visibility settings alongside the particle system in the list :


Visualize some edges of a mesh with Blender (or MeshLab)

Blender doesn't render mesh edges, it only renders faces. While you can display the mesh edges in the 3dview and see them when using an opengl render, they will be one colour for the object, normally black or orange when selected while grouped objects will be green when selected.

There are some ways to get around this, one is to use a wireframe modifier that turns the edges into a tube like mesh structure.

You can then apply the modifier and select parts of the mesh and assign different materials as explained before.

To get both outline and faces you simply need to duplicate the object and turn the duplicate into the wireframe tubing.

I don't know if the ply importer will maintain any edge colour information, but you may be able to adjust it to automate the process if you need to work with a complex mesh.


How can I copy one side of a rig to the other?

In order to mirror a rig down the very middle, you'll need the 3d cursor reset (ShiftC) and used as your 'Pivot Point' (.). That'll determine the mirror center, so long as the rig itself is placed correctly in the center (0,0,0). Now Select any half of the armature (excluding the spine/middle) and duplicate it with ShiftD, next press CtrlM + (the axis you are working along, usually  X) to mirror it over to the other side. With the selection still instact, press W > Flip Names to update the names so something like upper-arm.L becomes upper-arm.R.

After doing this, the mirrored bones might have a different roll from the other side. To fix, select the original bones (can just invert selection with CtrlI if you still have the mirrored side selected), enable X-Axis mirror under Armature Options in the toolshelf and press CtrlR to fix the roll.


Im doing a 2d animation and need timeline help

Simply click on the left top icon in your timeline area (currently that is graph editor) and select dope sheet


Have you selected an audio codec for your output? Default is "No Audio"

Edit:
Ok, I just saw that you seem to have enabled a codec... Have you tried different codecs? Maybe you chose one that is not supported on your media player?

Alternatively: Have you tried re-importing the output video strip into blender?


How to know what is new in the daily releases?

You can check the Developers website, or you can subscribe to Bf-committers mailing list.


How to duplicate object along extracted curve?

No modifier required when using a curve:

create your curve, make sure the radius, weights, tilt along the curve are as desired (otherwise it will scale/rotate your mesh...):

assign your object to the curve and clear the origin (Alt-O)

For your model, select Duplication/frame, uncheck "Speed" and set the number of instances you want in the "end" field

For the curve, set the same number of frames as in 3. in the Path Animation section, set the Evaluation Time as 0 and check Follow if you want your mesh to have its direction follow the curve (I guess you want to uncheck it in your case):

select your original mesh then Shift-Ctrl-A to "Make Duplicate Real".


How can I create a countdown timer in Cycles?

Please have a try with this script By Respected fellow: batFINGER:

import bpy
import math
from bpy.props import BoolProperty
def countdown_timer(scene):
    # look for all font objects with _timer property
    timers = [ob.data for ob in scene.objects if ob.type == 'FONT' and ob.data.is_timer]
    for font in timers:
        secs = font["timer"]
        countdown_frames = secs * scene.render.fps / scene.render.fps_base
        frame = countdown_frames - scene.frame_current + 1
        if frame < 0:
            continue
        t = float(frame * scene.render.fps_base ) / float(scene.render.fps)
        minutes = t // 60
        t %= 60
        seconds = math.floor(t)
        t = t - seconds
        hundreds = math.floor(100 * (t))
        font.body = "%02d:%02d:%02d" % (minutes,seconds,hundreds)
    return None
def is_timer(self, context):
    if self.is_timer:
        if "timer" not in self.keys():
            self["timer"] = 10 # 10 seconds default
    return None
class TimerPanel(bpy.types.Panel):
    """Timer Panel"""
    bl_label = "Countdown Timer"
    bl_idname = "FONT_PT_timer"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "data"

    @classmethod
    def poll(cls, context):
        return (context.object and context.object.type in {'FONT'} and context.curve)
    def draw_header(self, context):
        font = context.object.data

        self.layout.prop(font, "is_timer", text="")
    def draw(self, context):
        font = context.object.data
        layout = self.layout
        if font.is_timer:
            row = layout.row()
            row.prop(font,'["timer"]', text="Seconds")
def register():
    bpy.types.TextCurve.is_timer = BoolProperty(default=False, update=is_timer, description="Make countdown timer")

    bpy.app.handlers.frame_change_pre.append(countdown_timer)
    bpy.utils.register_class(TimerPanel)

def unregister():
    bpy.utils.unregister_class(TimerPanel)
    bpy.app.handlers.frame_change_pre.pop()

if __name__ == "__main__":
    register()

Copy it to the Text Editor

Dont forget to hit run script

Create a new text  and you will get a new option box under fonts.

Adjust the value as per your needs

Play it! It can be used in Cycles or gaming engine !

You will have a full control of materials fonts size and rotations etc

Best of luck


Is there a Frame node in Sverchok addon?


Blender PNG saved as 48 bit color depth really?

There are lots of programs that refer to bit depths in different ways. The confusion comes from whether they are referring to the number of bits per pixel or the number of bits per color
 channel.

16 bit per color channel RGB is also referred as 48bit color by some programs ( each pixel will use 48 bits to store color information: 16 bits for the Red channel, 16 for the Green and 16 for the Blue: 16 x 3 = 48).

16 bit RGB with Alpha channel is also referred sometimes as 64bit (RGB + A or 16 x 3 + 16 = 64 )

What most programs label 32 bit images are really 8 bit per channel images plus an Alpha channel: (RGB + Alpha 8 x 3 + 8 = 32 bits per pixel.

Without the Alpha channel an 8bit RGB image would use 24bits per pixel.

To make things more confusing it is possible to use 32bit per channel when using OpenEXR or HDR files...

There are some programs (like versions of GIMP previous to 2.9 or other paint programs) that cannot deal with 16 bit images and will convert them to 8 bit which will always result in data loss.

8 bit images allow for only 256 different values per color channel, with a total of 16 million combinations.

Even though 16 million colors sounds like a lot and is close to the limit of what the eye can see, it presents problems when representing subtle gradations  where you need many more values. The most common artifact that you'll see in 8 bit images is known as "banding". In this image banding is clearly visible in the sky:

Photo by geograph.org.uk

16 bit allows for 65,536 values per channel giving over a trillion possible combinations. Using a higher bit rate will solve most of the banding issues and will give you more flexibility in terms of color correcting or further processing of the images.


Cycles baking testbuild gives black image (no displacement used)

You need to recalculate the normals of the object (Edit Mode > CtrlN).

If you don't, the normals will all face inward (where there is no light).


You can import the image as a simple 4-vertex plane with the Import Images as Planes addon.
Then you can add a Subdivision Surface modifier & change the smoothing algorithm from Catmull-Clark to Simple, which will add more vertices but keep the same mesh shape.

Increase the resolution to get as many vertices as you need.


Display full error at the bottom right of blender 2.8

tab window and got to toggle system console


Set the transparent bsdf to one color (solid white: 1, 1, 1...alpha is disregarded). For this shader to be truly "transparent," the color must be so.

Transparency color levels from left to right: 0, 0.25, 0.5, 0.75, and 1 (yes, there is an invisible monkey on the end).

Here is the demo blend:

And here is a link to the transparent shader in the manual:

https://www.blender.org/manual//render/cycles/nodes/types/shaders/transparent.html

The color can also be used to tint (it doesn't have to be the same for R, G, and B channels):

From left to right, the RGB color is as follows: (0.5, 0, 0), (0, 0, 1), (0, 0.75, 0), (0.75, 1, 0.75), (1, 1, 0).


Import Image with Drag and Drop as Plane

To import a lot of images at once ... it is much faster to use included addon Images as Planes, just enable it in User Preferences. Addon imports multiple images, you can set a basic material and set distance between images to bring them organised
Note - by drag&drop you import only one image per drag, then you will have to convert Empties to Planes (as pointed by Jachym Michal)


Unfortunately, adaptive subdivision (at least as it is now) works by applying the subdivision to the UV dynamically with respect to the view.  It must be dynamic.  However, the ocean modifier obviously radically changes geometry and it does so by modifying a known geometry.  With ASD, the geometry is unknown and is in flux.  For this reason, ASD must be applied last.

This is just a workaround and it may not even be applicable to your needs (and you've probably already thought of it).  It's not adaptive but you can lock the camera to plane and maybe make it appear as if your subject is moving through the ocean.

Create a plane and subdivide it in sections:

Apply Ocean mod Set Geometry to Displace.  Play with settings:

Sorry for the crummy sky hdri:


Locate and assign weights to vertices with no weights in a Mesh

I had this problem and came here so hopefully my script will save someone some time and headache looking through the blender API

# Usage: with a mesh selected, run the script. It will add a new
# vertex group to the mesh called 'ProblemVertices'
# The script will add any vertices with a total weight != 1.0
# to the 'ProblemVertices' group.

import bpy

print("Start script")

me = bpy.context.object.data                # the selected mesh
grps = bpy.context.object.vertex_groups     # all vertex groups in the mesh
grps.new(name="ProblemVertices")            # add a vertex group to the mesh
myvertexgroup = grps[-1]                    # the last vertex group in the mesh - our new group

# optional part which when uncommented deletes vertices
# from groups where the vertex has weight 0 for that group.
#for vertex in me.vertices:
#    for grpelement in vertex.groups:                        # for each vertex group element in the mesh
#       if grpelement.weight == 0.0:                        # if the vertex is unweighted
#           grps[grpelement.group].remove([vertex.index])   #remove it from that group
#           print("Removed Vertex from group")
#       if len(vertex.groups) == 0:                            # if the vertex is not a member of any groups
#           myvertexgroup.add([vertex.index], 1.0, 'ADD')          # add it to the last group with weight 1
#           print("Unweighted vertex added to group")

for vertex in me.vertices:                              # for each vertex
    thisweight = 0.0                                    #keep track of total weight
    for grpelement in vertex.groups:                    # for each vertex group element in the mesh
        thisweight += grpelement.weight
    if thisweight < 0.9999 or thisweight > 1.0001:          # if the vertex weights don't add up to roughly 1.0
        myvertexgroup.add([vertex.index], 1.0, 'ADD')           # add the vertex to the last group with weight 1.0
        print("Vertex weight not 1.0 found")

print("Finished script")


Scale and snapping ... something doesn't work

The maneuver in your illustration is a constrained scale along global X, with the 3D cursor as pivot.  I'm not sure how the constraint was applied; I would expect to see it in the keystrokes or in the use of X axis of the scale manipulator.

Anyway, the settings show: "snap the 'Closest' element (vertex) of your transforming  selection to a 'vertex' on the target, (chosen by hovering over it), while transforming the rest of the selection with it"

So the moves are:

Ensure the pivot is at the center of your scale. That's the point which won't move
Select the vertices you want scaled away from the pivot
Hit SX, or use the manipulator to constrain the scale to X
Hover over the target vertex
Left-click with your cursor inside the little snap target circle to confirm.

'Closest' seems to select the vertex of the transforming selection that was closest to the hover target along the constraint axis before the transform began as the point to lock on the the target. At least, it does when the entire transforming selection was to one side of the target down that axis before the move was made. However I have to say I find its behavior unpredictable when the target is between or inside the source selection.

So I would much rather take the little extra time to use 'Active' as the source element. Then, in vertex mode, you know exactly which vertex will be aligned with your target by ensuring it is the last selected. That may involve shift right-clicking it twice.


Mirror and flip objects with mirror modifier

What you actually are doing is rotating the object 180 deg in the Z axis.
You can do that procedurally with an array modifier and an empty rotated 180 degrees.


Is there a way to offset an edge? (extrude edge loop perpendicular to each edge)

ZMJ100 wrote an addon called SIRE outline. When installed it will appear in the left hand toolshelf in 3dview. It does offset (inset, outset).

https://vimeo.com/28147691 (demo video by tungee)

Over at BlenderArtists ZMj100 went crazy (in a good way) writing mesh addons, one of the addons does exactly what you want. It's probably not polite to link someone elses collection directly here, although I would like to. but here is a direct link to the thread and the zip is in the thread. It's all GPL license.


Using python to change the settings of all subdivision surface modifiers

Use the old one if it exists, else create new one.

Iterated over scene objects rather than all objects in blend.
If the object already has a modifier named "foo" use it, otherwise
create a new one.

test code

import bpy
context = bpy.context

for ob in context.scene.objects:
     if ob.type == 'MESH':
         # get old one or add one
         m = ob.modifiers.get("My SubDiv") or ob.modifiers.new('My SubDiv', 'SUBSURF')
         m.levels = 1
         m.render_levels = 2
         m.quality = 3

oh and in case in testing you have ended up with a cluster of modifiers, here is an example of removing all modifiers with a name starting with "My SubDiv".

for ob in context.scene.objects:
     if ob.type == 'MESH':
         mods = [m for m in ob.modifiers
                 if m.name.startswith("My SubDiv")]
         while mods:
             ob.modifiers.remove(mods.pop())


Motion track while knowing distance between points

If the tracking is accurate, and there are at least 8 good tracking points, and the camera motion contains enough parallax information to solve the scene, then yes, it is possible.
You can set the scale using known distances.
Select two trackers for which you know the distance in the real world, type that value in the Distance option for orientation. Then press Apply Scale.

Then set up the tracking scene.
Please read also the detailed post on this site on motion tracking:
How can I get better results when doing camera motion tracking?


I need to export a list of particle coordinates

Of Blender 2.78 to Blender 2.82 there were several changes.

Now the code that yes work:

import bpy

depg = bpy.context.evaluated_depsgraph_get()
object= bpy.context.scene.objects['Plane']

particles = object.evaluated_get(depg).particle_systems[0].particles

bpy.ops.text.new()

for p in particles:
    bpy.data.texts[-1].write("<particle x='"+str(p.location[0])+"' y='"+str(p.location[1])+"'z='"+str(p.location[2])+"'/>\n")

I get to this code after find these links:

Particles python access is broken in 2.8

Manipulating particles in python


Yes, you can use Alt and ShiftAlt too. However, this only seems to work in a few places.

It worked in some number sliders, it didn't in others. It didn't work in any of the modal operators I tested


How do I get the Color value from an RGB node with Python?

Welcome to Blender.SE, UlfR.

Finding out a property in Blender is relatively easy. Make sure, you have python tooltips enabled (in the user preferences).

Then hover your mouse cursor over the property (in this case the color). A tooltip containing the python command will appear.

The property you seek seems to be outputs[0].default_value.

def_rgb = bpy.data.materials['MyMaterial'].node_tree.nodes['RGB'].outputs[0].default_value

It is a bpy_prop_array by default, so you may want to convert it to a list.

float_values = list(def_rgb)


python 2.8 - image texture stretch versus repeat

You need to create a Texture Coordinate node and connect it to the Image Texture node. This is necessary to provide a mapping for the 2D image onto the 3D model.

The Texture Coordinate node is created using:

tex_coord = nodes.new(type = 'ShaderNodeTexCoord')

Then link the appropriate coordinate type to your image texture. Usually this would be either UV for the coordinates created through UV unwrapping of your mesh or Generated for the automatically generated coordinates. Depending on what you choose, you'll have to use one of the following options to connect the sockets.

links.new(tex_coord.outputs["UV"], node_texture.inputs["Vector"])

or

links.new(tex_coord.outputs["Generated"], node_texture.inputs["Vector"])

The Extension of the Image Texture node doesn't have to be changed, since it is set to Repeat by default, just like the documentation says.


How to change object color depending on its location? (EEVEE or BI, no Cycles)

Your source object doesn't have vertex colors at all, hence the problem (no data to transfer)

To add vertex colors to an object:

Add new vertex color layer
Go to Vertex Paint mode
Enable face selecting
Select face on a mesh
Choose a color
To fill a face with color: Paint -> Set Vertex Color

Steps above in one pic:

Now it is working in Vertex paint mode:

To see it in actual Blender Internal render, check Vertex Color Paint option in material settings:

And for Eevee/Cycles use Attribute node, just type vertex color layer name you have:


How to add fog in the compositor in blender 2.79

The cheapest way to do it is just using the Z-depth like the old games in the 90s to 2000s did it.

For that you just scale the z-depth into the desired range and use it as a factor to mix in a fog-color.

Additionally you can add an early cutoff to not have that much fog closer to the camera.

You can play around with all the factors and the mixing types to get the fog you like.

You can also add a power-to math node to make the falloff non-linear.

If you want something more advanced you can add some ground-fog by rendering
world-coordinate as an additional layer and using world-Z in addition to camera-Z as a factor.

To make it look more realistic you can also add in differently scaled noise-textures based on bands of z-depth (using masks generated with less-than and greater-than nodes).


Where can I find the diameter of my object?

You can change units scall into the scene menu:


Where is the Pipe joint addon in Blender 2.7.3?

This is now located under Extra Objects in the Add Mesh category.

Once you enable it, you can access the custom primitive types with ShiftA > Pipe Joints.

EDIT:

On version 2.79 Pipe Joints are on Add>Mesh>Mechanical>Pipe Joints


Best Strategy To Speed Up Work Flow For Repeated Actions

If you are willing to do a bit of Python scripting, it actually isn't that hard, assuming that you don't have to do anything that involves modifying specific vertices in Edit Mode. For my example script, I will do these three actions:

Duplicate the object and move it 2 Blender Units in the +X direction,
Scale it by a factor of 2 along the Z axis.
Apply the scale.

You can do whatever actions apply to you.

First, set up the viewport. Split the view and pull up a text editor. Create a new text file and name it script.py. At the top of the screen, hover over the bottom of the Info bar (the one with the File, Edit, etc. menus). Your cursor should become vertical resizing arrows. Drag the Info bar down to reveal the Python Report Console.

Next, we need to set up our Python script. In the text editor, type

import bpy

Now, do the first step of our composite action (in this case, duplicate the object and move it). In the Report Console, you will see a new entry has popped up. Right click it, press Ctrl + C (or Cmd + C), and then paste it into a new line in the text editor. My code now looks like this:

import bpy

bpy.ops.object.duplicate_move(OBJECT_OT_duplicate={"linked":False, "mode":'TRANSLATION'}, TRANSFORM_OT_translate={"value":(2, 0, 0), "constraint_axis":(True, False, False), "constraint_orientation":'GLOBAL', "mirror":False, "proportional":'DISABLED', "proportional_edit_falloff":'SMOOTH', "proportional_size":1, "snap":False, "snap_target":'CLOSEST', "snap_point":(0, 0, 0), "snap_align":False, "snap_normal":(0, 0, 0), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":False, "release_confirm":False})

Now we just need to repeat that process for the remaining steps. Note: The blocks of code in the Report Console don't automatically deselect. We can use this to our advantage, though and copy and paste multiple lines at once. Once I got all of my code copied to the script, it looked like this:

import bpy

bpy.ops.object.duplicate_move(OBJECT_OT_duplicate={"linked":False, "mode":'TRANSLATION'}, TRANSFORM_OT_translate={"value":(2, 0, 0), "constraint_axis":(True, False, False), "constraint_orientation":'GLOBAL', "mirror":False, "proportional":'DISABLED', "proportional_edit_falloff":'SMOOTH', "proportional_size":1, "snap":False, "snap_target":'CLOSEST', "snap_point":(0, 0, 0), "snap_align":False, "snap_normal":(0, 0, 0), "gpencil_strokes":False, "texture_space":False, "remove_on_cancel":False, "release_confirm":False})
bpy.ops.transform.resize(value=(1, 1, 2), constraint_axis=(False, False, True), constraint_orientation='GLOBAL', mirror=False, proportional='DISABLED', proportional_edit_falloff='SMOOTH', proportional_size=1)
bpy.ops.object.transform_apply(location=False, rotation=False, scale=True)

Now, I can just select the object I want to duplicate, press "Run Script", and Blender performs all the actions I put there. This should work for most workflows.


No there is no way save for scripting to load and save presets for operators that do not explicitly support it in the toolbar. This would not be my recommendation for a first project in blender API however after a few basic tutorials (maybe this ) you should be able to do this sort of thing on your own.

Edit: Another alternative that comes to my mind is duplication. I can't tell if that is helpful but certainly making one bolt by hand is far easier than making a script to do it.


Make sure that under Symmetry \ Lock you turn Lock off. You had lock set to x axis. So the smooth brush was still working but the vertices did not move in the x axis.


Blender not playing the right animations

Okay, this was simple and silly. Just like Serge L said in the comments to the question. You need to click on one of the bones and then change the animation.

Pretty silly, but I think there might be others who might face the same problem when they start learning, so I am posting it here.

Thank You Serge.


Add a sphere and an empty at the center
Add an Array Modifier to the sphere, scale the empty and modify the arrays count.

Add another sphere and parent it to the first added sphere Ctrl-P
Enable duplication in the objetcs properties:

Result:


I think Blender needs either a *.py or *.zip file for add-ons. I downloaded the *.dmg, decompressed it and then I zipped it. Then i was able to install the add-on.


Here are a few ways to do it:

Go to Preferences > Add-ons and search for "Curve Tools" and activate the Add Curve: Curve Tools add-on by checking the box next to it. In the 3D Viewport press N to extent the Tool Shelf and click the Edit tab. Then go to Curve Tools > One Curve and click the "Set origin to spline start"-button.

Select the curve, go into Edit Mode. Select the starting vertex. press Shift + S, and choose Cursor to Selected. Go into Object Mode. Press F3 (default search key) and type "Set Origin" and choose Origin to 3D Cursor.

In the 3D Viewport Header click the Snapping-button. (It is the icon next to the little magnet icon.) Choose Snap to Vertex. Then in the same header click Options and check the box next to Origins (uncheck it when you're done). Now hold Ctrl (or click the magnet icon) while moving the origin to snap it to the starting vertex.


Bevel not uniform, despite applying transforms

This is how the "Percent" bevel mode works. Change it to one of the other modes, such as "Offset":


Texture appears in render but not in game engine

It seems that you haven't unwrapped the mesh.
Change to Edit Mode in the 3D-View and select all A press U for unwrap.

In the texures settings select UV for Coordinates and UVMap as Map, Projection should be Flat by default.

Set the Viewport Shading to Texture

After that the texture should be shown in the Game Engine.

EDIT:

Examining your .blend shows that the texture wasn't included in the file. I replaced it with another one, the issue that the texture isn't rendered in the BGE could be fixed either by moving it into the first slot:

Alternatively you could set Shading to GLSL in Properties Panel N in the 3D-View in Object Mode:


Using Cycles materials

Create the appearing object with material that is a combination of emitter and diffuse, and mix that with a transparent material.
At the beginning of the animation the material should be completely transparent:

Click the image to enlarge
Animate the values for the emitter and the transparency so that as it becomes more visible it also becomes brighter with the emitter. Once it reaches the brightest value, start taking the emitter back to zero so that it becomes diffuse only with no transparency.

Click the image to enlarge

Click the image to enlarge

Click the image to enlarge
For added visual punch swich over to the compositor, where you can add a glare effect (ShiftA > Filter > Glare) to the whole thing.

Using the compositor only
Separate the objects to appear in a different render layer.

Click the image to enlarge
Set the alpha transparency so that the layer is invisible at the beginning of the animation.

Click the image to enlarge
Then animate the values for the alpha channel so that the transparency is off and the layer is fully visible but very bright and blured.

Click the image to enlarge
Finally animate the values for the brightness and blur so that the render layer returns to its normal brightness and the blur disappears.


How to bake wireframe to texture? no i'm not referring to export uv

I'm not sure this is exactly what you want but you could duplicate your object, apply all the modifiers to the copy, in Edit mode/Face Select mode, select all and inset individual faces (double i), give a color to the selection, invert selection and give another color to the wireframe, then bake the result?


Move material actions separately in NLA for duplicated objects

You can't create different animations for same material, because NLA-tracks belong to the material, not to the objects. But there is a walkaround, to make that you want:

You can use one material that will be displayed differently depending on the properties of the object. For example, object index:

Object index sets in object properties. Relations tab:

Then using node setup, like this, you can set different settings for different object using same material.


You have the Only Render option enabled. Uncheck it in Display panel of the properties shelf (N).


How to make a precise bolt hole in a simpler way?

I'd do it almost your way, just skipping a couple of steps..

As you did, knife Project and cut through
Deselect the bottom faces, and E extrude the top faces downard, numerically entering the depth of 0.5 in the 'last operator' panel
Select the top and bottom inner faces, and..
...'Bridge Edge Loops' (you don't need to delete)

However, if your topology is simple enough to stand it, and you wouldn't need to do too much tidying afterwards.. you could just make and duplicate the bolts in the correct dimensions, and cut them all out in a single boolean operation.


How to draw a Rotoshape (mask) in the Compositor?

Masks work the same way they worked before 2.8

Masks are not edited in the compositor: Create, manipulate and animate your masks in the image editor or the movie clip editor. You can add keyframes to the spline points.

To use the mask in the compositor you use an Input > Mask node.

There is no need to render masks as images.

To automate the rotoscoping process you could also use motion tracking. See this link: Can a mask stick to a shape in the motion tracker?


The trick is to enable UV mapping on the curve and then use UV as the input texture coordinate. Then use can use the mapping node to rotate the default UV positioning to get the gradient to run along the length of the curve. Please note I had to adjust the X/Y scale factor to get the whole gradient to show on the curve.


You've got both an animation in the 3D Viewport set up, as well as a Sequence in the Video Sequence Editor within the same scene. The sequence in the VSE now seems to take precedence over the 3D Viewport Rendering. So essentially, when you do a render, instead of using Blender Render to knock out the frames of your animation, the VSE is trying to read the PNGs defined in the sequence strip, and spits out those.

To "fix" this, you can disable the Sequencer output in the Post Processing tab under the Render Settings. Disable the checkbox called Sequencer and render your animation.

Once done, you can enable the Sequencer checkbox again when you're ready to cut the video strips.

Personal Recommendation: To avoid this kind of confusion, create a second scene in your Blend File to separate animation from video editing. This way, Rendering and Animation can have their needed settings, while Video Editing can have completely different ones.


Rocket engine thrust. Point density node?

This is most likely a problem with Vector space. From your screenshot you are using 'Object' space but this will move along and distort with the location, rotation, scale of the domain object. As the missile moves and drags the domain (I presume it's parented to the missile) the coordinates will change. To resolve this try changing to World coordinates as shown :


Rendering does not process transparency changes over time - Playing my timeline do. v2.79b

Thanks for the file, i didnt realise that you were using Blender Render, i cant help you with that because i only use cycles and eevee.

If you want the retro-aesthetics of blender you could even use eevee and configure it that way, plus benfit from the rendering speed.

In Cycles as in EEVEE you would do your animation via the Node-Editor and animate the facture of a mix shader that hast one diffuse and one transparent shader (with absolute white!) in it.


Cycles Materials Math node with more than two inputs

I won't cover the complete topic about Custom Nodes, because there's too much that can be done.
This is just a small compilation of things to know for writing custom nodes that work in Cycles. Knowledge of Python and Blender's API is required, as I won't dig deep into them.

In Blender's API we have a NodeCustomGroup class that is similar to the NodeGroup class. Before going into the NodeCustomGroup, let us explain a bit how the nodetrees work:

A Nodetree has mainly 4 collections. The nodes collection, the links collection, the inputs collection and the outputs collection. The NodeGroup node encapsulates a nodetree in order to turn it into a visible node in the editor. It scans the nodetree interface, and creates sockets for using the nodetree. This process is automatic and there's nothing we can do with it.

The good news is that we have the NodeCustomGroup. From this class, we can build the interface of a nodetree and even build/rebuild the same nodetree dynamically, have custom properties, respond to events, and have access to the Blender's context.

For the NodeCustomGroup, we'll need to create our nodetree (which must be a ShaderNodeTree, if we're going to make a Cycles' node). Then we need to populate this tree with one NodeGroupInput and one NodeGroupOutput, as they are used to create the nodetree interface. After we build our nodetree as we do for nodegroups: add nodes, input sockets, output sockets, and links to connect everything.

After that you need to define how the Custom Node is supposed to work...For example, in this case, would include functions that check if an input Virtual Socket is linked, and if so, make the changes to the nodetree, create a new Float Socket, remove that original link and add a new link to the created socket, etc. Actions for checking if some socket is disconnect might also be written.

When the node is completed one must register it, which is the same process as for any class in Blender.

For adding it to the Add Menu and the Add Panel, you should to use the nodeitems_utils module (and for a better integration, one should also use the ShaderNewNodeCategory from nodeitems_builtins). This should be used with caution as I know some well known addons that use these modules in ways that disable the interface of other addons (i.e. Blend4Web).

For the last, I leave here the code from a node from my Github page. It's small enough to paste it here, and it covers dynamic nodetree and interface management. Some examples of this node working here.

# Node Authors: Secrop
# Node Description: Node for creating loops over some nodegroup
# version: (0,0,3)

import bpy

# for blender2.80 we should derive the class from bpy.types.ShaderNodeCustomGroup
class ShaderNodeLoop(bpy.types.NodeCustomGroup):

    bl_name='ShaderNodeLoop'
    bl_label='Loop Node'

    def nodegroups(self, context):
        nt=context.space_data.edit_tree
        list=[('None','None','None')]
        for nd in nt.nodes:
            if nd.type=='GROUP':
                ng=nd.node_tree
                if ng.inputs.get('iterator'):
                    list.append((ng.name, ng.name, ng.name))
        return list

    def __nodeinterface_setup__(self):
        self.node_tree.outputs.clear()
        self.node_tree.inputs.clear()
        if self.step_nodegroup=='None':
            return
        for input in bpy.data.node_groups[self.step_nodegroup].inputs:
            if not input.name=='iterator':
                self.node_tree.nodes['Group Input'].outputs.new(input.bl_socket_idname, input.name)
                self.node_tree.inputs.new(input.bl_socket_idname, input.name)
        for output in bpy.data.node_groups[self.step_nodegroup].outputs:
            self.node_tree.nodes['Group Output'].inputs.new(output.bl_socket_idname, output.name)
            self.node_tree.outputs.new(output.bl_socket_idname, output.name)

    def __nodetree_setup__(self):
        self.node_tree.links.clear()
        for node in self.node_tree.nodes:
            if not node.name in ['Group Input','Group Output']:
                self.node_tree.nodes.remove(node)
        if self.step_nodegroup=='None':
            return
        previousnode=self.node_tree.nodes['Group Input']
        for iter in range(self.iterations):
            curnode=self.node_tree.nodes.new('ShaderNodeGroup')
            curnode.node_tree=bpy.data.node_groups[self.step_nodegroup]
            curnode.inputs['iterator'].default_value=iter
            for input in curnode.inputs:
                poutput=previousnode.outputs.get(input.name)
                if poutput:
                    self.node_tree.links.new(poutput, input)
            if iter==self.iterations-1:
                for input in self.node_tree.nodes['Group Output'].inputs:
                    poutput=curnode.outputs.get(input.name)
                    if poutput:
                        self.node_tree.links.new(poutput, input)
            else:
                previousnode=curnode

    def update_nt(self, context):
        self.__nodeinterface_setup__()
        self.__nodetree_setup__()

    def update_it(self, context):
        self.__nodetree_setup__()

    # for blender 2.80, the following properties should be annotations
    step_nodegroup=bpy.props.EnumProperty(name="step_nodegroup", items=nodegroups, update=update_nt)

    iterations=bpy.props.IntProperty(name="iterations", min=1, max=63, default=8, update=update_it)

    def init(self, context):
        self.node_tree=bpy.data.node_groups.new('.' + self.bl_name, 'ShaderNodeTree')
        self.node_tree.nodes.new('NodeGroupInput')
        self.node_tree.nodes.new('NodeGroupOutput')

    def draw_buttons(self, context, layout):
        row=layout.row()
        row.alert=(self.step_nodegroup=='None')
        row.prop(self, 'step_nodegroup', text='')
        row=layout.row()
        row.prop(self, 'iterations', text='iterations')

    def copy(self, node):
        self.node_tree=node.node_tree.copy()

    def free(self):
        bpy.data.node_groups.remove(self.node_tree, do_unlink=True)

from nodeitems_utils import NodeItem, register_node_categories, unregister_node_categories
# in blender2.80 use ShaderNodeCategory
from nodeitems_builtins import ShaderNewNodeCategory

newcatlist = [ShaderNewNodeCategory("SH_NEW_CUSTOM", "Custom Nodes", items=[NodeItem("ShaderNodeLoop"),]),]

def register():
    bpy.utils.register_class(ShaderNodeLoop)
    register_node_categories("CUSTOM_NODES", newcatlist)

def unregister():
    unregister_node_categories("CUSTOM_NODES")
    bpy.utils.unregister_class(ShaderNodeLoop)

if __name__ == "__main__":
    register()

And here's a small video of another node I wrote with a dynamic interface:
https://www.youtube.com/watch?v=11Xd-p3HE48

EDIT

The above techniques can be used to produce a dynamic maths node with a variable number of inputs.

For example, paste the following code into a Text Editor window, name the text block 'mathsDynamic.py', tick the Register checkbox (so it's executed automatically when the blend file is loaded) and click 'Run Script'.

# Node Authors: Secrop, Rich Sedman
# Node Description: Dynamic Maths node with variable number of inputs
# version: (0,0,1)

import bpy

# for blender2.80 we should derive the class from bpy.types.ShaderNodeCustomGroup
class MathsDynamic(bpy.types.NodeCustomGroup):

    bl_name='MathsDynamic'
    bl_label='Dynamic Maths'

    # Return the list of valid operators
    def operators(self, context):
        nt=context.space_data.edit_tree
        list=[('ADD','Add','Addition'),('SUBTRACT', 'Subtract', 'Subtraction'), ('MULTIPLY', 'Multiply', 'Multiplication'), ('DIVIDE', 'Divide', 'Division'), ('MAXIMUM','Max','Maximum'),('MINIMUM','Min','Minimum') ]
        return list

    # Manage the node's sockets, adding additional ones when needed and removing those no longer required
    def __nodeinterface_setup__(self):

        # No operators --> no inpout or output sockets
        if self.inputSockets < 1:
            self.node_tree.inputs.clear()
            self.node_tree.outputs.clear()

            return

        # Look for input sockets that are no longer required and remove them
        for i in range(len(self.node_tree.inputs),0,-1):
            if i > self.inputSockets:
                self.node_tree.inputs.remove(self.node_tree.inputs[-1])

        # Add any additional input sockets that are now required
        for i in range(0, self.inputSockets):
            if i > len(self.node_tree.inputs):
                self.node_tree.inputs.new("NodeSocketFloat", "Value")

        # Add the output socket
        if len(self.node_tree.outputs) < 1:
            self.node_tree.outputs.new("NodeSocketFloat", "Value")

    # Manage the internal nodes to perform the chained operation - clear all the nodes and build from scratch each time.
    def __nodetree_setup__(self):

        # Remove all links and all nodes that aren't Group Input or Group Output
        self.node_tree.links.clear()
        for node in self.node_tree.nodes:
            if not node.name in ['Group Input','Group Output']:
                self.node_tree.nodes.remove(node)

        # Start from Group Input and add nodes as required, chaining each new one to the previous level and the next input
        groupinput = self.node_tree.nodes['Group Input']
        previousnode = groupinput
        if self.inputSockets <= 1:
            # Special case <= 1 input --> link input directly to output
            self.node_tree.links.new(previousnode.outputs[0],self.node_tree.nodes['Group Output'].inputs[0])
        else:
            # Create one node for each input socket > 1
            for i in range(1, self.inputSockets):
                newnode = self.node_tree.nodes.new('ShaderNodeMath')
                newnode.operation = self.selectOperator
                self.node_tree.links.new(previousnode.outputs[0],newnode.inputs[0])
                self.node_tree.links.new(groupinput.outputs[i],newnode.inputs[1])
                previousnode = newnode

            # Connect the last one to the output
            self.node_tree.links.new(previousnode.outputs[0],self.node_tree.nodes['Group Output'].inputs[0])

    # Chosen operator has changed - update the nodes and links
    def update_operator(self, context):
        self.__nodeinterface_setup__()
        self.__nodetree_setup__()

    # Number of inputs has changed - update the nodes and links
    def update_inpSockets(self, context):
        self.__nodeinterface_setup__()
        self.__nodetree_setup__()

    # The node properties - Operator (Add, Subtract, etc.) and number of input sockets
    # for blender 2.80, the following properties should be annotations
    selectOperator=bpy.props.EnumProperty(name="selectOperator", items=operators, update=update_operator)
    inputSockets=bpy.props.IntProperty(name="Inputs", min=0, max=63, default=0, update=update_inpSockets)

    # Setup the node - setup the node tree and add the group Input and Output nodes
    def init(self, context):
        self.node_tree=bpy.data.node_groups.new('.' + self.bl_name, 'ShaderNodeTree')
        self.node_tree.nodes.new('NodeGroupInput')
        self.node_tree.nodes.new('NodeGroupOutput')

    # Draw the node components
    def draw_buttons(self, context, layout):
        row=layout.row()
        row.alert=(self.selectOperator=='None')
        row.prop(self, 'selectOperator', text='')
        row=layout.row()
        row.prop(self, 'inputSockets', text='Inputs')

    # Copy
    def copy(self, node):
        self.node_tree=node.node_tree.copy()

    # Free (when node is deleted)
    def free(self):
        bpy.data.node_groups.remove(self.node_tree, do_unlink=True)

from nodeitems_utils import NodeItem, register_node_categories, unregister_node_categories
# in blender2.80 use ShaderNodeCategory
from nodeitems_builtins import ShaderNewNodeCategory

def register():
    bpy.utils.register_class(MathsDynamic)
    newcatlist = [ShaderNewNodeCategory("SH_NEW_CUSTOM", "Custom Nodes", items=[NodeItem("MathsDynamic"),]),]
    register_node_categories("CUSTOM_NODES", newcatlist)

def unregister():
    unregister_node_categories("CUSTOM_NODES")
    bpy.utils.unregister_class(MathsDynamic)

# Attempt to unregister our class (in case it's already been registered before) and register it.
try :
    unregister()
except:
    pass
register()

In the Node Editor you should now have an additional Custom Nodes menu in the Add menu and within that a new node, 'Dynamic Maths'.

The new node provides a drop-down to select the maths operation (Add, Subtract, etc.) and a control to specify the required number of inputs. The node is essentially a Node Group that cannot be manually edited and looks like a normal node. The nodes inside the group are rebuilt automatically each time the node parameters (the operation and the number of inputs) are changed.

For example, setting the operation to 'Add' and setting the number of inputs to 3 will produce the following internal node structure :

Note that the nodes within the group are automatically generated. Changing the node properties changes in inner workings of the group to provide the desired function with the specified number of inputs :

The node can be used anywhere a standard 'Maths' node is used and the performance should be similar to using multiple cascaded Maths nodes to create the same function (since it's essentially just a NodeGroup). It currently supports Add, Subtract, Multiply, Divide, Max and Min functions, with up to 63 inputs.

EDIT II

I'd like to add that there was some changes in the API for Blender 2.80 that affect this answer. Instead of NodeCustomGroup, we now have two new classes we can use:

-ShaderNodeCustomGroup, which is now compatible with Eevee, Cycles and the Viewport material shading.

-CompositorNodeCustomGroup, which allows having custom nodes for Compositor Node_Trees.


There is no limit to the number of iterations in theory.

What makes your loop a bit more advanced is that you iterate through two lists at the same time. Normally you only want to do this when both lists have the same length because the addon works in the following way:

At first the loop will take the first element from both lists (Index 0). Then the second element from both lists, etc... This will continue until it reaches the last element of a list -> so the shortest list defines the number of iterations in a loop. The rest will be ignored.

The Evaluate Sound node outputs a float list with 10 elements in your example.

The debug node in a loop always shows the last value that went into the node.

If you just want to move around all the objects you can simply remove the Float Iterator from the loop. Then each object should receive the transformation.

I guess you want to use the sound information in the loop with a different frequency for each object. The easiest way to archieve this is to use the Sound Equalizer template that ships with the addon:


Can I have two different UV unwrappings of the same object?

Yes, it is possible.

In the mesh panel, under UV Maps, press the "+" button. This will create a new UV map with the same coordinates as the existing one.

For Cycles, in the node editor, select Input -> UV Map to use different UV maps for different shader parts.

In Blender Internal, you can select which UV map to use in the texture panels.


procedural generate mesh that fits each other

Use a the Cell fracture addon - Fracture addon - to break up your master outline object, then shrink each piece using a deform modifier with a negative value, OR use the margin variable in the script preferences to create a gap between elements.
Check out this tutorial if you are stuck - Cell Fracture addon tut


Yes, just stop dragging and the dialog box to tweak everything will appear at the bottom (you just might need to expand it).


In edit mode you can change selection modes by pressing ctrl tab. Or just clicking this button in the 3D view header.

To select edges you want edge select mode.

To use more then one selection mode at a time, shift LMB  on ether the buttons in the 3D header or the ctrl tab menu.


To avoid moving markers, you need to move the mouse cursor away from the marker region at the bottom.

e.g. Here is an example for Select All operation:

Or you can toggle Lock Markers from Marker menu, to make them not editable / selectable:


How to make a triangle with one angle being 90°

If the second screenshot of your desired result is the side view of the future prism, then you can dissolve geometry of the cube.

Add a cube, in Edit mode choose Edge Select to select edges. Select one of the top edges of the cube. Press X > Dissolve Edges.

Once the edge is dissolved the mesh becomes a prism.


Short answer:

There is no “rendered” cache.
Not all codecs are equal.

As to the first point, every single operation, including shifting resolutions from your source file to destination, alpha overs, etc. are all done in real-time. This means that if you stack twenty strips with Alpha Over, every one is calculated on the fly.

As to the second point, codecs are designed with different design goals. Some are to compress the data size, some are for streams, some are for other nuanced things. These codecs can put more or less demand on a system depending how they were designed.

Typically, you shouldn't be doing manipulations and effects work in an NLE anyways, so it isn't much of an issue; use an NLE to get your beats, but use other tools for your grading or effects work in a non-realtime environment.

To maximize the VSE's ability to perform, you might want to try a few things:

Keep your rendering output dimensions precisely the same as the dimensions of your input file. Some DSLRs for example shoot 1920x1088, and using 1920x1080 will result in a costly scale every frame.
Use temporary simple effects strips to block in your complex work. Worry about keeping the frame rate high instead of how it looks. You can do the heavy work later in a compositor.
Don't bother grading or adding more processing. Again, save that for when you are finished so you can grade it more precisely in a proper tool, at proper deeper bit depths.
Keep dissolves and overs to an absolute minimum. The VSE can keep up if you avoid stacking many together.
Use a codec designed for quick seeking and decoding. A non Group Of Pictures (GOP) codec that stores all I frames is ideal.

As someone who decided to try and take a piece to broadcast with Blender, I can tell you that it can be used effectively, albeit with some effort and planning.

Hope that helps you along...


I don't know why it's not set up by default but you can change the "pan view direction" in: Preferences > Input > Keymap > 3d view > 3d view global and it will work


When using an Operator Modal Timer, how do i change the time period such that it executes every 5 seconds?

The event timer has a property which defines how often your modal function will get called with the timer event, just change the value accordingly in the execute function:
time = 5.0
self._timer = wm.event_timer_add(time, window=context.window)


How to Export correctly a standalone Game?

You only need one addon, is "required" that you have everything (textures, videos, others blends, sounds, etc.) in the same folder as your primary blend.

This highlighted files will be create when saving as runtime and they are required to be in the same folder of the .exe, if you are using only one blend and have already packed all external data you still require all that new files.

If you have this type of texture problem that I had while writing this answer:

Notice the next block is not in the same order of the gif

First i open the "blend file" and make paths relative and no change (but lol i has editing the wrong file...) so i pack all into blend and again no chage, then i almost realize and i set the textures names again then pack all and save the file and no change (lol). Finally i change de name of the file to load the want edit and the textures were there:

Disclaimer

I do not know if by repeatedly packing, make the blend file bigger.

Notice the file that i exported to run time is diferent from the one with the textures problem.
In the case of only one file after make the pack or repack, export it again to run time but this time dont need to check the copy of bundle and dlls.


Rotating a bone along one of its local axes

Have you tried hitting X one extra time? eg. R >> X >> X". Maybe you have to do two Y's OR two Z's but one of these options should get you there.

Here are bones rotating in their local axis.

If you are in Edit Mode, X May be close to equal (global vs. local).
Instead try Y & Z:


Topology overview:

You will probably want to go with similar topology for Smooth Shading and Subdivision Surface modifer.

It's created from simple Circle.

Extruded and Scaled outwards.
Extruded bottom edge.

Tip: To streighten Edge Loop on the Z axis - press S > Z > 0
Whole shape extruded.
Bottom part extruded.

After this you will need to add Proximity Loop to have nice Bevel with Bevel Modifier.

You can control edge sharpness with Bevel Width and number of Segments.

Blend file:


How to setup a simple scene using Python in BGE?

ShungChing!

This problem is due to the fact that you are using the wrong library. When you use Blender Game Engine, you have to use bge library instead of bpy.
Try to do the next things:
1) Add an empty in the position you wan to add cube;

2) Add the cube to another layer;

3) To Empty object attach the always sensor --> python controller --> EditObject actuator(make the actuator's name is 'AddCube')

4) The script:

import bge
from bge import logic, types

cont = logic.getCurrentController()
act = cont.actuators["AddCube"]
act.instantAddObject()

Answer files


Lighting a volume with a bi-color point light

I think your problem is with the scale of the mapping for the texture.
I made a test using an empty to control the mapping. Changing the scale of the empty or the size on the Mapping controls did the trick.


When I Render my image, the result is a Black Screen

You have enabled nodes for rendering but there is no render layer connected to the composite node.

Add a in input>render_layer node and plug it to the composite node to get some output.


Cycles GPU CUDA out of memory - How to identify the problem objects?

As far as I know, there's no automated tool to identify the resource hogs in your scene. You'll need to do most of it manually. But surely you'll have an idea on what object / element could be the cause? Like, high res textures, dense meshes (check subsurf and multires modifier render settings too!!), lots of copies instead of instances, or fur / hair.
One possibility is to put those objects on separate layers, and render just that layer with very low samples (1 should be enough). The memory consumption can then be read in the debug print line on top of the render view.
Important: Use final render (F12), as many modifiers (like the Subsurf by default) have higher settings for final render than for vieport render.

Edit
For rendering animations, it might also be beneficial for debugging this to have the memory usage in the test render frames directly. You can enable Stamp Output and check Memory to do so, if you have Blender 2.78 (or a current development build which was compiled after Jul 14, 2016):


Little problem with arm movement in my character's walk cycle

Your arm IK control bones (Arm.L and Arm.R) are positioned too far in parts of animation, so the arms need to extend too much and are no longer bent in elbow. That causes the elbow popping in the walk cycle.

Also the same bones are not looped, so that causes another discontinuity when looping the animation.

Keyframe these bones more carefully to not overextend the arms and loop them and the animation will be fine.


Where are influence and mapping settings of a texture saved?

You're right if you switch the Properties View to Datablocks you can examine the datastructure.

You find the per slot settings (Texture Layers) under /Materials/MaterialName/Textures /TextureName.
Each texture slot has its own settings.

How the different settings influence the resulting material is controled by the influence sliders of the checked properties and the Blend Mode setting.


This dropdown specifies the Node Tree to be linked within.

Check that both of them have the desired tree.


How to prevent the decimate modifier from working on vertices outside the vertex group (with python)?

Old answer below!

My solution was terrible slow. So I got the blender sources and changed the modifier. It was fairly easy!

I added following code on line 311 (https://git.blender.org/gitweb/gitweb.cgi/blender.git/blob/master:/source/blender/bmesh/tools/bmesh_decimate_collapse.c#l311)

// Only work on vertex groups
// vweights is false when no vertex groups are used
    if (vweights) {
        float weight_v1 = roundf(vweights[BM_elem_index_get(e->v1)]);
        float weight_v2 = roundf(vweights[BM_elem_index_get(e->v2)]);

        if (weight_v1 != 0.0f && weight_v2 != 0.0f)
        {
            eheap_table[BM_elem_index_get(e)] = BLI_heap_insert(eheap, cost, e);
            return;
        }
        else
            return;
    }

As you can see I used the weight to find out if the vertex is really in the group. I need to do that because in deform.c (https://git.blender.org/gitweb/gitweb.cgi/blender.git/blob/HEAD:/source/blender/blenkernel/intern/deform.c#l742) the weight is set to 0.0 even if the vertex isn't inside the group.
If you need this you need to add vertices to a group and set any value between 0.01 and 1 as vertex weight.

Old answer

I wrote a simple (stupid) decimate algorithm which only works on a vertex group or the whole mesh. It is only collapsing edges and the angles are totally ignored. It is not trying to preserve the shape really well.

Here is the code, it is not optimized (I am pretty new to python) and I know I could optimze it here and there (all the bpy.ops api calls could have faster api methods) but for now I am happy. Nevertheless: Here is the code!

If you have an idea how the algorithm would be faster, spit it out. Thanks!

# how_often: how often should a edge be collapsed
# group_name: if it is None it will work on the whole mesh or on a given group.
def decimate_mesh(self, how_often=0, group_name=None):
    import bpy
    ob = bpy.context.active_object
    mesh = ob.data

    # go to edit mode and deselect everything .. just to be sure
    bpy.ops.object.mode_set(mode = 'EDIT')
    bpy.ops.mesh.select_all(action='DESELECT')
    bpy.ops.object.mode_set(mode = 'OBJECT')
    how_often_decimate = how_often

    if group_name is None:
        # decimate all edges
        while how_often_decimate != 0:
            edge_length = dict()
            # calculate edge lengths
            for edge in mesh.edges:
                edge_length[(mesh.vertices[edge.vertices[0]].co-mesh.vertices[edge.vertices[1]].co).length] = edge
            # pick the shortest edge, collapse it and make all polygons concave
            min_key = min(edge_length.keys())
            edge_to_collapse = edge_length[min_key]
            edge_to_collapse.select = True
            bpy.ops.object.mode_set(mode = 'EDIT')
            bpy.ops.mesh.merge(type='COLLAPSE')

            bpy.ops.mesh.select_all(action='DESELECT')
            bpy.ops.mesh.select_all(action='SELECT')
            bpy.ops.mesh.vert_connect_concave()
            bpy.ops.mesh.select_all(action='DESELECT')
            bpy.ops.object.mode_set(mode = 'OBJECT')
            how_often_decimate -= 1
    else:
        # decimate edges where both vertices (of the edge) are part of the vertes group
        group_index = ob.vertex_groups[group_name].index
        while how_often_decimate != 0:
            vertices_which_are_assigned_to_group = set()
            edges_which_can_be_decimated = set()
            edge_length = dict()
            # I am unsure if I really need to do this every time. I know that the indexes could be altered by blender
            # but I need to know which vertices are inside the group. So yeah...
            for vert in mesh.vertices:
                for vert_group in vert.groups:
                    if vert_group.group == group_index:
                        vertices_which_are_assigned_to_group.add(vert.index)

            for edge in mesh.edges:
                vertex_0_index = edge.vertices[0]
                vertex_1_index = edge.vertices[1]
                if vertex_0_index in vertices_which_are_assigned_to_group and vertex_1_index in vertices_which_are_assigned_to_group:
                    edges_which_can_be_decimated.add(edge)

            if len(edges_which_can_be_decimated) == 0:
                print("No edges anymore!")
                break
            for edge in edges_which_can_be_decimated:
                edge_length[(mesh.vertices[edge.vertices[0]].co-mesh.vertices[edge.vertices[1]].co).length] = edge

            min_key = min(edge_length.keys())
            edge_to_collapse = edge_length[min_key]
            edge_to_collapse.select = True
            bpy.ops.object.mode_set(mode = 'EDIT')
            bpy.ops.mesh.merge(type='COLLAPSE')
            bpy.ops.mesh.select_all(action='DESELECT')
            bpy.ops.mesh.select_all(action='SELECT')
            bpy.ops.mesh.vert_connect_concave()
            bpy.ops.mesh.select_all(action='DESELECT')
            bpy.ops.object.mode_set(mode = 'OBJECT')
            how_often_decimate -= 1


How to change number of vertices for cylinder after created it?

You'll have to do it more or less manually.
Two ways come to mind.

01) Screw Modifier - when your mesh has a uniform profile (Eg. greek columns, wheel rims)

02) To sphere function - when you run out of options :)

Add loopcuts and use Mesh > Transform > To Sphere to correct the the circles


How to set location of instance objects randomly along input mesh's polygon normal?

You can scale polygon center location with random numbers or number wiggle for animation.

Node tree:


Lighting specific objects in cycles with volumetric atmosphere

A possible soution is not using volumetrics in the world setting but creating a solid that contains the whole scene with volume scatter shader.
Have that solid be in only one layer and have other layers with no volumetrics to light the objects.

For example on a scene like this:

I added a cube that surrounds the whole scene and added a volume scatter node as volume to create the volumetrics.

on a separate layer I have the object on the left with separate lighting and no volumetrics.

I render both layers separately and combine them in the compositor:


How to control the mix of emission and transparency materials?

As Artturi said, a mix shader can help transition between different shaders.  In the example below, I've used vertex paint to make the black and white image that is used as a factor between a glowing/opaque pink material (mostly an emission shader) and a more transparent purple material (I've used the fresnel node to make the outer edges more opaque, as in the picture you uploaded).

The node setup is more complicated than it needs to be to illustrate the principle, but it does show how you might use it to get something like your picture.


vtx files contain textures, and i think you can easily import/export them using: http://nemesis.thewavelength.net/index.php?c=178#p178 by nem

mdl files are compiled model files (probably for performance reasons), the original source files are in smd format which you can easily import into blender using the official Valve script for the smd format:
http://developer.valvesoftware.com/wiki/Blender_Source_Tools

As for the mdl decompiling you can use Crowbar:

https://developer.valvesoftware.com/wiki/Crowbar


I found it. it is my Wrong. I use reference videos for creating animation in video sequencer editor. Because of those videos rendered in render time. I delete this videos and it's fine.


Not Shure with not so much info. But for me it looks like caustics. if you want to get rid of them just disable them in Cycles render under Render>Light Paths>Caustics> click on boxes that may be on by Default. I hope it did help.


You may use Shrinkwrap modifier.
You should separate each part using "P" because the modifier is working between different objects.
You can find the balance between the settings, offset, even using a group of vertices, to have a gap between the two meshes.
The original mesh:

An example of the result using Shrinkwrap:

Notice on the right part: a poor vertex count or a wrong topology do not allow the modifier to manage the gap as expected.

Depending on the position of the vertices and the different topology,
you may need to modify or add/remove some loops.


I had this same problem and was able to fix it by changing the versions of each program. Below is the cocktail of versions I used:

Blender: 2.91.0
Renderdoc: 1.10
MapsModelsImporter: 0.3.5


As you said you have the right click mouse to select a line, you can select a block of line with B then click and drag for select or middle mouse click and drag for un-select. And you can select and un-select all the line with A.

You can delete all selected lines by pressing X.

As far as I know, the only way to copy a line is CtrlC.

My tip for selecting only one line is, if you have other lines selected, do A for un-select all and then copy your line.

Last thing, for navigating you can use the middle mouse wheel but you can also use the middle mouse wheel click then click and drag.


Why can't I see motion blur in the viewport cycles?

Look here -> http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Integrator under Motion Blur ... " Viewport rendering currently will not show motion blur." Not yet but maybe one day ;)

From a technical perspective I'd say - viewport is viewport (and has nothing to do with shutter, focal length, aperture etc.) - If you hit F12 you "jump" to your camera in your scene which has all those specs ... that seems quite comprehensible.

That's because the render process and the viewport rendering are two different things (from a programmers perspective) - that's all I can say ... maybe that will help you What are the technical differences between F12 render and viewport preview?


Button callback based on the objects particle system?

An Object property?

Make it an object property then it is set on a per object basis.

Since the property is defined on an Object class, then self in an update method is an object of type bpy.types.Object of which context.object is an instance .  If it was registered as a scene property, self would be a scene.

If it were a scene property, I would set the PS type for all objects with it.

def emitter_update(self, context):
    toogle = self.my_prop_grp.emitter_hair
    pobs = [o for o in self.objects if len(o.particle_systems)]
    for ob in pobs:
        part = ob.particle_systems[0]
        settings = part.settings
        settings.type = 'EMITTER' if toogle else 'HAIR'

Consult blender docs re naming conventions for classes, methods.

One of my pet hates: when context is passed as a function argument .. use it. Get out of the habit of bpy.context.foo.blah.bar...

Added a poll method in panel so it doesn't show when context object has no particle system.

import bpy
from bpy.props import  BoolProperty, PointerProperty
from bpy.types import PropertyGroup, Panel, Object

def emitter_update(self, context):
    toogle = self.my_prop_grp.emitter_hair
    part = self.particle_systems[0]
    settings = part.settings
    settings.type = 'EMITTER' if toogle else 'HAIR'

class MyParticleSettings(bpy.types.PropertyGroup):
    emitter_hair: BoolProperty(update = emitter_update)

class VIEW3D_PT_toggle_ps(Panel):
    """Test"""

    bl_label = "My Panel"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_category = "View"

    @classmethod
    def poll(self, context):
        ob = context.object
        return ob and len(ob.particle_systems)

    def draw(self, context):
        ob = context.object
        layout = self.layout
        layout.label(text="My problem:")
        layout.prop(ob.my_particle_settings, 'emitter_hair',  text="Toggle")

classes = (MyParticleSettings,
        VIEW3D_PT_toggle_ps)

def register():
    for cls in classes:
        bpy.utils.register_class(cls)

    Object.my_particle_settings = PointerProperty(type=MyParticleSettings)

def unregister():
    for cls in reversed(classes):
        bpy.utils.unregister_class(cls)

if __name__ == "__main__":
    register()

I imagine this will be extended, otherwise could simply put the enum in layout

row.prop(part, "type", expand=True)

or a window manager context toggle operator.

TIP.

In version 2.7x could reload scripts using the F8 key. It is  AFAIK not mapped to a key in default 2.8.

Either map it to a key, run in python console.

bpy.ops.script.reload()

Pre(ap)ending a simple operator button draw method to headers of both text editor and python console provides a couple of handy and often used buttons

For example when testing above, posted with ob.my_prop_group in the draw method after it had been renamed to ob.my_particle_settings.  As I hadn't reloaded scripts it was still registered from a previous test run, and worked as expected.

Running after reloading scripts will throw errors for such unregistered props.


Blender 2.82 Properties cannot be added and used within an operator?

Annotations are properties of the class instance

Bold question title, for what in the end is a python syntax error.

The error is because the property annotations of the operator need to be referenced from the instance (self)

subdivide.show_viewport = self.sub_visible

Without, the script is looking for a local variable sub_visible that is not defined. Error message in question

Recommend looking at the templates that come with blender Text Editor > Templates > Python and reading the documentation.

A clean up...  spot the difference between this and question code.  I use the nvim editor.  It does a lot of clean up for me, or flags unused imports etc.

If imported, use the imported types and props.
Use the recommended naming convention for operator and panel types.  See Docs.
When context is passed, use it. Don't get into the habit of bpy.
everything.

Added min and max for subdivision property value. 0 and below will produce an error, trying to set to 12 could produce a meltdown.

A poll method as it requires an object and object mode and a mesh  context.object.type == 'MESH'

import bpy
from bpy.types import (
    Operator,
    Panel,
)
from bpy.props import (
    BoolProperty,
    IntProperty,
)

class OBJECT_OT_subdivide(Operator):
    """Subdivide"""
    bl_idname = "object.subdivide"
    bl_label = "Subdivide"
    bl_options = {'REGISTER', 'UNDO'}

    sub_visible: BoolProperty()
    sub_levels: IntProperty(
        min=1,
        soft_max=6)

    @classmethod
    def poll(self, context):
        ob = context.object
        return ob and ob.mode == 'OBJECT' and ob.type == 'MESH'

    def invoke(self, context, event):
        return context.window_manager.invoke_props_dialog(self)

    def execute(self, context):
        subdivide = context.object.modifiers.new(
            type='SUBSURF',
            name="Qsubd_subdv")
        subdivide.show_viewport = self.sub_visible
        subdivide.levels = self.sub_levels
        bpy.ops.object.modifier_apply(
            apply_as='DATA',
            modifier=subdivide.name)

        return {'FINISHED'}

class OBJECT_PT_subdivide(Panel):
    bl_label = "Layout Demo"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'UI'

    def draw(self, context):
        layout = self.layout
        layout.operator("object.subdivide")

classes = (OBJECT_PT_subdivide,
           OBJECT_OT_subdivide,
           )

def register():
    for cls in classes:
        bpy.utils.register_class(cls)

def unregister():
    for cls in reversed(classes):
        bpy.utils.unregister_class(cls)

if __name__ == "__main__":
    register()


You've probably solved the problem by now but I just ran into this problem and found an easy solution: increase the Render Samples to 30.

I had the same problem when Cycles only computed 1 sample. At 2 samples, it was much better and so on.

I hope that helps someone.


Your DXF file is using 1 unit == 1 inch, so the marked length is $11\cdot 12 + 11.2780 = 143.278"$ long. Blender's internal unit is 1 meter long, so the DXF imports as 143.278 meters, and $ \frac{143.278}{0.3048} \approx 470'$ which is what's being displayed.
You could fix this by entering 0.0254 in the "Unit Scale Box." That will give you correct readings, but will still be insanely huge.
You could fix this by scaling the DXF by 0.0254 manually after you import it, or you could enter 0.0254 in the unit scale box of the DXF importer


Actually I figured it out, lol. But just in case someone had the same problem I had... To get the checkbox to become un-grayed (Or make it usable, lol) You must be in "Camera View". Otherwise it will remain gray. I hope this helps someone not experienced enough in Blender. Happy Creating :)


Follow objects as if there was a magnetic field using animation Nodes

Method 1 (Recommended)
You can evaluate Fcurves to get trailing or attractive effect. You need a source object with location keyframes. Then follow node tree given below.

Method 2
We can also do this without keyframed source object by storing positions of object.

For storing object transformation as Matrixlist:
setattr(AN, "store", Matrix4x4List()) if frame == 1 else AN.store.append(x)
Get stored Matrixlist:
AN.store[-amount:]


How can I select multiple parents and their children?

You can select all the parents that you wanna move and then go to Select > Select More / Less > Extend to children. Or Shift + ]Shift+]:

Hope that helps.


Any way to keep the kind of ilumination on preview for rendering?

What you want are Render Layers. A render layer is basically what layers are rendered to separate images, composited later in the compositor after the actual render takes place. It is possible to do this fairly easily actually.

First, make sure they are on different layers (I think you said they already are). Then go to Properties > Render Layers and set up the default Render Layer to only show your background object layer:

The Layer section is to show what layers to render, and the Exclude section is for what sections to exclude from the render (shadows, reflections, lamps, etc.). It is important you get these right.

Once you have that set up, you can add a Render Layer for the foreground object. Press the + beside the Render Layers display window, and name as desired:

Now set up the new layer using the same principles as the first, isolating the foreground element. You should get two images when you press F12 now:

Now we need to go into the Compositor to put the two images together.

Start by adding another Render Layer input:

Now set up your nodes like this:

You can see that now it is combining the two different rendered images based on the Alpha value of the second. One more iportant thing you need to do: Make sure that there is an Alpha value to use. Go to Properties > Render > Film and tick the Transparent checkbox:


Smoke and fire not showing up in my eevee render

I had the same issue until I realized that I typed in 'Density' instead of 'density' in the attribute node.

This should work:


How to make 2D stabilization in Movie Clip Editor only follow active tracks?

You can continue to track past an obstruction in the frame, or track a new feature by using the Offset value of the active Marker. Go to the Properties panel and look for Marker > Offset:  simply change these values to position the Marker boundary over the new feature and continue to track.


Not with keyframes or drivers

The overlay is a member of the 3d view space. bpy.types.SpaceView3D  Each property in blender has an is_animatable property, declaring if it can be animated.  Visually if you right click and there is no add driver or insert keyframes

Step thru this in the python console where C = bpy.context

Find which area is the 3d view

>>> for i, a in enumerate(C.screen.areas):
...     i, a.type
...
(0, 'PROPERTIES')
(1, 'CONSOLE')
(2, 'VIEW_3D')
(3, 'TEXT_EDITOR')

>>> a = C.screen.areas[2]

Its 3d view space will be the active one

>>> s = a.spaces.active

And here is the overlay wireframe threshold

>>> s.overlay.wireframe_threshold
0.0

Let's see if the property def says it is animatable.

>>> p = s.overlay.bl_rna.properties['wireframe_threshold']
>>> p.is_animatable
False

Confirmed ... Nope.

There are some dodgy ways this could be achieved, but will wait for further details on animation required to elaborate.


Link to How-To: Editing footage from multiple video cameras?

That description in the manual covers most points.
Align your clips so they all match the clapper board marking.
Add a Multi cam strip above them.
Split the preview into 4 previews by dragging from the corner of the editor area.
In the preview sidebar set the Channel number to match channels 0-3. 0 will show the final edit.
If your computer is fast enough to run everything in accurate fps, all is fine.
If not, select all video strips.
In the preview - view menu - go to proxies.
Select Set up.
Check 25%
Check Overwrite.
Select rebuild.
Select - Scene render size - Proxy 25% And repeat for all previews.
Now it should play at a constant frame rate.
Select the Multicam strip.
In the Sequencer sidebar, you can see the options.
The channel selector you can change the channel of the active/selected strip(white outline).
If you click on the number buttons underneath, you'll make a split in the multicam strip, and switch to the channel number you pressed.
If you set the playhead to the beginning, having the multicam strip selected, and you hit play, you can also do "live" switching by using the number keys ex. 1 is switch to channel 1.
I did a patch to improve the multicam user experience, but it has not been committed: https://developer.blender.org/D10521


Use weight paint mode in order to fix the geometry effected by the bones.

Select the mesh and you can change to weight paint mode by pressing CTRL + TAB.

Use CTRL + Right Click to select bones. You will see colors ranging from Red (a weight of 1) to Blue (a weight of 0). A weight of 1 means the geometry moves with the bone and a weight of 0 means the geometry is not affected by the bone. You can use the subtract brush to remove weight from geometry you do not want the bone to affect.

You can learn more about weight paint mode here: http://blender-manual-i18n.readthedocs.io/ja/latest/modeling/meshes/vertex_groups/weight_paint.html


What is a good way to turn straight edges to curves?

USING PROPORTIONAL EDITING

Add some edge loops (Ctrl+R) in the middle of the object to devide the object evenly. Select the face loop in the middle (Alt+RMB) and snap the cursor to it (Shift+S-->Cursor to Selected). Enable proportional editing, then press S,Shift+Z to scale along X and Y axes only.

USING SIMPLE DEFORM MODIFIER (STRETCH)

Give the object a Simple Deform modifier, change its mode to Stretch and adjust the deform factor as you like.

USING LATTICE MODIFIER

Add a Lattice, scale it to fit the object's size and subdivide it a few times. Select the object and give it a Lattice Modifier. Select the points around the middle subdivision of the lattice, then scale them with S.
NOTE: Adding more subdivision to the lattice allows you to better control the shape of the object (you can make it more uneven/realistic).


You probably have wrong Rigid body Collision shape, try changing it to mesh:


Check if object is being drawn in the scene

It's hard to know if this can be a solution for you or not, but here's what I would try:

Use either Object Index or Material Index to create a pass that will be like a mask of the object's outline.

So for example, in Cycles if you create a material with a Pass Index of 1 (as is on this cube)...

Then you could set up your nodes to get a mask from that like so:

Note that since the monkey object in front of the cube does not have a Material Index of 1, it occludes the cube.

You can set this up using the File Output node so that this gets output separately from the main render as its own file:

Then you can use an external script (in Python perhaps) to batch scan your frames and return TRUE when white pixels are found, or FALSE when the frame is all black.

This is a very specific use case, so expect to have to do custom scripting.


Blender is automatically selecting multiple vertices while not holding down shift, help?

At the top of the window you should see the select tool 'Mode' this indicates whether it should Replace, Extend, Subtract, Invert or Intersect the selection - presumably you have somehow changed the mode to Extend (add to the existing selection).

Note that as well as the selection tool in the tool shelf you can alternatively press B for a box select. This does not use the same selection mode and instead defaults to 'Extend' the selection - unless you hold Shift to indicate Subtract.


Material of mesh doesn't match the render because of subdivision surface

The subsurf modifier is designed to interpolate geometry in between existing vertices. The materials (and their borders) are interpolated as well.

You have a couple of options:

Select an edge loop and add a crease with a value of 1 (you can access the edge crease tool with Crl+E):

Or add a loop cut (Ctrl+R) and move it closer to the existing loops.


materials on cylinder have changed from workspace to render

Fixed it! I hadn't realised I needed to click on assign twice as I had only done it once and wasn't sure why it hadn't worked.

So it did end up being something simple that I'd missed


Rendering Glass (layers) resulting in strange dark patches (in Final but not Preview)

It looks like you have an object hidden in the viewport that is showing up in the render.

Look for a setting in the outliner similar to this and either hide that object in the render or delete it:

Alternatively, you can press Alt+H, and you should see all hidden objects in the viewport. Then you can select and delete/disable anything you need to.

This script will automatically hide all objects in the render that are hidden in the viewport:

import bpy

for obj in bpy.context.scene.objects:
    if obj.hide and not obj.hide_render:
        obj.hide_render = True

Putting this here for reference...

Why does my object not show up?


Where's Offset Edge Slide in Blender 2.80 menus?

You can find the Offset Edge Loop Cut/Slide in the toolbar. You need to press and hold your left mouse button on the Loop Cut icon and then select the Offset Edge Loop Cut from the menu. The naming is a bit inconsistent, the menu entry says Cut and the description, documentation and last operation panel call it Slide.


Multiple Blender processes for multiple GPUs?

It turns out all I needed was to update the NVIDIA driver to v346.72 for the ASUS GTX 970 Strix cards to be able to handle multiple processes in tandem.

Update - Oct 2019

To those wondering if there was a performance gain in doing this: yes, there was.

I don't have the specifics with me as this was done a few years back, but I do remember the render times breaking down like this simplified example:

1 GPU renders 1 frame of an animation in 4 minutes, so in theory bulking up to 4 GPUs should render that one frame in 1 minute. This wasn't what I was seeing in reality though. The actual result took more like 1.2 minutes per frame.

So for a 200 frame animation, the math broke down like this:

All 4 GPUs working as one:

(200 frames / 1 Combined GPU) = 200 frames * 1.2 minutes per frame = 240 mins total

Splitting up the GPUs to independently work on a queue of frames:

(200 frames / 4 GPUs) = 50 frames per GPU * 4 minutes per frame in parallel = 200 mins total