How do you export a blender file as an .avi file in Blender 2.74?

In order to export your video edit to a new AVI file, you need to:

Set your Render Settings to a movie format that supports AVI
Click the Render Animation button.

As long as you have the Sequence checkbox selected in the Post Processing panel, it should render out your video edit to a new video file.

There are a number of Movie formats that also support the AVI encoding format.

They include:

AVI JPEG
AVI Raw
H.264 (with AVI format selected)
MPEG (with AVI format selected)
Xvid (with AVI format selected)


Is it possible to move an object closer or farther away while keeping the same perspective?

If I got what you ask yes, it's possible, switch to view transform orientation then grab the object and press ZZ (constrain the grab on view Z axis):


Unwrapping not working and not giving any error message

All the faces appear to be unwrapped, so I don't understand what you mean by " on the left side, in the bottom left face i can't unwrap the image i want to ".
There are scaling issues and it would have helped some if you had packed your image texture into the .blend file.
You have not marked any UV Seams.
You also have two UV maps for your building so you need to tell Blender which one you want to be used by adding a UV Mapping node, See screenshot below:

The usual way of unwrapping such a building would be the following:
1: Apply the Boolean modifiers.
2: Mark UV seams.

3: UV Unwrap.

4: Edit the UV's to suit the type of texturing. In the example below the UV's have been
edited for use with seamless (tilable) textures. See this earlier post for more detailed explanation on how to do this.
How to unwrap model so its perfectly proportioned?


begginers problem : why rotation/scaling/moving doesnt work on my mesh?

Ohhhh yesss problem is finally resolved by myself.
here is the Error:
for some obscure reason, this box was checked :


While looking for another setting (Viewport roll) I found this under Preferences > Keymap > 3D View:
.

Removing those two entries (clicking the X) allows me to orbit smoothly!


In short, for the bpy api use ==, instead of is or comparing the name (which is error prone).

Blender data-blocks * happen not to be Python objects, that is to say, when Blender creates a mesh for example, there exists no Python object for it, until a script asks for one, The way the Python API works, each data-block is a reference to Blender data. therefor id(bpy.context.object) == id(bpy.context.object) won't be equal since each time a new python-object is created.

Note:

This is not the case for all areas of Blender, The game-engine (bge) and the bmesh api's can use identity for comparisons.

Note:

If you do want a unique id() for a data-block you can do:ob1.as_pointer() == ob2.as_pointer(), this is specific to the bpy api.

* In Blender data-block is a general term for a scene, group, mesh, image, material, texture... etc, (avoiding the term object since its confusing in this context)


How to make a sky-to-ground view shader?

click to enlarge
By feeding a wave texture into a noise texture,combined with true displacement, you can create a good starting point for a procedural terrain. The color ramp determines the shading, and the RGB to BW node creates a grayscale mask from the color ramp for the parts that should be water.
Here is the node setup, this is based around the planet plane material from the material library vx add-on which is now included in blender as of version 2.79:

click to enlarge
The contents of the displacement node group:

click to enlarge
The file to play with:


How Do I Move a Face Entirely on Its Own?

I think that you want to duplicate the face. You want to move the face without affecting the rest of geometry. To do this select the face and press shift+D and place your face where you want.

After you have duplicated and you want to delete your original face, press X to delete and select Only faces.


Blender 2.90 - Bevel node not working at all

I was also stuck a same thing, but when I changed the viewport (press Z) to Render (with Cycles), the bevel node was working.
Your viewport is material preview. So, unless you change the viewport to render, you can not realize the bevel node working.


Subdivide loop at custom position without stretching the texture

The loop cut operator has an option to correct UVs. Enable it in the redo panel, below the tool shelf or with F6:

You could also use the knife tool (K), with angle constrain (C) and cut through (Z):


I'm a bit lost with the axis but you can fix it this way:

In Object mode, rotate the vertex 180° on the X axis
Give your Solidify a negative Thickness value
Remove the Group from the Shrinkwrap modifier (or assign the only vertex to this group)


What do different execution contexts mean?

Probably you know more than me, but i think it is related to the words itself or the concepts behind it.
Area, Screen and Region are pointing to where the oops are meant to be executed/invoked i think. "But dont know whats the diference between exec and invoke." now i do. thanks, (i dont use many scripted oops)
You know, Area, Screen and Region are the names blender gives internally to the the user interface diferent componets. see: https://docs.blender.org/manual/en/dev/interface/window_system/screens.html

https://docs.blender.org/manual/en/dev/interface/window_system/areas.html

https://docs.blender.org/manual/en/dev/interface/window_system/regions.html

hope useful.


You have to  bake it. What you did looks probalby like this

But there  is  a better way to do it. Go to the physiks panel and go to cache.

Now you have to bake it till the frame that you want it to have.
Now you have a blue that looks like this.

Now you can save the object and when you open it again, it will stay as it is.


Seam on edges of displacement map on rope

so the problem here is that your texture isn‘t seamless which you can fix by making it seamless in an imageprocessing software like gimp
here is a youtube tutorial how to do that
https://youtu.be/qAXRDfDaJMk


Does anyone know how to mesh this robot claw?

There isn't need for a lot of complex mechanics. In 3D, you often fake it.

This is the fastest way I know how to do it:

Start by making a cylinder in a new scene. I chose these settings at the start. The main thing is, don't give it a cap fill type. I set mine to None.

With your object selected in Object Mode, go to the Modifiers Tab in the Properties Panel and create a Solidify modifier. Change the Thickness setting to 0.5. Then apply the modifier.

In Edit Mode, make sure you're in Face Select Mode (3 key), and box select, then delete the eight faces at the bottom center of the new shape. Then go into Edge Select Mode (2 key) and then Alt + Select an edge at the top center of the same object. Then split these edges by pressing Ctrl + e to bring up the Edge menu, then choose Edge Split. Note: This menu item seems to have been removed in Blender 2.83. If you are using this version, use the search function instead (F3) and type "Edge Split" in the search field to get access to this function).

In Edit Mode, choose Face Select Mode again and press a to select all faces. Press p and from the Separate menu that pops up, choose Loose Parts. Now you have two pieces. If not, then the previous step, where you selected edges and split them, was not completed properly, and some edges remained connected. Go back and check, and repeat that step if necessary.

In Object Mode, select either of these two new claw objects, and go into Edit Mode. Again, select all faces, and this time go to the top of the 3D view, and choose Mesh > Clean Up > Fill Holes. This will automatically cap both ends of your new object. Repeat the above steps for the other object.

Now go into Object Mode and select either claw object, and then Shift select the other claw object. Now go into Edit Mode (since both objects were selected before entering Edit Mode, they are both equally accessible in Edit Mode).  Go into the top orthographic view with Numpad 7, and select all faces again, which will select all faces for both objects. Translate them vertically by pressing g, followed by y, then dragging the mouse upward. Align these parts so that the middle of the bottom gap between these objects is centered on the Worldspace origin (try to get close to it, anyway). You can snap by holding Ctrl while moving the mouse, and get even finer control by additionally holding Shift. When you leave Edit Mode now, both objects will have their object origin centered at this location, which will make hinge movement easier.

Go back into Object Mode and, with the 3D cursor at the Worldspace Origin (if it is not there, put it there with Shift + c), press Shift  + a to add a new cylinder. It should appear where the 3D cursor is, which should be the same location as your origin point for the two claw objects (You may find that the Add Cylinder panel remembers some of the settings of our earlier created cylinder). This one needs to be smaller, to fit between the claws, and the Fill Cap Type needs to not be None this time. I chose Ngon, and a radius of 0.2.

Finally, go into Object Mode and select both claw objects, and then add the new cylinder to the selection last. Press Ctrl + p to bring up the Parent Menu, and select Object. The claws will now go where the pivot object goes. If you want, you can lock the axes that shouldn't move in the Transform Panel in the Properties Shelf to the right. You don't even need bones for this setup, nor drivers, really, since you can zero out the rotation values to get your claws back to their starting position, or else press Alt + r to restore the zeroed out values instantly.


Weird Protruding Vertices in Sculpt Mode

It's very difficult to tell what might be going on, without more information. If you can attach the .blend file, someone might be able to take a look at it.

Aside from that, there are a whole variety of things that might be going on. Sculpt mode might be "confused" about trying to smooth an inverted crease, or it might be "confused" by a single vertex that's not attached to anything. It doesn't look like you have any other modifiers on the object, but things like like "mirror x" on a mesh that has a mirror modifier can have weird results.

I'd recommend taking a deliberate, methodical approach, to sort out any oddities manually. Firstly, use edit mode to manually move your vertices back into the general vicinity of where they're supposed to be. If you pay attention during this process, it might reveal some clues about what's going on in sculpt mode. You might be able to use Proportional Edit mode to make things a little faster.

I suspect that you will discover some faces that are doing odd things you didn't intend, or edges that are connected in the wrong order, or something like that. Unfortunately, the only way to discover them is to pick individual vertices, and the only alternative is to blow that section away and rebuild it from scratch.

I hope that helps!


I'd suggest modelling the basic shape and then sculpting, then you can retopo a low poly and bake the detail from the sculpted piece to the low poly, if you are planning on it being a game ready asset.

If you aren't, just stopping after the sculpting phase is OK.


I believe this is what you want. Its a great addon, I've been using it for ages now. Basically what it does is it converts the selected uv area into an nicely lined up square, or into an evenly spaced grid.


How can I make a screenshot in the BGE (numpy of pixel values) without saving to disk?

you might try something like this:

import bge

source = texture.ImageRender(world,sensorView_Cam)

source.capsize = [640,480]

imageArray = texture.imageToArray(source, 'RGB')

charArray = imageArray.to_list()

works ok for me (Although, i dont know if it is fast enough for you and if there are faster ways)


Import fbx from Nuke/ Maya and have the correct orientation

I find a way to fix the rotation , this is my setup in fbx import parameter :  turn on manual orientation and set forwar to -Z forward and up to Y up. Then DO NOT use the camera directly , but used it as reference only. Create a new camera, go to constraint property and choose 'child of' and select the original camera as parent. now clear out all translation/rot/scale of the new camera and set X and Z rotation to 180. Now i can see through the new camera.


Getting separated meshes to use the same armature (clothes and hair moving with body ex)

