To remove panels, you can simply unregister the classes.

Here we remove all View 3D Panels:

import bpy
for pt in bpy.types.Panel.__subclasses__():
    if pt.bl_space_type == 'VIEW_3D':
        bpy.utils.unregister_class(pt)

Of course you may want to do some other checks to only remove some of the panels... try use the Python console to inspect the panel types and see which members are useful to check (__name__ for example)

Note that __subclasses__ is a standard Python method.

This works for other areas too, operators, menu's, (any class which can be registered).

To run Multiple times you need to check if the class has a specific RNA attribute:

import bpy
for pt in bpy.types.Panel.__subclasses__():
    if pt.bl_space_type == 'VIEW_3D':
        if "bl_rna" in pt.__dict__:   # <-- check if we already removed!
            bpy.utils.unregister_class(pt)

Note that this making use of an internal attribute and is not a documented part of the Python API, its used for Blender's own tracking of classes.


Animated extruded curve & micro displacement

I see no vector input in your textures nodes. What texture coordinates are you using?

Generated textures will often default to either Generated or Object type of automatic UV coordinates when omitted, both of which are local coordinate dependent.

That means geometry based animations with local mesh deformations in object space coordinates will change the sahpe of the geometry and hence its apparent UV mapping for a certain vertex, making it look like an animated texture.

You could use Bezier curve automatic UV coordinates, but those will most likely also deform along with the "growth effect" giving either an animated effect similar to what you have now or a non uniform stretching effect (which I am not sure is what you want or not).

Only way I could see this work is using a manually unwrapped mesh object instead, with controlled UV coordinates based on actual vertex, instead of object coordinates.

You could mate a cylinder object, with a quad based geometry, unwrap it into a orthogonal grid, then scale one of its ends to make it a cone. Subdivide it along its height enough times to suit your needs.

Then add a Curve deformation modifier so it deforms along the curve then use scaling along the local Z axis to give the growth effect. That should give a more static texture appearance even though it will still stretch with the growth. Otherwise you will likely also have to animate UV along with shape to compensate it.


This is a problem with the normals. Game engines will always display on only the side where the normals are pointing out. As far as I know, Blender does not allow  double sided normals, so make two planes, one for each side.


Is that normal to have larger render time with GPU?

GPU's are generally a better solution for your renderings. They offer more processing power and that can be harnessed to render your scenes.
Here your GPU might not be supported or your drivers not in place, If its not any of these, then its your GPU that is and. Get a newer one and it should work :)


How to lock center vertices with mirror modifier?

You want to enable clipping in the mirror modifier.
From the blender manual page for the mirror modifier.

Clipping
Prevents vertices from crossing through the mirror plane(s). Note that this is only valid in Edit mode (i.e when using object transformations, translations, scaling, et cetera, in Object mode, vertices will happily cross these borders.)
If Clipping is selected but vertices are outside of the Merge Limit the vertices will not merge. As soon as the vertices are within Merge Limit they are clipped together and cannot be moved beyond the mirror plane. If several vertices are selected and are at different distances from the mirror plane, they will one by one be clipped at the mirror plane.


what are you trying to do exactly? First you need to make some corrections: In Edit mode delete the vertex that is far away from your main plane, to do it select the plane with the lasso, then Ctrl i to inverse the selection and catch the lone vertex, then X to delete. Also in Object mode apply the scale of the plane and curve. Now as the plane is a bit shorter than the curve, if you ask a Fit Type > Fit Curve it will duplicate once. You can choose the curve in the Curve modifier. If the plane scales crazy, it's because the curve's vertex radius are very high, so in Edit mode select them and in the 3D View N panel bring them down to 1. And if you want the plane to begin at the beginning of the curve, put the origin of the curve at this point.


How to get correct lightning in the shadows?

Okay, got I myself. Didn't changed my render engine from Eevee to Cycles..
So much better :)


Blender crash while rendering image after building BVH

I've had the same problem. In my scene I used completely overloaded particle settings. Rducing children from 300 to 100 (before Mem. 3,97 GB, after Mem.1,97) fixed it and redering worked. Good luck


Can I increase the number of frames in an rigid body simulation?

You can change the number of frames in the Rigid Body Cache.


Armature Uneven deforming with Modifiers?

One can't parent a mesh to multiple armatures, and 1 should realy be enough.
If there are some small morphing you'd like to do who are because of their detail movement not easily done with bones, you can add shapekeys for that.

Notice its also possible to use bone constrains (often with empties as helper objects) to control you bones, ea i did that in a car rig, just telling because i dont see any reason why 2 armatures would be needed. I made way more complex armatures but have never had a need for it, so it puzzles me why you want it.
Its a but unclear to me, what you try to achieve with it, perhaps if you can explain i might think of another way to do that.


You need to do all this on one material. Applying materials to individual faces is not going to work for rapid testing.

Once you are using only one material toggling On and off is easy and changing the color is super simple.

First off you will need a mask to differentiate what parts of the mesh will get what. I'd recommend using an image (easy to paint in texture paint mode and transferable to any game engine), but you can also use vertex colors, or proxy objects inside blender.

For my example I'm using an image, and vertex colors.

The image texture node is the mask I painted. The key to the toggling is the MixRGB node(s). The Value input node is what I'm using to control the toggling. When the value is 0 the MixRGB node is outputting 100% black, which is feed into the Fac for the Mix Shader node. (0 uses the top socket, 1 is the bottom socket) Likewise when the value is changed to 1,  the MixRGB outputs the mask image which has white painted in the proper places. Thus the Emission shader gets to shine.

Its the exact same thing for the one I have labeled "Engine toggle" except here I'm using the vertex colors as the mask instead of an image.

The RGB input is how I'm changing the color of the "lights." You could also use a image and a special UV map just to re color (You would simply move the UVs to a different color) but for in blender the node is much easier.

The nodes can look much neater when wrapped in a node group, but for testing I prefer access straight to the nodes.


After updating to Blender 2.68 Driver Scripts are no longer automatically excecuted

You can turn this setting off in the user preferences by unchecking Auto Run Python Scripts:

See the wiki for more information.


My Texture looks paler/brighter in my 3D viewport than in my UV

I take it that you are using the material preview mode? This is occurring because the material preview mode still applies lighting to your model albeit not much. When the light strikes the darker and lighter areas of the texture, it uniformly brightens them all since there is no geometry/normal map etc. to cause the shadows to be emphasized or maintained.

Try increasing the material roughness and reducing the material specular properties if you want to minimize the effects of lighting.

Just for fun, take a sphere and set roughness to 0 and metallic to 1 in the Material Preview mode. This is what you'll see since Blender is using some lighting to light the model.


Why isn't 'bpy.context.object.name' printing out the name of my newly created object?

The simplest solution is to use active_object instead:

def execute(self, context):
    bpy.ops.object.empty_add(type='PLAIN_AXES')
    print(bpy.context.active_object.name)
    return {'FINISHED'}

Blender doesn't switch the bpy.context.object until after the createEmpty operator has completed, hence the Cube's name was being printed. Your operator is invoked from the createEmptyPanel which has bl_context = 'object', I suspect this has built in blocking of bpy.context.object changes.

Avoid this behaviour by using the lower level bpy.data.objects.new to make the empty. Change the execute function to avoid using bpy.ops.object.empty_add(), like:

import bpy

class createEmpty(bpy.types.Operator):
    """Create an empty object"""
    bl_idname = 'make.empty'
    bl_label = 'Create an empty object'

    def execute(self, context):
        # bpy.ops.object.empty_add(type='PLAIN_AXES')
        scene = context.scene
        objects = bpy.data.objects
        mt = objects.new("empty_name", None)
        mt.location = (0, 2, 1)
        mt.empty_draw_size = 2
        mt.empty_draw_type = 'PLAIN_AXES'
        scene.objects.link(mt)
        scene.update()
        print(mt.name)
        return {'FINISHED'}

class createEmptyPanel(bpy.types.Panel):
    bl_idname = 'create_empty_panel'
    bl_label = 'create empty object'
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = 'object'

    def draw(self, context):
        layout = self.layout
        row = layout.row()
        row.operator('make.empty')

bpy.utils.register_class(createEmpty)
bpy.utils.register_class(createEmptyPanel)

It's a bit more verbose, but it does immediately give you a reference to the new empty.


Why does blender select random faces in edit mode? (Ubuntu)

In edit mode, you see the three boxes for either putting select mode into 'vertex', 'edge', or 'face'?  Next to that is a button called 'Limit selection to visible'.
When it is 'selected' or darker, selecting parts of the mesh will no longer select what is behind the cursor on the other side.

See pic.


BI:
BI does have volumetric rendering, so you could you could use two Spot lamps with Halo enabled to get this effect:

ShiftA>Add > Lamp > Spot

Select the spot lamp and duplicate it with AltD to  duplicate linked. This way all settings will be mirrored between each Linked Duplicate.

Rotate the duplicated lamp 180° (R180):

Enable Halo in Object Data > Spot Shape.

Note that to get volumetric shadows, Step will have to be set to 1 or higher:

Result:

Cycles:
Cycles does not yet have volumetrics integrated, but they are planned to be in 2.69 or 2.70:

Plans
For 2.68, the following features are planned to be worked on:

Hair shader
Ubershader (combined diffuse+glossy+transparent node)
Look into of improvements for SSS, AO, mist, ..

After this the next big feature will be Volumetrics. Probably the
first release with Volumetrics will be 2.69 or 2.70.

You could fake this in Cycles by using the same scene with two spot lamps, but with transparent cone objects along with spot lamps to act as the volume.

Add a Cone and match it to the shape of the spot lamp:

Create a material for the cones. The IsCamera ray node mixes the transparent shaders so that the cone appears to have some color only to the camera. All other rays will just pass through it unaffected. The Layer Weight node allows us to change the color based on how much faces point towards the camera.

Result:

Note that with this technique it is impossible to get volumetric shadows. (see this post for some tricks to fake volumetrics in cycles with shadows.)


How to use a driver to pan and zoom an image

Either you should be using a driver OR you should be using keyframes - not both since one will override the other. It sounds like you should actually be using keyframes - so right-click and Remove Driver.
Using keyframes the field should be yellow/orange/green to indicate the keyframe. Move to your frame, set the value, then hit ‘i’ to insert keyframe. No need for driver.


Why are bright textures showing up in shadows on EEVEE?

By adding a color ramp between the base color and the divide i was able to fix it


Blender (2.91) crashes immediately when I press render because of animation nodes addon

