What are these black axes lines on my model?

Those axis you see are empties (or Null Objects).

quote from the manual:

  Empties can serve as transform handles which cannot be edited and do not render. Empties are important and useful objects. Some examples of ways to use them include: Parent object for a group of objects

  An Empty can be parented to any number of other objects - This gives the user the ability to control a group of objects easily, and without affecting a render.
  Target for constraints

  An empty can also be used as a target for normal, or bone constraints.
  This gives the user far more control; for instance, a rig can easily be set up to enable a camera to point towards an empty using the Track to constraint
  Array offset

  An empty can be used to offset an array modifier, meaning complex deformations can be achieved by only moving a single object.

An empty by itself would show on the outliner window like this, with nothing else:

An empty that has something parented to it will show what kind of objects is a parent of:

In your case the empties are controlling something, meshes or other objects.
To find out what that might be click on the Plus (+) sign on the left to expand the tree list (hierarchy).


Creating displacement maps from 3D geometry?

There are ways of baking scalar/vector displacement maps from non-planar originals, in Blender, by using an intermediate bake of high-res shading-point positions and subtracting low-poly positions from them in a shader, using a  corresponding UV map. But that's fiddly, and complicated.
As far as I can see, your sculpt is of surface details. (Mainly dinks from rim-shots?)
I'm assuming either you want a low-poly final, in which case your height-map will be used as a bump texture (the geometry would not support displacement), or you want low-poly geometry, and the renderer to generate the subdivision for true displacement...
In either case, I think it would be easier, for this kind of detail, to use  a low-poly mesh in the first place, without going through an all-round sculpt? You could texture-paint straight into a height-map, (while seeing the results), use and manipulate ready-made scratch-maps, or, if you're looking for paricular 3D characteristics, sculpt into a flat surface, bake that, chop bits of the image out to use in collage in your UV, or as texture-paint-brushes... any combination of these things, or others not mentioned here?


Type Error: 'expected class "execute" to be a function not a method' When Removing Poll

You would have to remove or comment out the method including the @classmethod decorator:
import bpy

class MonkeyOperator(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.make_monkey"
    bl_label = "Monkey Operator"

    def execute(self, context):
        # do stuff
        return {'FINISHED'}

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

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

if __name__ == "__main__":
    register()

For multiline comments you can use triple-quoted strings:
'''
@classmethod
def poll(cls, context):
    return context.object is None
'''


This can be changed in the particle settings under either Physics or Render (when using a display type that allows this) with the Size slider. You can also change the size of your particle objects by scaling the main object(s) you are using but it's best to control the size via the particle settings.

Additionally, you can randomize the size of your particles by using the Random Size slider.


You can match a camera in blender.

Select your camera
Go into the camera properties.

Set the Focal length of your camera to 121.

Set the Sensor Fit to Horizontal

Set the width value to 127 (which is 5 inches in millimeters).

You will need to make your image resolution fit a 4:5 aspect ratio.

Enter the camera properties
Set the width and height accordingly.

To make a new Preset click on the plus sign next to cemera presets

Add a name to it (Click on save focal length if you want to include the lens in the preset).

Once created the preset will be available for future projects.


(Creator of the tutorial here)

One of the curve handles of the curve that deforms the plane is pointing the wrong way, causing part of the mesh to be flipped upside down, as shown below by the directional arrows of the curve:

Enter 'Edit mode' for curve (Bezier Curve.001).
Select the middle curve point, which is the one that is flipped.
Rotate the curve point 180 degrees on the 'x' axis (R,X,1,8,0)
Exit edit mode, and if the error hasn't gone, simply turn the curve modifier on and then off and the mesh should refresh.


I'm unable to set the f-stop and depth of field of the viewport using Eevee renderer

You can enable or disable the Depth of Field in Viewport Shading by going into the Viewport Shading settings. Click on the down facing arrow button on the right of all the shading styles in the top right of the screen. The Depth Of Field settings is at the bottom of the settings.


Mesh is disappearing in Orthographic View? Is there in Perspective view

Select your Model
Switch to Ortho (nothing will be shown)
Then choose View Selected from the view menu as shown below or using the Numpad .
Then select View-> Front Numpad 1


To do this, Rightclick beside the panel name and choose Align Vertical instead of Horizontal as shown below:

This will be the result:


My camera is lost in my workspace and I cant find it

Select your camera in the outliner then put your mouse inside any 3d view and press Numpad . (period key on the number keypad).


How do I use IES lighting with a sphere?

Thanks to a little advice from my commentor,Jaroslav Jerryno Novotny,I figured it out. For the first Mapping node connected to the Geometry Normal socket,change the Z-axis scale from 1.000 to 0.000. I know you're facepalming right now because this question was stupid and it had an easy answer,but c'est la vie.

Solution


Mesh deforms on one side of model when attaching rig

Be sure to apply all scales to your mesh before you add a rig. Make also sure the origins of rig and mesh match.
Out of my head it's ctrl a to apply scales


The rigid body world contains global settings for the rigid body simulation.

With the "Rigid Body World" checkbox you can simply disable/enable the rigid body simulation.

In order to understand the groups, you have to understand the following:

The rigid body system uses regular Blender groups to keep track of the objects that need to be simulated.
When you add rigid body physics to the first object, a group called "Rigid Body World" is automatically created, and the object is added to it. You can see it in the Outliner, if you set it to show groups.
When you add rigid body physics to other objects, they are also added to the "Rigid Body World" group
You can create your own groups, and select them in the "Rigid Body World" panel. In this case the objects belonging to the new group will be simulated and the objects belonging to the old group will be ignored.


This is kind of similar I imagine to working with text objects in Blender so ill demo on that,

Your topology starts like this, Or something near this:

Go to Mesh>Clean Up>Limited Dissolve, which basically dissolves all edges based on the angle of faces they are connected to.

Thatll give you this:

You might go through and clean up your edges a little bit, just to even out a few really long triangles or what not. This step might be not necessary. Some times blender has to have an edge in one spot to figure out how to make a weird Ngon stay together. If that edge is weird try to connect other vertices Around it and then use Ctrl+X to dissolve the bad one. You should be left with this:

Then you can add your Bevel Modifier, Use these settings:
, most importantly, Setting the Bevel method to Angle, otherwise it bevels every single edge, and set the Outer Miter to Arc to smooth out the sharp corners. Set the model to Smooth Shaded, check Harden Normals on the Bevel Modifier and you get this:

Let me know if you have any other questions!


Animated textures don't work in Blender viewport playback

It is a very, very, very, very well known limitation of the current system.

Viewport shaders are optimized for speed and performance for smooth playback and as responsive interaction as possible during animations.

Animated materials and textures require shader re-compilation, and this is a computationally expensive and resource heavy task, that is generally preformed on the CPU rather than the graphics card). Recompiling requires constant re-upload and sending data back and forth from the CPU to the GPU which is comparatively slow.

As such, they are pre-compiled before playback to avoid constant updates or refreshes, and during this process animations are suppressed to achieve faster updates and increased smoothness during playback.

It is a limitation that will likely be overcome in future 2.8 versions of Blender and the redesigned EEVEE viewport engine.

That being said, if you plan on rendering using the OpenGL renderer whether for your final output or animation previews, offline rendering will effectively update the animated materials and correctly render your movie.

If you only have a sequence of images or a movie strip as texture just turn on the option Auto Update in the image texture node


Inset while keeping part of the shape intact

One simple way is to temporarily extrude the shape and inset part of extrusion which will create edges on the boundary. So instead of a plane:

You use the same form but extruded (or just extrude one edge where you need edges to touch the boundary)

Then select top faces plus one on the side and run Inset:

Dissolve unnecessary edges on the side as required (or delete bottom vertices to get rid of extrusion), note that dissolving might create Ngons which are better to avoid.


The circle and the different movement speed tells me that you have proportional editing enabled by accident. In the old days, this was only available in Edit Mode for meshes, now it's available in many places. You are using it in Object Mode.

Blender goes through your selected objects and checks whether any other objects are within this sphere (shown as a circle) put around all your selected Object Origins, in your case a cylinder. If it finds any, they get moved, rotated or scaled proportionally with your selection depending on what you do. Shortcut is O. You can disable it here:

https://docs.blender.org/manual/en/dev/editors/3dview/object/editing/transform/control/proportional_edit.html


Transforming Blender Render Textures to Cycles Textures

I'm not sure what you mean by eliminating noise in Blender Render if you are moving to cycles, but if you are looking to remove noise in cycles, there is already several answers in Blender StackExchange FAQ: Frequently Asked Questions on Blender Stack Exchange

BlenderGuru made also a great article about the topic: https://www.blenderguru.com/articles/7-ways-get-rid-fireflies/

For the second question, by looking at your texture I assume you want pixelated look. Answer is very simple, you can turn back your mips and get rid of the filter. All you need to do is set Sampling, the second field under the image name field currently have set as Linear to Closest.


Blender 2.8 Cycles Denoiser produces banding

There is banding in both your pictures. I increased the contrast so you can see clearly on any display:

You remove banding by introducing noise, the process is called dithering:

Rendered image shows visible "line strokes" artefacts

So the denoiser removed the noise making the banding more visible. If you'd save that in 16bit and view on 12bit display using quadro graphics there would be no visible banding.

If you'd render the image without denoiser for a lot more samples to clear the noise, you'd see the same banding problem.

If you want to have smooth looking gradients on 8bit displays you need to use dithering (introduce noise). This can be noise from Cycles itself (to be perfect Maxwell produces more natural noise for example), or if you get rid of the noise with denoiser a noise introduced in postproduction through dithering.


How to cut all faces in a specific direction from a point?

I'd would use a boolean modifier to go around this. It's a pretty easy way, not quite with the script though but works.
Start  by creating a very thin cube and rotating it by any angle you want, but make sure its cutting through all your mesh. Then give your icosphere a boolean modifier and set this new cube you have created as the mesh to use for boolean operation, don't forget to set the operation to difference.

p.s. It won't work with a plane as a boolean, only cube, just like that:


Selecting the top edge of the trapezium is most easily done in Vertex mode - select both ends and switch back to Edge mode. But even then, TinyCad is a bit of a long way round, here.

Vertices must somehow be cut (topologically) into the bottom edge of the rectangle, so alternatives include:

With Snap set to 'Active' and 'Vertex' and Automerge switched on:
AltD duplicate the bottom vertices of the rectangle in their edge, and drag them any old where..
Snap them onto the top vertices of the trapezium

On the whole though, when modeling, you would want the extra edges in the rectangle. If so..

CtrlR and scroll, cut 2 edge-loops into the rectangle
With Snap and Automerge set as before, and your Pivot set to 'Median', in Vertex mode, with one of the new loop vertices active...
SX the new loops, snapping to one of the top vertices of the trapezium.

These are by no means the 'right' ways of doing this.. I'm sure you have/will have your own grab-bag of favorite modeling patterns.


Why is my imported object transparent when rendered?

Check your materials and see if there's any alpha values applied on the objects. It does look like it comes from the materials


I need to add a perspective grid in orthographic view for grease pencil layer

Steps to make a dynamic non-destructive 2d grid in blender:-

  Add a Plane
  Add a SubSurf modifier
  Change the subdivision algorithm to simple
  Add a Wireframe modifier
  Tweak the subdivision levels and the wireframe thickness to adjust grid size and density

Here's the blend file:-

  I have added a Shadeless material to the grid for easier viewing which may suit your purpose.


The dock should be rather easy to make.

Add > Mesh > Cube and enter the plank dimensions (3600x200x50)
Then go Apply > Scale
Now add the Array modifier (to duplicate your planks)
Use the same principles to create the rails and the bottom floating part

Planks made using Array modifier

Bottom part

Final model


How to search for object in group list? - Animation Nodes

You can use the Object By Name node to get the required object. If you want to check if it is in the group, you can use an expression node like this:


OK, after some more experimentation, the only explanation I can find is that the author of the node group wished the input to be a slider instead of simply a value. Perhaps this makes sense, since the values should be between zero to one.
Does anyone else find some other explanation?


Is the AMD Radeon RX 5700 XT with Navi 10 compatible with Blender 2.81 on Linux?

Yes, you need OpenCL capable Drivers. Install theese ontop of amdgpu.

https://www.amd.com/de/support/kb/release-notes/rn-amdgpu-unified-navi-linux


IK constraint rotates the wrong direction

You have a few issues:

In Edit Mode, select mixamorig:LeftUpLeg. Under Bone:Transform uncheck lock, or the rest won't work.
In Edit Mode, select the root of mixamorig:LeftUpLeg and the tail of mixamorig:LeftLeg. Shift+S, Cursor to Selected.  This will place the cursor directly between the two.  Select the root of mixamorig:LeftLeg (the "knee") and Shift+S Selected to Cursor.  This will snap it right to the middle. From the right view, move it a bit forwards.  Part of your issue is that you have the initial position with the knee bending inside.  Having a slight bend forwards will help the IK solve correctly.

Select mixamorig:LeftUpLeg and mixamorig:LeftLeg. In Edit Mode, hit Control+N and recalculate the roll angles to "Global X Axis."  This'll align the Z to the X axis, keeping the bone X axis facing forwards.
In Edit Mode, select the whole bone mixamorig:LeftLegCtrl. With the cursor still at the knee, Shift+S Snap Selected to Cursor. The pole vector bone will snap its base to the knee.  Move it forwards a ways from the right view.
Assign the pole vector object to the IK contstraint on mixamorig:LeftLeg.

Once that's all done the IK should work fine.


Generating hooked curve through "n" number of points with python

import bpy
from mathutils import Vector
cubes = [ob for ob in bpy.context.scene.objects if ob.name.startswith('Cube')]
spline = bpy.context.active_object
length = len(spline.data.splines[0].points)
for i in range(length):
    bpy.ops.curve.select_all(action='DESELECT')
    point = spline.data.splines[0].points[i]
    cube = cubes[i]
    point.select = True
    point.co = Vector((cube.location.x, cube.location.y, cube.location.z, 1))
    cube.select_set(True)
    bpy.ops.object.hook_add_selob(use_bone=False)
    cube.select_set(False)

It's a bit quick and dirty, so here are the preparations you need to do:

The scripts selects the cubes by name, in alphabetical order. If any object in your scene starts with 'Cube' (e.g. Cube.001), it will be added to the cube array. There are more elegant ways to select a group of objects, but this was the simplest one.
You need at least as many cubes as the spline has points.
You need to select the curve and go into Edit Mode before running the script.


Disable Tweak mode / hide screen space transform gizmos?

You can turn off the gizmos completely using the Overlays options at the top of the screen. I personally have them off because they don't serve much purpose once you're committed to the use of hotkeys to do all your transforms.


Curved arrow of variable thickness to connect to objects

I think you're looking for a scripted solution which allows you to define two points and the direction of the Curve. Remember; the thickness and colour of such Curves can be animated at a later stage, and the Arrow or 'direction indicator' of the Curve is another matter.

The concept is each box you want to connect has an edge which will be a terminal for the Curve.

Exactly how you determine the length of these virtual guide lines is up to you, it could be some factor of the relative distance between the two terminals on the boxes -- really that's down to taste.

The script would create something like this, if you give it two terminal coordinates, and a direction for each.

If you look at the source of the TubeTool addon you'd get a fair idea of how to script it, but the core of the code is this snippet.

import bpy
from mathutils import Vector

def add_curve(medians, normals, curvename, amp=2):
    curvedata = bpy.data.curves.new(name=curvename, type='CURVE')
    curvedata.dimensions = '3D'

    obj = bpy.data.objects.new('Obj'+curvename, curvedata)
    obj.location = (0,0,0) #object origin
    bpy.context.scene.objects.link(obj)

    polyline = curvedata.splines.new('BEZIER')
    polyline.bezier_points.add(1)
    #   polyline.use_smooth = False

    # obj.data.fill_mode = 'FULL'
    # obj.data.bevel_depth = 0.1
    # obj.data.bevel_resolution = 4
    point = polyline.bezier_points[0]
    co = medians[0]

    point.co = co
    point.handle_left = co - (normals[0]*amp)
    point.handle_right = co + (normals[0]*amp)

    point = polyline.bezier_points[1]
    co = medians[1]
    point.co = co
    point.handle_right = co - (normals[1]*amp)
    point.handle_left = co + (normals[1]*amp)

    polyline.order_u = len(polyline.points)-1

medians = [Vector((-2, 0, 0)), Vector((2,3,0))]
normals = [Vector((0, 2, 0)), Vector(( -2, 0, 0))]
add_curve(medians, normals, "curvename", amp=1.2)

And that gives (with the extras commented out, like thickness) this:

medians: Absolute coordinates, Vectors. (Location)
normals: Relative to the median they're associated with. (Direction, and Distance away from Location)
amp:  'push factor' for the control point. The amp parameter pushes the control points along the normals, effectively scaling the control points to be further away or closer to the terminal)


Blender Sculpt brushes don't function properly

I was having this issue too. I don't know why this is occurring but I can confirm that Mr Zak's solution worked for me.

To clarify on his instruction:

Create a backup of your work
Switch to object mode
Select only the model you want to sculpt (you can only choose one at
a time)
Press Ctrl + A
Select Scale from the pop-up menu

The fix is complete and you may now switch back to sculpting if you wish.


What is the best way to convert VRay Reflection Maps to Roughness?

You can adjust the colors with a ColorRamp node.
The result won't be the same, but you can get close.
Left: Roughness Map
Right: Reflection map adjusted with ColorRamp


How to make grass respond to an object hitting them

Final:

Overview:

Whole process is very easy. You will only need to make your grass object as Cloth or Soft Body (with Weight Paint) then Convert Particle System to mesh and delete Particle Emitter as it will not longer be needed. Then add to your Cube Collision.

First of all you will need to choose if you want to use Cloth or Soft Body. Quick test shows me that Cloth simulation is fairly faster, but Soft Body will give you probably more options, as Plastics, Edge Stiffness and such.

Secondly I don't know why (and maybe someone can correct me) when your object is in Particle System simulation works, but Pinning/Soft Body Goal won't. Maybe it's a bug or maybe there is an explanation.

  Note: Below steps could vary from your scene setup so don't take them
  as granted. I will point out most important settings and you could
  tweak them for your needs.

Steps:

Grass strand.

You will need to Weight Paint your grass strand. Red is stiff, green is... less stiff. You can experiment with this as you like to make grass really soft or hard.
Add to your object Cloth Simulation. I have used settings as you can see on the image. Most important things here are:

Mass - it should be really low, higher will make grass to lay on the ground,
Pinning - from Weight Paint, it will keep grass strong at the bottom and weak at the top, or not if you painted it differently,
Velocity - how fast grass will return to base position,
Cloth Collision - check also Self Collision, there are lots of them so it will make simulation more realistic.

Particle Emitter.

Nothing special here, only after setting your grass go to Modifier Tab and Convert Particles then delete Particle Emitter.

Blend file:


Creating vertices at mouse position is very off

Add vert on left mouse click

Further to this answer added code to add vertex on left mouse click. (Using method explained here)  Added a list to class to hold the newly added vertices, as suggested via this question.

Things to note:

Vertex coordinates are  local coordinates, whereas the calculated 3d cursor position is a global coordinate. To convert global to local the global vector is multiplied by the objects matrix world inverted.

A class property for the matrix world inverted, similar to setting cls.bm for bmesh to avoid inverting the matrix each time.

When writing operators or panels, very rarely (if ever) do you need to access context via bpy.context.  If context is an argument use it.  I often use context = bpy.context atop of test scripts as a convenient way to later copy / paste into code where context is defined.

import bpy
import bmesh
from bpy_extras.view3d_utils import region_2d_to_location_3d

bmeshes = {}

