Since there are no further answers: no, this doesn't work out of the box. Converter misses many nodes and some Nodes like "Light Path" are not possible to keep, if you want to use bidirectional path tracing. Node editor in Lux shows a warning sign near the nodes which were not correctly converted. To keep track of the conversion, one should run Blender in Terminal, as errors and warnings will be printed there.

Apart from that, many things can go wrong. The textures packed in .blend won't be loaded, multiple render layers are likely to be a problem.


It is possible to deform a mesh grid with Depth Map or Point Position Map to create the scene geometry with the help of the Animation Nodes + Extra Nodes as well as the Shader Nodes.

Method for Depth Map with AN+EN:

Render the Color Map and Depth Map (must with OpenEXR) with OpenEXR format,

We need to create two grids, one grid (Mesh Grid) is scaled according to the aspect ratio of the depth map. The second to evaluate texture from the Texture Input node (In Texture Properties, set the mapping to clip or extend), and this is a square grid (2x2) because the texture is displayed with square aspect ratio in the world origin. So, I created them a group node so that we can cache them:

Then added resolution input for extra control:

This how these grids look (green for geometry, white for texture)

Now, the Mesh Grid points scaled texture aspect ratio but we have scaled these points using the camera distance factor and depth scale (from Texture Input node), that will give correct X, Y coordinates (as shown by @WhatAMesh in his answer).

The Z coordinate will be the negative of the depth map to deform toward the camera,

Now the points of Mesh Grid are deformed correctly. Now, to align them correctly with respect to the camera, we have to transfer them according to the camera,

Then combine points (from Step 3) with the Edge Indices and Polygon Indices to get a deformed Mesh Grid. I also added the UV map to the mesh Grid, so that we can use it for the camera projection of the color map.

The Mesh Grid is perfectly matching with the actual scene geometry.

Complete Node-Tree,

For the color map, use the UV Project modifier and set the scale according to the aspect ratio. Then in shader nodes use UVs to assign the color map to the Mesh Grid,

Blend File:

Method for Point Position Map with AN+EN:
This is very simple as compared to the Depth Map Method and faster.

To render the point position map of a scene: In Shader Nodes, the Geometry node has a position pass that contains location (X, Y, Z) info for each point/pixel of the geometry. So, use this shader-node setup, and override the material of the whole scene to get the point position pass. Then render this as an OpenEXR image,

Now, we need pixels info of point position that we can't get with the Texture Input node because these values can be negative. So, use the Expression node to get info for dimensions and pixels from the texture. Then, we create Mesh Grid but with swap X, Y divisions to get the correct order for edge indices and polygon indices for pixels or location(X, Y, Z) of points from the pixels. The pixels from the Expression node in a single list so we have to use the Slice List to get R, G, B values or X, Y, Z:

Edit - Low-Resolution Grid:
We can generate a low-resolution mesh grid by resampling the high-resolution grid with the help of KDTree nodes. The Find Nearest Point node outputs the indices with that, we will get the points/vectors of the high-resolution mesh grid (in this case vectors from pixels) that is near to the low-resolution mesh grid points. Here is the group node,

Now, we have to replace the Mesh Grid with this group node and set the cache to One Time which is important for performance,

For the color map, do Step-5 of the Depth Map Method.

Blend File:
Blend File For Low-Resolution Grid:

Method for Point Position Map with Shader Nodes:

First, render the Point Position Map as mentioned in Step-1 of Method for Depth Map with AN+EN

Change the render engine to Cycles and feature set Experimental. Add a square plane in the world center

Then subdivide it for few times, and add the Subdivision modifier with Adaptive Subdivision option is enabled,

In the Shader Nodes, Options > Settings > Displacement to Displacement Only. Then use the Point Position map (In Image Input node, set the mapping to clip or extend) as a vector displacement as shown below, (In Render View)

Blend File:


Does Blender support texture with straight alpha

This behaviour seems to be internal, so no easy way to modify it.
But a way to facilitate that duplication process is to instead of duplicating the texture file itself, duplicating the Image datablock that references the file inside Blender.

Create the Image Texture node as usual and duplicate it, and then click the user number to make a new copy of the Image datablock -- they will both reference the same file but have separate Use Alpha settings.


A fluid simulation uses a certain number of divisions to determine the resolution of the fluid. The number of divisions is related to the domain size in that 1 division will be 1/Domain Size blender units. Therefore scaling up the domain will make each division larger, so your fluid will be less smooth when you scale up the domain.

To make your fluid smoother, select your domain object and adjust the resolution values in the physics tab in the fluid settings. If you are looking for the exact same resolution as you had before, multiply the current resolution value by the amount you scaled the domain (if you scaled the domain by 2, multiply the resolution by 2, etc.). Blender allows you to do math equations in the input boxes as well so it should be fairly easy.


The smoke domain is completely filled with smoke

That is normal. As long as there is no simulated smoke, the complete volume of the domain is filled with the volumetric material.


For anyone else having this problem I fixed it by first make sure you have no keyframes. If there are none and your object still resets position on render position your object how you want it than add that position as a keyframe.


How to add a group into a node tree with Python

After adding the new node group node you can assign the node_group data type to the node_tree:

group = node_tree.nodes.new("ShaderNodeGroup")
group.node_tree = bpy.data.node_groups['OldNodeGroupName']


Script that supposed to change value of the text is only working on viewport

I looked at other results and I applied their examples to my code.
I added this variable in my TimeCounter function, that gets evaluated value from custom property.
eval_text = TextObject.evaluated_get(depsgraph)
and also changed def TimeCounter(scene): to def TimeCounter(scene, depsgraph):
And in the end this script was here to recompile the results,
    bpy.app.handlers.frame_change_post.clear()
    bpy.app.handlers.frame_change_post.append(TimeCounter)

def unregister():
    bpy.app.handlers.frame_change_post.remove(TimeCounter)

if __name__ == "__main__":
    register()

It also works without this long code.
bpy.app.handlers.frame_change_post.append(TimeCounter)

Here's full working code:
import bpy

scene = bpy.context.scene
TextObject = scene.objects['TimerText']

def TimeCounter(scene, depsgraph):
    eval_tex = TextObject.evaluated_get(depsgraph)
    value = eval_tex.data['time']
    min = int(round(value/60, 60))
    sec = value-(min*60)

    TextObject.data.body = 'Time ' + str(min) + ':' + str(sec).zfill(2)
def register():
    bpy.app.handlers.frame_change_post.clear()
    bpy.app.handlers.frame_change_post.append(TimeCounter)

def unregister():
    bpy.app.handlers.frame_change_post.remove(TimeCounter)

if __name__ == "__main__":
    register()


I have rendered my Blender Intro and it saved as a .avi file but I cant open it?

Try rendering as png sequence images then editing them together in the Video sequence editor... this way you can try different formats without having to render all the work again ;-)


How can I disable bpy.ops.convert objects sorting?

Run the operator once for all curves

I imagine you are getting poor performance because you are running the operator for each curve object, rather than once for all.  See Python performance with Blender operators

Suggest selecting all the curves in scene, and running the operator once, example test code.

import bpy

context = bpy.context

# select only curves
for o in context.scene.objects:
    o.select = o.type == 'CURVE'

curves = context.selected_objects
if curves:
    # just in case context object not a curve
    if not context.object.select:
        context.scene.objects.active = curves[0]
    # convert them all
    bpy.ops.object.convert(target='MESH')

As for the sorting, that's just what blender does in its background processing, and is I doubt responsible for slowing down your blender.

There is also the Object.to_mesh which can be used to convert the curve to mesh without using the operator. However in this case I think selecting all curves and converting with one operator call is sufficient.


All you need to do to get an image to repeat in a Cycles material is add a Vector > Mapping node between the Texture Coordinates and Image Texture.  Set the Mapping node to Texture at the top and set any of the Scale: values to less than one to make the image repeat along a certain (or multiple) axis(axes).

The other option, without adding any other nodes, is to simply scale up the UVmap in the UV/Image Editor. A UV map larger then the image will make the image repeat.


Looping walk cycle animation snaps back on repeat

Oh dear, I feel kind of stupid but also so glad I worked it out.

So this is the setup that works.

Action 1: walk - in-place walk cycle

Action 2: moveForward - moving the root bone in time with the feet to avoid slipping. F-Curve modifier set to repeat with offset.

Convert both animated actions to action strips on the NLA editor. Here's where I was going wrong and what to do right. I was setting the repeat value on both strips. This worked for the walk cycle which has the same start and end frame so the "snapping back" isn't noticable but caused the character to walk forward then snap back at the end of each forward motion cycle. In essence it was only repeating the first F-Curve and ignoring all the future repeats with offset. To fix this I set the repeat value on moveForward to 1 and then set the end frame to what I wanted. This then allows the character to keep moving forward, applying any extrapolated future F-curve repeats to the motion. This also allows for extra animations to be layered on top.

For example if you have a walk cycle that's 25 frames long and you want the character to walk straight for 10 seconds (assuming 25 fps) you can set the walk action repeats to 10 and the end frame for the moveForward action to 250 frames (leaving the repeats and scale to 1).

I now realise that this is pretty much exactly what Adhi said in the other question I linked to but it didn't quite make sense to me for some reason. Anyway. I hope this will prove a useful tip for anyone else stuck on a similar looping animation problem.


Sound export in 44100 Hz instead of 48000 Hz, why?

The sound frequency for the project is set here:

change it to 48000 Hz.


Make sure Global Undo is enabled.
For 2.8x and 2.9.
Edit > User preferences > System > Memory & Limits: Global Undo

For 2.79 use
CtrlAltU > User preferences > Editing > Undo:

That panel is called the redo panel, because when you change a setting on it, blender actually redoes the previous operator with the new settings.
If blender can't undo the previous operator first, running it again will add it's effect on top of the result of the previous operator (which is not the desired effect at all).
So this panel is disabled when undo is not available.


I solved the problem! It was mcprep! The function prep materials made the skin glitch when improve gui wqs activated


I've found what it is. Turns out that while the MakeClothes exporter allows all tris or all quads, Makehuman only works with all quads.  As such, all meshes need to be quads for MakeHuman to work properly.


How do I attach a few cubes via script. Blender 2.79. Pic =>

Download the blend file and test the script (updated)

in order to parent the cubes

import bpy