This is probably because the add-on is not compatible with blender 2.91. You will have to use a version that is compatible with the version, like 2.83. That is most probably the reason why it isn't rendering. It could also be that the animation nodes are so heavy that they ate up all the Ram at that instance. Try to look for an alternative. Do try the first solution, if it still doesn't work, then try for an alternative add-on.


The "eye-like" logo seems to be the one from Blenderguru. Doing a reverse image search on Google, it seems that it has first been published by Greg Zaal for the Cycles Shader Encyclopedia.

I don't think you should use it, since the logo might be copyright protected. For blender users, the Blender ape "Suzanne" is often used for demonstration purposes. You can create it by "Add/Mesh/Monkey".


Blender may be buffering the source video differently at render? Try transcoding the source files to another codec first, as it looks like a screen capture and they are notorious for having strange FPS (frames per second) values.

I'm afraid that Blender's video function is handled by a limited version of ffmpeg that may not recognize your file correctly.

Otherwise check your output settings, there might be something odd about those codec settings too?


How can I get something to crumble instead of explode while using the cell Fracture addon?

Ensure collision margins of the rigid bodies are set to zero, and the physics iterations are high enough to handle whatever simulation you run... also increase the physics time step to a higher value.... it's also sometimes useful to check the "start disabled" checkbox in the rigid bodies tab... this should stop the objects moving until a collision occurs


Baking normals from high to low poly mesh for game object

It's not actually required that you unwrap the high poly mesh for this operation to work, only that the two meshes be in the same location when you do the baking. Development of aberrations around corners is a common problem with normal maps. Cycles allows baking now and has a cage function that may help.

Take your low poly model and make a duplicate of it. This is going to be the cage object. Using Atl+S increase the size of the cage object to be slightly larger than the target object. You may have to do a little tweaking to the cage to ensure that it has an even surface around your target object

Switch to Cycles Render and create a new material for the target object.

Create a new image to act as the normal image

In the node editor go to the material for the target object and create an image texture node and load the normal image you just created into the node. The node does not have to be connected to anything it just has to be there.

Go to the Render tab in the properties window, go down to Bake, select Normal in Bake Type, set Space to Tangent, check Selected to Active and Cage, and select the cage object in the object selection window

Select the hi-res source object followed by the lo-res target object and click on the Bake button.

If all goes well you should get a much different result than the one you're getting now.


Why does a UV Map cover the entire model?

Move the vertices you would like to ignore off the UV Map ... to some side.  Use this in combination with Clip.


Render with a wider dynamic range in cycles to produce photorealistic looking images

Update as of June 23, 2019

Plenty has changed since the original posting. I figured it was worth updating this post to highlight two excellent videos provided by two of the celebrities in the community, Gleb Alexandrov and Andrew Price. Both of the videos are top shelf quality, and well worth viewing.

Mr. Price was largely responsible for kicking the monumental interest in camera rendering transforms forward, including exposing plenty of folks to ACES. The Secret Ingredient to Photorealism has now hit over 1.7 million views, attracting viewers from plenty of different domains.

Mr. Alexandrov's video came out slightly thereafter, and has some terrific examples with synthetic imagery, as well as a humorous dive into some of the more nuanced details.

Update as of October 5, 2016

There has been a huge amount of interest in the creative affordances colour management provides an imager. If you want to jump right in and know what you are doing, there is an updated filmic set of tools available in a new filmic Blender set. The new set offers:

Very easy view based selection of five basic contrasts. Added to support new imagers that are interested in trying the package out, but worry about grading. The new set should be turn-key for this audience.
Much improved contrast curves selection. In addition to a simplified naming convention, the basic transfer curves are much more refined, perfectly pegging your scene referred middle grey values of 0.18 to 0.50 in every single transform.
Much improved desaturation and crosstalk film emulation. This new transform is complex and offers imagers an extremely graceful roll-off to display referred white. In addition to this, there has been a crosstalk element added which carefully mixes the primaries as the values reach peak. This will result in images that are much closer to what one would expect from typical photographic mediums.

It would be excellent if the talented imagers out there would try this new set and render out some sample images for this posting.

Issues

Post your issues to the GitHub repository.

Original Update

If you are seeking the original OpenColorIO set, you can find it at the original link.

After a recent presentation I did on the subject, there is a Google Slides presentation on dynamic range and intensity. For those interested in this subject, or perhaps for a greater understanding, feel free to watch the presentation located in this link.

Sample Images

Here are some sample images generated from the OCIO configuration. You should notice immediately how all of the physical based light interactions are augmented such as subsurface scattering, indirect lighting etc. Also note how the configuration allows for proper photo-based highlights captured in the display referred transform. Sample files compliments of Eugenio Pignataro, Mike Pan, Henri Hebeisen, Tynaud, and Mareck, Dmitry Ryabov, Rachel Frick, Marius Kreiser, and Andrew Price. Click to enlarge.

Mareck:

Click to Enlarge

Dmitry Ryabov:

Click to Enlarge

Rachel Frick

Click to Enlarge

Marius Kreiser

Click to Enlarge

Andrew Price

Click to Enlarge

Eugenio Pignataro:

Click to Enlarge

Mike Pan:

Click to Enlarge

Henri Hebeisen

Click to Enlarge

Tynaud

Simple Example of the Filmic Desaturation / Crosstalk 3D LUT

Two simple images that demonstrate the critical differences of high intensity values and how purely saturated colours fail to behave photographically. Note how the average greyscale values desaturate and bloom to display referred white as expected, while the purely saturated colours break. Compare against the transformed version which blooms as one would expect as values increase:

Click to enlarge

The Question

  To get images that seem more photorealistic, not only a much wider
  Dynamic Range is needed, but also having the color information
  desaturate towards white as it would happen in an overexposed
  photograph.

The key word here is photorealistic. While many imagers focus on modeling, texturing, and other critical nuances, this is an often overlooked term with some profound implications on imaging.

What is Photorealistic?

While an apparently obvious question, breaking it down into components will help us provide a solution to the initial question. Photorealism has a direct link to the photographic world. This means that to solve the problem at hand, we need to break down what exactly a photograph is and how it has influenced our learned aesthetic response. Once having done so, we can compare how the photographic model relates to a CGI model, and provide bridging tissue to derive a solution.

What is Film?

The advent of film provided a unique aesthetic transformation of a physical scene into a convention. This convention brought with it particular nuances of photographic emulsion, and later digital sensors that sought to imitate the medium. These nuances can be loosely broken down into two categories when evaluating CGI and its relationship to the photographic and photorealistic.

Breaking Down Film, and the Photograph

  The vectorscope reveals another issue as well: The Red, Green and Blue
  colors, also reach a point in saturation at 1 and keep going past what
  is possible to represent correctly.

For our purposes, we will examine the later era of colour photographic reproduction. The first concept we need to address is why, when photographing something of intense light, does the image desaturate? First, the composition of the film itself:

Click to enlarge

Given that the spectral locus, or range of all visible light, is a strangely curved mapping of wavelengths to colour, we can begin to see some of the reasons that images blow out to a white. In the above example, we see that there are three primary layers that are sensitive to loose regions of the spectral wavelength, crystallizing and "recording" the wavelengths. Here are some simple spectral responses based on the layers:

Click to enlarge

What we learn immediately is that film is not a narrow band recording medium. That is, if we think of the primaries, or colours for each RGB such as sRGB, the primaries are extremely narrow band, representing a unique and singular colour of light for each channel.

What are the Implications of Non-Narrow Band Recording?

Both film and DSLRs use the filtering technique to record their data. With regard to colour, we know that the filtering mechanism, due to a variety of complex reasons, are sensitive to a non-narrow range of actual physical wavelengths in the visible spectrum. This means that even though the "green" layer is attempting to only record a specific colour of green, the emulsion / DSLR photosites will also register recorded information because of the wider wavelength gathering.

The net sum is that when a specific "blue" light lands on a photograph, it is also crosstalking with the other layers or photosites, creating an extremely unique mixture of values. Part of this is colour response, and forms another discussion. The critical part we need to grasp regarding the desaturation of film / DSLRs, is that there is no single, physically plausible colour of light that will solely trigger an isolated emulsion layer or photosite. As a result, the stock or sensor will bloom out to white given enough exposure time. This is very much unlike the default sRGB transfer curve applied to Blender's default view.

The Intensity of Light in Relation to a Photograph

Photography has unique colour characteristics above which result in an image "blowing out to white" as well as many more subtle crosstalk features that yield the unique looks of film and DSLRs. At least as important as this facet is the dynamic range of the medium itself.

Film had an extremely unique feature that even DSLRs struggle to match today: a logarithmic encoding scheme. That is, as the particles of silver were exposed to light and crystallised, the response became harder and harder to influence the negative; once a granule was exposed, it became physically harder to expose the grains behind or around it. This meant that film was able to respond to light in a logarithmic form, and in doing so, record a tremendous range of intensity of light.

Film and a Camera

When we dial in a camera to record a scene, we set an aperture, shutter speed, and typically select an ISO sensitivity. These three facets restrict the scene's intensity values that the logarithmic film records.

To understand this better, we need to consider two CGI terms that break our computerized models down into a more granular format: Scene Referred and Display Referred (aka Output Referred, Device Referred, etc.)

Scene Referred Capture of a Photograph to a Display

If we consider that the scene, or scene referred data in our photographic examples above, cover a vast range of intensities, we can see a transformation happen at the camera / emulsion level. This is a mapping of the scene referred linear light values to the logarithmic encoding structure of film. The following image shows an arbitrary twelve and a bit stop mapping of scene referred values to the display referred / device referred encoding of film or DSLRs, as viewed on an sRGB device:

Click to enlarge

What is Happening in Blender from Cycles?

In Blender, and particular using a raytracing engine such as Cycles, we are generating scene referred values in the internal model, and passing those values via a display referred transform to output. The default "sRGB" display referred viewing transform appears to be a blind and ignorant hard cut. While some might call this "clipping", it would be more accurate to consider this a transform from the scene referred domain to the display referred, and the value of 1.0, while happens to match the same value of 1.0 in the display referred domain. The values, despite being identical, represent different things.

The "Default" transform is a strict inversion of the sRGB transfer curve that was developed as part of the sRGB specification. Here is roughly what it looks like from a layperson's vantage:

Click to enlarge

This transform is particularly confusing for a number of reasons:

It grossly ignores much of the scene referred data present in Cycles.
It uncharacteristically models the range of intensity of light to the display referred output image.
Imagers unaware of the transformation of scene referred to display referred values conflate the concept as existing on a single continuum, forcing unfortunate mangling of their rendered scenes to fit in under this completely arbitrary and extremely important transformation.