I would parent the object to the a bone that makes sense and then just make sure that bone is has full influence over it.


Blender 2.8 Reference images in local view

Are you selecting both the reference image and the meshes before entering local view? For example:

Entering local view only with the cube and then entering while also having the reference image selected


How can one be sure that 2 objects are exactly at the same base height level in blender?

In the upper right corner of the 3D viewport click Options then Transform only Origins.

Enable snapping and in the adjacent menu pick Face.

Rotate to a view on the underside of each object, select them in turn and [G]rab the origin and move it anywhere to a bottom face where it will rest because of the snapping.

Select the Item tab on the right side of the 3D viewport and change the Z Location for each object to zero. You do not need to deselect the Origins transform from the first step for this procedure as the Item values do not change the position of the origin in relation to the object, but rather the object as a whole including the origin, and this location points to the object origin.


Transparent shadow catcher under HDRI lighting in Cycles?

A Hacky way to do this is by using a few render layers and object or material IDs

For a scene like this, where the object is lit exclusively by the environment (no lamps on the scene)

Make a copy of all of the objects, move them to a new layer and set new layer to use a single white material.

Set the render layers so that each render layer corresponds to the layers for the scene and excludes the other layer.

For the Layer that will hold the shadow only make the objects invisible to camera, so that the only information on for the layer will be a plane and the shadow. Make sure you enable material Index for the first render layer.

Give the object on the first render layer a material ID:

In the compositor set the Render layer with the shadow over white using alpha over. This will become the base image to use for whatever compositing you want to do.

If you combine it with the Material ID/Index Pass you can then create an alpha channel with the object and the shadow, to be used to key the original image.


texture coordinate node in blender - how to control textures with it

I believe you should be using the Generated coordinates for this rather than Object. The Generated coordinates range from 0.0 to 1.0 over the range of the object whereas the Object coordinates are in "object space" with 0 at the origin and positive values on one side of each axis and negative at the other - this is why you're seeing an oposite reflected image. You should then be able to scale it without seeing the reflected second image.

You should also set your Image Texture node Projection mode from Flat to Sphere.


How to mix shaders depending on the direction normals are facing?

Try using the Layer weight node with the Facing value as a mix factor:

The Layer weight node gives a map based on the angle of the surface to the camera:

When used to mix a diffuse and a transparent shader:

Blending:

The Blend value controls the blending between angles:

With a low Blend value:

With a high Blend value:

As mentioned by CharlesL you could further control the blending with a Color Ramp node:


Bulk renaming armature bones after already creating them?

Open a text editor in Blender and paste the code below there.
Replace the text in "original" and "replacement" as needed.
Go to pose mode and select the parent of the new chain.
Press "Run Script" in the text editor.

Here's the code:

import bpy
original    = "FrontLeg"    # Original name that was duplicated to generate all legs
replacement = "2ndFrontLeg" # The new name you want for this particular leg's bone chain

parent = bpy.context.active_pose_bone
for b in [ parent ] + parent.children_recursive:
    b.name = replacement


The viewer node you are using is actually an Emission Shader. To stop the glowing, plug the Principled BSDF into the Material Output.


What is a matcap and where is it located in blender 2.8?

Matcap is a way of shading objects in the viewport.

It is located here, in the little dropdown box in the top right of the viewport.


Blender Guru Tutorial part 5: coffee cup bottom gets deformed

I'm guessing you're making the the cup after making the donut.
When you did the icing (frosting) on the donut, you will have set the Proportional Editing Falloff to Random to create that uneven edge of the icing running down the side of the donut.

