How to get pixelated edges look? (PS1, DS, etc.)

I have now tried the solution from the post regarding the filter width, and it works in 2.79 as well. You need to change the "filter type" value under "film" in the "render tab" to a low value. Please note that this will only be visible in the final render.


For simplicity and avoiding the use of extra information:

You can check 'use self' which allows to get data from the object directly.

Using 'self' calculates the expression during the move, but keeps the current value (so that no circular dependencies) and finally apply the expression.

So for instance if the expression is:

(self.location[0] <= 0.5) * 0 + (self.location[0] > 0.5) * 1

you obtain:

Edit: of course in this case, the expression can be shorten to:

self.location[0] > 0.5

Edit2: following the comment of @DuaneDibbley, for your information.

A Python boolean expression can be True or False and True is numerically equal to 1, False is numerically equal to 0.

So you can use them as numerical values.


I was able to create that animation just using shape keys.

Start out with a plane that has the same geometry as the folds in a Miura fold.

Add two shape keys on that mesh. The first will be the "Basis," the second will be the one in which you edit the mesh. (I used more then two, but two will work fine.)

Tab in to Edit mode and start moving the edges together. The only tricky part is keeping the edges the same length. You will need to turn on Length in the Mesh Display heading of the properties region. (I duplicated the unedited mesh so I could check the edge lengths.)

Start by selecting every second edge loop and moving it up along the Z a bit less then the length of the edges. (In my mesh the shortest edge was about 2.66, so I moved the edges up 2.5.)
Starting at the end, select each edge loop and move it along the X until the lengths match the original length. (It does not have to be perfect, in the gif I'm sure not.) Continue moving the edges closer together until you are done with that axis.
Simply do the same thing for the other axis. Starting at the top (or bottom) select each edge loop and move it along the Y axis until it is the same length as the original.

In this gif I only do three edges, just because it is all the same.

4. Add a bevel and a Subsurf modifier to the mesh. You will need to crease the outside edges, to keep the corners from rounding.


How do I mirror the faces of a cube (edit all of them when I edit one)?

Use one or more mirror modifiers with a mirror object.
Use the array modifier with an object offset.
Use duplifaces displaying another object.

The third option suits your problem best, here is a step by step solution.

Add a plane ad duplicate it Shift + D.

Make sure both planes point to the same mesh datablock. If necessary, set the duplicated datablock to the same mesh. The mesh
datablock in the object properties panel should display a 2 at the
end.

Editing one plane now affects both, because they point to the same datablock.

Parent a plane to the cube Ctrl + P, both should have the same location.

Set the duplication property of the cube to Faces (in the object properties panel).

Editing one of the planes will now affects all faces of the cube. The plane parented to the cube will not be rendered. I duplicated the plane to make the edits to it easier, since the other plane is hidden in the cube.


What color space to use for EXR in textures

For EXR use Linear.

(If you know that your EXRs are encoded using other color space... then you would know the answer already)


Start with a plane. Keep it as separate object and add a "solidify" modifier and some subdivision.

Now in side view, in edge selection mode, select the top edge and extrude it along:

Keep the modifiers as long as possible in order to manage the fiewer vertices manually.
Do it for side parts too, and join the parts at the top, and adjust the heights as needed:

Once happy with the shape, apply "solidify" modifier, select the edges and bevel them:

You should obtain something like this:


What is the between normal and local space?

Probably your confusion derives by using a cube as example, which is an ultra regular object. Try Suzanne instead: the difference between local and normal is evident. The normal is calculated by the average of all normals of selected faces.


How to move selected object exactly towards/away from the camera origin?

if i understood you right, you want to change the axis from global to local.

Then select your camera and press G and Z. Now you can move the camera by moving your mouse and it is just zooming in and out now.
UPDATED ANSWER:
ok, now you have an object and your camera in the right position and rotation so that you see your object perfectly through your camera.
Now select your camera and tap on "local"

then tap on "+"
then you got this

then tap on your object and with G -> Z you can move your object as you wanted.
Viel Erfolg! ;)


Camera translation and rotation for rendering

I am not quite sure that I have understand what an Octant is, but you may try this:

first create a camera and an empty, then add to your camera a "TrackTo" constraint and set its Target to be the empty.

This is how it should look if you move you camera along the Y axis

after finishing your setup this code will pick random points in positive space, you have only to set min and max values so it can avoid overlaps and define the maximum length of your octant as you wish.

import bpy
import random

#pick random point in Octant
def Octant(minX, maxX, minY, maxY, minZ, maxZ):
    rndX = random.uniform(minX, maxX)
    rndY = random.uniform(minY, maxY)
    rndZ = random.uniform(minZ, maxZ)
    return (rndX, rndY, rndZ)

#select your main camera
camera = bpy.context.scene.objects["Camera"]
#set camera random position
camera.location = Octant(1,5, 1,4, 1,8)

it can be also enriched by the same logic so you may have small differences on the focal length and the empty's position too.


How does one align an object to trackers in 3d view?

In the Solve section you have two options:

3D trackers to mesh (which will create vertex where the selected trackers are)

or

Link Empty to track (which will create an empty in the 3D environment to which you can parent objects)


Active camera not working on blender game

There's several issues on you file...

Character Structure

Try to read the BGE Guide To Character Setup, you will understand that an armature should not be the physics object of your character: make an physics object with physics type Capsule and parent the armature to it. Also, make sure to check the Actor checkbox, so your player can be detected by the zones.

Zones Physics

Static objects can't detect collisions, so you have to change your zones physics types to Sensor and enable Detect actors. Also, disable the pulse mode on the collision sensors, it takes a lot of memory.

A Silly Mistake...

Your collision sensors are looking for an object with the property Player, but your player does not have this property! Add it to your player and the sensors should detect it.

Conclusion

Also, there's a lot of optimization you could do, especially disabling the physics on objects that don't need it (paintings, lamps, statue, etc). Try to read these guides to learn a bit more about logic, structure and project management.

Your file with some of the issues corrected:


This is happenning because you have smooth shading applied, to solve that you have to give your model 'Edge Split' Modifier.


