This might be a lighting problem. Do you have a colored light in your scene?
If none of your lights contain any Yellow, only the other colors will be reflected by the Material
EDIT:
I figured it out.
The part with the problem has multiple surfaces inside of each other.
I dragged them apart and apparently this part exists 8 times. With the pink material on 6 of the instances.

This sometimes happens unnoticed, when proportional editing is turned on, because it makes you move all the objects at once.
Proportional editing (for those who don't know) is this option:

Turn it off, point at the problematic part, hit L and then drag your selection away and you will see.
;)


Blender export as dae file contains broken 3D render

To me it looks like the face normals are facing different ways. Game engines use backface culling to only draw one side of a polygon.

In edit mode select all A and use ⎈ CtrlN or ⎈ Ctrl⇧ ShiftN to set the normals to the same direction.

You may also want to look at not using backface culling so that both sides of the robe are visible in your game.


In need of help concerning making a knot animation (paths etc.)

You don't have to move the rope, Depending on how you construct the rope you could animate either the Bevel Factor or the Dupliframes end frame, and have the rope 'grow' along the path.  It seems that this is what they've done in the linked video.  Albeit with some rotation to make it appear to be moving.


Is it possible to crease a NURBS vertex?

In your example a bezier curve will make it easier to get 'sharp' points in your curve as the control handles for each point give more control over how the curve enters and leaves each point.

If you do need to use nurbs and also need a 'sharp' point you can place three points close together which reduces the smooth interpolation between points to what visually appears to be a point.

In edit mode if you zoom right in you can see -


Can't import ctypes from Blender's Python

This is a known bug in 2.73 and 2.73a:

https://developer.blender.org/T43961

Blender 2.74, 2.75 and 2.76 should work. adding the missing _ctypes python module (_ctypes.pyd) from these versions to 2.73 should also work.


You have different resolution of mesh in preview and render:

This may not be so important, but not for edited hair. In fact, you have two different mesh. So move Particle system before Subsurf, or make Subdivision setting same for preview and render


When you generated your ribbon, did you make sure that the Merge checkbox on the array modifier was checked?

If it isn't checked, none of the mesh segments will actually, joined. Checking it makes overlapping vertices in the array get merged and so the result will be a single connected mesh.

For more details see https://www.blender.org/manual/modeling/modifiers/generate/array.html


How can i change intensity of AO and bake this effect using blender render

Pointiness node in Cycles

To have a full control over AO appearance you may use a Geometry (Pointiness) node with a ColorRamp to control the emission color and then bake it as a texture to use in Blender Internal. It only works in Cycles though.

In Cycles add a material to the unwrapped object and set up its material nodes as pictured below.

Use the ColorRamp node sliders to set the proportions between black and white emission colors. You may add several sliders there and change its mode for a different results.

To bake it as an AO map add a new texture in the UV Editor and call it e.g. AO Baker. In Node Editor add an Image Texture node and open the previously created AO Baker one there. With the Texture node selected, go to Render header-->Bake panel. Set up the bake type to Emit and press the Bake button.

Cavity Mask in Blender Internal Render (Texture Paint Mode)

To achieve similar functionallity as above in Blender Render you may create the cavity mask. Using the curve you can control how soft or hard the AO looks like.

Go to Texture Paint Mode and add a new diffuse texture slot. Change the brush type to Fill and set it's color to black. In the Options bookmark check the Cavity Mask checkbox. Play with the curve below for different results (example below). Click the 'wrench icon' to change the curve type to Vector e.g. for different results.


Is there a max size for saving openEXR multilayer files?

I don't think there is a limit. In my experience EXR Multilayer Feature works really great in Blender. Make sure that:

you have file permissions to write on your drive,
it is not a compositor issue or
you are not running out of memory.

I once rendered an image which needs to be a 30K EXR Multilayer with all possible passes included, file size was about 12gb. Rendering and Saving as EXR works as expected, but finally the image resolution was to high for the current compositor (2.71) so I can't do the compositing in blender. That's why I suggest you to disable all post processing image operations for the rendering process.

For rendering EXRs with Cycles this answer is also helpful. In this post Brecht even mentioned that rendering EXRs is the only way to write and render the image at the same time. With that in mind it even makes sense to render as EXR for large filesize images.


How to bake normals using modifiers only?

You can bake world normals instead of tangent ones


How Metaballs Works

A metaball object can contain multiple metaballs which you can add in the edit mode of the object, all metaballs in the same object tend to be polygonized together, that is, they combine forming a single mesh. Moreover, if another metaball object that possibly contain multiple metaballs have the same "predot" name (Object, Object.001, Object.002, ... all have the same "predot" name), it will also be polygonized with the metaballs of the original object and thus it becomes part of the output mesh. All metaballs that form a mesh are called a Family.

If a metaball was created outside of the family (by having a different name), it will no longer polyginize with the other families and will only polygonize with members of its family. So you see that naming is crucial in metaballs.

Solution to your problem

All your metaballs have the same name even the ones you duplicated, thus they belong to the same family and they polygonize together forming a single mesh. When you move the duplicated metaballs to a different layer, blender has to decide which layer to put your generated mesh (Because it is a single mesh since it is a single family), so it just put it in the layer where the base metaball is, the base metaball is the object with pure name, that is, a name without numbers (Object in our previous examples.)

So to save a backup version of your metaball, simply change the name of its objects.


Most (all?) of those effects can be easily replicated using the standard Principled Shader and Principled Volume shader, with the surface shader providing the IOR and surface interactions (eg, reflectivity, refraction, etc.) and the volume providing any scattering and absorption (but at a suitably low density).
At small scales the volumetric effects are negligible, making the water appear almost clear, the skewed absoption colours (set it with higher Blue, medium Green and low Red) give the different colors at different depths, the scatter can give volumetric rays and the IOR (again) will give 'Snell's window' effects when viewed from within.
This just needs something like the following (note the low Roughness, high Transmission, low(ish) volume Density, blueish volume absorption). I've also added Displacement for adding distortion to the surface.

You might want to tweak the settings slightly to get realistic behaviour with a specific scale - you should always ensure you model at 'real world' scales to ensure it's more physically accurate. In particular, the absorption and scattering (so the volumetric density) will be sensitive to scale.


How to add a button to outliner header via python script?

The header of the outliner panel can be accessed through bpy.types.OUTLINER_HT_header. It is possible to add additional buttons to the header by appending or prepending a draw function which assigns the relevant operators to the layout. The draw function could look like the following, if your operator class is called EXAMPLE_OT_something.
def draw(self, context):
        self.layout.operator(EXAMPLE_OT_something.bl_idname)

If the operator has been registered the draw function can be appended to the header. This places the button at the end of the header. Using .prepend would place it at the beginning.
bpy.types.OUTLINER_HT_header.append(draw)

Below is an example add-on that demonstrates the concept.
bl_info = {
    "name": "Outliner Header Button",
    "author": "Robert Guetzkow",
    "version": (1, 0, 0),
    "blender": (2, 81, 0),
    "location": "Outliner",
    "description": "Adds an example button to the outliner header.",
    "wiki_url": "",
    "category": "Outliner"}

import bpy

class EXAMPLE_OT_something(bpy.types.Operator):
    bl_idname = "example.something"
    bl_label = "Do something"
    bl_description = "This operator does something"
    bl_options = {"REGISTER"}

    def execute(self, context):
        print("Hello")
        return {"FINISHED"}

def draw(self, context):
    self.layout.operator(EXAMPLE_OT_something.bl_idname)

classes = (EXAMPLE_OT_something,)

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

    bpy.types.OUTLINER_HT_header.append(draw)

def unregister():
    bpy.types.OUTLINER_HT_header.remove(draw)

    for cls in classes:
        bpy.utils.unregister_class(cls)

if __name__ == "__main__":
    register()


Make camera to move with animated object by makewalk

This problem is because armatures do not move objects, they move the vertices within the object. Think of objects like containers for their data. So your camera is behaving properly, because your object is not moving!

What you need is to attach the camera to a bone in the armature, not the object itself. Usually the Root bone is used for this, but it will vary. Look at your armature and pick a bone that is moving with the animation. As you are using mocap data, it may not be moving the root bone. If not, you could use one of the spine, hip, or pelvis bones. The key is to use one that isn't rotating, as that will rotate the camera.

To parent to a bone, select your object, then shift+select the bone and hit ctrl+P. (The armature needs to be in pose mode.) Alternatively, in the Object tab of the Properties Panel there is a Parent drop down menu that can be set to Bone, and then lets you pick the specific bone.

It is also possible to use constraints to attach the camera. This is more setup, but can let you do things like only copy a bone's translation, and not rotation.


Change Anti-Aliasing Settings in Eevee (Blender 2.8)

try experimenting with the parameter Film->Filter Size (0 - anti aliasing)


Blender VSE Audio out-of-sync when animation (video) is rendered

So after a lot of online searching, I did find an answer to fix this problem, but not in Blender. If you are like me and would like to use Blender for video editing and still get around the issue, then I found a workaround, but you need Shotcut for this. Shotcut is another great free and open-source video editor

Export the entire long video from Blender (the rendered video has desync issues as expected).
Open the video in Shotcut and detach the audio from it.
Use the audio properties to make very fine adjustments to the audio playback speed to suit your requirements (make fine adjustments until video and audio are in sync).

Follow the GIF attached.
(I am using a shorter video in the GIF but you get the idea)

Explanation

