Since your mesh only contains vertices and edges, we will have to find the angle or bisector between every possible combination of edges that share the same vertex. So, the first thing to do is to find the neighbours of each vertex. The fastest way to do that is to use the following expressions:

Then we are going to loop over the vertices and their neighbours and construct vectors going from the vertex to its neighbours:

Then, we loop over every combination of vectors computing the bisector vector, where the bisector vector $\vec{c}$ between the two vectors $\vec{a}$ and $\vec{b}$ using the following formula:

$$
\vec{c} = \vert\vert\vec{b}\vert\vert\vec{a} + \vert\vert\vec{a}\vert\vert\vec{b}
$$

Every combination of vectors can be computed using the expression:

list(zip(*combinations(vectors, 2)))

Where combinations is a function in the itertools module, so make sure to import it in the advanced node settings. So we can implement it as follows:

Constructing transformations based on those bisectors gives:


How to disable entire tracks (or multiple clips) in VSE

To disable within the VSE, use Mute Strip.

Mute Strips: H

Un-Mute Strips: Alt + H


Get texture to never distort or change scale without manual unwrapping

If you don't want to unwrap, the only way I know how to achieve what you are asking for is by using 3D procedural texture shaders. You can achieve some very impressive results if you learn how to work with them and or code them yourself. Blender has some built in that you can layer up on top of each other, though it will likely take you a lot longer than unwrapping UVs and painting to make look nice.

Note that with procedural textures, you will lose a lot of control. With procedural textures you are trying to emulate a texture using math. So getting a dent or scratch right where you want it is difficult, getting an image like a decal is nearly impossible - or will still require unwrapping UVs and a good ol' fashioned texture. So basically procedural textures are really good if you have a repeating natural pattern such as landscapes, dirt, rock, metal, wood, cement, but not for highly controlled images/decals.

If you need your model to deform, you need to use refP or whatever the Blender equivalent is (relatively new to Blender myself.) Essentially, because you are using vertex positions as the coordinates (world space or object space) instead of UVs, if the vertex positions change or morph, your texture will swim unless you are using a static reference position/frame as your texture coordinate.

So moral of the story, if you have a deforming object or an object which needs a high amount of control and or decals/images, you are stuck with UV unwrapping. Honestly UV mapping is relatively painless in Blender with their seams. I prefer this method to all other solutions I have seen.

I know Disney came up with some form of mapping which made it so you don't have to unwrap or mess with UVs called Ptex, you just paint directly on the faces and each face stores its own image map of sorts (texels). But Blender obviously does not have that in their toolset. Here's the reference on that:
http://ptex.us/


The Bug team resolved it. Apparently the Viewport was not updating.
I had to install the new graphics card drivers and it started working fine.


How come when I subdivide an edge, it only continues to subdivide one side?

It's because the face on the right is already subdivided, and so is the edge between them. You should have subdivide them both at the same time.

You could fix this by selecting all the vertical edges between the faces and rip them (shortcut v). Then remove excess verts (select them and x -> Dissolve Vertices) on the face you're trying to subdivide. Subdivide the face. The verts on the right should allign. Now you have duplicated vertices in that region. Remove them by selecting all vers in the region (you'll probably have to turn on X-ray (alt+Z) to reach the duplicates) using Merge by Distance.


The reason that function does not come in the OSL Language Specification, it because 'noise_turbulence' is in fact a function done in OSL, and not hard coded into the OSL source.

It's located in the 'node_texture.h' (along with the voronoi function), and it can be found in the \blender\2.XX\scripts\addons\cycles\shader\ folder.


It's a bit hard to tell what you want to do, but It sounds like you want to make a round "border". In that case, Beveling is the tool for the job.
Select an edge that you need to round, and press CtrlB. Move your mouse to control the depth of the bevel, and scroll to adjust the segments of the bevel, sort of like its resolution. There are a lot of settings that you can change. You can even bevel multiple edges at the same time by selecting them all and doing the same thing. Additionally, there is a bevel modifier that can bevel every single edge.


How can I have multiple separate texture maps for separate objects? Is it possible?

Yes, it's possible. If you have the wings and ears in a separate object, just create a new material, and select there the image texture you want.
The relationship is the following: Object → Mesh → Material → UVMap → Image Texture.

A mesh can have more than 1 material. In the Edit mode you can select faces and assign them to a material in the material tab.

In the Image Editor you can select the texture images to inspect them or paint on them.

In the Texture Editor, the UV map and the texture are specified in the Texture Slot settings. Blender can read this pair from the material or you can specify the there. This defines on which image and where the pixels go when you paint on the 3D model, and vice versa.

In the Shader Editor you can define with nodes the UV Map and the Image Texture that a material uses.

And in the Object Data Properties > UV maps you can select the active (default) UV map for the viewport and for the render.


How to get a list of edges of current face in bpy

Standard API
The active face's index is accessible in the standard API (bpy) like:
me.polygons.active

To get the actual polygon, you do:
me.polygons[me.polygons.active]

Note that the index is 0 (first polygons) even if there's no face at all, and it's independent from vertex and edge selection (a face can be active without its edges or vertices being selected).
There's no direct access for a face's edges, you can create a dictionary from the edge_keys however:
import bpy

ob = bpy.context.object

if ob.type != 'MESH':
    raise TypeError("Active object is not a Mesh")

# Get editmode changes
ob.update_from_editmode()

me = ob.data

if len(me.polygons) < 1:
    raise ValueError("Mesh has no faces")

# Build lookup dictionary for edge keys to edges
edges = me.edges
face_edge_map = {ek: edges[i] for i, ek in enumerate(me.edge_keys)}

# Get active face by index
face = me.polygons[me.polygons.active]

selected = "selected"
not_selected = " ".join(("NOT", selected))

for ek in face.edge_keys:
    edge = face_edge_map[ek]
    print("%12s - %r" % ((selected if edge.select else not_selected), edge))

You can also do without such lookup dictionary, may use less memory and perform better, 'since there's just one face we need to find the edges of:
for ek in face.edge_keys:
    edge = me.edges[me.edge_keys.index(ek)]

Bmesh module
You can access the edges directly using the bmesh module (for edge in face.edges):
import bpy
import bmesh

ob = bpy.context.object

if ob.type != 'MESH':
    raise TypeError("Active object is not a Mesh")

me = ob.data

if me.is_editmode:
    # Gain direct access to the mesh
    bm = bmesh.from_edit_mesh(me)
else:
    # Create a bmesh from mesh
    # (won't affect mesh, unless explicitly written back)
    bm = bmesh.new()
    bm.from_mesh(me)

# Get active face
face = bm.faces.active

selected = "selected"
not_selected = " ".join(("NOT", selected))

for edge in face.edges:
    print("%12s - bm.edges[%i]" % ((selected if edge.select else not_selected), edge.index))

# No need to do anything here if you haven't changed the (b)mesh
# Otherwise, flush changes from wrapped bmesh / write back to mesh
"""
if me.is_editmode:
    bmesh.update_edit_mesh(me)
else:
    bm.to_mesh(me)
    me.update()

bm.free()
del bm
"""


filling a polygon with holes in it with one single face

First select the verts and make the faces.

Next select the faces and press X and select dissolve faces. Do it part by part

But there is a limit of amount you can merge.


How do I import a minecraft rig into my scene?

You can also append Groups. So if you first Group all your parts CtrlG and name them you will then be able to navigate to this Group using the file browser when you Append.

Immediately after you create a Group you will be given a chance to name it in the Operator Panel on the left side of your 3D Viewport. If you don't see your Tool Shelf which contains the Operator Panel, you probably just need to press T while your cursor is inside the 3D Viewport to make it appear.

If you later need to browse your groups, you can do it in the Outliner. Double-clicking on the Group's name will allow you to rename it.

To see if an object is in a Group, or to add it to or remove it from a Group, you can go to the Object Context to manage this. You can rename groups from here as well.


Project image on uv sphere (for pool balls)

Using the Cycles Render Engine.

Create a UV Sphere > Shift +”A” > Choose “Mesh” > “Sphere” from the drop down menu.

While still in Object Mode > Shading > Smooth from the Tool Bar (Press “T” to toggle it on/off). Also press CTRL + “A” and apply the Scale. (You can also add a Subdivision Surface Modifier).

In the Materials Tab create a new material.

In the Node Editor create your node set up. Including your image texture with an Alpha channel. I used a .PNG with an alpha channel image file.

EDIT:
I realized the the stripe (purple area)did not have any gloss so I've added an additional node set up for that.

Also I took out some roughness in the Gloss Nodes / Added  slight blur to the Image Texture / Added a slight bit of yellow and red to the white part of the ball.

Go into UV Editing Mode press TAB to go into Edit Mode and select all > Press “U” and select “Sphere Projection” from the drop down menu.

Select “Texture” and you will be able to see a preview of your texture.

If the texture is stretched while still in edit mode and your cursor in the UV Editing window adjust the “X” scale of the UV Map scale by pressing “S” then “X”.

In this example in order to avoid a gap in the image texture on the back of the Sphere > in the Image Editor scale the UV Map down to fit the Texture.


The glow simply comes from a lamp you let inside the head, lighting up strongly everything inside and bleeding outside. Delete that lamp and you'll be fine.


Sorry, this is a known bug, a regression.  Issue #425 details it, and a fix is in the works in #506.  Sometime in the next few days it should start working again, after that PR gets merged.

Also, even after the missing alpha channel gets fixed, you'll still have to specifically enable blending mode per-material.  This is done in the "Settings" panel of an Eevee material, "Blend Mode" should be set to "Alpha Blend".


Your End Clip value (in the middle right of your screenshot) is extremely high.

Computers have trouble calculating wide ranges of floating point (decimal) numbers with extreme precision and often end up with slightly inaccurate results. If you narrow down the range it has to calculate (by decreasing the End Clip), those artifacts will disappear.


How to animate a curve/circle for a tank

If the tracks are arrayed along the curve, then keyframing the location of the track object should work. It's probably along the X axis.


try this:

enable dyntopo, then in the options bar above smooth shading, enable relative detail, what relative detail does is that no matter how much zoomed in or out you are, the size of your strokes will be relative only to what you set in the size options of your brush.