class Modal(bpy.types.Operator):
    bl_idname = "object.modal"
    bl_label = "Modal Op"
    bl_description = "Other thingy"
    bl_options = {"REGISTER"}

    bm = None
    added_verts = []

    @classmethod
    def poll(cls, context):
        return context.object and context.object.type == 'MESH'

    @classmethod
    def bmesh(cls, context):
        me = context.edit_object.data
        cls.bm = bmesh.from_edit_mesh(me)

    def invoke(self, context, event):
        bpy.ops.object.mode_set(mode='EDIT')
        self.bmesh(context)
        context.window_manager.modal_handler_add(self)
        return {"RUNNING_MODAL"}

    def add_vert(self, loc):
        v = self.bm.verts.new(loc)
        self.added_verts.append(v)

        return v

    def modal(self, context, event):
        # no longer in edit mode
        if context.mode != 'EDIT_MESH':
            self.bm.free()
            self.bm = None
            return {'CANCELLED'}
        ob = context.edit_object
        me = ob.data
        if self.bm is None or not self.bm.is_valid:
            # in edit mode so try make a new bmesh
            self.bmesh(context)
        if event.type == "LEFTMOUSE" and event.value == "PRESS":

            x, y = event.mouse_region_x, event.mouse_region_y
            region = context.region
            rv3d = context.space_data.region_3d

            loc = region_2d_to_location_3d(region, rv3d, (x, y), (0, 0, 0))

            v = self.add_vert(ob.matrix_world.inverted() * loc)
            v.select = True

        if event.type in {"RIGHTMOUSE", "ESC"}:
            self.bm.verts.index_update()
            bmesh.update_edit_mesh(me)
            print("added", self.added_verts)
            return {"CANCELLED"}

        if event.type in ["WHEELUPMOUSE","WHEELDOWNMOUSE","MIDDLEMOUSE","LEFTMOUSE"]:
            return{"PASS_THROUGH"}

        return {"RUNNING_MODAL"}

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

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

if __name__ == "__main__":
    register()

Btw. If you put minimal working code into your question it would be a lot easier to work out where your particular mistake is.


Modify multiple objects at the same time (f.ex.: 8)

Objects can have the same object data.

It introduces some constraints. Like if you what to have different materials for those objects, the materials should be linked to the object, not to the object data.


My first idea is than you have "Snap tool" ON. Check Magnet icon (in horshoe shape) on 3D Viwe bottom bar. Next to "Proportional editing". Keyshort is "Shif+Tab". Can be easily switched accidentally.

If this don't help you, consider uploading your .blend. Because we can only guess now.


Add a single driver to the cube (e.g. Z-rotation)
Go to Graph Editor and switch to Drivers mode
Set Ob/Bone of the variable var to reference the Empty
Enter the Expression var/2 (or var*0.5)

var is equal to the X Location of the Empty, dividing it by 2 halves the "influence" of the location to the rotation of the Cube.