As I recall, I made the same mistake, because Andrew (Blender Guru) omits to tell you to switch off proportional editing (probably because it's a series of videos that he made at different times).
So before scaling the cup, make sure that Proportional Editing  is switched to Disable.


Damped track, locked track.

The compass has a limit distance/surface constraint to keep it on the surface of the earth.  There are other options.  It uses a damped track constraint to keep its local -Z axis pointing at the center of the earth.
The needle is parented to the compass.  It uses a locked track constraint to allow it to rotate in only a single axis.  It tracks a marker I've placed at the sphere's pole, parented to the sphere.
No matter how you move the sphere or the compass, the compass will remain glued to the surface of the sphere and oriented with it, and the needle will point at the north pole.
Your own axes are going to depend on how your orient your objects.  I've used empties here for my constraints, but strictly speaking, they're unnecessary; you can give constraints directly to objects and they will behave the same.
If you want to do it to something that's not a sphere, you might no longer be able to just use the origin of the object (definitely not for a limit distance constraint), but you can use shrinkwrap constraints instead, and you can locked track empties that are shrinkwrapped to non-rendering, negatively displaced copies of your mesh to acquire orientation.


Create a Modal operator and set your code to run on event.type='LEFTMOUSE'.

You can search for it on google or read this forum answers https://blenderartists.org/t/trigger-action-through-mouseclick/674367


How does this work?

from random import choice

# deselect all:
for obj in Coll.objects: obj.select_set(False)
# choose one and select it:
rnd_obj = choice(Coll.objects)
rnd_obj.select_set(True)


Creating a new vert with bmesh resets previously created verts

Add vert at cursor in edit mode

The cursor is in global coordinates. Set to local by multiplying by the objects world matrix inverse.

import bpy
import bmesh

context = bpy.context
scene = context.scene
ob = context.object
mwi = ob.matrix_world.inverted()
me = ob.data
bm = bmesh.from_edit_mesh(me)
bm.verts.new(mwi @ scene.cursor.location)
bmesh.update_edit_mesh(me)


How do I loft lines into a mesh with Animation Nodes?

It's easier if you use an existing node to loft elements, which is the Spline Loft node instead. Basically, you create a bunch of splines before, feed that as a list to the node, and then decide on the amount of samples / divisions of the mesh. See this blend here:

Here's a screenshot of the full setup:

The loop below is a workaround for me to get a few splines in the fashion that you did. I feed a list of integers into it, only using the loop index to generate a few start and end coordinates. With that, I create straight splines and collect them in a list at the end.

This spline list I feed back into the loft node. The samples parameter determines the number of points on the spline which the node generates. Spline Samples of 2 means, only start and end point, so a straight line. Important: you also need to set the samples in the other direction. That's why I get the list length in the end, so each spline is then sampled as a division as well.

Using a bit of randomness, you get this:


File not rendering in freestyle properly

I just moved the line at the bottom down:


Merging seam borders when using 360° Spin Tool

I would not use Spin Tool for this particular purpose, closed surface of revolution.  Remove doubles, a necessary step, did not solve the problem.  My problem was a hidden internal face problem.  Hidden faces are bad.

My initial actions produced an internal face with Spin Tool.  The face of the initial mesh.
I had to remove edges and one internal face and then bridge edge loops to get the mesh in good form.  The extra work seems unnecessary.  Consider sleuthing down an internal unwanted face.

Perhaps the best evidence is that loop cut seems to have difficultly with the resulting mesh. What appears visually as a loop has failed with Loop Cut.  It has simply created difficulties in your situation.

Finally I [deleted face only] before the spin tool and got the correct results. If felt if I were smacked in the face with a whipped cream pie.

I would use Spin Tool for corners of edited cylinders.

Consider Screw Modifier firstly.  (Array Modifier if you feel adventurous)
I applied the Screw Modifier.  Loop Cut worked as expected.

Followed by Smooth Modifier.

You might also just use proportional edit to achieve your [spin/lathe] shape.


For cycles

Put your image texture in to a Diffuse node. Then use the factor in the mix node to determine how much gloss there is. The color on the glossy node should be nearly white, you don't need to plug the image texture in to it also.


No, Neither Cycles nor Blender-Internal use a camera frustum check when rendering.

While it could work in some cases, but would obviously fail with reflections. Also the chances of flickering in animations where the camera moves is high, objects outside the camera may cast shadows or emit light.

This feature could be useful for preview renders (an additional simplify option).


Can I render a normal map into a diffuse texture?

First solution (more complex)

The tiled aspect of the normal map needs a specific UV map (I'll call it "tiled"). And your diffuse texture needs its own UV map (I'll call it "UVmap").

Making "tiled" is the first point : if your model is complex or if its "natural" UVmap is very curvy, it will be hard to handle how to tile it correctly without unwanted deformations.

As an exemple :

The base model (here a plane), and its UVmap :

Add a second UV map (1) and eventually rename it "tiled" (2), then scale it (3) in order to give the tiled aspect

For the example I used this normal map :

Setup your material nodes (here I have put a noise texture but that can be what you want ; there is a lamp in the scene but it is not mandatory)

Add a "UV map" input node and set it to the "tiled" UV map (1)

Connect it to your normal map image texture (2)

Set it as a normal map (3) and connect to the normal input of the shader

Add an image texture for the bake (4) (I presume you have create an image for that) and remember this node needs to be selected when you will bake (the selection defines it as the bake target)

The bake itself :

Make sure your "standard" UVMap is selected for rendering :

Go to the rendering tab and bake section. Click the bake button.

Second solution (simplier)

Make a tiled texture from your normal map texture (using for instance the "small tiles" filter in Gimp).

The principle is the same as above but you'll need only one UVMap as the normal map is already tiled.

Third solution (simplier too)

With one normal map, simply configurate your material like this, using a vector mapping the defining the values (here 10) for the scale :


Mix shaders with blend modes besides Add and Mix?

I think the answer to this is also negative.

Let me try to explain my understanding of the problem with a different blend mode. To have an example to work with, let's use Multiply:

When Cycles uses the shader, it uses it with exactly one sample. It doesn't know anything about the previous samples, and neither does it know anything about future samples for this pixel and material.

To be able to multiply two shaders with each other, you would need the averages of all samples from one shader and all samples from the other one, as it could happen that for each sample, one of them is 0 and the other one is 1 (with a 50% chance for either one to be 1). In average, both would still be 0.5 in brightness, so the correct Multiply-result would be 0.5 * 0.5 = 0.25, but because Blender only sees one sample at a time, it would always calculate 1 * 0 = 0 or 0 * 1 = 0 and the material would be black. This is why all blend-modes have to be independant of the respective other input to make sense. Add and Mix are pretty much the only two useful blend modes for which the output is only influenced by the two inputs independently.

Any linear modifications that are supposed to happen to either of the inputs or the output can be applied to the color before it even enters the shader, as all shaders are (as far as I know) linear in respect to the input color. Subtracting also works that way, you can replicate it with negative brightness in a Diffuse/Glossy/...-Shader.

This is not the programming explanation for why it doesn't work but only the explanation that I think is correct and describes the problem from a rendering process point of view, please correct me if it's not correct but I hope it helps in some way to understand what works and what doesn't and cannot work.


Why a new 'merged' mesh is created when adding multiple loop cuts?

Loop cuts are inserted using Ctrl+R or the Loop Cut tool in the Toolbar. Both tools are going to place an edge in a loop of faces and do not create any double geometry.
If you have double geometry after inserting a loopcut, it is there definitely not because of the loop cut, but because of some other mistake.


Blender Python: How to activate the Auto Refresh in a imported sequence on Image Editor?

Digging for classes and properties.

If you right click and view source on checkbox you see,

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

    sima = context.space_data
    iuser = sima.image_user

    layout.template_image(sima, "image", iuser, multiview=True)

which gives a clue that it belongs to the image editor space sima and there is a class  ImageUser instance sima.image_user...

Ok off to py console, making sure an image editor is open in same screen, in case below its in area 1

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

>>> sp = C.screen.areas[1].spaces.active
>>> sp.image_user.use_auto_refresh
False

Hence in your operator, as long as it is invoked from the image editor you can set with

space = context.space_data
space.image_user.use_auto_refresh = True

This is an example of

SpaceImageEditor.image_user

See the reference section of manual https://docs.blender.org/api/2.79/bpy.types.ImageUser.html?highlight=use_auto_refresh#bpy.types.ImageUser.use_auto_refresh for other possible references.

BackgroundImage.image_user
EnvironmentMapTexture.image_user
Image.filepath_from_user
ImageTexture.image_user
Object.image_user
ShaderNodeTexEnvironment.image_user
ShaderNodeTexImage.image_user
TextureNodeImage.image_user
UILayout.template_image
UILayout.template_image_layers
VoxelDataTexture.image_user


Particles falling through plane with collider

First thing that comes to mind is that you need to make sure that the emitter and the collision object need to share the same layer for them to affect each other in physics simulations. From your screenshot it looks like you are using at least two layers, so maybe that's it?


To reduce the render time of a large scale scene like that there is a nice new option for object camera culling (Cycles only).

It will remove the visibility of objects from the scene as they move outside of the camera's view, saving rendering computation. If the object moves back in frame the object comes back. It only does this for rendering. The objects will not actually be removed in your .blend file or 3D viewport.

Switch to the Cycles render engine
In the Properties panel go to the Scene tab.
Check the box for Simplify

Then select an individual object:

Go to the object properties panel
Expand the Cycles Settings section
Check Use Camera Cull

Warning: You will have to deal with problems like having shadows and reflections suddenly disappear from the camera's view, because the culling only detects the actual object in the camera's view; not any of its influence (shadows, reflections, etc) on the rest of the scene. Some of this could be fixed using the "Camera Cull Margin" option near the "Use Camera Cull" option in the scene properties (Image 1). The rest will have to be fixed by just being selective about which object you check the cull option on.


Simple Python script - Adding a primitive object to the active layer

right click on the add cube icon and then click Pie Menu Editor.

then it will ask you in which menu you want to put it.

by default the the arguments for layers are all False

so unless you specify one it will always create the cube in the activate layer


Typing G+X or R+X is not working. Instead is asking me if I want to delete

Most likely you inadvertently deleted the shortcut in the keymaps, or you set it to something else, overriding it. Clicking on Restore in the keymaps in the preferences should clear the modification.


Issues with normals to create more depth

You can get there using Displacement on a higly subdivided mesh.
Bump and Normal maps are faster, but will only get you so far.

Choose either Displacement only or Bump only depending on your needs.


I am not sure if anyone is still looking for a solution to this, but the answer for me was to set the Alpha value in the material properties to Pre multiplied instead of Straight.


I can't import materials or textures from OBJ or 3DS

Strangely, I had a similar problem with 3DS in cycles, but was able to apply textures and materials perfectly in Blender render.

In Blender Render, I needed to play around in the materials and textures panel a little, opening one of the image files. The rest were automatically applied, but I needed to add a lamp to see it.

For Cycles, I had to open nodes and do the textures that way.


How can I smooth out the edges of this mesh?

the problem is that some of the faces are triangulated, resulting in the bevel modifier having a hard time in finding a desirable solution. looking at the model you have there, you could automatically clean up the geometry using a decimate modifier BEFORE the bevel, set its mode to planar, and then, as lemon suggested, use the angle method in the bevel. See those two screenshots here:


Is there any standard way of measuring SSS according to real-life objects?

I would recommend to base your values on observation instead of guessing. since it's hard to get measured data for something as basic as albedo values, I think it is safe to forget about SSS measurements even if they existed. Correctly exposed and white balanced photographs in similar lighting conditions to your 3d scene should be a really good source of information.


"Follow Track" motion tracking constraint depth to empty

I'll answer my own question... My original understanding was that the 'depth object' was an object that was purely used to indicate the distance from the 'camera' that the tracking the object would be placed. However, I've just stumbled on the realisation that it's much, much cleverer than that.... the 'depth object' is used to position the object on its surface at the point that it would intersect with the depth object - so a wavey mesh would position it at varying depth depending on which bit of the wave it happened to hit. This means that an empty (being a point) would be a completely pointless (excuse the pun) thing to use - hence it's not valid to use in that situation! If you want to have the track placed at a constant distance from the source then you could use a plane perpendicular to the camera; but if you want it to follow a more complicated path the the 'depth object' can be tailored to suit whatever profile you require.


Add a text and convert it to mesh. Add an empty and use Simple Deform modifier > Bend with the empty as origin and high, like 4, Deform factor. You may want, too,remesh and subdivide the text mesh.


Why does scaling my UVs have any visible effect in the 3D View?

The only shading modes that allow an accurate view of your shaders are the material view and rendered view. Solid view using texture color display might not always show textures as they are, especially their mapping.
Also, what you see depends on your material's nodes setup.
Finally, I'd advise avoiding scaling UVs, it's usually a better idea to keep them correctly done in their UV space and use mapping nodes in your materials to dissort them.


How do I make it so that my camera shows the actual objects?

Your camera is panned, you just need to press Numpad0 to go inside the camera and then press Home


Bones local coordinates are coordinates in the bone rest pose space (initial location/rotation/scale before it moves in pose mode).
The difference between world and local coordinates is the parenting: world coordinates include parent chain transformation up to world.
Though, in local coordinates, moving along (say) X does not mean a movement along current X bone axis. This is still relative to its original rest position.
That's why your setting is not working.
You need to consider both X and Y (local or world won't directly matter in this case) in order to shift the arrayed meshes along the curve.
That can be this setting:

However, the turns are not good: both tracks follow the same speed even if we add the rotation around Z. We would prefer the track which is inside the curve to go slower than the other one.
... this can be handled by some driver functions (won't have time to explain it for now...).
The blend file contains the two versions (with and without speed differential when rotating).


Insetting a non-closed mesh into a solid object

This is going to be a bit of a tricky problem due to the edge of the crater being as rough and jagged as it is. I'm assuming that the edge of the crater is not going to line up perfectly with the tapered cylinder style you are going for.

I would go about it this way:

Create the base shape you are going for by taking a cylinder, extruding the top face a bit then scaling it down until it is an angle you like. It doesn't matter how high you extrude the face, what matters is that when you get the angle you are looking for the top face is smaller than the top edge loop of the crater. Make sure this base object is positioned where you want it to be in the final object.
Subdivide the base a lot, using CtrlR to add loops until the faces of the base are mostly square, then W and subdivide. You will want the geometry to be dense enough that the average edge on the angled portion is roughly the same as the average edge on the edge of the crater. Note that you only need to do this for the angled top faces, not the sides or bottom face of the cylinder, although it won't hurt if you do.
Look from the top at the two objects (they will need to be separate objects at least until this point) and use the circle select tool to select all of the vertices on the top of the base that the crater will cover. It doesn't have to be perfect, but you don't want there to be vertices inside the crater perimeter.
Join the two objects with CtrlJ. In edit mode, use proportional editing set to connected to adjust the height of the top edge of the base until it is fairly close to the edge of the crater. You will likely not be able to have the base be a smooth slope up to the edge of the crater due to the uneven edge. I would suggest trying to make the top of the base look a bit uneven and rocky as it gets closer to the edge, but the choice is ultimately yours.
In edit mode select the perimeter of the crater and the now uneven edge of the base using the non manifold edge method you did above.
Press CtrlE and choose 'Bridge edge loops'. The number of vertices on each edge should be close enough that it will do a decent job filling the gap. You may have to manually adjust a few places if there are any problematic spots.

Do note that I haven't tried this method on anything like your project, I'm going by what I think would work best. If you run into issues it could just be a limitation with this method, but I would imagine that it should work.


Quite simply swap the array_index property, which designates which component of an array property (eg location.x or location[0], has array_index == 0), of the two fcurves.

Example below using the python console, location as an example, change to rotation_euler for Euler rotation.

>>> action = D.actions['CubeAction']
>>> fx = action.fcurves.find('location', index=0) # location.x
>>> fy = action.fcurves.find('location', index=1) # location.y
>>> fx.array_index, fy.array_index = fy.array_index, fx.array_index


From the provided data file, you can obtain this kind of rendering, with (for example) either creating splines (curves) or creating a mesh with skin modifier.

The script allows to:

Load the data from the indicated site
Convert it to inner objects (NeuronPoint class below)
Optionally add some random intermediate points between the loaded coordinates

And

Either convert them to curve, creating a new curve for each data ramification
Or create a mesh from this point and add a skin modifier in order to obtain the neuron branches

Here is the commented code and blend file:

import bpy
import random
from mathutils import Vector

# Store the information from the SWC text file
class NeuronPoint:
    def __init__(self, id, type, x, y, z, radius, parent_id):
        self.id = id
        self.type = type
        self.x = x
        self.y = y
        self.z = z
        self.radius = radius
        self.parent_id = parent_id
        self.parent = None
        self.children = []

    @property
    def coordinates(self):
       return Vector( (self.x, self.y, self.z) )

# Read data from the file
def read_neuron_points( file_name ):
    file = open(file_name, "r")
    points = {}
    for line in [l for l in file if l and l[0] != '#']:
        string_data = line.split()
        if string_data:
            id = int(string_data[0]) - 1
            neuron_type = int(string_data[1])
            x = float(string_data[2])
            y = float(string_data[3])
            z = float(string_data[4])
            radius = float(string_data[5])
            parent_id = int(string_data[6]) - 1

            neuron_point = NeuronPoint(id, neuron_type, x, y, z, radius, parent_id)
            points[id] = neuron_point

    for point in points.values():
        point.parent = points.get( point.parent_id )
        if point.parent:
            point.parent.children.append( point )

    return [p for p in points.values()]

def random_vector( random_amount ):
    return Vector( (random.uniform(0,1), random.uniform(0,1), random.uniform(0,1)) ) * random_amount

# Cuts the data to have additional random points
def make_intermediate_points( points, point, min_distance, random_amount ):
    point_co = point.coordinates
    parent = point.parent
    parent_co = parent.coordinates
    vector = point_co - parent_co
    distance = vector.length
    # Do it only if distance is above the parameter
    if distance > min_distance:
        # Cut in half + random
        intermediate_co = parent_co + (vector * 0.5) + random_vector(random_amount)
        intermediate_radius = (parent.radius + point.radius) * 0.5
        # Insert the new point in the hierarchy
        new_point = NeuronPoint( len(points), point.type, *intermediate_co, intermediate_radius, parent.id )
        points.append( new_point )
        point.parent = new_point
        point.parent_id = new_point.id
        parent.children.remove( point )
        parent.children.append( new_point )
        new_point.parent = parent
        new_point.children.append( point )

        # Cut around this new point
        make_intermediate_points( points, point, min_distance, random_amount )
        make_intermediate_points( points, new_point, min_distance, random_amount )

# Cuts the data to have additional random points
def subdivide_points( points, min_distance, random_amount ):
    for point in [p for p in points if p.parent]:
        make_intermediate_points( points, point, min_distance, random_amount )
    return points

def mesh_from_neuron_points( context, name, points, scale_factor = 0.01, radius_factor = 1 ):

    # Gets vertices and edges from the points data
    verts = [p.coordinates * scale_factor for p in points]
    edges = [(p.id, p.parent_id) for p in points if p.parent]

    # Create a mesh
    mesh = bpy.data.meshes.new(name)
    mesh.from_pydata(verts, edges, [])

    # Create an object with this mesh
    obj = bpy.data.objects.new(name, mesh)

    # Add a subdivision surface (smooth the edges)
    subdivision = obj.modifiers.new( "subdivision", 'SUBSURF' )
    subdivision.render_levels = 1
    subdivision.levels = 1
    # Add a skin modifier in order to have thickness
    skin = obj.modifiers.new( "skin", 'SKIN' )
    skin.branch_smoothing = 0.5
    skin.use_smooth_shade = True
    # Smooth again with another subdivision
    subdivision = obj.modifiers.new( "subdivision", 'SUBSURF' )

    # Associates the radius to each skin vertex
    for s, p in zip( obj.data.skin_vertices[''].data, points ):
        radius = p.radius * radius_factor
        if not p.children:
            radius *= 0.1
        s.radius = (radius, radius)

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

# Cuts the point set into continuous spline parts, creating a new part for each ramification
def splines_points_from_points( points ):
    result = []
    base_points = [p for p in points if not p.children]

    while base_points:
        next_points = []
        for point in base_points:
            current = [point]
            result.append(current)
            while point.parent:
                point = point.parent
                current.append(point)
                if len(point.children) > 1:
                    next_points.append( point )
                    break
        base_points = next_points

    for spline in result:
        spline.reverse()

    return result

def curve_from_neuron_points( context, name, points, scale_factor = 0.01, radius_factor = 1 ):
    # Create a curve with some bevel depth
    curve = bpy.data.curves.new(name=name, type='CURVE')
    curve.dimensions = '3D'
    curve.bevel_depth = 1

    # Create an object with it
    obj = bpy.data.objects.new(name, curve)

    # Calculate splines parts
    splines_points = splines_points_from_points( points )

    for spline_points in splines_points:
        # Create a spline for each part
        bezier_curve = curve.splines.new('BEZIER')
        bezier_curve.bezier_points.add(len(spline_points)-1)
        # Set the points
        for bezier, point in zip(bezier_curve.bezier_points, spline_points):
            bezier.co = point.coordinates * scale_factor
            bezier.radius = point.radius * radius_factor
            if not point.children:
                bezier.radius *= 0.01

    # Link object to the scene
    context.scene.collection.objects.link(obj)
    # Toggle handle type (faster than doing it point by point)
    obj.select_set( True )
    context.view_layer.objects.active = obj
    bpy.ops.object.editmode_toggle()
    bpy.ops.curve.select_all(action='SELECT')
    bpy.ops.curve.handle_type_set(type='AUTOMATIC')
    bpy.ops.object.editmode_toggle()

    return obj

# Get the file name relative to this blend file
file_name = bpy.path.abspath("//test.txt")
# Read the file into points
points = read_neuron_points( file_name )

# Some parameters to handle result scale
scale_factor = 0.1
radius_factor = 0.1
# Subdivide the model with some random (optional)
points = subdivide_points( points, min_distance = 4, random_amount = 1 )
# Create the object as mesh with skin modifier
#obj = mesh_from_neuron_points( bpy.context, "test", points, scale_factor = scale_factor, radius_factor = radius_factor )
# Create the object as curve
obj = curve_from_neuron_points( bpy.context, "test", points, scale_factor = scale_factor, radius_factor = radius_factor )

# Set a material on it, if defined
mat = bpy.data.materials.get( "Material" )
if mat:
    obj.data.materials.append(mat)


How to extrude and leave the original in place?

The most practical procedure on ANY mesh would perhaps be select the Face, Shift+D (duplicate), cancel (Esc), extrude (E)


Linux cmdline rendering on multiple GPUs

The benchmark script sets the enabled devices itself, hence the script to enable all GPUs has no effect. Since the purpose of the benchmark is to evaluate the performance of a specific CPU or GPU, it only enables one (compute) device at a time. This can be seen by taking a look at the benchmark scripts.

In main.py it first parses the supplied arguments and starts the benchmark. You can specify which device shall be used through the optional -d, --device argument. The _benchmark() function gets the requested device as an argument and calls the render() function from the render.py script. It enables the requested device either through _enable_device() which in turn calls _enable_compute_device() or _enable_cpu_device(), depending whether the benchmark should be performed for a GPU or CPU. In your case it would be using the former function. _enable_compute_device() first disables all enabled graphics cards. If you supplied a specific GPU, it will try to enabled it. If no GPU was given as an argument (requested_device.name is None), it first tries to find one that isn't used as display device and if no such GPU exists, it picks the first one available. In both cases it only enables one GPU and it's the first one that matches the criteria.

Therefore you need to call the benchmark script multiple times and supply the GPU name through the --device argument for each run. The available device names can be printed to the terminal by using the -l or --list-devices argument.

Alternatively you would have to modify the script. However, this would also break the JSON reporting function since it expects exactly one device to be enabled. The report format could be modified as well, but it would not be possible to upload the modified reports to the Open Data platform.


You might be better off here using a single image that is tileable and the unwrapping the faces from views, and scaling the UV selections in the uv image editor. You can regulate the mapping by selecting a row of faces and choosing 'follow active quads' in the unwrap options. edit: I forgot to mention that you could do this on a second uv map, and then bake to the first one once you get the scale in your preferred size - this would then allow you to paint into the result with some variations like dirt or discoloration and not be stuck on the single tiled texture.


How am i doing so far with this character? Topology

The topology needed depend on the intend :
if for gaming, it should be low poly
for movie, it should be medium poly
for image, it can be high poly

Note: it also depend on your computer performance.

In the image you posted the modelissation looks "clean" so you should not have issue later.

It is normal to have more poly in the face, as it conveys emotion. But it will still repend on the end usage.

Note: you make a high poly model, then create a bump texture of it and then apply it on the low poly model -> in that way your model looks like high poly but is low poly in reality.


How do I get bevelled edges from the inside of a mouth?

The original file is this:

First, I removed 129 doubling vertices (W -> Remove Doubles).

After some basic tweaking (dissolving some edges and adding 2 loopcuts to make vertices adjacent) got this

Now, mouth and teeth form. I decided to drop original vertices of teeth and combine them with loops of mouth and of the hole head. To do that, I deleted top teeth vertices (X -> Faces), selected one vertice from base of the top teeth and one from base of the bottom teeth and pressed J to make edge.

I did that for all adjacent vertices forming base of teeth.
Then, I added loopcut (Ctrl + R) across the all head. I combined it with the top mouth edge so it to let me add more loopcuts without creating NGons:

Then I added 2 loopcuts across the head including mouth. I scaled them to 0 by Z axis (S -> Z -> 0) and moved slightly by Z to make teeth slightly smaller. Then I began recreating teeth by simply selecting adjacent vertices and pressing F:

After bottom teeth were done, I added adjacent quantity of vertical loopcuts (in this case 6) across the mouth to let it have roundish edges. Finally, I added Subsurf modifirer and set subdivision level to 2.

There are a lot of problems left, the eyes and whole top part of face should be rebuilt also or the eyes would not be seen as they should be. Also, my approach creates a lot of additional geometry - I tend to not creating NGons so Subsurf working as good as possible.

This is what I did. At the same time, I'm not sure what did OP to make his final image.


Cycles implements the shaders for both CPU and GPU through the shader virtual machine which can be found in /intern/cycles/kernel/svm. The same nodes are also separately implemented in the Open Shading Language (OSL) and can be found in /intern/cycles/kernel/shaders. For instance you will see that the brick texture node exists both as svm_brick.h and node_brick_texture.osl. OSL only runs on the CPU and integrating a OSO to SVM compiler was previously discussed but abandoned due to maintenance and performance concerns. Therefore your own OSL scripts have the same limitation and will only be executed on the CPU.

Note that using OSL is entirely optional and it's not enabled by default. OSL can be enabled in the Render Properties.

Additional information about Cycles can be found in the wiki. The articles may not always be fully polished, but they should be a good starting point to dig deeper into the code. The structure of Cycles source code is documented in the Source Code Layout page.


Cloth Simulation deforms before hitting anything, and seems to pass right through the table and plate

In the future, including a .blend file or a minimal working example script would be ideal because then we can directly diagnose any potential issues.

In lieu of that, here is a minimal working example script using Blender 2.82a with cloth collisions, which you can build upon for your own tests.

If this script is in a file called test.py then you just have to run blender -P test.py from your command line (e.g., this is usually Terminal or iTerm if you're on a Mac OS). Then this will open up Blender, and you can play around with the settings and observe what modifiers need to be present.

import bpy

def clear_scene():
    """Get rid of the starting cube."""
    bpy.ops.object.select_all(action='DESELECT')
    bpy.data.objects['Cube'].select_set(True)
    bpy.ops.object.delete()

def make_meshes():
    """Make Suzanne mesh, with the collision modifier."""
    bpy.ops.mesh.primitive_monkey_add(size=2, enter_editmode=False, location=(0, 0, 0))
    bpy.ops.transform.resize(value=(2, 2, 2))
    bpy.ops.object.modifier_add(type='COLLISION')

def make_fabrics():
    """Make fabric that drops over the Suzanne mesh and collides with it."""
    bpy.ops.mesh.primitive_plane_add(enter_editmode=False, location=(0, 0, 0))
    bpy.ops.transform.resize(value=(3.5, 3.5, 3.5))
    bpy.ops.transform.translate(value=(0, 0, 6.0))

    # Sub-divide into 50, like how you did it.
    bpy.ops.object.editmode_toggle()
    bpy.ops.mesh.subdivide(number_cuts=50)
    bpy.ops.object.editmode_toggle()
    bpy.ops.object.modifier_add(type='CLOTH')

    # Turn on collisions an increase the quality of the steps.
    bpy.context.object.modifiers["Cloth"].settings.quality = 10
    bpy.context.object.modifiers["Cloth"].collision_settings.collision_quality = 5
    bpy.context.object.modifiers["Cloth"].collision_settings.use_self_collision = True

if __name__ == '__main__':
    clear_scene()
    make_meshes()
    make_fabrics()

A few additional comments about the code:

It deletes the starting cube and adds a Suzanne mesh. I figured this would be more interesting, and it also shows how you need to add the collision modifier.
The cloth is subdivided into 50 (like you did) with the collisions on.

Upon running the code, I end up with the following screen recording upon clicking
"Play":

The cloth correctly collides with the Suzanne mesh, as desired, though it slows down a bit. :)


To the best of my knowledge, it is not possible to directly render only a single color pass in Cycles. However, after rendering your image, you can access the different color passes by using the compositor.

Before rendering, make sure to go to the Render>Layers menu and select "Direct", "Indirect", and "Color" for the material type you want to single out. This makes sure that you have all the necessary color passes when you get to the compositor.

In the compositor, instead of using "Image" as input to the Composite node, you want to combine in some way the three color passes "Direct", "Indirect", and "Color" for your material type. In the example below, I used two Color Overlay nodes as shown in my compositor setup.

My original image:

Diffuse Color Passes only:

Glossy Color Passes only:

My Compositor Setup:


Render Result doesn't match my background image in Camera View

Ok I feel dumb but hopefully this helps someone else!  I had to mess with it for a while because when I just had the render result it wasn't working but actually the scale node fixed it I just had to change the background image to my Render Result!


how do I permanently change the mesh and armature position?

This is actually two questions (probably more): The first is using weights to connect the bones to the mesh.  This is done in Weight Paint mode.
Here's a link to several answers which would help: https://blender.stackexchange.com/search?q=Use+Weight+paint+mode

The second is moving bones; which really just consists of selecting a bone, and moving it in a pose.  However, this is related to parenting the bones and weight paint:
https://blender.stackexchange.com/search?q=Parenting+bones

Possibly a third question regarding adding clothes; but, you should try to ask only one question at a time.  I realize with moving bones, this doesn't appear to be a multi-question problem.  Hopefully these links will help.

I've never had to reset the pose like you mention, but, I searched for information on how to change the pose and make this and the deformed mesh the default.  It says here that this presumes the weights are properly set and the deformations on the mesh work properly.  Credit goes to NixArt for this information.

"This procedure supposes that you have already rigged and weight-painted your object so that it deforms correctly. At this point, you simply want a different rest pose for your object. However, when selecting “Apply Pose as Rest Pose”, you do not want to waste your time correcting your mesh and redo the weight painting for your new rest pose. Here is how you can do it:

Select your armature and go in “Pose Mode”.
Pose your object in your new rest pose.
Go in “Object Mode” and select your deformed object.
In the object’s “Object Modifiers” stack, copy the “Armature Modifier” by pressing the “Copy” button. You should have two “Armature Modifiers”, one above the other in the stack, with the same parameters. This will deform your object twice, but it is ok. If you go in “Edit Mode”, you will see that the mesh has been deformed in your new rest pose.
Apply the first “Armature Modifier” (the top one), but keep the bottom one. The latter will replace the old “Armature Modifier” and will allow to pose your object with respect to your new rest pose. At this point, the object will still be deformed twice. That is because we need to apply the current pose as the new rest pose.
Select your armature and go in “Pose Mode”.
“Apply Pose as Rest Pose” in the “Pose” menu. This will clear the double deformation and put your object in your new rest pose." - NixArt

https://nixart.wordpress.com/2013/03/28/modifying-the-rest-pose-in-blender/

and possibly this tutorial

https://www.youtube.com/watch?v=r1AkueG7zpY&ab_channel=MakeHuman


Locking size of a faces in edit mode. Equal faces sizes for mockup

Bones should be kept for animating characters and in your case parenting edges to an empty and rotation is enough.


Wired face after boolean modifier that make the faces impossible to texture

Booleans will often not take into account surrounding vertices, edges, etc, and just cut away what they need to. You'll probably need to go in and do some surgery to the mesh itself to straighten things out a bit, or you could back out, subdivide the main rectangle first, then do the boolean routine.   Hope this helps!


https://docs.blender.org/api/current/bpy.types.WindowManager.html#bpy.types.WindowManager.popup_menu

import bpy

def oops(self, context):
    self.layout.label("You have done something you shouldn't do!")

bpy.context.window_manager.popup_menu(oops, title="Error", icon='ERROR')


Weird Bug When Trying To Mirror Keyframes

What is your goal here? What do you want to achieve by mirroring keyframes? I'm assuming, that you're trying to mirror pose and make a keyframe of it.Is that right? If so your armature probably is not symmetrized. It means, that symmetric bones on both sides of the body don't have symmetrical rolls. What you need to do is go in edit mode, select all bones of legs and arms, press W and choose Symmetrize. After that mirroring pose should work perfectly.


Handler frame_change_pre doesn't work in render

The answer is similar to this question. Though all this is new from 2.81.
So here are some little more information (as far as I understand all this, which seems to be new thing along the current versions).
To make your script work, you can change it to:
import bpy

def frame_handler(scene, depsgraph):
    #print(depsgraph)
    obj = scene.objects['Cube']
    obj = obj.evaluated_get(depsgraph)
    scene.objects['Text'].data.body = '{0:.2f}'.format(obj.location.z)

bpy.app.handlers.frame_change_post.clear()
bpy.app.handlers.frame_change_post.append(frame_handler)

Here frame_change_post is used. But following this documentation:

This can be used, for example, to alter scene prior it gets rendered.

So the result will be what you want to do.
In the script above I've changed the rounding for Z. That allows to confirm that 'post' is before rendering. If object Z position is 10 at frame 10, the text object will display 10 at the same frame.
Additionally, depsgraph is for dependencies graph. That means a data provided in the API to take into account the fact that during animation (or others) the object state varies due to what it depends on.
frame_change_pre has no depsgraph parameter in 2.82.


How to remove Armature bone from Binary fbx export?

I'm not sure if the bone being exported is infact Blender's armature object (since Blender has an armature object, which can have multiple root bones in the armature).

Seems like this is a known bug, see this report: https://developer.blender.org/T45368 for details.


How is the normal direction determined when I use "Make Edge/Face"?

If you create faces connecting to existing faces, they will be used to calculate the direction. Otherwise the direction is undefined at the moment.

If you have a file that you think is making faces pointing the wrong way, I'd be interested to know, however this is more of a bug report.

The possibility of making faces that point towards the view for example, or as you suggest, using the selection order is interesting and may be added but currently isn't supported.


How to restore functionality while drawing verticies?

The solution is to stop moving your mouse when you click.

In edit mode ⎈ Ctrl is a shortcut to extrude, the selected vertices will be extruded to the point you click.

Holding ⎈ Ctrl while dragging the  is the way to use lasso select. This is what gives you the grey area surrounded by dots.

Note that this is based on blenders default  RMB to select option, by changing that to  LMB you get the same result by using ⎈ Ctrl and  RMB


Replicating your steps:

I vectorized your design and I saved it in SVG.

Imported in Blender and I noticed the svg comes too small.

Not so small as yours.

I entered Edit mode Tab, then Select all A, then S, then 50 and finally Enter.

This made it big enough.

In your case, I think S, 200 could be enough.

See the image below:


Should I turn off Dynamic Topology if I have a huge number of verts?

Lets be clear:  If a feature isn't working, don't use it.  But I'll also provide an alternate perspective.

Z-Brush only recently got its Dynatopo equivalent: Sculptris mode. The workflow for Z-Brush, which has been the industry standard for years, is to make a lowpoly base mesh and sub-divide it until there is enough density of vertices to keep the detail.  The artist usually is working with a mesh that is at least 3 million polys at this point.

What I'm trying to say is: it is ok if you are starting with a high vertex count and work from there, it's an established pro-workflow.  It is a shame Blender isn't able to handle  larger poly counts right now, but that is out of our control.

Remember that while in Dynatopo, the size of your brush will affect the vertex density.  This means you can remove verts by making your brush larger.  You can reduce parts of the mesh that don't need the detail so you can redirect that budget for parts that do.


relationship between light intensity and 8bit grayscale

Light is remarkably predictable and, as with most energies, strictly a linear phenomenon.

If we have a pixel of emissive energy, and we use photographic terms, our ability to perform math is ridiculously simple. To increase the amount of light by double, or in photographic terms a stop, we simply double the value. Want to go down a stop of intensity or halve the quantity? Easy, halve the value.

Our visual system on the other hand, is strictly nonlinear. We sense the visual stimuli and uniquely bend the values to meet the needs of our perceptual system. In particular, we bend a very specific range such that we can detect gradations acutely, while sacrificing the darker and lighter regions our iris has dialed into view.

Given that our devices are significantly lower dynamic range than any physical scene, we cannot however simply pass radiometrically linear ratios of light to our display / output referred contexts. If we did so, the values would appear vastly too dark, even with darker viewing conditions.

To compensate for this complex phenomena, the values need to be bent away from the radiometrically linear ratios such that the relative emission is roughly that which our eyes would expect to perceive the relative levels as expected.

Most imaging formats bake this bent version, also known as transfer curved or tone response curved, into the data itself and the curve varies by color space. Others, with unique design constraints, may or may not depending on file tags and metadata. EXR is one such example that specifically mandates a linear format for the data within.

Finally, the issue of black and white or grayscale adds another layer of complexity. Such a representation is typically an averaged luminance obtained from the RGB triplet. Every colorspace within an RGB color encoding scheme will have uniquely colored primary lights. These colors can be mapped to an absolute color model known as XYZ. The Y axis in this non orthogonal model is relative luminance. To obtain a greyscale representation of any RGB colorspace, one multiplies the Y position of each channel by the value.

TL;DR No you cannot rely on the data values in any given format to be representations of radiometric ratios. It varies by format and within a format, by color space. Further, even if you invert the two part formula for something like an sRGB JPEG, you will only arrive at a rough display linear value set that terminates at display referred 1.0, having compressed and discarded much more of the dynamic range from something such as a camera. EXRs on the other hand will often offer scene linear representations that require no transfer curve inversions. With focus on a sensor-like response, a sensor will capture largely linearized values with nonlinear responses near the edges of the sensitivity ranges.


How to remove title bar in Blender 2.8 Beta?

In the top menu: Window->Toggle Window Fullscreen

Or use:

Ctrl+Space

To toggle full screen use:

Ctrl+Alt+Space

To see the shortcuts that changed in 2.8 go to:

https://developer.blender.org/T55194


Couple of things to make it work.

Origins of the objects should be in the the Center of the Mass and in the same place in space for both of them.

Ctrl+Alt+Shift+C > Origin to Center of Mass (Volume)
Shift+S > Cursor to Center
Shift+S > Selection to Cursor

  Repeat for both objects.

This way we will have both objects in the center of the scene with Origin
Points in the sam place, like so:

Add Array then Curve modifier and set it like this:


How can I link bones from the same armature? Head to Tail and Vice-versa?

IK is indeed the solution. It looks similar in principle to rigging a piston, which is just a type of four-bar linkage: https://vimeo.com/25357097

I think the main insight to make your rig work is the use of IK "Target" bones. For example, where you want the spring to connect, create a small bone parented to the link's bone. Give the spring bone an IK modifier with chain length of one and allow stretching. That should be all it takes.


How to simulate a lamp shade in the game engine

Actually it is translucency, it doesn't have anything common with cloth simulation. Most close and simple you could make - bake Translucent shader from Cycles into texture, but result actually would be good only for one point of view, so I think it would be better but much harder to write own fragment shader.


Image empties are as overlays and you disabled them to display. Enable them back and your image will be displayed again:


Blender 2.8 image texture node and color space

In short:

Use "non-color" for inputs that are supposed to be spatial (3D) vectors or simple factor values.
Use one of the others (depending on your needs) for what is effectively a color.

More details:

I've dig a bit into Blender code and into OpenColorIO (OCIO) documentation and my (very young and superficial) understanding is the following.

Blender uses a processor component to handle image data. This processor can be based on OCIO or be a 'fall back' one if OCIO is not present (I don't know why it could be absent... maybe to allow Blender to run on some low level hardware?).

The main goal of OCIO is to allow to transform image data into device rendered image data which fits the best to human eyes perspective as (for instance) our perception of light intensity is not linear (so intensity can be coded or manipulated linearly, as it is, but rendered differently). But more globally, OCIO can process image data transformation 'the way you want'.

OpenColorIO is a set of libraries (programs) that are provided OCIO organisation and these libraries are open source.

From that, when an image is processed (in our case for texture nodes) it is given to OCIO to do it. And OCIO is based on a configuration that can be found in 'Your installation path\2.8\2.80\datafiles\colormanagement'.

In this directory, we can find a file called 'config.ocio' (describing the possible configurations) and two subdirectories 'filmic' and 'lut' (containing data tables used by these configurations).

LUT stands for 'look up table'. For image calibration it has been defined by Academy Color Encoding Specification (ACES). Linear ACES is one of the possible option for the texture node.

Filmic is another calibration approach. The best is to read this answer from troy_s to know more.

The general principle of OCIO configuration seems to be giving a range to the input data and apply a transformation table to it. Transformations can be direct or reverse.

Concretely, what about 'XYZ', 'sRGB', 'Raw', 'Non-color', 'Linear ACES', 'Linear' and 'Filmic-Log'?

XYZ

'XYZ' is not 3D vector (x, y, z).

CIE XYZ is a calibration and its result is analogous to the LMS color space which corresponds to the cones response of the human eyes.
Y is the luminance. Z is nearly the blue. X is a mixing factor. The response value for them is defined in the OCIO configuration.

This is a transformed data.

sRGB

Stands for Standard RGB and is the "default color space for byte image" as defined in 'config.ocio'. It also has a transformation table defined in it.

This is a transformed data.

Raw

'Raw' is the image encoded data as it is. There is no transformations for it.

This is not a transformed data.

Non-color

This is similar to 'raw' from the calculation point of view. But it is semantically different as it is for things we know to be 'non color'. The comment in config.ocio says "color space used for images which contains non-color data (i,e, normal maps)".

This is not a transformed data.

Linear ACES

It is transformed by OCIO. The configuration is linear (as said in it name) and is done from a table giving parameters of this operation for each color channel.

This is a transformed data.

Linear

Correspond to Rec. 709 (Full Range) and is commented as 'Blender native linear space'.

This is a transformed data.

Filmic-Log

Again please refer to this answer. It is commented as 'Log based filmic shaper with 16.5 stops of latitude, and 25 stops of dynamic range'.

This is a transformed data.

A link to OCIO configuration in the Blender repository.

Note:

When using an image texture node, the color space information is given by or set to the image texture itself. This is not a node property. So that, if you set the color space in one material, this will affect all the others that are using the same texture.


No need to worry, everything is fine.
Main Reason
Since Blender 2.8, the installer is signed by the Blender foundation for improved security. However:

Ray Molenkamp (Blender for Windows developer):
Windows Smart Screen is throwing a fit, since we are a new publisher it has never seen before.
There is nothing we can do on our side about smartscreen except wait for it to have enough data to trust us.

Temporary solution
(versions that don't trigger Windows Smart Screen)
Blender from Microsoft Store
Blender from Steam
There's a whole thread on developer.blender.org if you want to know more.


MakeHuman Model Rigging - Bone Heat Weighting Failed To Find Solution

Try scaling up your object and the rig by a fair bit (say 10x) then try again. The algorithm seems to have some sort of hard internal limit for how close vertices can be (or something like that) and thus larger, less dense models seem to consistently work better. After parenting you can scale it back down again.


The issue with your unwrap isn't the seam placement, it's that you didn't uncheck Fill Holes in the unwrap dialog.
This is probably way overkill, but here is the layout I came up with that uses the least amount of visible seams as possible:
Top:

Bottom:

The layout:


By only looking at the filenames, v2.78 has releases for glibc 211 and 219.

Another option would be compiling blender yourself, that will allow you to patch any glibc calls that aren't compatible with the older library version. As it is only the latest version that doesn't use the older library, I'd expect it to be only a matter of linking it with the older library rather than making any code changes. Any incompatible code changes that have been made can be found in blenders source code repository so you can also see any related code changes that will be affected by the change.


How do I obtain an untriangulate rendered image in Cycles?

Go to edit mode and Press Alt+J or Press Ctrl+F and select Tris to Quad


Extrude/Scale evenly in a mirrored circle

Pivot in the circle's center

The origin of the trasformation in your current setup is probably set to "median point", so the scaling is using the baricenter of the geometry as pivot point.

This is usually not a problem while scaling a full circle, as the baricenter of the whole points is in the exact location of the center of the circle.

If you are controlling just half of the point, you should switch to another type of pivot point, that allows you to set the center of the circle as pivot for the transformation.

I'll suggest to use the 3D cursor as shown in the image sequence below:


How do I switch form Object mode to Edit mode, Weight Paint, Vertex Paint or Sculpt Mode mode in version 2.8?

To toggle between different modes use the keyboard number keys

1 for Object Mode

2 for Edit Mode

3 for Weight Paint

4 for Vertex Paint

5 for Texture Paint

6 for Sculpt Mode

Source: https://youtu.be/t-EKbCJagqI?t=356


Blender renders always frame 1 on 2nd computer

I answer the question on myself. I can't excatly describe what the problem was, but I...

a) updated from Blender 2.79 to 2.80 beta
b) baked animations and physics
c) corrected dope sheet animations with start and end points

As side effect I have a ~5x performace gain, what is great, I'm not sure if the new blender or the baked animations did this.
Now parallel computation on 2 notebooks and 1 desktop runs fine, resulting in another ~3x performance gain. :-)


Particles can be used to emit smoke, and I've seen something quite similar to what you posted.

The current version of Blender allows a lot of particle tricks, like particles fighting flocking etc..

It might take Blender a bit more time to render, but smoke is pretty good from blender. Here is Death-Eater (Harry Potter effect) that's quite close to what you seem to be looking for.


How to make curved (bent) rectangle, and add material?

The shape of the object.

Cube scaled as appropriate in Edit Mode
Loop Cut to provide vertex density to allow the next step to work.  The edges are shown above.
Curve Modifier.
Smooth Shading
Edge Split Modifier to keep sharp corner where needed and keep smooth shading where needed
I hesitate to comment on material yet I will comment that the dark lines can be achieved with Freestyle which requires more searching and learning.

You can search [Curve Modifier] and [Edge Split].  There will be many matches at BSE.

Hopefully you get more than one answer with different approaches as well.


How to build a rectangle with convex edges and rounded corners?

I suggest you this: if the exact shape is important, trace the bitmap to svg, then import the svg and import it to Blender, convert to mesh, clean the mesh... done! Here it goes:

Open Inkscape, paste the png and trace it like this:

you need to clean the traced paths, delete whatever is not your desired shapes...

then delete the bitmap, save the svg and import it in Blender: scale the imported curve enough (I did 50x), and put "geometry to the center" using the toolbox function (left panel).

then, convert curve to mesh, and change material color if you wish:

Then, convert all mesh triangles (many) to simple ngons, using limited dissolve:

there you are! Of course you have many vertices...

Of course you could also just keep the vector/curves....


Going down the wrong path for human skin?

I was recently dealing with a similar problem.  I found that I didn't really have to worry about it-- these kind of detail, high-res normal maps can stand a bit of noise.  Specular rarely aligns closely enough with a seam for it to be visible.

If you try that and find you're having visible problems, you may want to consider masking your normal map with another (hand-made) texture.  I'm not sure of your application, but with what I was doing, scaling the R and G components down smoothly eliminates the normal map (leaving only the meaningless depth component of the vector).  You may want to consider an unorthodox seaming strategy for this, seaming along the smoothest parts of your model rather than natural lines, since these seam lines are exactly where you'll be masking the normal map.  That may mean using an extra set of UV coordinates.


Never mind. I found one. Here's the link for anyone else looking: https://github.com/Antonioya/blender/blob/master/add_window_3/add_window_3.zip


My skinned model gets smaller and deform badly, when I rotate its bone in Z-axis

You haven't weight painted your model

From the Wiki
Weight Paint in a nutshell

Weight Painted Vertex Group

  You enter Weight Paint mode from the Mode Menu Ctrl-Tab). The selected Mesh Object is displayed
  slightly shaded with a rainbow color spectrum.
  The color visualizes the weights associated to each vertex in the active Vertex Group. Blue means unweighted; Red means fully weighted.