next zoom very close to the part of the abdomen that you want to smooth, and smooth it with the correct sized brush, in theory, that should work.

it should also be noted that the more polygons you have in there, the more gentle the smoothing will be, you can read more here:

smooth brush is destroying my model,what is happening?[SOLVED]

sources for my claim:https://www.youtube.com/watch?v=tZnUgt659oI   [at the 14:15 minute mark]

hope it works.


Instant Way To Set Objects' Distance In Circular Pattern

Assuming all the vanes are separate objects, and you're in Object Mode..

The scaling of the center points isn't working because they are all already at 0.

Select all of the objects, and hit ShiftCtrlAltC > 'Origin to Geometry'.

The scaling of the center points should now have an effect.
If you need the slight spiraling effect in the second picture, then. still manipulating center points only, rotate the objects in their common plane, about their common center.


You can do it using Live Unwrap and pinning vertices of the islands.

First select one UV island and hit V button to pin all the vertices, then select and pin one vertex in the center of the second island.

Then remove UV seam in the place where the islands should connect.

Change the mode to Live Unwrap.

And grab the center pinned vertex of the island and move it until you have a desired result.


How to attach colors (e.g., gradient color) to fluid particles

The answer depends on how much control you want to have over the color. In Cycles you can use the Geometry node's Position output as a factor between two colors or two shaders, and this will give you a variation between them.

If you want control over the angle you can then route that Position output into a Normal node and connect the Dot output into the Factor of the two colors - rotate the sphere to change the angle.

If you want it to be driven by the distance from an Empty then look into Drivers.

And finally, as another possibility for coloring/texturing liquids you might look into how to create matcap materials in Cycles.


You can use LoopTools add-on, turn it on it the User Preferences:

After it select outer rim and press W > LoopTools > Circle.


How to create 2 distinct objects from a single object with 2 Vertex Groups? (python)

Dupe n Delete

Similarly to another answer re materials and "normalizing"  material slots (removing unused), can use a default dictionary with a list of  the vertices of each vertex group, then remove others from from a dupe for each group.

Ultimately this would be better if could split using bmesh, but as of now cannot set a split target to another mesh or bmesh instance.

Note this will split based on vertex group.  Vertices that are members of more than one group will be in each split off object. Vertices not assigned to any group will not be split off into new object.

Using copy on both the object and the mesh brings along all data.

import bpy
from collections import defaultdict
import bmesh

context = bpy.context

ob = context.object
me = ob.data
vgs = ob.vertex_groups[:]
col = context.collection
rg = defaultdict(set)

for v in me.vertices:
    for g in v.groups:
        rg[vgs[g.group]].add(v.index)

bm = bmesh.new()
all_verts = set(range(len(me.vertices)))

for vg, verts in rg.items():
    if not verts:
        continue #  no empty vg mesh
    oc = ob.copy()
    oc.name = vg.name
    me = oc.data = oc.data.copy()
    bm.from_mesh(me)
    bm.verts.ensure_lookup_table()
    bmesh.ops.delete(bm,
        geom=list(bm.verts[i] for i in (all_verts - verts)),
        context='VERTS',
        )
    bm.to_mesh(me)
    bm.clear()
    for g in oc.vertex_groups:
        if g.name != vg.name:
            oc.vertex_groups.remove(g)
    col.objects.link(oc)

Note I haven't bothered to remove materials, as mentioned this is similar to a previous script used in one of your answers, to test what materials are on a face and remove.

Alternatively, instead of copying a new mesh each time, copy the bmesh and write to a new mesh.  Once again will have to deal with materials, using all faces left after delete operator, to check which materials are assigned to faces of a particular vertex group.

See Delete all materials that aren't assigned to a face?

If the material is data (mesh) linked, can append to the Mesh.materials collection instead of using the slot operators.

import bpy
from collections import defaultdict
import bmesh

context = bpy.context

ob = context.object
me = ob.data
vgs = ob.vertex_groups[:]
col = context.collection
rg = defaultdict(set)

for v in me.vertices:
    for g in v.groups:
        rg[vgs[g.group]].add(v.index)

bm = bmesh.new()
all_verts = set(range(len(me.vertices)))
bm.from_mesh(me)
for vg, verts in rg.items():
    if not verts:
        continue #  no empty vg mesh
    oc = ob.copy()
    oc.name = vg.name
    oc.data = bpy.data.meshes.new(vg.name)
    bmc = bm.copy()
    bmc.verts.ensure_lookup_table()
    bmesh.ops.delete(bmc,
        geom=list(bmc.verts[i] for i in (all_verts - verts)),
        context='VERTS',
        )
    bmc.to_mesh(oc.data)
    bmc.free()
    for g in oc.vertex_groups:
        if g.name != vg.name:
            oc.vertex_groups.remove(g)
    col.objects.link(oc)


In the UV editor you can pin selected vertices from the UV editor menu UV -> Pin or press the P key.

You can also unpin them from the same menu or Alt + P.

There are also other ways to give finer control, for example you can create seams in your UV map effectively cutting it into parts that unwrap nicely.

Too long a discussion for here, but in mesh edit mode you can mark edges as seams, then when you unwrap it will be more forgiving.

You would still need to pin vertices if unwrapping a second time, but gives you more options.


Is there a way of updating blender with all of my files contained?

Your .blend files will still be accessible. Blender is backwards compatible way past 2.75.


Object Mode in 2D Animation Colors Disappeared

Your 3D view is set to Wireframe mode. You can change it to any other mode (Solid, Material Preview, and Rendered) in the topright of the editor. You can also use the shortcut SHIFT + Z to toggle between Solid / Wireframe mode.


How to make textures certain size and constant between objects?

A texture with a texture coordinate node that is applied to different objects that have all had their scale applied should appear at the same scale across the .blend file. You can use the texture coordinate node to alter the texture to the right scale for your world.
Good luck!


Bake a Displacement map from a cylinder object

Since you're baking scalar displacement from a cylinder, the set-up isn't too bad.. the illustration below shows the rope shaded with its height-map-to-cylinder.

Assuming your rope has its object Z axis straight up its core, with this tree, you put the radial distance from its surface to an (imaginary) cylinder, in this case with radius of 0.65, straight into the strength of a pure-white emission shader.
Put the UV unwrapped low-poly cylinder in the same location as the rope, at the world origin, and bake the emission from selected (the rope), to active (the cylinder) Bake into a floating-point format, 16 bits will probably do.
Then the baked map can drive a Displacement shader for the cylinder:

The cylinder, displaced, is on the left, next to its baked height-map, and the original rope on the right.
It is possible to bake Vector Displacement .. it gets a bit more complicated, with an intermediate map of World-Space positions baked for the Hi-res object, from which positions of the Lo-res object are then subtracted, and baked again, into an exactly corresponding UV map.


How to approach the modeling of duct work, piping, wiring?

To create basic connections you can use any or a combination of the following 3 Techniques:

Pipe Joints, part of the Mesh > Extra Objects Add-on

Open the user preferences window (Ctrl+Alt+U in 2.79, or Edit>Preferences in 2.8) Navigate to the add-ons section.
Enable the Add Mesh: Extra Objects Add-on

You'll have a new item on the add menu to create pipe joints.

UPDATE:
As of version 2.79 and 2.8 Pipe Joints are accessible on Add>Mesh>Mechanical>Pipe Joints.