It is hard to see it all without all the pictures packed (or I just don't have HDR activated), or that the head is lacking materials. However, I myself have had a few troubles in regards to things being not lit the way I like it. One of the things involves having specularity spots on eyes even in a dimly lit room. The two options I came up with was having "virtual lights" (spot and point) surrounding the face, and having a starfield texture added as emission.

I have played around a bit with your node setup, and what I've come up with is that from the Mix node that is connected to the Principled's Base Color, add a connection to a Bright/Contrast node, connect that to an Ambient Occlusion shader, and then an Add shader that adds together the Principled and Ambient outputs to the Material Output.

With the Bright/Contrast node you can control how bright/vibrant you want your eye, seeing as AO (and Add) doesn't have a slider for how much it affects the material. If you want a "strength slider" for the shader, or don't mind the eye emitting some light, you can exchange the AO shader for an Emission shader.

Hope this helps.


How to modify something in two dimensions at the same time?

As I see.
If you want to move the object by 2 dimensions.
1. Select the object
2. Press G
3. Press Shift + Z (Or Shift + Y, Shift + X demand on which dimension you don't want to change)
4. Move as much as you want.
Do the same with Scale.


Python: drive a shape key with scripting

Make an object custom property to drive each shape

From an Old blenderartists thread adds a custom property to context mesh object for each of its mesh data shapekeys, and sets up a driver from property to shapekey.

import bpy

context = bpy.context
scene = context.scene
object = context.object
mesh = object.data
shape_keys = mesh.shape_keys

frame = scene.frame_start
scene.frame_set(frame)
# dictionary of shape_key fcurves keyed by data_path
fcurve_dict = {}
rna = object.get('_RNA_UI', {})
for key, keyblock in shape_keys.key_blocks.items():
    if keyblock == shape_keys.key_blocks[0]:
        print("keyblock %s assumed Basis and ignored" % key)
        continue
    # create a custom property for the key

    rna[key] =  {"name": key,
                "min": keyblock.slider_min,
                "max": keyblock.slider_max,
                "description": "Shape Key %s" % key,
                "soft_min": keyblock.slider_min,
                "soft_max": keyblock.slider_max,
                }
    object[key] = keyblock.value
    object["_RNA_UI"] = rna

    # add a driver

    fcurve = shape_keys.driver_add('key_blocks["%s"].value' % key)
    driver = fcurve.driver
    driver.type = 'SCRIPTED'
    driver.expression = "shape"
    var = driver.variables.new()
    var.name = "shape"
    var.type = 'SINGLE_PROP'
    target = var.targets[0]
    target.id_type = "OBJECT"
    target.id = object.id_data
    target.data_path = '["%s"]' % key

If for instance you wish to put properties on the armature

object = bpy.data.objects["Name of Armature Object"]
mesh = bpy.data.meshes["Name of Mesh with Shapekeys"]

Please note old code.. don't use object as a variable name as its a reserved python keyword use ob or obj (for example) instead


Why doesn't my plane array align to a curve?

You ran into 3 gotchas.

The transforms on plane and path were not CtrlA applied. The object-level scale was sending deformed planes over the clipping horizon, which I also adjusted. As a general rule, while modeling, scale the mesh in Edit mode, rather than altering the object's transform.
The 'Radius' checkbox was set in the path's curve data tab. This means the scale of the deformed plane-array was responding to the curve's radius, which was somewhere near 100. In Edit Mode, under the Transform panel, I selected all the curve's vertices and set the radius to 1.
(Maybe not one?) The curve was not closed (cyclic). To toggle that, in Edit Mode, hit  AltC

Here's the file..

(BTW, on BSE, this is the preferred (dedicated) site for exchanging .blend files.)


Cut object into two objects with a plane

While i can suggest to use bisect, i have an even better solution, i wrote a little "free" add-on for exactly this situation. Called it Bisectplus, as it can take a plane object and generate 3 vertex groups which represent the cut loop, as well as both sides (which include the center each) to make it easy to use for further operations.

The source-code can be found under https://github.com/Xylvier/Bisectplus/

As it says, seeing is believing:

No harm was done to the monkey.


In your current F-curve the interpolation between frames (75,80) , (125,130) is linear, and because there is 5 frames between the frame sets I mentioned instead of 1, the rotation reverses in those 5 frames, causing the object to spin backwards very quickly. What you can do:

Bring all the keyframes starting from frame 80 back 4 frames, so the
gap becomes 1 frame instead of 5, and I recommend changing the
interpolation from linear to no interpolation, so if you change the
framerate or move the keyframes a little bit, the backward rotation
will not be visible a lot.
Do that with the keyframes starting from
    130, and for any similar 5 frame gaps.


Clipboard erased when quitting Blender on Ubuntu

I posted a bug report on this, but apparently it's not Blender's fault.
As Sergey explained in the bug report, Blender only instructs the clipboard manager to save the text, but in Ubuntu, this is a bug that affects many programs.  You can read more about why it happens here.
Going to the Ubuntu Software Center and installing the application Parcellite, which is an alternative clipboard manager has fixed the problem for me.
EDIT: I also had some problems with Parcellite and Blender working together.  You could try a different clipboard manager.


Ah I had the Profile variable set to 1! So it was trying to square everything off!

Changed the bevel settings to this to resolve my issue -


How to scale all the edges proportionally

Alt+S command should do the job here. Don't know why it doesn't? What you can do is extrude the bottom edge loop downwards (E,Z), select the extruded face loop, press E,RMB, then Alt+S, S (to enable even thickness mode). Finally delete the unnecessary geometry.

Note: After doing this the edges lenghts are still not perfect. It's because the model you provided isn't perfect too.


Try pressing X on the 2 vertices that need to be deleted, and try Delete Vertices.
If that doesn't work, press X again, but click on Dissolve Vertices instead.


Your image showed that the alpha was plugged into the image input while the image was plugged into the mix factor. So if there was no alpha you would be mixing with black. However to save re-rendering you could try using a lumakey node to remove the black background:

or use a simple mix effect, like "screen" or "add":


Every operator requires a proper context to run in. Since you mentioned that you are running the script in batch mode and accessing a view3d operator, you must provide the exact context to the operator

import bpy
# in this case the area at index 4 happens to be view3d
view3d = bpy.context.screen.areas[4]
context_override = {'window': bpy.context.window,
                    'screen': bpy.context.screen,
                    'area' : view3d}
bpy.ops.view3d.snap_cursor_to_center(context_override)

By doing this, I am able to snap the cursor by running the script from the Python console. Also, you do not need the call to poll() since you are providing the explicit context.

Relevant Links

Overriding Context
Execution Context


How to change to constant interpolation mode from a python script?

slightly simple option (probably not the best in the long run)

A toggle inverts, if all curves are selected it will select the curves that are not selected. The solution might be as simple as this.

bpy.ops.graph.select_all_toggle(invert=False)

broader answer (which is hopefully more useful)

Easy enough, but perhaps not very obvious.

kf = bpy.data.objects['Cube'].animation_data.action.fcurves[0].keyframe_points[0]
kf.interpolation = 'CONSTANT'

or for Keyframes on all F-Curves of that object

import bpy

obj = bpy.data.objects['Cube']
fcurves = obj.animation_data.action.fcurves
for fcurve in fcurves:
    for kf in fcurve.keyframe_points:
        kf.interpolation = 'CONSTANT'

Without seeing your code I can only assume things about it. You can use the Outliner (DataBlocks view) to get a reasonable idea of where to look in the API for these things.

Addendum

If the script seems to behave slowly, it might not be the interpolation but the way the script adds keyframes. I Might be wrong but I assume you are using something like this to add keyframes:

bpy.ops.anim.keyframe_insert(type='Location', confirm_success=True)
# this does more than just add keyframes

This would be faster:

import bpy

positions = (0,0,2),(0,1,2),(3,2,1),(3,4,1),(1,2,1)
start_pos = (0,0,0)

bpy.ops.mesh.primitive_uv_sphere_add(segments=32, size=0.3, location=start_pos)
bpy.ops.object.shade_smooth()
ob = bpy.context.active_object

frame_num = 0

for position in positions:
    bpy.context.scene.frame_set(frame_num)
    ob.location = position
    ob.keyframe_insert(data_path="location", index=-1)  # <-- this
    frame_num += 10

Setting the interpolation type at creation time:

for position in positions:
    bpy.context.scene.frame_set(frame_num)
    ob.location = position
    ob.keyframe_insert(data_path="location", index=-1)

    for fcurve in ob.animation_data.action.fcurves:
        kf = fcurve.keyframe_points[-1]
        kf.interpolation = 'CONSTANT'
    frame_num += 10


How can I get Blender to snap vert using grab command?

The problem is that you have proportional editing on, press O, or the blue dot at the bottom of the viewport to turn it off (see circled in red)
You also might have forgotten to turn auto merge on (circled in blue), as you seem to have 4 vertices overlapping. To remove them, select everything (A) and use the Remove Doubles function (Press space and search up Remove Doubles).


Moving an animation from 1 rig to another in a separate Blender file

Append the Action data block from the first file into the second file, then set the Action in the Action Editor.  There's no need to copy and paste.  If the rigs really are identical, connecting the appended Action should be all you need.

If location and rotation comes in wrong, I'd check the position of your Armature in Object Mode-- could be that you have values on it in one file or the other.


Difference between OpenEXR and OpenEXR Multilayer file format?

It was noted in the comments but in short, use Multilayer when you want to bundle multiple render passes in one file. It's worth noting that some programs can read EXR files, but not Multilayer EXR files. For this reason, I use  OpenEXR for non-lossy high color depth renders, and pretty much don't use OpenEXR Multilayer. The main purpose of Multilayer is to keep all the corresponding passes together for each frame, which is useful for working with other compositing software that then extracs and uses each pass.


Motion Tracking Data into Animation Nodes Editor?

According to the documentation:

  Matrices from Matrix Input node are more reliable than transforms from Transforms Input node because of their different forms and because they are always up to date even during physics simulations or when constraints are used.

For instance, if one uses a Copy Location constraint to adjust the object's location, the transforms will report the original location while the matrix inputs will report the final location.


Create cut from the wall exactly 0.3m in

The fastest way seems to be the Bevel tool.

Select the starting edge and Bevel it
Set Segments = 2, Profile = 1
Adjust offset value to your 0,3 meters

Note: This will also create two double verts. Select All and go Mesh > Clean Up > Merge by distance.


how to use the vertices data or how it affect the model

You can use it to control if and how much bevel you want on specific edges on your model. Add a Bevel Modifier and set the Limit Method to Weight.


When you change things about the mesh the UV for the textures doesn't actually update. To do that, you just need to click "u" on your keyboard and choose unwrap. You can also open the UV editor and make more complex changes from there.


Not sure exactly what you want to do, but sure, it can be done.

Yes, things will start at frame 0 unless you change the Offset value in the Domain settings. You will want to set it to -(framerate times 4). So -96 or -100 I guess. By the way, the Offset value does not need being set before baking. You can change it anytime you want.

The Start value is something else. If you set it to 4, then the first 4 seconds won't show, so you won't see the beginning of the animation. It will still need to be calculated though, so there is no saving time. I don't know why it wouldn't bake at one time. I did some tests and experienced no problems.

In general, there is usually no need to change the Start value. Offset is what you need.


How to remove rigid body setting from all the objects?

Select rigid body objects run remove operator.

An object is a rigid body if it has a rigid_body property that is not None

is_rigid_body = ob.rigid_body is not None

See Select Active Rigid Body Parts

Script that selects objects if they are a rigid body of a certain type.  Once selected running

bpy.ops.rigidbody.objects_remove()

Will remove the rigid body settings of selected rigid bodies.

Disable the rigid body world

As commented can disable rigid body world.  Cam temporarily disable via

scene.rigidbody_world.enabled = False


This question,in relation to setting operator properties in a draw method,  is a duplicate, but can never find it.

Here is a sample draw method that adds a button to render the layer "RenderLayer" of all scenes in blend.

def draw(self, context):
    layout = self.layout
    for scene in bpy.data.scenes:
        op = layout.operator("render.render", text=scene.name)
        op.layer = "RenderLayer"
        op.scene = scene.name


Split concave into separate convex meshes?

I ran into exactly the same question. I wrote a script that uses the "Split Concave Faces" feature to split the object into separate parts. It's not foolproof -- it only works well for reasonably flat, rectangular geometry.
The hardest parts of the process are:

Identifying which edges the object should be split by, since "Split Concave Faces" only adds edges that it deems necessary, but the object may already have edges that define the boundary of a convex region.
Intelligently matching up which faces of an object should be grouped together into a new closed object after splitting-up the parent object. For example, two faces that are parallel to one another might end up as separate planes after splitting by convex boundary edges -- so the script must find these and determine that they need to be matched up.

I have not found a feasible way to do either of the above if an object has holes or openings inside -- especially curved openings. It seems that the algorithm can never be sure which edges connect both sides of a convex shape for splitting, and which edges should be left alone because they're part of a closed shape. Meanwhile, once split, knowing the optimal combination of faces to re-combine to form closed shapes becomes intractible because there's no good way to know how many distinct faces/pieces need to be re-combined -- 2? 3?
Anyway, here's a link to the script:
https://gist.github.com/GuyPaddock/e2420a0c54f6892c2c2f01556d6a4e14
It operates on the selected object.
Since this is likely to be used for collision meshes for things like Unreal Engine 4, the script also renames the split pieces according to sequence numbering. Before running the script, give the object you are splitting a name
that ends with _01 (e.g. UCX_My_Mesh_01) so that all the pieces that split off from it are properly (e.g. UCX_My_Mesh_02, UCX_My_Mesh_031, etc.)
numbered.
In case my link disappears, here's the full script as of the date I am writing this:
##
# A script to split simple, architectural geometry into convex pieces.
#
# This script makes use of Blender's built-in "Split Concave Faces" clean-up
# algorithm to break-up the faces of an object into convex pieces. The script
# attempts to identify all the edges that represent convex boundaries, and then
# it splits objects up along those edges. Each resulting piece is then made into
# a closed object by converting it into a convex hull.
#
# Be sure to select the object you wish the split into convex pieces before
# running the script.
#
# NOTE: This script is expecting to work with flat, reasonably clean geometry.
# For example, it is expected to be used when generating collision on the
# ceiling and walls of an architectural visualization project, but is not
# expected to perform well with round or n-gon geometry. Using
# create_closed_objects=True and matchup_degenerates=True, in particular, does
# not work well with objects that have openings inside.
#
# If this script doesn't work for you, a plug-in like V-HACD may work better.
# This script was written to handle cases V-HACD did not handle well -- flat,
# reasonably rectangular arch. vis. geometry.
#
# @author Guy Elsmore-Paddock <guy.paddock@gmail.com>
#

import bmesh
import bpy
import operator
import re

from itertools import combinations, count
from math import atan2, pi, radians, degrees
from mathutils import Vector

def split_into_convex_pieces(ob, create_closed_objects=True,
                             matchup_degenerates=True):
    object_name = ob.name

    deselect_all_objects()
    make_all_faces_convex(ob)

    eliminated_piece_names = \
        split_on_convex_boundaries(
            ob,
            create_closed_objects,
            matchup_degenerates
        )

    rename_pieces(object_name, eliminated_piece_names)

    # Deselect everything, for the convenience of the user.
    deselect_all_objects()

def make_all_faces_convex(ob):
    bpy.context.view_layer.objects.active = ob
    bpy.ops.object.mode_set(mode='EDIT')

    # This is what actually defines the new geometry -- Blender creates the
    # convex shapes we need to split by.
    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.mesh.vert_connect_concave()
    bpy.ops.mesh.select_all(action='DESELECT')

##
# Splits an object into smaller pieces by its convex, planar edges.
#
# In an ideal world, we could just split the object by all the edges that are
# attached to -- and are co-planar with -- the faces of the object, since those
# edges are most likely to represent the convex boundaries of the object. But,
# Blender does not provide an easy way to find such edges.
#
# Instead, we use several heuristics to simulate this type of selection:
#   1. First, we select all the sharp edges of the object, since sharp edges are
#      only co-planar with one of the faces they connect with and are therefore
#      unlikely to represent convex boundary edges.
#   2. Second, we select all edges that are similar in angle to the sharp edges,
#      to catch any edges that are almost steep enough to be sharp edges.
#   3. Third, we invert the selection, which should (hopefully) cause all the
#      convex boundary edges we want to be selected.
#   4. Fourth, we seek out any sharp edges that connect with the convex boundary
#      edges, since we will need to split on these edges as well so that our
#      "cuts" go all the way around the object (e.g. if the convex boundary
#      edges lay on the top and bottom faces of an object, we need to select
#      sharp edges to connect the top and bottom edges on the left and right
#      sides so that each split piece is a complete shape instead of just
#      disconnected, detached planes).
#   4. Next, we split the object by all selected edges, which should result in
#      creation of each convex piece we seek.
#
def split_on_convex_boundaries(ob, create_closed_objects=True,
                               matchup_degenerates=True):
    bpy.ops.object.mode_set(mode='EDIT')

    select_convex_boundary_edges(ob)

    # Now perform an vertex + edge split along each selected edge, which should
    # result in the object being broken-up along each planar edge and connected
    # sharp edges (e.g. on corners).
    bpy.ops.mesh.edge_split(type='VERT')

    # Now, just break each loose part off into a separate object.
    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.mesh.separate(type='LOOSE')

    if create_closed_objects:
        # And then make each piece fully enclosed.
        return create_closed_shapes_from_pieces(ob, matchup_degenerates)
    else:
        return []

##
# Selects all edges that denote the boundaries of convex pieces.
#
# This is a multi-step process driven by heuristics:
#   1. First, we select all the sharp edges of the object, since sharp edges are
#      only co-planar with one of the faces they connect with and are therefore
#      unlikely to represent convex boundary edges.
#   2. Second, we select all edges that are similar in length to the sharp
#      edges, to catch any edges that are almost steep enough to be sharp edges.
#   3. Third, we invert the selection, which should (hopefully) cause all the
#      convex boundary edges we want to be selected.
#
def select_convex_boundary_edges(ob, max_edge_length_proportion=0.1):
    bpy.ops.object.mode_set(mode='EDIT')

    mesh = ob.data
    bm = bmesh.from_edit_mesh(mesh)

    # Enter "Edge" select mode
    bpy.context.tool_settings.mesh_select_mode = [False, True, False]

    # Find all sharp edges and edges of similar length
    bpy.ops.mesh.select_all(action='DESELECT')
    bpy.ops.mesh.edges_select_sharp()
    bpy.ops.mesh.select_similar(type='LENGTH', threshold=0.01)

    # Invert the selection to find the convex boundary edges.
    bpy.ops.mesh.select_all(action='INVERT')

    bm.faces.ensure_lookup_table()
    bm.edges.ensure_lookup_table()

    edges_to_select = []
    max_edge_length = max(ob.dimensions) * max_edge_length_proportion

    for selected_edge in [e for e in bm.edges if e.select]:
        edge_bridges =\
            find_shortest_edge_bridges(
                selected_edge,
                max_edge_length=max_edge_length
            )

        for path in edge_bridges.values():
            for edge in path:
                edges_to_select.append(edge)

    # Select the edges after we pick which edges we *want* to select, to ensure
    # that we only base our decisions on the initial convex boundary edges.
    for edge in edges_to_select:
        edge.select = True

##
# Locate the shortest path of edges to connect already-selected edges.
#
# This is used to find the additional edges that must be selected for a cut
# along a convex boundary to create a complete, closed object shape.
#
# The max edge length argument can be provided to avoid trying to find
# connections between convex boundaries that are very far apart in the same
# object.
#
def find_shortest_edge_bridges(starting_edge, max_edge_length=None):
    edge_bridges = find_bridge_edges(starting_edge, max_edge_length)
    sorted_edge_bridges = sorted(edge_bridges, key=lambda eb: eb[0])
    edge_solutions = {}

    for edge_bridge in sorted_edge_bridges:
        path_distance, final_edge, path = edge_bridge

        # Skip edges we've already found a min-length path to
        if final_edge not in edge_solutions.keys():
            edge_solutions[final_edge] = path

    print(f"Shortest edge bridges for starting edge '{str(starting_edge.index)}':")

    if len(edge_solutions) > 0:
        print(
            "  - " +
            "\n  - ".join(map(
                lambda i: str(
                    (i[0].index, str(list(map(lambda e: e.index, i[1]))))
                ),
                edge_solutions.items()
            )))
    print("")
    print("")

    return edge_solutions

##
# Performs a recursive, depth-first search from a selected edge to other edges.
#
# This returns all possible paths -- and distances of those paths -- to traverse
# the mesh from the starting, selected edge to another selected edge. To avoid
# a lengthy search, the max_depth parameter controls how many levels of edges
# are searched.
#
# The result is an array of tuples, where each tuple contains the total distance
# of the path, the already-selected edge that the path was able to reach, and
# the list of edges that would need to be selected in order to reach that
# destination edge.
#
def find_bridge_edges(edge, max_edge_length=None, max_depth=3, current_depth=0,
                      path_distance=0, edge_path=None, seen_verts=None):
    if edge_path is None:
        edge_path = []

    if seen_verts is None:
        seen_verts = []

    # Don't bother searching edges we've seen
    if edge in edge_path:
        return []

    if (current_depth > 0):
        first_edge = edge_path[0]
        edge_length = edge.calc_length()

        # Don't bother searching edges along the same normal as the first edge.
        # We want our cuts to be along convex boundaries that are perpendicular.
        if have_common_face(first_edge, edge):
            return []

        if edge.select:
            return [(path_distance, edge, edge_path)]

        # Disqualify edges that are too long.
        if max_edge_length is not None and edge_length > max_edge_length:
            print(
                f"Disqualifying edge {edge.index} because length [{edge_length}] > [{max_edge_length}"
            )

            return []

    if current_depth == max_depth:
        return []

    new_edge_path = edge_path + [edge]
    bridges = []

    for edge_vert in edge.verts:
        # Don't bother searching vertices we've already seen (no backtracking).
        if edge_vert in seen_verts:
            continue

        new_seen_verts = seen_verts + [edge_vert]

        for linked_edge in edge_vert.link_edges:
            # Don't bother searching selected edges connected to the starting
            # edge, since that gets us nowhere.
            if linked_edge.select and current_depth == 0:
                continue

            edge_length = linked_edge.calc_length()

            found_bridge_edges = find_bridge_edges(
                edge=linked_edge,
                max_edge_length=max_edge_length,
                max_depth=max_depth,
                current_depth=current_depth + 1,
                path_distance=path_distance + edge_length,
                edge_path=new_edge_path,
                seen_verts=new_seen_verts
            )

            bridges.extend(found_bridge_edges)

    return bridges

def create_closed_shapes_from_pieces(ob, matchup_degenerates=True,
                                     min_volume=0.1):
    print("Converting each piece into a closed object...")

    degenerate_piece_names = []

    for piece in name_duplicates_of(ob):
        if not make_piece_convex(piece):
            degenerate_piece_names.append(piece.name)

    degenerate_count = len(degenerate_piece_names)

    print("")
    print(f"Total degenerate (flat) pieces: {degenerate_count}")
    print("")

    eliminated_piece_names = []

    if matchup_degenerates:
        if degenerate_count > 10:
            # TODO: Hopefully, some day, find a good deterministic way to
            # automatically match up any number of degenerate pieces using a
            # heuristic that generates sane geometry.
            print(
                "There are too many degenerates for reliable auto-matching, so "
                "it will not be performed. You will need to manually combine "
                "degenerate pieces.")
            print("")
        else:
            eliminated_piece_names.extend(
                matchup_degenerate_pieces(degenerate_piece_names, min_volume)
            )

            eliminated_piece_names.extend(
                eliminate_tiny_pieces(degenerate_piece_names, min_volume)
            )

    return eliminated_piece_names

def matchup_degenerate_pieces(degenerate_piece_names, min_volume=0.1):
    pieces_eliminated = []
    degenerate_volumes = find_degenerate_combos(degenerate_piece_names)

    print("Searching for a way to match-up degenerates into volumes...")

    for piece1_name, piece1_volumes in degenerate_volumes.items():
        # Skip pieces already joined with degenerate pieces we've processed
        if piece1_name not in degenerate_piece_names:
            continue

        piece1 = bpy.data.objects[piece1_name]

        piece1_volumes_asc = dict(
            sorted(
                piece1_volumes.items(),
                key=operator.itemgetter(1)
            )
        )

        piece2 = None

        for piece2_name, combo_volume in piece1_volumes_asc.items():
            # Skip pieces that would make a volume that's too small, or that
            # have been joined with degenerate pieces we've processed
            if combo_volume < min_volume or piece2_name not in degenerate_piece_names:
                continue
            else:
                piece2 = bpy.data.objects[piece2_name]
                break

        if piece2 is not None:
            degenerate_piece_names.remove(piece2.name)
            pieces_eliminated.append(piece2.name)

            print(
                f"  - Combining parallel degenerate '{piece1.name}' with "
                f"'{piece2.name}' to form complete mesh '{piece1.name}'."
            )

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

            bpy.context.view_layer.objects.active = piece1

            piece1.select_set(True)
            piece2.select_set(True)

            bpy.ops.object.join()

            make_piece_convex(piece1)

    return pieces_eliminated

def find_degenerate_combos(degenerate_piece_names):
    volumes = {}

    for piece_combo in combinations(degenerate_piece_names, 2):
        piece1_name, piece2_name = piece_combo
        piece1 = bpy.data.objects[piece1_name]
        piece2 = bpy.data.objects[piece2_name]

        if not volumes.get(piece1_name):
            volumes[piece1_name] = {}

        piece1_mesh = piece1.data
        piece1_bm = bmesh.new()
        piece1_bm.from_mesh(piece1_mesh)

        piece2_mesh = piece2.data
        piece2_bm = bmesh.new()
        piece2_bm.from_mesh(piece2_mesh)

        piece1_bm.faces.ensure_lookup_table()
        piece2_bm.faces.ensure_lookup_table()

        if (len(piece1_bm.faces) == 0) or (len(piece2_bm.faces) == 0):
            continue

        piece1_face = piece1_bm.faces[0]
        piece2_face = piece2_bm.faces[0]

        combo_angle_radians = piece1_face.normal.angle(piece2_face.normal)
        combo_angle_degrees = int(round(degrees(combo_angle_radians)))

        # We only combine faces that are parallel to each other
        if combo_angle_degrees in [0, 180]:
            combo_volume = convex_volume(piece1, piece2)

            volumes[piece1.name][piece2.name] = combo_volume

    return volumes

def eliminate_tiny_pieces(degenerate_piece_names, min_volume=0.1):
    eliminated_piece_names = []

    tiny_piece_names = [
        n for n in degenerate_piece_names
        if n not in eliminated_piece_names
           and convex_volume(bpy.data.objects.get(n)) < min_volume
    ]

    print("")
    print(f"Total remaining tiny pieces: {len(tiny_piece_names)}")

    # Delete tiny pieces that are too small to be useful
    for tiny_piece_name in tiny_piece_names:
        print(f"  - Eliminating tiny piece '{tiny_piece_name}'...")

        tiny_piece = bpy.data.objects[tiny_piece_name]

        bpy.data.objects.remove(tiny_piece, do_unlink=True)
        eliminated_piece_names.append(tiny_piece_name)

    print("")

    return eliminated_piece_names

def make_piece_convex(ob, min_volume=0.1):
    print(
        f"  - Attempting to make '{ob.name}' into a closed, convex "
        f"shape."
    )

    volume_before = convex_volume(ob)

    make_convex_hull(ob)

    volume_after = convex_volume(ob)
    volume_delta = abs(volume_after - volume_before)

    # If the volume of the piece is very small when we tried making it convex,
    # then it's degenerate -- it's a plane or something flat that we need to
    # remove.
    is_degenerate = (volume_after < min_volume)

    print(f"    - Volume before: {volume_before}")
    print(f"    - Volume after: {volume_after}")
    print(f"    - Volume delta: {volume_delta}")
    print(f"    - Is degenerate: {is_degenerate}")

    return not is_degenerate

def make_convex_hull(ob):
    deselect_all_objects()

    bpy.context.view_layer.objects.active = ob
    ob.select_set(True)

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

    bpy.ops.mesh.select_all(action='SELECT')
    bpy.ops.mesh.convex_hull()

    mesh = ob.data
    bm = bmesh.from_edit_mesh(mesh)

    # Clean-up unnecessary edges
    bmesh.ops.dissolve_limit(
        bm,
        angle_limit=radians(5),
        verts=bm.verts,
        edges=bm.edges,
    )

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

def have_common_normal(e1, e2):
    e1_normals = map(lambda f: f.normal, e1.link_faces)
    e2_normals = map(lambda f: f.normal, e2.link_faces)

    common_normals = [n for n in e1_normals if n in e2_normals]

    return len(common_normals) > 0

def have_common_face(e1, e2):
    common_faces = [f for f in e1.link_faces if f in e2.link_faces]

    return len(common_faces) > 0

def convex_volume(*obs):
    meshes = []
    verts = []

    for ob in obs:
        mesh = ob.data
        bm = bmesh.new()

        bm.from_mesh(mesh)

        bm.verts.ensure_lookup_table()
        bm.edges.ensure_lookup_table()
        bm.faces.ensure_lookup_table()

        # Prevent early garbage collection.
        meshes.append(bm)

        geom = list(bm.verts) + list(bm.edges) + list(bm.faces)

        for g in geom:
            if hasattr(g, "verts"):
                verts.extend(v.co for v in g.verts)
            else:
                verts.append(g.co)

    return build_volume_from_verts(verts)

def build_volume_from_verts(verts):
    # Based on code from:
    # https://blender.stackexchange.com/questions/107357/how-to-find-if-geometry-linked-to-an-edge-is-coplanar
    origin = sum(verts, Vector((0, 0, 0))) / len(verts)
    bm = bmesh.new()

    for v in verts:
        bm.verts.new(v - origin)

    bmesh.ops.convex_hull(bm, input=bm.verts)

    return bm.calc_volume()

def deselect_all_objects():
    try:
        bpy.ops.object.mode_set(mode='OBJECT')
        bpy.ops.object.select_all(action='DESELECT')
    except:
        pass

def rename_pieces(object_name, name_skiplist=None):
    if name_skiplist is None:
        name_skiplist = []

    for duplicate_name, old_index_str, new_index in dupe_name_sequence(object_name, name_skiplist):
        piece = bpy.data.objects.get(duplicate_name)

        if not piece:
            break

        old_name = piece.name
        new_name = re.sub(fr"(?:01)?\.{old_index_str}$", f"{new_index:02d}", piece.name)

        if old_name != new_name:
            print(f"Renaming piece '{old_name}' to '{new_name}'.")
            piece.name = new_name

def name_duplicates_of(ob):
    duplicates = []

    for duplicate_name, _, _ in dupe_name_sequence(ob.name):
        piece = bpy.data.objects.get(duplicate_name)

        if not piece:
            break
        else:
            duplicates.append(piece)

    return duplicates

def dupe_name_sequence(base_name, skiplist=None):
    if skiplist is None:
        skiplist = []

    yield base_name, "", 1

    new_index = 1

    for old_name_index in count(start=1):
        old_index_str = f"{old_name_index:03d}"
        duplicate_name = f"{base_name}.{old_index_str}"

        if duplicate_name in skiplist:
            continue
        else:
            new_index = new_index + 1

            yield duplicate_name, old_index_str, new_index

split_into_convex_pieces(bpy.context.view_layer.objects.active)
print("Done!")

I added screenshots to the gist:
https://gist.github.com/GuyPaddock/e2420a0c54f6892c2c2f01556d6a4e14#gistcomment-3631462


There are many ways to do this, obviously.

I recommend, for the best result, to first model the whole cockpit, completely ignoring any seams and materials, just getting the shape perfectly right using subsurf and as many or few loops as you want to use.

Then, you can use the retopo tools in Blender to model a relatively fine mesh over this base-shape, fully concentrating on the right topology following the aluminium or glass surfaces. Because, through the retopology-tools (surface snapping), you don't have to worry about the three-dimensional shape at all, you will get one perfectly fitting mesh with the edge loops in the right places.

All you have to do then is to separate (Y > Split) the sections that are made out of different materials and give them some thickness through a solidify modifier or by hand. This way both the glass and the metal will look good from all angles because they have real thickness.

I actually wrote a blogpost about this a few years ago and made a screen capture of the process. The Blender Version is 2.49, but all techniques used there are still applicable today: Blogpost (Sorry, it's not a good tutorial, but maybe it helps in some way).


I suggest that instead of trying to copy and paste the bevel as a new object, you should simply duplicate the mesh you have, leaving one copy the same, and using the other mesh to create the bevels you wanted.  Simply create the bevels, and with the bevels still selected, hit ctrl-i to invert the selection, and press delete.  This way you end up with just the beveled mesh, yet you still have the original mesh to keep.

Hope that helps.


How can I setup a controller in the BGE?

In fairness, that file from blendswap did not work for me either. However making a controller's axes work is pretty easy.

There are two ways to access a controller in the BGE, that is with the joystick sensor or the joystick class through python. They are both very much the same.

The notable difference is in the way it reports the input from the axes. Using the logic brick you will get a rather arbitrary range between -32767 and 32767 (if this is the horizontal axis,-32767 is left, 0 is no moment, and 32767 is full right.)
Now getting the input through the python class normalizes the values: between -1.0 and 1.0, again 0 is no movement.

For the remainder of the answer I will be using the just the python class, but everything is easily adaptable to the logic brick.

Trouble is there are no event handlers for controllers (buttons, hats, or axes), so we have to make our own.

The buttons

For the button, using the python class, all you get is a list of the active buttons. They are listed by id 0-12. As an example button 0 is the Square Button on a DS4, and the blue X button on the xbox layout.

To turn the list in to something useful for input you will need a few lines like these:

joystick = bge.logic.joysticks[0]
btns = joystick.activeButtons
if 0 in btns and len(btns) == 1:
    doSomething()

The top line gets the controller, the second line gets the button list. Then it is just checking if the button we are targeting (button 0) is in the list. I have the len(btns) == 1 part in there so that it is only triggered by an exclusive button press (there are no other buttons held down).

The hats

Similarly the active hat is expressed in a list. However there will only ever be one active "direction" in this hat list. There are eight directions on the hat:

  0:None
  1:Up
  2:Right
  4:Down
  8:Left
  3:Up - Right
  6:Down - Right
  12:Down - Left
  9:Up - Left

from the api

Now if there is no active direction (the hat is not being pressed) then the list will be 0, not an empty list.

This is one way you can use the input from the hats:

up = 1
down = 4
left = 8
right = 2
upLeft =9
upRight = 3
downLeft = 12
downRight = 6

hats = joystick.hatValues
if up in hats:
    player.applyMovement([0.01, 0, 0], True)
elif left in hats:
    player.applyMovement([0, 0.01, 0], True)

The axes

As mentioned above the axis values are in a list axisValues, which is different for the logic brick and the python class.  Also, I do not have a DS controller, I have a "Logitech Dual Action" controller, so the axes may be (probably are) different.

At least for a xbox style controller the axes are in this order: left analog stick X, left analog stick Y, then right analog stick X and right analog stick Y.

So some (overly simplified) code to use this would be:

av = joystick.axisValues
left_analog_x = av[0]
left_analog_y = av[1]
right_analog_x = av[2]
right_analog_y = av[3]
dead_zone = .05
if abs(left_analog_y) > dead_zone:
    player.applyMovement([0, .2*left_analog_y, 0], True)

Note the dead zone there, if that is not done the player will always drift, even when there is not input.) Now I have done this on two different computers, and both have had wildly different amounts of initial drift. So what I do is just print(joystick.axisValues) and then add or subtract those values to each value in the axisValues list. It is not an ideal solution, but if the values are small it works.


Trying to add muscle to a 3d skeleton model

Looks like your model is having some issues with normals and so on. This is because .Obj models are not always being imported correctly. X-Muscle System is designed to work with armatures mostly. It is possible to connect muscles directly to geometry however you will lose many advantages and automation when using this method. All you have to do is to parent muscle's both tendons to according bone. Keep in mind all dinosaur's geometry bones have to be in hierarchy, parented to each other. I hope this helps!


is it possible to make light not follow object geometry?

You can achieve an effect like this by manipulating the normal.
Here's Suzanne showing the difference with the default surface Normal and the manipulated Normal based on the vector from the origin to the surface point :

By using a Normal calculated based on the origin, the reflection will always be as if it is formed on the surface of a sphere - thereby ignoring the geometry. Obviously the reflection is still on the surface of the mesh, but it is as if it is pointing in the direction a sphere's surface would be pointing if it were a sphere of that size at that point.
Without the manipulated Normal you can see the distorted reflection due to the surface geometry and with the manipulated Normal it becomes a symetrical circular reflection.


How to create a cube from two united planes?

One of many ways to achieve an extrusion-like result if one face is already in place:

select the two open edges in edge-selection mode

Shift + S: snap 'Cursor to Selected'

set pivot mode to '3D Cursor'

select 'hinge' edge at the bottom

Shift + D to duplicate, S, -, 1, Enter to mirror around 3D Cursor

Fill the result by selecting pairs of edges and pressing F


Edit 2: the bug has been fixed on Blender side - so if you try the latest 2.83 beta build, you shouldn't have this issue anymore.

Having the same issue and from my tests it seems related to the new undo system introduced in 2.83 beta. Scenes can (randomly?) see their user count drop to 0 after an undo operation. Saving and re-opening the file temporarily fix that, but next undo may have the same effect.
It can become harmful if you use the "Purge All" action to clean orphan data, because those 0-user scenes will be considered as such and therefore deleted.

Edit: I've reported this issue here.

It does not happen (at least in my tests) when using "Undo Legacy".

Preferences > Interface > Developer Extras
Preferences > Experimental > Undo Legacy


How can I make springs stretch and squeeze, depending on the cube movements?

The stretching of the springs can be accomplished through the 'stretch to' constraint.

The motion of the cubes driven by the springs can be generated using Blender physics.

The animation, generated in Blender 2.76, uses rigid body physics to solve for the motion of the cubes and uses the 'stretch to' constraint to stretch the springs.

The steps to generate this kind of animation are:

Add three cubes to the scene. Name the cubes 'top', 'mid', 'bot'. These will be the red, green, and blue cubes in the animation.
In the physics tab, add rigid-body dynamics to each cube. Add rigid-body constraints. Setup spring constraints between each cube. For the top cube (the red one in the animation, check 'Animated'. This setup will animate the cubes moving up and down, driven by the springs.

Add 4 empties to the scene. The empties will be used to locate the ends of the spring on the cubes. Name the empties as follows: top-lower, mid-upper, mid-lower, bot-upper. These empties are placed at the upper and lower face of the cubes. The image below illustrates the placement on the bottom of a cube.

Create the spring so it aligns with the y-axis. Parent the spring to the empty on the bottom of the cube. Repeat this each cube.

Add the 'Stretch To' constraint to each spring. Chose the empty on the upper part of the cubes as the target.

Now, if the animation is started, the results should resemble the animation.

The blend file for this animation is:


I can't make nonmanifold wings mesh manifold for 3d print

I presume you already understand what non-manifold geometry is, but if anyone reading this doesn't, there's a good explanation here.

I opened up your model, entered edit mode, pressed 2 to enter edge select mode, then went to Select > Select All By Trait > Non-manifold. This is what Blender highlighted (its the same for both wings).

I presume that the complexity of this mesh and the awkwardly placed non-manifold geometry is what is tripping up Blender's algorithm for eliminating that geometry. Let's take a closer look at what exactly going on.

The faces that are highlighted are purely flat planes. Notice how the same face is highlighted when viewing from both sides? You'll need to add thickness to those.

You'll notice that there are a couple of edges that are highlighted in the center of the wing. In these areas, the faces are coming together down to an edge, a flat edge. Once again, notice how individual edges can be viewed from both sides of the mesh. I've forgotten to deselect a couple edges that are just on the perimeter of your object, but I think you get the point.

I don't see any quick one press fixes for this... there are multiple non-manifold faces that Blender didn't even highlight, particularly at the base of the wing.

Edit:

Alright, I've managed to waterproof the mesh up to the part where it needs to connect to the rest of the body. Waterproofing the mesh was simply a nightmare...Let's just say I had to take apart the mesh and reassemble it, adding in extra edges and faces where necessary.

I wasn't sure how its meant to connect to the rest of the figure (and thus how the mesh should be shaped) so I just left it open there. The bulk of the work is done though, the only open parts of the wings are shown below.


Checker Shader Node - strange distortion Blender 2.92.0

as Jachym correctly said, just plugin the texture coordinate node, UV to vector and play with scale and you will get:


How to change a specific colour in an image

When separating colors, it is separating the primary colors.
This means red's hex will be: FF0000
Blue's hex will be: 0000FF
Green's hex will be: 00FF00

This means if you have a hex of 00FBFF and separate the colors, and only keep green, the 00FBFF will become green, because it's still got the G in it.

So when trying to change the color blue, you can't change the color blue and then combine it back with the other colors because it won't be blue. It won't function properly because you connected a different color with blue.

When separating RGBA, instead of changing Blue into BW, and then using color balance, create another Combine RGBA node and plug the Blue from the Separate RGBA into the B input (To create a proper input for B). Next, create a Hue/Saturation node, and plug the new Combine RGBA into the Hue/Saturation node. Finally, add a Mix RGB node and plug both Combine RGBA nodes into each input. Change the Mix RGB node into an Add RGB node, and plug the Add RGB node into the Viewer and/or Composite.

Now if you change the hue in the Hue/Saturation node, the blue color alone should change.

This is because we separated blue from the rest of the image, and then changed it, and replaced the color blue with something else. It works because it is separate until after the combine RBGA node.

Before

After (I change blue to the color yellow because why not
)

I hope I explained this well, and I hope I helped.


Animations not working after renaming vertex groups?

Channels

An action consists of several named channels.

Each channel is assigned to a named bone. The channels are grouped by bone name for easier identification.

When you have a different armature you get different assignements.

If you rename a bone Blender automatically changes the assignment and the group for you.

But it can do that only on known actions. That means it does this on assigned actions only. There can be only one assigned -> so it renames the current one only.

If you assign an action (via ActionEditor) that belongs to an armature with bones of different names, the channels lose the bone assignment:

This action will not play with this armature as there is no bone to play the channel.

You can rename such unassigned channels. Be aware this removes the previous assignment.

Vertex Groups

You can assign vertices to bones by assigning them a vertex group with the name that matches the bone name.

When the bone gets animated the animation engine considers the vertices that are part of the matching vertex group.

When you rename vertex groups you need to rename the according bones too. Otherwise the animation can't be matched. Blender will not automatically rename the bones. Re-parenting to the armature will (dependent on the options) result in vertex groups that match the bone names. But these are not the vertex groups you just renamed.

Conclusion

When you rename bones, ensure to rename the channels and the vertex
groups too.
When you rename vertex groups ensure to rename bones and
channels too.

I hope it helps


Time Lapse Video-week to week transition animation

That sounds like a really cool project, I'd be interested to see the results if you happen to post it somewhere.
As far as animating, if each stage of construction is a separate object, you can keyframe their visibility at different points along the timeline to have them transition.
For example, assuming 30 frames per second and each object stays in the scene for 2 seconds, you would start out the scene with the first object visible and the rest turned off (for rendering, not just in the viewport).  At frame 1, hold the cursor over the visibility icon for that object and press i to add a keyframe.  You'll want to have the other objects turned off and keyframe each of them the same way.  Notice that the color of the icons changes when they're keyframed:

Move the timeline to frame 60 (2 seconds) and keyframe Object 1 again, this will keep it visible for the entire two seconds.  Now, keyframe Object 2 as visible.  Move the timeline to frame 120 (0:04 in video time) and keyframe Object 2 as visible again and Object 1 as invisible.  Move the timeline to frame 150 (0:05 in video time) and keyframe Object 2 again to keep it visible.  I did a test in Blender with three objects and here's what the timelines looked like for all three:
Object 1:

Object 2:

Object 3:

The diamonds are the keyframes, the line in between them shows when the object is in a constant state (in this case, visible).
For the rest of the objects, keyframe them as follows:
-invisible at frame 0
-visible at the end of the last object
-visible 60 frames later
-invisible at the final frame
Doing that, you should be able to just keep increasing the total number of frames as you add more objects and, each time you add an object, just render only the new frames and assemble everything in your video editor of choice.  You can even add transitions between them, titles/captions, etc.
Good luck, hope that helps!


Dope Sheet Key Automation/Effects/Preset

I've written this script to shift all the keyframes at once.

Select the objects
Open the script in the Text Edit
Set the amount of frames, eg: step(10)
Run script (Alt + P)

import bpy

def shift(step):
    interval = 0.0
    for object in bpy.context.selected_objects:
        interval += step
        if object.animation_data !=  None:
            fcurves = object.animation_data.action.fcurves
            for curve in fcurves:
                keyframepoints = curve.keyframe_points
                for point in keyframepoints:
                    point.co.x += interval
                    point.handle_left.x += interval
                    point.handle_right.x += interval

shift(10)

The script will loop through the fcurves of the selected objects and will increment the x value of each point.
Caveat:

the script doesn't allow to set the order of the objects.
the script will shift ALL the keyframes


Blender UV mapping equivalent of disabling Normalize Map in 3ds Max

The Magic UV addon (available here) can be used to accomplish the desired result.

To install the Magic UV addon:

Place uv_magic_uv folder in the Blender/(version number)/scripts/addons folder.
In Blender, go to File > User Preferences > Add-ons.
Scroll down the list and enable "UV: Magic UV".

Use:

For a given texture intended to be X units by X units in size, make a reference square (e.g., the side of cube) of those dimensions.
Switch to the UV Editing screen layout.
UV map the square such that it occupies the entire UV area (no margin).
With the square selected, press U and select World Scale UV > Measure.
To apply the same scaling to other faces, select them, press U, and select World Scale UV > Apply.

A video demonstrating Magic UV's World Scale UV functionality is available here (recorded by Nutti, the creator of the addon).


I do not have a straight out easy solution, but i can think of a 2 ways of doing this.

Do all the STL files have the same number of Vertices and faces?

If the number of Vertices and Faces dont change, I would suggest a python script.

first have a look at the AnimAll addon that comes with blender. you just have to enable it in your user preferences.

http://wiki.blender.org/index.php/Extensions:2.6/Py/Scripts/Animation/AnimAll

write a script that does the following:

imports the first STL frame.
call:

  bpy.ops.anim.insert_keyframe_animall()

then for each frame after that:

import the STL File for that frame.
change the positions of each vertex in the main object to that in the frame imported.
call:

  bpy.ops.anim.insert_keyframe_animall()
  delete the STL frame imported.

That way all your frames will be in the same object, and show up as keyframes in the animation editors.

This assumes that the STL files have kept the vertices order the same, otherwise this method will not work and your imported animation will just jump all over the place.

There is the MeshFoot addon which will import a sequence of OBJ files, however it does not work with STL files, so you would have to modify the code to get it working with STL files.


As from release notes, Limited Dissolve without All Boundaries will:

  Limited Dissolve will have no affect on edges or vertices selected on the openings, but will limit the mesh appropriately on the edges/vertices away from the openings.

Limited Dissolve will affect only on edges / vertices which are located inside of closed areas (i.e. not closely to boundary loop).

All Boundaries checked will make tool to dissolve vertices located on the boundary loop if those vertices have no more than 2 edges connected to them.

Taking into consideration some examples, this will look as follows.

Unfolded cube with edge loops in the corners

Loops were removed by both options;
All Boundaries removed several faces of the mesh. Those were faces which haven't any further extruding out; their boundary vertices had only 2 edges connecting them - the ones which the actual face consisted of.

UV sphere with several edges deleted

Edge loops in the top (and bottom) part of the mesh were decreased in both cases, surrounding faces were converted into Ngons;
All Boundaries option changed boundary loop (where mesh is opened); faces which had 1 vertex not connected to anything else were converted to tris, and that vertex dissolved.
If sphere weren't opened, there wouldn't be any differences between All Boundaries turned on or off.

Generally All Boundaries may seem a bit strange because it dissolves geometry fallen under the threshold on the flat surfaces and around opened loops; thus if there isn't any supported geometry remained, the result won't be as expected:

Unexpected result of dissolving with All Boundaries turned on; the plane subdivisions were removed and hence was removed that part of plane because only 2 edges were touching vertices in the corners of the mesh after dissolving.


How to use absolute value in Loopcut and edge slide?

When you press Ctrl + R you actually perform two actions: Loop Cut + Edge Slide.
The easiest way to slide edges a certain distance from a vertex is to slide to a vertex first, then slide the desired distance.

Ctrl + R + LMB to select the ring to cut
1 (or -1) to place the loop at the very last vertex of the edge you are cutting
Ctrl + E + Edge Slide + relative distance

NOTE
In this way you can set zero at a vertex instead at the center.
It helps to calculate the absolute distance (as Carlo suggests), but actually doesn't allow to set edge slide by unit.
You don't need to calculate the value manually: use Python expressions instead, simply typing = followed by the operation
Check Edge Info: Length in Property Panel (N)

Even off
If you're sliding proportionally (Even off), you have to choose the edge wich the absolute slide amount refers to.
In this example, I want the edge to slide 0.5 units along the shortest edge.

Now the tricky part: type this simple operation (thanks @Carlo):
= absolute_distance / edge_lenght

in my case:
= 0.5 / 1.13

Even on
From Blender Manual

Even E
Forces the edge loop to match the shape of the adjacent edge loop. You can flip to the opposite vertex using F. Use Alt-Wheel to change the control edge.
Flip F
When Even mode is active, this flips between the two adjacent edge loops the active edge loop will match

In this case, the operation is a bit longer, because zero is at the median point of the edge :
  = absolute_distance / edge_lenght - edge_lenght / 2

in my case:
= 0.5 / 1.13 - 1.13 / 2

note:
You'll notice a rounding error (the value is not exactly 0.5), because some approximation


Check that you have the "keep uv and edit mode mesh sync" disabled (in the bottom screen options). I had the same issue and that worked


Based on your video; you are roughly here;

You first step should be to enable, then bake, the mesh;

(Note: My image shows "free mesh" on that button, because I've already baked it)

Now, turn off the liquid;

And you should now have this;


No Addon, plain Blender.

The arch was mirrored.

The mirrored arch is extruded along the normals and meet in the middle. Like the extrusion in the video.

Here the view with only one side editable:

Side note:
Without the mirror if you have the whole arch. You can archive something similar with extrude followed by scale. e then s


Materials in the game engine have no shadows

Use dynamic shadows. Check the shdow propery of your lamp object.

Or bake your shadows in blender render or cycles, what can lead to better performance, however they will be static.


Blender [2.91] Liquid simulation not filling container

I think I figured it out.

Lower The Viscosity of your liquid
Make the source size bigger
Make sure your source has enough room to "spout out" the liquid
Use modular bake so you can finetune settings without having to bake everything all over all the time
Bake the mesh


The data structure seems to be python dictionaries pointing to addresses in memory.
Given your above code you can see the dictionaries by using

DNA_struct_of_scene = scene.file.structs[scene.sdna_index]
rel_dict = DNA_struct_of_scene.field_from_name[b'r'].dna_type.field_from_name

From the dict posted below, you can use

scene[b"r",b'size']

to get the render scale and

scene[b'r',b'frs_sec']

to get the frames per second

rel dict =
 {b'im_format': <__main__.DNAField at 0x7f4e476aa990>,
 b'avicodecdata': <__main__.DNAField at 0x7f4e476aa9d8>,
 b'qtcodecdata': <__main__.DNAField at 0x7f4e476aaa20>,
 b'qtcodecsettings': <__main__.DNAField at 0x7f4e476aaa68>,
 b'ffcodecdata': <__main__.DNAField at 0x7f4e476aaab0>,
 b'cfra': <__main__.DNAField at 0x7f4e476aaaf8>,
 b'sfra': <__main__.DNAField at 0x7f4e476aab40>,
 b'efra': <__main__.DNAField at 0x7f4e476aab88>,
 b'subframe': <__main__.DNAField at 0x7f4e476aabd0>,
 b'psfra': <__main__.DNAField at 0x7f4e476aac18>,
 b'pefra': <__main__.DNAField at 0x7f4e476aac60>,
 b'images': <__main__.DNAField at 0x7f4e476aaca8>,
 b'framapto': <__main__.DNAField at 0x7f4e476aacf0>,
 b'flag': <__main__.DNAField at 0x7f4e476aad38>,
 b'threads': <__main__.DNAField at 0x7f4e476aad80>,
 b'framelen': <__main__.DNAField at 0x7f4e476aadc8>,
 b'blurfac': <__main__.DNAField at 0x7f4e476aae10>,
 b'edgeR': <__main__.DNAField at 0x7f4e476aae58>,
 b'edgeG': <__main__.DNAField at 0x7f4e476aaea0>,
 b'edgeB': <__main__.DNAField at 0x7f4e476aaee8>,
 b'fullscreen': <__main__.DNAField at 0x7f4e476aaf30>,
 b'xplay': <__main__.DNAField at 0x7f4e476aaf78>,
 b'yplay': <__main__.DNAField at 0x7f4e476aafc0>,
 b'freqplay': <__main__.DNAField at 0x7f4e476ab048>,
 b'depth': <__main__.DNAField at 0x7f4e476ab090>,
 b'attrib': <__main__.DNAField at 0x7f4e476ab0d8>,
 b'frame_step': <__main__.DNAField at 0x7f4e476ab120>,
 b'stereomode': <__main__.DNAField at 0x7f4e476ab168>,
 b'dimensionspreset': <__main__.DNAField at 0x7f4e476ab1b0>,
 b'filtertype': <__main__.DNAField at 0x7f4e476ab1f8>,
 b'size': <__main__.DNAField at 0x7f4e476ab240>,
 b'maximsize': <__main__.DNAField at 0x7f4e476ab288>,
 b'pad6': <__main__.DNAField at 0x7f4e476ab2d0>,
 b'xsch': <__main__.DNAField at 0x7f4e476ab318>,
 b'ysch': <__main__.DNAField at 0x7f4e476ab360>,
 b'xparts': <__main__.DNAField at 0x7f4e476ab3a8>,
 b'yparts': <__main__.DNAField at 0x7f4e476ab3f0>,
 b'tilex': <__main__.DNAField at 0x7f4e476ab438>,
 b'tiley': <__main__.DNAField at 0x7f4e476ab480>,
 b'planes': <__main__.DNAField at 0x7f4e476ab4c8>,
 b'imtype': <__main__.DNAField at 0x7f4e476ab510>,
 b'subimtype': <__main__.DNAField at 0x7f4e476ab558>,
 b'quality': <__main__.DNAField at 0x7f4e476ab5a0>,
 b'displaymode': <__main__.DNAField at 0x7f4e476ab5e8>,
 b'use_lock_interface': <__main__.DNAField at 0x7f4e476ab630>,
 b'pad7': <__main__.DNAField at 0x7f4e476ab678>,
 b'scemode': <__main__.DNAField at 0x7f4e476ab6c0>,
 b'mode': <__main__.DNAField at 0x7f4e476ab708>,
 b'raytrace_options': <__main__.DNAField at 0x7f4e476ab750>,
 b'raytrace_structure': <__main__.DNAField at 0x7f4e476ab798>,
 b'pad1': <__main__.DNAField at 0x7f4e476ab7e0>,
 b'ocres': <__main__.DNAField at 0x7f4e476ab828>,
 b'pad4': <__main__.DNAField at 0x7f4e476ab870>,
 b'alphamode': <__main__.DNAField at 0x7f4e476ab8b8>,
 b'osa': <__main__.DNAField at 0x7f4e476ab900>,
 b'frs_sec': <__main__.DNAField at 0x7f4e476ab948>,
 b'edgeint': <__main__.DNAField at 0x7f4e476ab990>,
 b'safety': <__main__.DNAField at 0x7f4e476ab9d8>,
 b'border': <__main__.DNAField at 0x7f4e476aba20>,
 b'disprect': <__main__.DNAField at 0x7f4e476aba68>,
 b'layers': <__main__.DNAField at 0x7f4e476abab0>,
 b'actlay': <__main__.DNAField at 0x7f4e476abaf8>,
 b'mblur_samples': <__main__.DNAField at 0x7f4e476abb40>,
 b'xasp': <__main__.DNAField at 0x7f4e476abb88>,
 b'yasp': <__main__.DNAField at 0x7f4e476abbd0>,
 b'frs_sec_base': <__main__.DNAField at 0x7f4e476abc18>,
 b'gauss': <__main__.DNAField at 0x7f4e476abc60>,
 b'color_mgt_flag': <__main__.DNAField at 0x7f4e476abca8>,
 b'postgamma': <__main__.DNAField at 0x7f4e476abcf0>,
 b'posthue': <__main__.DNAField at 0x7f4e476abd38>,
 b'postsat': <__main__.DNAField at 0x7f4e476abd80>,
 b'dither_intensity': <__main__.DNAField at 0x7f4e476abdc8>,
 b'bake_osa': <__main__.DNAField at 0x7f4e476abe10>,
 b'bake_filter': <__main__.DNAField at 0x7f4e476abe58>,
 b'bake_mode': <__main__.DNAField at 0x7f4e476abea0>,
 b'bake_flag': <__main__.DNAField at 0x7f4e476abee8>,
 b'bake_normal_space': <__main__.DNAField at 0x7f4e476abf30>,
 b'bake_quad_split': <__main__.DNAField at 0x7f4e476abf78>,
 b'bake_maxdist': <__main__.DNAField at 0x7f4e476abfc0>,
 b'bake_biasdist': <__main__.DNAField at 0x7f4e476ad048>,
 b'bake_samples': <__main__.DNAField at 0x7f4e476ad090>,
 b'bake_pad': <__main__.DNAField at 0x7f4e476ad0d8>,
 b'bake_user_scale': <__main__.DNAField at 0x7f4e476ad120>,
 b'bake_pad1': <__main__.DNAField at 0x7f4e476ad168>,
 b'pic': <__main__.DNAField at 0x7f4e476ad1b0>,
 b'stamp': <__main__.DNAField at 0x7f4e476ad1f8>,
 b'stamp_font_id': <__main__.DNAField at 0x7f4e476ad240>,
 b'pad3': <__main__.DNAField at 0x7f4e476ad288>,
 b'stamp_udata': <__main__.DNAField at 0x7f4e476ad2d0>,
 b'fg_stamp': <__main__.DNAField at 0x7f4e476ad318>,
 b'bg_stamp': <__main__.DNAField at 0x7f4e476ad360>,
 b'seq_prev_type': <__main__.DNAField at 0x7f4e476ad3a8>,
 b'seq_rend_type': <__main__.DNAField at 0x7f4e476ad3f0>,
 b'seq_flag': <__main__.DNAField at 0x7f4e476ad438>,
 b'pad5': <__main__.DNAField at 0x7f4e476ad480>,
 b'simplify_flag': <__main__.DNAField at 0x7f4e476ad4c8>,
 b'simplify_subsurf': <__main__.DNAField at 0x7f4e476ad510>,
 b'simplify_subsurf_render': <__main__.DNAField at 0x7f4e476ad558>,
 b'simplify_shadowsamples': <__main__.DNAField at 0x7f4e476ad5a0>,
 b'pad9': <__main__.DNAField at 0x7f4e476ad5e8>,
 b'simplify_particles': <__main__.DNAField at 0x7f4e476ad630>,
 b'simplify_particles_render': <__main__.DNAField at 0x7f4e476ad678>,
 b'simplify_aosss': <__main__.DNAField at 0x7f4e476ad6c0>,
 b'cineonwhite': <__main__.DNAField at 0x7f4e476ad708>,
 b'cineonblack': <__main__.DNAField at 0x7f4e476ad750>,
 b'cineongamma': <__main__.DNAField at 0x7f4e476ad798>,
 b'jp2_preset': <__main__.DNAField at 0x7f4e476ad7e0>,
 b'jp2_depth': <__main__.DNAField at 0x7f4e476ad828>,
 b'rpad3': <__main__.DNAField at 0x7f4e476ad870>,
 b'domeres': <__main__.DNAField at 0x7f4e476ad8b8>,
 b'domemode': <__main__.DNAField at 0x7f4e476ad900>,
 b'domeangle': <__main__.DNAField at 0x7f4e476ad948>,
 b'dometilt': <__main__.DNAField at 0x7f4e476ad990>,
 b'domeresbuf': <__main__.DNAField at 0x7f4e476ad9d8>,
 b'pad2': <__main__.DNAField at 0x7f4e476ada20>,
 b'dometext': <__main__.DNAField at 0x7f4e476ada68>,
 b'line_thickness_mode': <__main__.DNAField at 0x7f4e476adab0>,
 b'unit_line_thickness': <__main__.DNAField at 0x7f4e476adaf8>,
 b'engine': <__main__.DNAField at 0x7f4e476adb40>,
 b'bake': <__main__.DNAField at 0x7f4e476adb88>,
 b'preview_start_resolution': <__main__.DNAField at 0x7f4e476adbd0>,
 b'debug_pass_type': <__main__.DNAField at 0x7f4e476adc18>,
 b'pad': <__main__.DNAField at 0x7f4e476adc60>,
 b'views': <__main__.DNAField at 0x7f4e476adca8>,
 b'actview': <__main__.DNAField at 0x7f4e476adcf0>,
 b'views_format': <__main__.DNAField at 0x7f4e476add38>,
 b'pad8': <__main__.DNAField at 0x7f4e476add80>,
 b'mblur_shutter_curve': <__main__.DNAField at 0x7f4e476addc8>}


The color is comming from Flames Color Ramp. The last color (left side) of ColorRamp has to be Black to get Transparency in Domain.

Also you have disabled Sphere from calculation. To let it participate as Inflow you have to click on Monitor icon.


This error occurs when you do not have enough RAM for your scene. This could be cause by the particles, but it also may be something else in your scene. Try a blank scene with a particle system of 500,000 and see if you get the same error. If you don't, you'll need to optimize the other objects in your scene. Either way, a RAM upgrade is generally a good idea when getting into intense 3D arts.

Also, are you rendering on GPU? If so, try switching to CPU. GPU rendering uses VRAM, whereas CPU uses your computer's RAM.


Blender 2.79 smoke simulation, domain rendering as solid cube

The Quick Smoke option automatically generates the smoke material based on your currently selected Render Engine. The Blender Render renderer uses different materials to Cycles and they are not interchangeable. Therefore, if you do 'Quick Smoke' whilst Blender Render is selected and then swap to Cycles, you will not have a valid material (since it will be the Blender Render material, rather than Cycles) and you will see the Cycles material rendered as the default (Diffuse) material.

The solution is to select Cycles renderer before you select Quick Smoke. The easiest way to resolve this will be to delete your Smoke Domain, select your Cube again, and then re-select Quick Smoke - this should create a new domain with the correct smoke material.


Weird box that I can't get rid of on the viewport

In the viewport:
Press Ctrl + Alt + B to remove a render region.
Press Alt + B to discard a clipping region.


In this blend, you need to adjust the following to get the desired effect:

1) set Rigidbody shape to Convex Hull, this is faster and with regular voronoi geometry, more stable as well. Means the wall will not explode with lower constraints settings.

2) reduce the constraint search radius to about 5.0 and the amount of constraints to 50. Those settings apply to each mesh island, means each island searches for max. 50 neighbors in a radius of 5.0 around its centroid then.
Rule of thumb: the smaller the shards are, the smaller the search radius can become to find enough neighbors.
You dont need 2000 constraints per Island and such a large search radius here. (btw, I work without units mostly, but this is personal preference.)

3) optionally you could make the wall animated and triggered, and the wrecking ball a trigger. With this setting the shard simulation starts only for those shards being hit by a trigger, basically. The others remain inactive, which is faster too.


How to make objects draw transparent/wireframe in the viewport?

You can make an object be displayed as a wireframe by setting the Maximum draw type to wire in Properties editor > Object > Display:

You make an object display as transparent by adjusting the alpha of it's material, and enabling Transparent in the display settings:


Getting instanced particles to follow paths of hairs in particle system with hair dynamics

You almost did it, just a few things to fix:

decimate the number of faces of the cylinder with the Decimate modifier, un-subdivide. The faces get multiplied by each particle. In Object mode, right-click the object and select Shade Smooth, and will look the same with only 300 vertices, that's 1/10th.

lay down the cylinder along the Y-axis by a -90° rotation around the X-axis in Object mode, apply the Rotation (Ctrl+A). Make sure that the cylinder's origin is at bottom of the mesh, at world origin. Apply Location if needed.

In Edit mode, move 3D Cursor to world origin (Shift+S), select all vertices (A), and select from menu: Mesh → Sort Elements... → Cursor Distance. This prevents strange things from happening as the particles bend and twist due to a change in wind direction.
layout of particle object

Change the settings of the Particle Instance modifier: (Pole Axis: Z, set Position: 1.000, clear Keep Shape checkbox)

Particles in the wind:

Blend file:


Why is Pie empty when no object in layer

Replace:

mesh = context.active_object.data

With:

if context.active_object :
    mesh = context.active_object.data

By Chebhou


When I Change My Frame Rate from 24 the 60 fps the particles go ultra fast and are not normal speed anymore

Ok, I see what's happening now.  The reason it's going wonky is because you need to bake the particles first:
Just to make sure it's right, do it before you change the framerate.

After it's completed baking (it could take a minute depending on your processor speed), set the end frame and framerate settings as shown below:

Here's the final, notice the fps in the upper left hand corner:


Why is my model showing different shading on a flat area around a hole?

It looks to me like you simply have smooth shading turned on. In edit mode, in the 3d view, the toolbar on the left (in your picture it says "Add Meshes" at the top), go to the transform tab, and in the "Edit" section, look for a label called "Shading:". Under that, there should be two buttons, one says "smooth" and the other says "flat". Click the one that says "flat" and see if those dark patches go away.


Physic simulation is visible in viewport, but not in the animation render

You need to cache the physic animation:

Go to Scene Properties.
Go to Rigid Body World.
Under Cache, delete all bakes and then click on Bake All Dynamics.
You can now render your video.


Like many many others I do models for 3d print with blender. When creating models for 3d print you have to be aware of the limitations of the 3d printer and of the material you're going to print. What software you use to create your model is almost entirely a question of preference. One advantage of blender is that it offers a wide range of tools for modeling which you can all use or combine to create the perfect shape for your 3d-printed object. Shapeways has a nice guide for using blender: https://www.shapeways.com/creator/blender which you might find useful.


Merge multiple meshes into one single mesh?

There are two methods of combining meshes that I know of;
The first uses the addon BoolTool:

Select the separate objects that you want to combine
Press Ctrl+Numpad +, to perform a union operation
Press Ctrl+Shift+Numpad Enter to apply the operation

Your separate pieces will now be combined, with new geometry created at the intersections, forming one solid mesh.

The second and lengthier way uses the Intersect (Knife) mesh operation:

Combine two (or more) objects together with Ctrl+J
In edit mode, select all of the faces of one of the meshes, the easy way to do this is to select one face and press Ctrl+L to select all of the linked faces
Press Ctrl+F to bring up the faces menu and select Intersect (Knife), cuts will be made into the unselected faces where the selected faces overlap with them
Select all of the faces and perform the Remove Doubles operation

You will end up with the same result as the first method. It is advised that when using this method to only combine two objects at a time, repeating the above steps for each pairing.

In both cases you will likely be left with N-GONs, a quick, though messy way to remove these without resorting to the Knife tool is the following:

Select all of the faces and/or N-GONs and press Ctrl+T to triangulate them
With all of the faces still selected, press Alt+J to convert the resulting triangles to quads

This may save some time in some areas of the mesh where the N-GONs are relatively simple, but the resulting topology may be lacking.

I hope this helps.


These are different objects.

You can edit them all together by selecting them and switching to edit mode.

By the way, Blender has .WRL importer:

but it seems to be broken for the recent versions.

Generally it is better to download original files from SketchFab because glTF messes them up.


Expanding on the first point of John's answer.

  For realtime or viewport effects like this the general idea is to duplicate the mesh, then change that mesh to complete black then slightly upscale it so it covers your base mesh, as well as flipping all the normals on the black mesh and turning on 'Backface Culling' in the viewport settings.

⇧ ShiftD to duplicate.
Enter Edit Mode ↹ Tab, select all A, flip normals ⎈ CtrlF > Flip Normals.
Fatten the mesh slightly, ⎇ AltS.
Exit edit mode and assign a new black Material.
Turning off double sided faces in Blender: Go to the Shading Panel and check Backface Culling.


There is no sound in 2.80 but was ok in 2.79

I found the problem.
In my preference setting (go to Edit>Preference...) for Audio Device it was by default selected "SDL".
I have changed it now to OpenAl and have the audio working fine.


Why is using 'C.object.data.uv_layers.remove()' in a loop not removing all UV layers?

Try a while loop.
Rather than looping thru a list you are removing from, it is often a better to make a copy of that list and pop and remove until list exhausted.
Using pop() is taking from the end of the list.
>>> me = C.object.data
>>> me
bpy.data.meshes['Suzanne']

>>> uvlayers = me.uv_layers[:]
>>> while uvlayers:
...     me.uv_layers.remove(uvlayers.pop())


Can I do more than ctrl z/ go back very far into my model?

Blender saves one (by default) backup version of the file when you save it. You can look in it (it's named whatever.blend1) to see if it has the version you want.

Also, Blender also saves a backup file as you work, every 2 minutes by default. You can use File > Recover Auto Save... to restore this and see if it has the version you want.

If neither of these work, you are probably out of luck this time. There are a few things you can do to keep it from happening again, though:

Increase the Undo Levels in Editing preferences, so you can go back farther. I use 256 myself, but you may want to try less if it makes you run out of memory.
Increase the number of .blendX backup files Blender makes, in File preferences. I use 32, but this may be too many for you.

After changing any settings, remember to press the Save User Settings button! Otherwise, your changes will not be saved.


While in Texture Paint mode, with the Active Tool tab open (this is the case in your image), look under the Texture Slot Section for Mode. There are two options. Material and Single Image. Your pic shows Material selected currently. Try Single Image.

Some other links on this topic that might help:

What does this step do in Texture Paint?

No painting strokes showing when Texture painting


How to prevent Blender from crashing when running out of memory?

If you are out of memory, the only solutions are to install more RAM in the computer, or to make the paging file (virtual memory stored on disk) in the OS larger.
Or work in scenes that do not exceed the resources available in your computer. Don't abuse the number of particles, use instances instead of duplicates, use modifiers and set subdivision surface to low values Blender render crash when using subsurf modifiers.


How to cover a surface with cells (Biological tissue)

Final:

Overview:

I think the best option would be to use Metaball as a Hair object.

This method will need a little bit of experimenting as it could highly differ between meshes.

Metaball settings:

In Edit Mode set Resolution as low as possible, it will be better looking while rendering, as preview resolution is always a bit lower.

Really low Threshold along with high Stiffness will give more defined Mballs. As well as scaling Ellipsoid on Y axis. Higher scaling, more noticeable bumps.

Particle System settings:

Nothing fancy here.

Tweak all settings as you like. In this example I've used ones below.


Can we preset Graph Editor Interpolations for Elastic?

The first tip is that pressing T will apply the interpolation to every selected keyframe.

First, to simplify the graph editor, hide curves you aren't working on.

It would appear that you want to do this to every third keyframe, so select all won't help. We have the common selection options in the graph editor.

B to box select keyframes
C to circle select keyframes
⎈ Ctrl RMB to draw a lasso around keyframes to select

I'm thinking if you zoom out enough to see all or most of your keyframes, you can use circle select to quickly select the keys at each "corner" of your stepped fcurve.

That is about where blenders UI stops being helpful. Then we can often turn to python to help automate repetitive tasks like this. We can use the text editor to type and run longer scripts. For smaller tasks, the python console can be used to type out commands. Pressing ↑ Up arrow can bring back the previous command so we can change a single value (like the index number of the keyframe point) before repeating.

If you have selected the keys that you want and used T to set the interpolation to elestic, we can set the amplitude and period of these keys -

import bpy

obj = bpy.context.object
fc = obj.animation_data.action.fcurves

for c in fc:
    for k in c.keyframe_points:
        if k.interpolation == 'ELASTIC':
            k.amplitude = 0.8
            k.period = 4.1

In your example you appear to be setting every third keyframe, you may need to add some extra keys to maintain the repetitiveness as at least one appears missing. We can use a repetitive sequence like this to automate the entire process.

import bpy

obj = bpy.context.object
fc = obj.animation_data.action.fcurves

# adjust this to 1 or 2 to get the right keys
startidx = 0
for c in fc:
    if c.hide: continue # skip curves we have hidden
    for i in range(startidx, len(c.keyframe_points), 3):
        c.keyframe_points[i].interpolation = 'ELASTIC'
        c.keyframe_points[i].amplitude = 0.8
        c.keyframe_points[i].period = 4.1

You may also run the script and then select the first and last keys to undo the elastic setting if you didn't want it over the entire curve.


Why don't hair particles rendered as an object follow parent object when the parent object is falling under gravity as a rigid body?

I probably need some screenshots, but I'll give it a shot:
Blender hair physics cannot get the same physical behaviour as their visualized object. Not that the object gets inserted in the "Render" tab, not the physics tab. Hair have their own strand based physics, which are limited. Unfortunately (to my knowledge and frustration) you cannot even make the rendered object bend along the hair's path.
If that wasn't your question, make sure you did this:

If your using softbody, make sure they are above the hair in the modifier stack. And lastly, make sure to bake the rigidbody animation to keyframes.

Blend File


apparently after toggeling the other visibility options a few times it worked


Animation duplication for multiple objects

Shape key animation

Set origin at point of nail.
Make a simple shapekey, moving whole mesh in edit mode to "fully
nailed". Origin is at head of nail for this shapekey.
Orient the nail anywhere, Need only animate the value of the shapekey, from 0 to 1.

The nail in image is animated to nail in local Z direction... The nail object is rotated -90degs about Y axis.  should have put local axis on it I suppose.

Drivers

An interesting take on this is to use drivers (make sure that prefs > save & load > auto run python scripts is checked)

Copy the script below, paste into text editor and click run script. To have it run automatically when blend file is opened, name it nail.py and check register.

import bpy

dns = bpy.app.driver_namespace

def nail(start, end, frame):
    if frame < start:
        return 0
    elif frame >= end:
        return 1
    else:
        return (frame - start) / (end - start)

dns["nail"] = nail

Now in the value property of a nail can type in

#nail(10, 50, frame)

to have a nail start nailing in at frame 10 and finish at 50.

Now we can copy the nail, move it somewhere else,  and change the numbers in the driver to change when the nail gets nailed.

This may be a bit "out there", but is an example of there are many ways to skin a cat with blender.


First unzip the file. You'll have a folder with .py files in it.
Then go to the "scripts" folder in your blender installation directory.
In the "scripts" folder you'll find another folder named "addons". Open that.
Then copy the folder you have unzipped in to this "addons" folder.

You're done. Now all you need to do is open Blender and go to File -> User Preferences. Go to the "Add-ons" tab and search for it and it'll be there. Make sure the "Community" supported level is turned on.


Blender uses a user configurable shortcut system. We can easily add a shortcut to many operators by  on the button or menu item and choosing Add Shortcut. If you then managed to right click on the shortcut entry dialog you would get the right click as the shortcut.

If this is what you did, you will see Right Mouse next to the plane in the add menu ⇧ ShiftA->Mesh.

To remove it should be as simple as quitting blender and starting it again. If however you saved the user settings after adding the shortcut, then you will need to remove it manually or revert to factory settings. Note that adding a keyboard shortcut can be removed by right clicking it again, but a mouse shortcut needs to be removed in the input settings.

In User Preferences under the Input tab you will find the shortcut. For adding an object, you will find it by expanding 3D View and Object Mode and scrolling down to the bottom of that list.

Click the X icon to the right of the entry to remove it.

In your case you could also search for plane to find it, other times searching may be the easiest way to find it, if you can think of the right search words. You can also search by shortcut, but you will find many entries for each key and mouse so it doesn't always help.

Be sure to save user settings after removing the shortcut so that it doesn't return next time you use blender.


Toggle vertices/edge/faces with numpad emulation

I did it this way: go to Preferences > Keymap > 3D view > Mesh > Mesh (Global) > Select Mode, if you unfold the 3 first ones you should see Type > Vertices, Type > Edges and Type > Faces, and for example, for each one, you could choose alt Z / alt X / alt C


Subdivision Surface mesh weird vertex behaviour

You have a normal issue, you need to select all in Edit mode and press shiftN to recalculate. Also you'll have to disable the Subsurf Clipping option, select all the boarder vertices, move them a bit on the X axis to create a gap, then reactivate Clipping and move back the vertices so that it sticks correctly.


Dupliframes may be a good way for you here

First, ensure that the origin of your object is placed at the point of the object's mesh which you wish to lie on the curve. To make things easier, align your object so that, untransformed, the local axis you wish to follow the curve is on world Y. (You can change this later, but it's nice not to have to.)

On the plane (or tower) Object Properties > Duplication > check 'Frames'

On the curve, Curve Data > check 'Path animation' and the number of duplicates required in 'Frames', and check 'Follow' if you want the orientation of the duplicates to be tangential to the curve.

Be careful to apply any Object Mode scaling you may have  put on your curve.

Having parented the object to the curve 'Clear its Origin' (AltO, (letter'O')) You can do this at any time, to bring the object's and its duplicates' origins to lie on the curve).

