I think the best way is to build this mesh again. Here is my solution on how to do it properly:

Add a low poly (8 vertices for example) cylinder and subdivide it as many times you like verticaly/ horizontaly.

Select single edge and press Shift+S--> Cursor to Selected.

Press Alt+Shift+S and move the cursor from left to right (or input a value 1). It will make the edge spherical.

Repeat the proces with other edge loops. Select the next one and press Shift+R. Make all of them spherical and then cut the holes.

Delete half of the cylinder and scale it in y axis using proportional editing. Now all look super smooth.


I am having trouble with the subdivision surface modifier

Subdivision Surface modifier folds stuff. It's kind of meant for that. It smooths your mesh, it's not like it actually subdivides. It emulates subdivision placing "imaginary" vertex in middle of the existent ones. Those imaginary ones can't be edited, they move calculated by the program as you move from point to point the real ones, and when you apply the modifier, just then they come to life. There is no way to correct that bending using just the modifier, I believe.

Why don't you try, actually modifying the mesh using Space->Subdivide or in the viewport in Edit Mode: T(on left of view port) ->Subdivide ?

Be aware that will add real vertex to the thing and make it heavy if abused. Next time if you are planning on doing all with the Subsurf, start right from the start using it, and model your thing with it active. I'm telling you that doing that will turn your crazy, because the program will still smooth the planes; I mean you will be working with the vertex putting them in places that make your modified by modifier mesh "nice" to the eye, but at the moment of turning the modifier off at any given moment, you'll realize that the vertex are not actually where you put them. Because the modifier calculates stuff placing them that way so that the algorithm for the modifier shows you nice stuff.

For the time being, use the Subsurf modifier for organic stuff of smooth stuff, and not for sharp edged things like rocks, guns, etc. You can always use cylinders, cubes and subdivide them with "real subdivide". And turn on the Smooth shading in the T menu (on left of view port) in Object mode.

EDIT: Please, take a look at this page. These are the geometries you need. Although 2nd option may be better since doesn't require you to add geometry at all.

Keep sharp edges when using subdivision surface


v2.8 beta EEVEE, transparent mask is black instead of transparent

For it to work I changed the Blend Mode to Apha Clip. That's all it needed for it to work.

Materials tab> Options> Blend Mode> Alpha Clip


Blender 2.8 comes with a plugin pre-installed called MeasureIt. This allows adding Measurement notations as scene data.  You can then render the annotations separately and composite them back in. In order to get your measurements rendered, all you would have to do is:

Click on the Render button in the Render panel which is going to render your measurements as a separate image based on the active camera
Open up a new Compositor window or just switch the workspace to Compositing, add an Image as well as an Alpha Over node
Set the image for Image node to generated image by the MeasureIt add-on
Plug your rendering into the upper socket and the generated image into the background (lower) socket of the Alpha Over node

Note: MeasureIt is a large and complicated tool, some research is required. I'd suggest have a look into the manual: https://docs.blender.org/manual/en/latest/addons/3d_view/measureit.html or watch some time consuming youtube tutorials.


What does the "F" mean in-front-of these Grease Pencil brushes?

F is a "Fake user":

Fake User (shield icon) Keeps the data-block saved in the blend-file,
even if it has no Real User. When activated an “F” will be shown
before the name in the list.

Any data block with no users (for example, material that not used in scene) will be deleted after reloading scene. If you want to keep data block in scene (I think, you want to keep brushes!) you should mark it as "Fake user". In 2.80 version F replaced by shield icon,  but "F" still presents in lists


Blender python process killed after rendering

I ran the script at the background using simple python script:

import os
import sys

if __name__ == '__main__':
    blender = sys.argv[-4]
    amount = int(sys.argv[-3])
    scene = sys.argv[-2]
    script = sys.argv[-1]

    os.system('rm -rf ./temp_idx.p')
    for i in range(amount):
        os.system(blender + ' ' + scene + ' --background -P ' + script)

To overcome the loop issue (how can I keep the correct index) I dumped the index to a file and read it each time:

import bpy
import os
import pickle
import math
import random
import sys

def deg_to_rad(deg):
    return deg / 180 * math.pi

scenarios = pickle.load(open("./scenarios0.p", 'rb'))

START = 0

context = bpy.context

try:
    idx = pickle.load(open("./temp_idx.p", 'rb'))
    pickle.dump(idx+1, open("./temp_idx.p", "wb"))
except FileNotFoundError:
    idx = START
    pickle.dump(idx+1, open("./temp_idx.p", "wb"))

try:
    my_dirs, num_models = pickle.load(open("./temp_dirs.p", 'rb'))
except FileNotFoundError:
    d = './car_collection/'
    my_dirs = [os.path.join(d, o) for o in os.listdir(d) if os.path.isdir(os.path.join(d, o))]
    my_dirs.sort()
    num_models = len(my_dirs)
    pickle.dump((my_dirs, num_models), open("./temp_dirs.p", "wb"))

old_objs = set(context.scene.objects)
my_cars = scenarios[idx]
for j in range(len(my_cars)):
    rand_idx = random.randint(0, num_models - 1)
    file_loc = os.path.join(my_dirs[rand_idx], 'model.obj')
    cur_objs = set(context.scene.objects)
    bpy.ops.import_scene.obj(filepath=file_loc)

    imported_obj = set(context.scene.objects) - cur_objs

    for obj in imported_obj:
        obj.scale = (5.3, 5.3, 5.3)
        obj.rotation_euler = (deg_to_rad(90), 0, deg_to_rad(my_cars[j][1]))  # Roll, Pitch, Yaw
        obj.location.x = my_cars[j][0][0]
        obj.location.y = my_cars[j][0][1]

scene = bpy.context.scene
scene.render.filepath = './renders_wed/' + str(idx) + '.png'
# bpy.ops.render.render("INVOKE_DEFAULT", write_still=True)
bpy.ops.render.render("EXEC_DEFAULT", write_still=True)

to_delete_objs = set(context.scene.objects) - old_objs
for obj in to_delete_objs:
    bpy.data.objects.remove(obj)


Copy relative positions of empties to bone rotations in a smaller armature

Rotation constraints.

Going off the image in question, contend this can be done with two copy rotation pose bone constraints.

Add a copy rotation constraint from base pose bone targeting base emtpy. Check the offset property.  Do for corresponding bone - empty pairs down the chain.


How to make a custom sculpting brush using the bake function

I really don't think you can have such a deep point on a displacement texture. That's why it just bakes a white square. Your brush is essentially just a square brush.

I quickly made an example of how the texture should actually look like. It's not precise but it's to give you an idea.


What exactly does the "Use 3D Viewport" rendering option do?

As far as I can tell this is for use together with Local Camera feature of a viewport, or the now possible multi-window workflows.
Using local camera you can have any viewport display an arbitrary camera other than the one defined as active camera in the Scene tab of the Properties Editor.

Rendering from such viewport would potentially lead to unexpected behavior, as the produced image would not match the view angle currently visible in a 3D view, since by default Blender would be rendering the scene active camera, rather than the one you would be seeing through.
With Use 3D Viewport option checked you render what is actually displayed in the current 3D View the command originated from, using context as deps-graph source, regardless of default scene settings.
I suspect this possibly overrides other settings as well, like say rendering from another Blender window from the same session that has a different active view layer from the scene default one, or different visibility or collection states.


Create an Arrow of adjustable length but constant head dimension

DisJoin & use Limit Scale Constraint

A quick solution could be to disjoin the object in two pieces and assing scaling constraints to the arrow's head. Then parent the head to the body in order to acquire the transformation info we need to keep the object consistent (location & rotation).

In the image below you can see the constrain applied to the head. The origin of the arrow's body has been set to the tail (it seemed handy to me to have it there, but you can change)

As the head object has been parented while there was an offset between itsel and the body's origin, while scaling the body, a scaling of the head still occour, but because of the constraint, only the location of the object is being scaled (and so the head stays in place)


How to save normal map texture from Blender?

Apparently what I was missing (Windows or Linux) is to check Save as Render box for PNG/OpenEXR. So the following worked for me to generate an external normal map texture:

Generate an image in Raw Color Space and with Float Buffer:

Note that Float Buffer is important, as 8bit dynamic range is not enough for a quality Normal Map. The Raw Color Space maps 8080FF as neutral color in Blender

Bake a normal map in Cycles or Blender Internal
Save resulting map as 16bit PNG with Save as Render checked.


How to texture Dragon/Reptile for later import into UE4?

Well I won't give you an easy why to do it but I can tell you some basics that you can do.
You are wanting to make a texture that resembles the skin of a reptile. First look up reptiles and look at there skin.
Then you can either try to hand paint this in gimp or you can use an image that has authorized the use of the image to be used by anyone. You can grab a piece of the image and then you can look up how to make a seamless texture which will let you repeat it as much as you want to create the effect of reptilian skin.

If you are having trouble finding tutorials on this you can look up either how to paint a texture and apply it to reptilian skin or you can look up how to manipulate an image and use it to make into a texture.

This might also help you: https://www.youtube.com/watch?v=TLj2bDa2qno


In Sverchok, how can I create a different parametric object at each vector in a list?

You can use a Generators > "Hilbert 3d" node to make the matrix. I'll use this for brevity. Either that or stack a few subdivided planes and join them with Mesh Join.

Each point on the matrix is a Vector, you wanted to check the distance between each vector and the origin vector (0,0,0) and use that distance to scale a sphere placed on that vector point.

here's how to make a more dynamic matrix

import the Gist from the SV import/export panel
https://gist.github.com/c0f658e5dab427711f58c1908d470c64

Mesh instances


makehuman visemes to shape keys for unity

Since there are not enough details in your question, there are many things that can go wrong.

Two things to note:

1) When you import mhx2 into Blender, you must choose to override the default settings at the import menu at the bottom left:

Override Exported Data: Checked;

Import Human Type: Base, Offset, Face Shapes;

Masking: Apply, Conservation Mask;

Rigging: Add Rig, Rig Type - Exported, Custom Shapes.

2) Make sure you export your model from Blender in a fbx file.

3) Import your fbx file into Unity. Before you drag it into the view/hierarchy, make sure that in Inspector you have the box ticked for importing face shapes - should be the default but just in case.

This tutorial is for a plugin for lip sync in Unity, which uses blend shapes/face shapes. You may or may not need it but the first half of the tutorial is very useful for your case. If you follow it step by step, you should be able to get the blend shapes/face shapes into Unity successfully.