Beveling edges with varying number of segments (preferably programatically)

As the index of an item changes as edits are made to the mesh you need to get each edge object before making any changes, then refer to each edge as you do the bevel. You can use the edges verts property to get the vertices at each end.

import bpy, bmesh

bpy.ops.object.mode_set(mode='EDIT')
me = bpy.context.edit_object.data

# edge_bevel_data
ebd = [
{'idx': 13, 'edge': None, 'offset': 0.05, 'segments': 3},
{'idx': 32, 'edge': None, 'offset': 0.04, 'segments': 2},
{'idx': 89, 'edge': None, 'offset': 0.06, 'segments': 3},
]

bm = bmesh.from_edit_mesh(me)

# first get the edges
for i in range(len(ebd)):
    ebd[i]['edge'] = bm.edges[ebd[i]['idx']]

# bevel each edge
for i in range(len(ebd)):
    e = ebd[i]['edge']
    bev_geom = [e.verts[0], e.verts[1], e]
    o = ebd[i]['offset']
    s = ebd[i]['segments']
    bmesh.ops.bevel(bm, geom=bev_geom, offset=o, segments=s)

bmesh.update_edit_mesh(me, True)


How does "Flip Normals" affect Face Corner Data?

I would assume this is due to the fact that it is a bunch of disconnected planes which are treated like one object. In the newer Blender 2.8x+ series, normals are automatically corrected while editing in edit mode.
The problem in your case is that all of the disconnected planes are being treated as if they are one object, and therefore, the normals are going to look very messed up. However, if you try this with all the planes connected into a full, closed mesh, you should see this problem disappear when you recalculate (if needed) the normals. If you flip the normals, they should flip.