If you need to correct the rotation of the master and its duplicates, with the pivot point set to 'Individual Origins',  rotate the master object around its own pivot point.

I'm confident the object centers are parametrically evenly spaced on the curve - (the tool gives a constant speed in animation) .. but there is a difference in spacing if you use the straight-line approximations to the curve, since, near Y=0 the straight line 'cuts the corner' more than near X=0.


How can I make a cycles material like white cotton material for a doctors coat?

The velvet shader often results in darker colors, so for creating a cotton material I would stay away from that. Here is a node setup for a simple cotton fabric:

Utilizing this very nice cloth texture method:

From this thread

Final result:


Is there a way to use a MIDI controller as a sensor in the Game Engine?

There is a script extension, Blender HID Mapper, that does the following:

  Create a HID Mapping script similar to the provided template and run it. Then you can control blender with your MIDI device like specified in your mapping.

Just install the most recent version of the script from this site, then write your mapping as you desire. The first link above also has a sample mapping script that you can work off of.


Hide tools in 3D viewport on Blender 2.8

Yes, just like that. Unfortunately it also hide the new axis thingy next to it, which I like a lot.


Try ⎈ CtrlF> Solidify:

Note that in many cases (including the example in the gif), this will probably result in non-manifold geometry.


Are there any tools for making irregular polygons regular?