Blender has issues while rendering long videos and I noticed that the video is exported at 1.0x speed but the audio is sometimes faster (1.00400x or something like that) and hence the rendered video has audio not in sync with the video.
Another bad thing is that Blender does not really allow very fine playback speed adjustment just to the audio.
One trick is to adjust the pitch of the audio in Blender which in turn changes the playback speed but this is only allowed up to 2 decimal places (not what we want for long videos) and it makes the audio sound funny (since it actually changes the pitch).
Shotcut is a great tool that allows fine playback adjustment, and it also has a pitch compensation feature so that your pitch is kind of unaffected (since we don't want the characters to be sounding funny in our edited video).
Shotcut allows playback speed adjustment up to 6 decimal places.

I have also created a short video about this, which can be found here.


Enable Snap during transform option (click the magnet icon) and change the Snap Element type to Vertex. Extrude along the desired axis (in my case I press E,Z) and move the cursor until your extruded element snaps to the other mesh's edge.


What is Blender 2.8 alternative to ctrl+shift+alt+c? (Set Origin in 2.8)

Header menu > Object > Set Origin > Origin To Geometry. And if you right click on this function you can add it in your Quick Favorites. I don't know why they removed the shortcut though.


Your problem is that the "up" axis is set to Z and the "to" axis is set to Z. The constraint can't point Z up and track it to the armature at the same time. If you want to track to the Z axis use a different axis as "up".


Temporaly set an Armature to Rest Position

You don't need to switch pose_position, because tail, head, matrix and so on are not affected by keyframed poses if you access the Armature data (Object.data.bones[#]).

If you access the pose data however (Object.pose.bones[#]), the properties will change based on the current frame.


A modal operator is just an operator that does things a little differently. While there are tons of ways to setup a modal operator, it doesn't have quite the same clearly defined lifetime like regular operators. For example, if you wanted to move an object with a regular operator, the implementation would do something like this the following and would execute in a fraction of a second.

Get how far you want to move it
Move it
Quit, and return what happened (success, cancelled, etc.)

On the other hand, a modal operator that does the same thing has a completely different functionality. It may take a very long time before the user has confirmed the motion and stopped the execution, but Blender shouldn't become unresponsive if it is written correctly.

Start the modal operator
Interact with the user in real-time to update the position
Stop (generally when the user ends the process) at some point and return the results

However, not all modal operators take over all user interaction like you may think. For example, you can have a modal operator that is always running and displays a clock in the 3D viewport. You could have an operator that shows the bounding box and wireframe for selected objects.

Here is an example of a modal operator that does both of the above.

So the real answer to What do the modal operators do? is simply an operator that runs in the background.

The Blender Python docs put it this way:

  This operator defines a Operator.modal function which running,
  handling events until it returns {'FINISHED'} or {'CANCELLED'}.

  Grab, Rotate, Scale and Fly-Mode are examples of modal operators. They
  are especially useful for interactive tools, your operator can have
  its own state where keys toggle options as the operator runs.

Here is a useful post by one of the Blender developers about all of the "operator methods" including modal:

https://blender.stackexchange.com/a/19431/28015


As we can see from https://knowledge.autodesk.com/support/maya/learn-explore/caas/CloudHelp/cloudhelp/2018/ENU/Maya-Scripting/files/GUID-C0F27A50-3DD6-454C-A4D1-9E3C44B3C990-htm.html :

  Maya installs Python with your Maya installation. Maya uses Python
  version 2.7.11 on all supported platforms.

Maya uses an old legacy version of Python while Blender uses Python version 3.5.3. There are syntax differences between these versions and brackets is one of them. I am not sure about indentation in 2.7.11, but in the version that comes with Blender it is 4 spaces.

The sequence in which the selected objects are stored is not something that can be intuitive in my opinion and there is no logical reason one way is better than the other, however if you wish to reverse the order you can do so with Python very easily:

sel = bpy.context.selected_objects[::-1]


Slow preview in the layout/modelling tab

The reason the scene is rendering faster in the Shading Tab is because by default, the 3D  viewport in that tab is less than half the size of the 3D viewport in the Layout tab.
Very simply put - The scene renders faster in the shading tab (in your example) because the viewport is smaller, and therefore there are less pixels to render overall.


CAD file into blender, round shapes not round

If the mesh hasn't been tampered with, I'm guessing this is a situation caused by incorrect smoothing information. A normals related issue.
Make sure when you export, you export the smoothing information correctly. After importing it into blender you have 'shade smooth' set, and then play with auto-smooth angle.


Strategies for performing lots of world coordinate calculations in Blender

You should cache the result of the inner loop.

verts2 = [mat2 * ob2.data.vertices[v2_ind].co for v2_ind in verts2]

and might do this for the outer loop as well

verts1 = [mat1 * ob1.data.vertices[v1_ind].co for v1_ind in verts1]

Generally you might gain performance by keeping python objects rather than doing an attribute / index lookup each time.

Tested with suzanne subdivided 3 times:

import bpy
import timeit
log = bpy.data.texts['log']
log.clear()

stmt_setup = """
import bpy
obj = bpy.context.active_object
vertices = obj.data.vertices
mat_world = obj.matrix_world
indices = range(len(vertices))"""

stmt_vertex_iter = """
verts_world = [mat_world * v.co for v in vertices]"""

stmt_index_lu = """
verts_world = [mat_world * obj.data.vertices[i].co for i in indices]"""

time_lc = timeit.timeit(stmt=stmt_vertex_iter, setup=stmt_setup, number=100)
time_il = timeit.timeit(stmt=stmt_index_lu,    setup=stmt_setup, number=100)

log.write("Vertex Iterator %.4f \n" % time_lc)
log.write("Index Look Up %.4f \n" % time_il)

yields

Vertex Iterator 2.5746
Index Look Up 4.8094


blender 2.8 refresh the graph editor after removing a modifier?

Ok, damn, figured it out. I added one line of code that fixed it.

i.modifiers.update()

So now the function looks like this, and it works:

def main_step():
    obs = bpy.context.selected_objects
    for ob in obs:
        fc = ob.animation_data.action.fcurves
        for i in fc:
            for j in i.modifiers:
                i.modifiers.remove(j)
            i.modifiers.update()


You don’t need to bake.
Try adding a Volume Scatter node to Smoke Domain and connect it to Volume input of the material. Also delete the standart BSDF.


Character Rig: High deformation with bones

Well, you have irregular scale of armature:

Fix by doing this:

Select armature
Select object mode (instead of pose mode)
Press Alt+S

See also: Why is it important to apply transformation to an objects data?


line thickness (using tablet) doesn't work

By default the pressure affects the brush strength only. To make the pressure affect the radius of the brush you have to activate the small toggle switch located just to the right of the radius value.


.obj file imported on 2.82 doesn't consider separated meshes, while blender 2.79 does

If the imported object consists of disconnected mesh parts then you can use Mesh > Separate > By Loose Parts (P > By Loose Parts). In order to move the origin to each separated object use Object > Set Origin > Origin to Geometry.


The bump node creates normal vectors from grayscale textures. You connect it to the shader(s) that you want that normal map to affect. Normally you connect it to every shader, but it depends on the material you want to create. Sometimes each shader requires a different normal map than another shader, so it's up to the artist to decide.
It works by finding the derivatives from every pixel in the texture, to form a transformed vector that is applied to the default normal vector, or a custom vector linked to the normal input.


How does the Turbulence Force Field work?

A force field is a vector field, meaning at every point in space it defines a vector based on some vector-valued function.  In the case of a force field, the vectors represent forces pushing the particles around.   In other words, at each frame the force field exerts a force on every particle dependant on the particle's position.

What differs between the different force fields is the vector function they are based on.  For a turbulence field it uses some noise pattern (Perlin, I think), creating random "turbulent" particle movement.  Most of the settings for the force field (the ones that change when you change the force field type) modify this noise pattern.

TL;DR: The turbulence force field pushes particles around based on their position in a 3D noise.

Here's a rough explanation of the key settings:

Strength controls the amount of force the field exerts on the particles.  Note that this is a multiplier to the strength given by the noise texture so it' actually a maximum value since the noise gives values from 0 to 1.
Size is the scale of the noise texture.  Larger values (compared to the scale of your scene) will make the particles move in bigger masses, while small values will produce more chaotic movement.
Noise is the amount distortion applied to the noise texture.  Higher values will make the particle movement tighter and more erratic.
Falloff - Type (Sphere/Tube/Cone) changes the shape of the falloff zone.
Falloff - Power changes the polynomial power, essentially the steepness, of the falloff.  A value of 0 here means no falloff, meaning all particles are affected by the force field equally no matter their relation to it.
Falloff - Minimum/Maximum changes the start and end point of the falloff curve.  The force field is in full effect for all particles closer than the minimum and does not effect particles beyond the maximum at all.


How do i duplicate to get the same size on all corners of the objects?

Select all of the side faces of a cube (excluding top and bottom) and do Extrude individual

To scale the newly created faces, just press S (to scale) and constraint the scaling to the X and Y axes by pressing Shift Z or checking the X and Y boxes on the tool panel.


You can control the lighting of the mesh via the user preferences. However if some of the faces are dark and others not, it is a telltale sign of a certain flaw in your mesh: normals pointing inwards. You can fix it by selecting all (A), hitting space and looking for Recalculate Normals.

If you want to read up on normals, see Wikipedia: https://en.m.wikipedia.org/wiki/Normal_(geometry)


How to make this abstract Ribbon-y shape in Blender?

I tried:

Create a short fat cylinder with no caps (the base ring)
Select the edge ring around the cylinder, and subdivide with multiple cuts to make the whole thing into squares instead of long rectangles.
Enable cloth physics on the mesh, and set the cloth to “rubber.” Enable self collision.
In Scene Properties, set gravity to zero.
Add a turbulent force field, and turn it up fairly high.
Run the simulation a bit.
Adjust physics settings as needed.
Add solidify and subdivision surface modifiers.
Create a glass material (you can add together three glass shaders with slightly different IOR values to get a chromatic aberration effect).
Use a noise texture to displace the surface a bit.

Note: I actually started with a bezier circle, then converted it to mesh after extruding it.


How do I change the shape of an object while keeping all of its data?

You can use two different methods.

Switch the meshes

Select your cube. In the Data panel, the first field allows you to select another mesh :

The object data will be preserved (logic bricks, modifiers, etc). Only the mesh data will be affected (vertex groups, materials slots, etc)

Use parenting

This method is preferable if your character already has an armature, and allows to keep the cube Physics settings.

Parent the character to the cube : select the character (or its armature if it has one), keep Shift pressed, then select the cube, hit Ctrl+P, select Object.

Make the cube invisible : in its Physics panel, tick Invisible.

To "hide" the cube in the 3d view but keep it selectable and usable, you can set Maximum draw type : Wire in its Object panel.


How can I achieve this type of spherical unwrapping?

The idea is to deform a sphere and report its UVs on another sphere.
Use an icosphere with some subdivision (say 6).
In edit mode, change its tri to quads: select all and AltJ (this matters for the UV tranfer operation later).
Back in object mode, copy this sphere.
Enter edit mode, in front view, select the four faces at the center. Turn proportional editing on, scale and enlarge the proportional editing so that its around all the vertices.
You should have something like this:

Once done, in front view, edit mode, select all and unwrap U then "project from view (bounds)".
Back to object mode, select the original, shift select the scaled sphere and make links CtrlL and choose "transfer UV map".

And, voilà:

Other side:

Scaled UVs:


How Can I Use Dynamic Sky from a Python script?

I'd recommend enable Developer Extras in the Preferences to get the actual operator (button) call. Once enabled, this is going to add a new Edit Source entry to the RMB context menu which allows to inspect the associated code coming from the the add-on in the Text Editor:

Turns out to be a pretty simple add-on, just creates a certain world node tree and allows to control its contents using a panel. The code itself consists of only one sky.dyn() operator, one scene property Scene.dynamic_sky_name storing the name of the current data-block and the panel of course.
Proof using the python console on how to create a 'Dynamic Sky', get the reference, assign it to the world data-block and set the brightness to 2:
# Call the operator
>>> bpy.ops.sky.dyn()
{'FINISHED'}

# Get the created world data block
>>> dyn_sky = D.worlds.get(C.scene.dynamic_sky_name)
>>> dyn_sky
bpy.data.worlds['Dynamic_1']

# Assign the data-block to scene world
>>> C.scene.world = dyn_sky

# Get the Scene_Brightness node
>>> scene_brightness = C.scene.world.node_tree.nodes.get("Scene_Brightness")
>>> scene_brightness
bpy.data.worlds['Dynamic_2'].node_tree.nodes["Scene_Brightness"]

# Set the strength to 2
>>> scene_brightness.inputs['Strength'].default_value = 2

How to enable a certain add-on is nicely explained in the following Q&A:
How to enable and disable Add-ons via Python?


Move objetct perpendicular to the viewport

You have to set the transform orientations to "view", then press G Z, move the mouse and confirm with left click.

If your view is orthographic you will not see any apparent movement but you can read the distance you're moving in the top left corner of the 3D window.


Blender for the chemical structure visualization

I'm very confident you can achieve what you want using Blender. Searching the web for "Blender for chemistry" gives you a number of hits including video tutorials and images what others did. Maybe this blog post is interesting for you:

https://patrickfuller.github.io/molecules-from-smiles-molfiles-in-blender/

Furthermore I found an addon for PDB import/export:

https://wiki.blender.org/index.php/Extensions:2.6/Py/Scripts/Import-Export/PDB


Hard surface modeling - How to model engraved lines?

Method 1 - Split Vertices
Such engraved lines can be created by splitting vertices and using the Solidify and Bevel modifier. The vertices of edges can be split manually in Edit mode (V + Enter) or mark them as Sharp and use the Split Edge modifier.

The vertices around the circle are split manually, the others are marked as sharp.

Modifier stack is:

Subdivision Surface: level: 2
EdgeSplit: [_] Edge Angle (unchecked), [X] Sharp Edges
Solidify: default values
Bevel: Segments: 2, Limited Method: Angle, Angle: 30° (default)

Video: Modeling Techniques Hardsurface in Blender combined - Pedro Augusto (The part about panels comes towards the end of the video.)
Method 2 - Boolean Modifier
Alternatively, you can copy the model parts, use the Boolean modifier (operation: Difference) to cut it out, and another Boolean modifier (operation: Intersection) on the copy to get the cut-out part. This way you have a deep cut between the parts. Finally, add a Bevel modifier to each part. And tick the Shading → [X] Harden Normals option in the Bevel modifier to fix the shading. Note: This requires in the Object Data Properties the Normals → [X] Auto Smooth setting to be activated.
The Bool Cutter object on the screenshot is 2 cubes join together. One cuts the sphere at the top, the other one cuts it at the bottom. The sphere is actually 2 spheres (one is the middle part, the other one is the top and bottom parts).

Video: Blender Hard Surface Modeling | Slice Operation
Method 3 - Mask Modifier
A flexible method that uses the existing edge loops of the mesh and Bevel and Mask modifiers to create the support loops and the gap. It's described here by Robin Betts:
What is the best way to model the intersection of multiple hard-surface pieces?


Applying an image with an alpha mask to a plane

This looks like bad alpha sorting in the viewport. It should be fine in the rendered view.

Essentially, Blender's old GLSL viewport has pretty mixed results with drawing transparency. this should be fixed in the new 2.8 Eevee based viewport.


Perhaps a more suitable way of generating instances would be with a Particle System?

CtrlG Make a Group of a proton and a neutron
Make an Emitter object, (maybe a rounded cube, to avoid crunching at the poles?)
Assign a Particle System to the emitter
No physics, start and end frames at 1
If you want to vary the proportion of neutrons and protons, you can 'Use Count' in the settings

Settings to taste, but this produced the illustrated result.

Now you can hit 'Convert' in the modifier stack of the emitter.. and..
..Ctrl ShiftA 'Make Duplicates Real'
Because the material is not dependent on Object ID,  Ctrl
J preserves materials


Looking for an After Effects feature in Blender (Expressions)?

Not that extensive. In the grapheditor you can use modifiers for your animations, like noise, which makes it the selected line(s) of keyframes wiggle. It's very limited.

It would make a good addon tho....


manuelbastioni add-on: hair library and clothes

I can answer your first question. You need to be using Manuel-Bastioni Lab 1.6 or higher. You must design a character and then finalize it (Finalize Tools), after which an ASSETS button appears. As of my writing hair is the only asset available. For best results choose hair with the same prefix as the human type you created. Press Load Element From Library. To fit it to the head you have to shift select the character's body mesh then look under Proxy Fitting to find and press Fit Proxy. I use the defaults with both options selected, but you can experiment in whatever context you later use the character. To change the hair colour use the Main Color node found in the Node Editor.


The simplest solution would be the following:

Step 1:
First your foot bone has to be set parent to the leg, not the ik bone.
Then deselect "inherit rotation" in the bone settings of the foot bone. This way the foot will allways stick to the leg, but will not rotate with the leg.

Step 2: After that, go to the bone constraints panel and add a "child of" constraint. select the ik controler as target, only select rotation and hit "set inverse". this way the bone will copy the rotation of the ik controler.


The file you should select will be a .py file, that can be found inside the .zip file. (Use WinRAR or 7Zip to open it) if the init.py doesn't work and it's the only file in there, you could have a corrupt download. What plugin are you trying to install?

Here are the specific installation options for installing the Mitsuba render engine:

First, download this file, then follow the following instructions:

  Unpack this file and move the resulting mitsuba folder into your
  Blender scripts/addons folder. After you do this, restart blender then go to user preferences, then find mitsuba in the addons tab and enable it. Then, you should be able to select
  Mitsuba as the currently active renderer (click either Cycles or Blender Render above the 3D view.

  In the main scene tab, you
  will need to set the path to the main renderer executable (mitsuba.exe
  on Windows, Mitsuba.app/Contents/MacOS/mitsuba on MacOS,
  /usr/bin/mitsuba on Linux).

Then, to install the spaceship generator, go to this link and select "Clone or download" and download .ZIP

Then open the .ZIP and drag the spaceship_generator.py onto your desktop. Then, in blender, go to the addons tab and choose 'install from file'. then select the spaceship_generator.py through the dialog box. Afterwards, just enable the addon and you're good to go.


What is the difference between a rigid body object and a dynamic object?

It seems that your assumption is right Rigid Bodies add angular physics (angular velocity) to the behaviour of Dynamic objects.

Which makes a rigid body roll over when it collides with another object, while a dynamic object would just stop to move.

From Python Wiki: Physics Type

  NO_COLLISION No Collision, Disable collision for this object.
  STATIC Static, Stationary object.
  DYNAMIC Dynamic, Linear physics.
  RIGID_BODY Rigid Body, Linear and angular physics.
  SOFT_BODY Soft Body, Soft body.
  OCCLUDE Occlude, Occluder for optimizing scene rendering.
  SENSOR Sensor, Collision Sensor, detects static and dynamic objects but not the other collision sensor objects.
  NAVMESH Navigation Mesh, Navigation mesh.
  CHARACTER Character, Simple kinematic physics appropriate for game characters.


as far as I am aware the only way to change those bindings is by modifying some python files. those number are being assigned to the menu automatically in base of the order the calls are made. it kind of doesn't make too much sense but there is a specific order in which are assign. the first 4 calls will always be the S,W,E,N points and so on.

so in order have your favorite menus calls with the keybindings you like, you need to change the order of the lines.

added some duplicate lines that creates number 7 and 9

If there is another way I am not aware.. you better of learning how to do your pie menu and use that IMO.

the file in question of the Z pie menu in Blender 2.80 is space_view3d.py. you can find it in blender configuration inside the script/startup/bl_ui folder.
mac path will be

Application/Blender_2.80/blender.app/Contents/Resources/2.80/scripts/startup/bl_ui/space_view3d.py

I am not on windows right now but that will be something like

C:\\Program Files\Blender Foundation\Blender\2.79\scripts\startup\bl_ui\space_view3d.py


A vector has a rotate function - see mathutils.Vector.rotate

vec = mathutils.Vector((0.0, 1.0, 2.0))
eul = mathutils.Euler((0.0, math.radians(45.0), 0.0), 'XYZ')
vec.rotate(eul)


Map Multiple Objects and then Join into One Object with One UV Map?

Unless I am misunderstanding, you are just trying to preserve the UV mapping of each model while joining them to a single mesh?

If that is your goal, ctrl+J with both models selected in Object mode will do that.  The join will preserve the models UV maps as is.  It might get a bit weird if the two objects share the same material but the UVs will not have changed (though, they will be stacked on each other, but again, if the materials are assigned correctly it won't matter).


Is there a way to create a pause between movements in Animation Nodes?

I'm sure there are many ways to create this effect but here is one relatively simple one:

The essential node here is Mix Euler List. For translation you could use the Mix Vector List node.

The Mix Euler List node takes a list of vectors and a value between 0 and 1 (can be higher when Repeat is enabled). If the factor is 0 it will output the first element, if it's one it will output the last one. All values inbetween will result in an interpolated output. (eg. 0.1 will be something between 0° and 90° in the z-axis).

The downside of this approach is that the time intervalls are always the same, but it seems to work in your case. You can animate the time somehow to change the intervalls using the same approach but this can become messy very quickly so I didn't do it here.


Change the ground plane's Rigid Body Type to Passive


If I understand your goal, you can do this in one go.

Select all outer edges (even the horizontal one)
Bevel them with Clamp Overlap checked (Shortcut: C)
Merge double vertices (Alt+M > by distance)


It sounds like you want to use blender's Video Sequence Editor.

http://wiki.blender.org/index.php/Doc:2.6/Manual/Sequencer/Usage

You will create a Movie or Image strip from your source clip.  You will then drag it to the right to open up some time at the beginning.  You can then add a strip for the added frames (whether they are an image sequence, movie clip, title card image, or solid color) in that space.


What is the Alpha Convert node used for?

It's used for manually converting between Straight and Premultiplied alpha.
This is sometimes needed when using external images in compositing, among other uses.
See the wiki:

Straight Alpha
This is the alpha type used by paint programs such as Photoshop or
Gimp, and used in common file formats like PNG, BMP or Targa. So,
image textures or output for the web are usually straight alpha. RGBA
color are stored as (R, G, B, A) channels, with the RGB channels
unaffected by the alpha channels.
Premultiplied Alpha
Rendering will output premultiplied alpha images, and the OpenEXR file
format uses this alpha type. So, intermediate files for rendering and
compositing are often stored as premultiplied alpha. Compared to
straight alpha, the colors could be considered to be stored as (R*A,
G*A, B*A, A), with the alpha multiplied into the RGB channel.
This is the natural output of render engines, with the RGB channels
representing the amount of light that comes toward the viewer, and
alpha representing how much of the light from the background is
blocked.
Conversion
Conversion between the two alpha types is not a simple operation and
can involve data loss, as both alpha types can represent data that the
other can not, though it is often subtle.
Straight alpha can be considered to be an RGB color image with a
separate alpha mask. In areas where this mask is fully transparent,
there can still be colors in the RGB channels. On conversion to
premultiplied alpha this mask is 'applied' and the colors in such
areas become black and are lost.
Premultiplied alpha on the other hand can represent renders that are
both emitting light and letting through light from the background. For
example a transparent fire render might be emitting light, but also
letting through all light from objects behind it. On converting to
straight alpha this effect is lost.


How can I store lists & dictionaries in an object?

You can store anything in a game property from python. You simply assign it:

obj['inventory'] = {'sword':3, 'armour':5}

It doesn't have to be present in the logic brick window.

Also, you can (and probably should) store the instance of your class rather than regenerate it each frame. You can do this in a number of ways including:

Using module mode and a global variable
Saving it in a game property
Saving it to bge.logic.globalDict

That way, __init__() isn't called every frame

The other thing you can do is you can mutate the game object. The API includes this example:

import bge

class CustomGameObject(bge.types.KX_GameObject):
    RATE = 0.05

    def __init__(self, old_owner):
        # "old_owner" can just be ignored. At this point, "self" is
        # already the object in the scene, and "old_owner" has been
        # destroyed.

        # New attributes can be defined - but we could also use a game
        # property, like "self['rate']".
        self.rate = CustomGameObject.RATE

    def update(self):
        self.worldPosition.z += self.rate

        # switch direction
        if self.worldPosition.z > 1.0:
            self.rate = -CustomGameObject.RATE
        elif self.worldPosition.z < 0.0:
            self.rate = CustomGameObject.RATE

# Called first
def mutate(cont):
    old_object = cont.owner
    mutated_object = CustomGameObject(cont.owner)

    # After calling the constructor above, references to the old object
    # should not be used.
    assert(old_object is not mutated_object)
    assert(old_object.invalid)
    assert(mutated_object is cont.owner)

# Called later - note we are now working with the mutated object.
def update(cont):
    cont.owner.update()

Which gives the game object the function 'update'


Wall angles - Is there a quicker way of achieving this result?

There are a few ways to do this. My personal choice is to use a curve representing the wall shape as the bevel object for another curve representing the floor plan.

Create a mesh object with the outline of the wall shape you want to use, such as this
Convert it to a curve (ALT-C -> Curve from Mesh)
Create a floor plan and convert it to a curve, such as this
Use the wall shape as the bevel object for the floor plan

You can create the curves directly if you prefer and you can convert the beveled curve to a mesh (ALT-C -> curve to mesh) so that you can modify it.


why do not have a " export uv layout option"

If "Export UV Layout" menu is not available, check if the addon is enabled:

In "File" -> "User Preferences...",
In Tab "Add-ons",
Select the "Import-Export" category,
Check that "Import-Export: UV Layout" is enabled,
If not, enable it by checking the corresponding box (be sure to save your change by clicking "Save User Settings" button

Normally, the option is now available in the UVs menu.


Is it possible to add a driver to a vertex position?

In edit mode, select the vertex you want to animate. Then CtrlH > H (Hook to new object). This will create an empty, whose position you can animate, and the selected vertex will follow it.


The requested feature doesn't natively exist within Blender, hence recreating the behaviour is very complex and tedious.

Download the accompanying blend file with various node setups.

Creating shapes with material nodes

If a shape can be recreated with mathematical functions (plotted shapes) it can be created with cycles math nodes.

Let's create a procedural rounded rectangle group. (If you know Blender and math, skip to step 3.)

On a large plane, add a material with an Object Texture Coordinate input.

We're going to focus on the X, Y positive area (marked blue) first.
Let's by defining the bounds for the rectangle, separate the XYZ channels and add two greather than nodes for X an. Add them together clamped.

The black is the interiour of the rectangle in the XY positive area. Make sure your object's scale is applied as we're using local coordinates. Strangely enough, we don't need these nodes, discard them!
Create a circular shape using the unit circle functions.
In our case it is simple: radius^2 = x^2 + y^2
This means, that for every point inside the circle, the following is true: `sqrt(x^2 + y^2) < radius.
In nodes, add a Power node for each x and y, then an add node to add them together, then another Power node for the square root. Finally a greather than to determine if the point is outside of the circle (= if the radius is to great).

The 2nd power node with a value of 0.5 is missing in the image.
Don't forget, the effect of the nodes is seen in material view and rendered view only.
Offset the X and Y coordinate by rectangle-"radius" minus rounded corner radius.

Regardless of the value of the CornerRadius, the circles bounds are clamped to the RectangleSize bounds.
Clamp the values left and below of the circle respective X and Y diameter.

These are the desired areas. To get the red area we multiply x < rectangleRadius - circleRadius with `y < rectangle radius, and for the blue area switch the inputs. Then add both results together.

This is the node graph, after multiplying this rectangle restriction onto the circle, a neatly rounded corner.

To make the rounded corner XY symmetrical, add an abs node each to the X and Y outputs form the separate RGB node.

Before the abs node, add a subtract node, to be able to shift the x and y coordinates.

Make the end result influence a color mix node.

Make it a group with an input for inputColor, Vector Coordinates, offsetX, offsetY, Size and CornerSize.

Nodegraph before grouping
But wait, add support for a different height and width. Figure it out yourself or download the blend.

Go wild, this is rather slow.

Creating shapes based on functions with nodes

Let's recreate this easter egg.

The first function will be converted as we did with the first example. I will interpret
(x-10)^2 / 300 + y^2 / 600 = 1
as

I added some arbitrary sine functions.

Creating a shape with OSL

The open shading language enable us to use a custom script node. Knowlegde of C and Python is required for the following part. (Since I don't really know any C or Python, the code samples are messy.)

You might want to head to BlenderSushi and complete their OSL series.

We'll create a stop sign polygon octagon.

I'll hard code some coordinates. Store the points in a string and convert them to a c style array with this python snippet. I just manually copied and pasted the coordinates separated by spaces and commas and the manually copied and pasted the generated code. Execute the snippet in any python interpreter.

pts = "-1,2 1,2 2,1 2,-1 1,-2 -1,-2 -2,-1 -2,1"
pts = [[float(n) for n in m.split(",")] for m in pts.split(" ")]
pts.append(pts[0])

pt_array = "point pts[" + str(len(pts)) + "] = {"
for pt in pts:
    pt_array += " point(" + str(pt[0]) + ", " + str(pt[1]) + ", 0),"
pt_array = pt_array[:-1] + "};"

print(pt_array)

This generates the following output.

point pts[9] = { point(-1.0, 2.0, 0), point(1.0, 2.0, 0), point(2.0, 1.0, 0), point(2.0, -1.0, 0), point(1.0, -2.0, 0), point(-1.0, -2.0, 0), point(-2.0, -1.0, 0), point(-2.0, 1.0, 0), point(-1.0, 2.0, 0)};

In Blender, create a new text block and start off with a basic osl shader

shader simpleColor(
    point Vector = P,
    output color col = color(0.0))
{
    // insert our custom point array here
}
Select the textblock in a script-node in the material nodes. Activate Open Shading Language in the Render Settings.

Now we got our polygon in our osl shader. To detect if a point lies in the polygon, we are going to implement a simple version of the Ray Casting algorithm. There are plenty of resources on point-in-polgyon topics on stackoverflow. I'll cast a ray from the y minimum and check with how many polylines it intersects. If the number is a multiple of two, the point must lie outside the polygon.
Create a simple function, which will take two points of a linear mathematical function and an x value and return the corresponding y value.

float linear_function(float x, point p1, point p2) {
    float x1 = p1[0];
    float y1 = p1[1];
    float x2 = p2[0];
    float y2 = p2[1];
    if (x1 == x2)
        return 0.0;

    float m = ((y2 - y1) / (x2 - x1));
    float n = y1 - m * x1;

    return (m*x+n);
}

7. Now, we'll add another function to detect if a point lies above a polyline. First we'll check if the x coordinate is inbetween the two points of the line, then we'll compare the y value of the function between the two lines with the y value of our point.

int hit(point p, point p1, point p2) {
    float x = p[0];
    if (p1[0] == p2[0])
        return 0;
    if (p1[0] < p2[0])
        if (p1[0] > x || p2[0] < x)
            return 0;
    if (p1[0] > p2[0])
        if (p1[0] < x || p2[0] > x)
            return 0;

    if (linear_function(x, p1, p2) > p[1])
        return 1;
    return 0;
}

With these two functions added, the shader can be tested with 2 points. Note, that osl shaders are only visible in rendered preview mode.

We can also use our stop sign coordinates.

Notes on svgs

With these tools you are equipped to start writing your svg plugin. The hit function has to be implemented for curveto, smooth curveto, quadratic Bézier curve, smooth quadratic Bézier curveto and elliptical Arc and the python script has to convert all types of the svg path. It's actually not that hard to compute further intersections, but parsing the svg is going to be a lot of work.

The final goal is to write a python script, which parses an svg (with python's xml parser) and converts is to a osl shader script. The points and curves would be hardcoded in the shader.
Unfortunately, we have to first implement the most basic collision detection for beziers (see the previous link), because most svgs will use them, and possibly for all other svg elements (see the previous2 link).


Can I make 3D spheres to deform/pulse in sync with audio?

I had so much fun re-creating this effect that I ended up doing it twice. You can see the final results (with sound) here.

Unfortunately a step-by-step guide to creating exactly what I made would be a bit long for an answer, so instead I'll summarize the process, with lots of links to other more specific answers.
The basic idea is this:

Create an empty (⇧ ShiftA> Empty) and keyframe an arbitrary transform channel (I) (using an empty's transform makes setting up drivers a little quicker later on)

Use Graph editor > Bake Sound to Fcurve.
If you want to get fancy you can bake several empties (or several transform channels) with different frequency ranges (for example, if you want to change the scale with the amplitude of bass sounds while changing the color with higher pitched sounds)

Use drivers to control whatever settings you want (object scale, subdivision levels, or even cycles materials) based on the empty's baked transform channel.
The reason for baking to an intermediate empty rather than directly to the property you want to animate is solely for ease of tweaking. With a driver you can e.g. use an expression to adjust the amplitude later on, or use multiple drivers to drive multiple properties off of a single empty.

With that in mind, I used a cube with some modifiers to create the sphere:

Subsurf To add more geometry to the cube
Cast To make the subsurfed cube spherical (note the Factor is set to 1)
Displace To produce the actual distortions. The texture used for this modifier is on the top right. The empty used for the texture's coordinate space has a random rotation animation generated with a noise fcurve modifier.
Cast (again) To flatten the displacements back towards a sphere a bit, but not all the way. Note the Factor on this one is < 1
Smooth Just to smooth out annoying wrinkles

Other points of interest in this screenshot:

The material used for the main sphere
The material used for the duplispheres (small dots)
The driver expression used to drive the displacement modifier strength (the referenced empty's Y location is driven by a sound-baked fcurve). To add a little "pep", the raw value is multiplied by 5 (totally arbitrary choice on my part) then taken to the second power. min() provides a quick way to limit the maximum value the driver will produce; e.g. min(somenumber, 1) can only ever return numbers < 1.

To create the dots I duplicated this cube and used dupliverts to render the second cube's vertices as icospheres, and added a driver to the subdivision level on the subsurf modifier.


Unable to apply materials to the entire mesh object correctly

Programming languages are very literal and do exactly as they are written in the order that they are written, with python the formatting (line indentation) also makes a difference.

Assuming the code you show was pasted with the same formatting as the script you are running, you start by looping over every object and selecting it and making it active. bpy.ops.object.select_all(action='SELECT') will get the same result.

When the loop is finished you deselect all objects, select one object, set self.model to the last object in the loop then create and assign a material to the one object.

You could indent the lines that make the material so that it becomes part of the loop so that you get a new material created for each object. Another approach is to create the material first and then assign the same material to each object in a loop.

mat = bpy.data.materials.new('colored')
mat.diffuse_color = [0., 191./255, 255./255]
mat.specular_intensity = 0.3

bpy.ops.object.select_all(action='SELECT')
for ob in bpy.context.selected_objects:
    if ob.type == 'MESH':
        ob.active_material = mat


Thick Cyan lines on edges on export - import mesh?

Those line represents the "Make sharp", there seems to be a bug that create those make sharp edges when exporting meshes. To remove them go to edit mode, edge selection mode. Hit A to select all edges. Then Hit Ctrl + E and select "Clear sharp" from the drop down list.


Create the circular distorion from an anamorphic lense

You can probably use radial blur to simulate the effect of lens aberration in post-processing.

But the effect is also surprisingly easy to achieve in Cycles with the camera. Just add a black, circular aperture object in front of the camera:

Here is the setup from the camera's perspective. The more closed off the circle is, the heavier the vignetting:

Blend file Download


How to avoid crashing when applying particle system with 10 000 000+ polys?

First of all I would think about the necessity of 10 polys per 1 needle. Since 1 would be enough, it would reduce the polycount to a tenth. In case you need a close up, I would suggest setting up another tree with higher density settings. This workflow maybe does not bring you into your " particle kill situation".


How I use the Curve Modifier.
I subdivided the plane using Cut and Slide with Ctrl+R.
I created a NurbsPath cuverd the desired shape.
So I used the Curve modifier.
The plane just fits half the curve, then you shall move and scale de plane to envolve the entire curve as you wish. Good luck.


Is there a way to make a gradient based on an object or a image texture?

You can use the Dilate / Erode node in the Compositor Editor. Link to the docs
First setup your Object as needed and render the image.

Now you can play with several dilate / erode nodes to get the desired effect. It basically creates a dilated mask for each subsequent dilation and we're adding them , then dividing by the number of dilations, then plugging it into a Combine HSVA node to get rainbow colors. You can tweak it to get desired colors too.

There is a Distance and a Step mode in the Dilate / Erode node. I found the Distance mode to be more pleasing, but the compositing time will skyrocket on high values.


Blender 2.8 Custom Start Window (Ctrl + u) Not working

You will have to do this through the menu.

To save the default scene use File > Save Startup file.

Many shortcuts have changed in 2.8. There is no default shortcut for that operation any more. Ctrl+Alt+U doesn't work any more.


Use a Transform node (Add > Distort > Transform) and animate the values for X (horizontal)


How to get a object mask as part of the alpha channel?

If you are using cycles, all you have to do is use holdout sahder node.
 Give the object that you want to have the 0 alpha a new material like this.

Then in the render tab of the properties window, under the Film section enable Transparent. You will have to save your render to a image format with a alpha channel, such as a .png.


You need a light in scene to see the texture, or go to the material and set it to 'shadeless'. I usually set up lights in a sphere around the object and then hide them so that my object is well lit.


If you just converted the hair, you then have a string of vertices. Since there are no faces, these will not show up. They are likely there, you just can't see them. Try giving them some thickness. To do this, convert them to curves and extrude them, then convert back to mesh. Or use the screw modifier with a setting of only 1-3 degrees.


This can be done a number of ways:

1) Set a different material to each facing of the die and give each a separate image texture.

2) Make a color stencil texture with a different color on each face, then use it as a factor between the different image textures within the same material.

3) Like above, but use vertex colors.


How do I add objects on selected polygons?

Good reason to use Instancing (DupliFaces in old terms)

Duplicate selected faces and separate it from base object;
Create Cylinder, make it parent of separated faces object and copy location - origins must match each other;

Updated:

In Object properties, on Instancing tab select Faces.

As instance for DupiFace Cylinder will not be rendered!

After that you can Make Duplicates Real for next processing.


Does the Vector Math Normalize operation use the second input?

Input 2 is not used, manual is wrong, I guess. Links to the source code for the node are below, you can clearly see input 2 is never called when in normalize mode.

SVM: https://developer.blender.org/diffusion/B/browse/master/intern/cycles/kernel/svm/svm_math_util.h

OSL: https://developer.blender.org/diffusion/B/browse/master/intern/cycles/kernel/shaders/node_vector_math.osl


How do you combine two different blender files?

I most often use append to combine two separate blend files. (File > Append)


To get these directional reflections its best to use a Anisotropic Shader, it yields those as a result and you can change certain properties of it:

This is the node tree that i've used:

Depending on the look and feel you want to produce you can play around with the settings of the anisotropic shader. To turn the effect down, simple change the factor of the mix node.

To get the small surface effects printed paper sometimes has, i've implemented a simple voroni noice as a normal in the anisotropic node. It adds a small level of detail that could be needed on close shots. It's not perfect and more meant as an example as to what is possible.

Note: It's also possible to use the built in anisotropic settings in the principled bsdf - i just like to use it seperated.


Vector math to get Curve object silhouette

The solution is to calculate the crossproduct of the incoming and curve direction vectors. The absolute of the dotproduct of that and the normal is the facing which you can connect up to your color ramp.


Mesh auto unhide when select another object

One way is with the Mask modifier:

In edit mode, select the part of the object you want to hide (or the inverse; the part you want to remain visible)
Create and assign a vertex group in Properties > Object Data
Add a mask modifier and specify the vertex group. Click the invert button if needed.


Use Shadeless material option in the Properties panel for each material,and that will keep you from having to use things like AO or anything like that. You can mimic the shadeless material in Cycles with an emission shader on everything, but I think the rendering in Blender Render for this type is faster.


The arctan2 into division step is turning this into a radial gradient.  Instead of a light and a dark half you have light and dark quarters of the mesh, basically, and the way you've ramped the color is kind of hiding the problem from you.

So I think what you are asking for is not going to happen without some changes to the math leading up to it.  If you take the output of your noise texture into a math node set to Less Than you may find something you like, or try the following:


How to Join two Armatures without losing constraints in Blender 2.8?

All constraints look for an armature and a bone. If you merged the "B" armature into the "A" armature, probably some constraint are looking for an "X" bone which was in the "B" armature, but now it is into the "A" armature. If all bones names are different, it should be enough to change all constraints armature target from "B" to "A".


The answer is : "Play with the UV unwrapped mesh till it gets better".

Although I imported as plane and I thought this would be enough it isn't.

You need to move the vertices of the uv-unwrapped mesh and check what it produces. After some testing I brought it to levels that it is not pixelated.

I would like though, to know what is the exact size in that unwrapped mesh to match the video perfectly. Comment if anyone knows.


Blender now responds to changes made in the 3DConnexion properties application (this wasn't previously the case in 2.79).
If you reverse all the navigation properties in the 3DConnexion advanced settings, the space mouse will respond as if it was set up with default settings in Blender. In every other CAD program I have used the opposite is true.

I can't seem to find any documentation of these changes or why it is mapped wrong by default.


found it

import bpy

i = 0 #default number
pref = "new" #name
name = "%s%d" % (pref, i)

for ob in bpy.context.selected_objects: #for every object in selection
    i += 1 #add i+1
    name = "%s%d" % (pref, i) #redefinie name
    ob.name = name

if i wanted to just keep the same name, i need to replace pref by

pref = "%s" % bpy.context.object.name

if i want to make the prefix into a suffix or add _ - ect i just need to change

name = "%s%d" % (pref, i)
to
name = "%s_%d" % (pref, i)

basically its simple, for each object in my selection, i add +1 to i = 1
that's it

there is also a special python function that transform the number into numbers like 001 002 003 010.. ect... ii only work with strings so you need to convert the number into a string first:

newnumberfilledwithzeros =str(10).zfill(3) #will be = to 010

with all thoses examples, here what i came with this example below,
and witouth the " "%s" method, its actually not necessary for this small exercise.

name="hello"
#if you want to keep the same name and just add the suffix ? use this line below instead
#name= bpy.context.selected_object.name
start=0 #could start at -1 if you want the first obj to be named 000
zeros=3 #3x= numbers like 001,019... 4x = 0012,0003... ...
for ob in bpy.context.selected_objects:
    start+=1
    f=str(start).zfill(zeros)
    ob.name = name + f
    #result will be "hello001" "hello002" "hello003" ect..
    #want to be "hello_001" ? just to this below
    #ob.name = name + "_" + f
    #want to do a prefix ?
    #ob.name = f + "_" + name


This is a "Math" node;

It takes on the name of the operation you are applying to the inputs;

My most frequent use of it is to multiply input to increase or decrease the strength of Mix Shader nodes.


Is there a way to prevent mesh editing when importing via the API?

In general this is possible, but a few conditions must be met to achieve this.

First off, to prevent the end user to accidentally edit the mesh, it has to be linked instead of appended to the file. In order to answer that from a scripting point of view you need to provide more detail on how you handle the appending currently. There are low-level and high level approaches to this, so please add your code to the question. The tricky part is that if you want to edit material assignment, only the mesh data must be linked, but the object must be local. If all tansforms on the incoming object are applied, that would be trivial. You could then create a new mesh object in Python, and use the linked mesh datablock in it. Otherwise, things become more tricky or require end user interaction.

Note that linking the mesh in will also mean that whenever the source mesh in the source file is updated, it will be updated in all files that link it as well on reload.

Second, by default Blender associates the object data datablock with the material. That means, the mesh datablock you have just linked in also defines what materials are assigned to the mesh. Since now the data is linked and unchangeable, you can not change the material any longer. The solution to that is to set the material link to 'Object' instead, like in the answer given here.


How to make a shader with different emission strengths, depending on the object it is associated to?

You can get any object's local space with the Texture Coordinate node and use the distance from its center to create a falloff.


How do I move the camera in any perspective mode so the reference image doesn't vanish?

Your background image will vanish as soon as you leave orthographic view or rotate the camera to an angle the background image isn´t set for.

Just stay in orthographic view (Numpad 5) and use Front View (Numpad 1), Side View (Numpad 3) and Top View (Numpad 7) to change the directions; for the opposite of those views press Ctrl as well.

To move your current view without rotating just press Shift and drag your view with Middle Mouse Button


how can i make a robe that follow leg movement without wasting too much memory on collision?

Try Copy Rotation Constraints. Place them on the bone chains of the skirt bones and make them follow the leg bones, adjusting their influence based on how closely you want the skirt to follow the movement.

For extra control, you could create one set of skirt bones to auto-follow the legs and make them the parent of an additional bone for manual control.

The included .blend only has two bone chains for the coat, and they were done with automated weights, but it should guide you right.


When I do 2D stuff, I use armatures, which work well when the mesh has evenly distribuited quads. In my example I created the line with 4 vertices, then I added some loop cuts until they were evenly distribuited, then I added 2 loop cuts near every joint, then I made the bones to be bendy bones with 2 segments each, playing with curve Y in and out settings.

The rounded cap is obtained by simply adding a subsurf modifier (level 3), which has to be set after the armature modifier. Enable the Armature "preserve volume" option for better results.

Watch Nathan Vegdahl's free YouTube humane rigging course, in some of the first lessons he explains some useful rigging tricks fro 2D animation.


This is because the text is in the same place as the background plane.

TL;DR: Move the text a little above the plane so they don't intersect and interfere.

Blender has no way of knowing if the text should be on top (and invisible) or if the background plane should be on top (obscuring the text). Even though either scenario comes to the same result in this particular case, such an undefined situation is liable to cause undefined behavior.

What happens is some cycles form of z-fighting (the classic z-fighting artifacts only seem to appear when in ortho view and from some angles). If you put an object behind the plane and text, the issue becomes clearer:


Download platform specific animation nodes 2.0

The platform specific variations of Animation Nodes 2.0 can be found while viewing this release of the add-on via its Github page: https://github.com/JacquesLucke/animation_nodes/releases/tag/v2.0


Eevee render doesn't look like render preview

Check if Ambient Occlusion is on in the Render panel. That might make the object shadows disappear if it's off.


Objects appear lit even if there is no light source

In your shaders, you shouldn't plug a texture directly into the "Material" output.

If you don't want your shader to emit light, but only to diffuse external light based on its color, then add a Diffuse shader.

PS: you can tell that a shader is probably wrong when there is a line between two differently-colored sockets. In your case, yellow ("color info") sockets were connected to green ("shader info") sockets.


My choice would be.

For the river, Mesh Plane with animated water material.
Particle system as a tool to randomly distribute the stones and branches.


Access "self" in add-on from separate module file

A buddy helped out with this. In the secondary file, I added an optional argument def someFunction(lanes) and use print(lanes) instead of print(self.lanes). Then in init.py, when I call the function I use someFunction(self.lanes)


It sounds like you are in Pose Mode. To change that, simply click on a different object, say the minecraft guy (not the rig). Or in the 3D view header switch to Object mode, then you will be able to add a camera.

Here is a picture of the add menu in pose mode. As you can see the camera, along with other object types are grayed out.


Texture slots and viewing combined textures

Simply using Material Draw Mode for combined textures is the only option in Cycles for now. Blender Render used GLSL viewport to get combined, but the nice thing about Cycles Material Draw mode is that you can toggle shadeless in the N panel without affecting the shaders themselves. Also, you might be interested in looking at BPainter addon as it simplifies and streamlines the painting experience in Blender all around.


Whats the right way to create scenes ready for gltf and draco compression?

Ok i got it. It is indeed a bug in the glTF-Blender-IO addon. See https://github.com/KhronosGroup/glTF-Blender-IO/issues/993. There is also a workaround described how we can solve this. So what stays is the hope that other people will find this solution a bit earlier than me and there will be a bugfix soon...


You can use a base cube, then in edit mode, subdivide two edges and manually create a curve by moving the nodes with the "G" key. You can use the subdivision modifyer to smooth it and sculpt mode to create small irregularities in the bread. That is how I would go about this. Try looking up basic Blender tutorials on youtube to learn to use the program more effectively.


Recover corrupt .blend file after power failure

Certainly sounds like it ought to read that file.
Something you can try is opening a new file and File>Append>Navigate to your Blend file>Collections and select all the collections.
This should append all the objects with any data attached to them and they should still be in the collection hierarchy that you've used.


Correlation between image render cap size and game resolution

Ok. I figured it out. Capsize is limited to the window size of the BGE rasterizer.

I implemented something like:

import Rasterizer

windowSize = (Rasterizer.getWindowWidth(), Rasterizer.getWindowHeight())

...
imageRender.capSize = windowSize

Then I can start a standalone player with my desired resolution of 1600 x 1200 px and get the camera image in that very same resolution.


What do I need to do to make be able to make some changes to proxied linked objects?

Linked objects can only be altered in the original file, that's the point of them being proxied.

When you Link and object (⎈ Ctrl⎇ AltO) you can make a local copy. However this won't work unless you make your Linked Group local.

When you proxy the object ⎈ Ctrl⎇ AltP from a linked group ⎈ Ctrl⎇ AltO, it simply creates a duplicate, which change the object level properties (like Transformation, Delta Transformation, etc).
The original oject is still in the Linked Group.

If you wish to change your geometry you have to make a local copy by clicking the copy number in the object data section. Editing this copy will however not change the group object.

This copy could also have simply been appended to the current file ⇧ ShiftF1.


Transformation matrix problem with matrix_world, with different results based on the same values in different form

I think the two answers above pretty much explain what's happening. In case of assignments, we need to understand what's being assigned. Is it value or reference to the memory location (in C, it's called pointer)?

When one does an assignment like:

c1 = bpy.data.objects["Cube.002"].matrix_world

one essentially stores the reference of matrix_world in c1. So if c1 changes, matrix_world would change and vice versa. Since the active object in this case happens to be (I guess) one of the two cubes, let's say Cube.001,  whose matrix world references is held in one of the two references (c2), the assignment to that objects matrix_world with the following line:

bpy.context.active_object.matrix_world = c1 * c2

changes the value referenced by matrix_world. But this is also the value referenced by c2. So when the same statement is executed again c2's value is already changed. This should explain the incremental movement. (I missed this point before since I was thinking the active object is not one of Cube.001 and Cube.002 but the original Cube :).

This does not hold true for h, it's a new memory location, which contains the (static) product of the two matrices. This is static in this particular case since none of the operations are manipulating the value referenced by h. So no matter how many times you assign h to the matrix_world the object is not going to change.


What is the best way to animate tension?

You could use a bezier curve, make a middle vertex, hook the vertex to something using ctrl+h (empty works best), use a medium noise on z location of the empty and a low noise on x or y so it moves left to right, and as the rope gets tighter reduce the strength of the z and decrease the scale so its movements are faster and tighter
If you want more detail just ask.


Tracking things down led to client.py line 354

class NetworkRenderEngine(bpy.types.RenderEngine):
    bl_idname = 'NET_RENDER'
    bl_label = "Network Render"
    #bl_use_postprocess = False
    bl_use_postprocess = True #turning this to true enabled the blur and layer mask issue (not yet discussed)

I think the network render is a great feature, but could use some optimization. Seems to be a lot faster if you can use a shared directory, placeholders approach with no overwrite, and start multiple instances of blender on multiple machines (pretty fast renders). Cons: no management, oversight, and then have to manually put everything together at the end. Which is why I wanted to use Network Render since it has those features.  Might end up needing to custom scripts to maximize speed or integrate multiple calls to background blender render processes (not sure how to do that offhand from the given code)--if anyone has any thoughts on this, please forward them my way.


how to change grease pencil radius using brackets []

I couldn't edit the keymap to get this to work at the time this question was asked, BUT the shortcuts have been added to the 3.0 alpha build:

New Bracket keymaps ([, ]) to increase and decrease brush size. (c58bf31aed)

3.0 Grease Pencil release notes
Daily builds download page


You can create multiple materials for the object in the materials tab of the properties panel.  Then, on edit mode, use the assign buttons in the materials tab to give the selected faces the selected material.  By default all faces are assigned the first material you create.

Note: the rendering properties of a material can be found in the surface rollout.  But materials, by default, have a gray viewport color, this can be changed for each material at the bottom of the material's settings.


Hiding vertices from Automatic Weights process?

UPDATE: I have found a workaround that seems to solve the problem. I don't know if there is a smarter way, but I'll post it for anyone else with a similar issue.

I selected all the vertices that made up the problematic area, pressed P and separated by "Selection".
I then select my mesh (which is now separated from the problematic vertices), go to Weight Paint mode and then do Automatic Weights binding.
After weighting process is complete, I select the seperated mesh, then shift-select my main mesh and do Ctrl+J to join them again.
Then I go back to weight paint mode and click the bone nearest to this area and manually paint it so it follows the rig.
Finally, I manually merge (Alt+M) EACH INDIVIDUAL vertex at the points where they were cut/separated.

This solved the problem, and it even kept the shape keys I had in that area from being destroyed, since no vertices was added or removed by doing this. If anyone have a smarter method, I would still love to hear it!


What's causing this misshading, and how can I fix it?

Smooth shading was turned on, and reacted weirdly with the geometry.
(Some normals were also flipped, and were fixed early.)


Any other way will leave a flat face. The way I do it is to create the exact size UV sphere with the same amount of segments, delete the unnecessary faces, and then manually connect the vertices to the cap of the new UV Sphere.

But I'm guessing since you have so many segments that would take forever. So another more inaccurate way- since it's a sphere is...
Extrude the opening's edge 2 or 3 times. Then merge the smallest loop into a single vertice.
From there you can adjust the height of the new vertice loops until the smooth operator or subsurface takes effect visually.


How can I restore the scripts/addons folder after accidentally deleting it?

Download the Windows Portable .Zip package from the Blender website (instead of the installer). Open the Zip file and extract just the missing folder. The files are all scripts/add-ons so it should be the same for all versions (so shouldn't be a problem for Mac).


I'm not quite sure if this is what you're looking for, but one way would be to take your waves (top), and a Gradient texture (middle), mix the two, and put the mix through a threshold (bottom).

This is object space, so 0 is at the center, and the gradient is made symmetrical by mapping it with the absolute value of the of the texture space.(only X matters, here).

The mapping nodes just line things up as shown in the illustration.

Further to your comment, the above example is, in principle, halftoning. To get it to work as it does in your reference, rather than using a gradient, in EEVEE, you can use the actual light-response of a surface by using the Shader to RGB node.

In an effort to get somewhere near your reference, I've tried a couple of extra things:

The texture space

So the image would work more as if it was printed or drawn, I thought the hatching texture shouldn't change size with distance. The 'Window' texture space does this, but is scaled in proportion to the rectangle that contains it.. so this cluster flattens the space of a perspective camera instead. The top planes are textured in Camera space, the bottom ones in the space corrected as shown. That becomes the little group: 'Screen Space'.

The hatching..

.. has taken your wave texture, given it a bit of a wobble, and tried to break it up a bit with some Voronoi noise. Judging by the aliasing in your reference, the jigs, jags, and missing strokes, I think the hatching there was probably hand-drawn, and that's maybe the best way. I had fun knocking out the odd stroke and messing with the texture space to imitate it procedurally, but the tree was getting too big... it's really a different question. This cluster became the 'Broken Hatch' group.

So now, by mixing two copies the hatching, rotated at different angles, with the output of 'Shader to RGB', and putting through thresholds as shown above, you can half-tone Suzanne. The Mix factors and the Color Ramps give you not-too-twitchy control over the look.

If you're after AO, bear in mind that it can be wound up to more than 1 in EEVEE.

I don't know, this is not as tasty as your reference, it looks too procedural. But I'm sure you could take it from here.


How to get thinner ends of hair particles?

As far as I know, you can only do it using Cycles.

So, once you've changed your render engine, head over to the Particle Properties tab and tweak the values under the Hair Shape section until you get satisfied with the result.

The first three inputs are pretty intuitive, just mess with them; the fourth one is simply a global scaling factor.


Blender api: How to set shapekeys as keyframe in a loop?

Answering my own question as I figured it out. Just in case anyone else has a need for it, the below script works as expected.

import bpy

#save the total number of frames as var
frames = bpy.context.scene.frame_end + 1

#loop through frames, jump to each frame, add the armature, set as shapekey
for frame in range(frames):
    bpy.context.scene.frame_set(frame)
    bpy.ops.object.modifier_add(type='ARMATURE')
    bpy.context.object.modifiers["Armature"].object = bpy.data.objects["rig"]
    bpy.ops.object.modifier_apply(apply_as='SHAPE', modifier="Armature")

#for each frame, loop through shapekeys and add as keyframe per frame, set value to 1 if current frame = corresponding shapekey
for frame in range(frames):
    for shapekey in bpy.data.shape_keys:
        for i, keyblock in enumerate(shapekey.key_blocks):
            if keyblock.name != 'Basis':
               curr = i - 1
               if curr != frame:
                   keyblock.value = 0
                   keyblock.keyframe_insert("value", frame=frame)
               else:
                   keyblock.value = 1
                   keyblock.keyframe_insert("value", frame=frame)


How to bake textures with compositing applied?

You could try saving the image as close to the size of your texture as you can get and projection-mapping it (this does mean you'll need to render a few times, though). EDIT: You'd need to render at least one more time to get the back, and possibly a few more for more obscure angles and stitch the images together either via UV layers or externally, or, my favorite, with masking maps.


Blender mesh becomes messed up after importing

It figured it out. It was all in the textures and I had to delete them all and then and add them back into the game.  When you import a obj into a game sometimes the textures and materials get messed up.  I just deleted all the material slots and recreated the material and uploaded the same image to be mapped on it.


Cycles spotlight creates fireflies on glass and glossy materials

Try using the denoise feature in 2.79.

Using the default denoise settings with your file at 1024 samples (and 100% resolution):

A different option without denoising is to modify the default glass shader (see :How to illuminate the darkness inside glass objects in Cycles?).

(1024 samples at 100% resolution)


Blender Object loses Alignment during Rotation (Only During Render)

Issue was caused by original object overlapping with my Collection Instance and showing up on render. I had to hide the original object in order to make it work on render.


search for unknown operator (bpy warning in custom script)

The message:

search for unknown operator "NAME_TYPE_shortname", "NAME_TYPE_shortname"

could come from the user preferences keyboard shortcuts manager.

Registering an incorrectly spelled operator path will give that message.
Adding the shortcut in your script before the operator is registered will give that error too.

Maybe this is a typo but your

class updateList(bpy.types.Operator):
    bl_idname = "myplug.update_list"

Would mean that the operator is located at bpy.ops.myplug.update_list(), not bpy.ops.myplugin.*

There is no inherent reason that operators can't be called within other operators, but you will have to wait for the called operator to complete before the calling operator can end, it doesn't fork off into its own thread.

for instance

import bpy

class login(bpy.types.Operator):
    bl_idname = "myplug.login"
    bl_label = "Login"

    def execute(self,context):
        ...

        # bpy.ops.myplug.update_list()  # should be.
        bpy.ops.myplugin.update_list()

        return {'FINISHED'}

class updateList(bpy.types.Operator):
    bl_idname = "myplug.update_list"
    bl_label = "UpdateList"

    def execute(self,context):
        print('caramba!')
        return {'FINISHED'}

def register():
    bpy.utils.register_module(__name__)

def unregister():
    bpy.utils.unregister_module(__name__)

if __name__ == '__main__':
    register()
    bpy.ops.myplug.login()

# AttributeError: Calling operator "bpy.ops.myplugin.update_list" error, could not be found

If you are calling a set of operators in sequence, then of course you must  ensure that the operators are registered globally. If i'm not mistaken the bpy.utils.register_module(__name__) will register classes in order of appearance in the file, use that order to your advantage.


What modifier or plugin does uneven mesh division?

This can be achieved with a Subdivision Surface modifier set to "Simple" followed with a Decimate modifier set to "collapse" with a low ratio (I used 0.1).


How can I add background to rendered image

You can  create plane and use this recipe with texture you like it works perfectly every time


Identify Vertices intersecting with Bounding Box using Animation Nodes

You can use Is Inside Volume node to know which vertices are inside the volume. Then use Mask List node to filter out vertices inside.


How to create a slinky animation in blender?

You can generate the mesh of your slinky using the screw modifier on a crossection mesh. Then you want to use a Bézier to deform your slinky.  You can animate the whole thing by applying shape keys to your curve. You can simply key frame these.

You will encounter a problem regarding how far your object stretches along the curve. I have no solution but key framing the z scale yet. But I think you can calculate the length of your Bézier and write a driver for it if it is too much to animate. Which is way more difficult for a beginner.

a lattice might improve the destribution of your slinky along the curve.


How do i change just one side of a mirrored model?

If you want to break symmetry you have to remove the mirror modifier by clicking "Apply". Unfortunately once i'ts done you can't go back, so be sure that your cat has enough details before you apply the modifier.

Another way to do that to keep the mirror modifier would be to add another modifier on the stack, over the mirror modifier. In your case, you could add a boolean modifier to make the cut, but think to hide this modifier if you want to edit the base mesh if it is high poly, it can slow down blender.


Calling a function in operator to create a button

bl_info = {
    "name": "",
    "description": "",
    "author": "",
    "blender": (2, 80, 0),
    "version": (0, 0),
    "category": "",
    "location": "3D View > UI > Create",
    "warning": "",
}

import boy

class PrinterFunction(bpy.types.Operator):
    """desc"""
    bl_idname = "print.helloworld"
    bl_label = "Hello World"
    bl_options = {'REGISTER', 'UNDO'}
    def execute(self, context):
        print('hi world')
        return {'FINISHED'}

class OBJECT_PT_hw(bpy.types.Panel):
    bl_idname = "object_PT_hw"
    bl_label = "hw"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'UI'
    bl_category = "Create"
    bl_context = "objectmode"
    def draw(self, context):
        self.layout.use_property_split = True
        self.layout.operator('print.helloworld', icon="IMPORT", text="Rename here")

classes = (
    PrinterFunction,
    OBJECT_PT_hw,
)

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

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

if __name__ == "__main__":
    register()

FYI: Blender already has many useful python templates. You can access them from here


Erasing Alpha does not erase the Mesh in Texture Paint?

In eevee you have to select the material and enable "Alpha something" as blend mode in the settings.


removing reflection in plastic for final rendering

The apparent reflection in the side of the glass cover is not actually a reflection but is a refraction - due to your glass cover not having 'thickness' and only being a single surface (so it's as if the whole inside is solid glass). Give it some thickness (either extrude it or just add a Solidify modifier) and that apparent reflection will disappear.


How would I smooth a 90 degree pipe angle?

Indeed it would be easier to deal with this type of geometry using Bezier Curves instead.
Otherwise just use the Bridge Edge Loops operator.
Erase the straight corner faces, select both end edge loops, call the Bridge Edge Loops from the Space Bar / F3 search, then adjust the number of cuts and smoothness as desired.


When modelling something you would always add minimal geometry (eg. loop cuts) and work with it until the shape of the object cannot be further improved with the current geometry! This is very important, as if you start adding too much geometry initially, you will get lost and you make your task exponentially harder, because you will have to manually manipulate so much more verts.

Now, in most cases you should avoid subdividing altogether, before you are finished modelling, in a sense. Meaning that with your modelling you would have laid out the optimal topology of the model and would have made sure that every vertex and every face is absolutely necessary for describing the object and maintaining the topology! Only then you would subdivide, to get a smoother result (as your object would be approximated at a higher resolution).

Having said that, don't consider the subdivision taboo and absolutely neglect it. Usually it is good practice to check the topology of your mesh, every once in a while, by subdividing it and seeing if it flows and looks natural... this way you can also spot duplicate vertices or holes in the mesh.

I am not a pro modeler and maybe someone could argue this is not always the case, however those are some tips that help me.


Show transparent viewport image (via script)

Your second idea works!

Use the "Import images as planes" option (activate addon in preferences) or make Empty and set display as image.
Then make a dummy camera and parent it (keep transform) to you image plane
Activate textured view and make sure that in Materials -> Settings you set Blend mode to "Alpha blend" (or use alpha is activated if you used an Empty as Image)
You can use +/- to zoom camera border, so its no longer in view. (changing the zoom here works only while camera not locked to view)
Make the plane "unselectable" (by clicking cursor symbol in Outliner) otherwise you will always select the plane if locked to view ;)
Finally activate "Lock Camera to view"

And you're done!
Here is my implementation:

+

Here is the same procedure in Code:
PS: However there is a small TODO section for setting the 3d view to the Camera view in script, which i havent quite figured out how to do yet

import bpy
from mathutils import Euler ##For Rotations

######Deletes all Objects in default blender startup
bpy.ops.object.select_all(action='SELECT')
bpy.ops.object.delete(use_global=False)
######
########### Make Objects you need: Camera-Dummy and Empty as Image (and set it as parent)

imgEmpty = bpy.data.objects.new("myImgEmpty", None)
scene = bpy.context.scene
bpy.context.collection.objects.link(imgEmpty)
imgEmpty.location = (0, 0, -1.5)
imgEmpty.rotation_euler = Euler((0, 0, 0), 'XYZ')
imgEmpty.empty_display_type = 'IMAGE'
imgOverlay = bpy.data.images.load("C:/Users/robert/Desktop/Installers/2019/blender-2.80.0-git.d30f72dfd8ac-windows64/TestOverlay.png", check_existing=True) ##### CHANGE PATH !!!
imgEmpty.data = imgOverlay

bpy.ops.object.camera_add(location=(0, 0, 0), rotation=(1.5708, 0, 0)) ##90deg in radian
dummyCamera = bpy.context.view_layer.objects.active
layer = bpy.context.view_layer
layer.update()

imgEmpty.parent = dummyCamera

###########
################ Set 3d view to Camera view and Zoom

   #TODO ;)

################
##################### Set camera to Lock camera to view and Set 3d View to Textured view
for area in bpy.context.screen.areas:
   if area.type == 'VIEW_3D':
      for space in area.spaces:
         if space.type == 'VIEW_3D':
            space.lock_camera = True
            space.shading.type = 'MATERIAL'
#####################

Happy Blending!


It's impossible to tell what's going wrong in your particular case as there just isn't enough information in your question - you've only partially shown the 'internal' node tree (many of the nodes are hidden, meaning it's impossible to verify that they aren't marked as 'Clamped' and left assuming that, say, 'Root' is raising to the power of 0.5) and you don't show any detail of how the group is actually being used (it's hinted at behind your 'group' nodes but nothing explicit) - which is quite critical.

However, it is possible to produce such a result as shown below (assuming I've got my maths correct). The example image you provided must have been produced with a large number of iterations of the calculation - which would take a considerable amount of time to render. For my example I have limited it to a relatively small number of iterations to demonstrate the concept.

Firstly, rather than manually generate the node structures for the calculation I have created an add-on to generate the nodes directly from an entered expression (it's something I've been meaning to do for quite some time - building on the answer Cycles Materials Math node with more than two inputs). This add-on parses the entered expression and automatically generates the required nodes in a node group - this allows different expressions to be more easily tested since the expression can simply be edited. The add-on can be downloaded from https://github.com/baldingwizard/Blender-Addons - simply download the ZIP file and use Blender's User Preferences/Add-ons/Install Add-on from File to install, enable it, and Save User Settings. You should now have a new Custom Nodes menu in the Node Editor 'Add' menu that lets you add a Dynamic Maths Expression node. Entering an expression into the Expression field will automatically build the required maths nodes in a corresponding node Group. Since the expression is built from standard nodes it is fully GPU compatible (unlike an OSL solution). Note that the add-on is currently a work in progress and may contain rough edges (and I have some ideas for future improvements) - I'll tidy it up and file off any rough edges in due course but for now it shoul dbe reasonably functional.

With the new Dynamic Maths Expression node you can create the node trees for each of the functions by simply entering the relevant expression. For example,

'r' :
    (x**2+y**2+z**2)**0.5

This automatically creates the following nodes behind the scenes :

Similarly, 'theta' :atan(((x**2+y**2)**0.5)/z)

And 'phi':atan(y/x)

We can then use a similar technique to create expressions for 'newx', 'newy', and 'newz' :

newx = (r**n)*sin(n*theta)*cos(n*phi)
newy = (r**n)*sin(n*theta)*sin(n*phi)
newz = (r**n)*cos(n*theta)

These can then be linked together to form the following node group for the calculation of one 'iteration' :

Note that some of the inputs are fed directly out to the outputs - this is to assist with linking mulitple iterations together. Also the 'Valid' input/output is modified based on the condition that the result of this node is detected as 'outside range'. This is to detect the termination of the series at the specific iteration - if any iteration is out of range then we need to detect it rather than taking acount of any subsequent iteration. Only those 'points' in the volume that successfully pass through all stages of the iteration are rendered as 'solid' (ie, part of the 'bulb'). The more iterations applied the more complicated the final surface (but the more complicated the calculation - so considerably longer render times).

The individual stages are linked together as follows :

Note that one group node is required for each iteration of the calculation (the more iterations, the more complicated the resultant surface). The 'n' setting dictates the 'order' of the mandelbulb (in this case '3').

In order to render as a well defined volume you will need to multiply-up the result to generate a reasonable Density (eg, 100) and use this in a Volume material similar to how you would for smoke. You will also need to significantly decrease the Volume Sampling Step Size parameter in the Render properties from it's default of 0.1 to, say, 0.005 or lower (this defines the resolution of the volumetric) - this will produce a more detailed result but will significantly affect render times.

This can produce the following results :

Blend file included (you'll need to install the add-on to activate the Dynamic Maths Nodes)

Here is a further example - this time an 8th order mandelbulb (by setting 'n' to 8) with additional Iteration nodes in the chain to add detail (I used 16 iterations for this - ideally you'd use many more). This took approximately 3 hours to render on my system - it would fare a lot better on a system with GPU support (which I don't have).


How work with CAD 'stl' imported object files

I just tried it with an STL file, and it works fine for me.  Steps I used:
1. File:Import:STL
2. Select file and import
3. Select the newly imported object (right click)
4. In the materials panel, add a new material
5. Check the transparency panel
6. Change alpha slider to desired transparency


How to set Blender to use identical controls as Unity?

Yes, you can remap the controls. Press Ctrl + Alt + U, or go to the Info Header>File>User Preferences, to open the User Preferences; Then, switch to the edit tab and edit away!

You might also want to take a look at existing presets; However there isn't any for Unity controls...


Blender eats up all memory and crashes upon simple small texture

Finally i have solved this issue on Windows 10. The problem was a driver corrupt file on my case.... I made a clean installation of the drivers and Blender now stays at normal rates. Between 180 MB and 200 MB of RAM.
I had this problem in Linux but I updated my drivers from Windows(dual boot) and problem was solved


Subdivision failed on boolean-subtracted object

It is not always efficient to use boolean tool when you are using subdivision. Subdivision demands good topology especially on curved even surfaces and boolean often needs cleanup afterwards. This is how I do it.

Enable the LoopTools add-on.

Create a cylinder with sufficient amount of faces to hold your holes without deforming too much. Divide your cylinder so that faces are square and even.

Select at least a square of four faces (2x2, 3x3 etc).

Run Specials menu (w), LoopTools, Circle. This will make the circles perimeter to be arranged in a circle. Make sure to uncheck the "flatten" option (you will want the circle to be curved on the surface).

Inset the selection a tiny bit to create a support loop around the hole and then delete the inner faces.

Add a solidify and a subdivision modifier and configure then to your needs.

Add other needed support loops and delete unneeded loops. If you need you could apply the solidify modifier and add extra support loops on the rim.


You need to set the context's area type first, run the folowing script from the text editor not from the console:

import bpy
area = bpy.context.area.type
bpy.context.area.type = 'IMAGE_EDITOR'
bpy.ops.transform.translate(value=(-0.209548, 0.232831, 0), constraint_axis=(False, False, False), constraint_orientation='GLOBAL', mirror=False, proportional='DISABLED', proportional_edit_falloff='SMOOTH', proportional_size=1)
bpy.context.area.type = area

Related

Python - move UV for selected items