Here is something you can try:

Select one object and add the decimate modifier. Do not apply it.
Select all objects EXCEPT for the one with the modifier.
Shift-select the modified object. It will now be the active object
    (bright yellow-orange outline).
Press Ctrl+L and choose "Modifiers" from the Make Links menu.

This should apply the modifier across all objects and keep the modifier editable.

Alternatively, you could apply the modifier in the first step and in the fourth step select "Object Data". Keep in mind this links the objects so certain changes made to the active object will take effect across all the others. Scaling and other transforms done in Object Mode should not affect the others.

If you need to unlink object data the method in 2.8 is select one object in Object Mode and in the Object menu (top left of the viewport) select Object> Relations> Make Single User> Object & Data (or whatever serves your purpose) and select All.

In 2.79 and earlier select an object, hit U, and choose Object & Data or whatever.


How do I view Annotations (i.e. pencil strokes) in the Sculpting Workspace?

Open the Viewport Overlays options and enable Annotations. This will allow you to view the pencil strokes in the Sculpting workspace, where this option is disabled by default.


How to fill holes in Mesh from Curve from SVG

You will have to fix the topology of this. This is quite a mess.

A good clean mesh based of quads is easier to fill. To close holes you can select the edges around the hole and press F

I have created this very basic key, by extruding faces from a plane using E with edges selected in top view. You can use the SVG as reference if you want it to match the lines of the model. I then selected all faces in face select mode by double tabbing A and extruded the model up along the Z axis by pressing E.

Then I selected the edges around the model and bevelled them using CTRL+B


Are your GPUs in SLI or similar pairing technology, or somehow presented at OS level as a single GPU?

If so that will negatively affect performance in Blender, because those systems are generally inefficient and will not fully utilize the power of both GPUs entirely.

Blender however if presented with two discrete graphics cards for rendering in Cycles can make full use of both at full speed without performance compromises, virtually doubling the speed and halving render time.

Having only one bucket while rendering is generally a sign that only one GPU is being detected by Cycles.

If possible tweak your settings in such way that Blender can see both your graphics cards as independent hardware.


How to use Separate Text Object inside a "Subprogram"?

The Separate Text Object node actually outputs a list of each individual letter of the input text object. If you want to loop into each letter you have to use the output of the separate node as input in you loop node.

From there you can do any modifs to the letter you want. What you where trying to do could be implemented like this, and there is no need to nest loops.

If you get confused by the Object Id Key node: Object Initial Transforms, try to think about what would happen if was a single vector. All the letters would animate to the same position (as long as they have an individual origin).
The Object Initial Transforms takes the inital position of each letter and outputs the vector, so you can properly animate the text.

If you want to animate individual letters of mutliple text objects, there is no solution yet apart from making two different loops of the separate node. You can implement the group functionnality which is very useful when you have to repeat a process like there.

Maybe an input for the seperate individual letters will be implemented in future realeses.
Note that Jacques Luke now include a very nice Animate individual Letter template, which is basically the same node setup than the first image, but animating matrices.


How to make a fluid simulation start from the middle of an animation and make the domain not visible until that point?

in the domain, change the frames from 0 to 250 (or however your flow simulation lasts)
do not keyframe inflow type (delete those keyframes)
do keyframe use flow (74 - off, 75 - on)

4) free bake and bake all
-> works
visibility:
the domain itself normally is not visible, but the effector might be visible.
you can keyframe the visibility of objects here:


Blender function to transform a selected edge along a custom axis

I think http://web.purplefrog.com/~thoth/blender/python-cookbook/extrude-edge-along-custom-axis.html will accomplish your mission.  Here's a copy in-line:

import bpy
import bmesh

def guess_edge_order(bm, edge):
    """ We need to create a new face,
    but if that face is going to have a normal consistent with an adjacent face
    we need to choose the order of the vertices carefully.
    """
    v0 = edge.verts[0]
    v1 = edge.verts[1]
    if len(edge.link_faces) != 1:
        # it is going to be non-manifold.  balls!
        return v0, v1

    face = edge.link_faces[0]
    nverts = len(face.verts)

    i0 = [ i for i in range(nverts) if face.verts[i].index == v0.index]
    i0 = i0[0]
    #print(["indices", i0, face.verts[i0], face.verts[i1], i1])
    i1 = (i0 + 1)% nverts
    #print(["next", face.verts[i1] , "==", v1])

    # does the polarity of this edge match the order of the vertices on the face?
    if (face.verts[i1].index != v1.index):
        return v0, v1
    else:
        return v1,v0

def mission1(obj, axis, len):

    bm = bmesh.from_edit_mesh(obj.data)

    # collect a set of all the vertices from all selected edges (without duplicates)
    verts = set()
    for edge in bm.edges:
        if edge.select:
            verts.add(edge.verts[0])
            verts.add(edge.verts[1])
    print(verts)

    # create new vertices "extruded" from the vertices of all the selected edges and
    # stash them in a hash so we can map from the old vertex to its extruded partner
    newverts = {}
    for v in verts:
        v2 = bm.verts.new( v.co + axis*len)
        newverts[v.index] = v2

    # for each selected edge create a new face from the original edge plus the extruded vertices
    for edge in bm.edges:
        if edge.select:
            v0,v1 = guess_edge_order(bm, edge)
            v2 = newverts[v1.index]
            v3 = newverts[v0.index]
            bm.faces.new( [v0, v1, v2, v3] )

    # if we don't do this, it will look silly in the editor, and maybe even cause problems during render
    bm.normal_update()

    # apply all the changes we made back to to the target mesh data
    bmesh.update_edit_mesh(obj.data, destructive=True)

#
#
#

obj = bpy.context.active_object
scn = bpy.context.scene
# which custom orientation are we using?
orientation = scn.orientations['Face']

x_axis=0
y_axis=1
z_axis=2
m1 = obj.matrix_world.to_3x3().inverted() # this is what we need to map from world space to object space
m2 = orientation.matrix.transposed() # we transpose this so we can extract a column
global_axis = m2.row[z_axis] # this is the custom orientation axis we want in global space
axis = m1* global_axis # now we have the necessary extrusion vector in the object's local coordinate space

if True:
    print (m1*m2.row[x_axis])
    print (m1*m2.row[y_axis])
    print (axis)

mission1(obj, axis, 1.5)


Soft Body Object-Collision Object Interaction Not Working

You need to add the Collision physics to the object that yhe soft body should be colliding with, not to the soft body itself. Also, check your normals to ensure they’re pointing ‘outwards’ (otherwise the collision won’t work).

Another issue can be where the Soft Body/Cloth collision ‘Inner’ setting (on the non-soft body mesh) is set too large - it ahould never exceed half the thickness of the mesh or it can have undesired consequences (drawing the soft body through from the ppposite side).

Also, fast moving collisions can potentially get through the surface before they are detected. To address this, increase the Min steps (and Max if you need to increase Min even higher) in the Soft Body Solver settings.

After reviewing the Blend file I noticed that the collision object and the soft body are actually on different layers. For the collision to be active (in fact, for any physics effects) the meshes must share the same layer. To move objects to a different layer you should select them, hit M and click on the desired 'target' layer on the popup panel, holding Shift to select multiple layers if desired. Note that moving layers doesn't necessarily invalidate the soft body cache but this can be triggered by simply selecting the Soft Body object and going into and out of Edit mode (TabTab).


Mac Pro Tower - Sapphire Radeon Rx580 is really, really slow

Unfortunately Apple has deprecated OpenCL and OpenGL in favor of their own Metal API. In fact, Blender has recently dropped OpenCL support on macOS completely, due to too many bugs in the macOS OpenCL compiler.

Long story short, due to apple's rejection of widely used open APIs, it's unlikely there will be any support for OpenCL rendering on macOS in the immediate foreseeable  future. Perhaps someday it will be supported via vulkan, but in the meantime it looks like you're out of luck/stuck on old versions of blender.

If you don't want to shell out the $$$ to dual-boot Windows, you might try running Linux. Historically, Linux has outperformed Windows when it comes to CPU rendering (it usually matters less for GPU rendering, but it's often a little faster there too). That said, I was unable to find any up-to-date benchmarks comparing the two, so take this with a grain of salt.


Ovelayed images show transparent in compositor


How can i download/install the Motion Trail-addon (svn-download)?

While blender has moved it's revision control to git nearly two years ago, you can still find links to the old svn repository, even on blender's own wiki.

While blender's source code is split into four repositories and there are a few other repositories for related projects the one that most users would be interested in is the Add-ons Contrib which can now be found here, where you can also find the git command to download the entire repo. The contrib repo is a collection of semi-official addons that haven't been accepted into the official releases of blender. The old links that you find starting with projects.blender.org or svn.blender.org that have /contrib/ in the path can now be found at developer.blender.org/diffusion/BAC

Now specifically for the addon you mention, the multiple links on the page are different versions of the same addon submitted during it's review process, the addon is contained in one file, the issue you have may be from different versions conflicting or an older version loading first and preventing the new one loading. Remove the older files so that only one new version is installed.