def conectando(vertice, objeto):
    cd = main.data
    cd.vertices[vertice].select=True
    bpy.ops.object.mode_set(mode = 'EDIT')
    bpy.context.scene.objects[objeto].select_set(state=True)
    bpy.ops.object.vertex_parent_set()
    bpy.context.scene.objects[objeto].select_set(state=False)
    bpy.ops.object.mode_set(mode = 'OBJECT')
    cd.vertices[vertice].select=False

print("*"*50)

#get active object
main = bpy.context.active_object
mat = main.matrix_world

bpy.ops.object.mode_set(mode = 'EDIT')
bpy.ops.mesh.select_all(action='DESELECT')
bpy.ops.object.mode_set(mode = 'OBJECT')

vertices = [v for v in main.data.vertices]

conectar=[]
for ob in bpy.context.scene.objects:
    if ob.type == 'MESH' and not ob.name == main.name:
        # select object in order to join at the end
        #ob.select_set(state=True) # select object in order to join at the end
        distance = []
        for c in vertices:
            v = c.co
            loc = mat @ v #matrix world of vertex co
            distance.append([(loc-ob.location).length, c.index, ob.name])

        distance.sort()
        conectar.append(distance[0])

for c in conectar:
    conectando(c[1],c[2])

import bpy

print("*"*50)

#get active object
main = bpy.context.active_object
main_coords = [(main.matrix_world @ v.co) for v in main.data.vertices]

#move other mesh objects to nearest location in active object
for ob in bpy.data.objects:
    if ob.type == 'MESH' and not ob.name == main.name:
        ob.select_set(state=True) # select object in order to join at the end
        distance = []
        for c in main_coords:
            distance.append([(c-ob.location).length, c])

        distance.sort()
        ob.location = distance[0][1]
        print(distance[0][1])
            #$print(ob.name + str(tuple(ob.location)))

#join all objects
bpy.ops.object.join()


Your mesh is high-poly, which will make rigging and animations more complicated imho, but what you could do is join the helmet to the rest of the body (CtrlJ), remove its vertices from all groups and assign them to the vertex group called spine.006 which is controlled by the head bone:


This Python script will step through your frames in reverse and render them one-by-one. Save as render-backward.py:

import bpy

for frame in range(bpy.context.scene.frame_end, 1, -1):
    bpy.context.scene.frame_set(frame)
    bpy.ops.render.render(write_still=True)

Run it like so:

blender yourfile.blend -b -P render-backward.py


How do I get other angles in orthographic view?

You can use the Numpad keys to freely switch from perspective to orthographic views.

Numpad 5 toggles perspective/orthographic view mode without changing your camera angle.


Try to use the boolean modifier set to add and then fix the topology manually using the knife tool


Intersection of Particles in a Hair Particle System

I'm not sure there's a way to avoid particle overlapping (except maybe with the help of this tuto?), but you can:

Create several buildings, texture them. Put them into a collection called Buildings:

Create a plane (let's call it Generator) and give it a Particle System > Hair, activate the Advanced option,  choose the collection you've created as particle, give it an Emission > Number of 20:

In the Modifier panel > Particle Settings, click on Convert. It will generate instances, reorganize them so that they don't overlap, select all, make the objects single users and join them with J to create an object:

Come back to your Generator plane, generate a new combination, vary the Emission > Seed and the Render > Use Count settings so that it differs from the previous combination. Do the same as before in order to create a second object. Do it again several times, put all these objects in a collection called Master.

Create a new plane, subdivide it for example 10 times, give it a Particle > Hair, activate the Advanced option, choose Master as its particle, give it an Emission > Number as high as you have faces on this plane. In Emission > Source, deactivate Random Order, choose Particles/Face = 1.


The reason this mesh has strange shading is because of the topology.

Polygons which are made of more than 4 vertices are called ngons. These ngons are pretty extreme in your mesh as you can see. While ngons have their place (on totally planar faces) if an ngon face has even the slightest twist, then it will cause horrible shading.
This is why in 3D modelling (especially for beginners) people avoid ngons and aim to keep faces consisting of no more than 4 vertices, which are called quads.
Another way to make these kinds of stylized rocks is to add a cube. Subdivide it with constant detail and then enter sculpt mode.
With the scrape brush, you can scrape away at the faces of the heavily subdivided cube to get nice flat edges.
Once you're happy with it, you can leave sculpt mode and then add a decimate modifier and decimate the rock to reduce the polygon as much as possible (lower the value in the slider to somewhere near 0.01).
The decimate modifier will retain the detail best while keeping the shading looking the best. Once you find a happy medium between detail and polygon count, you can apply the decimate modifier and move on to UV unwrapping and later texturing.
This is how I make stylized rocks.
Hope that helps! :)
I just added a rock I did just now.
https://www.dropbox.com/s/rcbo7lwoyoetbln/RockSculpting_Demo.blend?dl=0
I just rushed this so with a bit more time and effort put into it, you could get something looking nicer but hopefully it'll give you an idea of how the topology should look.


If you choose Flow, you can immediately below that choose Flow Behaviour under Settings, there you have Inflow as an option.


It looks like a few objects in the model had "mesh cache modifiers" which were affecting the geometry in order to create the animation.

I followed the instructions on this answer to "bake" the mesh cache into regular animation steps. I used this .pc2 importer add-on to use the point caches that had been provided to me; exporting them to .mdd and then importing again did not work.

Once that was done, I exported to a COLLADA file but it was huge—80 MB. I applied this trick to merge animations into one. But the animation does not work yet.


bpy.data.meshes.new gets slower and slower

Not a real answer, but more of a workaround : I manually merged the meshes by fiddling with the vertices arrays. So instead of creating 3000 meshes, I create only 1. Works in my use-case.

If it can help someone else, it looks like this:

lAllVertices = []
lAllTriangles = []

for fileToParse in allFilesToParse:
    lVertices, lTriangles = ParsePolygonalRep(fileToParse)

    # Before extending lAllTriangles, fiddle with the indices
    lCurrentIndexCount = len(lAllVertices)
    lTriangles = [(x+lCurrentIndexCount,y+lCurrentIndexCount,z+lCurrentIndexCount) for x,y,z in lTriangles]

    lAllVertices.extend(lVertices)
    lAllTriangles.extend(lTriangles)

lMesh = bpy.data.meshes.new(lMeshName)
lMesh.from_pydata(lAllVertices,[],lAllTriangles)
ob = bpy.data.objects.new("tmp", lMesh)
bpy.context.scene.objects.link(ob)


Yellow selection outline not appearing in solid 3D view

Blender doesn't show the outline for transparent objects in the viewport.

Remove transparency in your material to make the outline visible again.


mirrored mesh not showing up in edit mode

In the Properties Window > Modifiers Tab > Mirror Modifier look for the button on the top that reads Display Modifier in Edit Mode, the one with the cube with four vertex highlighted.


Need Help making a frosted light Bulb material

Overview:

I'll show you two methods with their pros and cons. One of them are using Cynicat Pro PBR Nodes and the second one is created by myself. As pointed by @cegeton you'll need some kind of environment to see reflections in light bulb. Try HDRI maps.

Both setups are using same masking method so I'll start with that.

Mask:

Mask is for the transition between clear glass and frosted/milky one.

You can control position of this transition and sharpness/smoothness.

My method:

My setup is using simple mix of Translucent and Glossy shader by Layer Weight.

If you want to have less/more reflection you can tweak Layer Weight Blend value.

Pros: It's good if you want to have it completely off (no light emission) and also works with light source inside.

Cons: It's pretty "heavy" to render, note amount of noise in final render.

Method based on Cynicat Pro PBR:

After downloading file from link in overview, append from it two Materials - Light and Glass. Then set Light as your object material and modify it accordingly to the image. PBR nodes are in Add > Group in Node Editor.

Pros: It look awesome. It's really fast. It's easy to manipulate.

Cons: It need to be always turned on. Emission value should be higher then something around 0.2, otherwise material is black.


How to give the color texture "light"-gloss instead of just lighten up the color of the pattern?

The best way to test metallic or mirror reflections is to have something to reflect. Perhaps the material IS reflecting correctly.

Use an HDRI environment or other method to create a known environment with light sources, colors, etc. Then you can better judge if the material is behaving correctly to metallic shaders.


Subdividing a mesh into convex subvolumes and tagging faces

1a.  The technique you are looking for is called Convex Decomposition and there is a fair amount of research on it.  It's good for skeletonizing meshes for rigging, and I'm sure many other useful things.

http://masc.cs.gmu.edu/wiki/ACD

1b.  I do not believe there is any way to do this automatically in blender natively.

1c.  There is an addon to do this volume decomposition in blender, it relies on external code library and is more targetdd at the game engine however you may be able to tailor it's results to your needs.  This is an approximate decomposition.
http://blenderartists.org/forum/showthread.php?357513-Volumetric-Hierarchical-Approximate-Convex-Decomposition-%28e-g-for-BGE-Physics%29

2a. If your method is actually going to create interior geometry in the same mesh, then finding the non manifold edges and then interior faces is not a big deal. However my answer above is going to create approximate new objects

2b.  If you are able to split your mesh into groups of verts, using the bmesh convex hull modifier will tell you what new geomtry it creates.  By the definitition of your problem, all the new geometry will be the


How to return view window back to original location

Look here: Workspaces and use the Next button at the bottom to see more detail. Should answer your questions.


Select both the object and the node with the animated property:


Following the previous comments, I would suggest to try the following :

Select the object in object mode
In the header menu, go to Object -> Shade Smooth
Try to adjust the normal smoothing by going into the properties panel, in the object data properties, and enable the auto smooth + try increase the default value


What tool can I use to explore a scene created with blender?

You could put it on Sketchfab or just place it in Unity with the standard  player model


BGE: How do I make a sensor of one object trigger an actuator of another object?

Add a collision sensor in the button. There are 2 options there:

collision with the material of the player and
collision with a property that you can add to a player.

Then add an action actuator to the door. Remember that you should add the animation actuator to the object that is gonna get animated.

At last, connect them by dragging the "noodle" from the end of the sensor of object 1 to the start of the actuator of object 2. Remember to have them both selected so you can see both their SCAs.

In case those 2 can't be connected add manually a controller "And" and drag the noodle from the sensor to the start of the controller, and then drag the noodle from the end of the "And: controller to the start of the actuator.


