How create a map based edge wear shader?

The only way I know to do anything like this is to take the heightmap into the Compositor (I connected it as an emission, aligned the camera and rendered to get it this way - choose whatever method works best for you). The next step is to take the difference between a blurred version of the image and the original. Anywhere with a "sharp cutoff" will be highlighted (assisted by a ColorRamp). It isn't perfect, as you can see from the photos. I picked a "noisy" texture on purpose to how many non-edges I could eliminate, but it's still rather noisy. The success will depend on the "cleanliness" of the original heightmap.
Here is my node setup in the compositor. The original heightmap image is on the left.

Here are just the nodes (for easier viewing). You will have to adjust the ColorRamp to your needs (it can be rather finicky finding the correct range).

From here, it's just a matter of saving your image and using it as a mask for your material. Here's my original material without and with the whites of a Noise Texture added to the "edges" using the mask I made (color channel only).
Without "edge wear" mask:

With "edge wear" mask:

As you can see, it's not perfect. It's still a bit "noisy", however it is obeying the "rules", so to speak. The areas that are highlighted are the ones that have the harshest cuttoffs, it's just that I picked a "bumpy" texture to begin with. Hopefully your heightmap will be a bit cleaner (as I said, I picked the noisiest one I could find), and you will have more success.
Here's an example with a "clean" heightmap (keyboard):

Again, here is final material without "edge wear":

And here it is with the edge wear. Note- I know noise is not a great texture to emulate wear - I just used it as a quick way to get some distortion to the white.


The bus will be moved by the "body" bone if all vertices are assigned to the "Body" vertex group and the bus object has an armature modifier pointing to the armature of the "body" bone.

In fact, in your file if you select a moving object (i.e. a wheel), you'll notice that the automatic procedure has inserted an armature modifier:

While if you select the bus no armature modifier is found, so the bus doesn't move even if its vertices are assigned and weighted to the "body" bone:

The simplest method to have your rig work is: go to pose mode and select the body bone; then select the bus; shift select the body bone again; Ctrl P "bone option", which skips the vertex groups and solidly parent the whole mesh to the body bone:

But a new problem arises: the bus doesn't move along with its wheels and accessories: this is because (i.e. a wheel) has a double parent so it gets double movement request: the wheel mesh is parented to the bus mesh, so - when the bus moves the wheel mesh moves; but the wheels vertices are moving too, due to the armature and bones assignements!

So you'll have to remove all parenting between wheels and bus, leaving to the armature the work to make the spare parts move together:

Last consideration: the usual" workflow would be: join all pieces in one single mesh, Shift select the armature, Ctrl P "with empty groups", select all vertices except wheels and assign them to the body bone, select all vertices of a  wheel and assign them to the wheel bone.


Relative path to script folder using text view

If you are editing a script in the text editor and clicking the Run Script button then you need to have import bpy at the top of your script to use anything in the bpy module.

Blender's python console automatically imports the bpy module for you, it also gives you some shortcuts like D = bpy.data so you can simply use D.filepath in the python console. The console also imports math and mathutils items so you can simply use radians() in the console but will need to import it if you use it in a script.

  Convenience Imports: from mathutils import *; from math import *
  Convenience Variables: C = bpy.context, D = bpy.data

It is also possible to run text from the text editor in the console. I use the addon mentioned in the previous link to run scripts in the console to make debugging easier.


The simplest way to access the layout for tracking is to create a new project: File->New->VFX.

It should open with all the windows you need for motion tracking.

To display the paths for tracking marks Open Clip Display and enable Marker Display-> Path


View point shading strength slider missing?

Found it! You need to update Blender from 2.80 to 2.81 (I downloaded the old version to check).


So far as I understand, there are 5 possible reasons:

1.) LoopTool's Circle menu settings may be the culprit:

The settings used restrict it's alignment. Try other combinations.

2.) Duplicate vertexes and/or lines. LoopTool's tools depend on nearest-neighbor objects. This may indicate that the mesh needs cleaning.

3.) Multiple plugins may cause undesirable operation. Try removing other enabled plugins and try again.

4.) Possible driver conflict. Verify that the drivers your system is using is compatible and up-to-date. You might also need to use an older version of a compatible driver for stable operation.

5.) Faulty Blender - A fresh installation of Blender may be needed. Also verify the storage device you load it from is in good condition, and is properly connected.


The children attribute is a convenience property, That is to say - Blender doesn't store a list of children for each bone, This attribute has just been added to some types since its such a common task.

Objects have this, but as you have noticed, not pose bones.

This can be monkey-patched in with:

import bpy

def pose_bone_children(self):
    obj = self.id_data
    pbones = obj.pose.bones
    self_bone = self.bone
    return tuple(pbones[bone.name] for bone in obj.data.bones
                 if bone.parent == self_bone)

# Add the property to the class at runtime
bpy.types.PoseBone.children = property(pose_bone_children)

Note that this will be included in 2.69, Committed r60407


You can do this in cycles also, when using the UV coordinate texture node, make sure to click 'from dupli'


Blender 2.8x Save Add-on Class Instance To Scene

This is what is often referred to as a monkey patch.  Data will not be saved to blend file.
To monkey patch onto a scene type could simply
import bpy

class HoldData:
    dat = None

def register():
    bpy.types.Scene.my_data = HoldData()

def unregister():
    del bpy.types.Scene.my_data

if __name__ == "__main__":
    register()

Test in console
>>> C.scene.my_data.dat = "foo"
>>> C.scene.my_data.dat
'foo'

In as much as can do this, would favour simply
from foo import HoldData

my_data = HoldData()

and
from bah import my_data

To save some data to blender and use a third party for other recommend a PropertyGroup and PointerProperty set up.   Not all members of the defined property group need be annotated properties.
The other issue mentioned is a typo, the class is bpy.types.AnyType (CamelCase ie capital T for type)  Not sure where you're going with this either?


While I think there must be a more elegant way to accomplish what you are trying to do, the problem lies in the fact that Blender isn't updating the scenegraph when it's deep inside the Python loop.

You can force an update and redraw with:

# bpy.types.Scene.update()
bpy.context.scene.update()

and

bpy.ops.wm.redraw_timer(type='DRAW_WIN_SWAP', iterations=1)

Note: calling bpy.ops.wm.redraw_timer is very much a hack, since scripts are not supposed to be forcing redraws, however it does work.


New graphics card not rendering anything

As it shows in Blender Release notes, GTX 9xx series are supported from version 2.73.


In making a mask, how do I remove the outer area and lay the inner area atop video?

Compositing

Solution with compositing like you suggested with the screenshot.
Using the mask as an factor input mentioned in the comments above.
(I just use the colors as a placeholder, you can use renders, movies, images...)

Video Sequence Editor (VSE)

Another solution would be to use the Video Sequence Editor (VSE). You can add both the render or what you want to cut out and the video. The video under the 'overlay'. On the strip you want to overlay you can add a mask modifier. Don't forget to change the blend type of the strip above to 'Alpha Over' or 'Over Drop' otherwise it will replace the image below.

Inverting the mask

To invert the mask, go to the mask editor (image editor and then select the mask view). In the right panel (N-Panel) there is the option for the mask layer. On the right of the 'Opacity' input there is the invert switch (white and black rectangle). By clicking it you can invert the mask.