Almost At the Solution

Before we "solve" the above to issues of desaturation and latitude, it is worth revisiting how a clear division between scene referred data and display referred data can greatly elevate an imager's ability to craft work.

How is Scene Referred Data Different?

  1 is white and, of course, there is nothing whiter than than white

Scene referred data has no notion of white nor black. Those concepts do not exist until the display referred transformation. "Whiter than white" is an anachronistic term that typically referred to safe video encodes.
Scene referred data, much like a true scene in reality, can represent a colossal and infinitely large range of data. Imagine a planet with one sun? Now imagine one with two suns? Three? The only limit on scene referred data is the bit depth of the actual architecture, and even then, it is constantly evolving.
Scene referred data is rendered from architecture such as Cycles that seeks to model a version of reality. If an imager is unaware of the transformation from scene referred to the display referred domain, they may end up artificially mangling their lighting, data, textures, etc. to fit in under an arbitrary view transform.
Scene referred data is stored linearly, or more specifically, a visual radiometrically linear fashion. That means the ratios of light emulate a physical model of light, and respond accordingly.
Very few formats store scene referred data effectively. EXR is the most robust format for such storage.

How is Display Referred Data Different?

Display referred data has a minimum and maximum creative point, typically zero and one respectively.
Display referred data is most typically stored nonlinearly, with the arbitrary middle grey point mapped to a particular middling value in the display referred encoding.
Only at the display referred transform do values end up mapped from a given high and low point to white and black respectively. Speaking in terms of white or black prior to this transform is utterly meaningless. Only terms like achromatic, or without colour, apply.
The display referred transformation is handled via OpenColourIO in Blender. This transformation is arbitrary and a creative tool for imagers.
Display referred encodings will almost always be discarding information when stored on disk, and as such imagers should be well aware of formats used to store their data. This extends to alpha storage concerns, as some formats such as PNG mangle alpha.

The Long Path to the Solution

In summary, we are faced with two unique problems posed in the original question by @cegaton.

Latitude or dynamic range of the encoded image.
Unique colour characteristics such as desaturation to emulate the photographic.

We know that OpenColorIO controls the transformation from the scene referred domain to the display referred domain, and as such, the solution will revolve around our manipulation of the configuration for OpenColourIO.

What Might a Solution Look Like?

Dealing with Latitude / Dynamic Range

With regard to how to capture the latitude range, we need to consider what a more optimal solution would be than the default sRGB display referred transform. We could suggest it might look something like the following:

Click to enlarge

The above image maps approximately six and a half stops above middle grey to our display referred notion of white. It also maps a scene referred value of 0.2 (again, in scene linear) to our middle grey value. This keeps roughly to the values that many display referred images would have their middle grey values mapped to when converted to display linear. The above ignores a more complex display referred black range mapping, and simply maps zero to zero.

This can be accomplished via a 1D display referred viewing transform in OpenColourIO. An imager can use a spreadsheet or other tools to generate such a LUT. More information on this can be provided if someone chooses to ask the question.

Dealing with Desaturation or Crosstalk

Dealing with the desaturation or crosstalk issue is much more subtly complicated. In the case of a desaturation, we expect that as say, the blue primary pushes up toward the display referred maximum, that the other channels move up as well. This is impossible to achieve using any amount of curves.

It should be noted that no matter how hard one tries with the default sRGB display referred viewing transform, that colours will always be mangled as they near the ceiling of the viewing transform. Why is this? This is because the 1D LUT simply hard cuts the scene referred data within the transform. This yields colours that, while it is possible to force them to clip to white, do so in a manner that is entirely unlike any sort of desaturation known in a photographic medium.

The technique to achieve this is typically via a 3D LUT. A 3D LUT differs from a 1D LUT only in the sense of the input and output influence. While a 1D LUT takes an input value and converts it to an output value, a 3D LUT is able to take a single input value and adjust, in addition to the input value, also the other channels. This provides us the magic tool to simulate not only desaturation but also the complexities of filmic crosstalk.

3D LUTs have a unique problem however, in that the input range must be very well defined as their size and resolution grows exponentially. To accomplish a suitable 3D LUT, it is prudent to convert scene referred linearized data to a display referred perceptual domain. This allows the 3D LUT to be applied in a perceptually uniform manner to the data, increasing the quality of the transform.

One Possible Solution

While the above hopefully highlights how much creative control an imager has, it hopefully also sheds light on how not to deal with the complexities of image based lighting or high dynamic range lighting. Instead of mangling and crunching scene values to fit the display referred transform, it is much more prudent for an imager to create a clear division between the scene referred data and the display referred encoding. Doing so will not only elevate the imager's work, but also her creative control when grading at a later step.

While the actual generation of 1D and 3D LUTs, as well as the OpenColourIO configuration details, is beyond the scope of the original question, the following is left here for any imager to experiment and light with. It is a fully compatible OpenColourIO configuration for use immediately.

What it does:

The "-10-+6.5" represents a viewing transform that grabs approximately 6.5 stops over middle grey and maps it to the display referred encode.
In the Looks you will find a number of different looks. While well documented in the README, the "Basic" adds onto the above transform a desaturation / convergence toward display referred white. This is the exact shaper transformation, further transformed into a 3D LUT that deals with the desaturation component explained above. The LUT was generated using the idea that the luminance of the primaries would be roughly a decent entry point for emulating the desaturation of the layers / photosites. As such, it uses the sRGB / 709 primaries weights to more accurately desaturate as the intensity values near the display referred maximum point, at approximately two and a half stops below the maximum scene referred value of 16.291, or roughly 3.0 scene referred linear.

Other useful Looks:

A False Color look that offers a visually shifted "heatmap" of exposure useful for lighting.
Several Sharp variants which interpret the data under a power curve that increases contrast. Useful as a rough approximation of a grade.
A Scaled set that maps middle grey from the view's .6 to sRGB's 0.466. This can be considered training wheels for those not used to grading footage.
A Greyscale Look on both the desaturated and standard views for evaluating contrast. It uses 709 primaries as weights.

Updated LUTs are located at this GitHub link. Please read the README to spot specific issues with some of Blender's yet-to-be-addressed shortcomings when operating on scene referred imagery. Sadly, many of the problems present in Blender are simply because very few imagers realize the extent to which the default view impacts their view of the scene referred data. In this regard, it makes the scene referred data appears as though it were display referred simply because imagers rarely are aware of the data in their scene.

The more imagers that give the LUT pack a spin, the more likely they are going to help Blender evolve as a tool. That is of course, in addition to almost magically transforming their imagery.

To use it, an imager merely needs to:

Backup / copy / move their [BLENDER DIR]/bin/[VERSION NUMBER]/datafiles/colormangement directory to a different directory.
Link or copy the files into a fresh colormangement directory in the datafiles directory.
Change between the rendered views using the Scene's Colormanagement Properties panel.

References and Further Reading / Viewing:

Alex Fry interview article discussing scene linear and wide dynamic range imaging in ACES.
ACES in VFx presentation video by Alex Fry, covering some fascinating issues regarding wide dynamic range rendering in The Lego Movie and other projects.
The OpenEXR file format standard and specification, covering wide dynamic range imaging and other details.
Jeremy Selan's excellent site on Cinematic Color, including the Visual Effects Society handbook on colour in motion pictures and animations.
An exploration into how film stocks and emulsion layers work.
An excellent PDF presentation from GDC 2016 on the subject of wide dynamic range mapping in games.


Strange render, though in object mode I can see the object just fine