How do i copy and paste and objects location,rotation and scale at the same time

With the 'camera' object selected, go to the 'dope sheet' editor window. Select the key-frames you want to duplicate and press Shift+D. Then press G to grab and drag the new keys to the desired frame. Hope this helps..


Try delete brush and create new. That worked to me.


Unit direction vector.

Suggest doing this without the transform matrix. The direction vector

>>> d = Vector((1, -1, 0))

can be normalized, ie have a length of one, to

>>> d.normalize() # in place normalize
Vector((0.7071067690849304, -0.7071067690849304, 0.0))

Now, given a source location point p can move from p x units in the direction d using

new_loc = p + x * d  # x is a scalar.

In the context of your original question

import bpy
import bmesh
from mathutils import Vector

me = bpy.context.object.data
bm = bmesh.from_edit_mesh(me)

p = Vector() # using origin as source point.

vec = Vector((1, -1, 0))  # direction vector
d = vec.normalized()  # unit direction vector

newverts = [bm.verts.new(p + x * d) for x in (1, 1.5, 2)]

bmesh.update_edit_mesh(me)


How to update appended object/armature, while keeping existing animation?

select your old armature. In armature settings, change the armature data with the new one.


If when exporting your asset you let the bake animation enabled and the sampling rate on 1, then it should put keys on each frame of your animations, removing any interpolation and negating the effects of key type change.
I forgot to mention, Blender's FBX exporter does a keyframe cleanup in its baking, which you might want to remove by setting the "simplify" to 0.


Cut doesn't work on particular angles view

It's not too tough to solve this problem by switching to perspective view. This helps keep the knife from "catching" on geometry that you cannot see.


This is possibly easier to achieve in post production through the compositor.

You probably don't even need Cycles or "formal rendering" for somethning this simple. You can use the *OpenGL Render active viewport" or animation at the bottom of the 3D view.

Then add the glow effect and colors as desired in the compositor. You can use a Filter > Blur or a Filter > Glow node for this.


How to get a hover craft effect (Object over Landscape)?

Shrinkwrap constraint is pretty good for this,  to control how far your object is from the ground you can simply lift it in edit mode to move it's origin downward.


Assigning a python command to a mouse hotkey

open User Preferences -> Input
open some category and click Add New button
insert hexblender.adjust_nodes_linear into the input field
assign some keyboard shortcut
test the keyboard shortcut and if it works, use the X-Mouse Button Control application to set your mouse button action to trigger your keyboard shortcut


What is the difference between IK and FK in animation on blender

With inverse kinematics (IK) the hands and feet will keep their position when the body is moved. When you switch from FK to IK you need to enable the layers for IK also.

FK and IK have different control bones (custom shapes) for both modes. With IK you control the pose with the large plate shaped widgets at the hands and feet.
The lines you see are pole targets and allow to control the position of the knee or elbow.
IK example

With forward kinematics (FK) each bone from shoulder to wrist needs to be adjusted. This is exactly how bones can be moved right after creation.
FK example

Movement with arms still set to IK but leg to FK
Rigs like Makehuman or MHX allow you to switch from IK to FK separately for the legs and arms. You can even control the influence of the FK/IK controls.

The snap buttons allow copying from the IK position to FK and vice versa.

Here Rigify

MHX


You may try that

Select both objects, hit Ctrl + J
Select the two or more vertix you want to be combined
Hit Alt + M
From Pop up menu, may select, At First, At last etc as required

Best of luck !


How can I push down actions to nla strips with python?

I have the answer:

I don't Need to go to nla-editor, I just add a new track and a new Strip with the Action, which I get from my object.

for obj in bpy.context.scene.object:
    if obj.animation_data is not None:
        action = obj.animation_data.action
        if action is not None:
            track = obj.animation_data.nla_tracks.new()
            track.strips.new(action.name, action.frame_range[0], action)
            obj.animation_data.action = None


Archimesh export as fbx leaves large box on windows and doors

The box is used by the boolean modifier to cut the hole in the wall for the door/window. After you have applied the modifiers, you can delete the objects called "CTRL_hole" to keep them from being exported.


Scale center points

You can manipulate the center points of the objects by enabling the little icon with the double arrows next to the pivot center select.

By setting the 3D cursor as pivot you'll be able to Scale not the object, but only it's center point location on the needed axis (X firts and then Y in the example shown below):


Change the collision distance. There are distance settings in the Cloth, and also in the collision object. The total distance will be the two combined. Try adjusting both.


Scaling:
If you plan on scaling the characters at different scales for different scenes then I would Follow Jaroslav's advice.
However if you just found out they were not scaled ideally and now that you see them together in a scene you want to adjust them permanently, you should go back to each characters rig file and make the adjustments there, this way you won't need to worry about factoring scale of your characters when you try to animate them in your scenes. Having to deal with scale factor of your character may complicate your animation process, or give unexpected results when running certain scripts if you use those...

LipSync:
You definitely want to set up the phonemes in the rig file of each character (think of them as the poses the face of your character can do always: A, E, I, O, U, BVF, smile, angry etc...).
In your scene file you should only worry about animating those existing face poses to match the dialog of that scene. If you find you need to add some expressions, go back to your rig and add it there, that way it will be available for any scene you want to do in the future. Your character rig will get more powerful as you add expressions to it.


Composite output window differs from viewer

It appears you are using blender 2.8. In blender 2.92, the set alpha node is updated to allow apply mask mode. To fix this, drop an alpha convert node after the set alpha node. Make sure it is set to convert straight to premul. That should fix your alpha problem.


Why does the mirror modifier sometimes give me an overlapping mesh?

The reason you're getting an overlapping mesh is because the Origin point of your object is offset from the center line of your model. The Mirror modifier uses the origin to determine the symmetry line, so to fix the overlap, you need to move the origin back to the centerline of your mesh.

You can do this one of two ways.

Method #1. Move the mesh back in line.

You can move the mesh manually back to the center by grabbing it in Edit Mode and moving it along the respective axis (in this case the X-axis) until the center vertices are lined up with the object origin.

This is not generally an ideal method, though, as it can be difficult to aline the center vertices perfectly without employing other steps. I recommend method #2.

Method #2. Move the object origin.

The second way to correct this problem is to move the object's origin back to the center of the object. You can do this in a couple steps:

1. In Edit Mode, select the center vertices and press Shift + S and choose Cursor to Selected.

2. Next exit Edit Mode with Tab.

3. Now press Ctrl + Alt + Shift + C choose Origin to 3D Cursor.

4. Problem solved!

Preventing this in the future

What you need to keep in mind is how the object origin moves. Anytime you move the object in Object Mode the origin will move with the object.

However, anytime you move the mesh in Edit Mode the origin will stay put. The reason for this is because moving the mesh is not actually moving the object, you're simply moving the data that belongs to the object.


imported glb file is hollow, how to fix?

The problem you are having is easily overlooked, and is found in your material settings.
You have backface culling turned on, and not all faces are facing the same direction giving you the strange result you are seeing.

Turn off backface culling and this should fix the problem.


Subdivide and re-weight parallel/sibling bones? (or, how to deform-rig lips)

You can simply select the armature, in edit mode use shift D to duplicate some lips bones, place them where you want them (the duplicated will have the same parent-child relationships), then in pose mode select all lips bones, go to object mode, shift select the mesh, go to weight paint mode and use the weights menu "Automatic assign from (selected) bones".
Make some manual weight adjustments if  needed.


How to acess and change solid OpenGL lights settings via python?

If you hover the color boxes with the mouse cursor you will find that the responsible python struct is UserSolidLight with the following properties

  base class — bpy_struct

  class bpy.types.UserSolidLight(bpy_struct) Light used for OpenGL
  lighting in solid draw mode

  diffuse_color Diffuse color of the OpenGL light

  Type: float array of 3 items in [0, inf], default (0.0, 0.0, 0.0)

  direction Direction that the OpenGL light is shining

  Type: float array of 3 items in [-inf, inf], default (0.0, 1.0, 0.0)

  specular_color Color of the light’s specular highlight

  Type: float array of 3 items in [0, inf], default (0.0, 0.0, 0.0)

  use
  Enable this OpenGL light in solid draw mode

  Type: boolean, default False

According to the Python API Documentation


I cannot pose my humanoid, even though it is rigged and parented

while in object mode, select your object shift select (add select) your bone armature, then hit ctrl + p, with automatic wheigths.
But before you do this apply scale (ctrl+a) for both mesh and bones, people often forget it and that gives a lot of problems


I got it now. If the magnet is active and snap to vertex is selected you need to hold and drag mouse to snap nearest vertex. If you just click it doesn't work.


Boolean operation destroying topology-deleting faces

So, First, you have overlapping vertices.
Select all your vertices with  A  in edit mode and vertex select mode, and Press  ALT  +  M  > by distance in order to eliminate double-vertices.

The real problem is you have 3 inside faces which mess up your boolean operation. Notice how in wireframe view, some faces have a clearer shade of grey. That means there are faces which shouldn't be there. Also note that there are some issues in the leg of the chair, but you will be able to fix them with the same technique :

In edit mode, select faces around the 3 culprits and press  H  to hide them. Then go in face select mode by pressing  3  , and select them. You have to select next to its little dot which may or may not be easily visible. Press  X  to delete, then select "only faces".

When all the culprit faces are deleted, while still in edit mode, press  ALT  +  H to unhide your geometry. Result :


Net Render Outputs Black .exr Files, Regardless of Selected File Type

While multilayer OpenEXR files are a useful way to keep all the render results in one file, not every application supports them.

An easy way to get render output that can be used outside of blenders compositor is to save each part into a more compatible file, blenders file output node is useful for this.

As shown in the node properties, each output file can have it's own file format and any compositing can be included with the output.


Can I transpose along a single axis and have the other frames in between move accordingly without damaging the animation

Use the graph editor, F-Curve View.

First select all Bones (Pose Mode) and all Objects (Armature in Object Mode) in the scene you want to manipulate, so that you see all Channels in the Left Panel of the Editor.

Then mark all Keys you want to move (e.g. Select -> After Current Frame)
Now you can move the keyframes with "G" and "X" on the X Axis (unit 1 is one frame).
ATTENTION! Ensure that no channel is marked as "not visible" (Eye closed)

If you want to move all keyframes of the scene, so turn off the Selection "Only include channels relating to selected objects and data"