How do you create the bone/armature structure for a 4-bar linkage?

Generally speaking, you'd create that via IK, which controls angles while keeping lengths constant:

That's your basic parallelogram IK, used for a lot of mechanical rigging. Note that it doesn't have to be a parallelogram-- if you build it with different lengths for your bones, different angles, it still behaves properly.
The IK target (and the first bone of the IK chain) is parented to root, while the last bone, "4", has a 4-bone-long IK bone constraint targeting the IK target.  No matter how you rotate the bones, the lengths will not change.
To adjust the structure, you rotate the IK controlled bones.


Problem finding a face center of a mirrored object using a ray_cast

So, I used scene ray cast instead. It worked faster than ray casting through objects and was returning correct normals/faces.


How to check if node property is not None while iterating through materials?

An attribute can be None
The error NoneType has no attribute is a common error seen in blender scripting .  For example it can be the case that context.object is None
To the OP would recommend editing the title of question to reflect this error message more-so.

Error: AttributeError: 'NoneType' object has no attribute 'name'

thrown by node.node_tree.name == 'NodeGroupName'  is informing  node.node_tree has the value None.  Can test for this being the case, ie
if node.node_tree is  None:

as opposed to
if hasattr(node, "node_tree"):

Both will be true when the node tree is None
It is actually a strange case that the code in question would throw this error, as I'm not aware (yet) of how to add a group node and have no linked node_tree.  Speculate this is the result of deleting a node group from bpy.data.node_groups that was a node of a material node tree..
hence the last line of question script could be
if (node.type in ["GROUP"]
        and node.node_tree
        and node.node_tree.name == 'NodeGroupName'
        ):

since chaining ands ceases on first False
Using getattr
Since we pretty much would treat either the same using get attribute with the third argument default
node_tree = getattr(node, "node_tree", None)

will be None in both cases.  IMO this "trumps" using both the has node tree then has name attribute test.  None has nothing, if we know it's none testing further for attributes would seem superfluous  Can also ensure that if  a node tree is not None it will have a name. bpy.types.ShaderNodeTree.name
Test script
Using the above with the "double test" for a node being of 'GROUP' type check it has a non none node tree.
Make a dictionary, with keys matching node group name containing a list of material name , node name tupples.
import bpy
from bpy import data
from collections import defaultdict

# all the group nodes in blendfile
print(data.node_groups.keys())

group_nodes = defaultdict(list)
# create a look up dictionary
for m in data.materials:
    if m.use_nodes:
        for n in m.node_tree.nodes:
            nt = getattr(n, "node_tree", None)
            if nt and n.type == 'GROUP':
                group_nodes[nt.name].append((m.name, n.name))

print(group_nodes)

Output.
File with 1 node group "Test_Material", 2 materials "TestMat" and "TestMat.001".
The node group is used in both materials with name "Group" in both.
['Test_Material']

defaultdict(<class 'list'>, {'Test_Material': [('TestMat', 'Group'), ('TestMat.001', 'Group')]})

Notes:
Beware of equating to True or False in tests.  By default python  equates most types to True or false. Some examples of false are None, the integer 0 and an empty list []
Methods like hasattr return either True or False
if hasattr(foo, "bar") == True:

if foo.bar  exists this reads somewhat akin to
if True == True:

instead simply use
if hasattr(foo, "bar"):

Changing above slightly to return boolean false instead of none when the node has no node_tree attribute, if nt: will be false in both cases, but we can discern between the two.
        nt = getattr(n, "node_tree", False)
        if nt and n.type == 'GROUP':
            group_nodes[nt.name].append((m.name, n.name))
        if nt is None:
            print(f"{m.name}:{n.name} node_tree is None")


I had just pressed ctrl z in sculpting mode and this happen.. can any one help me out

try Ctrl + shift + Z to cancel the Ctrl Z


Why is my glass plane displaying diffuse at specific angles?

The problem is due to a flipped normal - this can occur when extruding a plane, depending on which way the extrusion is applied.

In the following example one plane is extruded 'upwards' (the left-hand one) and the other is extruded 'downwards' (the right-hand one). The 'upwards' plane has correct normals but the other has inverted normals.

When adding a Glass material the glass acts based on the Index of Refraction (IOR). For normal glass in air the IOR is usually around 1.45 - ie, the default setting for the glass. However, with the flipped normals the mesh actually behaves as if it is a cavity of air within a glass solid and this causes the "surface" to refract unexpectedly and behave as if the IOR is the inverse (in the case of an IOR of 1.45 it behaves as if the IOR is 1/1.45 - ie, 0.69).

The solution to this problem is to either Flip Normals or Recalculate Normals so that the normals are pointing 'out' of the mesh.


How to merge overlapping edges into one?

Doing so in the past would have been painful and given you a lot of bad geometry.  If you tried to animate it you'd get horrible mesh deformations.

Now, you might be able to get good results with the intersect tool added in 2.71.

Here's a YouTube video about how to use it:
https://www.youtube.com/watch?v=tWSiRDw_tKE

Basically you tell Blender to calculate the intersection of the two meshes, then delete the over lap, and finally you can bridge the two in a number of different ways (including the bridge tool, but in your case probably merging each vertex pair).

There might still be some odd topology to clean up, and it might not animate cleanly.. but I think cleaning this up will be easier than other methods of getting the vertices in the same place.


moonboots's answer in image ...

Select a letter, Shift select the Armature
Switch to Pose mode, select a bone and Parent to Ctrl + P > Bone

(Walk downloaded from Mixamo. I just added a keyframe of rest pose on frame zero, to let letters parent on straight bone pose.)


How can I export my blender model as a python script

So exporting the .blend to a .py file is impossible (see here), but instead of exporting, you can run a python script on a .blend file externally through the command line.

For this example, lets assume we have a directory that contains a folder of 100 .blend files that each have an object located at the origin. For our needs, we would like to raise each object by one unit on the Z axis, and change it's name to the name of the .blend file. We will use a python script to modify these files.

project_files
|   edit_blends.py
|   modify.py
|
|___blend_files
    |   lid.blend
    |   cup.blend
    |   pencil.blend
    |   ...

In the edit_blends.py file, we have code that utilizes the Python library to iterate over each of the .blend files. (edit_blends.py) For each of the files, we use the subprocess module of Python to call Blender from the command line with certain arguments that will run our script (modify.py).

Here is edit_blends.py

import os
import subprocess

blend_files_path = 'blend_files'

for blend_file in os.listdir(blend_files_path):
    if blend_file.endswith('.blend'): # Exclude .blend1 .blend2 files
        file = os.path.join(blend_files_path, blend_file)
        # Run Blender in the background
        subprocess.run(['blender', '-b', file, '-P', 'modify.py'])

Here is modify.py. This file is what is run in the Blender process that is called.

import bpy

blend_file = bpy.data.filepath

for object in bpy.data.objects:
    object.location.z += 1

    object.name = bpy.path.display_name_from_filepath(blend_file)

# SAVE THE FILE
bpy.ops.wm.save_as_mainfile()

It is very important to save the file, otherwise all changes will be lost.

The line that calls Blender subprocess.run(['blender', '-b', file, '-P', 'modify.py']) runs Blender, with the arguments given in a list.

-b <.blend>: run the file in the background
-P <.py>: run the given Python file

For more information on the command line, read this. Of course, you can do almost anything to the .blend file externally through Python (some things are restricted like OpenGL renders because they require the GUI to be open)

If you are on Windows, you need to add Blender to the PATH or run the command with the path to Blender.


How to render parts of the camera view and merge afterwards?

Using python is probably the best way to split up the image into exact tiles, as mentioned by Campbell Barton:

  If you do some operation that requires precision (splitting the render into exact tiles for eg), you would be best to use Python for this anyway

At the moment you can try the Render Border Add-on. Although it's built to (re-)render an exact area of the image in order to save render time. For a single image you can animate 'Center X' and 'Center Y' properties to get the desired tiles:

To get 4 Tiles for instance:

Hit 'Reset the Render Border' to get the full frame
Divide 'R' and 'T' by 2 to get the first tile
Multiply 'Center X' by 3 to get the tile in the lower right corner
Then multiply 'Center Y' by 3 to get the upper right tile
Finally divide 'Center X' by 3 to get the tile in the upper left corner

Note: Unfortunately you cannot render this as animation, since Blender checks the size of the render border only once per render execution. So you'll need to render single frames and stitch it afterwards (by hand or using image tools such as ImageMagick):

Result

Also I'd highly recommend Brecht's instructions on how to render large image resolutions: https://blender.stackexchange.com/a/16261/3710


All geometry looks glitchy in viewport in Blender 2.8

Check your viewport's clipping. The min value may be too small for your scene, or too large.


When I render, only some emissions and some gloss render, while others doesn't

I think I found your problem.

You had certain objects set to NOT render by turning off the camera icon.
Just turn them all back on and it should render fine.


How to control the zoom in and zoom out?

Hold Ctrl + click and hold middle mouse button and move the mouse forward/backward for more precise zooming.

Left Alt + click middle mouse button on the object you want to focus on to reset the zoom-focus on this object.


Is there a way to change the mortar geometry of the Brick Texture?

You can do something like this :

The Noise texture is used to distort the Vector input to the Brick Texture node - this results in distortion of the brick texture. Note how the Factor of the Add node (a MixRGB node set to 'Add') is extremely low and the Scale of the Noise texture increased to 75 to produce many small ripples in the lines of mortar.


How to align a single bone between two animated empties

Aligned Bone -
This is similar to the 'Rubbery lines' project in that a curve-path with just 2 control-points (one at each end) is strung between 2 moving empties.  The northern empty is a hook which stretches the path between them.   (Blend file below)

To set it up -
Place the empties and animate them around scene as desired.  (call them  H nth  &  H sth?)
Add a Nurbs path, goto Edit mode and delete it's 3 intermediate control points so there are just 2 remaining.  One at each end.
Set the path's Origin Point to the starting end. (see it's arrows in Edit mode)
Move the path so it's reasonably aligned between the two empties and that it's starting end & OP are near the southern empty.
Select this empty and with SH-S, set the 3D cursor "to selected".
Select the Path and use SH-S again --> "Selected to 3D cursor"
The path's starting end should then be sitting exactly at the southern empty.
Make the empty a parent for the path.  (CTL-P)
Give the path a 'Track-to' constraint and have it 'looking at' the Northern Empty.
When played, the path should be attached to the southern empty and always looking at the northern one.
-============-
To keep the path stretched between them -
Goto frame 1 and Select the path.  Go into Edit mode and drag the end CP up so it reaches the northern empty.
Check from the top & side views (in ortho view) to see it's aligned properly.
Hook the northern empty to the path's northern CP. (CTL-H)
Play the animation again and the path should now reach both empties at all times.
-================-
The  Bone -
At frame 1 place the bone at the path's center or wherever it's required.  Align it to the path reasonably well.
Parent the bone to the path. (child = bone)
In this example the bone was simply keyframed to keep it reasonably at the center of the path but a driver or short script may well do this automatically.