Your scene is enclosed inside a giant cube that is disabled for the viewport ( and enabled for render (camera icon).

What you see is the inside of that cube that has a very dense value for volume scatter. To view the animal like object in your scene you can disable the renderability(camera icon) of the cube  on the outliner or bring down the volume scatter to a more reasonable level.


How to fix "bone heat weighting: failed to find solution for one or more bones"

If you want the frosting move according to the main body I would recommend the DataTransfer modifier as solution.

Therefore you should parent the frosting to the same armature as the Gingerbread man. But you don't have to make weights just the empty vertex groups.

My example scene looks like this

So, for Bone deformation we need the Vertexgroup information projected from the Base(your gngerbread man) to the Addon(your frosting).

The modifier has to be on the Addon and it should look like this.

depending to the Size of your object you may change the ray radius

After getting the weight information from the base object you should be able to join the two meshes together(but you don't have to). The frosting should have reasonable weighting.

EDIT:

After projecting the vertexgroups you have to apply the DataTransfer modifier, because it will automatically recalculate it when you change your pose.

Edit2:

Parent just one object at the same time to the armature.


The one you need is the Transformation constraint. It allows you to map values from one transformation type (location, rotation or scale) of a bone to a transformation type of the target bone. This mapping can also switch X/Y/Z channels around and set appropriate limits and ranges.
If your case you would want to map the vertical location of the pan bone (in local space probably) to the rotation of your indication bone around the appropriate axis (probably also in local space).


What are the Hotkeys to adjust Grease Pencil Brush Radius?

As for version 2.8 radius can be changed by using the keyboard shortcut F


Make an extruded circle along a path into a solid object

You can join two meshes by using Ctrl+J, however make sure they are both a mesh before attempting this. As Reactive said, you can convert a curve into a mesh using Alt+C > Mesh from Curve/Meta/Surf/Text. If it is using a modifier, simply press the Apply button before joining the meshes.


Using difference modifier on two objects doesn't always work

This one helped me reduce the problem so that I could manually finish the last.
Thanks for the help. :)

Removing doubles and fixing the normals. More instructions at the link.


He is definitely doing it right in the tutorial so the problem lies somewhere in the part you have not revealed any information about - in something that you did differently. The thing to do here would be to redo it all again until it works carefully tracking and keeping all your actions in mind. This is how tutorials should usually be approached.
I guess, you may have double geometry and when you select the vertices, some overlapping vertices remain unselected. You could try to redo the whole part from start or select all and merge vertices by distance first.


Move vertices same distance as a shape keyed vertex / add vertices to shape key

I can make 3 examples of 3 different ways of doing this (and there can be many more).

1 - Vertex parent: select 3 vertices of the eyelid, then in object mode select the eyelash; shift select the eyelid and press Ctrl P (choose vertex triangle), so that eyelashes will follow any movement of the 3 choosen vertices.

2 - Drivers: set a shape key for the eyelash also and set a driver so that it will act together with the eyelid shapekey.

3 - Join the two objects: select the eyelash FISRT, then shift select the eyelid, press ctrl J, then select the shapekey and in edit mode put the eyelash in the correct position.


Blender no longer opens my blend file, it loads the Export FBX screen and is stuck there

Open the file without the Load UI option ticked

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

If not, open a new Blender instance and append your scenes from the previous file.

Otherwise post your file here so we can look at it.


Why does Ray sensor in Blender Game Engine cause actuator to activate superfluously?

1.
Your Ray sensor should be set to Tap to prevent any extra pulses.
2.
Your Ray sensor's option Invert is turned on, I don't think this option needs to be on, unless there's some other logic that I'm not getting and the option is internationally turned on.


How can I move an edge a precise distance from another edge?

Use the snap to edge tool while in edit mode found on the bottom toolbar of the Viewport. Snap the selected edge to the second one and then use the keys G + y + -0.30083 to move it left by the appropriate amount.


Edit Mode - XRay Clutter - Edges/Faces/Verts

Probably you just toggled the actual X-Ray mode

and changed its alpha value.


You could add a fourth dimension to your Noise and Voronoi texture and control the W dimension with #frame driver. Just write #frame to the value field.

The frame driver is probably too fast so you could divide it by 100.


Update parent and pivot of multiple children

Possibly, when parenting, what you're looking for is CtrlP > Object (Without Inverse), or, after parenting , with the children selected, Object menu > Clear > Origin. It is odd, IMO, that the Object menu > Parent item doesn't offer the first of these options.

The manual advertises (as in 2.79) the keyboard shortcuts CtrlShiftP for parenting this way, and AltO for clearing the origin. However, in my build, these shortcuts seem to have been removed. Having checked for conflicts, I've put them back without appearing to do any harm.


texture mapping menu missing in blender render 2.75

This is because Use Nodes is enabled on the material using the texture:

Once this option is disabled, the Mapping panel is available in the texture options.


Just borrow bits from your existing geometry. (If you model a lot, you learn to be lazy)

CtrlR cut a loop round the middle of your spool, if there isn't one there already
ShiftD duplicate it and P separate the selection into a new object
In Edit Mode, S scale it out about its median point a bit, Xdelete its bottom 2 edges
E Zextrude the new end vertices down in Z
.. and Header > Object Menu > convert to a curve.

You can bevel the curve in its Data tab > Geometry panel, and keep the bevel resolution down for a low-poly rope, or in the Header menu again, Edit Mode, all selected,Curve > Set Spline type to Bezier, and V set the control points to automatic to get a smooth rope... all sorts.


Try Ctrl+Tab  .

When the menu appears choose the appropriate letter:

V Vertex select

E Edge select

F Face select

Alternatively you can use numbers: 1, 2, and 3

The tooltip shows the Python in case you decide to assign a single keystroke.


Blender VSE - speed control and cross effect at the same time

You need to put the cross on the speed control strip, not the original strip. You see only the cross at the moment because it is the top most.

Here is the step by step process:

Add the speed strip  (in your case to the rejs_anima... image strip)
Select the newly added speed strip (not the original image strip) and the second video strip (MVI_... in your case) then
Add the cross strip


It acts like this because it tries to create a face between your 4 vertices. To do what you want to do you will have to create a transverse edge like that:


You can add a sharp 'crease' to a model by using the edge split modifier. I see in your screenshot that you already have the modifier applied.

The edge split modifier will treat sharp edges as qualified to split, regardless of the Edge Angle specified in the modifier. Edge Crease forces a pinching effect to be applied to the geometry generated from the subsurf modifier. By combining these two, you can get a sharp edge while maintaining the smoothing effect of the subsurf modifier.

In edit mode, select the edges you wish to effect and press 'Ctrl+E' to open the Edges menu. Select 'Mark Sharp'.This will split the edges to create sharp edges in the shading.

Afterwards, select those same edges and the edges connecting the corners of your grooves. Use 'Ctrl+E' again to open the Edges menu and use the 'Edge Crease' option to pinch the geometry into a sharp profile, effectively ignoring the rounded edges from the subsurf modifier.

Here is a sphere showcasing the different effects. Left is normal geometry, middle is 'Mark Sharp' Applied, and right is 'Mark Sharp' and 'Edge Crease' applied.


How to make the mirror and actual mesh switch places

You can mirror a mesh or a part of it with the interactive mirror

set the pivot point to 3D cursor and place it correctly.
select the geometry you want to mirror
press CtrlM and one of the axis (x,y,z )
then press enter to commit


What image format encodes the fastest, or at least faster? PNG is too slow

TL;DR If you want to work in a scene referred workflow you should use OpenEXR. It's also the quickest to save, especially for large renders. I'd recommend to use it with the PIZ lossless codec when rendering in Cycles, since it can compress images with (subtle) noise particularly well.

Let me begin by saying not all image formats are equal, so comparing just the time required for encoding wouldn't necessarily give you a reasonable choice. There are four parameters that are usually of interest when it comes to choosing the right image format for the task:

Bit Depth
Compression
Alpha (Straight vs. Premultiplied)
Encoding Performance

The bit depth is relevant because it determines how much information the image can actually hold, which directly influences the dynamic range your image can have. OpenEXR and Radiance HDR can store 32-bit per pixel in each channel, whereas JPEG has only 8-bit. Naturally if you render the frames you don't want to discard a majority of the information, therefore a higher bit depth is desirable. However storing the raw bits would result in very large file sizes, which is why compression is also relevant.
Compression can be lossless or lossy. The former allows to reconstruct the original values as is. Lossy compression leverages that the human perception doesn't notice slight quality degradation. It can therefore reach higher compression ratios. Whether lossless or lossy compression is faster to store isn't possible to say in general. Using a lossy compression likely results in fewer bytes that have to be written, but the compression algorithm may have a higher computational complexity. This is why the speed of saving the image is also depending on the size of it. PNG, as you noticed, is notoriously slow and has a poor compression ratio. An image format with lossless compression, a high (enough) compression ratio and fast encoding would therefore be preferable. A lossy compression may also be useful if disk space is of the essence and quality loss isn't a concern.
Another area where image formats differ is the alpha. Some image formats don't support it at all and those that do use either unassociated alpha (also called straight alpha) or associated alpha (also called premultiplied alpha). JPEG for instance doesn't have an alpha channel, PNG uses unassociated alpha, OpenEXR associated alpha. While unassociated alpha allows to store occlusion ("transparency") it cannot model pixels that are simultaneously emissive and semi-transparent which associated alpha can. This is why the latter is suitable for VFX/Compositing and the others are not. For more information see the following answer by Troy Sobotka.
The only image format which is a good solution to all four aspects is OpenEXR. It supports 32-bit depth, good compression (lossless and lossy codecs), associated alpha and good encoding performance. In Blender it also allows you store all your render passes, which is very useful for compositing and a scene referred workflow.

While OpenEXR may be the best choice for the job, is it also one of the fastest solution?
I've written a script which measures the time it takes to store an image in all the image formats Blender offers. Unfortunately Blender's Python API doesn't offer a way to hook into the encoding step, which is why the measurements are for the time required to save the image to disk. Since I/O isn't constant time due to scheduling, the controller, read/write access patterns and usage by other software, the script saves the image(s) multiple times for an average save time as well as the standard deviation to get an impression how strongly the results vary. The following measurements were all made on a Samsung 840 Pro SSD.
Performance comparision with highest quality settings
For the first experiment an HDRI in four resolution is loaded into Blender and saved saved using every image format available. For each format the settings have been set to maximize output quality. The error bar represents the standard deviation.
Remark 2020-06-22: The results may not be representative for every input. Additionally the image formats supporting lossless codecs have the maximum compression ratio set. This increases their encoding time compared to the lossy formats.
All image formats

All image formats except for PNG

The measurement confirms your impression that PNG's performance is pretty terrible at maximum compression. OpenEXR is the fastest out of all the options for the data set it was tested on. Since OpenEXR has also the most desirable properties of all the image formats, it is the best choice. The test use only one codec for OpenEXR though, which is PIZ. Further measurements that compare the available codecs of OpenEXR will give a full picture of the performance.
(Update 2020-06-22) Performance comparision with default compression ratio
Mechalynx criticized the choice of the compression ratio for PNG in the original measurement. Hence, I've repeated the evaluation on the same data, but every image format uses Blender's default compression ratio and quality option. The color channel for the output is set to RGB for every format and the bit depth to the maximum. Note that the maximum supported bit depth varies between formats.

The default amount of compression for PNG is 15% in Blender, which results in greatly reduced saving time compared to the maximum compression in the previous measurement. However, PNG is still among the formats that saves the slowest, even with the default compression settings, for the particular data used in this test.
OpenEXR comparison of codecs
We have established that OpenEXR is one of the best choices among the file formats Blender offers. Next we can take a closer look at the different codecs and which of the lossless and lossy codecs are the fastest.

The lossless PIZ codec seems to be significantly faster on the tested data than the other codecs. It also creates the smallest file size for this particular file at 16500 x 8250 among the lossless codecs with 453.8 MB. DWAA seems to be the fastest among the lossy codecs and it had the smallest file size with 107.2 MB for the 16500 x 8250 image. The last measurement contained a significant outlier for the PXR24 codec which skewed the results.

The script
In case you want to run tests on your own hardware, you can find the script here.
Example for testing on HDRIs
# HDRI can be downloaded from https://hdrihaven.com/hdri/?c=indoor&h=machine_shop_01
filepaths = [
    "K:\\Bugs_and_Features\\StackExchange\\2019_08_12_performance_encoding\\hdris\\machine_shop_01_1k.hdr",
    "K:\\Bugs_and_Features\\StackExchange\\2019_08_12_performance_encoding\\hdris\\machine_shop_01_2k.hdr",
    "K:\\Bugs_and_Features\\StackExchange\\2019_08_12_performance_encoding\\hdris\\machine_shop_01_4k.hdr",
    "K:\\Bugs_and_Features\\StackExchange\\2019_08_12_performance_encoding\\hdris\\machine_shop_01_8k.hdr",
    "K:\\Bugs_and_Features\\StackExchange\\2019_08_12_performance_encoding\\hdris\\machine_shop_01_16k.hdr"]
file_settings = [BMP(),
                 IRIS(),
                 PNG(),
                 JPEG(),
                 JPEG2000(),
                 TARGA(),
                 TARGARaw(),
                 Cineon(),
                 DPX(),
                 OpenEXRMultilayer(),
                 OpenEXR(),
                 RadianceHDR(),
                 TIFF()]
result_directory = "K:\\Bugs_and_Features\\StackExchange\\2019_08_12_performance_encoding"
benchmark = BenchmarkImage(filepaths, file_settings, result_directory, measurements_per_file=3)
benchmark.run()

Example for testing OpenEXR codecs
# HDRI can be downloaded from https://hdrihaven.com/hdri/?c=indoor&h=machine_shop_01
filepaths = ["K:\\Bugs_and_Features\\StackExchange\\2019_08_12_performance_encoding\\hdris\\machine_shop_01_1k.hdr",
             "K:\\Bugs_and_Features\\StackExchange\\2019_08_12_performance_encoding\\hdris\\machine_shop_01_2k.hdr",
             "K:\\Bugs_and_Features\\StackExchange\\2019_08_12_performance_encoding\\hdris\\machine_shop_01_4k.hdr",
             "K:\\Bugs_and_Features\\StackExchange\\2019_08_12_performance_encoding\\hdris\\machine_shop_01_8k.hdr",
             "K:\\Bugs_and_Features\\StackExchange\\2019_08_12_performance_encoding\\hdris\\machine_shop_01_16k.hdr"]
file_settings = [OpenEXR(exr_codec="DWAA"),
                 OpenEXR(exr_codec="ZIPS"),
                 OpenEXR(exr_codec="RLE"),
                 OpenEXR(exr_codec="PIZ"),
                 OpenEXR(exr_codec="ZIP"),
                 OpenEXR(exr_codec="PXR24"),
                 OpenEXR(exr_codec="NONE")]
result_directory = "K:\\Bugs_and_Features\\StackExchange\\2019_08_12_performance_encoding"
benchmark = BenchmarkImage(filepaths, file_settings, result_directory, measurements_per_file=3)
benchmark.run()

Example for rendering and measuring the current scene
file_settings = [BMP(),
                 IRIS(),
                 PNG(),
                 JPEG(),
                 JPEG2000(),
                 TARGA(),
                 TARGARaw(),
                 Cineon(),
                 DPX(),
                 OpenEXRMultilayer(),
                 OpenEXR(),
                 RadianceHDR(),
                 TIFF()]
result_directory = "K:\\Bugs_and_Features\\StackExchange\\2019_08_12_performance_encoding"
benchmark = BenchmarkProject(file_settings, result_directory, measurements_per_file=3)
benchmark.run()

For the charts you need matplotlib in Blender. I would recommend to create a venv using the same Python version as Blender uses, install matplotlib in the venv, then create a directory with subdirectories modules, addons, presets and startup. Copy the modules from the venv into the modules directory. Now add the parent directory to Blender's Scripts file path in Edit > Preferences > File Paths and you should be able to import matplotlib.

Update: File size comparison
As suggested by Troy, we can also show that OpenEXR produces significantly smaller file sizes than PNG.

The chart compares the file size of images saved as 16-bit PNG with maximum compression and 16-bit OpenEXR with DWAA (lossy) and PIZ (lossless) codecs.
The file sizes are:
1024x512  :   3.02 MB (PNG),   0.82 MB (OpenEXR - DWAA),   1.70 MB (OpenEXR - PIZ)
2048x1024 :  11.80 MB (PNG),   2.87 MB (OpenEXR - DWAA),   6.52 MB (OpenEXR - PIZ)
4096x2048 :  46.03 MB (PNG),   9.74 MB (OpenEXR - DWAA),  25.23 MB (OpenEXR - PIZ)
8192x4096 : 176.68 MB (PNG),  32.71 MB (OpenEXR - DWAA),  96.13 MB (OpenEXR - PIZ)
16500x8250: 657.86 MB (PNG), 107.19 MB (OpenEXR - DWAA), 352.64 MB (OpenEXR - PIZ)

Evidently OpenEXR also beats PNG in file size, with DWAA creating files that are approximately 72-83% and PIZ 43-46% smaller than the PNG on the tested images.
Although the strong increase in file size makes it hard to read precise values from the chart, they should give a general impression of the required storage. The following one shows the file sizes for all file formats in the same configuration as the timing chart. J2K refused to save the largest resolution, which is why there is no value at 16500 x 8250.

(Update 2020-06-22) OpenEXR vs PNG for baked textures
Since there's been a discussion with Mechalynx in the comments about how well suited OpenEXR is for baked textures, such as normal or displacement maps, I've investigated this as well. One claim was that the original benchmark may not be representative for other types of image content. I've modified the script to evaluate the file size and saving time for baked images. It is also available on GitHub. The following test compares the saving time and required file size for a normal map baked from a high resolution mesh.

In the evaluated data OpenEXR consistently beats PNG in encoding speed. Furthermore, OpenEXR produced smaller files at equal bit depth for all codecs (excluding None which doesn't compress). The lossy codec DWAA produces smaller files than PNG even at 32-bit.
The measurements are just a sample and do not prove that this holds for all or a majority of the input data. Further evaluation on a well designed data set would be necessary to draw a generalized conclusion. However, there is a strong indication that OpenEXR provides better encoding speed and smaller file size compared to PNG when an appropriate codec and comparable bit depth are used.


How do I get the armature/bones to fall with gravity?

You can't. Armature are not supported in context with the rigid body sytem.
The behaviour occurs, since the Armature is evaluated after the rigid body simulation. You can't change the order of evaluation (as in Maya e.g.).

Shapekey however, get evaluated before rigid bodies.

Use this hacky script to transfer your animation into shapekeys. (Refine it first, then use it!)
To make this script work, the active object:

has to be selected
has to have an Armature modifier name "Armature"
has to have no Armature modifier name "Armature.001"
has to have a "Basis" Shapekey

import bpy

scn = bpy.context.scene

frame_range = [1, 200]
for i in range(frame_range[0], frame_range[1] + 1):
    scn.frame_set(i)
    bpy.ops.object.modifier_copy(modifier="Armature")
    bpy.ops.object.modifier_apply(apply_as='SHAPE', modifier='Armature.001')
    bpy.data.shape_keys["Key"].key_blocks["Armature.001"].name = str(i).zfill(3)

key = bpy.context.selected_objects[0].data.shape_keys.key_blocks

for i in range(frame_range[0], frame_range[1] + 1):
    key[str(i).zfill(3)].value = 0
    key[str(i).zfill(3)].keyframe_insert(data_path="value", frame=(i+1))
    key[str(i).zfill(3)].keyframe_insert(data_path="value", frame=(i-1))
    key[str(i).zfill(3)].value = 1
    key[str(i).zfill(3)].keyframe_insert(data_path="value", frame=i)

Disable the rigid body, by checking its animated property.
Create the Basis Shapekey.
Execute the script.
Hide the Armature modifier.

The animation is now transfered to shapekeys.

Disable the animated property again to simulate.

  If you wish to change the animation, delete all shapekeys and enable the armature modifier again.


Compositing multiple scenes and passes with transparency

You can use the alpha channel of the trees renderlayer as a mix factor between the sky and the trees:

You can combine the Mist pass with the trees however you like, just replace the screen node with whatever nodes you want.


How can I downgrade the number of elements in a mesh so Blender won't freeze so much? + How to erase flying bits in the stl?

you could press h to hide certain elements and then add them back in the final render


Compute Device Selection for a shared Blender Version

Okay. Robert's answer was the key.
Apparently the array in bpy.context.preferences.addons['cycles'].preferences.devices holds all devices that have ever been activated and saved in the blender gui. In order to get the current hardware and to update the devices array, you call:
preferences = bpy.context.preferences.addons['cycles'].preferences
cuda_devices, opencl_devices = preferences.get_devices()

And then you do something like:
gpu_device = None

for device in preferences.devices:
    device.use = False #reset all other devices
    if device.type == "CUDA" and device in cuda_devices:
        gpu_device = device

bpy.context.scene.cycles.device = "GPU"
bpy.context.preferences.addons["cycles"].preferences.compute_device_type = gpu_device.type
gpu_device.use = True

for scene in bpy.data.scenes:
    scene.render.engine = "CYCLES"
    scene.cycles.device = "GPU"


How can a parameter be passed from one operator to another?

I had to add the self keyword to access the variable in the invoked operator (basic python, ouch!)

class AnimOperator(bpy.types.Operator):
    bl_idname = "object.anim_operator"
    bl_label = "Pose Anim Operator"

    text_name = bpy.props.StringProperty(name="anim_text_name")
    @classmethod
    def poll(cls, context):
        return context.active_object is not None

    def execute(self, context):
        print("invoked script name=%s" % self.text_name ) # <<- self.


You could just take a straight curve, right up the middle of your tree, bevel it,  and AltS edit the radius of the curve up its length. Or use half of your profile as a 'Taper' curve for another curve's bevel. (Both handy for bendy trees)
But the easiest move from your profile to its surface of revolution is to take half of it, (with its origin on the axis of rotation,) and give it a Screw modifier:


Python: How to parent an object to a bone without transformation?

You can do this using bpy.ops.object.parent_set() and using the keep_transform parameter. I also allowed to choose which bone of your armature you want it to be the parent by setting parent_bone = 'BoneNameYouWantToBeParent'as shown below:

import bpy

ob= bpy.data.objects['Cube']
arma = bpy.data.objects['Armature']

bpy.ops.object.select_all(action='DESELECT')
arma.select = True
bpy.context.scene.objects.active = arma

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

parent_bone = 'Bone' # choose the bone name which you want to be the parent

arma.data.edit_bones.active = arma.data.edit_bones[parent_bone]

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

bpy.ops.object.select_all(action='DESELECT') #deselect all objects
ob.select = True
arma.select = True
bpy.context.scene.objects.active = arma    #the active object will be the parent of all selected object

bpy.ops.object.parent_set(type='BONE', keep_transform=True)

As shown below I modified your armature to have multiple bones so you can select which bone you want it to be the parent to your Cube. In the below screenshot I used Bone to be the parent:

In the screenshot below I chose Bone.001 to be the parent:

Updated .blend file can be found here:


Well, I just found out that this bug only occurs in the version of Blender that you get from the Manjaro repository. The binary from the official website seems to work fine. So I guess, I'll head over to a Manjaro forum and tell them about this...


BGE: Having trouble with getting my character to turn properly

After much troubleshooting I found that making my character turn 180 degrees was a bad way in turning so is used the edit object actuator, and used the track to object feature.

I hope this helps anyone that gets stuck with the same problem


How do I get two way coupling in FLIP Fluids?

Well flip and manta dont support this.
However maybe you can fake it.
If you use a paint canvas for displacment you can mimic it a bit.
If the water moves wild your out of luck though.
There are some raindrops examples that might work.
Else you need some proffesional solver and an openvdb import
(if it supports that) to render it in Blender.
btw there's a popular youtube channel 2 minute papers has lots of research about this topic, maybe through that you can find software that does it.


You can it like this:

def set_image(obj, image):
    '''Sets the image used as a background. Expects an instance of PIL.Image
    CAUTION: THIS OPERATION IS SLOW'''
    if image is None:
        # Sets the image to all black
        buff = bgl.Buffer(bgl.GL_BYTE, 3)  # Blank, really small image
        width, height = [1, 1]
    else:
        width, height = image.size
        imdata = numpy.asarray(image.convert('RGB')).ravel()  # SLOW
        buff = bgl.Buffer(bgl.GL_BYTE, width*height*3, imdata)

    image_buffer = bge.texture.ImageBuff(1, 1)  # Very small image
    image_buffer.load(buff, width, height)  # Overwritten with PIL one

    if 'TEX' not in obj:
        obj['TEX'] = bge.texture.Texture(obj, 0) # 0 is the texture ID
    tex = obj['TEX']
    tex.source = image_buffer
    tex.refresh(False)


You need to switch to Vertex manipulation mode. Just press Ctrl+Tab and then V.


Loop cut incomplete, skipping faces from a simple shape

Check the Draw All Edges checkbox in the object properties panel.


Possible solutions:

apply all modifiers before exporting
apply rotation location and scale (ctrl+a)
Check your export options in Blender
When importing in UE4, import the skeleton first and then the skeletal mesh


How to get solid shadows cast from obstacles?

this parameter should have been set to 0


Array not looking smooth in render along a path

I think that:

Your curve has way too many vertices, so I guess it cuts your shape in small slices and annihilates the smoothing. You need to simplify it a lot: Convert it to mesh, delete most of the vertices with the Checker Deselect tool and Dissolve Vertices, come back to a curve, now in Edit mode, in the Tools panel, Set Spline Type to Bezier, and Set Handle Type to Automatic then Aligned.
Or simply redo a spirale with less vertices.
In the Properties panel > Data > Shape, give more Resolution to your curve. It has 12 by default but as it is a long curve you must increase the Resolution to 48.
Add some horizontal edge loops to your object so that its arrays can bend along the curve.


How to remove the upper tabs from the UI?(i.e Layout, Modeling, Sculpting etc.)

You could always just right-click on those tabs and delete, with the possibility of deleting all of them except one:
It's possible to rename them by double clicking on the text.
Alternatively, you can take lines 45 through 56 of the space_topbar.py file and comment them out:

Just a side note: The space_topbar.py file can be easily found by right clicking any of the top tabs and clicking "Edit Source", which will populate the file inside the script editor (via the file dropdown)


V 2.91 Shrink Wrap Modifer is Not Allowing Target Selection

If you just want a cube with rounded corners, the easiest way is to add a bevel modifier, increase the segments to something like 3 or 4 and then add a Subdivision surface modifier set to something like level 2:

If you want the whole cube to be round (like ballooning out), use a Subdivision Surface Modifier, followed by a Cast Modifier set to cuboid:

If you want the edges and corners rounded (like dice), inset every face slightly, and then add a Subdivision Surface Modifier:


Raycasting from inner to outer

Code to shoot a ray from each inner object face centre along the normal, to the outer object.  Object.ray_cast(...) the parameters need to be in the local space of the object we are casting on.

Some notes. The code below gives expected result for a cube within a cube, or sphere within a sphere, as the face normal is the same direction (with origin at centre of geom) as face.centre - origin.   For your object, might want to have some test where normal isn't in the direction of closest point on outer.  For example on the slope of bumps. (hope that's not too confusing)

import bpy
context = bpy.context
scene = context.scene
show_hit = True # add empty at hit.

def draw_empty_arrow(loc, dir, draw_size=1):
    R = (-dir).to_track_quat('Z', 'X').to_matrix().to_4x4()
    mt = bpy.data.objects.new("mt", None)
    R.translation = loc + dir
    #mt.show_name = True
    mt.matrix_world = R
    mt.empty_draw_type = 'SINGLE_ARROW'
    mt.empty_draw_size = dir.length
    scene.objects.link(mt)

# check thickness by raycasting from inner object out.
# select inner and outer obj, make inner active
inner_obj = context.active_object
outer_obj = context.selected_objects[1]
omwi = outer_obj.matrix_world.inverted()

imw = inner_obj.matrix_world
omw = outer_obj.matrix_world
mat = omwi * imw
hits = [] # vectors from inner to outer
for face in inner_obj.data.polygons:
    print("face", face.index)
    o = mat * face.center
    n = mat * (face.center + face.normal) - o
    hit, loc, norm, index = outer_obj.ray_cast(o, n)
    if hit:
        print("hit outer on face %d" % index)
        hits.append((o, loc))

# test on cube, cylinder ok.
# print((outer_obj.dimensions.x - inner_obj.dimensions.x) / 2)
if hits:
    avge_thickness = sum((omw * hit - omw * o).length for o, hit in hits) / len(hits)
    print(avge_thickness)
    if show_hit:
        for hit, o in hits:
            draw_empty_arrow(omw * o, omw * hit - omw * o, draw_size=1)

Result of running on sphere within a sphere (the outer sphere is wireframe)  Empties drawn from inner face to outer hit.


Blender Cycles Diffuese Material - Why it stays so light?

Here's a scene with a light that is set at a low intensity:

Here's the same scene with a brighter light:

Here's the same scene with a much brighter light:

Cycles uses lights that try to resemble how light works in the real world:
The brighter the source, the more light that will be reflected by the object, making it brighter.

The "color" of a diffuse object thus depends on the light it reflects.

Other factors that might be affecting your scene:

The brightness of the environment (world)
The Exposure setting in the film section (default is 1 don't change it unless you have a very good reason, and know what you are doing)
The Exposure setting in the Color Management section (read: Which Exposure control to use?)
The settings for color management:

The view transform used. (Read: Render with a wider dynamic range in cycles to produce photorealistic looking images)

Any changes in the settings for gamma or the use of curves.
The use of ambient occulsion (in cycles you don't need it. Read: Ambient occlusion in Principled BSDF and Adding Ambient Occlusion to Material)


Why does the grease Pencil Fill becomes transparent when zoomed out

Not sure if you've figured out a solution for this problem, but if not, this could be worth a shot:

Select Grease Pencil object
Add an "Offset" modifier
Try changing the Location value by either +0.01 or -0.01 across each axis, then render the results to see if it's fixed the issue. Do it one at a time; you're basically testing which axis the grease pencil needs to be "pushed away from the object" & towards the camera on for it to display properly.

I've had a similar issue which only happens the further the object gets away from the camera. Up close is fine, then if I zoom out, I've had to use this offset modifier & change the location value for my Y axis to -0.02 .. then keyframe it back to 0 when moving back in. The further away the object is, Blender seems to get confused by how close the grease pencil is to another GP object or a 3D object, hence using the offset to move it further away.

Hope this helps


How can I translate an object along its local axis using a script?

I found the answer here.

  import bpy
  from mathutils import Vector, Matrix

  ...

  trans_local = Vector((0.0, 32.0, 0.0))
  trans_world = obj.matrix_world.to_3x3() * trans_local
  obj.matrix_world.translation += trans_world


Select mirror: Could it add to the selection

Open up the operator part of the Toolshelf Region or press F6. Then click on the Extend check box.


Try turning off the On Cage option in the modifier. This will allow you to see exactly where the vertices are.
The image below was taken from Blender 2.8 so the icon is at the other end of the row to your image (2.9?) but it works the same.


You have probably started an Extrusion (E) and then "accepted" it without moving the vertices, effectively creating a zero-width rim.

Problems like this are easily fixed by selecting all your vertices and doing W > "Remove Doubles" ("remove double vertices" since Blender 2.8)


Using Global rotation where you want local rotation

Global and local rotation of default bone about z axis.

RZ is rotate around global z axis. eg Default bone of default single bone armature points up. The y axis of a bone is its head to tail. Rotating this bone around global z axis rolls the bone around Y.

Instead to rotate bones around their local axes use

RZZ


Can I make a smear frame from the blender?

If all the animation is done using the grease pencil, it is quite simple. Enter sculpt mode and you can use any of the brushes to smear the drawing at will.


The only way I know of it's importing (appending in blender terms) the entire node-tree :/
File->Append->select the blend file to copy from-> click NodeTree-> click the tree of interest.
Definitively not user friendly considering the more common case to import into your current tree, but you can invoke the subprograms inside the newly imported node-tree and use it in your main tree.
Another way would be to add the code to recreate to the templates dir and repackage-reinstall the addon (or just add them directly in your addon's  installation directory) for example:

    [...]
    sourceObjectNode = self.newNode("an_DataInputNode", x = 0, y = 0, label = "Source Object")
    sourceObjectNode.assignedType = "Object"

    timeInfoNode = self.newNode("an_TimeInfoNode", x = 0, y = -200)
    [...]

See here for the full explanation of how to take advantage of multiple node-tree


I found a solution also based on atexit,
but thread need property daemon=True.
Then python interpreter do not wait he will complete the work and fires atexit-callback


If you're using Cycles:

Select your smoke object, go to Object Properties tab, then Visibility > Ray Visibility and disable Shadows.


Can I specify a portion of the image to render in Cycles?

You can use border render, like explained in the wiki :

  You can render just a portion of the view instead of rendering the entire frame. While in Camera View, enable Border and press CtrlB, then drag a rectangle to define the area you want to render. CtrlAltB is the shortcut to disable the border.
      Note that this disables the Save Buffers option in Performance and Full Sample option in Anti-Aliasing.

  Enabling Crop will crop the rendered image to the Border size, instead of rendering a black region around it.

This answer goes further in explaining this feature.

If needed, you can set the border position with python, for instance :

bpy.data.scenes["Scene"].render.use_border = True      # Tell Blender to use border render
bpy.data.scenes["Scene"].render.border_max_y = 0.75    # Set the border top at 3/4 of the image's height
bpy.data.scenes["Scene"].render.border_min_y = 0.33    # Set the border bottom at 1/3 of the image's height
bpy.data.scenes["Scene"].render.border_min_x = 0.25    # Set the border left at 1/4 of the image's width
bpy.data.scenes["Scene"].render.border_max_x = 1.0     # Set the border right at the image's right border

And then, just hit render !


How to Speed Up Blender 2.80 EEVEE Viewport?

2.8 builds are snapshots of current development and are intended for testing a preview, not actual work. As parts, such as Eeevee, are not complete, there will be performance issues and bugs, and some features that are not yet present.

Given all of this, I would not yet be expecting any speed or performance features. And I wouldn't be worrying too much about their absence yet either.


How to simulate sculpt layers in Blender?

You may be able to use the Sculpt settings in the Multires Motifier in that way. I generally just do all my sculpts on one layer but setting up multiples in this way may do the trick. Hope this helps.


Does Cycles support all (relatively new) CUDA GPUs?

GPU Rendering Page: https://www.blender.org/manual/render/cycles/gpu_rendering.html

Blender supports GPU rendering of CUDA cards with computing power 2.0 and above. (See chart here: https://developer.nvidia.com/cuda-gpus)

So as long as the GPU is on the NVIDIA CUDA chart with a processing power of atleast 2.0, you are good to go. If it not on the chart you are running a gamble whether it will work or not. (Unless of course your friend confirms specfic GPU will work because he has tried it.)

As for what to Specfically look for, I am not exactly the expert but I can say that Blender cannot render a scene IF the size of the scene is larger than the memory of the video card. For example:
A scene that is 2.5 gb will not render on a 2gb video card.
A scene that is 2.5 gb will render on a 3gb video card.

And obviously try to shoot for a higher porcessiung power when buying. Here is a 'blenchmark' sheet for GPUs: http://blenchmark.com/gpu-benchmarks

I personally use the GTX 970.


how to use the color black on an alpha texture?

in the end, i got it to show by turning the blend mode in the materials settings to alpha blend, then i could see the color black as i painting on the model.


How do you manipulate pose bones using python?

I'd avoid using ops to set the mode to Pose Mode.

Access the bones directly through the hierarchy as it is exposed through the api.

import bpy
import random

armature = bpy.context.scene.objects['Armature']

for pose_bone in armature.pose.bones:
    x = pose_bone.location[0] + random.uniform(-0.2, 0.2)
    y = pose_bone.location[1] + random.uniform(-0.2, 0.2)
    z = pose_bone.location[2] + random.uniform(-0.2, 0.2)
    pose_bone.location[0] = x
    pose_bone.location[1] = y
    pose_bone.location[2] = z


Is there an easy way to read an image file to create ingame map data?

I realize you're kinda asking for a scripting answer, but hopefully this will be of use.

First start out with a map (white is wall, black is no wall). This one is 16x16:

That's all it is. A 16x16 png file. Now go into blender, create a plane, TAB into edit mode, and add ringcuts in both directions equal to the size of the map minus one. Since my map is 16x16, I should add 15x15 ringcuts. The shortcut for that would be CTRL + R15. You'll end up with:

Press A to select everything, and then ALT + E to extrude each face individually. If a little window pops up, click on Individual Faces. Press Esc to save the extrude, but keep the new faces in the same place as the old faces.

Keeping the new faces selected, press CTRL + G and click Assign to New Group to assign these extruded faces to their own group. We'll be using this a bit later.

Still with these same faces selected, press CTRL + . to cause each face to scale around it's own center, and then press S and scale all the faces down ever so slightly. Seriously. Just barely.

One last step. You can come back into object mode with Tab, go to the modifiers panel (it looks like this: ) and add a new displacement modifier.

Click New under Texture, then go to the texture panel (), click Open, and browse to your map png.

IMPORTANT: Under Image Sampling, uncheck Interpolation!

Finally, go back to the modifier panel, select the vertex group we created, and set the Midlevel to 0. And viola!

You can change the image map and then refresh it in the texture panel, and it will instantly update the model.

Simply make the mesh invisible in your game, and have the walls sticking up through your floor. I'm sure there's a way to script this, I'm just not very proficient with blender scripting :)


I'll have the same problem with a small 200mb scene. If I use more than, say 200 samples, then the scene will crash. If it actually was a memory problem, then Blender would give you the error: Out of memory. A few things I have uncovered that help me with this is using less samples, denoising, and using smaller size tiles for rendering. (CPU). Using larger tiles for your GPU may also work. Blender will also crash if your CPU is slower than the minimum speed for processing a huge render. One last thing that might help is to use more CPU threads. More threads will use more of the CPU, so that more of the CPU is used for rendering. This may help Blender to not crash. I compared rendering a scene on one thread as opposed to 250, and there was a big difference. The downside to using more threads is that the rest of your computer may run slower. These are just some options for rendering, but I hope at least a few help.


Mesh Repair, "Torn" Mesh with Holes, Shrinkwrap Modifier?

How about trying to retopo it? I see that mostly it is composed from easy shapes like circles, boxes and ovals, that you can easily create manually and everything else you can retopologise turning on and off snap to the surface when needed.


If you are using 2.79: You need to go to File >> USer Preferences >> System >> Custom Weight Paint Range

If you are using 2.80: You need to go to Edit >> Preferences >> Editing >>Weight Paint >> Use custom colors.

Hope that helps
Good Luck


Moving parent in world causes copy locations to act odd

Instead of the crank's motion driving the body back and forth, I elected to keyframe the body's animation and synch that up with the crank's motion...

Here's how...

Position the crank with one of it's ends hinged at the rear wheel's crank-pin.   Set it's Point of Origin at the pin's center.

Use the "Track to" constraint to always look at the front wheel nut.

Rotate the rear wheels 360 degrees over the desired frame range for speed of rotation.

Make sure the two keyframes are set to "Linear" interpolation.
(select keyframes in Dope sheet and press T)

Step the timeline cursor to the 2nd last frame and insert another rotation keyframe.

Delete the last rotation keyframe.  This is to avoid a one-frame pause when at the next frame, we loop back to the first rotation frame again.

Play the animation and check that both keyframes are indeed linear.  If unsure, check the graph editor.  There should be a straight line (no curvature) in the transformation.

Set the view into Ortho Mode and from the side view and at frame 1, position the crank (in the Y axis only) over the front wheel nut as desired.

Add an object or mesh circle and center it at the front wheel nut's center.  Make it a child of the crank.

Duplicate the marker and move it out in the X axis slightly, parent that to the Wheel nut.

These are going to be reference markers with which to keep the front wheel in the same relative horizontal position with respect to the crank.  (i.e. keep both markers aligned in the Z axis by moving the body (boiler) in the Y axis only)

Step to frame 2, Drag the body (boiler) in the Y axis so both markers are aligned in the Z axis again.

Repeat this over the full number of frames you've got so far.  (29 frames?)

Save the project under a different filename.  (One_Rev.Blend?)
This will be a return reference point which you can always come back to.

In the Dope Sheet, duplicate all keyframes for the rear wheel's rotation and Body's animation and slide them to the right, one frame on from the final keyframe.

Check that out, make sure there's no jitter between each revolution.

Repeat the copy procedure, doubling the animation frames each time until you have sufficient.

Check it, make sure the crank isn't slopping around the front wheel nut.  LCD screens may make it appear to be doing this but if you switch off the nut's visibility you will see that it's not.

If a slow down is required at the end, the Body's keyframes will need to be realigned for those slow-down frames.

The model is now ready to follow a path or be moved about manually or keyframed.

Save the project.  This can be used for other projects that wish to use the loco.

-=============-

Repeat Loop-backs for the extended animation would be a desirable alternative to the duplication process but in Vers 2.77a it appears you either have "cyclic" for a dopesheet strip, or you don't.  There's no Bezier + Linear + Bezier again to start off slowly or slowdown at the end that I can see.


Make Efficient Grass For Large Areas In The BGE

I believe you have to rely on intersecting textured planes for this. The grass model with 24 tris is way too much (i am assuming actual strands). Additionally you have to "grow" the grass only in the player visible area, and cull it when it gets really far away and substitute with a similar ground texture (even triple A games do this, like Skyrim). Additionally don't forget to have a fustrum size of your sun lamp that doesnt cover the entire landscape, but moves with the player. Drawing shadows is very expensive.

There are more than a few tutorials on how to create good looking grass patches for all kinds of game engines and the underlying principles stay the same for BGE unless the engine uses their own custom grass system.

Here is a tutorial for 3ds max on how to do grass for UE4: https://www.youtube.com/watch?v=B4j5tzAIflU

Here is one in blender (very similar):
https://www.youtube.com/watch?v=BKxUKzpx--s

And here is a demo of an implementation of a generative approach in BGE: https://www.youtube.com/watch?v=kN6ftu0H4bQ

You might also want to have a look at different BGE forks like Upbge (https://www.youtube.com/watch?v=fx9JfJyCY6I) and Armory Engine (for better performance in transparency mixing and low poly meshes etc)


Make particles follow true (material) displacement

Also make sure you checked "Use Modifier Stack" in particle settings


What are the most common beginner mistakes when learning Blender?

Double Vertices - Most often caused by extruding something, cancelling the move afterwards, and then extruding again. Can be fixed by selecting all by pressing A, then pressing Ctrl + V, and choosing 'Remove Doubles'.
Flipped Normals - This can have many causes. It's visible as odd shading on a model, but is often a bit hard to pick out. Can be fixed by selecting all, then pressing Ctrl + N.
Unapplied Rotation and Scale - If the scale of an object is not 1 or its rotation is not 0 degrees on all axes, a lot of actions can have strange results. Unless there is a specific reason not to apply rotation or scale, can be fixed by pressing Ctrl + A and selecting the appropriate option.
Hidden things - Pressing H makes whatever is selected invisible. Pressing Alt + H unhides things.
Unnessesary Ngons - Faces with more than 4 connected vertices (Ngons) may cause shading issues, and should be minimized. Ctrl + T triangulates the mesh, and can help avoid these problems.


I will answer this, but avoid questions that are opinion based like this on this stack exchange. Take the Tour here.
Of course you can! Drawing is not required at all for blender. You can utilize tools like sculpt and modeling which dont require knowing how to draw. I am absolutely horrible at drawing, and I know how to do these things using blender.


How to merge 4 adjacent, coplanar faces into a single face

There is an operator called Dissolve which does exactly what you want.

Select everything, with A, and then press X (or Delete) and select Limited dissolve. This will do the same thing as above, but will not require you to select the proper vertices manually.


In "bevel modifier" under "Geometry" try changing "Miter Outer" and "Inner" settings. "Patch" or "Arc" usually gives better results. Changing "Inner" settings will blow up your mesh but you can dial it down from "Spread".


Problems updating the context within a loop? C.scene.update()

Maybe use matrix_parent_inverse * location

Not sure what the issue is here.  The three values "np", "xx", and "tr" in test code below correlate.

Using mpw * mpi * ob.location avoids a scene update for each iter.

(of-course if our parent inverse isn't Identity only the "xx" and "tr" values will match)

import bpy
import numpy as np
from mathutils import Matrix
ball = bpy.context.object
mw = ball.matrix_world
mpi = ball.matrix_parent_inverse.copy()
mwp = ball.parent.matrix_world if ball.parent else Matrix()
for ix in np.arange (3, 50, 0.25):
    for iy in np.arange (2, 50, 0.25):
        #mw.translation = mw * Vector((ix, iy, ball.location.z))
        ball.location.xy = (ix, iy)
        print("np", ix, iy)
        xx = mwp * mpi * ball.location
        print("xx", xx.x, xx.y)
        # required or matrices don't update in loop
        bpy.context.scene.update()
        tr = mw.translation
        print("tr", tr.x, tr.y)

Last few results

np 49.75 49.0
xx 49.75 49.0
tr 49.75 49.0
np 49.75 49.25
xx 49.75 49.25
tr 49.75 49.25
np 49.75 49.5
xx 49.75 49.5
tr 49.75 49.5
np 49.75 49.75
xx 49.75 49.75
tr 49.75 49.75


Eevee glass not working at certain angles

There is an option called 'Edge Fading' under 'Screen Space Reflections' settings in Render Settings. Try making it 0. That should most likely do the trick.


How can i obtain a 247 white in blender 2.8?

Read about color transformations here first, then ...

use an emission material and
set the view transform to Raw.

]2


Two UV Maps here, just change the one used for rendering:


Blender 2.8 - render image creates only an outline of the image

If you want to render the scene as it is displayed in the 3D view, you'll have to set the render engine to Workbench. You can do this in render tab in Blender 2.8.

Otherwise when rendering with Cycles or Eevee you need to setup materials and lighting otherwise you won't be seeing much in your render.


How do I save my undo history as well to my blender file?

as you mentioned there is a limitation.
this test shows you how many steps you can undo. In my pc I can undo only 32 steps:
import bpy

for i in range(0,100):
    bpy.ops.mesh.primitive_cube_add(enter_editmode=False, align='WORLD', location=(i, 0, 0))
    bpy.ops.ed.undo_push(message="Add Cube")

for i in range(0,100):
    bpy.ops.ed.undo()

I decompiled undo script
void ED_undo_push(bContext *C, const char *str)
{
  CLOG_INFO(&LOG, 1, "name='%s'", str);
  WM_file_tag_modified();

  wmWindowManager *wm = CTX_wm_manager(C);
  int steps = U.undosteps;

  /* Ensure steps that have been initialized are always pushed,
   * even when undo steps are zero.
   *
   * Note that some modes (paint, sculpt) initialize an undo step before an action runs,
   * then accumulate changes there, or restore data from it in the case of 2D painting.
   *
   * For this reason we need to handle the undo step even when undo steps is set to zero.
   */
  if ((steps <= 0) && wm->undo_stack->step_init != NULL) {
    steps = 1;
  }
  if (steps <= 0) {
    return;
  }

  /* Only apply limit if this is the last undo step. */
  if (wm->undo_stack->step_active && (wm->undo_stack->step_active->next == NULL)) {
    BKE_undosys_stack_limit_steps_and_memory(wm->undo_stack, steps - 1, 0);
  }

  BKE_undosys_step_push(wm->undo_stack, C, str);

  if (U.undomemory != 0) {
    const size_t memory_limit = (size_t)U.undomemory * 1024 * 1024;
    BKE_undosys_stack_limit_steps_and_memory(wm->undo_stack, -1, memory_limit);
  }

  if (CLOG_CHECK(&LOG, 1)) {
    BKE_undosys_print(wm->undo_stack);
  }
}

you can see how limitation calculated:
const size_t memory_limit = (size_t)U.undomemory * 1024 * 1024;

as  @Jachym Michal said in comments increasing this limitation is not recommended
I suggest you use Git.you can easily undo (checkout) by git commands

Git is a distributed version control system for tracking changes in source code during software development.

but if you like the automatic way you can commit after each change:
import subprocess
from subprocess import Popen, PIPE, STDOUT

import re

# undo step
step = 0
# repository path
repoDir = 'C:/Users/Kamali/Desktop/Test'

def gitCommit(message):
    global step
    step += 1
    cmd = 'git add . && git commit -am '+message
    p = subprocess.Popen(cmd, cwd=repoDir)
    p.wait()

def undo():
  global step
  step -= 1
  checkoutTo(step)

# check out to specific step
def checkoutTo(Index):
    cmd = 'git checkout ' + getStepRevision()
    p = subprocess.Popen(cmd, cwd=repoDir)
    p.wait()

# get specific revision from git log history 546bece2c66acb454878500689e3017b92c43d28
def getStepRevision():
    cmd = 'powershell.exe git show HEAD~'+str(step)+' --pretty=oneline --no-patch'
    p = Popen(cmd, shell=True, stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True, cwd=repoDir)
    output = p.stdout.read()
    p.wait()

    revision = re.search('(.*?)\s',output.decode('utf-8')).group(1)
    print(revision)

Update
if you don't know git commands
you can use git extension
after you undo (check out) you have to close and reopen blender to refresh
but these lines of code help you to reload it easy
import bpy

bpy.ops.wm.open_mainfile(filepath=bpy.data.filepath)

Tutorial
run this code and see what happened!!!
import subprocess
from subprocess import Popen, PIPE, STDOUT

import bpy

repoDir = 'C:/Users/Kamali/Desktop/New folder'

for i in range(0,100):
    bpy.ops.mesh.primitive_cube_add(enter_editmode=False, align='WORLD', location=(i, 0, 0))
    bpy.ops.ed.undo_push(message="Add Cube")

def gitCommit(message):
    bpy.ops.wm.save_as_mainfile(filepath=bpy.data.filepath)
    add = 'git add .'
    p = subprocess.Popen(add, cwd=repoDir)
    p.wait()
    commit = 'git commit -m ' + message
    p = subprocess.Popen(commit, cwd=repoDir)
    p.wait()

I could commit 100 steps with code


I don't know how you did the parenting thing, but your problem is fixed if you select the mesh, go to Properties > Relations and change the parent type from object to Armature.

Re-parenting everything all over again, it works fine!


Check if object position and rotation are zero

You can try rounding the values to 2-3 decimal points when comparing with 0 to make sure you're not falling victim to floating point errors:

object = bpy.context.active_object

def nozeros( vec, decimal_points = 2 ):
    ''' Returns True if none of the elements in the provided vector vec
        equate to zero when rounded by the provided number of decimal_points
    '''

    return any( round( v, decimal_points ) for v in vec )

if nozeros(object.location) or nozeros(object.rotation_euler):
    print(object.location)
    print(object.rotation_euler)

If either the location or rotation of the active object is non-zero this will script print the values of both.


Where are the Rigid Body Tools in Blender 2.8

You can access through the horizontal menu bar > Object > Rigid Body. I don't know if there's another way.


Blender 2.8 goes off when I click on material buttons

Same thing Happened to me to, I found switching to Cycles Render is a bit more stable on Intel Hardware drivers and deselecting add-on`s that are not being used.


Smoke Simulation does not appear in Eevee viewport

Just found out through some extra searching that a new change was made in Blender 2.82 that removes the "live" smoke simulation in rendered view. We now have to bake the simulation everytime we want to see something different.

I found another thread about this problem:
Quick Liquid and Smoke doesn't work in viewport


How to add the Procedural Nebula shader to a new blend file

Read the link on your question:

Download the blend file and open it from blender.
The rest of the "instructions" to use it are on the video
To use it in your own project you can copy the assets to this project or you can append the material from the downloaded file to an existing project.


Assigning a new material to a face makes it transparent

I hope this helps others who run across this. This is a known issue when using multiple materials with a number of older GeForce and Quadro graphics cards.

  Blender Known Issue: Drawing error with multi-material object. Faces disappear or showing artifacts with 2 or more material slots applied to same object. When trying to use a second material or more on an object, the faces where it is applied become transparent or in some cases they are distorted as black rectangles that stretch to the origin (this second occurs above all with more complex models than a cube). It happens in Blender 2.81 as well as in Blender 2.82, but in Blender 2.80 there is no such error.

While the bug report lists multiple cards such as the ones below, the list is not exhaustive (my card for instance, GeForce 9800 GTX+, is not listed), the core issue is that the GPU has to be able to run NVIDIA drivers greater than v400. The highest driver that I can install is the GeForce v342.01 driver.

GeForce 210
GeForce 410M
GeForce GT 220
GeForce GTX 275
Quadro FX 3700
Quadro FX 3800
Quadro FX 4800

I can also confirm that as listed in the bug report, Blender 2.80 does work for me.


how do I render my animation and the rest of the scene seperately

You can render the first static frame, save it as image and then plug into Alpha Over node in compositing.

Disable animated river. Uncheck Disable in Renders icon in the Outliner tab:
Render only Statics and save on disk:
Enable the river in Render and disable all statics (same as 1)
Check Fill>Transparent (available for both Eevee and Cycles):
Set up compositing Alpha Over node:
Render the river. Compositing will be executed for each frame of the animation:


Moving a surface from one side of an object to the other

Select the faces for mouth, press Y to split;

Press S > X > -1 to give it a mirrored scale along its X axis. Done. (or CtrlM > X)

P.S.: I'm not so sure about the word "rig" you mentioned here, suppose you are trying to animate it, then I suggest using Blender's ShapeKey feature in this case. Demo file included.


Well, I had play with the Children settings till actually got some reasonable result:

Here is my recipe for a nicer looking braid:

As you can see, mainly Random and Size properties made the strands get thicker, but it can also mess around with the shape at the end. So I suggest trim it with Length.
Use a high value for Clump on Effects Section and a low Clump on Kink Section.
If you get a fading effect like I was having on my question, try to change the Shape value to something like -0.9 on Cycles Hair Settings.

Suggestions are very welcome.


How can I render objects with very shiny surfaces?

What you are missing is proper lighting.

The main idea is that you are not photographing an object, but what is being reflected on it.

Ditch the HDR and start from scratch (Unless you have an HDR that reproduces a photographic studio used to photograph the exact same object from the exact point of view, any other HDR will be largely useless for what you want to do)

You have an object that is reflecting the environment around it.

Start by placing a very large plane with an emitter in the scene and see how is being reflected on the surface. Move it around the scene, and notice how the placement helps you reveal or not the shape and qualities of your object. Add a second emitter or just planes with a white surface. Find the correct placement for them. You need a mostly white environment around your object, but having gaps in between the emitters/reflectors will help you reveal the contours and subtle shapes of the object.

Look for websites on how to photograph shiny objects in the real world, there are a lot of them. The same techniques apply for 3D rendering.

This link might help: http://project52pros.com/2014pros/assignment-thirty-five-photographing-a-very-shiny-object/