(Tip: If you don't see a change. In the composition may enable auto render. In the VSE press 'Refresh Sequencer'.


This is the workflow I've found for doing this repetitively in Object mode.
The setup:

Pivot set to '3D Cursor'
Snap-magnet: 'Off'
Snap set to 'Vertex' and 'Center'. Because of the 'Pivot' setting, 'Center'  refers to the location of the 3D Cursor at the start of the move.
(The active tool is 'Tweak'.. it always is, for me)

The moves, for each snap:

Shift-Right  drag the cursor. Once you're in charge of the cursor, you can release the Shift.
Still Right-dragging, hold Ctrl to snap the cursor to the desired 'From' vertex. You have now established the snap 'From' point.
Now Left-drag the 'From' object to the 'To' object, with Ctrl, hovering over the target 'To' vertex. The 'From' point will snap to it.


odd vertex behavior when translating or editing

Turn off X mirror under options and all is well.

...or turn off Topology mirror if you need the X Mirror.


You have Transparent enabled in render settings > film.

Disable that and you'll see the sky...


How can i activate the wireframe on preview while in solid mode?

Yes, you can enable Wire in Properties > Object > Display:


Save this to a .py file and install it as an addon

import bpy

bl_info = {
    "name": "Scale 0 Operators",
    "author": "Jan Kadeřábek",
    "version": (1, 0),
    "blender": (2, 7, 0),
    "location": "",
    "description": "",
    "category": "User",
}

class scale_x_0(bpy.types.Operator):
    bl_idname = "view3d.scale_x_0"
    bl_label = "Scale X 0"

    def execute(self, context):
        bpy.ops.transform.resize(value=(0, 1, 1))
        return {"FINISHED"}

class scale_y_0(bpy.types.Operator):
    bl_idname = "view3d.scale_y_0"
    bl_label = "Scale Y 0"

    def execute(self, context):
        bpy.ops.transform.resize(value=(1, 0, 1))
        return {"FINISHED"}

class scale_z_0(bpy.types.Operator):
    bl_idname = "view3d.scale_z_0"
    bl_label = "Scale Z 0"

    def execute(self, context):
        bpy.ops.transform.resize(value=(1, 1, 0))
        return {"FINISHED"}

def register():
    bpy.utils.register_class(scale_x_0)
    bpy.utils.register_class(scale_y_0)
    bpy.utils.register_class(scale_z_0)

def unregister():
    bpy.utils.unregister_class(scale_x_0)
    bpy.utils.unregister_class(scale_y_0)
    bpy.utils.unregister_class(scale_z_0)

This will allow you to set a shortcut for each "scale 0" action.

So after enabling the addon, navigate to User Preferences -> Input -> 3D View -> 3D View (Global) and add shorcuts by inserting corresponding operators, i.e. for scale X = 0, enter view3d.scale_x_0:

It should work for UV editor too, just assign the shortcuts again in Input -> Image -> UV Editor.


To select the next or previous bone in the same chain, do this:

Select the armature RMB
Go to Edit Mode TAB
Go to level up [ or level down ]


Is there an add on that can register the visual locrot of bones influences by IK?

Select the bones you need and in pose mode go to the menu Pose_Animation_Bake action. Check Visual keying and clear constraints.


How can I connect an object with particle instances on an emitter via some Curve/Geometry connection

Create an edges between each alive particle and the object using the Create Edges Node then use the Splines From Edges Node to generate splines from that and output it.


You have not assigned the image texture to the material. That's the reason why it's no shown on the cube.
In the material properties, click the yellow dot right next to Base Color and select Image Texture. Then click the image icon with a little arrow next to it that just appeared. In the popup select your image. Done.
Alternatively, go to the Shader Editor. Add an Image Texture node, select the image, and connect the color output of the Image Texture node to the Base Color input of the Principled BSDF.


How to copy and link collection to other scene?

Ensure that the scene to which you want your collection to be linked is selected.

In an "Outliner" editor window, ensure that the "Display Mode" in the toolbar is set to "Blender File" or "Scenes".

Find the collection you want to link under "Collections" or "Scene Collection", and activate "Link to Scene" under its alternate-click context menu.


Armature doesn't stay connected when moving mesh in object mode

Armature Deformation usually works from bone to mesh, not the other way around. There is an option to use a shape key to deform the mesh, and then parent a bone to some of the vertices, but it will not be applicable to your situation. Depending on the rig itself, there might however be a workaround.

Given that the bones have to deform the mesh, what you need to achieve then is to reposition all of your bones in Pose Mode so they form a circle. To do this, you can try the following: Set the rotation mode to individual origins with the button on the bottom left of the screenshot:

This will apply the rotation to each child of the bone individually, instead of just rotating the upmost parent. The bone chain in my screenshot is one single chain, so all bones are in a parent/child relationship. If you now select all bones, and then activate the rotation tool, constraining the rotation to Z-Axis only, you should be able to achieve this:

Rotate it until the circle closes and you're done. In Edit Mode the chain will still be straight, also if you disable the armature modifier visibility you're back to a straight chain.

The logic is: The first bone rotates by X degrees, its first child by X degrees again, the child of that child by another X degrees, and so on. That's why you get a circle in the end. This method is sometimes used when animating fingers curling. If that works with your current rig has to be tested, but I believe there is a chance it will.


That's because each triangle in that model is 'disjointed' , it is not joined to any other triangle. You can join them using Remove Doubles.

In Edit mode, hit A until Blender selects every polygon (Triangle). Then look for the tools menu, and press Remove Doubles.


Can Blender easily render a single image from 3D source files?

The types of images you mention are what you would use in blender to control the surface appearance of a 3D object, that you then position and render into a 2D image.

If you want to merge multiple images into one image, you would be better off using a 2D image editing program like GIMP or Krita. Another option could be using ImageMagick to combine them using the CLI.


Blender Camera Tracking ground plane - unable to adjust shadow darkness

Just to cover the basics first, check the ground plane material; the material settings will affect the shadow's visibility.  Also, if the world is emitting light, that can dim the shadow. Color space can affect it; sometimes filmic will dim it even further in the compositor.

If not, the issue is likely from the render layer's alpha channel.  You can change the alpha's strength with a color ramp or multiply node.  Feed that ramp with the render into a 'Set Alpha' node, which you can then feed into the alpha over node.


How to create stacked rotation with bones? (similar to array mod with object offset)

Using "child of" constraint:

Add the constraint to each of the bones, using "set inverse", relatively to its parent:

Tune the influence to be progressively decreased: 100% for the first then 75, 50 and 25 (as 4 bones in my example).
Notes:
-will work under some limits, because if too much rotation the last bones will turn over the constraint limits.
-scales are progressive too (like array modifier)


Keep particles from fluid simulation in render?

You can sort of do that, using the viewport render:

1) Disable all overlays and set the view mode to rendered:

2) In the domain's material settings panel, set the Blend Mode to Alpha blend and make sure Show Backface is checked:

3) Change the domain's material to Transparent BSDF:

4) If you don't want to see the viewport's background, check the transparent option in the render tab, Film panel:

5) In the viewport, go to the View menu, and make a viewport render:

And here's the result:

You can use this in compositing if you need it to see it in your full feature render. Though I can't think of a way to make it look not overlayed on top or bellow.


Starting from the profile of the rails, you can use the spin tool:


Color ramp isn't working correctly with particle info node?

Here's a demonstration showing just that part of the cycles particle info being used to drive a colour ramp.  Notice I had to also add in another divide just to get the far end of the colour ramp to appear in the view.  You can see clearly that the individual particle blurred paths are constant in colour even though different particles may have different colours.  You might be able to use a spherical gradient in addition to the age and lifetime values to change colour along a long thin particle to create the effect you are looking for.

Here's a crude version of the suggestion above.


The issue is that your objects are too thin.  To fix this, you could scale your object up along the Z axis, or increase the Density Scale, or change the material type to Surface.  I would recommend changing the material type.


It seems that you want to see this image purely as reference when working on your scene. For that purpose, it would be enough to use a small area of your blender screen layout as UV/Image Editor. You can force the UV/Image Editor to always display your image by using the pin icon in the UV/Image editor.


For the edge loop in your picture, with the Pivot Point  set to Median Point, Individual Origins, or Bounding Box Center, you can press SY 0.

That will scale all the selected vertices along the Y axis to 0, meaning all together, because the scaling is constrained to the Y axis, you will get a straight line perpendicular to the Y axis.

SX 0 for the X axis
SY 0 for the Y axis
SZ 0 for the Z axis


Module Import Error in the Standalone Player

The module, to be correctly found by the standalone player, must be placed inside <my_blender_folder>/2.71/python/lib/python3.4/.

So it's completely different from the embedded player (used normally by hitting p in the game engine) (which is <my_blender_folder>/2.71/scripts/addons/)

I finally found it by using a import sys; print(sys.path) and using the standalone player.

This info doesn't seem to be found anywhere in the API docs strangely.


Problem with appending model after previous linking

Well, putting it into words helped me look for the answer. In the outliner, there's a drop down which lists orphaned data. I cleaned that out and then I was good to go. There's also a clean up->purge option in the file menu but I never got to try that.


How to add panel to 3D view Tool shelf in Texture Paint Mode

I use this

bl_<prop>      | allowed
---------------+-------------------------------------------------------------
bl_space_type  | 'CLIP_EDITOR', 'CONSOLE', 'DOPESHEET_EDITOR', 'EMPTY',
               | 'FILE_BROWSER', 'GRAPH_EDITOR', 'IMAGE_EDITOR', 'INFO',
               | 'LOGIC_EDITOR', 'NLA_EDITOR', 'NODE_EDITOR', 'OUTLINER',
               | 'PROPERTIES', 'SEQUENCE_EDITOR', 'TEXT_EDITOR', 'TIMELINE',
               | 'USER_PREFERENCES', 'VIEW_3D'
---------------+-------------------------------------------------------------
bl_region_type | 'CHANNELS', 'HEADER', 'PREVIEW', 'TEMPORARY', 'TOOLS',
               | 'TOOL_PROPS', 'UI', 'WINDOW'
---------------+-------------------------------------------------------------
bl_context     | 'armature_edit', 'curve_edit', 'imagepaint', 'lattice_edit',
               | 'mball_edit', 'mesh_edit', 'objectmode', 'particlemode',
               | 'posemode', 'sculpt_mode', 'surface_edit', 'text_edit',
               | 'vertexpaint', 'weightpaint'

So for you I think it's:

bl_space_type = 'VIEW_3D'
bl_region_type = 'TOOLS'
bl_context = "imagepaint"


How can I tear two bones and their skinned mesh apart during animation?

If you wanna tear a bone chain in a specific joint, you can't just break the parenting of those bones, as this will break the skinning as you noticed.

You need 2 chains to overlap in the location of the tearing (exaggerated with a gap):

The amount of overlapping depends on how your bone weights overlap on the mesh.

You skin the bottom piece to the green armature and the top piece to the red one. To tear the limbs/parts apart you just separate the armatures.

The only problem is mesh smoothing in the area of tearing. You can fix that with normal mapping or with custom split normals that blender now supports.


Where is the recalculate normals button?

Its in the shading/uv tab of the tools panel, on the left. You can also use Ctrl-N to perform the action. If you can't find a button or remember the shortcut, you can use the Spacebar menu to try searching for it


This is an update of lemon's code on the question Convert bones to meshes. Run the script and it will pop a menu asking if you want Pyramid, Tapered, or Box shapes. Pyramid is what the code did originally, tapered uses the bone envelope, and Box takes the average.
This image is "Box":

# from https://blender.stackexchange.com/a/75049/33589

import bpy
import mathutils
from mathutils import Vector
from math import *

class ArmatureMenu(bpy.types.Menu):
    bl_label = "Mesh 2 Armature Menu"
    bl_idname = "OBJECT_MT_Mesh_From_Armature"

    def draw(self, context):
        layout = self.layout
        layout.operator("wm.mesh_from_armature", text="Pyramid").mesh_type = 'Pyramid' # from here
        layout.operator("wm.mesh_from_armature", text="Tapered").mesh_type = 'Tapered' # from here
        layout.operator("wm.mesh_from_armature", text="Box").mesh_type = 'Box' # from here

def CreateMesh(self, meshType):

    obj = bpy.context.active_object

    if obj == None:
        self.report({"ERROR"}, "No selection" )
    elif obj.type != 'ARMATURE':
        self.report({"ERROR"}, "Armature expected" )
    else:
        processArmature( bpy.context, obj, meshType = meshType )

#Create the base object from the armature
def meshFromArmature( arm ):
    name = arm.name + "_mesh"
    meshData = bpy.data.meshes.new( name + "Data" )
    meshObj = bpy.data.objects.new( name, meshData )
    meshObj.matrix_world = arm.matrix_world.copy()
    return meshObj

