Custom 'Smooth Shading' shorcut not working

Blender doesn't currently support symbols for shortcuts. Try using a different combination with only alphabets and special keys. If you want to check for available keys, enable the "is key free" add-on from User Preferences and go to the tools shelf of text editor and you will find the add-on at the bottom.


Mouse keeps flouncing when I try to edit an object

You have "snap to grid" turned on. Click the little magnet button next to the Proportional Editing settings, and that will turn off snapping. You can use the pull-down menu next to the magnet to choose what element to use for snapping.


As far as I know object scale can only be done along its own axis (X, Y and Z).

So if we have this cube orientation (rotated 45 degrees around Y for instance):

it cannot be scaled in the global Z axis only.

That's why we have this result:

So to obtain the wanted diamong shape, you need to either:

Apply rotation CtrlA and choose 'rotation'. Then scale along global Z:

Or:

Enter edit mode, then scale along global Z:


In the materials panel, choose Object instead of Data.


From making cockpits before, I can tell you that they are tricky. I would advise you to use subsurf, and turn on autosmooth under Object Data > Auto Smooth.

Autosmooth should be default, as it is far more useful than smooth shading alone. I just got used to turning it on after a while.

A shape like this one can be obtained quite simply using that technique, and won't contain shading errors.

Making the cockpit first, then using it as a boolean is probably a good solution. If quads are an issue, it's always possible to triangulate later. Also look into Voxel Remesh https://www.youtube.com/watch?v=_9dEqM3H31g&t=1322s


Getting constant Unreal crashes when porting a blender model to it

it appears that unreal engine crashes when the blender animation FBX is without a material.
This means if you add a texture or material to your object it will work.


More Python thing than Blender's one, but you can:
import bpy

def find_meshes_recursive( root, levels=10, meshes=None ):
    # Initialize the result once
    if meshes is None:
        meshes = []

    def recurse( parent, result, level, levels ):
        # Does nothing if level is reached
        if level < levels:
            # Keeps meshes
            if parent.type == 'MESH':
                result.append(parent)
            # Look over children at next level
            for child in parent.children:
                recurse( child, result, level + 1, levels )

    recurse( root, meshes, 0, levels )
    return meshes

root = bpy.context.object

meshes = find_meshes_recursive(root, levels = 10)
print(meshes)

Note that you can also do it in non recursive way:
def find_meshes(root, levels=10, meshes=None):
    meshes = [] if meshes is None else meshes

    parents = [root]
    while levels > 0 and parents:
        meshes.extend([obj for obj in parents if obj.type == 'MESH'])
        parents = [child for obj in parents for child in obj.children]
        levels -= 1

    return meshes


I think the accepted answer works but could be better. What you are seeing is an optical illusion. The barrels in the middle of the animation are lining up with the previous frame, so they appear to not be moving.

Enabling motion blur should let you see the motion throughout the animation, but still allow you to use smooth interpolation (so the spin up and slow down would be smooth).


Only Render Vertexes with Normals Parrallel to the Screen?

I would talk of poligons (faces), as vertex can't be strictly said "renderable": they are 0-dimensional (you'll need for example to use a halo materal to create something around the vertex).
What we see rendered/drawn in the 3D Viewport is a also a rapresentation, a placeholder, built to make them visible.

You can filter out the faces in a "static" way by select one of the faces whose normal is pointing toward the camera and then:

 Select -> Select Similar -> Normal

The thereshold value would act as the "tollerance" factor you mention. Repeat also for the backfaces. Once selected  both you can delete them, or separate them and tweak visibility, assing a different material, or even assing them to a vertex group and use the Mask modifier.

Or you can work with materials to obtain a dynamic masking.

In cycles there is the Layer Weight node whose Facing options is able to assing a factor to the faces based on how much their normals are pointing toward the camera

The factor can be used to mix a shader with a Transparent shader:

By tweaking the Color Ramp's handles you'll have full control on the masking range, not just a tollerance.

Notice that this way you are rendering all the faces (some are trasparent and some not, but the path tracing takes all in account). The static way previusly exposed will probably render faster, as it excludes faces from the caluculation, while the dynamic doesn't.


Cycles, Using Ambient Occlusion as a Factor in Material Node Editor

In the node editor Shift + A then under input you'll find Ambient Occlusion, the node itself shows in the image above, you can use AO output as a factor to feed to a Mix Shader node or a MixRGB node or... whatever you would use a factor for.


How do I measure half the length of a specific part of an object in Blender (3D modeling software)?

Use snap vertex and an array modifier. By snapping a cubes vertex to the outside edge of the castle turret the cube will be lined up. Then add a array modifier to that cube and set the count to 4. If your math is right number 4 cube will line up with the opposed edge.


My rig does not move my character correctly

The problem is that the normals of your mesh are flipped so it gives bad parening:

To fix it, select your mesh, select all in Edit mode and AltN > Recalculate Outside. Then reparent to the armature With Automatic Weight. It should work much better. If you need to make some corrections, display the good layer, i.e. the one with the bones that are supposed to deform your mesh:

Then select the armature, shift select the mesh, switch to Weight Paint mode, check each bone and give some corrections:


I would add in a cube and and delete three faces (top, one left and one right) this way you have enough light coming through and also have a light gray background and one sun lamp. This would be the way that I would recreate the scene.


How to make Daredevil dripping wax using liquid simulation

The effect is accomplished by using a hidden underlying mesh object to serve as a obstacle/attraction. This effect can be simulated by Blender's built-in fluid simulator, but could be easier and done more prettily with an add-on called FLIP Fluids. If this is just a personal/experimental project, you could go ahead and download it from their GitHub repository at https://github.com/rlguy/Blender-FLIP-Fluids. If you're planning on selling it your work or sharing it with larger numbers of people, probably buy it from their Blender Market page.

Jeez I just realized how much that sounded like a sponsorship
Anyway, I still think it's a valuable tool to be aware of.

Honestly, probably some in-depth fluid tutorials will teach you all you need to create this effect whichever method you choose. Take a look at this video, as a good starting point.  https://youtu.be/3o9E2t0cTCc

That will give you a basic overview of everything, then you can teaser h individual aspects a bit more closely.

I hope you get this working! Seems like an awesome project.


Where can the angle for Select Sharp Edges operation be set in Blender 2.80?

I found it, the panel to edit options of the last used operator in 2.8 is in the bottom of 3D viewport, by default it's minimized. Default shortcut to open it was also changed and now it is F9.


1) Keeping modifiers unapplied

Modeling without applying modifiers can be quite tricky.

Tring to keep the Solidify modifier, which basically extrude faces along their normals, isn't probably the best choiche for your task because your reference object has a different depth extrusion on one side.

You could have done that by stacking two Solidify modifiers, but unfortunately currently faces created by another modifier cannot be pickedlike in other software packages (3dsMax...). Probably, with a bit of work the closest thing you can get is something like this:

where I had to Inset faces and pick only a few of them manually in order to put them in a Vertex group which would allowed me to set a different Factor in the modifier for the object's faces.

From the Blender manual page of the Solidify modifier;

  Vertex Group

  Only vertices in this group are solidified - their weights are multiplied by the thickness, so vertices with lower weights will be
  less thick.

and

  Factor

  How much the vertex weights are taken into account.

  On 0.0, vertices with zero weight will have no thickness at all.
  On 0.5, vertices with zero weight will be half as thick as those with full weight.
  On 1.0, the weights are ignored and the thickness value is used for every vertex.

To make the edges sligtly thinner toward the center you can work (for example) on the inner edges of the Full Weight faces:

2) Applying modifiers

If is suitable for the project, it's probably easier to apply the Solidifiy modifier it seems you are using (or extrude the faces inward as in the picture below)

then use the Checker deselect tool to pick one face every two and "Extrude region (vertex normals)" to build the gear tooth.

Pick the iner faces, set Individual origin Pivot, Normal orientation and then scale each faces along the Normal-X axis by pressing in sequence SXX followed by the wanted value.


Why is the HDRI reflection different and how do I control it?

When using perspective camera, the reflections will never match.
To preview the same reflections, you can use local collections.

Put each glasses into a different collection, but give them the same coordinates (like 0,0,0)
Open multiple viewports side by side
Go View > Collections and choose which one to show for each viewport


How to use subdivide on this shape that i cant name

Choose edges you want to keep sharp then go Edge>mark crease (Shift+E) and drag up for maximum value


How can I create a script that runs continuously but does not block the interface?

What you are looking for is to create a modal operator. From the Wiki:

  A modal operator defines a Operator.modal function which running,
  handling events until it returns {'FINISHED'} or {'CANCELLED'}. Grab,
  Rotate, Scale and Fly-Mode are examples of modal operators. They are
  especially useful for interactive tools, your operator can have its
  own state where keys toggle options as the operator runs.

There is a template for the Modal Operator accessible from the Blender Text Editor.


My mesh is not rendering, but my particle system is. How do I make it all visible in during a render?

By default Blender does have the particle emitter enabled for rendering, though perhaps you have turned it off?

It would be helpful in answering the question if you could provide a .blend that shows the issue. Blender is quite complex and guessing based on a description is not always easy.


How can I render something like a lattice around my object?

As the lattice can not be rendered, you can use a mesh object with the same geometry and hook both with empties.

In the example above, the lattice is the default cubic lattice which is associated via hooks to a simple cube. The cube itself has a wireframe modifier.

The recipe:

Create the lattice and the cube so that they have the same initial geometry
Add a wireframe modifier to the cube
Now create the hooks for the cube :
Enter edit mode, select a vertex
Use CtrlH to make the hook menu appear and choose "hook to new object"
Do that for all the vertices of the cube
Once done come back to object mode
Now the lattice part:
Select the lattice and enter to edit mode
Select a vertex
Use CtrlH and choose "assign to hook" and choose the corresponding previously created empty
Do that for all the vertices of the lattice

Note: if you have many (say more than 8) vertices to manipulate, it can be difficult to remember which empty correspond to which vertex. So you can also do the following:

In object mode, select the empty the shift select the lattice
Enter edit mode
Select the corresponding vertex
Use CtrlH but now choose "hook to selected object"
Come back in object mode and do the same for the other empties/vertices


how to fix normal of a shader after scaling with a factor of -1

First set your normal map to be non-color, then apply scale on the copied door and recalculate it's normals (Alt+N in Edit Mode)


Some vertices don't move along with the rig

To solve this issue, you need to:

Make sure the mesh weights are set correctly
Probably join all the body part meshes into one mesh
Make you rig bind to the mesh using bone envelopes or vertex groups. If you choose bone envelopes, make sure they encapsulate all parts of your mesh so they effect all parts of the mesh. If you choose vertex groups, make sure all the vertices of the mesh are accounted for in all the vertex groups.

That being said, you can follow the steps I've laid out here until you get to the end, and then try googling adjusting bone envelopes or vertex groups, or hopefully I or someone else can figure out how to get it working properly so I can finish giving step-by-step instructions.

Moving a Mesh with an Armature

In order to move a mesh with an armature/rig, you need to:

Make sure the Weight for your mesh is set correctly
Make sure your mesh is bound to the rig correctly with either Vertex Groups or Bone Envelopes

Weight Painting

Weights for mesh objects that you want to be moved by your rig/armature must be painted something other than blue:

Blue means it will be effected 0% by rig movement
Red mesh will be 100% effected you the rig
Any color in between blue and red will be partially effected by the rig movement:

Since your figure's body is divided into different meshes, I suggest you join all body parts together into one mesh so the rig will effect them as one mesh. Perhaps it's possible to use the rig with all the parts separate like they are now, but I don't know how to do that. So, I recommend selecting all parts and then using the Join command by pressing CTRLJ.

Now you need to paint all parts of your mesh with the correct weights:
Select the figure
Select Weight Paint mode in the 3D Viewport header:

Now adjust the brush settings and paint.
NOTE: If you want an easy way to paint every part of your mesh red so it'll all move 100% with the rig, then make sure Limit Selection to Visible is disabled so that when you paint, it'll paint even parts of the mesh you can't see (i.e. the back sides, etc), as shown in the video below:

You might want to paint the hair and the leaf dress to something other than full red in case you want them to move slightly differently. You can read more about weight paint here on the Blender wiki.
Now that you've taken care of the mesh weights, let's move on to the rig and how it's attached to the mesh. You might consider turning off the visibility of the controls you are not using at the moment so it's easier to grab the ones you want. To do this, open the Properties panel (N), scroll down to the bottom and toggle off the visibility of the ones you're not using, like this:

This will leave only the IK (Inverse Kinematics) controls visible so they'll be MUCH easier to find & select when you're posing the rig.

NOTE: If you're not sure about whether to use FK or IK controls, see the answer here for a detailed description of what FK and IK controls do.
Next, select your rig, then enable Auto IK in the Options tab:
Tools panel (T) -> Options tab -> enable Auto IK

Now you need to bind the vertices of your mesh to your rig/armature using either Vertex Groups or Bone Envelopes:

Bind to Vertex Groups and/or Bone Envelopes

One common cause of parts of the mesh not moving with an armature can be related to how you bind the armature to your mesh -- whether you have Bind to Vertex Groups, Bone Envelopes, both or neither selected. If you'd like to read more about Vertex Groups and Bone Envelopes, you can read more about them here:

Vertex Groups
Bone Envelopes

In this instance, I'll show how to bind using bone envelopes.

First, make sure you only have 1 Armature modifier on your figure, then set it so only Bind to Bone Envelopes is selected:

Then, select the rig, go into Edit mode, and in the Properties panel (N) adjust the size of the radius and envelope of each bone to make sure it encompass all parts of the mesh it's intended to move:

Then, when you go into Pose mode to pose your figure, if part of the mesh doesn't move properly, like the parts of her face you showed in your picture, then that means the radius and/or envelope of the bone governing the head movement is not large enough.

More On Rigify

For more information about some of Rigify's not so obvious features, see this question.


.exr file quality options for seperate renders?

Yes, another EXR would be the best option. Any other file type will have a hard time matching the quality and compression method. And it's not as if the EXR will be "bloated" with lots of passes without data. It just won't store data that you don't give it.

It'd also be more convenient to use the same types for the same things. If you're going to be pulling in passes for compositing, it makes sense to use the same type of file for that same process, even though it might contain different passes.


I think what you want is "linear light" and a linear colour model.
Setting either "Displace Device" to "None" or "View Transform" to "Raw" under "Color Management" in "Render Properties" seems to do the trick:

Also pay attention to "Save As Render" in the image save dialog box.
A render with four concentric and equally spaced rings with maximum roughness and zero specularity around a point light source produces peak colour values of around [1.0, 0.29, 0.14, 0.09]— Mostly what you'd expect from physically correct inverse-square behaviour, with some margin from clipping and sampling noise:

I saved the result as a 16-bit PNG, which should give you plenty of bit depth to play with. You may also want to try EXR or RGBE, depending on your use case— My image viewer for those formats seemed to apply an sRGB transform by default on display, but the data itself seems to be intact.

Notes on interpreting the data:
As the output data is in the form of dimensionless RGB values, if you want physical units then you'll have to calculate a conversion ratio based off of a known lamp power output, surface albedo, and distance.
In my example file, the innermost ring has an RGB peak of 1.0 with an albedo of 0.8 at a distance of 1m from a point light source with 50W of power output.
The 50W of radiation at a distance of 1m will be spread across a spherical shell of 4π(1m)²=12.57m², so incoming irradiance at that distance should be 50W/(12.57m²)=3.98W/m². Outgoing surface radiosity accounting for the 0.8 albedo should then be 3.98W/m²*0.8=3.18W/m². So that means RGB(1.0)=3.18W/m², which in turn means that the radiosity at the other rings can be figured out by RGB(0.29)=(0.29/1.0)*3.18W/m²=0.92W/m², etc.
It may be more sensible to establish a conversion ratio using a Sun lamp shining perpendicularly on a full-albedo, full-roughness, zero-fresnel dielectric (non-metallic) surface than a point lamp. The tooltip says that "Strength" maps directly to W/m².
You can probably also put that ratios or its multiple and/or reciprocal into the "Exposure" setting under Colour Management in order to havea 1:1 ratio between the RGB values and your physical unit of choice. Note that if RGB goes above 1.0, then you'll probably want to use either EXR or RGBE as your output file format.
Always sample parts of your data by hand and check your numbers manually to see whether they make any sense, both based on your scene and relative to each other. Digital colour management is frankly a mess, and there's a lot that can go wrong at pretty much any stage of the pipeline when you're trying to pull physical measurements out of artistic software.
Further caveats:
Note that this also still technically isn't the luminance, as it's just the radiosity. Luminance is a measure of perceived light as detected by human retinal cells, so you'd need to apply a luminosity function to calculate it. You'll also need to make sure your render engine, file format, image viewer, etc aren't already accounting for the effects of the luminosity function.
From the fact that RGB(1,1,1) is white, we can also reason that even if interpreted as radiosity, the data is scaled against sunlight's spectrum rather than having a spectrally uniform power distribution.
Also note that Cycles and EEVEE run entirely in RGB, AFAIK, and not with continuous spectra. So if the spectra of your light sources and albedoes have a lot of spikes or valleys, the result will end up being further from physical accuracy.


How to merge two faces of different normals to create a corner?

Install this Destructive Extrude Addon

In Edit mode Select the Face and Press Alt+E and select the Destructive Extrude option.

Now you can extrude and if need to snap to face press Ctrl key.

It never creates extra faces and no doubles.


You can actually get back to the default 1:1 f-curve mapping by simply deleting all keyframes from the f-curve (ie, select the curve, press L to select all (linked) points on that curve, press X to delete). While this means that there isn't an f-curve to edit, Blender will assume a 1:1 relationship between driver value and the resultant property to give the same effect as the initial driver f-curve. If there are no Modifiers present then Blender will render the 'curve' as a dashed line rather than the normal 'solid' line.

In order to be able to edit the f-curve again you will need to re-create an actual f-curve. This can be achieved by simply adding a Keyframe to the object property being driven - ie, in the above example by hovering the mouse over the Y location property (shown in purple in the 3D Editor window) and pressing I.

Once you have created a keyframe you will then be able to adjust the f-curve as normal. To get back to the default state, set the Key 'Frame' and 'Value' to [0.0, 0.0], Left Handle to [-1/3, -1/3], Right Handle to [1/3, 1/3], Handle Types to 'Vector'. Then press I in the F-Curve Editor to add a new keyframe to the channel and set this similar to the above, except [1.0, 1.0] for the Frame/Value, [2/3, 2/3] for Left Handle, [4/3, 4/3] for Right Handle.


You could do it this way (here, syringe and piston are two separate meshes in one unique object):

Create an armature with two bones, the top is child (Keep Offset mode).
Parent the syringe to the armature With Empty Groups.
In the Properties panel > Data > Vertex Groups, assign the piston vertices to the vertices group that has the name of the top bone and the syringe vertices to the vertices group that has the name of the bottom bone.
Select the armature and switch to Pose mode.
Select the piston bone and give it a Limit Location constraint.
Activate all axis to limit the piston in all axis possible.
Keep all values to 0, just change the Y maximum value (here: 2), Y being the vertical axis of the bones.
Choose Local Space instead of World Space, so that it takes only the local space of the object into account.
Now when you move the piston bone it will only go up and down and will be blocked at its maximum Y value.

If you piston and syringe are 2 separate objects, keep the same bone settings, switch the armature to Pose mode, select the piston object, select the piston bone, and ctrlP > Bone. Same thing for the syringe.


Seamless animation of Wave procedural texture

You wrong. Perfect number is 1,884955781 ( or Pi / 5 * value in modulo )

For answer the question, first you need to know, that exactly Wave Texture node do.

So I build in simpler nodes exact copy of Wave Texture node:

This node setup produce similar result as Wave Texture node, and you can check this:

So now we can follow the nodes, to know where 1.8888 is hidden.

We begin in modulo coordinates here, from reference question. As i see, you have 3 repeats, so I think you set 0.3333 in modulo. You didn't give any information about it, but it's looks like that I'm right.

x,y,z now is from 0 to 0.3333.

Next stop is my node setup, in first nodes texture coordinates are multiplying with the result of this two:

First, multiply 10: 0.3333*10=3.3333

Next it is our X-number, that you think is 1.8888. I call him X, so result is 3.3333*X.

Last stop - sine. You need to know, that Sine repeats in 2*Pi period. So now we can get eaquation:

3.3333*X=2*Pi

So X will be:

X=(2*Pi)/3.3333

X=1,884955781

So, you wrong. perfect number is 1,884955781


I do not know why, but it seems that using an object as a focal point only works when using an Empty.

Cycles:

(Note that cycles will render with DoF without the need for composite nodes.)

Setting Blades to 3 or more makes it possible to render with a non-circular aperture (this setting refers to the number of "blades" in the camera's aperture)

Blender Internal:


Maximum number of materials that can be added in a scene?

Use the same material for every object but have different colors for it.

I assume you will generate this dynamically. Some methods I can think of:

Generate a 4096x4096 texture and assign that. Use nearest interpolation (like in minecraft). Have each planes UV-coordinates point out what pixel to use.
Use vertex colors for each plane. Have the material use the the vertex colors. Use the attribute node: http://wiki.blender.org/index.php/Doc:2.6/Manual/Render/Cycles/Nodes/More#Attribute
If you don't need exact colors, if you are content with a random color, use the object info node to get a random value for each node, insert it into a color ramp node.


There is no " Object Tools" it just says Transform

The UI has probably changed since the tutorial was made. Blender moves and changes UI elements quite often.

Rigid Body Tools is in the Physics tab. The Objects section is pretty much the Transform section, just with the title renamed. Make sure you're in the proper mode when you're looking around (i.e., mesh Edit mode vs Object mode).


Fedora21: Only three movie options (AVI JPEG, AVI Raw, Frameserver)? No XVid! Why?

If you get the latest download from blender.org you'll have
all kinds of format choices including XVid


TextureAtlas flips normals on half of the deep linked duplicates

So what fixed it for me was:

Select all objects and duplicate them by pressing Shift + D.
Make everything a single user object (hit U » Object & Data).
Apply the scale and rotation with Ctrl+ A » Scale & Rotation.
Go through each object with wrong normals and fix them (Tab to enter edit mode, select all by pressing A and then Ctrl + N to fix the normals)

When I then selected the Texture Atlas group and started the unwrapping everthing was fine, no flipped normals anymore.


What is an easy way to correct the position of the lower jaw of the dog? After animation and parented to armature? Is it possible?

I have figured out how to do it in a way. I couldn't correct the jaw. What I did was duplicate the lower jaw and then separate it from the body mesh. Reparent the lower jaw (which have to be rescaled and repositioned), but it still follow the animation pretty well.


Can a image be render on planes through scripting?

The only solution is to save the image that you want to put it on the plane and to load the image from there

texImage.image = bpy.data.images.load("path to your image saved previously in code")


Where has the "Show in Viewport" option in the 2.8 branch of Animation-Nodes gone?

This option has been replaced by a more advanced node called the Viweport Input node. Every Viweport Input node creates an input box in the AN panel, the name of the input box is defined by the label of the Viweport Input node that defines it. The boxes can be minimized and you can change the order of inputs as you wish from the N menu. For instance, we have here two Viweport Input nodes defining two input boxes:


sort objects in outliner case-insensitive

I think there's no need in addon for the thing like that.

The software put a new object name with an upper case because of python script in the source code that define an objects' (for example cube) name with upper case. So the solutions are:

Name your objects with a capital letter
Rewrite source files. I mean put cube instead of Cube in every file where it is. But it's time consuming

PS

You can create new objects on the separate layer with enabled option "visible layers" in outliner


First, a workflow question about your scene: might it work just as well to set up a different scene in the same blend file, dividing the groups between the two scenes?

If not, I think the fastest way within blender would be to save your blender file under a new name (or twice, each under it's own new name) and delete the objects in the group you want to split out in one copy, and delete all of the other objects in the other copy. (Keeping the original unchanged is just part of my standard workflow. I'm too afraid of deleting an object from both copies and losing it. Your mileage may vary.)


How can I align the background image to an object?

Adjust the Y setting in the background images tab to raise or lower your background image. You can also you the X value to offset the image on the X dimension.


Split (shortcut `y`) face to limit loop cut?

Using Split faces does create double vertices.
You can easily merge them after adding your loopcuts.

Split faces Y
Add loopcuts
Select All A > Merge by distance Alt+M


How to disable multiple keymaps with the same name?

Call pie menu operator
Firstly the name is the id (bl_idname) of the call pie menu operator.  The idname of the registered pie menu is passed as name property to the operator.
To call snap pie menu
bpy.ops.wm.call_menu_pie(name="VIEW3D_MT_snap_pie")

Distinguish by the operator's name property

To distinguish between them look at properties passed to the operator.
Test script to make a list of all pie menu short cuts in 3D view (from question).  Look for all the keymap items using this operator "wm.call_pie_menu" and populate  list with the name of the menu.
import bpy

context = bpy.context

wm = context.window_manager
active = wm.keyconfigs.active
view3d = active.keymaps["3D View"]

# using call menu

pies = [km.properties['name'] for name, km in view3d.keymap_items.items() if name == "wm.call_menu_pie"]

print(pies)

output
['VIEW3D_MT_view_pie', 'VIEW3D_MT_snap_pie', 'VIEW3D_MT_pivot_pie', 'VIEW3D_MT_orientations_pie', 'VIEW3D_MT_shading_pie']

List Comprehension
The list pies is created with list comprehension.  Recommend getting head around list comprehension.
To disable all, Note pies is different here, it is being populated with the keymapitems, not the value of the operator name property

pies = [km for name, km in view3d.keymap_items.items() if name == "wm.call_menu_pie"]

for pie in pies:
    pie.active = False

To disable all but snap

for pie in pies:
    pie.active = pie.properties['name'].endswith("snap_pie")

Toggle

for pie in pies:
    pie.active = not pie.active

All call pie menu keymap items in all active keymaps
Create a dictionary of all all the call pie menu operates in each keymap.
all_pies = {
        km.name : [
            kmi for name, kmi in km.keymap_items.items()
            if name == "wm.call_menu_pie"
            #and kmi.properties['name'].endswith("foo"
        ]
        for km in active.keymaps
        }

for name, pies in all_pies.items():
    if pies:
        print(name, [pie.properties['name'] for pie in pies])

Result
Grease Pencil Stroke Edit Mode ['GPENCIL_MT_snap_pie', 'VIEW3D_MT_proportional_editing_falloff_pie']
Weight Paint ['VIEW3D_MT_wpaint_vgroup_lock_pie']
Object Mode ['VIEW3D_MT_proportional_editing_falloff_pie']
Curve ['VIEW3D_MT_proportional_editing_falloff_pie']
Sculpt ['VIEW3D_MT_sculpt_mask_edit_pie', 'VIEW3D_MT_sculpt_face_sets_edit_pie']
Mesh ['VIEW3D_MT_proportional_editing_falloff_pie']
Metaball ['VIEW3D_MT_proportional_editing_falloff_pie']
Lattice ['VIEW3D_MT_proportional_editing_falloff_pie']
Particle ['VIEW3D_MT_proportional_editing_falloff_pie']
3D View ['VIEW3D_MT_view_pie', 'VIEW3D_MT_snap_pie', 'VIEW3D_MT_pivot_pie', 'VIEW3D_MT_orientations_pie', 'VIEW3D_MT_shading_pie']
UV Editor ['IMAGE_MT_uvs_snap_pie', 'VIEW3D_MT_proportional_editing_falloff_pie']
Mask Editing ['VIEW3D_MT_proportional_editing_falloff_pie']
Graph Editor ['GRAPH_MT_snap_pie', 'VIEW3D_MT_proportional_editing_falloff_pie', 'GRAPH_MT_pivot_pie']
Image ['IMAGE_MT_pivot_pie']
NLA Editor ['NLA_MT_snap_pie']
Clip ['CLIP_MT_tracking_pie', 'CLIP_MT_solving_pie', 'CLIP_MT_marker_pie', 'CLIP_MT_reconstruction_pie']
Clip Editor ['CLIP_MT_pivot_pie']


Multiple meshes with rigify: One does not transform at all

Found out that there was an issue with too many verticies in the object causing the automatic weight painting mode to not work at all. By doing retopology and/or simply decreasing the face count and repeating the steps it will work.


how can I select all objects in a collections using python?

If you want to process every object in a collection, you would have to iterate through Collection.all_objects:
collection = bpy.data.collections["collection_name"]
for obj in collection.all_objects:
    print(obj.name)

Further reading: How to list all collections and their objects?


As far as I can see:

No Sync just tries to play back every single Frame no matter if it causes lags or time shifting problems with the Audio or the actual physical time.
Frame Dropping drops Frames from the ViewPort Animation Playback to match up with the actual Frame Rate being used
AV Sync skips Frames from Video Footage in the VSE so that Audio and Video in the Image Preview Sequencer Mode stays in sync


I think what you mean is a node that does the same thing as the time node in the compositor.  Unfortunately there is no single cycles node that does this.  However one can be constructed rather easily.

First add a value node and plug it into the color on an RGB curves node.  Then keyframe the value node's value to be 0 at frame 1 and 1 at the last frame.

Then select the value node and hop over to the graph editor...

... select the keyframes, press T, and select linear interpolation.

The output of the RGB curves node will be the same as the output of the time node would be in the compositor.  You could eliminate the RGB curves node and just edit the interpolation curve in the graph editor; but while that will give you a little more control it would be more cumbersome to tweak.  But it is an option if you need the extra control.


How to designate a viewport for one camera?

Blender only allows one active camera in a scene and numpad 0 moves the view to the active camera, so you can't setup a different camera view for each viewport.

You can setup as many viewports as you want and you don't have to be viewing from a camera in each viewport. Blender includes an addon called stored views which gives you a way to bookmark multiple viewport locations, this can provide an easy way to set a viewport back to a desired viewing location, similar to what you would get from a camera.


Rotating arm bone twists and distorts mesh

As you have to actually deal with a rotation, you have to distribute this rotation smoothly along some different edgeloops. This is an example of how it can be achieved.


How do you find the nodes you're looking for

I think it would be a great idea for the developers of Blender to show these words in search results even if the word is a part of the node (rather than the node's name itself).

You should suggest this to the developers, if enough people find it useful it will have a better chance to be implemented,there is a section in blender about small tasks so that new developers can pick a small task and try to code them to be implemented in blender , yours seem like a good task.

  Does anyone know of a way to find where to find certain functions of a node when it doesn't show up in the search results

There aren't many nodes like that that have those kind of sub menus, if you use blender long enough and with practice you will know their location by heart.

to ask for a feature to be implemented in blender , see  : Best Place to put Feature Requests?


I can see you have 2 objects, because there are 2 origins.
First Join objects (cmd/ctrl + J).
And yes, Joonas is right you have doubles (> Merge by distance).


I, too, am somewhat new to Blender, and this one has gotten me several times.  If I'm guessing correctly, the problem lies in the order in which sources for rendering are processed.  In the picture below, I show that the render output panel is selected in the properties window (upper left highlight).

Way down at the bottom of that panel is a flippy triangle marked Post Processing.  I think rendering first looks for something in the Compositing timeline if the Compositing box is checked.  Then it looks for something in the Sequencer (video editing) window if the Sequencer box is checked.  If not checked or nothing there, it renders the viewport camera that's active directly.
So, uncheck the Compositor box, check the Sequencer box and let me know whether this now works.
HTH


Can't zoom after pressing Numpad (.) on object - Blender 2.8

In 2.8+ the simplest fix is to go into Edit -> Preferences -> Navigation and enable "Auto Depth"

This will fix the zoom slow down issue, but does change it so your cursor placement affects the navigation.

Since 2.8, some of the better responses have changed to this previously asked question and no longer work, or work differently.


HIDE_HEADER in bl_options over rides the panel location in the UI

Sub Panels

Blender now has subpanels. Recommend making "Holding Panels" and make your other panels children.

Example https://blender.stackexchange.com/a/155517/15543

On rearranging panels

  This is easily done by rearranging the order in which each panel is
  registered.

Maybe a poison chalice.  Remember the user can move panels around. The expected result is the register order.  Been my experience this is (generally but) not always the case.  Registering panels in startup scripts places them higher than via addon.

As mentioned above, would now use subpanels.

If the same issue is the case re a headerless panels panels moving to top, recommend using an appended or prepended draw method.

Here is example rejigged from link above

Panel 2 and 3 are children of panel 1. Both panel 1 and panel 3 are set to hide header.

2 results of running script below. Both preserve order. The render of the no header subpanel is strange (bg color).  Panel 1 is Ok, perhaps explains why no header panels are moved to top.

import bpy

class EXAMPLE_PT_panel_1(bpy.types.Panel):
    bl_label = "Panel 1"
    bl_category = "Example tab"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_options = {"HIDE_HEADER"}

    def draw(self, context):
        layout = self.layout
        layout.label(text="This is panel 1.")

class EXAMPLE_PT_panel_2(bpy.types.Panel):
    bl_label = "Panel 2"
    bl_category = "Example tab"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_options = {"DEFAULT_CLOSED"}
    bl_parent_id = "EXAMPLE_PT_panel_1"
    def draw(self, context):
        layout = self.layout
        layout.label(text="This is panel 2.")

class EXAMPLE_PT_panel_3(bpy.types.Panel):
    bl_label = "Panel 3"
    bl_category = "Example tab"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_options = {'HIDE_HEADER'}
    bl_parent_id = "EXAMPLE_PT_panel_1"
    def draw(self, context):
        layout = self.layout
        layout.label(text="This is panel 3.")

classes = [ EXAMPLE_PT_panel_2, EXAMPLE_PT_panel_3]

from random import shuffle
shuffle(classes)
classes.insert(0, EXAMPLE_PT_panel_1)
print(classes)

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

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

if __name__ == "__main__":
    register()

Here is another example that dynamically generates n panels.  Test script uses driver namespace to hold panels to unregister while running from __main__

Gives some options to play around with. There is a bl_order flag that the base PropertyPanel (Custom Props) uses always be at the bottom.

import bpy
from  bpy.app import driver_namespace as dns

for p in dns.get("panels", []):
    if getattr(p, "is_registered"):
        bpy.utils.unregister_class(p)
else:
    dns.get("panels", []).clear()

from random import shuffle

use_parent_zero = True
hide_second_headers = False
n = 5 # number of panels
shuffle_order = True
random_shuffle = False

order = list(range(n))
if shuffle_order:
    shuffle(order)

class TestPanel:
    bl_category = 'TestPanel'
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "object"
    bl_order = 0

    def draw(self, context):
        layout = self.layout
        cls = self.__class__
        layout.label(text=f"{cls.bl_label} Order {cls.bl_order}")

panels = [type(f"Panel{i}",
                (TestPanel, bpy.types.Panel),
                {"bl_label" : f"Panel {i}",
                 "bl_idname" : f"TEST_PT_Panel{i}",
                 "bl_order" :  TestPanel.bl_order + order[i],
                 }) for i in range(n)
                 ]

panels.sort(key=lambda p : p.bl_order)
if random_shuffle:
    shuffle(panels)
print([(p.bl_label, p.bl_order) for p in panels])
for i, p in enumerate(panels):
    if i and use_parent_zero:
        p.bl_parent_id = panels[0].bl_idname
    if i % 2 and hide_second_headers :
        p.bl_options = {'HIDE_HEADER'}

    bpy.utils.register_class(p)

dns["panels"] = panels

About the only conclusion is sub panels are displayed in registered order.


How to add empty object not using bpy.ops?

This is possible by placing None as the object data:

#                          Name,   Data
o = bpy.data.objects.new( "empty", None )
bpy.context.scene.objects.link( o )

You can later access its unique empty props like any ol' empty:

o.empty_draw_size = 2
o.empty_draw_type = 'PLAIN_AXES'

For Blender 2.8, the API change a little bit:

o = bpy.data.objects.new( "empty", None )

# due to the new mechanism of "collection"
bpy.context.scene.collection.objects.link( o )

# empty_draw was replaced by empty_display
o.empty_display_size = 2
o.empty_display_type = 'PLAIN_AXES'


Extend strip to current position (or marker) in VSE

If you select start point of strip instead of full strip, Shift+S will do exactly what you want:


I don't seem to be able to reproduce your issue, but seeing you are trying to render directly to video i suspect the problem is in encoding and would strongly advice to render as image sequence instead and then render the video from sequence, as described for example in How to render an animation as video in Blender? , which is better workflow in general as well.


Is there a way to render overlapping geometry as different passes/layers?

I found a way with Cycles for my use case by using the Transparent Depth of the Light Path node.

A transparent shader is mixed with the original shader based on the pass index required. If the transparent depth is equal to the pass index, then it should use the original shader, otherwise it should be transparent.

Node setup:

Sphere 0-1 indexes:

Suzanne 0-3 indexes:


object disappearing after using Boolean modifier

I did a bit of experimenting on your .blend file. Turns out that if I go into edit mode on the cylinders, press P>By Loose Parts (To make them different objects) and then move them to a new colloection, and then set the boolean type to collection and put in that cylinder collection, the boolean works and doesn't make the mesh disappear.


What is the most efficient way to finely "slice" layers though objects with python

A more straight-forward approach.
Not sure this is "most efficient" but it's relatively quick and is a straight forward load mesh into bmesh & single bisect cut per rep
Now it's clearer the result desired, re just the edges of the bisect cuts have re-jigged answers from
Python: Bisect mesh into n parts, without separate 'LOOSE'
How to extract side-view outline (e.g. top view) of a 3D object to 2D surface?
to create objects using the result of the bisect operator.
Notes.

Suprisingly it was quicker to constantly reload the bmesh rather than use recycling the same

For example sake have simply run from (0, 0, -1) to (0, 0, 1) local coordinates to test on sphere / icosphere / cube etc.

See Replace matrix @ vector list comprehensions with something more efficient  re a fast way to convert between spaces and calculate the required limits.

To convert the bmesh to global (or another space) use bm.transform(matrix)

To use a mesh with modifiers and shapes applied use bm.from_object(ob, depsgraph)

Other commented out code re attempts to squeeze out a bit more speed, have AFAIK left those that ran the quickest.

Test script.
import bpy
import bmesh
from mathutils import Vector
from bpy import context

def slicer(ob, start, end, cuts):
    #slices = [] could instead return unlinked objects
    axis = end - start
    dv = axis / cuts
    #axis.normalize()
    mw = ob.matrix_world
    bm0 = bm = bmesh.new()

    # transform to world coords
    # bm.transform(mw)
    # mesh = bpy.data.meshes.new("Slice")

    for i in range(cuts + 1):
        bm.from_mesh(ob.data)
        #bm.from_object(ob, dg) # use modified mesh
        #bm = bm0.copy()
        #bm.transform(mw) # make global
        plane_co = start + i * dv

        cut = bmesh.ops.bisect_plane(
                bm,
                plane_co=plane_co,
                plane_no=axis,
                geom=bm.verts[:] + bm.faces[:] + bm.edges[:],
                clear_inner=True,
                clear_outer=True,
                )["geom_cut"]
        if not cut:
            bm.clear()
            continue
        me = bpy.data.meshes.new(f"Slice{i}")
        # me = mesh.copy()
        bm.to_mesh(me)
        '''
        # only slightly slower
        me.from_pydata(
            [v.co for v in cut if hasattr(v, "co")],
            [(e.verts[0].index, e.verts[1].index) for e in cut if hasattr(e, "verts")],
            []
            )
        '''

        slice = bpy.data.objects.new(f"Slice{i}", me)
        slice.matrix_world = mw
        context.collection.objects.link(slice)
        bm.clear()
        #bm.free() # if using bm = bm0.copy()
    #bm.free()

slicer(
        context.object,
        Vector((0, 0, -1)),
        Vector((0, 0, 1)),
        200)

Timing it.
Using the decorator method
REPS = 10
import time
def time_it(func):
    from builtins import print
    def wrapper(*arg, **kw):
        t1 = time.time()
        for i in range(REPS):
            ret = func(*arg, **kw)
        t2 = time.time()
        print(func.__name__, (t2 - t1))
        return ret
    return wrapper
@time_it
def slicer(....

10 Test runs of 10 reps making 200 cuts in default UV sphere.  Using the command for your script of
slicer(0.01, (0,0,1)) #

which should be 200 cuts on default sphere at origin.
To time the two scripts, after removing prints from yours  to make things relatively equal (as mentioned didn't calculate the bounds of mesh, however as shown in link provided using numpy or other methods, it's hardly rate determining) consistently came up with a speed ratio, this answer to yours of around 8 to 11.
However an issue was yours is making 2500 objects, whereas mine makes 2000 over 10 runs, which will also account for some time differential when fixed.
Not seeing the glitch.

Unfortunately there seems to be a glitch where sometimes layers are
lost or only partially formed - I think it's a bug in the bisect
function, not my code - eg bottom photo: the icosphere is missing the
middle layer if the slice would be at exactly the midline of the
icosphere .

No issue with code above run on icosphere,

Left using 2 cuts (prob should be segments as it's 1 middle cut) and on right with 200 and middle edge ring selected


Blender doesn't change the textures in any way by itself and this applies to all possible actions.

The texture size does not necessarily define its quality, it depends on the source (image texture, procedural material, tiling, up/donwscaling...) but normally I'd say that everything from 1k upwards is fine.

You might want to check Blender's System Settings. Hit Ctrl+Alt+U, go to "System" and play around with the settings for "Mipmap" and "Anisotropic Filtering". Deactivating them seems to help in many cases.


I looked over the file and found that over huge parts of the object there are faces overlapping other faces:

Some connected some not. While using a remesh modifier with a low enough voxel (roughly 0.08) size results in the geometry to be clean again:

The resulting mesh will have a throughout higher density and i do not know if you want to retopologize your dragon, as that might be the best way to reduce the density again.

I tried to use the decimate modifier and it actually resulted in similar artifacts, so retopo seems to be the best choice.

Another option going out from the version you shared, would be to cut away half of the dragon and using the mirror modifier. Then you would have to go over half the dragon and manually remove all the overlapping faces, believe me, it will be a good timekiller. Retopo seems in my humble opinion to be the better option.

Happy Blending


Assosiating STL with Blender no longer works, you have to use File -> Import -> STL now.

This is because STL used to be written in C and loaded the same way *.blend files were, but now its an addon.

Note, its possible to make a shell script or batch file which you can assosiate STL with, that calls blender with the addon, though this isnt completely straightforward and will require some small Python snippet to run the importer.


How to rotate/pan Blender viewport like the Meshlab trackball?

There's a setting for that under Main Menu > Edit > Preferences > Navigation Tab > Orbit & Pan choose: Orbit Method: Trackball

Otherwise Blender will constrain you to turntable rotation, which does not allow full free rotation around all axes (it keeps the Z-axis upright while rotating).


Cannot apply modifier via script despite object being active?

bpy.ops.object.modifier_apply(modifier='Mirror')

This command requires you to give it a modifier name.

bpy.ops.object.apply_all_modifiers()

This will apply all modifiers.  Note, this is a operator from addon 'Modifier Tools'.  You have to have this addon enabled to be able to use that command.


There is no one set way to do this. It depends on what you are going for, what you are modeling or any special cases you are adhering to, etc.

In your case here, since you have basically two flat surfaces, you can add supporting edge loops to the outer mesh and join the matching edges together by selecting the edgeloops and manually filling each one with F, the images differ a bit but I think you get the point. (Also, your flat outer mesh does not seem to need so many loops at the moment, you can remove some.)

In the example above you can also bridge the two edge loops by using Ctrl + E > Bridge Edge Loops after selecting the outer and inner edges to connect. This only works when the amount of edges are equal in both loops, but it will give a nice and cleaner result.

Or you can just select an edgeloop and use Alt+F to fill the gaps. (I added an edgeloop to the middle of the frame in the image below before filling and aligned it accordingly with the other mesh so it stayed flat.) You can do the same or use one of the existing ones depending on what you are going for.


This is the just the dependencies graph not updating in the right time just as you speculated. The value 101° is actually the result of the driver at frame 45 while the value 96.2° is actually the result of the driver at frame 43. The true value of the driver at frame 44 is 98.5°.

When you approach the frame 44 from the left, the last computed value is at frame 45, so its value is used. When you approach the frame 44 from the right, the last computed value is at frame 43, so its value is used. If you updated the dependencies at the frame 44, the true value is used.

I don't think there is an easy way to solve this, and this is one of many reasons I stopped using drivers. I recommend using Animation Nodes instead.


Is 2000 materials a lot? Is there a better way?

Is 2000 materials a lot? It's a big number, but Blender can handle it. The real question is; is there a more manageable way. Maybe a way that lets you define one material, and use some property of the individual objects as a source for the color?

Yes there is. There's two parts to this answer.

Step 1 : Vertex Colors (layer)

Using a obj.data.vertex_colors on the Object's Mesh to set the RGB of the faces. This is per vertex per face, the code is very simple.

import bpy

obj = bpy.data.objects['Cube']
mesh = obj.data
polygons = mesh.polygons
vcols = mesh.vertex_colors

if len(vcols) == 0:
    vcols.new()

color_layer = vcols["Col"]

r, g, b = 0.3, 0.2, 0.9

for face in polygons:
    for v_idx in polygons[face.index].loop_indices:
        color_layer.data[v_idx].color = r, g, b

Step 2 : Shader Tree 'Attribute Node'

This Node has a text field where you can specify the vertex_colors layer by name, by default it's 'Col', but you can name it what you like.

To see the effect of the vertex_color layer in the 3d viewport (without rendering) Swith to Vertex Paint mode

Assigning one material to mutiple Objects

Once you have a material configured and want to share it over all objects in question, you can iterate over all these objects and do:

common_material = bpy.data.materials[some_named_material]
for obj in objects_in_question:
    obj.active_material = common_material

Things to consider

You raised another question about whether it might be easier to create the cubes as part of one object. That's totally doable if you keep track of the vertices and indices of the individual cubes ( at that point they are disjoint submeshes ) and when you know the face indices of each cube setting the vertex_color layer information is easy enough.

Doing it all as one object means you will need only 1 vertex color layer, and 1 material.
You could even use the foreach_set construct, it's perfect for meshes with uniform vertex-per-face counts (ie, all Tris, all Quads.. all N-gons)

 # flattened_list = [r,g,b,r,g,b,r,g,b,r,g,b,.....]
 obj.data.vertex_colors[0].data.foreach_set("color", flattened_list)

https://gist.github.com/zeffii/1a7d6800559f9ee902f8 shows how to do it for an Icosphere

import bpy

# default 80 faces, all Tris
obj = bpy.data.objects['Icosphere']

# note the range is 80 * 3
flattened_list = []
[flattened_list.extend([0.5, 0.3, 0.7]) for i in range(80*3)]

obj.data.vertex_colors[0].data.foreach_set("color", flattened_list)
obj.data.update()

Keeping the objects separate means you must use a vertex_color layer for each object, but you can share the common material.
Using thousands of materials for thousands of objects is certainly OK too.

Which of these options is the best depends on your scenario.

Code simplicity vs Efficiency
Efficiency vs 'How important is Efficiency'

How important is Efficiency: Is a High real-time framerate a requirement or is it being rendered and is the efficiency of your method not a real concern.


Add object constraints and link to an object

Some tidy up.

In addition to @Leanders answer re limiting the constraint when using transform (which I've added in code below),  Note doesn't stop you setting  the z rotation property in UI to whatever..

If we wish to use context, would select those to add constraint to before script and then run from the context.  This is the fundamental concept of the context-operator paradigm. eg to run on object "A" select only "A" and run script below.

Test script. Adds constraint for all selected objects.  Note uses the reference to the newly created constraint con. It will have the default name only when there are no others with that name. Otherwise you add a new one and set the old one.

I use context = bpy.context in test scripts, so they can be simply copied and pasted into operator or panel code later, where context is passed as an argument.

Added code to remove other constraints of same type first.

import bpy

context = bpy.context

ob = context.object

for o in context.selected_objects:
    #o.constraints.clear() # removes all

    # remove other constraints by type
    lrcs = [c for c in o.constraints if c.type == 'LIMIT_ROTATION']
    while lrcs:
        o.constraints.remove(lrcs.pop())

    con = o.constraints.new( type='LIMIT_ROTATION')
    con.use_limit_z = True

    con.influence = 1
    con.min_z = 0.0872665
    con.max_z = 0.0872665

    con.owner_space = 'LOCAL'
    con.use_transform_limit = True

If you know the name of the target object is "A".  Unless you are going to later use operators on this object, there is no reason to set it as active and selected (context) to add modifiers to it this way.

scene = context.scene
o = scene.objects.get("A") #  if there is no object named A it will be None
if o:
    con = o.constraints.new(...) # as above.

For other constraints that need a target set, for example to add a constraint to each selected targeting context object

obs = context.selected_objects #safe to manipulate this prop
obs.remove(context.object)
for o in obs:
    con = o.constraint.new(...)
    con.object = context.object


I don't know if is this that you are looking for, but there is an option to move the mirrored bones if they have names like arm.L/arm.Left and arm.R/arm.Right.

Its named X-Axis mirror and you can find it in the Options Tab when pressing T while in the Edit Mode.


Cannot execute boolean operation for hexagonal mesh

Your torus grid layer consists of 5 disjoint grids. Those sections match up quite well with each-other to give the impression that they are joined, but  topologically they intersect. The Boolean modifier chokes on self intersecting meshes.

Do you really need this grid to be hollow tubes, it's not a hollow tube in reality - worth considering that as a way to make the operation a little lighter processing wise.

The best geometry for the boolean is geometry that has no intersections, no double vertices. This means you must spend more time making such a grid, perhaps a script is the way to go.

You can see in the closeup that your geometry isn't as clean as you think.

If this answers the 'why' to your Boolean misfortune, perhaps the real question should be how to make such a grid to your exact specs.


3D print tablet wall recessed mount incomplete

Newer

Normals Recalculate Outside

Edit Older Disregard

Use Make Normals Consistent.  This will help.


Why can't I sculpt on a plane when using Subdivision Surface?

Subdivision Surface modifier (or Subsurf) isn't designed to work with sculpting. Subdivisions added with it are accessible for sculpting only once the modifieir's applied. Multiresolution is the one which is designed for that, allowing to edit subdivided surface with sculpt brushes. There doesn't seem to be any real reason to sculpt with Subsurf.


If by "amplify" you mean make the shadows sharper, adjusting the emitter's size down will sharpen them.

If you mean make them darker, one easy way is to change the "Look" of your scene's Color Management (in the Scene tab of the Properties window, under "Color Management") to a higher contrast look, such as "High Contrast" or "Very High Contrast"

Filmic base contrast:

Filmic high contrast:

For more control, in Cycles you can create a "shadow catcher" object (Properties window, Object tab, under "Cycles Settings", tick the box next to "Shadow Catcher").  Put it on its own layer, set up a separate render layer for it, then use the compositor to darken the shadow catcher render layer and overlay it onto the other layer.

Here is an example involving an emitter, a cube, a ground plane, and a duplicate of the ground plane which serves as the shadow catcher.

Emitter is on layer 20.
Cube is on layers 1 and 11.  Layer 11 will be a "mask" layer, so no shadow will appear on top of the cube in the final composite.
Ground plane is on layer 1.
Shadow catcher plane is on layer 2.

The render layers are set up as follows:

Note that Film must be set to "transparent" in the Render tab of the Properties window.  If you need to render the environment, you can add an "Environment" pass to your object render layer and composite it in.

Here is one way to set up the compositor nodes:

You can use the "Bright/Contrast" node to further enhance the shadows, but simply combining the shadow layer with the other layer using "Alpha Over" darkens the shadows considerably.

Here are the output layers (object layer, shadow catcher layer, combined):

And, finally, here is the combined output if I use the "Bright/Contrast" node in the compositor to set Brightness to -2:


How to construct a pyramid in blender but the edges of the triangles to be equal?

The formula for the pyramid you are describing can be found on Wikipedia. Look for the formula for the height of the 'Johnson Solid J(1)':

$$
H = \frac{1}{\sqrt{2}}a
$$

Where $a$ is the edge length of your pyramid.

Constructing the pyramid is pretty easy now: Start with a plane of the desired size. I started with the default plane (edge length of 2):

Now go into edit mode, select one vertex and extrude it (it does not matter which one or how far).

In the properties shelf you can now set the coordinates of the vertex. The properties shelf is the one to the right of your 3d viewport which you can toggle by pressing N. Under 'Transform' set the x- and y-coordinate to 0, and the z-coordinate according to the formula from Wikipedia. Since Blender can interpret some python commands in the number fields you can type in the formula directly:

Now always select three vertices that should form a pyramid side and connect them to a face.

To make sure your normals are all pointing outwards, select everything and press Ctrl+N to recalculate them.

To see the angles between faces go to the properties shelf again, scroll down to 'Mesh Display' and enable the 'Angle' checkbox under 'Edge Info':


Cycles Render Pixleated when rendering (Example of a minecraft image)

You have to increase the samples of the rendering.

For further information:

How to avoid noisy renders in Cycles?


The problem is that your Render Resolution Y = 399. You didn't mention your render settings but I assume that your output format is: FFMPEG Video with an H.264 codec. The way this encoder works is by dividing your image into macroblocks of a fixed size (e.g. 4x4) and compress these blocks in parallel. Therefore your width and height must be divisible by 2.
If you should change your Height to 400, I think the problem will be fixed.
If you need this 1500 x 399 resolution, you can render it out as a PNG sequence. Then, you can use FFMPEG to create a movie (e.g. MP4) of it. There are plenty of solutions on the internet to do this; see for example https://stackoverflow.com/questions/60788967/ffmpeg-width-not-divisible-by-2-375x500-error.
You will find a more elaborate answer for this common question on https://vse-docs.readthedocs.io/extra-tools/ffmpeg/ffmpeg.html


How to make a report bug button in add-on?

The Report a Bug button will be added automatically if you add the tracker_url key to the bl_info dict of your add-on. See the following example:
bl_info = {
    "name": "3D Simple X",
    "author": "8N Films",
    "version": (1, 0),
    "blender": (2, 92, 0),
    "location": "View3D > Toolbar > 3D Simple X",
    "description": "Very Simple and easy! Add everything you want!",
    "wiki_url": "",
    "tracker_url": "https://github.com/user/add-on/issues",
    "category": "8N Films",
}

More about 'Script Meta Informations' and a complete list of available keys, you can find in the official wiki: https://wiki.blender.org/wiki/Process/Addons/Guidelines/metainfo


Curve modifier, deformation only on Z axis

Array a Z deformed panel

No, the Curve modifier has no option for that yet.

The trick you can go for at the moment is to Shear your panel and set up an array modifer that not only offest on the X axis, but also in the Z of the right amount to build a seamsless mesh.

Luckily stairs usually have steps that are evenly spaced on Z, so the linearity of the height growth imposed by the usage of the Array modifier should not be a problem in this case.

The curve is now defining only the path of the rail on plan:

Note for example that in the picture there the tile is romboid shaped, not squared shaped.


Is a triangle with 4 verts considered a quad?

Yes, it is a quad, even if two of the edges are exactly in a line. If, for example, you were to use triangulate (Ctrl + T while in Edit mode) you would find that it was split into two tris (hopefully from the bottom right point to the middle left one).

I generally find making tris into quads like this makes for a messier model, though, unless there is a reason for it. If it works with your mesh, then go for it, but if you are just doing something like this to have quads, I don't think it's a great idea (feel free to correct me if you think I'm wrong).


Keying node in compositor. How can I associate the alpha channel so that it works with the Alpha Over Node?

There are potentially a few issues with either "Convert Premul", converting alpha, or a simple multiply across the channels, that may not be entirely obvious at first. It is a point of confusion in that that no node should deliver unassociated alpha as the entire compositor assumes associated values. Sadly the node used here, does.

One issue, with particular attention to pulling a key, is that your edges will likely not be of the correct luminance value to blend seamlessly. That is, when a subject is shot against a green screen, the alpha channel that is produced would be a ratio of the foreground against the background, which in this case is some non-black value of the screen used. The resulting output ratio isn't going to be the same as an object set against non-emitting pixels. Those semi-transparents can be extremely tricky to get the ratios correct on without having a good grasp on the behind-the-scenes models.

The second issue would be with associating is that you can destroy RGB information. As per the OpenEXR Technical Introduction, alpha with a greater ratio RGB is entirely valid and represents emission with a lower degree of occlusion. The problem is that if you craft this in an RGB image, zero alpha will destroy this information on the multiply.

  Calling the color channels “premultiplied” does not mean that the
  color values in an image have actually been multiplied by alpha at
  some point during the creation of the image, or that pixels with zero
  alpha and non-zero color channels are illegal. Non-zero color with
  zero alpha is legal; such a pixel represents an object that emits
  light even though it is completely transparent, for example, a candle
  flame or a lens flare.

  In the visual effects industry premultiplied color channels are the
  norm, and application software packages typically use internal image
  representations that are also premultiplied.

To work around this, a carefully crafted RGB against zero emission RGB values can be associated manually.

Once you have a representation of your emission levels in RGB, which is effectively RGB values against black, you can use whatever technique you desire to assign the alpha channel. For example, if you have a blue glow with low or zero occlusion (alpha), you would want the equivalent occlusion values properly set into your base. "Set Alpha" will assign the alpha directly to the alpha channel, and the result should be correct[1].

TL;DR in your sample, "Convert Premul", using the alpha conversion node, or strictly a simple multiply will all work as expected, with a rather large caveat being the first issue above. You would ideally want your image to represent emission on the semi-occluded pixels, which as any keyer would tell you, is quite a dance of artistry. Using that canned After-Effects-Esque "Keying" nightmare node won't help either, as it assumes a single luminance / RGB value to compare against across the whole green screen, which is never the case, and will result in whack or rather cheated values, which will impact your final composite. An alternative that might get you closer is to inpaint and use a distance node on the RGB values, which will at least pull data from the fully non-occluded plate elements and push them into the semi-transparent regions. This will result in a luminance difference that is closer to what was behind the actual pixels in question.

[1] Note that there are largely two primary methods to do this. One is probabilistic, aka A+B-AB and the other is non-overlapping, which is A+B. If you are certain your geometry doesn't overlap for the pixel in question, the latter is correct. If your geometry overlaps, such as a transparent window atop of another transparent window, the former is correct.


Custom trackpad pan/zoom/rotate behavior add-on

go to preferences, input, emulate 3 button mouse


Check the Amount, it should be on $1$ and the Offset on $0$. I cannot seem to get this modifier to work on 2.9

I am not sure if this was what you're after, but my Amount in the modifier tab is at $1$ and the Offset is at $0$


It's not that hard,  but not particularly obvious either.

Switch to edge select mode using the button at the bottom of the 3D view.
Select the edges you want to add vertices to.
Hit W > Subdivide. (Not Subdivide Smooth! Unless you want your new edge to be rounded, which doesn't sound like the case here.)
(Optional) Switch back to vertex mode.

That's all there is to it!


Rotate Individual Origins Of An Array Of Faces With Proportional Editing On

I don't totally understand but if your trying to rotate on the faces origin just change pivot point to individual origins.


Have you played with the "Light Falloff" node?
Just add the node into your light material and try the different falloff types.

But you can go further if you play with math nodes. First you need to understand how to build them:

Constant falloff : same strength everywere, no matter if you're close or far from the emitter.
Linear falloff : strength decreasing with the distance (strength = 1/distance).
Quadratic falloff : same as linear but decreases faster (strength = 1/distance²).

Now we can play with math nodes to get tweaks and lower strength values.

I'm using your file but I had to fix your plane (removed doubles and useless perpendicular face)


Node compositing - How to switch colours in frames

You can keyframe any color. Just move to the time where you want the change to happen, hover over the color field and hit I. It'll get a yellow outline. You can keyframe almost anything in Blender. Not everything, but close. (Remember to set a key frame on frame 1 so the original color is kept.)

The only other thing you need to do is to go into the Graph Editor and set the interpolation to constant. That will make sure the color will stay the same until the next key frame. Otherwise the colors will slowly blend into each other.

Just select the node with the keyframed color and the curves will show up in the Graph Editor. There you can select constant interpolation with T, SHIFT-E or the menu (Channel >> Extrapolation Mode)


If you don't want gravity inside your simulation, it is very easy. Inside the physics properties of the domain, scroll down to the bottom at "Field Weights" and drag Gravity to zero.


When I used add material option it added a principled bsdf node, I replaced it with Diffuse BSDF and it worked correctly. I don't know how. It's a possible workaround.


Mid point between levels on subsurf modifier

As Timaroberts said, the preview and render settings need to match for it to be the same. This means that it will not work if you are using the adaptive subsurf setting on the newer versions of blender.

Occasionally you will need to reload blender before the viewport preview matches the final render when the preview and final are the same.


how to set camera fov and focal lens independently?

The field of view is determined largely by two factors: the lens length and the sensor size (we're going to leave focus distance out of this calculation to keep it simple). So changing the lens size will always change the field of view, unless the sensor size is changed accordingly to compensate.

Increasing the length on the lens will make for a smaller field of view (like a telephoto in a camera). A shorter lens would have the opposite effect, the field of view would be much wider (like in a wide angle lens). How much will depend on the sensor size.

In my opinion, the simplest answer for what you need would be that if you know the field of view you really don't need anything else. Just set it to 69.9 and don't worry about the sensor or lens size.

Knowing the sensor size from the manufacturer might not be the answer either, we don't know many things: how much of the sensor is actually used? Are the measurements of the sensor (and field of view) you are given for the width, height or diagonal. What is the aspect ratio of the generated image? Also there are many things in the real world that do not meet the specifications of the manufacturers (is the 4mm lens really 4mm?)

If you want to make a simulation (for depth of field reasons maybe)
that uses a 4mm lens covering a field of vision of 69.9 degree, then move the sensor width until you get to the numbers you want (5.591mm)

Notice that the field of view you just set up is only good for the Camera view.


The drop-down menu (top left) is context-sensitive. Select your Armature in the Outliner (on the right side). This will bring back the Pose Mode.


Why has a circle when the point light through my glass？

When looking through glass, the light path is considered a transmission ray instead of a camera ray, and the full sphere of the point light is visible to transmission rays. Point lights in Cycles are not true point lights unless size is set to 0 (as these are non-physical and usually look bad). If size is > 0, you instead get what's technically a spherical area light. And like a regular area light, the surface is visible through glass (and in reflections). As far as getting rid of it, there's a bunch of possible solutions:

You can just hide the lamp from transmission rays by unchecking object data > Cycles Settings > Transmission. But this will also make the lamp not cast light when viewed through glass, which I suspect isn't the result you want.

A better solution is to change your glass to not be true glass. Some render engines have an "architectural glass" shader designed to fix this sort of issue. Cycles doesn't have one, but the node system allows you to recreate one pretty well:

This glass will not refract, but otherwise looks exactly like the glass shader. For very thin and flat panes of glass, the refractive effect isn't very noticeable anyway, so you can get away with this. It will still reflect like glass, but as far as light rays are concerned, objects seen through it are still viewed directly ("camera rays"). Not only will this keep lamp objects hidden, but it also has some other nice side effects, like passing the alpha channel through, and preventing clamp indirect from affecting things seen through the glass.

Technical mumbo jumbo P.S.

The geometry > backfacing node is to prevent reflections on the backface, which would otherwise appear black. There's actually a slightly neater way to do this, as fresnel - backfacing, rather than fresnel * 1-backfacing as in the other setup. Doesn't really matter, but it's a little cleaner on the nodegraph at the cost of being slightly less intuitive:


Texture space vs. poly count: Which is optimal / best practice in a game engine?

Technical Investigation

Most modern 3D game engines and GPUs can technically deal with a very high polycount. The main reason why game companies cut them down is to make games playable on lower-end systems and also consoles (once they are 3 to 4 years old, they can't keep up with a modern high-end PC) and mobile platforms. Therefore it's important to plan for the game engine and also the hardware platform you are aiming for.

One problem that remains across all platforms and all 3D game engines is that too many materials put a high load on the system. Loading and processing materials produce draw calls, therefore you want to keep them as low as possible by reducing the materials to the bare minimum for each model.

If you want to go deeper into the topic, I highly recommend to read Simon Scheibt's "Render Hell".

Modeling 3D Game Assets

If it comes to the question of "good practice" or "best practice", you possibly get more than one answer, depending on who you ask.

Reducing polycount has been the subject of controversial debate for a long time. Some people say that triangles are bad in general (even for assets that aren't animated), others tell you the complete opposite.

Personally I follow the rule "If it doesn't change the visual appearance of a model (geometry and shading), it's not necessary".

My "working model" is composed entirely of quads. Then I create a copy of it and add detail for the high-poly version. A second copy will be the final low-poly version, where I eliminate all unnecessary vertices by sliding them across the edges without changing the geometry.

Another good method to keep the polycount down without loosing too much detail is to compose assets out of several submeshes, when necessary.

While it's always nice to have a "clean topology" there are certain cases where it simply doesn't make sense, for instance if you have to add many additional loopcuts and vertices for the sake of keeping your asset as "one mesh".

One Mesh (including submeshes) and one Material per Asset

Simply put, that's the second rule I try follow, whenever possible. Big models like buildings are problematic when it comes to texture space. In this case I'm a big fan of the modular approach (as known from the Elder Scrolls since Morrowind and Fallout 3, NV and 4).

Another method of adding detail to diffuse maps without creating insanely big textures is using secondary maps or detail textures. Modern 3D game engines like Unity 5 and UE4 are capable of cross-blening a second material onto a model, when the camera comes close to it.


How can I get my usual interface when opening projects created by other people?

Everyone uses blender in a different way and reconfigures the user interface to their needs. The user interface is saved as part of the project.

You can load other people's projects using your own user interface this way:

Close the project.

Then go to file open, uncheck the load UI box and then open the project.

In newer versions you need to click on the gear on the top right of the window to see the LoadUI option.


how to follow a list of splines one after another

After playing a while with the nodes you have used, I discovered that the Object Action Output Node expects to start with frame 1 for each subsequent action. You might put a math-node with Modulo selected between Time Per Char Node(b)  plus * *(a) and the Frame input from the Object Action Output Node to get what you want.


I have solved this problem, You must set the length of the arm in the IK or else it will think the parented bone chain is part of the deformation.


How to make the sequencer 'Preview' area fullscreen with python?

After realizing I wanted this feature as well, I have been giving this some thought.  The script shouldn't be trying to figure out which preview to full-screen (there may be more than one preview), it should let the user decide that.  This can be accomplished by moving the check for the space view_type into the menu_append function, and having the operator just use the passed in context.

I was also thinking about how to close this preview, and I think the best way to do so would be to just use a modal operator for the whole thing, and revert everything once it ends.

So, after some reworking, here's the code I came up with:

import bpy

class SEQUENCE_MT_true_fullscreen(bpy.types.Operator):
    """True fullscreen preview"""
    bl_label = "True Fullscreen"
    bl_idname = "sequencer.true_fullscreen"

    runs = 0
    original_area = None

    def invoke(self, context, event):
        self.original_area = context.area
        bpy.ops.wm.window_fullscreen_toggle()
        self.runs = 0
        context.window_manager.modal_handler_add(self)
        return {'RUNNING_MODAL'}

    def modal(self, context, event):
        if self.runs == 0:
            override = context.copy()
            bpy.ops.screen.screen_full_area(override, use_hide_panels=True) #This has to be delayed because if it is run in the invoke function, it crashes blender...
        if self.runs == 1:
            bpy.ops.sequencer.view_all_preview() #This has to be delayed because if it is run right after the screen_full_area, it crashes blender...
        self.runs = self.runs + 1
        if event.type in {'RIGHTMOUSE', 'ESC'}:
            bpy.ops.wm.window_fullscreen_toggle()
            bpy.ops.screen.header()
            bpy.ops.screen.back_to_previous()
            override = context.copy()
            area = self.original_area
            override['area'] = area
            override['space_data'] = area.spaces.active
            for region in area.regions:
                if region.type == 'PREVIEW':
                    break
            override['region'] = region
            bpy.ops.sequencer.view_all_preview(override)
            return {'FINISHED'}
        return {'PASS_THROUGH'}

def true_fullscreen_menu(self, context):
    if context.area.spaces[0].view_type == 'PREVIEW':
        self.layout.operator(SEQUENCE_MT_true_fullscreen.bl_idname)

def register():
    bpy.utils.register_class(SEQUENCE_MT_true_fullscreen)
    bpy.types.SEQUENCER_MT_view.append(true_fullscreen_menu) # add to "view" vse header menu

def unregister():
    bpy.utils.unregister_class(SEQUENCE_MT_true_fullscreen)
    bpy.types.SEQUENCER_MT_view.remove(true_fullscreen_menu)

if __name__ == "__main__":
    register()

Note that I had to use the modal operator to delay a couple operators, or blender crashed -_-

edit: fixed that last issue!


I'm not sure what is exactly your problem as your mesh is a bit messy.

First, to clear you object a bit: In Object mode, ctrl A to apply scale. In Edit mode, select all and W > Remove Doubles, and also ctrl N to recalculate the normals.

Now, you have inner faces, it makes the Solidify a bit complicated because it will not only thicken the external walls but also the internal, and you will probably have faces crossing and overlapping each others. So if you want to use Solidify you should better create separate objects, ie separate floors form walls from roof.

I hope it will fix your problems...


Which object should be selected when selected to active is check for texture baking?

The active object is the same no matter what action you are performing in blender.
The active object is always the object you selected last.
When using the default theme, the active object is outlined in yellow, and all other selected objects are in orange.

If you selected your object in the wrong order, you can just ShiftRMB  on the object again to make it the active object.

To remember the selection order for baking is simple when you know what the active object is. Just say selected to active. Now think, you are baking from the selected object to the active object.


How to get reference clip to start in middle of timeline?

Texturing a plane with a video/image- For a Background Image see Edit below...

I'm using vers 2.77a here so 2.79 might be a little different. Here goes -

Select your model first in the 3D window.

At the extreme right are the 'Properties panels'.  The one with a small brown sphere is the "Material properties panel"  Click on that.

Go to the Texture properties next.  That's shown as a tiny coloured checkerboard of
sorts.  Click on that.

Go down to the "Image" tab and open that.

Down near the bottom is a tick-box called "Auto Refresh".  Make sure that's ticked to
make the video play.

At the left of that is a pair of slots - "Start & Offset".

Click in the "Start slot and enter the Blender timeline frame-number that you want the video to commence playing from.

The Offset slot points to the frame number within the video-clip itself that it's to treat as it's first frame.  (like pulling a tape or film strip through a player and starting from there)

EDIT 27th April 2019 - re Movie clip as a Background Image -

The same applies in the bkd image's panel.

Press N to open up the Viewport's properties. Scroll down to the "Background Image" tab and open that.  Click on the image folder icon to open your movie.

In there you'll see the same tick-boxes and entry slots as mentioned above.

You'll notice the "Opacity" slider is set at half by default.  Wind it up to 100% for full opacity.


If you can easily select the vertices that you want to separate, then in edit mode press P > By Selection. You may also be able to use the By Material if the materials are different or By Loose Parts if the objects are not connected.
By Selection:

By Materials:

By Loose Parts:


How can i disable a particle base object from render?

Disable "show emitter"

Will have effect in rendering only (not when viewport shading is set to rendered).
Seems I've misunderstood the question. To hide the original particle object, put it in another collection and disable this collection for rendering.

Note that if the PS instances are based on a collection, move this collection in another one and disable this last one for rendering.


How do I get my offset models to be at 0, 0, 0?

Switch to 'Edit mode' (Tab key).
Press A key. This will select all the verts in the model.
In Orthographic view (Numbad 5) move the selected group of verts over the orange dot (the origin).
Repeat this step in orthographic view for X, Y and Z.
Back to Object mode, select the model, choose Object> Apply> All Transforms. This just resets any scale or transform issues.


The hair particles are added to your mesh object through the modifier system. You can enable/disable the effects of any modifier for viewport and rendering, the camera is for rendering and the eye is for the viewport.

For particle systems you can also adjust the visibility within the particle settings.


Making a smooth transition from full alpha opacity to full transparency

Your issue is that you are applying the gradient to the color of the transparent shader, instead of using it to control how the two shaders are mixed. Since your factor slot is empty, they are just being mixed with a factor of 0.5 across the whole surface.
My result:

The nodes:

Explanation
To transition from a color to transparent, you essentially want to mix the two shaders, here a transparent BSDF and an emission shader, with the mix factor increasing along the gradient. For a simple gradient along the X axis, I used a color ramp, but you could apply the same process with any other gradient texture. Here, I want a value from 0 to 1 along the color ramp based on the X position on the object, so I plug in the X component of the Object coordinates as the factor to the color ramp, and use that to control the mixing.


How to make a varnish transparent effect?

You could create a mask for the area that is supposed to be glossy:

then plug it into the Roughness factor of the Principled BSDF. Mix it with a bit of noise if you don't want it to be too clean, and use this setup to create bump if necessary:

it should work:


There is no alpha channel behind the bars, just around the window.

This image shows the alpha channel you have on your image.
To make it transparent use the following node setup:

To make the black areas of the images transparent you need to edit the image on an image editor (like photoshop or gimp), or add acolor ramp to control the transparency on a new mix shader.


Yes the vertices have to be inside. This tutorial might help: https://www.youtube.com/watch?v=0r-cGjVKvGw


Graphic card not detected when installing from flatpack or .deb

Flatpack, Repositories, SnapInstall versions are created by third parties, not by the blender developers. It is common that there are outdated, missing libraries or dependencies, or other errors depending on the specific OS.
Unless you have a very good reason not to, use the official version from blender.org


Click numpad dot/del to focus camera transform around selceted object origin, then zoom in /out and it'll be cool. :)


How do I accurately select half of a symmetrical mesh?

You can select everything relative to the last selected (active) vertex.

Select the middle vertex
Access the menu: Select -> Side of Active.(Which has options regarding which side/axis).


The top face is an n-gon (it's defined by more than 4 vertices) and problems with beveling n-gons are to be expected. You can move the n-gon inside, by selecting that face and insetting it. As you move it toward the middle, you will experience a different issue, where the edges are going to intersect, so at some point you stop insetting (click to accept), and then scale the face down to further decrease it. Now there's plenty of room using quad topology for the bevel.


Can I set the Brick Texture Node horizontal mortar size to be equivalent to the vertical mortar size?

the mortar size is a percentage of the width or height so they won't be equal unless width = height
or  you can try this :

tweak the scale on the Y axis till you get the effect


IMO it might be as simple as a Glossy shader mixed to a Transparent shader:

I also added a little roughness control, as your reference looks like it has some kind of noise.


Background in the 3D view appears black instead of transparent

You appear to have a background image which is being displayed under the viewport render. If you disable it in 3D view > Properties region (N) > Background Images, the transparent background is visible once more:


As mentioned in the comments, there is no way to change the grid pattern in Blender. A workaround to this would be to add a circle curve to guide you.

This process will convert the circle curve to a mesh, meaning it will have vertices like a normal mesh would, as seen in the screenshot below:

From there you can enable vert snapping to align your object to the circle:

As you notice, not all the spheres will align with the center on the vertices, to change this, you have to change the "nearest" option to "center" like so:

Edit
Asker requested this as a half-circle. This is easily achieved by simply cutting the circle in half.

Hope this helps.


Bring vertices in/out of center of object?

Under the assumption that you are progressing from How can I subdivide a triangle so there is a vertex in the center of each triange? ; Maybe what you want is to select a bunch of vertices then use s to scale.  The trick is that scale is relative to the pivot point which is usually Active Element.  Often this is good enough, but sometimes you'll have to pick Cursor, or something else.


Trying to make a pie menu with custom operator

Register the operator class

Register the operator class.  The bl_idname needs to be in all
lower case, with one period. Blender 2.8 is a lot stricter on this
and must follow the naming convention between class and operator eg
OBJECT_OT_MyOperator and object.myoperator  [Links]
The operator returns a set that contains one of ('RUNNING_MODAL',
'CANCELLED', 'FINISHED', 'PASS_THROUGH', 'INTERFACE')  in this case
{'FINISHED'} which is a set as indicated by the curly braces.

Amended code.

import bpy
from bpy.types import Menu, Operator

# spawn an edit mode selection pie (run while object is in edit mode to get a valid output)

class HyperBevel(Operator):
    bl_idname = "hyper.bevel"
    bl_label = "HyperBevel"

    def execute(self, context):
        bpy.ops.object.editmode_toggle()
        --- removed for brevity ---
        bpy.ops.object.modifier_move_up(modifier="Bevel")
        return {'FINISHED'}

class VIEW3D_PIE_template(Menu):
    # label is displayed at the center of the pie menu.
    bl_label = "Operators"

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

        pie = layout.menu_pie()
        pie.operator("hyper.bevel")

def register():
    bpy.utils.register_class(VIEW3D_PIE_template)
    bpy.utils.register_class(HyperBevel)

def unregister():
    bpy.utils.unregister_class(HyperBevel)
    bpy.utils.unregister_class(VIEW3D_PIE_template)

if __name__ == "__main__":
    register()

    bpy.ops.wm.call_menu_pie(name="VIEW3D_PIE_template")


Python: How to disconnect and reconnect massive ammount of shading nodes

I propose the following script for this.
Basically, you access each material in the file, then get a reference to the image texture and bsdf nodes, then create a new invert node and connect everything. You don't care about unlinking first because it will be overwritten by your new link.
import bpy

for mat in bpy.data.materials:
    node_tree = mat.node_tree
    if not node_tree:
        continue

    # Get a reference to the image and bsdf nodes
    tex_image = bsdf = None
    for node in node_tree.nodes:
        if node.type == 'TEX_IMAGE':
            tex_image = node
        elif node.type == 'BSDF_PRINCIPLED':
            bsdf = node

    # If you have several Image Texture nodes, you can access a specific one by its name
    # tex_image = node_tree.nodes.get("Image Texture") # (Or whatever the name of the image texture node connected to the roughness channel usually is)

    if not (tex_image and bsdf):
        continue

    invert_node = node_tree.nodes.new(type='ShaderNodeInvert')
    invert_node.location = (-200, 50)

    tex_image.location = (-600, 50)

    # Update the links. We don't care about unlinking because the current links will get overwritten
    links = node_tree.links
    links.new(tex_image.outputs[0], invert_node.inputs[1])
    links.new(invert_node.outputs[0], bsdf.inputs["Roughness"])


Particle Object to Inherit Uniform Colour from Emitter

Switch from Eevee to Cycles, make the materials Single User Materials by clicking on the "2" right to the material name in the material tab (either the plane or Suzanne) and uncheck "From Instancer" in the "Texture Coordinate" node of the plane's material node tree (only your instanced object has to have this option checked). If you change the noise texture setting on your plane, copy the plane material to Suzanne where you have to make it Single User and check "from Instancer":


viewing rendered animation from command line

Call the operator

To Play Rendered Animation you call the operator. For example sake saved to a file scripts/playback.py

import bpy
bpy.ops.render.play_rendered_anim()

To call the operator from command line

blender -P scripts/playback.py tests/demo.blend

The operator makes a command based on your User Preferences > Files > Animation Player  settings.

Which in the case for Internal Player will be something like

Executing command:
   '/../bin/blender -a -f 24 1.0 -s 0 -e 4 -j 1 /tmp/0000.png'

see blender command line arguments

The script that generates the command can be found in 2.79/scripts/startup/bl_operators/screen_play_rendered_anim.py


you have some options to try :

1- just move the curve and try to approximate the result you want

( moved the curve a little bit down )

2- use another modifiers stack to create the same shape

now you get the origin in the center of the circle

the modifiers used are :


"." nor "f" work to viewport zoom on a selected object


Perhaps Andrew Price could help you out here. He did a snow scene tutorial, available on his site. It's long, but it's a step-by-step look at how to get soft, slushy and glittery snow using both procedural techniques and texture-based techniques.

He starts talking about shading around 58:00, but the whole video is worth listening to because he talks about textures, displacements and lighting that can add some much-needed chaos into the scene.

Suzanne, on the other hand, might need some adjustment from his shader setup. You might need to increase the subsurface scattering (SSS) influence because you're trying to get light through the object, not just glitter on the surface. Just remember that SSS will increase your render times significantly, so use it sparingly.


Interactive Python workflow for Blender beginner

Yes, as long as Blender has the functionality you need, I would say automation in Python is one of Blenders strengths.

In fact Blender's SPH fluid simulator was developed/improved by a company who made a product that did automated fluid simulation that ran on a supercomputer to test fluids behavior in through different pipes/containers for a commercial project.
But you can automate many other tasks too. see AutoCRC (bottom of credits page link).

Blender can for example be compiled without a user interface, as a Python module (or just run release builds in background mode), and perform automated physics simulations, video editing, rendering, file format conversions, mesh processing - etc.

There are some caveats though:

Not every area of Blender has been used in automation, if you try to automate something that nobody tried before, you mileage may vary(fluid simulation should go fine, but some areas rely on a user interface - game engine or sculpting for eg).
Its best to first use the interface to setup tasks before automating.From your questions it sounds like you may want to avoid using Blender at all? I think its not wise to avoid using the UI at least for testing steps to be automated.

As a starting point for automation in Blender, I'd recommend see the Background Job template. See:Text Editor -> Templates -> Background Job.
This means you can run Blender from the command line to execute the task.

Another example (based on that template) that renders FBX files from the command line.

Any pure-python solution depends totally on the python-modules available to use, I wasn't aware of PyOgre being able to do fluid simulation - and am not familiar with fluid simulation in Python in general, so its hard to answer this part of your question.

Note:

Your question asks "for a beginner", I wouldn't consider this a beginner project, and I don't think being a beginner makes any difference to the answer. This stuff you have to learn one way or another and if you are a beginner you may just take longer to figure it all out.