best practice for add-on generation with many functions single file or split it up?

In my opinion you should always use multiple files for non-trivial addons (e.g. more than one operator).
I agree that it can be complicated in at first and I have to admit that it took me quite some time until I was able to create multi-file addons in a nice way.
BUT, a few months ago I developed an addon template for my Code Autocomplete addon that allows you to create multi-file addons very easily. Without having to care about reloading etc.
Since then I always use this template. Even as large addons as Animation Nodes and Code Autocomplete use it (and some others as well, e.g. this one).
Here is how I setup a new addon:

Create a new folder in Blenders addons directory. It's not super important but I suggest to use a name that can be a python identifier and all lower case.

Inside of this folder I create a _ init _.py file with this content.

Create a developer_utils.py file with this content.

Setup a git repository in that folder.

That's it. You can simply create more .py files in the folder now and all of them will be loaded and reloaded automatically. If you define operators, panels, ... inside of one of these files they will be registered as well (by the bpy.utils.register_module(_ name _) statement in the main file).
Ah and don't forget to create a _ init _.py file in each subdirectory. I generally keep them empty.
The Code Autocomplete addon can do the first 3 steps for you.
http://code-autocomplete-manual.readthedocs.org/en/latest/addon_development.html
So why should you use multiple files:

Much better support by version control systems like GIT.
The dependencies in your code are much clearer, because you have to import functions you want to use in a file. That makes refactoring much easier.
Easier to extend without cluttering existing code.
Better separation between parts of you addon like operators and ui.
Makes it possible to write reusable modules.
Easier to manage in modern code editors, because most of them use a folder as project (I personally use Atom atm and like it very much!).

In summary: I only see benefits in using multi-file addons and using the template I developed most of the difficulties are gone.


How do I bend a scanned .stl object with several complex features

Ok, not having your exact object, and having not well understood your question I should probably avoid inserting an answer here, but I wish to show an easy way you could "roll up" that plane to a "cylindrical" shape, since it could give you some ideas on how to proceed. Then maybe you can suggest if some variant could be better.
Note, I simulated a flat rectangular object with irregular vertices (I randomized them): I know it's not as your object, which seem far less easy to be deformed than mine, but if you could arrange your object, subdividing it a lot perhaps, the following could fit your case too. Maybe.
Here it goes:

Here is my "simulation" of your flat rectangular object, with its red twin I leave there for comparison

in the same "object center" I add a "curve circle", from top view

obtaining this

Then I select the grey rectangular object and insert a curve modifier, targeting the bezier circle just inserted before

...and I get this horrible shape! But don't worry, it's just the circle, too little. We're going to fix it.

Now, I zoomed a bit to show you better, but I selected (see the upper right outliner area) the bezier circle

Then I enter the edit mode with TAB and select all control points

Then I scale it outwards, perhaps too much in the picture below, but at least now I can see where my curved surface ends are, which should probably stick together

...and I can make then stick together just by scaling a bit less (some snapping to grid could help while scaling)

Exiting edit mode, this is what I get.

As said above your object could not follow the curve so easily, and it could need to be subdivided, maybe with subsurf modifier applied in advance. Or, you could give us hints on how exactly you need it to be.
You could share your object, also, preferably using this dedicated hosting service and then pasting in your question the provided link:
http://blend-exchange.giantcowfilms.com/


Is it possible to prevent a Displacement modifier from affecting certain parts of a mesh?

You can achieve this by applying your displace modifier to a vertex group.

Just ensure that the vertices you don't want it applied to are not a part of your vertex group.

Example:


Changing object location in local coordinates don't work

From http://en.wikibooks.org/wiki/Blender_3D:_Noob_to_Pro/Parenting:

  The “Clear Parent Inverse” function sets this inverse transformation to the identity transformation, so the child picks up the full parent object transformation.

I guess instead of adding the object to the parent with CTRLP, I have to do it so with CTRLSHIFTP, so that the child+parent relation ship is set and the Clear Parent Inverse is performed.

NOTE: I don't understand the details so if anyone adds a proper answer I'll mark it as answer. For now though this will be the answer for this question.


This is due to the extreme perspective that forces high errors on simple geometry as mentioned by @jachymmichal.

One way is to add geometry to your cube before projecting UVs from view. Here is a way using the subdiv modifier:


Non-manifold, bad contig Edges and Sharp Edges on simple basic geometry

I had a similair issue, although the shape had no inside-outside errors, still it was solved by  :    reset vectors-  recalculate outside

I'm guesing that while editing normals can get distorted, not alike the shape you see.


It is hard to comment without seeing the blend file, however, you can try:

Un-hiding all faces (Alt + H); and/or
The Make Normals Consistent commend. Highlight all faces (using A in face mode), and then access the command by hitting space bar and searching for it.

I would also run the Remove Doubles command, just to make sure you have not created a face on top of another face when trying to "fill in" the gaps.


I finally found a way to fix it. I changed my controls in File -> User Preferences -> 3d View -> 3d View Global -> rotate view and changed it to right click.


Triangles are notoriously difficult to shade. Unfortunately, EVERYTHING gets turned into triangles by the renderer before rendering happens. Consequently, long, thin quads are also notoriously difficult to shade... because they're actually triangles once they get rendered.

Firstly, turn any triangles into quads. The renderer has a much easier time knowing which direction the quad should be split so that the triangles get smoothed the right direction, than it does trying to figure out which direction your triangle is supposed to be smoothed (without having come from a quad).

Secondly, make your quads as square as possible. It's not always necessary to make them perfectly square, but if you can add a couple of edge loops to make them shorter, that will probably help.