At creation time, each of the tools have a different set of options to refine the angle, diameter, etc. (if the tool tab is not open press T to make it visible or press F6
Keep in mind that once you make any further transformations, those original parameters cannot be reset (read this).

Connect different segments.

To connect two cylinder segments that have the same number of vertices, select the end edges and use Bridge Edge Loops, and adjust number of cut and smoothness.

Curves

To create large sections and more intricate paths , create a base shape for the pipe.

And use it as a Bevel object on a curve:

To deal with sharp turns adjust the control points by pressing B and selecting Vector. The width of the curve can then be ajusted by changing the radius of a control point.


Wrong zorder in viewport but ok in cycles render

@scurest was right! All that was needed was to set blend mode in material properties:
Material properties -> Viewport display -> Settings -> Blend mode = opaque


Why does parenting Heel IK to Thigh Bone cause jittering in right leg but not left leg?

To have an IK controller which is child of a bone which is part of the IK chain must be considered a rigging error, because it creates a circular dedendency, leading to unpredictable behaviours (and jitterings).

Instead you can create a new bone (which I called "scaler") that will be parent of the thigh and the HeelIK. In my picture scaling the scaler bone caused the whole left leg to scale proportionally, maintaining full functionality of the IK leg chain, without any need of constraints.


Use "object" output from "texture coordinates" node:

Then to tune the texture position and scale, you can use the vector "mapping" node.
Also turn the image boundings to "clip" if you don't want it to repeat over the plane surface.

Alternatively, you can use another object as position, scale and rotation, as indicated here.

A link to the documentation.

Object
Uses an object as a source for coordinates. Often used with an empty,
this is an easy way to place a small image at a given point on
the object. This object can also be animated, to move a texture around
or through a surface.


Are there faster ways to switch pose modes? Am I missing something?

Personally when I do weight painting (or any rigged mesh work really), I split and pin the Pose/Rest controls in their own pane at the far bottom right, with bone layers and IK toggles in the same pin. That way it's just a single click to get to rest pose and back no matter what objects I have selected.
In addition, this workflow might help out a bit:

Object Mode
Select Rig
Shift-select Mesh object(s)
Weight Paint Mode.

This should allow you to select any bone in weight paint mode, pose them and paint the related vertex weights in real time, with the armature panel pinned it makes it a lot easier to do operations that require rest pose.


Blender 2.8 eevee render light too bright than cycle

if you go into the settings of your light source you will see that the settings are different in EEVEE. changing the settings in EEVEE does not change how the light looks in cycles and vice versa. So you can tweak the settings to get the same ish result across render engines.


As @metaphor_set already said, you cannot UV unwrap this high poly model without having a huge headache. That's why you need to do something called retopology, this is when you wrap a low poly mesh on top of the high poly mesh to get a low poly copy of the high poly mesh. There are many tools and add-ons that will make your life easier.

First I explain how you can do it without add-ons:

Add a new object with a single vertex
In the modifer tab add the subdivision surface modifier and the shrink wrap modifier
Enter edit mode, select the vertex and enable "snap to" (the magnet) and select faces

Now if you extrude the vertex over the object you will see it snaps to the surface of the object. With some tricks you can get very clean and easy to handle and animate topology

But if you want to have it even easier (I recommend) use retopoflow, an addon that basically does all the settings for you and has many tools for easy retopology. Tho I will not go  further here as there are many great tutorials on it already


Accessing bpy.context gives a '_RestrictContext' warning, how to fix this?

Short answer: don't access blendfile data when an add-on loads.

This is an intentional limitation with add-on loading which was added because it caused so many errors with inexperienced developers not properly understanding how data should be accessed, in practice it's almost never what you really want, and if for some obscure reason it is, you better not do it in an add-on (just run a script directly).

The kind of bug this caused was:

Add-on loads, sets the active scene. eg: scene = bpy.context.scene
User changes active scene or loads another blend file.
User tries to use the add-on, which starts using the previous scene.

Enabling an add-on should always give the same results no matter what Blend file you have open.

Instead, your tools should read from the context when they are activated by the user.


Can loopcuts be made when Blender is in background with the "-b" option?

It's actually quite simple:
You can't use operators in background mode.

When Blender is in background mode or you use Blender as a Python module, then the context does not work as usual, because it doesn't exist. There has to be a 3D viewport etc. for the context to work but all of those things don't exist in background mode.

The solution is to use the internal functions of the operator you are trying to use. But if this operator does not use internal functions you are out of luck.

I got this info from a youtube video where the blender devs answered questions (at about 11 minutes in).


i'm a beginner following blender guru's donut tutorial trying to make the icing but when i try to pull down one vertex other vertices spasm out

You might have proportional editing on
try pressing O to turn it off.
(it's also an icon at the top of the viewpoint - a circle with a dot in it.)


How to store a list or an array with python so its global available?

Two methods:

Method 1: python way

import bpy

arr = ["string1", "string2"]

class ClassName(bpy.types.Operator):

    def execute(self, context):
        for str in arr:
        print(str)

    return {'FINISHED'}

classes = (
    ClassName,
)

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

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

if __name__ == "__main__":
    register()

Method 2: Blender way

import bpy

class Variables(bpy.types.PropertyGroup):
    string1: bpy.props.StringProperty(name="a string")
    string2: bpy.props.StringProperty(name="another string", default="default value")

class ClassName(bpy.types.Operator):

    def execute(self, context):
        bpy.context.scene.var.string1 = "Hello World"
        print(bpy.context.scene.var.string1)
        print(bpy.context.scene.var.string2)

    return {'FINISHED'}

classes = (
    ClassName,
    Variables,
)

def register():
    from bpy.utils import register_class
    for cls in classes:
        register_class(cls)
    bpy.types.Scene.var = bpy.props.PointerProperty(type=Variables)

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

if __name__ == "__main__":
    register()

learnt from: Godot Game Tools

edit:
this is how you can access a variable in blender from anywhere. I've used GodotGameTools as an example and also highlighted what it should have been if you used my code


Align and snap one object to a slanted and rotated other object

Using the same snapping setting as in your question, Blender will snap applying the smallest rotation possible.

So you can do that in two steps:

Place it in a first side
The grab it to another side

Similar to this question.

If you want the handle to be in another direction, rotate it first (for instance 90 degrees around Z) and snap again.


How can I attack to different portions of the screen?

After trying to solve this problem by myself for almost my entire blender career, I stumbled across a solution. This is a no python approach.

The basic idea is to have an empty, offset from the player, and "slow parented" to the player that two specialized bones track toward. By animating a normal downward chopping motion, as well as the influence value of the track-to bone constraint, we can cause the player to chop across in his upper arc.
This comes at the expense of variation as the player can't chop up from a downward position or thrust.

Step 1

For you basic setup, you will need to create three extra bones: one for each shoulder, and one that control those two so they don't point inward. You will also need to create a "plain axis" empty that the control bone tracks to.
Add a track to bone constraint on the control bone and set it's target as the empty, which will need a slight upward and forward offset (see figure 1). Parent it to the player and give it some slow parent value.

figure 1

Step 2

Animate your chopping motion; it should provide all the functionality you'll need. note: do not animate the shoulder bones as this might interfere with the essential tracking.
Also animate the influence of the track-to constraint, starting at 1, staying at 1 until shortly before the end, and then moving to 0.

Step 3

Switch to the logic editor and add a mouse-click sensor, an AND controller, and a Action actuator, set to play mode and with the chopping/turning of the shoulders action.

Viola! looks a bit awkward, but hey, that's the cost of beheading people.

(edit) you will also need a run-armature actuator


Object appears as orange points in object mode, but looks fine in edit mode

Your object has a halo material assigned to it.

change it to surface.

(By the way you also have issues with overlapping surfaces causing z-fighting. Fix it by removing doubles. See this answer: https://blender.stackexchange.com/a/21218/1853)


BGE and MakeHuman:Why the mesh is not displayed correctly?

Actually the file is in great shape. All you had to do is set the Shading mode to GLSL. It's currently set to Multitexture, which is an older, and less powerful system.

As an aside, the purple texture you see is the normal map on the character, which isn't supported in Multitexture mode.


So I've got two problems with my armature

A quick and easy fix of all your problems, try Rigify. It will give you complete custom controls and you may assign bones to mesh With automatic weight.

Enable Add on

Add Armature

Adjust bones according to your character, Ctrl + A and apply Location, Rotation and scale.

Hit Generate button under Rig tab in right side bar.

Select mesh, select custom shapes (in this order) Hit Ctrl + P and select With automatic weight.

I hope it will make your life easy, Good luck :)


Pivot point is a very important thing to learn. Also, yes, median is what you are looking for.


Cutting a "channel" halfway into a shape?

You can use knife project.

By hiding the faces you don't want to cut, you can control which faces get cut with the shape and which are left uncut.

Example:

With the shape object selected,  Shift-Select the object you want to cut and enter edit mode:

Select the bottom faces (the ones you want to preserve with no cuts) and Hide them (H)

Then in top orthogonal view press the Space Bar and type Knife Project. Enable Cut Through** and then unhide the hidden faces (AltH)


In order to edit individual buildings you will have to edit the actual models in the "buildings" collection, "Building1", "Building2", etc. The buildings appearing on the emitter plane are merely linked duplicates from the actual models, and not editable on the go.

To hide the base plane object, you have to go in the particle settings and uncheck "show emitter" from rendering or/and from the viewport, depending on what you want :


It sounds like you accidentally turned on orthographic view.  To turn it off, just click on that little grid icon under the camera icon on the right of the 3D view.  That button toggles the view between perspective where things further away from the camera seem smaller and orthographic mode where everything is the same size no matter how far from the camera it is.
Orthographic mode can be useful in front, side, and top views because it helps everything line up more nicely (in fact, blender automatically switches to orthographic mode when you click on top, bottom, front, back, left, or right views, but then switches out of it when you start rotating the view).  But to turn it back to perspective mode, just click on that grid icon.
As for the rotating around the 3D cursor, you could try going into Edit -> Preferences -> Navigation -> Orbit & Pan and then check the Orbit Around Selection option.  That will make it rotate around the selected object.


Blender models adding extra faces in Element 3d

Looks like you have quite a few complex ngons in your model. The OBJ exporter may be getting confused. Before exporting to OBJ, in edit mode, select all the faces (or at least the ones giving you trouble), and hit Ctrl+T, which is 'triangulate faces'. This will convert all your quads and ngons into triangles.

Once converted, ensure those strange edges have not reappeared (and fix them if they do), then export to OBJ once again.


How to place cubes evenly around a hexagon?

An quick way to do so would be DupliVerts.

Parent the cube to your hexagon

In object settings of the hexagon set duplication to verts

Enable rotation
Now you have your corner stones:

Copy your cube and hexagon and rotate them to get the stones in between

The original cube in the middle will not show up in a render.
But you can get rid of it by making the Duply Verts real Ctrl | Cmd+Shift+A.


Beginner's mistake here.

I've hidden the domain on render because it was first showing like a solid.
That was not the right thing to do.

Comparing with QuickSmoke, I found that changing the density of domain's material from 1 to 0 made exactly what I wanted.


As stated by the Blender manual's section about the Grid fill command:

  Grid Fill uses a pair of connected edge-loops to fill in a grid that
  follows the surrounding geometry.

Despite this, using the vertices indices and the picking order, the operator is capable to guess the user intention even if he defines the whole boundary, but it still needs to guess the right offset's and span's values because you are not providing edgeloops but only some vertices and it has to guess which gruops of them belong to an edgeloop.

See in this sequence how the operator behaves differently on same geometry simply by picking another vertex to complete the selection.


How can I get rid of a Blender element I cannot select?

Check to see if you may have added a modifier to your object. Some modifiers, for example, the hook modifier, add empties that are used in the function of the modifier that show in object mode, but which cannot be selected in edit mode.


Adjacent planes rendered in very different colors?

I think this is due only to the HDRI lighting. I tried with a different, more uniform world lighting and all planes are shaded in a more "uniform" way.

I'm not an expert, but even if the two plane's normal are close, or identical, the planes position is not the same (and cannot be the same) respect to every HDRI pixel lighting the scene.

Since this is not a uniform light color, and because a single flat plane can "reflect" just one shade, this is to be taken into account. Probably a real object like that would appear the same.

As said, normals smoothing can't help you here, because all square meshes are separate: if you can join them to appear as a single plane (although with those separating "cylinders" all above them) maybe, but I'm not sure it would give desired results anyway.

Btw, you have some plane with inverted normals, here and there...


Select logo go to edit mode press W and Remove doubles.

Then set the Boolean modifier to Difference.


Add different materials to different parts of a mesh?

You need to be in edit mode.

Select the part of the mesh you want to add the material to:

Click the "+" icon on the right side of "material" shown in the image below to create a new material.

Let's give the new material a green color.

Click the Assign button in the Materials tab under the list of materials:

(for older versions)

And you're done!

*_Note that when using this method there can be a sharp contrast between the two materials._


How can i avoid making doubles when using subdivision modifier?

Doubles are generally a bad thing, as they are difficult to properly select, can cause artefacts, prevent cleaning whole model with Remove Doubles and can cause accidental unwanted merge when moving things with auto merge on. Sliding the loopcut just a bit before the end instead is totally fine way to do that, i really don't see what incorrect you see in that.


Assigning material to every second face via python

I almost always look for hacks when doing simple tests like these (half of the time the function you spend hours on, Blender has the functionality tucked away in some menu) so if your use case is similar meshes I would probably use bpy.ops.mesh.select_nth(offset=1) to get the selections in a checkered pattern.

import bpy

# get the object
ob = bpy.context.active_object

# get the mesh
mesh = ob.data

# create a list with all faces
face_list = [face for face in mesh.polygons]

# select all faces for offset operator
for face in face_list:
    face.select = True

# toggle to edit mode
bpy.ops.object.mode_set(mode='EDIT')

# make sure face select mode is enabled
bpy.context.tool_settings.mesh_select_mode = [False, False, True]

# select every second face
bpy.ops.mesh.select_nth(offset=1)

# use second material slot
ob.active_material_index = 1

# assign the material
bpy.ops.object.material_slot_assign()

# toggle to object mode
bpy.ops.object.mode_set(mode='OBJECT')

To get the inner vertex, select the outer edges in edge select and then switch to vertex select and invert the selection. It's far from elegant but should work for the example you are using


You can append the path to your script

import bpy, sys
sys.path.append('//myscript.py')
import myscript


The easiest way to do it is to:

Begin with a cube that you subdivide twice (smooth mode).
Cut off a hole on the bottom, select the hole, flatten it on the Z axis (SZ0.
Make it a circle ShiftAltS.
Extrude down to make the vertical cylinder.
Do the exact same operation for the horizontal extrusion.
Add some edge loops close to the edges you want to sharp.


You need to bevel Edges, not faces.

How to:
1) Remove unnecessary geometry (to prevent ugly topology later)
2) Bevel the edges
3) Finish your geometry
4) You're done.