#Create the bone geometry (vertices and faces)
def boneGeometry( l1, l2, x, z, baseSize, l1Size, l2Size, base, meshType ):

    if meshType == 'Tapered':
        print(meshType)
        x1 = x * baseSize * l1Size
        z1 = z * baseSize * l1Size

        x2 = x * baseSize * l2Size
        z2 = z * baseSize * l2Size
    elif meshType == 'Box':
        print(meshType)
        lSize = (l1Size + l2Size) / 2
        x1 = x * baseSize * lSize
        z1 = z * baseSize * lSize

        x2 = x * baseSize * lSize
        z2 = z * baseSize * lSize

    else: # default to Pyramid
        print(meshType)
        x1 = x * baseSize * l1Size
        z1 = z * baseSize * l1Size

        x2 = Vector( (0, 0, 0) )
        z2 = Vector( (0, 0, 0) )

    verts = [
        l1 - x1 + z1,
        l1 + x1 + z1,
        l1 - x1 - z1,
        l1 + x1 - z1,
        l2 - x2 + z2,
        l2 + x2 + z2,
        l2 - x2 - z2,
        l2 + x2 - z2
        ]

    faces = [
        (base+3, base+1, base+0, base+2),
        (base+6, base+4, base+5, base+7),
        (base+4, base+0, base+1, base+5),
        (base+7, base+3, base+2, base+6),
        (base+5, base+1, base+3, base+7),
        (base+6, base+2, base+0, base+4)
        ]

    return verts, faces

#Process the armature, goes through its bones and creates the mesh
def processArmature(context, arm, genVertexGroups = True, meshType = 'Pyramid'):
    print("processing armature {0} {1}".format(arm.name, meshType) )

    #Creates the mesh object
    meshObj = meshFromArmature( arm )
    context.collection.objects.link( meshObj )

    verts = []
    edges = []
    faces = []
    vertexGroups = {}

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

    try:
        #Goes through each bone
        for editBone in [b for b in arm.data.edit_bones if b.use_deform]:
            boneName = editBone.name
            # print( boneName )
            poseBone = arm.pose.bones[boneName]

            #Gets edit bone informations
            editBoneHead = editBone.head
            editBoneTail = editBone.tail
            editBoneVector = editBoneTail - editBoneHead
            editBoneSize = editBoneVector.dot( editBoneVector )
            editBoneRoll = editBone.roll
            editBoneX = editBone.x_axis
            editBoneZ = editBone.z_axis
            editBoneHeadRadius = editBone.head_radius
            editBoneTailRadius = editBone.tail_radius

            #Creates the mesh data for the bone
            baseIndex = len(verts)
            baseSize = sqrt( editBoneSize )
            newVerts, newFaces = boneGeometry( editBoneHead, editBoneTail, editBoneX, editBoneZ, baseSize, editBoneHeadRadius, editBoneTailRadius, baseIndex, meshType )

            verts.extend( newVerts )
            faces.extend( newFaces )

            #Creates the weights for the vertex groups
            vertexGroups[boneName] = [(x, 1.0) for x in range(baseIndex, len(verts))]

        #Assigns the geometry to the mesh
        meshObj.data.from_pydata(verts, edges, faces)

    except:
        bpy.ops.object.mode_set(mode='OBJECT')
    else:
        bpy.ops.object.mode_set(mode='OBJECT')

    #Assigns the vertex groups
    if genVertexGroups:
        for name, vertexGroup in vertexGroups.items():
            groupObject = meshObj.vertex_groups.new(name=name)
            for (index, weight) in vertexGroup:
                groupObject.add([index], weight, 'REPLACE')

    #Creates the armature modifier
    modifier = meshObj.modifiers.new('ArmatureMod', 'ARMATURE')
    modifier.object = arm
    modifier.use_bone_envelopes = False
    modifier.use_vertex_groups = True

    meshObj.data.update()

    return meshObj

class MeshFromArmatureOperator(bpy.types.Operator):
    bl_idname = "wm.mesh_from_armature"
    bl_label  = "MeshFromArmatureOperator"

    mesh_type : bpy.props.StringProperty(name="mesh_type")

    def execute(self, context):
        print('The mesh type is', self.mesh_type)
        CreateMesh(self, self.mesh_type)
        return {'FINISHED'}

def register():
    bpy.utils.register_class( ArmatureMenu )
    bpy.utils.register_class( MeshFromArmatureOperator )

def unregister():
    bpy.utils.unregister_class( ArmatureMenu )
    bpy.utils.unregister_class( MeshFromArmatureOperator )

if __name__ == "__main__":
    register()

    # The menu can also be called from scripts
    bpy.ops.wm.call_menu(name='OBJECT_MT_Mesh_From_Armature')


I have a problem duplicating a Mesh and again applying curve modifiers to the copy correctly?

You've enabled the Object Offset of the Array modifier, with your curve as the offset object, is there a reason for that? Because it messes your object: as your curve is scaled 6 times, it will also scale your cube 6 times...

Object Offset will array your object taking account of the location, rotation and scale of the chosen object, like for example it will scale your original object increasingly if your offset object has been scaled, which is not what you want, you want a simple array, then a second modifier that makes the array follow a curve.

So disable this option as you just want your cube to be duplicated. It's the next modifier (Curve) that will take care of making your object following the curve.

Also, if you choose to apply the scale of your curve, don't forget, in Edit mode, to bring back the Radius of your curve vertices to 1 (on the N panel of your 3D view).


Why is my finger deforming so weirdly and not following the bones?

To solve this:

Select your armature in Object Mode
Hit Ctrl+A and Apply Location
Select your mesh then keep holding Shift and select your armature
Hit Ctrl+P and Parent with Automatic Weighting

This will fix your problem as shown below:

Updated .blend file can be found here:


How to Connect a Convex Face To a Concave Edge That Fits its Shape Perfectly

You can get it there using Vertex Snapping

Enable vertex snapping
Set it to Active (this will snap the active vertex)
Select the circle and snap it to place

(You end up with some double vertices that need to be merged.)


Trying to import .OBJ from Magicavoxel to Blender, but it imports as a single large object?

Fortunately a plugin to import a .vox file without the need to convert to .obj https://github.com/RichysHub/MagicaVoxel-VOX-importer . Instructions on how to use it and caveats are on that page but will reproduce installation and basic usage instructions here:
Download io_scene_vox.py from the github page and install it into Blender.
In order to enable the add-on, you will need to have Testing add-ons visible within the Blender Preferences menu.

With the add-on installed and enabled, the importer can be accessed from File > Import > MagicaVoxel (.vox)

This add-on imports each voxel of the original model as an individual cube primitive. This opens up the use of voxel models for projects such as physics simulations.


Why the mesh is twisting when base bone is rotated?

That deformation occurs because you didn't add weights in weight paint mode.

Select the armature and change to pose mode
In pose mode with the armature selected click the mesh
Change to weight paint mode
Select bone by bone and add vertex weight

Related:
Vertex Weight Issues


(Others have mentioned this in comments, but the question still has no answer. I am writing this for other people that might run into the problem in the future.)

The position of the sun has no effect on the direction the light is coming from. This is because the sun light is meant to simulate a light source that is infinitely far away. This gives an effect very close to that given by our actual sun, since the real sun is very far away.

Instead, to control the direction the light is falling from, rotate your sun object. Example:

Straight down

Rotated

Note that it doesn't matter where you put the sun. It could even be positioned behind the object. It is always going to give light that appears to be coming from far away, opposite the direction you have pointed it in.


Polygons are rendered as smooth colors instead of solid

In the Tools panels T under Shading you can toggle between Flat and Smooth.
It can be applied to the whole object or only to some selected faces when in edit mode (the option then moves to the Shading/UVs tab).

Update: This option as now moved to the top-left corner of the 3d viewport, under Object in object mode and Face in edit mode.


Blender adding unnecessary edges to flat surfaces

The simplest way to bevel is not to convert the text to mesh, but to use bevels within the curve's geometry.

Converting curves (or text, which is another kind of curve) to mesh will almost always result in terrible topology.


How to avoid obstruction of supposedly parallel sun light?

A 'Sun' lamp is so called because it simulates the light of the sun as perceived on Earth.
Its rays are parallel, from infinity. It has no position, and so no falloff with distance. (Good for you, in that respect.) The position of the lamp's gizmo has no bearing on its effect; only its direction makes any difference. All objects will cast shadows on other objects 'behind' them in that direction.
A quick solution to your problem, either in Cycles or EEVEE, would be to use one Sun lamp, anywhere you like, (inside the Sun object if that seems logical) pointing parallel to the Sun > Planet direction, and with 'Cast Shadow' or 'Shadow' switched off in the lamp's Properties panel > Data tab.
This would also mean planets do not cast shadows on one another.
If you want more particular effects, the answer will vary, depending on your renderer. For example, if you're in Cycles, you may want to prevent planets bouncing light on to one another, using a Light Path node. Or if you wanted the planets to go round the sun, you could use a shadowless point-lamp at the sun's position, with its falloff adjusted if necessary.


Fastest way to move vertices with python

foreach_set() is actually very fast but not usable in my case because I'm not always going through all vertices in all cases.
It seems that the "for" loop is the best way to go.

Using bmesh actually is a little faster because it doen't refresh the scene each time the script changes the location of a vertex.

Thx @CoDEmanX and  @MikePan for the help.


How do I offset animation start in a linked blend?

I don't know if you have solved your problem, but, I had the same situation of  your.

I would like to offset the entire linked objects animation, but it don't appear in the NLA panel without make proxies. In my case, my rosource file has more than 50 animated objects, it's impracticable to make proxies of each one and then offset each nla strip.

My solutions was:
When you thing in animation in Blender, think in armatures! Do not animate objects, animate bones! I've changed my resources files and add one armature to each one. Each object is child of one bone, and the animation is made on the bone. Therefore, when you link your resource, you make only one proxy (the armature) and only one nla offset (the armature's nla).

I hope that I've helped


Here is what I did

For the displacement, I mixed different Noise Textures with different settings to them with a bunch of Mix RGB nodes. At the end, I mixed the Noise textures with a Musgrave texture too add some lumpiness to the displacement.

You can play around with the noise settings to achieve the look you want.

For the color, I attached the noise textures to a color ramp, black being a darker brown, and white being a lighter brown, and plugged that into the base color of the principled BSDF shader.

I didn't change any of the BSDF shader settings, but I realized it might help if you increased the roughness.

I hope I helped out.


Blender objects in outliner, but not visible

All your objects are on layer '1'. When the file opens only layer '5' is set to be visible.

Select the first layer (highlighted in red, below) in the layer selector UI in the 3D View header to make that layer visible:

The orange dot in the middle of the sqaure shows that not only is an object on this layer, but that it is currently selected. The fifth square along, which is grey, shows the currently visible layer. There is no dot in the middle of the square, showing that it is empty.

For more information on using layers, see the Blender Manual.


Extending Sverchok - Development of new nodes in a separate addon