⬅
(I realised too late that this is annoyingly slow. It can be easily fixed by speeding up the Empty's animation and by increasing the number of emitted particles per unit time)
Wobbliness

Add an Empty to your scene, and animate it in some ways using only rotation al location keyframes. You will use this empty to drive the coordinate space for the ripples on the blob's surface.

On your UV sphere, add a "Displace" modifier:

Set the Texture coordinates to "Object" and the Object to your Empty. Reduce the strength to around 0.4. Select "New texture" in the modifier, then go on the "texture" tab and select Type = "Clouds" and Size = 5.

The empty and the Displace texture, combined, will give a result similar to this:

Bubbles

Create another UV sphere and place it on a different Layer.

Select your main sphere, and add a Particle System. Apart from the default values, use Emission Number = 20; Use Modifier Stack = Yes; Render type "Object"; Dupli Object = ; Size = 0.500; Random Size = 0.600; Field Weights Gravity = -1

Bake the Particle cache and this is the result:

For enhanced smoothness
The two spheres can be Metaballs instead of UV spheres, but achieving the wobbliness would become more difficult


Is there a way to capture the viewport in Blender the same way as it is on 3DS Max?

You can perform an OpenGL render. Simply press the little camera in the 3d view header or go to Render > OpenGL Render Image. It will render out a snapshot of your current view as it is, no cameras or lights needed. You can also change the world settings if the default gray is too bland and also the resolution. More info on the relevant wiki page.


Making a property change when an animation ends?

Actuator sensor

The actuator sensor can tell you when an actuator deactivates. In your case it can listen to your action actuator.

Remarks:

Ensure to evaluate the sensor status after the observed actuator gets activated. Otherwise you might trigger the next operation before the action actuator even started to play something.

Frame property

The action actuator allows you to setup a property to receive the currently played action frame. With a property sensor you can sense over that property to act according to the current frame.

Remarks:

To measure the end of an animation, you need to setup the end frame twice (at the action sensor and at the action actuator)
Frames are no integer. Any equal checks will fail. You need to perform range checks.

Frame counter / Time measurement

Establish a setup that constantly increases a property by one. This enables you to trigger actuators after certain frames.

Remarks:

There is no direct relationship between counted frames and animation
You need to be sure that the counted frame number matches what you are measuring (the duration of the animation).


is .blend file size proportional to the unit settings?

It comes down to the information needed to describe the scene.

When you have modifiers, you only store the input mesh and the settings of modifiers. So in the case of subdivision modifier (for example) you save only the low-polygon mesh and a number indicating how many subdivisions there are. When you open the file, Blender generates all the subdivided vertices and displays them - they are kept in system RAM when the file is open, but not saved when you save the file.

When you apply the modifier(s) all that generated geometry becomes real - you can change each vertex individually. The information how to generate all that is lost because the modifier is gone. So when you save the file, Blender needs to save all the geometry.

Unit settings have no effect for file size, you are saving the same amount of values. The values themselves are just different (instead of saving the number 1.5 you save 3.81 - inch vs cm). Blender stores all these numbers as 32bit floats so no matter the value they occupy the same space in memory: 32bits = 4 bytes for each.


For the controller, check the Ghost option under the physics tab. This will cause the object to still fall, but there won't be any collisions. You can also parent the character to the controller without having do a major freak-out.


Transparent Background in Lower Third for Export to Different Program

Try setting your output to ffmpeg + Quicktime + PNG:

In the Sequencer View menu select Sequence Render Animation:


Is there a way to remove dublicate objects on top of each other in Object Mode?

If they have the same names they probably have a trailing .00x number behind them. So you could just pick them from the outliner and delete them.

alternatively select the ones you want to keep > ctrl + i to invert selection and delete.


Is there a way to use renderman in blender?

There is now a public release of a Renderman plugin for Blender. Maintained in part by folks from Pixar.

Official intro to RenderMan for Blender: https://community.renderman.pixar.com/article/906/introduction-to-prman-for-blender.html

Also see PRMan for Blender Support thread:
https://renderman.pixar.com/forum/showthread.php?s=&threadid=28298


You will have to delete the strips in the Video Sequence editor windows.
Rendering to windows will work after you removed them.

What happened?

Basically the creator of the blend file have already rendered out the sequence of frames on his computer. He has also imported them as sequence strips into the video sequence editor for editing and then planned to output them into a movie file. When you downloaded the file, those film strips are targeted to render out when you hit the render button. Since those sequence file are not pack within the blend file ... you would get transparent frames.

Note what cegaton said below in the comment would also work.


How to increase number of visible hairs in particle edit mode?

could it be that you have children visualized (default enabled in quick fur)?

this is with children, as in quick fur, and they are visible only in object/render mode (I think there's no way to visualize children during editmode). You could convert from the modifier panel to a real mesh, perhaps, so that children become "real", but you'll loose particle behaviour...

which in particle edit mode becomes

and this is the same mesh without children, in object and edit mode


Select two vertices in Edit mode and type
s0

Explanation:

(Scale 0)

In the image below the tool tip indicates the median point is used for this user operation.

The gold planes had the same relative positions as the cyan planes.  The steps written above were applied to place the vertices in the same location.


blender not responding while pinning the image in facebuilder addon

It looks like you have a video card that does not support the necessary OpenGL shaders. You must reinstall the video drivers. But you can’t do anything with some graphics cards such as those made by Intel.


How to convert a CSV file to 3D Text objects with Python?

Try this:

import bpy # THIS IS A MUST TO IMPORT ALL BLENDER PYTHON MODULE
import csv # IMPORT CSV MODULE

# READ INPUT FILE

fp   = 'D:\daves\WBD\wbd filtered text'
file = csv.reader( open( fp, newline='' ), delimiter=',' )

nameIdx = 6 # Column index of text object's name
bodyIdx = 7 # Column index of text object's body (content)

for idx, row in enumerate( file ):
    if idx < 22: # this is hard coded but you can use
        # display first data index as string
        bpy.ops.object.text_add(location=(0,idx*2,0), rotation=(0,0,0))

        # After the line above is executed, the added text object becomes
        # the active object, referenced as the bpy.context.object
        # 't' will become a shortcut variable to access this object
        t = bpy.context.object

        # Access and alter the text object's name
        # This will be reflected in the outliner and object properties panel
        t.name = row[ nameIdx ]

        # Often in blender, the 'data' property holds specitic data
        # related to the object's type. For instance, a polygonal mesh
        # object's data property hold data about vertices, edges and polygons
        # among other things.
        # A text object's data stores the "body" property, which is the
        # actual text content of the text object. In this line we are
        # updating the text content, and assigning it the name, a newline
        # character and then the title.
        t.data.body = row[ nameIdx ] + "\n" + row[ bodyIdx ].upper()

For simplicity's sake I combined the name and title to one text object (with a newline special character "\n" between them), but you can of course simply generate another text object and offset its position with a variation of this code.


Can I personalize the insert keyframe menu?

Yes, it's done using Keying Sets:

Types of Keying Sets
There are basically two types of Keying Set in Blender: "Builtin" and "Absolute".
Builtin are the ones that are always available (context permitting) in Blender. They are the (familiar) ones that show up in the IKEY menu by default - "Location", "Rotation", "Scaling", and friends. All you generally need to know about these are that they are defined using in Python so that they can check the context to see what properties they should act on. This means that you CAN'T add/remove properties from them yourself unless you edit the Python code which determines what they use. If you're curious to add a few more 'builtins' that you commonly like to use, you can find these under scripts/keyingsets/ in your install directory. Be aware though that the attempts at making these definitions quite "modular" may initially be a little confusing for novice/beginner Python programmers, though they should still be quite easy to grasp. The topic of setting these up shall be left as an exercise to the reader and/or a future post :)
Absolute are the ones that you should be most interested in, as they are the "user-defined" Keying Sets, and are stored per Scene (that they are defined for). By setting up and using these carefully, you can improve your workflow quite a bit. Used appropriately, you can insert keyframes for a whole bunch of related properties with the touch of a key (or single click if you like), saving frustration from forgetting to key one of a bunch of properties and saving time jumping around keying multiple things separately. This has significant benefits, especially for the modern character animator working in the standard pose-to-pose full-pose blocking method, where keying every single control on every key-pose at once is the método comodo.

See the documentation written by the developer of this feature for more info:

Getting to grips with Keying Sets
Coding your own "Builtin Keying Set"


why i cant create a hole with bool tool addon

Geometry is too much complex.
Change Overlap Threshold in Boolean Modifier to zero.


No, blender rally can't do this,
but solution for now calls fSpy:

https://fspy.io/

Standalone application with blender plugin.
Formerly known as Blam.


How to fade one material into the other?

A mesh face cannot be assigned to several materials. So you'll need to "incorporate" one of the material nodes into the other.

For convenience I have set face nodes/shader and lip nodes/shader each in a dedicated nodes group. That allows to use them both in your face or lips original materials. Doing so, imagine that 'as if' these nodes groups were replacing your initial materials.

Now select you lips faces and one ring more around. And assign these faces to a new UV map (called 'LipsIntensity' in the screen capture (1)).

Create a blank image (2).

Put your original face and mouth nodes respectively in a node group (select and group all the nodes except the output for each). So that you can reuse them (mainly the face shader) in the lips material (3 and arrows).
Now mix them so that the mix (4) factor is driven by the texture you added and itself based on the 'LipsIntensity' UV map (5).

Now go in the 3D view (6) and in texture paint mode and rendered mode. Make sure that your are painting on the 'LipsIntensity' texture (look at 'Available paint slots' in the 'Slot' panel of the texture paint mode).

Now simply paint in black over the lips, with a relatively large brush in order to obtain the ease you want (7 / 8).


Might it be possible to use scripts in blender to do what Mandelbulber does?

Sure you can generate such fractals at finite poly resolution.

You just need to figure out the fractal math and positions of vertices. Then you can build such mesh in python with the BMesh module.


IK control bone not rotating linked bone when behind it

The movements are limited by the IK settings for the lower leg bones. That is the IK settings not the IK Constraint settings. While in pose mode select the lower leg bone and you will find an Inverse Kinematics panel under bone properties.

There you have enabled a limit and set it to 0-90 degrees for the x-axis. While this does seem like a reasonable setting, it is causing the upper bone to take the rotation when the rotation of the lower leg could be negative.


Could someone please explain gimbal lock?

I gather that it's an inherent weakness of just storing three axial rotations (Quaternion, on the other hand, also evaluates orientation value).

(Per ideasman42's comment): We can easily see this for any object using Euler rotational system, by manipulating the rotation widget with transformation orientation set to Gimbal. It turns out to be easy to reproduce, by manipulating 2nd axis in the evaluation order (Z for XZY, or X for ZXY, etc.). I get the following condition on XYZ order by just manipulating Y axis:

Here's an article and a video for alternative explanations of the condition.


You can either reate a b&w ovale image that you'll use as a mask for your bottle material, or create an object for the label itselt. In that case you can use the Knife Project tool:

Create a plane, subdivide vertically. Create another object, a circle that you stretch on the Z axis and that you put in front of the plane:

In Object mode, select the ovale, shift select the plane, switch to Edit mode, go in front view and in the header menu > Mesh > Knife Project:

It has cut the ovale shape on the plane. Ctrli to invert the selection and delete the edges to keep the ovale:

Apply the Rotation of your label, give it a Simple Deform modifier / Bend mode, bend as much as you want on the Z axis, give it a Solidify modifier if you want:

Or (but it will be less accurate as it's an anamorphosis):

Duplicate your bottle, create an circle in front of it that you stretch on the Z axis:

Select the ovale, shift select the bottle, switch to Edit mode, go in front view:

Go in the header menu > Mesh > Knife Project:

The ovale shape has been printed on the bottle, you can keep the ovale and delete the rest with Ctrli to invert the selection and X > Delete Faces. Then you can give it thickness with a Solidify modifier.


as @CoDEmanX noted you can disable the depth test with bgl.glDisable(bgl.GL_DEPTH_TEST) while drawing and use the POST_VIEW.

here is an example code of a modified draw modal operator :

import bpy
import bgl
import blf
from mathutils import Vector
from bpy_extras import view3d_utils

def draw_callback_px(self, context, points):

    bgl.glEnable(bgl.GL_BLEND)
    bgl.glColor4f(1.0, 1.0, 1.0, 1.0)
    bgl.glLineWidth(2)
    bgl.glDisable(bgl.GL_DEPTH_TEST)

    bgl.glBegin(bgl.GL_LINE_STRIP)
    for x, y, z in self.points:
        bgl.glVertex3f(x, y, z)
    bgl.glEnd()

    # restore opengl defaults
    bgl.glLineWidth(1)
    bgl.glDisable(bgl.GL_BLEND)
    bgl.glEnable(bgl.GL_DEPTH_TEST)
    bgl.glColor4f(0.0, 0.0, 0.0, 1.0)

class ModalDrawOperator(bpy.types.Operator):
    """Draw a line with the mouse"""
    bl_idname = "view3d.modal_operator"
    bl_label = "Simple Modal View3D Operator"

    def modal(self, context, event):
        context.area.tag_redraw()

        if event.type == 'LEFTMOUSE':
            if event.value == 'RELEASE':
                co_2d = Vector((event.mouse_region_x, event.mouse_region_y))
                viewport = context.area.regions[4]
                r3d = context.area.spaces[0].region_3d
                nor =  view3d_utils.region_2d_to_vector_3d(viewport, r3d, co_2d)
                v3 =  view3d_utils.region_2d_to_location_3d(viewport, r3d, co_2d, nor)

                self.points.append(v3)

        elif event.type in {'RIGHTMOUSE', 'ESC'}:
            bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW')
            return {'CANCELLED'}

        return {'RUNNING_MODAL'}

    def invoke(self, context, event):
        if context.area.type == 'VIEW_3D':
            self.points = []
            args = (self, context, self.points)
            self._handle = bpy.types.SpaceView3D.draw_handler_add(draw_callback_px, args, 'WINDOW', 'POST_VIEW')
            context.window_manager.modal_handler_add(self)
            return {'RUNNING_MODAL'}
        else:
            self.report({'WARNING'}, "View3D not found, cannot run operator")
            return {'CANCELLED'}

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

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

if __name__ == "__main__":
    register()


press O then scale it will work just fine
you are enabling proportional editing
make sure you  turn it off


JPG decompressed and compressed again, will it affect colors and color space?

The color space is the same: sRGB, so expect no transformation there, but know that Jpeg is a compressed format, a lossy compression format designed to make file sizes small at the expense of quality. A terrible format if you are applying transformations.

Every time you decompress an image, change the geometry or color, and re-compress the image again you will get new compression artifacts. Do an image search for "macroblocking" and "compression artifacts" to understand the horrors of the JPEG format.


How can I create a shortcut to activate / deactivate multiple checkboxes?

Here's the script to do it. It currently toggles Backface Culling, MatCap, and Ambient Occlusion. I don't think there's a Normal toggle in object mode. did you mean in Edit Mode, toggling Face/Vertex Normals?

I've set up a key command to use SHIFT+SPACE but you can change that if you want.

import bpy

def main(context):

    area = bpy.context.area

    if area.type == 'VIEW_3D':
        bpy.context.space_data.show_backface_culling = not bpy.context.space_data.show_backface_culling
        bpy.context.space_data.use_matcap = not bpy.context.space_data.use_matcap
        bpy.context.space_data.fx_settings.use_ssao = not bpy.context.space_data.fx_settings.use_ssao

class opToggleCheckboxes(bpy.types.Operator):
    """Tooltip"""
    bl_idname = "object.toggle_checkboxes"
    bl_label = "Toggle Checkboxes"

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

    def execute(self, context):
        main(context)
        return {'FINISHED'}

addon_keymaps = []

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

    # handle the keymap
    wm = bpy.context.window_manager
    km = wm.keyconfigs.active.keymaps['3D View']
    kmi = km.keymap_items.new(opToggleCheckboxes.bl_idname, 'SPACE', 'PRESS', shift=True)
    addon_keymaps.append(km)

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

    # handle the keymap
    wm = bpy.context.window_manager
    for km in addon_keymaps:
        wm.keyconfigs.addon.keymaps.remove(km)
    # clear the list
    del addon_keymaps[:]

if __name__ == "__main__":
    register()


Blender: How do I unpack a linked instance to make changes to it?

If you have imported a linked collection, you need first to select it and CtrlA > Make Instances Real, then select one of its objects and in the header menu > Object > Relations >  Make Local > Object & Data.


How can I make a cylindrical outline to a mesh (2.9)

One way of doing this would be to start with your base shape (this is an obviously simplified version):

Use insets and/or edge loops to give a "seam" to your edges.

Select the "seam edges", right-click and select "Extrude Faces Along Normals" and drag the mouse to bring out the edges to your desired depth. You may also want to check "offset even" in the operator panel in the bottom left corner.

Once you have the desired width/depth to your "Seams", add a Subdivision Surface Modifier to round them out. Don't forget to shade smooth.


That's not something you can do AFAIK. You could try to block out the feathering of the light with a shadow created by another mesh aperture, but even then you have to deal with diffraction of light around the corners. That just isn't how light works.

For example, see this monochromatic light that diffracts when passing through a small aperture:

I'd suggest you look at the rest of the Wikipedia article where that image came from.

The Cycles behavior is relatively consistent (although it appears to only have the central diffraction maxima):

As far as the amount of light spread, you may be interested in the lamp size property. From the Blender manual:

  Size of the lamp in Blender Units; increasing this will result in softer shadows and shading.


Way for delete all object inside an Collection "Mycoll" in blender 2.8

Unlink an object to remove it from a collection.

Py console code, for example sake, creates a new collection that is a copy of "Collection 1".  It contains the default file objects "Cube" "Camera" and "Lamp", and like the original is a child of scene collection.

>>> mycol = D.collections['Collection 1'].copy()
>>> mycol.name
'Collection 1.002'

>>> mycol.objects[:]
[bpy.data.objects['Cube'], bpy.data.objects['Lamp'], bpy.data.objects['Camera']]

To get by name and remove the "Cube" object from collection. (If there is no object named "Cube" in collection get returns None)

>>> cube = mycol.objects.get("Cube")
>>> # remove it from collection
>>> mycol.objects.unlink(cube)
>>> mycol.objects[:]
[bpy.data.objects['Lamp'], bpy.data.objects['Camera']]

Loop thru and empty the whole collection.  Note mycol.objects is boolean False when emtpy.

>>> while mycol.objects:
...     mycol.objects.unlink(mycol.objects[0])
...
>>> mycol.objects[:]
[]

To remove the object ob  from file use bpy.data.objects.remove(ob, do_unlink=True)  Unlinking do_unlink=Trueis the default, and hence can be left out, will unlink from the collection, and all others containing this object, for you.


How to draw circle or rectangle or arrow in blender video editor?

Here is what I do (or something similar, as I use this tactic to position more videos for people to click on), you can create a simple box with transparency around it (though make sure that the image format you save it as has support for alpha, png should work):

Get your image onto your sequencer (drag in the image, or Shift + A).

Select your image (Right click), and press Shift + A , then choose Effect Strip, and then Transform.

Select the Transform block/strip, then over on the right, choose
Alpha Over instead of Replace.

Change the position and scale settings on the right, in the Effect Strip


Set the flow source on the emitter within the domain to Particle System, and select your particle system.

You can then set the size of those particles below. It will always be a spherical inflow shape, it doesn't take in account any object you set as the particle render shape.


Animation Nodes: How to create splines from two different points in order to create procedural telegraph poles?

The Rotation To Direction node can be used to get a vector pointing along the local x axis of the objects, This direction is then added to the location of the object giving you point one, the inverse of that vector is added to the location giving you point two. You now have two points per object, use them in your node tree.


Currently you have a maximum of 4 transparency bounces:

So after 4 transparent surfaces overlap you will get errors.

You need to increase the number of transparency bounces so that there are as many as transparent surfaces a ray has to go throuugh:


Is it possible to have different background images for different visible layers?

This isn't possible by default with the Background Images subset in the Properties panel, whichever image you have set to a view is what will show across all layers.

An alternative however is to use Empties with their Display type set to Image as detailed in my answer here. This way you can just move the specific empty with the blueprint to the layer with the object you are working on. To have this not obscure or interfere with your work, just open the Outliner and restrict these from being selected (the cursor icon).

(Notice that I switch from Layer 1 to Layer 2)

A similar method to the above is to enable the Import Images as Planes addon and create two planes, one for each image. These can be placed in any layer, and display of the images can be enabled or disabled separately for each image by using the outliner window, or by careful placement of the planes in layers, and enabling or disabling the visibility of the layer.


Altering transparency / thickness of rising smoke

Use a Gradient texture to control the mix between the smoke density and a transparent shader.

You can use generated coordinates and a mapping node to control the placement. In this case note the rotation on the $Y$ axis.

After the Gradient texture you can use color ramp to control the placement for the transparency.


How to make blender confirm closing an unsaved file?

Open File > User Preferences (Ctrl + Alt + U), under Interface tab on the lower left Prompt Quit


How do I make an object emit from different points, and animate the emission location?

Create a Particle System and use either the Dynamic Paint or the Point Density in Cycles. Both can create exacly what you want with some additional Material tweaking.


It can be converted into a curve ( Object Mode > AltC > Curve from Mesh ) and then have its bevel and profile modified in various ways


Try using the subdivision surface modifier. I don’t know if shade smooth works in render. Or just in the viewport.


Mirror-ball for fisheye effect with orthographic camera

The sensor size or camera object scale has no effect on the projection. It works like this:

It's the camera plane (the base of the pyramid shape) projected into the scene.

render resolution sets the plane's sides ratio
orthographic scale sets the plane size, scale of 1.0 means the camera's plane is 1.0 units wide

You can calculate the camera corners with python:

Export rendered image corners coordinates

You will get them at camera origin where the sensor is, not where the camera border is displayed in viewport. Since the projection is orthogonal this should not matter.


Blender 2.8: how to cut non visible edges?

To cut through, press Z just after you've activated the knife.

And press C to cut perpendicularly to the view and ctrl to cut an edge by its center.


Objects are 2 different sizes but scale says they're the same

Basically, object scale and Edit Mode scale are two different things. You likely scaled him in Edit Mode, so the object mode scale does not change. I would scale one of the two objects back down in Edit Mode (Tab) until they match up. Hope this helps!


Uf ...

Apply Scale Ctrl+A ... fixed painting, brush skipped all parts with even minimum slope.

Since painting worked fine without Displacement modifier I was just curious why you used Strength 3000 for such contrast displace map (usually 1 is more than enough). Than I saw your Scale ratio Terrain 7500 / 4500 / 1.

If you try to set Scale 1/1/1, you can see why brush could not handle that :)
Faces are too steep in original ratio. Brush probably thinks faces are on side or squeezed in such a small place to detect or what ever. Scale ratio cause quite a lot of issues in general.

BTW - the similar extreme is use for mesh as a one face for such kind of subdivision, I would suggest subdivide id few times in edit mode (first Ctrl+R to add loopcut in a midle so subdivision faces are square, not rectangle)


To unlink datablocks from the blend file hold Shift button and click on the X icon of the datablock. That will set the number of users to zero and it will not be saved in the blend file.

Remember to reload file after saving it.


You can set the index of the list to 0, iterate through all slots and override the context of material_slot_remove():

for obj in bpy.context.selected_editable_objects:
    obj.active_material_index = 0
    for i in range(len(obj.material_slots)):
        bpy.ops.object.material_slot_remove({'object': obj})


Hair emitter not following texture in correct places

In the comments Mr Zak provided an answer that turned out to be the correct answer:

In the particle system texture settings open the Mapping rollout and chech what option is choosed in the Coordinates dropdown. It is closed on your screenshot so it's not visible what option is used. Nodes won't control that.

To clarify, here's an image of that particular texture slot:


Plot single vertices based on xy coordinates from CSV file

I suppose the input data is a 2D grid with known max values.

Here, we start with a random input but seeing your question you know how to load data from a file.

The script below does the following:

Create random inputs (you'll use file data instead)
Create vertices and store the color value as Z coordinate
Create the face vertex indices
Make a mesh object from that
Scale the object along Z
Create a vertex colors layer
Assign the Z value of the vertices as vertex color
Link a prepared material to the object

That gives the following result:

import bpy
import bmesh
from mathutils import Vector, Matrix
from itertools import product
import random

# Generate a random grid of the given file
x_size = 20
y_size = 30
z_max = 256

# Vertices store the color values as Z
vertices = [Vector( (x, y, int(z_max * random.random())) ) for x, y in product( range(x_size), range(y_size) )]

# Get base face indices
face_basis = ((x * y_size) + y for (x, y) in product( range(x_size-1), range(y_size-1) ))

# Each face is a square for the base index turning around counterclockwise
faces = [(v, v + 1, v + y_size + 1, v + y_size) for v in face_basis]

# Create resulting object
name = "grid"
mesh = bpy.data.meshes.new( name )
obj = bpy.data.objects.new( name, mesh )

obj.data.from_pydata( vertices, [], faces )

# Scale it along Z
scale = 1.0 / z_max # Or set 0.0 here
obj.matrix_world = Matrix.Scale( scale, 4, (0, 0, 1) ) @ obj.matrix_world

# Smooth faces
for face in obj.data.polygons:
    face.use_smooth = True

# Get or create vertex colors data of the given name
vcol_name = "VCol"
vcol = obj.data.vertex_colors.get( vcol_name )
if not vcol:
    vcol = obj.data.vertex_colors.new( name = vcol_name )

# Assigns z values as vertex colors
for face in obj.data.polygons:
    for vertex_index, loop_index in zip( face.vertices, face.loop_indices ):
        intensity = obj.data.vertices[vertex_index].co.z / z_max
        vcol.data[loop_index].color = (intensity, intensity, intensity, 1)

# Get the prepared material
material_name = "Material"
material = bpy.data.materials.get( material_name )

# If found assign it to the object
if material:
    obj.data.materials.append( material )

# Link the object to the scene
bpy.context.scene.collection.objects.link( obj )

The material is the following:

It uses the created vertex color as input for a color ramp and use this color for shading:

As your question was about plotting vertices, you may want to rework the mesh manually or modify the script to have this kind of results:

Note:

An illustration for

# Vertices store the color values as Z
vertices = [Vector( (x, y, int(z_max * random.random())) ) for x, y in product( range(x_size), range(y_size) )]

# Get base face indices
face_basis = ((x * y_size) + y for (x, y) in product( range(x_size-1), range(y_size-1) ))


How can i animate multiple objects to give an explosion effect?

For a 'dumb' explosion effect, you could try keyframing the objects, then scale their centers, so they all move away from the center. This would give some control over the speed of the 'explosion'. But, this technique has no dynamics. So, the shrapnel would not react to other objects. but it might work well for mechanical drawings.

make sure the 'Manipulate Cneter Points' button is checked.

select all the objects. (I used Cube, applied 3 array modifiers, and separated loose parts.)

Add a keyframe with I-Key. select location.

Move to a later point in the timeline and Scale larger.

Add another keyframe.

The objects are 'exploded'.

If you have an object on center (0,0,0), it will not move. You can change this by scaling from the 3d cursor.


Why does my render not show my light source?

You have a sphere that is hidden in viewport but that will be rendered, as we see in the Outliner. Note that even if you move your sun inside it won't light your scene, the location of the sun is not taken into account, so you need to either hide your sphere in render or find another solution:


Select the edge with Alt+RMB, then hit Del or X > Dissolve Edges.


After Boolean union operation - correcting imperfections in joined mesh?

Shading artifacts is a common problem using the Boolean workflow. Using the bevel modifier with a very small width can help mitigate the problem. After that, consider marking any edges surrounding flat surfaces as sharp.

Finally, tab into Edit Mode and look for any double vertices or incorrectly shaded n-gons and fix these issues manually. Double vertices can be merged together (try selecting one, then pressing G twice to slide it along the edge into another vertex and Merge by Distance AltM).

Incorrectly shaded n-gons can be broken up, and you can add supporting edges for the merge point in the local geometry.


Different Behavior on Different Faces With Procedural Texturing

Insert a displacement node between the height value and the output.

This displacement node will calculate the direction appropriately considering the given height. Here you need to scale it negatively in order to have white higher than red.


How do I get object names to appear in the render?

For the labels to be visible in the render they must be created as objects within the scene. The following script will process each object in turn and automatically create a Text object set to the object's name and position the Text in front of the camera so that it is in line with the object (1.0 blender unit infront of the camera) :

# Script to automatically generate labels for all objects in the scene and position them in the camera view
# Generated labels are prefixed with '_generated.' and replaced each time the script is run.
# Note that any objects with name that happens to start with '_generated.' will be automatically deleted!
#
# This script will automatically create a material named '_generated.Label' and assign it to all generated labels.
# The generated material can be modified to affect the appearance of the labels.

import bpy
from bpy_extras.object_utils import world_to_camera_view

scn = bpy.context.scene
cam = scn.camera

# Pickup the label material if it exists
mat = bpy.data.materials.get("_generated.Label")

if mat is None:
    # Material doesn't exist, create it
    mat = bpy.data.materials.new(name="_generated.Label")

# Get each object in turn
for obj in scn.objects:
    if obj.name.startswith('_generated.'):
        # Delete the old label
        scn.objects.unlink(obj)
        bpy.data.objects.remove(obj)
    else:
        # Create a new label
        bpy.ops.object.text_add()
        tobj = bpy.context.object

        # Set the name of the label to include the prefix so we can identify them and set the text
        tobj.name = '_generated.'+obj.name
        tobj.data.body = obj.name

        # Position the label between the camera and the object
        diffloc = obj.location - cam.location
        dist = (diffloc[0]**2 + diffloc[1]**2 + diffloc[2]**2)**0.5
        if dist == 0:
            tobj.location = cam.location
        else:
            tobj.location = cam.location + (diffloc / dist * 1.0)  #1.0 blender unit from the camera

        # Set the rotation the same as the camera and scale it appropriate to the distance
        tobj.rotation_euler = cam.rotation_euler
        tobj.scale = (0.03,0.03,0.03)

        # Assign material to object
        if tobj.data.materials:
            # assign to 1st material slot
            tobj.data.materials[0] = mat
        else:
            # no slots
            tobj.data.materials.append(mat)

Open a Text Editor window and click 'New' and name it 'objectnames.py'. Paste the above text into the window and click Run Script to run it.

The script examines each object in turn and calculates a position in line with the object where a label needs to be positioned for it to overlay the object. A new Text object is created at that location, orientated to face the camera, and assigned a material.

Once the script is run, switching to Camera view should show the labels positioned over each object in the scene. Changing the generated material '_generated.Label' will affect the appearance of all labels in the render.

The line :

tobj.location = cam.location + (diffloc / dist * 1.0)

affects the location of the labels - with the '1.0' indicating how far from the camera the labels should be positioned - amend it and re-run the script to position them closer or further from the camera.

Similarly, the line setting 'tobj.scale = (....)' sets the scale of the labels - again, amend that line to change the scale if desired (larger values give larger labels).

Amend the '_generated.Label' material to affect how the labels are rendered. For example, to give them an emission colour without the emission affecting the rest of the scene you may have something like the following :

This can produce the following result :

For animated scenes you will need to run the script for each frame of the animation to reposition the labels. This can be achieved via a "handler" which can be registered to execute each time the frame changes. This can be achieved with the following code :

# Script to automatically generate labels for all objects in the scene and position them in the camera view
# Generated labels are prefixed with '_generated.' and replaced each time the script is run.
# Note that any objects with name that happens to start with '_generated.' will be automatically deleted!
#
# This script will automatically create a material named '_generated.Label' and assign it to all generated labels.
# The generated material can be modified to affect the appearance of the labels.
#
# Scene Custom Property '_generated_label_scale' can be set to a numeric to set the scale of the labels.
# Create an object group named 'Labels' and place any objects within it to only render labels for those specific objects.

import bpy

def handler_object_labels(scn):

    cam = scn.camera

    labelscale = scn["_generated_label_scale"]

    # Pickup the label material if it exists
    mat = bpy.data.materials.get("_generated.Label")

    if mat is None:
        # Material doesn't exist, create it
        mat = bpy.data.materials.new(name="_generated.Label")

    # Get each object in turn
    for obj in scn.objects:
        if obj.name.startswith('_generated.'):
            # Delete the old label
            curve = obj.data
            scn.objects.unlink(obj)
            bpy.data.objects.remove(obj)
            bpy.data.curves.remove(curve)
        else:
            # Check if group 'Labels' exists and if object within that group
            if bpy.data.groups.get("Labels") != None:
                if (bpy.data.groups["Labels"].objects.get(obj.name) == None):
                    continue

            # Create a new label
            curve = bpy.data.curves.new(type="FONT",name="_generated."+obj.name)
            tobj = bpy.data.objects.new("_generated."+obj.name,curve)
            bpy.context.scene.objects.link(tobj)

            # Set the name of the label to include the prefix so we can identify them and set the text
            tobj.name = '_generated.'+obj.name
            tobj.data.body = obj.name

            camloc = cam.matrix_world.to_translation()

            # Position the label between the camera and the object
            diffloc = obj.location - camloc
            dist = (diffloc[0]**2 + diffloc[1]**2 + diffloc[2]**2)**0.5
            if dist == 0:
                tobj.location = camloc
            else:
                tobj.location = camloc + (diffloc / dist * 1.0)  #1.0 blender unit from the camera

            # Set the rotation the same as the camera and scale it appropriate to the distance
            tobj.rotation_euler = cam.matrix_world.to_euler()
            tobj.scale = (labelscale, labelscale, labelscale)

            # Assign material to object
            if tobj.data.materials:
                # assign to 1st material slot
                tobj.data.materials[0] = mat
            else:
                # no slots
                tobj.data.materials.append(mat)

    bpy.context.scene.update()

if not '_generated_label_scale' in bpy.context.scene.keys():
    bpy.context.scene["_generated_label_scale"] = 0.06

if handler_object_labels in bpy.app.handlers.frame_change_post:
    bpy.app.handlers.remove(handler_object_labels)
bpy.app.handlers.frame_change_post.append(handler_object_labels)

Note that this script uses a Scene Custom Property (_generated_label_scale) to control the scale of the labels (defaults to 0.06). By default, labels will be created for all objects in the scene. However, if a group named 'Labels' is found then only those objects within the group are given labels (so select all the objects you want to have labels, select Object/Group/Create New Group from the menu, then on the Objects propert panel rename the group to 'Labels').

Note that the labels are only refreshed on change of frame - so if you move objects or the camera you'll need to swap frame before the labels re-arrange.

This can produce the following result :

Blend file included


Add a skin modifier which adds geometry to the mesh.

The image below shows two mesh objects one with the modifier visible and the selected mesh has modifier not visible comparison.

The image belows the skin close to the edges (skinnier).

To achieve this in edit mode use the keystroke Ctrl+a and move the mouse.


Cutting a shape out of an object with another object

You can use knife project.
(from the wiki)
Knife projection is a non-interactive tool where you can use objects to cookie-cut into the mesh rather than hand drawing the line.

This works by using the outlines of other selected objects in edit-mode to cut into the mesh, resulting geometry inside the cutters outline will be selected.

Outlines can be wire or boundary edges.

To use Knife Project, in 'object' mode select the "cutting object" first then shift select the "object to be cut". Now tab into edit mode and press "knife project".


How to make an object point in the direction that it's going?

You could try using the Follow Path  constraint.

Add a path (ShiftA> Curve > Path)

Select the object you wish to animate along the path and add a Follow Path constraint. Select the curve path as the target:

You can quickly setup the path animation by pressing Animate Path

Enable Follow Curve to make the object face the direction it is moving in:

For more precise animation of the speed along the path, keyframe the Evaluation time in Curve > Path Animation:

Note that if you have animated the path by pressing Animate Path, you will have to remove the generated F-modifier in the Graph Editor to be able to keyframe it.


How do I render out a clear render with no blurs?

To me it doesn't look really blurry, but more like a (too) heavy denoising.

How many samples are in this render?
To me, it looks like there is not enough in the first place, so the denoiser doesn't have enough detail to work with, and basically roughly washes out the pixels to get rid of the noise.
Out of my head, I would say such render would require a few hundreds of samples. So try like 300 first, then increase per hundred.

Just so you don't spend your entire day making test renders for nothing, don't hesitate to use the render border tool ⎈ CtrlB to render only small parts of your shot. So it will be fast to render & re-render.

Another thing you can do is to set a crazy amount of samples you will never reach and enable Progressive refine:

That way, it will render the entire frame sample per sample instead of fully rendering every sample of little portions. So you can render a portion of your frame via render border and see how the render quality improves along with the samples.
Once you're happy with the result (don't forget you have a denoise after), you look which sample amount has been rendered and you set that value for the final render samples.

Don't forget to disable progressive refine and render border (⎈ Ctrl⎇ AltB) for that one. Progressive refine is slower, and you don't want to let that render border on when you think you render the entire frame.


That's probably done using Freestyle, which was made to create line drawings.


Manipulate BGE logic bricks through python

This is done using the bpy.types.Sensor.link method, e.g.

import bpy

obj = bpy.context.object
sensors = obj.game.sensors
controllers = obj.game.controllers
actuators = obj.game.actuators

bpy.ops.logic.sensor_add(type="ALWAYS", object=obj.name)
bpy.ops.logic.controller_add(type="LOGIC_AND", object=obj.name)
bpy.ops.logic.actuator_add(type="ACTION", object=obj.name)

# Newly added logic blocks will be the last ones:
sensor = sensors[-1]
controller = controllers[-1]
actuator = actuators[-1]

sensor.link(controller)
actuator.link(controller)


Change the image of the UV/image editor with python for 2.8

Try this:

import bpy

for area in bpy.context.screen.areas:
    if area.type == 'IMAGE_EDITOR':
        area.spaces.active.image = bpy.data.images['Your_image_name']

Deactivate image in Image Editor

for area in bpy.context.screen.areas:
    if area.type == 'IMAGE_EDITOR':
        area.spaces.active.image = None


Best way to paint same Material with different mask?

You will have to specify some kind of "mask" at some point of process for any object. So I'm not sure if the shared material is key for you.
If you want just be able to change node-tree shared by multiple objects from one place you can use Node Groups. Place all material node-tree into a group (Ctrl+G) only "mask" node and Material Output place out of this group.

Once created, the node group can be placed (Shift+A > Group) everywhere and managed from any of its copies. This way you can completely change node tree into totally different look without touching material with mask specific to object.


As mentioned on the Blender wiki page on undo, there is the User level of undo, and the System level.

User level:

Expanding on the existing answers, You can configure the number of undo steps in User Preferences > Editing:

or Preferences > System > Memory & Limits in 2.8:

However, this value is arbitrarily limited to 64 256, or the Memory limit value. In other words, Steps is the maximum possible amount of undo steps, no matter what the Memory limit is set at.

Note that edit mode undo steps and object mode undo steps are stored separately, so you can have 256 edit mode undo steps and simultaneously have 256 object mode undo steps. (if you have enough memory)

System level:

You could use blenders autosave features to do something like zeffi suggested automatically.

  Save on Quit
  The function Save on Quit is enabled by default in Blender. Blender will always save your files when you quit the application
  under normal operation.
  Save Versions
  This option tells Blender to keep the indicated number of saved versions of your file in your current working directory when you
  manually save a file. These files will have the extension: .blend1,
  .blend2, etc., with the number increasing to the number of versions
  you specify. Older files will be named with a higher number. e.g. With
  the default setting of 2, you will have three versions of your file:
  *.blend (your last save), *.blend1 (your second last save) and *.blend2 (your third last save).
  Auto Save Temporary Files
  Checking this box tells Blender to automatically save a backup copy of your work-in-progress to the Temp directory (refer to the File
  panel in the User Preferences window for its location). This will also
  enable the Timer(mins) control which specifies the number of minutes
  between each Auto Save. The default value of the Blender installation
  is 5 (5 minutes). The minimum is 1, and the Maximum is 60 (Save at
  every one hour).The Auto Saved files are named using a random number
  and have a .blend extension.

Settings are in User preferences > File:

Or Preferences > Save & Load in 2.8:

I personally use a combination of automated saving and manual saving, and always save or at least duplicate the object when doing something destructive such as applying a modifier.

Images are from the wiki


Finding vertices in a Vertex Group using Blender's Python API

Methods

1. List comprehension

As mentioned by Pycoder in the comments below, using operators is often slow. So a quicker and simpler (and X2 faster) method to get all the verts that belong to a certain vertex group index:

vg_idx = 0
o = bpy.context.object
vs = [ v for v in o.data.vertices if vg_idx in [ vg.group for vg in v.groups ] ]

2. bpy.ops

You can also use the bpy.ops.object.vertex_group_select operator in edit mode:

import bpy

o = bpy.context.object

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

# Set the first vertex group as active:
o.vertex_groups.active = o.vertex_groups[0]

# Deselect all verts and select only current VG
bpy.ops.mesh.select_all( action = 'DESELECT' )
bpy.ops.object.vertex_group_select()

# Now the selected vertices are the ones that belong to this VG
vgVerts = [ v for v in o.data.vertices if v.select ]

3. Optimization if only one group

If there is only one group, this is a more optimized way to get the verts that belong to it. Note that this only works if there is only one vertex group.

vertices = [v for v in obj.data.vertices if v.groups]

Performance testing

1. List comprehension

With the default cube (8 vertices), this was timed 1,000,000 times, and had a minimum value of:

  0.000003528 seconds

With the default cube subdivided 8 times (393,218 vertices), this was timed 1,000 times, and had a minimum value of:

  0.1528 seconds

2. bpy.ops

With the default cube (8 vertices), this was timed 10,000 times, and had a minimum value of:

  0.0003289 seconds

With the default cube subdivided 8 times (393,218 vertices), this was timed 100 times, and had a minimum value of:

  0.8849 seconds

3. Optimization if only one group

With the default cube (8 vertices), this was timed 1,000,000 times, and had a minimum value of:

  0.00000222 seconds

With the default cube subdivided 8 times (393,218 vertices), this was timed 1,000 times, and had a minimum value of:

  0.0659 seconds

Here is a graphical (but less accurate) model if the performance. Each point is the min of 100 iterations.

Another representation of it:

Because the higher subdivision values make the lower end almost meaningless, we can use a logarithmic scale to see everything a bit more clearly:

Additional links

https://blenderartists.org/forum/showthread.php?304054-Getting-vertices-of-a-vertex-group-from-within-Python

Checking if a vertex belongs to a vertex group in python

How can i get the weight for all vertices in a vertex group?

vertex groups and bone weights programmatically

How can I get the names of the vertex groups these vertices are in?


How to split a certain area using python?

Iterate through all visible areas and override the context when calling area_split() operator:
import bpy

for area in bpy.context.screen.areas:
    if area.type == 'IMAGE_EDITOR': # 'VIEW_3D', 'CONSOLE', 'INFO' etc.
        override = bpy.context.copy()
        override['area'] = area
        bpy.ops.screen.area_split(override, direction='VERTICAL', factor=0.3)
        break


Rendering fire animations with transparent background

Blender's viewer is broken for that kind of images, so it's possible that your fire is rendered properly but the viewer isn't showing it correctly when you activated the "transparent" checkbox.
Try to switch the channels preview setting in the viewer from "color and alpha" (RGBA) to "color" (RGB).

If after doing that you can see the fire on black background, then your output is ok. (The ball occludes and emits, while the fire only emits.)
The next step is making sure that you're exporting the image correctly: You'll have to use a format that supports associated alpha. As @mentalist mentioned, EXR is one of those formats.
You'll have to make sure that the program where you're going to use that sprite supports EXR and associated alpha images, otherwise it won't be composited properly.
Keep in mind that PNG won't work for that, as it uses unassociated alpha.
EDIT:
On version 2.92 the viewer has been fixed, so you can see the proper associated alpha.


You find the right amount of samples by testing what is enough to get a clear image
Samples represent the calculations of how each pixel should look. During one sample a path from a pixel to a light source is calculated. A ray travelling that path is effected by various interactions with surfaces in the scene and this is how the colour of the pixel is determined. The same pixel can be a result of light coming from a lot of directions so the more samples, the more accurate the result, because they each calculate another path checking if it goes to some light source.
So simple scenes with direct lighting need a lot less samples than complex scenes with a lot of indirect light or caustics for the render to have less noise/grain. To determine the correct amount of samples for your scene you should test, how many samples is enough. You can start with fewer samples and make test renders to see if it's enough while increasing the amount. If you do this with the whole image this might take too much time so you can render only regions for testing (ctrl+b in edit mode to define region, ctrl+alt+b to remove region):

It is best to chose the regions that are the darkest lit places that will have the most indirect light and therefore are most likely to contain noise or any areas that you suspect might have more noise. You can also choose progressive rendering and just look at the render while it's going to see how many samples is enough.


How to get vertex normals from a shape-key in Python?

The only way I can think of is to use Object.to_mesh() and read normals from this temp mesh datablock, before freeing it (see also the doc):

me = my_ob.to_mesh(scene, True, 'Render', False, False)
for v in me.vertices:
    print(v.normal)
bpy.data.meshes.remove(me)

Quite obviously, you need to set the influence of your shape key accordingly first.


How do I create a particle system with an object that already has a particle system

In the modifier tab on the source object, apply the particle system modifier. This will turn the branches of the tree into individual objects. Then, select all of the branches as well as the tree trunk as the active object and join them together. This will give you one object that can then be used as the object when rendering the forest particle system.


How to determine the poly/vert counts of a fluid simulation?

When in object mode the info panel shows the vertex count of every object in the current scene which includes hidden objects, with a fluid simulation this changes each frame as the fluid mesh changes.

The frame before the fluid simulation starts will show the scene vertex count to use as a basis, lets start at frame -1 and say we have 16 vertices for a simple simulation with a cube for fluid and another for domain. Jump to frame 20 and we have 17184 vertices. By subtracting the 16 vertices we started with we have a fluid mesh with 17168 vertices. For an exact figure I believe the 8 vertices for the domain are included in the deformed fluid mesh so should not be subtracted from the vertex count of the frame.


So I managed to resolve the issue. It turned out the impression was due to my vertex group. I made a large selection of what would be on top of the table, and the sides of the mesh which were not part of that group were being raised as a result (for some reason). I deleted the vertex group and it now looks the way it is supposed to.


If you know that your circle has a even number of vertices, and do not care how the gird is aligned; then select all the vertices in the circle with alt RMB , then ctrl F > grid fill.

Select half of the vertices of the circle. The selection needs to have the same number of vertices along the top and bottom, and the same number unselected on the side.

Then press ctrl F > grid fill.

Which will give you this.


The recorded macros are stored as small text blocks in the Text Editor as macro, Blender will incrementally add a numeric constant to these so take care to rename before saving. To execute the macro again, execute them from there.


change pivot-center in image. Video Editiing

I watched the video, I think the rotation happens always using the center of the VSE video output. In the video the overlay image position is such that its lower left corner happens to be roughly at the overall frame center, so rotation seems to happen pivoting on its lower left corner,but is just a coincidence.

Edit: The image is not rotated itself. The image has just an offset that moves it to the upper right corned. Another (green) "trasformation" strip is applied to the image, and that green strip is what is rotated.

Her is what I think it happens:


In "Object Data" properties, please check that :

Only Axis Aligned isn't checked
Opacity isn't set to 0


How can I render with GPU on iMac 09' NVIDIA GeForce 9400 256 MB?

It's difficult to find clear information, but if Wikipedia is to be believed, the GeForce 9400 is supported by CUDA 1.x, but not 2.x which is what Cycles uses (look for the chart). This would be why it says "found 1.1," which is what comes with the driver.

That being said, there seem to be rumors in the deep web... whispers of dark magics... that will allow the 9400GT to run some newer versions of CUDA. Of such things... I hope never to be openly spoken in the halls of men.


set the UVs to their vertices's coordinates?

To get your image to display once on each face, select the entire mesh and press U > Reset. Each face will now be mapped to the image bounds.

In the UV/Image Editor header turn on UV and Edit mode selection sync.

Now in the 3D view you can select any faces with the texture on the wrong way, and rotate them in the UV Editor.


Edit:

Select your curve
go into edit mode
with all Points selected press "w" and select "Set Curve Radius"
Change the curve radius in the operator panel

to reset the curve radius divide 1 by the scaling factor, in this case the scaling factor is 2.048


Render subsection, produce full resolution image

By default, using the render border (CtrlB) will still produce a full image according to the set render resolution (I think this what you want).

The image will only be cropped to the border region if Crop is enabled in Render settings > Dimensions:

With Crop disabled, only the border region will be rendered, and the rest of the image will be filled with transparency.


The issue is one of the many problems with the PNG format: Unassociated Alpha

Blender will display the RGB information because it is part of the file and the alpha channel has not been associated correctly, and Blender expects associated alpha.

Quoting from the PNG specifications:

  PNG uses "unassociated" or "non-premultiplied" alpha so that images with separate transparency masks can be stored losslessly.

  An alpha value of zero represents full transparency, and a value of (2^bitdepth)-1 represents a fully opaque pixel. Intermediate values indicate partially transparent pixels that can be combined with a background image to yield a composite image. (Thus, alpha is really the degree of opacity of the pixel. But most people refer to alpha as providing transparency information, not opacity information, and we continue that custom here.)

  The color values stored for a pixel are not affected by the alpha value assigned to the pixel. This rule is sometimes called "unassociated" or "non-premultiplied" alpha.

  "premultiplied alpha", stores pixel values premultiplied by the alpha fraction; in effect, the image is already composited against a black background

A different way to think about the problem is to blender sees the RGB information on those pixels as luminous and transparent at the same time... (like the fire on a candle, for example).

What would happen if you switch from Straigth Alpha to Premultiplied?

Not a real solution, because the RGB information is still there (though this will display correctly in rendered view). When you premultiply blender would expect black instead of RGB information.

The proper way to deal with this situation is to multiply the alpha with the RGB information.

Split the RGB information, use a converter>math node in multiply mode to multiply the information of each channel by alpha and recombine the RGB channels.

(click on the image to enlarge)

Or use the color and alpha information on a color Mix node in multiply mode and use 1 as factor.

Other ways to use unassociated alpha information.

Unassociated alpha could then be thought as a mask to determine how two elemements mix. White (1) would be one element, black (0) would be the other and any shade of gray would be a partial mix.

You can then use such a mask to control the mix between two different shaders(like emission and transparent) plugging alpha directly as a factor for the mix.

Or if what you need is to control the color of the sader only, use a color mix factor and have the alpha information work as a mask for the mix.

Further reading

Why does blender then use associated alpha and why shouldn't I use PNGs you might be asking...

Quoting from this very clever answer:

  ONLY associated alpha (often called pre multiplied) allows the
  compositing of pixels that are luminous and transparent (Like halos, blurs, fire, glares, etc) so choose a file format that supports associated alpha (the most common for visual effects is EXR)
  It's impossible to produce that kind of alpha blending with
  unassociated alpha, so formats like PNG are completely ruled out.
  Image editing programs like Photoshop and GIMP work internally with
  unassociated alpha, so they are not suitable for compositing that
  kind of effects with alpha blending. You need to cheat and use an RGB
  only image with an addition instead (those programs are also likely
  to destroy the RGB information of every pixel with alpha=0, so be careful).

Suggested links:

https://wiki.blender.org/index.php/User:Sobotka/Alpha/Associated_and_Unassociated_Alpha

and

Compsiting Digital Images, by Porter & Duff


Compositor: Get the average value of an input fac

Blender has a levels node that return:

Mean (Average).
Standard Deviation.


Blender does not play audio track after restart

This was only when I pressed to recover last session.
If I open .blend file - everything was fine.
I noticed Blender was trying to open some file in /tmp dir. And it couldn't.


I was having the same problem in version 2.82, when pan suddenly stopped working, both manually and with Shift + Middle Mouse Button. In some forums they point out that #1 you may have accidentally activated walk or fly modes; or #2 you accidentally locked your view to a particular object (N  menu, View > View Lock.

If you tried to undo walk mode, fly mode, and view lock, and none of them were activated, then it may just be an old, obscure bug, predating since version 2.78. You can "solve" it by opening the N-menu, View, and changing the *Clip Start * and Clip End parameters by few orders of magnitude (i.e., x100 to x10000), until you start losing visibility nearby your rotation center.

It may let you pan and rotate just slightly between some weird unphysical boundaries. Keep changing the visibility until it suddenly starts working normally again. Then put back the old clip parameters.


The problem is that the 'Spine' is  also affecting the head and the arms. If you remove the arms and head from this vertex group, it works just fine.

In weight paint mode choose the 'Spine' vertex group. Use the subtract brush to remove the weights from the arms and head. Then test with different poses and adjust the weights where needed.

Here is a screenshot of how it should look like (although some more tweaking is needed :) ):


You could try something like this.

What I did was combine a Musgrave and a Noise texture and used that as a mix factor for the "Cake colors". I then took a lightened (softened) version of this mix and used that as a Bump Map of sorts. I also took the normal values from the Bump map, and the color data from the Noise Texture to provide the values for an Ambient Occlusion Node which I then colored dark brown and mixed with the original "cake color" to make the "darkened baked bits".
Lastly, I isolated the Z vector of a Gradient Texture (so it would lay flat) and "shaped" it with a ColorRamp to make a "top cap" mask which I would then use as a mix factor to apply the whites of yet another Noise Texture to the Cake by using a MixRGB node set to lighten. This makes the "icing sugar" on top.


How to fix polygons occupying the same space

If I understood well your problem, just select all vertices pressing A, then select "Mesh" -> "Merge" -> "By Distance" as in the image.

If you need you can then adjust the threshold in the redo panel.


Color ramp node resets one color when rendering

@FFeller's comment was completely right!

Somehow, a key frame was created on that first color. After deleting it (right mouse button click on the color), the original color is used and it doesn't turn black on rendering.


I know I did by mistake a key combination in sculpt mode....

From looking at your image, and from your description, it sounds like you most likely pressed Ctrl+2 or otherwise activated the Multi-resolution Modifier while sculpting.

This modifier has separate preview/ sculpt and render settings much like the Subdivision Surface Modifier as seen in the left column of the modifier settings.

From the manual:

  Levels

  The left column of settings control the general quality generated by
  the modifier in various contexts.

  Preview

  Set the level of subdivisions to show in Object Mode. Sculpt

  Set the level of subdivisions to use in Sculpt Mode. Render

  Set the level of subdivisions to show when rendering. Quality

  How precisely the vertices are positioned (relatively to their theoretical position), can be lowered to get a better performance when
  working on heavy meshes.

If the render and preview amounts do not match, you will see a different result when rendering, although performance may be improved with lower sculpt/ preview amounts in some cases.

In your specific situation however, needing a low-poly object you can simply remove the modifier. (click the x icon)


How can you set, if at all possible, the channels for OpenVDB export?

well, as far as I know there is just basic vdb support and blender does not offer you the possibilities houdini does. the vdb data is hard coded and depends on the sim settings. Though I have experienced that blender exported vdbs hold all the information needed to shade them within houdini. If you feel like the same simulation exports differently every time this is probably a bug. If it changes together with certain sim settings I would think it is supposed to be that way.


How to make a pure white smoke with blender internal render engine (not Cycles)

If you want to make smoke brighter, you need to make color of the smoke  brighter than white. This is howto:

In material settings make reflection color completely black:

As you can see, it doesn't affects at all, because this setting rewrites by smoke texture.

Next, go to the texture settings and find reflection color. Put here something like 5.0. (To set value above the limits click on value and print the number from keyboard)

This setting mix value 5 times more different than original (black in material settings) color of smoke reflection.

Also, you can set "extra-white" color in smoke color setting:

Select emiter of the smoke (not domain) and in phisics tab find smoke color setting


Wrong color space for the normal map
First of all you have some object with the normal pointing inside the surface, you can enable the Face Orientation overlay to spot them. I suggest to fix them by recalculating the normals.
Your node setup would be correct if you were using a common Normal Map you can find around the web. Your normal map has been baked with different settings, as you can easily spot by comparing the shades of blue between yours (on the left) and another normal map made from a professionist.
Your is simply baked in another color space. You should ask the person who did it which one exactly is, but if you switch to sRGB instead of Non-Color, all seems fine, so we can assume sRGB is the one.

Here's some normal map from the web: your nuance is clearly lighter.

Solution:
Change this parameter.


This feature can be enabled both for the viewport and a final render with the workbench engine.
When the render engine is set to Workbench the option can be found in Render Properties > Options > Shadow.

When the Viewport Shading is set to Solid, the same option is available for the viewport.


Is it possible to save animation as frame by frame to edit?

Blender does have the ability to render to individual frames (PNG format is popular) and this is the preferred workflow.

I like to increase the compression to 100%, and if you aren't rendering frames with transparency, then use RGB instead of RGBA.  And uncheck the Overwrite box.  If you decide you need to throw away the previously rendered frames (because you updated the animation or whatever) you can delete them using your file explorer or bash.

As you have calculated this can result numerous images, which are usually each pretty large.

When you say you intend to "edit" the results of blender's rendering, you are being pretty vague, and depending upon the nature of the alterations you want to perform, your workflow can vary drastically.


you don't have the full screenshot, so can't see if you've set the particles to end at the same time or not. right hand corner of the screen, in particle settings, make sure you have the particle system start/end values set correctly, as well as the 'life' of the particles.


How do I adjust opacity of an "image as a plane" in Version 2.90.1?

When selecting your image plane, navigate to the image section of the properties side bar and click on the transparency button to enable it, then adjust the opacity to your desired value.

Alternatively, if you are using the add-on version of images as planes, and still wish to see your image in the final render, you can modify your shader like this, and use the "fac" slider to adjust transparency.


From the print output, it looks like the 'dead' vertices don't have any index associated with them. Did you try iterating through the list -  verts_to_weld -  and removing vertices with index == None? Or maybe print the index of all the vertices in the list and see what it is for dead vertices. Most likely it won't be an int.