Lastly, (and I doubt this is the problem, but it's worth checking) recalculate your normals (ctrln or Mesh -> Normals -> Recalculate Outside) to make sure they're all facing the same direction.


Just incase anyone else needs this I figured it out, it only works in the stable release in Blender 2.8 and I was using the old version back in July

Link your image editor by going to Preferences > file paths > image editor > click on the EXE of your program

Then to project from the editor go into texture paint > Options > External > Quick edit

Save to apply save the file, make sure you only have one layer it will mess up. Then hit "apply" under external.


Need guidance for creating no dependancies between two installs of Blender

At least on Windows, it is enough to create an empty folder config in Blender\2.70\.

Blender binary path is for example:
...\Blender Foundation\Blender\blender.exe

and the version-specific folder is here:
...\Blender Foundation\Blender\2.70\

Add the config folder like this:
...\Blender Foundation\Blender\2.70\config\

Blender will note the local config folder on startup and prefer it over the user dir. If you save the startup file or user settings, startup.blend and userpref.blend will be created in your local config folder. Scripts located in the user dir won't be picked up.


Well, everything depends on your scene.

An 8GB graphics cards will be faster than than your CPU but you will be limited to 8GB (side note: do not keep in your old 2GB graphics card, along with the new 8GB card, Blender will only use the ram of the lowest card)

If you go with the CPU 16GB ram then you will be able to render larger scenes but it will be slower.

I would say get the graphics card with 8GB.


How to make the chacter detect stairs and react to it

It sounds like you need to change the action mode to play, and you might have it set to "loop stop" or "loop end".

Here is a list of the play-modes for your benefit.

PLAY- plays the action once on a positive pulse.
PING-PONG- plays the animation forward and backward
FLIPPER- plays the animation first forward, then after a negative pulse plays it backward.
LOOP-STOP- will play the animation over and over as long as it has a positive pulse.
LOOP-END- Like loop stop, but even after positive pulse is gone, it will finish playing the animation cycle it is in.
PROPERTY- plays the animation based on a value from an existing game property.


Convert old AnimationNodes to Current - a flying away movement - what is the "Objects from Group" replacement

thanks so @OmarEmaraDev it's called "Collection Info" now,
also it kind of messed up the the inital transforms and Index Keys


Emit map and mirror map? How can I texture emission and reflection?

I tried a simple test: I created a 600x200 pixel png file, with the left half pure black and the right half pure white. Created a new emission material in Cycles and set the color to 'Image Texture', then loaded the png image as the texture. I placed the material on a quad and set that quad perpendicular to a flat surface and rendered. The half textured with white acted exactly like a bright light, shining white light over my flat surface. The half textured in black emitted no apparent light. Looks to me like it just works.

The blend for this texture emission can be found here:

The partial mirror is achievable by using a glossy BDSF shader with another UV-mapped texture feeding the 'Roughness' variable. I updated the blend to use this textured mirroring node setup. You can find it here:


How to create a good topology from SVG for 2D animation?

What is good topology for 2D anim depends on how this animation should looks like. There is many technique and styles so for example you can try
CutOut animation
model cut into several parts driven manually or armature. For this kind there is awesome addon Cut-Out Animation Tools, that make it very easy to work with (includes script to generate parts from Photoshop or Inkscape layers in proper position and ready to import to blender with click to generate armature).
Grease Pencil
Very powerful anim tool set with many options of creation and animation, frame by frame, using sculpt mode , or armature as well ... example one of many
Delaunay Triangulation
For some kind of animation could be helpful to use triangulated topology. There was a script for Blender 2.49 that I can't even find. But similar feature is a part of great BlenderGIS addon, but it doesn't generate point cloud for triangulation (as the old one) it just connects the points. So to get Delaunay work you have to generate a point cloud first.
I'm sure there has to be a simple script that can do this in a one click, but in meantime here is one solution ...

Download, install, enable BlenderGIS addon

Select SVG curve convert to mesh like Ctrl+A Visual Geometry to Mesh

In Geometry Node editor add New, add Point Distribution node type Poisson Disk and merge original mesh with points by Join Geometry node as shown bellow

Apply Geometry Node modifier under Properties editor > Modifiers
Search for GIS Delaunay (or go to 3D view editor top row menu > GIS > Mesh > Delaunay)

Notes:

Poison Disk can be generated also by addon Point Cloud Visualizer
Delaunay can be generated also by Archipack addon under Terrain
or there was a Point Cloud Skinner addon, but v0.18 works only for blender 2.83 not 2.9x
I saw some technique of delaunay triangulation based on Voronoi pattern (out of blender)


Render and save " view port render image (openGL)" with python directly?

It was actually easy. thanks there is already arguments, to direct output render-image in bpy.ops.render.opengl()  (write_still = "True")
then most simple case (if keep current scene render setting), once change path(file name) to render thumbnail(openGL view image), then after generate the img , return path as same as before. (so user may not notice it changed)
import bpy

def render_icons(fname):
    render = bpy.context.scene.render
    upath = render.filepath
    render.filepath = fname
    bpy.ops.render.opengl(animation=False, view_context=False, write_still=True)
    bpy.context.scene.render.filepath = upath

I suppose, to enhance this, untill render, set some render propertys of bpy.context.scene.render to fit as thumbnail, then return all property as same as before.
and add option flag (user may manually set those setting, or use preset for icon render)


Keep an object's origin at 0 during an animation?

For a video game you don't want to do that. Shape key animations are very expensive and hard to transfer over. Plus, the pieces would not interact with the rest of the game world.

You most likely want to simulate the physics for the pieces in real time in the actual game engine. Often this type of things are made with an intact version of the wall and after the impact happens, the object is removed and the physics-simulated pieces are instantiated.

Or if you want a non-interactive version you could make a rig for the pieces and bake the simulation on the rig in Blender, then export the object with meshes and animation. Considering how advanced and efficient the physics simulation capabilities of even free and indie game engines are today, this is becoming an increasingly obsolete solution.


A simple code example:

# switch on nodes and get reference
bpy.context.scene.use_nodes = True
tree = bpy.context.scene.node_tree

# clear default nodes
for node in tree.nodes:
    tree.nodes.remove(node)

# create input image node
image_node = tree.nodes.new(type='CompositorNodeImage')
image_node.image = bpy.data.images['YOUR_IMAGE_NAME']
image_node.location = 0,0

# create output node
comp_node = tree.nodes.new('CompositorNodeComposite')
comp_node.location = 400,0

# link nodes
links = tree.links
link = links.new(image_node.outputs[0], comp_node.inputs[0])

Here are node types you can create:
Nodes subclasses API

If you need anything more let me know.


How to get a seed and perlin noise /randomnumber in Python in BGE

Blender comes with the mathutils module, which has a whole host of functions for just this kind of thing:

Here's the script for the above demo. It's a little boilerplate-y, really the gist of it is just the section in the middle (iterate over each vertex, get value from 2D location of vertex, set Z location of vertex)

from bge import logic
from mathutils import noise

# a list of various noise functions with some default values
noise_functions = [
    lambda p: noise.cell(p),
    lambda p: noise.fractal(p, 1.0, 2.0, 8),
    lambda p: noise.hetero_terrain(p, 1.0, 2.0, 8, 0),
    lambda p: noise.hybrid_multi_fractal(p, 1.0, 2.0, 8, 0, 1),
    lambda p: noise.multi_fractal(p, .5, 2.0, 8),
    lambda p: noise.noise(p),
    lambda p: noise.ridged_multi_fractal(p, .5, 2.0, 8, 1, 0),
    lambda p: noise.turbulence(p, 8, True),
    lambda p: noise.variable_lacunarity(p, 1),

    #lambda p: noise.voronoi(p),
]

verts_per_tic = 100 # number of verts to move every logic tic
zoffset = 1 # sort of useable as a "seed" when distorting a 2D plane on the Z axis like this
scale = .5

def move_verts(cont):
    own = cont.owner

    for m_index in range(len(own.meshes[0].materials)):
        v_range = own.meshes[0].getVertexArrayLength(m_index)

        cvert = own.get("current_vert", v_range)
        noise_scale = own.get("noise_scale", 1)

        if cvert < v_range:
            # iterate over verts in the current material of the current object
            for v in range(cvert, min(cvert + verts_per_tic, v_range)):
                vertex = own.meshes[0].getVertex(m_index, cvert)

                # get the XY position of the current vertex and scale it
                sample_pos = vertex.XYZ.copy().xy * scale

                # turn the 2D XY vector into a 3D vector
                sample_pos.resize(3)

                # set the Z component to a pre-defined constant
                sample_pos.z = zoffset

                # feed it to the current noise function
                height = own["noise_generator"](sample_pos)

                # set the vertex position
                vertex.z = height

                cvert += 1

            own["current_vert"] = cvert
        else:
            # if we've moved all the verts according to the current function, then pick a new one
            iter = own.get("iterations", 0)
            if iter >= len(noise_functions):
                iter = 0

            own["noise_generator"] = noise_functions[iter]

            # cycle through each noise function
            iter += 1
            own["iterations"] = iter

            own["current_vert"] = 0


I had a similar problem when tinkering with the BGE.  I had a rudimentary cannon and large sponge rubber shells so no one gets hurt.  The empty was used to move the shells out of the barrel .  It was too close to the barrel if I remember properly and would sort of tremble.  It was long time ago but I can go back into that project and even send it to you if you want.

Try removing the parentage, move the empty about a little, then re-parent it, see if the problem goes away...


You have the camera ray visibility disabled for cycles on the "particleCube".


Draw straight lines for sphere/polar coordinate meshes

Here's a view of a sphere from directly above one of the poles:

The orange selected vertices look like a square, don't they?  that's because I used the knife tool to carefully draw "straight" lines between four of the vertices.
But let's look at the sphere from a slightly different view:

Notice how in 3d the "Square" doesn't have right angles or straight lines?
Next I added a seam around the equator of the sphere.  (It's the red line that's outlining the equator in both drawings.  In the UV editor, I selected all vertices and did a UV unwrap.  Here's what you get for two hemispheres:

Notice that the apparent square is curved?
When you want to UV uwrap a sphere and draw in a box you end up with this sort of distortion.  Rather than all of the quadrants being separate, I would settle for two hemispheres, I think.
To draw in the boxes, I would export the UV map and then import it into an editor to use as a guide layer for my texture painting.
Here is one way to do that:
In the UV editor, type ALT-N to bring up the new image menu:

Give the image a name, and then make sure you've selected all of the vertices in the sphere.
You should end up with an image that looks something like this:

Next export the image to a file by typing SHIFT-ALT-S and using the dialog box.  Take that image to your favorite drawing program and make it a layer.  Do your drawing on it.  Then, before you save the drawing, remove the layer containing the image.  That'll be your texture file.


This set-up is only good if you are going in a straight line. You have not said anything about parenting or driver settings. By looking at your gifs, I can assume you have the wheel parented to the Empty, and your driving the wheels 'X' rotation with the Emptys 'Y' location in 'Local' space, Am I correct so far ?? Even if you change the drivers space to 'World' or 'Transform' - you will still have a 'Coordinance' issue. So then you start thinking , I will use an armature bone(s) - well you will run into the same 'Coordinance' issue again. This issue has been highly debated over at BA for many years, we refer to it as 'the tank track issue', it is a shame that something so basic is so troublesome. So clockmender wrote an animation node to overcome this issue, but if A/N is not your thing, then this is my solution I use; I create 3 actions for the wheel, (1) START (2) TRAVEL (3) STOP -- You can combine these into one action, but I find this way more flexible. You assemble those actions in the NLA, then all you have to worry about is animating the steering. Hope this helps in some way.


Does the Bone Selection Set Addon exist for Blender 2.8?

The answer is yes. But the reason I couldn't find this add-on in the Preferences window is because I unknowingly had the Enabled Add-ons Only box checked, meaning that searches that I was performing in the filter field weren't finding the add-on I was looking for. How funny is that?


Object material/color not visible - Only wireframe

Your object has no faces, it just has edges.

In edit mode select the vertices of your object and press F to fill, and create a face to which you can assign a material.


Negative angle values mean rotation in opposite direction i.e. clockwise/counterclockwise. Hence, -180 deg is back from 180 to 0. A 360 degree rotation doesn't need negative angles.


What is the best way to make a scene look like the inner of the colon?

To answer your question about the camera, you could do either. Try inputting the specifications of the camera you are using, and see if it looks right, otherwise I would recommend Panoramic set to Fisheye Equisolid. You can play with the aperture and FOV settings from there.
For the material/ reflections, you can try this:

Basically What I did was warp the vectors of a couple of Voronai Textures with a noise texture that I softened by mixing it heavily with light grey.  I offset one of them, and colored them red and blue respectively, to make the veins. I also attempted to cancel some of the vein continuity by mixing in another Noise Texture, but looking at it now, I think I needed to darken the noise with a ColorRamp first.

I made the wall color by connecting a ColorRamp to another noise texture, and used a Musgrave Texture to make the inner wall bumps. I softened the Musgrave and plugged it into the height input of a bump node to get some normal information. Before this, I mixed in some height information from the veins as well. I also inverted this mix and darkened the contrast to use as a roughness input - this, combined with the normal map is a large basis for the reflections.  Lastly I mixed the colors together to use as both the BaseColor and the Subsurface color.

I set my Principled  BDSF as shown below. I made this in EEVEE, but it works just as well in Cycles - just note that you may have to turn down the transmission, subsurface, and maybe even metallic to make it look correct.

The end result looks like this:

I'll upload the blend file if you want to see for yourself - Keep in mind this is for 2.83, so it will likely not work in 2.79 unfortunately due to my use of Vector Math nodes, which I think 2.79 may lack (correct me if i'm wrong). If you can obtain and use 2.83, I would heavily recommend it.
File is here -
Cheers


The size of the output image  is determined by the image connected to the background.

If you plug in a scaled (or differently sized) image as foreground, it will mess up the sizing of the composite.

In this case your setup is correct but the keying node is filling the frame with a value of black information (0) around the image, and a value of 1 in the alpha channel, creating full opacity.

The way to fix this is making the Black clip be a value that is not 0, so that the alpha channel becomes transparent to that value.
Changing the value to 0.00001 will make the transparency come back:


Run modal timer depending on a condition

Running timers based on the file you have open can be done by defining a handler on bpy.app.handlers.load_post.

This handler can check the state of the blend file and start executing based on this.


Final render not showing full node setup

Looking at your node setup, I think it is because you have the wrong socket plugged into the Composite node. It should be coming from the same Add node that the Viewer node is also plugged into. Maybe you were testing earlier and forgot to change it back?

Also, you can enable Backdrop while in the compositor to update your changes as you work, this can save you the time of rendering everytime you need to try a certain setup or see changes.

See What is the difference between a Viewer and a Compositor node? for more information.


How do I get the context menu in the node editor/3d editor (and more) if I preffer to use Right Click Selection?

The default key for the context menu is "w". I use it since I also use right-click select.


In the 3d-viewport select only those 3d-faces you want to seperate in the uv-editor. Then only these faces appear in the uv-editor.

Next you select all appearing faces (a) in the uv-editor, scale them using sx-1, so the faces get mirrored and grab them (g) to place them where you want them to be.


I'd suggest to limit the numbers of vertical loop cuts to the same number of vertical lines along side the Yamato hull.

Start with a low poly general shape of the main hull.
Then start to split / separate the parts as new objects.
Parent everything to the main hull
Hide the main hull and start to develop the other objects into their proper shape.
Some details will be external objects placed along side the hull so don't worry in attempting to model the whole ship from a single mesh.

For the Wave Motion Gun you can use a small cylinder and then Joim the mesh with the main hull, bridging edge loops and creating faces when necessary


How to import Downloaded Materials/Files?

Blender has no specific file formats for objects, materials, shaders and so on. To reuse the material from one .blend file in another, you can either create a link to the material in your material blend or you can append said material.

Linking materials is a great way to create material libraries. If you make changes to the material blend, those changes will be visible in all files that have links to the material file, as soon as you open or reload them.

Appending materials creates copies of the source material in your current blend file.

The process for both methods is the same.

Open the file you want to link/append the material to.
Go to "Files - Link/Append"
Navigate to the .blend that contains the material and click on it
Open the Material Folder and double-click on the material you want to link/append.

After that, your material should be visible in the Material selector.


That's correct.

The scale is an arbitrary number which is used to offset the size of the mesh from it's original state. It doesn't refer to the actual size of the mesh, just how much bigger or smaller it is.

I think you are looking for the dimensions values in the properties region:

Setting the dimensions will set the scale values to the appropriate value to make the mesh a certain size, e.g. 2.5m tall:


Cylinder with no cap ends invisible on the inside

This is because you have Textured Solid ticked under Display in the Toolshelf. You use this feature when you want to display face assigned textures while in solid view.


You can do that zooming for sure if you know how to add a new keymap:

Go in that keymap setting panel and choose the 3D-view(global) panel, scroll down to see that Add New Button. Press it, it will give you a None keymap.

Setting up the identifier field with the thing you want, in the zoom case view3d.zoom

And then setup rest of the key setting, you shouldn't need other details setting for your task.


You can make sure your UV's are rotated the way you expect by loading in a test texture before saving out the UV layout.

Blender has some built in textures which you can load by going to Image> New Image in the header of the UV Image Editor while in Edit mode for the object you are unwrapping.

Choosing 'Color Grid' and pressing 'OK', will load in the test texture.

From here you can edit the UV's in the Image Editor using the normal rotation, grab and scale shortcuts until the UV's are rotated the way you want.

Below, I selected the row of quads by hovering my cursor over them and pressing L to trigger 'Select Linked', then R to rotate the UV island.

You can remove the texture once the UV's are aligned correctly.


Why blender is not registering its website on brave rewards?

Blender has its own platform for donations. You can donate to Blender development fund or make a one time donation using the listed options that include PayPal and even several cryptocurrencies.


Don't autocrop video when having different dimensions of videos

First set your render settings Resolution to X:1000 px and Y:1000 px. In Video Sequence Editor right click on the name of the video that you are editing with the ending .001 (or similar). Open the options window with N and select Crop option and crop away the top, bottom, left and right to get the size that you need. To constantly see what you are doing the option at the bottom Use Backdrop is also good to be turned on.


Python code to add objects to the 3D Cursor

Add new object at cursor
Default values.
If you auto complete on the operator in the python console, it shows the properties and their default values.  There is no need to pass any default value to the operator.
>>> bpy.ops.mesh.primitive_cube_add(
primitive_cube_add()
bpy.ops.mesh.primitive_cube_add(size=2, calc_uvs=True, enter_editmode=False, align='WORLD', location=(0, 0, 0), rotation=(0, 0, 0), scale=(0, 0, 0))
Construct a cube mesh

To add a cube with location and rotation of 3D cursor
bpy.ops.mesh.primitive_cube_add(align='CURSOR')

To add at  cursor location.
bpy.ops.mesh.primitive_cube_add(location=bpy.context.scene.cursor.location)

or equivalently, align to cursor but override rotation.  Even though the zero rotation passed is default, just passing it (in tests so far) overrides cursor rotation.
bpy.ops.mesh.primitive_cube_add(align='CURSOR', rotation=(0, 0, 0))

Related
Precisely move the 3D cursor
How to move selected object to the curser location using a python command?


You need to switch to the Options tab to see the Blend Mode setting.


RTX 2080 graphics card is not recognized as Optix compatible on Debian 10

I switched the NVidia drivers to 440.100 (from the backports repository) and Optix now seems to work.


Control a property with no socket (color ramp swatch, etc) from a Group Node input?

As far as I know, I don't think it is possible to drive a Color Ramp or Mapping nodes from another socket (but I am not super experienced in drivers).  However I have managed to re-create the color ramp and mapping node with math nodes, which you can plug inputs into directly.

Color Ramp

Unfortunately there is no way to create a group node exactly like the Color Ramp, with addable and removable color swatches.  To get around this I have created a node with two movable swatches, you can then combine multiple of these nodes together to have the functionality of multiple swatches.

The theory:

The two input colors are plugged directly into a Mix RGB node.  The two Pos inputs need to be sent through a function and plugged into the mix factor.  The position of the first swatch needs to be mapped to $0$ to get just the first color out of the mix node.  The position of the second swatch needs to be mapped to $1$ to get just the second color out of the mix node.

The math:

Here's a graph to visualize what we are trying to do, on the x-axis is the input factor of the color ramp, on the y-axis is the desired output, $a$ and $b$ are the positions of the two swatches.

With some simple algebra we can find the equation of the line to be:

$$
y = \frac{1}{b-a}x + \frac{a}{a-b}
$$

The math nodes below are simply replicating this equation.  The final Add node also has Clamp checked to clamp the output to the interval $[0,1]$, which is what the mix node accepts.

Mapping node

The mapping node has three functions it can Translate (move), Rotate, and Scale the texture.  Since often not all of these are needed I will create separate group nodes for each of these functions.

If you don't have a decent understanding about how texture coordinates work you may want to read my answer here.  The basic theory of manipulation texture coordinates is to separate the components of the vector with a Separate XYZ node, manipulate the components individually, then combine them back into a vector with a Combine XYZ node.

Mapping Node - Translation

Translation is easy, to translate $V$ to $V^\prime$ just add the desired amounts to each of the components of $V$.

In the above node setup I actually used Subtract nodes instead of Add so positive values will move the texture to the right instead of left.

Mapping Node - Scaling

Scaling is the same as translating, just multiply the individual coordinates by the scale factor instead of adding.

Mapping Node - Rotation

Rotation is a little more complicated and I won't take the time to derive the equations here, but they are pretty standard pre-calc formulas.  Here are the formulas for rotation.

Around the x-axis

$$
\begin{aligned}
x^\prime &= x\\
y^\prime &= y\cos{\theta} - z\sin{\theta}\\
z^\prime &= y\sin{\theta} + z\cos{\theta}
\end{aligned}
$$

Around the y-axis

$$
\begin{aligned}
x^\prime &= x\cos{\theta} - z\sin{\theta}\\
y^\prime &= y\\
z^\prime &= x\sin{\theta} + z\cos{\theta}
\end{aligned}
$$

Around the z-axis
$$
\begin{aligned}
x^\prime &= x\cos{\theta} - y\sin{\theta}\\
y^\prime &= x\sin{\theta} + y\cos{\theta}\\
z^\prime &= z
\end{aligned}
$$

Note: the first two nodes in each of the rotation setups convert the degree input to radians, which is what the trig math nodes want.

And finally, here's a .blend file with all the above node groups.


Is it possible to render and composite certain materials before others?

Yes and no.

You can not render certain materials before other ones, both cycles and the blender internal will render your whole scene in one go. You can't say render my cube before the ball.

However you can use render layers. Render layers brake up your scene in to pieces that get rendered separately. Then after it is done rendering everything you can combine, and manipulate them way you want in the compositor.

Here I have a simple scene, a cube, a ball and a background. The important thing is that each object is on its own render layer, the cube, the ball and the background, are all on their own render layers.

Those three images (click for full size) are what you get if you render them using separate render layers. Note on the background layer it renders the part of the background that would normally be hidden but the ball and cube, yet the shadows stay.

Now in the compositor I combined these using alpha over nodes, to get the final rendered image. The benefit here is that you can apply any effects to just one piece. For example, I changed the color of the cube.

Your other option, which will work just as well in a simple case like my example is to use an object or material index pass. This works a bit differently then separating the objects out on different render layers, here they all are rendered in one pass, but the addition of the Object Index pass works like a mask for the objects.
Do note that you first must set the pass on each object. In the Object tab of the properties window, under the Relations section you will find the Pass Index value.

After all the passes are set correctly for the objects, render and let the fun in the compositor begin.

Here are the nodes to use a Object Index pass as a mask, which will isolate the specific object.

It may look complicated but, it is really just the Object Index pass as the factor in the Mix node. The important part is the ID Mask node. The number you put in there corresponds to the number you set the object pass to.
All that I'm doing is some color, and blurring manipulations on the original image. Then Using the ID Mask to pull the correct mask out of the Object Index pass. Which gets feed in to the mix nodes, to determine what part of the image gets manipulated.


Blender twisting parts of mesh when rigging

The problem in your scene is caused by the bone structure. Take the L side for example:

Since you are using two bones for each upperarm for some reason (which is unlike normal human), the constrained bone DEF-upper_arm.01.L doesn't follow the rotation of its control bone or even DEF-upper_arm.02.L, which would lead to the problem. As shown below:

There would be a few ways to fix this, but I'm really not sure why you structed and set the control bone for upper arm like this (I assume you are trying to simulate the natural-looking muscle stretch). However, I think at least an additional Copy Rotation constraint onDEF-upper_arm.01.L is needed here.

Here is my try, FYI:


Set inverse Child OF constraints via python

Toggle a constraint property

As mentioned, simply changing the inverse_matrix property does nought.  If another property of the constraint is toggled, for example the target it appears to work as expected, using the new value assigned to inverse_matrix

Test script, tested on simple example of single bone and default cube parent. Set cmd to 'CLEAR' for clear and 'SET' for set.

EDIT:  code to interpolate based on constraint influence when set.

import bpy
from mathutils import Matrix

context = bpy.context

ob = context.object
constraints = [(pb, c) for pb in ob.pose.bones
        for c in pb.constraints if c.type == 'CHILD_OF']

cmd = 'SET' # or 'SET'
for pb, c in constraints:

    if cmd == 'CLEAR':
        c.inverse_matrix = Matrix.Identity(4)

    elif cmd == 'SET':
        if c.target:
            M = ob.convert_space(pose_bone=pb,
                    matrix=c.target.matrix_world,
                    from_space='WORLD',
                    to_space='POSE')
            P = Matrix.Identity(4).lerp(M, c.influence)
            c.inverse_matrix = P.inverted()
    # toggle a property
    target = c.target
    c.target = None
    c.target = target
    #pb.constraints.update()

why is this so?  Constraint properties that are set by a user (esp via UI) update the data appropriately on change.

An operator for each has been  chosen to crunch the numbers , and handle the necessary updating.  Perhaps a patch to make the python attribute update on change, not sure..


transfer weights across separated Meshes?

Found the answer to my question, It was something i had already done but didnt do it quite right.

In object mode>Select all Meshes>Join
Move to Edit mode>Select all Vertices>Vertex>Merge Vertices>By Distance

Apply Automatic Weights as normal AND THEN start seperating the parts you want to.


How to enter the interior spaces for render

You can place a camera inside your mesh and use the 'Lock Camera to View' in the view tab (N). Then go to camera view (Numpad 0) and navigate with camera locked to view. You can deactivate lock once you get the right view for render.
You can also separate parts of the mesh and then you will be able to hide the parts you want in Object Mode. In Edit Mode, Select all > P > Separate by Loose Parts.
https://docs.blender.org/manual/en/latest/modeling/meshes/editing/mesh/separate.html


I think the problem is that you're hooking up your nodes wrong because you've been misled by your white stucco texture.  Its base color is a nearly solid color, so scaling only the base color -- which is what you're doing in the GIF -- will have no noticeable effect.

I grabbed the base color and roughness maps for a white stucco texture from here, which I think are the same ones you're using in your GIF.  I applied them to the default cube using the following node network:

Note that the Vector output of the Mapping node is connected to both image textures.  The Texture Coordinate output should be connected to the Vector input of the Mapping node, leaving the Scale unconnected so you have the sliders available.

After that, scaling should work fine:


How to check the pose bone have property which is driven?

I think there should be better way, but I feel it worked for me.
import bpy
def get_driver_list(ob):
    drvs = ob.animation_data.drivers
    li = []
    if drvs is not None:
        for drv in drvs:
            drv_path = drv.data_path
            li.append(drv_path)
    return li

def get_bone_driven(ob, bn):
    flag = False
    li = get_driver_list(ob)
    bn_path = ob.pose.bones[bn].path_from_id()
    for path in li:
        if bn_path in path:
            flag = True
            print(bn_path, "in" , path)
            break

    return(flag)

ob = bpy.context.object

for pb in ob.pose.bones:
    if get_bone_driven(ob, pb.name):
        print(pb.name)


Automatic moving of unselected objects & detailed Blender documentation

Thanks for the explanations. I will hunt down resources to explain what Blender thinks origins are, not to mention how it handles non-absolute world coordinate systems. I'm wondering if learning about "local" coordinates might help me, which I've seen reference to.
It seems unnecessarily confusing because at most times Blender pretends there are no absolute coordinates, which is bogus, since that is how it knows where to draw things relative to where it draws the X, Y, and Z axes. I could figure what Blender was doing in operations if there were a visible absolute reference for everything. I can't very well keep moving all objects' origins to their geometries to understand what an operation involving origins is doing.


Blender is rendering all file formats with transpancy as boxes without the rest of the image

just hide your plane in viewport + render.

and you will get this:

i just added an alpha over node with green to your compositing tree so that you can see that the alpha is "there".


How to render in blender with compositing

I would check 2 things first:

Do you have the Compositing checkbox in the Post Processing panel under Render settings checked? If not the render process will bypass the compositor.

Do you have your compositing nodetree connected to the Composite node? If you only have the Viewer node hooked up you won't see the effects of your composite.


Textures Not Showing in Viewport (Blender 2.8)

Blender 2.8 uses an entirely different materials system from previous versions. As a consequence of this (and perhaps also as a result of some missing backwards compatibility features in Blender 2.8), image-based materials created in older versions of blender get replaced with plain, solid-color materials with no textures when opened in Blender 2.8.

To fix this, you will need to manually re-assign textures to their appropriate materials in the project. Select the model you want to fix, then in the properties editor go to the materials tab, select a material to fix, and click "Use Nodes". Next, click the small button to the right of the "Base Color", and click "Image Texture". Finally, click the image dropdown below the base color, and select the correct texture for the material you have selected. Depending on how well named the materials and textures are, you may have to use a bit of trial and error to figure out which texture goes where. Now repeat this process for every material in the project.

Yes, this could be extremely tedious depending on the size of your project, but until Blender introduces a built-in way to convert old models to the new materials system this is what we're stuck with, apparently.

For more information on this issue, see Opening old .blend files (missing images) on KatsBits.


Trouble with Context for bpy.ops.transform.translate

Could do it without using the transform.translate operator

import bpy
from mathutils import Vector
# open another file.
bpy.ops.wm.open_mainfile(filepath="/home/batfinger/3DModels/New.blend")

scene = bpy.context.scene
#scene.update()
objects = [o for o in scene.objects]
override = bpy.context.copy()
override["selected_objects"] = objects
override["object"] = objects[0]
bpy.ops.mesh.boundbox_add(override)
bbox = scene.objects.active

for o in objects:
    print(o.name)
    o.location -= bbox.location # origin after translate above

bbox.location -= bbox.location

or run for each scene in the file for scene in bpy.data.scenes

Not a fan of opening new blender file in script as above.  My suggestion would be to use a handler or run a batch command.


Using different materials on each instance of an object with a mirror modifier

You will have to go around the mirror modifier and create 2 copies of the door each with different material, but with the same mesh they share between each other:

Get rid of the mirror modifier.
For each material slot set it to be linked to Object:

Make an instance of the door with Alt+D. This will duplicate the object, but link the same mesh between them. More on this can be found here:

What is a Duplivert, or a Dupliframe, internally?
Scale one object in the axis you want to -1 to mirror. Arrange them accordingly.
Assign different materials to the material slot(s).


Texture appears differently across surfaces of a complex object?

Automatic UV coordinates will yield relatively uniform and consisten texture densities across your mesh, with little effort too, at the expense of control and flexibility.

They will inevitably produce distortions of parts of the mesh, since they are blindly projected from a predefined point, without any regard for mesh topology or shape. They should however maintain an overall constant density distortions aside.

If you wish to have better results at the expense of a lot more manual work you should go with the proper texturing workfow and use actual UV Coordinates by unwrapping your mesh.

This is a manual process, and the texture density will only be as uniform as your UV map quality and unwrapping skills will dictate.

I was able to achieve relatively good UV quality from the U > Unwrap > Follow Active Quads > Even option, with a fresh UV layer, on part of your mesh.

It yielded a relatively good and even quads grid. This is how a good UV map would look.

Again I can't stress enough that by default there is absolutely no obligation that your UVs will be uniform under any circumstances, you have to manually make them uniform by eyeballing and visually scaling every UV island so it matches your desired density.


Cant Rotate,Scale when I hook a vert on a curve in Blender 2.8

I went into the same issue today in 2.8. The way to make it works is to select your BezierCurve handles in Edit Mode then press RMB and click on Set Handle Type -> Toggle Free/Align, now you can rotate and scale your Hook.


Bevel segments on bevel modifier not working properly

Changing the Mitre type to Arc should resolve this.  You will likely need to do this for both internal and external, but play with the settings and see what works for you.


If you are just wanting a calculation based on given Euler angles, (since location makes no difference to a Sun lamp, which shines down its negative Z all over the world from an infinite distance), then all we are interested in the world-Z component of the direction of the lamp's own Z axis. If that is positive, the sun is shining down.

So you could do this sort of thing:

from mathutils import Matrix, Euler
from math import radians

def shines_down(XYZ_angles):
    angles = (radians(x) for x in XYZ_angles)
    eul = Euler(angles, 'XYZ')
    mat = eul.to_matrix()
    return mat[2][2] > 0

print ( shines_down((78,38,-179)) )

However, if you have the object already created, then you could just read the value out of its transformation matrix:

import bpy

ob = bpy.data.objects['Sun']
print (ob.matrix_world[2][2] > 0)

#True if down


How do I export stl without the origin point being connected as vertex to the mesh?

Try going to the "Object" tab, and select the "Origin to geometry". This will put the origin in the center of the object, which should make the object easier to export.


Match two planes with different origin locations (Blender Python Matrix Math)

Face centre as "Pseudo Origin"

Given we have 2 single face planes, will make the face centre the "pseudo origin" and match that.

Test script, moving "Plane.001" to "Plane".  The difference in face centre coordinates vector is used to create a local transformation matrix. Premultiplying this by the matrix world will translate the "face centres" to match.

import bpy
from mathutils import Matrix
context = bpy.context
scene = context.scene
# going to match transform of p2 to p1
p1 = scene.objects["Plane"]
mw = p1.matrix_world
p2 = scene.objects["Plane.001"]

# local offsets
o1 = p1.data.polygons[0].center
o2 = p2.data.polygons[0].center
# match the face centers global coords
# local translation matrix
LTM = Matrix.Translation(o1 - o2)
p2.matrix_world = mw * LTM


Shoe not moving with Leg when posing (armature)

You probably didn't weight paint the shoes.
First, name your feet bones something that you can remember. Then, parent the shoes to the bones again. Go into the properties panel > Object data (the green triangle) and then in the vertex groups look for your foot bone name. Select that, go into weight paint mode, and paint the shoe. That should cause your shoe to move.
Hope this works


Loop cut and slide using python script in blender

I found the answer, the way it is done is:

old_type = bpy.context.area.type
bpy.ops.object.mode_set(mode='EDIT')
bpy.context.area.type = 'VIEW_3D'

bpy.ops.mesh.loopcut_slide(MESH_OT_loopcut={"number_cuts":10, "smoothness":0, "falloff":'ROOT', "edge_index":1})
bpy.ops.mesh.loopcut_slide(MESH_OT_loopcut={"number_cuts":10, "smoothness":0, "falloff":'ROOT', "edge_index":0})
bpy.context.area.type = old_type

So you should be in edit mode, and VIEW_3D context, then use the loop cut to cut the edge "edge_index"


The misleading representation of wires does not mean that your mesh has holes.

The inconsistent display of wires for faster viewport display can be "corrected" with the Draw All Edges option.

As you noted correctly, after the boolean modifier, the wire display is not consistent with the solid representation.

However, adding wire display in the Object's Properties Panel, shows the same wires in solid view.

To show all wires, enable Draw All Edges.

There are, however, many other tools, which are useful for cleaning objects. For example:

the Mesh Analysis Section of the Properties Panel in the 3D View

the "Select Non Manifold Geometry" option in the 3D View ⎈ Ctrl⇧ Shift⎇ AltM
the 3D print toolbox addon


Is it possible model a perspective image in orthographic view

Yes, but ...
You have to keep in mind that using photographs as reference images you will always have a bit of "distortion". Therefore use them only as loose reference, not as "set-in-stone-rules".

If you start for example in the front-view, adding all the faces they will be completly flat, and if looked from any other angle, they will appear as a big plane without any structure. Now if you switch to side-view and start moving the verticies horizontal you'll get more and more "3d-ish".

(maybe somebody can add explaining images to this answer)


Check box to enable add-ons in blender is missing

The check box you're after is located on the left side.


You can do this by keyframing the Gravity checkbox in Properties>>Scene>>Gravity.

1.) Select frame 40 and keyframe the unchecked checkbox by pressing i or by right clicking and selecting "Insert Keyframe".

2.) Go to frame 41 and keyframe the checked checkbox by pressing i