If you are in Cycles Render, select the object, go in the Properties panel > Object > Cycles Settings, and disable Shadow.

As aded by Lemon, if you are in Eevee, select the object, go in the Properties panel > Material > Settings, and set Shadow mode to None


How do I fix these weird lines in my model

Those lines are a result of mesh distortion. It means that your polygons aren't "flat". Mesh distortion results in shading errors.

Blender's Mesh Analysis functionality helps you checking with these kind of problems. In the screenshot below you see all the distorted polygons in your mesh. Grey is ok, then it goes from blue to green and finally to red (which means bad).

This is OK to a certain extend, but it depends on the purpose of your model. I would stay in the grey and blue-ish area to keep things safe.

The solution in your case would be working with a little more polygons, for example by adding loopcuts and then moving the vertices until the polygons change their color into blue or turquoise.


Here is my solution:

 (updated to v3.5)

How to Use:

-First, download and install Animation Nodes v1.6 from here.

-Open the file, DIY your own sramble and solution notation list in Text Editor.

-Tweak parameters on Settings node if needed, then play animation.

Advantages:

Use standard move notations to control moves.
Allow playback.
Solvable (any move is pre-calculated).
The whole cube is parented to a root object for additional transformation control.
With a few more additional features for convenience.

Basic Idea:

First, generate a sequenced euler list by the notations read from textblock(s) for each move.

Second, generate bool list for each unit to decide whether it should be rotated according to the notation during each move (e.g. when notation is U, it means only the top layer will be moved, while the mid layer and bottom layer will keep still).

For the unit objects, a custom property called Position ID is implemented, which indicates the exact position of each unit right before next move starts. After moving(rotating), the Position ID will be overwritten by a new one according to the new position.

[TBC..]


How do I make objects ignore certain Light sources?

This isn't possible in Cycles just yet; You will need to move those objects to a different Render Layer. However it is possible on Blender Internal, using one of these methods:

Materials

By default, materials are lit by all lamps in all visible layers, but a material (and thus all objects using that material) can be limited to a single group of lamps. To enable this, navigate to the Material menu's Options panel and select a group of lamps in the Light Group field. Note that a light group must be created first.

If the Exclusive button is enabled, lights in the specified group will only affect objects with this material.

Render Layers

You can also use RenderLayers. If a light group name is selected in this Light field, the scene will be lit exclusively by lamps in the specified group.

Check the relevant wiki page.


How do you use constraints with Armatures?

You can use armature in Constraint parentings very easily, select the object you wan the bone to influence, add the desired constraint, and then select the proper armature.

You can also select the individual bone within an Armature object within the Constraint settings.