1) Delete faces
Remove unnecessary faces with Delete > Faces, to prevent n-gons.

2) Bevel edges
Select your edges and bevel them.
Adjust width and number of segments as you need.

3) Finish your mesh.
To create a new face Press F or go to Vertex > New face from vertices
Keep quads where you can.
Add some new edges like I did :).

4) You're done.
Result with a Bevel modifier and a Subdivision modifier on top.


Object properties for just a specific object with python?

Your property is being created for the scenes, when you want to create it for the objects. So this:

bpy.types.Scene.IntCheckpoint

needs to be changed to this:

bpy.types.Object.IntCheckpoint

And then in your panel you'll change this:

col.prop(scene, "IntCheckpoint")

to this:

col.prop(obj, "IntCheckpoint")

So to create a property specific to a type, you have to use that type in your property declaration.


Your problem has 2 origins: the simpler is that the subsurf modifier should be after (down) the mirror modifier. The harder is that the mirror modifier uses as mirror pivot point the origin of the object, and your mesh is not in line with the axis. You can  solve the issue in this way:
switch to top ortographic view (toggle Numpad7 and 5); rotate your mesh until is quite aligned with the axis; in edit mode select the center line and scale it on the x axis by 0 (S,X, 0, Enter); put the cursor aligned with this edge loop (Shift S, cursor to selected, then - in object mode - set origin to 3D cursor); select the edge loop next to the central one and dissolve it (X, dissolve edges).
It's always a good practice to mantain the origin of the object in the center of the scene during the modelling phase, then move objects to the desired position.


This is a common issue in automatic weighting. There is no "one click solution", so I can only propose some tips to improve your weighting skills:

1 - put your subsurf modifier after (down) the armature modifier and enable two little buttons that let you see the changes you'll make in edit mode and weight painting mode.

2 - in edit mode, if you select one vertex you can read the weight assigned to every bone - vertex group in the "N" panel, vertex weight tab.

3 - in edit mode select some vertices (tipically some edge rings), then switch to weight paint mode and click the red highlited button: your weight painting will apply only to the selected vertices

4 - if you select some vertices you can directly assign a weight in the vertex properties, vertex group tab.

Always consider that every vertex is moved by all the bones to which a weight is assigned.

Hope it helps!


Use particle location as driver variable

The easiest option is the one Leander suggested; installing the animation nodes addon, then using a node setup that looks like this (the highlighted part makes it so you can animate particles seperately):


How to access per-face UV assignment via API

Found it. This code prints the name of the TexFace image for each face of the mesh:

import bpy

object = bpy.context.object
mesh = object.data

for face in mesh.uv_textures['UVMap'].data:
    print(face.image.name)


If someone has a similar problem. Rolling back the drivers of my graphic card has helped.


Non Manifold object ? why hole is not print with 3D Printer?

Some normals are flipped, so go in Edit mode, select all and recalculate the normals with ctrlN


You can try using the Filmic Blender set of Luts and OCIO configs that @Troy_s has been working on, to render images with a much wider dynamic range.
Read this answer for a detailed description on how it works.

https://blender.stackexchange.com/a/46940/1853


Changing default Blend Mode settings for materials