In 3d view you may be playing only the OpenGL version of the scene, for example in textured or material mode or even just wireframe. Blender is optimised for this and it takes relatively little memory. This will play very fast.

After rendering to a high resolution image sequence you are asking Blender to load into memory a lot more data to display. Try selecting the strip and and creating a proxy, define the resolution and timecode type in the strip properties panel. The rebuild proxy/TC function is in the Strip menu at the bottom of the VSE timeline. Then go to the VSE preview window properties (N-key) and select the proxy size to view. Proxies of your footage should play back properly (less memory and processing overhead).

Alternatively go to the Blender timeline (not the VSE) and change the playback mode to AV-Sync. This will prioritise playback to frame rate and drop frames to do so.


You can change a bone's axis by going into edit mode, selecting the bone, and pressing Shift + N. then you'll be able to change the transformation axis

https://imgur.com/ByO5yQa


what's the difference between 'repeat', 'extend' in image texture node?

I figured out. you can check the difference when you use mapping node with image texture and change the scale of an image on the object through mapping node. scale the image down with the mapping node by tweaking its scale option you'll see that extend just extends the image on the top of a object while repeat makes several same images on the top of an object.
from what I've figured out, you should scale the image down through mapping node or whatsoever.


At the Blender Institute / Blender Animation Studio we use Subversion for our projects. It works fine for blend files, but you have to make sure they are not compressed. Compression can cause the entire file to be different when only a single byte changed, whereas in the uncompressed blend file only that one byte will differ. As a result, binary diffs will be much smaller, and your repository will be faster to work with.