Not only that, you can also influence a bone's rotation via constraints:


I think it could be that you used the Glossy Shader in the material. This causes the world background to be reflected in some parts of the mesh.


Is there a shortcut for switching pivot point?

, : Bounding Box Center

. : 3D Cursor

Ctrl + . : Individual Origins

Alt + , : Toggle Manipulate center points

If you want to customize the shortcuts, open the Blender User Preferences > Input, set the Filter Type "Key-Binding" and type , in the search field.

You'll find the list of the Assignement Values here:

http://www.blender.org/api/blender_python_api_2_74_0/bpy.types.SpaceView3D.html?highlight=bounding_box_center#bpy.types.SpaceView3D.pivot_point


backside selected only by border select and lasso, but not mouse click

This is the basic idea : we keep the occluding OFF but switch it ON only when selecting with mouse click, and for this you create your own operator for selection and replace the shortcuts to point to this new operator.( or simply override the old operator )

Here is the code that does that run it then set the shortcuts

import bpy
from bpy.props import BoolProperty, IntVectorProperty

class SelectionOperator(bpy.types.Operator):
    """ Costum selection
    """
    bl_idname = "view3d.select_costum" #to override the old selection replace this with "view3d.select"
    bl_label = "costum selection"

    extend = BoolProperty(default = False)
    deselect = BoolProperty(default = False)
    toggle = BoolProperty(default = False)
    center = BoolProperty(default = False)
    enumerate = BoolProperty(default = False)
    object = BoolProperty(default = False)
    location = IntVectorProperty(default = (0,0),subtype ='XYZ', size = 2)

    def execute(self, context):
        context.space_data.use_occlude_geometry = True
        bpy.ops.view3d.select(extend=self.extend, deselect=self.deselect, toggle=self.toggle, center=self.center, enumerate=self.enumerate, object=self.object, location=(self.location[0] , self.location[1] ))
        context.space_data.use_occlude_geometry = False
        return {'FINISHED'}

    def invoke(self, context, event):
        if context.space_data.type == 'VIEW_3D':
            self.location[0] = event.mouse_region_x
            self.location[1]  = event.mouse_region_y
            return self.execute(context)
        else:
                self.report({'WARNING'}, "Active space must be a View3d")
                return {'CANCELLED'}

bpy.utils.register_class(SelectionOperator)

if you didn't override the old selection you have to change the shortcuts :

hit Ctrl+Alt+U
in Input➝3D view➝3D view Global➝Activate/Select
change the operator to view3d.select_costum
repeat for all the Activate/Select entries below this one


If you want the IK-Handle to stay in the same position as the pencil, simply use a Bone Constraint on the IK-Handle. Select the IK-Handle in Pose Mode and add the Copy Location Constraint from the Bone Constraint Menu (not the regular Object Constraints, see screenshot). Choose the pencil as a target, the bone will then follow the pencils origin.

If that origin is not where you would like, simply parent an Empty to the pencil in the place you want the hand to grip it and target the Bone Constraint to that Empty.


Blender does not allow key-framing text data, so you can't really bake this animation to key-frames. What you can do is separate the texts using the Separate Text node and then animate the scale or the visibility of the individual characters as follows:


BGE: Expression to check if Collision Sensor's property is True or False

No Expression Required

I don't know if there's no way for a Collision Sensor to pass along the value of the property it's watching. Instead, we can have the object collided with send a Message, and receiving that Message can be one of the conditions required by an And Controller in order to trigger the Actuator.

Obstacle Logic

Cube Logic

As for expressions, here is a reference. I'll re-post it below:

Table 26-1. Valid expressions

Expression type  Example
===============  =======
Integer number   15
Float number     12.23224
Booleans         TRUE, FALSE
Strings          "I am a string!"
Properties       propname
Sensornames      sensorname (as named in the LogicBrick)