look at ladybug addon for sverchok and even more to sverchok extended nodes addon
https://github.com/nortikin/sverchok/wiki/Dependencies#side-extending-packages
also. But make an issue on nortikin/sverchok for that to proper integration


How to completely remove influence of bone to mesh

The easiest and most straight forward way is to uncheck Deform in bone properties (marked red on the image below). Second way is to delete from the mesh vertex groups named like the bones.


Are UVs important for importing blender mesh into Unreal Engine 4?

The get the most of Unreal you should create a UV map for texturing and non-overlapping Light map UV for unreal to bake cached light and shadow information.

You can use the Smart UV project operator ("U" in edit mode) to quickly get a non overlapping UV map. You can then let Unreal create the Light map UV from this (on import or on the Static mesh asset) based on this.

I would however recommend you to get into manually creating your UV maps in a more controlled way. Texturing/UV-mapping should be considered as an important step as modelling.

Is it necessary? No.

Is it important? Yes (depending on what your ambitions are).


How do I find the controls after adding in an object?

when you add an object in the 3d-view, the creation variables (which you are searching for) are still accessable and editing them can be done. After any modification in the 3d-view (such as selecting another object) the creation variables can no longer be accessed, you have commited to the creation values. Use regular editing for changing the mesh, or create a new object until you're satisfied.


How to temporarily disable pose transformation in Weight Paint mode?

Select the Armature. In Object Data Properties, enable Rest Position.
Don't forget to re-enable Pose Position once you're done.


Thanks to @m.ardito and @Mentalist, I was able to remove the odd shading by locating the internal face and removing it by >> Edit Mode with Vertex Selection enabled, and Select > Non-Manifold.


Editing group node sockets, with no external input?

I downloaded Blender 2.76b, opened my .blend file inside it, and it didn't have this problem. Perhaps it was as easy as that?


How do you optimize Blender/mesh for sculpting with multiresolution modifier?

Edit: This post was made when the referenced tools were still considered experimental and not a part of the official builds.  Now these tools and more are available from official builds.

There is a new option for adding fine detail but it is not fully in trunk yet.  You would have to grab the GSOC Paint build from Graphicall.org.

Psy-f's build has curve and line tools that work as precision stroke brushes.  Maybe that definition is not exactly correct but it's close enough I think. They work in sculpt mode as well but this requires extra geometry which is going to slow you down.

The idea here is to attach a 32 bit texture map(currently available) to your models UV's and then use that as a bump map. As is, this will not create real geometry but instead will create the illusion of extra detail which can be baked as a normal map.  This seems to me to be the ideal situation for smaller detail since anyone would be hard pressed to tell the difference between real displacement and normal maps when it comes to the small scale that you are hoping to work with.  This technique will also dramatically decrease your render times and the possibility of your computer locking up.

If, however, you insist on using true displacement then you can use this bump map in combination with the displacement modifier at a later stage.  This will allow you to work with a lower poly model during the sculpt/modelling process and then you can crank up the multi-res detail in combination with a displacement modifier when it's time to render.

Even still, without the most excellent curve and line tools you can still paint bump maps but it's much harder to get the precision that these new brush tools provide.


Even though you have 'Transmission' bounces set to 12 you are capping the 'Max' bounces to 4, meaning it's never doing 12 bounces. Here I have upped the 'Max' bounces to 6 and the liquid started to let light through:

If you want the liquid to use all 12 Transmission bounces you will have to set your 'Max' bounces to 12 as well.


What steps should I take to speed up an Eevee render?

To reduce render time in EEVEE you can try the following steps:

In the screen space reflections menu and turn off refraction and enable Half Res Trace.
In the sampling menu reduce the samples for rendering.
In the output properties panel reduce the resolution of the from a 100% to about 75% or lower.


Export .obj with normalized UV coordinates

I found the problem. The output was normalized but blenders coordinate system starts in the lower right. My coordinate System in OpenGl has (0|0) in the upper left.


Tile size in performance not changing at all

I'm guessing you have the Render Auto Tile Size addon enabled? If that's true, you can't change the tile size manually. Just disable the addon to input a custom size.


Can't see any fonts except Bfont for text objects

A new font can be loaded by clicking on the folder icon in the Font panel.

Blender will open the directory configured in Preferences > File Paths by default. All font files located in the directory will be displayed. If you've installed fonts through the Install option, instead of Install for all users, they will not be located in C:\Windows\Fonts but C:\Users\[your username]\AppData\Local\Microsoft\Windows\Fonts instead.

Image source: Announcing Windows 10 Insider Preview Build 17704


In the properties panel, under Display / Grid floor, is a Scale parameter. It seems that in your first picture, you set it to 10 (look top left of the 3DView, it says "Meters x10"). That means each square of the grid is 10m ; but your Plane is just a few cm.

Just set the grid Scale to a more appropriate value (0.01 seems good : 1cm for each square of the grid).


(2.8) Do you need to apply subdivision surface mod before UV unwrapping for texture painting?

If you just unwrap it as normal, so that it unwraps the un-subdivided version of the mesh, and then start texture painting, it should work as expected.  If not, you can apply the subdivision modifier and then unwrap.


The basic key to getting the head to react to the motion of the body is using the Slow Parent function. Similar results can be achieved with soft body or cloth sim, however, this method has the advantage of no simulation baking.

The slow parent function is then used the drive the rotation of the head around the center of the body, so that acceleration causes the head to "lag" behind the body.

Setup

First we will set up the rotation of the ball based on location. Start with the ball, next, add an empty. This  will be the control for your droid. I chose the type of circle, and rotated it by 90 degrees along the X axis, and set the display size to 1.1, to create something that looks like a belt:

Next, I named it Ctrl (name your emtpies now, or you will become hopelessly confused).

We want our ball to be at the location of our control object. We could parent it, but that might cause conflict over the rotation later. Instead we will use a copy location constraint, with the object set to Ctrl. leave all other settings as they stand.

In order to have the ball rotate correctly, we will need two drivers, linked to the X and Y location of the control object respectively.