Baking out proper normals and AO's from Blender

You should turn OFF "Selected to Active," choose "Tangent" for your Normal space. , and set your "Distance" higher than zero. The Distance setting here is for baking to a cage (lo-poly version of your hi-poly model). There's a similar Distance setting in the AO section that should be greater than zero.

Cycles is currently (and quite admirably) trying to map your normals and AO map onto the lamp. "Selected to Active" is for baking normals from a hi-poly mesh onto a lo-poly mesh. It doesn't have anything to do with the lamp. In this case, you just want it off.

You also want to check the AO settings in the World panel. That's (mysteriously) where the AO distance and sampling settings are. Make sure those a reasonable, and you should get a better result.


Blender video editing: shortcuts for selecting video strips

Except moving the mouse cursor to the side you want selected before cutting(use K, unless you need a freeze frame), there is only this selection option, but it'll select all strips to the right of the playhead:


Start Game from File, how to send a message

You can't send anything from a blend file. A blend file is just a container for data. It gets read and written by Blender. The BGE can read them (but does not write to it).
Game Sessions
As you are talking about blend files I guess you mean game session (you are using the game actuator to switch levels). A game session is when you start your game and lives until it ends (quit). When you start again, you get a new session without any relationship to a previous one. Game sessions can run parallel. They still have no relationship to each other.
What you need is to transfer game status between game sessions.
Parallel
When two game sessions are running at the same time they can communicate via network (Python -> socket). In this case I suggest to search for question/answer regarding network communication. Be aware this is no topic for beginners.
Sequential
When two game sessions are not running at the same time you need to persist the game status. Persistence between game sessions can be in the file system (or a database) -> It must survive the end of the game session.
Therefore I suggest you specifically look for a question/answer dealing with Save/Load. This requires a bit of Python knowledge, but there are quite a few tutorials out there.
Levels as Scenes
When your levels are different scenes within the same game session, you could transfer game data via Messages or via Python. This is the case when you use the scene actuator.
Sorry but I can't give you a better answer with the information I currently have.
I hope it helps anyway