Table 26-2. Arithmetic expressions

Expression       Example
==========       =======
EXPR1 + EXPR2    Addition, 12+3, propname+21
EXPR1 - EXPR2    Subtraction, 12-3, propname-21
EXPR1 * EXPR2    Multiplication, 12*3, propname*21
EXPR1 / EXPR2    Division, 12/3, propname/21
EXPR1 > EXPR2    EXPR1 greater EXPR2
EXPR1 >= EXPR2   EXPR1 greater or equal EXPR2
EXPR1 < EXPR2    EXPR1 less EXPR2

Table 26-3. Boolean operations

Operation        Example
=========        =======
NOT EXPR         Not EXPR
EXPR1 OR EXPR2   logical OR
EXPR1 AND EXPR2  logical AND
EXPR1 == EXPR2   EXPR1 equals EXPR2

Conditional statement: IF( Test, ValueTrue, ValueFalse )

Examples:

Table 26-4. Expression examples

Expression           Result          Explanation
==========           ======          ===========
12+12                24              Addition
property=="Carsten"  TRUE or FALSE   String comparison between a Property and a string
"Erwin">"Carsten"    TRUE            A string comparison is done

And if anyone figures out syntax for testing the value of a property, please share.


It's unlikely that this overlap matters; assuming this model works okay in GMod, these are probably different materials that use different textures.

However.  A smart first step is to create a new UV map to work with, so that you can later bake any textures from this UV map to your new UV map.  Switch to properties view/data/UV Maps, select your UV map from the list with LMB, then hit the + button to the right of the list.  This copies that UV map to a new UV map.

Okay.  Now select your object, switch to edit mode, and select all vertices.  Open up a UV editing window; if it's set to a rendered image, change the image to something else so that you can see and edit your UV coords.  Select all verts in the UV editor ('a' once or twice or however you want.)  Hit ctrl-p to pack the islands.  This will translate and scale the UV islands in order to eliminate any overlap.  (There are other techniques you can use, but packing islands is the easiest and simplest.)

At this point, if you need to, you can bake your original textures from their original UV to your new, packed UV.


Hand model keeps bending finger when wrist is rotated

The reason is that the last bones on that finger have a bone constraint with "world space" instead of "local space", as ll the others have


Yes, you can do this. It's fairly easy once you know how.

Go to the frame you want to start on. In your case, 100.
First select the whole video. Then press Shift+K, to hard cut. Now you should have two videos and/or audio(cutting the video cuts the audio too).
Then do the same as number one but to last frame you want to cut out. (200)
Simply select the middle video and audio, and press X then E
Finally select the last strip of video and audio and slide over to the first using G

Want More Info?

Check out Mikeycal Myers Videos on Blenders V.S.E. here
For this, I would recommend video #4


What does it mean when blender prints "cyclic OBU" to the console?

I figured out how to reproduce the message.

Create two objects and make one the parent of the other (maybe Cube is the parent of Sphere)
Create a second scene.
link the child object from the original scene to the new scene (I selected the sphere and used the Ctrl-L menu to do this).
Switch to the new scene.  Blender prints "cyclic OBSphere".

I suspect it's because the scene includes an object whose parent is NOT in the scene.  I have a feeling it is printing "cyclic OB%s", and this is going to make it hard for anyone googling to find an answer, since the only constant is the word "cyclic".  OB is glued to the name of the object which can vary quite a bit.  I bet "cyclic OBCube" or "cyclic OBCube.001" will be pretty common.

In my original question it was an object named "U voxel -8.0,-4.5" .

This is with blender 2.74


How do I remove overlapping faces for this case?

First of all you need to select the inner ring that you created with I. You can use Alt for it. Then deselect everything that is fine with the circle selection tool (C). Then press X and select Edge Collapse. Your problems should now be fixed. For that selection part I made a little picture here:

Just deselect everything which is outside the problem area.


Use denoiser on certain frames of animation

Ended up with this code, where denoiser starts working on specific renderlayer only on certain frames.

import bpy

scene = bpy.context.scene

def denoiser_control (scene):
if scene.frame_current in list(range(66, 90)) + [1, 20, 50]:
    bpy.data.scenes["Scene"].render.layers["RenderLayer"].cycles.use_denoising = True
else:
    bpy.data.scenes["Scene"].render.layers["RenderLayer"].cycles.use_denoising = False

bpy.app.handlers.frame_change_pre.append(denoiser_control)

range(66, 90) stands for some frame range and [1, 20, 50] defines single frames.


How can I cast artificially darker shadows?

You have three options.

You could add a light that is only visible to the shadow path, so it won't add any light, but it will cast shadows.  If you're happy with the scene otherwise, you should duplicate one of the existing lights and move it forward or back just a touch.
Another option is to add a "negative light", where you add a light with a color of white, and a negative value for the strength.  There aren't such things in real life (except maybe black-holes) but for some lighting effects it is a neat trick to add darkness.
Lastly you could do something with render layers, and render passes to get the shadow on it's own render layer and then control how dark it is during composting.


Proportional Editing - Limit to selected?

One workaround is to select the vertices that you want to leave unaffected and press H to hide them. Proportional editing will only have effect on the visible geometry.


How to animate a lightbulb going on and off

The principle is the following but can be more or less complex starting from the video as it will surely involve several drivers and to do it in material and compositing nodes settings.

Here the cube's color is changing depending on the position of an empty along Y (the effect is visible in rendering mode):

In this example, I add a driver to the 'fac' value of a mix shader:

Then open a view and set it to 'graph editor' (1), then set it to 'drivers' mode (2), select your object (the lamp in your case), then its material and the 'fac'. Then (4), open the right panel (N) and choose the 'drivers' tab:

Add for instance an empty. Then in the driver panel, use it as input (variable) object (1), and for example choose its Y position to drive the result. Set (2) the driver to 'scripted expression' then set the expression to (var > 0) so that the output is 1 when the empty.Y is above 0, and is 0 when it is below 0.

Doing that, the mix shader node is driven by this previous driver's output. So you can animate a lamp this way, just moving an empty.


How to delete concave edges automatically?

Convex Hull operator

There is an operator in the Vertices sub menu (under Mesh) called Convex Hull that

  Enclose selected vertice in a convex polygon.

For the proposed mesh the result could be something like this:


Bevelling concave curve part results in buggy mesh

What you are seeing are shading artifacts from intersecting geometry.

Very tight sharp corners always cause problems when beveling in graphics software in general, since the software can't automatically handle these hard corner-cases cases unless it is specifically programmed to, or an option exists to clip/trim or extend said bevel options.

Blender has no special tools to deal with these so they end up self intersecting.

I usually solve it with the Offset modification available to the left of Bevel value.

Since beveling offsets the curve "outside" by the same amount of units used as bevel factor, all you have to do is counter this by using that value as a negative factor for offset so Blender "insets" the growth.

Additionally you may want to add an Edge Split modifier to your curve to avoid smoothing artifacts or errors.


By material, I assume you mean the mesh. For the purpose of simulating the cloth, the answer is no you don't need volume/thickness.

You can dynamically add thickness that is not calculated in the simulation by adding a Solidify modifier after the cloth modifier. This may be useful if you want the cloth mesh to appear thicker without slowing down the simulation
AFAIK, no. I have seen no visible differences after running a few tests.
I'm not sure what you mean. Could you try and explain more/add screenshots?

From the wiki:

  Structural
  Overall stiffness of the cloth.

  Bending
  Wrinkle coefficient. Higher creates more large folds.

Also see the wiki page on cloth simulation.


What does the geometry node mean with the point the shading point is being viewed from

I find it helpful to think about this as naive, simplified reverse ray-tracing.

So a ray is fired from the camera through a pixel in the screen, and hits a shading point on a visible surface. That ray is then split, and bounced off the surface towards all the lamps it can 'see', asking of each lamp: "what light contribution are you making to my color calculation?" The 'incoming' output of the lamp shader's Geometry node  is the vector representing the direction of that last segment of the ray, which hits the lamp. (To or from doesn't matter in this case).

The CombineXYZ, Mapping, and Normalize nodes establish an easily rotated unit vector P, whose origin we can think of as being at the lamp.

The DotProduct and Absolute nodes return the positive dot product of the incoming ray and P. The closer this is to 0, the smaller the angle between the incoming ray and the plane whose normal is P, passing through the lamp. We want the light to emit only if the incoming ray's origin is close to that plane.

The angle won't do. We want a measure of the distance between the origin of the ray and the plane. We don't want our beam to spread as it gets further from the lamp. The Light Path>Ray Length and Multiply nodes multiply the our dot product by the length of the incoming ray, giving  us a number which varies linearly with the distance of the ray origin from the plane. (Think similar triangles.)

The Less Than node returns 1 if that distance falls within a threshold, 0 if not.

The Light Falloff>Constant>Strength and Multiply nodes give us a light whose intensity is a constant Strength value, irrespective of the length of the incoming ray, if the threshold requirements are met.

The result: a planar sheet of light, which doesn't decay with distance, with an adjustable rotation, strength, and thickness.


how to add texture to an object import in .stl format

An image or procedural texture is used by a material to control the color over the surface of the object.

Using blender render, a texture can only be added if a material has been assigned to the object. Also note that the texture panel has sub-sections, you will want the material textures option to be selected. After importing an .stl file, there may be no material, so first create the material and then add a texture.

Also there are differences based on the render engine chosen, cycles uses a nodes based system that allows textures to be incorporated at different stages of the material.


When I open my project all shadows have gone

I don't have enough reputation to comment, sorry.
In addition to Christopher Bennet's comment (making sure you are in the rendered viewport, Z -> Rendered) I will suggest another possible cause for future readers.
In Eevee, one can turn off shadows manually for each light source. You can click on a light source in the outliner, go to object data properties (the light bulb). There you can select two checkboxes: Shadow and Contact shadows. Check if these have not been accidentally turned off.


Problem solved. Used a circle as a target for the aray of treads with the array modifier. That worked but did not bend the tread mesh itself. Using a nurbs curve and a curve modifier also bended de mesh of the tread.


Sometimes you get this issue with orphaned vertices, which can be fixed with Merge By Distance option. And sometimes it needs to be UV reunwrapped, as I think you have discovered.