Near the top of an addon script you will find bl_info = { followed by a list of values, the one you are interested in is "version" -

bl_info = {
    ...
    "version": (3, 1, 2),
    ...

only keep the one with the highest version.


How to parent an object to another one but inherit the rotation from a third object?

So the bolt needs to follow the upper leg, but to rotate when the lower leg rotates.

The copy rotation you used is good. But you need to involve an additional bone to obtain the result :

Here is the setting :

Add/extrude a new bone from the upper leg
Set it disconnected
Place its head at the center of the bolt
Align it with the lower leg bone and make sure that bolt bone and lower leg bone have the same roll (so that these two bones have the same local directions)
Assign the bolt vertices to this new/knee bolt's bone group of the mesh

Now (as you did), in pose mode, add a constraint to the knee bone like this :


I figured it's because appended/new actions are added under the current selected item, which can be a mesh or an armature.


I found a solution. Apparently, you can use a holdout node in the shader editor to get this desired effect.
Create a new material or use an existing material and assign it to whatever object you want to hide and hide whatever is behind it. Go to the Shader Editor and add a holdout node and assign it to surface, you can create the holdout node by going Add >Search and then search for Holdout.

Once all of that is done, you won't notice anything in the editor after the changes and it should look the same as seen below.

You'll need to render to see it take effect so press F12. Here's the result below, I think you can set the holdout to display a specific color it seems by default its just transparent (which is what I want) when you have the node selected in the Shader Editor just edit the color and experiment around with it.
If you want everything transparent you'll have to change the World settings from the default grey as seen below to transparent.


Child object does not render - even after setting duplication to none

The location of the armature by design affects the child mesh.  For ease of experience .. have your mesh and armature at the grid center at the time of parenting.  Delete [ALL] previous armature modifiers.  They can collect like dust during experimentation.  Inspect carefully your modifiers panel.
Verify your object is visible in Camera View.  Press [Numpad 0] multiple times to alternate this view.  Objects can be viewed in (Non Camera View) .... yet be off camera in (Camera View) which can cause confusion the first few times.
Move your object to the center of grid and point the camera to center. Align Active Camera to View.  Control Alt Numpad Zero.
Place other simple objects near the failed object to make sure your camera has a good view of the entire scene, distance shot ... then refine later.


The seams on the mesh are the reason for several pixels of the background color of the image to be seen. Paint on the image in UV / Image Editor and the problem will be solved.

This happens in the places where seams for unwrap are assigned.

When edge is marked as seam, the latter will cut mesh trying to unfold it on the 2D surface of UV map. This means that in the place of seam two parts of mesh "meet each other", i.e. when you paint over seam, part of your painting happens on one part of UV map, and another part - on another one.

So the reason for the painting being partially "transparent" are these "steps of pixels" on UV map:

Another part of UV map with adjacent face meeting isn't shown here
In your case background color of image is black, so that's the color which is being visible on mesh like artifacts.

It's possible to avoid this using workarounds:

while texture painting, paint from several directions, rotating viewpoint from different angles. This will decrease visibility of problem (small parts may remain but this isn't important if camera isn't placed just near the mesh).
add some painting in UV / Image Editor in the places where seams are assigned. By adding extra width of painting the problem will dissappear.


To convert any Mesh object to 3D Grease Pencil object we need Animation Nodes with Extra Nodes(Builds available for Linux, Windows),

(1) First we have to get all the individual polygon (face) vertices using Mesh Object Node and Separate Polygons Node. Separate Polygons Node is needed because all
polygons are joined i.e., they are sharing some vertices,

(2) then convert a polygon vertices to a close (cyclic) grease pencil stroke with fill using GPencil Stroke Output Node.

(3) Because a mesh has many polygons (faces) so we are going to use the Loop Group Node (Loop Input) to convert all polygons to fill grease pencil strokes (cyclic).

(4) Now we have all strokes as output from the Loop Node, with GPencil Object Output Node we can convert them to a grease pencil object.

Happy Noding :)


How to select all identically faces on object

Make sure that you are in Face mode, select the face and press ShiftG > Area (or header menu > Select > Select Similar > Area).

You can tweak the threshold in the Operator box:


Let say you have a part that is completely messed up, Select it and delete:

Select the borders and press CtrlF > Grid Fill:

Play with the parameters in the Operator box (on the bottom left of your 3D view) to fill properly (here: Span 3, Offset -2):


You used to be able to render vertices as halos. That only worked with the old Blender Internal renderer which was completely scrapped. I miss the halos.
Anyways, there is an alternative option called Point Density, I'm not going into this here, because it renders slowly and is not well suited for your situation.
I suggest you use icospheres, or stick to the cubes if they looked good enough.


How to mirror or flip duplicates in edit mode?

There is an easy way to do that. Set the 3D cursor in the middle between leggs (it would be probably a characters pivot point) then, set pivot point for transforms to 3D cursor and Shift+D to duplicate, then Enter or right click, then CTRL+M and choose axis on which you want to mirror the shoe by pressing X or Y. After that you should have mirrored shoe on the other side of the cursor.Like this:


vanishing displacement maps shortly after baking

You need to save all images (also created textures) to an image file F3 (Menu: Image / Save As Image) otherwise all changes are lost. Blender indicates an unsaved texture in the UV-Editor with an asterisk at the Image Menu Item.

Another option would be to pack the image into the .blend file.


Image as reference, proportional editing/sculpting, and tip thickness
As you have a reference image, I think the best way to start the modeling is blocking out of the shape right onto the reference image to ensure the similarity of the proportions.
Keep the topology tidy in this phase as long as possible. In my test file I started by extruding and scaling a circle on the Z-axis while keeping an image-type empty behind. Don't worry about the a-symmetry of the reference object, just focus on the overall proportions.
For the tip I went for a grid fill, followed by some smooth vertex operator iterations.

The shape has now some kind of radial symmetry that we would like to avoid. I took advantage of the proportional editing tool to grab the vertices around and various sculpt tools to smooth the shape (or to bump out some parts).

Add to the roof a hair particle system, set the right amount of particles, comb the hairs toward the bottom (in particle edit mode) and use weight paint to adjust the density and length.

Once satisfied with the distribution, start tweaking the parameters of the individual hairs. I went for a long stick type by setting the Tip section equal to the Root section. You can find more info about how to control the shape of the strand in the Blender Manual page:

Finish by setting the Children particles type to one of the proposed modes (in this case I went for Interpolated) to increase the amount of particles.
Play with other parameters till you reach the right look for your job. Here's a possible result:

Note: this is just a presentation of the workflow and the tools I would use for the job. Each one probably requires some time and further research in order to be mastered.


You can't. Unity has its own cloth simulation tools, but you can't import any simulation from Blender. This is true for smoke, cloth, soft body, rigid body, fluid, etc. In general, if it isn't a mesh or directly related to a mesh (e.g., UV maps), Unity will have nothing to do with it.


You'll probably want to try using this Blender exporter, exporting to glTF, and loading into three.js with GLTFLoader. Many other workflows have trouble handling multiple animations.


is there a shortcut for toggle between default screen layout and composit screen layout?

Yes, press Ctrl+Left Arrow to go to composite from Default, and Ctrl+Right Arrow to go back.


Creating a panoramic, shaped backdrop with UV project modifier

I found out how to use an equirectangular image as a projected texture for projection mapping type scenarios. Maybe it's helpful to someone else, so i'll share it here.

Render an equirectangular panorama of the scene. This needs cycles and the camera set to panoramic instead of perspective.
Save the rendered image.
go to the thing you want to project on, go to the Shading-Environment and create a new Material.
add an "Environment Texture" Node and drop your Equirec-Render into it. Plug that into your Principled BSDF, or, if you don't want shadows and stuff, an Emission Node.
add a "Texture Coordinate" Node and connect it's object socket with the "Environment Texture"-Nodes vector socket.
add an "Empty" and place it at the specific location that is supposed to be the center of your projection. (in my case the place where a visitor would stand to see the diorama)
In the texture coordinate node, choose the empty for the "Object" field.
Tweak the projection by moving or rotating the empty.
Slab the material on anything you want to project onto.

The Node Setup. The projektor2 object is the empty defining the source or center of the projection

the diorama. The selected empty is the texture coordinate input


Those white dots look to me like light fireflies. To fix this, use denoising. You can enable this in the second render collections tab in the properties panel.


How can I reuse texture within the same model?

In edit mode select all edges and mark them as seams, then select only one face, U to Unwrap, in UV editor place the UV in the right place of the texture.

Repeat for all others 31 faces.

This is for understanding the principle, then you can find all the available shortcuts!


One easy solution, though kind of "hacky", would be to append "v " (a lowercase v and a space) to the beginning of each line, and then importing it has a Wavefront .obj format.

So just do: print "v " + '%.2f %.2f %.2f %.2f'%(vec[0],vec[1],vec[2],vec[3])

In this example three vertices are defined, then they are automatically assigned an index from top to bottom;

v 0.00 1.00 0.00 0.00 #This is the index 1
v 0.10 0.99 0.10 0.10 #This is the index 2
v 0.20 0.98 0.20 0.20 #This is the index 3

Then, to define a "face" (a connection of 2 or more vertices) use:

f 1 2 3

Using this will define a face between the vertices of index 1, 2 and 3.

If, however, you want to only connect vertices with edges, you can use:

l 1 2

To define an edge between vertices  of index 1 and 2.

If you want a brief explanation, there's a Wikipedia page. For the complete specification, refer to this page.


The pie menu items are filled in a specific order - first the left item then the right, the bottom item then the top, then the top diagonals and the bottom diagonals are filled last. If the numbers used for each position seems odd for this layout compare them to your numeric keypad.

The primary design of the pie menus is to place one menu item at each location. As we have found this can be abused to show many items at each location.

While items are added in order to specific locations, we can effectively 'skip' an item by having a label with no text taking the position we want blank, it will need to be followed by a call to menu_pie() to make the next item to go to the next position otherwise it will be positioned with the label.

pie = pie.row()
pie.label('')
pie = layout.menu_pie()


Best Version for my iMac - Recommended Version for Mac OS X 10.5.8

Blender 2.79b is the last stable release before the user interface change happened in 2.8.
Try it. It looks very different and does not have eevee tho


How do you create a simple single vertex mesh with no actual faces whatsoever?

Create a cube or a plane or anything really, go into edit mode and select all with "a".  Then press "m" at center to merge all the vertices into one.
Alternatively enable the "mesh: extra objects" module in preferences and then you get an option to add a single vert.1
Specifically what this demo has done though is create a single vert as mentioned above, then duplicated it and moved the second one a little way off, then with both vertices selected they made an edge between them with "f".  Now you can hop into object mode and follow the rest of that little tutorial to make your cylinder.


In 3d View select 1 object of your desired type (Camera, Light, Mesh etc.)
Go to the Outliner and select Same Types from the dropdown menu

This will display all objects in your scene based on the current selection. E.g. When a camera is selected, the outliner will display all available cameras in your scene:


Workaround for offset of linked collection? (Blender 2.8)

TL;DR: Set offset for a corresponding source collection in properties>object>collections  to control where collection will be placed with respect to empty when collection is instanced

It is possible to provide the offset for a selected collections in source file. Offsets can be set for a source collection in Collections Panel of Object Tab of Properties editor

Properties > Object Properties > Collections

If location of collection in source file is 4 units in x axis, then set offset of x (in properties>Object> collections) 4 units. By setting offset we can control how far collection instance will be with respect to it's parent empty(also called Instancer).

Where new collection instances can be create by using add menu or by setting collection in instancer panel of empty object

Collection are the powerful feature introduced in blender 2.8. Blender supports linking nested collections as well. Instancing new collection is equivalent to adding new empty followed by choosing desired collection in instancing panel of object properties.

For collections in action and workflow check the following video from Blender Conference
Creating blender demos glowing tigers and tortured creatures - Daniel Bystedt


How can render overlapped object's edge freestyle line?

This isn't possible (as far as I know) using freestyle. However, it is possible to fake the effect in the Compositor by looking for sharp changes to the rendered Normal and/or Depth.
To achieve this, we need to compare each point in the render with a neighboring point and highlight those areas where the Normal or the Depth varies by a significant amount between those points. This can be acieved with a node group as follows :

Here we take the Depth and Normal as inputs and translate each by a specified X and Y (multiplied by the desired Thickness) - this allows the current pixel to be compared with a neighbouring pixel.
For the Normal, the RGB Subtract node compares them and the result is separated into its components and its overall magnitude calculated (as 'sqrt(r^2+g^2+b^2)'). If the result is greater than a Threshold we have found an edge.
Similarly, the Depth is subtracted from its neighbour and the Absolute result compared with a second Threshold. The two results are combined using the Maximum.
In order to avoid artifacts from features in particular directions, we can sample neighbouring pixels in different directions. This can be achieved with multiple node groups with different X and Y offsets - one above, one below, one to the left and one to the right (ie, (0,1), (0,-1), (-1,0), (1,0)) and the results combined as follows :

This can produce the following results (after tweaking the line thickness and thresholds) :


Textures disappear when the rendering engine is switched to cycles

Materials and textures work differently in cycles.

In BI, textures for the selected material are defined separately and most often in the properties editor.
In Cycles, textures are defined as part of the material itself and usually in the node editor (see Learning cycles material nodes).

Assuming a typical basic setup (one UV map, one texture, one material), then in cycles it should look something like this:

Make sure you are in the node editor
Make sure you are editing Material nodes
Add an image texture node (⇧ ShiftA> Textures > Image) and select your image.
The materials section of the properties editor will reflect what you do in the node editor. Editing the material in either the node editor or the properties editor will update the other.

If you have lots of materials you might try an automated conversion script, see How do I convert materials from Blender Internal to Cycles?


If you're talking about this shape, increase its V resolution:


To enter and exit a node group press Tab

(Think of it like entering/exiting Edit Mode for node groups)

Form the manual:

  With a group node selected, Tab expands the node to a window frame, and the individual nodes within it are shown. You can move them around, play with their individual controls, re-thread them internally, etc. just like you can if they were a normal part of your editor window. You will not be able, though, to thread them to a node outside the group; you have to use the external sockets on the side of the group node. To add or remove nodes from the group, you need to ungroup them.


Open the "Motion Tracking" layout.
Load your video

Track high contrast points (ctrl+LMB to create a tracking point, then press the track forward/backward buttons)

Change the layout to "Video Editing"
Drag in your tracked footage
Drag in your image file
Use the VSE_Transform_Tools addon to position and size your image over the face

Alt+S will rescale an image to it's original aspect ratio FYI

Use the "Transform from 2D Track" function (also part of the VSE_Transform_Tools addon) to pin the image to the face.


How to center object in global coordinate system?

Using the ideas of the proposed solution, this snippet does the offset calculation:

bpy.context.scene.update()

# determine minima of the object
min_x = min_y = min_z = 999999.0
for vertex in self.blender_object.data.vertices:
        # object vertices are in object space, translate to world space
        v_world = self.blender_object.matrix_world * Vector((vertex.co[0], vertex.co[1], vertex.co[2]))

        if v_world[0] < min_x:
            min_x = v_world[0]

        if v_world[1] < min_y:
            min_y = v_world[1]

        if v_world[2] < min_z:
            min_z = v_world[2]

# convert to world coordinates again
size = self.blender_object.matrix_world * self.blender_object.dimensions

offset = Vector((min_x +  size.x/2, min_y - size.y/2, min_z))

self.blender_object.location = self.blender_object.location - offset


what do the difference between using GPU or CPU for rendering?

Gpu's have many cores (yours may have 72 cores) but they run at lower speed (frequency) .Gpu cores can understand simpier instructions that a cpu core can understand.Cpu has much less cores than gpu cores but they run at higher frequency and they understand complex set of instructions.These are some key differences.


If I understand it correctly, you have one object where different parts have different materials. But some parts have the same material split up in different material slots.
To merge them all into one material slot, change to Edit Mode first deselect all faces. Then choose the first "wood panels" material slot and click on Select under the material list. Now select the next "wood panels" slot and hit Select again. This adds the faces assigned to this material to the first selection. Repeat until all wooden parts are selected.
Now choose the wooden material slot you wish to keep and hit Assign. Now all faces are assigned to this one material. Back in Object Mode you can select a slot you don't need anymore and hit the minus button to delete it.


Grease Pencil, drawing straight lines v 2.78

To draw straight lines select Draw>Line on the grease pencil section.

Otherwise press CtrlD and place the cursor on the starting point of the straight line, then release the Ctrl key while still holding the D key, and position the end point of the line and release the D key.


Try to pickle the custom property which saves the data. You can retrieve the dictionary from it with the .to_dict() method.

import bpy

print("-"*79)

class MyPropertyGroup(bpy.types.PropertyGroup):
    name = bpy.props.StringProperty()
    index = bpy.props.IntProperty()
    value = bpy.props.FloatProperty()

bpy.utils.register_class(MyPropertyGroup)
bpy.types.Object.test = \
    bpy.props.PointerProperty(type=MyPropertyGroup)

obj = bpy.context.object
#assign some data to test!
obj.test.name = "foo"
obj.test.index = 42
obj.test.value = 3.1416

#if you haven't assigned any data to the attributes of obj.test
#obj["test"] may not exist
#the expression statement
obj.test
#will create obj["test"] with default values then
dict_test = obj["test"].to_dict()

import pickle

bytes_test = pickle.dumps(dict_test)

del obj["test"]
#no data - returns default values
print(
    'del obj["test"]',
    "name: %s"%obj.test.name,
    "index: %d"%obj.test.index,
    "value: %f"%obj.test.value,
    "\n",
    sep="\n"
    )

dict_test = pickle.loads(bytes_test)
obj["test"] = dict_test
print(
    'obj["test"] = dict_test',
    "name: %s"%obj.test.name,
    "index: %d"%obj.test.index,
    "value: %f"%obj.test.value,
    sep="\n"
    )


You probably didn`t unwrapped whole mesh. go to edit mode select all faces and when unwrap.


Script: assign image texture to Image Texture node

The texture is not assigned because you are referring to it as a String instead of a data. Use the following code:

import bpy

# create blank image
bpy.ops.image.new(name="TestImg", width=1024, height=1024)

# get material reference
mat = bpy.context.view_layer.objects.active.active_material

# get texture reference
tex = bpy.data.images.get('TestImg')

# create node and assing the texture to it
image_node = mat.node_tree.nodes.new('ShaderNodeTexImage')
image_node.image = tex


There are two different rig-types available rigify and mhx you need to enable the corresponding addon in the User Preferences.

MakeHuman rig (mhx)

Rigify

The bones are organized in layers, with the addon enabled you get buttons to select them, in Pose Mode you can setup poses and keyframe them.

Same for rigify:

Related:

How should an animated character be moved while repeating a walk cycle?
What are the not so obvious features of Rigify?
how to do custom animation in a mhx file made using Makehuman


Is there a way to make a vertical grid show on final image rendered?

One way to "make one yourself" as @gandalf3 said above is this:

add a plane  subdivided as you "scale", and use a material as "grid" and "shadeless".

it will look like this (blender render)

here I used 2 planes, you may tweak the grid appearance...
is this something similar to what you need?

for "cycles render"
you can try a "wireframe" modifier, and a suited material, like

but probably, a freestyle setup would fit both cases... I'll add that later, or others will suggest howto here...

[edit] Yes freestyle would work with both cycles and internal render:

activate the master freestyle flag in the render option tab
set a freestyle linestyle in the render layers option tab, with the color/style you prefer, and enable as edge types only "edge mark" for it
mark all subdivided grid mesh edges as "freestyle edge"
set the material of the grid to be completely transparent (different in cycles and internal, anyway remove all reflection, specular, shinyness)

like this:

results in cycles and internal can be quite similar (for the grid):

and, finally, I tried and even the wireframe modifier works in cycles and internal, only a the grid material must be defined differently (eg: white shadeless for internal, white emission for cycles).

freestyle can give you much more choice of linestyle (eg: dotted, hand drawn, etc), but the setup is slightly more complex, and since is a post-render effect, it could interfere with some of the scene setup to render as you wish, depending on the scene.


Cycling between cameras through python script issue

You can access all objects of the current scene by using bpy.context.scene.collection.all_objects. Then you can filter the objects by their type like lemon suggested, list comprehension makes the code a little shorter. Once you have a list of the cameras you can iterate through them and activate one after another.

import bpy

obj_in_scene = bpy.context.scene.collection.all_objects
cameras = [obj for obj in obj_in_scene if obj.type == 'CAMERA']

for cam in cameras:
    bpy.context.scene.camera = cam
    # Do something else here while this object is the current camera
    print(bpy.context.scene.camera.name)


Now I have found a way to export the bezier curves in world coordinates. To do so I name all my bezier curves "BezierCurve01", "BezierCurve02",...,"BezierCurve18" and so on. I also have to make sure that the curves are in exactly this order in the table bpy.data.curves. This is achieved by simply renaming every curve. Then I can run the following script to get the desired output:

import bpy
import os

currPath = os.path.splitext(bpy.data.filepath)[0]+".txt"
file = open(currPath, "w")
i = 1

for curves in bpy.data.curves:
    idx = str(i)
    if i < 10:
      bezier = "BezierCurve0"+idx
    else:
      bezier = "BezierCurve"+idx
    ob = bpy.data.objects.get(bezier, None)
    for splines in curves.splines:
        for x in range(len(splines.bezier_points)):
            file.write("p ")
            handle_left = ob.matrix_world * splines.bezier_points[x].handle_left
            handle_left *= 11
            co = ob.matrix_world * splines.bezier_points[x].co
            co *= 11
            handle_right = ob.matrix_world * splines.bezier_points[x].handle_right
            handle_right *= 11
            file.write("%.3f " % (handle_left.y))
            file.write("%.3f " % (-handle_left.x))
            file.write("%.3f " % (handle_left.z))
            file.write("%.3f " % (co.y))
            file.write("%.3f " % (-co.x))
            file.write("%.3f " % (co.z))
            file.write("%.3f " % (handle_right.y))
            file.write("%.3f " % (-handle_right.x))
            file.write("%.3f " % (handle_right.z))
            file.write("\n")
    file.write("n\n")
    i = i + 1

file.close()

This only works for 20 curves and has to be adjusted properly for more.


First of all go to Edit Mode, select all and W > Remove Double, than select this edge and Ctrl+E > Clear Sharp.


How to completely evenly light a 3D molecule model

you can try mixing a BSDF shader with an emission node applied to the molecule: the emission shader will give some extra lights to the model (if you add too much emission the object will be flat with no shadow, so play with the right value of the strength of the emission)


I speculate that the problem lays in a slight missunderstanding of the concepts of object/edit mode and modifiers. For better understanding maby you should update your question and add some visualization what you want to accomplish exactly and what is not working as expected. Then if you put a comment under this answer i could take another look at it and edit my answer accordingly.
the only way to realy edit the array itself in object mode is via the thwo separate array modifiers. Relative offset values or object offset can produce diffrent results. Transformations will apply to the whole object+array-setup.
the other way would be to edit your base mesh in edit mode. This edit will get passed down first to the one array modifier and then also this result will get passed down as a whole to the next array modifier. Individual edits are not possible, as for they are not what array modifier is intended.
There are other ways of working with seriality and transformation offsets in it, so it would really help knowig what you want to suggest other solutions. :)


Python path for allowing animation of viewport and render visibility of objects

Keyframe Insert / Delete.
Further to the answer of @scurest

Mouse over the property after setting to refresh the panel
Every object in blender has a keyframe_insert and keyframe_delete method.   It does everything required, eg if the object has no animation data or action it adds them, then adds the keyframe.
Set the value, insert the keyframe. eg hide the object at frame 10
>>> C.object.hide_viewport = True
>>> C.object.keyframe_insert('hide_viewport', frame=10)
True

Can pass the frame, or it defaults to the current frame of the scene.


The first two questions are related I will focus on them.
The stretching you face only appears with inverse kinematics (IK) when you move the control bone in a impossible position, this is used for cartonic exaggeration.

You can disable this by setting the Auto Stretch IK slider to 0.

The elbow has an IK-target which can be controlled as knees with a ball shaped control.


How to remove animation from duplicated object?

That's because you didn't duplicate the object (which is done by pressing Shift + D), you instanced it (done by pressing Alt + D).

The difference is that, when using the second method, all of the object's properties get linked to another's, so, editting one will result in all being modified.

To unlink a object, you use Make Single User, by pressing U, in Object Mode, which will give you a list of possible data to unlink. As you seem to only want independent animations, then choose Object Animation on the list that shows up


Only Emission shader is reflecting off glass, objects with Diffuse show up as black

Probable Cause:

Your ground plane has Incorrect ray visibility settings In order to check if this is the issue, select your ground plane and diffuse objects. and make sure all the settings look like this:

If they don't, change them.

Also note that a Light path node could be the culprit as well.


How can I see the center of rotation of the 3D view?

There may be another way but once you move the view if you press CTRL+ALT+Numpad 0 that will center a camera to the current view. The cameras position should now be the center of the rotation as well and you can get that info in the Item tab.


Modeling a twisty tree: How do I twist a beveled curve?

You're actually super close to getting what you want. The default circle shape of bevels just makes it really hard to see. The reason for this is because you're trying to twist a smooth, cylindrical object. Twisting a smooth cylinder results in another smooth cylinder, up until the point where you twist more than the geometry allows, which is what you see in the last gif.

I tried a similar setup but with an irregular shape and it works really well.

Here's my setup:

As you can see I used less handles, but that doesn't really matter.

I also animated the twist of each handle as I found it gave a nicer result. To find how much you need to twist each handle, think about how many twists you want overall, then divide that by the number of handles. 360 degrees per handle for 8 handles will give you a really twisted tree. The one in your image has more like 3 twists in the full length. In my case I did just over 2 full twists, so each handle was twisted 540 degrees more than the previous one. For your tree, try 90-120 degrees per handle and go from there.

When/if you animate these values, just be aware that because of the magnitude of the values, they will be off screen at first.

Mine looked like this:

The final animation looks like this. The animations could be better, but the idea is there.


Is it possible to export a multiplayer game from BGE?

Short answer:  No, at least not without a lot of effort.

Long answer:

The engine has no baked-in network multiplayer.  You have to set up the whole thing yourself with Python scripting.  It's all quite complex.

As far as I know this is the most in-depth explanation of the subject:
http://youtu.be/4xZRfzOtxzA

^ Should you decide to build that into a full game, be sure to swap pickle for something like json.  Using pickle on untrusted data is a nightmarish fiery hell of insecurity.

If you're familiar with Python and compiling, check out the Python bindings for ENet:
https://github.com/aresch/pyenet

At one point someone was working on an addon to ease the burden for common folk, but last I checked it wasn't matured enough for actual use.  The project might be dead as well:
http://blenderartists.org/forum/showthread.php?242740-Blender-Game-Engine-Multiplayer-Add-on


Get the idname like:

bpy.ops.render.render.idname()
# 'RENDER_OT_render'

(or simply take render.render and replace the . by _OT_)

Search that operator in the source code, and find it here:

blender\source\blender\editors\render\render_internal.c

/* contextual render, using current scene, view3d? */
void RENDER_OT_render(wmOperatorType *ot)
{
    PropertyRNA *prop;

    /* identifiers */
    ot->name = "Render";
    ot->description = "Render active scene";
    ot->idname = "RENDER_OT_render";

    /* api callbacks */
    ot->invoke = screen_render_invoke;
    ot->modal = screen_render_modal;
    ot->cancel = screen_render_cancel;
    ot->exec = screen_render_exec;

You'll likely wanna look for the exec function code (screen_render_exec) and see what it does.


Rigid and soft body collision - no interaction

It seems to be a bug of 2.8: https://developer.blender.org/T60079
You need to switch back to 2.79 if you want to feature
You can fake the gravity simulation and do as explained here:

the net should be cloth
the ball should be set as collision


I dont know if this is the correct method but this one
works for me turn the world and viewport to white


Blender 2.8 How to rotate viewport 90 deg after Shift +7

You can use the navigation options under View > Navigation and their corresponding hotkeys to pan, orbit and rotate the view in 15 degree increments.

If I understand your description correctly, what you are looking for is numpad 4 and 6 to orbit.


Blender 2.49b crashes when right-clicking to select an object

Runnig such an old version of Blender on a modern version of windows can lead to incompatibilities such as you are experiencing - the old versions were obviously developed way before Windows 10 was even imagined and there are all kinds of reasons why newer Windows could expose a bug that’s been dormant and undiscovered in the old Blender code.

Probably the best way forward is to run against an older version of the operating system that doesn’t experience the problem. If you don’t have the physical hardware to run such a system you can run it as a ‘virtual’ computer using VM tools such as VirtualBox. I’ve had great success running older versions of Blender on VirtualBox running Linux (which is free to install if you can’t get Windows XP) - so I currently have a Windows 10 laptop running Blender 2.79.6 and Blender 2.8 and use a Linux VM (in VirtualBox) to run earlier versions.


Python: Get the "stop" value of an UI element that's currently used

There is no sophisticated event system that would let you distinguish between onChange and afterChange events. Changes to properties will immediately be evaluated. It allows for instant feedback, which is usually desired.

However, it's a nightmare in terms of user experience if the triggered operation takes very long. It will block Blender until completion, then start the next eval cycle if you keep dragging, resulting in a very unresponsive application.

In such a situation, in which you do not want immediate evaluation, use a props dialog (as opposed to a props popup, which comes with instant eval):

import bpy

class SimpleOperator(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.simple_operator"
    bl_label = "Simple Object Operator"

    myProp = bpy.props.FloatProperty(
        name="My Property",
        min=0,
        max=10,
        default=5,
        subtype='FACTOR'
    )

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

    def execute(self, context):
        self.report({'ERROR'}, "myProp = {}".format(self.myProp))
        return {'FINISHED'}

def register():
    bpy.utils.register_class(SimpleOperator)

def unregister():
    bpy.utils.unregister_class(SimpleOperator)

if __name__ == "__main__":
    register()

    # test call
    bpy.ops.object.simple_operator('INVOKE_DEFAULT')

Note that it needs to be invoked to show the dialog. If you call the operator from Python console for instance, then it will be executed and not show a dialog.

Operators added to the interface are invoked by default:

bpy.types.RENDER_PT_render.append(
    lambda self, context: self.layout.operator("object.simple_operator")
)

Another approach is to have an additional property (e.g. on the WindowManager type) and add that to a panel. Then let the user adjust the value and click a button to assign the value to the actual property. A callback on the actual property will only be called when the property is assigned by the operator (or manually by the user in the Python console for instance), but not as the property in the panel is dragged - because that's a different property:

import bpy

class HelloWorldPanel(bpy.types.Panel):
    """Creates a Panel in the Object properties window"""
    bl_label = "Hello World Panel"
    bl_idname = "OBJECT_PT_hello"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "object"

    def draw(self, context):
        layout = self.layout
        wm = context.window_manager
        layout.prop(wm, "myProp")
        props = layout.operator("object.assign_value")
        props.helperProp = wm.myProp

class ObjectAssignValue(bpy.types.Operator):
    bl_label = "Assign Value"
    bl_idname = "object.assign_value"

    helperProp = bpy.props.FloatProperty()

    @classmethod
    def poll(cls, context):
        return context.object is not None

    def execute(self, context):
        ob = context.object
        ob.myProp = self.helperProp
        self.report({'INFO'}, "Assigned: {}".format(self.helperProp))
        return {'FINISHED'}

def register():
    bpy.types.Object.myProp = bpy.props.FloatProperty(update=lambda self, context: print(self.myProp))
    bpy.types.WindowManager.myProp = bpy.props.FloatProperty()
    bpy.utils.register_class(HelloWorldPanel)
    bpy.utils.register_class(ObjectAssignValue)

def unregister():
    bpy.utils.unregister_class(HelloWorldPanel)
    bpy.utils.unregister_class(ObjectAssignValue)
    del bpy.types.Object.myProp
    del bpy.types.WindowManager.myProp

if __name__ == "__main__":
    register()


Subdivision Surface modifier above level 1 subdivide causes boolean modifier to break

You basically want to make sure that the vertices, edges and faces of the cutting object never sit directly on top of those of the object cutted into. Try scaling or moving the cutting object by only a few micro- or millimeters. Finding a good position obviously becomes harder with each subdivision, since there are more possibilities of nearly identical vertices appearing.


Transfer UV map and 3D data between objects

https://www.youtube.com/watch?v=gORp5LC9xZk
this can probably help you with that


I did come up with a solution, but probably not the most elegant one. The vertex_group_clean method is an accessor to a menu, it is not a method to an object. So in the solution I select and activate an object, then switch to weight view, select all the vertices, do cleaning, and switch back to object view.

def active(obj):
    bpy.ops.object.select_all(action='DESELECT')
    obj.select=True
    bpy.context.scene.objects.active = obj
    bpy.ops.object.mode_set(mode = 'OBJECT')

for obj in bpy.context.visible_objects:
    if obj.name[-2:] == '-l':
        active(obj)
        bpy.ops.paint.weight_paint_toggle()
        bpy.ops.paint.vert_select_all(action="SELECT")
        bpy.ops.object.vertex_group_clean(group_select_mode='ALL', limit=0.005, keep_single=True)
        bpy.ops.paint.vert_select_all(action="DESELECT")
        bpy.ops.paint.weight_paint_toggle()

It does the job, but I hope there is a better way to write this :)


How best to create random surface variations (BI) in script-generated objects?

The answer appears to be...

DRIVERS

Here is a quick manual proof-of-concept using Drivers, as in the tutorial ref'd below and in Comments on the original Question, which I heartily recommend.  My text explanation here will not be nearly so clear and user-friendly as the video, so I suggest anyone who is interested should watch it!

These cubes are copies of one cube (manually created, not scripted) which has random-number drivers (manually created and tweaked via the UI) attached to various properties -- Scale (xyz), Diffuse Colour, Diffuse Intensity, and the geometry of the Marble generated texture.  The result is fairly pleasing, though I would like to know whether/how I can overcome the signature diagonal grain of the generated texture.  In a game landscape these cubes would probably pass OK as "different" from one another, despite the grain issue.

Method:

1) expose some kind of python random function(s) to driver context, as shown in this vimeo tutorial:
https://vimeo.com/40389198
(sample rand function code is provided by the author via a link on this vimeo page, and this is what I used:).

import bpy
import random

def randf(lo, hi):
    return random.uniform(lo, hi)

def randi(lo, hi):
    return random.randint(lo, hi)

def gauss(mean, stdev):
    return random.gauss(mean, stdev)

bpy.app.driver_namespace["randf"] = randf
bpy.app.driver_namespace["randi"] = randi
bpy.app.driver_namespace["gauss"] = gauss

2) With object selected:  in a property editing pane, select an object property such as Scale, RGB value in Material, etc.  Other-click on it (whichever one you don't use for regular selection of objects, focus placement, etc).  When menu comes up, choose "Add Driver" and then select either the whole group or just one property, to be "set manually later".  The slider should turn purple to indicate that it's being driven.

3) Open a Graph Editor and reveal its property editing panel (N).  Choose the Driver tab.  Now you can select your driver (at left) and edit/tweak it in the pane.  I for example would choose Scripted Expression for my randomising drivers, and for the expression enter my randf function which takes 2 args, min and max.  For some properties (material and texture props, so far) you have to set a driver variable.  For others (pos/rot/scale I believe) you can skip it...  I don't know why there is a difference.  If you've done it all correctly, then when you press Update Dependencies, your object should randomly change its shape, position, rotation, colour, whatever the driver is randomising -- in my case, within the bounds set by the 2 args to the rand function.  Anything that causes a Scene Update should trigger this regeneration of the random values, but you can "turn off" the drivers using the "mute buttons" next to their entries in the GE left hand pane, freezing the object's appearance.

4) When you Duplicate this "driven" object, the drivers go with it and the cloned object also has the randomised property.  However, aspects of the original object are by default shared with its dupes.  So for example, material seems to be shared with dupes;  you can spawn a new cube by duplication but it will have the same (random) colour as the original;  they will both change to the identical new value when Update Dependencies is invoked.  To fix this, I selected all the objects (dupes and original), hit U, and picked Materials/Texture.  This apparently prevents sharing.  Each cube now has its own independent material/texture settings and finds its own random colour/texture when the update happens.  You can dupe the dupes and the inheritance continues; the original object can even be deleted without losing any of your hard work.  But whenever you dupe, you have to turn off material sharing if you want randomised material properties.

Conclusion:  Drivers are insanely powerful;  also -- potentially -- insanely fun.  It actually boggles the mind, thinking of all the strange and wonderful ways that properties could be driven by, say, other objects' properties, frame count, external data files, higher math functions... But my immediate practical need was to make random small variations in mass produced objects, and Drivers seem to be the solution of choice.  My next challenge is to create drivers under Python control.  If I succeed, there will be one more photo in this series :-)

Another interesting write-up on Drivers may be found here

http://blendersushi.blogspot.ca/2013/06/python-driving-arrays-like-boss.html

some of it is a bit beyond me right now, but I hope to understand it better in a day or so.


You can do this with Rigid Body Constraints.
The 'Generic' constraint allows you to set up the constrains between two objects to set the amount the objects are allowed to vary from an Angular (rotation) and a Linear (position) point of view. By linking your 'Active' Rigid Body object to a 'Passive' one (that acts as the anchor) you can easily limit the motion.
The settings I used were as follows :

Here the limits on X and Y prevent it from moving in anything but the Z direction and the limits on Angle prevent it being rotated. Note how each is enable/disabled and the Lower and Upper limits set. In my case the Cube was the Active body and Sphere was passive to act as the anchor to it.
To set this up, simply select the two rigid bodies and select the Connect option, specifying to connect as contraint type 'Generic', then select the created empty and setup the constraint as shown above.


Render Glass like materials with Alpha Channel to composite in external app

Newer builds of Cycles (post 2.79, currently available from the buildbot) include a native functionality for this:

This is activated by enabling the new "transparent glass" option in the "Film" panel. The normal "transparent" option must be activated as well, or "transparent glass" will be greyed out. There is also a "roughness threshold" control, which allows you to have only clear glass transparent, with frosted glass blocking alpha. Alpha transparency will only be enabled for glass with roughness below the set value. Above a certain roughness, you're usually better off getting blurred refractions from whatever environment/HDRI you're using for reflections. The default setting of 0.1 is pretty decent cutoff point to start with.


When I add text to blender it disappears when I start the game engine

I just solved the issue. I had earlier changed the ui font of my blender. So it made the text object invisible when I render. I had to reset my preferences/settings.


Object On Characters Back Follows Character but Not In Unity

Nevermind I figured it out.  Turns out I did not have my backpack meshes vertices assigned to the chest bone in weight paint


There is no such issue with me when i do baking :)
Set render settings to default (Supported , CPU) maybe you are using Experimental for GPU .
I had some Crashes when I was using Experimental for feature set
I hope this helps you
GL.


How to get rotation of constrained object?

The file you've linked works as it is supposed to work, you've given a Limit Rotation on the X axis of -30° and 30°, as seen below. 0° on the X axis is a flat axis (in Global axis but also in cylinder's Local axis if you ever switch to it).

If you want the gun to follow the angle you're displaying you need to choose Min -60° and Max 0°.

If you want the angle to be relative to the rectangle rotations, don't use a Copy Location for your cylinder, parent it to the rectangle so that it's new Global orientations depends on the rectangle, not on the world. Also don't forget to limit on Z so that it doesn't flip.


Cloth repels and glitches through object

try this file... maybe you get some hints

I tried to separate well the unpinned geometry (exagerating a bit but...) and subdivided also the hair so they get a better cloth structure


Is there really no way to add edge loops with maintaining geometry?

I have not found any information on the web regarding that sort of tool in Blender therefore I conclude it does not exist. However I think the workaround might work in some situations depending on your needs. Here is what I used:

select your mesh
alt +c (convert to) -> mesh from curve/meta/subd/text
cleverly use the edges you need for your shape and remove the ones that does not affect it

Hope it helps.


Blender Game Engine Edit Object: can't use "add object" to spawn a character object

Ensure the object you want to add is at an hidden layer. This makes object an inactive object while running the game. The BGE will dynamically add inactive objects only (it makes a copy of the inactive original).

This restriction avoids to accidentally remove the original object (which disables the ability to add more copies later on).


Fill in object's surface with another object

You need Tissue addon

available in standard addons
https://vimeo.com/132720942


Scale keyframes for multiple objects with a script

I found a solution, however it resizes keypoints around arbitrary point.

old_type = bpy.context.area.type
bpy.context.area.type = 'GRAPH_EDITOR'
bpy.ops.graph.interpolation_type(type='CONSTANT')
bpy.context.scene.frame_current = 1
bpy.ops.transform.resize(value=(6, 1, 1))
bpy.context.area.type = old_type


What happens when you plug a BSDF into a value socket?

It doesn't do anything.

Cycles will use the value specified for that socket and ignore the invalid connection:

This example uses a color input, but the same applies for value inputs.

As you can see, the render result is the same with or without the diffuse node in the above setup.

For some explanation on why cycles works like this, see Convert cycles closure (shader) output to colors?
For a workaround, see Is it possible to use the output of a Renderlayer in the material nodes of another RenderLayer?


Error while exporting preset in sapling:add tree

Ok, I've solved this problem and it was simply a permission problem.
Blender needs to have administrator rights to write in the "presets" folder, so it won't export anything in there if you don't give the permissions.
What you have to do is to right click on the folder "presets" -> Properties -> Security and give to user the permissions to write.


Extruding imported svg does only translate curve

Go to the object mode, press ALT+C and transform the curve into the mesh. Go to the edit mode and then extrude it along z-axis.


1: Are you following the  “Blender for beginners: Alarm clock 1 of 2” tutorial.    https://www.youtube.com/watch?v=Ay7fgeQC1WI   ?

2: When UV unwrapping the clock face at 11:40 are you saying that you have two circles showing up in the UV space instead of one big one?

Two circles unwrapped instead of one means that you have two circles selected in the 3D edit window before unwrapping.

You need to go back to the 3D edit window and check out why two circles were selected instead of only one.

Perhaps you have the the glass lens selected instead of the clock face?

If you still don't see how two circles are being selected then I suggest you add your .blend file to your post

https://blend-exchange.giantcowfilms.com/

then someone can take a look at it for you.


When you add an effect strip, that strip essentially replaces the input strip. So add your transform strip, then--with that transform strip selected--add the gaussian blur.


Blender array modifier wont rotate around empty object

When you give an Array modifier an object-offset target, there is a transform that would take the original of the arrayed object to the target.
For example:

The original cube is the one at 3 o'clock. Although the cube's mesh is at X=2, the cube's pivot, the object, is at 0, and aligned to the world. It's the larger yellow axes in the picture. (The mesh was moved in Edit mode, leaving the object behind.)
In the picture, there is also an Empty at 0, the smaller orange axes. The transform that would take the cube object to the Empty is a rotation of 30 degrees. The Empty is the target of the object-offset array.
The transform that would take the original object to the target in an object-offset array is the one that's given to each iteration of the array, with respect to the previous iteration. So, above, each element of the array is rotated 30 degrees from the previous one, about its own object axes.
In short, to get a clean rotation, without a translation being added, too, the object's axes must be coincident with the target, just rotated, that's all.


Use Select > Select All by Trait > Non-Manifold option in 3dView header (or Ctrl+Alt+Shift+M) and in options of operator located in Last Operator panel (they appear there after executing it) deselect everything but Boundaries.

Select all and choose Select > Select Boundary Loop.

This will select boundary loops around selected edges.

Use shipped with Blender MeshLint addon (by default not activated). It allows choosing which categories of wrong topology to select, including non-manifold (however I think it will select wire, multiple faces etc. as well but still for completeness).


In the glass mesh, the normals (direction it's facing) of the faces are not all pointing out to the air as they should.
So the fluid simulator does not know how to calculate the shape of the glass obstacle correctly.

To fix (EDIT) your second try:

With the glass selected,

Go into edit mode. (tab)
select everything. (a key)
Then "recalculate normals".  (ctrl+n  This is also in the tool panel at the left, in the "Shading / UVs" tab.)

More tips:

You could make the domain object much smaller for more efficient
simulation.  So you can resize it to just where the fluid will be.
Now you can turn up the Domain's fluid resolution...
You might want to make the glass a little thicker towards the bottom,
so the fluid does not stick through.

(EDIT.  Noticed my instructions were just for your second try.)

To fix your first try:

On both the glass and fluid shape:

(In object mode, look at the scale of the objects, they're negative numbers, they need to be positive for the fluid sim to figure out the shapes.)

Apply the scale.  (Ctl+A then click scale)  Applying the scale makes the scale 1,1,1.)
Then recalculate normals.  (If you recalculate the normals when the object is inverted, it looks ok, but it confuses the fluid sim.
(Also I didn't test if you needed to, but I'd also remove doubles on your meshes, the fluid shape has quite a few.)


Why does a bump/normal map change the look of a plane to which they're applied to, even if the plane only has 1 normal?

A normal can be thought of as the direction a face is pointing.  The face (usually) has one normal, it's just a vector pointing into space going outwards from the face.  For our purposes here, it defines the average angle of reflection of light rays.
When you modify it with a Normal Map, you're giving it additional instructions on how to handle light across the face.  For every evaluated pixel, the light is taking the face normal and your Normal Map information into account.
So it's not that it is creating more normals.  There is only one, with a little math being done for every pixel sampled.  Very easy for your processor/gpu.
From Wikipedia

To calculate the Lambertian (diffuse) lighting of a surface, the unit
vector from the shading point to the light source is dotted with the
unit vector normal to that surface, and the result is the intensity of
the light on that surface. Imagine a polygonal model of a sphere - you
can only approximate the shape of the surface. By using a 3-channel
bitmap textured across the model, more detailed normal vector
information can be encoded. Each channel in the bitmap corresponds to
a spatial dimension (X, Y and Z). This adds much more detail to the
surface of a model, especially in conjunction with advanced lighting
techniques.


To increase the effect of, and invert the direction that effects the shape key in your driver:

Go to File->User Preferences.
In the User Preferences window, select the File tab and check the box for "Auto Run Python Scripts".

Go to the graph editor in the Drivers tab and Change the type to "Scripted Expression".
In the expression box, type "-2 * var" (no quotes and with var being your variable name).

This expression will multiply the distance you target object travels by 2(or whatever you number you choose). So your target will have to move half as far. The higher the number, the shorter the distance. Making the number negative changes the direction it must travel.

EDIT

After looking at the blend, the target is upside down on the Z axis, making its local space z axis(and your variable) -6.69. Negate that by adding 6.69 to it. Then multiply that by -10 so you will only have to move up by 0.1 to reach the maximum of the driver. So the expression is: -10 * (var + 6.69) And make sure "Auto Run Python Scripts" is enabled.


How to get the value of the matrix socket via scriptsNode

When creating a subprogram in Animation Nodes (eg. Script Node), you are only defining what that subprogram do, in order to actually use it, you have to Invoke the subprogram. You can invoke a subprogram by adding an Invoke Subprogram Node pointing to the required subprogram, this can be done through the Subprograms panel in the Add Node menu where all subprograms are listed:

To get the value of some data in the script, you add an input with the same type, in your case, it is a Matrix List and input the data to it. A variable that carry the input data is automatically created with the name of the input, in our case, it is called MatrixList, you can use this variable to do what ever you want with the input data. For instance, you can print the list and its length as follows:


This script:

import bpy, bmesh

THR = 4  # <-- the only parameter. The smaller, the stricter

for element in bpy.data.objects:
    if element.type != "MESH": continue

    # reset
    for m in element.modifiers:
        if m.name == 'ScriptedDecimate':
            element.modifiers.remove(m)

    # scoring function
    vert = len(element.data.vertices)
    areabbox = (element.dimensions.x*element.dimensions.y
               + element.dimensions.y*element.dimensions.z
               + element.dimensions.x*element.dimensions.z)*2
    indicator = vert/areabbox

    # select and decimate!
    if (indicator > THR):
        element.select=True
        decimator = element.modifiers.new("ScriptedDecimate", type = "DECIMATE")
        decimator.ratio = (THR/indicator)**(2/3)
        bpy.context.scene.update()
    else:
        element.select=False

can be useful.

It creates a Decimate modifier for each element where the number of vertices, divided by the surface area of the bounding box, is greater than a set threshold THR. It also adds these object to your selection (and removes all the unaffected meshes). It resets its actions every time you run it again (to avoid double modifiers).

The Decimate Ratio depends on "how far" the original vertex count per area was from the threshold (but it doesn't try to decimate it right to the point where it doesn't exceed the threshold!).

↑↑   verts, faces (tris): 6171, 7182 (12218) → 1743, 2601 (3374)


A common way to do that is create a hole in the surface, add a circle into that space then fill in the gaps.

1 : Subdivide a plane and delete some of the inner vertices.

2: Add a circle with a vertice count the same as the number of vertices that now make up the inner edges of the plane.

3: Select both the circle and the inner edges of the plane, then using the W shortcut key open the Specials menu and choose Bridge Edge Loops.

4: Using the Extrude tool model the rest of the Dial.

5: Add bevels and or supporting edge loops, smooth….. etc  etc .

Note that if you intend to use a Subsurf modifier then aim to use a circle with less vertices than in my example below.

Check on Youtube for cutting holes in meshes. This is a good example https://www.youtube.com/watch?v=Bc52fcrHvAA


Write the Rotation Matrix Values of an Object by XYZ individually?

How to make the three basic rotation matrices rotate around the x, y, or z axis.

import bpy
from math import pi
from mathutils import Vector, Matrix, Euler

theta = pi / 6

for i in range(3):
    angle = Vector()
    angle[i] = theta
    mat = Euler(angle, 'XYZ').to_matrix().to_4x4()
    print(mat, "\n")

Or directly

from math import pi, sin, cos
from mathutils import Matrix

theta = pi / 6
s = sin(theta)
c = cos(theta)

mat = Matrix()
mat[1][1] = c
mat[1][2] =-s
mat[2][1] = s
mat[2][2] = c

print(mat, "\n")


Can a custom optimization code be added for doing accurate mesh deformation simulation in Blender?

Your question is a bit too broad.
Whether Blender will support your needs depends on many things, including what you mean by "equipped well", "accurate simulation", and "at the industrial level". It's certainly seen use in a wide variety of industrial applications.

Blender will give you an extremely flexible interactive 3D environment to display and examine results, and many other useful features, all fully controllable using Python. As a starting point, you may want to familiarise yourself with the mesh data sections of the Python API to see if it will give you what you want. https://docs.blender.org/api/current/index.html

Beyond that, Blender doesn't necessarily have the sort of physics solver functions you may be accustomed to from other software. Your code, whatever it is, might need to do more of the the physics 'heavy lifting' by itself, than perhaps you would have to do in a more dedicated scientific computing application.

Still, plenty of people have done FEA-type work and presentations using Blender before. Many of those have utilised/included numpy for calculations. There are Blender Conference talks from past years available on youtube - for example, on rendering supernovae, medical implant design with FEA testing stress/material forces, and others such as flood prevention design using Blender's built-in fluid sim, which in that case was adequate for their needs.

Blender's built in physics (eg rigid/soft body) solvers are primarily designed for graphics / speed-priority applications. So in terms of your crash test, you might determine that you'd need to solve the physics yourself. Again, this completely depends on what you mean when you say 'accurate simulation', and how critical scientifically accurate physics sim is to your project.

(edit: further response to follow-on comment):

Addressing what I meant about 'accuracy':

The various 'scientific'/engineering specific software, with serious academic/industrial applications, very much focus on real-world accurate integrators which minimize error (for example). This is one strong reason for using those sorts of programs.
Blender may not be that. Its integration methods might destabilize or constraints might blow up, as they're designed for speed (graphics/animation application) rather than low-error 'reality-proof' solving.
I don't know this for sure as I've not read that much of the source code. I would say that, to make your decision on how usable it is, you may need to check that yourself (if it is a concern).

But Blender will let you do that sort of computing within it, if you treat Blender as your 'display tool'. You can attach custom fields and enrich the mesh data any way you like from Python - so attaching all the metallurgic parameters is pretty simple, and that can then be linked to shaders.
Where exactly the division point between your simulation and Blender's provided functionality ends up being will just depend on how much your program itself needs to worry about. I would suggest you may need to do some 'toy example' proof-of-concept tests first, to find out if Blender will do what you need, to avoid finding unforeseen limitations later. Of course a major benefit is the open source code and documentation, meaning you can debug/directly check what Blender is doing under the hood, should you need to.


Advantages/disadvantages of various file formats for storing non-color texture data?

Due to comment limitations I am posting Yet Another Answer to one that is largely sufficiently explained already.

First, I would state rather vociferously that PNG is an absolutely diseased format. It has a foothold in Blender almost purely because it was set as default by someone a long, long time ago. My TL;DR is never use it in an imaging pipeline. Ever. Delivering to web? Have at you. In a pipeline? Keep it well the heck away.

With that out of the way, specifically, what are the shortcomings of display referred imaging encodes such as PNG when it comes to data? In no particular order:

They were not designed for storing data. When we consider what data is, and its potential ranges, we can see things more clearly. Data should be viable to dip to negatives for some types of passes, as well as extend arbitrarily off into large values. Z buffer is an obvious example of the latter, and any origin 0.0 based data is a sample of the former. Examples include but are not limited to:

Normal (negative)
Vector (negative)
UV (negative)
Z (infinite)
Deep alpha (infinite)
Emission (infinite)
Environment (infinite)

They almost exclusively don't play well in many other applications. Most applications are going to make unfortunate assumptions about your display referred encode. This will end up in a mangled mess. Even with applications that understand transfer functions, how many are applying them correctly? Is your application applying the sRGB two part transfer or a blind 2.2 power law? Is there some colour management happening via installed display profiles that you might miss? Even the much beloved Photoshop is an absolute dog at handling data despite storing it in the robust EXR format, including truncating 32 bit EXRs down to 16 bit.
Quantisation. Given that many display referred formats are trapped storing integers, an imager is going to have a heck of a time expressing some ratios. 16 bits in float is a literal order of a magnitude different than 16 bit integer. Is your data format using a power law or purely linear storage approach? Those sorts of issues will end up impacting the influence quantisation has on your encoded values.

In the end summary, at some point it is very likely an experienced imager is going to ram into some mangled up data or value range that, when stored in a display referred encoding format, will cause nothing but heartache and heartburn. It is far easier to suggest that they simply start and end with EXR and avoid all problems through their entire pipeline than suggest "Use this here and that there, and be sure to do this" dark alchemy.


Proper way to remove unused linked Group data-blocks

Groups are intentionally not garbage collected, (so they have to be removed manually). Only a few kinds of data-blocks behave this way, Scene's are another example.

As a user, you can select them in the outliner and unlink them, but there is no way to remove single user groups other then to script this as you have done.

For details see the reference manual.


I just found the problem) !!
It was some faces inverted.


(I wish users were a bit more curious and explored the menus...)
The Extrude function will extrude a face.
If you olny want to extrude the edges, select the face, then use Edge> Extrude Edges.

Likewise, if you want to extrude only vertices, then use Vertex > Extrude Vertices


How can I hide just the custom gizmo icon on with a checkbox instead of all gizmo's as my script does?

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

# CUTOM PANEL IN PROPERTIES OUTPUT PANEL
class CUSTOM_PT_menupanel(bpy.types.Panel):
    """Creates a Panel in the Output Properties of the properties editor"""
    bl_label = "Test"
    bl_idname = "SCENE_PT_layout"
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "output"

    def draw(self, context):
        layout = self.layout
        scene = context.scene

        row = layout.row()
        row.prop(scene, "gizmo_show_hide")

#SCREEN OVERLAY GIZMO
class Camera_overlay(GizmoGroup):
    bl_idname = "Gizmo_Icon"
    bl_label = "Gizmo"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'WINDOW'
    bl_options = {'PERSISTENT', 'SCALE'}

    @classmethod
    def poll(cls, context):
        scene = context.scene
        if scene.gizmo_show_hide:
            return False
        else:
            return True

    def draw_prepare(self, context):
        region = context.region
        self.my_gizmo.matrix_basis[0][3] = region.width - 35
        self.my_gizmo.matrix_basis[1][3] = 40

    def setup(self, context):
        mpr = self.gizmos.new("GIZMO_GT_button_2d")
        mpr.icon = 'OUTLINER_OB_CAMERA'
        mpr.draw_options = {'BACKDROP', 'OUTLINE'}
        self.my_gizmo = mpr

#CHECKBOX GIZMO BOOL
bpy.types.Scene.gizmo_show_hide = BoolProperty(
    name="Gizmo Hide",
    description="Check Box to Show And Hide Gizmo",
    default = True)

#CLASS LIST
classes = (

    CUSTOM_PT_menupanel,
    Camera_overlay,

)

#REGISTER AND UNREGISTER CLASSES
register, unregister = bpy.utils.register_classes_factory(classes)

if __name__ == "__main__":
    register()


frame is currently the only updated value in the driver namespace. The rest are functions, available for use in scripted expression driver through bpy.app.driver_namespace.

Several modules are already pre-imported to the driver namespace, like builtins, bpy, math, and mathutils.noise. So, other than frame, and unlike manually-registered functions, functions from these modules are available to scripted expression by default.


What's the 'generate grease pencil' command in render view?

To create an image in the image editor and create a grease pencil object with it.
In the image editor create a new image (Image>New).
Change to Draw Mode.
Create your drawing.
Select Image>Generate Grease Pencil Object.
Switch to the 3d viewport, the grease pencil object should appear. The grease pencil object will be created with the lower left corner at the place where the 3d cursor is.


How to write the output of Blender console out to a file

On Linux/Ubuntu its ./blender > myLog123.txt from the working directory.

./blender &> myLog123.txt to include Stderr.

In Python you can do

import sys
file = open(filepath, "w")
sys.stdout = file
#...
#...
sys.stdout = sys.__stdout__ #reset
file.close()

to catch the console output while your script is running.


This behavior is normal. The copy rotation in world space will align the rotation axis of the bone with the cube (X with X, Y with Y, Z with Z). If you don't want the bone to rotate 90deg when you add the copy rotation you will have to rotate the bone in edit mode, making sure it aligns with the rotation of the cube (in your example, in edit mode, rotate the bone -90deg in X axis).

The rotation in edit mode has an impact on how the bone is oriented in pose mode (in pose mode the Y axis of the bone is the one going from the head to the tail of the bone).

Then when you add your constraint to the bone, it shouldn't rotate.

Hopes this makes sens.


By default, motion tracking is set up to solve camera motion.

To enable object solving mode you need to click on the plus sign of the Objects Tab on the right side of the screen (if it's not visible press N)

and select Object.

Now Solve Object Motion is enabled.


The Normal node outputs a normalized vector ((X,Y,Z)), meaning a vector with a length of 1. The ball represents the direction of the normal, like you were looking down on it from the top of the 3D Viewport.

Therefore, the default output of the Normal node is (0,0,1), or directly up. When you rotate the ball, you are changing the output normal, as if you were looking at it from the top, so +X is to the right, and +Y is towards the top of your screen.

If you choose to plug something into the Normal input, the Dot output will give the dot product of the input normal and the normal represented by the ball.


So what have you tried so far? Have you tried to duplicate your object, give the copy a higher Emission Strength and make it invisible to the camera?

Create a copy of your object and duplicate its material.
Scale the copy or move it above the original object.
Go in the Properties panel > Object > Display and choose Maximum Draw Type > Wire to make it easier to manipulate in Object mode.
Go in the Properties panel > Object > Cycle Settings and deactivate the Camera option to make your object invisible in Render mode.
Give this copy a higher Emission Strength so that it emits more light than the original and can enlight its environment.


Locking planes together and animating them separately with shape keys

You can (sortof) do it like this

set the pivot point for all the planes in the same exact point in 3d space.
this can be done in more then one way: you can join all them togheter (so that all meshes get one single pivot point) and then separate them back again, one by one (the pivot point of separated meshes remains untouched); another one would be manually "set origins" to one 3d point of your choice...
then select one plane as "base" and use "copy location" constraint on all the others, with the "base" one as target.

the constrained planes can't be moved anymore, if not moving the "base" one, which moves all the others too.
shape keys for each plane are still independent
for rotation/scale, just select all them, they will rotate/scale around the same pivot point for all so they will rotate/scale all together


In the actuator, if you uncheck lock Z velocity it works for me.
Are you sure you have in unchecked? Can you share file?


There is an addon tutorial that covers keymaps.

# store keymaps here to access after registration
addon_keymaps = []

def register():

    # handle the keymap
    wm = bpy.context.window_manager
    km = wm.keyconfigs.addon.keymaps.new(name='Object Mode', space_type='EMPTY')

    kmi = km.keymap_items.new(ObjectCursorArray.bl_idname, 'SPACE', 'PRESS', ctrl=True, shift=True)
    kmi.properties.total = 4

    addon_keymaps.append((km, kmi))

def unregister():

    # handle the keymap
    for km, kmi in addon_keymaps:
        km.keymap_items.remove(kmi)
    addon_keymaps.clear()

There are several addons that can be viewed as examples as well.

Material Utils is one of them -

kc = bpy.context.window_manager.keyconfigs.addon
if kc:
    km = kc.keymaps.new(name="3D View", space_type="VIEW_3D")
    kmi = km.keymap_items.new('wm.call_menu', 'Q', 'PRESS')
    kmi.properties.name = "VIEW3D_MT_master_material"


How can an animated object kept on the surface of an ocean?

As gandalf3 suggested a Shrinkwrap constrained works, but not alone. Using Vertex Parent on a triangle and shrinkwrap the triangle to the ocean does the trick.

For the second requirement to follow a curve a Curve modifier must be added before the Shrinkwrap in the modifier stack.

The vertex parent trick was described here but this tutorial uses softbodies and is more complicated to setup.


As I supposed, it was my faulut, not blender bug. (Maybe blender's not-intuitivnes)
Thanks @lemon, Mix factor must be set to full 1.


If I read your question correctly, you want to use the diffuse map and the displacement map and make them line up with each other, so that they are aligned.

To do this, all you have to do is use the same UV map for both images.

In short, create two image nodes, and load the diffuse into one, and the displacement into the other. Plug the diffuse into the color slot of an emission node, and plug the displacement into the height slot of a bump node.

Add a geometry node and plug one of the mapping types (UV, generated, etc.) into the vector slot of both of the image nodes (use the same mapping type for both images).

Plug the emission shader into the shader slot of the output node, and plug the bump node into the displacement slot of the output node.

For Blender Internal, the process is a little different.

You'll only need one material.

But you'll need to add two textures to that material. One texture should be set up like you expect for a regular image texture.

The other should be set up like this. Basically, you'll have two textures, one with each image. For the diffuse image you'll check "Diffuse: Color" and for the bump map you'll check "Geometry: Normal." There may be other bump map settings below that, but this should get you close enough to see some results.

Keep in mind that Normal Maps are different from Bump Maps. Normal maps are usually bluish, and bump maps are always gray-scale.

There's also a displacement modifier, which you can use your grayscale image with. You'll still create a bump texture, just like normal. Then choose that texture in the box on the displacement modifier. To make it line up with the diffuse/albedo map, just change the "Texture Coordinates" from "map" to "UV."

Then you'll see a new box called "UV Map" where you can specify which UV map to use. Just choose the same UV map that you used for the diffuse map. You can give UV maps custom names, too, which might help you choose the right one. There are lots of places to specify UV maps, as long as all your images are using the same UV map, they'll line up with each other.

There's more information here for both Cycles and BI.

That should do what you want.


the compositor is not getting any input, I think.
you can connect the "image" output of the rgb node ALSO to the compositor, which builds the output. Just drag it.

you can leave the viewer connected, to see the result of that (or others) node output, too, like the backdrop, if you use it.


Texture showing errors (edges of texture)?

Cause

I think the texture gets blurred either because it is scaled out or scaled in via automatic mipmapping texture.

Blur means the adjacent texels are considered when calculating the color.

It will include any texel outside the UV area. It even wraps around the around the texture's border (which is the cause of the effect you discover).

Solution

In both cases I suggest you shrink the UV-face that you get some border around the face (in UV-Editor).

Reference

See Avoid Seams in Textured Objects


How can I go back to the original interface layout?

Save and close your file, fully close Blender and then open a new Blender instance with the correct default layout.

Then go to File > Open and browse to open your desired file, but before you open uncheck the Load UI option on the bottom left of the File Browser window.

If when you open Blender by default the layout is already messed up you may have to delete your Startup.blend file from the user preferences folder either under

Blender/2.##/config for portable installations or under
or %APPDATA%\Blender Foundation\Blender\2.##\config for formal installation, generally under C:\Users\<UserName>\AppData\Roaming\Blender Foundation\Blender\<VersionNumber>\config for Windows users


Try this:

Place the ear in the perfect position.
Select the both the ear and head mesh using shift+right click
Hit ctrl+J to join the the two meshes together
you can then enter edit mode select vertices and choose smooth vertices from the tools menu


Clone Brush in the Image Editor (2D) doesn't work at all the same -you cannot use the cursor as a reference - you instead use a transfer or clone image that is the same size as the target image, and then move it about with rmb to position it and then paint through to clone. This is a VERY limited functionality, and there is no rotation of the image. For this reason, I prefer to use Stencil Brush Texture instead since we can rotate/scale/move and even set the UV to be upside down/repeating etc. Honestly, that is why it is sometimes better to just work on a 2d image plane in the 3d viewport than to waste time with the image editor for anything other than fast paint dabs or Fill tool control.


Subdivision Surface Artifacts / Topology Issues?

You may consider retopologizing it a bit (changing the edges flow). Here's my proposal:

This kind of geometry doesn't create the shading artifacts plus allows you to properly crease the subsufed mesh with edge loops.


turn splines from 3d into 2d using animation nodes

The dimensions is a property of the Curve Data Block not the splines themselves, thus there is no distinction between 2D and 3D for splines.

A 2D curve just ignores the z axis of the spline points and also ignores the tilt and radius of the splines, so you may do that manually if that is your objective.


Resize vertex group using bpy.ops.transform.resize

Using a scale amount of 0.2 means scale to 20% of the current size, to increase the size you want to use 1.2 to be 20% bigger than the existing size.

You can also simplify what you have by using two operators to set the active vertex group and then select the vertices in that group.

import bpy

sfac = 1.2
vgrp = 'Group'

obj = bpy.context.active_object

bpy.ops.object.mode_set(mode='EDIT')

bpy.ops.mesh.select_all(action='DESELECT')
bpy.ops.object.vertex_group_set_active(group=vgrp)
bpy.ops.object.vertex_group_select()
bpy.ops.transform.resize(value=(sfac,sfac,sfac))

bpy.ops.object.mode_set(mode='OBJECT')

Part of the issue I see in the first image is that having a mirror modifier causes the scaling to pull away from the centre of the object and I think most of them are going past the halfway point to give you inverted mesh in the middle. One option is to do this without the mirror modifier. The other may be to position the 3D cursor and use it as the pivot point but that may get difficult depending on what else you plan to do.


Blender Sine wave calculated incorrectly?

There is nothing wrong, your expectation and the parameters of the modifier just do not fit together. I guess this is caused by a unit mash-up of radians, degrees and frames.

I'll try to sum up the necessary math as short as possible to avoid further misunderstanding. Take a look at the XY plot with a circle given a radius of 1 (known as unit-cirle) and consider the marked triangle:

The sine is now the Y position of the black dot (green line) and depends on the position of the dot running counterclockwise around our circle. We can either measure the marked angle in degree or radians. Plotting this with reference to the angle measured in radians gives us this plot:

You can observe, that a full period is reached after 2 PI, which is approx. 6,28. Now compare this to a sine modifier applied to the x-location of some object:

Looks similar, right? Both plots are bounded by +1 and -1 and complete a full period after 6,28. But in the Blender case 6,28 is the number of FRAMES, after which the sine starts all over again.

Now it depends on your use case if you want such a fast oscillation. You can stretch and shift the sine with the four given parameters as you like. The equation seems to be this one (c=constans):

Hope this helps!


The STL format does not support units. It just records arbitrary X,Y,Z coordinates of the vertices for each face.  Blender cannot know the units you intend.

blender scenes have their own co-ordinate system.  Unit system and Unit Scale just offer consistent display of properties through the user interface.  The objects themselves remain unchanged, because equally these do not have real dimensions either, much like the STL file they just have an arbitrary X,Y,Z.

To fix the problem with your STL you must enable the Scene Unit checkbox in the STL exporter options as shown.  It is also worth using the Selection Only to avoid exporting unwanted geometry.

.

Please note that the STL importer also has similar settings.


Blender Video Sequence editor taking all memory and crashing

Blender include a setting in the User Preferences/System tab to limit the amount of memory that the Video Sequence Editor can use. This setting should be never set to more than your available system memory plus the available swap - otherwise Blender can attempt to grab more memory than is available and cause the system to crash or become unresponsive.

At the bottom of the System tab in User Preferences is a 'Sequencer/Clip Editor' setting that dictates the memory limit for blender when caching and rendering videos in the VSE. This setting normally defaults to 1024Mb - ie, 1Gb - and so should not cause a problem (unless your system has less than 1Gb of available memory). If this is set to a value that is larger than your system memory - or less than your 'free' memory when Blender is not running - then you may get Blender trying to allocate more memory than is available.

Reduce the value to limit the amount of memory available to Blender.


Your Normal and displacements are connected in the wrong way, you need a Normal map node and a displacement Node, also your normal image needs to have a Non color on the color space.


Differences between Center and Median options of Blender snap target menu?

Center uses the pivot point instead of a property of the object itself. The default for the pivot point, however, happens to just be the median center, which is why selecting "center" doesn't appear to do anything by default:

In other words, you can think of the "center" setting as a "defer to pivot point" setting. The primary use of this is that it lets the snap point be defined by the 3D cursor by selecting "3D Cursor" in the pivot point menu (see above image) while the snap target is set to "Center". Using "Center" with the other pivot point options isn't too useful in most cases.


Change sculpting brush alpha visibility?

There is a fantastic addon by Kgeogeo called Stencil Widget that allows a lot of control over the Stencil images in both Texture paint and Sculpt.

You will see an icon looking like a square with a triangle missing - that is the alpha control.

You can get it here and watch a short video here


Hair particles not following curve modifier :(

The order of modifiers matters. In your case, Blender creates particles first and then blends the source mesh by the given curve. Just move the Particle Modifier down in your modifier stack.

Also check if you enabled Use Modifier Stack under Particles > Emission by accident.


Select all the objects you want to change the transforms.

Then open Object menu, select Transform>Origin to Geometry.

That will change the origins only and not the rotations of the objects.


Is there a way to clear the "info" editor?

OK, I discovered the solution, press A twice to select all and then X or Delete to get rid of these lines.


Particle start frame not exceeding 200 with python code

I tested the bpy.data.particles["star1"].frame_start = 400 in Blender 2.83 and it worked fine.
In Blender 2.82 though it did indeed set the Frame Start value only to 200 as mentioned in the question.

The reason is Blender making internally sure, that the start value can't exceed the end value, which by default is 200. Should you set the end value to 400 and try to set the start value to 500, it will result in the start value being capped at 400 as well.
There are 2 Solution possible:

Update to Blender 2.83, which as i mentioned solves the issue, and sets the start and end value to the highest if the start value exceeds the old end value.
Stick with Blender 2.82 for whatever your reasons may be, but then you have to first set the frame_end value to be higher then the wanted frame_start value for this to work. Means in your code, just move the line where you set the frame_end above the line where you set the frame_start.

With solution 2, it would need to look like this:
bpy.data.particles["star1"].frame_end = 489
bpy.data.particles["star1"].frame_start = 319