How to bake multiple audio sounds to f curve?

Bake to custom properties to drive from.

As an example I've made 3 custom properties on the default cube.
Add a keyframe and bake to sound for each.

Image. Baked prop, added keyframe to prop2.

Now let's say we want to drive the cube's x location by these props.

Add a driver to the location.x field. Hover over with mouse, right click, add drivers > manually create later single.  Put the graph editor in Drivers mode, select the location.x driver, hit N and choose drivers tab.

with scripted expression chosen (default) and the "use self" option checked, can type (or paste) in an expression, where self is the Cube object, adnd self["prop"] is the value of baked property "prop".

The following sums the three.

self["prop"] + self["prop1"] + self["prop2]"

or another way using sum

sum([self["prop"], self["prop1"], self["prop2]"])

average

sum([self["prop"], self["prop1"], self["prop2]"]) / 3

the maximum.

max([self["prop"], self["prop1"], self["prop2]"])

Or if you cannot add the properties to what you are animating, can set up the drivers the old fashioned way  with variables.  Add a single property type variable for each, select the Cube as the target object and the datapath is ["prop"] for "prop"

The expression uses the variable names, I've used p0 , p1, p2.  Similarly to above, the sum would be.

sum([p0, p1, p2])

or by choosing 'SUM' as the driver type.


Blender 2.8 - Field property declaration and dynamic class creation

The annotations for an object (which can be a class or a function as well) are stored in its __annotations__ property, as defined by PEP 526 and introduced in Python 3.6. This gives rise to the following solution:

The following approach works as I suspect you're looking for:

>>> clss = type('TestPropGrp2', (bpy.types.PropertyGroup,), {
...     '__annotations__': {'myProp': (StringProperty, {'default': 'MyStr'})}
... })
>>> print(clss.__annotations__)
{'myProp': (<built-in function StringProperty>, {'default': 'MyStr'})}

This also allows you to see that your proposed "one way to do it" approach doesn't actually work as intended:

>>> clss = type('TestPropGrp', (bpy.types.PropertyGroup,), {})
>>> clss.myProp : StringProperty(default='MyStr')
>>> print(clss.__annotations__)
Traceback (most recent call last):
  File "<blender_console>", line 1, in <module>
AttributeError: type object 'TestPropGrp' has no attribute '__annotations__'


Why is my model reflecting light like this?

This issue must have occurred due to shade smooth. This issue is quite common. All you have to do is go into object properties -> Normals -> AutoSmooth


There is a game development framework called Urho which utilizes 3D models as .mdl files for the model and .png for the texture, you don't need to download the whole framework but they have a plugin for blender that lets you export a model in those formats.

See http://urho3d.wikia.com/wiki/Blender_to_Urho3D_Guide

Simple Installation: https://github.com/reattiva/Urho3D-Blender

^^^ go to that page and  click the green button where it says 'clone or download' then click Download Zip

Once you have the zip file, open Blender, go to File -> User Preferences -> Addons.

At the bottom click  Install From File... and give it the zip file.

Then click the checkbox to enable, and to see the export option:

The addon is located in the "Properties" panel, at the end of the "Render" page (camera icon)

Note: In Urho, the textures are mapped to the models via xml material files, this is due to the Xamarin (mobile .NET) architecture of Urho projects. If all you need however, is the .mdl then this is the solution for you :)


For a logo trace it in a vector drawing program and export it as SVG.
No need to deal with alpha or pixels.

read the following links:

How do I turn my PNG Image into a mesh object?

Why can't I import a SVG file from Adobe Illustrator or Inkscape?


The Render output panel is in: Properties Panel->Render->Output

-

https://www.blender.org/manual/render/output/output.html#output-panel


Object Selection options not showing in 2.8

Assuming that your problem is not fixed yet, and you are using the latest version of blender (Version 2.82):

If the header is missing like this

then just click on the arrow pointing down at the top-right of the viewport window to unhide it.

The texts were replaced by icons as shown below:

If the Header is missing and you can't find the arrow as shown

then right-click on one of the control buttons at the top of the viewport window to show a Options where you can find the "Header" options And activate the "Show Tool Settings" checkbox found as shown below.


Python: Import X8R8G8B8 DDS texture as A8R8G8B8?

So far, I modify the header of the DDS texture file (according to how it is documented officially), as I didn't find another way. It's still a kinda hackish solution for me, but it's also a hackish problem I have.

with BinaryWriter(open(image_file_name, "r+b")) as writer:
    writer.seek(0x68) # DDS_HEADER->DDS_PIXELFORMAT->dwABitMask
    writer.write_uint32(0xFF000000) # Mask of the alpha data.

(BinaryWriter is a custom class. Simply pack an unsigned integer at position 0x68 which masks the alpha bits.)


The OS shows rendered files as TextEdit Documents instead of PNGs

Most likely the files have no extension. The OS doesn't know what kind of files they are, or what program to open them with, so it shows the files as text files (the default icon for unknown file formats).
Rename the files to be *.png
In blender enable File extensions.