You may not like the answer, but I'm afraid the way you possibly imagine it is not meaningful to implement. Basically there are two ways to expand Blender programmatically: Either with an add-on (via pyhton API) or by hacking the C++ files. The latter means that you have to compile your own version of Blender every time a new official update appears. Gone are the days when you simply pressed the download button and installed it. That also means that you have to mess around with things like compiler choice and dependency management (which can be very painfull in C environments). If you are not familiar with it, then I would rather advise against this.
The far more convenient way would be to write a small addon and use the Pyhton API provided for this use-cases. However, this has the disadvantage that you have to press your own button for your adapted material, similar to what you are used to from other addons. But, as long as the Pyhton API doesn't change much, you can still download and install new Blender versions as usual and nothing will break.
Take a look at the following script and run it in Blender to test whether you would like to go the path of an add-on. If you need further help with the adaptation, feel free to ask me, but in principle you only have to expand or add a few lines to adapt it to your needs.
You can easily test it by pressing "Shift - F11", creating a new file and inserting the script. Then press the play button. Then, as with many other add-ons, another menu should be available in which you can create your material with a mouse-click (don't forget to select a mesh). I have tested the script but it is far from "bullet-proof" so do not test it in your project that you have to hand in tomorrow ;). Hope that helps.

Useful resources:
https://www.youtube.com/watch?v=eo7UjKFiagk
https://docs.blender.org/api/2.90/bpy.types.Material.html#bpy.types.Material.blend_method
https://docs.blender.org/api/2.90/info_quickstart.html

import bpy

class ADDONNAME_PT_main_panel(bpy.types.Panel):

    bl_label = "Add Hashed Material Panel"
    bl_idname = "MYADDON_PT_main_panel"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'UI'
    bl_category = 'My Default Material'

    def draw(self, context):
        layout = self.layout
        layout.operator("addonname.addbasic_operator")

class ADDONNAME_OT_add_basic(bpy.types.Operator):
    bl_label = "Add My Material"
    bl_idname = "addonname.addbasic_operator"

    def execute(self, context):

        material_basic = bpy.data.materials.new(name= "Basic")
        material_basic.use_nodes = True

        material_basic.blend_method = "HASHED"
        material_basic.shadow_method = "HASHED"

        bpy.context.object.active_material = material_basic

        return {'FINISHED'}

    def invoke(self, context, event):
        return context.window_manager.invoke_props_dialog(self)

classes = [ADDONNAME_PT_main_panel, ADDONNAME_OT_add_basic]

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

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

if __name__ == "__main__":
    register()


What about doing it like this ?

import bpy

class MyDialog(bpy.types.Operator):

    bl_idname = "tools.mydialog"
    bl_label = "My Dialog"

    string_prop = bpy.props.StringProperty(name="String Prop")

    def invoke(self, context, event):
        return context.window_manager.invoke_props_dialog(self)

    def execute(self, context):
        # Whatsoever needs to be done...
        return {'FINISHED'}

def my_menu_addition(self, context):
    self.layout.operator(MyDialog.bl_idname)

if __name__ == "__main__":

    bpy.utils.register_class(MyDialog)
    bpy.types.INFO_MT_file.append(my_menu_addition)


Trampoline like effect using cloth modifier?

(Blend file below)
Particles and cloth reacting to each other - (bouncing is adjustable)
If you're dealing with just a single object, either limit the emitter to a single particle or simply animate/keyframe the object itself to follow the cloth up and down. (Bezier interpolation works best with cloth)

The cloth is pinned by it's outer vertices.  When played, and with it's (cloth) structure slider set appropriately, gravity will make it sag, retract, sag etc at the center until finally coming to rest.
Once this is working as required, the cloth's motions can be 'Baked as Shapekeys' in the Modifier panel. (not the physics panel)
With that done, it's physics properties are lost and the cloth is ordinary mesh again but with shapekeys now stretching and unstretching it's vertices.
Add physics to this again but not as cloth, rather, just set it as a 'Collision' object this time so the particles will react to it as though it's hard ground which is sagging up and down.  It's sags and bounces will therefore take the particles up and down with it.
With the cloth now shapekeyed you have control over when the sags and retractions take place by setting shapekey values between zero & 1. (Geometry --> Shapekey tab, (press " i " to keyframe each)
As each subsequent sag would be less than the previous, set that shapekey value to less than 1.  If it's not to rise back to flat again, set the retraction shapekey values to something above zero.
Once the timing of the sags look normal, go into the Dopesheet and select all the shapekeys, then slide them left and right so the first sag coincides with the arrival of the first particles.  (See note below)
Because your shapekeyed mesh has been set as 'collision' object they won't (or shouldn't) go through it and will follow it up and down as it sags and retracts.
-===============-
A few points should be made here...
1.
When applying the cloth's sags as shapekeys, it's the most extended sag that get's recorded.  That's where the cloth will go down to when a shapekey value is set to 1.  Anything between 0 & 1 will sag the cloth to some point between fully sagged and fully retracted.
2.
Particle physics work on each particle's origin-point, not their mesh, meaning they usually half bury themselves into a collision object as a result.
3.
If you view from the side, you'll notice in this instance that the particles are not actually settling at the cloth but a significant distance above it.
There is an effective work-around that cures notes 2 & 3...
With the emulated cloth behaving as required and timed correctly, duplicate it and check that the copy doesn't have physics or cloth properties, but does inherit the original's shapekeys and therefore should be sagging and retracting in synch with the original.
Because it has no physics it's only animated scenery and not going to affect the particles.
Make the active cloth (collision object) invisible.
You can raise the (non-physic'd) duplicate so particles will actually sit in it's deepest sag and bounce up and down with it.
(For newbies, the invisible and real collision 'cloth' is still controlling their behavior)
-============-
Note -
It may be that the first few particles don't land in the cloth's center and therefore the first sag will appear to be self motivated.
The solution is to make a duplicate of the particle object (cube) in layer 2, move that to layer 1 and rescale it to the same size as the particles.
Animate this to fall down into the center of the sagged cloth and bounce up and down with it by making it follow the cloth's rises and falls. If that's too much bother, have it conveniently disappear behind the others after it's fall.


How do I transfer only single vertex groups between objects?

Select object where you'd like the vertex group to copy to. You don't need to create empty vertex group there as it will be added automatically, still it's possible to do for testing purposes.
With this object still selected,  Shift + RMB to select object which has original vertex group.
Choose Copy Vertex Group entry from drop-down menu. The thing is that you should select mesh with vertex group to be copied last.


Simple script for pasting node to every material. Can't figure out

I don't know exactly how to copy/paste nodes between materials, but this solution works anyway.

I suggest to have a reference to the image texture node you want to duplicate inside your blend file data. To do this, choose any material that will be used as source (srcmat in my example), and add the image texture node you want to duplicate in its node tree (set the image too). Assign a name to this node (mynode in my example) from the N sidebar.

This lines of codes will create a new texture image node for all the other materials assigned to the object, then assign the texture you set in mynode node and finally link the texture to the color input of the Principled shader node:

import bpy
from mathutils import *

# replace 'srcmat' with the name of your source material
# replace 'mynode' with the name of your image texture node
srcmat = bpy.data.materials['srcmat']
srctxtnodeimg = bpy.data.images[srcmat.node_tree.nodes['mynode'].image.name]

# select your object first
o = bpy.context.active_object

# create the same node on all the other materials
for i in range(len(o.material_slots)):
    o.active_material_index = i
    m = bpy.data.materials[o.active_material_index]

    if m.name != srcmat.name:

      mnodes = m.node_tree.nodes

      newnode = mnodes.new("ShaderNodeTexImage")
      newnode.image = srctxtnodeimg
      newnode.location = Vector((-100, 500))

      princshader = mnodes.get("Principled BSDF")
      m.node_tree.links.new(princshader.inputs[0], newnode.outputs[0])

P.s.: you can add other properties of the source node such as color space, interpolation or projection if you need. Moreover I assume that all your materials (created after import from Sketchup) use the Principled BSDF shader, which is (based on my experience) the default shader used by Blender in any situation (eg if you import a model).


How to make a camera rotate on the spot?

Select your camera
Set a Keyframe by pressing I and selecting Rotation
Then move some frames forward (by clicking in the Timeline at the bottom)
Now rotate the camera by pressing R+X+3+6+0 and apply by pressing Enter
(Press X twice if you want to rotate around a local axis instead)
Set another keyframe like in step 2

That's all. Note that the movement won't be linear by default. If you want a linear movement instead, you need to change the interpolation mode of the keyframes. For that, you can have a look at the second part of this answer.
Hope it helps :)


Can Grease Pencil 2.8 support transparent background

I solve the problem by using OT Animation Video Codec, then import to Photoshop with transparent background. But there is still another problem, I have set the display and hide some fields in grease pencil, but the video cannot display properly.


How make a character climb rocks and blocks in the BGE?

I've get a satisfatory answer to my problem working only in expressions and logick bricks.
In fact, I was searching a system that make me get a cube or anything to climb other object for after do the animations and etc.

Today i've found a way to allow me to do a wall climb with one cube to other object.

The way I use was:
Named any properties to my cube that is my personage.

Called a property "climbable" to the object that you want you personage climb.
link colision "obst" and property "parede" to the actuators edit object "supende" and property "escalaS" using the controller expression with "obst AND NOT parede"
link the sensors: Keyboard W and property "parede" to the actuator motion "cima"

explain:

colision "obst" is to test the colision between personage and object.
property "parede" is to verify true to the property "climbable" in the personage.
edit object named "suspende" is to suspend the dynamics. Actuator edit mode, set to dynamics -> suspend (that is the trick on newer blenders. Cause it turns any object into a static one with no colision rules).
property "escalaS" is to set property from persnagem to a climbable one (this do easy to me to treat the others problems.)
The actuator motion "cima" is to move up the actually static object.

Then you'll ask me: and to turn it dynamic again?
Do yours links in the better way you find and link actuators:

property climbable assign False and
edit object dynamics restore

These last 2 do the cube works like a personage or character again.
Now is time to work in the animations then throw in the cube and do my game.

I hope this helps anyone.

p.s.: I've used names like suspende, cima, parede and others no english cause i'm brazilian. And here we talk brazilian portuguese. If have any or many errors in this text correct me. I'll thank you.


Options for object creation are greyed out

You have to enable: Global Undo
For 2.8x and 2.9.
Edit > User preferences > System > Memory & Limits: Global Undo

For 2.79
You can do it in User Preferences (Ctrl+ Alt U), in "Editing" Tab.


Why does my cloth simulation bounce for a moment before settling down?

You are right with the idea of starting the simulation before the start of the animation so that the first rendered frame uses a stationary version of the cloth.

Note that this will have no effect on your render times, the simulation only needs to be baked once before you start rendering and the cached results are then used during render.


Setup an inverted pendulum simulation with BGE

I made a simple example in the game engine of a mouse controlled inverted pendulum. It answers only your question about the hinge, but maybe you can go from there.

The body block has a rigid body constraint, type hinge, target is the pole. The weight at the top is parented to the pole.

I'm sure it's not physically correct, but I had to change translation and rotation damping in the physics properties of the pole to have a chance at controlling the pendulum. I also reduced the mass of the pole.

If you'd like to have a look, here's the blend file:


How to flip without using mirror modifier

Select green object, press Shift+S and choose cursor to selected. Change pivot center for rotation/scaling to 3D cursor.Select yellow object (all meshes) and either press S,X -1 (to scale it by value of -1 on the X axis, which will cause to mirror the object to the other side) or CTRL+M,X (which will cause to mirror object to the other side)


Grease pencil 2.8 stroke placement problem

I just finded a workaround.

Go to Layers of Grease Pencil, and under the Relations drop menu you have to Parent the Layer to the Camera.

To predict better the draw radius I set up the grease pencil to draw with 3D Cursor and in Side (Y-Z) or Front (it depends). Remember that you have to place the cursor closer to the camera so it overlaps any other model in the scene.


Object cannot be selected and only appears in Object mode?

I think you accidentally hid it (pressed H key).
go to edit mode and unhide it by pressing AltH.


Viewport shader material is different from material preview

I got what I excepted by changing coloramp node


How to avoid operator `collection_instance_add`?

Just do all necessary steps

Create a new Empty object
Set instance_collection to the collection you want
Set instance_type to 'COLLECTION'
Link the resulting object to the place you want to have it in
(reference: Basic Object Operations Example)

source_collection = bpy.data.collections["the_name_of_the_collection_to_use"]
instance_obj = bpy.data.objects.new(
    name="my_new__obj_instance_name",
    object_data=None
)
instance_obj.instance_collection = source_collection
instance_obj.instance_type = 'COLLECTION'
parent_collection = bpy.context.view_layer.active_layer_collection
parent_collection.collection.objects.link(instance_obj)


In your Domain's object settings, Ray visibility channel, check the Camera option:

I don't know why you unchecked this, but this options basically determines whether or not the object is rendered in the camera's eyes. So you never uncheck this on something you want to see.

By the way, you may want to check that related question as well: Rendering Smoke in Cycles.


Geometry jitters while animated along path

Turns out, this IS in fact a floating point precision issue.  Not something to do with the math along the path, itself.  In an effort to keep my vehicle and camera near the world origin, I created a root object, parented my environment and path to it, then animated it's location to try to keep the vehicle near to 0,0,0.  It has helped a LOT!  Here is a video, outlining the solution and result: http://sean.novak.us/vid/help/jitterSolution.mp4


I connected colour to composite node directely, and there is a noise

This was rather a simple question. In the Post Processing tab, reducing Dither to 0 will solve this problem.

Hope this will help somebody.


That would be the Simple Deform > Taper modifier, which by default uses the object's own space, but can be set to use the origin and axes of any other object, typically an Empty.


You can't create actions with the BGE. Animations needs to be present in the blend, a linked blend, or loaded blend (via LibLoad).

Background

You used bpy - which is the API to Blender. Be aware Blender is only available when you run your game session embedded inside Blender. Typically you do not deliver Blender with your game.

When you run the game session embedded inside Blender creating an action, it is only present in Blender (-> bpy is talking with Blender, not with the BGE). The running game session will not know about it. Any change made by Blender will not be recognized by the game session, as everything is loaded already.

For better imagination:

Imagine your game session is a car the player is driving.
The BlenderPlayer is the factory that creates a new car from a blue print.
The .blend file is the blue print.
Blender is the construction office that created the blue prints.

When you modify the blue prints while you are driving the car the car will not change. You will need to create a new car from the modified blue prints.

So you stop the car you are sitting in. Then you let the factory create a new car and start that one.

Back to the BGE: You stop your game session and start a new one. Then you see the modifications.


Rotate view around a vertex in object mode

Nope, not when using "Rotate Around Selection." You can kind of get close with Auto Depth, but you have to watch the mouse location whenever you start to rotate the view.

I would recommend you try Auto Depth on, and Rotate Around Selection off for a bit. I personally don't like Auto Depth, but it can make it quicker to navigate when there are many objects. Just move the mouse over a object and it will rotate around that spot. Auto Depth does not have the same problem of using the object origin like Rotate Around Selection does.

With both Auto Depth and Rotate Around Selection off, the 3D view works in object mode like you desire, but you are back to manually centering the view.

There is even a warning on the linked manual page about the Rotate Around Selection setting in object mode (exactly what you are experiencing).

  This may seem ideal behavior. However, it can become problematic with larger objects such as a terrain-mesh, where the center is not necessarily your point of interest.

The way I navigate in the 3D view is to go in to edit mode select a vertex, or a piece of a model; then press NumPad . to center the view around that part and head back to object mode.
You can rotate and zoom the view as much as you like and it will stay centered around the selection from edit mode.


Change object animation become cyclic for many objects, use Python

Get fcurve array for object

fc = object.animation_data.action.fcurves

From list find fcurve want repeat (example location X)

locationX = fc.find('location', index=0)

Create modifier type CYCLES and set mode_before and mode_after become REPEAT

modifier = locationX.modifiers.new(type='CYCLES')
modifier.mode_before = 'REPEAT'
modifier.mode_after = 'REPEAT'

One problem, this method cause two repeat loops between original two keyframes, object move 1/2 time and 1/2 distance between keyframes. Need double original distance and time between key frames.


How to maintain smooth curves on meshes with lots of uneven loopcuts?

IMHO, it is hardly possible to keep that curve exactly the same as what it is after adding support loop, unless you take GiantCowFilms' second way, though it will bring new problem for subdivision. However, you can make the difference unnoticeable:

You can either do this by sliding GG or ShiftV on each side; or, select both sides, then W > Smooth, tweak levels and axes in F6 panel.


pose.bones.matrix does not update after frame change via script

To summerize, I needed to perform these changes:

for action in bpy.data.actions:
    bpy.context.object.animation_data.action = action # sets active action
    for frame in range(numberOfFrames):
        bpy.context.scene.frame_set(frame)
        bpy.context.scene.update()
        for bone in bpy.context.object.data.bones: # instead of armature.pose.bones
            poseBone = armature.pose.bones[bone.name]


FlipFluids & Ocean modifier as displacement. Baked frames in 3D view show all movements but rendered animation not. Manual keyframe ok. Any solution?

Turned out to be a bug in Blender 2.81.
The team of Blender will be fixing it:

https://developer.blender.org/T71908


There is no polygon select tool in Blender (yet) but you can hold down CTRL after your first selection and Blender will create a path to the next vertex you right click. There are some settings in the Tool panel to adjust it's behavior. If your selection path is closed you can press H to hide, which then enables you to L link select the island. ALTH and you get the whole gang. A bit of a work around but can be handy.


How is Cycles different from Blender Internal?

Cycles
Cycles is unbiased, physically based, *path tracing engine* designed for animations, which means that it produces an image by tracing the paths of "rays" through the scene.
Specifically, cycles is a "backwards" path tracer, which means that it traces light rays by sending them from the camera instead of sending them from the light source(s).
From Wikipedia:

Path tracing is a computer graphics method of rendering images of three-dimensional scenes such that the global illumination is faithful to reality. Fundamentally, the algorithm is integrating over all the illuminance arriving at a single point on the surface of an object. This illuminance is then reduced by a surface reflectance function to determine how much of it will go towards the viewpoint camera. This integration procedure is repeated for every pixel in the output image. When combined with physically accurate models of surfaces, accurate models of real light sources (light bulbs), and optically-correct cameras, path tracing can produce still images that are indistinguishable from photographs.

Path tracing naturally simulates many effects that have to be specifically added to other methods (conventional ray tracing or scanline rendering), such as soft shadows, depth of field, motion blur, caustics, ambient occlusion, and indirect lighting. Implementation of a renderer including these effects is correspondingly simpler.

Due to its accuracy and unbiased nature, path tracing is used to generate reference images when testing the quality of other rendering algorithms. In order to get high-quality images from path tracing, a large number of rays must be traced to avoid visible noisy artifacts.

To visualize this, take the following image:

The pixel the gray ray was sent from will be dark, as it did not encounter any light sources. The pixel from which the orange-ray was sent will be bright, as it hit a light source after bouncing off a diffuse object.
Most materials scatter light, so Cycles needs to account for light bouncing in different directions. How this is done depends on which Integrator is used.
Progressive Integrator
When using the Progressive integrator, this is done by taking multiple samples of the scene.
A sample refers to a single ray being sent from each pixel. For materials that scatter light, many samples are required to account for every possible angle at which a ray could be reflected/transmitted.
Branched Path Integrator
The Branched path integrator splits the ray at the first bounce.
To visualize this, take the following animation:

For more information on the mechanics of cycles, see the following questions:

What are the differences between lamps in Cycles and Blender Internal?

How are cycles lamp types different?

Why can't cycles cast one ray per image pixel, instead of rendering progressively to infinity?

Why does Cycles sampling give diminishing returns?

What is branched path tracing and how is it useful?

Spherical emitter does not illuminate very well?

Blender Internal
BI is a biased rasterization engine, which means that it works by calculating which objects are visible to the camera and not by simulating the behavior of light.
Comparison
Neither engine is necessarily "better", they both have strengths and weakness.
To visualize some of the differences between BI and Cycles, take the following example inspired by Mike Pan's shaped bokeh demonstration:

In cycles this works because cycles is actually simulating light, so you will get a result similar to what you would get in the real world:

In BI, however, this does not work because the plane is calculated as "visible", and then everything behind it is obscured:

There are many more differences between cycles and BI, such as caustics:

Cycles can render caustics, however, due to its backward path tracing nature, rendering caustics under some conditions can be hard to the point of practically impossible. There are algorithms such as Bidirectional path tracing and Metropolis Light Transport (MLT) that are good at rendering caustics, unfortunately there are no plans to implement these in cycles anytime soon.

Update: There is now a working patch for metropolis sampling, which also includes working adaptive sampling and stopping for the existing path tracing integrator. There are also plans to add lightgroups and PIS to the same patch.

BI cannot render caustics, however there is a workaround.

This does not necessarily make cycles "better", for instance, BI usually renders noiseless images while cycles must sample a scene many times to reduce the noise to an acceptable level.
Both rendering engines have different advantages, which one is best depends on what you want.
Switching Render Engines
One thing to keep in mind is that each render engine is fundamentally different and so are its settings and most importantly its material and texture definitions. As such you can't render Cycles materials in Blender internal, and the opposite is also true.
Materials designed for one render engine will mostly only work for that one render engine they were created for. You have to stick with your choice, if you created a scene for Cycles you must always render it in Cycles, and vice versa; you can't just switch at will and expect things to work. At least, not without recreating all of your materials.
Check the active render engine in the header of the Window. The currently active render engine at any moment will determine which type of materials is created when you press the + button to add a new one.


3 things that you have to keep in mind:

You have to use the Filmic Color Management
The engine emission shader must be very bright and just a bit desaturated
You have to add a Glare node in "Node Editor" > "Compositing Nodes"

For the laser beam I've made this setup

The laser beam is just an elongated "drop" with a very bright green-yellow material. I've made the beam to move rapidly forward and i've enabled the motion blur option.


How do I force a refresh after rendering animation?

You don't need to refresh anything, lighting is always up to date and recalculated per render, unless you somehow baked it into the objects.

How are you rendering this, using Cycles? Could you post some screenshots or perhaps a blender file?

Hemi lights are not supported in Cycles, they will render as point lights as stated in the Blender Manual, and in most situations you will want only one sun light in your scene, so perhaps use some area lights instead, and use the world background for ambient light.

Edit

You scene is updating real time as expected, see bellow.

Deleting lights updates the scene immediately

Some random tips

Hemi lights are like ambient lights, they emit light from a 180º dome, you generally do not want many of them in your scene. Many will cause a washed out and bland lighting that will absorb details.

Also sun lights are generally used sparingly in most scenes because they emit parallel rays of light. Try using a mix of spot lights, point lights and area lamps instead.

Edit II
Disable Compositing and Sequencer in the Properties Window > Render > Post Processing


Animating 2 Charetors at once (fight sene)

Animation is done with key frames, move both characters a set amount as desired, then apply a new key frame at the desired time line.  It is quite a bit of work so take your time to do it properly, as the timing is what counts a lot.  Use Ctrl+A, in object mode, and make sure you use "location,rotation, scale" every movement and keyframe you change (or appropriate /scale/rotation/location etc). Tutorials someone else might know? Hope this helps.


you'll have to reassign the vertices indexes using an built in function or using your own code as mentioned in the DOCs

  index_update()

Initialize the index values of this sequence.
This is the equivalent of looping over all elements and assigning the index values.

so your code should be :

bm = bmesh.from_edit_mesh(active_obj.data)
for i in range(20):
    vert = bm.verts.new((0.0, 0.0, 0.0))
    vert.index = len(bm.verts)
    print(vert.index)

or use

bm.verts.index_update()


Force Cycles GPU rendering for a Render Farm

Send it to the farm that will let you change the settings or they will change it for you. Try GarageFarm.NET as they have super friendly support working 24/7


Why does the box select tool change to the cursor tool when clicking in a blank space?

I have had the same problem, I think it's a bug, but I couldn't reproduce the steps of how to trigger it.

I just created a new scene and appended my stuff from the faulty file into it, that seemed to work as a workaround.


The bone wouldn't follow your modifications in edit-mode (unless maybe with specific constraints, which you would have to set manually).

So the bone would have to be manually adjusted (in edit-mode, not pose-mode) to follow.

Another approach would be to modify (scale for example) your bone in pose-mode. The associated parts of the mesh would follow the bone (if your vertex groups/bones associations are set up properly).

It's not easy to give you an "advice" because we don't really know what you want to do. You're only asking "If I do A, does it imply B ?". So answers are limited to yes/no.

For an advice, you should probably directly ask something like "In the context C, what are my options for doing D ?". Here we have part of C, but no real idea about D.


You need to keep the bone's scales to 1. This is not mandatory in the kind of parenting you used here for the other objects (but generally preferable).

Impact of armature scale on the rig :

If we start from a cube and a simple armature scaled Z to two :

Then parent the cube to one of the bones, the way you did it, you can see immediately that the cube is stretched (here the parenting is done by using directly the fields above the green line):

And effectively, when we rotate the bone :

Weirdly, this effect is not visible if you parent the bone this way :

And I don't know why (surely a 'keep transform' is involved in this parenting mode, but where is the data for that ? please comment if you know), as the result is now this (so apparently the same as before):

But if we move the bone again, same kind of result :

Your original file "corrected" :


How can edge rings be selected in a predictable way?

The direction is determined from the edge your mouse is over when you click.

ShiftAltRMB clicking an edge will select the face loop perpendicular to the edge clicked:


When an addon defines a panel for the toolbar it should add a property called bl_category which defines the name of the tab it will be shown in. If this property is not defined then the panel will be shown in every toolbar tab.

Current repository versions of Contours and Oscurart Tools have been updated to have their own tabs. Contours was updated in January and Oscurart Tools in February. The solution for these would be to update them.

class CGCOOKIE_OT_retopo_contour_panel(bpy.types.Panel):
    '''Retopologize Forms with Contour Strokes'''
    bl_category = "Retopology"
    bl_label = "Contour Retopolgy"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'TOOLS'

I don't know which addon Object Tools belongs to. To manually fix this edit it's source file by right-clicking on one of it's buttons and select Edit Source. Then add a bl_category property to the panel. If this addon is located within the official addons or addons_contrib then you will need to repeat this when you upgrade, if the addon still hasn't been updated. If it is an official addon or from addon_contrib them submit a bug report (include a patch?) to get it updated.


How can I test the Blender 2.8 game engine on Linux?

As far as I know, there is no work being done on 2.8's game engine at the moment (Feb 2018). Eevee is a viewport rendering engine and has not made its way to the BGE yet.

As for UPBGE, it seems there is some work being done on getting Eevee shaders to work there back in last year, but stopped.


How to animate text over a twisted mesh (or text flowing along an infinity loop)

Just adding another approach...

Create a cube at the origin, scale in edit mode, subdivide. The orientation is as shown in the blue unmodified copy, aligned to world axes.
CtrlH Assign an Empty as a Hook to all its vertices
Assign two Simple Deform modifiers, a Twist and a Bend, settings as shown.
UV unwrap as you would any other cube, and control an emission shader with a UV Texture.

Now when you rotate the Hook-Empty in Z, (which you can key with a linear interpolation to loop) the squorus will twist as in the OP's animation

Along with this, you could animate the U-mapping location of the texture in a mapping node in the shader as well, to make the text animate along the faces..
see here.


The "correct" way to do it would be to have the material to emit more than 1 in value and set the threshold so that the rest gets cut off. But I don't know your setup so here is another way to do it:

Change the color of the image to filter out other colors than blue. Feed that image into the glare node and set Mix to 1. This will create an image with only the glare. Add-mix the original image with the glare.


White background turning grey during video creation

Short answer:

Your source and your output need proper color management.

Long answer:

If your sources have already been mapped to display referred values, then set the input values to sRGB and set the color management to use sRGB as well and set the view to default.

It makes no sense to use filmic blender color transforms if you are not using scene referred values with a wide dynamic range, or if your sources are not log encoded.

As a side note: if you end up using log encoding, avoid an 8bit format for the images, it will only give you headaches and lots of quantization errors.
Please read this post: https://blender.stackexchange.com/a/46940/1853 to understand how values are mapped.


round sloped-flat Ceiling appears flat when rendering

A cube, a plane, a circle, a sphere... Can you tell them apart?

Impossible to tell with flat light. In this case the light comes from behind the camera lighting everything everything evenly.

We have no clue of the depth of the objects without a shadow. Our brain sees these as bidimensional objects...

Making the light have a clear direction helps our brain understand the shapes better:


How to drive shape keys based on the angle between two bones?

For an ultra-fast driver for corrective shape keys based on the angle between two bones, you can use this one:

The driver type is Scripted Expression, with this line (depending on your Blender version):

Blender 2.7x:

poseBones[A].matrix.col[1] * poseBones[B].matrix.col[1]

Blender 2.8x:

(Same line as above, but replace * with @)

(In order for this expression to work you need to enable the Auto Run Python Scripts setting in Blender. On 2.80 it's in Preferences -> Save & Load -> Auto Run Python Scripts and on 2.79 it's in User Preferences -> File -> Auto Run Python Scripts.)

This expression uses the dot product of the bones' aim vectors, a mechanism known as a "pose reader", used with pose space deformation (PSD).
As the bones rotate during animation or posing, the driver will output a value in the range [-1, +1], going from -1 when the bones point in opposite directions, up to 0 when they become perpendicular, up to +1 when they point in the same direction.

Replace A and B in that expression with the indices of the two bones involved. The indices are from the bones list of the armature, and the only way to find them is by using Python. But it's simple:

Select your armature object;
Change the editor to Python Console;
Type the next line in the console and hit Enter:

C.object.pose.bones.find("My Bone")

Instead of "My Bone", use the name of the bone whose index you want to find, then press Enter to see the result. Do this once for each bone so you'll have two numbers, like 12 and 103 for example. Put them in the expression (in any order), inside the poseBones brackets:

poseBones[103].matrix.col[1] * poseBones[12].matrix.col[1]

Next, the other driver variables are:

A Single Property type variable named 'poseBones', used in that expression. The ID type is set to Object, and the object itself is the armature that has the two bones involved. The actual path to the property in the object is pose.bones, write this in that field. See more details in the Notes section below.
(Blender 2.79 only, not needed for 2.80+):
A dummy Transform Channel type variable, it needs to point to any bone in that armature (any indeed, like the root bone). This variable is unused but is an essential piece, it's a way to force Blender 2.79 to evaluate the driver every time a bone in your armature moves from animation or posing.  Set the channel type and space to Location X and World Space, respectively, which makes this very fast to evaluate.
Again, this variable is not used in the expression and is only needed when on Blender 2.7x.

Your driver is ready to be used, with no roll changes or sudden flips.

Notes:

The two bones used in the expression should not be animated in scale (be it their own or inherited scale from their parents), they should only be animated in position and rotation. This means that they need to have a scale of exactly 1 in all axes, for the entire animation, otherwise this will mess with the speed of the driver because it affects the length of the matrix.col[1] vector.

If you need to animate them in scale, simply add a child bone to them and animate the scale of the child and deform the mesh with that child bone, not the parent.

You can adjust the timing and speed of this driver by playing with the driver graph curve, like using easing or bezier handles.

For example, when used with shape keys, you can make the graph minimum be zero and maximum be 1 (click to enlarge):

The natural rate of change of this driver is senoidal because of the dot product that it uses in the expression. If you happen to need linear speed, adjust the bézier handles of the curve in this way to keep the rate of change constant (click to enlarge):

The poseBones variable in the driver is referencing the .pose.bones property of the armature object (like bpy.data.objects("Armature")) and not the armature data (like bpy.data.armatures("Armature")). That .pose property exists in objects only.


Fluid: How to convert the simulation to a series of meshes?

You can get obj (wavefront) meshes in the cache directory as indicated here.

Mesh File Format (Liquids Only)
File format for the mesh cache files.

Binary Object
    Mesh data files with some compression.

Object
    Simple, standard data format for mesh data.

The settings:

Check "Mesh"
In the cache part, set the directory you want
Choose "object" as format for the meshes

Once the simulation played, if you go to the cache directory, you'll see:

and the meshes in obj format are in the "mesh" subdirectory. One per frame.
So that you can import them:


I am not aware of a direct csv importer. But of course you could write a python script for your special case. If your csv contains just object locations on a timeline, then it would be rather easy:

then you would iterate over the timeline something like this:

import bpy
context = bpy.context
obj     = context.object
scene   = context.scene

start   = scene.frame_start
end     = scene.frame_end

for frame in range(start, end+1):

    # Set object location to whatever you get from the cvs
    # here i just move the object along the x axis:
    obj.location.x=frame
    obj.keyframe_insert("location",frame=frame)

This is not a very efficient way to do an animation. The above example would be done much more efficient by just adding 2 keyframes (one at the start and one at the end) and let blender calculate the movement in between.

Also you might want to create the animation curves (fcurves) directly instead of keyframing every timeframe. But it really depends on what your csv data contains.

However, maybe the above script can help to start your journey :)