To add a driver, select the ball, and go into the object properties. In the X and Y rotation boxes, enter a pound sign (#).

Next, enter the graph editor, it is time to setup some drivers! Switch to driver mode:

Starting with the X Euler Rotation, we need to add a variable, var. Use single property, and set the object to Ctrl (aren't you glad we named it :D). Into the data bath box, enter location[1]. This will get the Y location of our droid. Set the expression to -var.

Repeat for the Y Euler Rotation, except use location[0] in the data path.
 and var (not negative) for the expression this time.

Our rotation is now set up, but lets quickly look back to the expression we used, -var. This might not seem logical at first, since you'd think we'd need to multiply be π and some number of degrees etc; however, we aren't working with degrees we are working with radians. 1 Radian is equal to a turn such that the each point on the circumference of the is moved along by a distance equal to the radius of the circle in the direction of rotation. Basically, if our droid has a radius of 1, it will turn 180 degrees when we travel π radius. So, when our droid moves π units, it will rotate by 180 degrees, which is the correct rotation. Note the actual expression should be -var * 1 since it is location * radius in blender units. If your droid has a radius other then one, be sure the put the multiplication in there.

After writing this, I did a couple tests, and I am now convinced that the above method of driving rotation produces incorrect results. I am still searching for a definitive answer to this, at least the above method has the benefit of producing reasonably convincing results, so it is being left in.

Now, its on to the head. This is where the slow parent comes back in. For this portion, we will need three new empties all added at the origin. Name these "Drag", "Face", and "Point".

We'll deal with drag first. It needs to be parented to Ctrl, but with slow parent under relation extras checked. The offset will control the amount of forward motion the head has when the droid moves. I liked a value of 1.8, but set it to whatever looks right for you.

Drag now, as it name implies, drags behind the droid. We can use this to drive the position of the head.

Lets work on "face" next. This empty should face drag, hence the name. To do this, we need to use a track to constraint. Add a track to constraint and set the target to drag, that is all that needs to be done. leave the other settings at default. Finally, add a copy location constraint to face, set to Ctrl, like the one we used on the sphere earlier.

Finally it is time to work with "Point". Point works by pointing to the location of the center of the head. when the head is parented to point, it will move to this location on the outside of the sphere. The set up for point consists of two constraints and a driver.

The first constraint is yet another copy location set to Ctrl, like we had earlier. With "Face" and the droid body. The second constraint is a copy rotation constraint, which should have the target set to "Face: and only the X axis checked:

Finally, we need to set up a driver that uses "Drag" to animate the position of the head. In the X rotation property of "Point" add a driver by entering the pound sign (#), and proceed into the graph editor.

Add anther variable, but this time set it from Single Property to Distance and select the Ctrl and Drag objects. Finally, enter var into the expression.

Last but not least, parent BB8's Head to the "Point" object.

Lets watch our droid roll!

Note: The head may act strangely while you position the droid or jump to a different position in the timeline. However, when you play back a completed animation, it should act normally.


How can I select and move only one primitive?

If you have joined 2 objects then you will need to access each one of them by going to Edit Mode

Once you are in Edit Mode, hover your mouse over the primitive you want to select and press L.

You will be able to select a single primitive of your choice.


How to set frame rate to 25 FPS as default?

Just change your default .blend file. In a new Blender window, change the default framerate, then go to File > Save Startup File or press Ctrl + U.


Your armature doesn't work because, you may not see it in Weight Paint mode, but some bones have influence on some meshes while they shouldn't. I don't know how it happened, perhaps your claw was one unique object, you parented it to the armature With Automatic Weight, then you separated your object in several objects?

Anyway, if you want to keep several separate objects, select each one and in the Properties panel > Data > Vertex Groups, delete each vertex group that is not supposed to be here, i.e. every vertex group except the one that has the name of the bone that is supposed to control this part.

You can also join all these different meshes to make one object, then parent this object to the armature with the With Empty Groups option, then select each mesh and in the Properties panel > Data > Vertex Groups, assign it the vertex group it supposed to be part of.


Bone heat weighting: failed to find solution for one or more bones after i remove doubles

I quickly fixed it , First you have to select the robot then press[ ALT + P ] , Then select clear parent and keep transformation

Do that to the armature aswell.

Now select the robot , Hold SHIFT and right click the armature .

Press CNTRL + P

Add automatic weights.

It will now work , if you have problems just ask

Also keep in mind you will have to some manually weight distribution because it does get messy


Flip animation along an axis (Mirror animation)

Select all the bones involved in the animation of the right hand with your mouse over the graph editor press A to select all keyframes (make sure none are hidden), press W or right click and choose copy.
Select all bones from the left hand, make sure they have an f-curve for the selected channels (i.e. insert one keyframe for each channel, loc, rot etc.), select a frame  where you can easily delete the new keyframes.
Go to frame 1 in your animation.
Pres RMB or W and choose paste flipped.


How to display hidden functions in menu bar?

The function is available in Edit mode under Face > Solidify Faces.
You can then adjust it in the pop-up overlay.

I believe all functions are accessible through the main menu bar, they're just hard to find sometimes. :).


Why am I getting errors with Cycles baking from materials?

EDITED

All you have to do is put the same image into every texture you're baking:

It seems to work:


In Edit mode go to tool shelf under Add-> Bisect right click on it and add shortcut a pop-up to give a selection of the key. Add the key. Go to User Preference Setting save user setting so next time it will be save.


How to get a list of vertices from a list of edges in bmesh?

Use sets.
Will most likely be duplicates in the following vertex list, from any connected edges.
selected_verts = [v for e in bm.edges if e.select for v in e.verts]

Converting to set(...) will have only one member for each vertex.
 set(selected_verts)

or defining as set in first place.
selected_verts = {v for e in bm.edges if e.select for v in e.verts}

The set(...) sounds like the way go as you can check intersection between sets of vertices easily.
between sets.


This usually happens when you have Backface Culling enabled. Make sure it is unchecked as shown on the picture below.


When objects were separate, they had their own UV maps as they should have been textured. Let's assume these are called "UVmap" as by default.
Objects had their materials, I assume they were called "Material_1" and "Material_2"; let's call the new material created esspecially for the bake as "Material_Bake".

After joining objects create new UV map and call it "UVmap_For Bake".
Make some arrangements on that new UV map so faces not overlap there (the easiest way is to press Ctrl + P with everything selected that you'd like to rearrange while in UV/Image Editor).

For "Material_1" and "Material_2" in Texture tab, Mapping scroll set Map option to "UVMap", so that the original images are mapped using original map.
For "Material_Bake" choose in Texture > Mapping > Map your new UV map "UVmap_For Bake" so that baked texture to be mapped on the both objects with arranged map:

It seems in your file "BakedMaterial" was assigned to all the model's faces, therefore others didn't affect on the final result.
The original materials should be assigned to those parts of mesh which they were created for.
After joining, you create that new material, but don't assign it to anything or you'll get circular reference in texture stack, empty result, rewritten images etc. Just create it and proceed to the next steps. You can look at 2 ways of how materials were assigned below.

It's most likely that you won't get expected result of baking in the second case.

The file below is the one with the result of incorrect baking, slightly edited. Open it, press Bake and enjoy. It'll bake generated images of one color (unfortunately your files weren't packed) into "Texture_For_Baking" texture.


Physics and simulations generally only affect mesh or particle objects, you often have to convert your curves to a mesh.
If you are using the builtin Blender tree generator Sapling Addon it even has an option to create an animated armature with wind animation, but even then, has far as I know you will have to convert it to mesh to work.

You may keep a copy of the original curve object in a separate scene or another layer in case you need to go back and change something.

It is however possible to use some basic soft body physics on Curve objects if it is well subdivided, although it does not work very reliably.

It seems most settings don't have any effect, except for the Self Collision options, as stated Quick Noodle Physics in Blender Tutorial Youtube Video

The trick is using a highly subdivided curve, there must be lots of actual vertex (display subdivisions are insufficient), then tweak the parameters under Soft Body Self Collision like *Ball Size and Stiffness and turning off Soft Body Goal.

Some other objects set to Collision Physics type must be present at the scene for interaction.


How to get perfect UV sphere Mercator projection?

Update:

Newer versions of Blender now come with a Generate UVs checkbox (that can do as the name says and provides pretty decent maps) when adding a new mesh for most of the objects. Simply access this from the F6 menu or the toolshelf. This option is only available when generating a new object. The layout is below, still not perfect but useful nonetheless .

Add a UV Sphere to the scene and select an edge with AltRMB, next enter Face selection mode and select a face near the edge you marked. Next hit A to select the entire sphere and hit U > Follow Active Quads.

Note the grayed face near the middle of the sphere along the edge, this means that it had been selected before you selected the entire sphere and this is similar to what you should have done.

After unwrapping, you should get a huge UV map in the Image Editor. Transform it as desired, I would recommend aligning one corner of the map to a corner of the image and scaling it via the 2D Cursor.

A perfectly unwrapped sphere sans exponentially spaced UVs which aren't possible unless you tweak the map afterwards or modify the object's geometry.

You might notice a sharp seam near the top of your sphere where the texture stops. This is caused by the geometry of the sphere as the top vertices merge into a single point and the unwrap method basically ignores it.

To fix, just get an edge ring as close as you can to the middle vertex so that it won't be noticeable.


Weird shadow at object intersection in render view

It doesn't look like a shadow but like a Freestyle Stroke.

Make sure you have that unchecked in your render settings:


How to used the mousescroll to as a modal function to, for example, move the object?

The event.type that you get within modal() will be WHEELUPMOUSE or WHEELDOWNMOUSE when the scrollwheel is used.

def modal(self, context, event):
    if event.type == 'WHEELUPMOUSE':
        context.object.location.x += 0.5
    elif event.type == 'WHEELDOWNMOUSE':
        context.object.location.x -= 0.5
    elif event.type == 'ESC':
        return {'CANCELLED'}

    return {'RUNNING_MODAL'}


Is it possible to transition from one material to another in bge?

Create a new material and apply it to the dome, then enable Use Shader Nodes on this material.

Then open Node editor and add your 2 material nodes you want to interchange and  pass them through Mix RGB node.

To switch between the materials animate the Mix Factor.


Why is unchecking emitter not removing text?

That setting only applies in the render. If you turn on rendered shading (⇧ ShiftZ) the text should vanish on cue.


Given a set of points, build a quad mesh such that each point is in the center of a quad

Use Dupli verts

1st mesh with center vertices, under Properties > Object > Duplication switch Verts:

2nd mesh a simple quad (add plane) and parent it under 1st mesh:

if you want to convert it to editable mesh, do it with Shift+Ctrl+A

Edit: To rotate them like in your picture, connect your points with edges so they form concentric ellipses. Extrude them so you have some polygons - this will give those verts proper normals:

Check the rotation in that Duplication tab and convert to geometry, delete the original plane, concentric ellipses and delete the bottom dupli-objects:

The spacing is determined by the position of your input vertices so this should end up in what you want..


Is there any way to turn off light contribution from the HDR environment maps in Blender Cycles?

You can disable the ray visibility of the environment for everything, except for the camera.


Can animation nodes be used for animating a rubik's cube?

It needs some work but possible. You can try using Child of constraints, to dynamically parent the cubes to empties as time going. Here is an example setup:

Also, you can try using particles to generate location set. Like this:

Both solutions are a bit tricky, and not perfect, still figuring out how to fix that, but that's how it goes for now.


No object option when adding a geometry bevel to a curve?

Sussed, it, Idiot me was using a mesh circle rather than a curve circle


Because your light source is too big.

God rays are just interesting/complicated shadow patterns hanging in space. If your light is throwing soft, boring shadows, the god rays of those shadows hanging in the air area going to be blurred and boring too.

Just as a start, here's your scene with the Icosphere mesh light at 1/20th the size, and 100x the power:

Since we just need a small sphere light for this, we'll replace that mesh with a point light as it's a bit more efficient and easier to control. I've set this one to size=0.02 (2cm) and the power to 1000. I also got rid of the volume cube around the object, unless you want some 2-tier rays, you don't need that AND the world volume.

Looks like this

You can vary the sharpness of the shadows by adjusting the lamp size. That will sharpen the rays as well. Here's the point light at 5mm instead of 2cm

Or tweak the lamp colors. Here's 2cm point lamp with an orange color. I also switched to branched path tracing, as it tends to be good with "volume show" scenes like this since you can turn up volume sampling. Plus I flipped on the denoiser:


Scale a face to always fit the same point in global space in an array modifier

Some of possible solutions are to add one more modifier or to apply exhisting one and to continue working with mesh with changed geometry due to that.

Non-destructive way - adding Boolean

Place the rollercoaster where it should be; create ground plane and position it accordingly (so no flying meshes etc). Don't apply Array modifier; instead add one more to stack - Boolean.

Before:

After:

Note that you should position Boolean modifier after Array modifier, so there to be information for Boolean that rollercoaster is arrayed.

Note that Boolean is modifier dependent on mesh itself; results of its work depend on topology of your meshes, their complexity etc.
There are cases when Boolean modifier fails, see related question. That's why it's a good idea to check your meshes for both double vertices and non-manifold geometry. Also check them on Ngons which boolean might not like too.

Destructive way - apply Array

You may apply Array modifier and modifications made by it will become real. You can continue edit them in any possible way:

Turn on snapping, set it to Face mode, select bottom face of the rollercoaster's support, and grab it by Z axis;
It's possible to even join meshes, select all and use Mesh > Faces > Intersect function (when selecting all choose Self-Intersect mode of the operator in Last Operator panel or by pressing F6).

Joining faces may be undesirable, of course (you may separate them after cutting though).
you can add a loopcut to support, turn on again snapping and grab it by Z axis to position loopcut accordingly (pretty much the same as grabbing face).


I found the issue. It was the texture size viewport limit setting that wasn't active on my 2.83 version.


Edge extruding instead of moving the mesh

Hold shift while selecting and then extrude...PS. You need to have at least 1 edge selected for the extrude result not to be a plane!


Blender problem UV texture after applied subdivision surface

It looks like part of your mesh isn't unwrapped and the subdivision modifier streches that part out.

But maybe the newly created geometry is dragged around your entire UV Map similar to this:
In that case try separating part of your leaf using P and then joining both objects again by selecting both in Object Mode and pressing CTRL + J


As i gathered from the comments, your question has already been answered. For future readers:- Uncheck "Front faces only" in the brush tool settings


Camera tracking : solving floor plane when the floor is not flat

If modelling a simple approximation isn't good enough and the scene and ground remains relatively static in the footage in terms of moving objects and lighting changes, I'd try photogrammetry. This allows you to create a 3D model of the scene which can edit however you like. For instance you can extract the ground and use it as shadow catcher.

For open source photogrammetry software I'd suggest MeshRoom. Another good software is COLMAP, it misses some features that MeshRoom has, e.g. texture extraction for the mesh.


Render settings light bounces, you need to increase their count. You can increase the maximum and transmission only for glass other bounces are used in different cases.

Basically light paths or bounces indicate how many times the emitted ray will change direction (hit a surface and bounce of).

Minimum are least number of bounces / light paths emitted. This value should be pretty low for performance but shouldn't be 0.  1-2 works fine for most scenes.

Max bounces indicate maximum number of bounces. If diffuse bounces are set to 10 and Max is set to 5 the maximum will still be 5.

Transmission is for glass objects using ... Well transmission. That's exactly what you're looking for. Keep it high for such a scene.

Glossy light bounces are for reflections, you could also increase that one a bit as well.

Generally only the first 5 bounces change the image quite a lot, the further you go the less visual impact it'll have.
Performance wise it scales weirdly, the first few bounces are the most complex for the program and the rest still slow it down just a lot less.

Just don't set your bounces all the way down to just 1 - 2, it usually looks bad.  :)


Why is my animation not keeping location and rotation correctly?

I found the answer after finding another similar post earlier. The post mentioned a local axis. I checked this on the pieces and found they did not have the same local x axis. I applied the rotation and it now works. How to fix this:

Select the pieces.
Press R,X,X> Move Mouse
If they rotate in different directions then the local x axes are different.
Select all the affected pieces and press Ctrl+A
Left click "rotation"
That should fix other problems that are experienced.


During this commit a constant named IMA_MAX_RENDER_SLOT was introduced and set to 8.

You'd have to change the line

#define IMA_MAX_RENDER_SLOT     8

in source/blender/makesdna/DNA_image_types.h to something else and re-compile to change the number of slots.


https://lists.ffmpeg.org/pipermail/ffmpeg-user/2015-July/027532.html
First Solution
My first solution involves taking the rendered image, saving it to a single tmp.png, then appending that to an ffmpeg mp4 at the end of every frame.
First we need to bootstrap
ffmpeg -r 24 -f concat -safe 0 -i video-input-list.txt -safe 0  -pix_fmt yuv420p -crf 23 -r 24 -shortest -y video-from-frames.mp4

video-input-list.txt looks something like this:
file 'tmp.png'

next we need to copy the frame's boostrapped video into a temp video with do_ffmpeg_with_tmp.sh :
ffmpeg -i input1.mp4 -filter_complex "concat=n=2:v=1:a=0" -r 24 -f concat -safe 0 -i video-input-list.txt -safe 0  -pix_fmt yuv420p -crf 23 -r 24 -shortest -y video-from-frames.mp4```
This ends up copying the video to a temp as well since the input cannot be the same as the output in ffmpeg.

Next we need to call all this in Blender :
```import bpy
def render_image():
    print("after render", bpy.data.filepath)
    scene = bpy.context.scene
    scene.render.image_settings.file_format = 'PNG'
    scene.render.filepath = "tmp.png"
    bpy.ops.render.render(write_still = 1)
    os.system("do_ffmpeg_with_tmp.sh")
    # increment to next frame

while bpy.context.scene.frame_current <= bpy.context.scene.frame_end:
    render_image()
    bpy.context.scene.frame_set(bpy.context.scene.frame_current +1 )

This is all to say that doing it with a video and image buffer that ffmpeg concats at the end of every frame is doable, but image sequences are better. if you're worried about space, you could write a script similar to this one that changes the location of the storage after every 1000 frames or so, then compile the files together later through image sequences and video concatenations.
Second Solution - piping output
I looked into getting a pipe out from blender:
The main issue is that blender is noisy and piping out
If you want blender to pipe you need to have it return a png image and flush stdout.
ffmpeg cannot read a piped in image without image2pipe https://superuser.com/questions/426193/multiple-png-images-over-a-single-pipe-to-ffmpeg-no-file-writes-to-disk.
We convert image to png data and send it accross the noisy wire.
import base64
import zlib
import struct
import sys
import os
def render_image():
    print("after render", bpy.data.filepath)
    scene = bpy.context.scene
    scene.render.image_settings.file_format = 'PNG'
    scene.render.filepath = "./tmp.png"
    bpy.ops.render.render(write_still = 0)

def png_to_base64(png_bytes):
    return 'data:image/png;base64,' + base64.b64encode(png_bytes).decode()

def img_to_png(blender_image):
    width = blender_image.size[0]
    height = blender_image.size[1]
    buf = bytearray([int(p * 255) for p in blender_image.pixels])

    # reverse the vertical line order and add null bytes at the start
    width_byte_4 = width * 4
    raw_data = b''.join(b'\x00' + buf[span:span + width_byte_4]
                        for span in range((height - 1) * width_byte_4, -1, - width_byte_4))

    def png_pack(png_tag, data):
        chunk_head = png_tag + data
        return (struct.pack("!I", len(data)) +
                chunk_head +
                struct.pack("!I", 0xFFFFFFFF & zlib.crc32(chunk_head)))

    png_bytes = b''.join([
        b'\x89PNG\r\n\x1a\n',
        png_pack(b'IHDR', struct.pack("!2I5B", width, height, 8, 6, 0, 0, 0)),
        png_pack(b'IDAT', zlib.compress(raw_data, 9)),
        png_pack(b'IEND', b'')])

    return png_bytes

render_image()
bpy.data.images['Render Result'].save_render("/tmp/tmp.png")
r2 = bpy.data.images.load("/tmp/tmp.png")
print("*#*#*#")
print(img_to_png(r2))
#file = open('/tmp/stufff.png','wb')
#file.write(img_to_png(r2))
#file.close()
sys.stdout.flush()
print("*#*#*#")

To compensate for the noise we use a runner:
import sys
from subprocess import check_output
render_progress = check_output(['blender','--background','--python','pipe_image.py','scripting_ffmpeg.blend'])
msg = render_progress.split('*#*#*#')[1]

print(msg)
sys.stdout.flush()

This is what we use to pipe png files out. However the only remaining problem to be solved is to pass the frame in through the runner and find the amount left in the render, and to put the runner in a while loop to output piped data.
This should provide piped image output to the ffmpeg. Its a very complex process.Maybe even needlessly so. I explored it though.


How do I subdivide smooth in blender 2.8?

Welcome to Blender Stack Exchange!

It appears that they have removed the Subdivide Smooth option in 2.80 (at least  in the version I have). However, it's always actually been a bit redundant as the Subdivide tool has a Smoothness slider that, when set to 1, behaves the exact same way as Subdivide smooth did. Plus, Blender will use your most recently used settings when subdividing, so it will the Subdivide tool will act exactly like Subdivide Smooth until you tell it otherwise (or close Blender). The Subdivide tool should still be in the specials menu like before.


Why does not Animation Nodes provide the uv information properly?

Load UVs option is hidden by default. You have to enable it.


I did not get it to work with the transparency shader but it seems to work when I just attach the Alpha of the Logo (although it has no alpha channel, I believe - it is just a jpg) to the Fac of the Color Mix Node.


Do not enable the [Tap] option. It makes no sense.

Background

The Always sensor "always evaluates positive".

Any sensor will trigger all connected controllers when the evaluation result changes (from not positive to positive and from positive to not positive).

As the always sensor never evaluate not positive, it will only trigger when the object was just created. So it is more a "is created" trigger.

There are configuration options that modify the behavior of the sensor. You set the Tap option. This option changes the behavior of the sensor to evaluate not positive the next frame after evaluating positive, regardless of the real situation. This was introduced to make the use of the keyboard sensor a bit more comfortable.

As you enabled that option, you get this processing from the always sensor

frame 1: evaluate positive -> (result changed): trigger the controller
frame 2: evaluate negative (because of Tap) -> (result changed): trigger the controller
frame 3+: evaluate negative -> no trigger

Solutions

Assumption: single trigger

With the default settings (no Tap, no Triggering Levels, no Inv ...) the always sensor (and the delay sensor) will trigger the controller exactly once.

With that Assumption (one trigger) you can run your Python code as is.

Common use case

When you have different settings or other sensors (like a keyboard sensor) you need to implement the supposed behavior of a controller.

You ALWAYS check the status of ALL connected sensors and consider that in your custom code.

if all(sensor.positive for sensor in bge.logic.getCurrentController().sensors):
    ...
else:
    ...

Remark: even the basic controllers (AND, OR ...) do that. That is the minimum code you should write (unless the above assumption applies).


How do I keep my cylinder from being filled?

I suspect your normals are inverted on the inner faces. In Edit mode, press A to select all, then Ctrl-N and re-export.


Copying pose of one leg to another withouot using x- axis mirroring

I don't know if there's another way to do it than this one:

First make sure that the axis of your second bone is good:

Create the animation for your first bone. Select the keyframes in the Dopesheet and copy, make sure to have the Only Selected (little arrow icon) option enabled:

Select the second bone, in the Dopesheet create a keyframe on its rest position (this step seems necessary):

Now paste in the DopeSheet, it creates new keyframe(s), the second bone has now the same animation as the first one:


Just toggle one of your nodes off and on again.
Viewer/Composite nodes refresh only when there's a change in the compositor.

You can use M on your keyboard to Mute/Unmute a node.
Or just disconnect and reconnect it.


How to draw a for e.g. a grass ground in texture paint within blender 2.8?

You have it almost ready - under Texture in the Properties Panel tool settings, leave the image brush set to Tiled but make your brush a white color and full strength.


You need to have an inner edge loop on the top side of the edge in order for the bevel tool to work properly.

You either need to:

Select all the vertical side faces and extrude outward along their normals

OR

Delete some of the top faces that connect to the corner
edge. Then you can extrude the corner edge in slightly to achieve
the inner edge loop.


You simply imported the mesh, and that is it. You have no lights in your scene. You (kind of) need a light to see your object. You also could use an hdr, but that is just complicating things unnecessarily.

For just a simple test render, or so you can see your object, a three point light setup will work (and make Gleb Alexandrov cringe).

You also need to turn off Auto Smooth for your object. There is something about the bad mesh (probably has to do with the normals) that is making auto smooth break.
Auto Smooth is found in the mesh tab of the properties window.

After the two changes I listed above, I rendered out your object like this.


Missing Blender Prefs folder on other Mac user account

Never mind.
I thought that a Blender folder automatically got created upon the first launch of Blender under that account.
But it turns out that you need to save some preferences of some sort in order for that folder to be created. Once you do that the folder appears, and then just swap out the 2.92 folder for the one containing the preferences your desire to copy over.
Or you could just create the ~/Library/Application Support/Blender/ folder yourself. There is no need to rely on the app to do it.
Pretty simple stuff. My mistake was just based on the flawed assumption that it gets created on first launch. But it's actually on first prefs save.
Please move along, nothing to see here...


how to color in 'wave' procedural texture (cycles)

You can do this by putting the Color or Fac output of the texture through a Color Ramp Node and adjusting the colors and positions of the markers. This works both for Cycles and Blender Render
Cycles

Blender Render


The solution is to disconnect the normal input connected to the fresnel node.

The cause is the order that things get calculated. In your example the normal value is calculated to fulfil the material needs, then the constraint is applied and the result is sent to be rendered. Without the normal input, cycles uses the normals of the object during the render, which means the normals are calculated after the constraint is applied.


Thanks for all the suggestions! I found out that my mirror modifier wasn't melding the center vertices.

To fix my problem I had to delete the modifier, duplicate my Bezier-object, manually delete the center vertices and redefine the broken segments.


Blending Displacement Textures with Geometry Node - why doesnt it work?

The issue with your file seems to be Experimental Feature Set, where you use Adaptive Subdivision Surface modifier. Switching to Supported Feature Set works with Normal node (also easier to adjust direction).

I know it is not a solution if you want to keep Adaptive Subdivision, sorry.
It gives me an impression it's a loop that should not work, because Displacement node is waiting for Normal that is generated from displacement ... I would expect result of Normal calculated from flat plane, but it is calculated from output of Displacement that is at the end of node tree. It is like a question what was first - egg or chicken. But it works :)
It is out of my understanding how shader data are used by regular Subdiv vs Adaptive.
BTW - for Micro-displacement (Adaptive Subsurf) you don't need such high dense mesh, four vertices are enough.

Here is a test from scratch to avoid hidden things.

Feature Set - Supported
Few times Subdivided W Plane with classic Subdivision Surface modifier set to 4
Material Propeties > Surface > Displacement+Bump (even there is not bump set result is much detailed, hm)

Or you can use Separate XYZ node as factor for mix.. Mix node with colors plugged into Diffuse shader is just to better visualise effect.


Have you turned on file compression?

Other Alternative would be to zip - trying to zip a already compressed file would make little difference - your file up and try other cloud services like dropbox or mega.co.nz. if your file is just too big.

If you file contains animated simulation data, it's wise to delete them before uploading the file. Also you will want to keep what is necessary to discuss the issue you were having, meaning deleting all the other elements that would not matter to the problems on hand.

CONCLUSION
78mb on the one circuit board object named "curve.001". It's the poor conservation of polygons. Meaning your object have too many polygon for it's purpose. The film strip object is too high res in the mesh count too, with very bad topology if you want it to bend nicely along a bezier curve.


I don't think Blender has any preset sounds, it's just what you import.
https://docs.blender.org/manual/en/latest/editors/vse/sequencer/strips/sound.html


Import Rhino into Blender - problem sculpting

Firstly, welcome to the Blender world.

Sculpting works on the vertices mainly, means the density of the mesh needs to be high enough, while you also have another problem due to the object import.
I would guess that the object you have is build of split parts, means the caps and the cylinder are not really merged.
To check this you can go in edit mode and select a vertex of the cap, pressing L should then only select the cap. Means the cap is a loose geometry and not connected to the rest.

Solution of the first part needed:

Select the object and go in Edit Mode
Press A to select the entire objects elements
Press Alt+M "by Distance" to merge all vertices that are sharing the same location, essentially merging the caps with the cylinder part.

Now to the sculpting part, you have 2 options:

Using Dyntopo, which will allow you to set a certain density that will be dynamically used to sculpt and change the mesh while you sculpt. Easy to use on low density meshes. The lower "Detail Size" you set, (shown in the picture below) the finer mesh will be generated at the parts you sculpt, causing the mesh to gain a lot more vertices/density.

Increase the density of the mesh manually, either by using a subdivision surface modifier, which can casue problems without control-loops, or by using the "Subdivide" function in the context menu by RMB in edit mode.

I would recommend to try the dyntopo method first to see how it works out, as the other option includes a lot more work to be able to start sculpting.

And finally regarding the back to rhino idea, i do not know if rhino can work with the resulting high density mesh. As far as i can remember back (long time) Rhino was Nurbs based.


Best way to make particle lines on cylinder

Here's a shader approach. I'm not going to illustrate the tree; it's (perhaps unnecessarily?) big, and most of it isn't interesting - it's just plumbing to recover things like cell-centers from a randomized cell-grid.
This though, is the principle that's being followed:

A 1D Voronoi texture gives us distances from randomly-distributed centers in the U dimension. (stripes, on the left).
Another 1D Voronoi texture gives us stripes in the V dimension in the same way. But this time, the texture is shifted per U-stripe, by adding a multiple of the 'R' of the random-per-stripe Color output of the first, U, Voronoi, to the V Voronoi's location in its one dimension. (shifted stripes, center)
The two Voronoi textures are intersected, by considering the U Voronoi and the shifted V Voronoi as the X and Y of a vector, and taking its length.
The Object Info node > Random output is used as a lookup into a White Noise texture to shift the entire space in which these texures are calculated. This gives a random-per-object result.
The linked .blend shows you the tree that does this, and a node group made from it.
The node group has the inputs:

Object Seed: randomizes the textures on all objects
X and Y 'Gaps' This modifies the 'Gappiness' - the average space between stripes, and dots-in-stripes.
X and Y Randomness. The lower these numbers, the more closely the texture approaches a regular grid. Tweaking this  a little can avoid dot-collisions.
Dot Size
Y BaseLine.  A margin below which dots will not appear, masked in such a way not to clip any dots. We could add a top margin that works the same way, if needed.

The Outputs are:

Mask. A mask of the dots, white out of black.
Distance: the distance of the shading-point from the nearest dot.
Cell center: the location of the center of the Voronoi cell containing the dot, in the original UV space. A sort of 2D 'Dot ID', could be useful for coloring dots separately, etc.

The group is used in the .blend to produce this:

If you go for this approach, with Node Wrangler enabled, you could Ctrl-Shift click around the nodes to figure out what the tree is up to.. and maybe improve it :)


If blender freezes while script execution, you should check performance using build-in modules.

In some cases you can cache function return using functools.lru_cache.

The one way to get more resources is using multiprocessing.


How to scale primitive shapes in Blender so that they are within a [unit] sphere?

Use the bound box.

Result on Default cube scaled to fit in unit sphere

Half the length of one of the principal diagonals of the bounding box will be the radius of an encompassing sphere.

Simple test script.  Looks purely at local coordinates from the bounding box and scales such that will fit in local unit sphere.

Note this ensures they fit in a cuboid that fits in a sphere, not such that it fits perfectly into a sphere.

import bpy
from mathutils import Vector

def bbox(ob):
    return (Vector(b) for b in ob.bound_box)

def bbox_center(ob):
    return sum(bbox(ob), Vector()) / 8

def bbox_radius(ob):
    bb = list(bbox(ob))
    return (bb[6] - bb[0]).length / 2

context = bpy.context
for ob in context.selected_objects:
    scale_factor = 1 / bbox_radius(ob)
    ob.scale *= scale_factor

Max vert from centroid.

Result on Cone

A similar method could be employed that looks at maximum distance from centroid on a per vertex basis.

def mesh_radius(ob):
    o = bbox_center(ob)
    return max((v.co - o).length for v in ob.data.vertices)

context = bpy.context
for ob in context.selected_objects:
    scale_factor = 1 / mesh_radius(ob)
    ob.scale *= scale_factor


Camera in BGE seeing through non-transparent solids when having small near clipping distance

EDIT2: The issue was finally found to be related to the absurdly small
  (0.00000001) 'camera near clipping distance', which I have set to see
  my own cheek-plate. It has nothing to do with offsets, levels of
  detail or parenting.

You found the issue by yourself. I just want to answer the followup question:

  why this should cause such a problem.

The 3D engine of the BGE uses Z-Buffer processing to "sort" the rendered pixels. This means your scene will be "sliced" between the near and far clipping distance of the camera.

Within one slice the render can't decide which face is in front of the other. So it will pick more or less a random one. That is the reason why you should avoid planes covering each other with a very small distance (e.g. a painting at a wall). This can cause Z-Fighting at pixel level.

In orthogonal mode you see the same detail level at all distances. Therefore the z-Buffer is equally distributed (all slices have the same thickness).

In perspective mode the object near to the camera are rendered with more visible details than objects more far away from the camera. The sliced near the near clipping plane are thinner while the slices near the far clipping plane are thicker.

As you setup a really close near clipping plane you get a really detailed helmet with the costs of the other characters end in very thick slices.

I assume the result was that the complete shield and the legs are within the same slice sometimes rendered in the wrong order. The slices are so wide that you can't see pixel-wide Z-Fighting (or it is not obvious in your sample images).

Solution

Obviously the near clipping plane should not be that close. When you set up a more practical value (e.g. the default value) you should avoid the z-fighting effect.

There are several different options to show the helmet.

use an overlay scene to render the helmet (best option)
move the faces of the helmet more far away that it is still in the camera frustum


try to rotate the object (the initial petal) where the petals are inheriting from, in object mode or even in edit mode if it has modifiers on it.


This is possible in BGE using an action actuator.

https://cdn.discordapp.com/attachments/387475783838466051/597625497622544384/animatelightscolouration.blend

However I think there's a bug before 2.78 that doesn't allow you to do this.


You can use fake reflections (quite the same as a Matcap), here is a tutorial :
https://www.youtube.com/watch?v=H1t7fMKVuQs


Error importing several meshes from single dir

os.listdir only return name and extension and subdir for a Dir, you didn't indicate the relative directory path or absolute path for filepath to search the file by name.

You could use os.path.join() to join your path:

dir_path = ("C:\stlfiles")
files = os.listdir(dir_path) # if you just create a reference to dir, why not use it directly?

for file_name in files:
    if file_name.lower().endswith('.stl'):
        full_file_path = os.path.join(dir_path,file_name)
        pass #do something to full_file_path


Artifacts in rendered geometry which appears okay in openGL / Solid view?

Your real problem appears to be scale:

I think caused by clipping plane being way beyond what is necessary.

You had it set to 1mm - 1km
Overlapping faces
My first impression is that you are trying to fix the wrong problem. I suspect that the reason you are using BSurfaces is because you don't know why you are getting scratches. The scratches is a much more interesting problem, and knowing how to fix those will help you in future modelling.
If I am correct, the 'scratches' as you call them, are the result of overlapping geometry, and this results in z-fighting. The scale you are modelling at compared to the viewing world scale will result big enough rounding errors to make this noticeable.


If you're talking about reseting/applying global scale, rotation, location then you can press ctrl+A shortcut and select the needed option.


Get pose from bones that get motion from parent objects

You need to Bake the pose into an Action using visual keying:

Pose > Animation > Bake Action
You can bake 1 frame by setting the start and end to the same frame
Set Visual Keying ON
Set Clear Constraints ON
Set Clear Parents ON
Bake Data to Pose

Now you should have an action with desired pose keyed.

You can load this action into Pose library (make it suitable for pose library with help ring icon)


Only render what's visible from camera's view when creating multi-layer EXR?

Separate the object you want to render by layer.

Place the render object on layer 2. (e.g. Torus)
Place the masking objects (all other objects) on layer 1. (e.g. Cube)
Make both layers visible in the Scene's layers.
Set the Layer to layer 2 in the render layers tab.
Set the Mask Layer to layer 1 (or more) in the render layers tab.

The objects on layer 1 will now act as a mask.

Compositing in Photoshop

Sadly, stacking these image on top of each other messes up the premultiplication / alpha / hard to explain.

Here's how to composite these two layers in Photoshop.

Basically, we add all akphas together, add all colors together, then use the alphas as a mask.

Create layers containing only the alphas.
Set the lowest alpha layer to Normal blending mode, the others to Add.
Merge the alpha layers creating an alpha for all layers together (you could also render this from Blender).

Create a group (folder) for each layer. In each group add a black solid layer below the imported image.
Set the lowest group's blending mode to Normal and all other group's blending modes to Add.

You should have the original image infront of black now.

Group all existing groups into a new folder. Set the alpha mask for this folder.

Although this setup is tedious, you can now edit the individual parts, while previewing the final result.


Emission: Red glow while the object itself is white

If you really want to use Cycles: Add a box which encloses the entire scene, add a principled volume shader to the box and play with Density and Anisotropy:

In comp you can add a Denoise node to save render time and a Glare node to introduce a soft glow:

If the volume takes forever to render, a few blur nodes with various blur amounts can introduce a 'colorful blur' in comp as well:


how to create half circle surrounding in rounded column/pillar?

You could add a cylinder and inset each face (I to inset, then F6 and change to 'individual'). Then extrude inward and bevel the edges as necessary.

The result looks like this. The geometry may be difficult to work with if you're using a subdivision surface, in which case I would add extra loop cuts on the edges between the insets to connect horizontally.


Emission node in 2.81 not working iun Cycles

There are multiple shader nodes that you can use to build materials. The "Principled BSDF" is an uber shader which gives a lot of options in a single node, one of which is emission. That shader will emit light when the color is changed to something other than black. If you want an image to be used as an emission light, plug the image into the color input on either the emission node or the principled bsdf, not both.


Shade smooth render looks like Shade Flat

Changing the color space of your normal map from sRGB to non-color in the texture node should fix your problem.


The blend file that you have provided doesn't render to the image above.  It is always a good idea to pack external files into the Blend file.  However, my guess would be the sun lamp you have in there is managing to reach that part of the scene and provide some highlights on the surfaces you are getting the bright spots on.  A quick test would be to turn off the sun and see if the bright spots remain.  If they go away then you can be sure that the sun is the source.  If you still want the bright area at the rear of the scene then you may need to rotate the sun a little or change it to a point source and add a Color/Light Falloff node into the strength.


Start with a loop cut around your object:

Give the loop some thickness by beveling it with Ctrl+B. Select the new faces around the edge (but not on the existing extrusion), and "extrude faces along normals".

Select the top and bottom edges of the new extrusion:

Then use Ctrl+B to bevel again, this time scrolling the mouse wheel to add more segments. Move the mouse to adjust the bevel until it looks right.

If you're concerned about clean topology, you may need to add some new cuts into the extrusion that was there before the loop, and remove the new overlapping face created by the extrusion, but otherwise it should be fine.


Snap two objects face to face in object mode?

To do this:

Select the object you want to snap it to the other object
switch to edit mode
switch to face selection
Select the face you want it to be the one touching the other object
Hit Shift+S
choose Cursor to selected
Hit Ctrl + Alt + Shift + C and choose Origin to 3D Cursor
switch to object mode
Select the object you want to snap another object to it
Enter to edit mode
Switch to Face Selection
Select the face you want to snap the other object to
Hit Shift+S
choose Cursor to selected
switch to object mode
Select the object you want to snap it to the other object
Hit Shift+S and choose selected to cursor
That's it
you need to set the origin of the snapped object back to normal using Ctrl + Alt + Shift + C and choose Origin to Geometry


While i havent seen it doen inside the game engine, it has been done inside blender. there is a great stack exchange answer here How to move an Arduino's servo motors using Blender?

To use this in the game engine you would need to modify the python code to use the game engine modules, and connect it as a python script controller in the game panel.


Either

Select the part you want to separate and press P Separate > Selection
Or press P Separate > By Loose Parts parts to break whole the object into all independent parts

You can quickly select all linked geometry inside the same object by selecting Faces/Edges/Vertex and then pressing Ctrl + L, or by hovering the cursor over some peace of geometry and pressing L


Any way to make a curve from intersection of two objectives?

You could duplicate one of the objects, use boolean modifier with the other object and apply it. You would get geometry that contains the edge, so only problem left is to select it. You could use ctrl+clicking to select shortest path and this way select all the edges you need, then invert selection with ctrl+i and delete everything else. Once you are left with a mesh object that contains only edges of the intersection edge, you can convert it to curve (Object menu-> Convert To-> Curve)


How to apply the effects of weight painting instantly?

Select your mesh and in the properites panel, modifiers tab, enable thoose little two buttons on the armature modifiers: in this way you will be able to see the effect of all weight paint strokes in real time.


How to slice an object depending on whether it is in camera or not

With the help of rob I've figured out how to do it and to help people that have a similar question in the future I post this answer. It is made in a way so that it is fully scriptable, you can of course do it by hand.

Remodel blenders camera
Set a real blender camera as parent object. This step can be done in a
seperate file if you then append it.
Position the parent-camera however you like
Extrude the remodeled camera
Add a boolean modifier to the remodeled camera and select the other object
that you want to cut out
Apply the modifier and delete all the stuff you don't need.

Important: For my project I only need the 3D shape, if you need the materials textures etc. you'd have to figure out how to also include it, because it won't be there after cutting (probably just add the boolean modifier to the car)


How can animated shape keys be used in the NLA when a character is linked from another .blend?

I created a .blend file start with the default cube.  I gave it a relative shape key and shrunk one of the faces.  I then added keyframes at 1 and 31 with influence 0 and 1.0 respectively.  That makes the face shrink over time.

I then duplicated the cube with alt-d.  Since both cubes have the same mesh, the action is on both of them.  I made a single-user copy of the mesh by clicking the [2] button next to the mesh's name.

It still had a link to the action datablock.  While there are probably easier ways to do this I went into the NLA editor and used the vv icon to move the action into a track, then I deleted the track.

Now I have one cube with the action, and another cube with no action.  I think I am at the point where I can answer your question.

I took the cube that has no action and in the NLA editor I used the menu Add > Add Track to put an NLA track on it.  Then I use Add > Add Action Strip and select the KeyAction.  This causes the action to be added as a strip in the track starting at the current frame of the timeline (I had my time cursor at 31).

Now I have two cubes, each with its own mesh datablock (although they have identical shape keys) and those shape keys are animated by the same action, but the action occurs at different times, because the strip is offsetted.

Although this may not be exactly what you want to accomplish, maybe it shines light on the relationships between the datablocks and guides you to your answer.


In my answer I will only cover the importance of good UV layouts for real-time graphics engines, because it's the only topic I have enough experience in to write about.

Importance in Real-time Graphics Engines
Besides giving artists the advantage to hand-paint models, good UV maps are very important for any type of real-time graphics engine (the likes you'll find in any modern game engine). The reason for this is obviously performance.

Enter the wonderful World of Draw Calls:
Simply put, every time a graphics engine needs to draw an object with a texture-based material (one or multiple textures) on the screen, it sends a message to the CPU to load the object mesh data and the material from the storage medium (conventional hard disk, ssd, DVD,...).

The CPU then sends the data block to the already waiting GPU, which processes the data block into a visual representation on the screen.

If you dive further into the matter, you soon find out, that every UV island has seams that produce another draw call per seam, while the GPU figures out how to stitch the islands together.

Every draw call produces load on CPU, GPU, RAM, VRAM and the storage medium. If you have loads of them, the frame rate will suffer.

Conclusion
Again, in highly simplified terms, you get the amount of draw calls per object by adding up the materials and the texture islands on the UV map.

This is the reason why game asset artists try to use every trick in the book to use the maximal available texture space while maintaining a the lowest amount of UV islands.

Further Information on Draw Calls
Simon Scheibt's Render Hell delivers the most complete source on the topic that I know of.


How do i select multiple object Using Python Script?

If you want to select all objects at once, then use: bpy.ops.object.select_all(action='SELECT') (select_all operator). In case you want to only select a subset of objects you have to iterate through the list of scene objects (bpy.context.scene.objects) or through the list of objects in the blend-file:

Blender 2.7x

# Deselect all objects
bpy.ops.object.select_all(action='DESELECT')

for o in bpy.data.objects:
    # Check for given object names
    if o.name in ("Cube.026","Cube.027","Cube.028"):
        o.select = True

Blender 2.8x

# Deselect all objects
bpy.ops.object.select_all(action='DESELECT')

for o in bpy.data.objects:
    # Check for given object names
    if o.name in ("Cube.026","Cube.027","Cube.028"):
        o.select_set(True)


Why is Blender muting the first split second of sound in the rendered video file?

Try moving the audio clip in blender so that it starts at frame 1.

To do this, select your audio clip and press g.