Subdivision surface modifier creates new faces between the existing ones and uses the material from adjacent faces to fill in the new ones.  So if you're assigning materials to faces, you can run into issues where subdivision pulls the material seam away from where you want it.
You see this when there are faces of different lengths:


Is there a way to use a particle system on a mesh with a re-mesh modifier?

SOLVED: I have discovered a solution to the issue. Move the particle system up the modifier stack until it is above the Re-mesh modifier.

Now particles render normally. One thing you must realize, is that particle orientation will be based off of the original mesh, not the modified mesh.


How do I get images named sequentially when using the 'Frame step' render option?

I can think of two techniques:

1) Create a second scene using the VSE to add a Scene strip and then apply a Speed Control modifier to make the scene run double speed.

2) use a shell script to make symlinks like

i=1

S=/var/tmp/blender/knot-hop

D=$S/sequence

mkdir $D

for f in $S/scene1/*.png $S/scene2/*.png $S/scene3/*.png; do
    o=$D/$(printf %04d $i).png
    [ -e $o ] && rm $o
    ln -s $f $o
    i=`expr $i + 1`
done

# make sure we don't have any stale files left over
o=$D/$(printf %04d $i).png
rm -f $o


GPU rendering with OpenCL requires the proprietary AMD drivers on Linux. This is documented in Blender's manual:

  AMD drivers are open source, except for the OpenCL support which is available as part of Pro drivers. Installing packages through your Linux distribution is usually best. AMD also provides graphics drivers for download on their website if you need the latest version.

  AMD Drivers and Support Website


You didn't apply the scale of your plank objects, so when they twist they deform badly, just apply the scale with a CtrlA. By the way your setting seems a bit complicated, why not just make one unique object and maybe, if the deformation is not noticeable, duplicate it around with Array + Curve?


3D modeling- is it possible to map image to 3d mesh

select your object
add a new material
open the node editor
enable "use nodes"
add -> texture -> image texture
then you can change the position of the texture in the uv editor

That is only a short description. For more information please see the comment from Duarte Farrajota Ramos
or look here.


After blood, sweat and tears I've decide to just copy my mesh and armature by selecting it and pressing ctrl + c and then in another file pressing ctrl + v and the line shows up in the new file just fine.

I don't know what the problem is in the previous file (I did transfer it via google drive maybe that messed something up?)

Conclusion: If something doesnt render properly try copying your mesh (and armature) to another file


How can I change the movement to Linear?

Select the keyframes
menu bar(header) > Key > Interpolation Mode > Linear  (or shortcut T2)


Blender collision sensor is triggered twice

If I remember correctly, collision sensors fire twice by design.  Once when set True, and another when False.

This isn't a problem when connected to an And or Not controller (because they check) but in a script you'll have to do something like this:

def collision(cont):
    # Loops through all connected sensors and returns if one is False
    # Basically makes it work like an And conroller.
    for sens in cont.sensors:
        if not sens.positive:
            return
    ...


glTF 2.0 has a specific PBR material model, for transfer to realtime rendering engines.  It cannot support arbitrary arrangements of Blender nodes, as for example a mobile phone wouldn't be able to handle realtime rendering of complex Blender nodes.  Instead, the glTF material definition has a strict number of fields, corresponding to a particular interpretation of physically-based materials.

The Blender Manual documents how to export materials to glTF.


How do I fix these strange glass lighting artifacts?

Use a solidify modifier. When I was a beginner I used to make the mistake of thinking that glass would only be applied to the mesh and not the entire volume.


Array Modifier - Equal space between all duplicates (Loops)

Consider an [Array Modifier] followed by a [Curve modifier]

In the above image you see some distortion of angles between faces.
Consider a script which calculates [x constant offset] of the array modifier.  Note the warning.

Consider a [spline constraint ] where each track has a one-to-one correspondence with a single bone.


You can change the viewport shading options:

Turn 'cavity' on or off.

Or change the 'valley' line size.


When is it beneficial for the Active Object to be unselected?

One situation that comes in my mind is when you have the pivot center set to "Active Element".

I often use this to rotate the selected objects around the active object without rotating the active object itself. To achieve this I deselect the active object before I perform the rotation while it's still active.

(boah... sounds more complicated than it is :))


How do I fix my tree leaves turning black when I increase their number?

Your problem is likely caused by too many transparent objects being stacked in front of each other. Cycles' rays will just try to cross a fixed amount of layers before giving up and rendering black.

You can increase this "fixed amount":

→ In the Render settings for Cycles, under Light Paths, increase the value for the Transparency bounces until the problem goes away.


How to unwrap UV for each non-adjacent selected faces?

Assuming your topography won't change from this point forward ( or at least not significantly change ), you can solve this by following these steps:

select the faces you want to unwrap ( in the case the windows ) and detach them by pressing p ( or whatever hotkey you've bound to it ), and selecting "selection"
select the detached object, and go into edit mode
select all faces, press p - select "separate parts"
select all detached objects, and press ctrl+alt+shift+c - origin to center of mass
select one of the windows and unwrap it
select all windows, making sure your unwrapped window is active ( bright orange ) by clicking on it last
press ctrl + l - select "object data"

This will essentially make every window into an instance of the active window. Please note however that this assumes that the geometry of every window is exactly the same.


Is there a way to grab both keyframes and markers in blender?


How do I have random color variations for grass?

In the Render settings of the particles you can set Render as to Collection. Put the green grass and orange flowers into the selected Collection. Tick Use Count in Render section and add some count values to specify how much grass and flowers you want.


How to select scale x,y,z keyframes all at once in graph editor

In the Graph Editor, on the right side you will see the sidebar that shows you all objects and items that have some animation attached to it. Select your object from that list and make sure to widen the drop menu of it beside its name. There you will see the different axis. Using Shift select all of the. Next in the actual editor press A once or twice so all handles are selected and then press S to scale all of them.


How to merge two unconnected edges into a single one

Maybe this is a little faster ... hmmm
But you will have to turn on the addon called "F2"

Select the 2 edges.
Hit F, connects the 2 mesh and gives you 2 original edges.
Select the extra edge you didn't need. Hit X dissolve the edge.


Can you pack UV's according to material ID?

If you turn on the UV-edit mesh sync in the UV editor then you can select uv islands by materials in the materials tab. So select one material then hit Ctrl-P in the UV editor and repeat it with all of the materials.


Ok here's what I found. Due to the way your hires model is made you do not have an initial starting point with a basic UV unwrap. So we have to go the cage projection route. Which is the same method you were trying to follow on the video tutorial you posted in the chat.

Attached is the file you sent me, I have manage to produce the normals and AO with no problems on my end. You can try out the blend file below. I have packed a copy of the bake I made. Also to the left of the baking models I have created a GLSL shading model using Blender Internal Materials.

You will need to create nodes holding the texture for Ambient Occlusion and Normals. On the file you will see a green frame and a red one on the node window. The Green one is the node you need to select and make active before baking the Ambient Occlusion. Likewise the Red on is the node which holds the normal texture you need to select before baking.

DOWNLOAD - Here is the file.


GxAV Addon does not do anything more than adding static bars

The GxAV addon was last updated on GitHub three years ago.
I didn't test it but I think the addon is broken in the current blender version.
In this case you could try to use an old version of blender.
Older Versions are available here: https://www.blender.org/features/releases/
In your case i would try 2.70 to 2.72

If you don't want to downgrade or can't. I have two more options.

Standard blender functionality "bake sound to f-curves"

Manual entry:
https://docs.blender.org/manual/de/dev/editors/graph_editor/fcurves/editing.html#bake-sound-to-f-curves

Insert keyframe for the property you want the sound to manipulate.
Select the F-Curve the sound should manipulate

Key->"Bake Sound to F-Curves", select file and frequency, etc.
The bake starts at the current frame position.

Now you have baked you selected fequency range to the F-Curve and you have animation to the sound.

If the amplitude is to small you can use the modifier "Envelope". Add the modifier "Envelope" to the F-Curve. Add a new point in the modifier and ajust the minimum and maximum bounds.

If you want the same "Envelope" modifier for other F-Curves, you can copy and paste them with the buttons right of the "Add modifiers"-Dropdown.

Animation Nodes

More powerfull but also more learning involved. You need to install the addon and learn how it works.

Download Link: https://github.com/JacquesLucke/animation_nodes/releases

Manual: http://animation-nodes-manual.readthedocs.io/en/latest/

Installation: http://animation-nodes-manual.readthedocs.io/en/latest/user_guide/install/install.html
Sound nodes: http://animation-nodes-manual.readthedocs.io/en/latest/user_guide/nodes/sound/index.html

Simple example:

Install the addon.
Open a node editor window.
Add new NodeTree.
Add the "Bake Sound"-Node.
Click "Load New Sound" and select your sound file.

Click "Bake Average". Now you have baked your average value of the sound file and you can use it.
Rebuild the node setup like in the following picture:

Maybe you have to adjust the channel (see the Video Sequence Editor)
In the "Object Output"-Node, you have to select your target object.
Adjust the mulipication value in the math node.

Now the object should resize to the sound.


Add vertices at the intersection of edges

You can indeed, select all the edges and  use the shipped add-on TinyCAD > XALL to put a vertex at the intersections of all the lines simultaneously. All those intersections have to be detected. This can get (Python) computationally expensive in more complex cases..
More Blenderish, here, IMO, would be to delete all those edges, start from a clean perimeter, and CtrlF  Face Menu > Grid Fill the empty rectangle, (constructing the intersections instead; much cheaper,) before X deleting 'Only Faces', if you want the bare edges.


Setting the obstacle's volume initialisation to shell seems to have fixed it

I have no idea why this works if anyone knows why please add it to the comments.


UV Unwrapped Blender texture image is either rotated or stretched, cannot get it to be straight and not stretched

You still don't have a plane there (from the problem of your last question). At the top you can see, there are 8 vertices and 5 faces.

delete the vertices that are only connected to the side walls of your cube. then normal unwrapping works just fine.


I believe if you switched to imperial units and just use for example extruding for 1.5 it will be 1.5 feet or 1'6". To do ' or " signs while doing these operation you need to use "advanced mode" pressing = after choosing operation. Not sure if there are addons/better ways for using imperial units. Some info on advanced mode from similar question. Also you could check "Separate Units" on Scene tab under Units settings, so you can see units as separate, otherwise by default you could see 1.5' instead of 1'6" during/after operations which can be quite confusing.


The common solution for this is to use a particle system.

Select your mountain
Go into the particle system tab in the properties
Set Physics to No, Render to "Object" and set your grass object as "Dupli Object" (if you got more than one grass object create a group and use this group instead)
Hit play for tiny second all your grass particles should now appear.
Toy around with other setting or have a look into the blender documentation
Go to the modifer tab and hit convert on the particle system to make all the particles into real objects


How to place an overlay video with a transparent background upon another video/image?

The next day...
I have tried Alpha Over as was suggested. Initially, it was tricky and difficult to work with nodes, while making mistakes. Now, I have finally achieved the desired result and here I enclose the screenshot.


Why is this simple primitive shaded so weirdly?

You appear to have the mesh set to Smooth shading. This will attempt to generate consistent normals around the edges and vertices to blend in with the adjacent geometry. Set the shading to 'Flat' and each face will have consistent shading (with hard edges).


I guess it's this kind of node chain: Texture Coordinate > Mapping > Gradient > ColorRamp > Diffuse > Output.


How to extrude an irregular shape into a cylinder?

Multiple Methods
Extrude and To Sphere

Extrude your edge loop upwards.
Type Shift + Alt + S > 1 to execute the To Sphere command.
If you have overlapping vertices, try using the smooth (W > O) a couple of times and then the To Sphere command again.

LoopTools Circle

Extrude your edge loop upwards and select it.
Choose the Circle of the LoopTools addon. It comes with Blender and has to be activated first in the User Preferences > Addons. It is located in the Specials menu. W > LoopTools > Circle.

Bridge to Circle

Select your edge loop and note the vertice-count in the info bar.
Add a circle, set its number of vertices equal to the edge loops.
Position the circle and select both, circle and previous edge loop.
Do the bridge edge loops command. Ctrl + E > L


Currently, I'm developing a web application that allows architects to load their models in a-frame (their models are decimated, processed and texture's are baked). I've been initially using c4d for this but I had a big limitation: I couldn't include python packages (I needed numpy). Then I decided to move to blender and It's working nicely.

I don't actually know how you could include blender in a .exe or .app file, but since blender it's open source and multi-platform, you should not have big problems. You'll probably have to download the repo from git and do some tweaking.

Since you will have to solve a lot of equations, you could consider using libigl https://libigl.github.io/
It's actually a header-only library (in C++ with a python interface) so you could actually use it along with blender, if you want to. I haven't done it, but I'm coding a mesh decimation algorithm with libigl to be include in blender (for academic purpose)

Hope this helped


If I open a Blender file and the UI looks weird, can I move/close the UI elements to make it look like the default?

At the top of the screen next to the layout tabs, you can click the + sign to add the layouts you are more familiar with. The default workspace is Layout which can be found by going to General > Layout.

To move around the existing workspaces, right-click a tab, and select Reorder to Front or Reorder to Back.


Hair Dynamics not working on mesh from Daz Bridge

you set the simulation end on the cap to 0. Set it to 250 and it works.


blender subsurface scattering scale control with non-color data texture

Yes it's possible. There are two simple ways to do that(and countless more complicated). First is to use the texture to influence scale of subsurface scattering shader (Full white has value of 1 and full black 0,if you would use other colours only Value would be taken into account, Hue and saturation are irrelevant)

Second way (better in my opinion, cause it gives more control) is to use texture to influence shaders mixing:


Averaged normals is called smooth shading within Blender.  The easiest way is to set an entire object as smooth or faceted by selecting a mesh object, and in Object Mode, click Smooth in the Tool Shelf. This button does not stay pressed; it forces the assignment of the “smoothing” attribute to each face in the mesh, including when you add or delete geometry.

You can save this information in your export by ensuring the option to include normals is checked.


Fixing black faces in texture after using dyntopo

I have developed a workaround exactly for this (I also use meshroom by the way). Before you fix the topology with Dyntopo, create a backup of your mesh. When you are finished painting in the polygons, you can rebake the color information from the original mesh to the Dyntopo'd one.


Armature moves when switching from Edit to Object Mode

The problem is created by the IK bone pivot not align to the child bones in edit mode. Use the cursor to snap all the bone pivot to the same location. Also make sure that your bones are rotated so that it is perpendicular to the front view as much as possible - at rest.

Attached is are the bones rotated and all the IK pivots of the bone aligned properly.

Snapping the bone pivot onto the same location do the following - In edit Mode.

Select the end bone nub.
Use CtrlS choose "cursor to selected"
Select the other bones hit CtrlS choose " Selection to Cursor"
If required , go to pose mode and reset all rotation and transformation using
AltG and AltR

Below, you can see 3 spherical nub aligned. The 2 red ones and the big green one    needs to all be aligned in one spot using the "Cursor to selection" then " selection to cursor" method.


Why does my object become so rounded when adding a Subsurf modifier?

There's a few different things you can do to fix this, and there's loads of tutorials about it.  I know Blender Guru has done one including the relevant info about subdivision modelling, but there's others as well.

Still, linking something isn't directly answering so I'll do that as well:

The problem here is a lack of controlling geometry.  The control mesh that the subsurface is generated of will tend to produce a very rounded subsurface whenever it has a sharp corner, and you can control that by adding extra geometry near the corners.  (Specifically you are constraining the size of the rounded corner by adding the extra supporting geometry - it's still there, just very small, effectively a bevel now instead of a huge rounded corner)

The first thing to do is add edge-loops, by default with ctrl + R in edit mode.  If you have the subdivision surface displaying in edit mode this is much easier.  Push an edge loop near the top of the bottle lid and it will look much much closer to the original.  The two downsides to this technique is that it adds geometry and it takes some manual work to put the loops where you need them, but the main advantage is you have perfect control over where that extra geometry goes and exactly how sharp each edge becomes.  In some cases Inset faces (I in edit mode) is also useful for this, especially with faces such as the top face on that mesh.

If you have a big mesh and want to automate more, you can use a bevel modifier with an angle limit before (above) the subdivision surface modifier, and this will effectively add edge-loops for you.  Keep the bevel low resolution as the subsurf will already be adding more geometry, but play with the offset to adjust the 'sharpness' of the result. This is a lot faster than adding loops manually, but you usually end up with even more added geometry, and you have less control over where exactly unless you fiddle with marking bevel weights and such and I usually find it's easier to just do it by hand at that point.

Lastly and almost least effectively in this particular case, you can use edge creasing (shift + E in edit mode with edges selected) to pull the subdivision surface closer to the control mesh - but this often fails with circular shapes such as the one you've got here, especially with ngons, and for this mesh I wouldn't recommend it.  It's a useful thing to practice with as it gives you better control over subdivision surfaces in general but there are some shapes it just won't help with much - experiment with it on this mesh and you'll probably find it's either not helpful or that your lid ends up looking weirdly polygonal.  If you ever do have to do this, removing the ngon and using grid fill or some other method for filling in the top will probably work better.

You can of course combine these methods, and often some combination will produce the 'best' result, though it's up to you to determine which set is worth the effort.


Using Python, How would I get my player to rotate 180 degrees left or right,

It sounds like you want a specific (end-) pose rather than a turn. Therefore I suggest to split the operations: Set target pose (turned east or whatever) -> animate towards the target pose until it is reached (the object faces east ). Subsequent turn requests will set the same target pose without visible effect.

In your case you do not want to animate so you can skip the "animation" state:

import bge
import mathutils
from math import radians

keyboard = bge.logic.keyboard
if  bge.logic.KX_INPUT_JUST_ACTIVATED == keyboard.events[bge.events.LEFTARROWKEY]:
    controller = bge.logic.getCurrentController()
    player  = controller.owner
    keyboard = bge.logic.keyboard

    FACE_EAST = mathutils.Matrix.Rotation(radians(90.0), 3, 'Z')
    player.worldOrientation = FACE_EAST


Yes there is!
Select your camera and in camera tab, you can see clipping section.
Set the End to whatever you need, but not more (more number makes it harder for you computer to render)


Steps 3/4/5 can be replaced by Shift+S (for Snapping) / O.

Step 8 can be replaced by T. In general, you can look for underlined letters in such menus.

I also wrote an add-on to automate the process: OriginToSelection.py.

Install the add-on via User Preferences / Add-ons / Install from file, don't forget to activate it (check the box before its name). Press Spacebar and search Origin, then select Origin To Selection.

Be careful, I'm new to publishing add-ons and I'm pretty sure it can cause crashes. Save your work before using!


Different materials for each fluid inflow?

Unfortunately, I don't know of any way to do this with the main fluid simulator, however it is possible with blender's SPH fluid simulator.
Note that there is currently no way to convert fluid particles into a mesh from blender. There are some python scripts that do this, but these are mostly pretty slow. There are also a few patches, but it seems development on these has been dropped for the most part.
Some advantages of the SPH fluid simulator:

No domain bounds

Supports inter-fluid interactions

Supports force fields

To mix to different colored fluids:

Create two emitter planes (ShiftA> Mesh > Plane):

Add two separate particle systems to the planes in Properties > Particles:

Increase the Life time of the particles in Particles > Emission to be at least equal to the scene end frame:

Set the particle physics to Fluid in Particles > Physics:

Add an object to represent the fluid particles. It should be very low-poly, a 1 division icosphere works well (ShiftA> Mesh > Icosphere). Note that you will need one for each color:

Set the Shading to Smooth on the icospheres and move them to another layer (M)

Set the particle type to Object in Particles > Render and select an icosphere in Dupli Object:

In Particles > Physics > Fluid interaction press the + button to add an particle system interaction and select the other emitter plane as the particle system object:

With both planes setup this way, add another object (e.g. a floor plane) and make it a collision object in Properties > Physics:

Create separate materials for each of the icospheres.

Set the Size (in Particles > Physics) and Number (in Particles > Emission) for each particle system. Larger particles = lower resolution, smaller = higher resolution. Adjust these settings so as to make the particles appear as a fluid without making the simulation too heavy.

You may also want to set the cache step to 1 in Particles > Cache for each particle system to ensure accurate caching.

Result:

See the wiki for more information about each setting.


You might also want to inspect for keyframes that you didn't mean to place but accidentally did. I have had a similar result especially when using cntl+option+0 to place a camers


Need rigging help for a robotic jaw holder

Various constraints can provide the functionality you are looking for.

For the rigid tubing connected to the main column I would add bones in place to move them. To get them to follow the upper arm movement I would add a Copy Rotation constraint, only enable the axes you want to use and adjust the influence so that they rotate less than the main arm. For the lower piece I would use a StretchTo constraint to keep the end attached to the other tube.

For the flexible tubing going up to the arm, create several small bones to deform the tubing and add a curve to match the rest position of the tubing, then use hooks (see below) to deform the curve and use the curve in a SplineIK constraint to move the bones you positioned for this.

Setting up hooks can be confusing and a little awkward, the step are -

Select the upper arm in pose mode.
Shift select the curve (the outliner can make this easier)
Enter edit mode for the curve.
Select the point in the curve that you want to move with the arm.
Press ⎈ CtrlH->Hook to Selected Object Bone

Now exit edit mode and move the armature, the end of the curve should follow the bone. Note that the viewport lags behind with the splineIK but it will be in the right place when rendering. Repeat for the other end of the curve.


How do I add more than 8 decals to an object?

Image above.  Rendered image with two imagined logos on particular faces.

Image above.  UV Maps.  Color Blue used to increase visibility of Seams.

Mapping Extension set to Clip.
Even if you see Blender Render the UV Map applies to Cycles Render as well. Combined with the video tutorials you have seen you can do this. Note the part of UV is off the image which is what I want.  The Clip setting allows us to exclude modifications of color from parts of the mesh.  Please click to see larger image.

What is presented here is a quick summary, not a tutorial.


As other users said, this is normal. Do not try to remove this.


Combining rendered images to increase samples

From the linked answer (https://blender.stackexchange.com/a/21809) you have the following image to show the compositor node setup :

As mentioned in the correction to the linked answer, the Mix factors are actually incorrect - the correct values are as you stated : (100%), 50%, 33%, 25%, 20%, for 5 images (where the 100% corresponds to the first image which shares the mix node with the second image).

While this might intuitively seem wrong, it is actually correct due to how the images higher up the chain actually proliferate through multiple Mix nodes.

Consider the four images A, B, C, D.

Starting at the last image 'mixed', this is included with a mix factor of 25%. As expected, this will contribute 25% to the final result. This means that 75% of the final result will be contributed to by the remaining 3 images (A, B, C).

Final Result = 25% of D + 75% of (A, B, C)

Now considering the next image (C), this will contribute 33%, meaning that A and B contribute the remaining 67% (actually 33.33333% and 66.66666% would be more accurate) :

Final Result = 25% of D + 75% of (33% of C + 66% of (A,B))

For the final mix, 50% is contributed by B and the remainder (50%) is contributed by A (we don't need to bother with the 100% since that's purely A) :

Final Result = 25% of D + 75% of (33% of C + 66% of (50% of B + 50% of A))

All we've done so far is expand the mix nodes to represent the percentage of each output that contributes to the output, bearing in mind that the two percentages must add up to 100% (so if one image contributes 'x'% then the other must contribute '100-x'%).

Now, we can multiply the percentages into the braces to expand as follows :

Final Result = 25% of D + 75% of (33% of C + (66% of 50% of B) + (66% of 50% of A))
             = 25% of D + 75% of (33% of C + 33% of B + 33% of A)
             = 25% of D + (75% of 33% of C) + (75% of 33% of B) + (75% of 33% of A)
             = (25% of D) + (25% of C) + (25% of B) + (25% of A)

i.e. Because the Mix nodes are chained together, the 100%, 50%, 33%, 25% factors combine to result in each input image contributing to 25% of the resultant image.

As mentioned in the linked answer, the same result could be achieved by using Add nodes to add the images together and dividing the result by 4.

i.e. Mix nodes (note the reducing Factors) :

Is equivalent to Add and Divide nodes (again, note the Factors set to 1.0) :


How can I unlink all images from a project?

Combining this and this answers, one may get code like this:

    import bpy

    for img in bpy.data.images:
        img.user_clear()

It will unlink all images in the .blend (one currently selected in the UV Image Editor will remain selected, but also will become unlinked, you can unlink one image by yourself or make improvement to the code).

Then you will only need to delete unlinked images.

The final code might look like this (thanks for evilferber's comment):

import bpy
for img in bpy.data.images:
  img.user_clear()
for img in bpy.data.images:
  if not img.users:
    bpy.data.images.remove(img)


I recommend using a Normal Map to simulate the effect of a bevel. It doesn't add any mesh either (yes, even modifiers add mesh, except they are not directly applied to the object in Edit Mode). I wrote a tutorial on my blog for it.
http://renderedsmoothie.wordpress.com/2014/05/31/fake-bevels-using-normal-maps-blender-cycles/
(But here's the full post in a quote ;) )

First, we have a basic Cube. We need to UV-unwrap it. Press the U key, and click Smart UV Project to quickly unwrap this model. Next, duplicate your model and go to Edit Mode. Bevel that model by clicking Ctrl+B. (You can use the scroll wheel to adjust the quality of the bevel, and move your mouse to adjust the size of the bevel).

When you go back to Object Mode, you will notice that your cubes are overlapping. That’s great! Except that the beveled cube needs to be slightly larger.

Scale the beveled cube up just a small but so that you can not see the cube underneath.

Next, select your non-beveled cube and go to Edit Mode. Visit the UV/Image Editor window and create a new image. It can be whatever size you want. After you have your image created, go back to Object Mode on the cube, and follow these directions very carefully:

Select the Beveled Cube FIRST
(Go into Wireframe view mode for this one) Select the non-beveled cube SECOND.
Go into Edit Mode (Should be on the non-beveled cube)

You need to make sure you are in Blender Render Engine for this step. This is where we bake the Normals. In the Properties Window, find the Bake header. Change the Bake Type to Normals, set the Normal Type to Tangent, and check Selected to Active. Make sure you have your New Image in the Image Editor Window before baking. Then click Bake.

Shortly, you will see a Normal Map pop up on the Image Editor screen! Go ahead and Save the image so you don’t loose it from Blender’s Cache. Move the Beveled cube to another layer (by pressing the M-Key in the 3D Viewport) or Delete it. Next, switch back to Cycles Render. Cycles uses a special Node for Normal Maps. It’s called the Normal Map Node. Anyway, add that node to your node setup and plug it into the Normal plug of any shader. In the photo below, I have made a basic glossy and diffuse material setup using my “Bump-map-Normal-map”.


Blender does not come with e.g. numpy pre-installed

Yes it does, unless you configure WITH_PYTHON_INSTALL_NUMPY:BOOL=OFF and build it yourself.

Python modules can simply be imported from whatever is listed on the PYTHONPATH environment variable. If it doesn't automatically work by placing .py files next to your .blend file, you can modify PYTHONPATH to point to that location.

You can bundle 3rd-party modules with your game, but you do have to think about the following:

You have to adhere to the license of the module, so probably you'll have to include their license, give them credit, etc.
Be careful with binary modules. Make sure you test (so don't read documentation and assume it'll work, but actually test it) that they work with the version of Python that's built into Blender. On Windows this may be an issue, since (AFAIK) we build Python with different options than the python.org build, and as a result the pre-built binary Python modules may not load in Blender.
If you do decide to use binary (i.e. .pyd, .so, or .dll extensions) Python modules, make sure you include the versions for all platforms you want your game to run on.


Make materials uneditable & inapplicable

As mentioned in the comments, you can hide some of the complexity in the material by baking stuff to textures, but this isn't possible for everything.

Blender offers techinical no way of doing stuff like this, in part because it is against the ideology which drives blender (Open Source) and in part because for digital stuff it is pretty much impossible. Consider how much effort the entertainment industry spends to try and create technical solutions to digital piracy, and still they get broken.

There are however legal solutions, you could release you work under a 'No Derivative Works' license (I believe there is a variant of creative commons for this https://en.wikipedia.org/wiki/Creative_Commons_license).


Is it possible to manipulate normals explicitly in Blender?

As @MarcClintDion said, this is not possible... Yet. There is a custom Split Normals branch being worked on by Bastien Montagne(Mont29) to try to incorporate this into Blender; However, it's not yet finished - Loop Normal Edition is the current sub-project under development.


How to overlay someone (and his/her movements) in a video clip tracking eyes,face,mouth of a 3d character

Well, first of all I would be surprised if this would work at all.
The faces you are tracking are so extremely tiny, that the solver has barely a chance to solve that correctly.
Second, you have a moving camera, so you should solve that first.

So first track the room and solve the camera for that.
Then, in the objects panel of the clip editor's sidebar, add an object and then place markers on the person's head and try to solve it.
But as I said, I really don't think it's possible, considering how tiny the persons are in relation to the frame size and how blurry the footage is.


Bevel Tool – What exactly does LoopSlide do?

It controls whether to keep intersecting edges perpendicular to the bevel direction.
Loopslide On: gives smoother topology and better results for tight geometry
Loopslide Off: keeps perpendicular edges and even bevel width

When Clamp Overlap isn't enough, Loopslide On can keep the topology in check:


How do create a mesh on the base of a set of orthodontic brackets I designed like the regular bracket on the picture e

Import your models (or design from scratch) your bracket objects into a .blend file. Each bracket should be a separate Blender object. You can name the brackets whatever you like. I recommend some syntax which let's you know the intended tooth, and some of the clinical parameters of the bracket's prescription. Eg, "UR3_tip11_tq0" for an Upper Right Canine, with 11 degree tip and 0 degree torque.
Orientation of the Bracket
Correct orientation of the bracket is critical to the convenience .
The 'Z' axis should point toward the facial aspect of the bracket
The local positive 'Y' axis should point toward the incisal, and be perpendicular to the wire slot, NOT aligned with the vertical alignment slot. This is important for the bracket being displayed correctly when first imported.
The 'X' axis should be aligned with the horizontal wire slot, the positive direction does not matter, and is determined by #1, and #2 above.
The local object origin, should be in the middle of the bracket, on the surface which touches the tooth.
Here is an example of the Upper Right Canine (first image) and the lower right canine (second image). A few things are important to notice. The positive Z-axis (blue arrow) points outward to the facial in both situations. The positive Y-axis (green arrow) points toward the incisal, which is down in the first image and up in the 2nd image. The X-axis (red arrow) is parallel with the wire slot, but can point in either direction (left in first image, right in second) based on the requirements of the first two constraints. Both these images show the local coordinate transform selected (the white arrow).
Assigning Custom Properties
Custom properties allow to display clinically meaningful visual guides to placing the bracket with respect to the bracket's prescription (eg. tip, torque, in/out etc'). Currently, only prescribed tip has any effect on how the visual aids are displayed while using the orthodontic bracket placement tools.
Adding a custom property
There are 2 ways a custom property can be added to a bracket. The easiest way is to add a property via the object tab of the properties panel. The "Custom Properties" panel is at the very bottom of that tab, you may need to scroll down. You can "Add Custom Property" which will create a blank property that you can edit the name and value of.  From here you must add the following custom properties to your brackets for the visual aids to display correctly.
quadrant - must be lower case, can be UR, UL, LL, LR, 1, 2, 3, 4
tip - any positive or negative number, in degrees
bracket_gauge - the length of the virtual bracket placement gauge
Other properties will be supported in the future, and you can add any information you want to it! Brand, author, system etc.
Using python to automate
Going through and adding and editing these properties one by one can be time consuming. The following simple script will at least add the custom data properties, which you can then edit in the properties panel above.
for ob in bpy.data.objects:
if not ob.get('tip'):
ob['tip'] = 0.0
if not ob.get('torque'):
ob['torque'] = 0.0

Then for base create chain like structures and copy pate it for planner base surface:


Keyed Particle System ( Renders static particles associated with each keyed mesh)

I must have been getting confused between the RENDER and DISPLAY tool panels!
Within the RENDER tool panel it is as simple as selecting 'NONE'


How do I successfully Import a humanik Maya character via FBX

I have been using an alternative FBX importer with good success rate.
You can download the tool and script at http://blenderfbx.render.jp/

The default fbx importer that comes with blender often could not resolve
rigs, and rotation and scale just get screwed. For fbx you will need to download an extra set of software, follow the installation instruction closely. After installing the software and the addon... importing fbx should be a breeze.

A MORE DETAILED INSTRUCTION by Eric huelin
Here are the handy concise instructions. You will need:
(Remember to check on the correct versions. This is accurate as on Feb 2016)

1 - Visual C++ download here: microsoft.com/en-us/download/details.aspx?id=40784
2 - UmConverter download here: umconv.render.jp
3 - BL_20150704 download here: blenderfbx.render.jp

Install Visual C++. Open the UmConverter zip folder copy into the blender.exe folder. In Blender File>User Preference>Addons tab>[ Install from file ] Select io_scene_bos_fbx.zip Check the box on the right [ ] [ Save as default ]. When importing goto File>Import>Bos FBX – Eric huelin


Take a plane; scale, subdivide, rotate, unwrap it; Add a Wireframe modifier and a Displacement modifier. Use your text as hieght texture. That's it!


If you're looking to calculate the Fresnel factor by yourself, a commonly used approximation is this: https://en.wikipedia.org/wiki/Schlick's_approximation

This should give you a percentage of how much "gloss" there should be.


Perhaps you could apply the keymap after startup as an addon, rather than in the startup folder?
Here is an extract of an example script from an addon I wrote to Toggle Emulate MMB & Numpad. I have included some keymap reference documentation in the repository, and commented code that might make it easier for you to set up your own script. I have removed here the superfluous elements for your purposes.
bl_info = {
    "name": "My Custom Keymaps",
    "author": "me",
    "version": (1, 0),
    "blender": (2, 90, 1),
    "location": "...",
    "description": "Loading Custom Keymaps",
    "warning": "",
    "wiki_url": "",
    "category": "Preferences"}

import bpy
import rna_keymap_ui
from bpy.utils import register_class, unregister_class

# Keymap Code

# First, set up a dictionary of key mappings.

# "TEMPLATE": [{"label": "Human readable name of keymap in Blender Keymap UI",
#               "region_type": "WINDOW", //Default is WINDOW (optional)
#               "space_type", "EMPTY", //Default is EMPTY
#               "map_type": "KEYBOARD", //Device to be used (optional)
#               "keymap": "Window", //Name to be chosen from declared list of keymap names
#               "idname": ..., //Specific reference to operator from blender API
#               "type": "", //Key type identifier - choose a specific keyboard button or mouse button, etc...
#               "ctrl": False, //Combination keys for compound hotkeys (optional)
#               ...
#               "value": "PRESS"}, //Whether key will be held, pressed, etc...
#              {...}]

keys = {"MENU": [{"label": "Toggle Emulate 3 Button Mouse",
                  "region_type": "WINDOW",
                  "space_type": "EMPTY",
                  "map_type": "KEYBOARD",
                  "keymap": "Window",
                  "idname": "preferences.toggle_emulate_3_button_mouse",
                  "type": "QUOTE",
                  "ctrl": False,
                  "alt": False,
                  "shift": False,
                  "oskey": False,
                  "value": "PRESS"
                  },
                {"label": "Toggle Emulate Numpad",
                  "region_type": "WINDOW",
                  "space_type": "EMPTY",
                  "map_type": "KEYBOARD",
                  "keymap": "Window",
                  "idname": "preferences.toggle_numpad",
                  "type": "SEMI_COLON",
                  "ctrl": False,
                  "alt": False,
                  "shift": False,
                  "oskey": False,
                  "value": "PRESS"
                  }]}

# Define a function to get a list of key mappings, 'keylists'
def get_keys():
    keylists = []
    keylists.append(keys["MENU"])
    return keylists

# Define a function to register the key mappings templated in the dict as keymaps, using the constructor kc.keymaps.new()
def register_keymaps(keylists):
    wm = bpy.context.window_manager
    kc = wm.keyconfigs.addon

    keymaps = []

    for keylist in keylists:
        for item in keylist:
            keymap = item.get("keymap")
            space_type = item.get("space_type", "EMPTY")
            region_type = item.get("region_type", "WINDOW")

            if keymap:
                km = kc.keymaps.new(name=keymap, space_type=space_type, region_type=region_type)
                # km = kc.keymaps.new(name=keymap, space_type=space_type)

                if km:
                    idname = item.get("idname")
                    type = item.get("type")
                    value = item.get("value")

                    shift = item.get("shift", False)
                    ctrl = item.get("ctrl", False)
                    alt = item.get("alt", False)
                    oskey = item.get("oskey", False)

                    kmi = km.keymap_items.new(idname, type, value, shift=shift, ctrl=ctrl, alt=alt, oskey=oskey)

                    if kmi:
                        properties = item.get("properties")

                        if properties:
                            for name, value in properties:
                                setattr(kmi.properties, name, value)

                        keymaps.append((km, kmi))
    return keymaps

# Define a function to unregister the keymaps
def unregister_keymaps(keymaps):
    for km, kmi in keymaps:
        km.keymap_items.remove(kmi)

def register():
    global keymaps
    keys = get_keys()
    keymaps = register_keymaps(keys)

def unregister():
    global keymaps
    for km, kmi in keymaps:
        km.keymap_items.remove(kmi)


Attaching a rope (curve or mesh) to two other objects

What you can do is create a long plane, subdivide it, create a group, give it a Physics > Cloth with the group as Pin Group:

Create your 2 objects, 2 cubes here (but it can be empties or bones), select a cube, shift select the plane, switch to Edit mode, select the same vertices as the pin group, press CtrlH > Hook to Selected Object. You can hook to a vertex group of the object if needed. Do the same for the other cube. Put the Cloth modifier under the Hook modifiers:

Create your pipe object, hook it as well, give it a Surface Deform with the plane as Target, click on Bind. The Surface Deform modifier must be under the Hook modifiers:

Make the plane invisible, move the cubes:


Most often, objects breaking up is done by, when hit by something, ending the original object and replacing it with one or more rigid bodies. (ie using add object/end object actuators or the python equivalent)

Now, on to constraints. I know no way to get the constraint if it was made in the user interface. There simply doesn't seem to be a method to get constraints. But if you create the constraint from python and store it's ID's, then you can manipulate it/destroy it.

To create a constraint (this is for a wheel, free to rotate in one axis):

def joinWheel(wheel, axle):
    obj1 = wheel
    obj2 = axle

    id1 = obj1.getPhysicsId()
    id2 = obj2.getPhysicsId()

    '''bge.constraints.createConstraint(physics_id_1, physics_id_2,
                             constraint_type,
                             edge_position_x, edge_position_y, edge_position_z,
                             edge_angle_x, edge_angle_y, edge_angle_z)'''

    obj1['joint'] = bge.constraints.createConstraint(id1, id2,
                             bge.constraints.GENERIC_6DOF_CONSTRAINT,
                             0,0,0,0,0,0)

    obj1['joint'].setParam(0, 0.0, 0.0) #No X translation
    obj1['joint'].setParam(1, 0.0, 0.0) #No Y translation
    obj1['joint'].setParam(2, 0.0, 0.0) #No Z translation
    obj1['joint'].setParam(3, 0, 0) #No X Rotation
    obj1['joint'].setParam(4, 0, 0) #No Y Rotation
    #obj1['joint'].setParam(5, 0, 0) #Commented out so there is z rotation

And now we have a reference to the constraint stored in objs['joint'] which can be removed with:

def removeWheel(wheel):
    bge.constraints.removeConstraint(wheel['joint'].getConstraintId())


It's really very easy to do this, Just follow these steps:

In addition to this if you want to add a force in the forward axis, then add a linear velocity or force in that axis.


Disable trackball toggle (R) when rotating objects

Do do this, you can remove the keymap from your preferences.

Open your preferences, go to the keymap tab, and search for "rotation" as shown below. Find the keymap for mouse/trackpad rotate, and remove it. That should remove the hotkey.

I'm not 100% sure that is the right setting, but i hope this helps.


Turn off the headers for the rendered window

If I understand what you are asking, you can get the same results by choosing New Window or Fullscreen in the Render panel under the Display drop-down list.

Choosing New Window will give you a tad bit more screen estate by not having the Info header. Hover over the list with the current selection for the python equivalent if you want to use it in a script.


I would use c for circle select and pick the top parts of the globes then either grow selection or use select similar.

Select similar which is Shift + g can be used to find faces with similar angles/direction which should be your best bet. Then just grow your selection using
Ctrl + +
More ways to select can be found here https://docs.blender.org/manual/en/latest/modeling/curves/selecting.html


How to run a python script external to Blender to run bpy commands in Blender'spython console

This is the equivalent to running the script directly, referencing a scripts path from a 2 line text-block.

filename = "/full/path/to/myscript.py"
exec(compile(open(filename).read(), filename, 'exec'))

You might want to reference a script relative to the blend file.

import bpy
filepath = bpy.path.abspath("//myscript.py")
exec(compile(open(filepath).read(), filepath, 'exec'))


Using Plane as Object transform "final" output

If you want the grid of cubes to follow the angle of the faces of the plane, you can use the plane itself to define the grid locations and angles.

In this example, I created a plane, subdivided it into 32 polygons (4x8), then applied the Simple Deform modifier to the plane to create a curve.

In Animation Nodes, you can use the Object Mesh Data node to get the locations of the polygons making up the plane, as well as the normal angles of their faces.

Then, just instance the cubes at the locations of the polygon centers, and apply the angle of rotation using the face normal.

I also used the normal angle to constrain the wiggle, so the cube moves perpendicular to the face of the curve.

I created this in Blender 2.79 / AN 2.0.4, but equivalent nodes are available in later versions of AN and Blender as well.


Is it possible to delete backfaces as opposed to hiding them?

It is impossible to delete backfaces, since they are only a concept in rendering algorithms - there is nothing to delete

Backface culling is a shading feature of the render engine that you are using. Back faces are not in any way stored with 3d data so there is nothing to delete. Backface is the back of a regular face that is determined by which direction the surface is facing or in other words - surface normals, that are definitely already included in your models when you export them from Blender or pretty much any other 3d app. No other information about back faces than surface normals is saved with the models so there is nothing more that can be done inside Blender. This features should be turned on or off in the game engine you are using. Backfaces might not be displayed by default in some rendering scenarios so it may also not be considered a feature at all, but actually the lack of another feature - backface shading, or double sided shading. It depends on how you look at it and how the shading works in a specific render engine.


Further googling found that it is a driver issue:
https://community.amd.com/thread/198677


So in short, you have a "deform rig" and you would like to combine it with a complete rig like rigify (which includes its own deform rig, controllers rig, mechanical rig, ...)?

Sadly it isn't possible. Not in an automated way I mean. You can't mix two different rigs and expect them to work together, they don't know how to "communicate" with each other.

But you have different options to choose from:

Start from the original deform rig and manually build your own controls and mechanics around.
Discard the original deform rig and create a whole new one with rigify.
Try to rename the meshes's vertex groups to the corresponding rigify's deform bones so that the rigify rig uses the original vertex groups for deformation, and make some adaptations when needed.

There isn't one best solution IMHO, they each have their pros and cons. But depending on your situation and goals, some might be more adapted.
If you just want to have an animation ready rig as soon as possible and you feel comfortable with retargeting weights, then the third option looks fine.
If you want your rig asap but don't quite enjoy the tricks of retargeting, then the second option looks more appropriate.
If you want to learn how to rig and skin, then the first option is hand on the best. Or even start from scratch, it's even more instructive.
If you know how to rig, then... Well, whatever, really.


One technique for eroding the fuse would be to keyframe the Bevel Factor of a bezier curve.

The reverse of Animate Extending a Curve .


Is there a way to mirror and duplicate in one action?

Use a mirror modifier.

All you need to do is add the mirror modifier, and set its Axis to Y...

Assuming you have the object origin at the scene center, and your cube positioned where you want it.


Everything is working exactly as it should.

When you import an object blender will rotate it so that it lines up with the blender world. The rotation is determined by the import settings Forward and Up.

All you have to do is apply the rotation ( CtrlA > Rotation ) on your imported object before making the shape key.
You will have to remake the shape key, or rotate the mesh in edit mode.
If you use the edit mode option you will want to set the 3D cursor to the original object's origin then set the Pivot Point to 3D cursor ( . ).


R to set rotation mode

Ctrl+M to set mirror mode

In this case X key twice

You'll see two red lines cross over your character in front view.


How to attach the Character to a moving base

I think this is what you are looking for : walk around and stick to animated objects.blend

Original Blender.Artists Thread link here

Video showing the following script in action here

THIS SCRIPT DOES NOT WORK WELL WITH CHARACTER PHYSICS!

USE DYNAMIC PHYSICS INSTEAD!

# Walk and stick on animated objects and planets v3
# by cotaks

# w,s,a,d and spacebar to move

# able to walk speheres and animated objects:
# like elevators/platforms/planets/beveled cubes/etc.
# when you jump off one of the objects, it will automatically turn +z axis back up

# it' a small script but very adjustable, i added more comments then script itself haha
# have fun with it.

from bge import logic

# from player origin to the floor
heigth_offset = 1.0

# length of the raycast
# increase this to be able to jump higher before falling of an object
# (also tweak jump force(brick) and (lower) gravity force)
ray_distance = 0.5

# creates some player gravity, default 30.
# (lower ables to jump off objects, higher means you can jump at all sides of the object)
# adjust the player jump force(brick), or adjust the gravity_force, i suggest keeping it 20+
#just experiment around with it till you are statisfied with the results
gravity_force = 30

def cast_ray(own, vector):

    total_distance = ray_distance + heigth_offset
    return own.rayCast(vector, own, total_distance)

def stick_to_it(cont):

    own = cont.owner

    vector_z    = own.worldPosition - own.worldOrientation.col[2]
    ray_z       = cast_ray(own, vector_z)

    if ray_z and ray_z[0] is not None:

    # this could be usefull if you use python for movement, stops the sliding
    # if you use this make sure you add a + to line 48 and 49 (so it becomes +=)
    #own.linearVelocity.x = 0
    #own.linearVelocity.y = 0

    # creates some player gravity
    vector = -own.worldOrientation.col[2] * gravity_force
    counter_gravity = own.applyForce(vector,False)

    # match our speed with the ground speed (add a + before the = if you use the above code)
    own.linearVelocity.x = ray_z[0].linearVelocity.x
    own.linearVelocity.y = ray_z[0].linearVelocity.y

    # align to the floor
    own.alignAxisToVect(ray_z[2],2, 0.3)

    # counters default gravity stops sliding down from the sides with player friction at 0
    # if you use player (material) friction (default 0.500) then you can remove this line
    own.applyForce((0,0,9.8*own.mass),False)

else:
    # put head (z axis) back up
    own.alignAxisToVect([0,0,2],2, 0.1)

def update_physics(cont):
    # for the (animated) object(s), or any object that needs to update it
    # (if you want to walk on animated objects(with bones) they need this part)
    # always(true pulse)-python(module)-scriptname.update_physics
    # if you have multiple animated objects, your better of making using for loop here
    # if you use it remove the own.reinstancePhysicsMesh() and uncomment the for loop code
    # with the for loop the animated objects needs a property called: update_physics
    own = cont.owner
    own.reinstancePhysicsMesh()

#    if not 'update_list' in own:
#        own['update_list'] = [obj for obj in own.scene.objects if 'update_physics' in obj]
#
#    for obj in own['update_list']:
#        obj.reinstancePhysicsMesh()

Just add this script to your character like that :


What noise.types are implemented within blender?

In Blender python console type noise.types. and hit Ctrl+Space and it will list all types :

>>> noise.types.
                BLENDER
                CELLNOISE
                NEWPERLIN
                STDPERLIN
                VORONOI_CRACKLE
                VORONOI_F1
                VORONOI_F2
                VORONOI_F2F1
                VORONOI_F3
                VORONOI_F4


Hiding objects with scripting - unpredictable behaviour

I think the problem here is that you do not set the active object for the context on which operators almost always rely. Here is a low-level approach without operators, tested and working. All children (recursive) of the active object are hidden.

import bpy

ob = bpy.context.active_object

def makeInvisible(ob):
    for child in ob.children:
        child.hide = True
        #call the function on the child to catch all its children
        #as there is no ob.children_recursive attribute
        makeInvisible(child)

makeInvisible(ob)

Note that this does not hide the active object itself, only its children. If you want to hide the active object too, just add ob.hide = True right below the function header.


Does Blender support other Python implementations?

Short answer, None of the other implementations.

Blender isn't just using Python for scripting, it embeds the CPython interpreter using its C-API, something which other Python implimentations don't provide.

Note: PyPy has made a start on the CPython API, it may one day be usable with Blender, currently its incomplete..

In the near future - its unlikely we will have a drop-in replacement for CPython such as IronPython, PyPy, ShedSkin, Cython... etc.

Alternatives

Import a faster environment

numpy is the best example of this, but there are other Python modules which you can speedup your scripts and comes bundled with Blender.

Embed a faster environment

Embed a faster environment _in_ Python. eg:

http://github.com/dabeaz/bitey
http://www.llvmpy.org
http://code.google.com/p/py2llvm
http://numba.pydata.org
http://documen.tician.de/pyopencl
http://documen.tician.de/pycuda

... there are probably others.

The main downside to this is your limited to primitive types (also known as POD), (eg - bytes, ints, floats, doubles) - so you end up having to convert your data into structures both environments can handle, crunch numbers, then convert back and apply to your Blender data.
Depending on the task this may not be an issue, however it does limit what you can optimize.

Write in the C extension API

For lots of users this isnt an option and involves learning how to write extensions, in C/Python-API or in something like Cython, SWIG... etc. Listing here because in some cases a small part of the script can be ported to C/C++ for a large speedup.

This method has the potential to provide an API which executes very fast, the main downside is the time it takes to write such modules and having users install them (since they're compiled C/C++).

Call out to a faster environment

You could execute code from any other language/environment as an external process and communicate with it via pipes/sockets (or even just process files and read them back), this may be too cumbersome both from a developer perspective and the effort users have to make to setup such an environment, but it _can_ be done and in some cases its worth the effort.


Setup a material similar to the following :

The 'Animate' Value should be keyframed to start at 0 and increase to change the colours - the faster this changes, the faster they will animate. The Color Ramp can be adjusted to change the sequence of colors or you could use a different interpolation if you want gradual changes rather than 'Constant'. The Power node uses the 'Random' value to add some variation to the flashing - so that some of the objects change at a different rate. Set the Power to 0 and they should all change at the same rate - or experiment with other Maths nodes to get the desired spread (eg, an 'Add 1.0' node in place of Power would allow you to set the rate to range from 1.0 to 2.0 so you'd never get really slow changing ones).

Results as shown :

Blend file attached


Texture baking noise reduction with filmic-blender, clamping does not work?

Applying simple 2D image filters for lightmap textures does not work for many reasons, primarily because it will ignore things like adjacent faces, edges, difference of shapes between faces, and other features of the 3D mesh.

But you can use the Batch Bake Blender Addon, it can use a texture noise reduction ("denoising") solution that consider the mesh geometry of the texture:

It's available at
https://noevu.com/#batch-bake

Blender Artists post: https://blenderartists.org/forum/showthread.php?443843


Hit Shift+G in Edit mode while having one of the edges selected that you want to mark as a seam.

This brings up the select similar dialog which offers the possibility to select other elements by similar properties (in your example perhaps edge length)

Another way to speed things up is box selection (B) in edit mode or circle selection (C) in edit mode. If you want to get certain stuff out of the way while selecting hit H to hide elements. Just make sure you unhide them before you unwrap.


" I basically just want to be able to run my car into another object and have it randomly deform." that is very easy to do . add collision  sensor(senses collisions) to your car and add edit object replace mesh actuator (deforms your car(you have to make independent deformed model of your car))
here is example on how to make random deformations
https://www.youtube.com/watch?v=l32qN6CwzXs


Use Blender's file browser via python, without a UI panel

Blender comes with a template for this, see:

Text Editor -> Templates -> Python -> File Export

Run the script, it will execute immediately (which is just for testing), but it also adds a menu item to the export menu.


Getting Euler rotations for an object and exporting them

Should be as simple as:

from math import degrees

"{:f} {:f} {:f}".format(*map(degrees, obj.matrix_world.to_euler()))
# '-90.224203 -10.379210 -11.433244'

to_euler() converts a matrix to an Euler object, with order XYZ (regardless of what is set for rotation_mode). The angles are given in radians, but they can be simply converted to degrees using math.degrees().


Where should I give feedback about the new Blender 2.80?

You should look for that information on the same website - blender.org. There are links to developer forums on the download page at the bottom including this one: https://devtalk.blender.org/ There is a section called User Feedback in it:


How do I remove the line from the camera view?

That line is the camera object itself. Either its width is very small or its height is very large, which is making it display as a line. The camera gets its size from the Resolution and Aspect Ratio properties in the Dimensions panel in the Render tab of the Properties editor:

Set your resolution to something more regular (or pick a Render Preset from the drop-down box) and make sure your Aspect Ratio is '1' for both x and y.


You need to switch "even thickness ON", after command starts...

eg: after pressing ALTS...

then pressing S or ALT, thus getting:

which it seems to be what you wish to obtain...


It seems that your cutout model is already extruded.

Select the outline of your cutout and mark seams for unwrap.

Select all the front faces and unwrap them (Project from View is best in this case).
Load your sonic picture in uv window and adjust the resize the unwrap (if the picture is in box size like 400x400, 512x512, it's going to fit perfect)

After this, in 3d view, Press Ctrl+I to invert the selection and unwrap it too. In Uv Window, press w and select weld (This turns the other selected faces into 1 single dot) and place the result where ever you seem appropriate.

Give material to your model and add the sonic texture sheet.


I need to merge these two objects together, with different geometry

Joining both the mesh will not get a better geometry so i deleted the below part. To get a better geometry.

I added a cube and align little bit near the cut or jaw.

I remove doubles (In edit mode -> select all press W key and remove doubles)

With the helmet selected add boolean modifier -> target the cube and apply

With the below faces selected. Extrude and scale down and once again extrude little.

Add smooth shading

Add edge modifier

Add subsurf modifier

If you see some corner edges.Go to edit mode and select the edges and dissolve them.

This is the result.

Due to large size of gif. click here to watch the preview and to enlarge the preview click on the preview


Associate Blender with file import in other format than .blend

How about making a .bat file which will open blender and load a python script, which will load your object? I've made a little proof of concept.

First, the python script. Save it somewhere. It could be next to the .bat file.

import sys
import bpy

pathToImport = sys.argv[-1]

if pathToImport.endswith('fbx'):
    bpy.ops.import_scene.fbx(filepath=pathToImport)
elif pathToImport.endswith('dae'):
    bpy.ops.wm.collada_import(filePath=pathToImport)
elif pathToImport.endswith('obj'):
    bpy.ops.import_scene.obj(filepath=pathToImport)
else:
    print('Add the specific format?')

As the import operators are not all in the same place (as you can see for the fbx and the collada) I've done this if/elif statement where you can add other formats.

Then the .bat file

SET blender="C:\bin\blender-2.70-windows64\blender.exe"
SET pythonOpenScript="R:\flavio\tmp\openAndImport.py"

%blender% -P %pythonOpenScript% -- %1

I set the paths to blender and to the python script here, easier to manage/change. The %1 at the end of the last line will be the fbx or collada file you want to open.

To finish, right click on any fbx file / properties go to the 'open with' and change it targeting the .bat. That will open the default blender scene and import your object. Any other fbx file should do the same thing. Proceed in the same way for .obj and .dae files.


blender 2.80 AV sync / frame dropping option

It's still at the top of the playback menu but now in it's own drop down sub-menu. It says No Sync by default.


A camera representation is missing from my scene. How can I see it?

This is a very common issue for newer Blender users. There are many hotkeys that they are not aware of, and because of that may unwittingly do something not intended.
This is a prime example of that. You appear to have accidentally pressed H while your camera was selected. This keystroke is the Blender shortcut to hide objects in the viewport. To make all objects in the scene visible again, press Alt+H. This un-hides all objects in the current viewport.


Look for the link.

Each run of script, offsetting old mix node
's location.x

Put all current mix nodes into a list.
Find any links between a mix node and the principle shader
Make a new mix node.
If there's a link attach the from node (a mix node) output to the
input of new mix node
Make link new mix node to principled shader
Move the old mix nodes.  Could do this prior... sometimes handy to post-process incase a prior step is aborted.)

Test script
import bpy
context = bpy.context
nodes = context.active_object.active_material.node_tree.nodes
links = context.active_object.active_material.node_tree.links
ps = nodes.get('Principled BSDF')

mixnodes = [n for n in nodes if n.label == "mix"]
mix_ps_links = [l for l in links if l.from_node.label == "mix" and l.to_node == ps]

# add new mix node
mix = nodes.new('ShaderNodeMixRGB')
mix.location = (-300, -200)
mix.label = "mix"

if mix_ps_links:
    link = mix_ps_links.pop()
    links.new(link.from_node.outputs[0], mix.inputs[0])

links.new(mix.outputs[0], ps.inputs[0])

for mix in mixnodes:
    mix.location.y -= 200

Note: I use the line in test code context = bpy.context to make it cut and paste directly into methods where context is passed, eg def execute(self, context):


Disable Texture Solid option

When that option is enabled, it's supposed that the artist is more intrested in seeing textures than faces dots, so they are automatically hidden (as if you were in texture paint mode) to avoid confusion.

Imagine these dots upon a pois-pattern texture!

As stated by Sergey Sharybin in this task:

  [...] it's currently intentional behavior. Textured shading wouldn't have dots, solid shading with textured solid enabled also wouldn't have dots. This makes sense since this dots wouldn't be much helpful -- they either could obscure texture or the wouldn't be well enough visible.


There exists a work in progress plugin thats claims to be able to view blend files in VR: https://www.youtube.com/watch?v=9qAC8FTrU5s

The HTC Vive Virtual Reality Headset is basically a Display. It has no software to show things by itself. So equally to your computer screen it can't open Files.

First option would bee to find some software that is able to display 3D objects on your VR-Headset. You can import .obj/.mtl files to tiltrbush with some fiddling - maybe something more general exists. And after that you need to figure out the details how to export to that specific software.

Option two would be to create software that can render to your VR-Headset. That is easiest done with a Game engine like godotengine (open source), Unity3d or Unreal (proprietary with free entry level licenses).
I Would personally recommend Unity3d as it is beginner friendly and has nice Blender integration.
Making things look god in a game engine is some one topic of study though.


Object turns white when rendering/render Layer Colors disappear

If you are using a material in the render layer's settings, it will override all other materials at the time of rendering.

To clear it press on the X to the right of the material.

Once cleared, the render layer will use the materials set for each of the objects in the scene.

EDIT:

Newer versions of blender don't use layers, but "collections" so the override function is in the scene>View Layer section.

Additional info:

Where is the Layers panel in Blender 2.8?

2.8 - Is it possible to assign (override) a material to a whole collection?


How to run a Python callback when Blender exits?

While we could support this via bpy.app.handlers, we decieded not to add this since Python already supports exit callbacks, so you can use these (outside of Blender too - for any Python script).

See Python's atexit module.

Simple example use:

def goodbye(name, adjective):
    print("Goodbye, %s, it was %s to meet you." % (name, adjective))

import atexit
atexit.register(goodbye, "Suzanne", "nice")


I've analyzed your scene, even rebuilt it from scratch because I could not understand my self what the problem was!

The reason you are getting artifacts and freestyle fails to compute correctly is because you have the legs of the table coplanar with the surface of the table and this notoriously cause problems not only in freestyle but in BI and Cycles too.
In other words avoid having a surface exactly snapped on another surface because it may cause errors computing what is on top of the other.

Just lower the two cubes by few mm and you have solved the problem

edit more info:

It's called Z-fighting

it's not specific to Blender even, this problems may be noticeable or not but for your purpose you are asking to freestyle to show only visible edge and there is no way for it to discern if the upper face of the leg/cube it's higher or lower the bottom face of the table/cube. You need to give the render a hint even by a very slight amount.

And speaking about common practice, the common practice is to delete the invisible face!


Label not showing up as transparent... or showing at all

On't use a mix shader but an RBG mix to combine the color and the texture


How do I export rigged model from Blender to Mixamo?

You should be able to setup the armature in Mixiamo. Make sure your character is in a standard pose with both arms extended. Mixamo has problems with characters with short arms and legs. It works best with standard humanoid looking character because it's  easier to identify the difference between the different joints. Once you've setup the armature you can click the "Download" button.


When sculpting, my brush changes from Add to Subtract and viceversa

If you try to enter Sculpt Mode with your model, you can see the warning message Object has non-uniform scale, sculpting may be inpredictable .

First, select the object in Object Mode and then Apply the Scale by Ctrl+A > Scale.
Then go into Edit Mode, select all by A and Make Normals Consistent by pressing Ctrl+N.
If normals are now inverted, invert them back by W > Flip Normals.

Then your sculpting tool should work equally on the whole model.