You can use LoopTools addon, which is already with the official Blender builds.

Enable this addon from the Add-Ons list, then select the target face, then W > LoopTools > Circle, which will distribute vertices circularly and evenly.


Because fire is a volume, and volume rendering is slow. First of all, the baking you did doesn't help with rendering, it just caches the simulation itself. Anyway, the problem with rendering volumes is that you can't just sample the shader once at the surface like you can for solid objects. To render a volume, you need to evaluate the shader and sample what light is available multiple times along the transit through the volume. The finer the detail in the volume, the more steps you need to sample. The distance between steps in controlled by the "step size" attribute:  The distance is in meters, although the property doesn't show as distance for some reason. You don't need a step length any smaller than 1/2 the size of the smallest volume detail. For a smoke/fire sim, that would be the size of your voxels. You can find this for Blender's smoke sim by getting the dimensions of your domain, and plugging the length of the longest size into the formula: voxel size + length / (base res * (hi-res level + 1)). So a 10m domain with 80 res and 2 hi-res divisions would be 10 / (80 * (2+1)), or about 4cm.

There is also a "max steps" option you can use to force it to stop at some point along the path, although I'd recommend avoiding this control. Running out of steps mid-volume can potentially give some weird shading.

Additionally, if you're using the volume scatter shader, rays can be scattered (aka deflected) during the volume transit. And if your volume bounces is set greater than 0 under render settings > light path? That scattered path can scatter again. So higher values for volume bounces can increase render times a lot. Too few volume bounces can lead to dark volumes, especially for highly reflective clouds such as water vapor. You can compensate for this by adding some (more) emission to the volume if needed.

One way you can optimize a bit for smoke and the like is to prevent the shaders from running if the density is below a certain threshold. The node setup looks like this:

If the density is below the value set in the "less than" math node, it will output 0, causing the mix shader to switch to it's second socket, which as no shader. Thus, the volume closures are only executed if there's a enough density for it to matter. Figuring out the proper value for the less than node might take some trial and error.


How can I make my stone objects look less shiny?

I am assuming you are using the Blender Game Engine. Try turning down the Specular Intensity on your materials.


Boolean Union Modifier Disappearing Components

No, Blender did not run out of memory. If it had, Blender would have crashed. Furthermore, the scale (applied or not) of an object has nothing to do with it's complexity. A mesh with 5000 polygons takes up exactly (within a few bits) the same RAM no matter what scale it is.

This is probably a bug. If you can reproduce it reliably, you should look for it in the bug tracker and if it hasn't already been reported, report it.