In the Multiresolution Modifier there is a way to save the mutliresolution information, but how do I import and apply the saved *.btx file?

The way I know it works is by saving displacements into one .btx file, creating another .btx file on another model and substituting the latter with the former.

Save needed sculpt and name the .btx file appropiately ("useful-sculpt.btx").
Open new file (or create another model in the same one). On another model add Multires modifier and set it to the same level of subdivision.
While this isn't necessary in order the method to work it's best to keep the same subdivision level so not to lose any details from the original sculpt.
Save sculpt of second model with Save External button to a temporary .btx file (note: do not overwrite the first one).
The step is present only to make accessible button for opening a file.
Press small folder icon next to the file name in Multires modfiier's properties of the second model to open file browser and choose there file with original sculpt ("useful-sculpt.btx").


Blender Evee volumentrics aren't working as they are supposed to

The quality of volumetrics is largely controlled by the Tile Size and the number of Samples:

To better control the definition of the volume, use a ColorRamp.


Bevel constantly regardless of face size (don't stretch bevel)

Use the Bevel modifier, scale the object and then Apply the transform using CTRL+A -> Scale.


How to bake multiple materials on a single texture

Cube has attached three separate Shaders (materials) - Pink, Green, White ...

To bake them into one texture ... add Texture node with new (empty) image and keep node selected. Do the same for other materials (like here for Pink and White). Just copy&paste node and keep selected.

In case you want bake only color pass, select Diffuse and uncheck Direct and Indirect Light.


Objects Disappear when using Cycle Engine

Please post a blend file to reproduce.
chances are your material is off , your cycles visibility is off, or something else is off.
Edit:

See that arrow thing bouncing up? that's indirect, and it says it only uses shadows if that is selected. I turned it off on Collection1 and your blend file now works.


Is there a way to fill the area between two circles?

If both circles have the same number of vertices you can use the Bridge Edge Loops (from the menu Mesh > Edge > Bridge Edge Loops, or press F3 to bring up the search menu, and start typing bridge edge loops)

It will not fill as an NGon, that is generally not desirable anyway, instead creating an even quad-based topology.


Make sure that the light is set in the correct direction.

Also, you are working in texture mode, switching to solid mode might be easier to work the model until you are ready to add a texture to it.


Texture assigned to more than one object renders differently

The object which has another appearence of the texture was scaled in Object mode, while its UV map was left as it was from the original one. Apply the transforms, redo (or change) the UV map and the texture will act in the same way on both objects.

What happens when duplicating unwrapped object

The original object was unwrapped.
Then the duplicate was created. It derived the UV map from the original object, and that UV map was the same as there.
After that the duplicate was scaled to fit the scene specifics.

The difference consists in that the duplicate was scaled in Object mode, and most likely was scaled non-uniformly (e.g. by Z axis more than by X). These transforms weren't applied to the object data. Hence the mesh was different from one unfolded in the UV map, and that's where the difference came from.

Generally, if you scale by one axis in Edit mode, you'll get non-unform texture distribution too. However you will be able to change that by unwrapping once more.

For details about the possible cases when you need applying transforms refer to Why is it important to apply transformation to an objects data?


Thanks for the youtube video. I believe the problem you are describing is this: Your model moves its arms and legs in a walk cycle, but the model does not move from the center of the grid -- there is no X or Y motion while the animation is run.

If my understanding is right, this is easy to fix: Your walk cycle animation does not include any "forward" motion in the animation. You can add this separate from the walk cycle and make them separately controlled. You could make the legs move faster (by adjusting their scale as an Action Strip, if that is how you have the walk cycle saved) and also adjust the f curve that controls forward motion (if that is what you used).... Again, there are a couple of ways to combine multiple actions...

But I think the essence of your problem is that the walk cycle itself does not include moving the model forward... (I did not download your model, as I do not recognize the download site.)

Shout if I can assist or if I misunderstood.


How to get the UV corresponding to a vertex via the Python API?

As madlaina says, A vertex doesn't have a 1:1 corraspondance with UV coordinates.

However using BMesh you can loop over a vertices connected face corners (loops), and find the UV's used by a vertex.

Heres a script that prints all vertices UV's in editmode.

Both the first-uv found (which is OK if you assume all UV's attached to a vertex will be the same).
And the mean average.

import bpy
import bmesh
from mathutils import Vector

obj = bpy.context.edit_object
me = obj.data
bm = bmesh.from_edit_mesh(me)

def uv_from_vert_first(uv_layer, v):
    for l in v.link_loops:
        uv_data = l[uv_layer]
        return uv_data.uv
    return None

def uv_from_vert_average(uv_layer, v):
    uv_average = Vector((0.0, 0.0))
    total = 0.0
    for loop in v.link_loops:
        uv_average += loop[uv_layer].uv
        total += 1.0

    if total != 0.0:
        return uv_average * (1.0 / total)
    else:
        return None

# Example using the functions above
uv_layer = bm.loops.layers.uv.active

for v in bm.verts:
    uv_first = uv_from_vert_first(uv_layer, v)
    uv_average = uv_from_vert_average(uv_layer, v)
    print("Vertex: %r, uv_first=%r, uv_average=%r" % (v, uv_first, uv_average))


Rendering with filmic log color space and saving output for use in photoshop

EXR files are always saved without the color management lut applied. They are always linear and is intended for compositing work.

To get a high bit-depth file with the LUT baked in, try saving as 32bit tiff.


Adding shiny gold material to a slice of bread

As a rough first shot:

Use a tool like Materialize to generate a pseudo-height map from
your diffuse image of the bread
Having UV unwrapped your slice you can use the height map to bump-map the surface of the slice using a simple set of shader nodes something like this...

Here, if the height is less than a threshold, a fully transparent material is substituted for the gold, so as to poke  holes in the bread. You might feel you need actually to displace the surface of the slice in shading, too, if your shot is close-up, or at a raking angle.

Once you've provided an HDR environment to reflect from the metal surface, you get this sort of result.

As for the metal itself, you could substitute this principled shader for something more sophisticated: from approximating physically accurate to quite convincing.


I had the same problem, yet not with scripting, but with my blend file moving to another computer, and I didn't take saved images with me.

Go to UV/Image editor, press N to bring up the properties panel, and in image tab change source to "Generated". You can change the resolution there as well if you need to.

As for scripting, you probably need to do

bpy.data.images["your_bake_texture"].source = 'GENERATED'

I haven't tried it myself, but I suppose it is what you need, that's what the info panel shows when I change source. It works from console at least.

EDIT1: a quick script to reinitialize all images in all materials in the active object, provided you have selected the image texture nodes in all materials (you need to do this to bake your textures anyway):

import bpy

for slot in bpy.context.active_object.material_slots:

    mat = slot.material

    imag = mat.node_tree.nodes.active.image

    imag.source = 'GENERATED'


How can I make a hole in this mesh and not mess it up?

This looks like a good candidate for Bezier curve objects.

It looks like you modeled you "blade" as a mesh object, there is nothing inherently wrong with it, but what you are trying to achieve may be a lot eaiser to do with Bezier Curve objects

They describe mathematical curves controlled by handles, instead of vertex, edges, and faces like meshes.

Since you don't have to actively worry about topology or "filling" in the faces they are very easy to use for opening holes like you want.

They will however require that you start to model from scratch using a diferent object.

Have in mind that they may not be useful depending on what you intend to use your object for later. If you plan on doing heavy texturing work involving unwrapping your mesh, shape animations, rigging, or plan to export this into a game engine; the topology produced by Bezier Curve Objects may not be adequate.

Otherwise you may also do this using meshes. Whether using Booleans (not recommended) or manually modelling it, but it will require lots of work and good understanding of proper topology.


Can I "Set Active Object as Camera" without also forcing the 3D view to change position? (Blender 2.82a)

There's no need to look through a camera to make it active.
Simply click the green camera icon and go View > Align View > Align Active camera to view.

The shortcut Ctrl + Numpad 0 automatically looks through active camera, which isn't what you want here.


Blender rigging join two ik-chain in one system

Problem solved with 3 ik-chains, finished file attached
https://blend-exchange.com/b/8MybezWq


Set a modified mesh (with shape keys) as default mesh

Set all the values on all the shape keys to 1, or to whatever you want in your final object.  Click on the down arrow (see pic), then on New Shape from Mix (see pic)

Highlight, one at a time, all the shape keys (including the Basis) and click on the "minus" sign on the right hand side (just above that down arrow.)  You'll be left with only one shape key.  You can export that and it can be imported as the end result you have just exported, without shape keys.


How can I create an irregular, marble-tiles surface?

I achieved the brick fade/like effect, as well as some irregularities in the scale of the bricks, the node setup is below the test image

You can use this add-on as well to create more complex brick textures: https://blenderartists.org/t/cycles-brick-tricks-0-1/685934


How to render only a section of the screen?

The VSE Video Sequence Editor and Compositor can offset and clip images already created. These techniques can be animated.
They can clip one image sequence and write those out to another set of files, another image sequence .
Of course you can change the camera location to create a whole new set of images.

In case you want to see part of a render without changing the camera the User can use this technique. This seems likely for testing purposes only, yet that is your choice.  This technique saves time because part of the image will be solid or transparent and no further calculation. Above has mentioned that image sequences can be offset and clipped.

The image resolution is << not changed >>.

View Menu

Render Border

Control-B

Choose the Camera View first. Then keystroke and draw rectangle like box select. Test Render.

I will leave you to explore and search more.
You may be able to do that faster than my time allows me to write a lot of words


just use this setup for your object. (i assume your are using cycles)
blue is your object color, on the orange bsdf you can change the alpha to change the shadow darkness.


(Blend file below)

The emitter is just a section of a standard UV sphere.
Particles are launched evenly from it's faces so the pattern is radial.

The emitter is placed inside 2 solidified but invisible cones that are setup as "collision objects" (physics) so they effectively focus/deflect particles.

If any escape in your version, try increasing the "Particles --> Physics --> Subframe" slider, but be mindful that each increment will labour your computer further.
In this example, (Blender Vers 2.77) the default particle settings were used throughout, apart from the emitter and draw size. (in Display tab)
With this arrangement, force fields or other coersions aren't necessary.  The number and size of the particles plus the renderer used will determine how dense it looks.
-=============-
The circular 'Nav-handle' is a common parent that holds it all together for when the emitter is to be animated,


Started sculpting before I should've, how can I add a mirror modifier again (without messing things up)?

You'll need to align the central vertices to the object origin:

Set the 3D cursor to the origin (⇧ ShiftS > Cursor to Selected while in object mode)
Switch to edit mode (↹ Tab) and select the central verts
Set the pivot point to the 3D cursor (.)
Scale them to 0 along the mirror axis. e.g. for mirroring along the X axis, press SX0


My model looks fine in blender but does not render all faces in Unity

The model is only loosely connected, and the top face is completely separate from the rest of the model. You can see for yourself by selecting the object's faces in Editor mode and dragging them away:

Since the faces aren't properly joined together, Blender is unable to recalculate the normals because it can't find any edges joining faces that are pointing in opposite directions.

You can fix this very easily. First select the entire mesh in editor mode and apply Remove Doubles. Then recalculate the normals again.


Clear "glass" bottle loses clearness in front of colored background

I have had this issue before. I am guessing the problem is with light paths in render settings.  If you don't have enough bounces, then having multiple transparent materials stacked behind one another will cause the darkening.

I'm pretty sure all I had to do was increase my minimum light bounces and it was fixed.  Good luck!

Edit: Minimum light bounces for transparency is the one you want to increase


You have set a Clipping Border - probably by pressing Alt+B. Simply press that same key combination again to clear it or go to the View menu and select Clipping Border.


How can I push down an action with only modifiers

Already found the solution:
Bake the curve - because, at least in this case, the modifier replaces it, but the Editor won't grumble about no data being present